


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


__snake_case     =		logging.getLogger(__name__)



@dataclass
class 					__lowerCamelCase	:
       _lowercase    							=      field(
           metadata={"""help""": """Path to pretrained model or model identifier from huggingface.co/models"""}		)
       _lowercase    							=      field(
           default=__A							,     metadata={"""help""": """Pretrained config name or path if not the same as model_name"""}		)
       _lowercase    							=      field(
           default=__A							,     metadata={"""help""": """Pretrained tokenizer name or path if not the same as model_name"""}		)
       _lowercase    							=      field(
           default=__A							,     metadata={"""help""": """Where do you want to store the pretrained models downloaded from huggingface.co"""}							,     )



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






def 						_A						(						_lowercase				)			->				List[Any]:


     """simple docstring"""


     __UpperCamelCase				=	default_data_collator(_a				)
     __UpperCamelCase				=	batch.pop('pairID'			,       _a				)
     return batch






def 						_A						(						)			->				Any:


     """simple docstring"""


     __UpperCamelCase				=	HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)				)
     __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'			,       _a				)

     # Set seed
     set_seed(training_args.seed				)

     try:
          __UpperCamelCase				=	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.

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

     # Get datasets
     __UpperCamelCase				=	(
         HansDataset(
             data_dir=data_args.data_dir			,       tokenizer=_a			,       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
     )
     __UpperCamelCase				=	(
         HansDataset(
             data_dir=data_args.data_dir			,       tokenizer=_a			,       task=data_args.task_name			,       max_seq_length=data_args.max_seq_length			,       overwrite_cache=data_args.overwrite_cache			,       evaluate=_a			,       )
         if training_args.do_eval
         else None
     )

     # Initialize our Trainer
     __UpperCamelCase				=	Trainer(
         model=_a			,       args=_a			,       train_dataset=_a			,       eval_dataset=_a			,       data_collator=_a			,       )

     # 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 ***'				)

          __UpperCamelCase				=	trainer.predict(_a				)
          __UpperCamelCase				=	output.predictions
          __UpperCamelCase				=	np.argmax(_a			,       axis=1				)

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

          trainer._log(output.metrics				)






def 						_A						(						_lowercase				)			->				List[str]:


     """simple docstring"""


     main()


if __name__ == "__main__":
     main()






import os

from apache_beam.io.filesystems import FileSystems
from apache_beam.pipeline import Pipeline

from .logging import get_logger


__snake_case     =		2 << 2_0  # 2mb
__snake_case     =		get_logger(__name__)



class 					__lowerCamelCase	(_a		):







       def 						snake_case_					(	self:				Optional[Any]			):






            '''simple docstring'''




            __UpperCamelCase				=	self._options.get_all_options().get('runner'			)
            return runner in [None, "DirectRunner", "PortableRunner"]






def 						_A						(						_lowercase			,       _lowercase			,       _lowercase=False				)			->				List[Any]:


     """simple docstring"""


     __UpperCamelCase				=	FileSystems
     if fs.exists(_lowercase				):
          if force_upload:
               logger.info(f'''Remote path already exist: {remote_file_path}. Overwriting it as force_upload=True.'''				)
          else:
               logger.info(f'''Remote path already exist: {remote_file_path}. Skipping it as force_upload=False.'''				)
               return
     with fs.create(_lowercase				) as remote_file:
          with open(_lowercase			,       'rb'				) as local_file:
               __UpperCamelCase				=	local_file.read(_lowercase				)
               while chunk:
                    remote_file.write(_lowercase				)
                    __UpperCamelCase				=	local_file.read(_lowercase				)






def 						_A						(						_lowercase			,       _lowercase			,       _lowercase=False				)			->				Optional[Any]:


     """simple docstring"""


     __UpperCamelCase				=	FileSystems
     if os.path.exists(_lowercase				):
          if force_download:
               logger.info(f'''Local path already exist: {remote_file_path}. Overwriting it as force_upload=True.'''				)
          else:
               logger.info(f'''Local path already exist: {remote_file_path}. Skipping it as force_upload=False.'''				)
               return
     with fs.open(_lowercase				) as remote_file:
          with open(_lowercase			,       'wb'				) as local_file:
               __UpperCamelCase				=	remote_file.read(_lowercase				)
               while chunk:
                    local_file.write(_lowercase				)
                    __UpperCamelCase				=	remote_file.read(_lowercase				)


