"""simple docstring"""




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 PoolFormerImageProcessor
class 						__A							( unittest.TestCase		):






     def __init__(		self				,     a__				,     a__=7				,     a__=3				,     a__=30				,     a__=400				,     a__=True				,     a__=None				,     a__=0.9				,     a__=None				,     a__=True				,     a__=[0.5, 0.5, 0.5]				,     a__=[0.5, 0.5, 0.5]				,     ):
       _lowerCAmelCase						:       Dict  			=     size if size is not None else {"""shortest_edge""": 30}
       _lowerCAmelCase						:       Union[str, Any]  			=     crop_size if crop_size is not None else {"""height""": 30, """width""": 30}
       _lowerCAmelCase						:       List[str]  			=     parent
       _lowerCAmelCase						:       int  			=     batch_size
       _lowerCAmelCase						:       Optional[Any]  			=     num_channels
       _lowerCAmelCase						:       List[Any]  			=     min_resolution
       _lowerCAmelCase						:       Tuple  			=     max_resolution
       _lowerCAmelCase						:       Optional[int]  			=     do_resize_and_center_crop
       _lowerCAmelCase						:       Dict  			=     size
       _lowerCAmelCase						:       int  			=     crop_pct
       _lowerCAmelCase						:       Optional[Any]  			=     crop_size
       _lowerCAmelCase						:       Tuple  			=     do_normalize
       _lowerCAmelCase						:       List[str]  			=     image_mean
       _lowerCAmelCase						:       Optional[Any]  			=     image_std






     def     __A  (		self  ):
       return {
           "size": self.size,
           "do_resize_and_center_crop": self.do_resize_and_center_crop,
           "crop_pct": self.crop_pct,
           "crop_size": self.crop_size,
           "do_normalize": self.do_normalize,
           "image_mean": self.image_mean,
           "image_std": self.image_std,
       }







@require_torch
@require_vision
class 						__A							( SCREAMING_SNAKE_CASE_    ,	unittest.TestCase		):
     _UpperCamelCase							:			List[Any]							=		PoolFormerImageProcessor if is_vision_available() else None






     def     __A  (		self  ):
       _lowerCAmelCase						:       Tuple  			=     PoolFormerImageProcessingTester(self  )






     @property
     def     __A  (		self  ):
       return self.image_processor_tester.prepare_image_processor_dict()






     def     __A  (		self  ):
       _lowerCAmelCase						:       Dict  			=     self.image_processing_class(**self.image_processor_dict  )
       self.assertTrue(hasattr(a__				,     """do_resize_and_center_crop"""  )  )
       self.assertTrue(hasattr(a__				,     """size"""  )  )
       self.assertTrue(hasattr(a__				,     """crop_pct"""  )  )
       self.assertTrue(hasattr(a__				,     """do_normalize"""  )  )
       self.assertTrue(hasattr(a__				,     """image_mean"""  )  )
       self.assertTrue(hasattr(a__				,     """image_std"""  )  )






     def     __A  (		self  ):
       _lowerCAmelCase						:       List[Any]  			=     self.image_processing_class.from_dict(self.image_processor_dict  )
       self.assertEqual(image_processor.size				,     {"""shortest_edge""": 30}  )
       self.assertEqual(image_processor.crop_size				,     {"""height""": 30, """width""": 30}  )

       _lowerCAmelCase						:       str  			=     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     __A  (		self  ):
       pass






     def     __A  (		self  ):
       # Initialize image_processing
       _lowerCAmelCase						:       Optional[Any]  			=     self.image_processing_class(**self.image_processor_dict  )
       # create random PIL images
       _lowerCAmelCase						:       Union[str, Any]  			=     prepare_image_inputs(self.image_processor_tester				,     equal_resolution=a__  )
       for image in image_inputs:
         self.assertIsInstance(a__				,     Image.Image  )

       # Test not batched input
       _lowerCAmelCase						:       Any  			=     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
       _lowerCAmelCase						:       str  			=     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     __A  (		self  ):
       # Initialize image_processing
       _lowerCAmelCase						:       int  			=     self.image_processing_class(**self.image_processor_dict  )
       # create random numpy tensors
       _lowerCAmelCase						:       Optional[Any]  			=     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
       _lowerCAmelCase						:       Union[str, Any]  			=     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
       _lowerCAmelCase						:       List[Any]  			=     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     __A  (		self  ):
       # Initialize image_processing
       _lowerCAmelCase						:       str  			=     self.image_processing_class(**self.image_processor_dict  )
       # create random PyTorch tensors
       _lowerCAmelCase						:       Dict  			=     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
       _lowerCAmelCase						:       Dict  			=     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
       _lowerCAmelCase						:       Any  			=     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"""],
           )				,     )





"""simple docstring"""




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							( SCREAMING_SNAKE_CASE_		):






     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.0_2				,     a__=False				,     a__=True				,     a__="None"				,     a__=3				,     a__=4				,     a__=None				,     ):
       _lowerCAmelCase						:       Dict  			=     parent
       _lowerCAmelCase						:       str  			=     batch_size
       _lowerCAmelCase						:       List[Any]  			=     seq_length
       _lowerCAmelCase						:       Dict  			=     is_training
       _lowerCAmelCase						:       Dict  			=     use_input_mask
       _lowerCAmelCase						:       int  			=     use_token_type_ids
       _lowerCAmelCase						:       int  			=     use_labels
       _lowerCAmelCase						:       Optional[int]  			=     vocab_size
       _lowerCAmelCase						:       Tuple  			=     hidden_size
       _lowerCAmelCase						:       Tuple  			=     num_hidden_layers
       _lowerCAmelCase						:       Dict  			=     num_attention_heads
       _lowerCAmelCase						:       Union[str, Any]  			=     intermediate_size
       _lowerCAmelCase						:       str  			=     hidden_act
       _lowerCAmelCase						:       Any  			=     hidden_dropout_prob
       _lowerCAmelCase						:       List[str]  			=     attention_probs_dropout_prob
       _lowerCAmelCase						:       List[str]  			=     max_position_embeddings
       _lowerCAmelCase						:       List[str]  			=     type_vocab_size
       _lowerCAmelCase						:       Tuple  			=     type_sequence_label_size
       _lowerCAmelCase						:       List[Any]  			=     initializer_range
       _lowerCAmelCase						:       Union[str, Any]  			=     num_labels
       _lowerCAmelCase						:       Optional[Any]  			=     num_choices
       _lowerCAmelCase						:       Tuple  			=     relative_attention
       _lowerCAmelCase						:       Tuple  			=     position_biased_input
       _lowerCAmelCase						:       Dict  			=     pos_att_type
       _lowerCAmelCase						:       Any  			=     scope






     def     __A  (		self  ):
       _lowerCAmelCase						:       int  			=     ids_tensor([self.batch_size, self.seq_length]				,     self.vocab_size  )

       _lowerCAmelCase						:       Optional[Any]  			=     None
       if self.use_input_mask:
         _lowerCAmelCase						:       str  			=     ids_tensor([self.batch_size, self.seq_length]				,     vocab_size=2  )

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

       _lowerCAmelCase						:       Union[str, Any]  			=     None
       _lowerCAmelCase						:       Union[str, Any]  			=     None
       _lowerCAmelCase						:       Any  			=     None
       if self.use_labels:
         _lowerCAmelCase						:       str  			=     ids_tensor([self.batch_size]				,     self.type_sequence_label_size  )
         _lowerCAmelCase						:       int  			=     ids_tensor([self.batch_size, self.seq_length]				,     self.num_labels  )
         _lowerCAmelCase						:       str  			=     ids_tensor([self.batch_size]				,     self.num_choices  )

       _lowerCAmelCase						:       List[str]  			=     self.get_config()

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






     def     __A  (		self  ):
       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     __A  (		self				,     a__  ):
       self.parent.assertListEqual(list(result.loss.size()  )				,     []  )






     def     __A  (		self				,     a__				,     a__				,     a__				,     a__				,     a__				,     a__				,     a__  ):
       _lowerCAmelCase						:       Union[str, Any]  			=     DebertaVaModel(config=a__  )
       model.to(a__  )
       model.eval()
       _lowerCAmelCase						:       List[Any]  			=     model(a__				,     attention_mask=a__				,     token_type_ids=a__  )[0]
       _lowerCAmelCase						:       List[Any]  			=     model(a__				,     token_type_ids=a__  )[0]
       _lowerCAmelCase						:       Any  			=     model(a__  )[0]

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






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






     def     __A  (		self  ):
       _lowerCAmelCase						:       Tuple  			=     self.prepare_config_and_inputs()
       (
           (
           _lowerCAmelCase
       )			,	(
           _lowerCAmelCase
       )			,	(
           _lowerCAmelCase
       )			,	(
           _lowerCAmelCase
       )			,	(
           _lowerCAmelCase
       )			,	(
           _lowerCAmelCase
       )			,	(
           _lowerCAmelCase
       )			,	
       )						:       Union[str, Any]  			=     config_and_inputs
       _lowerCAmelCase						:       Union[str, Any]  			=     {"""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		):
     _UpperCamelCase							:			Union[str, Any]							=		(
         (
             DebertaVaModel,
             DebertaVaForMaskedLM,
             DebertaVaForSequenceClassification,
             DebertaVaForTokenClassification,
             DebertaVaForQuestionAnswering,
             DebertaVaForMultipleChoice,
         )
         if is_torch_available()
         else ()
     )
     _UpperCamelCase							:			str							=		(
         {
             "feature-extraction": DebertaVaModel,
             "fill-mask": DebertaVaForMaskedLM,
             "question-answering": DebertaVaForQuestionAnswering,
             "text-classification": DebertaVaForSequenceClassification,
             "token-classification": DebertaVaForTokenClassification,
             "zero-shot": DebertaVaForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )

     _UpperCamelCase							:			Optional[Any]							=		True
     _UpperCamelCase							:			List[Any]							=		False
     _UpperCamelCase							:			List[Any]							=		False
     _UpperCamelCase							:			Dict							=		False
     _UpperCamelCase							:			Tuple							=		False






     def     __A  (		self  ):
       _lowerCAmelCase						:       Optional[Any]  			=     DebertaVaModelTester(self  )
       _lowerCAmelCase						:       Any  			=     ConfigTester(self				,     config_class=a__				,     hidden_size=37  )






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






     def     __A  (		self  ):
       _lowerCAmelCase						:       Optional[int]  			=     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_model(*a__  )






     def     __A  (		self  ):
       _lowerCAmelCase						:       List[str]  			=     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_sequence_classification(*a__  )






     def     __A  (		self  ):
       _lowerCAmelCase						:       Any  			=     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_masked_lm(*a__  )






     def     __A  (		self  ):
       _lowerCAmelCase						:       List[Any]  			=     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_question_answering(*a__  )






     def     __A  (		self  ):
       _lowerCAmelCase						:       List[Any]  			=     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_token_classification(*a__  )






     def     __A  (		self  ):
       _lowerCAmelCase						:       Union[str, Any]  			=     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_multiple_choice(*a__  )






     @slow
     def     __A  (		self  ):
       for model_name in DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         _lowerCAmelCase						:       Tuple  			=     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     __A  (		self  ):
       pass






     @slow
     def     __A  (		self  ):
       _lowerCAmelCase						:       Union[str, Any]  			=     DebertaVaModel.from_pretrained("""microsoft/deberta-v2-xlarge"""  )

       _lowerCAmelCase						:       Dict  			=     torch.tensor([[0, 31414, 232, 328, 740, 1140, 12695, 69, 46078, 1588, 2]]  )
       _lowerCAmelCase						:       Any  			=     torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]  )
       with torch.no_grad():
         _lowerCAmelCase						:       Optional[Any]  			=     model(a__				,     attention_mask=a__  )[0]
       # compare the actual values for a slice.
       _lowerCAmelCase						:       str  			=     torch.tensor(
           [[[0.2_3_5_6, 0.1_9_4_8, 0.0_3_6_9], [-0.1_0_6_3, 0.3_5_8_6, -0.5_1_5_2], [-0.6_3_9_9, -0.0_2_5_9, -0.2_5_2_5]]]  )
       self.assertTrue(torch.allclose(output[:, 1:4, 1:4]				,     a__				,     atol=1e-4  )				,     F"{output[:, 1:4, 1:4]}"  )




