From 215fd7824a6fdc1299150f308c5cf0bdb4b01587 Mon Sep 17 00:00:00 2001 From: Jael Gu Date: Tue, 30 Jul 2024 22:22:22 +0800 Subject: [PATCH] Add multimodal rag notebook Signed-off-by: Jael Gu --- .../quickstart/cir_with_milvus.ipynb | 32 +- .../multimodal_rag_with_milvus.ipynb | 620 ++++++++++++++++++ 2 files changed, 645 insertions(+), 7 deletions(-) create mode 100644 bootcamp/tutorials/quickstart/multimodal_rag_with_milvus.ipynb diff --git a/bootcamp/tutorials/quickstart/cir_with_milvus.ipynb b/bootcamp/tutorials/quickstart/cir_with_milvus.ipynb index dfc55375f..a60a4098d 100644 --- a/bootcamp/tutorials/quickstart/cir_with_milvus.ipynb +++ b/bootcamp/tutorials/quickstart/cir_with_milvus.ipynb @@ -34,6 +34,13 @@ "!pip install --upgrade pymilvus openai datasets timm einops ftfy peft tqdm" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To enable the latest codes of Visualized BGE, we will download the official repository and then install with the source code." + ] + }, { "cell_type": "code", "execution_count": 2, @@ -57,8 +64,6 @@ "source": [ "### Download Data\n", "\n", - "In this tutorial, we will use \n", - "\n", "The following command will download the example data and extract to a local folder \"./images_folder\" including:\n", "\n", "- **amazon_fashion**: A subset of [Amazon Reviews 2023](https://github.com/hyp1231/AmazonReviews2023) as containing approximately 145 images from the category \"Amazon_Fashion\".\n", @@ -81,7 +86,7 @@ "source": [ "### Load Embedding Model\n", "\n", - "In this tutorial, we will use the Visualized BGE model \"bge-visualized-base-en-v1.5\" to generate embeddings for both images and text. \n", + "We will use the Visualized BGE model \"bge-visualized-base-en-v1.5\" to generate embeddings for both images and text. \n", "\n", "**1. Download weight**" ] @@ -139,7 +144,11 @@ "source": [ "## Load Data\n", "\n", - "### Generate embeddings" + "This section will load example images into the database with corresponding embeddings.\n", + "\n", + "### Generate embeddings\n", + "\n", + "Load all jpeg images from the data directory and apply the encoder to convert images to embeddings." ] }, { @@ -196,7 +205,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Insert into Milvus" + "### Insert into Milvus\n", + "\n", + "Insert images with corresponding paths and embeddings into Milvus collection.\n", + "\n", + "> As for the argument of `MilvusClient`:\n", + "> - Setting the `uri` as a local file, e.g. `./milvus_demo.db`, is the most convenient method, as it automatically utilizes [Milvus Lite](https://milvus.io/docs/milvus_lite.md) to store all data in this file.\n", + "> - If you have large scale of data, you can set up a more performant Milvus server on [docker or kubernetes](https://milvus.io/docs/quickstart.md). In this setup, please use the server uri, e.g.`http://localhost:19530`, as your `uri`.\n", + "> - If you want to use [Zilliz Cloud](https://zilliz.com/cloud), the fully managed cloud service for Milvus, adjust the `uri` and `token`, which correspond to the [Public Endpoint and Api key](https://docs.zilliz.com/docs/on-zilliz-cloud-console#free-cluster-details) in Zilliz Cloud." ] }, { @@ -248,7 +264,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Multimodal Search" + "## Multimodal Search\n", + "\n", + "Now we are ready to perform the advanced image search with query data composed of both image and text instruction." ] }, { @@ -260,7 +278,7 @@ "query_image = os.path.join(\n", " data_dir, \"clothes.jpg\"\n", ") # Change to your own query image path\n", - "query_text = \"black tops of this style\"\n", + "query_text = \"black tops of this style\" # Change to your own text instruction, or None\n", "\n", "# Generate query embedding given image and text instructions\n", "query_vec = encoder.encode_query(image_path=query_image, text=query_text)\n", diff --git a/bootcamp/tutorials/quickstart/multimodal_rag_with_milvus.ipynb b/bootcamp/tutorials/quickstart/multimodal_rag_with_milvus.ipynb new file mode 100644 index 000000000..8a108acb9 --- /dev/null +++ b/bootcamp/tutorials/quickstart/multimodal_rag_with_milvus.ipynb @@ -0,0 +1,620 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + 'Open In Colab' + ], + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": ["# Multimodal RAG with Milvus 🖼️"], + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This tutorial showcases the multimodal RAG powered by Milvus, [Visualized BGE model](https://github.com/FlagOpen/FlagEmbedding/tree/master/FlagEmbedding/visual), and [GPT-4o](https://openai.com/index/hello-gpt-4o/). With this system, users are able to upload an image and edit text instructions, which are processed by BGE's composed retrieval model to search for candidate images. GPT-4o then acts as a reranker, selecting the most suitable image and providing the rationale behind the choice. This powerful combination enables a seamless and intuitive image search experience, leveraging Milvus for efficient retrieval, BGE model for precise image processing and matching, and GPT-4o for advanced reranking." + ], + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": ["## Preparation\n", "\n", "### Install Dependencies"], + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install --upgrade pymilvus openai datasets opencv-python timm einops ftfy peft tqdm" + ], + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "!git clone https://github.com/FlagOpen/FlagEmbedding.git\n", + "!pip install -e FlagEmbedding", + ], + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + '> If you are using Google Colab, to enable dependencies just installed, you may need to **restart the runtime** (click on the "Runtime" menu at the top of the screen, and select "Restart session" from the dropdown menu).' + ], + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Download Data\n", + "\n", + 'The following command will download the example data and extract to a local folder "./images_folder" including:\n', + "\n", + '- **amazon_fashion**: A subset of [Amazon Reviews 2023](https://github.com/hyp1231/AmazonReviews2023) as containing approximately 145 images from the category "Amazon_Fashion".\n', + "- **clothes.jpg**: An example query image.", + ], + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "!wget https://github.com/milvus-io/bootcamp/releases/download/data/amazon_reviews_2023_subset.tar.gz\n", + "!tar -xzf amazon_reviews_2023_subset.tar.gz", + ], + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load Embedding Model\n", + "\n", + 'We will use the Visualized BGE model "bge-visualized-base-en-v1.5" to generate embeddings for both images and text. \n', + "\n", + "**1. Download weight**", + ], + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "!wget https://huggingface.co/BAAI/bge-visualized/resolve/main/Visualized_base_en_v1.5.pth" + ], + }, + {"cell_type": "markdown", "metadata": {}, "source": ["**2. Build encoder**"]}, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from FlagEmbedding.visual.modeling import Visualized_BGE\n", + "\n", + "\n", + "class Encoder:\n", + " def __init__(self, model_name: str, model_path: str):\n", + " self.model = Visualized_BGE(model_name_bge=model_name, model_weight=model_path)\n", + " self.model.eval()\n", + "\n", + " def encode_query(self, image_path: str, text: str) -> list[float]:\n", + " with torch.no_grad():\n", + " query_emb = self.model.encode(image=image_path, text=text)\n", + " return query_emb.tolist()[0]\n", + " \n", + " def encode_image(self, image_path: str) -> list[float]:\n", + " with torch.no_grad():\n", + " query_emb = self.model.encode(image=image_path)\n", + " return query_emb.tolist()[0]\n", + "\n", + "\n", + 'model_name = "BAAI/bge-base-en-v1.5"\n', + 'model_path = "./Visualized_base_en_v1.5.pth" # Change to your own value if using a different model path\n', + "encoder = Encoder(model_name, model_path)", + ], + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load Data\n", + "\n", + "This section will load example images into the database with corresponding embeddings.\n", + "\n", + "### Generate embeddings\n", + "\n", + "Load all jpeg images from the data directory and apply the encoder to convert images to embeddings.", + ], + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Generating image embeddings: 100%|██████████| 145/145 [00:03<00:00, 43.54it/s]" + ], + }, + { + "name": "stdout", + "output_type": "stream", + "text": ["Number of encoded images: 145\n"], + }, + {"name": "stderr", "output_type": "stream", "text": ["\n"]}, + ], + "source": [ + "import os\n", + "from tqdm import tqdm\n", + "from glob import glob\n", + "\n", + "\n", + "# Generate embeddings for the image dataset\n", + 'data_dir = "./images_folder" # Change to your own value if using a different data directory\n', + 'image_list = glob(os.path.join(data_dir, "amazon_fashion", "*.jpg")) # We will only use images ending with ".jpg"\n', + "image_dict = {}\n", + 'for image_path in tqdm(image_list, desc="Generating image embeddings: "):\n', + " try:\n", + " image_dict[image_path] = encoder.encode_image(image_path)\n", + " except Exception as e:\n", + ' print(f"Failed to generate embedding for {image_path}. Skipped.")\n', + " continue\n", + 'print("Number of encoded images:", len(image_dict))', + ], + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Insert into Milvus\n", + "\n", + "Insert images with corresponding paths and embeddings into Milvus collection.\n", + "\n", + "> As for the argument of `MilvusClient`:\n", + "> - Setting the `uri` as a local file, e.g. `./milvus_demo.db`, is the most convenient method, as it automatically utilizes [Milvus Lite](https://milvus.io/docs/milvus_lite.md) to store all data in this file.\n", + "> - If you have large scale of data, you can set up a more performant Milvus server on [docker or kubernetes](https://milvus.io/docs/quickstart.md). In this setup, please use the server uri, e.g.`http://localhost:19530`, as your `uri`.\n", + "> - If you want to use [Zilliz Cloud](https://zilliz.com/cloud), the fully managed cloud service for Milvus, adjust the `uri` and `token`, which correspond to the [Public Endpoint and Api key](https://docs.zilliz.com/docs/on-zilliz-cloud-console#free-cluster-details) in Zilliz Cloud.", + ], + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'insert_count': 145,\n", + " 'ids': [451503448502042624, 451503448502042625, ..., 451503448502042768],\n", + " 'cost': 0}", + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result", + } + ], + "source": [ + "from pymilvus import MilvusClient\n", + "\n", + "\n", + "dim = len(list(image_dict.values())[0])\n", + 'collection_name = "multimodal_rag_demo"\n', + "\n", + "# Connect to Milvus client given URI\n", + 'milvus_client = MilvusClient(uri="./milvus_demo.db")\n', + "\n", + "# Create Milvus Collection\n", + '# By default, vector field name is "vector"\n', + "milvus_client.create_collection(\n", + " collection_name=collection_name,\n", + " overwrite=True, # This will drop the old collection if exists\n", + " auto_id=True,\n", + " dimension=dim,\n", + " enable_dynamic_field=True\n", + ")\n", + "\n", + "# Insert data into collection\n", + "milvus_client.insert(\n", + " collection_name=collection_name,\n", + " data=[\n", + " {\n", + ' "image_path": k,\n', + ' "vector": v\n', + " } for k, v in image_dict.items()\n", + " ]\n", + ")", + ], + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Multimodal Search with Generative Reranker\n", + "\n", + "In this section, we will firstly search for relevant images by a multimodal query and then use LLM service to rerank the results and find the best one with explanation.\n", + "\n", + "### Run search\n", + "\n", + "Now we are ready to perform the advanced image search with query data composed of both image and text instruction.", + ], + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['./images_folder/amazon_fashion/41MVxQj+9YL._AC_.jpg', './images_folder/amazon_fashion/41gGwTCKeCL._AC_.jpg', './images_folder/amazon_fashion/41oJjy3dRwL._AC_.jpg', './images_folder/amazon_fashion/41TjExDA-RL._AC_.jpg', './images_folder/amazon_fashion/31YULz01TyL._AC_.jpg', './images_folder/amazon_fashion/41fVaN6RetL._AC_.jpg', './images_folder/amazon_fashion/51QnU31-8wL._AC_.jpg', './images_folder/amazon_fashion/51CqMDJOODL._AC_.jpg', './images_folder/amazon_fashion/41aHOvnSaZL._AC_.jpg']\n" + ], + } + ], + "source": [ + 'query_image = os.path.join(data_dir, "clothes.jpg") # Change to your own query image path\n', + 'query_text = "tops of this style"\n', + "\n", + "# Generate query embedding given image and text instructions\n", + "query_vec = encoder.encode_query(image_path=query_image, text=query_text)\n", + "\n", + "search_results = milvus_client.search(\n", + " collection_name=collection_name,\n", + " data=[query_vec],\n", + ' output_fields=["image_path"],\n', + " limit=9, # Max number of search results to return\n", + ' search_params={"metric_type": "COSINE", "params": {}}, # Search parameters\n', + ")[0]\n", + "\n", + 'retrieved_images = [hit.get("entity").get("image_path") for hit in search_results]\n', + "print(retrieved_images)", + ], + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Rerank with GPT-4o\n", + "\n", + "We will use an LLM to rank images and generate an explanation for the best result based on the user query and retrieved results.\n", + "\n", + "**1. Create a panoramic view**\n", + "\n", + "Combine the query image and retrieved images with indices in a panoramic view.", + ], + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import cv2\n", + "\n", + "img_height = 300\n", + "img_width = 300\n", + "row_count = 3\n", + "\n", + "def create_panoramic_view(query_image_path: str, retrieved_images: list) -> np.ndarray:\n", + ' """\n', + " \n", + "\n", + " args:\n", + " images: list of images to be combined\n", + "\n", + " returns:\n", + " np.ndarray: the panoramic view image\n", + ' """\n', + " panoramic_width = img_width * row_count\n", + " panoramic_height = img_height * row_count\n", + " panoramic_image = np.full(\n", + " (panoramic_height, panoramic_width, 3), 255, dtype=np.uint8\n", + " )\n", + "\n", + " # create and resize the query image with a blue border\n", + " query_image_null = np.full((panoramic_height, img_width, 3), 255, dtype=np.uint8)\n", + ' query_image = Image.open(query_image_path).convert("RGB")\n', + " query_array = np.array(query_image)[:, :, ::-1]\n", + " resized_image = cv2.resize(query_array, (img_width, img_height))\n", + "\n", + " border_size = 10\n", + " blue = (255, 0, 0) # blue color in BGR\n", + " bordered_query_image = cv2.copyMakeBorder(\n", + " resized_image,\n", + " border_size,\n", + " border_size,\n", + " border_size,\n", + " border_size,\n", + " cv2.BORDER_CONSTANT,\n", + " value=blue,\n", + " )\n", + "\n", + " query_image_null[img_height * 2 : img_height * 3, 0:img_width] = cv2.resize(\n", + " bordered_query_image, (img_width, img_height)\n", + " )\n", + "\n", + ' # add text "query" below the query image\n', + ' text = "query"\n', + " font_scale = 1\n", + " font_thickness = 2\n", + " text_org = (10, img_height * 3 + 30)\n", + " cv2.putText(\n", + " query_image_null,\n", + " text,\n", + " text_org,\n", + " cv2.FONT_HERSHEY_SIMPLEX,\n", + " font_scale,\n", + " blue,\n", + " font_thickness,\n", + " cv2.LINE_AA,\n", + " )\n", + "\n", + " # combine the rest of the images into the panoramic view\n", + ' retrieved_imgs = [np.array(Image.open(img).convert("RGB"))[:, :, ::-1] for img in retrieved_images]\n', + " for i, image in enumerate(retrieved_imgs):\n", + " image = cv2.resize(image, (img_width - 4, img_height - 4))\n", + " row = i // row_count\n", + " col = i % row_count\n", + " start_row = row * img_height\n", + " start_col = col * img_width\n", + "\n", + " border_size = 2\n", + " bordered_image = cv2.copyMakeBorder(\n", + " image,\n", + " border_size,\n", + " border_size,\n", + " border_size,\n", + " border_size,\n", + " cv2.BORDER_CONSTANT,\n", + " value=(0, 0, 0),\n", + " )\n", + " panoramic_image[\n", + " start_row : start_row + img_height, start_col : start_col + img_width\n", + " ] = bordered_image\n", + "\n", + " # add red index numbers to each image\n", + " text = str(i)\n", + " org = (start_col + 50, start_row + 30)\n", + " (font_width, font_height), baseline = cv2.getTextSize(\n", + " text, cv2.FONT_HERSHEY_SIMPLEX, 1, 2\n", + " )\n", + "\n", + " top_left = (org[0] - 48, start_row + 2)\n", + " bottom_right = (org[0] - 48 + font_width + 5, org[1] + baseline + 5)\n", + "\n", + " cv2.rectangle(\n", + " panoramic_image, top_left, bottom_right, (255, 255, 255), cv2.FILLED\n", + " )\n", + " cv2.putText(\n", + " panoramic_image,\n", + " text,\n", + " (start_col + 10, start_row + 30),\n", + " cv2.FONT_HERSHEY_SIMPLEX,\n", + " 1,\n", + " (0, 0, 255),\n", + " 2,\n", + " cv2.LINE_AA,\n", + " )\n", + "\n", + " # combine the query image with the panoramic view\n", + " panoramic_image = np.hstack([query_image_null, panoramic_image])\n", + " return panoramic_image", + ], + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": ["Let's take a preview of this combined image:"], + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [""], + }, + "metadata": {}, + "output_type": "display_data", + } + ], + "source": [ + "from PIL import Image\n", + "\n", + 'combined_image_path = os.path.join(data_dir, "combined_image.jpg")\n', + "panoramic_image = create_panoramic_view(query_image, retrieved_images)\n", + "cv2.imwrite(combined_image_path, panoramic_image)\n", + "\n", + "combined_image = Image.open(combined_image_path)\n", + "show_combined_image = combined_image.resize((300, 300))\n", + "show_combined_image.show()", + ], + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**2. Rerank and explain**\n", + "\n", + "We will send the combined image to multimodal LLM service together with proper prompts to rank the retrieved results with explanation. To enable GPT-4o as the LLM, you need to prepare your [OpenAI API Key](https://platform.openai.com/docs/quickstart).", + ], + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "import requests\n", + "import base64\n", + "\n", + 'openai_api_key = "sk-***" # Change to your OpenAI API Key\n', + "\n", + "def generate_ranking_explanation(\n", + " combined_image_path: str, caption: str, infos: dict=None) -> tuple[list[int], str]:\n", + ' with open(combined_image_path, "rb") as image_file:\n', + ' base64_image = base64.b64encode(image_file.read()).decode("utf-8")\n', + "\n", + " information = (\n", + ' "You are responsible for ranking results for a Composed Image Retrieval. "\n', + " \"The user retrieves an image with an 'instruction' indicating their retrieval intent. \"\n", + " \"For example, if the user queries a red car with the instruction 'change this car to blue,' a similar type of car in blue would be ranked higher in the results. \"\n", + ' "Now you would receive instruction and query image with blue border. Every item has its red index number in its top left. Do not misunderstand it. "\n', + ' f"User instruction: {caption} \\n\\n"\n', + " )\n", + "\n", + " # add additional information for each image\n", + " if infos:\n", + ' for i, info in enumerate(infos["product"]):\n', + ' information += f"{i}. {info}\\n"\n', + "\n", + " information += (\n", + ' "Provide a new ranked list of indices from most suitable to least suitable, followed by an explanation for the top 1 most suitable item only. "\n', + " \"The format of the response has to be 'Ranked list: []' with the indices in brackets as integers, followed by 'Reasons:' plus the explanation why this most fit user's query intent.\"\n", + " )\n", + "\n", + " headers = {\n", + ' "Content-Type": "application/json",\n', + ' "Authorization": f"Bearer {openai_api_key}",\n', + " }\n", + "\n", + " payload = {\n", + ' "model": "gpt-4o",\n', + ' "messages": [\n', + " {\n", + ' "role": "user",\n', + ' "content": [\n', + ' {"type": "text", "text": information},\n', + " {\n", + ' "type": "image_url",\n', + ' "image_url": {\n', + ' "url": f"data:image/jpeg;base64,{base64_image}"\n', + " },\n", + " },\n", + " ],\n", + " }\n", + " ],\n", + ' "max_tokens": 300,\n', + " }\n", + "\n", + " response = requests.post(\n", + ' "https://api.openai.com/v1/chat/completions", headers=headers, json=payload\n', + " )\n", + ' result = response.json()["choices"][0]["message"]["content"]\n', + "\n", + " # parse the ranked indices from the response\n", + ' start_idx = result.find("[")\n', + ' end_idx = result.find("]")\n', + ' ranked_indices_str = result[start_idx + 1 : end_idx].split(",")\n', + " ranked_indices = [int(index.strip()) for index in ranked_indices_str]\n", + "\n", + " # extract explanation\n", + " explanation = result[end_idx + 1 :].strip()\n", + "\n", + " return ranked_indices, explanation", + ], + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Get the image indices after ranking and the reason for the best result:" + ], + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "ranked_indices, explanation = generate_ranking_explanation(\n", + " combined_image_path, query_text)", + ], + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": ["**3. Display the best result with explanation**"], + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reasons: \n", + "The most suitable item is index 0, as it features a top that is very similar in style to the one in the query image. Both tops are crop tops with long sleeves and have a similar design, making it the closest match to the user's instruction.\n", + ], + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [""], + }, + "metadata": {}, + "output_type": "display_data", + }, + ], + "source": [ + "print(explanation)\n", + "\n", + "best_index = ranked_indices[0]\n", + "best_img = Image.open(retrieved_images[best_index])\n", + "best_img = best_img.resize((150, 150)) \n", + "best_img.show()", + ], + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Quick Deploy\n", + "\n", + "To learn about how to start an online demo with this tutorial, please refer to [the example application](https://github.com/milvus-io/bootcamp/tree/master/bootcamp/tutorials/quickstart/apps/multimodal_rag_with_milvus).\n", + "\n", + '', + ], + }, + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.14", + }, + }, + "nbformat": 4, + "nbformat_minor": 2, +}