






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

					"""simple docstring"""





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



def 							a	(   )				->				Union[str, Any]:






					"""simple docstring"""







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

					a_									=   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					,  )
					a_									=   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					,  )
					a_									=   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
					a_									=   hasattr(model.config					,  'lang2id' )
					a_									=   (
					    SquadDataset(
					        _UpperCAmelCase					,  tokenizer=_UpperCAmelCase					,  is_language_sensitive=_UpperCAmelCase					,  cache_dir=model_args.cache_dir )
					    if training_args.do_train
					    else None
					)
					a_									=   (
					    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
					a_									=   DataCollatorWithPadding(_UpperCAmelCase					,  pad_to_multiple_of=8 ) if training_args.fpaa else None

					# Initialize our Trainer
					a_									=   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 							a	(   _UpperCAmelCase )				->				Optional[Any]:






					"""simple docstring"""







					main()


if __name__ == "__main__":
						main()









'''simple docstring'''
import random
from typing import List, Optional, Union

import numpy as np
import torch

from ..state import AcceleratorState
from .constants import CUDA_DISTRIBUTED_TYPES
from .dataclasses import DistributedType, RNGType
from .imports import is_npu_available, is_tpu_available, is_xpu_available


if is_tpu_available(check_device=False):
						import torch_xla.core.xla_model as xm

def 							a	(   _UpperCAmelCase					,  _UpperCAmelCase = False )				->				List[str]:






					"""simple docstring"""







					if device_specific:
										seed += AcceleratorState().process_index
					random.seed(_UpperCAmelCase )
					np.random.seed(_UpperCAmelCase )
					torch.manual_seed(_UpperCAmelCase )
					if is_xpu_available():
										torch.xpu.manual_seed_all(_UpperCAmelCase )
					elif is_npu_available():
										torch.npu.manual_seed_all(_UpperCAmelCase )
					else:
										torch.cuda.manual_seed_all(_UpperCAmelCase )
					# ^^ safe to call this function even if cuda is not available
					if is_tpu_available():
										xm.set_rng_state(_UpperCAmelCase )

def 							a	(   _UpperCAmelCase = None					,  _UpperCAmelCase = None )				->				Tuple:






					"""simple docstring"""







					if rng_type == RNGType.TORCH:
										a_									=   torch.get_rng_state()
					elif rng_type == RNGType.CUDA:
										a_									=   torch.cuda.get_rng_state()
					elif rng_type == RNGType.XLA:
										assert is_tpu_available(), "Can't synchronize XLA seeds on an environment without TPUs."
										a_									=   torch.tensor(xm.get_rng_state() )
					elif rng_type == RNGType.NPU:
										assert is_npu_available(), "Can't synchronize NPU seeds on an environment without NPUs."
										a_									=   torch.npu.get_rng_state()
					elif rng_type == RNGType.XPU:
										assert is_xpu_available(), "Can't synchronize XPU seeds on an environment without XPUs."
										a_									=   torch.xpu.get_rng_state()
					elif rng_type == RNGType.GENERATOR:
										assert generator is not None, "Need a generator to synchronize its seed."
										a_									=   generator.get_state()

					# Broadcast the rng state from device 0 to other devices
					a_									=   AcceleratorState()
					if state.distributed_type == DistributedType.TPU:
										a_									=   rng_state.to(xm.xla_device() )
										xm.collective_broadcast([rng_state] )
										xm.mark_step()
										a_									=   rng_state.cpu()
					elif (
					    state.distributed_type in CUDA_DISTRIBUTED_TYPES
					    or state.distributed_type == DistributedType.MULTI_NPU
					    or state.distributed_type == DistributedType.MULTI_XPU
					):
										a_									=   rng_state.to(state.device )
										torch.distributed.broadcast(_UpperCAmelCase					,  0 )
										a_									=   rng_state.cpu()
					elif state.distributed_type == DistributedType.MULTI_CPU:
										torch.distributed.broadcast(_UpperCAmelCase					,  0 )

					# Set the broadcast rng state
					if rng_type == RNGType.TORCH:
										torch.set_rng_state(_UpperCAmelCase )
					elif rng_type == RNGType.CUDA:
										torch.cuda.set_rng_state(_UpperCAmelCase )
					elif rng_type == RNGType.NPU:
										torch.npu.set_rng_state(_UpperCAmelCase )
					elif rng_type == RNGType.XPU:
										torch.xpu.set_rng_state(_UpperCAmelCase )
					elif rng_type == RNGType.XLA:
										xm.set_rng_state(rng_state.item() )
					elif rng_type == RNGType.GENERATOR:
										generator.set_state(_UpperCAmelCase )





def 							a	(   _UpperCAmelCase					,  _UpperCAmelCase = None )				->				Any:






					"""simple docstring"""







					for rng_type in rng_types:
										synchronize_rng_state(RNGType(_UpperCAmelCase )					,  generator=_UpperCAmelCase )

