


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


A_    :					Optional[Any]             =logging.getLogger(__name__)





@dataclass
class        lowercase_				:






							"""simple docstring"""







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





@dataclass
class        lowercase_				:






							"""simple docstring"""







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




def   lowerCamelCase_       (					UpperCAmelCase__		):



						"""simple docstring"""




						a_					=		default_data_collator(UpperCAmelCase__		)
						a_					=		batch.pop("""pairID"""       ,    UpperCAmelCase__		)
						return batch




def   lowerCamelCase_       (					):



						"""simple docstring"""




						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   lowerCamelCase_       (					UpperCAmelCase__		):



						"""simple docstring"""




						main()


if __name__ == "__main__":
	main()



import importlib
import sys
from argparse import REMAINDER, ArgumentParser
from pathlib import Path

import torch_xla.distributed.xla_multiprocessing as xmp




def   lowerCamelCase_       (					):



						"""simple docstring"""




						a_					=		ArgumentParser(
						    description=(
						        """PyTorch TPU distributed training launch helper utility that will spawn up multiple distributed processes"""
						    )      )

						# Optional arguments for the launch helper
						parser.add_argument("""--num_cores"""       ,    type=UpperCAmelCase__       ,    default=1       ,    help="""Number of TPU cores to use (1 or 8)."""      )

						# positional
						parser.add_argument(
						    """training_script"""       ,    type=UpperCAmelCase__       ,    help=(
						        """The full path to the single TPU training """
						        """program/script to be launched in parallel, """
						        """followed by all the arguments for the """
						        """training script"""
						    )       ,    )

						# rest from the training program
						parser.add_argument("""training_script_args"""       ,    nargs=UpperCAmelCase__      )

						return parser.parse_args()




def   lowerCamelCase_       (					):



						"""simple docstring"""




						a_					=		parse_args()

						# Import training_script as a module.
						a_					=		Path(args.training_script      )
						sys.path.append(str(script_fpath.parent.resolve()      )      )
						a_					=		script_fpath.stem
						a_					=		importlib.import_module(UpperCAmelCase__      )

						# Patch sys.argv
						a_					=		[args.training_script] + args.training_script_args + ["""--tpu_num_cores""", str(args.num_cores      )]

						xmp.spawn(mod._mp_fn       ,    args=()       ,    nprocs=args.num_cores      )


if __name__ == "__main__":
	main()