



import argparse
import json
import logging
import os
import shutil
import sys
import tempfile
import unittest
from unittest import mock

import torch
from accelerate.utils import write_basic_config

from transformers.testing_utils import TestCasePlus, get_gpu_count, run_command, slow, torch_device
from transformers.utils import is_apex_available


logging.basicConfig(level=logging.DEBUG)

__A   			=logging.getLogger()

def        a						(      ):







		'''simple docstring'''





		__UpperCAmelCase    :     Union[str, Any]													=	argparse.ArgumentParser()
		parser.add_argument('''-f'''						)
		__UpperCAmelCase    :     Optional[int]													=	parser.parse_args()
		return args.f

def        a						(      _UpperCAmelCase							:					Dict						):







		'''simple docstring'''





		__UpperCAmelCase    :     Optional[Any]													=	{}
		__UpperCAmelCase    :     Optional[int]													=	os.path.join(_UpperCAmelCase ,   '''all_results.json'''						)
		if os.path.exists(_UpperCAmelCase						):
				with open(_UpperCAmelCase ,   '''r'''						) as f:
						__UpperCAmelCase    :     Union[str, Any]													=	json.load(_UpperCAmelCase						)
		else:
				raise ValueError(f'can\'t find {path}'						)
		return results

def        a						(      ):







		'''simple docstring'''





		__UpperCAmelCase    :     Union[str, Any]													=	torch.cuda.is_available() and torch_device == '''cuda'''
		return is_using_cuda and is_apex_available()


__A   			=logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)

class 		UpperCAmelCase__			(			__UpperCamelCase   ):




			'''simple docstring'''






			@classmethod
			def  snake_case__     (   cls							: List[Any] ):
					'''simple docstring'''





					__UpperCAmelCase    :     Dict													=	tempfile.mkdtemp()
					__UpperCAmelCase    :     List[Any]													=	os.path.join(cls.tmpdir       ,       '''default_config.yml''' )
					write_basic_config(save_location=cls.configPath )
					__UpperCAmelCase    :     str													=	['''accelerate''', '''launch''', '''--config_file''', cls.configPath]




			@classmethod
			def  snake_case__     (   cls							: Optional[int] ):
					'''simple docstring'''





					shutil.rmtree(cls.tmpdir )




			@mock.patch.dict(os.environ       ,       {'''WANDB_MODE''': '''offline'''} )
			def  snake_case__     (   self							: Any ):
					'''simple docstring'''





					__UpperCAmelCase    :     Optional[int]													=	self.get_auto_remove_tmp_dir()
					__UpperCAmelCase    :     int													=	F'\n            {self.examples_dir}/pytorch/text-classification/run_glue_no_trainer.py\n            --model_name_or_path distilbert-base-uncased\n            --output_dir {tmp_dir}\n            --train_file ./tests/fixtures/tests_samples/MRPC/train.csv\n            --validation_file ./tests/fixtures/tests_samples/MRPC/dev.csv\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --learning_rate=1e-4\n            --seed=42\n            --checkpointing_steps epoch\n            --with_tracking\n        '.split()

					if is_cuda_and_apex_available():
							testargs.append('''--fp16''' )

					run_command(self._launch_args + testargs )
					__UpperCAmelCase    :     Optional[Any]													=	get_results(a_ )
					self.assertGreaterEqual(result['''eval_accuracy''']       ,       0.7_5 )
					self.assertTrue(os.path.exists(os.path.join(a_       ,       '''epoch_0''' ) ) )
					self.assertTrue(os.path.exists(os.path.join(a_       ,       '''glue_no_trainer''' ) ) )




			@mock.patch.dict(os.environ       ,       {'''WANDB_MODE''': '''offline'''} )
			def  snake_case__     (   self							: Union[str, Any] ):
					'''simple docstring'''





					__UpperCAmelCase    :     Any													=	self.get_auto_remove_tmp_dir()
					__UpperCAmelCase    :     int													=	F'\n            {self.examples_dir}/pytorch/language-modeling/run_clm_no_trainer.py\n            --model_name_or_path distilgpt2\n            --train_file ./tests/fixtures/sample_text.txt\n            --validation_file ./tests/fixtures/sample_text.txt\n            --block_size 128\n            --per_device_train_batch_size 5\n            --per_device_eval_batch_size 5\n            --num_train_epochs 2\n            --output_dir {tmp_dir}\n            --checkpointing_steps epoch\n            --with_tracking\n        '.split()

					if torch.cuda.device_count() > 1:
							# Skipping because there are not enough batches to train the model + would need a drop_last to work.
							return

					run_command(self._launch_args + testargs )
					__UpperCAmelCase    :     List[str]													=	get_results(a_ )
					self.assertLess(result['''perplexity''']       ,       1_00 )
					self.assertTrue(os.path.exists(os.path.join(a_       ,       '''epoch_0''' ) ) )
					self.assertTrue(os.path.exists(os.path.join(a_       ,       '''clm_no_trainer''' ) ) )




			@mock.patch.dict(os.environ       ,       {'''WANDB_MODE''': '''offline'''} )
			def  snake_case__     (   self							: List[Any] ):
					'''simple docstring'''





					__UpperCAmelCase    :     Any													=	self.get_auto_remove_tmp_dir()
					__UpperCAmelCase    :     Optional[int]													=	F'\n            {self.examples_dir}/pytorch/language-modeling/run_mlm_no_trainer.py\n            --model_name_or_path distilroberta-base\n            --train_file ./tests/fixtures/sample_text.txt\n            --validation_file ./tests/fixtures/sample_text.txt\n            --output_dir {tmp_dir}\n            --num_train_epochs=1\n            --checkpointing_steps epoch\n            --with_tracking\n        '.split()

					run_command(self._launch_args + testargs )
					__UpperCAmelCase    :     Optional[int]													=	get_results(a_ )
					self.assertLess(result['''perplexity''']       ,       42 )
					self.assertTrue(os.path.exists(os.path.join(a_       ,       '''epoch_0''' ) ) )
					self.assertTrue(os.path.exists(os.path.join(a_       ,       '''mlm_no_trainer''' ) ) )




			@mock.patch.dict(os.environ       ,       {'''WANDB_MODE''': '''offline'''} )
			def  snake_case__     (   self							: List[str] ):
					'''simple docstring'''





					__UpperCAmelCase    :     List[Any]													=	7 if get_gpu_count() > 1 else 2

					__UpperCAmelCase    :     Optional[int]													=	self.get_auto_remove_tmp_dir()
					__UpperCAmelCase    :     str													=	F'\n            {self.examples_dir}/pytorch/token-classification/run_ner_no_trainer.py\n            --model_name_or_path bert-base-uncased\n            --train_file tests/fixtures/tests_samples/conll/sample.json\n            --validation_file tests/fixtures/tests_samples/conll/sample.json\n            --output_dir {tmp_dir}\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=2\n            --num_train_epochs={epochs}\n            --seed 7\n            --checkpointing_steps epoch\n            --with_tracking\n        '.split()

					run_command(self._launch_args + testargs )
					__UpperCAmelCase    :     int													=	get_results(a_ )
					self.assertGreaterEqual(result['''eval_accuracy''']       ,       0.7_5 )
					self.assertLess(result['''train_loss''']       ,       0.5 )
					self.assertTrue(os.path.exists(os.path.join(a_       ,       '''epoch_0''' ) ) )
					self.assertTrue(os.path.exists(os.path.join(a_       ,       '''ner_no_trainer''' ) ) )




			@unittest.skip(reason='''Fix me @muellerzr''' )
			@mock.patch.dict(os.environ       ,       {'''WANDB_MODE''': '''offline'''} )
			def  snake_case__     (   self							: Dict ):
					'''simple docstring'''





					__UpperCAmelCase    :     List[Any]													=	self.get_auto_remove_tmp_dir()
					__UpperCAmelCase    :     int													=	F'\n            {self.examples_dir}/pytorch/question-answering/run_qa_no_trainer.py\n            --model_name_or_path bert-base-uncased\n            --version_2_with_negative\n            --train_file tests/fixtures/tests_samples/SQUAD/sample.json\n            --validation_file tests/fixtures/tests_samples/SQUAD/sample.json\n            --output_dir {tmp_dir}\n            --seed=42\n            --max_train_steps=10\n            --num_warmup_steps=2\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --checkpointing_steps epoch\n            --with_tracking\n        '.split()

					run_command(self._launch_args + testargs )
					__UpperCAmelCase    :     Any													=	get_results(a_ )
					# Because we use --version_2_with_negative the testing script uses SQuAD v2 metrics.
					self.assertGreaterEqual(result['''eval_f1''']       ,       28 )
					self.assertGreaterEqual(result['''eval_exact''']       ,       28 )
					self.assertTrue(os.path.exists(os.path.join(a_       ,       '''epoch_0''' ) ) )
					self.assertTrue(os.path.exists(os.path.join(a_       ,       '''qa_no_trainer''' ) ) )




			@mock.patch.dict(os.environ       ,       {'''WANDB_MODE''': '''offline'''} )
			def  snake_case__     (   self							: Optional[Any] ):
					'''simple docstring'''





					__UpperCAmelCase    :     Dict													=	self.get_auto_remove_tmp_dir()
					__UpperCAmelCase    :     int													=	F'\n            {self.examples_dir}/pytorch/multiple-choice/run_swag_no_trainer.py\n            --model_name_or_path bert-base-uncased\n            --train_file tests/fixtures/tests_samples/swag/sample.json\n            --validation_file tests/fixtures/tests_samples/swag/sample.json\n            --output_dir {tmp_dir}\n            --max_train_steps=20\n            --num_warmup_steps=2\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --with_tracking\n        '.split()

					run_command(self._launch_args + testargs )
					__UpperCAmelCase    :     int													=	get_results(a_ )
					self.assertGreaterEqual(result['''eval_accuracy''']       ,       0.8 )
					self.assertTrue(os.path.exists(os.path.join(a_       ,       '''swag_no_trainer''' ) ) )




			@slow
			@mock.patch.dict(os.environ       ,       {'''WANDB_MODE''': '''offline'''} )
			def  snake_case__     (   self							: Union[str, Any] ):
					'''simple docstring'''





					__UpperCAmelCase    :     Union[str, Any]													=	self.get_auto_remove_tmp_dir()
					__UpperCAmelCase    :     Optional[Any]													=	F'\n            {self.examples_dir}/pytorch/summarization/run_summarization_no_trainer.py\n            --model_name_or_path t5-small\n            --train_file tests/fixtures/tests_samples/xsum/sample.json\n            --validation_file tests/fixtures/tests_samples/xsum/sample.json\n            --output_dir {tmp_dir}\n            --max_train_steps=50\n            --num_warmup_steps=8\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --checkpointing_steps epoch\n            --with_tracking\n        '.split()

					run_command(self._launch_args + testargs )
					__UpperCAmelCase    :     Optional[int]													=	get_results(a_ )
					self.assertGreaterEqual(result['''eval_rouge1''']       ,       10 )
					self.assertGreaterEqual(result['''eval_rouge2''']       ,       2 )
					self.assertGreaterEqual(result['''eval_rougeL''']       ,       7 )
					self.assertGreaterEqual(result['''eval_rougeLsum''']       ,       7 )
					self.assertTrue(os.path.exists(os.path.join(a_       ,       '''epoch_0''' ) ) )
					self.assertTrue(os.path.exists(os.path.join(a_       ,       '''summarization_no_trainer''' ) ) )




			@slow
			@mock.patch.dict(os.environ       ,       {'''WANDB_MODE''': '''offline'''} )
			def  snake_case__     (   self							: List[str] ):
					'''simple docstring'''





					__UpperCAmelCase    :     Tuple													=	self.get_auto_remove_tmp_dir()
					__UpperCAmelCase    :     Optional[Any]													=	F'\n            {self.examples_dir}/pytorch/translation/run_translation_no_trainer.py\n            --model_name_or_path sshleifer/student_marian_en_ro_6_1\n            --source_lang en\n            --target_lang ro\n            --train_file tests/fixtures/tests_samples/wmt16/sample.json\n            --validation_file tests/fixtures/tests_samples/wmt16/sample.json\n            --output_dir {tmp_dir}\n            --max_train_steps=50\n            --num_warmup_steps=8\n            --num_beams=6\n            --learning_rate=3e-3\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --source_lang en_XX\n            --target_lang ro_RO\n            --checkpointing_steps epoch\n            --with_tracking\n        '.split()

					run_command(self._launch_args + testargs )
					__UpperCAmelCase    :     Optional[Any]													=	get_results(a_ )
					self.assertGreaterEqual(result['''eval_bleu''']       ,       30 )
					self.assertTrue(os.path.exists(os.path.join(a_       ,       '''epoch_0''' ) ) )
					self.assertTrue(os.path.exists(os.path.join(a_       ,       '''translation_no_trainer''' ) ) )




			@slow
			def  snake_case__     (   self							: str ):
					'''simple docstring'''





					__UpperCAmelCase    :     Dict													=	logging.StreamHandler(sys.stdout )
					logger.addHandler(a_ )

					__UpperCAmelCase    :     Optional[Any]													=	self.get_auto_remove_tmp_dir()
					__UpperCAmelCase    :     str													=	F'\n            {self.examples_dir}/pytorch/semantic-segmentation/run_semantic_segmentation_no_trainer.py\n            --dataset_name huggingface/semantic-segmentation-test-sample\n            --output_dir {tmp_dir}\n            --max_train_steps=10\n            --num_warmup_steps=2\n            --learning_rate=2e-4\n            --per_device_train_batch_size=2\n            --per_device_eval_batch_size=1\n            --checkpointing_steps epoch\n        '.split()

					run_command(self._launch_args + testargs )
					__UpperCAmelCase    :     Dict													=	get_results(a_ )
					self.assertGreaterEqual(result['''eval_overall_accuracy''']       ,       0.1_0 )




			@mock.patch.dict(os.environ       ,       {'''WANDB_MODE''': '''offline'''} )
			def  snake_case__     (   self							: List[Any] ):
					'''simple docstring'''





					__UpperCAmelCase    :     Optional[Any]													=	self.get_auto_remove_tmp_dir()
					__UpperCAmelCase    :     Optional[int]													=	F'\n            {self.examples_dir}/pytorch/image-classification/run_image_classification_no_trainer.py\n            --model_name_or_path google/vit-base-patch16-224-in21k\n            --dataset_name hf-internal-testing/cats_vs_dogs_sample\n            --learning_rate 1e-4\n            --per_device_train_batch_size 2\n            --per_device_eval_batch_size 1\n            --max_train_steps 2\n            --train_val_split 0.1\n            --seed 42\n            --output_dir {tmp_dir}\n            --with_tracking\n            --checkpointing_steps 1\n        '.split()

					if is_cuda_and_apex_available():
							testargs.append('''--fp16''' )

					run_command(self._launch_args + testargs )
					__UpperCAmelCase    :     int													=	get_results(a_ )
					# The base model scores a 25%
					self.assertGreaterEqual(result['''eval_accuracy''']       ,       0.6 )
					self.assertTrue(os.path.exists(os.path.join(a_       ,       '''step_1''' ) ) )
					self.assertTrue(os.path.exists(os.path.join(a_       ,       '''image_classification_no_trainer''' ) ) )










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




			'''simple docstring'''






			UpperCamelCase									=       """deberta-v2"""




			def __init__(   self							: Optional[int]       ,       a_							: List[str]=12_81_00       ,       a_							: Optional[Any]=15_36       ,       a_							: Optional[Any]=24       ,       a_							: List[Any]=24       ,       a_							: Optional[int]=61_44       ,       a_							: List[Any]="gelu"       ,       a_							: Any=0.1       ,       a_							: Tuple=0.1       ,       a_							: Optional[Any]=5_12       ,       a_							: Tuple=0       ,       a_							: Dict=0.0_2       ,       a_							: Optional[Any]=1e-7       ,       a_							: List[str]=False       ,       a_							: List[Any]=-1       ,       a_							: List[str]=0       ,       a_							: Optional[Any]=True       ,       a_							: List[Any]=None       ,       a_							: Optional[int]=0       ,       a_							: Tuple="gelu"       ,       **a_							: List[str]       ,       ):
					'''simple docstring'''





					super().__init__(**a_ )

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

					# Backwards compatibility
					if type(a_ ) == str:
							__UpperCAmelCase    :     Optional[Any]													=	[x.strip() for x in pos_att_type.lower().split('''|''' )]

					__UpperCAmelCase    :     Tuple													=	pos_att_type
					__UpperCAmelCase    :     int													=	vocab_size
					__UpperCAmelCase    :     Optional[Any]													=	layer_norm_eps

					__UpperCAmelCase    :     str													=	kwargs.get('''pooler_hidden_size'''       ,       a_ )
					__UpperCAmelCase    :     Union[str, Any]													=	pooler_dropout
					__UpperCAmelCase    :     Tuple													=	pooler_hidden_act

class 		UpperCAmelCase__			(			__UpperCamelCase   ):




			'''simple docstring'''






			@property
			def  snake_case__     (   self							: Optional[Any] ):
					'''simple docstring'''





					if self.task == "multiple-choice":
							__UpperCAmelCase    :     List[Any]													=	{0: '''batch''', 1: '''choice''', 2: '''sequence'''}
					else:
							__UpperCAmelCase    :     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  snake_case__     (   self							: Union[str, Any] ):
					'''simple docstring'''





					return 12




			def  snake_case__     (   self							: Any       ,       a_							: Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"]       ,       a_							: int = -1       ,       a_							: int = -1       ,       a_							: int = -1       ,       a_							: bool = False       ,       a_							: Optional["TensorType"] = None       ,       a_							: int = 3       ,       a_							: int = 40       ,       a_							: int = 40       ,       a_							: "PreTrainedTokenizerBase" = None       ,       ):
					'''simple docstring'''





					__UpperCAmelCase    :     List[Any]													=	super().generate_dummy_inputs(preprocessor=a_       ,       framework=a_ )
					if self._config.type_vocab_size == 0 and "token_type_ids" in dummy_inputs:
							del dummy_inputs["token_type_ids"]
					return dummy_inputs





