'''simple docstring'''




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    a__				:






     def __init__(			self		:		Dict  ,    a		:		int  ,    ):





         """simple docstring"""



         __lowerCamelCase          =  parent
         __lowerCamelCase          =  13
         __lowerCamelCase          =  7
         __lowerCamelCase          =  30
         __lowerCamelCase          =  self.seq_length + self.mem_len
         __lowerCamelCase          =  15
         __lowerCamelCase          =  True
         __lowerCamelCase          =  True
         __lowerCamelCase          =  99
         __lowerCamelCase          =  [10, 50, 80]
         __lowerCamelCase          =  32
         __lowerCamelCase          =  32
         __lowerCamelCase          =  4
         __lowerCamelCase          =  8
         __lowerCamelCase          =  1_28
         __lowerCamelCase          =  2
         __lowerCamelCase          =  2
         __lowerCamelCase          =  None
         __lowerCamelCase          =  1
         __lowerCamelCase          =  0
         __lowerCamelCase          =  3
         __lowerCamelCase          =  self.vocab_size - 1
         __lowerCamelCase          =  0.01






     def        SCREAMING_SNAKE_CASE__       (			self		:		Tuple   ):





         """simple docstring"""



         __lowerCamelCase          =  ids_tensor([self.batch_size, self.seq_length]  ,    self.vocab_size   )
         __lowerCamelCase          =  ids_tensor([self.batch_size, self.seq_length]  ,    self.vocab_size   )

         __lowerCamelCase          =  None
         if self.use_labels:
             __lowerCamelCase          =  ids_tensor([self.batch_size, self.seq_length]  ,    self.vocab_size   )

         __lowerCamelCase          =  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        SCREAMING_SNAKE_CASE__       (			self		:		Optional[Any]   ):





         """simple docstring"""



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






     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[Any]  ,    a		:		List[Any]  ,    a		:		List[str]  ,    a		:		Any  ,    a		:		Any   ):





         """simple docstring"""



         __lowerCamelCase          =  TFTransfoXLModel(a   )

         __lowerCamelCase     ,  __lowerCamelCase          =  model(a   ).to_tuple()

         __lowerCamelCase          =  {'''input_ids''': input_ids_a, '''mems''': mems_a}

         __lowerCamelCase     ,  __lowerCamelCase          =  model(a   ).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        SCREAMING_SNAKE_CASE__       (			self		:		Optional[int]  ,    a		:		int  ,    a		:		Optional[Any]  ,    a		:		Optional[Any]  ,    a		:		List[str]   ):





         """simple docstring"""



         __lowerCamelCase          =  TFTransfoXLLMHeadModel(a   )

         __lowerCamelCase     ,  __lowerCamelCase          =  model(a   ).to_tuple()

         __lowerCamelCase          =  {'''input_ids''': input_ids_a, '''labels''': lm_labels}
         __lowerCamelCase     ,  __lowerCamelCase          =  model(a   ).to_tuple()

         __lowerCamelCase     ,  __lowerCamelCase          =  model([input_ids_a, mems_a]   ).to_tuple()

         __lowerCamelCase          =  {'''input_ids''': input_ids_a, '''mems''': mems_a, '''labels''': lm_labels}

         __lowerCamelCase     ,  __lowerCamelCase          =  model(a   ).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        SCREAMING_SNAKE_CASE__       (			self		:		List[str]  ,    a		:		List[str]  ,    a		:		Dict  ,    a		:		Any  ,    a		:		List[str]   ):





         """simple docstring"""



         __lowerCamelCase          =  TFTransfoXLForSequenceClassification(a   )
         __lowerCamelCase          =  model(a   )
         self.parent.assertEqual(result.logits.shape  ,    (self.batch_size, self.num_labels)   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		List[str]   ):





         """simple docstring"""



         __lowerCamelCase          =  self.prepare_config_and_inputs()
         ((__lowerCamelCase)     ,  (__lowerCamelCase)     ,  (__lowerCamelCase)     ,  (__lowerCamelCase))          =  config_and_inputs
         __lowerCamelCase          =  {'''input_ids''': input_ids_a}
         return config, inputs_dict




@require_tf
class    a__				(       UpperCAmelCase__							,       UpperCAmelCase__							,       unittest.TestCase			):
     lowerCamelCase  :					Optional[int]							=(
         (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
     )
     lowerCamelCase  :					Optional[int]							=() if is_tf_available() else ()
     lowerCamelCase  :					List[Any]							=(
         {
             "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
     lowerCamelCase  :					str							=False
     lowerCamelCase  :					Tuple							=False
     lowerCamelCase  :					List[str]							=False
     lowerCamelCase  :					Optional[Any]							=False






     def        SCREAMING_SNAKE_CASE__       (			self		:		Union[str, Any]  ,    a		:		Union[str, Any]  ,    a		:		Any  ,    a		:		Tuple  ,    a		:		Tuple  ,    a		:		Union[str, Any]   ):





         """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        SCREAMING_SNAKE_CASE__       (			self		:		List[str]   ):





         """simple docstring"""



         __lowerCamelCase          =  TFTransfoXLModelTester(self   )
         __lowerCamelCase          =  ConfigTester(self  ,    config_class=a  ,    d_embed=37   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[Any]   ):





         """simple docstring"""



         self.config_tester.run_common_tests()






     def        SCREAMING_SNAKE_CASE__       (			self		:		Tuple   ):





         """simple docstring"""



         self.model_tester.set_seed()
         __lowerCamelCase          =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_model(*a   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		str   ):





         """simple docstring"""



         self.model_tester.set_seed()
         __lowerCamelCase          =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_lm_head(*a   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		Optional[Any]   ):





         """simple docstring"""



         __lowerCamelCase          =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*a   )






     def        SCREAMING_SNAKE_CASE__       (			self		:		Union[str, Any]   ):





         """simple docstring"""



         __lowerCamelCase     ,  __lowerCamelCase          =  self.model_tester.prepare_config_and_inputs_for_common()
         __lowerCamelCase          =  [TFTransfoXLForSequenceClassification]

         for model_class in self.all_model_classes:
             __lowerCamelCase          =  model_class(a   )
             assert isinstance(model.get_input_embeddings()  ,    tf.keras.layers.Layer   )
             if model_class in list_other_models_with_output_ebd:
                 __lowerCamelCase          =  model.get_output_embeddings()
                 assert isinstance(a  ,    tf.keras.layers.Layer   )
                 __lowerCamelCase          =  model.get_bias()
                 assert name is None
             else:
                 __lowerCamelCase          =  model.get_output_embeddings()
                 assert x is None
                 __lowerCamelCase          =  model.get_bias()
                 assert name is None






     def        SCREAMING_SNAKE_CASE__       (			self		:		Any   ):





         """simple docstring"""



         pass






     @slow
     def        SCREAMING_SNAKE_CASE__       (			self		:		Union[str, Any]   ):





         """simple docstring"""



         for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             __lowerCamelCase          =  TFTransfoXLModel.from_pretrained(a   )
             self.assertIsNotNone(a   )






     @unittest.skip(reason='''This model doesn\'t play well with fit() due to not returning a single loss.'''   )
     def        SCREAMING_SNAKE_CASE__       (			self		:		List[str]   ):





         """simple docstring"""



         pass




@require_tf
class    a__				(       unittest.TestCase			):






     @unittest.skip('''Skip test until #12651 is resolved.'''   )
     @slow
     def        SCREAMING_SNAKE_CASE__       (			self		:		Union[str, Any]   ):





         """simple docstring"""



         __lowerCamelCase          =  TFTransfoXLLMHeadModel.from_pretrained('''transfo-xl-wt103'''   )
         # fmt: off
         __lowerCamelCase          =  tf.convert_to_tensor([[33,12_97,2,1,10_09,4,11_09,1_17_39,47_62,3_58,5,25,2_45,22,17_06,17,2_00_98,5,32_15,21,37,11_10,3,13,10_41,4,24,6_03,4_90,2,7_14_77,2_00_98,10_44_47,2,2_09_61,1,26_04,4,1,3_29,3,62_24,8_31,1_60_02,2,8,6_03,7_89_67,2_95_46,23,8_03,20,25,4_16,5,8,2_32,4,2_77,6,18_55,46_01,3,2_95_46,54,8,36_09,5,5_72_11,49,4,1,2_77,18,8,17_55,1_56_91,3,3_41,25,4_16,6_93,4_25_73,71,17,4_01,94,31,1_79_19,2,2_95_46,78_73,18,1,4_35,23,1_10_11,7_55,5,51_67,3,79_83,98,84,2,2_95_46,32_67,8,36_09,4,1,48_65,10_75,2,60_87,71,6,3_46,8,58_54,3,2_95_46,8_24,14_00,18_68,2,19,1_60,2,3_11,8,54_96,2,2_09_20,17,25,1_50_97,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
         __lowerCamelCase          =  [33,12_97,2,1,10_09,4,11_09,1_17_39,47_62,3_58,5,25,2_45,22,17_06,17,2_00_98,5,32_15,21,37,11_10,3,13,10_41,4,24,6_03,4_90,2,7_14_77,2_00_98,10_44_47,2,2_09_61,1,26_04,4,1,3_29,3,62_24,8_31,1_60_02,2,8,6_03,7_89_67,2_95_46,23,8_03,20,25,4_16,5,8,2_32,4,2_77,6,18_55,46_01,3,2_95_46,54,8,36_09,5,5_72_11,49,4,1,2_77,18,8,17_55,1_56_91,3,3_41,25,4_16,6_93,4_25_73,71,17,4_01,94,31,1_79_19,2,2_95_46,78_73,18,1,4_35,23,1_10_11,7_55,5,51_67,3,79_83,98,84,2,2_95_46,32_67,8,36_09,4,1,48_65,10_75,2,60_87,71,6,3_46,8,58_54,3,2_95_46,8_24,14_00,18_68,2,19,1_60,2,3_11,8,54_96,2,2_09_20,17,25,1_50_97,3,24,24,0,33,1,18_57,2,1,10_09,4,11_09,1_17_39,47_62,3_58,5,25,2_45,28,11_10,3,13,10_41,4,24,6_03,4_90,2,7_14_77,2_00_98,10_44_47,2,2_09_61,1,26_04,4,1,3_29,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>

         __lowerCamelCase          =  model.generate(a  ,    max_length=2_00  ,    do_sample=a   )
         self.assertListEqual(output_ids[0].numpy().tolist()  ,    a   )

'''simple docstring'''




import functools
import operator

from ...configuration_utils import PretrainedConfig
from ...utils import logging


__UpperCAmelCase												=logging.get_logger(__name__)

__UpperCAmelCase												={
    "microsoft/unispeech-sat-base-100h-libri-ft": (
        "https://huggingface.co/microsoft/unispeech-sat-base-100h-libri-ft/resolve/main/config.json"
    ),
    # See all UniSpeechSat models at https://huggingface.co/models?filter=unispeech_sat
}




class    a__				(       UpperCAmelCase__			):
     lowerCamelCase  :					List[Any]							="unispeech-sat"






     def __init__(			self		:		Dict  ,    a		:		str=32  ,    a		:		Any=7_68  ,    a		:		Optional[Any]=12  ,    a		:		Optional[int]=12  ,    a		:		int=30_72  ,    a		:		int="gelu"  ,    a		:		Dict=0.1  ,    a		:		Dict=0.1  ,    a		:		List[Any]=0.1  ,    a		:		Tuple=0.0  ,    a		:		Optional[Any]=0.0  ,    a		:		Tuple=0.1  ,    a		:		List[Any]=0.1  ,    a		:		str=0.02  ,    a		:		List[Any]=1e-5  ,    a		:		int="group"  ,    a		:		Union[str, Any]="gelu"  ,    a		:		Optional[int]=(5_12, 5_12, 5_12, 5_12, 5_12, 5_12, 5_12)  ,    a		:		List[Any]=(5, 2, 2, 2, 2, 2, 2)  ,    a		:		int=(10, 3, 3, 3, 3, 2, 2)  ,    a		:		Optional[Any]=False  ,    a		:		Any=1_28  ,    a		:		Tuple=16  ,    a		:		str=False  ,    a		:		Optional[Any]=True  ,    a		:		Dict=0.05  ,    a		:		List[Any]=10  ,    a		:		Any=2  ,    a		:		Optional[Any]=0.0  ,    a		:		Optional[Any]=10  ,    a		:		Any=0  ,    a		:		Any=3_20  ,    a		:		str=2  ,    a		:		List[str]=0.1  ,    a		:		List[str]=1_00  ,    a		:		List[str]=2_56  ,    a		:		str=2_56  ,    a		:		Dict=0.1  ,    a		:		Optional[Any]="mean"  ,    a		:		str=False  ,    a		:		Tuple=False  ,    a		:		Optional[Any]=2_56  ,    a		:		int=(5_12, 5_12, 5_12, 5_12, 15_00)  ,    a		:		int=(5, 3, 3, 1, 1)  ,    a		:		Any=(1, 2, 3, 1, 1)  ,    a		:		Union[str, Any]=5_12  ,    a		:		Optional[int]=0  ,    a		:		Optional[int]=1  ,    a		:		Optional[int]=2  ,    a		:		int=5_04  ,    **a		:		Dict  ,    ):





         """simple docstring"""



         super().__init__(**a  ,    pad_token_id=a  ,    bos_token_id=a  ,    eos_token_id=a   )
         __lowerCamelCase          =  hidden_size
         __lowerCamelCase          =  feat_extract_norm
         __lowerCamelCase          =  feat_extract_activation
         __lowerCamelCase          =  list(a   )
         __lowerCamelCase          =  list(a   )
         __lowerCamelCase          =  list(a   )
         __lowerCamelCase          =  conv_bias
         __lowerCamelCase          =  num_conv_pos_embeddings
         __lowerCamelCase          =  num_conv_pos_embedding_groups
         __lowerCamelCase          =  len(self.conv_dim   )
         __lowerCamelCase          =  num_hidden_layers
         __lowerCamelCase          =  intermediate_size
         __lowerCamelCase          =  hidden_act
         __lowerCamelCase          =  num_attention_heads
         __lowerCamelCase          =  hidden_dropout
         __lowerCamelCase          =  attention_dropout
         __lowerCamelCase          =  activation_dropout
         __lowerCamelCase          =  feat_proj_dropout
         __lowerCamelCase          =  final_dropout
         __lowerCamelCase          =  layerdrop
         __lowerCamelCase          =  layer_norm_eps
         __lowerCamelCase          =  initializer_range
         __lowerCamelCase          =  vocab_size
         __lowerCamelCase          =  num_clusters
         __lowerCamelCase          =  do_stable_layer_norm
         __lowerCamelCase          =  use_weighted_layer_sum

         if (
             (len(self.conv_stride   ) != self.num_feat_extract_layers)
             or (len(self.conv_kernel   ) != self.num_feat_extract_layers)
             or (len(self.conv_dim   ) != self.num_feat_extract_layers)
         ):
             raise ValueError(
                 '''Configuration for convolutional layers is incorrect. It is required that `len(config.conv_dim)` =='''
                 ''' `len(config.conv_stride)` == `len(config.conv_kernel)`, but is `len(config.conv_dim) ='''
                 f""" {len(self.conv_dim   )}`, `len(config.conv_stride) = {len(self.conv_stride   )}`,"""
                 f""" `len(config.conv_kernel) = {len(self.conv_kernel   )}`."""   )

         # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
         __lowerCamelCase          =  apply_spec_augment
         __lowerCamelCase          =  mask_time_prob
         __lowerCamelCase          =  mask_time_length
         __lowerCamelCase          =  mask_time_min_masks
         __lowerCamelCase          =  mask_feature_prob
         __lowerCamelCase          =  mask_feature_length
         __lowerCamelCase          =  mask_feature_min_masks

         # parameters for pretraining with codevector quantized representations
         __lowerCamelCase          =  num_codevectors_per_group
         __lowerCamelCase          =  num_codevector_groups
         __lowerCamelCase          =  contrastive_logits_temperature
         __lowerCamelCase          =  feat_quantizer_dropout
         __lowerCamelCase          =  num_negatives
         __lowerCamelCase          =  codevector_dim
         __lowerCamelCase          =  proj_codevector_dim
         __lowerCamelCase          =  diversity_loss_weight

         # ctc loss
         __lowerCamelCase          =  ctc_loss_reduction
         __lowerCamelCase          =  ctc_zero_infinity

         # SequenceClassification-specific parameter. Feel free to ignore for other classes.
         __lowerCamelCase          =  classifier_proj_size

         # XVector-specific parameters. Feel free to ignore for other classes.
         __lowerCamelCase          =  list(a   )
         __lowerCamelCase          =  list(a   )
         __lowerCamelCase          =  list(a   )
         __lowerCamelCase          =  xvector_output_dim






     @property
     def        SCREAMING_SNAKE_CASE__       (			self		:		Any   ):





         """simple docstring"""



         return functools.reduce(operator.mul  ,    self.conv_stride  ,    1   )
