examples/trustscore_mnist.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Trust Scores applied to MNIST"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is important to know when a machine learning classifier's predictions can be trusted. Relying on the classifier's (uncalibrated) prediction probabilities is not optimal and can be improved upon. *Trust scores* measure the agreement between the classifier and a modified nearest neighbor classifier on the test set. The trust score is the ratio between the distance of the test instance to the nearest class different from the predicted class and the distance to the predicted class. Higher scores correspond to more trustworthy predictions. A score of 1 would mean that the distance to the predicted class is the same as to another class.\n",
    "\n",
    "The original paper on which the algorithm is based is called [To Trust Or Not To Trust A Classifier](https://arxiv.org/abs/1805.11783). Our implementation borrows heavily from https://github.com/google/TrustScore, as does the example notebook.\n",
    "\n",
    "Trust scores work best for low to medium dimensional feature spaces. This notebook illustrates how you can **apply trust scores to high dimensional** data like images by adding an additional pre-processing step in the form of an [auto-encoder](https://en.wikipedia.org/wiki/Autoencoder) to reduce the dimensionality. Other dimension reduction techniques like PCA can be used as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import keras\n",
    "from keras import backend as K\n",
    "from keras.layers import Conv2D, Dense, Dropout, Flatten, MaxPooling2D, Input, UpSampling2D\n",
    "from keras.models import Model\n",
    "from keras.utils import to_categorical\n",
    "import matplotlib\n",
    "%matplotlib inline\n",
    "import matplotlib.cm as cm\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from sklearn.model_selection import StratifiedShuffleSplit\n",
    "from alibi.confidence import TrustScore"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_train shape: (60000, 28, 28) y_train shape: (60000,)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f7fd1e40128>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP8AAAD8CAYAAAC4nHJkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAADO5JREFUeJzt3V2IXfW5x/Hf76QpiOlFYjUMNpqeogerSKKjCMYS9VhyYiEWg9SLkkLJ9CJKCyVU7EVzWaQv1JvAlIbGkmMrpNUoYmNjMQ1qcSJqEmNiElIzMW9lhCaCtNGnF7Nsp3H2f+/st7XH5/uBYfZez3p52Mxv1lp77bX/jggByOe/6m4AQD0IP5AU4QeSIvxAUoQfSIrwA0kRfiApwg8kRfiBpD7Vz43Z5uOEQI9FhFuZr6M9v+1ltvfZPmD7gU7WBaC/3O5n+23PkrRf0h2SxiW9LOneiHijsAx7fqDH+rHnv1HSgYg4FBF/l/RrSSs6WB+APuok/JdKOjLl+Xg17T/YHrE9Znusg20B6LKev+EXEaOSRiUO+4FB0sme/6ikBVOef66aBmAG6CT8L0u6wvbnbX9a0tckbelOWwB6re3D/og4a/s+Sb+XNEvShojY07XOAPRU25f62toY5/xAz/XlQz4AZi7CDyRF+IGkCD+QFOEHkiL8QFKEH0iK8ANJEX4gKcIPJEX4gaQIP5AU4QeSIvxAUoQfSIrwA0kRfiApwg8kRfiBpAg/kBThB5Ii/EBShB9IivADSRF+ICnCDyRF+IGkCD+QFOEHkmp7iG5Jsn1Y0mlJH0g6GxHD3WgKQO91FP7KrRHx1y6sB0AfcdgPJNVp+EPSVts7bY90oyEA/dHpYf+SiDhq+xJJz9p+MyK2T52h+qfAPwZgwDgiurMie52kMxHxo8I83dkYgIYiwq3M1/Zhv+0LbX/mo8eSvixpd7vrA9BfnRz2z5f0O9sfref/I+KZrnQFoOe6dtjf0sY47Ad6rueH/QBmNsIPJEX4gaQIP5AU4QeSIvxAUt24qy+FlStXNqytXr26uOw777xTrL///vvF+qZNm4r148ePN6wdOHCguCzyYs8PJEX4gaQIP5AU4QeSIvxAUoQfSIrwA0lxS2+LDh061LC2cOHC/jUyjdOnTzes7dmzp4+dDJbx8fGGtYceeqi47NjYWLfb6Rtu6QVQRPiBpAg/kBThB5Ii/EBShB9IivADSXE/f4tK9+xfe+21xWX37t1brF911VXF+nXXXVesL126tGHtpptuKi575MiRYn3BggXFeifOnj1brJ86dapYHxoaanvbb7/9drE+k6/zt4o9P5AU4QeSIvxAUoQfSIrwA0kRfiApwg8k1fR+ftsbJH1F0smIuKaaNk/SbyQtlHRY0j0R8W7Tjc3g+/kH2dy5cxvWFi1aVFx2586dxfoNN9zQVk+taDZewf79+4v1Zp+fmDdvXsPamjVrisuuX7++WB9k3byf/5eSlp0z7QFJ2yLiCknbqucAZpCm4Y+I7ZImzpm8QtLG6vFGSXd1uS8APdbuOf/8iDhWPT4uaX6X+gHQJx1/tj8ionQub3tE0kin2wHQXe3u+U/YHpKk6vfJRjNGxGhEDEfEcJvbAtAD7YZ/i6RV1eNVkp7oTjsA+qVp+G0/KulFSf9je9z2NyX9UNIdtt+S9L/VcwAzCN/bj4F19913F+uPPfZYsb579+6GtVtvvbW47MTEuRe4Zg6+tx9AEeEHkiL8QFKEH0iK8ANJEX4gKS71oTaXXHJJsb5r166Oll+5cmXD2ubNm4vLzmRc6gNQRPiBpAg/kBThB5Ii/EBShB9IivADSTFEN2rT7OuzL7744mL93XfL3xa/b9++8+4pE/b8QFKEH0iK8ANJEX4gKcIPJEX4gaQIP5AU9/Ojp26++eaGteeee6647OzZs4v1pUuXFuvbt28v1j+puJ8fQBHhB5Ii/EBShB9IivADSRF+ICnCDyTV9H5+2xskfUXSyYi4ppq2TtJqSaeq2R6MiKd71SRmruXLlzesNbuOv23btmL9xRdfbKsnTGplz/9LScummf7TiFhU/RB8YIZpGv6I2C5pog+9AOijTs7577P9uu0Ntud2rSMAfdFu+NdL+oKkRZKOSfpxoxltj9gesz3W5rYA9EBb4Y+IExHxQUR8KOnnkm4szDsaEcMRMdxukwC6r63w2x6a8vSrknZ3px0A/dLKpb5HJS2V9Fnb45J+IGmp7UWSQtJhSd/qYY8AeoD7+dGRCy64oFjfsWNHw9rVV19dXPa2224r1l944YViPSvu5wdQRPiBpAg/kBThB5Ii/EBShB9IiiG60ZG1a9cW64sXL25Ye+aZZ4rLcimvt9jzA0kRfiApwg8kRfiBpAg/kBThB5Ii/EBS3NKLojvvvLNYf/zxx4v19957r2Ft2bLpvhT631566aViHdPjll4ARYQfSIrwA0kRfiApwg8kRfiBpAg/kBT38yd30UUXFesPP/xwsT5r1qxi/emnGw/gzHX8erHnB5Ii/EBShB9IivADSRF+ICnCDyRF+IGkmt7Pb3uBpEckzZcUkkYj4me250n6jaSFkg5Luici3m2yLu7n77Nm1+GbXWu//vrri/WDBw8W66V79psti/Z0837+s5K+GxFflHSTpDW2vyjpAUnbIuIKSduq5wBmiKbhj4hjEfFK9fi0pL2SLpW0QtLGaraNku7qVZMAuu+8zvltL5S0WNKfJc2PiGNV6bgmTwsAzBAtf7bf9hxJmyV9JyL+Zv/7tCIiotH5vO0RSSOdNgqgu1ra89uercngb4qI31aTT9gequpDkk5Ot2xEjEbEcEQMd6NhAN3RNPye3MX/QtLeiPjJlNIWSauqx6skPdH99gD0SiuX+pZI+pOkXZI+rCY/qMnz/sckXSbpL5q81DfRZF1c6uuzK6+8slh/8803O1r/ihUrivUnn3yyo/Xj/LV6qa/pOX9E7JDUaGW3n09TAAYHn/ADkiL8QFKEH0iK8ANJEX4gKcIPJMVXd38CXH755Q1rW7du7Wjda9euLdafeuqpjtaP+rDnB5Ii/EBShB9IivADSRF+ICnCDyRF+IGkuM7/CTAy0vhb0i677LKO1v38888X682+DwKDiz0/kBThB5Ii/EBShB9IivADSRF+ICnCDyTFdf4ZYMmSJcX6/fff36dO8EnCnh9IivADSRF+ICnCDyRF+IGkCD+QFOEHkmp6nd/2AkmPSJovKSSNRsTPbK+TtFrSqWrWByPi6V41mtktt9xSrM+ZM6ftdR88eLBYP3PmTNvrxmBr5UM+ZyV9NyJesf0ZSTttP1vVfhoRP+pdewB6pWn4I+KYpGPV49O290q6tNeNAeit8zrnt71Q0mJJf64m3Wf7ddsbbM9tsMyI7THbYx11CqCrWg6/7TmSNkv6TkT8TdJ6SV+QtEiTRwY/nm65iBiNiOGIGO5CvwC6pKXw256tyeBviojfSlJEnIiIDyLiQ0k/l3Rj79oE0G1Nw2/bkn4haW9E/GTK9KEps31V0u7utwegV1p5t/9mSV+XtMv2q9W0ByXda3uRJi//HZb0rZ50iI689tprxfrtt99erE9MTHSzHQyQVt7t3yHJ05S4pg/MYHzCD0iK8ANJEX4gKcIPJEX4gaQIP5CU+znEsm3GcwZ6LCKmuzT/Mez5gaQIP5AU4QeSIvxAUoQfSIrwA0kRfiCpfg/R/VdJf5ny/LPVtEE0qL0Nal8SvbWrm71d3uqMff2Qz8c2bo8N6nf7DWpvg9qXRG/tqqs3DvuBpAg/kFTd4R+tefslg9rboPYl0Vu7aumt1nN+APWpe88PoCa1hN/2Mtv7bB+w/UAdPTRi+7DtXbZfrXuIsWoYtJO2d0+ZNs/2s7bfqn5PO0xaTb2ts320eu1etb28pt4W2P6j7Tds77H97Wp6ra9doa9aXre+H/bbniVpv6Q7JI1LelnSvRHxRl8bacD2YUnDEVH7NWHbX5J0RtIjEXFNNe0hSRMR8cPqH+fciPjegPS2TtKZukdurgaUGZo6srSkuyR9QzW+doW+7lENr1sde/4bJR2IiEMR8XdJv5a0ooY+Bl5EbJd07qgZKyRtrB5v1OQfT9816G0gRMSxiHilenxa0kcjS9f62hX6qkUd4b9U0pEpz8c1WEN+h6SttnfaHqm7mWnMr4ZNl6TjkubX2cw0mo7c3E/njCw9MK9dOyNedxtv+H3ckoi4TtL/SVpTHd4OpJg8ZxukyzUtjdzcL9OMLP0vdb527Y543W11hP+opAVTnn+umjYQIuJo9fukpN9p8EYfPvHRIKnV75M19/MvgzRy83QjS2sAXrtBGvG6jvC/LOkK25+3/WlJX5O0pYY+Psb2hdUbMbJ9oaQva/BGH94iaVX1eJWkJ2rs5T8MysjNjUaWVs2v3cCNeB0Rff+RtFyT7/gflPT9Onpo0Nd/S3qt+tlTd2+SHtXkYeA/NPneyDclXSRpm6S3JP1B0rwB6u1XknZJel2TQRuqqbclmjykf13Sq9XP8rpfu0JftbxufMIPSIo3/ICkCD+QFOEHkiL8QFKEH0iK8ANJEX4gKcIPJPVP82g/p9/JjhUAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()\n",
    "print('x_train shape:', x_train.shape, 'y_train shape:', y_train.shape)\n",
    "plt.gray()\n",
    "plt.imshow(x_test[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prepare data: scale, reshape and categorize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_train shape: (60000, 28, 28, 1) x_test shape: (10000, 28, 28, 1)\n",
      "y_train shape: (60000, 10) y_test shape: (10000, 10)\n"
     ]
    }
   ],
   "source": [
    "x_train = x_train.astype('float32') / 255\n",
    "x_test = x_test.astype('float32') / 255\n",
    "x_train = np.reshape(x_train, x_train.shape + (1,))\n",
    "x_test = np.reshape(x_test, x_test.shape + (1,))\n",
    "print('x_train shape:', x_train.shape, 'x_test shape:', x_test.shape)\n",
    "y_train = to_categorical(y_train)\n",
    "y_test = to_categorical(y_test)\n",
    "print('y_train shape:', y_train.shape, 'y_test shape:', y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "xmin, xmax = -.5, .5\n",
    "x_train = ((x_train - x_train.min()) / (x_train.max() - x_train.min())) * (xmax - xmin) + xmin\n",
    "x_test = ((x_test - x_test.min()) / (x_test.max() - x_test.min())) * (xmax - xmin) + xmin"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define and train model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For this example we are not interested in optimizing model performance so a simple softmax classifier will do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sc_model():\n",
    "    x_in = Input(shape=(28, 28, 1))\n",
    "    x = Flatten()(x_in)\n",
    "    x_out = Dense(10, activation='softmax')(x)\n",
    "    sc = Model(inputs=x_in, outputs=x_out)\n",
    "    sc.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy'])\n",
    "    return sc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_1 (InputLayer)         (None, 28, 28, 1)         0         \n",
      "_________________________________________________________________\n",
      "flatten_1 (Flatten)          (None, 784)               0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 10)                7850      \n",
      "=================================================================\n",
      "Total params: 7,850\n",
      "Trainable params: 7,850\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x7f7fd1e13630>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sc = sc_model()\n",
    "sc.summary()\n",
    "sc.fit(x_train, y_train, batch_size=128, epochs=5, verbose=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Evaluate the model on the test set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy:  0.8862\n"
     ]
    }
   ],
   "source": [
    "score = sc.evaluate(x_test, y_test, verbose=0)\n",
    "print('Test accuracy: ', score[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define and train auto-encoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ae_model():\n",
    "    # encoder\n",
    "    x_in = Input(shape=(28, 28, 1))\n",
    "    x = Conv2D(16, (3, 3), activation='relu', padding='same')(x_in)\n",
    "    x = MaxPooling2D((2, 2), padding='same')(x)\n",
    "    x = Conv2D(8, (3, 3), activation='relu', padding='same')(x)\n",
    "    x = MaxPooling2D((2, 2), padding='same')(x)\n",
    "    x = Conv2D(4, (3, 3), activation=None, padding='same')(x)\n",
    "    encoded = MaxPooling2D((2, 2), padding='same')(x)\n",
    "    encoder = Model(x_in, encoded)\n",
    "\n",
    "    # decoder\n",
    "    dec_in = Input(shape=(4, 4, 4))\n",
    "    x = Conv2D(4, (3, 3), activation='relu', padding='same')(dec_in)\n",
    "    x = UpSampling2D((2, 2))(x)\n",
    "    x = Conv2D(8, (3, 3), activation='relu', padding='same')(x)\n",
    "    x = UpSampling2D((2, 2))(x)\n",
    "    x = Conv2D(16, (3, 3), activation='relu')(x)\n",
    "    x = UpSampling2D((2, 2))(x)\n",
    "    decoded = Conv2D(1, (3, 3), activation=None, padding='same')(x)\n",
    "    decoder = Model(dec_in, decoded)\n",
    "    \n",
    "    # autoencoder = encoder + decoder\n",
    "    x_out = decoder(encoder(x_in))\n",
    "    autoencoder = Model(x_in, x_out)\n",
    "    autoencoder.compile(optimizer='adam', loss='mse')\n",
    "    \n",
    "    return autoencoder, encoder, decoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_2 (InputLayer)         (None, 28, 28, 1)         0         \n",
      "_________________________________________________________________\n",
      "model_2 (Model)              (None, 4, 4, 4)           1612      \n",
      "_________________________________________________________________\n",
      "model_3 (Model)              (None, 28, 28, 1)         1757      \n",
      "=================================================================\n",
      "Total params: 3,369\n",
      "Trainable params: 3,369\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x7f7fd24cd5c0>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ae, enc, dec = ae_model()\n",
    "ae.summary()\n",
    "ae.fit(x_train, x_train, batch_size=128, epochs=8, validation_data=(x_test, x_test), verbose=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculate Trust Scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initialize trust scores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "ts = TrustScore()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The key is to **fit and calculate the trust scores on the encoded instances**. The encoded data still needs to be reshaped from (60000, 4, 4, 4) to (60000, 64) to comply with the k-d tree format. This is handled internally:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Reshaping data from (60000, 4, 4, 4) to (60000, 64) so k-d trees can be built.\n"
     ]
    }
   ],
   "source": [
    "x_train_enc = enc.predict(x_train)\n",
    "ts.fit(x_train_enc, y_train, classes=10)  # 10 classes present in MNIST"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now calculate the trust scores and closest not predicted classes of the predictions on the test set, using the distance to the 5th nearest neighbor in each class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Reshaping data from (10000, 4, 4, 4) to (10000, 64) so k-d trees can be queried.\n"
     ]
    }
   ],
   "source": [
    "x_test_enc = enc.predict(x_test)\n",
    "y_pred = sc.predict(x_test)\n",
    "score, closest_class = ts.score(x_test_enc, y_pred, k=5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's inspect which predictions have low and high trust scores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 5\n",
    "idx_min, idx_max = np.argsort(score)[:n], np.argsort(score)[-n:]\n",
    "score_min, score_max = score[idx_min], score[idx_max]\n",
    "closest_min, closest_max = closest_class[idx_min], closest_class[idx_max]\n",
    "pred_min, pred_max = np.argmax(y_pred[idx_min], axis=1), np.argmax(y_pred[idx_max], axis=1)\n",
    "imgs_min, imgs_max = x_test[idx_min], x_test[idx_max]\n",
    "label_min, label_max = np.argmax(y_test[idx_min], axis=1), np.argmax(y_test[idx_max], axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Low Trust Scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The image below makes clear that the low trust scores correspond to misclassified images. Because the trust scores are significantly below 1, they correctly identified that the images belong to another class than the predicted class, and identified that class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x288 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(20, 4))\n",
    "for i in range(n):\n",
    "    ax = plt.subplot(1, n, i+1)\n",
    "    plt.imshow(imgs_min[i].reshape(28, 28))\n",
    "    plt.title('Model prediction: {} \\n Label: {} \\n Trust score: {:.3f}' \\\n",
    "              '\\n Closest other class: {}'.format(pred_min[i], label_min[i], score_min[i], closest_min[i]))\n",
    "    ax.get_xaxis().set_visible(False)\n",
    "    ax.get_yaxis().set_visible(False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### High Trust Scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The high trust scores on the other hand all are very clear 1's:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x288 with 5 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(20, 4))\n",
    "for i in range(n):\n",
    "    ax = plt.subplot(1, n, i+1)\n",
    "    plt.imshow(imgs_max[i].reshape(28, 28))\n",
    "    plt.title('Model prediction: {} \\n Label: {} \\n Trust score: {:.3f}'.format(pred_max[i], label_max[i], score_max[i]))\n",
    "    ax.get_xaxis().set_visible(False)\n",
    "    ax.get_yaxis().set_visible(False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparison of Trust Scores with model prediction probabilities"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s compare the prediction probabilities from the classifier with the trust scores for each prediction by checking whether trust scores are better than the model’s prediction probabilities at identifying correctly classified examples.\n",
    "\n",
    "First we need to set up a couple of helper functions.\n",
    "\n",
    "* Define a function that handles model training and predictions:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_sc(X_train, y_train, X_test):\n",
    "    clf = sc_model()\n",
    "    clf.fit(X_train, y_train, batch_size=128, epochs=5, verbose=0)\n",
    "    y_pred_proba = clf.predict(X_test)\n",
    "    y_pred = np.argmax(y_pred_proba, axis=1)\n",
    "    probas = y_pred_proba[range(len(y_pred)), y_pred]  # probabilities of predicted class\n",
    "    return y_pred, probas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Define the function that generates the precision plots:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_precision_curve(plot_title, \n",
    "                         percentiles, \n",
    "                         labels, \n",
    "                         final_tp, \n",
    "                         final_stderr, \n",
    "                         final_misclassification,\n",
    "                         colors = ['blue', 'darkorange', 'brown', 'red', 'purple']):\n",
    "    \n",
    "    plt.title(plot_title, fontsize=18)\n",
    "    colors = colors + list(cm.rainbow(np.linspace(0, 1, len(final_tp))))\n",
    "    plt.xlabel(\"Percentile\", fontsize=14)\n",
    "    plt.ylabel(\"Precision\", fontsize=14)\n",
    "    \n",
    "    for i, label in enumerate(labels):\n",
    "        ls = \"--\" if (\"Model\" in label) else \"-\"\n",
    "        plt.plot(percentiles, final_tp[i], ls, c=colors[i], label=label)\n",
    "        plt.fill_between(percentiles, \n",
    "                         final_tp[i] - final_stderr[i],\n",
    "                         final_tp[i] + final_stderr[i],\n",
    "                         color=colors[i],\n",
    "                         alpha=.1)\n",
    "    \n",
    "    if 0. in percentiles:\n",
    "        plt.legend(loc=\"lower right\", fontsize=14)\n",
    "    else:\n",
    "        plt.legend(loc=\"upper left\", fontsize=14)\n",
    "    model_acc = 100 * (1 - final_misclassification)\n",
    "    plt.axvline(x=model_acc, linestyle=\"dotted\", color=\"black\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The function below trains the model on a number of folds, makes predictions, calculates the trust scores, and generates the precision curves to compare the trust scores with the model prediction probabilities:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_precision_plt(X, y, nfolds, percentiles, run_model, test_size=.2, \n",
    "                      plt_title=\"\", plt_names=[], predict_correct=True, classes=10):\n",
    "    \n",
    "    def stderr(L):\n",
    "        return np.std(L) / np.sqrt(len(L))\n",
    "    \n",
    "    all_tp = [[[] for p in percentiles] for _ in plt_names]\n",
    "    misclassifications = []\n",
    "    mult = 1 if predict_correct else -1\n",
    "    \n",
    "    folds = StratifiedShuffleSplit(n_splits=nfolds, test_size=test_size, random_state=0)\n",
    "    for train_idx, test_idx in folds.split(X, y):\n",
    "        # create train and test folds, train model and make predictions\n",
    "        X_train, y_train = X[train_idx, :], y[train_idx, :]\n",
    "        X_test, y_test = X[test_idx, :], y[test_idx, :]\n",
    "        y_pred, probas = run_sc(X_train, y_train, X_test)\n",
    "        # target points are the correctly classified points\n",
    "        y_test_class = np.argmax(y_test, axis=1)\n",
    "        target_points = (np.where(y_pred == y_test_class)[0] if predict_correct else \n",
    "                         np.where(y_pred != y_test_class)[0])\n",
    "        final_curves = [probas]\n",
    "        # calculate trust scores\n",
    "        ts = TrustScore()\n",
    "        ts.fit(enc.predict(X_train), y_train, classes=classes)\n",
    "        scores, _ = ts.score(enc.predict(X_test), y_pred, k=5)\n",
    "        final_curves.append(scores)  # contains prediction probabilities and trust scores\n",
    "        # check where prediction probabilities and trust scores are above a certain percentage level\n",
    "        for p, perc in enumerate(percentiles):\n",
    "            high_proba = [np.where(mult * curve >= np.percentile(mult * curve, perc))[0] for curve in final_curves]\n",
    "            if 0 in map(len, high_proba):\n",
    "                continue\n",
    "            # calculate fraction of values above percentage level that are correctly (or incorrectly) classified\n",
    "            tp = [len(np.intersect1d(hp, target_points)) / (1. * len(hp)) for hp in high_proba]\n",
    "            for i in range(len(plt_names)):\n",
    "                all_tp[i][p].append(tp[i])  # for each percentile, store fraction of values above cutoff value\n",
    "        misclassifications.append(len(target_points) / (1. * len(X_test)))\n",
    "    \n",
    "    # average over folds for each percentile\n",
    "    final_tp = [[] for _ in plt_names]\n",
    "    final_stderr = [[] for _ in plt_names]\n",
    "    for p, perc in enumerate(percentiles):\n",
    "        for i in range(len(plt_names)):\n",
    "            final_tp[i].append(np.mean(all_tp[i][p]))\n",
    "            final_stderr[i].append(stderr(all_tp[i][p]))\n",
    "\n",
    "    for i in range(len(all_tp)):\n",
    "        final_tp[i] = np.array(final_tp[i])\n",
    "        final_stderr[i] = np.array(final_stderr[i])\n",
    "\n",
    "    final_misclassification = np.mean(misclassifications)\n",
    "    \n",
    "    # create plot\n",
    "    plot_precision_curve(plt_title, percentiles, plt_names, final_tp, final_stderr, final_misclassification)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Detect correctly classified examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The x-axis on the plot below shows the percentiles for the model prediction probabilities of the predicted class for each instance and for the trust scores. The y-axis represents the precision for each percentile. For each percentile level, we take the test examples whose trust score is above that percentile level and plot the percentage of those points that were correctly classified by the classifier. We do the same with the classifier’s own model confidence (i.e. softmax probabilities). For example, at percentile level 80, we take the top 20% scoring test examples based on the trust score and plot the percentage of those points that were correctly classified. We also plot the top 20% scoring test examples based on model probabilities and plot the percentage of those that were correctly classified. The vertical dotted line is the error of the classifier. The plots are an average over 2 folds of the dataset with 20% of the data kept for the test set.\n",
    "\n",
    "The *Trust Score* and *Model Confidence* curves then show that the model precision is typically higher when using the trust scores to rank the predictions compared to the model prediction probabilities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = x_train\n",
    "y = y_train\n",
    "percentiles = [0 + 0.5 * i for i in range(200)]\n",
    "nfolds = 2\n",
    "plt_names = ['Model Confidence', 'Trust Score']\n",
    "plt_title = 'MNIST -- Softmax Classifier -- Predict Correct'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Reshaping data from (48000, 4, 4, 4) to (48000, 64) so k-d trees can be built.\n",
      "Reshaping data from (12000, 4, 4, 4) to (12000, 64) so k-d trees can be queried.\n",
      "Reshaping data from (48000, 4, 4, 4) to (48000, 64) so k-d trees can be built.\n",
      "Reshaping data from (12000, 4, 4, 4) to (12000, 64) so k-d trees can be queried.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "run_precision_plt(X, y, nfolds, percentiles, run_sc, plt_title=plt_title, \n",
    "                  plt_names=plt_names, predict_correct=True)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}