





import unittest

from transformers import DebertaVaConfig, 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 (
				    DebertaVaForMaskedLM,
				    DebertaVaForMultipleChoice,
				    DebertaVaForQuestionAnswering,
				    DebertaVaForSequenceClassification,
				    DebertaVaForTokenClassification,
				    DebertaVaModel,
				)
				from transformers.models.deberta_va.modeling_deberta_va import DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST

class 	A_       (a_			):
	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'''







				UpperCAmelCase   		=				parent
				UpperCAmelCase   		=				batch_size
				UpperCAmelCase   		=				seq_length
				UpperCAmelCase   		=				is_training
				UpperCAmelCase   		=				use_input_mask
				UpperCAmelCase   		=				use_token_type_ids
				UpperCAmelCase   		=				use_labels
				UpperCAmelCase   		=				vocab_size
				UpperCAmelCase   		=				hidden_size
				UpperCAmelCase   		=				num_hidden_layers
				UpperCAmelCase   		=				num_attention_heads
				UpperCAmelCase   		=				intermediate_size
				UpperCAmelCase   		=				hidden_act
				UpperCAmelCase   		=				hidden_dropout_prob
				UpperCAmelCase   		=				attention_probs_dropout_prob
				UpperCAmelCase   		=				max_position_embeddings
				UpperCAmelCase   		=				type_vocab_size
				UpperCAmelCase   		=				type_sequence_label_size
				UpperCAmelCase   		=				initializer_range
				UpperCAmelCase   		=				num_labels
				UpperCAmelCase   		=				num_choices
				UpperCAmelCase   		=				relative_attention
				UpperCAmelCase   		=				position_biased_input
				UpperCAmelCase   		=				pos_att_type
				UpperCAmelCase   		=				scope
	def      _lowercase				(    self		):






				'''simple docstring'''







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

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

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

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

				UpperCAmelCase   		=				self.get_config()

				return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
	def      _lowercase				(    self		):






				'''simple docstring'''







				return DebertaVaConfig(
				    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      _lowercase				(    self							,					_A		):






				'''simple docstring'''







				self.parent.assertListEqual(list(result.loss.size()		)							,					[]		)
	def      _lowercase				(    self							,					_A							,					_A							,					_A							,					_A							,					_A							,					_A							,					_A		):






				'''simple docstring'''







				UpperCAmelCase   		=				DebertaVaModel(config=_A		)
				model.to(_A		)
				model.eval()
				UpperCAmelCase   		=				model(_A							,					attention_mask=_A							,					token_type_ids=_A		)[0]
				UpperCAmelCase   		=				model(_A							,					token_type_ids=_A		)[0]
				UpperCAmelCase   		=				model(_A		)[0]

				self.parent.assertListEqual(list(sequence_output.size()		)							,					[self.batch_size, self.seq_length, self.hidden_size]		)
	def      _lowercase				(    self							,					_A							,					_A							,					_A							,					_A							,					_A							,					_A							,					_A		):






				'''simple docstring'''







				UpperCAmelCase   		=				DebertaVaForMaskedLM(config=_A		)
				model.to(_A		)
				model.eval()
				UpperCAmelCase   		=				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      _lowercase				(    self							,					_A							,					_A							,					_A							,					_A							,					_A							,					_A							,					_A		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.num_labels
				UpperCAmelCase   		=				DebertaVaForSequenceClassification(_A		)
				model.to(_A		)
				model.eval()
				UpperCAmelCase   		=				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      _lowercase				(    self							,					_A							,					_A							,					_A							,					_A							,					_A							,					_A							,					_A		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.num_labels
				UpperCAmelCase   		=				DebertaVaForTokenClassification(config=_A		)
				model.to(_A		)
				model.eval()
				UpperCAmelCase   		=				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      _lowercase				(    self							,					_A							,					_A							,					_A							,					_A							,					_A							,					_A							,					_A		):






				'''simple docstring'''







				UpperCAmelCase   		=				DebertaVaForQuestionAnswering(config=_A		)
				model.to(_A		)
				model.eval()
				UpperCAmelCase   		=				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      _lowercase				(    self							,					_A							,					_A							,					_A							,					_A							,					_A							,					_A							,					_A		):






				'''simple docstring'''







				UpperCAmelCase   		=				DebertaVaForMultipleChoice(config=_A		)
				model.to(_A		)
				model.eval()
				UpperCAmelCase   		=				input_ids.unsqueeze(1		).expand(-1							,					self.num_choices							,					-1		).contiguous()
				UpperCAmelCase   		=				token_type_ids.unsqueeze(1		).expand(-1							,					self.num_choices							,					-1		).contiguous()
				UpperCAmelCase   		=				input_mask.unsqueeze(1		).expand(-1							,					self.num_choices							,					-1		).contiguous()
				UpperCAmelCase   		=				model(
				    _A							,					attention_mask=_A							,					token_type_ids=_A							,					labels=_A							,					)
				self.parent.assertEqual(result.logits.shape							,					(self.batch_size, self.num_choices)		)







	def      _lowercase				(    self		):






				'''simple docstring'''







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

@require_torch
class 	A_       (a_     ,							a_     ,							unittest.TestCase			):
	UpperCAmelCase__					=			(
	    (
	        DebertaVaModel,
	        DebertaVaForMaskedLM,
	        DebertaVaForSequenceClassification,
	        DebertaVaForTokenClassification,
	        DebertaVaForQuestionAnswering,
	        DebertaVaForMultipleChoice,
	    )
	    if is_torch_available()
	    else ()
	)
	UpperCAmelCase__					=			(
	    {
	        '''feature-extraction''': DebertaVaModel,
	        '''fill-mask''': DebertaVaForMaskedLM,
	        '''question-answering''': DebertaVaForQuestionAnswering,
	        '''text-classification''': DebertaVaForSequenceClassification,
	        '''token-classification''': DebertaVaForTokenClassification,
	        '''zero-shot''': DebertaVaForSequenceClassification,
	    }
	    if is_torch_available()
	    else {}
	)

	UpperCAmelCase__					=			True
	UpperCAmelCase__					=			False
	UpperCAmelCase__					=			False
	UpperCAmelCase__					=			False
	UpperCAmelCase__					=			False
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				DebertaVaModelTester(self		)
				UpperCAmelCase   		=				ConfigTester(self							,					config_class=_A							,					hidden_size=3_7		)
	def      _lowercase				(    self		):






				'''simple docstring'''







				self.config_tester.run_common_tests()
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_deberta_model(*_A		)
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_deberta_for_sequence_classification(*_A		)
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_deberta_for_masked_lm(*_A		)
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_deberta_for_question_answering(*_A		)
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_deberta_for_token_classification(*_A		)
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_deberta_for_multiple_choice(*_A		)







	@slow
	def      _lowercase				(    self		):






				'''simple docstring'''







				for model_name in DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							UpperCAmelCase   		=				DebertaVaModel.from_pretrained(_A		)
							self.assertIsNotNone(_A		)

@require_torch
@require_sentencepiece
@require_tokenizers
class 	A_       (unittest.TestCase			):
	@unittest.skip(reason='''Model not available yet'''		)
	def      _lowercase				(    self		):






				'''simple docstring'''







				pass







	@slow
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				DebertaVaModel.from_pretrained('''microsoft/deberta-v2-xlarge'''		)

				UpperCAmelCase   		=				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]]		)
				UpperCAmelCase   		=				torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]		)
				with torch.no_grad():
							UpperCAmelCase   		=				model(_A							,					attention_mask=_A		)[0]
				# compare the actual values for a slice.
				UpperCAmelCase   		=				torch.tensor(
				    [[[0.23_56, 0.19_48, 0.03_69], [-0.10_63, 0.35_86, -0.51_52], [-0.63_99, -0.02_59, -0.25_25]]]		)
				self.assertTrue(torch.allclose(output[:, 1:4, 1:4]							,					_A							,					atol=1E-4		)							,					F"""{output[:, 1:4, 1:4]}"""		)










def 						__SCREAMING_SNAKE_CASE  (				UpperCamelCase__ )  ->				list[int]:







			'''simple docstring'''

			if length <= 0 or not isinstance(UpperCamelCase__			,			UpperCamelCase__ ):
						raise ValueError('''Length must be a positive integer.''' )
			return [n * (2 * n - 1) for n in range(UpperCamelCase__ )]


if __name__ == "__main__":
				print(hexagonal_numbers(length=5))
				print(hexagonal_numbers(length=10))



