{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# FGSM网络对抗攻击\n", "\n", "[![在OpenI运行](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r1.9/resource/_static/logo_openi.png)](https://openi.pcl.ac.cn/MindSpore/docs/src/branch/r1.9/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.9/resource/_static/logo_notebook.png)](https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/r1.9/tutorials/application/zh_cn/cv/mindspore_fgsm.ipynb) [![下载样例代码](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r1.9/resource/_static/logo_download_code.png)](https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/r1.9/tutorials/application/zh_cn/cv/mindspore_fgsm.py) [![查看源文件](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r1.9/resource/_static/logo_source.png)](https://gitee.com/mindspore/docs/blob/r1.9/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.9/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:09<00:00, 1.09MB/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.14561422169208527\n", "epoch: 2 step: 1875, loss is 0.032565318048000336\n", "epoch: 3 step: 1875, loss is 0.004271362908184528\n", "epoch: 4 step: 1875, loss is 0.0025547388941049576\n", "epoch: 5 step: 1875, loss is 0.386110782623291\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.9894831730769231}\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.9895833333333334\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.34845753205128205\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 }