code: 
  
  
  '''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   (			A__  ,						A__  ,						unittest.TestCase   ):
        A				:							Optional[int]    							=     StableDiffusionParadigmsPipeline
        A				:							Dict    							=     TEXT_TO_IMAGE_PARAMS
        A				:							Any    							=     TEXT_TO_IMAGE_BATCH_PARAMS
        A				:							Union[str, Any]    							=     TEXT_TO_IMAGE_IMAGE_PARAMS
        A				:							Union[str, Any]    							=     TEXT_TO_IMAGE_IMAGE_PARAMS
  
  
        def        __lowerCamelCase			(							self		):
              torch.manual_seed(0		)
              lowercase			:   Dict					   =		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=SCREAMING_SNAKE_CASE__							,						)
              lowercase			:   List[Any]					   =		DDIMParallelScheduler(
                  beta_start=0.00085							,						beta_end=0.012							,						beta_schedule='''scaled_linear'''							,						clip_sample=SCREAMING_SNAKE_CASE__							,						set_alpha_to_one=SCREAMING_SNAKE_CASE__							,						)
              torch.manual_seed(0		)
              lowercase			:   List[str]					   =		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		)
              lowercase			:   Union[str, 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=1000							,						hidden_act='''gelu'''							,						projection_dim=512							,						)
              lowercase			:   Optional[int]					   =		CLIPTextModel(SCREAMING_SNAKE_CASE__		)
              lowercase			:   Optional[int]					   =		CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''		)
  
              lowercase			:   Union[str, Any]					   =		{
                  '''unet''': unet,
                  '''scheduler''': scheduler,
                  '''vae''': vae,
                  '''text_encoder''': text_encoder,
                  '''tokenizer''': tokenizer,
                  '''safety_checker''': None,
                  '''feature_extractor''': None,
              }
              return components
  
  
        def        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__=0		):
              if str(SCREAMING_SNAKE_CASE__		).startswith('''mps'''		):
                    lowercase			:   Any					   =		torch.manual_seed(SCREAMING_SNAKE_CASE__		)
              else:
                    lowercase			:   Dict					   =		torch.Generator(device=SCREAMING_SNAKE_CASE__		).manual_seed(SCREAMING_SNAKE_CASE__		)
              lowercase			:   Tuple					   =		{
                  '''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		):
              lowercase			:   int					   =		'''cpu'''  # ensure determinism for the device-dependent torch.Generator
              lowercase			:   str					   =		self.get_dummy_components()
              lowercase			:   List[Any]					   =		StableDiffusionParadigmsPipeline(**SCREAMING_SNAKE_CASE__		)
              lowercase			:   int					   =		sd_pipe.to(SCREAMING_SNAKE_CASE__		)
              sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__		)
  
              lowercase			:   Optional[int]					   =		self.get_dummy_inputs(SCREAMING_SNAKE_CASE__		)
              lowercase			:   Dict					   =		sd_pipe(**SCREAMING_SNAKE_CASE__		).images
              lowercase			:   List[str]					   =		image[0, -3:, -3:, -1]
              assert image.shape == (1, 64, 64, 3)
  
              lowercase			:   List[str]					   =		np.array([0.4773, 0.5417, 0.4723, 0.4925, 0.5631, 0.4752, 0.5240, 0.4935, 0.5023]		)
  
              assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   int					   =		'''cpu'''  # ensure determinism for the device-dependent torch.Generator
              lowercase			:   Dict					   =		self.get_dummy_components()
              torch.manual_seed(0		)
              lowercase			:   Dict					   =		DDPMParallelScheduler()
              torch.manual_seed(0		)
              lowercase			:   Optional[Any]					   =		StableDiffusionParadigmsPipeline(**SCREAMING_SNAKE_CASE__		)
              lowercase			:   int					   =		sd_pipe.to(SCREAMING_SNAKE_CASE__		)
              sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__		)
  
              lowercase			:   List[str]					   =		self.get_dummy_inputs(SCREAMING_SNAKE_CASE__		)
              lowercase			:   Any					   =		sd_pipe(**SCREAMING_SNAKE_CASE__		).images
              lowercase			:   Dict					   =		image[0, -3:, -3:, -1]
              assert image.shape == (1, 64, 64, 3)
  
              lowercase			:   str					   =		np.array([0.3573, 0.4420, 0.4960, 0.4799, 0.3796, 0.3879, 0.4819, 0.4365, 0.4468]		)
  
              assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2
  
  
        def        __lowerCamelCase			(							self		):
              super().test_inference_batch_consistent(batch_sizes=[1, 2]		)
  
  
        def        __lowerCamelCase			(							self		):
              super().test_inference_batch_single_identical(batch_size=2							,						expected_max_diff=3E-3		)
  
  
  
  
  
  
        def        __lowerCamelCase			(							self		):
              lowercase			:   int					   =		'''cpu'''  # ensure determinism for the device-dependent torch.Generator
              lowercase			:   List[str]					   =		self.get_dummy_components()
              lowercase			:   str					   =		StableDiffusionParadigmsPipeline(**SCREAMING_SNAKE_CASE__		)
              lowercase			:   int					   =		sd_pipe.to(SCREAMING_SNAKE_CASE__		)
              sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__		)
  
              lowercase			:   Union[str, Any]					   =		self.get_dummy_inputs(SCREAMING_SNAKE_CASE__		)
              lowercase			:   Dict					   =		'''french fries'''
              lowercase			:   Tuple					   =		sd_pipe(**SCREAMING_SNAKE_CASE__							,						negative_prompt=SCREAMING_SNAKE_CASE__		)
              lowercase			:   Union[str, Any]					   =		output.images
              lowercase			:   Optional[int]					   =		image[0, -3:, -3:, -1]
  
              assert image.shape == (1, 64, 64, 3)
  
              lowercase			:   Tuple					   =		np.array([0.4771, 0.5420, 0.4683, 0.4918, 0.5636, 0.4725, 0.5230, 0.4923, 0.5015]		)
  
              assert np.abs(image_slice.flatten() - expected_slice		).max() < 1E-2
  
  
  
  
  
  
  
  @slow
  @require_torch_gpu
  class 				__SCREAMING_SNAKE_CASE   (			unittest.TestCase   ):
  
  
        def        __lowerCamelCase			(							self		):
              super().tearDown()
              gc.collect()
              torch.cuda.empty_cache()
  
  
        def        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__=0		):
              lowercase			:   Optional[int]					   =		torch.Generator(device=SCREAMING_SNAKE_CASE__		).manual_seed(SCREAMING_SNAKE_CASE__		)
              lowercase			:   Optional[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		):
              lowercase			:   str					   =		'''stabilityai/stable-diffusion-2-base'''
              lowercase			:   Optional[int]					   =		DDIMParallelScheduler.from_pretrained(SCREAMING_SNAKE_CASE__							,						subfolder='''scheduler'''		)
              lowercase			:   List[str]					   =		StableDiffusionParadigmsPipeline.from_pretrained(SCREAMING_SNAKE_CASE__							,						scheduler=SCREAMING_SNAKE_CASE__							,						safety_checker=SCREAMING_SNAKE_CASE__		)
              pipe.to(SCREAMING_SNAKE_CASE__		)
              pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__		)
              pipe.enable_attention_slicing()
  
              lowercase			:   Dict					   =		self.get_inputs()
              lowercase			:   Any					   =		pipe(**SCREAMING_SNAKE_CASE__		).images
              lowercase			:   Optional[int]					   =		image[0, -3:, -3:, -1].flatten()
  
              assert image.shape == (1, 512, 512, 3)
  
              lowercase			:   Optional[int]					   =		np.array([0.9622, 0.9602, 0.9748, 0.9591, 0.9630, 0.9691, 0.9661, 0.9631, 0.9741]		)
  
              assert np.abs(expected_slice - image_slice		).max() < 1E-2
  
  
style_context: 
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available
  
  
  __a   				=      {'''configuration_yoso''': ['''YOSO_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''YosoConfig''']}
  
  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    __a   				=      [
        '''YOSO_PRETRAINED_MODEL_ARCHIVE_LIST''',
        '''YosoForMaskedLM''',
        '''YosoForMultipleChoice''',
        '''YosoForQuestionAnswering''',
        '''YosoForSequenceClassification''',
        '''YosoForTokenClassification''',
        '''YosoLayer''',
        '''YosoModel''',
        '''YosoPreTrainedModel''',
    ]
  
  
  if TYPE_CHECKING:
    from .configuration_yoso import YOSO_PRETRAINED_CONFIG_ARCHIVE_MAP, YosoConfig
  
    try:
      if not is_torch_available():
        raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
      pass
    else:
      from .modeling_yoso import (
          YOSO_PRETRAINED_MODEL_ARCHIVE_LIST,
          YosoForMaskedLM,
          YosoForMultipleChoice,
          YosoForQuestionAnswering,
          YosoForSequenceClassification,
          YosoForTokenClassification,
          YosoLayer,
          YosoModel,
          YosoPreTrainedModel,
      )
  
  
  else:
    import sys
  
    __a   				=      _LazyModule(__name__, globals()['''__file__'''], _import_structure)
  
  