



"""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 							SCREAMING_SNAKE_CASE__      (		SCREAMING_SNAKE_CASE__ :  Optional[Any]				,    SCREAMING_SNAKE_CASE__ :  List[Any]			):



					"""simple docstring"""





					return (preds == labels).mean()







@dataclass
class    __lowercase     :







						"""simple docstring"""







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







@dataclass
class    __lowercase     :







						"""simple docstring"""







						_A		:							str							       =		field(metadata={"""help""": """The name of the task to train on: """ + """, """.join(processors.keys())})
						_A		:							str							       =		field(metadata={"""help""": """Should contain the 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=_UpperCAmelCase					,    metadata={"""help""": """Overwrite the cached training and evaluation sets"""})







def 							SCREAMING_SNAKE_CASE__      (		):



					"""simple docstring"""





					snake_case_					:		Any 					=					HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)			)
					snake_case_					,			snake_case_					,			snake_case_					:		Union[str, Any] 					=					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"""				,    SCREAMING_SNAKE_CASE__			)

					# Set seed
					set_seed(training_args.seed			)

					try:
										snake_case_					:		str 					=					processors[data_args.task_name]()
										snake_case_					:		Optional[Any] 					=					processor.get_labels()
										snake_case_					:		Union[str, Any] 					=					len(SCREAMING_SNAKE_CASE__			)
					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.

					snake_case_					:		List[str] 					=					AutoConfig.from_pretrained(
					    model_args.config_name if model_args.config_name else model_args.model_name_or_path				,    num_labels=SCREAMING_SNAKE_CASE__				,    finetuning_task=data_args.task_name				,    cache_dir=model_args.cache_dir				,    )
					snake_case_					:		int 					=					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				,    )
					snake_case_					:		Any 					=					AutoModelForMultipleChoice.from_pretrained(
					    model_args.model_name_or_path				,    from_tf=bool(""".ckpt""" in model_args.model_name_or_path			)				,    config=SCREAMING_SNAKE_CASE__				,    cache_dir=model_args.cache_dir				,    )

					# Get datasets
					snake_case_					:		str 					=					(
					    MultipleChoiceDataset(
					        data_dir=data_args.data_dir				,    tokenizer=SCREAMING_SNAKE_CASE__				,    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
					)
					snake_case_					:		str 					=					(
					    MultipleChoiceDataset(
					        data_dir=data_args.data_dir				,    tokenizer=SCREAMING_SNAKE_CASE__				,    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(SCREAMING_SNAKE_CASE__ :  EvalPrediction			) -> Dict:
										snake_case_					:		str 					=					np.argmax(p.predictions				,    axis=1			)
										return {"acc": simple_accuracy(SCREAMING_SNAKE_CASE__				,    p.label_ids			)}

					# Data collator
					snake_case_					:		Tuple 					=					DataCollatorWithPadding(SCREAMING_SNAKE_CASE__				,    pad_to_multiple_of=8			) if training_args.fpaa else None

					# Initialize our Trainer
					snake_case_					:		Optional[Any] 					=					Trainer(
					    model=SCREAMING_SNAKE_CASE__				,    args=SCREAMING_SNAKE_CASE__				,    train_dataset=SCREAMING_SNAKE_CASE__				,    eval_dataset=SCREAMING_SNAKE_CASE__				,    compute_metrics=SCREAMING_SNAKE_CASE__				,    data_collator=SCREAMING_SNAKE_CASE__				,    )

					# 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
					snake_case_					:		int 					=					{}
					if training_args.do_eval:
										logger.info("""*** Evaluate ***"""			)

										snake_case_					:		Any 					=					trainer.evaluate()

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

																				results.update(SCREAMING_SNAKE_CASE__			)

					return results







def 							SCREAMING_SNAKE_CASE__      (		SCREAMING_SNAKE_CASE__ :  Tuple			):



					"""simple docstring"""





					main()


if __name__ == "__main__":
			main()









"""simple docstring"""

from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


if TYPE_CHECKING:
			from ... import FeatureExtractionMixin, PreTrainedTokenizerBase, TensorType


a_			   =					logging.get_logger(__name__)

a_			   =					{
    '''microsoft/deberta-v2-xlarge''': '''https://huggingface.co/microsoft/deberta-v2-xlarge/resolve/main/config.json''',
    '''microsoft/deberta-v2-xxlarge''': '''https://huggingface.co/microsoft/deberta-v2-xxlarge/resolve/main/config.json''',
    '''microsoft/deberta-v2-xlarge-mnli''': (
        '''https://huggingface.co/microsoft/deberta-v2-xlarge-mnli/resolve/main/config.json'''
    ),
    '''microsoft/deberta-v2-xxlarge-mnli''': (
        '''https://huggingface.co/microsoft/deberta-v2-xxlarge-mnli/resolve/main/config.json'''
    ),
}







class    __lowercase     (					_UpperCAmelCase):







						"""simple docstring"""







						_A		:							Dict							       =		"""deberta-v2"""







						def __init__(self   ,		lowercase__=12_81_00   ,		lowercase__=15_36   ,		lowercase__=24   ,		lowercase__=24   ,		lowercase__=61_44   ,		lowercase__="gelu"   ,		lowercase__=0.1   ,		lowercase__=0.1   ,		lowercase__=5_12   ,		lowercase__=0   ,		lowercase__=0.02   ,		lowercase__=1e-7   ,		lowercase__=False   ,		lowercase__=-1   ,		lowercase__=0   ,		lowercase__=True   ,		lowercase__=None   ,		lowercase__=0   ,		lowercase__="gelu"   ,		**lowercase__   ,		):
											super().__init__(**lowercase__       )

											snake_case_					:		Union[str, Any] 					=					hidden_size
											snake_case_					:		str 					=					num_hidden_layers
											snake_case_					:		Tuple 					=					num_attention_heads
											snake_case_					:		Dict 					=					intermediate_size
											snake_case_					:		Optional[int] 					=					hidden_act
											snake_case_					:		Union[str, Any] 					=					hidden_dropout_prob
											snake_case_					:		Any 					=					attention_probs_dropout_prob
											snake_case_					:		List[Any] 					=					max_position_embeddings
											snake_case_					:		Union[str, Any] 					=					type_vocab_size
											snake_case_					:		Union[str, Any] 					=					initializer_range
											snake_case_					:		List[Any] 					=					relative_attention
											snake_case_					:		Dict 					=					max_relative_positions
											snake_case_					:		Optional[int] 					=					pad_token_id
											snake_case_					:		List[str] 					=					position_biased_input

											# Backwards compatibility
											if type(lowercase__       ) == str:
																snake_case_					:		Union[str, Any] 					=					[x.strip() for x in pos_att_type.lower().split("""|"""       )]

											snake_case_					:		Optional[int] 					=					pos_att_type
											snake_case_					:		List[str] 					=					vocab_size
											snake_case_					:		Tuple 					=					layer_norm_eps

											snake_case_					:		List[Any] 					=					kwargs.get("""pooler_hidden_size"""   ,		lowercase__       )
											snake_case_					:		List[str] 					=					pooler_dropout
											snake_case_					:		int 					=					pooler_hidden_act







class    __lowercase     (					_UpperCAmelCase):







						"""simple docstring"""







						@property
						def 						__UpperCamelCase							(self       ):
											if self.task == "multiple-choice":
																snake_case_					:		List[Any] 					=					{0: """batch""", 1: """choice""", 2: """sequence"""}
											else:
																snake_case_					:		int 					=					{0: """batch""", 1: """sequence"""}
											if self._config.type_vocab_size > 0:
																return OrderedDict(
																    [("""input_ids""", dynamic_axis), ("""attention_mask""", dynamic_axis), ("""token_type_ids""", dynamic_axis)]       )
											else:
																return OrderedDict([("""input_ids""", dynamic_axis), ("""attention_mask""", dynamic_axis)]       )







						@property
						def 						__UpperCamelCase							(self       ):
											return 12







						def 						__UpperCamelCase							(self   ,		lowercase__   ,		lowercase__ = -1   ,		lowercase__ = -1   ,		lowercase__ = -1   ,		lowercase__ = False   ,		lowercase__ = None   ,		lowercase__ = 3   ,		lowercase__ = 40   ,		lowercase__ = 40   ,		lowercase__ = None   ,		):
											snake_case_					:		str 					=					super().generate_dummy_inputs(preprocessor=lowercase__   ,		framework=lowercase__       )
											if self._config.type_vocab_size == 0 and "token_type_ids" in dummy_inputs:
																del dummy_inputs["token_type_ids"]
											return dummy_inputs




