code: 
  
  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     lowerCamelCase_			(  snake_case__	,			snake_case__	,			unittest.TestCase  ):
  	_lowercase		:      str    				=							StableDiffusionParadigmsPipeline
  	_lowercase		:      Tuple    				=							TEXT_TO_IMAGE_PARAMS
  	_lowercase		:      str    				=							TEXT_TO_IMAGE_BATCH_PARAMS
  	_lowercase		:      Any    				=							TEXT_TO_IMAGE_IMAGE_PARAMS
  	_lowercase		:      Union[str, Any]    				=							TEXT_TO_IMAGE_IMAGE_PARAMS
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    str       ):
  		torch.manual_seed(0       )
  		__A   : List[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""")				,			cross_attention_dim=32				,			attention_head_dim=(2, 4)				,			use_linear_projection=__snake_case				,			)
  		__A   : str								= DDIMParallelScheduler(
  		    beta_start=0.0_0_0_8_5				,			beta_end=0.0_1_2				,			beta_schedule="""scaled_linear"""				,			clip_sample=__snake_case				,			set_alpha_to_one=__snake_case				,			)
  		torch.manual_seed(0       )
  		__A   : 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       )
  		__A   : str								= CLIPTextConfig(
  		    bos_token_id=0				,			eos_token_id=2				,			hidden_size=32				,			intermediate_size=37				,			layer_norm_eps=1e-0_5				,			num_attention_heads=4				,			num_hidden_layers=5				,			pad_token_id=1				,			vocab_size=1000				,			hidden_act="""gelu"""				,			projection_dim=512				,			)
  		__A   : str								= CLIPTextModel(__snake_case       )
  		__A   : Tuple								= CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""       )
  
  		__A   : str								= {
  		    """unet""": unet,
  		    """scheduler""": scheduler,
  		    """vae""": vae,
  		    """text_encoder""": text_encoder,
  		    """tokenizer""": tokenizer,
  		    """safety_checker""": None,
  		    """feature_extractor""": None,
  		}
  		return components
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    str				,			__A	:    Any				,			__A	:    List[str]=0       ):
  		if str(__snake_case       ).startswith("""mps"""       ):
  			__A   : Optional[int]								= torch.manual_seed(__snake_case       )
  		else:
  			__A   : Optional[int]								= torch.Generator(device=__snake_case       ).manual_seed(__snake_case       )
  		__A   : List[Any]								= {
  		    """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 					lowerCAmelCase_					(    self	:    Optional[Any]       ):
  		__A   : Tuple								= """cpu"""  # ensure determinism for the device-dependent torch.Generator
  		__A   : Any								= self.get_dummy_components()
  		__A   : Dict								= StableDiffusionParadigmsPipeline(**__snake_case       )
  		__A   : List[str]								= sd_pipe.to(__snake_case       )
  		sd_pipe.set_progress_bar_config(disable=__snake_case       )
  
  		__A   : str								= self.get_dummy_inputs(__snake_case       )
  		__A   : Any								= sd_pipe(**__snake_case       ).images
  		__A   : Any								= image[0, -3:, -3:, -1]
  		assert image.shape == (1, 64, 64, 3)
  
  		__A   : Any								= np.array([0.4_7_7_3, 0.5_4_1_7, 0.4_7_2_3, 0.4_9_2_5, 0.5_6_3_1, 0.4_7_5_2, 0.5_2_4_0, 0.4_9_3_5, 0.5_0_2_3]       )
  
  		assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-2
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    Tuple       ):
  		__A   : Optional[Any]								= """cpu"""  # ensure determinism for the device-dependent torch.Generator
  		__A   : str								= self.get_dummy_components()
  		torch.manual_seed(0       )
  		__A   : Union[str, Any]								= DDPMParallelScheduler()
  		torch.manual_seed(0       )
  		__A   : Dict								= StableDiffusionParadigmsPipeline(**__snake_case       )
  		__A   : Tuple								= sd_pipe.to(__snake_case       )
  		sd_pipe.set_progress_bar_config(disable=__snake_case       )
  
  		__A   : Any								= self.get_dummy_inputs(__snake_case       )
  		__A   : List[Any]								= sd_pipe(**__snake_case       ).images
  		__A   : Union[str, Any]								= image[0, -3:, -3:, -1]
  		assert image.shape == (1, 64, 64, 3)
  
  		__A   : List[Any]								= np.array([0.3_5_7_3, 0.4_4_2_0, 0.4_9_6_0, 0.4_7_9_9, 0.3_7_9_6, 0.3_8_7_9, 0.4_8_1_9, 0.4_3_6_5, 0.4_4_6_8]       )
  
  		assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-2
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    Dict       ):
  		super().test_inference_batch_consistent(batch_sizes=[1, 2]       )
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    Any       ):
  		super().test_inference_batch_single_identical(batch_size=2				,			expected_max_diff=3e-3       )
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    Optional[Any]       ):
  		__A   : Optional[int]								= """cpu"""  # ensure determinism for the device-dependent torch.Generator
  		__A   : List[Any]								= self.get_dummy_components()
  		__A   : Optional[int]								= StableDiffusionParadigmsPipeline(**__snake_case       )
  		__A   : Optional[int]								= sd_pipe.to(__snake_case       )
  		sd_pipe.set_progress_bar_config(disable=__snake_case       )
  
  		__A   : Optional[int]								= self.get_dummy_inputs(__snake_case       )
  		__A   : Tuple								= """french fries"""
  		__A   : str								= sd_pipe(**__snake_case				,			negative_prompt=__snake_case       )
  		__A   : Optional[int]								= output.images
  		__A   : Optional[int]								= image[0, -3:, -3:, -1]
  
  		assert image.shape == (1, 64, 64, 3)
  
  		__A   : Optional[int]								= np.array([0.4_7_7_1, 0.5_4_2_0, 0.4_6_8_3, 0.4_9_1_8, 0.5_6_3_6, 0.4_7_2_5, 0.5_2_3_0, 0.4_9_2_3, 0.5_0_1_5]       )
  
  		assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-2
  
  
  
  
  
  
  @slow
  @require_torch_gpu
  class     lowerCamelCase_			(  unittest.TestCase  ):
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    List[str]       ):
  		super().tearDown()
  		gc.collect()
  		torch.cuda.empty_cache()
  
  
  
  
  	def 					lowerCAmelCase_					(    self	:    List[str]				,			__A	:    Optional[int]=0       ):
  		__A   : Tuple								= torch.Generator(device=__snake_case       ).manual_seed(__snake_case       )
  		__A   : Union[str, 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 					lowerCAmelCase_					(    self	:    Union[str, Any]       ):
  		__A   : Optional[Any]								= """stabilityai/stable-diffusion-2-base"""
  		__A   : str								= DDIMParallelScheduler.from_pretrained(__snake_case				,			subfolder="""scheduler"""       )
  		__A   : str								= StableDiffusionParadigmsPipeline.from_pretrained(__snake_case				,			scheduler=__snake_case				,			safety_checker=__snake_case       )
  		pipe.to(__snake_case       )
  		pipe.set_progress_bar_config(disable=__snake_case       )
  		pipe.enable_attention_slicing()
  
  		__A   : Tuple								= self.get_inputs()
  		__A   : Any								= pipe(**__snake_case       ).images
  		__A   : List[Any]								= image[0, -3:, -3:, -1].flatten()
  
  		assert image.shape == (1, 512, 512, 3)
  
  		__A   : Optional[int]								= np.array([0.9_6_2_2, 0.9_6_0_2, 0.9_7_4_8, 0.9_5_9_1, 0.9_6_3_0, 0.9_6_9_1, 0.9_6_6_1, 0.9_6_3_1, 0.9_7_4_1]       )
  
  		assert np.abs(expected_slice - image_slice       ).max() < 1e-2
  
  
  
  
  
  
style_context: 
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available
  
  
  UpperCAmelCase_       :				Optional[Any]		   =      {
      '''configuration_prophetnet''': ['''PROPHETNET_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ProphetNetConfig'''],
      '''tokenization_prophetnet''': ['''ProphetNetTokenizer'''],
  }
  
  try:
  			if not is_torch_available():
  						raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  			pass
  else:
  			UpperCAmelCase_       :				List[str]		   =      [
  			    '''PROPHETNET_PRETRAINED_MODEL_ARCHIVE_LIST''',
  			    '''ProphetNetDecoder''',
  			    '''ProphetNetEncoder''',
  			    '''ProphetNetForCausalLM''',
  			    '''ProphetNetForConditionalGeneration''',
  			    '''ProphetNetModel''',
  			    '''ProphetNetPreTrainedModel''',
  			]
  
  
  if TYPE_CHECKING:
  			from .configuration_prophetnet import PROPHETNET_PRETRAINED_CONFIG_ARCHIVE_MAP, ProphetNetConfig
  			from .tokenization_prophetnet import ProphetNetTokenizer
  
  			try:
  						if not is_torch_available():
  									raise OptionalDependencyNotAvailable()
  			except OptionalDependencyNotAvailable:
  						pass
  			else:
  						from .modeling_prophetnet import (
  						    PROPHETNET_PRETRAINED_MODEL_ARCHIVE_LIST,
  						    ProphetNetDecoder,
  						    ProphetNetEncoder,
  						    ProphetNetForCausalLM,
  						    ProphetNetForConditionalGeneration,
  						    ProphetNetModel,
  						    ProphetNetPreTrainedModel,
  						)
  
  else:
  			import sys
  
  			UpperCAmelCase_       :				Any		   =      _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
  
  
  
  
  
  