CountMin_Count_MisraGries_Sketch_Comparison.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "18110091_Q4_A2.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zC3cy15AM38h"
      },
      "source": [
        "**Installing Libraries**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i9QsZJqXCPFc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "650137e8-e513-4c06-eb99-eb051c418789"
      },
      "source": [
        "!pip install mmh3"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Collecting mmh3\n",
            "\u001b[?25l  Downloading https://files.pythonhosted.org/packages/d9/46/0e568554c7f70ebc3de0c2b2effd3f7b25e66e0e4e0eacaeb7c9145949f2/mmh3-3.0.0-cp37-cp37m-manylinux2010_x86_64.whl (50kB)\n",
            "\r\u001b[K     |██████▍                         | 10kB 10.5MB/s eta 0:00:01\r\u001b[K     |████████████▉                   | 20kB 15.3MB/s eta 0:00:01\r\u001b[K     |███████████████████▎            | 30kB 7.8MB/s eta 0:00:01\r\u001b[K     |█████████████████████████▊      | 40kB 6.5MB/s eta 0:00:01\r\u001b[K     |████████████████████████████████| 51kB 2.5MB/s \n",
            "\u001b[?25hInstalling collected packages: mmh3\n",
            "Successfully installed mmh3-3.0.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EQ0Vs2JxMvPu"
      },
      "source": [
        "**Importing Modules**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pLJ1emlP0gtZ"
      },
      "source": [
        "import pandas as pd\n",
        "from IPython.display import display, HTML\n",
        "import random\n",
        "import statistics\n",
        "import mmh3\n",
        "import numpy as np\n",
        "import sys\n",
        "from collections import defaultdict\n",
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZEnRLmt2NPq2"
      },
      "source": [
        "**Importing Data** <br>\n",
        "We first import the training data for the frequency of words in given documents. Then a data frame is created by splitting the values into columns and deleting the first column for docID. A new dictionary is created to store the frequencies of each word appearing in all documents."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A-rjyIMm0iYl"
      },
      "source": [
        "train_path = 'https://raw.githubusercontent.com/kushagra-18110091/http_test/main/train.data'\n",
        "data = pd.read_csv(train_path)\n",
        "data = data.iloc[:, 0].str.split(pat=\" \", expand=True)\n",
        "data = data.drop(data.columns[[0]], axis=1)\n",
        "\n",
        "uniq_index = pd.unique(data.iloc[:,0])\n",
        "result = {}\n",
        "\n",
        "for i in range(len(uniq_index)):\n",
        "  result[uniq_index[i]] = int(0)\n",
        "\n",
        "for i in range(len(data)):\n",
        "  result[data.iloc[i,0]] = int(result[data.iloc[i,0]]) + int(data.iloc[i,1])\n",
        "\n",
        "data.columns = ['wordIdx', 'count']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0rg1Y46PObbW"
      },
      "source": [
        "**Creating Query Set** <br>\n",
        "We create a data frame for query set by sorting the previously created dictionary in descending order of frequencies and then sample 100 entries from it."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ppd5AiQXyVWz"
      },
      "source": [
        "query = pd.DataFrame(result.items(), columns=['WordIdx', 'Count'])\n",
        "query = query.sort_values('Count', ascending=False)\n",
        "query = query.iloc[0:1000,:]\n",
        "query = query.sample(n=100)\n",
        "\n",
        "query = query.to_numpy()\n",
        "data = data.to_numpy()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NVschOD0O-Yr"
      },
      "source": [
        "**Count Min Sketch** <br>\n",
        "The class contains three functions `__init__`, `addCM` and `queryCM`. <br><ul>\n",
        "<li> The `__init__` function initialzes the `w` and `d` values and creates an array to store the frequencies calculated by the count min sketch. <br> \n",
        "<li> The `addCM` function adds the element, count times, to the array by calculating the array index using hash values.\n",
        "<li> The `queryCM` function queries the sketch to return the frequency computed by the sketch for an element. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nxsX8a2FGVY6"
      },
      "source": [
        "class CMSketch:\n",
        "    def __init__(self,w,d):\n",
        "        self.w = w\n",
        "        self.d = d\n",
        "        self.arrayCM = np.zeros([self.w, self.d],dtype=int)\n",
        "        self.seed_hi = np.random.randint(d, size = w)\n",
        "\n",
        "    def addCM(self,id,count):\n",
        "        for i in range(self.w):\n",
        "            hi = mmh3.hash(id,self.seed_hi[i])%(self.d)\n",
        "            self.arrayCM[i][hi] += count\n",
        "        return\n",
        "\n",
        "    def queryCM(self,id):\n",
        "        countArray = []\n",
        "        for i in range(self.w):\n",
        "            hi = mmh3.hash(id,self.seed_hi[i])%(self.d)\n",
        "            countArray.append(self.arrayCM[i][hi])\n",
        "        return min(countArray)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J1ZvxMAcR8iI"
      },
      "source": [
        "**Querying Count Min Sketch** <br>\n",
        "For each value of `d`, Count Min Sketch is initialized and the values from the data stream are added. The average relative error is then calculated by querying the sketch."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wXQVhrU0RHS1"
      },
      "source": [
        "CMError = []\n",
        "\n",
        "for d in [20,40,100,200,400]:\n",
        "  CMS = CMSketch(5,d)\n",
        "\n",
        "  for i in range(len(data)):\n",
        "    CMS.addCM(data[i][0],int(data[i][1]))\n",
        "\n",
        "  sum  = 0\n",
        "\n",
        "  for i in range(100):\n",
        "    sum += abs(CMS.queryCM(query[i][0]) - query[i][1])/query[i][1]\n",
        "\n",
        "  CMError.append(sum/100)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rNe1o-HSUGk9"
      },
      "source": [
        "**Count Sketch** <br>\n",
        "The class contains three functions `__init__`, `addCS` and `queryCS`. <br><ul>\n",
        "<li> The `__init__` function initialzes the `w` and `d` values and creates an array to store the frequencies calculated by the count sketch. <br> \n",
        "<li> The `addCS` function adds the element, count times, to the array by calculating the array index using hash values and sign value for each index and element.\n",
        "<li> The `queryCS` function queries the sketch to return the frequency computed by the sketch for an element. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wDhNFBJESrks"
      },
      "source": [
        "class CSketch:\n",
        "    def __init__(self,w,d):\n",
        "        self.w = w\n",
        "        self.d = d\n",
        "        self.arrayCS = np.zeros([self.w, self.d],dtype=int)\n",
        "        self.seed_hi = np.random.randint(d, size = w)\n",
        "        self.seed_gi = np.random.randint(d, size = w)\n",
        "\n",
        "    def addCS(self,id,count):\n",
        "        for i in range(self.w):\n",
        "            hi = mmh3.hash(id,self.seed_hi[i])%(self.d)\n",
        "            sign = 1\n",
        "            if(mmh3.hash(id,self.seed_gi[i])%2 == 0):\n",
        "                sign = -1\n",
        "            self.arrayCS[i][hi]+= count*sign\n",
        "        return\n",
        "\n",
        "    def queryCS(self,id):\n",
        "        countArray = []\n",
        "        for i in range(self.w):\n",
        "            hi = mmh3.hash(id,self.seed_hi[i])%(self.d)\n",
        "            sign = 1\n",
        "            if(mmh3.hash(id,self.seed_gi[i])%2 == 0):\n",
        "                sign = -1\n",
        "            countArray.append(sign*self.arrayCS[i][hi])\n",
        "        return statistics.median(countArray)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "93_QPdqRVckd"
      },
      "source": [
        "**Querying Count Sketch** <br>\n",
        "For each value of `d`, Count Sketch is initialized and the values from the data stream are added. The average relative error is then calculated by querying the sketch."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cnO0YwJCRoDs"
      },
      "source": [
        "CSError = []\n",
        "\n",
        "for d in [20,40,100,200,400]:\n",
        "  CS = CSketch(5,d)\n",
        "\n",
        "  for i in range(len(data)):\n",
        "    CS.addCS(data[i][0],int(data[i][1]))\n",
        "\n",
        "  sum = 0\n",
        "  for i in range(100):\n",
        "    sum += abs(CS.queryCS(query[i][0]) - query[i][1])/query[i][1]\n",
        "\n",
        "  CSError.append(sum/100)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vpf2xzIpWKkT"
      },
      "source": [
        "**Misra Gries Sketch** <br>\n",
        "The class contains three functions `__init__`, `addMG` and `queryMG`. <br><ul>\n",
        "<li> The `__init__` function initialzes the `K` value and creates a dictionary to store the frequencies calculated by the misra gries sketch. <br> \n",
        "<li> The `addMG` function adds the element with count, to the dictionary if not present. Otherwise the count of the element is increased count times. If the number of elements in dictionary are greater than `K`, the count of each element is decreased count times and all elements with frequencies less than 0 are deleted.\n",
        "<li> The `queryMG` function queries the sketch to return the frequency computed by the sketch for an element. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xU2uQc7yaSC2"
      },
      "source": [
        "class MGSketch:\n",
        "    def __init__(self,K):\n",
        "        self.K = K\n",
        "        self.countMG = defaultdict(int)\n",
        "\n",
        "    def addMG(self,id,count):\n",
        "      if len(self.countMG.keys()) < self.K:\n",
        "          self.countMG[id] += count\n",
        "        \n",
        "      elif id in self.countMG:\n",
        "          self.countMG[id] += count\n",
        "\n",
        "      else:\n",
        "          for key in list(self.countMG.keys()):\n",
        "              self.countMG[key] -= count\n",
        "              if self.countMG[key] <= 0:\n",
        "                del self.countMG[key]\n",
        "      return\n",
        "\n",
        "    def queryMG(self,id):\n",
        "        if(self.countMG[id] != 0):    \n",
        "          return self.countMG[id]\n",
        "        else:\n",
        "          return 0"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GTHInQQ9W_K4"
      },
      "source": [
        "**Querying Misra Gries Sketch** <br>\n",
        "For each value of `K`, Misra Gries Sketch is initialized and the values from the data stream are added. The average relative error is then calculated by querying the sketch."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oVIRS5ZBRwn4"
      },
      "source": [
        "MGError = []\n",
        "\n",
        "for K in [100,200,500,1000,2000]:\n",
        "  MG = MGSketch(K)\n",
        "\n",
        "  for i in range(len(data)):\n",
        "    MG.addMG(data[i][0],int(data[i][1]))\n",
        "\n",
        "  sum = 0\n",
        "\n",
        "  for i in range(100):\n",
        "    sum += abs(MG.queryMG(query[i][0]) - query[i][1])/query[i][1]\n",
        "  \n",
        "  MGError.append(sum/100)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "le_T_m9siz2W"
      },
      "source": [
        "**Calculating Relative Errors for each K**<br>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 212
        },
        "id": "rtRyjWtRQh-7",
        "outputId": "2a18804e-98e4-4f27-af5e-56514db9dfc5"
      },
      "source": [
        "result = []\n",
        "\n",
        "for i in range(0,5):\n",
        "  errors = []\n",
        "  errors.append(CMError[i])\n",
        "  errors.append(CSError[i])\n",
        "  errors.append(MGError[i])\n",
        "  result.append(errors)\n",
        "\n",
        "print(\"Relative errors for the sketches for K values in [100,200,400,1000,2000]\")\n",
        "result = pd.DataFrame(result, columns=[\"Count Min Sketch\",\"Count Sketch\",\"Misra Gries Sketch\"])\n",
        "display(HTML(result.to_html()))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Relative errors for the sketches for K values in [100,200,400,1000,2000]\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Count Min Sketch</th>\n",
              "      <th>Count Sketch</th>\n",
              "      <th>Misra Gries Sketch</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>148.678827</td>\n",
              "      <td>63.212568</td>\n",
              "      <td>0.998396</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>62.666012</td>\n",
              "      <td>9.456200</td>\n",
              "      <td>0.991614</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>21.014037</td>\n",
              "      <td>4.712923</td>\n",
              "      <td>0.953058</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>9.017712</td>\n",
              "      <td>2.291099</td>\n",
              "      <td>0.887774</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>3.805000</td>\n",
              "      <td>1.228228</td>\n",
              "      <td>0.754445</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>"
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QscG5BvFjJuI"
      },
      "source": [
        "**Plotting the Results**<br>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 594
        },
        "id": "bfIQP5Hp6fIe",
        "outputId": "d955a75d-58fc-454b-a06d-7cdfb681e7f2"
      },
      "source": [
        "x = [100,200,500,1000,2000]\n",
        "\n",
        "plt.figure(dpi=150)\n",
        "plt.plot(x, CMError, label = \"Count Min Sketch\")\n",
        "plt.plot(x, CSError, label = \"Count Sketch\")\n",
        "plt.plot(x, MGError, label = \"Misra Gries Sketch\")\n",
        "\n",
        "plt.xlabel('K')\n",
        "plt.ylabel('Relative Error')\n",
        "  \n",
        "plt.title('Relative Error for Sketches')\n",
        "plt.legend()\n",
        "  \n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 900x600 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XI-ZjDT1jbCN"
      },
      "source": [
        "**Binary Search Function**<br> "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X3ZdjUJs8BaK"
      },
      "source": [
        "def find_error(sketch):\n",
        "  low = 1000\n",
        "  high = 250000\n",
        "  while(low <= high):\n",
        "    mid = low + (high - low)/2\n",
        "    error = 0\n",
        "\n",
        "    if (sketch == \"CMS\"):\n",
        "      CMS = CMSketch(5,int(mid/5))\n",
        "\n",
        "      for i in range(len(data)):\n",
        "        CMS.addCM(data[i][0],int(data[i][1]))\n",
        "\n",
        "      for i in range(100):\n",
        "        error += abs(CMS.queryCM(query[i][0]) - query[i][1])/query[i][1]\n",
        "\n",
        "    elif (sketch == \"CS\"):\n",
        "      CS = CSketch(5,int(mid/5))\n",
        "\n",
        "      for i in range(len(data)):\n",
        "        CS.addCS(data[i][0],int(data[i][1]))\n",
        "\n",
        "      for i in range(100):\n",
        "        error += abs(CS.queryCS(query[i][0]) - query[i][1])/query[i][1]\n",
        "\n",
        "    elif (sketch == \"MG\"):\n",
        "      MG = MGSketch(mid)\n",
        "\n",
        "      for i in range(len(data)):\n",
        "        MG.addMG(data[i][0],int(data[i][1]))\n",
        "\n",
        "      for i in range(100):\n",
        "        error += abs(MG.queryMG(query[i][0]) - query[i][1])/query[i][1]\n",
        "\n",
        "    if (error <= 1.5 and error >= 0.85):\n",
        "      return mid\n",
        "    elif (error > 1.05):\n",
        "      low = mid + 1\n",
        "    elif (error < 0.85):\n",
        "      high = mid - 1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZA3--ZPmjj8H"
      },
      "source": [
        "**Calculating Minimum K for less than 1% Error**<br>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SUobOnrD8xzn",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 94
        },
        "outputId": "8293cd7c-66ff-4fe1-a97b-063219054250"
      },
      "source": [
        "error_values = []\n",
        "result = []\n",
        "error_values.append(find_error(\"CMS\"))\n",
        "error_values.append(find_error(\"CS\"))\n",
        "error_values.append(find_error(\"MG\"))\n",
        "result.append(error_values)\n",
        "\n",
        "print(\"K values such that the relative error is less than 1%\")\n",
        "result = pd.DataFrame(result, columns=[\"Count Min Sketch\",\"Count Sketch\",\"Misra Gries Sketch\"])\n",
        "display(HTML(result.to_html()))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "K values such that the relative error is less than 1%\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/html": [
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Count Min Sketch</th>\n",
              "      <th>Count Sketch</th>\n",
              "      <th>Misra Gries Sketch</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>78812.125</td>\n",
              "      <td>125500.0</td>\n",
              "      <td>32124.25</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>"
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    }
  ]
}