






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      __SCREAMING_SNAKE_CASE       ( __UpperCAmelCase		,       __UpperCAmelCase		,       __UpperCAmelCase		,       unittest.TestCase):
						_SCREAMING_SNAKE_CASE						:							Tuple				=       StableDiffusionImageVariationPipeline
						_SCREAMING_SNAKE_CASE						:							str				=       IMAGE_VARIATION_PARAMS
						_SCREAMING_SNAKE_CASE						:							Optional[int]				=       IMAGE_VARIATION_BATCH_PARAMS
						_SCREAMING_SNAKE_CASE						:							Union[str, Any]				=       frozenset([])
						# TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
						_SCREAMING_SNAKE_CASE						:							Dict				=       frozenset([])






						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												torch.manual_seed(0 )
												lowerCAmelCase__         =    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  ,    )
												lowerCAmelCase__         =    PNDMScheduler(skip_prk_steps=UpperCAmelCase_ )
												torch.manual_seed(0 )
												lowerCAmelCase__         =    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 )
												lowerCAmelCase__         =    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  ,    )
												lowerCAmelCase__         =    CLIPVisionModelWithProjection(UpperCAmelCase_ )
												lowerCAmelCase__         =    CLIPImageProcessor(crop_size=32  ,    size=32 )

												lowerCAmelCase__         =    {
												    'unet': unet,
												    'scheduler': scheduler,
												    'vae': vae,
												    'image_encoder': image_encoder,
												    'feature_extractor': feature_extractor,
												    'safety_checker': None,
												}
												return components






						def    UpperCamelCase__   (						self  ,    _UpperCamelCase  ,    _UpperCamelCase=0 ):






												"""simple docstring"""
												lowerCAmelCase__         =    floats_tensor((1, 3, 32, 32)  ,    rng=random.Random(UpperCAmelCase_ ) )
												lowerCAmelCase__         =    image.cpu().permute(0  ,    2  ,    3  ,    1 )[0]
												lowerCAmelCase__         =    Image.fromarray(np.uinta(UpperCAmelCase_ ) ).convert('RGB' ).resize((32, 32) )
												if str(UpperCAmelCase_ ).startswith('mps' ):
																		lowerCAmelCase__         =    torch.manual_seed(UpperCAmelCase_ )
												else:
																		lowerCAmelCase__         =    torch.Generator(device=UpperCAmelCase_ ).manual_seed(UpperCAmelCase_ )
												lowerCAmelCase__         =    {
												    'image': image,
												    'generator': generator,
												    'num_inference_steps': 2,
												    'guidance_scale': 6.0,
												    'output_type': 'numpy',
												}
												return inputs






						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												lowerCAmelCase__         =    'cpu'  # ensure determinism for the device-dependent torch.Generator
												lowerCAmelCase__         =    self.get_dummy_components()
												lowerCAmelCase__         =    StableDiffusionImageVariationPipeline(**UpperCAmelCase_ )
												lowerCAmelCase__         =    sd_pipe.to(UpperCAmelCase_ )
												sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_ )

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

												assert image.shape == (1, 64, 64, 3)
												lowerCAmelCase__         =    np.array([0.52_39, 0.57_23, 0.47_96, 0.50_49, 0.55_50, 0.46_85, 0.53_29, 0.48_91, 0.49_21] )

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






						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												lowerCAmelCase__         =    'cpu'  # ensure determinism for the device-dependent torch.Generator
												lowerCAmelCase__         =    self.get_dummy_components()
												lowerCAmelCase__         =    StableDiffusionImageVariationPipeline(**UpperCAmelCase_ )
												lowerCAmelCase__         =    sd_pipe.to(UpperCAmelCase_ )
												sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_ )

												lowerCAmelCase__         =    self.get_dummy_inputs(UpperCAmelCase_ )
												lowerCAmelCase__         =    2 * [inputs['image']]
												lowerCAmelCase__         =    sd_pipe(**UpperCAmelCase_ )

												lowerCAmelCase__         =    output.images

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

												assert image.shape == (2, 64, 64, 3)
												lowerCAmelCase__         =    np.array([0.68_92, 0.56_37, 0.58_36, 0.57_71, 0.62_54, 0.64_09, 0.55_80, 0.55_69, 0.52_89] )

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







						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												super().test_inference_batch_single_identical(expected_max_diff=3E-3 )




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






						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												super().tearDown()
												gc.collect()
												torch.cuda.empty_cache()






						def    UpperCamelCase__   (						self  ,    _UpperCamelCase  ,    _UpperCamelCase="cpu"  ,    _UpperCamelCase=torch.floataa  ,    _UpperCamelCase=0 ):






												"""simple docstring"""
												lowerCAmelCase__         =    torch.Generator(device=UpperCAmelCase_ ).manual_seed(UpperCAmelCase_ )
												lowerCAmelCase__         =    load_image(
												    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
												    '/stable_diffusion_imgvar/input_image_vermeer.png' )
												lowerCAmelCase__         =    np.random.RandomState(UpperCAmelCase_ ).standard_normal((1, 4, 64, 64) )
												lowerCAmelCase__         =    torch.from_numpy(UpperCAmelCase_ ).to(device=UpperCAmelCase_  ,    dtype=UpperCAmelCase_ )
												lowerCAmelCase__         =    {
												    'image': init_image,
												    'latents': latents,
												    'generator': generator,
												    'num_inference_steps': 3,
												    'guidance_scale': 7.5,
												    'output_type': 'numpy',
												}
												return inputs






						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												lowerCAmelCase__         =    StableDiffusionImageVariationPipeline.from_pretrained(
												    'lambdalabs/sd-image-variations-diffusers'  ,    safety_checker=UpperCAmelCase_ )
												lowerCAmelCase__         =    sd_pipe.to(UpperCAmelCase_ )
												sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_ )

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

												assert image.shape == (1, 5_12, 5_12, 3)
												lowerCAmelCase__         =    np.array([0.8_44_91, 0.9_07_89, 0.7_57_08, 0.7_87_34, 0.8_34_85, 0.7_00_99, 0.6_69_38, 0.6_87_27, 0.6_13_79] )
												assert np.abs(image_slice - expected_slice ).max() < 6E-3






						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												lowerCAmelCase__         =    0

												def callback_fn(_UpperCamelCase  ,    _UpperCamelCase  ,    _UpperCamelCase ) -> None:
																		lowerCAmelCase__         =    True
																		nonlocal number_of_steps
																		number_of_steps += 1
																		if step == 1:
																								lowerCAmelCase__         =    latents.detach().cpu().numpy()
																								assert latents.shape == (1, 4, 64, 64)
																								lowerCAmelCase__         =    latents[0, -3:, -3:, -1]
																								lowerCAmelCase__         =    np.array(
																								    [-0.16_21, 0.28_37, -0.79_79, -0.12_21, -1.30_57, 0.76_81, -2.11_91, 0.04_64, 1.63_09] )

																								assert np.abs(latents_slice.flatten() - expected_slice ).max() < 5E-2
																		elif step == 2:
																								lowerCAmelCase__         =    latents.detach().cpu().numpy()
																								assert latents.shape == (1, 4, 64, 64)
																								lowerCAmelCase__         =    latents[0, -3:, -3:, -1]
																								lowerCAmelCase__         =    np.array([0.62_99, 1.75_00, 1.19_92, -2.15_82, -1.89_94, 0.73_34, -0.70_90, 1.01_37, 1.52_73] )

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

												lowerCAmelCase__         =    False

												lowerCAmelCase__         =    StableDiffusionImageVariationPipeline.from_pretrained(
												    'fusing/sd-image-variations-diffusers'  ,    safety_checker=UpperCAmelCase_  ,    torch_dtype=torch.floataa  ,    )
												pipe.to(UpperCAmelCase_ )
												pipe.set_progress_bar_config(disable=UpperCAmelCase_ )
												pipe.enable_attention_slicing()

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







						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												torch.cuda.empty_cache()
												torch.cuda.reset_max_memory_allocated()
												torch.cuda.reset_peak_memory_stats()

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

												lowerCAmelCase__         =    self.get_inputs(UpperCAmelCase_  ,    dtype=torch.floataa )
												lowerCAmelCase__         =    pipe(**UpperCAmelCase_ )

												lowerCAmelCase__         =    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      __SCREAMING_SNAKE_CASE       ( unittest.TestCase):






						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												super().tearDown()
												gc.collect()
												torch.cuda.empty_cache()






						def    UpperCamelCase__   (						self  ,    _UpperCamelCase  ,    _UpperCamelCase="cpu"  ,    _UpperCamelCase=torch.floataa  ,    _UpperCamelCase=0 ):






												"""simple docstring"""
												lowerCAmelCase__         =    torch.Generator(device=UpperCAmelCase_ ).manual_seed(UpperCAmelCase_ )
												lowerCAmelCase__         =    load_image(
												    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
												    '/stable_diffusion_imgvar/input_image_vermeer.png' )
												lowerCAmelCase__         =    np.random.RandomState(UpperCAmelCase_ ).standard_normal((1, 4, 64, 64) )
												lowerCAmelCase__         =    torch.from_numpy(UpperCAmelCase_ ).to(device=UpperCAmelCase_  ,    dtype=UpperCAmelCase_ )
												lowerCAmelCase__         =    {
												    'image': init_image,
												    'latents': latents,
												    'generator': generator,
												    'num_inference_steps': 50,
												    'guidance_scale': 7.5,
												    'output_type': 'numpy',
												}
												return inputs






						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												lowerCAmelCase__         =    StableDiffusionImageVariationPipeline.from_pretrained('fusing/sd-image-variations-diffusers' )
												sd_pipe.to(UpperCAmelCase_ )
												sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_ )

												lowerCAmelCase__         =    self.get_inputs(UpperCAmelCase_ )
												lowerCAmelCase__         =    sd_pipe(**UpperCAmelCase_ ).images[0]

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







						def    UpperCamelCase__   (						self ):






												"""simple docstring"""
												lowerCAmelCase__         =    StableDiffusionImageVariationPipeline.from_pretrained('fusing/sd-image-variations-diffusers' )
												lowerCAmelCase__         =    DPMSolverMultistepScheduler.from_config(sd_pipe.scheduler.config )
												sd_pipe.to(UpperCAmelCase_ )
												sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_ )

												lowerCAmelCase__         =    self.get_inputs(UpperCAmelCase_ )
												lowerCAmelCase__         =    25
												lowerCAmelCase__         =    sd_pipe(**UpperCAmelCase_ ).images[0]

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







"""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 			_lowercase  (							__UpperCAmelCase							,			__UpperCAmelCase							,			__UpperCAmelCase							,			unittest.TestCase						):
	lowercase_								=      StableDiffusionImageVariationPipeline
	lowercase_								=      IMAGE_VARIATION_PARAMS
	lowercase_								=      IMAGE_VARIATION_BATCH_PARAMS
	lowercase_								=      frozenset([]						)
	# TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
	lowercase_								=      frozenset([]						)




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

			lowerCamelCase	:     Any            =       {
			    'unet': unet,
			    'scheduler': scheduler,
			    'vae': vae,
			    'image_encoder': image_encoder,
			    'feature_extractor': feature_extractor,
			    'safety_checker': None,
			}
			return components




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




	def      _UpperCamelCase       (					self   )						->				str:
			lowerCamelCase	:     Tuple            =       'cpu'  # ensure determinism for the device-dependent torch.Generator
			lowerCamelCase	:     List[str]            =       self.get_dummy_components()
			lowerCamelCase	:     Tuple            =       StableDiffusionImageVariationPipeline(**UpperCAmelCase_   )
			lowerCamelCase	:     Optional[Any]            =       sd_pipe.to(UpperCAmelCase_   )
			sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_   )

			lowerCamelCase	:     List[Any]            =       self.get_dummy_inputs(UpperCAmelCase_   )
			lowerCamelCase	:     Any            =       sd_pipe(**UpperCAmelCase_   ).images
			lowerCamelCase	:     Dict            =       image[0, -3:, -3:, -1]

			assert image.shape == (1, 64, 64, 3)
			lowerCamelCase	:     str            =       np.array([0.5239, 0.5723, 0.4796, 0.5049, 0.5550, 0.4685, 0.5329, 0.4891, 0.4921]   )

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




	def      _UpperCamelCase       (					self   )						->				Any:
			lowerCamelCase	:     List[Any]            =       'cpu'  # ensure determinism for the device-dependent torch.Generator
			lowerCamelCase	:     List[str]            =       self.get_dummy_components()
			lowerCamelCase	:     Union[str, Any]            =       StableDiffusionImageVariationPipeline(**UpperCAmelCase_   )
			lowerCamelCase	:     Any            =       sd_pipe.to(UpperCAmelCase_   )
			sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_   )

			lowerCamelCase	:     Any            =       self.get_dummy_inputs(UpperCAmelCase_   )
			lowerCamelCase	:     Any            =       2 * [inputs['image']]
			lowerCamelCase	:     Dict            =       sd_pipe(**UpperCAmelCase_   )

			lowerCamelCase	:     List[str]            =       output.images

			lowerCamelCase	:     Dict            =       image[-1, -3:, -3:, -1]

			assert image.shape == (2, 64, 64, 3)
			lowerCamelCase	:     Dict            =       np.array([0.6892, 0.5637, 0.5836, 0.5771, 0.6254, 0.6409, 0.5580, 0.5569, 0.5289]   )

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




	def      _UpperCamelCase       (					self   )						->				List[str]:
			super().test_inference_batch_single_identical(expected_max_diff=3E-3   )






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




	def      _UpperCamelCase       (					self   )						->				Dict:
			super().tearDown()
			gc.collect()
			torch.cuda.empty_cache()




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




	def      _UpperCamelCase       (					self   )						->				Optional[int]:
			lowerCamelCase	:     List[Any]            =       StableDiffusionImageVariationPipeline.from_pretrained(
			    'lambdalabs/sd-image-variations-diffusers'						,					safety_checker=UpperCAmelCase_   )
			lowerCamelCase	:     Dict            =       sd_pipe.to(UpperCAmelCase_   )
			sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_   )

			lowerCamelCase	:     Optional[int]            =       self.get_inputs(UpperCAmelCase_   )
			lowerCamelCase	:     Any            =       sd_pipe(**UpperCAmelCase_   ).images
			lowerCamelCase	:     Union[str, Any]            =       image[0, -3:, -3:, -1].flatten()

			assert image.shape == (1, 512, 512, 3)
			lowerCamelCase	:     List[str]            =       np.array([0.84491, 0.90789, 0.75708, 0.78734, 0.83485, 0.70099, 0.66938, 0.68727, 0.61379]   )
			assert np.abs(image_slice - expected_slice   ).max() < 6E-3




	def      _UpperCamelCase       (					self   )						->				List[Any]:
			lowerCamelCase	:     Optional[Any]            =       0

			def callback_fn(UpperCAmelCase_						,					UpperCAmelCase_						,					UpperCAmelCase_   ) -> None:
					lowerCamelCase	:     int            =       True
					nonlocal number_of_steps
					number_of_steps += 1
					if step == 1:
							lowerCamelCase	:     List[Any]            =       latents.detach().cpu().numpy()
							assert latents.shape == (1, 4, 64, 64)
							lowerCamelCase	:     Dict            =       latents[0, -3:, -3:, -1]
							lowerCamelCase	:     List[Any]            =       np.array(
							    [-0.1621, 0.2837, -0.7979, -0.1221, -1.3057, 0.7681, -2.1191, 0.0464, 1.6309]   )

							assert np.abs(latents_slice.flatten() - expected_slice   ).max() < 5E-2
					elif step == 2:
							lowerCamelCase	:     Union[str, Any]            =       latents.detach().cpu().numpy()
							assert latents.shape == (1, 4, 64, 64)
							lowerCamelCase	:     Optional[int]            =       latents[0, -3:, -3:, -1]
							lowerCamelCase	:     Optional[Any]            =       np.array([0.6299, 1.7500, 1.1992, -2.1582, -1.8994, 0.7334, -0.7090, 1.0137, 1.5273]   )

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

			lowerCamelCase	:     List[str]            =       False

			lowerCamelCase	:     str            =       StableDiffusionImageVariationPipeline.from_pretrained(
			    'fusing/sd-image-variations-diffusers'						,					safety_checker=UpperCAmelCase_						,					torch_dtype=torch.floataa						,					)
			pipe.to(UpperCAmelCase_   )
			pipe.set_progress_bar_config(disable=UpperCAmelCase_   )
			pipe.enable_attention_slicing()

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




	def      _UpperCamelCase       (					self   )						->				str:
			torch.cuda.empty_cache()
			torch.cuda.reset_max_memory_allocated()
			torch.cuda.reset_peak_memory_stats()

			lowerCamelCase	:     Any            =       'fusing/sd-image-variations-diffusers'
			lowerCamelCase	:     Optional[int]            =       StableDiffusionImageVariationPipeline.from_pretrained(
			    UpperCAmelCase_						,					safety_checker=UpperCAmelCase_						,					torch_dtype=torch.floataa   )
			lowerCamelCase	:     Any            =       pipe.to(UpperCAmelCase_   )
			pipe.set_progress_bar_config(disable=UpperCAmelCase_   )
			pipe.enable_attention_slicing(1   )
			pipe.enable_sequential_cpu_offload()

			lowerCamelCase	:     Optional[int]            =       self.get_inputs(UpperCAmelCase_						,					dtype=torch.floataa   )
			lowerCamelCase	:     int            =       pipe(**UpperCAmelCase_   )

			lowerCamelCase	:     List[Any]            =       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 			_lowercase  (							unittest.TestCase						):




	def      _UpperCamelCase       (					self   )						->				Dict:
			super().tearDown()
			gc.collect()
			torch.cuda.empty_cache()




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




	def      _UpperCamelCase       (					self   )						->				Any:
			lowerCamelCase	:     int            =       StableDiffusionImageVariationPipeline.from_pretrained('fusing/sd-image-variations-diffusers'   )
			sd_pipe.to(UpperCAmelCase_   )
			sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_   )

			lowerCamelCase	:     int            =       self.get_inputs(UpperCAmelCase_   )
			lowerCamelCase	:     int            =       sd_pipe(**UpperCAmelCase_   ).images[0]

			lowerCamelCase	:     List[Any]            =       load_numpy(
			    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
			    '/stable_diffusion_imgvar/lambdalabs_variations_pndm.npy'   )
			lowerCamelCase	:     str            =       np.abs(expected_image - image   ).max()
			assert max_diff < 1E-3




	def      _UpperCamelCase       (					self   )						->				List[str]:
			lowerCamelCase	:     List[Any]            =       StableDiffusionImageVariationPipeline.from_pretrained('fusing/sd-image-variations-diffusers'   )
			lowerCamelCase	:     Optional[int]            =       DPMSolverMultistepScheduler.from_config(sd_pipe.scheduler.config   )
			sd_pipe.to(UpperCAmelCase_   )
			sd_pipe.set_progress_bar_config(disable=UpperCAmelCase_   )

			lowerCamelCase	:     Union[str, Any]            =       self.get_inputs(UpperCAmelCase_   )
			lowerCamelCase	:     Optional[Any]            =       25
			lowerCamelCase	:     List[str]            =       sd_pipe(**UpperCAmelCase_   ).images[0]

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






