From 74779cd31914856e308c192b7bd835c430db0058 Mon Sep 17 00:00:00 2001
From: tornikeo <tornikeonoprishvili@gmail.com>
Date: Mon, 2 Dec 2024 11:34:56 +0100
Subject: [PATCH] Update BLINK benchmark

---
 notebooks/figures/make_figures.ipynb | 482 +++++++++++++++++++++++----
 1 file changed, 421 insertions(+), 61 deletions(-)

diff --git a/notebooks/figures/make_figures.ipynb b/notebooks/figures/make_figures.ipynb
index 4afbfc5..3372cfa 100644
--- a/notebooks/figures/make_figures.ipynb
+++ b/notebooks/figures/make_figures.ipynb
@@ -26,7 +26,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 36,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -92,7 +92,7 @@
     "    \"figure.titlesize\": \"medium\",\n",
     "}\n",
     "\n",
-    "plt.style.use(plotting_style)\n",
+    "# plt.style.use(plotting_style)\n",
     "assert cuda.is_available()"
    ]
   },
@@ -783,61 +783,173 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 44,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      " 15%|█▌        | 2/13 [00:03<00:19,  1.74s/it]/home/tornikeo/micromamba/envs/pb2/lib/python3.11/site-packages/blink/spectral_normalization.py:50: RuntimeWarning: divide by zero encountered in scalar divide\n",
+      "  0%|          | 0/8 [00:00<?, ?it/s]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "SET 1e-05 1e-05 99999.99999999999\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tornikeo/micromamba/envs/pb2/lib/python3.11/site-packages/blink/spectral_normalization.py:50: RuntimeWarning: divide by zero encountered in scalar divide\n",
       "  inorm = np.array([1.0/np.linalg.norm(mzi[1]**intensity_power) for mzi in mzis])\n",
-      " 23%|██▎       | 3/13 [00:05<00:19,  1.90s/it]/home/tornikeo/micromamba/envs/pb2/lib/python3.11/site-packages/blink/spectral_normalization.py:50: RuntimeWarning: divide by zero encountered in scalar divide\n",
+      " 12%|█▎        | 1/8 [00:08<00:56,  8.02s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "SET 3.727593720314938e-05 3.727593720314938e-05 26826.95795279727\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tornikeo/micromamba/envs/pb2/lib/python3.11/site-packages/blink/spectral_normalization.py:50: RuntimeWarning: divide by zero encountered in scalar divide\n",
       "  inorm = np.array([1.0/np.linalg.norm(mzi[1]**intensity_power) for mzi in mzis])\n",
-      " 31%|███       | 4/13 [00:09<00:24,  2.77s/it]/home/tornikeo/micromamba/envs/pb2/lib/python3.11/site-packages/blink/spectral_normalization.py:50: RuntimeWarning: divide by zero encountered in scalar divide\n",
+      " 25%|██▌       | 2/8 [00:13<00:40,  6.71s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "SET 0.00013894954943731373 0.00013894954943731373 7196.856730011522\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tornikeo/micromamba/envs/pb2/lib/python3.11/site-packages/blink/spectral_normalization.py:50: RuntimeWarning: divide by zero encountered in scalar divide\n",
       "  inorm = np.array([1.0/np.linalg.norm(mzi[1]**intensity_power) for mzi in mzis])\n",
-      " 38%|███▊      | 5/13 [00:12<00:21,  2.74s/it]/home/tornikeo/micromamba/envs/pb2/lib/python3.11/site-packages/blink/spectral_normalization.py:50: RuntimeWarning: divide by zero encountered in scalar divide\n",
+      " 38%|███▊      | 3/8 [00:19<00:30,  6.09s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "SET 0.0005179474679231213 0.0005179474679231213 1930.6977288832495\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tornikeo/micromamba/envs/pb2/lib/python3.11/site-packages/blink/spectral_normalization.py:50: RuntimeWarning: divide by zero encountered in scalar divide\n",
       "  inorm = np.array([1.0/np.linalg.norm(mzi[1]**intensity_power) for mzi in mzis])\n",
-      " 46%|████▌     | 6/13 [00:16<00:22,  3.24s/it]/home/tornikeo/micromamba/envs/pb2/lib/python3.11/site-packages/blink/spectral_normalization.py:50: RuntimeWarning: divide by zero encountered in scalar divide\n",
+      " 50%|█████     | 4/8 [00:23<00:21,  5.46s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "SET 0.0019306977288832496 0.001 1000.0\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tornikeo/micromamba/envs/pb2/lib/python3.11/site-packages/blink/spectral_normalization.py:50: RuntimeWarning: divide by zero encountered in scalar divide\n",
       "  inorm = np.array([1.0/np.linalg.norm(mzi[1]**intensity_power) for mzi in mzis])\n",
-      " 54%|█████▍    | 7/13 [00:30<00:40,  6.82s/it]/home/tornikeo/micromamba/envs/pb2/lib/python3.11/site-packages/blink/spectral_normalization.py:50: RuntimeWarning: divide by zero encountered in scalar divide\n",
+      " 62%|██████▎   | 5/8 [00:29<00:16,  5.57s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "SET 0.007196856730011514 0.001 1000.0\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tornikeo/micromamba/envs/pb2/lib/python3.11/site-packages/blink/spectral_normalization.py:50: RuntimeWarning: divide by zero encountered in scalar divide\n",
       "  inorm = np.array([1.0/np.linalg.norm(mzi[1]**intensity_power) for mzi in mzis])\n",
-      " 62%|██████▏   | 8/13 [00:37<00:33,  6.77s/it]/home/tornikeo/micromamba/envs/pb2/lib/python3.11/site-packages/blink/spectral_normalization.py:50: RuntimeWarning: divide by zero encountered in scalar divide\n",
+      " 75%|███████▌  | 6/8 [00:35<00:11,  5.87s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "SET 0.026826957952797246 0.001 1000.0\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tornikeo/micromamba/envs/pb2/lib/python3.11/site-packages/blink/spectral_normalization.py:50: RuntimeWarning: divide by zero encountered in scalar divide\n",
       "  inorm = np.array([1.0/np.linalg.norm(mzi[1]**intensity_power) for mzi in mzis])\n",
-      " 69%|██████▉   | 9/13 [00:54<00:40, 10.10s/it]/home/tornikeo/micromamba/envs/pb2/lib/python3.11/site-packages/blink/spectral_normalization.py:50: RuntimeWarning: divide by zero encountered in scalar divide\n",
+      " 88%|████████▊ | 7/8 [00:45<00:07,  7.20s/it]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "SET 0.1 0.001 1000.0\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/tornikeo/micromamba/envs/pb2/lib/python3.11/site-packages/blink/spectral_normalization.py:50: RuntimeWarning: divide by zero encountered in scalar divide\n",
       "  inorm = np.array([1.0/np.linalg.norm(mzi[1]**intensity_power) for mzi in mzis])\n",
-      "100%|██████████| 13/13 [01:12<00:00,  5.56s/it]\n"
+      "100%|██████████| 8/8 [01:13<00:00,  9.22s/it]\n"
      ]
     }
    ],
    "source": [
     "import blink\n",
+    "import torch\n",
     "from tqdm.cli import tqdm\n",
     "\n",
     "\n",
     "tolerances = np.logspace(\n",
-    "    np.log10(MIN_TOLERANCE),\n",
-    "    np.log10(MAX_TOLERANCE),\n",
+    "    start=-5,\n",
+    "    stop=-1,\n",
     "    endpoint=True,\n",
-    "    num=NUM_EVALS,\n",
-    ")[\n",
-    "    :-3\n",
-    "]  # We don't need tolerances of size 10^3\n",
+    "    num=8,\n",
+    ")\n",
     "\n",
     "np.random.seed(123)\n",
     "\n",
     "references = np.random.choice(\n",
     "    spectra,\n",
-    "    size=512,\n",
+    "    size=512 * 2,\n",
     "    replace=False,\n",
     ")\n",
     "\n",
     "queries = np.random.choice(\n",
     "    spectra,\n",
-    "    size=512,\n",
+    "    size=512 * 2,\n",
     "    replace=False,\n",
     ")\n",
     "batch_size = max(len(references), len(queries))\n",
+    "n_reps = 10  # Repeat each kernel 10 times and average to get better estimate of speed performance\n",
     "\n",
     "\n",
     "def measure_blink_vs_simms():\n",
@@ -846,12 +958,12 @@
     "        tolerance = float(tolerance)\n",
     "\n",
     "        ## MatchMS\n",
-    "        scores = get_correct_scores(\n",
-    "            references=references,\n",
-    "            queries=queries,\n",
-    "            similarity_class=CosineGreedy,\n",
-    "            tolerance=tolerance,\n",
-    "        )\n",
+    "        # scores = get_correct_scores(\n",
+    "        #     references=references,\n",
+    "        #     queries=queries,\n",
+    "        #     similarity_class=CosineGreedy,\n",
+    "        #     tolerance=tolerance,\n",
+    "        # )\n",
     "\n",
     "        ## SimMS\n",
     "        kernel = CudaCosineGreedy(\n",
@@ -860,26 +972,45 @@
     "        )\n",
     "        kernel.matrix(references[:4], queries[:4])\n",
     "        with Timer() as t_simms:\n",
-    "            scores_cu = kernel.matrix(references, queries)\n",
+    "            for _ in range(n_reps):\n",
+    "                scores_cu = kernel.matrix(references, queries)\n",
+    "\n",
+    "        scores = scores_cu  # TODO\n",
     "\n",
     "        acc = np.isclose(\n",
     "            scores[\"score\"].ravel(), scores_cu[\"score\"].ravel(), atol=0.001\n",
     "        ).mean()\n",
     "        data.append(\n",
-    "            dict(method=\"simms\", tolerance=tolerance, time=t_simms.duration, acc=acc)\n",
+    "            dict(\n",
+    "                method=\"simms\",\n",
+    "                tolerance=tolerance,\n",
+    "                time=t_simms.duration / n_reps,\n",
+    "                acc=acc,\n",
+    "                speed=float(\n",
+    "                    len(references) * len(queries) / (t_simms.duration / n_reps)\n",
+    "                ),\n",
+    "            )\n",
     "        )\n",
     "\n",
     "        ## BLINK\n",
+    "        torch.cuda.empty_cache()\n",
     "        queries_ = [e.peaks.to_numpy.T for e in queries]\n",
     "        references_ = [e.peaks.to_numpy.T for e in references]\n",
     "        query_precursor_mz_ = [e.get(\"precursor_mz\") for e in queries]\n",
     "        reference_precursor_mz_ = [e.get(\"precursor_mz\") for e in references]\n",
-    "\n",
-    "        for blink_bin_width in [0.00001, 0.0001, 0.001]:\n",
-    "            # On the one hand, BLINK can only work with tolerances in range (bin_width, bin_width * 1000)\n",
-    "            # On the other, BLINK memory requirements for discretization grow as 1/bin_width.\n",
-    "            # This requires us to use different bin widths for different tolerances and take all configurations into account\n",
-    "            if tolerance >= blink_bin_width and tolerance < blink_bin_width * 1000:\n",
+    "        # blink_bin_width = 0.00001\n",
+    "        # blink_bin_width = tolerance / 5\n",
+    "        blink_bin_width = min(\n",
+    "            tolerance, 0.001\n",
+    "        )  # with lower tolerance, it is necessary to use bin width <= tolerance\n",
+    "        # for blink_bin_width in [0.00001, 0.0001, 0.001]:\n",
+    "        # On the one hand, BLINK can only work with tolerances in range (bin_width, bin_width * 1000)\n",
+    "        # On the other, BLINK memory requirements for discretization grow as 1/bin_width.\n",
+    "        # This requires us to use different bin widths for different tolerances and take all configurations into account\n",
+    "        # if tolerance >= blink_bin_width and tolerance <= blink_bin_width * 256:\n",
+    "        print(\"SET\", tolerance, blink_bin_width, 1 / blink_bin_width)\n",
+    "        with Timer() as t_blink:\n",
+    "            for _ in range(n_reps):\n",
     "                blink_discretized_spectra = blink.discretize_spectra(\n",
     "                    references_,\n",
     "                    queries_,\n",
@@ -889,24 +1020,26 @@
     "                    bin_width=blink_bin_width,\n",
     "                    tolerance=tolerance,\n",
     "                )\n",
-    "                with Timer() as t_blink:\n",
-    "                    blink_results = blink.score_sparse_spectra(\n",
-    "                        blink_discretized_spectra, gpu=True\n",
-    "                    )\n",
-    "                acc = np.isclose(\n",
-    "                    scores[\"score\"].ravel(),\n",
-    "                    blink_results[\"mzi\"].todense().ravel(),\n",
-    "                    atol=0.001,\n",
-    "                ).mean()\n",
-    "                data.append(\n",
-    "                    dict(\n",
-    "                        method=\"blink\",\n",
-    "                        tolerance=tolerance,\n",
-    "                        blink_bin_width=blink_bin_width,\n",
-    "                        time=t_blink.duration,\n",
-    "                        acc=acc,\n",
-    "                    )\n",
+    "                blink_results = blink.score_sparse_spectra(\n",
+    "                    blink_discretized_spectra, gpu=True\n",
     "                )\n",
+    "        acc = np.isclose(\n",
+    "            scores[\"score\"].ravel(),\n",
+    "            blink_results[\"mzi\"].todense().ravel(),\n",
+    "            atol=0.001,\n",
+    "        ).mean()\n",
+    "        data.append(\n",
+    "            dict(\n",
+    "                method=\"blink\",\n",
+    "                tolerance=tolerance,\n",
+    "                blink_bin_width=blink_bin_width,\n",
+    "                time=t_blink.duration / n_reps,\n",
+    "                speed=float(\n",
+    "                    len(references) * len(queries) / (t_blink.duration / n_reps)\n",
+    "                ),\n",
+    "                acc=acc,\n",
+    "            )\n",
+    "        )\n",
     "    data = pd.DataFrame(data)\n",
     "    return data\n",
     "\n",
@@ -925,12 +1058,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 55,
+   "execution_count": 68,
    "metadata": {},
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_35409/3628115559.py:12: UserWarning: Ignoring `palette` because no `hue` variable has been assigned.\n",
+      "  sns.lineplot(\n",
+      "/tmp/ipykernel_35409/3628115559.py:46: UserWarning: Ignoring `palette` because no `hue` variable has been assigned.\n",
+      "  sns.lineplot(\n"
+     ]
+    },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1100x300 with 2 Axes>"
       ]
@@ -945,18 +1088,20 @@
     "    figsize=(11, 3),\n",
     "    # sharex=True,\n",
     ")\n",
+    "\n",
     "prop_cycle = plt.rcParams[\"axes.prop_cycle\"]\n",
     "colors = list(prop_cycle.by_key()[\"color\"])\n",
-    "perf_df[\"Bin Width\"] = \"BLINK \" + perf_df.blink_bin_width.astype(str)\n",
+    "# perf_df[\"Bin Width\"] = \"BLINK \" + perf_df.blink_bin_width.astype(str)\n",
     "gp = perf_df.groupby(\"method\")\n",
     "plt.sca(axs[\"a\"])\n",
     "sns.lineplot(\n",
     "    gp.get_group(\"blink\"),\n",
     "    x=\"tolerance\",\n",
     "    y=\"acc\",\n",
-    "    hue=\"Bin Width\",\n",
+    "    # hue=\"Bin Width\",\n",
     "    palette=\"dark:r_r\",\n",
     "    marker=\"o\",\n",
+    "    label=\"BLINK\",\n",
     ")\n",
     "plt.legend()\n",
     "sns.lineplot(\n",
@@ -972,12 +1117,13 @@
     "plt.ylim([0.8999, None])\n",
     "plt.ylabel(\"Accuracy\")\n",
     "plt.xlabel(\"Tolerance\")\n",
+    "plt.grid(True, \"major\")\n",
     "\n",
     "plt.sca(axs[\"b\"])\n",
     "sns.lineplot(\n",
     "    gp.get_group(\"simms\"),\n",
     "    x=\"tolerance\",\n",
-    "    y=\"time\",\n",
+    "    y=\"speed\",\n",
     "    color=colors[2],\n",
     "    marker=\"o\",\n",
     "    label=\"SimMS\",\n",
@@ -985,21 +1131,235 @@
     "sns.lineplot(\n",
     "    gp.get_group(\"blink\"),\n",
     "    x=\"tolerance\",\n",
-    "    y=\"time\",\n",
-    "    hue=\"Bin Width\",\n",
+    "    y=\"speed\",\n",
+    "    # hue=\"Bin Width\",\n",
     "    palette=\"dark:r_r\",\n",
     "    marker=\"o\",\n",
+    "    label=\"BLINK\",\n",
     ")\n",
-    "plt.legend([])\n",
+    "# plt.legend([])\n",
     "plt.title(\"B\", fontweight=\"bold\")\n",
     "plt.xscale(\"log\")\n",
-    "plt.yscale(\"log\")\n",
+    "# plt.yscale(\"log\")\n",
     "plt.xlabel(\"Tolerance\")\n",
-    "plt.ylabel(\"Wall Time (s)\")\n",
+    "plt.ylabel(\"Speed\")\n",
+    "plt.grid(True, \"major\")\n",
     "\n",
     "plt.savefig(\"vs_blink.png\", bbox_inches=\"tight\", dpi=200)"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 70,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>method</th>\n",
+       "      <th>tolerance</th>\n",
+       "      <th>time</th>\n",
+       "      <th>acc</th>\n",
+       "      <th>speed</th>\n",
+       "      <th>blink_bin_width</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>simms</td>\n",
+       "      <td>0.000010</td>\n",
+       "      <td>0.177503</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>5.907363e+06</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>blink</td>\n",
+       "      <td>0.000010</td>\n",
+       "      <td>0.459600</td>\n",
+       "      <td>0.998867</td>\n",
+       "      <td>2.281496e+06</td>\n",
+       "      <td>0.000010</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>simms</td>\n",
+       "      <td>0.000037</td>\n",
+       "      <td>0.207746</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>5.047400e+06</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>blink</td>\n",
+       "      <td>0.000037</td>\n",
+       "      <td>0.199679</td>\n",
+       "      <td>0.996355</td>\n",
+       "      <td>5.251303e+06</td>\n",
+       "      <td>0.000037</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>simms</td>\n",
+       "      <td>0.000139</td>\n",
+       "      <td>0.214266</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>4.893795e+06</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>blink</td>\n",
+       "      <td>0.000139</td>\n",
+       "      <td>0.123235</td>\n",
+       "      <td>0.989000</td>\n",
+       "      <td>8.508767e+06</td>\n",
+       "      <td>0.000139</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>simms</td>\n",
+       "      <td>0.000518</td>\n",
+       "      <td>0.215997</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>4.854578e+06</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>blink</td>\n",
+       "      <td>0.000518</td>\n",
+       "      <td>0.086598</td>\n",
+       "      <td>0.977319</td>\n",
+       "      <td>1.210859e+07</td>\n",
+       "      <td>0.000518</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>simms</td>\n",
+       "      <td>0.001931</td>\n",
+       "      <td>0.255105</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>4.110371e+06</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>blink</td>\n",
+       "      <td>0.001931</td>\n",
+       "      <td>0.135083</td>\n",
+       "      <td>0.970738</td>\n",
+       "      <td>7.762450e+06</td>\n",
+       "      <td>0.001000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>simms</td>\n",
+       "      <td>0.007197</td>\n",
+       "      <td>0.268993</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>3.898158e+06</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>blink</td>\n",
+       "      <td>0.007197</td>\n",
+       "      <td>0.172732</td>\n",
+       "      <td>0.990274</td>\n",
+       "      <td>6.070548e+06</td>\n",
+       "      <td>0.001000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>12</th>\n",
+       "      <td>simms</td>\n",
+       "      <td>0.026827</td>\n",
+       "      <td>0.348851</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>3.005801e+06</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>13</th>\n",
+       "      <td>blink</td>\n",
+       "      <td>0.026827</td>\n",
+       "      <td>0.474729</td>\n",
+       "      <td>0.965332</td>\n",
+       "      <td>2.208790e+06</td>\n",
+       "      <td>0.001000</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>14</th>\n",
+       "      <td>simms</td>\n",
+       "      <td>0.100000</td>\n",
+       "      <td>0.588925</td>\n",
+       "      <td>1.000000</td>\n",
+       "      <td>1.780490e+06</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>15</th>\n",
+       "      <td>blink</td>\n",
+       "      <td>0.100000</td>\n",
+       "      <td>2.017830</td>\n",
+       "      <td>0.898851</td>\n",
+       "      <td>5.196553e+05</td>\n",
+       "      <td>0.001000</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   method  tolerance      time       acc         speed  blink_bin_width\n",
+       "0   simms   0.000010  0.177503  1.000000  5.907363e+06              NaN\n",
+       "1   blink   0.000010  0.459600  0.998867  2.281496e+06         0.000010\n",
+       "2   simms   0.000037  0.207746  1.000000  5.047400e+06              NaN\n",
+       "3   blink   0.000037  0.199679  0.996355  5.251303e+06         0.000037\n",
+       "4   simms   0.000139  0.214266  1.000000  4.893795e+06              NaN\n",
+       "5   blink   0.000139  0.123235  0.989000  8.508767e+06         0.000139\n",
+       "6   simms   0.000518  0.215997  1.000000  4.854578e+06              NaN\n",
+       "7   blink   0.000518  0.086598  0.977319  1.210859e+07         0.000518\n",
+       "8   simms   0.001931  0.255105  1.000000  4.110371e+06              NaN\n",
+       "9   blink   0.001931  0.135083  0.970738  7.762450e+06         0.001000\n",
+       "10  simms   0.007197  0.268993  1.000000  3.898158e+06              NaN\n",
+       "11  blink   0.007197  0.172732  0.990274  6.070548e+06         0.001000\n",
+       "12  simms   0.026827  0.348851  1.000000  3.005801e+06              NaN\n",
+       "13  blink   0.026827  0.474729  0.965332  2.208790e+06         0.001000\n",
+       "14  simms   0.100000  0.588925  1.000000  1.780490e+06              NaN\n",
+       "15  blink   0.100000  2.017830  0.898851  5.196553e+05         0.001000"
+      ]
+     },
+     "execution_count": 70,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "perf_df"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 6,