

'''simple docstring'''

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 					lowerCAmelCase       :
       lowerCAmelCase_				=	field(
           metadata={"help": "Path to pretrained model or model identifier from huggingface.co/models"}				)
       lowerCAmelCase_				=	field(
           default=A				,     metadata={"help": "Pretrained config name or path if not the same as model_name"}				)
       lowerCAmelCase_				=	field(
           default=A				,     metadata={"help": "Pretrained tokenizer name or path if not the same as model_name"}				)
       lowerCAmelCase_				=	field(
           default=A				,     metadata={"help": "Where do you want to store the pretrained models downloaded from huggingface.co"}				,     )






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






def 			__UpperCamelCase							(		lowercase__  :					List[InputFeatures]	):






     '''simple docstring'''





     __lowercase     						=default_data_collator(lowercase__	)
     __lowercase     						=batch.pop('pairID',   lowercase__	)
     return batch

def 			__UpperCamelCase							(		):






     '''simple docstring'''





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

     __lowercase     						=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,   )
     __lowercase     						=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,   )
     __lowercase     						=AutoModelForSequenceClassification.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
     __lowercase     						=(
         HansDataset(
             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,   )
         if training_args.do_train
         else None
     )
     __lowercase     						=(
         HansDataset(
             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,   evaluate=lowercase__,   )
         if training_args.do_eval
         else None
     )

     # Initialize our Trainer
     __lowercase     						=Trainer(
         model=lowercase__,   args=lowercase__,   train_dataset=lowercase__,   eval_dataset=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
     if training_args.do_eval:
          logger.info('*** Evaluate ***'	)

          __lowercase     						=trainer.predict(lowercase__	)
          __lowercase     						=output.predictions
          __lowercase     						=np.argmax(lowercase__,   axis=1	)

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

          trainer._log(output.metrics	)

def 			__UpperCamelCase							(		lowercase__  :					Optional[int]	):






     '''simple docstring'''





     main()


if __name__ == "__main__":
       main()





'''simple docstring'''

from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


UpperCAmelCase							=					logging.get_logger(__name__)


class 					lowerCAmelCase       ( A				):
       lowerCAmelCase_				=	["pixel_values"]







       def __init__(							self     :	List[Any]  , __lowercase     :	bool = True  , __lowercase     :	Optional[Dict[str, int]] = None  , __lowercase     :	PILImageResampling = PILImageResampling.BILINEAR  , __lowercase     :	bool = True  , __lowercase     :	Union[int, float] = 1 / 255  , __lowercase     :	bool = True  , __lowercase     :	Optional[Union[float, List[float]]] = None  , __lowercase     :	Optional[Union[float, List[float]]] = None  , **__lowercase     :	List[Any]  , ):







            """simple docstring"""







            super().__init__(**__lowercase )
            __lowercase     						=size if size is not None else {'height': 224, 'width': 224}
            __lowercase     						=get_size_dict(__lowercase )
            __lowercase     						=do_resize
            __lowercase     						=do_rescale
            __lowercase     						=do_normalize
            __lowercase     						=size
            __lowercase     						=resample
            __lowercase     						=rescale_factor
            __lowercase     						=image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
            __lowercase     						=image_std if image_std is not None else IMAGENET_STANDARD_STD







       def      snake_case				(							self     :	Dict  , __lowercase     :	np.ndarray  , __lowercase     :	Dict[str, int]  , __lowercase     :	PILImageResampling = PILImageResampling.BILINEAR  , __lowercase     :	Optional[Union[str, ChannelDimension]] = None  , **__lowercase     :	Union[str, Any]  , ):







            """simple docstring"""







            __lowercase     						=get_size_dict(__lowercase )
            if "height" not in size or "width" not in size:
                 raise ValueError(f'''The `size` dictionary must contain the keys `height` and `width`. Got {size.keys()}''' )
            return resize(
                __lowercase  , size=(size['height'], size['width'])  , resample=__lowercase  , data_format=__lowercase  , **__lowercase )







       def      snake_case				(							self     :	str  , __lowercase     :	np.ndarray  , __lowercase     :	float  , __lowercase     :	Optional[Union[str, ChannelDimension]] = None  , **__lowercase     :	Optional[Any] ):







            """simple docstring"""







            return rescale(__lowercase  , scale=__lowercase  , data_format=__lowercase  , **__lowercase )







       def      snake_case				(							self     :	Any  , __lowercase     :	np.ndarray  , __lowercase     :	Union[float, List[float]]  , __lowercase     :	Union[float, List[float]]  , __lowercase     :	Optional[Union[str, ChannelDimension]] = None  , **__lowercase     :	str  , ):







            """simple docstring"""







            return normalize(__lowercase  , mean=__lowercase  , std=__lowercase  , data_format=__lowercase  , **__lowercase )







       def      snake_case				(							self     :	str  , __lowercase     :	ImageInput  , __lowercase     :	Optional[bool] = None  , __lowercase     :	Dict[str, int] = None  , __lowercase     :	PILImageResampling = None  , __lowercase     :	Optional[bool] = None  , __lowercase     :	Optional[float] = None  , __lowercase     :	Optional[bool] = None  , __lowercase     :	Optional[Union[float, List[float]]] = None  , __lowercase     :	Optional[Union[float, List[float]]] = None  , __lowercase     :	Optional[Union[str, TensorType]] = None  , __lowercase     :	Union[str, ChannelDimension] = ChannelDimension.FIRST  , **__lowercase     :	Tuple  , ):







            """simple docstring"""







            __lowercase     						=do_resize if do_resize is not None else self.do_resize
            __lowercase     						=do_rescale if do_rescale is not None else self.do_rescale
            __lowercase     						=do_normalize if do_normalize is not None else self.do_normalize
            __lowercase     						=resample if resample is not None else self.resample
            __lowercase     						=rescale_factor if rescale_factor is not None else self.rescale_factor
            __lowercase     						=image_mean if image_mean is not None else self.image_mean
            __lowercase     						=image_std if image_std is not None else self.image_std

            __lowercase     						=size if size is not None else self.size
            __lowercase     						=get_size_dict(__lowercase )

            __lowercase     						=make_list_of_images(__lowercase )

            if not valid_images(__lowercase ):
                 raise ValueError(
                     'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '
                     'torch.Tensor, tf.Tensor or jax.ndarray.' )

            if do_resize and size is None:
                 raise ValueError('Size must be specified if do_resize is True.' )

            if do_rescale and rescale_factor is None:
                 raise ValueError('Rescale factor must be specified if do_rescale is True.' )

            # All transformations expect numpy arrays.
            __lowercase     						=[to_numpy_array(__lowercase ) for image in images]

            if do_resize:
                 __lowercase     						=[self.resize(image=__lowercase  , size=__lowercase  , resample=__lowercase ) for image in images]

            if do_rescale:
                 __lowercase     						=[self.rescale(image=__lowercase  , scale=__lowercase ) for image in images]

            if do_normalize:
                 __lowercase     						=[self.normalize(image=__lowercase  , mean=__lowercase  , std=__lowercase ) for image in images]

            __lowercase     						=[to_channel_dimension_format(__lowercase  , __lowercase ) for image in images]

            __lowercase     						={'pixel_values': images}
            return BatchFeature(data=__lowercase  , tensor_type=__lowercase )


