
'''simple docstring'''





import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPImageProcessor, CLIPVisionConfig, CLIPVisionModelWithProjection

from diffusers import (
    AutoencoderKL,
    DPMSolverMultistepScheduler,
    PNDMScheduler,
    StableDiffusionImageVariationPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, nightly, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()



class 			lowerCAmelCase__ (							UpperCamelCase       ,				UpperCamelCase       ,				UpperCamelCase       ,				unittest.TestCase							):



  '''simple docstring'''






  _UpperCamelCase							=			StableDiffusionImageVariationPipeline
  _UpperCamelCase							=			IMAGE_VARIATION_PARAMS
  _UpperCamelCase							=			IMAGE_VARIATION_BATCH_PARAMS
  _UpperCamelCase							=			frozenset([]							)
  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
  _UpperCamelCase							=			frozenset([]							)

  def 		_lowerCamelCase						(self	:			Tuple     ) ->							Optional[Any]:
        torch.manual_seed(0     )
        snake_case_    							=				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						,			)
        snake_case_    							=				PNDMScheduler(skip_prk_steps=_lowerCamelCase     )
        torch.manual_seed(0     )
        snake_case_    							=				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						,			)
        torch.manual_seed(0     )
        snake_case_    							=				CLIPVisionConfig(
            hidden_size=32						,			projection_dim=32						,			intermediate_size=37						,			layer_norm_eps=1E-05						,			num_attention_heads=4						,			num_hidden_layers=5						,			image_size=32						,			patch_size=4						,			)
        snake_case_    							=				CLIPVisionModelWithProjection(_lowerCamelCase     )
        snake_case_    							=				CLIPImageProcessor(crop_size=32						,			size=32     )

        snake_case_    							=				{
            "unet": unet,
            "scheduler": scheduler,
            "vae": vae,
            "image_encoder": image_encoder,
            "feature_extractor": feature_extractor,
            "safety_checker": None,
        }
        return components

  def 		_lowerCamelCase						(self	:			List[Any]						,			lowerCAmelCase_	:			Tuple						,			lowerCAmelCase_	:			List[str]=0     ) ->							Dict:
        snake_case_    							=				floats_tensor((1, 3, 32, 32)						,			rng=random.Random(_lowerCamelCase     )     )
        snake_case_    							=				image.cpu().permute(0						,			2						,			3						,			1     )[0]
        snake_case_    							=				Image.fromarray(np.uinta(_lowerCamelCase     )     ).convert("RGB"     ).resize((32, 32)     )
        if str(_lowerCamelCase     ).startswith("mps"     ):
              snake_case_    							=				torch.manual_seed(_lowerCamelCase     )
        else:
              snake_case_    							=				torch.Generator(device=_lowerCamelCase     ).manual_seed(_lowerCamelCase     )
        snake_case_    							=				{
            "image": image,
            "generator": generator,
            "num_inference_steps": 2,
            "guidance_scale": 6.0,
            "output_type": "numpy",
        }
        return inputs

  def 		_lowerCamelCase						(self	:			Dict     ) ->							Dict:
        snake_case_    							=				"cpu"  # ensure determinism for the device-dependent torch.Generator
        snake_case_    							=				self.get_dummy_components()
        snake_case_    							=				StableDiffusionImageVariationPipeline(**_lowerCamelCase     )
        snake_case_    							=				sd_pipe.to(_lowerCamelCase     )
        sd_pipe.set_progress_bar_config(disable=_lowerCamelCase     )

        snake_case_    							=				self.get_dummy_inputs(_lowerCamelCase     )
        snake_case_    							=				sd_pipe(**_lowerCamelCase     ).images
        snake_case_    							=				image[0, -3:, -3:, -1]

        assert image.shape == (1, 64, 64, 3)
        snake_case_    							=				np.array([0.5_239, 0.5_723, 0.4_796, 0.5_049, 0.5_550, 0.4_685, 0.5_329, 0.4_891, 0.4_921]     )

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

  def 		_lowerCamelCase						(self	:			Dict     ) ->							List[str]:
        snake_case_    							=				"cpu"  # ensure determinism for the device-dependent torch.Generator
        snake_case_    							=				self.get_dummy_components()
        snake_case_    							=				StableDiffusionImageVariationPipeline(**_lowerCamelCase     )
        snake_case_    							=				sd_pipe.to(_lowerCamelCase     )
        sd_pipe.set_progress_bar_config(disable=_lowerCamelCase     )

        snake_case_    							=				self.get_dummy_inputs(_lowerCamelCase     )
        snake_case_    							=				2 * [inputs["image"]]
        snake_case_    							=				sd_pipe(**_lowerCamelCase     )

        snake_case_    							=				output.images

        snake_case_    							=				image[-1, -3:, -3:, -1]

        assert image.shape == (2, 64, 64, 3)
        snake_case_    							=				np.array([0.6_892, 0.5_637, 0.5_836, 0.5_771, 0.6_254, 0.6_409, 0.5_580, 0.5_569, 0.5_289]     )

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


  def 		_lowerCamelCase						(self	:			Tuple     ) ->							Union[str, Any]:
        super().test_inference_batch_single_identical(expected_max_diff=3E-3     )



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



  '''simple docstring'''






  def 		_lowerCamelCase						(self	:			Tuple     ) ->							List[str]:
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()

  def 		_lowerCamelCase						(self	:			int						,			lowerCAmelCase_	:			Union[str, Any]						,			lowerCAmelCase_	:			Optional[Any]="cpu"						,			lowerCAmelCase_	:			Union[str, Any]=torch.floataa						,			lowerCAmelCase_	:			Tuple=0     ) ->							List[str]:
        snake_case_    							=				torch.Generator(device=_lowerCamelCase     ).manual_seed(_lowerCamelCase     )
        snake_case_    							=				load_image(
            "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"
            "/stable_diffusion_imgvar/input_image_vermeer.png"     )
        snake_case_    							=				np.random.RandomState(_lowerCamelCase     ).standard_normal((1, 4, 64, 64)     )
        snake_case_    							=				torch.from_numpy(_lowerCamelCase     ).to(device=_lowerCamelCase						,			dtype=_lowerCamelCase     )
        snake_case_    							=				{
            "image": init_image,
            "latents": latents,
            "generator": generator,
            "num_inference_steps": 3,
            "guidance_scale": 7.5,
            "output_type": "numpy",
        }
        return inputs

  def 		_lowerCamelCase						(self	:			Optional[Any]     ) ->							Union[str, Any]:
        snake_case_    							=				StableDiffusionImageVariationPipeline.from_pretrained(
            "lambdalabs/sd-image-variations-diffusers"						,			safety_checker=_lowerCamelCase     )
        snake_case_    							=				sd_pipe.to(_lowerCamelCase     )
        sd_pipe.set_progress_bar_config(disable=_lowerCamelCase     )

        snake_case_    							=				self.get_inputs(_lowerCamelCase     )
        snake_case_    							=				sd_pipe(**_lowerCamelCase     ).images
        snake_case_    							=				image[0, -3:, -3:, -1].flatten()

        assert image.shape == (1, 5_12, 5_12, 3)
        snake_case_    							=				np.array([0.84_491, 0.90_789, 0.75_708, 0.78_734, 0.83_485, 0.70_099, 0.66_938, 0.68_727, 0.61_379]     )
        assert np.abs(image_slice - expected_slice     ).max() < 6E-3

  def 		_lowerCamelCase						(self	:			str     ) ->							Dict:
        snake_case_    							=				0

        def callback_fn(lowerCAmelCase_	:			int						,			lowerCAmelCase_	:			int						,			lowerCAmelCase_	:			torch.FloatTensor     ) -> None:
              snake_case_    							=				True
              nonlocal number_of_steps
              number_of_steps += 1
              if step == 1:
                    snake_case_    							=				latents.detach().cpu().numpy()
                    assert latents.shape == (1, 4, 64, 64)
                    snake_case_    							=				latents[0, -3:, -3:, -1]
                    snake_case_    							=				np.array(
                        [-0.1_621, 0.2_837, -0.7_979, -0.1_221, -1.3_057, 0.7_681, -2.1_191, 0.0_464, 1.6_309]     )

                    assert np.abs(latents_slice.flatten() - expected_slice     ).max() < 5E-2
              elif step == 2:
                    snake_case_    							=				latents.detach().cpu().numpy()
                    assert latents.shape == (1, 4, 64, 64)
                    snake_case_    							=				latents[0, -3:, -3:, -1]
                    snake_case_    							=				np.array([0.6_299, 1.7_500, 1.1_992, -2.1_582, -1.8_994, 0.7_334, -0.7_090, 1.0_137, 1.5_273]     )

                    assert np.abs(latents_slice.flatten() - expected_slice     ).max() < 5E-2

        snake_case_    							=				False

        snake_case_    							=				StableDiffusionImageVariationPipeline.from_pretrained(
            "fusing/sd-image-variations-diffusers"						,			safety_checker=_lowerCamelCase						,			torch_dtype=torch.floataa						,			)
        pipe.to(_lowerCamelCase     )
        pipe.set_progress_bar_config(disable=_lowerCamelCase     )
        pipe.enable_attention_slicing()

        snake_case_    							=				self.get_inputs(_lowerCamelCase						,			dtype=torch.floataa     )
        pipe(**_lowerCamelCase						,			callback=_lowerCamelCase						,			callback_steps=1     )
        assert callback_fn.has_been_called
        assert number_of_steps == inputs["num_inference_steps"]


  def 		_lowerCamelCase						(self	:			str     ) ->							Optional[int]:
        torch.cuda.empty_cache()
        torch.cuda.reset_max_memory_allocated()
        torch.cuda.reset_peak_memory_stats()

        snake_case_    							=				"fusing/sd-image-variations-diffusers"
        snake_case_    							=				StableDiffusionImageVariationPipeline.from_pretrained(
            _lowerCamelCase						,			safety_checker=_lowerCamelCase						,			torch_dtype=torch.floataa     )
        snake_case_    							=				pipe.to(_lowerCamelCase     )
        pipe.set_progress_bar_config(disable=_lowerCamelCase     )
        pipe.enable_attention_slicing(1     )
        pipe.enable_sequential_cpu_offload()

        snake_case_    							=				self.get_inputs(_lowerCamelCase						,			dtype=torch.floataa     )
        snake_case_    							=				pipe(**_lowerCamelCase     )

        snake_case_    							=				torch.cuda.max_memory_allocated()
        # make sure that less than 2.6 GB is allocated
        assert mem_bytes < 2.6 * 10**9



@nightly
@require_torch_gpu
class 			lowerCAmelCase__ (							unittest.TestCase							):



  '''simple docstring'''






  def 		_lowerCamelCase						(self	:			str     ) ->							Optional[Any]:
        super().tearDown()
        gc.collect()
        torch.cuda.empty_cache()

  def 		_lowerCamelCase						(self	:			Dict						,			lowerCAmelCase_	:			List[Any]						,			lowerCAmelCase_	:			int="cpu"						,			lowerCAmelCase_	:			Union[str, Any]=torch.floataa						,			lowerCAmelCase_	:			List[Any]=0     ) ->							Dict:
        snake_case_    							=				torch.Generator(device=_lowerCamelCase     ).manual_seed(_lowerCamelCase     )
        snake_case_    							=				load_image(
            "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"
            "/stable_diffusion_imgvar/input_image_vermeer.png"     )
        snake_case_    							=				np.random.RandomState(_lowerCamelCase     ).standard_normal((1, 4, 64, 64)     )
        snake_case_    							=				torch.from_numpy(_lowerCamelCase     ).to(device=_lowerCamelCase						,			dtype=_lowerCamelCase     )
        snake_case_    							=				{
            "image": init_image,
            "latents": latents,
            "generator": generator,
            "num_inference_steps": 50,
            "guidance_scale": 7.5,
            "output_type": "numpy",
        }
        return inputs

  def 		_lowerCamelCase						(self	:			Union[str, Any]     ) ->							int:
        snake_case_    							=				StableDiffusionImageVariationPipeline.from_pretrained("fusing/sd-image-variations-diffusers"     )
        sd_pipe.to(_lowerCamelCase     )
        sd_pipe.set_progress_bar_config(disable=_lowerCamelCase     )

        snake_case_    							=				self.get_inputs(_lowerCamelCase     )
        snake_case_    							=				sd_pipe(**_lowerCamelCase     ).images[0]

        snake_case_    							=				load_numpy(
            "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"
            "/stable_diffusion_imgvar/lambdalabs_variations_pndm.npy"     )
        snake_case_    							=				np.abs(expected_image - image     ).max()
        assert max_diff < 1E-3


  def 		_lowerCamelCase						(self	:			Optional[int]     ) ->							List[str]:
        snake_case_    							=				StableDiffusionImageVariationPipeline.from_pretrained("fusing/sd-image-variations-diffusers"     )
        snake_case_    							=				DPMSolverMultistepScheduler.from_config(sd_pipe.scheduler.config     )
        sd_pipe.to(_lowerCamelCase     )
        sd_pipe.set_progress_bar_config(disable=_lowerCamelCase     )

        snake_case_    							=				self.get_inputs(_lowerCamelCase     )
        snake_case_    							=				25
        snake_case_    							=				sd_pipe(**_lowerCamelCase     ).images[0]

        snake_case_    							=				load_numpy(
            "https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"
            "/stable_diffusion_imgvar/lambdalabs_variations_dpm_multi.npy"     )
        snake_case_    							=				np.abs(expected_image - image     ).max()
        assert max_diff < 1E-3



import gc
import random
import unittest

import numpy as np
import torch
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
from diffusers.utils import floats_tensor, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()
class    _UpperCamelCase(   SCREAMING_SNAKE_CASE		,						unittest.TestCase				):
						__A:						Dict				   =      KandinskyPipeline
						__A:						List[Any]				   =      [
						    """prompt""",
						    """image_embeds""",
						    """negative_image_embeds""",
						]
						__A:						Dict				   =      ["""prompt""", """negative_prompt""", """image_embeds""", """negative_image_embeds"""]
						__A:						List[str]				   =      [
						    """generator""",
						    """height""",
						    """width""",
						    """latents""",
						    """guidance_scale""",
						    """negative_prompt""",
						    """num_inference_steps""",
						    """return_dict""",
						    """guidance_scale""",
						    """num_images_per_prompt""",
						    """output_type""",
						    """return_dict""",
						]
						__A:						List[str]				   =      False

						@property
						def 						a__ (					self		:			List[Any]			):
													return 32

						@property
						def 						a__ (					self		:			Tuple			):
													return 32

						@property
						def 						a__ (					self		:			List[Any]			):
													return self.time_input_dim

						@property
						def 						a__ (					self		:			List[Any]			):
													return self.time_input_dim * 4

						@property
						def 						a__ (					self		:			Dict			):
													return 1_00

						@property
						def 						a__ (					self		:			Tuple			):
													_UpperCAmelCase  :			Optional[int]	       =		XLMRobertaTokenizerFast.from_pretrained("YiYiXu/tiny-random-mclip-base"			)
													return tokenizer

						@property
						def 						a__ (					self		:			Tuple			):
													torch.manual_seed(0			)
													_UpperCAmelCase  :			int	       =		MCLIPConfig(
													    numDims=self.cross_attention_dim	,						transformerDimensions=self.text_embedder_hidden_size	,						hidden_size=self.text_embedder_hidden_size	,						intermediate_size=37	,						num_attention_heads=4	,						num_hidden_layers=5	,						vocab_size=10_05	,						)

													_UpperCAmelCase  :			Optional[Any]	       =		MultilingualCLIP(_lowerCamelCase			)
													_UpperCAmelCase  :			str	       =		text_encoder.eval()

													return text_encoder

						@property
						def 						a__ (					self		:			Any			):
													torch.manual_seed(0			)

													_UpperCAmelCase  :			Any	       =		{
													    "in_channels": 4,
													    # Out channels is double in channels because predicts mean and variance
													    "out_channels": 8,
													    "addition_embed_type": "text_image",
													    "down_block_types": ("ResnetDownsampleBlock2D", "SimpleCrossAttnDownBlock2D"),
													    "up_block_types": ("SimpleCrossAttnUpBlock2D", "ResnetUpsampleBlock2D"),
													    "mid_block_type": "UNetMidBlock2DSimpleCrossAttn",
													    "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
													    "layers_per_block": 1,
													    "encoder_hid_dim": self.text_embedder_hidden_size,
													    "encoder_hid_dim_type": "text_image_proj",
													    "cross_attention_dim": self.cross_attention_dim,
													    "attention_head_dim": 4,
													    "resnet_time_scale_shift": "scale_shift",
													    "class_embed_type": None,
													}

													_UpperCAmelCase  :			Optional[Any]	       =		UNetaDConditionModel(**_lowerCamelCase			)
													return model

						@property
						def 						a__ (					self		:			Optional[Any]			):
													return {
													    "block_out_channels": [32, 64],
													    "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
													    "in_channels": 3,
													    "latent_channels": 4,
													    "layers_per_block": 1,
													    "norm_num_groups": 8,
													    "norm_type": "spatial",
													    "num_vq_embeddings": 12,
													    "out_channels": 3,
													    "up_block_types": [
													        "AttnUpDecoderBlock2D",
													        "UpDecoderBlock2D",
													    ],
													    "vq_embed_dim": 4,
													}

						@property
						def 						a__ (					self		:			Tuple			):
													torch.manual_seed(0			)
													_UpperCAmelCase  :			Dict	       =		VQModel(**self.dummy_movq_kwargs			)
													return model

						def 						a__ (					self		:			List[Any]			):
													_UpperCAmelCase  :			Union[str, Any]	       =		self.dummy_text_encoder
													_UpperCAmelCase  :			Any	       =		self.dummy_tokenizer
													_UpperCAmelCase  :			List[Any]	       =		self.dummy_unet
													_UpperCAmelCase  :			Union[str, Any]	       =		self.dummy_movq

													_UpperCAmelCase  :			str	       =		DDIMScheduler(
													    num_train_timesteps=10_00	,						beta_schedule="linear"	,						beta_start=0.0_00_85	,						beta_end=0.0_12	,						clip_sample=_lowerCamelCase	,						set_alpha_to_one=_lowerCamelCase	,						steps_offset=1	,						prediction_type="epsilon"	,						thresholding=_lowerCamelCase	,						)

													_UpperCAmelCase  :			Optional[Any]	       =		{
													    "text_encoder": text_encoder,
													    "tokenizer": tokenizer,
													    "unet": unet,
													    "scheduler": scheduler,
													    "movq": movq,
													}
													return components

						def 						a__ (					self		:			int	,						_lowerCamelCase		:			Any	,						_lowerCamelCase		:			List[str]=0			):
													_UpperCAmelCase  :			Tuple	       =		floats_tensor((1, self.cross_attention_dim)	,						rng=random.Random(_lowerCamelCase			)			).to(_lowerCamelCase			)
													_UpperCAmelCase  :			Tuple	       =		floats_tensor((1, self.cross_attention_dim)	,						rng=random.Random(seed + 1			)			).to(_lowerCamelCase			)
													if str(_lowerCamelCase			).startswith("mps"			):
																				_UpperCAmelCase  :			Union[str, Any]	       =		torch.manual_seed(_lowerCamelCase			)
													else:
																				_UpperCAmelCase  :			Optional[Any]	       =		torch.Generator(device=_lowerCamelCase			).manual_seed(_lowerCamelCase			)
													_UpperCAmelCase  :			int	       =		{
													    "prompt": "horse",
													    "image_embeds": image_embeds,
													    "negative_image_embeds": negative_image_embeds,
													    "generator": generator,
													    "height": 64,
													    "width": 64,
													    "guidance_scale": 4.0,
													    "num_inference_steps": 2,
													    "output_type": "np",
													}
													return inputs






						def 						a__ (					self		:			List[Any]			):
													_UpperCAmelCase  :			Optional[Any]	       =		"cpu"

													_UpperCAmelCase  :			Dict	       =		self.get_dummy_components()

													_UpperCAmelCase  :			Any	       =		self.pipeline_class(**_lowerCamelCase			)
													_UpperCAmelCase  :			Optional[int]	       =		pipe.to(_lowerCamelCase			)

													pipe.set_progress_bar_config(disable=_lowerCamelCase			)

													_UpperCAmelCase  :			Dict	       =		pipe(**self.get_dummy_inputs(_lowerCamelCase			)			)
													_UpperCAmelCase  :			int	       =		output.images

													_UpperCAmelCase  :			Tuple	       =		pipe(
													    **self.get_dummy_inputs(_lowerCamelCase			)	,						return_dict=_lowerCamelCase	,						)[0]

													_UpperCAmelCase  :			Any	       =		image[0, -3:, -3:, -1]
													_UpperCAmelCase  :			Optional[Any]	       =		image_from_tuple[0, -3:, -3:, -1]

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

													_UpperCAmelCase  :			Dict	       =		np.array(
													    [0.32_86_63, 1.0, 0.23_21_68_73, 1.0, 0.92_71_75_64, 0.4_63_90_46, 0.96_89_47_77, 0.31_71_33_78, 0.6_29_39_53]			)

													assert (
													    np.abs(image_slice.flatten() - expected_slice			).max() < 1E-2
													), f""" expected_slice {expected_slice}, but got {image_slice.flatten()}"""
													assert (
													    np.abs(image_from_tuple_slice.flatten() - expected_slice			).max() < 1E-2
													), f""" expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}"""







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

						def 						a__ (					self		:			int			):
													# clean up the VRAM after each test
													super().tearDown()
													gc.collect()
													torch.cuda.empty_cache()






						def 						a__ (					self		:			str			):
													_UpperCAmelCase  :			List[str]	       =		load_numpy(
													    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
													    "/kandinsky/kandinsky_text2img_cat_fp16.npy"			)

													_UpperCAmelCase  :			Dict	       =		KandinskyPriorPipeline.from_pretrained(
													    "kandinsky-community/kandinsky-2-1-prior"	,						torch_dtype=torch.floataa			)
													pipe_prior.to(_lowerCamelCase			)

													_UpperCAmelCase  :			str	       =		KandinskyPipeline.from_pretrained("kandinsky-community/kandinsky-2-1"	,						torch_dtype=torch.floataa			)
													_UpperCAmelCase  :			Union[str, Any]	       =		pipeline.to(_lowerCamelCase			)
													pipeline.set_progress_bar_config(disable=_lowerCamelCase			)

													_UpperCAmelCase  :			Tuple	       =		"red cat, 4k photo"

													_UpperCAmelCase  :			List[Any]	       =		torch.Generator(device="cuda"			).manual_seed(0			)
													_UpperCAmelCase       ,_UpperCAmelCase  :			int	       =		pipe_prior(
													    _lowerCamelCase	,						generator=_lowerCamelCase	,						num_inference_steps=5	,						negative_prompt=""	,						).to_tuple()

													_UpperCAmelCase  :			Tuple	       =		torch.Generator(device="cuda"			).manual_seed(0			)
													_UpperCAmelCase  :			Dict	       =		pipeline(
													    _lowerCamelCase	,						image_embeds=_lowerCamelCase	,						negative_image_embeds=_lowerCamelCase	,						generator=_lowerCamelCase	,						num_inference_steps=1_00	,						output_type="np"	,						)

													_UpperCAmelCase  :			Tuple	       =		output.images[0]

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

													assert_mean_pixel_difference(_lowerCamelCase	,						_lowerCamelCase			)




