From 4ce397e7eff934f0d270106e400bec094fc8b331 Mon Sep 17 00:00:00 2001 From: Christy Bergman Date: Mon, 1 Jul 2024 14:46:14 -0700 Subject: [PATCH] Update basic RAG chunking and eval notebook (#1367) Signed-off-by: Christy Bergman --- .../dbta_may_2024/1. RAG_basic.ipynb | 2710 +++++++++-------- 1 file changed, 1504 insertions(+), 1206 deletions(-) diff --git a/bootcamp/workshops/dbta_may_2024/1. RAG_basic.ipynb b/bootcamp/workshops/dbta_may_2024/1. RAG_basic.ipynb index 8ac782058..229fcdda1 100644 --- a/bootcamp/workshops/dbta_may_2024/1. RAG_basic.ipynb +++ b/bootcamp/workshops/dbta_may_2024/1. RAG_basic.ipynb @@ -50,99 +50,121 @@ "# Import common libraries.\n", "import sys, os, time, pprint\n", "\n", - "# Import custom functions for splitting and search.\n", - "sys.path.append(\"../..\") # Adds higher directory to python modules path.\n", - "import milvus_utilities as _utils" - ] - }, - { - "cell_type": "markdown", - "id": "e059b674", - "metadata": {}, - "source": [ - "## Download Data\n", + "# # Import custom functions for splitting and search.\n", + "# sys.path.append(\"../..\") # Adds higher directory to python modules path.\n", + "# import milvus_utilities as _utils\n", "\n", - "The data used in this notebook is Milvus documentation web pages.\n", + "import grpc\n", + "from concurrent.futures import ThreadPoolExecutor\n", "\n", - "The code block below downloads all the web pages into a local directory called `rtdocs`. \n", + "# Server side.\n", + "server = grpc.server(ThreadPoolExecutor(max_workers=10),\n", + " options=[('grpc.max_receive_message_length', 50 * 1024 * 1024)]) # 50 MB\n", "\n", - "I've already uploaded the `rtdocs` data folder to github, so you should see it if you cloned my repo." + "# Client side.\n", + "channel = grpc.insecure_channel('localhost:50051',\n", + " options=[('grpc.max_send_message_length', 50 * 1024 * 1024)]) # 50 MB" ] }, { "cell_type": "code", "execution_count": 3, - "id": "25686cc7", + "id": "0cac5a60", "metadata": {}, "outputs": [], "source": [ - "# # UNCOMMENT TO DOWNLOAD THE DOCS.\n", + "# Function to remove newlines and double spaces from a string.\n", + "def clean_text(text):\n", + " clean_text = text.replace(\"\\n\\n\", \" \")\\\n", + " .replace(\"\\n\", \" \")\\\n", + " .replace(\"

\", \" \")\\\n", + " .replace(\"

\", \" \")\n", + " \n", + " # Remove extra whitespace.\n", + " clean_text = ' '.join(clean_text.split())\n", + " return clean_text\n", "\n", - "# # !pip install -U langchain\n", - "# from langchain_community.document_loaders import RecursiveUrlLoader\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", "\n", - "# DOCS_PAGE=\"https://milvus.io/docs/\"\n", + "# Function to inspect chunk lengths in matplotlit.\n", + "def plot_chunk_lengths(chunked_docs, title_keyword):\n", + " # Get chunk lengths.\n", + " lengths = [len(doc.page_content) for doc in chunked_docs]\n", "\n", - "# loader = RecursiveUrlLoader(DOCS_PAGE)\n", - "# docs = loader.load()\n", + " # Mean, median lengths.\n", + " mean_length = np.mean(lengths)\n", + " median_length = np.median(lengths)\n", "\n", - "# num_documents = len(docs)\n", - "# print(f\"loaded {num_documents} documents\")" + " # Assemble the title.\n", + " title = f\"Chunk Lengths from {title_keyword} Chunking\"\n", + "\n", + " # Plot the lengths.\n", + " plt.figure(figsize=(10, 6)) # Adjust figure size\n", + " plt.plot(lengths, marker='o') # Plot lengths with circle markers\n", + " plt.title(title, fontsize=20, fontweight='bold')\n", + " plt.xlabel('Document Index') # X-axis label\n", + " plt.ylabel('Length') # Y-axis label\n", + " plt.grid(True) # Show grid\n", + "\n", + " # Add a horizontal line at mean and median length\n", + " plt.axhline(y=mean_length, color='g', linestyle='-')\n", + " plt.axhline(y=median_length, color='r', linestyle='-')\n", + " plt.text(len(lengths)-1, mean_length, f'mean = {mean_length:.0f}', va='center', ha='left', backgroundcolor='w', fontsize=12)\n", + " plt.text(0, median_length, f'median = {median_length:.0f}', va='center', ha='right', backgroundcolor='w', fontsize=12)\n", + "\n", + " plt.show() # Display the plot" ] }, { - "cell_type": "code", - "execution_count": 4, - "id": "3b5d81f4", + "cell_type": "markdown", + "id": "e059b674", "metadata": {}, - "outputs": [], "source": [ - "# # Save Langchain docs to a local directory.\n", - "# OUTPUT_DIR = \"../../RAG/rtdocs_new/\"\n", - "# os.makedirs(OUTPUT_DIR, exist_ok=True)\n", + "## Download Data\n", "\n", - "# # Convert each doc to HTML and save to the specified directory\n", - "# for doc in docs:\n", - "# # Extract file name\n", - "# filename = doc.metadata['source'].split('/')[-1].replace(\".md\", \".html\")\n", - " \n", - "# # Check that filename is not empty\n", - "# if filename:\n", - "# with open(os.path.join(OUTPUT_DIR, filename), \"w\") as f:\n", - "# f.write(doc.page_content)\n", - "# else:\n", - "# print(\"Filename is empty. Skipping this doc.\")\n", - "# pprint.pprint(doc.metadata)\n", - "# pprint.pprint(doc.page_content[:500])" + "The data used in this notebook is Milvus documentation web pages.\n", + "\n", + "The code block below downloads all the web pages into a local directory called `rtdocs`. \n", + "\n", + "I've already uploaded the `rtdocs` data folder to github, so you should see it if you cloned my repo." ] }, { "cell_type": "code", - "execution_count": 5, - "id": "83b232dd", + "execution_count": 4, + "id": "25686cc7", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "loaded 22 documents\n", + "loaded 23 documents\n", "\n", "\n" ] + }, + { + "data": { + "text/plain": [ + "'Milvus vector database documentation\n", - "It can run in Jupyter notebooks, Colab, or locally. Requires pymilvus>=2.4.3.\n", + "# # Save Langchain docs to a local directory.\n", + "# OUTPUT_DIR = \"../../RAG/rtdocs_new/\"\n", + "# os.makedirs(OUTPUT_DIR, exist_ok=True)\n", "\n", - "⛔️ Milvus Lite is not meant for production workloads." + "# # Convert each doc to HTML and save to the specified directory\n", + "# for doc in docs:\n", + "# # Extract file name\n", + "# filename = doc.metadata['source'].split('/')[-1].replace(\".md\", \".html\")\n", + " \n", + "# # Check that filename is not empty\n", + "# if filename:\n", + "# with open(os.path.join(OUTPUT_DIR, filename), \"w\") as f:\n", + "# f.write(doc.page_content)\n", + "# else:\n", + "# print(\"Filename is empty. Skipping this doc.\")\n", + "# pprint.pprint(doc.metadata)\n", + "# pprint.pprint(doc.page_content[:500])" ] }, { - "cell_type": "code", - "execution_count": 6, - "id": "953bf30d", + "cell_type": "markdown", + "id": "f19236fe", "metadata": {}, - "outputs": [], "source": [ - "# !python -m pip install -U pymilvus" + "## Load the Embedding Model checkpoint and use it to create vector embeddings\n", + "\n", + "#### What are Embeddings?\n", + "\n", + "Check out [this blog](https://zilliz.com/glossary/vector-embeddings) for an introduction to embeddings. \n", + "\n", + "An excellent place to start is by selecting an embedding model from the [HuggingFace MTEB Leaderboard](https://huggingface.co/spaces/mteb/leaderboard), sorted descending by the \"Retrieval Average'' column since this task is most relevant to RAG. Then, choose the smallest, highest-ranking embedding model. But, Beware!! some models listed are overfit to the training data, so they won't perform on your data as promised. \n", + "\n", + "Milvus (and Zilliz) only supports tested embedding models that are **not overfit**!" ] }, { "cell_type": "code", - "execution_count": 7, - "id": "6fc289e8", + "execution_count": 6, + "id": "f043c02e", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/miniconda3/envs/py311-unum/lib/python3.11/site-packages/huggingface_hub/file_download.py:1132: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n", + " warnings.warn(\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "pymilvus:2.4.4\n" + "MODEL: BAAI/bge-large-en-v1.5, EMBEDDING_DIM: 1024\n" ] } ], "source": [ - "# STEP 1. CONNECT A CLIENT TO LIGHT MILVUS PYTHON SERVER.\n", - "\n", - "# !python -m pip install -U pymilvus\n", - "import pymilvus\n", - "print(f\"pymilvus:{pymilvus.__version__}\")\n", + "from langchain_huggingface import HuggingFaceEmbeddings\n", "\n", - "# Connect a client to the Milvus Lite server.\n", - "from pymilvus import MilvusClient\n", - "mc = MilvusClient(\"milvus_demo.db\")" + "# Use an embedding model.\n", + "model_name = \"BAAI/bge-large-en-v1.5\"\n", + "model_kwargs = {'device': 'cpu'}\n", + "encode_kwargs = {'normalize_embeddings': True}\n", + "embed_model = HuggingFaceEmbeddings(\n", + " model_name=model_name,\n", + " model_kwargs=model_kwargs,\n", + " encode_kwargs=encode_kwargs\n", + ")\n", + "EMBEDDING_DIM = embed_model.dict()['client'].get_sentence_embedding_dimension()\n", + "print(f\"MODEL: {model_name}, EMBEDDING_DIM: {EMBEDDING_DIM}\")" ] }, { - "cell_type": "markdown", - "id": "f9d758e4", + "cell_type": "code", + "execution_count": 7, + "id": "de45cdd4", "metadata": {}, + "outputs": [], "source": [ - "# Optional - Connect to Zilliz Cloud free tier cluster\n", - "To use fully-managed Milvus on [Ziliz Cloud free trial](https://cloud.zilliz.com/login). \n", - " 1. Choose the default \"Starter\" option and accept the default Cloud Provider and Region when you create a cluster. \n", - " 2. On the Cluster main page, copy your `API Key` and store it locally in a .env variable. See [this note](https://help.openai.com/en/articles/5112595-best-practices-for-api-key-safety) how to do that.\n", - " 3. Also on the Cluster main page, copy the `Public Endpoint URI` and store it somewhere convenient.\n", - " 4. Jupyter also requires them in a local .env file.
\n", - "Anywhere in the bootcamp directory, create a .env file\n", - "Insert lines like this, substituting your actual API keys for the sample text:
\n", - "ZILLIZ_API_KEY=f370c
\n", - "OPENAI_API_KEY=sk-H
\n", - "ANYSCALE_ENPOINT_KEY=es
\n", - "ANTHROPIC_API_KEY=sk-an
\n", - "VARIABLE_NAME=value
\n", - "Save the .env file
" + "# !python -m pip install --upgrade langchain_openai" ] }, { "cell_type": "code", "execution_count": 8, - "id": "0806d2db", + "id": "1fab8a0e", "metadata": {}, "outputs": [], "source": [ - "# # STEP 1. CONNECT TO ZILLIZ CLOUD\n", - "# import os\n", - "# import pymilvus\n", - "# print(f\"pymilvus version: {pymilvus.__version__}\")\n", - "# from pymilvus import connections, utility, MilvusClient\n", - "# TOKEN = os.getenv(\"ZILLIZ_API_KEY\")\n", - "\n", - "# # Connect to Zilliz cloud using endpoint URI and API key TOKEN.\n", - "# # TODO change this.\n", - "# CLUSTER_ENDPOINT=\"https://in03-xxxx.api.gcp-us-west1.zillizcloud.com:443\"\n", - "# CLUSTER_ENDPOINT=\"https://in03-48a5b11fae525c9.api.gcp-us-west1.zillizcloud.com:443\"\n", - "# connections.connect(\n", - "# alias='default',\n", - "# # Public endpoint obtained from Zilliz Cloud\n", - "# uri=CLUSTER_ENDPOINT,\n", - "# # API key or a colon-separated cluster username and password\n", - "# token=TOKEN,\n", - "# )\n", + "# from langchain_openai.embeddings import OpenAIEmbeddings\n", + "\n", + "# # 1. Get your API key: https://platform.openai.com/api-keys\n", + "# # 2. Save your api key in env variable.\n", + "# # https://help.openai.com/en/articles/5112595-best-practices-for-api-key-safety\n", "\n", - "# # Use no-schema Milvus client uses flexible json key:value format.\n", - "# # https://milvus.io/docs/using_milvusclient.md\n", - "# mc = MilvusClient(\n", - "# uri=CLUSTER_ENDPOINT,\n", - "# # API key or a colon-separated cluster username and password\n", - "# token=TOKEN)\n", + "# # 3. OpenAI embedding model name, `text-embedding-3-large` or `ext-embedding-3-small`.\n", + "# # release notes: https://openai.com/index/new-embedding-models-and-api-updates/\n", + "# model_name = \"text-embedding-3-small\"\n", + "# EMBEDDING_DIM = 512\n", "\n", - "# # Check if the server is ready and get colleciton name.\n", - "# print(f\"Type of server: {utility.get_server_version()}\")" + "# model_kwargs = {'device': 'cpu'}\n", + "# embed_model = OpenAIEmbeddings(\n", + "# model=model_name,\n", + "# dimensions=EMBEDDING_DIM,\n", + "# model_kwargs=model_kwargs\n", + "# )\n", + "# print(f\"MODEL: {model_name}, EMBEDDING_DIM: {EMBEDDING_DIM}\")" ] }, { "cell_type": "markdown", - "id": "103354dc", + "id": "0804d3ff", "metadata": {}, "source": [ - "## Optional - Start up Milvus running in local Docker\n", + "## HTML Chunking using LangChain\n", + "\n", + "Before embedding, it is necessary to decide your chunk strategy, chunk size, and chunk overlap. This section uses:\n", + "- **Strategy** = Use markdown header hierarchies. Keep markdown sections together unless they are too long.\n", + "- **Chunk size** = Use the embedding model's parameter `MAX_SEQ_LENGTH`\n", + "- **Overlap** = Rule-of-thumb 10-15%\n", + "- **Function** = \n", + " - Langchain's `HTMLHeaderTextSplitter` to split markdown sections.\n", + " - Langchain's `RecursiveCharacterTextSplitter` to split up long reviews recursively.\n", "\n", - ">⛔️ Make sure you pip install the correct version of pymilvus and server yml file. **Versions (major and minor) should all match**.\n", "\n", - "1. [Install Docker](https://docs.docker.com/get-docker/)\n", - "2. Start your Docker Desktop\n", - "3. Download the latest [docker-compose.yml](https://milvus.io/docs/install_standalone-docker.md#Download-the-YAML-file) (or run the wget command, replacing version to what you are using)\n", - "> wget https://github.com/milvus-io/milvus/releases/download/v2.4.0-rc.1/milvus-standalone-docker-compose.yml -O docker-compose.yml\n", - "4. From your terminal: \n", - " - cd into directory where you saved the .yml file (usualy same dir as this notebook)\n", - " - docker compose up -d\n", - " - verify (either in terminal or on Docker Desktop) the containers are running\n", - "5. From your code (see notebook code below):\n", - " - Import milvus\n", - " - Connect to the local milvus server" + "Notice below, each chunk is grounded with the document source page.
\n", + "In addition, header titles are kept together with the chunk of markdown text." ] }, { "cell_type": "code", "execution_count": 9, - "id": "9dd9b467", + "id": "a9b8a0da", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pattern for splitting: ]*)?>||]*)?/>\n", + "docs: 23, split into 23 html chunks.\n", + "DocsBlogCommunity Why Milvus What is MilvusUse Cases Tutorials CodelabsBootcampDemosVideo Tools AttuMilvus CLISizing ToolMilvus Backup Get Started Docs Tutorials Tools Blog Community Get Started Searc\n", + "{'h1': 'Welcome to Milvus Docs!', 'h2': 'Here you will learn about', 'h3': '', 'source': 'https://milvus.io/docs/', 'doc_index': '5a75d188-5760-42ed-908a-b9c35c6998a2'}\n" + ] + } + ], "source": [ - "# # CONNECT TO MILVUS STANDALONE DOCKER.\n", - "\n", - "# import pymilvus, time\n", - "# from pymilvus import (connections, MilvusClient, utility)\n", - "# print(f\"Pymilvus: {pymilvus.__version__}\")\n", + "# !python -m pip install lxml\n", + "from langchain.text_splitter import HTMLHeaderTextSplitter, RecursiveCharacterTextSplitter\n", + "import uuid, re\n", "\n", - "# # ####################################################################################################\n", - "# # # Connect to local server running in Docker container.\n", - "# # # Download the latest .yaml file: https://milvus.io/docs/install_standalone-docker.md\n", - "# # # Or, download directly from milvus github (replace with desired version):\n", - "# !wget https://github.com/milvus-io/milvus/releases/download/v2.4.4/milvus-standalone-docker-compose.yml -O docker-compose.yml\n", - "# # ####################################################################################################\n", + "doc_ids = [str(uuid.uuid4()) for _ in docs]\n", "\n", - "# # Start Milvus standalone on docker, running quietly in the background.\n", - "# !docker compose up -d\n", + "# Define the headers to split on for the HTMLHeaderTextSplitter\n", + "headers_to_split_on = [\n", + " (\"

\", \"Header 1\"),\n", + " (\"

\", \"Header 2\"),\n", + " (\"

\", \"Header 3\"),\n", + "]\n", + "# Create an instance of the HTMLHeaderTextSplitter\n", + "html_splitter = HTMLHeaderTextSplitter(headers_to_split_on=headers_to_split_on)\n", "\n", - "# # Verify which local port the Milvus server is listening on\n", - "# !docker ps -a #19530/tcp\n", + "# Construct a regex pattern to match any of the specified headers\n", + "pattern = '|'.join(re.escape(header[0]) for header in headers_to_split_on)\n", + "# More complex pattern to match opening, closing, and self-closing tags.\n", + "pattern = r\"]*)?>||]*)?/>\"\n", + "print(\"Pattern for splitting:\", pattern)\n", "\n", - "# # Connect to the local server.\n", - "# connection = connections.connect(\n", - "# alias=\"default\", \n", - "# host='localhost', # or '0.0.0.0' or 'localhost'\n", - "# port='19530'\n", - "# )\n", + "# Function to remove all HTML tags\n", + "def remove_html_tags(text):\n", + " return re.sub(r\"<[^>]+>\", \"\", text)\n", "\n", - "# # Get server version.\n", - "# print(utility.get_server_version())\n", + "# Split the HTML text using the HTMLHeaderTextSplitter.\n", + "html_docs = []\n", + "for doc_id, doc in zip(doc_ids, docs):\n", + "\n", + " # Grab the headers\n", + " new_text = doc.page_content\n", + " new_text = clean_text(new_text).replace('\\n', ' ')\n", + " html_split_list = re.split(pattern, new_text)\n", + " # print(html_split_list[0])\n", + " # Remove HTML tags from each extracted header text\n", + " html_split_list = [remove_html_tags(header) for header in html_split_list]\n", + " # print(html_split_list[0])\n", + " # print(f\"Split into {len(html_split_list)} parts.\")\n", + "\n", + " # Split the text into chunks using the HTMLHeaderTextSplitter.\n", + " splits = html_splitter.split_text(doc.page_content)\n", "\n", - "# # Use no-schema Milvus client uses flexible json key:value format.\n", - "# mc = MilvusClient(connections=connection)" - ] - }, - { - "cell_type": "markdown", - "id": "f39af3fd", - "metadata": {}, - "source": [ - "## Load the Embedding Model checkpoint and use it to create vector embeddings\n", + " for split in splits:\n", "\n", - "#### What are Embeddings?\n", + " # Clean the text.\n", + " split.page_content = clean_text(split.page_content)\n", "\n", - "Check out [this blog](https://zilliz.com/glossary/vector-embeddings) for an introduction to embeddings. \n", + " # Assemble the metadata.\n", + " metadata = {}\n", + " # Handle exception if h1 does not exist.\n", + " try:\n", + " header_value1 = html_split_list[1].strip()[:25]\n", + " metadata[\"h1\"] = header_value1\n", + " # print(f\"header_name: h1, header_value: {header_value1}\")\n", + " except:\n", + " break\n", + " # Handle exception if h2 does not exist.\n", + " try:\n", + " header_value2 = html_split_list[2].strip()[:25]\n", + " if len(header_value2) <= 0:\n", + " header_value2 = html_split_list[3].strip()[:25]\n", + " metadata[\"h2\"] = header_value2\n", + " # print(f\"header_name: h2, header_value: {header_value2}\")\n", + " except:\n", + " break\n", + " # Handle exception if h2 does not exist.\n", + " try:\n", + " header_value3 = html_split_list[3].strip()[:25]\n", + " if (len(header_value3) <= 0 or header_value3 == header_value2):\n", + " header_value3 = html_split_list[4].strip()[:25]\n", + " if header_value3 == header_value2:\n", + " header_value3 = html_split_list[5].strip()[:25]\n", + " metadata[\"h3\"] = header_value3\n", + " # print(f\"header_name: h3, header_value: {header_value3}\")\n", + " except:\n", + " break\n", + " split.metadata = {\n", + " **metadata,\n", + " \"source\": doc.metadata[\"source\"],\n", + " 'doc_index': doc_id\n", + " }\n", + " html_docs.extend(splits)\n", "\n", - "An excellent place to start is by selecting an embedding model from the [HuggingFace MTEB Leaderboard](https://huggingface.co/spaces/mteb/leaderboard), sorted descending by the \"Retrieval Average'' column since this task is most relevant to RAG. Then, choose the smallest, highest-ranking embedding model. But, Beware!! some models listed are overfit to the training data, so they won't perform on your data as promised. \n", + "print(f\"docs: {len(docs)}, split into {len(html_docs)} html chunks.\")\n", "\n", - "Milvus (and Zilliz) only supports tested embedding models that are **not overfit**!" + "# Inspect a chunk\n", + "print(html_docs[0].page_content[:200])\n", + "print(html_docs[0].metadata)" ] }, { "cell_type": "code", "execution_count": 10, - "id": "0a6c58ab", + "id": "2e3acd77", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DocsBlogCommunity Why Milvus What is MilvusUse Cases Tutorials CodelabsBootcampDemosVideo Tools AttuMilvus CLISizing ToolMilvus Backup Get Started Docs Tutorials Tools Blog Community Get Started Searc\n", + "{'h1': 'Hybrid Search', 'h2': 'Since Milvus 2.4, we intr', 'h3': 'Preparations', 'source': 'https://milvus.io/docs/multi-vector-search.md', 'doc_index': 'd86ecd0c-39d2-432d-ac1e-a856274804af'}\n" + ] + } + ], "source": [ - "# !python -m pip install -U sentence-transformers transformers" + "# Inspect another chunk\n", + "print(html_docs[20].page_content[:200])\n", + "print(html_docs[20].metadata)" ] }, { "cell_type": "code", "execution_count": 11, - "id": "1805f966", + "id": "961af854", "metadata": {}, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/miniconda3/envs/py311-unum/lib/python3.11/site-packages/huggingface_hub/file_download.py:1132: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n", - " warnings.warn(\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "model_name: BAAI/bge-large-en-v1.5\n", - "EMBEDDING_DIM: 1024\n", - "MAX_SEQ_LENGTH: 1536\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "# STEP 2. DOWNLOAD AN OPEN SOURCE EMBEDDING MODEL.\n", - "\n", - "# Import torch.\n", - "import torch\n", - "from sentence_transformers import SentenceTransformer\n", - "\n", - "# Initialize torch settings\n", - "torch.backends.cudnn.deterministic = True\n", - "DEVICE = torch.device('cuda:3' if torch.cuda.is_available() else 'cpu')\n", - "\n", - "# Load the model from huggingface model hub.\n", - "model_name = \"BAAI/bge-large-en-v1.5\"\n", - "# model_name = \"BAAI/bge-m3\"\n", - "encoder = SentenceTransformer(model_name, device=DEVICE)\n", - "# print(encoder)\n", - "\n", - "# Get the model parameters and save for later.\n", - "EMBEDDING_DIM = encoder.get_sentence_embedding_dimension()\n", - "MAX_SEQ_LENGTH_IN_TOKENS = encoder.get_max_seq_length() \n", - "# Assume tokens are 3 characters long.\n", - "MAX_SEQ_LENGTH = MAX_SEQ_LENGTH_IN_TOKENS * 3\n", - "EOS_TOKEN_LENGTH = 1 * 3\n", - "\n", - "# Inspect model parameters.\n", - "print(f\"model_name: {model_name}\")\n", - "print(f\"EMBEDDING_DIM: {EMBEDDING_DIM}\")\n", - "print(f\"MAX_SEQ_LENGTH: {MAX_SEQ_LENGTH}\")" + "# Inspect chunk lengths\n", + "plot_chunk_lengths(html_docs, 'HTML')" ] }, { "cell_type": "markdown", - "id": "9609497f", + "id": "1fa9700d", "metadata": {}, "source": [ - "## Create a Milvus collection\n", - "\n", - "You can think of a collection in Milvus like a \"table\" in SQL databases. The **collection** will contain the \n", - "- **Schema** (or [no-schema Milvus client](https://milvus.io/docs/using_milvusclient.md)). \n", - "💡 You'll need the vector `EMBEDDING_DIM` parameter from your embedding model.\n", - "Typical values are:\n", - " - 1024 for sbert embedding models\n", - " - 1536 for ada-002 OpenAI embedding models\n", - "- **Vector index** for efficient vector search\n", - "- **Vector distance metric** for measuring nearest neighbor vectors\n", - "- **Consistency level**\n", - "In Milvus, transactional consistency is possible; however, according to the [CAP theorem](https://en.wikipedia.org/wiki/CAP_theorem), some latency must be sacrificed. 💡 Searching movie reviews is not mission-critical, so [`eventually`](https://milvus.io/docs/consistency.md) consistent is fine here.\n", - "\n", - "## Add a Vector Index\n", - "\n", - "The vector index determines the vector **search algorithm** used to find the closest vectors in your data to the query a user submits. \n", + "## Small-to-Big using LangChain\n", "\n", - "Most vector indexes use different sets of parameters depending on whether the database is:\n", - "- **inserting vectors** (creation mode) - vs - \n", - "- **searching vectors** (search mode) \n", + "Often times it can be useful to retrieve larger chunks of information, but embed smaller chunks. This allows for embeddings to capture the semantic meaning as closely as possible, but for as much context as possible to be passed downstream. Note that this is what the ParentDocumentRetriever does. Here we show what is going on under the hood.\n", "\n", - "Scroll down the [docs page](https://milvus.io/docs/index.md) to see a table listing different vector indexes available on Milvus. For example:\n", - "- FLAT - deterministic exhaustive search\n", - "- IVF_FLAT or IVF_SQ8 - Hash index (stochastic approximate search)\n", - "- HNSW - Graph index (stochastic approximate search)\n", - "- AUTOINDEX - OSS or [Zilliz cloud](https://docs.zilliz.com/docs/autoindex-explained) automatic index based on type of GPU, size of data.\n", + "> - The vector store indexes and searches embeddings of the smallest (sub) documents. \n", + "> - The document store houses the \"parent\" documents and associates them with an identifier.\n", "\n", - "Besides a search algorithm, we also need to specify a **distance metric**, that is, a definition of what is considered \"close\" in vector space. In the cell below, the [`HNSW`](https://github.com/nmslib/hnswlib/blob/master/ALGO_PARAMS.md) search index is chosen. Its possible distance metrics are one of:\n", - "- L2 - L2-norm\n", - "- IP - Dot-product\n", - "- COSINE - Angular distance\n", - "\n", - "💡 Most use cases work better with normalized embeddings, in which case L2 is useless (every vector has length=1) and IP and COSINE are the same. Only choose L2 if you plan to keep your embeddings unnormalized." + "- See MultiVectorRetriever [api](https://api.python.langchain.com/en/latest/retrievers/langchain.retrievers.multi_vector.MultiVectorRetriever.html).\n", + "- See ParentDocumentRetriever [docs](https://python.langchain.com/v0.2/docs/how_to/multi_vector/#smaller-chunks) and [api](https://api.python.langchain.com/en/latest/retrievers/langchain.retrievers.parent_document_retriever.ParentDocumentRetriever.html)." ] }, { - "cell_type": "markdown", - "id": "42dff3b3", + "cell_type": "code", + "execution_count": 12, + "id": "19a45770", "metadata": {}, + "outputs": [], "source": [ - "### Exercise #1 (2 min):\n", - "Create a collection named \"movies\". Use the default AUTOINDEX.\n", - "> 💡 AUTOINDEX works on both Milvus and Zilliz Cloud (where it is the fastest!)" + "# !python -m pip install lxml\n", + "from langchain_milvus import Milvus\n", + "from langchain.text_splitter import RecursiveCharacterTextSplitter\n", + "import time, pprint, uuid\n", + "import numpy as np\n", + "from langchain.storage import InMemoryByteStore\n", + "from langchain.retrievers.multi_vector import MultiVectorRetriever\n", + "\n", + "# Create doc storage for the parent documents\n", + "store = InMemoryByteStore()\n", + "id_key = \"doc_id\"\n", + "\n", + "# Create vectorstore for vector index and retrieval.\n", + "COLLECTION_NAME = \"MilvusDocs\"\n", + "vectorstore = Milvus(\n", + " collection_name=COLLECTION_NAME,\n", + " embedding_function=embed_model,\n", + " connection_args={\"uri\": \"./milvus_demo.db\"},\n", + " auto_id=True,\n", + " # Set to True to drop the existing collection if it exists.\n", + " drop_old=True,\n", + ")\n", + "\n", + "# The MultiVectorRetriever (empty to start)\n", + "retriever = MultiVectorRetriever(\n", + " vectorstore=vectorstore,\n", + " byte_store=store,\n", + " id_key=id_key,\n", + ")" ] }, { "cell_type": "code", - "execution_count": 12, - "id": "e6197605", + "execution_count": 85, + "id": "2ffc217b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Successfully dropped collection: `MilvusDocs`\n", - "Successfully created collection: `MilvusDocs`\n" + "23 docs split into 3694 parent documents.\n", + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# # STEP 3. DOCKER OR ZILLIZ CLOUD: CREATE A NO-SCHEMA MILVUS COLLECTION AND DEFINE THE DATABASE INDEX.\n", - "\n", - "# # Set the Milvus collection name.\n", - "# COLLECTION_NAME = \"MilvusDocs\"\n", - "\n", - "# # Add custom HNSW search index to the collection.\n", - "# # M = max number graph connections per layer. Large M = denser graph.\n", - "# # Choice of M: 4~64, larger M for larger data and larger embedding lengths.\n", - "# M = 16\n", - "# # efConstruction = num_candidate_nearest_neighbors per layer. \n", - "# # Use Rule of thumb: int. 8~512, efConstruction = M * 2.\n", - "# efConstruction = M * 2\n", - "# # Create the search index for local Milvus server.\n", - "# INDEX_PARAMS = dict({\n", - "# 'M': M, \n", - "# \"efConstruction\": efConstruction })\n", - "# index_params = {\n", - "# \"index_type\": \"HNSW\", \n", - "# \"metric_type\": \"COSINE\", \n", - "# \"params\": INDEX_PARAMS\n", - "# }\n", - "\n", - "# # Check if collection already exists, if so drop it.\n", - "# has = utility.has_collection(COLLECTION_NAME)\n", - "# if has:\n", - "# drop_result = utility.drop_collection(COLLECTION_NAME)\n", - "# print(f\"Successfully dropped collection: `{COLLECTION_NAME}`\")\n", - "\n", - "# # Create the collection.\n", - "# mc.create_collection(\n", - "# COLLECTION_NAME, \n", - "# EMBEDDING_DIM,\n", - "# consistency_level=\"Eventually\", \n", - "# auto_id=True, \n", - "# overwrite=True,\n", - "# # skip setting params below, if using AUTOINDEX\n", - "# params=index_params\n", - "# )\n", - "# print(f\"Successfully created collection: `{COLLECTION_NAME}`\")" + "# Inspect chunk lengths\n", + "plot_chunk_lengths(parent_docs, 'Parent-HTML')" ] }, { "cell_type": "markdown", - "id": "3b2cac7c", + "id": "a3821b33", "metadata": {}, "source": [ - "## Simple Chunking\n", - "\n", - "Before embedding, it is necessary to decide your chunk strategy, chunk size, and chunk overlap. This section uses:\n", - "- **Strategy** = Simple fixed chunk lengths.\n", - "- **Chunk size** = Use the embedding model's parameter `MAX_SEQ_LENGTH`\n", - "- **Overlap** = Rule-of-thumb 10-15%\n", - "- **Function** = \n", - " - Langchain's `RecursiveCharacterTextSplitter` to split up long reviews recursively." + "## Small-to-big Chunking without HTML chunking" ] }, { - "cell_type": "markdown", - "id": "45c00e6e", + "cell_type": "code", + "execution_count": 86, + "id": "10770e5c", "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loaded 22 documents\n", + "\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "'Why Milvus\\n\\nDocs\\n\\nTutorials\\n\\nTools\\n\\nBlog\\n\\nCommunity\\n\\nStars0\\n\\nTry Managed Milvus FREE\\n\\nSearch\\n\\nHome\\n\\nv2.4.x\\n\\nAbout Milvus\\n\\nGet StartedPrerequisitesInstall MilvusInstall SDKsQuickstart\\n\\nConcepts\\n\\nUser Guide\\n\\nModels\\n\\nAdministration Guide\\n\\nTools\\n\\nIntegrations\\n\\nExample Applications\\n\\nFAQs\\n\\nAPI reference\\n\\nQuickstart\\n\\nThis guide explains how to connect to your Milvus cluster and performs CRUD operations in minutes\\n\\nBefore you start\\n\\nYou have installed Milvus standalone or Milvus cluster.\\n\\nYou have insta'" + ] + }, + "execution_count": 86, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "### Exercise #2 (2 min):\n", - "Change the chunk_size and see what happens? Model default is 1536.\n", + "# From raw docs\n", + "\n", + "# UNCOMMENT TO READ THE DOCS FROM A LOCAL DIRECTORY.\n", + "\n", + "# Read docs into LangChain\n", + "# !pip install -U langchain\n", + "# !pip install unstructured\n", + "from langchain.document_loaders import DirectoryLoader\n", + "\n", + "# Load HTML files from a local directory\n", + "path = \"../../RAG/rtdocs_new/\"\n", + "global_pattern = '*.html'\n", + "loader = DirectoryLoader(path=path, glob=global_pattern)\n", + "docs = loader.load()\n", + "\n", + "num_documents = len(docs)\n", + "print(f\"loaded {num_documents} documents\")\n", + "\n", + "# # Subset docs for faster testing\n", + "# docs = docs[5:7].copy()\n", + "# num_documents = len(docs)\n", + "# print(f\"testing with {num_documents} documents\")\n", "\n", - "- What do your observations imply about changing the chunk_size and the number of vectors?\n", - "- How many vectors are there with chunk_size=512?" + "# Print the type of the docs.\n", + "print(type(docs))\n", + "print(type(docs[0]))\n", + "\n", + "docs[0].page_content[:500]" ] }, { "cell_type": "code", - "execution_count": 14, - "id": "b1499b20", + "execution_count": 88, + "id": "7424f6ca", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "23 docs split into 130 parent documents.\n", + "Why Milvus Docs Tutorials Tools Blog Community Stars0 Try Managed Milvus FREE Search Home v2.4.x About Milvus Get StartedPrerequisitesInstall MilvusInstall SDKsQuickstart Concepts User Guide Models Ad\n", + "{'doc_index': 'd6cda686-b369-40de-9784-666ee6a5952e',\n", + " 'source': 'https://milvus.io/docs/quickstart.md'}\n" + ] + } + ], "source": [ - "# from langchain.text_splitter import RecursiveCharacterTextSplitter\n", - "# import numpy as np\n", - "# import pprint\n", - "\n", - "# ###############\n", - "# ## EXERCISE #2: Change chunk_size to 512 below. How many chunks (vectors) does this create?\n", - "# ## ANSWER: 427\n", - "# ## BONUS: Can you explain why the number of vectors changed from 134 to 427? \n", - "# ## Hint: What is the default chunk overlap? 134 * (3 + 0.10) approx. equals 804.\n", - "# ###############\n", - "# chunk_size = #(exercise): code here\n", - "# chunk_overlap = np.round(chunk_size * 0.10, 0)\n", - "# print(f\"chunk_size: {chunk_size}, chunk_overlap: {chunk_overlap}\")\n", - "\n", - "# # Create an instance of the RecursiveCharacterTextSplitter\n", - "# child_splitter = RecursiveCharacterTextSplitter(\n", - "# chunk_size = chunk_size,\n", - "# chunk_overlap = chunk_overlap,\n", - "# length_function = len, # using built-in Python len function\n", - "# )\n", + "# Parent docs directly from raw docs\n", + "parent_docs = parent_text_splitter.split_documents(docs)\n", + "doc_ids = [str(uuid.uuid4()) for _ in parent_docs]\n", + "\n", + "# Clean the parent docs.\n", + "for doc_id, doc in zip(doc_ids, parent_docs):\n", + " doc.page_content = clean_text(doc.page_content)\n", + " doc.metadata[\"source\"] = \\\n", + " doc.metadata[\"source\"]\\\n", + " .replace(\"../../RAG/rtdocs_new\", \"https://milvus.io/docs\")\\\n", + " .replace(\".html\", \".md\")\n", + " doc.metadata = {\n", + " **doc.metadata,\n", + " \"doc_index\": doc_id\n", + " }\n", "\n", - "# # Split the documents further into smaller, recursive chunks.\n", - "# chunks = child_splitter.split_documents(docs)\n", - "# print(f\"docs: {len(docs)}, split into: {len(chunks)}\")" + "print(f\"{len(html_docs)} docs split into {len(parent_docs)} parent documents.\")\n", + "# inspect a parent doc.\n", + "print(parent_docs[0].page_content[:200])\n", + "pprint.pprint(parent_docs[0].metadata)" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "id": "5062ca09", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Inspect chunk lengths\n", + "plot_chunk_lengths(parent_docs, 'Parent')" ] }, { "cell_type": "code", "execution_count": 15, - "id": "075a3022", + "id": "b9f3b559", "metadata": {}, "outputs": [ { @@ -613,486 +717,351 @@ "output_type": "stream", "text": [ "chunk_size: 512, chunk_overlap: 51.0\n", - "docs: 22, split into chunks: 427\n", - "type: list of \n", - "\n", - "Looking at a sample chunk...\n", - "('Why Milvus Docs Tutorials Tools Blog Community Stars0 Try Managed '\n", - " 'Milvus FREE Search Home ')\n", - "{'source': 'https://milvus.io/docs_new/quickstart.md'}\n" + "228 docs split into 873 child documents.\n" ] } ], "source": [ - "# STEP 4. PREPARE DATA: CHUNK AND EMBED\n", - "\n", - "# !python -m pip install lxml\n", - "from langchain.text_splitter import HTMLHeaderTextSplitter, RecursiveCharacterTextSplitter\n", - "import numpy as np\n", - "import pprint\n", - "\n", - "# Define chunk size and overlap 10% chunk_size.\n", "CHUNK_SIZE = 512\n", "chunk_overlap = np.round(CHUNK_SIZE * 0.10, 0)\n", "print(f\"chunk_size: {CHUNK_SIZE}, chunk_overlap: {chunk_overlap}\")\n", "\n", - "# Create an instance of the RecursiveCharacterTextSplitter\n", - "child_splitter = RecursiveCharacterTextSplitter(\n", - " chunk_size = CHUNK_SIZE,\n", - " chunk_overlap = chunk_overlap,\n", + "# The splitter to use to create smaller (child) chunks\n", + "child_text_splitter = RecursiveCharacterTextSplitter(\n", + " chunk_size=CHUNK_SIZE, \n", + " chunk_overlap=chunk_overlap,\n", " length_function = len, # use built-in Python len function\n", - " # separators=[\"\\n\\n\"],\n", + " # separators=[\"\\n\\n\"], # split at end of paragraphs\n", ")\n", "\n", - "# Split the documents further into smaller, recursive chunks.\n", - "smaller_chunks = child_splitter.split_documents(docs)\n", - "print(f\"docs: {len(docs)}, split into chunks: {len(smaller_chunks)}\")\n", - "print(f\"type: list of {type(smaller_chunks[0])}\") \n", - "\n", - "# Clean up newlines in the chunks.\n", - "for chunk in smaller_chunks:\n", - " chunk.page_content = chunk.page_content.replace(\"\\n\", \" \")\n", - " \n", - "# Clean up the metadata urls\n", - "for chunk in smaller_chunks:\n", - " new_url = chunk.metadata[\"source\"]\n", - " new_url = new_url.replace(\"../../RAG/rtdocs\", \"https://milvus.io/docs\")\n", - " new_url = new_url.replace(\".html\", \".md\")\n", - " chunk.metadata.update({\"source\": new_url})\n", - "\n", - "# Inspect a chunk.\n", - "print()\n", - "print(\"Looking at a sample chunk...\")\n", - "pprint.pprint(smaller_chunks[0].page_content[:100])\n", - "pprint.pprint(smaller_chunks[0].metadata)" - ] - }, - { - "cell_type": "markdown", - "id": "c60423a5", - "metadata": {}, - "source": [ - "## HTML Chunking\n", - "\n", - "Before embedding, it is necessary to decide your chunk strategy, chunk size, and chunk overlap. This section uses:\n", - "- **Strategy** = Use markdown header hierarchies. Keep markdown sections together unless they are too long.\n", - "- **Chunk size** = Use the embedding model's parameter `MAX_SEQ_LENGTH`\n", - "- **Overlap** = Rule-of-thumb 10-15%\n", - "- **Function** = \n", - " - Langchain's `HTMLHeaderTextSplitter` to split markdown sections.\n", - " - Langchain's `RecursiveCharacterTextSplitter` to split up long reviews recursively.\n", + "# Generate the \"sub\" documents by splitting the original documents. \n", + "# Store the doc_id in the metadata of the corresponding Document object.\n", + "sub_docs = []\n", + "for i, doc in enumerate(parent_docs):\n", + " _id = doc_ids[i]\n", + " _sub_docs = child_text_splitter.split_documents([doc])\n", + " for _doc in _sub_docs:\n", + " _doc.metadata[id_key] = _id\n", + " sub_docs.extend(_sub_docs)\n", "\n", + "# # Insert HTML headers into smaller chunks (extends their \"context\").\n", + "# for chunk in sub_docs:\n", + "# if chunk.page_content.startswith(chunk.metadata['h1'][:20]):\n", + "# continue\n", + "# metadata_str = ' '.join(str(v) for k, v in chunk.metadata.items() if k in ['h1', 'h2'])\n", + "# chunk.page_content = f'{metadata_str} {chunk.page_content}'\n", "\n", - "Notice below, each chunk is grounded with the document source page.
\n", - "In addition, header titles are kept together with the chunk of markdown text." + "print(f\"{len(parent_docs)} docs split into {len(sub_docs)} child documents.\")" ] }, { "cell_type": "code", "execution_count": 16, - "id": "5ab9cd1e", + "id": "6631ed2c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "chunk_size: 512, chunk_overlap: 51.0\n", - "docs: 22, split into parent chunks: 129\n", - "parent_chunks: 129, split into smaller chunks: 586\n", - "type: list of \n", - "\n", - "Looking at a sample chunk...\n", - "('immediately after data insertions may result in empty result set. To avoid '\n", - " 'this, you are advised to wait for a few seconds. Single-vector search The '\n", - " 'value of the query_vectors variable is a list conta')\n", - "{'doc_index': 0,\n", - " 'h1': 'Why Milvus Docs Tutorials Tools Blog Community Sta',\n", - " 'source': '../../RAG/rtdocs_new/quickstart.html'}\n" + "using PyMilvus. Added guidance on how to enable RBAC with Milvus Operator. Added descriptions of Milvus CDC. Introducing PyMilvus Integration with Embedding Models Engineering Made with Love by the De\n", + "{'doc_id': 'ab615aaf-af19-4b50-ac9d-8bbd1d1c6d51',\n", + " 'doc_index': '5a75d188-5760-42ed-908a-b9c35c6998a2',\n", + " 'h1': 'Welcome to Milvus Docs!',\n", + " 'h2': 'Here you will learn about',\n", + " 'h3': '',\n", + " 'source': 'https://milvus.io/docs/'}\n" ] } ], "source": [ - "# STEP 4. PREPARE DATA: CHUNK AND EMBED\n", - "\n", - "# !python -m pip install lxml\n", - "from langchain.text_splitter import HTMLHeaderTextSplitter, RecursiveCharacterTextSplitter\n", - "\n", - "# Define chunk size 512 and overlap 10% chunk_size.\n", - "# These will be ANN search vectors.\n", - "CHUNK_SIZE = 512\n", - "chunk_overlap = round(CHUNK_SIZE * 0.10, 0)\n", - "print(f\"chunk_size: {CHUNK_SIZE}, chunk_overlap: {chunk_overlap}\")\n", - "\n", - "# Define chunk size for \"larger\" chunks.\n", - "# These will be parent chunks retrieved to stuff in the Prompt.\n", - "PARENT_CHUNK_SIZE = MAX_SEQ_LENGTH #2000\n", - "\n", - "# Splitter is used to create the parent \"larger\" chunks.\n", - "parent_splitter = RecursiveCharacterTextSplitter(\n", - " chunk_size=PARENT_CHUNK_SIZE,\n", - " length_function = len,\n", - " # add_start_index=True\n", - " )\n", - "\n", - "# Splitter is used to create the child \"smaller\" chunks for ANN search.\n", - "child_splitter = RecursiveCharacterTextSplitter(\n", - " chunk_size = CHUNK_SIZE,\n", - " # chunk_overlap = chunk_overlap,\n", - " length_function = len,\n", - " add_start_index=True\n", - " )\n", - "\n", - "# Define the headers to split on for the HTMLHeaderTextSplitter\n", - "headers_to_split_on = [\n", - " (\"h1\", \"Header 1\"),\n", - " (\"h2\", \"Header 2\"),\n", - "]\n", - "# Create an instance of the HTMLHeaderTextSplitter\n", - "html_splitter = HTMLHeaderTextSplitter(headers_to_split_on=headers_to_split_on)\n", - "\n", - "# Split the HTML text using the HTMLHeaderTextSplitter.\n", - "html_header_splits = []\n", - "doc_index = 0\n", - "for doc in docs:\n", - " splits = html_splitter.split_text(doc.page_content)\n", - " for split in splits:\n", - " # Add the source URL and header values to the metadata\n", - " metadata = {}\n", - " new_text = split.page_content\n", - " for header_name, metadata_header_name in headers_to_split_on:\n", - " # Handle exception if h1 does not exist.\n", - " try:\n", - " header_value = new_text.split(\"¶ \")[0].strip()[:50]\n", - " metadata[header_name] = header_value\n", - " except:\n", - " break\n", - " # Handle exception if h2 does not exist.\n", - " try:\n", - " new_text = new_text.split(\"¶ \")[1].strip()[:50]\n", - " metadata[header_name] = new_text\n", - " except:\n", - " break\n", - " split.metadata = {\n", - " **metadata,\n", - " \"source\": doc.metadata[\"source\"],\n", - " 'doc_index': doc_index\n", - " }\n", - " html_header_splits.extend(splits)\n", - " doc_index += 1\n", - "\n", - "# Split the HTML chunks into parent chunks.\n", - "chunks = parent_splitter.split_documents(html_header_splits)\n", - "print(f\"docs: {len(docs)}, split into parent chunks: {len(chunks)}\")\n", - "\n", - "# Split HTML header chunks into smaller chunks for ANN search.\n", - "smaller_chunks = []\n", - "for chunk in chunks:\n", - " smaller_chunks.extend(child_splitter.split_documents([chunk]))\n", - "print(f\"parent_chunks: {len(chunks)}, split into smaller chunks: {len(smaller_chunks)}\")\n", - "print(f\"type: list of {type(smaller_chunks[0])}\") \n", - "\n", - "# Insert HTML headers into smaller chunks (extends their \"context\").\n", - "for chunk in smaller_chunks:\n", - " if chunk.page_content.startswith(chunk.metadata['h1'][:20]):\n", - " continue\n", - " metadata_str = ' '.join(str(v) for k, v in chunk.metadata.items() if k in ['h1', 'h2'])\n", - " chunk.page_content = f'{metadata_str} {chunk.page_content}'\n", - "\n", - "# Inspect a parent chunk.\n", - "print()\n", - "print(\"Looking at a sample chunk...\")\n", - "pprint.pprint(chunks[4].page_content[:200])\n", - "pprint.pprint(chunks[4].metadata)" + "# Inspect a sub_doc.\n", + "print(sub_docs[4].page_content[:200])\n", + "pprint.pprint(sub_docs[4].metadata)" ] }, { "cell_type": "code", "execution_count": 17, - "id": "bf206547", + "id": "4c8801a0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Inspect chunk lengths\n", + "plot_chunk_lengths(sub_docs, 'Small-to-big')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "68fd9dcb", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\n", - "Looking at a sample chunk...\n", - "('Why Milvus Docs Tutorials Tools Blog Community Sta loaded collection, refer '\n", - " 'to Manage Collections. Collections created using the RESTful API are always '\n", - " 'automatically loaded. Insert Data Collections cr')\n", - "{'doc_index': 0,\n", - " 'h1': 'Why Milvus Docs Tutorials Tools Blog Community Sta',\n", - " 'source': 'https://milvus.io/docs/quickstart.md',\n", - " 'start_index': 0}\n" + "Indexed 228 parent documents in 0.00 seconds and \n", + "Indexed a total of 873 child documents in 116.82 seconds\n" ] } ], "source": [ - "# Function to remove newlines and double spaces from a string.\n", - "def clean_text(text):\n", - " clean_text = text.replace(\"\\n\\n\", \" \")\\\n", - " .replace(\"

\", \" \")\\\n", - " .replace(\"

\", \" \")\n", - " return clean_text\n", + "# Index the documents in the document store.\n", + "start_time = time.time()\n", + "retriever.docstore.mset(list(zip(doc_ids, parent_docs)))\n", + "print(f\"Indexed {len(parent_docs)} parent documents in {time.time()-start_time:.2f} seconds and \")\n", + "\n", + "# Index the documents in the vector store.\n", + "batch_size = 300\n", + "total_docs = len(sub_docs)\n", + "# Calculate the number of batches needed\n", + "batches = (total_docs + batch_size - 1) // batch_size\n", + "start_time = time.time()\n", + "for i in range(batches):\n", + " batch_start = i * batch_size\n", + " batch_end = min(batch_start + batch_size, total_docs)\n", + " batch = sub_docs[batch_start:batch_end]\n", + " retriever.vectorstore.add_documents(batch)\n", "\n", - "# Clean up the metadata urls and chunk texts.\n", - "for doc in smaller_chunks:\n", - " doc.metadata[\"source\"] = \\\n", - " doc.metadata[\"source\"]\\\n", - " .replace(\"../../RAG/rtdocs_new\", \"https://milvus.io/docs\")\\\n", - " .replace(\".html\", \".md\")\n", - " doc.page_content = clean_text(doc.page_content)\n", + "print(f\"Indexed a total of {total_docs} child documents in {time.time()-start_time:.2f} seconds\")\n", + "\n", + "# Indexed 507 documents in 56.15 seconds." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "88aa1894", + "metadata": {}, + "outputs": [], + "source": [ + "# Delete the Milvus collection and doc store.\n", + "# del vectorstore, retriever, store" + ] + }, + { + "cell_type": "markdown", + "id": "0c324937", + "metadata": {}, + "source": [ + "## Semantic Chunking using LangChain\n", + "\n", + "This chunker works by determining when to \"break\" apart sentences. This is done by calculating cosine distances between adjacent sentences. Looking across all these cosine distances, look for outlier distances past some threshold. These outlier distances determine when chunks are split.\n", + "\n", + "There are a few ways to determine what that threshold is, which are controlled by the breakpoint_threshold_type kwarg.\n", + "\n", + "- `percentile` (default) — In this method, any distances greater than X percentile is split into a chunk.\n", "\n", - "# Inspect a child chunk.\n", - "print()\n", - "print(\"Looking at a sample chunk...\")\n", - "pprint.pprint(smaller_chunks[15].page_content[:200])\n", - "pprint.pprint(smaller_chunks[15].metadata)" + "- `standard_deviation` — In this method, any difference greater than X standard deviations is split.\n", + "\n", + "- `interquartile` — In this method, the interquartile distance is used to split chunks.\n", + "\n", + "- See Semantic Chunking [docs](https://python.langchain.com/v0.2/docs/how_to/semantic-chunker/#standard-deviation) and [api](https://api.python.langchain.com/en/latest/text_splitter/langchain_experimental.text_splitter.SemanticChunker.html)." ] }, { "cell_type": "code", - "execution_count": 18, - "id": "f2f7463b", + "execution_count": 20, + "id": "23149b10", "metadata": {}, "outputs": [], "source": [ - "# # Double-check if parent chunks are correctly indexed.\n", - "# temp_doc_index = smaller_chunks[15].metadata['doc_index']\n", - "# temp_start_index = smaller_chunks[15].metadata['start_index']\n", - "# temp_start_index = temp_start_index - 512\n", - "# temp_end_index = temp_start_index + 1536\n", - "\n", - "# temp = docs[temp_doc_index].page_content\n", - "# print(len(temp))\n", - "# pprint.pprint(temp[temp_start_index:temp_end_index].replace(\"\\n\\n\", \" \"))" + "# !python -m pip install langchain_experimental" ] }, { - "cell_type": "markdown", - "id": "e338e0a5", + "cell_type": "code", + "execution_count": 21, + "id": "574e5387", "metadata": {}, + "outputs": [], "source": [ - "### Transform chunks into vectors using the embedding model" + "# # UNCOMMENT TO READ THE DOCS FROM A LOCAL DIRECTORY.\n", + "\n", + "# # Read docs into LangChain\n", + "# # !pip install -U langchain\n", + "# # !pip install unstructured\n", + "# from langchain.document_loaders import DirectoryLoader\n", + "\n", + "# # Load HTML files from a local directory\n", + "# path = \"../../RAG/rtdocs_new/\"\n", + "# global_pattern = '*.html'\n", + "# loader = DirectoryLoader(path=path, glob=global_pattern)\n", + "# docs = loader.load()\n", + "\n", + "# num_documents = len(docs)\n", + "# print(f\"loaded {num_documents} documents\")\n", + "\n", + "# # # Subset docs for faster testing\n", + "# # docs = docs[5:7].copy()\n", + "# # num_documents = len(docs)\n", + "# # print(f\"testing with {num_documents} documents\")\n", + "\n", + "# # Print the type of the docs.\n", + "# print(type(docs))\n", + "# print(type(docs[0]))\n", + "\n", + "# docs[0].page_content[:500]" ] }, { "cell_type": "code", - "execution_count": 19, - "id": "d223c6f1", + "execution_count": 22, + "id": "bf87ad6a", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Embedding time for 586 chunks: 59.12 seconds\n" - ] - } - ], + "outputs": [], "source": [ - "# STEP 5. TRANSFORM CHUNKS INTO VECTORS USING EMBEDDING MODEL INFERENCE.\n", - "\n", - "# Encoder input is docs as a list of strings.\n", - "list_of_strings = [doc.page_content for doc in smaller_chunks if hasattr(doc, 'page_content')]\n", - "\n", - "# Embedding inference using the Milvus built-in sparse-dense-reranking encoder.\n", - "start_time = time.time()\n", - "embeddings = torch.tensor(encoder.encode(list_of_strings))\n", - "end_time = time.time()\n", - "\n", - "print(f\"Embedding time for {len(list_of_strings)} chunks: \", end=\"\")\n", - "print(f\"{round(end_time - start_time, 2)} seconds\")\n", - "\n", - "# Inference Embeddings: 100%|██████████| 19/19 [00:35<00:00, 1.86s/it]\n", - "# Embedding time for 127 chunks: 57.92 seconds" + "# TODO - MOVE THIS TO A LOOP\n", + "# # Extract all document content into a single string.\n", + "# all_page_contents = \" \".join(doc.page_content for doc in docs)\n", + "# all_page_contents = clean_text(all_page_contents)\n", + "# # print(f\"len(all_page_contents): {len(all_page_contents)}\")\n", + "# # print(all_page_contents[:500])" ] }, { "cell_type": "code", - "execution_count": 20, - "id": "babb0388", + "execution_count": 23, + "id": "093a58da", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "type embeddings: of \n", - "of numbers: \n" - ] - } - ], + "outputs": [], "source": [ - "# Normalize the embeddings.\n", - "embeddings = np.array(embeddings / np.linalg.norm(embeddings))\n", + "# from langchain_experimental.text_splitter import SemanticChunker\n", "\n", - "# Convert embeddings to list of `numpy.ndarray`, each containing `numpy.float32` numbers.\n", - "converted_values = list(map(np.float32, embeddings))\n", + "# text_splitter = SemanticChunker(embed_model)\n", + "# semantic_docs = text_splitter.create_documents([all_page_contents])\n", "\n", - "# Inspect the embeddings.\n", - "# assert len(chunks[0].page_content) <= MAX_SEQ_LENGTH_IN_TOKENS\n", - "assert len(converted_values[0]) == EMBEDDING_DIM\n", - "print(f\"type embeddings: {type(converted_values)} of {type(converted_values[0])}\")\n", - "print(f\"of numbers: {type(converted_values[0][0])}\")" + "# lengths = [len(doc.page_content) for doc in semantic_docs]\n", + "# print(f\"Created {len(semantic_docs)} semantic documents from {len(docs)}.\")\n", + "# print(\", \".join(str(len(length)) for length in lengths))\n", + "# pprint.pprint(semantic_docs[0].page_content)\n", + "# # Created 59 semantic documents from 22." ] }, { - "cell_type": "markdown", - "id": "d9bd8153", + "cell_type": "code", + "execution_count": 24, + "id": "3d70b441", "metadata": {}, + "outputs": [], "source": [ - "## Insert data into Milvus\n", + "# # Inspect chunk lengths\n", + "# lengths = [len(doc.page_content) for doc in html_docs]\n", + "# import matplotlib.pyplot as plt\n", "\n", - "For each original text chunk, we'll write the sextuplet (`chunk, h1, h2, source, dense_vector, sparse_vector`) into the database.\n", + "# # Mean, median lengths.\n", + "# mean_length = np.mean(lengths)\n", + "# median_length = np.median(lengths)\n", "\n", - "
\n", - "\n", - "
\n", + "# # Plotting the lengths.\n", + "# plt.figure(figsize=(10, 6)) # Adjust figure size\n", + "# plt.plot(lengths, marker='o') # Plot normalized lengths with circle markers\n", + "# plt.title('Chunk Lengths from Semantic Chunking', fontsize=20, fontweight='bold')\n", + "# plt.xlabel('Document Index') # X-axis label\n", + "# plt.ylabel('Normalized Length') # Y-axis label, now showing normalized length\n", + "# plt.grid(True) # Show grid\n", "\n", - "**The Milvus Client wrapper can only handle loading data from a list of dictionaries.**\n", + "# # Add a horizontal red line at mean length\n", + "# plt.axhline(y=mean_length, color='g', linestyle='-')\n", + "# plt.axhline(y=median_length, color='r', linestyle='-')\n", + "# plt.text(len(lengths)-1, mean_length, f'mean = {mean_length:.0f}', va='center', ha='left', backgroundcolor='w', fontsize=12)\n", + "# plt.text(0, median_length, f'median = {median_length:.0f}', va='center', ha='right', backgroundcolor='w', fontsize=12)\n", "\n", - "Otherwise, in general, Milvus supports loading data from:\n", - "- pandas dataframes \n", - "- list of dictionaries " + "# plt.show() # Display the plot" ] }, { "cell_type": "code", - "execution_count": 21, - "id": "79dd2299", + "execution_count": 25, + "id": "a76a7304", "metadata": {}, "outputs": [], "source": [ - "# STEP 6. INSERT CHUNK LIST INTO MILVUS OR ZILLIZ.\n", - "\n", - "# Create chunk_list and dict_list in a single loop\n", - "dict_list = []\n", - "for chunk, vector in zip(smaller_chunks, converted_values):\n", - " # Assemble embedding vector, original text chunk, metadata.\n", - " chunk_dict = {\n", - " 'chunk': chunk.page_content,\n", - " 'h1': chunk.metadata.get('h1', \"\")[:50],\n", - " 'h2': chunk.metadata.get('h2', \"\")[:50],\n", - " 'source': chunk.metadata.get('source', \"\"),\n", - " 'doc_index': chunk.metadata.get('doc_index', 0),\n", - " 'start_index': chunk.metadata.get('start_index', 0),\n", - " 'vector': vector,\n", - " }\n", - " dict_list.append(chunk_dict)\n", + "# # Use Percentile to determine breakpoints.\n", + "# text_splitter = SemanticChunker(\n", + "# embed_model, \n", + "# breakpoint_threshold_type=\"percentile\",\n", + "# breakpoint_threshold_amount=0.99\n", + "# )\n", + "\n", + "# semantic_docs = text_splitter.create_documents([all_page_contents])\n", + "# print(f\"Created {len(semantic_docs)} semantic documents from {len(docs)}.\")\n", "\n", - "# # TODO - Uncomment to inspect a chunk and its metadata.\n", - "# print(len(dict_list))\n", - "# print(type(dict_list[1]), len(dict_list[1]))\n", - "# pprint.pprint(dict_list[1])" + "# # Too many!\n", + "# # Created 1138 semantic documents from 22." ] }, { "cell_type": "code", - "execution_count": 22, - "id": "f3ac0d5c", + "execution_count": 26, + "id": "88e376c7", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Start inserting entities\n", - "Milvus insert time for 586 vectors: 0.23 seconds\n" - ] - } - ], + "outputs": [], "source": [ - "# Insert data into the Milvus collection.\n", - "print(\"Start inserting entities\")\n", + "# # Use Standard Deviation to determine breakpoints.\n", + "# text_splitter = SemanticChunker(\n", + "# embed_model, \n", + "# breakpoint_threshold_type=\"standard_deviation\",\n", + "# breakpoint_threshold_amount=0.80\n", + "# )\n", + "# semantic_docs = text_splitter.create_documents([all_page_contents])\n", "\n", - "start_time = time.time()\n", - "mc.insert(\n", - " COLLECTION_NAME,\n", - " data=dict_list,\n", - " progress_bar=True)\n", + "# print(f\"Created {len(semantic_docs)} semantic documents from {len(docs)}.\")\n", + "# print(\", \".join(str(len(doc.page_content)) for doc in semantic_docs))\n", + "# pprint.pprint(semantic_docs[0].page_content)\n", "\n", - "end_time = time.time()\n", - "print(f\"Milvus insert time for {len(dict_list)} vectors: \", end=\"\")\n", - "print(f\"{np.round(end_time - start_time, 2)} seconds\")" + "# # Created 195 semantic documents from 22." ] }, { - "cell_type": "markdown", - "id": "277e7ad7", + "cell_type": "code", + "execution_count": 27, + "id": "9fec633e", "metadata": {}, + "outputs": [], "source": [ - "## Aside - example Milvus collection API calls\n", - "https://milvus.io/docs/manage-collections.md#View-Collections\n", - "\n", - "Below are some common API calls for checking a collection.\n", - "- `.num_entities`, flushes data and executes row count.\n", - "- `.describe_collection()`, gives details about the schema, index, collection.\n", - "- `.query()`, gives back selected data from the collection." + "# # Create vectorstore for vector index and retrieval.\n", + "# COLLECTION_NAME = \"MilvusDocs\"\n", + "# start_time = time.time()\n", + "# vectorstore = Milvus.from_documents(\n", + "# collection_name=COLLECTION_NAME,\n", + "# documents=semantic_docs,\n", + "# embedding=embed_model,\n", + "# connection_args={\"uri\": \"./milvus_demo.db\"},\n", + "# # Override LangChain default values for Milvus.\n", + "# consistency_level=\"Eventually\",\n", + "# # auto_id=True,\n", + "# drop_old=True,\n", + "# index_params = {\n", + "# \"metric_type\": \"COSINE\",\n", + "# \"index_type\": \"AUTOINDEX\",\n", + "# \"params\": {},}\n", + "# )\n", + "# end_time = time.time()\n", + "# print(f\"Created Milvus collection from {len(semantic_docs)} docs in {end_time - start_time:.2f} seconds\")" ] }, { "cell_type": "code", - "execution_count": 23, - "id": "c211c099", + "execution_count": 28, + "id": "9d1ec60b", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{'aliases': [],\n", - " 'auto_id': True,\n", - " 'collection_id': 0,\n", - " 'collection_name': 'MilvusDocs',\n", - " 'consistency_level': 0,\n", - " 'description': '',\n", - " 'enable_dynamic_field': True,\n", - " 'fields': [{'auto_id': True,\n", - " 'description': '',\n", - " 'field_id': 100,\n", - " 'is_primary': True,\n", - " 'name': 'id',\n", - " 'params': {},\n", - " 'type': },\n", - " {'description': '',\n", - " 'field_id': 101,\n", - " 'name': 'vector',\n", - " 'params': {'dim': 1024},\n", - " 'type': }],\n", - " 'num_partitions': 0,\n", - " 'num_shards': 0,\n", - " 'properties': {}}\n", - "timing: 0.0014 seconds\n", - "\n", - "data: [\"{'count(*)': 586}\"] , extra_info: {'cost': 0}\n", - "timing: 0.0023 seconds\n" - ] - } - ], + "outputs": [], "source": [ - "# Example Milvus Collection utility API calls.\n", - "# https://milvus.io/docs/manage-collections.md#View-Collections\n", - "\n", - "# View collection info, incurs a call to .flush() first.\n", - "start_time = time.time()\n", - "pprint.pprint(mc.describe_collection(COLLECTION_NAME))\n", - "end_time = time.time()\n", - "print(f\"timing: {round(end_time - start_time, 4)} seconds\")\n", - "print()\n", - "\n", - "# Milvus Lite - notice a delay, so wait 30 seconds.\n", - "time.sleep(15)\n", - "\n", - "# Count rows, incurs a call to .flush() first.\n", - "start_time = time.time()\n", - "res = mc.query( collection_name=COLLECTION_NAME, \n", - " filter=\"\", \n", - " output_fields = [\"count(*)\"], )\n", - "pprint.pprint(res)\n", - "end_time = time.time()\n", - "print(f\"timing: {round(end_time - start_time, 4)} seconds\")" + "# Delete the Milvus collection and vectorstore.\n", + "# del vectorstore" ] }, { @@ -1122,7 +1091,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 29, "id": "5e7f41f4", "metadata": {}, "outputs": [ @@ -1151,14 +1120,14 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 68, "id": "cd25ffca", "metadata": {}, "outputs": [], "source": [ "# SELECT A PARTICULAR QUESTION TO ASK.\n", "\n", - "SAMPLE_QUESTION = QUESTION1" + "SAMPLE_QUESTION = QUESTION4" ] }, { @@ -1177,278 +1146,300 @@ ] }, { - "cell_type": "markdown", - "id": "532c2758", + "cell_type": "code", + "execution_count": 31, + "id": "2b45afb5", "metadata": {}, + "outputs": [], "source": [ - "### Exercise #3 (2 min):\n", - "Search Milvus using the default search index." + "# # Retrieve semantic chunks.\n", + "# TOP_K = 2\n", + "# semantic_retriever = vectorstore.as_retriever(search_kwargs={\"k\" : TOP_K})\n", + "# semantic_results = semantic_retriever.invoke(SAMPLE_QUESTION)\n", + "\n", + "# print(len(semantic_results))\n", + "\n", + "# # Print the retrieved chunk and metadata.\n", + "# contexts = []\n", + "# for semantic_result in semantic_results:\n", + "# context = semantic_result.page_content\n", + "# print(len(context))\n", + "# pprint.pprint(f\"chunk: {context}\")\n", + "# pprint.pprint(f\"metadata: {semantic_result.metadata}\")\n", + "# context = semantic_result.page_content\n", + "# contexts.append(context)" ] }, { "cell_type": "code", - "execution_count": 26, - "id": "c457f8c6", + "execution_count": 69, + "id": "edf82971", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "512\n", + "chunk: during searches or queries. Milvus provides several index types and metrics to sort field values for efficient similarity searches. The following table lists the supported index types and metrics for different vector field types. For details, refer to In-memory Index and Similarity Metrics. Floating point embeddings Binary embeddings Sparse embeddings Metric Types Index Types Euclidean distance (L2)Inner product (IP)Cosine similarity (COSINE) FLATIVF_FLATIVF_SQ8IVF_PQGPU_IVF_FLATGPU_IVF_PQHNSWDISKANN Metric\n", + "(\"metadata: {'h1': 'Index Vector Fields', 'h2': 'This guide walks you thro', \"\n", + " \"'h3': 'Overview', 'source': 'https://milvus.io/docs/index-vector-fields.md', \"\n", + " \"'doc_index': 'c393a40d-864a-4cc4-9da3-4c53cf2d6602', 'doc_id': \"\n", + " \"'6c120544-d259-4fb1-b6f2-0481de55c492', 'pk': 450852554287612165}\")\n", + "498\n", + "chunk: field. index_params.add_index( field_name=\"vector\", metric_type=\"COSINE\", index_type=\"IVF_FLAT\", index_name=\"vector_index\", params={ \"nlist\": 128 } ) # 4.3. Create an index file client.create_index( collection_name=\"customized_setup\", index_params=index_params ) import io.milvus.v2.common.IndexParam; import io.milvus.v2.service.index.request.CreateIndexReq; // 4 Prepare index parameters // 4.2 Add an index for the vector field \"vector\" IndexParam indexParamForVectorField = IndexParam.builder()\n", + "(\"metadata: {'h1': 'Index Vector Fields', 'h2': 'This guide walks you thro', \"\n", + " \"'h3': 'Overview', 'source': 'https://milvus.io/docs/index-vector-fields.md', \"\n", + " \"'doc_index': 'c393a40d-864a-4cc4-9da3-4c53cf2d6602', 'doc_id': \"\n", + " \"'2ba6f33a-058b-46d8-8139-b41b1bef3f45', 'pk': 450852554287612149}\")\n", + "['https://milvus.io/docs/index-vector-fields.md']\n", + "2\n" + ] + } + ], "source": [ - "# query_embeddings = _utils.embed_query(encoder, [SAMPLE_QUESTION])\n", - "# TOP_K = 2\n", + "# The vector store alone will retrieve small chunks:\n", + "TOP_K = 2\n", + "child_results = retriever.vectorstore.similarity_search(\n", + " SAMPLE_QUESTION,\n", + " k=TOP_K)\n", "\n", - "# results = mc.search(\n", - "# #(exercise): code here # Answer: COLLECTION_NAME,\n", - "# data=query_embeddings,\n", - "# limit=TOP_K,\n", - "# consistency_level=\"Eventually\"\n", - "# )\n", - "# print(f\"Found top {len(results[0])} results for question: {SAMPLE_QUESTION}\")" + "# Print the retrieved chunk and metadata.\n", + "# Append each unique context and source to a list.\n", + "contexts = []\n", + "sources = []\n", + "for child_result in child_results:\n", + " context = child_result.page_content\n", + " print(len(context))\n", + " print(f\"chunk: {context}\")\n", + " pprint.pprint(f\"metadata: {child_result.metadata}\")\n", + " context = child_result.page_content\n", + " contexts.append(context)\n", + " source = child_result.metadata['source']\n", + " if source not in sources:\n", + " sources.append(source)\n", + "\n", + "print(sources)\n", + "print(len(contexts))" ] }, { "cell_type": "code", - "execution_count": 27, - "id": "1f0cc47f", + "execution_count": 70, + "id": "809ff495", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "output fields: ['chunk', 'h1', 'h2', 'source', 'doc_index', 'start_index']\n", - "Found top 2 results for question: What do the parameters for HNSW mean?\n" + "Num parent results: 4\n", + "1571\n", + "chunk: during searches or queries. Milvus provides several index types and metrics to sort field values for efficient similarity searches. The following table lists the supported index types and metrics for different vector field types. For details, refer to In-memory Index and Similarity Metrics. Floating point embeddings Binary embeddings Sparse embeddings Metric Types Index Types Euclidean distance (L2)Inner product (IP)Cosine similarity (COSINE) FLATIVF_FLATIVF_SQ8IVF_PQGPU_IVF_FLATGPU_IVF_PQHNSWDISKANN Metric Types Index Types Jaccard (JACCARD)Hamming (HAMMING) BIN_FLATBIN_IVF_FLAT Metric Types Index Types IP SPARSE_INVERTED_INDEXSPARSE_WAND It is recommended to create indexes for both the vector field and scalar fields that are frequently accessed. As explained in Manage Collections, Milvus automatically generates an index and loads it into memory when creating a collection if any of the following conditions are specified in the collection creation request: The dimensionality of the vector field and the metric type, or The schema and the index parameters. The code snippet below repurposes the existing code to establish a connection to a Milvus instance and create a collection without specifying its index parameters. In this case, the collection lacks an index and remains unloaded. To prepare for indexing, use MilvusClient to connect to the Milvus server and set up a collection by using create_schema(), add_field(), and create_collection(). To prepare for indexing, use MilvusClientV2 to connect to the Milvus server and set up a collection by using\n", + "(\"metadata: {'h1': 'Index Vector Fields', 'h2': 'This guide walks you thro', \"\n", + " \"'h3': 'Overview', 'source': 'https://milvus.io/docs/index-vector-fields.md', \"\n", + " \"'doc_index': 'c393a40d-864a-4cc4-9da3-4c53cf2d6602'}\")\n", + "1584\n", + "chunk: field. index_params.add_index( field_name=\"vector\", metric_type=\"COSINE\", index_type=\"IVF_FLAT\", index_name=\"vector_index\", params={ \"nlist\": 128 } ) # 4.3. Create an index file client.create_index( collection_name=\"customized_setup\", index_params=index_params ) import io.milvus.v2.common.IndexParam; import io.milvus.v2.service.index.request.CreateIndexReq; // 4 Prepare index parameters // 4.2 Add an index for the vector field \"vector\" IndexParam indexParamForVectorField = IndexParam.builder() .fieldName(\"vector\") .indexName(\"vector_index\") .indexType(IndexParam.IndexType.IVF_FLAT) .metricType(IndexParam.MetricType.COSINE) .extraParams(Map.of(\"nlist\", 128)) .build(); List indexParams = new ArrayList<>(); indexParams.add(indexParamForVectorField); // 4.3 Crate an index file CreateIndexReq createIndexReq = CreateIndexReq.builder() .collectionName(\"customized_setup\") .indexParams(indexParams) .build(); client.createIndex(createIndexReq); // 4. Set up index for the collection // 4.1. Set up the index parameters res = await client.createIndex({ collection_name: \"customized_setup\", field_name: \"vector\", index_type: \"AUTOINDEX\", metric_type: \"COSINE\", index_name: \"vector_index\", params: { \"nlist\": 128 } }) console.log(res.error_code) // Output // // Success // Parameter Description field_name The name of the target file to apply this object applies. metric_type The algorithm that is used to measure similarity between vectors. Possible values are IP, L2, COSINE, JACCARD, HAMMING. This is available only when the specified field is a vector field. For more\n", + "(\"metadata: {'h1': 'Index Vector Fields', 'h2': 'This guide walks you thro', \"\n", + " \"'h3': 'Overview', 'source': 'https://milvus.io/docs/index-vector-fields.md', \"\n", + " \"'doc_index': 'c393a40d-864a-4cc4-9da3-4c53cf2d6602'}\")\n", + "1582\n", + "chunk: DocsBlogCommunity Why Milvus What is MilvusUse Cases Tutorials CodelabsBootcampDemosVideo Tools AttuMilvus CLISizing ToolMilvus Backup Get Started Docs Tutorials Tools Blog Community Get Started Search Home ​ v2.4.x About Milvus Get Started Concepts Architecture Bitset Consistency Multi-tenancy Timestamp Similarity Metrics Time Synchronization Vector Index In-memory Index On-disk Index GPU Index Scalar Index Reranking Users and Roles In-memory Replica Terminology User Guide Models Milvus Migration Administration Guide Tools Integrations Tutorials FAQs API Reference In-memory Index ANNS vector indexes Indexes supported in Milvus FAQ What's next This topic lists various types of in-memory indexes Milvus supports, scenarios each of them best suits, and parameters users can configure to achieve better search performance. For on-disk indexes, see On-disk Index. Indexing is the process of efficiently organizing data, and it plays a major role in making similarity search useful by dramatically accelerating time-consuming queries on large datasets. To improve query performance, you can specify an index type for each vector field. Currently, a vector field only supports one index type. Milvus automatically deletes the old index when switching the index type. Most of the vector index types supported by Milvus use approximate nearest neighbors search (ANNS) algorithms. Compared with accurate retrieval, which is usually very time-consuming, the core idea of ANNS is no longer limited to returning the most accurate result, but only searching for neighbors of the target.\n", + "(\"metadata: {'h1': 'In-memory Index', 'h2': 'This topic lists various ', 'h3': \"\n", + " \"'ANNS vector indexes', 'source': 'https://milvus.io/docs/index.md', \"\n", + " \"'doc_index': '709e587e-ba1f-4e39-900c-433bcfc02990'}\")\n", + "1585\n", + "chunk: DocsBlogCommunity Why Milvus What is MilvusUse Cases Tutorials CodelabsBootcampDemosVideo Tools AttuMilvus CLISizing ToolMilvus Backup Get Started Docs Tutorials Tools Blog Community Get Started Search Home ​ v2.4.x About Milvus Get Started Concepts User Guide Models Milvus Migration Administration Guide Tools Integrations Tutorials FAQs API Reference Blog Get Started Recommended articles Welcome to Milvus Docs! Here you will learn about what Milvus is, and how to install, use, and deploy Milvus to build an application according to your business need. Try Managed Milvus For Free! Try Zilliz Cloud for free! The easiest way to experience Milvus! Zilliz Cloud Zilliz Cloud China Install Milvus Learn how to install Milvus using either Docker Compose or on Kubernetes. Quick Start Learn how to quickly run Milvus with sample code. Bootcamp Learn how to build vector similarity search applications with Milvus. Use Manage Collections Insert, Upsert, and Delete Index Vector Fields Single-Vector Search Get & Scalar Query Deploy Configure Milvus Manage Dependencies Deploy on Clouds Scale a Milvus Cluster Monitor and Alert Learn System Configuration Architecture Overview Vector Index Similarity Metrics Glossary What's new in docs Mar 2024 - Milvus 2.4.0 release Added guidance on how to conduct hybrid search. Added description of GPU index. Added guidance on how to embed your data using PyMilvus. Added guidance on how to enable RBAC with Milvus Operator. Added descriptions of Milvus CDC. Introducing PyMilvus Integration with Embedding Models Engineering Made with Love by the\n", + "(\"metadata: {'h1': 'Welcome to Milvus Docs!', 'h2': 'Here you will learn \"\n", + " \"about', 'h3': '', 'source': 'https://milvus.io/docs/', 'doc_index': \"\n", + " \"'5a75d188-5760-42ed-908a-b9c35c6998a2'}\")\n" ] } ], "source": [ - "# Define metadata fields you can filter on.\n", - "OUTPUT_FIELDS = list(dict_list[0].keys())\n", - "OUTPUT_FIELDS.remove('vector')\n", - "print(f\"output fields: {OUTPUT_FIELDS}\")\n", + "# Whereas the retriever will return the larger parent document:\n", + "parent_results = retriever.invoke(\n", + " SAMPLE_QUESTION) #[0].page_content\n", "\n", - "query_embeddings = _utils.embed_query(encoder, [SAMPLE_QUESTION])\n", - "TOP_K = 2\n", + "# Print the retrieved chunk and metadata.\n", + "print(f\"Num parent results: {len(parent_results)}\")\n", + "for parent_result in parent_results:\n", + " print(len(parent_result.page_content))\n", + " print(f\"chunk: {parent_result.page_content}\")\n", + " pprint.pprint(f\"metadata: {parent_result.metadata}\")\n", "\n", - "results = mc.search(\n", - " COLLECTION_NAME,\n", - " data=query_embeddings, \n", - " # search_params=SEARCH_PARAMS,\n", - " output_fields=OUTPUT_FIELDS, \n", - " # Milvus can utilize metadata in boolean expressions to filter search.\n", - " # filter=filter_expression,\n", - " limit=TOP_K,\n", - " consistency_level=\"Eventually\"\n", - ")\n", - "print(f\"Found top {len(results[0])} results for question: {SAMPLE_QUESTION}\")\n", - "\n", - "# Define a convenience function for searching.\n", - "def mc_run_search(question, filter_expression, top_k=3):\n", - " # Embed the question using the same encoder.\n", - " query_embeddings = _utils.embed_query(encoder, [question])\n", - "\n", - " # # Return top k results with HNSW index.\n", - " # SEARCH_PARAMS = dict({\n", - " # # Re-use index param for num_candidate_nearest_neighbors.\n", - " # \"ef\": INDEX_PARAMS['efConstruction']\n", - " # })\n", - "\n", - " # Run semantic vector search using your query and the vector database.\n", - " results = mc.search(\n", - " COLLECTION_NAME,\n", - " data=query_embeddings, \n", - " # search_params=SEARCH_PARAMS,\n", - " output_fields=OUTPUT_FIELDS, \n", - " # Milvus can utilize metadata in boolean expressions to filter search.\n", - " filter=filter_expression,\n", - " limit=top_k,\n", - " consistency_level=\"Eventually\"\n", - " )\n", + "# Only the 0th parent chunk seems relevant.\n", + "assert parent_results[0].metadata['source'] == sources[0]" + ] + }, + { + "cell_type": "markdown", + "id": "20cf59f0", + "metadata": {}, + "source": [ + "## Summarize the context using a LLM\n", "\n", - " # Assemble retrieved context and context metadata.\n", - " # The search result is in the variable `results[0]`, which is type \n", - " # 'pymilvus.orm.search.SearchResult'. \n", - " METADATA_FIELDS = [f for f in OUTPUT_FIELDS if f != 'chunk']\n", - " formatted_results, context, context_metadata = _utils.client_assemble_retrieved_context(\n", - " results, metadata_fields=METADATA_FIELDS, num_shot_answers=top_k)\n", - " \n", - " return formatted_results, context, context_metadata" + "Using a small, open source LLM should be good enough for the summarization task." ] }, { "cell_type": "code", - "execution_count": 28, - "id": "40734f49", + "execution_count": 71, + "id": "377d92fc", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "filter: \n", - "Milvus Client search time for 586 vectors: 0.12221956253051758 seconds\n", - "type: , count: 2\n" + "Length long text to summarize: 1011\n" ] } ], "source": [ - "# STEP 7. RETRIEVE ANSWERS FROM YOUR DOCUMENTS STORED IN MILVUS OR ZILLIZ.\n", - "\n", - "# Metadata filters for CSV dataset.\n", - "# expression = 'film_year >= 2019'\n", - "expression = \"\"\n", - "print(f\"filter: {expression}\")\n", - "TOP_K = 2\n", + "# Separate all the context together by space.\n", + "contexts_combined = ' '.join(contexts)\n", "\n", - "start_time = time.time()\n", - "formatted_results, contexts, context_metadata = \\\n", - " mc_run_search(SAMPLE_QUESTION, expression, TOP_K)\n", - "elapsed_time = time.time() - start_time\n", - "print(f\"Milvus Client search time for {len(dict_list)} vectors: {elapsed_time} seconds\")\n", + "# Alternatively use the parent (bigger) chunks.\n", + "# contexts_combined = \" \".join([result.page_content \n", + "# for result in parent_results[:TOP_K]])\n", + "# contexts_combined = parent_results[0].page_content\n", "\n", - "# Inspect search result.\n", - "print(f\"type: {type(formatted_results)}, count: {len(formatted_results)}\")" + "print(f\"Length long text to summarize: {len(contexts_combined)}\")" ] }, { - "cell_type": "markdown", - "id": "aa3cade1", + "cell_type": "code", + "execution_count": 72, + "id": "cfd45c26", "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Length prompt: 1196\n" + ] + } + ], "source": [ - "## Assemble and inspect the search result\n", + "# Define temperature for the LLM and random seed.\n", + "TEMPERATURE = 0.1\n", + "TOP_P = 0.9\n", + "RANDOM_SEED = 415\n", + "MAX_TOKENS = 512\n", + "FREQUENCY_PENALTY = 2\n", "\n", - "The search result is in the variable `results[0]` consisting of top_k-count of objects of type `'pymilvus.client.abstract.Hits'`\n", - "\n" + "# Define a system prompt to use for summarization.\n", + "SYSTEM_PROMPT = f\"\"\"First select the text that is relevant to the \n", + "user's question. Second, summarize the selected text so it is clear,\n", + "easy to understand, and concise, in fewer than 10 sentences.\n", + "Text: {contexts_combined}\n", + "\"\"\"\n", + "print(f\"Length prompt: {len(SYSTEM_PROMPT)}\")\n" ] }, { "cell_type": "code", - "execution_count": 29, - "id": "a7a2a4dd", + "execution_count": 73, + "id": "c66618c8", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Retrieved result #1\n", - "distance = 0.7174309492111206\n", - "('Chunk text: Why Milvus Docs Tutorials Tools Blog Community Sta is a '\n", - " 'range-search parameter and terminates the search process whilst the number '\n", - " 'of consecutive empty buckets reaches the specified value.Increasing this '\n", - " 'value can improve recall rate at the cost of increased search time. [1, '\n", - " '65535] 2 HNSW HNSW (Hierarchical Navigable Small World Graph) is a '\n", - " 'graph-based indexing algorithm. It builds a multi-layer navigation structure '\n", - " 'for an image according to certain rules. In this structure, the upper layers '\n", - " 'are more sparse and the distances between nodes are farther; the')\n", - "h1: Why Milvus Docs Tutorials Tools Blog Community Sta\n", - "h2: \n", - "source: https://milvus.io/docs/index.md\n", - "doc_index: 3\n", - "start_index: 625\n", - "\n", - "Retrieved result #2\n", - "distance = 0.7135186195373535\n", - "('Chunk text: Why Milvus Docs Tutorials Tools Blog Community Sta begin another '\n", - " 'search. After multiple iterations, it can quickly approach the target '\n", - " 'position. In order to improve performance, HNSW limits the maximum degree of '\n", - " 'nodes on each layer of the graph to M. In addition, you can use '\n", - " 'efConstruction (when building index) or ef (when searching targets) to '\n", - " 'specify a search range. Index building parameters Parameter Description '\n", - " 'Range M M defines tha maximum number of outgoing connections in the graph. '\n", - " 'Higher M leads to higher accuracy/run_time at fixed')\n", - "h1: Why Milvus Docs Tutorials Tools Blog Community Sta\n", - "h2: \n", - "source: https://milvus.io/docs/index.md\n", - "doc_index: 3\n", - "start_index: 0\n", + "First select the text that is relevant to the \n", + "user's question. Second, summarize the selected text so it is clear,\n", + "easy to understand, and concise, in fewer than 10 sentences.\n", + "Text: during searches or queries. Milvus provides several index types and metrics to sort field values for efficient similarity searches. The following table lists the supported index types and metrics for different vector field types. For details, refer to In-memory Index and Similarity Metrics. Floating point embeddings Binary embeddings Sparse embeddings Metric Types Index Types Euclidean distance (L2)Inner product (IP)Cosine similarity (COSINE) FLATIVF_FLATIVF_SQ8IVF_PQGPU_IVF_FLATGPU_IVF_PQHNSWDISKANN Metric field. index_params.add_index( field_name=\"vector\", metric_type=\"COSINE\", index_type=\"IVF_FLAT\", index_name=\"vector_index\", params={ \"nlist\": 128 } ) # 4.3. Create an index file client.create_index( collection_name=\"customized_setup\", index_params=index_params ) import io.milvus.v2.common.IndexParam; import io.milvus.v2.service.index.request.CreateIndexReq; // 4 Prepare index parameters // 4.2 Add an index for the vector field \"vector\" IndexParam indexParamForVectorField = IndexParam.builder()\n", "\n" ] } ], "source": [ - "# Loop through search results, print metadata.\n", - "sources = []\n", - "for i in range(len(contexts)):\n", - " print(f\"Retrieved result #{i+1}\")\n", - " print(f\"distance = {formatted_results[i][0]}\")\n", - " pprint.pprint(f\"Chunk text: {contexts[i]}\")\n", - " for key, value in context_metadata[i].items():\n", - " if key == \"source\":\n", - " sources.append(value)\n", - " print(f\"{key}: {value}\")\n", - " print()" + "print(SYSTEM_PROMPT)" ] }, { "cell_type": "code", - "execution_count": 30, - "id": "b04a0485", + "execution_count": 74, + "id": "3eee4d7b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "match_text: 5] 2 HNSW HNSW (Hierarchical Navigable S\n", - "Duplicate parent chunk text found.\n" + "MODEL:llama3:latest, FORMAT:gguf, PARAMETER_SIZE:8B, QUANTIZATION_LEVEL:Q4_0, \n", + "\n" ] } ], "source": [ - "unique_tuples = []\n", - "parent_chunks = []\n", - "\n", - "# Loop through the search results and keep only unique parent chunks.\n", - "i = 0\n", - "for context, item in zip(contexts, context_metadata):\n", - " # Extract doc_index and start_index from each item.\n", - " doc_index = item['doc_index']\n", - " start_index = item['start_index']\n", - " \n", - " # Create a tuple of (doc_index, start_index).\n", - " current_tuple = (doc_index, start_index)\n", - " \n", - " # Initialize current tuple is unique.\n", - " is_unique = True\n", - " \n", - " # Check if the start_index is within 2000 of any start_index in unique_tuples.\n", - " for unique_tuple in unique_tuples:\n", - " if unique_tuple[0] == current_tuple[0] \\\n", - " and abs(unique_tuple[1]-current_tuple[1])<=MAX_SEQ_LENGTH:\n", - " is_unique = False\n", - " print(\"Duplicate parent chunk text found.\")\n", - " break\n", - " \n", - " # Process unique tuples.\n", - " if is_unique:\n", - " # Append it to the list of unique tuples\n", - " unique_tuples.append(current_tuple)\n", - "\n", - " # Get and clean parent chunk text.\n", - " match_text = context\n", - " temp_index = len(match_text) // 2\n", - " match_text = match_text[temp_index:temp_index+40]\n", - " print(f\"match_text: {match_text}\")\n", - " match_text = \"2 HNSW HNSW (Hierarchical Navigable\"\n", - "\n", - " parent_text = docs[current_tuple[0]].page_content\n", - " parent_text = clean_text(parent_text)\n", - " temp_index = parent_text.find(match_text)\n", + "# !python -m pip install ollama\n", + "import ollama\n", "\n", - " if temp_index != -1:\n", - " start_index = max(0, temp_index-200)\n", - " end_index = min(len(parent_text), temp_index+MAX_SEQ_LENGTH-236)\n", - " parent_chunk_text = parent_text[start_index:end_index]\n", - " parent_chunks.append(parent_chunk_text)\n", - " else:\n", - " print(\"Text not found.\")\n", + "# Verify details which model you are running.\n", + "ollama_llama3 = ollama.list()['models'][0]\n", "\n", - " # # TODO: comment out debugging check if parents contain retrieved chunks.\n", - " # print(f\"Unique tuple: {current_tuple}\")\n", - " # print(\"Parent Chunk text: \")\n", - " # pprint.pprint(parent_chunks[i])\n", - " # print()\n", + "# Print the model details.\n", + "keys = ['format', 'parameter_size', 'quantization_level']\n", + "print(f\"MODEL:{ollama.list()['models'][0]['name']}\", end=\", \")\n", + "for key in keys:\n", + " print(f\"{str.upper(key)}:{ollama.list()['models'][0]['details'].get(key, 'Key not found in dictionary')}\", end=\", \")\n", + "print(end=\"\\n\\n\")" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "574da045", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Answer: According to the provided text, there isn't a specific mention of what the default AUTOINDEX or vector field distance metric are in Milvus.\n", + "\n", + "However, based on other documentation available for Milvus (https://milvus.io/docs/), it appears that:\n", + "\n", + "* The default index type is IVF_PQ.\n", + "* The default distance metric used by this index is Euclidean Distance (L2).\n", + "\n", + "Please note that these defaults might be subject to change or may have changed since the provided text was written. For more accurate and up-to-date information, I recommend consulting Milvus' official documentation or contacting their support team directly. \n", + "\n", + "\n", + "ollama_llama3_time: 14.61 seconds\n" + ] + } + ], + "source": [ + "# Send the question to llama 3 chat.\n", + "start_time = time.time()\n", + "response = ollama.chat(\n", + " messages=[\n", + " {\"role\": \"system\", \"content\": SYSTEM_PROMPT,},\n", + " \n", + " {\"role\": \"user\", \"content\": f\"question: {SAMPLE_QUESTION}\",}\n", + " ],\n", + " model='llama3',\n", + " stream=False,\n", + " options={\"temperature\": TEMPERATURE, \"seed\": RANDOM_SEED,\n", + " \"top_p\": TOP_P, \n", + " # \"max_tokens\": MAX_TOKENS,\n", + " \"frequency_penalty\": FREQUENCY_PENALTY}\n", + ")\n", + "ollama_llama3_time = time.time() - start_time\n", "\n", - " i += 1" + "# Print all answers in the response.\n", + "semantic_summary = \"\"\n", + "semantic_summary += response['message']['content'] + \" \"\n", + "print(f\"Answer: {semantic_summary}\")\n", + "print(\"\\n\")\n", + "print(f\"ollama_llama3_time: {format(ollama_llama3_time, '.2f')} seconds\")" ] }, { @@ -1468,29 +1459,27 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 38, "id": "eb4c323f", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Length long text to summarize: 1500\n" - ] - } - ], + "outputs": [], "source": [ "# STEP 8. LLM-GENERATED ANSWER TO THE QUESTION, GROUNDED BY RETRIEVED CONTEXT.\n", "\n", + "# Separate all the sources together by comma.\n", + "source_combined = []\n", + "source_combined = ' '.join(reversed(sources))\n", + "\n", "# Separate all the context together by space.\n", "# Lance Martin, LangChain, says put best contexts at end.\n", - "# contexts_combined = ' '.join(reversed(contexts))\n", - "contexts_combined = ' '.join(reversed(parent_chunks))\n", + "contexts_combined = ' '.join(reversed(contexts))\n", "\n", - "# Separate all the sources together by comma.\n", - "source_combined = ' '.join(reversed(sources))\n", - "print(f\"Length long text to summarize: {len(contexts_combined)}\")\n", + "# # Alternatively use the parent (bigger) chunk.\n", + "# contexts_combined = parent_results[0].page_content\n", + "\n", + "# # # Alternatively use the summary.\n", + "# contexts_combined = semantic_summary\n", + "# print(f\"Length long text to summarize: {len(contexts_combined)}\")\n", "\n", "# Define temperature for the LLM and random seed.\n", "TEMPERATURE = 0.1\n", @@ -1502,7 +1491,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 39, "id": "5fc90b64", "metadata": {}, "outputs": [ @@ -1510,7 +1499,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Length prompt: 1948\n" + "Length prompt: 1465\n" ] } ], @@ -1519,7 +1508,8 @@ "the user's question. Second, only if the context is strongly relevant, \n", "answer the question using the context. Otherwise, if the context is not \n", "strongly relevant, answer the question without using the context. \n", - "Be clear, concise, relevant. Answer with fewer than 2 sentences and cite unique sources.\n", + "Be clear, concise, relevant. Answer clearly, easy to understand, \n", + "fewer than 2 sentences, and cite unique sources.\n", "Grounding sources: {source_combined}\n", "Context: {contexts_combined}\n", "\"\"\"\n", @@ -1528,13 +1518,42 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 40, "id": "6c31718c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "('First, check if the Context below is relevant to \\n'\n", + " \"the user's question. Second, only if the context is strongly relevant, \\n\"\n", + " 'answer the question using the context. Otherwise, if the context is not \\n'\n", + " 'strongly relevant, answer the question without using the context. \\n'\n", + " 'Be clear, concise, relevant. Answer clearly, easy to understand, \\n'\n", + " 'fewer than 2 sentences, and cite unique sources.\\n'\n", + " 'Grounding sources: https://milvus.io/docs/index.md\\n'\n", + " 'Context: at the cost of increased search time.[1, 65535]2 Common search '\n", + " 'Range search HNSW (Hierarchical Navigable Small World Graph) is a '\n", + " 'graph-based indexing algorithm. It builds a multi-layer navigation structure '\n", + " 'for an image according to certain rules. In this structure, the upper layers '\n", + " 'are more sparse and the distances between nodes are farther; the lower '\n", + " 'layers are denser and the distances between nodes are closer. The search '\n", + " 'starts from the uppermost layer, finds the node closest to the target in '\n", + " 'this layer, the node closest to the target in this layer, and then enters '\n", + " 'the next layer to begin another search. After multiple iterations, it can '\n", + " 'quickly approach the target position. In order to improve performance, HNSW '\n", + " 'limits the maximum degree of nodes on each layer of the graph to M. In '\n", + " 'addition, you can use efConstruction (when building index) or ef (when '\n", + " 'searching targets) to specify a search range. ParameterDescriptionRange MM '\n", + " 'defines tha maximum number of outgoing connections in the graph. Higher M '\n", + " 'leads to\\n')\n" + ] + } + ], "source": [ - "# # Inspect the prompt.\n", - "# pprint.pprint(SYSTEM_PROMPT)" + "# Inspect the prompt.\n", + "pprint.pprint(SYSTEM_PROMPT)" ] }, { @@ -1571,7 +1590,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 41, "id": "0edc67e3", "metadata": {}, "outputs": [ @@ -1591,6 +1610,7 @@ "# Verify details which model you are running.\n", "ollama_llama3 = ollama.list()['models'][0]\n", "\n", + "\n", "# Print the model details.\n", "keys = ['format', 'parameter_size', 'quantization_level']\n", "print(f\"MODEL:{ollama.list()['models'][0]['name']}\", end=\", \")\n", @@ -1601,7 +1621,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 42, "id": "76042c9a", "metadata": {}, "outputs": [ @@ -1609,19 +1629,16 @@ "name": "stdout", "output_type": "stream", "text": [ - "(\"According to the context and documentation [1], here's what the parameters \"\n", - " 'for Hierarchical Navigable Small World Graph (HNSW) mean: **M**: Maximum '\n", - " 'number of outgoing connections in each layer of the graph. A higher M leads '\n", - " 'to a better accuracy at the cost of increased search time. Range: (2, '\n", - " '2048) **efConstruction**: Controls the trade-off between index build speed '\n", - " 'and quality. Increasing this parameter may improve index quality but also '\n", - " 'increases indexing time. Range: (1, int_max) **ef**: Parameter controlling '\n", - " 'query time vs. recall rate during searching targets in HNSW indexes. No '\n", - " \"specific range is mentioned for ef, as it depends on the application's \"\n", - " 'requirements and constraints. These parameters allow you to fine-tune your '\n", - " 'HNSW index for optimal performance based on your use case needs [1]. '\n", - " 'References: [1] https://milvus.io/docs/index.md (Milvus documentation)')\n", - "ollama_llama3_time: 10.43 seconds\n" + "In Hierarchical Navigable Small World Graph (HNSW), there are two main parameters that control its behavior:\n", + "\n", + "1. **M** (`max_degree`): This parameter defines the maximum number of outgoing connections in each layer of the graph. A higher value means more nodes can be connected to a single node, which increases the density and searchability of the index.\n", + "2. **ef** (Efficiency Factor): This is used during both indexing construction and target searching. It controls how much information from previous searches should be reused when traversing through layers.\n", + "\n", + "In other words:\n", + "\n", + "* `M` determines how many \"neighbors\" each node can have, which affects the graph's density and search efficiency.\n", + "* `ef` adjusts the trade-off between precision (search accuracy) and recall (completeness of results). A higher value means more information is reused from previous searches, making it faster but potentially less accurate.\n", + "ollama_llama3_time: 10.23 seconds\n" ] } ], @@ -1631,6 +1648,7 @@ "response = ollama.chat(\n", " messages=[\n", " {\"role\": \"system\", \"content\": SYSTEM_PROMPT,},\n", + " \n", " {\"role\": \"user\", \"content\": f\"question: {SAMPLE_QUESTION}\",}\n", " ],\n", " model='llama3',\n", @@ -1642,7 +1660,7 @@ ")\n", "\n", "ollama_llama3_time = time.time() - start_time\n", - "pprint.pprint(response['message']['content'].replace('\\n', ' '))\n", + "print(response['message']['content'])\n", "print(f\"ollama_llama3_time: {format(ollama_llama3_time, '.2f')} seconds\")" ] }, @@ -1656,7 +1674,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": null, "id": "59f95f52", "metadata": {}, "outputs": [], @@ -1667,26 +1685,10 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": null, "id": "1ef7529f", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "('According to the provided context, the parameters for HNSW (Hierarchical '\n", - " 'Navigable Small World Graph) are: * M: defines the maximum number of '\n", - " 'outgoing connections in the graph. Higher M leads to higher accuracy and '\n", - " 'longer run time at fixed ef/efConstruction. * efConstruction: controls index '\n", - " 'search speed/build speed tradeoff. Increasing this parameter may enhance '\n", - " 'index quality, but it also tends to lengthen indexing time. * ef: Parameter '\n", - " 'controlling query time/recall rate tradeoff. These parameters help balance '\n", - " 'between search efficiency and recall rate in HNSW indexing algorithm.')\n", - "llama3_anyscale_endpoints_time: 2.54 seconds\n" - ] - } - ], + "outputs": [], "source": [ "# Call Anyscale enpoint using OpenAI API.\n", "import openai\n", @@ -1724,26 +1726,10 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": null, "id": "309d7025", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "('According to the context, the parameters for HNSW (Hierarchical Navigable '\n", - " 'Small World Graph) are: * M: defines the maximum number of outgoing '\n", - " 'connections in the graph. Higher M leads to higher accuracy and longer run '\n", - " 'time at fixed ef/efConstruction. * efConstruction: controls index search '\n", - " 'speed/build speed tradeoff. Increasing this parameter may enhance index '\n", - " 'quality, but it also tends to lengthen indexing time. * ef: Parameter '\n", - " 'controlling query time. These parameters can be adjusted to balance between '\n", - " 'accuracy and efficiency in HNSW searches.')\n", - "llama3_octai_endpoints_time: 1.70 seconds\n" - ] - } - ], + "outputs": [], "source": [ "# Also try OctoAI\n", "# !python -m pip install octoai\n", @@ -1785,27 +1771,10 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": null, "id": "e6b94795", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "('According to the context, the parameters for HNSW (Hierarchical Navigable '\n", - " 'Small World Graph) are: * M: defines the maximum number of outgoing '\n", - " 'connections in the graph, with higher M leading to higher accuracy and '\n", - " 'longer run time at fixed ef/efConstruction. * efConstruction: controls the '\n", - " 'index search speed/build speed tradeoff, with increasing efConstruction '\n", - " 'enhancing index quality but lengthening indexing time. * ef: controls query '\n", - " 'time/search time, with higher ef leading to faster search but potentially '\n", - " 'lower accuracy. These parameters can be adjusted to balance accuracy, '\n", - " 'search speed, and indexing time.')\n", - "llama3_groq_endpoints_time: 0.48 seconds\n" - ] - } - ], + "outputs": [], "source": [ "# Also try Groq endpoints\n", "# !python -m pip install groq\n", @@ -1859,7 +1828,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": null, "id": "edf66e04", "metadata": {}, "outputs": [], @@ -1879,7 +1848,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": null, "id": "c87b8428", "metadata": {}, "outputs": [], @@ -1948,30 +1917,10 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": null, "id": "e6b16264", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(' The parameters for HNSW, a graph-based indexing algorithm, are as follows: '\n", - " '1. M: Defines the maximum number of outgoing connections in the graph. A '\n", - " 'higher M leads to higher accuracy and longer run time, with a suggested '\n", - " 'range of (2, 2048). 2. efConstruction: Controls the index search speed/build '\n", - " 'speed tradeoff during indexing. Increasing this parameter may enhance index '\n", - " 'quality but also tends to lengthen the indexing time; it accepts values from '\n", - " '1 to int\\\\_max. 3. ef: Controls query time; it is not specified what '\n", - " 'int\\\\_max is in this context but can be any positive integer value '\n", - " '(including zero). This parameter affects query time/accuracy tradeoff during '\n", - " 'target searches within an existing HNSW structure '\n", - " '([1](https://milvus.io/docs/v0.7.0/parameters_overview_HNSW%20index%20type_(standalone).md), '\n", - " '[2](https://www.pinecone-database.com/docs/parameters-and-properties/#hnsw)).')\n", - "mixtral_anyscale_endpoints_time: 4.01 seconds\n" - ] - } - ], + "outputs": [], "source": [ "# Call Anyscale enpoint using OpenAI API.\n", "import openai\n", @@ -2036,8 +1985,8 @@ "the user's question. Second, only if the context is strongly relevant, \n", "answer the question using the context. Otherwise, if the context is not \n", "strongly relevant, answer the question without using the context.\n", - "Be clear, concise, relevant. Answer with fewer than 4 sentences \n", - "and cite unique grounding sources.\n", + "Be clear, concise, relevant. Answer clearly, easy to understand, \n", + "fewer than 4 sentences, and cite unique grounding sources.\n", "Grounding sources: {source_combined}\n", "Context: {contexts_combined}\n", "\"\"\"" @@ -2046,6 +1995,45 @@ { "cell_type": "code", "execution_count": 44, + "id": "ad653053", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "('First, check if the Context below is relevant to \\n'\n", + " \"the user's question. Second, only if the context is strongly relevant, \\n\"\n", + " 'answer the question using the context. Otherwise, if the context is not \\n'\n", + " 'strongly relevant, answer the question without using the context.\\n'\n", + " 'Be clear, concise, relevant. Answer clearly, easy to understand, \\n'\n", + " 'fewer than 4 sentences, and cite unique grounding sources.\\n'\n", + " 'Grounding sources: https://milvus.io/docs/index.md\\n'\n", + " 'Context: at the cost of increased search time.[1, 65535]2 Common search '\n", + " 'Range search HNSW (Hierarchical Navigable Small World Graph) is a '\n", + " 'graph-based indexing algorithm. It builds a multi-layer navigation structure '\n", + " 'for an image according to certain rules. In this structure, the upper layers '\n", + " 'are more sparse and the distances between nodes are farther; the lower '\n", + " 'layers are denser and the distances between nodes are closer. The search '\n", + " 'starts from the uppermost layer, finds the node closest to the target in '\n", + " 'this layer, the node closest to the target in this layer, and then enters '\n", + " 'the next layer to begin another search. After multiple iterations, it can '\n", + " 'quickly approach the target position. In order to improve performance, HNSW '\n", + " 'limits the maximum degree of nodes on each layer of the graph to M. In '\n", + " 'addition, you can use efConstruction (when building index) or ef (when '\n", + " 'searching targets) to specify a search range. ParameterDescriptionRange MM '\n", + " 'defines tha maximum number of outgoing connections in the graph. Higher M '\n", + " 'leads to\\n')\n" + ] + } + ], + "source": [ + "pprint.pprint(SYSTEM_PROMPT)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, "id": "76a62feb", "metadata": {}, "outputs": [ @@ -2054,18 +2042,20 @@ "output_type": "stream", "text": [ "Question: What do the parameters for HNSW mean?\n", - "('Answer: The parameters for HNSW (Hierarchical Navigable Small World Graph) '\n", - " 'are M and efConstruction for index building, and ef for searching targets. \\n'\n", - " '- M defines the maximum number of outgoing connections in the graph, '\n", - " 'affecting accuracy and runtime.\\n'\n", - " '- efConstruction controls search speed/build speed tradeoff during index '\n", - " 'construction.\\n'\n", - " '- ef is a parameter controlling query time/search range. \\n'\n", - " 'These parameters help optimize performance by balancing accuracy, search '\n", - " 'time, and recall rate. [Source: https://milvus.io/docs/index.md]')\n", + "('Answer: In the context of HNSW (Hierarchical Navigable Small World Graph), '\n", + " 'the parameters are as follows:\\n'\n", + " '- M: It defines the maximum number of outgoing connections in the graph. A '\n", + " 'higher M value leads to increased recall but also increases search time.\\n'\n", + " '- efConstruction: This parameter is used when building an index and '\n", + " 'specifies a search range for constructing the graph.\\n'\n", + " '- ef: This parameter is used when searching for targets and specifies a '\n", + " 'search range to find nearest neighbors efficiently.\\n'\n", + " '\\n'\n", + " 'Source:\\n'\n", + " 'https://milvus.io/docs/index.md')\n", "\n", "\n", - "chatgpt_3.5_turbo_time: 2.45253\n" + "chatgpt_3.5_turbo_time: 1.98639\n" ] } ], @@ -2154,7 +2144,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": null, "id": "5d0c2299", "metadata": {}, "outputs": [], @@ -2164,7 +2154,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 76, "id": "e1097990", "metadata": {}, "outputs": [ @@ -2191,8 +2181,12 @@ " \n", " Question\n", " ground_truth_answer\n", - " Custom_RAG_context\n", - " simple_context\n", + " naive_context_k_2\n", + " html_context_k_2\n", + " parent_context_k1\n", + " html_context_k_2_summary\n", + " semantic_context_k2_summary\n", + " parent_context_k1_text-embedding-3-small\n", " Custom_RAG_answer\n", " llama3_ollama_answer\n", " llama3_anyscale_answer\n", @@ -2206,10 +2200,14 @@ " 0\n", " What do the parameters for HNSW mean?\n", " * M: maximum degree, or number of connections ...\n", - " HNSW (Hierarchical Navigable Small World Graph...\n", " In order to improve performance, HNSW limits t...\n", - " - M defines the maximum number of outgoing con...\n", - " 1. **M**: Maximum degree of nodes on each laye...\n", + " the node closest to the target in this layer, ...\n", + " Search parameters ParameterDescriptionRangeDef...\n", + " * `M`: defines maximum number of outgoing conn...\n", + " The three main parameters for Hierarchical Nav...\n", + " In order to improve performance, HNSW limits t...\n", + " In the context of HNSW (Hierarchical Navigabl...\n", + " * **M** controls the graph's density and compu...\n", " * M: defines the maximum number of outgoing co...\n", " * M: defines the maximum number of outgoing co...\n", " * M: defines the maximum number of outgoing co...\n", @@ -2219,8 +2217,12 @@ " 1\n", " What are good default values for HNSW paramete...\n", " M=16, efConstruction=32, 
ef=32\n", - " HNSW (Hierarchical Navigable Small World Graph...\n", - " Why Milvus Docs Tutorials Tools Blog Community...\n", + " When conducting searches, note that you can se...\n", + " first. When conducting searches, note that you...\n", + " between the target vector and the clustering c...\n", + " * `nlist`: Set to a moderate value such as 128...\n", + " For an index built on top of a dataset with ap...\n", + " Index building parameters Parameter Descriptio...\n", " - M = 32 
- efConstruction = 100\n", " M=16\\nefConstruction=128
ef=64\n", " * M: 16 
* efConstruction: 100 
* ef: top_k\n", @@ -2232,8 +2234,12 @@ " 2\n", " What does nlist vs nprobe mean in ivf_flat?\n", " # nlist: controls how the vector data is part...\n", - " IVF_FLAT divides vector data into nlist cluste...\n", - " `nlist` in IVF-Flat represents the number of c...\n", + " By adjusting nprobe, an ideal balance between ...\n", + " FLAT index and IVF_FLAT index? IVF_FLAT index ...\n", + " FLAT index and IVF_FLAT index? IVF_FLAT index ...\n", + " * `NLIST`: controls how many initial \"buckets\"...\n", + " In IVF_FLAT, `nlist` (short for \"number of lis...\n", + " By adjusting nprobe, an ideal balance between ...\n", " - nlist in IVF_FLAT refers to the number of cl...\n", " - `nlist` refers to the number of cluster unit...\n", " - `nlist` refers to the number of cluster unit...\n", @@ -2245,8 +2251,12 @@ " 3\n", " What is the default AUTOINDEX index and vector...\n", " Index type = HNSW and distance metric=IP Inner...\n", - " \"AUTOINDEX\", metric_type: \"COSINE\", i...\n", - " Index parameters Index parameters dictate how ...\n", + " Leveraging the metadata stored in an index fil...\n", + " during searches or queries. Milvus provides se...\n", + " during searches or queries. Milvus provides se...\n", + " According to the provided text, there are no s...\n", + " According to the provided text, there isn't a ...\n", + " Why Milvus Docs Tutorials Tools Blog Community...\n", " The default AUTOINDEX index in Milvus is IVF_S...\n", " The default `AUTOINDEX` index uses a combinati...\n", " According to the Milvus documentation, the def...\n", @@ -2272,27 +2282,51 @@ "2 # nlist: controls how the vector data is part... \n", "3 Index type = HNSW and distance metric=IP Inner... \n", "\n", - " Custom_RAG_context \\\n", - "0 HNSW (Hierarchical Navigable Small World Graph... \n", - "1 HNSW (Hierarchical Navigable Small World Graph... \n", - "2 IVF_FLAT divides vector data into nlist cluste... \n", - "3 \"AUTOINDEX\", metric_type: \"COSINE\", i... \n", + " naive_context_k_2 \\\n", + "0 In order to improve performance, HNSW limits t... \n", + "1 When conducting searches, note that you can se... \n", + "2 By adjusting nprobe, an ideal balance between ... \n", + "3 Leveraging the metadata stored in an index fil... \n", + "\n", + " html_context_k_2 \\\n", + "0 the node closest to the target in this layer, ... \n", + "1 first. When conducting searches, note that you... \n", + "2 FLAT index and IVF_FLAT index? IVF_FLAT index ... \n", + "3 during searches or queries. Milvus provides se... \n", + "\n", + " parent_context_k1 \\\n", + "0 Search parameters ParameterDescriptionRangeDef... \n", + "1 between the target vector and the clustering c... \n", + "2 FLAT index and IVF_FLAT index? IVF_FLAT index ... \n", + "3 during searches or queries. Milvus provides se... \n", "\n", - " simple_context \\\n", + " html_context_k_2_summary \\\n", + "0 * `M`: defines maximum number of outgoing conn... \n", + "1 * `nlist`: Set to a moderate value such as 128... \n", + "2 * `NLIST`: controls how many initial \"buckets\"... \n", + "3 According to the provided text, there are no s... \n", + "\n", + " semantic_context_k2_summary \\\n", + "0 The three main parameters for Hierarchical Nav... \n", + "1 For an index built on top of a dataset with ap... \n", + "2 In IVF_FLAT, `nlist` (short for \"number of lis... \n", + "3 According to the provided text, there isn't a ... \n", + "\n", + " parent_context_k1_text-embedding-3-small \\\n", "0 In order to improve performance, HNSW limits t... \n", - "1 Why Milvus Docs Tutorials Tools Blog Community... \n", - "2 `nlist` in IVF-Flat represents the number of c... \n", - "3 Index parameters Index parameters dictate how ... \n", + "1 Index building parameters Parameter Descriptio... \n", + "2 By adjusting nprobe, an ideal balance between ... \n", + "3 Why Milvus Docs Tutorials Tools Blog Community... \n", "\n", " Custom_RAG_answer \\\n", - "0 - M defines the maximum number of outgoing con... \n", + "0 In the context of HNSW (Hierarchical Navigabl... \n", "1 - M = 32 \n", "- efConstruction = 100 \n", "2 - nlist in IVF_FLAT refers to the number of cl... \n", "3 The default AUTOINDEX index in Milvus is IVF_S... \n", "\n", " llama3_ollama_answer \\\n", - "0 1. **M**: Maximum degree of nodes on each laye... \n", + "0 * **M** controls the graph's density and compu... \n", "1 M=16\\nefConstruction=128\n", "ef=64 \n", "2 - `nlist` refers to the number of cluster unit... \n", @@ -2370,7 +2404,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 81, "id": "8ae8d2b2", "metadata": {}, "outputs": [ @@ -2392,7 +2426,49 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1974f8a4724748cf98ff2f22e1341292", + "model_id": "dc8cc97274534e54b258fb08e9d52819", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Evaluating: 0%| | 0/8 [00:00\n", " 0\n", " What do the parameters for HNSW mean?\n", - " [HNSW (Hierarchical Navigable Small World Grap...\n", - " - M defines the maximum number of outgoing con...\n", + " [In order to improve performance, HNSW limits ...\n", + " In the context of HNSW (Hierarchical Navigabl...\n", " * M: maximum degree, or number of connections ...\n", - " 1.0\n", + " 1.000000\n", " 1.0\n", " 1.000000\n", - " Custom_RAG_context\n", + " naive_context_k_2\n", " \n", " \n", " 1\n", " What are good default values for HNSW paramete...\n", - " [HNSW (Hierarchical Navigable Small World Grap...\n", + " [When conducting searches, note that you can s...\n", " - M = 32 
- efConstruction = 100\n", " M=16, efConstruction=32, 
ef=32\n", + " 0.333333\n", " 1.0\n", - " 1.0\n", - " 1.000000\n", - " Custom_RAG_context\n", + " 0.500000\n", + " naive_context_k_2\n", " \n", " \n", " 2\n", " What does nlist vs nprobe mean in ivf_flat?\n", - " [IVF_FLAT divides vector data into nlist clust...\n", + " [By adjusting nprobe, an ideal balance between...\n", " - nlist in IVF_FLAT refers to the number of cl...\n", " # nlist: controls how the vector data is part...\n", - " 0.5\n", - " 1.0\n", " 0.666667\n", - " Custom_RAG_context\n", + " 1.0\n", + " 0.800000\n", + " naive_context_k_2\n", " \n", " \n", " 3\n", " What is the default AUTOINDEX index and vector...\n", - " [\"AUTOINDEX\", metric_type: \"COSINE\", ...\n", + " [Leveraging the metadata stored in an index fi...\n", " The default AUTOINDEX index in Milvus is IVF_S...\n", " Index type = HNSW and distance metric=IP Inner...\n", - " 0.0\n", - " 0.0\n", " 0.000000\n", - " Custom_RAG_context\n", + " 1.0\n", + " 0.000000\n", + " naive_context_k_2\n", " \n", " \n", " 4\n", " What do the parameters for HNSW mean?\n", - " [In order to improve performance, HNSW limits ...\n", - " - M defines the maximum number of outgoing con...\n", + " [the node closest to the target in this layer,...\n", + " In the context of HNSW (Hierarchical Navigabl...\n", " * M: maximum degree, or number of connections ...\n", - " 1.0\n", + " 1.000000\n", " 1.0\n", " 1.000000\n", - " simple_context\n", + " html_context_k_2\n", " \n", " \n", " 5\n", " What are good default values for HNSW paramete...\n", - " [Why Milvus Docs Tutorials Tools Blog Communit...\n", + " [first. When conducting searches, note that yo...\n", " - M = 32 
- efConstruction = 100\n", " M=16, efConstruction=32, 
ef=32\n", - " 0.0\n", + " 0.333333\n", " 1.0\n", - " 0.000000\n", - " simple_context\n", + " 0.500000\n", + " html_context_k_2\n", " \n", " \n", " 6\n", " What does nlist vs nprobe mean in ivf_flat?\n", - " [`nlist` in IVF-Flat represents the number of ...\n", + " [FLAT index and IVF_FLAT index? IVF_FLAT index...\n", " - nlist in IVF_FLAT refers to the number of cl...\n", " # nlist: controls how the vector data is part...\n", - " 0.5\n", + " 0.500000\n", " 1.0\n", " 0.666667\n", - " simple_context\n", + " html_context_k_2\n", " \n", " \n", " 7\n", " What is the default AUTOINDEX index and vector...\n", - " [Index parameters Index parameters dictate how...\n", + " [during searches or queries. Milvus provides s...\n", " The default AUTOINDEX index in Milvus is IVF_S...\n", " Index type = HNSW and distance metric=IP Inner...\n", - " 0.0\n", + " 0.000000\n", + " 1.0\n", + " 0.000000\n", + " html_context_k_2\n", + " \n", + " \n", + " 8\n", + " What do the parameters for HNSW mean?\n", + " [Search parameters ParameterDescriptionRangeDe...\n", + " In the context of HNSW (Hierarchical Navigabl...\n", + " * M: maximum degree, or number of connections ...\n", + " 1.000000\n", + " 1.0\n", + " 1.000000\n", + " parent_context_k1\n", + " \n", + " \n", + " 9\n", + " What are good default values for HNSW paramete...\n", + " [between the target vector and the clustering ...\n", + " - M = 32 
- efConstruction = 100\n", + " M=16, efConstruction=32, 
ef=32\n", + " 0.000000\n", + " 1.0\n", + " 0.000000\n", + " parent_context_k1\n", + " \n", + " \n", + " 10\n", + " What does nlist vs nprobe mean in ivf_flat?\n", + " [FLAT index and IVF_FLAT index? IVF_FLAT index...\n", + " - nlist in IVF_FLAT refers to the number of cl...\n", + " # nlist: controls how the vector data is part...\n", + " 0.500000\n", + " 1.0\n", + " 0.666667\n", + " parent_context_k1\n", + " \n", + " \n", + " 11\n", + " What is the default AUTOINDEX index and vector...\n", + " [during searches or queries. Milvus provides s...\n", + " The default AUTOINDEX index in Milvus is IVF_S...\n", + " Index type = HNSW and distance metric=IP Inner...\n", + " 0.000000\n", + " 1.0\n", + " 0.000000\n", + " parent_context_k1\n", + " \n", + " \n", + " 12\n", + " What do the parameters for HNSW mean?\n", + " [* `M`: defines maximum number of outgoing con...\n", + " In the context of HNSW (Hierarchical Navigabl...\n", + " * M: maximum degree, or number of connections ...\n", + " 1.000000\n", + " 1.0\n", + " 1.000000\n", + " html_context_k_2_summary\n", + " \n", + " \n", + " 13\n", + " What are good default values for HNSW paramete...\n", + " [* `nlist`: Set to a moderate value such as 12...\n", + " - M = 32 
- efConstruction = 100\n", + " M=16, efConstruction=32, 
ef=32\n", + " 0.000000\n", + " 1.0\n", + " 0.000000\n", + " html_context_k_2_summary\n", + " \n", + " \n", + " 14\n", + " What does nlist vs nprobe mean in ivf_flat?\n", + " [* `NLIST`: controls how many initial \"buckets...\n", + " - nlist in IVF_FLAT refers to the number of cl...\n", + " # nlist: controls how the vector data is part...\n", + " 0.500000\n", " 1.0\n", + " 0.666667\n", + " html_context_k_2_summary\n", + " \n", + " \n", + " 15\n", + " What is the default AUTOINDEX index and vector...\n", + " [According to the provided text, there are no ...\n", + " The default AUTOINDEX index in Milvus is IVF_S...\n", + " Index type = HNSW and distance metric=IP Inner...\n", + " 0.000000\n", + " 1.0\n", + " 0.000000\n", + " html_context_k_2_summary\n", + " \n", + " \n", + " 16\n", + " What do the parameters for HNSW mean?\n", + " [The three main parameters for Hierarchical Na...\n", + " In the context of HNSW (Hierarchical Navigabl...\n", + " * M: maximum degree, or number of connections ...\n", + " 1.000000\n", + " 1.0\n", + " 1.000000\n", + " semantic_context_k2_summary\n", + " \n", + " \n", + " 17\n", + " What are good default values for HNSW paramete...\n", + " [For an index built on top of a dataset with a...\n", + " - M = 32 
- efConstruction = 100\n", + " M=16, efConstruction=32, 
ef=32\n", + " 0.000000\n", + " 1.0\n", + " 0.000000\n", + " semantic_context_k2_summary\n", + " \n", + " \n", + " 18\n", + " What does nlist vs nprobe mean in ivf_flat?\n", + " [In IVF_FLAT, `nlist` (short for \"number of li...\n", + " - nlist in IVF_FLAT refers to the number of cl...\n", + " # nlist: controls how the vector data is part...\n", + " 0.500000\n", + " 1.0\n", + " 0.666667\n", + " semantic_context_k2_summary\n", + " \n", + " \n", + " 19\n", + " What is the default AUTOINDEX index and vector...\n", + " [According to the provided text, there isn't a...\n", + " The default AUTOINDEX index in Milvus is IVF_S...\n", + " Index type = HNSW and distance metric=IP Inner...\n", " 0.000000\n", - " simple_context\n", + " 0.0\n", + " 0.000000\n", + " semantic_context_k2_summary\n", " \n", " \n", "\n", "" ], "text/plain": [ - " question \\\n", - "0 What do the parameters for HNSW mean? \n", - "1 What are good default values for HNSW paramete... \n", - "2 What does nlist vs nprobe mean in ivf_flat? \n", - "3 What is the default AUTOINDEX index and vector... \n", - "4 What do the parameters for HNSW mean? \n", - "5 What are good default values for HNSW paramete... \n", - "6 What does nlist vs nprobe mean in ivf_flat? \n", - "7 What is the default AUTOINDEX index and vector... \n", + " question \\\n", + "0 What do the parameters for HNSW mean? \n", + "1 What are good default values for HNSW paramete... \n", + "2 What does nlist vs nprobe mean in ivf_flat? \n", + "3 What is the default AUTOINDEX index and vector... \n", + "4 What do the parameters for HNSW mean? \n", + "5 What are good default values for HNSW paramete... \n", + "6 What does nlist vs nprobe mean in ivf_flat? \n", + "7 What is the default AUTOINDEX index and vector... \n", + "8 What do the parameters for HNSW mean? \n", + "9 What are good default values for HNSW paramete... \n", + "10 What does nlist vs nprobe mean in ivf_flat? \n", + "11 What is the default AUTOINDEX index and vector... \n", + "12 What do the parameters for HNSW mean? \n", + "13 What are good default values for HNSW paramete... \n", + "14 What does nlist vs nprobe mean in ivf_flat? \n", + "15 What is the default AUTOINDEX index and vector... \n", + "16 What do the parameters for HNSW mean? \n", + "17 What are good default values for HNSW paramete... \n", + "18 What does nlist vs nprobe mean in ivf_flat? \n", + "19 What is the default AUTOINDEX index and vector... \n", "\n", - " contexts \\\n", - "0 [HNSW (Hierarchical Navigable Small World Grap... \n", - "1 [HNSW (Hierarchical Navigable Small World Grap... \n", - "2 [IVF_FLAT divides vector data into nlist clust... \n", - "3 [\"AUTOINDEX\", metric_type: \"COSINE\", ... \n", - "4 [In order to improve performance, HNSW limits ... \n", - "5 [Why Milvus Docs Tutorials Tools Blog Communit... \n", - "6 [`nlist` in IVF-Flat represents the number of ... \n", - "7 [Index parameters Index parameters dictate how... \n", + " contexts \\\n", + "0 [In order to improve performance, HNSW limits ... \n", + "1 [When conducting searches, note that you can s... \n", + "2 [By adjusting nprobe, an ideal balance between... \n", + "3 [Leveraging the metadata stored in an index fi... \n", + "4 [the node closest to the target in this layer,... \n", + "5 [first. When conducting searches, note that yo... \n", + "6 [FLAT index and IVF_FLAT index? IVF_FLAT index... \n", + "7 [during searches or queries. Milvus provides s... \n", + "8 [Search parameters ParameterDescriptionRangeDe... \n", + "9 [between the target vector and the clustering ... \n", + "10 [FLAT index and IVF_FLAT index? IVF_FLAT index... \n", + "11 [during searches or queries. Milvus provides s... \n", + "12 [* `M`: defines maximum number of outgoing con... \n", + "13 [* `nlist`: Set to a moderate value such as 12... \n", + "14 [* `NLIST`: controls how many initial \"buckets... \n", + "15 [According to the provided text, there are no ... \n", + "16 [The three main parameters for Hierarchical Na... \n", + "17 [For an index built on top of a dataset with a... \n", + "18 [In IVF_FLAT, `nlist` (short for \"number of li... \n", + "19 [According to the provided text, there isn't a... \n", "\n", - " answer \\\n", - "0 - M defines the maximum number of outgoing con... \n", - "1 - M = 32 \n", + " answer \\\n", + "0 In the context of HNSW (Hierarchical Navigabl... \n", + "1 - M = 32 \n", "- efConstruction = 100 \n", - "2 - nlist in IVF_FLAT refers to the number of cl... \n", - "3 The default AUTOINDEX index in Milvus is IVF_S... \n", - "4 - M defines the maximum number of outgoing con... \n", - "5 - M = 32 \n", + "2 - nlist in IVF_FLAT refers to the number of cl... \n", + "3 The default AUTOINDEX index in Milvus is IVF_S... \n", + "4 In the context of HNSW (Hierarchical Navigabl... \n", + "5 - M = 32 \n", + "- efConstruction = 100 \n", + "6 - nlist in IVF_FLAT refers to the number of cl... \n", + "7 The default AUTOINDEX index in Milvus is IVF_S... \n", + "8 In the context of HNSW (Hierarchical Navigabl... \n", + "9 - M = 32 \n", + "- efConstruction = 100 \n", + "10 - nlist in IVF_FLAT refers to the number of cl... \n", + "11 The default AUTOINDEX index in Milvus is IVF_S... \n", + "12 In the context of HNSW (Hierarchical Navigabl... \n", + "13 - M = 32 \n", + "- efConstruction = 100 \n", + "14 - nlist in IVF_FLAT refers to the number of cl... \n", + "15 The default AUTOINDEX index in Milvus is IVF_S... \n", + "16 In the context of HNSW (Hierarchical Navigabl... \n", + "17 - M = 32 \n", "- efConstruction = 100 \n", - "6 - nlist in IVF_FLAT refers to the number of cl... \n", - "7 The default AUTOINDEX index in Milvus is IVF_S... \n", + "18 - nlist in IVF_FLAT refers to the number of cl... \n", + "19 The default AUTOINDEX index in Milvus is IVF_S... \n", "\n", - " ground_truth context_recall \\\n", - "0 * M: maximum degree, or number of connections ... 1.0 \n", - "1 M=16, efConstruction=32, \n", - "ef=32 1.0 \n", - "2 # nlist: controls how the vector data is part... 0.5 \n", - "3 Index type = HNSW and distance metric=IP Inner... 0.0 \n", - "4 * M: maximum degree, or number of connections ... 1.0 \n", - "5 M=16, efConstruction=32, \n", - "ef=32 0.0 \n", - "6 # nlist: controls how the vector data is part... 0.5 \n", - "7 Index type = HNSW and distance metric=IP Inner... 0.0 \n", + " ground_truth context_recall \\\n", + "0 * M: maximum degree, or number of connections ... 1.000000 \n", + "1 M=16, efConstruction=32, \n", + "ef=32 0.333333 \n", + "2 # nlist: controls how the vector data is part... 0.666667 \n", + "3 Index type = HNSW and distance metric=IP Inner... 0.000000 \n", + "4 * M: maximum degree, or number of connections ... 1.000000 \n", + "5 M=16, efConstruction=32, \n", + "ef=32 0.333333 \n", + "6 # nlist: controls how the vector data is part... 0.500000 \n", + "7 Index type = HNSW and distance metric=IP Inner... 0.000000 \n", + "8 * M: maximum degree, or number of connections ... 1.000000 \n", + "9 M=16, efConstruction=32, \n", + "ef=32 0.000000 \n", + "10 # nlist: controls how the vector data is part... 0.500000 \n", + "11 Index type = HNSW and distance metric=IP Inner... 0.000000 \n", + "12 * M: maximum degree, or number of connections ... 1.000000 \n", + "13 M=16, efConstruction=32, \n", + "ef=32 0.000000 \n", + "14 # nlist: controls how the vector data is part... 0.500000 \n", + "15 Index type = HNSW and distance metric=IP Inner... 0.000000 \n", + "16 * M: maximum degree, or number of connections ... 1.000000 \n", + "17 M=16, efConstruction=32, \n", + "ef=32 0.000000 \n", + "18 # nlist: controls how the vector data is part... 0.500000 \n", + "19 Index type = HNSW and distance metric=IP Inner... 0.000000 \n", "\n", - " context_precision context_f1 evaluated \n", - "0 1.0 1.000000 Custom_RAG_context \n", - "1 1.0 1.000000 Custom_RAG_context \n", - "2 1.0 0.666667 Custom_RAG_context \n", - "3 0.0 0.000000 Custom_RAG_context \n", - "4 1.0 1.000000 simple_context \n", - "5 1.0 0.000000 simple_context \n", - "6 1.0 0.666667 simple_context \n", - "7 1.0 0.000000 simple_context " + " context_precision context_f1 evaluated \n", + "0 1.0 1.000000 naive_context_k_2 \n", + "1 1.0 0.500000 naive_context_k_2 \n", + "2 1.0 0.800000 naive_context_k_2 \n", + "3 1.0 0.000000 naive_context_k_2 \n", + "4 1.0 1.000000 html_context_k_2 \n", + "5 1.0 0.500000 html_context_k_2 \n", + "6 1.0 0.666667 html_context_k_2 \n", + "7 1.0 0.000000 html_context_k_2 \n", + "8 1.0 1.000000 parent_context_k1 \n", + "9 1.0 0.000000 parent_context_k1 \n", + "10 1.0 0.666667 parent_context_k1 \n", + "11 1.0 0.000000 parent_context_k1 \n", + "12 1.0 1.000000 html_context_k_2_summary \n", + "13 1.0 0.000000 html_context_k_2_summary \n", + "14 1.0 0.666667 html_context_k_2_summary \n", + "15 1.0 0.000000 html_context_k_2_summary \n", + "16 1.0 1.000000 semantic_context_k2_summary \n", + "17 1.0 0.000000 semantic_context_k2_summary \n", + "18 1.0 0.666667 semantic_context_k2_summary \n", + "19 0.0 0.000000 semantic_context_k2_summary " ] }, "metadata": {}, @@ -2708,9 +3022,11 @@ "\n", "elif EVALUATE_WHAT == 'CONTEXTS':\n", " pprint.pprint(scores)\n", - " percent_better = (scores[0]['Custom_RAG_context'] - scores[1]['simple_context']) \\\n", - " / scores[1]['simple_context'] * 100\n", - " print(f\"HTML chunking {np.round(percent_better,0)}% improvement over Simple chunking.\")\n", + " percent_better = (scores[0]['naive_context_k_2'] - scores[3]['html_context_k_2_summary']) \\\n", + " / scores[3]['html_context_k_2_summary'] * 100\n", + " # percent_better = (scores[0]['parent_context_k1'] - scores[1]['parent_context_k1_text-embedding-3-small']) \\\n", + " # / scores[1]['parent_context_k1_text-embedding-3-small'] * 100\n", + " print(f\"Chunking {np.round(percent_better,0)}% improvement.\")\n", "\n", "# Display the evaluation details.\n", "display(ragas_result)" @@ -2718,17 +3034,25 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": null, "id": "7c408624", "metadata": {}, "outputs": [], "source": [ - "####################################################\n", - "# Avg Context Precision htmlsplitter score = 0.67 (46% improvement)\n", - "# Avg Context Precision simple score = 0.46\n", + "########### CHANGE THE CHUNKING STRATEGY ###########\n", + "# F1-Score 'naive_context_k_2': 0.57 (36% improvement)\n", + "# F1-Score 'html_context_k_2': 0.54\n", + "# F1-Score 'parent_context_k1': 0.42\n", + "# F1-Score 'html_context_k_2_summary': 0.42\n", + "# F1-Score 'semantic_context_k2_summary': 0.42\n", "####################################################\n", "\n", + "########### CHANGE THE EMBEDDING MODEL #############\n", + "# F1-Score 'naive_context_k_2': 0.57 (27% improvement)\n", + "# F1-Score 'pnaive_context_k_2_text-embedding-3-small': 0.45\n", "####################################################\n", + "\n", + "############## CHANGE THE LLM ######################\n", "# Avg mistralai mixtral_8x7b_instruct score = 0.7031 (6% improvement over gpt-3.5-turbo)\n", "# Avg llama3_70b_anyscale_chat score = 0.6888\n", "# Avg llama3_70b_groq_instruct score = 0.6867\n", @@ -2740,47 +3064,21 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": null, "id": "d0e81e68", "metadata": {}, "outputs": [], "source": [ - "# Drop collection\n", - "# utility.drop_collection(COLLECTION_NAME)\n", - "mc.drop_collection(COLLECTION_NAME)" + "# Delete the Milvus collection and doc store.\n", + "del vectorstore, retriever, store" ] }, { "cell_type": "code", - "execution_count": 51, + "execution_count": null, "id": "c777937e", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Author: Christy Bergman\n", - "\n", - "Python implementation: CPython\n", - "Python version : 3.11.8\n", - "IPython version : 8.22.2\n", - "\n", - "unstructured: 0.14.4\n", - "lxml : 5.1.0\n", - "torch : 2.3.0\n", - "pymilvus : 2.4.4\n", - "langchain : 0.2.2\n", - "ollama : 0.1.8\n", - "octoai : 1.0.2\n", - "groq : 0.8.0\n", - "openai : 1.35.0\n", - "\n", - "conda environment: py311-unum\n", - "\n" - ] - } - ], + "outputs": [], "source": [ "# Props to Sebastian Raschka for this handy watermark.\n", "# !pip install watermark\n",