




'''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
)
_lowerCamelCase							:						str							     =  logging.getLogger(__name__)






def 		_lowercase		(     ):



		'''simple docstring'''







		_snake_case     	=	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."  )
		_snake_case     	=	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()

		_snake_case     	=	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 )
		_snake_case     	=	TransfoXLCorpus.from_pretrained(args.model_name  )

		_snake_case     	=	corpus.get_iterator("valid"						,							args.batch_size						,							args.tgt_len						,							device=lowercase_						,							ext_len=args.ext_len  )
		_snake_case     	=	corpus.get_iterator("test"						,							args.batch_size						,							args.tgt_len						,							device=lowercase_						,							ext_len=args.ext_len  )

		# Load a pre-trained model
		_snake_case     	=	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:
				_snake_case     	=	args.clamp_len
		if args.same_length:
				_snake_case     	=	True

		###############################################################################
		# Evaluation code
		###############################################################################
		def evaluate(lowercase_  ):
				# Turn on evaluation mode which disables dropout.
				model.eval()
				_snake_case	,   _snake_case     	=	0, 0.0
				_snake_case     	=	time.time()
				with torch.no_grad():
						_snake_case     	=	None
						for idx, (data, target, seq_len) in enumerate(lowercase_  ):
								_snake_case     	=	model(lowercase_						,							lm_labels=lowercase_						,							mems=lowercase_  )
								_snake_case	,   _snake_case	,   _snake_case     	=	ret
								_snake_case     	=	loss.mean()
								total_loss += seq_len * loss.item()
								total_len += seq_len
						_snake_case     	=	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":
				_snake_case     	=	evaluate(lowercase_  )
				_snake_case     	=	evaluate(lowercase_  )
		elif args.split == "valid":
				_snake_case     	=	evaluate(lowercase_  )
				_snake_case     	=	None
		elif args.split == "test":
				_snake_case     	=	evaluate(lowercase_  )
				_snake_case     	=	None

		def format_log(lowercase_						,							lowercase_  ):
				_snake_case     	=	"| {0} loss {1:5.2f} | {0} ppl {2:9.3f} ".format(lowercase_						,							lowercase_						,							math.exp(lowercase_  )  )
				return log_str

		_snake_case     	=	""
		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()











'''simple docstring'''







def 		_lowercase		(     lowercase_						,							lowercase_ = 2  ):



		'''simple docstring'''







		return round((float(lowercase_  ) * 9 / 5) + 32						,							lowercase_  )






def 		_lowercase		(     lowercase_						,							lowercase_ = 2  ):



		'''simple docstring'''







		return round(float(lowercase_  ) + 273.15						,							lowercase_  )






def 		_lowercase		(     lowercase_						,							lowercase_ = 2  ):



		'''simple docstring'''







		return round((float(lowercase_  ) * 9 / 5) + 491.67						,							lowercase_  )






def 		_lowercase		(     lowercase_						,							lowercase_ = 2  ):



		'''simple docstring'''







		return round((float(lowercase_  ) - 32) * 5 / 9						,							lowercase_  )






def 		_lowercase		(     lowercase_						,							lowercase_ = 2  ):



		'''simple docstring'''







		return round(((float(lowercase_  ) - 32) * 5 / 9) + 273.15						,							lowercase_  )






def 		_lowercase		(     lowercase_						,							lowercase_ = 2  ):



		'''simple docstring'''







		return round(float(lowercase_  ) + 459.67						,							lowercase_  )






def 		_lowercase		(     lowercase_						,							lowercase_ = 2  ):



		'''simple docstring'''







		return round(float(lowercase_  ) - 273.15						,							lowercase_  )






def 		_lowercase		(     lowercase_						,							lowercase_ = 2  ):



		'''simple docstring'''







		return round(((float(lowercase_  ) - 273.15) * 9 / 5) + 32						,							lowercase_  )






def 		_lowercase		(     lowercase_						,							lowercase_ = 2  ):



		'''simple docstring'''







		return round((float(lowercase_  ) * 9 / 5)						,							lowercase_  )






def 		_lowercase		(     lowercase_						,							lowercase_ = 2  ):



		'''simple docstring'''







		return round((float(lowercase_  ) - 491.67) * 5 / 9						,							lowercase_  )






def 		_lowercase		(     lowercase_						,							lowercase_ = 2  ):



		'''simple docstring'''







		return round(float(lowercase_  ) - 459.67						,							lowercase_  )






def 		_lowercase		(     lowercase_						,							lowercase_ = 2  ):



		'''simple docstring'''







		return round((float(lowercase_  ) * 5 / 9)						,							lowercase_  )






def 		_lowercase		(     lowercase_						,							lowercase_ = 2  ):



		'''simple docstring'''







		return round((float(lowercase_  ) * 1.25 + 273.15)						,							lowercase_  )






def 		_lowercase		(     lowercase_						,							lowercase_ = 2  ):



		'''simple docstring'''







		return round((float(lowercase_  ) * 2.25 + 32)						,							lowercase_  )






def 		_lowercase		(     lowercase_						,							lowercase_ = 2  ):



		'''simple docstring'''







		return round((float(lowercase_  ) * 1.25)						,							lowercase_  )






def 		_lowercase		(     lowercase_						,							lowercase_ = 2  ):



		'''simple docstring'''







		return round((float(lowercase_  ) * 2.25 + 32 + 459.67)						,							lowercase_  )


if __name__ == "__main__":
						import doctest

						doctest.testmod()





