
import inspect
import unittest

from datasets import load_dataset
from packaging import version

from transformers import BeitConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch
					from torch import nn

					from transformers import (
					    MODEL_MAPPING,
					    BeitForImageClassification,
					    BeitForMaskedImageModeling,
					    BeitForSemanticSegmentation,
					    BeitModel,
					)
					from transformers.models.beit.modeling_beit import BEIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
					import PIL
					from PIL import Image

					from transformers import BeitImageProcessor


class        lowercase      :



		def __init__(				self       ,   A_       ,   A_=100       ,   A_=13       ,   A_=30       ,   A_=2       ,   A_=3       ,   A_=True       ,   A_=True       ,   A_=32       ,   A_=4       ,   A_=4       ,   A_=37       ,   A_="gelu"       ,   A_=0.1       ,   A_=0.1       ,   A_=10       ,   A_=0.02       ,   A_=3       ,   A_=None       ,   A_=[0, 1, 2, 3]       ,   )						->      Tuple:
				"""simple docstring"""
				UpperCamelCase						=  parent
				UpperCamelCase						=  100
				UpperCamelCase						=  batch_size
				UpperCamelCase						=  image_size
				UpperCamelCase						=  patch_size
				UpperCamelCase						=  num_channels
				UpperCamelCase						=  is_training
				UpperCamelCase						=  use_labels
				UpperCamelCase						=  hidden_size
				UpperCamelCase						=  num_hidden_layers
				UpperCamelCase						=  num_attention_heads
				UpperCamelCase						=  intermediate_size
				UpperCamelCase						=  hidden_act
				UpperCamelCase						=  hidden_dropout_prob
				UpperCamelCase						=  attention_probs_dropout_prob
				UpperCamelCase						=  type_sequence_label_size
				UpperCamelCase						=  initializer_range
				UpperCamelCase						=  scope
				UpperCamelCase						=  out_indices
				UpperCamelCase						=  num_labels

				# in BeiT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
				UpperCamelCase						=  (image_size // patch_size) ** 2
				UpperCamelCase						=  num_patches + 1



		def __UpperCamelCase				(				self )						->      List[str]:
				"""simple docstring"""
				UpperCamelCase						=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

				UpperCamelCase						=  None
				UpperCamelCase						=  None
				if self.use_labels:
						UpperCamelCase						=  ids_tensor([self.batch_size]       ,   self.type_sequence_label_size )
						UpperCamelCase						=  ids_tensor([self.batch_size, self.image_size, self.image_size]       ,   self.num_labels )

				UpperCamelCase						=  self.get_config()

				return config, pixel_values, labels, pixel_labels



		def __UpperCamelCase				(				self )						->      Any:
				"""simple docstring"""
				return BeitConfig(
				    vocab_size=self.vocab_size       ,   image_size=self.image_size       ,   patch_size=self.patch_size       ,   num_channels=self.num_channels       ,   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       ,   is_decoder=A_       ,   initializer_range=self.initializer_range       ,   out_indices=self.out_indices       ,   )



		def __UpperCamelCase				(				self       ,   A_       ,   A_       ,   A_       ,   A_ )						->      int:
				"""simple docstring"""
				UpperCamelCase						=  BeitModel(config=A_ )
				model.to(A_ )
				model.eval()
				UpperCamelCase						=  model(A_ )
				self.parent.assertEqual(result.last_hidden_state.shape       ,   (self.batch_size, self.seq_length, self.hidden_size) )



		def __UpperCamelCase				(				self       ,   A_       ,   A_       ,   A_       ,   A_ )						->      Optional[Any]:
				"""simple docstring"""
				UpperCamelCase						=  BeitForMaskedImageModeling(config=A_ )
				model.to(A_ )
				model.eval()
				UpperCamelCase						=  model(A_ )
				self.parent.assertEqual(result.logits.shape       ,   (self.batch_size, self.seq_length - 1, self.vocab_size) )



		def __UpperCamelCase				(				self       ,   A_       ,   A_       ,   A_       ,   A_ )						->      str:
				"""simple docstring"""
				UpperCamelCase						=  self.type_sequence_label_size
				UpperCamelCase						=  BeitForImageClassification(A_ )
				model.to(A_ )
				model.eval()
				UpperCamelCase						=  model(A_       ,   labels=A_ )
				self.parent.assertEqual(result.logits.shape       ,   (self.batch_size, self.type_sequence_label_size) )

				# test greyscale images
				UpperCamelCase						=  1
				UpperCamelCase						=  BeitForImageClassification(A_ )
				model.to(A_ )
				model.eval()

				UpperCamelCase						=  floats_tensor([self.batch_size, 1, self.image_size, self.image_size] )
				UpperCamelCase						=  model(A_       ,   labels=A_ )
				self.parent.assertEqual(result.logits.shape       ,   (self.batch_size, self.type_sequence_label_size) )



		def __UpperCamelCase				(				self       ,   A_       ,   A_       ,   A_       ,   A_ )						->      List[Any]:
				"""simple docstring"""
				UpperCamelCase						=  self.num_labels
				UpperCamelCase						=  BeitForSemanticSegmentation(A_ )
				model.to(A_ )
				model.eval()
				UpperCamelCase						=  model(A_ )
				self.parent.assertEqual(
				    result.logits.shape       ,   (self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2) )
				UpperCamelCase						=  model(A_       ,   labels=A_ )
				self.parent.assertEqual(
				    result.logits.shape       ,   (self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2) )



		def __UpperCamelCase				(				self )						->      Union[str, Any]:
				"""simple docstring"""
				UpperCamelCase						=  self.prepare_config_and_inputs()
				UpperCamelCase			,						UpperCamelCase			,						UpperCamelCase			,						UpperCamelCase						=  config_and_inputs
				UpperCamelCase						=  {'pixel_values': pixel_values}
				return config, inputs_dict






@require_torch
class        lowercase      (	_SCREAMING_SNAKE_CASE						,     _SCREAMING_SNAKE_CASE						,     unittest.TestCase     ):
		__lowercase : str			  =       (
		    (BeitModel, BeitForImageClassification, BeitForMaskedImageModeling, BeitForSemanticSegmentation)
		    if is_torch_available()
		    else ()
		)
		__lowercase : Tuple			  =       (
		    {
		        "feature-extraction": BeitModel,
		        "image-classification": BeitForImageClassification,
		        "image-segmentation": BeitForSemanticSegmentation,
		    }
		    if is_torch_available()
		    else {}
		)

		__lowercase : Any			  =       False
		__lowercase : int			  =       False
		__lowercase : List[Any]			  =       False



		def __UpperCamelCase				(				self )						->      List[str]:
				"""simple docstring"""
				UpperCamelCase						=  BeitModelTester(self )
				UpperCamelCase						=  ConfigTester(self       ,   config_class=A_       ,   has_text_modality=A_       ,   hidden_size=37 )



		def __UpperCamelCase				(				self )						->      List[str]:
				"""simple docstring"""
				self.config_tester.run_common_tests()



		@unittest.skip(reason='BEiT does not use inputs_embeds' )
		def __UpperCamelCase				(				self )						->      List[Any]:
				"""simple docstring"""
				pass



		@require_torch_multi_gpu
		@unittest.skip(reason='BEiT has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`' )
		def __UpperCamelCase				(				self )						->      List[str]:
				"""simple docstring"""
				pass



		def __UpperCamelCase				(				self )						->      List[Any]:
				"""simple docstring"""
				UpperCamelCase			,						UpperCamelCase						=  self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
						UpperCamelCase						=  model_class(A_ )
						self.assertIsInstance(model.get_input_embeddings()       ,   (nn.Module) )
						UpperCamelCase						=  model.get_output_embeddings()
						self.assertTrue(x is None or isinstance(A_       ,   nn.Linear ) )



		def __UpperCamelCase				(				self )						->      Tuple:
				"""simple docstring"""
				UpperCamelCase			,						UpperCamelCase						=  self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
						UpperCamelCase						=  model_class(A_ )
						UpperCamelCase						=  inspect.signature(model.forward )
						# signature.parameters is an OrderedDict => so arg_names order is deterministic
						UpperCamelCase						=  [*signature.parameters.keys()]

						UpperCamelCase						=  ['pixel_values']
						self.assertListEqual(arg_names[:1]       ,   A_ )



		def __UpperCamelCase				(				self )						->      List[str]:
				"""simple docstring"""
				UpperCamelCase						=  self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*A_ )



		def __UpperCamelCase				(				self )						->      Dict:
				"""simple docstring"""
				UpperCamelCase						=  self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_masked_lm(*A_ )



		def __UpperCamelCase				(				self )						->      List[str]:
				"""simple docstring"""
				UpperCamelCase						=  self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_classification(*A_ )



		def __UpperCamelCase				(				self )						->      List[str]:
				"""simple docstring"""
				UpperCamelCase						=  self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_semantic_segmentation(*A_ )



		def __UpperCamelCase				(				self )						->      List[Any]:
				"""simple docstring"""
				if not self.model_tester.is_training:
						return

				UpperCamelCase			,						UpperCamelCase						=  self.model_tester.prepare_config_and_inputs_for_common()
				UpperCamelCase						=  True

				for model_class in self.all_model_classes:
						# we don't test BeitForMaskedImageModeling
						if model_class in [*get_values(A_ ), BeitForMaskedImageModeling]:
								continue

						UpperCamelCase						=  model_class(A_ )
						model.to(A_ )
						model.train()
						UpperCamelCase						=  self._prepare_for_class(A_       ,   A_       ,   return_labels=A_ )
						UpperCamelCase						=  model(**A_ ).loss
						loss.backward()



		def __UpperCamelCase				(				self )						->      Union[str, Any]:
				"""simple docstring"""
				UpperCamelCase			,						UpperCamelCase						=  self.model_tester.prepare_config_and_inputs_for_common()
				if not self.model_tester.is_training:
						return

				UpperCamelCase						=  False
				UpperCamelCase						=  True

				for model_class in self.all_model_classes:
						# we don't test BeitForMaskedImageModeling
						if (
						    model_class in [*get_values(A_ ), BeitForMaskedImageModeling]
						    or not model_class.supports_gradient_checkpointing
						):
								continue

						UpperCamelCase						=  model_class(A_ )
						model.gradient_checkpointing_enable()
						model.to(A_ )
						model.train()
						UpperCamelCase						=  self._prepare_for_class(A_       ,   A_       ,   return_labels=A_ )
						UpperCamelCase						=  model(**A_ ).loss
						loss.backward()



		def __UpperCamelCase				(				self )						->      Dict:
				"""simple docstring"""
				UpperCamelCase			,						UpperCamelCase						=  self.model_tester.prepare_config_and_inputs_for_common()

				UpperCamelCase						=  _config_zero_init(A_ )
				for model_class in self.all_model_classes:
						UpperCamelCase						=  model_class(config=A_ )
						for name, param in model.named_parameters():
								# we skip lambda parameters as these require special initial values
								# determined by config.layer_scale_init_value
								if "lambda" in name:
										continue
								if param.requires_grad:
										self.assertIn(
										    ((param.data.mean() * 1e9).round() / 1e9).item()       ,   [0.0, 1.0]       ,   msg=F'''Parameter {name} of model {model_class} seems not properly initialized'''       ,   )



		@slow
		def __UpperCamelCase				(				self )						->      Optional[int]:
				"""simple docstring"""
				for model_name in BEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						UpperCamelCase						=  BeitModel.from_pretrained(A_ )
						self.assertIsNotNone(A_ )






def    A (      )     ->						List[str]:
		'''simple docstring'''

		UpperCamelCase						=  Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
		return image


@require_torch
@require_vision
class        lowercase      (	unittest.TestCase     ):



		@cached_property
		def __UpperCamelCase				(				self )						->      List[Any]:
				"""simple docstring"""
				return BeitImageProcessor.from_pretrained('microsoft/beit-base-patch16-224' ) if is_vision_available() else None



		@slow
		def __UpperCamelCase				(				self )						->      List[Any]:
				"""simple docstring"""
				UpperCamelCase						=  BeitForMaskedImageModeling.from_pretrained('microsoft/beit-base-patch16-224-pt22k' ).to(A_ )

				UpperCamelCase						=  self.default_image_processor
				UpperCamelCase						=  prepare_img()
				UpperCamelCase						=  image_processor(images=A_       ,   return_tensors='pt' ).pixel_values.to(A_ )

				# prepare bool_masked_pos
				UpperCamelCase						=  torch.ones((1, 196)       ,   dtype=torch.bool ).to(A_ )

				# forward pass
				with torch.no_grad():
						UpperCamelCase						=  model(pixel_values=A_       ,   bool_masked_pos=A_ )
				UpperCamelCase						=  outputs.logits

				# verify the logits
				UpperCamelCase						=  torch.Size((1, 196, 8_192) )
				self.assertEqual(logits.shape       ,   A_ )

				UpperCamelCase						=  torch.tensor(
				    [[-3.2437, 0.5072, -13.9174], [-3.2456, 0.4948, -13.9401], [-3.2033, 0.5121, -13.8550]] ).to(A_ )

				self.assertTrue(torch.allclose(logits[bool_masked_pos][:3, :3]       ,   A_       ,   atol=1e-2 ) )



		@slow
		def __UpperCamelCase				(				self )						->      str:
				"""simple docstring"""
				UpperCamelCase						=  BeitForImageClassification.from_pretrained('microsoft/beit-base-patch16-224' ).to(A_ )

				UpperCamelCase						=  self.default_image_processor
				UpperCamelCase						=  prepare_img()
				UpperCamelCase						=  image_processor(images=A_       ,   return_tensors='pt' ).to(A_ )

				# forward pass
				with torch.no_grad():
						UpperCamelCase						=  model(**A_ )
				UpperCamelCase						=  outputs.logits

				# verify the logits
				UpperCamelCase						=  torch.Size((1, 1_000) )
				self.assertEqual(logits.shape       ,   A_ )

				UpperCamelCase						=  torch.tensor([-1.2385, -1.0987, -1.0108] ).to(A_ )

				self.assertTrue(torch.allclose(logits[0, :3]       ,   A_       ,   atol=1e-4 ) )

				UpperCamelCase						=  281
				self.assertEqual(logits.argmax(-1 ).item()       ,   A_ )



		@slow
		def __UpperCamelCase				(				self )						->      str:
				"""simple docstring"""
				UpperCamelCase						=  BeitForImageClassification.from_pretrained('microsoft/beit-large-patch16-224-pt22k-ft22k' ).to(
				    A_ )

				UpperCamelCase						=  self.default_image_processor
				UpperCamelCase						=  prepare_img()
				UpperCamelCase						=  image_processor(images=A_       ,   return_tensors='pt' ).to(A_ )

				# forward pass
				with torch.no_grad():
						UpperCamelCase						=  model(**A_ )
				UpperCamelCase						=  outputs.logits

				# verify the logits
				UpperCamelCase						=  torch.Size((1, 21_841) )
				self.assertEqual(logits.shape       ,   A_ )

				UpperCamelCase						=  torch.tensor([1.6881, -0.2787, 0.5901] ).to(A_ )

				self.assertTrue(torch.allclose(logits[0, :3]       ,   A_       ,   atol=1e-4 ) )

				UpperCamelCase						=  2_396
				self.assertEqual(logits.argmax(-1 ).item()       ,   A_ )



		@slow
		def __UpperCamelCase				(				self )						->      Tuple:
				"""simple docstring"""
				UpperCamelCase						=  BeitForSemanticSegmentation.from_pretrained('microsoft/beit-base-finetuned-ade-640-640' )
				UpperCamelCase						=  model.to(A_ )

				UpperCamelCase						=  BeitImageProcessor(do_resize=A_       ,   size=640       ,   do_center_crop=A_ )

				UpperCamelCase						=  load_dataset('hf-internal-testing/fixtures_ade20k'       ,   split='test' )
				UpperCamelCase						=  Image.open(ds[0]['file'] )
				UpperCamelCase						=  image_processor(images=A_       ,   return_tensors='pt' ).to(A_ )

				# forward pass
				with torch.no_grad():
						UpperCamelCase						=  model(**A_ )
				UpperCamelCase						=  outputs.logits

				# verify the logits
				UpperCamelCase						=  torch.Size((1, 150, 160, 160) )
				self.assertEqual(logits.shape       ,   A_ )

				UpperCamelCase						=  version.parse(PIL.__version__ ) < version.parse('9.0.0' )

				if is_pillow_less_than_a:
						UpperCamelCase						=  torch.tensor(
						    [
						        [[-4.9225, -2.3954, -3.0522], [-2.8822, -1.0046, -1.7561], [-2.9549, -1.3228, -2.1347]],
						        [[-5.8168, -3.4129, -4.0778], [-3.8651, -2.2214, -3.0277], [-3.8356, -2.4643, -3.3535]],
						        [[-0.0078, 3.9952, 4.0754], [2.9856, 4.6944, 5.0035], [3.2413, 4.7813, 4.9969]],
						    ]       ,   device=A_       ,   )
				else:
						UpperCamelCase						=  torch.tensor(
						    [
						        [[-4.8960, -2.3688, -3.0355], [-2.8478, -0.9836, -1.7418], [-2.9449, -1.3332, -2.1456]],
						        [[-5.8081, -3.4124, -4.1006], [-3.8561, -2.2081, -3.0323], [-3.8365, -2.4601, -3.3669]],
						        [[-0.0309, 3.9868, 4.0540], [2.9640, 4.6877, 4.9976], [3.2081, 4.7690, 4.9942]],
						    ]       ,   device=A_       ,   )

				self.assertTrue(torch.allclose(logits[0, :3, :3, :3]       ,   A_       ,   atol=1e-4 ) )



		@slow
		def __UpperCamelCase				(				self )						->      Any:
				"""simple docstring"""
				UpperCamelCase						=  BeitForSemanticSegmentation.from_pretrained('microsoft/beit-base-finetuned-ade-640-640' )
				UpperCamelCase						=  model.to(A_ )

				UpperCamelCase						=  BeitImageProcessor(do_resize=A_       ,   size=640       ,   do_center_crop=A_ )

				UpperCamelCase						=  load_dataset('hf-internal-testing/fixtures_ade20k'       ,   split='test' )
				UpperCamelCase						=  Image.open(ds[0]['file'] )
				UpperCamelCase						=  image_processor(images=A_       ,   return_tensors='pt' ).to(A_ )

				# forward pass
				with torch.no_grad():
						UpperCamelCase						=  model(**A_ )

				UpperCamelCase						=  outputs.logits.detach().cpu()

				UpperCamelCase						=  image_processor.post_process_semantic_segmentation(outputs=A_       ,   target_sizes=[(500, 300)] )
				UpperCamelCase						=  torch.Size((500, 300) )
				self.assertEqual(segmentation[0].shape       ,   A_ )

				UpperCamelCase						=  image_processor.post_process_semantic_segmentation(outputs=A_ )
				UpperCamelCase						=  torch.Size((160, 160) )
				self.assertEqual(segmentation[0].shape       ,   A_ )


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

import datasets


_UpperCAmelCase      :				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"

_UpperCAmelCase      :				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"

_UpperCAmelCase      :				List[str]          = "\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    A (      lowercase					, lowercase				)     ->						List[str]:
		'''simple docstring'''

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


def    A (      lowercase					, lowercase				)     ->						Tuple:
		'''simple docstring'''

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


def    A (      lowercase					, lowercase				)     ->						Optional[int]:
		'''simple docstring'''

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


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



		def __UpperCamelCase				(				self )						->      Optional[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 __UpperCamelCase				(				self       ,   A_       ,   A_ )						->      Any:
				"""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"]' )
