{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# FGSM网络对抗攻击\n", "\n", "[![在OpenI运行](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r1.10/resource/_static/logo_openi.png)](https://openi.pcl.ac.cn/MindSpore/docs/src/branch/r1.10/tutorials/application/source_zh_cn/cv/fgsm.ipynb?card=2&image=MindSpore1.8.1) [![下载Notebook](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r1.10/resource/_static/logo_notebook.png)](https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/r1.10/tutorials/application/zh_cn/cv/mindspore_fgsm.ipynb) [![下载样例代码](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r1.10/resource/_static/logo_download_code.png)](https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/r1.10/tutorials/application/zh_cn/cv/mindspore_fgsm.py) [![查看源文件](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r1.10/resource/_static/logo_source.png)](https://gitee.com/mindspore/docs/blob/r1.10/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/r1.10/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", "metadata": {}, "source": [ "## 数据处理\n", "\n", "本案例将使用MNIST训练一个精度达标的LeNet网络,然后运行上文中所提到的FGSM攻击方法,达到欺骗网络模型,让模型实现错误分类的效果。\n", "\n", "以下示例代码将数据集下载并解压到指定位置。" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Downloading data from https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/MNIST_Data.zip (10.3 MB)\n", "\n", "file_sizes: 100%|██████████████████████████| 10.8M/10.8M [00:01<00:00, 5.69MB/s]\n", "Extracting zip file...\n", "Successfully downloaded / unzipped to ./\n" ] } ], "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", "# 数据预处理\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)" ] }, { "cell_type": "markdown", "metadata": {}, "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": 2, "metadata": {}, "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()" ] }, { "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 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": {}, "source": [ "训练LeNet网络:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "epoch: 1 step: 1875, loss is 0.10958568006753922\n", "epoch: 2 step: 1875, loss is 0.06083061546087265\n", "epoch: 3 step: 1875, loss is 0.01855824515223503\n", "epoch: 4 step: 1875, loss is 0.009113041684031487\n", "epoch: 5 step: 1875, loss is 0.0039208317175507545\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)])" ] }, { "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.9898838141025641}\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": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 7, "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": 8, "metadata": {}, "outputs": [], "source": [ "def forward_fn(inputs, targets):\n", " out = network(inputs)\n", " loss = net_loss(out, targets)\n", " return loss" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "然后根据公式(2)实现FGSM攻击:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "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" ] }, { "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(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": {}, "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.9898838141025641\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)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "再将$\\varepsilon$设定为0.5,尝试运行攻击:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.2965745192307692\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": {}, "source": [ "从上面的打印结果可以看出,此时LeNet模型的精度大幅降低。\n", "\n", "下面演示受攻击照片现在的实际形态,可以看出图片只是发生了很小的变化,然而在精度测试中却严重下降:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "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": { "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.8.15" } }, "nbformat": 4, "nbformat_minor": 4 }