code: 
  
  
  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  _lowerCamelCase(			lowercase__     ,				lowercase__     ,				lowercase__     ,				lowercase__     ,				lowercase__			)		->			str:
  
  		'''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  _lowerCamelCase(			lowercase__     ,				lowercase__     ,				lowercase__			)		->			int:
  
  		'''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  _lowerCamelCase(			lowercase__     ,				lowercase__			)		->			Optional[Any]:
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		__lowercase=    path.split('.'			)
  		return reduce(lowercase__     ,				lowercase__     ,				lowercase__			)
  
  
  
  
  
  
  
  def  _lowerCamelCase(			lowercase__     ,				lowercase__     ,				lowercase__     ,				lowercase__			)		->			Optional[Any]:
  
  		'''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  _lowerCamelCase(			lowercase__     ,				lowercase__     ,				lowercase__     ,				lowercase__			)		->			Tuple:
  
  		'''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  _lowerCamelCase(			lowercase__     ,				lowercase__     ,				lowercase__     ,				lowercase__			)		->			Union[str, Any]:
  
  		'''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  _lowerCamelCase(			lowercase__     ,				lowercase__     ,				lowercase__=None     ,				lowercase__=None     ,				lowercase__=True			)		->			Any:
  
  		'''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=    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
  	)
  
  
  
  
  
  
  
style_context: 
  
  
  def  _lowerCamelCase(			lowercase__			)		->			str:
  
  		'''simple docstring'''
  
  
  
  
  
  
  
  		return " ".join([word[::-1] for word in input_str.split()]			)
  
  
  if __name__ == "__main__":
  	import doctest
  
  	doctest.testmod()
  
  
  
  
  
  
  