


"""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


lowerCamelCase_     :     int    		=						logging.getLogger(__name__)






@dataclass
class    __A       :






 """simple docstring"""




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






@dataclass
class    __A       :






 """simple docstring"""




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

def _A		(		lowercase	):







    """simple docstring"""
    a					=default_data_collator(lowercase	)
    a					=batch.pop('''pairID''' ,					lowercase	)
    return batch
def _A		(		):







    """simple docstring"""
    # 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''' ,					lowercase	)

    # 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=lowercase ,					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=lowercase ,					cache_dir=model_args.cache_dir ,					)

    # Get datasets
    a					=(
        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
    )
    a					=(
        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
    a					=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 ***'''	)

        a					=trainer.predict(lowercase	)
        a					=output.predictions
        a					=np.argmax(lowercase ,					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(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 _A		(		lowercase	):







    """simple docstring"""
    # For xla_spawn (TPUs)
    main()


if __name__ == "__main__":
       main()



"""simple docstring"""







import copy

from transformers.configuration_utils import PretrainedConfig
from transformers.utils import logging


lowerCamelCase_     :     int    		=						logging.get_logger(__name__)






class    __A       ( _SCREAMING_SNAKE_CASE    ):






 """simple docstring"""




 __lowerCAmelCase				      =						"hybrid-clip"
 __lowerCAmelCase				      =						True


 def __init__(	self				,					__A=512				,					**__A		)      ->  Any:
     super().__init__(**__A		)

     if "text_config" not in kwargs:
         raise ValueError('''`text_config` can not be `None`.'''		)

     if "vision_config" not in kwargs:
         raise ValueError('''`vision_config` can not be `None`.'''		)

     a					=kwargs.pop('''text_config'''		)
     a					=kwargs.pop('''vision_config'''		)

     a					=text_config.pop('''model_type'''		)
     a					=vision_config.pop('''model_type'''		)

     from transformers import AutoConfig

     a					=AutoConfig.for_model(__A				,					**__A		)

     if vision_model_type == "clip":
         a					=AutoConfig.for_model(__A				,					**__A		).vision_config
     elif vision_model_type == "clip_vision_model":
         from transformers import CLIPVisionConfig

         a					=CLIPVisionConfig(**__A		)
     else:
         a					=AutoConfig.for_model(__A				,					**__A		)

     a					=projection_dim
     a					=1.0


 @classmethod
 def    SCREAMING_SNAKE_CASE							(	cls				,					__A				,					__A				,					**__A		)      ->  Tuple:
     return cls(text_config=text_config.to_dict()				,					vision_config=vision_config.to_dict()				,					**__A		)





 def    SCREAMING_SNAKE_CASE							(	self		)      ->  Optional[int]:
     a					=copy.deepcopy(self.__dict__		)
     a					=self.text_config.to_dict()
     a					=self.vision_config.to_dict()
     a					=self.__class__.model_type
     return output