notebooks/01_knn_is_dead.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# KNN (K-Nearest Neighbors) is Dead!\n",
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/stephenleo/adventures-with-ann/blob/main/knn_is_dead.ipynb)\n",
    "\n",
    "Long live ANNs for their whopping 380X speedup over sklearn's KNN while delivering 99.3% similar results.\n",
    "\n",
    "![A Dead Tree in a desert](images/header.jpeg)\n",
    "\n",
    "We're living through an extinction-level event. No, not COVID19, I'm talking about the demise of the popular KNN algorithm that is taught in pretty much every Data Science course! Read on to find out what's replacing this staple in every Data Scientists' toolkit.\n",
    "\n",
    "# KNN Background\n",
    "Finding \"K\" similar items to any given item is widely known in the machine learning community as a \"similarity\" search or \"nearest neighbor\" (NN) search. The most widely known NN search algorithm is the K-Nearest Neighbours (KNN) algorithm. In KNN, given a collection of objects like an e-commerce catalog of handphones, we can find a small number (K) nearest neighbors from this entire catalog for any new search query. For example, in the below example, if you set K = 3, then the 3 nearest neighbors for each \"iPhone\" is another \"iPhone.\" Similarly, the 3 nearest neighbors to each \"Samsung\" are all Samsungs.\n",
    "\n",
    "| Title                                              |\n",
    "|----------------------------------------------------|\n",
    "| Apple iPhone 12/12 Pro and 12 Pro max              |\n",
    "| APPLE iPhone 12 2020 256GB SIM Free / Smart Phone  |\n",
    "| Samsung Galaxy Note20 - Ultra/5G/LTE/4G w Warranty |\n",
    "| APPLE IPHONE 12PRO MAX 256GB ONE YEAR WARRANTY     |\n",
    "| New Release Samsung Note 20 4G / Note 20 Ultra 5G  |\n",
    "| SAMSUNG GALAXY NOTE 20 ULTRA 5G                    |\n",
    "\n",
    "## Issue with KNN\n",
    "While KNN is great at finding similar items, it finds neighbors using an exhaustive pairwise distance computation. If your data contains 1000 items, then to find the K=3 nearest neighbors of a new product, the algorithm needs to perform 1000 distance computations of the new product to all the other products in your database. Well, that's not too bad, yet. But imagine a real-world Customer-to-Customer (C2C) marketplace with millions of products in the database and potentially thousands of new products uploaded every day. Comparing each new product to all the millions of products is wasteful and takes too much time, a.k.a not-scalable <b><i>at all</i></b>.\n",
    "\n",
    "## The Solution\n",
    "The solution to scale Nearest Neighbors to large data volumes is to sidestep the brute force distance computations completely and instead use a more sophisticated class of algorithms called Approximate Nearest Neighbors (ANN)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Approximate Nearest Neighbors (ANN)\n",
    "Strictly speaking, ANNs are a class of algorithms in which a small number of errors are allowed during the NN search. But in a real-world C2C marketplace where the number of \"real\" neighbors is higher than the \"K\" nearest neighbors being searched, ANNs can achieve remarkable accuracy on par with brute-force KNN within a fraction of the time. There are several ANN algorithms such as \n",
    "1. Spotify's [ANNOY](https://github.com/spotify/annoy)\n",
    "2. Google's [ScaNN](https://github.com/google-research/google-research/tree/master/scann)\n",
    "3. Facebook's [Faiss](https://github.com/facebookresearch/faiss)\n",
    "3. And my personal favourite: Hierarchical Navigable Small World graphs [HNSW](https://github.com/nmslib/hnswlib)\n",
    "\n",
    "The rest of this post benchmarks the KNN algorithm implemented in Python's `sklearn` to the excellent ANN algorithm called Hierarchical Navigable Small World (HNSW) graphs implemented in Python's `hnswlib` package. I'll use a large [Amazon product dataset](http://deepyeti.ucsd.edu/jianmo/amazon/) which contains 527000 products in the 'Cell Phones & Accessories' category to prove that HNSW is far superior in terms of speed (380X faster, to be precise) while delivering 99.3% similar results to sklearn's KNN.\n",
    "\n",
    "## Hierarchical Navigable Small World (HNSW)\n",
    "In HNSW [[paper @ arxiv]](https://arxiv.org/abs/1603.09320), the authors describe an ANN algorithm using a multi-layer graph. During element insertion, the HNSW graph is built incrementally by randomly selecting each element's maximum layer with an exponentially decaying probability distribution. This ensures that layer=0 has many elements to enable fine-search while layer=2 has $e^{-2}$ lower number of elements to facilitate coarse-search. The nearest neighbor search starts at the topmost layer with a coarse search and proceeds lower until the lowest layer using a greedy graph routing to traverse the graph and find the required number of neighbors.\n",
    "\n",
    "![HNSW Graph Structure](images/hnsw_graph.png \"HNSW graph structure. Nearest Neighbors search starts at the topmost layer (coarse search) and ends in the bottom-most layer (fine search)\")\n",
    "\n",
    "## HNSW Python package\n",
    "The whole HNSW algorithm has been written in C++ with Python bindings that can be pip installed on your machine by typing: `pip install hnswlib`. Once you install the package and import it, creating the HNSW graph requires a few steps that I have wrapped into a convenience function below. Once you have created the HNSW index, querying for \"K\" nearest neighbors is as simple as calling a single line of code as below.\n",
    "\n",
    "```\n",
    "ann_neighbor_indices, ann_distances = p.knn_query(features, k)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install hnswlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import hnswlib\n",
    "import numpy as np\n",
    "\n",
    "def fit_hnsw_index(features, ef=100, M=16, save_index_file=False):\n",
    "    # Convenience function to create HNSW graph\n",
    "    # features : list of lists containing the embeddings\n",
    "    # ef, M: parameters to tune the HNSW algorithm\n",
    "    \n",
    "    num_elements = len(features)\n",
    "    labels_index = np.arange(num_elements)\n",
    "    EMBEDDING_SIZE = len(features[0])\n",
    "    \n",
    "    # Declaring index\n",
    "    # possible space options are l2, cosine or ip\n",
    "    p = hnswlib.Index(space='l2', dim=EMBEDDING_SIZE)\n",
    "    \n",
    "    # Initing index - the maximum number of elements should be known\n",
    "    p.init_index(max_elements=num_elements, ef_construction=ef, M=M)\n",
    "    \n",
    "    # Element insertion\n",
    "    int_labels = p.add_items(features, labels_index)\n",
    "    \n",
    "    # Controlling the recall by setting ef\n",
    "    # ef should always be > k\n",
    "    p.set_ef(ef) \n",
    "    \n",
    "    # If you want to save the graph to a file\n",
    "    if save_index_file:\n",
    "         p.save_index(save_index_file)\n",
    "    \n",
    "    return p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# KNN vs. ANN Benchmarking Experiment\n",
    "## Plan\n",
    "We'll first download a large dataset with 500K+ rows. Then we'll convert a text column to an `300d` embedding vector by using the pre-trained `fasttext` sentence vector. Then I'll train both KNN and HNSW ANN models on different lengths of the input data `[1000, 10000, 100000, len(data)]` to measure the impact of data size on the speed. Finally, I'll query `K = 10` and `100` nearest neighbors from both models to measure the impact of `K` on the speed. First, let's import the necessary packages and models. This will take some time as the `fasttext` model needs to be downloaded from the internet."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "! pip install fasttext"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Warning : `load_model` does not return WordVectorModel or SupervisedModel any more, but a `FastText` object which is very similar.\n"
     ]
    }
   ],
   "source": [
    "# Imports\n",
    "# For input data pre-processing\n",
    "import json\n",
    "import gzip\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import fasttext.util\n",
    "fasttext.util.download_model('en', if_exists='ignore') # English pre-trained model\n",
    "ft = fasttext.load_model('cc.en.300.bin')\n",
    "\n",
    "# For KNN vs ANN benchmarking\n",
    "from datetime import datetime\n",
    "from tqdm import tqdm\n",
    "from sklearn.neighbors import NearestNeighbors\n",
    "import hnswlib"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data\n",
    "We'll use the [Amazon product dataset](http://deepyeti.ucsd.edu/jianmo/amazon/), which contains 527000 products in the 'Cell Phones & Accessories' category. Download the dataset from the link and run the below code to convert it to a data frame. We only need the product title column as we will use it to search for similar products.\n",
    "\n",
    "If everything ran fine, you should see an output as below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Data: http://deepyeti.ucsd.edu/jianmo/amazon/\n",
    "!wget http://deepyeti.ucsd.edu/jianmo/amazon/metaFiles/meta_Cell_Phones_and_Accessories.json.gz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = []\n",
    "with gzip.open('meta_Cell_Phones_and_Accessories.json.gz') as f:\n",
    "    for l in f:\n",
    "        data.append(json.loads(l.strip()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(527543, 1)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>title</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Puppies Faceplate Hard Case Protector for Net1...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>White Wolf Faceplate Protector Hard Case for S...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Camo Duck Grass Rubberized Hard Case Phone Fac...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Camoflague Camo Usa Deer Combo Hybrid Hard Cas...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Motorola H700 Black - Non-Retail Packaging</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                               title\n",
       "0  Puppies Faceplate Hard Case Protector for Net1...\n",
       "1  White Wolf Faceplate Protector Hard Case for S...\n",
       "2  Camo Duck Grass Rubberized Hard Case Phone Fac...\n",
       "3  Camoflague Camo Usa Deer Combo Hybrid Hard Cas...\n",
       "4         Motorola H700 Black - Non-Retail Packaging"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Pre-Processing: https://colab.research.google.com/drive/1Zv6MARGQcrBbLHyjPVVMZVnRWsRnVMpV#scrollTo=LgWrDtZ94w89\n",
    "# Convert list into pandas dataframe\n",
    "df = pd.DataFrame.from_dict(data)\n",
    "df.fillna('', inplace=True)\n",
    "\n",
    "# Filter unformatted rows\n",
    "df = df[~df.title.str.contains('getTime')] \n",
    "\n",
    "# Restrict to just 'Cell Phones and Accessories'\n",
    "df = df[df['main_cat']=='Cell Phones & Accessories']\n",
    "\n",
    "# Reset index\n",
    "df.reset_index(inplace=True, drop=True)\n",
    "\n",
    "# Only keep the title columns\n",
    "df = df[['title']]\n",
    "\n",
    "# Check the df\n",
    "print(df.shape)\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Embedding\n",
    "To run any similarity search on textual data, we must first convert it to a numeric vector. A fast and convenient approach uses a pre-trained network's embedding layer, such as the one provided by Facebook's [FastText](https://github.com/facebookresearch/fastText). Since we want all the rows to have the same length vector, irrespective of the number of words in the title, we shall apply the `get_sentence_vector` method on the `title` column in df. Once the embedding is completed, we extract the `emb` column as a list of lists to input into our NN algorithms. Ideally, you would run some text cleaning pre-processing before this step. Also, using a fine-tuned embedding model is generally a good idea. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Title Embedding using FastText Sentence Embedding\n",
    "df['emb'] = df['title'].apply(ft.get_sentence_vector)\n",
    "\n",
    "# Extract out the embeddings column as a list of lists for input to our NN algos\n",
    "X = [item.tolist() for item in df['emb'].values]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Benchmarking\n",
    "Now that we have the input to our algorithms let's run the benchmarking tests. We will run the test as a loop within a loop of the number of products in the search space and `K` nearest neighbors being searched. \n",
    "\n",
    "At each iteration, in addition to clocking the time taken by each algorithm, we check the `pct_overlap` as the ratio of the number of KNN nearest neighbors that were also picked up as nearest neighbors by the ANN.\n",
    "\n",
    "<b>Beware!</b> The whole test ran for ~6days on an 8 core, 30 GB RAM machine running 24x7, so this could take some time. Ideally, you could speed it up by multiprocessing since each run is independent of the other.\n",
    "\n",
    "The output at the end of this run looks as below. As you can already see from the table, the HNSW ANN completely blows away KNN!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Number of products for benchmark loop\n",
    "n_products = [1000, 10000, 100000, len(X)]\n",
    "\n",
    "# Number of neighbors for benchmark loop\n",
    "n_neighbors = [10, 100]\n",
    "\n",
    "# Dictionary to save metric results for each iteration\n",
    "metrics = {'products':[], 'k':[], 'knn_time':[], 'ann_time':[], 'pct_overlap':[]}\n",
    "\n",
    "for products in tqdm(n_products):\n",
    "    # \"products\" number of products included in the search space\n",
    "    features = X[:products]\n",
    "    \n",
    "    for k in tqdm(n_neighbors):   \n",
    "        # \"K\" Nearest Neighbor search\n",
    "        # KNN \n",
    "        knn_start = datetime.now()\n",
    "        nbrs = NearestNeighbors(n_neighbors=k, metric='euclidean').fit(features)\n",
    "        knn_distances, knn_neighbor_indices = nbrs.kneighbors(features)\n",
    "        knn_end = datetime.now()\n",
    "        metrics['knn_time'].append((knn_end - knn_start).total_seconds())\n",
    "        \n",
    "        # HNSW ANN\n",
    "        ann_start = datetime.now()\n",
    "        p = fit_hnsw_index(features, ef=k*10)\n",
    "        ann_neighbor_indices, ann_distances = p.knn_query(features, k)\n",
    "        ann_end = datetime.now()\n",
    "        metrics['ann_time'].append((ann_end - ann_start).total_seconds())\n",
    "        \n",
    "        # Average Percent Overlap in Nearest Neighbors across all \"products\"\n",
    "        pct_overlap_per_product = [len(np.intersect1d(knn_neighbor_indices[i], ann_neighbor_indices[i]))/k for i in range(len(features))]\n",
    "        metrics['pct_overlap'].append(np.mean(pct_overlap_per_product))\n",
    "        \n",
    "        metrics['products'].append(products)\n",
    "        metrics['k'].append(k)\n",
    "        \n",
    "metrics_df = pd.DataFrame(metrics)\n",
    "metrics_df.to_csv('data/metrics_df.csv', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>products</th>\n",
       "      <th>k</th>\n",
       "      <th>knn_time</th>\n",
       "      <th>ann_time</th>\n",
       "      <th>pct_overlap</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1000</td>\n",
       "      <td>10</td>\n",
       "      <td>0.580620</td>\n",
       "      <td>0.051501</td>\n",
       "      <td>0.997700</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1000</td>\n",
       "      <td>100</td>\n",
       "      <td>0.597760</td>\n",
       "      <td>0.126358</td>\n",
       "      <td>0.999990</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>10000</td>\n",
       "      <td>10</td>\n",
       "      <td>63.103122</td>\n",
       "      <td>0.652903</td>\n",
       "      <td>0.979910</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>10000</td>\n",
       "      <td>100</td>\n",
       "      <td>64.446671</td>\n",
       "      <td>3.155929</td>\n",
       "      <td>0.999258</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>100000</td>\n",
       "      <td>10</td>\n",
       "      <td>6234.982191</td>\n",
       "      <td>11.146112</td>\n",
       "      <td>0.964912</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>100000</td>\n",
       "      <td>100</td>\n",
       "      <td>6331.495806</td>\n",
       "      <td>83.650471</td>\n",
       "      <td>0.995826</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>527543</td>\n",
       "      <td>10</td>\n",
       "      <td>222900.147851</td>\n",
       "      <td>85.357864</td>\n",
       "      <td>0.935081</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>527543</td>\n",
       "      <td>100</td>\n",
       "      <td>243439.207189</td>\n",
       "      <td>634.716238</td>\n",
       "      <td>0.992623</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   products    k       knn_time    ann_time  pct_overlap\n",
       "0      1000   10       0.580620    0.051501     0.997700\n",
       "1      1000  100       0.597760    0.126358     0.999990\n",
       "2     10000   10      63.103122    0.652903     0.979910\n",
       "3     10000  100      64.446671    3.155929     0.999258\n",
       "4    100000   10    6234.982191   11.146112     0.964912\n",
       "5    100000  100    6331.495806   83.650471     0.995826\n",
       "6    527543   10  222900.147851   85.357864     0.935081\n",
       "7    527543  100  243439.207189  634.716238     0.992623"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metrics_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results\n",
    "Let's look at the benchmark results in the form of plots to appreciate the difference's magnitude truly. I'll use standard `matplotlib` code to plot these graphs. The X-axis is in `log` scale. The difference is spectacular! HNSW ANN knocks KNN out of the park in terms of time required to query `K=10` and `100` nearest neighbors. When the search space contains `~500K` products, searching for 100 nearest neighbors is 380X faster on ANN!!! At the same time, both KNN and ANN find 99.3% same nearest neighbors. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>products</th>\n",
       "      <th>k</th>\n",
       "      <th>knn_time</th>\n",
       "      <th>ann_time</th>\n",
       "      <th>pct_overlap</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1000</td>\n",
       "      <td>10</td>\n",
       "      <td>0.580620</td>\n",
       "      <td>0.051501</td>\n",
       "      <td>0.997700</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1000</td>\n",
       "      <td>100</td>\n",
       "      <td>0.597760</td>\n",
       "      <td>0.126358</td>\n",
       "      <td>0.999990</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>10000</td>\n",
       "      <td>10</td>\n",
       "      <td>63.103122</td>\n",
       "      <td>0.652903</td>\n",
       "      <td>0.979910</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>10000</td>\n",
       "      <td>100</td>\n",
       "      <td>64.446671</td>\n",
       "      <td>3.155929</td>\n",
       "      <td>0.999258</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>100000</td>\n",
       "      <td>10</td>\n",
       "      <td>6234.982191</td>\n",
       "      <td>11.146112</td>\n",
       "      <td>0.964912</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   products    k     knn_time   ann_time  pct_overlap\n",
       "0      1000   10     0.580620   0.051501     0.997700\n",
       "1      1000  100     0.597760   0.126358     0.999990\n",
       "2     10000   10    63.103122   0.652903     0.979910\n",
       "3     10000  100    64.446671   3.155929     0.999258\n",
       "4    100000   10  6234.982191  11.146112     0.964912"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "metrics_df = pd.read_csv('data/metrics_df.csv')\n",
    "metrics_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/stephenleo/anaconda3/envs/ann/lib/python3.6/site-packages/matplotlib/axes/_base.py:3245: UserWarning: Attempted to set non-positive ylimits for log-scale axis; invalid limits will be ignored.\n",
      "  'Attempted to set non-positive ylimits for log-scale axis; '\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f7fa90269b0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "k10_df = metrics_df[metrics_df['k']==10]\n",
    "k100_df = metrics_df[metrics_df['k']==100]\n",
    "\n",
    "fig = plt.figure(figsize=(12,5))\n",
    "fig.patch.set_facecolor('white')\n",
    "\n",
    "ax1 = fig.add_subplot(1,2,1)\n",
    "ax1.plot(k10_df['products'].values, k10_df['knn_time'].values, label='KNN', linewidth=2, marker='o')\n",
    "ax1.plot(k10_df['products'].values, k10_df['ann_time'].values, label='ANN', linewidth=2, marker='s')\n",
    "ax1.set_xscale('log')\n",
    "ax1.set_yscale('log')\n",
    "ax1.set_ylim(0, 500000)\n",
    "ax1.legend(fontsize=15)\n",
    "ax1.set_title('K = 10', fontsize=15)\n",
    "ax1.set_xlabel('Number of Products', fontsize=15)\n",
    "ax1.set_ylabel('Query Time (s)', fontsize=15)\n",
    "\n",
    "ax2 = fig.add_subplot(1,2,2)\n",
    "ax2.plot(k100_df['products'].values, k100_df['knn_time'].values, label='KNN', linewidth=2, marker='o')\n",
    "ax2.plot(k100_df['products'].values, k100_df['ann_time'].values, label='ANN', linewidth=2, marker='s')\n",
    "ax2.set_xscale('log')\n",
    "ax2.set_yscale('log')\n",
    "ax2.set_ylim(0, 500000)\n",
    "ax2.legend(fontsize=15)\n",
    "ax2.set_title('K = 100', fontsize=15)\n",
    "ax2.set_xlabel('Number of Products', fontsize=15)\n",
    "\n",
    "plt.suptitle('Nearest Neighbors Query Time (s)', fontsize=15);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f7fa6a71160>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(10,5))\n",
    "fig.patch.set_facecolor('white')\n",
    "plt.plot(k10_df['products'].values, k10_df['pct_overlap'].values, label='K=10', linewidth=2, marker='o')\n",
    "plt.plot(k100_df['products'].values, k100_df['pct_overlap'].values, label='K=100', linewidth=2, marker='s')\n",
    "plt.title('Nearest Neighbors Overlap Ratio between KNN and HNSW ANN', fontsize=15)\n",
    "plt.xlabel('Number of Products', fontsize=15)\n",
    "plt.ylabel('Nearest Neighbors Overlap Ratio', fontsize=15)\n",
    "plt.legend(fontsize=15)\n",
    "plt.xscale('log')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With these results, I think it's safe to say, \"KNN is dead!\", there is no reasonable reason to use `sklearn's` KNN anymore. I hope you found this post useful! Thank you for reading!"
   ]
  }
 ],
 "metadata": {
  "environment": {
   "name": "tf2-2-3-gpu.2-3.m59",
   "type": "gcloud",
   "uri": "gcr.io/deeplearning-platform-release/tf2-2-3-gpu.2-3:m59"
  },
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}