04_datasketch_no_solution.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Using datasketch to find related sets in large corpora"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Computing the exact value for Jaccard similarity or containment for all pairs of sets in the corpus can be an expensive task. Let us consider for instance a corpus composed of 10k tables. Selected a query table and a column out of it, represented as a set of cells, we want to retrieve all tables in the corpus that are joinable with the query table on that column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import lzma\n",
    "import pandas as pd\n",
    "import pickle as pkl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tables = pkl.load(lzma.LZMAFile(\"datasets/joinable_tables/joinable_tables.pkl\", \"rb\"))\n",
    "id_mapping = {tables[i][\"_id\"]: i for i in range(0, len(tables))}  # map table ids to their indices inside the table list\n",
    "len(tables)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(tables[0][\"_id\"])\n",
    "print(tables[0][\"context\"])\n",
    "pd.DataFrame(tables[0][\"content\"], columns=tables[0][\"headers\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gt = pd.read_csv(\"datasets/joinable_tables/joinable_tables.csv\")\n",
    "gt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "datasketch provides probabilistic data structures that can process and search very large amount of data super fast, with little loss of accuracy.\n",
    "\n",
    "https://ekzhu.com/datasketch/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datasketch"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MinHash"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "datasketch.MinHash can be used to estimate the Jaccard similarity (resemblance) between sets of arbitrary sizes in linear time using a small and fixed memory space.\n",
    "\n",
    "https://ekzhu.com/datasketch/minhash.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datasketch import MinHash"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us consider two sets of values (e.g., two tokenized sentences)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data1 = ['minhash', 'is', 'a', 'probabilistic', 'data', 'structure', 'for', 'estimating', 'the', 'similarity', 'between', 'datasets']\n",
    "data2 = ['minhash', 'is', 'a', 'probability', 'data', 'structure', 'for', 'estimating', 'the', 'similarity', 'between', 'documents']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can estimate their Jaccard similarity through MinHash."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m1 = MinHash()  # by default 128 permutations, but the number can be adjusted, e.g., by setting num_perm=256\n",
    "for d in data1:\n",
    "    m1.update(d.encode('utf8'))\n",
    "m1.hashvalues"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m2 = MinHash()\n",
    "for d in data2:\n",
    "    m2.update(d.encode('utf8'))\n",
    "m2.hashvalues"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m1.jaccard(m2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\[For students\\] Let us check the exact value for the Jaccard similarity computed between the two sets of values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = set(data1)\n",
    "s2 = set(data2)\n",
    "# actual_jaccard = # write your solution here\n",
    "actual_jaccard"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But always keep in mind the shortcomings of Jaccard similarity..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data1 = ['minhash', 'is', 'a', 'probabilistic', 'data', 'structure', 'for', 'estimating', 'the', 'similarity', 'between', 'datasets']\n",
    "data2 = ['similarity', 'between', 'datasets']\n",
    "\n",
    "m1, m2 = MinHash(), MinHash()\n",
    "for d in data1:\n",
    "    m1.update(d.encode('utf8'))\n",
    "for d in data2:\n",
    "    m2.update(d.encode('utf8'))\n",
    "m1.jaccard(m2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MinHash LSH"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\[For students\\] Suppose you have a very large collection of sets. Given a query, which is also a set, you want to find sets in your collection that have Jaccard similarities above certain threshold, and you want to do it with many other queries. To do this efficiently, you can create a MinHash for every set, and when a query comes, you compute the Jaccard similarities between the query MinHash and all the MinHash of your collection, and return the sets that satisfy your threshold. \n",
    "\n",
    "In particular, let us consider:\n",
    "- table \"35424124-1_0\" as the query table\n",
    "- and its first column as the query column\n",
    "- different thresholds too, e.g., 0.7 and 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q_table_id = \"35424124-1_0\"\n",
    "q_table_index = id_mapping[q_table_id]\n",
    "print(tables[q_table_index][\"context\"])\n",
    "pd.DataFrame(tables[q_table_index][\"content\"], columns=tables[q_table_index][\"headers\"]).head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "minhash_list = list()\n",
    "# write your solution here\n",
    "# we want to insert in minhash_list tuples representing columns:\n",
    "# in the form: (tables[table_id][\"_id\"] + \"_\" + str(col_id), m), where m is the minhash of th column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q_col_id = 0\n",
    "q_col_set = {row[q_col_id] for row in tables[q_table_index][\"content\"]}\n",
    "qm = MinHash()\n",
    "for val in list(q_col_set):\n",
    "    qm.update(val.encode('utf8'))\n",
    "join_cols = list()\n",
    "for col in minhash_list:\n",
    "    if qm.jaccard(col[1]) >= 0.5:\n",
    "        join_cols.append(col[0])\n",
    "join_cols"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The said approach is still an O(n) algorithm, meaning the query cost increases linearly with respect to the number of sets. A popular alternative is to use Locality Sensitive Hashing (LSH) index. LSH can be used with MinHash to achieve sub-linear query cost - that is a huge improvement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datasketch import MinHashLSH"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "set1 = set(['minhash', 'is', 'a', 'probabilistic', 'data', 'structure', 'for', 'estimating', 'the', 'similarity', 'between', 'datasets'])\n",
    "set2 = set(['minhash', 'is', 'a', 'probability', 'data', 'structure', 'for', 'estimating', 'the', 'similarity', 'between', 'documents'])\n",
    "set3 = set(['similarity', 'between', 'documents'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m1 = MinHash(num_perm=128)\n",
    "m2 = MinHash(num_perm=128)\n",
    "m3 = MinHash(num_perm=128)\n",
    "for d in set1:\n",
    "    m1.update(d.encode('utf8'))\n",
    "for d in set2:\n",
    "    m2.update(d.encode('utf8'))\n",
    "for d in set3:\n",
    "    m3.update(d.encode('utf8'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lsh = MinHashLSH(threshold=0.5, num_perm=128)\n",
    "lsh.insert(\"m2\", m2)\n",
    "lsh.insert(\"m3\", m3)\n",
    "lsh.query(m1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define the query table and column and compute its MinHash."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q_table_id = \"35424124-1_0\"\n",
    "q_table_index = id_mapping[q_table_id]\n",
    "q_col_id = 0\n",
    "q_col_set = {row[q_col_id] for row in tables[q_table_index][\"content\"]}\n",
    "qm = MinHash(num_perm=128)\n",
    "for val in list(q_col_set):\n",
    "    qm.update(val.encode('utf8'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us reply the previous search for joinable columns using MinHash LSH. First, insert into the LSH index the MinHash of all table columns in the corpus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lsh = MinHashLSH(threshold=0.5, num_perm=128)\n",
    "for table_index in range(0, len(tables)):  # for each table\n",
    "    if tables[table_index][\"_id\"] != q_table_id:\n",
    "        for col_id in range(0, len(tables[table_index][\"headers\"])):  # for each column of the table\n",
    "            col_set = {row[col_id] for row in tables[table_index][\"content\"]}\n",
    "            m = MinHash(num_perm=128)\n",
    "            for val in list(col_set):\n",
    "                m.update(val.encode('utf8'))\n",
    "            lsh.insert(tables[table_index][\"_id\"] + \"_\" + str(col_id), m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, obtain the ones with a Jaccard similarity above the defined threshold."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "## compare the time with the previous approach\n",
    "lsh.query(qm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(lsh.b, lsh.r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\[For students\\] datasketch supports table querying scenario. Nevertheless, finding all pairs of sets whose similarity overcomes the defined threshold is useful in many cases. Therefore, try to implement MinHash LSH Banding to obtain all pairs of similar sets in the corpus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute MinHash for each table column\n",
    "minhash_list = list()\n",
    "for table_id in range(0, len(tables)):  # for each table\n",
    "    for col_id in range(0, len(tables[table_id][\"headers\"])):  # for each column of the table\n",
    "        col_set = {row[col_id] for row in tables[table_id][\"content\"]}\n",
    "        m = MinHash()\n",
    "        for val in list(col_set):\n",
    "            m.update(val.encode('utf8'))\n",
    "        minhash_list.append((tables[table_id][\"_id\"] + \"_\" + str(col_id), m))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Perform MinHash LSH Banding\n",
    "minhash_size = 128\n",
    "num_bands = 16\n",
    "num_rows = int(minhash_size / num_bands)  # number of rows in each band\n",
    "# write your solution here (check the slides)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import combinations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate the pairs of similar sets\n",
    "set_pairs = set()  # set to store the distinct set pairs\n",
    "for cluster in clusters:  # for each cluster\n",
    "    cluster_set_pairs = list(combinations(sorted(cluster[\"sets\"]), 2))  # compute the set pairs\n",
    "    for set_pair in cluster_set_pairs:  # add each table pair to the set pairs\n",
    "        set_pairs.add(set_pair)\n",
    "len(set_pairs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(set_pairs)[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MinHash LSH Forest"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "MinHash LSH is useful for threshold queries. However, top-k queries are often more useful in some cases. LSH Forest is a general LSH data structure that makes top-k query possible for many different types of LSH indexes, including MinHash LSH. MinHash LSH Forest returns therefore the top-k matching sets that have the approximately highest Jaccard similarity with the query set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q_table_id = \"23912408-1_0\"\n",
    "q_table_index = id_mapping[q_table_id]\n",
    "print(tables[q_table_index][\"_id\"])\n",
    "print(tables[q_table_index][\"context\"])\n",
    "pd.DataFrame(tables[q_table_index][\"content\"], columns=tables[q_table_index][\"headers\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gt[gt[\"query_table\"] == q_table_id]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "table_index = id_mapping[\"23912408-1_3\"]\n",
    "pd.DataFrame(tables[table_index][\"content\"], columns=tables[table_index][\"headers\"]).head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q_col_id = 0\n",
    "q_col_set = {row[q_col_id] for row in tables[q_table_index][\"content\"]}\n",
    "qm = MinHash(num_perm=128)\n",
    "for val in list(q_col_set):\n",
    "    qm.update(val.encode('utf8'))\n",
    "q_col_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lsh = MinHashLSH(threshold=0.5, num_perm=128)\n",
    "for table_index in range(0, len(tables)):  # for each table\n",
    "    if tables[table_index][\"_id\"] != q_table_id:\n",
    "        for col_id in range(0, len(tables[table_index][\"headers\"])):  # for each column of the table\n",
    "            col_set = {row[col_id] for row in tables[table_index][\"content\"]}\n",
    "            m = MinHash(num_perm=128)\n",
    "            for val in list(col_set):\n",
    "                m.update(val.encode('utf8'))\n",
    "            lsh.insert(tables[table_index][\"_id\"] + \"_\" + str(col_id), m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lsh.query(qm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "table_index = id_mapping[\"23912408-1_2\"]\n",
    "pd.DataFrame(tables[table_index][\"content\"], columns=tables[table_index][\"headers\"]).head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datasketch import MinHashLSHForest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "forest = MinHashLSHForest(num_perm=128)\n",
    "for table_index in range(0, len(tables)):  # for each table\n",
    "    if tables[table_index][\"_id\"] != q_table_id:\n",
    "        for col_id in range(0, len(tables[table_index][\"headers\"])):  # for each column of the table\n",
    "            col_set = {row[col_id] for row in tables[table_index][\"content\"]}\n",
    "            m = MinHash(num_perm=128)\n",
    "            for val in list(col_set):\n",
    "                m.update(val.encode('utf8'))\n",
    "            forest.add(tables[table_index][\"_id\"] + \"_\" + str(col_id), m)\n",
    "forest.index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "forest.query(qm, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## MinHash LSH Ensemble"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "LSH Ensemble is a LSH index for containment search: given a query set, it returns sets with containment above a certain threshold.\n",
    "\n",
    "![image.png](attachment:image.png)\n",
    "\n",
    "https://ekzhu.com/datasketch/lshensemble.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datasketch import MinHashLSHEnsemble"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q_table_id = \"23912408-1_0\"\n",
    "q_table_index = id_mapping[q_table_id]\n",
    "q_col_id = 0\n",
    "q_col_set = {row[q_col_id] for row in tables[q_table_index][\"content\"]}\n",
    "qm = MinHash(num_perm=128)\n",
    "for val in list(q_col_set):\n",
    "    qm.update(val.encode('utf8'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lshensemble = MinHashLSHEnsemble(threshold=0.8, num_perm=128, num_part=32)\n",
    "triples = list()  # an iterable of (key, minhash, size)\n",
    "for table_index in range(0, len(tables)):  # for each table\n",
    "    if tables[table_index][\"_id\"] != q_table_id:\n",
    "        for col_id in range(0, len(tables[table_index][\"headers\"])):  # for each column of the table\n",
    "            col_set = {row[col_id] for row in tables[table_index][\"content\"]}\n",
    "            m = MinHash(num_perm=128)\n",
    "            for val in list(col_set):\n",
    "                m.update(val.encode('utf8'))\n",
    "            triples.append((tables[table_index][\"_id\"] + \"_\" + str(col_id), m, len(col_set)))\n",
    "lshensemble.index(triples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[key for key in lshensemble.query(qm, len(q_col_set))]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bonus: Tokenization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gt[gt[\"query_table\"] == q_table_id]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "table_index = id_mapping[\"23912408-1_6\"]\n",
    "pd.DataFrame(tables[table_index][\"content\"], columns=tables[table_index][\"headers\"]).head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\[For students\\] Note that we can tokenize our cell values at different levels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q_col_id = 0\n",
    "q_col_set = {token for row in tables[q_table_index][\"content\"] for token in re.split(\" |-|_|'\", row[q_col_id])}\n",
    "qm = MinHash(num_perm=128)\n",
    "for val in list(q_col_set):\n",
    "    qm.update(val.encode('utf8'))\n",
    "q_col_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lshensemble = MinHashLSHEnsemble(threshold=0.8, num_perm=128, num_part=32)\n",
    "triples = list()  # an iterable of (key, minhash, size)\n",
    "# write your solution here\n",
    "lshensemble.index(triples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[key for key in lshensemble.query(qm, len(q_col_set))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}