



'''simple docstring'''





import argparse
import math
import os

import torch
from neural_compressor.utils.pytorch import load
from PIL import Image
from transformers import CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, StableDiffusionPipeline, UNetaDConditionModel




def lowerCAmelCase    ():



     """simple docstring"""



     _a           =    argparse.ArgumentParser()
     parser.add_argument(
         '''-m'''    ,      '''--pretrained_model_name_or_path'''    ,      type=__A    ,      default=__A    ,      required=__A    ,      help='''Path to pretrained model or model identifier from huggingface.co/models.'''    ,      )
     parser.add_argument(
         '''-c'''    ,      '''--caption'''    ,      type=__A    ,      default='''robotic cat with wings'''    ,      help='''Text used to generate images.'''    ,      )
     parser.add_argument(
         '''-n'''    ,      '''--images_num'''    ,      type=__A    ,      default=4    ,      help='''How much images to generate.'''    ,      )
     parser.add_argument(
         '''-s'''    ,      '''--seed'''    ,      type=__A    ,      default=42    ,      help='''Seed for random process.'''    ,      )
     parser.add_argument(
         '''-ci'''    ,      '''--cuda_id'''    ,      type=__A    ,      default=0    ,      help='''cuda_id.'''    ,      )
     _a           =    parser.parse_args()
     return args




def lowerCAmelCase    (__A    ,      __A    ,      __A):



     """simple docstring"""



     if not len(__A) == rows * cols:
          raise ValueError('''The specified number of rows and columns are not correct.''')

     _a    ,       _a           =    imgs[0].size
     _a           =    Image.new('''RGB'''    ,      size=(cols * w, rows * h))
     _a    ,       _a           =    grid.size

     for i, img in enumerate(__A):
          grid.paste(__A    ,      box=(i % cols * w, i // cols * h))
     return grid




def lowerCAmelCase    (__A    ,      __A="robotic cat with wings"    ,      __A=7.5    ,      __A=50    ,      __A=1    ,      __A=42    ,      ):



     """simple docstring"""



     _a           =    torch.Generator(pipeline.device).manual_seed(__A)
     _a           =    pipeline(
         __A    ,      guidance_scale=__A    ,      num_inference_steps=__A    ,      generator=__A    ,      num_images_per_prompt=__A    ,      ).images
     _a           =    int(math.sqrt(__A))
     _a           =    image_grid(__A    ,      rows=_rows    ,      cols=num_images_per_prompt // _rows)
     return grid, images


lowercase_									=    parse_args()
# Load models and create wrapper for stable diffusion
lowercase_									=    CLIPTokenizer.from_pretrained(args.pretrained_model_name_or_path, subfolder="tokenizer")
lowercase_									=    CLIPTextModel.from_pretrained(args.pretrained_model_name_or_path, subfolder="text_encoder")
lowercase_									=    AutoencoderKL.from_pretrained(args.pretrained_model_name_or_path, subfolder="vae")
lowercase_									=    UNetaDConditionModel.from_pretrained(args.pretrained_model_name_or_path, subfolder="unet")

lowercase_									=    StableDiffusionPipeline.from_pretrained(
    args.pretrained_model_name_or_path, text_encoder=text_encoder, vae=vae, unet=unet, tokenizer=tokenizer
)
lowercase_									=    lambda images, clip_input: (images, False)
if os.path.exists(os.path.join(args.pretrained_model_name_or_path, "best_model.pt")):
  lowercase_									=    load(args.pretrained_model_name_or_path, model=unet)
  unet.eval()
  setattr(pipeline, "unet", unet)
else:
  lowercase_									=    unet.to(torch.device("cuda", args.cuda_id))
lowercase_									=    pipeline.to(unet.device)
lowercase_			,   lowercase_									=    generate_images(pipeline, prompt=args.caption, num_images_per_prompt=args.images_num, seed=args.seed)
grid.save(os.path.join(args.pretrained_model_name_or_path, "{}.png".format("_".join(args.caption.split()))))
lowercase_									=    os.path.join(args.pretrained_model_name_or_path, "_".join(args.caption.split()))
os.makedirs(dirname, exist_ok=True)
for idx, image in enumerate(images):
  image.save(os.path.join(dirname, "{}.png".format(idx + 1)))










"""simple docstring"""


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

import torch
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    LMSDiscreteScheduler,
    PNDMScheduler,
    StableDiffusionPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker


lowerCamelCase__						= "CompVis/stable-diffusion-v1-1"
lowerCamelCase__						= "CompVis/stable-diffusion-v1-2"
lowerCamelCase__						= "CompVis/stable-diffusion-v1-3"
lowerCamelCase__						= "CompVis/stable-diffusion-v1-4"



class   __SCREAMING_SNAKE_CASE     (    _UpperCamelCase ):







  '''simple docstring'''


  def __init__(		self :							Union[str, Any]       , __a :							AutoencoderKL       , __a :							CLIPTextModel       , __a :							CLIPTokenizer       , __a :							UNetaDConditionModel       , __a :							Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler]       , __a :							StableDiffusionSafetyChecker       , __a :							CLIPImageProcessor       , __a :							bool = True       , )		->					List[str]:
        super()._init_()

        _UpperCamelCase   :						Optional[int]    =							StableDiffusionPipeline.from_pretrained(__a						)
        _UpperCamelCase   :						int    =							StableDiffusionPipeline.from_pretrained(__a						)
        _UpperCamelCase   :						List[Any]    =							StableDiffusionPipeline.from_pretrained(__a						)
        _UpperCamelCase   :						int    =							StableDiffusionPipeline(
            vae=__a       , text_encoder=__a       , tokenizer=__a       , unet=__a       , scheduler=__a       , safety_checker=__a       , feature_extractor=__a       , requires_safety_checker=__a       , )

        self.register_modules(pipelinea=self.pipea       , pipelinea=self.pipea       , pipelinea=self.pipea       , pipelinea=self.pipea						)

  @property
  def  __SCREAMING_SNAKE_CASE					(		self :							Optional[int]						)		->					Dict[str, Any]:
        return {k: getattr(self       , __a						) for k in self.config.keys() if not k.startswith("_"						)}

  def  __SCREAMING_SNAKE_CASE					(		self :							Any       , __a :							Optional[Union[str, int]] = "auto"						)		->					Optional[Any]:
        if slice_size == "auto":
              # half the attention head size is usually a good trade-off between
              # speed and memory
              _UpperCamelCase   :						Tuple    =							self.unet.config.attention_head_dim // 2
        self.unet.set_attention_slice(__a						)

  def  __SCREAMING_SNAKE_CASE					(		self :							str						)		->					Any:
        self.enable_attention_slicing(__a						)

  @torch.no_grad()
  def  __SCREAMING_SNAKE_CASE					(		self :							List[str]       , __a :							Union[str, List[str]]       , __a :							int = 512       , __a :							int = 512       , __a :							int = 50       , __a :							float = 7.5       , __a :							Optional[Union[str, List[str]]] = None       , __a :							Optional[int] = 1       , __a :							float = 0.0       , __a :							Optional[torch.Generator] = None       , __a :							Optional[torch.FloatTensor] = None       , __a :							Optional[str] = "pil"       , __a :							bool = True       , __a :							Optional[Callable[[int, int, torch.FloatTensor], None]] = None       , __a :							int = 1       , **__a :							Any       , )		->					Optional[int]:
        return self.pipea(
            prompt=__a       , height=__a       , width=__a       , num_inference_steps=__a       , guidance_scale=__a       , negative_prompt=__a       , num_images_per_prompt=__a       , eta=__a       , generator=__a       , latents=__a       , output_type=__a       , return_dict=__a       , callback=__a       , callback_steps=__a       , **__a       , )

  @torch.no_grad()
  def  __SCREAMING_SNAKE_CASE					(		self :							List[Any]       , __a :							Union[str, List[str]]       , __a :							int = 512       , __a :							int = 512       , __a :							int = 50       , __a :							float = 7.5       , __a :							Optional[Union[str, List[str]]] = None       , __a :							Optional[int] = 1       , __a :							float = 0.0       , __a :							Optional[torch.Generator] = None       , __a :							Optional[torch.FloatTensor] = None       , __a :							Optional[str] = "pil"       , __a :							bool = True       , __a :							Optional[Callable[[int, int, torch.FloatTensor], None]] = None       , __a :							int = 1       , **__a :							Tuple       , )		->					str:
        return self.pipea(
            prompt=__a       , height=__a       , width=__a       , num_inference_steps=__a       , guidance_scale=__a       , negative_prompt=__a       , num_images_per_prompt=__a       , eta=__a       , generator=__a       , latents=__a       , output_type=__a       , return_dict=__a       , callback=__a       , callback_steps=__a       , **__a       , )

  @torch.no_grad()
  def  __SCREAMING_SNAKE_CASE					(		self :							List[Any]       , __a :							Union[str, List[str]]       , __a :							int = 512       , __a :							int = 512       , __a :							int = 50       , __a :							float = 7.5       , __a :							Optional[Union[str, List[str]]] = None       , __a :							Optional[int] = 1       , __a :							float = 0.0       , __a :							Optional[torch.Generator] = None       , __a :							Optional[torch.FloatTensor] = None       , __a :							Optional[str] = "pil"       , __a :							bool = True       , __a :							Optional[Callable[[int, int, torch.FloatTensor], None]] = None       , __a :							int = 1       , **__a :							Tuple       , )		->					Any:
        return self.pipea(
            prompt=__a       , height=__a       , width=__a       , num_inference_steps=__a       , guidance_scale=__a       , negative_prompt=__a       , num_images_per_prompt=__a       , eta=__a       , generator=__a       , latents=__a       , output_type=__a       , return_dict=__a       , callback=__a       , callback_steps=__a       , **__a       , )

  @torch.no_grad()
  def  __SCREAMING_SNAKE_CASE					(		self :							Dict       , __a :							Union[str, List[str]]       , __a :							int = 512       , __a :							int = 512       , __a :							int = 50       , __a :							float = 7.5       , __a :							Optional[Union[str, List[str]]] = None       , __a :							Optional[int] = 1       , __a :							float = 0.0       , __a :							Optional[torch.Generator] = None       , __a :							Optional[torch.FloatTensor] = None       , __a :							Optional[str] = "pil"       , __a :							bool = True       , __a :							Optional[Callable[[int, int, torch.FloatTensor], None]] = None       , __a :							int = 1       , **__a :							List[Any]       , )		->					Union[str, Any]:
        return self.pipea(
            prompt=__a       , height=__a       , width=__a       , num_inference_steps=__a       , guidance_scale=__a       , negative_prompt=__a       , num_images_per_prompt=__a       , eta=__a       , generator=__a       , latents=__a       , output_type=__a       , return_dict=__a       , callback=__a       , callback_steps=__a       , **__a       , )


  @torch.no_grad()
  def  __SCREAMING_SNAKE_CASE					(		self :							str       , __a :							Union[str, List[str]]       , __a :							int = 512       , __a :							int = 512       , __a :							int = 50       , __a :							float = 7.5       , __a :							Optional[Union[str, List[str]]] = None       , __a :							Optional[int] = 1       , __a :							float = 0.0       , __a :							Optional[torch.Generator] = None       , __a :							Optional[torch.FloatTensor] = None       , __a :							Optional[str] = "pil"       , __a :							bool = True       , __a :							Optional[Callable[[int, int, torch.FloatTensor], None]] = None       , __a :							int = 1       , **__a :							int       , )		->					List[Any]:
        _UpperCamelCase   :						Tuple    =							"cuda" if torch.cuda.is_available() else "cpu"
        self.to(__a						)

        # Checks if the height and width are divisible by 8 or not
        if height % 8 != 0 or width % 8 != 0:
              raise ValueError(F'''`height` and `width` must be divisible by 8 but are {height} and {width}.'''						)

        # Get first result from Stable Diffusion Checkpoint v1.1
        _UpperCamelCase   :						List[str]    =							self.textaimg_sda_a(
            prompt=__a       , height=__a       , width=__a       , num_inference_steps=__a       , guidance_scale=__a       , negative_prompt=__a       , num_images_per_prompt=__a       , eta=__a       , generator=__a       , latents=__a       , output_type=__a       , return_dict=__a       , callback=__a       , callback_steps=__a       , **__a       , )

        # Get first result from Stable Diffusion Checkpoint v1.2
        _UpperCamelCase   :						Optional[Any]    =							self.textaimg_sda_a(
            prompt=__a       , height=__a       , width=__a       , num_inference_steps=__a       , guidance_scale=__a       , negative_prompt=__a       , num_images_per_prompt=__a       , eta=__a       , generator=__a       , latents=__a       , output_type=__a       , return_dict=__a       , callback=__a       , callback_steps=__a       , **__a       , )

        # Get first result from Stable Diffusion Checkpoint v1.3
        _UpperCamelCase   :						str    =							self.textaimg_sda_a(
            prompt=__a       , height=__a       , width=__a       , num_inference_steps=__a       , guidance_scale=__a       , negative_prompt=__a       , num_images_per_prompt=__a       , eta=__a       , generator=__a       , latents=__a       , output_type=__a       , return_dict=__a       , callback=__a       , callback_steps=__a       , **__a       , )

        # Get first result from Stable Diffusion Checkpoint v1.4
        _UpperCamelCase   :						str    =							self.textaimg_sda_a(
            prompt=__a       , height=__a       , width=__a       , num_inference_steps=__a       , guidance_scale=__a       , negative_prompt=__a       , num_images_per_prompt=__a       , eta=__a       , generator=__a       , latents=__a       , output_type=__a       , return_dict=__a       , callback=__a       , callback_steps=__a       , **__a       , )

        # Get all result images into a single list and pass it via StableDiffusionPipelineOutput for final result
        return StableDiffusionPipelineOutput([resa[0], resa[0], resa[0], resa[0]]						)
