

'''simple docstring'''
from __future__ import annotations

import unittest

from transformers import RoFormerConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
					import tensorflow as tf

					from transformers import (
					    TFRoFormerForCausalLM,
					    TFRoFormerForMaskedLM,
					    TFRoFormerForMultipleChoice,
					    TFRoFormerForQuestionAnswering,
					    TFRoFormerForSequenceClassification,
					    TFRoFormerForTokenClassification,
					    TFRoFormerModel,
					)
					from transformers.models.roformer.modeling_tf_roformer import (
					    TFRoFormerSelfAttention,
					    TFRoFormerSinusoidalPositionalEmbedding,
					)







class 							A__   :





		def __init__(		self				:     Union[str, Any]							, _a				:     str							, _a				:     Tuple=13							, _a				:     Optional[Any]=7							, _a				:     Dict=True							, _a				:     Tuple=True							, _a				:     int=True							, _a				:     int=True							, _a				:     Dict=99							, _a				:     str=32							, _a				:     str=2							, _a				:     Union[str, Any]=4							, _a				:     str=37							, _a				:     str="gelu"							, _a				:     int=0.1							, _a				:     List[str]=0.1							, _a				:     str=512							, _a				:     List[str]=16							, _a				:     int=2							, _a				:     Any=0.02							, _a				:     Optional[int]=3							, _a				:     Dict=4							, _a				:     Dict=None							, )     ->   int:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =parent
							_SCREAMING_SNAKE_CASE							   =13
							_SCREAMING_SNAKE_CASE							   =7
							_SCREAMING_SNAKE_CASE							   =True
							_SCREAMING_SNAKE_CASE							   =True
							_SCREAMING_SNAKE_CASE							   =True
							_SCREAMING_SNAKE_CASE							   =True
							_SCREAMING_SNAKE_CASE							   =99
							_SCREAMING_SNAKE_CASE							   =32
							_SCREAMING_SNAKE_CASE							   =2
							_SCREAMING_SNAKE_CASE							   =4
							_SCREAMING_SNAKE_CASE							   =37
							_SCREAMING_SNAKE_CASE							   ='gelu'
							_SCREAMING_SNAKE_CASE							   =0.1
							_SCREAMING_SNAKE_CASE							   =0.1
							_SCREAMING_SNAKE_CASE							   =512
							_SCREAMING_SNAKE_CASE							   =16
							_SCREAMING_SNAKE_CASE							   =2
							_SCREAMING_SNAKE_CASE							   =0.02
							_SCREAMING_SNAKE_CASE							   =3
							_SCREAMING_SNAKE_CASE							   =4
							_SCREAMING_SNAKE_CASE							   =None





		def 						A  (		self				:     Union[str, Any]			)     ->   List[str]:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =ids_tensor([self.batch_size, self.seq_length]							, self.vocab_size			)

							_SCREAMING_SNAKE_CASE							   =None
							if self.use_input_mask:
												_SCREAMING_SNAKE_CASE							   =random_attention_mask([self.batch_size, self.seq_length]			)

							_SCREAMING_SNAKE_CASE							   =None
							if self.use_token_type_ids:
												_SCREAMING_SNAKE_CASE							   =ids_tensor([self.batch_size, self.seq_length]							, self.type_vocab_size			)

							_SCREAMING_SNAKE_CASE							   =None
							_SCREAMING_SNAKE_CASE							   =None
							_SCREAMING_SNAKE_CASE							   =None
							if self.use_labels:
												_SCREAMING_SNAKE_CASE							   =ids_tensor([self.batch_size]							, self.type_sequence_label_size			)
												_SCREAMING_SNAKE_CASE							   =ids_tensor([self.batch_size, self.seq_length]							, self.num_labels			)
												_SCREAMING_SNAKE_CASE							   =ids_tensor([self.batch_size]							, self.num_choices			)

							_SCREAMING_SNAKE_CASE							   =RoFormerConfig(
							    vocab_size=self.vocab_size							, hidden_size=self.hidden_size							, num_hidden_layers=self.num_hidden_layers							, num_attention_heads=self.num_attention_heads							, intermediate_size=self.intermediate_size							, hidden_act=self.hidden_act							, hidden_dropout_prob=self.hidden_dropout_prob							, attention_probs_dropout_prob=self.attention_probs_dropout_prob							, max_position_embeddings=self.max_position_embeddings							, type_vocab_size=self.type_vocab_size							, initializer_range=self.initializer_range							, return_dict=_a							, )

							return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels





		def 						A  (		self				:     Union[str, Any]							, _a				:     List[str]							, _a				:     str							, _a				:     Tuple							, _a				:     Union[str, Any]							, _a				:     Union[str, Any]							, _a				:     Any							, _a				:     Optional[int]			)     ->   Any:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =TFRoFormerModel(config=_a			)
							_SCREAMING_SNAKE_CASE							   ={'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}

							_SCREAMING_SNAKE_CASE							   =[input_ids, input_mask]
							_SCREAMING_SNAKE_CASE							   =model(_a			)

							_SCREAMING_SNAKE_CASE							   =model(_a			)

							self.parent.assertEqual(result.last_hidden_state.shape							, (self.batch_size, self.seq_length, self.hidden_size)			)





		def 						A  (		self				:     Tuple							, _a				:     Optional[int]							, _a				:     Any							, _a				:     List[Any]							, _a				:     Any							, _a				:     Optional[Any]							, _a				:     Optional[int]							, _a				:     Any			)     ->   Tuple:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =True
							_SCREAMING_SNAKE_CASE							   =TFRoFormerForCausalLM(config=_a			)
							_SCREAMING_SNAKE_CASE							   ={
							    'input_ids': input_ids,
							    'attention_mask': input_mask,
							    'token_type_ids': token_type_ids,
							}
							_SCREAMING_SNAKE_CASE							   =model(_a			)['logits']
							self.parent.assertListEqual(
							    list(prediction_scores.numpy().shape			)							, [self.batch_size, self.seq_length, self.vocab_size]			)





		def 						A  (		self				:     List[str]							, _a				:     List[str]							, _a				:     Union[str, Any]							, _a				:     Tuple							, _a				:     Dict							, _a				:     Union[str, Any]							, _a				:     Any							, _a				:     Optional[Any]			)     ->   Dict:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =TFRoFormerForMaskedLM(config=_a			)
							_SCREAMING_SNAKE_CASE							   ={
							    'input_ids': input_ids,
							    'attention_mask': input_mask,
							    'token_type_ids': token_type_ids,
							}
							_SCREAMING_SNAKE_CASE							   =model(_a			)
							self.parent.assertEqual(result.logits.shape							, (self.batch_size, self.seq_length, self.vocab_size)			)





		def 						A  (		self				:     Optional[Any]							, _a				:     Tuple							, _a				:     Union[str, Any]							, _a				:     str							, _a				:     Optional[Any]							, _a				:     str							, _a				:     List[Any]							, _a				:     List[Any]			)     ->   Optional[int]:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =self.num_labels
							_SCREAMING_SNAKE_CASE							   =TFRoFormerForSequenceClassification(config=_a			)
							_SCREAMING_SNAKE_CASE							   ={
							    'input_ids': input_ids,
							    'attention_mask': input_mask,
							    'token_type_ids': token_type_ids,
							}

							_SCREAMING_SNAKE_CASE							   =model(_a			)
							self.parent.assertEqual(result.logits.shape							, (self.batch_size, self.num_labels)			)





		def 						A  (		self				:     Tuple							, _a				:     Tuple							, _a				:     List[Any]							, _a				:     Tuple							, _a				:     Optional[Any]							, _a				:     Tuple							, _a				:     Optional[Any]							, _a				:     int			)     ->   Optional[int]:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =self.num_choices
							_SCREAMING_SNAKE_CASE							   =TFRoFormerForMultipleChoice(config=_a			)
							_SCREAMING_SNAKE_CASE							   =tf.tile(tf.expand_dims(_a							, 1			)							, (1, self.num_choices, 1)			)
							_SCREAMING_SNAKE_CASE							   =tf.tile(tf.expand_dims(_a							, 1			)							, (1, self.num_choices, 1)			)
							_SCREAMING_SNAKE_CASE							   =tf.tile(tf.expand_dims(_a							, 1			)							, (1, self.num_choices, 1)			)
							_SCREAMING_SNAKE_CASE							   ={
							    'input_ids': multiple_choice_inputs_ids,
							    'attention_mask': multiple_choice_input_mask,
							    'token_type_ids': multiple_choice_token_type_ids,
							}
							_SCREAMING_SNAKE_CASE							   =model(_a			)
							self.parent.assertEqual(result.logits.shape							, (self.batch_size, self.num_choices)			)





		def 						A  (		self				:     List[str]							, _a				:     List[str]							, _a				:     Union[str, Any]							, _a				:     int							, _a				:     List[str]							, _a				:     List[str]							, _a				:     Union[str, Any]							, _a				:     Optional[int]			)     ->   Optional[int]:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =self.num_labels
							_SCREAMING_SNAKE_CASE							   =TFRoFormerForTokenClassification(config=_a			)
							_SCREAMING_SNAKE_CASE							   ={
							    'input_ids': input_ids,
							    'attention_mask': input_mask,
							    'token_type_ids': token_type_ids,
							}
							_SCREAMING_SNAKE_CASE							   =model(_a			)
							self.parent.assertEqual(result.logits.shape							, (self.batch_size, self.seq_length, self.num_labels)			)





		def 						A  (		self				:     str							, _a				:     Union[str, Any]							, _a				:     Dict							, _a				:     Union[str, Any]							, _a				:     str							, _a				:     Union[str, Any]							, _a				:     str							, _a				:     int			)     ->   int:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =TFRoFormerForQuestionAnswering(config=_a			)
							_SCREAMING_SNAKE_CASE							   ={
							    'input_ids': input_ids,
							    'attention_mask': input_mask,
							    'token_type_ids': token_type_ids,
							}

							_SCREAMING_SNAKE_CASE							   =model(_a			)
							self.parent.assertEqual(result.start_logits.shape							, (self.batch_size, self.seq_length)			)
							self.parent.assertEqual(result.end_logits.shape							, (self.batch_size, self.seq_length)			)





		def 						A  (		self				:     int			)     ->   Any:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =self.prepare_config_and_inputs()
							(
							    (
							    _SCREAMING_SNAKE_CASE						
							)   ,						(
							    _SCREAMING_SNAKE_CASE						
							)   ,						(
							    _SCREAMING_SNAKE_CASE						
							)   ,						(
							    _SCREAMING_SNAKE_CASE						
							)   ,						(
							    _SCREAMING_SNAKE_CASE						
							)   ,						(
							    _SCREAMING_SNAKE_CASE						
							)   ,						(
							    _SCREAMING_SNAKE_CASE						
							)   ,												
							)							   =config_and_inputs
							_SCREAMING_SNAKE_CASE							   ={'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
							return config, inputs_dict







@require_tf
class 							A__   (	A__					,       A__					,       unittest.TestCase  ):
		A__					=    (
		    (
		        TFRoFormerModel,
		        TFRoFormerForCausalLM,
		        TFRoFormerForMaskedLM,
		        TFRoFormerForQuestionAnswering,
		        TFRoFormerForSequenceClassification,
		        TFRoFormerForTokenClassification,
		        TFRoFormerForMultipleChoice,
		    )
		    if is_tf_available()
		    else ()
		)
		A__					=    (
		    {
		        'feature-extraction': TFRoFormerModel,
		        'fill-mask': TFRoFormerForMaskedLM,
		        'question-answering': TFRoFormerForQuestionAnswering,
		        'text-classification': TFRoFormerForSequenceClassification,
		        'text-generation': TFRoFormerForCausalLM,
		        'token-classification': TFRoFormerForTokenClassification,
		        'zero-shot': TFRoFormerForSequenceClassification,
		    }
		    if is_tf_available()
		    else {}
		)

		A__					=    False
		A__					=    False





		def 						A  (		self				:     Tuple							, _a				:     Optional[int]							, _a				:     str							, _a				:     str							, _a				:     Dict							, _a				:     List[Any]			)     ->   Optional[Any]:





							'''simple docstring'''






							if pipeline_test_casse_name == "TextGenerationPipelineTests":
												return True

							return False





		def 						A  (		self				:     Dict			)     ->   Dict:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =TFRoFormerModelTester(self			)
							_SCREAMING_SNAKE_CASE							   =ConfigTester(self							, config_class=_a							, hidden_size=37			)





		def 						A  (		self				:     Tuple			)     ->   Optional[int]:





							'''simple docstring'''






							self.config_tester.run_common_tests()





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





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*_a			)





		def 						A  (		self				:     Any			)     ->   Optional[Any]:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_lm(*_a			)





		def 						A  (		self				:     List[Any]			)     ->   Optional[int]:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_lm_head(*_a			)





		def 						A  (		self				:     List[Any]			)     ->   Dict:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_multiple_choice(*_a			)





		def 						A  (		self				:     List[str]			)     ->   str:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_question_answering(*_a			)





		def 						A  (		self				:     List[Any]			)     ->   List[str]:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_sequence_classification(*_a			)





		def 						A  (		self				:     Dict			)     ->   Dict:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_token_classification(*_a			)





		@slow
		def 						A  (		self				:     str			)     ->   Dict:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =TFRoFormerModel.from_pretrained('junnyu/roformer_chinese_base'			)
							self.assertIsNotNone(_a			)







@require_tf
class 							A__   (	unittest.TestCase  ):





		@slow
		def 						A  (		self				:     List[str]			)     ->   Tuple:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =TFRoFormerForMaskedLM.from_pretrained('junnyu/roformer_chinese_base'			)
							_SCREAMING_SNAKE_CASE							   =tf.constant([[0, 1, 2, 3, 4, 5]]			)
							_SCREAMING_SNAKE_CASE							   =model(_a			)[0]

							# TODO Replace vocab size
							_SCREAMING_SNAKE_CASE							   =5_0000

							_SCREAMING_SNAKE_CASE							   =[1, 6, vocab_size]
							self.assertEqual(output.shape							, _a			)

							print(output[:, :3, :3]			)

							# TODO Replace values below with what was printed above.
							_SCREAMING_SNAKE_CASE							   =tf.constant(
							    [
							        [
							            [-0.12_05_33_41, -1.0_26_49_01, 0.29_22_19_46],
							            [-1.5_13_37_83, 0.19_74_33, 0.15_19_06_07],
							            [-5.0_13_54_03, -3.90_02_56, -0.84_03_87_64],
							        ]
							    ]			)
							tf.debugging.assert_near(output[:, :3, :3]							, _a							, atol=1e-4			)







@require_tf
class 							A__   (	unittest.TestCase  ):
		A__					=    1E-4





		def 						A  (		self				:     int			)     ->   Tuple:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =tf.constant([[4, 10]]			)
							_SCREAMING_SNAKE_CASE							   =TFRoFormerSinusoidalPositionalEmbedding(num_positions=6							, embedding_dim=6			)

							_SCREAMING_SNAKE_CASE							   =emba(input_ids.shape			)
							_SCREAMING_SNAKE_CASE							   =tf.constant(
							    [[0.00_00, 0.00_00, 0.00_00, 1.00_00, 1.00_00, 1.00_00], [0.84_15, 0.04_64, 0.00_22, 0.54_03, 0.99_89, 1.00_00]]			)

							tf.debugging.assert_near(_a							, _a							, atol=self.tolerance			)





		def 						A  (		self				:     Dict			)     ->   List[Any]:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =tf.constant(
							    [
							        [0.00_00, 0.00_00, 0.00_00, 0.00_00, 0.00_00],
							        [0.84_15, 0.82_19, 0.80_20, 0.78_19, 0.76_17],
							        [0.90_93, 0.93_64, 0.95_81, 0.97_49, 0.98_70],
							    ]			)
							_SCREAMING_SNAKE_CASE							   =TFRoFormerSinusoidalPositionalEmbedding(num_positions=512							, embedding_dim=512			)
							emba([2, 16, 512]			)
							_SCREAMING_SNAKE_CASE							   =emba.weight[:3, :5]

							tf.debugging.assert_near(_a							, _a							, atol=self.tolerance			)







@require_tf
class 							A__   (	unittest.TestCase  ):
		A__					=    1E-4





		def 						A  (		self				:     List[Any]			)     ->   Optional[Any]:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =tf.reshape(tf.range(2 * 12 * 16 * 64							, dtype=tf.floataa			)							, shape=(2, 12, 16, 64)			) / 100

							_SCREAMING_SNAKE_CASE							   =-tf.reshape(tf.range(2 * 12 * 16 * 64							, dtype=tf.floataa			)							, shape=(2, 12, 16, 64)			) / 100

							_SCREAMING_SNAKE_CASE							   =TFRoFormerSinusoidalPositionalEmbedding(num_positions=32							, embedding_dim=64			)
							_SCREAMING_SNAKE_CASE							   =embed_positions([2, 16, 768]			)[None, None, :, :]

							_SCREAMING_SNAKE_CASE   ,						_SCREAMING_SNAKE_CASE							   =TFRoFormerSelfAttention.apply_rotary_position_embeddings(
							    _a							, _a							, _a			)

							_SCREAMING_SNAKE_CASE							   =tf.constant(
							    [
							        [0.00_00, 0.01_00, 0.02_00, 0.03_00, 0.04_00, 0.05_00, 0.06_00, 0.07_00],
							        [-0.20_12, 0.88_97, 0.02_63, 0.94_01, 0.20_74, 0.94_63, 0.34_81, 0.93_43],
							        [-1.70_57, 0.62_71, -1.21_45, 1.38_97, -0.63_03, 1.76_47, -0.11_73, 1.89_85],
							        [-2.17_31, -1.63_97, -2.73_58, 0.28_54, -2.18_40, 1.71_83, -1.30_18, 2.48_71],
							        [0.27_17, -3.61_73, -2.92_06, -2.19_88, -3.66_38, 0.38_58, -2.91_55, 2.29_80],
							        [3.98_59, -2.15_80, -0.79_84, -4.49_04, -4.11_81, -2.02_52, -4.47_82, 1.12_53],
							    ]			)
							_SCREAMING_SNAKE_CASE							   =tf.constant(
							    [
							        [0.00_00, -0.01_00, -0.02_00, -0.03_00, -0.04_00, -0.05_00, -0.06_00, -0.07_00],
							        [0.20_12, -0.88_97, -0.02_63, -0.94_01, -0.20_74, -0.94_63, -0.34_81, -0.93_43],
							        [1.70_57, -0.62_71, 1.21_45, -1.38_97, 0.63_03, -1.76_47, 0.11_73, -1.89_85],
							        [2.17_31, 1.63_97, 2.73_58, -0.28_54, 2.18_40, -1.71_83, 1.30_18, -2.48_71],
							        [-0.27_17, 3.61_73, 2.92_06, 2.19_88, 3.66_38, -0.38_58, 2.91_55, -2.29_80],
							        [-3.98_59, 2.15_80, 0.79_84, 4.49_04, 4.11_81, 2.02_52, 4.47_82, -1.12_53],
							    ]			)

							tf.debugging.assert_near(query_layer[0, 0, :6, :8]							, _a							, atol=self.tolerance			)
							tf.debugging.assert_near(key_layer[0, 0, :6, :8]							, _a							, atol=self.tolerance			)



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

import datasets


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

lowerCamelCase			:				List[str] 			=					"\\nGLUE, the General Language Understanding Evaluation benchmark\n(https://gluebenchmark.com/) is a collection of resources for training,\nevaluating, and analyzing natural language understanding systems.\n"

lowerCamelCase			:				Dict 			=					"\nCompute GLUE evaluation metric associated to each GLUE dataset.\nArgs:\n    predictions: list of predictions to score.\n        Each translation should be tokenized into a list of tokens.\n    references: list of lists of references for each translation.\n        Each reference should be tokenized into a list of tokens.\nReturns: depending on the GLUE subset, one or several of:\n    \"accuracy\": Accuracy\n    \"f1\": F1 score\n    \"pearson\": Pearson Correlation\n    \"spearmanr\": Spearman Correlation\n    \"matthews_correlation\": Matthew Correlation\nExamples:\n\n    >>> glue_metric = datasets.load_metric('glue', 'sst2')  # 'sst2' or any of [\"mnli\", \"mnli_mismatched\", \"mnli_matched\", \"qnli\", \"rte\", \"wnli\", \"hans\"]\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'accuracy': 1.0}\n\n    >>> glue_metric = datasets.load_metric('glue', 'mrpc')  # 'mrpc' or 'qqp'\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'accuracy': 1.0, 'f1': 1.0}\n\n    >>> glue_metric = datasets.load_metric('glue', 'stsb')\n    >>> references = [0., 1., 2., 3., 4., 5.]\n    >>> predictions = [0., 1., 2., 3., 4., 5.]\n    >>> results = glue_metric.compute(predictions=predictions, references=references)\n    >>> print({\"pearson\": round(results[\"pearson\"], 2), \"spearmanr\": round(results[\"spearmanr\"], 2)})\n    {'pearson': 1.0, 'spearmanr': 1.0}\n\n    >>> glue_metric = datasets.load_metric('glue', 'cola')\n    >>> references = [0, 1]\n    >>> predictions = [0, 1]\n    >>> results = glue_metric.compute(predictions=predictions, references=references)\n    >>> print(results)\n    {'matthews_correlation': 1.0}\n"


def 	_lowerCAmelCase (						_UpperCamelCase						:					List[Any]							,			_UpperCamelCase						:					Dict    )				->      List[str]:
     """simple docstring"""




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


def 	_lowerCAmelCase (						_UpperCamelCase						:					Dict							,			_UpperCamelCase						:					Any    )				->      Tuple:
     """simple docstring"""




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


def 	_lowerCAmelCase (						_UpperCamelCase						:					Optional[int]							,			_UpperCamelCase						:					Optional[int]    )				->      Dict:
     """simple docstring"""




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







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





  def 						A  (		self				:     Optional[int]			)     ->   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 						A  (		self				:     str							, _a				:     str							, _a				:     List[Any]			)     ->   str:





       '''simple docstring'''






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