





"""simple docstring"""
def   __lowerCamelCase     (							a_  :	int = 99_80_01							)    ->   int:
      __SCREAMING_SNAKE_CASE     :List[Any]	       =						0
      for i in range(9_99				,     99				,     -1							):  # 3 digit numbers range from 999 down to 100
            for j in range(9_99				,     99				,     -1							):
                  __SCREAMING_SNAKE_CASE     :Union[str, Any]	       =						str(i * j							)
                  if product_string == product_string[::-1] and i * j < n:
                        __SCREAMING_SNAKE_CASE     :Dict	       =						max(a_				,     i * j							)
      return answer


if __name__ == "__main__":
  print(f'{solution() = }')






"""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_          =	logging.getLogger(__name__)



def   __lowerCamelCase     (							)    ->   Optional[Any]:
      __SCREAMING_SNAKE_CASE     :Union[str, Any]	       =						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=1_28				,     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=16_00				,     help='''length of the retained previous heads'''							)
      parser.add_argument('''--clamp_len'''				,     type=a_				,     default=10_00				,     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.'''							)
      __SCREAMING_SNAKE_CASE     :Optional[Any]	       =						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()

      __SCREAMING_SNAKE_CASE     :Tuple	       =						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 )
      __SCREAMING_SNAKE_CASE     :Optional[int]	       =						TransfoXLCorpus.from_pretrained(args.model_name							)

      __SCREAMING_SNAKE_CASE     :Tuple	       =						corpus.get_iterator('''valid'''				,     args.batch_size				,     args.tgt_len				,     device=a_				,     ext_len=args.ext_len							)
      __SCREAMING_SNAKE_CASE     :Tuple	       =						corpus.get_iterator('''test'''				,     args.batch_size				,     args.tgt_len				,     device=a_				,     ext_len=args.ext_len							)

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

      ###############################################################################
      # Evaluation code
      ###############################################################################
      def evaluate(a_  :	Optional[int]							):
            # Turn on evaluation mode which disables dropout.
            model.eval()
            __SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE     :Optional[Any]	       =						0, 0.0
            __SCREAMING_SNAKE_CASE     :Tuple	       =						time.time()
            with torch.no_grad():
                  __SCREAMING_SNAKE_CASE     :Any	       =						None
                  for idx, (data, target, seq_len) in enumerate(a_							):
                        __SCREAMING_SNAKE_CASE     :Optional[Any]	       =						model(a_				,     lm_labels=a_				,     mems=a_							)
                        __SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE     :List[str]	       =						ret
                        __SCREAMING_SNAKE_CASE     :Tuple	       =						loss.mean()
                        total_loss += seq_len * loss.item()
                        total_len += seq_len
                  __SCREAMING_SNAKE_CASE     :List[str]	       =						time.time() - start_time
            logger.info('''Time : {:.2f}s, {:.2f}ms/segment'''.format(a_				,     10_00 * total_time / (idx + 1)							)							)
            return total_loss / total_len

      # Run on test data.
      if args.split == "all":
            __SCREAMING_SNAKE_CASE     :Optional[Any]	       =						evaluate(a_							)
            __SCREAMING_SNAKE_CASE     :Any	       =						evaluate(a_							)
      elif args.split == "valid":
            __SCREAMING_SNAKE_CASE     :Tuple	       =						evaluate(a_							)
            __SCREAMING_SNAKE_CASE     :Optional[int]	       =						None
      elif args.split == "test":
            __SCREAMING_SNAKE_CASE     :Optional[int]	       =						evaluate(a_							)
            __SCREAMING_SNAKE_CASE     :List[Any]	       =						None

      def format_log(a_  :	int				,     a_  :	List[Any]							):
            __SCREAMING_SNAKE_CASE     :Optional[Any]	       =						'''| {0} loss {1:5.2f} | {0} ppl {2:9.3f} '''.format(a_				,     a_				,     math.exp(a_							)							)
            return log_str

      __SCREAMING_SNAKE_CASE     :Tuple	       =						''''''
      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('''=''' * 1_00							)
      logger.info(a_							)
      logger.info('''=''' * 1_00							)


if __name__ == "__main__":
  main()