





"""simple docstring"""



from sklearn.metrics import fa_score, matthews_corrcoef

import datasets

from .record_evaluation import evaluate as evaluate_record


a_			=      """\
@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_			=      """\
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_			=      """
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 		__lowercase					(       snake_case_  :  int    ,snake_case_  :  Optional[int]						)       ->Union[str, Any]:



    '''simple docstring'''







    return float((preds == labels).mean()						)







def 		__lowercase					(       snake_case_  :  int    ,snake_case_  :  Any    ,snake_case_  :  Union[str, Any]="binary"						)       ->Optional[int]:



    '''simple docstring'''







    __A   :						List[Any]									=					simple_accuracy(snake_case_    ,snake_case_						)
    __A   :						List[str]									=					float(fa_score(y_true=snake_case_    ,y_pred=snake_case_    ,average=snake_case_						)						)
    return {
        "accuracy": acc,
        "f1": fa,
    }







def 		__lowercase					(       snake_case_  :  List[Any]    ,snake_case_  :  List[str]						)       ->Tuple:



    '''simple docstring'''







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





 """simple docstring"""


 def  UpperCamelCase__(   self  ):



     '''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  UpperCamelCase__(   self  ):



     '''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  UpperCamelCase__(   self ,						__lowerCamelCase ,						__lowerCamelCase  ):



     '''simple docstring'''




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



from typing import TYPE_CHECKING

from ..utils import _LazyModule


a_			=      {
    """config""": [
        """EXTERNAL_DATA_FORMAT_SIZE_LIMIT""",
        """OnnxConfig""",
        """OnnxConfigWithPast""",
        """OnnxSeq2SeqConfigWithPast""",
        """PatchingSpec""",
    ],
    """convert""": ["""export""", """validate_model_outputs"""],
    """features""": ["""FeaturesManager"""],
    """utils""": ["""ParameterFormat""", """compute_serialized_parameters_size"""],
}


if TYPE_CHECKING:
       from .config import (
           EXTERNAL_DATA_FORMAT_SIZE_LIMIT,
           OnnxConfig,
           OnnxConfigWithPast,
           OnnxSeqaSeqConfigWithPast,
           PatchingSpec,
       )
       from .convert import export, validate_model_outputs
       from .features import FeaturesManager
       from .utils import ParameterFormat, compute_serialized_parameters_size

else:
       import sys

       a_			=      _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)




