code: 
  
  
  """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()
style_context: 
  
  
  """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