code: 
  
  
  import argparse
  import logging
  import math
  import time
  
  import torch
  
  from transformers import TransfoXLCorpus, TransfoXLLMHeadModel
  
  
  logging.basicConfig(
      format='%(asctime)s - %(levelname)s - %(name)s - %(message)s', datefmt='%m/%d/%Y %H:%M:%S', level=logging.INFO
  )
  UpperCamelCase__				       =			logging.getLogger(__name__)
  
  def   UpperCamelCase__   (    )						->							Dict:
  
  
  
  
         '''simple docstring'''
  
  
  
  
  
  
         _lowercase					:				Any           =			argparse.ArgumentParser(description='''PyTorch Transformer Language Model'''			)
         parser.add_argument('''--model_name'''    ,     type=UpperCAmelCase_    ,     default='''transfo-xl-wt103'''    ,     help='''pretrained model name'''			)
         parser.add_argument(
             '''--split'''    ,     type=UpperCAmelCase_    ,     default='''test'''    ,     choices=['''all''', '''valid''', '''test''']    ,     help='''which split to evaluate'''			)
         parser.add_argument('''--batch_size'''    ,     type=UpperCAmelCase_    ,     default=10    ,     help='''batch size'''			)
         parser.add_argument('''--tgt_len'''    ,     type=UpperCAmelCase_    ,     default=128    ,     help='''number of tokens to predict'''			)
         parser.add_argument('''--ext_len'''    ,     type=UpperCAmelCase_    ,     default=0    ,     help='''length of the extended context'''			)
         parser.add_argument('''--mem_len'''    ,     type=UpperCAmelCase_    ,     default=1600    ,     help='''length of the retained previous heads'''			)
         parser.add_argument('''--clamp_len'''    ,     type=UpperCAmelCase_    ,     default=1000    ,     help='''max positional embedding index'''			)
         parser.add_argument('''--no_cuda'''    ,     action='''store_true'''    ,     help='''Do not use CUDA even though CUA is available'''			)
         parser.add_argument('''--work_dir'''    ,     type=UpperCAmelCase_    ,     required=UpperCAmelCase_    ,     help='''path to the work_dir'''			)
         parser.add_argument('''--no_log'''    ,     action='''store_true'''    ,     help='''do not log the eval result'''			)
         parser.add_argument('''--same_length'''    ,     action='''store_true'''    ,     help='''set same length attention with masking'''			)
         parser.add_argument('''--server_ip'''    ,     type=UpperCAmelCase_    ,     default=''''''    ,     help='''Can be used for distant debugging.'''			)
         parser.add_argument('''--server_port'''    ,     type=UpperCAmelCase_    ,     default=''''''    ,     help='''Can be used for distant debugging.'''			)
         _lowercase					:				int           =			parser.parse_args()
         assert args.ext_len >= 0, "extended context length must be non-negative"
  
         if args.server_ip and args.server_port:
                # Distant debugging - see https://code.visualstudio.com/docs/python/debugging#_attach-to-a-local-script
                import ptvsd
  
                print('''Waiting for debugger attach'''			)
                ptvsd.enable_attach(address=(args.server_ip, args.server_port)    ,     redirect_output=UpperCAmelCase_			)
                ptvsd.wait_for_attach()
  
         _lowercase					:				List[Any]           =			torch.device('''cuda''' if torch.cuda.is_available() and not args.no_cuda else '''cpu'''			)
         logger.info('''device: {}'''.format(UpperCAmelCase_			)			)
  
         # Load a pre-processed dataset
         # You can also build the corpus yourself using TransfoXLCorpus methods
         # The pre-processing involve computing word frequencies to prepare the Adaptive input and SoftMax
         # and tokenizing the dataset
         # The pre-processed corpus is a convertion (using the conversion script )
         _lowercase					:				Tuple           =			TransfoXLCorpus.from_pretrained(args.model_name			)
  
         _lowercase					:				List[str]           =			corpus.get_iterator('''valid'''    ,     args.batch_size    ,     args.tgt_len    ,     device=UpperCAmelCase_    ,     ext_len=args.ext_len			)
         _lowercase					:				List[Any]           =			corpus.get_iterator('''test'''    ,     args.batch_size    ,     args.tgt_len    ,     device=UpperCAmelCase_    ,     ext_len=args.ext_len			)
  
         # Load a pre-trained model
         _lowercase					:				Dict           =			TransfoXLLMHeadModel.from_pretrained(args.model_name			)
         model.to(UpperCAmelCase_			)
  
         logger.info(
             '''Evaluating with bsz {} tgt_len {} ext_len {} mem_len {} clamp_len {}'''.format(
                 args.batch_size    ,     args.tgt_len    ,     args.ext_len    ,     args.mem_len    ,     args.clamp_len			)			)
  
         model.reset_memory_length(args.mem_len			)
         if args.clamp_len > 0:
                _lowercase					:				Union[str, Any]           =			args.clamp_len
         if args.same_length:
                _lowercase					:				Union[str, Any]           =			True
  
         ###############################################################################
         # Evaluation code
         ###############################################################################
         def evaluate(UpperCAmelCase_			):
                # Turn on evaluation mode which disables dropout.
                model.eval()
                _lowercase       ,	_lowercase					:				Optional[int]           =			0, 0.0
                _lowercase					:				Any           =			time.time()
                with torch.no_grad():
                       _lowercase					:				Optional[int]           =			None
                       for idx, (data, target, seq_len) in enumerate(UpperCAmelCase_			):
                              _lowercase					:				Tuple           =			model(UpperCAmelCase_    ,     lm_labels=UpperCAmelCase_    ,     mems=UpperCAmelCase_			)
                              _lowercase       ,	_lowercase       ,	_lowercase					:				Tuple           =			ret
                              _lowercase					:				Dict           =			loss.mean()
                              total_loss += seq_len * loss.item()
                              total_len += seq_len
                       _lowercase					:				Dict           =			time.time() - start_time
                logger.info('''Time : {:.2f}s, {:.2f}ms/segment'''.format(UpperCAmelCase_    ,     1000 * total_time / (idx + 1)			)			)
                return total_loss / total_len
  
         # Run on test data.
         if args.split == "all":
                _lowercase					:				List[str]           =			evaluate(UpperCAmelCase_			)
                _lowercase					:				str           =			evaluate(UpperCAmelCase_			)
         elif args.split == "valid":
                _lowercase					:				Any           =			evaluate(UpperCAmelCase_			)
                _lowercase					:				Optional[Any]           =			None
         elif args.split == "test":
                _lowercase					:				List[str]           =			evaluate(UpperCAmelCase_			)
                _lowercase					:				Dict           =			None
  
         def format_log(UpperCAmelCase_    ,     UpperCAmelCase_			):
                _lowercase					:				Tuple           =			'''| {0} loss {1:5.2f} | {0} ppl {2:9.3f} '''.format(UpperCAmelCase_    ,     UpperCAmelCase_    ,     math.exp(UpperCAmelCase_			)			)
                return log_str
  
         _lowercase					:				Optional[Any]           =			''''''
         if valid_loss is not None:
                log_str += format_log(UpperCAmelCase_    ,     '''valid'''			)
         if test_loss is not None:
                log_str += format_log(UpperCAmelCase_    ,     '''test'''			)
  
         logger.info('''=''' * 100			)
         logger.info(UpperCAmelCase_			)
         logger.info('''=''' * 100			)
  
  
  if __name__ == "__main__":
     main()
style_context: 
  
  
  import torch
  
  from diffusers import DDIMScheduler
  
  from .test_schedulers import SchedulerCommonTest
  
  class 						UpperCAmelCase__   (      A_		):
  
  
  
       '''simple docstring'''
       UpperCAmelCase_         =  (DDIMScheduler,)
       UpperCAmelCase_         =  (('''eta''', 0.0), ('''num_inference_steps''', 5_0))
  
  
  
  
       def   lowerCAmelCase_   ( self       :       List[Any]	,      **UpperCamelCase       :       str		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              _lowercase					:				Any           =			{
                  '''num_train_timesteps''': 10_00,
                  '''beta_start''': 0.0001,
                  '''beta_end''': 0.02,
                  '''beta_schedule''': '''linear''',
                  '''clip_sample''': True,
              }
  
              config.update(**UpperCamelCase		)
              return config
  
  
  
  
       def   lowerCAmelCase_   ( self       :       str	,      **UpperCamelCase       :       int		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              _lowercase					:				str           =			self.scheduler_classes[0]
              _lowercase					:				Dict           =			self.get_scheduler_config(**UpperCamelCase		)
              _lowercase					:				List[str]           =			scheduler_class(**UpperCamelCase		)
  
              _lowercase       ,	_lowercase					:				int           =			10, 0.0
  
              _lowercase					:				List[str]           =			self.dummy_model()
              _lowercase					:				int           =			self.dummy_sample_deter
  
              scheduler.set_timesteps(UpperCamelCase		)
  
              for t in scheduler.timesteps:
                     _lowercase					:				Union[str, Any]           =			model(UpperCamelCase	,      UpperCamelCase		)
                     _lowercase					:				List[Any]           =			scheduler.step(UpperCamelCase	,      UpperCamelCase	,      UpperCamelCase	,      UpperCamelCase		).prev_sample
  
              return sample
  
  
  
  
       def   lowerCAmelCase_   ( self       :       Dict		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              for timesteps in [1_00, 5_00, 10_00]:
                     self.check_over_configs(num_train_timesteps=UpperCamelCase		)
  
  
  
  
       def   lowerCAmelCase_   ( self       :       List[Any]		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              for steps_offset in [0, 1]:
                     self.check_over_configs(steps_offset=UpperCamelCase		)
  
              _lowercase					:				List[Any]           =			self.scheduler_classes[0]
              _lowercase					:				Tuple           =			self.get_scheduler_config(steps_offset=1		)
              _lowercase					:				Union[str, Any]           =			scheduler_class(**UpperCamelCase		)
              scheduler.set_timesteps(5		)
              assert torch.equal(scheduler.timesteps	,      torch.LongTensor([8_01, 6_01, 4_01, 2_01, 1]		)		)
  
  
  
  
       def   lowerCAmelCase_   ( self       :       Optional[Any]		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              for beta_start, beta_end in zip([0.0001, 0.001, 0.01, 0.1]	,      [0.002, 0.02, 0.2, 2]		):
                     self.check_over_configs(beta_start=UpperCamelCase	,      beta_end=UpperCamelCase		)
  
  
  
  
       def   lowerCAmelCase_   ( self       :       Any		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              for schedule in ["linear", "squaredcos_cap_v2"]:
                     self.check_over_configs(beta_schedule=UpperCamelCase		)
  
  
  
  
       def   lowerCAmelCase_   ( self       :       Optional[int]		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              for prediction_type in ["epsilon", "v_prediction"]:
                     self.check_over_configs(prediction_type=UpperCamelCase		)
  
  
  
  
       def   lowerCAmelCase_   ( self       :       Optional[Any]		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              for clip_sample in [True, False]:
                     self.check_over_configs(clip_sample=UpperCamelCase		)
  
  
  
  
       def   lowerCAmelCase_   ( self       :       Any		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              for timestep_spacing in ["trailing", "leading"]:
                     self.check_over_configs(timestep_spacing=UpperCamelCase		)
  
  
  
  
       def   lowerCAmelCase_   ( self       :       List[str]		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              for rescale_betas_zero_snr in [True, False]:
                     self.check_over_configs(rescale_betas_zero_snr=UpperCamelCase		)
  
  
  
  
       def   lowerCAmelCase_   ( self       :       Optional[Any]		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              self.check_over_configs(thresholding=UpperCamelCase		)
              for threshold in [0.5, 1.0, 2.0]:
                     for prediction_type in ["epsilon", "v_prediction"]:
                            self.check_over_configs(
                                thresholding=UpperCamelCase	,      prediction_type=UpperCamelCase	,      sample_max_value=UpperCamelCase	,      )
  
  
  
  
       def   lowerCAmelCase_   ( self       :       str		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              for t in [1, 10, 49]:
                     self.check_over_forward(time_step=UpperCamelCase		)
  
  
  
  
       def   lowerCAmelCase_   ( self       :       Optional[int]		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              for t, num_inference_steps in zip([1, 10, 50]	,      [10, 50, 5_00]		):
                     self.check_over_forward(time_step=UpperCamelCase	,      num_inference_steps=UpperCamelCase		)
  
  
  
  
       def   lowerCAmelCase_   ( self       :       Optional[Any]		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              for t, eta in zip([1, 10, 49]	,      [0.0, 0.5, 1.0]		):
                     self.check_over_forward(time_step=UpperCamelCase	,      eta=UpperCamelCase		)
  
  
  
  
       def   lowerCAmelCase_   ( self       :       List[Any]		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              _lowercase					:				int           =			self.scheduler_classes[0]
              _lowercase					:				str           =			self.get_scheduler_config()
              _lowercase					:				int           =			scheduler_class(**UpperCamelCase		)
  
              assert torch.sum(torch.abs(scheduler._get_variance(0	,      0		) - 0.0		)		) < 1E-5
              assert torch.sum(torch.abs(scheduler._get_variance(4_20	,      4_00		) - 0.14771		)		) < 1E-5
              assert torch.sum(torch.abs(scheduler._get_variance(9_80	,      9_60		) - 0.32460		)		) < 1E-5
              assert torch.sum(torch.abs(scheduler._get_variance(0	,      0		) - 0.0		)		) < 1E-5
              assert torch.sum(torch.abs(scheduler._get_variance(4_87	,      4_86		) - 0.00979		)		) < 1E-5
              assert torch.sum(torch.abs(scheduler._get_variance(9_99	,      9_98		) - 0.02		)		) < 1E-5
  
  
  
  
       def   lowerCAmelCase_   ( self       :       List[Any]		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              _lowercase					:				Any           =			self.full_loop()
  
              _lowercase					:				Optional[Any]           =			torch.sum(torch.abs(UpperCamelCase		)		)
              _lowercase					:				Union[str, Any]           =			torch.mean(torch.abs(UpperCamelCase		)		)
  
              assert abs(result_sum.item() - 172.0067		) < 1E-2
              assert abs(result_mean.item() - 0.223967		) < 1E-3
  
  
  
  
       def   lowerCAmelCase_   ( self       :       Union[str, Any]		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              _lowercase					:				List[Any]           =			self.full_loop(prediction_type='''v_prediction'''		)
  
              _lowercase					:				int           =			torch.sum(torch.abs(UpperCamelCase		)		)
              _lowercase					:				Union[str, Any]           =			torch.mean(torch.abs(UpperCamelCase		)		)
  
              assert abs(result_sum.item() - 52.5302		) < 1E-2
              assert abs(result_mean.item() - 0.0684		) < 1E-3
  
  
  
  
       def   lowerCAmelCase_   ( self       :       Any		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              _lowercase					:				Tuple           =			self.full_loop(set_alpha_to_one=UpperCamelCase	,      beta_start=0.01		)
              _lowercase					:				List[Any]           =			torch.sum(torch.abs(UpperCamelCase		)		)
              _lowercase					:				Any           =			torch.mean(torch.abs(UpperCamelCase		)		)
  
              assert abs(result_sum.item() - 149.8295		) < 1E-2
              assert abs(result_mean.item() - 0.1951		) < 1E-3
  
  
  
  
       def   lowerCAmelCase_   ( self       :       Any		):
  
  
  
  
  
              """simple docstring"""
  
  
  
              _lowercase					:				int           =			self.full_loop(set_alpha_to_one=UpperCamelCase	,      beta_start=0.01		)
              _lowercase					:				Optional[int]           =			torch.sum(torch.abs(UpperCamelCase		)		)
              _lowercase					:				Dict           =			torch.mean(torch.abs(UpperCamelCase		)		)
  
              assert abs(result_sum.item() - 149.0784		) < 1E-2
              assert abs(result_mean.item() - 0.1941		) < 1E-3