



'''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       __magic_name__		:







							def __init__(				self   :			List[Any]      ,_UpperCAmelCase   :			Dict      ,):
									_a	: int								=				parent
									_a	: Union[str, Any]								=				13
									_a	: int								=				7
									_a	: Optional[Any]								=				30
									_a	: Union[str, Any]								=				self.seq_length + self.mem_len
									_a	: Tuple								=				15
									_a	: Optional[int]								=				True
									_a	: List[Any]								=				True
									_a	: Any								=				99
									_a	: Dict								=				[10, 50, 80]
									_a	: int								=				32
									_a	: str								=				32
									_a	: Any								=				4
									_a	: Tuple								=				8
									_a	: Dict								=				128
									_a	: str								=				2
									_a	: int								=				2
									_a	: Union[str, Any]								=				None
									_a	: Optional[int]								=				1
									_a	: str								=				0
									_a	: Dict								=				3
									_a	: Tuple								=				self.vocab_size - 1
									_a	: Tuple								=				0.01







							def 				__lowercase     (				self   :			Union[str, Any]						):
									_a	: Dict								=				ids_tensor([self.batch_size, self.seq_length]      ,self.vocab_size						)
									_a	: List[Any]								=				ids_tensor([self.batch_size, self.seq_length]      ,self.vocab_size						)

									_a	: Optional[int]								=				None
									if self.use_labels:
											_a	: Any								=				ids_tensor([self.batch_size, self.seq_length]      ,self.vocab_size						)

									_a	: List[str]								=				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 				__lowercase     (				self   :			Union[str, Any]						):
									random.seed(self.seed						)
									tf.random.set_seed(self.seed						)







							def 				__lowercase     (				self   :			List[str]      ,_UpperCAmelCase   :			Dict      ,_UpperCAmelCase   :			List[Any]      ,_UpperCAmelCase   :			List[Any]      ,_UpperCAmelCase   :			Dict						):
									_a	: int								=				TFTransfoXLModel(_UpperCAmelCase						)

									_a			,   _a	: Optional[int]								=				model(_UpperCAmelCase						).to_tuple()

									_a	: Optional[Any]								=				{'input_ids': input_ids_a, 'mems': mems_a}

									_a			,   _a	: Union[str, Any]								=				model(_UpperCAmelCase						).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 				__lowercase     (				self   :			Any      ,_UpperCAmelCase   :			Optional[int]      ,_UpperCAmelCase   :			List[Any]      ,_UpperCAmelCase   :			Tuple      ,_UpperCAmelCase   :			Any						):
									_a	: List[str]								=				TFTransfoXLLMHeadModel(_UpperCAmelCase						)

									_a			,   _a	: Dict								=				model(_UpperCAmelCase						).to_tuple()

									_a	: Optional[int]								=				{'input_ids': input_ids_a, 'labels': lm_labels}
									_a			,   _a	: int								=				model(_UpperCAmelCase						).to_tuple()

									_a			,   _a	: List[Any]								=				model([input_ids_a, mems_a]						).to_tuple()

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

									_a			,   _a	: Any								=				model(_UpperCAmelCase						).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 				__lowercase     (				self   :			List[Any]      ,_UpperCAmelCase   :			Dict      ,_UpperCAmelCase   :			Optional[int]      ,_UpperCAmelCase   :			Tuple      ,_UpperCAmelCase   :			Tuple						):
									_a	: int								=				TFTransfoXLForSequenceClassification(_UpperCAmelCase						)
									_a	: str								=				model(_UpperCAmelCase						)
									self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.num_labels)						)







							def 				__lowercase     (				self   :			int						):
									_a	: Tuple								=				self.prepare_config_and_inputs()
									((_a)			,   (_a)			,   (_a)			,   (_a))	: str								=				config_and_inputs
									_a	: Optional[int]								=				{'input_ids': input_ids_a}
									return config, inputs_dict

@require_tf
class       __magic_name__		(       _UpperCamelCase     ,		_UpperCamelCase     ,		unittest.TestCase  ):
							lowerCAmelCase			:       Optional[int]  							=   (
							    (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
							)
							lowerCAmelCase			:       Tuple  							=   () if is_tf_available() else ()
							lowerCAmelCase			:       int  							=   (
							    {
							        '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			:       Dict  							=   False
							lowerCAmelCase			:       Dict  							=   False
							lowerCAmelCase			:       str  							=   False
							lowerCAmelCase			:       List[str]  							=   False







							def 				__lowercase     (				self   :			Any      ,_UpperCAmelCase   :			Union[str, Any]      ,_UpperCAmelCase   :			List[Any]      ,_UpperCAmelCase   :			Union[str, Any]      ,_UpperCAmelCase   :			List[str]      ,_UpperCAmelCase   :			Any						):
									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 				__lowercase     (				self   :			List[str]						):
									_a	: int								=				TFTransfoXLModelTester(self						)
									_a	: int								=				ConfigTester(self      ,config_class=_UpperCAmelCase      ,d_embed=37						)







							def 				__lowercase     (				self   :			Optional[Any]						):
									self.config_tester.run_common_tests()







							def 				__lowercase     (				self   :			Optional[int]						):
									self.model_tester.set_seed()
									_a	: Union[str, Any]								=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_transfo_xl_model(*_UpperCAmelCase						)







							def 				__lowercase     (				self   :			Dict						):
									self.model_tester.set_seed()
									_a	: Optional[int]								=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_transfo_xl_lm_head(*_UpperCAmelCase						)







							def 				__lowercase     (				self   :			List[Any]						):
									_a	: Dict								=				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*_UpperCAmelCase						)







							def 				__lowercase     (				self   :			Any						):
									_a			,   _a	: Any								=				self.model_tester.prepare_config_and_inputs_for_common()
									_a	: List[str]								=				[TFTransfoXLForSequenceClassification]

									for model_class in self.all_model_classes:
											_a	: str								=				model_class(_UpperCAmelCase						)
											assert isinstance(model.get_input_embeddings()      ,tf.keras.layers.Layer						)
											if model_class in list_other_models_with_output_ebd:
													_a	: Dict								=				model.get_output_embeddings()
													assert isinstance(_UpperCAmelCase      ,tf.keras.layers.Layer						)
													_a	: List[str]								=				model.get_bias()
													assert name is None
											else:
													_a	: int								=				model.get_output_embeddings()
													assert x is None
													_a	: Dict								=				model.get_bias()
													assert name is None







							def 				__lowercase     (				self   :			Optional[Any]						):
									# TODO JP: Make TransfoXL XLA compliant
									pass







							@slow
							def 				__lowercase     (				self   :			Any						):
									for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											_a	: Any								=				TFTransfoXLModel.from_pretrained(_UpperCAmelCase						)
											self.assertIsNotNone(_UpperCAmelCase						)







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

@require_tf
class       __magic_name__		(       unittest.TestCase  ):







							@unittest.skip('Skip test until #12651 is resolved.'						)
							@slow
							def 				__lowercase     (				self   :			List[str]						):
									_a	: Dict								=				TFTransfoXLLMHeadModel.from_pretrained('transfo-xl-wt103'						)
									# fmt: off
									_a	: Union[str, Any]								=				tf.convert_to_tensor([[33,1297,2,1,1009,4,1109,11739,4762,358,5,25,245,22,1706,17,20098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,71477,20098,104447,2,20961,1,2604,4,1,329,3,6224,831,16002,2,8,603,78967,29546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,29546,54,8,3609,5,57211,49,4,1,277,18,8,1755,15691,3,341,25,416,693,42573,71,17,401,94,31,17919,2,29546,7873,18,1,435,23,11011,755,5,5167,3,7983,98,84,2,29546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,29546,824,1400,1868,2,19,160,2,311,8,5496,2,20920,17,25,15097,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	: Optional[int]								=				[33,1297,2,1,1009,4,1109,11739,4762,358,5,25,245,22,1706,17,20098,5,3215,21,37,1110,3,13,1041,4,24,603,490,2,71477,20098,104447,2,20961,1,2604,4,1,329,3,6224,831,16002,2,8,603,78967,29546,23,803,20,25,416,5,8,232,4,277,6,1855,4601,3,29546,54,8,3609,5,57211,49,4,1,277,18,8,1755,15691,3,341,25,416,693,42573,71,17,401,94,31,17919,2,29546,7873,18,1,435,23,11011,755,5,5167,3,7983,98,84,2,29546,3267,8,3609,4,1,4865,1075,2,6087,71,6,346,8,5854,3,29546,824,1400,1868,2,19,160,2,311,8,5496,2,20920,17,25,15097,3,24,24,0,33,1,1857,2,1,1009,4,1109,11739,4762,358,5,25,245,28,1110,3,13,1041,4,24,603,490,2,71477,20098,104447,2,20961,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	: List[str]								=				model.generate(_UpperCAmelCase      ,max_length=200      ,do_sample=_UpperCAmelCase						)
									self.assertListEqual(output_ids[0].numpy().tolist()      ,_UpperCAmelCase						)









'''simple docstring'''

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


__lowerCAmelCase		     =  logging.get_logger(__name__)

__lowerCAmelCase		     =  {
    '''s-JoL/Open-Llama-V1''': '''https://huggingface.co/s-JoL/Open-Llama-V1/blob/main/config.json''',
}

class       __magic_name__		(       _UpperCamelCase  ):
							lowerCAmelCase			:       str  							=   'open-llama'







							def __init__(				self   :			str      ,_UpperCAmelCase   :			int=100000      ,_UpperCAmelCase   :			List[str]=4096      ,_UpperCAmelCase   :			Dict=11008      ,_UpperCAmelCase   :			int=32      ,_UpperCAmelCase   :			Union[str, Any]=32      ,_UpperCAmelCase   :			List[str]="silu"      ,_UpperCAmelCase   :			List[Any]=2048      ,_UpperCAmelCase   :			Any=0.02      ,_UpperCAmelCase   :			int=1E-6      ,_UpperCAmelCase   :			Optional[int]=True      ,_UpperCAmelCase   :			Dict=0      ,_UpperCAmelCase   :			Optional[Any]=1      ,_UpperCAmelCase   :			Dict=2      ,_UpperCAmelCase   :			Tuple=False      ,_UpperCAmelCase   :			Dict=True      ,_UpperCAmelCase   :			Dict=0.1      ,_UpperCAmelCase   :			Optional[int]=0.1      ,_UpperCAmelCase   :			List[str]=True      ,_UpperCAmelCase   :			int=True      ,_UpperCAmelCase   :			Union[str, Any]=None      ,**_UpperCAmelCase   :			Optional[int]      ,):
									_a	: str								=				vocab_size
									_a	: str								=				max_position_embeddings
									_a	: List[str]								=				hidden_size
									_a	: Any								=				intermediate_size
									_a	: Union[str, Any]								=				num_hidden_layers
									_a	: Tuple								=				num_attention_heads
									_a	: int								=				hidden_act
									_a	: str								=				initializer_range
									_a	: Any								=				rms_norm_eps
									_a	: Dict								=				use_cache
									_a	: Optional[int]								=				kwargs.pop(
									    'use_memorry_efficient_attention'      ,_UpperCAmelCase						)
									_a	: int								=				hidden_dropout_prob
									_a	: int								=				attention_dropout_prob
									_a	: Union[str, Any]								=				use_stable_embedding
									_a	: str								=				shared_input_output_embedding
									_a	: Any								=				rope_scaling
									self._rope_scaling_validation()

									super().__init__(
									    pad_token_id=_UpperCAmelCase      ,bos_token_id=_UpperCAmelCase      ,eos_token_id=_UpperCAmelCase      ,tie_word_embeddings=_UpperCAmelCase      ,**_UpperCAmelCase      ,)







							def 				__lowercase     (				self   :			Optional[Any]						):
									if self.rope_scaling is None:
											return

									if not isinstance(self.rope_scaling      ,_UpperCAmelCase						) or len(self.rope_scaling						) != 2:
											raise ValueError(
											    '`rope_scaling` must be a dictionary with with two fields, `name` and `factor`, '
											    F"""got {self.rope_scaling}"""						)
									_a	: Optional[Any]								=				self.rope_scaling.get('type'      ,_UpperCAmelCase						)
									_a	: Optional[Any]								=				self.rope_scaling.get('factor'      ,_UpperCAmelCase						)
									if rope_scaling_type is None or rope_scaling_type not in ["linear", "dynamic"]:
											raise ValueError(
											    F"""`rope_scaling`'s name field must be one of ['linear', 'dynamic'], got {rope_scaling_type}"""						)
									if rope_scaling_factor is None or not isinstance(_UpperCAmelCase      ,_UpperCAmelCase						) or rope_scaling_factor <= 1.0:
											raise ValueError(F"""`rope_scaling`'s factor field must be an float > 1, got {rope_scaling_factor}"""						)




