


'''simple docstring'''





import datasets


UpperCAmelCase__  			=				'''\
@InProceedings{conneau2018xnli,
  author = "Conneau, Alexis
                 and Rinott, Ruty
                 and Lample, Guillaume
                 and Williams, Adina
                 and Bowman, Samuel R.
                 and Schwenk, Holger
                 and Stoyanov, Veselin",
  title = "XNLI: Evaluating Cross-lingual Sentence Representations",
  booktitle = "Proceedings of the 2018 Conference on Empirical Methods
               in Natural Language Processing",
  year = "2018",
  publisher = "Association for Computational Linguistics",
  location = "Brussels, Belgium",
}
'''

UpperCAmelCase__  			=				'''\
XNLI is a subset of a few thousand examples from MNLI which has been translated
into a 14 different languages (some low-ish resource). As with MNLI, the goal is
to predict textual entailment (does sentence A imply/contradict/neither sentence
B) and is a classification task (given two sentences, predict one of three
labels).
'''

UpperCAmelCase__  			=				'''
Computes XNLI score which is just simple accuracy.
Args:
    predictions: Predicted labels.
    references: Ground truth labels.
Returns:
    \'accuracy\': accuracy
Examples:

    >>> predictions = [0, 1]
    >>> references = [0, 1]
    >>> xnli_metric = datasets.load_metric("xnli")
    >>> results = xnli_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {\'accuracy\': 1.0}
'''






def 						UpperCAmelCase__(				_SCREAMING_SNAKE_CASE					: List[str],_SCREAMING_SNAKE_CASE					: str ):






			"""simple docstring"""




			return (preds == labels).mean()






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





			'''simple docstring'''

			def 					lowerCAmelCase     (  self							:			Tuple	)      ->		str:
						return datasets.MetricInfo(
						    description=_DESCRIPTION			,    citation=_CITATION			,    inputs_description=_KWARGS_DESCRIPTION			,    features=datasets.Features(
						        {
						            'predictions': datasets.Value('int64' if self.config_name != 'sts-b' else 'float32'	),
						            'references': datasets.Value('int64' if self.config_name != 'sts-b' else 'float32'	),
						        }	)			,    codebase_urls=[]			,    reference_urls=[]			,    format='numpy'			,    )

			def 					lowerCAmelCase     (  self							:			Any			,    lowerCAmelCase_							:			int			,    lowerCAmelCase_							:			Union[str, Any]	)      ->		str:
						return {"accuracy": simple_accuracy(lowerCAmelCase_			,    lowerCAmelCase_	)}







'''simple docstring'''





from __future__ import annotations

import unittest

from transformers import is_tf_available, is_torch_available
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, SMALL_MODEL_IDENTIFIER, is_pt_tf_cross_test, slow


if is_tf_available():
					from transformers import (
					    AutoConfig,
					    BertConfig,
					    GPTaConfig,
					    TaConfig,
					    TFAutoModel,
					    TFAutoModelForCausalLM,
					    TFAutoModelForMaskedLM,
					    TFAutoModelForPreTraining,
					    TFAutoModelForQuestionAnswering,
					    TFAutoModelForSeqaSeqLM,
					    TFAutoModelForSequenceClassification,
					    TFAutoModelWithLMHead,
					    TFBertForMaskedLM,
					    TFBertForPreTraining,
					    TFBertForQuestionAnswering,
					    TFBertForSequenceClassification,
					    TFBertModel,
					    TFGPTaLMHeadModel,
					    TFRobertaForMaskedLM,
					    TFTaForConditionalGeneration,
					)
					from transformers.models.bert.modeling_tf_bert import TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST
					from transformers.models.gpta.modeling_tf_gpta import TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST
					from transformers.models.ta.modeling_tf_ta import TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST

if is_torch_available():
					from transformers import (
					    AutoModel,
					    AutoModelForCausalLM,
					    AutoModelForMaskedLM,
					    AutoModelForPreTraining,
					    AutoModelForQuestionAnswering,
					    AutoModelForSeqaSeqLM,
					    AutoModelForSequenceClassification,
					    AutoModelWithLMHead,
					    BertForMaskedLM,
					    BertForPreTraining,
					    BertForQuestionAnswering,
					    BertForSequenceClassification,
					    BertModel,
					    GPTaLMHeadModel,
					    RobertaForMaskedLM,
					    TaForConditionalGeneration,
					)
@is_pt_tf_cross_test
class 						a__					(					unittest.TestCase   ):





			'''simple docstring'''

			@slow
			def 					lowerCAmelCase     (  self							:			List[str]	)      ->		List[Any]:
						# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						for model_name in ["bert-base-uncased"]:
									__A=	AutoConfig.from_pretrained(lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)
									self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)

									__A=	TFAutoModel.from_pretrained(lowerCAmelCase_			,    from_pt=lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)
									self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)

									__A=	AutoModel.from_pretrained(lowerCAmelCase_			,    from_tf=lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)
									self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)
			@slow
			def 					lowerCAmelCase     (  self							:			Tuple	)      ->		Optional[Any]:
						# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						for model_name in ["bert-base-uncased"]:
									__A=	AutoConfig.from_pretrained(lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)
									self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)

									__A=	TFAutoModelForPreTraining.from_pretrained(lowerCAmelCase_			,    from_pt=lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)
									self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)

									__A=	AutoModelForPreTraining.from_pretrained(lowerCAmelCase_			,    from_tf=lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)
									self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)
			@slow
			def 					lowerCAmelCase     (  self							:			int	)      ->		Optional[int]:
						for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__A=	AutoConfig.from_pretrained(lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)
									self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)

									__A=	TFAutoModelForCausalLM.from_pretrained(lowerCAmelCase_			,    from_pt=lowerCAmelCase_	)
									__A,	__A=	TFAutoModelForCausalLM.from_pretrained(
									    lowerCAmelCase_			,    output_loading_info=lowerCAmelCase_			,    from_pt=lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)
									self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)

									__A=	AutoModelForCausalLM.from_pretrained(lowerCAmelCase_			,    from_tf=lowerCAmelCase_	)
									__A,	__A=	AutoModelForCausalLM.from_pretrained(
									    lowerCAmelCase_			,    output_loading_info=lowerCAmelCase_			,    from_tf=lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)
									self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)
			@slow
			def 					lowerCAmelCase     (  self							:			Union[str, Any]	)      ->		Optional[Any]:
						for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__A=	AutoConfig.from_pretrained(lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)
									self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)

									__A=	TFAutoModelWithLMHead.from_pretrained(lowerCAmelCase_			,    from_pt=lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)
									self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)

									__A=	AutoModelWithLMHead.from_pretrained(lowerCAmelCase_			,    from_tf=lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)
									self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)
			@slow
			def 					lowerCAmelCase     (  self							:			Union[str, Any]	)      ->		Optional[int]:
						for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__A=	AutoConfig.from_pretrained(lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)
									self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)

									__A=	TFAutoModelForMaskedLM.from_pretrained(lowerCAmelCase_			,    from_pt=lowerCAmelCase_	)
									__A,	__A=	TFAutoModelForMaskedLM.from_pretrained(
									    lowerCAmelCase_			,    output_loading_info=lowerCAmelCase_			,    from_pt=lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)
									self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)

									__A=	AutoModelForMaskedLM.from_pretrained(lowerCAmelCase_			,    from_tf=lowerCAmelCase_	)
									__A,	__A=	AutoModelForMaskedLM.from_pretrained(
									    lowerCAmelCase_			,    output_loading_info=lowerCAmelCase_			,    from_tf=lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)
									self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)
			@slow
			def 					lowerCAmelCase     (  self							:			Tuple	)      ->		Dict:
						for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__A=	AutoConfig.from_pretrained(lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)
									self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)

									__A=	TFAutoModelForSeqaSeqLM.from_pretrained(lowerCAmelCase_			,    from_pt=lowerCAmelCase_	)
									__A,	__A=	TFAutoModelForSeqaSeqLM.from_pretrained(
									    lowerCAmelCase_			,    output_loading_info=lowerCAmelCase_			,    from_pt=lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)
									self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)

									__A=	AutoModelForSeqaSeqLM.from_pretrained(lowerCAmelCase_			,    from_tf=lowerCAmelCase_	)
									__A,	__A=	AutoModelForSeqaSeqLM.from_pretrained(
									    lowerCAmelCase_			,    output_loading_info=lowerCAmelCase_			,    from_tf=lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)
									self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)
			@slow
			def 					lowerCAmelCase     (  self							:			Optional[Any]	)      ->		str:
						# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						for model_name in ["bert-base-uncased"]:
									__A=	AutoConfig.from_pretrained(lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)
									self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)

									__A=	TFAutoModelForSequenceClassification.from_pretrained(lowerCAmelCase_			,    from_pt=lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)
									self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)

									__A=	AutoModelForSequenceClassification.from_pretrained(lowerCAmelCase_			,    from_tf=lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)
									self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)
			@slow
			def 					lowerCAmelCase     (  self							:			Union[str, Any]	)      ->		List[Any]:
						# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						for model_name in ["bert-base-uncased"]:
									__A=	AutoConfig.from_pretrained(lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)
									self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)

									__A=	TFAutoModelForQuestionAnswering.from_pretrained(lowerCAmelCase_			,    from_pt=lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)
									self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)

									__A=	AutoModelForQuestionAnswering.from_pretrained(lowerCAmelCase_			,    from_tf=lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)
									self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)
			def 					lowerCAmelCase     (  self							:			int	)      ->		List[str]:
						__A=	TFAutoModelWithLMHead.from_pretrained(lowerCAmelCase_			,    from_pt=lowerCAmelCase_	)
						self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)
						self.assertEqual(model.num_parameters()			,    14_410	)
						self.assertEqual(model.num_parameters(only_trainable=lowerCAmelCase_	)			,    14_410	)

						__A=	AutoModelWithLMHead.from_pretrained(lowerCAmelCase_			,    from_tf=lowerCAmelCase_	)
						self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)
						self.assertEqual(model.num_parameters()			,    14_410	)
						self.assertEqual(model.num_parameters(only_trainable=lowerCAmelCase_	)			,    14_410	)

			def 					lowerCAmelCase     (  self							:			Optional[Any]	)      ->		Tuple:
						__A=	TFAutoModelWithLMHead.from_pretrained(lowerCAmelCase_			,    from_pt=lowerCAmelCase_	)
						self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)
						self.assertEqual(model.num_parameters()			,    14_410	)
						self.assertEqual(model.num_parameters(only_trainable=lowerCAmelCase_	)			,    14_410	)

						__A=	AutoModelWithLMHead.from_pretrained(lowerCAmelCase_			,    from_tf=lowerCAmelCase_	)
						self.assertIsInstance(lowerCAmelCase_			,    lowerCAmelCase_	)
						self.assertEqual(model.num_parameters()			,    14_410	)
						self.assertEqual(model.num_parameters(only_trainable=lowerCAmelCase_	)			,    14_410	)



