




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_       (     SCREAMING_SNAKE_CASE__     ):





	def __init__(							self      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE=13      ,     SCREAMING_SNAKE_CASE=7      ,     SCREAMING_SNAKE_CASE=True      ,     SCREAMING_SNAKE_CASE=True      ,     SCREAMING_SNAKE_CASE=True      ,     SCREAMING_SNAKE_CASE=True      ,     SCREAMING_SNAKE_CASE=99      ,     SCREAMING_SNAKE_CASE=32      ,     SCREAMING_SNAKE_CASE=5      ,     SCREAMING_SNAKE_CASE=4      ,     SCREAMING_SNAKE_CASE=37      ,     SCREAMING_SNAKE_CASE="gelu"      ,     SCREAMING_SNAKE_CASE=0.1      ,     SCREAMING_SNAKE_CASE=0.1      ,     SCREAMING_SNAKE_CASE=512      ,     SCREAMING_SNAKE_CASE=16      ,     SCREAMING_SNAKE_CASE=2      ,     SCREAMING_SNAKE_CASE=0.0_2      ,     SCREAMING_SNAKE_CASE=False      ,     SCREAMING_SNAKE_CASE=True      ,     SCREAMING_SNAKE_CASE="None"      ,     SCREAMING_SNAKE_CASE=3      ,     SCREAMING_SNAKE_CASE=4      ,     SCREAMING_SNAKE_CASE=None      ,     )  ->					int:




				"""simple docstring"""



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





	def 						A_(							self      )  ->					Optional[int]:




				"""simple docstring"""



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

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

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

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

				SCREAMING_SNAKE_CASE_								=						self.get_config()

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





	def 						A_(							self      )  ->					Any:




				"""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 						A_(							self      )  ->					List[str]:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						self.get_config()
				SCREAMING_SNAKE_CASE_								=						300
				return config





	def 						A_(							self      ,     SCREAMING_SNAKE_CASE      )  ->					Tuple:




				"""simple docstring"""



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





	def 						A_(							self      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      )  ->					Any:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						DebertaModel(config=SCREAMING_SNAKE_CASE      )
				model.to(SCREAMING_SNAKE_CASE      )
				model.eval()
				SCREAMING_SNAKE_CASE_								=						model(SCREAMING_SNAKE_CASE      ,     attention_mask=SCREAMING_SNAKE_CASE      ,     token_type_ids=SCREAMING_SNAKE_CASE      )[0]
				SCREAMING_SNAKE_CASE_								=						model(SCREAMING_SNAKE_CASE      ,     token_type_ids=SCREAMING_SNAKE_CASE      )[0]
				SCREAMING_SNAKE_CASE_								=						model(SCREAMING_SNAKE_CASE      )[0]

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





	def 						A_(							self      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      )  ->					Optional[Any]:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						DebertaForMaskedLM(config=SCREAMING_SNAKE_CASE      )
				model.to(SCREAMING_SNAKE_CASE      )
				model.eval()
				SCREAMING_SNAKE_CASE_								=						model(SCREAMING_SNAKE_CASE      ,     attention_mask=SCREAMING_SNAKE_CASE      ,     token_type_ids=SCREAMING_SNAKE_CASE      ,     labels=SCREAMING_SNAKE_CASE      )

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





	def 						A_(							self      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      )  ->					Optional[int]:




				"""simple docstring"""



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





	def 						A_(							self      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      )  ->					List[Any]:




				"""simple docstring"""



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





	def 						A_(							self      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      ,     SCREAMING_SNAKE_CASE      )  ->					Union[str, Any]:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						DebertaForQuestionAnswering(config=SCREAMING_SNAKE_CASE      )
				model.to(SCREAMING_SNAKE_CASE      )
				model.eval()
				SCREAMING_SNAKE_CASE_								=						model(
				    SCREAMING_SNAKE_CASE      ,     attention_mask=SCREAMING_SNAKE_CASE      ,     token_type_ids=SCREAMING_SNAKE_CASE      ,     start_positions=SCREAMING_SNAKE_CASE      ,     end_positions=SCREAMING_SNAKE_CASE      ,     )
				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 						A_(							self      )  ->					List[Any]:




				"""simple docstring"""



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




@require_torch
class       a_       (     SCREAMING_SNAKE_CASE__  ,    SCREAMING_SNAKE_CASE__  ,    unittest.TestCase     ):
	A    							= (
	    (
	        DebertaModel,
	        DebertaForMaskedLM,
	        DebertaForSequenceClassification,
	        DebertaForTokenClassification,
	        DebertaForQuestionAnswering,
	    )
	    if is_torch_available()
	    else ()
	)
	A    							= (
	    {
	        '''feature-extraction''': DebertaModel,
	        '''fill-mask''': DebertaForMaskedLM,
	        '''question-answering''': DebertaForQuestionAnswering,
	        '''text-classification''': DebertaForSequenceClassification,
	        '''token-classification''': DebertaForTokenClassification,
	        '''zero-shot''': DebertaForSequenceClassification,
	    }
	    if is_torch_available()
	    else {}
	)

	A    							= True
	A    							= False
	A    							= False
	A    							= False
	A    							= False





	def 						A_(							self      )  ->					Dict:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						DebertaModelTester(self      )
				SCREAMING_SNAKE_CASE_								=						ConfigTester(self      ,     config_class=SCREAMING_SNAKE_CASE      ,     hidden_size=37      )





	def 						A_(							self      )  ->					Optional[Any]:




				"""simple docstring"""



				self.config_tester.run_common_tests()





	def 						A_(							self      )  ->					Any:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_deberta_model(*SCREAMING_SNAKE_CASE      )





	def 						A_(							self      )  ->					List[str]:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_deberta_for_sequence_classification(*SCREAMING_SNAKE_CASE      )





	def 						A_(							self      )  ->					Optional[int]:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_deberta_for_masked_lm(*SCREAMING_SNAKE_CASE      )





	def 						A_(							self      )  ->					List[Any]:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_deberta_for_question_answering(*SCREAMING_SNAKE_CASE      )





	def 						A_(							self      )  ->					Optional[int]:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_deberta_for_token_classification(*SCREAMING_SNAKE_CASE      )





	@slow
	def 						A_(							self      )  ->					Dict:




				"""simple docstring"""



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




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





	@unittest.skip(reason='Model not available yet'      )
	def 						A_(							self      )  ->					Union[str, Any]:




				"""simple docstring"""



				pass





	@slow
	def 						A_(							self      )  ->					Union[str, Any]:




				"""simple docstring"""



				SCREAMING_SNAKE_CASE_								=						DebertaModel.from_pretrained('microsoft/deberta-base'      )

				SCREAMING_SNAKE_CASE_								=						torch.tensor([[0, 3_1414, 232, 328, 740, 1140, 1_2695, 69, 4_6078, 1588, 2]]      )
				SCREAMING_SNAKE_CASE_								=						torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]      )
				with torch.no_grad():
							SCREAMING_SNAKE_CASE_								=						model(SCREAMING_SNAKE_CASE      ,     attention_mask=SCREAMING_SNAKE_CASE      )[0]
				# compare the actual values for a slice.
				SCREAMING_SNAKE_CASE_								=						torch.tensor(
				    [[[-0.5_9_8_6, -0.8_0_5_5, -0.8_4_6_2], [1.4_4_8_4, -0.9_3_4_8, -0.8_0_5_9], [0.3_1_2_3, 0.0_0_3_2, -1.4_1_3_1]]]      )
				self.assertTrue(torch.allclose(output[:, 1:4, 1:4]      ,     SCREAMING_SNAKE_CASE      ,     atol=1e-4      )      ,     f'{output[:, 1:4, 1:4]}'      )






def lowercase    (  SCREAMING_SNAKE_CASE )			->							int:


			'''simple docstring'''







			if not numbers:
						return 0

			if not isinstance(SCREAMING_SNAKE_CASE       ,    (list, tuple) ) or not all(
			    isinstance(SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE ) for number in numbers ):
						raise ValueError('numbers must be an iterable of integers' )

			SCREAMING_SNAKE_CASE_								=						SCREAMING_SNAKE_CASE_								=						SCREAMING_SNAKE_CASE_								=						numbers[0]

			for i in range(1       ,    len(SCREAMING_SNAKE_CASE ) ):
						# update the maximum and minimum subarray products
						SCREAMING_SNAKE_CASE_								=						numbers[i]
						if number < 0:
									SCREAMING_SNAKE_CASE_						,		SCREAMING_SNAKE_CASE_								=						min_till_now, max_till_now
						SCREAMING_SNAKE_CASE_								=						max(SCREAMING_SNAKE_CASE       ,    max_till_now * number )
						SCREAMING_SNAKE_CASE_								=						min(SCREAMING_SNAKE_CASE       ,    min_till_now * number )

						# update the maximum product found till now
						SCREAMING_SNAKE_CASE_								=						max(SCREAMING_SNAKE_CASE       ,    SCREAMING_SNAKE_CASE )

			return max_prod
