






import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()

class     _SCREAMING_SNAKE_CASE       (			_a		,   _a		,   unittest.TestCase      ):
	snake_case__							:     Any     	=  StableDiffusionXLImgaImgPipeline
	snake_case__							:     Tuple     	=  TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""height""", """width"""}
	snake_case__							:     Tuple     	=  PipelineTesterMixin.required_optional_params - {"""latents"""}
	snake_case__							:     Any     	=  TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
	snake_case__							:     List[str]     	=  IMAGE_TO_IMAGE_IMAGE_PARAMS
	snake_case__							:     Tuple     	=  IMAGE_TO_IMAGE_IMAGE_PARAMS





	def 						_A (		self				:					int	):
		torch.manual_seed(0	)
		UpperCamelCase     :Any          =	UNetaDConditionModel(
		    block_out_channels=(32, 64) ,  layers_per_block=2 ,  sample_size=32 ,  in_channels=4 ,  out_channels=4 ,  down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""") ,  up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""") ,  attention_head_dim=(2, 4) ,  use_linear_projection=__lowerCamelCase ,  addition_embed_type="""text_time""" ,  addition_time_embed_dim=8 ,  transformer_layers_per_block=(1, 2) ,  projection_class_embeddings_input_dim=80 ,  cross_attention_dim=64 ,  )
		UpperCamelCase     :Tuple          =	EulerDiscreteScheduler(
		    beta_start=0.00085 ,  beta_end=0.012 ,  steps_offset=1 ,  beta_schedule="""scaled_linear""" ,  timestep_spacing="""leading""" ,  )
		torch.manual_seed(0	)
		UpperCamelCase     :Union[str, Any]          =	AutoencoderKL(
		    block_out_channels=[32, 64] ,  in_channels=3 ,  out_channels=3 ,  down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""] ,  up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""] ,  latent_channels=4 ,  sample_size=128 ,  )
		torch.manual_seed(0	)
		UpperCamelCase     :Optional[int]          =	CLIPTextConfig(
		    bos_token_id=0 ,  eos_token_id=2 ,  hidden_size=32 ,  intermediate_size=37 ,  layer_norm_eps=1E-05 ,  num_attention_heads=4 ,  num_hidden_layers=5 ,  pad_token_id=1 ,  vocab_size=1_000 ,  hidden_act="""gelu""" ,  projection_dim=32 ,  )
		UpperCamelCase     :Any          =	CLIPTextModel(__lowerCamelCase	)
		UpperCamelCase     :List[Any]          =	CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" ,  local_files_only=__lowerCamelCase	)

		UpperCamelCase     :List[Any]          =	CLIPTextModelWithProjection(__lowerCamelCase	)
		UpperCamelCase     :int          =	CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip""" ,  local_files_only=__lowerCamelCase	)

		UpperCamelCase     :Union[str, Any]          =	{
		    """unet""": unet,
		    """scheduler""": scheduler,
		    """vae""": vae,
		    """text_encoder""": text_encoder,
		    """tokenizer""": tokenizer,
		    """text_encoder_2""": text_encoder_a,
		    """tokenizer_2""": tokenizer_a,
		    # "safety_checker": None,
		    # "feature_extractor": None,
		}
		return components





	def 						_A (		self				:					Tuple ,  __lowerCamelCase				:					Any ,  __lowerCamelCase				:					Optional[Any]=0	):
		UpperCamelCase     :Tuple          =	floats_tensor((1, 3, 32, 32) ,  rng=random.Random(__lowerCamelCase	)	).to(__lowerCamelCase	)
		UpperCamelCase     :List[str]          =	image / 2 + 0.5
		if str(__lowerCamelCase	).startswith("""mps"""	):
			UpperCamelCase     :Any          =	torch.manual_seed(__lowerCamelCase	)
		else:
			UpperCamelCase     :List[Any]          =	torch.Generator(device=__lowerCamelCase	).manual_seed(__lowerCamelCase	)
		UpperCamelCase     :str          =	{
		    """prompt""": """A painting of a squirrel eating a burger""",
		    """image""": image,
		    """generator""": generator,
		    """num_inference_steps""": 2,
		    """guidance_scale""": 5.0,
		    """output_type""": """numpy""",
		    """strength""": 0.75,
		}
		return inputs





	def 						_A (		self				:					str	):
		UpperCamelCase     :List[str]          =	"""cpu"""  # ensure determinism for the device-dependent torch.Generator
		UpperCamelCase     :Optional[Any]          =	self.get_dummy_components()
		UpperCamelCase     :List[Any]          =	StableDiffusionXLImgaImgPipeline(**__lowerCamelCase	)
		UpperCamelCase     :Any          =	sd_pipe.to(__lowerCamelCase	)
		sd_pipe.set_progress_bar_config(disable=__lowerCamelCase	)

		UpperCamelCase     :Optional[Any]          =	self.get_dummy_inputs(__lowerCamelCase	)
		UpperCamelCase     :Union[str, Any]          =	sd_pipe(**__lowerCamelCase	).images
		UpperCamelCase     :Union[str, Any]          =	image[0, -3:, -3:, -1]

		assert image.shape == (1, 32, 32, 3)

		UpperCamelCase     :List[Any]          =	np.array([0.4656, 0.4840, 0.4439, 0.6698, 0.5574, 0.4524, 0.5799, 0.5943, 0.5165]	)

		assert np.abs(image_slice.flatten() - expected_slice	).max() < 1E-2





	def 						_A (		self				:					Dict	):
		super().test_attention_slicing_forward_pass(expected_max_diff=3E-3	)





	def 						_A (		self				:					Optional[Any]	):
		super().test_inference_batch_single_identical(expected_max_diff=3E-3	)





	def 						_A (		self				:					Union[str, Any]	):
		pass





	def 						_A (		self				:					Optional[int]	):
		UpperCamelCase     :Union[str, Any]          =	self.get_dummy_components()
		UpperCamelCase     :Dict          =	StableDiffusionXLImgaImgPipeline(**__lowerCamelCase	)
		UpperCamelCase     :List[Any]          =	sd_pipe.to(__lowerCamelCase	)
		UpperCamelCase     :List[str]          =	sd_pipe.to(__lowerCamelCase	)
		sd_pipe.set_progress_bar_config(disable=__lowerCamelCase	)

		# forward without prompt embeds
		UpperCamelCase     :List[Any]          =	self.get_dummy_inputs(__lowerCamelCase	)
		UpperCamelCase     :int          =	3 * ["""this is a negative prompt"""]
		UpperCamelCase     :Union[str, Any]          =	negative_prompt
		UpperCamelCase     :Union[str, Any]          =	3 * [inputs["""prompt"""]]

		UpperCamelCase     :Dict          =	sd_pipe(**__lowerCamelCase	)
		UpperCamelCase     :Union[str, Any]          =	output.images[0, -3:, -3:, -1]

		# forward with prompt embeds
		UpperCamelCase     :Union[str, Any]          =	self.get_dummy_inputs(__lowerCamelCase	)
		UpperCamelCase     :Optional[int]          =	3 * ["""this is a negative prompt"""]
		UpperCamelCase     :Union[str, Any]          =	3 * [inputs.pop("""prompt"""	)]

		(
		    (
		    UpperCamelCase
		)     ,      (
		    UpperCamelCase
		)     ,      (
		    UpperCamelCase
		)     ,      (
		    UpperCamelCase
		)     ,      
		)     :Union[str, Any]          =	sd_pipe.encode_prompt(__lowerCamelCase ,  negative_prompt=__lowerCamelCase	)

		UpperCamelCase     :Dict          =	sd_pipe(
		    **__lowerCamelCase ,  prompt_embeds=__lowerCamelCase ,  negative_prompt_embeds=__lowerCamelCase ,  pooled_prompt_embeds=__lowerCamelCase ,  negative_pooled_prompt_embeds=__lowerCamelCase ,  )
		UpperCamelCase     :Union[str, Any]          =	output.images[0, -3:, -3:, -1]

		# make sure that it's equal
		assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()	).max() < 1E-4

@slow
@require_torch_gpu
class     _SCREAMING_SNAKE_CASE       (			unittest.TestCase      ):





	def 						_A (		self				:					Tuple	):
		super().tearDown()
		gc.collect()
		torch.cuda.empty_cache()





	def 						_A (		self				:					List[Any] ,  __lowerCamelCase				:					Any ,  __lowerCamelCase				:					Dict="cpu" ,  __lowerCamelCase				:					List[Any]=torch.floataa ,  __lowerCamelCase				:					Tuple=0	):
		UpperCamelCase     :Optional[int]          =	torch.Generator(device=__lowerCamelCase	).manual_seed(__lowerCamelCase	)
		UpperCamelCase     :Optional[Any]          =	np.random.RandomState(__lowerCamelCase	).standard_normal((1, 4, 64, 64)	)
		UpperCamelCase     :Dict          =	torch.from_numpy(__lowerCamelCase	).to(device=__lowerCamelCase ,  dtype=__lowerCamelCase	)
		UpperCamelCase     :str          =	{
		    """prompt""": """a photograph of an astronaut riding a horse""",
		    """latents""": latents,
		    """generator""": generator,
		    """num_inference_steps""": 3,
		    """guidance_scale""": 7.5,
		    """output_type""": """numpy""",
		}
		return inputs





	def 						_A (		self				:					Optional[Any]	):
		UpperCamelCase     :Any          =	DiffusionPipeline.from_pretrained("""stabilityai/stable-diffusion-2-base"""	)
		pipe.to(__lowerCamelCase	)
		pipe.set_progress_bar_config(disable=__lowerCamelCase	)

		UpperCamelCase     :Optional[Any]          =	self.get_inputs(__lowerCamelCase	)
		UpperCamelCase     :Optional[int]          =	pipe(**__lowerCamelCase	).images
		UpperCamelCase     :Dict          =	image[0, -3:, -3:, -1].flatten()

		assert image.shape == (1, 512, 512, 3)
		UpperCamelCase     :Union[str, Any]          =	np.array([0.49493, 0.47896, 0.40798, 0.54214, 0.53212, 0.48202, 0.47656, 0.46329, 0.48506]	)
		assert np.abs(image_slice - expected_slice	).max() < 7E-3



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   __lowercase      (_UpperCAmelCase ):
 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      ,							)					->List[Any]:



       '''simple docstring'''





       __lowerCAmelCase					:						Union[str, Any]					=					parent
       __lowerCAmelCase					:						List[str]					=					batch_size
       __lowerCAmelCase					:						Dict					=					seq_length
       __lowerCAmelCase					:						List[Any]					=					is_training
       __lowerCAmelCase					:						List[Any]					=					use_input_mask
       __lowerCAmelCase					:						Optional[int]					=					use_token_type_ids
       __lowerCAmelCase					:						Tuple					=					use_labels
       __lowerCAmelCase					:						str					=					vocab_size
       __lowerCAmelCase					:						int					=					hidden_size
       __lowerCAmelCase					:						Any					=					num_hidden_layers
       __lowerCAmelCase					:						Any					=					num_attention_heads
       __lowerCAmelCase					:						Dict					=					intermediate_size
       __lowerCAmelCase					:						int					=					hidden_act
       __lowerCAmelCase					:						int					=					hidden_dropout_prob
       __lowerCAmelCase					:						Any					=					attention_probs_dropout_prob
       __lowerCAmelCase					:						List[str]					=					max_position_embeddings
       __lowerCAmelCase					:						Union[str, Any]					=					type_vocab_size
       __lowerCAmelCase					:						Union[str, Any]					=					type_sequence_label_size
       __lowerCAmelCase					:						Optional[int]					=					initializer_range
       __lowerCAmelCase					:						int					=					num_labels
       __lowerCAmelCase					:						int					=					num_choices
       __lowerCAmelCase					:						List[str]					=					relative_attention
       __lowerCAmelCase					:						Union[str, Any]					=					position_biased_input
       __lowerCAmelCase					:						int					=					pos_att_type
       __lowerCAmelCase					:						List[Any]					=					scope
 def 	UpperCamelCase__  (							self					)					->Dict:



       '''simple docstring'''





       __lowerCAmelCase					:						Dict					=					ids_tensor([self.batch_size, self.seq_length]      ,							self.vocab_size					)

       __lowerCAmelCase					:						int					=					None
       if self.use_input_mask:
             __lowerCAmelCase					:						List[Any]					=					ids_tensor([self.batch_size, self.seq_length]      ,							vocab_size=2					)

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

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

       __lowerCAmelCase					:						Tuple					=					self.get_config()

       return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
 def 	UpperCamelCase__  (							self					)					->List[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 	UpperCamelCase__  (							self					)					->str:



       '''simple docstring'''





       __lowerCAmelCase					:						str					=					self.get_config()
       __lowerCAmelCase					:						Dict					=					300
       return config
 def 	UpperCamelCase__  (							self      ,							A_					)					->Union[str, Any]:



       '''simple docstring'''





       self.parent.assertListEqual(list(result.loss.size()					)      ,							[]					)
 def 	UpperCamelCase__  (							self      ,							A_      ,							A_      ,							A_      ,							A_      ,							A_      ,							A_      ,							A_					)					->Any:



       '''simple docstring'''





       __lowerCAmelCase					:						Optional[Any]					=					DebertaModel(config=A_					)
       model.to(A_					)
       model.eval()
       __lowerCAmelCase					:						str					=					model(A_      ,							attention_mask=A_      ,							token_type_ids=A_					)[0]
       __lowerCAmelCase					:						Any					=					model(A_      ,							token_type_ids=A_					)[0]
       __lowerCAmelCase					:						List[str]					=					model(A_					)[0]

       self.parent.assertListEqual(list(sequence_output.size()					)      ,							[self.batch_size, self.seq_length, self.hidden_size]					)
 def 	UpperCamelCase__  (							self      ,							A_      ,							A_      ,							A_      ,							A_      ,							A_      ,							A_      ,							A_					)					->int:



       '''simple docstring'''





       __lowerCAmelCase					:						Tuple					=					DebertaForMaskedLM(config=A_					)
       model.to(A_					)
       model.eval()
       __lowerCAmelCase					:						Union[str, 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 	UpperCamelCase__  (							self      ,							A_      ,							A_      ,							A_      ,							A_      ,							A_      ,							A_      ,							A_					)					->Any:



       '''simple docstring'''





       __lowerCAmelCase					:						Any					=					self.num_labels
       __lowerCAmelCase					:						Tuple					=					DebertaForSequenceClassification(A_					)
       model.to(A_					)
       model.eval()
       __lowerCAmelCase					:						Union[str, 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 	UpperCamelCase__  (							self      ,							A_      ,							A_      ,							A_      ,							A_      ,							A_      ,							A_      ,							A_					)					->Dict:



       '''simple docstring'''





       __lowerCAmelCase					:						List[Any]					=					self.num_labels
       __lowerCAmelCase					:						Optional[int]					=					DebertaForTokenClassification(config=A_					)
       model.to(A_					)
       model.eval()
       __lowerCAmelCase					:						Tuple					=					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 	UpperCamelCase__  (							self      ,							A_      ,							A_      ,							A_      ,							A_      ,							A_      ,							A_      ,							A_					)					->str:



       '''simple docstring'''





       __lowerCAmelCase					:						List[str]					=					DebertaForQuestionAnswering(config=A_					)
       model.to(A_					)
       model.eval()
       __lowerCAmelCase					:						int					=					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 	UpperCamelCase__  (							self					)					->List[str]:



       '''simple docstring'''





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







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

 _UpperCamelCase			  =  True
 _UpperCamelCase			  =  False
 _UpperCamelCase			  =  False
 _UpperCamelCase			  =  False
 _UpperCamelCase			  =  False
 def 	UpperCamelCase__  (							self					)					->int:



       '''simple docstring'''





       __lowerCAmelCase					:						int					=					DebertaModelTester(self					)
       __lowerCAmelCase					:						List[Any]					=					ConfigTester(self      ,							config_class=A_      ,							hidden_size=37					)
 def 	UpperCamelCase__  (							self					)					->Optional[Any]:



       '''simple docstring'''





       self.config_tester.run_common_tests()
 def 	UpperCamelCase__  (							self					)					->List[Any]:



       '''simple docstring'''





       __lowerCAmelCase					:						Dict					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_model(*A_					)
 def 	UpperCamelCase__  (							self					)					->int:



       '''simple docstring'''





       __lowerCAmelCase					:						Any					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_sequence_classification(*A_					)
 def 	UpperCamelCase__  (							self					)					->int:



       '''simple docstring'''





       __lowerCAmelCase					:						Any					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_masked_lm(*A_					)
 def 	UpperCamelCase__  (							self					)					->Optional[int]:



       '''simple docstring'''





       __lowerCAmelCase					:						List[Any]					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_question_answering(*A_					)
 def 	UpperCamelCase__  (							self					)					->List[Any]:



       '''simple docstring'''





       __lowerCAmelCase					:						str					=					self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_deberta_for_token_classification(*A_					)





 @slow
 def 	UpperCamelCase__  (							self					)					->Tuple:



       '''simple docstring'''





       for model_name in DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             __lowerCAmelCase					:						Optional[int]					=					DebertaModel.from_pretrained(A_					)
             self.assertIsNotNone(A_					)







@require_torch
@require_sentencepiece
@require_tokenizers
class   __lowercase      (unittest.TestCase ):
 @unittest.skip(reason='''Model not available yet'''					)
 def 	UpperCamelCase__  (							self					)					->Dict:



       '''simple docstring'''





       pass





 @slow
 def 	UpperCamelCase__  (							self					)					->Tuple:



       '''simple docstring'''





       __lowerCAmelCase					:						str					=					DebertaModel.from_pretrained('''microsoft/deberta-base'''					)

       __lowerCAmelCase					:						Tuple					=					torch.tensor([[0, 3_1414, 232, 328, 740, 1140, 1_2695, 69, 4_6078, 1588, 2]]					)
       __lowerCAmelCase					:						Union[str, Any]					=					torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]					)
       with torch.no_grad():
             __lowerCAmelCase					:						Optional[int]					=					model(A_      ,							attention_mask=A_					)[0]
       # compare the actual values for a slice.
       __lowerCAmelCase					:						Optional[Any]					=					torch.tensor(
           [[[-0.5_986, -0.8_055, -0.8_462], [1.4_484, -0.9_348, -0.8_059], [0.3_123, 0.0_032, -1.4_131]]]					)
       self.assertTrue(torch.allclose(output[:, 1:4, 1:4]      ,							A_      ,							atol=1e-4					)      ,							f"""{output[:, 1:4, 1:4]}"""					)


