{ "cells": [ { "attachments": {}, "cell_type": "markdown", "id": "ed3140bd-24c7-4eb3-9a1a-2b9ece1e2e76", "metadata": {}, "source": [ "# Lightweight image generation with aMUSEd and OpenVINO\n", "\n", "[Amused](https://huggingface.co/docs/diffusers/api/pipelines/amused) is a lightweight text to image model based off of the [muse](https://arxiv.org/pdf/2301.00704.pdf) architecture. Amused is particularly useful in applications that require a lightweight and fast model such as generating many images quickly at once.\n", "\n", "Amused is a VQVAE token based transformer that can generate an image in fewer forward passes than many diffusion models. In contrast with muse, it uses the smaller text encoder CLIP-L/14 instead of t5-xxl. Due to its small parameter count and few forward pass generation process, amused can generate many images quickly. This benefit is seen particularly at larger batch sizes.\n", "\n", " \n" ] }, { "attachments": {}, "cell_type": "markdown", "id": "836f7a88-8d7f-43b7-b0c7-394a7483d932", "metadata": {}, "source": [ "\n", "\n", "\n", "\n", "\n", "\n", "#### Table of contents:\n", "\n", "- [Prerequisites](#Prerequisites)\n", "- [Load and run the original pipeline](#Load-and-run-the-original-pipeline)\n", "- [Convert the model to OpenVINO IR](#Convert-the-model-to-OpenVINO-IR)\n", " - [Convert the Text Encoder](#Convert-the-Text-Encoder)\n", " - [Convert the U-ViT transformer](#Convert-the-U-ViT-transformer)\n", " - [Convert VQ-GAN decoder (VQVAE)](#Convert-VQ-GAN-decoder-(VQVAE))\n", "- [Compiling models and prepare pipeline](#Compiling-models-and-prepare-pipeline)\n", "- [Quantization](#Quantization)\n", " - [Prepare calibration dataset](#Prepare-calibration-dataset)\n", " - [Run model quantization](#Run-model-quantization)\n", " - [Compute Inception Scores and inference time](#Compute-Inception-Scores-and-inference-time)\n", "- [Interactive inference](#Interactive-inference)\n", "\n" ] }, { "attachments": {}, "cell_type": "markdown", "id": "6e8f0c42-62f4-44f1-90a3-2bf33d797aa3", "metadata": {}, "source": [ "## Prerequisites\n", "[back to top ⬆️](#Table-of-contents:)" ] }, { "cell_type": "code", "execution_count": 1, "id": "acba1777-2480-4f55-922b-a61c2d3be0ce", "metadata": { "ExecuteTime": { "end_time": "2024-04-11T14:00:35.760045Z", "start_time": "2024-04-11T14:00:35.754903Z" } }, "outputs": [], "source": [ "%pip install -q transformers \"diffusers>=0.25.0\" \"openvino>=2023.2.0\" \"accelerate>=0.20.3\" \"gradio>=4.19\" \"torch>=2.1\" \"pillow\" \"torchmetrics\" \"torch-fidelity\" --extra-index-url https://download.pytorch.org/whl/cpu\n", "%pip install -q \"nncf>=2.9.0\" datasets" ] }, { "attachments": {}, "cell_type": "markdown", "id": "31b4f27a-c164-499f-8cfe-4e94509b5384", "metadata": {}, "source": [ "## Load and run the original pipeline\n", "[back to top ⬆️](#Table-of-contents:)" ] }, { "cell_type": "code", "execution_count": 2, "id": "740ff68e-2468-4a40-a51e-04f2e5f80a2d", "metadata": { "ExecuteTime": { "end_time": "2024-04-11T14:00:47.188490Z", "start_time": "2024-04-11T14:00:35.893193Z" }, "scrolled": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/nsavel/venvs/ov_notebooks/lib/python3.8/site-packages/diffusers/utils/outputs.py:63: UserWarning: torch.utils._pytree._register_pytree_node is deprecated. Please use torch.utils._pytree.register_pytree_node instead.\n", " torch.utils._pytree._register_pytree_node(\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "8f735abcf39f4dc88eccf9445a05c10c", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Loading pipeline components...: 0%| | 0/5 [00:00" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "image" ] }, { "attachments": {}, "cell_type": "markdown", "id": "9c38f8d4-fa96-4ba0-abe0-8f6050bb1c22", "metadata": {}, "source": [ "## Convert the model to OpenVINO IR\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "aMUSEd consists of three separately trained components: a pre-trained CLIP-L/14 text encoder, a VQ-GAN, and a U-ViT.\n", "\n", "![image_png](https://cdn-uploads.huggingface.co/production/uploads/5dfcb1aada6d0311fd3d5448/97ca2Vqm7jBfCAzq20TtF.png)\n", "\n", "During inference, the U-ViT is conditioned on the text encoder’s hidden states and iteratively predicts values for all masked tokens. The cosine masking schedule determines a percentage of the most confident token predictions to be fixed after every iteration. After 12 iterations, all tokens have been predicted and are decoded by the VQ-GAN into image pixels." ] }, { "attachments": {}, "cell_type": "markdown", "id": "be642b08-96d3-437d-8057-21f37777a9e6", "metadata": {}, "source": [ "Define paths for converted models:" ] }, { "cell_type": "code", "execution_count": 4, "id": "a8801bd8-96e3-4db4-8cd1-362ccb6c7e99", "metadata": { "ExecuteTime": { "end_time": "2024-04-11T14:00:47.209047Z", "start_time": "2024-04-11T14:00:47.203859Z" } }, "outputs": [], "source": [ "from pathlib import Path\n", "\n", "\n", "TRANSFORMER_OV_PATH = Path(\"models/transformer_ir.xml\")\n", "TEXT_ENCODER_OV_PATH = Path(\"models/text_encoder_ir.xml\")\n", "VQVAE_OV_PATH = Path(\"models/vqvae_ir.xml\")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "24868d33-c539-454c-ab27-5cbe99091dba", "metadata": {}, "source": [ "Define the conversion function for PyTorch modules. We use `ov.convert_model` function to obtain OpenVINO Intermediate Representation object and `ov.save_model` function to save it as XML file." ] }, { "cell_type": "code", "execution_count": 5, "id": "1e7fb475-fd84-46e9-9ced-6b50628df8e2", "metadata": { "ExecuteTime": { "end_time": "2024-04-11T14:00:47.262438Z", "start_time": "2024-04-11T14:00:47.212279Z" } }, "outputs": [], "source": [ "import torch\n", "\n", "import openvino as ov\n", "\n", "\n", "def convert(model: torch.nn.Module, xml_path: str, example_input):\n", " xml_path = Path(xml_path)\n", " if not xml_path.exists():\n", " xml_path.parent.mkdir(parents=True, exist_ok=True)\n", " with torch.no_grad():\n", " converted_model = ov.convert_model(model, example_input=example_input)\n", " ov.save_model(converted_model, xml_path, compress_to_fp16=False)\n", "\n", " # cleanup memory\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()" ] }, { "attachments": {}, "cell_type": "markdown", "id": "a3fbfa19-293c-4a64-9d32-9fa58df2062e", "metadata": {}, "source": [ "### Convert the Text Encoder\n", "[back to top ⬆️](#Table-of-contents:)" ] }, { "cell_type": "code", "execution_count": 6, "id": "a095363b-24b3-436d-8399-2797494829fb", "metadata": { "ExecuteTime": { "end_time": "2024-04-11T14:00:47.268900Z", "start_time": "2024-04-11T14:00:47.263821Z" } }, "outputs": [], "source": [ "class TextEncoderWrapper(torch.nn.Module):\n", " def __init__(self, text_encoder):\n", " super().__init__()\n", " self.text_encoder = text_encoder\n", "\n", " def forward(self, input_ids=None, return_dict=None, output_hidden_states=None):\n", " outputs = self.text_encoder(\n", " input_ids=input_ids,\n", " return_dict=return_dict,\n", " output_hidden_states=output_hidden_states,\n", " )\n", "\n", " return outputs.text_embeds, outputs.last_hidden_state, outputs.hidden_states\n", "\n", "\n", "input_ids = pipe.tokenizer(\n", " prompt,\n", " return_tensors=\"pt\",\n", " padding=\"max_length\",\n", " truncation=True,\n", " max_length=pipe.tokenizer.model_max_length,\n", ")\n", "\n", "input_example = {\n", " \"input_ids\": input_ids.input_ids,\n", " \"return_dict\": torch.tensor(True),\n", " \"output_hidden_states\": torch.tensor(True),\n", "}\n", "\n", "convert(TextEncoderWrapper(pipe.text_encoder), TEXT_ENCODER_OV_PATH, input_example)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "1f91cd05-3b5b-46ec-89a9-bdaa711d4665", "metadata": {}, "source": [ "### Convert the U-ViT transformer\n", "[back to top ⬆️](#Table-of-contents:)" ] }, { "cell_type": "code", "execution_count": 7, "id": "b928ba09-b7dd-4071-9c64-51290c5b0461", "metadata": { "ExecuteTime": { "end_time": "2024-04-11T14:00:47.279093Z", "start_time": "2024-04-11T14:00:47.269958Z" } }, "outputs": [], "source": [ "class TransformerWrapper(torch.nn.Module):\n", " def __init__(self, transformer):\n", " super().__init__()\n", " self.transformer = transformer\n", "\n", " def forward(\n", " self,\n", " latents=None,\n", " micro_conds=None,\n", " pooled_text_emb=None,\n", " encoder_hidden_states=None,\n", " ):\n", " return self.transformer(\n", " latents,\n", " micro_conds=micro_conds,\n", " pooled_text_emb=pooled_text_emb,\n", " encoder_hidden_states=encoder_hidden_states,\n", " )\n", "\n", "\n", "shape = (1, 16, 16)\n", "latents = torch.full(shape, pipe.scheduler.config.mask_token_id, dtype=torch.long)\n", "latents = torch.cat([latents] * 2)\n", "\n", "\n", "example_input = {\n", " \"latents\": latents,\n", " \"micro_conds\": torch.rand([2, 5], dtype=torch.float32),\n", " \"pooled_text_emb\": torch.rand([2, 768], dtype=torch.float32),\n", " \"encoder_hidden_states\": torch.rand([2, 77, 768], dtype=torch.float32),\n", "}\n", "\n", "\n", "pipe.transformer.eval()\n", "w_transformer = TransformerWrapper(pipe.transformer)\n", "convert(w_transformer, TRANSFORMER_OV_PATH, example_input)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "fb1c619c-b134-4a45-bed6-061da6b298a4", "metadata": {}, "source": [ "### Convert VQ-GAN decoder (VQVAE)\n", "[back to top ⬆️](#Table-of-contents:)\n", "Function `get_latents` is needed to return real latents for the conversion. Due to the VQVAE implementation autogenerated tensor of the required shape is not suitable. This function repeats part of `AmusedPipeline`." ] }, { "cell_type": "code", "execution_count": 8, "id": "19d5aab3-a28c-4688-a567-3c2141c75487", "metadata": { "ExecuteTime": { "end_time": "2024-04-11T14:00:47.978414Z", "start_time": "2024-04-11T14:00:47.280157Z" } }, "outputs": [], "source": [ "def get_latents():\n", " shape = (1, 16, 16)\n", " latents = torch.full(shape, pipe.scheduler.config.mask_token_id, dtype=torch.long)\n", " model_input = torch.cat([latents] * 2)\n", "\n", " model_output = pipe.transformer(\n", " model_input,\n", " micro_conds=torch.rand([2, 5], dtype=torch.float32),\n", " pooled_text_emb=torch.rand([2, 768], dtype=torch.float32),\n", " encoder_hidden_states=torch.rand([2, 77, 768], dtype=torch.float32),\n", " )\n", " guidance_scale = 10.0\n", " uncond_logits, cond_logits = model_output.chunk(2)\n", " model_output = uncond_logits + guidance_scale * (cond_logits - uncond_logits)\n", "\n", " latents = pipe.scheduler.step(\n", " model_output=model_output,\n", " timestep=torch.tensor(0),\n", " sample=latents,\n", " ).prev_sample\n", "\n", " return latents\n", "\n", "\n", "class VQVAEWrapper(torch.nn.Module):\n", " def __init__(self, vqvae):\n", " super().__init__()\n", " self.vqvae = vqvae\n", "\n", " def forward(self, latents=None, force_not_quantize=True, shape=None):\n", " outputs = self.vqvae.decode(\n", " latents,\n", " force_not_quantize=force_not_quantize,\n", " shape=shape.tolist(),\n", " )\n", "\n", " return outputs\n", "\n", "\n", "latents = get_latents()\n", "example_vqvae_input = {\n", " \"latents\": latents,\n", " \"force_not_quantize\": torch.tensor(True),\n", " \"shape\": torch.tensor((1, 16, 16, 64)),\n", "}\n", "\n", "convert(VQVAEWrapper(pipe.vqvae), VQVAE_OV_PATH, example_vqvae_input)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "b8c30389-9cc3-486e-93e8-03474161b8e9", "metadata": {}, "source": [ "## Compiling models and prepare pipeline\n", "[back to top ⬆️](#Table-of-contents:)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "113b5a88-8b21-43a8-b453-88065ef06e8b", "metadata": {}, "source": [ "Select device from dropdown list for running inference using OpenVINO." ] }, { "cell_type": "code", "execution_count": 9, "id": "54f6f251-589b-49a8-baec-a6b94ddd55e4", "metadata": { "ExecuteTime": { "end_time": "2024-04-11T14:00:48.263618Z", "start_time": "2024-04-11T14:00:47.979474Z" } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "cb5827295551492db8bec5a898c0a92b", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Dropdown(description='Device:', index=4, options=('CPU', 'GPU.0', 'GPU.1', 'GPU.2', 'AUTO'), value='AUTO')" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import ipywidgets as widgets\n", "\n", "\n", "core = ov.Core()\n", "device = widgets.Dropdown(\n", " options=core.available_devices + [\"AUTO\"],\n", " value=\"AUTO\",\n", " description=\"Device:\",\n", " disabled=False,\n", ")\n", "\n", "device" ] }, { "cell_type": "code", "execution_count": 11, "id": "e8b94b29-a65b-42ae-974d-52bb28090fc6", "metadata": { "ExecuteTime": { "end_time": "2024-04-11T14:00:51.127648Z", "start_time": "2024-04-11T14:00:48.280087Z" } }, "outputs": [], "source": [ "ov_text_encoder = core.compile_model(TEXT_ENCODER_OV_PATH, device.value)\n", "ov_transformer = core.compile_model(TRANSFORMER_OV_PATH, device.value)\n", "ov_vqvae = core.compile_model(VQVAE_OV_PATH, device.value)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "1a05be62-e609-4a9a-9aec-243550d9e523", "metadata": {}, "source": [ "Let's create callable wrapper classes for compiled models to allow interaction with original `AmusedPipeline` class. Note that all of wrapper classes return `torch.Tensor`s instead of `np.array`s.\n" ] }, { "cell_type": "code", "execution_count": 12, "id": "79dc24a0-5a0e-4e76-8c79-621e402a5633", "metadata": { "ExecuteTime": { "end_time": "2024-04-11T14:00:51.135641Z", "start_time": "2024-04-11T14:00:51.129625Z" } }, "outputs": [], "source": [ "from collections import namedtuple\n", "\n", "\n", "class ConvTextEncoderWrapper(torch.nn.Module):\n", " def __init__(self, text_encoder, config):\n", " super().__init__()\n", " self.config = config\n", " self.text_encoder = text_encoder\n", "\n", " def forward(self, input_ids=None, return_dict=None, output_hidden_states=None):\n", " inputs = {\n", " \"input_ids\": input_ids,\n", " \"return_dict\": return_dict,\n", " \"output_hidden_states\": output_hidden_states,\n", " }\n", "\n", " outs = self.text_encoder(inputs)\n", "\n", " outputs = namedtuple(\"CLIPTextModelOutput\", (\"text_embeds\", \"last_hidden_state\", \"hidden_states\"))\n", "\n", " text_embeds = torch.from_numpy(outs[0])\n", " last_hidden_state = torch.from_numpy(outs[1])\n", " hidden_states = list(torch.from_numpy(out) for out in outs.values())[2:]\n", "\n", " return outputs(text_embeds, last_hidden_state, hidden_states)" ] }, { "cell_type": "code", "execution_count": 13, "id": "fb328c35-80a6-4650-8c17-82e8b8b50b93", "metadata": { "ExecuteTime": { "end_time": "2024-04-11T14:00:51.148280Z", "start_time": "2024-04-11T14:00:51.136957Z" } }, "outputs": [], "source": [ "class ConvTransformerWrapper(torch.nn.Module):\n", " def __init__(self, transformer, config):\n", " super().__init__()\n", " self.config = config\n", " self.transformer = transformer\n", "\n", " def forward(self, latents=None, micro_conds=None, pooled_text_emb=None, encoder_hidden_states=None, **kwargs):\n", " outputs = self.transformer(\n", " {\n", " \"latents\": latents,\n", " \"micro_conds\": micro_conds,\n", " \"pooled_text_emb\": pooled_text_emb,\n", " \"encoder_hidden_states\": encoder_hidden_states,\n", " },\n", " share_inputs=False,\n", " )\n", "\n", " return torch.from_numpy(outputs[0])" ] }, { "cell_type": "code", "execution_count": 14, "id": "e19f4ab7-85a7-41b2-b5bb-a5e544a3660c", "metadata": { "ExecuteTime": { "end_time": "2024-04-11T14:00:51.156879Z", "start_time": "2024-04-11T14:00:51.150248Z" } }, "outputs": [], "source": [ "class ConvVQVAEWrapper(torch.nn.Module):\n", " def __init__(self, vqvae, dtype, config):\n", " super().__init__()\n", " self.vqvae = vqvae\n", " self.dtype = dtype\n", " self.config = config\n", "\n", " def decode(self, latents=None, force_not_quantize=True, shape=None):\n", " inputs = {\n", " \"latents\": latents,\n", " \"force_not_quantize\": force_not_quantize,\n", " \"shape\": torch.tensor(shape),\n", " }\n", "\n", " outs = self.vqvae(inputs)\n", " outs = namedtuple(\"VQVAE\", \"sample\")(torch.from_numpy(outs[0]))\n", "\n", " return outs" ] }, { "attachments": {}, "cell_type": "markdown", "id": "6752651b-53a4-4f93-8910-6a2aa02ae69c", "metadata": {}, "source": [ "And insert wrappers instances in the pipeline:" ] }, { "cell_type": "code", "execution_count": 15, "id": "2a0067c1-d2ba-4e7d-9643-117f7c9e9c3c", "metadata": { "ExecuteTime": { "end_time": "2024-04-11T14:00:55.131869Z", "start_time": "2024-04-11T14:00:51.158628Z" }, "scrolled": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/nsavel/venvs/ov_notebooks/lib/python3.8/site-packages/diffusers/configuration_utils.py:139: FutureWarning: Accessing config attribute `_execution_device` directly via 'AmusedPipeline' object attribute is deprecated. Please access '_execution_device' over 'AmusedPipeline's config object instead, e.g. 'scheduler.config._execution_device'.\n", " deprecate(\"direct config name access\", \"1.0.0\", deprecation_message, standard_warn=False)\n", "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 12/12 [00:03<00:00, 3.30it/s]\n" ] } ], "source": [ "prompt = \"kind smiling ghost\"\n", "\n", "transformer = pipe.transformer\n", "vqvae = pipe.vqvae\n", "text_encoder = pipe.text_encoder\n", "\n", "pipe.__dict__[\"_internal_dict\"][\"_execution_device\"] = pipe._execution_device # this is to avoid some problem that can occur in the pipeline\n", "pipe.register_modules(\n", " text_encoder=ConvTextEncoderWrapper(ov_text_encoder, text_encoder.config),\n", " transformer=ConvTransformerWrapper(ov_transformer, transformer.config),\n", " vqvae=ConvVQVAEWrapper(ov_vqvae, vqvae.dtype, vqvae.config),\n", ")\n", "\n", "image = pipe(prompt, generator=torch.Generator(\"cpu\").manual_seed(8)).images[0]\n", "image.save(\"text2image_256.png\")" ] }, { "cell_type": "code", "execution_count": 16, "id": "353aed47-2199-494a-a472-3f06c01eecc7", "metadata": { "ExecuteTime": { "end_time": "2024-04-11T14:00:55.144287Z", "start_time": "2024-04-11T14:00:55.133046Z" } }, "outputs": [ { "data": { "image/jpeg": "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", "image/png": "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", "text/plain": [ "" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "image" ] }, { "attachments": {}, "cell_type": "markdown", "id": "25e65a716d719fde", "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 `FP32`/`FP16` making model inference faster.\n", "\n", "According to `Amused` pipeline structure, the vision transformer model takes up significant portion of the overall pipeline execution time. Now we will show you how to optimize the UNet part using [NNCF](https://github.com/openvinotoolkit/nncf/) to reduce computation cost and speed up the pipeline. Quantizing the rest of the pipeline does not significantly improve inference performance but can lead to a substantial degradation of generations quality.\n", "\n", "We also estimate the quality of generations produced by optimized pipeline with [Inception Score](https://en.wikipedia.org/wiki/Inception_score) which is often used to measure quality of text-to-image generation systems.\n", "\n", "The steps are the following:\n", "\n", "1. Create a calibration dataset for quantization.\n", "2. Run `nncf.quantize()` on the model.\n", "3. Save the quantized model using `openvino.save_model()` function.\n", "4. Compare inference time and Inception score for original and quantized pipelines. \n", "\n", "Please select below whether you would like to run quantization to improve model inference speed.\n", "\n", "> **NOTE**: Quantization is time and memory consuming operation. Running quantization code below may take some time." ] }, { "cell_type": "code", "execution_count": null, "id": "794fb99feb8b3d8c", "metadata": { "ExecuteTime": { "end_time": "2024-04-11T15:54:24.345655Z", "start_time": "2024-04-11T15:54:24.315345Z" } }, "outputs": [], "source": [ "QUANTIZED_TRANSFORMER_OV_PATH = Path(str(TRANSFORMER_OV_PATH).replace(\".xml\", \"_quantized.xml\"))\n", "\n", "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" ] }, { "cell_type": "code", "execution_count": 1, "id": "ceec7d9e941bdfde", "metadata": { "ExecuteTime": { "end_time": "2024-04-11T15:53:46.336770Z", "start_time": "2024-04-11T15:53:46.323193Z" } }, "outputs": [], "source": [ "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", "%load_ext skip_kernel_extension" ] }, { "attachments": {}, "cell_type": "markdown", "id": "4f354c94da7dd923", "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 customize `CompiledModel`." ] }, { "cell_type": "code", "execution_count": null, "id": "47b44358e7ca3e38", "metadata": { "ExecuteTime": { "end_time": "2024-04-11T15:54:15.594506Z", "start_time": "2024-04-11T15:54:15.466395Z" } }, "outputs": [], "source": [ "%%skip not $to_quantize.value\n", "\n", "import datasets\n", "from tqdm.auto import tqdm\n", "from typing import Any, Dict, List\n", "import pickle\n", "import numpy as np\n", "\n", "\n", "def disable_progress_bar(pipeline, disable=True):\n", " if not hasattr(pipeline, \"_progress_bar_config\"):\n", " pipeline._progress_bar_config = {'disable': disable}\n", " else:\n", " pipeline._progress_bar_config['disable'] = disable\n", "\n", "\n", "class CompiledModelDecorator(ov.CompiledModel):\n", " def __init__(self, compiled_model: ov.CompiledModel, data_cache: List[Any] = None, keep_prob: float = 0.5):\n", " super().__init__(compiled_model)\n", " self.data_cache = data_cache if data_cache is not None else []\n", " self.keep_prob = keep_prob\n", "\n", " def __call__(self, *args, **kwargs):\n", " if np.random.rand() <= self.keep_prob:\n", " self.data_cache.append(*args)\n", " return super().__call__(*args, **kwargs)\n", "\n", "\n", "def collect_calibration_data(ov_transformer_model, calibration_dataset_size: int) -> List[Dict]:\n", " calibration_dataset_filepath = Path(f\"calibration_data/{calibration_dataset_size}.pkl\")\n", " if not calibration_dataset_filepath.exists():\n", " calibration_data = []\n", " pipe.transformer.transformer = CompiledModelDecorator(ov_transformer_model, calibration_data, keep_prob=1.0)\n", " disable_progress_bar(pipe)\n", " \n", " dataset = datasets.load_dataset(\"conceptual_captions\", split=\"train\").shuffle(seed=42)\n", " \n", " # Run inference for data collection\n", " pbar = tqdm(total=calibration_dataset_size)\n", " for batch in dataset:\n", " prompt = batch[\"caption\"]\n", " if len(prompt) > pipe.tokenizer.model_max_length:\n", " continue\n", " pipe(prompt, generator=torch.Generator('cpu').manual_seed(0))\n", " pbar.update(len(calibration_data) - pbar.n)\n", " if pbar.n >= calibration_dataset_size:\n", " break\n", " \n", " pipe.transformer.transformer = ov_transformer_model\n", " disable_progress_bar(pipe, disable=False)\n", " \n", " calibration_dataset_filepath.parent.mkdir(exist_ok=True, parents=True)\n", " with open(calibration_dataset_filepath, 'wb') as f:\n", " pickle.dump(calibration_data, f)\n", " \n", " with open(calibration_dataset_filepath, 'rb') as f:\n", " calibration_data = pickle.load(f)\n", " return calibration_data" ] }, { "attachments": {}, "cell_type": "markdown", "id": "6b639455e8e4f718", "metadata": {}, "source": [ "### Run model quantization\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "\n", "Run calibration data collection and quantize the vision transformer model." ] }, { "cell_type": "code", "execution_count": null, "id": "a7578c11a8b89b3e", "metadata": { "ExecuteTime": { "end_time": "2024-04-11T15:53:48.050946Z", "start_time": "2024-04-11T15:53:48.042694Z" }, "test_replace": { "CALIBRATION_DATASET_SIZE = 12 * 25": "CALIBRATION_DATASET_SIZE = 12" } }, "outputs": [], "source": [ "%%skip not $to_quantize.value\n", "\n", "from nncf.quantization.advanced_parameters import AdvancedSmoothQuantParameters\n", "from nncf.quantization.range_estimator import RangeEstimatorParameters, StatisticsCollectorParameters, StatisticsType, \\\n", " AggregatorType\n", "import nncf\n", "\n", "CALIBRATION_DATASET_SIZE = 12 * 25\n", "\n", "if not QUANTIZED_TRANSFORMER_OV_PATH.exists():\n", " calibration_data = collect_calibration_data(ov_transformer, CALIBRATION_DATASET_SIZE)\n", " quantized_model = nncf.quantize(\n", " core.read_model(TRANSFORMER_OV_PATH),\n", " nncf.Dataset(calibration_data),\n", " model_type=nncf.ModelType.TRANSFORMER,\n", " subset_size=len(calibration_data),\n", " # We ignore convolutions to improve quality of generations without significant drop in inference speed\n", " ignored_scope=nncf.IgnoredScope(types=[\"Convolution\"]),\n", " # Value of 0.85 was obtained using grid search based on Inception Score computed below\n", " advanced_parameters=nncf.AdvancedQuantizationParameters(\n", " smooth_quant_alphas=AdvancedSmoothQuantParameters(matmul=0.85),\n", " # During activation statistics collection we ignore 1% of outliers which improves quantization quality\n", " activations_range_estimator_params=RangeEstimatorParameters(\n", " min=StatisticsCollectorParameters(statistics_type=StatisticsType.MIN,\n", " aggregator_type=AggregatorType.MEAN_NO_OUTLIERS,\n", " quantile_outlier_prob=0.01),\n", " max=StatisticsCollectorParameters(statistics_type=StatisticsType.MAX,\n", " aggregator_type=AggregatorType.MEAN_NO_OUTLIERS,\n", " quantile_outlier_prob=0.01)\n", " )\n", " )\n", " )\n", " ov.save_model(quantized_model, QUANTIZED_TRANSFORMER_OV_PATH)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "e684f5e111282666", "metadata": {}, "source": [ "### Demo generation with quantized pipeline" ] }, { "cell_type": "code", "execution_count": null, "id": "98baef3f09083ad5", "metadata": { "ExecuteTime": { "end_time": "2024-04-11T15:53:48.417224Z", "start_time": "2024-04-11T15:53:48.409500Z" } }, "outputs": [], "source": [ "%%skip not $to_quantize.value\n", "\n", "original_ov_transformer_model = pipe.transformer.transformer\n", "pipe.transformer.transformer = core.compile_model(QUANTIZED_TRANSFORMER_OV_PATH, device.value)\n", "\n", "image = pipe(prompt, generator=torch.Generator('cpu').manual_seed(8)).images[0]\n", "image.save('text2image_256_quantized.png')\n", "\n", "pipe.transformer.transformer = original_ov_transformer_model\n", "\n", "display(image)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "f6c49afdc5f4c94e", "metadata": {}, "source": [ "### Compute Inception Scores and inference time\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "\n", "Below we compute [Inception Score](https://en.wikipedia.org/wiki/Inception_score) of original and quantized pipelines on a small subset of images. Images are generated from prompts of `conceptual_captions` validation set. We also measure the time it took to generate the images for comparison reasons.\n", "\n", "Please note that the validation dataset size is small and serves only as a rough estimate of generation quality." ] }, { "cell_type": "code", "execution_count": null, "id": "4908c5c1a95244be", "metadata": { "ExecuteTime": { "end_time": "2024-04-11T15:53:48.957357Z", "start_time": "2024-04-11T15:53:48.947976Z" }, "test_replace": { "VALIDATION_DATASET_SIZE = 100": "VALIDATION_DATASET_SIZE = 2" } }, "outputs": [], "source": [ "%%skip not $to_quantize.value\n", "\n", "from torchmetrics.image.inception import InceptionScore\n", "from torchvision import transforms as transforms\n", "from itertools import islice\n", "import time\n", "\n", "VALIDATION_DATASET_SIZE = 100\n", "\n", "def compute_inception_score(ov_transformer_model_path, validation_set_size, batch_size=100):\n", " original_ov_transformer_model = pipe.transformer.transformer\n", " pipe.transformer.transformer = core.compile_model(ov_transformer_model_path, device.value)\n", " \n", " disable_progress_bar(pipe)\n", " dataset = datasets.load_dataset(\"conceptual_captions\", \"unlabeled\", split=\"validation\").shuffle(seed=42)\n", " dataset = islice(dataset, validation_set_size)\n", " \n", " inception_score = InceptionScore(normalize=True, splits=1)\n", " \n", " images = []\n", " infer_times = []\n", " for batch in tqdm(dataset, total=validation_set_size, desc=\"Computing Inception Score\"):\n", " prompt = batch[\"caption\"]\n", " if len(prompt) > pipe.tokenizer.model_max_length:\n", " continue\n", " start_time = time.perf_counter()\n", " image = pipe(prompt, generator=torch.Generator('cpu').manual_seed(0)).images[0]\n", " infer_times.append(time.perf_counter() - start_time)\n", " image = transforms.ToTensor()(image)\n", " images.append(image)\n", " \n", " mean_perf_time = sum(infer_times) / len(infer_times)\n", " \n", " while len(images) > 0:\n", " images_batch = torch.stack(images[-batch_size:])\n", " images = images[:-batch_size]\n", " inception_score.update(images_batch)\n", " kl_mean, kl_std = inception_score.compute()\n", " \n", " pipe.transformer.transformer = original_ov_transformer_model\n", " disable_progress_bar(pipe, disable=False)\n", " \n", " return kl_mean, mean_perf_time\n", "\n", "\n", "original_inception_score, original_time = compute_inception_score(TRANSFORMER_OV_PATH, VALIDATION_DATASET_SIZE)\n", "print(f\"Original pipeline Inception Score: {original_inception_score}\")\n", "quantized_inception_score, quantized_time = compute_inception_score(QUANTIZED_TRANSFORMER_OV_PATH, VALIDATION_DATASET_SIZE)\n", "print(f\"Quantized pipeline Inception Score: {quantized_inception_score}\")\n", "print(f\"Quantization speed-up: {original_time / quantized_time:.2f}x\")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "281ca3bd-651c-4cc8-bcee-22fa3fbb3636", "metadata": {}, "source": [ "## Interactive inference\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "Below you can select which pipeline to run: original or quantized. " ] }, { "cell_type": "code", "execution_count": null, "id": "60117ddfcffc2308", "metadata": {}, "outputs": [], "source": [ "quantized_model_present = QUANTIZED_TRANSFORMER_OV_PATH.exists()\n", "\n", "use_quantized_model = widgets.Checkbox(\n", " value=True if quantized_model_present else False,\n", " description=\"Use quantized pipeline\",\n", " disabled=not quantized_model_present,\n", ")\n", "\n", "use_quantized_model" ] }, { "cell_type": "code", "execution_count": null, "id": "5bf32074-c955-4210-84a3-0714bd960247", "metadata": {}, "outputs": [], "source": [ "import gradio as gr\n", "import numpy as np\n", "\n", "pipe.transformer.transformer = core.compile_model(\n", " QUANTIZED_TRANSFORMER_OV_PATH if use_quantized_model.value else TRANSFORMER_OV_PATH,\n", " device.value,\n", ")\n", "\n", "\n", "def generate(prompt, seed, _=gr.Progress(track_tqdm=True)):\n", " image = pipe(prompt, generator=torch.Generator(\"cpu\").manual_seed(seed)).images[0]\n", " return image\n", "\n", "\n", "demo = gr.Interface(\n", " generate,\n", " [\n", " gr.Textbox(label=\"Prompt\"),\n", " gr.Slider(0, np.iinfo(np.int32).max, label=\"Seed\", step=1),\n", " ],\n", " \"image\",\n", " examples=[\n", " [\"happy snowman\", 88],\n", " [\"green ghost rider\", 0],\n", " [\"kind smiling ghost\", 8],\n", " ],\n", " allow_flagging=\"never\",\n", ")\n", "try:\n", " demo.queue().launch(debug=True)\n", "except Exception:\n", " demo.queue().launch(debug=True, share=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/amused-lightweight-text-to-image/amused-lightweight-text-to-image.png?raw=true", "tags": { "categories": [ "Model Demos" ], "libraries": [], "other": [], "tasks": [ "Text-to-Image" ] } }, "widgets": { "application/vnd.jupyter.widget-state+json": { "state": {}, "version_major": 2, "version_minor": 0 } } }, "nbformat": 4, "nbformat_minor": 5 }