



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


snake_case_								=			logging.getLogger(__name__)







@dataclass
class  A_     :



						"""simple docstring"""
						__UpperCamelCase													=				field(
						    metadata={"""help""": """Path to pretrained model or model identifier from huggingface.co/models"""}							)
						__UpperCamelCase													=				field(
						    default=SCREAMING_SNAKE_CASE_      ,  metadata={"""help""": """Pretrained config name or path if not the same as model_name"""}							)
						__UpperCamelCase													=				field(
						    default=SCREAMING_SNAKE_CASE_      ,  metadata={"""help""": """Pretrained tokenizer name or path if not the same as model_name"""}							)
						__UpperCamelCase													=				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"""
						__UpperCamelCase													=				field(
						    metadata={"""help""": """The name of the task to train selected in the list: """ + """, """.join(hans_processors.keys()							)}							)
						__UpperCamelCase													=				field(
						    metadata={"""help""": """The input data dir. Should contain the .tsv files (or other data files) for the task."""}							)
						__UpperCamelCase													=				field(
						    default=1_28      ,  metadata={
						        """help""": (
						            """The maximum total input sequence length after tokenization. Sequences longer """
						            """than this will be truncated, sequences shorter will be padded."""
						        )
						    }      ,  )
						__UpperCamelCase													=				field(
						    default=SCREAMING_SNAKE_CASE_      ,  metadata={"""help""": """Overwrite the cached training and evaluation sets"""}							)


def 					_lowerCAmelCase (  lowercase_		):
						UpperCAmelCase			 =					default_data_collator(lowercase_		)
						UpperCAmelCase			 =					batch.pop('pairID'						,      lowercase_		)
						return batch

def 					_lowerCAmelCase (  ):
						# 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.

						UpperCAmelCase			 =					HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)		)
						UpperCAmelCase ,       UpperCAmelCase ,       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'						,      lowercase_		)

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

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

												UpperCAmelCase			 =					trainer.predict(lowercase_		)
												UpperCAmelCase			 =					output.predictions
												UpperCAmelCase			 =					np.argmax(lowercase_						,      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(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 					_lowerCAmelCase (  lowercase_		):
						# For xla_spawn (TPUs)
						main()


if __name__ == "__main__":
				main()








import json
import os
from collections.abc import Mapping
from typing import Dict, List, Optional, Union

import numpy as np
import torch

from .imports import is_safetensors_available
def   _lowerCAmelCase(						__A ,							__A ,							__A ,							__A=None      ):
  UpperCAmelCase          =	None
  # Check the string instead of the dtype to be compatible with versions of PyTorch that don't have bfloat16.
  if str(weight.dtype      ) == "torch.bfloat16":
    # Need to reinterpret the underlined data as int16 since NumPy does not handle bfloat16s.
    UpperCAmelCase          =	weight.view(torch.intaa      )
    UpperCAmelCase          =	"bfloat16"
  UpperCAmelCase          =	weight.cpu().numpy()
  UpperCAmelCase          =	os.path.join(__A ,							F"{weight_name}.dat"      )
  if index is not None:
    if dtype is None:
      UpperCAmelCase          =	str(array.dtype      )
    UpperCAmelCase          =	{"dtype": dtype, "shape": list(array.shape      )}
  if array.ndim == 0:
    UpperCAmelCase          =	array[None]
  UpperCAmelCase          =	np.memmap(__A ,							dtype=array.dtype ,							mode="w+" ,							shape=array.shape      )
  UpperCAmelCase          =	array[:]
  file_array.flush()
  return index
def   _lowerCAmelCase(						__A ,							__A      ):
  UpperCAmelCase          =	tuple(weight_info["shape"]      )
  if shape == ():
    # NumPy memory-mapped arrays can't have 0 dims so it was saved as 1d tensor
    UpperCAmelCase          =	(1,)

  UpperCAmelCase          =	weight_info["dtype"]
  if dtype == "bfloat16":
    # NumPy does not support bfloat16 so this was saved as a int16
    UpperCAmelCase          =	"int16"

  UpperCAmelCase          =	np.memmap(__A ,							dtype=__A ,							shape=__A ,							mode="r"      )

  if len(weight_info["shape"]      ) == 0:
    UpperCAmelCase          =	weight[0]
  UpperCAmelCase          =	torch.tensor(__A      )
  if weight_info["dtype"] == "bfloat16":
    UpperCAmelCase          =	weight.view(torch.bfloataa      )

  return weight
def   _lowerCAmelCase(						__A ,							__A      ):
  if index is None or len(__A      ) == 0:
    # Nothing to save
    return

  UpperCAmelCase          =	os.path.join(__A ,							"index.json"      )
  if os.path.isfile(__A      ):
    with open(__A ,							"r" ,							encoding="utf-8"      ) as f:
      UpperCAmelCase          =	json.load(__A      )
  else:
    UpperCAmelCase          =	{}
  current_index.update(__A      )

  with open(__A ,							"w" ,							encoding="utf-8"      ) as f:
    json.dump(__A ,							__A ,							indent=2      )
def   _lowerCAmelCase(						__A ,							__A      ):
  os.makedirs(__A ,							exist_ok=__A      )
  UpperCAmelCase          =	{}
  for name, parameter in state_dict.items():
    UpperCAmelCase          =	offload_weight(__A ,							__A ,							__A ,							index=__A      )

  # Update index
  save_offload_index(__A ,							__A      )






class     __magic_name__     (							_snake_case     ):


 def __init__(    self		:			Tuple      ,    lowerCAmelCase__		:			Mapping      ,    lowerCAmelCase__		:			str     )     ->   Tuple:
   UpperCAmelCase          =	dataset
   UpperCAmelCase          =	prefix


 def __getitem__(    self		:			Dict      ,    lowerCAmelCase__		:			Any     )     ->   Optional[int]:
   return self.dataset[f"{self.prefix}{key}"]


 def __iter__(    self		:			Optional[int]     )     ->   Any:
   return iter([key for key in self.dataset if key.startswith(self.prefix     )]     )


 def __len__(    self		:			Union[str, Any]     )     ->   int:
   return len(self.dataset     )






class     __magic_name__     (							_snake_case     ):


 def __init__(    self		:			Optional[int]      ,    lowerCAmelCase__		:			Dict[str, torch.Tensor] = None      ,    lowerCAmelCase__		:			Optional[Union[str, os.PathLike]] = None      ,    lowerCAmelCase__		:			Mapping = None      ,    lowerCAmelCase__		:			Dict=None      ,    )     ->   Dict:
   if state_dict is None and save_folder is None:
     raise ValueError("Need either a `state_dict` or a `save_folder` containing offloaded weights."     )

   UpperCAmelCase          =	{} if state_dict is None else state_dict
   UpperCAmelCase          =	save_folder
   if index is None and save_folder is not None:
     with open(os.path.join(lowerCAmelCase__      ,    "index.json"     )     ) as f:
       UpperCAmelCase          =	json.load(lowerCAmelCase__     )
   UpperCAmelCase          =	{} if index is None else index
   UpperCAmelCase          =	list(self.state_dict.keys()     )
   self.all_keys.extend([key for key in self.index if key not in self.all_keys]     )
   UpperCAmelCase          =	device


 def __getitem__(    self		:			str      ,    lowerCAmelCase__		:			str     )     ->   Dict:
   # State dict gets priority
   if key in self.state_dict:
     return self.state_dict[key]
   UpperCAmelCase          =	self.index[key]
   if weight_info.get("safetensors_file"     ) is not None:
     if not is_safetensors_available():
       raise ImportError("These offloaded weights require the use of safetensors: `pip install safetensors`."     )

     from safetensors import safe_open

     UpperCAmelCase          =	"cpu" if self.device is None else self.device
     with safe_open(weight_info["safetensors_file"]      ,    framework="pt"      ,    device=lowerCAmelCase__     ) as f:
       UpperCAmelCase          =	f.get_tensor(weight_info.get("weight_name"      ,    lowerCAmelCase__     )     )

     if "dtype" in weight_info:
       return tensor.to(getattr(lowerCAmelCase__      ,    weight_info["dtype"]     )     )
     else:
       return tensor

   UpperCAmelCase          =	os.path.join(self.save_folder      ,    f"{key}.dat"     )
   return load_offloaded_weight(lowerCAmelCase__      ,    lowerCAmelCase__     )


 def __iter__(    self		:			str     )     ->   Dict:
   return iter(self.all_keys     )


 def __len__(    self		:			Optional[Any]     )     ->   List[Any]:
   return len(self.all_keys     )

def   _lowerCAmelCase(						__A ,							__A      ):
  UpperCAmelCase          =	{}
  for module_name in submodule_names:
    # We want to catch module_name parameter (module_name.xxx) or potentially module_name, but not any of the
    # submodules that could being like module_name (transformers.h.1 and transformers.h.10 for instance)
    result.update(
        {
            key: param
            for key, param in state_dict.items()
            if key == module_name or key.startswith(module_name + "."      )
        }      )
  return result



