





"""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_					:						Union[str, Any]      = logging.getLogger(__name__)

@dataclass
class 			_UpperCAmelCase  :



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





def 						UpperCAmelCase__		(					):






  """simple docstring"""





  A_  :	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.
    A_						,	A_						,	A_  :	List[Any]    						=  parser.parse_json_file(json_file=os.path.abspath(sys.argv[1] ) )
  else:
    A_						,	A_						,	A_  :	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'			, _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_  :	str    						=  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_  :	Union[str, 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=_UpperCAmelCase			, )
  A_  :	Tuple    						=  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_  :	int    						=  hasattr(model.config			, 'lang2id' )
  A_  :	Union[str, Any]    						=  (
      SquadDataset(
          _UpperCAmelCase			, tokenizer=_UpperCAmelCase			, is_language_sensitive=_UpperCAmelCase			, cache_dir=model_args.cache_dir )
      if training_args.do_train
      else None
  )
  A_  :	Dict    						=  (
      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_  :	Dict    						=  DataCollatorWithPadding(_UpperCAmelCase			, pad_to_multiple_of=8 ) if training_args.fpaa else None

  # Initialize our Trainer
  A_  :	Optional[int]    						=  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 						UpperCAmelCase__		(					_UpperCAmelCase ):






  """simple docstring"""





  main()


if __name__ == "__main__":
   main()






"""simple docstring"""




from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


lowerCamelCase_					:						List[str]      = logging.get_logger(__name__)

lowerCamelCase_					:						Optional[int]      = {
    'google/electra-small-generator': 'https://huggingface.co/google/electra-small-generator/resolve/main/config.json',
    'google/electra-base-generator': 'https://huggingface.co/google/electra-base-generator/resolve/main/config.json',
    'google/electra-large-generator': 'https://huggingface.co/google/electra-large-generator/resolve/main/config.json',
    'google/electra-small-discriminator': (
        'https://huggingface.co/google/electra-small-discriminator/resolve/main/config.json'
    ),
    'google/electra-base-discriminator': (
        'https://huggingface.co/google/electra-base-discriminator/resolve/main/config.json'
    ),
    'google/electra-large-discriminator': (
        'https://huggingface.co/google/electra-large-discriminator/resolve/main/config.json'
    ),
}

class 			_UpperCAmelCase  (       UpperCAmelCase__		):



      '''simple docstring'''
      lowercase_				:			Tuple        =       """electra"""

      def __init__(					self ,				snake_case_=3_0_5_2_2 ,				snake_case_=1_2_8 ,				snake_case_=2_5_6 ,				snake_case_=1_2 ,				snake_case_=4 ,				snake_case_=1_0_2_4 ,				snake_case_="gelu" ,				snake_case_=0.1 ,				snake_case_=0.1 ,				snake_case_=5_1_2 ,				snake_case_=2 ,				snake_case_=0.02 ,				snake_case_=1E-12 ,				snake_case_="first" ,				snake_case_=True ,				snake_case_="gelu" ,				snake_case_=0.1 ,				snake_case_=0 ,				snake_case_="absolute" ,				snake_case_=True ,				snake_case_=None ,				**snake_case_ ,				):

        """simple docstring"""

        super().__init__(pad_token_id=snake_case_ ,				**snake_case_  )

        A_  :	Optional[Any]    						=  vocab_size
        A_  :	Any    						=  embedding_size
        A_  :	Optional[int]    						=  hidden_size
        A_  :	Tuple    						=  num_hidden_layers
        A_  :	Tuple    						=  num_attention_heads
        A_  :	List[Any]    						=  intermediate_size
        A_  :	Any    						=  hidden_act
        A_  :	str    						=  hidden_dropout_prob
        A_  :	Any    						=  attention_probs_dropout_prob
        A_  :	str    						=  max_position_embeddings
        A_  :	Optional[Any]    						=  type_vocab_size
        A_  :	Dict    						=  initializer_range
        A_  :	Optional[int]    						=  layer_norm_eps

        A_  :	int    						=  summary_type
        A_  :	List[str]    						=  summary_use_proj
        A_  :	Optional[Any]    						=  summary_activation
        A_  :	Optional[Any]    						=  summary_last_dropout
        A_  :	List[Any]    						=  position_embedding_type
        A_  :	Union[str, Any]    						=  use_cache
        A_  :	Tuple    						=  classifier_dropout


class 			_UpperCAmelCase  (       UpperCAmelCase__		):



      '''simple docstring'''

      @property
      def  lowerCamelCase_      (					self  ):

        """simple docstring"""

        if self.task == "multiple-choice":
          A_  :	int    						=  {0: 'batch', 1: 'choice', 2: 'sequence'}
        else:
          A_  :	Optional[Any]    						=  {0: 'batch', 1: 'sequence'}
        return OrderedDict(
            [
                ('input_ids', dynamic_axis),
                ('attention_mask', dynamic_axis),
                ('token_type_ids', dynamic_axis),
            ]  )