




"""simple docstring"""
from logging import getLogger
from typing import Any, Callable, List, Optional, Union

import numpy as np
import PIL
import torch

from ...schedulers import DDPMScheduler
from ..onnx_utils import ORT_TO_NP_TYPE, OnnxRuntimeModel
from ..pipeline_utils import ImagePipelineOutput
from . import StableDiffusionUpscalePipeline


_SCREAMING_SNAKE_CASE						 =     getLogger(__name__)


_SCREAMING_SNAKE_CASE						 =     4
_SCREAMING_SNAKE_CASE						 =     7

_SCREAMING_SNAKE_CASE						 =     {
    """float16""": torch.floataa,
    """float32""": torch.floataa,
}






def 				__lowerCAmelCase					(					__lowerCAmelCase			:		str						)    ->       Any:
 if isinstance(__lowerCamelCase  ,	torch.Tensor						):
  return image
 elif isinstance(__lowerCamelCase  ,	PIL.Image.Image						):
  _UpperCamelCase      :	Optional[int]					      =  [image]

 if isinstance(image[0]  ,	PIL.Image.Image						):
  _UpperCamelCase      ,	_UpperCamelCase      :	Optional[int]					      =  image[0].size
  _UpperCamelCase      ,	_UpperCamelCase      :	Tuple					      =  (x - x % 64 for x in (w, h))  # resize to integer multiple of 32

  _UpperCamelCase      :	Tuple					      =  [np.array(i.resize((w, h)						)						)[None, :] for i in image]
  _UpperCamelCase      :	List[Any]					      =  np.concatenate(__lowerCamelCase  ,	axis=0						)
  _UpperCamelCase      :	Union[str, Any]					      =  np.array(__lowerCamelCase						).astype(np.floataa						) / 255.0
  _UpperCamelCase      :	Tuple					      =  image.transpose(0  ,	3  ,	1  ,	2						)
  _UpperCamelCase      :	List[str]					      =  2.0 * image - 1.0
  _UpperCamelCase      :	int					      =  torch.from_numpy(__lowerCamelCase						)
 elif isinstance(image[0]  ,	torch.Tensor						):
  _UpperCamelCase      :	Union[str, Any]					      =  torch.cat(__lowerCamelCase  ,	dim=0						)

 return image







class  _SCREAMING_SNAKE_CASE       (     __SCREAMING_SNAKE_CASE				):



 '''simple docstring'''





 def __init__(self					,     lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__ = 3_50					,     ):

  '''simple docstring'''







  super().__init__(
      vae=_A					,     text_encoder=_A					,     tokenizer=_A					,     unet=_A					,     low_res_scheduler=_A					,     scheduler=_A					,     safety_checker=_A					,     feature_extractor=_A					,     watermarker=_A					,     max_noise_level=_A					,     )






 def __call__(self					,     lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__ = 75					,     lowerCAmelCase__ = 9.0					,     lowerCAmelCase__ = 20					,     lowerCAmelCase__ = None					,     lowerCAmelCase__ = 1					,     lowerCAmelCase__ = 0.0					,     lowerCAmelCase__ = None					,     lowerCAmelCase__ = None					,     lowerCAmelCase__ = None					,     lowerCAmelCase__ = None					,     lowerCAmelCase__ = "pil"					,     lowerCAmelCase__ = True					,     lowerCAmelCase__ = None					,     lowerCAmelCase__ = 1					,     ):

  '''simple docstring'''







  self.check_inputs(_A					,     _A					,     _A					,     _A   )

  # 2. Define call parameters
  if prompt is not None and isinstance(_A					,     _A   ):
   _UpperCamelCase      :	Any					      =  1
  elif prompt is not None and isinstance(_A					,     _A   ):
   _UpperCamelCase      :	int					      =  len(_A   )
  else:
   _UpperCamelCase      :	Tuple					      =  prompt_embeds.shape[0]

  _UpperCamelCase      :	Dict					      =  self._execution_device
  # 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.
  _UpperCamelCase      :	Dict					      =  guidance_scale > 1.0

  # 3. Encode input prompt
  _UpperCamelCase      :	Optional[int]					      =  self._encode_prompt(
      _A					,     _A					,     _A					,     _A					,     _A					,     prompt_embeds=_A					,     negative_prompt_embeds=_A					,     )

  _UpperCamelCase      :	Tuple					      =  ORT_TO_PT_TYPE[str(text_embeddings.dtype   )]

  # 4. Preprocess image
  _UpperCamelCase      :	List[str]					      =  preprocess(_A   )
  _UpperCamelCase      :	Optional[Any]					      =  image.cpu()

  # 5. set timesteps
  self.scheduler.set_timesteps(_A					,     device=_A   )
  _UpperCamelCase      :	Union[str, Any]					      =  self.scheduler.timesteps

  # 5. Add noise to image
  _UpperCamelCase      :	str					      =  torch.tensor([noise_level]					,     dtype=torch.long					,     device=_A   )
  _UpperCamelCase      :	Tuple					      =  torch.randn(image.shape					,     generator=_A					,     device=_A					,     dtype=_A   )
  _UpperCamelCase      :	str					      =  self.low_res_scheduler.add_noise(_A					,     _A					,     _A   )

  _UpperCamelCase      :	Any					      =  2 if do_classifier_free_guidance else 1
  _UpperCamelCase      :	List[Any]					      =  np.concatenate([image] * batch_multiplier * num_images_per_prompt   )
  _UpperCamelCase      :	Dict					      =  np.concatenate([noise_level] * image.shape[0]   )

  # 6. Prepare latent variables
  _UpperCamelCase      ,	_UpperCamelCase      :	str					      =  image.shape[2:]
  _UpperCamelCase      :	Optional[Any]					      =  self.prepare_latents(
      batch_size * num_images_per_prompt					,     _A					,     _A					,     _A					,     _A					,     _A					,     _A					,     _A					,     )

  # 7. Check that sizes of image and latents match
  _UpperCamelCase      :	Tuple					      =  image.shape[1]
  if NUM_LATENT_CHANNELS + num_channels_image != NUM_UNET_INPUT_CHANNELS:
   raise ValueError(
       "Incorrect configuration settings! The config of `pipeline.unet` expects"
       F" {NUM_UNET_INPUT_CHANNELS} but received `num_channels_latents`: {NUM_LATENT_CHANNELS} +"
       F" `num_channels_image`: {num_channels_image} "
       F" = {NUM_LATENT_CHANNELS+num_channels_image}. Please verify the config of"
       " `pipeline.unet` or your `image` input."   )

  # 8. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline
  _UpperCamelCase      :	str					      =  self.prepare_extra_step_kwargs(_A					,     _A   )

  _UpperCamelCase      :	Any					      =  next(
      (input.type for input in self.unet.model.get_inputs() if input.name == "timestep")					,     "tensor(float)"   )
  _UpperCamelCase      :	Union[str, Any]					      =  ORT_TO_NP_TYPE[timestep_dtype]

  # 9. Denoising loop
  _UpperCamelCase      :	Union[str, Any]					      =  len(_A   ) - num_inference_steps * self.scheduler.order
  with self.progress_bar(total=_A   ) as progress_bar:
   for i, t in enumerate(_A   ):
    # expand the latents if we are doing classifier free guidance
    _UpperCamelCase      :	Any					      =  np.concatenate([latents] * 2   ) if do_classifier_free_guidance else latents

    # concat latents, mask, masked_image_latents in the channel dimension
    _UpperCamelCase      :	List[Any]					      =  self.scheduler.scale_model_input(_A					,     _A   )
    _UpperCamelCase      :	List[Any]					      =  np.concatenate([latent_model_input, image]					,     axis=1   )

    # timestep to tensor
    _UpperCamelCase      :	int					      =  np.array([t]					,     dtype=_A   )

    # predict the noise residual
    _UpperCamelCase      :	Optional[Any]					      =  self.unet(
        sample=_A					,     timestep=_A					,     encoder_hidden_states=_A					,     class_labels=noise_level.astype(np.intaa   )					,     )[0]

    # perform guidance
    if do_classifier_free_guidance:
     _UpperCamelCase      ,	_UpperCamelCase      :	List[str]					      =  np.split(_A					,     2   )
    _UpperCamelCase      :	List[str]					      =  noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

    # compute the previous noisy sample x_t -> x_t-1
    _UpperCamelCase      :	Tuple					      =  self.scheduler.step(
        torch.from_numpy(_A   )					,     _A					,     _A					,     **_A   ).prev_sample

    # call the callback, if provided
    if i == len(_A   ) - 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:
      callback(_A					,     _A					,     _A   )

        # 10. Post-processing
  _UpperCamelCase      :	Tuple					      =  self.decode_latents(latents.float()   )

  # 11. Convert to PIL
  if output_type == "pil":
   _UpperCamelCase      :	Dict					      =  self.numpy_to_pil(_A   )

  if not return_dict:
   return (image,)

  return ImagePipelineOutput(images=_A   )






 def lowercase_      (self					,     lowerCAmelCase__   ):

  '''simple docstring'''







  _UpperCamelCase      :	List[Any]					      =  1 / 0.0_8333 * latents
  _UpperCamelCase      :	str					      =  self.vae(latent_sample=_A   )[0]
  _UpperCamelCase      :	Dict					      =  np.clip(image / 2 + 0.5					,     0					,     1   )
  _UpperCamelCase      :	Dict					      =  image.transpose((0, 2, 3, 1)   )
  return image






 def lowercase_      (self					,     lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__					,     lowerCAmelCase__ = None					,     lowerCAmelCase__ = None					,     ):

  '''simple docstring'''







  if prompt is not None and isinstance(_A					,     _A   ):
   _UpperCamelCase      :	List[Any]					      =  1
  elif prompt is not None and isinstance(_A					,     _A   ):
   _UpperCamelCase      :	Any					      =  len(_A   )
  else:
   _UpperCamelCase      :	List[Any]					      =  prompt_embeds.shape[0]

  if prompt_embeds is None:
   _UpperCamelCase      :	Optional[Any]					      =  self.tokenizer(
       _A					,     padding="max_length"					,     max_length=self.tokenizer.model_max_length					,     truncation=_A					,     return_tensors="pt"					,     )
   _UpperCamelCase      :	Any					      =  text_inputs.input_ids
   _UpperCamelCase      :	str					      =  self.tokenizer(_A					,     padding="longest"					,     return_tensors="pt"   ).input_ids

   if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(
       _A					,     _A   ):
    _UpperCamelCase      :	Optional[Any]					      =  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}"   )

   # no positional arguments to text_encoder
   _UpperCamelCase      :	List[str]					      =  self.text_encoder(
       input_ids=text_input_ids.int().to(_A   )					,     )
   _UpperCamelCase      :	Optional[int]					      =  prompt_embeds[0]

  _UpperCamelCase      ,	_UpperCamelCase      ,	_UpperCamelCase      :	List[str]					      =  prompt_embeds.shape
  # duplicate text embeddings for each generation per prompt, using mps friendly method
  _UpperCamelCase      :	Dict					      =  prompt_embeds.repeat(1					,     _A   )
  _UpperCamelCase      :	List[Any]					      =  prompt_embeds.reshape(bs_embed * num_images_per_prompt					,     _A					,     -1   )

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

   _UpperCamelCase      :	List[str]					      =  text_input_ids.shape[-1]
   _UpperCamelCase      :	Optional[Any]					      =  self.tokenizer(
       _A					,     padding="max_length"					,     max_length=_A					,     truncation=_A					,     return_tensors="pt"					,     )

   # if hasattr(uncond_input, "attention_mask"):
   #     attention_mask = uncond_input.attention_mask.to(device)
   # else:
   #     attention_mask = None

   _UpperCamelCase      :	Tuple					      =  self.text_encoder(
       input_ids=uncond_input.input_ids.int().to(_A   )					,     )
   _UpperCamelCase      :	Any					      =  uncond_embeddings[0]

  if do_classifier_free_guidance:
   _UpperCamelCase      :	List[str]					      =  uncond_embeddings.shape[1]
   # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
   _UpperCamelCase      :	List[Any]					      =  uncond_embeddings.repeat(1					,     _A   )
   _UpperCamelCase      :	List[Any]					      =  uncond_embeddings.reshape(batch_size * num_images_per_prompt					,     _A					,     -1   )

   # For classifier free guidance, we need to do two forward passes.
   # Here we concatenate the unconditional and text embeddings into a single batch
   # to avoid doing two forward passes
   _UpperCamelCase      :	List[str]					      =  np.concatenate([uncond_embeddings, prompt_embeds]   )

  return prompt_embeds





from typing import List

import datasets
from datasets.tasks import ImageClassification

from ..folder_based_builder import folder_based_builder


__UpperCAmelCase   						=     datasets.utils.logging.get_logger(__name__)





class 				UpperCamelCase__		(	folder_based_builder.FolderBasedBuilderConfig	):






       """simple docstring"""


       UpperCAmelCase_				       =None
       UpperCAmelCase_				       =None







class 				UpperCamelCase__		(	folder_based_builder.FolderBasedBuilder	):






       """simple docstring"""


       UpperCAmelCase_				       =datasets.Image()
       UpperCAmelCase_				       ="image"
       UpperCAmelCase_				       =ImageFolderConfig
       UpperCAmelCase_				       =42  # definition at the bottom of the script
       UpperCAmelCase_				       =ImageClassification(image_column="image"       ,    label_column="label"	)







__UpperCAmelCase   						=     [
    ".blp",
    ".bmp",
    ".dib",
    ".bufr",
    ".cur",
    ".pcx",
    ".dcx",
    ".dds",
    ".ps",
    ".eps",
    ".fit",
    ".fits",
    ".fli",
    ".flc",
    ".ftc",
    ".ftu",
    ".gbr",
    ".gif",
    ".grib",
    ".h5",
    ".hdf",
    ".png",
    ".apng",
    ".jp2",
    ".j2k",
    ".jpc",
    ".jpf",
    ".jpx",
    ".j2c",
    ".icns",
    ".ico",
    ".im",
    ".iim",
    ".tif",
    ".tiff",
    ".jfif",
    ".jpe",
    ".jpg",
    ".jpeg",
    ".mpg",
    ".mpeg",
    ".msp",
    ".pcd",
    ".pxr",
    ".pbm",
    ".pgm",
    ".ppm",
    ".pnm",
    ".psd",
    ".bw",
    ".rgb",
    ".rgba",
    ".sgi",
    ".ras",
    ".tga",
    ".icb",
    ".vda",
    ".vst",
    ".webp",
    ".wmf",
    ".emf",
    ".xbm",
    ".xpm",
]
__UpperCAmelCase   						=     IMAGE_EXTENSIONS


