





'''simple docstring'''



import argparse
import json
import os
import re
from collections import OrderedDict
from dataclasses import dataclass, field
from functools import partial
from pathlib import Path
from pprint import pprint
from typing import Dict, List, Tuple

import torch
import torch.nn as nn
from classy_vision.models.regnet import RegNet, RegNetParams
from huggingface_hub import cached_download, hf_hub_url
from torch import Tensor
from vissl.models.model_helpers import get_trunk_forward_outputs

from transformers import AutoImageProcessor, RegNetConfig, RegNetForImageClassification, RegNetModel
from transformers.modeling_utils import PreTrainedModel
from transformers.utils import logging


logging.set_verbosity_info()
snake_case_   :  Optional[int]								=      logging.get_logger()

@dataclass
class     A_ :

			'''simple docstring'''





			_lowerCAmelCase						=    42
			_lowerCAmelCase						=    field(default_factory=lowerCAmelCase_  )
			_lowerCAmelCase						=    field(default_factory=lowerCAmelCase_  )
			_lowerCAmelCase						=    field(default_factory=lowerCAmelCase_  )




			def       a	(					self			,     A_			,     A_			,     A_			,     A_   ):
								_UpperCamelCase											=   len(list(m.modules()   )   ) == 1 or isinstance(A_			,     nn.Convad   ) or isinstance(A_			,     nn.BatchNormad   )
								if has_not_submodules:
													self.traced.append(A_   )
													_UpperCamelCase											=   m




			def __call__(					self			,     A_   ):
								for name, m in self.module.named_modules():
													self.handles.append(m.register_forward_hook(partial(self._forward_hook			,     name=A_   )   )   )
								self.module(A_   )
								[x.remove() for x in self.handles]
								return self




			@property
			def       a	(					self   ):
								# check the len of the state_dict keys to see if we have learnable params
								return {k: v for k, v in self.nameamodule.items() if len(list(v.state_dict().keys()   )   ) > 0}




class     A_ (  nn.Module  ):

			'''simple docstring'''





			def __init__(					self			,     A_   ):
								super().__init__()

								_UpperCamelCase											=   []
								# - get the stem
								feature_blocks.append(("conv1", model.stem)   )
								# - get all the feature blocks
								for k, v in model.trunk_output.named_children():
													assert k.startswith("block"   ), F"Unexpected layer name {k}"
													_UpperCamelCase											=   len(A_   ) + 1
													feature_blocks.append((F"res{block_index}", v)   )

								_UpperCamelCase											=   nn.ModuleDict(A_   )




			def       a	(					self			,     A_   ):
								return get_trunk_forward_outputs(
								    A_			,     out_feat_keys=A_			,     feature_blocks=self._feature_blocks			,     )




class     A_ (  lowerCAmelCase_  ):

			'''simple docstring'''





			def       a	(					self   ):
								return [(8, 2, 2, 8, 1.0), (8, 2, 7, 8, 1.0), (8, 2, 17, 8, 1.0), (8, 2, 1, 8, 1.0)]




def  lowercase__(		_UpperCamelCase  : str				)->   Dict[str, str]:






					"""simple docstring"""

					_UpperCamelCase											=   RegNetConfig(depths=[2, 7, 17, 1] ,   hidden_sizes=[8, 8, 8, 8] ,   groups_width=8				)
					if "in1k" in model_name:
										_UpperCamelCase											=   RegNetForImageClassification(_UpperCamelCase				)
					else:
										_UpperCamelCase											=   RegNetModel(_UpperCamelCase				)
					# create from model (with small weights)
					_UpperCamelCase											=   FakeRegNetVisslWrapper(
					    RegNet(FakeRegNetParams(depth=27 ,   group_width=1010 ,   w_a=1744 ,   w_a=620.83 ,   w_m=2.52				)				)				)

					with torch.no_grad():
										_UpperCamelCase											=   from_model.eval()
										_UpperCamelCase											=   our_model.eval()

										_UpperCamelCase											=   torch.randn((1, 3, 32, 32)				)
										# trace both
										_UpperCamelCase											=   Tracker(_UpperCamelCase				)
										_UpperCamelCase											=   dest_tracker(_UpperCamelCase				).parametrized

										pprint(dest_tracker.nameamodule				)
										_UpperCamelCase											=   Tracker(_UpperCamelCase				)
										_UpperCamelCase											=   src_tracker(_UpperCamelCase				).parametrized

					# convert the keys -> module dict to keys -> params
					def to_params_dict(_UpperCamelCase  : str				):
										_UpperCamelCase											=   OrderedDict()
										for name, module in dict_with_modules.items():
															for param_name, param in module.state_dict().items():
																				_UpperCamelCase											=   param
										return params_dict

					_UpperCamelCase											=   {}

					_UpperCamelCase											=   to_params_dict(_UpperCamelCase				)
					_UpperCamelCase											=   to_params_dict(_UpperCamelCase				)

					for (src_key, src_param), (dest_key, dest_param) in zip(src_state_dict.items() ,   dst_state_dict.items()				):
										_UpperCamelCase											=   dest_key
										logger.info(f"{src_key} -> {dest_key}"				)
					# if "in1k" was in the model_name it means it must have a classification head (was finetuned)
					if "in1k" in model_name:
										_UpperCamelCase											=   "classifier.1.weight"
										_UpperCamelCase											=   "classifier.1.bias"

					return from_to_ours_keys



def  lowercase__(		_UpperCamelCase  : Path ,   _UpperCamelCase  : str = None ,   _UpperCamelCase  : bool = True				)->   Optional[Any]:






					"""simple docstring"""

					_UpperCamelCase											=   "imagenet-1k-id2label.json"
					_UpperCamelCase											=   1000

					_UpperCamelCase											=   "huggingface/label-files"
					_UpperCamelCase											=   num_labels
					_UpperCamelCase											=   json.load(open(cached_download(hf_hub_url(_UpperCamelCase ,   _UpperCamelCase ,   repo_type="dataset"				)				) ,   "r"				)				)
					_UpperCamelCase											=   {int(_UpperCamelCase				): v for k, v in idalabel.items()}

					_UpperCamelCase											=   idalabel
					_UpperCamelCase											=   {v: k for k, v in idalabel.items()}

					_UpperCamelCase											=   partial(_UpperCamelCase ,   num_labels=_UpperCamelCase ,   idalabel=_UpperCamelCase ,   labelaid=_UpperCamelCase				)

					_UpperCamelCase											=   {
					    "regnet-y-10b-seer": ImageNetPreTrainedConfig(
					        depths=[2, 7, 17, 1] ,   hidden_sizes=[2020, 4040, 11110, 28280] ,   groups_width=1010				),
					    # finetuned on imagenet
					    "regnet-y-10b-seer-in1k": ImageNetPreTrainedConfig(
					        depths=[2, 7, 17, 1] ,   hidden_sizes=[2020, 4040, 11110, 28280] ,   groups_width=1010				),
					}

					# add seer weights logic
					def load_using_classy_vision(_UpperCamelCase  : str				) -> Tuple[Dict, Dict]:
										_UpperCamelCase											=   torch.hub.load_state_dict_from_url(_UpperCamelCase ,   model_dir=str(_UpperCamelCase				) ,   map_location="cpu"				)
										# check if we have a head, if yes add it
										_UpperCamelCase											=   files["classy_state_dict"]["base_model"]["model"]
										return model_state_dict["trunk"], model_state_dict["heads"]

					_UpperCamelCase											=   {
					    "regnet-y-10b-seer": partial(
					        _UpperCamelCase ,   "https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_regnet10B/model_iteration124500_conso.torch" ,   ),
					    "regnet-y-10b-seer-in1k": partial(
					        _UpperCamelCase ,   "https://dl.fbaipublicfiles.com/vissl/model_zoo/seer_finetuned/seer_10b_finetuned_in1k_model_phase28_conso.torch" ,   ),
					}

					_UpperCamelCase											=   get_from_to_our_keys(_UpperCamelCase				)

					if not (save_directory / f"{model_name}.pth").exists():
										logger.info("Loading original state_dict."				)
										_UpperCamelCase				,	_UpperCamelCase											=   names_to_from_model[model_name]()
										_UpperCamelCase											=   from_state_dict_trunk
										if "in1k" in model_name:
															# add the head
															_UpperCamelCase											=   {**from_state_dict_trunk, **from_state_dict_head}
										logger.info("Done!"				)

										_UpperCamelCase											=   {}

										_UpperCamelCase											=   list(from_state_dict.keys()				)
										_UpperCamelCase											=   R"\.block.-part."
										# this is "interesting", so the original checkpoints have `block[0,1]-part` in each key name, we remove it
										for key in from_state_dict.keys():
															# remove the weird "block[0,1]-part" from the key
															_UpperCamelCase											=   re.sub(_UpperCamelCase ,   "" ,   _UpperCamelCase				)
															# now src_key from the model checkpoints is the one we got from the original model after tracing, so use it to get the correct destination key
															_UpperCamelCase											=   from_to_ours_keys[src_key]
															# store the parameter with our key
															_UpperCamelCase											=   from_state_dict[key]
															not_used_keys.remove(_UpperCamelCase				)
										# check that all keys have been updated
										assert len(_UpperCamelCase				) == 0, f"Some keys where not used {','.join(_UpperCamelCase				)}"

										logger.info(f"The following keys were not used: {','.join(_UpperCamelCase				)}"				)

										# save our state dict to disk
										torch.save(_UpperCamelCase ,   save_directory / f"{model_name}.pth"				)

										del converted_state_dict
					else:
										logger.info("The state_dict was already stored on disk."				)
					if push_to_hub:
										logger.info(f"Token is {os.environ['HF_TOKEN']}"				)
										logger.info("Loading our model."				)
										# create our model
										_UpperCamelCase											=   names_to_config[model_name]
										_UpperCamelCase											=   RegNetModel
										if "in1k" in model_name:
															_UpperCamelCase											=   RegNetForImageClassification
										_UpperCamelCase											=   our_model_func(_UpperCamelCase				)
										# place our model to the meta device (so remove all the weights)
										our_model.to(torch.device("meta"				)				)
										logger.info("Loading state_dict in our model."				)
										# load state dict
										_UpperCamelCase											=   our_model.state_dict().keys()
										PreTrainedModel._load_pretrained_model_low_mem(
										    _UpperCamelCase ,   _UpperCamelCase ,   [save_directory / f"{model_name}.pth"]				)
										logger.info("Finally, pushing!"				)
										# push it to hub
										our_model.push_to_hub(
										    repo_path_or_name=save_directory / model_name ,   commit_message="Add model" ,   output_dir=save_directory / model_name ,   )
										_UpperCamelCase											=   384
										# we can use the convnext one
										_UpperCamelCase											=   AutoImageProcessor.from_pretrained("facebook/convnext-base-224-22k-1k" ,   size=_UpperCamelCase				)
										image_processor.push_to_hub(
										    repo_path_or_name=save_directory / model_name ,   commit_message="Add image processor" ,   output_dir=save_directory / model_name ,   )


if __name__ == "__main__":
			snake_case_   :  List[str]								=      argparse.ArgumentParser()
			# Required parameters
			parser.add_argument(
			    '''--model_name''',
			    default=None,
			    type=str,
			    help=(
			        '''The name of the model you wish to convert, it must be one of the supported regnet* architecture,'''
			        ''' currently: regnetx-*, regnety-*. If `None`, all of them will the converted.'''
			    ),
			)
			parser.add_argument(
			    '''--pytorch_dump_folder_path''',
			    default=None,
			    type=Path,
			    required=True,
			    help='''Path to the output PyTorch model directory.''',
			)
			parser.add_argument(
			    '''--push_to_hub''',
			    default=True,
			    type=bool,
			    required=False,
			    help='''If True, push model and image processor to the hub.''',
			)

			snake_case_   :  Any								=      parser.parse_args()

			snake_case_   :  Path								=      args.pytorch_dump_folder_path
			pytorch_dump_folder_path.mkdir(exist_ok=True, parents=True)
			convert_weights_and_push(pytorch_dump_folder_path, args.model_name, args.push_to_hub)










'''simple docstring'''



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()
snake_case_   :  Optional[Any]								=      logging.get_logger(__name__)

snake_case_   :  Optional[Any]								=      {
    '''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''',
}
snake_case_   :  Optional[Any]								=      [
    '''lm_head''',
]



def  lowercase__(		_UpperCamelCase  : List[Any] ,   _UpperCamelCase  : Optional[Any] ,   _UpperCamelCase  : Tuple ,   _UpperCamelCase  : Tuple ,   _UpperCamelCase  : Optional[Any]				)->   Tuple:






					"""simple docstring"""

					for attribute in key.split("."				):
										_UpperCamelCase											=   getattr(_UpperCamelCase ,   _UpperCamelCase				)

					if weight_type is not None:
										_UpperCamelCase											=   getattr(_UpperCamelCase ,   _UpperCamelCase				).shape
					else:
										_UpperCamelCase											=   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":
										_UpperCamelCase											=   value
					elif weight_type == "weight_g":
										_UpperCamelCase											=   value
					elif weight_type == "weight_v":
										_UpperCamelCase											=   value
					elif weight_type == "bias":
										_UpperCamelCase											=   value
					else:
										_UpperCamelCase											=   value

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



def  lowercase__(		_UpperCamelCase  : Tuple ,   _UpperCamelCase  : Optional[Any] ,   _UpperCamelCase  : List[str]				)->   List[str]:






					"""simple docstring"""

					_UpperCamelCase											=   []
					_UpperCamelCase											=   fairseq_model.state_dict()

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

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

					for name, value in fairseq_dict.items():
										_UpperCamelCase											=   False
										if "conv_layers" in name:
															load_conv_layer(
															    _UpperCamelCase ,   _UpperCamelCase ,   _UpperCamelCase ,   _UpperCamelCase ,   )
															_UpperCamelCase											=   True
										elif "pos_conv" in name:
															load_pos_conv_layer(
															    _UpperCamelCase ,   _UpperCamelCase ,   _UpperCamelCase ,   _UpperCamelCase ,   )
															_UpperCamelCase											=   True
										else:
															for key, mapped_key in MAPPING.items():
																				if not is_headless:
																									_UpperCamelCase											=   "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]:
																									_UpperCamelCase											=   True
																									if "*" in mapped_key:
																														_UpperCamelCase											=   name.split(_UpperCamelCase				)[0].split("."				)[-2]
																														_UpperCamelCase											=   mapped_key.replace("*" ,   _UpperCamelCase				)
																									if "weight_g" in name:
																														_UpperCamelCase											=   "weight_g"
																									elif "weight_v" in name:
																														_UpperCamelCase											=   "weight_v"
																									elif "bias" in name:
																														_UpperCamelCase											=   "bias"
																									elif "weight" in name:
																														# TODO: don't match quantizer.weight_proj
																														_UpperCamelCase											=   "weight"
																									else:
																														_UpperCamelCase											=   None
																									set_recursively(_UpperCamelCase ,   _UpperCamelCase ,   _UpperCamelCase ,   _UpperCamelCase ,   _UpperCamelCase				)
																				continue
										if not is_used:
															unused_weights.append(_UpperCamelCase				)

					logger.warning(f"Unused weights: {unused_weights}"				)



def  lowercase__(		_UpperCamelCase  : List[Any] ,   _UpperCamelCase  : Tuple				)->   int:






					"""simple docstring"""

					_UpperCamelCase											=   path.split("."				)
					return reduce(_UpperCamelCase ,   _UpperCamelCase ,   _UpperCamelCase				)



def  lowercase__(		_UpperCamelCase  : str ,   _UpperCamelCase  : List[Any] ,   _UpperCamelCase  : Dict ,   _UpperCamelCase  : List[str]				)->   List[str]:






					"""simple docstring"""

					_UpperCamelCase											=   access_by_string(_UpperCamelCase ,   _UpperCamelCase				)
					_UpperCamelCase											=   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."				)
					_UpperCamelCase											=   fsq_value
					logger.info(f"{full_name} was correctly initialized from {hf_weight_path}."				)



def  lowercase__(		_UpperCamelCase  : Tuple ,   _UpperCamelCase  : Union[str, Any] ,   _UpperCamelCase  : int ,   _UpperCamelCase  : str				)->   Dict:






					"""simple docstring"""

					_UpperCamelCase											=   full_name.split("conv_layers."				)[-1]
					_UpperCamelCase											=   name.split("."				)
					_UpperCamelCase											=   int(items[0]				)
					_UpperCamelCase											=   int(items[1]				)

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

					set_weights(_UpperCamelCase ,   _UpperCamelCase ,   _UpperCamelCase ,   f"conv_layers.{layer_id}.{layer_type}.{weight_type}"				)



def  lowercase__(		_UpperCamelCase  : Union[str, Any] ,   _UpperCamelCase  : List[Any] ,   _UpperCamelCase  : Tuple ,   _UpperCamelCase  : int				)->   Dict:






					"""simple docstring"""

					_UpperCamelCase											=   full_name.split("pos_conv."				)[-1]
					_UpperCamelCase											=   name.split("."				)
					_UpperCamelCase											=   int(items[0]				)
					_UpperCamelCase											=   int(items[1]				)

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

					set_weights(_UpperCamelCase ,   _UpperCamelCase ,   _UpperCamelCase ,   f"layers.{layer_id}.{layer_type}.{weight_type}"				)



@torch.no_grad()
def  lowercase__(		_UpperCamelCase  : List[Any] ,   _UpperCamelCase  : Tuple ,   _UpperCamelCase  : Optional[Any]=None ,   _UpperCamelCase  : List[Any]=None ,   _UpperCamelCase  : Optional[Any]=True				)->   Optional[int]:






					"""simple docstring"""

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

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

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

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

					_UpperCamelCase											=   load_dataavec(_UpperCamelCase				)

					recursively_load_weights(_UpperCamelCase ,   _UpperCamelCase ,   not is_finetuned				)

					_UpperCamelCase											=   WavaVecaProcessor.from_pretrained("facebook/wav2vec2-large-lv60"				)

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

					_UpperCamelCase											=   processor(_UpperCamelCase ,   return_tensors="pt" ,   padding=_UpperCamelCase				)

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

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

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

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

					print(our_output.shape ,   their_output.shape				)
					_UpperCamelCase											=   torch.max(torch.abs(our_output - their_output				)				).item()
					print(f"max_absolute_diff = {max_absolute_diff}"				)  # ~ 1e-7
					_UpperCamelCase											=   torch.allclose(_UpperCamelCase ,   _UpperCamelCase ,   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(_UpperCamelCase				)

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


if __name__ == "__main__":
			snake_case_   :  int								=      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'''
			)
			snake_case_   :  Any								=      parser.parse_args()
			convert_wavaveca_checkpoint(
			    args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
			)



