diff --git a/.ci/ignore_treon_docker.txt b/.ci/ignore_treon_docker.txt index 509d7013110..7a74d813143 100644 --- a/.ci/ignore_treon_docker.txt +++ b/.ci/ignore_treon_docker.txt @@ -81,4 +81,5 @@ notebooks/sam2-image-segmentation/segment-anything-2-image.ipynb notebooks/pixtral/pixtral.ipynb notebooks/llm-agent-react/llm-agent-react.ipynb notebooks/multilora-image-generation/multilora-image-generation.ipynb -notebooks/llm-agent-react/llm-agent-react-langchain.ipynb \ No newline at end of file +notebooks/llm-agent-react/llm-agent-react-langchain.ipynb +notebooks/multimodal-rag/multimodal-rag-llamaindex.ipynb \ No newline at end of file diff --git a/.ci/skipped_notebooks.yml b/.ci/skipped_notebooks.yml index 80a8d2f1b3c..d8dc9d6b43f 100644 --- a/.ci/skipped_notebooks.yml +++ b/.ci/skipped_notebooks.yml @@ -559,6 +559,10 @@ - ubuntu-22.04 - windows-2019 - notebook: notebooks/glm-edge-v/glm-edge-v.ipynb + skips: + - os: + - macos-13 +- notebook: notebooks/multimodal-rag/multimodal-rag-llamaindex.ipynb skips: - os: - macos-13 \ No newline at end of file diff --git a/.ci/spellcheck/.pyspelling.wordlist.txt b/.ci/spellcheck/.pyspelling.wordlist.txt index 3aed0be9e46..08aafa75159 100644 --- a/.ci/spellcheck/.pyspelling.wordlist.txt +++ b/.ci/spellcheck/.pyspelling.wordlist.txt @@ -613,6 +613,7 @@ OpenVINO openvino OpenVino OpenVINO's +OpenVINOMultiModal openvoice OpenVoice OpenVoiceBaseClass @@ -996,6 +997,7 @@ VITS vitt VL vl +VLM VLModel VM Vladlen @@ -1042,6 +1044,7 @@ YOLOv yolov Youri youri +YouTube Zafrir ZavyChromaXL Zongyuan diff --git a/notebooks/multimodal-rag/README.md b/notebooks/multimodal-rag/README.md new file mode 100644 index 00000000000..dd0a636e882 --- /dev/null +++ b/notebooks/multimodal-rag/README.md @@ -0,0 +1,27 @@ +# Multimodal RAG for video analytics with LlamaIndex + +Constructing a RAG pipeline for text is relatively straightforward, thanks to the tools developed for parsing, indexing, and retrieving text data. However, adapting RAG models for video content presents a greater challenge. Videos combine visual, auditory, and textual elements, requiring more processing power and sophisticated video pipelines. + +To build a truly multimodal search for videos, you need to work with different modalities of a video like spoken content, visual. In this notebook, we showcase a Multimodal RAG pipeline designed for video analytics. It utilizes Whisper model to convert spoken content to text, CLIP model to generate multimodal embeddings, and Vision Language model (VLM) to process retrieved images and text messages. The following picture illustrates how this pipeline is working. + +![image](https://github.com/user-attachments/assets/a8ebf3fc-7a34-416b-b744-609965792744) + +## Notebook contents +The tutorial consists from following steps: + +- Install requirements +- Convert and Optimize model +- Download and process video +- Create the multi-modal index +- Search text and image embeddings +- Generate final response using VLM +- Launch Interactive demo + +In this demonstration, you'll create interactive Q&A system that can answer questions about provided video's content. + +## Installation instructions +This is a self-contained example that relies solely on its own code.
+We recommend running the notebook in a virtual environment. You only need a Jupyter server to start. +For details, please refer to [Installation Guide](../../README.md). + + diff --git a/notebooks/multimodal-rag/gradio_helper.py b/notebooks/multimodal-rag/gradio_helper.py new file mode 100644 index 00000000000..2ff4f9fbc4b --- /dev/null +++ b/notebooks/multimodal-rag/gradio_helper.py @@ -0,0 +1,129 @@ +from typing import Callable +import gradio as gr + +examples = [ + ["Tell me more about gaussian function"], + ["Explain the formula of gaussian function to me"], + ["What is the Herschel Maxwell derivation of a Gaussian ?"], +] + + +def clear_files(): + return "Vector Store is Not ready" + + +def handle_user_message(message, history): + """ + callback function for updating user messages in interface on submit button click + + Params: + message: current message + history: conversation history + Returns: + None + """ + # Append the user's message to the conversation history + return "", history + [[message, ""]] + + +def make_demo( + example_path: str, + build_index: Callable, + search: Callable, + run_fn: Callable, + stop_fn: Callable, +): + + with gr.Blocks( + theme=gr.themes.Soft(), + css=".disclaimer {font-variant-caps: all-small-caps;}", + ) as demo: + gr.Markdown("""

QA over Video

""") + gr.Markdown(f"""
Powered by OpenVINO
""") + image_list = gr.State([]) + txt_list = gr.State([]) + + with gr.Row(): + with gr.Column(scale=1): + video_file = gr.Video( + label="Step 1: Load a '.mp4' video file", + value=example_path, + ) + load_video = gr.Button("Step 2: Build Vector Store", variant="primary") + status = gr.Textbox( + "Vector Store is Ready", + show_label=False, + max_lines=1, + interactive=False, + ) + + with gr.Column(scale=3): + chatbot = gr.Chatbot( + height=800, + label="Step 3: Input Query", + ) + with gr.Row(): + with gr.Column(): + with gr.Row(): + msg = gr.Textbox( + label="QA Message Box", + placeholder="Chat Message Box", + show_label=False, + container=False, + ) + with gr.Column(): + with gr.Row(): + submit = gr.Button("Submit", variant="primary") + stop = gr.Button("Stop") + clear = gr.Button("Clear") + gr.Examples( + examples, + inputs=msg, + label="Click on any example and press the 'Submit' button", + ) + video_file.clear(clear_files, outputs=[status], queue=False).then(lambda: gr.Button(interactive=False), outputs=submit) + load_video.click(lambda: gr.Button(interactive=False), outputs=submit).then( + fn=build_index, + inputs=[video_file], + outputs=[status], + queue=True, + ).then(lambda: gr.Button(interactive=True), outputs=submit) + submit_event = ( + msg.submit(handle_user_message, [msg, chatbot], [msg, chatbot], queue=False) + .then( + search, + [chatbot], + [image_list, txt_list], + queue=True, + ) + .then( + run_fn, + [chatbot, image_list, txt_list], + chatbot, + queue=True, + ) + ) + submit_click_event = ( + submit.click(handle_user_message, [msg, chatbot], [msg, chatbot], queue=False) + .then( + search, + [chatbot], + [image_list, txt_list], + queue=True, + ) + .then( + run_fn, + [chatbot, image_list, txt_list], + chatbot, + queue=True, + ) + ) + stop.click( + fn=stop_fn, + inputs=None, + outputs=None, + cancels=[submit_event, submit_click_event], + queue=False, + ) + clear.click(lambda: None, None, chatbot, queue=False) + return demo diff --git a/notebooks/multimodal-rag/multimodal-rag-llamaindex.ipynb b/notebooks/multimodal-rag/multimodal-rag-llamaindex.ipynb new file mode 100644 index 00000000000..960881ca84c --- /dev/null +++ b/notebooks/multimodal-rag/multimodal-rag-llamaindex.ipynb @@ -0,0 +1,1092 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "id": "2d0db251-6c4d-423d-a580-d883efe0708c", + "metadata": {}, + "source": [ + "# Multimodal RAG for video analytics with LlamaIndex\n", + "\n", + "Constructing a RAG pipeline for text is relatively straightforward, thanks to the tools developed for parsing, indexing, and retrieving text data. However, adapting RAG models for video content presents a greater challenge. Videos combine visual, auditory, and textual elements, requiring more processing power and sophisticated video pipelines.\n", + "\n", + "To build a truly multimodal search for videos, you need to work with different modalities of a video like spoken content, visual. In this notebook, we showcase a Multimodal RAG pipeline designed for video analytics. It utilizes Whisper model to convert spoken content to text, CLIP model to generate multimodal embeddings, and Vision Language model (VLM) to process retrieved images and text messages. The following picture illustrates how this pipeline is working.\n", + "\n", + "![Multimodal RAG](https://github.com/user-attachments/assets/baef4914-5c07-432c-9363-1a0cb5944b09)\n", + "\n", + "#### Table of contents:\n", + "\n", + "- [Prerequisites](#Prerequisites)\n", + "- [Convert and Compress models](#Convert-and-Compress-models)\n", + " - [ASR model](#ASR-model)\n", + " - [CLIP model](#CLIP-model)\n", + " - [VLM model](#VLM-model)\n", + "- [Download and process video](#Download-and-process-video)\n", + " - [Initialize ASR](#Initialize-ASR)\n", + "- [Create the multi-modal index](#Create-the-multi-modal-index)\n", + " - [Initialize CLIP](#Initialize-CLIP)\n", + "- [Search text and image embeddings](#Search-text-and-image-embeddings)\n", + "- [Generate final response using VLM](#Generate-final-response-using-VLM)\n", + " - [Set the RAG prompt template](#Set-the-RAG-prompt-template)\n", + " - [Initialize VLM](#Initialize-VLM)\n", + "- [Interactive Demo](#Interactive-Demo)\n", + "\n", + "### Installation Instructions\n", + "\n", + "This is a self-contained example that relies solely on its own code.\n", + "\n", + "We recommend running the notebook in a virtual environment. You only need a Jupyter server to start.\n", + "For details, please refer to [Installation Guide](https://github.com/openvinotoolkit/openvino_notebooks/blob/latest/README.md#-installation-guide).\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "e4d85cc2-6b0a-458c-9332-84a70f54ce86", + "metadata": {}, + "source": [ + "## Prerequisites\n", + "\n", + "[back to top ⬆️](#Table-of-contents:)\n", + "\n", + "install required packages and setup helper functions." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ad6c48df", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "%pip uninstall -q -y \"moviepy\" \"decorator\"\n", + "\n", + "%pip install -q \"llama-index-core\" \"llama-index-embeddings-openvino>=0.4.1\" \"llama-index-multi-modal-llms-openvino\" \"llama-index-readers-file\" \\\n", + " \"llama-index-vector-stores-qdrant\" \\\n", + " \"transformers>=4.45\" \\\n", + " \"moviepy>=2.1.1\" \\\n", + " \"librosa\" \\\n", + " \"python-ffmpeg<=1.0.16\" \\\n", + " \"open_clip_torch\" \\\n", + " \"huggingface_hub\" \\\n", + " \"gradio>=4.44.1\" --extra-index-url https://download.pytorch.org/whl/cpu" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f24c553d-8c4c-40dd-86e4-313b99f928d0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "%pip install -q \"git+https://github.com/huggingface/optimum-intel.git\" \"openvino>=2024.5.0\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "2c61cb01-9c46-46e3-bf22-20c4ca0da417", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import requests\n", + "from pathlib import Path\n", + "\n", + "os.environ[\"GIT_CLONE_PROTECTION_ACTIVE\"] = \"false\"\n", + "\n", + "if not Path(\"notebook_utils.py\").exists():\n", + " r = requests.get(url=\"https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/latest/utils/notebook_utils.py\")\n", + " open(\"notebook_utils.py\", \"w\", encoding=\"utf-8\").write(r.text)\n", + "\n", + "if not Path(\"cmd_helper.py\").exists():\n", + " r = requests.get(url=\"https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/latest/utils/cmd_helper.py\")\n", + " open(\"cmd_helper.py\", \"w\", encoding=\"utf-8\").write(r.text)" + ] + }, + { + "cell_type": "markdown", + "id": "498b50cd-6b8f-4377-8705-1522af8de31a", + "metadata": {}, + "source": [ + "## Convert and Compress models\n", + "\n", + "[back to top ⬆️](#Table-of-contents:)\n", + "\n", + "### ASR model\n", + "\n", + "[back to top ⬆️](#Table-of-contents:)\n", + "\n", + "In this example, we utilize [Distil-Whisper](https://huggingface.co/distil-whisper/distil-large-v2) to recognize the spoken content in video and generate text. Distil-Whisper is a distilled variant of the [Whisper](https://huggingface.co/openai/whisper-large-v2) model by OpenAI. The Distil-Whisper is proposed in the paper [Robust Knowledge Distillation via Large-Scale Pseudo Labelling](https://arxiv.org/abs/2311.00430). According to authors, compared to Whisper, Distil-Whisper runs in several times faster with 50% fewer parameters, while performing to within 1% word error rate (WER) on out-of-distribution evaluation data.\n", + "For more information about Distil-Whisper, please refer [Distil-Whisper notebook](../distil-whisper-asr)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b4d0e724", + "metadata": {}, + "outputs": [], + "source": [ + "import huggingface_hub as hf_hub\n", + "\n", + "asr_model_id = \"OpenVINO/distil-whisper-large-v3-int8-ov\"\n", + "asr_model_path = asr_model_id.split(\"/\")[-1]\n", + "\n", + "if not Path(asr_model_path).exists():\n", + " hf_hub.snapshot_download(asr_model_id, local_dir=asr_model_path)" + ] + }, + { + "cell_type": "markdown", + "id": "45424e39-7854-448a-9ab1-33331c5016d7", + "metadata": {}, + "source": [ + "### CLIP model\n", + "\n", + "[back to top ⬆️](#Table-of-contents:)\n", + "\n", + "In this example, CLIP model will help to generate the embedding vectors for both text and images. CLIP (Contrastive Language-Image Pre-Training) is a neural network trained on various (image, text) pairs. It can be instructed in natural language to predict the most relevant text snippet, given an image, without directly optimizing for the task.\n", + "\n", + "CLIP uses a [ViT](https://arxiv.org/abs/2010.11929) like transformer to get visual features and a causal language model to get the text features. The text and visual features are then projected into a latent space with identical dimensions. The dot product between the projected image and text features is then used as a similarity score." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d2ea678c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/markdown": [ + "**Export command:**" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "`optimum-cli export openvino --model laion/CLIP-ViT-B-32-laion2B-s34B-b79K CLIP-ViT-B-32-laion2B-s34B-b79K`" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from cmd_helper import optimum_cli\n", + "\n", + "clip_model_id = \"laion/CLIP-ViT-B-32-laion2B-s34B-b79K\"\n", + "clip_model_path = clip_model_id.split(\"/\")[-1]\n", + "\n", + "if not Path(clip_model_path).exists():\n", + " optimum_cli(clip_model_id, clip_model_path)" + ] + }, + { + "cell_type": "markdown", + "id": "40053ea9-fb8c-4a03-af08-f4b7ac4b9e95", + "metadata": {}, + "source": [ + "### VLM model\n", + "\n", + "[back to top ⬆️](#Table-of-contents:)\n", + "\n", + "Vision Language model (VLM) is used to generate final response regrading the context of images and texts retrieved from vector DB. It can help to understand the both language and image instructions to complete various real-world tasks. In this example, we select [Phi-3.5-Vision](https://huggingface.co/microsoft/Phi-3.5-vision-instruct) as VLM.\n", + "\n", + "The Phi-3-Vision is a lightweight, state-of-the-art open multimodal model built upon datasets which include - synthetic data and filtered publicly available websites - with a focus on very high-quality, reasoning dense data both on text and vision. The model belongs to the Phi-3 model family, and the multimodal version comes with 128K context length (in tokens) it can support. The model underwent a rigorous enhancement process, incorporating both supervised fine-tuning and direct preference optimization to ensure precise instruction adherence and robust safety measures. More details about model can be found in [model blog post](https://azure.microsoft.com/en-us/blog/new-models-added-to-the-phi-3-family-available-on-microsoft-azure/), [technical report](https://aka.ms/phi3-tech-report), [Phi-3-cookbook](https://github.com/microsoft/Phi-3CookBook)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eedcf36c", + "metadata": {}, + "outputs": [], + "source": [ + "vlm_model_id = \"microsoft/Phi-3.5-vision-instruct\"\n", + "vlm_model_path = Path(vlm_model_id.split(\"/\")[-1]) / \"FP16\"\n", + "\n", + "if not vlm_model_path.exists():\n", + " !optimum-cli export openvino --model {vlm_model_id} --weight-format fp16 {vlm_model_path} --trust-remote-code" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "43d7f303", + "metadata": {}, + "outputs": [], + "source": [ + "import shutil\n", + "import nncf\n", + "import openvino as ov\n", + "import gc\n", + "\n", + "core = ov.Core()\n", + "\n", + "compression_config = {\n", + " \"mode\": nncf.CompressWeightsMode.INT4_SYM,\n", + " \"group_size\": 64,\n", + " \"ratio\": 0.6,\n", + "}\n", + "\n", + "compressed_model_path = vlm_model_path.parent / \"INT4\"\n", + "if not compressed_model_path.exists():\n", + " ov_model = core.read_model(vlm_model_path / \"openvino_language_model.xml\")\n", + " compressed_ov_model = nncf.compress_weights(ov_model, **compression_config)\n", + " ov.save_model(\n", + " compressed_ov_model,\n", + " compressed_model_path / \"openvino_language_model.xml\",\n", + " )\n", + " del compressed_ov_model\n", + " del ov_model\n", + " gc.collect()\n", + " for file_name in vlm_model_path.glob(\"*\"):\n", + " if file_name.name in [\n", + " \"openvino_language_model.xml\",\n", + " \"openvino_language_model.bin\",\n", + " ]:\n", + " continue\n", + " shutil.copy(file_name, compressed_model_path)" + ] + }, + { + "cell_type": "markdown", + "id": "b91b445b", + "metadata": {}, + "source": [ + "## Download and process video\n", + "\n", + "[back to top ⬆️](#Table-of-contents:)\n", + "\n", + "To begin, download an example video from YouTube and extract the audio and frame files from it." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "093464db-893e-4813-a6cc-19473a1a890c", + "metadata": {}, + "outputs": [], + "source": [ + "video_url = \"https://github.com/user-attachments/assets/2e38afa5-ce3e-448c-ad1a-0e9471039ff1\"\n", + "output_folder = \"./mixed_data/\"\n", + "output_audio_path = \"./mixed_data/output_audio.wav\"\n", + "filepath = \"video_data/input_vid.mp4\"\n", + "\n", + "example_path = Path(filepath)\n", + "example_path.parent.mkdir(parents=True, exist_ok=True)\n", + "Path(output_folder).mkdir(parents=True, exist_ok=True)\n", + "\n", + "r = requests.get(video_url)\n", + "with example_path.open(\"wb\") as f:\n", + " f.write(r.content)" + ] + }, + { + "cell_type": "markdown", + "id": "10d8f627", + "metadata": {}, + "source": [ + "### Initialize ASR\n", + "\n", + "[back to top ⬆️](#Table-of-contents:)\n", + "\n", + "Select inference device" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "b6636cd0", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2752228494b446279c7a5e6b686543ee", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Dropdown(description='Device:', index=2, options=('CPU', 'GPU', 'AUTO'), value='AUTO')" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from notebook_utils import device_widget\n", + "\n", + "asr_device = device_widget(default=\"AUTO\", exclude=[\"NPU\"])\n", + "\n", + "asr_device" + ] + }, + { + "cell_type": "markdown", + "id": "47f9b19a", + "metadata": {}, + "source": [ + "The Hugging Face Optimum API is a high-level API that enables us to convert and quantize models from the Hugging Face Transformers library to the OpenVINO™ IR format. For more details, refer to the [Hugging Face Optimum documentation](https://huggingface.co/docs/optimum/intel/inference).\n", + "\n", + "Optimum Intel can be used to load optimized models from the [Hugging Face Hub](https://huggingface.co/docs/optimum/intel/hf.co/models) and create pipelines to run an inference with OpenVINO Runtime using Hugging Face APIs. The Optimum Inference models are API compatible with Hugging Face Transformers models. This means we just need to replace the `AutoModelForXxx` class with the corresponding `OVModelForXxx` class." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "534c83b8-a8f4-499f-bfad-6799fdbabe8c", + "metadata": {}, + "outputs": [], + "source": [ + "from optimum.intel import OVModelForSpeechSeq2Seq\n", + "from transformers import AutoProcessor, pipeline\n", + "\n", + "asr_model = OVModelForSpeechSeq2Seq.from_pretrained(asr_model_path, device=asr_device.value)\n", + "asr_processor = AutoProcessor.from_pretrained(asr_model_path)\n", + "\n", + "pipe = pipeline(\"automatic-speech-recognition\", model=asr_model, tokenizer=asr_processor.tokenizer, feature_extractor=asr_processor.feature_extractor)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d300f17f-bf8d-4cc2-a61a-86fbb2529b3d", + "metadata": {}, + "outputs": [], + "source": [ + "import librosa\n", + "from moviepy.video.io.VideoFileClip import VideoFileClip\n", + "\n", + "\n", + "def video_to_images(video_path, output_folder):\n", + " \"\"\"\n", + " Convert a video to a sequence of images and save them to the output folder.\n", + "\n", + " Params:\n", + " video_path (str): The path to the video file.\n", + " output_folder (str): The path to the folder to save the images to.\n", + "\n", + " \"\"\"\n", + " clip = VideoFileClip(video_path)\n", + " clip.write_images_sequence(os.path.join(output_folder, \"frame%04d.png\"), fps=0.1)\n", + "\n", + "\n", + "def video_to_audio(video_path, output_audio_path):\n", + " \"\"\"\n", + " Convert a video to audio and save it to the output path.\n", + "\n", + " Params:\n", + " video_path (str): The path to the video file.\n", + " output_audio_path (str): The path to save the audio to.\n", + "\n", + " \"\"\"\n", + " clip = VideoFileClip(video_path)\n", + " audio = clip.audio\n", + " audio.write_audiofile(output_audio_path)\n", + "\n", + "\n", + "def audio_to_text(audio_path):\n", + " \"\"\"\n", + " Convert audio to text using the SpeechRecognition library.\n", + "\n", + " Params:\n", + " audio_path (str): The path to the audio file.\n", + "\n", + " Returns:\n", + " test (str): The text recognized from the audio.\n", + "\n", + " \"\"\"\n", + " en_raw_speech, samplerate = librosa.load(audio_path, sr=16000)\n", + " result = pipe(en_raw_speech, return_timestamps=True)\n", + "\n", + " return result[\"text\"]" + ] + }, + { + "cell_type": "markdown", + "id": "62b1e544", + "metadata": {}, + "source": [ + "In this step, we will extract the images and audio from video, then convert its audio into text." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8f45641a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Moviepy - Writing frames ./mixed_data/frame%04d.png.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Moviepy - Done writing frames ./mixed_data/frame%04d.png.\n", + "MoviePy - Writing audio in ./mixed_data/output_audio.wav\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MoviePy - Done.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "You have passed task=transcribe, but also have set `forced_decoder_ids` to [[1, None], [2, 50360]] which creates a conflict. `forced_decoder_ids` will be ignored in favor of task=transcribe.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Text data saved to file\n" + ] + } + ], + "source": [ + "try:\n", + " video_to_images(filepath, output_folder)\n", + " video_to_audio(filepath, output_audio_path)\n", + " text_data = audio_to_text(output_audio_path)\n", + "\n", + " with open(output_folder + \"output_text.txt\", \"w\") as file:\n", + " file.write(text_data)\n", + " print(\"Text data saved to file\")\n", + " file.close()\n", + " os.remove(output_audio_path)\n", + "\n", + "except Exception as e:\n", + " raise e" + ] + }, + { + "cell_type": "markdown", + "id": "e7ec33e4", + "metadata": {}, + "source": [ + "## Create the multi-modal index\n", + "\n", + "[back to top ⬆️](#Table-of-contents:)\n", + "\n", + "In this step, we are going to build multi-modal index and vector store to index both text and images. The CLIP model is used to generate the embedding vector for texts and images.\n", + "\n", + "\n", + "### Initialize CLIP\n", + "\n", + "[back to top ⬆️](#Table-of-contents:)\n", + "\n", + "Select inference device" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "effcfe0f", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "32ec80b4c0d2409686c34410d5e58cfc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Dropdown(description='Device:', index=2, options=('CPU', 'GPU', 'AUTO'), value='AUTO')" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "clip_device = device_widget(default=\"AUTO\", exclude=[\"NPU\"])\n", + "\n", + "clip_device" + ] + }, + { + "cell_type": "markdown", + "id": "b73a4746", + "metadata": {}, + "source": [ + "Class `OpenVINOClipEmbedding` in LlamaIndex can support exporting and loading open_clip models with OpenVINO runtime. for more information, please refer [Local Embeddings with OpenVINO](https://docs.llamaindex.ai/en/stable/examples/embeddings/openvino/#openclip-model-exporter)." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "c2e7d376-4348-4810-9e5a-8237964a2aa6", + "metadata": {}, + "outputs": [], + "source": [ + "from llama_index.embeddings.huggingface_openvino import OpenVINOClipEmbedding\n", + "\n", + "clip_model = OpenVINOClipEmbedding(model_id_or_path=clip_model_path, device=clip_device.value)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "f106c225-0742-4f79-a089-c0534f589d64", + "metadata": {}, + "outputs": [], + "source": [ + "from llama_index.core.indices import MultiModalVectorStoreIndex\n", + "from llama_index.vector_stores.qdrant import QdrantVectorStore\n", + "from llama_index.core import StorageContext, Settings\n", + "from llama_index.core.node_parser import SentenceSplitter\n", + "from llama_index.core import SimpleDirectoryReader\n", + "import qdrant_client\n", + "\n", + "# Create the MultiModal index\n", + "documents = SimpleDirectoryReader(output_folder).load_data()\n", + "\n", + "# Create a local Qdrant vector store\n", + "client = qdrant_client.QdrantClient(\":memory:\")\n", + "\n", + "text_store = QdrantVectorStore(client=client, collection_name=\"text_collection\")\n", + "image_store = QdrantVectorStore(client=client, collection_name=\"image_collection\")\n", + "storage_context = StorageContext.from_defaults(vector_store=text_store, image_store=image_store)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c74c3b59-3feb-449c-953c-f4d6ed522ca9", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:root:Payload indexes have no effect in the local Qdrant. Please use server Qdrant if you need payload indexes.\n", + "WARNING:root:Payload indexes have no effect in the local Qdrant. Please use server Qdrant if you need payload indexes.\n" + ] + } + ], + "source": [ + "Settings.embed_model = clip_model\n", + "\n", + "index = MultiModalVectorStoreIndex.from_documents(\n", + " documents, storage_context=storage_context, image_embed_model=Settings.embed_model, transformations=[SentenceSplitter(chunk_size=300, chunk_overlap=30)]\n", + ")\n", + "\n", + "retriever_engine = index.as_retriever(similarity_top_k=2, image_similarity_top_k=5)" + ] + }, + { + "cell_type": "markdown", + "id": "a64fd2cf", + "metadata": {}, + "source": [ + "## Search text and image embeddings\n", + "\n", + "[back to top ⬆️](#Table-of-contents:)\n", + "\n", + "To simply the prompt for VLM, we have to prepare the context of text and images regarding user's query. In this step, the most relevant context will be retrieved from vector DB through multi-modal index." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "0ef0ebc2-a8f0-4dc6-90b6-2988e0ee20f5", + "metadata": {}, + "outputs": [], + "source": [ + "from llama_index.core.response.notebook_utils import display_source_node\n", + "from llama_index.core.schema import ImageNode\n", + "from PIL import Image\n", + "import matplotlib.pyplot as plt\n", + "import os\n", + "\n", + "\n", + "def plot_images(image_paths):\n", + " images_shown = 0\n", + " plt.figure(figsize=(16, 9))\n", + " for img_path in image_paths:\n", + " if os.path.isfile(img_path):\n", + " image = Image.open(img_path)\n", + "\n", + " plt.subplot(2, 3, images_shown + 1)\n", + " plt.imshow(image)\n", + " plt.xticks([])\n", + " plt.yticks([])\n", + "\n", + " images_shown += 1\n", + " if images_shown >= 7:\n", + " break\n", + "\n", + "\n", + "def retrieve(retriever_engine, query_str):\n", + " retrieval_results = retriever_engine.retrieve(query_str)\n", + "\n", + " retrieved_image = []\n", + " retrieved_text = []\n", + " for res_node in retrieval_results:\n", + " if isinstance(res_node.node, ImageNode):\n", + " retrieved_image.append(res_node.node.metadata[\"file_path\"])\n", + " else:\n", + " display_source_node(res_node, source_length=200)\n", + " retrieved_text.append(res_node.text)\n", + "\n", + " return retrieved_image, retrieved_text" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "7fad6de8-fac4-4df9-a544-94179d52b625", + "metadata": {}, + "outputs": [ + { + "data": { + "text/markdown": [ + "**Node ID:** 72d9a990-ba98-4281-be50-42ef56254cad
**Similarity:** 0.6902350328083398
**Text:** The basic function underlying a normal distribution, aka a Gaussian, is E to the negative x squared. But you might wonder why this function? Of all the expressions we could dream up that give you s...
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/markdown": [ + "**Node ID:** 5989233f-c4dd-4394-802f-5b7d0fa1cacc
**Similarity:** 0.679477746185225
**Text:** I'd like to share an especially pleasing visual way that you can think about this calculation, which hopefully offers some sense of what makes the E to the negative x squared function special in th...
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[\"The basic function underlying a normal distribution, aka a Gaussian, is E to the negative x squared. But you might wonder why this function? Of all the expressions we could dream up that give you some symmetric smooth graph with mass concentrated towards the middle, why is it that the theory of probability seems to have a special place in its heart for this particular expression? For the last many videos I've been hinting at an answer to this question, and here we'll finally arrive at something like a satisfying answer. As a quick refresher on where we are, a couple videos ago we talked about the central limit theorem, which describes how as you add multiple copies of a random variable, for example rolling a weighted die many different times or letting a ball bounce off of a peg repeatedly, then the distribution describing that sum tends to look approximately like a normal distribution. What the central limit theorem says is as you make that sum bigger and bigger, under appropriate conditions, that approximation to a normal becomes better and better. But I never explained why this theorem is actually true. We only talked about what it's claiming. In the last video, we started talking about the math involved in adding two random variables. If you have two random variables each following some distribution, then to find the distribution describing the sum of those variables, you compute something known as a convolution between the two original functions. And we spent a lot of time building up two distinct ways to visualize what this convolution operation really is. really is. Today, our basic job is to work through a particular example, which is to ask, what happens when you add two normally distributed random variables, which, as you know by now, is the same as asking what do you get if you compute a convolution between two Gaussian functions?\", \"I'd like to share an especially pleasing visual way that you can think about this calculation, which hopefully offers some sense of what makes the E to the negative x squared function special in the first place. After we walk through it, we'll talk about how this calculation is one of the steps involved improving the central limit theorem. It's the step that answers the question of why a Gaussian and not something else is the central limit. But first, let's dive in. The full formula for a Gaussian is more complicated than just e to the negative x squared. The exponent is typically written as negative 1 half times x divided by sigma squared, where sigma describes the spread of the distribution, specifically the standard deviation. All of this needs to be multiplied by a fraction on the front, which is there to make sure that the area under the curve is one, making it a valid probability distribution, and if you want to consider distributions that aren't necessarily centered at zero, you would also throw another parameter mu into the exponent like this, although for everything we'll be doing here we just consider centered distributions. Now if you look at our central goal for today, which is to compute a convolution between two Gaussian functions, The direct way to do this would be to take the definition of a convolution, this integral expression we built up last video, and then to plug in for each one of the functions involved, the formula for a Gaussian. It's kind of a lot of symbols when you throw it all together, but more than anything, working this out, is an exercise in completing the square. And there's nothing wrong with that. That will get you the answer that you want.\"]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "query_str = \"tell me more about gaussian function\"\n", + "\n", + "img, txt = retrieve(retriever_engine=retriever_engine, query_str=query_str)\n", + "image_documents = SimpleDirectoryReader(input_dir=output_folder, input_files=img).load_data()\n", + "context_str = \"\".join(txt)\n", + "plot_images(img)\n", + "print(txt)" + ] + }, + { + "cell_type": "markdown", + "id": "1d1d68d6", + "metadata": {}, + "source": [ + "## Generate final response using VLM\n", + "\n", + "[back to top ⬆️](#Table-of-contents:)\n", + "\n", + "### Set the RAG prompt template\n", + "\n", + "[back to top ⬆️](#Table-of-contents:)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "bb3eec2b", + "metadata": {}, + "outputs": [], + "source": [ + "qa_tmpl_str = (\n", + " \"Given the provided information, including relevant images and retrieved context from the video, \\\n", + " accurately and precisely answer the query without any additional prior knowledge.\\n\"\n", + " \"Please ensure honesty and responsibility, refraining from any racist or sexist remarks.\\n\"\n", + " \"---------------------\\n\"\n", + " \"Context: {context_str}\\n\"\n", + " \"---------------------\\n\"\n", + " \"Query: {query_str}\\n\"\n", + " \"Answer: \"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "0105ee1b", + "metadata": {}, + "source": [ + "### Initialize VLM\n", + "\n", + "[back to top ⬆️](#Table-of-contents:)\n", + "\n", + "Select inference device" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "4737c584", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5982cfc89f8847cc91806a74c2d33628", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Dropdown(description='Device:', index=2, options=('CPU', 'GPU', 'AUTO'), value='AUTO')" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vlm_device = device_widget(default=\"AUTO\", exclude=[\"NPU\"])\n", + "\n", + "vlm_device" + ] + }, + { + "cell_type": "markdown", + "id": "344d6500", + "metadata": {}, + "source": [ + "`OpenVINOMultiModal` class provides convenient way for running multimodal model in LlamaIndex. It accepts directory with converted model and inference device as arguments. For running model with streaming we will use `stream_complete` method. For more information about the OpenVINO multimodal models support in LlamaIndex, refer to the [OpenVINOMultiModal Document](https://docs.llamaindex.ai/en/stable/examples/multi_modal/openvino_multimodal/)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d5866d53-7c5c-48da-b3e2-6f173509e9fd", + "metadata": {}, + "outputs": [], + "source": [ + "from transformers import AutoProcessor, AutoTokenizer\n", + "\n", + "vlm_int4_model_path = \"Phi-3.5-vision-instruct/INT4\"\n", + "\n", + "processor = AutoProcessor.from_pretrained(vlm_int4_model_path, trust_remote_code=True)\n", + "tokenizer = AutoTokenizer.from_pretrained(vlm_int4_model_path)\n", + "\n", + "\n", + "def messages_to_prompt(messages, image_documents):\n", + " \"\"\"\n", + " Prepares the input messages and images.\n", + " \"\"\"\n", + " images = []\n", + " placeholder = \"\"\n", + "\n", + " for i, img_doc in enumerate(image_documents, start=1):\n", + " images.append(Image.open(img_doc.image_path))\n", + " placeholder += f\"<|image_{i}|>\\n\"\n", + " conversation = [\n", + " {\"role\": \"user\", \"content\": placeholder + messages[0].content},\n", + " ]\n", + "\n", + " prompt = tokenizer.apply_chat_template(conversation, tokenize=False, add_generation_prompt=True)\n", + "\n", + " inputs = processor(prompt, images, return_tensors=\"pt\")\n", + " return inputs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "76af44a6-1bc8-4829-9605-bd8804c90c6a", + "metadata": {}, + "outputs": [], + "source": [ + "from llama_index.multi_modal_llms.openvino import OpenVINOMultiModal\n", + "\n", + "vlm = OpenVINOMultiModal(\n", + " model_id_or_path=vlm_int4_model_path,\n", + " device=vlm_device.value,\n", + " messages_to_prompt=messages_to_prompt,\n", + " trust_remote_code=True,\n", + " generate_kwargs={\"do_sample\": False, \"eos_token_id\": processor.tokenizer.eos_token_id},\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "56623614-0d44-49ac-bc9e-f8d87c659d7d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "A Gaussian function, also known as a normal distribution, is a type of probability distribution that is symmetric and bell-shaped. It is characterized by its mean and standard deviation, which determine the center and spread of the distribution, respectively. The Gaussian function is widely used in statistics and probability theory due to its unique properties and applications in various fields such as physics, engineering, and finance. The function is defined by the equation e to the negative x squared, where x represents the input variable. The graph of a Gaussian function is a smooth curve that approaches the x-axis as it moves away from the center, creating a bell-like shape. The function is also known for its property of being able to describe the distribution of random variables, making it a fundamental concept in probability theory and statistics." + ] + } + ], + "source": [ + "response = vlm.stream_complete(\n", + " prompt=qa_tmpl_str.format(context_str=context_str, query_str=query_str),\n", + " image_documents=image_documents,\n", + ")\n", + "for r in response:\n", + " print(r.delta, end=\"\")" + ] + }, + { + "cell_type": "markdown", + "id": "6c92517c", + "metadata": {}, + "source": [ + "## Interactive Demo\n", + "[back to top ⬆️](#Table-of-contents:)\n", + "\n", + "Now, you can try to chat with model. Upload video, provide your text message into `Input` field and click `Submit` to start communication." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "32e7d202", + "metadata": {}, + "outputs": [], + "source": [ + "import gradio as gr\n", + "import base64\n", + "\n", + "\n", + "def path2base64(path):\n", + " with open(path, \"rb\") as f:\n", + " byte_data = f.read()\n", + " base64_str = base64.b64encode(byte_data).decode(\"ascii\")\n", + " return base64_str\n", + "\n", + "\n", + "def build_index(video_path):\n", + " \"\"\"\n", + " callback function for building index of vector store\n", + "\n", + " Params:\n", + " video_path: path of uploaded video file\n", + " Returns:\n", + " vector store is ready\n", + "\n", + " \"\"\"\n", + "\n", + " global retriever_engine\n", + " progress = gr.Progress()\n", + " progress(None, desc=\"Video to Images...\")\n", + " video_to_images(video_path, output_folder)\n", + " progress(None, desc=\"Video to Audio...\")\n", + " video_to_audio(video_path, output_audio_path)\n", + " progress(None, desc=\"Audio to Texts...\")\n", + " text_data = audio_to_text(output_audio_path)\n", + "\n", + " with open(output_folder + \"output_text.txt\", \"w\") as file:\n", + " file.write(text_data)\n", + " print(\"Text data saved to file\")\n", + " file.close()\n", + " os.remove(output_audio_path)\n", + "\n", + " progress(0, desc=\"Building Index...\")\n", + " documents = SimpleDirectoryReader(output_folder).load_data()\n", + " client = qdrant_client.QdrantClient(\":memory:\")\n", + "\n", + " text_store = QdrantVectorStore(client=client, collection_name=\"text_collection\")\n", + " image_store = QdrantVectorStore(client=client, collection_name=\"image_collection\")\n", + " storage_context = StorageContext.from_defaults(vector_store=text_store, image_store=image_store)\n", + " index = MultiModalVectorStoreIndex.from_documents(\n", + " documents, storage_context=storage_context, image_embed_model=Settings.embed_model, transformations=[SentenceSplitter(chunk_size=300, chunk_overlap=30)]\n", + " )\n", + "\n", + " retriever_engine = index.as_retriever(similarity_top_k=2, image_similarity_top_k=5)\n", + " return \"Vector Store is Ready\"\n", + "\n", + "\n", + "def search(history):\n", + " \"\"\"\n", + " callback function for searching vector store\n", + "\n", + " Params:\n", + " history: conversation history\n", + " Returns:\n", + " lists of retrieved images and texts\n", + "\n", + " \"\"\"\n", + " progress = gr.Progress()\n", + " progress(None, desc=\"Searching...\")\n", + " img, txt = retrieve(retriever_engine=retriever_engine, query_str=history[-1][0])\n", + " return img, txt\n", + "\n", + "\n", + "def generate(history, images, texts):\n", + " \"\"\"\n", + " callback function for running chatbot on submit button click\n", + "\n", + " Params:\n", + " history: conversation history\n", + " images: list of retrieved images\n", + " texts: list of retrieved texts\n", + "\n", + " \"\"\"\n", + " progress = gr.Progress()\n", + " progress(None, desc=\"Generating...\")\n", + " image_documents = SimpleDirectoryReader(input_dir=output_folder, input_files=images).load_data()\n", + "\n", + " context_str = \"\".join(texts)\n", + "\n", + " response = vlm.stream_complete(\n", + " prompt=qa_tmpl_str.format(context_str=context_str, query_str=history[-1][0]),\n", + " image_documents=image_documents,\n", + " )\n", + " images_list = \"\"\n", + " for image in images:\n", + " image_base64 = path2base64(image)\n", + " images_list += f''\n", + " images_list += \"\\n\"\n", + " partial_text = \"According to audio and following screenshots from the video: \\n\"\n", + " partial_text += images_list\n", + " for r in response:\n", + " partial_text += r.delta\n", + " history[-1][1] = partial_text\n", + " yield history\n", + "\n", + "\n", + "def stop():\n", + " vlm._model.request.cancel()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d3cb1cef", + "metadata": {}, + "outputs": [], + "source": [ + "if not Path(\"gradio_helper.py\").exists():\n", + " r = requests.get(url=\"https://raw.githubusercontent.com/openvinotoolkit/openvino_notebooks/latest/notebooks/multimodal-rag/gradio_helper.py\")\n", + " open(\"gradio_helper.py\", \"w\").write(r.text)\n", + "\n", + "from gradio_helper import make_demo\n", + "\n", + "demo = make_demo(filepath, build_index, search, generate, stop)\n", + "\n", + "try:\n", + " demo.queue().launch()\n", + "except Exception:\n", + " demo.queue().launch(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.10.7" + }, + "openvino_notebooks": { + "imageUrl": "https://github.com/user-attachments/assets/fb3ec06f-e4b0-4ca3-aac6-71465ae14808", + "tags": { + "categories": [ + "Model Demos", + "AI Trends" + ], + "libraries": [], + "other": [], + "tasks": [ + "Visual Question Answering", + "Video-to-Text" + ] + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}