AE_singular_values.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initialized TensorFlow\n"
     ]
    }
   ],
   "source": [
    "\"\"\"\n",
    "This tutorial shows how to generate adversarial examples using FGSM\n",
    "and train a model using adversarial training with TensorFlow.\n",
    "It is very similar to mnist_tutorial_keras_tf.py, which does the same\n",
    "thing but with a dependence on keras.\n",
    "The original paper can be found at:\n",
    "https://arxiv.org/abs/1412.6572\n",
    "\"\"\"\n",
    "from __future__ import absolute_import\n",
    "from __future__ import division\n",
    "from __future__ import print_function\n",
    "from __future__ import unicode_literals\n",
    "\n",
    "from model import *\n",
    "import functools\n",
    "from cleverhans import initializers\n",
    "\n",
    "from tqdm import tqdm\n",
    "import logging\n",
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "from tensorflow.python.platform import flags\n",
    "\n",
    "from cleverhans.loss import CrossEntropy\n",
    "from cleverhans.dataset import MNIST\n",
    "from cleverhans.utils_tf import model_eval\n",
    "from cleverhans.train import train\n",
    "from cleverhans.attacks import FastGradientMethod\n",
    "from cleverhans.utils import AccuracyReport, set_log_level, get_log_level\n",
    "from cleverhans_tutorials.tutorial_models import ModelBasicCNN\n",
    "from cleverhans.model import Model\n",
    "from cleverhans.compat import softmax_cross_entropy_with_logits\n",
    "\n",
    "%matplotlib inline\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "FLAGS = flags.FLAGS\n",
    "\n",
    "NB_EPOCHS = 3\n",
    "BATCH_SIZE = 128\n",
    "LEARNING_RATE = 0.001\n",
    "CLEAN_TRAIN = True\n",
    "BACKPROP_THROUGH_ATTACK = False\n",
    "NB_FILTERS = 64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ModelCNN(Model):\n",
    "  def __init__(self, scope, nb_classes, nb_filters, **kwargs):\n",
    "    del kwargs\n",
    "    Model.__init__(self, scope, nb_classes, locals())\n",
    "    self.nb_filters = nb_filters\n",
    "\n",
    "    # Do a dummy run of fprop to make sure the variables are created from\n",
    "    # the start\n",
    "    self.fprop(tf.placeholder(tf.float32, [128, 28, 28, 1]))\n",
    "    # Put a reference to the params in self so that the params get pickled\n",
    "    self.params = self.get_params()\n",
    "\n",
    "  def eigens(self, sess, xs, x = None, x_orig = None):\n",
    "    with sess.as_default():\n",
    "        # forward propagation\n",
    "        out = self.fprop(x)\n",
    "        \n",
    "        # getting saved norms tensor array\n",
    "        torun = self.norms\n",
    "        \n",
    "        # running array with inputs\n",
    "        e = sess.run(torun, feed_dict = {x_orig: xs})\n",
    "        \n",
    "        # sanity check\n",
    "        assert len(e) % 2 == 0, \"Must have even number of arrays\"\n",
    "        \n",
    "        # unpacking results...\n",
    "        res = []\n",
    "        for x, y in zip(e[1::2], e[0::2]):\n",
    "            res += [[a / b for (a, b) in zip(x, y)]]\n",
    "            \n",
    "        # returning original arrays and the final result\n",
    "        return e, res\n",
    "    \n",
    "  def fprop(self, x, **kwargs):\n",
    "    del kwargs\n",
    "    my_conv = functools.partial(\n",
    "        tf.layers.conv2d, activation = None,\n",
    "        kernel_initializer=initializers.HeReLuNormalInitializer, use_bias = False)\n",
    "    def get_norm(y):\n",
    "        return tf.norm(tf.reshape(y, (-1, np.prod([int(t) for t in y.shape[1:]]))), axis = 1)\n",
    "    with tf.variable_scope(self.scope, reuse=tf.AUTO_REUSE):\n",
    "      norms = []\n",
    "      y = x\n",
    "      norms += [get_norm(y)]\n",
    "      y = my_conv(y, self.nb_filters, 8, strides=2, padding='same')\n",
    "      norms += [get_norm(y)]\n",
    "    \n",
    "      y = tf.nn.relu(y)\n",
    "      norms += [get_norm(y)]\n",
    "      y = my_conv(y, 2 * self.nb_filters, 6, strides=2, padding='valid')\n",
    "      norms += [get_norm(y)]\n",
    "    \n",
    "      y = tf.nn.relu(y)\n",
    "      norms += [get_norm(y)]\n",
    "      y = my_conv(y, 2 * self.nb_filters, 5, strides=1, padding='valid')\n",
    "      norms += [get_norm(y)]\n",
    "    \n",
    "      y = tf.nn.relu(y)\n",
    "        \n",
    "      norms += [get_norm(y)]\n",
    "      logits = tf.layers.dense(\n",
    "          tf.layers.flatten(y), self.nb_classes,\n",
    "          kernel_initializer=initializers.HeReLuNormalInitializer)\n",
    "      norms += [get_norm(logits)]\n",
    "      self.norms = norms\n",
    "      print('Saved norms tensor')\n",
    "      return {self.O_LOGITS: logits,\n",
    "              self.O_PROBS: tf.nn.softmax(logits=logits)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mnist_tutorial(train_start=0, train_end=60000, test_start=0,\n",
    "                   test_end=10000, nb_epochs=NB_EPOCHS, batch_size=BATCH_SIZE,\n",
    "                   learning_rate=LEARNING_RATE,\n",
    "                   clean_train=CLEAN_TRAIN,\n",
    "                   testing=False,\n",
    "                   backprop_through_attack=BACKPROP_THROUGH_ATTACK,\n",
    "                   nb_filters=NB_FILTERS, num_threads=None,\n",
    "                   label_smoothing=0.1):\n",
    "  \"\"\"\n",
    "  MNIST cleverhans tutorial\n",
    "  :param train_start: index of first training set example\n",
    "  :param train_end: index of last training set example\n",
    "  :param test_start: index of first test set example\n",
    "  :param test_end: index of last test set example\n",
    "  :param nb_epochs: number of epochs to train model\n",
    "  :param batch_size: size of training batches\n",
    "  :param learning_rate: learning rate for training\n",
    "  :param clean_train: perform normal training on clean examples only\n",
    "                      before performing adversarial training.\n",
    "  :param testing: if true, complete an AccuracyReport for unit tests\n",
    "                  to verify that performance is adequate\n",
    "  :param backprop_through_attack: If True, backprop through adversarial\n",
    "                                  example construction process during\n",
    "                                  adversarial training.\n",
    "  :param label_smoothing: float, amount of label smoothing for cross entropy\n",
    "  :return: an AccuracyReport object\n",
    "  \"\"\"\n",
    "\n",
    "  tf.reset_default_graph()\n",
    "\n",
    "  # Object used to keep track of (and return) key accuracies\n",
    "  report = AccuracyReport()\n",
    "\n",
    "  # Set logging level to see debug information\n",
    "  set_log_level(logging.WARNING)\n",
    "\n",
    "  # Create TF session\n",
    "  if num_threads:\n",
    "    config_args = dict(intra_op_parallelism_threads=1)\n",
    "  else:\n",
    "    config_args = {}\n",
    "  config = tf.ConfigProto(**config_args)\n",
    "  config.gpu_options.per_process_gpu_memory_fraction = 0.5\n",
    "  config.gpu_options.allow_growth = True\n",
    "  sess = tf.Session(config=config)\n",
    "\n",
    "  # Get MNIST data\n",
    "  mnist = MNIST(train_start=train_start, train_end=train_end,\n",
    "                test_start=test_start, test_end=test_end)\n",
    "  x_train, y_train = mnist.get_set('train')\n",
    "  x_test, y_test = mnist.get_set('test')\n",
    "\n",
    "  #print(np.min(x_train), np.max(x_train)) 0.0 1.0\n",
    "\n",
    "  # Use Image Parameters\n",
    "  img_rows, img_cols, nchannels = x_train.shape[1:4]\n",
    "  nb_classes = y_train.shape[1]\n",
    "    \n",
    "  print('NormTrain: %.2f' % np.linalg.norm(x_train[0].flatten()))\n",
    "\n",
    "  # Define input TF placeholder\n",
    "  x = tf.placeholder(tf.float32, shape=(None, img_rows, img_cols,\n",
    "                                        nchannels))\n",
    "  y = tf.placeholder(tf.float32, shape=(None, nb_classes))\n",
    "\n",
    "  # Train an MNIST model\n",
    "  train_params = {\n",
    "      'nb_epochs': nb_epochs,\n",
    "      'batch_size': batch_size,\n",
    "      'learning_rate': learning_rate\n",
    "  }\n",
    "  eval_params = {\n",
    "      'batch_size': batch_size\n",
    "  }\n",
    "\n",
    "  # making attack single-coordinate\n",
    "  fgsm_params = {\n",
    "      'eps': 0.1,\n",
    "      'clip_min': 0.,\n",
    "      'clip_max': 1.\n",
    "  }\n",
    "  rng = np.random.RandomState([2017, 8, 30])\n",
    "\n",
    "  def do_eval(preds, x_set, y_set, report_key, is_adv=None):\n",
    "    acc = model_eval(sess, x, y, preds, x_set, y_set, args=eval_params, feed = {})\n",
    "    setattr(report, report_key, acc)\n",
    "    if is_adv is None:\n",
    "      report_text = None\n",
    "    elif is_adv:\n",
    "      report_text = 'adversarial'\n",
    "    else:\n",
    "      report_text = 'legitimate'\n",
    "    if report_text:\n",
    "      print('Test accuracy on %s examples: %0.4f' % (report_text, acc))\n",
    "\n",
    "  if clean_train:\n",
    "    model = ModelCNN('model1', nb_classes, nb_filters)\n",
    "    preds = model.get_logits(x)\n",
    "    loss = CrossEntropy(model, smoothing=label_smoothing)\n",
    "\n",
    "    def evaluate():\n",
    "      do_eval(preds, x_test, y_test, 'clean_train_clean_eval', False)\n",
    "    \n",
    "    #eigens1 = model.eigens(sess, x_train)\n",
    "\n",
    "    train(sess, loss, x_train, y_train, evaluate=evaluate,\n",
    "          args=train_params, rng=rng, var_list=model.get_params(),\n",
    "          feed = {})\n",
    "    \n",
    "    def loss_grad_orig(x):\n",
    "        with sess.as_default():\n",
    "            loss = softmax_cross_entropy_with_logits(labels=y, logits=preds)\n",
    "            return sess.run(tf.gradients(loss, x), feed_dict = {})\n",
    "            \n",
    "    #grads1 = loss_grad_orig(x_test[:1000])\n",
    "    \n",
    "    _, eigens1 = model.eigens(sess, x_test[:1000], x = x, x_orig = x)\n",
    "    _, eigens2 = model.eigens(sess, x_train[:1000], x = x, x_orig = x)\n",
    "    \n",
    "    #return e\n",
    "\n",
    "    # Calculate training error\n",
    "    if testing:\n",
    "      do_eval(preds, x_train, y_train, 'train_clean_train_clean_eval')\n",
    "\n",
    "    # Initialize the Fast Gradient Sign Method (FGSM) attack object and\n",
    "    # graph\n",
    "    fgsm = FastGradientMethod(model, sess=sess)\n",
    "    adv_x = fgsm.generate(x, **fgsm_params)\n",
    "    preds_adv = model.get_logits(adv_x)\n",
    "\n",
    "    # Evaluate the accuracy of the MNIST model on adversarial examples\n",
    "    do_eval(preds_adv, x_test[:1000], y_test[:1000], 'clean_train_adv_eval', True)\n",
    "\n",
    "    _, eigens3 = model.eigens(sess, x_train[:1000], x = adv_x, x_orig = x)\n",
    "\n",
    "    # Calculate training error\n",
    "    if testing:\n",
    "      do_eval(preds_adv, x_train, y_train, 'train_clean_train_adv_eval')\n",
    "    \n",
    "    return eigens1, eigens2, eigens3\n",
    "\n",
    "  return report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NormTrain: 9.56\n",
      "Saved norms tensor\n",
      "Saved norms tensor\n",
      "Saved norms tensor\n",
      "Saved norms tensor\n",
      "num_devices:  2\n",
      "Test accuracy on legitimate examples: 0.9883\n",
      "Test accuracy on legitimate examples: 0.9907\n",
      "Test accuracy on legitimate examples: 0.9923\n",
      "Saved norms tensor\n",
      "Saved norms tensor\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/localhome/xxxx/miniconda3/envs/neuronfailure/lib/python3.6/site-packages/cleverhans/attacks_tf.py:26: UserWarning: attacks_tf is deprecated and will be removed on 2019-07-18 or after. Code should import functions from their new locations directly.\n",
      "  warnings.warn(\"attacks_tf is deprecated and will be removed on 2019-07-18\"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saved norms tensor\n",
      "Saved norms tensor\n",
      "Saved norms tensor\n",
      "Test accuracy on adversarial examples: 0.8330\n",
      "Saved norms tensor\n"
     ]
    }
   ],
   "source": [
    "res = mnist_tutorial()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "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": [
    "for i in range(len(res[0])):\n",
    "    plt.figure()\n",
    "    test_, train_, adv_ = [x[i] for x in res]\n",
    "    plt.title('Layer %d' % (i + 1))\n",
    "    plt.hist(test_, alpha = 0.5, label = 'Test')\n",
    "    plt.hist(train_, alpha = 0.5, label = 'Train')\n",
    "    plt.hist(adv_, alpha = 0.5, label = 'Adversarial')\n",
    "    plt.legend()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.8"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}