


from __future__ import annotations

import random
import unittest

from transformers import TransfoXLConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
     import tensorflow as tf

     from transformers import (
         TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
         TFTransfoXLForSequenceClassification,
         TFTransfoXLLMHeadModel,
         TFTransfoXLModel,
     )






class   _lowerCamelCase :




       """simple docstring"""



       def __init__(      self				,       _SCREAMING_SNAKE_CASE				,       )->Optional[int]:




         '''simple docstring'''





         A_      :				List[str]		     =					parent
         A_      :				Optional[int]		     =					13
         A_      :				Dict		     =					7
         A_      :				Dict		     =					30
         A_      :				str		     =					self.seq_length + self.mem_len
         A_      :				Dict		     =					15
         A_      :				Optional[Any]		     =					True
         A_      :				Any		     =					True
         A_      :				Tuple		     =					99
         A_      :				List[str]		     =					[10, 50, 80]
         A_      :				List[str]		     =					32
         A_      :				Tuple		     =					32
         A_      :				Optional[int]		     =					4
         A_      :				Optional[int]		     =					8
         A_      :				List[str]		     =					128
         A_      :				int		     =					2
         A_      :				Optional[int]		     =					2
         A_      :				Dict		     =					None
         A_      :				Union[str, Any]		     =					1
         A_      :				int		     =					0
         A_      :				str		     =					3
         A_      :				int		     =					self.vocab_size - 1
         A_      :				int		     =					0.0_1



       def        _snake_case       (      self		)->Tuple:




         '''simple docstring'''





         A_      :				Dict		     =					ids_tensor([self.batch_size, self.seq_length]				,       self.vocab_size		)
         A_      :				Any		     =					ids_tensor([self.batch_size, self.seq_length]				,       self.vocab_size		)

         A_      :				Dict		     =					None
         if self.use_labels:
           A_      :				Union[str, Any]		     =					ids_tensor([self.batch_size, self.seq_length]				,       self.vocab_size		)

         A_      :				int		     =					TransfoXLConfig(
             vocab_size=self.vocab_size				,       mem_len=self.mem_len				,       clamp_len=self.clamp_len				,       cutoffs=self.cutoffs				,       d_model=self.hidden_size				,       d_embed=self.d_embed				,       n_head=self.num_attention_heads				,       d_head=self.d_head				,       d_inner=self.d_inner				,       div_val=self.div_val				,       n_layer=self.num_hidden_layers				,       eos_token_id=self.eos_token_id				,       pad_token_id=self.vocab_size - 1				,       init_range=self.init_range				,       num_labels=self.num_labels				,       )

         return (config, input_ids_a, input_ids_a, lm_labels)



       def        _snake_case       (      self		)->Optional[int]:




         '''simple docstring'''





         random.seed(self.seed		)
         tf.random.set_seed(self.seed		)



       def        _snake_case       (      self				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)->Optional[int]:




         '''simple docstring'''





         A_      :				Tuple		     =					TFTransfoXLModel(_SCREAMING_SNAKE_CASE		)

         A_     ,       A_      :				Optional[Any]		     =					model(_SCREAMING_SNAKE_CASE		).to_tuple()

         A_      :				List[Any]		     =					{'''input_ids''': input_ids_a, '''mems''': mems_a}

         A_     ,       A_      :				Tuple		     =					model(_SCREAMING_SNAKE_CASE		).to_tuple()

         self.parent.assertEqual(hidden_states_a.shape				,       (self.batch_size, self.seq_length, self.hidden_size)		)
         self.parent.assertEqual(hidden_states_a.shape				,       (self.batch_size, self.seq_length, self.hidden_size)		)
         self.parent.assertListEqual(
             [mem.shape for mem in mems_a]				,       [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers				,       )
         self.parent.assertListEqual(
             [mem.shape for mem in mems_a]				,       [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers				,       )



       def        _snake_case       (      self				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)->int:




         '''simple docstring'''





         A_      :				Optional[int]		     =					TFTransfoXLLMHeadModel(_SCREAMING_SNAKE_CASE		)

         A_     ,       A_      :				List[Any]		     =					model(_SCREAMING_SNAKE_CASE		).to_tuple()

         A_      :				Any		     =					{'''input_ids''': input_ids_a, '''labels''': lm_labels}
         A_     ,       A_      :				str		     =					model(_SCREAMING_SNAKE_CASE		).to_tuple()

         A_     ,       A_      :				Union[str, Any]		     =					model([input_ids_a, mems_a]		).to_tuple()

         A_      :				List[Any]		     =					{'''input_ids''': input_ids_a, '''mems''': mems_a, '''labels''': lm_labels}

         A_     ,       A_      :				Optional[int]		     =					model(_SCREAMING_SNAKE_CASE		).to_tuple()

         self.parent.assertEqual(lm_logits_a.shape				,       (self.batch_size, self.seq_length, self.vocab_size)		)
         self.parent.assertListEqual(
             [mem.shape for mem in mems_a]				,       [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers				,       )

         self.parent.assertEqual(lm_logits_a.shape				,       (self.batch_size, self.seq_length, self.vocab_size)		)
         self.parent.assertListEqual(
             [mem.shape for mem in mems_a]				,       [(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers				,       )



       def        _snake_case       (      self				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)->int:




         '''simple docstring'''





         A_      :				List[Any]		     =					TFTransfoXLForSequenceClassification(_SCREAMING_SNAKE_CASE		)
         A_      :				Any		     =					model(_SCREAMING_SNAKE_CASE		)
         self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.num_labels)		)







       def        _snake_case       (      self		)->Optional[int]:




         '''simple docstring'''





         A_      :				int		     =					self.prepare_config_and_inputs()
         ((A_)     ,       (A_)     ,       (A_)     ,       (A_))      :				Optional[int]		     =					config_and_inputs
         A_      :				Any		     =					{'''input_ids''': input_ids_a}
         return config, inputs_dict






@require_tf
class   _lowerCamelCase (					UpperCamelCase					,							UpperCamelCase					,							unittest.TestCase			):




       """simple docstring"""
       snake_case      =    (
           (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
       )
       snake_case      =    () if is_tf_available() else ()
       snake_case      =    (
           {
               "feature-extraction": TFTransfoXLModel,
               "text-classification": TFTransfoXLForSequenceClassification,
               "text-generation": TFTransfoXLLMHeadModel,
               "zero-shot": TFTransfoXLForSequenceClassification,
           }
           if is_tf_available()
           else {}
       )
       # TODO: add this test when TFTransfoXLLMHead has a linear output layer implemented
       snake_case      =    False
       snake_case      =    False
       snake_case      =    False
       snake_case      =    False



       def        _snake_case       (      self				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE		)->Tuple:




         '''simple docstring'''





         if pipeline_test_casse_name == "TextGenerationPipelineTests":
           # Get `ValueError: AttributeError: 'NoneType' object has no attribute 'new_ones'` or `AssertionError`.
           # `TransfoXLConfig` was never used in pipeline tests: cannot create a simple
           # tokenizer.
           return True

         return False



       def        _snake_case       (      self		)->List[str]:




         '''simple docstring'''





         A_      :				str		     =					TFTransfoXLModelTester(self		)
         A_      :				List[Any]		     =					ConfigTester(self				,       config_class=_SCREAMING_SNAKE_CASE				,       d_embed=37		)



       def        _snake_case       (      self		)->Optional[int]:




         '''simple docstring'''





         self.config_tester.run_common_tests()



       def        _snake_case       (      self		)->int:




         '''simple docstring'''





         self.model_tester.set_seed()
         A_      :				int		     =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_model(*_SCREAMING_SNAKE_CASE		)



       def        _snake_case       (      self		)->Union[str, Any]:




         '''simple docstring'''





         self.model_tester.set_seed()
         A_      :				Dict		     =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_lm_head(*_SCREAMING_SNAKE_CASE		)



       def        _snake_case       (      self		)->int:




         '''simple docstring'''





         A_      :				Union[str, Any]		     =					self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*_SCREAMING_SNAKE_CASE		)



       def        _snake_case       (      self		)->int:




         '''simple docstring'''





         A_     ,       A_      :				List[str]		     =					self.model_tester.prepare_config_and_inputs_for_common()
         A_      :				int		     =					[TFTransfoXLForSequenceClassification]

         for model_class in self.all_model_classes:
           A_      :				Optional[int]		     =					model_class(_SCREAMING_SNAKE_CASE		)
           assert isinstance(model.get_input_embeddings()				,       tf.keras.layers.Layer		)
           if model_class in list_other_models_with_output_ebd:
             A_      :				Optional[int]		     =					model.get_output_embeddings()
             assert isinstance(_SCREAMING_SNAKE_CASE				,       tf.keras.layers.Layer		)
             A_      :				Tuple		     =					model.get_bias()
             assert name is None
           else:
             A_      :				Any		     =					model.get_output_embeddings()
             assert x is None
             A_      :				List[Any]		     =					model.get_bias()
             assert name is None



       def        _snake_case       (      self		)->Tuple:




         '''simple docstring'''





         pass



       @slow
       def        _snake_case       (      self		)->str:




         '''simple docstring'''





         for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           A_      :				Any		     =					TFTransfoXLModel.from_pretrained(_SCREAMING_SNAKE_CASE		)
           self.assertIsNotNone(_SCREAMING_SNAKE_CASE		)







       @unittest.skip(reason='''This model doesn\'t play well with fit() due to not returning a single loss.'''		)
       def        _snake_case       (      self		)->Optional[Any]:




         '''simple docstring'''





         pass






@require_tf
class   _lowerCamelCase (					unittest.TestCase			):




       """simple docstring"""



       @unittest.skip('''Skip test until #12651 is resolved.'''		)
       @slow
       def        _snake_case       (      self		)->Optional[int]:




         '''simple docstring'''





         A_      :				Union[str, Any]		     =					TFTransfoXLLMHeadModel.from_pretrained('''transfo-xl-wt103'''		)
         # fmt: off
         A_      :				Optional[Any]		     =					tf.convert_to_tensor([[33,1297,2,1,1009,4,1109,1_1739,4762,358,5,25,245,22,1706,17,2_0098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,3,6224,831,1_6002,2,8,603,7_8967,2_9546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,2_9546,54,8,3609,5,5_7211,49,4,1,277,18,8,1755,1_5691,3,341,25,416,693,4_2573,71,17,401,94,31,1_7919,2,2_9546,7873,18,1,435,23,1_1011,755,5,5167,3,7983,98,84,2,2_9546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,2_9546,824,1400,1868,2,19,160,2,311,8,5496,2,2_0920,17,25,1_5097,3,24,24,0]]				,       dtype=tf.intaa		)  # noqa: E231
         # fmt: on
         #  In 1991 , the remains of Russian Tsar Nicholas II and his family
         #  ( except for Alexei and Maria ) are discovered .
         #  The voice of Nicholas's young son , Tsarevich Alexei Nikolaevich , narrates the
         #  remainder of the story . 1883 Western Siberia ,
         #  a young Grigori Rasputin is asked by his father and a group of men to perform magic .
         #  Rasputin has a vision and denounces one of the men as a horse thief . Although his
         #  father initially slaps him for making such an accusation , Rasputin watches as the
         #  man is chased outside and beaten . Twenty years later , Rasputin sees a vision of
         #  the Virgin Mary , prompting him to become a priest . Rasputin quickly becomes famous ,
         #  with people , even a bishop , begging for his blessing . <eod> </s> <eos>

         # fmt: off
         A_      :				str		     =					[33,1297,2,1,1009,4,1109,1_1739,4762,358,5,25,245,22,1706,17,2_0098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,3,6224,831,1_6002,2,8,603,7_8967,2_9546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,2_9546,54,8,3609,5,5_7211,49,4,1,277,18,8,1755,1_5691,3,341,25,416,693,4_2573,71,17,401,94,31,1_7919,2,2_9546,7873,18,1,435,23,1_1011,755,5,5167,3,7983,98,84,2,2_9546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,2_9546,824,1400,1868,2,19,160,2,311,8,5496,2,2_0920,17,25,1_5097,3,24,24,0,33,1,1857,2,1,1009,4,1109,1_1739,4762,358,5,25,245,28,1110,3,13,1041,4,24,603,490,2,7_1477,2_0098,10_4447,2,2_0961,1,2604,4,1,329,3,0]  # noqa: E231
         # fmt: on
         #  In 1991, the remains of Russian Tsar Nicholas II and his family (
         #  except for Alexei and Maria ) are discovered. The voice of young son,
         #  Tsarevich Alexei Nikolaevich, narrates the remainder of the story.
         #  1883 Western Siberia, a young Grigori Rasputin is asked by his father
         #  and a group of men to perform magic. Rasputin has a vision and
         #  denounces one of the men as a horse thief. Although his father initially
         #  slaps him for making such an accusation, Rasputin watches as the man
         #  is chased outside and beaten. Twenty years later, Rasputin sees a vision
         #  of the Virgin Mary, prompting him to become a priest.
         #  Rasputin quickly becomes famous, with people, even a bishop, begging for
         #  his blessing. <unk> <unk> <eos> In the 1990s, the remains of Russian Tsar
         # Nicholas II and his family were discovered. The voice of <unk> young son,
         # Tsarevich Alexei Nikolaevich, narrates the remainder of the story.<eos>

         A_      :				Optional[int]		     =					model.generate(_SCREAMING_SNAKE_CASE				,       max_length=200				,       do_sample=_SCREAMING_SNAKE_CASE		)
         self.assertListEqual(output_ids[0].numpy().tolist()				,       _SCREAMING_SNAKE_CASE		)








from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxSeqaSeqConfigWithPast
from ...utils import logging


UpperCamelCase								=	logging.get_logger(__name__)

UpperCamelCase								=	{
    """t5-small""": """https://huggingface.co/t5-small/resolve/main/config.json""",
    """t5-base""": """https://huggingface.co/t5-base/resolve/main/config.json""",
    """t5-large""": """https://huggingface.co/t5-large/resolve/main/config.json""",
    """t5-3b""": """https://huggingface.co/t5-3b/resolve/main/config.json""",
    """t5-11b""": """https://huggingface.co/t5-11b/resolve/main/config.json""",
}






class   _lowerCamelCase (					UpperCamelCase			):




       """simple docstring"""
       snake_case      =    "t5"
       snake_case      =    ["past_key_values"]
       snake_case      =    {"hidden_size": "d_model", "num_attention_heads": "num_heads", "num_hidden_layers": "num_layers"}



       def __init__(      self				,       _SCREAMING_SNAKE_CASE=3_2128				,       _SCREAMING_SNAKE_CASE=512				,       _SCREAMING_SNAKE_CASE=64				,       _SCREAMING_SNAKE_CASE=2048				,       _SCREAMING_SNAKE_CASE=6				,       _SCREAMING_SNAKE_CASE=None				,       _SCREAMING_SNAKE_CASE=8				,       _SCREAMING_SNAKE_CASE=32				,       _SCREAMING_SNAKE_CASE=128				,       _SCREAMING_SNAKE_CASE=0.1				,       _SCREAMING_SNAKE_CASE=1e-6				,       _SCREAMING_SNAKE_CASE=1.0				,       _SCREAMING_SNAKE_CASE="relu"				,       _SCREAMING_SNAKE_CASE=True				,       _SCREAMING_SNAKE_CASE=True				,       _SCREAMING_SNAKE_CASE=0				,       _SCREAMING_SNAKE_CASE=1				,       **_SCREAMING_SNAKE_CASE				,       )->List[Any]:




         '''simple docstring'''





         A_      :				List[Any]		     =					vocab_size
         A_      :				int		     =					d_model
         A_      :				Optional[Any]		     =					d_kv
         A_      :				str		     =					d_ff
         A_      :				int		     =					num_layers
         A_      :				Any		     =					(
             num_decoder_layers if num_decoder_layers is not None else self.num_layers
         )  # default = symmetry
         A_      :				Optional[Any]		     =					num_heads
         A_      :				Union[str, Any]		     =					relative_attention_num_buckets
         A_      :				Dict		     =					relative_attention_max_distance
         A_      :				List[str]		     =					dropout_rate
         A_      :				Dict		     =					layer_norm_epsilon
         A_      :				str		     =					initializer_factor
         A_      :				Dict		     =					feed_forward_proj
         A_      :				int		     =					use_cache

         A_      :				Optional[int]		     =					self.feed_forward_proj.split('''-'''		)
         A_      :				Optional[Any]		     =					act_info[-1]
         A_      :				Optional[Any]		     =					act_info[0] == '''gated'''

         if len(_SCREAMING_SNAKE_CASE		) > 1 and act_info[0] != "gated" or len(_SCREAMING_SNAKE_CASE		) > 2:
           raise ValueError(
               F'''`feed_forward_proj`: {feed_forward_proj} is not a valid activation function of the dense layer.'''
               '''Please make sure `feed_forward_proj` is of the format `gated-{ACT_FN}` or `{ACT_FN}`, e.g. '''
               '''\'gated-gelu\' or \'relu\''''		)

         # for backwards compatibility
         if feed_forward_proj == "gated-gelu":
           A_      :				Tuple		     =					'''gelu_new'''

         super().__init__(
             pad_token_id=_SCREAMING_SNAKE_CASE				,       eos_token_id=_SCREAMING_SNAKE_CASE				,       is_encoder_decoder=_SCREAMING_SNAKE_CASE				,       **_SCREAMING_SNAKE_CASE				,       )






class   _lowerCamelCase (					UpperCamelCase			):




       """simple docstring"""



       @property
       def        _snake_case       (      self		)->Mapping[str, Mapping[int, str]]:




         '''simple docstring'''





         A_      :				Union[str, Any]		     =					{
             '''input_ids''': {0: '''batch''', 1: '''encoder_sequence'''},
             '''attention_mask''': {0: '''batch''', 1: '''encoder_sequence'''},
         }
         if self.use_past:
           A_      :				List[str]		     =					'''past_encoder_sequence + sequence'''
           A_      :				Optional[int]		     =					{0: '''batch'''}
           A_      :				str		     =					{0: '''batch''', 1: '''past_decoder_sequence + sequence'''}
         else:
           A_      :				Optional[int]		     =					{0: '''batch''', 1: '''decoder_sequence'''}
           A_      :				List[Any]		     =					{0: '''batch''', 1: '''decoder_sequence'''}

         if self.use_past:
           self.fill_with_past_key_values_(_SCREAMING_SNAKE_CASE				,       direction='''inputs'''		)

         return common_inputs







       @property
       def        _snake_case       (      self		)->int:




         '''simple docstring'''





         return 13




