


"""simple docstring"""


from sklearn.metrics import fa_score, matthews_corrcoef

import datasets

from .record_evaluation import evaluate as evaluate_record


a_       							=    "\\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"

a_       							=    "\\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"

a_       							=    "\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__ (				__lowercase     ,			__lowercase   )	->	Union[str, Any]:
				return float((preds == labels).mean()   )






def      a__ (				__lowercase     ,			__lowercase     ,			__lowercase="binary"   )	->	Optional[Any]:
				_A					  =			simple_accuracy(__lowercase     ,			__lowercase   )
				_A					  =			float(fa_score(y_true=__lowercase     ,			y_pred=__lowercase     ,			average=__lowercase   )   )
				return {
				    "accuracy": acc,
				    "f1": fa,
				}






def      a__ (				__lowercase     ,			__lowercase   )	->	List[str]:
				_A					  =			{}
				for id_pred, label in zip(__lowercase     ,			__lowercase   ):
								_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(*__lowercase   )
								_A					  =			fa_score(y_true=__lowercase     ,			y_pred=__lowercase     ,			average="macro"   )
								fas.append(__lowercase   )
								_A					  =			int(sum(pred == label for pred, label in preds_labels   ) == len(__lowercase   )   )
								ems.append(__lowercase   )
				_A					  =			float(sum(__lowercase   ) / len(__lowercase   )   )
				_A					  =			sum(__lowercase   ) / len(__lowercase   )
				_A					  =			float(fa_score(y_true=__lowercase     ,			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 snake_case      (  datasets.Metric):







		def  a_ (					self      :       int		)       ->						Union[str, Any]:





						'''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  a_ (					self      :       List[Any]		)       ->						List[str]:





						'''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  a_ (					self      :       str    ,   a__      :       Dict    ,   a__      :       Any		)       ->						int:





						'''simple docstring'''







						if self.config_name == "axb":
										return {"matthews_correlation": matthews_corrcoef(a__    ,   a__		)}
						elif self.config_name == "cb":
										return acc_and_fa(a__    ,   a__    ,   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(a__    ,   a__		)[0]
						elif self.config_name == "multirc":
										return evaluate_multirc(a__    ,   a__		)
						elif self.config_name in ["copa", "rte", "wic", "wsc", "wsc.fixed", "boolq", "axg"]:
										return {"accuracy": simple_accuracy(a__    ,   a__		)}
						else:
										raise KeyError(
										    "You should supply a configuration name selected in "
										    "[\"boolq\", \"cb\", \"copa\", \"multirc\", \"record\", \"rte\", \"wic\", \"wsc\", \"wsc.fixed\", \"axb\", \"axg\",]"		)



"""simple docstring"""


import argparse
import json
import os
from collections import OrderedDict

import numpy as np
import tensorflow as tf
import torch






def      a__ (				__lowercase   )	->	List[Any]:
				_A					  =			os.path.join(args.tf_model_dir     ,			"parameters.json"   )
				_A					  =			json.loads(open(__lowercase   ).read()   )
				if not params:
								raise ValueError(
								    f"""It seems that the json file at {parameter_file} is empty. Make sure you have a correct json file."""   )
				if not args.output.endswith(".pt"   ):
								_A					  =			args.output + ".pt"
				_A					  =			OrderedDict()
				with tf.device("/CPU:0"   ):
								_A					  =			tf.train.load_checkpoint(args.tf_model_dir   )
								_A					  =			reader.get_variable_to_shape_map()
								for key_name in shapes.keys():
												_A					  =			reader.get_tensor(__lowercase   ).astype(np.floataa   )
												if key_name.endswith("/adam_m"   ) or key_name.endswith("/adam_v"   ):
																continue
												if key_name.startswith("pasts/"   ):
																if key_name.startswith("pasts/mlp"   ):
																				_A					  =			int(key_name[9]   )
																elif key_name.startswith("pasts/out"   ):
																				_A					  =			8
																_A					  =			"model.sqout.%d.weight" % (player * 2)  # enter to nn.Sequencial with Tanh, so 2 at a time
																_A					  =			vnp.transpose([1, 0]   ).copy()  # Mesh-Tensorflow is a diagonal matrix
																_A					  =			torch.tensor(__lowercase   )
												elif key_name.startswith("model/moe"   ):
																_A					  =			int(key_name[9:].split("/"   )[0]   )
																if key_name.endswith("/switch_gating/kernel"   ):
																				_A					  =			"model.blocks.%d.feed_forward.mlp.router.classifier.weight" % player
																				_A					  =			vnp.transpose([1, 0]   ).copy()  # Mesh-Tensorflow is a diagonal matrix
																				_A					  =			torch.tensor(__lowercase   )
																elif key_name.endswith("/softmlp/kernel"   ):
																				_A					  =			"model.blocks.%d.feed_forward.soft_bypass_mlp.weight" % player
																				_A					  =			vnp.transpose([1, 0]   ).copy()  # Mesh-Tensorflow is a diagonal matrix
																				_A					  =			torch.tensor(__lowercase   )
																elif key_name.endswith("/wo/kernel"   ) or key_name.endswith("/wi/kernel"   ):
																				_A					  =			key_name[-9:-7]
																				for i in range(16   ):
																								_A					  =			"model.blocks.%d.feed_forward.mlp.experts.expert_%d.%s.weight" % (player, i, nlayer)
																								_A					  =			(
																								    vnp[i].transpose([1, 0]   ).copy()
																								)  # In Mesh-Tensorflow, it is one array, so it is divided
																								_A					  =			torch.tensor(__lowercase   )
												elif key_name.startswith("model/mlp"   ):
																_A					  =			int(key_name[9:].split("/"   )[0]   )
																if key_name.endswith("/p1/kernel"   ):
																				_A					  =			"model.blocks.%d.feed_forward.mlp.wi.weight" % player
																				_A					  =			vnp.transpose([1, 0]   ).copy()  # Mesh-Tensorflow is a diagonal matrix
																				_A					  =			torch.tensor(__lowercase   )
																elif key_name.endswith("/p1/bias"   ):
																				_A					  =			"model.blocks.%d.feed_forward.mlp.wi.bias" % player
																				_A					  =			vnp.copy()  # same because it is one dimensional
																				_A					  =			torch.tensor(__lowercase   )
																elif key_name.endswith("/p2/kernel"   ):
																				_A					  =			"model.blocks.%d.feed_forward.mlp.wo.weight" % player
																				_A					  =			vnp.transpose([1, 0]   ).copy()  # Mesh-Tensorflow is a diagonal matrix
																				_A					  =			torch.tensor(__lowercase   )
																elif key_name.endswith("/p2/bias"   ):
																				_A					  =			"model.blocks.%d.feed_forward.mlp.wo.bias" % player
																				_A					  =			vnp.copy()  # same because it is one dimensional
																				_A					  =			torch.tensor(__lowercase   )
												elif key_name.startswith("model/ln"   ):
																_A					  =			int(key_name[8:].split("/"   )[0]   )
																if key_name.endswith("/b"   ):
																				_A					  =			"model.blocks.%d.feed_forward.norm.bias" % player
																				_A					  =			vnp.copy()  # same because it is one dimensional
																				_A					  =			torch.tensor(__lowercase   )
																elif key_name.endswith("/g"   ):
																				_A					  =			"model.blocks.%d.feed_forward.norm.weight" % player
																				_A					  =			vnp.copy()  # same because it is one dimensional
																				_A					  =			torch.tensor(__lowercase   )
												elif key_name.startswith("model/att"   ):
																_A					  =			int(key_name[9:].split("/"   )[0]   )
																if key_name.endswith("/qkv/kernel"   ):
																				_A					  =			vnp.copy()  # Compute same dimension as Mesh-tensorflow using einsum
																				_A					  =			state[:, 0, :, :]
																				_A					  =			state[:, 1, :, :]
																				_A					  =			state[:, 2, :, :]
																				_A					  =			(
																				    state_q.reshape([state_q.shape[0], state_q.shape[1] * state_q.shape[2]]   )
																				    .transpose([1, 0]   )
																				    .copy()
																				)  # Mesh-Tensorflow is a diagonal matrix
																				_A					  =			(
																				    state_k.reshape([state_k.shape[0], state_k.shape[1] * state_k.shape[2]]   )
																				    .transpose([1, 0]   )
																				    .copy()
																				)  # Mesh-Tensorflow is a diagonal matrix
																				_A					  =			(
																				    state_v.reshape([state_v.shape[0], state_v.shape[1] * state_v.shape[2]]   )
																				    .transpose([1, 0]   )
																				    .copy()
																				)  # Mesh-Tensorflow is a diagonal matrix
																				_A					  =			"model.blocks.%d.self_attn.self_attn.q_proj.weight" % player
																				_A					  =			torch.tensor(__lowercase   )
																				_A					  =			"model.blocks.%d.self_attn.self_attn.k_proj.weight" % player
																				_A					  =			torch.tensor(__lowercase   )
																				_A					  =			"model.blocks.%d.self_attn.self_attn.v_proj.weight" % player
																				_A					  =			torch.tensor(__lowercase   )
																elif key_name.endswith("/o/kernel"   ):
																				_A					  =			"model.blocks.%d.self_attn.self_attn.out_proj.weight" % player
																				_A					  =			(
																				    vnp.reshape([vnp.shape[0] * vnp.shape[1], vnp.shape[2]]   ).transpose([1, 0]   ).copy()
																				)  # Mesh-Tensorflow is a diagonal matrix
																				_A					  =			torch.tensor(__lowercase   )
												elif key_name.startswith("model/an"   ):
																_A					  =			int(key_name[8:].split("/"   )[0]   )
																if key_name.endswith("/b"   ):
																				_A					  =			"model.blocks.%d.self_attn.norm.bias" % player
																				_A					  =			vnp.copy()  # same because it is one dimensional
																				_A					  =			torch.tensor(__lowercase   )
																elif key_name.endswith("/g"   ):
																				_A					  =			"model.blocks.%d.self_attn.norm.weight" % player
																				_A					  =			vnp.copy()  # same because it is one dimensional
																				_A					  =			torch.tensor(__lowercase   )
												elif (
												    key_name.startswith("model/wte"   )
												    or key_name.startswith("model/wpe"   )
												    or key_name.startswith("model/ete"   )
												):
																_A					  =			{"wte": "embed_tokens", "wpe": "position_embeddings", "ete": "extra_position_embeddings"}[
																    key_name[-3:]
																]
																_A					  =			"model.%s.weight" % nlayer
																_A					  =			vnp.copy()  # same in embedded
																_A					  =			torch.tensor(__lowercase   )
																if key_name.startswith("model/wte"   ):
																				_A					  =			"lm_head.weight"
																				_A					  =			vnp.copy()  # same in embedded
																				_A					  =			torch.tensor(__lowercase   )
												elif key_name.startswith("model/wob"   ):
																_A					  =			"final_logits_bias"
																_A					  =			vnp.copy()  # same in embedded
																_A					  =			state.reshape((1, -1)   )
																_A					  =			torch.tensor(__lowercase   )
												elif key_name == "model/dense/kernel":
																_A					  =			"model.last_project.weight"
																_A					  =			vnp.transpose([1, 0]   ).copy()  # Mesh-Tensorflow is a diagonal matrix
																_A					  =			torch.tensor(__lowercase   )
												elif key_name == "model/dense_1/bias":
																_A					  =			"model.last_project.bias"
																_A					  =			vnp.copy()  # same because it is one dimensional
																_A					  =			torch.tensor(__lowercase   )
				torch.save(__lowercase     ,			args.output   )


if __name__ == "__main__":
		a_       							=    argparse.ArgumentParser(
		    description="model converter.", formatter_class=argparse.ArgumentDefaultsHelpFormatter
		)
		parser.add_argument("--tf_model_dir", metavar="PATH", type=str, required=True, help="import model")
		parser.add_argument("--output", metavar="PATH", type=str, required=True, help="output model")
		a_       							=    parser.parse_args()
		convert_tf_gptsan_to_pt(args)