{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# FGSM网络对抗攻击\n", "\n", "[](https://authoring-modelarts-cnnorth4.huaweicloud.com/console/lab?share-url-b64=aHR0cHM6Ly9vYnMuZHVhbHN0YWNrLmNuLW5vcnRoLTQubXlodWF3ZWljbG91ZC5jb20vbWluZHNwb3JlLXdlYnNpdGUvbm90ZWJvb2svcjEuNy90dXRvcmlhbHMvYXBwbGljYXRpb24vemhfY24vY3YvbWluZHNwb3JlX2Znc20uaXB5bmI=&imageid=9d63f4d1-dc09-4873-b669-3483cea777c0) [](https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/r1.7/tutorials/application/zh_cn/cv/mindspore_fgsm.ipynb) [](https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/r1.7/tutorials/application/zh_cn/cv/mindspore_fgsm.py) [](https://gitee.com/mindspore/docs/blob/r1.7/tutorials/application/source_zh_cn/cv/fgsm.ipynb)\n", "\n", "近年来随着数据、计算能力、理论的不断发展演进,深度学习在图像、文本、语音、自动驾驶等众多领域都得到了广泛应用。与此同时,人们也越来越关注各类模型在使用过程中的安全问题,因为AI模型很容易受到外界有意无意的攻击而产生错误的结果。\n", "\n", "在本案例中,我们将以梯度符号攻击(Fast Gradient Sign Method,FGSM)为例,演示此类攻击是如何误导模型的。\n", "\n", "## 对抗样本定义\n", "\n", "Szegedy在2013年最早提出对抗样本的概念:\n", "\n", "在原始样本处加入人类无法察觉的微小扰动,使得深度模型性能下降,这种样本即对抗样本。如下图所示,本来预测为“panda”的图像在添加噪声之后,模型就将其预测为“gibbon”,右边的样本就是一个对抗样本:\n", "\n", "\n", "\n", "> 图片来自[Explaining and Harnessing Adversarial Examples](https://arxiv.org/abs/1412.6572)。\n", "\n", "## 攻击方法\n", "\n", "对模型的攻击方法在宏观层面可以从如下两个方面进行分类:\n", "\n", "1. 攻击者掌握的信息多少:\n", "\n", " - **白盒攻击**:攻击者具有对模型的全部知识和访问权限,包括模型结构、权重、输入、输出,在产生对抗性攻击数据的过程中能够与模型系统有所交互。由于模型的信息完全被攻击者掌握,攻击者可以针对被攻击模型的特性设计特定的攻击算法。\n", "\n", " - **黑盒攻击**:与白盒攻击相反,攻击者仅具有关于模型的有限知识。攻击者对模型的结构权重一无所知,仅了解部分输入输出。\n", "\n", "2. 攻击者的目的:\n", "\n", " - **有目标的攻击**:攻击者将模型结果误导为特定分类。\n", "\n", " - **无目标的攻击**:攻击者只想产生错误结果,而不在乎新结果是什么。\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对于输入变化的敏感性。\n", "\n", "然后在原始输入加上上述梯度,使得loss增大,导致模型对于改造后的输入样本分类效果变差,从而达到攻击效果。\n", "\n", "对抗样本的另一要求是生成样本与原始样本的差异要尽可能的小,使用sign函数可以使得修改图片时尽可能的均匀。\n", "\n", "产生的对抗扰动用公式可以表示为:\n", "\n", "$$ \\eta = \\varepsilon sign(\\nabla_x J(\\theta)) \\tag{1}$$\n", "\n", "对抗样本可公式化为:\n", "\n", "$$ x' = x + \\varepsilon sign(\\nabla_x J(\\theta ,x ,y)) \\tag{2}$$\n", "\n", "其中,\n", "\n", "- $x$:正确分类为“Pandas”的原始输入图像。\n", "- $y$:是$x$的输出。\n", "- $\\theta$:模型参数。\n", "- $\\varepsilon$:攻击系数。\n", "- $J(\\theta, x, y)$:训练网络的损失。\n", "- $\\nabla_x J(\\theta)$:反向传播梯度。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 数据处理\n", "\n", "本案例将使用MNIST训练一个精度达标的LeNet网络,然后运行上文中所提到的FGSM攻击方法,达到欺骗网络模型,让模型实现错误分类的效果。\n", "\n", "以下示例代码将数据集下载并解压到指定位置。" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from mindvision.dataset import Mnist\n", "\n", "# 下载并处理MNIST数据集\n", "download_train = Mnist(path=\"./mnist\", split=\"train\", shuffle=True, download=True)\n", "download_eval = Mnist(path=\"./mnist\", split=\"test\", download=True)\n", "\n", "dataset_train = download_train.run()\n", "dataset_eval = download_eval.run()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "下载的数据集文件的目录结构如下:\n", "\n", "```text\n", "./mnist\n", "├── test\n", "│ ├── t10k-images-idx3-ubyte\n", "│ └── t10k-labels-idx1-ubyte\n", "└── train\n", " ├── train-images-idx3-ubyte\n", " └── train-labels-idx1-ubyte\n", "```\n", "\n", "## 训练LeNet网络\n", "\n", "实验中使用LeNet作为演示模型完成图像分类,这里先定义网络并使用MNIST数据集进行训练。\n", "\n", "定义LeNet网络:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "from mindvision.classification.models import lenet\n", "\n", "network = lenet(num_classes=10, pretrained=False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "定义优化器与损失函数:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "import mindspore.nn as nn\n", "\n", "net_loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')\n", "net_opt = nn.Momentum(network.trainable_params(), learning_rate=0.01, momentum=0.9)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "定义网络参数:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "from mindspore.train.callback import ModelCheckpoint, CheckpointConfig\n", "\n", "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": 5, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Epoch:[ 0/ 5], step:[ 1875/ 1875], loss:[0.094/0.094], time:2345.947 ms, lr:0.01000\n", "Epoch time: 3680.524 ms, per step time: 1.963 ms, avg loss: 0.094\n", "Epoch:[ 1/ 5], step:[ 1875/ 1875], loss:[0.323/0.323], time:1250.154 ms, lr:0.01000\n", "Epoch time: 1250.843 ms, per step time: 0.667 ms, avg loss: 0.323\n", "Epoch:[ 2/ 5], step:[ 1875/ 1875], loss:[0.014/0.014], time:1408.945 ms, lr:0.01000\n", "Epoch time: 1409.764 ms, per step time: 0.752 ms, avg loss: 0.014\n", "Epoch:[ 3/ 5], step:[ 1875/ 1875], loss:[0.198/0.198], time:1332.741 ms, lr:0.01000\n", "Epoch time: 1333.454 ms, per step time: 0.711 ms, avg loss: 0.198\n", "Epoch:[ 4/ 5], step:[ 1875/ 1875], loss:[0.001/0.001], time:1436.917 ms, lr:0.01000\n", "Epoch time: 1437.587 ms, per step time: 0.767 ms, avg loss: 0.001\n" ] } ], "source": [ "from mindspore.train import Model\n", "from mindvision.engine.callback import LossMonitor\n", "\n", "model = Model(network, loss_fn=net_loss, optimizer=net_opt, metrics={'accuracy'})\n", "model.train(5, dataset_train, callbacks=[ckpoint, LossMonitor(0.01, 1875)])" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "测试此时的网络,可以观察到LeNet已经达到比较高的精度:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'accuracy': 0.9888822115384616}\n" ] } ], "source": [ "acc = model.eval(dataset_eval)\n", "print(\"{}\".format(acc))" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "加载已经训练好的LeNet模型:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "from mindspore import load_checkpoint, load_param_into_net\n", "\n", "param_dict = load_checkpoint(\"checkpoint_lenet-5_1875.ckpt\")\n", "load_param_into_net(network, param_dict)" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "### 实现FGSM\n", "\n", "在得到精准的LeNet网络之后,下面将会采用FSGM攻击方法,在图像中加载噪声后重新进行测试。\n", "\n", "先通过损失函数求取反向梯度:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "class WithLossCell(nn.Cell):\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", " \"\"\"通过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]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "然后根据公式(2)实现FGSM攻击:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from mindspore import Tensor\n", "\n", "class FastGradientSignMethod:\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", " 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" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "再次处理MINIST数据集中测试集的图片:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "images = []\n", "labels = []\n", "test_images = []\n", "test_labels = []\n", "predict_labels = []\n", "\n", "ds_test = dataset_eval.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)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 运行攻击\n", "\n", "由FGSM攻击公式中可以看出,攻击系数$\\varepsilon$越大,对梯度的改变就越大。当$\\varepsilon$ 为零时则攻击效果不体现。\n", "\n", "$$\\eta = \\varepsilon sign(\\nabla_x J(\\theta)) \\tag{3}$$\n", "\n", "现在先观察当$\\varepsilon$为零时的攻击效果:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.9888822115384616\n" ] } ], "source": [ "import mindspore.ops as ops\n", "\n", "fgsm = FastGradientSignMethod(network, 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": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.36828926282051283\n" ] } ], "source": [ "fgsm = FastGradientSignMethod(network, 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": 13, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "<Figure size 1200x360 with 20 Axes>" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "%matplotlib inline\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(figsize=(10, 3), dpi=120)\n", "for i in range(10):\n", " plt.subplot(3, 10, i+1)\n", " plt.axis(\"off\")\n", " plt.imshow(np.squeeze(ori_examples[i]))\n", " plt.subplot(3, 10, i+11)\n", " plt.axis(\"off\")\n", " plt.imshow(np.squeeze(adv_examples[i]))\n", "plt.show()" ] } ], "metadata": { "kernelspec": { "display_name": "MindSpore", "language": "python", "name": "mindspore" }, "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.9.0" } }, "nbformat": 4, "nbformat_minor": 4 }