






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 		_snake_case  (  A__					):






			def __init__(       self		,					a		,					a=13		,					a=7		,					a=True		,					a=True		,					a=True		,					a=True		,					a=99		,					a=32		,					a=5		,					a=4		,					a=37		,					a="gelu"		,					a=0.1		,					a=0.1		,					a=512		,					a=16		,					a=2		,					a=0.02		,					a=False		,					a=True		,					a="None"		,					a=3		,					a=4		,					a=None		,					)      ->       int:
						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    SCREAMING_SNAKE_CASE__    (       self)      ->       List[str]:
						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    SCREAMING_SNAKE_CASE__    (       self)      ->       int:
						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    SCREAMING_SNAKE_CASE__    (       self		,					a)      ->       int:
						self.parent.assertListEqual(list(result.loss.size())		,					[])






			def    SCREAMING_SNAKE_CASE__    (       self		,					a		,					a		,					a		,					a		,					a		,					a		,					a)      ->       int:
						SCREAMING_SNAKE_CASE						= DebertaVaModel(config=a)
						model.to(a)
						model.eval()
						SCREAMING_SNAKE_CASE						= model(a		,					attention_mask=a		,					token_type_ids=a)[0]
						SCREAMING_SNAKE_CASE						= model(a		,					token_type_ids=a)[0]
						SCREAMING_SNAKE_CASE						= 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)      ->       Dict:
						SCREAMING_SNAKE_CASE						= DebertaVaForMaskedLM(config=a)
						model.to(a)
						model.eval()
						SCREAMING_SNAKE_CASE						= 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)      ->       str:
						SCREAMING_SNAKE_CASE						= self.num_labels
						SCREAMING_SNAKE_CASE						= DebertaVaForSequenceClassification(a)
						model.to(a)
						model.eval()
						SCREAMING_SNAKE_CASE						= 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)      ->       int:
						SCREAMING_SNAKE_CASE						= self.num_labels
						SCREAMING_SNAKE_CASE						= DebertaVaForTokenClassification(config=a)
						model.to(a)
						model.eval()
						SCREAMING_SNAKE_CASE						= 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)      ->       Optional[int]:
						SCREAMING_SNAKE_CASE						= DebertaVaForQuestionAnswering(config=a)
						model.to(a)
						model.eval()
						SCREAMING_SNAKE_CASE						= 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		,					a		,					a		,					a		,					a		,					a		,					a		,					a)      ->       Any:
						SCREAMING_SNAKE_CASE						= DebertaVaForMultipleChoice(config=a)
						model.to(a)
						model.eval()
						SCREAMING_SNAKE_CASE						= input_ids.unsqueeze(1).expand(-1		,					self.num_choices		,					-1).contiguous()
						SCREAMING_SNAKE_CASE						= token_type_ids.unsqueeze(1).expand(-1		,					self.num_choices		,					-1).contiguous()
						SCREAMING_SNAKE_CASE						= input_mask.unsqueeze(1).expand(-1		,					self.num_choices		,					-1).contiguous()
						SCREAMING_SNAKE_CASE						= model(
						    a		,					attention_mask=a		,					token_type_ids=a		,					labels=a		,					)
						self.parent.assertEqual(result.logits.shape		,					(self.batch_size, self.num_choices))







			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Optional[int]:
						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 		_snake_case  (  A__   ,    A__   ,    unittest.TestCase					):
			_lowercase		:    Dict			     =							(
			    (
			        DebertaVaModel,
			        DebertaVaForMaskedLM,
			        DebertaVaForSequenceClassification,
			        DebertaVaForTokenClassification,
			        DebertaVaForQuestionAnswering,
			        DebertaVaForMultipleChoice,
			    )
			    if is_torch_available()
			    else ()
			)
			_lowercase		:    Optional[int]			     =							(
			    {
			        '''feature-extraction''': DebertaVaModel,
			        '''fill-mask''': DebertaVaForMaskedLM,
			        '''question-answering''': DebertaVaForQuestionAnswering,
			        '''text-classification''': DebertaVaForSequenceClassification,
			        '''token-classification''': DebertaVaForTokenClassification,
			        '''zero-shot''': DebertaVaForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)

			_lowercase		:    Optional[int]			     =							True
			_lowercase		:    int			     =							False
			_lowercase		:    Dict			     =							False
			_lowercase		:    Optional[int]			     =							False
			_lowercase		:    List[str]			     =							False






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Optional[int]:
						SCREAMING_SNAKE_CASE						= DebertaVaModelTester(self)
						SCREAMING_SNAKE_CASE						= ConfigTester(self		,					config_class=a		,					hidden_size=37)






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Dict:
						self.config_tester.run_common_tests()






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Tuple:
						SCREAMING_SNAKE_CASE						= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_deberta_model(*a)






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       List[Any]:
						SCREAMING_SNAKE_CASE						= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_deberta_for_sequence_classification(*a)






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Dict:
						SCREAMING_SNAKE_CASE						= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_deberta_for_masked_lm(*a)






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Union[str, Any]:
						SCREAMING_SNAKE_CASE						= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_deberta_for_question_answering(*a)






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       int:
						SCREAMING_SNAKE_CASE						= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_deberta_for_token_classification(*a)






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Union[str, Any]:
						SCREAMING_SNAKE_CASE						= self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_deberta_for_multiple_choice(*a)







			@slow
			def    SCREAMING_SNAKE_CASE__    (       self)      ->       str:
						for model_name in DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									SCREAMING_SNAKE_CASE						= DebertaVaModel.from_pretrained(a)
									self.assertIsNotNone(a)



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






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







			@slow
			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Union[str, Any]:
						SCREAMING_SNAKE_CASE						= DebertaVaModel.from_pretrained('microsoft/deberta-v2-xlarge')

						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(a		,					attention_mask=a)[0]
						# compare the actual values for a slice.
						SCREAMING_SNAKE_CASE						= 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]}''')












import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
				import torch

if is_vision_available():
				from PIL import Image

				from transformers import MobileViTImageProcessor

class 		_snake_case  (  unittest.TestCase					):






			def __init__(       self		,					a		,					a=7		,					a=3		,					a=18		,					a=30		,					a=400		,					a=True		,					a=None		,					a=True		,					a=None		,					a=True		,					)      ->       Any:
						SCREAMING_SNAKE_CASE						= size if size is not None else {'shortest_edge': 20}
						SCREAMING_SNAKE_CASE						= crop_size if crop_size is not None else {'height': 18, 'width': 18}
						SCREAMING_SNAKE_CASE						= parent
						SCREAMING_SNAKE_CASE						= batch_size
						SCREAMING_SNAKE_CASE						= num_channels
						SCREAMING_SNAKE_CASE						= image_size
						SCREAMING_SNAKE_CASE						= min_resolution
						SCREAMING_SNAKE_CASE						= max_resolution
						SCREAMING_SNAKE_CASE						= do_resize
						SCREAMING_SNAKE_CASE						= size
						SCREAMING_SNAKE_CASE						= do_center_crop
						SCREAMING_SNAKE_CASE						= crop_size
						SCREAMING_SNAKE_CASE						= do_flip_channel_order







			def    SCREAMING_SNAKE_CASE__    (       self)      ->       List[Any]:
						return {
						    "do_resize": self.do_resize,
						    "size": self.size,
						    "do_center_crop": self.do_center_crop,
						    "crop_size": self.crop_size,
						    "do_flip_channel_order": self.do_flip_channel_order,
						}



@require_torch
@require_vision
class 		_snake_case  (  A__   ,    unittest.TestCase					):
			_lowercase		:    Optional[int]			     =							MobileViTImageProcessor if is_vision_available() else None






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       List[str]:
						SCREAMING_SNAKE_CASE						= MobileViTImageProcessingTester(self)






			@property
			def    SCREAMING_SNAKE_CASE__    (       self)      ->       str:
						return self.image_processor_tester.prepare_image_processor_dict()






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       str:
						SCREAMING_SNAKE_CASE						= self.image_processing_class(**self.image_processor_dict)
						self.assertTrue(hasattr(a		,					'do_resize'))
						self.assertTrue(hasattr(a		,					'size'))
						self.assertTrue(hasattr(a		,					'do_center_crop'))
						self.assertTrue(hasattr(a		,					'center_crop'))
						self.assertTrue(hasattr(a		,					'do_flip_channel_order'))






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       str:
						SCREAMING_SNAKE_CASE						= self.image_processing_class.from_dict(self.image_processor_dict)
						self.assertEqual(image_processor.size		,					{'shortest_edge': 20})
						self.assertEqual(image_processor.crop_size		,					{'height': 18, 'width': 18})

						SCREAMING_SNAKE_CASE						= self.image_processing_class.from_dict(self.image_processor_dict		,					size=42		,					crop_size=84)
						self.assertEqual(image_processor.size		,					{'shortest_edge': 42})
						self.assertEqual(image_processor.crop_size		,					{'height': 84, 'width': 84})






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Tuple:
						pass






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Tuple:
						# Initialize image_processing
						SCREAMING_SNAKE_CASE						= self.image_processing_class(**self.image_processor_dict)
						# create random PIL images
						SCREAMING_SNAKE_CASE						= prepare_image_inputs(self.image_processor_tester		,					equal_resolution=a)
						for image in image_inputs:
									self.assertIsInstance(a		,					Image.Image)

						# Test not batched input
						SCREAMING_SNAKE_CASE						= image_processing(image_inputs[0]		,					return_tensors='pt').pixel_values
						self.assertEqual(
						    encoded_images.shape		,					(
						        1,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    )		,					)

						# Test batched
						SCREAMING_SNAKE_CASE						= image_processing(a		,					return_tensors='pt').pixel_values
						self.assertEqual(
						    encoded_images.shape		,					(
						        self.image_processor_tester.batch_size,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    )		,					)






			def    SCREAMING_SNAKE_CASE__    (       self)      ->       Dict:
						# Initialize image_processing
						SCREAMING_SNAKE_CASE						= self.image_processing_class(**self.image_processor_dict)
						# create random numpy tensors
						SCREAMING_SNAKE_CASE						= prepare_image_inputs(self.image_processor_tester		,					equal_resolution=a		,					numpify=a)
						for image in image_inputs:
									self.assertIsInstance(a		,					np.ndarray)

						# Test not batched input
						SCREAMING_SNAKE_CASE						= image_processing(image_inputs[0]		,					return_tensors='pt').pixel_values
						self.assertEqual(
						    encoded_images.shape		,					(
						        1,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    )		,					)

						# Test batched
						SCREAMING_SNAKE_CASE						= image_processing(a		,					return_tensors='pt').pixel_values
						self.assertEqual(
						    encoded_images.shape		,					(
						        self.image_processor_tester.batch_size,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    )		,					)







			def    SCREAMING_SNAKE_CASE__    (       self)      ->       int:
						# Initialize image_processing
						SCREAMING_SNAKE_CASE						= self.image_processing_class(**self.image_processor_dict)
						# create random PyTorch tensors
						SCREAMING_SNAKE_CASE						= prepare_image_inputs(self.image_processor_tester		,					equal_resolution=a		,					torchify=a)
						for image in image_inputs:
									self.assertIsInstance(a		,					torch.Tensor)

						# Test not batched input
						SCREAMING_SNAKE_CASE						= image_processing(image_inputs[0]		,					return_tensors='pt').pixel_values
						self.assertEqual(
						    encoded_images.shape		,					(
						        1,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    )		,					)

						# Test batched
						SCREAMING_SNAKE_CASE						= image_processing(a		,					return_tensors='pt').pixel_values
						self.assertEqual(
						    encoded_images.shape		,					(
						        self.image_processor_tester.batch_size,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size['height'],
						        self.image_processor_tester.crop_size['width'],
						    )		,					)




