"""simple docstring"""


import unittest

from transformers import ElectraConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch

    from transformers import (
        MODEL_FOR_PRETRAINING_MAPPING,
        ElectraForCausalLM,
        ElectraForMaskedLM,
        ElectraForMultipleChoice,
        ElectraForPreTraining,
        ElectraForQuestionAnswering,
        ElectraForSequenceClassification,
        ElectraForTokenClassification,
        ElectraModel,
    )
    from transformers.models.electra.modeling_electra import ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST




class 					UpperCamelCase   :







       def __init__(					self,				lowerCAmelCase__,				lowerCAmelCase__=13,				lowerCAmelCase__=7,				lowerCAmelCase__=True,				lowerCAmelCase__=True,				lowerCAmelCase__=True,				lowerCAmelCase__=True,				lowerCAmelCase__=99,				lowerCAmelCase__=32,				lowerCAmelCase__=5,				lowerCAmelCase__=4,				lowerCAmelCase__=37,				lowerCAmelCase__="gelu",				lowerCAmelCase__=0.1,				lowerCAmelCase__=0.1,				lowerCAmelCase__=512,				lowerCAmelCase__=16,				lowerCAmelCase__=2,				lowerCAmelCase__=0.02,				lowerCAmelCase__=3,				lowerCAmelCase__=4,				lowerCAmelCase__=None,				) -> Any:
            snake_case_   			=   parent
            snake_case_   			=   batch_size
            snake_case_   			=   seq_length
            snake_case_   			=   is_training
            snake_case_   			=   use_input_mask
            snake_case_   			=   use_token_type_ids
            snake_case_   			=   use_labels
            snake_case_   			=   vocab_size
            snake_case_   			=   hidden_size
            snake_case_   			=   num_hidden_layers
            snake_case_   			=   num_attention_heads
            snake_case_   			=   intermediate_size
            snake_case_   			=   hidden_act
            snake_case_   			=   hidden_dropout_prob
            snake_case_   			=   attention_probs_dropout_prob
            snake_case_   			=   max_position_embeddings
            snake_case_   			=   type_vocab_size
            snake_case_   			=   type_sequence_label_size
            snake_case_   			=   initializer_range
            snake_case_   			=   num_labels
            snake_case_   			=   num_choices
            snake_case_   			=   scope







       def 						a_		(					self) -> int:
            snake_case_   			=   ids_tensor([self.batch_size, self.seq_length],				self.vocab_size)

            snake_case_   			=   None
            if self.use_input_mask:
                 snake_case_   			=   random_attention_mask([self.batch_size, self.seq_length])

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

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

            snake_case_   			=   self.get_config()

            return (
                config,
                input_ids,
                token_type_ids,
                input_mask,
                sequence_labels,
                token_labels,
                choice_labels,
                fake_token_labels,
            )







       def 						a_		(					self) -> Optional[Any]:
            return ElectraConfig(
                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,				is_decoder=__UpperCAmelCase,				initializer_range=self.initializer_range,				)







       def 						a_		(					self) -> Optional[int]:
            (
                snake_case_						
            )   			=   self.prepare_config_and_inputs()

            snake_case_   			=   True
            snake_case_   			=   floats_tensor([self.batch_size, self.seq_length, self.hidden_size])
            snake_case_   			=   ids_tensor([self.batch_size, self.seq_length],				vocab_size=2)

            return (
                config,
                input_ids,
                token_type_ids,
                input_mask,
                sequence_labels,
                token_labels,
                choice_labels,
                encoder_hidden_states,
                encoder_attention_mask,
            )







       def 						a_		(					self,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				) -> Any:
            snake_case_   			=   ElectraModel(config=__UpperCAmelCase)
            model.to(__UpperCAmelCase)
            model.eval()
            snake_case_   			=   model(__UpperCAmelCase,				attention_mask=__UpperCAmelCase,				token_type_ids=__UpperCAmelCase)
            snake_case_   			=   model(__UpperCAmelCase,				token_type_ids=__UpperCAmelCase)
            snake_case_   			=   model(__UpperCAmelCase)
            self.parent.assertEqual(result.last_hidden_state.shape,				(self.batch_size, self.seq_length, self.hidden_size))







       def 						a_		(					self,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				) -> Any:
            snake_case_   			=   True
            snake_case_   			=   ElectraModel(__UpperCAmelCase)
            model.to(__UpperCAmelCase)
            model.eval()
            snake_case_   			=   model(
                __UpperCAmelCase,				attention_mask=__UpperCAmelCase,				token_type_ids=__UpperCAmelCase,				encoder_hidden_states=__UpperCAmelCase,				encoder_attention_mask=__UpperCAmelCase,				)
            snake_case_   			=   model(
                __UpperCAmelCase,				attention_mask=__UpperCAmelCase,				token_type_ids=__UpperCAmelCase,				encoder_hidden_states=__UpperCAmelCase,				)
            snake_case_   			=   model(__UpperCAmelCase,				attention_mask=__UpperCAmelCase,				token_type_ids=__UpperCAmelCase)
            self.parent.assertEqual(result.last_hidden_state.shape,				(self.batch_size, self.seq_length, self.hidden_size))







       def 						a_		(					self,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				) -> Union[str, Any]:
            snake_case_   			=   ElectraForMaskedLM(config=__UpperCAmelCase)
            model.to(__UpperCAmelCase)
            model.eval()
            snake_case_   			=   model(__UpperCAmelCase,				attention_mask=__UpperCAmelCase,				token_type_ids=__UpperCAmelCase,				labels=__UpperCAmelCase)
            self.parent.assertEqual(result.logits.shape,				(self.batch_size, self.seq_length, self.vocab_size))







       def 						a_		(					self,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				) -> Union[str, Any]:
            snake_case_   			=   ElectraForCausalLM(config=__UpperCAmelCase)
            model.to(__UpperCAmelCase)
            model.eval()
            snake_case_   			=   model(__UpperCAmelCase,				attention_mask=__UpperCAmelCase,				token_type_ids=__UpperCAmelCase,				labels=__UpperCAmelCase)
            self.parent.assertEqual(result.logits.shape,				(self.batch_size, self.seq_length, self.vocab_size))







       def 						a_		(					self,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				) -> List[Any]:
            snake_case_   			=   self.num_labels
            snake_case_   			=   ElectraForTokenClassification(config=__UpperCAmelCase)
            model.to(__UpperCAmelCase)
            model.eval()
            snake_case_   			=   model(__UpperCAmelCase,				attention_mask=__UpperCAmelCase,				token_type_ids=__UpperCAmelCase,				labels=__UpperCAmelCase)
            self.parent.assertEqual(result.logits.shape,				(self.batch_size, self.seq_length, self.num_labels))







       def 						a_		(					self,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				) -> List[Any]:
            snake_case_   			=   self.num_labels
            snake_case_   			=   ElectraForPreTraining(config=__UpperCAmelCase)
            model.to(__UpperCAmelCase)
            model.eval()
            snake_case_   			=   model(__UpperCAmelCase,				attention_mask=__UpperCAmelCase,				token_type_ids=__UpperCAmelCase,				labels=__UpperCAmelCase)
            self.parent.assertEqual(result.logits.shape,				(self.batch_size, self.seq_length))







       def 						a_		(					self,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				) -> Tuple:
            snake_case_   			=   self.num_labels
            snake_case_   			=   ElectraForSequenceClassification(__UpperCAmelCase)
            model.to(__UpperCAmelCase)
            model.eval()
            snake_case_   			=   model(__UpperCAmelCase,				attention_mask=__UpperCAmelCase,				token_type_ids=__UpperCAmelCase,				labels=__UpperCAmelCase)
            self.parent.assertEqual(result.logits.shape,				(self.batch_size, self.num_labels))







       def 						a_		(					self,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				) -> Optional[Any]:
            snake_case_   			=   ElectraForQuestionAnswering(config=__UpperCAmelCase)
            model.to(__UpperCAmelCase)
            model.eval()
            snake_case_   			=   model(
                __UpperCAmelCase,				attention_mask=__UpperCAmelCase,				token_type_ids=__UpperCAmelCase,				start_positions=__UpperCAmelCase,				end_positions=__UpperCAmelCase,				)
            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,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				) -> int:
            snake_case_   			=   self.num_choices
            snake_case_   			=   ElectraForMultipleChoice(config=__UpperCAmelCase)
            model.to(__UpperCAmelCase)
            model.eval()
            snake_case_   			=   input_ids.unsqueeze(1).expand(-1,				self.num_choices,				-1).contiguous()
            snake_case_   			=   token_type_ids.unsqueeze(1).expand(-1,				self.num_choices,				-1).contiguous()
            snake_case_   			=   input_mask.unsqueeze(1).expand(-1,				self.num_choices,				-1).contiguous()
            snake_case_   			=   model(
                __UpperCAmelCase,				attention_mask=__UpperCAmelCase,				token_type_ids=__UpperCAmelCase,				labels=__UpperCAmelCase,				)
            self.parent.assertEqual(result.logits.shape,				(self.batch_size, self.num_choices))







       def 						a_		(					self) -> Any:
            snake_case_   			=   self.prepare_config_and_inputs()
            (
                snake_case_						
            )   			=   config_and_inputs
            snake_case_   			=   {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
            return config, inputs_dict




@require_torch
class 					UpperCamelCase   (							_lowerCAmelCase       ,						_lowerCAmelCase       ,						unittest.TestCase  ):
       SCREAMING_SNAKE_CASE_						      = (
           (
               ElectraModel,
               ElectraForPreTraining,
               ElectraForMaskedLM,
               ElectraForCausalLM,
               ElectraForMultipleChoice,
               ElectraForTokenClassification,
               ElectraForSequenceClassification,
               ElectraForQuestionAnswering,
           )
           if is_torch_available()
           else ()
       )
       SCREAMING_SNAKE_CASE_						      = (
           {
               "feature-extraction": ElectraModel,
               "fill-mask": ElectraForMaskedLM,
               "question-answering": ElectraForQuestionAnswering,
               "text-classification": ElectraForSequenceClassification,
               "text-generation": ElectraForCausalLM,
               "token-classification": ElectraForTokenClassification,
               "zero-shot": ElectraForSequenceClassification,
           }
           if is_torch_available()
           else {}
       )
       SCREAMING_SNAKE_CASE_						      = True







       def 						a_		(					self,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__=False) -> Dict:
            snake_case_   			=   super()._prepare_for_class(__UpperCAmelCase,				__UpperCAmelCase,				return_labels=__UpperCAmelCase)

            if return_labels:
                 if model_class in get_values(__UpperCAmelCase):
                      snake_case_   			=   torch.zeros(
                          (self.model_tester.batch_size, self.model_tester.seq_length),				dtype=torch.long,				device=__UpperCAmelCase)
            return inputs_dict







       def 						a_		(					self) -> List[Any]:
            snake_case_   			=   ElectraModelTester(self)
            snake_case_   			=   ConfigTester(self,				config_class=__UpperCAmelCase,				hidden_size=37)







       def 						a_		(					self) -> Optional[int]:
            self.config_tester.run_common_tests()







       def 						a_		(					self) -> Any:
            snake_case_   			=   self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_electra_model(*__UpperCAmelCase)







       def 						a_		(					self) -> int:
            snake_case_   			=   self.model_tester.prepare_config_and_inputs_for_decoder()
            self.model_tester.create_and_check_electra_model_as_decoder(*__UpperCAmelCase)







       def 						a_		(					self) -> Optional[int]:
            snake_case_   			=   self.model_tester.prepare_config_and_inputs()
            for type in ["absolute", "relative_key", "relative_key_query"]:
                 snake_case_   			=   type
                 self.model_tester.create_and_check_electra_model(*__UpperCAmelCase)







       def 						a_		(					self) -> List[Any]:
            snake_case_   			=   self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_electra_for_masked_lm(*__UpperCAmelCase)







       def 						a_		(					self) -> str:
            snake_case_   			=   self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_electra_for_token_classification(*__UpperCAmelCase)







       def 						a_		(					self) -> List[str]:
            snake_case_   			=   self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_electra_for_pretraining(*__UpperCAmelCase)







       def 						a_		(					self) -> Dict:
            snake_case_   			=   self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_electra_for_sequence_classification(*__UpperCAmelCase)







       def 						a_		(					self) -> Tuple:
            snake_case_   			=   self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_electra_for_question_answering(*__UpperCAmelCase)







       def 						a_		(					self) -> str:
            snake_case_   			=   self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_electra_for_multiple_choice(*__UpperCAmelCase)







       @slow
       def 						a_		(					self) -> Union[str, Any]:



            for model_name in ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 snake_case_   			=   ElectraModel.from_pretrained(__UpperCAmelCase)
                 self.assertIsNotNone(__UpperCAmelCase)







       def 						a_		(					self) -> Dict:
            snake_case_   			=   self.model_tester.prepare_config_and_inputs_for_decoder()
            self.model_tester.create_and_check_electra_for_causal_lm(*__UpperCAmelCase)




@require_torch
class 					UpperCamelCase   (							unittest.TestCase  ):







       @slow
       def 						a_		(					self) -> List[str]:
            snake_case_   			=   ElectraModel.from_pretrained('google/electra-small-discriminator')
            snake_case_   			=   torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]])
            snake_case_   			=   torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])
            snake_case_   			=   model(__UpperCAmelCase,				attention_mask=__UpperCAmelCase)[0]
            snake_case_   			=   torch.Size((1, 11, 256))
            self.assertEqual(output.shape,				__UpperCAmelCase)
            snake_case_   			=   torch.tensor(
                [[[0.4471, 0.6821, -0.3265], [0.4627, 0.5255, -0.3668], [0.4532, 0.3313, -0.4344]]])

            self.assertTrue(torch.allclose(output[:, 1:4, 1:4],				__UpperCAmelCase,				atol=1e-4))


"""simple docstring"""




import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMParallelScheduler,
    DDPMParallelScheduler,
    StableDiffusionParadigmsPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    require_torch_gpu,
)

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()

class        __SCREAMING_SNAKE_CASE     (   _lowerCAmelCase						,       _lowerCAmelCase						,       unittest.TestCase							):
				UpperCAmelCase	=      StableDiffusionParadigmsPipeline
				UpperCAmelCase	=      TEXT_TO_IMAGE_PARAMS
				UpperCAmelCase	=      TEXT_TO_IMAGE_BATCH_PARAMS
				UpperCAmelCase	=      TEXT_TO_IMAGE_IMAGE_PARAMS
				UpperCAmelCase	=      TEXT_TO_IMAGE_IMAGE_PARAMS







				def   lowercase_		(    self    :List[Any]  )      ->					Tuple:




									"""simple docstring"""



									torch.manual_seed(0  )
									lowerCamelCase__		:   int  				=					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''')      ,cross_attention_dim=32      ,attention_head_dim=(2, 4)      ,use_linear_projection=__UpperCAmelCase      ,)
									lowerCamelCase__		:   List[Any]  				=					DDIMParallelScheduler(
									    beta_start=0.00_085      ,beta_end=0.012      ,beta_schedule='''scaled_linear'''      ,clip_sample=__UpperCAmelCase      ,set_alpha_to_one=__UpperCAmelCase      ,)
									torch.manual_seed(0  )
									lowerCamelCase__		:   Dict  				=					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=1_28      ,)
									torch.manual_seed(0  )
									lowerCamelCase__		:   Any  				=					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=10_00      ,hidden_act='''gelu'''      ,projection_dim=5_12      ,)
									lowerCamelCase__		:   Tuple  				=					CLIPTextModel(__UpperCAmelCase  )
									lowerCamelCase__		:   int  				=					CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''  )

									lowerCamelCase__		:   List[Any]  				=					{
									    '''unet''': unet,
									    '''scheduler''': scheduler,
									    '''vae''': vae,
									    '''text_encoder''': text_encoder,
									    '''tokenizer''': tokenizer,
									    '''safety_checker''': None,
									    '''feature_extractor''': None,
									}
									return components







				def   lowercase_		(    self    :Tuple      ,__UpperCAmelCase    :int      ,__UpperCAmelCase    :Dict=0  )      ->					Optional[int]:




									"""simple docstring"""



									if str(__UpperCAmelCase  ).startswith('''mps'''  ):
														lowerCamelCase__		:   Dict  				=					torch.manual_seed(__UpperCAmelCase  )
									else:
														lowerCamelCase__		:   List[str]  				=					torch.Generator(device=__UpperCAmelCase  ).manual_seed(__UpperCAmelCase  )
									lowerCamelCase__		:   Optional[int]  				=					{
									    '''prompt''': '''a photograph of an astronaut riding a horse''',
									    '''generator''': generator,
									    '''num_inference_steps''': 10,
									    '''guidance_scale''': 6.0,
									    '''output_type''': '''numpy''',
									    '''parallel''': 3,
									    '''debug''': True,
									}
									return inputs







				def   lowercase_		(    self    :Optional[int]  )      ->					str:




									"""simple docstring"""



									lowerCamelCase__		:   Any  				=					'''cpu'''  # ensure determinism for the device-dependent torch.Generator
									lowerCamelCase__		:   int  				=					self.get_dummy_components()
									lowerCamelCase__		:   int  				=					StableDiffusionParadigmsPipeline(**__UpperCAmelCase  )
									lowerCamelCase__		:   Union[str, Any]  				=					sd_pipe.to(__UpperCAmelCase  )
									sd_pipe.set_progress_bar_config(disable=__UpperCAmelCase  )

									lowerCamelCase__		:   Dict  				=					self.get_dummy_inputs(__UpperCAmelCase  )
									lowerCamelCase__		:   Tuple  				=					sd_pipe(**__UpperCAmelCase  ).images
									lowerCamelCase__		:   List[Any]  				=					image[0, -3:, -3:, -1]
									assert image.shape == (1, 64, 64, 3)

									lowerCamelCase__		:   Tuple  				=					np.array([0.4_773, 0.5_417, 0.4_723, 0.4_925, 0.5_631, 0.4_752, 0.5_240, 0.4_935, 0.5_023]  )

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







				def   lowercase_		(    self    :int  )      ->					str:




									"""simple docstring"""



									lowerCamelCase__		:   Tuple  				=					'''cpu'''  # ensure determinism for the device-dependent torch.Generator
									lowerCamelCase__		:   Optional[int]  				=					self.get_dummy_components()
									torch.manual_seed(0  )
									lowerCamelCase__		:   Any  				=					DDPMParallelScheduler()
									torch.manual_seed(0  )
									lowerCamelCase__		:   str  				=					StableDiffusionParadigmsPipeline(**__UpperCAmelCase  )
									lowerCamelCase__		:   Tuple  				=					sd_pipe.to(__UpperCAmelCase  )
									sd_pipe.set_progress_bar_config(disable=__UpperCAmelCase  )

									lowerCamelCase__		:   int  				=					self.get_dummy_inputs(__UpperCAmelCase  )
									lowerCamelCase__		:   Optional[int]  				=					sd_pipe(**__UpperCAmelCase  ).images
									lowerCamelCase__		:   int  				=					image[0, -3:, -3:, -1]
									assert image.shape == (1, 64, 64, 3)

									lowerCamelCase__		:   Optional[int]  				=					np.array([0.3_573, 0.4_420, 0.4_960, 0.4_799, 0.3_796, 0.3_879, 0.4_819, 0.4_365, 0.4_468]  )

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







				def   lowercase_		(    self    :List[str]  )      ->					Dict:




									"""simple docstring"""



									super().test_inference_batch_consistent(batch_sizes=[1, 2]  )







				def   lowercase_		(    self    :Any  )      ->					str:




									"""simple docstring"""



									super().test_inference_batch_single_identical(batch_size=2      ,expected_max_diff=3E-3  )







				def   lowercase_		(    self    :int  )      ->					List[str]:




									"""simple docstring"""



									lowerCamelCase__		:   Optional[Any]  				=					'''cpu'''  # ensure determinism for the device-dependent torch.Generator
									lowerCamelCase__		:   str  				=					self.get_dummy_components()
									lowerCamelCase__		:   int  				=					StableDiffusionParadigmsPipeline(**__UpperCAmelCase  )
									lowerCamelCase__		:   List[Any]  				=					sd_pipe.to(__UpperCAmelCase  )
									sd_pipe.set_progress_bar_config(disable=__UpperCAmelCase  )

									lowerCamelCase__		:   int  				=					self.get_dummy_inputs(__UpperCAmelCase  )
									lowerCamelCase__		:   int  				=					'''french fries'''
									lowerCamelCase__		:   Any  				=					sd_pipe(**__UpperCAmelCase      ,negative_prompt=__UpperCAmelCase  )
									lowerCamelCase__		:   Optional[Any]  				=					output.images
									lowerCamelCase__		:   str  				=					image[0, -3:, -3:, -1]

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

									lowerCamelCase__		:   Tuple  				=					np.array([0.4_771, 0.5_420, 0.4_683, 0.4_918, 0.5_636, 0.4_725, 0.5_230, 0.4_923, 0.5_015]  )

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





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







				def   lowercase_		(    self    :Union[str, Any]  )      ->					Optional[int]:




									"""simple docstring"""



									super().tearDown()
									gc.collect()
									torch.cuda.empty_cache()







				def   lowercase_		(    self    :Optional[int]      ,__UpperCAmelCase    :List[str]=0  )      ->					str:




									"""simple docstring"""



									lowerCamelCase__		:   str  				=					torch.Generator(device=__UpperCAmelCase  ).manual_seed(__UpperCAmelCase  )
									lowerCamelCase__		:   List[Any]  				=					{
									    '''prompt''': '''a photograph of an astronaut riding a horse''',
									    '''generator''': generator,
									    '''num_inference_steps''': 10,
									    '''guidance_scale''': 7.5,
									    '''output_type''': '''numpy''',
									    '''parallel''': 3,
									    '''debug''': True,
									}
									return inputs







				def   lowercase_		(    self    :Optional[Any]  )      ->					Optional[int]:




									"""simple docstring"""



									lowerCamelCase__		:   Optional[Any]  				=					'''stabilityai/stable-diffusion-2-base'''
									lowerCamelCase__		:   Tuple  				=					DDIMParallelScheduler.from_pretrained(__UpperCAmelCase      ,subfolder='''scheduler'''  )
									lowerCamelCase__		:   Optional[Any]  				=					StableDiffusionParadigmsPipeline.from_pretrained(__UpperCAmelCase      ,scheduler=__UpperCAmelCase      ,safety_checker=__UpperCAmelCase  )
									pipe.to(__UpperCAmelCase  )
									pipe.set_progress_bar_config(disable=__UpperCAmelCase  )
									pipe.enable_attention_slicing()

									lowerCamelCase__		:   Optional[Any]  				=					self.get_inputs()
									lowerCamelCase__		:   Tuple  				=					pipe(**__UpperCAmelCase  ).images
									lowerCamelCase__		:   List[Any]  				=					image[0, -3:, -3:, -1].flatten()

									assert image.shape == (1, 5_12, 5_12, 3)

									lowerCamelCase__		:   List[str]  				=					np.array([0.9_622, 0.9_602, 0.9_748, 0.9_591, 0.9_630, 0.9_691, 0.9_661, 0.9_631, 0.9_741]  )

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






