demo_adversarial_examples_MNIST.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Adversarial Examples: a simple demo on MNIST with a 4-layer concolutional neural network (CNN)\n",
    "\n",
    "Adversarial examples are slight perturbed inputs in a way to fool a neural network.\n",
    "\n",
    "Here is the famous \"panda->gibbon\" example:\n",
    "\n",
    "<img src=\"images/adversarial_example.jpg\" width=\"600\">\n",
    "\n",
    "This demo shows how to train a simple deep neural network and trick the network with adversarial examples. A simple 4 layer neural network will be trained to recognize handwritten digits (MNIST). We then will use the Fast Gradient Sign Mehtod (FGSM) to craft adversarial examples based on a test image.\n",
    "\n",
    "<img src=\"images/mnist_advs.png\" width=\"600\">\n",
    "\n",
    "(The demo is implemented by Daniel (Xingjun) Ma for [AI2019 Adversarial Machine Learning Tutorial](http://nugget.unisa.edu.au/AI2019/index.php)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Load dataset\n",
    "### Load MNIST data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.datasets import mnist\n",
    "(X_train, y_train), (X_test, y_test) = mnist.load_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### reshape to (n_samples, 28, 28, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = X_train.reshape(-1, 28, 28, 1)\n",
    "X_test = X_test.reshape(-1, 28, 28, 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### cast pixels to floats, normalize to [0, 1] range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = X_train.astype('float32')\n",
    "X_test = X_test.astype('float32')\n",
    "\n",
    "X_train = (X_train / 255.0)\n",
    "X_test = (X_test / 255.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### one-hot encoding the class labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.utils import np_utils\n",
    "# one-hot encoding the class labels\n",
    "Y_train = np_utils.to_categorical(y_train, 10)\n",
    "Y_test = np_utils.to_categorical(y_test, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train: (60000, 28, 28, 1)\n",
      "Y_train: (60000, 10)\n",
      "X_test: (10000, 28, 28, 1)\n",
      "Y_test (10000, 10)\n"
     ]
    }
   ],
   "source": [
    "print(\"X_train:\", X_train.shape)\n",
    "print(\"Y_train:\", Y_train.shape)\n",
    "print(\"X_test:\", X_test.shape)\n",
    "print(\"Y_test\", Y_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Build a 4-layer convolutional nerual network\n",
    "### Create the network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load the keras layers\n",
    "from keras.layers import Input, Conv2D, Dense, MaxPooling2D, Dropout, \\\n",
    "    Flatten, Activation, BatchNormalization, Activation, AvgPool2D\n",
    "from keras.models import Model\n",
    "\n",
    "img_input = Input(shape=(28, 28, 1))\n",
    "\n",
    "x = Conv2D(32, (3, 3), padding='same', kernel_initializer=\"he_normal\", name='conv1')(img_input)\n",
    "x = BatchNormalization()(x)\n",
    "x = Activation('relu')(x)\n",
    "x = AvgPool2D((2, 2), strides=(2, 2), name='pool1')(x)\n",
    "\n",
    "x = Conv2D(64, (3, 3), padding='same', kernel_initializer=\"he_normal\", name='conv2')(x)\n",
    "x = BatchNormalization()(x)\n",
    "x = Activation('relu')(x)\n",
    "x = AvgPool2D((2, 2), strides=(2, 2), name='pool2')(x)\n",
    "\n",
    "x = Flatten(name='flatten')(x)\n",
    "\n",
    "x = Dense(128, kernel_initializer=\"he_normal\", name='features')(x)\n",
    "\n",
    "x = Dense(10, name='logits')(x)\n",
    "x = Activation(\"softmax\")(x)\n",
    "\n",
    "model = Model(img_input, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Check the structure of the network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_7 (InputLayer)         (None, 28, 28, 1)         0         \n",
      "_________________________________________________________________\n",
      "conv1 (Conv2D)               (None, 28, 28, 32)        320       \n",
      "_________________________________________________________________\n",
      "batch_normalization_6 (Batch (None, 28, 28, 32)        128       \n",
      "_________________________________________________________________\n",
      "activation_8 (Activation)    (None, 28, 28, 32)        0         \n",
      "_________________________________________________________________\n",
      "pool1 (AveragePooling2D)     (None, 14, 14, 32)        0         \n",
      "_________________________________________________________________\n",
      "conv2 (Conv2D)               (None, 14, 14, 64)        18496     \n",
      "_________________________________________________________________\n",
      "batch_normalization_7 (Batch (None, 14, 14, 64)        256       \n",
      "_________________________________________________________________\n",
      "activation_9 (Activation)    (None, 14, 14, 64)        0         \n",
      "_________________________________________________________________\n",
      "pool2 (AveragePooling2D)     (None, 7, 7, 64)          0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 3136)              0         \n",
      "_________________________________________________________________\n",
      "features (Dense)             (None, 128)               401536    \n",
      "_________________________________________________________________\n",
      "logits (Dense)               (None, 10)                1290      \n",
      "_________________________________________________________________\n",
      "activation_10 (Activation)   (None, 10)                0         \n",
      "=================================================================\n",
      "Total params: 422,026\n",
      "Trainable params: 421,834\n",
      "Non-trainable params: 192\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create the optimizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.optimizers import Adam, SGD\n",
    "# optimizer = SGD(lr=0.01, decay=1e-4, momentum=0.9)\n",
    "optimizer = Adam(learning_rate=0.001, beta_1=0.9, beta_2=0.999, amsgrad=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compile the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(\n",
    "    loss='categorical_crossentropy',\n",
    "    optimizer=optimizer,\n",
    "    metrics=['accuracy']\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Train the model for 10 epochs with batch size 128"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 60000 samples, validate on 10000 samples\n",
      "Epoch 1/10\n",
      "60000/60000 [==============================] - 162s 3ms/step - loss: 0.1634 - acc: 0.9491 - val_loss: 0.0729 - val_acc: 0.9766\n",
      "Epoch 2/10\n",
      "60000/60000 [==============================] - 143s 2ms/step - loss: 0.0599 - acc: 0.9817 - val_loss: 0.0511 - val_acc: 0.9833\n",
      "Epoch 3/10\n",
      "60000/60000 [==============================] - 144s 2ms/step - loss: 0.0457 - acc: 0.9859 - val_loss: 0.0381 - val_acc: 0.9881\n",
      "Epoch 4/10\n",
      "60000/60000 [==============================] - 129s 2ms/step - loss: 0.0385 - acc: 0.9879 - val_loss: 0.0402 - val_acc: 0.9876\n",
      "Epoch 5/10\n",
      "60000/60000 [==============================] - 129s 2ms/step - loss: 0.0336 - acc: 0.9897 - val_loss: 0.0359 - val_acc: 0.9877\n",
      "Epoch 6/10\n",
      "60000/60000 [==============================] - 128s 2ms/step - loss: 0.0300 - acc: 0.9907 - val_loss: 0.0339 - val_acc: 0.9883\n",
      "Epoch 7/10\n",
      "60000/60000 [==============================] - 128s 2ms/step - loss: 0.0260 - acc: 0.9921 - val_loss: 0.0301 - val_acc: 0.9908\n",
      "Epoch 8/10\n",
      "60000/60000 [==============================] - 130s 2ms/step - loss: 0.0238 - acc: 0.9927 - val_loss: 0.0299 - val_acc: 0.9896\n",
      "Epoch 9/10\n",
      "60000/60000 [==============================] - 151s 3ms/step - loss: 0.0223 - acc: 0.9933 - val_loss: 0.0334 - val_acc: 0.9898\n",
      "Epoch 10/10\n",
      "60000/60000 [==============================] - 141s 2ms/step - loss: 0.0198 - acc: 0.9942 - val_loss: 0.0288 - val_acc: 0.9906\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x12bb562b0>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model.fit(X_train, Y_train,\n",
    "          batch_size=128,\n",
    "          epochs=10,\n",
    "          verbose=1,\n",
    "          validation_data=(X_test, Y_test))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save/load the trained model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "# model.save_weights('model/mnist.h5')\n",
    "model.load_weights('model/mnist.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Evaluate the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "_, test_acc = model.evaluate(X_test, Y_test, verbose=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test accuracy: 0.99\n"
     ]
    }
   ],
   "source": [
    "print('Test accuracy: %.2f' % test_acc)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Craft adversarial examples using Fast Gradient Sign Method (FGSM) attack\n",
    "### Define TF placeholders for the input and output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "x_test = tf.placeholder(tf.float32, shape=(None,) + X_test.shape[1:])\n",
    "y_test = tf.placeholder(tf.float32, shape=(None,) + Y_test.shape[1:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Use cleverhans [https://github.com/tensorflow/cleverhans]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "import keras.backend as K\n",
    "from cleverhans.evaluation import batch_eval\n",
    "from cleverhans.attacks import FastGradientMethod"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Wrap the model for cleverhans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "from cleverhans.utils_keras import KerasModelWrapper\n",
    "model = KerasModelWrapper(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10000, 28, 28, 1)"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Crafting fgsm adversarial samples...\n",
      "Done\n"
     ]
    }
   ],
   "source": [
    "print('Crafting fgsm adversarial samples...')\n",
    "\n",
    "fgsm = FastGradientMethod(model)\n",
    "fgsm_params = {'eps': 0.3,\n",
    "               'clip_min': 0,\n",
    "               'clip_max': 1}\n",
    "\n",
    "adv_x = fgsm.generate(x_test, **fgsm_params)\n",
    "\n",
    "X_adv, = batch_eval(sess=K.get_session(), tf_inputs=[x_test, y_test], tf_outputs=[adv_x],\n",
    "                    numpy_inputs=[X_test, Y_test], batch_size=100)\n",
    "\n",
    "print('Done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### predict the adversarial labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = model.model\n",
    "predictions = model.predict(X_adv, batch_size=100, verbose=0)\n",
    "y_pred = np.argmax(predictions, axis=1)\n",
    "Y_adv = np_utils.to_categorical(y_pred, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save adversarial examples and labels into local files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save('data/advs_fgsm.npy', X_adv)\n",
    "np.save('data/labels_advs_fgsm.npy', Y_adv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### check predictions on adversarial examples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy on clean test set: 99.06%\n",
      "Model accuracy on the adversarial test set: 4.28%\n"
     ]
    }
   ],
   "source": [
    "# model = model.model # switch back to normal model from KerasModelWrapper\n",
    "_, acc = model.evaluate(X_test, Y_test, batch_size=100, verbose=0)\n",
    "print(\"Accuracy on clean test set: %0.2f%%\" % (100*acc))\n",
    "\n",
    "# statistics of the attacks\n",
    "_, acc = model.evaluate(X_adv, Y_test, batch_size=100, verbose=0)\n",
    "print(\"Model accuracy on the adversarial test set: %0.2f%%\" % (100 * acc))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### check average L2 perturbation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average L-2 distortion [FGSM: 6.24]\n"
     ]
    }
   ],
   "source": [
    "l2_diff = np.linalg.norm(\n",
    "    X_adv.reshape((len(X_test), -1)) -\n",
    "    X_test.reshape((len(X_test), -1)),\n",
    "    axis=1\n",
    ").mean()\n",
    "print(\"Average L-2 distortion [%s: %0.2f]\" % ('FGSM', l2_diff))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### check $L_{\\infty}$ perturbation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average L-i distortion [FGSM: 0.30]\n"
     ]
    }
   ],
   "source": [
    "li_diff = np.max(\n",
    "    np.abs(\n",
    "        X_adv.reshape((len(X_test), -1)) -\n",
    "        X_test.reshape((len(X_test), -1))),\n",
    "        axis=0\n",
    ").mean()\n",
    "print(\"Average L-i distortion [%s: %0.2f]\" % ('FGSM', li_diff))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Visualize adversarial examples\n",
    "### clean vs advs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define source -> target classes\n",
    "classes = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']\n",
    "target_classes = ['3', '9', '3', '0', '5', '8', '8', '9', '5', '7']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1080x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [],
   "source": [
    "# one-hot to integer labels\n",
    "clean_labels = np.argmax(Y_test, axis=1)\n",
    "adv_labels = np.argmax(Y_adv, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([8, 8, 8, ..., 8, 8, 8])"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "adv_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "selected random samples:  [7887, 6254, 1335, 5724, 4258, 4302, 2160, 144, 9817, 7535]\n",
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "[9 8 1 8 8 3 5 3 6 8]\n",
      "\n",
      "Saving figure\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x288 with 20 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.gridspec as gridspec\n",
    "\n",
    "# image properties\n",
    "dataset = 'mnist'\n",
    "attack = 'FGSM'\n",
    "n_classes = 10\n",
    "n_channels = 1\n",
    "image_size = 28\n",
    "\n",
    "# find one random image index for each class\n",
    "sample_idxes = []\n",
    "for i in range(n_classes):\n",
    "    ind, = np.where(clean_labels == i)\n",
    "    select = np.random.choice(ind, size=1)\n",
    "    sample_idxes.append(select[0])\n",
    "print('selected random samples: ', sample_idxes)\n",
    "print(clean_labels[sample_idxes])\n",
    "print(adv_labels[sample_idxes])\n",
    "\n",
    "%matplotlib inline\n",
    "# creat the grid plot\n",
    "fig = plt.figure(figsize=(1.5*n_classes, 4))\n",
    "gs = gridspec.GridSpec(2, n_classes, wspace=0.025, hspace=0.05)\n",
    "\n",
    "## plot normal images\n",
    "for i in range(n_classes):\n",
    "    ax = fig.add_subplot(gs[0, i])\n",
    "    img = X_test[sample_idxes[i]]\n",
    "    label = classes[i]\n",
    "    # deal with normalized images [-0.5, 0.5] - already buildin in matplot?\n",
    "    img = img + 0.5\n",
    "    if n_channels == 1:\n",
    "        img = np.reshape(img, (image_size,image_size))\n",
    "        ax.imshow(img, cmap='gray')\n",
    "    else:\n",
    "        img = np.reshape(img, (image_size, image_size, n_channels))\n",
    "        ax.imshow(img)\n",
    "\n",
    "    if ax.is_first_col():\n",
    "        ax.set_ylabel('Clean', fontsize=15)\n",
    "\n",
    "    # Hide the right and top spines\n",
    "    ax.spines['right'].set_visible(False)\n",
    "    ax.spines['top'].set_visible(False)\n",
    "    ax.spines['left'].set_visible(False)\n",
    "    ax.spines['bottom'].set_visible(False)\n",
    "    ax.set_xticks([])\n",
    "    ax.set_yticks([])\n",
    "    ax.set_title(label, fontsize=12)\n",
    "\n",
    "## plot advs images\n",
    "for j in range(n_classes):\n",
    "    img = X_adv[sample_idxes[j]]\n",
    "    label = classes[adv_labels[sample_idxes[j]]]\n",
    "\n",
    "    ax = fig.add_subplot(gs[1, j])\n",
    "    img = img + 0.5\n",
    "    if n_channels == 1:\n",
    "        img = np.reshape(img, (image_size, image_size))\n",
    "    else:\n",
    "        img = np.reshape(img, (image_size, image_size, n_channels))\n",
    "\n",
    "    if n_channels == 1:\n",
    "        ax.imshow(img, cmap='gray')\n",
    "    else:\n",
    "        ax.imshow(img)\n",
    "\n",
    "    if ax.is_first_col():\n",
    "        ax.set_ylabel(attack, fontsize=15)\n",
    "\n",
    "    ax.set_title(label, fontsize=12)\n",
    "    # Hide the right and top spines\n",
    "    ax.spines['right'].set_visible(False)\n",
    "    ax.spines['top'].set_visible(False)\n",
    "    ax.spines['left'].set_visible(False)\n",
    "    ax.spines['bottom'].set_visible(False)\n",
    "    ax.set_xticks([])\n",
    "    ax.set_yticks([])\n",
    "\n",
    "print('\\nSaving figure')\n",
    "# gs.tight_layout(fig) # don't use this - this will writeoff wspace/hspace settings\n",
    "fig.savefig(\"images/%s_%s_clean_advs.png\" % (dataset, attack), dpi=300)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "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.5.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}