mnist_attack_examples.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: keras in /usr/local/lib/python3.5/dist-packages (2.2.4)\n",
      "Requirement already satisfied: pyyaml in /usr/local/lib/python3.5/dist-packages (from keras) (3.13)\n",
      "Requirement already satisfied: numpy>=1.9.1 in /usr/local/lib/python3.5/dist-packages (from keras) (1.15.4)\n",
      "Requirement already satisfied: keras-preprocessing>=1.0.5 in /usr/local/lib/python3.5/dist-packages (from keras) (1.0.5)\n",
      "Requirement already satisfied: scipy>=0.14 in /usr/local/lib/python3.5/dist-packages (from keras) (1.1.0)\n",
      "Requirement already satisfied: h5py in /usr/local/lib/python3.5/dist-packages (from keras) (2.8.0)\n",
      "Requirement already satisfied: keras-applications>=1.0.6 in /usr/local/lib/python3.5/dist-packages (from keras) (1.0.6)\n",
      "Requirement already satisfied: six>=1.9.0 in /usr/local/lib/python3.5/dist-packages (from keras) (1.11.0)\n",
      "\u001b[33mYou are using pip version 18.1, however version 19.0.3 is available.\n",
      "You should consider upgrading via the 'pip install --upgrade pip' command.\u001b[0m\n",
      "Requirement already satisfied: adversarial-robustness-toolbox in /usr/local/lib/python3.5/dist-packages (0.5.0)\n",
      "Requirement already satisfied: six in /usr/local/lib/python3.5/dist-packages (from adversarial-robustness-toolbox) (1.11.0)\n",
      "Requirement already satisfied: setuptools in /usr/local/lib/python3.5/dist-packages (from adversarial-robustness-toolbox) (40.5.0)\n",
      "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.5/dist-packages (from adversarial-robustness-toolbox) (0.20.0)\n",
      "Requirement already satisfied: scipy in /usr/local/lib/python3.5/dist-packages (from adversarial-robustness-toolbox) (1.1.0)\n",
      "Requirement already satisfied: numpy in /usr/local/lib/python3.5/dist-packages (from adversarial-robustness-toolbox) (1.15.4)\n",
      "\u001b[33mYou are using pip version 18.1, however version 19.0.3 is available.\n",
      "You should consider upgrading via the 'pip install --upgrade pip' command.\u001b[0m\n",
      "Requirement already satisfied: foolbox in /usr/local/lib/python3.5/dist-packages (1.8.0)\n",
      "Requirement already satisfied: scipy in /usr/local/lib/python3.5/dist-packages (from foolbox) (1.1.0)\n",
      "Requirement already satisfied: numpy in /usr/local/lib/python3.5/dist-packages (from foolbox) (1.15.4)\n",
      "Requirement already satisfied: GitPython in /usr/local/lib/python3.5/dist-packages (from foolbox) (2.1.11)\n",
      "Requirement already satisfied: setuptools in /usr/local/lib/python3.5/dist-packages (from foolbox) (40.5.0)\n",
      "Requirement already satisfied: requests in /usr/local/lib/python3.5/dist-packages (from foolbox) (2.21.0)\n",
      "Requirement already satisfied: gitdb2>=2.0.0 in /usr/local/lib/python3.5/dist-packages (from GitPython->foolbox) (2.0.5)\n",
      "Requirement already satisfied: urllib3<1.25,>=1.21.1 in /usr/local/lib/python3.5/dist-packages (from requests->foolbox) (1.24.1)\n",
      "Requirement already satisfied: idna<2.9,>=2.5 in /usr/local/lib/python3.5/dist-packages (from requests->foolbox) (2.8)\n",
      "Requirement already satisfied: chardet<3.1.0,>=3.0.2 in /usr/local/lib/python3.5/dist-packages (from requests->foolbox) (3.0.4)\n",
      "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.5/dist-packages (from requests->foolbox) (2019.3.9)\n",
      "Requirement already satisfied: smmap2>=2.0.0 in /usr/local/lib/python3.5/dist-packages (from gitdb2>=2.0.0->GitPython->foolbox) (2.0.5)\n",
      "\u001b[33mYou are using pip version 18.1, however version 19.0.3 is available.\n",
      "You should consider upgrading via the 'pip install --upgrade pip' command.\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "!pip install keras\n",
    "!pip install adversarial-robustness-toolbox\n",
    "!pip install foolbox"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from __future__ import print_function\n",
    "import keras\n",
    "from keras.datasets import mnist\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Dropout, Flatten\n",
    "from keras.layers import Conv2D, MaxPooling2D\n",
    "from keras import backend as K\n",
    "import keras.backend as K\n",
    "from keras.models import  load_model\n",
    "import tensorflow as tf\n",
    "from keras.layers import Input, Reshape, Add\n",
    "from keras import backend as K\n",
    "from keras.layers.noise import GaussianNoise\n",
    "import numpy as np\n",
    "from functools import reduce\n",
    "from operator import mul\n",
    "from keras.models import Model\n",
    "from keras import metrics\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "from random import randint\n",
    "import foolbox\n",
    "import keras\n",
    "import numpy as np\n",
    "from random import randint\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_attack(image, adversarial):\n",
    "    # if you use Jupyter notebooks\n",
    "    %matplotlib inline\n",
    "\n",
    "    import matplotlib.pyplot as plt\n",
    "\n",
    "    plt.figure()\n",
    "\n",
    "    plt.subplot(1, 3, 1)\n",
    "    plt.title('Original')\n",
    "    plt.imshow(image.reshape((28, 28)), cmap='gray')  # division by 255 to convert [0, 255] to [0, 1]\n",
    "    plt.axis('off')\n",
    "\n",
    "    plt.subplot(1, 3, 2)\n",
    "    plt.title('Adversarial')\n",
    "    plt.imshow(adversarial.reshape((28, 28)), cmap='gray')  # ::-1 to convert BGR to RGB\n",
    "    plt.axis('off')\n",
    "\n",
    "    plt.subplot(1, 3, 3)\n",
    "    plt.title('Difference')\n",
    "    difference = adversarial- image\n",
    "    print(np.max(difference))\n",
    "    plt.imshow((difference + 0.5).reshape((28, 28)), cmap='gray')\n",
    "    plt.axis('off')\n",
    "\n",
    "    plt.show()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x_train shape: (60000, 28, 28, 1)\n",
      "60000 train samples\n",
      "10000 test samples\n"
     ]
    }
   ],
   "source": [
    "batch_size = 128\n",
    "num_classes = 10\n",
    "img_rows, img_cols = 28, 28\n",
    "\n",
    "# the data, split between train and test sets\n",
    "(x_train, y_train), (x_test, y_test) = mnist.load_data()\n",
    "\n",
    "if K.image_data_format() == 'channels_first':\n",
    "    x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)\n",
    "    x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)\n",
    "    input_shape = (1, img_rows, img_cols)\n",
    "else:\n",
    "    x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)\n",
    "    x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)\n",
    "    input_shape = (img_rows, img_cols, 1)\n",
    "\n",
    "x_train = x_train.astype('float32')\n",
    "x_test = x_test.astype('float32')\n",
    "x_train /= 255\n",
    "x_test /= 255\n",
    "print('x_train shape:', x_train.shape)\n",
    "print(x_train.shape[0], 'train samples')\n",
    "print(x_test.shape[0], 'test samples')\n",
    "\n",
    "# convert class vectors to binary class matrices\n",
    "y_train = keras.utils.to_categorical(y_train, num_classes)\n",
    "y_test = keras.utils.to_categorical(y_test, num_classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 60000 samples, validate on 10000 samples\n",
      "Epoch 1/4\n",
      "60000/60000 [==============================] - 14s 231us/step - loss: 0.1913 - acc: 0.9411 - val_loss: 0.0569 - val_acc: 0.9823\n",
      "Epoch 2/4\n",
      "60000/60000 [==============================] - 12s 195us/step - loss: 0.0510 - acc: 0.9846 - val_loss: 0.0450 - val_acc: 0.9854\n",
      "Epoch 3/4\n",
      "60000/60000 [==============================] - 11s 191us/step - loss: 0.0310 - acc: 0.9904 - val_loss: 0.0355 - val_acc: 0.9878\n",
      "Epoch 4/4\n",
      "60000/60000 [==============================] - 11s 188us/step - loss: 0.0198 - acc: 0.9943 - val_loss: 0.0447 - val_acc: 0.9848\n",
      "Test loss: 0.044733963569859043\n",
      "Test accuracy: 0.9848\n"
     ]
    }
   ],
   "source": [
    "epochs = 4\n",
    "\n",
    "model = Sequential()\n",
    "model.add(Conv2D(32, kernel_size=(3, 3),\n",
    "                 activation='relu',\n",
    "                 input_shape=input_shape))\n",
    "model.add(Conv2D(64, (3, 3), activation='relu'))\n",
    "model.add(Flatten())\n",
    "model.add(Dense(128, activation='relu'))\n",
    "model.add(Dense(num_classes, activation='softmax'))\n",
    "\n",
    "model.compile(loss=keras.losses.categorical_crossentropy,\n",
    "              optimizer=keras.optimizers.Adadelta(),\n",
    "              metrics=['accuracy'])\n",
    "\n",
    "model.fit(x_train, y_train,\n",
    "          batch_size=batch_size,\n",
    "          epochs=epochs,\n",
    "          verbose=1,\n",
    "          validation_data=(x_test, y_test))\n",
    "score = model.evaluate(x_test, y_test, verbose=0)\n",
    "print('Test loss:', score[0])\n",
    "print('Test accuracy:', score[1])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.models import save_model\n",
    "save_model(model, 'mnist_model.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "K.clear_session()\n",
    "inference_model = load_model('mnist_model.h5')\n",
    "for l in inference_model.layers:\n",
    "    l.trainable = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss: 0.044733963569859043\n",
      "Test accuracy: 0.9848\n"
     ]
    }
   ],
   "source": [
    "score = inference_model.evaluate(x_test, y_test, verbose=0)\n",
    "print('Test loss:', score[0])\n",
    "print('Test accuracy:', score[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generate attack Dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Foolbox Example\n",
    "https://github.com/bethgelab/foolbox"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "0.17000002\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import foolbox\n",
    "import keras\n",
    "import numpy as np\n",
    "from random import randint\n",
    "\n",
    "num = randint(0, len(x_test))\n",
    "keras.backend.set_learning_phase(0)\n",
    "fmodel = foolbox.models.KerasModel(inference_model, bounds=(0, 1))\n",
    "image, label = x_test[num], np.argmax(y_test[num])\n",
    "print(label)\n",
    "\n",
    "attack = foolbox.attacks.FGSM(fmodel)\n",
    "adversarial = attack(image, label)\n",
    "# if the attack fails, adversarial will be None and a warning will be printed\n",
    "\n",
    "plot_attack(image, adversarial)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IBM-ART Exemple\n",
    "https://github.com/IBM/adversarial-robustness-toolbox"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "from os.path import abspath\n",
    "\n",
    "from art.attacks.fast_gradient import FastGradientMethod\n",
    "from art.classifiers import KerasClassifier\n",
    "from art.utils import load_dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss: 6.104571129608154\n",
      "Test accuracy: 0.0722\n",
      "0.30000004\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "min_, max_ = 0, 1\n",
    "\n",
    "classifier = KerasClassifier((min_, max_), model=inference_model)\n",
    "\n",
    "# Craft adversarial samples with FGSM\n",
    "epsilon = .3  # Maximum perturbation\n",
    "adv_crafter = FastGradientMethod(classifier)\n",
    "x_test_adv = adv_crafter.generate(x=x_test, eps=epsilon)\n",
    "\n",
    "# Evaluate the classifier on the adversarial examples\n",
    "\n",
    "score = inference_model.evaluate(x_test_adv, y_test, verbose=0)\n",
    "print('Test loss:', score[0])\n",
    "print('Test accuracy:', score[1])\n",
    "\n",
    "num = randint(0, len(x_test_adv))\n",
    "image, adversarial = x_test[num], x_test_adv[num]\n",
    "plot_attack(image, adversarial)"
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}