code: 
  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
  
  
  _SCREAMING_SNAKE_CASE   						=    logging.getLogger(__name__)
  
  
  
  
  
  
  
  @dataclass
  class 					UpperCAmelCase_				:
      UpperCAmelCase_			:       Any						 =							field(
          metadata={'help': 'Path to pretrained model or model identifier from huggingface.co/models'}    )
      UpperCAmelCase_			:       int						 =							field(
          default=UpperCamelCase_     ,     metadata={'help': 'Pretrained config name or path if not the same as model_name'}    )
      UpperCAmelCase_			:       List[str]						 =							field(
          default=UpperCamelCase_     ,     metadata={'help': 'Pretrained tokenizer name or path if not the same as model_name'}    )
      UpperCAmelCase_			:       List[Any]						 =							field(
          default=UpperCamelCase_     ,     metadata={'help': 'Where do you want to store the pretrained models downloaded from huggingface.co'}     ,     )
  
  
  
  
  
  
  
  @dataclass
  class 					UpperCAmelCase_				:
      UpperCAmelCase_			:       Optional[Any]						 =							field(
          metadata={'help': 'The name of the task to train selected in the list: ' + ', '.join(hans_processors.keys()    )}    )
      UpperCAmelCase_			:       Optional[Any]						 =							field(
          metadata={'help': 'The input data dir. Should contain the .tsv files (or other data files) for the task.'}    )
      UpperCAmelCase_			:       List[Any]						 =							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.'
              )
          }     ,     )
      UpperCAmelCase_			:       List[str]						 =							field(
          default=UpperCamelCase_     ,     metadata={'help': 'Overwrite the cached training and evaluation sets'}    )
  
  def 				__lowercase	(						lowerCamelCase__					)				->Dict[str, torch.Tensor]:
  
    '''simple docstring'''
  
  
  
  
    a__     		=     default_data_collator(snake_case_					)
    a__     		=     batch.pop("pairID" ,				snake_case_					)
    return batch
  def 				__lowercase	(						)				->Optional[int]:
  
    '''simple docstring'''
  
  
  
  
    a__     		=     HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)					)
    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" ,				snake_case_					)
  
    # 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=snake_case_ ,				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=snake_case_ ,				cache_dir=model_args.cache_dir ,				)
  
    # Get datasets
    a__     		=     (
        HansDataset(
            data_dir=data_args.data_dir ,				tokenizer=snake_case_ ,				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=snake_case_ ,				task=data_args.task_name ,				max_seq_length=data_args.max_seq_length ,				overwrite_cache=data_args.overwrite_cache ,				evaluate=snake_case_ ,				)
        if training_args.do_eval
        else None
    )
  
    # Initialize our Trainer
    a__     		=     Trainer(
        model=snake_case_ ,				args=snake_case_ ,				train_dataset=snake_case_ ,				eval_dataset=snake_case_ ,				data_collator=snake_case_ ,				)
  
    # 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(snake_case_					)
      a__     		=     output.predictions
      a__     		=     np.argmax(snake_case_ ,				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(snake_case_ ,				"w"					) as writer:
          writer.write("pairID,gold_label\n"					)
          for pid, pred in zip(snake_case_ ,				snake_case_					):
            writer.write("ex" + str(snake_case_					) + "," + label_list[int(snake_case_					)] + "\n"					)
  
      trainer._log(output.metrics					)
  def 				__lowercase	(						lowerCamelCase__					)				->Union[str, Any]:
  
    '''simple docstring'''
  
  
  
  
    main()
  
  
  if __name__ == "__main__":
       main()
  
  
style_context: import copy
  
  from ...configuration_utils import PretrainedConfig
  from ...utils import logging
  
  
  _SCREAMING_SNAKE_CASE   						=    logging.get_logger(__name__)
  
  _SCREAMING_SNAKE_CASE   						=    {
      """facebook/sam-vit-huge""": """https://huggingface.co/facebook/sam-vit-huge/resolve/main/config.json""",
      """facebook/sam-vit-large""": """https://huggingface.co/facebook/sam-vit-large/resolve/main/config.json""",
      """facebook/sam-vit-base""": """https://huggingface.co/facebook/sam-vit-base/resolve/main/config.json""",
  }
  
  
  
  
  
  
  
  class 					UpperCAmelCase_				(							_a    ):
  
  
  
  
      def __init__(					self  :   List[str]      ,      lowerCAmelCase  :   str=256      ,      lowerCAmelCase  :   Any=1024      ,      lowerCAmelCase  :   List[str]=16      ,      lowerCAmelCase  :   Union[str, Any]=16      ,      lowerCAmelCase  :   int=4      ,      lowerCAmelCase  :   List[Any]="gelu"      ,      lowerCAmelCase  :   str=1e-6      ,      **lowerCAmelCase  :   Union[str, Any]      ,      )	-> Union[str, Any]:
        super().__init__(**lowerCAmelCase   )
        a__     		=     hidden_size
        a__     		=     image_size
        a__     		=     patch_size
        a__     		=     image_size // patch_size
        a__     		=     mask_input_channels
        a__     		=     num_point_embeddings
        a__     		=     hidden_act
        a__     		=     layer_norm_eps
  
  
  
  
  
  
  
  class 					UpperCAmelCase_				(							_a    ):
  
  
  
  
      def __init__(					self  :   Dict      ,      lowerCAmelCase  :   str=256      ,      lowerCAmelCase  :   Union[str, Any]="relu"      ,      lowerCAmelCase  :   Optional[int]=2048      ,      lowerCAmelCase  :   Any=2      ,      lowerCAmelCase  :   Any=8      ,      lowerCAmelCase  :   Optional[Any]=2      ,      lowerCAmelCase  :   Optional[Any]=3      ,      lowerCAmelCase  :   Union[str, Any]=3      ,      lowerCAmelCase  :   List[str]=256      ,      lowerCAmelCase  :   Optional[Any]=1e-6      ,      **lowerCAmelCase  :   Any      ,      )	-> int:
        super().__init__(**lowerCAmelCase   )
        a__     		=     hidden_size
        a__     		=     hidden_act
        a__     		=     mlp_dim
        a__     		=     num_hidden_layers
        a__     		=     num_attention_heads
        a__     		=     attention_downsample_rate
        a__     		=     num_multimask_outputs
        a__     		=     iou_head_depth
        a__     		=     iou_head_hidden_dim
        a__     		=     layer_norm_eps
  
  
  
  
  
  
  
  class 					UpperCAmelCase_				(							_a    ):
  
  
  
  
      def __init__(					self  :   Optional[Any]      ,      lowerCAmelCase  :   Optional[Any]=768      ,      lowerCAmelCase  :   int=256      ,      lowerCAmelCase  :   Tuple=12      ,      lowerCAmelCase  :   List[str]=12      ,      lowerCAmelCase  :   Tuple=3      ,      lowerCAmelCase  :   Any=1024      ,      lowerCAmelCase  :   Dict=16      ,      lowerCAmelCase  :   Dict="gelu"      ,      lowerCAmelCase  :   List[Any]=1e-0_6      ,      lowerCAmelCase  :   Any=0.0      ,      lowerCAmelCase  :   Optional[Any]=1e-1_0      ,      lowerCAmelCase  :   Tuple=True      ,      lowerCAmelCase  :   Tuple=4.0      ,      lowerCAmelCase  :   Optional[Any]=True      ,      lowerCAmelCase  :   List[str]=True      ,      lowerCAmelCase  :   Dict=14      ,      lowerCAmelCase  :   Optional[int]=[2, 5, 8, 11]      ,      lowerCAmelCase  :   List[str]=128      ,      lowerCAmelCase  :   List[str]=None      ,      **lowerCAmelCase  :   str      ,      )	-> Optional[int]:
        super().__init__(**lowerCAmelCase   )
  
        a__     		=     hidden_size
        a__     		=     output_channels
        a__     		=     num_hidden_layers
        a__     		=     num_attention_heads
        a__     		=     num_channels
        a__     		=     image_size
        a__     		=     patch_size
        a__     		=     hidden_act
        a__     		=     layer_norm_eps
        a__     		=     attention_dropout
        a__     		=     initializer_range
        a__     		=     qkv_bias
        a__     		=     mlp_ratio
        a__     		=     use_abs_pos
        a__     		=     use_rel_pos
        a__     		=     window_size
        a__     		=     global_attn_indexes
        a__     		=     num_pos_feats
        a__     		=     int(hidden_size * mlp_ratio   ) if mlp_dim is None else mlp_dim
  
  
  
  
  
  
  
  class 					UpperCAmelCase_				(							_a    ):
      UpperCAmelCase_			:       Optional[Any]						 =							'sam'
      UpperCAmelCase_			:       List[Any]						 =							True
  
  
  
  
      def __init__(					self  :   Dict      ,      lowerCAmelCase  :   Any=None      ,      lowerCAmelCase  :   Optional[Any]=None      ,      lowerCAmelCase  :   Optional[Any]=None      ,      lowerCAmelCase  :   str=0.02      ,      **lowerCAmelCase  :   int      ,      )	-> Dict:
        super().__init__(**lowerCAmelCase   )
        a__     		=     vision_config if vision_config is not None else {}
        a__     		=     prompt_encoder_config if prompt_encoder_config is not None else {}
        a__     		=     mask_decoder_config if mask_decoder_config is not None else {}
  
        if isinstance(lowerCAmelCase      ,      lowerCAmelCase   ):
          a__     		=     vision_config.to_dict()
        if isinstance(lowerCAmelCase      ,      lowerCAmelCase   ):
          a__     		=     prompt_encoder_config.to_dict()
        if isinstance(lowerCAmelCase      ,      lowerCAmelCase   ):
          a__     		=     mask_decoder_config.to_dict()
  
        a__     		=     SamVisionConfig(**lowerCAmelCase   )
        a__     		=     SamPromptEncoderConfig(**lowerCAmelCase   )
        a__     		=     SamMaskDecoderConfig(**lowerCAmelCase   )
        a__     		=     initializer_range
  
  
  
  
      def 						__lowerCamelCase (					self  :   Optional[Any]   )	-> Union[str, Any]:
        a__     		=     copy.deepcopy(self.__dict__   )
        a__     		=     self.vision_config.to_dict()
        a__     		=     self.prompt_encoder_config.to_dict()
        a__     		=     self.mask_decoder_config.to_dict()
        a__     		=     self.__class__.model_type
        return output
  
  