task_01_duplicate_detection.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.sparse as sp\n",
    "import re\n",
    "import json\n",
    "import time\n",
    "\n",
    "from scipy.sparse import linalg as spl\n",
    "from collections import defaultdict\n",
    "from IPython.display import Markdown, display\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "words = np.load('top_25k_words.npy')\n",
    "bow_subset = sp.load_npz('bow_subset.npz')\n",
    "N = bow_subset.shape[0]\n",
    "\n",
    "with open('reviews_subset.json' , 'r') as f:\n",
    "    reviews = json.load(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(100000, 25000)\n"
     ]
    }
   ],
   "source": [
    "print(bow_subset.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['food' 'good' 'place' ... \"burke's\" 'electronica' 'peels']\n"
     ]
    }
   ],
   "source": [
    "print(words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'biz': {'categories': ['Restaurants', 'Steakhouses'],\n",
       "  'city': 'Las Vegas',\n",
       "  'name': \"Gallagher's Steakhouse\"},\n",
       " 'business_id': 'nnDLapJk1z2NJE0-XzwMlQ',\n",
       " 'review_id': '0Lx-agcwqjNhS4JtCVqkHQ',\n",
       " 'stars': 5,\n",
       " 'text': \"The surf and turf here was one of the best I've had.\\n\\nFilet mignon and lobster tail was very good.  i generally dont think the food in Vegas is great, but after being dissappointed on many occasions, I was pleasantly surprised with the quality of our meal.  Thanks to the Taste, i was lured to this restaurant only to find that it is a somehat hidden jewel in New York New York close to the sometimes obnoxious piana bar time square.  \\n\\nThe side of green beans were delish and the potatos are just meh.\\n\\nFor desert they  served an extremely delicious lemon pudding which taste more tart than pudding....it was fabulous.\\n\\nI think Gallaghers is good for couples, groups, and even kids.\",\n",
       " 'user_id': 'M63uPVZtCv7ReY2RgJRmOw'}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reviews[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cosine_distance(X, i, j):\n",
    "    \"\"\"Compute cosine distance between two rows of a sparse matrix.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    X : sp.spmatrix, shape [N, D]\n",
    "        Sparse data matrix.\n",
    "    i : int\n",
    "        Index of the first row.\n",
    "    j : int\n",
    "        Index of the second row.\n",
    "        \n",
    "    Returns\n",
    "    -------\n",
    "    d : float\n",
    "        Cosine distance between the two rows of the sparse matrix.\n",
    "        \n",
    "    \"\"\"\n",
    "    i_norm = spl.norm(X[i])\n",
    "    j_norm = spl.norm(X[j])\n",
    "    ij_dot = X[i].dot(X[j].T)[0, 0]\n",
    "    \n",
    "    return 1-ij_dot/(i_norm*j_norm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def LSH(X, b=8, r=32, d=0.3):\n",
    "    \"\"\"Find candidate duplicate pairs using LSH and refine using exact cosine distance.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    X : sp.spmatrix, shape [N, D]\n",
    "        Sparse data matrix.\n",
    "    b : int\n",
    "        Number of bands.\n",
    "    r : int\n",
    "        Number of rows per band.\n",
    "    d : float\n",
    "        Distance treshold for reporting duplicates.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    duplicates : {(ID1, ID2, d_{12}), ..., (IDX, IDY, d_{xy})}\n",
    "        A set of tuples indicating the detected duplicates.\n",
    "        Each tuple should have 3 elements:\n",
    "            * ID of the first review\n",
    "            * ID of the second review\n",
    "            * The cosine distance between them\n",
    "    \n",
    "    n_candidates : int\n",
    "        Number of detected candidate pairs.\n",
    "        \n",
    "    \"\"\"\n",
    "    np.random.seed(158)\n",
    "    n_candidates = 0\n",
    "    duplicates = set()\n",
    "    \n",
    "    ### YOUR CODE HERE ###\n",
    "    \n",
    "    \n",
    "    candidates = []\n",
    "    #create signature matrix size #by all number of documents and wanted number of hash\n",
    "    random_planes = np.zeros((bow_subset.shape[1], b * r))\n",
    "    for i in range(b * r):\n",
    "        random_planes[:, i] = np.random.normal(0, 1, bow_subset.shape[1])\n",
    "    signature_matrix = bow_subset.dot(random_planes)\n",
    "\n",
    "    # go over all hashed signature matrix , if matrix index> 0 means we are one side of\n",
    "    # the random plane(indicated as 1), if index<0 means we are another side of random plane(indicated as 0)\n",
    "    for k in range(signature_matrix.shape[1]):\n",
    "        for v in range(signature_matrix.shape[0]):\n",
    "            if signature_matrix[v, k] >= 0:\n",
    "                signature_matrix[v, k] = 1\n",
    "            else:\n",
    "                signature_matrix[v, k] = 0\n",
    "\n",
    "\n",
    "    #get signature matrix by dividing it small matrixes as size row size b  \n",
    "    for s in range(b):\n",
    "        dictionary = {}\n",
    "        for review in range(bow_subset.shape[0]):\n",
    "            b = ''.join(map(str, signature_matrix[review, (s * r):((s + 1) * r)]))\n",
    "            hash_value = hash(b)\n",
    "            if hash_value in dictionary.keys():\n",
    "                dictionary[hash_value].append(review)\n",
    "            else:\n",
    "                dictionary[hash_value] = [review]\n",
    "\n",
    "        #if there is more than one thing inside the dictionary row, that means we found candidate:\n",
    "        #we need to get all pairs from that row as follow:\n",
    "        for k, v in dictionary.items():\n",
    "            if len(dictionary[k]) > 1:\n",
    "                list_of_pairs = [(v[p1], v[p2]) for p1 in range(len(v)) for p2 in range(p1 + 1, len(v))]\n",
    "                candidates.append(list((list_of_pairs, 0)))\n",
    "\n",
    "    n_candidates = len(candidates)\n",
    "\n",
    "    #calculate all pair wise cosine similairty in candidates\n",
    "    #candidate list is like this: ((23,455), 0.1) -> document 23 and 455 has 0.1 cosine distance\n",
    "    for i in range(len(candidates)):\n",
    "        index1 = candidates[i][0][0][0]\n",
    "        index2 = candidates[i][0][0][1]\n",
    "        cos = cosine_distance(bow_subset, index1,  index2)\n",
    "        candidates[i][1] = cos\n",
    "\n",
    "    real_result = []\n",
    "    for i in range(len(candidates)):\n",
    "        if candidates[i][1] < d:   #get pairs only with cos dis is smaller than d threshold\n",
    "            real_result.append(candidates[i])\n",
    "\n",
    "    #only eliminate duplicated results(change duplicated list to set(there is no duplication in sets))\n",
    "    duplicates = set((real_result[i][0][0][0], real_result[i][0][0][1], real_result[i][1]) for i in range(len(real_result)))\n",
    "\n",
    "    return duplicates, n_candidates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "duplicates, n_candidates = LSH(bow_subset, b=6, r=28, d=0.2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We detected 845 candidates.\n"
     ]
    }
   ],
   "source": [
    "print('We detected {} candidates.'.format(n_candidates))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(1809, 13244, 0.0),\n",
       " (6600, 93310, 0.0),\n",
       " (17779, 72702, 1.1102230246251565e-16),\n",
       " (32066, 71726, 0.0),\n",
       " (35163, 82597, 1.1102230246251565e-16),\n",
       " (42795, 95179, 0.0),\n",
       " (47940, 65607, 0.0),\n",
       " (64525, 70002, 0.12712843905603044)}"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "duplicates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "**Good** **Service** **Good** **food**"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "vs.\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "**Service** is **good** very **friendly** and **good** **food** who **could** **want** more nagar it was very **good**"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "===\n",
      "Same business: False\n",
      "Same user: False\n",
      "Cosine distance 0.1271\n",
      "\n",
      "#######\n",
      "\n"
     ]
    }
   ],
   "source": [
    "similar_review_pairs = []\n",
    "for ix1, ix2, sim in duplicates:\n",
    "    rev1 = reviews[ix1]\n",
    "    rev2 = reviews[ix2]\n",
    "    similar_review_pairs.append((rev1, rev2, sim))\n",
    "    \n",
    "pattern = re.compile('(\\S+|\\n)')\n",
    "pattern_punctuation = re.compile('^\\W+|\\W+$')\n",
    "\n",
    "def highlight_vocabulary(text, vocabulary):\n",
    "    split = re.findall(r\"[\\w']+\", text)\n",
    "    in_vocabulary = [pattern.sub(lambda m: pattern_punctuation.sub('', m.group()), str.lower(x)) in words for x in split]\n",
    "    highlighted_words = [\"**{}**\".format(x) if in_vocabulary[ix] else x for ix,x in enumerate(split) ]\n",
    "    highlighted_text = \" \".join(highlighted_words)\n",
    "    return highlighted_text\n",
    "\n",
    "def printmd(string):\n",
    "    display(Markdown(string))\n",
    "\n",
    "\n",
    "for r1, r2, sim in similar_review_pairs:\n",
    "    if not np.isclose(sim, 0.0):\n",
    "        printmd(highlight_vocabulary(r1['text'], words))\n",
    "        print(\"\")\n",
    "        print(\"vs.\")\n",
    "        print(\"\")\n",
    "        printmd(highlight_vocabulary(r2['text'], words))\n",
    "        print(\"===\")\n",
    "        print(\"Same business: {}\".format(r1['business_id'] == r2['business_id']))\n",
    "        print(\"Same user: {}\".format(r1['user_id'] == r2['user_id']))\n",
    "        print(\"Cosine distance {:.4f}\".format(sim))\n",
    "        print(\"\")    \n",
    "        print(\"#######\")\n",
    "        print(\"\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# naively compute the duplicates using a double for loop\n",
    "def naive_duplicates(X, d = 0.2):\n",
    "    \"\"\"\n",
    "    Parameters\n",
    "    ----------\n",
    "    X : sp.spmatrix, shape [N, D]\n",
    "        Sparse data matrix.\n",
    "    d : float\n",
    "        Distance treshold for reporting duplicates.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    duplicates : {(ID1, ID2, d_{12}), ..., (IDX, IDY, d_{xy})}\n",
    "        A set of tuples indicating the detected duplicates.\n",
    "        Each tuple should have 3 elements:\n",
    "            * ID of the first review\n",
    "            * ID of the second review\n",
    "            * The cosine distance between them\n",
    "    \"\"\"\n",
    "    N = X.shape[0]\n",
    "    duplicates = set()\n",
    "    for i in range(N):\n",
    "        for j in range(N):\n",
    "            d_ij = cosine_distance(X, i, j)\n",
    "            if d_ij < d and i != j:\n",
    "                duplicates.add((i, j, d_ij))\n",
    "    return duplicates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def runtime_comparison():\n",
    "    \"\"\"\n",
    "    Compare the runtime between LSH and the naive approach.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    trace : [(n1, lsh_dur, naive_dur), (n2, lsh_dur, naive_dur), ... ]\n",
    "            A list of tuples with execution times for different number of reviews.\n",
    "            Each tuple should have 3 elements:\n",
    "                * number of reviews considered\n",
    "                * duration of the LSH approach\n",
    "                * duration of the naive approach\n",
    "    \"\"\"\n",
    "    trace = []\n",
    "    for n in np.arange(25, 251, 25):\n",
    "        print('Running comparison for {} reviews.'.format(n))\n",
    "        \n",
    "        ### YOUR CODE HERE ###\n",
    "        start = time.time()\n",
    "        LSH(bow_subset[:n], b=6, r=28, d=0.2)\n",
    "        end = time.time() - start\n",
    "\n",
    "        start_naive = time.time()\n",
    "        naive_duplicates(bow_subset[:n], d=0.2)\n",
    "        end_naive = time.time() - start_naive\n",
    "        print('Naive time: ', end_naive,' seconds')\n",
    "        print('LHS time: ', end,' seconds')\n",
    "\n",
    "        trace.append((n, end, end_naive))\n",
    "    return trace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running comparison for 25 reviews.\n",
      "Naive time:  0.44322705268859863  seconds\n",
      "LHS time:  16.85658025741577  seconds\n",
      "Running comparison for 50 reviews.\n",
      "Naive time:  1.7747151851654053  seconds\n",
      "LHS time:  16.85270667076111  seconds\n",
      "Running comparison for 75 reviews.\n",
      "Naive time:  4.757646322250366  seconds\n",
      "LHS time:  18.41991901397705  seconds\n",
      "Running comparison for 100 reviews.\n",
      "Naive time:  7.636318206787109  seconds\n",
      "LHS time:  18.200227737426758  seconds\n",
      "Running comparison for 125 reviews.\n",
      "Naive time:  12.04703950881958  seconds\n",
      "LHS time:  16.114455938339233  seconds\n",
      "Running comparison for 150 reviews.\n",
      "Naive time:  17.187649250030518  seconds\n",
      "LHS time:  16.235074758529663  seconds\n",
      "Running comparison for 175 reviews.\n",
      "Naive time:  24.51213526725769  seconds\n",
      "LHS time:  16.895872592926025  seconds\n",
      "Running comparison for 200 reviews.\n",
      "Naive time:  29.850348711013794  seconds\n",
      "LHS time:  16.225059986114502  seconds\n",
      "Running comparison for 225 reviews.\n",
      "Naive time:  36.8639440536499  seconds\n",
      "LHS time:  16.284204959869385  seconds\n",
      "Running comparison for 250 reviews.\n",
      "Naive time:  43.480438470840454  seconds\n",
      "LHS time:  15.228448867797852  seconds\n"
     ]
    }
   ],
   "source": [
    "trace = runtime_comparison()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1ab1893b160>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#My LSH implementation takes 15 seconds regardless of input size, it is little longer than example code you provided but still\n",
    "# O(N) complexity\n",
    "plt.ylim([0,60])\n",
    "plt.xlim([25, 250])\n",
    "\n",
    "plt.plot( [y[0] for y in trace],  [y[1] for y in trace]) \n",
    "plt.plot(  [y[0] for y in trace],  [y[2] for y in trace]) \n",
    "\n",
    "plt.title('Comparison')\n",
    "plt.ylabel('Time in seconds')\n",
    "plt.xlabel('Number of reviews processed')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}