





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


__lowercase													=			logging.getLogger(__name__)

@dataclass
class   __snake_case				:






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


@dataclass
class   __snake_case				:






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


def 					__SCREAMING_SNAKE_CASE  (							__lowercase:		Any):



		'''simple docstring'''






		__lowerCAmelCase			=				default_data_collator(__lowercase)
		__lowerCAmelCase			=				batch.pop('''pairID'''     ,							__lowercase)
		return batch


def 					__SCREAMING_SNAKE_CASE  (							):



		'''simple docstring'''






		__lowerCAmelCase			=				HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments))
		__lowerCAmelCase			=				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'''     ,							__lowercase)

		# Set seed
		set_seed(training_args.seed)

		try:
				__lowerCAmelCase			=				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.

		__lowerCAmelCase			=				AutoConfig.from_pretrained(
		    model_args.config_name if model_args.config_name else model_args.model_name_or_path     ,							num_labels=__lowercase     ,							finetuning_task=data_args.task_name     ,							cache_dir=model_args.cache_dir     ,							)
		__lowerCAmelCase			=				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     ,							)
		__lowerCAmelCase			=				AutoModelForSequenceClassification.from_pretrained(
		    model_args.model_name_or_path     ,							from_tf=bool('''.ckpt''' in model_args.model_name_or_path)     ,							config=__lowercase     ,							cache_dir=model_args.cache_dir     ,							)

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

		# Initialize our Trainer
		__lowerCAmelCase			=				Trainer(
		    model=__lowercase     ,							args=__lowercase     ,							train_dataset=__lowercase     ,							eval_dataset=__lowercase     ,							data_collator=__lowercase     ,							)

		# 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 ***''')

				__lowerCAmelCase			=				trainer.predict(__lowercase)
				__lowerCAmelCase			=				output.predictions
				__lowerCAmelCase			=				np.argmax(__lowercase     ,							axis=1)

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

				trainer._log(output.metrics)


def 					__SCREAMING_SNAKE_CASE  (							__lowercase:		List[str]):



		'''simple docstring'''






		main()


if __name__ == "__main__":
						main()







import inspect
import os
import unittest

import torch

import accelerate
from accelerate import debug_launcher
from accelerate.test_utils import (
    execute_subprocess_async,
    require_cpu,
    require_multi_gpu,
    require_single_gpu,
    test_sync,
)
from accelerate.utils import patch_environment

class   __snake_case				(			unittest.TestCase   ):






    '''simple docstring'''





    def 	A		(   self						:		int							):

      """simple docstring"""





      __lowerCAmelCase			=				inspect.getfile(accelerate.test_utils							)
      __lowerCAmelCase			=				os.path.sep.join(mod_file.split(os.path.sep							)[:-1] + ['''scripts''', '''test_sync.py''']							)





    @require_cpu
    def 	A		(   self						:		str							):

      """simple docstring"""





      debug_launcher(test_sync.main			,						num_processes=1							)





    @require_cpu
    def 	A		(   self						:		List[str]							):

      """simple docstring"""





      debug_launcher(test_sync.main							)





    @require_single_gpu
    def 	A		(   self						:		Optional[Any]							):

      """simple docstring"""





      test_sync.main()





    @require_multi_gpu
    def 	A		(   self						:		Union[str, Any]							):

      """simple docstring"""





      print(f'''Found {torch.cuda.device_count()} devices.'''							)
      __lowerCAmelCase			=				['''torchrun''', f'''--nproc_per_node={torch.cuda.device_count()}''', self.test_file_path]
      with patch_environment(omp_num_threads=1							):
        execute_subprocess_async(snake_case			,						env=os.environ.copy()							)
