

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


__UpperCAmelCase    				=     logging.getLogger(__name__)







def 	_snake_case		(    SCREAMING_SNAKE_CASE		,							SCREAMING_SNAKE_CASE				)       ->      List[Any]:

     """simple docstring"""







     return (preds == labels).mean()





@dataclass
class A__    :



 """simple docstring"""







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





@dataclass
class A__    :



 """simple docstring"""







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







def 	_snake_case		(    )       ->      Optional[int]:

     """simple docstring"""







     _lowerCAmelCase   :					Any        =    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"		,							SCREAMING_SNAKE_CASE				)

     # Set seed
     set_seed(training_args.seed				)

     try:
          _lowerCAmelCase   :					Tuple        =    processors[data_args.task_name]()
          _lowerCAmelCase   :					Dict        =    processor.get_labels()
          _lowerCAmelCase   :					Tuple        =    len(SCREAMING_SNAKE_CASE				)
     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   :					Dict        =    AutoConfig.from_pretrained(
         model_args.config_name if model_args.config_name else model_args.model_name_or_path		,							num_labels=SCREAMING_SNAKE_CASE		,							finetuning_task=data_args.task_name		,							cache_dir=model_args.cache_dir		,							)
     _lowerCAmelCase   :					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   :					Optional[int]        =    AutoModelForMultipleChoice.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
     _lowerCAmelCase   :					Union[str, Any]        =    (
         MultipleChoiceDataset(
             data_dir=data_args.data_dir		,							tokenizer=SCREAMING_SNAKE_CASE		,							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   :					int        =    (
         MultipleChoiceDataset(
             data_dir=data_args.data_dir		,							tokenizer=SCREAMING_SNAKE_CASE		,							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(SCREAMING_SNAKE_CASE				) -> Dict:
          _lowerCAmelCase   :					List[str]        =    np.argmax(p.predictions		,							axis=1				)
          return {"acc": simple_accuracy(SCREAMING_SNAKE_CASE		,							p.label_ids				)}

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

     # Initialize our Trainer
     _lowerCAmelCase   :					int        =    Trainer(
         model=SCREAMING_SNAKE_CASE		,							args=SCREAMING_SNAKE_CASE		,							train_dataset=SCREAMING_SNAKE_CASE		,							eval_dataset=SCREAMING_SNAKE_CASE		,							compute_metrics=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				)

    # Evaluation
     _lowerCAmelCase   :					str        =    {}
     if training_args.do_eval:
          logger.info("*** Evaluate ***"				)

          _lowerCAmelCase   :					Union[str, Any]        =    trainer.evaluate()

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

                    results.update(SCREAMING_SNAKE_CASE				)

     return results







def 	_snake_case		(    SCREAMING_SNAKE_CASE				)       ->      Dict:

     """simple docstring"""







     main()


if __name__ == "__main__":
  main()









from typing import TYPE_CHECKING

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


__UpperCAmelCase    				=     {
    'configuration_lxmert': ['LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'LxmertConfig'],
    'tokenization_lxmert': ['LxmertTokenizer'],
}

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

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __UpperCAmelCase    				=     [
      'LxmertEncoder',
      'LxmertForPreTraining',
      'LxmertForQuestionAnswering',
      'LxmertModel',
      'LxmertPreTrainedModel',
      'LxmertVisualFeatureEncoder',
      'LxmertXLayer',
  ]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  __UpperCAmelCase    				=     [
      'TF_LXMERT_PRETRAINED_MODEL_ARCHIVE_LIST',
      'TFLxmertForPreTraining',
      'TFLxmertMainLayer',
      'TFLxmertModel',
      'TFLxmertPreTrainedModel',
      'TFLxmertVisualFeatureEncoder',
  ]


if TYPE_CHECKING:
  from .configuration_lxmert import LXMERT_PRETRAINED_CONFIG_ARCHIVE_MAP, LxmertConfig
  from .tokenization_lxmert import LxmertTokenizer

  try:
    if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_lxmert_fast import LxmertTokenizerFast

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_lxmert import (
        LxmertEncoder,
        LxmertForPreTraining,
        LxmertForQuestionAnswering,
        LxmertModel,
        LxmertPreTrainedModel,
        LxmertVisualFeatureEncoder,
        LxmertXLayer,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_lxmert import (
        TF_LXMERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFLxmertForPreTraining,
        TFLxmertMainLayer,
        TFLxmertModel,
        TFLxmertPreTrainedModel,
        TFLxmertVisualFeatureEncoder,
    )

else:
  import sys

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






