code: 
  
  
  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()
style_context: 
  
  
  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()