



# Copyright (c) 2021-, NVIDIA CORPORATION.  All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

####################################################################################################

#
# Note: If when running this conversion script you're getting an exception:
#     ModuleNotFoundError: No module named 'megatron.model.enums'
# you need to tell python where to find the clone of Megatron-LM, e.g.:
#
# cd /tmp
# git clone https://github.com/NVIDIA/Megatron-LM
# PYTHONPATH=/tmp/Megatron-LM python src/transformers/models/megatron_bert/convert_megatron_bert_checkpoint.py ...
#
# if you already have it cloned elsewhere, simply adjust the path to the existing path
#
# If the training was done using a Megatron-LM fork, e.g.,
# https://github.com/microsoft/Megatron-DeepSpeed/ then chances are that you need to have that one
# in your path, i.e., /path/to/Megatron-DeepSpeed/
#

import argparse
import os
import re
import zipfile

import torch

from transformers import MegatronBertConfig







def 							A     (						__UpperCAmelCase				,   __UpperCAmelCase				,   __UpperCAmelCase=0      )			->			Optional[int]:



						'''simple docstring'''






						if name is None:
												UpperCAmelCase_					=	None
						else:
												UpperCAmelCase_					=	'''.''' * max(0				,   spaces - 2      ) + '''# {:''' + str(50 - spaces      ) + '''s}'''
												UpperCAmelCase_					=	fmt.format(_lowercase      )

						# Print and recurse (if needed).
						if isinstance(_lowercase				,   _lowercase      ):
												if msg is not None:
																		print(_lowercase      )
												for k in val.keys():
																		recursive_print(_lowercase				,   val[k]				,   spaces + 2      )
						elif isinstance(_lowercase				,   torch.Tensor      ):
												print(_lowercase				,   ''':'''				,   val.size()      )
						else:
												print(_lowercase				,   ''':'''				,   _lowercase      )







def 							A     (						__UpperCAmelCase				,   __UpperCAmelCase				,   __UpperCAmelCase				,   __UpperCAmelCase				,   __UpperCAmelCase      )			->			List[str]:



						'''simple docstring'''






						UpperCAmelCase_					=	param.size()
						if checkpoint_version == 1.0:
												# version 1.0 stores [num_heads * hidden_size * num_splits, :]
												UpperCAmelCase_					=	(num_heads, hidden_size, num_splits) + input_shape[1:]
												UpperCAmelCase_					=	param.view(*_lowercase      )
												UpperCAmelCase_					=	param.transpose(0				,   2      )
												UpperCAmelCase_					=	param.transpose(1				,   2      ).contiguous()
						elif checkpoint_version >= 2.0:
												# other versions store [num_heads * num_splits * hidden_size, :]
												UpperCAmelCase_					=	(num_heads, num_splits, hidden_size) + input_shape[1:]
												UpperCAmelCase_					=	param.view(*_lowercase      )
												UpperCAmelCase_					=	param.transpose(0				,   1      ).contiguous()
						UpperCAmelCase_					=	param.view(*_lowercase      )
						return param







def 							A     (						__UpperCAmelCase				,   __UpperCAmelCase				,   __UpperCAmelCase      )			->			List[str]:



						'''simple docstring'''






						UpperCAmelCase_					=	{}

						# old versions did not store training args
						UpperCAmelCase_					=	input_state_dict.get('''args'''				,   _lowercase      )
						if ds_args is not None:
												# do not make the user write a config file when the exact dimensions/sizes are already in the checkpoint
												# from pprint import pprint
												# pprint(vars(ds_args))

												UpperCAmelCase_					=	ds_args.tokenizer_type
												UpperCAmelCase_					=	ds_args.padded_vocab_size
												UpperCAmelCase_					=	ds_args.max_position_embeddings
												UpperCAmelCase_					=	ds_args.hidden_size
												UpperCAmelCase_					=	ds_args.num_layers
												UpperCAmelCase_					=	ds_args.num_attention_heads
												UpperCAmelCase_					=	ds_args.ffn_hidden_size if '''ffn_hidden_size''' in ds_args else 4 * ds_args.hidden_size
												# pprint(config)

						# The number of heads.
						UpperCAmelCase_					=	config.num_attention_heads
						# The hidden_size per head.
						UpperCAmelCase_					=	config.hidden_size // heads
						# Megatron-LM checkpoint version
						if "checkpoint_version" in input_state_dict.keys():
												UpperCAmelCase_					=	input_state_dict['''checkpoint_version''']
						else:
												UpperCAmelCase_					=	0.0

						# The model.
						UpperCAmelCase_					=	input_state_dict['''model''']
						# The language model.
						UpperCAmelCase_					=	model['''language_model''']
						# The embeddings.
						UpperCAmelCase_					=	lm['''embedding''']

						# The word embeddings.
						UpperCAmelCase_					=	embeddings['''word_embeddings''']['''weight''']
						# Truncate the embedding table to vocab_size rows.
						UpperCAmelCase_					=	word_embeddings[: config.vocab_size, :]
						# Store the word embeddings.
						UpperCAmelCase_					=	word_embeddings

						# The position embeddings.
						UpperCAmelCase_					=	embeddings['''position_embeddings''']['''weight''']
						assert pos_embeddings.size(0      ) == config.max_position_embeddings and pos_embeddings.size(1      ) == config.hidden_size
						# Store the position embeddings.
						UpperCAmelCase_					=	pos_embeddings

						# The token-type embeddings.
						UpperCAmelCase_					=	embeddings['''tokentype_embeddings''']['''weight''']
						# Store the position embeddings.
						UpperCAmelCase_					=	tokentype_embeddings

						# The transformer.
						UpperCAmelCase_					=	lm['''transformer'''] if '''transformer''' in lm.keys() else lm['''encoder''']

						# The regex to extract layer names.
						UpperCAmelCase_					=	re.compile(r'''layers\.(\d+)\.([a-z0-9_.]+)\.([a-z]+)'''      )

						# The simple map of names for "automated" rules.
						UpperCAmelCase_					=	{
						    '''attention.dense''': '''.attention.output.dense.''',
						    '''self_attention.dense''': '''.attention.output.dense.''',
						    '''mlp.dense_h_to_4h''': '''.intermediate.dense.''',
						    '''mlp.dense_4h_to_h''': '''.output.dense.''',
						}

						# Keep track of the attention/query/value tensor.
						UpperCAmelCase_					=	None

						# Extract the layers.
						for key, val in transformer.items():
												# Match the name.
												UpperCAmelCase_					=	layer_re.match(_lowercase      )

												# Stop if that's not a layer
												if m is None:
																		break

												# The index of the layer.
												UpperCAmelCase_					=	int(m.group(1      )      )
												# The name of the operation.
												UpperCAmelCase_					=	m.group(2      )
												# Is it a weight or a bias?
												UpperCAmelCase_					=	m.group(3      )

												# The name of the layer.
												UpperCAmelCase_					=	f"bert.encoder.layer.{layer_idx}"

												# For layernorm(s), simply store the layer norm.
												if op_name.endswith('''layernorm'''      ):
																		UpperCAmelCase_					=	'''attention.ln''' if op_name.startswith('''input'''      ) else '''ln'''
																		UpperCAmelCase_					=	val

												# Transpose the QKV matrix.
												elif (
												    op_name == "attention.query_key_value" or op_name == "self_attention.query_key_value"
												) and weight_or_bias == "weight":
																		# Make sure the QKV pointer is nil.
																		assert attention_qkv_weight is None, ""

																		UpperCAmelCase_					=	fix_query_key_value_ordering(_lowercase				,   _lowercase				,   3				,   _lowercase				,   _lowercase      )
																		# Store the tensor as we need the bias as well to interleave QKV and biases.
																		UpperCAmelCase_					=	out_val

												# Transpose the bias.
												elif (
												    op_name == "attention.query_key_value" or op_name == "self_attention.query_key_value"
												) and weight_or_bias == "bias":
																		# Make sure we read the weight tensor.
																		assert attention_qkv_weight is not None, ""

																		# Split the QKV matrix into Q, K and V. Megatron stores Q,K,V interleaved.
																		UpperCAmelCase_					=	attention_qkv_weight[0 * config.hidden_size : 1 * config.hidden_size, :]
																		UpperCAmelCase_					=	attention_qkv_weight[1 * config.hidden_size : 2 * config.hidden_size, :]
																		UpperCAmelCase_					=	attention_qkv_weight[2 * config.hidden_size : 3 * config.hidden_size, :]

																		UpperCAmelCase_					=	fix_query_key_value_ordering(_lowercase				,   _lowercase				,   3				,   _lowercase				,   _lowercase      )
																		# Split the bias.
																		UpperCAmelCase_					=	out_val[0 * config.hidden_size : 1 * config.hidden_size]
																		UpperCAmelCase_					=	out_val[1 * config.hidden_size : 2 * config.hidden_size]
																		UpperCAmelCase_					=	out_val[2 * config.hidden_size : 3 * config.hidden_size]

																		# Store.
																		UpperCAmelCase_					=	q
																		UpperCAmelCase_					=	q_bias
																		UpperCAmelCase_					=	k
																		UpperCAmelCase_					=	k_bias
																		UpperCAmelCase_					=	v
																		UpperCAmelCase_					=	v_bias

																		# Clear the stored tensor.
																		UpperCAmelCase_					=	None

												# Copy weights and biases as is.
												elif weight_or_bias in ["weight", "bias"]:
																		UpperCAmelCase_					=	megatron_to_transformers[op_name]
																		UpperCAmelCase_					=	val

    # The final layernorm.
						UpperCAmelCase_					=	transformer['''final_layernorm.weight''']
						UpperCAmelCase_					=	transformer['''final_layernorm.bias''']

						# The pooler.
						UpperCAmelCase_					=	lm['''pooler''']

						# Store the matrix and the bias.
						UpperCAmelCase_					=	pooler['''dense.weight''']
						UpperCAmelCase_					=	pooler['''dense.bias''']

						# The LM head from Megatron (for RACE).
						UpperCAmelCase_					=	model['''lm_head''']

						# The transform matrix.
						UpperCAmelCase_					=	lm_head['''dense.weight''']
						UpperCAmelCase_					=	lm_head['''dense.bias''']

						# The transform LN.
						UpperCAmelCase_					=	lm_head['''layernorm.weight''']
						UpperCAmelCase_					=	lm_head['''layernorm.bias''']

						# For the decoder, we replicate the weights.
						UpperCAmelCase_					=	word_embeddings
						UpperCAmelCase_					=	lm_head['''bias''']

						# The classifier from Megatron (for MLNI).
						UpperCAmelCase_					=	model['''binary_head''']

						# Store the classifier.
						UpperCAmelCase_					=	binary_head['''weight''']
						UpperCAmelCase_					=	binary_head['''bias''']

						# It should be done!
						return output_state_dict







def 							A     (						)			->			List[str]:



						'''simple docstring'''






						UpperCAmelCase_					=	argparse.ArgumentParser()
						parser.add_argument('''--print-checkpoint-structure'''				,   action='''store_true'''      )
						parser.add_argument('''path_to_checkpoint'''				,   type=_lowercase				,   help='''Path to the ZIP file containing the checkpoint'''      )
						parser.add_argument(
						    '''--config_file'''				,   default=''''''				,   type=_lowercase				,   help='''An optional config json file describing the pre-trained model.'''				,   )
						UpperCAmelCase_					=	parser.parse_args()

						# Extract the basename.
						UpperCAmelCase_					=	os.path.dirname(args.path_to_checkpoint      )

						# Load the model.
						# the .zip is very optional, let's keep it for backward compatibility
						print(f"Extracting PyTorch state dictionary from \"{args.path_to_checkpoint}\""      )
						if args.path_to_checkpoint.endswith('''.zip'''      ):
												with zipfile.ZipFile(args.path_to_checkpoint				,   '''r'''      ) as checkpoint:
																		with checkpoint.open('''release/mp_rank_00/model_optim_rng.pt'''      ) as pytorch_dict:
																								UpperCAmelCase_					=	torch.load(_lowercase				,   map_location='''cpu'''      )
						else:
												UpperCAmelCase_					=	torch.load(args.path_to_checkpoint				,   map_location='''cpu'''      )

						if args.config_file == "":
												# Default config of megatron-bert 345m
												UpperCAmelCase_					=	MegatronBertConfig()

												# different megatron-bert-*-345m models have different vocab sizes, so override the default
												# config (which is for megatron-bert-cased-345m) with the actual vocab dimension
												UpperCAmelCase_					=	input_state_dict['''model''']['''lm_head''']['''bias'''].numel()
						else:
												UpperCAmelCase_					=	MegatronBertConfig.from_json_file(args.config_file      )

						# Convert.
						print('''Converting'''      )
						UpperCAmelCase_					=	convert_megatron_checkpoint(_lowercase				,   _lowercase				,   _lowercase      )

						# Print the structure of converted state dict.
						if args.print_checkpoint_structure:
												recursive_print(_lowercase				,   _lowercase      )

						# Store the config to file.
						print('''Saving config'''      )
						config.save_pretrained(_lowercase      )

						# Store the state_dict to file.
						UpperCAmelCase_					=	os.path.join(_lowercase				,   '''pytorch_model.bin'''      )
						print(f"Saving checkpoint to \"{output_checkpoint_file}\""      )
						torch.save(_lowercase				,   _lowercase      )


####################################################################################################

if __name__ == "__main__":
							main()

####################################################################################################













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
   )
