






'''simple docstring'''
import logging
import os
from dataclasses import dataclass, field
from typing import Dict, Optional

import numpy as np
from utils_multiple_choice import MultipleChoiceDataset, Split, processors

import transformers
from transformers import (
    AutoConfig,
    AutoModelForMultipleChoice,
    AutoTokenizer,
    DataCollatorWithPadding,
    EvalPrediction,
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    set_seed,
)
from transformers.trainer_utils import is_main_process


a_					= logging.getLogger(__name__)





def  _a(  UpperCamelCase__				:						Union[str, Any],	UpperCamelCase__				:						List[Any]							):




						'''simple docstring'''






						return (preds == labels).mean()






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






@dataclass
class      __SCREAMING_SNAKE_CASE      :
	snake_case_  							=							field(metadata={"""help""": """The name of the task to train on: """ + """, """.join(processors.keys()				)}				)
	snake_case_  							=							field(metadata={"""help""": """Should contain the data files for the task."""}				)
	snake_case_  							=							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."""
	        )
	    }	,				)
	snake_case_  							=							field(
	    default=lowerCamelCase	,				metadata={"""help""": """Overwrite the cached training and evaluation sets"""}				)





def  _a(  ):




						'''simple docstring'''






						SCREAMING_SNAKE_CASE__     :				Tuple									=HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)							)
						SCREAMING_SNAKE_CASE__     :				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''',	UpperCamelCase__							)

						# Set seed
						set_seed(training_args.seed							)

						try:
												SCREAMING_SNAKE_CASE__     :				List[Any]									=processors[data_args.task_name]()
												SCREAMING_SNAKE_CASE__     :				int									=processor.get_labels()
												SCREAMING_SNAKE_CASE__     :				Tuple									=len(UpperCamelCase__							)
						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.

						SCREAMING_SNAKE_CASE__     :				Any									=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,	)
						SCREAMING_SNAKE_CASE__     :				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,	)
						SCREAMING_SNAKE_CASE__     :				Tuple									=AutoModelForMultipleChoice.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
						SCREAMING_SNAKE_CASE__     :				Tuple									=(
						    MultipleChoiceDataset(
						        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,	mode=Split.train,	)
						    if training_args.do_train
						    else None
						)
						SCREAMING_SNAKE_CASE__     :				Union[str, Any]									=(
						    MultipleChoiceDataset(
						        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,	mode=Split.dev,	)
						    if training_args.do_eval
						    else None
						)

						def compute_metrics(UpperCamelCase__				:						EvalPrediction							) -> Dict:
												SCREAMING_SNAKE_CASE__     :				Optional[int]									=np.argmax(p.predictions,	axis=1							)
												return {"acc": simple_accuracy(UpperCamelCase__,	p.label_ids							)}

						# Data collator
						SCREAMING_SNAKE_CASE__     :				Optional[Any]									=DataCollatorWithPadding(UpperCamelCase__,	pad_to_multiple_of=8							) if training_args.fpaa else None

						# Initialize our Trainer
						SCREAMING_SNAKE_CASE__     :				Dict									=Trainer(
						    model=UpperCamelCase__,	args=UpperCamelCase__,	train_dataset=UpperCamelCase__,	eval_dataset=UpperCamelCase__,	compute_metrics=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
						SCREAMING_SNAKE_CASE__     :				Dict									={}
						if training_args.do_eval:
												logger.info('''*** Evaluate ***'''							)

												SCREAMING_SNAKE_CASE__     :				List[str]									=trainer.evaluate()

												SCREAMING_SNAKE_CASE__     :				str									=os.path.join(training_args.output_dir,	'''eval_results.txt'''							)
												if trainer.is_world_master():
																		with open(UpperCamelCase__,	'''w'''							) as writer:
																								logger.info('''***** Eval results *****'''							)
																								for key, value in result.items():
																														logger.info('''  %s = %s''',	UpperCamelCase__,	UpperCamelCase__							)
																														writer.write('''%s = %s\n''' % (key, value)							)

																								results.update(UpperCamelCase__							)

						return results





def  _a(  UpperCamelCase__				:						Optional[int]							):




						'''simple docstring'''






						main()


if __name__ == "__main__":
		main()







'''simple docstring'''
from typing import TYPE_CHECKING

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


a_					= {
    'configuration_deberta': ['DEBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP', 'DebertaConfig', 'DebertaOnnxConfig'],
    'tokenization_deberta': ['DebertaTokenizer'],
}

try:
  if not is_tokenizers_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  a_					= ['DebertaTokenizerFast']

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  a_					= [
      'DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST',
      'DebertaForMaskedLM',
      'DebertaForQuestionAnswering',
      'DebertaForSequenceClassification',
      'DebertaForTokenClassification',
      'DebertaModel',
      'DebertaPreTrainedModel',
  ]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  a_					= [
      'TF_DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST',
      'TFDebertaForMaskedLM',
      'TFDebertaForQuestionAnswering',
      'TFDebertaForSequenceClassification',
      'TFDebertaForTokenClassification',
      'TFDebertaModel',
      'TFDebertaPreTrainedModel',
  ]


if TYPE_CHECKING:
  from .configuration_deberta import DEBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, DebertaConfig, DebertaOnnxConfig
  from .tokenization_deberta import DebertaTokenizer

  try:
    if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_deberta_fast import DebertaTokenizerFast

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_deberta import (
        DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
        DebertaForMaskedLM,
        DebertaForQuestionAnswering,
        DebertaForSequenceClassification,
        DebertaForTokenClassification,
        DebertaModel,
        DebertaPreTrainedModel,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_deberta import (
        TF_DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFDebertaForMaskedLM,
        TFDebertaForQuestionAnswering,
        TFDebertaForSequenceClassification,
        TFDebertaForTokenClassification,
        TFDebertaModel,
        TFDebertaPreTrainedModel,
    )


else:
  import sys

  a_					= _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)