

'''simple docstring'''

from scipy.stats import pearsonr, spearmanr
from sklearn.metrics import fa_score, matthews_corrcoef

import datasets


UpperCAmelCase					 =	'''\
@inproceedings{wang2019glue,
  title={{GLUE}: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding},
  author={Wang, Alex and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R.},
  note={In the Proceedings of ICLR.},
  year={2019}
}
'''

UpperCAmelCase					 =	'''\
GLUE, the General Language Understanding Evaluation benchmark
(https://gluebenchmark.com/) is a collection of resources for training,
evaluating, and analyzing natural language understanding systems.
'''

UpperCAmelCase					 =	'''
Compute GLUE evaluation metric associated to each GLUE dataset.
Args:
    predictions: list of predictions to score.
        Each translation should be tokenized into a list of tokens.
    references: list of lists of references for each translation.
        Each reference should be tokenized into a list of tokens.
Returns: depending on the GLUE subset, one or several of:
    "accuracy": Accuracy
    "f1": F1 score
    "pearson": Pearson Correlation
    "spearmanr": Spearman Correlation
    "matthews_correlation": Matthew Correlation
Examples:

    >>> glue_metric = datasets.load_metric(\'glue\', \'sst2\')  # \'sst2\' or any of ["mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'accuracy\': 1.0}

    >>> glue_metric = datasets.load_metric(\'glue\', \'mrpc\')  # \'mrpc\' or \'qqp\'
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'accuracy\': 1.0, \'f1\': 1.0}

    >>> glue_metric = datasets.load_metric(\'glue\', \'stsb\')
    >>> references = [0., 1., 2., 3., 4., 5.]
    >>> predictions = [0., 1., 2., 3., 4., 5.]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print({"pearson": round(results["pearson"], 2), "spearmanr": round(results["spearmanr"], 2)})
    {\'pearson\': 1.0, \'spearmanr\': 1.0}

    >>> glue_metric = datasets.load_metric(\'glue\', \'cola\')
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'matthews_correlation\': 1.0}
'''

def 					__UpperCamelCase				(						lowercase__    :	List[Any],       lowercase__    :	str			):






     '''simple docstring'''





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

def 					__UpperCamelCase				(						lowercase__    :	Tuple,       lowercase__    :	Optional[int]			):






     '''simple docstring'''





     __lowercase      		=simple_accuracy(lowercase__,       lowercase__			)
     __lowercase      		=float(fa_score(y_true=lowercase__,       y_pred=lowercase__			)			)
     return {
         "accuracy": acc,
         "f1": fa,
     }

def 					__UpperCamelCase				(						lowercase__    :	Optional[int],       lowercase__    :	List[Any]			):






     '''simple docstring'''





     __lowercase      		=float(pearsonr(lowercase__,       lowercase__			)[0]			)
     __lowercase      		=float(spearmanr(lowercase__,       lowercase__			)[0]			)
     return {
         "pearson": pearson_corr,
         "spearmanr": spearman_corr,
     }







@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION ,      _KWARGS_DESCRIPTION )
class 	lowerCAmelCase  (   datasets.Metric ):







       def       snake_case (				self      :			Any   ):







            """simple docstring"""







            if self.config_name not in [
                "sst2",
                "mnli",
                "mnli_mismatched",
                "mnli_matched",
                "cola",
                "stsb",
                "mrpc",
                "qqp",
                "qnli",
                "rte",
                "wnli",
                "hans",
            ]:
                 raise KeyError(
                     'You should supply a configuration name selected in '
                     '["sst2", "mnli", "mnli_mismatched", "mnli_matched", '
                     '"cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans"]'   )
            return datasets.MetricInfo(
                description=_DESCRIPTION    ,   citation=_CITATION    ,   inputs_description=_KWARGS_DESCRIPTION    ,   features=datasets.Features(
                    {
                        'predictions': datasets.Value('int64' if self.config_name != 'stsb' else 'float32'   ),
                        'references': datasets.Value('int64' if self.config_name != 'stsb' else 'float32'   ),
                    }   )    ,   codebase_urls=[]    ,   reference_urls=[]    ,   format='numpy'    ,   )







       def       snake_case (				self      :			Optional[int]    ,   __lowercase      :			Dict    ,   __lowercase      :			List[str]   ):







            """simple docstring"""







            if self.config_name == "cola":
                 return {"matthews_correlation": matthews_corrcoef(lowerCamelCase_    ,   lowerCamelCase_   )}
            elif self.config_name == "stsb":
                 return pearson_and_spearman(lowerCamelCase_    ,   lowerCamelCase_   )
            elif self.config_name in ["mrpc", "qqp"]:
                 return acc_and_fa(lowerCamelCase_    ,   lowerCamelCase_   )
            elif self.config_name in ["sst2", "mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]:
                 return {"accuracy": simple_accuracy(lowerCamelCase_    ,   lowerCamelCase_   )}
            else:
                 raise KeyError(
                     'You should supply a configuration name selected in '
                     '["sst2", "mnli", "mnli_mismatched", "mnli_matched", '
                     '"cola", "stsb", "mrpc", "qqp", "qnli", "rte", "wnli", "hans"]'   )






'''simple docstring'''






import sys

from .dependency_versions_table import deps
from .utils.versions import require_version, require_version_core


# define which module versions we always want to check at run time
# (usually the ones defined in `install_requires` in setup.py)
#
# order specific notes:
# - tqdm must be checked before tokenizers

__UpperCAmelCase       							=				'''python tqdm regex requests packaging filelock numpy tokenizers'''.split()
if sys.version_info < (3, 7):
		pkgs_to_check_at_runtime.append('''dataclasses''')
if sys.version_info < (3, 8):
		pkgs_to_check_at_runtime.append('''importlib_metadata''')

for pkg in pkgs_to_check_at_runtime:
		if pkg in deps:
				if pkg == "tokenizers":
						# must be loaded here, or else tqdm check may fail
						from .utils import is_tokenizers_available

						if not is_tokenizers_available():
								continue  # not required, check version only if installed

				require_version_core(deps[pkg])
		else:
				raise ValueError(f"""can't find {pkg} in {deps.keys()}, check dependency_versions_table.py""")


def    _snake_case  (	A					,       A=None			)		->       Optional[Any]:
							require_version(deps[pkg]					,       A			)