




from sklearn.metrics import fa_score, matthews_corrcoef

import datasets

from .record_evaluation import evaluate as evaluate_record


__UpperCamelCase					:       Optional[Any]    					=      "\\n@article{wang2019superglue,\n  title={SuperGLUE: A Stickier Benchmark for General-Purpose Language Understanding Systems},\n  author={Wang, Alex and Pruksachatkun, Yada and Nangia, Nikita and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R},\n  journal={arXiv preprint arXiv:1905.00537},\n  year={2019}\n}\n"

__UpperCamelCase					:       List[str]    					=      "\\nSuperGLUE (https://super.gluebenchmark.com/) is a new benchmark styled after\nGLUE with a new set of more difficult language understanding tasks, improved\nresources, and a new public leaderboard.\n"

__UpperCamelCase					:       Any    					=      "\nCompute SuperGLUE evaluation metric associated to each SuperGLUE dataset.\nArgs:\n    predictions: list of predictions to score. Depending on the SuperGlUE subset:\n        - for 'record': list of question-answer dictionaries with the following keys:\n            - 'idx': index of the question as specified by the dataset\n            - 'prediction_text': the predicted answer text\n        - for 'multirc': list of question-answer dictionaries with the following keys:\n            - 'idx': index of the question-answer pair as specified by the dataset\n            - 'prediction': the predicted answer label\n        - otherwise: list of predicted labels\n    references: list of reference labels. Depending on the SuperGLUE subset:\n        - for 'record': list of question-answers dictionaries with the following keys:\n            - 'idx': index of the question as specified by the dataset\n            - 'answers': list of possible answers\n        - otherwise: list of reference labels\nReturns: depending on the SuperGLUE subset:\n    - for 'record':\n        - 'exact_match': Exact match between answer and gold answer\n        - 'f1': F1 score\n    - for 'multirc':\n        - 'exact_match': Exact match between answer and gold answer\n        - 'f1_m': Per-question macro-F1 score\n        - 'f1_a': Average F1 score over all answers\n    - for 'axb':\n        'matthews_correlation': Matthew Correlation\n    - for 'cb':\n        - 'accuracy': Accuracy\n        - 'f1': F1 score\n    - for all others:\n        - 'accuracy': Accuracy\nExamples:\n\n    >>> super_glue_metric = datasets.load_metric('super_glue', 'copa')  # any of [\"copa\", \"rte\", \"wic\", \"wsc\", \"wsc.fixed\", \"boolq\", \"axg\"]\n    >>> predictions = [0, 1]\n    >>> references = [0, 1]\n    >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'accuracy': 1.0}\n\n    >>> super_glue_metric = datasets.load_metric('super_glue', 'cb')\n    >>> predictions = [0, 1]\n    >>> references = [0, 1]\n    >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'accuracy': 1.0, 'f1': 1.0}\n\n    >>> super_glue_metric = datasets.load_metric('super_glue', 'record')\n    >>> predictions = [{'idx': {'passage': 0, 'query': 0}, 'prediction_text': 'answer'}]\n    >>> references = [{'idx': {'passage': 0, 'query': 0}, 'answers': ['answer', 'another_answer']}]\n    >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'exact_match': 1.0, 'f1': 1.0}\n\n    >>> super_glue_metric = datasets.load_metric('super_glue', 'multirc')\n    >>> predictions = [{'idx': {'answer': 0, 'paragraph': 0, 'question': 0}, 'prediction': 0}, {'idx': {'answer': 1, 'paragraph': 2, 'question': 3}, 'prediction': 1}]\n    >>> references = [0, 1]\n    >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'exact_match': 1.0, 'f1_m': 1.0, 'f1_a': 1.0}\n\n    >>> super_glue_metric = datasets.load_metric('super_glue', 'axb')\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = super_glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'matthews_correlation': 1.0}\n"





def 		__A		(	__lowerCamelCase							,			__lowerCamelCase    )      ->       Tuple:
	return float((preds == labels).mean()    )





def 		__A		(	__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase="binary"    )      ->       str:
	a										=							simple_accuracy(__lowerCamelCase							,			__lowerCamelCase    )
	a										=							float(fa_score(y_true=__lowerCamelCase							,			y_pred=__lowerCamelCase							,			average=__lowerCamelCase    )    )
	return {
	    "accuracy": acc,
	    "f1": fa,
	}





def 		__A		(	__lowerCamelCase							,			__lowerCamelCase    )      ->       Any:
	a										=							{}
	for id_pred, label in zip(__lowerCamelCase							,			__lowerCamelCase    ):
		a										=							f'{id_pred["idx"]["paragraph"]}-{id_pred["idx"]["question"]}'
		a										=							id_pred["""prediction"""]
		if question_id in question_map:
			question_map[question_id].append((pred, label)    )
		else:
			a										=							[(pred, label)]
	a				, a										=							[], []
	for question, preds_labels in question_map.items():
		a				, a										=							zip(*__lowerCamelCase    )
		a										=							fa_score(y_true=__lowerCamelCase							,			y_pred=__lowerCamelCase							,			average="""macro"""    )
		fas.append(__lowerCamelCase    )
		a										=							int(sum(pred == label for pred, label in preds_labels    ) == len(__lowerCamelCase    )    )
		ems.append(__lowerCamelCase    )
	a										=							float(sum(__lowerCamelCase    ) / len(__lowerCamelCase    )    )
	a										=							sum(__lowerCamelCase    ) / len(__lowerCamelCase    )
	a										=							float(fa_score(y_true=__lowerCamelCase							,			y_pred=[id_pred["""prediction"""] for id_pred in ids_preds]    )    )
	return {"exact_match": em, "f1_m": fa_m, "f1_a": fa_a}



@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION      ,       _KWARGS_DESCRIPTION )
class 		__lowerCAmelCase	(	datasets.Metric ):
							def       lowerCamelCase__							(						self						:List[str]				):







								'''simple docstring'''







								if self.config_name not in [
								    "boolq",
								    "cb",
								    "copa",
								    "multirc",
								    "record",
								    "rte",
								    "wic",
								    "wsc",
								    "wsc.fixed",
								    "axb",
								    "axg",
								]:
									raise KeyError(
									    """You should supply a configuration name selected in """
									    """[\"boolq\", \"cb\", \"copa\", \"multirc\", \"record\", \"rte\", \"wic\", \"wsc\", \"wsc.fixed\", \"axb\", \"axg\",]"""				)
								return datasets.MetricInfo(
								    description=_DESCRIPTION		,      citation=_CITATION		,      inputs_description=_KWARGS_DESCRIPTION		,      features=datasets.Features(self._get_feature_types()				)		,      codebase_urls=[]		,      reference_urls=[]		,      format="""numpy""" if not self.config_name == """record""" and not self.config_name == """multirc""" else None		,      )
							def       lowerCamelCase__							(						self						:Optional[Any]				):







								'''simple docstring'''







								if self.config_name == "record":
									return {
									    "predictions": {
									        "idx": {
									            "passage": datasets.Value("""int64"""				),
									            "query": datasets.Value("""int64"""				),
									        },
									        "prediction_text": datasets.Value("""string"""				),
									    },
									    "references": {
									        "idx": {
									            "passage": datasets.Value("""int64"""				),
									            "query": datasets.Value("""int64"""				),
									        },
									        "answers": datasets.Sequence(datasets.Value("""string"""				)				),
									    },
									}
								elif self.config_name == "multirc":
									return {
									    "predictions": {
									        "idx": {
									            "answer": datasets.Value("""int64"""				),
									            "paragraph": datasets.Value("""int64"""				),
									            "question": datasets.Value("""int64"""				),
									        },
									        "prediction": datasets.Value("""int64"""				),
									    },
									    "references": datasets.Value("""int64"""				),
									}
								else:
									return {
									    "predictions": datasets.Value("""int64"""				),
									    "references": datasets.Value("""int64"""				),
									}





							def       lowerCamelCase__							(						self						:Optional[Any]		,      __magic_name__						:List[str]		,      __magic_name__						:Optional[Any]				):







								'''simple docstring'''







								if self.config_name == "axb":
									return {"matthews_correlation": matthews_corrcoef(__magic_name__		,      __magic_name__				)}
								elif self.config_name == "cb":
									return acc_and_fa(__magic_name__		,      __magic_name__		,      fa_avg="""macro"""				)
								elif self.config_name == "record":
									a										=							[
									    {
									        """qas""": [
									            {"""id""": ref["""idx"""]["""query"""], """answers""": [{"""text""": ans} for ans in ref["""answers"""]]}
									            for ref in references
									        ]
									    }
									]
									a										=							{pred["""idx"""]["""query"""]: pred["""prediction_text"""] for pred in predictions}
									return evaluate_record(__magic_name__		,      __magic_name__				)[0]
								elif self.config_name == "multirc":
									return evaluate_multirc(__magic_name__		,      __magic_name__				)
								elif self.config_name in ["copa", "rte", "wic", "wsc", "wsc.fixed", "boolq", "axg"]:
									return {"accuracy": simple_accuracy(__magic_name__		,      __magic_name__				)}
								else:
									raise KeyError(
									    """You should supply a configuration name selected in """
									    """[\"boolq\", \"cb\", \"copa\", \"multirc\", \"record\", \"rte\", \"wic\", \"wsc\", \"wsc.fixed\", \"axb\", \"axg\",]"""				)







import argparse

import fairseq
import torch
from torch import nn

from transformers import (
    MBartaaTokenizer,
    MBartConfig,
    MBartForCausalLM,
    SpeechEncoderDecoderConfig,
    SpeechEncoderDecoderModel,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
    WavaVecaModel,
    logging,
)


logging.set_verbosity_info()
__UpperCamelCase					:       str    					=      logging.get_logger(__name__)

__UpperCamelCase					:       List[str]    					=      {
    "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": "lm_head",
    "mask_emb": "masked_spec_embed",
}
__UpperCamelCase					:       Union[str, Any]    					=      [
    "lm_head",
    "quantizer.weight_proj",
    "quantizer.codevectors",
    "project_q",
    "project_hid",
]





def 		__A		(	__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase    )      ->       Union[str, Any]:
	for attribute in key.split("""."""    ):
		a										=							getattr(__lowerCamelCase							,			__lowerCamelCase    )

	if weight_type is not None:
		a										=							getattr(__lowerCamelCase							,			__lowerCamelCase    ).shape
	else:
		a										=							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":
		a										=							value
	elif weight_type == "weight_g":
		a										=							value
	elif weight_type == "weight_v":
		a										=							value
	elif weight_type == "bias":
		a										=							value
	else:
		a										=							value

	logger.info(f'{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}.'    )





def 		__A		(	__lowerCamelCase							,			__lowerCamelCase    )      ->       int:
	a										=							[]
	a										=							fairseq_model.state_dict()

	a										=							hf_model.feature_extractor
	a										=							hf_model.adapter

	for name, value in fairseq_dict.items():
		a										=							False
		if "conv_layers" in name:
			load_conv_layer(
			    __lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase							,			hf_model.config.feat_extract_norm == """group"""							,			)
			a										=							True
		elif any(x in name for x in ["""adaptor""", """w2v_encoder.proj.""", """w2v_proj_ln."""]    ):
			load_adapter(__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase    )
			a										=							True
		else:
			for key, mapped_key in MAPPING.items():
				if key in name or key.split("""w2v_model."""    )[-1] == name.split("""."""    )[0]:
					a										=							True
					if "*" in mapped_key:
						a										=							name.split(__lowerCamelCase    )[0].split("""."""    )[-2]
						a										=							mapped_key.replace("""*"""							,			__lowerCamelCase    )
					if "weight_g" in name:
						a										=							"""weight_g"""
					elif "weight_v" in name:
						a										=							"""weight_v"""
					elif "bias" in name:
						a										=							"""bias"""
					elif "weight" in name:
						a										=							"""weight"""
					else:
						a										=							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 		__A		(	__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase    )      ->       Tuple:
	a										=							full_name.split("""conv_layers."""    )[-1]
	a										=							name.split("""."""    )
	a										=							int(items[0]    )
	a										=							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.'
			)
			a										=							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.'
			)
			a										=							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."
			)
			a										=							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.'
			)
			a										=							value
			logger.info(f'Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}.'    )
	else:
		unused_weights.append(__lowerCamelCase    )





def 		__A		(	__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase    )      ->       Any:
	a										=							full_name.split("""adaptor."""    )[-1]
	a										=							name.split("""."""    )

	if items[1].isdigit():
		a										=							int(items[1]    )
	else:
		a										=							None

	if "adaptor" not in full_name:
		if "proj_ln" in full_name:
			# has to be layer norm
			if "bias" in name:
				assert (
				    value.shape == adapter.proj_layer_norm.bias.data.shape
				), f'{full_name} has size {value.shape}, but {adapter.proj_layer_norm.bias.data.shape} was found.'
				a										=							value
				logger.info(f'Adapter proj layer norm bias was initialized from {full_name}.'    )
			if "weight" in name:
				assert (
				    value.shape == adapter.proj_layer_norm.weight.data.shape
				), f'{full_name} has size {value.shape}, but {adapter.proj_layer_norm.weight.data.shape} was found.'
				a										=							value
		else:
			# has to be projection layer
			if "bias" in name:
				assert (
				    value.shape == adapter.proj.bias.data.shape
				), f'{full_name} has size {value.shape}, but {adapter.proj.bias.data.shape} was found.'
				a										=							value
				logger.info(f'Adapter proj layer bias was initialized from {full_name}.'    )
			if "weight" in name:
				assert (
				    value.shape == adapter.proj.weight.data.shape
				), f'{full_name} has size {value.shape}, but {adapter.proj.weight.data.shape} was found.'
				a										=							value
				logger.info(f'Adapter proj layer weight was initialized from {full_name}.'    )
	elif isinstance(__lowerCamelCase							,			__lowerCamelCase    ):
		if "bias" in name:
			assert (
			    value.shape == adapter.layers[layer_id].conv.bias.data.shape
			), f'{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.bias.data.shape} was found.'
			a										=							value
			logger.info(f'Adapter layer {layer_id} bias was initialized from {full_name}.'    )
		elif "weight" in name:
			assert (
			    value.shape == adapter.layers[layer_id].conv.weight.data.shape
			), f'{full_name} has size {value.shape}, but {adapter.layers[layer_id].conv.weight.data.shape} was found.'
			a										=							value
			logger.info(f'Adapter layer {layer_id} bias was initialized from {full_name}.'    )
	else:
		unused_weights.append(__lowerCamelCase    )





def 		__A		(	__lowerCamelCase    )      ->       Tuple:
	a				, a										=							emb.weight.shape
	a										=							nn.Linear(__lowerCamelCase							,			__lowerCamelCase							,			bias=__lowerCamelCase    )
	a										=							emb.weight.data
	return lin_layer





@torch.no_grad()
def 		__A		(	__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase							,			)      ->       Optional[int]:
	a										=							WavaVecaConfig.from_pretrained(
	    __lowerCamelCase							,			add_adapter=__lowerCamelCase							,			adapter_stride=__lowerCamelCase							,			adapter_kernel_size=__lowerCamelCase							,			use_auth_token=__lowerCamelCase							,			output_hidden_size=__lowerCamelCase							,			)
	a										=							MBartConfig.from_pretrained(__lowerCamelCase    )

	# load model
	a				, a				, a										=							fairseq.checkpoint_utils.load_model_ensemble_and_task(
	    [checkpoint_path]							,			arg_overrides={
	        """config_yaml""": config_yaml_path,
	        """data""": """/""".join(dict_path.split("""/"""    )[:-1]    ),
	        """w2v_path""": checkpoint_path,
	        """load_pretrained_decoder_from""": None,
	    }							,			)
	a										=							model[0].eval()

	# load feature extractor
	a										=							WavaVecaFeatureExtractor.from_pretrained(__lowerCamelCase							,			use_auth_token=__lowerCamelCase    )

	# set weights for wav2vec2 encoder
	a										=							WavaVecaModel(__lowerCamelCase    )

	recursively_load_weights_wavaveca(model.encoder							,			__lowerCamelCase    )

	# load decoder weights
	a										=							MBartForCausalLM(__lowerCamelCase    )
	a				, a										=							hf_decoder.model.decoder.load_state_dict(model.decoder.state_dict()							,			strict=__lowerCamelCase    )
	logger.warning(f'The following keys are missing when loading the decoder weights: {missing_keys}'    )
	logger.warning(f'The following keys are unexpected when loading the decoder weights: {unexpected_keys}'    )

	a										=							SpeechEncoderDecoderModel(encoder=__lowerCamelCase							,			decoder=__lowerCamelCase    )
	a										=							False

	a										=							MBartaaTokenizer(__lowerCamelCase    )
	tokenizer.save_pretrained(__lowerCamelCase    )

	a										=							hf_wavavec.config.to_dict()
	a										=							tokenizer.pad_token_id
	a										=							tokenizer.bos_token_id
	a										=							tokenizer.eos_token_id
	a										=							"""mbart50"""
	a										=							"""wav2vec2"""

	a										=							tokenizer.eos_token_id
	a										=							25_0004
	a										=							tokenizer.eos_token_id

	a										=							SpeechEncoderDecoderConfig.from_dict(__lowerCamelCase    )

	hf_wavavec.save_pretrained(__lowerCamelCase    )
	feature_extractor.save_pretrained(__lowerCamelCase    )


if __name__ == "__main__":
		__UpperCamelCase					:       Any    					=      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_yaml_path", default=None, type=str, help="Path to yaml file of fine-tuned model")
		parser.add_argument(
		    "--encoder_config_path",
		    default="facebook/wav2vec2-xls-r-1b",
		    type=str,
		    help="Path to hf encoder wav2vec2 checkpoint config",
		)
		parser.add_argument(
		    "--decoder_config_path",
		    default="facebook/mbart-large-50-one-to-many-mmt",
		    type=str,
		    help="Path to hf decoder checkpoint config",
		)
		parser.add_argument("--add_adapter", default=True, type=bool, help="whethere to add model adapter layers")
		parser.add_argument("--adapter_stride", default=2, type=int, help="stride of adapter layers")
		parser.add_argument("--adapter_kernel_size", default=3, type=int, help="kernel size of adapter layers")
		parser.add_argument("--encoder_output_dim", default=1_024, type=int, help="encoder output dim")
		parser.add_argument("--start_token_id", default=250_004, type=int, help="`decoder_start_token_id` of model config")

		__UpperCamelCase					:       int    					=      parser.parse_args()
		convert_wavaveca_checkpoint(
		    args.checkpoint_path,
		    args.pytorch_dump_folder_path,
		    args.dict_path,
		    args.config_yaml_path,
		    encoder_config_path=args.encoder_config_path,
		    decoder_config_path=args.decoder_config_path,
		    add_adapter=args.add_adapter,
		    adapter_kernel_size=args.adapter_kernel_size,
		    adapter_stride=args.adapter_stride,
		    decoder_start_token_id=args.start_token_id,
		    encoder_output_dim=args.encoder_output_dim,
		)

