{ "cells": [ { "attachments": {}, "cell_type": "markdown", "id": "82044cea-a95d-4812-89a2-bbb055ea1661", "metadata": {}, "source": [ "# Universal Segmentation with OneFormer and OpenVINO" ] }, { "attachments": {}, "cell_type": "markdown", "id": "b6dbb8aa-c070-4e7d-8b7a-64588e7f0da4", "metadata": {}, "source": [ "This tutorial demonstrates how to use the [OneFormer](https://arxiv.org/abs/2211.06220) model from HuggingFace with OpenVINO. It describes how to download weights and create PyTorch model using Hugging Face transformers library, then convert model to OpenVINO Intermediate Representation format (IR) using OpenVINO Model Optimizer API and run model inference. Additionally, [NNCF](https://github.com/openvinotoolkit/nncf/) quantization is applied to improve OneFormer segmentation speed.\n", "\n", "![](https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/oneformer_architecture.png)\n", "\n", "OneFormer is a follow-up work of [Mask2Former](https://arxiv.org/abs/2112.01527). The latter still requires training on instance/semantic/panoptic datasets separately to get state-of-the-art results.\n", "\n", "OneFormer incorporates a text module in the Mask2Former framework, to condition the model on the respective subtask (instance, semantic or panoptic). This gives even more accurate results, but comes with a cost of increased latency, however." ] }, { "attachments": {}, "cell_type": "markdown", "id": "39d6e067", "metadata": {}, "source": [ "\n", "#### Table of contents:\n", "\n", "- [Install required libraries](#Install-required-libraries)\n", "- [Prepare the environment](#Prepare-the-environment)\n", "- [Load OneFormer fine-tuned on COCO for universal segmentation](#Load-OneFormer-fine-tuned-on-COCO-for-universal-segmentation)\n", "- [Convert the model to OpenVINO IR format](#Convert-the-model-to-OpenVINO-IR-format)\n", "- [Select inference device](#Select-inference-device)\n", "- [Choose a segmentation task](#Choose-a-segmentation-task)\n", "- [Inference](#Inference)\n", "- [Quantization](#Quantization)\n", " - [Preparing calibration dataset](#Preparing-calibration-dataset)\n", " - [Run quantization](#Run-quantization)\n", " - [Compare model size and performance](#Compare-model-size-and-performance)\n", "- [Interactive Demo](#Interactive-Demo)\n", "\n" ] }, { "attachments": {}, "cell_type": "markdown", "id": "3dc9e61e-e3d9-486b-a652-13083530fbc9", "metadata": { "tags": [] }, "source": [ "## Install required libraries\n", "[back to top ⬆️](#Table-of-contents:)\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "84e1b9f3-faf1-4260-aadf-c9edd53e53b6", "metadata": { "ExecuteTime": { "end_time": "2023-10-06T09:49:55.246601Z", "start_time": "2023-10-06T09:49:54.106715300Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Note: you may need to restart the kernel to use updated packages.\n" ] } ], "source": [ "import platform\n", "\n", "%pip install -q --extra-index-url https://download.pytorch.org/whl/cpu \"transformers>=4.26.0\" \"openvino>=2023.1.0\" \"nncf>=2.7.0\" \"gradio>=4.19\" \"torch>=2.1\" scipy ipywidgets Pillow tqdm\n", "\n", "if platform.system() != \"Windows\":\n", " %pip install -q \"matplotlib>=3.4\"\n", "else:\n", " %pip install -q \"matplotlib>=3.4,<3.7\"" ] }, { "attachments": {}, "cell_type": "markdown", "id": "c5fc745f-0960-4b17-8559-dd8daeac8318", "metadata": {}, "source": [ "## Prepare the environment\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "Import all required packages and set paths for models and constant variables." ] }, { "cell_type": "code", "execution_count": 2, "id": "1099fec8-3e7b-4699-b949-a166547a1081", "metadata": { "ExecuteTime": { "end_time": "2023-10-06T09:49:57.719482900Z", "start_time": "2023-10-06T09:49:54.246727800Z" } }, "outputs": [], "source": [ "import warnings\n", "from collections import defaultdict\n", "from pathlib import Path\n", "\n", "from transformers import OneFormerProcessor, OneFormerForUniversalSegmentation\n", "from transformers.models.oneformer.modeling_oneformer import (\n", " OneFormerForUniversalSegmentationOutput,\n", ")\n", "import torch\n", "import matplotlib.pyplot as plt\n", "import matplotlib.patches as mpatches\n", "from PIL import Image\n", "from PIL import ImageOps\n", "\n", "import openvino\n", "\n", "# Fetch `notebook_utils` module\n", "import requests\n", "\n", "r = requests.get(\n", " url=\"https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/latest/utils/notebook_utils.py\",\n", ")\n", "\n", "open(\"notebook_utils.py\", \"w\").write(r.text)\n", "from notebook_utils import download_file" ] }, { "cell_type": "code", "execution_count": 3, "id": "d3a38c4a-433f-4fed-bf5a-410be7160f78", "metadata": { "ExecuteTime": { "end_time": "2023-10-06T09:49:57.739657400Z", "start_time": "2023-10-06T09:49:57.719482900Z" } }, "outputs": [], "source": [ "IR_PATH = Path(\"oneformer.xml\")\n", "OUTPUT_NAMES = [\"class_queries_logits\", \"masks_queries_logits\"]" ] }, { "attachments": {}, "cell_type": "markdown", "id": "14aa6aa4-5730-469b-8fbe-2bece6ef1641", "metadata": { "tags": [] }, "source": [ "## Load OneFormer fine-tuned on COCO for universal segmentation\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "Here we use the `from_pretrained` method of `OneFormerForUniversalSegmentation` to load the [HuggingFace OneFormer model](https://huggingface.co/docs/transformers/model_doc/oneformer) based on Swin-L backbone and trained on [COCO](https://cocodataset.org/) dataset.\n", "\n", "Also, we use HuggingFace processor to prepare the model inputs from images and post-process model outputs for visualization." ] }, { "cell_type": "code", "execution_count": 4, "id": "ca18e5a3-34dd-466b-b08f-5cf0d6069e2a", "metadata": { "ExecuteTime": { "end_time": "2023-10-06T09:50:00.557805400Z", "start_time": "2023-10-06T09:49:57.720612300Z" } }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "2023-10-06 14:00:53.306851: 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", "2023-10-06 14:00:53.342792: 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", "2023-10-06 14:00:53.913248: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT\n", "/home/nsavel/venvs/ov_notebooks_tmp/lib/python3.8/site-packages/transformers/models/oneformer/image_processing_oneformer.py:427: FutureWarning: The `reduce_labels` argument is deprecated and will be removed in v4.27. Please use `do_reduce_labels` instead.\n", " warnings.warn(\n" ] } ], "source": [ "processor = OneFormerProcessor.from_pretrained(\"shi-labs/oneformer_coco_swin_large\")\n", "model = OneFormerForUniversalSegmentation.from_pretrained(\n", " \"shi-labs/oneformer_coco_swin_large\",\n", ")\n", "id2label = model.config.id2label" ] }, { "cell_type": "code", "execution_count": 5, "id": "95fb1caf-397a-4149-9dfe-641a47b3a68c", "metadata": { "ExecuteTime": { "end_time": "2023-10-06T09:50:00.578488Z", "start_time": "2023-10-06T09:50:00.554796700Z" } }, "outputs": [], "source": [ "task_seq_length = processor.task_seq_length\n", "shape = (800, 800)\n", "dummy_input = {\n", " \"pixel_values\": torch.randn(1, 3, *shape),\n", " \"task_inputs\": torch.randn(1, task_seq_length),\n", "}" ] }, { "attachments": {}, "cell_type": "markdown", "id": "9e4b09fd-dfd8-45bd-be93-992778ca8343", "metadata": { "tags": [] }, "source": [ "## Convert the model to OpenVINO IR format\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "Convert the PyTorch model to IR format to take advantage of OpenVINO optimization tools and features. The `openvino.convert_model` python function in OpenVINO Converter can convert the model. The function returns instance of OpenVINO Model class, which is ready to use in Python interface. However, it can also be serialized to OpenVINO IR format for future execution using `save_model` function.\n", "PyTorch to OpenVINO conversion is based on TorchScript tracing. HuggingFace models have specific configuration parameter `torchscript`, which can be used for making the model more suitable for tracing. For preparing model. we should provide PyTorch model instance and example input to `openvino.convert_model`." ] }, { "cell_type": "code", "execution_count": 6, "id": "d16648a3-fa3c-46d5-b2dd-53646c5f9b82", "metadata": { "ExecuteTime": { "end_time": "2023-10-06T09:50:00.578488Z", "start_time": "2023-10-06T09:50:00.565873Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "WARNING:tensorflow:Please fix your imports. Module tensorflow.python.training.tracking.base has been moved to tensorflow.python.trackable.base. The old module will be deleted in version 2.11.\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "[ WARNING ] Please fix your imports. Module %s has been moved to %s. The old module will be deleted in version %s.\n" ] } ], "source": [ "model.config.torchscript = True\n", "\n", "if not IR_PATH.exists():\n", " with warnings.catch_warnings():\n", " warnings.simplefilter(\"ignore\")\n", " model = openvino.convert_model(model, example_input=dummy_input)\n", " openvino.save_model(model, IR_PATH, compress_to_fp16=False)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "d55781cd", "metadata": {}, "source": [ "## Select inference device\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "Select device from dropdown list for running inference using OpenVINO" ] }, { "cell_type": "code", "execution_count": 7, "id": "34283a4d", "metadata": { "ExecuteTime": { "end_time": "2023-10-06T09:50:00.697540200Z", "start_time": "2023-10-06T09:50:00.570554700Z" } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "2b79d1df8d424db7896fe5be817bdf56", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Dropdown(description='Device:', index=1, options=('CPU', 'AUTO'), value='AUTO')" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import ipywidgets as widgets\n", "\n", "core = openvino.Core()\n", "\n", "device = widgets.Dropdown(\n", " options=core.available_devices + [\"AUTO\"],\n", " value=\"AUTO\",\n", " description=\"Device:\",\n", " disabled=False,\n", ")\n", "\n", "device" ] }, { "attachments": {}, "cell_type": "markdown", "id": "f2472a04-a13b-465c-9f42-9f961d7d7907", "metadata": { "tags": [] }, "source": [ "We can prepare the image using the HuggingFace processor. OneFormer leverages a processor which internally consists of an image processor (for the image modality) and a tokenizer (for the text modality). OneFormer is actually a multimodal model, since it incorporates both images and text to solve image segmentation." ] }, { "cell_type": "code", "execution_count": 8, "id": "b3beb94c-03b5-4f91-b44b-350ace719c64", "metadata": { "ExecuteTime": { "end_time": "2023-10-06T09:50:00.760038500Z", "start_time": "2023-10-06T09:50:00.686303500Z" } }, "outputs": [], "source": [ "def prepare_inputs(image: Image.Image, task: str):\n", " \"\"\"Convert image to model input\"\"\"\n", " image = ImageOps.pad(image, shape)\n", " inputs = processor(image, [task], return_tensors=\"pt\")\n", " converted = {\n", " \"pixel_values\": inputs[\"pixel_values\"],\n", " \"task_inputs\": inputs[\"task_inputs\"],\n", " }\n", " return converted" ] }, { "cell_type": "code", "execution_count": 9, "id": "63c52ac9-021d-4cbe-8a73-61c1f555220e", "metadata": { "ExecuteTime": { "end_time": "2023-10-06T09:50:00.760038500Z", "start_time": "2023-10-06T09:50:00.734454800Z" } }, "outputs": [], "source": [ "def process_output(d):\n", " \"\"\"Convert OpenVINO model output to HuggingFace representation for visualization\"\"\"\n", " hf_kwargs = {output_name: torch.tensor(d[output_name]) for output_name in OUTPUT_NAMES}\n", "\n", " return OneFormerForUniversalSegmentationOutput(**hf_kwargs)" ] }, { "cell_type": "code", "execution_count": 10, "id": "a7248344-3579-4016-a07c-027251c749c3", "metadata": { "ExecuteTime": { "end_time": "2023-10-06T09:50:36.298383400Z", "start_time": "2023-10-06T09:50:00.734454800Z" } }, "outputs": [], "source": [ "# Read the model from files.\n", "model = core.read_model(model=IR_PATH)\n", "# Compile the model.\n", "compiled_model = core.compile_model(model=model, device_name=device.value)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "1661c9b8-e08c-48a9-ab22-4d6fddab572a", "metadata": {}, "source": [ "Model predicts `class_queries_logits` of shape `(batch_size, num_queries)`\n", "and `masks_queries_logits` of shape `(batch_size, num_queries, height, width)`." ] }, { "attachments": {}, "cell_type": "markdown", "id": "58b3ab54-4f57-40ee-b32e-b2fff72b77af", "metadata": {}, "source": [ "Here we define functions for visualization of network outputs to show the inference results." ] }, { "cell_type": "code", "execution_count": 11, "id": "1dc3ec39-83ed-4fd8-8ff8-8975b027d18a", "metadata": { "ExecuteTime": { "end_time": "2023-10-06T09:50:36.301895Z", "start_time": "2023-10-06T09:50:36.298887600Z" } }, "outputs": [], "source": [ "class Visualizer:\n", " @staticmethod\n", " def extract_legend(handles):\n", " fig = plt.figure()\n", " fig.legend(handles=handles, ncol=len(handles) // 20 + 1, loc=\"center\")\n", " fig.tight_layout()\n", " return fig\n", "\n", " @staticmethod\n", " def predicted_semantic_map_to_figure(predicted_map):\n", " segmentation = predicted_map[0]\n", " # get the used color map\n", " viridis = plt.get_cmap(\"viridis\", max(1, torch.max(segmentation)))\n", " # get all the unique numbers\n", " labels_ids = torch.unique(segmentation).tolist()\n", " fig, ax = plt.subplots()\n", " ax.imshow(segmentation)\n", " ax.set_axis_off()\n", " handles = []\n", " for label_id in labels_ids:\n", " label = id2label[label_id]\n", " color = viridis(label_id)\n", " handles.append(mpatches.Patch(color=color, label=label))\n", " fig_legend = Visualizer.extract_legend(handles=handles)\n", " fig.tight_layout()\n", " return fig, fig_legend\n", "\n", " @staticmethod\n", " def predicted_instance_map_to_figure(predicted_map):\n", " segmentation = predicted_map[0][\"segmentation\"]\n", " segments_info = predicted_map[0][\"segments_info\"]\n", " # get the used color map\n", " viridis = plt.get_cmap(\"viridis\", max(torch.max(segmentation), 1))\n", " fig, ax = plt.subplots()\n", " ax.imshow(segmentation)\n", " ax.set_axis_off()\n", " instances_counter = defaultdict(int)\n", " handles = []\n", " # for each segment, draw its legend\n", " for segment in segments_info:\n", " segment_id = segment[\"id\"]\n", " segment_label_id = segment[\"label_id\"]\n", " segment_label = id2label[segment_label_id]\n", " label = f\"{segment_label}-{instances_counter[segment_label_id]}\"\n", " instances_counter[segment_label_id] += 1\n", " color = viridis(segment_id)\n", " handles.append(mpatches.Patch(color=color, label=label))\n", "\n", " fig_legend = Visualizer.extract_legend(handles)\n", " fig.tight_layout()\n", " return fig, fig_legend\n", "\n", " @staticmethod\n", " def predicted_panoptic_map_to_figure(predicted_map):\n", " segmentation = predicted_map[0][\"segmentation\"]\n", " segments_info = predicted_map[0][\"segments_info\"]\n", " # get the used color map\n", " viridis = plt.get_cmap(\"viridis\", max(torch.max(segmentation), 1))\n", " fig, ax = plt.subplots()\n", " ax.imshow(segmentation)\n", " ax.set_axis_off()\n", " instances_counter = defaultdict(int)\n", " handles = []\n", " # for each segment, draw its legend\n", " for segment in segments_info:\n", " segment_id = segment[\"id\"]\n", " segment_label_id = segment[\"label_id\"]\n", " segment_label = id2label[segment_label_id]\n", " label = f\"{segment_label}-{instances_counter[segment_label_id]}\"\n", " instances_counter[segment_label_id] += 1\n", " color = viridis(segment_id)\n", " handles.append(mpatches.Patch(color=color, label=label))\n", "\n", " fig_legend = Visualizer.extract_legend(handles)\n", " fig.tight_layout()\n", " return fig, fig_legend\n", "\n", " @staticmethod\n", " def figures_to_images(fig, fig_legend, name_suffix=\"\"):\n", " seg_filename, leg_filename = (\n", " f\"segmentation{name_suffix}.png\",\n", " f\"legend{name_suffix}.png\",\n", " )\n", " fig.savefig(seg_filename, bbox_inches=\"tight\")\n", " fig_legend.savefig(leg_filename, bbox_inches=\"tight\")\n", " segmentation = Image.open(seg_filename)\n", " legend = Image.open(leg_filename)\n", " return segmentation, legend" ] }, { "cell_type": "code", "execution_count": 12, "id": "702813df-3229-44c1-afbe-58cef6dff28d", "metadata": { "ExecuteTime": { "end_time": "2023-10-06T09:50:36.301895Z", "start_time": "2023-10-06T09:50:36.298887600Z" } }, "outputs": [], "source": [ "def segment(model, img: Image.Image, task: str):\n", " \"\"\"\n", " Apply segmentation on an image.\n", "\n", " Args:\n", " img: Input image. It will be resized to 800x800.\n", " task: String describing the segmentation task. Supported values are: \"semantic\", \"instance\" and \"panoptic\".\n", " Returns:\n", " Tuple[Figure, Figure]: Segmentation map and legend charts.\n", " \"\"\"\n", " if img is None:\n", " raise gr.Error(\"Please load the image or use one from the examples list\")\n", " inputs = prepare_inputs(img, task)\n", " outputs = model(inputs)\n", " hf_output = process_output(outputs)\n", " predicted_map = getattr(processor, f\"post_process_{task}_segmentation\")(hf_output, target_sizes=[img.size[::-1]])\n", " return getattr(Visualizer, f\"predicted_{task}_map_to_figure\")(predicted_map)" ] }, { "cell_type": "code", "execution_count": 13, "id": "ed98c5da-d67a-4c94-8df1-c760098b827a", "metadata": { "ExecuteTime": { "end_time": "2023-10-06T09:50:36.898279100Z", "start_time": "2023-10-06T09:50:36.298887600Z" } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "223ed197a12f45d290b3ee6cfe2465a0", "version_major": 2, "version_minor": 0 }, "text/plain": [ "sample.jpg: 0%| | 0.00/194k [00:00" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "image = download_file(\"http://images.cocodataset.org/val2017/000000439180.jpg\", \"sample.jpg\")\n", "image = Image.open(\"sample.jpg\")\n", "image" ] }, { "attachments": {}, "cell_type": "markdown", "id": "a4bb371e-3573-407b-80f8-5f49a92eecf7", "metadata": {}, "source": [ "## Choose a segmentation task\n", "[back to top ⬆️](#Table-of-contents:)\n" ] }, { "cell_type": "code", "execution_count": 14, "id": "0685b34c-2ec7-44d7-9238-12783107bdec", "metadata": { "ExecuteTime": { "end_time": "2023-10-06T09:50:36.899298100Z", "start_time": "2023-10-06T09:50:36.878775400Z" } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b1462b3ffc2840e4a649bb32ebd4117c", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Dropdown(options=('semantic', 'instance', 'panoptic'), value='semantic')" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from ipywidgets import Dropdown\n", "\n", "task = Dropdown(options=[\"semantic\", \"instance\", \"panoptic\"], value=\"semantic\")\n", "task" ] }, { "attachments": {}, "cell_type": "markdown", "id": "53dff9a4-a0ba-4455-a01f-bc7d65662e32", "metadata": {}, "source": [ "## Inference\n", "[back to top ⬆️](#Table-of-contents:)\n" ] }, { "cell_type": "code", "execution_count": 15, "id": "a9a6df8c-8f10-4502-a888-8c0c56bcd667", "metadata": { "ExecuteTime": { "end_time": "2023-10-06T09:50:39.040662700Z", "start_time": "2023-10-06T09:50:36.879762200Z" } }, "outputs": [ { "data": { "image/jpeg": "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", "image/png": "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", "text/plain": [ "" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import matplotlib\n", "\n", "matplotlib.use(\"Agg\") # disable showing figures\n", "\n", "\n", "def stack_images_horizontally(img1: Image, img2: Image):\n", " res = Image.new(\"RGB\", (img1.width + img2.width, max(img1.height, img2.height)), (255, 255, 255))\n", " res.paste(img1, (0, 0))\n", " res.paste(img2, (img1.width, 0))\n", " return res\n", "\n", "\n", "segmentation_fig, legend_fig = segment(compiled_model, image, task.value)\n", "segmentation_image, legend_image = Visualizer.figures_to_images(segmentation_fig, legend_fig)\n", "plt.close(\"all\")\n", "prediction = stack_images_horizontally(segmentation_image, legend_image)\n", "prediction" ] }, { "attachments": {}, "cell_type": "markdown", "id": "c8cac1f9", "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "source": [ "## Quantization\n", "[back to top ⬆️](#Table-of-contents:)\n" ] }, { "attachments": {}, "cell_type": "markdown", "id": "fb768314-e377-424a-98fa-1ab5f2dc55f9", "metadata": {}, "source": [ "[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", "The optimization process contains the following steps:\n", "1. Create a calibration dataset for quantization.\n", "2. Run `nncf.quantize()` to obtain quantized model.\n", "3. Serialize the `INT8` model using `openvino.save_model()` function.\n", "\n", "> Note: Quantization is time and memory consuming operation. Running quantization code below may take some time." ] }, { "attachments": {}, "cell_type": "markdown", "id": "fc4937a0-1b7d-4631-adee-3dff9c23b4fb", "metadata": {}, "source": [ "Please select below whether you would like to run quantization to improve model inference speed." ] }, { "cell_type": "code", "execution_count": 16, "id": "b275b069", "metadata": { "ExecuteTime": { "end_time": "2023-10-06T09:50:39.040662700Z", "start_time": "2023-10-06T09:50:39.040662700Z" }, "collapsed": false, "jupyter": { "outputs_hidden": false }, "test_replace": { "value=False": "value=True" } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "3ca7c0e009414b26ac95211abe84a5b2", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Checkbox(value=True, description='Quantization')" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "compiled_quantized_model = None\n", "\n", "to_quantize = widgets.Checkbox(\n", " value=False,\n", " description=\"Quantization\",\n", " disabled=False,\n", ")\n", "\n", "to_quantize" ] }, { "attachments": {}, "cell_type": "markdown", "id": "9b4afdfd-3061-4456-9882-1fbd09f6f067", "metadata": {}, "source": [ "Let's load skip magic extension to skip quantization if to_quantize is not selected" ] }, { "cell_type": "code", "execution_count": 17, "id": "77fcac65", "metadata": { "ExecuteTime": { "end_time": "2023-10-06T09:50:39.040662700Z", "start_time": "2023-10-06T09:50:39.040662700Z" }, "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [], "source": [ "# Fetch `skip_kernel_extension` module\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": "9f9209c2-412d-4edc-b860-a69cfcf2af4f", "metadata": {}, "source": [ "### Preparing calibration dataset\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "We use images from [COCO128](https://www.kaggle.com/datasets/ultralytics/coco128) dataset as calibration samples." ] }, { "cell_type": "code", "execution_count": 18, "id": "7f9e1897", "metadata": { "ExecuteTime": { "end_time": "2023-10-06T09:50:40.699943100Z", "start_time": "2023-10-06T09:50:39.040662700Z" }, "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "INFO:nncf:NNCF initialized successfully. Supported frameworks detected: torch, tensorflow, onnx, openvino\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "ebdf72abea024a8b9b882dc74235b651", "version_major": 2, "version_minor": 0 }, "text/plain": [ "coco128.zip: 0%| | 0.00/6.66M [00:00" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Quantized model prediction:\n" ] }, { "data": { "image/jpeg": "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", "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%%skip not $to_quantize.value\n", "\n", "from IPython.display import display\n", "\n", "image = Image.open(\"sample.jpg\")\n", "segmentation_fig, legend_fig = segment(compiled_quantized_model, image, task.value)\n", "segmentation_image, legend_image = Visualizer.figures_to_images(segmentation_fig, legend_fig, name_suffix=\"_int8\")\n", "plt.close(\"all\")\n", "prediction_int8 = stack_images_horizontally(segmentation_image, legend_image)\n", "print(\"Original model prediction:\")\n", "display(prediction)\n", "print(\"Quantized model prediction:\")\n", "display(prediction_int8)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "ce70995f", "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "source": [ "### Compare model size and performance\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "Below we compare original and quantized model footprint and inference speed." ] }, { "cell_type": "code", "execution_count": 21, "id": "9b851a5d-d437-4f22-a6a2-8049b5c91f72", "metadata": { "ExecuteTime": { "end_time": "2023-10-06T09:52:30.197035100Z", "start_time": "2023-10-06T09:51:24.972294800Z" }, "test_replace": { "INFERENCE_TIME_DATASET_SIZE = 30": "INFERENCE_TIME_DATASET_SIZE = 1" } }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "505c39db58984de19e40d38248476693", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Measuring performance: 0%| | 0/30 [00:00" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import time\n", "import gradio as gr\n", "\n", "quantized_model_present = compiled_quantized_model is not None\n", "\n", "\n", "def compile_model(device):\n", " global compiled_model\n", " global compiled_quantized_model\n", " compiled_model = core.compile_model(model=model, device_name=device)\n", " if quantized_model_present:\n", " compiled_quantized_model = core.compile_model(model=quantized_model, device_name=device)\n", "\n", "\n", "def segment_wrapper(image, task, run_quantized=False):\n", " current_model = compiled_quantized_model if run_quantized else compiled_model\n", "\n", " start_time = time.perf_counter()\n", " segmentation_fig, legend_fig = segment(current_model, image, task)\n", " end_time = time.perf_counter()\n", "\n", " name_suffix = \"\" if not quantized_model_present else \"_int8\" if run_quantized else \"_fp32\"\n", " segmentation_image, legend_image = Visualizer.figures_to_images(segmentation_fig, legend_fig, name_suffix=name_suffix)\n", " plt.close(\"all\")\n", " result = stack_images_horizontally(segmentation_image, legend_image)\n", " return result, f\"{end_time - start_time:.2f}\"\n", "\n", "\n", "with gr.Blocks() as demo:\n", " with gr.Row():\n", " with gr.Column():\n", " inp_img = gr.Image(label=\"Image\", type=\"pil\")\n", " inp_task = gr.Radio([\"semantic\", \"instance\", \"panoptic\"], label=\"Task\", value=\"semantic\")\n", " inp_device = gr.Dropdown(label=\"Device\", choices=core.available_devices + [\"AUTO\"], value=\"AUTO\")\n", " with gr.Column():\n", " out_result = gr.Image(label=\"Result (Original)\" if quantized_model_present else \"Result\")\n", " inference_time = gr.Textbox(label=\"Time (seconds)\")\n", " out_result_quantized = gr.Image(label=\"Result (Quantized)\", visible=quantized_model_present)\n", " inference_time_quantized = gr.Textbox(label=\"Time (seconds)\", visible=quantized_model_present)\n", " run_button = gr.Button(value=\"Run\")\n", " run_button.click(\n", " segment_wrapper,\n", " [inp_img, inp_task, gr.Number(0, visible=False)],\n", " [out_result, inference_time],\n", " )\n", " run_quantized_button = gr.Button(value=\"Run quantized\", visible=quantized_model_present)\n", " run_quantized_button.click(\n", " segment_wrapper,\n", " [inp_img, inp_task, gr.Number(1, visible=False)],\n", " [out_result_quantized, inference_time_quantized],\n", " )\n", " gr.Examples(examples=[[\"sample.jpg\", \"semantic\"]], inputs=[inp_img, inp_task])\n", "\n", " def on_device_change_begin():\n", " return (\n", " run_button.update(value=\"Changing device...\", interactive=False),\n", " run_quantized_button.update(value=\"Changing device...\", interactive=False),\n", " inp_device.update(interactive=False),\n", " )\n", "\n", " def on_device_change_end():\n", " return (\n", " run_button.update(value=\"Run\", interactive=True),\n", " run_quantized_button.update(value=\"Run quantized\", interactive=True),\n", " inp_device.update(interactive=True),\n", " )\n", "\n", " inp_device.change(on_device_change_begin, outputs=[run_button, run_quantized_button, inp_device]).then(compile_model, inp_device).then(\n", " on_device_change_end, outputs=[run_button, run_quantized_button, inp_device]\n", " )\n", "\n", "try:\n", " demo.launch(debug=True)\n", "except Exception:\n", " demo.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/oneformer-segmentation/oneformer-segmentation.png?raw=true", "tags": { "categories": [ "Model Demos" ], "libraries": [], "other": [], "tasks": [ "Image Segmentation" ] } }, "widgets": { "application/vnd.jupyter.widget-state+json": { "state": {}, "version_major": 2, "version_minor": 0 } } }, "nbformat": 4, "nbformat_minor": 5 }