{ "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/resource/_static/logo_modelarts.png)](https://authoring-modelarts-cnnorth4.huaweicloud.com/console/lab?share-url-b64=aHR0cHM6Ly9vYnMuZHVhbHN0YWNrLmNuLW5vcnRoLTQubXlodWF3ZWljbG91ZC5jb20vbWluZHNwb3JlLXdlYnNpdGUvbm90ZWJvb2svcjIuMC90dXRvcmlhbHMvYXBwbGljYXRpb24vemhfY24vY3YvbWluZHNwb3JlX2Znc20uaXB5bmI=&imageid=b8671c1e-c439-4ae2-b9c6-69b46db134ae) [![下载Notebook](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r2.0/resource/_static/logo_notebook.png)](https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/r2.0/tutorials/application/zh_cn/cv/mindspore_fgsm.ipynb) [![下载样例代码](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r2.0/resource/_static/logo_download_code.png)](https://obs.dualstack.cn-north-4.myhuaweicloud.com/mindspore-website/notebook/r2.0/tutorials/application/zh_cn/cv/mindspore_fgsm.py) [![查看源文件](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/r2.0/resource/_static/logo_source.png)](https://gitee.com/mindspore/docs/blob/r2.0/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/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", "> 更多的模型安全功能可参考[MindSpore Armour](https://www.mindspore.cn/mindarmour/docs/zh-CN/r2.0/index.html),现已支持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": { "collapsed": false, "pycharm": { "name": "#%% md\n" } }, "source": [ "## 数据处理\n", "\n", "本案例将使用MNIST训练一个精度达标的LeNet网络,然后运行上文中所提到的FGSM攻击方法,达到欺骗网络模型,让模型实现错误分类的效果。\n", "\n", "以下示例代码将数据集下载并解压到指定位置。" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } }, "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:11<00:00, 961kB/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", "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": { "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": 2, "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "from mindspore import nn, ops, grad\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": { "pycharm": { "name": "#%% md\n" } }, "source": [ "定义优化器与损失函数:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "net_loss = nn.CrossEntropyLoss()\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": 4, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "from mindspore.train import Model, LossMonitor, CheckpointConfig, ModelCheckpoint\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": { "pycharm": { "name": "#%% md\n" } }, "source": [ "训练LeNet网络:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "epoch: 1 step: 1875, loss is 0.05328045040369034\n", "epoch: 2 step: 1875, loss is 0.05333159118890762\n", "epoch: 3 step: 1875, loss is 0.010423079133033752\n", "epoch: 4 step: 1875, loss is 0.000635102391242981\n", "epoch: 5 step: 1875, loss is 0.23182234168052673\n" ] } ], "source": [ "\n", "model = 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.9879807692307693}\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": [ "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": { "collapsed": false, "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "def forward_fn(inputs, targets):\n", " out = network(inputs)\n", " loss = net_loss(out, targets)\n", " return loss" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "然后根据公式(2)实现FGSM攻击:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } }, "outputs": [], "source": [ "from mindspore import grad\n", "\n", "grad_fn = grad(forward_fn, 0)\n", "\n", "def generate(inputs, labels, eps):\n", " # 实现FGSM\n", " gradient = grad_fn(inputs, labels)\n", " # 产生扰动\n", " perturbation = eps * ops.sign(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 = ops.concat(res)\n", " return adv_x" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "再次处理MINIST数据集中测试集的图片:" ] }, { "cell_type": "code", "execution_count": 10, "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()\n", "\n", "for data in ds_test:\n", " images = data['image']\n", " labels = data['label']\n", " test_images.append(images)\n", " test_labels.append(labels)\n", " pred_labels = model.predict(images).argmax(1)\n", " predict_labels.append(pred_labels)\n", "\n", "test_images = ops.concat(test_images)\n", "predict_labels = ops.concat(predict_labels)\n", "true_labels = ops.concat(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": 11, "metadata": { "collapsed": false, "pycharm": { "name": "#%%\n" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.9879808\n" ] } ], "source": [ "import mindspore as ms\n", "\n", "advs = batch_generate(test_images, true_labels, batch_size=32, eps=0.0)\n", "\n", "adv_predicts = model.predict(advs).argmax(1)\n", "accuracy = ops.equal(adv_predicts, true_labels).astype(ms.float32).mean()\n", "print(accuracy)" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "再将$\\varepsilon$设定为0.5,尝试运行攻击:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.411258\n" ] } ], "source": [ "advs = batch_generate(test_images, true_labels, batch_size=32, eps=0.5)\n", "\n", "adv_predicts = model.predict(advs).argmax(1)\n", "accuracy = ops.equal(adv_predicts, true_labels).astype(ms.float32).mean()\n", "print(accuracy)" ] }, { "cell_type": "markdown", "metadata": { "pycharm": { "name": "#%% md\n" } }, "source": [ "从上面的打印结果可以看出,此时LeNet模型的精度大幅降低。\n", "\n", "下面演示受攻击照片现在的实际形态,可以看出图片只是发生了很小的变化,然而在精度测试中却严重下降:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "pycharm": { "name": "#%%\n" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "%matplotlib inline\n", "\n", "adv_examples = advs[:10].transpose(0, 2, 3, 1)\n", "ori_examples = test_images[:10].transpose(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(ori_examples[i].squeeze().asnumpy())\n", " plt.subplot(3, 10, i + 11)\n", " plt.axis(\"off\")\n", " plt.imshow(adv_examples[i].squeeze().asnumpy())\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.7.5" }, "vscode": { "interpreter": { "hash": "8c9da313289c39257cb28b126d2dadd33153d4da4d524f730c81a4aaccbd2ca7" } } }, "nbformat": 4, "nbformat_minor": 4 }