




'''simple docstring'''



import logging
import os
import sys
from dataclasses import dataclass, field
from typing import Optional

import transformers
from transformers import (
    AutoConfig,
    AutoModelForQuestionAnswering,
    AutoTokenizer,
    DataCollatorWithPadding,
    HfArgumentParser,
    SquadDataset,
    Trainer,
    TrainingArguments,
)
from transformers import SquadDataTrainingArguments as DataTrainingArguments
from transformers.trainer_utils import is_main_process


lowerCamelCase_		       =						logging.getLogger(__name__)







@dataclass
class 		lowercase_    :


   """simple docstring"""

   lowerCamelCase_				  =						field(
       metadata={'''help''': '''Path to pretrained model or model identifier from huggingface.co/models'''}   )
   lowerCamelCase_				  =						field(
       default=a__     ,  metadata={'''help''': '''Pretrained config name or path if not the same as model_name'''}   )
   lowerCamelCase_				  =						field(
       default=a__     ,  metadata={'''help''': '''Pretrained tokenizer name or path if not the same as model_name'''}   )
   lowerCamelCase_				  =						field(default=a__     ,  metadata={'''help''': '''Set this flag to use fast tokenization.'''}   )
   # If you want to tweak more attributes on your tokenizer, you should do it in a distinct script,
   # or just modify its tokenizer_config.json.
   lowerCamelCase_				  =						field(
       default=a__     ,  metadata={'''help''': '''Where do you want to store the pretrained models downloaded from huggingface.co'''}     ,  )


def  SCREAMING_SNAKE_CASE_ (							) -> Tuple:
   # See all possible arguments in src/transformers/training_args.py
   # or by passing the --help flag to this script.
   # We now keep distinct sets of args, for a cleaner separation of concerns.

   _SCREAMING_SNAKE_CASE       =      HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)  )

   if len(sys.argv  ) == 2 and sys.argv[1].endswith(".json"  ):
      # If we pass only one argument to the script and it's the path to a json file,
      # let's parse it to get our arguments.
      _SCREAMING_SNAKE_CASE,       _SCREAMING_SNAKE_CASE,       _SCREAMING_SNAKE_CASE       =      parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]  )  )
   else:
      _SCREAMING_SNAKE_CASE,       _SCREAMING_SNAKE_CASE,       _SCREAMING_SNAKE_CASE       =      parser.parse_args_into_dataclasses()

   if (
       os.path.exists(training_args.output_dir  )
       and os.listdir(training_args.output_dir  )
       and training_args.do_train
       and not training_args.overwrite_output_dir
   ):
      raise ValueError(
          f"""Output directory ({training_args.output_dir}) already exists and is not empty. Use"""
          " --overwrite_output_dir to overcome."  )

   # Setup logging
   logging.basicConfig(
       format="%(asctime)s - %(levelname)s - %(name)s - %(message)s"       ,     datefmt="%m/%d/%Y %H:%M:%S"       ,     level=logging.INFO if training_args.local_rank in [-1, 0] else logging.WARN       ,     )
   logger.warning(
       "Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s"       ,     training_args.local_rank       ,     training_args.device       ,     training_args.n_gpu       ,     bool(training_args.local_rank != -1  )       ,     training_args.fpaa       ,     )
   # Set the verbosity to info of the Transformers logger (on main process only):
   if is_main_process(training_args.local_rank  ):
      transformers.utils.logging.set_verbosity_info()
      transformers.utils.logging.enable_default_handler()
      transformers.utils.logging.enable_explicit_format()
   logger.info("Training/evaluation parameters %s"       ,     _UpperCAmelCase  )

   # Prepare Question-Answering task
   # Load pretrained model and tokenizer
   #
   # Distributed training:
   # The .from_pretrained methods guarantee that only one local process can concurrently
   # download model & vocab.

   _SCREAMING_SNAKE_CASE       =      AutoConfig.from_pretrained(
       model_args.config_name if model_args.config_name else model_args.model_name_or_path       ,     cache_dir=model_args.cache_dir       ,     )
   _SCREAMING_SNAKE_CASE       =      AutoTokenizer.from_pretrained(
       model_args.tokenizer_name if model_args.tokenizer_name else model_args.model_name_or_path       ,     cache_dir=model_args.cache_dir       ,     use_fast=_UpperCAmelCase       ,     )
   _SCREAMING_SNAKE_CASE       =      AutoModelForQuestionAnswering.from_pretrained(
       model_args.model_name_or_path       ,     from_tf=bool(".ckpt" in model_args.model_name_or_path  )       ,     config=_UpperCAmelCase       ,     cache_dir=model_args.cache_dir       ,     )

   # Get datasets
   _SCREAMING_SNAKE_CASE       =      hasattr(model.config       ,     "lang2id"  )
   _SCREAMING_SNAKE_CASE       =      (
       SquadDataset(
           _UpperCAmelCase       ,     tokenizer=_UpperCAmelCase       ,     is_language_sensitive=_UpperCAmelCase       ,     cache_dir=model_args.cache_dir  )
       if training_args.do_train
       else None
   )
   _SCREAMING_SNAKE_CASE       =      (
       SquadDataset(
           _UpperCAmelCase       ,     tokenizer=_UpperCAmelCase       ,     mode="dev"       ,     is_language_sensitive=_UpperCAmelCase       ,     cache_dir=model_args.cache_dir       ,     )
       if training_args.do_eval
       else None
   )

   # Data collator
   _SCREAMING_SNAKE_CASE       =      DataCollatorWithPadding(_UpperCAmelCase       ,     pad_to_multiple_of=8  ) if training_args.fpaa else None

   # Initialize our Trainer
   _SCREAMING_SNAKE_CASE       =      Trainer(
       model=_UpperCAmelCase       ,     args=_UpperCAmelCase       ,     train_dataset=_UpperCAmelCase       ,     eval_dataset=_UpperCAmelCase       ,     data_collator=_UpperCAmelCase       ,     )

   # Training
   if training_args.do_train:
      trainer.train(
          model_path=model_args.model_name_or_path if os.path.isdir(model_args.model_name_or_path  ) else None  )
      trainer.save_model()
      # For convenience, we also re-save the tokenizer to the same directory,
      # so that you can share your model easily on huggingface.co/models =)
      if trainer.is_world_master():
         tokenizer.save_pretrained(training_args.output_dir  )
def  SCREAMING_SNAKE_CASE_ (							__A				: Any  ) -> List[str]:
   # For xla_spawn (TPUs)
   main()


if __name__ == "__main__":
 main()








"""simple docstring"""
__UpperCamelCase			:		Tuple		    =   10**8

def 						_SCREAMING_SNAKE_CASE       (_UpperCAmelCase :  int       ):
 if n % 10 == 0:
  return False
 lowerCAmelCase  							=      str(_UpperCAmelCase       )
 return s == s[::-1]

def 						_SCREAMING_SNAKE_CASE       ():
 lowerCAmelCase  							=      set()
 lowerCAmelCase  							=      1
 lowerCAmelCase  							=      5
 while sum_squares < LIMIT:
  lowerCAmelCase  							=      first_square + 1
  while sum_squares < LIMIT:
   if is_palindrome(_UpperCAmelCase       ):
    answer.add(_UpperCAmelCase       )
   last_square += 1
   sum_squares += last_square**2
  first_square += 1
  lowerCAmelCase  							=      first_square**2 + (first_square + 1) ** 2

 return sum(_UpperCAmelCase       )


if __name__ == "__main__":
       print(solution())





