



"""simple docstring"""







import glob
import os
from typing import Dict, List, Union

import torch

from diffusers.utils import is_safetensors_available


if is_safetensors_available():
		import safetensors.torch

from huggingface_hub import snapshot_download

from diffusers import DiffusionPipeline, __version__
from diffusers.schedulers.scheduling_utils import SCHEDULER_CONFIG_NAME
from diffusers.utils import CONFIG_NAME, DIFFUSERS_CACHE, ONNX_WEIGHTS_NAME, WEIGHTS_NAME





class    UpperCamelCase     (			snake_case    ):




	"""simple docstring"""






	def __init__(			self					):
			self.register_to_config()
			super().__init__()






	def 					lowerCamelCase__ (			self							,UpperCAmelCase_							,UpperCAmelCase_					):
			if dicta == dicta:
					return True
			else:
					_lowercase			,   _lowercase							:      List[Any]			=					self._remove_meta_keys(UpperCAmelCase_					)
					_lowercase			,   _lowercase							:      Union[str, Any]			=					self._remove_meta_keys(UpperCAmelCase_					)
					if configa == configa:
							print(f"""Warning !: Mismatch in keys {meta_keysa} and {meta_keysa}."""					)
							return True
			return False






	def 					lowerCamelCase__ (			self							,UpperCAmelCase_					):
			_lowercase							:      Union[str, Any]			=					[]
			_lowercase							:      int			=					config_dict.copy()
			for key in config_dict.keys():
					if key.startswith("""_"""					):
							temp_dict.pop(UpperCAmelCase_					)
							meta_keys.append(UpperCAmelCase_					)
			return (temp_dict, meta_keys)






	@torch.no_grad()
	def 					lowerCamelCase__ (			self							,UpperCAmelCase_							,**UpperCAmelCase_					):
			_lowercase							:      Tuple			=					kwargs.pop("""cache_dir"""							,UpperCAmelCase_					)
			_lowercase							:      Union[str, Any]			=					kwargs.pop("""resume_download"""							,UpperCAmelCase_					)
			_lowercase							:      List[Any]			=					kwargs.pop("""force_download"""							,UpperCAmelCase_					)
			_lowercase							:      int			=					kwargs.pop("""proxies"""							,UpperCAmelCase_					)
			_lowercase							:      Tuple			=					kwargs.pop("""local_files_only"""							,UpperCAmelCase_					)
			_lowercase							:      List[str]			=					kwargs.pop("""use_auth_token"""							,UpperCAmelCase_					)
			_lowercase							:      Optional[int]			=					kwargs.pop("""revision"""							,UpperCAmelCase_					)
			_lowercase							:      Dict			=					kwargs.pop("""torch_dtype"""							,UpperCAmelCase_					)
			_lowercase							:      Any			=					kwargs.pop("""device_map"""							,UpperCAmelCase_					)

			_lowercase							:      Union[str, Any]			=					kwargs.pop("""alpha"""							,0.5					)
			_lowercase							:      List[Any]			=					kwargs.pop("""interp"""							,UpperCAmelCase_					)

			print("""Received list"""							,UpperCAmelCase_					)
			print(f"""Combining with alpha={alpha}, interpolation mode={interp}"""					)

			_lowercase							:      Union[str, Any]			=					len(UpperCAmelCase_					)
			# Ignore result from model_index_json comparision of the two checkpoints
			_lowercase							:      List[str]			=					kwargs.pop("""force"""							,UpperCAmelCase_					)

			# If less than 2 checkpoints, nothing to merge. If more than 3, not supported for now.
			if checkpoint_count > 3 or checkpoint_count < 2:
					raise ValueError(
					    """Received incorrect number of checkpoints to merge. Ensure that either 2 or 3 checkpoints are being"""
					    """ passed."""					)

			print("""Received the right number of checkpoints"""					)
			# chkpt0, chkpt1 = pretrained_model_name_or_path_list[0:2]
			# chkpt2 = pretrained_model_name_or_path_list[2] if checkpoint_count == 3 else None

			# Validate that the checkpoints can be merged
			# Step 1: Load the model config and compare the checkpoints. We'll compare the model_index.json first while ignoring the keys starting with '_'
			_lowercase							:      Any			=					[]
			for pretrained_model_name_or_path in pretrained_model_name_or_path_list:
					_lowercase							:      Any			=					DiffusionPipeline.load_config(
					    UpperCAmelCase_							,cache_dir=UpperCAmelCase_							,resume_download=UpperCAmelCase_							,force_download=UpperCAmelCase_							,proxies=UpperCAmelCase_							,local_files_only=UpperCAmelCase_							,use_auth_token=UpperCAmelCase_							,revision=UpperCAmelCase_							,)
					config_dicts.append(UpperCAmelCase_					)

			_lowercase							:      Dict			=					True
			for idx in range(1							,len(UpperCAmelCase_					)					):
					comparison_result &= self._compare_model_configs(config_dicts[idx - 1]							,config_dicts[idx]					)
					if not force and comparison_result is False:
							raise ValueError("""Incompatible checkpoints. Please check model_index.json for the models."""					)
							print(config_dicts[0]							,config_dicts[1]					)
			print("""Compatible model_index.json files found"""					)
			# Step 2: Basic Validation has succeeded. Let's download the models and save them into our local files.
			_lowercase							:      str			=					[]
			for pretrained_model_name_or_path, config_dict in zip(UpperCAmelCase_							,UpperCAmelCase_					):
					_lowercase							:      List[str]			=					[k for k in config_dict.keys() if not k.startswith("""_"""					)]
					_lowercase							:      Tuple			=					[os.path.join(UpperCAmelCase_							,"""*"""					) for k in folder_names]
					allow_patterns += [
					    WEIGHTS_NAME,
					    SCHEDULER_CONFIG_NAME,
					    CONFIG_NAME,
					    ONNX_WEIGHTS_NAME,
					    DiffusionPipeline.config_name,
					]
					_lowercase							:      Union[str, Any]			=					config_dict.get("""_class_name"""					)
					_lowercase							:      Any			=					{"""diffusers""": __version__, """pipeline_class""": requested_pipeline_class}

					_lowercase							:      str			=					(
					    pretrained_model_name_or_path
					    if os.path.isdir(UpperCAmelCase_					)
					    else snapshot_download(
					        UpperCAmelCase_							,cache_dir=UpperCAmelCase_							,resume_download=UpperCAmelCase_							,proxies=UpperCAmelCase_							,local_files_only=UpperCAmelCase_							,use_auth_token=UpperCAmelCase_							,revision=UpperCAmelCase_							,allow_patterns=UpperCAmelCase_							,user_agent=UpperCAmelCase_							,)
					)
					print("""Cached Folder"""							,UpperCAmelCase_					)
					cached_folders.append(UpperCAmelCase_					)

			# Step 3:-
			# Load the first checkpoint as a diffusion pipeline and modify its module state_dict in place
			_lowercase							:      Dict			=					DiffusionPipeline.from_pretrained(
			    cached_folders[0]							,torch_dtype=UpperCAmelCase_							,device_map=UpperCAmelCase_					)
			final_pipe.to(self.device					)

			_lowercase							:      Tuple			=					None
			if len(UpperCAmelCase_					) > 2:
					_lowercase							:      List[str]			=					os.path.join(cached_folders[2]					)

			if interp == "sigmoid":
					_lowercase							:      Any			=					CheckpointMergerPipeline.sigmoid
			elif interp == "inv_sigmoid":
					_lowercase							:      Union[str, Any]			=					CheckpointMergerPipeline.inv_sigmoid
			elif interp == "add_diff":
					_lowercase							:      List[Any]			=					CheckpointMergerPipeline.add_difference
			else:
					_lowercase							:      Union[str, Any]			=					CheckpointMergerPipeline.weighted_sum

			# Find each module's state dict.
			for attr in final_pipe.config.keys():
					if not attr.startswith("""_"""					):
							_lowercase							:      Any			=					os.path.join(cached_folders[1]							,UpperCAmelCase_					)
							if os.path.exists(UpperCAmelCase_					):
									_lowercase							:      Union[str, Any]			=					[
									    *glob.glob(os.path.join(UpperCAmelCase_							,"""*.safetensors"""					)					),
									    *glob.glob(os.path.join(UpperCAmelCase_							,"""*.bin"""					)					),
									]
									_lowercase							:      int			=					files[0] if len(UpperCAmelCase_					) > 0 else None
							if len(UpperCAmelCase_					) < 3:
									_lowercase							:      Union[str, Any]			=					None
							else:
									_lowercase							:      str			=					os.path.join(cached_folders[2]							,UpperCAmelCase_					)
									if os.path.exists(UpperCAmelCase_					):
											_lowercase							:      Optional[int]			=					[
											    *glob.glob(os.path.join(UpperCAmelCase_							,"""*.safetensors"""					)					),
											    *glob.glob(os.path.join(UpperCAmelCase_							,"""*.bin"""					)					),
											]
											_lowercase							:      Any			=					files[0] if len(UpperCAmelCase_					) > 0 else None
                # For an attr if both checkpoint_path_1 and 2 are None, ignore.
                # If atleast one is present, deal with it according to interp method, of course only if the state_dict keys match.
							if checkpoint_path_a is None and checkpoint_path_a is None:
									print(f"""Skipping {attr}: not present in 2nd or 3d model"""					)
									continue
							try:
									_lowercase							:      int			=					getattr(UpperCAmelCase_							,UpperCAmelCase_					)
									if isinstance(UpperCAmelCase_							,UpperCAmelCase_					):  # ignore requires_safety_checker boolean
											continue
									_lowercase							:      Tuple			=					getattr(UpperCAmelCase_							,"""state_dict"""					)
									_lowercase							:      List[str]			=					theta_a()

									_lowercase							:      int			=					getattr(UpperCAmelCase_							,"""load_state_dict"""					)
									_lowercase							:      int			=					(
									    safetensors.torch.load_file(UpperCAmelCase_					)
									    if (is_safetensors_available() and checkpoint_path_a.endswith(""".safetensors"""					))
									    else torch.load(UpperCAmelCase_							,map_location="""cpu"""					)
									)
									_lowercase							:      int			=					None
									if checkpoint_path_a:
											_lowercase							:      Union[str, Any]			=					(
											    safetensors.torch.load_file(UpperCAmelCase_					)
											    if (is_safetensors_available() and checkpoint_path_a.endswith(""".safetensors"""					))
											    else torch.load(UpperCAmelCase_							,map_location="""cpu"""					)
											)

									if not theta_a.keys() == theta_a.keys():
											print(f"""Skipping {attr}: key mismatch"""					)
											continue
									if theta_a and not theta_a.keys() == theta_a.keys():
											print(f"""Skipping {attr}:y mismatch"""					)
							except Exception as e:
									print(f"""Skipping {attr} do to an unexpected error: {str(UpperCAmelCase_					)}"""					)
									continue
							print(f"""MERGING {attr}"""					)

							for key in theta_a.keys():
									if theta_a:
											_lowercase							:      Any			=					theta_func(theta_a[key]							,theta_a[key]							,theta_a[key]							,UpperCAmelCase_					)
									else:
											_lowercase							:      str			=					theta_func(theta_a[key]							,theta_a[key]							,UpperCAmelCase_							,UpperCAmelCase_					)

							del theta_a
							del theta_a
							update_theta_a(UpperCAmelCase_					)

							del theta_a
			return final_pipe






	@staticmethod
	def 					lowerCamelCase__ (			UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_					):
			return ((1 - alpha) * thetaa) + (alpha * thetaa)






	@staticmethod
	def 					lowerCamelCase__ (			UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_					):
			_lowercase							:      Dict			=					alpha * alpha * (3 - (2 * alpha))
			return thetaa + ((thetaa - thetaa) * alpha)






	@staticmethod
	def 					lowerCamelCase__ (			UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_					):
			import math

			_lowercase							:      Dict			=					0.5 - math.sin(math.asin(1.0 - 2.0 * alpha					) / 3.0					)
			return thetaa + ((thetaa - thetaa) * alpha)






	@staticmethod
	def 					lowerCamelCase__ (			UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_							,UpperCAmelCase_					):
			return thetaa + (thetaa - thetaa) * (1.0 - alpha)











import inspect
from typing import List, Optional, Union

import torch
from torch import nn
from torch.nn import functional as F
from torchvision import transforms
from transformers import CLIPImageProcessor, CLIPModel, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    DPMSolverMultistepScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput




class 							a_ (						nn.Module		):


							'''simple docstring'''






							def __init__(		self			,			lowercase_			,			lowercase_=1.0   )					->					Any:
														'''simple docstring'''

														super().__init__()

														lowerCAmelCase_										=     cut_size
														lowerCAmelCase_										=     cut_power






							def      _lowercase       (		self			,			lowercase_			,			lowercase_   )					->					int:
														'''simple docstring'''

														lowerCAmelCase_						,   lowerCAmelCase_										=     pixel_values.shape[2:4]
														lowerCAmelCase_										=     min(lowercase_			,			lowercase_   )
														lowerCAmelCase_										=     min(lowercase_			,			lowercase_			,			self.cut_size   )
														lowerCAmelCase_										=     []
														for _ in range(lowercase_   ):
																					lowerCAmelCase_										=     int(torch.rand([]   ) ** self.cut_power * (max_size - min_size) + min_size   )
																					lowerCAmelCase_										=     torch.randint(0			,			sideX - size + 1			,			()   )
																					lowerCAmelCase_										=     torch.randint(0			,			sideY - size + 1			,			()   )
																					lowerCAmelCase_										=     pixel_values[:, :, offsety : offsety + size, offsetx : offsetx + size]
																					cutouts.append(F.adaptive_avg_poolad(lowercase_			,			self.cut_size   )   )
														return torch.cat(lowercase_   )


def      lowerCamelCase					(						a_ ,						a_	)	->			Optional[int]:
							lowerCAmelCase_										=     F.normalize(a_ ,						dim=-1	)
							lowerCAmelCase_										=     F.normalize(a_ ,						dim=-1	)
							return (x - y).norm(dim=-1	).div(2	).arcsin().pow(2	).mul(2	)
def      lowerCamelCase					(						a_ ,						a_	)	->			int:
							for param in model.parameters():
														lowerCAmelCase_										=     value




class 							a_ (						a_		):


							'''simple docstring'''






							def __init__(		self			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			)					->					str:
														'''simple docstring'''

														super().__init__()
														self.register_modules(
														    vae=lowercase_			,			text_encoder=lowercase_			,			clip_model=lowercase_			,			tokenizer=lowercase_			,			unet=lowercase_			,			scheduler=lowercase_			,			feature_extractor=lowercase_			,			)

														lowerCAmelCase_										=     transforms.Normalize(mean=feature_extractor.image_mean			,			std=feature_extractor.image_std   )
														lowerCAmelCase_										=     (
														    feature_extractor.size
														    if isinstance(feature_extractor.size			,			lowercase_   )
														    else feature_extractor.size['shortest_edge']
														)
														lowerCAmelCase_										=     MakeCutouts(self.cut_out_size   )

														set_requires_grad(self.text_encoder			,			lowercase_   )
														set_requires_grad(self.clip_model			,			lowercase_   )

							def      _lowercase       (		self			,			lowercase_ = "auto"   )					->					Union[str, Any]:
														'''simple docstring'''

														if slice_size == "auto":
																					# half the attention head size is usually a good trade-off between
																					# speed and memory
																					lowerCAmelCase_										=     self.unet.config.attention_head_dim // 2
														self.unet.set_attention_slice(lowercase_   )

							def      _lowercase       (		self   )					->					List[Any]:
														'''simple docstring'''

														self.enable_attention_slicing(lowercase_   )

							def      _lowercase       (		self   )					->					str:
														'''simple docstring'''

														set_requires_grad(self.vae			,			lowercase_   )

							def      _lowercase       (		self   )					->					List[str]:
														'''simple docstring'''

														set_requires_grad(self.vae			,			lowercase_   )

							def      _lowercase       (		self   )					->					List[str]:
														'''simple docstring'''

														set_requires_grad(self.unet			,			lowercase_   )

							def      _lowercase       (		self   )					->					Tuple:
														'''simple docstring'''

														set_requires_grad(self.unet			,			lowercase_   )

							@torch.enable_grad()
							def      _lowercase       (		self			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_=True			,			)					->					Union[str, Any]:
														'''simple docstring'''

														lowerCAmelCase_										=     latents.detach().requires_grad_()

														lowerCAmelCase_										=     self.scheduler.scale_model_input(lowercase_			,			lowercase_   )

														# predict the noise residual
														lowerCAmelCase_										=     self.unet(lowercase_			,			lowercase_			,			encoder_hidden_states=lowercase_   ).sample

														if isinstance(self.scheduler			,			(PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)   ):
																					lowerCAmelCase_										=     self.scheduler.alphas_cumprod[timestep]
																					lowerCAmelCase_										=     1 - alpha_prod_t
																					# compute predicted original sample from predicted noise also called
																					# "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
																					lowerCAmelCase_										=     (latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5

																					lowerCAmelCase_										=     torch.sqrt(lowercase_   )
																					lowerCAmelCase_										=     pred_original_sample * (fac) + latents * (1 - fac)
														elif isinstance(self.scheduler			,			lowercase_   ):
																					lowerCAmelCase_										=     self.scheduler.sigmas[index]
																					lowerCAmelCase_										=     latents - sigma * noise_pred
														else:
																					raise ValueError(f'''scheduler type {type(self.scheduler   )} not supported'''   )

														lowerCAmelCase_										=     1 / self.vae.config.scaling_factor * sample
														lowerCAmelCase_										=     self.vae.decode(lowercase_   ).sample
														lowerCAmelCase_										=     (image / 2 + 0.5).clamp(0			,			1   )

														if use_cutouts:
																					lowerCAmelCase_										=     self.make_cutouts(lowercase_			,			lowercase_   )
														else:
																					lowerCAmelCase_										=     transforms.Resize(self.cut_out_size   )(lowercase_   )
														lowerCAmelCase_										=     self.normalize(lowercase_   ).to(latents.dtype   )

														lowerCAmelCase_										=     self.clip_model.get_image_features(lowercase_   )
														lowerCAmelCase_										=     image_embeddings_clip / image_embeddings_clip.norm(p=2			,			dim=-1			,			keepdim=lowercase_   )

														if use_cutouts:
																					lowerCAmelCase_										=     spherical_dist_loss(lowercase_			,			lowercase_   )
																					lowerCAmelCase_										=     dists.view([num_cutouts, sample.shape[0], -1]   )
																					lowerCAmelCase_										=     dists.sum(2   ).mean(0   ).sum() * clip_guidance_scale
														else:
																					lowerCAmelCase_										=     spherical_dist_loss(lowercase_			,			lowercase_   ).mean() * clip_guidance_scale

														lowerCAmelCase_										=     -torch.autograd.grad(lowercase_			,			lowercase_   )[0]

														if isinstance(self.scheduler			,			lowercase_   ):
																					lowerCAmelCase_										=     latents.detach() + grads * (sigma**2)
																					lowerCAmelCase_										=     noise_pred_original
														else:
																					lowerCAmelCase_										=     noise_pred_original - torch.sqrt(lowercase_   ) * grads
														return noise_pred, latents






							@torch.no_grad()
							def __call__(		self			,			lowercase_			,			lowercase_ = 5_1_2			,			lowercase_ = 5_1_2			,			lowercase_ = 5_0			,			lowercase_ = 7.5			,			lowercase_ = 1			,			lowercase_ = 0.0			,			lowercase_ = 1_0_0			,			lowercase_ = None			,			lowercase_ = 4			,			lowercase_ = True			,			lowercase_ = None			,			lowercase_ = None			,			lowercase_ = "pil"			,			lowercase_ = True			,			)					->					str:
														'''simple docstring'''

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

														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}.'''   )

														# get prompt text embeddings
														lowerCAmelCase_										=     self.tokenizer(
														    lowercase_			,			padding='max_length'			,			max_length=self.tokenizer.model_max_length			,			truncation=lowercase_			,			return_tensors='pt'			,			)
														lowerCAmelCase_										=     self.text_encoder(text_input.input_ids.to(self.device   )   )[0]
														# duplicate text embeddings for each generation per prompt
														lowerCAmelCase_										=     text_embeddings.repeat_interleave(lowercase_			,			dim=0   )

														if clip_guidance_scale > 0:
																					if clip_prompt is not None:
																												lowerCAmelCase_										=     self.tokenizer(
																												    lowercase_			,			padding='max_length'			,			max_length=self.tokenizer.model_max_length			,			truncation=lowercase_			,			return_tensors='pt'			,			).input_ids.to(self.device   )
																					else:
																												lowerCAmelCase_										=     text_input.input_ids.to(self.device   )
																					lowerCAmelCase_										=     self.clip_model.get_text_features(lowercase_   )
																					lowerCAmelCase_										=     text_embeddings_clip / text_embeddings_clip.norm(p=2			,			dim=-1			,			keepdim=lowercase_   )
																					# duplicate text embeddings clip for each generation per prompt
																					lowerCAmelCase_										=     text_embeddings_clip.repeat_interleave(lowercase_			,			dim=0   )

														# 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.
														lowerCAmelCase_										=     guidance_scale > 1.0
														# get unconditional embeddings for classifier free guidance
														if do_classifier_free_guidance:
																					lowerCAmelCase_										=     text_input.input_ids.shape[-1]
																					lowerCAmelCase_										=     self.tokenizer(['']			,			padding='max_length'			,			max_length=lowercase_			,			return_tensors='pt'   )
																					lowerCAmelCase_										=     self.text_encoder(uncond_input.input_ids.to(self.device   )   )[0]
																					# duplicate unconditional embeddings for each generation per prompt
																					lowerCAmelCase_										=     uncond_embeddings.repeat_interleave(lowercase_			,			dim=0   )

																					# 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
																					lowerCAmelCase_										=     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`.
														lowerCAmelCase_										=     (batch_size * num_images_per_prompt, self.unet.config.in_channels, height // 8, width // 8)
														lowerCAmelCase_										=     text_embeddings.dtype
														if latents is None:
																					if self.device.type == "mps":
																												# randn does not work reproducibly on mps
																												lowerCAmelCase_										=     torch.randn(lowercase_			,			generator=lowercase_			,			device='cpu'			,			dtype=lowercase_   ).to(
																												    self.device   )
																					else:
																												lowerCAmelCase_										=     torch.randn(lowercase_			,			generator=lowercase_			,			device=self.device			,			dtype=lowercase_   )
														else:
																					if latents.shape != latents_shape:
																												raise ValueError(f'''Unexpected latents shape, got {latents.shape}, expected {latents_shape}'''   )
																					lowerCAmelCase_										=     latents.to(self.device   )

														# set timesteps
														lowerCAmelCase_										=     'offset' in set(inspect.signature(self.scheduler.set_timesteps   ).parameters.keys()   )
														lowerCAmelCase_										=     {}
														if accepts_offset:
																					lowerCAmelCase_										=     1

														self.scheduler.set_timesteps(lowercase_			,			**lowercase_   )

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

														# scale the initial noise by the standard deviation required by the scheduler
														lowerCAmelCase_										=     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]
														lowerCAmelCase_										=     'eta' in set(inspect.signature(self.scheduler.step   ).parameters.keys()   )
														lowerCAmelCase_										=     {}
														if accepts_eta:
																					lowerCAmelCase_										=     eta

														# check if the scheduler accepts generator
														lowerCAmelCase_										=     'generator' in set(inspect.signature(self.scheduler.step   ).parameters.keys()   )
														if accepts_generator:
																					lowerCAmelCase_										=     generator

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

																					# predict the noise residual
																					lowerCAmelCase_										=     self.unet(lowercase_			,			lowercase_			,			encoder_hidden_states=lowercase_   ).sample

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

																					# perform clip guidance
																					if clip_guidance_scale > 0:
																												lowerCAmelCase_										=     (
																												    text_embeddings.chunk(2   )[1] if do_classifier_free_guidance else text_embeddings
																												)
																												lowerCAmelCase_						,   lowerCAmelCase_										=     self.cond_fn(
																												    lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			lowercase_			,			)

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

														# scale and decode the image latents with vae
														lowerCAmelCase_										=     1 / self.vae.config.scaling_factor * latents
														lowerCAmelCase_										=     self.vae.decode(lowercase_   ).sample

														lowerCAmelCase_										=     (image / 2 + 0.5).clamp(0			,			1   )
														lowerCAmelCase_										=     image.cpu().permute(0			,			2			,			3			,			1   ).numpy()

														if output_type == "pil":
																					lowerCAmelCase_										=     self.numpy_to_pil(lowercase_   )

														if not return_dict:
																					return (image, None)

														return StableDiffusionPipelineOutput(images=lowercase_			,			nsfw_content_detected=lowercase_   )



