YASS_stemmer_clustering.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nltk.metrics import edit_distance\n",
    "from sklearn.cluster import AgglomerativeClustering\n",
    "from nltk.stem.porter import *\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import pickle\n",
    "from os.path import commonprefix\n",
    "\n",
    "def mismatchIndex(x,y):\n",
    "    i = 0\n",
    "    while i < len(x) and i < len(y) and x[i] == y[i]:\n",
    "        i+=1\n",
    "        \n",
    "    return i\n",
    "\n",
    "def distanceD1(x,y):\n",
    "    distance = 0\n",
    "    value = 1\n",
    "    for i in range(max(len(x),len(y))):\n",
    "        if i >= len(x) or i >= len(y) or x[i]!=y[i]:\n",
    "            distance+=(1/value)\n",
    "        value*=2\n",
    "            \n",
    "    return distance\n",
    "            \n",
    "def distanceD2(x,y):\n",
    "    distance = 0\n",
    "    m = mismatchIndex(x,y)\n",
    "    \n",
    "    if m == 0:\n",
    "        return float('inf')\n",
    "    \n",
    "    for i in range(m,max(len(x),len(y))):\n",
    "        distance+=(1/(2**(i-m)))\n",
    "        \n",
    "    return distance/m\n",
    "\n",
    "def distanceD3(x,y):\n",
    "    m = mismatchIndex(x,y)\n",
    "    if m == 0:\n",
    "        return float('inf')\n",
    "    return  ( max(len(x),len(y)) - m  ) * distanceD2(x,y)\n",
    "\n",
    "def distanceD4(x,y):\n",
    "    m = mismatchIndex(x,y)\n",
    "    if m == 0:\n",
    "        return float('inf')\n",
    "    return  (m/(max(len(x),len(y)))) * distanceD3(x,y)\n",
    "    \n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.248046875, 0.0076904296875)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "distanceD1('astronomer','astonish'),distanceD1('astronomer','astronomically')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.6614583333333334, 0.24609375)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "distanceD2('astronomer','astonish'),distanceD2('astronomer','astronomically')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4.630208333333334, 1.4765625)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "distanceD3('astronomer','astonish'),distanceD3('astronomer','astronomically')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.3890625, 0.84375)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "distanceD4('astronomer','astonish'),distanceD4('astronomer','astronomically')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 6)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "edit_distance('astronomer','astonish'),edit_distance('astronomer','astronomically')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_words = []\n",
    "with open('stemming-assignment.txt') as f:\n",
    "    list_of_words = f.readlines()\n",
    "word_list = [i[:-1] for i in list_of_words] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23531"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(word_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Clustering using D1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open(\"/content/gdrive/My Drive/Information_Retrieval/D1_matrix.csv\",'a')\n",
    "\n",
    "for i in range(len(word_list)):\n",
    "    l = []\n",
    "    for j in range(len(word_list)): \n",
    "        if i!=j:\n",
    "            l.append(str(distanceD1(word_list[i],word_list[j])))\n",
    "        else:\n",
    "            l.append(str(0))\n",
    "    s = \",\".join(l)+\"\\n\"\n",
    "    f.write(s)\n",
    "\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_ = pd.read_csv('/content/gdrive/My Drive/Information_Retrieval/D1_matrix.csv',header = None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "D1_matrix = data_.apply(pd.to_numeric)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold_values = np.arange(0,0.46,0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "threshold_map = dict()\n",
    "for threshold in threshold_values:\n",
    "  agg_clustering = AgglomerativeClustering(n_clusters = None,linkage='complete',affinity='precomputed',distance_threshold = threshold)\n",
    "  agg_clustering.fit(D1_matrix)\n",
    "  number_of_clusters = agg_clustering.n_clusters_\n",
    "  cluster_labels = agg_clustering.labels_\n",
    "  threshold_map[threshold] = [number_of_clusters,cluster_labels]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Dump the mapping of the threshold and the clusters in pickle file\n",
    "with open('D1_cluster_data.pickle', 'wb') as handle:\n",
    "    pickle.dump(threshold_map, handle, protocol=pickle.HIGHEST_PROTOCOL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold_map = dict()\n",
    "with open('D1_cluster_data.pickle', 'rb') as handle:\n",
    "    threshold_map = pickle.load(handle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_of_clusters = []\n",
    "\n",
    "for i in threshold_values:\n",
    "  number_of_clusters.append(threshold_map[i][0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Distance D1')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.grid()\n",
    "plt.plot(threshold_values,number_of_clusters)\n",
    "plt.scatter(threshold_values,number_of_clusters)\n",
    "plt.xlabel(\"Threshold Values\")\n",
    "plt.ylabel(\"Number of clusters\")\n",
    "plt.title(\"Distance D1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0.0: [23531,\n",
       "  array([17087, 16383, 16055, ...,     6,     2,     0], dtype=int64)],\n",
       " 0.01: [20797,\n",
       "  array([17087, 16383, 16055, ...,  7796,   877,  3599], dtype=int64)],\n",
       " 0.02: [18603,\n",
       "  array([17087, 16383, 16055, ..., 15593,  3511,  7199], dtype=int64)],\n",
       " 0.03: [17018,\n",
       "  array([ 8543, 16383, 16055, ..., 15593,  7024,  7199], dtype=int64)],\n",
       " 0.04: [15647,\n",
       "  array([ 8543,  8191,  8027, ..., 15593,  7024, 14399], dtype=int64)],\n",
       " 0.05: [14897,\n",
       "  array([ 8543,  8191,  8027, ...,  7796,  7024, 14399], dtype=int64)],\n",
       " 0.06: [13507, array([8543, 8191, 8027, ..., 7796, 1755, 7199], dtype=int64)],\n",
       " 0.07: [11664, array([8543, 8191, 8027, ..., 7796, 3511, 7199], dtype=int64)],\n",
       " 0.08: [11626, array([8543, 8191, 8027, ..., 7796, 3511, 7199], dtype=int64)],\n",
       " 0.09: [11559, array([8543, 8191, 8027, ..., 7796, 3511, 7199], dtype=int64)],\n",
       " 0.1: [10812, array([8543, 8191, 8027, ..., 7796, 3511, 7199], dtype=int64)],\n",
       " 0.11: [9782, array([8543, 8191, 8027, ..., 7796, 3511, 7199], dtype=int64)],\n",
       " 0.12: [8958, array([8543, 8191, 8027, ..., 7796, 3511, 7199], dtype=int64)],\n",
       " 0.13: [6702, array([4271, 4095, 4013, ..., 3897, 3511, 3599], dtype=int64)],\n",
       " 0.14: [6698, array([4271, 4095, 4013, ..., 3897, 3511, 3599], dtype=int64)],\n",
       " 0.15: [6690, array([4271, 4095, 4013, ..., 3897, 3511, 3599], dtype=int64)],\n",
       " 0.16: [6672, array([4271, 4095, 4013, ..., 3897, 3511, 3599], dtype=int64)],\n",
       " 0.17: [6672, array([4271, 4095, 4013, ..., 3897, 3511, 3599], dtype=int64)],\n",
       " 0.18: [6598, array([4271, 4095, 4013, ..., 3897, 3511, 3599], dtype=int64)],\n",
       " 0.19: [6168, array([4271, 4095, 4013, ..., 3897, 3511, 3599], dtype=int64)],\n",
       " 0.2: [6167, array([4271, 4095, 4013, ..., 3897, 3511, 3599], dtype=int64)],\n",
       " 0.21: [6147, array([4271, 4095, 4013, ..., 3897, 3511, 3599], dtype=int64)],\n",
       " 0.22: [5581, array([4271, 4095, 4013, ..., 3897, 3511, 3599], dtype=int64)],\n",
       " 0.23: [5580, array([4271, 4095, 4013, ..., 3897, 3511, 3599], dtype=int64)],\n",
       " 0.24: [4784, array([4271, 4095, 4013, ..., 3897, 3511, 3599], dtype=int64)],\n",
       " 0.25: [2205, array([2135, 2047,  485, ..., 1948, 1755, 1799], dtype=int64)],\n",
       " 0.26: [2159, array([2135, 2047,  485, ..., 1948, 1755, 1799], dtype=int64)],\n",
       " 0.27: [2159, array([2135, 2047,  485, ..., 1948, 1755, 1799], dtype=int64)],\n",
       " 0.28: [2159, array([2135, 2047,  485, ..., 1948, 1755, 1799], dtype=int64)],\n",
       " 0.29: [2159, array([2135, 2047,  485, ..., 1948, 1755, 1799], dtype=int64)],\n",
       " 0.3: [2158, array([2135, 2047,  485, ..., 1948, 1755, 1799], dtype=int64)],\n",
       " 0.31: [2154, array([2135, 2047,  485, ..., 1948, 1755, 1799], dtype=int64)],\n",
       " 0.32: [2148, array([2135, 2047,  485, ..., 1948, 1755, 1799], dtype=int64)],\n",
       " 0.33: [2148, array([2135, 2047,  485, ..., 1948, 1755, 1799], dtype=int64)],\n",
       " 0.34: [2148, array([2135, 2047,  485, ..., 1948, 1755, 1799], dtype=int64)],\n",
       " 0.35000000000000003: [2142,\n",
       "  array([2135, 2047,  485, ..., 1948, 1755, 1799], dtype=int64)],\n",
       " 0.36: [2134, array([1067, 2047,  485, ..., 1948, 1755, 1799], dtype=int64)],\n",
       " 0.37: [2121, array([1067, 2047,  485, ..., 1948, 1755, 1799], dtype=int64)],\n",
       " 0.38: [2024, array([1067, 1023,  971, ...,    1, 1755, 1799], dtype=int64)],\n",
       " 0.39: [2024, array([1067, 1023,  971, ...,    1, 1755, 1799], dtype=int64)],\n",
       " 0.4: [2024, array([1067, 1023,  971, ...,    1, 1755, 1799], dtype=int64)],\n",
       " 0.41000000000000003: [2019,\n",
       "  array([1067, 1023,  971, ...,    4, 1755, 1799], dtype=int64)],\n",
       " 0.42: [2019, array([1067, 1023,  971, ...,    4, 1755, 1799], dtype=int64)],\n",
       " 0.43: [2011, array([1067, 1023,  971, ...,    9, 1755, 1799], dtype=int64)],\n",
       " 0.44: [1904, array([1067, 1023,  485, ...,   79, 1755, 1799], dtype=int64)],\n",
       " 0.45: [1904, array([1067, 1023,  485, ...,   79, 1755, 1799], dtype=int64)]}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "threshold_map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold = 0.05\n",
    "cluster_words_mapping = dict()\n",
    "cluster_lables = threshold_map[threshold][1]\n",
    "\n",
    "for i in range(len(cluster_lables)):\n",
    "  if cluster_words_mapping.get(cluster_lables[i]) == None:\n",
    "    cluster_words_mapping[cluster_lables[i]] = [word_list[i]]\n",
    "  else:\n",
    "    cluster_words_mapping[cluster_lables[i]].append(word_list[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_root_word_mapping = dict()\n",
    "for k,v in cluster_words_mapping.items():\n",
    "  root_word = commonprefix(v)\n",
    "  for word in v:\n",
    "    word_root_word_mapping[word] = root_word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "count = 0\n",
    "for word in word_list:\n",
    "    stemmer = PorterStemmer()\n",
    "    \n",
    "    if word_root_word_mapping[word] == stemmer.stem(word):\n",
    "        count+=1\n",
    "        \n",
    "    print(\"Original Word: \",word,\" | Stemming using D1: \",word_root_word_mapping[word],\" | Stemming using Porter Stemmer: \",stemmer.stem(word))\n",
    "    print(\"*\"*100)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Clustering using D2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d2_matrix = np.zeros((23531,23531))\n",
    "for i in range(23531):\n",
    "    for j in range(23531): \n",
    "        if i == j:\n",
    "            d2_matrix[i][j] = 0\n",
    "        elif d2_matrix[j][i] > 0:\n",
    "            d2_matrix[i][j] = d2_matrix[j][i]\n",
    "        else:\n",
    "          d2_matrix[i][j] = distanceD2(word_list[i],word_list[j])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataframe = pd.DataFrame(d2_matrix)\n",
    "dataframe.to_csv(\"/content/gdrive/My Drive/Information_Retrieval/D2_matrix.csv\")\n",
    "data_D2 = pd.read_csv('/content/gdrive/My Drive/Information_Retrieval/D2_matrix.csv',header = None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "D2_matrix = data_D2.apply(pd.to_numeric)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "D2_matrix = D2_matrix.replace(to_replace =float('inf'), \n",
    "                 value =np.finfo(np.float64).max)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold_values = np.arange(0,0.9,0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold_map = dict()\n",
    "for threshold in threshold_values:\n",
    "  agg_clustering = AgglomerativeClustering(n_clusters = None,linkage='complete',affinity='precomputed',distance_threshold = threshold)\n",
    "  agg_clustering.fit(D2_matrix)\n",
    "  number_of_clusters = agg_clustering.n_clusters_\n",
    "  cluster_labels = agg_clustering.labels_\n",
    "  threshold_map[threshold] = [number_of_clusters,cluster_labels]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('/content/gdrive/My Drive/Information_Retrieval/D2_cluster_data.pickle', 'wb') as handle:\n",
    "    pickle.dump(threshold_map, handle, protocol=pickle.HIGHEST_PROTOCOL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold_map = dict()\n",
    "with open('D2_cluster_data.pickle', 'rb') as handle:\n",
    "    threshold_map = pickle.load(handle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_of_clusters = []\n",
    "for i in threshold_values:\n",
    "  number_of_clusters.append(threshold_map[i][0]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Distance D2')"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.grid()\n",
    "plt.plot(threshold_values,number_of_clusters)\n",
    "plt.scatter(threshold_values,number_of_clusters)\n",
    "plt.xlabel(\"Threshold Values\")\n",
    "plt.ylabel(\"Number of clusters\")\n",
    "plt.title(\"Distance D2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0.0: [23531,\n",
       "  array([23530, 20564, 23529, ...,     6,     2,     0], dtype=int64)],\n",
       " 0.01: [12602,\n",
       "  array([ 8447,  8447, 11667, ...,     1,     0,     0], dtype=int64)],\n",
       " 0.02: [12602,\n",
       "  array([ 8447,  8447, 11667, ...,     1,     0,     0], dtype=int64)],\n",
       " 0.03: [12602,\n",
       "  array([ 8447,  8447, 11667, ...,     1,     0,     0], dtype=int64)],\n",
       " 0.04: [12602,\n",
       "  array([ 8447,  8447, 11667, ...,     1,     0,     0], dtype=int64)],\n",
       " 0.05: [12602,\n",
       "  array([ 8447,  8447, 11667, ...,     1,     0,     0], dtype=int64)],\n",
       " 0.06: [12602,\n",
       "  array([ 8447,  8447, 11667, ...,     1,     0,     0], dtype=int64)],\n",
       " 0.07: [12602,\n",
       "  array([ 8447,  8447, 11667, ...,     1,     0,     0], dtype=int64)],\n",
       " 0.08: [12599,\n",
       "  array([ 8447,  8447, 11667, ...,     4,     7,     7], dtype=int64)],\n",
       " 0.09: [12594,\n",
       "  array([ 8447,  8447, 11667, ...,    10,    31,    31], dtype=int64)],\n",
       " 0.1: [12581,\n",
       "  array([ 8447,  8447, 11667, ...,    45,    64,    64], dtype=int64)],\n",
       " 0.11: [12562,\n",
       "  array([ 8447,  8447, 11667, ...,    92,    64,    64], dtype=int64)],\n",
       " 0.12: [12530,\n",
       "  array([ 8447,  8447, 11667, ...,   186,   259,   259], dtype=int64)],\n",
       " 0.13: [12463,\n",
       "  array([ 8447,  8447, 11667, ...,   186,   259,   259], dtype=int64)],\n",
       " 0.14: [12457,\n",
       "  array([ 8447,  8447, 11667, ...,   186,   259,   259], dtype=int64)],\n",
       " 0.15: [12372,\n",
       "  array([ 8447,  8447, 11667, ...,   186,  1041,  1041], dtype=int64)],\n",
       " 0.16: [12350,\n",
       "  array([ 8447,  8447, 11667, ...,   186,  1041,  1041], dtype=int64)],\n",
       " 0.17: [12204,\n",
       "  array([ 8447,  8447, 11667, ...,   186,  1041,  1041], dtype=int64)],\n",
       " 0.18: [12192,\n",
       "  array([ 8447,  8447, 11667, ...,   186,  1041,  1041], dtype=int64)],\n",
       " 0.19: [12122,\n",
       "  array([ 8447,  8447, 11667, ...,   186,  1041,  1041], dtype=int64)],\n",
       " 0.2: [12090,\n",
       "  array([ 8447,  8447, 11667, ...,   374,  1041,  1041], dtype=int64)],\n",
       " 0.21: [11992,\n",
       "  array([ 8447,  8447, 11667, ...,   374,  1041,  1041], dtype=int64)],\n",
       " 0.22: [11788,\n",
       "  array([ 8447,  8447, 11667, ...,   374,  1041,  1041], dtype=int64)],\n",
       " 0.23: [11788,\n",
       "  array([ 8447,  8447, 11667, ...,   374,  1041,  1041], dtype=int64)],\n",
       " 0.24: [11747,\n",
       "  array([ 8447,  8447, 11667, ...,   374,  1041,  1041], dtype=int64)],\n",
       " 0.25: [11726,\n",
       "  array([ 8447,  8447, 11667, ...,   374,  1041,  1041], dtype=int64)],\n",
       " 0.26: [11296, array([8447, 8447, 5833, ..., 1501, 2083, 2083], dtype=int64)],\n",
       " 0.27: [11182, array([8447, 8447, 5833, ..., 1501, 2083, 2083], dtype=int64)],\n",
       " 0.28: [11109, array([8447, 8447, 5833, ..., 1501, 2083, 2083], dtype=int64)],\n",
       " 0.29: [11074, array([8447, 8447, 5833, ..., 1501, 2083, 2083], dtype=int64)],\n",
       " 0.3: [10766, array([8447, 8447, 5833, ..., 3004, 4167, 4167], dtype=int64)],\n",
       " 0.31: [10530, array([8447, 8447, 5833, ..., 3004, 4167, 4167], dtype=int64)],\n",
       " 0.32: [10335, array([8447, 8447, 5833, ..., 3004, 4167, 4167], dtype=int64)],\n",
       " 0.33: [10120, array([8447, 8447, 5833, ..., 3004, 4167, 4167], dtype=int64)],\n",
       " 0.34: [10037, array([8447, 8447, 5833, ..., 3004, 4167, 4167], dtype=int64)],\n",
       " 0.35000000000000003: [9599,\n",
       "  array([8447, 8447, 5833, ..., 3004, 4167, 4167], dtype=int64)],\n",
       " 0.36: [9599, array([8447, 8447, 5833, ..., 3004, 4167, 4167], dtype=int64)],\n",
       " 0.37: [9599, array([8447, 8447, 5833, ..., 3004, 4167, 4167], dtype=int64)],\n",
       " 0.38: [8940, array([8447, 8447, 5833, ..., 3004, 4167, 4167], dtype=int64)],\n",
       " 0.39: [8663, array([8447, 8447, 5833, ..., 3004, 4167, 4167], dtype=int64)],\n",
       " 0.4: [8274, array([4223, 4223, 5833, ..., 3004, 2083, 2083], dtype=int64)],\n",
       " 0.41000000000000003: [8274,\n",
       "  array([4223, 4223, 5833, ..., 3004, 2083, 2083], dtype=int64)],\n",
       " 0.42: [8274, array([4223, 4223, 5833, ..., 3004, 2083, 2083], dtype=int64)],\n",
       " 0.43: [8274, array([4223, 4223, 5833, ..., 3004, 2083, 2083], dtype=int64)],\n",
       " 0.44: [7708, array([4223, 4223, 5833, ..., 3004, 2083, 2083], dtype=int64)],\n",
       " 0.45: [7708, array([4223, 4223, 5833, ..., 3004, 2083, 2083], dtype=int64)],\n",
       " 0.46: [7708, array([4223, 4223, 5833, ..., 3004, 2083, 2083], dtype=int64)],\n",
       " 0.47000000000000003: [7093,\n",
       "  array([4223, 4223, 5833, ..., 3004, 2083, 2083], dtype=int64)],\n",
       " 0.48: [7093, array([4223, 4223, 5833, ..., 3004, 2083, 2083], dtype=int64)],\n",
       " 0.49: [6567, array([4223, 4223, 5833, ..., 3004, 2083, 2083], dtype=int64)],\n",
       " 0.5: [5542, array([4223, 4223, 2916, ..., 1501, 4167, 4167], dtype=int64)],\n",
       " 0.51: [5418, array([4223, 4223, 2916, ..., 1501, 4167, 4167], dtype=int64)],\n",
       " 0.52: [5418, array([4223, 4223, 2916, ..., 1501, 4167, 4167], dtype=int64)],\n",
       " 0.53: [5418, array([4223, 4223, 2916, ..., 1501, 4167, 4167], dtype=int64)],\n",
       " 0.54: [5418, array([4223, 4223, 2916, ..., 1501, 4167, 4167], dtype=int64)],\n",
       " 0.55: [5418, array([4223, 4223, 2916, ..., 1501, 4167, 4167], dtype=int64)],\n",
       " 0.56: [5418, array([4223, 4223, 2916, ..., 1501, 4167, 4167], dtype=int64)],\n",
       " 0.5700000000000001: [5418,\n",
       "  array([4223, 4223, 2916, ..., 1501, 4167, 4167], dtype=int64)],\n",
       " 0.58: [5418, array([4223, 4223, 2916, ..., 1501, 4167, 4167], dtype=int64)],\n",
       " 0.59: [5071, array([4223, 4223, 2916, ..., 1501, 4167, 4167], dtype=int64)],\n",
       " 0.6: [5071, array([4223, 4223, 2916, ..., 1501, 4167, 4167], dtype=int64)],\n",
       " 0.61: [5071, array([4223, 4223, 2916, ..., 1501, 4167, 4167], dtype=int64)],\n",
       " 0.62: [5071, array([4223, 4223, 2916, ..., 1501, 4167, 4167], dtype=int64)],\n",
       " 0.63: [4462, array([4223, 4223, 2916, ..., 1501, 4167, 4167], dtype=int64)],\n",
       " 0.64: [4462, array([4223, 4223, 2916, ..., 1501, 4167, 4167], dtype=int64)],\n",
       " 0.65: [3756, array([2111, 2111, 2916, ..., 1501, 2083, 2083], dtype=int64)],\n",
       " 0.66: [3122, array([2111, 2111,  486, ..., 1501, 2083, 2083], dtype=int64)],\n",
       " 0.67: [1935, array([1055, 1055,  483, ...,  750, 1041, 1041], dtype=int64)],\n",
       " 0.68: [1935, array([1055, 1055,  483, ...,  750, 1041, 1041], dtype=int64)],\n",
       " 0.6900000000000001: [1935,\n",
       "  array([1055, 1055,  483, ...,  750, 1041, 1041], dtype=int64)],\n",
       " 0.7000000000000001: [1935,\n",
       "  array([1055, 1055,  483, ...,  750, 1041, 1041], dtype=int64)],\n",
       " 0.71: [1935, array([1055, 1055,  483, ...,  750, 1041, 1041], dtype=int64)],\n",
       " 0.72: [1935, array([1055, 1055,  483, ...,  750, 1041, 1041], dtype=int64)],\n",
       " 0.73: [1935, array([1055, 1055,  483, ...,  750, 1041, 1041], dtype=int64)],\n",
       " 0.74: [1935, array([1055, 1055,  483, ...,  750, 1041, 1041], dtype=int64)],\n",
       " 0.75: [1935, array([1055, 1055,  483, ...,  750, 1041, 1041], dtype=int64)],\n",
       " 0.76: [1910, array([1055, 1055,  483, ...,  750, 1041, 1041], dtype=int64)],\n",
       " 0.77: [1910, array([1055, 1055,  483, ...,  750, 1041, 1041], dtype=int64)],\n",
       " 0.78: [1910, array([1055, 1055,  483, ...,  750, 1041, 1041], dtype=int64)],\n",
       " 0.79: [1910, array([1055, 1055,  483, ...,  750, 1041, 1041], dtype=int64)],\n",
       " 0.8: [1910, array([1055, 1055,  483, ...,  750, 1041, 1041], dtype=int64)],\n",
       " 0.81: [1910, array([1055, 1055,  483, ...,  750, 1041, 1041], dtype=int64)],\n",
       " 0.8200000000000001: [1910,\n",
       "  array([1055, 1055,  483, ...,  750, 1041, 1041], dtype=int64)],\n",
       " 0.8300000000000001: [1910,\n",
       "  array([1055, 1055,  483, ...,  750, 1041, 1041], dtype=int64)],\n",
       " 0.84: [1910, array([1055, 1055,  483, ...,  750, 1041, 1041], dtype=int64)],\n",
       " 0.85: [1910, array([1055, 1055,  483, ...,  750, 1041, 1041], dtype=int64)],\n",
       " 0.86: [1910, array([1055, 1055,  483, ...,  750, 1041, 1041], dtype=int64)],\n",
       " 0.87: [1910, array([1055, 1055,  483, ...,  750, 1041, 1041], dtype=int64)],\n",
       " 0.88: [1853, array([1055, 1055,  483, ...,  750, 1041, 1041], dtype=int64)],\n",
       " 0.89: [1853, array([1055, 1055,  483, ...,  750, 1041, 1041], dtype=int64)]}"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "threshold_map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_clusters_and_their_words = []\n",
    "threshold = 0.01\n",
    "cluster_words_mapping = dict()\n",
    "cluster_lables = threshold_map[threshold][1]\n",
    "\n",
    "for i in range(len(cluster_lables)):\n",
    "  if cluster_words_mapping.get(cluster_lables[i]) == None:\n",
    "    cluster_words_mapping[cluster_lables[i]] = [word_list[i]]\n",
    "  else:\n",
    "    cluster_words_mapping[cluster_lables[i]].append(word_list[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_root_word_mapping = dict()\n",
    "for k,v in cluster_words_mapping.items():\n",
    "  root_word = commonprefix(v)\n",
    "  for word in v:\n",
    "    word_root_word_mapping[word] = root_word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "count = 0\n",
    "for word in word_list:\n",
    "    stemmer = PorterStemmer()\n",
    "    \n",
    "    if word_root_word_mapping[word] == stemmer.stem(word):\n",
    "        count+=1\n",
    "        \n",
    "    print(\"Original Word: \",word,\" | Stemming using D2: \",word_root_word_mapping[word],\" | Stemming using Porter Stemmer: \",stemmer.stem(word))\n",
    "    print(\"*\"*100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Clustering using D3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d3_matrix = np.zeros((23531,23531))\n",
    "for i in range(23531):\n",
    "    for j in range(23531): \n",
    "        if i == j:\n",
    "            d3_matrix[i][j] = 0\n",
    "        elif d3_matrix[j][i] > 0:\n",
    "            d3_matrix[i][j] = d3_matrix[j][i]\n",
    "        else:\n",
    "          d3_matrix[i][j] = distanceD3(word_list[i],word_list[j])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataframe = pd.DataFrame(d3_matrix)\n",
    "dataframe.to_csv(\"/content/gdrive/My Drive/Information_Retrieval/D3_matrix.csv\")\n",
    "data_D3 = pd.read_csv('/content/gdrive/My Drive/Information_Retrieval/D3_matrix.csv',header = None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "D3_matrix = data_D3.apply(pd.to_numeric)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold_values = np.arange(0,3,0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold_map = dict()\n",
    "for threshold in threshold_values:\n",
    "  agg_clustering = AgglomerativeClustering(n_clusters = None,linkage='complete',affinity='precomputed',distance_threshold = threshold)\n",
    "  agg_clustering.fit(D3_matrix)\n",
    "  number_of_clusters = agg_clustering.n_clusters_\n",
    "  cluster_labels = agg_clustering.labels_\n",
    "  threshold_map[threshold] = [number_of_clusters,cluster_labels]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('/content/gdrive/My Drive/Information_Retrieval/D3_cluster_data.pickle', 'wb') as handle:\n",
    "    pickle.dump(threshold_map, handle, protocol=pickle.HIGHEST_PROTOCOL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold_map = dict()\n",
    "with open('D3_cluster_data.pickle', 'rb') as handle:\n",
    "    threshold_map = pickle.load(handle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_of_clusters = []\n",
    "for i in threshold_values:\n",
    "  number_of_clusters.append(threshold_map[i][0]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Distance D3')"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.grid()\n",
    "plt.plot(threshold_values,number_of_clusters)\n",
    "plt.scatter(threshold_values,number_of_clusters)\n",
    "plt.xlabel(\"Threshold Values\")\n",
    "plt.ylabel(\"Number of clusters\")\n",
    "plt.title(\"Distance D3\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0.0: [23531,\n",
       "  array([13210, 15375, 15055, ...,     6,     2,     0], dtype=int64)],\n",
       " 0.1: [23407,\n",
       "  array([13210, 15375, 15055, ...,   235,   116,    16], dtype=int64)],\n",
       " 0.2: [20743,\n",
       "  array([13210, 15375, 15055, ...,  3786,  3765,  1119], dtype=int64)],\n",
       " 0.30000000000000004: [18456,\n",
       "  array([13210, 15375, 15055, ...,  3786,  3765,  4479], dtype=int64)],\n",
       " 0.4: [17347,\n",
       "  array([13210, 15375, 15055, ...,  3786,  3765,  4479], dtype=int64)],\n",
       " 0.5: [16887,\n",
       "  array([13210, 15375, 15055, ...,  3786,  3765,  4479], dtype=int64)],\n",
       " 0.6000000000000001: [15154,\n",
       "  array([13210,  7687, 15055, ...,  3786,  7531,  8959], dtype=int64)],\n",
       " 0.7000000000000001: [14988,\n",
       "  array([13210,  7687,  7527, ...,  3786,  7531,  8959], dtype=int64)],\n",
       " 0.8: [13806,\n",
       "  array([13210,  7687,  7527, ...,  3786,  7531,  8959], dtype=int64)],\n",
       " 0.9: [13279,\n",
       "  array([13210,  7687,  7527, ...,  3786,  7531,  8959], dtype=int64)],\n",
       " 1.0: [13211,\n",
       "  array([13210,  7687,  7527, ...,  3786,  7531,  8959], dtype=int64)],\n",
       " 1.1: [11598, array([ 699, 7687, 7527, ..., 3786, 7531, 8959], dtype=int64)],\n",
       " 1.2000000000000002: [11598,\n",
       "  array([ 699, 7687, 7527, ..., 3786, 7531, 8959], dtype=int64)],\n",
       " 1.3: [11305, array([1400, 7687, 7527, ..., 3786, 7531, 8959], dtype=int64)],\n",
       " 1.4000000000000001: [10378,\n",
       "  array([1400, 7687, 7527, ..., 3786, 7531, 8959], dtype=int64)],\n",
       " 1.5: [10369, array([2801, 7687, 7527, ..., 3786, 7531, 8959], dtype=int64)],\n",
       " 1.6: [9586, array([2801, 7687, 7527, ...,    0, 7531, 8959], dtype=int64)],\n",
       " 1.7000000000000002: [9403,\n",
       "  array([2801, 7687, 7527, ...,  641, 7531, 8959], dtype=int64)],\n",
       " 1.8: [8583, array([2801, 7687, 7527, ..., 1283, 7531, 4479], dtype=int64)],\n",
       " 1.9000000000000001: [7937,\n",
       "  array([2801, 7687, 7527, ..., 2568, 7531, 4479], dtype=int64)],\n",
       " 2.0: [7615, array([2801, 3843, 7527, ..., 5137, 7531, 4479], dtype=int64)],\n",
       " 2.1: [7615, array([2801, 3843, 7527, ..., 5137, 7531, 4479], dtype=int64)],\n",
       " 2.2: [7615, array([2801, 3843, 7527, ..., 5137, 7531, 4479], dtype=int64)],\n",
       " 2.3000000000000003: [7611,\n",
       "  array([2801, 3843, 7527, ..., 5137, 7531, 4479], dtype=int64)],\n",
       " 2.4000000000000004: [7401,\n",
       "  array([2801, 3843, 3763, ..., 5137, 3765, 4479], dtype=int64)],\n",
       " 2.5: [6805, array([2801, 3843, 3763, ..., 5137, 3765, 4479], dtype=int64)],\n",
       " 2.6: [5910, array([2801, 3843, 3763, ..., 5137, 3765, 4479], dtype=int64)],\n",
       " 2.7: [5696, array([2801, 3843, 3763, ..., 5137, 3765, 4479], dtype=int64)],\n",
       " 2.8000000000000003: [5589,\n",
       "  array([2801, 3843, 3763, ..., 5137, 3765, 4479], dtype=int64)],\n",
       " 2.9000000000000004: [5589,\n",
       "  array([2801, 3843, 3763, ..., 5137, 3765, 4479], dtype=int64)]}"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "threshold_map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_clusters_and_their_words = []\n",
    "threshold = 0.7000000000000001\n",
    "cluster_words_mapping = dict()\n",
    "cluster_lables = threshold_map[threshold][1]\n",
    "\n",
    "for i in range(len(cluster_lables)):\n",
    "  if cluster_words_mapping.get(cluster_lables[i]) == None:\n",
    "    cluster_words_mapping[cluster_lables[i]] = [word_list[i]]\n",
    "  else:\n",
    "    cluster_words_mapping[cluster_lables[i]].append(word_list[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_root_word_mapping = dict()\n",
    "for k,v in cluster_words_mapping.items():\n",
    "  root_word = commonprefix(v)\n",
    "  for word in v:\n",
    "    word_root_word_mapping[word] = root_word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "count = 0\n",
    "for word in word_list:\n",
    "    stemmer = PorterStemmer()\n",
    "    \n",
    "    if word_root_word_mapping[word] == stemmer.stem(word):\n",
    "        count+=1\n",
    "        \n",
    "    print(\"Original Word: \",word,\" | Stemming using D3: \",word_root_word_mapping[word],\" | Stemming using Porter Stemmer: \",stemmer.stem(word))\n",
    "    print(\"*\"*100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Clustering using D4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d4_matrix = np.zeros((23531,23531))\n",
    "for i in range(23531):\n",
    "    for j in range(23531): \n",
    "        if i == j:\n",
    "            d4_matrix[i][j] = 0\n",
    "        elif d4_matrix[j][i] > 0:\n",
    "            d4_matrix[i][j] = d4_matrix[j][i]\n",
    "        else:\n",
    "          d4_matrix[i][j] = distanceD4(word_list[i],word_list[j])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataframe = pd.DataFrame(d4_matrix)\n",
    "dataframe.to_csv(\"/content/gdrive/My Drive/Information_Retrieval/D4_matrix.csv\")\n",
    "data_D4 = pd.read_csv('/content/gdrive/My Drive/Information_Retrieval/D4_matrix.csv',header = None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "D4_matrix = data_D4.apply(pd.to_numeric)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold_values = np.arange(0.2,1,0.02)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold_map = dict()\n",
    "for threshold in threshold_values:\n",
    "  agg_clustering = AgglomerativeClustering(n_clusters = None,linkage='complete',affinity='precomputed',distance_threshold = threshold)\n",
    "  agg_clustering.fit(D4_matrix)\n",
    "  number_of_clusters = agg_clustering.n_clusters_\n",
    "  cluster_labels = agg_clustering.labels_\n",
    "  threshold_map[threshold] = [number_of_clusters,cluster_labels]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('/content/gdrive/My Drive/Information_Retrieval/D4_cluster_data.pickle', 'wb') as handle:\n",
    "    pickle.dump(threshold_map, handle, protocol=pickle.HIGHEST_PROTOCOL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold_map = dict()\n",
    "with open('D4_cluster_data.pickle', 'rb') as handle:\n",
    "    threshold_map = pickle.load(handle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_of_clusters = []\n",
    "for i in threshold_values:\n",
    "  number_of_clusters.append(threshold_map[i][0]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Distance D4')"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.grid()\n",
    "plt.plot(threshold_values,number_of_clusters)\n",
    "plt.scatter(threshold_values,number_of_clusters)\n",
    "plt.xlabel(\"Threshold Values\")\n",
    "plt.ylabel(\"Number of clusters\")\n",
    "plt.title(\"Distance D4\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0.2: [19686,\n",
       "  array([14990, 10703, 15043, ..., 10251,  4032, 10947], dtype=int64)],\n",
       " 0.22: [18547,\n",
       "  array([14990, 10703, 15043, ..., 10251,  8065, 10947], dtype=int64)],\n",
       " 0.24: [18521,\n",
       "  array([14990, 10703, 15043, ..., 10251,  8065, 10947], dtype=int64)],\n",
       " 0.26: [17733,\n",
       "  array([14990, 10703, 15043, ..., 10251,  8065, 10947], dtype=int64)],\n",
       " 0.27999999999999997: [17590,\n",
       "  array([14990, 10703, 15043, ..., 10251, 16132, 10947], dtype=int64)],\n",
       " 0.29999999999999993: [17590,\n",
       "  array([14990, 10703, 15043, ..., 10251, 16132, 10947], dtype=int64)],\n",
       " 0.31999999999999995: [17347,\n",
       "  array([14990, 10703, 15043, ..., 10251, 16132, 10947], dtype=int64)],\n",
       " 0.33999999999999997: [16662,\n",
       "  array([14990, 10703, 15043, ..., 10251, 16132, 10947], dtype=int64)],\n",
       " 0.35999999999999993: [16658,\n",
       "  array([14990, 10703, 15043, ..., 10251, 16132, 10947], dtype=int64)],\n",
       " 0.3799999999999999: [16005,\n",
       "  array([14990, 10703, 15043, ..., 10251,  8065, 10947], dtype=int64)],\n",
       " 0.3999999999999999: [16005,\n",
       "  array([14990, 10703, 15043, ..., 10251,  8065, 10947], dtype=int64)],\n",
       " 0.41999999999999993: [15974,\n",
       "  array([14990, 10703, 15043, ..., 10251,  8065, 10947], dtype=int64)],\n",
       " 0.4399999999999999: [15157,\n",
       "  array([14990, 10703, 15043, ..., 10251,  8065, 10947], dtype=int64)],\n",
       " 0.4599999999999999: [15154,\n",
       "  array([14990, 10703, 15043, ..., 10251,  8065, 10947], dtype=int64)],\n",
       " 0.47999999999999987: [14991,\n",
       "  array([14990, 10703,  7521, ..., 10251,  8065, 10947], dtype=int64)],\n",
       " 0.49999999999999983: [14991,\n",
       "  array([14990, 10703,  7521, ..., 10251,  8065, 10947], dtype=int64)],\n",
       " 0.5199999999999998: [14122,\n",
       "  array([  475, 10703,  7521, ..., 10251,  8065, 10947], dtype=int64)],\n",
       " 0.5399999999999998: [13761,\n",
       "  array([  951, 10703,  7521, ..., 10251,  8065, 10947], dtype=int64)],\n",
       " 0.5599999999999998: [13761,\n",
       "  array([  951, 10703,  7521, ..., 10251,  8065, 10947], dtype=int64)],\n",
       " 0.5799999999999998: [13726,\n",
       "  array([  951, 10703,  7521, ..., 10251,  8065, 10947], dtype=int64)],\n",
       " 0.5999999999999999: [13235,\n",
       "  array([  951, 10703,  7521, ..., 10251,  8065, 10947], dtype=int64)],\n",
       " 0.6199999999999999: [12479,\n",
       "  array([  951, 10703,  7521, ..., 10251,  8065, 10947], dtype=int64)],\n",
       " 0.6399999999999998: [12415,\n",
       "  array([  951, 10703,  7521, ..., 10251,  8065, 10947], dtype=int64)],\n",
       " 0.6599999999999997: [11758,\n",
       "  array([  951, 10703,  7521, ..., 10251,  8065, 10947], dtype=int64)],\n",
       " 0.6799999999999997: [11758,\n",
       "  array([  951, 10703,  7521, ..., 10251,  8065, 10947], dtype=int64)],\n",
       " 0.6999999999999997: [11598,\n",
       "  array([  951, 10703,  7521, ..., 10251,  8065, 10947], dtype=int64)],\n",
       " 0.7199999999999998: [11598,\n",
       "  array([  951, 10703,  7521, ..., 10251,  8065, 10947], dtype=int64)],\n",
       " 0.7399999999999998: [11598,\n",
       "  array([  951, 10703,  7521, ..., 10251,  8065, 10947], dtype=int64)],\n",
       " 0.7599999999999998: [10112,\n",
       "  array([ 951, 5351, 7521, ...,   13, 8065, 5473], dtype=int64)],\n",
       " 0.7799999999999998: [10112,\n",
       "  array([ 951, 5351, 7521, ...,   13, 8065, 5473], dtype=int64)],\n",
       " 0.7999999999999996: [10109,\n",
       "  array([ 951, 5351, 7521, ...,   13, 8065, 5473], dtype=int64)],\n",
       " 0.8199999999999996: [10046,\n",
       "  array([ 951, 5351, 7521, ...,   13, 8065, 5473], dtype=int64)],\n",
       " 0.8399999999999996: [9593,\n",
       "  array([3807, 5351, 7521, ..., 1805, 8065, 5473], dtype=int64)],\n",
       " 0.8599999999999997: [9585,\n",
       "  array([3807, 5351, 7521, ..., 1805, 8065, 5473], dtype=int64)],\n",
       " 0.8799999999999997: [8770,\n",
       "  array([3807, 5351, 7521, ..., 1805, 8065, 5473], dtype=int64)],\n",
       " 0.8999999999999997: [8610,\n",
       "  array([3807, 5351, 7521, ..., 1805, 8065, 5473], dtype=int64)],\n",
       " 0.9199999999999997: [8592,\n",
       "  array([3807, 5351, 7521, ..., 1805, 8065, 5473], dtype=int64)],\n",
       " 0.9399999999999997: [7938,\n",
       "  array([3807, 5351, 7521, ..., 1805, 4032, 5473], dtype=int64)],\n",
       " 0.9599999999999995: [7938,\n",
       "  array([3807, 5351, 7521, ..., 1805, 4032, 5473], dtype=int64)],\n",
       " 0.9799999999999995: [7681,\n",
       "  array([3807, 5351, 7521, ..., 1805, 4032, 5473], dtype=int64)],\n",
       " 0.9999999999999996: [7617,\n",
       "  array([3807, 5351, 7521, ..., 1805, 4032, 5473], dtype=int64)],\n",
       " 1.0199999999999996: [7579,\n",
       "  array([  28, 5351, 7521, ..., 1805, 4032, 5473], dtype=int64)],\n",
       " 1.0399999999999996: [7579,\n",
       "  array([  28, 5351, 7521, ..., 1805, 4032, 5473], dtype=int64)],\n",
       " 1.0599999999999996: [7247,\n",
       "  array([ 116, 5351, 3760, ..., 1805, 4032, 5473], dtype=int64)],\n",
       " 1.0799999999999996: [5676,\n",
       "  array([ 939, 5351, 3760, ..., 1805, 4032, 5473], dtype=int64)],\n",
       " 1.0999999999999996: [5676,\n",
       "  array([ 939, 5351, 3760, ..., 1805, 4032, 5473], dtype=int64)],\n",
       " 1.1199999999999994: [5676,\n",
       "  array([ 939, 5351, 3760, ..., 1805, 4032, 5473], dtype=int64)],\n",
       " 1.1399999999999995: [5669,\n",
       "  array([ 939, 5351, 3760, ..., 1805, 4032, 5473], dtype=int64)],\n",
       " 1.1599999999999995: [5558,\n",
       "  array([1880, 5351, 3760, ..., 1805, 4032, 5473], dtype=int64)],\n",
       " 1.1799999999999995: [5558,\n",
       "  array([1880, 5351, 3760, ..., 1805, 4032, 5473], dtype=int64)],\n",
       " 1.1999999999999995: [5145,\n",
       "  array([1880, 2675, 3760, ..., 1805, 4032, 2736], dtype=int64)],\n",
       " 1.2199999999999995: [4324,\n",
       "  array([3762, 2675, 3760, ..., 1805, 4032, 2736], dtype=int64)],\n",
       " 1.2399999999999995: [4283,\n",
       "  array([3762, 2675, 3760, ..., 1805, 4032, 2736], dtype=int64)],\n",
       " 1.2599999999999993: [4029,\n",
       "  array([3762, 2675, 3760, ...,    1,    1, 2736], dtype=int64)],\n",
       " 1.2799999999999994: [3780,\n",
       "  array([3762, 2675, 3760, ...,   94,   94, 2736], dtype=int64)],\n",
       " 1.2999999999999994: [3764,\n",
       "  array([3762, 2675, 3760, ...,   94,   94, 2736], dtype=int64)],\n",
       " 1.3199999999999994: [3096,\n",
       "  array([ 180, 2675,  348, ...,  190,  190, 2736], dtype=int64)],\n",
       " 1.3399999999999994: [2970,\n",
       "  array([ 362, 2675,  698, ...,  382,  382, 2736], dtype=int64)],\n",
       " 1.3599999999999994: [2970,\n",
       "  array([ 362, 2675,  698, ...,  382,  382, 2736], dtype=int64)],\n",
       " 1.3799999999999994: [2968,\n",
       "  array([ 362, 2675,  698, ...,  382,  382, 2736], dtype=int64)],\n",
       " 1.3999999999999992: [2103,\n",
       "  array([1453, 1337,  235, ...,  343,  343, 1367], dtype=int64)],\n",
       " 1.4199999999999993: [2103,\n",
       "  array([1453, 1337,  235, ...,  343,  343, 1367], dtype=int64)],\n",
       " 1.4399999999999993: [2076,\n",
       "  array([1453, 1337,  471, ...,  343,  343, 1367], dtype=int64)],\n",
       " 1.4599999999999993: [1770,\n",
       "  array([1453, 1337,  471, ...,  688,  688, 1367], dtype=int64)],\n",
       " 1.4799999999999993: [1506,\n",
       "  array([1453, 1337,  944, ...,  688,  688, 1367], dtype=int64)],\n",
       " 1.4999999999999993: [1338,\n",
       "  array([ 726, 1337,  944, ...,  688,  688,  683], dtype=int64)],\n",
       " 1.5199999999999994: [1322,\n",
       "  array([  7,   7, 944, ..., 688, 688, 683], dtype=int64)],\n",
       " 1.5399999999999994: [1240,\n",
       "  array([ 31,  31, 944, ..., 688, 688, 683], dtype=int64)],\n",
       " 1.5599999999999994: [967,\n",
       "  array([128, 128, 944, ..., 688, 688, 683], dtype=int64)],\n",
       " 1.5799999999999992: [944,\n",
       "  array([257, 257, 471, ..., 688, 688, 683], dtype=int64)],\n",
       " 1.5999999999999992: [672,\n",
       "  array([257, 257, 327, ..., 171, 171, 341], dtype=int64)],\n",
       " 1.6199999999999992: [660,\n",
       "  array([257, 257, 327, ..., 343, 343, 341], dtype=int64)],\n",
       " 1.6399999999999992: [470,\n",
       "  array([257, 257, 215, ..., 343, 343, 341], dtype=int64)],\n",
       " 1.6599999999999993: [467,\n",
       "  array([257, 257, 215, ..., 343, 343, 341], dtype=int64)],\n",
       " 1.6799999999999993: [354,\n",
       "  array([257, 257,  63, ..., 343, 343, 341], dtype=int64)],\n",
       " 1.6999999999999993: [278,\n",
       "  array([ 27,  27, 128, ...,  53,  53,  53], dtype=int64)],\n",
       " 1.719999999999999: [251,\n",
       "  array([ 56,  56, 128, ...,  53,  53,  53], dtype=int64)],\n",
       " 1.739999999999999: [221,\n",
       "  array([ 12,  12, 128, ...,  53,  53,  53], dtype=int64)],\n",
       " 1.7599999999999991: [216,\n",
       "  array([ 25,  25, 128, ...,  53,  53,  53], dtype=int64)],\n",
       " 1.7799999999999991: [193,\n",
       "  array([ 40,  40, 128, ...,  53,  53,  53], dtype=int64)],\n",
       " 1.7999999999999992: [168,\n",
       "  array([ 40,  40, 128, ...,   2,   2,   2], dtype=int64)],\n",
       " 1.8199999999999992: [129,\n",
       "  array([ 30,  30, 128, ...,  25,  25,  25], dtype=int64)],\n",
       " 1.8399999999999992: [94, array([45, 45, 45, ..., 12, 12, 12], dtype=int64)],\n",
       " 1.8599999999999992: [47, array([ 9,  9,  9, ..., 12, 12, 12], dtype=int64)],\n",
       " 1.8799999999999992: [31, array([ 9,  9,  9, ..., 25, 25, 25], dtype=int64)],\n",
       " 1.899999999999999: [28, array([ 6,  6,  6, ..., 25, 25, 25], dtype=int64)],\n",
       " 1.919999999999999: [28, array([ 6,  6,  6, ..., 25, 25, 25], dtype=int64)],\n",
       " 1.939999999999999: [27, array([ 6,  6,  6, ..., 25, 25, 25], dtype=int64)],\n",
       " 1.959999999999999: [27, array([ 6,  6,  6, ..., 25, 25, 25], dtype=int64)],\n",
       " 1.979999999999999: [27, array([ 6,  6,  6, ..., 25, 25, 25], dtype=int64)]}"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "threshold_map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_clusters_and_their_words = []\n",
    "threshold = 0.47999999999999987\n",
    "cluster_words_mapping = dict()\n",
    "cluster_lables = threshold_map[threshold][1]\n",
    "\n",
    "for i in range(len(cluster_lables)):\n",
    "  if cluster_words_mapping.get(cluster_lables[i]) == None:\n",
    "    cluster_words_mapping[cluster_lables[i]] = [word_list[i]]\n",
    "  else:\n",
    "    cluster_words_mapping[cluster_lables[i]].append(word_list[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_root_word_mapping = dict()\n",
    "for k,v in cluster_words_mapping.items():\n",
    "  root_word = commonprefix(v)\n",
    "  for word in v:\n",
    "    word_root_word_mapping[word] = root_word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "count = 0\n",
    "for word in word_list:\n",
    "    stemmer = PorterStemmer()\n",
    "    \n",
    "    if word_root_word_mapping[word] == stemmer.stem(word):\n",
    "        count+=1\n",
    "        \n",
    "    print(\"Original Word: \",word,\" | Stemming using D4: \",word_root_word_mapping[word],\" | Stemming using Porter Stemmer: \",stemmer.stem(word))\n",
    "    print(\"*\"*100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Clustering using Levenstein distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Levenstein_distance_matrix = np.zeros((23531,23531))\n",
    "for i in range(23531):\n",
    "    for j in range(23531): \n",
    "        if i == j:\n",
    "            Levenstein_distance_matrix[i][j] = 0\n",
    "        elif Levenstein_distance_matrix[j][i] > 0:\n",
    "            Levenstein_distance_matrix[i][j] = Levenstein_distance_matrix[j][i]\n",
    "        else:\n",
    "          Levenstein_distance_matrix[i][j] = edit_distance(word_list[i],word_list[j])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataframe = pd.DataFrame(Levenstein_distance_matrix)\n",
    "dataframe.to_csv(\"/content/gdrive/My Drive/Information_Retrieval/Levenstein_distance_matrix.csv\")\n",
    "data_Levenstein_distance = pd.read_csv('/content/gdrive/My Drive/Information_Retrieval/Levenstein_distance_matrix.csv',header = None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Levenstein_distance_matrix = data_Levenstein_distance.apply(pd.to_numeric)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold_values = np.arange(1,28,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold_map = dict()\n",
    "for threshold in threshold_values:\n",
    "  agg_clustering = AgglomerativeClustering(n_clusters = None,linkage='complete',affinity='precomputed',distance_threshold = threshold)\n",
    "  agg_clustering.fit(Levenstein_distance_matrix)\n",
    "  number_of_clusters = agg_clustering.n_clusters_\n",
    "  cluster_labels = agg_clustering.labels_\n",
    "  threshold_map[threshold] = [number_of_clusters,cluster_labels]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('/content/gdrive/My Drive/Information_Retrieval/Levenstein_distance_data.pickle', 'wb') as handle:\n",
    "    pickle.dump(threshold_map, handle, protocol=pickle.HIGHEST_PROTOCOL)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold_map = dict()\n",
    "with open('Levenstein_distance_cluster_data.pickle', 'rb') as handle:\n",
    "    threshold_map = pickle.load(handle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_of_clusters = []\n",
    "for i in threshold_values:\n",
    "  number_of_clusters.append(threshold_map[i][0]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Distance Levenstein distance')"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.grid()\n",
    "plt.plot(threshold_values,number_of_clusters)\n",
    "plt.scatter(threshold_values,number_of_clusters)\n",
    "plt.xlabel(\"Threshold Values\")\n",
    "plt.ylabel(\"Number of clusters\")\n",
    "plt.title(\"Distance Levenstein distance\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: [23531,\n",
       "  array([23530, 23529, 20997, ...,     3,     1,     0], dtype=int64)],\n",
       " 2: [15815,\n",
       "  array([ 5069, 13150, 10498, ...,  1549,  1043,  2421], dtype=int64)],\n",
       " 3: [10499,\n",
       "  array([   82,  6932, 10498, ...,  1413,  1110,  4844], dtype=int64)],\n",
       " 4: [6973, array([   7, 3342, 4016, ..., 4609, 1732, 1703], dtype=int64)],\n",
       " 5: [4600, array([   0,  907, 4016, ...,    0, 1732, 3408], dtype=int64)],\n",
       " 6: [2986, array([   0, 1045,  877, ...,    0,  445,  316], dtype=int64)],\n",
       " 7: [1886, array([   0,  932, 1755, ...,    0,  598, 1269], dtype=int64)],\n",
       " 8: [1180, array([  0, 392, 563, ...,   0,  95,  95], dtype=int64)],\n",
       " 9: [709, array([  0,  49, 159, ...,   0, 103, 103], dtype=int64)],\n",
       " 10: [397, array([  0,   0, 156, ...,   0,  13,  13], dtype=int64)],\n",
       " 11: [222, array([ 0,  0, 28, ...,  0,  0,  0], dtype=int64)],\n",
       " 12: [114, array([ 0,  0, 17, ...,  0,  0,  0], dtype=int64)],\n",
       " 13: [58, array([ 0,  0, 14, ...,  0,  0,  0], dtype=int64)],\n",
       " 14: [25, array([0, 0, 0, ..., 0, 0, 0], dtype=int64)],\n",
       " 15: [11, array([0, 0, 0, ..., 0, 0, 0], dtype=int64)],\n",
       " 16: [6, array([0, 0, 0, ..., 0, 0, 0], dtype=int64)],\n",
       " 17: [3, array([0, 0, 0, ..., 0, 0, 0], dtype=int64)],\n",
       " 18: [2, array([0, 0, 0, ..., 0, 0, 0], dtype=int64)],\n",
       " 19: [2, array([0, 0, 0, ..., 0, 0, 0], dtype=int64)],\n",
       " 20: [2, array([0, 0, 0, ..., 0, 0, 0], dtype=int64)],\n",
       " 21: [2, array([0, 0, 0, ..., 0, 0, 0], dtype=int64)],\n",
       " 22: [2, array([0, 0, 0, ..., 0, 0, 0], dtype=int64)],\n",
       " 23: [2, array([0, 0, 0, ..., 0, 0, 0], dtype=int64)],\n",
       " 24: [2, array([0, 0, 0, ..., 0, 0, 0], dtype=int64)],\n",
       " 25: [2, array([0, 0, 0, ..., 0, 0, 0], dtype=int64)],\n",
       " 26: [2, array([0, 0, 0, ..., 0, 0, 0], dtype=int64)],\n",
       " 27: [2, array([0, 0, 0, ..., 0, 0, 0], dtype=int64)]}"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "threshold_map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_of_clusters_and_their_words = []\n",
    "threshold = 2\n",
    "cluster_words_mapping = dict()\n",
    "cluster_lables = threshold_map[threshold][1]\n",
    "\n",
    "for i in range(len(cluster_lables)):\n",
    "  if cluster_words_mapping.get(cluster_lables[i]) == None:\n",
    "    cluster_words_mapping[cluster_lables[i]] = [word_list[i]]\n",
    "  else:\n",
    "    cluster_words_mapping[cluster_lables[i]].append(word_list[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "word_root_word_mapping = dict()\n",
    "for k,v in cluster_words_mapping.items():\n",
    "  root_word = commonprefix(v)\n",
    "  for word in v:\n",
    "    word_root_word_mapping[word] = root_word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23531"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(word_root_word_mapping)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "count = 0\n",
    "for word in word_list:\n",
    "    stemmer = PorterStemmer()\n",
    "    \n",
    "    if word_root_word_mapping[word] == stemmer.stem(word):\n",
    "        count+=1\n",
    "        \n",
    "    print(\"Original Word: \",word,\" | Stemming using Levenstein distance: \",word_root_word_mapping[word],\" | Stemming using Porter Stemmer: \",stemmer.stem(word))\n",
    "    print(\"*\"*100)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}