
"""simple docstring"""


import os
import tempfile
import unittest
from pathlib import Path

from transformers import AutoConfig, is_torch_available
from transformers.testing_utils import require_torch, torch_device


if is_torch_available():
		from transformers import PyTorchBenchmark, PyTorchBenchmarkArguments







@require_torch
class  lowerCAmelCase_ (					unittest.TestCase			):



						'''simple docstring'''


						def   _SCREAMING_SNAKE_CASE					(       self   :					int     ,A_   :					List[Any]					)   ->      Optional[Any]:
							for model_result in results.values():
								for batch_size, sequence_length in zip(model_result['bs']     ,model_result['ss']					):
									A        =      model_result['result'][batch_size][sequence_length]
									self.assertIsNotNone(A_					)


						def   _SCREAMING_SNAKE_CASE					(       self   :					int					)   ->      Optional[Any]:
							A        =      'sshleifer/tiny-gpt2'
							A        =      PyTorchBenchmarkArguments(
							    models=[MODEL_ID]     ,training=A_     ,inference=A_     ,sequence_lengths=[8]     ,batch_sizes=[1]     ,multi_process=A_     ,)
							A        =      PyTorchBenchmark(A_					)
							A        =      benchmark.run()
							self.check_results_dict_not_empty(results.time_inference_result					)
							self.check_results_dict_not_empty(results.memory_inference_result					)


						def   _SCREAMING_SNAKE_CASE					(       self   :					Optional[Any]					)   ->      Optional[int]:
							A        =      'sgugger/tiny-distilbert-classification'
							A        =      PyTorchBenchmarkArguments(
							    models=[MODEL_ID]     ,training=A_     ,inference=A_     ,sequence_lengths=[8]     ,batch_sizes=[1]     ,multi_process=A_     ,only_pretrain_model=A_     ,)
							A        =      PyTorchBenchmark(A_					)
							A        =      benchmark.run()
							self.check_results_dict_not_empty(results.time_inference_result					)
							self.check_results_dict_not_empty(results.memory_inference_result					)


						def   _SCREAMING_SNAKE_CASE					(       self   :					Union[str, Any]					)   ->      List[str]:
							A        =      'sshleifer/tiny-gpt2'
							A        =      PyTorchBenchmarkArguments(
							    models=[MODEL_ID]     ,training=A_     ,inference=A_     ,torchscript=A_     ,sequence_lengths=[8]     ,batch_sizes=[1]     ,multi_process=A_     ,)
							A        =      PyTorchBenchmark(A_					)
							A        =      benchmark.run()
							self.check_results_dict_not_empty(results.time_inference_result					)
							self.check_results_dict_not_empty(results.memory_inference_result					)


						@unittest.skipIf(torch_device == 'cpu'     ,'Cant do half precision'					)
						def   _SCREAMING_SNAKE_CASE					(       self   :					List[Any]					)   ->      List[Any]:
							A        =      'sshleifer/tiny-gpt2'
							A        =      PyTorchBenchmarkArguments(
							    models=[MODEL_ID]     ,training=A_     ,inference=A_     ,fpaa=A_     ,sequence_lengths=[8]     ,batch_sizes=[1]     ,multi_process=A_     ,)
							A        =      PyTorchBenchmark(A_					)
							A        =      benchmark.run()
							self.check_results_dict_not_empty(results.time_inference_result					)
							self.check_results_dict_not_empty(results.memory_inference_result					)


						def   _SCREAMING_SNAKE_CASE					(       self   :					Optional[Any]					)   ->      Optional[Any]:
							A        =      'sshleifer/tiny-gpt2'
							A        =      AutoConfig.from_pretrained(A_					)
							# set architectures equal to `None`
							A        =      None
							A        =      PyTorchBenchmarkArguments(
							    models=[MODEL_ID]     ,training=A_     ,inference=A_     ,sequence_lengths=[8]     ,batch_sizes=[1]     ,multi_process=A_     ,)
							A        =      PyTorchBenchmark(A_     ,configs=[config]					)
							A        =      benchmark.run()
							self.check_results_dict_not_empty(results.time_inference_result					)
							self.check_results_dict_not_empty(results.memory_inference_result					)


						def   _SCREAMING_SNAKE_CASE					(       self   :					Tuple					)   ->      Optional[int]:
							A        =      'sshleifer/tiny-gpt2'
							A        =      PyTorchBenchmarkArguments(
							    models=[MODEL_ID]     ,training=A_     ,inference=A_     ,sequence_lengths=[8]     ,batch_sizes=[1]     ,multi_process=A_     ,)
							A        =      PyTorchBenchmark(A_					)
							A        =      benchmark.run()
							self.check_results_dict_not_empty(results.time_train_result					)
							self.check_results_dict_not_empty(results.memory_train_result					)


						@unittest.skipIf(torch_device == 'cpu'     ,'Can\'t do half precision'					)
						def   _SCREAMING_SNAKE_CASE					(       self   :					Union[str, Any]					)   ->      List[Any]:
							A        =      'sshleifer/tiny-gpt2'
							A        =      PyTorchBenchmarkArguments(
							    models=[MODEL_ID]     ,training=A_     ,inference=A_     ,sequence_lengths=[8]     ,batch_sizes=[1]     ,fpaa=A_     ,multi_process=A_     ,)
							A        =      PyTorchBenchmark(A_					)
							A        =      benchmark.run()
							self.check_results_dict_not_empty(results.time_train_result					)
							self.check_results_dict_not_empty(results.memory_train_result					)


						def   _SCREAMING_SNAKE_CASE					(       self   :					List[str]					)   ->      Optional[int]:
							A        =      'sshleifer/tiny-gpt2'
							A        =      AutoConfig.from_pretrained(A_					)
							A        =      PyTorchBenchmarkArguments(
							    models=[MODEL_ID]     ,training=A_     ,inference=A_     ,sequence_lengths=[8]     ,batch_sizes=[1]     ,multi_process=A_     ,)
							A        =      PyTorchBenchmark(A_     ,configs=[config]					)
							A        =      benchmark.run()
							self.check_results_dict_not_empty(results.time_inference_result					)
							self.check_results_dict_not_empty(results.memory_inference_result					)


						def   _SCREAMING_SNAKE_CASE					(       self   :					Any					)   ->      List[Any]:
							A        =      'sshleifer/tinier_bart'
							A        =      AutoConfig.from_pretrained(A_					)
							A        =      PyTorchBenchmarkArguments(
							    models=[MODEL_ID]     ,training=A_     ,inference=A_     ,sequence_lengths=[8]     ,batch_sizes=[1]     ,multi_process=A_     ,)
							A        =      PyTorchBenchmark(A_     ,configs=[config]					)
							A        =      benchmark.run()
							self.check_results_dict_not_empty(results.time_inference_result					)
							self.check_results_dict_not_empty(results.memory_inference_result					)


						def   _SCREAMING_SNAKE_CASE					(       self   :					Any					)   ->      List[str]:
							A        =      'sshleifer/tiny-gpt2'
							A        =      AutoConfig.from_pretrained(A_					)
							A        =      PyTorchBenchmarkArguments(
							    models=[MODEL_ID]     ,training=A_     ,inference=A_     ,sequence_lengths=[8]     ,batch_sizes=[1]     ,multi_process=A_     ,)
							A        =      PyTorchBenchmark(A_     ,configs=[config]					)
							A        =      benchmark.run()
							self.check_results_dict_not_empty(results.time_train_result					)
							self.check_results_dict_not_empty(results.memory_train_result					)


						def   _SCREAMING_SNAKE_CASE					(       self   :					Any					)   ->      List[str]:
							A        =      'sshleifer/tinier_bart'
							A        =      AutoConfig.from_pretrained(A_					)
							A        =      PyTorchBenchmarkArguments(
							    models=[MODEL_ID]     ,training=A_     ,inference=A_     ,sequence_lengths=[8]     ,batch_sizes=[1]     ,multi_process=A_     ,)
							A        =      PyTorchBenchmark(A_     ,configs=[config]					)
							A        =      benchmark.run()
							self.check_results_dict_not_empty(results.time_train_result					)
							self.check_results_dict_not_empty(results.memory_train_result					)


						def   _SCREAMING_SNAKE_CASE					(       self   :					Dict					)   ->      Dict:
							A        =      'sshleifer/tiny-gpt2'
							with tempfile.TemporaryDirectory() as tmp_dir:
								A        =      PyTorchBenchmarkArguments(
								    models=[MODEL_ID]     ,training=A_     ,inference=A_     ,save_to_csv=A_     ,sequence_lengths=[8]     ,batch_sizes=[1]     ,inference_time_csv_file=os.path.join(A_     ,'inf_time.csv'					)     ,train_memory_csv_file=os.path.join(A_     ,'train_mem.csv'					)     ,inference_memory_csv_file=os.path.join(A_     ,'inf_mem.csv'					)     ,train_time_csv_file=os.path.join(A_     ,'train_time.csv'					)     ,env_info_csv_file=os.path.join(A_     ,'env.csv'					)     ,multi_process=A_     ,)
								A        =      PyTorchBenchmark(A_					)
								benchmark.run()
								self.assertTrue(Path(os.path.join(A_     ,'inf_time.csv'					)					).exists()					)
								self.assertTrue(Path(os.path.join(A_     ,'train_time.csv'					)					).exists()					)
								self.assertTrue(Path(os.path.join(A_     ,'inf_mem.csv'					)					).exists()					)
								self.assertTrue(Path(os.path.join(A_     ,'train_mem.csv'					)					).exists()					)
								self.assertTrue(Path(os.path.join(A_     ,'env.csv'					)					).exists()					)




						def   _SCREAMING_SNAKE_CASE					(       self   :					Dict					)   ->      List[str]:
							A        =      'sshleifer/tiny-gpt2'

							def _check_summary_is_not_empty(A_   :					Optional[int]					):
								self.assertTrue(hasattr(A_     ,'sequential'					)					)
								self.assertTrue(hasattr(A_     ,'cumulative'					)					)
								self.assertTrue(hasattr(A_     ,'current'					)					)
								self.assertTrue(hasattr(A_     ,'total'					)					)

							with tempfile.TemporaryDirectory() as tmp_dir:
								A        =      PyTorchBenchmarkArguments(
								    models=[MODEL_ID]     ,training=A_     ,inference=A_     ,sequence_lengths=[8]     ,batch_sizes=[1]     ,log_filename=os.path.join(A_     ,'log.txt'					)     ,log_print=A_     ,trace_memory_line_by_line=A_     ,multi_process=A_     ,)
								A        =      PyTorchBenchmark(A_					)
								A        =      benchmark.run()
								_check_summary_is_not_empty(result.inference_summary					)
								_check_summary_is_not_empty(result.train_summary					)
								self.assertTrue(Path(os.path.join(A_     ,'log.txt'					)					).exists()					)



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


lowerCamelCase											=       logging.get_logger(__name__)

lowerCamelCase											=       {
    'transfo-xl-wt103': 'https://huggingface.co/transfo-xl-wt103/resolve/main/config.json',
}




class A  (   UpperCamelCase_     ):
      UpperCamelCase__							:  Dict      ='transfo-xl'
      UpperCamelCase__							:  int      =['mems']
      UpperCamelCase__							:  List[str]      ={
          'n_token': 'vocab_size',
          'hidden_size': 'd_model',
          'num_attention_heads': 'n_head',
          'num_hidden_layers': 'n_layer',
      }






      def __init__(					self						:     Tuple			,   lowercase_						:     List[Any]=26_7735			,   lowercase_						:     List[Any]=[2_0000, 4_0000, 20_0000]			,   lowercase_						:     Tuple=1024			,   lowercase_						:     Optional[int]=1024			,   lowercase_						:     str=16			,   lowercase_						:     int=64			,   lowercase_						:     Any=4096			,   lowercase_						:     List[Any]=4			,   lowercase_						:     List[Any]=False			,   lowercase_						:     List[str]=18			,   lowercase_						:     Tuple=1600			,   lowercase_						:     List[str]=1000			,   lowercase_						:     Any=True			,   lowercase_						:     str=True			,   lowercase_						:     Optional[int]=0			,   lowercase_						:     List[Any]=-1			,   lowercase_						:     Optional[int]=True			,   lowercase_						:     Any=0.1			,   lowercase_						:     Tuple=0.0			,   lowercase_						:     str=True			,   lowercase_						:     Union[str, Any]="normal"			,   lowercase_						:     Dict=0.01			,   lowercase_						:     Optional[Any]=0.01			,   lowercase_						:     List[Any]=0.02			,   lowercase_						:     List[Any]=1E-5			,   lowercase_						:     Tuple=0			,   **lowercase_						:     Tuple			,   )					->						Dict:
             """simple docstring"""




             _lowerCamelCase       :		Optional[Any]		=vocab_size
             _lowerCamelCase       :		Optional[Any]		=[]
             self.cutoffs.extend(lowercase_ )
             if proj_share_all_but_first:
                    _lowerCamelCase       :		List[str]		=[False] + [True] * len(self.cutoffs )
             else:
                    _lowerCamelCase       :		str		=[False] + [False] * len(self.cutoffs )
             _lowerCamelCase       :		str		=d_model
             _lowerCamelCase       :		str		=d_embed
             _lowerCamelCase       :		str		=d_head
             _lowerCamelCase       :		Dict		=d_inner
             _lowerCamelCase       :		Union[str, Any]		=div_val
             _lowerCamelCase       :		Dict		=pre_lnorm
             _lowerCamelCase       :		Tuple		=n_layer
             _lowerCamelCase       :		Optional[Any]		=n_head
             _lowerCamelCase       :		List[Any]		=mem_len
             _lowerCamelCase       :		List[Any]		=same_length
             _lowerCamelCase       :		Optional[int]		=attn_type
             _lowerCamelCase       :		List[str]		=clamp_len
             _lowerCamelCase       :		int		=sample_softmax
             _lowerCamelCase       :		List[Any]		=adaptive
             _lowerCamelCase       :		List[str]		=dropout
             _lowerCamelCase       :		Any		=dropatt
             _lowerCamelCase       :		Dict		=untie_r
             _lowerCamelCase       :		List[Any]		=init
             _lowerCamelCase       :		List[str]		=init_range
             _lowerCamelCase       :		int		=proj_init_std
             _lowerCamelCase       :		Optional[int]		=init_std
             _lowerCamelCase       :		Tuple		=layer_norm_epsilon
             super().__init__(eos_token_id=lowercase_			,   **lowercase_ )






      @property
      def        lowerCamelCase       (					self						:     List[str] )					->						Dict:
             """simple docstring"""




             logger.info(F'''The model {self.model_type} is one of the few models that has no sequence length limit.''' )
             return -1






      @max_position_embeddings.setter
      def        lowerCamelCase       (					self						:     int			,   lowercase_						:     int )					->						List[str]:
             """simple docstring"""




             raise NotImplementedError(
                 F'''The model {self.model_type} is one of the few models that has no sequence length limit.''' )


