



'''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 :      Union[str, Any]             =logging.getLogger(__name__)


@dataclass
class   SCREAMING_SNAKE_CASE__				:
	"""simple docstring"""


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







@dataclass
class   SCREAMING_SNAKE_CASE__				:
	"""simple docstring"""


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







def 		_SCREAMING_SNAKE_CASE							(				lowerCamelCase__   :      List[InputFeatures]				):


			'''simple docstring'''







			A:      str														=   default_data_collator(lowerCamelCase__				)
			A:      Optional[int]														=   batch.pop("""pairID"""							,							lowerCamelCase__				)
			return batch



def 		_SCREAMING_SNAKE_CASE							(				):


			'''simple docstring'''







			A:      Tuple														=   HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)				)
			A							,		A							,		A:      List[str]														=   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"""							,							lowerCamelCase__				)

			# Set seed
			set_seed(training_args.seed				)

			try:
						A:      List[Any]														=   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:      str														=   AutoConfig.from_pretrained(
			    model_args.config_name if model_args.config_name else model_args.model_name_or_path							,							num_labels=lowerCamelCase__							,							finetuning_task=data_args.task_name							,							cache_dir=model_args.cache_dir							,							)
			A:      Optional[Any]														=   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:      Union[str, Any]														=   AutoModelForSequenceClassification.from_pretrained(
			    model_args.model_name_or_path							,							from_tf=bool(""".ckpt""" in model_args.model_name_or_path				)							,							config=lowerCamelCase__							,							cache_dir=model_args.cache_dir							,							)

			# Get datasets
			A:      Union[str, Any]														=   (
			    HansDataset(
			        data_dir=data_args.data_dir							,							tokenizer=lowerCamelCase__							,							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:      Optional[int]														=   (
			    HansDataset(
			        data_dir=data_args.data_dir							,							tokenizer=lowerCamelCase__							,							task=data_args.task_name							,							max_seq_length=data_args.max_seq_length							,							overwrite_cache=data_args.overwrite_cache							,							evaluate=lowerCamelCase__							,							)
			    if training_args.do_eval
			    else None
			)

			# Initialize our Trainer
			A:      int														=   Trainer(
			    model=lowerCamelCase__							,							args=lowerCamelCase__							,							train_dataset=lowerCamelCase__							,							eval_dataset=lowerCamelCase__							,							data_collator=lowerCamelCase__							,							)

			# 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:      Optional[int]														=   trainer.predict(lowerCamelCase__				)
						A:      int														=   output.predictions
						A:      List[str]														=   np.argmax(lowerCamelCase__							,							axis=1				)

						A:      Tuple														=   [ex.pairID for ex in eval_dataset]
						A:      Any														=   os.path.join(training_args.output_dir							,							"""hans_predictions.txt"""				)
						A:      List[Any]														=   eval_dataset.get_labels()
						if trainer.is_world_master():
									with open(lowerCamelCase__							,							"""w"""				) as writer:
												writer.write("""pairID,gold_label\n"""				)
												for pid, pred in zip(lowerCamelCase__							,							lowerCamelCase__				):
															writer.write("""ex""" + str(lowerCamelCase__				) + """,""" + label_list[int(lowerCamelCase__				)] + """\n"""				)

						trainer._log(output.metrics				)



def 		_SCREAMING_SNAKE_CASE							(				lowerCamelCase__   :      List[Any]				):


			'''simple docstring'''







			main()


if __name__ == "__main__":
					main()










'''simple docstring'''
import itertools
from dataclasses import dataclass
from typing import Optional

import pyarrow as pa

import datasets
from datasets.table import table_cast


__SCREAMING_SNAKE_CASE :      List[Any]             =datasets.utils.logging.get_logger(__name__)


@dataclass
class   SCREAMING_SNAKE_CASE__				(   datasets.BuilderConfig					):
	"""simple docstring"""


	A__    :    Optional[datasets.Features]						=				None







class   SCREAMING_SNAKE_CASE__				(   datasets.ArrowBasedBuilder					):
	"""simple docstring"""


	A__    :    Optional[int]						=				ArrowConfig


	def      a__ (		self			) ->							Union[str, Any]:
				return datasets.DatasetInfo(features=self.config.features			)


	def      a__ (		self					,   A			) ->							Any:
				if not self.config.data_files:
							raise ValueError(f'At least one data file must be specified, but got data_files={self.config.data_files}'			)
				A:      Tuple														=   dl_manager.download_and_extract(self.config.data_files			)
				if isinstance(A					,   (str, list, tuple)			):
							A:      Union[str, Any]														=   data_files
							if isinstance(A					,   A			):
										A:      Tuple														=   [files]
							# Use `dl_manager.iter_files` to skip hidden files in an extracted archive
							A:      str														=   [dl_manager.iter_files(A			) for file in files]
							return [datasets.SplitGenerator(name=datasets.Split.TRAIN					,   gen_kwargs={"""files""": files}			)]
				A:      Union[str, Any]														=   []
				for split_name, files in data_files.items():
							if isinstance(A					,   A			):
										A:      List[str]														=   [files]
							# Use `dl_manager.iter_files` to skip hidden files in an extracted archive
							A:      List[Any]														=   [dl_manager.iter_files(A			) for file in files]
							# Infer features is they are stoed in the arrow schema
							if self.info.features is None:
										for file in itertools.chain.from_iterable(A			):
													with open(A					,   """rb"""			) as f:
																A:      Dict														=   datasets.Features.from_arrow_schema(pa.ipc.open_stream(A			).schema			)
													break
							splits.append(datasets.SplitGenerator(name=A					,   gen_kwargs={"""files""": files}			)			)
				return splits


	def      a__ (		self					,   A			) ->							pa.Table:
				if self.info.features is not None:
							# more expensive cast to support nested features with keys in a different order
							# allows str <-> int/float or str to Audio for example
							A:      Dict														=   table_cast(A					,   self.info.features.arrow_schema			)
				return pa_table





	def      a__ (		self					,   A			) ->							Dict:
				for file_idx, file in enumerate(itertools.chain.from_iterable(A			)			):
							with open(A					,   """rb"""			) as f:
										try:
													for batch_idx, record_batch in enumerate(pa.ipc.open_stream(A			)			):
																A:      Union[str, Any]														=   pa.Table.from_batches([record_batch]			)
																# Uncomment for debugging (will print the Arrow table size and elements)
																# logger.warning(f"pa_table: {pa_table} num rows: {pa_table.num_rows}")
																# logger.warning('\n'.join(str(pa_table.slice(i, 1).to_pydict()) for i in range(pa_table.num_rows)))
																yield f'{file_idx}_{batch_idx}', self._cast_table(A			)
										except ValueError as e:
													logger.error(f'Failed to read file \'{file}\' with error {type(A			)}: {e}'			)
													raise





