adversarial_attack.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Importing libraries\n",
    "import tensorflow as tf\n",
    "\n",
    "from tensorflow.keras.datasets import mnist, cifar10, cifar100\n",
    "\n",
    "from tensorflow.keras import Sequential, Input, Model\n",
    "from tensorflow.keras.callbacks import LambdaCallback\n",
    "from tensorflow.keras.layers import Conv2D, MaxPooling2D, Dropout, Dense, Flatten, Activation\n",
    "\n",
    "\n",
    "import numpy as np\n",
    "import random\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.2.0'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#load data\n",
    "\n",
    "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
    "\n",
    "#different classes model has to learn to differentiate\n",
    "#code is written this way to make it generalizable to other datasets\n",
    "labels = ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Data shapes (10000, 28, 28, 1) (10000, 10) (60000, 28, 28, 1) (60000, 10)\n"
     ]
    }
   ],
   "source": [
    "#defining characteristics of the dataset\n",
    "img_rows = 28\n",
    "img_cols = 28\n",
    "channels = 1\n",
    "num_classes = 10\n",
    "\n",
    "#Normalizing Data\n",
    "x_train = x_train / 255\n",
    "x_test = x_test / 255\n",
    "\n",
    "#Reshaping data into required format\n",
    "x_train = x_train.reshape((-1, img_rows, img_cols, channels))\n",
    "x_test = x_test.reshape((-1, img_rows, img_cols, channels))\n",
    "\n",
    "#One hot encoding labels into a more NN friendly format\n",
    "y_train = tf.keras.utils.to_categorical(y_train, num_classes)\n",
    "y_test = tf.keras.utils.to_categorical(y_test, num_classes)\n",
    "\n",
    "print(\"Data shapes\", x_test.shape, y_test.shape, x_train.shape, y_train.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following model architecture is the baseline model I will be using. The model has been pre-trained to save time in another notebook called MNIST_baseline. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "313/313 [==============================] - 0s 997us/step - loss: 0.0029 - accuracy: 0.9818\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.0029318640008568764, 0.9818000197410583]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "def create_baseline_model():\n",
    "    X_Input = Input((img_rows, img_cols, channels))\n",
    "    X = Conv2D(32, kernel_size=(3, 3), strides=(3, 3), padding='same', activation='relu')(X_Input)\n",
    "    X = Conv2D(64, kernel_size=(3, 3), strides=(3, 3), padding='same', activation='relu')(X)\n",
    "    X = Conv2D(64, kernel_size=(3, 3), strides=(3, 3), padding='same', activation='relu')(X)\n",
    "    X = MaxPooling2D(pool_size=(2, 2))(X)\n",
    "    X = Dropout(0.2)(X)\n",
    "    X = Flatten()(X)\n",
    "    X = Dense(32)(X)\n",
    "    X = Dropout(0.2)(X)\n",
    "    X = Dense(32)(X)\n",
    "    X = Dropout(0.2)(X)\n",
    "    X = Dense(num_classes, activation='softmax')(X)\n",
    "    \n",
    "    model = Model(inputs = X_Input, outputs = X)\n",
    "    return model\n",
    "\n",
    "model = create_baseline_model()\n",
    "\n",
    "model.load_weights(filepath='./baseline_model.hdf5')\n",
    "model.compile(optimizer='adam', loss='mse', metrics=['accuracy'])\n",
    "# Check if model is imported correctly. Accuracy should be 0.981800019\n",
    "model.evaluate(x_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, the next code cell implements the adversarial attack algorithm. What this does essentially is finds the loss function of the model with respect to the image, and instead of updating the image to minimize loss, the model updates the image to maximize loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def adversarial_pattern(image, label):\n",
    "    image = tf.cast(image, tf.float32)\n",
    "    \n",
    "    with tf.GradientTape() as tape:\n",
    "        tape.watch(image)\n",
    "        prediction = model(image)\n",
    "        loss = tf.keras.losses.MSE(label, prediction)\n",
    "    \n",
    "    gradient = tape.gradient(loss, image)\n",
    "    \n",
    "    signed_grad = tf.sign(gradient)\n",
    "    \n",
    "    return signed_grad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we will generate adversarial examples! Right now, I will only generate adversarial examples for the first 3000 rows of the training set, but this is purely to save time. We will still be able to see a huge drop in accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds = []\n",
    "x_adversarial = np.zeros((60000, 28, 28, 1))\n",
    "\n",
    "for i in range(60000):\n",
    "    image = x_train[i]\n",
    "    image_label = y_train[i]\n",
    "    \n",
    "    perturbations = adversarial_pattern(image.reshape((1, img_rows, img_cols, channels)), image_label).numpy()\n",
    "    adversarial = image + perturbations * 0.1\n",
    "    x_adversarial[i, :, :, :] = adversarial\n",
    "    preds.append(model.predict(adversarial).argmax())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will see how are model performed on the adversarial examples. We will also compare it to how it performs on regular examples. There is a drop from 98% to 23%, which is almost 75%!. Here we see the need to prevent such attacks, as in a few minutes, we were able to bring the model down on its knees."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "94/94 [==============================] - 0s 950us/step - loss: 0.1367 - accuracy: 0.2293\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.13667051494121552, 0.2293333262205124]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Let's see the accuracy of model against adversarial\n",
    "model.evaluate(x_adversarial[0: 60000, :, :, :], y_train[0 : 60000, :])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "94/94 [==============================] - 0s 954us/step - loss: 0.0018 - accuracy: 0.9890\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.001836622366681695, 0.9890000224113464]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Let's see the accuracy of model against regular data to compare. The above value should be very low compared to this one.\n",
    "model.evaluate(x_train[0: 60000, :, :, :], y_train[0 : 60000, :])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Training on Adversarial Data\n",
    "The first approach we will try is the standard approach of training on adversarial data. I will not be using pure adversarial data as I don't want the model to forget how to classify regular images!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "ad_train = np.concatenate((x_adversarial, x_train[0 : 60000, :, :, :]))\n",
    "ad_y_train = np.concatenate((y_train[0 : 60000, :],y_train[0 : 60000, :]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(120000, 28, 28, 1)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ad_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(120000, 10)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ad_y_train.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we will train the model. When I was running experiments, I found something very interesting: if the epochs are set to 20, and then I try to implement adversarial attacks on the test set and evaluate, the model actually performs worse than otherwise. This means that the model is overfitting to adversarial examples, and hence is only memorizing some examples. Although overfitting happens for regular data as well, it is important to note that when training the model on regular data, the model didn't overfit even after 20 epochs, and the test accuracy was still going up. \n",
    "\n",
    "Conclusion: Adversarial Examples are extremely easy to overfit to. Hence, it won't be extremely effective."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/2\n",
      "188/188 [==============================] - 1s 3ms/step - loss: 0.0276 - accuracy: 0.8448\n",
      "Epoch 2/2\n",
      "188/188 [==============================] - 1s 3ms/step - loss: 0.0141 - accuracy: 0.9203\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7f807404eeb8>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(ad_train, ad_y_train, batch_size=32, epochs = 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "94/94 [==============================] - 0s 1ms/step - loss: 0.0131 - accuracy: 0.9267\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.013093532994389534, 0.9266666769981384]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.evaluate(x_adversarial[0: 60000, :, :, :], y_train[0 : 60000, :])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_preds = []\n",
    "test_adversarial = np.zeros((3000, 28, 28, 1))\n",
    "\n",
    "for i in range(3000):\n",
    "    image = x_test[i]\n",
    "    image_label = y_test[i]\n",
    "    \n",
    "    perturbations = adversarial_pattern(image.reshape((1, img_rows, img_cols, channels)), image_label).numpy()\n",
    "    adversarial = image + perturbations * 0.05\n",
    "    test_adversarial[i, :, :, :] = adversarial\n",
    "    test_preds.append(model.predict(adversarial).argmax())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3000, 28, 28, 1)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_adversarial.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "94/94 [==============================] - 0s 990us/step - loss: 0.0699 - accuracy: 0.5997\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.0698622614145279, 0.5996666550636292]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#So accuracy has increased to 61% from 20%. Major Improvement! But that's still not enough. Still 40% of the time, the model is horribly wrong.\n",
    "model.evaluate(test_adversarial, y_test[0 : 3000, :])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "313/313 [==============================] - 0s 1ms/step - loss: 0.0029 - accuracy: 0.9818\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.0029318640008568764, 0.9818000197410583]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.evaluate(x_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Saving Model Weights\n",
    "model.save(\"adv_trained_model.hdf5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The good thing is that after training on the adversarial examples, the model has grown a tolerance towards them, and improves to 61%. However, we are stuck here now, since we can't train the model more, else it will overfit the training data and perform worse."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "313/313 [==============================] - 0s 1ms/step - loss: 0.0029 - accuracy: 0.9818\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.0029318640008568764, 0.9818000197410583]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = create_baseline_model()\n",
    "\n",
    "model.load_weights(filepath='./baseline_model.hdf5')\n",
    "model.compile(optimizer='adam', loss='mse', metrics=['accuracy'])\n",
    "# Check if model is imported correctly. Accuracy should be 0.981800019\n",
    "model.evaluate(x_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "anti_noise_preds = []\n",
    "noise_adversarial = np.zeros((3000, 28, 28, 1))\n",
    "\n",
    "for i in range(3000):\n",
    "    image = x_test[i]\n",
    "    image_label = y_test[i]\n",
    "    \n",
    "    perturbations = adversarial_pattern(image.reshape((1, img_rows, img_cols, channels)), image_label).numpy()\n",
    "    adversarial = image + perturbations * 0.1\n",
    "    adversarial = adversarial>0.3\n",
    "    noise_adversarial[i, :, :, :] = adversarial\n",
    "    anti_noise_preds.append(model.predict(adversarial).argmax())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "94/94 [==============================] - 0s 1ms/step - loss: 0.0146 - accuracy: 0.9140\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.014571293257176876, 0.9139999747276306]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.evaluate(noise_adversarial, y_test[0 : 3000, :])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So it looks like denoising is amazing! It increases the accuracy to 91%. That's almost perfect - but now let's see how it holds against increased noise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "anti_noise_preds = []\n",
    "noise_adversarial = np.zeros((3000, 28, 28, 1))\n",
    "no_noise_adversarial = np.zeros((3000, 28, 28, 1))\n",
    "\n",
    "for i in range(3000):\n",
    "    image = x_test[i]\n",
    "    image_label = y_test[i]\n",
    "    \n",
    "    perturbations = adversarial_pattern(image.reshape((1, img_rows, img_cols, channels)), image_label).numpy()\n",
    "    adversarial = image + perturbations * 0.3\n",
    "    no_noise_adversarial[i, :, :, :] = adversarial\n",
    "    adversarial = adversarial>0.3\n",
    "    noise_adversarial[i, :, :, :] = adversarial\n",
    "    anti_noise_preds.append(model.predict(adversarial).argmax())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f80742d3630>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "plt.imshow(no_noise_adversarial[0, :, :, :].reshape((img_rows, img_cols)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f8073408d68>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD4CAYAAAAq5pAIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAANpUlEQVR4nO3dXahdZ53H8d9vMtFiVUj6ZqaGqSMtWKSJsjkKlaFDGVN7k3rhYC4kA8V4YUHBC0vnwl6WwRe8GITjNBgHpyJoaS7KHEMQOt6kPS1pmk5m0lqijQlJTC5SJ/Qt/c/FWRlO0/2Wvdaz13Py/37gsPdZa++1/med8ztr7/2s53kcEQJw9fuLvgsAMB+EHUiCsANJEHYgCcIOJPGX89zZ9RvXxS2b18/8/KOHPjBy3W13XJh5u5O2PWn7k547Sena+9x3m+33eVxL/lxt9z3O6/pfvRlveNg6t2l6s32PpB9KWifpXyPikXGPH2y5Jp5e2jzz/rb91daR65ZOHJx5u5O2PWn7k547Sena+9x3m+33eVxL/lxt9z3Ogdiv83FuaNhnfhlve52kf5H0BUm3S9ph+/ZZtwegrDbv2RckvRwRr0TEm5J+Lml7N2UB6FqbsN8s6dVV3x9vlr2L7V22l20vnzl7scXuALTRJuzD3he85wOAiFiMiEFEDG64bl2L3QFoo03Yj0ta/WnbRyWdaFcOgFLahP0ZSbfa/pjt90n6sqS93ZQFoGszt7NHxNu2H5C0pJWmt90R8WJnlc1Zm6aUSc+d1JTStomppLa1lWwuLdn81fZ3WqNWF9VExJOSnuyoFgAFcbkskARhB5Ig7EAShB1IgrADSRB2IIlWXVyv1Ie9MT7ju+e2vytRc7tqn91EJynZ1l2zWrvfFuniCmBtIexAEoQdSIKwA0kQdiAJwg4kMdehpG+744KWlmYfpbXmJqg22jb7Xa3NX21/7pLda0sq9bfKmR1IgrADSRB2IAnCDiRB2IEkCDuQBGEHkphrO3ufah62uKTSs7SWnEG21plS1yrO7EAShB1IgrADSRB2IAnCDiRB2IEkCDuQRFXt7H22ZdfcZ3wt77tke3ab31mfQ0G33f+4fS9suzByXauw2z4m6TVJFyW9HRGDNtsDUE4XZ/a/i4g/dbAdAAXxnh1Iom3YQ9KvbT9re9ewB9jeZXvZ9vKZsxdb7g7ArNq+jL8zIk7YvlHSPtv/HRFPrX5ARCxKWpSkwZZr5jexHIB3aXVmj4gTze1pSY9LWuiiKADdmznstq+1/aFL9yV9XtLhrgoD0K02L+NvkvS47Uvb+feI+I9OqkI1+m6PXqv6vAZglJnDHhGvSNrSYS0ACqLpDUiCsANJEHYgCcIOJEHYgSSq6uJa8/C+Jaf/rfnnLqnPn3st/87G7ftonB25jjM7kARhB5Ig7EAShB1IgrADSRB2IAnCDiThiPkNHvNhb4zP+O4i2y7dbpq1qyaGq7Xr78K2V7X8/Oseto4zO5AEYQeSIOxAEoQdSIKwA0kQdiAJwg4kUVV/9kltjyX7ELdp9yzdt5k2/rWnzd9yqd83Z3YgCcIOJEHYgSQIO5AEYQeSIOxAEoQdSKKqdvY2au1fXHrbk/TdT79Ne3LJ2mv+e5mk2LjxtnfbPm378KplG23vs/1Sc7vhSgsGMF/TvIz/iaR7Llv2oKT9EXGrpP3N9wAqNjHsEfGUpHOXLd4uaU9zf4+k+zquC0DHZv2A7qaIOClJze2Nox5oe5ftZdvLb+mNGXcHoK3in8ZHxGJEDCJisF7vL707ACPMGvZTtjdJUnN7uruSAJQwa9j3StrZ3N8p6YluygFQysR2dtuPSbpL0vW2j0v6jqRHJP3C9v2S/iDpS9Ps7LY7LmhpqUz7ZJ/tnjX3N2c8/eFqnp+9zTFf2HZh5LqJYY+IHSNWlZntAUARXC4LJEHYgSQIO5AEYQeSIOxAEldNF9fS+hj6d1ola1vLTZo1H5fSw48Pw5kdSIKwA0kQdiAJwg4kQdiBJAg7kARhB5KYazv70UMfKNa+2Ee75bT67Cba93TSfV+DMErNQ0kzZTOAVgg7kARhB5Ig7EAShB1IgrADSRB2IAlHxNx2NthyTTy9tHnm59fcll5SrdMDt7UW+4R3pdR00wdiv87HOQ9bx5kdSIKwA0kQdiAJwg4kQdiBJAg7kARhB5Jg3PhGqXbPttueZvsl99339ttYq7/T3vqz295t+7Ttw6uWPWz7j7YPNl/3FqkOQGemeRn/E0n3DFn+g4jY2nw92W1ZALo2MewR8ZSkc3OoBUBBbT6ge8D2oeZl/oZRD7K9y/ay7eUzZy+22B2ANmYN+48kfVzSVkknJX1v1AMjYjEiBhExuOG6dTPuDkBbM4U9Ik5FxMWIeEfSjyUtdFsWgK7NFHbbm1Z9+0VJh0c9FkAdJraz235M0l2Srrd9XNJ3JN1le6ukkHRM0tem2VnbcePHtT+u5b7NJbVtL560vmR7dJ/j7dds3M+9sO3CyHUTwx4RO4YsfnSqqgBUg8tlgSQIO5AEYQeSIOxAEoQdSGKuXVxvu+OClpb6aS5p24TU17bbupqHa665thpxZgeSIOxAEoQdSIKwA0kQdiAJwg4kQdiBJObazj6pi2vJLott22Rr7l5b8rj12Y205u61pZ9fAmd2IAnCDiRB2IEkCDuQBGEHkiDsQBKEHUiiqimb+xw6uM/+7n1ay8M1r+XrC9pctzFrbZzZgSQIO5AEYQeSIOxAEoQdSIKwA0kQdiAJR8TcdjbYck08vbR55ufXOv56jX2Xp1VzO3rJMQja6vP6hHH7PhD7dT7Oedi6iWd225tt/8b2Edsv2v5Gs3yj7X22X2puN8xcPYDipnkZ/7akb0XEJyR9VtLXbd8u6UFJ+yPiVkn7m+8BVGpi2CPiZEQ819x/TdIRSTdL2i5pT/OwPZLuK1UkgPau6AM627dI+pSkA5JuioiT0so/BEk3jnjOLtvLtpfPnL3YrloAM5s67LY/KOmXkr4ZEeenfV5ELEbEICIGN1y3bpYaAXRgqrDbXq+VoP8sIn7VLD5le1OzfpOk02VKBNCFiV1cbVvSo5KORMT3V63aK2mnpEea2yfaFlPz0MAl9Tlkcmklhw4v+fdQeqrrPppyp+nPfqekr0h6wfalCh/SSsh/Yft+SX+Q9KUiFQLoxMSwR8RvJQ1tpJd0d7flACiFy2WBJAg7kARhB5Ig7EAShB1Ioqopm0tq25Z9tQ4lPUmt3YqnUfO1FX3UxpkdSIKwA0kQdiAJwg4kQdiBJAg7kARhB5KoaijpmttFax5Keq2245c+bhl/ZwvbXtXy86/PNpQ0gKsDYQeSIOxAEoQdSIKwA0kQdiAJwg4kkaY/e1slxz+veVz4mmur+fqCGmvjzA4kQdiBJAg7kARhB5Ig7EAShB1IgrADSUwzP/tmST+V9BFJ70hajIgf2n5Y0lclnWke+lBEPFmqUCnv/Ow1q/m4jlPzmPRttn00zo5cN81FNW9L+lZEPGf7Q5Ketb2vWfeDiPjuzJUBmJtp5mc/Kelkc/8120ck3Vy6MADduqL37LZvkfQpSQeaRQ/YPmR7t+0NI56zy/ay7eW39EarYgHMbuqw2/6gpF9K+mZEnJf0I0kfl7RVK2f+7w17XkQsRsQgIgbr9f4OSgYwi6nCbnu9VoL+s4j4lSRFxKmIuBgR70j6saSFcmUCaGti2G1b0qOSjkTE91ct37TqYV+UdLj78gB0ZeJQ0rY/J+k/Jb2glaY3SXpI0g6tvIQPScckfa35MG+kSUNJt9HnsMSl1dzNtORU1jU365Vsumuz7XFDSU/zafxvJQ17ctE2dQDd4go6IAnCDiRB2IEkCDuQBGEHkiDsQBJzHUoaw7VtT665rXstd99to68usOO6uHJmB5Ig7EAShB1IgrADSRB2IAnCDiRB2IEkJvZn73Rn9hlJv1+16HpJf5pbAVem1tpqrUuitll1WdtfR8QNw1bMNezv2bm9HBGD3goYo9baaq1LorZZzas2XsYDSRB2IIm+w77Y8/7HqbW2WuuSqG1Wc6mt1/fsAOan7zM7gDkh7EASvYTd9j22/8f2y7Yf7KOGUWwfs/2C7YO2l3uuZbft07YPr1q20fY+2y81t0Pn2Ouptodt/7E5dgdt39tTbZtt/8b2Edsv2v5Gs7zXYzemrrkct7m/Z7e9TtJRSX8v6bikZyTtiIj/mmshI9g+JmkQEb1fgGH7byX9WdJPI+KTzbJ/lnQuIh5p/lFuiIhvV1Lbw5L+3Pc03s1sRZtWTzMu6T5J/6gej92Yuv5BczhufZzZFyS9HBGvRMSbkn4uaXsPdVQvIp6SdO6yxdsl7Wnu79HKH8vcjaitChFxMiKea+6/JunSNOO9Hrsxdc1FH2G/WdKrq74/rrrmew9Jv7b9rO1dfRczxE2Xptlqbm/suZ7LTZzGe54um2a8mmM3y/TnbfUR9mFTSdXU/ndnRHxa0hckfb15uYrpTDWN97wMmWa8CrNOf95WH2E/Lmn17I4flXSihzqGiogTze1pSY+rvqmoT12aQbe5Pd1zPf+vpmm8h00zrgqOXZ/Tn/cR9mck3Wr7Y7bfJ+nLkvb2UMd72L62+eBEtq+V9HnVNxX1Xkk7m/s7JT3RYy3vUss03qOmGVfPx6736c8jYu5fku7Vyifyv5P0T33UMKKuv5H0fPP1Yt+1SXpMKy/r3tLKK6L7JV0nab+kl5rbjRXV9m9amdr7kFaCtamn2j6nlbeGhyQdbL7u7fvYjalrLseNy2WBJLiCDkiCsANJEHYgCcIOJEHYgSQIO5AEYQeS+D8oe1pLW4hSVAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(noise_adversarial[0, :, :, :].reshape((img_rows, img_cols)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "94/94 [==============================] - 0s 1ms/step - loss: 0.1768 - accuracy: 0.0473\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.17678509652614594, 0.047333333641290665]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.evaluate(noise_adversarial, y_test[0 : 3000, :])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "About 5 percent. That's horrible - increasing the noise by a little completely ruined the model's performance. Hence, although this binary thresholding is the best approach we currently have, it won't be good enough since a small change can ruin it. Now we see the need for a more robust system. As I have shown, using current techniques doesn't help much since it isn't robust.\n",
    "Firstly, I will be trying out a filtering technique, which aims to identify and exclude adversarial examples from even enterring the model. The first filtering technique which was tried above was denoising, but we can see that this isn't particularly robust to different amounts of noise. Let's train a NN to predict whether or not a datapoint is adversarial. Then we can decline potentially harmful examples.\n",
    "\n",
    "First thing to do is to generate the training and testing data for the model. I will try out different noise levels for the test dataset to see if the model generalizes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "adv_train = np.zeros((3000, 28, 28, 1))\n",
    "\n",
    "adv_test = np.zeros((3000, 28, 28, 1))\n",
    "y_adv_train = np.zeros((6000, 1))\n",
    "y_adv_test = np.zeros((6000, 1))\n",
    "\n",
    "for i in range(3000):\n",
    "    image = x_train[i]\n",
    "    image_label = y_train[i]\n",
    "    \n",
    "    perturbations = adversarial_pattern(image.reshape((1, img_rows, img_cols, channels)), image_label).numpy()\n",
    "    \n",
    "    image_test = x_test[i]\n",
    "    image_label_test = y_test[i]\n",
    "    \n",
    "    perturbations_test = adversarial_pattern(image_test.reshape((1, img_rows, img_cols, channels)), image_label_test).numpy()\n",
    "\n",
    "    if i > 1499:\n",
    "        adversarial = image + perturbations * 0.1\n",
    "        adv_train[i] = adversarial\n",
    "        \n",
    "        adversarial = image_test + perturbations_test * 0.1\n",
    "        adv_test[i] = adversarial\n",
    "        \n",
    "    else:\n",
    "        adversarial = image + perturbations * 0.3\n",
    "        adv_train[i] = adversarial\n",
    "        \n",
    "        adversarial = image_test + perturbations_test * 0.4\n",
    "        adv_test[i] = adversarial\n",
    "    \n",
    "    y_adv_train[i] = 1\n",
    "    y_adv_test[i] = 1\n",
    "    \n",
    "fin_adv_train = np.concatenate((adv_train, x_train[3000 : 6000, :, :, :]))\n",
    "\n",
    "fin_adv_test = np.concatenate((adv_test, x_test[3000 : 6000, :, :, :]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shapes of final data are \n",
      "((6000, 28, 28, 1), (6000, 1), (6000, 28, 28, 1), (6000, 1))\n"
     ]
    }
   ],
   "source": [
    "print(\"Shapes of final data are \")\n",
    "print((fin_adv_train.shape, y_adv_train.shape, fin_adv_test.shape, y_adv_test.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f8073b17048>"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD4CAYAAAAq5pAIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAOm0lEQVR4nO3de4xc5XnH8d/Pd/ClsTFQ11gBgylFpEC0MTSQlBaVglUCNE0ELZGRaB1VUAVC1aA0UmhaKU6VBCUqSmMHB4cQEK1xcVXSQlxSSktdlkvAxAETaoKxYwMmMZTGl/XTP/Y4WmDPO+u528/3I61m5jzzznk02t+e2XnnzOuIEIBD37heNwCgOwg7kARhB5Ig7EAShB1IYkI3dzbJk2OKpnZzl0AqP9P/anfs8mi1lsJu+3xJX5I0XtLXImJp6f5TNFVn+NxWdgmgYF2sra01/TLe9nhJN0m6QNLJki6zfXKzjwegs1r5n32hpGcj4rmI2C3pDkkXtactAO3WStjnSnphxO3N1bY3sb3E9qDtwT3a1cLuALSilbCP9ibA2z57GxHLImIgIgYmanILuwPQilbCvlnSvBG3j5G0pbV2AHRKK2F/WNIC28fZniTpUklr2tMWgHZreuotIvbavlrSv2h46m1FRDzVts4AtFVL8+wRcY+ke9rUC4AO4uOyQBKEHUiCsANJEHYgCcIOJEHYgSQIO5AEYQeSIOxAEoQdSIKwA0kQdiAJwg4kQdiBJAg7kARhB5Ig7EAShB1IgrADSRB2IAnCDiRB2IEkCDuQBGEHkiDsQBKEHUiCsANJEHYgCcIOJEHYgSRaWrLZ9iZJr0kakrQ3Igba0RSA9msp7JXfiIiX2/A4ADqIl/FAEq2GPSTda/sR20tGu4PtJbYHbQ/u0a4WdwegWa2+jD8rIrbYPkrSfbZ/EBEPjLxDRCyTtEySZnhWtLg/AE1q6cgeEVuqy+2SVkta2I6mALRf02G3PdX29P3XJZ0naX27GgPQXq28jD9a0mrb+x/nWxHxz23pCl0zYf6xxfqWRb9UrE+/cGuxfv8pqw60pZ8b7/KxaCj2FesnP3hFbe34T71efuyNzxXrB6Omwx4Rz0k6tY29AOggpt6AJAg7kARhB5Ig7EAShB1Ioh0nwqDHxk2fXlt76dJTimMvv+bbxfqfvOOupnra7x/fmFFb2763vjYWU7y7WP/+2bfU1k794NXFsXOXHnpTbxzZgSQIO5AEYQeSIOxAEoQdSIKwA0kQdiAJ5tkPAh4oz5Xv/Ks3amvr3nVTcez/RXmu+tR1VxbrRy47vFg/7OEf1taGXtlRHNvIrkXvKdb/YPlXa2tHnvti+cGXNtNRf+PIDiRB2IEkCDuQBGEHkiDsQBKEHUiCsANJMM/eB17/8JnF+mc+u7xYP2fKntraLTvLXwX91aWXFOtzVz5UrDcy1NLoMl+7vemx2747t1ifp+ebfux+xZEdSIKwA0kQdiAJwg4kQdiBJAg7kARhB5JwRHRtZzM8K87wuV3bX7+I95YXu/3MN1cU6++Z7GJ9wao/rq2d9KkNxbFDO3cW6/3sfU/8rFgfivpj2UMD04pjY0/5PP9+tS7WamfsGPUXpuGR3fYK29ttrx+xbZbt+2xvrC5ntrNhAO03lpfxt0g6/y3brpe0NiIWSFpb3QbQxxqGPSIekPTW7w+6SNLK6vpKSRe3uS8AbdbsG3RHR8RWSaouj6q7o+0ltgdtD+7RriZ3B6BVHX83PiKWRcRARAxM1ORO7w5AjWbDvs32HEmqLps//QhAVzQb9jWSFlfXF0u6uz3tAOiUhuez275d0jmSZtveLOnTGv5W7TttXynpR5I+1MkmD3ZTPrutWG80j/7BZy8o1hdcM1hbG9rXyTPKe2vV/5xWrH/z1K/X1r7xuWuLY0/4+H811VM/axj2iLisppTv0zHAQYyPywJJEHYgCcIOJEHYgSQIO5AEXyXdBi8v+bVi/Tvzv1Csv7qvfJrxlhXzi/WZ+8pTe4eqn7xSPk31pIn1n9i84H2PFcdubKqj/saRHUiCsANJEHYgCcIOJEHYgSQIO5AEYQeSYJ59jDyh/qlasPjp4tgZ46YU6yfddlWxPr/FZZMPVi9+4r3F+g9++0sNHmF8beWhr727OHK2Dr3nnCM7kARhB5Ig7EAShB1IgrADSRB2IAnCDiTBPPsYPf3l+nnZZ4/92+LYMx+7tFg/4YbvFev7itWD17jp04v1X/1AebnpCYV5dEm68Jnfqa3NXv7fxbGHIo7sQBKEHUiCsANJEHYgCcIOJEHYgSQIO5AE8+xjdOHC8veMl/jvjijW973xTNOP3e88cVJtbffqmcWxtx77Dy3t++U3ptbWZh7CS1nXaXhkt73C9nbb60dsu8H2i7Yfr34WdbZNAK0ay8v4WySdP8r2GyPitOrnnva2BaDdGoY9Ih6QtKMLvQDooFbeoLva9hPVy/zaf75sL7E9aHtwj3a1sDsArWg27F+RdLyk0yRtlVS7cmFELIuIgYgYmKj6hfYAdFZTYY+IbRExFBH7JC2XtLC9bQFot6bCbnvOiJuXSFpfd18A/aHhPLvt2yWdI2m27c2SPi3pHNunSQpJmyR9tIM9dsWE495ZrF9+xN8XquXzqo/8zvPF+t5itb+NnzGjWN+z+hdqa/eeVJ5HH+/ysWgoymf6v7S9vrfyDP+hqWHYI+KyUTbf3IFeAHQQH5cFkiDsQBKEHUiCsANJEHYgCU5x3W/3nmL5x3vrp5A06fXi2KevKU/r/fKXy39z976wuVgv8eQGn1o85YRi+ZkrphXrf3leaUpS+r1pP66tnfRvf1Qce//Zf1OszxpXf/qsJB2zhl/vkTiyA0kQdiAJwg4kQdiBJAg7kARhB5Ig7EASTERW9r64pVi/btXi2tpvXn5jcezTv39Tsf7d351YrN/9av1y0Y3MmPBGsf4XR97a9GNL0vah8uMv/Pyf1dZO+NdXi2P3nV3e959ufX+xfvjqdeUHSIYjO5AEYQeSIOxAEoQdSIKwA0kQdiAJwg4kwTz7GM2//qHa2q8/d21x7Mevu7NYv3TaS8X6OXOany/+yKZzi/UTHllSrM9aV/4MwNF3PFWs/+LO/6ytvfJPC4pj544/vFj/9mPvKtZP1MPFejYc2YEkCDuQBGEHkiDsQBKEHUiCsANJEHYgCebZ22D2svo5eEm67c5TivVvHXZYO9t5k6GXXi7WT9w72NrjN6iPmzKltvaH8/+jpX0fd2d5yWa8WcMju+15tu+3vcH2U7Y/Vm2fZfs+2xury4xLXgMHjbG8jN8r6bqI+BVJZ0q6yvbJkq6XtDYiFkhaW90G0Kcahj0itkbEo9X11yRtkDRX0kWSVlZ3Wynp4k41CaB1B/QGne1jJZ0uaZ2koyNiqzT8B0HSUTVjltgetD24R7ta6xZA08YcdtvTJK2SdE1E7BzruIhYFhEDETEwUQ0WGQTQMWMKu+2JGg76bRFxV7V5m+05VX2OpO2daRFAOzScerNtSTdL2hARXxxRWiNpsaSl1eXdHenwEDD0k5+W79CofhDbdsXptbUrZ9Sf/ipJy386r1ifvO6ZYp2JuTcbyzz7WZI+IulJ249X2z6p4ZDfaftKST+S9KHOtAigHRqGPSIelOSacvmbEQD0DT4uCyRB2IEkCDuQBGEHkiDsQBKc4oqOmvSB8tdkl3zuwUXF+omv8VXRB4IjO5AEYQeSIOxAEoQdSIKwA0kQdiAJwg4kwTw7OmrhUc83PXby1vJy0TgwHNmBJAg7kARhB5Ig7EAShB1IgrADSRB2IAnCDiRB2IEkCDuQBGEHkiDsQBKEHUiCsANJEHYgiYZhtz3P9v22N9h+yvbHqu032H7R9uPVT/lLvgH01Fi+vGKvpOsi4lHb0yU9Yvu+qnZjRHy+c+0BaJexrM++VdLW6vprtjdImtvpxgC01wH9z277WEmnS1pXbbra9hO2V9ieWTNmie1B24N7tKulZgE0b8xhtz1N0ipJ10TETklfkXS8pNM0fOT/wmjjImJZRAxExMBETW5DywCaMaaw256o4aDfFhF3SVJEbIuIoYjYJ2m5pIWdaxNAq8bybrwl3SxpQ0R8ccT2OSPudomk9e1vD0C7OCLKd7DPlvTvkp6UtK/a/ElJl2n4JXxI2iTpo9WbebVmeFac4XNbbBlAnXWxVjtjh0erjeXd+AcljTb4nlYbA9A9fIIOSIKwA0kQdiAJwg4kQdiBJAg7kARhB5Ig7EAShB1IgrADSRB2IAnCDiRB2IEkCDuQRMPz2du6M/slSc+P2DRb0stda+DA9Gtv/dqXRG/Namdv74yII0crdDXsb9u5PRgRAz1roKBfe+vXviR6a1a3euNlPJAEYQeS6HXYl/V4/yX92lu/9iXRW7O60ltP/2cH0D29PrID6BLCDiTRk7DbPt/207aftX19L3qoY3uT7SerZagHe9zLCtvbba8fsW2W7ftsb6wuR11jr0e99cUy3oVlxnv63PV6+fOu/89ue7ykZyT9lqTNkh6WdFlEfL+rjdSwvUnSQET0/AMYtt8v6XVJ34iIU6ptfy1pR0Qsrf5QzoyIT/RJbzdIer3Xy3hXqxXNGbnMuKSLJV2hHj53hb4+rC48b704si+U9GxEPBcRuyXdIemiHvTR9yLiAUk73rL5Ikkrq+srNfzL0nU1vfWFiNgaEY9W11+TtH+Z8Z4+d4W+uqIXYZ8r6YURtzerv9Z7D0n32n7E9pJeNzOKo/cvs1VdHtXjft6q4TLe3fSWZcb75rlrZvnzVvUi7KMtJdVP839nRcS7JV0g6arq5SrGZkzLeHfLKMuM94Vmlz9vVS/CvlnSvBG3j5G0pQd9jCoitlSX2yWtVv8tRb1t/wq61eX2Hvfzc/20jPdoy4yrD567Xi5/3ouwPyxpge3jbE+SdKmkNT3o421sT63eOJHtqZLOU/8tRb1G0uLq+mJJd/ewlzfpl2W865YZV4+fu54vfx4RXf+RtEjD78j/UNKf96KHmr7mS/pe9fNUr3uTdLuGX9bt0fAroislHSFpraSN1eWsPurtVg0v7f2EhoM1p0e9na3hfw2fkPR49bOo189doa+uPG98XBZIgk/QAUkQdiAJwg4kQdiBJAg7kARhB5Ig7EAS/w9kokTpEDfOXgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#checking to see if data is as desired.\n",
    "plt.imshow(fin_adv_train[3000, :, :, :].reshape(28, 28))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def adv_classifier():\n",
    "    X_Input = Input((img_rows, img_cols, channels))\n",
    "    X = Conv2D(32, kernel_size=(3, 3), strides=(3, 3), padding='same', activation='relu')(X_Input)\n",
    "    X = Conv2D(64, kernel_size=(3, 3), strides=(3, 3), padding='same', activation='relu')(X)\n",
    "    X = MaxPooling2D(pool_size=(2, 2))(X)\n",
    "    X = Dropout(0.2)(X)\n",
    "    X = Flatten()(X)\n",
    "    X = Dense(32)(X)\n",
    "    X = Dropout(0.2)(X)\n",
    "    X = Dense(1, activation='sigmoid')(X)\n",
    "    \n",
    "    adv_model = Model(inputs = X_Input, outputs = X)\n",
    "    return adv_model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_2\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_3 (InputLayer)         [(None, 28, 28, 1)]       0         \n",
      "_________________________________________________________________\n",
      "conv2d_6 (Conv2D)            (None, 10, 10, 32)        320       \n",
      "_________________________________________________________________\n",
      "conv2d_7 (Conv2D)            (None, 4, 4, 64)          18496     \n",
      "_________________________________________________________________\n",
      "max_pooling2d_2 (MaxPooling2 (None, 2, 2, 64)          0         \n",
      "_________________________________________________________________\n",
      "dropout_6 (Dropout)          (None, 2, 2, 64)          0         \n",
      "_________________________________________________________________\n",
      "flatten_2 (Flatten)          (None, 256)               0         \n",
      "_________________________________________________________________\n",
      "dense_6 (Dense)              (None, 32)                8224      \n",
      "_________________________________________________________________\n",
      "dropout_7 (Dropout)          (None, 32)                0         \n",
      "_________________________________________________________________\n",
      "dense_7 (Dense)              (None, 1)                 33        \n",
      "=================================================================\n",
      "Total params: 27,073\n",
      "Trainable params: 27,073\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "adv_model = adv_classifier()\n",
    "adv_model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])\n",
    "adv_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/10\n",
      "188/188 [==============================] - 1s 3ms/step - loss: 0.1655 - accuracy: 0.9345\n",
      "Epoch 2/10\n",
      "188/188 [==============================] - 1s 3ms/step - loss: 0.0013 - accuracy: 1.0000\n",
      "Epoch 3/10\n",
      "188/188 [==============================] - 1s 3ms/step - loss: 3.7465e-04 - accuracy: 1.0000\n",
      "Epoch 4/10\n",
      "188/188 [==============================] - 1s 3ms/step - loss: 1.8127e-04 - accuracy: 1.0000\n",
      "Epoch 5/10\n",
      "188/188 [==============================] - 1s 3ms/step - loss: 7.9648e-05 - accuracy: 1.0000\n",
      "Epoch 6/10\n",
      "188/188 [==============================] - 1s 3ms/step - loss: 7.0082e-05 - accuracy: 1.0000\n",
      "Epoch 7/10\n",
      "188/188 [==============================] - 1s 3ms/step - loss: 5.0723e-05 - accuracy: 1.0000\n",
      "Epoch 8/10\n",
      "188/188 [==============================] - 1s 3ms/step - loss: 3.0002e-05 - accuracy: 1.0000\n",
      "Epoch 9/10\n",
      "188/188 [==============================] - 1s 3ms/step - loss: 2.6075e-05 - accuracy: 1.0000\n",
      "Epoch 10/10\n",
      "188/188 [==============================] - 1s 3ms/step - loss: 2.0114e-05 - accuracy: 1.0000\n"
     ]
    }
   ],
   "source": [
    "history = adv_model.fit(fin_adv_train, y_adv_train, batch_size=32, epochs=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "188/188 [==============================] - 0s 2ms/step - loss: 8.4749e-06 - accuracy: 1.0000\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[8.47487444843864e-06, 1.0]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "adv_model.evaluate(fin_adv_test, y_adv_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = adv_model.predict(fin_adv_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.0000000e+00],\n",
       "       [1.0000000e+00],\n",
       "       [1.0000000e+00],\n",
       "       ...,\n",
       "       [1.3129377e-06],\n",
       "       [2.1377024e-05],\n",
       "       [6.4337117e-05]], dtype=float32)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "188/188 [==============================] - 0s 2ms/step - loss: 0.0861 - accuracy: 0.5338\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.08614670485258102, 0.5338333249092102]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#before adding model safecatch\n",
    "model.evaluate(fin_adv_test, y_test[0 : 6000, :])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "accuracy = 0.9796666666666667\n"
     ]
    }
   ],
   "source": [
    "#adding model safecatch\n",
    "model_safe = adv_model.predict(fin_adv_test)\n",
    "correct = 0\n",
    "counter = 0\n",
    "for i in range(len(model_safe)):\n",
    "    if model_safe[i] > 0.5:\n",
    "        pass\n",
    "    else:\n",
    "        mod_pred = model.predict(fin_adv_test[i, :, :, :].reshape(-1, 28, 28, 1)).argmax()\n",
    "        if mod_pred == y_test[i].argmax():\n",
    "            correct += 1\n",
    "        counter += 1\n",
    "print('accuracy = ' + str(correct / counter))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that the model's accuracy has gone back up. The reason for this is that our model for filtering adversarial examples was very good. The problem is that we now have to run 2 models instead of 1, and in many applications, this is too slow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting foolbox==3.0.0b1\n",
      "  Downloading foolbox-3.0.0b1-py3-none-any.whl (1.6 MB)\n",
      "\u001b[K     |████████████████████████████████| 1.6 MB 2.8 MB/s eta 0:00:01\n",
      "\u001b[?25hRequirement already satisfied: numpy in /Users/yush/anaconda3/lib/python3.7/site-packages (from foolbox==3.0.0b1) (1.18.5)\n",
      "Collecting typing-extensions>=3.7.4.1\n",
      "  Downloading typing_extensions-3.7.4.2-py3-none-any.whl (22 kB)\n",
      "Collecting eagerpy==0.25.2\n",
      "  Downloading eagerpy-0.25.2-py3-none-any.whl (28 kB)\n",
      "Requirement already satisfied: scipy in /Users/yush/anaconda3/lib/python3.7/site-packages (from foolbox==3.0.0b1) (1.4.1)\n",
      "Requirement already satisfied: setuptools in /Users/yush/anaconda3/lib/python3.7/site-packages (from foolbox==3.0.0b1) (41.0.1)\n",
      "Collecting GitPython>=3.0.7\n",
      "  Downloading GitPython-3.1.3-py3-none-any.whl (451 kB)\n",
      "\u001b[K     |████████████████████████████████| 451 kB 3.3 MB/s eta 0:00:01\n",
      "\u001b[?25hCollecting gitdb<5,>=4.0.1\n",
      "  Downloading gitdb-4.0.5-py3-none-any.whl (63 kB)\n",
      "\u001b[K     |████████████████████████████████| 63 kB 2.3 MB/s eta 0:00:011\n",
      "\u001b[?25hCollecting smmap<4,>=3.0.1\n",
      "  Downloading smmap-3.0.4-py2.py3-none-any.whl (25 kB)\n",
      "Installing collected packages: typing-extensions, eagerpy, smmap, gitdb, GitPython, foolbox\n",
      "Successfully installed GitPython-3.1.3 eagerpy-0.25.2 foolbox-3.0.0b1 gitdb-4.0.5 smmap-3.0.4 typing-extensions-3.7.4.2\n",
      "\u001b[33mWARNING: You are using pip version 20.1; however, version 20.1.1 is available.\n",
      "You should consider upgrading via the '/Users/yush/anaconda3/bin/python -m pip install --upgrade pip' command.\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "!pip3 install foolbox==3.0.0b1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import foolbox as fb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /Users/yush/anaconda3/lib/python3.7/site-packages/foolbox/models/tensorflow.py:13: is_gpu_available (from tensorflow.python.framework.test_util) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use `tf.config.list_physical_devices('GPU')` instead.\n"
     ]
    }
   ],
   "source": [
    "preprocessing = dict()\n",
    "bounds = (0, 1)\n",
    "fmodel = fb.TensorFlowModel(model, bounds=bounds, preprocessing=preprocessing)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [],
   "source": [
    "images, labels = fb.utils.samples(fmodel, dataset='mnist', batchsize=20)\n",
    "fb.utils.accuracy(fmodel, images, labels)\n",
    "attack = fb.attacks.LinfPGD()\n",
    "epsilons = [0.0, 0.001, 0.01, 0.03, 0.1, 0.3, 0.5, 1.0]\n",
    "_, advs, success = attack(fmodel, images, labels, epsilons=epsilons)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.949999988079071"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [],
   "source": [
    "#attack = fb.attacks.LinfDeepFoolAttack()\n",
    "attack = fb.attacks.LinfPGD()\n",
    "epsilons = [0.0, 0.001, 0.01, 0.03, 0.1, 0.3, 0.5, 1.0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [],
   "source": [
    "#raw, clipped, is_adv = attack(fmodel, images, labels, epsilons=-1)\n",
    "_, advs, success = attack(fmodel, images, labels, epsilons=epsilons)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(8, 20), dtype=bool, numpy=\n",
       "array([[False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "         True, False],\n",
       "       [False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "         True, False],\n",
       "       [False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "         True, False],\n",
       "       [False, False, False, False, False, False,  True, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "         True, False],\n",
       "       [ True, False,  True,  True,  True, False,  True,  True,  True,\n",
       "         True, False,  True,  True,  True, False, False, False,  True,\n",
       "         True,  True],\n",
       "       [ True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True,  True],\n",
       "       [ True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True,  True],\n",
       "       [ True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True,  True]])>"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "success"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [],
   "source": [
    "advss = np.array(advs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7f7f3941cf98>"
      ]
     },
     "execution_count": 241,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "plt.imshow(advss[4, 0, :, :, :].reshape(28, 28))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [],
   "source": [
    "advsss = advss.reshape(20*8, 28, 28, 1)\n",
    "ad_labls = np.zeros((160,))\n",
    "ad_labls[80 : 160] = np.ones((80,))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 238,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5/5 [==============================] - 0s 1ms/step - loss: 4.7090 - accuracy: 0.5000\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[4.709028720855713, 0.5]"
      ]
     },
     "execution_count": 238,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "adv_model.evaluate(advsss, ad_labls) \n",
    "#Extremely bad filtering model against different type of attack"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(20, 28, 28, 1)"
      ]
     },
     "execution_count": 190,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "raw_np = raw.numpy()\n",
    "raw_np.shape\n",
    "imagess = images.numpy()\n",
    "labelss = tf.keras.utils.to_categorical(labels.numpy(), num_classes)\n",
    "count = 0\n",
    "for i in range(20):\n",
    "    pred = model.predict(raw_np[i, :, :, :].reshape(-1, 28, 28, 1)).argmax()\n",
    "    if pred == labels[i]:\n",
    "        count += 1\n",
    "print(\"Accuracy is \" + str(count / 20))\n",
    "is_adv_try = is_adv.numpy().astype('int')\n",
    "adv_model.evaluate(raw_np, np.ones((20,)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After this experiment, we can see that this filtering model is robust to different noise levels, but not very robust to different methods of attacks. We can see that against another gradient based attack, our filtering model was only able to filter out 80% of images. The other 20% still got through, meaning that a hacker may have to now try 4-5 attacks for atleast 1 to work. However, this is also not safe enough, since the model (once the image passes the filter), is guaranteed to get it wrong. \n",
    "\n",
    "Although we can use this as a filtering step when our application permits, we need a better approach."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now I will try to normalize all of the inputs to the layers of the neural network. Maybe, by standardizing inputs, we can reduce the impact a single pixel has, and hopefully make such models less suceptible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.layers import BatchNormalization"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Adding BatchNormalization After every input\n",
    "def create_batchnorm_model():\n",
    "    X_Input = Input((img_rows, img_cols, channels))\n",
    "    X = Conv2D(32, kernel_size=(3, 3), strides=(3, 3), padding='same', activation='relu')(X_Input)\n",
    "    X = BatchNormalization()(X, training=True)#\n",
    "    X = Conv2D(64, kernel_size=(3, 3), strides=(3, 3), padding='same', activation='relu')(X)\n",
    "    X = BatchNormalization()(X, training=True)#\n",
    "    X = Conv2D(64, kernel_size=(3, 3), strides=(3, 3), padding='same', activation='relu')(X)\n",
    "    X = MaxPooling2D(pool_size=(2, 2))(X)\n",
    "    X = BatchNormalization()(X, training=True)#\n",
    "    X = Dropout(0.2)(X)\n",
    "    X = Flatten()(X)\n",
    "    X = Dense(32)(X)\n",
    "    X = BatchNormalization()(X, training=True)#\n",
    "    X = Dropout(0.2)(X)\n",
    "    X = Dense(32)(X)\n",
    "    X = BatchNormalization()(X, training=True)#\n",
    "    X = Dropout(0.2)(X)\n",
    "    X = Dense(num_classes, activation='softmax')(X)\n",
    "    \n",
    "    model = Model(inputs = X_Input, outputs = X)\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_6\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_9 (InputLayer)         [(None, 28, 28, 1)]       0         \n",
      "_________________________________________________________________\n",
      "conv2d_21 (Conv2D)           (None, 10, 10, 32)        320       \n",
      "_________________________________________________________________\n",
      "batch_normalization_27 (Batc (None, 10, 10, 32)        128       \n",
      "_________________________________________________________________\n",
      "conv2d_22 (Conv2D)           (None, 4, 4, 64)          18496     \n",
      "_________________________________________________________________\n",
      "batch_normalization_28 (Batc (None, 4, 4, 64)          256       \n",
      "_________________________________________________________________\n",
      "conv2d_23 (Conv2D)           (None, 2, 2, 64)          36928     \n",
      "_________________________________________________________________\n",
      "max_pooling2d_6 (MaxPooling2 (None, 1, 1, 64)          0         \n",
      "_________________________________________________________________\n",
      "batch_normalization_29 (Batc (None, 1, 1, 64)          256       \n",
      "_________________________________________________________________\n",
      "dropout_18 (Dropout)         (None, 1, 1, 64)          0         \n",
      "_________________________________________________________________\n",
      "flatten_6 (Flatten)          (None, 64)                0         \n",
      "_________________________________________________________________\n",
      "dense_18 (Dense)             (None, 32)                2080      \n",
      "_________________________________________________________________\n",
      "batch_normalization_30 (Batc (None, 32)                128       \n",
      "_________________________________________________________________\n",
      "dropout_19 (Dropout)         (None, 32)                0         \n",
      "_________________________________________________________________\n",
      "dense_19 (Dense)             (None, 32)                1056      \n",
      "_________________________________________________________________\n",
      "batch_normalization_31 (Batc (None, 32)                128       \n",
      "_________________________________________________________________\n",
      "dropout_20 (Dropout)         (None, 32)                0         \n",
      "_________________________________________________________________\n",
      "dense_20 (Dense)             (None, 10)                330       \n",
      "=================================================================\n",
      "Total params: 60,106\n",
      "Trainable params: 59,658\n",
      "Non-trainable params: 448\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "batch_model = create_batchnorm_model()\n",
    "batch_model.compile(optimizer='adam', loss='mse', metrics=['accuracy'])\n",
    "batch_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "1875/1875 [==============================] - 11s 6ms/step - loss: 0.0156 - accuracy: 0.8971 - val_loss: 0.0049 - val_accuracy: 0.9683\n",
      "Epoch 2/20\n",
      "1875/1875 [==============================] - 11s 6ms/step - loss: 0.0070 - accuracy: 0.9551 - val_loss: 0.0045 - val_accuracy: 0.9713\n",
      "Epoch 3/20\n",
      " 509/1875 [=======>......................] - ETA: 8s - loss: 0.0059 - accuracy: 0.9623"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-52-5eecde6e6bea>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mhistory\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbatch_model\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_train\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbatch_size\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m32\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepochs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m20\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalidation_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mx_test\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/tensorflow/python/keras/engine/training.py\u001b[0m in \u001b[0;36m_method_wrapper\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m     64\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m_method_wrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     65\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_in_multi_worker_mode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 66\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     67\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     68\u001b[0m     \u001b[0;31m# Running inside `run_distribute_coordinator` already.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/tensorflow/python/keras/engine/training.py\u001b[0m in \u001b[0;36mfit\u001b[0;34m(self, x, y, batch_size, epochs, verbose, callbacks, validation_split, validation_data, shuffle, class_weight, sample_weight, initial_epoch, steps_per_epoch, validation_steps, validation_batch_size, validation_freq, max_queue_size, workers, use_multiprocessing)\u001b[0m\n\u001b[1;32m    846\u001b[0m                 batch_size=batch_size):\n\u001b[1;32m    847\u001b[0m               \u001b[0mcallbacks\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mon_train_batch_begin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 848\u001b[0;31m               \u001b[0mtmp_logs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtrain_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0miterator\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    849\u001b[0m               \u001b[0;31m# Catch OutOfRangeError for Datasets of unknown size.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    850\u001b[0m               \u001b[0;31m# This blocks until the batch has finished executing.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/tensorflow/python/eager/def_function.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m    578\u001b[0m         \u001b[0mxla_context\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mExit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    579\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 580\u001b[0;31m       \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    581\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    582\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mtracing_count\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_get_tracing_count\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/tensorflow/python/eager/def_function.py\u001b[0m in \u001b[0;36m_call\u001b[0;34m(self, *args, **kwds)\u001b[0m\n\u001b[1;32m    609\u001b[0m       \u001b[0;31m# In this case we have created variables on the first call, so we run the\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    610\u001b[0m       \u001b[0;31m# defunned version which is guaranteed to never create variables.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 611\u001b[0;31m       \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_stateless_fn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# pylint: disable=not-callable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    612\u001b[0m     \u001b[0;32melif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_stateful_fn\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    613\u001b[0m       \u001b[0;31m# Release the lock early so that multiple threads can perform the call\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   2418\u001b[0m     \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_lock\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2419\u001b[0m       \u001b[0mgraph_function\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_maybe_define_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2420\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mgraph_function\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_filtered_call\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# pylint: disable=protected-access\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2421\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2422\u001b[0m   \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36m_filtered_call\u001b[0;34m(self, args, kwargs)\u001b[0m\n\u001b[1;32m   1663\u001b[0m          if isinstance(t, (ops.Tensor,\n\u001b[1;32m   1664\u001b[0m                            resource_variable_ops.BaseResourceVariable))),\n\u001b[0;32m-> 1665\u001b[0;31m         self.captured_inputs)\n\u001b[0m\u001b[1;32m   1666\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1667\u001b[0m   \u001b[0;32mdef\u001b[0m \u001b[0m_call_flat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcaptured_inputs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcancellation_manager\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36m_call_flat\u001b[0;34m(self, args, captured_inputs, cancellation_manager)\u001b[0m\n\u001b[1;32m   1744\u001b[0m       \u001b[0;31m# No tape is watching; skip to running the function.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1745\u001b[0m       return self._build_call_outputs(self._inference_function.call(\n\u001b[0;32m-> 1746\u001b[0;31m           ctx, args, cancellation_manager=cancellation_manager))\n\u001b[0m\u001b[1;32m   1747\u001b[0m     forward_backward = self._select_forward_and_backward_functions(\n\u001b[1;32m   1748\u001b[0m         \u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/tensorflow/python/eager/function.py\u001b[0m in \u001b[0;36mcall\u001b[0;34m(self, ctx, args, cancellation_manager)\u001b[0m\n\u001b[1;32m    596\u001b[0m               \u001b[0minputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    597\u001b[0m               \u001b[0mattrs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mattrs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 598\u001b[0;31m               ctx=ctx)\n\u001b[0m\u001b[1;32m    599\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    600\u001b[0m           outputs = execute.execute_with_cancellation(\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/tensorflow/python/eager/execute.py\u001b[0m in \u001b[0;36mquick_execute\u001b[0;34m(op_name, num_outputs, inputs, attrs, ctx, name)\u001b[0m\n\u001b[1;32m     58\u001b[0m     \u001b[0mctx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mensure_initialized\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     59\u001b[0m     tensors = pywrap_tfe.TFE_Py_Execute(ctx._handle, device_name, op_name,\n\u001b[0;32m---> 60\u001b[0;31m                                         inputs, attrs, num_outputs)\n\u001b[0m\u001b[1;32m     61\u001b[0m   \u001b[0;32mexcept\u001b[0m \u001b[0mcore\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_NotOkStatusException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     62\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mname\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "history = batch_model.fit(x_train, y_train, batch_size=32, epochs=20, validation_data = (x_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Model's Accuracy is \n",
      "313/313 [==============================] - 0s 1ms/step - loss: 0.0029 - accuracy: 0.9818\n",
      "\n",
      "Batch Normalization Model's accuracy is \n",
      "313/313 [==============================] - 1s 2ms/step - loss: 0.0036 - accuracy: 0.9773\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.0036020977422595024, 0.9772999882698059]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Let's just double check to make sure we haven't decreased model accuracy - Generally, this shouldn't happen, although the large number of Batch Normalization layers might have an impact.\n",
    "print(\"Original Model's Accuracy is \")\n",
    "model.evaluate(x_test, y_test)\n",
    "print()\n",
    "print(\"Batch Normalization Model's accuracy is \")\n",
    "batch_model.evaluate(x_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The good thing is that Batch Norm has not decreased model accuracy, rather slightly increased it - although it is a small change and won't help much in performance.\n",
    "Now let's repeat the exercise to fool this model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def adversarial_pattern_m(model_t, image, label):\n",
    "    image = tf.cast(image, tf.float32)\n",
    "    \n",
    "    with tf.GradientTape() as tape:\n",
    "        tape.watch(image)\n",
    "        prediction = model_t(image)\n",
    "        loss = tf.keras.losses.MSE(label, prediction)\n",
    "    \n",
    "    gradient = tape.gradient(loss, image)\n",
    "    \n",
    "    signed_grad = tf.sign(gradient)\n",
    "    \n",
    "    return signed_grad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds = []\n",
    "x_adversarial = np.zeros((3000, 28, 28, 1))\n",
    "\n",
    "for i in range(3000):\n",
    "    image = x_train[i]\n",
    "    image_label = y_train[i]\n",
    "    \n",
    "#    perturbations = adversarial_pattern_m(batch_model, image.reshape((1, img_rows, img_cols, channels)), image_label).numpy()\n",
    "    perturbations = adversarial_pattern_m(batch_model, image.reshape((1, img_rows, img_cols, channels)), image_label).numpy()\n",
    "    adversarial = image + perturbations * 0.1\n",
    "    x_adversarial[i, :, :, :] = adversarial\n",
    "    preds.append(batch_model.predict(adversarial).argmax())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "94/94 [==============================] - 0s 2ms/step - loss: 0.0475 - accuracy: 0.6983\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.047455236315727234, 0.6983333230018616]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Let's hope that the model is more robust\n",
    "batch_model.evaluate(x_adversarial[0: 3000, :, :, :], y_train[0 : 3000, :])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7faba19d33c8>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "plt.imshow(x_adversarial[0, :, :, :].reshape(28, 28))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Saving Model Weights\n",
    "batch_model.save(\"batch_model.hdf5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It turns out that Batch Normalization during only test timeactually hurts the model. The reason for this must be that the model is used to inputs being normalized appropriately using BatchNorm, but adversarial examples are not normalized properly and so do worse.\n",
    "However, if batch normalization is used even during test time, the accuracy goes up to 69%, which is much better than 25%. This is because new values are used to normalize the input images."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next let's see if increasing the dropout a lot helps in reducing the dependence on each neuron, and makes the models more robust. I will be increasing dropout by 3 - 4 times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 274,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Increasing Dropout\n",
    "def dropout_inc_model():\n",
    "    X_Input = Input((img_rows, img_cols, channels))\n",
    "    X = Conv2D(32, kernel_size=(3, 3), strides=(3, 3), padding='same', activation='relu')(X_Input)\n",
    "    X = Conv2D(64, kernel_size=(3, 3), strides=(3, 3), padding='same', activation='relu')(X)\n",
    "    X = Conv2D(64, kernel_size=(3, 3), strides=(3, 3), padding='same', activation='relu')(X)\n",
    "    X = MaxPooling2D(pool_size=(2, 2))(X)\n",
    "    X = Dropout(0.8)(X)\n",
    "    X = Flatten()(X)\n",
    "    X = Dense(32)(X)\n",
    "    X = Dropout(0.6)(X)\n",
    "    X = Dense(32)(X)\n",
    "    X = Dropout(0.4)(X)\n",
    "    X = Dense(num_classes, activation='softmax')(X)\n",
    "    \n",
    "    model = Model(inputs = X_Input, outputs = X)\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 275,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_7\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_11 (InputLayer)        [(None, 28, 28, 1)]       0         \n",
      "_________________________________________________________________\n",
      "conv2d_28 (Conv2D)           (None, 10, 10, 32)        320       \n",
      "_________________________________________________________________\n",
      "conv2d_29 (Conv2D)           (None, 4, 4, 64)          18496     \n",
      "_________________________________________________________________\n",
      "conv2d_30 (Conv2D)           (None, 2, 2, 64)          36928     \n",
      "_________________________________________________________________\n",
      "max_pooling2d_9 (MaxPooling2 (None, 1, 1, 64)          0         \n",
      "_________________________________________________________________\n",
      "dropout_26 (Dropout)         (None, 1, 1, 64)          0         \n",
      "_________________________________________________________________\n",
      "flatten_9 (Flatten)          (None, 64)                0         \n",
      "_________________________________________________________________\n",
      "dense_26 (Dense)             (None, 32)                2080      \n",
      "_________________________________________________________________\n",
      "dropout_27 (Dropout)         (None, 32)                0         \n",
      "_________________________________________________________________\n",
      "dense_27 (Dense)             (None, 32)                1056      \n",
      "_________________________________________________________________\n",
      "dropout_28 (Dropout)         (None, 32)                0         \n",
      "_________________________________________________________________\n",
      "dense_28 (Dense)             (None, 10)                330       \n",
      "=================================================================\n",
      "Total params: 59,210\n",
      "Trainable params: 59,210\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "d_model = dropout_inc_model()\n",
    "d_model.compile('adam', loss='mse', metrics=['accuracy'])\n",
    "d_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "1875/1875 [==============================] - 5s 3ms/step - loss: 0.0643 - accuracy: 0.4692 - val_loss: 0.0285 - val_accuracy: 0.8567\n",
      "Epoch 2/20\n",
      "1875/1875 [==============================] - 5s 3ms/step - loss: 0.0481 - accuracy: 0.6383 - val_loss: 0.0182 - val_accuracy: 0.9051\n",
      "Epoch 3/20\n",
      "1875/1875 [==============================] - 5s 3ms/step - loss: 0.0436 - accuracy: 0.6799 - val_loss: 0.0150 - val_accuracy: 0.9158\n",
      "Epoch 4/20\n",
      "1875/1875 [==============================] - 5s 3ms/step - loss: 0.0406 - accuracy: 0.7053 - val_loss: 0.0126 - val_accuracy: 0.9294\n",
      "Epoch 5/20\n",
      "1875/1875 [==============================] - 5s 3ms/step - loss: 0.0385 - accuracy: 0.7241 - val_loss: 0.0115 - val_accuracy: 0.9300\n",
      "Epoch 6/20\n",
      "1875/1875 [==============================] - 5s 3ms/step - loss: 0.0375 - accuracy: 0.7354 - val_loss: 0.0110 - val_accuracy: 0.9347\n",
      "Epoch 7/20\n",
      "1875/1875 [==============================] - 5s 3ms/step - loss: 0.0356 - accuracy: 0.7509 - val_loss: 0.0102 - val_accuracy: 0.9382\n",
      "Epoch 8/20\n",
      "1875/1875 [==============================] - 5s 3ms/step - loss: 0.0353 - accuracy: 0.7552 - val_loss: 0.0107 - val_accuracy: 0.9338\n",
      "Epoch 9/20\n",
      "1875/1875 [==============================] - 5s 3ms/step - loss: 0.0339 - accuracy: 0.7687 - val_loss: 0.0104 - val_accuracy: 0.9370\n",
      "Epoch 10/20\n",
      "1875/1875 [==============================] - 5s 3ms/step - loss: 0.0333 - accuracy: 0.7735 - val_loss: 0.0097 - val_accuracy: 0.9417\n",
      "Epoch 11/20\n",
      "1875/1875 [==============================] - 5s 3ms/step - loss: 0.0322 - accuracy: 0.7844 - val_loss: 0.0094 - val_accuracy: 0.9428\n",
      "Epoch 12/20\n",
      "1875/1875 [==============================] - 5s 3ms/step - loss: 0.0318 - accuracy: 0.7886 - val_loss: 0.0104 - val_accuracy: 0.9382\n",
      "Epoch 13/20\n",
      "1875/1875 [==============================] - 5s 3ms/step - loss: 0.0312 - accuracy: 0.7933 - val_loss: 0.0103 - val_accuracy: 0.9406\n",
      "Epoch 14/20\n",
      "1875/1875 [==============================] - 6s 3ms/step - loss: 0.0306 - accuracy: 0.7987 - val_loss: 0.0107 - val_accuracy: 0.9366\n",
      "Epoch 15/20\n",
      "1875/1875 [==============================] - 6s 3ms/step - loss: 0.0301 - accuracy: 0.8025 - val_loss: 0.0107 - val_accuracy: 0.9380\n",
      "Epoch 16/20\n",
      "1875/1875 [==============================] - 6s 3ms/step - loss: 0.0297 - accuracy: 0.8065 - val_loss: 0.0094 - val_accuracy: 0.9446\n",
      "Epoch 17/20\n",
      "1875/1875 [==============================] - 6s 3ms/step - loss: 0.0292 - accuracy: 0.8098 - val_loss: 0.0098 - val_accuracy: 0.9415\n",
      "Epoch 18/20\n",
      "1875/1875 [==============================] - 6s 3ms/step - loss: 0.0295 - accuracy: 0.8083 - val_loss: 0.0105 - val_accuracy: 0.9402\n",
      "Epoch 19/20\n",
      "1875/1875 [==============================] - 6s 3ms/step - loss: 0.0292 - accuracy: 0.8103 - val_loss: 0.0096 - val_accuracy: 0.9428\n",
      "Epoch 20/20\n",
      "1875/1875 [==============================] - 6s 3ms/step - loss: 0.0286 - accuracy: 0.8145 - val_loss: 0.0100 - val_accuracy: 0.9413\n"
     ]
    }
   ],
   "source": [
    "history = d_model.fit(x_train, y_train, batch_size=32, epochs=20, validation_data = (x_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds = []\n",
    "x_adversarial = np.zeros((3000, 28, 28, 1))\n",
    "\n",
    "for i in range(3000):\n",
    "    image = x_train[i]\n",
    "    image_label = y_train[i]\n",
    "    \n",
    "    perturbations = adversarial_pattern_m(d_model, image.reshape((1, img_rows, img_cols, channels)), image_label).numpy()\n",
    "    adversarial = image + perturbations * 0.1\n",
    "    x_adversarial[i, :, :, :] = adversarial\n",
    "    preds.append(d_model.predict(adversarial).argmax())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 296,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "94/94 [==============================] - 0s 1ms/step - loss: 0.0240 - accuracy: 0.8497\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.023957913741469383, 0.8496666550636292]"
      ]
     },
     "execution_count": 296,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_model.evaluate(x_adversarial[0: 3000, :, :, :], y_train[0:3000, :])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Turns out that adding high amounts of dropout didn't help at all. This might be because of the small model, but this will generalize to larget models as well, in that increasing dropout may help performance a little, but not enough to make them secure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 299,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dropout_test_model():\n",
    "    X_Input = Input((img_rows, img_cols, channels))\n",
    "    X = Conv2D(32, kernel_size=(3, 3), strides=(3, 3), padding='same', activation='relu')(X_Input)\n",
    "    X = Dropout(0.4)(X, training=True)   #Extra block added\n",
    "    X = Conv2D(64, kernel_size=(3, 3), strides=(3, 3), padding='same', activation='relu')(X)\n",
    "    X = Conv2D(64, kernel_size=(3, 3), strides=(3, 3), padding='same', activation='relu')(X)\n",
    "    X = MaxPooling2D(pool_size=(2, 2))(X)\n",
    "    X = Dropout(0.4)(X, training=True)\n",
    "    X = Flatten()(X)\n",
    "    X = Dense(32)(X)\n",
    "    X = Dropout(0.2)(X, training=True)\n",
    "    X = Dense(32)(X)\n",
    "    X = Dropout(0.05)(X, training=True)\n",
    "    X = Dense(num_classes, activation='softmax')(X)\n",
    "    \n",
    "    model = Model(inputs = X_Input, outputs = X)\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_12\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_16 (InputLayer)        [(None, 28, 28, 1)]       0         \n",
      "_________________________________________________________________\n",
      "conv2d_43 (Conv2D)           (None, 10, 10, 32)        320       \n",
      "_________________________________________________________________\n",
      "dropout_41 (Dropout)         (None, 10, 10, 32)        0         \n",
      "_________________________________________________________________\n",
      "conv2d_44 (Conv2D)           (None, 4, 4, 64)          18496     \n",
      "_________________________________________________________________\n",
      "conv2d_45 (Conv2D)           (None, 2, 2, 64)          36928     \n",
      "_________________________________________________________________\n",
      "max_pooling2d_14 (MaxPooling (None, 1, 1, 64)          0         \n",
      "_________________________________________________________________\n",
      "dropout_42 (Dropout)         (None, 1, 1, 64)          0         \n",
      "_________________________________________________________________\n",
      "flatten_14 (Flatten)         (None, 64)                0         \n",
      "_________________________________________________________________\n",
      "dense_41 (Dense)             (None, 32)                2080      \n",
      "_________________________________________________________________\n",
      "dropout_43 (Dropout)         (None, 32)                0         \n",
      "_________________________________________________________________\n",
      "dense_42 (Dense)             (None, 32)                1056      \n",
      "_________________________________________________________________\n",
      "dropout_44 (Dropout)         (None, 32)                0         \n",
      "_________________________________________________________________\n",
      "dense_43 (Dense)             (None, 10)                330       \n",
      "=================================================================\n",
      "Total params: 59,210\n",
      "Trainable params: 59,210\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "d_model = dropout_test_model()\n",
    "d_model.compile('adam', loss='mse', metrics=['accuracy'])\n",
    "d_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 301,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "1875/1875 [==============================] - 7s 3ms/step - loss: 0.0262 - accuracy: 0.8164 - val_loss: 0.0163 - val_accuracy: 0.8916\n",
      "Epoch 2/20\n",
      "1875/1875 [==============================] - 6s 3ms/step - loss: 0.0139 - accuracy: 0.9082 - val_loss: 0.0123 - val_accuracy: 0.9198\n",
      "Epoch 3/20\n",
      "1875/1875 [==============================] - 6s 3ms/step - loss: 0.0117 - accuracy: 0.9241 - val_loss: 0.0108 - val_accuracy: 0.9304\n",
      "Epoch 4/20\n",
      "1875/1875 [==============================] - 7s 4ms/step - loss: 0.0105 - accuracy: 0.9323 - val_loss: 0.0097 - val_accuracy: 0.9383\n",
      "Epoch 5/20\n",
      "1875/1875 [==============================] - 7s 4ms/step - loss: 0.0097 - accuracy: 0.9374 - val_loss: 0.0092 - val_accuracy: 0.9411\n",
      "Epoch 6/20\n",
      "1875/1875 [==============================] - 7s 4ms/step - loss: 0.0092 - accuracy: 0.9413 - val_loss: 0.0087 - val_accuracy: 0.9460\n",
      "Epoch 7/20\n",
      "1875/1875 [==============================] - 7s 4ms/step - loss: 0.0087 - accuracy: 0.9447 - val_loss: 0.0089 - val_accuracy: 0.9418\n",
      "Epoch 8/20\n",
      "1875/1875 [==============================] - 7s 4ms/step - loss: 0.0084 - accuracy: 0.9462 - val_loss: 0.0084 - val_accuracy: 0.9462\n",
      "Epoch 9/20\n",
      "1875/1875 [==============================] - 7s 4ms/step - loss: 0.0081 - accuracy: 0.9481 - val_loss: 0.0081 - val_accuracy: 0.9474\n",
      "Epoch 10/20\n",
      "1875/1875 [==============================] - 7s 4ms/step - loss: 0.0079 - accuracy: 0.9496 - val_loss: 0.0079 - val_accuracy: 0.9480\n",
      "Epoch 11/20\n",
      "1875/1875 [==============================] - 8s 4ms/step - loss: 0.0076 - accuracy: 0.9516 - val_loss: 0.0082 - val_accuracy: 0.9480\n",
      "Epoch 12/20\n",
      "1875/1875 [==============================] - 8s 4ms/step - loss: 0.0076 - accuracy: 0.9519 - val_loss: 0.0075 - val_accuracy: 0.9526\n",
      "Epoch 13/20\n",
      "1875/1875 [==============================] - 7s 4ms/step - loss: 0.0074 - accuracy: 0.9535 - val_loss: 0.0077 - val_accuracy: 0.9515\n",
      "Epoch 14/20\n",
      "1875/1875 [==============================] - 7s 4ms/step - loss: 0.0073 - accuracy: 0.9538 - val_loss: 0.0071 - val_accuracy: 0.9559\n",
      "Epoch 15/20\n",
      "1875/1875 [==============================] - 7s 4ms/step - loss: 0.0072 - accuracy: 0.9543 - val_loss: 0.0067 - val_accuracy: 0.9582\n",
      "Epoch 16/20\n",
      "1875/1875 [==============================] - 10s 5ms/step - loss: 0.0070 - accuracy: 0.9557 - val_loss: 0.0076 - val_accuracy: 0.9513\n",
      "Epoch 17/20\n",
      "1875/1875 [==============================] - 12s 6ms/step - loss: 0.0070 - accuracy: 0.9554 - val_loss: 0.0069 - val_accuracy: 0.9571\n",
      "Epoch 18/20\n",
      "1875/1875 [==============================] - 13s 7ms/step - loss: 0.0068 - accuracy: 0.9575 - val_loss: 0.0072 - val_accuracy: 0.9533\n",
      "Epoch 19/20\n",
      "1875/1875 [==============================] - 12s 7ms/step - loss: 0.0068 - accuracy: 0.9565 - val_loss: 0.0070 - val_accuracy: 0.9573\n",
      "Epoch 20/20\n",
      "1875/1875 [==============================] - 12s 6ms/step - loss: 0.0067 - accuracy: 0.9581 - val_loss: 0.0067 - val_accuracy: 0.9579\n"
     ]
    }
   ],
   "source": [
    "history = d_model.fit(x_train, y_train, batch_size=32, epochs=20, validation_data = (x_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 302,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "313/313 [==============================] - 1s 3ms/step - loss: 0.0069 - accuracy: 0.9556\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.006904025096446276, 0.9556000232696533]"
      ]
     },
     "execution_count": 302,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_model.evaluate(x_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 304,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds = []\n",
    "x_adversarial = np.zeros((3000, 28, 28, 1))\n",
    "\n",
    "for i in range(3000):\n",
    "    image = x_train[i]\n",
    "    image_label = y_train[i]\n",
    "    \n",
    "    perturbations = adversarial_pattern_m(d_model, image.reshape((1, img_rows, img_cols, channels)), image_label).numpy()\n",
    "    adversarial = image + perturbations * 0.1\n",
    "    x_adversarial[i, :, :, :] = adversarial\n",
    "    preds.append(d_model.predict(adversarial).argmax())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 305,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "94/94 [==============================] - 0s 1ms/step - loss: 0.0491 - accuracy: 0.6870\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.04910464957356453, 0.6869999766349792]"
      ]
     },
     "execution_count": 305,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d_model.evaluate(x_adversarial[0: 3000, :, :, :], y_train[0:3000, :])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For image models, dropout in the convolutional layer is very important.\n",
    "Increasing dropout as much as possible will make the model more robust."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Previous dropout score - 0 / 0.4 / 0.2 / 0.05\n",
    "0.4156666696071625\n",
    "\n",
    "Current Dropout Score - 0.4 / 0.4 / 0.2 / 0.05\n",
    "0.6869999766349792\n",
    "\n",
    "These experiments show that increasing the dropout increases score a lot.\n",
    "\n",
    "However, there is a tradeoff - Increasing dropout too much prevents the model from learning the data properly, and hence model performs poorly. Lower dropout, and adversarial attacks are more successful. \n",
    "\n",
    "Now let's run a grid search for searching all values of dropout in the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dropout_grid_search(d1, d2, d3):\n",
    "    X_Input = Input((img_rows, img_cols, channels))\n",
    "    X = Conv2D(32, kernel_size=(3, 3), strides=(3, 3), padding='same', activation='relu')(X_Input)\n",
    "    X = Dropout(d1)(X, training=True)   #Extra block added\n",
    "    X = Conv2D(64, kernel_size=(3, 3), strides=(3, 3), padding='same', activation='relu')(X)\n",
    "    X = Conv2D(64, kernel_size=(3, 3), strides=(3, 3), padding='same', activation='relu')(X)\n",
    "    X = MaxPooling2D(pool_size=(2, 2))(X)\n",
    "    X = Dropout(d2)(X, training=True)\n",
    "    X = Flatten()(X)\n",
    "    X = Dense(32)(X)\n",
    "    X = Dropout(d3)(X, training=True)\n",
    "    X = Dense(32)(X)\n",
    "    X = Dropout(0.05)(X, training=True)\n",
    "    X = Dense(num_classes, activation='softmax')(X)\n",
    "    \n",
    "    model = Model(inputs = X_Input, outputs = X)\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# D1 best value = 0.45\n",
    "# D2 best value = 0.3\n",
    "# D3 best value = 0.075"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "fin_d_model = dropout_grid_search(0.45, 0.3, 0.075)\n",
    "fin_d_model.load_weights('dropout_model.hdf5')\n",
    "fin_d_model.compile('adam', loss='mse', metrics=['accuracy'])\n",
    "\n",
    "preprocessing = dict()\n",
    "bounds = (0, 1)\n",
    "fmodel = fb.TensorFlowModel(fin_d_model, bounds=bounds, preprocessing=preprocessing)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "images, labels = fb.utils.samples(fmodel, dataset='mnist', batchsize=20)\n",
    "fb.utils.accuracy(fmodel, images, labels)\n",
    "attack = fb.attacks.LinfPGD()\n",
    "epsilons = [0.0, 0.001, 0.01, 0.03, 0.1, 0.3, 0.5, 1.0]\n",
    "_, advs, success = attack(fmodel, images, labels, epsilons=epsilons)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<tf.Tensor: shape=(8, 20), dtype=bool, numpy=\n",
       "array([[False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "         True, False],\n",
       "       [False, False, False, False, False, False,  True, False, False,\n",
       "        False, False, False, False, False, False,  True, False, False,\n",
       "         True, False],\n",
       "       [False, False, False, False, False, False, False, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "         True, False],\n",
       "       [False, False, False, False, False, False,  True, False, False,\n",
       "        False, False, False, False, False, False, False, False, False,\n",
       "         True, False],\n",
       "       [False, False, False, False,  True, False,  True, False,  True,\n",
       "        False, False, False, False, False, False,  True, False, False,\n",
       "         True, False],\n",
       "       [ True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True,  True],\n",
       "       [ True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True,  True],\n",
       "       [ True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True,  True,  True,  True,  True,  True,  True,  True,  True,\n",
       "         True,  True]])>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "success"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 340,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/15\n",
      "1875/1875 [==============================] - 7s 4ms/step - loss: 0.0226 - accuracy: 0.8431 - val_loss: 0.0125 - val_accuracy: 0.9163\n",
      "Epoch 2/15\n",
      "1875/1875 [==============================] - 7s 4ms/step - loss: 0.0115 - accuracy: 0.9246 - val_loss: 0.0096 - val_accuracy: 0.9393\n",
      "Epoch 3/15\n",
      "1875/1875 [==============================] - 7s 4ms/step - loss: 0.0094 - accuracy: 0.9384 - val_loss: 0.0086 - val_accuracy: 0.9448\n",
      "Epoch 4/15\n",
      "1875/1875 [==============================] - 7s 4ms/step - loss: 0.0086 - accuracy: 0.9452 - val_loss: 0.0078 - val_accuracy: 0.9486\n",
      "Epoch 5/15\n",
      "1875/1875 [==============================] - 8s 4ms/step - loss: 0.0081 - accuracy: 0.9477 - val_loss: 0.0080 - val_accuracy: 0.9475\n",
      "Epoch 6/15\n",
      "1875/1875 [==============================] - 8s 4ms/step - loss: 0.0075 - accuracy: 0.9519 - val_loss: 0.0067 - val_accuracy: 0.9552\n",
      "Epoch 7/15\n",
      "1875/1875 [==============================] - 8s 4ms/step - loss: 0.0073 - accuracy: 0.9533 - val_loss: 0.0070 - val_accuracy: 0.9542\n",
      "Epoch 8/15\n",
      "1875/1875 [==============================] - 8s 4ms/step - loss: 0.0070 - accuracy: 0.9555 - val_loss: 0.0071 - val_accuracy: 0.9548\n",
      "Epoch 9/15\n",
      "1875/1875 [==============================] - 7s 4ms/step - loss: 0.0067 - accuracy: 0.9576 - val_loss: 0.0062 - val_accuracy: 0.9595\n",
      "Epoch 10/15\n",
      "1875/1875 [==============================] - 7s 4ms/step - loss: 0.0066 - accuracy: 0.9581 - val_loss: 0.0063 - val_accuracy: 0.9586\n",
      "Epoch 11/15\n",
      "1875/1875 [==============================] - 7s 4ms/step - loss: 0.0063 - accuracy: 0.9598 - val_loss: 0.0065 - val_accuracy: 0.9595\n",
      "Epoch 12/15\n",
      "1875/1875 [==============================] - 7s 4ms/step - loss: 0.0063 - accuracy: 0.9600 - val_loss: 0.0066 - val_accuracy: 0.9576\n",
      "Epoch 13/15\n",
      "1875/1875 [==============================] - 8s 4ms/step - loss: 0.0062 - accuracy: 0.9604 - val_loss: 0.0059 - val_accuracy: 0.9630\n",
      "Epoch 14/15\n",
      "1875/1875 [==============================] - 8s 4ms/step - loss: 0.0059 - accuracy: 0.9625 - val_loss: 0.0060 - val_accuracy: 0.9616\n",
      "Epoch 15/15\n",
      "1875/1875 [==============================] - 8s 4ms/step - loss: 0.0059 - accuracy: 0.9625 - val_loss: 0.0061 - val_accuracy: 0.9607\n"
     ]
    }
   ],
   "source": [
    "\n",
    "history = fin_d_model.fit(x_train, y_train, batch_size=32, epochs=15, validation_data = (x_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 341,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "313/313 [==============================] - 0s 1ms/step - loss: 0.0055 - accuracy: 0.9646\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.005549668334424496, 0.9646000266075134]"
      ]
     },
     "execution_count": 341,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fin_d_model.evaluate(x_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 343,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "94/94 [==============================] - 0s 1ms/step - loss: 0.0315 - accuracy: 0.7937\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.03149035573005676, 0.793666660785675]"
      ]
     },
     "execution_count": 343,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fin_d_model.evaluate(x_adversarial[0: 3000, :, :, :], y_train[0:3000, :])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The model is excellent against adversarial examples. Let's also increase noise to 20%."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 345,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "94/94 [==============================] - 0s 1ms/step - loss: 0.0897 - accuracy: 0.4267\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.08965112268924713, 0.4266666769981384]"
      ]
     },
     "execution_count": 345,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fin_d_model.evaluate(x_adversarial[0: 3000, :, :, :], y_train[0:3000, :])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 346,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Saving model weights\n",
    "fin_d_model.save(\"dropout_model.hdf5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Accuracy has gone down, quite a bit, but this is still much better than other techniques which went down to 15% or less.\n",
    "Combining this with other approaches might be extremely effective against adversarial examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 344,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds = []\n",
    "x_adversarial = np.zeros((3000, 28, 28, 1))\n",
    "\n",
    "for i in range(3000):\n",
    "    image = x_train[i]\n",
    "    image_label = y_train[i]\n",
    "    \n",
    "    perturbations = adversarial_pattern_m(fin_d_model, image.reshape((1, img_rows, img_cols, channels)), image_label).numpy()\n",
    "    adversarial = image + perturbations * 0.2\n",
    "    x_adversarial[i, :, :, :] = adversarial\n",
    "    preds.append(fin_d_model.predict(adversarial).argmax())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 336,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training for dropouts   0.05\n",
      "313/313 [==============================] - 0s 1ms/step - loss: 0.0061 - accuracy: 0.9615\n",
      "Training for dropouts   0.1\n",
      "313/313 [==============================] - 0s 1ms/step - loss: 0.0063 - accuracy: 0.9598\n",
      "Training for dropouts   0.15\n",
      "313/313 [==============================] - 0s 1ms/step - loss: 0.0068 - accuracy: 0.9560\n",
      "Training for dropouts   0.2\n",
      "313/313 [==============================] - 0s 1ms/step - loss: 0.0062 - accuracy: 0.9605\n",
      "Training for dropouts   0.25\n",
      "313/313 [==============================] - 0s 1ms/step - loss: 0.0067 - accuracy: 0.9581\n",
      "Training for dropouts   0.3\n",
      "313/313 [==============================] - 0s 1ms/step - loss: 0.0072 - accuracy: 0.9541\n"
     ]
    }
   ],
   "source": [
    "#d1s = [0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55]\n",
    "#d2s = [0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45]\n",
    "d3s = [0.05, 0.1, 0.15, 0.2, 0.25, 0.3]\n",
    "\n",
    "n_accuracy = []\n",
    "a_accuracy = []\n",
    "\n",
    "for d3 in d3s:\n",
    "    print(\"Training for dropouts   \" + str(d3))\n",
    "    d_model = dropout_grid_search(0.45, 0.3, d3)\n",
    "    d_model.compile('adam', loss='mse', metrics=['accuracy'])\n",
    "    history = d_model.fit(x_train, y_train, batch_size=32, epochs=15, validation_data = (x_test, y_test), verbose=0)\n",
    "\n",
    "    \n",
    "    preds = np.zeros(1000)\n",
    "    x_adversarial = np.zeros((1000, 28, 28, 1))\n",
    "    ys = np.zeros(1000)\n",
    "    for i in range(1000):\n",
    "        image = x_train[i]\n",
    "        image_label = y_train[i]\n",
    "\n",
    "        perturbations = adversarial_pattern_m(d_model, image.reshape((1, img_rows, img_cols, channels)), image_label).numpy()\n",
    "        adversarial = image + perturbations * 0.1\n",
    "        x_adversarial[i, :, :, :] = adversarial\n",
    "\n",
    "        preds[i] = d_model.predict(adversarial).argmax()\n",
    "        ys[i] = y_train[i].argmax()\n",
    "\n",
    "    a_accuracy.append((ys == preds).sum() / 1000)\n",
    "    n_accuracy.append(d_model.evaluate(x_test, y_test)[1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 337,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([0.9614999890327454,\n",
       "  0.9598000049591064,\n",
       "  0.9559999704360962,\n",
       "  0.9605000019073486,\n",
       "  0.9581000208854675,\n",
       "  0.9541000127792358],\n",
       " [0.762, 0.829, 0.57, 0.729, 0.639, 0.627])"
      ]
     },
     "execution_count": 337,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_accuracy, a_accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 338,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.7234999890327454,\n",
       " 1.7888000049591064,\n",
       " 1.525999970436096,\n",
       " 1.6895000019073487,\n",
       " 1.5971000208854675,\n",
       " 1.5811000127792358]"
      ]
     },
     "execution_count": 338,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tot = []\n",
    "for i in range(len(n_accuracy)):\n",
    "    tot.append(n_accuracy[i] + a_accuracy[i])\n",
    "tot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We already tried pre processing the image by running it through a noise fillter, however, higher level of noise rendered this filter useless. Hence, I will now try implementing a denoising autoencoder to clean the image. The reason this might work is that autoencoders are more robust to different kinds of noise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.layers import Conv2DTranspose, Reshape\n",
    "import tensorflow.keras.backend as K"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_denoiser(latent_dim = 16):\n",
    "    #________ENCODER______________\n",
    "    enc_input = Input(shape=(28, 28, 1))\n",
    "\n",
    "    enc = Conv2D(filters=32, kernel_size=(3, 3), strides=(2, 2), padding='Same', activation='relu')(enc_input)\n",
    "    enc = Conv2D(filters=64, kernel_size=(3, 3), strides=(2, 2), padding='Same', activation='relu')(enc)\n",
    "\n",
    "    enc_shape = K.int_shape(enc)\n",
    "\n",
    "    enc = Flatten()(enc)\n",
    "    enc = Dense(latent_dim)(enc)\n",
    "\n",
    "    encoder = Model(inputs=enc_input, outputs=enc)\n",
    "    \n",
    "    #______ DECODER ____________\n",
    "    dec_input = Input(shape=(latent_dim,))\n",
    "\n",
    "    dec = Dense(enc_shape[1] * enc_shape[2] * enc_shape[3])(dec_input)\n",
    "    dec = Reshape((enc_shape[1], enc_shape[2], enc_shape[3]))(dec)\n",
    "\n",
    "    dec = Conv2DTranspose(filters=64, kernel_size=(3, 3), strides=(2, 2), padding='Same', activation='relu')(dec)\n",
    "    dec = Conv2DTranspose(filters=32, kernel_size=(3, 3), strides=(2, 2), padding='Same', activation='relu')(dec)\n",
    "\n",
    "    dec = Conv2DTranspose(filters=1, kernel_size=(3, 3), padding='Same', activation='sigmoid')(dec)\n",
    "    decoder = Model(inputs=dec_input, outputs=dec)\n",
    "    \n",
    "    #_____ COMBINING ENCODER AND DECODER\n",
    "    denoiser = Model(inputs=enc_input, outputs=decoder(encoder(enc_input)))\n",
    "    return denoiser"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_3\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_2 (InputLayer)         [(None, 28, 28, 1)]       0         \n",
      "_________________________________________________________________\n",
      "model_1 (Model)              (None, 16)                69008     \n",
      "_________________________________________________________________\n",
      "model_2 (Model)              (None, 28, 28, 1)         108993    \n",
      "=================================================================\n",
      "Total params: 178,001\n",
      "Trainable params: 178,001\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "denoiser = build_denoiser()\n",
    "denoiser.load_weights(filepath='./denoiser.h5')\n",
    "denoiser.compile(loss='mse', optimizer='adam')\n",
    "denoiser.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds = []\n",
    "x_adversarial = np.zeros((3000, 28, 28, 1))\n",
    "\n",
    "for i in range(3000):\n",
    "    image = x_train[i]\n",
    "    image_label = y_train[i]\n",
    "    \n",
    "    perturbations = adversarial_pattern_m(model, image.reshape((1, img_rows, img_cols, channels)), image_label).numpy()\n",
    "    adversarial = image + perturbations * 0.2\n",
    "    x_adversarial[i, :, :, :] = adversarial\n",
    "    preds.append(model.predict(adversarial).argmax())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds = []\n",
    "x_adversarial_test = np.zeros((3000, 28, 28, 1))\n",
    "\n",
    "for i in range(3000):\n",
    "    image = x_test[i]\n",
    "    image_label = y_test[i]\n",
    "    \n",
    "    perturbations = adversarial_pattern_m(model, image.reshape((1, img_rows, img_cols, channels)), image_label).numpy()\n",
    "    adversarial = image + perturbations * 0.2\n",
    "    x_adversarial_test[i, :, :, :] = adversarial\n",
    "    preds.append(model.predict(adversarial).argmax())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "94/94 [==============================] - 1s 11ms/step - loss: 0.0372\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.037151604890823364"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "denoiser.evaluate(x_adversarial, x_train[0:3000, :, :, :])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/2\n",
      "24/24 [==============================] - 2s 70ms/step - loss: 0.0205\n",
      "Epoch 2/2\n",
      "24/24 [==============================] - 2s 71ms/step - loss: 0.0133\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7fada7255da0>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "denoiser.fit(x_adversarial, x_train[0:3000, :, :, :], epochs=2, batch_size=128)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "cleaned = denoiser.predict(x_adversarial)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 8, 5)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "pic = 11\n",
    "plt.imshow(x_adversarial[pic, :, :, :].reshape(28, 28))\n",
    "plt.imshow(cleaned[pic, :, :, :].reshape(28, 28))\n",
    "model.predict(cleaned[pic, :, : ,:].reshape(-1, 28, 28, 1)).argmax(), model.predict(x_adversarial[pic, :, : ,:].reshape(-1, 28, 28, 1)).argmax(), y_train[pic, :].argmax()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "cleaned_test = denoiser.predict(x_adversarial_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(9, 3, 9)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "pic = 20\n",
    "plt.imshow(x_adversarial_test[pic, :, :, :].reshape(28, 28))\n",
    "plt.imshow(cleaned_test[pic, :, :, :].reshape(28, 28))\n",
    "model.predict(cleaned_test[pic, :, : ,:].reshape(-1, 28, 28, 1)).argmax(), model.predict(x_adversarial_test[pic, :, : ,:].reshape(-1, 28, 28, 1)).argmax(), y_test[pic, :].argmax()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [],
   "source": [
    "cleaned_normal = denoiser.predict(x_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "313/313 [==============================] - 0s 1ms/step - loss: 0.0075 - accuracy: 0.9557\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.0074558500200510025, 0.9556999802589417]"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.evaluate(cleaned_normal, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 1, 1)"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "pic = 984\n",
    "plt.imshow(x_test[pic, :, :, :].reshape(28, 28))\n",
    "plt.imshow(cleaned_normal[pic, :, :, :].reshape(28, 28))\n",
    "model.predict(cleaned_normal[pic, :, : ,:].reshape(-1, 28, 28, 1)).argmax(), model.predict(x_test[pic, :, : ,:].reshape(-1, 28, 28, 1)).argmax(), y_test[pic, :].argmax()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "94/94 [==============================] - 0s 1ms/step - loss: 0.0264 - accuracy: 0.8457\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.02642643451690674, 0.8456666469573975]"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.evaluate(cleaned_test, y_test[0:3000, :])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds_test_cl = model.predict(cleaned_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "33 0 4\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "43 1 2\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "48 9 4\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD4CAYAAAAq5pAIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAQbklEQVR4nO3dW4xd5XnG8eeZYWx8woeAHWMggINKUVVIMqGpiIA0aUR8UZOLVHElRCUU5yKoiZSLInoRLlHVJEoPiuQUBKlSEE2C8AWiuBTVpQqIgbpgcKmBGmM82BwK+DyH/fZiNu0EZr1r2Ofx9/9Joz2z31l7f7NnP7P27Het73NECMDpb6jfAwDQG4QdKARhBwpB2IFCEHagEGf08s4WeXGcqWW9vEugKCd1TBNxynPV2gq77esk/UjSsKS/jYjbs+8/U8v0O0Nfqv6GdtqAnvPnm1Vv80VMNJIa7Uv0UPJcf6LxT5W1lhNge1jS30j6iqTLJG2xfVmrtwegu9rZ3V0p6cWIeDkiJiTdK2lzZ4YFoNPaCfsGSa/O+vpA87pfY3ur7THbY5M61cbdAWhHO2Gf6x+HD/3zGhHbImI0IkZHtLiNuwPQjnbCfkDS+bO+Pk/SwfaGA6Bb2gn7k5IusX2R7UWSvi5pe2eGBaDTWm69RcSU7Zsl/aNmWm93RsRz89iw1bts73Zjujv3C/Raixlqq88eEQ9KerCd2wDQGxwuCxSCsAOFIOxAIQg7UAjCDhSCsAOF6On57Atadgotp7hiAWDPDhSCsAOFIOxAIQg7UAjCDhSCsAOFoPU2Tx4erqzF1FQPRwK0hj07UAjCDhSCsAOFIOxAIQg7UAjCDhSCsAOFoM8+T/TSsdCxZwcKQdiBQhB2oBCEHSgEYQcKQdiBQhB2oBCEHShEWwfV2N4n6YikaUlTETHaiUEB6LxOHEH3hYh4swO3A6CLeBkPFKLdsIekh20/ZXvrXN9ge6vtMdtjkzrV5t0BaFW7L+OvioiDttdK2mH7PyNi5+xviIhtkrZJ0llew6JoQJ+0tWePiIPNy8OS7pd0ZScGBaDzWg677WW2V7z/uaQvS9rdqYEB6Kx2Xsavk3S/Z5YyPkPS30fEQx0ZFcqQLYOtfK5+SRpasSKtN44fb/m2fUZNNGq2j1P5+1MxMVFdm57O7zu94epSy2GPiJclXd7q9gB6i9YbUAjCDhSCsAOFIOxAIQg7UIjeTyWdtVuCA+wWnKGaFlbSovJI/vQb+vjatP7OZ9al9ZNrqvdlRy5KN9X0ovy5uGJfvp9cNp63z5a/eqKyNvzfr6fbNt55t7p4qjpf7NmBQhB2oBCEHSgEYQcKQdiBQhB2oBCEHShE7/vsJfbSa07llPO/uR7Kt49G8phGI7/tutNIly5N61r7sbQ8cd7qytq7Fy9Ot33r8vy58kfX/FtaP2/R25W1fzj4mXTb/WMb0vrQZD62qTNrfqfTyfYnTqbbKj0Ftvp22bMDhSDsQCEIO1AIwg4UgrADhSDsQCEIO1CI3vfZT0PtTjs8tHxZvn0bUwt7WX7bExfn54TvnXNRr/931SdfSuu/t7q6Fz7i/Oeajvz4gpdO5WP/y+e/UFlbtPOsdNuNvzqS1oeOV08FLUl+71haj6PV9UZNnz0/rqK6xJ4dKARhBwpB2IFCEHagEIQdKARhBwpB2IFC0GfvgLTvKWl4aX7etlfmPd8Tnzw7rb/3iZHK2tlb9qfbbtv4V2n9opHlaX3/1NG0/vp09c/+169/Md32sRcuSeurHl+U1i948r3K2vBbB9Jt4+138vrUVFpvJEsy12lryeZE7Z7d9p22D9vePeu6NbZ32N7bvKyeoQDAQJjPy/i7JF33getukfRIRFwi6ZHm1wAGWG3YI2KnpA/O77NZ0t3Nz++WdH2HxwWgw1p9g25dRIxLUvOyclEu21ttj9kem9SpFu8OQLu6/m58RGyLiNGIGB1R/kYVgO5pNeyHbK+XpObl4c4NCUA3tBr27ZJubH5+o6QHOjMcAN1S22e3fY+kayWdbfuApO9Jul3SfbZvkrRf0te6OciBkMz9Xjf3upcuSevHLj0nrb/1jfzc6M+d+0pl7Yurnk+3/fmRy9P6ffvy+dWPPZ4fA7DkcPUxCCPH8uMTLnwj72UveXE8rceb1fPGT5+qef+ortddM9d/3bEX6Xz+dWsr1K1DUKE27BGxpaKUHxEBYKBwuCxQCMIOFIKwA4Ug7EAhCDtQCE5xna+k1eJF1aeYSpLOzI8cPPTZfPsbNj6V1h8av6yy9tiDeWvt3H/NW1DnvPZuWl97Kj9VVCerbz+W58tBe6qm/TWZt+ZSNa2x+tbZZE29i0uTt3jb7NmBQhB2oBCEHSgEYQcKQdiBQhB2oBCEHSgEffb3DdWcpjpS/VANrVqZbju5Pp98d/rS/BTWl47np8C+/ej6ytqFD+VTInvfa2k96nrZdaf3nrWistZYlS8nPfx2Pk11HMsft0ZyGmtM9bFP3ifs2YFCEHagEIQdKARhBwpB2IFCEHagEIQdKAR99vnKphaumXZ4aDKvL3kiX7L5V7t/O62v2lc9LbFr7ruuT56djy5JWpQvm6xkaePh8eqpniUpTp5M642jeZ89Xfq43T563XTOA9inZ88OFIKwA4Ug7EAhCDtQCMIOFIKwA4Ug7EAhet9nz/qTNcvgZksjpz1VSWrU1LMldCVFsnnjSH7e9fBreU92/b/kPdkTG/LzvieXVz9ujaV5H9wb1ub1Q3kvXBP5eeHZYxM129aec15nAHvdnTC0onqOAB+tfi7U7tlt32n7sO3ds667zfZrtnc1PzZ91AED6K35vIy/S9J1c1z/w4i4ovnxYGeHBaDTasMeETsl1byWAzDo2nmD7mbbzzRf5ldOsmZ7q+0x22OTqjnOGkDXtBr2H0vaKOkKSeOSvl/1jRGxLSJGI2J0RPkChwC6p6WwR8ShiJiOiIakn0i6srPDAtBpLYXd9uy5i78qaXfV9wIYDLV9dtv3SLpW0tm2D0j6nqRrbV8hKSTtk/TNjoymphcedb3ydrTRk22cyM+7jmT+ckny/+Rzuy87mJ/vrlXV9cNX53POH1+bHwNwwcP52vFDe/en9fSx6ebvs9vqni9dPN+9cex49c02qo8XqQ17RGyZ4+o75jUqAAODw2WBQhB2oBCEHSgEYQcKQdiBQvT+FNfT8bTDupZh5G2YSKZbllR7Gulwo/oxnTgrP4V15ecPpfXXj6xL6+e+UPP7rDl1+LTVzed5iy1L9uxAIQg7UAjCDhSCsAOFIOxAIQg7UAjCDhSCJZt7od2ea01ftfHOu5W1kaP5fV937p60fu+avM8eExNp/bQ8rmKBYs8OFIKwA4Ug7EAhCDtQCMIOFIKwA4Ug7EAh6LOfDoaqz5efXpyfS//WZL4c9FDNil1BH733smmqk18He3agEIQdKARhBwpB2IFCEHagEIQdKARhBwpBn30hqFn+d3jN6sraxNXvtXXXq/fWzFE+vYCXXV6oWjy2oXbPbvt824/a3mP7Odvfbl6/xvYO23ubl9XPOAB9N5+X8VOSvhsRvynpc5K+ZfsySbdIeiQiLpH0SPNrAAOqNuwRMR4RTzc/PyJpj6QNkjZLurv5bXdLur5bgwTQvo/0Bp3tCyV9StITktZFxLg08wdB0pyLitneanvM9tikag60BtA18w677eWSfiHpOxEx73d9ImJbRIxGxOiIFrcyRgAdMK+w2x7RTNB/FhG/bF59yPb6Zn29pMPdGSKATqhtvdm2pDsk7YmIH8wqbZd0o6Tbm5cPdGWEC0FNa6y2VVLXWlt7Tlp//Q8uqqz9yWXb023vPfDZtL7y8QNpfYrW24Ixnz77VZJukPSs7V3N627VTMjvs32TpP2SvtadIQLohNqwR8Rjkqp2PV/s7HAAdAuHywKFIOxAIQg7UAjCDhSCsAOF4BTXXhgaTsvDK89K629s2pjWRza/UVk7NLky3fbIz9en9SVv/ntaZ0nmhYM9O1AIwg4UgrADhSDsQCEIO1AIwg4UgrADhaDP3gE+YyStD521PK1PXXpBWn/rmom0vumcVytrdz39u+m2v/FUPulQTE2ldSwc7NmBQhB2oBCEHSgEYQcKQdiBQhB2oBCEHSjEwuqzZ/Ord/u86uS+h5YtSTed3rghrb92zdK0vmzlO2n94R2frqxd9M95j37opXxe+Om6eeHbnTMfPcOeHSgEYQcKQdiBQhB2oBCEHSgEYQcKQdiBQsxnffbzJf1U0sclNSRti4gf2b5N0jckvT9p+a0R8WC3Biqprz1bDydzv2c1SUPHJ9P6yJH8viefXJXWNzxV3Utf8mL1nPKSNH3sRH7ndeijLxjzOahmStJ3I+Jp2yskPWV7R7P2w4j4i+4ND0CnzGd99nFJ483Pj9jeIyk/JAzAwPlI/7PbvlDSpyQ90bzqZtvP2L7T9uqKbbbaHrM9NqlTbQ0WQOvmHXbbyyX9QtJ3IuI9ST+WtFHSFZrZ839/ru0iYltEjEbE6IgWd2DIAFoxr7DbHtFM0H8WEb+UpIg4FBHTEdGQ9BNJV3ZvmADaVRt225Z0h6Q9EfGDWdfPXv7zq5J2d354ADplPu/GXyXpBknP2t7VvO5WSVtsXyEpJO2T9M2ujHABiJP5exE+9FZaX78zP03UJ/PWnd6png46TpzMt41GTZ3W2uliPu/GPyZprmdjd3vqADqKI+iAQhB2oBCEHSgEYQcKQdiBQhB2oBALayrpbqqbEtnVfxdjoqYPHsfym34ln+5ZI4tqbj/plY/U/IqTn0uSNJSfvlvbp0+37WMPv43ftySpUTPF9gBizw4UgrADhSDsQCEIO1AIwg4UgrADhSDsQCEcPex12n5D0iuzrjpb0ps9G8BHM6hjG9RxSYytVZ0c2yci4py5Cj0N+4fu3B6LiNG+DSAxqGMb1HFJjK1VvRobL+OBQhB2oBD9Dvu2Pt9/ZlDHNqjjkhhbq3oytr7+zw6gd/q9ZwfQI4QdKERfwm77Otsv2H7R9i39GEMV2/tsP2t7l+2xPo/lTtuHbe+edd0a2zts721ezrnGXp/Gdpvt15qP3S7bm/o0tvNtP2p7j+3nbH+7eX1fH7tkXD153Hr+P7vtYUn/Jen3JR2Q9KSkLRHxfE8HUsH2PkmjEdH3AzBsXy3pqKSfRsRvNa/7c0lvR8TtzT+UqyPiTwdkbLdJOtrvZbybqxWtn73MuKTrJf2x+vjYJeP6Q/XgcevHnv1KSS9GxMsRMSHpXkmb+zCOgRcROyW9/YGrN0u6u/n53Zp5svRcxdgGQkSMR8TTzc+PSHp/mfG+PnbJuHqiH2HfIOnVWV8f0GCt9x6SHrb9lO2t/R7MHNZFxLg08+SRtLbP4/mg2mW8e+kDy4wPzGPXyvLn7epH2Oea/GuQ+n9XRcSnJX1F0reaL1cxP/NaxrtX5lhmfCC0uvx5u/oR9gOSzp/19XmSDvZhHHOKiIPNy8OS7tfgLUV96P0VdJuXh/s8nv8zSMt4z7XMuAbgsevn8uf9CPuTki6xfZHtRZK+Lml7H8bxIbaXNd84ke1lkr6swVuKerukG5uf3yjpgT6O5dcMyjLeVcuMq8+PXd+XP4+Inn9I2qSZd+RfkvRn/RhDxbgulvQfzY/n+j02Sfdo5mXdpGZeEd0k6WOSHpG0t3m5ZoDG9neSnpX0jGaCtb5PY/u8Zv41fEbSrubHpn4/dsm4evK4cbgsUAiOoAMKQdiBQhB2oBCEHSgEYQcKQdiBQhB2oBD/C9muKVB4zrF1AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "59 7 5\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "61 3 8\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "62 8 9\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "63 2 3\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "65 9 4\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "66 3 6\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD4CAYAAAAq5pAIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAQRElEQVR4nO3df2xd9XnH8c9jJ3FSJ5T8XgihQAqFQEcAl6zN2CioXQBVodNaEYmSdkiptGZqtUobg3agaZXQWkATa2lTiJq2jK5SQaSIFaIMlKFtIYaF/CCMBAhJiLGXJjQ/gMQ/nv3hk8pNfJ5j7q9z4+/7JVnXvs/93vv42h+f6/s953zN3QVg9GspuwEAjUHYgUQQdiARhB1IBGEHEjGmkQ82ztp8vNob+ZBAUt7TER3zozZcraqwm9kiSf8kqVXSA+5+V3T78WrXArummocEEFjva3NrFb+MN7NWSd+VdK2keZKWmNm8Su8PQH1V8z/7FZJ2uPtr7n5M0s8kLa5NWwBqrZqwz5a0e8jXe7LrfoeZLTOzTjPr7NXRKh4OQDWqCftwbwKctO+tu69w9w537xirtioeDkA1qgn7Hklzhnx9pqS91bUDoF6qCfsGSeeZ2TlmNk7SjZJW16YtALVW8dSbu/eZ2XJJT2pw6m2lu2+tWWcAaqqqeXZ3f0LSEzXqBUAdsbsskAjCDiSCsAOJIOxAIgg7kAjCDiSCsAOJIOxAIgg7kAjCDiSCsAOJIOxAIgg7kIiGnkoaOWzYM/8OqVf+N9laW+MbtBQ8dn9/WPaCejyYRUUbiS07kAjCDiSCsAOJIOxAIgg7kAjCDiSCsAOJYJ69BlrGj4/rZ/xeWH/z+jPC+gU3vhzWr56SXz9/3Fvh2EvbjoT1gSrnwp9856QVwX7ru7d+Phx72nO7w3p/d09Y976+sJ4atuxAIgg7kAjCDiSCsAOJIOxAIgg7kAjCDiTCvIHHFJ9mU3yBXdOwx6slG5O/S4LN+3A4tu/eeC77m+f8MqyfO+ZwWB8XHA//0rFJ4di3Bz4Q1vs93h5MH3MwrEf2908M6z/u+nhYP/CtD4X1trUbc2ujdQ5+va/VQd8/7C9EVTvVmNlOSYck9Uvqc/eOau4PQP3UYg+6T7r7vhrcD4A64n92IBHVht0lPWVmz5vZsuFuYGbLzKzTzDp7dbTKhwNQqWpfxi90971mNkPSGjN72d3XDb2Bu6+QtEIafIOuyscDUKGqtuzuvje77JH0qKQratEUgNqrOOxm1m5mk45/LunTkrbUqjEAtVXNy/iZkh61wTneMZL+xd1/VZOuylBw7vaWSfnz1V1XTgnHXj91a1h/5EA8Y/n4yx8N66c/k388/cxfxceE+28K5sknxMfqW3s8T39w/szc2uW3Px+O/dZZj4X1+/7h6rD+evf5uTV/cVs4djSe077isLv7a5IuqWEvAOqIqTcgEYQdSARhBxJB2IFEEHYgERzielxLvLRx67ln5dYOXjIjHNvbHv9Nndr567Cu7vg4o4HD+YfQem/BoZwDBUsuFy0nXSRYbnrMjGnh0De+ODesL785npr79pOfya2d/43N4diBI/Fhyc0qOsSVLTuQCMIOJIKwA4kg7EAiCDuQCMIOJIKwA4lgyebjfCCuH8qfd524651waOvueGnhgSPx+IHD8amkQ0X7UVQ7j150/54/j99XsOTynPvi7/unVy0I6zdfvS63tn7WR8Kx2vF6XD8FsWUHEkHYgUQQdiARhB1IBGEHEkHYgUQQdiARzLMfFxx3PVjOr7ds3xWO7T/ybvzYRXP8Rb21xsfih1riefZoqWpJGngn3kegmlMy+7HesL53x/Swfsncp3JrD/35H4dj5/59V1gfeO+9sN6M2LIDiSDsQCIIO5AIwg4kgrADiSDsQCIIO5AI5tmPK5jr7nuru4r7LphrLjhnfREb3xbU4iWX37sk/3z4kmQFrbftOhDW+4Pjwgv3Dyj4mXzwpXj82dfnn49/4dVbwrHd97SHdY3GeXYzW2lmPWa2Zch1U8xsjZltzy4n17dNANUaycv4H0ladMJ1t0pa6+7nSVqbfQ2giRWG3d3XSdp/wtWLJa3KPl8l6YYa9wWgxip9g26mu3dJUnaZu9iZmS0zs04z6+zV0QofDkC16v5uvLuvcPcOd+8Yq/w3kgDUV6Vh7zazWZKUXcanCQVQukrDvlrS0uzzpZLitXMBlK5wnt3MHpZ0laRpZrZH0h2S7pL0czO7RdIuSZ+rZ5MNUc351atd475ojfSi4cF55e3YsXDshC17wvqRy+J5eN9b+f4H3lewdnyB9p74edt0dHZubd7EveHY7umXxQ++L38Ov1kVht3dl+SUrqlxLwDqiN1lgUQQdiARhB1IBGEHEkHYgURwiOtIVTu9Vk9Bb3403kW5aNnk8WvfDusDBfdfTx94Mz7M9LTW/PqhgQnxnQenDj9Vjb7vCMCwCDuQCMIOJIKwA4kg7EAiCDuQCMIOJIJ59tQV7D9QNE9fppa++FTTZ4zJP831A29eGd95975KWmpqbNmBRBB2IBGEHUgEYQcSQdiBRBB2IBGEHUgE8+xoWjYm/vXsuXxiWJ/akr+PwNbtZ4ZjLzi8OayfitiyA4kg7EAiCDuQCMIOJIKwA4kg7EAiCDuQCObZUZ5oGWxJLWfPCet/9hf/HtaPeP6vd/uOseFYtbbG9ZaCepXLcNdD4ZbdzFaaWY+ZbRly3Z1m9qaZbcw+rqtvmwCqNZKX8T+StGiY6+919/nZxxO1bQtArRWG3d3XSdrfgF4A1FE1b9AtN7NN2cv8yXk3MrNlZtZpZp29at7zmQGjXaVhv1/SXEnzJXVJujvvhu6+wt073L1jrNoqfDgA1aoo7O7e7e797j4g6YeSrqhtWwBqraKwm9msIV9+VtKWvNsCaA6F8+xm9rCkqyRNM7M9ku6QdJWZzZfkknZK+nIde2wO0ZxwM6/d3sRaTz89rB+4L94W/cmk+JjzB/blnxt+xv8cC8cWrs/u8Tnrm1Fh2N19yTBXP1iHXgDUEbvLAokg7EAiCDuQCMIOJIKwA4ngENeRsvy/izYufhr9WME0z6k8dVd0mOqECbm1V267IBz7zEXfDuvPvhsfAvv4f16WW/tI98FwrLUWTb2dej8ztuxAIgg7kAjCDiSCsAOJIOxAIgg7kAjCDiSCefZM0fLALeecVfF997/6RnwDL/G0wwXz5DYmPuXywMcuDOtvf/Nwbu2/L/5OOLa3YCr77u2fCuuznwmK/fGde/+pdwhrEbbsQCIIO5AIwg4kgrADiSDsQCIIO5AIwg4kYvTMsxcsodsyPl6Nxi+aG9Z3/W3+vOuRt9rDsRfefiCs9x+I6/XUMnFiWPcLzg7rH7+/M6z/1dT8+qGBeK77ppdvCutjfzolrJ/23O7cmh88FI713t6wfipiyw4kgrADiSDsQCIIO5AIwg4kgrADiSDsQCJGzzz7QHxMuPfH9V2LJoX1lfPvy63926HfD8euW/CJsN729Kaw7kePhvVoH4MxZ80Oh75+05lh/Xtf+n5YXzg+no/u9fzebtn+uXBs2zfin8mETRvDet+xoLeiJZdPwfPCFyncspvZHDN72sy2mdlWM/tqdv0UM1tjZtuzy8n1bxdApUbyMr5P0tfd/UJJfyDpK2Y2T9Ktkta6+3mS1mZfA2hShWF39y53fyH7/JCkbZJmS1osaVV2s1WSbqhXkwCq977eoDOzsyVdKmm9pJnu3iUN/kGQNCNnzDIz6zSzzl4V/O8JoG5GHHYzmyjpF5K+5u7xqnhDuPsKd+9w946xig9GAVA/Iwq7mY3VYNAfcvdHsqu7zWxWVp8lqac+LQKohcKpNzMzSQ9K2ubu9wwprZa0VNJd2eVjdemwVgqm3jw+o7Kmt76bW7vxgxvCsbvujA/F7Pzo5WF92qZ4yefdN+d/b//6iR+EYy8eV/CNF9jXH/9rduWzy3Nr598Rv0AceH1bXC/4mYbTZwWn0B6NRjLPvlDSFyRtNrPjE5u3aTDkPzezWyTtkhRPmgIoVWHY3f1ZSXl/Bq+pbTsA6oXdZYFEEHYgEYQdSARhBxJB2IFEmDfwUL7TbIovsJLewC841XTrhR8O6xf95JXc2l9O+49w7KzWCWG9JXeyY1Cf4vnkNouXVY78ZiB//wFJevhg/Lz84J8Xh/UzHtuZW+vf9+twbOGhvTjJel+rg75/2F8otuxAIgg7kAjCDiSCsAOJIOxAIgg7kAjCDiRi9JxKukjRqYN79ofl5/7uY7m1q669Ihz71598PKz/6aT8OXxJOlKwtPH+oP6lF5eGY6d+P16yecKGV8P6jP3/Fdb7RuEpmU9VbNmBRBB2IBGEHUgEYQcSQdiBRBB2IBGEHUhEOsezAwngeHYAhB1IBWEHEkHYgUQQdiARhB1IBGEHElEYdjObY2ZPm9k2M9tqZl/Nrr/TzN40s43Zx3X1bxdApUZy8oo+SV939xfMbJKk581sTVa7192/U7/2ANTKSNZn75LUlX1+yMy2SZpd78YA1Nb7+p/dzM6WdKmk9dlVy81sk5mtNLPJOWOWmVmnmXX2iuV8gLKMOOxmNlHSLyR9zd0PSrpf0lxJ8zW45b97uHHuvsLdO9y9Y6zaatAygEqMKOxmNlaDQX/I3R+RJHfvdvd+dx+Q9ENJ8VkXAZRqJO/Gm6QHJW1z93uGXD9ryM0+K2lL7dsDUCsjeTd+oaQvSNpsZhuz626TtMTM5ktySTslfbkuHQKoiZG8G/+sNOwC4k/Uvh0A9cIedEAiCDuQCMIOJIKwA4kg7EAiCDuQCMIOJIKwA4kg7EAiCDuQCMIOJIKwA4kg7EAiCDuQiIYu2Wxm/yfpjSFXTZO0r2ENvD/N2luz9iXRW6Vq2duH3H36cIWGhv2kBzfrdPeO0hoINGtvzdqXRG+ValRvvIwHEkHYgUSUHfYVJT9+pFl7a9a+JHqrVEN6K/V/dgCNU/aWHUCDEHYgEaWE3cwWmdn/mtkOM7u1jB7ymNlOM9ucLUPdWXIvK82sx8y2DLluipmtMbPt2eWwa+yV1FtTLOMdLDNe6nNX9vLnDf+f3cxaJb0i6VOS9kjaIGmJu7/U0EZymNlOSR3uXvoOGGb2R5IOS/qxu1+cXfePkva7+13ZH8rJ7v43TdLbnZIOl72Md7Za0ayhy4xLukHSF1Xicxf09Xk14HkrY8t+haQd7v6aux+T9DNJi0voo+m5+zpJ+0+4erGkVdnnqzT4y9JwOb01BXfvcvcXss8PSTq+zHipz13QV0OUEfbZknYP+XqPmmu9d5f0lJk9b2bLym5mGDPdvUsa/OWRNKPkfk5UuIx3I52wzHjTPHeVLH9erTLCPtxSUs00/7fQ3S+TdK2kr2QvVzEyI1rGu1GGWWa8KVS6/Hm1ygj7Hklzhnx9pqS9JfQxLHffm132SHpUzbcUdffxFXSzy56S+/mtZlrGe7hlxtUEz12Zy5+XEfYNks4zs3PMbJykGyWtLqGPk5hZe/bGicysXdKn1XxLUa+WtDT7fKmkx0rs5Xc0yzLeecuMq+TnrvTlz9294R+SrtPgO/KvSrq9jB5y+jpX0ovZx9aye5P0sAZf1vVq8BXRLZKmSloraXt2OaWJevuJpM2SNmkwWLNK6u0PNfiv4SZJG7OP68p+7oK+GvK8sbsskAj2oAMSQdiBRBB2IBGEHUgEYQcSQdiBRBB2IBH/DzO3BX5KYQ2AAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "72 3 2\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "73 7 9\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "77 7 2\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "92 4 9\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "104 5 9\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "115 9 4\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "149 3 2\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "151 8 9\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "175 1 7\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "195 1 3\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "217 5 6\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "230 5 3\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "235 7 9\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"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "241 8 9\n"
     ]
    },
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-61-3e018b6c0496>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mpreds_test_cl\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m         \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcleaned_test\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m28\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m28\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m         \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mpreds_test_cl\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my_test\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36mshow\u001b[0;34m(*args, **kw)\u001b[0m\n\u001b[1;32m    261\u001b[0m     \"\"\"\n\u001b[1;32m    262\u001b[0m     \u001b[0;32mglobal\u001b[0m \u001b[0m_show\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 263\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0m_show\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    264\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    265\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/ipykernel/pylab/backend_inline.py\u001b[0m in \u001b[0;36mshow\u001b[0;34m(close, block)\u001b[0m\n\u001b[1;32m     37\u001b[0m             display(\n\u001b[1;32m     38\u001b[0m                 \u001b[0mfigure_manager\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 39\u001b[0;31m                 \u001b[0mmetadata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0m_fetch_figure_metadata\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfigure_manager\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfigure\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     40\u001b[0m             )\n\u001b[1;32m     41\u001b[0m     \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/IPython/core/display.py\u001b[0m in \u001b[0;36mdisplay\u001b[0;34m(include, exclude, metadata, transient, display_id, *objs, **kwargs)\u001b[0m\n\u001b[1;32m    304\u001b[0m             \u001b[0mpublish_display_data\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetadata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmetadata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    305\u001b[0m         \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 306\u001b[0;31m             \u001b[0mformat_dict\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmd_dict\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minclude\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minclude\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexclude\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mexclude\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    307\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mformat_dict\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    308\u001b[0m                 \u001b[0;31m# nothing to display (e.g. _ipython_display_ took over)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36mformat\u001b[0;34m(self, obj, include, exclude)\u001b[0m\n\u001b[1;32m    178\u001b[0m             \u001b[0mmd\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    179\u001b[0m             \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 180\u001b[0;31m                 \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mformatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    181\u001b[0m             \u001b[0;32mexcept\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    182\u001b[0m                 \u001b[0;31m# FIXME: log the exception\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m</Users/yush/anaconda3/lib/python3.7/site-packages/decorator.py:decorator-gen-9>\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, obj)\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36mcatch_format_error\u001b[0;34m(method, self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    222\u001b[0m     \u001b[0;34m\"\"\"show traceback on failed format call\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    223\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 224\u001b[0;31m         \u001b[0mr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    225\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mNotImplementedError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    226\u001b[0m         \u001b[0;31m# don't warn on NotImplementedErrors\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m    339\u001b[0m                 \u001b[0;32mpass\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    340\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 341\u001b[0;31m                 \u001b[0;32mreturn\u001b[0m \u001b[0mprinter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    342\u001b[0m             \u001b[0;31m# Finally look for special method names\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    343\u001b[0m             \u001b[0mmethod\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mget_real_method\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_method\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/IPython/core/pylabtools.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(fig)\u001b[0m\n\u001b[1;32m    242\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    243\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;34m'png'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 244\u001b[0;31m         \u001b[0mpng_formatter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfor_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mFigure\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mprint_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'png'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    245\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0;34m'retina'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0;34m'png2x'\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mformats\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    246\u001b[0m         \u001b[0mpng_formatter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfor_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mFigure\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mretina_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/IPython/core/pylabtools.py\u001b[0m in \u001b[0;36mprint_figure\u001b[0;34m(fig, fmt, bbox_inches, **kwargs)\u001b[0m\n\u001b[1;32m    126\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    127\u001b[0m     \u001b[0mbytes_io\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mBytesIO\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 128\u001b[0;31m     \u001b[0mfig\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcanvas\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mprint_figure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbytes_io\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    129\u001b[0m     \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mbytes_io\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetvalue\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    130\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0mfmt\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'svg'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/matplotlib/backend_bases.py\u001b[0m in \u001b[0;36mprint_figure\u001b[0;34m(self, filename, dpi, facecolor, edgecolor, orientation, format, bbox_inches, **kwargs)\u001b[0m\n\u001b[1;32m   2058\u001b[0m                     \u001b[0mbbox_artists\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"bbox_extra_artists\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2059\u001b[0m                     bbox_inches = self.figure.get_tightbbox(renderer,\n\u001b[0;32m-> 2060\u001b[0;31m                             bbox_extra_artists=bbox_artists)\n\u001b[0m\u001b[1;32m   2061\u001b[0m                     \u001b[0mpad\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mkwargs\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"pad_inches\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2062\u001b[0m                     \u001b[0;32mif\u001b[0m \u001b[0mpad\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/matplotlib/figure.py\u001b[0m in \u001b[0;36mget_tightbbox\u001b[0;34m(self, renderer, bbox_extra_artists)\u001b[0m\n\u001b[1;32m   2374\u001b[0m                 \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2375\u001b[0m                     bbox = ax.get_tightbbox(renderer,\n\u001b[0;32m-> 2376\u001b[0;31m                             bbox_extra_artists=bbox_extra_artists)\n\u001b[0m\u001b[1;32m   2377\u001b[0m                 \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2378\u001b[0m                     \u001b[0mbbox\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0max\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_tightbbox\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/matplotlib/axes/_base.py\u001b[0m in \u001b[0;36mget_tightbbox\u001b[0;34m(self, renderer, call_axes_locator, bbox_extra_artists)\u001b[0m\n\u001b[1;32m   4350\u001b[0m                 \u001b[0mbb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbb_xaxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   4351\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 4352\u001b[0;31m             \u001b[0mbb_yaxis\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0myaxis\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_tightbbox\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   4353\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mbb_yaxis\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   4354\u001b[0m                 \u001b[0mbb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbb_yaxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m~/anaconda3/lib/python3.7/site-packages/matplotlib/axis.py\u001b[0m in \u001b[0;36mget_tightbbox\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m   1163\u001b[0m         \u001b[0mticks_to_draw\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_update_ticks\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1164\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1165\u001b[0;31m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_update_label_position\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrenderer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   1166\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   1167\u001b[0m         \u001b[0;31m# go back to just this axis's tick labels\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "\n",
    "for i in range(len(preds_test_cl)):\n",
    "    if preds_test_cl[i].argmax() != y_test[i].argmax():\n",
    "        plt.imshow(cleaned_test[i, :, :, :].reshape(28, 28))\n",
    "        plt.show()\n",
    "        print(i, preds_test_cl[i].argmax(), y_test[i].argmax())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "(_, _), (_, temp_test) = mnist.load_data()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/yush/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:9: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "  if __name__ == '__main__':\n"
     ]
    },
    {
     "ename": "IndexError",
     "evalue": "index 3 is out of bounds for axis 0 with size 3",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-86-c9b01a0f2283>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      8\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m9\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m         \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msubplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m330\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m         \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx_batch\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m28\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m28\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'gray'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: index 3 is out of bounds for axis 0 with size 3"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 9 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
    "\n",
    "datagen = ImageDataGenerator(zca_whitening=True)\n",
    "\n",
    "datagen.fit(cleaned_test)\n",
    "\n",
    "for x_batch, y_batch in datagen.flow(cleaned_test, temp_test[:3000], batch_size=9):\n",
    "    for i in range(9):\n",
    "        plt.subplot(330+1+i)\n",
    "        plt.imshow(x_batch[i].reshape(28, 28), cmap='gray')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3000,)"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp_test[:3000].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD4CAYAAAAq5pAIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAARYElEQVR4nO3dfZBV5X0H8O9X2IWwvMjKi+uCFSgTq3YKukI6SMXQWCSTQeskjeNYOrXFaWKJNu3UsdMJnfYPxzZaTasNUQYSo6ltwkgntpUyiSC+lEURIRghlJcFBIUgCLrA8usfe8hscM9z1vPcc89Zft/PzM7dvb997nnu5X65d+9znuehmUFEzn3nld0BEakPhV3ECYVdxAmFXcQJhV3EiYH1PFgjB9lgNBVy2zZiSFR7vnc89+1ntc1SdN9jxPYtRn++X0X2PeRDHMMJ62Rvtaiwk5wD4CEAAwA8Zmb3hX5/MJownbNjDpmqc+bVUe0H/XBd7tvPapul6L7HiO1bjP58v4rse8grtiq1lvttPMkBAP4ZwA0ALgNwC8nL8t6eiBQr5m/2aQC2mdl2MzsB4HsA5tWmWyJSazFhbwWwu8fPHcl1v4TkApLtJNtPojPicCISIybsvX0I8JFzb81ssZm1mVlbAwZFHE5EYsSEvQPA+B4/jwOwN647IlKUmLCvAzCZ5ASSjQC+CGBFbbolIrWWe+jNzE6RvBPAf6N76G2JmW0OthkxJGrIIzScET389dn8/Ypp2xeZw4IFHr+sISQg/n5V9flSi/ZpbM1LqbWocXYzexbAszG3ISL1odNlRZxQ2EWcUNhFnFDYRZxQ2EWcUNhFnKjrfPYiFTkmW7as+9afx8JDyh4LL1LMfct7v/TKLuKEwi7ihMIu4oTCLuKEwi7ihMIu4kSlht766/BX0UNERQ7TVPkxz1LlobUYRd0vvbKLOKGwizihsIs4obCLOKGwizihsIs4obCLOFGpcfYYVZ4OWfR4cJHLYGc9rlUepy90F9iMx62K5zfolV3ECYVdxAmFXcQJhV3ECYVdxAmFXcQJhV3ECZpZ3Q42nM02nbNT6+fq/OQqOzyxIVhvWXM46vZPb/hJaq3sra77q9Dj9tqah3H0cAd7q0WdVENyB4CjALoAnDKztpjbE5Hi1OIMuuvM7N0a3I6IFEh/s4s4ERt2A/AcyfUkF/T2CyQXkGwn2X4SnZGHE5G8Yt/GzzCzvSTHAFhJ8k0zW93zF8xsMYDFQPcHdJHHE5Gcol7ZzWxvcnkAwHIA02rRKRGpvdxhJ9lEctiZ7wFcD2BTrTomIrUV8zZ+LIDlJM/czpNm9l+hBjZiCDpn9s+x9NCYbezc5djx5k+seiO19uY/XRFsu3nOPwbrd992ba4+nfHC7stTa39x+TPBtvdvuj7q2KMWTkitvftCS7DtyJ+eDtaHPv1yrj6VKXfYzWw7gN+oYV9EpEAaehNxQmEXcUJhF3FCYRdxQmEXcaJfLSV9rm5dnHXs8wYPDtaveDH9NOT/vPCxYNsuCz8FHmldG6x/ac+MYP3ai3+WWnvpyKRg25mBtn0xgOknbHZ97u1g2+tv2xysL1l7TbB+bEprsB5S1HNRr+wiTijsIk4o7CJOKOwiTijsIk4o7CJOKOwiTtR1nJ3vHY+aKhoSO000Zhw+dgrroIPh5bq23x0sY0LXW+FfCLj0+T8M1gcM7Mp92wAw/uEBqbVj48LnD7xzZa8rIv/CwGPh+umG9HH25qsOBNt+c9xLwfqyJ8NTYHF/uBwS81ykHU+t6ZVdxAmFXcQJhV3ECYVdxAmFXcQJhV3ECYVdxIl+NZ+9qmLH+Ds+PTRYnzXhtWD9Gxe9mFqb/OPwOPrkhbuD9ePTJwbrMXOvh2XUG48Wt+z43gFjgvU7LvjNYP3/DjUH6xcVvHx4HnplF3FCYRdxQmEXcUJhF3FCYRdxQmEXcUJhF3FC4+wV0Dj9ULCetXZ7yKj/CM8Z73r3YLA+6IfhepbQeHLWGH3s+uk7/i59rPz5W/8+2HbR25+JOnYVZb6yk1xC8gDJTT2uaya5kuTW5HJksd0UkVh9eRu/FMCcs667B8AqM5sMYFXys4hUWGbYzWw1gLPfZ84DsCz5fhmAG2vcLxGpsbwf0I01s30AkFymnmhMcgHJdpLtJxFea01EilP4p/FmttjM2sysrQGDij6ciKTIG/b9JFsAILkML9UpIqXLG/YVAOYn388H8ExtuiMiRckcZyf5FIBZAEaR7ADwNQD3AXia5O0AdgH4fF8OZiOGoHNm/efxFi12PHjg2PDcabSFy6E90rsaw2urxypzrf+jreGn75O3PpRaix1H/3DriKj2ITH7ENia9PXuM8NuZreklGZntRWR6tDpsiJOKOwiTijsIk4o7CJOKOwiTriZ4ho7PBYSs8UuADTtPxWsX7fp5mB99a8vT62tX/R8sO1f/++twfrxiecH6zGOXBx++o28eU+wPn1E+FyuqwY1ptaytmReuDf8bzpyc7Bc6pBkGr2yizihsIs4obCLOKGwizihsIs4obCLOKGwizhRqXH2mLHwIsfRY8WOm55cNjZYf+De9G2V/6x5e7DtF5aHx+H/dUp4y+YDvz81WD82Lr02cebOYNvxTT8P1rssPH137YenU2t/uiltMme3TzwRXjB5yLHwuRFZYp6veZ9PemUXcUJhF3FCYRdxQmEXcUJhF3FCYRdxQmEXcYJmVreDDTt/nE2dubBux+spZnneMm+7LzqHD0it3f03TwXb3pwxln31+vB49Iopjwfr4wYOTa11Wfo4OAC8dfLDYP33vvHn4WMvfTP92AfD22RniV3DoCiv2CocsUO9noCgV3YRJxR2EScUdhEnFHYRJxR2EScUdhEnFHYRJ/rVfPbQ2GbsuGaV58Nn9W3nv0xLrT26c1aw7aqMtdevvnBXsP63GVsfv/XemNTannUXBduO3hA+B6Tl6ReD9a5gNazocyOKOnZoy+bMV3aSS0geILmpx3WLSO4huSH5mpu7dyJSF315G78UwJxern/QzKYkX8/WtlsiUmuZYTez1QDizi0UkdLFfEB3J8mNydv81AW7SC4g2U6y/eSJYxGHE5EYecP+KIBJAKYA2Afg62m/aGaLzazNzNoaGptyHk5EYuUKu5ntN7MuMzsN4FsA0j8OFpFKyBV2ki09frwJwKa03xWRasgcZyf5FIBZAEaR7ADwNQCzSE4BYAB2ALijwD7WRJnzj9+e1hCsnxgZHhGes2hwsD4JGz92n/rqkdaXg/Uv7flUsL5rf3NqbfzauLXXs5Q5Vp6ljL5lht3Melu9ILxigYhUjk6XFXFCYRdxQmEXcUJhF3FCYRdxoq5LSQ9ns03n7NztixyuOD46PDDxwej07YHH/E5HsO0nM6aRZm09nOW5jZen1tgQXq558NbwsN6Aqw4H6xumPRGsf2AnUmu/fc9dwbaDfx4zSTU8nBr7XIodqi1quraWkhYRhV3EC4VdxAmFXcQJhV3ECYVdxAmFXcSJSi0lnSVm/HHbg+GpmCtueiBYv7RhUO5jz9/56WD95RcvDdabdof/T75oX/pY+nknw+dRdDWGx+EvuWFfsJ5l6Hnp4/jvt4bv14gnwtNr+/MU1jKWLtcru4gTCruIEwq7iBMKu4gTCruIEwq7iBMKu4gTdR1ntxFD0Dkz/9hozPzkhtbw1lMx4+hZXt8f3pp4THu4/aHfPRqst44+mFrb/s4FwbbXXrItWH+kdW2wnuW6zfNSaxd/c3Owbdxs9rAqb9Fd2pbNInJuUNhFnFDYRZxQ2EWcUNhFnFDYRZxQ2EWcqOu68cPOH2dTZy7M3b7IdcAP/lF4HP6To9LXfv/3Sf8TdeysbY+zZG2rXOSxtxweG6wf+bf0cwxGLU4fE66FotZmL1vofr225mEcPdyRb914kuNJ/ojkFpKbSX4lub6Z5EqSW5PLkbl7LyKF68vb+FMAvmpmvwbgUwC+TPIyAPcAWGVmkwGsSn4WkYrKDLuZ7TOzV5PvjwLYAqAVwDwAy5JfWwbgxqI6KSLxPtYHdCQvATAVwCsAxprZPqD7PwQAY1LaLCDZTrL95Inw38UiUpw+h53kUADfB3CXmR3pazszW2xmbWbW1tDYlKePIlIDfQo7yQZ0B/27ZvaD5Or9JFuSeguA8FalIlKqzCmuJAngcQBbzKznessrAMwHcF9y+UwhPayTCx4Lv+v44PX0KbBXfu5Pgm05N30KKgB80NkYrGdZOmx77rY/3vmrwXrDmuHBeuuy8DRVm9HrX3f9XtlbPufRl/nsMwDcBuANkhuS6+5Fd8ifJnk7gF0APl9MF0WkFjLDbmYvAOh1kB7A7Np2R0SKotNlRZxQ2EWcUNhFnFDYRZxQ2EWc6FdbNofEjltmjZue6tiTWhv9aHoNADp3hW97WLCabSnSl2vOMj7jcct6XLoOv5f72GVuuVzFLZXPKOpx0Su7iBMKu4gTCruIEwq7iBMKu4gTCruIEwq7iBN1XUp6OJttOvNPlItZGrjIMd2ix/iLPn6Rqrqcc9Fj/EXet8KWkhaRc4PCLuKEwi7ihMIu4oTCLuKEwi7ihMIu4sQ5M5+9zHHTKs+NLlrMfS/6/IIy58sXKXS/acdTa3plF3FCYRdxQmEXcUJhF3FCYRdxQmEXcUJhF3GiL/uzjwfwbQAXAjgNYLGZPURyEYA/BvBO8qv3mtmzoduyEUPQObOaY59ljoWfy/O6i1TkGH/RY/hlzPPvy0k1pwB81cxeJTkMwHqSK5Pag2b2D4X0TERqqi/7s+8DsC/5/ijJLQBai+6YiNTWx/qbneQlAKYCeCW56k6SG0kuITkypc0Cku0k20+eOBbVWRHJr89hJzkUwPcB3GVmRwA8CmASgCnofuX/em/tzGyxmbWZWVtDY1MNuiwiefQp7CQb0B3075rZDwDAzPabWZeZnQbwLQDTiuumiMTKDDtJAngcwBYze6DH9S09fu0mAJtq3z0RqZXMpaRJXgNgDYA30D30BgD3ArgF3W/hDcAOAHckH+alylpKusipomVOQy1zeKvK00Bj+1bk8yFLVR/X0FLSffk0/gUAvTUOjqmLSLXoDDoRJxR2EScUdhEnFHYRJxR2EScUdhEn6rqUdNYU1yLHLsu87aK3dK7y9Nz+OoW26PtV1L+ZlpIWEYVdxAuFXcQJhV3ECYVdxAmFXcQJhV3Eicz57DU9GPkOgJ09rhoF4N26deDjqWrfqtovQH3Lq5Z9+xUzG91boa5h/8jByXYzayutAwFV7VtV+wWob3nVq296Gy/ihMIu4kTZYV9c8vFDqtq3qvYLUN/yqkvfSv2bXUTqp+xXdhGpE4VdxIlSwk5yDsmfktxG8p4y+pCG5A6Sb5DcQLK95L4sIXmA5KYe1zWTXElya3LZ6x57JfVtEck9yWO3geTckvo2nuSPSG4huZnkV5LrS33sAv2qy+NW97/ZSQ4A8BaAzwDoALAOwC1m9pO6diQFyR0A2sys9BMwSP4WgPcBfNvMrkiuux/AITO7L/mPcqSZ/WVF+rYIwPtlb+Od7FbU0nObcQA3AvgDlPjYBfr1BdThcSvjlX0agG1mtt3MTgD4HoB5JfSj8sxsNYBDZ109D8Cy5Ptl6H6y1F1K3yrBzPaZ2avJ90cBnNlmvNTHLtCvuigj7K0Advf4uQPV2u/dADxHcj3JBWV3phdjz2yzlVyOKbk/Z8vcxrueztpmvDKPXZ7tz2OVEfbetpKq0vjfDDO7EsANAL6cvF2VvunTNt710ss245WQd/vzWGWEvQPA+B4/jwOwt4R+9MrM9iaXBwAsR/W2ot5/Zgfd5PJAyf35hSpt493bNuOowGNX5vbnZYR9HYDJJCeQbATwRQArSujHR5BsSj44AckmANejeltRrwAwP/l+PoBnSuzLL6nKNt5p24yj5Meu9O3PzazuXwDmovsT+Z8B+Ksy+pDSr4kAXk++NpfdNwBPoftt3Ul0vyO6HcAFAFYB2JpcNleob99B99beG9EdrJaS+nYNuv803AhgQ/I1t+zHLtCvujxuOl1WxAmdQSfihMIu4oTCLuKEwi7ihMIu4oTCLuKEwi7ixP8D94XtMhW/VrMAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD4CAYAAAAq5pAIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAOnklEQVR4nO3df7BU5X3H8c+HnypKBBVCUCsIrdFUsbkFrUlj4jQ1JiliJ4m0TcnElHQaHc04bR3bjk4yzZCqcdo0kxYLhqSpjhm12sZECbHaOIZyJYhQVISgIggqFbVR4MK3f9xj54r3PHvZc/YHPO/XzJ3dPd89e74s93PP7j5nz+OIEIBD37BONwCgPQg7kAnCDmSCsAOZIOxAJka0c2OjPDoO05h2bhLIyhv6X+2OXR6sVinsts+X9LeShkv6p4hYkLr/YRqjWT6vyiYBJCyPZaW1pl/G2x4u6RuSPiLpVElzbZ/a7OMBaK0q79lnSnoqIjZGxG5Jt0qaXU9bAOpWJeyTJT074PbmYtlb2J5vu9d27x7tqrA5AFVUCftgHwK87djbiFgYET0R0TNSoytsDkAVVcK+WdIJA24fL2lLtXYAtEqVsK+QNN32FNujJF0s6e562gJQt6aH3iKiz/alku5V/9Db4ohYW1tnAGpVaZw9Iu6RdE9NvQBoIQ6XBTJB2IFMEHYgE4QdyARhBzJB2IFMEHYgE4QdyARhBzJB2IFMEHYgE4QdyARhBzJB2IFMEHYgE4QdyARhBzJB2IFMEHYgE4QdyARhBzJB2IFMEHYgE4QdyARhBzJB2IFMEHYgE4QdyARhBzJRaRZXHPzi7DPS9RHV9gfD/vNnldZHfSqF3fYmSa9K2iupLyJ66mgKQP3q2LN/MCJerOFxALQQ79mBTFQNe0i6z/YjtucPdgfb82332u7do10VNwegWVVfxp8TEVtsT5C01PbjEfHgwDtExEJJCyVprMdHxe0BaFKlPXtEbCkut0u6U9LMOpoCUL+mw257jO2j3rwu6cOS1tTVGIB6VXkZP1HSnbbffJx/iYgf1tIVDsiwo44qrT19+a8m1334j29I1o/wqKZ6etN1L51aWtsnV3rsRm5+9OzS2rvuTP+7jnpgfbK+96UdTfXUSU2HPSI2SkofkQGgazD0BmSCsAOZIOxAJgg7kAnCDmTCEe07qG2sx8csn9e27R0qUkNrkjT6348ord0+7QfJdfeptf//wxLDa9287X94eWqy/sOPn5ms923clKy3yvJYpldix6D/cPbsQCYIO5AJwg5kgrADmSDsQCYIO5AJwg5kglNJd4Hdv50+Ke/ZC/4rWf/yhAea3vafPj8rWf+3B6qdMPj4H+8rre2cmv71G/F6eix89Mvljy1J2y7cXVr7yq/fkVz3T47+ebL+j9e/L1mffFGy3BHs2YFMEHYgE4QdyARhBzJB2IFMEHYgE4QdyATj7F1g05z039z7JqSnPU6NNjcaR1//OxOS9WnP/TRZr+Kwlj1yvyO/V177y1tnJ9ed8/6bk/XP/vLDyfq9GpusdwJ7diAThB3IBGEHMkHYgUwQdiAThB3IBGEHMsE4+yFu/UePSdb7nt/Spk7ab+fvn1Va+8HZ1zdY+/B6m+kCDffsthfb3m57zYBl420vtb2+uBzX2jYBVDWUl/HfknT+fsuukrQsIqZLWlbcBtDFGoY9Ih6UtGO/xbMlLSmuL5F0Yc19AahZsx/QTYyIrZJUXJYeYG17vu1e2717tKvJzQGoquWfxkfEwojoiYiekRrd6s0BKNFs2LfZniRJxeX2+loC0ArNhv1uSfOK6/Mk3VVPOwBapeE4u+1bJJ0r6VjbmyVdI2mBpNtsXyLpGUmfaGWTh7ojnm7d4Q5Pzzs5WZ/81W0t23arDTv9lGT9r790U2ntxBHVxtEXPXF2sn681lZ6/FZo+FsWEXNLSufV3AuAFuJwWSAThB3IBGEHMkHYgUwQdiATjkhPi1unsR4fs8yH+Afqqe+cmaw/+aFFpbX/eGNkct3rLv69ZD1WPJasV+H3npasb7gy3fvjH1hcZztv8dEnPp6sD/9cure+jZtq7GbolscyvRI7PFiNPTuQCcIOZIKwA5kg7EAmCDuQCcIOZIKwA5ngVNIHgVOuSn8N9Yt3lU/LfOOk5cl1H160Ill/6JzjknVNmZwsv3za0aW1v//K3yXXPX3U8GQ9NVW1JH3/F+8orX3xx2Vf5uz37qs3JOt9Lz3XYOvdhz07kAnCDmSCsAOZIOxAJgg7kAnCDmSCsAOZ4Pvsh4AR75xYWjvvR+uT6142Ll1ftPPEZP1DY55M1k9OnLJ5n9K/ez/bnR5Jn/uvlyXrp3z156W1vucP3lNop/B9dgCEHcgFYQcyQdiBTBB2IBOEHcgEYQcywffZDwGpaZnPOPxHlR77knc80+AehyWry14fXVr7qy99LrnuMd9/Ilmf9tJPk/W+ZDU/Dffsthfb3m57zYBl19p+zvaq4ueC1rYJoKqhvIz/lqTzB1l+Y0TMKH7uqbctAHVrGPaIeFDSjjb0AqCFqnxAd6nt1cXL/HFld7I933av7d492lVhcwCqaDbs35R0sqQZkrZKuqHsjhGxMCJ6IqJnpMo/rAHQWk2FPSK2RcTeiNgn6SZJM+ttC0Ddmgq77UkDbs6RtKbsvgC6Q8Nxdtu3SDpX0rG2N0u6RtK5tmdICkmbJH2+hT0e9F791FnJ+r55LybrD51xW4MtrDzAjgYa9KvPtbn0e+Vj6VO+/XBy3b11N5O5hmGPiMHOpr+oBb0AaCEOlwUyQdiBTBB2IBOEHcgEYQcywamkC8OnTUnWH7+s/HTNiz+2MLnu+w9Lf9my0SmVG/nUhsG+p9Rv7QPTkutOWJk+XfOcLy9N1hudivq1feWHSP/Bb3wyuW7fs5uTdbwdp5IGQNiBXBB2IBOEHcgEYQcyQdiBTBB2IBPZnEr6hbt/JVn/+ntuSdZnjm5+LPx/9r2RrH+w94+S9XfeMCpZH7mu/HTPU19/NLnu85+dkazPHbs6WZfKp2SWpLHDyk81/YvTJpXWJGkU4+y1Ys8OZIKwA5kg7EAmCDuQCcIOZIKwA5kg7EAmshln37mhdIYqSdLM97bue/037zw9WR9+/9HJ+saL0t85H33iu0prF01Lj7Nfc9zXk/VG4+iNpKZsPvyRTcl1OZV0vdizA5kg7EAmCDuQCcIOZIKwA5kg7EAmCDuQCc4bX1j/jVnJ+tKP3VBaO2nEEcl1hzv9N3VvpMfRu1lqHF2Sbrzod0tr+1Y/Xnc72at03njbJ9i+3/Y622ttX14sH297qe31xWX6qBUAHTWUl/F9kq6MiHdLOkvSF2yfKukqScsiYrqkZcVtAF2qYdgjYmtErCyuvyppnaTJkmZLWlLcbYmkC1vVJIDqDugDOtsnSTpT0nJJEyNiq9T/B0HShJJ15tvutd27R+XzfgForSGH3faRkm6XdEVEvDLU9SJiYUT0RETPSKU/zAHQOkMKu+2R6g/6dyPijmLxNtuTivokSdtb0yKAOjQcerNt9b8n3xERVwxYfp2klyJige2rJI2PiD9LPVY3D701Mnz61NLahj8sn85ZknZPTE/Z/JlZDzXV01AMd3pYb2+k/97/870fSNanX/dU+vFfeCFZR71SQ29D+T77OZI+Lekx26uKZVdLWiDpNtuXSHpG0ifqaBZAazQMe0T8RNKgfykkHZy7aSBDHC4LZIKwA5kg7EAmCDuQCcIOZIKvuAKHkEpfcQVwaCDsQCYIO5AJwg5kgrADmSDsQCYIO5AJwg5kgrADmSDsQCYIO5AJwg5kgrADmSDsQCYIO5AJwg5kgrADmSDsQCYIO5AJwg5kgrADmSDsQCYIO5CJhmG3fYLt+22vs73W9uXF8mttP2d7VfFzQevbBdCsoczP3ifpyohYafsoSY/YXlrUboyI61vXHoC6DGV+9q2SthbXX7W9TtLkVjcGoF4H9J7d9kmSzpS0vFh0qe3VthfbHleyznzbvbZ792hXpWYBNG/IYbd9pKTbJV0REa9I+qakkyXNUP+e/4bB1ouIhRHRExE9IzW6hpYBNGNIYbc9Uv1B/25E3CFJEbEtIvZGxD5JN0ma2bo2AVQ1lE/jLWmRpHUR8bUByycNuNscSWvqbw9AXYbyafw5kj4t6THbq4plV0uaa3uGpJC0SdLnW9IhgFoM5dP4n0gabL7ne+pvB0CrcAQdkAnCDmSCsAOZIOxAJgg7kAnCDmSCsAOZIOxAJgg7kAnCDmSCsAOZIOxAJgg7kAnCDmTCEdG+jdkvSHp6wKJjJb3YtgYOTLf21q19SfTWrDp7+6WIOG6wQlvD/raN270R0dOxBhK6tbdu7Uuit2a1qzdexgOZIOxAJjod9oUd3n5Kt/bWrX1J9NastvTW0ffsANqn03t2AG1C2IFMdCTsts+3/YTtp2xf1YkeytjeZPuxYhrq3g73stj2dttrBiwbb3up7fXF5aBz7HWot66YxjsxzXhHn7tOT3/e9vfstodLelLSb0naLGmFpLkR8d9tbaSE7U2SeiKi4wdg2P5NSa9J+nZEvKdY9jeSdkTEguIP5biI+PMu6e1aSa91ehrvYraiSQOnGZd0oaTPqIPPXaKvT6oNz1sn9uwzJT0VERsjYrekWyXN7kAfXS8iHpS0Y7/FsyUtKa4vUf8vS9uV9NYVImJrRKwsrr8q6c1pxjv63CX6aotOhH2ypGcH3N6s7prvPSTdZ/sR2/M73cwgJkbEVqn/l0fShA73s7+G03i3037TjHfNc9fM9OdVdSLsg00l1U3jf+dExK9J+oikLxQvVzE0Q5rGu10GmWa8KzQ7/XlVnQj7ZkknDLh9vKQtHehjUBGxpbjcLulOdd9U1NvenEG3uNze4X7+XzdN4z3YNOPqgueuk9OfdyLsKyRNtz3F9ihJF0u6uwN9vI3tMcUHJ7I9RtKH1X1TUd8taV5xfZ6kuzrYy1t0yzTeZdOMq8PPXcenP4+Itv9IukD9n8hvkPQXneihpK+pkh4tftZ2ujdJt6j/Zd0e9b8iukTSMZKWSVpfXI7vot6+I+kxSavVH6xJHertfep/a7ha0qri54JOP3eJvtryvHG4LJAJjqADMkHYgUwQdiAThB3IBGEHMkHYgUwQdiAT/wfbKHbvH1HdfgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pic = 61\n",
    "plt.imshow(x_adversarial_test[pic, :, :, :].reshape(28, 28))\n",
    "plt.show()\n",
    "plt.imshow(x_test[pic, :, :, :].reshape(28, 28))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "313/313 [==============================] - 0s 1ms/step - loss: 0.0079 - accuracy: 0.9523\n",
      "313/313 [==============================] - 0s 1ms/step - loss: 0.0029 - accuracy: 0.9818\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "([0.007921529933810234, 0.9523000121116638],\n",
       " [0.0029318640008568764, 0.9818000197410583])"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.evaluate(denoiser.predict(x_test), y_test), model.evaluate(x_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The denoising Autoencoder takes the accuracy up to 85%. When looking at error analysis, the autoencoder is able to clean most of the images pretty well, even at high noise levels, however, there are few examples where the autoencoder generates a confusing version of the cleaned image, because some of the parts of the image are slightly faded.\n",
    "\n",
    "Also, I have tested the autoencoder on clean images itself, to see if a simple pipeline can be established, and fortunately, the denoising autoencoder doens't harm normal images too much.\n",
    "\n",
    "We also can't apply a threshold filter to clean images, since sometimes the autoencoder is not completely able to eliminate noise, so there are fatal faded spots. Other times, the model accidentally fades out important parts of the image, creating a problem. However, the accuracy has still gone up significantly, in a more robust way."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now I will try the last and final approach of hypothesis testing. Here, I will try and compare the variances and mean values of different digits, and if they are different, then we can establish a p-test to make sure our model didn't misclassify images. First, lets separate all of the images based on their category."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(10):\n",
    "    command = \"num_\" + str(i) + \" = x_test[temp_test == \" + str(i) + \"]\"\n",
    "    exec(command)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fad6dfffe80>"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "plt.imshow(num_2[10].reshape(28, 28))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "means = []\n",
    "vari = []\n",
    "for i in range(10):\n",
    "    means.append(np.mean(eval(\"num_\" + str(i))))\n",
    "    vari.append(np.var(eval(\"num_\" + str(i))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0.17231035, 0.0767375 , 0.15018502, 0.14330528, 0.1226675 ,\n",
       "        0.13205391, 0.14357606, 0.11490118, 0.15312719, 0.12526645]),\n",
       " array([0.12043064, 0.0604149 , 0.10728259, 0.10258094, 0.0895898 ,\n",
       "        0.09469835, 0.10344179, 0.08544615, 0.10789361, 0.09124957]))"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(means), np.array(vari)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We intantly see that this approach cannot work, because too many digits show similar characteristics. Many digits have a mean and variance which are both within the 3rd decimal place for each other, which is more than even the 1 standard deviation range. Hence we cannot segregate digits, and so a p-test cannot be established.\n",
    "\n",
    "Examples of issues:\n",
    "\n",
    "- Digits 2 and 8 have a similar mean and variance\n",
    "- Digits 3 and 6 have a similar mean and varianc\n",
    "\n",
    "If a p-test is established, a simple targetted attack for misclassifying 2 as 8 or 3 as 6 (or vice versa), could simply bypass the system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "def drop_batch_model():\n",
    "    X_Input = Input((img_rows, img_cols, channels))\n",
    "    X = Conv2D(32, kernel_size=(3, 3), strides=(3, 3), padding='same', activation='relu')(X_Input)\n",
    "    X = BatchNormalization()(X, training=True)#\n",
    "    X = Dropout(0.45)(X, training=True)   #Extra block added\n",
    "    X = Conv2D(64, kernel_size=(3, 3), strides=(3, 3), padding='same', activation='relu')(X)\n",
    "    X = BatchNormalization()(X, training=True)#\n",
    "    X = Conv2D(64, kernel_size=(3, 3), strides=(3, 3), padding='same', activation='relu')(X)\n",
    "    X = MaxPooling2D(pool_size=(2, 2))(X)\n",
    "    X = BatchNormalization()(X, training=True)#\n",
    "    X = Dropout(0.3)(X, training=True)\n",
    "    X = Flatten()(X)\n",
    "    X = Dense(32)(X)\n",
    "    X = BatchNormalization()(X, training=True)#\n",
    "    X = Dropout(0.075)(X, training=True)\n",
    "    X = Dense(32)(X)\n",
    "    X = BatchNormalization()(X, training=True)#\n",
    "    X = Dropout(0.05)(X, training=True)\n",
    "    X = Dense(num_classes, activation='softmax')(X)\n",
    "    \n",
    "    model = Model(inputs = X_Input, outputs = X)\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [],
   "source": [
    "def proxy():\n",
    "    X_Input = Input((img_rows, img_cols, channels))\n",
    "    X = Conv2D(32, kernel_size=(3, 3), strides=(3, 3), padding='same', activation='relu')(X_Input)\n",
    "    X = BatchNormalization()(X)#\n",
    "    X = Dropout(0.45)(X, training=True)   #Extra block added\n",
    "    X = Conv2D(64, kernel_size=(3, 3), strides=(3, 3), padding='same', activation='relu')(X)\n",
    "    X = BatchNormalization()(X)#\n",
    "    X = Conv2D(64, kernel_size=(3, 3), strides=(3, 3), padding='same', activation='relu')(X)\n",
    "    X = MaxPooling2D(pool_size=(2, 2))(X)\n",
    "    X = BatchNormalization()(X)#\n",
    "    X = Dropout(0.3)(X, training=True)\n",
    "    X = Flatten()(X)\n",
    "    X = Dense(32)(X)\n",
    "    X = BatchNormalization()(X)#\n",
    "    X = Dropout(0.075)(X, training=True)\n",
    "    X = Dense(32)(X)\n",
    "    X = BatchNormalization()(X)#\n",
    "    X = Dropout(0.05)(X, training=True)\n",
    "    X = Dense(num_classes, activation='softmax')(X)\n",
    "    \n",
    "    model = Model(inputs = X_Input, outputs = X)\n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_7\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_8 (InputLayer)         [(None, 28, 28, 1)]       0         \n",
      "_________________________________________________________________\n",
      "conv2d_15 (Conv2D)           (None, 10, 10, 32)        320       \n",
      "_________________________________________________________________\n",
      "batch_normalization_10 (Batc (None, 10, 10, 32)        128       \n",
      "_________________________________________________________________\n",
      "dropout_14 (Dropout)         (None, 10, 10, 32)        0         \n",
      "_________________________________________________________________\n",
      "conv2d_16 (Conv2D)           (None, 4, 4, 64)          18496     \n",
      "_________________________________________________________________\n",
      "batch_normalization_11 (Batc (None, 4, 4, 64)          256       \n",
      "_________________________________________________________________\n",
      "conv2d_17 (Conv2D)           (None, 2, 2, 64)          36928     \n",
      "_________________________________________________________________\n",
      "max_pooling2d_4 (MaxPooling2 (None, 1, 1, 64)          0         \n",
      "_________________________________________________________________\n",
      "batch_normalization_12 (Batc (None, 1, 1, 64)          256       \n",
      "_________________________________________________________________\n",
      "dropout_15 (Dropout)         (None, 1, 1, 64)          0         \n",
      "_________________________________________________________________\n",
      "flatten_5 (Flatten)          (None, 64)                0         \n",
      "_________________________________________________________________\n",
      "dense_14 (Dense)             (None, 32)                2080      \n",
      "_________________________________________________________________\n",
      "batch_normalization_13 (Batc (None, 32)                128       \n",
      "_________________________________________________________________\n",
      "dropout_16 (Dropout)         (None, 32)                0         \n",
      "_________________________________________________________________\n",
      "dense_15 (Dense)             (None, 32)                1056      \n",
      "_________________________________________________________________\n",
      "batch_normalization_14 (Batc (None, 32)                128       \n",
      "_________________________________________________________________\n",
      "dropout_17 (Dropout)         (None, 32)                0         \n",
      "_________________________________________________________________\n",
      "dense_16 (Dense)             (None, 10)                330       \n",
      "=================================================================\n",
      "Total params: 60,106\n",
      "Trainable params: 59,658\n",
      "Non-trainable params: 448\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "proxy_m = proxy()\n",
    "proxy_m.compile(optimizer='adam', loss='mse', metrics=['accuracy'])\n",
    "proxy_m.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "1875/1875 [==============================] - 11s 6ms/step - loss: 0.0192 - accuracy: 0.8688 - val_loss: 0.0082 - val_accuracy: 0.9471\n",
      "Epoch 2/20\n",
      "1875/1875 [==============================] - 11s 6ms/step - loss: 0.0091 - accuracy: 0.9400 - val_loss: 0.0071 - val_accuracy: 0.9527\n",
      "Epoch 3/20\n",
      "1875/1875 [==============================] - 11s 6ms/step - loss: 0.0076 - accuracy: 0.9499 - val_loss: 0.0055 - val_accuracy: 0.9637\n",
      "Epoch 4/20\n",
      "1875/1875 [==============================] - 11s 6ms/step - loss: 0.0066 - accuracy: 0.9568 - val_loss: 0.0055 - val_accuracy: 0.9631\n",
      "Epoch 5/20\n",
      "1875/1875 [==============================] - 11s 6ms/step - loss: 0.0063 - accuracy: 0.9587 - val_loss: 0.0050 - val_accuracy: 0.9669\n",
      "Epoch 6/20\n",
      "1875/1875 [==============================] - 12s 6ms/step - loss: 0.0059 - accuracy: 0.9617 - val_loss: 0.0046 - val_accuracy: 0.9704\n",
      "Epoch 7/20\n",
      "1875/1875 [==============================] - 11s 6ms/step - loss: 0.0056 - accuracy: 0.9637 - val_loss: 0.0050 - val_accuracy: 0.9662\n",
      "Epoch 8/20\n",
      "1875/1875 [==============================] - 12s 6ms/step - loss: 0.0053 - accuracy: 0.9663 - val_loss: 0.0045 - val_accuracy: 0.9713\n",
      "Epoch 9/20\n",
      "1875/1875 [==============================] - 12s 7ms/step - loss: 0.0051 - accuracy: 0.9671 - val_loss: 0.0043 - val_accuracy: 0.9721\n",
      "Epoch 10/20\n",
      "1875/1875 [==============================] - 17s 9ms/step - loss: 0.0049 - accuracy: 0.9680 - val_loss: 0.0044 - val_accuracy: 0.9707\n",
      "Epoch 11/20\n",
      "1875/1875 [==============================] - 21s 11ms/step - loss: 0.0047 - accuracy: 0.9696 - val_loss: 0.0040 - val_accuracy: 0.9752\n",
      "Epoch 12/20\n",
      "1875/1875 [==============================] - 21s 11ms/step - loss: 0.0046 - accuracy: 0.9700 - val_loss: 0.0042 - val_accuracy: 0.9727\n",
      "Epoch 13/20\n",
      "1875/1875 [==============================] - 16s 9ms/step - loss: 0.0044 - accuracy: 0.9721 - val_loss: 0.0039 - val_accuracy: 0.9739\n",
      "Epoch 14/20\n",
      "1875/1875 [==============================] - 14s 8ms/step - loss: 0.0044 - accuracy: 0.9719 - val_loss: 0.0040 - val_accuracy: 0.9738\n",
      "Epoch 15/20\n",
      "1875/1875 [==============================] - 15s 8ms/step - loss: 0.0043 - accuracy: 0.9721 - val_loss: 0.0040 - val_accuracy: 0.9748\n",
      "Epoch 16/20\n",
      "1875/1875 [==============================] - 16s 8ms/step - loss: 0.0041 - accuracy: 0.9730 - val_loss: 0.0037 - val_accuracy: 0.9758\n",
      "Epoch 17/20\n",
      "1875/1875 [==============================] - 17s 9ms/step - loss: 0.0041 - accuracy: 0.9729 - val_loss: 0.0038 - val_accuracy: 0.9752\n",
      "Epoch 18/20\n",
      "1875/1875 [==============================] - 19s 10ms/step - loss: 0.0041 - accuracy: 0.9733 - val_loss: 0.0036 - val_accuracy: 0.9766\n",
      "Epoch 19/20\n",
      "1875/1875 [==============================] - 18s 10ms/step - loss: 0.0040 - accuracy: 0.9744 - val_loss: 0.0037 - val_accuracy: 0.9757\n",
      "Epoch 20/20\n",
      "1875/1875 [==============================] - 17s 9ms/step - loss: 0.0038 - accuracy: 0.9755 - val_loss: 0.0036 - val_accuracy: 0.9765\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<tensorflow.python.keras.callbacks.History at 0x7fad6d965080>"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "proxy_m.fit(x_train, y_train, batch_size=32, epochs=20, validation_data = (x_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_6\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_7 (InputLayer)         [(None, 28, 28, 1)]       0         \n",
      "_________________________________________________________________\n",
      "conv2d_12 (Conv2D)           (None, 10, 10, 32)        320       \n",
      "_________________________________________________________________\n",
      "batch_normalization_5 (Batch (None, 10, 10, 32)        128       \n",
      "_________________________________________________________________\n",
      "dropout_10 (Dropout)         (None, 10, 10, 32)        0         \n",
      "_________________________________________________________________\n",
      "conv2d_13 (Conv2D)           (None, 4, 4, 64)          18496     \n",
      "_________________________________________________________________\n",
      "batch_normalization_6 (Batch (None, 4, 4, 64)          256       \n",
      "_________________________________________________________________\n",
      "conv2d_14 (Conv2D)           (None, 2, 2, 64)          36928     \n",
      "_________________________________________________________________\n",
      "max_pooling2d_3 (MaxPooling2 (None, 1, 1, 64)          0         \n",
      "_________________________________________________________________\n",
      "batch_normalization_7 (Batch (None, 1, 1, 64)          256       \n",
      "_________________________________________________________________\n",
      "dropout_11 (Dropout)         (None, 1, 1, 64)          0         \n",
      "_________________________________________________________________\n",
      "flatten_4 (Flatten)          (None, 64)                0         \n",
      "_________________________________________________________________\n",
      "dense_11 (Dense)             (None, 32)                2080      \n",
      "_________________________________________________________________\n",
      "batch_normalization_8 (Batch (None, 32)                128       \n",
      "_________________________________________________________________\n",
      "dropout_12 (Dropout)         (None, 32)                0         \n",
      "_________________________________________________________________\n",
      "dense_12 (Dense)             (None, 32)                1056      \n",
      "_________________________________________________________________\n",
      "batch_normalization_9 (Batch (None, 32)                128       \n",
      "_________________________________________________________________\n",
      "dropout_13 (Dropout)         (None, 32)                0         \n",
      "_________________________________________________________________\n",
      "dense_13 (Dense)             (None, 10)                330       \n",
      "=================================================================\n",
      "Total params: 60,106\n",
      "Trainable params: 59,658\n",
      "Non-trainable params: 448\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "drop_batch_m = drop_batch_model()\n",
    "drop_batch_m.compile(optimizer='adam', loss='mse', metrics=['accuracy'])\n",
    "drop_batch_m.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "1875/1875 [==============================] - 12s 6ms/step - loss: 0.0197 - accuracy: 0.8653 - val_loss: 0.0095 - val_accuracy: 0.9395\n",
      "Epoch 2/20\n",
      "1875/1875 [==============================] - 12s 6ms/step - loss: 0.0096 - accuracy: 0.9366 - val_loss: 0.0079 - val_accuracy: 0.9493\n",
      "Epoch 3/20\n",
      "1875/1875 [==============================] - 12s 7ms/step - loss: 0.0080 - accuracy: 0.9478 - val_loss: 0.0067 - val_accuracy: 0.9576\n",
      "Epoch 4/20\n",
      "1875/1875 [==============================] - 13s 7ms/step - loss: 0.0070 - accuracy: 0.9539 - val_loss: 0.0066 - val_accuracy: 0.9563\n",
      "Epoch 5/20\n",
      "1875/1875 [==============================] - 13s 7ms/step - loss: 0.0066 - accuracy: 0.9569 - val_loss: 0.0059 - val_accuracy: 0.9615\n",
      "Epoch 6/20\n",
      "1875/1875 [==============================] - 15s 8ms/step - loss: 0.0060 - accuracy: 0.9604 - val_loss: 0.0057 - val_accuracy: 0.9624\n",
      "Epoch 7/20\n",
      "1875/1875 [==============================] - 14s 8ms/step - loss: 0.0057 - accuracy: 0.9629 - val_loss: 0.0054 - val_accuracy: 0.9649\n",
      "Epoch 8/20\n",
      "1875/1875 [==============================] - 15s 8ms/step - loss: 0.0055 - accuracy: 0.9643 - val_loss: 0.0052 - val_accuracy: 0.9652\n",
      "Epoch 9/20\n",
      "1875/1875 [==============================] - 22s 12ms/step - loss: 0.0052 - accuracy: 0.9663 - val_loss: 0.0053 - val_accuracy: 0.9648\n",
      "Epoch 10/20\n",
      "1875/1875 [==============================] - 24s 13ms/step - loss: 0.0050 - accuracy: 0.9669 - val_loss: 0.0048 - val_accuracy: 0.9684\n",
      "Epoch 11/20\n",
      "1875/1875 [==============================] - 19s 10ms/step - loss: 0.0048 - accuracy: 0.9684 - val_loss: 0.0045 - val_accuracy: 0.9706\n",
      "Epoch 12/20\n",
      "1875/1875 [==============================] - 16s 9ms/step - loss: 0.0048 - accuracy: 0.9686 - val_loss: 0.0048 - val_accuracy: 0.9693\n",
      "Epoch 13/20\n",
      "1875/1875 [==============================] - 16s 8ms/step - loss: 0.0046 - accuracy: 0.9703 - val_loss: 0.0048 - val_accuracy: 0.9676\n",
      "Epoch 14/20\n",
      "1875/1875 [==============================] - 15s 8ms/step - loss: 0.0044 - accuracy: 0.9712 - val_loss: 0.0047 - val_accuracy: 0.9691\n",
      "Epoch 15/20\n",
      "1875/1875 [==============================] - 17s 9ms/step - loss: 0.0045 - accuracy: 0.9710 - val_loss: 0.0047 - val_accuracy: 0.9691\n",
      "Epoch 16/20\n",
      "1875/1875 [==============================] - 21s 11ms/step - loss: 0.0042 - accuracy: 0.9733 - val_loss: 0.0042 - val_accuracy: 0.9741\n",
      "Epoch 17/20\n",
      "1875/1875 [==============================] - 27s 14ms/step - loss: 0.0041 - accuracy: 0.9725 - val_loss: 0.0043 - val_accuracy: 0.9723\n",
      "Epoch 18/20\n",
      "1875/1875 [==============================] - 24s 13ms/step - loss: 0.0042 - accuracy: 0.9728 - val_loss: 0.0045 - val_accuracy: 0.9709\n",
      "Epoch 19/20\n",
      "1875/1875 [==============================] - 18s 10ms/step - loss: 0.0041 - accuracy: 0.9736 - val_loss: 0.0043 - val_accuracy: 0.9713\n",
      "Epoch 20/20\n",
      "1875/1875 [==============================] - 16s 9ms/step - loss: 0.0039 - accuracy: 0.9747 - val_loss: 0.0042 - val_accuracy: 0.9744\n"
     ]
    }
   ],
   "source": [
    "history = drop_batch_m.fit(x_train, y_train, batch_size=32, epochs=20, validation_data = (x_test, y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Model's Accuracy is \n",
      "313/313 [==============================] - 0s 1ms/step - loss: 0.0029 - accuracy: 0.9818\n",
      "Dropout + Batch Normalization Model's Accuracy is \n",
      "313/313 [==============================] - 1s 3ms/step - loss: 0.0041 - accuracy: 0.9730\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.0041421931236982346, 0.9729999899864197]"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"Original Model's Accuracy is \")\n",
    "model.evaluate(x_test, y_test)\n",
    "print(\"Dropout + Batch Normalization Model's Accuracy is \")\n",
    "drop_batch_m.evaluate(x_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "def adversarial_pattern_m(model_t, image, label):\n",
    "    image = tf.cast(image, tf.float32)\n",
    "    \n",
    "    with tf.GradientTape() as tape:\n",
    "        tape.watch(image)\n",
    "        prediction = model_t(image)\n",
    "        loss = tf.keras.losses.MSE(label, prediction)\n",
    "    \n",
    "    gradient = tape.gradient(loss, image)\n",
    "    \n",
    "    signed_grad = tf.sign(gradient)\n",
    "    \n",
    "    return signed_grad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_adversarial = np.zeros((3000, 28, 28, 1))\n",
    "\n",
    "for i in range(3000):\n",
    "    image = x_train[i]\n",
    "    image_label = y_train[i]\n",
    "    \n",
    "    perturbations = adversarial_pattern_m(proxy_m, image.reshape((1, img_rows, img_cols, channels)), image_label).numpy()\n",
    "    adversarial = image + perturbations * 0.1\n",
    "    x_adversarial[i, :, :, :] = adversarial\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "94/94 [==============================] - 0s 3ms/step - loss: 0.0477 - accuracy: 0.7000\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.047707121819257736, 0.699999988079071]"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "drop_batch_m.evaluate(x_adversarial, y_train[0:3000])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#It turns out that using both batch norm and dropout doesn't help, and reduces accuracy to batch norm amount.\n",
    "#A possible reason for this is that batch norm fixes the mean and variance of the output layers, so an attack doesn't need to worry about dissapearing neurons that much, since activations don't change"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fad6e9efef0>"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "plt.imshow(x_adversarial[0, :, :, :].reshape(28, 28))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'drop_batch_m' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-1-655630877431>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdrop_batch_m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'drop_batch_m' is not defined"
     ]
    }
   ],
   "source": []
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}