
"""simple docstring"""




from sklearn.metrics import fa_score, matthews_corrcoef

import datasets

from .record_evaluation import evaluate as evaluate_record


A__      :	int          =    """\
@article{wang2019superglue,
  title={SuperGLUE: A Stickier Benchmark for General-Purpose Language Understanding Systems},
  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},
  journal={arXiv preprint arXiv:1905.00537},
  year={2019}
}
"""

A__      :	Union[str, Any]          =    """\
SuperGLUE (https://super.gluebenchmark.com/) is a new benchmark styled after
GLUE with a new set of more difficult language understanding tasks, improved
resources, and a new public leaderboard.
"""

A__      :	int          =    """
Compute SuperGLUE evaluation metric associated to each SuperGLUE dataset.
Args:
    predictions: list of predictions to score. Depending on the SuperGlUE subset:
        - for 'record': list of question-answer dictionaries with the following keys:
            - 'idx': index of the question as specified by the dataset
            - 'prediction_text': the predicted answer text
        - for 'multirc': list of question-answer dictionaries with the following keys:
            - 'idx': index of the question-answer pair as specified by the dataset
            - 'prediction': the predicted answer label
        - otherwise: list of predicted labels
    references: list of reference labels. Depending on the SuperGLUE subset:
        - for 'record': list of question-answers dictionaries with the following keys:
            - 'idx': index of the question as specified by the dataset
            - 'answers': list of possible answers
        - otherwise: list of reference labels
Returns: depending on the SuperGLUE subset:
    - for 'record':
        - 'exact_match': Exact match between answer and gold answer
        - 'f1': F1 score
    - for 'multirc':
        - 'exact_match': Exact match between answer and gold answer
        - 'f1_m': Per-question macro-F1 score
        - 'f1_a': Average F1 score over all answers
    - for 'axb':
        'matthews_correlation': Matthew Correlation
    - for 'cb':
        - 'accuracy': Accuracy
        - 'f1': F1 score
    - for all others:
        - 'accuracy': Accuracy
Examples:

    >>> super_glue_metric = datasets.load_metric('super_glue', 'copa')  # any of [\"copa\", \"rte\", \"wic\", \"wsc\", \"wsc.fixed\", \"boolq\", \"axg\"]
    >>> predictions = [0, 1]
    >>> references = [0, 1]
    >>> results = super_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0}

    >>> super_glue_metric = datasets.load_metric('super_glue', 'cb')
    >>> predictions = [0, 1]
    >>> references = [0, 1]
    >>> results = super_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0, 'f1': 1.0}

    >>> super_glue_metric = datasets.load_metric('super_glue', 'record')
    >>> predictions = [{'idx': {'passage': 0, 'query': 0}, 'prediction_text': 'answer'}]
    >>> references = [{'idx': {'passage': 0, 'query': 0}, 'answers': ['answer', 'another_answer']}]
    >>> results = super_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'exact_match': 1.0, 'f1': 1.0}

    >>> super_glue_metric = datasets.load_metric('super_glue', 'multirc')
    >>> predictions = [{'idx': {'answer': 0, 'paragraph': 0, 'question': 0}, 'prediction': 0}, {'idx': {'answer': 1, 'paragraph': 2, 'question': 3}, 'prediction': 1}]
    >>> references = [0, 1]
    >>> results = super_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'exact_match': 1.0, 'f1_m': 1.0, 'f1_a': 1.0}

    >>> super_glue_metric = datasets.load_metric('super_glue', 'axb')
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = super_glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'matthews_correlation': 1.0}
"""



def 							a__ (				lowerCAmelCase	:       Optional[int]       ,    lowerCAmelCase	:       List[str]		):






     '''simple docstring'''
     return float((preds == labels).mean()		)



def 							a__ (				lowerCAmelCase	:       Any       ,    lowerCAmelCase	:       Optional[int]       ,    lowerCAmelCase	:       Dict="binary"		):






     '''simple docstring'''
     UpperCAmelCase__							: str 							=						simple_accuracy(lowerCAmelCase       ,    lowerCAmelCase		)
     UpperCAmelCase__							: int 							=						float(fa_score(y_true=lowerCAmelCase       ,    y_pred=lowerCAmelCase       ,    average=lowerCAmelCase		)		)
     return {
         "accuracy": acc,
         "f1": fa,
     }



def 							a__ (				lowerCAmelCase	:       Tuple       ,    lowerCAmelCase	:       Dict		):






     '''simple docstring'''
     UpperCAmelCase__							: List[Any] 							=						{}
     for id_pred, label in zip(lowerCAmelCase       ,    lowerCAmelCase		):
          UpperCAmelCase__							: List[str] 							=						F"{id_pred['idx']['paragraph']}-{id_pred['idx']['question']}"
          UpperCAmelCase__							: Optional[Any] 							=						id_pred["prediction"]
          if question_id in question_map:
               question_map[question_id].append((pred, label)		)
          else:
               UpperCAmelCase__							: Optional[Any] 							=						[(pred, label)]
     UpperCAmelCase__							,	UpperCAmelCase__							: Dict 							=						[], []
     for question, preds_labels in question_map.items():
          UpperCAmelCase__							,	UpperCAmelCase__							: int 							=						zip(*lowerCAmelCase		)
          UpperCAmelCase__							: str 							=						fa_score(y_true=lowerCAmelCase       ,    y_pred=lowerCAmelCase       ,    average="macro"		)
          fas.append(lowerCAmelCase		)
          UpperCAmelCase__							: int 							=						int(sum(pred == label for pred, label in preds_labels		) == len(lowerCAmelCase		)		)
          ems.append(lowerCAmelCase		)
     UpperCAmelCase__							: List[Any] 							=						float(sum(lowerCAmelCase		) / len(lowerCAmelCase		)		)
     UpperCAmelCase__							: List[str] 							=						sum(lowerCAmelCase		) / len(lowerCAmelCase		)
     UpperCAmelCase__							: Optional[int] 							=						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   _lowercase						(       datasets.Metric				):


     '''simple docstring'''





     def  lowerCAmelCase__       (      self  )->					Tuple:
          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  )->					Tuple:
          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 ,			__UpperCamelCase ,			__UpperCamelCase  )->					List[Any]:
          if self.config_name == "axb":
               return {"matthews_correlation": matthews_corrcoef(__UpperCamelCase ,			__UpperCamelCase  )}
          elif self.config_name == "cb":
               return acc_and_fa(__UpperCamelCase ,			__UpperCamelCase ,			fa_avg="macro"  )
          elif self.config_name == "record":
               UpperCAmelCase__							: Union[str, Any] 							=						[
                   {
                       "qas": [
                           {"id": ref["idx"]["query"], "answers": [{"text": ans} for ans in ref["answers"]]}
                           for ref in references
                       ]
                   }
               ]
               UpperCAmelCase__							: Any 							=						{pred["idx"]["query"]: pred["prediction_text"] for pred in predictions}
               return evaluate_record(__UpperCamelCase ,			__UpperCamelCase  )[0]
          elif self.config_name == "multirc":
               return evaluate_multirc(__UpperCamelCase ,			__UpperCamelCase  )
          elif self.config_name in ["copa", "rte", "wic", "wsc", "wsc.fixed", "boolq", "axg"]:
               return {"accuracy": simple_accuracy(__UpperCamelCase ,			__UpperCamelCase  )}
          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 torch

from transformers import GPTaConfig, GPTaModel, load_tf_weights_in_gpta
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()



def 							a__ (				lowerCAmelCase	:       List[Any]       ,    lowerCAmelCase	:       Any       ,    lowerCAmelCase	:       List[Any]		):






     '''simple docstring'''
     # Construct model
     if gpta_config_file == "":
          UpperCAmelCase__							: Optional[int] 							=						GPTaConfig()
     else:
          UpperCAmelCase__							: Dict 							=						GPTaConfig.from_json_file(lowerCAmelCase		)
     UpperCAmelCase__							: Optional[Any] 							=						GPTaModel(lowerCAmelCase		)

     # Load weights from numpy
     load_tf_weights_in_gpta(lowerCAmelCase       ,    lowerCAmelCase       ,    lowerCAmelCase		)

     # Save pytorch-model
     UpperCAmelCase__							: Optional[int] 							=						pytorch_dump_folder_path + "/" + WEIGHTS_NAME
     UpperCAmelCase__							: Any 							=						pytorch_dump_folder_path + "/" + CONFIG_NAME
     print(F"Save PyTorch model to {pytorch_weights_dump_path}"		)
     torch.save(model.state_dict()       ,    lowerCAmelCase		)
     print(F"Save configuration file to {pytorch_config_dump_path}"		)
     with open(lowerCAmelCase       ,    "w"       ,    encoding="utf-8"		) as f:
          f.write(config.to_json_string()		)


if __name__ == "__main__":
    A__      :	Optional[int]          =    argparse.ArgumentParser()
    # Required parameters
    parser.add_argument(
        """--gpt2_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
    )
    parser.add_argument(
        """--pytorch_dump_folder_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
    )
    parser.add_argument(
        """--gpt2_config_file""",
        default="""""",
        type=str,
        help=(
            """An optional config json file corresponding to the pre-trained OpenAI model. \n"""
            """This specifies the model architecture."""
        ),
    )
    A__      :	Optional[Any]          =    parser.parse_args()
    convert_gpta_checkpoint_to_pytorch(args.gpta_checkpoint_path, args.gpta_config_file, args.pytorch_dump_folder_path)



