{ "cells": [ { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "# FGSM网络对抗攻击\n", "\n", "[![在线运行](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r2.0.0-alpha/resource/_static/logo_modelarts.png)](https://authoring-modelarts-cnnorth4.huaweicloud.com/console/lab?share-url-b64=aHR0cHM6Ly9vYnMuZHVhbHN0YWNrLmNuLW5vcnRoLTQubXlodWF3ZWljbG91ZC5jb20vbWluZHNwb3JlLXdlYnNpdGUvbm90ZWJvb2svcjIuMC4wLWFscGhhL3R1dG9yaWFscy9hcHBsaWNhdGlvbi96aF9jbi9jdi9taW5kc3BvcmVfZmdzbS5pcHluYg==&imageid=77ef960a-bd26-4de4-9695-5b85a786fb90) [![下载Notebook](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r2.0.0-alpha/resource/_static/logo_notebook.png)](https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/r2.0.0-alpha/tutorials/application/zh_cn/cv/mindspore_fgsm.ipynb) [![下载样例代码](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r2.0.0-alpha/resource/_static/logo_download_code.png)](https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/r2.0.0-alpha/tutorials/application/zh_cn/cv/mindspore_fgsm.py) [![查看源文件](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r2.0.0-alpha/resource/_static/logo_source.png)](https://gitee.com/mindspore/docs/blob/r2.0.0-alpha/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", "![fgsm-panda-image](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r2.0.0-alpha/tutorials/application/source_zh_cn/cv/images/panda.png)\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", "source": [ "## 数据处理\n", "\n", "本案例将使用MNIST训练一个精度达标的LeNet网络,然后运行上文中所提到的FGSM攻击方法,达到欺骗网络模型,让模型实现错误分类的效果。\n", "\n", "以下示例代码将数据集下载并解压到指定位置。" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%% md\n" } } }, { "cell_type": "code", "execution_count": 19, "outputs": [], "source": [ "import mindspore.dataset.vision as transforms\n", "from mindspore.dataset.vision import Inter\n", "from mindspore.dataset import MnistDataset\n", "from download import download\n", "\n", "url = \"https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/\" \\\n", " \"notebook/datasets/MNIST_Data.zip\"\n", "path = download(url, \"./\", kind=\"zip\", replace=True)\n", "\n", "dataset_train = MnistDataset(dataset_dir=\"./MNIST_Data/train\", usage=\"train\", shuffle=True)\n", "dataset_eval = MnistDataset(dataset_dir=\"./MNIST_Data/test\", usage=\"test\", shuffle=True)\n", "\n", "trans_transform = [\n", " transforms.Resize(size=32, interpolation=Inter.LINEAR),\n", " transforms.Rescale(1.0 / 255.0, 0.0),\n", " transforms.Rescale(1 / 0.3081, -1 * 0.1307 / 0.3081),\n", " transforms.HWC2CHW(),\n", "]\n", "\n", "dataset_train = dataset_train.map(operations=trans_transform, input_columns=[\"image\"])\n", "dataset_train = dataset_train.map(operations=lambda x: x.astype(\"int32\"), input_columns=[\"label\"])\n", "dataset_train = dataset_train.batch(batch_size=32, drop_remainder=True)\n", "\n", "dataset_eval = dataset_eval.map(operations=trans_transform, input_columns=[\"image\"])\n", "dataset_eval = dataset_eval.map(operations=lambda x: x.astype(\"int32\"), input_columns=[\"label\"])\n", "dataset_eval = dataset_eval.batch(batch_size=32, drop_remainder=True)" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "下载的数据集文件的目录结构如下:\n", "\n", "```text\n", "./MNIST_Data\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": 6, "outputs": [], "source": [ "from mindspore import nn\n", "from mindspore.common.initializer import Normal\n", "\n", "\n", "class LeNet5(nn.Cell):\n", " \"\"\"LeNet5\"\"\"\n", " def __init__(self, num_classes=10, num_channel=1, include_top=True):\n", " super(LeNet5, self).__init__()\n", " self.include_top = include_top\n", "\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.relu = nn.ReLU()\n", " self.max_pool2d = nn.MaxPool2d(kernel_size=2, stride=2)\n", "\n", " if self.include_top:\n", " self.flatten = nn.Flatten()\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_classes, weight_init=Normal(0.02))\n", "\n", " def construct(self, x):\n", " \"\"\"\n", " LeNet5 construct.\n", " \"\"\"\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", " if self.include_top:\n", " x = self.flatten(x)\n", " x = self.relu(self.fc1(x))\n", " x = self.relu(self.fc2(x))\n", " x = self.fc3(x)\n", " return x\n", "\n", "\n", "network = LeNet5()" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "定义优化器与损失函数:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "pycharm": { "name": "#%%\n" } }, "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": { "pycharm": { "name": "#%% md\n" } }, "source": [ "定义网络参数:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "from mindspore import train\n", "\n", "config_ck = train.CheckpointConfig(save_checkpoint_steps=1875, keep_checkpoint_max=10)\n", "ckpoint = train.ModelCheckpoint(prefix=\"checkpoint_lenet\", config=config_ck)" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "训练LeNet网络:" ] }, { "cell_type": "code", "execution_count": 9, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "epoch: 1 step: 1875, loss is 0.022706642746925354\n", "epoch: 2 step: 1875, loss is 0.11357966810464859\n", "epoch: 3 step: 1875, loss is 0.011764582246541977\n", "epoch: 4 step: 1875, loss is 0.014187423512339592\n", "epoch: 5 step: 1875, loss is 0.0022521568462252617\n" ] } ], "source": [ "from mindspore.train import LossMonitor\n", "import mindspore as ms\n", "\n", "model = ms.Model(network, loss_fn=net_loss, optimizer=net_opt, metrics={'accuracy'})\n", "model.train(5, dataset_train, callbacks=[ckpoint, LossMonitor(1875)])" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "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.9887820512820513}\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": 10, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "data": { "text/plain": "[]" }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "param_dict = ms.load_checkpoint(\"checkpoint_lenet-5_1875.ckpt\")\n", "ms.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": 12, "outputs": [], "source": [ "def forward_fn(inputs, targets):\n", " out = network(inputs)\n", " loss = net_loss(out, targets)\n", " return loss" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "然后根据公式(2)实现FGSM攻击:" ] }, { "cell_type": "code", "execution_count": 13, "outputs": [], "source": [ "import numpy as np\n", "\n", "\n", "def gradient_func(inputs, labels):\n", " _grad_all = ops.composite.GradOperation(get_all=True, sens_param=False)\n", " # 求取梯度\n", " out_grad = _grad_all(forward_fn)(inputs, labels)[0]\n", " gradient = out_grad.asnumpy()\n", " gradient = np.sign(gradient)\n", " return gradient\n", "\n", "\n", "def generate(inputs, labels, eps):\n", " # 实现FGSM\n", " inputs_tensor = ms.Tensor(inputs)\n", " labels_tensor = ms.Tensor(labels)\n", " gradient = gradient_func(inputs_tensor, labels_tensor)\n", " # 产生扰动\n", " perturbation = eps * gradient\n", " # 生成受到扰动的图片\n", " adv_x = inputs + perturbation\n", " return adv_x\n", "\n", "\n", "def batch_generate(inputs, labels, eps, batch_size):\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 = generate(x_batch, y_batch, eps=eps)\n", " res.append(adv_x)\n", " adv_x = np.concatenate(res, axis=0)\n", " return adv_x\n" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "再次处理MINIST数据集中测试集的图片:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "pycharm": { "name": "#%%\n" } }, "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(ms.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": { "pycharm": { "name": "#%% md\n" } }, "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": 16, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.9887820512820513\n" ] } ], "source": [ "import mindspore.ops as ops\n", "\n", "advs = batch_generate(test_images, true_labels, batch_size=32, eps=0.0)\n", "\n", "adv_predicts = model.predict(ms.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)" ], "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } } }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "再将$\\varepsilon$设定为0.5,尝试运行攻击:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.30138221153846156\n" ] } ], "source": [ "advs = batch_generate(test_images, true_labels, batch_size=32, eps=0.5)\n", "\n", "adv_predicts = model.predict(ms.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": { "pycharm": { "name": "#%% md\n" } }, "source": [ "从上面的打印结果可以看出,此时LeNet模型的精度大幅降低。\n", "\n", "下面演示受攻击照片现在的实际形态,可以看出图片只是发生了很小的变化,然而在精度测试中却严重下降:" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "data": { "text/plain": "
", "image/png": "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\n" }, "metadata": {}, "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": { "name": "mindspore", "language": "python", "display_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 }