


"""simple docstring"""



import inspect
from typing import Optional, Union

import numpy as np
import PIL
import torch
from torch.nn import functional as F
from torchvision import transforms
from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTextModel, CLIPTokenizer

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







def   __lowerCAmelCase						(						lowercase  :  Optional[Any]						,							lowercase  :  List[Any]						,							lowercase  :  List[Any]			)     ->						Optional[Any]:


    """simple docstring"""





    if isinstance(lowerCAmelCase__						,							torch.Tensor			):
        return image
    elif isinstance(lowerCAmelCase__						,							PIL.Image.Image			):
        snake_case   :				List[str]				 =   [image]

    if isinstance(image[0]						,							PIL.Image.Image			):
        snake_case   :				Tuple				 =   [np.array(i.resize((w, h)						,							resample=PIL_INTERPOLATION["lanczos"]			)			)[None, :] for i in image]
        snake_case   :				List[Any]				 =   np.concatenate(lowerCAmelCase__						,							axis=0			)
        snake_case   :				int				 =   np.array(lowerCAmelCase__			).astype(np.floataa			) / 255.0
        snake_case   :				Tuple				 =   image.transpose(0						,							3						,							1						,							2			)
        snake_case   :				Optional[Any]				 =   2.0 * image - 1.0
        snake_case   :				List[Any]				 =   torch.from_numpy(lowerCAmelCase__			)
    elif isinstance(image[0]						,							torch.Tensor			):
        snake_case   :				int				 =   torch.cat(lowerCAmelCase__						,							dim=0			)
    return image







def   __lowerCAmelCase						(						lowercase  :  List[Any]						,							lowercase  :  int						,							lowercase  :  Union[str, Any]						,							lowercase  :  Any=0.9995			)     ->						List[str]:


    """simple docstring"""





    if not isinstance(lowerCAmelCase__						,							np.ndarray			):
        snake_case   :				str				 =   True
        snake_case   :				Tuple				 =   va.device
        snake_case   :				str				 =   va.cpu().numpy()
        snake_case   :				List[Any]				 =   va.cpu().numpy()

    snake_case   :				Optional[int]				 =   np.sum(va * va / (np.linalg.norm(lowerCAmelCase__			) * np.linalg.norm(lowerCAmelCase__			))			)
    if np.abs(lowerCAmelCase__			) > DOT_THRESHOLD:
        snake_case   :				Union[str, Any]				 =   (1 - t) * va + t * va
    else:
        snake_case   :				Dict				 =   np.arccos(lowerCAmelCase__			)
        snake_case   :				Tuple				 =   np.sin(lowerCAmelCase__			)
        snake_case   :				List[str]				 =   theta_a * t
        snake_case   :				Tuple				 =   np.sin(lowerCAmelCase__			)
        snake_case   :				Optional[int]				 =   np.sin(theta_a - theta_t			) / sin_theta_a
        snake_case   :				Tuple				 =   sin_theta_t / sin_theta_a
        snake_case   :				Any				 =   sa * va + sa * va

    if inputs_are_torch:
        snake_case   :				List[Any]				 =   torch.from_numpy(lowerCAmelCase__			).to(lowerCAmelCase__			)

    return va







def   __lowerCAmelCase						(						lowercase  :  str						,							lowercase  :  Optional[Any]			)     ->						Tuple:


    """simple docstring"""





    snake_case   :				List[Any]				 =   F.normalize(lowerCAmelCase__						,							dim=-1			)
    snake_case   :				Any				 =   F.normalize(lowerCAmelCase__						,							dim=-1			)
    return (x - y).norm(dim=-1			).div(2			).arcsin().pow(2			).mul(2			)







def   __lowerCAmelCase						(						lowercase  :  Optional[int]						,							lowercase  :  Tuple			)     ->						Dict:


    """simple docstring"""





    for param in model.parameters():
        snake_case   :				List[str]				 =   value







class _lowerCAmelCase    (				_lowerCAmelCase						):







   def __init__(     self						,     UpperCamelCase__						,     UpperCamelCase__						,     UpperCamelCase__						,     UpperCamelCase__						,     UpperCamelCase__						,     UpperCamelCase__						,     UpperCamelCase__						,     UpperCamelCase__=None						,     UpperCamelCase__=None						,     UpperCamelCase__=None						,     )     ->		Any:

       '''simple docstring'''




       super().__init__()
       self.register_modules(
           vae=SCREAMING_SNAKE_CASE_						,     text_encoder=SCREAMING_SNAKE_CASE_						,     clip_model=SCREAMING_SNAKE_CASE_						,     tokenizer=SCREAMING_SNAKE_CASE_						,     unet=SCREAMING_SNAKE_CASE_						,     scheduler=SCREAMING_SNAKE_CASE_						,     feature_extractor=SCREAMING_SNAKE_CASE_						,     coca_model=SCREAMING_SNAKE_CASE_						,     coca_tokenizer=SCREAMING_SNAKE_CASE_						,     coca_transform=SCREAMING_SNAKE_CASE_						,     )
       snake_case   :				Optional[int]				 =   (
           feature_extractor.size
           if isinstance(feature_extractor.size						,     SCREAMING_SNAKE_CASE_						)
           else feature_extractor.size["""shortest_edge"""]
       )
       snake_case   :				Optional[int]				 =   transforms.Normalize(mean=feature_extractor.image_mean						,     std=feature_extractor.image_std						)
       set_requires_grad(self.text_encoder						,     SCREAMING_SNAKE_CASE_						)
       set_requires_grad(self.clip_model						,     SCREAMING_SNAKE_CASE_						)







   def 			lowerCamelCase		(     self						,     UpperCamelCase__ = "auto"						)     ->		Tuple:

       '''simple docstring'''




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







   def 			lowerCamelCase		(     self						)     ->		Optional[Any]:

       '''simple docstring'''




       self.enable_attention_slicing(SCREAMING_SNAKE_CASE_						)







   def 			lowerCamelCase		(     self						)     ->		Optional[Any]:

       '''simple docstring'''




       set_requires_grad(self.vae						,     SCREAMING_SNAKE_CASE_						)







   def 			lowerCamelCase		(     self						)     ->		Optional[int]:

       '''simple docstring'''




       set_requires_grad(self.vae						,     SCREAMING_SNAKE_CASE_						)







   def 			lowerCamelCase		(     self						)     ->		Optional[Any]:

       '''simple docstring'''




       set_requires_grad(self.unet						,     SCREAMING_SNAKE_CASE_						)







   def 			lowerCamelCase		(     self						)     ->		Dict:

       '''simple docstring'''




       set_requires_grad(self.unet						,     SCREAMING_SNAKE_CASE_						)







   def 			lowerCamelCase		(     self						,     UpperCamelCase__						,     UpperCamelCase__						,     UpperCamelCase__						)     ->		int:

       '''simple docstring'''




       snake_case   :				Dict				 =   min(int(num_inference_steps * strength						)						,     SCREAMING_SNAKE_CASE_						)

       snake_case   :				Optional[int]				 =   max(num_inference_steps - init_timestep						,     0						)
       snake_case   :				Any				 =   self.scheduler.timesteps[t_start:]

       return timesteps, num_inference_steps - t_start







   def 			lowerCamelCase		(     self						,     UpperCamelCase__						,     UpperCamelCase__						,     UpperCamelCase__						,     UpperCamelCase__						,     UpperCamelCase__						,     UpperCamelCase__=None						)     ->		Optional[Any]:

       '''simple docstring'''




       if not isinstance(SCREAMING_SNAKE_CASE_						,     torch.Tensor						):
           raise ValueError(F'`image` has to be of type `torch.Tensor` but is {type(SCREAMING_SNAKE_CASE_						)}'						)

       snake_case   :				int				 =   image.to(device=SCREAMING_SNAKE_CASE_						,     dtype=SCREAMING_SNAKE_CASE_						)

       if isinstance(SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						):
           snake_case   :				Tuple				 =   [
               self.vae.encode(image[i : i + 1]						).latent_dist.sample(generator[i]						) for i in range(SCREAMING_SNAKE_CASE_						)
           ]
           snake_case   :				Optional[Any]				 =   torch.cat(SCREAMING_SNAKE_CASE_						,     dim=0						)
       else:
           snake_case   :				Tuple				 =   self.vae.encode(SCREAMING_SNAKE_CASE_						).latent_dist.sample(SCREAMING_SNAKE_CASE_						)

       # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
       snake_case   :				Tuple				 =   0.18215 * init_latents
       snake_case   :				Union[str, Any]				 =   init_latents.repeat_interleave(SCREAMING_SNAKE_CASE_						,     dim=0						)

       snake_case   :				Any				 =   randn_tensor(init_latents.shape						,     generator=SCREAMING_SNAKE_CASE_						,     device=SCREAMING_SNAKE_CASE_						,     dtype=SCREAMING_SNAKE_CASE_						)

       # get latents
       snake_case   :				Tuple				 =   self.scheduler.add_noise(SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						)
       snake_case   :				Optional[Any]				 =   init_latents

       return latents







   def 			lowerCamelCase		(     self						,     UpperCamelCase__						)     ->		int:

       '''simple docstring'''




       snake_case   :				str				 =   self.coca_transform(SCREAMING_SNAKE_CASE_						).unsqueeze(0						)
       with torch.no_grad(), torch.cuda.amp.autocast():
           snake_case   :				Any				 =   self.coca_model.generate(transformed_image.to(device=self.device						,     dtype=self.coca_model.dtype						)						)
       snake_case   :				List[str]				 =   self.coca_tokenizer.decode(generated[0].cpu().numpy()						)
       return generated.split("<end_of_text>"						)[0].replace("<start_of_text>"						,     ""						).rstrip(" .,"						)







   def 			lowerCamelCase		(     self						,     UpperCamelCase__						,     UpperCamelCase__						)     ->		List[str]:

       '''simple docstring'''




       snake_case   :				Tuple				 =   self.feature_extractor.preprocess(SCREAMING_SNAKE_CASE_						)
       snake_case   :				List[Any]				 =   torch.from_numpy(clip_image_input["pixel_values"][0]						).unsqueeze(0						).to(self.device						).half()
       snake_case   :				Tuple				 =   self.clip_model.get_image_features(SCREAMING_SNAKE_CASE_						)
       snake_case   :				List[Any]				 =   image_embeddings_clip / image_embeddings_clip.norm(p=2						,     dim=-1						,     keepdim=SCREAMING_SNAKE_CASE_						)
       snake_case   :				Dict				 =   image_embeddings_clip.repeat_interleave(SCREAMING_SNAKE_CASE_						,     dim=0						)
       return image_embeddings_clip







   @torch.enable_grad()
   def 			lowerCamelCase		(     self						,     UpperCamelCase__						,     UpperCamelCase__						,     UpperCamelCase__						,     UpperCamelCase__						,     UpperCamelCase__						,     UpperCamelCase__						,     UpperCamelCase__						,     )     ->		Union[str, Any]:

       '''simple docstring'''




       snake_case   :				int				 =   latents.detach().requires_grad_()

       snake_case   :				Dict				 =   self.scheduler.scale_model_input(SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						)

       # predict the noise residual
       snake_case   :				Tuple				 =   self.unet(SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						,     encoder_hidden_states=SCREAMING_SNAKE_CASE_						).sample

       if isinstance(self.scheduler						,     (PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)						):
           snake_case   :				int				 =   self.scheduler.alphas_cumprod[timestep]
           snake_case   :				str				 =   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
           snake_case   :				List[Any]				 =   (latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5

           snake_case   :				Any				 =   torch.sqrt(SCREAMING_SNAKE_CASE_						)
           snake_case   :				Tuple				 =   pred_original_sample * (fac) + latents * (1 - fac)
       elif isinstance(self.scheduler						,     SCREAMING_SNAKE_CASE_						):
           snake_case   :				Optional[Any]				 =   self.scheduler.sigmas[index]
           snake_case   :				Tuple				 =   latents - sigma * noise_pred
       else:
           raise ValueError(F'scheduler type {type(self.scheduler						)} not supported'						)

       # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
       snake_case   :				Tuple				 =   1 / 0.18215 * sample
       snake_case   :				str				 =   self.vae.decode(SCREAMING_SNAKE_CASE_						).sample
       snake_case   :				List[Any]				 =   (image / 2 + 0.5).clamp(0						,     1						)

       snake_case   :				List[Any]				 =   transforms.Resize(self.feature_extractor_size						)(SCREAMING_SNAKE_CASE_						)
       snake_case   :				Any				 =   self.normalize(SCREAMING_SNAKE_CASE_						).to(latents.dtype						)

       snake_case   :				str				 =   self.clip_model.get_image_features(SCREAMING_SNAKE_CASE_						)
       snake_case   :				List[Any]				 =   image_embeddings_clip / image_embeddings_clip.norm(p=2						,     dim=-1						,     keepdim=SCREAMING_SNAKE_CASE_						)

       snake_case   :				str				 =   spherical_dist_loss(SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						).mean() * clip_guidance_scale

       snake_case   :				str				 =   -torch.autograd.grad(SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						)[0]

       if isinstance(self.scheduler						,     SCREAMING_SNAKE_CASE_						):
           snake_case   :				Optional[int]				 =   latents.detach() + grads * (sigma**2)
           snake_case   :				int				 =   noise_pred_original
       else:
           snake_case   :				Optional[Any]				 =   noise_pred_original - torch.sqrt(SCREAMING_SNAKE_CASE_						) * grads
       return noise_pred, latents







   @torch.no_grad()
   def __call__(     self						,     UpperCamelCase__						,     UpperCamelCase__						,     UpperCamelCase__ = None						,     UpperCamelCase__ = None						,     UpperCamelCase__ = 512						,     UpperCamelCase__ = 512						,     UpperCamelCase__ = 0.6						,     UpperCamelCase__ = 50						,     UpperCamelCase__ = 7.5						,     UpperCamelCase__ = 1						,     UpperCamelCase__ = 0.0						,     UpperCamelCase__ = 100						,     UpperCamelCase__ = None						,     UpperCamelCase__ = "pil"						,     UpperCamelCase__ = True						,     UpperCamelCase__ = 0.8						,     UpperCamelCase__ = 0.1						,     UpperCamelCase__ = 0.1						,     )     ->		Optional[int]:

       '''simple docstring'''




       if isinstance(SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						) and len(SCREAMING_SNAKE_CASE_						) != batch_size:
           raise ValueError(F'You have passed {batch_size} batch_size, but only {len(SCREAMING_SNAKE_CASE_						)} generators.'						)

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

       if isinstance(SCREAMING_SNAKE_CASE_						,     torch.Generator						) and batch_size > 1:
           snake_case   :				str				 =   [generator] + [None] * (batch_size - 1)

       snake_case   :				List[str]				 =   [
           ("""model""", self.coca_model is None),
           ("""tokenizer""", self.coca_tokenizer is None),
           ("""transform""", self.coca_transform is None),
       ]
       snake_case   :				str				 =   [x[0] for x in coca_is_none if x[1]]
       snake_case   :				Optional[int]				 =   """, """.join(SCREAMING_SNAKE_CASE_						)
       # generate prompts with coca model if prompt is None
       if content_prompt is None:
           if len(SCREAMING_SNAKE_CASE_						):
               raise ValueError(
                   F'Content prompt is None and CoCa [{coca_is_none_str}] is None.'
                   F'Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.'						)
           snake_case   :				Dict				 =   self.get_image_description(SCREAMING_SNAKE_CASE_						)
       if style_prompt is None:
           if len(SCREAMING_SNAKE_CASE_						):
               raise ValueError(
                   F'Style prompt is None and CoCa [{coca_is_none_str}] is None.'
                   F' Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.'						)
           snake_case   :				int				 =   self.get_image_description(SCREAMING_SNAKE_CASE_						)

       # get prompt text embeddings for content and style
       snake_case   :				Any				 =   self.tokenizer(
           SCREAMING_SNAKE_CASE_						,     padding="max_length"						,     max_length=self.tokenizer.model_max_length						,     truncation=SCREAMING_SNAKE_CASE_						,     return_tensors="pt"						,     )
       snake_case   :				Tuple				 =   self.text_encoder(content_text_input.input_ids.to(self.device						)						)[0]

       snake_case   :				int				 =   self.tokenizer(
           SCREAMING_SNAKE_CASE_						,     padding="max_length"						,     max_length=self.tokenizer.model_max_length						,     truncation=SCREAMING_SNAKE_CASE_						,     return_tensors="pt"						,     )
       snake_case   :				Tuple				 =   self.text_encoder(style_text_input.input_ids.to(self.device						)						)[0]

       snake_case   :				Tuple				 =   slerp(SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						)

       # duplicate text embeddings for each generation per prompt
       snake_case   :				Tuple				 =   text_embeddings.repeat_interleave(SCREAMING_SNAKE_CASE_						,     dim=0						)

       # set timesteps
       snake_case   :				Optional[Any]				 =   """offset""" in set(inspect.signature(self.scheduler.set_timesteps						).parameters.keys()						)
       snake_case   :				Tuple				 =   {}
       if accepts_offset:
           snake_case   :				Union[str, Any]				 =   1

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

       snake_case   :				List[Any]				 =   self.get_timesteps(SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						,     self.device						)
       snake_case   :				Optional[int]				 =   timesteps[:1].repeat(SCREAMING_SNAKE_CASE_						)

       # Preprocess image
       snake_case   :				Union[str, Any]				 =   preprocess(SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						)
       snake_case   :				List[Any]				 =   self.prepare_latents(
           SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						,     text_embeddings.dtype						,     self.device						,     SCREAMING_SNAKE_CASE_						)

       snake_case   :				Any				 =   preprocess(SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						)
       snake_case   :				List[str]				 =   self.prepare_latents(
           SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						,     text_embeddings.dtype						,     self.device						,     SCREAMING_SNAKE_CASE_						)

       snake_case   :				List[Any]				 =   slerp(SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						)

       if clip_guidance_scale > 0:
           snake_case   :				Union[str, Any]				 =   self.get_clip_image_embeddings(SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						)
           snake_case   :				Optional[int]				 =   self.get_clip_image_embeddings(SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						)
           snake_case   :				Union[str, Any]				 =   slerp(
               SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						)

       # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
       # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
       # corresponds to doing no classifier free guidance.
       snake_case   :				Any				 =   guidance_scale > 1.0
       # get unconditional embeddings for classifier free guidance
       if do_classifier_free_guidance:
           snake_case   :				Optional[Any]				 =   content_text_input.input_ids.shape[-1]
           snake_case   :				Any				 =   self.tokenizer([""]						,     padding="max_length"						,     max_length=SCREAMING_SNAKE_CASE_						,     return_tensors="pt"						)
           snake_case   :				List[Any]				 =   self.text_encoder(uncond_input.input_ids.to(self.device						)						)[0]
           # duplicate unconditional embeddings for each generation per prompt
           snake_case   :				List[str]				 =   uncond_embeddings.repeat_interleave(SCREAMING_SNAKE_CASE_						,     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
           snake_case   :				List[str]				 =   torch.cat([uncond_embeddings, text_embeddings]						)

       # get the initial random noise unless the user supplied it

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

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

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

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

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

               # predict the noise residual
               snake_case   :				Union[str, Any]				 =   self.unet(SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						,     encoder_hidden_states=SCREAMING_SNAKE_CASE_						).sample

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

               # perform clip guidance
               if clip_guidance_scale > 0:
                   snake_case   :				List[Any]				 =   (
                       text_embeddings.chunk(2						)[1] if do_classifier_free_guidance else text_embeddings
                   )
                   snake_case   :				Dict				 =   self.cond_fn(
                       SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						,     )

               # compute the previous noisy sample x_t -> x_t-1
               snake_case   :				List[Any]				 =   self.scheduler.step(SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						,     SCREAMING_SNAKE_CASE_						,     **SCREAMING_SNAKE_CASE_						).prev_sample

        # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
       snake_case   :				str				 =   1 / 0.18215 * latents
       snake_case   :				int				 =   self.vae.decode(SCREAMING_SNAKE_CASE_						).sample

       snake_case   :				List[Any]				 =   (image / 2 + 0.5).clamp(0						,     1						)
       snake_case   :				Tuple				 =   image.cpu().permute(0						,     2						,     3						,     1						).numpy()

       if output_type == "pil":
           snake_case   :				Union[str, Any]				 =   self.numpy_to_pil(SCREAMING_SNAKE_CASE_						)

       if not return_dict:
           return (image, None)

       return StableDiffusionPipelineOutput(images=SCREAMING_SNAKE_CASE_						,     nsfw_content_detected=SCREAMING_SNAKE_CASE_						)









"""simple docstring"""



import math
import sys







def   __lowerCAmelCase						(						lowercase  :  int			)     ->						int:


    """simple docstring"""





    if number != int(lowercase			):
        raise ValueError("the value of input must be a natural number"			)
    if number < 0:
        raise ValueError("the value of input must not be a negative number"			)
    if number == 0:
        return 1
    snake_case   :				Optional[Any]				 =   [-1] * (number + 1)
    snake_case   :				str				 =   0
    for i in range(1						,							number + 1			):
        snake_case   :				List[Any]				 =   sys.maxsize
        snake_case   :				Union[str, Any]				 =   int(math.sqrt(lowercase			)			)
        for j in range(1						,							root + 1			):
            snake_case   :				List[str]				 =   1 + answers[i - (j**2)]
            snake_case   :				Optional[Any]				 =   min(lowercase						,							lowercase			)
        snake_case   :				Any				 =   answer
    return answers[number]


if __name__ == "__main__":
  import doctest

  doctest.testmod()





