




import argparse
import json
import os

import fairseq
import torch
from fairseq.data import Dictionary

from transformers import (
    UniSpeechConfig,
    UniSpeechForCTC,
    UniSpeechForPreTraining,
    WavaVecaFeatureExtractor,
    WavaVecaPhonemeCTCTokenizer,
    WavaVecaProcessor,
    logging,
)


logging.set_verbosity_info()
a													=			logging.get_logger(__name__)

a													=			{
    "post_extract_proj": "feature_projection.projection",
    "encoder.pos_conv.0": "encoder.pos_conv_embed.conv",
    "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",
    "quantizer.weight_proj": "quantizer.weight_proj",
    "quantizer.vars": "quantizer.codevectors",
    "project_q": "project_q",
    "final_proj": "project_hid",
    "w2v_encoder.proj": "ctc_proj",
    "mask_emb": "masked_spec_embed",
}
a													=			[
    "ctc_proj",
    "quantizer.weight_proj",
    "quantizer.codevectors",
    "project_q",
    "project_hid",
]




def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case			,     snake_case			,     snake_case			,     snake_case			,     snake_case       )						->				List[str]:
						for attribute in key.split("""."""       ):
												if is_finetuned:
																		if attribute in ["quantizer", "project_q", "project_hid"]:
																								# those layers are only relevant for pretraining and should be dropped
																								return

																		if attribute == "ctc_proj":
																								# we should rename `ctc_proj` to `lm_head` for fine-tuned phoneme models
																								_UpperCAmelCase      =			"""lm_head"""

												_UpperCAmelCase      =			getattr(snake_case			,     snake_case       )

						if weight_type is not None:
												_UpperCAmelCase      =			getattr(snake_case			,     snake_case       ).shape
						else:
												_UpperCAmelCase      =			hf_pointer.shape

						assert hf_shape == value.shape, (
						    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        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case			,     snake_case       )						->				Optional[int]:
						_UpperCAmelCase      =			[]
						_UpperCAmelCase      =			fairseq_model.state_dict()

						_UpperCAmelCase      =			hf_model.unispeech.feature_extractor

						for name, value in fairseq_dict.items():
												_UpperCAmelCase      =			False
												if "conv_layers" in name:
																		load_conv_layer(
																		    snake_case			,     snake_case			,     snake_case			,     snake_case			,     hf_model.config.feat_extract_norm == """group"""			,     )
																		_UpperCAmelCase      =			True
												else:
																		for key, mapped_key in MAPPING.items():
																								_UpperCAmelCase      =			"""unispeech.""" + 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(snake_case       )[0].split("""."""       )[-2]
																																				_UpperCAmelCase      =			mapped_key.replace("""*"""			,     snake_case       )
																														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(snake_case			,     snake_case			,     snake_case			,     snake_case			,     snake_case			,     snake_case       )
																								continue
												if not is_used:
																		unused_weights.append(snake_case       )

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




def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case			,     snake_case			,     snake_case			,     snake_case       )						->				List[str]:
						_UpperCAmelCase      =			full_name.split("""conv_layers."""       )[-1]
						_UpperCAmelCase      =			name.split("""."""       )
						_UpperCAmelCase      =			int(items[0]       )
						_UpperCAmelCase      =			int(items[1]       )

						if type_id == 0:
												if "bias" in name:
																		assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
																		    f"{full_name} has size {value.shape}, but"
																		    f" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."
																		)
																		_UpperCAmelCase      =			value
																		logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}."       )
												elif "weight" in name:
																		assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
																		    f"{full_name} has size {value.shape}, but"
																		    f" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."
																		)
																		_UpperCAmelCase      =			value
																		logger.info(f"Feat extract conv layer {layer_id} was initialized from {full_name}."       )
						elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
												if "bias" in name:
																		assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
																		    f"{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was"
																		    " found."
																		)
																		_UpperCAmelCase      =			value
																		logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."       )
												elif "weight" in name:
																		assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
																		    f"{full_name} has size {value.shape}, but"
																		    f" {feature_extractor[layer_id].layer_norm.weight.data.shape} was found."
																		)
																		_UpperCAmelCase      =			value
																		logger.info(f"Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."       )
						else:
												unused_weights.append(snake_case       )




@torch.no_grad()
def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case			,     snake_case=None			,     snake_case=None			,     snake_case=True       )						->				Optional[int]:
						if config_path is not None:
												_UpperCAmelCase      =			UniSpeechConfig.from_pretrained(snake_case       )
						else:
												_UpperCAmelCase      =			UniSpeechConfig()

						if is_finetuned:
												if dict_path:
																		_UpperCAmelCase      =			Dictionary.load_from_json(snake_case       )

																		# important change bos & pad token id since CTC symbol is <pad> and
																		# not <s> as in fairseq
																		_UpperCAmelCase      =			target_dict.pad_index
																		_UpperCAmelCase      =			target_dict.bos_index
																		_UpperCAmelCase      =			target_dict.eos_index
																		_UpperCAmelCase      =			len(target_dict.symbols       )
																		_UpperCAmelCase      =			os.path.join(snake_case			,     """vocab.json"""       )
																		if not os.path.isdir(snake_case       ):
																								logger.error("""--pytorch_dump_folder_path ({}) should be a directory""".format(snake_case       )       )
																								return
																		os.makedirs(snake_case			,     exist_ok=snake_case       )
																		_UpperCAmelCase      =			target_dict.indices

																		# fairseq has the <pad> and <s> switched
																		_UpperCAmelCase      =			4_2
																		_UpperCAmelCase      =			4_3
																		with open(snake_case			,     """w"""			,     encoding="""utf-8"""       ) as vocab_handle:
																								json.dump(snake_case			,     snake_case       )
																		_UpperCAmelCase      =			WavaVecaPhonemeCTCTokenizer(
																		    snake_case			,     unk_token=target_dict.unk_word			,     pad_token=target_dict.pad_word			,     bos_token=target_dict.bos_word			,     eos_token=target_dict.eos_word			,     word_delimiter_token="""|"""			,     do_lower_case=snake_case			,     )
																		_UpperCAmelCase      =			True if config.feat_extract_norm == """layer""" else False
																		_UpperCAmelCase      =			WavaVecaFeatureExtractor(
																		    feature_size=1			,     sampling_rate=1_6_0_0_0			,     padding_value=0			,     do_normalize=snake_case			,     return_attention_mask=snake_case			,     )
																		_UpperCAmelCase      =			WavaVecaProcessor(feature_extractor=snake_case			,     tokenizer=snake_case       )
																		processor.save_pretrained(snake_case       )

												_UpperCAmelCase      =			UniSpeechForCTC(snake_case       )
						else:
												_UpperCAmelCase      =			UniSpeechForPreTraining(snake_case       )

						if is_finetuned:
												_UpperCAmelCase    ,					_UpperCAmelCase    ,					_UpperCAmelCase      =			fairseq.checkpoint_utils.load_model_ensemble_and_task(
												    [checkpoint_path]			,     arg_overrides={"""data""": """/""".join(dict_path.split("""/"""       )[:-1]       ), """w2v_path""": checkpoint_path}       )
						else:
												_UpperCAmelCase    ,					_UpperCAmelCase    ,					_UpperCAmelCase      =			fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path]       )

						_UpperCAmelCase      =			model[0].eval()

						recursively_load_weights(snake_case			,     snake_case			,     snake_case       )

						hf_unispeech.save_pretrained(snake_case       )


if __name__ == "__main__":
				a													=			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"
				)
				a													=			parser.parse_args()
				convert_unispeech_checkpoint(
				    args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
				)





from __future__ import annotations




def        _SCREAMING_SNAKE_CASE      (		snake_case			,     snake_case       )						->				float:
						_UpperCAmelCase      =			sorted(numsa + numsa       )
						_UpperCAmelCase    ,					_UpperCAmelCase      =			divmod(len(snake_case       )			,     2       )
						if mod == 1:
												return all_numbers[div]
						else:
												return (all_numbers[div] + all_numbers[div - 1]) / 2


if __name__ == "__main__":
				import doctest

				doctest.testmod()
				a													=			[float(x) for x in input("Enter the elements of first array: ").split()]
				a													=			[float(x) for x in input("Enter the elements of second array: ").split()]
				print(F'The median of two arrays is: {median_of_two_arrays(array_a, array_a)}')