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
  )
  snake_case				:	Any							   =						logging.getLogger(__name__)
  
  
  
  
  
  
  def 						lowerCAmelCase_		(      )       ->	Dict:
  
  
  
  
  
  
  
  	'''simple docstring'''
  
  
  	__magic_name__	:	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."     )
  	__magic_name__	:	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()
  
  	__magic_name__	:	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 )
  	__magic_name__	:	Tuple			     =  TransfoXLCorpus.from_pretrained(args.model_name     )
  
  	__magic_name__	:	List[str]			     =  corpus.get_iterator("valid"   ,     args.batch_size   ,     args.tgt_len   ,     device=UpperCAmelCase_   ,     ext_len=args.ext_len     )
  	__magic_name__	:	List[Any]			     =  corpus.get_iterator("test"   ,     args.batch_size   ,     args.tgt_len   ,     device=UpperCAmelCase_   ,     ext_len=args.ext_len     )
  
  	# Load a pre-trained model
  	__magic_name__	:	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:
  		__magic_name__	:	Union[str, Any]			     =  args.clamp_len
  	if args.same_length:
  		__magic_name__	:	Union[str, Any]			     =  True
  
  	###############################################################################
  	# Evaluation code
  	###############################################################################
  	def evaluate(_snake_case   :						int     ):
  		# Turn on evaluation mode which disables dropout.
  		model.eval()
  		__magic_name__	:	Optional[int]			     =  0, 0.0
  		__magic_name__	:	Any			     =  time.time()
  		with torch.no_grad():
  			__magic_name__	:	Optional[int]			     =  None
  			for idx, (data, target, seq_len) in enumerate(UpperCAmelCase_     ):
  				__magic_name__	:	Tuple			     =  model(UpperCAmelCase_   ,     lm_labels=UpperCAmelCase_   ,     mems=UpperCAmelCase_     )
  				__magic_name__	:	Tuple			     =  ret
  				__magic_name__	:	Dict			     =  loss.mean()
  				total_loss += seq_len * loss.item()
  				total_len += seq_len
  			__magic_name__	:	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":
  		__magic_name__	:	List[str]			     =  evaluate(UpperCAmelCase_     )
  		__magic_name__	:	str			     =  evaluate(UpperCAmelCase_     )
  	elif args.split == "valid":
  		__magic_name__	:	Any			     =  evaluate(UpperCAmelCase_     )
  		__magic_name__	:	Optional[Any]			     =  None
  	elif args.split == "test":
  		__magic_name__	:	List[str]			     =  evaluate(UpperCAmelCase_     )
  		__magic_name__	:	Dict			     =  None
  
  	def format_log(_snake_case   :						Any   ,     _snake_case   :						Optional[Any]     ):
  		__magic_name__	:	Tuple			     =  '''| {0} loss {1:5.2f} | {0} ppl {2:9.3f} '''.format(UpperCAmelCase_   ,     UpperCAmelCase_   ,     math.exp(UpperCAmelCase_     )     )
  		return log_str
  
  	__magic_name__	:	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: 
  from __future__ import annotations
  
  snake_case				:	List[str]							   =						"Alexander Joslin"
  
  
  
  
  
  
  def 						lowerCAmelCase_		(      _snake_case   :						int     )       ->	int:
  
  
  
  
  
  
  
  	'''simple docstring'''
  
  
  	if number <= 0:
  		__magic_name__	:	int			     =  F'''n must be greater than 0. Got n = {number}'''
  		raise ValueError(_snake_case     )
  
  	__magic_name__	:	List[str]			     =  [number + 1] * (number + 1)
  
  	# starting position
  	__magic_name__	:	Any			     =  0
  	for i in range(1   ,     _snake_case     ):
  		__magic_name__	:	Optional[int]			     =  min(table[i + 1]   ,     table[i] + 1     )
  		# check if out of bounds
  		if i * 2 <= number:
  			__magic_name__	:	str			     =  min(table[i * 2]   ,     table[i] + 1     )
  		# check if out of bounds
  		if i * 3 <= number:
  			__magic_name__	:	Any			     =  min(table[i * 3]   ,     table[i] + 1     )
  	return table[number]
  
  
  if __name__ == "__main__":
  				import doctest
  
  				doctest.testmod()
  