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


__SCREAMING_SNAKE_CASE				:							str		       =		logging.getLogger(__name__)






@dataclass
class 				__lowerCAmelCase      :

						"""simple docstring"""






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






@dataclass
class 				__lowerCAmelCase      :

						"""simple docstring"""






						_UpperCAmelCase		:					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		:					Tuple      	=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		:					Tuple      	=field(
						    default=SCREAMING_SNAKE_CASE__							, metadata={"help": "Overwrite the cached training and evaluation sets"}	)







def 			a_							(  UpperCamelCase_   ):
							A_ 						=		default_data_collator(UpperCamelCase_   )
							A_ 						=		batch.pop("pairID"	,     UpperCamelCase_   )
							return batch







def 			a_							(  ):
							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"	,     UpperCamelCase_   )

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

							# Get datasets
							A_ 						=		(
							    HansDataset(
							        data_dir=data_args.data_dir	,     tokenizer=UpperCamelCase_	,     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=UpperCamelCase_	,     task=data_args.task_name	,     max_seq_length=data_args.max_seq_length	,     overwrite_cache=data_args.overwrite_cache	,     evaluate=UpperCamelCase_	,     )
							    if training_args.do_eval
							    else None
							)

							# Initialize our Trainer
							A_ 						=		Trainer(
							    model=UpperCamelCase_	,     args=UpperCamelCase_	,     train_dataset=UpperCamelCase_	,     eval_dataset=UpperCamelCase_	,     data_collator=UpperCamelCase_	,     )

							# 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(UpperCamelCase_   )
														A_ 						=		output.predictions
														A_ 						=		np.argmax(UpperCamelCase_	,     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(UpperCamelCase_	,     "w"   ) as writer:
																												writer.write("pairID,gold_label\n"   )
																												for pid, pred in zip(UpperCamelCase_	,     UpperCamelCase_   ):
																																			writer.write("ex" + str(UpperCamelCase_   ) + "," + label_list[int(UpperCamelCase_   )] + "\n"   )

														trainer._log(output.metrics   )







def 			a_							(  UpperCamelCase_   ):
							main()


if __name__ == "__main__":
							main()









'''simple docstring'''
import unittest

import numpy as np

from transformers import is_tf_available
from transformers.testing_utils import require_tf


if is_tf_available():
							import tensorflow as tf

							from transformers.activations_tf import get_tf_activation






@require_tf
class 				__lowerCAmelCase      (      unittest.TestCase	):

						"""simple docstring"""






						def 							_UpperCAmelCase					(     self       :			List[Any]  ):
													A_ 						=		tf.constant([-1_00, -1.0, -0.1, 0, 0.1, 1.0, 1_0_0.0]  )
													A_ 						=		get_tf_activation("gelu"  )
													A_ 						=		get_tf_activation("gelu_10"  )

													A_ 						=		gelu(lowerCAmelCase  )
													A_ 						=		geluaa(lowerCAmelCase  )

													A_ 						=		tf.where(y_gelu_aa < 1_0.0   ,     1.0   ,     0.0  )

													self.assertEqual(tf.math.reduce_max(lowerCAmelCase  ).numpy().item()   ,     1_0.0  )
													self.assertTrue(np.allclose(y_gelu * clipped_mask   ,     y_gelu_aa * clipped_mask  )  )






						def 							_UpperCAmelCase					(     self       :			Union[str, Any]  ):
													get_tf_activation("gelu"  )
													get_tf_activation("gelu_10"  )
													get_tf_activation("gelu_fast"  )
													get_tf_activation("gelu_new"  )
													get_tf_activation("glu"  )
													get_tf_activation("mish"  )
													get_tf_activation("quick_gelu"  )
													get_tf_activation("relu"  )
													get_tf_activation("sigmoid"  )
													get_tf_activation("silu"  )
													get_tf_activation("swish"  )
													get_tf_activation("tanh"  )
													with self.assertRaises(lowerCAmelCase  ):
																				get_tf_activation("bogus"  )
													with self.assertRaises(lowerCAmelCase  ):
																				get_tf_activation(lowerCAmelCase  )





