code: 
  
  
  """simple docstring"""
  
  
  
  
  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
  )
  __magic_name__	:   str          =							logging.getLogger(__name__)
  
  
  
  
  
  def 			a_   (  ):
  			__lowerCamelCase        =			argparse.ArgumentParser(description="""PyTorch Transformer Language Model"""    )
  			parser.add_argument("""--model_name""", type=lowercase__, default="""transfo-xl-wt103""", help="""pretrained model name"""    )
  			parser.add_argument(
  			    """--split""", type=lowercase__, default="""test""", choices=["""all""", """valid""", """test"""], help="""which split to evaluate"""    )
  			parser.add_argument("""--batch_size""", type=lowercase__, default=10, help="""batch size"""    )
  			parser.add_argument("""--tgt_len""", type=lowercase__, default=128, help="""number of tokens to predict"""    )
  			parser.add_argument("""--ext_len""", type=lowercase__, default=0, help="""length of the extended context"""    )
  			parser.add_argument("""--mem_len""", type=lowercase__, default=1600, help="""length of the retained previous heads"""    )
  			parser.add_argument("""--clamp_len""", type=lowercase__, 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=lowercase__, required=lowercase__, 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=lowercase__, default="""""", help="""Can be used for distant debugging."""    )
  			parser.add_argument("""--server_port""", type=lowercase__, default="""""", help="""Can be used for distant debugging."""    )
  			__lowerCamelCase        =			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=lowercase__    )
  						ptvsd.wait_for_attach()
  
  			__lowerCamelCase        =			torch.device("""cuda""" if torch.cuda.is_available() and not args.no_cuda else """cpu"""    )
  			logger.info("""device: {}""".format(lowercase__    )    )
  
  			# 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 )
  			__lowerCamelCase        =			TransfoXLCorpus.from_pretrained(args.model_name    )
  
  			__lowerCamelCase        =			corpus.get_iterator("""valid""", args.batch_size, args.tgt_len, device=lowercase__, ext_len=args.ext_len    )
  			__lowerCamelCase        =			corpus.get_iterator("""test""", args.batch_size, args.tgt_len, device=lowercase__, ext_len=args.ext_len    )
  
  			# Load a pre-trained model
  			__lowerCamelCase        =			TransfoXLLMHeadModel.from_pretrained(args.model_name    )
  			model.to(lowercase__    )
  
  			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:
  						__lowerCamelCase        =			args.clamp_len
  			if args.same_length:
  						__lowerCamelCase        =			True
  
  			###############################################################################
  			# Evaluation code
  			###############################################################################
  			def evaluate(lowercase__   :List[str]    ):
  						# Turn on evaluation mode which disables dropout.
  						model.eval()
  						__lowerCamelCase    ,__lowerCamelCase        =			0, 0.0
  						__lowerCamelCase        =			time.time()
  						with torch.no_grad():
  									__lowerCamelCase        =			None
  									for idx, (data, target, seq_len) in enumerate(lowercase__    ):
  												__lowerCamelCase        =			model(lowercase__, lm_labels=lowercase__, mems=lowercase__    )
  												__lowerCamelCase    ,__lowerCamelCase    ,__lowerCamelCase        =			ret
  												__lowerCamelCase        =			loss.mean()
  												total_loss += seq_len * loss.item()
  												total_len += seq_len
  									__lowerCamelCase        =			time.time() - start_time
  						logger.info("""Time : {:.2f}s, {:.2f}ms/segment""".format(lowercase__, 1000 * total_time / (idx + 1)    )    )
  						return total_loss / total_len
  
  			# Run on test data.
  			if args.split == "all":
  						__lowerCamelCase        =			evaluate(lowercase__    )
  						__lowerCamelCase        =			evaluate(lowercase__    )
  			elif args.split == "valid":
  						__lowerCamelCase        =			evaluate(lowercase__    )
  						__lowerCamelCase        =			None
  			elif args.split == "test":
  						__lowerCamelCase        =			evaluate(lowercase__    )
  						__lowerCamelCase        =			None
  
  			def format_log(lowercase__   :Optional[Any], lowercase__   :str    ):
  						__lowerCamelCase        =			"""| {0} loss {1:5.2f} | {0} ppl {2:9.3f} """.format(lowercase__, lowercase__, math.exp(lowercase__    )    )
  						return log_str
  
  			__lowerCamelCase        =			""""""
  			if valid_loss is not None:
  						log_str += format_log(lowercase__, """valid"""    )
  			if test_loss is not None:
  						log_str += format_log(lowercase__, """test"""    )
  
  			logger.info("""=""" * 100    )
  			logger.info(lowercase__    )
  			logger.info("""=""" * 100    )
  
  
  if __name__ == "__main__":
  					main()
  
  
  
  
  
style_context: 
  
  
  """simple docstring"""
  
  
  
  
  import os
  
  
  
  
  
  def 			a_   (  ):
  			__lowerCamelCase        =			os.path.dirname(os.path.realpath(lowercase__    )    )
  			__lowerCamelCase        =			os.path.join(lowercase__, """triangle.txt"""    )
  
  			with open(lowercase__    ) as in_file:
  						__lowerCamelCase        =			[[int(lowercase__    ) for i in line.split()] for line in in_file]
  
  			while len(lowercase__    ) != 1:
  						__lowerCamelCase        =			triangle.pop()
  						__lowerCamelCase        =			triangle[-1]
  						for j in range(len(lowercase__    ) - 1    ):
  									curr_row[j] += max(last_row[j], last_row[j + 1]    )
  			return triangle[0][0]
  
  
  if __name__ == "__main__":
  					print(solution())
  
  
  
  
  