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()
  lowercase__      =				logging.get_logger(__name__)
  
  lowercase__      =				{
      """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""",
  }
  lowercase__      =				[
      """lm_head""",
  ]
  
  def 	__lowerCamelCase			(						__UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase )		->					Union[str, Any]:
  
  		"""simple docstring"""
  
  
  
  
  
  
  
  		for attribute in key.split("." ):
  				lowerCAmelCase_     :							Any             =    getattr(__UpperCamelCase   , __UpperCamelCase )
  
  		if weight_type is not None:
  				lowerCAmelCase_     :							Optional[Any]             =    getattr(__UpperCamelCase   , __UpperCamelCase ).shape
  		else:
  				lowerCAmelCase_     :							Optional[Any]             =    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_     :							int             =    value
  		elif weight_type == "weight_g":
  				lowerCAmelCase_     :							int             =    value
  		elif weight_type == "weight_v":
  				lowerCAmelCase_     :							str             =    value
  		elif weight_type == "bias":
  				lowerCAmelCase_     :							List[str]             =    value
  		else:
  				lowerCAmelCase_     :							Any             =    value
  
  		logger.info(f'''{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.''' )
  
  def 	__lowerCamelCase			(						__UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase )		->					List[str]:
  
  		"""simple docstring"""
  
  
  
  
  
  
  
  		lowerCAmelCase_     :							str             =    []
  		lowerCAmelCase_     :							Optional[int]             =    fairseq_model.state_dict()
  
  		if not is_headless:
  				lowerCAmelCase_     :							Any             =    hf_model.dataavec_audio.feature_extractor
  				lowerCAmelCase_     :							str             =    hf_model.dataavec_audio.encoder.pos_conv_embed
  
  		else:
  				lowerCAmelCase_     :							List[Any]             =    hf_model.feature_extractor
  				lowerCAmelCase_     :							Any             =    hf_model.encoder.pos_conv_embed
  
  		for name, value in fairseq_dict.items():
  				lowerCAmelCase_     :							List[Any]             =    False
  				if "conv_layers" in name:
  						load_conv_layer(
  						    __UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase   , )
  						lowerCAmelCase_     :							Union[str, Any]             =    True
  				elif "pos_conv" in name:
  						load_pos_conv_layer(
  						    __UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase   , )
  						lowerCAmelCase_     :							Optional[int]             =    True
  				else:
  						for key, mapped_key in MAPPING.items():
  								if not is_headless:
  										lowerCAmelCase_     :							List[str]             =    "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_     :							Any             =    True
  										if "*" in mapped_key:
  												lowerCAmelCase_     :							List[str]             =    name.split(__UpperCamelCase )[0].split("." )[-2]
  												lowerCAmelCase_     :							Optional[int]             =    mapped_key.replace("*"   , __UpperCamelCase )
  										if "weight_g" in name:
  												lowerCAmelCase_     :							List[str]             =    "weight_g"
  										elif "weight_v" in name:
  												lowerCAmelCase_     :							List[Any]             =    "weight_v"
  										elif "bias" in name:
  												lowerCAmelCase_     :							int             =    "bias"
  										elif "weight" in name:
  												# TODO: don't match quantizer.weight_proj
  												lowerCAmelCase_     :							Union[str, Any]             =    "weight"
  										else:
  												lowerCAmelCase_     :							Tuple             =    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 	__lowerCamelCase			(						__UpperCamelCase   , __UpperCamelCase )		->					List[Any]:
  
  		"""simple docstring"""
  
  
  
  
  
  
  
  		lowerCAmelCase_     :							Dict             =    path.split("." )
  		return reduce(__UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase )
  
  def 	__lowerCamelCase			(						__UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase )		->					Dict:
  
  		"""simple docstring"""
  
  
  
  
  
  
  
  		lowerCAmelCase_     :							Tuple             =    access_by_string(__UpperCamelCase   , __UpperCamelCase )
  		lowerCAmelCase_     :							Union[str, Any]             =    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_     :							Optional[int]             =    fsq_value
  		logger.info(f'''{full_name} was correctly initialized from {hf_weight_path}.''' )
  
  def 	__lowerCamelCase			(						__UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase )		->					int:
  
  		"""simple docstring"""
  
  
  
  
  
  
  
  		lowerCAmelCase_     :							Optional[Any]             =    full_name.split("conv_layers." )[-1]
  		lowerCAmelCase_     :							Tuple             =    name.split("." )
  		lowerCAmelCase_     :							Any             =    int(items[0] )
  		lowerCAmelCase_     :							List[Any]             =    int(items[1] )
  
  		lowerCAmelCase_     :							Tuple             =    name.split("." )[-1]
  		if type_id == 0:
  				lowerCAmelCase_     :							List[str]             =    "conv"
  		elif type_id == 2:
  				lowerCAmelCase_     :							Dict             =    "layer_norm"
  		else:
  				unused_weights.append(__UpperCamelCase )
  				return
  
  		set_weights(__UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase   , f'''conv_layers.{layer_id}.{layer_type}.{weight_type}''' )
  
  def 	__lowerCamelCase			(						__UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase )		->					List[Any]:
  
  		"""simple docstring"""
  
  
  
  
  
  
  
  		lowerCAmelCase_     :							Any             =    full_name.split("pos_conv." )[-1]
  		lowerCAmelCase_     :							str             =    name.split("." )
  		lowerCAmelCase_     :							Tuple             =    int(items[0] )
  		lowerCAmelCase_     :							List[str]             =    int(items[1] )
  
  		lowerCAmelCase_     :							List[str]             =    name.split("." )[-1]
  		if type_id != 0:
  				unused_weights.append(__UpperCamelCase )
  				return
  		else:
  				lowerCAmelCase_     :							List[str]             =    "conv"
  
  		set_weights(__UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase   , f'''layers.{layer_id}.{layer_type}.{weight_type}''' )
  
  @torch.no_grad()
  def 	__lowerCamelCase			(						__UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase=None   , __UpperCamelCase=None   , __UpperCamelCase=True )		->					str:
  
  		"""simple docstring"""
  
  
  
  
  
  
  
  		if config_path is not None:
  				lowerCAmelCase_     :							Optional[Any]             =    DataaVecAudioConfig.from_pretrained(__UpperCamelCase )
  		else:
  				lowerCAmelCase_     :							Optional[int]             =    DataaVecAudioConfig()
  
  		if not is_finetuned:
  				# Modify final_proj layer name
  				lowerCAmelCase_     :							Any             =    DataaVecAudioModel(__UpperCamelCase )
  				lowerCAmelCase_     :							Any             =    os.path.dirname(__UpperCamelCase )
  
  				lowerCAmelCase_     :							Union[str, Any]             =    torch.load(__UpperCamelCase )
  				lowerCAmelCase_     :							Dict             =    state_dict["model"].pop("final_proj.0.weight" )
  				lowerCAmelCase_     :							Optional[Any]             =    state_dict["model"].pop("final_proj.0.bias" )
  				lowerCAmelCase_     :							List[str]             =    os.path.join(__UpperCamelCase   , "converted.pt" )
  				torch.save(__UpperCamelCase   , __UpperCamelCase )
  		else:
  				lowerCAmelCase_     :							Union[str, Any]             =    DataaVecAudioForCTC(__UpperCamelCase )
  				lowerCAmelCase_     :							Optional[int]             =    checkpoint_path
  
  		def load_dataavec(__UpperCamelCase ):
  				lowerCAmelCase_       ,			lowerCAmelCase_       ,			lowerCAmelCase_     :							Optional[int]             =    fairseq.checkpoint_utils.load_model_ensemble_and_task([path] )
  				return model[0].eval()
  
  		lowerCAmelCase_     :							Tuple             =    load_dataavec(__UpperCamelCase )
  
  		recursively_load_weights(__UpperCamelCase   , __UpperCamelCase   , not is_finetuned )
  
  		lowerCAmelCase_     :							Optional[Any]             =    WavaVecaProcessor.from_pretrained("facebook/wav2vec2-large-lv60" )
  
  		lowerCAmelCase_     :							Optional[int]             =    load_dataset("patrickvonplaten/librispeech_asr_dummy"   , "clean"   , split="validation" )
  		lowerCAmelCase_     :							Optional[int]             =    [x["array"] for x in ds[:4]["audio"]]
  
  		lowerCAmelCase_     :							List[Any]             =    processor(__UpperCamelCase   , return_tensors="pt"   , padding=__UpperCamelCase )
  
  		lowerCAmelCase_     :							Tuple             =    inputs.input_values
  		lowerCAmelCase_     :							Optional[Any]             =    inputs.attention_mask
  		#    input_values = inputs.input_values[:, :-1]
  		#    attention_mask = inputs.attention_mask[:, :-1]
  
  		hf_wavavec.eval()
  		model.eval()
  		if is_finetuned:
  				lowerCAmelCase_     :							Union[str, Any]             =    model(source=__UpperCamelCase   , padding_mask=(1 - attention_mask)   , mask=__UpperCamelCase   , features_only=__UpperCamelCase )[
  				    "encoder_out"
  				].transpose(0   , 1 )
  				lowerCAmelCase_     :							Any             =    hf_wavavec(__UpperCamelCase   , attention_mask=__UpperCamelCase )["logits"]
  
  				lowerCAmelCase_     :							Dict             =    torch.argmax(__UpperCamelCase   , dim=-1 )
  				lowerCAmelCase_     :							List[Any]             =    processor.batch_decode(__UpperCamelCase )
  
  				print(f'''Expected Output: {ds[:4]["text"]}, Pred: {output_string}''' )
  		else:
  				lowerCAmelCase_     :							str             =    model(source=__UpperCamelCase   , padding_mask=(1 - attention_mask)   , mask=__UpperCamelCase   , features_only=__UpperCamelCase )[
  				    "layer_results"
  				][-1][0].transpose(0   , 1 )
  				lowerCAmelCase_     :							Optional[Any]             =    hf_wavavec(__UpperCamelCase   , attention_mask=__UpperCamelCase )["last_hidden_state"]
  
  		print(our_output.shape   , their_output.shape )
  		lowerCAmelCase_     :							Any             =    torch.max(torch.abs(our_output - their_output ) ).item()
  		print(f'''max_absolute_diff = {max_absolute_diff}''' )  # ~ 1e-7
  		lowerCAmelCase_     :							Optional[Any]             =    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__":
  					lowercase__      =				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"""
  					)
  					lowercase__      =				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: 
  
  
  
  
  
  
  """simple docstring"""
  
  from __future__ import annotations
  
  from PIL import Image
  
  # Define the first generation of cells
  # fmt: off
  lowercase__      =				[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
  
  def 	__lowerCamelCase			(						__UpperCamelCase )		->					list[int]:
  
  		"""simple docstring"""
  
  
  
  
  
  
  
  		return [int(__UpperCamelCase ) for c in f'''{ruleset:08}'''[:8]]
  
  def 	__lowerCamelCase			(						__UpperCamelCase   , __UpperCamelCase   , __UpperCamelCase )		->					list[int]:
  
  		"""simple docstring"""
  
  
  
  
  
  
  
  		lowerCAmelCase_     :							int             =    len(cells[0] )  # 31
  		lowerCAmelCase_     :							List[Any]             =    []
  		for i in range(__UpperCamelCase ):
  				# Get the neighbors of each cell
  				# Handle neighbours outside bounds by using 0 as their value
  				lowerCAmelCase_     :							List[str]             =    0 if i == 0 else cells[time][i - 1]
  				lowerCAmelCase_     :							Optional[int]             =    0 if i == population - 1 else cells[time][i + 1]
  				# Define a new cell and add it to the new generation
  				lowerCAmelCase_     :							List[Any]             =    7 - int(f'''{left_neighbor}{cells[time][i]}{right_neighbor}'''   , 2 )
  				next_generation.append(rule[situation] )
  		return next_generation
  
  def 	__lowerCamelCase			(						__UpperCamelCase )		->					Image.Image:
  
  		"""simple docstring"""
  
  
  
  
  
  
  
  		lowerCAmelCase_     :							List[str]             =    Image.new("RGB"   , (len(cells[0] ), len(__UpperCamelCase )) )
  		lowerCAmelCase_     :							List[str]             =    img.load()
  		# Generates image
  		for w in range(img.width ):
  				for h in range(img.height ):
  						lowerCAmelCase_     :							Union[str, Any]             =    255 - int(255 * cells[h][w] )
  						lowerCAmelCase_     :							List[str]             =    (color, color, color)
  		return img
  
  
  if __name__ == "__main__":
  					lowercase__      =				bin(int(input("""Rule:\n""").strip()))[2:]
  					lowercase__      =				format_ruleset(int(rule_num))
  					for time in range(16):
  										CELLS.append(new_generation(CELLS, rule, time))
  					lowercase__      =				generate_image(CELLS)
  					# Uncomment to save the image
  					# img.save(f"rule_{rule_num}.png")
  					img.show()
  