



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











from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__lowerCamelCase						= {
    'configuration_bart': ['BART_PRETRAINED_CONFIG_ARCHIVE_MAP', 'BartConfig', 'BartOnnxConfig'],
    'tokenization_bart': ['BartTokenizer'],
}

try:
						if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowerCamelCase						= ['BartTokenizerFast']

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowerCamelCase						= [
						    'BART_PRETRAINED_MODEL_ARCHIVE_LIST',
						    'BartForCausalLM',
						    'BartForConditionalGeneration',
						    'BartForQuestionAnswering',
						    'BartForSequenceClassification',
						    'BartModel',
						    'BartPretrainedModel',
						    'PretrainedBartModel',
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowerCamelCase						= [
						    'TFBartForConditionalGeneration',
						    'TFBartForSequenceClassification',
						    'TFBartModel',
						    'TFBartPretrainedModel',
						]

try:
						if not is_flax_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowerCamelCase						= [
						    'FlaxBartDecoderPreTrainedModel',
						    'FlaxBartForCausalLM',
						    'FlaxBartForConditionalGeneration',
						    'FlaxBartForQuestionAnswering',
						    'FlaxBartForSequenceClassification',
						    'FlaxBartModel',
						    'FlaxBartPreTrainedModel',
						]

if TYPE_CHECKING:
						from .configuration_bart import BART_PRETRAINED_CONFIG_ARCHIVE_MAP, BartConfig, BartOnnxConfig
						from .tokenization_bart import BartTokenizer

						try:
												if not is_tokenizers_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_bart_fast import BartTokenizerFast

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_bart import (
												    BART_PRETRAINED_MODEL_ARCHIVE_LIST,
												    BartForCausalLM,
												    BartForConditionalGeneration,
												    BartForQuestionAnswering,
												    BartForSequenceClassification,
												    BartModel,
												    BartPretrainedModel,
												    PretrainedBartModel,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_bart import (
												    TFBartForConditionalGeneration,
												    TFBartForSequenceClassification,
												    TFBartModel,
												    TFBartPretrainedModel,
												)

						try:
												if not is_flax_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_flax_bart import (
												    FlaxBartDecoderPreTrainedModel,
												    FlaxBartForCausalLM,
												    FlaxBartForConditionalGeneration,
												    FlaxBartForQuestionAnswering,
												    FlaxBartForSequenceClassification,
												    FlaxBartModel,
												    FlaxBartPreTrainedModel,
												)

else:
						import sys

						__lowerCamelCase						= _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)