






"""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
)
A_     :					List[str]							=     logging.getLogger(__name__)






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

 lowerCamelCase__	:     Optional[Any]								=		torch.device('cuda' if torch.cuda.is_available() and not args.no_cuda else 'cpu'							)
 logger.info('device: {}'.format(_lowerCamelCase							)							)

 # 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__	:     Optional[Any]								=		TransfoXLCorpus.from_pretrained(args.model_name							)

 lowerCamelCase__	:     int								=		corpus.get_iterator('valid'     ,  args.batch_size     ,  args.tgt_len     ,  device=_lowerCamelCase     ,  ext_len=args.ext_len							)
 lowerCamelCase__	:     Optional[Any]								=		corpus.get_iterator('test'     ,  args.batch_size     ,  args.tgt_len     ,  device=_lowerCamelCase     ,  ext_len=args.ext_len							)

 # Load a pre-trained model
 lowerCamelCase__	:     Any								=		TransfoXLLMHeadModel.from_pretrained(args.model_name							)
 model.to(_lowerCamelCase							)

 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__	:     Union[str, Any]								=		args.clamp_len
 if args.same_length:
  lowerCamelCase__	:     Optional[Any]								=		True

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

 # Run on test data.
 if args.split == "all":
  lowerCamelCase__	:     str								=		evaluate(_lowerCamelCase							)
  lowerCamelCase__	:     Any								=		evaluate(_lowerCamelCase							)
 elif args.split == "valid":
  lowerCamelCase__	:     Dict								=		evaluate(_lowerCamelCase							)
  lowerCamelCase__	:     List[Any]								=		None
 elif args.split == "test":
  lowerCamelCase__	:     Optional[Any]								=		evaluate(_lowerCamelCase							)
  lowerCamelCase__	:     List[Any]								=		None

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

 lowerCamelCase__	:     Tuple								=		''
 if valid_loss is not None:
  log_str += format_log(_lowerCamelCase     ,  'valid'							)
 if test_loss is not None:
  log_str += format_log(_lowerCamelCase     ,  'test'							)

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


if __name__ == "__main__":
      main()









"""simple docstring"""
import unittest

from cer import CER


A_     :					Union[str, Any]							=     CER()



class 						a_ (      unittest.TestCase					):







      '''simple docstring'''

      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     Optional[Any]								=		['White House']
       lowerCamelCase__	:     List[str]								=		['white house']
       # S = 2, D = 0, I = 0, N = 11, CER = 2 / 11
       lowerCamelCase__	:     Dict								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertTrue(abs(char_error_rate - 0.1_818_181_818   ) < 1e-6   )




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     Union[str, Any]								=		['were wolf']
       lowerCamelCase__	:     Union[str, Any]								=		['werewolf']
       # S = 0, D = 0, I = 1, N = 9, CER = 1 / 9
       lowerCamelCase__	:     Dict								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertTrue(abs(char_error_rate - 0.1_111_111   ) < 1e-6   )

       lowerCamelCase__	:     List[Any]								=		['werewolf']
       lowerCamelCase__	:     Optional[Any]								=		['weae     wolf']
       # S = 1, D = 1, I = 0, N = 8, CER = 0.25
       lowerCamelCase__	:     List[str]								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertTrue(abs(char_error_rate - 0.25   ) < 1e-6   )

       # consecutive whitespaces case 1
       lowerCamelCase__	:     Optional[Any]								=		['were wolf']
       lowerCamelCase__	:     Tuple								=		['were               wolf']
       # S = 0, D = 0, I = 0, N = 9, CER = 0
       lowerCamelCase__	:     Tuple								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertTrue(abs(char_error_rate - 0.0   ) < 1e-6   )

       # consecutive whitespaces case 2
       lowerCamelCase__	:     Any								=		['were   wolf']
       lowerCamelCase__	:     int								=		['were               wolf']
       # S = 0, D = 0, I = 0, N = 9, CER = 0
       lowerCamelCase__	:     Optional[int]								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertTrue(abs(char_error_rate - 0.0   ) < 1e-6   )




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     Optional[Any]								=		['werewolf']
       lowerCamelCase__	:     Optional[int]								=		['weaewolf']
       # S = 1, D = 0, I = 0, N = 8, CER = 0.125
       lowerCamelCase__	:     Union[str, Any]								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertTrue(abs(char_error_rate - 0.125   ) < 1e-6   )




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     int								=		['werewolf']
       lowerCamelCase__	:     Union[str, Any]								=		['wereawolf']
       # S = 0, D = 1, I = 0, N = 8, CER = 0.125
       lowerCamelCase__	:     Any								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertTrue(abs(char_error_rate - 0.125   ) < 1e-6   )




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     List[Any]								=		['werewolf']
       lowerCamelCase__	:     Dict								=		['wereolf']
       # S = 0, D = 0, I = 1, N = 8, CER = 0.125
       lowerCamelCase__	:     int								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertTrue(abs(char_error_rate - 0.125   ) < 1e-6   )




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     Optional[int]								=		['werewolf']
       lowerCamelCase__	:     Tuple								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertEqual(lowerCamelCase_,	0.0   )




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     List[str]								=		['werewolf', 'I am your father']
       lowerCamelCase__	:     List[Any]								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertEqual(lowerCamelCase_,	0.0   )

       lowerCamelCase__	:     Dict								=		['werewolf', 'I am your father', 'doge']
       lowerCamelCase__	:     int								=		['werxwolf', 'I       am your father', 'doge']
       # S = 1, D = 0, I = 0, N = 28, CER = 1 / 28
       lowerCamelCase__	:     Optional[int]								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertTrue(abs(char_error_rate - 0.03_571_428   ) < 1e-6   )




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     Union[str, Any]								=		['My hovercraft', 'is full of eels']
       lowerCamelCase__	:     List[Any]								=		['My hovercraft is full', ' of eels']
       # S = 0, D = 0, I = 2, N = 28, CER = 2 / 28
       # whitespace at the front of " of eels" will be strip during preporcessing
       # so need to insert 2 whitespaces
       lowerCamelCase__	:     Dict								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_,	concatenate_texts=lowerCamelCase_   )
       self.assertTrue(abs(char_error_rate - 0.071_428   ) < 1e-6   )




      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     Optional[Any]								=		['我能吞下玻璃而不伤身体']
       lowerCamelCase__	:     Any								=		[' 能吞虾玻璃而 不霜身体啦']
       # S = 3, D = 2, I = 0, N = 11, CER = 5 / 11
       lowerCamelCase__	:     List[str]								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertTrue(abs(char_error_rate - 0.4_545_454_545   ) < 1e-6   )

       lowerCamelCase__	:     Optional[Any]								=		['我能吞下玻璃', '而不伤身体']
       lowerCamelCase__	:     Optional[Any]								=		['我    能 吞 下 玻 璃', '而不伤身体']
       # S = 0, D = 5, I = 0, N = 11, CER = 5 / 11
       lowerCamelCase__	:     Dict								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertTrue(abs(char_error_rate - 0.454_545_454_545   ) < 1e-6   )

       lowerCamelCase__	:     Optional[int]								=		['我能吞下玻璃而不伤身体']
       lowerCamelCase__	:     Union[str, Any]								=		cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )
       self.assertFalse(lowerCamelCase_,	0.0   )





      def      a__				(self   ):

       '''simple docstring'''



       lowerCamelCase__	:     Optional[int]								=		['']
       lowerCamelCase__	:     Optional[int]								=		['Hypothesis']
       with self.assertRaises(lowerCamelCase_   ):
        cer.compute(predictions=lowerCamelCase_,	references=lowerCamelCase_   )


if __name__ == "__main__":
      unittest.main()

