MNIST_Neuron2ProjectionCoverage_TestGen.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Neuron 2-projection on-off activation coverage and test gen (1) - MNIST CNN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Start by fixing the random seed to ensure reproducability. In all our examples, we use 42. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy.random\n",
    "# Fix the number for repeatability (we have also stored the trained model)\n",
    "numpy.random.seed(42)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Put these at the top of every notebook, to get automatic reloading and inline plotting\n",
    "%reload_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Import all required library, and set the device."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "\n",
    "import numpy as np\n",
    "import h5py\n",
    "import scipy.misc\n",
    "import math\n",
    "import matplotlib.pyplot as plt\n",
    "from torch.autograd  import Variable\n",
    "from torch.autograd.gradcheck import zero_gradients\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "\n",
    "import torchvision.transforms as T\n",
    "from torchvision.models.inception import inception_v3\n",
    "\n",
    "from PIL import Image\n",
    "from scipy.misc import imsave\n",
    "import os\n",
    "\n",
    "\n",
    "# Device configuration\n",
    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define hyper-parameters. The parameter \"sizeOfNeuronsToMonitor\" is the number of neurons we will monitor, which is the 2nd to last layer. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Hyper-parameters \n",
    "num_classes = 10\n",
    "num_epochs = 5\n",
    "batch_size = 64\n",
    "learning_rate = 0.001\n",
    "sizeOfNeuronsToMonitor = 40"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then , prepare the training and test set. MNIST can be directly downloaded. Notice that we do not normalize the input data, but just rely on small learning rates. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# MNIST dataset \n",
    "train_dataset = torchvision.datasets.MNIST(root='data/mnist', \n",
    "                                           train=True, \n",
    "                                           transform=transforms.ToTensor(),  \n",
    "                                           download=True)\n",
    "\n",
    "test_dataset = torchvision.datasets.MNIST(root='data/mnist', \n",
    "                                          train=False, \n",
    "                                          transform=transforms.ToTensor())\n",
    "\n",
    "# Data loader\n",
    "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, \n",
    "                                           batch_size=batch_size, \n",
    "                                           shuffle=True)\n",
    "\n",
    "test_loader = torch.utils.data.DataLoader(dataset=test_dataset, \n",
    "                                          batch_size=batch_size, \n",
    "                                          shuffle=False)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Define a utility function to display MNIST images. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import util\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 108x108 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "dataiter = iter(train_loader)\n",
    "images, labels = dataiter.next()\n",
    "\n",
    "util.displayMNIST(images[0].numpy())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Prepare the network \n",
    "\n",
    "To use run-time monitoring, apart from standard \"forward()\" function, we additionally define another function to return values of intermediate layers. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "class NeuralNet(nn.Module):\n",
    "    \n",
    "    def __init__(self):\n",
    "        super(NeuralNet, self).__init__()\n",
    " \n",
    "        self.conv1 = nn.Conv2d(1, 40, 5)\n",
    "        self.pool = nn.MaxPool2d(2, 2)\n",
    "        self.conv2 = nn.Conv2d(40, 20, 5)\n",
    "        self.fc1 = nn.Linear(20 * 4 * 4, 160)\n",
    "        self.fc2 = nn.Linear(160, 80)\n",
    "        self.fc3 = nn.Linear(80, sizeOfNeuronsToMonitor)\n",
    "        self.fc4 = nn.Linear(sizeOfNeuronsToMonitor, num_classes)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        # Original 28x28x1 -(conv)-> 24x24x40 -(pool)-> 12x12x40\n",
    "        x = self.pool(F.relu(self.conv1(x)))\n",
    "        # Original 12x12x40 -(conv)-> 8x8x20 -(pool)-> 4x4x20\n",
    "        x = self.pool(F.relu(self.conv2(x)))\n",
    "        # Flatten it to an array of inputs\n",
    "        x = x.view(-1, 20 * 4 * 4)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = F.relu(self.fc3(x))\n",
    "        out = self.fc4(x)\n",
    "        return out \n",
    "  \n",
    "    # Here we add another function, which does the same forward computation but also extracts intermediate layer results\n",
    "    def forwardWithIntermediate(self, x):\n",
    "        x = self.pool(F.relu(self.conv1(x)))\n",
    "        x = self.pool(F.relu(self.conv2(x)))\n",
    "        x = x.view(-1, 20 * 4 * 4)\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        x = self.fc3(x)\n",
    "        intermediateValues = x\n",
    "        x = F.relu(x)\n",
    "        out = self.fc4(x)\n",
    "        return out, intermediateValues    \n",
    "    \n",
    "net = NeuralNet()\n",
    "net.eval()\n",
    "\n",
    "# Loss and optimizer\n",
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(net.parameters(), lr=learning_rate)  \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load the model (if you have a pretrained one)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setup model to be attacked\n",
    "# net = NeuralNet()\n",
    "net.load_state_dict(torch.load('models/1_model_MNIST_CNN.ckpt'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Train the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "furtherTrain = False\n",
    "\n",
    "if furtherTrain: \n",
    "\n",
    "    # Train the model\n",
    "    total_step = len(train_loader)\n",
    "    for epoch in range(num_epochs):\n",
    "        for i, (images, labels) in enumerate(train_loader):  \n",
    "            # Move tensors to the configured device\n",
    "            labels = labels.to(device)\n",
    "\n",
    "            # Forward pass\n",
    "            outputs = net(images)\n",
    "            loss = criterion(outputs, labels)\n",
    "\n",
    "            # Backward and optimize\n",
    "            optimizer.zero_grad()\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "\n",
    "            if (i+1) % 100 == 0:\n",
    "                print ('Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}' \n",
    "                       .format(epoch+1, num_epochs, i+1, total_step, loss.item()))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compute accuracy on the test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This may take a while ...\n",
      "Accuracy of the network on the 10000 test images: 98.81 %\n"
     ]
    }
   ],
   "source": [
    "# In test phase, we don't need to compute gradients (for memory efficiency)\n",
    "\n",
    "with torch.no_grad():\n",
    "    correct = 0\n",
    "    outofActivationPattern = 0\n",
    "    outofActivationPatternAndResultWrong = 0\n",
    "    \n",
    "    print('This may take a while ...')\n",
    "    total = 0\n",
    "    for images, labels in test_loader:\n",
    "        labels = labels.to(device)\n",
    "        outputs = net(images)\n",
    "        _, predicted = torch.max(outputs.data, 1)\n",
    "        total += labels.size(0)\n",
    "        correct += (predicted == labels).sum().item()\n",
    "        \n",
    "\n",
    "    print('Accuracy of the network on the 10000 test images: {} %'.format(100 * correct / total))\n",
    "     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Trigger 2-projection neuron on-off activation coverage computation\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nndependability.metrics import NeuronKProjection\n",
    "\n",
    "k_Value = 2\n",
    "\n",
    "metric = NeuronKProjection.Neuron_OnOff_KProjection_Metric(k_Value, sizeOfNeuronsToMonitor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trigger the function addInputs() to update the k-projection table based on all visited patterns for each batch. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Computing 2-projection neuron on-off activation coverage ...\n",
      "\n",
      "Current input size fed into the metric: 64\n",
      "2-projection neuron on-off activation coverage:2744/3120=0.8794871794871795\n",
      "\n",
      "\n",
      "Computing 2-projection neuron on-off activation coverage ...\n",
      "\n",
      "Current input size fed into the metric: 3264\n",
      "2-projection neuron on-off activation coverage:2871/3120=0.9201923076923076\n",
      "\n",
      "\n",
      "Computing 2-projection neuron on-off activation coverage ...\n",
      "\n",
      "Current input size fed into the metric: 6464\n",
      "2-projection neuron on-off activation coverage:2913/3120=0.9336538461538462\n",
      "\n",
      "\n",
      "Computing 2-projection neuron on-off activation coverage ...\n",
      "\n",
      " ... early stopping for DEMO.\n"
     ]
    }
   ],
   "source": [
    "with torch.no_grad():\n",
    "\n",
    "    total = 0\n",
    "    i = 0\n",
    "    print('Computing 2-projection neuron on-off activation coverage ...')\n",
    "    print('')\n",
    "    for images, labels in train_loader:\n",
    "        \n",
    "        total = total + (len(labels))\n",
    "        labels = labels.to(device)\n",
    "        outputs, intermediateValues = net.forwardWithIntermediate(images)\n",
    "        \n",
    "        # Add the batch of neuron activation patterns to the k-projection table\n",
    "        metric.addInputs(intermediateValues.numpy())\n",
    "                \n",
    "        if(i % 50) == 0:\n",
    "            print('Current input size fed into the metric: '+str(total))\n",
    "            metric.printMetricQuantity()\n",
    "            print(\"\\n\")\n",
    "            print('Computing 2-projection neuron on-off activation coverage ...')\n",
    "            print('')\n",
    "        i = i+1\n",
    "        if i > 100:\n",
    "            print(' ... early stopping for DEMO.')\n",
    "            break\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2-projection neuron on-off activation coverage:2903/3120=0.930448717948718\n"
     ]
    }
   ],
   "source": [
    "metric.printMetricQuantity()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(Optional) Now, ask the test case generator to derive us a pattern which maximally increases 2-projection coverage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nndependability.atg.nap import napgen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum possibility for improvement = 217\n",
      "Optimal objective value computed from IP = 137\n",
      "\n",
      "for neuron 0, set it to 1\n",
      "for neuron 1, set it to 1\n",
      "for neuron 2, set it to 1\n",
      "for neuron 3, set it to 1\n",
      "for neuron 4, set it to 0\n",
      "for neuron 5, set it to 0\n",
      "for neuron 6, set it to 1\n",
      "for neuron 7, set it to 0\n",
      "for neuron 8, set it to 0\n",
      "for neuron 9, set it to 0\n",
      "for neuron 10, set it to 0\n",
      "for neuron 11, set it to 1\n",
      "for neuron 12, set it to 0\n",
      "for neuron 13, set it to 1\n",
      "for neuron 14, set it to 1\n",
      "for neuron 15, set it to 0\n",
      "for neuron 16, set it to 0\n",
      "for neuron 17, set it to 1\n",
      "for neuron 18, set it to 1\n",
      "for neuron 19, set it to 0\n",
      "for neuron 20, set it to 0\n",
      "for neuron 21, set it to 0\n",
      "for neuron 22, set it to 1\n",
      "for neuron 23, set it to 0\n",
      "for neuron 24, set it to 1\n",
      "for neuron 25, set it to 0\n",
      "for neuron 26, set it to 0\n",
      "for neuron 27, set it to 0\n",
      "for neuron 28, set it to 0\n",
      "for neuron 29, set it to 1\n",
      "for neuron 30, set it to 0\n",
      "for neuron 31, set it to 1\n",
      "for neuron 32, set it to 1\n",
      "for neuron 33, set it to 0\n",
      "for neuron 34, set it to 1\n",
      "for neuron 35, set it to 0\n",
      "for neuron 36, set it to 0\n",
      "for neuron 37, set it to 0\n",
      "for neuron 38, set it to 1\n",
      "for neuron 39, set it to 1\n"
     ]
    }
   ],
   "source": [
    "napgen.proposeNAPcandidate(metric)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now pick an image, and try to find a perturbation to satisfy a specific neuron pattern"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 108x108 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "dataiter = iter(train_loader)\n",
    "images, labels = dataiter.next()\n",
    "\n",
    "util.displayMNIST(images[0].numpy())\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we want to control neuron 3 and neuron 4 such that there sign is positive (activated) and negative (deactivated)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nndependability.atg.gradient import gratestgen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[ -9.6908,  15.8513,   1.4734,  -4.2752,   9.7392,  -4.7660,\n",
      "           4.8499,  10.7609,  -3.9903,  -6.7088,   7.3951, -10.7857,\n",
      "           6.6921,  -5.3404, -10.5902,  -2.6812,  15.6182,  -9.1596,\n",
      "          -8.0016,  -5.9410,   7.0480,  10.7112,  -2.0577,  -2.9086,\n",
      "          -7.7821,   8.3959,  11.7659,  -0.4871,  -8.9550,  -4.9751,\n",
      "          17.6865,  -7.8803,  12.0032,  -4.8063,  -2.8981,   1.3612,\n",
      "          14.3057,  15.2438,   5.2589,  -3.8208]])\n",
      "tensor([[ -9.6908,  15.8513,   1.4734,   1.0000,  -1.0000,  -4.7660,\n",
      "           4.8499,  10.7609,  -3.9903,  -6.7088,   7.3951, -10.7857,\n",
      "           6.6921,  -5.3404, -10.5902,  -2.6812,  15.6182,  -9.1596,\n",
      "          -8.0016,  -5.9410,   7.0480,  10.7112,  -2.0577,  -2.9086,\n",
      "          -7.7821,   8.3959,  11.7659,  -0.4871,  -8.9550,  -4.9751,\n",
      "          17.6865,  -7.8803,  12.0032,  -4.8063,  -2.8981,   1.3612,\n",
      "          14.3057,  15.2438,   5.2589,  -3.8208]])\n",
      "0: -4.2752366, 9.739197\n",
      "Found an image to successfully create the required pattern:\n"
     ]
    }
   ],
   "source": [
    "targetedNeuronIndex= list()\n",
    "desiredNAP = list()\n",
    "\n",
    "# Specify the target - we want to contril neuron 3 and neuron 4, with sign being positiove and negative\n",
    "targetedNeuronIndex.append(3)\n",
    "targetedNeuronIndex.append(4)\n",
    "\n",
    "desiredNAP.append(1)\n",
    "desiredNAP.append(-1)\n",
    "\n",
    "# Trigger gradient-based test case generation\n",
    "new_image, testcaseGenSuccessful = gratestgen.generateTestCase(images[0].unsqueeze(0), targetedNeuronIndex, desiredNAP, net)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 108x108 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "neuron activation: 0.06272768, -0.0002675876\n"
     ]
    }
   ],
   "source": [
    "if testcaseGenSuccessful: \n",
    "    util.displayMNIST(new_image[0].numpy())\n",
    "    out, intermediate = net.forwardWithIntermediate(new_image)\n",
    "    print(\"neuron activation: \"+str(intermediate.detach().numpy().squeeze(0)[targetedNeuronIndex[0]]) + \", \"+ str(intermediate.detach().numpy().squeeze(0)[targetedNeuronIndex[1]]))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 108x108 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "if testcaseGenSuccessful: \n",
    "    util.displayMNIST((new_image[0].numpy() - images[0].numpy()) + 0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}