



from typing import TYPE_CHECKING

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


lowerCamelCase__     =	{
    """auto_factory""": ["""get_values"""],
    """configuration_auto""": ["""ALL_PRETRAINED_CONFIG_ARCHIVE_MAP""", """CONFIG_MAPPING""", """MODEL_NAMES_MAPPING""", """AutoConfig"""],
    """feature_extraction_auto""": ["""FEATURE_EXTRACTOR_MAPPING""", """AutoFeatureExtractor"""],
    """image_processing_auto""": ["""IMAGE_PROCESSOR_MAPPING""", """AutoImageProcessor"""],
    """processing_auto""": ["""PROCESSOR_MAPPING""", """AutoProcessor"""],
    """tokenization_auto""": ["""TOKENIZER_MAPPING""", """AutoTokenizer"""],
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCamelCase__     =	[
						    """MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING""",
						    """MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING""",
						    """MODEL_FOR_AUDIO_XVECTOR_MAPPING""",
						    """MODEL_FOR_BACKBONE_MAPPING""",
						    """MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING""",
						    """MODEL_FOR_CAUSAL_LM_MAPPING""",
						    """MODEL_FOR_CTC_MAPPING""",
						    """MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING""",
						    """MODEL_FOR_DEPTH_ESTIMATION_MAPPING""",
						    """MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING""",
						    """MODEL_FOR_IMAGE_SEGMENTATION_MAPPING""",
						    """MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING""",
						    """MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING""",
						    """MODEL_FOR_MASKED_LM_MAPPING""",
						    """MODEL_FOR_MASK_GENERATION_MAPPING""",
						    """MODEL_FOR_MULTIPLE_CHOICE_MAPPING""",
						    """MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING""",
						    """MODEL_FOR_OBJECT_DETECTION_MAPPING""",
						    """MODEL_FOR_PRETRAINING_MAPPING""",
						    """MODEL_FOR_QUESTION_ANSWERING_MAPPING""",
						    """MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING""",
						    """MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING""",
						    """MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING""",
						    """MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING""",
						    """MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING""",
						    """MODEL_FOR_TEXT_ENCODING_MAPPING""",
						    """MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING""",
						    """MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING""",
						    """MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING""",
						    """MODEL_FOR_VISION_2_SEQ_MAPPING""",
						    """MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING""",
						    """MODEL_MAPPING""",
						    """MODEL_WITH_LM_HEAD_MAPPING""",
						    """MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING""",
						    """MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING""",
						    """AutoModel""",
						    """AutoBackbone""",
						    """AutoModelForAudioClassification""",
						    """AutoModelForAudioFrameClassification""",
						    """AutoModelForAudioXVector""",
						    """AutoModelForCausalLM""",
						    """AutoModelForCTC""",
						    """AutoModelForDepthEstimation""",
						    """AutoModelForImageClassification""",
						    """AutoModelForImageSegmentation""",
						    """AutoModelForInstanceSegmentation""",
						    """AutoModelForMaskGeneration""",
						    """AutoModelForTextEncoding""",
						    """AutoModelForMaskedImageModeling""",
						    """AutoModelForMaskedLM""",
						    """AutoModelForMultipleChoice""",
						    """AutoModelForNextSentencePrediction""",
						    """AutoModelForObjectDetection""",
						    """AutoModelForPreTraining""",
						    """AutoModelForQuestionAnswering""",
						    """AutoModelForSemanticSegmentation""",
						    """AutoModelForSeq2SeqLM""",
						    """AutoModelForSequenceClassification""",
						    """AutoModelForSpeechSeq2Seq""",
						    """AutoModelForTableQuestionAnswering""",
						    """AutoModelForTokenClassification""",
						    """AutoModelForUniversalSegmentation""",
						    """AutoModelForVideoClassification""",
						    """AutoModelForVision2Seq""",
						    """AutoModelForVisualQuestionAnswering""",
						    """AutoModelForDocumentQuestionAnswering""",
						    """AutoModelWithLMHead""",
						    """AutoModelForZeroShotImageClassification""",
						    """AutoModelForZeroShotObjectDetection""",
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCamelCase__     =	[
						    """TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING""",
						    """TF_MODEL_FOR_CAUSAL_LM_MAPPING""",
						    """TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING""",
						    """TF_MODEL_FOR_MASK_GENERATION_MAPPING""",
						    """TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING""",
						    """TF_MODEL_FOR_MASKED_LM_MAPPING""",
						    """TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING""",
						    """TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING""",
						    """TF_MODEL_FOR_PRETRAINING_MAPPING""",
						    """TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING""",
						    """TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING""",
						    """TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING""",
						    """TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING""",
						    """TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING""",
						    """TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING""",
						    """TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING""",
						    """TF_MODEL_FOR_TEXT_ENCODING_MAPPING""",
						    """TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING""",
						    """TF_MODEL_FOR_VISION_2_SEQ_MAPPING""",
						    """TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING""",
						    """TF_MODEL_MAPPING""",
						    """TF_MODEL_WITH_LM_HEAD_MAPPING""",
						    """TFAutoModel""",
						    """TFAutoModelForAudioClassification""",
						    """TFAutoModelForCausalLM""",
						    """TFAutoModelForImageClassification""",
						    """TFAutoModelForMaskedImageModeling""",
						    """TFAutoModelForMaskedLM""",
						    """TFAutoModelForMaskGeneration""",
						    """TFAutoModelForMultipleChoice""",
						    """TFAutoModelForNextSentencePrediction""",
						    """TFAutoModelForPreTraining""",
						    """TFAutoModelForDocumentQuestionAnswering""",
						    """TFAutoModelForQuestionAnswering""",
						    """TFAutoModelForSemanticSegmentation""",
						    """TFAutoModelForSeq2SeqLM""",
						    """TFAutoModelForSequenceClassification""",
						    """TFAutoModelForSpeechSeq2Seq""",
						    """TFAutoModelForTableQuestionAnswering""",
						    """TFAutoModelForTextEncoding""",
						    """TFAutoModelForTokenClassification""",
						    """TFAutoModelForVision2Seq""",
						    """TFAutoModelForZeroShotImageClassification""",
						    """TFAutoModelWithLMHead""",
						]

try:
						if not is_flax_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						lowerCamelCase__     =	[
						    """FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING""",
						    """FLAX_MODEL_FOR_CAUSAL_LM_MAPPING""",
						    """FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING""",
						    """FLAX_MODEL_FOR_MASKED_LM_MAPPING""",
						    """FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING""",
						    """FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING""",
						    """FLAX_MODEL_FOR_PRETRAINING_MAPPING""",
						    """FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING""",
						    """FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING""",
						    """FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING""",
						    """FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING""",
						    """FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING""",
						    """FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING""",
						    """FLAX_MODEL_MAPPING""",
						    """FlaxAutoModel""",
						    """FlaxAutoModelForCausalLM""",
						    """FlaxAutoModelForImageClassification""",
						    """FlaxAutoModelForMaskedLM""",
						    """FlaxAutoModelForMultipleChoice""",
						    """FlaxAutoModelForNextSentencePrediction""",
						    """FlaxAutoModelForPreTraining""",
						    """FlaxAutoModelForQuestionAnswering""",
						    """FlaxAutoModelForSeq2SeqLM""",
						    """FlaxAutoModelForSequenceClassification""",
						    """FlaxAutoModelForSpeechSeq2Seq""",
						    """FlaxAutoModelForTokenClassification""",
						    """FlaxAutoModelForVision2Seq""",
						]


if TYPE_CHECKING:
						from .auto_factory import get_values
						from .configuration_auto import ALL_PRETRAINED_CONFIG_ARCHIVE_MAP, CONFIG_MAPPING, MODEL_NAMES_MAPPING, AutoConfig
						from .feature_extraction_auto import FEATURE_EXTRACTOR_MAPPING, AutoFeatureExtractor
						from .image_processing_auto import IMAGE_PROCESSOR_MAPPING, AutoImageProcessor
						from .processing_auto import PROCESSOR_MAPPING, AutoProcessor
						from .tokenization_auto import TOKENIZER_MAPPING, AutoTokenizer

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_auto import (
												    MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
												    MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING,
												    MODEL_FOR_AUDIO_XVECTOR_MAPPING,
												    MODEL_FOR_BACKBONE_MAPPING,
												    MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING,
												    MODEL_FOR_CAUSAL_LM_MAPPING,
												    MODEL_FOR_CTC_MAPPING,
												    MODEL_FOR_DEPTH_ESTIMATION_MAPPING,
												    MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING,
												    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
												    MODEL_FOR_IMAGE_SEGMENTATION_MAPPING,
												    MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING,
												    MODEL_FOR_MASK_GENERATION_MAPPING,
												    MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
												    MODEL_FOR_MASKED_LM_MAPPING,
												    MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
												    MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
												    MODEL_FOR_OBJECT_DETECTION_MAPPING,
												    MODEL_FOR_PRETRAINING_MAPPING,
												    MODEL_FOR_QUESTION_ANSWERING_MAPPING,
												    MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING,
												    MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
												    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
												    MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
												    MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
												    MODEL_FOR_TEXT_ENCODING_MAPPING,
												    MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
												    MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING,
												    MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
												    MODEL_FOR_VISION_2_SEQ_MAPPING,
												    MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING,
												    MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING,
												    MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING,
												    MODEL_MAPPING,
												    MODEL_WITH_LM_HEAD_MAPPING,
												    AutoBackbone,
												    AutoModel,
												    AutoModelForAudioClassification,
												    AutoModelForAudioFrameClassification,
												    AutoModelForAudioXVector,
												    AutoModelForCausalLM,
												    AutoModelForCTC,
												    AutoModelForDepthEstimation,
												    AutoModelForDocumentQuestionAnswering,
												    AutoModelForImageClassification,
												    AutoModelForImageSegmentation,
												    AutoModelForInstanceSegmentation,
												    AutoModelForMaskedImageModeling,
												    AutoModelForMaskedLM,
												    AutoModelForMaskGeneration,
												    AutoModelForMultipleChoice,
												    AutoModelForNextSentencePrediction,
												    AutoModelForObjectDetection,
												    AutoModelForPreTraining,
												    AutoModelForQuestionAnswering,
												    AutoModelForSemanticSegmentation,
												    AutoModelForSeqaSeqLM,
												    AutoModelForSequenceClassification,
												    AutoModelForSpeechSeqaSeq,
												    AutoModelForTableQuestionAnswering,
												    AutoModelForTextEncoding,
												    AutoModelForTokenClassification,
												    AutoModelForUniversalSegmentation,
												    AutoModelForVideoClassification,
												    AutoModelForVisionaSeq,
												    AutoModelForVisualQuestionAnswering,
												    AutoModelForZeroShotImageClassification,
												    AutoModelForZeroShotObjectDetection,
												    AutoModelWithLMHead,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_auto import (
												    TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
												    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
												    TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING,
												    TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
												    TF_MODEL_FOR_MASK_GENERATION_MAPPING,
												    TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
												    TF_MODEL_FOR_MASKED_LM_MAPPING,
												    TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
												    TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
												    TF_MODEL_FOR_PRETRAINING_MAPPING,
												    TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
												    TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING,
												    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
												    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
												    TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
												    TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
												    TF_MODEL_FOR_TEXT_ENCODING_MAPPING,
												    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
												    TF_MODEL_FOR_VISION_2_SEQ_MAPPING,
												    TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING,
												    TF_MODEL_MAPPING,
												    TF_MODEL_WITH_LM_HEAD_MAPPING,
												    TFAutoModel,
												    TFAutoModelForAudioClassification,
												    TFAutoModelForCausalLM,
												    TFAutoModelForDocumentQuestionAnswering,
												    TFAutoModelForImageClassification,
												    TFAutoModelForMaskedImageModeling,
												    TFAutoModelForMaskedLM,
												    TFAutoModelForMaskGeneration,
												    TFAutoModelForMultipleChoice,
												    TFAutoModelForNextSentencePrediction,
												    TFAutoModelForPreTraining,
												    TFAutoModelForQuestionAnswering,
												    TFAutoModelForSemanticSegmentation,
												    TFAutoModelForSeqaSeqLM,
												    TFAutoModelForSequenceClassification,
												    TFAutoModelForSpeechSeqaSeq,
												    TFAutoModelForTableQuestionAnswering,
												    TFAutoModelForTextEncoding,
												    TFAutoModelForTokenClassification,
												    TFAutoModelForVisionaSeq,
												    TFAutoModelForZeroShotImageClassification,
												    TFAutoModelWithLMHead,
												)

						try:
												if not is_flax_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_flax_auto import (
												    FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
												    FLAX_MODEL_FOR_CAUSAL_LM_MAPPING,
												    FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
												    FLAX_MODEL_FOR_MASKED_LM_MAPPING,
												    FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
												    FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
												    FLAX_MODEL_FOR_PRETRAINING_MAPPING,
												    FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
												    FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
												    FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
												    FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
												    FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
												    FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING,
												    FLAX_MODEL_MAPPING,
												    FlaxAutoModel,
												    FlaxAutoModelForCausalLM,
												    FlaxAutoModelForImageClassification,
												    FlaxAutoModelForMaskedLM,
												    FlaxAutoModelForMultipleChoice,
												    FlaxAutoModelForNextSentencePrediction,
												    FlaxAutoModelForPreTraining,
												    FlaxAutoModelForQuestionAnswering,
												    FlaxAutoModelForSeqaSeqLM,
												    FlaxAutoModelForSequenceClassification,
												    FlaxAutoModelForSpeechSeqaSeq,
												    FlaxAutoModelForTokenClassification,
												    FlaxAutoModelForVisionaSeq,
												)

else:
						import sys

						lowerCamelCase__     =	_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





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



def 					lowerCAmelCase__  (							):
				"""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"""			,       _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.

				__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=_SCREAMING_SNAKE_CASE			,       )
				__a					       =						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
				__a					       =						hasattr(model.config			,       """lang2id"""      )
				__a					       =						(
				    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
				)
				__a					       =						(
				    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
				__a					       =						DataCollatorWithPadding(_SCREAMING_SNAKE_CASE			,       pad_to_multiple_of=8      ) if training_args.fpaa else None

				# Initialize our Trainer
				__a					       =						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 					lowerCAmelCase__  (							_SCREAMING_SNAKE_CASE    :     Optional[Any]      ):
				"""simple docstring"""







				main()


if __name__ == "__main__":
						main()
