AI安全之对抗样本攻击---FGSM实战脚本解析

一、对抗样本与FGSM的背景

在深度学习安全领域，对抗样本（Adversarial Examples）因其特殊的生成机制备受关注。2015年ICLR会议收录的里程碑式论文《Explaining and Harnessing Adversarial Examples》中，Goodfellow等学者首次系统阐述了快速梯度符号方法（FGSM）的生成原理，这一发现揭示了深度神经网络在鲁棒性方面存在的重大缺陷。

二、FGSM的核心工作原理

不同于常规训练中的梯度下降优化，FGSM采用逆向梯度操作实现对抗样本生成。其本质是通过梯度符号方向的参数扰动，构造出使模型产生错误判断的输入样本。具体而言：

梯度方向逆转：传统网络训练通过损失函数梯度反方向（-∇）更新参数，而FGSM则沿梯度正方向（+∇）施加扰动
扰动控制机制：通过ε参数约束扰动幅度，确保对抗样本在人类视觉感知中与原始样本无明显差异
损失函数最大化：数学表达为x_adv = x + ε·sign(∇_xJ(θ,x,y))，其中J为损失函数，θ为模型参数

实战代码解析：

python 复制代码

# -*- coding: utf-8 -*-
from __future__ import print_function
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
import numpy as np
import matplotlib.pyplot as plt

# 下载MNIST数据集时，解决"用户代理"限制的问题
# 详情参考： https://github.com/pytorch/vision/issues/3497
from six.moves import urllib
opener = urllib.request.build_opener()
opener.addheaders = [('User-agent', 'Mozilla/5.0')]
urllib.request.install_opener(opener)

"""代码实现
--------------

本节将详细阐述本教程的输入参数定义、受攻击模型配置，以及攻击算法的具体实现与验证测试。

输入参数配置
~~~~~~

本实现包含三个关键输入参数，其定义如下：

-  **扰动系数（epsilons）** 
   
   用于实验的ε值列表，需注意：
   - 必须包含0值用于基准测试（原始样本准确率）
   - 根据数据归一化范围$[0,1]$，ε最大值不应超过1
   - 经验规律：ε值与扰动可见性、模型准确率下降程度呈正相关

-  **预训练模型（pretrained_model）** 
   基于PyTorch官方MNIST示例训练的模型路径：
   ``` 
   https://github.com/pytorch/examples/tree/master/mnist
   ```  
   为方便使用，可直接下载预训练模型：
   ```
   https://drive.google.com/drive/folders/1fn83DF14tWmit0RTKWRhPq5uVXt73e0h?usp=sharing
   ``` 

-  **GPU加速（use_cuda）**  
   布尔型标志位，启用条件：
   - CUDA环境可用时自动启用GPU加速
   - 注：本实验CPU计算耗时可控，非必须使用GPU



"""
#新建扰动强度列表，从0开始到0.3，步长为0.05 ，epsilon = 0 表示无扰动（原始图像），值越大表示添加的扰动越强。这些值将用于测试模型在不同扰动强度下的表现。
epsilons = [0, .05, .1, .15, .2, .25, .3]
#指定预训练模型的路径
pretrained_model = "data/lenet_mnist_model.pth"
#是否使用GPU加速，True 表示如果有 GPU 可用就使用 GPU，使用 GPU 可以加快模型的计算速度，如果没有 GPU，代码会自动回退到 CPU
use_cuda=True

"""受攻击模型配置
~~~~~~~~~~~~~~~~~~

本实验的攻击对象为PyTorch官方MNIST示例项目实现的分类模型
（代码库见：<https://github.com/pytorch/examples/tree/master/mnist>）。使用者可选择以下任一方式获取模型：
1. **自主训练模式**  
   基于官方代码库重新训练并保存MNIST分类模型
   
2. **预训练模型调用**  
   直接加载本文提供的已训练模型文件

本模块完整复用了原始项目的以下核心组件：
- 网络结构定义（*Net* 类）
- 测试集数据加载器（Test Dataloader）


"""

# LeNet 模型定义 先定义与图像识别模型相同的模型结构 Net类定义了模型的"骨架"（网络结构），
# lenet_mnist_model.pth 文件提供了这个骨架上的"肌肉"（具体参数）
# 这个 Net 类实现的是 LeNet 卷积神经网络，
# 包含：
#- 2个卷积层（用于提取图像特征）
#- Dropout层（防止过拟合）
#- 2个全连接层（进行最终的分类）
#- 输出10个类别（对应0-9这10个数字）
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
        self.conv2_drop = nn.Dropout2d()
        self.fc1 = nn.Linear(320, 50)
        self.fc2 = nn.Linear(50, 10)

# 前向传播函数 定义数据在网络中的流动路径
    def forward(self, x):
        x = F.relu(F.max_pool2d(self.conv1(x), 2)) # 第一层：卷积->池化->ReLU激活
        x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2)) # 第二层：卷积->Dropout->池化->ReLU激活
        x = x.view(-1, 320)  # 将特征图展平
        x = F.relu(self.fc1(x)) # 第一个全连接层，接ReLU激活
        x = F.dropout(x, training=self.training) # Dropout层
        x = self.fc2(x) # 第二个全连接层
        return F.log_softmax(x, dim=1) # 输出层，使用log_softmax激活
"""
上面这个方法定义了数据从输入到输出的完整处理流程：

1. 输入的手写数字图像先经过两层卷积层提取特征
2. 然后将特征图展平成一维向量
3. 接着通过两个全连接层进行分类
4. 最后用 log_softmax 输出每个数字类别的概率
当我们调用 model(data) 时，实际上就是在调用这个 forward 方法。这是 PyTorch 的一个特性，它会自动调用 forward ，使代码更简洁。

"""

# MNIST数据集加载器，检查本地 ./data 目录是否已有数据集，如果没有，则从官方地址下载
test_loader = torch.utils.data.DataLoader(
    datasets.MNIST('./data', train=False, download=True, transform=transforms.Compose([
            transforms.ToTensor(),
            ])), 
        batch_size=1, shuffle=True)

# 定义我们使用的设备
print("CUDA Available: ",torch.cuda.is_available())
device = torch.device("cuda" if (use_cuda and torch.cuda.is_available()) else "cpu")

# 初始化网络
model = Net().to(device)

# 加载预训练模型
model.load_state_dict(torch.load(pretrained_model, map_location='cpu'))

# 将模型设置为评估模式
model.eval()

"""FGSM 攻击算法实现

本模块定义通过梯度扰动生成对抗样本的核心函数

"""

# FGSM 攻击代码
def fgsm_attack(image, epsilon, data_grad):
    # 收集数据梯度的元素符号
    sign_data_grad = data_grad.sign()
    # 通过调整输入图像的每个像素来创建扰动的图像
    perturbed_image = image + epsilon*sign_data_grad
    # 添加剪辑以维护[0,1]范围
    perturbed_image = torch.clamp(perturbed_image, 0, 1)
    # 返回扰动后的图像
    return perturbed_image

"""测试函数
~~~~~~~~~~~~~~~~

最后，本教程的核心结果来自于test函数。每次调用此测试函数都会在MNIST测试集上执行完整的测试步骤并报告最终准确率。
然而，请注意该函数还接受epsilon输入参数。这是因为test函数报告的是在强度为epsilon的攻击下模型的准确率。
具体来说，对于测试集中的每个样本，该函数计算损失相对于输入数据的梯度($data\_grad$)，使用fgsm_attack创建扰动图像($perturbed\_data$)，
然后检查扰动后的样本是否成为对抗样本。除了测试模型的准确率外，该函数还保存并返回一些成功的对抗样本，以便后续可视化。

"""

def test( model, device, test_loader, epsilon ):

    # 准确度计数器
    correct = 0
    adv_examples = []

    # 循环遍历测试集中所有案例
    for data, target in test_loader:

        # 向设备发送数据和标签
        data, target = data.to(device), target.to(device)

        # 设置张量的requires_grad属性，这对攻击非常重要
        data.requires_grad = True

        # 数据通过模型前向传播
        output = model(data)
        init_pred = output.max(1, keepdim=True)[1] # 获取最大对数概率的索引

        # 如果初始预测报错，无需攻击，直接跳过
        if init_pred.item() != target.item():
            continue

        # 计算损失
        loss = F.nll_loss(output, target)

        # 清零所有现有梯度
        model.zero_grad()

        # 在反向传播中计算模型的梯度
        loss.backward()

        # 收集数据梯度
        data_grad = data.grad.data

        # 调用FGSM攻击
        perturbed_data = fgsm_attack(data, epsilon, data_grad)

        # 重新分类扰动图像
        output = model(perturbed_data)

        # 检查攻击是否成功
        final_pred = output.max(1, keepdim=True)[1] # 获取最大对数概率的索引
        if final_pred.item() == target.item():
            correct += 1
            # 保存0扰动样本的特殊情况
            if (epsilon == 0) and (len(adv_examples) < 5):
                adv_ex = perturbed_data.squeeze().detach().cpu().numpy()
                adv_examples.append( (init_pred.item(), final_pred.item(), adv_ex) )
        else:
            # 保存一些对抗样本用于后续可视化
            if len(adv_examples) < 5:
                adv_ex = perturbed_data.squeeze().detach().cpu().numpy()
                adv_examples.append( (init_pred.item(), final_pred.item(), adv_ex) )

    # 计算此epsilon值的最终准确率
    final_acc = correct/float(len(test_loader))
    print("Epsilon: {}\tTest Accuracy = {} / {} = {}".format(epsilon, correct, len(test_loader), final_acc))

    # 返回准确率和对抗样本
    return final_acc, adv_examples

"""执行攻击
~~~~~~~~~~

代码实现的最后一部分是执行攻击。在这里，我们对*epsilons*输入中的每个epsilon值运行完整的测试步骤。
对于每个epsilon值，我们还保存最终的准确率和一些成功的对抗样本，以便在后续章节中进行绘图。
注意观察随着epsilon值的增加，打印的准确率如何下降。另外，请注意$\epsilon=0$的情况代表原始测试准确率，即无攻击状态。

"""

accuracies = []
examples = []

# 对每个epsilon运行测试
for eps in epsilons:
    acc, ex = test(model, device, test_loader, eps)
    accuracies.append(acc)
    examples.append(ex)

"""结果
-------

准确率 VS 扰动系数
~~~~~~~~~~~~~~~~~~~

第一个结果是准确率与epsilon(扰动系数)的关系图。如前所述，随着epsilon的增加，我们预期测试准确率会下降。
这是因为较大的epsilon意味着我们在最大化损失的方向上迈出更大的步伐。注意曲线趋势并非线性，尽管epsilon值是线性间隔的。
例如，epsilon=0.05时的准确率仅比epsilon=0低约4%，但epsilon=0.2时的准确率比epsilon=0.15低25%。
此外，注意模型的准确率在epsilon=0.25和epsilon=0.3之间达到了10类分类器的随机准确率水平。

"""

plt.figure(figsize=(5,5))
plt.plot(epsilons, accuracies, "*-")
plt.yticks(np.arange(0, 1.1, step=0.1))
plt.xticks(np.arange(0, .35, step=0.05))
plt.title("Accuracy vs Epsilon")
plt.xlabel("Epsilon")
plt.ylabel("Accuracy")
plt.show()

"""对抗样本示例
~~~~~~~~~~~~~~~~~~~~~~~~~~~

世上没有免费的午餐。在本例中，随着epsilon的增加，测试准确率下降，但扰动变得更容易被感知。
实际上，攻击者必须考虑准确率下降与可感知性之间的权衡。在这里，我们展示了每个epsilon值下成功对抗样本的一些示例。
图的每一行显示不同的epsilon值。第一行是epsilon=0的示例，代表无扰动的原始"干净"图像。
每个图像的标题显示了"原始分类 -> 对抗分类"。注意，在epsilon=0.15时扰动开始变得明显，在epsilon=0.3时非常明显。
然而，在所有情况下，尽管有噪声添加，人类仍然能够识别正确的类别。

"""

# 绘制几个在epsilon值下对抗样本示例
cnt = 0
plt.figure(figsize=(8,10))
for i in range(len(epsilons)):
    for j in range(len(examples[i])):
        cnt += 1
        plt.subplot(len(epsilons),len(examples[0]),cnt)
        plt.xticks([], [])
        plt.yticks([], [])
        if j == 0:
            plt.ylabel("Eps: {}".format(epsilons[i]), fontsize=14)
        orig,adv,ex = examples[i][j]
        plt.title("{} -> {}".format(orig, adv))
        plt.imshow(ex, cmap="gray")
plt.tight_layout()
plt.show()

实战案例效果

说明：

代码来自于https://pytorch.org/tutorials/beginner/fgsm_tutorial.html,

应在github：https://github.com/pytorch/tutorials/blob/master/beginner_source/fgsm_tutorial.py

基本使用说明：

安装依赖项。

pip3 install numpy torch torchvision matplotlib

执行FGSM算法对图像识别进行攻击，请保证您的电脑可以联网，代码会自动下载mnist数据集。

python fgsm_tutorial.py