






"""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__					: Any=	logging.getLogger(__name__)







def   lowerCAmelCase_( SCREAMING_SNAKE_CASE ,	SCREAMING_SNAKE_CASE					)					->	List[Any]:
    """simple docstring"""

    return (preds == labels).mean()
@dataclass
class    __lowerCamelCase    :
   a      :				str 						=field(
       metadata={"""help""": """Path to pretrained model or model identifier from huggingface.co/models"""}  )
   a      :				Optional[str] 						=field(
       default=_a							,	metadata={"""help""": """Pretrained config name or path if not the same as model_name"""}  )
   a      :				Optional[str] 						=field(
       default=_a							,	metadata={"""help""": """Pretrained tokenizer name or path if not the same as model_name"""}  )
   a      :				Optional[str] 						=field(
       default=_a							,	metadata={"""help""": """Where do you want to store the pretrained models downloaded from huggingface.co"""}							,	)







@dataclass
class    __lowerCamelCase    :
   a      :				str 						=field(metadata={"""help""": """The name of the task to train on: """ + """, """.join(processors.keys()  )}  )
   a      :				str 						=field(metadata={"""help""": """Should contain the data files for the task."""}  )
   a      :				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."""
           )
       }							,	)
   a      :				bool 						=field(
       default=_a							,	metadata={"""help""": """Overwrite the cached training and evaluation sets"""}  )







def   lowerCAmelCase_( )					->	List[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' ,	SCREAMING_SNAKE_CASE					)

    # Set seed
    set_seed(training_args.seed					)

    try:
        UpperCamelCase__         =    processors[data_args.task_name]()
        UpperCamelCase__         =    processor.get_labels()
        UpperCamelCase__         =    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.

    UpperCamelCase__         =    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 ,	)
    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=SCREAMING_SNAKE_CASE ,	cache_dir=model_args.cache_dir ,	)

    # Get datasets
    UpperCamelCase__         =    (
        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
    )
    UpperCamelCase__         =    (
        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:
        UpperCamelCase__         =    np.argmax(p.predictions ,	axis=1					)
        return {"acc": simple_accuracy(SCREAMING_SNAKE_CASE ,	p.label_ids					)}

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

    # Initialize our Trainer
    UpperCamelCase__         =    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
    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(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   lowerCAmelCase_( SCREAMING_SNAKE_CASE					)					->	Any:
    """simple docstring"""

    main()


if __name__ == "__main__":
  main()












"""simple docstring"""





import doctest
import logging
import os
import unittest
from pathlib import Path
from typing import List, Union

import transformers
from transformers.testing_utils import require_tf, require_torch, slow


A__					: Union[str, Any]=	logging.getLogger()
@unittest.skip("""Temporarily disable the doc tests."""  )
@require_torch
@require_tf
@slow
class    __lowerCamelCase    (  unittest.TestCase  ):

   def 						SCREAMING_SNAKE_CASE__ (					self ,				snake_case_ ,				snake_case_ = None ,				snake_case_ = None ,				snake_case_ = None ,				snake_case_ = True ,				)		->       Tuple:
       UpperCamelCase__         =    [file for file in os.listdir(snake_case_      ) if os.path.isfile(os.path.join(snake_case_ ,				snake_case_      )      )]

       if identifier is not None:
           UpperCamelCase__         =    [file for file in files if identifier in file]

       if n_identifier is not None:
           if isinstance(snake_case_ ,				snake_case_      ):
               for n_ in n_identifier:
                   UpperCamelCase__         =    [file for file in files if n_ not in file]
           else:
               UpperCamelCase__         =    [file for file in files if n_identifier not in file]

       UpperCamelCase__         =    ignore_files or []
       ignore_files.append('__init__.py'      )
       UpperCamelCase__         =    [file for file in files if file not in ignore_files]

       for file in files:
           # Open all files
           print('Testing' ,				snake_case_      )

           if only_modules:
               UpperCamelCase__         =    file.split('.'      )[0]
               try:
                   UpperCamelCase__         =    getattr(snake_case_ ,				snake_case_      )
                   UpperCamelCase__         =    doctest.DocTestSuite(snake_case_      )
                   UpperCamelCase__         =    unittest.TextTestRunner().run(snake_case_      )
                   self.assertIs(len(result.failures      ) ,				0      )
               except AttributeError:
                   logger.info(F'{module_identifier} is not a module.'      )
           else:
               UpperCamelCase__         =    doctest.testfile(str('..' / directory / file      ) ,				optionflags=doctest.ELLIPSIS      )
               self.assertIs(result.failed ,				0      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Union[str, Any]:
       UpperCamelCase__         =    Path('src/transformers'      )
       UpperCamelCase__         =    'modeling'
       UpperCamelCase__         =    [
           'modeling_ctrl.py',
           'modeling_tf_ctrl.py',
       ]
       self.analyze_directory(snake_case_ ,				identifier=snake_case_ ,				ignore_files=snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[int]:
       UpperCamelCase__         =    Path('src/transformers'      )
       UpperCamelCase__         =    'tokenization'
       self.analyze_directory(snake_case_ ,				identifier=snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Optional[Any]:
       UpperCamelCase__         =    Path('src/transformers'      )
       UpperCamelCase__         =    'configuration'
       self.analyze_directory(snake_case_ ,				identifier=snake_case_      )

   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       str:
       UpperCamelCase__         =    Path('src/transformers'      )
       UpperCamelCase__         =    ['configuration', 'modeling', 'tokenization']
       self.analyze_directory(snake_case_ ,				n_identifier=snake_case_      )







   def 						SCREAMING_SNAKE_CASE__ (					self      )		->       Union[str, Any]:
       UpperCamelCase__         =    Path('docs/source'      )
       UpperCamelCase__         =    ['favicon.ico']
       self.analyze_directory(snake_case_ ,				ignore_files=snake_case_ ,				only_modules=snake_case_      )




