




'''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_   		=     logging.getLogger(__name__)




def 					__SCREAMING_SNAKE_CASE   (  lowercase_					,     lowercase_      )       ->	Any:

    """simple docstring"""


    return (preds == labels).mean()

@dataclass
class  _lowerCamelCase						:

      """simple docstring"""

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







@dataclass
class  _lowerCamelCase						:

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







def 					__SCREAMING_SNAKE_CASE   (  )       ->	Optional[Any]:

    """simple docstring"""


    __UpperCamelCase  		=						HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)      )
    __UpperCamelCase		,      __UpperCamelCase		,      __UpperCamelCase  		=						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:
        __UpperCamelCase  		=						processors[data_args.task_name]()
        __UpperCamelCase  		=						processor.get_labels()
        __UpperCamelCase  		=						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.

    __UpperCamelCase  		=						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					,     )
    __UpperCamelCase  		=						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					,     )
    __UpperCamelCase  		=						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
    __UpperCamelCase  		=						(
        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
    )
    __UpperCamelCase  		=						(
        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:
        __UpperCamelCase  		=						np.argmax(p.predictions					,     axis=1      )
        return {"acc": simple_accuracy(lowercase_					,     p.label_ids      )}

    # Data collator
    __UpperCamelCase  		=						DataCollatorWithPadding(lowercase_					,     pad_to_multiple_of=8      ) if training_args.fpaa else None

    # Initialize our Trainer
    __UpperCamelCase  		=						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
    __UpperCamelCase  		=						{}
    if training_args.do_eval:
        logger.info('''*** Evaluate ***'''      )

        __UpperCamelCase  		=						trainer.evaluate()

        __UpperCamelCase  		=						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 					__SCREAMING_SNAKE_CASE   (  lowercase_      )       ->	Tuple:

    """simple docstring"""


    main()


if __name__ == "__main__":
 main()












from pathlib import PurePosixPath
from typing import Optional

import fsspec
from fsspec import AbstractFileSystem
from huggingface_hub.hf_api import DatasetInfo

from ..utils.file_utils import get_authentication_headers_for_url
from ..utils.hub import hf_hub_url

class  _lowerCamelCase						(			_SCREAMING_SNAKE_CASE   ):

      """simple docstring"""

      lowerCAmelCase__			: Any    =					""
      lowerCAmelCase__			: Any    =					"hf-legacy"  # "hf://"" is reserved for hffs







      def __init__(     self					: str ,       snake_case					: Optional[DatasetInfo] = None ,       snake_case					: Optional[str] = None ,       **snake_case					: List[Any] ,       ):
          super().__init__(self ,       **snake_case				)
          __UpperCamelCase  		=						repo_info
          __UpperCamelCase  		=						token
          __UpperCamelCase  		=						None







      def       snake_case	(     self					: List[Any]				):
          if self.dir_cache is None:
              __UpperCamelCase  		=						{}
              for hf_file in self.repo_info.siblings:
                  # TODO(QL): add sizes
                  __UpperCamelCase  		=						{
                      '''name''': hf_file.rfilename,
                      '''size''': None,
                      '''type''': '''file''',
                  }
                  self.dir_cache.update(
                      {
                          str(snake_case				): {'''name''': str(snake_case				), '''size''': None, '''type''': '''directory'''}
                          for d in list(PurePosixPath(hf_file.rfilename				).parents				)[:-1]
                      }				)







      def       snake_case	(     self					: Dict ,       snake_case					: str ,       snake_case					: str = "rb" ,       **snake_case					: Union[str, Any] ,       ):
          if not isinstance(self.repo_info ,       snake_case				):
              raise NotImplementedError(F"Open is only implemented for dataset repositories, but got {self.repo_info}"				)
          __UpperCamelCase  		=						hf_hub_url(self.repo_info.id ,       snake_case ,       revision=self.repo_info.sha				)
          return fsspec.open(
              snake_case ,       mode=snake_case ,       headers=get_authentication_headers_for_url(snake_case ,       use_auth_token=self.token				) ,       client_kwargs={'''trust_env''': True} ,       ).open()







      def       snake_case	(     self					: Optional[Any] ,       snake_case					: Tuple ,       **snake_case					: List[Any]				):
          self._get_dirs()
          __UpperCamelCase  		=						self._strip_protocol(snake_case				)
          if path in self.dir_cache:
              return self.dir_cache[path]
          else:
              raise FileNotFoundError(snake_case				)







      def       snake_case	(     self					: List[str] ,       snake_case					: int ,       snake_case					: Tuple=False ,       **snake_case					: Dict				):
          self._get_dirs()
          __UpperCamelCase  		=						PurePosixPath(path.strip('''/'''				)				)
          __UpperCamelCase  		=						{}
          for p, f in self.dir_cache.items():
              __UpperCamelCase  		=						PurePosixPath(p.strip('''/'''				)				)
              __UpperCamelCase  		=						p.parent
              if root == path:
                  __UpperCamelCase  		=						f
          __UpperCamelCase  		=						list(paths.values()				)
          if detail:
              return out
          else:
              return sorted(f['''name'''] for f in out				)






