

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

import numpy as np
import torch
from utils_hans import HansDataset, InputFeatures, hans_processors, hans_tasks_num_labels

import transformers
from transformers import (
    AutoConfig,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    default_data_collator,
    set_seed,
)
from transformers.trainer_utils import is_main_process


_UpperCAmelCase    	=			logging.getLogger(__name__)



@dataclass
class        _UpperCAmelCase :
  '''simple docstring'''







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



@dataclass
class        _UpperCAmelCase :
  '''simple docstring'''







  SCREAMING_SNAKE_CASE							:				str					      =				field(
      metadata={'''help''': '''The name of the task to train selected in the list: ''' + ''', '''.join(hans_processors.keys()			)}			)
  SCREAMING_SNAKE_CASE							:				str					      =				field(
      metadata={'''help''': '''The input data dir. Should contain the .tsv files (or other data files) for the task.'''}			)
  SCREAMING_SNAKE_CASE							:				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.'''
          )
      }     ,				)
  SCREAMING_SNAKE_CASE							:				bool					      =				field(
      default=__lowercase     ,				metadata={'''help''': '''Overwrite the cached training and evaluation sets'''}			)


def 			__UpperCamelCase    (lowerCAmelCase					:  List[InputFeatures]     )     ->  Dict[str, torch.Tensor]:
      A    =				default_data_collator(lowerCAmelCase     )
      A    =				batch.pop('pairID',    lowerCAmelCase     )
      return batch


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

      A    =				HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)     )
      A ,	A ,	A    =				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',    lowerCAmelCase     )

      # Set seed
      set_seed(training_args.seed     )

      try:
            A    =				hans_tasks_num_labels[data_args.task_name]
      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.

      A    =				AutoConfig.from_pretrained(
          model_args.config_name if model_args.config_name else model_args.model_name_or_path,    num_labels=lowerCAmelCase,    finetuning_task=data_args.task_name,    cache_dir=model_args.cache_dir,    )
      A    =				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,    )
      A    =				AutoModelForSequenceClassification.from_pretrained(
          model_args.model_name_or_path,    from_tf=bool('.ckpt' in model_args.model_name_or_path     ),    config=lowerCAmelCase,    cache_dir=model_args.cache_dir,    )

      # Get datasets
      A    =				(
          HansDataset(
              data_dir=data_args.data_dir,    tokenizer=lowerCAmelCase,    task=data_args.task_name,    max_seq_length=data_args.max_seq_length,    overwrite_cache=data_args.overwrite_cache,    )
          if training_args.do_train
          else None
      )
      A    =				(
          HansDataset(
              data_dir=data_args.data_dir,    tokenizer=lowerCAmelCase,    task=data_args.task_name,    max_seq_length=data_args.max_seq_length,    overwrite_cache=data_args.overwrite_cache,    evaluate=lowerCAmelCase,    )
          if training_args.do_eval
          else None
      )

      # Initialize our Trainer
      A    =				Trainer(
          model=lowerCAmelCase,    args=lowerCAmelCase,    train_dataset=lowerCAmelCase,    eval_dataset=lowerCAmelCase,    data_collator=lowerCAmelCase,    )

      # 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
      if training_args.do_eval:
            logger.info('*** Evaluate ***'     )

            A    =				trainer.predict(lowerCAmelCase     )
            A    =				output.predictions
            A    =				np.argmax(lowerCAmelCase,    axis=1     )

            A    =				[ex.pairID for ex in eval_dataset]
            A    =				os.path.join(training_args.output_dir,    'hans_predictions.txt'     )
            A    =				eval_dataset.get_labels()
            if trainer.is_world_master():
                  with open(lowerCAmelCase,    'w'     ) as writer:
                        writer.write('pairID,gold_label\n'     )
                        for pid, pred in zip(lowerCAmelCase,    lowerCAmelCase     ):
                              writer.write('ex' + str(lowerCAmelCase     ) + ',' + label_list[int(lowerCAmelCase     )] + '\n'     )

            trainer._log(output.metrics     )


def 			__UpperCamelCase    (lowerCAmelCase					:  Optional[int]     )     ->  Dict:
      # For xla_spawn (TPUs)
      main()


if __name__ == "__main__":
  main()






from typing import Optional, Tuple

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_openai import OpenAIGPTTokenizer


_UpperCAmelCase    	=			logging.get_logger(__name__)

_UpperCAmelCase    	=			{"vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_file": "tokenizer.json"}

_UpperCAmelCase    	=			{
    "vocab_file": {"openai-gpt": "https://huggingface.co/openai-gpt/resolve/main/vocab.json"},
    "merges_file": {"openai-gpt": "https://huggingface.co/openai-gpt/resolve/main/merges.txt"},
    "tokenizer_file": {"openai-gpt": "https://huggingface.co/openai-gpt/resolve/main/tokenizer.json"},
}

_UpperCAmelCase    	=			{
    "openai-gpt": 512,
}



class        _UpperCAmelCase (   __lowercase			):
  '''simple docstring'''







  SCREAMING_SNAKE_CASE							:				Union[str, Any]					      =				VOCAB_FILES_NAMES
  SCREAMING_SNAKE_CASE							:				Any					      =				PRETRAINED_VOCAB_FILES_MAP
  SCREAMING_SNAKE_CASE							:				Dict					      =				PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  SCREAMING_SNAKE_CASE							:				List[str]					      =				['''input_ids''', '''attention_mask''']
  SCREAMING_SNAKE_CASE							:				Tuple					      =				OpenAIGPTTokenizer







  def __init__( self	: Dict		,						UpperCamelCase__	: List[Any]=None		,						UpperCamelCase__	: Union[str, Any]=None		,						UpperCamelCase__	: Optional[int]=None		,						UpperCamelCase__	: Tuple="<unk>"		,						**UpperCamelCase__	: Union[str, Any] ):
        super().__init__(UpperCamelCase__		,						UpperCamelCase__		,						tokenizer_file=UpperCamelCase__		,						unk_token=UpperCamelCase__		,						**UpperCamelCase__ )







  @property
  def 	UpperCamelCase       ( self	: Optional[Any] ):
        return True







  def 	UpperCamelCase       ( self	: Dict		,						UpperCamelCase__	: str		,						UpperCamelCase__	: Optional[str] = None ):
        A    =				self._tokenizer.model.save(UpperCamelCase__		,						name=UpperCamelCase__ )
        return tuple(UpperCamelCase__ )



