1998-Similarity Search in High Dimensions via Hashing.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# preliminaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from sklearn import datasets\n",
    "from scipy.stats import norm\n",
    "from scipy.stats import cauchy\n",
    "import scipy.stats as stats\n",
    "from scipy.spatial import distance \n",
    "import math\n",
    "from sklearn.preprocessing import Normalizer\n",
    "from hashlib import md5\n",
    "import sys\n",
    "from sklearn.model_selection import train_test_split\n",
    "import timeit\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "mbyte = 1048576\n",
    "norm_l1 = Normalizer(norm='l1')\n",
    "norm_l2 = Normalizer(norm='l2')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def R(P):\n",
    "    max_p = P.max(axis=0)\n",
    "    min_p = P.min(axis=0)\n",
    "    R = np.sqrt(np.sum((max_p - min_p) ** 2))\n",
    "    return R / 2\n",
    "\n",
    "def generate_md5(H):\n",
    "    hmd5 = md5()\n",
    "    hmd5.update(str(H).encode(encoding='utf-8'))\n",
    "    return hmd5.hexdigest()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "%store -r Datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['SIFT-10K'])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Datasets.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = Datasets['SIFT-10K']\n",
    "\n",
    "train = data['train']\n",
    "test = data['test']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 测试 L1 与 L2 距离结果类似"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "q = test[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2176, 2837,  882, 3752,  190, 1045, 3615, 4009,  292, 1272,  107,\n",
       "        816, 1295, 9541,  492,  146,  224, 1156, 9806, 4938])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argsort([distance.minkowski(p, q, p=1) for p in train])[:20]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2176, 3752,  882, 4009, 2837,  190, 3615,  816, 1045, 1884,  224,\n",
       "       3013,  292, 1272, 5307, 4938, 1295,  492, 9211, 3625])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argsort([distance.euclidean(p, q) for p in train])[:20]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_r1(P):\n",
    "    \"\"\"\n",
    "    Desc:\n",
    "        Caculate r1\n",
    "        20 points nearest neighbor\n",
    "    \n",
    "    Arg:\n",
    "        P: dataset\n",
    "    \n",
    "    Return:\n",
    "        r1\n",
    "    \"\"\"\n",
    "    n = P.shape[0]\n",
    "    idxs = np.random.choice(np.arange(n), 20, replace=False)\n",
    "    r1 = 0\n",
    "    far = 0\n",
    "    for idx in idxs:\n",
    "        q = P[idx]\n",
    "        ds = np.sort(np.array([distance.minkowski(q, p, p=1) for p in P]))\n",
    "        r1 += ds[1]\n",
    "        far += ds[-1]\n",
    "    print('nearest: {:.4f}, far: {:.4f}'.format(math.ceil(r1 / len(idxs)), math.ceil(far / len(idxs))))\n",
    "    return math.ceil(r1 / len(idxs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "p_1 = 1 - \\frac{r}{d^{'}} \\\\\n",
    "p_2 = 1 - \\frac{r(1+\\epsilon)}{d^{'}}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_Pr(P, Cd, r, epsilon):\n",
    "    \"\"\"\n",
    "    Desc:\n",
    "        p1, p2\n",
    "    \n",
    "    Args:\n",
    "        P: dataset\n",
    "        Cd: max value * d\n",
    "        r: r1\n",
    "        epsilon: approximate factor\n",
    "    \n",
    "    Returns:\n",
    "        p1\n",
    "        p2\n",
    "    \"\"\"\n",
    "    \n",
    "    p1 = 1 - r / Cd\n",
    "    p2 = 1 - (1 + epsilon) * r / Cd\n",
    "    return p1, p2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**引用 B**\n",
    "$$\n",
    "k = log_{p_2}\\frac{B}{n} \\\\\n",
    "\\rho = \\frac{\\text{ln} 1/p_1}{\\text{ln} 1/p_2} \\\\\n",
    "L = (\\frac{n}{B})^\\rho\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**不引用 B**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "k = log_{p_2}\\frac{1}{n} \\\\\n",
    "\\rho = \\frac{\\text{ln} 1/p_1}{\\text{ln} 1/p_2} \\\\\n",
    "L = n^\\rho\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**引入错误率 $\\delta$**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "L \\ge \\frac{\\text{log}1/\\delta}{-\\text{log}(1-p_1^k)}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_kL(P, p1, p2, delta, B=None):\n",
    "    \"\"\"\n",
    "    Desc:\n",
    "        k, L\n",
    "    \n",
    "    Args:\n",
    "        P\n",
    "        p1\n",
    "        p2\n",
    "        delta: miss ratio\n",
    "        B: with M\n",
    "    \n",
    "    Returns:\n",
    "        k\n",
    "        L\n",
    "    \"\"\"\n",
    "    n, d = P.shape\n",
    "    if B is None:\n",
    "        k = math.ceil(np.log(1/n) / np.log(p2))\n",
    "    else:\n",
    "        k = math.ceil(np.log(n/B) / np.log(1/p2))\n",
    "\n",
    "    L = math.ceil(-np.log(1 / delta) / np.log(1 - (p1 ** k)))\n",
    "    return k, L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "M = \\alpha\\frac{n}{B}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_M(n, B, alpha):\n",
    "    return math.ceil(alpha * n / B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocessing(P, k, L, C, M=None, random_state=None):\n",
    "    \"\"\"\n",
    "    Desc:\n",
    "        Construct Data Struture.\n",
    "\n",
    "    Args:\n",
    "        P: dataset\n",
    "        k: number of h\n",
    "        L: number of g\n",
    "        M: number of hash tables\n",
    "        C: max value, Cd = C * d\n",
    "        random_state: random seed\n",
    "\n",
    "    Returns:\n",
    "        M is None:\n",
    "            G\n",
    "            hash_tables\n",
    "        Else:\n",
    "            fp_rand: fingerprint\n",
    "            G\n",
    "            hash_tables\n",
    "    \"\"\"\n",
    "    \n",
    "    if random_state is None:\n",
    "        rand = np.random.RandomState()\n",
    "    else:\n",
    "        rand = np.random.RandomState(random_state)\n",
    "\n",
    "    n, d = P.shape\n",
    "    \n",
    "    hash_tables = []\n",
    "    # for M\n",
    "    if M is not None:\n",
    "        fp_rand = rand.randint(0, M, k)\n",
    "\n",
    "    Cd = C * d\n",
    "    # hash family\n",
    "    G = np.sort(rand.choice(np.arange(Cd), (L, k), replace=True).astype(np.int))\n",
    "    \n",
    "    hash_tables = []\n",
    "    for i in range(L):\n",
    "        hash_tables.append(dict())\n",
    "\n",
    "    for idx, p in enumerate(P):\n",
    "        Gv = (p[G // C] > (G % C)).astype(np.int)\n",
    "        if M is not None:\n",
    "            Gv = Gv.dot(fp_rand) % M\n",
    "            for i, gv in enumerate(Gv):\n",
    "                if gv in hash_tables[i]:\n",
    "                    hash_tables[i][gv].append(idx)\n",
    "                else:\n",
    "                    hash_tables[i][gv] = [idx]\n",
    "    \n",
    "    if M is None:\n",
    "        return G, hash_tables\n",
    "    else:\n",
    "        return G, hash_tables, fp_rand"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# query"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def query(args, q):\n",
    "    \"\"\"\n",
    "    Desc:\n",
    "        Query Function\n",
    "    \n",
    "    Args:\n",
    "        P: dataset\n",
    "        q: query\n",
    "        C: max value\n",
    "        M: number of hash tables\n",
    "        fp_rand\n",
    "        G\n",
    "        hash_tables\n",
    "    \n",
    "    Result:\n",
    "        nearest points (maybe)\n",
    "    \"\"\"\n",
    "    C = args['C']\n",
    "    G = args['G']\n",
    "    hash_tables = args['hash_tables']\n",
    "    \n",
    "    Gv = (q[G // C] > (G % C)).astype(np.int)\n",
    "    \n",
    "    if 'M' in args:\n",
    "        M = args['M']\n",
    "        fp_rand = args['fp_rand']\n",
    "        Gv = Gv.dot(fp_rand) % M\n",
    "    \n",
    "    result = []\n",
    "\n",
    "    for i, gv in enumerate(Gv):\n",
    "        if gv in hash_tables[i]:\n",
    "            result.append(hash_tables[i][gv])\n",
    "    \n",
    "    if len(result) != 0:\n",
    "        result = np.unique(np.concatenate(np.array(result)))\n",
    "\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def metrics(P, query_func, args, test, exact_nearest):\n",
    "    \"\"\"\n",
    "    Pr of find nearest neighbor, Error ratio, memory\n",
    "    \n",
    "    Args:\n",
    "        P\n",
    "        query_func(args, q)\n",
    "        args\n",
    "        test\n",
    "        exact_nearest\n",
    "    \n",
    "    Returns:\n",
    "        pr of find nearest neighbor\n",
    "        error ratio\n",
    "        memory\n",
    "    \"\"\"\n",
    "    # memory\n",
    "    size = 0\n",
    "    hash_tables = args['hash_tables']\n",
    "    for buckets in hash_tables:\n",
    "        for idx, bucket in buckets.items():\n",
    "            size += sys.getsizeof(idx)\n",
    "            for b in bucket:\n",
    "                size += sys.getsizeof(b)\n",
    "    memory = size / mbyte\n",
    "    \n",
    "    test_n = test.shape[0]\n",
    "    correct = 0\n",
    "    dis_total = 0\n",
    "\n",
    "    for i in range(test_n):\n",
    "        result = query_func(args, test[i])\n",
    "        if len(result) != 0:\n",
    "            if exact_nearest[i] in result:\n",
    "                correct += 1   \n",
    "        else:\n",
    "            correct += 1\n",
    "\n",
    "        dis = np.array([distance.euclidean(P[idx], test[i]) for idx in result])\n",
    "        idx_approximate_nearest_neighbor = dis.argsort()[0]\n",
    "        dis_total += ((dis[idx_approximate_nearest_neighbor] / \n",
    "                      distance.euclidean(test[i], P[exact_nearest[i]])) - 1)\n",
    "\n",
    "    return correct / test_n, dis_total / test_n, memory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "P = train\n",
    "C = P.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = 100\n",
    "alpha = 2\n",
    "epsilon = 1\n",
    "n, d = P.shape\n",
    "Cd = C * d\n",
    "M = get_M(n, B, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nearest: 1017.0000, far: 5867.0000\n",
      "CPU times: user 2.92 s, sys: 69.2 ms, total: 2.99 s\n",
      "Wall time: 2.94 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "r = get_r1(P)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "p1: 0.9559, p2: 0.9117\n"
     ]
    }
   ],
   "source": [
    "p1, p2 = get_Pr(P, Cd, r, epsilon)\n",
    "print('p1: {:.4f}, p2: {:.4f}'.format(p1, p2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k = 100, L = 110\n"
     ]
    }
   ],
   "source": [
    "k, L = get_kL(P, p1, p2, delta=0.3)\n",
    "\n",
    "print('k = {}, L = {}'.format(k, L))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "    Desc:\n",
      "        Construct Data Struture.\n",
      "\n",
      "    Args:\n",
      "        P: dataset\n",
      "        k: number of h\n",
      "        L: number of g\n",
      "        M: number of hash tables\n",
      "        C: max value, Cd = C * d\n",
      "        random_state: random seed\n",
      "\n",
      "    Returns:\n",
      "        M is None:\n",
      "            G\n",
      "            hash_tables\n",
      "        Else:\n",
      "            fp_rand: fingerprint\n",
      "            G\n",
      "            hash_tables\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "print(preprocessing.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 3.77 s, sys: 15.3 ms, total: 3.79 s\n",
      "Wall time: 3.8 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "G, hash_tables, fp_rand = preprocessing(P, k, L, C, M=M, random_state=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "args = dict()\n",
    "args['C'] = C\n",
    "args['G'] = G\n",
    "args['M'] = M\n",
    "args['fp_rand'] = fp_rand\n",
    "args['hash_tables'] = hash_tables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 5.55 s, sys: 0 ns, total: 5.55 s\n",
      "Wall time: 5.55 s\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(0.63, 0.03817072299025879, 30.04413604736328)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "metrics(P=P, args=args, query_func=query, \n",
    "        exact_nearest=data['nearest_neighbor'], test=test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 固定 k，调整 L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k = 100, L = 210\n"
     ]
    }
   ],
   "source": [
    "k, L = get_kL(P, p1, p2, 0.1)\n",
    "print('k = {}, L = {}'.format(k, L))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr_L = np.arange(50, 650, 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 4min 27s, sys: 164 ms, total: 4min 27s\n",
      "Wall time: 4min 28s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "arr_error = []\n",
    "arr_pr = []\n",
    "\n",
    "for L in arr_L:\n",
    "    G, hash_tables, fp_rand = preprocessing(P, k, L, C, M=M, random_state=1)\n",
    "\n",
    "    args = dict()\n",
    "    args['C'] = C\n",
    "    args['G'] = G\n",
    "    args['M'] = M\n",
    "    args['hash_tables'] = hash_tables\n",
    "    args['fp_rand'] = fp_rand\n",
    "\n",
    "    value_error, value_pr, value_memory = metrics(P=P, args=args, query_func=query, \n",
    "            exact_nearest=data['nearest_neighbor'], test=test)\n",
    "    \n",
    "    arr_error.append(value_error)\n",
    "    arr_pr.append(value_pr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(12, 5))\n",
    "plt.subplot(121)\n",
    "plt.plot(arr_L, arr_error, '>-', label='error')\n",
    "plt.title('Fixed B = 100, alpha = 2, epsilon = 1, k = 84')\n",
    "plt.xticks(arr_L)\n",
    "plt.xlabel('L')\n",
    "plt.ylabel('Quality')\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(122)\n",
    "plt.plot(arr_L, arr_pr, 'x-', label='pr of find nearest')\n",
    "plt.xticks(arr_L)\n",
    "plt.xlabel('L')\n",
    "plt.ylabel('Quality')\n",
    "plt.legend()\n",
    "plt.title('Fixed B = 100, alpha = 2, epsilon = 1, k = 84')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.6"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "283px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}