exact-cp-optimization.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "opening-power",
   "metadata": {},
   "source": [
    "# Exact Optimization of Conformal Predictors via Incremental and Decremental Learning\n",
    "\n",
    "This notebook documents (and allows to replicate) our experiments.\n",
    "We define each nonconformity measure and its optimized version (whose name is denoted by `_fast`).\n",
    "We then evaluate each of them for CP, and then compare the optimized ones with ICP."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fixed-webmaster",
   "metadata": {},
   "source": [
    "# Imports and multiprocessing settings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "hindu-retention",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-07T11:49:58.299916Z",
     "start_time": "2021-06-07T11:49:58.295399Z"
    },
    "code_folding": [
     4
    ]
   },
   "outputs": [],
   "source": [
    "# Disable multithreading in numpy for fair measurements.\n",
    "# Needs to be run before importing numpy.\n",
    "import os\n",
    "import ctypes\n",
    "def disable_np_multithreading():\n",
    "    \"\"\"A multithreading-disabling routine for numpy, taken\n",
    "    from https://github.com/numpy/numpy/issues/11826.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        import mkl\n",
    "        mkl.set_num_threads(1)\n",
    "        return 0\n",
    "    except:\n",
    "        pass \n",
    "    \n",
    "    for name in [ \"libmkl_rt.so\", \"libmkl_rt.dylib\", \"mkl_Rt.dll\"]: \n",
    "        try: \n",
    "            mkl_rt = ctypes.CDLL(name)\n",
    "            mkl_rt.mkl_set_num_threads(ctypes.byref(ctypes.c_int(1)))\n",
    "            return 0 \n",
    "        except:\n",
    "            pass   \n",
    "\n",
    "    os.environ[\"OMP_NUM_THREADS\"] = \"1\"\n",
    "    os.environ[\"OPENBLAS_NUM_THREADS\"] = \"1\" \n",
    "    os.environ[\"MKL_NUM_THREADS\"] = \"1\"\n",
    "    os.environ[\"VECLIB_MAXIMUM_THREADS\"] = \"1\"\n",
    "    os.environ[\"NUMEXPR_NUM_THREADS\"] = \"1\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ahead-transparency",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-07T11:49:59.518426Z",
     "start_time": "2021-06-07T11:49:58.481506Z"
    }
   },
   "outputs": [],
   "source": [
    "disable_np_multithreading()\n",
    "\n",
    "import os\n",
    "import json\n",
    "import time\n",
    "import copy\n",
    "import bisect\n",
    "import scipy\n",
    "import doctest\n",
    "import unittest\n",
    "import functools\n",
    "import matplotlib\n",
    "import collections\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import multiprocessing\n",
    "from numpy.linalg import inv\n",
    "from itertools import product\n",
    "import matplotlib.pylab as plt\n",
    "from sklearn.datasets import *\n",
    "from interval import Interval as interval\n",
    "from interval import Inf as inf\n",
    "import matplotlib.ticker as ticker\n",
    "from sklearn.utils import resample\n",
    "from collections import defaultdict\n",
    "from IPython.display import display\n",
    "from parameterized import parameterized\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "from sklearn.datasets import make_classification\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics.pairwise import euclidean_distances, rbf_kernel\n",
    "\n",
    "from eli import Eli"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "supreme-tucson",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-07T11:51:34.284893Z",
     "start_time": "2021-06-07T11:51:34.276695Z"
    },
    "tags": [
     "plots"
    ]
   },
   "outputs": [],
   "source": [
    "# Plots settings\n",
    "DPI = 300\n",
    "plt.rc('xtick', labelsize='small')\n",
    "plt.rc('ytick', labelsize='small')\n",
    "plt.style.use(['seaborn-white', 'seaborn-talk'])\n",
    "matplotlib.rcParams['text.usetex'] = True #Let TeX do the typsetting\n",
    "matplotlib.rcParams['text.latex.preamble'] = [r'\\usepackage{sansmath}', r'\\sansmath'] #Force sans-serif math mode (for axes labels)\n",
    "matplotlib.rcParams['font.family'] = 'sans-serif' # ... for regular text\n",
    "matplotlib.rcParams['font.sans-serif'] = 'Helvetica, Avant Garde, Computer Modern Sans serif' # Choose a nice font here\n",
    "\n",
    "\n",
    "COLORS = ['#000000', '#174905', '#28836d', '#829bc5', '#d5c4dd']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "separate-humanitarian",
   "metadata": {},
   "source": [
    "# Definitions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "confidential-husband",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-07T11:40:43.090225Z",
     "start_time": "2021-06-07T11:40:43.084918Z"
    }
   },
   "outputs": [],
   "source": [
    "def dist(a, b):\n",
    "    return euclidean_distances([a], [b])[0][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "limited-tradition",
   "metadata": {},
   "source": [
    "## Nonconformity measures\n",
    "\n",
    "A nonconformity measure (ncm)\n",
    "$A((x, y); \\{(x_1, y_1), ..., (x_{n}, y_{n})\\}) \\mapsto \\mathcal{R}$\n",
    "scores the conformity of an example $(x, y)$ with respect to a set\n",
    "of training examples $\\{(x_1, y_1), ..., (x_{n}, y_{n})\\}$.\n",
    "The larger its value is, the less conforming (~similar) the example\n",
    "is to the training ones.\n",
    "\n",
    "In this notebook, ncms should implement 2 methods:\n",
    "- `train_ncm(X, Y)`\n",
    "- `compute_scores(x, y, only_score_x)`\n",
    "\n",
    "For simplicity, we define a common interface, `NCM`, which new\n",
    "ncms can inherit from.\n",
    "\n",
    "Simple (unoptimized) ncms can simply implement the method\n",
    "`train_ncm(x, y, X, Y)`, and the remaining methods\n",
    "(`train()` and `compute_scores()`) will be implemented automatically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "persistent-sunday",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-03T16:40:05.317143Z",
     "start_time": "2021-06-03T16:40:05.309941Z"
    },
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "# Define an interface for nonconformity measures\n",
    "class NCM:\n",
    "    \"\"\"A template for all nonconformity scorers.\n",
    "    \"\"\"\n",
    "    def train(self, X, Y, inductive=False):\n",
    "        \"\"\"By default, this simply stores the training\n",
    "        data as an element of the NCM object.\n",
    "        \"\"\"\n",
    "        self.inductive = inductive\n",
    "        if inductive:\n",
    "            self.ncm = self.train_ncm(X, Y)\n",
    "        else:\n",
    "            self.X = np.array(X)\n",
    "            self.Y = np.array(Y)\n",
    "\n",
    "    def train_ncm(self, X, Y):\n",
    "        \"\"\"Should return the nonconformity scorer for\n",
    "        the training data (X, Y), which is a function\n",
    "        (x, y) -> score.\n",
    "        \"\"\"\n",
    "        def example_scorer(x, y):\n",
    "            raise NotImplemented\n",
    "        \n",
    "        return example_scorer\n",
    "\n",
    "    def compute_scores(self, x, y, only_score_x=False):\n",
    "        \"\"\"Returns a tuple:\n",
    "            (score_xy, scores)\n",
    "        where score_xy is the score for (x, y) and\n",
    "        scores are the nonconformity scores for the\n",
    "        training examples.\n",
    "        \n",
    "        If `only_score_x = True`, this method returns\n",
    "        only the prediction for (x, y), `score_xy`.\n",
    "        \"\"\"\n",
    "        if self.inductive:\n",
    "            ncm = self.ncm\n",
    "        else:\n",
    "            ncm = self.train_ncm(self.X, self.Y)\n",
    "        \n",
    "        score_x = ncm(x, y)\n",
    "        \n",
    "        if only_score_x:\n",
    "            return score_x\n",
    "        \n",
    "        scores = []\n",
    "        \n",
    "        for i in range(len(self.X)):\n",
    "            # Score the i-th example, removing it from the\n",
    "            # training data and appending (x, y) instead\n",
    "            idx = np.array(list(range(len(self.X))))\n",
    "            if self.inductive:\n",
    "                ncm = self.ncm\n",
    "            else:\n",
    "                ncm = self.train_ncm(np.row_stack((self.X[idx!=i,:], x)),\n",
    "                                     np.append(self.Y[idx!=i], y))\n",
    "            scores.append(ncm(self.X[i,:], self.Y[i]))\n",
    "            \n",
    "        return score_x, np.array(scores)\n",
    "\n",
    "    def name(self):\n",
    "        return self.__class__.__name__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "developed-medicare",
   "metadata": {},
   "source": [
    "### Simplified k-NN nonconformity measure\n",
    "\n",
    "Particularly useful for anomaly detection contexts (where there is\n",
    "just one label in training).\n",
    "\n",
    "\n",
    "Fix a distance $d$. Let $\\delta^j(x, X)$ be the $j$-th smallest\n",
    "distance of $x$ from the elements of the set $X$.\n",
    "\n",
    "$$A((x, y); \\{(x_1, y_1), ..., (x_{n}, y_{n})\\}) =\n",
    "    \\sum_{j=1}^k \\delta^j(x, \\{x_i \\mid i=1...n, y_i=y\\})$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "concerned-bangkok",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-03T16:40:06.638372Z",
     "start_time": "2021-06-03T16:40:06.635096Z"
    }
   },
   "outputs": [],
   "source": [
    "def best_k(a, k):\n",
    "    if len(a) <= k:\n",
    "        return a\n",
    "\n",
    "    return a[np.argpartition(a, k)[:k]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "stuffed-falls",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-03T16:40:07.672066Z",
     "start_time": "2021-06-03T16:40:07.666011Z"
    }
   },
   "outputs": [],
   "source": [
    "class SimplifiedKNN(NCM):\n",
    "    def __init__(self, k=15):\n",
    "        self.k = k\n",
    "\n",
    "    def train_ncm(self, X, Y):\n",
    "        X = np.array(X)\n",
    "        Y = np.array(Y)\n",
    "        \n",
    "        def scorer(x, y):\n",
    "            dist = euclidean_distances([x], X[Y==y,:]).flatten()\n",
    "            kdist = best_k(dist, self.k)\n",
    "        \n",
    "            return sum(kdist)\n",
    "        \n",
    "        return scorer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "opened-credits",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-03T16:40:08.444110Z",
     "start_time": "2021-06-03T16:40:08.426547Z"
    }
   },
   "outputs": [],
   "source": [
    "class SimplifiedKNN_fast(NCM):\n",
    "    def __init__(self, k=15):\n",
    "        self.k = k\n",
    "    \n",
    "    def train(self, X, Y):\n",
    "        self.distances = {}\n",
    "        self.temporary_scores = {}\n",
    "        for y in set(Y):\n",
    "            Xy = X[Y==y,:]\n",
    "            if not len(Xy):\n",
    "                raise Exception(\"[!] label `{}` not in training data\".format(y))\n",
    "            dist = euclidean_distances(Xy)\n",
    "            # Only keep best k, excluding self (first column, because\n",
    "            # distance will be 0).\n",
    "            dist.sort(axis=1)\n",
    "            dist = dist[:, 1:self.k+1]\n",
    "            # Store.\n",
    "            # NOTE: as a matter of fact, we could just keep 1 distance!\n",
    "            self.distances[y] = dist\n",
    "            self.temporary_scores[y] = np.sum(dist, axis=1)\n",
    "\n",
    "        self.X = X\n",
    "        self.Y = Y\n",
    "    \n",
    "    def compute_scores(self, x, y, only_score_x=False):\n",
    "        if not self.distances:\n",
    "            raise Exception(\"need to train the nonconformity measure first\")\n",
    "        \n",
    "        # Score the new example first.\n",
    "        distances_x = euclidean_distances([x], self.X[self.Y==y,:]).flatten()\n",
    "        score_x = sum(best_k(distances_x, self.k))\n",
    "        \n",
    "        if only_score_x:\n",
    "            return score_x\n",
    "\n",
    "        # Compute the remaining scores.\n",
    "        scores = []\n",
    "        \n",
    "        for yi in self.temporary_scores:\n",
    "            if yi != y:\n",
    "                # Scores not affected by (x, y).\n",
    "                scores += list(self.temporary_scores[yi])\n",
    "            else:\n",
    "                #assert len(distances_x) == len(self.distances[yi])\n",
    "                for dist_x, kdist, tmp_score in zip(distances_x,\n",
    "                                                    self.distances[yi],\n",
    "                                                    self.temporary_scores[yi]):\n",
    "                    # If the distance to x is among the k best, add it to the\n",
    "                    # score and remove the larger one.\n",
    "                    if kdist[-1] > dist_x:\n",
    "                        score = tmp_score - kdist[-1] + dist_x\n",
    "                    else:\n",
    "                        score = tmp_score\n",
    "                    scores.append(score)\n",
    "        \n",
    "        return score_x, np.array(scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "binding-inflation",
   "metadata": {},
   "source": [
    "### k-NN nonconformity measure\n",
    "\n",
    "Fix a distance $d$. Let $\\delta^j(x, X)$ be the $j$-th smallest\n",
    "distance of $x$ from the elements of the set $X$.\n",
    "\n",
    "$$A((x, y); \\{(x_1, y_1), ..., (x_{n}, y_{n})\\}) =\n",
    "    \\frac{\\sum_{j=1}^k \\delta^j(x, \\{x_i \\mid i=1...n, y_i=y\\})}\n",
    "         {\\sum_{j=1}^k \\delta^j(x, \\{x_i \\mid i=1...n, y_i\\neq y\\})}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "cross-healthcare",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-05-23T16:52:43.755241Z",
     "start_time": "2021-05-23T16:52:43.751352Z"
    }
   },
   "outputs": [],
   "source": [
    "class KNN(NCM):\n",
    "    def __init__(self, k=15):\n",
    "        self.k = k\n",
    "\n",
    "    def train_ncm(self, X, Y):\n",
    "        X = np.array(X)\n",
    "        Y = np.array(Y)\n",
    "        \n",
    "        def scorer(x, y):\n",
    "            dist = euclidean_distances([x], X).flatten()\n",
    "        \n",
    "            # k best for y and for not y\n",
    "            kdist_y = best_k(dist[Y==y], self.k)\n",
    "            kdist_not_y = best_k(dist[Y!=y], self.k)\n",
    "\n",
    "            return sum(kdist_y) / max(sum(kdist_not_y), 0.1)\n",
    "        \n",
    "        return scorer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "nutritional-cancer",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-05-23T16:52:44.179237Z",
     "start_time": "2021-05-23T16:52:44.171866Z"
    }
   },
   "outputs": [],
   "source": [
    "class KNN_fast(NCM):\n",
    "    def __init__(self, k=15):\n",
    "        self.k = k\n",
    "    \n",
    "    def train(self, X, Y):\n",
    "        # k best distances from y and from not y for each training point.\n",
    "        self.distances_y = []\n",
    "        self.distances_not_y = []\n",
    "        self.temporary_scores = []\n",
    "\n",
    "        for x, y, all_dist in zip(X, Y, euclidean_distances(X)):\n",
    "            # Keep smallest k distances (excluding \"self\").\n",
    "            kdist_y = sorted(all_dist[Y==y])[1:self.k+1]\n",
    "            kdist_not_y = sorted(all_dist[Y!=y])[:self.k]\n",
    "            score = sum(kdist_y) / sum(kdist_not_y)\n",
    "            \n",
    "            self.distances_y.append(kdist_y)\n",
    "            self.distances_not_y.append(kdist_not_y)\n",
    "            self.temporary_scores.append(score)\n",
    "\n",
    "        self.X = X\n",
    "        self.Y = Y\n",
    "    \n",
    "    def compute_scores(self, x, y, only_score_x=False):\n",
    "        # Score the new example first.\n",
    "        distances_x = euclidean_distances([x], self.X).flatten()\n",
    "        \n",
    "        # Best k for y and not y.\n",
    "        kdist_y = best_k(distances_x[self.Y==y], self.k)\n",
    "        kdist_not_y = best_k(distances_x[self.Y!=y], self.k)\n",
    "        \n",
    "        score_x = sum(kdist_y) / max(sum(kdist_not_y), 0.1) \n",
    "        \n",
    "        if only_score_x:\n",
    "            return score_x\n",
    "\n",
    "        # Compute the remaining scores.\n",
    "        scores = []\n",
    "        \n",
    "        for dist_x, kdist_y, kdist_not_y, score, yi in zip(distances_x,\n",
    "                                                           self.distances_y,\n",
    "                                                           self.distances_not_y,\n",
    "                                                           self.temporary_scores,\n",
    "                                                           self.Y):\n",
    "            if yi == y:\n",
    "                # dist_x affects the score's nominator if its label\n",
    "                # is yi, the denominator otherwise.\n",
    "                if len(kdist_y) < self.k or kdist_y[-1] > dist_x:\n",
    "                    # Remove effect of dist_y[-1] and use new distance.\n",
    "                    # NOTE: write \"kdist_y[:self.k-1]\" and not \"kdist_y[:-1]\"\n",
    "                    # or the code will have issues when dealing with small\n",
    "                    # training sets (and train objects don't have k neighbors).\n",
    "                    score = (score / sum(kdist_y)) * (sum(kdist_y[:self.k-1]) + dist_x)\n",
    "            else:\n",
    "                if len(kdist_not_y) < self.k or kdist_not_y[-1] > dist_x:\n",
    "                    score = (score * sum(kdist_not_y)) / (sum(kdist_not_y[:self.k-1]) + dist_x)\n",
    "            \n",
    "            scores.append(score)\n",
    "    \n",
    "        return score_x, np.array(scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "marked-hybrid",
   "metadata": {},
   "source": [
    "### 1-NN nonconformity measure\n",
    "\n",
    "For some distance $d$:\n",
    "\n",
    "$$A((x, y); \\{(x_1, y_1), ..., (x_{n}, y_{n})\\}) =\n",
    "    \\frac{min_{i=1, ..., n: y_i=y} d(x, x_i)}\n",
    "         {min_{i=1, ..., n: y_i\\neq y} d(x, x_i)}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "meaning-seminar",
   "metadata": {},
   "source": [
    "**Note**\n",
    "\n",
    "We instantiate the NN nonconformity measure, and conduct experiments with it.\n",
    "However, since its results are almost identical to those of k-NN (and its\n",
    "asymptotic complexity is the same), we did not include them in the paper."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "concerned-above",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-05-23T16:52:45.671570Z",
     "start_time": "2021-05-23T16:52:45.667116Z"
    }
   },
   "outputs": [],
   "source": [
    "class NN(KNN):\n",
    "    def __init__(self):\n",
    "        super().__init__(k=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "collected-spencer",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-05-23T16:52:46.272614Z",
     "start_time": "2021-05-23T16:52:46.269483Z"
    },
    "code_folding": [
     1
    ]
   },
   "outputs": [],
   "source": [
    "class NN_fast(KNN_fast):\n",
    "    def __init__(self):\n",
    "        super().__init__(k=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "scenic-church",
   "metadata": {},
   "source": [
    "### KDE\n",
    "\n",
    "$$A((x, y); \\{(x_1, y_1), ..., (x_{n}, y_{n})\\}) =\n",
    "  - \\left(\\frac{1}{n_yh^d} \\sum_{x_i: y_i = y} K \\left(\\frac{x - x_i}{h}\\right)\\right)$$\n",
    "\n",
    "where $n_y = |\\{ i=1, ..., n : y_i = y \\}|$, $K$ is a kernel, $h$ is the bandwidth.\n",
    "\n",
    "We use minus the log-likelihood of the respective scores, for numerical stability of CP."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "statutory-watson",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-05-23T16:52:47.415308Z",
     "start_time": "2021-05-23T16:52:47.310976Z"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.neighbors import KernelDensity\n",
    "\n",
    "class KDE(NCM):\n",
    "    def __init__(self, h=1.):\n",
    "        self.h = h\n",
    "\n",
    "    def train_ncm(self, X, Y):\n",
    "        X = np.array(X)\n",
    "        Y = np.array(Y)\n",
    "        kde = KernelDensity(bandwidth=self.h)\n",
    "        \n",
    "        def scorer(x, y):\n",
    "            kde.fit(X[Y==y,:])\n",
    "\n",
    "            # Uncomment for likelihood. We use -loglikelihood by default.\n",
    "            #return -np.exp(kde.score([x]))\n",
    "            return -kde.score([x])\n",
    "        \n",
    "        return scorer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "fundamental-investing",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-05-23T16:52:47.979802Z",
     "start_time": "2021-05-23T16:52:47.968408Z"
    }
   },
   "outputs": [],
   "source": [
    "class KDE_fast(NCM):\n",
    "    def __init__(self, h=1.):\n",
    "        self.h = h\n",
    "    \n",
    "    def train(self, X, Y):\n",
    "        scores = {}\n",
    "        mult_factor = {}\n",
    "\n",
    "        for y in set(Y):\n",
    "            Xy = X[Y==y, :]\n",
    "            ny, d = Xy.shape\n",
    "            dist_squared = euclidean_distances(Xy, squared=True)\n",
    "            K = np.exp(-.5*dist_squared)\n",
    "            # Remove contribution of distance to self.\n",
    "            K -= np.eye(ny)\n",
    "            # Precompute temporary scores and multiplicative factors.\n",
    "            scores[y] = np.sum(K, axis=0)\n",
    "            \n",
    "            mult_factor[y] = -(2*np.pi)**(-.5*d)/((ny-1)*self.h**d)\n",
    "        \n",
    "        self.X = X\n",
    "        self.Y = Y\n",
    "        self.temporary_scores = scores\n",
    "        self.mult_factor = mult_factor\n",
    "        \n",
    "    def compute_scores(self, x, y, only_score_x=False):\n",
    "        # Preprocess kernel and compute score for (x, y).\n",
    "        Xy = self.X[self.Y==y,:]\n",
    "        dist_squared_y = euclidean_distances([x],\n",
    "                                             Xy,\n",
    "                                             squared=True).flatten()\n",
    "        K = np.exp(-.5*dist_squared_y)\n",
    "        \n",
    "        # Update multiplicative factor.\n",
    "        ny, d = Xy.shape\n",
    "        mult_factor_y = self.mult_factor[y] * ((ny-1)*self.h**d)/(ny*self.h**d)\n",
    "        \n",
    "        # Compute the score for x.\n",
    "        score_x = sum(K)*mult_factor_y\n",
    "        \n",
    "        if only_score_x:\n",
    "            return score_x\n",
    "\n",
    "        scores = []\n",
    "        for yi, scores_yi in self.temporary_scores.items():\n",
    "            if yi == y:\n",
    "                # Update scores with example (x, y).\n",
    "                scores_yi = scores_yi + K\n",
    "                mult_factor = mult_factor_y\n",
    "            else:\n",
    "                mult_factor = self.mult_factor[yi]\n",
    "\n",
    "            scores += list(scores_yi*mult_factor)\n",
    "        \n",
    "        # NOTE: can be further sped up by keeping track of the log-likelihood\n",
    "        # instead of normal likelihood.\n",
    "        return -np.log(-score_x), -np.log(-np.array(scores))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "veterinary-cathedral",
   "metadata": {},
   "source": [
    "The `KDE_fast` alternative defined below (`KDE_fast_mpmath`) uses arbitrary precision math (via the `mpmath` module) to get exact solutions. This is used for cases where the inter-distances (see `dist_squared` in the code) take large values. It is slower than `KDE_fast`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "adjacent-customs",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-05-23T16:52:50.023799Z",
     "start_time": "2021-05-23T16:52:49.959616Z"
    },
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "import mpmath\n",
    "\n",
    "k = lambda x: mpmath.exp(-.5*x)\n",
    "kernel = np.vectorize(k)\n",
    "\n",
    "class KDE_fast_mpmath(NCM):\n",
    "    def __init__(self, h=1.):\n",
    "        self.h = h\n",
    "\n",
    "    def train(self, X, Y):\n",
    "        scores = {}\n",
    "        mult_factor = {}\n",
    "\n",
    "        for y in set(Y):\n",
    "            Xy = X[Y==y, :]\n",
    "            ny, d = Xy.shape\n",
    "            # Not accounting for bandwidth here.\n",
    "            dist_squared = euclidean_distances(Xy, squared=True)\n",
    "            # Arbitrary precision. TODO: can be improved.\n",
    "            K = kernel(dist_squared)\n",
    "            # This would be better (computation-wise) but it's\n",
    "            # unstable if dist_squared has large values:\n",
    "            #K = np.exp(-.5*dist_squared)\n",
    "            # Remove contribution of distance to self.\n",
    "            K -= np.eye(ny)\n",
    "            # Precompute temporary scores and multiplicative factors.\n",
    "            scores[y] = np.sum(K, axis=0)\n",
    "            mult_factor[y] = -(2*np.pi)**(-.5*d)/((ny-1)*self.h**d)\n",
    "\n",
    "        self.X = X\n",
    "        self.Y = Y\n",
    "        self.temporary_scores = scores\n",
    "        self.mult_factor = mult_factor\n",
    "        \n",
    "    def compute_scores(self, x, y, only_score_x=False):\n",
    "        # Preprocess kernel and compute score for (x, y).\n",
    "        Xy = self.X[self.Y==y,:]\n",
    "        dist_squared_y = euclidean_distances([x],\n",
    "                                             Xy,\n",
    "                                             squared=True).flatten()\n",
    "        #K = np.exp(-.5*dist_squared_y)\n",
    "        K = kernel(dist_squared_y)\n",
    "        \n",
    "        # Update multiplicative factor.\n",
    "        ny, d = Xy.shape\n",
    "        mult_factor_y = self.mult_factor[y] * ((ny-1)*self.h**d)/(ny*self.h**d)\n",
    "        \n",
    "        # Compute the score for x.\n",
    "        score_x = sum(K)*mult_factor_y\n",
    "        \n",
    "        if only_score_x:\n",
    "            return score_x\n",
    "\n",
    "        scores = []\n",
    "        for yi, scores_yi in self.temporary_scores.items():\n",
    "            if yi == y:\n",
    "                # Update scores with example (x, y).\n",
    "                scores_yi = scores_yi + K\n",
    "                mult_factor = mult_factor_y\n",
    "            else:\n",
    "                mult_factor = self.mult_factor[yi]\n",
    "\n",
    "            scores += list(scores_yi*mult_factor)\n",
    "        \n",
    "        # NOTE: can be further sped up by keeping track of the log-likelihood\n",
    "        # instead of likelihood within the algorithm.\n",
    "\n",
    "        # We convert from mpmath to ndarray when taking log.\n",
    "        logf = np.vectorize(mpmath.log)\n",
    "        return -logf([-score_x]).astype(float)[0], -logf(-np.array(scores)).astype(float)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "attended-appeal",
   "metadata": {},
   "source": [
    "### Least-squares SVM\n",
    "\n",
    "$$w^* = \\Phi[\\Phi^T \\Phi + \\rho I_N]^{-1}y = [\\rho I_J + \\Phi\\Phi^T]^{-1}\\Phi y$$\n",
    "\n",
    "\n",
    "We consider LS-SVM (ridge regression) as a classifier.\n",
    "Predictions $y >= 0$ indicate label y=+1, predictions $y < 0$\n",
    "mean label $y=-1$.\n",
    "\n",
    "We define the nonconformity measure as follows:\n",
    "\n",
    "$$A((x, y); \\{(x_1, y_1), ..., (x_{n}, y_{n})\\}) = -y f(x)$$\n",
    "\n",
    "where $f(x)$ is the prediction of LS-SVM for $x$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "small-diameter",
   "metadata": {},
   "outputs": [],
   "source": [
    "def linear_kernel(A):\n",
    "    return np.array(A).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "received-consensus",
   "metadata": {},
   "outputs": [],
   "source": [
    "class LSSVM(NCM):\n",
    "    def __init__(self, feature_map=None, rho=1.):\n",
    "        if not feature_map:\n",
    "            # Linear kernel if map is not specified\n",
    "            self.phi = linear_kernel\n",
    "        else:\n",
    "            self.phi = lambda A: np.atleast_2d(list(map(feature_map, A))).T\n",
    "        self.rho = rho\n",
    "\n",
    "    def train_ncm(self, X, Y):\n",
    "        n = len(X)\n",
    "        X = np.array(X)\n",
    "        Y = np.atleast_2d(Y).T\n",
    "        # Labels to {-1, 1}\n",
    "        Y[Y==0] = -1\n",
    "        assert len(np.unique(Y)) == 2\n",
    "        \n",
    "        Phi = self.phi(X)\n",
    "        I = np.eye(n)\n",
    "        w = Phi @ inv(Phi.T @ Phi + self.rho*I) @ Y\n",
    "        \n",
    "        def scorer(x, y):\n",
    "            if y == 0:\n",
    "                y = -1\n",
    "            pred = (w.T @ self.phi([x])).item()\n",
    "\n",
    "            return -pred*y\n",
    "        \n",
    "        return scorer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "weird-miracle",
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "class LSSVM_fast(NCM):\n",
    "    def __init__(self, feature_map=None, rho=1.):\n",
    "        if not feature_map:\n",
    "            # Linear kernel if map is not specified\n",
    "            self.phi = linear_kernel\n",
    "        else:\n",
    "            self.phi = lambda A: np.atleast_2d(list(map(feature_map, A))).T\n",
    "        self.rho = rho\n",
    "    \n",
    "    def _add_example(self, x, y, w, C):\n",
    "        \"\"\"Increments the trained LSSVM weights `w` with\n",
    "        a new example.\n",
    "        \"\"\"\n",
    "        I = np.eye(len(C))\n",
    "        phi_x = self.phi([x])\n",
    "        update = (C-I) @ phi_x  @ (phi_x.T @ w - y)\n",
    "        update /= (phi_x.T @ phi_x + self.rho - phi_x.T @ C @ phi_x).item()\n",
    "        # NOTE: do not change to \"w += update\", otherwise\n",
    "        # you'll be modifying the \"w\" provided as input :)\n",
    "        w = w + update\n",
    "\n",
    "        update = (C-I) @ phi_x @ phi_x.T @ (C-I)\n",
    "        update /= (phi_x.T @ phi_x + self.rho - phi_x.T @ C @ phi_x).item()\n",
    "        C = C + update\n",
    "        \n",
    "        return w, C\n",
    "    \n",
    "    def _remove_example(self, x, y, w, C, compute_c=True):\n",
    "        \"\"\"Decrements the trained LSSVM weights `w` after removing\n",
    "        one examples.\n",
    "        \"\"\"\n",
    "        I = np.eye(len(C))\n",
    "        phi_x = self.phi([x])\n",
    "        update = (C-I) @ phi_x  @ (phi_x.T @ w - y)\n",
    "        update /= (-phi_x.T @ phi_x + self.rho + phi_x.T @ C @ phi_x).item()\n",
    "        w = w - update\n",
    "        \n",
    "        if compute_c:\n",
    "            update = (C-I) @ phi_x @ phi_x.T @ (C-I)\n",
    "            update /= (-phi_x.T @ phi_x + self.rho + phi_x.T @ C @ phi_x).item()\n",
    "            C = C - update\n",
    "        else:\n",
    "            C = None\n",
    "        \n",
    "        return w, C\n",
    "    \n",
    "    def _predict(self, x, w):\n",
    "        return (w.T @ self.phi(x)).item()\n",
    "\n",
    "    def train(self, X, Y):\n",
    "        n = len(X)\n",
    "        X = np.array(X)\n",
    "        Y = np.atleast_2d(Y).T\n",
    "        # Labels to {-1, 1}\n",
    "        Y[Y==0] = -1\n",
    "        assert set(np.unique(Y)) == set([-1, 1]), \"Only binary labels in {-1, 1}!\"\n",
    "        \n",
    "        # Prepare for incremental/decremental learning\n",
    "        Phi = self.phi(X)\n",
    "        I = np.eye(n)\n",
    "        # NOTE: we could have made this even faster by computing\n",
    "        # inv(Phi.T @ Phi + self.rho*I) only once, and by\n",
    "        # rearranging the terms.\n",
    "        self.w = Phi @ inv(Phi.T @ Phi + self.rho*I) @ Y\n",
    "        self.C = Phi @ inv(Phi.T @ Phi + self.rho*I) @ Phi.T\n",
    "\n",
    "        # Need to keep them for CP\n",
    "        self.X = X\n",
    "        self.Y = Y\n",
    "\n",
    "    def compute_scores(self, x, y, only_score_x=False):\n",
    "        # Labels to {-1, 1}\n",
    "        if y == 0:\n",
    "            y = -1\n",
    "        \n",
    "        w = self.w\n",
    "        C = self.C\n",
    "\n",
    "        # Score x for first\n",
    "        score_x = -y * self._predict(x, w)\n",
    "        \n",
    "        if only_score_x:\n",
    "            return score_x\n",
    "        \n",
    "        # Add x to training\n",
    "        w, C = self._add_example(x, y, w, C)\n",
    "        \n",
    "        # Score all the rest\n",
    "        scores = []\n",
    "        for xi, yi in zip(self.X, self.Y):\n",
    "            yi = yi.item()\n",
    "            w_tmp, _ = self._remove_example(xi, yi, w, C, compute_c=False)\n",
    "            score = -yi * self._predict(xi, w_tmp)\n",
    "            scores.append(score)\n",
    "        \n",
    "        return score_x, np.array(scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "numerous-checklist",
   "metadata": {},
   "source": [
    "### Random forest\n",
    "\n",
    "Training: we generate many bootstrap samples $(X_b, Y_b)$ until there are B\n",
    "for every training point $(x_i, y_i)$ and for a (placeholder) test point\n",
    "$(x, y)$. A bootstrap sample is used for a point if that point does not\n",
    "belong to the sample.\n",
    "We also pre-train a model for each $(X_b, Y_b)$ if $(x, y) \\notin (X_b, Y_b)$,\n",
    "and pre-compute the score for all points $(x_i, y_i) \\notin (X_b, Y_b)$.\n",
    "\n",
    "Scoring: for each training example $(x_i, y_i)$ we train every model that hasn't\n",
    "been trained already, and we use it to predict $(x_i, y_i)$, and average\n",
    "the predictions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "nominated-hobby",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier as DT\n",
    "\n",
    "class BaggingClassifier:\n",
    "    def __init__(self, model, n_estimators=200, random_state=None,\n",
    "                 **model_args):\n",
    "        self.n_classes = None\n",
    "        self.estimators_ = [None]*n_estimators\n",
    "        self.model = model\n",
    "        self.model_args = model_args\n",
    "        self.random_state = random_state\n",
    "        self.model_args[\"random_state\"] = random_state\n",
    "        # The following dictionary associates the index i of a training\n",
    "        # data point to the tree(s) where that point was used.\n",
    "        self.used_data = defaultdict(set)\n",
    "\n",
    "    def refit_estimator(self, X, Y, estimator_idx):\n",
    "        Xboot, Yboot, used_idx = resample(X, Y,\n",
    "                                          list(range(len(X))),\n",
    "                                          replace=True)\n",
    "\n",
    "        model = self.model(**self.model_args)\n",
    "        model.fit(Xboot, Yboot)\n",
    "        self.estimators_[estimator_idx] = model\n",
    "\n",
    "        # Keep track of index of used points for this estimator.\n",
    "        for i in used_idx:\n",
    "            self.used_data[i] |= set([estimator_idx])\n",
    "\n",
    "    def fit(self, X, Y):\n",
    "        if not self.n_classes:\n",
    "            self.n_classes = len(np.unique(Y))\n",
    "\n",
    "        np.random.seed(self.random_state)\n",
    "\n",
    "        for model_idx in range(len(self.estimators_)):\n",
    "            self.refit_estimator(X, Y, model_idx)    \n",
    "\n",
    "    def predict_proba(self, X):\n",
    "        preds = []\n",
    "        for x in X:\n",
    "            preds_x = np.zeros(self.n_classes)\n",
    "            for tree in self.estimators_:\n",
    "                y = tree.predict([x])\n",
    "                preds_x[y] += 1\n",
    "            preds.append(preds_x / len(self.estimators_))\n",
    "\n",
    "        return np.array(preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "imported-lingerie",
   "metadata": {},
   "outputs": [],
   "source": [
    "class RandomForest(NCM):\n",
    "    def __init__(self, n_estimators=10, max_depth=10, max_features=\"auto\",\n",
    "                 random_state=None):\n",
    "        self.rf_args = dict(n_estimators=n_estimators,\n",
    "                            max_depth=max_depth,\n",
    "                            max_features=max_features,\n",
    "                            random_state=random_state)\n",
    "\n",
    "    def train_ncm(self, X, Y):\n",
    "        n = len(X)\n",
    "        X = np.array(X)\n",
    "        \n",
    "        rf = BaggingClassifier(DT, **self.rf_args)\n",
    "        rf.fit(X, Y)\n",
    "        \n",
    "        def scorer(x, y):\n",
    "            return -rf.predict_proba([x])[0][y]\n",
    "        \n",
    "        return scorer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "upper-oxygen",
   "metadata": {
    "code_folding": [
     11
    ]
   },
   "outputs": [],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier as DT\n",
    "\n",
    "\n",
    "class RandomForest_fast(NCM):\n",
    "    def __init__(self, n_estimators=10, max_depth=10, max_features=\"auto\",\n",
    "                 random_state=None):\n",
    "        self.n_estimators = n_estimators\n",
    "        self.max_depth = max_depth\n",
    "        self.random_state = random_state\n",
    "        self.max_features = max_features\n",
    "    \n",
    "    def _fit_model(self, X, Y, idx):\n",
    "        \"\"\"Fits base classifier on subset idx of\n",
    "        data (X, Y).\n",
    "        \"\"\"\n",
    "        idx = np.array(idx, dtype=int)\n",
    "\n",
    "        model = DT(max_depth=self.max_depth,\n",
    "                   max_features=self.max_features,\n",
    "                  )\n",
    "        model.fit(X[idx,:], Y[idx])\n",
    "        \n",
    "        return model\n",
    "\n",
    "    def train(self, X, Y):\n",
    "        if not self.random_state is None:\n",
    "            np.random.seed(self.random_state)\n",
    "\n",
    "        models = []\n",
    "        # Structure: idx_to_model[i] = [model_idx_0, model_idx_1, ...]\n",
    "        idx_to_model = defaultdict(list)\n",
    "\n",
    "        # We create bootstraps (and models) until each data point\n",
    "        # has at least B models.\n",
    "        # NOTE: we assume we already know the test point (x, y),\n",
    "        # to which we associate index 0. If this point appears in\n",
    "        # one of the bootstrap samples, we simply store the dataset\n",
    "        # (excluding (x, y) of course) instead of the model.\n",
    "        # If it doesn't appear, we pre-train the model.\n",
    "        B = self.n_estimators\n",
    "        # Add (x, y) placeholder at position 0.\n",
    "        nan_vec = np.full(X.shape[1], np.nan)\n",
    "        X = np.row_stack(([nan_vec], X))\n",
    "        Y = np.concatenate(([np.nan], Y))\n",
    "        # How many models each data point has.\n",
    "        bootstrap_count = {i: 0 for i in range(len(X))}\n",
    "        all_have_enough = lambda count: sum(np.array(list(count)) >= B) == len(count)\n",
    "\n",
    "        while not all_have_enough(bootstrap_count.values()):\n",
    "            used_idx = resample(list(range(len(X))), replace=True)\n",
    "            used_idx_unique = set(used_idx)\n",
    "            \n",
    "            if not 0 in used_idx_unique:\n",
    "                # Normal case: the test point is not in this\n",
    "                # bootstrap sample. We can already fit the model.\n",
    "                model = self._fit_model(X, Y, used_idx)\n",
    "            else:\n",
    "                # The test point should be in the bootstrap sample.\n",
    "                # Since we don't know it, we store the indeces\n",
    "                # that allow to generate this bootstrap sample.\n",
    "                model = used_idx\n",
    "\n",
    "            models.append(model)\n",
    "            \n",
    "            # We use this new model to compute the scores\n",
    "            # for the points that were not in this bootstrap\n",
    "            # sample.\n",
    "            for i in range(len(X)):\n",
    "                if i in used_idx_unique:\n",
    "                    continue\n",
    "                bootstrap_count[i] += 1\n",
    "                idx_to_model[i].append(len(models)-1)\n",
    "\n",
    "        self.idx_to_model = idx_to_model\n",
    "        self.models = models\n",
    "        self.X = X\n",
    "        self.Y = Y\n",
    "        self.n_labels = len(set(Y)) - 1 # Count to exclude placeholder \"np.nan\"\n",
    "\n",
    "    def _predict(self, model, x, y, X=None, Y=None):\n",
    "        # model can be a model or a list of indeces on\n",
    "        # which the model should be trained.\n",
    "        if isinstance(model, list):\n",
    "            if X is None or Y is None:\n",
    "                raise Exception(\"Specify (X, Y) for model retraining!\")\n",
    "            X = X[model,:]\n",
    "            Y = Y[model]\n",
    "            model = self._fit_model(X, Y, model)\n",
    "\n",
    "        return model.predict([x])[0] == y\n",
    "\n",
    "    def compute_scores(self, x, y, only_score_x=False):\n",
    "        # Replace placeholder with test point (x, y).\n",
    "        X, Y = self.X, self.Y\n",
    "        X[0,:] = x\n",
    "        Y[0] = y\n",
    "\n",
    "        # Prediction for (x, y)\n",
    "        pred_y = 0.\n",
    "        for model_idx in self.idx_to_model[0][:self.n_estimators]:\n",
    "            pred_y += self._predict(self.models[model_idx], x, y)\n",
    "\n",
    "        score_x = -pred_y/self.n_estimators\n",
    "        \n",
    "        if only_score_x:\n",
    "            return score_x\n",
    "        \n",
    "        # Score all the rest\n",
    "        scores = []\n",
    "        for point_idx, models_idx in self.idx_to_model.items():\n",
    "            if point_idx == 0:\n",
    "                continue\n",
    "            xi, yi = self.X[point_idx,:], self.Y[point_idx]\n",
    "            # Compute prediction for (xi, yi) given all\n",
    "            # the models trained on data excluding it.\n",
    "            models_idx = models_idx[:self.n_estimators]\n",
    "            pred_y = 0.\n",
    "            for idx in models_idx:\n",
    "                pred_y += self._predict(self.models[idx], xi, yi, X, Y)\n",
    "\n",
    "            scores.append(-pred_y/self.n_estimators)\n",
    "        \n",
    "        return score_x, np.array(scores)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "hazardous-globe",
   "metadata": {},
   "source": [
    "## Conformal Prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "electronic-superior",
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "def compute_pvalues(x, labels, ncm, precomputed_scores=None):\n",
    "    \"\"\"Generic function for computing p-values for `x`\n",
    "    for all candidate `labels` given a nonconformity\n",
    "    measure `ncm`.\n",
    "    If `precomputed_scores=None` this is used for (transductive) CP;\n",
    "    otherwise for inductive CP.\n",
    "    \"\"\"\n",
    "    pvalues_x = []\n",
    "    for y in labels:\n",
    "        if precomputed_scores is None:\n",
    "            # CP\n",
    "            score_x, scores = ncm.compute_scores(x, y)\n",
    "        else:\n",
    "            # ICP\n",
    "            score_x = ncm.compute_scores(x, y, only_score_x=True)\n",
    "            scores = precomputed_scores\n",
    "\n",
    "        pvalue = (1 + sum(scores >= score_x)) / (1 + len(scores))\n",
    "        pvalues_x.append(pvalue)\n",
    "\n",
    "    return pvalues_x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "drawn-relief",
   "metadata": {},
   "source": [
    "**NOTE** We define two (equivalent) functions for doing CP:\n",
    "a sequential version, which also returns running time information,\n",
    "and a parallel one, designed for when we're only interested\n",
    "in the predictions and not in the computational performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "extraordinary-commitment",
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "def cp_predict(Xtrain, Ytrain, Xtest, labels, ncm,\n",
    "               return_time=False, timeout=None):\n",
    "    # Train nonconformity measure\n",
    "    start = time.perf_counter()\n",
    "    ncm.train(Xtrain, Ytrain)\n",
    "    train_time = time.perf_counter() - start\n",
    "\n",
    "    # Predict p-values\n",
    "    start = time.perf_counter()\n",
    "    prediction_times = []\n",
    "    reached_timeout = False\n",
    "\n",
    "    pvalues = []\n",
    "    for x in Xtest:\n",
    "        pvalues_x = compute_pvalues(x, labels, ncm)\n",
    "        pvalues.append(pvalues_x)\n",
    "        \n",
    "        # Store time\n",
    "        t = time.perf_counter() - start\n",
    "        prediction_times.append(t)\n",
    "        \n",
    "        # Check if reached timeout\n",
    "        if timeout and t > timeout:\n",
    "            reached_timeout = True\n",
    "            break\n",
    "    \n",
    "    if return_time:\n",
    "        return np.array(pvalues), {\"training_time\": train_time,\n",
    "                                   \"prediction_time\": prediction_times,\n",
    "                                   \"reached_timeout\": reached_timeout,\n",
    "                                   }\n",
    "    else:\n",
    "        return np.array(pvalues)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "coral-concrete",
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "def cp_predict_parallel(Xtrain, Ytrain, Xtest, labels, ncm, jobs=None):\n",
    "    Xtrain = np.array(Xtrain)\n",
    "    Ytrain = np.array(Ytrain)\n",
    "    Xtest = np.array(Xtest)\n",
    "\n",
    "    # Train nonconformity measure\n",
    "    ncm.train(Xtrain, Ytrain)\n",
    "\n",
    "    # Predict p-values\n",
    "    with multiprocessing.Pool(jobs) as p:\n",
    "        pvalues = p.map(functools.partial(compute_pvalues,\n",
    "                                          labels=labels,\n",
    "                                          ncm=ncm), Xtest)\n",
    "\n",
    "    return np.array(pvalues)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "available-referral",
   "metadata": {},
   "source": [
    "ICP implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "furnished-adult",
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "def icp_predict(Xtrain, Ytrain, Xcalib, Ycalib, Xtest,\n",
    "                labels, ncm, return_time=False, timeout=None):\n",
    "    # Train nonconformity measure\n",
    "    start = time.perf_counter()\n",
    "    ncm.train(Xtrain, Ytrain, inductive=True)\n",
    "    train_time = time.perf_counter() - start\n",
    "    \n",
    "    # Calibrate\n",
    "    start = time.perf_counter()\n",
    "    scores = []\n",
    "    for x, y in zip(Xcalib, Ycalib):\n",
    "        scores.append(ncm.compute_scores(x, y, only_score_x=True))\n",
    "    scores = np.array(scores)\n",
    "    calibration_time = time.perf_counter() - start\n",
    "\n",
    "    # Predict p-values\n",
    "    start = time.perf_counter()\n",
    "    prediction_times = []\n",
    "    reached_timeout = False\n",
    "\n",
    "    pvalues = []\n",
    "    for x in Xtest:\n",
    "        pvalues_x = compute_pvalues(x, labels, ncm, scores)\n",
    "        pvalues.append(pvalues_x)\n",
    "        \n",
    "        # Store time\n",
    "        t = time.perf_counter() - start\n",
    "        prediction_times.append(t)\n",
    "        \n",
    "        # Check if reached timeout\n",
    "        if timeout and t > timeout:\n",
    "            reached_timeout = True\n",
    "            break\n",
    "    \n",
    "    pred_time = time.perf_counter() - start\n",
    "    \n",
    "    if return_time:\n",
    "        return np.array(pvalues), {\"training_time\": train_time,\n",
    "                                   \"calibration_time\": calibration_time,\n",
    "                                   \"prediction_time\": prediction_times,\n",
    "                                   \"reached_timeout\": reached_timeout,\n",
    "                                   }\n",
    "    else:\n",
    "        return np.array(pvalues)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "loved-direction",
   "metadata": {},
   "source": [
    "# Correctness\n",
    "\n",
    "Unit tests, to ensure the correctness of our implementations\n",
    "(as much as it is possible)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "southwest-bonus",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Unit test for CP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "valuable-arrangement",
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "class CPTests(unittest.TestCase):\n",
    "    def setUp(self):\n",
    "        self.X = [[0, 0], [1, 0], [0, 1], [1, 1], [1, 2]]\n",
    "        self.Y = np.array([0, 0, 0, 1, 1])\n",
    "        self.x = [2, 2]\n",
    "\n",
    "    def test_cp(self):\n",
    "        \"\"\"Test 1-NN CP on hand-calculated values.\n",
    "        \"\"\"\n",
    "        # Calculate with alternative method (manual)\n",
    "        X = [[0, 0], [1, 0], [0, 1], [1, 1], [1, 2]]\n",
    "        Y = np.array([0, 0, 0, 1, 1])\n",
    "        x = [2, 2]\n",
    "        \n",
    "        X.append(self.x)\n",
    "        D = euclidean_distances(X)\n",
    "        # Scores given y = 0\n",
    "        score_x = D[1,5]/D[4,5]\n",
    "        scores = np.array([D[1,0]/D[3,0], D[0,1]/D[3,1], D[0,2]/D[3,2], D[4,3]/D[4,3], D[3,4]/D[5,4]])\n",
    "        pvalue0 = (sum(scores >= score_x)+1) / (len(scores)+1)\n",
    "        # Scores given y = 1\n",
    "        score_x = D[4,5]/D[1,5]\n",
    "        scores = np.array([D[1,0]/D[3,0], D[0,1]/D[3,1], D[0,2]/D[3,2], D[4,3]/D[4,3], D[3,4]/D[2,4]])\n",
    "        pvalue1 = (sum(scores >= score_x)+1) / (len(scores)+1)\n",
    "        \n",
    "        expected_pvalues = [pvalue0, pvalue1]\n",
    "        \n",
    "        output = cp_predict(self.X, self.Y, [self.x, self.x], [0, 1], ncm=NN())\n",
    "        output = list(output[0,:])\n",
    "\n",
    "        self.assertListEqual(output, expected_pvalues)\n",
    "\n",
    "    def test_icp_cp(self):\n",
    "        \"\"\"ICP with Xtrain=Xcalib and Ytrain=Ycalib must be equivalent to CP.\n",
    "        \n",
    "        Evaluation numbers come from test_cp_scores().\n",
    "        \"\"\"\n",
    "        # Calculate with alternative method (manual)\n",
    "        Xtrain = [[0, 0], [1, 0], [0, 1], [1, 1], [1, 2]]\n",
    "        Ytrain = np.array([0, 0, 0, 1, 1])\n",
    "        Xcalib = [[4, 3], [1, -1], [2, 1], [4, 5]]\n",
    "        Ycalib = [0, 0, 1, 1]\n",
    "        x = [2, 2]\n",
    "        \n",
    "        # Calibration scores\n",
    "        D = euclidean_distances(Xcalib, Xtrain)\n",
    "        scores = np.array([D[0,1]/D[0,4], D[1,1]/D[1,3], D[2,3]/D[2,1], D[3,4]/D[3,2]])\n",
    "\n",
    "        # Scores given y = 0\n",
    "        D = euclidean_distances([x], Xtrain).flatten()\n",
    "        score_x = D[1]/D[4]\n",
    "        pvalue0 = (sum(scores >= score_x)+1) / (len(scores)+1)\n",
    "\n",
    "        # Scores given y = 1\n",
    "        D = euclidean_distances([x], Xtrain).flatten()\n",
    "        score_x = D[4]/D[1]\n",
    "        pvalue1 = (sum(scores >= score_x)+1) / (len(scores)+1)\n",
    "        \n",
    "        expected_pvalues = [pvalue0, pvalue1]\n",
    "        \n",
    "        output = icp_predict(Xtrain, Ytrain, Xcalib, Ycalib, [x, x], [0, 1], ncm=NN())\n",
    "        output = list(output[0,:])\n",
    "\n",
    "        self.assertListEqual(output, expected_pvalues)\n",
    "\n",
    "    def test_cp_parallel_equivalent(self):\n",
    "        \"\"\"CP and parallel CP should give the same results.\n",
    "        \"\"\"\n",
    "        X, Y = load_iris(return_X_y=True)\n",
    "\n",
    "        r1 = cp_predict(X, Y, X, np.unique(Y), KNN_fast())\n",
    "        r2 = cp_predict_parallel(X, Y, X, np.unique(Y), KNN_fast())\n",
    "\n",
    "        np.testing.assert_allclose(r1, r2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "located-surface",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## Verify that optimized NCMs are equivalent to unoptimized ones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "recovered-trance",
   "metadata": {
    "code_folding": [],
    "hidden": true
   },
   "outputs": [],
   "source": [
    "class NCMTests(unittest.TestCase):\n",
    "    \n",
    "    def setUp(self):       \n",
    "        X, Y = load_iris(return_X_y=True)\n",
    "        Y[Y==2] = 1\n",
    "        \n",
    "        np.random.seed(0)\n",
    "        self.Xtrain, self.Xtest, self.Ytrain, self.Ytest = train_test_split(X, Y, test_size=50)\n",
    "    \n",
    "    @parameterized.expand([\n",
    "        [NN(), NN_fast()],\n",
    "        [SimplifiedKNN(), SimplifiedKNN_fast()],\n",
    "        [KNN(), KNN_fast()],\n",
    "        [KDE(), KDE_fast()],\n",
    "        [LSSVM(), LSSVM_fast()],\n",
    "        # NOTE: random forest is not an exact approximation.\n",
    "        [RandomForest(random_state=0), RandomForest_fast(random_state=0), 0.2],\n",
    "    ])\n",
    "    def test_equivalent(self, ncm_a, ncm_b, rtol=1e-07):\n",
    "        \"\"\"Are standard and optimized ncms equivalent?\n",
    "        \"\"\"\n",
    "        print(f\"Testing: {ncm_a.__class__.__name__}, {ncm_b.__class__.__name__}\")\n",
    "        ncm_a.train(self.Xtrain, self.Ytrain)\n",
    "        ncm_b.train(self.Xtrain, self.Ytrain)\n",
    "        \n",
    "        for x, y in zip(self.Xtest, self.Ytest):\n",
    "            score_x_a, scores_a = ncm_a.compute_scores(x, y)\n",
    "            score_x_b, scores_b = ncm_b.compute_scores(x, y)\n",
    "            np.testing.assert_allclose(score_x_a, score_x_b, rtol=rtol)\n",
    "            # NOTE: we sort the scores here, because for some ncms\n",
    "            # (e.g., SimplifiedKNN) the fast version returns the\n",
    "            # same scores in a different order. Of course, for the\n",
    "            # CP algorithm the order of the scores is irrelevant.\n",
    "            np.testing.assert_allclose(sorted(scores_a),\n",
    "                                       sorted(scores_b), rtol=rtol)\n",
    "\n",
    "suite = unittest.defaultTestLoader.loadTestsFromTestCase(NCMTests)\n",
    "_ = unittest.TextTestRunner().run(suite)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "starting-authorization",
   "metadata": {},
   "source": [
    "# Computational performance\n",
    "\n",
    "Predictions scale linearly in the number of test\n",
    "points (times the expense of computing the prediction for one).\n",
    "\n",
    "Therefore, it's interesting to evaluate how changing the\n",
    "size of the training data affects the performance.\n",
    "We  measure the time to predict 100 test points,\n",
    "and then will be concerned in the average time this takes.\n",
    "\n",
    "We select the number of training points from the set\n",
    "`np.logspace(1, 5, 13, dtype='int').tolist()`.\n",
    "\n",
    "For these experiments the kind of data is not\n",
    "important: we only care about the running time.\n",
    "We therefore generate data by using `scikit-learn`'s\n",
    "`make_classification()`.\n",
    "\n",
    "## Note on the experiments (Eli)\n",
    "\n",
    "To run our experiments, we use a simple library we wrote, `Eli`,\n",
    "which enables launching jobs over several parameters, and\n",
    "fetching the respective results, via a simple interface.\n",
    "\n",
    "For example, suppose we want to launch function `foo(a, b)`\n",
    "for values `a = 0, 1, ..., 9` and fixed `b=5`.\n",
    "The output of the function must be a `dict` containing its\n",
    "results (e.g., `{\"res\": a+b}`).\n",
    "\n",
    "```python\n",
    "eli = Eli(\"results/\")\n",
    "\n",
    "eli.run_experiment(exp_name=\"experiment-foo\",\n",
    "                   func=foo,                      # Function to launch\n",
    "                   repetitions=5,                 # Repetitions per parameter combination\n",
    "                   n_jobs=40,                     # Number of concurrent processes\n",
    "                   automatic_seed=True,           # Automatically change numpy seed for each repetition\n",
    "                   # Parameters (appearance order matters!)\n",
    "                   a=list(range(10)),\n",
    "                   b=5,\n",
    "                  )\n",
    "```\n",
    "\n",
    "Results will be found in `results/experiment-foo`, and they can be fetched with:\n",
    "\n",
    "```python\n",
    "results = eli.fetch_results(\"experiment-foo\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dimensional-christmas",
   "metadata": {},
   "source": [
    "## Experiment "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "integrated-soviet",
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate_ncm(ncm, train_size, max_test_size, n_classes, n_dimensions,\n",
    "                 inductive_cp, calibration_size, timeout):\n",
    "    # Discard invalid parameter sets.\n",
    "    if inductive_cp and calibration_size is None:\n",
    "        return\n",
    "    if not inductive_cp and calibration_size is not None:\n",
    "        return\n",
    "    \n",
    "    ncm_class = eval(ncm)       # eval(): Perdoname, madre, por mi vida loca :D\n",
    "    ncm = ncm_class()\n",
    "\n",
    "    X, Y = make_classification(train_size+max_test_size,\n",
    "                               n_dimensions, n_classes=n_classes)\n",
    "\n",
    "    Xtrain, Xtest, Ytrain, Ytest = train_test_split(X, Y, test_size=max_test_size)\n",
    "\n",
    "    if inductive_cp:\n",
    "        Xtrain, Xcalib, Ytrain, Ycalib = train_test_split(Xtrain, Ytrain,\n",
    "                                                          test_size=calibration_size)\n",
    "        _, times = icp_predict(Xtrain, Ytrain, Xcalib, Ycalib,\n",
    "                               Xtest, np.unique(Y), ncm, return_time=True)\n",
    "    else:\n",
    "        _, times = cp_predict(Xtrain, Ytrain, Xtest, np.unique(Y),\n",
    "                          ncm, return_time=True, timeout=timeout)\n",
    "    \n",
    "    return times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "coordinated-instrument",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-07T11:50:06.879094Z",
     "start_time": "2021-06-07T11:50:06.875722Z"
    },
    "tags": [
     "experiment:vary-training-data"
    ]
   },
   "outputs": [],
   "source": [
    "EXPERIMENT_NAME = \"training-size-comparison\"\n",
    "RESULTS_DIR = \"results/\"\n",
    "REPETITIONS = 5\n",
    "TRAIN_SIZE = np.logspace(1, 5, 13, dtype='int').tolist()\n",
    "MAX_TEST_SIZE = 100\n",
    "N_CLASSES = 2\n",
    "N_DIMENSIONS = 30\n",
    "TIMEOUT = 60*60*10"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "medical-mystery",
   "metadata": {},
   "source": [
    "### CP vs optimized CP\n",
    "\n",
    "We run the experiments for training size $n \\in [10, 10^5]$, with two exceptions:\n",
    "\n",
    "- Standard LS-SVM only runs up to 4641.\n",
    "- Standard and optimized Random Forest only run up to 46415.\n",
    "\n",
    "For larger values of $n$, the training time of the above methods (LS-SVM and Random Forest)\n",
    "would go well beyond the timeout time that we fixed for the plots (Figure 1 in paper)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "varied-rainbow",
   "metadata": {
    "tags": [
     "experiment:vary-training-data"
    ]
   },
   "outputs": [],
   "source": [
    "# All nonconformity measures except for the above exceptions\n",
    "\n",
    "NCMs = [\"NN\", \"SimplifiedKNN\", \"KNN\", \"KDE\"]\n",
    "NCMs += [ncm + \"_fast\" for ncm in NCMs]\n",
    "NCMs += [\"LSSVM_fast\"]\n",
    "\n",
    "eli = Eli(RESULTS_DIR)\n",
    "eli.run_experiment(exp_name=EXPERIMENT_NAME,\n",
    "                   func=evaluate_ncm,\n",
    "                   repetitions=REPETITIONS,\n",
    "                   n_jobs=40,\n",
    "                   automatic_seed=True,\n",
    "                   # Parameters\n",
    "                   ncm=NCMs,\n",
    "                   train_size=TRAIN_SIZE,\n",
    "                   max_test_size=MAX_TEST_SIZE,\n",
    "                   n_classes=N_CLASSES,\n",
    "                   n_dimensions=N_DIMENSIONS,\n",
    "                   inductive_cp=False,\n",
    "                   calibration_size=None,\n",
    "                   timeout=TIMEOUT,\n",
    "                  )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cheap-enzyme",
   "metadata": {
    "tags": [
     "experiment:vary-training-data"
    ]
   },
   "outputs": [],
   "source": [
    "eli = Eli(RESULTS_DIR)\n",
    "\n",
    "# LS-SVM\n",
    "eli.run_experiment(exp_name=EXPERIMENT_NAME,\n",
    "                   func=evaluate_ncm,\n",
    "                   repetitions=REPETITIONS,\n",
    "                   n_jobs=40,\n",
    "                   automatic_seed=True,\n",
    "                   # Parameters\n",
    "                   ncm=\"LSSVM\",\n",
    "                   train_size=TRAIN_SIZE[:9],\n",
    "                   max_test_size=MAX_TEST_SIZE,\n",
    "                   n_classes=N_CLASSES,\n",
    "                   n_dimensions=N_DIMENSIONS,\n",
    "                   inductive_cp=False,\n",
    "                   calibration_size=None,\n",
    "                   timeout=TIMEOUT,\n",
    "                  )\n",
    "\n",
    "# Random Forest\n",
    "eli.run_experiment(exp_name=EXPERIMENT_NAME,\n",
    "                   func=evaluate_ncm,\n",
    "                   repetitions=REPETITIONS,\n",
    "                   n_jobs=40,\n",
    "                   automatic_seed=True,\n",
    "                   # Parameters\n",
    "                   ncm=[\"RandomForest\", \"RandomForest_fast\"],\n",
    "                   train_size=TRAIN_SIZE[:12],\n",
    "                   max_test_size=MAX_TEST_SIZE,\n",
    "                   n_classes=N_CLASSES,\n",
    "                   n_dimensions=N_DIMENSIONS,\n",
    "                   inductive_cp=False,\n",
    "                   calibration_size=None,\n",
    "                   timeout=TIMEOUT,\n",
    "                  )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "accurate-programming",
   "metadata": {},
   "source": [
    "### ICP\n",
    "\n",
    "For ICP we run all the methods together, with $n \\in [10, 10^5]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "primary-hammer",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-07T11:50:09.896437Z",
     "start_time": "2021-06-07T11:50:09.779957Z"
    },
    "tags": [
     "experiment:vary-training-data"
    ]
   },
   "outputs": [],
   "source": [
    "NCMs = [\"NN\", \"SimplifiedKNN\", \"KNN\", \"KDE\", \"LSSVM\", \"RandomForest\"]\n",
    "\n",
    "eli = Eli(RESULTS_DIR)\n",
    "eli.run_experiment(exp_name=EXPERIMENT_NAME,\n",
    "                   func=evaluate_ncm,\n",
    "                   repetitions=REPETITIONS,\n",
    "                   n_jobs=40,\n",
    "                   automatic_seed=True,\n",
    "                   # Parameters\n",
    "                   ncm=NCMs,\n",
    "                   train_size=TRAIN_SIZE,\n",
    "                   max_test_size=MAX_TEST_SIZE,\n",
    "                   n_classes=N_CLASSES,\n",
    "                   n_dimensions=N_DIMENSIONS,\n",
    "                   inductive_cp=True,\n",
    "                   calibration_size=0.5,\n",
    "                   timeout=TIMEOUT,\n",
    "                  )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "advanced-geography",
   "metadata": {},
   "source": [
    "## Plots and results\n",
    "\n",
    "Comparing with respect to the training size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "aggressive-computer",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-07T11:50:20.419754Z",
     "start_time": "2021-06-07T11:50:19.760551Z"
    },
    "tags": [
     "plots"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1200 observations\n"
     ]
    },
    {
     "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>name</th>\n",
       "      <th>training_time</th>\n",
       "      <th>calibration_time</th>\n",
       "      <th>prediction_time</th>\n",
       "      <th>reached_timeout</th>\n",
       "      <th>ncm</th>\n",
       "      <th>train_size</th>\n",
       "      <th>max_test_size</th>\n",
       "      <th>n_classes</th>\n",
       "      <th>n_dimensions</th>\n",
       "      <th>inductive_cp</th>\n",
       "      <th>calibration_size</th>\n",
       "      <th>timeout</th>\n",
       "      <th>repetition</th>\n",
       "      <th>git-commit</th>\n",
       "      <th>started</th>\n",
       "      <th>finished</th>\n",
       "      <th>avg_time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>ncm=RandomForest-train_size=4641-max_test_size...</td>\n",
       "      <td>0.108136</td>\n",
       "      <td>1.312082</td>\n",
       "      <td>[0.009590358007699251, 0.023431785870343447, 0...</td>\n",
       "      <td>False</td>\n",
       "      <td>RandomForest</td>\n",
       "      <td>4641</td>\n",
       "      <td>100</td>\n",
       "      <td>2</td>\n",
       "      <td>30</td>\n",
       "      <td>True</td>\n",
       "      <td>0.5</td>\n",
       "      <td>36000</td>\n",
       "      <td>0</td>\n",
       "      <td>88c0ef46a4fdee12a2715739adff119d7cd24953</td>\n",
       "      <td>2021-04-12T15:06:45.735397+00:00</td>\n",
       "      <td>2021-04-12T15:06:48.068019+00:00</td>\n",
       "      <td>0.008963</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>ncm=RandomForest-train_size=4641-max_test_size...</td>\n",
       "      <td>0.103274</td>\n",
       "      <td>1.319600</td>\n",
       "      <td>[0.008455939823761582, 0.01775519293732941, 0....</td>\n",
       "      <td>False</td>\n",
       "      <td>RandomForest</td>\n",
       "      <td>4641</td>\n",
       "      <td>100</td>\n",
       "      <td>2</td>\n",
       "      <td>30</td>\n",
       "      <td>True</td>\n",
       "      <td>0.5</td>\n",
       "      <td>36000</td>\n",
       "      <td>3</td>\n",
       "      <td>88c0ef46a4fdee12a2715739adff119d7cd24953</td>\n",
       "      <td>2021-04-12T15:06:52.704668+00:00</td>\n",
       "      <td>2021-04-12T15:06:55.035293+00:00</td>\n",
       "      <td>0.008912</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>ncm=RandomForest-train_size=4641-max_test_size...</td>\n",
       "      <td>0.108236</td>\n",
       "      <td>1.270121</td>\n",
       "      <td>[0.008516540052369237, 0.01738778594881296, 0....</td>\n",
       "      <td>False</td>\n",
       "      <td>RandomForest</td>\n",
       "      <td>4641</td>\n",
       "      <td>100</td>\n",
       "      <td>2</td>\n",
       "      <td>30</td>\n",
       "      <td>True</td>\n",
       "      <td>0.5</td>\n",
       "      <td>36000</td>\n",
       "      <td>4</td>\n",
       "      <td>88c0ef46a4fdee12a2715739adff119d7cd24953</td>\n",
       "      <td>2021-04-12T15:06:55.062958+00:00</td>\n",
       "      <td>2021-04-12T15:06:57.322627+00:00</td>\n",
       "      <td>0.008649</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>ncm=RandomForest-train_size=4641-max_test_size...</td>\n",
       "      <td>0.099264</td>\n",
       "      <td>1.261298</td>\n",
       "      <td>[0.008587141055613756, 0.01721918396651745, 0....</td>\n",
       "      <td>False</td>\n",
       "      <td>RandomForest</td>\n",
       "      <td>4641</td>\n",
       "      <td>100</td>\n",
       "      <td>2</td>\n",
       "      <td>30</td>\n",
       "      <td>True</td>\n",
       "      <td>0.5</td>\n",
       "      <td>36000</td>\n",
       "      <td>2</td>\n",
       "      <td>88c0ef46a4fdee12a2715739adff119d7cd24953</td>\n",
       "      <td>2021-04-12T15:06:50.438903+00:00</td>\n",
       "      <td>2021-04-12T15:06:52.676796+00:00</td>\n",
       "      <td>0.008620</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>ncm=RandomForest-train_size=4641-max_test_size...</td>\n",
       "      <td>0.102344</td>\n",
       "      <td>1.314754</td>\n",
       "      <td>[0.008790143998339772, 0.017412087181583047, 0...</td>\n",
       "      <td>False</td>\n",
       "      <td>RandomForest</td>\n",
       "      <td>4641</td>\n",
       "      <td>100</td>\n",
       "      <td>2</td>\n",
       "      <td>30</td>\n",
       "      <td>True</td>\n",
       "      <td>0.5</td>\n",
       "      <td>36000</td>\n",
       "      <td>1</td>\n",
       "      <td>88c0ef46a4fdee12a2715739adff119d7cd24953</td>\n",
       "      <td>2021-04-12T15:06:48.093314+00:00</td>\n",
       "      <td>2021-04-12T15:06:50.410478+00:00</td>\n",
       "      <td>0.008850</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                name  training_time  \\\n",
       "0  ncm=RandomForest-train_size=4641-max_test_size...       0.108136   \n",
       "1  ncm=RandomForest-train_size=4641-max_test_size...       0.103274   \n",
       "2  ncm=RandomForest-train_size=4641-max_test_size...       0.108236   \n",
       "3  ncm=RandomForest-train_size=4641-max_test_size...       0.099264   \n",
       "4  ncm=RandomForest-train_size=4641-max_test_size...       0.102344   \n",
       "\n",
       "   calibration_time                                    prediction_time  \\\n",
       "0          1.312082  [0.009590358007699251, 0.023431785870343447, 0...   \n",
       "1          1.319600  [0.008455939823761582, 0.01775519293732941, 0....   \n",
       "2          1.270121  [0.008516540052369237, 0.01738778594881296, 0....   \n",
       "3          1.261298  [0.008587141055613756, 0.01721918396651745, 0....   \n",
       "4          1.314754  [0.008790143998339772, 0.017412087181583047, 0...   \n",
       "\n",
       "   reached_timeout           ncm  train_size  max_test_size  n_classes  \\\n",
       "0            False  RandomForest        4641            100          2   \n",
       "1            False  RandomForest        4641            100          2   \n",
       "2            False  RandomForest        4641            100          2   \n",
       "3            False  RandomForest        4641            100          2   \n",
       "4            False  RandomForest        4641            100          2   \n",
       "\n",
       "   n_dimensions  inductive_cp  calibration_size  timeout  repetition  \\\n",
       "0            30          True               0.5    36000           0   \n",
       "1            30          True               0.5    36000           3   \n",
       "2            30          True               0.5    36000           4   \n",
       "3            30          True               0.5    36000           2   \n",
       "4            30          True               0.5    36000           1   \n",
       "\n",
       "                                 git-commit                           started  \\\n",
       "0  88c0ef46a4fdee12a2715739adff119d7cd24953  2021-04-12T15:06:45.735397+00:00   \n",
       "1  88c0ef46a4fdee12a2715739adff119d7cd24953  2021-04-12T15:06:52.704668+00:00   \n",
       "2  88c0ef46a4fdee12a2715739adff119d7cd24953  2021-04-12T15:06:55.062958+00:00   \n",
       "3  88c0ef46a4fdee12a2715739adff119d7cd24953  2021-04-12T15:06:50.438903+00:00   \n",
       "4  88c0ef46a4fdee12a2715739adff119d7cd24953  2021-04-12T15:06:48.093314+00:00   \n",
       "\n",
       "                           finished  avg_time  \n",
       "0  2021-04-12T15:06:48.068019+00:00  0.008963  \n",
       "1  2021-04-12T15:06:55.035293+00:00  0.008912  \n",
       "2  2021-04-12T15:06:57.322627+00:00  0.008649  \n",
       "3  2021-04-12T15:06:52.676796+00:00  0.008620  \n",
       "4  2021-04-12T15:06:50.410478+00:00  0.008850  "
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load data\n",
    "\n",
    "eli = Eli(RESULTS_DIR)\n",
    "results = eli.fetch_results(\"training-size-comparison\")\n",
    "\n",
    "print(f\"{len(results)} observations\")\n",
    "\n",
    "NAMES = {\"SimplifiedKNN\": \"Simplified k-NN\",\n",
    "         \"KNN\": \"k-NN\",\n",
    "         \"LSSVM\": \"LS-SVM\",\n",
    "         \"KDE\": \"KDE\",\n",
    "         \"RandomForest\": \"Random Forest\",\n",
    "        }\n",
    "TIMEOUT = 60*60*10\n",
    "\n",
    "avgerage_time = lambda vec: np.concatenate((\n",
    "                                [vec[0]],\n",
    "                                pd.Series(vec).diff()[1:]\n",
    "                            )).mean()\n",
    "\n",
    "results[\"avg_time\"] = results.prediction_time.apply(avgerage_time)\n",
    "\n",
    "results.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "narrow-walter",
   "metadata": {},
   "source": [
    "In the following cell, we calculate the numbers reported in the paper."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "recovered-evolution",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-03T17:05:24.083260Z",
     "start_time": "2021-06-03T17:05:23.999044Z"
    },
    "code_folding": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k-NN optimized avg pred (100k): 0.6334899960040057 seconds\n",
      "k-NN avg pred (100k): 1.968957308143136 hours\n",
      "LSSVM optimized avg pred (4641): 0.21028654634393754 seconds\n",
      "LSSVM avg pred (4641): 24.52378716933872 hours\n",
      "RF optimized avg pred (46415): 43.19851039095787 hours\n",
      "RF avg pred (46415): 81.54313994453346 hours\n",
      "k-NN (train: 100k test: 20k): 2.088605384212111 h training 3.5193888666889204 h prediction\n",
      "k-NN (train: 100k test: 20k): 0 h training 4.495336319961498 years prediction\n",
      "LSSVM optimized avg pred (100k): 6.6777872765858195 seconds\n",
      "LSSVM ICP avg pred (100k): 0.15608686965843663 seconds\n",
      "KDE ICP avg pred (100k): 0.3133951543457806 seconds\n",
      "KDE optimized avg pred (100k): 0.4642496941339923 seconds\n"
     ]
    }
   ],
   "source": [
    "print(\"k-NN optimized avg pred (100k): {} seconds\".format(\n",
    "            results[(results.ncm==\"KNN_fast\") &\n",
    "                    (results.train_size==100000) &\n",
    "                    (results.inductive_cp==False)].avg_time.mean()))\n",
    "print(\"k-NN avg pred (100k): {} hours\".format(\n",
    "            results[(results.ncm==\"KNN\") &\n",
    "                    (results.train_size==100000) &\n",
    "                    (results.inductive_cp==False)].avg_time.mean()/60/60))\n",
    "\n",
    "print(\"LSSVM optimized avg pred (4641): {} seconds\".format(\n",
    "            results[(results.ncm==\"LSSVM_fast\") &\n",
    "                    (results.train_size==4641) &\n",
    "                    (results.inductive_cp==False)].avg_time.mean()))\n",
    "print(\"LSSVM avg pred (4641): {} hours\".format(\n",
    "            results[(results.ncm==\"LSSVM\") &\n",
    "                    (results.train_size==4641) &\n",
    "                    (results.inductive_cp==False)].avg_time.mean()/60/60))\n",
    "\n",
    "print(\"RF optimized avg pred (46415): {} hours\".format(\n",
    "            results[(results.ncm==\"RandomForest_fast\") &\n",
    "                    (results.inductive_cp==False) &\n",
    "                    (results.train_size==46415)].avg_time.mean()/60/60))\n",
    "print(\"RF avg pred (46415): {} hours\".format(\n",
    "            results[(results.ncm==\"RandomForest\") &\n",
    "                    (results.inductive_cp==False) &\n",
    "                    (results.train_size==46415)].avg_time.mean()/60/60))\n",
    "\n",
    "print(\"k-NN (train: 100k test: 20k): {} h training {} h prediction\".format(\n",
    "            results[(results.ncm==\"KNN_fast\") &\n",
    "                    (results.inductive_cp==False) &\n",
    "                    (results.train_size==100000)].training_time.mean()/60/60,\n",
    "            results[(results.ncm==\"KNN_fast\") &\n",
    "                    (results.inductive_cp==False) &\n",
    "                    (results.train_size==100000)].avg_time.mean()*20000/60/60))\n",
    "print(\"k-NN (train: 100k test: 20k): {} h training {} years prediction\".format(\n",
    "            0,\n",
    "            results[(results.ncm==\"KNN\") &\n",
    "                    (results.inductive_cp==False) &\n",
    "                    (results.train_size==100000)].avg_time.mean()*20000/60/60/24/365))\n",
    "\n",
    "print(\"LSSVM optimized avg pred (100k): {} seconds\".format(\n",
    "            results[(results.ncm==\"LSSVM_fast\") &\n",
    "                    (results.train_size==100000) &\n",
    "                    (results.inductive_cp==False)].avg_time.mean()))\n",
    "print(\"LSSVM ICP avg pred (100k): {} seconds\".format(\n",
    "            results[(results.ncm==\"LSSVM\") &\n",
    "                    (results.train_size==100000) &\n",
    "                    (results.inductive_cp==True)].avg_time.mean()))\n",
    "print(\"KDE ICP avg pred (100k): {} seconds\".format(\n",
    "            results[(results.ncm==\"KDE\") &\n",
    "                    (results.train_size==100000) &\n",
    "                    (results.inductive_cp==True)].avg_time.mean()))\n",
    "print(\"KDE optimized avg pred (100k): {} seconds\".format(\n",
    "            results[(results.ncm==\"KDE_fast\") &\n",
    "                    (results.train_size==100000) &\n",
    "                    (results.inductive_cp==False)].avg_time.mean()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "valid-wrist",
   "metadata": {},
   "source": [
    "Producing **Figure 1**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "wrong-assessment",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-07T11:52:19.030482Z",
     "start_time": "2021-06-07T11:52:12.126253Z"
    },
    "tags": [
     "plots"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x288 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(1, 4, sharex=True,\n",
    "                         figsize=(14, 4))\n",
    "colors = sns.color_palette()\n",
    "NCMS = [\"KNN\", \"LSSVM\", \"KDE\", \"RandomForest\"]\n",
    "\n",
    "for i, (ax, ncm) in enumerate(zip(axes.flat, NCMS)):\n",
    "    # CP\n",
    "    plot_data = results[((results.ncm == ncm) | (results.ncm == ncm + \"_fast\")) &\n",
    "                        (results.inductive_cp == False)]\n",
    "\n",
    "    sns.lineplot(x=\"train_size\", y=\"avg_time\",\n",
    "                 data=plot_data[plot_data.ncm==ncm],\n",
    "                 ax=ax, legend=None, label=\"Standard CP\",\n",
    "                 color=colors[0])\n",
    "    sns.lineplot(x=\"train_size\", y=\"avg_time\",\n",
    "                 data=plot_data[plot_data.ncm==ncm+\"_fast\"],\n",
    "                 ax=ax, legend=None, label=\"Optimized CP\",\n",
    "                 color=colors[1])\n",
    "    \n",
    "    # ICP\n",
    "    plot_data_icp = results[(results.ncm == ncm) &\n",
    "                        (results.inductive_cp == True) &\n",
    "                        (results.calibration_size == 0.5)]\n",
    "    \n",
    "    sns.lineplot(x=\"train_size\", y=\"avg_time\", data=plot_data_icp,\n",
    "                 ax=ax, legend=False, label=\"ICP\",\n",
    "                 color=colors[-3])\n",
    "\n",
    "    ax.plot(range(10**5), [TIMEOUT]*10**5, color='k', ls=':')\n",
    "    \n",
    "    ax.lines[0].set_linestyle(\"--\")\n",
    "    ax.lines[2].set_linestyle(\":\")\n",
    "\n",
    "    ax.set_yscale(\"log\")\n",
    "    ax.xaxis.set_major_formatter(ticker.EngFormatter())\n",
    "    ax.grid()\n",
    "    ax.set_xlim([0, 10**5])\n",
    "    ax.set_ylim([10**-2, 10**5])\n",
    "    ax.set_title(NAMES[ncm])\n",
    "    ax.set_xlabel(\"Training set size\")\n",
    "    ax.set_ylabel(\"Average prediction time (s)\")\n",
    "    if i == 0:\n",
    "        ax.set_ylabel(\"Average prediction time (s)\")\n",
    "        ax.legend(title=\"\", loc=\"best\", frameon=True, labels=[\"Standard\", \"Optimized\", \"ICP\"])\n",
    "    else:\n",
    "        ax.set_ylabel(None)\n",
    "        plt.setp(ax.get_yticklabels(), visible=False)\n",
    "\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig(f\"training-size-comparison-all.pdf\", dpi=DPI)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "pressed-lease",
   "metadata": {},
   "source": [
    "Producing **Figure 5**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "reduced-extreme",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-07T11:52:05.882359Z",
     "start_time": "2021-06-07T11:52:02.069010Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 540x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axes = plt.subplots(1, 2, sharex=True,\n",
    "                         figsize=(7.5, 4))\n",
    "colors = sns.color_palette()\n",
    "NCMS = [\"SimplifiedKNN\", \"KNN\"]\n",
    "\n",
    "for i, (ax, ncm) in enumerate(zip(axes.flat, NCMS)):\n",
    "    plot_data = results[((results.ncm == ncm) | (results.ncm == ncm + \"_fast\")) &\n",
    "                        (results.inductive_cp == False)]\n",
    "\n",
    "    sns.lineplot(x=\"train_size\", y=\"avg_time\",\n",
    "                 data=plot_data[plot_data.ncm==ncm],\n",
    "                 ax=ax, legend=None, label=\"Standard CP\",\n",
    "                 color=colors[0])\n",
    "    sns.lineplot(x=\"train_size\", y=\"avg_time\",\n",
    "                 data=plot_data[plot_data.ncm==ncm+\"_fast\"],\n",
    "                 ax=ax, legend=None, label=\"Optimized CP\",\n",
    "                 color=colors[1])\n",
    "    \n",
    "    # ICP\n",
    "    plot_data = results[(results.ncm == ncm) &\n",
    "                        (results.inductive_cp == True) &\n",
    "                        (results.calibration_size == 0.5)]\n",
    "\n",
    "    sns.lineplot(x=\"train_size\", y=\"avg_time\", data=plot_data,\n",
    "                 ax=ax, legend=False, label=\"ICP\",\n",
    "                 color=colors[-3])\n",
    "\n",
    "    ax.lines[0].set_linestyle(\"--\")\n",
    "    ax.lines[2].set_linestyle(\":\")\n",
    "\n",
    "    ax.plot(range(10**5), [TIMEOUT]*10**5, color='k', ls=':')\n",
    "    ax.set_yscale(\"log\")\n",
    "    ax.xaxis.set_major_formatter(ticker.EngFormatter())\n",
    "    ax.grid()\n",
    "    ax.set_xlim([0, 10**5])\n",
    "    ax.set_ylim([10**-2, 10**5])\n",
    "    ax.set_title(NAMES[ncm])\n",
    "    ax.set_xlabel(\"Training set size\")\n",
    "    if i == 0:\n",
    "        ax.set_ylabel(\"Average prediction time (s)\")\n",
    "        ax.legend(title=\"\", loc=\"best\", frameon=True, labels=[\"Standard\", \"Optimized\", \"ICP\"])\n",
    "    else:\n",
    "        ax.set_ylabel(None)\n",
    "        plt.setp(ax.get_yticklabels(), visible=False)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig(f\"training-size-comparison-fullknn-all.pdf\", dpi=DPI)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "excellent-chain",
   "metadata": {},
   "source": [
    "# Training time of optimized CP\n",
    "\n",
    "We measure the training time of optimized nonconformity measures separately.\n",
    "This is used to produce **Figure 2**.\n",
    "\n",
    "## Experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "still-freight",
   "metadata": {},
   "outputs": [],
   "source": [
    "def timeit(foo, *args, **kwargs):\n",
    "    start = time.perf_counter()\n",
    "    res = foo(*args, **kwargs)\n",
    "    return time.perf_counter() - start, res\n",
    "\n",
    "def measure_training_time(ncm, n):\n",
    "    ncm = eval(ncm)()\n",
    "    X, Y = make_classification(n, 30, n_classes=2)\n",
    "\n",
    "    time, _ = timeit(ncm.train, X, Y)\n",
    "\n",
    "    return {\"training-time\": time}\n",
    "\n",
    "NCM_BASE = [\"NN\", \"SimplifiedKNN\", \"KNN\", \"RandomForest\", \"KDE\", \"LSSVM\"]\n",
    "NCM_FAST = [f\"{ncm}_fast\" for ncm in NCM_BASE]\n",
    "TRAIN_SIZE = np.logspace(1, 5, 13, dtype='int').tolist()\n",
    "\n",
    "eli = Eli(RESULTS_DIR)\n",
    "\n",
    "eli.run_experiment(exp_name=\"training-time\",\n",
    "                   func=measure_training_time,\n",
    "                   repetitions=5,\n",
    "                   n_jobs=1,\n",
    "                   automatic_seed=True,\n",
    "                   ncm=NCM_FAST,\n",
    "                   n=TRAIN_SIZE,\n",
    "                  )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "median-myrtle",
   "metadata": {},
   "source": [
    "## Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "suited-freedom",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-07T11:52:26.351213Z",
     "start_time": "2021-06-07T11:52:26.113104Z"
    }
   },
   "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>name</th>\n",
       "      <th>training-time</th>\n",
       "      <th>ncm</th>\n",
       "      <th>n</th>\n",
       "      <th>repetition</th>\n",
       "      <th>git-commit</th>\n",
       "      <th>started</th>\n",
       "      <th>finished</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>ncm=KDE_fast-n=10</td>\n",
       "      <td>0.000688</td>\n",
       "      <td>KDE_fast</td>\n",
       "      <td>10</td>\n",
       "      <td>0</td>\n",
       "      <td>429857c00ab0d3e8f1cdc09eba4fffc1c3f36348</td>\n",
       "      <td>2020-06-01T18:39:01.514476+00:00</td>\n",
       "      <td>2020-06-01T18:39:01.516808+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>ncm=KDE_fast-n=10</td>\n",
       "      <td>0.000634</td>\n",
       "      <td>KDE_fast</td>\n",
       "      <td>10</td>\n",
       "      <td>3</td>\n",
       "      <td>429857c00ab0d3e8f1cdc09eba4fffc1c3f36348</td>\n",
       "      <td>2020-06-01T18:39:01.592893+00:00</td>\n",
       "      <td>2020-06-01T18:39:01.594844+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>ncm=KDE_fast-n=10</td>\n",
       "      <td>0.000637</td>\n",
       "      <td>KDE_fast</td>\n",
       "      <td>10</td>\n",
       "      <td>4</td>\n",
       "      <td>429857c00ab0d3e8f1cdc09eba4fffc1c3f36348</td>\n",
       "      <td>2020-06-01T18:39:01.613110+00:00</td>\n",
       "      <td>2020-06-01T18:39:01.615095+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>ncm=KDE_fast-n=10</td>\n",
       "      <td>0.000624</td>\n",
       "      <td>KDE_fast</td>\n",
       "      <td>10</td>\n",
       "      <td>2</td>\n",
       "      <td>429857c00ab0d3e8f1cdc09eba4fffc1c3f36348</td>\n",
       "      <td>2020-06-01T18:39:01.569596+00:00</td>\n",
       "      <td>2020-06-01T18:39:01.571471+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>ncm=KDE_fast-n=10</td>\n",
       "      <td>0.000733</td>\n",
       "      <td>KDE_fast</td>\n",
       "      <td>10</td>\n",
       "      <td>1</td>\n",
       "      <td>429857c00ab0d3e8f1cdc09eba4fffc1c3f36348</td>\n",
       "      <td>2020-06-01T18:39:01.541619+00:00</td>\n",
       "      <td>2020-06-01T18:39:01.543809+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                name  training-time       ncm   n  repetition  \\\n",
       "0  ncm=KDE_fast-n=10       0.000688  KDE_fast  10           0   \n",
       "1  ncm=KDE_fast-n=10       0.000634  KDE_fast  10           3   \n",
       "2  ncm=KDE_fast-n=10       0.000637  KDE_fast  10           4   \n",
       "3  ncm=KDE_fast-n=10       0.000624  KDE_fast  10           2   \n",
       "4  ncm=KDE_fast-n=10       0.000733  KDE_fast  10           1   \n",
       "\n",
       "                                 git-commit                           started  \\\n",
       "0  429857c00ab0d3e8f1cdc09eba4fffc1c3f36348  2020-06-01T18:39:01.514476+00:00   \n",
       "1  429857c00ab0d3e8f1cdc09eba4fffc1c3f36348  2020-06-01T18:39:01.592893+00:00   \n",
       "2  429857c00ab0d3e8f1cdc09eba4fffc1c3f36348  2020-06-01T18:39:01.613110+00:00   \n",
       "3  429857c00ab0d3e8f1cdc09eba4fffc1c3f36348  2020-06-01T18:39:01.569596+00:00   \n",
       "4  429857c00ab0d3e8f1cdc09eba4fffc1c3f36348  2020-06-01T18:39:01.541619+00:00   \n",
       "\n",
       "                           finished  \n",
       "0  2020-06-01T18:39:01.516808+00:00  \n",
       "1  2020-06-01T18:39:01.594844+00:00  \n",
       "2  2020-06-01T18:39:01.615095+00:00  \n",
       "3  2020-06-01T18:39:01.571471+00:00  \n",
       "4  2020-06-01T18:39:01.543809+00:00  "
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eli = Eli(RESULTS_DIR)\n",
    "results = eli.fetch_results(\"training-time\")\n",
    "results.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "democratic-oxford",
   "metadata": {},
   "source": [
    "Producing **Figure 2**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "duplicate-juvenile",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-07T11:52:33.695986Z",
     "start_time": "2021-06-07T11:52:29.869717Z"
    },
    "tags": [
     "plots"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 324x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "NAMES = {\"SimplifiedKNN\": \"Simplified k-NN\",\n",
    "         \"KNN\": \"k-NN\",\n",
    "         \"LSSVM\": \"LS-SVM\",\n",
    "         \"KDE\": \"KDE\",\n",
    "         \"RandomForest\": \"Random Forest\",\n",
    "        }\n",
    "NCM_SORTED = [\"LSSVM\", \"KNN\", \"SimplifiedKNN\", \"KDE\", \"RandomForest\"]\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(4.5, 4))\n",
    "\n",
    "plot_data = results\n",
    "\n",
    "# Sort labels\n",
    "plot_data.ncm = [ncm.replace(\"_fast\", \"\") for ncm in plot_data.ncm]\n",
    "plot_data.ncm = pd.Categorical(plot_data.ncm, NCM_SORTED)\n",
    "plot_data = plot_data.sort_values(\"ncm\")\n",
    "\n",
    "# Replace with nice names\n",
    "plot_data.ncm = plot_data.ncm.apply(lambda ncm: NAMES[ncm])\n",
    "\n",
    "g = sns.lineplot(x=\"n\", y=\"training-time\", data=plot_data,\n",
    "             hue=\"ncm\", style=\"ncm\", ax=ax)\n",
    "\n",
    "# Remove legend title.\n",
    "g.legend_.set_title(None)\n",
    "g.legend_.set_frame_on(True)\n",
    "\n",
    "ax.set_yscale(\"log\")\n",
    "ax.set_xlim([0, 10**5])\n",
    "ax.set_ylim([10**-2, 10**5])\n",
    "ax.xaxis.set_major_formatter(ticker.EngFormatter())\n",
    "ax.set_xlabel(\"Training set size\")\n",
    "ax.set_ylabel(\"Training time (s)\")\n",
    "ax.grid()\n",
    "\n",
    "fig.tight_layout()\n",
    "\n",
    "plt.savefig(\"training-time.pdf\", dpi=DPI)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "twelve-dimension",
   "metadata": {},
   "source": [
    "# Multiprocessing comparison\n",
    "\n",
    "We measure whether it's best to use multiprocessing or not, both\n",
    "with CP and ICP, with optimized and unoptimized nonconformity measures.\n",
    "\n",
    "## Experiments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "floppy-craps",
   "metadata": {
    "code_folding": [
     0,
     6,
     12,
     18
    ],
    "tags": [
     "experiment:to-parallel"
    ]
   },
   "outputs": [],
   "source": [
    "def generic1000():\n",
    "    X, Y = make_classification(1000, 30, n_classes=2)\n",
    "    Xtrain, Xtest, Ytrain, Ytest = train_test_split(X, Y, train_size=0.7)\n",
    "    \n",
    "    return Xtrain, Ytrain, Xtest, Ytest, \"classification\"\n",
    "\n",
    "def generic100000():\n",
    "    X, Y = make_classification(100000, 30, n_classes=2)\n",
    "    Xtrain, Xtest, Ytrain, Ytest = train_test_split(X, Y, train_size=0.7)\n",
    "    \n",
    "    return Xtrain, Ytrain, Xtest, Ytest, \"classification\"\n",
    "\n",
    "LOAD_DATASET = dict(\n",
    "    generic1000=generic1000,\n",
    "    generic100000=generic100000,\n",
    ")\n",
    "\n",
    "\n",
    "def timeit(foo, *args, **kwargs):\n",
    "    start = time.perf_counter()\n",
    "    foo(*args, **kwargs)\n",
    "    return time.perf_counter() - start\n",
    "\n",
    "def cp_classification(ncm, dataset, parallel=False):\n",
    "    # Load NCM.\n",
    "    ncm_class = eval(ncm)       # eval: Perdoname, madre, por mi vida loca :D\n",
    "    ncm = ncm_class()\n",
    "\n",
    "    # Load data.\n",
    "    Xtrain, Ytrain, Xtest, Ytest, task = LOAD_DATASET[dataset]()\n",
    "    if task == \"classification\":\n",
    "        labels = set(Ytrain) | set(Ytest)\n",
    "    else:\n",
    "        raise Exception(f\"Task {task} undefined.\")\n",
    "\n",
    "    func = cp_predict_parallel if parallel else cp_predict\n",
    "    pvalues = func(Xtrain, Ytrain, Xtest, labels, ncm=ncm)\n",
    "\n",
    "\n",
    "def time_methods(ncm, dataset):\n",
    "    return {\"CP\": timeit(cp_classification, ncm, dataset, parallel=False),\n",
    "            \"CP Parallel\": timeit(cp_classification, ncm, dataset, parallel=True),\n",
    "           }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dominican-viking",
   "metadata": {},
   "outputs": [],
   "source": [
    "NCMs = [\"NN\", \"LSSVM\", \"SimplifiedKNN\", \"KNN\", \"KDE\", \"RandomForest\"]\n",
    "NCMs += [x + \"_fast\" for x in NCMs]\n",
    "\n",
    "eli = Eli(RESULTS_DIR)\n",
    "\n",
    "# First run for all with a dataset of 1k examples\n",
    "eli.run_experiment(exp_name=\"to-parallel-or-not\",\n",
    "                   func=time_methods,\n",
    "                   repetitions=1,\n",
    "                   n_jobs=1,\n",
    "                   automatic_seed=True,\n",
    "                   # Parameters\n",
    "                   dataset=\"generic1000\",\n",
    "                   ncm=NCMs,\n",
    "                  )\n",
    "\n",
    "# Run just for optimized k-NN for a dataset of 100k examples\n",
    "eli.run_experiment(exp_name=\"to-parallel-or-not\",\n",
    "                   func=time_methods,\n",
    "                   repetitions=1,\n",
    "                   n_jobs=1,\n",
    "                   automatic_seed=True,\n",
    "                   # Parameters\n",
    "                   dataset=\"generic100000\",\n",
    "                   ncm=\"KNN_fast\",\n",
    "                  )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "choice-violin",
   "metadata": {},
   "source": [
    "## Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "declared-villa",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-07T11:52:39.565142Z",
     "start_time": "2021-06-07T11:52:39.402653Z"
    },
    "tags": [
     "plots"
    ]
   },
   "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>name</th>\n",
       "      <th>CP</th>\n",
       "      <th>CP Parallel</th>\n",
       "      <th>ICP</th>\n",
       "      <th>ICP Parallel</th>\n",
       "      <th>dataset</th>\n",
       "      <th>ncm</th>\n",
       "      <th>repetition</th>\n",
       "      <th>git-commit</th>\n",
       "      <th>started</th>\n",
       "      <th>finished</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>dataset=generic500-ncm=KNN</td>\n",
       "      <td>15.836166</td>\n",
       "      <td>0.951336</td>\n",
       "      <td>0.235575</td>\n",
       "      <td>0.527536</td>\n",
       "      <td>generic500</td>\n",
       "      <td>KNN</td>\n",
       "      <td>0</td>\n",
       "      <td>adbfbe95d569eec31a71f654d35af9279216b4df</td>\n",
       "      <td>2020-05-27T14:54:25.325975+00:00</td>\n",
       "      <td>2020-05-27T14:54:42.876824+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>dataset=generic500-ncm=KNN</td>\n",
       "      <td>15.370247</td>\n",
       "      <td>0.955251</td>\n",
       "      <td>0.241041</td>\n",
       "      <td>0.563496</td>\n",
       "      <td>generic500</td>\n",
       "      <td>KNN</td>\n",
       "      <td>3</td>\n",
       "      <td>adbfbe95d569eec31a71f654d35af9279216b4df</td>\n",
       "      <td>2020-05-27T14:55:18.907586+00:00</td>\n",
       "      <td>2020-05-27T14:55:36.037856+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>dataset=generic500-ncm=KNN</td>\n",
       "      <td>15.411377</td>\n",
       "      <td>0.943102</td>\n",
       "      <td>0.235843</td>\n",
       "      <td>0.521436</td>\n",
       "      <td>generic500</td>\n",
       "      <td>KNN</td>\n",
       "      <td>4</td>\n",
       "      <td>adbfbe95d569eec31a71f654d35af9279216b4df</td>\n",
       "      <td>2020-05-27T14:55:36.066316+00:00</td>\n",
       "      <td>2020-05-27T14:55:53.178292+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>dataset=generic500-ncm=KNN</td>\n",
       "      <td>17.060600</td>\n",
       "      <td>0.954220</td>\n",
       "      <td>0.238130</td>\n",
       "      <td>0.544712</td>\n",
       "      <td>generic500</td>\n",
       "      <td>KNN</td>\n",
       "      <td>2</td>\n",
       "      <td>adbfbe95d569eec31a71f654d35af9279216b4df</td>\n",
       "      <td>2020-05-27T14:55:00.081821+00:00</td>\n",
       "      <td>2020-05-27T14:55:18.880108+00:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>dataset=generic500-ncm=KNN</td>\n",
       "      <td>15.231931</td>\n",
       "      <td>1.062567</td>\n",
       "      <td>0.277911</td>\n",
       "      <td>0.576440</td>\n",
       "      <td>generic500</td>\n",
       "      <td>KNN</td>\n",
       "      <td>1</td>\n",
       "      <td>adbfbe95d569eec31a71f654d35af9279216b4df</td>\n",
       "      <td>2020-05-27T14:54:42.906576+00:00</td>\n",
       "      <td>2020-05-27T14:55:00.055732+00:00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                         name         CP  CP Parallel       ICP  ICP Parallel  \\\n",
       "0  dataset=generic500-ncm=KNN  15.836166     0.951336  0.235575      0.527536   \n",
       "1  dataset=generic500-ncm=KNN  15.370247     0.955251  0.241041      0.563496   \n",
       "2  dataset=generic500-ncm=KNN  15.411377     0.943102  0.235843      0.521436   \n",
       "3  dataset=generic500-ncm=KNN  17.060600     0.954220  0.238130      0.544712   \n",
       "4  dataset=generic500-ncm=KNN  15.231931     1.062567  0.277911      0.576440   \n",
       "\n",
       "      dataset  ncm  repetition                                git-commit  \\\n",
       "0  generic500  KNN           0  adbfbe95d569eec31a71f654d35af9279216b4df   \n",
       "1  generic500  KNN           3  adbfbe95d569eec31a71f654d35af9279216b4df   \n",
       "2  generic500  KNN           4  adbfbe95d569eec31a71f654d35af9279216b4df   \n",
       "3  generic500  KNN           2  adbfbe95d569eec31a71f654d35af9279216b4df   \n",
       "4  generic500  KNN           1  adbfbe95d569eec31a71f654d35af9279216b4df   \n",
       "\n",
       "                            started                          finished  \n",
       "0  2020-05-27T14:54:25.325975+00:00  2020-05-27T14:54:42.876824+00:00  \n",
       "1  2020-05-27T14:55:18.907586+00:00  2020-05-27T14:55:36.037856+00:00  \n",
       "2  2020-05-27T14:55:36.066316+00:00  2020-05-27T14:55:53.178292+00:00  \n",
       "3  2020-05-27T14:55:00.081821+00:00  2020-05-27T14:55:18.880108+00:00  \n",
       "4  2020-05-27T14:54:42.906576+00:00  2020-05-27T14:55:00.055732+00:00  "
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eli = Eli(RESULTS_DIR)\n",
    "results = eli.fetch_results(\"to-parallel-or-not\")\n",
    "\n",
    "results.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "devoted-lafayette",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-03T16:55:34.232157Z",
     "start_time": "2021-06-03T16:55:34.080316Z"
    },
    "code_folding": [
     0
    ],
    "tags": [
     "plots"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "generic1000\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<style  type=\"text/css\" >\n",
       "    #T_8348901a_c48c_11eb_927a_00163e5e6c00row0_col1 {\n",
       "            background-color:  darkorange;\n",
       "        }    #T_8348901a_c48c_11eb_927a_00163e5e6c00row1_col1 {\n",
       "            background-color:  darkorange;\n",
       "        }    #T_8348901a_c48c_11eb_927a_00163e5e6c00row2_col1 {\n",
       "            background-color:  darkorange;\n",
       "        }    #T_8348901a_c48c_11eb_927a_00163e5e6c00row3_col1 {\n",
       "            background-color:  darkorange;\n",
       "        }    #T_8348901a_c48c_11eb_927a_00163e5e6c00row4_col1 {\n",
       "            background-color:  darkorange;\n",
       "        }    #T_8348901a_c48c_11eb_927a_00163e5e6c00row5_col1 {\n",
       "            background-color:  darkorange;\n",
       "        }    #T_8348901a_c48c_11eb_927a_00163e5e6c00row6_col0 {\n",
       "            background-color:  darkorange;\n",
       "        }    #T_8348901a_c48c_11eb_927a_00163e5e6c00row7_col1 {\n",
       "            background-color:  darkorange;\n",
       "        }    #T_8348901a_c48c_11eb_927a_00163e5e6c00row8_col0 {\n",
       "            background-color:  darkorange;\n",
       "        }    #T_8348901a_c48c_11eb_927a_00163e5e6c00row9_col1 {\n",
       "            background-color:  darkorange;\n",
       "        }    #T_8348901a_c48c_11eb_927a_00163e5e6c00row10_col1 {\n",
       "            background-color:  darkorange;\n",
       "        }    #T_8348901a_c48c_11eb_927a_00163e5e6c00row11_col1 {\n",
       "            background-color:  darkorange;\n",
       "        }</style><table id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00\" ><thead>    <tr>        <th class=\"blank level0\" ></th>        <th class=\"col_heading level0 col0\" >CP</th>        <th class=\"col_heading level0 col1\" >CP Parallel</th>    </tr>    <tr>        <th class=\"index_name level0\" >NCM</th>        <th class=\"blank\" ></th>        <th class=\"blank\" ></th>    </tr></thead><tbody>\n",
       "                <tr>\n",
       "                        <th id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00level0_row0\" class=\"row_heading level0 row0\" >NN</th>\n",
       "                        <td id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00row0_col0\" class=\"data row0 col0\" >75.038471</td>\n",
       "                        <td id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00row0_col1\" class=\"data row0 col1\" >4.041478</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00level0_row1\" class=\"row_heading level0 row1\" >SimplifiedKNN</th>\n",
       "                        <td id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00row1_col0\" class=\"data row1 col0\" >74.595183</td>\n",
       "                        <td id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00row1_col1\" class=\"data row1 col1\" >3.945033</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00level0_row2\" class=\"row_heading level0 row2\" >KNN</th>\n",
       "                        <td id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00row2_col0\" class=\"data row2 col0\" >82.144661</td>\n",
       "                        <td id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00row2_col1\" class=\"data row2 col1\" >4.110659</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00level0_row3\" class=\"row_heading level0 row3\" >KDE</th>\n",
       "                        <td id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00row3_col0\" class=\"data row3 col0\" >138.483183</td>\n",
       "                        <td id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00row3_col1\" class=\"data row3 col1\" >6.661167</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00level0_row4\" class=\"row_heading level0 row4\" >LSSVM</th>\n",
       "                        <td id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00row4_col0\" class=\"data row4 col0\" >8852.179454</td>\n",
       "                        <td id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00row4_col1\" class=\"data row4 col1\" >624.744138</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00level0_row5\" class=\"row_heading level0 row5\" >RandomForest</th>\n",
       "                        <td id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00row5_col0\" class=\"data row5 col0\" >5061.670597</td>\n",
       "                        <td id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00row5_col1\" class=\"data row5 col1\" >225.752851</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00level0_row6\" class=\"row_heading level0 row6\" >NN_fast</th>\n",
       "                        <td id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00row6_col0\" class=\"data row6 col0\" >1.404174</td>\n",
       "                        <td id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00row6_col1\" class=\"data row6 col1\" >1.466071</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00level0_row7\" class=\"row_heading level0 row7\" >SimplifiedKNN_fast</th>\n",
       "                        <td id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00row7_col0\" class=\"data row7 col0\" >1.294473</td>\n",
       "                        <td id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00row7_col1\" class=\"data row7 col1\" >0.432346</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00level0_row8\" class=\"row_heading level0 row8\" >KNN_fast</th>\n",
       "                        <td id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00row8_col0\" class=\"data row8 col0\" >1.604430</td>\n",
       "                        <td id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00row8_col1\" class=\"data row8 col1\" >9.041655</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00level0_row9\" class=\"row_heading level0 row9\" >KDE_fast</th>\n",
       "                        <td id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00row9_col0\" class=\"data row9 col0\" >1.349043</td>\n",
       "                        <td id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00row9_col1\" class=\"data row9 col1\" >0.406260</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00level0_row10\" class=\"row_heading level0 row10\" >LSSVM_fast</th>\n",
       "                        <td id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00row10_col0\" class=\"data row10 col0\" >8.469933</td>\n",
       "                        <td id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00row10_col1\" class=\"data row10 col1\" >0.757119</td>\n",
       "            </tr>\n",
       "            <tr>\n",
       "                        <th id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00level0_row11\" class=\"row_heading level0 row11\" >RandomForest_fast</th>\n",
       "                        <td id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00row11_col0\" class=\"data row11 col0\" >2409.592761</td>\n",
       "                        <td id=\"T_8348901a_c48c_11eb_927a_00163e5e6c00row11_col1\" class=\"data row11 col1\" >110.321268</td>\n",
       "            </tr>\n",
       "    </tbody></table>"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x758c3cc55d30>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "generic100000\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<style  type=\"text/css\" >\n",
       "    #T_834d1612_c48c_11eb_927a_00163e5e6c00row0_col1 {\n",
       "            background-color:  darkorange;\n",
       "        }</style><table id=\"T_834d1612_c48c_11eb_927a_00163e5e6c00\" ><thead>    <tr>        <th class=\"blank level0\" ></th>        <th class=\"col_heading level0 col0\" >CP</th>        <th class=\"col_heading level0 col1\" >CP Parallel</th>    </tr>    <tr>        <th class=\"index_name level0\" >NCM</th>        <th class=\"blank\" ></th>        <th class=\"blank\" ></th>    </tr></thead><tbody>\n",
       "                <tr>\n",
       "                        <th id=\"T_834d1612_c48c_11eb_927a_00163e5e6c00level0_row0\" class=\"row_heading level0 row0\" >KNN_fast</th>\n",
       "                        <td id=\"T_834d1612_c48c_11eb_927a_00163e5e6c00row0_col0\" class=\"data row0 col0\" >12742.034330</td>\n",
       "                        <td id=\"T_834d1612_c48c_11eb_927a_00163e5e6c00row0_col1\" class=\"data row0 col1\" >3918.190429</td>\n",
       "            </tr>\n",
       "    </tbody></table>"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x758c3c6e59e8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def highlight_min(data, color='yellow'):\n",
    "    '''\n",
    "    highlight the minimum in a Series or DataFrame\n",
    "    '''\n",
    "    attr = 'background-color: {}'.format(color)\n",
    "    if data.ndim == 1:  # Series from .apply(axis=0) or axis=1\n",
    "        is_min = data == data.min()\n",
    "        return [attr if v else '' for v in is_min]\n",
    "    else:  # from .apply(axis=None)\n",
    "        is_min = data == data.min().min()\n",
    "        return pd.DataFrame(np.where(is_min, attr, ''),\n",
    "                            index=data.index, columns=data.columns)\n",
    "\n",
    "\n",
    "NCMs = [\"NN\", \"SimplifiedKNN\", \"KNN\", \"KDE\", \"LSSVM\", \"RandomForest\"]\n",
    "NCMs = NCMs + [f\"{ncm}_fast\" for ncm in NCMs]\n",
    "\n",
    "for dataset in [\"generic1000\", \"generic100000\"]:\n",
    "    # Prepare data\n",
    "    print(dataset)\n",
    "    table_results = results[results.dataset==dataset]\n",
    "\n",
    "    table_results = {\n",
    "        \"CP\": table_results.groupby(\"ncm\")[\"CP\"].mean(),\n",
    "        \"CP-std\": table_results.groupby(\"ncm\")[\"CP\"].std(),\n",
    "        \"CP Parallel\": table_results.groupby(\"ncm\")[\"CP Parallel\"].mean(),\n",
    "        \"CP Parallel-std\": table_results.groupby(\"ncm\")[\"CP Parallel\"].std(),\n",
    "    }\n",
    "    table_results = pd.DataFrame(table_results)\n",
    "    table_results.index = pd.Categorical(table_results.index, NCMs)\n",
    "    table_results = table_results.sort_index()\n",
    "\n",
    "    # Nice table on jupyter\n",
    "    table = table_results[[\"CP\", \"CP Parallel\"]]\n",
    "    table.index.name = \"NCM\"\n",
    "    display(table.style.apply(highlight_min,\n",
    "                      color='darkorange',\n",
    "                      axis=1, subset=[\"CP\", \"CP Parallel\"]\n",
    "                     ))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eligible-rwanda",
   "metadata": {},
   "source": [
    "# k-NN CP regression"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "portuguese-accordance",
   "metadata": {},
   "source": [
    "Fix a distance $d$. Let $y_{(j)}$ be the label of the $j$-th closest\n",
    "object ($x_{(j)}$) to example $(x, y)$.\n",
    "\n",
    "$$A((x, y); \\{(x_1, y_1), ..., (x_{n}, y_{n})\\}) =\n",
    "    |y-\\frac{1}{k}\\sum_{j=1}^k y_{(j)}|,$$\n",
    "    \n",
    "where the term $\\frac{1}{k}\\sum_{j=1}^k y_{(j)}$ is the k-NN regressor's prediction for $y$."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "looking-singer",
   "metadata": {},
   "source": [
    "## Base implementations\n",
    "\n",
    "### Full CP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "adaptive-account",
   "metadata": {
    "code_folding": [
     37
    ]
   },
   "outputs": [],
   "source": [
    "class KNNR_CP:\n",
    "    def __init__(self, k):\n",
    "        self.k = k\n",
    "\n",
    "    def train(self, Xtrain, Ytrain):\n",
    "        self.Xtrain = Xtrain\n",
    "        self.Ytrain = Ytrain\n",
    "\n",
    "    def compute_sets(self, x):\n",
    "        # First compute a and b for (x, y).\n",
    "        dist = euclidean_distances([x], self.Xtrain).flatten()\n",
    "        best_idx = best_k_idx(dist, self.k)\n",
    "        a_x = -sum(self.Ytrain[best_idx]) / len(best_idx)\n",
    "        b_x = 1\n",
    "\n",
    "        # Compute the remaining a and b, and construct P and S.\n",
    "        P = []\n",
    "        S = []\n",
    "        for i, (xi, yi) in enumerate(zip(self.Xtrain, self.Ytrain)):\n",
    "            idx = np.array(list(range(len(self.Xtrain))))\n",
    "            dist = euclidean_distances([xi], np.row_stack(([x], self.Xtrain[idx!=i,:]))).flatten()\n",
    "            Ytmp = np.concatenate(([0], self.Ytrain[idx!=i]))\n",
    "            best_idx = best_k_idx(dist, self.k)\n",
    "            # If (x, y) is one of the k-NNs.\n",
    "            w = 1./self.k\n",
    "            ai = yi - w*sum(Ytmp[best_idx])\n",
    "            if 0 in best_idx:\n",
    "                bi = -w\n",
    "            else:\n",
    "                bi = 0\n",
    "            \n",
    "            s, P = self._compute_set(ai, bi, a_x, b_x, P)\n",
    "            S.append(s)\n",
    "            \n",
    "        \n",
    "        return P, S\n",
    "    \n",
    "    def _compute_set(self, ai, bi, a_x, b_x, P):\n",
    "        if bi < 0:\n",
    "            ai = -ai\n",
    "            bi = -bi\n",
    "\n",
    "        if b_x > bi:\n",
    "            p1 = -(ai-a_x)/(bi-b_x)\n",
    "            p2 = -(ai+a_x)/(bi+b_x)\n",
    "            if p1 == p2:\n",
    "                s = {\"type\": \"point\",\n",
    "                     #\"points\": interval([p1, p1]),\n",
    "                     \"j\": (len(P)),\n",
    "                    }\n",
    "                P += [p1]\n",
    "            else:\n",
    "                s = {\"type\": \"interval\",\n",
    "                     #\"points\": interval([p1, p2]),\n",
    "                     \"j\": (len(P), len(P)+1),\n",
    "                    }\n",
    "                P += [p1, p2]\n",
    "        elif b_x < bi:\n",
    "            p1 = -(ai-a_x)/(bi-b_x)\n",
    "            p2 = -(ai+a_x)/(bi+b_x)\n",
    "            s = {\"type\": \"union\",\n",
    "                 #\"points\": interval([-np.inf, p1], [p2, np.inf]),\n",
    "                 \"j\": (len(P), len(P)+1),\n",
    "                }\n",
    "            P += [p1, p2]\n",
    "            counter += 2\n",
    "        elif a_x < ai:\n",
    "            p = -(ai+a_x)/(2*bi)\n",
    "            {\"type\": \"right-ray\",\n",
    "             #\"points\": interval([p, np.inf]),\n",
    "             \"j\": len(P),\n",
    "            }\n",
    "            P.append(p)\n",
    "        elif a_x > ai:\n",
    "            p = -(ai+a_x)/(2*bi)\n",
    "            s = {\"type\": \"left-ray\",\n",
    "                 #\"points\": interval([-np.inf, p]),\n",
    "                 \"j\": len(P),\n",
    "                }\n",
    "            P.append(p)\n",
    "        elif abs(a_x) <= abs(ai):\n",
    "            s = {\"type\": \"line\",\n",
    "                 #\"points\": interval([-np.inf, np.inf]),\n",
    "                }\n",
    "        elif abs(a_x) > abs(ai):\n",
    "            s = {\"type\": \"empty\",\n",
    "                 #\"points\": None,\n",
    "                }\n",
    "        else:\n",
    "            raise Exception(\"Unhandled! Shouldn't happen.\")\n",
    "        \n",
    "        return s, P\n",
    "    \n",
    "    def predict(self, x, epsilon):\n",
    "        P, S = self.compute_sets(x)\n",
    "        # Sort P, and create a dict to map to associate\n",
    "        # points in the sets S[i] to points in (sorted) P.\n",
    "        P, K = zip(*sorted(zip(P, range(len(P)))))\n",
    "        # Note: the range() is shifted by 1 because we need\n",
    "        # to add -infinity to the beginning of P.\n",
    "        S_to_P = dict(zip(K, range(1, len(P)+1)))\n",
    "        \n",
    "        P = [-np.infty] + list(P) + [np.infty]\n",
    "        m = len(P) - 2\n",
    "        N = np.zeros(m+1)\n",
    "        M = np.zeros(m)\n",
    "        \n",
    "        for i in range(len(self.Xtrain)):\n",
    "            if S[i][\"type\"] == \"empty\":\n",
    "                pass\n",
    "            elif S[i][\"type\"] == \"point\":\n",
    "                j = S[i][\"j\"]\n",
    "                j = S_to_P[j]\n",
    "                M[j-1] +=1\n",
    "            elif S[i][\"type\"] == \"interval\":\n",
    "                j1, j2 = S[i][\"j\"]\n",
    "                j1, j2 = S_to_P[j1], S_to_P[j2]\n",
    "                j1, j2 = (j1, j2) if j1 < j2 else (j2, j1)\n",
    "                M[j1-1:j2] += 1\n",
    "                N[j1:j2] += 1\n",
    "            elif S[i][\"type\"] == \"right-ray\":\n",
    "                j = S[i][\"j\"]\n",
    "                j = S_to_P[j]\n",
    "                M[j-1:] += 1\n",
    "                N[j:] += 1\n",
    "            elif S[i][\"type\"] == \"left-ray\":\n",
    "                j = S[i][\"j\"]\n",
    "                j = S_to_P[j]\n",
    "                M[j-1:] += 1\n",
    "                N[j:] += 1\n",
    "            elif S[i][\"type\"] == \"union\":\n",
    "                j1, j2 = S[i][\"j\"]\n",
    "                j1, j2 = S_to_P[j1], S_to_P[j2]\n",
    "                j1, j2 = (j1, j2) if j1 < j2 else (j2, j1)\n",
    "                M[:j1-1] += 1\n",
    "                M[j2-1:] += 1\n",
    "                N[:j1-1] += 1\n",
    "                N[j2:] += 1\n",
    "            elif S[i][\"type\"] == \"line\":\n",
    "                M += 1\n",
    "                N += 1\n",
    "            else:\n",
    "                raise Exception(\"Unhandled! Shouldn't happen.\")\n",
    "\n",
    "        # Union of intervals.\n",
    "        ints = []\n",
    "        for j in range(len(N)):\n",
    "            if (N[j] / (len(self.Xtrain)+1.)) > epsilon:\n",
    "                ints.append([P[j], P[j+1]])\n",
    "        \n",
    "        # Exact solution:\n",
    "        #for j in range(len(M)):\n",
    "        #    if (M[j] / (len(self.Xtrain)+1.)) > epsilon:\n",
    "        #        ints.append([P[j], P[j]])\n",
    "\n",
    "        pred = interval(*ints)\n",
    "\n",
    "        return pred"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "collaborative-mercy",
   "metadata": {},
   "source": [
    "### Full CP Optimized"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "foreign-sucking",
   "metadata": {},
   "outputs": [],
   "source": [
    "def chunked_euclidean_distances(X, working_memory=2**14):\n",
    "    for chunk in pairwise_distances_chunked(X, working_memory=working_memory):\n",
    "        for dist in chunk:\n",
    "            yield dist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "lyric-fourth",
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "class KNNR_CP_fast(KNNR_CP):\n",
    "    def __init__(self, k):\n",
    "        self.k = k\n",
    "\n",
    "    def train(self, Xtrain, Ytrain):\n",
    "        self.Xtrain = Xtrain\n",
    "        self.Ytrain = Ytrain\n",
    "        \n",
    "        # Precomputations.\n",
    "        A = []\n",
    "        D = []\n",
    "        Y_max = []\n",
    "        \n",
    "        all_dists = chunked_euclidean_distances(Xtrain)\n",
    "\n",
    "        for i, (dist, yi) in enumerate(zip(all_dists, Ytrain)):\n",
    "            dist = np.delete(dist, i)\n",
    "            Ytmp = np.delete(Ytrain, i)\n",
    "            best_idx = best_k_idx(dist, self.k)\n",
    "\n",
    "            # These \"ai\" don't account for the contribution of the test example.\n",
    "            w = 1./self.k\n",
    "            ai = yi - w*sum(Ytmp[best_idx])\n",
    "            A.append(ai)\n",
    "\n",
    "            # Keep track of largest distance (and label), in preparation for updates.\n",
    "            idx = np.argmax(dist[best_idx])\n",
    "            D.append(dist[best_idx][idx])\n",
    "            Y_max.append(Ytmp[best_idx][idx])\n",
    "\n",
    "        \n",
    "        self.A = A\n",
    "        self.D = D\n",
    "        self.Y_max = Y_max\n",
    "\n",
    "    def compute_sets(self, x):\n",
    "        # First compute a and b for (x, y).\n",
    "        dist = euclidean_distances([x], self.Xtrain).flatten()\n",
    "        best_idx = best_k_idx(dist, self.k)\n",
    "        a_x = -sum(self.Ytrain[best_idx]) / len(best_idx)\n",
    "        b_x = 1\n",
    "        w = 1./self.k\n",
    "\n",
    "        # Update the remaining a and b, and construct P.\n",
    "        P = []\n",
    "        S = []\n",
    "        for d_x, ai, di, y_max in zip(dist, self.A, self.D, self.Y_max):\n",
    "            # Check if (x, y) is one of the k-NNs.\n",
    "            if d_x < di:\n",
    "                # Remove contribution of y_max (which isn't a k-NN anymore).\n",
    "                # NOTE: as per algorithm, there's no need to add the contribution of y to ai.\n",
    "                ai += w*y_max\n",
    "                # Update bi.\n",
    "                bi = -w\n",
    "            else:\n",
    "                bi = 0\n",
    "            \n",
    "            if bi < 0:\n",
    "                ai = -ai\n",
    "                bi = -bi\n",
    "            \n",
    "            s, P = self._compute_set(ai, bi, a_x, b_x, P)\n",
    "            S.append(s)\n",
    "        \n",
    "        return P, S"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "jewish-stylus",
   "metadata": {},
   "source": [
    "### Unit tests for regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "extended-cursor",
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "class KNNRTests(unittest.TestCase):\n",
    "    \n",
    "    def setUp(self):    \n",
    "        np.random.seed(0)\n",
    "        X, Y = make_regression (200)\n",
    "        \n",
    "        self.Xtrain, self.Xtest, self.Ytrain, self.Ytest = train_test_split(X, Y, test_size=100)\n",
    "    \n",
    "    @parameterized.expand([\n",
    "        [KNNR_CP(5), KNNR_CP_fast(5)],\n",
    "    ])\n",
    "    def test_equivalent(self, cp_a, cp_b, rtol=1e-07):\n",
    "        \"\"\"Are standard and optimized ncms equivalent?\n",
    "        \"\"\"\n",
    "        print(f\"Testing: {cp_a.__class__.__name__}, {cp_b.__class__.__name__}\")\n",
    "        \n",
    "        eps = 0.1\n",
    "        \n",
    "        cp_a.train(self.Xtrain, self.Ytrain)\n",
    "        cp_b.train(self.Xtrain, self.Ytrain)\n",
    "\n",
    "        for x, y in zip(self.Xtest, self.Ytest):            \n",
    "            pred_a = cp_a.predict(x, eps)\n",
    "            pred_b = cp_b.predict(x, eps)\n",
    "            np.testing.assert_allclose(pred_a, pred_b, rtol=rtol)\n",
    "\n",
    "\n",
    "suite = unittest.defaultTestLoader.loadTestsFromTestCase(KNNRTests)\n",
    "_ = unittest.TextTestRunner().run(suite)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "familiar-strategy",
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "def knn_cp_regressor_predict(Xtrain, Ytrain, Xtest, Ytest, k, epsilon, fast=True,\n",
    "                             return_time=False, timeout=None):\n",
    "    \n",
    "    if fast:\n",
    "        cp = KNNR_CP_fast(k)\n",
    "    else:\n",
    "        cp = KNNR_CP(k)\n",
    "\n",
    "    # Train nonconformity measure\n",
    "    start = time.perf_counter()\n",
    "    cp.train(Xtrain, Ytrain)\n",
    "    train_time = time.perf_counter() - start\n",
    "\n",
    "    # Compute predictions\n",
    "    start = time.perf_counter()\n",
    "    prediction_times = []\n",
    "    reached_timeout = False\n",
    "\n",
    "    preds = []\n",
    "    \n",
    "    for x, y in zip(Xtest, Ytest):\n",
    "        pred = cp.predict(x, epsilon)\n",
    "        preds.append(pred)\n",
    "\n",
    "        # Store time\n",
    "        t = time.perf_counter() - start\n",
    "        prediction_times.append(t)\n",
    "        \n",
    "        # Check if reached timeout\n",
    "        if timeout and t > timeout:\n",
    "            reached_timeout = True\n",
    "            break\n",
    "    \n",
    "    if return_time:\n",
    "        return np.array(preds), {\"training_time\": train_time,\n",
    "                                 \"prediction_time\": prediction_times,\n",
    "                                 \"reached_timeout\": reached_timeout,\n",
    "                                }\n",
    "    else:\n",
    "        return np.array(preds)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "surprising-jungle",
   "metadata": {},
   "source": [
    "### ICP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "authentic-medium",
   "metadata": {},
   "outputs": [],
   "source": [
    "def best_k_idx(a, k):\n",
    "    \"\"\"Returns the index of the smallest `k` elements of `a`.\n",
    "    \"\"\"\n",
    "    if len(a) <= k:\n",
    "        return a\n",
    "\n",
    "    return np.argpartition(a, k)[:k]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fallen-cursor",
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "class KNNR(NCM):\n",
    "    def __init__(self, k=15):\n",
    "        self.k = k\n",
    "\n",
    "    def train_ncm(self, X, Y):\n",
    "        X = np.array(X)\n",
    "        Y = np.array(Y)\n",
    "        \n",
    "        def scorer(x, y):\n",
    "            dist = euclidean_distances([x], X).flatten()\n",
    "            best_idx = best_k_idx(dist, self.k)\n",
    "            \n",
    "            # NOTE: len(best_idx) could be less than self.k.\n",
    "            pred = sum(Y[best_idx]) / len(best_idx)\n",
    "            \n",
    "            return abs(y - pred)\n",
    "        \n",
    "        return scorer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "acoustic-cathedral",
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "def icp_regressor_predict(Xtrain, Ytrain, Xcalib, Ycalib, Xtest, Ytest, k, epsilon,\n",
    "                          return_time=False, timeout=None):\n",
    "    ncm = KNNR(k)\n",
    "    # Train nonconformity measure\n",
    "    start = time.perf_counter()\n",
    "    ncm.train(Xtrain, Ytrain, inductive=True)\n",
    "    train_time = time.perf_counter() - start\n",
    "    \n",
    "    # Calibrate\n",
    "    start = time.perf_counter()\n",
    "    scores = []\n",
    "    for x, y in zip(Xcalib, Ycalib):\n",
    "        scores.append(ncm.compute_scores(x, y, only_score_x=True))\n",
    "    scores = np.array(scores)\n",
    "    calibration_time = time.perf_counter() - start\n",
    "\n",
    "    # Compute predictions\n",
    "    start = time.perf_counter()\n",
    "    prediction_times = []\n",
    "    reached_timeout = False\n",
    "\n",
    "    scores = sorted(scores, reverse=True)\n",
    "    s = int(np.floor(epsilon*len(scores)))\n",
    "    alpha_s = scores[s]\n",
    "    \n",
    "    preds = []\n",
    "    for x, y in zip(Xtest, Ytest):\n",
    "        pred = ncm.ncm(x, y)\n",
    "        preds.append((pred-alpha_s, pred+alpha_s))\n",
    "        t = time.perf_counter() - start\n",
    "        prediction_times.append(t)\n",
    "\n",
    "        # Check if reached timeout\n",
    "        if timeout and t > timeout:\n",
    "            reached_timeout = True\n",
    "            break\n",
    "    \n",
    "    pred_time = time.perf_counter() - start\n",
    "    \n",
    "    if return_time:\n",
    "        return np.array(preds), {\"training_time\": train_time,\n",
    "                                 \"calibration_time\": calibration_time,\n",
    "                                 \"prediction_time\": prediction_times,\n",
    "                                 \"reached_timeout\": reached_timeout,\n",
    "                                }\n",
    "    else:\n",
    "        return np.array(preds)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "domestic-whale",
   "metadata": {},
   "source": [
    "## Experiments"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "healthy-narrative",
   "metadata": {},
   "source": [
    "### CP vs optimized CP vs ICP\n",
    "\n",
    "We run the experiments for training size $n \\in [10, 10^5]$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "alternative-capability",
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate_cp_regressor(train_size, max_test_size, n_dimensions,\n",
    "                          inductive_cp, optimized, calibration_size, timeout):\n",
    "    epsilon = 0.1\n",
    "    k = 10\n",
    "    # Discard invalid parameter sets.\n",
    "    if inductive_cp and calibration_size is None:\n",
    "        return\n",
    "    if not inductive_cp and calibration_size is not None:\n",
    "        return\n",
    "    if inductive_cp and optimized:\n",
    "        return\n",
    "\n",
    "    X, Y = make_regression(train_size+max_test_size, n_dimensions)\n",
    "\n",
    "    Xtrain, Xtest, Ytrain, Ytest = train_test_split(X, Y, test_size=max_test_size)\n",
    "\n",
    "    if inductive_cp:\n",
    "        Xtrain, Xcalib, Ytrain, Ycalib = train_test_split(Xtrain, Ytrain,\n",
    "                                                          test_size=calibration_size)\n",
    "        _, times = icp_regressor_predict(Xtrain, Ytrain, Xcalib, Ycalib, Xtest,\n",
    "                                         Ytest, k, epsilon, return_time=True,\n",
    "                                         timeout=timeout)\n",
    "    else:\n",
    "        _, times = knn_cp_regressor_predict(Xtrain, Ytrain, Xtest, Ytest, k, epsilon,\n",
    "                                            fast=optimized, return_time=True, timeout=timeout)\n",
    "    \n",
    "    return times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "protecting-public",
   "metadata": {
    "tags": [
     "experiment:regression-timing"
    ]
   },
   "outputs": [],
   "source": [
    "EXPERIMENT_NAME = \"regression-training-size-comparison\"\n",
    "RESULTS_DIR = \"results/\"\n",
    "REPETITIONS = 5\n",
    "TRAIN_SIZE = np.logspace(1, 5, 13, dtype='int').tolist()\n",
    "MAX_TEST_SIZE = 100\n",
    "N_DIMENSIONS = 30\n",
    "TIMEOUT = 60*60*10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "biological-swing",
   "metadata": {
    "tags": [
     "experiment:regression-timing"
    ]
   },
   "outputs": [],
   "source": [
    "eli = Eli(RESULTS_DIR)\n",
    "eli.run_experiment(exp_name=EXPERIMENT_NAME,\n",
    "                   func=evaluate_cp_regressor,\n",
    "                   repetitions=REPETITIONS,\n",
    "                   n_jobs=20,\n",
    "                   automatic_seed=True,\n",
    "                   # Parameters\n",
    "                   train_size=TRAIN_SIZE,\n",
    "                   max_test_size=MAX_TEST_SIZE,\n",
    "                   n_dimensions=N_DIMENSIONS,\n",
    "                   inductive_cp=[True, False],\n",
    "                   optimized=[True, False],\n",
    "                   calibration_size=[None, 0.5],\n",
    "                   timeout=TIMEOUT,\n",
    "                  )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "completed-allowance",
   "metadata": {},
   "source": [
    "#### Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "middle-chicago",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-07T11:52:50.196470Z",
     "start_time": "2021-06-07T11:52:49.944671Z"
    },
    "tags": [
     "plots"
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "175 observations\n"
     ]
    },
    {
     "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>name</th>\n",
       "      <th>training_time</th>\n",
       "      <th>calibration_time</th>\n",
       "      <th>prediction_time</th>\n",
       "      <th>reached_timeout</th>\n",
       "      <th>train_size</th>\n",
       "      <th>max_test_size</th>\n",
       "      <th>n_dimensions</th>\n",
       "      <th>inductive_cp</th>\n",
       "      <th>optimized</th>\n",
       "      <th>calibration_size</th>\n",
       "      <th>timeout</th>\n",
       "      <th>repetition</th>\n",
       "      <th>git-commit</th>\n",
       "      <th>started</th>\n",
       "      <th>finished</th>\n",
       "      <th>avg_time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>train_size=46-max_test_size=100-n_dimensions=3...</td>\n",
       "      <td>0.000038</td>\n",
       "      <td>0.003018</td>\n",
       "      <td>[0.00021340400007829885, 0.0003716080000231159...</td>\n",
       "      <td>False</td>\n",
       "      <td>46</td>\n",
       "      <td>100</td>\n",
       "      <td>30</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>0.5</td>\n",
       "      <td>36000</td>\n",
       "      <td>0</td>\n",
       "      <td>d400510e20c6d0e1ff3bd6e67dc5b22b0ca79169</td>\n",
       "      <td>2021-01-22T12:25:21.545696+00:00</td>\n",
       "      <td>2021-01-22T12:25:21.572890+00:00</td>\n",
       "      <td>0.000105</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>train_size=46-max_test_size=100-n_dimensions=3...</td>\n",
       "      <td>0.000059</td>\n",
       "      <td>0.002435</td>\n",
       "      <td>[0.00011590299982344732, 0.0001984040000024833...</td>\n",
       "      <td>False</td>\n",
       "      <td>46</td>\n",
       "      <td>100</td>\n",
       "      <td>30</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>0.5</td>\n",
       "      <td>36000</td>\n",
       "      <td>3</td>\n",
       "      <td>d400510e20c6d0e1ff3bd6e67dc5b22b0ca79169</td>\n",
       "      <td>2021-01-22T12:25:21.404809+00:00</td>\n",
       "      <td>2021-01-22T12:25:21.435993+00:00</td>\n",
       "      <td>0.000114</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>train_size=46-max_test_size=100-n_dimensions=3...</td>\n",
       "      <td>0.000017</td>\n",
       "      <td>0.003168</td>\n",
       "      <td>[0.0001632030000564555, 0.0003098060001320846,...</td>\n",
       "      <td>False</td>\n",
       "      <td>46</td>\n",
       "      <td>100</td>\n",
       "      <td>30</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>0.5</td>\n",
       "      <td>36000</td>\n",
       "      <td>4</td>\n",
       "      <td>d400510e20c6d0e1ff3bd6e67dc5b22b0ca79169</td>\n",
       "      <td>2021-01-22T12:25:21.462862+00:00</td>\n",
       "      <td>2021-01-22T12:25:21.484100+00:00</td>\n",
       "      <td>0.000098</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>train_size=46-max_test_size=100-n_dimensions=3...</td>\n",
       "      <td>0.000016</td>\n",
       "      <td>0.002162</td>\n",
       "      <td>[9.860199998001917e-05, 0.00017920400000548398...</td>\n",
       "      <td>False</td>\n",
       "      <td>46</td>\n",
       "      <td>100</td>\n",
       "      <td>30</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>0.5</td>\n",
       "      <td>36000</td>\n",
       "      <td>2</td>\n",
       "      <td>d400510e20c6d0e1ff3bd6e67dc5b22b0ca79169</td>\n",
       "      <td>2021-01-22T12:25:21.649670+00:00</td>\n",
       "      <td>2021-01-22T12:25:21.672520+00:00</td>\n",
       "      <td>0.000123</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>train_size=46-max_test_size=100-n_dimensions=3...</td>\n",
       "      <td>0.000021</td>\n",
       "      <td>0.003501</td>\n",
       "      <td>[0.0001549040000554669, 0.00028090599994357035...</td>\n",
       "      <td>False</td>\n",
       "      <td>46</td>\n",
       "      <td>100</td>\n",
       "      <td>30</td>\n",
       "      <td>True</td>\n",
       "      <td>False</td>\n",
       "      <td>0.5</td>\n",
       "      <td>36000</td>\n",
       "      <td>1</td>\n",
       "      <td>d400510e20c6d0e1ff3bd6e67dc5b22b0ca79169</td>\n",
       "      <td>2021-01-22T12:25:21.602766+00:00</td>\n",
       "      <td>2021-01-22T12:25:21.626677+00:00</td>\n",
       "      <td>0.000138</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                name  training_time  \\\n",
       "0  train_size=46-max_test_size=100-n_dimensions=3...       0.000038   \n",
       "1  train_size=46-max_test_size=100-n_dimensions=3...       0.000059   \n",
       "2  train_size=46-max_test_size=100-n_dimensions=3...       0.000017   \n",
       "3  train_size=46-max_test_size=100-n_dimensions=3...       0.000016   \n",
       "4  train_size=46-max_test_size=100-n_dimensions=3...       0.000021   \n",
       "\n",
       "   calibration_time                                    prediction_time  \\\n",
       "0          0.003018  [0.00021340400007829885, 0.0003716080000231159...   \n",
       "1          0.002435  [0.00011590299982344732, 0.0001984040000024833...   \n",
       "2          0.003168  [0.0001632030000564555, 0.0003098060001320846,...   \n",
       "3          0.002162  [9.860199998001917e-05, 0.00017920400000548398...   \n",
       "4          0.003501  [0.0001549040000554669, 0.00028090599994357035...   \n",
       "\n",
       "   reached_timeout  train_size  max_test_size  n_dimensions  inductive_cp  \\\n",
       "0            False          46            100            30          True   \n",
       "1            False          46            100            30          True   \n",
       "2            False          46            100            30          True   \n",
       "3            False          46            100            30          True   \n",
       "4            False          46            100            30          True   \n",
       "\n",
       "   optimized  calibration_size  timeout  repetition  \\\n",
       "0      False               0.5    36000           0   \n",
       "1      False               0.5    36000           3   \n",
       "2      False               0.5    36000           4   \n",
       "3      False               0.5    36000           2   \n",
       "4      False               0.5    36000           1   \n",
       "\n",
       "                                 git-commit                           started  \\\n",
       "0  d400510e20c6d0e1ff3bd6e67dc5b22b0ca79169  2021-01-22T12:25:21.545696+00:00   \n",
       "1  d400510e20c6d0e1ff3bd6e67dc5b22b0ca79169  2021-01-22T12:25:21.404809+00:00   \n",
       "2  d400510e20c6d0e1ff3bd6e67dc5b22b0ca79169  2021-01-22T12:25:21.462862+00:00   \n",
       "3  d400510e20c6d0e1ff3bd6e67dc5b22b0ca79169  2021-01-22T12:25:21.649670+00:00   \n",
       "4  d400510e20c6d0e1ff3bd6e67dc5b22b0ca79169  2021-01-22T12:25:21.602766+00:00   \n",
       "\n",
       "                           finished  avg_time  \n",
       "0  2021-01-22T12:25:21.572890+00:00  0.000105  \n",
       "1  2021-01-22T12:25:21.435993+00:00  0.000114  \n",
       "2  2021-01-22T12:25:21.484100+00:00  0.000098  \n",
       "3  2021-01-22T12:25:21.672520+00:00  0.000123  \n",
       "4  2021-01-22T12:25:21.626677+00:00  0.000138  "
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load data\n",
    "\n",
    "eli = Eli(RESULTS_DIR)\n",
    "results = eli.fetch_results(\"regression-training-size-comparison\")\n",
    "\n",
    "print(f\"{len(results)} observations\")\n",
    "\n",
    "TIMEOUT = 60*60*10\n",
    "\n",
    "avgerage_time = lambda vec: np.concatenate((\n",
    "                                [vec[0]],\n",
    "                                pd.Series(vec).diff()[1:]\n",
    "                            )).mean()\n",
    "\n",
    "results[\"avg_time\"] = results.prediction_time.apply(avgerage_time)\n",
    "\n",
    "results.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "buried-telling",
   "metadata": {},
   "source": [
    "Producing **Figure 3**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "southwest-retailer",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-07T11:52:55.316911Z",
     "start_time": "2021-06-07T11:52:53.310706Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 324x302.4 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(1, 1, figsize=(4.5, 4.2))\n",
    "\n",
    "colors = sns.color_palette()\n",
    "plot_data = results\n",
    "sns.lineplot(x=\"train_size\", y=\"avg_time\",\n",
    "             data=plot_data[(plot_data.inductive_cp==False) & (plot_data.optimized==False)],\n",
    "             ax=ax, legend=None, label=\"Papadopoulos et al. (2011)\",\n",
    "             color=colors[0])\n",
    "sns.lineplot(x=\"train_size\", y=\"avg_time\",\n",
    "             data=plot_data[plot_data.optimized==True],\n",
    "             ax=ax, legend=None, label=\"Optimized\",\n",
    "             color=colors[1])\n",
    "sns.lineplot(x=\"train_size\", y=\"avg_time\",\n",
    "             data=plot_data[plot_data.inductive_cp==True],\n",
    "             ax=ax, legend=None, label=\"ICP\",\n",
    "             color=colors[-3])\n",
    "ax.lines[0].set_linestyle(\"--\")\n",
    "ax.lines[2].set_linestyle(\":\")\n",
    "\n",
    "#ax.plot(range(10**5), [TIMEOUT]*10**5, color='0.30', ls=':')\n",
    "ax.set_yscale(\"log\")\n",
    "ax.xaxis.set_major_formatter(ticker.EngFormatter())\n",
    "ax.grid()\n",
    "ax.set_xlim([0, 10**5])\n",
    "ax.set_ylim([10**-4, 10**5])\n",
    "ax.set_xlabel(\"Training set size\")\n",
    "ax.set_ylabel(\"Average prediction time (s)\")\n",
    "ax.legend(title=\"\", loc=\"upper left\", frameon=True) #, labels=[\"Standard\", \"Optimized\"])\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig(f\"regression-comparison.pdf\", dpi=DPI)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "headed-robin",
   "metadata": {},
   "source": [
    "### Numbers\n",
    "\n",
    "Numbers reported in the text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ultimate-roller",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"CP k-NN optimized avg pred (100k): {} seconds\".format(\n",
    "            results[(results.optimized==True) &\n",
    "                    (results.train_size==100000) &\n",
    "                    (results.inductive_cp==False)].avg_time.mean()))\n",
    "print(\"CP k-NN avg pred (100k): {} hours\".format(\n",
    "            results[(results.optimized==False) &\n",
    "                    (results.train_size==100000) &\n",
    "                    (results.inductive_cp==False)].avg_time.mean()/60/60))\n",
    "print(\"ICP k-NN avg pred (100k): {} seconds\".format(\n",
    "            results[(results.optimized==False) &\n",
    "                    (results.train_size==100000) &\n",
    "                    (results.inductive_cp==True)].avg_time.mean()))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "brave-albuquerque",
   "metadata": {},
   "source": [
    "# Bootstrap calculations\n",
    "\n",
    "We estimate empirically the value $E[B']$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "toxic-essay",
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import count\n",
    "\n",
    "def count_bprime(B, n):\n",
    "    data_idx = list(range(n))\n",
    "    E = {i: 0 for i in data_idx}\n",
    "    \n",
    "    for bprime in count():\n",
    "        Zb = resample(data_idx)\n",
    "        sampled = set(Zb)\n",
    "        to_check = list(E.keys())  # Necessary to prevent issues in iterating dict.\n",
    "        for i in to_check:\n",
    "            if not i in sampled:\n",
    "                # Bootstrap sample Zb can be used for example i.\n",
    "                E[i] += 1\n",
    "                # To speed up B' estimation, remove E[i] when full.\n",
    "                if E[i] == B:\n",
    "                    del E[i]\n",
    "\n",
    "        # Check if all are satisfied.\n",
    "        if not E:\n",
    "            break\n",
    "    \n",
    "    return bprime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "quarterly-zealand",
   "metadata": {},
   "outputs": [],
   "source": [
    "REPETITIONS = 10\n",
    "\n",
    "results = defaultdict(list)\n",
    "\n",
    "for b in [2, 5, 10, 20, 50, 100]:\n",
    "    for n in [100, 1000, 10000, 100000]:\n",
    "        for seed in range(REPETITIONS):\n",
    "            results[\"seed\"].append(seed)\n",
    "            results[\"B\"].append(b)\n",
    "            results[\"n\"].append(n)\n",
    "            results[\"B'\"].append(count_bprime(b, n))\n",
    "\n",
    "results = pd.DataFrame(results)\n",
    "results.to_csv(\"results/bootstrap-bprime.csv\")\n",
    "results.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "concrete-elimination",
   "metadata": {},
   "source": [
    "Producing **Figure 4**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "least-halifax",
   "metadata": {},
   "outputs": [],
   "source": [
    "results = pd.read_csv(\"results/bootstrap-bprime.csv\")\n",
    "plt.figure(figsize=(4.5, 4.2))\n",
    "sns.lineplot(\"B\", \"B'\", data=results, hue=\"n\", legend=\"full\")\n",
    "plt.grid()\n",
    "plt.xlim([0, results.B.max()])\n",
    "plt.ylim([0, 400])\n",
    "plt.legend(loc=\"best\", frameon=True)\n",
    "plt.ylabel(\"B'   \", rotation=0)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig(\"bprime.png\", dpi=DPI)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "genuine-convert",
   "metadata": {},
   "source": [
    "The following, `bprime()`, calculates the expectation $E[B']$ exactly,\n",
    "but it is computational heavy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "proved-bosnia",
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import permutations\n",
    "\n",
    "P = np.exp(-1)\n",
    "cache = {}\n",
    "\n",
    "def bprime(counts):\n",
    "    counts = list(filter(lambda x: x != 0, counts))\n",
    "    if len(counts) == 0:\n",
    "        return 0\n",
    "    elif len(counts) == 1:\n",
    "        return counts[0]/P\n",
    "    \n",
    "    key = tuple(sorted(counts))\n",
    "    if key in cache:\n",
    "        return cache[key]\n",
    "\n",
    "    n = len(counts)\n",
    "    p2 = (1-(1-P)**n)\n",
    "    e = 1\n",
    "    # k is how many are subtracted.\n",
    "    # k>1 (i.e., there's at least one success),\n",
    "    # since p2 already accounts for the recursion\n",
    "    # on bprime(counts)\n",
    "    for k in range(1, n+1):\n",
    "        # happens with probability:\n",
    "        p1 = P**k*(1-P)**(n-k)\n",
    "        # Generate all the possible movements.\n",
    "        for sub in combinations(range(n), k):\n",
    "            new_counts = counts.copy()\n",
    "            for i in sub:\n",
    "                if new_counts[i] > 0:\n",
    "                    new_counts[i] -= 1\n",
    "            e += p1*bprime(new_counts)\n",
    "    \n",
    "    e /= p2\n",
    "    \n",
    "    cache[key] = e\n",
    "\n",
    "    return e\n",
    "\n",
    "\n",
    "assert bprime([0, 0, 2, 0, 0, 0]) == 2/P\n",
    "assert bprime([1, 1]) == (3-2*P)/(1-(1-P)**2)\n",
    "assert bprime([0, 0, 1, 0, 1, 0]) == (3-2*P)/(1-(1-P)**2)\n",
    "assert bprime([2, 1]) == (3 - P + bprime([1, 1])*P*(1-P))/(1-(1-P)**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "democratic-paradise",
   "metadata": {},
   "source": [
    "# Comparison on MNIST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "demographic-logging",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import fetch_openml\n",
    "\n",
    "def evaluate_ncm_mnist(ncm, inductive_cp, calibration_size, timeout):\n",
    "    # Discard invalid parameter sets.\n",
    "    if inductive_cp and calibration_size is None:\n",
    "        return\n",
    "    if not inductive_cp and calibration_size is not None:\n",
    "        return\n",
    "    \n",
    "    X, Y = fetch_openml('mnist_784', version=1, return_X_y=True, as_frame=False)\n",
    "    Y = Y.astype(int)\n",
    "    ntrain = 60000\n",
    "    Xtrain = X[:ntrain,]\n",
    "    Ytrain = Y[:ntrain]\n",
    "    Xtest = X[ntrain:,]\n",
    "    Ytest = Y[ntrain:]\n",
    "  \n",
    "    ncm_class = eval(ncm)       # eval(): Perdoname, madre, por mi vida loca :D\n",
    "    ncm = ncm_class()\n",
    "\n",
    "\n",
    "    if inductive_cp:\n",
    "        Xtrain, Xcalib, Ytrain, Ycalib = train_test_split(Xtrain, Ytrain,\n",
    "                                                          test_size=calibration_size)\n",
    "        pvalues, times = icp_predict(Xtrain, Ytrain, Xcalib, Ycalib,\n",
    "                                     Xtest, np.unique(Y), ncm, return_time=True)\n",
    "    else:\n",
    "        pvalues, times = cp_predict(Xtrain, Ytrain, Xtest, np.unique(Y),\n",
    "                                    ncm, return_time=True, timeout=timeout)\n",
    "    \n",
    "    return pvalues.tolist(), times"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dense-commander",
   "metadata": {},
   "source": [
    "## Experiments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "starting-negotiation",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-07T11:53:01.910689Z",
     "start_time": "2021-06-07T11:53:01.907513Z"
    }
   },
   "outputs": [],
   "source": [
    "EXPERIMENT_NAME = \"mnist-comparison\"\n",
    "RESULTS_DIR = \"results/\"\n",
    "REPETITIONS = 1\n",
    "TIMEOUT = 60*60*48"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "herbal-diary",
   "metadata": {},
   "outputs": [],
   "source": [
    "NCMs = [\"KNN\", \"KDE\", \"LSSVM\", \"NN\", \"SimplifiedKNN\", \"RandomForest\"]\n",
    "\n",
    "eli = Eli(RESULTS_DIR)\n",
    "eli.run_experiment(exp_name=EXPERIMENT_NAME,\n",
    "                   func=evaluate_ncm_mnist,\n",
    "                   repetitions=REPETITIONS,\n",
    "                   n_jobs=16,\n",
    "                   automatic_seed=True,\n",
    "                   # Parameters\n",
    "                   ncm=NCMs,\n",
    "                   inductive_cp=True,\n",
    "                   calibration_size=0.5,\n",
    "                   timeout=TIMEOUT,\n",
    "                  )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "persistent-kinase",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We use arbitrary precision math for KDE in this case.\n",
    "KDE_fast = KDE_fast_mpmath"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aware-founder",
   "metadata": {},
   "outputs": [],
   "source": [
    "NCMs = [\"KNN_fast\", \"KDE_fast\", \"LSSVM_fast\", \"NN_fast\", \"SimplifiedKNN_fast\", \"RandomForest_fast\"]\n",
    "NCMs += [\"KNN\", \"KDE\", \"LSSVM\", \"NN\", \"SimplifiedKNN\", \"RandomForest\"]\n",
    "\n",
    "eli = Eli(RESULTS_DIR)\n",
    "eli.run_experiment(exp_name=EXPERIMENT_NAME,\n",
    "                   func=evaluate_ncm_mnist,\n",
    "                   repetitions=REPETITIONS,\n",
    "                   n_jobs=8,\n",
    "                   automatic_seed=True,\n",
    "                   # Parameters\n",
    "                   ncm=NCMs,\n",
    "                   inductive_cp=False,\n",
    "                   calibration_size=None,\n",
    "                   timeout=TIMEOUT,\n",
    "                  )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "arctic-philosophy",
   "metadata": {},
   "source": [
    "## Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "vertical-maple",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-07T11:53:38.499197Z",
     "start_time": "2021-06-07T11:53:10.111413Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "31 observations\n"
     ]
    },
    {
     "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>name</th>\n",
       "      <th>results</th>\n",
       "      <th>ncm</th>\n",
       "      <th>inductive_cp</th>\n",
       "      <th>calibration_size</th>\n",
       "      <th>timeout</th>\n",
       "      <th>repetition</th>\n",
       "      <th>git-commit</th>\n",
       "      <th>started</th>\n",
       "      <th>finished</th>\n",
       "      <th>pvalues</th>\n",
       "      <th>prediction_time</th>\n",
       "      <th>training_time</th>\n",
       "      <th>reached_timeout</th>\n",
       "      <th>calibration_time</th>\n",
       "      <th>avg_time</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>ncm=KNN_fast-inductive_cp=False-calibration_si...</td>\n",
       "      <td>[[[1.666638889351844e-05, 1.666638889351844e-0...</td>\n",
       "      <td>KNN_fast</td>\n",
       "      <td>False</td>\n",
       "      <td>NaN</td>\n",
       "      <td>172800</td>\n",
       "      <td>0</td>\n",
       "      <td>518a84a497f6fa122d2bf10069a8122921d8062d</td>\n",
       "      <td>2021-04-13T13:11:03.763703+00:00</td>\n",
       "      <td>2021-04-13T21:06:54.802423+00:00</td>\n",
       "      <td>[[1.666638889351844e-05, 1.666638889351844e-05...</td>\n",
       "      <td>[6.1571719700004905, 8.886775984894484, 11.710...</td>\n",
       "      <td>2057.124651</td>\n",
       "      <td>False</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2.64784</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>ncm=KNN-inductive_cp=False-calibration_size=No...</td>\n",
       "      <td>[[], {'training_time': 0.13243418373167515, 'p...</td>\n",
       "      <td>KNN</td>\n",
       "      <td>False</td>\n",
       "      <td>NaN</td>\n",
       "      <td>172800</td>\n",
       "      <td>0</td>\n",
       "      <td>6c46c2420ef1fdbeae1d5c993f72d8b84ba15223</td>\n",
       "      <td>2021-04-16T21:20:29.249526+00:00</td>\n",
       "      <td>2021-04-18T21:20:44.887870+00:00</td>\n",
       "      <td>[]</td>\n",
       "      <td>[]</td>\n",
       "      <td>0.132434</td>\n",
       "      <td>True</td>\n",
       "      <td>NaN</td>\n",
       "      <td>[inf]</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>ncm=KDE-inductive_cp=False-calibration_size=No...</td>\n",
       "      <td>[[[0.011616473058782354, 0.010299828336194397,...</td>\n",
       "      <td>KDE</td>\n",
       "      <td>False</td>\n",
       "      <td>NaN</td>\n",
       "      <td>172800</td>\n",
       "      <td>0</td>\n",
       "      <td>88c0ef46a4fdee12a2715739adff119d7cd24953</td>\n",
       "      <td>2021-03-25T02:01:39.018236+00:00</td>\n",
       "      <td>2021-04-01T00:57:27.103169+00:00</td>\n",
       "      <td>[[0.011616473058782354, 0.010299828336194397, ...</td>\n",
       "      <td>[600932.015585535]</td>\n",
       "      <td>0.148963</td>\n",
       "      <td>True</td>\n",
       "      <td>NaN</td>\n",
       "      <td>600932</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>ncm=KDE_fast-inductive_cp=False-calibration_si...</td>\n",
       "      <td>[[[0.003983266945550908, 0.01058315694738421, ...</td>\n",
       "      <td>KDE_fast</td>\n",
       "      <td>False</td>\n",
       "      <td>NaN</td>\n",
       "      <td>172800</td>\n",
       "      <td>0</td>\n",
       "      <td>518a84a497f6fa122d2bf10069a8122921d8062d</td>\n",
       "      <td>2021-04-13T13:11:03.761652+00:00</td>\n",
       "      <td>2021-04-14T19:41:26.214120+00:00</td>\n",
       "      <td>[[0.003983266945550908, 0.01058315694738421, 0...</td>\n",
       "      <td>[8.8238184528891, 17.559826349839568, 26.27758...</td>\n",
       "      <td>4623.610986</td>\n",
       "      <td>False</td>\n",
       "      <td>NaN</td>\n",
       "      <td>10.5184</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>ncm=SimplifiedKNN-inductive_cp=False-calibrati...</td>\n",
       "      <td>[[[0.008566523891268479, 0.008749854169097182,...</td>\n",
       "      <td>SimplifiedKNN</td>\n",
       "      <td>False</td>\n",
       "      <td>NaN</td>\n",
       "      <td>172800</td>\n",
       "      <td>0</td>\n",
       "      <td>88c0ef46a4fdee12a2715739adff119d7cd24953</td>\n",
       "      <td>2021-03-25T02:01:39.010173+00:00</td>\n",
       "      <td>2021-03-29T04:24:57.008391+00:00</td>\n",
       "      <td>[[0.008566523891268479, 0.008749854169097182, ...</td>\n",
       "      <td>[354181.07600883796]</td>\n",
       "      <td>0.150874</td>\n",
       "      <td>True</td>\n",
       "      <td>NaN</td>\n",
       "      <td>354181</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                name  \\\n",
       "1  ncm=KNN_fast-inductive_cp=False-calibration_si...   \n",
       "2  ncm=KNN-inductive_cp=False-calibration_size=No...   \n",
       "4  ncm=KDE-inductive_cp=False-calibration_size=No...   \n",
       "5  ncm=KDE_fast-inductive_cp=False-calibration_si...   \n",
       "7  ncm=SimplifiedKNN-inductive_cp=False-calibrati...   \n",
       "\n",
       "                                             results            ncm  \\\n",
       "1  [[[1.666638889351844e-05, 1.666638889351844e-0...       KNN_fast   \n",
       "2  [[], {'training_time': 0.13243418373167515, 'p...            KNN   \n",
       "4  [[[0.011616473058782354, 0.010299828336194397,...            KDE   \n",
       "5  [[[0.003983266945550908, 0.01058315694738421, ...       KDE_fast   \n",
       "7  [[[0.008566523891268479, 0.008749854169097182,...  SimplifiedKNN   \n",
       "\n",
       "   inductive_cp  calibration_size  timeout  repetition  \\\n",
       "1         False               NaN   172800           0   \n",
       "2         False               NaN   172800           0   \n",
       "4         False               NaN   172800           0   \n",
       "5         False               NaN   172800           0   \n",
       "7         False               NaN   172800           0   \n",
       "\n",
       "                                 git-commit                           started  \\\n",
       "1  518a84a497f6fa122d2bf10069a8122921d8062d  2021-04-13T13:11:03.763703+00:00   \n",
       "2  6c46c2420ef1fdbeae1d5c993f72d8b84ba15223  2021-04-16T21:20:29.249526+00:00   \n",
       "4  88c0ef46a4fdee12a2715739adff119d7cd24953  2021-03-25T02:01:39.018236+00:00   \n",
       "5  518a84a497f6fa122d2bf10069a8122921d8062d  2021-04-13T13:11:03.761652+00:00   \n",
       "7  88c0ef46a4fdee12a2715739adff119d7cd24953  2021-03-25T02:01:39.010173+00:00   \n",
       "\n",
       "                           finished  \\\n",
       "1  2021-04-13T21:06:54.802423+00:00   \n",
       "2  2021-04-18T21:20:44.887870+00:00   \n",
       "4  2021-04-01T00:57:27.103169+00:00   \n",
       "5  2021-04-14T19:41:26.214120+00:00   \n",
       "7  2021-03-29T04:24:57.008391+00:00   \n",
       "\n",
       "                                             pvalues  \\\n",
       "1  [[1.666638889351844e-05, 1.666638889351844e-05...   \n",
       "2                                                 []   \n",
       "4  [[0.011616473058782354, 0.010299828336194397, ...   \n",
       "5  [[0.003983266945550908, 0.01058315694738421, 0...   \n",
       "7  [[0.008566523891268479, 0.008749854169097182, ...   \n",
       "\n",
       "                                     prediction_time  training_time  \\\n",
       "1  [6.1571719700004905, 8.886775984894484, 11.710...    2057.124651   \n",
       "2                                                 []       0.132434   \n",
       "4                                 [600932.015585535]       0.148963   \n",
       "5  [8.8238184528891, 17.559826349839568, 26.27758...    4623.610986   \n",
       "7                               [354181.07600883796]       0.150874   \n",
       "\n",
       "   reached_timeout  calibration_time avg_time  \n",
       "1            False               NaN  2.64784  \n",
       "2             True               NaN    [inf]  \n",
       "4             True               NaN   600932  \n",
       "5            False               NaN  10.5184  \n",
       "7             True               NaN   354181  "
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load data\n",
    "\n",
    "eli = Eli(RESULTS_DIR)\n",
    "results = eli.fetch_results(\"mnist-comparison\")\n",
    "\n",
    "print(f\"{len(results)} observations\")\n",
    "\n",
    "NAMES = {\"SimplifiedKNN\": \"Simplified k-NN\",\n",
    "         \"KNN\": \"k-NN\",\n",
    "         \"LSSVM\": \"LS-SVM\",\n",
    "         \"KDE\": \"KDE\",\n",
    "         \"RandomForest\": \"Random Forest\",\n",
    "         \"NN\": \"NN\",\n",
    "        }\n",
    "TIMEOUT = 60*60*48\n",
    "\n",
    "\n",
    "# True labels for MNIST test set.\n",
    "_, Y = fetch_openml('mnist_784', version=1, return_X_y=True, as_frame=False)\n",
    "Y = Y.astype(int)\n",
    "ntrain = 60000\n",
    "Ytest = Y[ntrain:]\n",
    "\n",
    "\n",
    "# The data structure is a bit different from previous experiments\n",
    "# (we have p-values). So we first do a bit of unpacking.\n",
    "pvalues = []\n",
    "prediction_time = []\n",
    "training_time = []\n",
    "reached_timeout = []\n",
    "calibration_time = []\n",
    "\n",
    "for row in results.results:\n",
    "    pvalues.append(row[0])\n",
    "    d = row[1]\n",
    "    prediction_time.append(d[\"prediction_time\"])\n",
    "    training_time.append(d[\"training_time\"])\n",
    "    reached_timeout.append(d[\"reached_timeout\"])\n",
    "    c = d[\"calibration_time\"] if \"calibration_time\" in d else None\n",
    "    calibration_time.append(c)\n",
    "\n",
    "results[\"pvalues\"] = pvalues\n",
    "results[\"prediction_time\"] = prediction_time\n",
    "results[\"training_time\"] = training_time\n",
    "results[\"reached_timeout\"] = reached_timeout\n",
    "results[\"calibration_time\"] = calibration_time\n",
    "\n",
    "average_time = lambda vec: np.concatenate((\n",
    "                                [vec[0]],\n",
    "                                pd.Series(vec).diff()[1:]\n",
    "                            )).mean() if len(vec) else [np.inf]\n",
    "\n",
    "results[\"avg_time\"] = results.prediction_time.apply(average_time)\n",
    "\n",
    "results = results[results.timeout==TIMEOUT]\n",
    "\n",
    "results.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "molecular-campbell",
   "metadata": {},
   "source": [
    "### Computation time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "adaptive-allah",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-07T09:40:25.103280Z",
     "start_time": "2021-06-07T09:40:25.055214Z"
    },
    "code_folding": [
     0,
     13
    ],
    "run_control": {
     "marked": false
    }
   },
   "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>CP</th>\n",
       "      <th>Optimized CP</th>\n",
       "      <th>ICP</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>NN</th>\n",
       "      <td>0s/109h 49m* (1) (109h 49m)</td>\n",
       "      <td>34m 5s + 7h 9m (7h 44m)</td>\n",
       "      <td>22m 58s + 2h 38m (3h 1m)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SimplifiedKNN</th>\n",
       "      <td>0s/98h 23m* (1) (98h 23m)</td>\n",
       "      <td>29s + 4h 36m (4h 36m)</td>\n",
       "      <td>3m 47s + 1h 38m (1h 42m)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>KNN</th>\n",
       "      <td>0s/['48h 0m+']* (0) (0.13243418373167515)</td>\n",
       "      <td>34m 17s + 7h 21m (7h 55m)</td>\n",
       "      <td>20m 25s + 2h 29m (2h 49m)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>KDE</th>\n",
       "      <td>0s/166h 55m* (1) (166h 55m)</td>\n",
       "      <td>1h 17m + 29h 13m (30h 30m)</td>\n",
       "      <td>1h 30m + 6h 13m (7h 44m)</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>RandomForest</th>\n",
       "      <td>0s/['48h 0m+']* (0) (0.12978316098451614)</td>\n",
       "      <td>48s/['48h 0m+']* (0) (47.719479077961296)</td>\n",
       "      <td>21s + 1h 25m (1h 25m)</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                      CP  \\\n",
       "NN                           0s/109h 49m* (1) (109h 49m)   \n",
       "SimplifiedKNN                  0s/98h 23m* (1) (98h 23m)   \n",
       "KNN            0s/['48h 0m+']* (0) (0.13243418373167515)   \n",
       "KDE                          0s/166h 55m* (1) (166h 55m)   \n",
       "RandomForest   0s/['48h 0m+']* (0) (0.12978316098451614)   \n",
       "\n",
       "                                            Optimized CP  \\\n",
       "NN                               34m 5s + 7h 9m (7h 44m)   \n",
       "SimplifiedKNN                      29s + 4h 36m (4h 36m)   \n",
       "KNN                            34m 17s + 7h 21m (7h 55m)   \n",
       "KDE                           1h 17m + 29h 13m (30h 30m)   \n",
       "RandomForest   48s/['48h 0m+']* (0) (47.719479077961296)   \n",
       "\n",
       "                                     ICP  \n",
       "NN              22m 58s + 2h 38m (3h 1m)  \n",
       "SimplifiedKNN   3m 47s + 1h 38m (1h 42m)  \n",
       "KNN            20m 25s + 2h 29m (2h 49m)  \n",
       "KDE             1h 30m + 6h 13m (7h 44m)  \n",
       "RandomForest       21s + 1h 25m (1h 25m)  "
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def highlight_min(data, color='yellow'):\n",
    "    \"\"\"\n",
    "    highlight the minimum in a Series or DataFrame\n",
    "    \"\"\"\n",
    "    attr = 'background-color: {}'.format(color)\n",
    "    if data.ndim == 1:  # Series from .apply(axis=0) or axis=1\n",
    "        is_min = data == data.min()\n",
    "        return [attr if v else '' for v in is_min]\n",
    "    else:  # from .apply(axis=None)\n",
    "        is_min = data == data.min().min()\n",
    "        return pd.DataFrame(np.where(is_min, attr, ''),\n",
    "                            index=data.index, columns=data.columns)\n",
    "\n",
    "def format_time(seconds):\n",
    "    seconds = int(round(seconds))\n",
    "    m, s = divmod(seconds, 60)\n",
    "    h, m = divmod(m, 60)\n",
    "    \n",
    "    if h > 0:\n",
    "        fmt = f\"{h}h {m}m\"\n",
    "    elif m > 0:\n",
    "        fmt = f\"{m}m {s}s\"\n",
    "    else:\n",
    "        fmt = f\"{s}s\"\n",
    "    \n",
    "    return fmt\n",
    "\n",
    "def get_times(r):\n",
    "    if len(r):\n",
    "        r = r.iloc[0]\n",
    "        if not np.isnan(r.calibration_time):\n",
    "            training_time = format_time(r.training_time+r.calibration_time)\n",
    "            total_time = r.training_time+r.calibration_time\n",
    "        else:\n",
    "            training_time = format_time(r.training_time)\n",
    "            total_time = r.training_time\n",
    "        if r.prediction_time:\n",
    "            prediction_time = format_time(max(r.prediction_time))\n",
    "            total_time = format_time(total_time+max(r.prediction_time))\n",
    "        else:\n",
    "            prediction_time = [f\"{format_time(TIMEOUT)}+\"]\n",
    "        if r.reached_timeout:\n",
    "            fmt = f\"{training_time}/{prediction_time}* ({len(r.prediction_time)}) ({total_time})\"\n",
    "        else:\n",
    "            fmt = f\"{training_time} + {prediction_time} ({total_time})\"\n",
    "    else:\n",
    "        fmt = \"/\"\n",
    "    \n",
    "    return fmt\n",
    "\n",
    "    \n",
    "NCMs = [\"NN\", \"SimplifiedKNN\", \"KNN\", \"KDE\", \"RandomForest\"]\n",
    "\n",
    "table_results = {\"CP\": [], \"Optimized CP\": [], \"ICP\": []}\n",
    "\n",
    "for ncm in NCMs:\n",
    "    t = get_times(results[((results.ncm == ncm)) &\n",
    "                                 (results.inductive_cp == False)])\n",
    "    table_results[\"CP\"].append(t)\n",
    "\n",
    "    t = get_times(results[((results.ncm == ncm + \"_fast\")) &\n",
    "                                 (results.inductive_cp == False)])\n",
    "    table_results[\"Optimized CP\"].append(t)\n",
    "\n",
    "    t = get_times(results[((results.ncm == ncm)) &\n",
    "                                 (results.inductive_cp == True)])\n",
    "    table_results[\"ICP\"].append(t)\n",
    "\n",
    "table = pd.DataFrame(table_results)\n",
    "table.index = NCMs\n",
    "table"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "moral-consultation",
   "metadata": {},
   "source": [
    "**NOTE** the experiments in the above table were run with two different ways\n",
    "of setting a timeout:\n",
    "- a \"strict\" way, which would terminate the called function after TIMEOUT\n",
    "- a \"relaxed\" way, which would terminate after a prediction (pvalue) was computed and if the TIMEOUT had been reached.\n",
    "(This was due to computational constraints.)\n",
    "\n",
    "Consequently, some of them show computation times greater than TIMEOUT (e.g., CP KDE: 166h).\n",
    "\n",
    "For our purposes, we cut everything after TIMEOUT (=48h), but keep these numbers here for reference."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "superb-force",
   "metadata": {},
   "source": [
    "### Prediction efficiency\n",
    "\n",
    "We compare CP and ICP w.r.t.: fuzziness and average number of errors for a fixed significance level.\n",
    "\n",
    "The fuzziness of a set of p-values $\\{p_y\\}_{y\\in Y}$ is the average\n",
    "of the p-values excluding the largest one:\n",
    "\n",
    "$$\\sum_{y\\in Y} p_y - \\max_y p_y .$$\n",
    "\n",
    "The smaller it is, the better.\n",
    "\n",
    "We use the Welch one-sided statistical test for the\n",
    "null hypothesis $H_0$: \"ICP has a smaller fuzziness (i.e., it is better) than CP\".\n",
    "\n",
    "We reject the null hypothesis for a p-value $< 0.01$.\n",
    "\n",
    "We also evaluate the methods w.r.t. their average number of errors. This metric is however not ideal for evaluating CP classification, as it reflects a very coarse requirement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "acquired-least",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-07T09:40:29.229188Z",
     "start_time": "2021-06-07T09:40:29.215928Z"
    }
   },
   "outputs": [],
   "source": [
    "def pvalues_stats(results, true_labels, eps=0.05):\n",
    "    if not len(results):\n",
    "        return None, None, [None], None\n",
    "    pvalues = results.iloc[0].pvalues\n",
    "    if not len(pvalues):\n",
    "        return None, None, [None], None\n",
    "    avg = np.mean(pvalues, axis=1)\n",
    "    fuzziness = []\n",
    "    errors = []\n",
    "    avg_size = []\n",
    "    for y, pvals in zip(true_labels, pvalues):\n",
    "        pvals = sorted(pvals)\n",
    "        fuzziness.append(np.mean(pvals[:-1]))\n",
    "        e = pvals[y] > eps\n",
    "        errors.append(e)\n",
    "        avg_size.append(sum(np.array(pvals) > eps))\n",
    "    \n",
    "    return avg, fuzziness, errors, np.mean(avg_size)\n",
    "\n",
    "def compare_cp_icp(cp, icp, quantity=\"fuzziness\", eps=0.1, real_labels=Ytest):\n",
    "    \"\"\"We run a statistical test to verify if cp is better than icp\n",
    "    w.r.t. the chosen quantity.\n",
    "    \"\"\"\n",
    "    avgpval_cp, fuzziness_cp, errors_cp, avg_error_cp = pvalues_stats(cp, real_labels)\n",
    "    avgpval_icp, fuzziness_icp, errors_icp, avg_error_icp = pvalues_stats(icp, real_labels)\n",
    "    \n",
    "    if quantity == \"fuzziness\":\n",
    "        a, b = fuzziness_cp, fuzziness_icp\n",
    "    elif quantity == \"errors\":\n",
    "        a, b = errors_cp, errors_icp\n",
    "        if a[0] is None or b[0] is None:\n",
    "            a = None\n",
    "            b = None\n",
    "    else:\n",
    "        raise Exception(\"not implemented\")\n",
    "\n",
    "    if a is not None and b is not None:\n",
    "        n = min(len(a), len(b))\n",
    "        test = ttest_ind(a[:n], b[:n], equal_var=False, alternative=\"less\")\n",
    "        pvalue = test.pvalue\n",
    "        stats = np.mean(a), np.std(a), np.mean(b), np.std(b)\n",
    "    else:\n",
    "        pvalue = None\n",
    "        stats = [None]*4\n",
    "    \n",
    "    return pvalue, stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "coordinated-private",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-06-07T09:40:37.631281Z",
     "start_time": "2021-06-07T09:40:30.027011Z"
    },
    "code_folding": [],
    "run_control": {
     "marked": false
    }
   },
   "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>CP-fuzziness</th>\n",
       "      <th>ICP-fuzziness</th>\n",
       "      <th>Fuzziness Welch's test p-value</th>\n",
       "      <th>CP-errors</th>\n",
       "      <th>ICP-errors</th>\n",
       "      <th>Errors Welch's test p-value</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>NN</th>\n",
       "      <td>0.00047120788727595287 \\pm 0.001053153206224986</td>\n",
       "      <td>0.0006458762485694922 \\pm 0.0014301424366343868</td>\n",
       "      <td>4.571809e-23</td>\n",
       "      <td>0.0946 \\pm 0.2926616476410942</td>\n",
       "      <td>0.097 \\pm 0.29595776725742473</td>\n",
       "      <td>2.821133e-01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>SimplifiedKNN</th>\n",
       "      <td>0.04998261343792418 \\pm 0.07151025197073532</td>\n",
       "      <td>0.056842360439837196 \\pm 0.07743769360518381</td>\n",
       "      <td>3.908227e-11</td>\n",
       "      <td>0.3196 \\pm 0.4663216057615173</td>\n",
       "      <td>0.3574 \\pm 0.4792340138178843</td>\n",
       "      <td>8.004115e-09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>KNN</th>\n",
       "      <td>0.0006636913458849759 \\pm 0.0012478295179766522</td>\n",
       "      <td>0.0009820046739182767 \\pm 0.0017408069323029127</td>\n",
       "      <td>5.794395e-50</td>\n",
       "      <td>0.0965 \\pm 0.2952757186088961</td>\n",
       "      <td>0.0983 \\pm 0.29771985153832115</td>\n",
       "      <td>3.338728e-01</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>KDE</th>\n",
       "      <td>0.04250649711393699 \\pm 0.06775728672896837</td>\n",
       "      <td>0.16791270661348326 \\pm 0.11729239544234434</td>\n",
       "      <td>0.000000e+00</td>\n",
       "      <td>0.2612 \\pm 0.4392886977831321</td>\n",
       "      <td>0.427 \\pm 0.494642294997102</td>\n",
       "      <td>8.961766e-137</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                                  CP-fuzziness  \\\n",
       "NN             0.00047120788727595287 \\pm 0.001053153206224986   \n",
       "SimplifiedKNN      0.04998261343792418 \\pm 0.07151025197073532   \n",
       "KNN            0.0006636913458849759 \\pm 0.0012478295179766522   \n",
       "KDE                0.04250649711393699 \\pm 0.06775728672896837   \n",
       "\n",
       "                                                 ICP-fuzziness  \\\n",
       "NN             0.0006458762485694922 \\pm 0.0014301424366343868   \n",
       "SimplifiedKNN     0.056842360439837196 \\pm 0.07743769360518381   \n",
       "KNN            0.0009820046739182767 \\pm 0.0017408069323029127   \n",
       "KDE                0.16791270661348326 \\pm 0.11729239544234434   \n",
       "\n",
       "               Fuzziness Welch's test p-value                      CP-errors  \\\n",
       "NN                               4.571809e-23  0.0946 \\pm 0.2926616476410942   \n",
       "SimplifiedKNN                    3.908227e-11  0.3196 \\pm 0.4663216057615173   \n",
       "KNN                              5.794395e-50  0.0965 \\pm 0.2952757186088961   \n",
       "KDE                              0.000000e+00  0.2612 \\pm 0.4392886977831321   \n",
       "\n",
       "                                   ICP-errors  Errors Welch's test p-value  \n",
       "NN              0.097 \\pm 0.29595776725742473                 2.821133e-01  \n",
       "SimplifiedKNN   0.3574 \\pm 0.4792340138178843                 8.004115e-09  \n",
       "KNN            0.0983 \\pm 0.29771985153832115                 3.338728e-01  \n",
       "KDE               0.427 \\pm 0.494642294997102                8.961766e-137  "
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from scipy.stats import ttest_ind\n",
    "\n",
    "CP_EPS = 0.1\n",
    "NCMs = [\"NN\", \"SimplifiedKNN\", \"KNN\", \"KDE\"]\n",
    "\n",
    "table_results = {\"CP-fuzziness\": [], \"ICP-fuzziness\": [], \"Fuzziness Welch's test p-value\": [],\n",
    "                 \"CP-errors\": [], \"ICP-errors\": [], \"Errors Welch's test p-value\": []}\n",
    "\n",
    "\n",
    "for ncm in NCMs:\n",
    "    pvalue, (fuz_mean_cp, fuz_std_cp, fuz_mean_icp, fuz_std_icp) = \\\n",
    "        compare_cp_icp(results[((results.ncm == ncm + \"_fast\")) & (results.inductive_cp == False)],\n",
    "                       results[((results.ncm == ncm)) & (results.inductive_cp == True)],\n",
    "                       quantity=\"fuzziness\", eps=CP_EPS, real_labels=Ytest)\n",
    "    \n",
    "    table_results[\"CP-fuzziness\"].append(f\"{fuz_mean_cp} \\pm {fuz_std_cp}\")\n",
    "    table_results[\"ICP-fuzziness\"].append(f\"{fuz_mean_icp} \\pm {fuz_std_icp}\")\n",
    "    table_results[\"Fuzziness Welch's test p-value\"].append(pvalue)\n",
    "    \n",
    "    pvalue, (err_mean_cp, err_std_cp, err_mean_icp, err_std_icp) = \\\n",
    "        compare_cp_icp(results[((results.ncm == ncm + \"_fast\")) & (results.inductive_cp == False)],\n",
    "                       results[((results.ncm == ncm)) & (results.inductive_cp == True)],\n",
    "                       quantity=\"errors\", eps=CP_EPS, real_labels=Ytest)\n",
    "    \n",
    "    table_results[\"CP-errors\"].append(f\"{err_mean_cp} \\pm {err_std_cp}\")\n",
    "    table_results[\"ICP-errors\"].append(f\"{err_mean_icp} \\pm {err_std_icp}\")\n",
    "    table_results[\"Errors Welch's test p-value\"].append(pvalue)\n",
    "\n",
    "    \n",
    "\n",
    "table = pd.DataFrame(table_results)\n",
    "table.index = NCMs\n",
    "table"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "jupytext": {
   "formats": "ipynb,md"
  },
  "kernelspec": {
   "display_name": "ml",
   "language": "python",
   "name": "ml"
  },
  "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"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}