


'''simple docstring'''



import logging
import os
from dataclasses import dataclass, field
from typing import Dict, Optional

import numpy as np
from utils_multiple_choice import MultipleChoiceDataset, Split, processors

import transformers
from transformers import (
    AutoConfig,
    AutoModelForMultipleChoice,
    AutoTokenizer,
    DataCollatorWithPadding,
    EvalPrediction,
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    set_seed,
)
from transformers.trainer_utils import is_main_process


A__		:					List[str]												=  logging.getLogger(__name__)



def 			UpperCAmelCase__					(	UpperCAmelCase_    :				Union[str, Any]      ,    UpperCAmelCase_    :				int							)     ->		Optional[int]:
     return (preds == labels).mean()





@dataclass
class    UpperCAmelCase_  :





    """simple docstring"""






    lowerCamelCase  :					str							     =			field(
        metadata={'help': 'Path to pretrained model or model identifier from huggingface.co/models'}  )
    lowerCamelCase  :					Optional[str]							     =			field(
        default=_UpperCAmelCase					,		metadata={'help': 'Pretrained config name or path if not the same as model_name'}  )
    lowerCamelCase  :					Optional[str]							     =			field(
        default=_UpperCAmelCase					,		metadata={'help': 'Pretrained tokenizer name or path if not the same as model_name'}  )
    lowerCamelCase  :					Optional[str]							     =			field(
        default=_UpperCAmelCase					,		metadata={'help': 'Where do you want to store the pretrained models downloaded from huggingface.co'}					,		)







@dataclass
class    UpperCAmelCase_  :





    """simple docstring"""






    lowerCamelCase  :					str							     =			field(metadata={'help': 'The name of the task to train on: ' + ', '.join(processors.keys()  )}  )
    lowerCamelCase  :					str							     =			field(metadata={'help': 'Should contain the data files for the task.'}  )
    lowerCamelCase  :					int							     =			field(
        default=1_2_8					,		metadata={
            'help': (
                'The maximum total input sequence length after tokenization. Sequences longer '
                'than this will be truncated, sequences shorter will be padded.'
            )
        }					,		)
    lowerCamelCase  :					bool							     =			field(
        default=_UpperCAmelCase					,		metadata={'help': 'Overwrite the cached training and evaluation sets'}  )







def 			UpperCAmelCase__					(	)     ->		Union[str, Any]:
     # See all possible arguments in src/transformers/training_args.py
     # or by passing the --help flag to this script.
     # We now keep distinct sets of args, for a cleaner separation of concerns.

     __lowerCamelCase   :	int								=		HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)							)
     __lowerCamelCase				,       __lowerCamelCase				,       __lowerCamelCase   :	List[str]								=		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_							)

     # Set seed
     set_seed(training_args.seed							)

     try:
          __lowerCamelCase   :	Dict								=		processors[data_args.task_name]()
          __lowerCamelCase   :	str								=		processor.get_labels()
          __lowerCamelCase   :	List[str]								=		len(UpperCAmelCase_							)
     except KeyError:
          raise ValueError('Task not found: %s' % (data_args.task_name)							)

     # Load pretrained model and tokenizer
     #
     # Distributed training:
     # The .from_pretrained methods guarantee that only one local process can concurrently
     # download model & vocab.

     __lowerCamelCase   :	List[Any]								=		AutoConfig.from_pretrained(
         model_args.config_name if model_args.config_name else model_args.model_name_or_path      ,    num_labels=UpperCAmelCase_      ,    finetuning_task=data_args.task_name      ,    cache_dir=model_args.cache_dir      ,    )
     __lowerCamelCase   :	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      ,    )
     __lowerCamelCase   :	Union[str, Any]								=		AutoModelForMultipleChoice.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
     __lowerCamelCase   :	List[str]								=		(
         MultipleChoiceDataset(
             data_dir=data_args.data_dir      ,    tokenizer=UpperCAmelCase_      ,    task=data_args.task_name      ,    max_seq_length=data_args.max_seq_length      ,    overwrite_cache=data_args.overwrite_cache      ,    mode=Split.train      ,    )
         if training_args.do_train
         else None
     )
     __lowerCamelCase   :	List[Any]								=		(
         MultipleChoiceDataset(
             data_dir=data_args.data_dir      ,    tokenizer=UpperCAmelCase_      ,    task=data_args.task_name      ,    max_seq_length=data_args.max_seq_length      ,    overwrite_cache=data_args.overwrite_cache      ,    mode=Split.dev      ,    )
         if training_args.do_eval
         else None
     )

     def compute_metrics(UpperCAmelCase_    :				EvalPrediction							) -> Dict:
          __lowerCamelCase   :	Union[str, Any]								=		np.argmax(p.predictions      ,    axis=1							)
          return {"acc": simple_accuracy(UpperCAmelCase_      ,    p.label_ids							)}

     # Data collator
     __lowerCamelCase   :	List[str]								=		DataCollatorWithPadding(UpperCAmelCase_      ,    pad_to_multiple_of=8							) if training_args.fpaa else None

     # Initialize our Trainer
     __lowerCamelCase   :	Tuple								=		Trainer(
         model=UpperCAmelCase_      ,    args=UpperCAmelCase_      ,    train_dataset=UpperCAmelCase_      ,    eval_dataset=UpperCAmelCase_      ,    compute_metrics=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							)

    # Evaluation
     __lowerCamelCase   :	Optional[int]								=		{}
     if training_args.do_eval:
          logger.info('*** Evaluate ***'							)

          __lowerCamelCase   :	List[str]								=		trainer.evaluate()

          __lowerCamelCase   :	Dict								=		os.path.join(training_args.output_dir      ,    'eval_results.txt'							)
          if trainer.is_world_master():
               with open(UpperCAmelCase_      ,    'w'							) as writer:
                    logger.info('***** Eval results *****'							)
                    for key, value in result.items():
                         logger.info('  %s = %s'      ,    UpperCAmelCase_      ,    UpperCAmelCase_							)
                         writer.write('%s = %s\n' % (key, value)							)

                    results.update(UpperCAmelCase_							)

     return results



def 			UpperCAmelCase__					(	UpperCAmelCase_    :				Any							)     ->		Dict:
     # For xla_spawn (TPUs)
     main()


if __name__ == "__main__":
      main()










'''simple docstring'''



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


A__		:					List[Any]												=  {
    """configuration_megatron_bert""": ["""MEGATRON_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """MegatronBertConfig"""],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      A__		:					int												=  [
          """MEGATRON_BERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """MegatronBertForCausalLM""",
          """MegatronBertForMaskedLM""",
          """MegatronBertForMultipleChoice""",
          """MegatronBertForNextSentencePrediction""",
          """MegatronBertForPreTraining""",
          """MegatronBertForQuestionAnswering""",
          """MegatronBertForSequenceClassification""",
          """MegatronBertForTokenClassification""",
          """MegatronBertModel""",
          """MegatronBertPreTrainedModel""",
      ]

if TYPE_CHECKING:
      from .configuration_megatron_bert import MEGATRON_BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, MegatronBertConfig

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_megatron_bert import (
                MEGATRON_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
                MegatronBertForCausalLM,
                MegatronBertForMaskedLM,
                MegatronBertForMultipleChoice,
                MegatronBertForNextSentencePrediction,
                MegatronBertForPreTraining,
                MegatronBertForQuestionAnswering,
                MegatronBertForSequenceClassification,
                MegatronBertForTokenClassification,
                MegatronBertModel,
                MegatronBertPreTrainedModel,
            )

else:
      import sys

      A__		:					List[Any]												=  _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)






