






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_						     =  logging.getLogger(__name__)
def      lowerCamelCase					(						)	->			Tuple:
							lowerCAmelCase_										=     argparse.ArgumentParser(description='PyTorch Transformer Language Model'	)
							parser.add_argument('--model_name' ,						type=a_ ,						default='transfo-xl-wt103' ,						help='pretrained model name'	)
							parser.add_argument(
							    '--split' ,						type=a_ ,						default='test' ,						choices=['all', 'valid', 'test'] ,						help='which split to evaluate'	)
							parser.add_argument('--batch_size' ,						type=a_ ,						default=10 ,						help='batch size'	)
							parser.add_argument('--tgt_len' ,						type=a_ ,						default=128 ,						help='number of tokens to predict'	)
							parser.add_argument('--ext_len' ,						type=a_ ,						default=0 ,						help='length of the extended context'	)
							parser.add_argument('--mem_len' ,						type=a_ ,						default=1_600 ,						help='length of the retained previous heads'	)
							parser.add_argument('--clamp_len' ,						type=a_ ,						default=1_000 ,						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=a_ ,						required=a_ ,						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=a_ ,						default='' ,						help='Can be used for distant debugging.'	)
							parser.add_argument('--server_port' ,						type=a_ ,						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=a_	)
														ptvsd.wait_for_attach()

							lowerCAmelCase_										=     torch.device('cuda' if torch.cuda.is_available() and not args.no_cuda else 'cpu'	)
							logger.info('device: {}'.format(a_	)	)

							# 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=a_ ,						ext_len=args.ext_len	)
							lowerCAmelCase_										=     corpus.get_iterator('test' ,						args.batch_size ,						args.tgt_len ,						device=a_ ,						ext_len=args.ext_len	)

							# Load a pre-trained model
							lowerCAmelCase_										=     TransfoXLLMHeadModel.from_pretrained(args.model_name	)
							model.to(a_	)

							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(a_	):
														# 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(a_	):
																												lowerCAmelCase_										=     model(a_ ,						lm_labels=a_ ,						mems=a_	)
																												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(a_ ,						1_000 * total_time / (idx + 1)	)	)
														return total_loss / total_len

							# Run on test data.
							if args.split == "all":
														lowerCAmelCase_										=     evaluate(a_	)
														lowerCAmelCase_										=     evaluate(a_	)
							elif args.split == "valid":
														lowerCAmelCase_										=     evaluate(a_	)
														lowerCAmelCase_										=     None
							elif args.split == "test":
														lowerCAmelCase_										=     evaluate(a_	)
														lowerCAmelCase_										=     None

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

							lowerCAmelCase_										=     ''
							if valid_loss is not None:
														log_str += format_log(a_ ,						'valid'	)
							if test_loss is not None:
														log_str += format_log(a_ ,						'test'	)

							logger.info('=' * 100	)
							logger.info(a_	)
							logger.info('=' * 100	)


if __name__ == "__main__":
		main()











from doctest import testmod
from math import sqrt
def      lowerCamelCase					(						a_	)	->			list:
							lowerCAmelCase_										=     []
							if num < 1:
														return facs
							facs.append(1	)
							if num == 1:
														return facs
							facs.append(a_	)
							for i in range(2 ,						int(sqrt(a_	)	) + 1	):
														if num % i == 0:  # If i is a factor of num
																					facs.append(a_	)
																					lowerCAmelCase_										=     num // i  # num//i is the other factor of num
																					if d != i:  # If d and i are distinct
																												facs.append(a_	)  # we have found another factor
							facs.sort()
							return facs


if __name__ == "__main__":
		testmod(name="""factors_of_a_number""", verbose=True)



