


'''simple docstring'''





import re
import string
from collections import Counter

import sacrebleu
import sacremoses
from packaging import version

import datasets


UpperCAmelCase__  			=				'''
@inproceedings{xu-etal-2016-optimizing,
    title = {Optimizing Statistical Machine Translation for Text Simplification},
    authors={Xu, Wei and Napoles, Courtney and Pavlick, Ellie and Chen, Quanze and Callison-Burch, Chris},
    journal = {Transactions of the Association for Computational Linguistics},
    volume = {4},
    year={2016},
    url = {https://www.aclweb.org/anthology/Q16-1029},
    pages = {401--415
},
@inproceedings{post-2018-call,
    title = "A Call for Clarity in Reporting {BLEU} Scores",
    author = "Post, Matt",
    booktitle = "Proceedings of the Third Conference on Machine Translation: Research Papers",
    month = oct,
    year = "2018",
    address = "Belgium, Brussels",
    publisher = "Association for Computational Linguistics",
    url = "https://www.aclweb.org/anthology/W18-6319",
    pages = "186--191",
}
'''

UpperCAmelCase__  			=				'''\
WIKI_SPLIT is the combination of three metrics SARI, EXACT and SACREBLEU
It can be used to evaluate the quality of machine-generated texts.
'''


UpperCAmelCase__  			=				'''
Calculates sari score (between 0 and 100) given a list of source and predicted
sentences, and a list of lists of reference sentences. It also computes the BLEU score as well as the exact match score.
Args:
    sources: list of source sentences where each sentence should be a string.
    predictions: list of predicted sentences where each sentence should be a string.
    references: list of lists of reference sentences where each sentence should be a string.
Returns:
    sari: sari score
    sacrebleu: sacrebleu score
    exact: exact score

Examples:
    >>> sources=["About 95 species are currently accepted ."]
    >>> predictions=["About 95 you now get in ."]
    >>> references=[["About 95 species are currently known ."]]
    >>> wiki_split = datasets.load_metric("wiki_split")
    >>> results = wiki_split.compute(sources=sources, predictions=predictions, references=references)
    >>> print(results)
    {\'sari\': 21.805555555555557, \'sacrebleu\': 14.535768424205482, \'exact\': 0.0}
'''






def 						UpperCAmelCase__(				_SCREAMING_SNAKE_CASE					: List[str] ):






			"""simple docstring"""




			def remove_articles(_SCREAMING_SNAKE_CASE					: Optional[Any] ):
						__A=	re.compile(r'\b(a|an|the)\b',re.UNICODE )
						return re.sub(_SCREAMING_SNAKE_CASE,' ',_SCREAMING_SNAKE_CASE )

			def white_space_fix(_SCREAMING_SNAKE_CASE					: Optional[Any] ):
						return " ".join(text.split() )

			def remove_punc(_SCREAMING_SNAKE_CASE					: Optional[Any] ):
						__A=	set(string.punctuation )
						return "".join(ch for ch in text if ch not in exclude )

			def lower(_SCREAMING_SNAKE_CASE					: str ):
						return text.lower()

			return white_space_fix(remove_articles(remove_punc(lower(_SCREAMING_SNAKE_CASE ) ) ) )






def 						UpperCAmelCase__(				_SCREAMING_SNAKE_CASE					: str,_SCREAMING_SNAKE_CASE					: int ):






			"""simple docstring"""




			return int(normalize_answer(_SCREAMING_SNAKE_CASE ) == normalize_answer(_SCREAMING_SNAKE_CASE ) )






def 						UpperCAmelCase__(				_SCREAMING_SNAKE_CASE					: Optional[Any],_SCREAMING_SNAKE_CASE					: Tuple ):






			"""simple docstring"""




			__A=	[any(compute_exact(_SCREAMING_SNAKE_CASE,_SCREAMING_SNAKE_CASE ) for ref in refs ) for pred, refs in zip(_SCREAMING_SNAKE_CASE,_SCREAMING_SNAKE_CASE )]
			return (sum(_SCREAMING_SNAKE_CASE ) / len(_SCREAMING_SNAKE_CASE )) * 100






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






			"""simple docstring"""




			__A=	[rgram for rgrams in rgramslist for rgram in rgrams]
			__A=	Counter(_SCREAMING_SNAKE_CASE )

			__A=	Counter(_SCREAMING_SNAKE_CASE )
			__A=	Counter()
			for sgram, scount in sgramcounter.items():
						__A=	scount * numref

			__A=	Counter(_SCREAMING_SNAKE_CASE )
			__A=	Counter()
			for cgram, ccount in cgramcounter.items():
						__A=	ccount * numref

			# KEEP
			__A=	sgramcounter_rep & cgramcounter_rep
			__A=	keepgramcounter_rep & rgramcounter
			__A=	sgramcounter_rep & rgramcounter

			__A=	0
			__A=	0
			for keepgram in keepgramcountergood_rep:
						keeptmpscorea += keepgramcountergood_rep[keepgram] / keepgramcounter_rep[keepgram]
						# Fix an alleged bug [2] in the keep score computation.
						# keeptmpscore2 += keepgramcountergood_rep[keepgram] / keepgramcounterall_rep[keepgram]
						keeptmpscorea += keepgramcountergood_rep[keepgram]
			# Define 0/0=1 instead of 0 to give higher scores for predictions that match
			#      a target exactly.
			__A=	1
			__A=	1
			if len(_SCREAMING_SNAKE_CASE ) > 0:
						__A=	keeptmpscorea / len(_SCREAMING_SNAKE_CASE )
			if len(_SCREAMING_SNAKE_CASE ) > 0:
						# Fix an alleged bug [2] in the keep score computation.
						# keepscore_recall = keeptmpscore2 / len(keepgramcounterall_rep)
						__A=	keeptmpscorea / sum(keepgramcounterall_rep.values() )
			__A=	0
			if keepscore_precision > 0 or keepscore_recall > 0:
						__A=	2 * keepscore_precision * keepscore_recall / (keepscore_precision + keepscore_recall)

			# DELETION
			__A=	sgramcounter_rep - cgramcounter_rep
			__A=	delgramcounter_rep - rgramcounter
			__A=	sgramcounter_rep - rgramcounter
			__A=	0
			__A=	0
			for delgram in delgramcountergood_rep:
						deltmpscorea += delgramcountergood_rep[delgram] / delgramcounter_rep[delgram]
						deltmpscorea += delgramcountergood_rep[delgram] / delgramcounterall_rep[delgram]
			# Define 0/0=1 instead of 0 to give higher scores for predictions that match
			# a target exactly.
			__A=	1
			if len(_SCREAMING_SNAKE_CASE ) > 0:
						__A=	deltmpscorea / len(_SCREAMING_SNAKE_CASE )

			# ADDITION
			__A=	set(_SCREAMING_SNAKE_CASE ) - set(_SCREAMING_SNAKE_CASE )
			__A=	set(_SCREAMING_SNAKE_CASE ) & set(_SCREAMING_SNAKE_CASE )
			__A=	set(_SCREAMING_SNAKE_CASE ) - set(_SCREAMING_SNAKE_CASE )

			__A=	0
			for addgram in addgramcountergood:
						addtmpscore += 1

			# Define 0/0=1 instead of 0 to give higher scores for predictions that match
			# a target exactly.
			__A=	1
			__A=	1
			if len(_SCREAMING_SNAKE_CASE ) > 0:
						__A=	addtmpscore / len(_SCREAMING_SNAKE_CASE )
			if len(_SCREAMING_SNAKE_CASE ) > 0:
						__A=	addtmpscore / len(_SCREAMING_SNAKE_CASE )
			__A=	0
			if addscore_precision > 0 or addscore_recall > 0:
						__A=	2 * addscore_precision * addscore_recall / (addscore_precision + addscore_recall)

			return (keepscore, delscore_precision, addscore)






def 						UpperCAmelCase__(				_SCREAMING_SNAKE_CASE					: Any,_SCREAMING_SNAKE_CASE					: int,_SCREAMING_SNAKE_CASE					: Any ):






			"""simple docstring"""




			__A=	len(_SCREAMING_SNAKE_CASE )

			__A=	ssent.split(' ' )
			__A=	csent.split(' ' )
			__A=	[]
			__A=	[]
			__A=	[]
			__A=	[]
			__A=	[]
			__A=	[]

			__A=	[]
			__A=	[]
			__A=	[]
			__A=	[]
			for rsent in rsents:
						__A=	rsent.split(' ' )
						__A=	[]
						__A=	[]
						__A=	[]
						ragramslist.append(_SCREAMING_SNAKE_CASE )
						for i in range(0,len(_SCREAMING_SNAKE_CASE ) - 1 ):
									if i < len(_SCREAMING_SNAKE_CASE ) - 1:
												__A=	ragrams[i] + ' ' + ragrams[i + 1]
												ragrams.append(_SCREAMING_SNAKE_CASE )
									if i < len(_SCREAMING_SNAKE_CASE ) - 2:
												__A=	ragrams[i] + ' ' + ragrams[i + 1] + ' ' + ragrams[i + 2]
												ragrams.append(_SCREAMING_SNAKE_CASE )
									if i < len(_SCREAMING_SNAKE_CASE ) - 3:
												__A=	ragrams[i] + ' ' + ragrams[i + 1] + ' ' + ragrams[i + 2] + ' ' + ragrams[i + 3]
												ragrams.append(_SCREAMING_SNAKE_CASE )
						ragramslist.append(_SCREAMING_SNAKE_CASE )
						ragramslist.append(_SCREAMING_SNAKE_CASE )
						ragramslist.append(_SCREAMING_SNAKE_CASE )

			for i in range(0,len(_SCREAMING_SNAKE_CASE ) - 1 ):
						if i < len(_SCREAMING_SNAKE_CASE ) - 1:
									__A=	sagrams[i] + ' ' + sagrams[i + 1]
									sagrams.append(_SCREAMING_SNAKE_CASE )
						if i < len(_SCREAMING_SNAKE_CASE ) - 2:
									__A=	sagrams[i] + ' ' + sagrams[i + 1] + ' ' + sagrams[i + 2]
									sagrams.append(_SCREAMING_SNAKE_CASE )
						if i < len(_SCREAMING_SNAKE_CASE ) - 3:
									__A=	sagrams[i] + ' ' + sagrams[i + 1] + ' ' + sagrams[i + 2] + ' ' + sagrams[i + 3]
									sagrams.append(_SCREAMING_SNAKE_CASE )

			for i in range(0,len(_SCREAMING_SNAKE_CASE ) - 1 ):
						if i < len(_SCREAMING_SNAKE_CASE ) - 1:
									__A=	cagrams[i] + ' ' + cagrams[i + 1]
									cagrams.append(_SCREAMING_SNAKE_CASE )
						if i < len(_SCREAMING_SNAKE_CASE ) - 2:
									__A=	cagrams[i] + ' ' + cagrams[i + 1] + ' ' + cagrams[i + 2]
									cagrams.append(_SCREAMING_SNAKE_CASE )
						if i < len(_SCREAMING_SNAKE_CASE ) - 3:
									__A=	cagrams[i] + ' ' + cagrams[i + 1] + ' ' + cagrams[i + 2] + ' ' + cagrams[i + 3]
									cagrams.append(_SCREAMING_SNAKE_CASE )

			((__A),	(__A),	(__A))=	SARIngram(_SCREAMING_SNAKE_CASE,_SCREAMING_SNAKE_CASE,_SCREAMING_SNAKE_CASE,_SCREAMING_SNAKE_CASE )
			((__A),	(__A),	(__A))=	SARIngram(_SCREAMING_SNAKE_CASE,_SCREAMING_SNAKE_CASE,_SCREAMING_SNAKE_CASE,_SCREAMING_SNAKE_CASE )
			((__A),	(__A),	(__A))=	SARIngram(_SCREAMING_SNAKE_CASE,_SCREAMING_SNAKE_CASE,_SCREAMING_SNAKE_CASE,_SCREAMING_SNAKE_CASE )
			((__A),	(__A),	(__A))=	SARIngram(_SCREAMING_SNAKE_CASE,_SCREAMING_SNAKE_CASE,_SCREAMING_SNAKE_CASE,_SCREAMING_SNAKE_CASE )
			__A=	sum([keepascore, keepascore, keepascore, keepascore] ) / 4
			__A=	sum([delascore, delascore, delascore, delascore] ) / 4
			__A=	sum([addascore, addascore, addascore, addascore] ) / 4
			__A=	(avgkeepscore + avgdelscore + avgaddscore) / 3
			return finalscore






def 						UpperCAmelCase__(				_SCREAMING_SNAKE_CASE					: int,_SCREAMING_SNAKE_CASE					: bool = True,_SCREAMING_SNAKE_CASE					: str = "13a",_SCREAMING_SNAKE_CASE					: bool = True ):






			"""simple docstring"""




			if lowercase:
						__A=	sentence.lower()

			if tokenizer in ["13a", "intl"]:
						if version.parse(sacrebleu.__version__ ).major >= 2:
									__A=	sacrebleu.metrics.bleu._get_tokenizer(_SCREAMING_SNAKE_CASE )()(_SCREAMING_SNAKE_CASE )
						else:
									__A=	sacrebleu.TOKENIZERS[tokenizer]()(_SCREAMING_SNAKE_CASE )
			elif tokenizer == "moses":
						__A=	sacremoses.MosesTokenizer().tokenize(_SCREAMING_SNAKE_CASE,return_str=_SCREAMING_SNAKE_CASE,escape=_SCREAMING_SNAKE_CASE )
			elif tokenizer == "penn":
						__A=	sacremoses.MosesTokenizer().penn_tokenize(_SCREAMING_SNAKE_CASE,return_str=_SCREAMING_SNAKE_CASE )
			else:
						__A=	sentence

			if not return_str:
						__A=	normalized_sent.split()

			return normalized_sent






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






			"""simple docstring"""




			if not (len(_SCREAMING_SNAKE_CASE ) == len(_SCREAMING_SNAKE_CASE ) == len(_SCREAMING_SNAKE_CASE )):
						raise ValueError('Sources length must match predictions and references lengths.' )
			__A=	0
			for src, pred, refs in zip(_SCREAMING_SNAKE_CASE,_SCREAMING_SNAKE_CASE,_SCREAMING_SNAKE_CASE ):
						sari_score += SARIsent(normalize(_SCREAMING_SNAKE_CASE ),normalize(_SCREAMING_SNAKE_CASE ),[normalize(_SCREAMING_SNAKE_CASE ) for sent in refs] )
			__A=	sari_score / len(_SCREAMING_SNAKE_CASE )
			return 100 * sari_score






def 						UpperCAmelCase__(				_SCREAMING_SNAKE_CASE					: Dict,_SCREAMING_SNAKE_CASE					: Optional[int],_SCREAMING_SNAKE_CASE					: Tuple="exp",_SCREAMING_SNAKE_CASE					: Tuple=None,_SCREAMING_SNAKE_CASE					: List[Any]=False,_SCREAMING_SNAKE_CASE					: Any=False,_SCREAMING_SNAKE_CASE					: Union[str, Any]=False,):






			"""simple docstring"""




			__A=	len(references[0] )
			if any(len(_SCREAMING_SNAKE_CASE ) != references_per_prediction for refs in references ):
						raise ValueError('Sacrebleu requires the same number of references for each prediction' )
			__A=	[[refs[i] for refs in references] for i in range(_SCREAMING_SNAKE_CASE )]
			__A=	sacrebleu.corpus_bleu(
			    _SCREAMING_SNAKE_CASE,_SCREAMING_SNAKE_CASE,smooth_method=_SCREAMING_SNAKE_CASE,smooth_value=_SCREAMING_SNAKE_CASE,force=_SCREAMING_SNAKE_CASE,lowercase=_SCREAMING_SNAKE_CASE,use_effective_order=_SCREAMING_SNAKE_CASE,)
			return output.score






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





			'''simple docstring'''

			def 					lowerCAmelCase     (  self							:			Union[str, Any]	)      ->		Any:
						return datasets.MetricInfo(
						    description=_DESCRIPTION			,    citation=_CITATION			,    inputs_description=_KWARGS_DESCRIPTION			,    features=datasets.Features(
						        {
						            'predictions': datasets.Value('string'			,    id='sequence'	),
						            'references': datasets.Sequence(datasets.Value('string'			,    id='sequence'	)			,    id='references'	),
						        }	)			,    codebase_urls=[
						        'https://github.com/huggingface/transformers/blob/master/src/transformers/data/metrics/squad_metrics.py',
						        'https://github.com/cocoxu/simplification/blob/master/SARI.py',
						        'https://github.com/tensorflow/tensor2tensor/blob/master/tensor2tensor/utils/sari_hook.py',
						        'https://github.com/mjpost/sacreBLEU',
						    ]			,    reference_urls=[
						        'https://www.aclweb.org/anthology/Q16-1029.pdf',
						        'https://github.com/mjpost/sacreBLEU',
						        'https://en.wikipedia.org/wiki/BLEU',
						        'https://towardsdatascience.com/evaluating-text-output-in-nlp-bleu-at-your-own-risk-e8609665a213',
						    ]			,    )

			def 					lowerCAmelCase     (  self							:			List[Any]			,    lowerCAmelCase_							:			Optional[int]			,    lowerCAmelCase_							:			List[Any]			,    lowerCAmelCase_							:			str	)      ->		Any:
						__A=	{}
						result.update({'sari': compute_sari(sources=lowerCAmelCase_			,    predictions=lowerCAmelCase_			,    references=lowerCAmelCase_	)}	)
						result.update({'sacrebleu': compute_sacrebleu(predictions=lowerCAmelCase_			,    references=lowerCAmelCase_	)}	)
						result.update({'exact': compute_em(predictions=lowerCAmelCase_			,    references=lowerCAmelCase_	)}	)
						return result







'''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	)



