




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


lowercase      :   Union[str, Any]      =       logging.getLogger(__name__)



def        lowerCamelCase__				(      __lowercase     ,   __lowercase				):
     return (preds == labels).mean()







@dataclass
class 					_a :





     '''simple docstring'''



     lowerCAmelCase_  :     str          =					field(
         metadata={"""help""": """Path to pretrained model or model identifier from huggingface.co/models"""}	)
     lowerCAmelCase_  :     Optional[str]          =					field(
         default=a__,		metadata={"""help""": """Pretrained config name or path if not the same as model_name"""}	)
     lowerCAmelCase_  :     Optional[str]          =					field(
         default=a__,		metadata={"""help""": """Pretrained tokenizer name or path if not the same as model_name"""}	)
     lowerCAmelCase_  :     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'''



     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=128,		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=a__,		metadata={"""help""": """Overwrite the cached training and evaluation sets"""}	)



def        lowerCamelCase__				(      ):
     # 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.

     snake_case			:      Tuple        =			HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)				)
     snake_case ,		snake_case ,		snake_case			:      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"""     ,   __lowercase				)

     # Set seed
     set_seed(training_args.seed				)

     try:
          snake_case			:      Optional[int]        =			processors[data_args.task_name]()
          snake_case			:      Tuple        =			processor.get_labels()
          snake_case			:      List[str]        =			len(__lowercase				)
     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.

     snake_case			:      Any        =			AutoConfig.from_pretrained(
         model_args.config_name if model_args.config_name else model_args.model_name_or_path     ,   num_labels=__lowercase     ,   finetuning_task=data_args.task_name     ,   cache_dir=model_args.cache_dir     ,   )
     snake_case			:      Optional[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     ,   )
     snake_case			:      Optional[Any]        =			AutoModelForMultipleChoice.from_pretrained(
         model_args.model_name_or_path     ,   from_tf=bool(""".ckpt""" in model_args.model_name_or_path				)     ,   config=__lowercase     ,   cache_dir=model_args.cache_dir     ,   )

     # Get datasets
     snake_case			:      Tuple        =			(
         MultipleChoiceDataset(
             data_dir=data_args.data_dir     ,   tokenizer=__lowercase     ,   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
     )
     snake_case			:      Optional[int]        =			(
         MultipleChoiceDataset(
             data_dir=data_args.data_dir     ,   tokenizer=__lowercase     ,   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(__lowercase				) -> Dict:
          snake_case			:      Dict        =			np.argmax(p.predictions     ,   axis=1				)
          return {"acc": simple_accuracy(__lowercase     ,   p.label_ids				)}

     # Data collator
     snake_case			:      Dict        =			DataCollatorWithPadding(__lowercase     ,   pad_to_multiple_of=8				) if training_args.fpaa else None

     # Initialize our Trainer
     snake_case			:      Union[str, Any]        =			Trainer(
         model=__lowercase     ,   args=__lowercase     ,   train_dataset=__lowercase     ,   eval_dataset=__lowercase     ,   compute_metrics=__lowercase     ,   data_collator=__lowercase     ,   )

     # 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
     snake_case			:      List[Any]        =			{}
     if training_args.do_eval:
          logger.info("""*** Evaluate ***"""				)

          snake_case			:      str        =			trainer.evaluate()

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

                    results.update(__lowercase				)

     return results



def        lowerCamelCase__				(      __lowercase				):
     # For xla_spawn (TPUs)
     main()


if __name__ == "__main__":
      main()









'''simple docstring'''







import os


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_doctest_list.py
lowercase      :   List[str]      =       """."""


if __name__ == "__main__":
      lowercase      :   List[str]      =       os.path.join(REPO_PATH, """utils/documentation_tests.txt""")
      lowercase      :   Union[str, Any]      =       []
      lowercase      :   List[str]      =       []
      with open(doctest_file_path) as fp:
            for line in fp:
                  lowercase      :   List[str]      =       line.strip()
                  lowercase      :   Optional[Any]      =       os.path.join(REPO_PATH, line)
                  if not (os.path.isfile(path) or os.path.isdir(path)):
                        non_existent_paths.append(line)
                  all_paths.append(path)
      if len(non_existent_paths) > 0:
            lowercase      :   int      =       """\n""".join(non_existent_paths)
            raise ValueError(F"""`utils/documentation_tests.txt` contains non-existent paths:\n{non_existent_paths}""")
      if all_paths != sorted(all_paths):
            raise ValueError("""Files in `utils/documentation_tests.txt` are not in alphabetical order.""")



