import inspect
import unittest

from transformers import is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
      import torch

      from transformers import MODEL_MAPPING, GLPNConfig, GLPNForDepthEstimation, GLPNModel
      from transformers.models.glpn.modeling_glpn import GLPN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
      from PIL import Image

      from transformers import GLPNImageProcessor





class   lowerCAmelCase    (       lowercase_      ):



     def       a__	(       self							):
            _A=						self.config_class(**self.inputs_dict							)
            self.parent.assertTrue(hasattr(snake_case__					,   'hidden_sizes'							)							)
            self.parent.assertTrue(hasattr(snake_case__					,   'num_attention_heads'							)							)
            self.parent.assertTrue(hasattr(snake_case__					,   'num_encoder_blocks'							)							)





class   lowerCAmelCase    :



     def __init__(       self					,   lowerCAmelCase__					,   lowerCAmelCase__=13					,   lowerCAmelCase__=64					,   lowerCAmelCase__=3					,   lowerCAmelCase__=4					,   lowerCAmelCase__=[2, 2, 2, 2]					,   lowerCAmelCase__=[8, 4, 2, 1]					,   lowerCAmelCase__=[16, 32, 64, 128]					,   lowerCAmelCase__=[1, 4, 8, 16]					,   lowerCAmelCase__=[1, 2, 4, 8]					,   lowerCAmelCase__=True					,   lowerCAmelCase__=True					,   lowerCAmelCase__="gelu"					,   lowerCAmelCase__=0.1					,   lowerCAmelCase__=0.1					,   lowerCAmelCase__=0.02					,   lowerCAmelCase__=16					,   lowerCAmelCase__=3					,   lowerCAmelCase__=None					,   ):
            _A=						parent
            _A=						batch_size
            _A=						image_size
            _A=						num_channels
            _A=						num_encoder_blocks
            _A=						sr_ratios
            _A=						depths
            _A=						hidden_sizes
            _A=						downsampling_rates
            _A=						num_attention_heads
            _A=						is_training
            _A=						use_labels
            _A=						hidden_act
            _A=						hidden_dropout_prob
            _A=						attention_probs_dropout_prob
            _A=						initializer_range
            _A=						decoder_hidden_size
            _A=						num_labels
            _A=						scope



     def       a__	(       self							):
            _A=						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

            _A=						None
            if self.use_labels:
                   _A=						ids_tensor([self.batch_size, self.image_size, self.image_size]					,   self.num_labels							)

            _A=						self.get_config()
            return config, pixel_values, labels



     def       a__	(       self							):
            return GLPNConfig(
                image_size=self.image_size					,   num_channels=self.num_channels					,   num_encoder_blocks=self.num_encoder_blocks					,   depths=self.depths					,   hidden_sizes=self.hidden_sizes					,   num_attention_heads=self.num_attention_heads					,   hidden_act=self.hidden_act					,   hidden_dropout_prob=self.hidden_dropout_prob					,   attention_probs_dropout_prob=self.attention_probs_dropout_prob					,   initializer_range=self.initializer_range					,   decoder_hidden_size=self.decoder_hidden_size					,   )



     def       a__	(       self					,   lowerCAmelCase__					,   lowerCAmelCase__					,   lowerCAmelCase__							):
            _A=						GLPNModel(config=snake_case__							)
            model.to(snake_case__							)
            model.eval()
            _A=						model(snake_case__							)
            _A=						_A=						self.image_size // (self.downsampling_rates[-1] * 2)
            self.parent.assertEqual(
                result.last_hidden_state.shape					,   (self.batch_size, self.hidden_sizes[-1], expected_height, expected_width)							)



     def       a__	(       self					,   lowerCAmelCase__					,   lowerCAmelCase__					,   lowerCAmelCase__							):
            _A=						self.num_labels
            _A=						GLPNForDepthEstimation(snake_case__							)
            model.to(snake_case__							)
            model.eval()
            _A=						model(snake_case__							)
            self.parent.assertEqual(result.predicted_depth.shape					,   (self.batch_size, self.image_size, self.image_size)							)
            _A=						model(snake_case__					,   labels=snake_case__							)
            self.parent.assertEqual(result.predicted_depth.shape					,   (self.batch_size, self.image_size, self.image_size)							)





     def       a__	(       self							):
            _A=						self.prepare_config_and_inputs()
            _A,      _A,      _A=						config_and_inputs
            _A=						{'pixel_values': pixel_values}
            return config, inputs_dict





@require_torch
class   lowerCAmelCase    (       lowercase_      ,		lowercase_      ,		unittest.TestCase      ):
     _SCREAMING_SNAKE_CASE  :  List[Any]		=(GLPNModel, GLPNForDepthEstimation) if is_torch_available() else ()
     _SCREAMING_SNAKE_CASE  :  str		=(
         {"""depth-estimation""": GLPNForDepthEstimation, """feature-extraction""": GLPNModel} if is_torch_available() else {}
     )

     _SCREAMING_SNAKE_CASE  :  Optional[Any]		=False
     _SCREAMING_SNAKE_CASE  :  Union[str, Any]		=False
     _SCREAMING_SNAKE_CASE  :  Dict		=False



     def       a__	(       self							):
            _A=						GLPNModelTester(self							)
            _A=						GLPNConfigTester(self					,   config_class=snake_case__							)



     def       a__	(       self							):
            self.config_tester.run_common_tests()



     def       a__	(       self							):
            _A=						self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*snake_case__							)



     def       a__	(       self							):
            _A=						self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_depth_estimation(*snake_case__							)



     @unittest.skip('GLPN does not use inputs_embeds'							)
     def       a__	(       self							):
            pass



     @unittest.skip('GLPN does not have get_input_embeddings method and get_output_embeddings methods'							)
     def       a__	(       self							):
            pass



     def       a__	(       self							):
            _A,      _A=						self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                   _A=						model_class(snake_case__							)
                   _A=						inspect.signature(model.forward							)
                   # signature.parameters is an OrderedDict => so arg_names order is deterministic
                   _A=						[*signature.parameters.keys()]

                   _A=						['pixel_values']
                   self.assertListEqual(arg_names[:1]					,   snake_case__							)



     def       a__	(       self							):
            _A,      _A=						self.model_tester.prepare_config_and_inputs_for_common()
            _A=						True

            for model_class in self.all_model_classes:
                   _A=						True
                   _A=						False
                   _A=						True
                   _A=						model_class(snake_case__							)
                   model.to(snake_case__							)
                   model.eval()
                   with torch.no_grad():
                          _A=						model(**self._prepare_for_class(snake_case__					,   snake_case__							)							)
                   _A=						outputs.attentions

                   _A=						sum(self.model_tester.depths							)
                   self.assertEqual(len(snake_case__							)					,   snake_case__							)

                   # check that output_attentions also work using config
                   del inputs_dict["output_attentions"]
                   _A=						True
                   _A=						model_class(snake_case__							)
                   model.to(snake_case__							)
                   model.eval()
                   with torch.no_grad():
                          _A=						model(**self._prepare_for_class(snake_case__					,   snake_case__							)							)
                   _A=						outputs.attentions

                   self.assertEqual(len(snake_case__							)					,   snake_case__							)

                   # verify the first attentions (first block, first layer)
                   _A=						(self.model_tester.image_size // 4) ** 2
                   _A=						(self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2
                   self.assertListEqual(
                       list(attentions[0].shape[-3:]							)					,   [self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len]					,   )

                   # verify the last attentions (last block, last layer)
                   _A=						(self.model_tester.image_size // 32) ** 2
                   _A=						(self.model_tester.image_size // (32 * self.model_tester.sr_ratios[-1])) ** 2
                   self.assertListEqual(
                       list(attentions[-1].shape[-3:]							)					,   [self.model_tester.num_attention_heads[-1], expected_seq_len, expected_reduced_seq_len]					,   )
                   _A=						len(snake_case__							)

                   # Check attention is always last and order is fine
                   _A=						True
                   _A=						True
                   _A=						model_class(snake_case__							)
                   model.to(snake_case__							)
                   model.eval()
                   with torch.no_grad():
                          _A=						model(**self._prepare_for_class(snake_case__					,   snake_case__							)							)

                   self.assertEqual(out_len + 1					,   len(snake_case__							)							)

                   _A=						outputs.attentions

                   self.assertEqual(len(snake_case__							)					,   snake_case__							)
                   # verify the first attentions (first block, first layer)
                   _A=						(self.model_tester.image_size // 4) ** 2
                   _A=						(self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2
                   self.assertListEqual(
                       list(self_attentions[0].shape[-3:]							)					,   [self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len]					,   )



     def       a__	(       self							):



            def check_hidden_states_output(lowerCAmelCase__					,   lowerCAmelCase__					,   lowerCAmelCase__							):
                   _A=						model_class(snake_case__							)
                   model.to(snake_case__							)
                   model.eval()

                   with torch.no_grad():
                          _A=						model(**self._prepare_for_class(snake_case__					,   snake_case__							)							)

                   _A=						outputs.hidden_states

                   _A=						self.model_tester.num_encoder_blocks
                   self.assertEqual(len(snake_case__							)					,   snake_case__							)

                   # verify the first hidden states (first block)
                   self.assertListEqual(
                       list(hidden_states[0].shape[-3:]							)					,   [
                           self.model_tester.hidden_sizes[0],
                           self.model_tester.image_size // 4,
                           self.model_tester.image_size // 4,
                       ]					,   )

            _A,      _A=						self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                   _A=						True
                   check_hidden_states_output(snake_case__					,   snake_case__					,   snake_case__							)

                   # check that output_hidden_states also work using config
                   del inputs_dict["output_hidden_states"]
                   _A=						True

                   check_hidden_states_output(snake_case__					,   snake_case__					,   snake_case__							)



     def       a__	(       self							):



            if not self.model_tester.is_training:
                   return

            _A,      _A=						self.model_tester.prepare_config_and_inputs_for_common()
            _A=						True

            for model_class in self.all_model_classes:
                   if model_class in get_values(snake_case__							):
                          continue
                   # TODO: remove the following 3 lines once we have a MODEL_FOR_DEPTH_ESTIMATION_MAPPING
                   # this can then be incorporated into _prepare_for_class in test_modeling_common.py
                   if model_class.__name__ == "GLPNForDepthEstimation":
                          _A,      _A,      _A,      _A=						inputs_dict['pixel_values'].shape
                          _A=						torch.zeros(
                              [self.model_tester.batch_size, height, width]					,   device=snake_case__							).long()
                   _A=						model_class(snake_case__							)
                   model.to(snake_case__							)
                   model.train()
                   _A=						self._prepare_for_class(snake_case__					,   snake_case__					,   return_labels=snake_case__							)
                   _A=						model(**snake_case__							).loss
                   loss.backward()





     @slow
     def       a__	(       self							):



            for model_name in GLPN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   _A=						GLPNModel.from_pretrained(snake_case__							)
                   self.assertIsNotNone(snake_case__							)


def 				UpperCamelCase					(     )		->    List[Any]:




       '''simple docstring'''






       _A=						Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
       return image





@require_torch
@require_vision
@slow
class   lowerCAmelCase    (       unittest.TestCase      ):



     @slow
     def       a__	(       self							):
            _A=						GLPNImageProcessor.from_pretrained(GLPN_PRETRAINED_MODEL_ARCHIVE_LIST[0]							)
            _A=						GLPNForDepthEstimation.from_pretrained(GLPN_PRETRAINED_MODEL_ARCHIVE_LIST[0]							).to(snake_case__							)

            _A=						prepare_img()
            _A=						image_processor(images=snake_case__					,   return_tensors='pt'							).to(snake_case__							)

            # forward pass
            with torch.no_grad():
                   _A=						model(**snake_case__							)

            # verify the predicted depth
            _A=						torch.Size([1, 480, 640]							)
            self.assertEqual(outputs.predicted_depth.shape					,   snake_case__							)

            _A=						torch.tensor(
                [[3.4291, 2.7865, 2.5151], [3.2841, 2.7021, 2.3502], [3.1147, 2.4625, 2.2481]]							).to(snake_case__							)

            self.assertTrue(torch.allclose(outputs.predicted_depth[0, :3, :3]					,   snake_case__					,   atol=1E-4							)							)







import argparse
import os
from functools import reduce

import fairseq
import torch
from datasets import load_dataset

from transformers import WavaVecaProcessor, logging
from transformers.models.dataavec.configuration_dataavec_audio import DataaVecAudioConfig

# Copied from https://github.com/pytorch/fairseq/blob/main/examples/data2vec/models/data2vec_audio.py
from transformers.models.dataavec.dataavec_audio import DataaVecAudioModel as Dummy  # noqa: F401
from transformers.models.dataavec.modeling_dataavec_audio import DataaVecAudioForCTC, DataaVecAudioModel


logging.set_verbosity_info()
lowerCamelCase					    =	logging.get_logger(__name__)

lowerCamelCase					    =	{
    '''post_extract_proj''': '''feature_projection.projection''',
    '''models.0.layer_norm''': '''feature_projection.layer_norm''',
    '''self_attn.k_proj''': '''encoder.layers.*.attention.k_proj''',
    '''self_attn.v_proj''': '''encoder.layers.*.attention.v_proj''',
    '''self_attn.q_proj''': '''encoder.layers.*.attention.q_proj''',
    '''self_attn.out_proj''': '''encoder.layers.*.attention.out_proj''',
    '''self_attn_layer_norm''': '''encoder.layers.*.layer_norm''',
    '''fc1''': '''encoder.layers.*.feed_forward.intermediate_dense''',
    '''fc2''': '''encoder.layers.*.feed_forward.output_dense''',
    '''final_layer_norm''': '''encoder.layers.*.final_layer_norm''',
    '''encoder.layer_norm''': '''encoder.layer_norm''',
    '''w2v_model.layer_norm''': '''feature_projection.layer_norm''',
    '''w2v_encoder.proj''': '''lm_head''',
    '''mask_emb''': '''masked_spec_embed''',
}
lowerCamelCase					    =	[
    '''lm_head''',
]
def 							UpperCAmelCase   ( _lowercase,   _lowercase,   _lowercase,   _lowercase,   _lowercase   ):


    '''simple docstring'''



    for attribute in key.split('.'   ):
        _lowercase     			=						getattr(_lowercase,   _lowercase   )

    if weight_type is not None:
        _lowercase     			=						getattr(_lowercase,   _lowercase   ).shape
    else:
        _lowercase     			=						hf_pointer.shape

    if hf_shape != value.shape:
        raise ValueError(
            f'''Shape of hf {key + "." + weight_type if weight_type is not None else ""} is {hf_shape}, but should be'''
            f''' {value.shape} for {full_name}'''   )

    if weight_type == "weight":
        _lowercase     			=						value
    elif weight_type == "weight_g":
        _lowercase     			=						value
    elif weight_type == "weight_v":
        _lowercase     			=						value
    elif weight_type == "bias":
        _lowercase     			=						value
    else:
        _lowercase     			=						value

    logger.info(f'''{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.'''   )
def 							UpperCAmelCase   ( _lowercase,   _lowercase,   _lowercase   ):


    '''simple docstring'''



    _lowercase     			=						[]
    _lowercase     			=						fairseq_model.state_dict()

    if not is_headless:
        _lowercase     			=						hf_model.dataavec_audio.feature_extractor
        _lowercase     			=						hf_model.dataavec_audio.encoder.pos_conv_embed

    else:
        _lowercase     			=						hf_model.feature_extractor
        _lowercase     			=						hf_model.encoder.pos_conv_embed

    for name, value in fairseq_dict.items():
        _lowercase     			=						False
        if "conv_layers" in name:
            load_conv_layer(
                _lowercase,   _lowercase,   _lowercase,   _lowercase,   )
            _lowercase     			=						True
        elif "pos_conv" in name:
            load_pos_conv_layer(
                _lowercase,   _lowercase,   _lowercase,   _lowercase,   )
            _lowercase     			=						True
        else:
            for key, mapped_key in MAPPING.items():
                if not is_headless:
                    _lowercase     			=						'data2vec_audio.' + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key
                if key in name or key.split('w2v_model.'   )[-1] == name.split('.'   )[0]:
                    _lowercase     			=						True
                    if "*" in mapped_key:
                        _lowercase     			=						name.split(_lowercase   )[0].split('.'   )[-2]
                        _lowercase     			=						mapped_key.replace('*',   _lowercase   )
                    if "weight_g" in name:
                        _lowercase     			=						'weight_g'
                    elif "weight_v" in name:
                        _lowercase     			=						'weight_v'
                    elif "bias" in name:
                        _lowercase     			=						'bias'
                    elif "weight" in name:
                        # TODO: don't match quantizer.weight_proj
                        _lowercase     			=						'weight'
                    else:
                        _lowercase     			=						None
                    set_recursively(_lowercase,   _lowercase,   _lowercase,   _lowercase,   _lowercase   )
                continue
        if not is_used:
            unused_weights.append(_lowercase   )

    logger.warning(f'''Unused weights: {unused_weights}'''   )
def 							UpperCAmelCase   ( _lowercase,   _lowercase   ):


    '''simple docstring'''



    _lowercase     			=						path.split('.'   )
    return reduce(_lowercase,   _lowercase,   _lowercase   )
def 							UpperCAmelCase   ( _lowercase,   _lowercase,   _lowercase,   _lowercase   ):


    '''simple docstring'''



    _lowercase     			=						access_by_string(_lowercase,   _lowercase   )
    _lowercase     			=						hf_weight.data

    if fsq_value.shape != hf_value.shape:
        raise ValueError(f'''{full_name} has size {fsq_value.shape}, but {hf_value.shape} was found.'''   )
    _lowercase     			=						fsq_value
    logger.info(f'''{full_name} was correctly initialized from {hf_weight_path}.'''   )
def 							UpperCAmelCase   ( _lowercase,   _lowercase,   _lowercase,   _lowercase   ):


    '''simple docstring'''



    _lowercase     			=						full_name.split('conv_layers.'   )[-1]
    _lowercase     			=						name.split('.'   )
    _lowercase     			=						int(items[0]   )
    _lowercase     			=						int(items[1]   )

    _lowercase     			=						name.split('.'   )[-1]
    if type_id == 0:
        _lowercase     			=						'conv'
    elif type_id == 2:
        _lowercase     			=						'layer_norm'
    else:
        unused_weights.append(_lowercase   )
        return

    set_weights(_lowercase,   _lowercase,   _lowercase,   f'''conv_layers.{layer_id}.{layer_type}.{weight_type}'''   )
def 							UpperCAmelCase   ( _lowercase,   _lowercase,   _lowercase,   _lowercase   ):


    '''simple docstring'''



    _lowercase     			=						full_name.split('pos_conv.'   )[-1]
    _lowercase     			=						name.split('.'   )
    _lowercase     			=						int(items[0]   )
    _lowercase     			=						int(items[1]   )

    _lowercase     			=						name.split('.'   )[-1]
    if type_id != 0:
        unused_weights.append(_lowercase   )
        return
    else:
        _lowercase     			=						'conv'

    set_weights(_lowercase,   _lowercase,   _lowercase,   f'''layers.{layer_id}.{layer_type}.{weight_type}'''   )
@torch.no_grad()
def 							UpperCAmelCase   ( _lowercase,   _lowercase,   _lowercase=None,   _lowercase=None,   _lowercase=True   ):


    '''simple docstring'''



    if config_path is not None:
        _lowercase     			=						DataaVecAudioConfig.from_pretrained(_lowercase   )
    else:
        _lowercase     			=						DataaVecAudioConfig()

    if not is_finetuned:
        # Modify final_proj layer name
        _lowercase     			=						DataaVecAudioModel(_lowercase   )
        _lowercase     			=						os.path.dirname(_lowercase   )

        _lowercase     			=						torch.load(_lowercase   )
        _lowercase     			=						state_dict['model'].pop('final_proj.0.weight'   )
        _lowercase     			=						state_dict['model'].pop('final_proj.0.bias'   )
        _lowercase     			=						os.path.join(_lowercase,   'converted.pt'   )
        torch.save(_lowercase,   _lowercase   )
    else:
        _lowercase     			=						DataaVecAudioForCTC(_lowercase   )
        _lowercase     			=						checkpoint_path

    def load_dataavec(_lowercase   ):
        _lowercase			,     _lowercase			,     _lowercase     			=						fairseq.checkpoint_utils.load_model_ensemble_and_task([path]   )
        return model[0].eval()

    _lowercase     			=						load_dataavec(_lowercase   )

    recursively_load_weights(_lowercase,   _lowercase,   not is_finetuned   )

    _lowercase     			=						WavaVecaProcessor.from_pretrained('facebook/wav2vec2-large-lv60'   )

    _lowercase     			=						load_dataset('patrickvonplaten/librispeech_asr_dummy',   'clean',   split='validation'   )
    _lowercase     			=						[x['array'] for x in ds[:4]['audio']]

    _lowercase     			=						processor(_lowercase,   return_tensors='pt',   padding=_lowercase   )

    _lowercase     			=						inputs.input_values
    _lowercase     			=						inputs.attention_mask
    #    input_values = inputs.input_values[:, :-1]
    #    attention_mask = inputs.attention_mask[:, :-1]

    hf_wavavec.eval()
    model.eval()
    if is_finetuned:
        _lowercase     			=						model(source=_lowercase,   padding_mask=(1 - attention_mask),   mask=_lowercase,   features_only=_lowercase   )[
            'encoder_out'
        ].transpose(0,   1   )
        _lowercase     			=						hf_wavavec(_lowercase,   attention_mask=_lowercase   )['logits']

        _lowercase     			=						torch.argmax(_lowercase,   dim=-1   )
        _lowercase     			=						processor.batch_decode(_lowercase   )

        print(f'''Expected Output: {ds[:4]["text"]}, Pred: {output_string}'''   )
    else:
        _lowercase     			=						model(source=_lowercase,   padding_mask=(1 - attention_mask),   mask=_lowercase,   features_only=_lowercase   )[
            'layer_results'
        ][-1][0].transpose(0,   1   )
        _lowercase     			=						hf_wavavec(_lowercase,   attention_mask=_lowercase   )['last_hidden_state']

    print(our_output.shape,   their_output.shape   )
    _lowercase     			=						torch.max(torch.abs(our_output - their_output   )   ).item()
    print(f'''max_absolute_diff = {max_absolute_diff}'''   )  # ~ 1e-7
    _lowercase     			=						torch.allclose(_lowercase,   _lowercase,   atol=1e-3   )
    print('Do both models output the same tensors?',   '🔥' if success else '💩'   )
    if not success:
        raise Exception('Something went wRoNg'   )

    hf_wavavec.save_pretrained(_lowercase   )

    if is_finetuned:
        processor.save_pretrained(_lowercase   )
    else:
        processor.feature_extractor.save_pretrained(_lowercase   )


if __name__ == "__main__":
   lowerCamelCase					    =	argparse.ArgumentParser()
   parser.add_argument('''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model.''')
   parser.add_argument('''--checkpoint_path''', default=None, type=str, help='''Path to fairseq checkpoint''')
   parser.add_argument('''--dict_path''', default=None, type=str, help='''Path to dict of fine-tuned model''')
   parser.add_argument('''--config_path''', default=None, type=str, help='''Path to hf config.json of model to convert''')
   parser.add_argument(
       '''--not_finetuned''', action='''store_true''', help='''Whether the model to convert is a fine-tuned model or not'''
   )
   lowerCamelCase					    =	parser.parse_args()
   convert_wavaveca_checkpoint(
       args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
   )
