Update pipeline.py

89e0184 verified about 2 months ago

No virus

89.4 kB

	# Implementation of Stable Diffusion Inpaint Pipeline with Perturbed-Attention Guidance

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

	import numpy as np
	import PIL.Image
	import torch
	import torch.nn.functional as F
	from packaging import version
	from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer, CLIPVisionModelWithProjection

	from diffusers.configuration_utils import FrozenDict
	from diffusers.image_processor import PipelineImageInput, VaeImageProcessor
	from diffusers.loaders import FromSingleFileMixin, IPAdapterMixin, LoraLoaderMixin, TextualInversionLoaderMixin
	from diffusers.models import AsymmetricAutoencoderKL, AutoencoderKL, ImageProjection, UNet2DConditionModel
	from diffusers.models.lora import adjust_lora_scale_text_encoder
	from diffusers.schedulers import KarrasDiffusionSchedulers
	from diffusers.utils import USE_PEFT_BACKEND, deprecate, logging, scale_lora_layers, unscale_lora_layers
	from diffusers.utils.torch_utils import randn_tensor
	from diffusers.pipelines.pipeline_utils import DiffusionPipeline, StableDiffusionMixin
	from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
	from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
	from diffusers.models.attention_processor import Attention, AttnProcessor2_0


	logger = logging.get_logger(__name__) # pylint: disable=invalid-name

	class PAGIdentitySelfAttnProcessor:
	r"""
	Processor for implementing scaled dot-product attention (enabled by default if you're using PyTorch 2.0).
	"""

	def __init__(self):
	if not hasattr(F, "scaled_dot_product_attention"):
	raise ImportError("AttnProcessor2_0 requires PyTorch 2.0, to use it, please upgrade PyTorch to 2.0.")

	def __call__(
	self,
	attn: Attention,
	hidden_states: torch.FloatTensor,
	encoder_hidden_states: Optional[torch.FloatTensor] = None,
	attention_mask: Optional[torch.FloatTensor] = None,
	temb: Optional[torch.FloatTensor] = None,
	*args,
	**kwargs,
	) -> torch.FloatTensor:
	if len(args) > 0 or kwargs.get("scale", None) is not None:
	deprecation_message = "The `scale` argument is deprecated and will be ignored. Please remove it, as passing it will raise an error in the future. `scale` should directly be passed while calling the underlying pipeline component i.e., via `cross_attention_kwargs`."
	deprecate("scale", "1.0.0", deprecation_message)

	residual = hidden_states
	if attn.spatial_norm is not None:
	hidden_states = attn.spatial_norm(hidden_states, temb)

	input_ndim = hidden_states.ndim
	if input_ndim == 4:
	batch_size, channel, height, width = hidden_states.shape
	hidden_states = hidden_states.view(batch_size, channel, height * width).transpose(1, 2)

	# chunk
	hidden_states_org, hidden_states_ptb = hidden_states.chunk(2)

	# original path
	batch_size, sequence_length, _ = hidden_states_org.shape

	if attention_mask is not None:
	attention_mask = attn.prepare_attention_mask(attention_mask, sequence_length, batch_size)
	# scaled_dot_product_attention expects attention_mask shape to be
	# (batch, heads, source_length, target_length)
	attention_mask = attention_mask.view(batch_size, attn.heads, -1, attention_mask.shape[-1])

	if attn.group_norm is not None:
	hidden_states_org = attn.group_norm(hidden_states_org.transpose(1, 2)).transpose(1, 2)

	query = attn.to_q(hidden_states_org)
	key = attn.to_k(hidden_states_org)
	value = attn.to_v(hidden_states_org)

	inner_dim = key.shape[-1]
	head_dim = inner_dim // attn.heads

	query = query.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)

	key = key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
	value = value.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)

	# the output of sdp = (batch, num_heads, seq_len, head_dim)
	# TODO: add support for attn.scale when we move to Torch 2.1
	hidden_states_org = F.scaled_dot_product_attention(
	query, key, value, attn_mask=attention_mask, dropout_p=0.0, is_causal=False
	)

	hidden_states_org = hidden_states_org.transpose(1, 2).reshape(batch_size, -1, attn.heads * head_dim)
	hidden_states_org = hidden_states_org.to(query.dtype)

	# linear proj
	hidden_states_org = attn.to_out[0](hidden_states_org)
	# dropout
	hidden_states_org = attn.to_out[1](hidden_states_org)

	if input_ndim == 4:
	hidden_states_org = hidden_states_org.transpose(-1, -2).reshape(batch_size, channel, height, width)

	# perturbed path (identity attention)
	batch_size, sequence_length, _ = hidden_states_ptb.shape

	if attention_mask is not None:
	attention_mask = attn.prepare_attention_mask(attention_mask, sequence_length, batch_size)
	# scaled_dot_product_attention expects attention_mask shape to be
	# (batch, heads, source_length, target_length)
	attention_mask = attention_mask.view(batch_size, attn.heads, -1, attention_mask.shape[-1])

	if attn.group_norm is not None:
	hidden_states_ptb = attn.group_norm(hidden_states_ptb.transpose(1, 2)).transpose(1, 2)

	value = attn.to_v(hidden_states_ptb)

	# hidden_states_ptb = torch.zeros(value.shape).to(value.get_device())
	hidden_states_ptb = value

	hidden_states_ptb = hidden_states_ptb.to(query.dtype)

	# linear proj
	hidden_states_ptb = attn.to_out[0](hidden_states_ptb)
	# dropout
	hidden_states_ptb = attn.to_out[1](hidden_states_ptb)

	if input_ndim == 4:
	hidden_states_ptb = hidden_states_ptb.transpose(-1, -2).reshape(batch_size, channel, height, width)

	# cat
	hidden_states = torch.cat([hidden_states_org, hidden_states_ptb])

	if attn.residual_connection:
	hidden_states = hidden_states + residual

	hidden_states = hidden_states / attn.rescale_output_factor

	return hidden_states


	class PAGCFGIdentitySelfAttnProcessor:
	r"""
	Processor for implementing scaled dot-product attention (enabled by default if you're using PyTorch 2.0).
	"""

	def __init__(self):
	if not hasattr(F, "scaled_dot_product_attention"):
	raise ImportError("AttnProcessor2_0 requires PyTorch 2.0, to use it, please upgrade PyTorch to 2.0.")

	def __call__(
	self,
	attn: Attention,
	hidden_states: torch.FloatTensor,
	encoder_hidden_states: Optional[torch.FloatTensor] = None,
	attention_mask: Optional[torch.FloatTensor] = None,
	temb: Optional[torch.FloatTensor] = None,
	*args,
	**kwargs,
	) -> torch.FloatTensor:
	if len(args) > 0 or kwargs.get("scale", None) is not None:
	deprecation_message = "The `scale` argument is deprecated and will be ignored. Please remove it, as passing it will raise an error in the future. `scale` should directly be passed while calling the underlying pipeline component i.e., via `cross_attention_kwargs`."
	deprecate("scale", "1.0.0", deprecation_message)

	residual = hidden_states
	if attn.spatial_norm is not None:
	hidden_states = attn.spatial_norm(hidden_states, temb)

	input_ndim = hidden_states.ndim
	if input_ndim == 4:
	batch_size, channel, height, width = hidden_states.shape
	hidden_states = hidden_states.view(batch_size, channel, height * width).transpose(1, 2)

	# chunk
	hidden_states_uncond, hidden_states_org, hidden_states_ptb = hidden_states.chunk(3)
	hidden_states_org = torch.cat([hidden_states_uncond, hidden_states_org])

	# original path
	batch_size, sequence_length, _ = hidden_states_org.shape

	if attention_mask is not None:
	attention_mask = attn.prepare_attention_mask(attention_mask, sequence_length, batch_size)
	# scaled_dot_product_attention expects attention_mask shape to be
	# (batch, heads, source_length, target_length)
	attention_mask = attention_mask.view(batch_size, attn.heads, -1, attention_mask.shape[-1])

	if attn.group_norm is not None:
	hidden_states_org = attn.group_norm(hidden_states_org.transpose(1, 2)).transpose(1, 2)

	query = attn.to_q(hidden_states_org)
	key = attn.to_k(hidden_states_org)
	value = attn.to_v(hidden_states_org)

	inner_dim = key.shape[-1]
	head_dim = inner_dim // attn.heads

	query = query.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)

	key = key.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)
	value = value.view(batch_size, -1, attn.heads, head_dim).transpose(1, 2)

	# the output of sdp = (batch, num_heads, seq_len, head_dim)
	# TODO: add support for attn.scale when we move to Torch 2.1
	hidden_states_org = F.scaled_dot_product_attention(
	query, key, value, attn_mask=attention_mask, dropout_p=0.0, is_causal=False
	)

	hidden_states_org = hidden_states_org.transpose(1, 2).reshape(batch_size, -1, attn.heads * head_dim)
	hidden_states_org = hidden_states_org.to(query.dtype)

	# linear proj
	hidden_states_org = attn.to_out[0](hidden_states_org)
	# dropout
	hidden_states_org = attn.to_out[1](hidden_states_org)

	if input_ndim == 4:
	hidden_states_org = hidden_states_org.transpose(-1, -2).reshape(batch_size, channel, height, width)

	# perturbed path (identity attention)
	batch_size, sequence_length, _ = hidden_states_ptb.shape

	if attention_mask is not None:
	attention_mask = attn.prepare_attention_mask(attention_mask, sequence_length, batch_size)
	# scaled_dot_product_attention expects attention_mask shape to be
	# (batch, heads, source_length, target_length)
	attention_mask = attention_mask.view(batch_size, attn.heads, -1, attention_mask.shape[-1])

	if attn.group_norm is not None:
	hidden_states_ptb = attn.group_norm(hidden_states_ptb.transpose(1, 2)).transpose(1, 2)

	value = attn.to_v(hidden_states_ptb)
	hidden_states_ptb = value
	hidden_states_ptb = hidden_states_ptb.to(query.dtype)

	# linear proj
	hidden_states_ptb = attn.to_out[0](hidden_states_ptb)
	# dropout
	hidden_states_ptb = attn.to_out[1](hidden_states_ptb)

	if input_ndim == 4:
	hidden_states_ptb = hidden_states_ptb.transpose(-1, -2).reshape(batch_size, channel, height, width)

	# cat
	hidden_states = torch.cat([hidden_states_org, hidden_states_ptb])

	if attn.residual_connection:
	hidden_states = hidden_states + residual

	hidden_states = hidden_states / attn.rescale_output_factor

	return hidden_states


	def prepare_mask_and_masked_image(image, mask, height, width, return_image: bool = False):
	"""
	Prepares a pair (image, mask) to be consumed by the Stable Diffusion pipeline. This means that those inputs will be
	converted to ``torch.Tensor`` with shapes ``batch x channels x height x width`` where ``channels`` is ``3`` for the
	``image`` and ``1`` for the ``mask``.

	The ``image`` will be converted to ``torch.float32`` and normalized to be in ``[-1, 1]``. The ``mask`` will be
	binarized (``mask > 0.5``) and cast to ``torch.float32`` too.

	Args:
	image (Union[np.array, PIL.Image, torch.Tensor]): The image to inpaint.
	It can be a ``PIL.Image``, or a ``height x width x 3`` ``np.array`` or a ``channels x height x width``
	``torch.Tensor`` or a ``batch x channels x height x width`` ``torch.Tensor``.
	mask (_type_): The mask to apply to the image, i.e. regions to inpaint.
	It can be a ``PIL.Image``, or a ``height x width`` ``np.array`` or a ``1 x height x width``
	``torch.Tensor`` or a ``batch x 1 x height x width`` ``torch.Tensor``.


	Raises:
	ValueError: ``torch.Tensor`` images should be in the ``[-1, 1]`` range. ValueError: ``torch.Tensor`` mask
	should be in the ``[0, 1]`` range. ValueError: ``mask`` and ``image`` should have the same spatial dimensions.
	TypeError: ``mask`` is a ``torch.Tensor`` but ``image`` is not
	(ot the other way around).

	Returns:
	tuple[torch.Tensor]: The pair (mask, masked_image) as ``torch.Tensor`` with 4
	dimensions: ``batch x channels x height x width``.
	"""
	deprecation_message = "The prepare_mask_and_masked_image method is deprecated and will be removed in a future version. Please use VaeImageProcessor.preprocess instead"
	deprecate(
	"prepare_mask_and_masked_image",
	"0.30.0",
	deprecation_message,
	)
	if image is None:
	raise ValueError("`image` input cannot be undefined.")

	if mask is None:
	raise ValueError("`mask_image` input cannot be undefined.")

	if isinstance(image, torch.Tensor):
	if not isinstance(mask, torch.Tensor):
	raise TypeError(f"`image` is a torch.Tensor but `mask` (type: {type(mask)} is not")

	# Batch single image
	if image.ndim == 3:
	assert image.shape[0] == 3, "Image outside a batch should be of shape (3, H, W)"
	image = image.unsqueeze(0)

	# Batch and add channel dim for single mask
	if mask.ndim == 2:
	mask = mask.unsqueeze(0).unsqueeze(0)

	# Batch single mask or add channel dim
	if mask.ndim == 3:
	# Single batched mask, no channel dim or single mask not batched but channel dim
	if mask.shape[0] == 1:
	mask = mask.unsqueeze(0)

	# Batched masks no channel dim
	else:
	mask = mask.unsqueeze(1)

	assert image.ndim == 4 and mask.ndim == 4, "Image and Mask must have 4 dimensions"
	assert image.shape[-2:] == mask.shape[-2:], "Image and Mask must have the same spatial dimensions"
	assert image.shape[0] == mask.shape[0], "Image and Mask must have the same batch size"

	# Check image is in [-1, 1]
	if image.min() < -1 or image.max() > 1:
	raise ValueError("Image should be in [-1, 1] range")

	# Check mask is in [0, 1]
	if mask.min() < 0 or mask.max() > 1:
	raise ValueError("Mask should be in [0, 1] range")

	# Binarize mask
	mask[mask < 0.5] = 0
	mask[mask >= 0.5] = 1

	# Image as float32
	image = image.to(dtype=torch.float32)
	elif isinstance(mask, torch.Tensor):
	raise TypeError(f"`mask` is a torch.Tensor but `image` (type: {type(image)} is not")
	else:
	# preprocess image
	if isinstance(image, (PIL.Image.Image, np.ndarray)):
	image = [image]
	if isinstance(image, list) and isinstance(image[0], PIL.Image.Image):
	# resize all images w.r.t passed height an width
	image = [i.resize((width, height), resample=PIL.Image.LANCZOS) for i in image]
	image = [np.array(i.convert("RGB"))[None, :] for i in image]
	image = np.concatenate(image, axis=0)
	elif isinstance(image, list) and isinstance(image[0], np.ndarray):
	image = np.concatenate([i[None, :] for i in image], axis=0)

	image = image.transpose(0, 3, 1, 2)
	image = torch.from_numpy(image).to(dtype=torch.float32) / 127.5 - 1.0

	# preprocess mask
	if isinstance(mask, (PIL.Image.Image, np.ndarray)):
	mask = [mask]

	if isinstance(mask, list) and isinstance(mask[0], PIL.Image.Image):
	mask = [i.resize((width, height), resample=PIL.Image.LANCZOS) for i in mask]
	mask = np.concatenate([np.array(m.convert("L"))[None, None, :] for m in mask], axis=0)
	mask = mask.astype(np.float32) / 255.0
	elif isinstance(mask, list) and isinstance(mask[0], np.ndarray):
	mask = np.concatenate([m[None, None, :] for m in mask], axis=0)

	mask[mask < 0.5] = 0
	mask[mask >= 0.5] = 1
	mask = torch.from_numpy(mask)

	masked_image = image * (mask < 0.5)

	# n.b. ensure backwards compatibility as old function does not return image
	if return_image:
	return mask, masked_image, image

	return mask, masked_image


	# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img.retrieve_latents
	def retrieve_latents(
	encoder_output: torch.Tensor, generator: Optional[torch.Generator] = None, sample_mode: str = "sample"
	):
	if hasattr(encoder_output, "latent_dist") and sample_mode == "sample":
	return encoder_output.latent_dist.sample(generator)
	elif hasattr(encoder_output, "latent_dist") and sample_mode == "argmax":
	return encoder_output.latent_dist.mode()
	elif hasattr(encoder_output, "latents"):
	return encoder_output.latents
	else:
	raise AttributeError("Could not access latents of provided encoder_output")


	# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.retrieve_timesteps
	def retrieve_timesteps(
	scheduler,
	num_inference_steps: Optional[int] = None,
	device: Optional[Union[str, torch.device]] = None,
	timesteps: Optional[List[int]] = None,
	**kwargs,
	):
	"""
	Calls the scheduler's `set_timesteps` method and retrieves timesteps from the scheduler after the call. Handles
	custom timesteps. Any kwargs will be supplied to `scheduler.set_timesteps`.

	Args:
	scheduler (`SchedulerMixin`):
	The scheduler to get timesteps from.
	num_inference_steps (`int`):
	The number of diffusion steps used when generating samples with a pre-trained model. If used, `timesteps`
	must be `None`.
	device (`str` or `torch.device`, optional):
	The device to which the timesteps should be moved to. If `None`, the timesteps are not moved.
	timesteps (`List[int]`, optional):
	Custom timesteps used to support arbitrary spacing between timesteps. If `None`, then the default
	timestep spacing strategy of the scheduler is used. If `timesteps` is passed, `num_inference_steps`
	must be `None`.

	Returns:
	`Tuple[torch.Tensor, int]`: A tuple where the first element is the timestep schedule from the scheduler and the
	second element is the number of inference steps.
	"""
	if timesteps is not None:
	accepts_timesteps = "timesteps" in set(inspect.signature(scheduler.set_timesteps).parameters.keys())
	if not accepts_timesteps:
	raise ValueError(
	f"The current scheduler class {scheduler.__class__}'s `set_timesteps` does not support custom"
	f" timestep schedules. Please check whether you are using the correct scheduler."
	)
	scheduler.set_timesteps(timesteps=timesteps, device=device, **kwargs)
	timesteps = scheduler.timesteps
	num_inference_steps = len(timesteps)
	else:
	scheduler.set_timesteps(num_inference_steps, device=device, **kwargs)
	timesteps = scheduler.timesteps
	return timesteps, num_inference_steps


	class StableDiffusionInpaintPipeline(
	DiffusionPipeline,
	StableDiffusionMixin,
	TextualInversionLoaderMixin,
	IPAdapterMixin,
	LoraLoaderMixin,
	FromSingleFileMixin,
	):
	r"""
	Pipeline for text-guided image inpainting using Stable Diffusion.

	This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods
	implemented for all pipelines (downloading, saving, running on a particular device, etc.).

	The pipeline also inherits the following loading methods:
	- [`~loaders.TextualInversionLoaderMixin.load_textual_inversion`] for loading textual inversion embeddings
	- [`~loaders.LoraLoaderMixin.load_lora_weights`] for loading LoRA weights
	- [`~loaders.LoraLoaderMixin.save_lora_weights`] for saving LoRA weights
	- [`~loaders.IPAdapterMixin.load_ip_adapter`] for loading IP Adapters
	- [`~loaders.FromSingleFileMixin.from_single_file`] for loading `.ckpt` files

	Args:
	vae ([`AutoencoderKL`, `AsymmetricAutoencoderKL`]):
	Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent representations.
	text_encoder ([`CLIPTextModel`]):
	Frozen text-encoder ([clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14)).
	tokenizer ([`~transformers.CLIPTokenizer`]):
	A `CLIPTokenizer` to tokenize text.
	unet ([`UNet2DConditionModel`]):
	A `UNet2DConditionModel` to denoise the encoded image latents.
	scheduler ([`SchedulerMixin`]):
	A scheduler to be used in combination with `unet` to denoise the encoded image latents. Can be one of
	[`DDIMScheduler`], [`LMSDiscreteScheduler`], or [`PNDMScheduler`].
	safety_checker ([`StableDiffusionSafetyChecker`]):
	Classification module that estimates whether generated images could be considered offensive or harmful.
	Please refer to the [model card](https://huggingface.co/runwayml/stable-diffusion-v1-5) for more details
	about a model's potential harms.
	feature_extractor ([`~transformers.CLIPImageProcessor`]):
	A `CLIPImageProcessor` to extract features from generated images; used as inputs to the `safety_checker`.
	"""

	model_cpu_offload_seq = "text_encoder->image_encoder->unet->vae"
	_optional_components = ["safety_checker", "feature_extractor", "image_encoder"]
	_exclude_from_cpu_offload = ["safety_checker"]
	_callback_tensor_inputs = ["latents", "prompt_embeds", "negative_prompt_embeds", "mask", "masked_image_latents"]

	def __init__(
	self,
	vae: Union[AutoencoderKL, AsymmetricAutoencoderKL],
	text_encoder: CLIPTextModel,
	tokenizer: CLIPTokenizer,
	unet: UNet2DConditionModel,
	scheduler: KarrasDiffusionSchedulers,
	safety_checker: StableDiffusionSafetyChecker,
	feature_extractor: CLIPImageProcessor,
	image_encoder: CLIPVisionModelWithProjection = None,
	requires_safety_checker: bool = True,
	):
	super().__init__()

	if hasattr(scheduler.config, "steps_offset") and scheduler.config.steps_offset != 1:
	deprecation_message = (
	f"The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`"
	f" should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure "
	"to update the config accordingly as leaving `steps_offset` might led to incorrect results"
	" in future versions. If you have downloaded this checkpoint from the Hugging Face Hub,"
	" it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json`"
	" file"
	)
	deprecate("steps_offset!=1", "1.0.0", deprecation_message, standard_warn=False)
	new_config = dict(scheduler.config)
	new_config["steps_offset"] = 1
	scheduler._internal_dict = FrozenDict(new_config)

	if hasattr(scheduler.config, "skip_prk_steps") and scheduler.config.skip_prk_steps is False:
	deprecation_message = (
	f"The configuration file of this scheduler: {scheduler} has not set the configuration"
	" `skip_prk_steps`. `skip_prk_steps` should be set to True in the configuration file. Please make"
	" sure to update the config accordingly as not setting `skip_prk_steps` in the config might lead to"
	" incorrect results in future versions. If you have downloaded this checkpoint from the Hugging Face"
	" Hub, it would be very nice if you could open a Pull request for the"
	" `scheduler/scheduler_config.json` file"
	)
	deprecate("skip_prk_steps not set", "1.0.0", deprecation_message, standard_warn=False)
	new_config = dict(scheduler.config)
	new_config["skip_prk_steps"] = True
	scheduler._internal_dict = FrozenDict(new_config)

	if safety_checker is None and requires_safety_checker:
	logger.warning(
	f"You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure"
	" that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered"
	" results in services or applications open to the public. Both the diffusers team and Hugging Face"
	" strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling"
	" it only for use-cases that involve analyzing network behavior or auditing its results. For more"
	" information, please have a look at https://github.com/huggingface/diffusers/pull/254 ."
	)

	if safety_checker is not None and feature_extractor is None:
	raise ValueError(
	"Make sure to define a feature extractor when loading {self.__class__} if you want to use the safety"
	" checker. If you do not want to use the safety checker, you can pass `'safety_checker=None'` instead."
	)

	is_unet_version_less_0_9_0 = hasattr(unet.config, "_diffusers_version") and version.parse(
	version.parse(unet.config._diffusers_version).base_version
	) < version.parse("0.9.0.dev0")
	is_unet_sample_size_less_64 = hasattr(unet.config, "sample_size") and unet.config.sample_size < 64
	if is_unet_version_less_0_9_0 and is_unet_sample_size_less_64:
	deprecation_message = (
	"The configuration file of the unet has set the default `sample_size` to smaller than"
	" 64 which seems highly unlikely .If you're checkpoint is a fine-tuned version of any of the"
	" following: \n- CompVis/stable-diffusion-v1-4 \n- CompVis/stable-diffusion-v1-3 \n-"
	" CompVis/stable-diffusion-v1-2 \n- CompVis/stable-diffusion-v1-1 \n- runwayml/stable-diffusion-v1-5"
	" \n- runwayml/stable-diffusion-inpainting \n you should change 'sample_size' to 64 in the"
	" configuration file. Please make sure to update the config accordingly as leaving `sample_size=32`"
	" in the config might lead to incorrect results in future versions. If you have downloaded this"
	" checkpoint from the Hugging Face Hub, it would be very nice if you could open a Pull request for"
	" the `unet/config.json` file"
	)
	deprecate("sample_size<64", "1.0.0", deprecation_message, standard_warn=False)
	new_config = dict(unet.config)
	new_config["sample_size"] = 64
	unet._internal_dict = FrozenDict(new_config)

	# Check shapes, assume num_channels_latents == 4, num_channels_mask == 1, num_channels_masked == 4
	if unet.config.in_channels != 9:
	logger.info(f"You have loaded a UNet with {unet.config.in_channels} input channels which.")

	self.register_modules(
	vae=vae,
	text_encoder=text_encoder,
	tokenizer=tokenizer,
	unet=unet,
	scheduler=scheduler,
	safety_checker=safety_checker,
	feature_extractor=feature_extractor,
	image_encoder=image_encoder,
	)
	self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1)
	self.image_processor = VaeImageProcessor(vae_scale_factor=self.vae_scale_factor)
	self.mask_processor = VaeImageProcessor(
	vae_scale_factor=self.vae_scale_factor, do_normalize=False, do_binarize=True, do_convert_grayscale=True
	)
	self.register_to_config(requires_safety_checker=requires_safety_checker)

	# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._encode_prompt
	def _encode_prompt(
	self,
	prompt,
	device,
	num_images_per_prompt,
	do_classifier_free_guidance,
	negative_prompt=None,
	prompt_embeds: Optional[torch.FloatTensor] = None,
	negative_prompt_embeds: Optional[torch.FloatTensor] = None,
	lora_scale: Optional[float] = None,
	**kwargs,
	):
	deprecation_message = "`_encode_prompt()` is deprecated and it will be removed in a future version. Use `encode_prompt()` instead. Also, be aware that the output format changed from a concatenated tensor to a tuple."
	deprecate("_encode_prompt()", "1.0.0", deprecation_message, standard_warn=False)

	prompt_embeds_tuple = self.encode_prompt(
	prompt=prompt,
	device=device,
	num_images_per_prompt=num_images_per_prompt,
	do_classifier_free_guidance=do_classifier_free_guidance,
	negative_prompt=negative_prompt,
	prompt_embeds=prompt_embeds,
	negative_prompt_embeds=negative_prompt_embeds,
	lora_scale=lora_scale,
	**kwargs,
	)

	# concatenate for backwards comp
	prompt_embeds = torch.cat([prompt_embeds_tuple[1], prompt_embeds_tuple[0]])

	return prompt_embeds

	# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.encode_prompt
	def encode_prompt(
	self,
	prompt,
	device,
	num_images_per_prompt,
	do_classifier_free_guidance,
	negative_prompt=None,
	prompt_embeds: Optional[torch.FloatTensor] = None,
	negative_prompt_embeds: Optional[torch.FloatTensor] = None,
	lora_scale: Optional[float] = None,
	clip_skip: Optional[int] = None,
	):
	r"""
	Encodes the prompt into text encoder hidden states.

	Args:
	prompt (`str` or `List[str]`, optional):
	prompt to be encoded
	device: (`torch.device`):
	torch device
	num_images_per_prompt (`int`):
	number of images that should be generated per prompt
	do_classifier_free_guidance (`bool`):
	whether to use classifier free guidance or not
	negative_prompt (`str` or `List[str]`, optional):
	The prompt or prompts not to guide the image generation. If not defined, one has to pass
	`negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is
	less than `1`).
	prompt_embeds (`torch.FloatTensor`, optional):
	Pre-generated text embeddings. Can be used to easily tweak text inputs, e.g. prompt weighting. If not
	provided, text embeddings will be generated from `prompt` input argument.
	negative_prompt_embeds (`torch.FloatTensor`, optional):
	Pre-generated negative text embeddings. Can be used to easily tweak text inputs, e.g. prompt
	weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input
	argument.
	lora_scale (`float`, optional):
	A LoRA scale that will be applied to all LoRA layers of the text encoder if LoRA layers are loaded.
	clip_skip (`int`, optional):
	Number of layers to be skipped from CLIP while computing the prompt embeddings. A value of 1 means that
	the output of the pre-final layer will be used for computing the prompt embeddings.
	"""
	# set lora scale so that monkey patched LoRA
	# function of text encoder can correctly access it
	if lora_scale is not None and isinstance(self, LoraLoaderMixin):
	self._lora_scale = lora_scale

	# dynamically adjust the LoRA scale
	if not USE_PEFT_BACKEND:
	adjust_lora_scale_text_encoder(self.text_encoder, lora_scale)
	else:
	scale_lora_layers(self.text_encoder, lora_scale)

	if prompt is not None and isinstance(prompt, str):
	batch_size = 1
	elif prompt is not None and isinstance(prompt, list):
	batch_size = len(prompt)
	else:
	batch_size = prompt_embeds.shape[0]

	if prompt_embeds is None:
	# textual inversion: process multi-vector tokens if necessary
	if isinstance(self, TextualInversionLoaderMixin):
	prompt = self.maybe_convert_prompt(prompt, self.tokenizer)

	text_inputs = self.tokenizer(
	prompt,
	padding="max_length",
	max_length=self.tokenizer.model_max_length,
	truncation=True,
	return_tensors="pt",
	)
	text_input_ids = text_inputs.input_ids
	untruncated_ids = self.tokenizer(prompt, padding="longest", return_tensors="pt").input_ids

	if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(
	text_input_ids, untruncated_ids
	):
	removed_text = self.tokenizer.batch_decode(
	untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1]
	)
	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}"
	)

	if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
	attention_mask = text_inputs.attention_mask.to(device)
	else:
	attention_mask = None

	if clip_skip is None:
	prompt_embeds = self.text_encoder(text_input_ids.to(device), attention_mask=attention_mask)
	prompt_embeds = prompt_embeds[0]
	else:
	prompt_embeds = self.text_encoder(
	text_input_ids.to(device), attention_mask=attention_mask, output_hidden_states=True
	)
	# Access the `hidden_states` first, that contains a tuple of
	# all the hidden states from the encoder layers. Then index into
	# the tuple to access the hidden states from the desired layer.
	prompt_embeds = prompt_embeds[-1][-(clip_skip + 1)]
	# We also need to apply the final LayerNorm here to not mess with the
	# representations. The `last_hidden_states` that we typically use for
	# obtaining the final prompt representations passes through the LayerNorm
	# layer.
	prompt_embeds = self.text_encoder.text_model.final_layer_norm(prompt_embeds)

	if self.text_encoder is not None:
	prompt_embeds_dtype = self.text_encoder.dtype
	elif self.unet is not None:
	prompt_embeds_dtype = self.unet.dtype
	else:
	prompt_embeds_dtype = prompt_embeds.dtype

	prompt_embeds = prompt_embeds.to(dtype=prompt_embeds_dtype, device=device)

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

	# get unconditional embeddings for classifier free guidance
	if do_classifier_free_guidance and negative_prompt_embeds is None:
	uncond_tokens: List[str]
	if negative_prompt is None:
	uncond_tokens = [""] * batch_size
	elif prompt is not None and type(prompt) is not type(negative_prompt):
	raise TypeError(
	f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !="
	f" {type(prompt)}."
	)
	elif isinstance(negative_prompt, str):
	uncond_tokens = [negative_prompt]
	elif batch_size != len(negative_prompt):
	raise ValueError(
	f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:"
	f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
	" the batch size of `prompt`."
	)
	else:
	uncond_tokens = negative_prompt

	# textual inversion: process multi-vector tokens if necessary
	if isinstance(self, TextualInversionLoaderMixin):
	uncond_tokens = self.maybe_convert_prompt(uncond_tokens, self.tokenizer)

	max_length = prompt_embeds.shape[1]
	uncond_input = self.tokenizer(
	uncond_tokens,
	padding="max_length",
	max_length=max_length,
	truncation=True,
	return_tensors="pt",
	)

	if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
	attention_mask = uncond_input.attention_mask.to(device)
	else:
	attention_mask = None

	negative_prompt_embeds = self.text_encoder(
	uncond_input.input_ids.to(device),
	attention_mask=attention_mask,
	)
	negative_prompt_embeds = negative_prompt_embeds[0]

	if do_classifier_free_guidance:
	# duplicate unconditional embeddings for each generation per prompt, using mps friendly method
	seq_len = negative_prompt_embeds.shape[1]

	negative_prompt_embeds = negative_prompt_embeds.to(dtype=prompt_embeds_dtype, device=device)

	negative_prompt_embeds = negative_prompt_embeds.repeat(1, num_images_per_prompt, 1)
	negative_prompt_embeds = negative_prompt_embeds.view(batch_size * num_images_per_prompt, seq_len, -1)

	if isinstance(self, LoraLoaderMixin) and USE_PEFT_BACKEND:
	# Retrieve the original scale by scaling back the LoRA layers
	unscale_lora_layers(self.text_encoder, lora_scale)

	return prompt_embeds, negative_prompt_embeds

	# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.encode_image
	def encode_image(self, image, device, num_images_per_prompt, output_hidden_states=None):
	dtype = next(self.image_encoder.parameters()).dtype

	if not isinstance(image, torch.Tensor):
	image = self.feature_extractor(image, return_tensors="pt").pixel_values

	image = image.to(device=device, dtype=dtype)
	if output_hidden_states:
	image_enc_hidden_states = self.image_encoder(image, output_hidden_states=True).hidden_states[-2]
	image_enc_hidden_states = image_enc_hidden_states.repeat_interleave(num_images_per_prompt, dim=0)
	uncond_image_enc_hidden_states = self.image_encoder(
	torch.zeros_like(image), output_hidden_states=True
	).hidden_states[-2]
	uncond_image_enc_hidden_states = uncond_image_enc_hidden_states.repeat_interleave(
	num_images_per_prompt, dim=0
	)
	return image_enc_hidden_states, uncond_image_enc_hidden_states
	else:
	image_embeds = self.image_encoder(image).image_embeds
	image_embeds = image_embeds.repeat_interleave(num_images_per_prompt, dim=0)
	uncond_image_embeds = torch.zeros_like(image_embeds)

	return image_embeds, uncond_image_embeds

	# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_ip_adapter_image_embeds
	def prepare_ip_adapter_image_embeds(
	self, ip_adapter_image, ip_adapter_image_embeds, device, num_images_per_prompt, do_classifier_free_guidance
	):
	if ip_adapter_image_embeds is None:
	if not isinstance(ip_adapter_image, list):
	ip_adapter_image = [ip_adapter_image]

	if len(ip_adapter_image) != len(self.unet.encoder_hid_proj.image_projection_layers):
	raise ValueError(
	f"`ip_adapter_image` must have same length as the number of IP Adapters. Got {len(ip_adapter_image)} images and {len(self.unet.encoder_hid_proj.image_projection_layers)} IP Adapters."
	)

	image_embeds = []
	for single_ip_adapter_image, image_proj_layer in zip(
	ip_adapter_image, self.unet.encoder_hid_proj.image_projection_layers
	):
	output_hidden_state = not isinstance(image_proj_layer, ImageProjection)
	single_image_embeds, single_negative_image_embeds = self.encode_image(
	single_ip_adapter_image, device, 1, output_hidden_state
	)
	single_image_embeds = torch.stack([single_image_embeds] * num_images_per_prompt, dim=0)
	single_negative_image_embeds = torch.stack(
	[single_negative_image_embeds] * num_images_per_prompt, dim=0
	)

	if do_classifier_free_guidance:
	single_image_embeds = torch.cat([single_negative_image_embeds, single_image_embeds])
	single_image_embeds = single_image_embeds.to(device)

	image_embeds.append(single_image_embeds)
	else:
	repeat_dims = [1]
	image_embeds = []
	for single_image_embeds in ip_adapter_image_embeds:
	if do_classifier_free_guidance:
	single_negative_image_embeds, single_image_embeds = single_image_embeds.chunk(2)
	single_image_embeds = single_image_embeds.repeat(
	num_images_per_prompt, (repeat_dims len(single_image_embeds.shape[1:]))
	)
	single_negative_image_embeds = single_negative_image_embeds.repeat(
	num_images_per_prompt, (repeat_dims len(single_negative_image_embeds.shape[1:]))
	)
	single_image_embeds = torch.cat([single_negative_image_embeds, single_image_embeds])
	else:
	single_image_embeds = single_image_embeds.repeat(
	num_images_per_prompt, (repeat_dims len(single_image_embeds.shape[1:]))
	)
	image_embeds.append(single_image_embeds)

	return image_embeds

	# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.run_safety_checker
	def run_safety_checker(self, image, device, dtype):
	if self.safety_checker is None:
	has_nsfw_concept = None
	else:
	if torch.is_tensor(image):
	feature_extractor_input = self.image_processor.postprocess(image, output_type="pil")
	else:
	feature_extractor_input = self.image_processor.numpy_to_pil(image)
	safety_checker_input = self.feature_extractor(feature_extractor_input, return_tensors="pt").to(device)
	image, has_nsfw_concept = self.safety_checker(
	images=image, clip_input=safety_checker_input.pixel_values.to(dtype)
	)
	return image, has_nsfw_concept

	# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline.prepare_extra_step_kwargs
	def prepare_extra_step_kwargs(self, generator, eta):
	# 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]

	accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys())
	extra_step_kwargs = {}
	if accepts_eta:
	extra_step_kwargs["eta"] = eta

	# check if the scheduler accepts generator
	accepts_generator = "generator" in set(inspect.signature(self.scheduler.step).parameters.keys())
	if accepts_generator:
	extra_step_kwargs["generator"] = generator
	return extra_step_kwargs

	def check_inputs(
	self,
	prompt,
	image,
	mask_image,
	height,
	width,
	strength,
	callback_steps,
	output_type,
	negative_prompt=None,
	prompt_embeds=None,
	negative_prompt_embeds=None,
	ip_adapter_image=None,
	ip_adapter_image_embeds=None,
	callback_on_step_end_tensor_inputs=None,
	padding_mask_crop=None,
	):
	if strength < 0 or strength > 1:
	raise ValueError(f"The value of strength should in [0.0, 1.0] but is {strength}")

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

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

	if callback_on_step_end_tensor_inputs is not None and not all(
	k in self._callback_tensor_inputs for k in callback_on_step_end_tensor_inputs
	):
	raise ValueError(
	f"`callback_on_step_end_tensor_inputs` has to be in {self._callback_tensor_inputs}, but found {[k for k in callback_on_step_end_tensor_inputs if k not in self._callback_tensor_inputs]}"
	)

	if prompt is not None and prompt_embeds is not None:
	raise ValueError(
	f"Cannot forward both `prompt`: {prompt} and `prompt_embeds`: {prompt_embeds}. Please make sure to"
	" only forward one of the two."
	)
	elif prompt is None and prompt_embeds is None:
	raise ValueError(
	"Provide either `prompt` or `prompt_embeds`. Cannot leave both `prompt` and `prompt_embeds` undefined."
	)
	elif prompt is not None and (not isinstance(prompt, str) and not isinstance(prompt, list)):
	raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")

	if negative_prompt is not None and negative_prompt_embeds is not None:
	raise ValueError(
	f"Cannot forward both `negative_prompt`: {negative_prompt} and `negative_prompt_embeds`:"
	f" {negative_prompt_embeds}. Please make sure to only forward one of the two."
	)

	if prompt_embeds is not None and negative_prompt_embeds is not None:
	if prompt_embeds.shape != negative_prompt_embeds.shape:
	raise ValueError(
	"`prompt_embeds` and `negative_prompt_embeds` must have the same shape when passed directly, but"
	f" got: `prompt_embeds` {prompt_embeds.shape} != `negative_prompt_embeds`"
	f" {negative_prompt_embeds.shape}."
	)
	if padding_mask_crop is not None:
	if not isinstance(image, PIL.Image.Image):
	raise ValueError(
	f"The image should be a PIL image when inpainting mask crop, but is of type" f" {type(image)}."
	)
	if not isinstance(mask_image, PIL.Image.Image):
	raise ValueError(
	f"The mask image should be a PIL image when inpainting mask crop, but is of type"
	f" {type(mask_image)}."
	)
	if output_type != "pil":
	raise ValueError(f"The output type should be PIL when inpainting mask crop, but is" f" {output_type}.")

	if ip_adapter_image is not None and ip_adapter_image_embeds is not None:
	raise ValueError(
	"Provide either `ip_adapter_image` or `ip_adapter_image_embeds`. Cannot leave both `ip_adapter_image` and `ip_adapter_image_embeds` defined."
	)

	if ip_adapter_image_embeds is not None:
	if not isinstance(ip_adapter_image_embeds, list):
	raise ValueError(
	f"`ip_adapter_image_embeds` has to be of type `list` but is {type(ip_adapter_image_embeds)}"
	)
	elif ip_adapter_image_embeds[0].ndim not in [3, 4]:
	raise ValueError(
	f"`ip_adapter_image_embeds` has to be a list of 3D or 4D tensors but is {ip_adapter_image_embeds[0].ndim}D"
	)

	def prepare_latents(
	self,
	batch_size,
	num_channels_latents,
	height,
	width,
	dtype,
	device,
	generator,
	latents=None,
	image=None,
	timestep=None,
	is_strength_max=True,
	return_noise=False,
	return_image_latents=False,
	):
	shape = (batch_size, num_channels_latents, height // self.vae_scale_factor, width // self.vae_scale_factor)
	if isinstance(generator, list) and len(generator) != batch_size:
	raise ValueError(
	f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
	f" size of {batch_size}. Make sure the batch size matches the length of the generators."
	)

	if (image is None or timestep is None) and not is_strength_max:
	raise ValueError(
	"Since strength < 1. initial latents are to be initialised as a combination of Image + Noise."
	"However, either the image or the noise timestep has not been provided."
	)

	if return_image_latents or (latents is None and not is_strength_max):
	image = image.to(device=device, dtype=dtype)

	if image.shape[1] == 4:
	image_latents = image
	else:
	image_latents = self._encode_vae_image(image=image, generator=generator)
	image_latents = image_latents.repeat(batch_size // image_latents.shape[0], 1, 1, 1)

	if latents is None:
	noise = randn_tensor(shape, generator=generator, device=device, dtype=dtype)
	# if strength is 1. then initialise the latents to noise, else initial to image + noise
	latents = noise if is_strength_max else self.scheduler.add_noise(image_latents, noise, timestep)
	# if pure noise then scale the initial latents by the Scheduler's init sigma
	latents = latents * self.scheduler.init_noise_sigma if is_strength_max else latents
	else:
	noise = latents.to(device)
	latents = noise * self.scheduler.init_noise_sigma

	outputs = (latents,)

	if return_noise:
	outputs += (noise,)

	if return_image_latents:
	outputs += (image_latents,)

	return outputs

	def _encode_vae_image(self, image: torch.Tensor, generator: torch.Generator):
	if isinstance(generator, list):
	image_latents = [
	retrieve_latents(self.vae.encode(image[i : i + 1]), generator=generator[i])
	for i in range(image.shape[0])
	]
	image_latents = torch.cat(image_latents, dim=0)
	else:
	image_latents = retrieve_latents(self.vae.encode(image), generator=generator)

	image_latents = self.vae.config.scaling_factor * image_latents

	return image_latents

	def prepare_mask_latents(
	self, mask, masked_image, batch_size, height, width, dtype, device, generator
	):
	# resize the mask to latents shape as we concatenate the mask to the latents
	# we do that before converting to dtype to avoid breaking in case we're using cpu_offload
	# and half precision
	mask = torch.nn.functional.interpolate(
	mask, size=(height // self.vae_scale_factor, width // self.vae_scale_factor)
	)
	mask = mask.to(device=device, dtype=dtype)

	masked_image = masked_image.to(device=device, dtype=dtype)

	if masked_image.shape[1] == 4:
	masked_image_latents = masked_image
	else:
	masked_image_latents = self._encode_vae_image(masked_image, generator=generator)

	# duplicate mask and masked_image_latents for each generation per prompt, using mps friendly method
	if mask.shape[0] < batch_size:
	if not batch_size % mask.shape[0] == 0:
	raise ValueError(
	"The passed mask and the required batch size don't match. Masks are supposed to be duplicated to"
	f" a total batch size of {batch_size}, but {mask.shape[0]} masks were passed. Make sure the number"
	" of masks that you pass is divisible by the total requested batch size."
	)
	mask = mask.repeat(batch_size // mask.shape[0], 1, 1, 1)
	if masked_image_latents.shape[0] < batch_size:
	if not batch_size % masked_image_latents.shape[0] == 0:
	raise ValueError(
	"The passed images and the required batch size don't match. Images are supposed to be duplicated"
	f" to a total batch size of {batch_size}, but {masked_image_latents.shape[0]} images were passed."
	" Make sure the number of images that you pass is divisible by the total requested batch size."
	)
	masked_image_latents = masked_image_latents.repeat(batch_size // masked_image_latents.shape[0], 1, 1, 1)

	# aligning device to prevent device errors when concating it with the latent model input
	masked_image_latents = masked_image_latents.to(device=device, dtype=dtype)
	return mask, masked_image_latents

	# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_img2img.StableDiffusionImg2ImgPipeline.get_timesteps
	def get_timesteps(self, num_inference_steps, strength, device):
	# get the original timestep using init_timestep
	init_timestep = min(int(num_inference_steps * strength), num_inference_steps)

	t_start = max(num_inference_steps - init_timestep, 0)
	timesteps = self.scheduler.timesteps[t_start * self.scheduler.order :]
	if hasattr(self.scheduler, "set_begin_index"):
	self.scheduler.set_begin_index(t_start * self.scheduler.order)

	return timesteps, num_inference_steps - t_start

	# Copied from diffusers.pipelines.latent_consistency_models.pipeline_latent_consistency_text2img.LatentConsistencyModelPipeline.get_guidance_scale_embedding
	def get_guidance_scale_embedding(
	self, w: torch.Tensor, embedding_dim: int = 512, dtype: torch.dtype = torch.float32
	) -> torch.FloatTensor:
	"""
	See https://github.com/google-research/vdm/blob/dc27b98a554f65cdc654b800da5aa1846545d41b/model_vdm.py#L298

	Args:
	w (`torch.Tensor`):
	Generate embedding vectors with a specified guidance scale to subsequently enrich timestep embeddings.
	embedding_dim (`int`, optional, defaults to 512):
	Dimension of the embeddings to generate.
	dtype (`torch.dtype`, optional, defaults to `torch.float32`):
	Data type of the generated embeddings.

	Returns:
	`torch.FloatTensor`: Embedding vectors with shape `(len(w), embedding_dim)`.
	"""
	assert len(w.shape) == 1
	w = w * 1000.0

	half_dim = embedding_dim // 2
	emb = torch.log(torch.tensor(10000.0)) / (half_dim - 1)
	emb = torch.exp(torch.arange(half_dim, dtype=dtype) * -emb)
	emb = w.to(dtype)[:, None] * emb[None, :]
	emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1)
	if embedding_dim % 2 == 1: # zero pad
	emb = torch.nn.functional.pad(emb, (0, 1))
	assert emb.shape == (w.shape[0], embedding_dim)
	return emb

	@property
	def guidance_scale(self):
	return self._guidance_scale

	@property
	def clip_skip(self):
	return self._clip_skip

	# 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.
	@property
	def do_classifier_free_guidance(self):
	return self._guidance_scale > 1 and self.unet.config.time_cond_proj_dim is None

	@property
	def cross_attention_kwargs(self):
	return self._cross_attention_kwargs

	@property
	def num_timesteps(self):
	return self._num_timesteps

	@property
	def interrupt(self):
	return self._interrupt

	@property
	def pag_scale(self):
	return self._pag_scale

	@property
	def do_perturbed_attention_guidance(self):
	return self._pag_scale > 0

	@property
	def pag_adaptive_scaling(self):
	return self._pag_adaptive_scaling

	@property
	def do_pag_adaptive_scaling(self):
	return self._pag_adaptive_scaling > 0

	@property
	def pag_applied_layers_index(self):
	return self._pag_applied_layers_index

	@torch.no_grad()
	def __call__(
	self,
	prompt: Union[str, List[str]] = None,
	image: PipelineImageInput = None,
	mask_image: PipelineImageInput = None,
	masked_image_latents: torch.FloatTensor = None,
	height: Optional[int] = None,
	width: Optional[int] = None,
	padding_mask_crop: Optional[int] = None,
	strength: float = 1.0,
	num_inference_steps: int = 50,
	timesteps: List[int] = None,
	guidance_scale: float = 7.5,
	pag_scale: float = 0.0,
	pag_adaptive_scaling: float = 0.0,
	pag_applied_layers_index: List[str] = ["d4"],
	negative_prompt: Optional[Union[str, List[str]]] = None,
	num_images_per_prompt: Optional[int] = 1,
	eta: float = 0.0,
	generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
	latents: Optional[torch.FloatTensor] = None,
	prompt_embeds: Optional[torch.FloatTensor] = None,
	negative_prompt_embeds: Optional[torch.FloatTensor] = None,
	ip_adapter_image: Optional[PipelineImageInput] = None,
	ip_adapter_image_embeds: Optional[List[torch.FloatTensor]] = None,
	output_type: Optional[str] = "pil",
	return_dict: bool = True,
	cross_attention_kwargs: Optional[Dict[str, Any]] = None,
	clip_skip: int = None,
	callback_on_step_end: Optional[Callable[[int, int, Dict], None]] = None,
	callback_on_step_end_tensor_inputs: List[str] = ["latents"],
	**kwargs,
	):
	r"""
	The call function to the pipeline for generation.

	Args:
	prompt (`str` or `List[str]`, optional):
	The prompt or prompts to guide image generation. If not defined, you need to pass `prompt_embeds`.
	image (`torch.FloatTensor`, `PIL.Image.Image`, `np.ndarray`, `List[torch.FloatTensor]`, `List[PIL.Image.Image]`, or `List[np.ndarray]`):
	`Image`, numpy array or tensor representing an image batch to be inpainted (which parts of the image to
	be masked out with `mask_image` and repainted according to `prompt`). For both numpy array and pytorch
	tensor, the expected value range is between `[0, 1]` If it's a tensor or a list or tensors, the
	expected shape should be `(B, C, H, W)` or `(C, H, W)`. If it is a numpy array or a list of arrays, the
	expected shape should be `(B, H, W, C)` or `(H, W, C)` It can also accept image latents as `image`, but
	if passing latents directly it is not encoded again.
	mask_image (`torch.FloatTensor`, `PIL.Image.Image`, `np.ndarray`, `List[torch.FloatTensor]`, `List[PIL.Image.Image]`, or `List[np.ndarray]`):
	`Image`, numpy array or tensor representing an image batch to mask `image`. White pixels in the mask
	are repainted while black pixels are preserved. If `mask_image` is a PIL image, it is converted to a
	single channel (luminance) before use. If it's a numpy array or pytorch tensor, it should contain one
	color channel (L) instead of 3, so the expected shape for pytorch tensor would be `(B, 1, H, W)`, `(B,
	H, W)`, `(1, H, W)`, `(H, W)`. And for numpy array would be for `(B, H, W, 1)`, `(B, H, W)`, `(H, W,
	1)`, or `(H, W)`.
	height (`int`, optional, defaults to `self.unet.config.sample_size * self.vae_scale_factor`):
	The height in pixels of the generated image.
	width (`int`, optional, defaults to `self.unet.config.sample_size * self.vae_scale_factor`):
	The width in pixels of the generated image.
	padding_mask_crop (`int`, optional, defaults to `None`):
	The size of margin in the crop to be applied to the image and masking. If `None`, no crop is applied to
	image and mask_image. If `padding_mask_crop` is not `None`, it will first find a rectangular region
	with the same aspect ration of the image and contains all masked area, and then expand that area based
	on `padding_mask_crop`. The image and mask_image will then be cropped based on the expanded area before
	resizing to the original image size for inpainting. This is useful when the masked area is small while
	the image is large and contain information irrelevant for inpainting, such as background.
	strength (`float`, optional, defaults to 1.0):
	Indicates extent to transform the reference `image`. Must be between 0 and 1. `image` is used as a
	starting point and more noise is added the higher the `strength`. The number of denoising steps depends
	on the amount of noise initially added. When `strength` is 1, added noise is maximum and the denoising
	process runs for the full number of iterations specified in `num_inference_steps`. A value of 1
	essentially ignores `image`.
	num_inference_steps (`int`, optional, defaults to 50):
	The number of denoising steps. More denoising steps usually lead to a higher quality image at the
	expense of slower inference. This parameter is modulated by `strength`.
	timesteps (`List[int]`, optional):
	Custom timesteps to use for the denoising process with schedulers which support a `timesteps` argument
	in their `set_timesteps` method. If not defined, the default behavior when `num_inference_steps` is
	passed will be used. Must be in descending order.
	guidance_scale (`float`, optional, defaults to 7.5):
	A higher guidance scale value encourages the model to generate images closely linked to the text
	`prompt` at the expense of lower image quality. Guidance scale is enabled when `guidance_scale > 1`.
	negative_prompt (`str` or `List[str]`, optional):
	The prompt or prompts to guide what to not include in image generation. If not defined, you need to
	pass `negative_prompt_embeds` instead. Ignored when not using guidance (`guidance_scale < 1`).
	num_images_per_prompt (`int`, optional, defaults to 1):
	The number of images to generate per prompt.
	eta (`float`, optional, defaults to 0.0):
	Corresponds to parameter eta (η) from the [DDIM](https://arxiv.org/abs/2010.02502) paper. Only applies
	to the [`~schedulers.DDIMScheduler`], and is ignored in other schedulers.
	generator (`torch.Generator` or `List[torch.Generator]`, optional):
	A [`torch.Generator`](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make
	generation deterministic.
	latents (`torch.FloatTensor`, optional):
	Pre-generated noisy latents sampled from a Gaussian distribution, to be used as inputs for image
	generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
	tensor is generated by sampling using the supplied random `generator`.
	prompt_embeds (`torch.FloatTensor`, optional):
	Pre-generated text embeddings. Can be used to easily tweak text inputs (prompt weighting). If not
	provided, text embeddings are generated from the `prompt` input argument.
	negative_prompt_embeds (`torch.FloatTensor`, optional):
	Pre-generated negative text embeddings. Can be used to easily tweak text inputs (prompt weighting). If
	not provided, `negative_prompt_embeds` are generated from the `negative_prompt` input argument.
	ip_adapter_image: (`PipelineImageInput`, optional): Optional image input to work with IP Adapters.
	ip_adapter_image_embeds (`List[torch.FloatTensor]`, optional):
	Pre-generated image embeddings for IP-Adapter. It should be a list of length same as number of
	IP-adapters. Each element should be a tensor of shape `(batch_size, num_images, emb_dim)`. It should
	contain the negative image embedding if `do_classifier_free_guidance` is set to `True`. If not
	provided, embeddings are computed from the `ip_adapter_image` input argument.
	output_type (`str`, optional, defaults to `"pil"`):
	The output format of the generated image. Choose between `PIL.Image` or `np.array`.
	return_dict (`bool`, optional, defaults to `True`):
	Whether or not to return a [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] instead of a
	plain tuple.
	cross_attention_kwargs (`dict`, optional):
	A kwargs dictionary that if specified is passed along to the [`AttentionProcessor`] as defined in
	[`self.processor`](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py).
	clip_skip (`int`, optional):
	Number of layers to be skipped from CLIP while computing the prompt embeddings. A value of 1 means that
	the output of the pre-final layer will be used for computing the prompt embeddings.
	callback_on_step_end (`Callable`, optional):
	A function that calls at the end of each denoising steps during the inference. The function is called
	with the following arguments: `callback_on_step_end(self: DiffusionPipeline, step: int, timestep: int,
	callback_kwargs: Dict)`. `callback_kwargs` will include a list of all tensors as specified by
	`callback_on_step_end_tensor_inputs`.
	callback_on_step_end_tensor_inputs (`List`, optional):
	The list of tensor inputs for the `callback_on_step_end` function. The tensors specified in the list
	will be passed as `callback_kwargs` argument. You will only be able to include variables listed in the
	`._callback_tensor_inputs` attribute of your pipeline class.
	Examples:

	```py
	>>> import PIL
	>>> import requests
	>>> import torch
	>>> from io import BytesIO

	>>> from diffusers import StableDiffusionInpaintPipeline


	>>> def download_image(url):
	... response = requests.get(url)
	... return PIL.Image.open(BytesIO(response.content)).convert("RGB")


	>>> img_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png"
	>>> mask_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png"

	>>> init_image = download_image(img_url).resize((512, 512))
	>>> mask_image = download_image(mask_url).resize((512, 512))

	>>> pipe = StableDiffusionInpaintPipeline.from_pretrained(
	... "runwayml/stable-diffusion-inpainting", torch_dtype=torch.float16
	... )
	>>> pipe = pipe.to("cuda")

	>>> prompt = "Face of a yellow cat, high resolution, sitting on a park bench"
	>>> image = pipe(prompt=prompt, image=init_image, mask_image=mask_image).images[0]
	```

	Returns:
	[`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] or `tuple`:
	If `return_dict` is `True`, [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] is returned,
	otherwise a `tuple` is returned where the first element is a list with the generated images and the
	second element is a list of `bool`s indicating whether the corresponding generated image contains
	"not-safe-for-work" (nsfw) content.
	"""

	callback = kwargs.pop("callback", None)
	callback_steps = kwargs.pop("callback_steps", None)

	if callback is not None:
	deprecate(
	"callback",
	"1.0.0",
	"Passing `callback` as an input argument to `__call__` is deprecated, consider use `callback_on_step_end`",
	)
	if callback_steps is not None:
	deprecate(
	"callback_steps",
	"1.0.0",
	"Passing `callback_steps` as an input argument to `__call__` is deprecated, consider use `callback_on_step_end`",
	)

	# 0. Default height and width to unet
	height = height or self.unet.config.sample_size * self.vae_scale_factor
	width = width or self.unet.config.sample_size * self.vae_scale_factor

	# 1. Check inputs
	self.check_inputs(
	prompt,
	image,
	mask_image,
	height,
	width,
	strength,
	callback_steps,
	output_type,
	negative_prompt,
	prompt_embeds,
	negative_prompt_embeds,
	ip_adapter_image,
	ip_adapter_image_embeds,
	callback_on_step_end_tensor_inputs,
	padding_mask_crop,
	)

	self._guidance_scale = guidance_scale
	self._clip_skip = clip_skip
	self._cross_attention_kwargs = cross_attention_kwargs
	self._interrupt = False

	self._pag_scale = pag_scale
	self._pag_adaptive_scaling = pag_adaptive_scaling
	self._pag_applied_layers_index = pag_applied_layers_index

	# 2. Define call parameters
	if prompt is not None and isinstance(prompt, str):
	batch_size = 1
	elif prompt is not None and isinstance(prompt, list):
	batch_size = len(prompt)
	else:
	batch_size = prompt_embeds.shape[0]

	device = self._execution_device

	# 3. Encode input prompt
	text_encoder_lora_scale = (
	cross_attention_kwargs.get("scale", None) if cross_attention_kwargs is not None else None
	)
	prompt_embeds, negative_prompt_embeds = self.encode_prompt(
	prompt,
	device,
	num_images_per_prompt,
	self.do_classifier_free_guidance,
	negative_prompt,
	prompt_embeds=prompt_embeds,
	negative_prompt_embeds=negative_prompt_embeds,
	lora_scale=text_encoder_lora_scale,
	clip_skip=self.clip_skip,
	)
	# 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

	# cfg
	if self.do_classifier_free_guidance and not self.do_perturbed_attention_guidance:
	prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds])
	# pag
	elif not self.do_classifier_free_guidance and self.do_perturbed_attention_guidance:
	prompt_embeds = torch.cat([prompt_embeds, prompt_embeds])
	# both
	elif self.do_classifier_free_guidance and self.do_perturbed_attention_guidance:
	prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds, prompt_embeds])

	if ip_adapter_image is not None or ip_adapter_image_embeds is not None:
	image_embeds = self.prepare_ip_adapter_image_embeds(
	ip_adapter_image,
	ip_adapter_image_embeds,
	device,
	batch_size * num_images_per_prompt
	)

	# 4. set timesteps
	timesteps, num_inference_steps = retrieve_timesteps(self.scheduler, num_inference_steps, device, timesteps)
	timesteps, num_inference_steps = self.get_timesteps(
	num_inference_steps=num_inference_steps, strength=strength, device=device
	)
	# check that number of inference steps is not < 1 - as this doesn't make sense
	if num_inference_steps < 1:
	raise ValueError(
	f"After adjusting the num_inference_steps by strength parameter: {strength}, the number of pipeline"
	f"steps is {num_inference_steps} which is < 1 and not appropriate for this pipeline."
	)
	# at which timestep to set the initial noise (n.b. 50% if strength is 0.5)
	latent_timestep = timesteps[:1].repeat(batch_size * num_images_per_prompt)
	# create a boolean to check if the strength is set to 1. if so then initialise the latents with pure noise
	is_strength_max = strength == 1.0

	# 5. Preprocess mask and image

	if padding_mask_crop is not None:
	crops_coords = self.mask_processor.get_crop_region(mask_image, width, height, pad=padding_mask_crop)
	resize_mode = "fill"
	else:
	crops_coords = None
	resize_mode = "default"

	original_image = image
	init_image = self.image_processor.preprocess(
	image, height=height, width=width, crops_coords=crops_coords, resize_mode=resize_mode
	)
	init_image = init_image.to(dtype=torch.float32)

	# 6. Prepare latent variables
	num_channels_latents = self.vae.config.latent_channels
	num_channels_unet = self.unet.config.in_channels
	return_image_latents = num_channels_unet == 4

	latents_outputs = self.prepare_latents(
	batch_size * num_images_per_prompt,
	num_channels_latents,
	height,
	width,
	prompt_embeds.dtype,
	device,
	generator,
	latents,
	image=init_image,
	timestep=latent_timestep,
	is_strength_max=is_strength_max,
	return_noise=True,
	return_image_latents=return_image_latents,
	)

	if return_image_latents:
	latents, noise, image_latents = latents_outputs
	else:
	latents, noise = latents_outputs

	# 7. Prepare mask latent variables
	mask_condition = self.mask_processor.preprocess(
	mask_image, height=height, width=width, resize_mode=resize_mode, crops_coords=crops_coords
	)

	if masked_image_latents is None:
	masked_image = init_image * (mask_condition < 0.5)
	else:
	masked_image = masked_image_latents

	mask, masked_image_latents = self.prepare_mask_latents(
	mask_condition,
	masked_image,
	batch_size * num_images_per_prompt,
	height,
	width,
	prompt_embeds.dtype,
	device,
	generator
	)

	# 8. Check that sizes of mask, masked image and latents match
	if num_channels_unet == 9:
	# default case for runwayml/stable-diffusion-inpainting
	num_channels_mask = mask.shape[1]
	num_channels_masked_image = masked_image_latents.shape[1]
	if num_channels_latents + num_channels_mask + num_channels_masked_image != self.unet.config.in_channels:
	raise ValueError(
	f"Incorrect configuration settings! The config of `pipeline.unet`: {self.unet.config} expects"
	f" {self.unet.config.in_channels} but received `num_channels_latents`: {num_channels_latents} +"
	f" `num_channels_mask`: {num_channels_mask} + `num_channels_masked_image`: {num_channels_masked_image}"
	f" = {num_channels_latents+num_channels_masked_image+num_channels_mask}. Please verify the config of"
	" `pipeline.unet` or your `mask_image` or `image` input."
	)
	elif num_channels_unet != 4:
	raise ValueError(
	f"The unet {self.unet.__class__} should have either 4 or 9 input channels, not {self.unet.config.in_channels}."
	)

	# 9. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline
	extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)

	# 9.1 Add image embeds for IP-Adapter
	added_cond_kwargs = (
	{"image_embeds": image_embeds}
	if ip_adapter_image is not None or ip_adapter_image_embeds is not None
	else None
	)

	# 9.2 Optionally get Guidance Scale Embedding
	timestep_cond = None
	if self.unet.config.time_cond_proj_dim is not None:
	guidance_scale_tensor = torch.tensor(self.guidance_scale - 1).repeat(batch_size * num_images_per_prompt)
	timestep_cond = self.get_guidance_scale_embedding(
	guidance_scale_tensor, embedding_dim=self.unet.config.time_cond_proj_dim
	).to(device=device, dtype=latents.dtype)

	# 10. Denoising loop
	if self.do_perturbed_attention_guidance:
	down_layers = []
	mid_layers = []
	up_layers = []
	for name, module in self.unet.named_modules():
	if "attn1" in name and "to" not in name:
	layer_type = name.split(".")[0].split("_")[0]
	if layer_type == "down":
	down_layers.append(module)
	elif layer_type == "mid":
	mid_layers.append(module)
	elif layer_type == "up":
	up_layers.append(module)
	else:
	raise ValueError(f"Invalid layer type: {layer_type}")

	# change attention layer in UNet if use PAG
	if self.do_perturbed_attention_guidance:
	if self.do_classifier_free_guidance:
	replace_processor = PAGCFGIdentitySelfAttnProcessor()
	else:
	replace_processor = PAGIdentitySelfAttnProcessor()

	drop_layers = self.pag_applied_layers_index
	for drop_layer in drop_layers:
	try:
	if drop_layer[0] == "d":
	down_layers[int(drop_layer[1])].processor = replace_processor
	elif drop_layer[0] == "m":
	mid_layers[int(drop_layer[1])].processor = replace_processor
	elif drop_layer[0] == "u":
	up_layers[int(drop_layer[1])].processor = replace_processor
	else:
	raise ValueError(f"Invalid layer type: {drop_layer[0]}")
	except IndexError:
	raise ValueError(
	f"Invalid layer index: {drop_layer}. Available layers: {len(down_layers)} down layers, {len(mid_layers)} mid layers, {len(up_layers)} up layers."
	)

	num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order
	self._num_timesteps = len(timesteps)
	with self.progress_bar(total=num_inference_steps) as progress_bar:
	for i, t in enumerate(timesteps):
	if self.interrupt:
	continue

	# cfg
	if self.do_classifier_free_guidance and not self.do_perturbed_attention_guidance:
	latent_model_input = torch.cat([latents] * 2)
	mask_input = torch.cat([mask] * 2)
	masked_image_latents_input = torch.cat([masked_image_latents] * 2)
	# pag
	elif not self.do_classifier_free_guidance and self.do_perturbed_attention_guidance:
	latent_model_input = torch.cat([latents] * 2)
	mask_input = torch.cat([mask] * 2)
	masked_image_latents_input = torch.cat([masked_image_latents] * 2)
	# both
	elif self.do_classifier_free_guidance and self.do_perturbed_attention_guidance:
	latent_model_input = torch.cat([latents] * 3)
	mask_input = torch.cat([mask] * 3)
	masked_image_latents_input = torch.cat([masked_image_latents] * 3)
	# no
	else:
	latent_model_input = latents
	mask_input = mask
	masked_image_latents_input = masked_image_latents

	latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)

	if num_channels_unet == 9:

	latent_model_input = torch.cat([latent_model_input, mask_input, masked_image_latents_input], dim=1)

	# predict the noise residual
	noise_pred = self.unet(
	latent_model_input,
	t,
	encoder_hidden_states=prompt_embeds,
	timestep_cond=timestep_cond,
	cross_attention_kwargs=self.cross_attention_kwargs,
	added_cond_kwargs=added_cond_kwargs,
	return_dict=False,
	)[0]

	# perform guidance

	# cfg
	if self.do_classifier_free_guidance and not self.do_perturbed_attention_guidance:
	noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)

	delta = noise_pred_text - noise_pred_uncond
	noise_pred = noise_pred_uncond + self.guidance_scale * delta

	# pag
	elif not self.do_classifier_free_guidance and self.do_perturbed_attention_guidance:
	noise_pred_original, noise_pred_perturb = noise_pred.chunk(2)

	signal_scale = self.pag_scale
	if self.do_pag_adaptive_scaling:
	signal_scale = self.pag_scale - self.pag_adaptive_scaling * (1000 - t)
	if signal_scale < 0:
	signal_scale = 0

	noise_pred = noise_pred_original + signal_scale * (noise_pred_original - noise_pred_perturb)

	# both
	elif self.do_classifier_free_guidance and self.do_perturbed_attention_guidance:
	noise_pred_uncond, noise_pred_text, noise_pred_text_perturb = noise_pred.chunk(3)

	signal_scale = self.pag_scale
	if self.do_pag_adaptive_scaling:
	signal_scale = self.pag_scale - self.pag_adaptive_scaling * (1000 - t)
	if signal_scale < 0:
	signal_scale = 0

	noise_pred = (
	noise_pred_text
	+ (self.guidance_scale - 1.0) * (noise_pred_text - noise_pred_uncond)
	+ signal_scale * (noise_pred_text - noise_pred_text_perturb)
	)

	# compute the previous noisy sample x_t -> x_t-1
	latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0]
	if num_channels_unet == 4:
	init_latents_proper = image_latents
	if self.do_classifier_free_guidance:
	init_mask, _ = mask.chunk(2)
	else:
	init_mask = mask

	if i < len(timesteps) - 1:
	noise_timestep = timesteps[i + 1]
	init_latents_proper = self.scheduler.add_noise(
	init_latents_proper, noise, torch.tensor([noise_timestep])
	)

	latents = (1 - init_mask) * init_latents_proper + init_mask * latents

	if callback_on_step_end is not None:
	callback_kwargs = {}
	for k in callback_on_step_end_tensor_inputs:
	callback_kwargs[k] = locals()[k]
	callback_outputs = callback_on_step_end(self, i, t, callback_kwargs)

	latents = callback_outputs.pop("latents", latents)
	prompt_embeds = callback_outputs.pop("prompt_embeds", prompt_embeds)
	negative_prompt_embeds = callback_outputs.pop("negative_prompt_embeds", negative_prompt_embeds)
	mask = callback_outputs.pop("mask", mask)
	masked_image_latents = callback_outputs.pop("masked_image_latents", masked_image_latents)

	# call the callback, if provided
	if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
	progress_bar.update()
	if callback is not None and i % callback_steps == 0:
	step_idx = i // getattr(self.scheduler, "order", 1)
	callback(step_idx, t, latents)

	if not output_type == "latent":
	condition_kwargs = {}
	if isinstance(self.vae, AsymmetricAutoencoderKL):
	init_image = init_image.to(device=device, dtype=masked_image_latents.dtype)
	init_image_condition = init_image.clone()
	init_image = self._encode_vae_image(init_image, generator=generator)
	mask_condition = mask_condition.to(device=device, dtype=masked_image_latents.dtype)
	condition_kwargs = {"image": init_image_condition, "mask": mask_condition}
	image = self.vae.decode(
	latents / self.vae.config.scaling_factor, return_dict=False, generator=generator, **condition_kwargs
	)[0]
	image, has_nsfw_concept = self.run_safety_checker(image, device, prompt_embeds.dtype)
	else:
	image = latents
	has_nsfw_concept = None

	if has_nsfw_concept is None:
	do_denormalize = [True] * image.shape[0]
	else:
	do_denormalize = [not has_nsfw for has_nsfw in has_nsfw_concept]

	image = self.image_processor.postprocess(image, output_type=output_type, do_denormalize=do_denormalize)

	if padding_mask_crop is not None:
	image = [self.image_processor.apply_overlay(mask_image, original_image, i, crops_coords) for i in image]

	# Offload all models
	self.maybe_free_model_hooks()

	# change attention layer in UNet if use PAG
	if self.do_perturbed_attention_guidance:
	drop_layers = self.pag_applied_layers_index
	for drop_layer in drop_layers:
	try:
	if drop_layer[0] == "d":
	down_layers[int(drop_layer[1])].processor = AttnProcessor2_0()
	elif drop_layer[0] == "m":
	mid_layers[int(drop_layer[1])].processor = AttnProcessor2_0()
	elif drop_layer[0] == "u":
	up_layers[int(drop_layer[1])].processor = AttnProcessor2_0()
	else:
	raise ValueError(f"Invalid layer type: {drop_layer[0]}")
	except IndexError:
	raise ValueError(
	f"Invalid layer index: {drop_layer}. Available layers: {len(down_layers)} down layers, {len(mid_layers)} mid layers, {len(up_layers)} up layers."
	)

	if not return_dict:
	return (image, has_nsfw_concept)

	return StableDiffusionPipelineOutput(images=image, nsfw_content_detected=has_nsfw_concept)