
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_      :					Optional[Any]				      =     logging.getLogger(__name__)





@dataclass
class 		__lowerCamelCase     :
							lowerCamelCase__:				str      =							field(
							    metadata={'''help''': '''Path to pretrained model or model identifier from huggingface.co/models'''}		)
							lowerCamelCase__:				Optional[str]      =							field(
							    default=lowercase							, metadata={'''help''': '''Pretrained config name or path if not the same as model_name'''}		)
							lowerCamelCase__:				Optional[str]      =							field(
							    default=lowercase							, metadata={'''help''': '''Pretrained tokenizer name or path if not the same as model_name'''}		)
							lowerCamelCase__:				Optional[str]      =							field(
							    default=lowercase							, metadata={'''help''': '''Where do you want to store the pretrained models downloaded from huggingface.co'''}							, )





@dataclass
class 		__lowerCamelCase     :
							lowerCamelCase__:				str      =							field(
							    metadata={'''help''': '''The name of the task to train selected in the list: ''' + ''', '''.join(hans_processors.keys()		)}		)
							lowerCamelCase__:				str      =							field(
							    metadata={'''help''': '''The input data dir. Should contain the .tsv files (or other data files) for the task.'''}		)
							lowerCamelCase__:				int      =							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__:				bool      =							field(
							    default=lowercase							, metadata={'''help''': '''Overwrite the cached training and evaluation sets'''}		)



def      __UpperCAmelCase    (  snake_case_							:		List[InputFeatures]				):



	'''simple docstring'''



	UpperCAmelCase:					Union[str, Any] 						=     default_data_collator(snake_case_				)
	UpperCAmelCase:					List[Any] 						=     batch.pop("pairID"				,					snake_case_				)
	return batch



def      __UpperCAmelCase    (  ):



	'''simple docstring'''



	UpperCAmelCase:					List[str] 						=     HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)				)
	UpperCAmelCase						,   UpperCAmelCase						,   UpperCAmelCase:					Any 						=     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:
		UpperCAmelCase:					Tuple 						=     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:					List[Any] 						=     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				,					)
	UpperCAmelCase:					List[str] 						=     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:					int 						=     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
	UpperCAmelCase:					List[str] 						=     (
	    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
	)
	UpperCAmelCase:					str 						=     (
	    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
	UpperCAmelCase:					Union[str, Any] 						=     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 ***"				)

		UpperCAmelCase:					Tuple 						=     trainer.predict(snake_case_				)
		UpperCAmelCase:					List[str] 						=     output.predictions
		UpperCAmelCase:					str 						=     np.argmax(snake_case_				,					axis=1				)

		UpperCAmelCase:					List[Any] 						=     [ex.pairID for ex in eval_dataset]
		UpperCAmelCase:					Any 						=     os.path.join(training_args.output_dir				,					"hans_predictions.txt"				)
		UpperCAmelCase:					Dict 						=     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      __UpperCAmelCase    (  snake_case_							:		Tuple				):



	'''simple docstring'''



	main()


if __name__ == "__main__":
	main()


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


snake_case_      :					Dict				      =     {
    'configuration_big_bird': ['BIG_BIRD_PRETRAINED_CONFIG_ARCHIVE_MAP', 'BigBirdConfig', 'BigBirdOnnxConfig'],
}

try:
	if not is_sentencepiece_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	snake_case_      :					str				      =     ['BigBirdTokenizer']

try:
	if not is_tokenizers_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	snake_case_      :					Any				      =     ['BigBirdTokenizerFast']

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	snake_case_      :					Optional[Any]				      =     [
	    'BIG_BIRD_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'BigBirdForCausalLM',
	    'BigBirdForMaskedLM',
	    'BigBirdForMultipleChoice',
	    'BigBirdForPreTraining',
	    'BigBirdForQuestionAnswering',
	    'BigBirdForSequenceClassification',
	    'BigBirdForTokenClassification',
	    'BigBirdLayer',
	    'BigBirdModel',
	    'BigBirdPreTrainedModel',
	    'load_tf_weights_in_big_bird',
	]

try:
	if not is_flax_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	snake_case_      :					Any				      =     [
	    'FlaxBigBirdForCausalLM',
	    'FlaxBigBirdForMaskedLM',
	    'FlaxBigBirdForMultipleChoice',
	    'FlaxBigBirdForPreTraining',
	    'FlaxBigBirdForQuestionAnswering',
	    'FlaxBigBirdForSequenceClassification',
	    'FlaxBigBirdForTokenClassification',
	    'FlaxBigBirdModel',
	    'FlaxBigBirdPreTrainedModel',
	]

if TYPE_CHECKING:
	from .configuration_big_bird import BIG_BIRD_PRETRAINED_CONFIG_ARCHIVE_MAP, BigBirdConfig, BigBirdOnnxConfig

	try:
		if not is_sentencepiece_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_big_bird import BigBirdTokenizer

	try:
		if not is_tokenizers_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_big_bird_fast import BigBirdTokenizerFast

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_big_bird import (
		    BIG_BIRD_PRETRAINED_MODEL_ARCHIVE_LIST,
		    BigBirdForCausalLM,
		    BigBirdForMaskedLM,
		    BigBirdForMultipleChoice,
		    BigBirdForPreTraining,
		    BigBirdForQuestionAnswering,
		    BigBirdForSequenceClassification,
		    BigBirdForTokenClassification,
		    BigBirdLayer,
		    BigBirdModel,
		    BigBirdPreTrainedModel,
		    load_tf_weights_in_big_bird,
		)

	try:
		if not is_flax_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_flax_big_bird import (
		    FlaxBigBirdForCausalLM,
		    FlaxBigBirdForMaskedLM,
		    FlaxBigBirdForMultipleChoice,
		    FlaxBigBirdForPreTraining,
		    FlaxBigBirdForQuestionAnswering,
		    FlaxBigBirdForSequenceClassification,
		    FlaxBigBirdForTokenClassification,
		    FlaxBigBirdModel,
		    FlaxBigBirdPreTrainedModel,
		)

else:
	import sys

	snake_case_      :					int				      =     _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
