




import unittest

from transformers import DebertaConfig, is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch

					from transformers import (
					    DebertaForMaskedLM,
					    DebertaForQuestionAnswering,
					    DebertaForSequenceClassification,
					    DebertaForTokenClassification,
					    DebertaModel,
					)
					from transformers.models.deberta.modeling_deberta import DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST
class       a__   ( snake_case__				):






						def __init__(       self		,      _A		,      _A=1_3		,      _A=7		,      _A=True		,      _A=True		,      _A=True		,      _A=True		,      _A=9_9		,      _A=3_2		,      _A=5		,      _A=4		,      _A=3_7		,      _A="gelu"		,      _A=0.1		,      _A=0.1		,      _A=5_1_2		,      _A=1_6		,      _A=2		,      _A=0.02		,      _A=False		,      _A=True		,      _A="None"		,      _A=3		,      _A=4		,      _A=None		,      ):




											"""simple docstring"""



											__lowerCAmelCase           =	parent
											__lowerCAmelCase           =	batch_size
											__lowerCAmelCase           =	seq_length
											__lowerCAmelCase           =	is_training
											__lowerCAmelCase           =	use_input_mask
											__lowerCAmelCase           =	use_token_type_ids
											__lowerCAmelCase           =	use_labels
											__lowerCAmelCase           =	vocab_size
											__lowerCAmelCase           =	hidden_size
											__lowerCAmelCase           =	num_hidden_layers
											__lowerCAmelCase           =	num_attention_heads
											__lowerCAmelCase           =	intermediate_size
											__lowerCAmelCase           =	hidden_act
											__lowerCAmelCase           =	hidden_dropout_prob
											__lowerCAmelCase           =	attention_probs_dropout_prob
											__lowerCAmelCase           =	max_position_embeddings
											__lowerCAmelCase           =	type_vocab_size
											__lowerCAmelCase           =	type_sequence_label_size
											__lowerCAmelCase           =	initializer_range
											__lowerCAmelCase           =	num_labels
											__lowerCAmelCase           =	num_choices
											__lowerCAmelCase           =	relative_attention
											__lowerCAmelCase           =	position_biased_input
											__lowerCAmelCase           =	pos_att_type
											__lowerCAmelCase           =	scope






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	ids_tensor([self.batch_size, self.seq_length]		,      self.vocab_size      )

											__lowerCAmelCase           =	None
											if self.use_input_mask:
																__lowerCAmelCase           =	ids_tensor([self.batch_size, self.seq_length]		,      vocab_size=2      )

											__lowerCAmelCase           =	None
											if self.use_token_type_ids:
																__lowerCAmelCase           =	ids_tensor([self.batch_size, self.seq_length]		,      self.type_vocab_size      )

											__lowerCAmelCase           =	None
											__lowerCAmelCase           =	None
											__lowerCAmelCase           =	None
											if self.use_labels:
																__lowerCAmelCase           =	ids_tensor([self.batch_size]		,      self.type_sequence_label_size      )
																__lowerCAmelCase           =	ids_tensor([self.batch_size, self.seq_length]		,      self.num_labels      )
																__lowerCAmelCase           =	ids_tensor([self.batch_size]		,      self.num_choices      )

											__lowerCAmelCase           =	self.get_config()

											return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											return DebertaConfig(
											    vocab_size=self.vocab_size		,      hidden_size=self.hidden_size		,      num_hidden_layers=self.num_hidden_layers		,      num_attention_heads=self.num_attention_heads		,      intermediate_size=self.intermediate_size		,      hidden_act=self.hidden_act		,      hidden_dropout_prob=self.hidden_dropout_prob		,      attention_probs_dropout_prob=self.attention_probs_dropout_prob		,      max_position_embeddings=self.max_position_embeddings		,      type_vocab_size=self.type_vocab_size		,      initializer_range=self.initializer_range		,      relative_attention=self.relative_attention		,      position_biased_input=self.position_biased_input		,      pos_att_type=self.pos_att_type		,      )






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	self.get_config()
											__lowerCAmelCase           =	3_0_0
											return config






						def     __SCREAMING_SNAKE_CASE(       self		,      _A      ):




											"""simple docstring"""



											self.parent.assertListEqual(list(result.loss.size()      )		,      []      )






						def     __SCREAMING_SNAKE_CASE(       self		,      _A		,      _A		,      _A		,      _A		,      _A		,      _A		,      _A      ):




											"""simple docstring"""



											__lowerCAmelCase           =	DebertaModel(config=_A      )
											model.to(_A      )
											model.eval()
											__lowerCAmelCase           =	model(_A		,      attention_mask=_A		,      token_type_ids=_A      )[0]
											__lowerCAmelCase           =	model(_A		,      token_type_ids=_A      )[0]
											__lowerCAmelCase           =	model(_A      )[0]

											self.parent.assertListEqual(list(sequence_output.size()      )		,      [self.batch_size, self.seq_length, self.hidden_size]      )






						def     __SCREAMING_SNAKE_CASE(       self		,      _A		,      _A		,      _A		,      _A		,      _A		,      _A		,      _A      ):




											"""simple docstring"""



											__lowerCAmelCase           =	DebertaForMaskedLM(config=_A      )
											model.to(_A      )
											model.eval()
											__lowerCAmelCase           =	model(_A		,      attention_mask=_A		,      token_type_ids=_A		,      labels=_A      )

											self.parent.assertEqual(result.logits.shape		,      (self.batch_size, self.seq_length, self.vocab_size)      )






						def     __SCREAMING_SNAKE_CASE(       self		,      _A		,      _A		,      _A		,      _A		,      _A		,      _A		,      _A      ):




											"""simple docstring"""



											__lowerCAmelCase           =	self.num_labels
											__lowerCAmelCase           =	DebertaForSequenceClassification(_A      )
											model.to(_A      )
											model.eval()
											__lowerCAmelCase           =	model(_A		,      attention_mask=_A		,      token_type_ids=_A		,      labels=_A      )
											self.parent.assertListEqual(list(result.logits.size()      )		,      [self.batch_size, self.num_labels]      )
											self.check_loss_output(_A      )






						def     __SCREAMING_SNAKE_CASE(       self		,      _A		,      _A		,      _A		,      _A		,      _A		,      _A		,      _A      ):




											"""simple docstring"""



											__lowerCAmelCase           =	self.num_labels
											__lowerCAmelCase           =	DebertaForTokenClassification(config=_A      )
											model.to(_A      )
											model.eval()
											__lowerCAmelCase           =	model(_A		,      attention_mask=_A		,      token_type_ids=_A		,      labels=_A      )
											self.parent.assertEqual(result.logits.shape		,      (self.batch_size, self.seq_length, self.num_labels)      )






						def     __SCREAMING_SNAKE_CASE(       self		,      _A		,      _A		,      _A		,      _A		,      _A		,      _A		,      _A      ):




											"""simple docstring"""



											__lowerCAmelCase           =	DebertaForQuestionAnswering(config=_A      )
											model.to(_A      )
											model.eval()
											__lowerCAmelCase           =	model(
											    _A		,      attention_mask=_A		,      token_type_ids=_A		,      start_positions=_A		,      end_positions=_A		,      )
											self.parent.assertEqual(result.start_logits.shape		,      (self.batch_size, self.seq_length)      )
											self.parent.assertEqual(result.end_logits.shape		,      (self.batch_size, self.seq_length)      )






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	self.prepare_config_and_inputs()
											(
											    (
											    __lowerCAmelCase
											)       ,							(
											    __lowerCAmelCase
											)       ,							(
											    __lowerCAmelCase
											)       ,							(
											    __lowerCAmelCase
											)       ,							(
											    __lowerCAmelCase
											)       ,							(
											    __lowerCAmelCase
											)       ,							(
											    __lowerCAmelCase
											)       ,							
											)           =	config_and_inputs
											__lowerCAmelCase           =	{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
											return config, inputs_dict






@require_torch
class       a__   ( snake_case__			,    snake_case__			,    unittest.TestCase				):
						_a							:   Tuple =   (
						    (
						        DebertaModel,
						        DebertaForMaskedLM,
						        DebertaForSequenceClassification,
						        DebertaForTokenClassification,
						        DebertaForQuestionAnswering,
						    )
						    if is_torch_available()
						    else ()
						)
						_a							:   int =   (
						    {
						        """feature-extraction""": DebertaModel,
						        """fill-mask""": DebertaForMaskedLM,
						        """question-answering""": DebertaForQuestionAnswering,
						        """text-classification""": DebertaForSequenceClassification,
						        """token-classification""": DebertaForTokenClassification,
						        """zero-shot""": DebertaForSequenceClassification,
						    }
						    if is_torch_available()
						    else {}
						)

						_a							:   Union[str, Any] =   True
						_a							:   Optional[Any] =   False
						_a							:   int =   False
						_a							:   List[str] =   False
						_a							:   Dict =   False






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	DebertaModelTester(self      )
											__lowerCAmelCase           =	ConfigTester(self		,      config_class=_A		,      hidden_size=3_7      )






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											self.config_tester.run_common_tests()






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_deberta_model(*_A      )






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_deberta_for_sequence_classification(*_A      )






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_deberta_for_masked_lm(*_A      )






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_deberta_for_question_answering(*_A      )






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_deberta_for_token_classification(*_A      )






						@slow
						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											for model_name in DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																__lowerCAmelCase           =	DebertaModel.from_pretrained(_A      )
																self.assertIsNotNone(_A      )






@require_torch
@require_sentencepiece
@require_tokenizers
class       a__   ( unittest.TestCase				):






						@unittest.skip(reason="Model not available yet"      )
						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											pass






						@slow
						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	DebertaModel.from_pretrained("microsoft/deberta-base"      )

											__lowerCAmelCase           =	torch.tensor([[0, 3_1_4_1_4, 2_3_2, 3_2_8, 7_4_0, 1_1_4_0, 1_2_6_9_5, 6_9, 4_6_0_7_8, 1_5_8_8, 2]]      )
											__lowerCAmelCase           =	torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]      )
											with torch.no_grad():
																__lowerCAmelCase           =	model(_A		,      attention_mask=_A      )[0]
											# compare the actual values for a slice.
											__lowerCAmelCase           =	torch.tensor(
											    [[[-0.59_86, -0.80_55, -0.84_62], [1.44_84, -0.93_48, -0.80_59], [0.31_23, 0.00_32, -1.41_31]]]      )
											self.assertTrue(torch.allclose(output[:, 1:4, 1:4]		,      _A		,      atol=1E-4      )		,      f"""{output[:, 1:4, 1:4]}"""      )










import enum
import shutil
import sys


UpperCamelCase__      ,     UpperCamelCase__         =      shutil.get_terminal_size()

UpperCamelCase__         =      {"""UP""": """A""", """DOWN""": """B""", """RIGHT""": """C""", """LEFT""": """D"""}
class       a__   ( enum.Enum				):
						_a							:   Any =   0
						_a							:   Dict =   1







def      _a				(						SCREAMING_SNAKE_CASE_							:    Tuple				,				SCREAMING_SNAKE_CASE_							:    Dict=""					):
					sys.stdout.write(str(SCREAMING_SNAKE_CASE_					) + end					)
					sys.stdout.flush()







def      _a				(						SCREAMING_SNAKE_CASE_							:    Any				,				SCREAMING_SNAKE_CASE_							:    Union[str, Any]				,				SCREAMING_SNAKE_CASE_							:    str=""					):
					forceWrite(F"""\u001b[{color}m{content}\u001b[0m"""				,				SCREAMING_SNAKE_CASE_					)







def      _a				(						):
					forceWrite("\r"					)







def      _a				(						SCREAMING_SNAKE_CASE_							:    int				,				SCREAMING_SNAKE_CASE_							:    str					):
					forceWrite(F"""\033[{num_lines}{CURSOR_TO_CHAR[direction.upper()]}"""					)







def      _a				(						):
					forceWrite(" " * TERMINAL_WIDTH					)
					reset_cursor()







def      _a				(						):
					reset_cursor()
					forceWrite("-" * TERMINAL_WIDTH					)




