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






@dataclass
class  a__     :
   snake_case_				=   field(
       metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}						)
   snake_case_				=   field(
       default=A_       ,       metadata={"help": "Pretrained config name or path if not the same as model_name"}						)
   snake_case_				=   field(
       default=A_       ,       metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"}						)
   snake_case_				=   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.
   snake_case_				=   field(
       default=A_       ,       metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"}       ,       )







def        __a (		):






     '''simple docstring'''



     lowercase__								=				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.
          lowercase__								=				parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]   )   )
     else:
          lowercase__								=				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"     ,					_SCREAMING_SNAKE_CASE   )

     # 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.

     lowercase__								=				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     ,					)
     lowercase__								=				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=_SCREAMING_SNAKE_CASE     ,					)
     lowercase__								=				AutoModelForQuestionAnswering.from_pretrained(
         model_args.model_name_or_path     ,					from_tf=bool(".ckpt" in model_args.model_name_or_path   )     ,					config=_SCREAMING_SNAKE_CASE     ,					cache_dir=model_args.cache_dir     ,					)

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

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

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

     # 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        __a (		A   ):






     '''simple docstring'''



     main()


if __name__ == "__main__":
 main()





"""simple docstring"""







import importlib
import sys
from argparse import REMAINDER, ArgumentParser
from pathlib import Path

import torch_xla.distributed.xla_multiprocessing as xmp




def 						_lowercase				(  )    ->     List[str]:







     '''simple docstring'''


     __A					:					int								=		ArgumentParser(
         description=(
             'PyTorch TPU distributed training launch helper utility that will spawn up multiple distributed processes'
         )						)

     # Optional arguments for the launch helper
     parser.add_argument('--num_cores'  ,       type=_SCREAMING_SNAKE_CASE  ,       default=1  ,       help='Number of TPU cores to use (1 or 8).'						)

     # positional
     parser.add_argument(
         'training_script'  ,       type=_SCREAMING_SNAKE_CASE  ,       help=(
             'The full path to the single TPU training '
             'program/script to be launched in parallel, '
             'followed by all the arguments for the '
             'training script'
         )  ,       )

     # rest from the training program
     parser.add_argument('training_script_args'  ,       nargs=_SCREAMING_SNAKE_CASE						)

     return parser.parse_args()




def 						_lowercase				(  )    ->     List[str]:







     '''simple docstring'''


     __A					:					List[str]								=		parse_args()

     # Import training_script as a module.
     __A					:					Dict								=		Path(args.training_script						)
     sys.path.append(str(script_fpath.parent.resolve()						)						)
     __A					:					List[Any]								=		script_fpath.stem
     __A					:					Optional[Any]								=		importlib.import_module(_SCREAMING_SNAKE_CASE						)

     # Patch sys.argv
     __A					:					Union[str, Any]								=		[args.training_script] + args.training_script_args + ['--tpu_num_cores', str(args.num_cores						)]

     xmp.spawn(mod._mp_fn  ,       args=()  ,       nprocs=args.num_cores						)


if __name__ == "__main__":
       main()



