


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       UpperCAmelCase__							(     self		)					->			Optional[int]:




									"""simple docstring"""





									for model_name in ["bert-base-uncased"]:
																_UpperCAmelCase											=     AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE		)
																self.assertIsNotNone(_SCREAMING_SNAKE_CASE		)
																self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)

																_UpperCAmelCase											=     TFAutoModel.from_pretrained(_SCREAMING_SNAKE_CASE     ,       from_pt=_SCREAMING_SNAKE_CASE		)
																self.assertIsNotNone(_SCREAMING_SNAKE_CASE		)
																self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)

																_UpperCAmelCase											=     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       UpperCAmelCase__							(     self		)					->			str:




									"""simple docstring"""





									for model_name in ["bert-base-uncased"]:
																_UpperCAmelCase											=     AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE		)
																self.assertIsNotNone(_SCREAMING_SNAKE_CASE		)
																self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)

																_UpperCAmelCase											=     TFAutoModelForPreTraining.from_pretrained(_SCREAMING_SNAKE_CASE     ,       from_pt=_SCREAMING_SNAKE_CASE		)
																self.assertIsNotNone(_SCREAMING_SNAKE_CASE		)
																self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)

																_UpperCAmelCase											=     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       UpperCAmelCase__							(     self		)					->			int:




									"""simple docstring"""





									for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																_UpperCAmelCase											=     AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE		)
																self.assertIsNotNone(_SCREAMING_SNAKE_CASE		)
																self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)

																_UpperCAmelCase											=     TFAutoModelForCausalLM.from_pretrained(_SCREAMING_SNAKE_CASE     ,       from_pt=_SCREAMING_SNAKE_CASE		)
																_UpperCAmelCase						,			_UpperCAmelCase											=     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		)

																_UpperCAmelCase											=     AutoModelForCausalLM.from_pretrained(_SCREAMING_SNAKE_CASE     ,       from_tf=_SCREAMING_SNAKE_CASE		)
																_UpperCAmelCase						,			_UpperCAmelCase											=     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       UpperCAmelCase__							(     self		)					->			Optional[Any]:




									"""simple docstring"""





									for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																_UpperCAmelCase											=     AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE		)
																self.assertIsNotNone(_SCREAMING_SNAKE_CASE		)
																self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)

																_UpperCAmelCase											=     TFAutoModelWithLMHead.from_pretrained(_SCREAMING_SNAKE_CASE     ,       from_pt=_SCREAMING_SNAKE_CASE		)
																self.assertIsNotNone(_SCREAMING_SNAKE_CASE		)
																self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)

																_UpperCAmelCase											=     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       UpperCAmelCase__							(     self		)					->			Dict:




									"""simple docstring"""





									for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																_UpperCAmelCase											=     AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE		)
																self.assertIsNotNone(_SCREAMING_SNAKE_CASE		)
																self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)

																_UpperCAmelCase											=     TFAutoModelForMaskedLM.from_pretrained(_SCREAMING_SNAKE_CASE     ,       from_pt=_SCREAMING_SNAKE_CASE		)
																_UpperCAmelCase						,			_UpperCAmelCase											=     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		)

																_UpperCAmelCase											=     AutoModelForMaskedLM.from_pretrained(_SCREAMING_SNAKE_CASE     ,       from_tf=_SCREAMING_SNAKE_CASE		)
																_UpperCAmelCase						,			_UpperCAmelCase											=     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       UpperCAmelCase__							(     self		)					->			Optional[int]:




									"""simple docstring"""





									for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																_UpperCAmelCase											=     AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE		)
																self.assertIsNotNone(_SCREAMING_SNAKE_CASE		)
																self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)

																_UpperCAmelCase											=     TFAutoModelForSeqaSeqLM.from_pretrained(_SCREAMING_SNAKE_CASE     ,       from_pt=_SCREAMING_SNAKE_CASE		)
																_UpperCAmelCase						,			_UpperCAmelCase											=     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		)

																_UpperCAmelCase											=     AutoModelForSeqaSeqLM.from_pretrained(_SCREAMING_SNAKE_CASE     ,       from_tf=_SCREAMING_SNAKE_CASE		)
																_UpperCAmelCase						,			_UpperCAmelCase											=     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       UpperCAmelCase__							(     self		)					->			Optional[int]:




									"""simple docstring"""





									for model_name in ["bert-base-uncased"]:
																_UpperCAmelCase											=     AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE		)
																self.assertIsNotNone(_SCREAMING_SNAKE_CASE		)
																self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)

																_UpperCAmelCase											=     TFAutoModelForSequenceClassification.from_pretrained(_SCREAMING_SNAKE_CASE     ,       from_pt=_SCREAMING_SNAKE_CASE		)
																self.assertIsNotNone(_SCREAMING_SNAKE_CASE		)
																self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)

																_UpperCAmelCase											=     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       UpperCAmelCase__							(     self		)					->			Union[str, Any]:




									"""simple docstring"""





									for model_name in ["bert-base-uncased"]:
																_UpperCAmelCase											=     AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE		)
																self.assertIsNotNone(_SCREAMING_SNAKE_CASE		)
																self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)

																_UpperCAmelCase											=     TFAutoModelForQuestionAnswering.from_pretrained(_SCREAMING_SNAKE_CASE     ,       from_pt=_SCREAMING_SNAKE_CASE		)
																self.assertIsNotNone(_SCREAMING_SNAKE_CASE		)
																self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)

																_UpperCAmelCase											=     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       UpperCAmelCase__							(     self		)					->			int:




									"""simple docstring"""





									_UpperCAmelCase											=     TFAutoModelWithLMHead.from_pretrained(_SCREAMING_SNAKE_CASE     ,       from_pt=_SCREAMING_SNAKE_CASE		)
									self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)
									self.assertEqual(model.num_parameters()     ,       14410		)
									self.assertEqual(model.num_parameters(only_trainable=_SCREAMING_SNAKE_CASE		)     ,       14410		)

									_UpperCAmelCase											=     AutoModelWithLMHead.from_pretrained(_SCREAMING_SNAKE_CASE     ,       from_tf=_SCREAMING_SNAKE_CASE		)
									self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)
									self.assertEqual(model.num_parameters()     ,       14410		)
									self.assertEqual(model.num_parameters(only_trainable=_SCREAMING_SNAKE_CASE		)     ,       14410		)






		def       UpperCAmelCase__							(     self		)					->			int:




									"""simple docstring"""





									_UpperCAmelCase											=     TFAutoModelWithLMHead.from_pretrained(_SCREAMING_SNAKE_CASE     ,       from_pt=_SCREAMING_SNAKE_CASE		)
									self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)
									self.assertEqual(model.num_parameters()     ,       14410		)
									self.assertEqual(model.num_parameters(only_trainable=_SCREAMING_SNAKE_CASE		)     ,       14410		)

									_UpperCAmelCase											=     AutoModelWithLMHead.from_pretrained(_SCREAMING_SNAKE_CASE     ,       from_tf=_SCREAMING_SNAKE_CASE		)
									self.assertIsInstance(_SCREAMING_SNAKE_CASE     ,       _SCREAMING_SNAKE_CASE		)
									self.assertEqual(model.num_parameters()     ,       14410		)
									self.assertEqual(model.num_parameters(only_trainable=_SCREAMING_SNAKE_CASE		)     ,       14410		)




from typing import Any

def 			lowerCAmelCase__					(     a__:						list     ,    a__:						list     ,    a__:						dict     ,    a__:						dict     ,    a__:						dict     ,    )    ->						list:


							'''simple docstring'''





							_validation(
							    a__     ,    a__     ,    a__     ,    a__     ,    a__     ,    )
							# Creates data structures and fill initial step
							_UpperCAmelCase											=     {}
							_UpperCAmelCase											=     {}
							for state in states_space:
														_UpperCAmelCase											=     observations_space[0]
														_UpperCAmelCase											=     (
														    initial_probabilities[state] * emission_probabilities[state][observation]
														)
														_UpperCAmelCase											=     None

							# Fills the data structure with the probabilities of
							# different transitions and pointers to previous states
							for o in range(1     ,    len(a__			)			):
														_UpperCAmelCase											=     observations_space[o]
														_UpperCAmelCase											=     observations_space[o - 1]
														for state in states_space:
																					# Calculates the argmax for probability function
																					_UpperCAmelCase											=     ''
																					_UpperCAmelCase											=     -1
																					for k_state in states_space:
																												_UpperCAmelCase											=     (
																												    probabilities[(k_state, prior_observation)]
																												    * transition_probabilities[k_state][state]
																												    * emission_probabilities[state][observation]
																												)
																												if probability > max_probability:
																																			_UpperCAmelCase											=     probability
																																			_UpperCAmelCase											=     k_state

            # Update probabilities and pointers dicts
																					_UpperCAmelCase											=     (
																					    probabilities[(arg_max, prior_observation)]
																					    * transition_probabilities[arg_max][state]
																					    * emission_probabilities[state][observation]
																					)

																					_UpperCAmelCase											=     arg_max

    # The final observation
							_UpperCAmelCase											=     observations_space[len(a__			) - 1]

							# argmax for given final observation
							_UpperCAmelCase											=     ''
							_UpperCAmelCase											=     -1
							for k_state in states_space:
														_UpperCAmelCase											=     probabilities[(k_state, final_observation)]
														if probability > max_probability:
																					_UpperCAmelCase											=     probability
																					_UpperCAmelCase											=     k_state
							_UpperCAmelCase											=     arg_max

							# Process pointers backwards
							_UpperCAmelCase											=     last_state
							_UpperCAmelCase											=     []
							for o in range(len(a__			) - 1     ,    -1     ,    -1			):
														result.append(a__			)
														_UpperCAmelCase											=     pointers[previous, observations_space[o]]
							result.reverse()

							return result

def 			lowerCAmelCase__					(     a__:						Any     ,    a__:						Any     ,    a__:						Any     ,    a__:						Any     ,    a__:						Any     ,    )    ->						None:


							'''simple docstring'''





							_validate_not_empty(
							    a__     ,    a__     ,    a__     ,    a__     ,    a__     ,    )
							_validate_lists(a__     ,    a__			)
							_validate_dicts(
							    a__     ,    a__     ,    a__			)

def 			lowerCAmelCase__					(     a__:						Any     ,    a__:						Any     ,    a__:						Any     ,    a__:						Any     ,    a__:						Any     ,    )    ->						None:


							'''simple docstring'''





							if not all(
							    [
							        observations_space,
							        states_space,
							        initial_probabilities,
							        transition_probabilities,
							        emission_probabilities,
							    ]			):
														raise ValueError('There\'s an empty parameter'			)

def 			lowerCAmelCase__					(     a__:						Any     ,    a__:						Any			)    ->						None:


							'''simple docstring'''





							_validate_list(a__     ,    'observations_space'			)
							_validate_list(a__     ,    'states_space'			)

def 			lowerCAmelCase__					(     a__:						Any     ,    a__:						str			)    ->						None:


							'''simple docstring'''





							if not isinstance(_object     ,    a__			):
														_UpperCAmelCase											=     F'''{var_name} must be a list'''
														raise ValueError(a__			)
							else:
														for x in _object:
																					if not isinstance(a__     ,    a__			):
																												_UpperCAmelCase											=     F'''{var_name} must be a list of strings'''
																												raise ValueError(a__			)

def 			lowerCAmelCase__					(     a__:						Any     ,    a__:						Any     ,    a__:						Any     ,    )    ->						None:


							'''simple docstring'''





							_validate_dict(a__     ,    'initial_probabilities'     ,    a__			)
							_validate_nested_dict(a__     ,    'transition_probabilities'			)
							_validate_nested_dict(a__     ,    'emission_probabilities'			)

def 			lowerCAmelCase__					(     a__:						Any     ,    a__:						str			)    ->						None:


							'''simple docstring'''





							_validate_dict(_object     ,    a__     ,    a__			)
							for x in _object.values():
														_validate_dict(a__     ,    a__     ,    a__     ,    a__			)

def 			lowerCAmelCase__					(     a__:						Any     ,    a__:						str     ,    a__:						type     ,    a__:						bool = False			)    ->						None:


							'''simple docstring'''





							if not isinstance(_object     ,    a__			):
														_UpperCAmelCase											=     F'''{var_name} must be a dict'''
														raise ValueError(a__			)
							if not all(isinstance(a__     ,    a__			) for x in _object			):
														_UpperCAmelCase											=     F'''{var_name} all keys must be strings'''
														raise ValueError(a__			)
							if not all(isinstance(a__     ,    a__			) for x in _object.values()			):
														_UpperCAmelCase											=     'nested dictionary ' if nested else ''
														_UpperCAmelCase											=     F'''{var_name} {nested_text}all values must be {value_type.__name__}'''
														raise ValueError(a__			)


if __name__ == "__main__":
		from doctest import testmod

		testmod()
