dbal_pytorch.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is an implementation of the paper Deep Bayesian Active Learning with Image Data using PyTorch and modAL. \n",
    "\n",
    "modAL is an active learning framework for Python3, designed with modularity, flexibility and extensibility in mind. Built on top of scikit-learn, it allows you to rapidly create active learning workflows with nearly complete freedom. What is more, you can easily replace parts with your custom built solutions, allowing you to design novel algorithms with ease.\n",
    "\n",
    "Since modAL only supports sklearn models, we will also use [skorch](https://skorch.readthedocs.io/en/stable/), a scikit-learn compatible neural network library that wraps PyTorch. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import numpy as np\n",
    "from torch import nn\n",
    "from torch.nn import functional as F\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision.transforms import ToTensor\n",
    "from torchvision.datasets import MNIST\n",
    "from skorch import NeuralNetClassifier\n",
    "from modAL.models import ActiveLearner"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### architecture of the network we will be using\n",
    "\n",
    "We will use the architecture described in the paper."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CNN(nn.Module):\n",
    "    def __init__(self,):\n",
    "        super(CNN, self).__init__()\n",
    "        self.convs = nn.Sequential(\n",
    "                                nn.Conv2d(1,32,4),\n",
    "                                nn.ReLU(),\n",
    "                                nn.Conv2d(32,32,4),\n",
    "                                nn.ReLU(),\n",
    "                                nn.MaxPool2d(2),\n",
    "                                nn.Dropout(0.25)\n",
    "        )\n",
    "        self.fcs = nn.Sequential(\n",
    "                                nn.Linear(11*11*32,128),\n",
    "                                nn.ReLU(),\n",
    "                                nn.Dropout(0.5),\n",
    "                                nn.Linear(128,10),\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        out = x\n",
    "        out = self.convs(out)\n",
    "        out = out.view(-1,11*11*32)\n",
    "        out = self.fcs(out)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### read training data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "0it [00:00, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ./MNIST/raw/train-images-idx3-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "9920512it [00:03, 2906822.66it/s]                            \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ./MNIST/raw/train-images-idx3-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "0it [00:00, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ./MNIST/raw/train-labels-idx1-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "32768it [00:00, 42333.82it/s]                           \n",
      "0it [00:00, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ./MNIST/raw/train-labels-idx1-ubyte.gz\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ./MNIST/raw/t10k-images-idx3-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1654784it [00:02, 770061.63it/s]                            \n",
      "0it [00:00, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ./MNIST/raw/t10k-images-idx3-ubyte.gz\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ./MNIST/raw/t10k-labels-idx1-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "8192it [00:00, 15859.84it/s]            \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting ./MNIST/raw/t10k-labels-idx1-ubyte.gz\n",
      "Processing...\n",
      "Done!\n"
     ]
    }
   ],
   "source": [
    "mnist_train = MNIST('.', train=True, download=True, transform=ToTensor())\n",
    "mnist_test  = MNIST('.', train=False,download=True, transform=ToTensor())\n",
    "traindataloader = DataLoader(mnist_train, shuffle=True, batch_size=60000)\n",
    "testdataloader  = DataLoader(mnist_test , shuffle=True, batch_size=10000)\n",
    "X_train, y_train = next(iter(traindataloader))\n",
    "X_test , y_test  = next(iter(testdataloader))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### preprocessing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = X_train.reshape(60000, 1, 28, 28)\n",
    "X_test = X_test.reshape(10000, 1, 28, 28)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### initial labelled data\n",
    "We initialize the labelled set with 20 balanced randomly sampled examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "initial_idx = np.array([],dtype=np.int)\n",
    "for i in range(10):\n",
    "    idx = np.random.choice(np.where(y_train==i)[0], size=2, replace=False)\n",
    "    initial_idx = np.concatenate((initial_idx, idx))\n",
    "\n",
    "X_initial = X_train[initial_idx]\n",
    "y_initial = y_train[initial_idx]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### initial unlabelled pool"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_pool = np.delete(X_train, initial_idx, axis=0)\n",
    "y_pool = np.delete(y_train, initial_idx, axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Query Strategies"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Uniform\n",
    "All the acquisition function we will use will be compared to the uniform acquisition function $\\mathbb{U}_{[0,1]}$ which will be our baseline that we would like to beat."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def uniform(learner, X, n_instances=1):\n",
    "    query_idx = np.random.choice(range(len(X)), size=n_instances, replace=False)\n",
    "    return query_idx, X[query_idx]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Entropy\n",
    "Our first acquisition function is the entropy:\n",
    "$$ \\mathbb{H} = - \\sum_{c} p_c \\log(p_c)$$\n",
    "where $p_c$ is the probability predicted for class c. This is approximated by:\n",
    "\\begin{align}\n",
    "p_c &= \\frac{1}{T} \\sum_t p_{c}^{(t)} \n",
    "\\end{align}\n",
    "where $p_{c}^{t}$ is the probability predicted for class c at the t th feedforward pass."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "def max_entropy(learner, X, n_instances=1, T=100):\n",
    "    random_subset = np.random.choice(range(len(X)), size=2000, replace=False)\n",
    "    with torch.no_grad():\n",
    "        outputs = np.stack([torch.softmax(learner.estimator.forward(X[random_subset], training=True),dim=-1).cpu().numpy()\n",
    "                            for t in range(100)])\n",
    "    pc = outputs.mean(axis=0)\n",
    "    acquisition = (-pc*np.log(pc + 1e-10)).sum(axis=-1)\n",
    "    idx = (-acquisition).argsort()[:n_instances]\n",
    "    query_idx = random_subset[idx]\n",
    "    return query_idx, X[query_idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bald(learner, X, n_instances=1, T=100):\n",
    "    random_subset = np.random.choice(range(len(X)), size=2000, replace=False)\n",
    "    with torch.no_grad():\n",
    "        outputs = np.stack([torch.softmax(learner.estimator.forward(X[random_subset], training=True),dim=-1).cpu().numpy()\n",
    "                            for t in range(100)])\n",
    "    pc = outputs.mean(axis=0)\n",
    "    H   = (-pc*np.log(pc + 1e-10)).sum(axis=-1)\n",
    "    E_H = - np.mean(np.sum(outputs * np.log(outputs + 1e-10), axis=-1), axis=0)  # [batch size]\n",
    "    acquisition = H - E_H\n",
    "    idx = (-acquisition).argsort()[:n_instances]\n",
    "    query_idx = random_subset[idx]\n",
    "    return query_idx, X[query_idx]    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Active Learning Procedure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "def active_learning_procedure(query_strategy,\n",
    "                              X_test,\n",
    "                              y_test,\n",
    "                              X_pool,\n",
    "                              y_pool,\n",
    "                              X_initial,\n",
    "                              y_initial,\n",
    "                              estimator,\n",
    "                              n_queries=100,\n",
    "                              n_instances=10):\n",
    "    learner = ActiveLearner(estimator=estimator,\n",
    "                            X_training=X_initial,\n",
    "                            y_training=y_initial,\n",
    "                            query_strategy=query_strategy,\n",
    "                           )\n",
    "    perf_hist = [learner.score(X_test, y_test)]\n",
    "    for index in range(n_queries):\n",
    "        query_idx, query_instance = learner.query(X_pool, n_instances)\n",
    "        learner.teach(X_pool[query_idx], y_pool[query_idx])\n",
    "        X_pool = np.delete(X_pool, query_idx, axis=0)\n",
    "        y_pool = np.delete(y_pool, query_idx, axis=0)\n",
    "        model_accuracy = learner.score(X_test, y_test)\n",
    "        print('Accuracy after query {n}: {acc:0.4f}'.format(n=index + 1, acc=model_accuracy))\n",
    "        perf_hist.append(model_accuracy)\n",
    "    return perf_hist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy after query 1: 0.6002\n",
      "Accuracy after query 2: 0.6314\n",
      "Accuracy after query 3: 0.6636\n",
      "Accuracy after query 4: 0.6945\n",
      "Accuracy after query 5: 0.6981\n",
      "Accuracy after query 6: 0.7165\n",
      "Accuracy after query 7: 0.7556\n",
      "Accuracy after query 8: 0.7810\n",
      "Accuracy after query 9: 0.7738\n",
      "Accuracy after query 10: 0.7904\n",
      "Accuracy after query 11: 0.7589\n",
      "Accuracy after query 12: 0.8249\n",
      "Accuracy after query 13: 0.8057\n",
      "Accuracy after query 14: 0.8220\n",
      "Accuracy after query 15: 0.8549\n",
      "Accuracy after query 16: 0.8738\n",
      "Accuracy after query 17: 0.8557\n",
      "Accuracy after query 18: 0.8745\n",
      "Accuracy after query 19: 0.8963\n",
      "Accuracy after query 20: 0.8979\n",
      "Accuracy after query 21: 0.9054\n",
      "Accuracy after query 22: 0.8972\n",
      "Accuracy after query 23: 0.8974\n",
      "Accuracy after query 24: 0.8944\n",
      "Accuracy after query 25: 0.9206\n",
      "Accuracy after query 26: 0.9051\n",
      "Accuracy after query 27: 0.9279\n",
      "Accuracy after query 28: 0.9249\n",
      "Accuracy after query 29: 0.9343\n",
      "Accuracy after query 30: 0.9377\n",
      "Accuracy after query 31: 0.9297\n",
      "Accuracy after query 32: 0.9287\n",
      "Accuracy after query 33: 0.9406\n",
      "Accuracy after query 34: 0.9343\n",
      "Accuracy after query 35: 0.9467\n",
      "Accuracy after query 36: 0.9376\n",
      "Accuracy after query 37: 0.9401\n",
      "Accuracy after query 38: 0.9372\n",
      "Accuracy after query 39: 0.9507\n",
      "Accuracy after query 40: 0.9450\n",
      "Accuracy after query 41: 0.9580\n",
      "Accuracy after query 42: 0.9511\n",
      "Accuracy after query 43: 0.9530\n",
      "Accuracy after query 44: 0.9528\n",
      "Accuracy after query 45: 0.9533\n",
      "Accuracy after query 46: 0.9565\n",
      "Accuracy after query 47: 0.9611\n",
      "Accuracy after query 48: 0.9573\n",
      "Accuracy after query 49: 0.9640\n",
      "Accuracy after query 50: 0.9606\n",
      "Accuracy after query 51: 0.9590\n",
      "Accuracy after query 52: 0.9510\n",
      "Accuracy after query 53: 0.9564\n",
      "Accuracy after query 54: 0.9581\n",
      "Accuracy after query 55: 0.9692\n",
      "Accuracy after query 56: 0.9599\n",
      "Accuracy after query 57: 0.9631\n",
      "Accuracy after query 58: 0.9656\n",
      "Accuracy after query 59: 0.9636\n",
      "Accuracy after query 60: 0.9623\n",
      "Accuracy after query 61: 0.9651\n",
      "Accuracy after query 62: 0.9646\n",
      "Accuracy after query 63: 0.9657\n",
      "Accuracy after query 64: 0.9704\n",
      "Accuracy after query 65: 0.9666\n",
      "Accuracy after query 66: 0.9720\n",
      "Accuracy after query 67: 0.9692\n",
      "Accuracy after query 68: 0.9698\n",
      "Accuracy after query 69: 0.9706\n",
      "Accuracy after query 70: 0.9719\n",
      "Accuracy after query 71: 0.9699\n",
      "Accuracy after query 72: 0.9715\n",
      "Accuracy after query 73: 0.9723\n",
      "Accuracy after query 74: 0.9738\n",
      "Accuracy after query 75: 0.9754\n",
      "Accuracy after query 76: 0.9746\n",
      "Accuracy after query 77: 0.9692\n",
      "Accuracy after query 78: 0.9721\n",
      "Accuracy after query 79: 0.9738\n",
      "Accuracy after query 80: 0.9743\n",
      "Accuracy after query 81: 0.9698\n",
      "Accuracy after query 82: 0.9736\n",
      "Accuracy after query 83: 0.9773\n",
      "Accuracy after query 84: 0.9743\n",
      "Accuracy after query 85: 0.9773\n",
      "Accuracy after query 86: 0.9801\n",
      "Accuracy after query 87: 0.9749\n",
      "Accuracy after query 88: 0.9797\n",
      "Accuracy after query 89: 0.9790\n",
      "Accuracy after query 90: 0.9787\n",
      "Accuracy after query 91: 0.9800\n",
      "Accuracy after query 92: 0.9778\n",
      "Accuracy after query 93: 0.9784\n",
      "Accuracy after query 94: 0.9792\n",
      "Accuracy after query 95: 0.9824\n",
      "Accuracy after query 96: 0.9787\n",
      "Accuracy after query 97: 0.9787\n",
      "Accuracy after query 98: 0.9781\n",
      "Accuracy after query 99: 0.9801\n",
      "Accuracy after query 100: 0.9789\n"
     ]
    }
   ],
   "source": [
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "estimator = NeuralNetClassifier(CNN,\n",
    "                                max_epochs=50,\n",
    "                                batch_size=128,\n",
    "                                lr=0.001,\n",
    "                                optimizer=torch.optim.Adam,\n",
    "                                criterion=torch.nn.CrossEntropyLoss,\n",
    "                                train_split=None,\n",
    "                                verbose=0,\n",
    "                                device=device)\n",
    "entropy_perf_hist = active_learning_procedure(max_entropy,\n",
    "                                              X_test,\n",
    "                                              y_test,\n",
    "                                              X_pool,\n",
    "                                              y_pool,\n",
    "                                              X_initial,\n",
    "                                              y_initial,\n",
    "                                              estimator,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy after query 1: 0.6155\n",
      "Accuracy after query 2: 0.6817\n",
      "Accuracy after query 3: 0.7019\n",
      "Accuracy after query 4: 0.6774\n",
      "Accuracy after query 5: 0.7130\n",
      "Accuracy after query 6: 0.7266\n",
      "Accuracy after query 7: 0.7136\n",
      "Accuracy after query 8: 0.7485\n",
      "Accuracy after query 9: 0.7254\n",
      "Accuracy after query 10: 0.7325\n",
      "Accuracy after query 11: 0.7155\n",
      "Accuracy after query 12: 0.7153\n",
      "Accuracy after query 13: 0.7647\n",
      "Accuracy after query 14: 0.8088\n",
      "Accuracy after query 15: 0.7760\n",
      "Accuracy after query 16: 0.8224\n",
      "Accuracy after query 17: 0.8514\n",
      "Accuracy after query 18: 0.8600\n",
      "Accuracy after query 19: 0.8596\n",
      "Accuracy after query 20: 0.8559\n",
      "Accuracy after query 21: 0.9251\n",
      "Accuracy after query 22: 0.9296\n",
      "Accuracy after query 23: 0.9233\n",
      "Accuracy after query 24: 0.9220\n",
      "Accuracy after query 25: 0.9202\n",
      "Accuracy after query 26: 0.9218\n",
      "Accuracy after query 27: 0.9258\n",
      "Accuracy after query 28: 0.9292\n",
      "Accuracy after query 29: 0.9380\n",
      "Accuracy after query 30: 0.9430\n",
      "Accuracy after query 31: 0.9320\n",
      "Accuracy after query 32: 0.9371\n",
      "Accuracy after query 33: 0.9464\n",
      "Accuracy after query 34: 0.9460\n",
      "Accuracy after query 35: 0.9538\n",
      "Accuracy after query 36: 0.9489\n",
      "Accuracy after query 37: 0.9501\n",
      "Accuracy after query 38: 0.9461\n",
      "Accuracy after query 39: 0.9498\n",
      "Accuracy after query 40: 0.9392\n",
      "Accuracy after query 41: 0.9516\n",
      "Accuracy after query 42: 0.9580\n",
      "Accuracy after query 43: 0.9585\n",
      "Accuracy after query 44: 0.9455\n",
      "Accuracy after query 45: 0.9642\n",
      "Accuracy after query 46: 0.9606\n",
      "Accuracy after query 47: 0.9614\n",
      "Accuracy after query 48: 0.9645\n",
      "Accuracy after query 49: 0.9625\n",
      "Accuracy after query 50: 0.9660\n",
      "Accuracy after query 51: 0.9689\n",
      "Accuracy after query 52: 0.9683\n",
      "Accuracy after query 53: 0.9675\n",
      "Accuracy after query 54: 0.9668\n",
      "Accuracy after query 55: 0.9707\n",
      "Accuracy after query 56: 0.9736\n",
      "Accuracy after query 57: 0.9621\n",
      "Accuracy after query 58: 0.9739\n",
      "Accuracy after query 59: 0.9727\n",
      "Accuracy after query 60: 0.9680\n",
      "Accuracy after query 61: 0.9720\n",
      "Accuracy after query 62: 0.9715\n",
      "Accuracy after query 63: 0.9704\n",
      "Accuracy after query 64: 0.9714\n",
      "Accuracy after query 65: 0.9739\n",
      "Accuracy after query 66: 0.9744\n",
      "Accuracy after query 67: 0.9684\n",
      "Accuracy after query 68: 0.9753\n",
      "Accuracy after query 69: 0.9747\n",
      "Accuracy after query 70: 0.9734\n",
      "Accuracy after query 71: 0.9765\n",
      "Accuracy after query 72: 0.9729\n",
      "Accuracy after query 73: 0.9770\n",
      "Accuracy after query 74: 0.9792\n",
      "Accuracy after query 75: 0.9766\n",
      "Accuracy after query 76: 0.9731\n",
      "Accuracy after query 77: 0.9758\n",
      "Accuracy after query 78: 0.9748\n",
      "Accuracy after query 79: 0.9780\n",
      "Accuracy after query 80: 0.9735\n",
      "Accuracy after query 81: 0.9747\n",
      "Accuracy after query 82: 0.9760\n",
      "Accuracy after query 83: 0.9713\n",
      "Accuracy after query 84: 0.9757\n",
      "Accuracy after query 85: 0.9770\n",
      "Accuracy after query 86: 0.9798\n",
      "Accuracy after query 87: 0.9783\n",
      "Accuracy after query 88: 0.9771\n",
      "Accuracy after query 89: 0.9781\n",
      "Accuracy after query 90: 0.9757\n",
      "Accuracy after query 91: 0.9778\n",
      "Accuracy after query 92: 0.9789\n",
      "Accuracy after query 93: 0.9801\n",
      "Accuracy after query 94: 0.9779\n",
      "Accuracy after query 95: 0.9802\n",
      "Accuracy after query 96: 0.9818\n",
      "Accuracy after query 97: 0.9785\n",
      "Accuracy after query 98: 0.9835\n",
      "Accuracy after query 99: 0.9829\n",
      "Accuracy after query 100: 0.9820\n"
     ]
    }
   ],
   "source": [
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "estimator = NeuralNetClassifier(CNN,\n",
    "                                max_epochs=50,\n",
    "                                batch_size=128,\n",
    "                                lr=0.001,\n",
    "                                optimizer=torch.optim.Adam,\n",
    "                                criterion=torch.nn.CrossEntropyLoss,\n",
    "                                train_split=None,\n",
    "                                verbose=0,\n",
    "                                device=device)\n",
    "bald_perf_hist = active_learning_procedure(bald,\n",
    "                                           X_test,\n",
    "                                           y_test,\n",
    "                                           X_pool,\n",
    "                                           y_pool,\n",
    "                                           X_initial,\n",
    "                                           y_initial,\n",
    "                                           estimator,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy after query 1: 0.5799\n",
      "Accuracy after query 2: 0.6213\n",
      "Accuracy after query 3: 0.6573\n",
      "Accuracy after query 4: 0.7146\n",
      "Accuracy after query 5: 0.6983\n",
      "Accuracy after query 6: 0.7362\n",
      "Accuracy after query 7: 0.7681\n",
      "Accuracy after query 8: 0.7707\n",
      "Accuracy after query 9: 0.7912\n",
      "Accuracy after query 10: 0.7993\n",
      "Accuracy after query 11: 0.8199\n",
      "Accuracy after query 12: 0.8161\n",
      "Accuracy after query 13: 0.8257\n",
      "Accuracy after query 14: 0.8534\n",
      "Accuracy after query 15: 0.8481\n",
      "Accuracy after query 16: 0.8582\n",
      "Accuracy after query 17: 0.8525\n",
      "Accuracy after query 18: 0.8571\n",
      "Accuracy after query 19: 0.8671\n",
      "Accuracy after query 20: 0.8651\n",
      "Accuracy after query 21: 0.7627\n",
      "Accuracy after query 22: 0.8604\n",
      "Accuracy after query 23: 0.8706\n",
      "Accuracy after query 24: 0.8749\n",
      "Accuracy after query 25: 0.8895\n",
      "Accuracy after query 26: 0.8922\n",
      "Accuracy after query 27: 0.8944\n",
      "Accuracy after query 28: 0.8953\n",
      "Accuracy after query 29: 0.8919\n",
      "Accuracy after query 30: 0.8980\n",
      "Accuracy after query 31: 0.9005\n",
      "Accuracy after query 32: 0.9032\n",
      "Accuracy after query 33: 0.8991\n",
      "Accuracy after query 34: 0.8896\n",
      "Accuracy after query 35: 0.8916\n",
      "Accuracy after query 36: 0.9016\n",
      "Accuracy after query 37: 0.9109\n",
      "Accuracy after query 38: 0.9143\n",
      "Accuracy after query 39: 0.9119\n",
      "Accuracy after query 40: 0.9146\n",
      "Accuracy after query 41: 0.9101\n",
      "Accuracy after query 42: 0.9161\n",
      "Accuracy after query 43: 0.9155\n",
      "Accuracy after query 44: 0.9248\n",
      "Accuracy after query 45: 0.9176\n",
      "Accuracy after query 46: 0.9174\n",
      "Accuracy after query 47: 0.9205\n",
      "Accuracy after query 48: 0.9222\n",
      "Accuracy after query 49: 0.9259\n",
      "Accuracy after query 50: 0.9231\n",
      "Accuracy after query 51: 0.9311\n",
      "Accuracy after query 52: 0.9249\n",
      "Accuracy after query 53: 0.9338\n",
      "Accuracy after query 54: 0.9219\n",
      "Accuracy after query 55: 0.9217\n",
      "Accuracy after query 56: 0.9315\n",
      "Accuracy after query 57: 0.9285\n",
      "Accuracy after query 58: 0.9338\n",
      "Accuracy after query 59: 0.9308\n",
      "Accuracy after query 60: 0.9321\n",
      "Accuracy after query 61: 0.9327\n",
      "Accuracy after query 62: 0.9359\n",
      "Accuracy after query 63: 0.9355\n",
      "Accuracy after query 64: 0.9378\n",
      "Accuracy after query 65: 0.9342\n",
      "Accuracy after query 66: 0.9371\n",
      "Accuracy after query 67: 0.9376\n",
      "Accuracy after query 68: 0.9400\n",
      "Accuracy after query 69: 0.9402\n",
      "Accuracy after query 70: 0.9381\n",
      "Accuracy after query 71: 0.9423\n",
      "Accuracy after query 72: 0.9456\n",
      "Accuracy after query 73: 0.9447\n",
      "Accuracy after query 74: 0.9420\n",
      "Accuracy after query 75: 0.9395\n",
      "Accuracy after query 76: 0.9435\n",
      "Accuracy after query 77: 0.9422\n",
      "Accuracy after query 78: 0.9449\n",
      "Accuracy after query 79: 0.9481\n",
      "Accuracy after query 80: 0.9449\n",
      "Accuracy after query 81: 0.9512\n",
      "Accuracy after query 82: 0.9440\n",
      "Accuracy after query 83: 0.9452\n",
      "Accuracy after query 84: 0.9495\n",
      "Accuracy after query 85: 0.9477\n",
      "Accuracy after query 86: 0.9444\n",
      "Accuracy after query 87: 0.9446\n",
      "Accuracy after query 88: 0.9500\n",
      "Accuracy after query 89: 0.9488\n",
      "Accuracy after query 90: 0.9439\n",
      "Accuracy after query 91: 0.9522\n",
      "Accuracy after query 92: 0.9513\n",
      "Accuracy after query 93: 0.9481\n",
      "Accuracy after query 94: 0.9491\n",
      "Accuracy after query 95: 0.9457\n",
      "Accuracy after query 96: 0.9538\n",
      "Accuracy after query 97: 0.9513\n",
      "Accuracy after query 98: 0.9472\n",
      "Accuracy after query 99: 0.9489\n",
      "Accuracy after query 100: 0.9527\n"
     ]
    }
   ],
   "source": [
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "estimator = NeuralNetClassifier(CNN,\n",
    "                                max_epochs=50,\n",
    "                                batch_size=128,\n",
    "                                lr=0.001,\n",
    "                                optimizer=torch.optim.Adam,\n",
    "                                criterion=torch.nn.CrossEntropyLoss,\n",
    "                                train_split=None,\n",
    "                                verbose=0,\n",
    "                                device=device)\n",
    "uniform_perf_hist = active_learning_procedure(uniform,\n",
    "                                              X_test,\n",
    "                                              y_test,\n",
    "                                              X_pool,\n",
    "                                              y_pool,\n",
    "                                              X_initial,\n",
    "                                              y_initial,\n",
    "                                              estimator,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f05220867f0>"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "sns.set()\n",
    "plt.plot(entropy_perf_hist, label=\"entropy\")\n",
    "plt.plot(bald_perf_hist, label=\"bald\")\n",
    "plt.plot(uniform_perf_hist, label=\"uniform\")\n",
    "plt.ylim([0.7,1])\n",
    "plt.legend()"
   ]
  }
 ],
 "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.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}