{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 对抗示例生成\n",
    "\n",
    "[![](https://gitee.com/mindspore/docs/raw/r1.3/resource/_static/logo_source.png)](https://gitee.com/mindspore/docs/blob/r1.3/tutorials/source_zh_cn/intermediate/image_and_video/adversarial_example_generation.ipynb) [![](https://gitee.com/mindspore/docs/raw/r1.3/resource/_static/logo_notebook.png)](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/r1.3/tutorials/zh_cn/mindspore_adversarial_example_generation.ipynb) [![](https://gitee.com/mindspore/docs/raw/r1.3/resource/_static/logo_modelarts.png)](https://authoring-modelarts-cnnorth4.huaweicloud.com/console/lab?share-url-b64=aHR0cHM6Ly9taW5kc3BvcmUtd2Vic2l0ZS5vYnMuY24tbm9ydGgtNC5teWh1YXdlaWNsb3VkLmNvbS9ub3RlYm9vay9yMS4zL3R1dG9yaWFscy96aF9jbi9taW5kc3BvcmVfYWR2ZXJzYXJpYWxfZXhhbXBsZV9nZW5lcmF0aW9uLmlweW5i&imageid=59a6e9f5-93c0-44dd-85b0-82f390c5d53b)\n",
    "\n",
    "近年来随着数据、计算能力、理论的不断发展演进，深度学习在图像、文本、语音、自动驾驶等众多领域都得到了广泛应用。与此同时，人们也越来越关注各类模型在使用过程中的安全问题，因为AI模型很容易受到外界有意无意的攻击而产生错误的结果。在本案例中，我们将以梯度符号攻击FGSM（Fast Gradient Sign Method）为例，演示此类攻击是如何误导模型的。\n",
    "\n",
    "> 本篇基于MindSpore v1.3.0，CPU/GPU/Ascend环境运行。\n",
    "\n",
    "## 对抗样本定义\n",
    "\n",
    "Szegedy在2013年最早提出对抗样本的概念：在原始样本处加入人类无法察觉的微小扰动，使得深度模型性能下降，这种样本即对抗样本。如下图所示，本来预测为“panda”的图像在添加噪声之后，模型就将其预测为“gibbon”，右边的样本就是一个对抗样本：\n",
    "\n",
    "![fgsm-panda-image](images/panda.png)\n",
    "\n",
    "> 图片来自[Explaining and Harnessing Adversarial Examples](https://arxiv.org/abs/1412.6572)。\n",
    "\n",
    "\n",
    "## 攻击方法\n",
    "\n",
    "对模型的攻击方法可以按照以下方法分类：\n",
    "\n",
    "1. 攻击者掌握的信息多少：\n",
    "\n",
    "1.1 白盒攻击：攻击者具有对模型的全部知识和访问权限，包括模型结构、权重、输入、输出。攻击者在产生对抗性攻击数据的过程中能够与模型系统有所交互。攻击者可以针对被攻击模型的特性设计特定的攻击算法。\n",
    "\n",
    "1.2 黑盒攻击：与白盒攻击相反，攻击者仅具有关于模型的有限知识。攻击者对模型的结构权重一无所知，仅了解部分输入输出。\n",
    "\n",
    "2. 攻击者的目的：\n",
    "\n",
    "2.1 有目标的攻击：攻击者将模型结果误导为特定分类。\n",
    "\n",
    "2.2 无目标的攻击：攻击者只想产生错误结果，而不在乎新结果是什么。\n",
    "\n",
    "本案例中用到的FGSM是一种白盒攻击方法，既可以是有目标也可以是无目标攻击。\n",
    "\n",
    "更多的模型安全功能可参考[MindArmour](https://www.mindspore.cn/mindarmour)，现支持FGSM、LLC、Substitute Attack等多种对抗样本生成方法，并提供对抗样本鲁棒性模块、Fuzz Testing模块、隐私保护与评估模块，帮助用户增强模型安全性。\n",
    "\n",
    "### 快速梯度符号攻击（FGSM）\n",
    "\n",
    "正常分类网络的训练会定义一个损失函数，用于衡量模型输出值与样本真实标签的距离，通过反向传播计算模型梯度，梯度下降更新网络参数，减小损失值，提升模型精度。\n",
    "\n",
    "FGSM（Fast Gradient Sign Method）是一种简单高效的对抗样本生成方法。不同于正常分类网络的训练过程，FGSM通过计算loss对于输入的梯度$\\nabla_x J(\\theta ,x ,y)$，这个梯度表征了loss对于输入变化的敏感性。然后在原始输入加上上述梯度，使得loss增大，模型对于改造后的输入样本分类效果变差，达到攻击效果。对抗样本的另一要求是生成样本与原始样本的差异要尽可能的小，使用sign函数可以使得修改图片时尽可能的均匀。\n",
    "\n",
    "产生的对抗扰动用公式可以表示为：\n",
    "\n",
    "$$ \\eta  = \\varepsilon  sign(\\nabla_x  J(\\theta))$$\n",
    "\n",
    "对抗样本可公式化为：\n",
    "\n",
    "$$ x' = x + \\epsilon \\times sign(\\nabla_x J(\\theta ,x ,y)) $$\n",
    "\n",
    "其中，\n",
    "- $x$：正确分类为“Pandas”的原始输入图像。\n",
    "- $y$：是$x$的输出。\n",
    "- $\\theta$：模型参数。\n",
    "- $\\varepsilon$：攻击系数。\n",
    "- $J(\\theta, x, y)$：训练网络的损失。\n",
    "- $\\nabla_x  J(\\theta)$：反向传播梯度。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 实验前准备\n",
    "\n",
    "### 导入模型训练需要的库\n",
    "\n",
    "本案例将使用MNIST训练一个精度达标的LeNet网络，然后运行上文中所提到的FGSM攻击方法，实现错误分类的效果。\n",
    "\n",
    "首先导入模型训练需要的库"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "\n",
    "from mindspore import Tensor, context, Model, load_checkpoint, load_param_into_net\n",
    "import mindspore.nn as nn\n",
    "import mindspore.ops as ops\n",
    "from mindspore.common.initializer import Normal\n",
    "from mindspore.train.callback import LossMonitor, ModelCheckpoint, CheckpointConfig\n",
    "import mindspore.dataset as ds\n",
    "import mindspore.dataset.transforms.c_transforms as C\n",
    "import mindspore.dataset.vision.c_transforms as CV\n",
    "from mindspore.dataset.vision import Inter\n",
    "from mindspore import dtype as mstype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 下载数据集\n",
    "\n",
    "下载MINIST数据集："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[01;34m./datasets/MNIST_Data\u001b[00m\r\n",
      "├── \u001b[01;34mtest\u001b[00m\r\n",
      "│   ├── t10k-images-idx3-ubyte\r\n",
      "│   └── t10k-labels-idx1-ubyte\r\n",
      "└── \u001b[01;34mtrain\u001b[00m\r\n",
      "    ├── train-images-idx3-ubyte\r\n",
      "    └── train-labels-idx1-ubyte\r\n",
      "\r\n",
      "2 directories, 4 files\r\n"
     ]
    }
   ],
   "source": [
    "!mkdir -p ./datasets/MNIST_Data/train ./datasets/MNIST_Data/test\n",
    "!wget -NP ./datasets/MNIST_Data/train https://mindspore-website.obs.myhuaweicloud.com/notebook/datasets/mnist/train-labels-idx1-ubyte\n",
    "!wget -NP ./datasets/MNIST_Data/train https://mindspore-website.obs.myhuaweicloud.com/notebook/datasets/mnist/train-images-idx3-ubyte\n",
    "!wget -NP ./datasets/MNIST_Data/test https://mindspore-website.obs.myhuaweicloud.com/notebook/datasets/mnist/t10k-labels-idx1-ubyte\n",
    "!wget -NP ./datasets/MNIST_Data/test https://mindspore-website.obs.myhuaweicloud.com/notebook/datasets/mnist/t10k-images-idx3-ubyte\n",
    "!tree ./datasets/MNIST_Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 攻击准备\n",
    "\n",
    "在完成准备工作之后，开始训练精度达标的LeNet网络。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "采用`GRAPH_MODE`在CPU/GPU/Ascend中运行本案例，下面将硬件设定为Ascend："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "context.set_context(mode=context.GRAPH_MODE, device_target='Ascend')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 训练LeNet网络\n",
    "\n",
    "实验中使用LeNet作为演示模型完成图像分类，这里先定义网络并使用MNIST数据集进行训练。\n",
    "\n",
    "定义LeNet网络："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LeNet5(nn.Cell):\n",
    "\n",
    "    def __init__(self, num_class=10, num_channel=1):\n",
    "        super(LeNet5, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(num_channel, 6, 5, pad_mode='valid')\n",
    "        self.conv2 = nn.Conv2d(6, 16, 5, pad_mode='valid')\n",
    "        self.fc1 = nn.Dense(16 * 5 * 5, 120, weight_init=Normal(0.02))\n",
    "        self.fc2 = nn.Dense(120, 84, weight_init=Normal(0.02))\n",
    "        self.fc3 = nn.Dense(84, num_class, weight_init=Normal(0.02))\n",
    "        self.relu = nn.ReLU()\n",
    "        self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)\n",
    "        self.flatten = nn.Flatten()\n",
    "\n",
    "    def construct(self, x):\n",
    "        x = self.conv1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.max_pool2d(x)\n",
    "        x = self.conv2(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.max_pool2d(x)\n",
    "        x = self.flatten(x)\n",
    "        x = self.fc1(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.fc2(x)\n",
    "        x = self.relu(x)\n",
    "        x = self.fc3(x)\n",
    "        return x\n",
    "\n",
    "net = LeNet5()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "进行数据处理："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_dataset(data_path, batch_size=1, num_parallel_workers=1):\n",
    "\n",
    "    # 定义数据集\n",
    "    mnist_ds = ds.MnistDataset(data_path)\n",
    "    resize_height, resize_width = 32, 32\n",
    "    rescale = 1.0 / 255.0\n",
    "    shift = 0.0\n",
    "    rescale_nml = 1 / 0.3081\n",
    "    shift_nml = -1 * 0.1307 / 0.3081\n",
    "\n",
    "    # 定义所需要操作的map映射\n",
    "    resize_op = CV.Resize((resize_height, resize_width), interpolation=Inter.LINEAR)\n",
    "    rescale_nml_op = CV.Rescale(rescale_nml, shift_nml)\n",
    "    rescale_op = CV.Rescale(rescale, shift)\n",
    "    hwc2chw_op = CV.HWC2CHW()\n",
    "    type_cast_op = C.TypeCast(mstype.int32)\n",
    "\n",
    "    # 使用map映射函数，将数据操作应用到数据集\n",
    "    mnist_ds = mnist_ds.map(operations=type_cast_op, input_columns=\"label\", num_parallel_workers=num_parallel_workers)\n",
    "    mnist_ds = mnist_ds.map(operations=resize_op, input_columns=\"image\", num_parallel_workers=num_parallel_workers)\n",
    "    mnist_ds = mnist_ds.map(operations=rescale_op, input_columns=\"image\", num_parallel_workers=num_parallel_workers)\n",
    "    mnist_ds = mnist_ds.map(operations=rescale_nml_op, input_columns=\"image\", num_parallel_workers=num_parallel_workers)\n",
    "    mnist_ds = mnist_ds.map(operations=hwc2chw_op, input_columns=\"image\", num_parallel_workers=num_parallel_workers)\n",
    "\n",
    "    # 进行shuffle、batch操作\n",
    "    buffer_size = 10000\n",
    "    mnist_ds = mnist_ds.shuffle(buffer_size=buffer_size)\n",
    "    mnist_ds = mnist_ds.batch(batch_size, drop_remainder=True)\n",
    "\n",
    "    return mnist_ds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义优化器与损失函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')\n",
    "net_opt = nn.Momentum(net.trainable_params(), learning_rate=0.01, momentum=0.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义网络参数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "config_ck = CheckpointConfig(save_checkpoint_steps=1875, keep_checkpoint_max=10)\n",
    "ckpoint = ModelCheckpoint(prefix=\"checkpoint_lenet\", config=config_ck)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义LeNet网络的训练函数和测试函数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_net(model, data_path):\n",
    "    ds_eval = create_dataset(os.path.join(data_path, \"test\"))\n",
    "    acc = model.eval(ds_eval, dataset_sink_mode=False)\n",
    "    print(\"{}\".format(acc))\n",
    "    \n",
    "def train_net(model, epoch_size, data_path, ckpoint_cb, sink_mode):\n",
    "    ds_train = create_dataset(os.path.join(data_path, \"train\"), 32)\n",
    "    model.train(epoch_size, ds_train, callbacks=[ckpoint_cb, LossMonitor(125)], dataset_sink_mode=sink_mode)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_epoch = 1\n",
    "mnist_path = \"./datasets/MNIST_Data/\"\n",
    "model = Model(net, net_loss, net_opt, metrics={\"Accuracy\": nn.Accuracy()})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "训练LeNet网络："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 1 step: 125, loss is 2.3018382\n",
      "epoch: 1 step: 250, loss is 2.2910337\n",
      "epoch: 1 step: 375, loss is 2.2876282\n",
      "epoch: 1 step: 500, loss is 2.293197\n",
      "epoch: 1 step: 625, loss is 2.2983356\n",
      "epoch: 1 step: 750, loss is 0.73134214\n",
      "epoch: 1 step: 875, loss is 0.39000687\n",
      "epoch: 1 step: 1000, loss is 0.12004304\n",
      "epoch: 1 step: 1125, loss is 0.10009943\n",
      "epoch: 1 step: 1250, loss is 0.31425583\n",
      "epoch: 1 step: 1375, loss is 0.14330618\n",
      "epoch: 1 step: 1500, loss is 0.05759584\n",
      "epoch: 1 step: 1625, loss is 0.18315211\n",
      "epoch: 1 step: 1750, loss is 0.19758298\n",
      "epoch: 1 step: 1875, loss is 0.0815863\n"
     ]
    }
   ],
   "source": [
    "train_net(model, train_epoch, mnist_path, ckpoint, False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "测试此时的网络，可以观察到LeNet已经达到比较高的精度："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Accuracy': 0.9691}\n"
     ]
    }
   ],
   "source": [
    "test_net(model, mnist_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "加载已经训练好的LeNet模型："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "param_dict = load_checkpoint(\"checkpoint_lenet-1_1875.ckpt\")\n",
    "load_param_into_net(net, param_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### 实现FGSM\n",
    "\n",
    "在得到精准的LeNet网络之后，下面将会采用FSGM攻击方法，在图像中加载噪声后重新进行测试。\n",
    "\n",
    "先通过损失函数求取反向梯度："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class WithLossCell(nn.Cell):\n",
    "    \"\"\"\n",
    "    包装网络与损失函数\n",
    "    \"\"\"\n",
    "    def __init__(self, network, loss_fn):\n",
    "        super(WithLossCell, self).__init__()\n",
    "        self._network = network\n",
    "        self._loss_fn = loss_fn\n",
    "\n",
    "    def construct(self, data, label):\n",
    "        out = self._network(data)\n",
    "        return self._loss_fn(out, label)\n",
    "\n",
    "\n",
    "class GradWrapWithLoss(nn.Cell):\n",
    "    \"\"\"\n",
    "    通过loss求反向梯度\n",
    "    \"\"\"\n",
    "    def __init__(self, network):\n",
    "        super(GradWrapWithLoss, self).__init__()\n",
    "        self._grad_all = ops.composite.GradOperation(get_all=True, sens_param=False)\n",
    "        self._network = network\n",
    "\n",
    "    def construct(self, inputs, labels):\n",
    "        gout = self._grad_all(self._network)(inputs, labels)\n",
    "        return gout[0]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "然后根据公式实现FGSM攻击："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FastGradientSignMethod:\n",
    "    \"\"\"\n",
    "    实现FGSM攻击\n",
    "    \"\"\"\n",
    "    def __init__(self, network, eps=0.07, loss_fn=None):\n",
    "        # 变量初始化\n",
    "        self._network = network\n",
    "        self._eps =  eps\n",
    "        with_loss_cell = WithLossCell(self._network, loss_fn)\n",
    "        self._grad_all = GradWrapWithLoss(with_loss_cell)\n",
    "        self._grad_all.set_train()\n",
    "\n",
    "\n",
    "    def _gradient(self, inputs, labels):\n",
    "        # 求取梯度\n",
    "        out_grad = self._grad_all(inputs, labels)\n",
    "        gradient = out_grad.asnumpy()\n",
    "        gradient = np.sign(gradient)\n",
    "        return gradient\n",
    "    \n",
    "    def generate(self, inputs, labels):\n",
    "        # 实现FGSM\n",
    "        inputs_tensor = Tensor(inputs)\n",
    "        labels_tensor = Tensor(labels) \n",
    "        gradient = self._gradient(inputs_tensor, labels_tensor)\n",
    "        # 产生扰动\n",
    "        perturbation = self._eps*gradient\n",
    "        # 生成受到扰动的图片\n",
    "        adv_x = inputs + perturbation\n",
    "        return adv_x\n",
    "    \n",
    "    def batch_generate(self, inputs, labels, batch_size=32):\n",
    "        # 对数据集进行处理\n",
    "        arr_x = inputs\n",
    "        arr_y = labels\n",
    "        len_x = len(inputs)\n",
    "        batches = int(len_x / batch_size)\n",
    "        rest = len_x - batches*batch_size\n",
    "        res = []\n",
    "        for i in range(batches):\n",
    "            x_batch = arr_x[i*batch_size: (i + 1)*batch_size]\n",
    "            y_batch = arr_y[i*batch_size: (i + 1)*batch_size]\n",
    "            adv_x = self.generate(x_batch, y_batch)\n",
    "            res.append(adv_x)\n",
    "        adv_x = np.concatenate(res, axis=0)\n",
    "        return adv_x    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "再次处理MINIST数据集中测试集的图片："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "images = []\n",
    "labels = []\n",
    "test_images = []\n",
    "test_labels = []\n",
    "predict_labels = []\n",
    "\n",
    "ds_test = create_dataset(os.path.join(mnist_path, \"test\"), batch_size=32).create_dict_iterator(output_numpy=True)\n",
    "\n",
    "for data in ds_test:\n",
    "    images = data['image'].astype(np.float32)\n",
    "    labels = data['label']\n",
    "    test_images.append(images)\n",
    "    test_labels.append(labels)\n",
    "    pred_labels = np.argmax(model.predict(Tensor(images)).asnumpy(), axis=1)\n",
    "    predict_labels.append(pred_labels)\n",
    "    \n",
    "test_images = np.concatenate(test_images)\n",
    "predict_labels = np.concatenate(predict_labels)\n",
    "true_labels = np.concatenate(test_labels)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 运行攻击\n",
    "\n",
    "由FGSM攻击公式中可以看出，攻击系数$\\varepsilon$越大，对梯度的改变就越大。当$\\varepsilon$ 为零时则攻击效果不体现。\n",
    "\n",
    "$$ \\eta  = \\varepsilon  sign(\\nabla_x  J(\\theta)) $$\n",
    "\n",
    "现在先观察当$\\varepsilon$为零时的攻击效果："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9602363782051282\n"
     ]
    }
   ],
   "source": [
    "fgsm = FastGradientSignMethod(net, eps=0.0, loss_fn=net_loss)\n",
    "advs = fgsm.batch_generate(test_images, true_labels, batch_size=32)\n",
    "\n",
    "adv_predicts = model.predict(Tensor(advs)).asnumpy()\n",
    "adv_predicts = np.argmax(adv_predicts, axis=1)\n",
    "accuracy = np.mean(np.equal(adv_predicts, true_labels))\n",
    "print(accuracy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "再将$\\varepsilon$设定为0.5，尝试运行攻击："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.3212139423076923\n"
     ]
    }
   ],
   "source": [
    "fgsm = FastGradientSignMethod(net, eps=0.5, loss_fn=net_loss)\n",
    "advs = fgsm.batch_generate(test_images, true_labels, batch_size=32)\n",
    "\n",
    "adv_predicts = model.predict(Tensor(advs)).asnumpy()\n",
    "adv_predicts = np.argmax(adv_predicts, axis=1)\n",
    "accuracy = np.mean(np.equal(adv_predicts, true_labels))\n",
    "print(accuracy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此时LeNet模型的精度大幅降低。\n",
    "\n",
    "下面演示受攻击照片现在的实际形态，可以看出图片并没有发生明显的改变，然而在精度测试中却有了不一样的结果："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 20 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "adv_examples = np.transpose(advs[:10],[0,2,3,1])\n",
    "ori_examples = np.transpose(test_images[:10],[0,2,3,1]) \n",
    "\n",
    "plt.figure() \n",
    "for i in range(10):\n",
    "    plt.subplot(2,10,i+1) \n",
    "    plt.imshow(ori_examples[i])\n",
    "    plt.subplot(2,10,i+11) \n",
    "    plt.imshow(adv_examples[i])\n"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}