




import inspect
from typing import Callable, List, Optional, Union

import torch
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer

from diffusers import DiffusionPipeline
from diffusers.models import AutoencoderKL, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
from diffusers.schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler
from diffusers.utils import logging


__UpperCamelCase					:		Union[str, Any]	  =						logging.get_logger(__name__)  # pylint: disable=invalid-name


class   __SCREAMING_SNAKE_CASE(	a_	):
							def __init__(     self:      Tuple       ,	UpperCamelCase:      AutoencoderKL       ,	UpperCamelCase:      CLIPTextModel       ,	UpperCamelCase:      CLIPTokenizer       ,	UpperCamelCase:      UNetaDConditionModel       ,	UpperCamelCase:      Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler]       ,	UpperCamelCase:      StableDiffusionSafetyChecker       ,	UpperCamelCase:      CLIPImageProcessor       ,	)		->		List[Any]:
											super().__init__()
											self.register_modules(
											    vae=UpperCamelCase       ,	text_encoder=UpperCamelCase       ,	tokenizer=UpperCamelCase       ,	unet=UpperCamelCase       ,	scheduler=UpperCamelCase       ,	safety_checker=UpperCamelCase       ,	feature_extractor=UpperCamelCase       ,	)
							def lowerCAmelCase_ (     self:      str       ,	UpperCamelCase:      Optional[Union[str, int]] = "auto"						)		->		Union[str, Any]:
											if slice_size == "auto":
															# half the attention head size is usually a good trade-off between
															# speed and memory
															snake_case__									=     self.unet.config.attention_head_dim // 2
											self.unet.set_attention_slice(UpperCamelCase						)
							def lowerCAmelCase_ (     self:      str						)		->		Any:
											self.enable_attention_slicing(UpperCamelCase						)


							@torch.no_grad()
							def __call__(     self:      List[str]       ,	UpperCamelCase:      Union[str, List[str]]       ,	UpperCamelCase:      int = 5_12       ,	UpperCamelCase:      int = 5_12       ,	UpperCamelCase:      int = 50       ,	UpperCamelCase:      float = 7.5       ,	UpperCamelCase:      Optional[Union[str, List[str]]] = None       ,	UpperCamelCase:      Optional[int] = 1       ,	UpperCamelCase:      float = 0.0       ,	UpperCamelCase:      Optional[torch.Generator] = None       ,	UpperCamelCase:      Optional[torch.FloatTensor] = None       ,	UpperCamelCase:      Optional[str] = "pil"       ,	UpperCamelCase:      bool = True       ,	UpperCamelCase:      Optional[Callable[[int, int, torch.FloatTensor], None]] = None       ,	UpperCamelCase:      int = 1       ,	UpperCamelCase:      Optional[torch.FloatTensor] = None       ,	**UpperCamelCase:      int       ,	)		->		Tuple:

											if isinstance(UpperCamelCase       ,	UpperCamelCase						):
															snake_case__									=     1
											elif isinstance(UpperCamelCase       ,	UpperCamelCase						):
															snake_case__									=     len(UpperCamelCase						)
											else:
															raise ValueError(F'''`prompt` has to be of type `str` or `list` but is {type(UpperCamelCase						)}'''						)

											if height % 8 != 0 or width % 8 != 0:
															raise ValueError(F'''`height` and `width` have to be divisible by 8 but are {height} and {width}.'''						)

											if (callback_steps is None) or (
											    callback_steps is not None and (not isinstance(UpperCamelCase       ,	UpperCamelCase						) or callback_steps <= 0)
											):
															raise ValueError(
															    F'''`callback_steps` has to be a positive integer but is {callback_steps} of type'''
															    F''' {type(UpperCamelCase						)}.'''						)

											# get prompt text embeddings
											snake_case__									=     self.tokenizer(
											    UpperCamelCase       ,	padding='max_length'       ,	max_length=self.tokenizer.model_max_length       ,	return_tensors='pt'       ,	)
											snake_case__									=     text_inputs.input_ids

											if text_input_ids.shape[-1] > self.tokenizer.model_max_length:
															snake_case__									=     self.tokenizer.batch_decode(text_input_ids[:, self.tokenizer.model_max_length :]						)
															logger.warning(
															    'The following part of your input was truncated because CLIP can only handle sequences up to'
															    F''' {self.tokenizer.model_max_length} tokens: {removed_text}'''						)
															snake_case__									=     text_input_ids[:, : self.tokenizer.model_max_length]

											if text_embeddings is None:
															snake_case__									=     self.text_encoder(text_input_ids.to(self.device						)						)[0]

											# duplicate text embeddings for each generation per prompt, using mps friendly method
											snake_case__							,						snake_case__							,						snake_case__									=     text_embeddings.shape
											snake_case__									=     text_embeddings.repeat(1       ,	UpperCamelCase       ,	1						)
											snake_case__									=     text_embeddings.view(bs_embed * num_images_per_prompt       ,	UpperCamelCase       ,	-1						)

											# here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
											# of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
											# corresponds to doing no classifier free guidance.
											snake_case__									=     guidance_scale > 1.0
											# get unconditional embeddings for classifier free guidance
											if do_classifier_free_guidance:
															snake_case__									=     42
															if negative_prompt is None:
																			snake_case__									=     ['']
															elif type(UpperCamelCase						) is not type(UpperCamelCase						):
																			raise TypeError(
																			    F'''`negative_prompt` should be the same type to `prompt`, but got {type(UpperCamelCase						)} !='''
																			    F''' {type(UpperCamelCase						)}.'''						)
															elif isinstance(UpperCamelCase       ,	UpperCamelCase						):
																			snake_case__									=     [negative_prompt]
															elif batch_size != len(UpperCamelCase						):
																			raise ValueError(
																			    F'''`negative_prompt`: {negative_prompt} has batch size {len(UpperCamelCase						)}, but `prompt`:'''
																			    F''' {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches'''
																			    ' the batch size of `prompt`.'						)
															else:
																			snake_case__									=     negative_prompt

															snake_case__									=     text_input_ids.shape[-1]
															snake_case__									=     self.tokenizer(
															    UpperCamelCase       ,	padding='max_length'       ,	max_length=UpperCamelCase       ,	truncation=UpperCamelCase       ,	return_tensors='pt'       ,	)
															snake_case__									=     self.text_encoder(uncond_input.input_ids.to(self.device						)						)[0]

															# duplicate unconditional embeddings for each generation per prompt, using mps friendly method
															snake_case__									=     uncond_embeddings.shape[1]
															snake_case__									=     uncond_embeddings.repeat(UpperCamelCase       ,	UpperCamelCase       ,	1						)
															snake_case__									=     uncond_embeddings.view(batch_size * num_images_per_prompt       ,	UpperCamelCase       ,	-1						)

															# For classifier free guidance, we need to do two forward passes.
															# Here we concatenate the unconditional and text embeddings into a single batch
															# to avoid doing two forward passes
															snake_case__									=     torch.cat([uncond_embeddings, text_embeddings]						)

											# get the initial random noise unless the user supplied it

											# Unlike in other pipelines, latents need to be generated in the target device
											# for 1-to-1 results reproducibility with the CompVis implementation.
											# However this currently doesn't work in `mps`.
											snake_case__									=     (batch_size * num_images_per_prompt, self.unet.config.in_channels, height // 8, width // 8)
											snake_case__									=     (batch_size * num_images_per_prompt, self.unet.config.in_channels, 64, 64)
											snake_case__									=     text_embeddings.dtype
											if latents is None:
															if self.device.type == "mps":
																			# randn does not exist on mps
																			snake_case__									=     torch.randn(
																			    UpperCamelCase       ,	generator=UpperCamelCase       ,	device='cpu'       ,	dtype=UpperCamelCase						).to(self.device						)
																			snake_case__									=     torch.randn(UpperCamelCase       ,	generator=UpperCamelCase       ,	device='cpu'       ,	dtype=UpperCamelCase						).to(
																			    self.device						)
															else:
																			snake_case__									=     torch.randn(
																			    UpperCamelCase       ,	generator=UpperCamelCase       ,	device=self.device       ,	dtype=UpperCamelCase						)
																			snake_case__									=     torch.randn(UpperCamelCase       ,	generator=UpperCamelCase       ,	device=self.device       ,	dtype=UpperCamelCase						)
											else:
															if latents_reference.shape != latents_shape:
																			raise ValueError(F'''Unexpected latents shape, got {latents.shape}, expected {latents_shape}'''						)
															snake_case__									=     latents_reference.to(self.device						)
															snake_case__									=     latents.to(self.device						)

											# This is the key part of the pipeline where we
											# try to ensure that the generated images w/ the same seed
											# but different sizes actually result in similar images
											snake_case__									=     (latents_shape[3] - latents_shape_reference[3]) // 2
											snake_case__									=     (latents_shape[2] - latents_shape_reference[2]) // 2
											snake_case__									=     latents_shape_reference[3] if dx >= 0 else latents_shape_reference[3] + 2 * dx
											snake_case__									=     latents_shape_reference[2] if dy >= 0 else latents_shape_reference[2] + 2 * dy
											snake_case__									=     0 if dx < 0 else dx
											snake_case__									=     0 if dy < 0 else dy
											snake_case__									=     max(-dx       ,	0						)
											snake_case__									=     max(-dy       ,	0						)
											# import pdb
											# pdb.set_trace()
											snake_case__									=     latents_reference[:, :, dy : dy + h, dx : dx + w]

											# set timesteps
											self.scheduler.set_timesteps(UpperCamelCase						)

											# Some schedulers like PNDM have timesteps as arrays
											# It's more optimized to move all timesteps to correct device beforehand
											snake_case__									=     self.scheduler.timesteps.to(self.device						)

											# scale the initial noise by the standard deviation required by the scheduler
											snake_case__									=     latents * self.scheduler.init_noise_sigma

											# prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
											# eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
											# eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
											# and should be between [0, 1]
											snake_case__									=     'eta' in set(inspect.signature(self.scheduler.step						).parameters.keys()						)
											snake_case__									=     {}
											if accepts_eta:
															snake_case__									=     eta

											for i, t in enumerate(self.progress_bar(UpperCamelCase						)						):
															# expand the latents if we are doing classifier free guidance
															snake_case__									=     torch.cat([latents] * 2						) if do_classifier_free_guidance else latents
															snake_case__									=     self.scheduler.scale_model_input(UpperCamelCase       ,	UpperCamelCase						)

															# predict the noise residual
															snake_case__									=     self.unet(UpperCamelCase       ,	UpperCamelCase       ,	encoder_hidden_states=UpperCamelCase						).sample

															# perform guidance
															if do_classifier_free_guidance:
																			snake_case__							,						snake_case__									=     noise_pred.chunk(2						)
																			snake_case__									=     noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

															# compute the previous noisy sample x_t -> x_t-1
															snake_case__									=     self.scheduler.step(UpperCamelCase       ,	UpperCamelCase       ,	UpperCamelCase       ,	**UpperCamelCase						).prev_sample

															# call the callback, if provided
															if callback is not None and i % callback_steps == 0:
																			callback(UpperCamelCase       ,	UpperCamelCase       ,	UpperCamelCase						)

											snake_case__									=     1 / 0.18_215 * latents
											snake_case__									=     self.vae.decode(UpperCamelCase						).sample

											snake_case__									=     (image / 2 + 0.5).clamp(0       ,	1						)

											# we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
											snake_case__									=     image.cpu().permute(0       ,	2       ,	3       ,	1						).float().numpy()

											if self.safety_checker is not None:
															snake_case__									=     self.feature_extractor(self.numpy_to_pil(UpperCamelCase						)       ,	return_tensors='pt'						).to(
															    self.device						)
															snake_case__							,						snake_case__									=     self.safety_checker(
															    images=UpperCamelCase       ,	clip_input=safety_checker_input.pixel_values.to(text_embeddings.dtype						)						)
											else:
															snake_case__									=     None

											if output_type == "pil":
															snake_case__									=     self.numpy_to_pil(UpperCamelCase						)

											if not return_dict:
															return (image, has_nsfw_concept)

											return StableDiffusionPipelineOutput(images=UpperCamelCase       ,	nsfw_content_detected=UpperCamelCase						)












import gc
import random
import unittest

import numpy as np
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModel,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import AutoencoderKL, DDIMScheduler, DDPMScheduler, StableUnCLIPImgaImgPipeline, UNetaDConditionModel
from diffusers.pipelines.pipeline_utils import DiffusionPipeline
from diffusers.pipelines.stable_diffusion.stable_unclip_image_normalizer import StableUnCLIPImageNormalizer
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    floats_tensor,
    load_image,
    load_numpy,
    require_torch_gpu,
    skip_mps,
    slow,
    torch_device,
)

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
    assert_mean_pixel_difference,
)


enable_full_determinism()


class   __SCREAMING_SNAKE_CASE(	a_    ,  a_    ,  a_    ,  unittest.TestCase	):
							_UpperCAmelCase     =       StableUnCLIPImgaImgPipeline
							_UpperCAmelCase     =       TEXT_GUIDED_IMAGE_VARIATION_PARAMS
							_UpperCAmelCase     =       TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
							_UpperCAmelCase     =       frozenset(
							    []	)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
							_UpperCAmelCase     =       frozenset([]	)
							def lowerCAmelCase_ (     self:      List[Any]						)		->		Union[str, Any]:
											snake_case__									=     32
											snake_case__									=     embedder_hidden_size

											# image encoding components

											snake_case__									=     CLIPImageProcessor(crop_size=32       ,	size=32						)

											torch.manual_seed(0						)
											snake_case__									=     CLIPVisionModelWithProjection(
											    CLIPVisionConfig(
											        hidden_size=UpperCamelCase       ,	projection_dim=UpperCamelCase       ,	num_hidden_layers=5       ,	num_attention_heads=4       ,	image_size=32       ,	intermediate_size=37       ,	patch_size=1       ,	)						)

											# regular denoising components

											torch.manual_seed(0						)
											snake_case__									=     StableUnCLIPImageNormalizer(embedding_dim=UpperCamelCase						)
											snake_case__									=     DDPMScheduler(beta_schedule='squaredcos_cap_v2'						)

											torch.manual_seed(0						)
											snake_case__									=     CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'						)

											torch.manual_seed(0						)
											snake_case__									=     CLIPTextModel(
											    CLIPTextConfig(
											        bos_token_id=0       ,	eos_token_id=2       ,	hidden_size=UpperCamelCase       ,	projection_dim=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       ,	)						)

											torch.manual_seed(0						)
											snake_case__									=     UNetaDConditionModel(
											    sample_size=32       ,	in_channels=4       ,	out_channels=4       ,	down_block_types=('CrossAttnDownBlock2D', 'DownBlock2D')       ,	up_block_types=('UpBlock2D', 'CrossAttnUpBlock2D')       ,	block_out_channels=(32, 64)       ,	attention_head_dim=(2, 4)       ,	class_embed_type='projection'       ,	projection_class_embeddings_input_dim=embedder_projection_dim * 2       ,	cross_attention_dim=UpperCamelCase       ,	layers_per_block=1       ,	upcast_attention=UpperCamelCase       ,	use_linear_projection=UpperCamelCase       ,	)

											torch.manual_seed(0						)
											snake_case__									=     DDIMScheduler(
											    beta_schedule='scaled_linear'       ,	beta_start=0.00_085       ,	beta_end=0.012       ,	prediction_type='v_prediction'       ,	set_alpha_to_one=UpperCamelCase       ,	steps_offset=1       ,	)

											torch.manual_seed(0						)
											snake_case__									=     AutoencoderKL()

											snake_case__									=     {
											    # image encoding components
											    'feature_extractor': feature_extractor,
											    'image_encoder': image_encoder.eval(),
											    # image noising components
											    'image_normalizer': image_normalizer.eval(),
											    'image_noising_scheduler': image_noising_scheduler,
											    # regular denoising components
											    'tokenizer': tokenizer,
											    'text_encoder': text_encoder.eval(),
											    'unet': unet.eval(),
											    'scheduler': scheduler,
											    'vae': vae.eval(),
											}

											return components
							def lowerCAmelCase_ (     self:      str       ,	UpperCamelCase:      Dict       ,	UpperCamelCase:      Tuple=0       ,	UpperCamelCase:      Union[str, Any]=True						)		->		Any:
											if str(UpperCamelCase						).startswith('mps'						):
															snake_case__									=     torch.manual_seed(UpperCamelCase						)
											else:
															snake_case__									=     torch.Generator(device=UpperCamelCase						).manual_seed(UpperCamelCase						)

											snake_case__									=     floats_tensor((1, 3, 32, 32)       ,	rng=random.Random(UpperCamelCase						)						).to(UpperCamelCase						)

											if pil_image:
															snake_case__									=     input_image * 0.5 + 0.5
															snake_case__									=     input_image.clamp(0       ,	1						)
															snake_case__									=     input_image.cpu().permute(0       ,	2       ,	3       ,	1						).float().numpy()
															snake_case__									=     DiffusionPipeline.numpy_to_pil(UpperCamelCase						)[0]

											return {
											    "prompt": "An anime racoon running a marathon",
											    "image": input_image,
											    "generator": generator,
											    "num_inference_steps": 2,
											    "output_type": "np",
											}
							@skip_mps
							def lowerCAmelCase_ (     self:      Dict						)		->		Optional[Any]:
											snake_case__									=     'cpu'  # ensure determinism for the device-dependent torch.Generator
											snake_case__									=     self.get_dummy_components()
											snake_case__									=     StableUnCLIPImgaImgPipeline(**UpperCamelCase						)
											snake_case__									=     sd_pipe.to(UpperCamelCase						)
											sd_pipe.set_progress_bar_config(disable=UpperCamelCase						)

											snake_case__									=     self.get_dummy_inputs(UpperCamelCase						)
											inputs.update({'image_embeds': None}						)
											snake_case__									=     sd_pipe(**UpperCamelCase						).images
											snake_case__									=     image[0, -3:, -3:, -1]

											assert image.shape == (1, 32, 32, 3)
											snake_case__									=     np.array([0.3_872, 0.7_224, 0.5_601, 0.4_741, 0.6_872, 0.5_814, 0.4_636, 0.3_867, 0.5_078]						)

											assert np.abs(image_slice.flatten() - expected_slice						).max() < 1e-3
							def lowerCAmelCase_ (     self:      Optional[int]						)		->		Union[str, Any]:
											snake_case__									=     torch_device in ['cpu', 'mps']

											self._test_attention_slicing_forward_pass(test_max_difference=UpperCamelCase						)
							def lowerCAmelCase_ (     self:      List[Any]						)		->		int:
											snake_case__									=     torch_device in ['cpu', 'mps']

											self._test_inference_batch_single_identical(test_max_difference=UpperCamelCase						)


							@unittest.skipIf(
							    torch_device != 'cuda' or not is_xformers_available()       ,	reason='XFormers attention is only available with CUDA and `xformers` installed'       ,	)
							def lowerCAmelCase_ (     self:      str						)		->		Optional[int]:
											self._test_xformers_attention_forwardGenerator_pass(test_max_difference=UpperCamelCase						)


@slow
@require_torch_gpu
class   __SCREAMING_SNAKE_CASE(	unittest.TestCase	):
							def lowerCAmelCase_ (     self:      Union[str, Any]						)		->		Optional[int]:
											# clean up the VRAM after each test
											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()
							def lowerCAmelCase_ (     self:      List[Any]						)		->		Dict:
											snake_case__									=     load_image(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'						)

											snake_case__									=     load_numpy(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_l_img2img_anime_turtle_fp16.npy'						)

											snake_case__									=     StableUnCLIPImgaImgPipeline.from_pretrained(
											    'fusing/stable-unclip-2-1-l-img2img'       ,	torch_dtype=torch.floataa						)
											pipe.to(UpperCamelCase						)
											pipe.set_progress_bar_config(disable=UpperCamelCase						)
											# stable unclip will oom when integration tests are run on a V100,
											# so turn on memory savings
											pipe.enable_attention_slicing()
											pipe.enable_sequential_cpu_offload()

											snake_case__									=     torch.Generator(device='cpu'						).manual_seed(0						)
											snake_case__									=     pipe(UpperCamelCase       ,	'anime turle'       ,	generator=UpperCamelCase       ,	output_type='np'						)

											snake_case__									=     output.images[0]

											assert image.shape == (7_68, 7_68, 3)

											assert_mean_pixel_difference(UpperCamelCase       ,	UpperCamelCase						)
							def lowerCAmelCase_ (     self:      Optional[int]						)		->		Dict:
											snake_case__									=     load_image(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'						)

											snake_case__									=     load_numpy(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/stable_unclip_2_1_h_img2img_anime_turtle_fp16.npy'						)

											snake_case__									=     StableUnCLIPImgaImgPipeline.from_pretrained(
											    'fusing/stable-unclip-2-1-h-img2img'       ,	torch_dtype=torch.floataa						)
											pipe.to(UpperCamelCase						)
											pipe.set_progress_bar_config(disable=UpperCamelCase						)
											# stable unclip will oom when integration tests are run on a V100,
											# so turn on memory savings
											pipe.enable_attention_slicing()
											pipe.enable_sequential_cpu_offload()

											snake_case__									=     torch.Generator(device='cpu'						).manual_seed(0						)
											snake_case__									=     pipe(UpperCamelCase       ,	'anime turle'       ,	generator=UpperCamelCase       ,	output_type='np'						)

											snake_case__									=     output.images[0]

											assert image.shape == (7_68, 7_68, 3)

											assert_mean_pixel_difference(UpperCamelCase       ,	UpperCamelCase						)


							def lowerCAmelCase_ (     self:      Optional[Any]						)		->		str:
											snake_case__									=     load_image(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/stable_unclip/turtle.png'						)

											torch.cuda.empty_cache()
											torch.cuda.reset_max_memory_allocated()
											torch.cuda.reset_peak_memory_stats()

											snake_case__									=     StableUnCLIPImgaImgPipeline.from_pretrained(
											    'fusing/stable-unclip-2-1-h-img2img'       ,	torch_dtype=torch.floataa						)
											snake_case__									=     pipe.to(UpperCamelCase						)
											pipe.set_progress_bar_config(disable=UpperCamelCase						)
											pipe.enable_attention_slicing()
											pipe.enable_sequential_cpu_offload()

											snake_case__									=     pipe(
											    UpperCamelCase       ,	'anime turtle'       ,	num_inference_steps=2       ,	output_type='np'       ,	)

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




