


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

import datasets


__snake_case				 =	'''\
@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}
}
'''

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

__snake_case				 =	'''
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      a (     __a					,   __a  )    ->      Union[str, Any]:



					'''simple docstring'''






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


def      a (     __a					,   __a  )    ->      str:



					'''simple docstring'''






					UpperCamelCase__  :Tuple				   =					simple_accuracy(__a					,   __a  )
					UpperCamelCase__  :List[Any]				   =					float(fa_score(y_true=__a					,   y_pred=__a  )  )
					return {
					    "accuracy": acc,
					    "f1": fa,
					}


def      a (     __a					,   __a  )    ->      Dict:



					'''simple docstring'''






					UpperCamelCase__  :Any				   =					float(pearsonr(__a					,   __a  )[0]  )
					UpperCamelCase__  :Optional[Any]				   =					float(spearmanr(__a					,   __a  )[0]  )
					return {
					    "pearson": pearson_corr,
					    "spearmanr": spearman_corr,
					}







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

		"""simple docstring"""

		def        lowerCAmelCase__							(						self				):

							'''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        lowerCAmelCase__							(						self       ,  UpperCamelCase_       ,  UpperCamelCase_				):

							'''simple docstring'''


							if self.config_name == "cola":
												return {"matthews_correlation": matthews_corrcoef(UpperCamelCase_       ,  UpperCamelCase_				)}
							elif self.config_name == "stsb":
												return pearson_and_spearman(UpperCamelCase_       ,  UpperCamelCase_				)
							elif self.config_name in ["mrpc", "qqp"]:
												return acc_and_fa(UpperCamelCase_       ,  UpperCamelCase_				)
							elif self.config_name in ["sst2", "mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]:
												return {"accuracy": simple_accuracy(UpperCamelCase_       ,  UpperCamelCase_				)}
							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'''
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__snake_case				 =	{
    '''configuration_convbert''': ['''CONVBERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ConvBertConfig''', '''ConvBertOnnxConfig'''],
    '''tokenization_convbert''': ['''ConvBertTokenizer'''],
}

try:
		if not is_tokenizers_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__snake_case				 =	['''ConvBertTokenizerFast''']

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__snake_case				 =	[
		    '''CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''ConvBertForMaskedLM''',
		    '''ConvBertForMultipleChoice''',
		    '''ConvBertForQuestionAnswering''',
		    '''ConvBertForSequenceClassification''',
		    '''ConvBertForTokenClassification''',
		    '''ConvBertLayer''',
		    '''ConvBertModel''',
		    '''ConvBertPreTrainedModel''',
		    '''load_tf_weights_in_convbert''',
		]


try:
		if not is_tf_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__snake_case				 =	[
		    '''TF_CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''TFConvBertForMaskedLM''',
		    '''TFConvBertForMultipleChoice''',
		    '''TFConvBertForQuestionAnswering''',
		    '''TFConvBertForSequenceClassification''',
		    '''TFConvBertForTokenClassification''',
		    '''TFConvBertLayer''',
		    '''TFConvBertModel''',
		    '''TFConvBertPreTrainedModel''',
		]


if TYPE_CHECKING:
		from .configuration_convbert import CONVBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, ConvBertConfig, ConvBertOnnxConfig
		from .tokenization_convbert import ConvBertTokenizer

		try:
				if not is_tokenizers_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .tokenization_convbert_fast import ConvBertTokenizerFast

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_convbert import (
				    CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
				    ConvBertForMaskedLM,
				    ConvBertForMultipleChoice,
				    ConvBertForQuestionAnswering,
				    ConvBertForSequenceClassification,
				    ConvBertForTokenClassification,
				    ConvBertLayer,
				    ConvBertModel,
				    ConvBertPreTrainedModel,
				    load_tf_weights_in_convbert,
				)

		try:
				if not is_tf_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_tf_convbert import (
				    TF_CONVBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TFConvBertForMaskedLM,
				    TFConvBertForMultipleChoice,
				    TFConvBertForQuestionAnswering,
				    TFConvBertForSequenceClassification,
				    TFConvBertForTokenClassification,
				    TFConvBertLayer,
				    TFConvBertModel,
				    TFConvBertPreTrainedModel,
				)


else:
		import sys

		__snake_case				 =	_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)