

import unittest

from transformers import (
    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
    TextClassificationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, nested_simplify, require_tf, require_torch, slow

from .test_pipelines_common import ANY


# These 2 model types require different inputs than those of the usual text models.
a		={"""LayoutLMv2Config""", """LayoutLMv3Config"""}






@is_pipeline_test
class 	A_		(	unittest.TestCase    ):
							_UpperCAmelCase   :  Dict										=				MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING
							_UpperCAmelCase   :  Optional[int]										=				TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING

							if model_mapping is not None:
														_UpperCAmelCase   :  Optional[Any]										=				{config: model for config, model in model_mapping.items() if config.__name__ not in _TO_SKIP}
							if tf_model_mapping is not None:
														_UpperCAmelCase   :  Optional[int]										=				{
														    config: model for config, model in tf_model_mapping.items() if config.__name__ not in _TO_SKIP
														}
							@require_torch
							def    lowerCAmelCase					(		self		:      Dict):
								__lowerCamelCase    :    List[str] 	=			pipeline(
								    task='text-classification'       ,model='hf-internal-testing/tiny-random-distilbert'       ,framework='pt')

								__lowerCamelCase    :    Union[str, Any] 	=			text_classifier('This is great !')
								self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE__)       ,[{'label': 'LABEL_0', 'score': 0.504}])

								__lowerCamelCase    :    int 	=			text_classifier('This is great !'       ,top_k=2)
								self.assertEqual(
								    nested_simplify(SCREAMING_SNAKE_CASE__)       ,[{'label': 'LABEL_0', 'score': 0.504}, {'label': 'LABEL_1', 'score': 0.496}])

								__lowerCamelCase    :    Dict 	=			text_classifier(['This is great !', 'This is bad']       ,top_k=2)
								self.assertEqual(
								    nested_simplify(SCREAMING_SNAKE_CASE__)       ,[
								        [{'label': 'LABEL_0', 'score': 0.504}, {'label': 'LABEL_1', 'score': 0.496}],
								        [{'label': 'LABEL_0', 'score': 0.504}, {'label': 'LABEL_1', 'score': 0.496}],
								    ]       ,)

								__lowerCamelCase    :    List[str] 	=			text_classifier('This is great !'       ,top_k=1)
								self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE__)       ,[{'label': 'LABEL_0', 'score': 0.504}])

								# Legacy behavior
								__lowerCamelCase    :    Optional[Any] 	=			text_classifier('This is great !'       ,return_all_scores=SCREAMING_SNAKE_CASE__)
								self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE__)       ,[{'label': 'LABEL_0', 'score': 0.504}])

								__lowerCamelCase    :    Union[str, Any] 	=			text_classifier('This is great !'       ,return_all_scores=SCREAMING_SNAKE_CASE__)
								self.assertEqual(
								    nested_simplify(SCREAMING_SNAKE_CASE__)       ,[[{'label': 'LABEL_0', 'score': 0.504}, {'label': 'LABEL_1', 'score': 0.496}]])

								__lowerCamelCase    :    Dict 	=			text_classifier(['This is great !', 'Something else']       ,return_all_scores=SCREAMING_SNAKE_CASE__)
								self.assertEqual(
								    nested_simplify(SCREAMING_SNAKE_CASE__)       ,[
								        [{'label': 'LABEL_0', 'score': 0.504}, {'label': 'LABEL_1', 'score': 0.496}],
								        [{'label': 'LABEL_0', 'score': 0.504}, {'label': 'LABEL_1', 'score': 0.496}],
								    ]       ,)

								__lowerCamelCase    :    Optional[Any] 	=			text_classifier(['This is great !', 'Something else']       ,return_all_scores=SCREAMING_SNAKE_CASE__)
								self.assertEqual(
								    nested_simplify(SCREAMING_SNAKE_CASE__)       ,[
								        {'label': 'LABEL_0', 'score': 0.504},
								        {'label': 'LABEL_0', 'score': 0.504},
								    ]       ,)
							@require_torch
							def    lowerCAmelCase					(		self		:      Dict):
								import torch

								__lowerCamelCase    :    Any 	=			pipeline(
								    task='text-classification'       ,model='hf-internal-testing/tiny-random-distilbert'       ,framework='pt'       ,device=torch.device('cpu')       ,)

								__lowerCamelCase    :    Optional[Any] 	=			text_classifier('This is great !')
								self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE__)       ,[{'label': 'LABEL_0', 'score': 0.504}])
							@require_tf
							def    lowerCAmelCase					(		self		:      List[Any]):
								__lowerCamelCase    :    List[str] 	=			pipeline(
								    task='text-classification'       ,model='hf-internal-testing/tiny-random-distilbert'       ,framework='tf')

								__lowerCamelCase    :    List[Any] 	=			text_classifier('This is great !')
								self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE__)       ,[{'label': 'LABEL_0', 'score': 0.504}])
							@slow
							@require_torch
							def    lowerCAmelCase					(		self		:      Tuple):
								__lowerCamelCase    :    Optional[Any] 	=			pipeline('text-classification')

								__lowerCamelCase    :    Optional[Any] 	=			text_classifier('This is great !')
								self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE__)       ,[{'label': 'POSITIVE', 'score': 1.0}])
								__lowerCamelCase    :    str 	=			text_classifier('This is bad !')
								self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE__)       ,[{'label': 'NEGATIVE', 'score': 1.0}])
								__lowerCamelCase    :    Union[str, Any] 	=			text_classifier('Birds are a type of animal')
								self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE__)       ,[{'label': 'POSITIVE', 'score': 0.988}])
							@slow
							@require_tf
							def    lowerCAmelCase					(		self		:      str):
								__lowerCamelCase    :    str 	=			pipeline('text-classification'       ,framework='tf')

								__lowerCamelCase    :    List[str] 	=			text_classifier('This is great !')
								self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE__)       ,[{'label': 'POSITIVE', 'score': 1.0}])
								__lowerCamelCase    :    int 	=			text_classifier('This is bad !')
								self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE__)       ,[{'label': 'NEGATIVE', 'score': 1.0}])
								__lowerCamelCase    :    Optional[Any] 	=			text_classifier('Birds are a type of animal')
								self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE__)       ,[{'label': 'POSITIVE', 'score': 0.988}])
							def    lowerCAmelCase					(		self		:      Tuple       ,SCREAMING_SNAKE_CASE__		:      str       ,SCREAMING_SNAKE_CASE__		:      Tuple       ,SCREAMING_SNAKE_CASE__		:      str):
								__lowerCamelCase    :    Optional[Any] 	=			TextClassificationPipeline(model=SCREAMING_SNAKE_CASE__       ,tokenizer=SCREAMING_SNAKE_CASE__)
								return text_classifier, ["HuggingFace is in", "This is another test"]


							def    lowerCAmelCase					(		self		:      str       ,SCREAMING_SNAKE_CASE__		:      int       ,SCREAMING_SNAKE_CASE__		:      Optional[int]):
								__lowerCamelCase    :    Dict 	=			text_classifier.model
								# Small inputs because BartTokenizer tiny has maximum position embeddings = 22
								__lowerCamelCase    :    List[Any] 	=			'HuggingFace is in'
								__lowerCamelCase    :    Optional[Any] 	=			text_classifier(SCREAMING_SNAKE_CASE__)

								self.assertEqual(nested_simplify(SCREAMING_SNAKE_CASE__)       ,[{'label': ANY(SCREAMING_SNAKE_CASE__), 'score': ANY(SCREAMING_SNAKE_CASE__)}])
								self.assertTrue(outputs[0]['label'] in model.config.idalabel.values())

								__lowerCamelCase    :    Union[str, Any] 	=			['HuggingFace is in ', 'Paris is in France']
								__lowerCamelCase    :    Union[str, Any] 	=			text_classifier(SCREAMING_SNAKE_CASE__)
								self.assertEqual(
								    nested_simplify(SCREAMING_SNAKE_CASE__)       ,[{'label': ANY(SCREAMING_SNAKE_CASE__), 'score': ANY(SCREAMING_SNAKE_CASE__)}, {'label': ANY(SCREAMING_SNAKE_CASE__), 'score': ANY(SCREAMING_SNAKE_CASE__)}]       ,)
								self.assertTrue(outputs[0]['label'] in model.config.idalabel.values())
								self.assertTrue(outputs[1]['label'] in model.config.idalabel.values())

								# Forcing to get all results with `top_k=None`
								# This is NOT the legacy format
								__lowerCamelCase    :    List[Any] 	=			text_classifier(SCREAMING_SNAKE_CASE__       ,top_k=SCREAMING_SNAKE_CASE__)
								__lowerCamelCase    :    int 	=			len(model.config.idalabel.values())
								self.assertEqual(
								    nested_simplify(SCREAMING_SNAKE_CASE__)       ,[[{'label': ANY(SCREAMING_SNAKE_CASE__), 'score': ANY(SCREAMING_SNAKE_CASE__)}] * N, [{'label': ANY(SCREAMING_SNAKE_CASE__), 'score': ANY(SCREAMING_SNAKE_CASE__)}] * N]       ,)

								__lowerCamelCase    :    Any 	=			{'text': 'HuggingFace is in ', 'text_pair': 'Paris is in France'}
								__lowerCamelCase    :    List[Any] 	=			text_classifier(SCREAMING_SNAKE_CASE__)
								self.assertEqual(
								    nested_simplify(SCREAMING_SNAKE_CASE__)       ,{'label': ANY(SCREAMING_SNAKE_CASE__), 'score': ANY(SCREAMING_SNAKE_CASE__)}       ,)
								self.assertTrue(outputs['label'] in model.config.idalabel.values())

								# This might be used a text pair, but tokenizer + pipe interaction
								# makes it hard to understand that it's not using the pair properly
								# https://github.com/huggingface/transformers/issues/17305
								# We disabled this usage instead as it was outputting wrong outputs.
								__lowerCamelCase    :    List[str] 	=			[['HuggingFace is in ', 'Paris is in France']]
								with self.assertRaises(SCREAMING_SNAKE_CASE__):
									text_classifier(SCREAMING_SNAKE_CASE__)

								# This used to be valid for doing text pairs
								# We're keeping it working because of backward compatibility
								__lowerCamelCase    :    Optional[Any] 	=			text_classifier([[['HuggingFace is in ', 'Paris is in France']]])
								self.assertEqual(
								    nested_simplify(SCREAMING_SNAKE_CASE__)       ,[{'label': ANY(SCREAMING_SNAKE_CASE__), 'score': ANY(SCREAMING_SNAKE_CASE__)}]       ,)
								self.assertTrue(outputs[0]['label'] in model.config.idalabel.values())







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    ):
							@slow
							def    lowerCAmelCase					(		self		:      List[str]):
								# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
								for model_name in ["bert-base-uncased"]:
									__lowerCamelCase    :    Optional[int] 	=			AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    Tuple 	=			TFAutoModel.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    str 	=			AutoModel.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_tf=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
							@slow
							def    lowerCAmelCase					(		self		:      Optional[int]):
								# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
								for model_name in ["bert-base-uncased"]:
									__lowerCamelCase    :    str 	=			AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    Tuple 	=			TFAutoModelForPreTraining.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    str 	=			AutoModelForPreTraining.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_tf=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
							@slow
							def    lowerCAmelCase					(		self		:      Optional[int]):
								for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__lowerCamelCase    :    Union[str, Any] 	=			AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    Union[str, Any] 	=			TFAutoModelForCausalLM.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
									__lowerCamelCase	,			__lowerCamelCase    :    Union[str, Any] 	=			TFAutoModelForCausalLM.from_pretrained(
									    SCREAMING_SNAKE_CASE__       ,output_loading_info=SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    List[Any] 	=			AutoModelForCausalLM.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_tf=SCREAMING_SNAKE_CASE__)
									__lowerCamelCase	,			__lowerCamelCase    :    Any 	=			AutoModelForCausalLM.from_pretrained(
									    SCREAMING_SNAKE_CASE__       ,output_loading_info=SCREAMING_SNAKE_CASE__       ,from_tf=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
							@slow
							def    lowerCAmelCase					(		self		:      List[Any]):
								for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__lowerCamelCase    :    List[str] 	=			AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    List[str] 	=			TFAutoModelWithLMHead.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    Optional[Any] 	=			AutoModelWithLMHead.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_tf=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
							@slow
							def    lowerCAmelCase					(		self		:      Tuple):
								for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__lowerCamelCase    :    Optional[Any] 	=			AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    Optional[int] 	=			TFAutoModelForMaskedLM.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
									__lowerCamelCase	,			__lowerCamelCase    :    Dict 	=			TFAutoModelForMaskedLM.from_pretrained(
									    SCREAMING_SNAKE_CASE__       ,output_loading_info=SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    List[Any] 	=			AutoModelForMaskedLM.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_tf=SCREAMING_SNAKE_CASE__)
									__lowerCamelCase	,			__lowerCamelCase    :    Optional[Any] 	=			AutoModelForMaskedLM.from_pretrained(
									    SCREAMING_SNAKE_CASE__       ,output_loading_info=SCREAMING_SNAKE_CASE__       ,from_tf=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
							@slow
							def    lowerCAmelCase					(		self		:      str):
								for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__lowerCamelCase    :    Dict 	=			AutoConfig.from_pretrained(SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    Optional[Any] 	=			TFAutoModelForSeqaSeqLM.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
									__lowerCamelCase	,			__lowerCamelCase    :    List[str] 	=			TFAutoModelForSeqaSeqLM.from_pretrained(
									    SCREAMING_SNAKE_CASE__       ,output_loading_info=SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

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

									__lowerCamelCase    :    Optional[int] 	=			TFAutoModelForSequenceClassification.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

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

									__lowerCamelCase    :    str 	=			TFAutoModelForQuestionAnswering.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)

									__lowerCamelCase    :    Optional[int] 	=			AutoModelForQuestionAnswering.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_tf=SCREAMING_SNAKE_CASE__)
									self.assertIsNotNone(SCREAMING_SNAKE_CASE__)
									self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
							def    lowerCAmelCase					(		self		:      int):
								__lowerCamelCase    :    List[Any] 	=			TFAutoModelWithLMHead.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
								self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
								self.assertEqual(model.num_parameters()       ,1_4_4_1_0)
								self.assertEqual(model.num_parameters(only_trainable=SCREAMING_SNAKE_CASE__)       ,1_4_4_1_0)

								__lowerCamelCase    :    Union[str, Any] 	=			AutoModelWithLMHead.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_tf=SCREAMING_SNAKE_CASE__)
								self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
								self.assertEqual(model.num_parameters()       ,1_4_4_1_0)
								self.assertEqual(model.num_parameters(only_trainable=SCREAMING_SNAKE_CASE__)       ,1_4_4_1_0)


							def    lowerCAmelCase					(		self		:      Tuple):
								__lowerCamelCase    :    str 	=			TFAutoModelWithLMHead.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_pt=SCREAMING_SNAKE_CASE__)
								self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
								self.assertEqual(model.num_parameters()       ,1_4_4_1_0)
								self.assertEqual(model.num_parameters(only_trainable=SCREAMING_SNAKE_CASE__)       ,1_4_4_1_0)

								__lowerCamelCase    :    Optional[int] 	=			AutoModelWithLMHead.from_pretrained(SCREAMING_SNAKE_CASE__       ,from_tf=SCREAMING_SNAKE_CASE__)
								self.assertIsInstance(SCREAMING_SNAKE_CASE__       ,SCREAMING_SNAKE_CASE__)
								self.assertEqual(model.num_parameters()       ,1_4_4_1_0)
								self.assertEqual(model.num_parameters(only_trainable=SCREAMING_SNAKE_CASE__)       ,1_4_4_1_0)




