



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


UpperCamelCase__    :     int			  =   logging.getLogger(__name__)


@dataclass
class 							_lowerCAmelCase	:


 """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     UpperCAmelCase     (    )   ->       Union[str, Any]:



   """simple docstring"""






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

   # 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_  :		List[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      ,		)
   A_  :		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=a_      ,		)
   A_  :		int						=					AutoModelForQuestionAnswering.from_pretrained(
       model_args.model_name_or_path      ,		from_tf=bool(""".ckpt""" in model_args.model_name_or_path		)      ,		config=a_      ,		cache_dir=model_args.cache_dir      ,		)

   # Get datasets
   A_  :		Optional[Any]						=					hasattr(model.config      ,		"""lang2id"""		)
   A_  :		List[str]						=					(
       SquadDataset(
           a_      ,		tokenizer=a_      ,		is_language_sensitive=a_      ,		cache_dir=model_args.cache_dir		)
       if training_args.do_train
       else None
   )
   A_  :		Dict						=					(
       SquadDataset(
           a_      ,		tokenizer=a_      ,		mode="""dev"""      ,		is_language_sensitive=a_      ,		cache_dir=model_args.cache_dir      ,		)
       if training_args.do_eval
       else None
   )

   # Data collator
   A_  :		Optional[Any]						=					DataCollatorWithPadding(a_      ,		pad_to_multiple_of=8		) if training_args.fpaa else None

   # Initialize our Trainer
   A_  :		str						=					Trainer(
       model=a_      ,		args=a_      ,		train_dataset=a_      ,		eval_dataset=a_      ,		data_collator=a_      ,		)

   # 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     UpperCAmelCase     (    a_		)   ->       List[Any]:



   """simple docstring"""






   main()


if __name__ == "__main__":
  main()





'''simple docstring'''





from ..utils import DummyObject, requires_backends


class 							_lowerCAmelCase	(  metaclass=__A							):


 """simple docstring"""

 lowerCamelCase									=     ['''torch''', '''librosa''']







 def __init__(      self					,    *_lowerCamelCase					,    **_lowerCamelCase  )    ->    str:
    requires_backends(self					,    ["""torch""", """librosa"""]  )







 @classmethod
 def       UpperCAmelCase_       (      cls					,    *_lowerCamelCase					,    **_lowerCamelCase  )    ->    Dict:
    requires_backends(cls					,    ["""torch""", """librosa"""]  )







 @classmethod
 def       UpperCAmelCase_       (      cls					,    *_lowerCamelCase					,    **_lowerCamelCase  )    ->    Optional[int]:
    requires_backends(cls					,    ["""torch""", """librosa"""]  )


class 							_lowerCAmelCase	(  metaclass=__A							):


 """simple docstring"""

 lowerCamelCase									=     ['''torch''', '''librosa''']







 def __init__(      self					,    *_lowerCamelCase					,    **_lowerCamelCase  )    ->    Dict:
    requires_backends(self					,    ["""torch""", """librosa"""]  )







 @classmethod
 def       UpperCAmelCase_       (      cls					,    *_lowerCamelCase					,    **_lowerCamelCase  )    ->    str:
    requires_backends(cls					,    ["""torch""", """librosa"""]  )







 @classmethod
 def       UpperCAmelCase_       (      cls					,    *_lowerCamelCase					,    **_lowerCamelCase  )    ->    Dict:
    requires_backends(cls					,    ["""torch""", """librosa"""]  )
