{ "cells": [ { "cell_type": "markdown", "id": "777945df-d8b1-4ae2-8c6b-24875f6a0555", "metadata": {}, "source": [ "# One Step Sketch to Image translation with pix2pix-turbo and OpenVINO\n", "\n", "Diffusion models achieve remarkable results in image generation. They are able synthesize high-quality images guided by user instructions. In the same time, majority of diffusion-based image generation approaches are time-consuming due to the iterative denoising process.Pix2Pix-turbo model was proposed in [One-Step Image Translation with Text-to-Image Models paper](https://arxiv.org/abs/2403.12036) for addressing slowness of diffusion process in image-to-image translation task. It is based on [SD-Turbo](https://huggingface.co/stabilityai/sd-turbo), a fast generative text-to-image model that can synthesize photorealistic images from a text prompt in a single network evaluation. Using only single inference, pix2pix-turbo achieves comparable by quality results with recent works such as ControlNet for Sketch2Photo and Edge2Image for 50 steps.\n", "\n", "![](https://github.com/GaParmar/img2img-turbo/raw/main/assets/gen_variations.jpg)\n", "\n", "In this tutorial you will learn how to turn sketches to images using [Pix2Pix-Turbo](https://github.com/GaParmar/img2img-turbo) and OpenVINO.\n", "#### Table of contents:\n", "\n", "- [Prerequisites](#Prerequisites)\n", "- [Load PyTorch model](#Load-PyTorch-model)\n", "- [Convert PyTorch model to Openvino Intermediate Representation format](#Convert-PyTorch-model-to-Openvino-Intermediate-Representation-format)\n", "- [Select inference device](#Select-inference-device)\n", "- [Compile model](#Compile-model)\n", "- [Run model inference](#Run-model-inference)\n", "- [Interactive demo](#Interactive-demo)\n", "\n" ] }, { "cell_type": "markdown", "id": "0b55bfa3-a826-4ec0-a445-84f1fdf6d404", "metadata": {}, "source": [ "## Prerequisites\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "Clone [model repository](https://github.com/GaParmar/img2img-turbo) and install required packages." ] }, { "cell_type": "code", "execution_count": 1, "id": "3f825f99-9c02-40b2-909f-a64829c711cf", "metadata": { "tags": [] }, "outputs": [], "source": [ "%pip install -q \"openvino>=2024.1.0\" \"torch>=2.1\" torchvision \"diffusers==0.25.1\" \"peft==0.6.2\" transformers tqdm pillow opencv-python \"gradio==3.43.1\" --extra-index-url https://download.pytorch.org/whl/cpu" ] }, { "cell_type": "code", "execution_count": 2, "id": "a636e89d-68fe-4f85-af6a-03e7552f0a0f", "metadata": { "tags": [] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "/home/ea/work/openvino_notebooks/notebooks/sketch-to-image-pix2pix-turbo/img2img-turbo\n" ] } ], "source": [ "from pathlib import Path\n", "\n", "repo_dir = Path(\"img2img-turbo\")\n", "\n", "if not repo_dir.exists():\n", " !git clone https://github.com/GaParmar/img2img-turbo.git\n", "\n", "pix2pix_turbo_py_path = repo_dir / \"src/pix2pix_turbo.py\"\n", "model_py_path = repo_dir / \"src/model.py\"\n", "orig_pix2pix_turbo_path = pix2pix_turbo_py_path.parent / (\"orig_\" + pix2pix_turbo_py_path.name)\n", "orig_model_py_path = model_py_path.parent / (\"orig_\" + model_py_path.name)\n", "\n", "if not orig_pix2pix_turbo_path.exists():\n", " pix2pix_turbo_py_path.rename(orig_pix2pix_turbo_path)\n", "\n", " with orig_pix2pix_turbo_path.open(\"r\") as f:\n", " data = f.read()\n", " data = data.replace(\"cuda\", \"cpu\")\n", " with pix2pix_turbo_py_path.open(\"w\") as out_f:\n", " out_f.write(data)\n", "\n", "if not orig_model_py_path.exists():\n", " model_py_path.rename(orig_model_py_path)\n", "\n", " with orig_model_py_path.open(\"r\") as f:\n", " data = f.read()\n", " data = data.replace(\"cuda\", \"cpu\")\n", " with model_py_path.open(\"w\") as out_f:\n", " out_f.write(data)\n", "%cd $repo_dir" ] }, { "cell_type": "markdown", "id": "a10d77f9-b3bb-49c7-b791-39854445d54c", "metadata": {}, "source": [ "## Load PyTorch model\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "Pix2Pix-turbo architecture illustrated on the diagram below. Model combines three separate modules in the original latent diffusion models into a single end-to-end network with small trainable weights. This architecture allows translation the input image x to the output y, while retaining the input scene structure. Authors use LoRA adapters in each module, introduce skip connections and Zero-Convolutions between input and output, and retrain the first layer of the U-Net. Blue boxes on diagram indicate trainable layers. Semi-transparent layers are frozen. \n", "![model_diagram](https://github.com/openvinotoolkit/openvino_notebooks/assets/29454499/18f1a442-8547-4edd-85b0-d8bd1a99bdf1)" ] }, { "cell_type": "code", "execution_count": 3, "id": "1b4dec1e-6c5b-424a-9c6d-da5bdb17db39", "metadata": { "tags": [] }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/home/ea/work/my_optimum_intel/optimum_env/lib/python3.8/site-packages/bitsandbytes/cextension.py:34: UserWarning: The installed version of bitsandbytes was compiled without GPU support. 8-bit optimizers, 8-bit multiplication, and GPU quantization are unavailable.\n", " warn(\"The installed version of bitsandbytes was compiled without GPU support. \"\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "/home/ea/work/my_optimum_intel/optimum_env/lib/python3.8/site-packages/bitsandbytes/libbitsandbytes_cpu.so: undefined symbol: cadam32bit_grad_fp32\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "2024-05-02 18:48:47.607304: I tensorflow/core/util/port.cc:110] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", "2024-05-02 18:48:47.609104: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", "2024-05-02 18:48:47.643578: I tensorflow/tsl/cuda/cudart_stub.cc:28] Could not find cuda drivers on your machine, GPU will not be used.\n", "2024-05-02 18:48:47.644677: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", "2024-05-02 18:48:48.268888: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", "WARNING[XFORMERS]: xFormers can't load C++/CUDA extensions. xFormers was built for:\n", " PyTorch 2.0.1+cu118 with CUDA 1108 (you have 2.1.2+cpu)\n", " Python 3.8.18 (you have 3.8.10)\n", " Please reinstall xformers (see https://github.com/facebookresearch/xformers#installing-xformers)\n", " Memory-efficient attention, SwiGLU, sparse and more won't be available.\n", " Set XFORMERS_MORE_DETAILS=1 for more details\n" ] } ], "source": [ "import requests\n", "import copy\n", "from tqdm import tqdm\n", "import torch\n", "from transformers import AutoTokenizer, CLIPTextModel\n", "from diffusers import AutoencoderKL, UNet2DConditionModel\n", "from diffusers.models.autoencoders.vae import DiagonalGaussianDistribution\n", "from diffusers.utils.peft_utils import set_weights_and_activate_adapters\n", "from peft import LoraConfig\n", "import types\n", "\n", "from src.model import make_1step_sched\n", "from src.pix2pix_turbo import TwinConv\n", "\n", "tokenizer = AutoTokenizer.from_pretrained(\"stabilityai/sd-turbo\", subfolder=\"tokenizer\")\n", "\n", "\n", "def tokenize_prompt(prompt):\n", " caption_tokens = tokenizer(prompt, max_length=tokenizer.model_max_length, padding=\"max_length\", truncation=True, return_tensors=\"pt\").input_ids\n", " return caption_tokens\n", "\n", "\n", "def _vae_encoder_fwd(self, sample):\n", " sample = self.conv_in(sample)\n", " l_blocks = []\n", " # down\n", " for down_block in self.down_blocks:\n", " l_blocks.append(sample)\n", " sample = down_block(sample)\n", " # middle\n", " sample = self.mid_block(sample)\n", " sample = self.conv_norm_out(sample)\n", " sample = self.conv_act(sample)\n", " sample = self.conv_out(sample)\n", " current_down_blocks = l_blocks\n", " return sample, current_down_blocks\n", "\n", "\n", "def _vae_decoder_fwd(self, sample, incoming_skip_acts, latent_embeds=None):\n", " sample = self.conv_in(sample)\n", " upscale_dtype = next(iter(self.up_blocks.parameters())).dtype\n", " # middle\n", " sample = self.mid_block(sample, latent_embeds)\n", " sample = sample.to(upscale_dtype)\n", " if not self.ignore_skip:\n", " skip_convs = [self.skip_conv_1, self.skip_conv_2, self.skip_conv_3, self.skip_conv_4]\n", " # up\n", " for idx, up_block in enumerate(self.up_blocks):\n", " skip_in = skip_convs[idx](incoming_skip_acts[::-1][idx] * self.gamma)\n", " # add skip\n", " sample = sample + skip_in\n", " sample = up_block(sample, latent_embeds)\n", " else:\n", " for idx, up_block in enumerate(self.up_blocks):\n", " sample = up_block(sample, latent_embeds)\n", " # post-process\n", " if latent_embeds is None:\n", " sample = self.conv_norm_out(sample)\n", " else:\n", " sample = self.conv_norm_out(sample, latent_embeds)\n", " sample = self.conv_act(sample)\n", " sample = self.conv_out(sample)\n", " return sample\n", "\n", "\n", "def vae_encode(self, x: torch.FloatTensor):\n", " \"\"\"\n", " Encode a batch of images into latents.\n", "\n", " Args:\n", " x (`torch.FloatTensor`): Input batch of images.\n", "\n", " Returns:\n", " The latent representations of the encoded images. If `return_dict` is True, a\n", " [`~models.autoencoder_kl.AutoencoderKLOutput`] is returned, otherwise a plain `tuple` is returned.\n", " \"\"\"\n", " h, down_blocks = self.encoder(x)\n", "\n", " moments = self.quant_conv(h)\n", " posterior = DiagonalGaussianDistribution(moments)\n", "\n", " return (posterior, down_blocks)\n", "\n", "\n", "def vae_decode(self, z: torch.FloatTensor, skip_acts):\n", " decoded = self._decode(z, skip_acts)[0]\n", " return (decoded,)\n", "\n", "\n", "def vae__decode(self, z: torch.FloatTensor, skip_acts):\n", " z = self.post_quant_conv(z)\n", " dec = self.decoder(z, skip_acts)\n", "\n", " return (dec,)\n", "\n", "\n", "class Pix2PixTurbo(torch.nn.Module):\n", " def __init__(self, pretrained_name=None, pretrained_path=None, ckpt_folder=\"checkpoints\", lora_rank_unet=8, lora_rank_vae=4):\n", " super().__init__()\n", " self.text_encoder = CLIPTextModel.from_pretrained(\"stabilityai/sd-turbo\", subfolder=\"text_encoder\").cpu()\n", " self.sched = make_1step_sched()\n", "\n", " vae = AutoencoderKL.from_pretrained(\"stabilityai/sd-turbo\", subfolder=\"vae\")\n", " vae.encoder.forward = types.MethodType(_vae_encoder_fwd, vae.encoder)\n", " vae.decoder.forward = types.MethodType(_vae_decoder_fwd, vae.decoder)\n", " vae.encode = types.MethodType(vae_encode, vae)\n", " vae.decode = types.MethodType(vae_decode, vae)\n", " vae._decode = types.MethodType(vae__decode, vae)\n", " # add the skip connection convs\n", " vae.decoder.skip_conv_1 = torch.nn.Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False).cpu()\n", " vae.decoder.skip_conv_2 = torch.nn.Conv2d(256, 512, kernel_size=(1, 1), stride=(1, 1), bias=False).cpu()\n", " vae.decoder.skip_conv_3 = torch.nn.Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False).cpu()\n", " vae.decoder.skip_conv_4 = torch.nn.Conv2d(128, 256, kernel_size=(1, 1), stride=(1, 1), bias=False).cpu()\n", " vae.decoder.ignore_skip = False\n", " unet = UNet2DConditionModel.from_pretrained(\"stabilityai/sd-turbo\", subfolder=\"unet\")\n", " ckpt_folder = Path(ckpt_folder)\n", "\n", " if pretrained_name == \"edge_to_image\":\n", " url = \"https://www.cs.cmu.edu/~img2img-turbo/models/edge_to_image_loras.pkl\"\n", " ckpt_folder.mkdir(exist_ok=True)\n", " outf = ckpt_folder / \"edge_to_image_loras.pkl\"\n", " if not outf:\n", " print(f\"Downloading checkpoint to {outf}\")\n", " response = requests.get(url, stream=True)\n", " total_size_in_bytes = int(response.headers.get(\"content-length\", 0))\n", " block_size = 1024 # 1 Kibibyte\n", " progress_bar = tqdm(total=total_size_in_bytes, unit=\"iB\", unit_scale=True)\n", " with open(outf, \"wb\") as file:\n", " for data in response.iter_content(block_size):\n", " progress_bar.update(len(data))\n", " file.write(data)\n", " progress_bar.close()\n", " if total_size_in_bytes != 0 and progress_bar.n != total_size_in_bytes:\n", " print(\"ERROR, something went wrong\")\n", " print(f\"Downloaded successfully to {outf}\")\n", " p_ckpt = outf\n", " sd = torch.load(p_ckpt, map_location=\"cpu\")\n", " unet_lora_config = LoraConfig(r=sd[\"rank_unet\"], init_lora_weights=\"gaussian\", target_modules=sd[\"unet_lora_target_modules\"])\n", " vae_lora_config = LoraConfig(r=sd[\"rank_vae\"], init_lora_weights=\"gaussian\", target_modules=sd[\"vae_lora_target_modules\"])\n", " vae.add_adapter(vae_lora_config, adapter_name=\"vae_skip\")\n", " _sd_vae = vae.state_dict()\n", " for k in sd[\"state_dict_vae\"]:\n", " _sd_vae[k] = sd[\"state_dict_vae\"][k]\n", " vae.load_state_dict(_sd_vae)\n", " unet.add_adapter(unet_lora_config)\n", " _sd_unet = unet.state_dict()\n", " for k in sd[\"state_dict_unet\"]:\n", " _sd_unet[k] = sd[\"state_dict_unet\"][k]\n", " unet.load_state_dict(_sd_unet)\n", "\n", " elif pretrained_name == \"sketch_to_image_stochastic\":\n", " # download from url\n", " url = \"https://www.cs.cmu.edu/~img2img-turbo/models/sketch_to_image_stochastic_lora.pkl\"\n", " ckpt_folder.mkdir(exist_ok=True)\n", " outf = ckpt_folder / \"sketch_to_image_stochastic_lora.pkl\"\n", " if not outf.exists():\n", " print(f\"Downloading checkpoint to {outf}\")\n", " response = requests.get(url, stream=True)\n", " total_size_in_bytes = int(response.headers.get(\"content-length\", 0))\n", " block_size = 1024 # 1 Kibibyte\n", " progress_bar = tqdm(total=total_size_in_bytes, unit=\"iB\", unit_scale=True)\n", " with open(outf, \"wb\") as file:\n", " for data in response.iter_content(block_size):\n", " progress_bar.update(len(data))\n", " file.write(data)\n", " progress_bar.close()\n", " if total_size_in_bytes != 0 and progress_bar.n != total_size_in_bytes:\n", " print(\"ERROR, something went wrong\")\n", " print(f\"Downloaded successfully to {outf}\")\n", " p_ckpt = outf\n", " convin_pretrained = copy.deepcopy(unet.conv_in)\n", " unet.conv_in = TwinConv(convin_pretrained, unet.conv_in)\n", " sd = torch.load(p_ckpt, map_location=\"cpu\")\n", " unet_lora_config = LoraConfig(r=sd[\"rank_unet\"], init_lora_weights=\"gaussian\", target_modules=sd[\"unet_lora_target_modules\"])\n", " vae_lora_config = LoraConfig(r=sd[\"rank_vae\"], init_lora_weights=\"gaussian\", target_modules=sd[\"vae_lora_target_modules\"])\n", " vae.add_adapter(vae_lora_config, adapter_name=\"vae_skip\")\n", " _sd_vae = vae.state_dict()\n", " for k in sd[\"state_dict_vae\"]:\n", " if k not in _sd_vae:\n", " continue\n", " _sd_vae[k] = sd[\"state_dict_vae\"][k]\n", "\n", " vae.load_state_dict(_sd_vae)\n", " unet.add_adapter(unet_lora_config)\n", " _sd_unet = unet.state_dict()\n", " for k in sd[\"state_dict_unet\"]:\n", " _sd_unet[k] = sd[\"state_dict_unet\"][k]\n", " unet.load_state_dict(_sd_unet)\n", "\n", " elif pretrained_path is not None:\n", " sd = torch.load(pretrained_path, map_location=\"cpu\")\n", " unet_lora_config = LoraConfig(r=sd[\"rank_unet\"], init_lora_weights=\"gaussian\", target_modules=sd[\"unet_lora_target_modules\"])\n", " vae_lora_config = LoraConfig(r=sd[\"rank_vae\"], init_lora_weights=\"gaussian\", target_modules=sd[\"vae_lora_target_modules\"])\n", " vae.add_adapter(vae_lora_config, adapter_name=\"vae_skip\")\n", " _sd_vae = vae.state_dict()\n", " for k in sd[\"state_dict_vae\"]:\n", " _sd_vae[k] = sd[\"state_dict_vae\"][k]\n", " vae.load_state_dict(_sd_vae)\n", " unet.add_adapter(unet_lora_config)\n", " _sd_unet = unet.state_dict()\n", " for k in sd[\"state_dict_unet\"]:\n", " _sd_unet[k] = sd[\"state_dict_unet\"][k]\n", " unet.load_state_dict(_sd_unet)\n", "\n", " # unet.enable_xformers_memory_efficient_attention()\n", " unet.to(\"cpu\")\n", " vae.to(\"cpu\")\n", " self.unet, self.vae = unet, vae\n", " self.vae.decoder.gamma = 1\n", " self.timesteps = torch.tensor([999], device=\"cpu\").long()\n", " self.text_encoder.requires_grad_(False)\n", "\n", " def set_r(self, r):\n", " self.unet.set_adapters([\"default\"], weights=[r])\n", " set_weights_and_activate_adapters(self.vae, [\"vae_skip\"], [r])\n", " self.r = r\n", " self.unet.conv_in.r = r\n", " self.vae.decoder.gamma = r\n", "\n", " def forward(self, c_t, prompt_tokens, noise_map):\n", " caption_enc = self.text_encoder(prompt_tokens)[0]\n", " # scale the lora weights based on the r value\n", " sample, current_down_blocks = self.vae.encode(c_t)\n", " encoded_control = sample.sample() * self.vae.config.scaling_factor\n", " # combine the input and noise\n", " unet_input = encoded_control * self.r + noise_map * (1 - self.r)\n", "\n", " unet_output = self.unet(\n", " unet_input,\n", " self.timesteps,\n", " encoder_hidden_states=caption_enc,\n", " ).sample\n", " x_denoised = self.sched.step(unet_output, self.timesteps, unet_input, return_dict=True).prev_sample\n", " output_image = (self.vae.decode(x_denoised / self.vae.config.scaling_factor, current_down_blocks)[0]).clamp(-1, 1)\n", " return output_image" ] }, { "cell_type": "code", "execution_count": 4, "id": "b1672584-8016-457a-9473-406eb38e59a0", "metadata": { "tags": [] }, "outputs": [], "source": [ "ov_model_path = Path(\"model/pix2pix-turbo.xml\")\n", "\n", "pt_model = None\n", "\n", "if not ov_model_path.exists():\n", " pt_model = Pix2PixTurbo(\"sketch_to_image_stochastic\")\n", " pt_model.set_r(0.4)\n", " pt_model.eval()" ] }, { "cell_type": "markdown", "id": "2e6a4e98-4311-4713-a877-b56530ed814e", "metadata": {}, "source": [ "## Convert PyTorch model to Openvino Intermediate Representation format\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "Starting from OpenVINO 2023.0 release, OpenVINO supports direct PyTorch models conversion to [OpenVINO Intermediate Representation (IR) format](https://docs.openvino.ai/2024/documentation/openvino-ir-format.html) to take the advantage of advanced OpenVINO optimization tools and features. You need to provide a model object, input data for model tracing to [OpenVINO Model Conversion API](https://docs.openvino.ai/2024/openvino-workflow/model-preparation/convert-model-to-ir.html). `ov.convert_model` function convert PyTorch model instance to `ov.Model` object that can be used for compilation on device or saved on disk using `ov.save_model` in compressed to FP16 format." ] }, { "cell_type": "code", "execution_count": 5, "id": "f424caac-2886-41dd-b735-7e07312a8573", "metadata": {}, "outputs": [], "source": [ "import gc\n", "import openvino as ov\n", "\n", "if not ov_model_path.exists():\n", " example_input = [torch.ones((1, 3, 512, 512)), torch.ones([1, 77], dtype=torch.int64), torch.ones([1, 4, 64, 64])]\n", " with torch.no_grad():\n", " ov_model = ov.convert_model(pt_model, example_input=example_input, input=[[1, 3, 512, 512], [1, 77], [1, 4, 64, 64]])\n", " ov.save_model(ov_model, ov_model_path)\n", " del ov_model\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", "del pt_model\n", "gc.collect();" ] }, { "cell_type": "markdown", "id": "cdc5ad49-430b-44b5-ba01-e50405539ad6", "metadata": {}, "source": [ "## Select inference device\n", "[back to top ⬆️](#Table-of-contents:)" ] }, { "cell_type": "code", "execution_count": 6, "id": "005673fc-2269-4f45-b616-cc35ef3abd9b", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "3f1d46367ac94f3bbeb8fc5b14e52747", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Dropdown(description='Device:', index=3, options=('CPU', 'GPU.0', 'GPU.1', 'AUTO'), value='AUTO')" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import ipywidgets as widgets\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": "markdown", "id": "5cbe4562-b319-483c-93e8-b4886042d15b", "metadata": {}, "source": [ "## Compile model\n", "[back to top ⬆️](#Table-of-contents:)" ] }, { "cell_type": "code", "execution_count": 7, "id": "c8000325-9e29-4f1f-ae9a-fdd390a88182", "metadata": {}, "outputs": [], "source": [ "compiled_model = core.compile_model(ov_model_path, device.value)" ] }, { "cell_type": "markdown", "id": "2e5b7146-ec7c-4639-af7d-529747e8cfa9", "metadata": {}, "source": [ "## Run model inference\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "Now, let's try model in action and turn simple cat sketch into professional artwork." ] }, { "cell_type": "code", "execution_count": 8, "id": "fa9a7741-9b89-4f73-aea5-86fad705508b", "metadata": { "tags": [] }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from diffusers.utils import load_image\n", "\n", "sketch_image = load_image(\"https://github.com/openvinotoolkit/openvino_notebooks/assets/29454499/f964a51d-34e8-411a-98f4-5f97a28f56b0\")\n", "\n", "sketch_image" ] }, { "cell_type": "code", "execution_count": 9, "id": "9b1ccb97-5278-48c7-87ad-60dd90595feb", "metadata": { "tags": [] }, "outputs": [], "source": [ "import torchvision.transforms.functional as F\n", "\n", "torch.manual_seed(145)\n", "c_t = torch.unsqueeze(F.to_tensor(sketch_image) > 0.5, 0)\n", "noise = torch.randn((1, 4, 512 // 8, 512 // 8))" ] }, { "cell_type": "code", "execution_count": 10, "id": "0a243777-64b3-47cd-a69a-088bd6663e6b", "metadata": { "tags": [] }, "outputs": [], "source": [ "prompt_template = \"anime artwork {prompt} . anime style, key visual, vibrant, studio anime, highly detailed\"\n", "prompt = prompt_template.replace(\"{prompt}\", \"fluffy magic cat\")\n", "\n", "prompt_tokens = tokenize_prompt(prompt)" ] }, { "cell_type": "code", "execution_count": 11, "id": "c99ee2a6-7367-48db-9579-e3c39ddf9694", "metadata": { "tags": [] }, "outputs": [], "source": [ "result = compiled_model([1 - c_t.to(torch.float32), prompt_tokens, noise])[0]" ] }, { "cell_type": "code", "execution_count": 12, "id": "a26c50e0-f7f3-4e12-869b-008a2995069d", "metadata": { "tags": [] }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from PIL import Image\n", "import numpy as np\n", "\n", "image_tensor = (result[0] * 0.5 + 0.5) * 255\n", "image = np.transpose(image_tensor, (1, 2, 0)).astype(np.uint8)\n", "Image.fromarray(image)" ] }, { "cell_type": "markdown", "id": "24c773a6-cc27-4ced-bdf1-46e37a391833", "metadata": {}, "source": [ "## Interactive demo\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "In this section, you can try model on own paintings.\n", "\n", "**Instructions:**\n", "* Enter a text prompt (e.g. cat)\n", "* Start sketching, using pencil and eraser buttons\n", "* Change the image style using a style template\n", "* Try different seeds to generate different results\n", "* Download results using download button" ] }, { "cell_type": "code", "execution_count": null, "id": "82240121-dd90-46a4-a146-c949b367fa95", "metadata": { "tags": [] }, "outputs": [], "source": [ "import random\n", "import base64\n", "from io import BytesIO\n", "import gradio as gr\n", "\n", "style_list = [\n", " {\n", " \"name\": \"Cinematic\",\n", " \"prompt\": \"cinematic still {prompt} . emotional, harmonious, vignette, highly detailed, high budget, bokeh, cinemascope, moody, epic, gorgeous, film grain, grainy\",\n", " },\n", " {\n", " \"name\": \"3D Model\",\n", " \"prompt\": \"professional 3d model {prompt} . octane render, highly detailed, volumetric, dramatic lighting\",\n", " },\n", " {\n", " \"name\": \"Anime\",\n", " \"prompt\": \"anime artwork {prompt} . anime style, key visual, vibrant, studio anime, highly detailed\",\n", " },\n", " {\n", " \"name\": \"Digital Art\",\n", " \"prompt\": \"concept art {prompt} . digital artwork, illustrative, painterly, matte painting, highly detailed\",\n", " },\n", " {\n", " \"name\": \"Photographic\",\n", " \"prompt\": \"cinematic photo {prompt} . 35mm photograph, film, bokeh, professional, 4k, highly detailed\",\n", " },\n", " {\n", " \"name\": \"Pixel art\",\n", " \"prompt\": \"pixel-art {prompt} . low-res, blocky, pixel art style, 8-bit graphics\",\n", " },\n", " {\n", " \"name\": \"Fantasy art\",\n", " \"prompt\": \"ethereal fantasy concept art of {prompt} . magnificent, celestial, ethereal, painterly, epic, majestic, magical, fantasy art, cover art, dreamy\",\n", " },\n", " {\n", " \"name\": \"Neonpunk\",\n", " \"prompt\": \"neonpunk style {prompt} . cyberpunk, vaporwave, neon, vibes, vibrant, stunningly beautiful, crisp, detailed, sleek, ultramodern, magenta highlights, dark purple shadows, high contrast, cinematic, ultra detailed, intricate, professional\",\n", " },\n", " {\n", " \"name\": \"Manga\",\n", " \"prompt\": \"manga style {prompt} . vibrant, high-energy, detailed, iconic, Japanese comic style\",\n", " },\n", "]\n", "\n", "styles = {k[\"name\"]: k[\"prompt\"] for k in style_list}\n", "STYLE_NAMES = list(styles.keys())\n", "DEFAULT_STYLE_NAME = \"Fantasy art\"\n", "MAX_SEED = np.iinfo(np.int32).max\n", "\n", "\n", "def pil_image_to_data_uri(img, format=\"PNG\"):\n", " buffered = BytesIO()\n", " img.save(buffered, format=format)\n", " img_str = base64.b64encode(buffered.getvalue()).decode()\n", " return f\"data:image/{format.lower()};base64,{img_str}\"\n", "\n", "\n", "def run(image, prompt, prompt_template, style_name, seed):\n", " print(f\"prompt: {prompt}\")\n", " print(\"sketch updated\")\n", " if image is None:\n", " ones = Image.new(\"L\", (512, 512), 255)\n", " temp_uri = pil_image_to_data_uri(ones)\n", " return ones, gr.update(link=temp_uri), gr.update(link=temp_uri)\n", " prompt = prompt_template.replace(\"{prompt}\", prompt)\n", " image = image.convert(\"RGB\")\n", " image_t = F.to_tensor(image) > 0.5\n", " print(f\"seed={seed}\")\n", " caption_tokens = tokenizer(prompt, max_length=tokenizer.model_max_length, padding=\"max_length\", truncation=True, return_tensors=\"pt\").input_ids.cpu()\n", " with torch.no_grad():\n", " c_t = image_t.unsqueeze(0)\n", " torch.manual_seed(seed)\n", " B, C, H, W = c_t.shape\n", " noise = torch.randn((1, 4, H // 8, W // 8))\n", " output_image = torch.from_numpy(compiled_model([c_t.to(torch.float32), caption_tokens, noise])[0])\n", " output_pil = F.to_pil_image(output_image[0].cpu() * 0.5 + 0.5)\n", " input_sketch_uri = pil_image_to_data_uri(Image.fromarray(255 - np.array(image)))\n", " output_image_uri = pil_image_to_data_uri(output_pil)\n", " return (\n", " output_pil,\n", " gr.update(link=input_sketch_uri),\n", " gr.update(link=output_image_uri),\n", " )\n", "\n", "\n", "def update_canvas(use_line, use_eraser):\n", " if use_eraser:\n", " _color = \"#ffffff\"\n", " brush_size = 20\n", " if use_line:\n", " _color = \"#000000\"\n", " brush_size = 4\n", " return gr.update(brush_radius=brush_size, brush_color=_color, interactive=True)\n", "\n", "\n", "def upload_sketch(file):\n", " _img = Image.open(file.name)\n", " _img = _img.convert(\"L\")\n", " return gr.update(value=_img, source=\"upload\", interactive=True)\n", "\n", "\n", "scripts = \"\"\"\n", "async () => {\n", " globalThis.theSketchDownloadFunction = () => {\n", " console.log(\"test\")\n", " var link = document.createElement(\"a\");\n", " dataUri = document.getElementById('download_sketch').href\n", " link.setAttribute(\"href\", dataUri)\n", " link.setAttribute(\"download\", \"sketch.png\")\n", " document.body.appendChild(link); // Required for Firefox\n", " link.click();\n", " document.body.removeChild(link); // Clean up\n", "\n", " // also call the output download function\n", " theOutputDownloadFunction();\n", " return false\n", " }\n", "\n", " globalThis.theOutputDownloadFunction = () => {\n", " console.log(\"test output download function\")\n", " var link = document.createElement(\"a\");\n", " dataUri = document.getElementById('download_output').href\n", " link.setAttribute(\"href\", dataUri);\n", " link.setAttribute(\"download\", \"output.png\");\n", " document.body.appendChild(link); // Required for Firefox\n", " link.click();\n", " document.body.removeChild(link); // Clean up\n", " return false\n", " }\n", "\n", " globalThis.UNDO_SKETCH_FUNCTION = () => {\n", " console.log(\"undo sketch function\")\n", " var button_undo = document.querySelector('#input_image > div.image-container.svelte-p3y7hu > div.svelte-s6ybro > button:nth-child(1)');\n", " // Create a new 'click' event\n", " var event = new MouseEvent('click', {\n", " 'view': window,\n", " 'bubbles': true,\n", " 'cancelable': true\n", " });\n", " button_undo.dispatchEvent(event);\n", " }\n", "\n", " globalThis.DELETE_SKETCH_FUNCTION = () => {\n", " console.log(\"delete sketch function\")\n", " var button_del = document.querySelector('#input_image > div.image-container.svelte-p3y7hu > div.svelte-s6ybro > button:nth-child(2)');\n", " // Create a new 'click' event\n", " var event = new MouseEvent('click', {\n", " 'view': window,\n", " 'bubbles': true,\n", " 'cancelable': true\n", " });\n", " button_del.dispatchEvent(event);\n", " }\n", "\n", " globalThis.togglePencil = () => {\n", " el_pencil = document.getElementById('my-toggle-pencil');\n", " el_pencil.classList.toggle('clicked');\n", " // simulate a click on the gradio button\n", " btn_gradio = document.querySelector(\"#cb-line > label > input\");\n", " var event = new MouseEvent('click', {\n", " 'view': window,\n", " 'bubbles': true,\n", " 'cancelable': true\n", " });\n", " btn_gradio.dispatchEvent(event);\n", " if (el_pencil.classList.contains('clicked')) {\n", " document.getElementById('my-toggle-eraser').classList.remove('clicked');\n", " document.getElementById('my-div-pencil').style.backgroundColor = \"gray\";\n", " document.getElementById('my-div-eraser').style.backgroundColor = \"white\";\n", " }\n", " else {\n", " document.getElementById('my-toggle-eraser').classList.add('clicked');\n", " document.getElementById('my-div-pencil').style.backgroundColor = \"white\";\n", " document.getElementById('my-div-eraser').style.backgroundColor = \"gray\";\n", " }\n", " }\n", "\n", " globalThis.toggleEraser = () => {\n", " element = document.getElementById('my-toggle-eraser');\n", " element.classList.toggle('clicked');\n", " // simulate a click on the gradio button\n", " btn_gradio = document.querySelector(\"#cb-eraser > label > input\");\n", " var event = new MouseEvent('click', {\n", " 'view': window,\n", " 'bubbles': true,\n", " 'cancelable': true\n", " });\n", " btn_gradio.dispatchEvent(event);\n", " if (element.classList.contains('clicked')) {\n", " document.getElementById('my-toggle-pencil').classList.remove('clicked');\n", " document.getElementById('my-div-pencil').style.backgroundColor = \"white\";\n", " document.getElementById('my-div-eraser').style.backgroundColor = \"gray\";\n", " }\n", " else {\n", " document.getElementById('my-toggle-pencil').classList.add('clicked');\n", " document.getElementById('my-div-pencil').style.backgroundColor = \"gray\";\n", " document.getElementById('my-div-eraser').style.backgroundColor = \"white\";\n", " }\n", " }\n", "}\n", "\"\"\"\n", "\n", "with gr.Blocks(css=\"style.css\") as demo:\n", " # these are hidden buttons that are used to trigger the canvas changes\n", " line = gr.Checkbox(label=\"line\", value=False, elem_id=\"cb-line\")\n", " eraser = gr.Checkbox(label=\"eraser\", value=False, elem_id=\"cb-eraser\")\n", " with gr.Row(elem_id=\"main_row\"):\n", " with gr.Column(elem_id=\"column_input\"):\n", " gr.Markdown(\"## INPUT\", elem_id=\"input_header\")\n", " image = gr.Image(\n", " source=\"canvas\",\n", " tool=\"color-sketch\",\n", " type=\"pil\",\n", " image_mode=\"L\",\n", " invert_colors=True,\n", " shape=(512, 512),\n", " brush_radius=4,\n", " height=440,\n", " width=440,\n", " brush_color=\"#000000\",\n", " interactive=True,\n", " show_download_button=True,\n", " elem_id=\"input_image\",\n", " show_label=False,\n", " )\n", " download_sketch = gr.Button(\"Download sketch\", scale=1, elem_id=\"download_sketch\")\n", "\n", " gr.HTML(\n", " \"\"\"\n", "
\n", "
\n", "
\n", "
\n", "
\n", "
\n", "
\n", " \"\"\"\n", " )\n", " # gr.Markdown(\"## Prompt\", elem_id=\"tools_header\")\n", " prompt = gr.Textbox(label=\"Prompt\", value=\"\", show_label=True)\n", " with gr.Row():\n", " style = gr.Dropdown(\n", " label=\"Style\",\n", " choices=STYLE_NAMES,\n", " value=DEFAULT_STYLE_NAME,\n", " scale=1,\n", " )\n", " prompt_temp = gr.Textbox(\n", " label=\"Prompt Style Template\",\n", " value=styles[DEFAULT_STYLE_NAME],\n", " scale=2,\n", " max_lines=1,\n", " )\n", "\n", " with gr.Row():\n", " seed = gr.Textbox(label=\"Seed\", value=42, scale=1, min_width=50)\n", " randomize_seed = gr.Button(\"Random\", scale=1, min_width=50)\n", "\n", " with gr.Column(elem_id=\"column_process\", min_width=50, scale=0.4):\n", " gr.Markdown(\"## pix2pix-turbo\", elem_id=\"description\")\n", " run_button = gr.Button(\"Run\", min_width=50)\n", "\n", " with gr.Column(elem_id=\"column_output\"):\n", " gr.Markdown(\"## OUTPUT\", elem_id=\"output_header\")\n", " result = gr.Image(\n", " label=\"Result\",\n", " height=440,\n", " width=440,\n", " elem_id=\"output_image\",\n", " show_label=False,\n", " show_download_button=True,\n", " )\n", " download_output = gr.Button(\"Download output\", elem_id=\"download_output\")\n", " gr.Markdown(\"### Instructions\")\n", " gr.Markdown(\"**1**. Enter a text prompt (e.g. cat)\")\n", " gr.Markdown(\"**2**. Start sketching\")\n", " gr.Markdown(\"**3**. Change the image style using a style template\")\n", " gr.Markdown(\"**4**. Try different seeds to generate different results\")\n", "\n", " eraser.change(\n", " fn=lambda x: gr.update(value=not x),\n", " inputs=[eraser],\n", " outputs=[line],\n", " queue=False,\n", " api_name=False,\n", " ).then(update_canvas, [line, eraser], [image])\n", " line.change(\n", " fn=lambda x: gr.update(value=not x),\n", " inputs=[line],\n", " outputs=[eraser],\n", " queue=False,\n", " api_name=False,\n", " ).then(update_canvas, [line, eraser], [image])\n", "\n", " demo.load(None, None, None, _js=scripts)\n", " randomize_seed.click(\n", " lambda x: random.randint(0, MAX_SEED),\n", " inputs=[],\n", " outputs=seed,\n", " queue=False,\n", " api_name=False,\n", " )\n", " inputs = [image, prompt, prompt_temp, style, seed]\n", " outputs = [result, download_sketch, download_output]\n", " prompt.submit(fn=run, inputs=inputs, outputs=outputs, api_name=False)\n", " style.change(\n", " lambda x: styles[x],\n", " inputs=[style],\n", " outputs=[prompt_temp],\n", " queue=False,\n", " api_name=False,\n", " ).then(\n", " fn=run,\n", " inputs=inputs,\n", " outputs=outputs,\n", " api_name=False,\n", " )\n", " run_button.click(fn=run, inputs=inputs, outputs=outputs, api_name=False)\n", " image.change(run, inputs=inputs, outputs=outputs, queue=False, api_name=False)\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/assets/29454499/32c3b9a6-298e-44a5-8e50-60a56e6f1980", "tags": { "categories": [ "Model Demos" ], "libraries": [], "other": [ "Stable Diffusion" ], "tasks": [ "Image-to-Image" ] } }, "widgets": { "application/vnd.jupyter.widget-state+json": { "state": {}, "version_major": 2, "version_minor": 0 } } }, "nbformat": 4, "nbformat_minor": 5 }