code: 
  
  
  '''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()
  UpperCAmelCase      :						Optional[Any]    =		logging.get_logger(__name__)
  
  UpperCAmelCase      :						int    =		{
      '''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''',
  }
  UpperCAmelCase      :						Any    =		[
      '''lm_head''',
  ]
  
  
  
  
  
  
  def   __lowerCamelCase	(       lowerCamelCase__		:	Optional[int]     ,       lowerCamelCase__		:	Any     ,       lowerCamelCase__		:	Tuple     ,       lowerCamelCase__		:	Tuple     ,       lowerCamelCase__		:	int			):
  
  
  
  
  
  			'''simple docstring'''
  
  
  
  
  			for attribute in key.split("""."""			):
  						lowerCamelCase								=     getattr(lowerCamelCase__     ,       lowerCamelCase__			)
  
  			if weight_type is not None:
  						lowerCamelCase								=     getattr(lowerCamelCase__     ,       lowerCamelCase__			).shape
  			else:
  						lowerCamelCase								=     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":
  						lowerCamelCase								=     value
  			elif weight_type == "weight_g":
  						lowerCamelCase								=     value
  			elif weight_type == "weight_v":
  						lowerCamelCase								=     value
  			elif weight_type == "bias":
  						lowerCamelCase								=     value
  			else:
  						lowerCamelCase								=     value
  
  			logger.info(f'{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.'			)
  
  
  
  
  
  
  def   __lowerCamelCase	(       lowerCamelCase__		:	Optional[int]     ,       lowerCamelCase__		:	Optional[Any]     ,       lowerCamelCase__		:	List[str]			):
  
  
  
  
  
  			'''simple docstring'''
  
  
  
  
  			lowerCamelCase								=     []
  			lowerCamelCase								=     fairseq_model.state_dict()
  
  			if not is_headless:
  						lowerCamelCase								=     hf_model.dataavec_audio.feature_extractor
  						lowerCamelCase								=     hf_model.dataavec_audio.encoder.pos_conv_embed
  
  			else:
  						lowerCamelCase								=     hf_model.feature_extractor
  						lowerCamelCase								=     hf_model.encoder.pos_conv_embed
  
  			for name, value in fairseq_dict.items():
  						lowerCamelCase								=     False
  						if "conv_layers" in name:
  									load_conv_layer(
  									    lowerCamelCase__     ,       lowerCamelCase__     ,       lowerCamelCase__     ,       lowerCamelCase__     ,       )
  									lowerCamelCase								=     True
  						elif "pos_conv" in name:
  									load_pos_conv_layer(
  									    lowerCamelCase__     ,       lowerCamelCase__     ,       lowerCamelCase__     ,       lowerCamelCase__     ,       )
  									lowerCamelCase								=     True
  						else:
  									for key, mapped_key in MAPPING.items():
  												if not is_headless:
  															lowerCamelCase								=     '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]:
  															lowerCamelCase								=     True
  															if "*" in mapped_key:
  																		lowerCamelCase								=     name.split(lowerCamelCase__			)[0].split("""."""			)[-2]
  																		lowerCamelCase								=     mapped_key.replace("""*"""     ,       lowerCamelCase__			)
  															if "weight_g" in name:
  																		lowerCamelCase								=     'weight_g'
  															elif "weight_v" in name:
  																		lowerCamelCase								=     'weight_v'
  															elif "bias" in name:
  																		lowerCamelCase								=     'bias'
  															elif "weight" in name:
  																		# TODO: don't match quantizer.weight_proj
  																		lowerCamelCase								=     'weight'
  															else:
  																		lowerCamelCase								=     None
  															set_recursively(lowerCamelCase__     ,       lowerCamelCase__     ,       lowerCamelCase__     ,       lowerCamelCase__     ,       lowerCamelCase__			)
  												continue
  						if not is_used:
  									unused_weights.append(lowerCamelCase__			)
  
  			logger.warning(f'Unused weights: {unused_weights}'			)
  
  
  
  
  
  
  def   __lowerCamelCase	(       lowerCamelCase__		:	Union[str, Any]     ,       lowerCamelCase__		:	Tuple			):
  
  
  
  
  
  			'''simple docstring'''
  
  
  
  
  			lowerCamelCase								=     path.split("""."""			)
  			return reduce(lowerCamelCase__     ,       lowerCamelCase__     ,       lowerCamelCase__			)
  
  
  
  
  
  
  def   __lowerCamelCase	(       lowerCamelCase__		:	List[Any]     ,       lowerCamelCase__		:	int     ,       lowerCamelCase__		:	str     ,       lowerCamelCase__		:	str			):
  
  
  
  
  
  			'''simple docstring'''
  
  
  
  
  			lowerCamelCase								=     access_by_string(lowerCamelCase__     ,       lowerCamelCase__			)
  			lowerCamelCase								=     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.'			)
  			lowerCamelCase								=     fsq_value
  			logger.info(f'{full_name} was correctly initialized from {hf_weight_path}.'			)
  
  
  
  
  
  
  def   __lowerCamelCase	(       lowerCamelCase__		:	str     ,       lowerCamelCase__		:	str     ,       lowerCamelCase__		:	str     ,       lowerCamelCase__		:	List[Any]			):
  
  
  
  
  
  			'''simple docstring'''
  
  
  
  
  			lowerCamelCase								=     full_name.split("""conv_layers."""			)[-1]
  			lowerCamelCase								=     name.split("""."""			)
  			lowerCamelCase								=     int(items[0]			)
  			lowerCamelCase								=     int(items[1]			)
  
  			lowerCamelCase								=     name.split("""."""			)[-1]
  			if type_id == 0:
  						lowerCamelCase								=     'conv'
  			elif type_id == 2:
  						lowerCamelCase								=     'layer_norm'
  			else:
  						unused_weights.append(lowerCamelCase__			)
  						return
  
  			set_weights(lowerCamelCase__     ,       lowerCamelCase__     ,       lowerCamelCase__     ,       f'conv_layers.{layer_id}.{layer_type}.{weight_type}'			)
  
  
  
  
  
  
  def   __lowerCamelCase	(       lowerCamelCase__		:	Union[str, Any]     ,       lowerCamelCase__		:	Dict     ,       lowerCamelCase__		:	str     ,       lowerCamelCase__		:	Union[str, Any]			):
  
  
  
  
  
  			'''simple docstring'''
  
  
  
  
  			lowerCamelCase								=     full_name.split("""pos_conv."""			)[-1]
  			lowerCamelCase								=     name.split("""."""			)
  			lowerCamelCase								=     int(items[0]			)
  			lowerCamelCase								=     int(items[1]			)
  
  			lowerCamelCase								=     name.split("""."""			)[-1]
  			if type_id != 0:
  						unused_weights.append(lowerCamelCase__			)
  						return
  			else:
  						lowerCamelCase								=     'conv'
  
  			set_weights(lowerCamelCase__     ,       lowerCamelCase__     ,       lowerCamelCase__     ,       f'layers.{layer_id}.{layer_type}.{weight_type}'			)
  
  
  
  
  
  
  @torch.no_grad()
  def   __lowerCamelCase	(       lowerCamelCase__		:	List[Any]     ,       lowerCamelCase__		:	Union[str, Any]     ,       lowerCamelCase__		:	Optional[Any]=None     ,       lowerCamelCase__		:	List[str]=None     ,       lowerCamelCase__		:	str=True			):
  
  
  
  
  
  			'''simple docstring'''
  
  
  
  
  			if config_path is not None:
  						lowerCamelCase								=     DataaVecAudioConfig.from_pretrained(lowerCamelCase__			)
  			else:
  						lowerCamelCase								=     DataaVecAudioConfig()
  
  			if not is_finetuned:
  						# Modify final_proj layer name
  						lowerCamelCase								=     DataaVecAudioModel(lowerCamelCase__			)
  						lowerCamelCase								=     os.path.dirname(lowerCamelCase__			)
  
  						lowerCamelCase								=     torch.load(lowerCamelCase__			)
  						lowerCamelCase								=     state_dict['model'].pop("""final_proj.0.weight"""			)
  						lowerCamelCase								=     state_dict['model'].pop("""final_proj.0.bias"""			)
  						lowerCamelCase								=     os.path.join(lowerCamelCase__     ,       """converted.pt"""			)
  						torch.save(lowerCamelCase__     ,       lowerCamelCase__			)
  			else:
  						lowerCamelCase								=     DataaVecAudioForCTC(lowerCamelCase__			)
  						lowerCamelCase								=     checkpoint_path
  
  			def load_dataavec(lowerCamelCase__		:	str			):
  						lowerCamelCase								=     fairseq.checkpoint_utils.load_model_ensemble_and_task([path]			)
  						return model[0].eval()
  
  			lowerCamelCase								=     load_dataavec(lowerCamelCase__			)
  
  			recursively_load_weights(lowerCamelCase__     ,       lowerCamelCase__     ,       not is_finetuned			)
  
  			lowerCamelCase								=     WavaVecaProcessor.from_pretrained("""facebook/wav2vec2-large-lv60"""			)
  
  			lowerCamelCase								=     load_dataset("""patrickvonplaten/librispeech_asr_dummy"""     ,       """clean"""     ,       split="""validation"""			)
  			lowerCamelCase								=     [x['array'] for x in ds[:4]['audio']]
  
  			lowerCamelCase								=     processor(lowerCamelCase__     ,       return_tensors="""pt"""     ,       padding=lowerCamelCase__			)
  
  			lowerCamelCase								=     inputs.input_values
  			lowerCamelCase								=     inputs.attention_mask
  			#    input_values = inputs.input_values[:, :-1]
  			#    attention_mask = inputs.attention_mask[:, :-1]
  
  			hf_wavavec.eval()
  			model.eval()
  			if is_finetuned:
  						lowerCamelCase								=     model(source=lowerCamelCase__     ,       padding_mask=(1 - attention_mask)     ,       mask=lowerCamelCase__     ,       features_only=lowerCamelCase__			)[
  						    'encoder_out'
  						].transpose(0     ,       1			)
  						lowerCamelCase								=     hf_wavavec(lowerCamelCase__     ,       attention_mask=lowerCamelCase__			)['logits']
  
  						lowerCamelCase								=     torch.argmax(lowerCamelCase__     ,       dim=-1			)
  						lowerCamelCase								=     processor.batch_decode(lowerCamelCase__			)
  
  						print(f'Expected Output: {ds[:4]["text"]}, Pred: {output_string}'			)
  			else:
  						lowerCamelCase								=     model(source=lowerCamelCase__     ,       padding_mask=(1 - attention_mask)     ,       mask=lowerCamelCase__     ,       features_only=lowerCamelCase__			)[
  						    'layer_results'
  						][-1][0].transpose(0     ,       1			)
  						lowerCamelCase								=     hf_wavavec(lowerCamelCase__     ,       attention_mask=lowerCamelCase__			)['last_hidden_state']
  
  			print(our_output.shape     ,       their_output.shape			)
  			lowerCamelCase								=     torch.max(torch.abs(our_output - their_output			)			).item()
  			print(f'max_absolute_diff = {max_absolute_diff}'			)  # ~ 1e-7
  			lowerCamelCase								=     torch.allclose(lowerCamelCase__     ,       lowerCamelCase__     ,       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(lowerCamelCase__			)
  
  			if is_finetuned:
  						processor.save_pretrained(lowerCamelCase__			)
  			else:
  						processor.feature_extractor.save_pretrained(lowerCamelCase__			)
  
  
  if __name__ == "__main__":
  		UpperCAmelCase      :						Dict    =		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"
  		)
  		UpperCAmelCase      :						List[str]    =		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: 
  
  
  import math
  
  import qiskit
  from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute
  
  
  
  
  
  
  def   __lowerCamelCase	(       lowerCamelCase__		:	int = 1     ,       lowerCamelCase__		:	int = 1			):
  
  
  
  
  
  			'''simple docstring'''
  
  
  
  
  			if isinstance(lowerCamelCase__     ,       lowerCamelCase__			) or isinstance(lowerCamelCase__     ,       lowerCamelCase__			):
  						raise TypeError("""inputs must be integers."""			)
  			if (bit_a < 0) or (bit_a < 0):
  						raise ValueError("""inputs must be positive."""			)
  			if (math.floor(lowerCamelCase__			) != bit_a) or (math.floor(lowerCamelCase__			) != bit_a):
  						raise ValueError("""inputs must be exact integers."""			)
  			if (bit_a > 1) or (bit_a > 1):
  						raise ValueError("""inputs must be less or equal to 1."""			)
  
  			# build registers
  			lowerCamelCase								=     QuantumRegister(2     ,       """qr"""			)
  			lowerCamelCase								=     ClassicalRegister(2     ,       """cr"""			)
  
  			lowerCamelCase								=     QuantumCircuit(lowerCamelCase__     ,       lowerCamelCase__			)
  
  			# entanglement the qubits
  			quantum_circuit.h(1			)
  			quantum_circuit.cx(1     ,       0			)
  
  			# send the information
  			lowerCamelCase								=     str(lowerCamelCase__			) + str(lowerCamelCase__			)
  
  			if c_information == "11":
  						quantum_circuit.x(1			)
  						quantum_circuit.z(1			)
  			elif c_information == "10":
  						quantum_circuit.z(1			)
  			elif c_information == "01":
  						quantum_circuit.x(1			)
  			else:
  						quantum_circuit.i(1			)
  
  			# unentangled the circuit
  			quantum_circuit.cx(1     ,       0			)
  			quantum_circuit.h(1			)
  
  			# measure the circuit
  			quantum_circuit.measure(lowerCamelCase__     ,       lowerCamelCase__			)
  
  			lowerCamelCase								=     Aer.get_backend("""aer_simulator"""			)
  			lowerCamelCase								=     execute(lowerCamelCase__     ,       lowerCamelCase__     ,       shots=1000			)
  
  			return job.result().get_counts(lowerCamelCase__			)
  
  
  if __name__ == "__main__":
  		print(f"""Counts for classical state send: {superdense_coding(1,1)}""")
  
  