{ "cells": [ { "attachments": {}, "cell_type": "markdown", "id": "0dc07a8a-6d77-43f7-afd3-c1852a5f21b8", "metadata": {}, "source": [ "# Mobile language assistant with MobileVLM and OpenVINO\n", "[MobileVLM](https://arxiv.org/abs/2312.16886) is a competent multimodal vision language model (MMVLM) targeted to run on mobile devices. It is an amalgamation of a myriad of architectural designs and techniques that are mobile-oriented, which comprises a set of language models at the scale of 1.4B and 2.7B parameters, trained from scratch, a multimodal vision model that is pre-trained in the CLIP fashion, cross-modality interaction via an efficient projector.\n", "\n", "![](https://github.com/Meituan-AutoML/MobileVLM/raw/main/assets/mobilevlm_arch.png)\n", "\n", "The MobileVLM architecture (right) utilizes [MobileLLaMA](https://huggingface.co/mtgv/MobileLLaMA-1.4B-Base) as its language model, intakes $\\mathbf{X}_v$ and $\\mathbf{X}_q$ which are image and language instructions as respective inputs and gives $\\mathbf{Y}_a$ as the output language response. LDP refers to a lightweight downsample projector (left).\n", "\n", "See more information on official [GitHub](https://github.com/Meituan-AutoML/MobileVLM) project page and [paper](https://arxiv.org/abs/2312.16886).\n", "\n", "#### Table of contents:\n", "\n", "- [Install requirements](#Install-requirements)\n", "- [Clone MobileVLM repository](#Clone-MobileVLM-repository)\n", "- [Import required packages](#Import-required-packages)\n", "- [Load the model](#Load-the-model)\n", "- [Convert model to OpenVINO Intermediate Representation (IR)](#Convert-model-to-OpenVINO-Intermediate-Representation-(IR))\n", "- [Inference](#Inference)\n", " - [Load OpenVINO model](#Load-OpenVINO-model)\n", " - [Prepare input data](#Prepare-input-data)\n", " - [Run generation process](#Run-generation-process)\n", "- [Interactive inference](#Interactive-inference)\n", "\n" ] }, { "attachments": {}, "cell_type": "markdown", "id": "2d05c5ef-d883-4304-a9f9-667b745d0916", "metadata": {}, "source": [ "## Install requirements\n", "[back to top ⬆️](#Table-of-contents:)" ] }, { "cell_type": "code", "execution_count": 1, "id": "4c41f7a1-e506-4935-abfd-0a6ee2f01167", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Note: you may need to restart the kernel to use updated packages.\n", "Note: you may need to restart the kernel to use updated packages.\n" ] } ], "source": [ "%pip install -q \"torch>=2.1.0\" \"timm>=0.9.12\" --extra-index-url \"https://download.pytorch.org/whl/cpu\"\n", "%pip install -q \"transformers>=4.33.1,<4.35.0\" accelerate \"sentencepiece>=0.1.99\" \"openvino>=2023.2.0\" \"nncf>=2.7.0\" ipywidgets numpy \"gradio>=4.19\"" ] }, { "attachments": {}, "cell_type": "markdown", "id": "30a8ea7b-cec8-42bf-902a-26f711e6696c", "metadata": {}, "source": [ "## Clone MobileVLM repository\n", "[back to top ⬆️](#Table-of-contents:)" ] }, { "cell_type": "code", "execution_count": 2, "id": "1056d6c7-97ae-44b3-8d2b-3d918798345c", "metadata": {}, "outputs": [], "source": [ "from pathlib import Path\n", "import sys\n", "\n", "MOBILEVLM_REPO_DIR = Path(\"./MobileVLM\")\n", "if not MOBILEVLM_REPO_DIR.exists():\n", " !git clone -q \"https://github.com/Meituan-AutoML/MobileVLM.git\"\n", "sys.path.insert(0, str(MOBILEVLM_REPO_DIR))" ] }, { "attachments": {}, "cell_type": "markdown", "id": "219dc629-3e9a-4e00-9cb2-b97f7ccc3fdd", "metadata": {}, "source": [ "## Import required packages\n", "[back to top ⬆️](#Table-of-contents:)" ] }, { "cell_type": "code", "execution_count": 3, "id": "d4222982-c853-43fc-a522-662c47ea785d", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "INFO:nncf:NNCF initialized successfully. Supported frameworks detected: torch, openvino\n" ] } ], "source": [ "import warnings\n", "import itertools\n", "import gc\n", "from typing import Optional, List, Tuple\n", "\n", "from mobilevlm.model.mobilevlm import load_pretrained_model\n", "from mobilevlm.conversation import conv_templates, SeparatorStyle\n", "from mobilevlm.utils import (\n", " disable_torch_init,\n", " process_images,\n", " tokenizer_image_token,\n", " KeywordsStoppingCriteria,\n", ")\n", "from mobilevlm.constants import IMAGE_TOKEN_INDEX, DEFAULT_IMAGE_TOKEN\n", "import PIL\n", "import torch\n", "import transformers\n", "import numpy as np\n", "import gradio as gr\n", "import openvino as ov\n", "import nncf\n", "import ipywidgets as widgets" ] }, { "cell_type": "code", "execution_count": 4, "id": "ba6fb0d0-be7c-4a48-a55a-4dcf148869da", "metadata": {}, "outputs": [], "source": [ "MODELS_DIR = Path(\"./models\")\n", "MODEL_PATH = \"mtgv/MobileVLM-1.7B\"\n", "\n", "TEMPERATURE = 0.2\n", "TOP_P = None\n", "NUM_BEAMS = 1\n", "MAX_NEW_TOKENS = 512\n", "\n", "IMAGE_PATH = MOBILEVLM_REPO_DIR / \"assets\" / \"samples\" / \"demo.jpg\"\n", "PROMPT_STR = \"Who is the author of this book?\\nAnswer the question using a single word or phrase.\"" ] }, { "attachments": {}, "cell_type": "markdown", "id": "dc0fc34a-fd93-4af0-9cce-fd7750136521", "metadata": {}, "source": [ "## Load the model\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "To load the model, we use pre-defined `load_pretrained_model` function in `mobilevlm` module. It returns the model itself, tokenizer, and image processor to convert images to appropriate tensors." ] }, { "cell_type": "code", "execution_count": 5, "id": "b02af483-06fc-40d1-a908-562e42f0e1ae", "metadata": {}, "outputs": [], "source": [ "model_name = MODEL_PATH.split(\"/\")[-1]\n", "disable_torch_init()\n", "with warnings.catch_warnings():\n", " warnings.simplefilter(\"ignore\")\n", " tokenizer, model, image_processor, _ = load_pretrained_model(MODEL_PATH, device=\"cpu\")\n", "model = model.to(dtype=torch.float32)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "fd47411b-d601-4d96-b2a4-0e5682db7898", "metadata": {}, "source": [ "## Convert model to OpenVINO Intermediate Representation (IR)\n", "[back to top ⬆️](#Table-of-contents:)" ] }, { "cell_type": "code", "execution_count": 6, "id": "3a290547-575e-4ee0-9a59-274548e2c50a", "metadata": {}, "outputs": [], "source": [ "def cleanup_torchscript_cache():\n", " \"\"\"\n", " Helper for removing cached model representation\n", " \"\"\"\n", " torch._C._jit_clear_class_registry()\n", " torch.jit._recursive.concrete_type_store = torch.jit._recursive.ConcreteTypeStore()\n", " torch.jit._state._clear_class_state()" ] }, { "attachments": {}, "cell_type": "markdown", "id": "f02b9979-21c6-4120-a86b-a8cc7024a536", "metadata": {}, "source": [ "For reducing memory consumption, weights compression optimization can be applied using [NNCF](https://github.com/openvinotoolkit/nncf). Weight compression aims to reduce the memory footprint of a model. It can also lead to significant performance improvement for large memory-bound models, such as Large Language Models (LLMs). LLMs and other models, which require extensive memory to store the weights during inference, can benefit from weight compression in the following ways:\n", "\n", "* enabling the inference of exceptionally large models that cannot be accommodated in the memory of the device;\n", "\n", "* improving the inference performance of the models by reducing the latency of the memory access when computing the operations with weights, for example, Linear layers.\n", "\n", "[Neural Network Compression Framework (NNCF)](https://github.com/openvinotoolkit/nncf) provides 4-bit / 8-bit mixed weight quantization as a compression method primarily designed to optimize LLMs. The main difference between weights compression and full model quantization (post-training quantization) is that activations remain floating-point in the case of weights compression which leads to a better accuracy. Weight compression for LLMs provides a solid inference performance improvement which is on par with the performance of the full model quantization. In addition, weight compression is data-free and does not require a calibration dataset, making it easy to use.\n", "\n", "`nncf.compress_weights` function can be used for performing weights compression. The function accepts an OpenVINO model and other compression parameters. Compared to INT8 compression, INT4 compression improves performance even more, but introduces a minor drop in prediction quality.\n", "\n", "More details about weights compression, can be found in [OpenVINO documentation](https://docs.openvino.ai/2024/openvino-workflow/model-optimization-guide/weight-compression.html).\n", "\n", "Please select below whether you would like to run INT4 weight compression instead of INT8 weight compression." ] }, { "cell_type": "code", "execution_count": 7, "id": "45ac142b-e8bb-49ca-aa05-d0a0899daf07", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "ca56ff04506a463fae4e6c1f221f8d08", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Dropdown(description='Compression mode:', options=('INT4', 'INT8'), value='INT4')" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "compression_mode = widgets.Dropdown(\n", " options=[\"INT4\", \"INT8\"],\n", " value=\"INT4\",\n", " description=\"Compression mode:\",\n", " disabled=False,\n", ")\n", "\n", "compression_mode" ] }, { "cell_type": "code", "execution_count": 8, "id": "d692efcf-144a-4c32-9c0b-dc1f7d18d41e", "metadata": {}, "outputs": [], "source": [ "stage1_xml_path = MODELS_DIR / f\"stage1_{compression_mode.value}.xml\"\n", "stage2_xml_path = MODELS_DIR / f\"stage2_{compression_mode.value}.xml\"" ] }, { "cell_type": "code", "execution_count": 9, "id": "9ff7d623-69e6-4fcb-8f73-7c29f5dae9a9", "metadata": {}, "outputs": [], "source": [ "if compression_mode.value == \"INT4\":\n", " wc_parameters = dict(mode=nncf.CompressWeightsMode.INT4_ASYM, group_size=128, ratio=0.8)\n", "else:\n", " wc_parameters = dict(mode=nncf.CompressWeightsMode.INT8)" ] }, { "cell_type": "code", "execution_count": 10, "id": "42c6d11e-8c21-423f-9d25-6703fb288560", "metadata": {}, "outputs": [], "source": [ "class ModelWrapper(torch.nn.Module):\n", " def __init__(self, model):\n", " super().__init__()\n", " self.model = model\n", "\n", " def forward(\n", " self,\n", " input_ids: torch.LongTensor = None,\n", " attention_mask: Optional[torch.Tensor] = None,\n", " past_key_values: Optional[List[torch.FloatTensor]] = None,\n", " inputs_embeds: Optional[torch.FloatTensor] = None,\n", " ):\n", " outputs = self.model.model(\n", " input_ids=input_ids,\n", " attention_mask=attention_mask,\n", " past_key_values=past_key_values,\n", " inputs_embeds=inputs_embeds,\n", " )\n", " hidden_states = outputs[0]\n", " logits = self.model.lm_head(hidden_states)\n", "\n", " return (logits,) + outputs[1:]" ] }, { "cell_type": "code", "execution_count": 11, "id": "4cfa1256-66af-40ac-b0d3-9fd7aeac54f1", "metadata": {}, "outputs": [], "source": [ "def set_input_names(model, past_key_values):\n", " input_names = [\n", " \"input_ids\",\n", " \"attention_mask\",\n", " *itertools.chain.from_iterable([f\"past_key_values.{idx}.key\", f\"past_key_values.{idx}.value\"] for idx, _ in enumerate(past_key_values)),\n", " ]\n", " assert len(input_names) == len(model.inputs)\n", " for _input, input_name in zip(model.inputs, input_names):\n", " _input.get_tensor().set_names({input_name})" ] }, { "cell_type": "code", "execution_count": 12, "id": "bfbaa52b-7bf5-4239-a3ca-1ed78b04711e", "metadata": {}, "outputs": [], "source": [ "def set_output_names(model, past_key_values):\n", " output_names = [\n", " \"logits\",\n", " *itertools.chain.from_iterable([f\"present.{idx}.key\", f\"present.{idx}.value\"] for idx, _ in enumerate(past_key_values)),\n", " ]\n", " assert len(output_names) == len(model.outputs)\n", " for out, out_name in zip(ov_model.outputs, output_names):\n", " out.get_tensor().set_names({out_name})" ] }, { "cell_type": "code", "execution_count": 13, "id": "653409bb-3958-4e5f-a4a7-625a28320fa6", "metadata": {}, "outputs": [], "source": [ "example_input = {\n", " \"inputs_embeds\": torch.zeros((1, 205, 2048)),\n", " \"attention_mask\": torch.ones((1, 205), dtype=torch.long),\n", "}\n", "\n", "wrapped = ModelWrapper(model)\n", "past_key_values = wrapped(**example_input)[1]\n", "\n", "if not stage1_xml_path.exists():\n", " ov_model = ov.convert_model(wrapped, example_input=example_input)\n", " set_output_names(ov_model, past_key_values)\n", " ov_model = nncf.compress_weights(ov_model, **wc_parameters)\n", " ov.save_model(ov_model, stage1_xml_path)\n", " cleanup_torchscript_cache()\n", " del ov_model\n", " gc.collect()" ] }, { "cell_type": "code", "execution_count": 14, "id": "1ede1f11-44f4-4425-b991-d408e16e954f", "metadata": {}, "outputs": [], "source": [ "example_input = {\n", " \"input_ids\": torch.ones((1, 1), dtype=torch.long),\n", " \"past_key_values\": past_key_values,\n", " \"attention_mask\": torch.ones((1, past_key_values[-1][-1].shape[-2] + 1), dtype=torch.long),\n", "}\n", "\n", "if not stage2_xml_path.exists():\n", " ov_model = ov.convert_model(\n", " wrapped,\n", " example_input=example_input,\n", " )\n", " set_input_names(ov_model, past_key_values)\n", " set_output_names(ov_model, past_key_values)\n", " ov_model = nncf.compress_weights(ov_model, **wc_parameters)\n", " ov.save_model(ov_model, stage2_xml_path)\n", " cleanup_torchscript_cache()\n", " del ov_model\n", " gc.collect()" ] }, { "cell_type": "code", "execution_count": 15, "id": "d235f796-f697-48a2-abe5-41fd10ce340c", "metadata": {}, "outputs": [], "source": [ "prepare_inputs_labels_for_multimodal = model.prepare_inputs_labels_for_multimodal\n", "prepare_inputs_for_generation = model.prepare_inputs_for_generation\n", "config = model.config\n", "config.save_pretrained(MODELS_DIR)" ] }, { "cell_type": "code", "execution_count": 16, "id": "f0c9e203-79d2-4cd3-afcf-2eb9b83cb362", "metadata": {}, "outputs": [], "source": [ "del wrapped\n", "del model\n", "gc.collect();" ] }, { "attachments": {}, "cell_type": "markdown", "id": "dc864b13-c531-4324-abac-ecfa5fa19272", "metadata": {}, "source": [ "## Inference\n", "[back to top ⬆️](#Table-of-contents:)\n", "\n", "`OVMobileLlamaForCausalLM` class provides ease-to-use interface for using model in generation scenario. It is based on `transformers.generation.GenerationMixin` that gives us opportunity to reuse all reach capabilities for generation implemented in HuggingFace Transformers library. More details about this interface can be found in [HuggingFace documentation](https://huggingface.co/docs/transformers/main_classes/text_generation)." ] }, { "cell_type": "code", "execution_count": 17, "id": "60fe69b9-520d-45b4-8a35-e191a87847de", "metadata": {}, "outputs": [], "source": [ "class OVMobileLlamaForCausalLM(transformers.GenerationMixin):\n", " def __init__(self, stage1_path, stage2_path, device):\n", " self.stage1 = core.compile_model(stage1_path, device)\n", " self.stage2 = core.read_model(stage2_path)\n", "\n", " self.generation_config = transformers.GenerationConfig.from_model_config(config)\n", " self.config = transformers.AutoConfig.from_pretrained(MODELS_DIR)\n", " self.main_input_name = \"input_ids\"\n", " self.device = torch.device(\"cpu\")\n", " self.prepare_inputs_for_generation = prepare_inputs_for_generation\n", " self.num_pkv = 2\n", " self.input_names = {key.get_any_name(): idx for idx, key in enumerate(self.stage2.inputs)}\n", " self.output_names = {key.get_any_name(): idx for idx, key in enumerate(self.stage2.outputs)}\n", " self.key_value_input_names = [key for key in self.input_names if \"key_values\" in key]\n", " self.key_value_output_names = [key for key in self.output_names if \"present\" in key]\n", " stage2 = core.compile_model(self.stage2, device)\n", " self.request = stage2.create_infer_request()\n", "\n", " def can_generate(self):\n", " \"\"\"Returns True to validate the check that the model using `GenerationMixin.generate()` can indeed generate.\"\"\"\n", " return True\n", "\n", " def __call__(\n", " self,\n", " input_ids: torch.LongTensor,\n", " images: torch.Tensor,\n", " attention_mask: Optional[torch.LongTensor] = None,\n", " prefix_mask: Optional[torch.LongTensor] = None,\n", " past_key_values: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,\n", " **kwargs,\n", " ) -> transformers.modeling_outputs.CausalLMOutputWithPast:\n", " return self.forward(input_ids, images, attention_mask, prefix_mask, past_key_values)\n", "\n", " def forward(\n", " self,\n", " input_ids: torch.LongTensor,\n", " images: torch.Tensor,\n", " attention_mask: Optional[torch.LongTensor] = None,\n", " prefix_mask: Optional[torch.LongTensor] = None,\n", " past_key_values: Optional[Tuple[Tuple[torch.FloatTensor]]] = None,\n", " **kwargs,\n", " ) -> transformers.modeling_outputs.CausalLMOutputWithPast:\n", " \"\"\"General inference method\"\"\"\n", " inputs = {}\n", " if past_key_values is not None:\n", " # Flatten the past_key_values\n", " attention_mask = torch.ones(\n", " (input_ids.shape[0], past_key_values[-1][-1].shape[-2] + 1),\n", " dtype=input_ids.dtype,\n", " )\n", " past_key_values = tuple(past_key_value for pkv_per_layer in past_key_values for past_key_value in pkv_per_layer)\n", " # Add the past_key_values to the decoder inputs\n", " inputs = dict(zip(self.key_value_input_names, past_key_values))\n", "\n", " else:\n", " return self.forward_with_image(input_ids, images, attention_mask)\n", " inputs[\"input_ids\"] = np.array(input_ids)\n", "\n", " if \"attention_mask\" in self.input_names:\n", " inputs[\"attention_mask\"] = np.array(attention_mask)\n", "\n", " # Run inference\n", " self.request.start_async(inputs, share_inputs=True)\n", " self.request.wait()\n", "\n", " logits = torch.from_numpy(self.request.get_tensor(\"logits\").data)\n", "\n", " # Tuple of length equal to : number of layer * number of past_key_value per decoder layer (2 corresponds to the self-attention layer)\n", " past_key_values = tuple(self.request.get_tensor(key).data for key in self.key_value_output_names)\n", " # Tuple of tuple of length `n_layers`, with each tuple of length equal to 2 (k/v of self-attention)\n", "\n", " past_key_values = tuple(past_key_values[i : i + self.num_pkv] for i in range(0, len(past_key_values), self.num_pkv))\n", "\n", " return transformers.modeling_outputs.CausalLMOutputWithPast(logits=logits, past_key_values=past_key_values)\n", "\n", " def forward_with_image(self, input_ids, images, attention_mask):\n", " \"\"\"First step inference method, that resolves multimodal data\"\"\"\n", " _, attention_mask, _, input_embed, _ = prepare_inputs_labels_for_multimodal(input_ids, attention_mask, images=images, past_key_values=None, labels=None)\n", " outs = self.stage1({\"inputs_embeds\": input_embed, \"attention_mask\": attention_mask})\n", " logits = outs[0]\n", " pkv = list(outs.values())[1:]\n", " pkv = tuple(pkv[i : i + self.num_pkv] for i in range(0, len(pkv), self.num_pkv))\n", " return transformers.modeling_outputs.CausalLMOutputWithPast(logits=torch.from_numpy(logits), past_key_values=pkv)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "6546d183-1e22-4801-a57d-f58b70a69061", "metadata": {}, "source": [ "Now, when we have model and defined generation pipeline, we can run model inference.\n", "\n", "Select device from dropdown list for running inference using OpenVINO." ] }, { "cell_type": "code", "execution_count": 18, "id": "4f2044b7-449b-4446-bde1-39ba9cf95475", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "3b95c8fdbb4440dcabe5b473c05365fe", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Dropdown(description='Device:', index=1, options=('CPU', 'AUTO'), value='AUTO')" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "core = ov.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": "e1996220-bc65-4e10-bd08-c50db96de13c", "metadata": {}, "source": [ "### Load OpenVINO model\n", "[back to top ⬆️](#Table-of-contents:)" ] }, { "cell_type": "code", "execution_count": 19, "id": "ee3ff877-1769-4692-9421-d958a0efbf41", "metadata": {}, "outputs": [], "source": [ "ov_model = OVMobileLlamaForCausalLM(stage1_xml_path, stage2_xml_path, device.value)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "36be6844-e00d-4611-85da-31ad76163062", "metadata": {}, "source": [ "### Prepare input data\n", "[back to top ⬆️](#Table-of-contents:)" ] }, { "cell_type": "code", "execution_count": 20, "id": "8a496153-4580-4343-98c0-f85c13be0fbb", "metadata": {}, "outputs": [], "source": [ "images = [PIL.Image.open(IMAGE_PATH).convert(\"RGB\")]\n", "images_tensor = process_images(images, image_processor, transformers.AutoConfig.from_pretrained(MODELS_DIR))" ] }, { "cell_type": "code", "execution_count": 21, "id": "ff8dc273-8ffa-4ffb-b14a-42e1d2144466", "metadata": {}, "outputs": [], "source": [ "conv = conv_templates[\"v1\"].copy()\n", "conv.append_message(conv.roles[0], DEFAULT_IMAGE_TOKEN + \"\\n\" + PROMPT_STR)\n", "conv.append_message(conv.roles[1], None)\n", "prompt = conv.get_prompt()\n", "stop_str = conv.sep if conv.sep_style != SeparatorStyle.TWO else conv.sep2\n", "input_ids = tokenizer_image_token(prompt, tokenizer, IMAGE_TOKEN_INDEX, return_tensors=\"pt\").unsqueeze(0)\n", "stopping_criteria = KeywordsStoppingCriteria([stop_str], tokenizer, input_ids)" ] }, { "cell_type": "code", "execution_count": 21, "id": "e90ea32d-6857-4c8c-9356-c81c509f9d5c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Who is the author of this book?\n", "Answer the question using a single word or phrase.\n" ] }, { "data": { "image/jpeg": "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", "image/png": "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", "text/plain": [ "" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "print(PROMPT_STR)\n", "images[0]" ] }, { "attachments": {}, "cell_type": "markdown", "id": "601f2c18-fc6c-48ac-8dae-9e5356a9ffad", "metadata": {}, "source": [ "### Run generation process\n", "[back to top ⬆️](#Table-of-contents:)" ] }, { "cell_type": "code", "execution_count": 22, "id": "79789ce6-ddff-4544-a5d0-7d3614450037", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "🚀 MobileVLM-1.7B with OpenVINO: Susan Wise Bauer\n", "\n" ] } ], "source": [ "output_ids = ov_model.generate(\n", " input_ids,\n", " images=images_tensor,\n", " do_sample=True if TEMPERATURE > 0 else False,\n", " temperature=TEMPERATURE,\n", " top_p=TOP_P,\n", " num_beams=NUM_BEAMS,\n", " max_new_tokens=MAX_NEW_TOKENS,\n", " use_cache=True,\n", " stopping_criteria=[stopping_criteria],\n", ")\n", "input_token_len = input_ids.shape[1]\n", "n_diff_input_output = (input_ids != output_ids[:, :input_token_len]).sum().item()\n", "if n_diff_input_output > 0:\n", " print(f\"[Warning] {n_diff_input_output} output_ids are not the same as the input_ids\")\n", "outputs = tokenizer.batch_decode(output_ids[:, input_token_len:], skip_special_tokens=True)[0]\n", "outputs = outputs.strip()\n", "if outputs.endswith(stop_str):\n", " outputs = outputs[: -len(stop_str)]\n", "print(f\"🚀 {model_name} with OpenVINO: {outputs.strip()}\\n\")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "a0eb76b8-24f7-4d55-ad32-0de282c2137d", "metadata": {}, "source": [ "## Interactive inference\n", "[back to top ⬆️](#Table-of-contents:)" ] }, { "cell_type": "code", "execution_count": null, "id": "9fe048d2-0bd4-4748-aaf5-af221e069333", "metadata": {}, "outputs": [], "source": [ "def generate(img, prompt):\n", " images_tensor = process_images([img], image_processor, transformers.AutoConfig.from_pretrained(MODELS_DIR))\n", " prompt = DEFAULT_IMAGE_TOKEN + \"\\n\" + prompt\n", " conv = conv_templates[\"v1\"].copy()\n", " conv.append_message(conv.roles[0], prompt)\n", " conv.append_message(conv.roles[1], None)\n", " prompt = conv.get_prompt()\n", " stop_str = conv.sep if conv.sep_style != SeparatorStyle.TWO else conv.sep2\n", " input_ids = tokenizer_image_token(prompt, tokenizer, IMAGE_TOKEN_INDEX, return_tensors=\"pt\").unsqueeze(0)\n", " stopping_criteria = KeywordsStoppingCriteria([stop_str], tokenizer, input_ids)\n", "\n", " output_ids = ov_model.generate(\n", " input_ids,\n", " images=images_tensor,\n", " do_sample=True if TEMPERATURE > 0 else False,\n", " temperature=TEMPERATURE,\n", " top_p=TOP_P,\n", " num_beams=NUM_BEAMS,\n", " max_new_tokens=MAX_NEW_TOKENS,\n", " use_cache=True,\n", " stopping_criteria=[stopping_criteria],\n", " )\n", " input_token_len = input_ids.shape[1]\n", " outputs = tokenizer.batch_decode(output_ids[:, input_token_len:], skip_special_tokens=True)[0]\n", " outputs = outputs.strip()\n", " if outputs.endswith(stop_str):\n", " outputs = outputs[: -len(stop_str)]\n", "\n", " return outputs.strip()\n", "\n", "\n", "demo = gr.Interface(\n", " generate,\n", " [gr.Image(label=\"Image\", type=\"pil\"), gr.Textbox(label=\"Prompt\")],\n", " gr.Textbox(),\n", " examples=[\n", " [\n", " str(IMAGE_PATH),\n", " PROMPT_STR,\n", " ]\n", " ],\n", " allow_flagging=\"never\",\n", ")\n", "\n", "try:\n", " demo.launch(debug=True)\n", "except Exception:\n", " demo.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/Meituan-AutoML/MobileVLM/raw/main/assets/mobilevlm_arch.png", "tags": { "categories": [ "Model Demos", "AI Trends" ], "libraries": [], "other": [], "tasks": [ "Image-to-Text", "Text Generation" ] } }, "widgets": { "application/vnd.jupyter.widget-state+json": { "state": {}, "version_major": 2, "version_minor": 0 } } }, "nbformat": 4, "nbformat_minor": 5 }