



"""simple docstring"""


from ...utils import (
    OptionalDependencyNotAvailable,
    is_torch_available,
    is_transformers_available,
    is_transformers_version,
)


try:
    if not (is_transformers_available() and is_torch_available() and is_transformers_version(""">=""", """4.25.0""")):
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    from ...utils.dummy_torch_and_transformers_objects import (
        VersatileDiffusionDualGuidedPipeline,
        VersatileDiffusionImageVariationPipeline,
        VersatileDiffusionPipeline,
        VersatileDiffusionTextToImagePipeline,
    )
else:
    from .modeling_text_unet import UNetFlatConditionModel
    from .pipeline_versatile_diffusion import VersatileDiffusionPipeline
    from .pipeline_versatile_diffusion_dual_guided import VersatileDiffusionDualGuidedPipeline
    from .pipeline_versatile_diffusion_image_variation import VersatileDiffusionImageVariationPipeline
    from .pipeline_versatile_diffusion_text_to_image import VersatileDiffusionTextToImagePipeline










"""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_    ):



						"""simple docstring"""






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






						def      UpperCAmelCase__					( self			:Optional[int]       ,  lowercase_			:str       ,  lowercase_			:Tuple       ,  lowercase_			:str       ,  lowercase_			:int       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:List[str]       ,  lowercase_			:Optional[int] )    ->      Optional[int]:
												UpperCAmelCase					=			DebertaVaModel(config=lowercase_ )
												model.to(lowercase_ )
												model.eval()
												UpperCAmelCase					=			model(lowercase_       ,  attention_mask=lowercase_       ,  token_type_ids=lowercase_ )[0]
												UpperCAmelCase					=			model(lowercase_       ,  token_type_ids=lowercase_ )[0]
												UpperCAmelCase					=			model(lowercase_ )[0]

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






						def      UpperCAmelCase__					( self			:Optional[Any]       ,  lowercase_			:Dict       ,  lowercase_			:List[str]       ,  lowercase_			:Any       ,  lowercase_			:List[str]       ,  lowercase_			:Tuple       ,  lowercase_			:List[Any]       ,  lowercase_			:int )    ->      Any:
												UpperCAmelCase					=			DebertaVaForMaskedLM(config=lowercase_ )
												model.to(lowercase_ )
												model.eval()
												UpperCAmelCase					=			model(lowercase_       ,  attention_mask=lowercase_       ,  token_type_ids=lowercase_       ,  labels=lowercase_ )

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






						def      UpperCAmelCase__					( self			:Union[str, Any]       ,  lowercase_			:Any       ,  lowercase_			:List[Any]       ,  lowercase_			:Any       ,  lowercase_			:Dict       ,  lowercase_			:str       ,  lowercase_			:List[Any]       ,  lowercase_			:Dict )    ->      Union[str, Any]:
												UpperCAmelCase					=			self.num_labels
												UpperCAmelCase					=			DebertaVaForSequenceClassification(lowercase_ )
												model.to(lowercase_ )
												model.eval()
												UpperCAmelCase					=			model(lowercase_       ,  attention_mask=lowercase_       ,  token_type_ids=lowercase_       ,  labels=lowercase_ )
												self.parent.assertListEqual(list(result.logits.size() )       ,  [self.batch_size, self.num_labels] )
												self.check_loss_output(lowercase_ )






						def      UpperCAmelCase__					( self			:Any       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:Dict       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:Any       ,  lowercase_			:Optional[int]       ,  lowercase_			:Optional[Any]       ,  lowercase_			:Any )    ->      List[Any]:
												UpperCAmelCase					=			self.num_labels
												UpperCAmelCase					=			DebertaVaForTokenClassification(config=lowercase_ )
												model.to(lowercase_ )
												model.eval()
												UpperCAmelCase					=			model(lowercase_       ,  attention_mask=lowercase_       ,  token_type_ids=lowercase_       ,  labels=lowercase_ )
												self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.seq_length, self.num_labels) )






						def      UpperCAmelCase__					( self			:Any       ,  lowercase_			:Any       ,  lowercase_			:List[Any]       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:Dict       ,  lowercase_			:List[Any]       ,  lowercase_			:Optional[int] )    ->      Dict:
												UpperCAmelCase					=			DebertaVaForQuestionAnswering(config=lowercase_ )
												model.to(lowercase_ )
												model.eval()
												UpperCAmelCase					=			model(
												    lowercase_       ,  attention_mask=lowercase_       ,  token_type_ids=lowercase_       ,  start_positions=lowercase_       ,  end_positions=lowercase_       ,  )
												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      UpperCAmelCase__					( self			:Optional[int]       ,  lowercase_			:str       ,  lowercase_			:List[Any]       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:List[Any]       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:Any       ,  lowercase_			:Any )    ->      List[Any]:
												UpperCAmelCase					=			DebertaVaForMultipleChoice(config=lowercase_ )
												model.to(lowercase_ )
												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(
												    lowercase_       ,  attention_mask=lowercase_       ,  token_type_ids=lowercase_       ,  labels=lowercase_       ,  )
												self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.num_choices) )






						def      UpperCAmelCase__					( self			:Dict )    ->      int:
												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_      (					SCREAMING_SNAKE_CASE_     ,       SCREAMING_SNAKE_CASE_     ,       unittest.TestCase    ):



						"""simple docstring"""
						__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      UpperCAmelCase__					( self			:Optional[Any] )    ->      Optional[int]:
												UpperCAmelCase					=			DebertaVaModelTester(self )
												UpperCAmelCase					=			ConfigTester(self       ,  config_class=lowercase_       ,  hidden_size=37 )






						def      UpperCAmelCase__					( self			:Optional[Any] )    ->      Optional[Any]:
												self.config_tester.run_common_tests()






						def      UpperCAmelCase__					( self			:Optional[Any] )    ->      Tuple:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_deberta_model(*lowercase_ )






						def      UpperCAmelCase__					( self			:Any )    ->      List[str]:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_deberta_for_sequence_classification(*lowercase_ )






						def      UpperCAmelCase__					( self			:Optional[Any] )    ->      List[Any]:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_deberta_for_masked_lm(*lowercase_ )






						def      UpperCAmelCase__					( self			:Optional[Any] )    ->      Optional[int]:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_deberta_for_question_answering(*lowercase_ )






						def      UpperCAmelCase__					( self			:Union[str, Any] )    ->      Tuple:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_deberta_for_token_classification(*lowercase_ )






						def      UpperCAmelCase__					( self			:Any )    ->      Union[str, Any]:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_deberta_for_multiple_choice(*lowercase_ )






						@slow
						def      UpperCAmelCase__					( self			:Any )    ->      Optional[int]:
												for model_name in DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		UpperCAmelCase					=			DebertaVaModel.from_pretrained(lowercase_ )
																		self.assertIsNotNone(lowercase_ )







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



						"""simple docstring"""






						@unittest.skip(reason='Model not available yet' )
						def      UpperCAmelCase__					( self			:str )    ->      Tuple:
												pass






						@slow
						def      UpperCAmelCase__					( self			:List[Any] )    ->      Any:
												UpperCAmelCase					=			DebertaVaModel.from_pretrained('microsoft/deberta-v2-xlarge' )

												UpperCAmelCase					=			torch.tensor([[0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 4_60_78, 15_88, 2]] )
												UpperCAmelCase					=			torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] )
												with torch.no_grad():
																		UpperCAmelCase					=			model(lowercase_       ,  attention_mask=lowercase_ )[0]
												# compare the actual values for a slice.
												UpperCAmelCase					=			torch.tensor(
												    [[[0.2356, 0.1948, 0.0369], [-0.1063, 0.3586, -0.5152], [-0.6399, -0.0259, -0.2525]]] )
												self.assertTrue(torch.allclose(output[:, 1:4, 1:4]       ,  lowercase_       ,  atol=1E-4 )       ,  f"""{output[:, 1:4, 1:4]}""" )





