{ "cells": [ { "attachments": {}, "cell_type": "markdown", "id": "d59799fb-ee4c-4601-acb1-05c653331a96", "metadata": {}, "source": [ "# Image generation with DeciDiffusion and OpenVINO\n", "\n", "DeciDiffusion 1.0 is a diffusion-based text-to-image generation model. While it maintains foundational architecture elements from Stable Diffusion, such as the Variational Autoencoder (VAE) and CLIP's pre-trained Text Encoder, DeciDiffusion introduces significant enhancements. The primary innovation is the substitution of U-Net with the more efficient U-Net-NAS, a design pioneered by Deci. This novel component streamlines the model by reducing the number of parameters, leading to superior computational efficiency.\n", "\n", "The domain of text-to-image generation, with its transformative potential in design, art, and advertising, has captivated both experts and laypeople. This technology’s allure lies in its ability to effortlessly transform text into vivid images, marking a significant leap in AI capabilities. While Stable Diffusion’s open-source foundation has spurred many advancements, it grapples with practical deployment challenges due to its heavy computational needs. These challenges lead to notable latency and cost concerns in training and deployment. In contrast, DeciDiffusion stands out. Its superior computational efficiency ensures a smoother user experience and boasts an impressive reduction of nearly 66% in production costs.\n", "\n", "In this tutorial we consider how to convert and run DeciDiffusion using OpenVINO, making text-to-image generative applications more accessible and feasible. An additional part demonstrates how to run quantization with [NNCF](https://github.com/openvinotoolkit/nncf/) to speed up pipeline.\n", "\n", "The notebook contains the following steps:\n", "\n", "1. Convert PyTorch models to OpenVINO Intermediate Representation using OpenVINO Converter Tool (OVC).\n", "2. Prepare Inference Pipeline.\n", "3. Run Inference pipeline with OpenVINO.\n", "4. Optimize `OVStableDiffusionPipeline` with [NNCF](https://github.com/openvinotoolkit/nncf/) quantization.\n", "5. Compare results of original and optimized pipelines.\n", "6. Run Interactive demo for DeciDiffusion model.\n", "\n", "\n", "#### Table of contents:\n", "\n", "- [Prerequisites](#Prerequisites)\n", "- [Prepare DeciDiffusion models for OpenVINO format conversion](#Prepare-DeciDiffusion-models-for-OpenVINO-format-conversion)\n", " - [About model](#About-model)\n", " - [DeciDiffusion integration with Diffusers library](#DeciDiffusion-integration-with-Diffusers-library)\n", "- [Convert models to OpenVINO format](#Convert-models-to-OpenVINO-format)\n", " - [Text Encoder](#Text-Encoder)\n", " - [U-Net NAS](#U-Net-NAS)\n", " - [VAE](#VAE)\n", "- [Prepare inference pipeline](#Prepare-inference-pipeline)\n", " - [Guidance scale and negative prompt for controlling generation result.](#Guidance-scale-and-negative-prompt-for-controlling-generation-result.)\n", " - [Strength for controlling Image-to-Image generation](#Strength-for-controlling-Image-to-Image-generation)\n", " - [Configure Inference Pipeline](#Configure-Inference-Pipeline)\n", "- [Text-to-Image generation](#Text-to-Image-generation)\n", " - [Image-to-Image generation](#Image-to-Image-generation)\n", "- [Quantization](#Quantization)\n", " - [Prepare calibration dataset](#Prepare-calibration-dataset)\n", " - [Run quantization](#Run-quantization)\n", " - [Compare inference time of the FP16 and INT8 pipelines](#Compare-inference-time-of-the-FP16-and-INT8-pipelines)\n", " - [Compare UNet file size](#Compare-UNet-file-size)\n", "- [Interactive demo](#Interactive-demo)\n", "\n" ] }, { "attachments": {}, "cell_type": "markdown", "id": "13c7efe9-5dbd-4904-be80-27ec6d0ec27b", "metadata": {}, "source": [ "## Prerequisites\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "install required packages" ] }, { "cell_type": "code", "execution_count": null, "id": "f9be7dc1-a3e3-4bd3-ad02-01da30d9e602", "metadata": {}, "outputs": [], "source": [ "%pip install -q --extra-index-url https://download.pytorch.org/whl/cpu \"diffusers\" \"transformers\" \"torch>=2.1\" \"pillow\" \"openvino>=2023.1.0\" \"gradio>=4.19\" \"datasets>=2.14.6\" \"huggingface-hub>=0.19.4\" \"nncf>=2.7.0\" \"peft==0.6.2\" \"opencv-python\"" ] }, { "attachments": {}, "cell_type": "markdown", "id": "e209ffee-bae8-48f0-8666-7d75d49ba4c9", "metadata": {}, "source": [ "## Prepare DeciDiffusion models for OpenVINO format conversion\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "### About model\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "DeciDiffusion 1.0 is an 820 million parameter text-to-image latent diffusion model trained on the LAION-v2 dataset and fine-tuned on the LAION-ART dataset. It's architecture based on Stable Diffusion foundational model with the replacement of the traditional U-Net component with a more streamlined variant, U-Net-NAS, conceived by Deci.\n", "\n", "To understand the role and significance of the the U-Net component, it’s worth diving into the latent diffusion architecture:\n", "\n", "Latent diffusion starts with a rudimentary, “noisy” image representation in latent space. With textual guidance, like “A drawing of a pint of beer on a brick wall,” the model progressively refines this representation, gradually unveiling a denoised image representation. After sufficient iterations, this representation in latent space is expanded into a high-resolution image.\n", "\n", "Latent diffusion comprises three primary components:\n", "\n", "* **Variational Autoencoder (VAE)**: Transforms images into latent representations and vice versa. During training, the encoder converts an image into a latent version, while the decoder reverses this during both training and inference.\n", "\n", "* **U-Net**: An iterative encoder-decoder mechanism that introduces and subsequently reduces noise in the latent images. The decoder employs cross-attention layers, conditioning output on text embeddings linked to the given text description.\n", "\n", "* **Text Encoder**: This component transforms textual prompts into latent text embeddings, which the U-Net decoder uses.\n", "\n", "U-Net is a resource-intensive component during training and inference. The repetitive noising and denoising processes incur substantial computational costs at every iteration.\n", "\n", "![unet-vs-unet-nas](https://deci.ai/wp-content/uploads/2023/09/U-Net-NAS-1024x632.png)\n", "\n", "U-Net-NAS features two fewer up and down blocks than U-Net. Its distinctive feature is the variable composition of each block, where the number of ResNet and Attention blocks is optimized to achieve the best overall model performance using the fewest computations. With DeciDiffusion's incorporation of U-Net-NAS — characterized by fewer parameters and enhanced computational efficiency — the overall model’s computational demands are reduced. \n", "\n", "### DeciDiffusion integration with Diffusers library\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "To work with DeciDiffusion, we will use Hugging Face [Diffusers](https://github.com/huggingface/diffusers) library. DeciDiffusion the [`StableDiffusionPipeline`](https://huggingface.co/docs/diffusers/using-diffusers/conditional_image_generation) with small customization: overriding default parameters and replacing U-Net model. The code, defined in `load_orginal_pytorch_pipeline_componets` function, demonstrates how to create diffusers pipeline for DeciDiffusion." ] }, { "cell_type": "code", "execution_count": null, "id": "7582e14c-61af-4832-892b-b94c4f74cb0a", "metadata": {}, "outputs": [], "source": [ "from pathlib import Path\n", "import gc\n", "import torch\n", "import openvino as ov\n", "from diffusers import StableDiffusionPipeline\n", "import warnings\n", "\n", "warnings.filterwarnings(\"ignore\")\n", "\n", "TEXT_ENCODER_OV_PATH = Path(\"model/text_encoder.xml\")\n", "UNET_OV_PATH = Path(\"model/unet_nas.xml\")\n", "VAE_ENCODER_OV_PATH = Path(\"model/vae_encoder.xml\")\n", "VAE_DECODER_OV_PATH = Path(\"model/vae_decoder.xml\")\n", "checkpoint = \"Deci/DeciDiffusion-v1-0\"\n", "scheduler_config_dir = Path(\"model/scheduler\")\n", "tokenizer_dir = Path(\"model/tokenizer\")\n", "\n", "\n", "def load_orginal_pytorch_pipeline_componets():\n", " pipeline = StableDiffusionPipeline.from_pretrained(checkpoint, custom_pipeline=checkpoint, torch_dtype=torch.float32)\n", " pipeline.unet = pipeline.unet.from_pretrained(checkpoint, subfolder=\"flexible_unet\", torch_dtype=torch.float32)\n", " text_encoder = pipeline.text_encoder\n", " text_encoder.eval()\n", " unet = pipeline.unet\n", " unet.eval()\n", " vae = pipeline.vae\n", " vae.eval()\n", "\n", " del pipeline\n", " gc.collect()\n", " return text_encoder, unet, vae\n", "\n", "\n", "def cleanup_torchscript_cache():\n", " \"\"\"\n", " Helper for removing cached model representation\n", " \"\"\"\n", " torch._C._jit_clear_class_registry()\n", " torch.jit._recursive.concrete_type_store = torch.jit._recursive.ConcreteTypeStore()\n", " torch.jit._state._clear_class_state()\n", "\n", "\n", "skip_conversion = TEXT_ENCODER_OV_PATH.exists() and UNET_OV_PATH.exists() and VAE_ENCODER_OV_PATH.exists() and VAE_DECODER_OV_PATH.exists()\n", "\n", "if not skip_conversion:\n", " text_encoder, unet, vae = load_orginal_pytorch_pipeline_componets()\n", "else:\n", " text_encoder, unet, vae = None, None, None" ] }, { "attachments": {}, "cell_type": "markdown", "id": "ace6a515-3de6-414d-a15a-b5c845e009fa", "metadata": {}, "source": [ "## Convert models to OpenVINO format\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "Starting from 2023.0 release, OpenVINO supports PyTorch models directly via Model Conversion API. `ov.convert_model` function accepts instance of PyTorch model and example inputs for tracing and returns object of `ov.Model` class, ready to use or save on disk using `ov.save_model` function. \n", "\n", "\n", "As we already discussed above, the pipeline consists of three important parts:\n", "\n", "* Text Encoder to create condition to generate an image from a text prompt.\n", "* U-Net-NAS for step-by-step denoising latent image representation.\n", "* Autoencoder (VAE) for decoding latent space to image.\n", "\n", "Let us convert each part:\n", "\n", "### Text Encoder\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "The text-encoder is responsible for transforming the input prompt, for example, \"a photo of an astronaut riding a horse\" into an embedding space that can be understood by the U-Net. It is usually a simple transformer-based encoder that maps a sequence of input tokens to a sequence of latent text embeddings.\n", "\n", "Input of the text encoder is the tensor `input_ids` which contains indexes of tokens from text processed by tokenizer and padded to maximum length accepted by model. Model outputs are two tensors: `last_hidden_state` - hidden state from the last MultiHeadAttention layer in the model and `pooler_out` - Pooled output for whole model hidden states." ] }, { "cell_type": "code", "execution_count": 3, "id": "2b7fb03a-254c-4237-8982-0f38fa110262", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Text encoder will be loaded from model/text_encoder.xml\n" ] } ], "source": [ "def convert_encoder(text_encoder: torch.nn.Module, ir_path: Path):\n", " \"\"\"\n", " Convert Text Encoder mode.\n", " Function accepts text encoder model, and prepares example inputs for conversion,\n", " Parameters:\n", " text_encoder (torch.nn.Module): text_encoder model from Stable Diffusion pipeline\n", " ir_path (Path): File for storing model\n", " Returns:\n", " None\n", " \"\"\"\n", " input_ids = torch.ones((1, 77), dtype=torch.long)\n", " # switch model to inference mode\n", " text_encoder.eval()\n", "\n", " # disable gradients calculation for reducing memory consumption\n", " with torch.no_grad():\n", " # Export model to IR format\n", " ov_model = ov.convert_model(\n", " text_encoder,\n", " example_input=input_ids,\n", " input=[\n", " (1, 77),\n", " ],\n", " )\n", " ov.save_model(ov_model, ir_path)\n", " del ov_model\n", " cleanup_torchscript_cache()\n", " gc.collect()\n", " print(f\"Text Encoder successfully converted to IR and saved to {ir_path}\")\n", "\n", "\n", "if not TEXT_ENCODER_OV_PATH.exists():\n", " convert_encoder(text_encoder, TEXT_ENCODER_OV_PATH)\n", "else:\n", " print(f\"Text encoder will be loaded from {TEXT_ENCODER_OV_PATH}\")\n", "\n", "del text_encoder\n", "gc.collect();" ] }, { "attachments": {}, "cell_type": "markdown", "id": "5badfb50-1349-44c1-bae7-e48e322d23a4", "metadata": {}, "source": [ "### U-Net NAS\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "U-Net NAS model, similar to Stable Diffusion UNet model, has three inputs:\n", "\n", "* `sample` - latent image sample from previous step. Generation process has not been started yet, so you will use random noise.\n", "* `timestep` - current scheduler step.\n", "* `encoder_hidden_state` - hidden state of text encoder.\n", "\n", "Model predicts the `sample` state for the next step." ] }, { "cell_type": "code", "execution_count": 4, "id": "b9bc7ac2-c34b-4291-a693-b9c80deed7ce", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "U-Net NAS will be loaded from model/unet_nas.xml\n" ] } ], "source": [ "import numpy as np\n", "\n", "dtype_mapping = {torch.float32: ov.Type.f32, torch.float64: ov.Type.f64}\n", "\n", "\n", "def convert_unet(unet: torch.nn.Module, ir_path: Path):\n", " \"\"\"\n", " Convert U-net model to IR format.\n", " Function accepts unet model, prepares example inputs for conversion,\n", " Parameters:\n", " unet (StableDiffusionPipeline): unet from Stable Diffusion pipeline\n", " ir_path (Path): File for storing model\n", " Returns:\n", " None\n", " \"\"\"\n", " # prepare inputs\n", " encoder_hidden_state = torch.ones((2, 77, 768))\n", " latents_shape = (2, 4, 512 // 8, 512 // 8)\n", " latents = torch.randn(latents_shape)\n", " t = torch.from_numpy(np.array(1, dtype=float))\n", " dummy_inputs = (latents, t, encoder_hidden_state)\n", " input_info = []\n", " for i, input_tensor in enumerate(dummy_inputs):\n", " shape = ov.PartialShape(tuple(input_tensor.shape))\n", " if i != 1:\n", " shape[0] = -1\n", " element_type = dtype_mapping[input_tensor.dtype]\n", " input_info.append((shape, element_type))\n", "\n", " unet.eval()\n", " with torch.no_grad():\n", " ov_model = ov.convert_model(unet, example_input=dummy_inputs, input=input_info)\n", " ov.save_model(ov_model, ir_path)\n", " del ov_model\n", " cleanup_torchscript_cache()\n", " gc.collect()\n", " print(f\"U-Net NAS successfully converted to IR and saved to {ir_path}\")\n", "\n", "\n", "if not UNET_OV_PATH.exists():\n", " convert_unet(unet, UNET_OV_PATH)\n", "else:\n", " print(f\"U-Net NAS will be loaded from {UNET_OV_PATH}\")\n", "del unet\n", "gc.collect();" ] }, { "attachments": {}, "cell_type": "markdown", "id": "91ea70c1-3b81-40a1-96b0-18e1d8833ef4", "metadata": {}, "source": [ "### VAE\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "The VAE model has two parts, an encoder and a decoder. The encoder is used to convert the image into a low dimensional latent representation, which will serve as the input to the U-Net model. The decoder, conversely, transforms the latent representation back into an image.\n", "\n", "During latent diffusion training, the encoder is used to get the latent representations (latents) of the images for the forward diffusion process, which applies more and more noise at each step. During inference, the denoised latents generated by the reverse diffusion process are converted back into images using the VAE decoder. When you run inference for text-to-image, there is no initial image as a starting point. You can skip this step and directly generate initial random noise.\n", "\n", "As the encoder and the decoder are used independently in different parts of the pipeline, it will be better to convert them to separate models." ] }, { "cell_type": "code", "execution_count": 5, "id": "220c006d-09cd-440c-8b03-8c666d36369f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "VAE encoder will be loaded from model/vae_encoder.xml\n", "VAE decoder will be loaded from model/vae_decoder.xml\n" ] } ], "source": [ "def convert_vae_encoder(vae: torch.nn.Module, ir_path: Path):\n", " \"\"\"\n", " Convert VAE model for encoding to IR format.\n", " Function accepts vae model, creates wrapper class for export only necessary for inference part,\n", " prepares example inputs for conversion,\n", " Parameters:\n", " vae (torch.nn.Module): VAE model from StableDiffusio pipeline\n", " ir_path (Path): File for storing model\n", " Returns:\n", " None\n", " \"\"\"\n", "\n", " class VAEEncoderWrapper(torch.nn.Module):\n", " def __init__(self, vae):\n", " super().__init__()\n", " self.vae = vae\n", "\n", " def forward(self, image):\n", " return self.vae.encode(x=image)[\"latent_dist\"].sample()\n", "\n", " vae_encoder = VAEEncoderWrapper(vae)\n", " vae_encoder.eval()\n", " image = torch.zeros((1, 3, 512, 512))\n", " with torch.no_grad():\n", " ov_model = ov.convert_model(vae_encoder, example_input=image, input=[((1, 3, 512, 512),)])\n", " ov.save_model(ov_model, ir_path)\n", " del ov_model\n", " cleanup_torchscript_cache()\n", " gc.collect()\n", " print(f\"VAE encoder successfully converted to IR and saved to {ir_path}\")\n", "\n", "\n", "if not VAE_ENCODER_OV_PATH.exists():\n", " convert_vae_encoder(vae, VAE_ENCODER_OV_PATH)\n", "else:\n", " print(f\"VAE encoder will be loaded from {VAE_ENCODER_OV_PATH}\")\n", "\n", "\n", "def convert_vae_decoder(vae: torch.nn.Module, ir_path: Path):\n", " \"\"\"\n", " Convert VAE model for decoding to IR format.\n", " Function accepts vae model, creates wrapper class for export only necessary for inference part,\n", " prepares example inputs for conversion,\n", " Parameters:\n", " vae (torch.nn.Module): VAE model frm StableDiffusion pipeline\n", " ir_path (Path): File for storing model\n", " Returns:\n", " None\n", " \"\"\"\n", "\n", " class VAEDecoderWrapper(torch.nn.Module):\n", " def __init__(self, vae):\n", " super().__init__()\n", " self.vae = vae\n", "\n", " def forward(self, latents):\n", " return self.vae.decode(latents)\n", "\n", " vae_decoder = VAEDecoderWrapper(vae)\n", " latents = torch.zeros((1, 4, 64, 64))\n", "\n", " vae_decoder.eval()\n", " with torch.no_grad():\n", " ov_model = ov.convert_model(vae_decoder, example_input=latents, input=[((1, 4, 64, 64),)])\n", " ov.save_model(ov_model, ir_path)\n", " del ov_model\n", " cleanup_torchscript_cache()\n", " gc.collect()\n", " print(f\"VAE decoder successfully converted to IR and saved to {ir_path}\")\n", "\n", "\n", "if not VAE_DECODER_OV_PATH.exists():\n", " convert_vae_decoder(vae, VAE_DECODER_OV_PATH)\n", "else:\n", " print(f\"VAE decoder will be loaded from {VAE_DECODER_OV_PATH}\")\n", "\n", "del vae\n", "gc.collect();" ] }, { "attachments": {}, "cell_type": "markdown", "id": "e52fa562-f5fb-4c5e-b6a0-a9707b547a7e", "metadata": {}, "source": [ "## Prepare inference pipeline\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "Putting it all together, let us now take a closer look at how the model works in inference by illustrating the logical flow.\n", "![sd-pipeline](https://user-images.githubusercontent.com/29454499/260981188-c112dd0a-5752-4515-adca-8b09bea5d14a.png)\n", "\n", "As you can see from the diagram, the only difference between Text-to-Image and text-guided Image-to-Image generation in approach is how initial latent state is generated. In case of Image-to-Image generation, you additionally have an image encoded by VAE encoder mixed with the noise produced by using latent seed, while in Text-to-Image you use only noise as initial latent state.\n", "The stable diffusion model takes both a latent image representation of size $64 \\times 64$ and a text prompt is transformed to text embeddings of size $77 \\times 768$ via CLIP's text encoder as an input.\n", "\n", "Next, the U-Net iteratively *denoises* the random latent image representations while being conditioned on the text embeddings. The output of the U-Net, being the noise residual, is used to compute a denoised latent image representation via a scheduler algorithm. Many different scheduler algorithms can be used for this computation, each having its pros and cons.\n", "More information about supported schedulers algorithms can be found in [diffusers documentation](https://huggingface.co/docs/diffusers/main/en/using-diffusers/schedulers).\n", "\n", "Theory on how the scheduler algorithm function works is out of scope for this notebook. Nonetheless, in short, you should remember that you compute the predicted denoised image representation from the previous noise representation and the predicted noise residual.\n", "For more information, refer to the recommended [Elucidating the Design Space of Diffusion-Based Generative Models](https://arxiv.org/abs/2206.00364)\n", "\n", "The *denoising* process is repeated given number of times (by default 30 for DeciDiffusion) to step-by-step retrieve better latent image representations.\n", "When complete, the latent image representation is decoded by the decoder part of the variational auto encoder.\n", "\n", "### Guidance scale and negative prompt for controlling generation result.\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "Guidance scale controls how similar the generated image will be to the prompt. A higher guidance scale means the model will try to generate an image that follows the prompt more strictly. A lower guidance scale means the model will have more creativity.\n", "guidance_scale is a way to increase the adherence to the conditional signal that guides the generation (text, in this case) as well as overall sample quality. It is also known as [classifier-free guidance](https://arxiv.org/abs/2207.12598). The default guidance scale in DeciDiffusion is 0.7.\n", "\n", "Additionally, to improve image generation quality, model supports negative prompting. Technically, positive prompt steers the diffusion toward the images associated with it, while negative prompt steers the diffusion away from it.In other words, negative prompt declares undesired concepts for generation image, e.g. if we want to have colorful and bright image, gray scale image will be result which we want to avoid, in this case gray scale can be treated as negative prompt. The positive and negative prompt are in equal footing. You can always use one with or without the other. More explanation of how it works can be found in this [article](https://stable-diffusion-art.com/how-negative-prompt-work/).\n", "\n", "**Note**: negative prompting applicable only for high guidance scale (at least > 1).\n", "\n", "### Strength for controlling Image-to-Image generation\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "In the Image-to-Image mode, the strength parameter plays a crucial role. It determines the level of noise that is added to the initial image while generating a new one. By adjusting this parameter, you can achieve better consistency with the original image and accomplish your creative objectives. It gives you the flexibility to make small alterations or lets you entirely transform the image.\n", "\n", "Working with the strength parameter is really straightforward, you only need to remember how the extremes work:\n", "\n", "* setting strength close to 0 will produce an image nearly identical to the original,\n", "\n", "* setting strength to 1 will produce an image that greatly differs from the original.\n", "\n", "For optimal results - combining elements from the original image with the concepts outlined in the prompt, it is best to aim for values between 0.4 and 0.6. " ] }, { "cell_type": "code", "execution_count": 6, "id": "c9cf8808-1569-4343-8075-63a6d818498c", "metadata": {}, "outputs": [], "source": [ "import inspect\n", "from typing import List, Optional, Union, Dict\n", "\n", "import PIL\n", "import cv2\n", "\n", "from transformers import CLIPTokenizer\n", "from diffusers.pipelines.pipeline_utils import DiffusionPipeline\n", "from diffusers.schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler\n", "from openvino.runtime import Model\n", "\n", "\n", "def scale_fit_to_window(dst_width: int, dst_height: int, image_width: int, image_height: int):\n", " \"\"\"\n", " Preprocessing helper function for calculating image size for resize with peserving original aspect ratio\n", " and fitting image to specific window size\n", "\n", " Parameters:\n", " dst_width (int): destination window width\n", " dst_height (int): destination window height\n", " image_width (int): source image width\n", " image_height (int): source image height\n", " Returns:\n", " result_width (int): calculated width for resize\n", " result_height (int): calculated height for resize\n", " \"\"\"\n", " im_scale = min(dst_height / image_height, dst_width / image_width)\n", " return int(im_scale * image_width), int(im_scale * image_height)\n", "\n", "\n", "def preprocess(image: PIL.Image.Image):\n", " \"\"\"\n", " Image preprocessing function. Takes image in PIL.Image format, resizes it to keep aspect ration and fits to model input window 512x512,\n", " then converts it to np.ndarray and adds padding with zeros on right or bottom side of image (depends from aspect ratio), after that\n", " converts data to float32 data type and change range of values from [0, 255] to [-1, 1], finally, converts data layout from planar NHWC to NCHW.\n", " The function returns preprocessed input tensor and padding size, which can be used in postprocessing.\n", "\n", " Parameters:\n", " image (PIL.Image.Image): input image\n", " Returns:\n", " image (np.ndarray): preprocessed image tensor\n", " meta (Dict): dictionary with preprocessing metadata info\n", " \"\"\"\n", " src_width, src_height = image.size\n", " dst_width, dst_height = scale_fit_to_window(512, 512, src_width, src_height)\n", " image = np.array(image.resize((dst_width, dst_height), resample=PIL.Image.Resampling.LANCZOS))[None, :]\n", " pad_width = 512 - dst_width\n", " pad_height = 512 - dst_height\n", " pad = ((0, 0), (0, pad_height), (0, pad_width), (0, 0))\n", " image = np.pad(image, pad, mode=\"constant\")\n", " image = image.astype(np.float32) / 255.0\n", " image = 2.0 * image - 1.0\n", " image = image.transpose(0, 3, 1, 2)\n", " return image, {\"padding\": pad, \"src_width\": src_width, \"src_height\": src_height}\n", "\n", "\n", "class OVStableDiffusionPipeline(DiffusionPipeline):\n", " def __init__(\n", " self,\n", " vae_decoder: Model,\n", " text_encoder: Model,\n", " tokenizer: CLIPTokenizer,\n", " unet: Model,\n", " scheduler: Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler],\n", " vae_encoder: Model = None,\n", " ):\n", " \"\"\"\n", " Pipeline for text-to-image generation using Stable Diffusion.\n", " Parameters:\n", " vae (Model):\n", " Variational Auto-Encoder (VAE) Model to decode images to and from latent representations.\n", " text_encoder (Model):\n", " Frozen text-encoder. Stable Diffusion uses the text portion of\n", " [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), specifically\n", " the clip-vit-large-patch14(https://huggingface.co/openai/clip-vit-large-patch14) variant.\n", " tokenizer (CLIPTokenizer):\n", " Tokenizer of class CLIPTokenizer(https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer).\n", " unet (Model): Conditional U-Net architecture to denoise the encoded image latents.\n", " scheduler (SchedulerMixin):\n", " A scheduler to be used in combination with unet to denoise the encoded image latents. Can be one of\n", " DDIMScheduler, LMSDiscreteScheduler, or PNDMScheduler.\n", " \"\"\"\n", " super().__init__()\n", " self.scheduler = scheduler\n", " self.vae_decoder = vae_decoder\n", " self.vae_encoder = vae_encoder\n", " self.text_encoder = text_encoder\n", " self.register_to_config(unet=unet)\n", " self._text_encoder_output = text_encoder.output(0)\n", " self._unet_output = unet.output(0)\n", " self._vae_d_output = vae_decoder.output(0)\n", " self._vae_e_output = vae_encoder.output(0) if vae_encoder is not None else None\n", " self.height = 512\n", " self.width = 512\n", " self.tokenizer = tokenizer\n", "\n", " def __call__(\n", " self,\n", " prompt: Union[str, List[str]],\n", " image: PIL.Image.Image = None,\n", " num_inference_steps: Optional[int] = 30,\n", " negative_prompt: Union[str, List[str]] = None,\n", " guidance_scale: Optional[float] = 0.7,\n", " eta: Optional[float] = 0.0,\n", " output_type: Optional[str] = \"pil\",\n", " seed: Optional[int] = None,\n", " strength: float = 1.0,\n", " gif: Optional[bool] = False,\n", " **kwargs,\n", " ):\n", " \"\"\"\n", " Function invoked when calling the pipeline for generation.\n", " Parameters:\n", " prompt (str or List[str]):\n", " The prompt or prompts to guide the image generation.\n", " image (PIL.Image.Image, *optional*, None):\n", " Intinal image for generation.\n", " num_inference_steps (int, *optional*, defaults to 30):\n", " The number of denoising steps. More denoising steps usually lead to a higher quality image at the\n", " expense of slower inference.\n", " negative_prompt (str or List[str]):\n", " The negative prompt or prompts to guide the image generation.\n", " guidance_scale (float, *optional*, defaults to 0.7):\n", " Guidance scale as defined in Classifier-Free Diffusion Guidance(https://arxiv.org/abs/2207.12598).\n", " guidance_scale is defined as `w` of equation 2.\n", " Higher guidance scale encourages to generate images that are closely linked to the text prompt,\n", " usually at the expense of lower image quality.\n", " eta (float, *optional*, defaults to 0.0):\n", " Corresponds to parameter eta (η) in the DDIM paper: https://arxiv.org/abs/2010.02502. Only applies to\n", " [DDIMScheduler], will be ignored for others.\n", " output_type (`str`, *optional*, defaults to \"pil\"):\n", " The output format of the generate image. Choose between\n", " [PIL](https://pillow.readthedocs.io/en/stable/): PIL.Image.Image or np.array.\n", " seed (int, *optional*, None):\n", " Seed for random generator state initialization.\n", " gif (bool, *optional*, False):\n", " Flag for storing all steps results or not.\n", " Returns:\n", " Dictionary with keys:\n", " sample - the last generated image PIL.Image.Image or np.array\n", " iterations - *optional* (if gif=True) images for all diffusion steps, List of PIL.Image.Image or np.array.\n", " \"\"\"\n", " if seed is not None:\n", " np.random.seed(seed)\n", "\n", " img_buffer = []\n", " do_classifier_free_guidance = guidance_scale > 1.0\n", " # get prompt text embeddings\n", " text_embeddings = self._encode_prompt(\n", " prompt,\n", " do_classifier_free_guidance=do_classifier_free_guidance,\n", " negative_prompt=negative_prompt,\n", " )\n", "\n", " # set timesteps\n", " accepts_offset = \"offset\" in set(inspect.signature(self.scheduler.set_timesteps).parameters.keys())\n", " extra_set_kwargs = {}\n", " if accepts_offset:\n", " extra_set_kwargs[\"offset\"] = 1\n", "\n", " self.scheduler.set_timesteps(num_inference_steps, **extra_set_kwargs)\n", " timesteps, num_inference_steps = self.get_timesteps(num_inference_steps, strength)\n", " latent_timestep = timesteps[:1]\n", "\n", " # get the initial random noise unless the user supplied it\n", " latents, meta = self.prepare_latents(image, latent_timestep)\n", "\n", " # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature\n", " # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.\n", " # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502\n", " # and should be between [0, 1]\n", " accepts_eta = \"eta\" in set(inspect.signature(self.scheduler.step).parameters.keys())\n", " extra_step_kwargs = {}\n", " if accepts_eta:\n", " extra_step_kwargs[\"eta\"] = eta\n", "\n", " for i, t in enumerate(self.progress_bar(timesteps)):\n", " # expand the latents if you are doing classifier free guidance\n", " latent_model_input = np.concatenate([latents] * 2) if do_classifier_free_guidance else latents\n", " latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)\n", "\n", " # predict the noise residual\n", " noise_pred = self.unet([latent_model_input, t, text_embeddings])[self._unet_output]\n", " # perform guidance\n", " if do_classifier_free_guidance:\n", " noise_pred_uncond, noise_pred_text = noise_pred[0], noise_pred[1]\n", " noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)\n", "\n", " # compute the previous noisy sample x_t -> x_t-1\n", " latents = self.scheduler.step(\n", " torch.from_numpy(noise_pred),\n", " t,\n", " torch.from_numpy(latents),\n", " **extra_step_kwargs,\n", " )[\"prev_sample\"].numpy()\n", " if gif:\n", " image = self.vae_decoder(latents * (1 / 0.18215))[self._vae_d_output]\n", " image = self.postprocess_image(image, meta, output_type)\n", " img_buffer.extend(image)\n", "\n", " # scale and decode the image latents with vae\n", " image = self.vae_decoder(latents * (1 / 0.18215))[self._vae_d_output]\n", "\n", " image = self.postprocess_image(image, meta, output_type)\n", " return {\"sample\": image, \"iterations\": img_buffer}\n", "\n", " def _encode_prompt(\n", " self,\n", " prompt: Union[str, List[str]],\n", " num_images_per_prompt: int = 1,\n", " do_classifier_free_guidance: bool = True,\n", " negative_prompt: Union[str, List[str]] = None,\n", " ):\n", " \"\"\"\n", " Encodes the prompt into text encoder hidden states.\n", "\n", " Parameters:\n", " prompt (str or list(str)): prompt to be encoded\n", " num_images_per_prompt (int): number of images that should be generated per prompt\n", " do_classifier_free_guidance (bool): whether to use classifier free guidance or not\n", " negative_prompt (str or list(str)): negative prompt to be encoded\n", " Returns:\n", " text_embeddings (np.ndarray): text encoder hidden states\n", " \"\"\"\n", " batch_size = len(prompt) if isinstance(prompt, list) else 1\n", "\n", " # tokenize input prompts\n", " text_inputs = self.tokenizer(\n", " prompt,\n", " padding=\"max_length\",\n", " max_length=self.tokenizer.model_max_length,\n", " truncation=True,\n", " return_tensors=\"np\",\n", " )\n", " text_input_ids = text_inputs.input_ids\n", "\n", " text_embeddings = self.text_encoder(text_input_ids)[self._text_encoder_output]\n", "\n", " # duplicate text embeddings for each generation per prompt\n", " if num_images_per_prompt != 1:\n", " bs_embed, seq_len, _ = text_embeddings.shape\n", " text_embeddings = np.tile(text_embeddings, (1, num_images_per_prompt, 1))\n", " text_embeddings = np.reshape(text_embeddings, (bs_embed * num_images_per_prompt, seq_len, -1))\n", "\n", " # get unconditional embeddings for classifier free guidance\n", " if do_classifier_free_guidance:\n", " uncond_tokens: List[str]\n", " max_length = text_input_ids.shape[-1]\n", " if negative_prompt is None:\n", " uncond_tokens = [\"\"] * batch_size\n", " elif isinstance(negative_prompt, str):\n", " uncond_tokens = [negative_prompt]\n", " else:\n", " uncond_tokens = negative_prompt\n", " uncond_input = self.tokenizer(\n", " uncond_tokens,\n", " padding=\"max_length\",\n", " max_length=max_length,\n", " truncation=True,\n", " return_tensors=\"np\",\n", " )\n", "\n", " uncond_embeddings = self.text_encoder(uncond_input.input_ids)[self._text_encoder_output]\n", "\n", " # duplicate unconditional embeddings for each generation per prompt, using mps friendly method\n", " seq_len = uncond_embeddings.shape[1]\n", " uncond_embeddings = np.tile(uncond_embeddings, (1, num_images_per_prompt, 1))\n", " uncond_embeddings = np.reshape(uncond_embeddings, (batch_size * num_images_per_prompt, seq_len, -1))\n", "\n", " # For classifier free guidance, we need to do two forward passes.\n", " # Here we concatenate the unconditional and text embeddings into a single batch\n", " # to avoid doing two forward passes\n", " text_embeddings = np.concatenate([uncond_embeddings, text_embeddings])\n", "\n", " return text_embeddings\n", "\n", " def prepare_latents(self, image: PIL.Image.Image = None, latent_timestep: torch.Tensor = None):\n", " \"\"\"\n", " Function for getting initial latents for starting generation\n", "\n", " Parameters:\n", " image (PIL.Image.Image, *optional*, None):\n", " Input image for generation, if not provided randon noise will be used as starting point\n", " latent_timestep (torch.Tensor, *optional*, None):\n", " Predicted by scheduler initial step for image generation, required for latent image mixing with nosie\n", " Returns:\n", " latents (np.ndarray):\n", " Image encoded in latent space\n", " \"\"\"\n", " latents_shape = (1, 4, self.height // 8, self.width // 8)\n", " noise = np.random.randn(*latents_shape).astype(np.float32)\n", " if image is None:\n", " # if you use LMSDiscreteScheduler, let's make sure latents are multiplied by sigmas\n", " if isinstance(self.scheduler, LMSDiscreteScheduler):\n", " noise = noise * self.scheduler.sigmas[0].numpy()\n", " return noise, {}\n", " input_image, meta = preprocess(image)\n", " latents = self.vae_encoder(input_image)[self._vae_e_output] * 0.18215\n", " latents = self.scheduler.add_noise(torch.from_numpy(latents), torch.from_numpy(noise), latent_timestep).numpy()\n", " return latents, meta\n", "\n", " def postprocess_image(self, image: np.ndarray, meta: Dict, output_type: str = \"pil\"):\n", " \"\"\"\n", " Postprocessing for decoded image. Takes generated image decoded by VAE decoder, unpad it to initila image size (if required),\n", " normalize and convert to [0, 255] pixels range. Optionally, convertes it from np.ndarray to PIL.Image format\n", "\n", " Parameters:\n", " image (np.ndarray):\n", " Generated image\n", " meta (Dict):\n", " Metadata obtained on latents preparing step, can be empty\n", " output_type (str, *optional*, pil):\n", " Output format for result, can be pil or numpy\n", " Returns:\n", " image (List of np.ndarray or PIL.Image.Image):\n", " Postprocessed images\n", " \"\"\"\n", " if \"padding\" in meta:\n", " pad = meta[\"padding\"]\n", " (_, end_h), (_, end_w) = pad[1:3]\n", " h, w = image.shape[2:]\n", " unpad_h = h - end_h\n", " unpad_w = w - end_w\n", " image = image[:, :, :unpad_h, :unpad_w]\n", " image = np.clip(image / 2 + 0.5, 0, 1)\n", " image = np.transpose(image, (0, 2, 3, 1))\n", " # 9. Convert to PIL\n", " if output_type == \"pil\":\n", " image = self.numpy_to_pil(image)\n", " if \"src_height\" in meta:\n", " orig_height, orig_width = meta[\"src_height\"], meta[\"src_width\"]\n", " image = [img.resize((orig_width, orig_height), PIL.Image.Resampling.LANCZOS) for img in image]\n", " else:\n", " if \"src_height\" in meta:\n", " orig_height, orig_width = meta[\"src_height\"], meta[\"src_width\"]\n", " image = [cv2.resize(img, (orig_width, orig_width)) for img in image]\n", " return image\n", "\n", " def get_timesteps(self, num_inference_steps: int, strength: float):\n", " \"\"\"\n", " Helper function for getting scheduler timesteps for generation\n", " In case of image-to-image generation, it updates number of steps according to strength\n", "\n", " Parameters:\n", " num_inference_steps (int):\n", " number of inference steps for generation\n", " strength (float):\n", " value between 0.0 and 1.0, that controls the amount of noise that is added to the input image.\n", " Values that approach 1.0 enable lots of variations but will also produce images that are not semantically consistent with the input.\n", " \"\"\"\n", " # get the original timestep using init_timestep\n", " init_timestep = min(int(num_inference_steps * strength), num_inference_steps)\n", "\n", " t_start = max(num_inference_steps - init_timestep, 0)\n", " timesteps = self.scheduler.timesteps[t_start:]\n", "\n", " return timesteps, num_inference_steps - t_start" ] }, { "attachments": {}, "cell_type": "markdown", "id": "a57236f8-990c-4500-bd79-53429ac7ec4c", "metadata": {}, "source": [ "### Configure Inference Pipeline\n", "[back to top ⬆️](#Table-of-contents:)\n" ] }, { "cell_type": "code", "execution_count": 7, "id": "b3ed3172-ebf4-4171-93c0-043ab2c4ad47", "metadata": {}, "outputs": [], "source": [ "core = ov.Core()" ] }, { "attachments": {}, "cell_type": "markdown", "id": "53d8d1e8-d4c6-42bc-9d76-48b728574279", "metadata": {}, "source": [ "First, you should create instances of OpenVINO Model and compile it using selected device. Select device from dropdown list for running inference using OpenVINO." ] }, { "cell_type": "code", "execution_count": null, "id": "778bcebb-2963-4312-a3b3-e003e2e090d1", "metadata": {}, "outputs": [], "source": [ "import ipywidgets as widgets\n", "\n", "device = widgets.Dropdown(\n", " options=core.available_devices + [\"AUTO\"],\n", " value=\"CPU\",\n", " description=\"Device:\",\n", " disabled=False,\n", ")\n", "\n", "device" ] }, { "cell_type": "code", "execution_count": 9, "id": "1557f090-a8ce-4f65-8366-d8ebb8a66ec7", "metadata": {}, "outputs": [], "source": [ "text_enc = core.compile_model(TEXT_ENCODER_OV_PATH, device.value)" ] }, { "cell_type": "code", "execution_count": 10, "id": "ce032cc9-def8-42ed-af60-2162fe16ea5c", "metadata": {}, "outputs": [], "source": [ "unet_model = core.compile_model(UNET_OV_PATH, device.value)" ] }, { "cell_type": "code", "execution_count": 11, "id": "a28d2a35-93c4-40ea-b990-f466cf03e5d9", "metadata": {}, "outputs": [], "source": [ "ov_vae_config = {\"INFERENCE_PRECISION_HINT\": \"f32\"} if device.value != \"CPU\" else {}\n", "\n", "vae_decoder = core.compile_model(VAE_DECODER_OV_PATH, device.value, ov_vae_config)\n", "vae_encoder = core.compile_model(VAE_ENCODER_OV_PATH, device.value, ov_vae_config)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "8971d327-1925-4996-93bc-b68a247c557d", "metadata": {}, "source": [ "Model tokenizer and scheduler are also important parts of the pipeline. Let us define them and put all components together" ] }, { "cell_type": "code", "execution_count": 12, "id": "e24f06fc-b0c2-4ec6-86cc-2b5648faa0a2", "metadata": {}, "outputs": [], "source": [ "from transformers import AutoTokenizer\n", "from diffusers import DDIMScheduler\n", "\n", "if not tokenizer_dir.exists():\n", " tokenizer = AutoTokenizer.from_pretrained(checkpoint, subfolder=\"tokenizer\")\n", " tokenizer.save_pretrained(tokenizer_dir)\n", "else:\n", " tokenizer = AutoTokenizer.from_pretrained(tokenizer_dir)\n", "\n", "if not scheduler_config_dir.exists():\n", " scheduler = DDIMScheduler.from_pretrained(checkpoint, subfolder=\"scheduler\")\n", " scheduler.save_pretrained(scheduler_config_dir)\n", "else:\n", " scheduler = DDIMScheduler.from_pretrained(scheduler_config_dir)\n", "\n", "ov_pipe = OVStableDiffusionPipeline(\n", " tokenizer=tokenizer,\n", " text_encoder=text_enc,\n", " unet=unet_model,\n", " vae_encoder=vae_encoder,\n", " vae_decoder=vae_decoder,\n", " scheduler=scheduler,\n", ")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "572420e2-261a-493b-930f-72bf646c0021", "metadata": {}, "source": [ "## Text-to-Image generation\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "Now, let's see model in action" ] }, { "cell_type": "code", "execution_count": 13, "id": "73b4b809-3204-453f-a19a-d5f4bdba3573", "metadata": {}, "outputs": [], "source": [ "text_prompt = \"Highly detailed portrait of a small, adorable cat with round, expressive eyes and a friendly smile\"\n", "num_steps = 30\n", "seed = 4217" ] }, { "cell_type": "code", "execution_count": 14, "id": "35939ee4-a56e-412e-a5d4-8647e36862f2", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Pipeline settings\n", "Input text: Highly detailed portrait of a small, adorable cat with round, expressive eyes and a friendly smile\n", "Seed: 4217\n", "Number of steps: 30\n" ] } ], "source": [ "print(\"Pipeline settings\")\n", "print(f\"Input text: {text_prompt}\")\n", "print(f\"Seed: {seed}\")\n", "print(f\"Number of steps: {num_steps}\")" ] }, { "cell_type": "code", "execution_count": 15, "id": "f251a4bf-7039-49e3-a93a-e91c0eaad22a", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "bf6c953196684747ba8f258b6801ca50", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/30 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "text = \"\\n\\t\".join(text_prompt.split(\".\"))\n", "print(\"Input text:\")\n", "print(\"\\t\" + text)\n", "display(result[\"sample\"][0])" ] }, { "attachments": {}, "cell_type": "markdown", "id": "f3d0aa91-2739-4401-ab63-c21c5a027058", "metadata": {}, "source": [ "### Image-to-Image generation\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "One of the most amazing features of Stable Diffusion model is the ability to condition image generation from an existing image or sketch. Given a (potentially crude) image and the right text prompt, latent diffusion models can be used to “enhance” an image." ] }, { "cell_type": "code", "execution_count": 17, "id": "ceebfd05-769f-4807-bd19-5ed117565711", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Pipeline settings\n", "Input text: Highly detailed realistic portrait of a grumpy small, adorable cat with round, expressive eyes\n", "Seed: 4217\n", "Number of steps: 15\n", "Strength: 0.87\n", "Guidance scale: 7.5\n" ] }, { "data": { "image/jpeg": "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", "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from diffusers.utils import load_image\n", "\n", "default_image_url = \"https://user-images.githubusercontent.com/29454499/274843996-b0d97f9b-7bfb-4d33-a6d8-d1822eec41ce.jpg\"\n", "text_i2i_prompt = \"Highly detailed realistic portrait of a grumpy small, adorable cat with round, expressive eyes\"\n", "strength = 0.87\n", "guidance_scale = 7.5\n", "num_i2i_steps = 15\n", "seed_i2i = seed\n", "\n", "image = load_image(default_image_url)\n", "print(\"Pipeline settings\")\n", "print(f\"Input text: {text_i2i_prompt}\")\n", "print(f\"Seed: {seed_i2i}\")\n", "print(f\"Number of steps: {num_i2i_steps}\")\n", "print(f\"Strength: {strength}\")\n", "print(f\"Guidance scale: {guidance_scale}\")\n", "display(image)" ] }, { "cell_type": "code", "execution_count": 18, "id": "7627ab4a-6a38-4c5e-955f-9b2ba4efed8d", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "52005158a8374a18a53041ee203c8fb5", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/13 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "text = \"\\n\\t\".join(text_i2i_prompt.split(\".\"))\n", "print(\"Input text:\")\n", "print(\"\\t\" + text)\n", "display(result[\"sample\"][0])" ] }, { "attachments": {}, "cell_type": "markdown", "id": "0075bf16", "metadata": {}, "source": [ "## Quantization\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "[NNCF](https://github.com/openvinotoolkit/nncf/) enables post-training quantization by adding quantization layers into model graph and then using a subset of the training dataset to initialize the parameters of these additional quantization layers. Quantized operations are executed in `INT8` instead of `FP16` making model inference faster.\n", "\n", "According to `DeciDiffusion` structure, the `UNet NAS` model takes up significant portion of the overall pipeline execution time. Now we will show you how to optimize the UNet part using NNCF to reduce computation cost and speed up the pipeline. Quantizing the rest of the `DeciDiffusion` pipeline does not significantly improve inference performance but can lead to a substantial degradation of accuracy.\n", "\n", "The optimization process contains the following steps:\n", "\n", "1. Create a calibration dataset for quantization.\n", "2. Run `nncf.quantize()` to obtain quantized model.\n", "3. Save the `INT8` model using `openvino.save_model()` function.\n", "\n", "Please select below whether you would like to run quantization to improve model inference speed." ] }, { "cell_type": "code", "execution_count": 20, "id": "66980c5d", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "39d5cc6102c648ecb99563c49ca649d4", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Checkbox(value=True, description='Quantization')" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "skip_for_device = \"GPU\" in device.value\n", "to_quantize = widgets.Checkbox(value=not skip_for_device, description=\"Quantization\", disabled=skip_for_device)\n", "to_quantize" ] }, { "attachments": {}, "cell_type": "markdown", "id": "5fcf00ec", "metadata": {}, "source": [ "Let's load `skip magic` extension to skip quantization if `to_quantize` is not selected" ] }, { "cell_type": "code", "execution_count": 21, "id": "de745904", "metadata": {}, "outputs": [], "source": [ "# Fetch `skip_kernel_extension` module\n", "import requests\n", "\n", "r = requests.get(\n", " url=\"https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/latest/utils/skip_kernel_extension.py\",\n", ")\n", "open(\"skip_kernel_extension.py\", \"w\").write(r.text)\n", "\n", "int8_pipe = None\n", "\n", "%load_ext skip_kernel_extension" ] }, { "attachments": {}, "cell_type": "markdown", "id": "620932bc", "metadata": {}, "source": [ "### Prepare calibration dataset\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "We use a portion of [conceptual_captions](https://huggingface.co/datasets/conceptual_captions) dataset from Hugging Face as calibration data.\n", "To collect intermediate model inputs for calibration we should customize `CompiledModel`." ] }, { "cell_type": "code", "execution_count": 22, "id": "9548733e", "metadata": {}, "outputs": [], "source": [ "%%skip not $to_quantize.value\n", "\n", "class CompiledModelDecorator(ov.CompiledModel):\n", " def __init__(self, compiled_model, prob=0.5):\n", " super().__init__(compiled_model)\n", " self.data_cache = []\n", " self.prob = np.clip(prob, 0, 1)\n", "\n", " def __call__(self, *args, **kwargs):\n", " if np.random.rand() >= self.prob:\n", " self.data_cache.append(*args)\n", " return super().__call__(*args, **kwargs)" ] }, { "cell_type": "code", "execution_count": 23, "id": "87306b4e", "metadata": {}, "outputs": [], "source": [ "%%skip not $to_quantize.value\n", "\n", "import datasets\n", "from tqdm.notebook import tqdm\n", "from transformers import set_seed\n", "from typing import Any, Dict, List\n", "\n", "set_seed(1)\n", "\n", "def collect_calibration_data(pipeline: OVStableDiffusionPipeline, subset_size: int) -> List[Dict]:\n", " original_unet = pipeline.unet\n", " pipeline.unet = CompiledModelDecorator(original_unet, prob=0.3)\n", " pipeline.set_progress_bar_config(disable=True)\n", "\n", " dataset = datasets.load_dataset(\"conceptual_captions\", split=\"train\", streaming=True).shuffle(seed=42)\n", "\n", " pbar = tqdm(total=subset_size)\n", " for batch in dataset:\n", " prompt = batch[\"caption\"]\n", " if len(prompt) > tokenizer.model_max_length:\n", " continue\n", " _ = pipeline(prompt, num_inference_steps=num_steps, seed=seed)\n", " collected_subset_size = len(pipeline.unet.data_cache)\n", " if collected_subset_size >= subset_size:\n", " pbar.update(subset_size - pbar.n)\n", " break\n", " pbar.update(collected_subset_size - pbar.n)\n", "\n", " calibration_dataset = pipeline.unet.data_cache\n", " pipeline.set_progress_bar_config(disable=False)\n", " pipeline.unet = original_unet\n", " return calibration_dataset" ] }, { "cell_type": "code", "execution_count": 24, "id": "e07943eb", "metadata": { "test_replace": { "subset_size = 300": "subset_size = 10" } }, "outputs": [], "source": [ "%%skip not $to_quantize.value\n", "\n", "UNET_INT8_OV_PATH = Path('model/unet_nas_int8.xml')\n", "\n", "if not UNET_INT8_OV_PATH.exists():\n", " subset_size = 300\n", " unet_calibration_data = collect_calibration_data(ov_pipe, subset_size=subset_size)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "37bf3d8f", "metadata": {}, "source": [ "### Run quantization\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "Create a quantized model from the pre-trained converted OpenVINO model.\n", "\n", "> **NOTE**: Quantization is time and memory consuming operation. Running quantization code below may take some time." ] }, { "cell_type": "code", "execution_count": 25, "id": "6a58f643", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "INFO:nncf:NNCF initialized successfully. Supported frameworks detected: torch, tensorflow, onnx, openvino\n" ] } ], "source": [ "%%skip not $to_quantize.value\n", "\n", "import nncf\n", "\n", "UNET_INT8_OV_PATH = Path('model/unet_nas_int8.xml')\n", "\n", "if not UNET_INT8_OV_PATH.exists():\n", " unet = core.read_model(UNET_OV_PATH)\n", " quantized_unet = nncf.quantize(\n", " model=unet,\n", " subset_size=subset_size,\n", " calibration_dataset=nncf.Dataset(unet_calibration_data),\n", " model_type=nncf.ModelType.TRANSFORMER,\n", " # Smooth Quant algorithm reduces activation quantization error; optimal alpha value was obtained through grid search\n", " advanced_parameters=nncf.AdvancedQuantizationParameters(\n", " smooth_quant_alpha=0.05,\n", " )\n", " )\n", " ov.save_model(quantized_unet, UNET_INT8_OV_PATH)" ] }, { "cell_type": "code", "execution_count": 26, "id": "44b7db8c", "metadata": {}, "outputs": [], "source": [ "%%skip not $to_quantize.value\n", "\n", "unet_optimized = core.compile_model(UNET_INT8_OV_PATH, device.value)\n", "\n", "int8_pipe = OVStableDiffusionPipeline(\n", " tokenizer=tokenizer,\n", " text_encoder=text_enc,\n", " unet=unet_optimized,\n", " vae_encoder=vae_encoder,\n", " vae_decoder=vae_decoder,\n", " scheduler=scheduler\n", ")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "068a5117", "metadata": {}, "source": [ "Let us check predictions with the quantized UNet using the same input data." ] }, { "cell_type": "code", "execution_count": 27, "id": "1946b504", "metadata": {}, "outputs": [], "source": [ "%%skip not $to_quantize.value\n", "\n", "import matplotlib.pyplot as plt\n", "from PIL import Image\n", "\n", "def visualize_results(orig_img:Image.Image, optimized_img:Image.Image):\n", " \"\"\"\n", " Helper function for results visualization\n", "\n", " Parameters:\n", " orig_img (Image.Image): generated image using FP16 models\n", " optimized_img (Image.Image): generated image using quantized models\n", " Returns:\n", " fig (matplotlib.pyplot.Figure): matplotlib generated figure contains drawing result\n", " \"\"\"\n", " orig_title = \"FP16 pipeline\"\n", " control_title = \"INT8 pipeline\"\n", " figsize = (20, 20)\n", " fig, axs = plt.subplots(1, 2, figsize=figsize, sharex='all', sharey='all')\n", " list_axes = list(axs.flat)\n", " for a in list_axes:\n", " a.set_xticklabels([])\n", " a.set_yticklabels([])\n", " a.get_xaxis().set_visible(False)\n", " a.get_yaxis().set_visible(False)\n", " a.grid(False)\n", " list_axes[0].imshow(np.array(orig_img))\n", " list_axes[1].imshow(np.array(optimized_img))\n", " list_axes[0].set_title(orig_title, fontsize=15)\n", " list_axes[1].set_title(control_title, fontsize=15)\n", "\n", " fig.subplots_adjust(wspace=0.01, hspace=0.01)\n", " fig.tight_layout()\n", " return fig" ] }, { "attachments": {}, "cell_type": "markdown", "id": "1d8ddf6f", "metadata": {}, "source": [ "Text-to-Image generation" ] }, { "cell_type": "code", "execution_count": 28, "id": "8914df6b", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "fe91727f0e4e4d32b5c18564f0b8cb2d", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/30 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%skip not $to_quantize.value\n", "\n", "fp16_image = ov_pipe(text_prompt, num_inference_steps=num_steps, seed=seed)['sample'][0]\n", "int8_image = int8_pipe(text_prompt, num_inference_steps=num_steps, seed=seed)['sample'][0]\n", "fig = visualize_results(fp16_image, int8_image)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "af613aef", "metadata": {}, "source": [ "Image-to-Image generation" ] }, { "cell_type": "code", "execution_count": 29, "id": "230dcd51", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "24232e2d39c441399ce35f95a0aee6ac", "version_major": 2, "version_minor": 0 }, "text/plain": [ " 0%| | 0/13 [00:00" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%skip not $to_quantize.value\n", "\n", "fp16_text_i2i = ov_pipe(text_i2i_prompt, image, guidance_scale=guidance_scale, strength=strength, num_inference_steps=num_i2i_steps, seed=seed_i2i)['sample'][0]\n", "int8_text_i2i = int8_pipe(text_i2i_prompt, image, guidance_scale=guidance_scale, strength=strength, num_inference_steps=num_i2i_steps, seed=seed_i2i)['sample'][0]\n", "fig = visualize_results(fp16_text_i2i, int8_text_i2i)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "150316f0", "metadata": {}, "source": [ "### Compare inference time of the FP16 and INT8 pipelines\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "To measure the inference performance of the `FP16` and `INT8` pipelines, we use median inference time on calibration subset.\n", "\n", "> **NOTE**: For the most accurate performance estimation, it is recommended to run `benchmark_app` in a terminal/command prompt after closing other applications." ] }, { "cell_type": "code", "execution_count": 30, "id": "aaab650d", "metadata": {}, "outputs": [], "source": [ "%%skip not $to_quantize.value\n", "\n", "import time\n", "\n", "validation_size = 10\n", "calibration_dataset = datasets.load_dataset(\"conceptual_captions\", split=\"train\", streaming=True)\n", "validation_data = []\n", "for idx, batch in enumerate(calibration_dataset):\n", " if idx >= validation_size:\n", " break\n", " prompt = batch[\"caption\"]\n", " validation_data.append(prompt)\n", "\n", "def calculate_inference_time(pipeline, calibration_dataset):\n", " inference_time = []\n", " pipeline.set_progress_bar_config(disable=True)\n", " for idx, prompt in enumerate(validation_data):\n", " start = time.perf_counter()\n", " _ = pipeline(prompt, num_inference_steps=num_steps, seed=seed)\n", " end = time.perf_counter()\n", " delta = end - start\n", " inference_time.append(delta)\n", " if idx >= validation_size:\n", " break\n", " return np.median(inference_time)" ] }, { "cell_type": "code", "execution_count": 31, "id": "6df2c282", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Performance speed up: 2.305\n" ] } ], "source": [ "%%skip not $to_quantize.value\n", "\n", "fp_latency = calculate_inference_time(ov_pipe, validation_data)\n", "int8_latency = calculate_inference_time(int8_pipe, validation_data)\n", "print(f\"Performance speed up: {fp_latency / int8_latency:.3f}\")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "0a82b780", "metadata": {}, "source": [ "#### Compare UNet file size\n", "[back to top ⬆️](#Table-of-contents:)\n" ] }, { "cell_type": "code", "execution_count": 32, "id": "04bdc5b1", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "FP16 model size: 1591318.15 KB\n", "INT8 model size: 797158.32 KB\n", "Model compression rate: 1.996\n" ] } ], "source": [ "%%skip not $to_quantize.value\n", "\n", "fp16_ir_model_size = UNET_OV_PATH.with_suffix(\".bin\").stat().st_size / 1024\n", "quantized_model_size = UNET_INT8_OV_PATH.with_suffix(\".bin\").stat().st_size / 1024\n", "\n", "print(f\"FP16 model size: {fp16_ir_model_size:.2f} KB\")\n", "print(f\"INT8 model size: {quantized_model_size:.2f} KB\")\n", "print(f\"Model compression rate: {fp16_ir_model_size / quantized_model_size:.3f}\")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "d3a27c6e-c16d-40ab-b6ea-68f3d8d95d80", "metadata": {}, "source": [ "## Interactive demo\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "Please select below whether you would like to use the quantized model to launch the interactive demo." ] }, { "cell_type": "code", "execution_count": 33, "id": "62009c49", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "8c7d56af4b7445b0995c9ca109e4b143", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Checkbox(value=True, description='Use quantized model')" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "quantized_model_present = int8_pipe is not None\n", "\n", "use_quantized_model = widgets.Checkbox(\n", " value=True if quantized_model_present else False,\n", " description=\"Use quantized model\",\n", " disabled=not quantized_model_present,\n", ")\n", "\n", "use_quantized_model" ] }, { "cell_type": "code", "execution_count": null, "id": "61c9a1ab-91da-417c-aefe-ed81aa0bb924", "metadata": {}, "outputs": [], "source": [ "import gradio as gr\n", "\n", "sample_img_url = \"https://storage.openvinotoolkit.org/repositories/openvino_notebooks/data/data/image/tower.jpg\"\n", "\n", "img = load_image(sample_img_url).save(\"tower.jpg\")\n", "pipeline = int8_pipe if use_quantized_model.value else ov_pipe\n", "\n", "\n", "def generate_from_text(\n", " text,\n", " negative_prompt,\n", " seed,\n", " num_steps,\n", " guidance_scale,\n", " _=gr.Progress(track_tqdm=True),\n", "):\n", " result = pipeline(\n", " text,\n", " negative_prompt=negative_prompt,\n", " num_inference_steps=num_steps,\n", " seed=seed,\n", " guidance_scale=guidance_scale,\n", " )\n", " return result[\"sample\"][0]\n", "\n", "\n", "def generate_from_image(\n", " img,\n", " text,\n", " negative_prompt,\n", " seed,\n", " num_steps,\n", " strength,\n", " guidance_scale,\n", " _=gr.Progress(track_tqdm=True),\n", "):\n", " result = pipeline(\n", " text,\n", " img,\n", " negative_prompt=negative_prompt,\n", " num_inference_steps=num_steps,\n", " seed=seed,\n", " strength=strength,\n", " guidance_scale=guidance_scale,\n", " )\n", " return result[\"sample\"][0]\n", "\n", "\n", "with gr.Blocks() as demo:\n", " with gr.Tab(\"Text-to-Image generation\"):\n", " with gr.Row():\n", " with gr.Column():\n", " text_input = gr.Textbox(lines=3, label=\"Positive prompt\")\n", " neg_text_input = gr.Textbox(lines=3, label=\"Negative prompt\")\n", " seed_input = gr.Slider(0, 10000000, value=751, label=\"Seed\")\n", " steps_input = gr.Slider(1, 50, value=20, step=1, label=\"Steps\")\n", " guidance_scale = gr.Slider(label=\"Guidance Scale\", minimum=0, maximum=50, value=0.7, step=0.1)\n", " out = gr.Image(label=\"Result\", type=\"pil\")\n", " sample_text = (\n", " \"futuristic synthwave city, retro sunset, crystals, spires, volumetric lighting, studio Ghibli style, rendered in unreal engine with clean details\"\n", " )\n", " sample_text2 = \"Highly detailed realistic portrait of a grumpy small, adorable cat with round, expressive eyes\"\n", " btn = gr.Button()\n", " btn.click(\n", " generate_from_text,\n", " [text_input, neg_text_input, seed_input, steps_input, guidance_scale],\n", " out,\n", " )\n", " gr.Examples(\n", " [[sample_text, \"\", 42, 20, 0.7], [sample_text2, \"\", 4218, 20, 0.7]],\n", " [text_input, neg_text_input, seed_input, steps_input, guidance_scale],\n", " )\n", " with gr.Tab(\"Image-to-Image generation\"):\n", " with gr.Row():\n", " with gr.Column():\n", " i2i_input = gr.Image(label=\"Image\", type=\"pil\")\n", " i2i_text_input = gr.Textbox(lines=3, label=\"Text\")\n", " i2i_neg_text_input = gr.Textbox(lines=3, label=\"Negative prompt\")\n", " i2i_seed_input = gr.Slider(0, 10000000, value=42, label=\"Seed\")\n", " i2i_steps_input = gr.Slider(1, 50, value=10, step=1, label=\"Steps\")\n", " strength_input = gr.Slider(0, 1, value=0.5, label=\"Strength\")\n", " i2i_guidance_scale = gr.Slider(label=\"Guidance Scale\", minimum=0, maximum=50, value=0.7, step=0.1)\n", " i2i_out = gr.Image(label=\"Result\", type=\"pil\")\n", " i2i_btn = gr.Button()\n", " sample_i2i_text = \"amazing watercolor painting\"\n", " i2i_btn.click(\n", " generate_from_image,\n", " [\n", " i2i_input,\n", " i2i_text_input,\n", " i2i_neg_text_input,\n", " i2i_seed_input,\n", " i2i_steps_input,\n", " strength_input,\n", " i2i_guidance_scale,\n", " ],\n", " i2i_out,\n", " )\n", " gr.Examples(\n", " [[\"tower.jpg\", sample_i2i_text, \"\", 6400023, 30, 0.6, 5]],\n", " [\n", " i2i_input,\n", " i2i_text_input,\n", " i2i_neg_text_input,\n", " i2i_seed_input,\n", " i2i_steps_input,\n", " strength_input,\n", " i2i_guidance_scale,\n", " ],\n", " )\n", "\n", "try:\n", " demo.queue().launch(debug=True)\n", "except Exception:\n", " demo.queue().launch(share=True, debug=True)\n", "# if you are launching remotely, specify server_name and server_port\n", "# demo.launch(server_name='your server name', server_port='server port in int')\n", "# Read more in the docs: https://gradio.app/docs/" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.10" }, "openvino_notebooks": { "imageUrl": "https://github.com/openvinotoolkit/openvino_notebooks/blob/latest/notebooks/decidiffusion-image-generation/decidiffusion-image-generation.png?raw=true", "tags": { "categories": [ "Model Demos", "AI Trends" ], "libraries": [], "other": [ "Stable Diffusion" ], "tasks": [ "Image-to-Image", "Text-to-Image" ] } }, "widgets": { "application/vnd.jupyter.widget-state+json": { "state": {}, "version_major": 2, "version_minor": 0 } } }, "nbformat": 4, "nbformat_minor": 5 }