



'''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


A_				:					int							=      logging.getLogger(__name__)



@dataclass
class 				lowercase			:


 """simple docstring"""


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







def        snake_case_   (	)->						Dict:





       '''simple docstring'''


       _UpperCAmelCase    :		Optional[Any]     	=					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.
              _UpperCAmelCase	,_UpperCAmelCase	,_UpperCAmelCase    :		str     	=					parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]						)						)
       else:
              _UpperCAmelCase	,_UpperCAmelCase	,_UpperCAmelCase    :		Optional[int]     	=					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"""			,  lowerCAmelCase_						)

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

       _UpperCAmelCase    :		Optional[Any]     	=					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			,  )
       _UpperCAmelCase    :		List[Any]     	=					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=lowerCAmelCase_			,  )
       _UpperCAmelCase    :		List[str]     	=					AutoModelForQuestionAnswering.from_pretrained(
           model_args.model_name_or_path			,  from_tf=bool(""".ckpt""" in model_args.model_name_or_path						)			,  config=lowerCAmelCase_			,  cache_dir=model_args.cache_dir			,  )

       # Get datasets
       _UpperCAmelCase    :		Tuple     	=					hasattr(model.config			,  """lang2id"""						)
       _UpperCAmelCase    :		Tuple     	=					(
           SquadDataset(
               lowerCAmelCase_			,  tokenizer=lowerCAmelCase_			,  is_language_sensitive=lowerCAmelCase_			,  cache_dir=model_args.cache_dir						)
           if training_args.do_train
           else None
       )
       _UpperCAmelCase    :		Optional[Any]     	=					(
           SquadDataset(
               lowerCAmelCase_			,  tokenizer=lowerCAmelCase_			,  mode="""dev"""			,  is_language_sensitive=lowerCAmelCase_			,  cache_dir=model_args.cache_dir			,  )
           if training_args.do_eval
           else None
       )

       # Data collator
       _UpperCAmelCase    :		Optional[int]     	=					DataCollatorWithPadding(lowerCAmelCase_			,  pad_to_multiple_of=8						) if training_args.fpaa else None

       # Initialize our Trainer
       _UpperCAmelCase    :		Union[str, Any]     	=					Trainer(
           model=lowerCAmelCase_			,  args=lowerCAmelCase_			,  train_dataset=lowerCAmelCase_			,  eval_dataset=lowerCAmelCase_			,  data_collator=lowerCAmelCase_			,  )

       # 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        snake_case_   (	lowerCAmelCase_						)->						Any:





       '''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        a__			(							):





						"""simple docstring"""

						UpperCAmelCase__												=     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=_UpperCamelCase						,      default=1						,      help='''Number of TPU cores to use (1 or 8).'''			)

						# positional
						parser.add_argument(
						    '''training_script'''						,      type=_UpperCamelCase						,      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=_UpperCamelCase			)

						return parser.parse_args()






def        a__			(							):





						"""simple docstring"""

						UpperCAmelCase__												=     parse_args()

						# Import training_script as a module.
						UpperCAmelCase__												=     Path(args.training_script			)
						sys.path.append(str(script_fpath.parent.resolve()			)			)
						UpperCAmelCase__												=     script_fpath.stem
						UpperCAmelCase__												=     importlib.import_module(_UpperCamelCase			)

						# Patch sys.argv
						UpperCAmelCase__												=     [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()