






"""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
					)








"""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()
