AI模型安全与隐私保护：从对抗攻击到差分隐私的实战指南

发布时间：2026/7/6 23:51:59

1. 项目概述：当AI模型成为资产，安全与隐私不再是附加题

最近几年，AI模型，尤其是大语言模型和各类生成式AI，已经从实验室的“玩具”变成了企业核心的“资产”。我们团队在交付一个金融风控模型时，客户问的第一个问题不是“准确率多少？”，而是“我们的数据安全吗？模型会被攻击吗？”。这让我意识到，AI模型的安全与隐私保护，已经从学术界的“选修课”，变成了工业界落地的“必修课”。它不再是模型训练好之后，由安全团队来“加固”的一道工序，而是需要从模型设计、数据准备、训练、部署到运维的全生命周期都融入的核心考量。

简单来说，AI模型安全关注的是模型本身的健壮性和可靠性，防止它被“欺骗”或“破坏”。比如，一张人眼看起来完全正常的“熊猫”图片，经过精心设计的微小扰动，就可能让一个图像分类模型自信地将其识别为“长臂猿”，这就是典型的对抗攻击。而隐私保护，则关注的是在模型开发和使用的过程中，如何确保训练数据中的敏感信息不被泄露。一个经典的案例是，攻击者通过反复查询一个训练好的模型，甚至能“反推”出某条特定的训练数据，比如某位用户的病历记录。

因此，这个项目标题“AI模型安全与隐私保护原理与代码实战案例讲解”，其核心就是拆解这两大核心挑战背后的技术原理，并通过可运行的代码，让你亲手体验攻击是如何发生的，以及防御是如何构建的。无论你是算法工程师、后端开发，还是对AI应用安全感兴趣的安全研究员，理解这些内容都能让你构建的AI系统更可靠、更值得信赖。

2. 核心威胁模型：你的AI模型面临哪些“敌人”？

在构建防御之前，我们必须先了解攻击者可能从哪些角度发起攻击。这就像设计一座城堡，得先知道敌人会用云梯、挖地道还是用投石机。在AI安全领域，我们通常从三个维度来构建威胁模型：机密性、完整性和可用性，也就是安全领域的CIA三元组在AI场景下的具体体现。

2.1 隐私泄露攻击：模型成了“告密者”

这类攻击的目标是破坏数据的机密性。攻击者试图从模型本身或其对外的API中，窃取训练数据的敏感信息。

2.1.1 成员推理攻击这是最常见的一种。攻击者想知道：“某条特定的数据记录（例如，张三的医疗数据）是否被用于训练了这个模型？” 攻击的基本原理是，模型对于训练过的数据（成员）和没训练过的数据（非成员），其行为通常有细微差别，比如对成员数据的预测置信度可能更高、损失函数值可能更低。攻击者可以训练一个二分类的“影子模型”来学习这种差别，从而判断目标数据是否为成员。

2.1.2 模型逆向攻击这比成员推理更进了一步。攻击者试图从模型中“重构”出原始训练数据的特征，甚至完整样本。例如，在图像生成模型中，通过反复优化输入，让模型生成与某张训练图片高度相似的输出，从而泄露隐私。

2.1.3 属性推理攻击攻击者不关心具体某条数据，而是想推断出训练数据集的整体统计属性。例如，通过查询一个基于某地区用户数据训练的信用评分模型，推断出该地区用户的平均收入水平或消费习惯。

注意：很多人误以为把训练数据从服务器上删除就安全了。但实际上，模型参数本身已经“记忆”了数据中的模式和关联。一个过参数化的大型模型，其记忆能力非常强，隐私泄露的风险也随之增高。

2.2 对抗攻击：给模型戴上“哈哈镜”

这类攻击的目标是破坏模型的完整性。攻击者通过精心构造的、人眼难以察觉的扰动，让模型做出完全错误的预测。

2.2.1 白盒攻击攻击者拥有模型的全部信息，包括架构、参数、训练算法等。这为攻击提供了最大的便利。最著名的算法是FGSM和PGD。

FGSM：快速梯度符号法。它利用模型损失函数相对于输入数据的梯度方向，一次性添加一个小的扰动，使损失增大，从而导致误分类。计算高效，但攻击成功率相对较低。
PGD：投影梯度下降法。可以看作是FGSM的迭代版本。它在多个小步中反复应用FGSM的思想，并在每一步后将扰动投影回一个允许的扰动范围内（如ε-ball）。PGD是目前最强的白盒攻击方法之一，常被用作评估模型鲁棒性的基准。

2.2.2 黑盒攻击攻击者只能通过向模型API发送输入并接收输出来与模型交互，对模型内部一无所知。这更贴近现实攻击场景。

基于迁移的攻击：攻击者训练一个自己的替代模型，试图模仿目标模型的行为。然后对这个替代模型进行白盒攻击，生成的对抗样本有很大概率也能欺骗目标模型。
基于查询的攻击：通过大量查询来估计模型的决策边界或梯度，例如使用有限差分法来近似梯度，然后构造对抗样本。

2.2.3 物理世界攻击将数字世界生成的对抗样本应用到物理物体上。例如，打印出带有对抗性扰动的贴纸贴在眼镜上，就能欺骗人脸识别系统；或者在路牌上粘贴特定图案，导致自动驾驶汽车的视觉系统错误识别。这类攻击证明了对抗威胁的现实性。

2.3 模型窃取与投毒攻击

2.3.1 模型窃取攻击者目标是通过查询输入-输出对，尽可能完整地复刻出一个功能近似的模型副本。这对于提供模型API服务的公司是重大威胁，因为其核心知识产权（模型）可能被低成本窃取。

2.3.2 数据投毒攻击在模型训练阶段，攻击者向训练数据中注入恶意样本。这分为两类：

后门攻击：注入的样本带有特定“触发器”（如图像角落的一个特定图案）和一个错误的标签。模型训练后，对于正常样本表现良好，但对于包含触发器的样本，则会输出攻击者预设的恶意标签。模型就像被安装了“后门”。
降低性能攻击：单纯地注入噪声或错误标签数据，旨在降低模型整体的准确率和可靠性。

3. 隐私保护核心技术：从理论到代码

理解了威胁，我们来看防御。隐私保护的核心是在不显著牺牲模型效用的情况下，为数据或模型增加“噪音”，使得攻击者无法从输出中精确推断出个体信息。

3.1 差分隐私：隐私保护的“黄金标准”

差分隐私提供了一个严格的、可量化的隐私保障。它的核心思想是：查询单个数据集中某条特定记录是否存在，所得到的答案概率分布，与查询缺少这条记录的另一个数据集所得到的答案概率分布，非常接近。这个“接近”的程度由参数ε（epsilon）控制，ε越小，隐私保护越强，但通常数据效用（模型精度）也会越低。

3.1.1 拉普拉斯机制与代码实战拉普拉斯机制适用于数值型查询的输出。它通过在查询结果上添加服从拉普拉斯分布的噪声来实现差分隐私。噪声的尺度Δf/ε，其中Δf是查询的敏感度（改变一条记录，查询结果的最大可能变化）。

让我们通过一个简单的例子，计算一个数据集的平均年龄并应用DP保护。

import numpy as np def calculate_average_age(ages): """计算平均年龄（非隐私版本）""" return np.mean(ages) def laplace_mechanism(query_result, sensitivity, epsilon): """ 拉普拉斯机制 :param query_result: 原始查询结果 :param sensitivity: 查询敏感度 Δf :param epsilon: 隐私预算 ε :return: 满足(ε,0)-DP的噪声结果 """ # 拉普拉斯分布的尺度参数 b = sensitivity / epsilon scale = sensitivity / epsilon # 从拉普拉斯分布中采样噪声 noise = np.random.laplace(loc=0.0, scale=scale) return query_result + noise # 模拟一个包含1000人年龄的数据集，年龄在18-65之间 np.random.seed(42) ages = np.random.randint(18, 66, size=1000) true_average = calculate_average_age(ages) print(f"真实平均年龄: {true_average:.2f}") # 假设我们查询的是 SUM(ages)，那么改变一条记录（最大年龄差65-18=47）会影响总和最多47。 # 但查询的是平均值，平均值的敏感度需要计算：改变一条记录，平均值最大变化是 (max_age - min_age) / n n = len(ages) max_age, min_age = 65, 18 sensitivity_avg = (max_age - min_age) / n # 这是平均值查询的敏感度 print(f"平均值查询的敏感度 Δf: {sensitivity_avg:.4f}") # 设置隐私预算 epsilon epsilon = 1.0 # 应用拉普拉斯机制 dp_average = laplace_mechanism(true_average, sensitivity_avg, epsilon) print(f"满足 ε={epsilon}-DP 的平均年龄: {dp_average:.2f}") print(f"绝对误差: {abs(dp_average - true_average):.2f}") # 多次运行观察噪声影响 print("\n--- 多次运行模拟（epsilon=1.0）---") for i in range(5): dp_avg_run = laplace_mechanism(true_average, sensitivity_avg, epsilon) print(f"运行 {i+1}: {dp_avg_run:.2f} (误差: {abs(dp_avg_run - true_average):.2f})")

代码解读与实操要点：

敏感度计算是关键：错误估计敏感度Δf会导致隐私保障失效。对于平均值查询，其全局敏感度是(数据最大值-数据最小值)/数据量n。对于求和查询，则是(数据最大值-数据最小值)。必须根据具体查询函数准确计算。
隐私预算ε是消耗品：整个分析过程（例如训练一个模型）的隐私预算是所有步骤ε的总和。需要谨慎规划预算分配。通常，ε在0.1到10之间，越小越隐私，但数据可用性越差。
拉普拉斯噪声特点：添加的噪声可能使结果变得不寻常（如平均年龄出现小数），这是为了隐私必须付出的代价。

3.2 差分隐私随机梯度下降

在机器学习中，最常用的DP算法是DP-SGD。它在标准的SGD优化步骤中加入了两个关键操作：梯度裁剪和添加高斯噪声。

3.2.1 DP-SGD 原理步骤

小批量采样：随机采样一个小批量（Batch）数据。
计算梯度：计算该小批量中每个样本的损失梯度。
梯度裁剪：将每个样本的梯度向量裁剪到某个最大范数C。这是为了限制单个样本对整体更新的影响，从而约束敏感度。
添加噪声：计算裁剪后梯度的平均值，然后向这个平均梯度中添加高斯噪声。噪声的方差与(C * σ)相关，其中σ是噪声乘子，与ε、δ（一个小的松弛概率）和训练轮数等有关。
参数更新：使用加噪后的梯度更新模型参数。

3.2.2 使用Opacus库实战DP-SGDPyTorch的Opacus库让实现DP-SGD变得非常简单。下面我们以在CIFAR-10上训练一个简单CNN为例。

import torch import torch.nn as nn import torch.optim as optim import torchvision import torchvision.transforms as transforms from opacus import PrivacyEngine import warnings warnings.filterwarnings('ignore') # 1. 数据准备 transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform) trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True, num_workers=2) testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform) testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False, num_workers=2) # 2. 定义一个简单的CNN模型 class SimpleCNN(nn.Module): def __init__(self): super(SimpleCNN, self).__init__() self.conv1 = nn.Conv2d(3, 6, 5) self.pool = nn.MaxPool2d(2, 2) self.conv2 = nn.Conv2d(6, 16, 5) self.fc1 = nn.Linear(16 * 5 * 5, 120) self.fc2 = nn.Linear(120, 84) self.fc3 = nn.Linear(84, 10) def forward(self, x): x = self.pool(torch.relu(self.conv1(x))) x = self.pool(torch.relu(self.conv2(x))) x = x.view(-1, 16 * 5 * 5) x = torch.relu(self.fc1(x)) x = torch.relu(self.fc2(x)) x = self.fc3(x) return x device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") model = SimpleCNN().to(device) criterion = nn.CrossEntropyLoss() # 3. 关键区别：使用Opacus的PrivacyEngine包装优化器 optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9) privacy_engine = PrivacyEngine() # 定义DP参数 MAX_GRAD_NORM = 1.0 # 梯度裁剪的最大范数 C EPSILON = 3.0 # 目标隐私预算 ε DELTA = 1e-5 # 松弛参数 δ，通常设置为小于 1/训练集大小 model, optimizer, trainloader = privacy_engine.make_private( module=model, optimizer=optimizer, data_loader=trainloader, noise_multiplier=1.1, # 噪声乘子 σ，与ε、δ、epoch数相关，可通过计算得到 max_grad_norm=MAX_GRAD_NORM, ) # 4. 训练循环（与普通训练几乎一样，但梯度是自动裁剪和加噪的） def train_dp(model, trainloader, optimizer, criterion, epoch): model.train() running_loss = 0.0 for i, (inputs, labels) in enumerate(trainloader, 0): inputs, labels = inputs.to(device), labels.to(device) optimizer.zero_grad() outputs = model(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() # 这一步包含了DP-SGD的裁剪和加噪操作 running_loss += loss.item() if i % 200 == 199: print(f'[Epoch {epoch + 1}, Batch {i + 1}] loss: {running_loss / 200:.3f}') running_loss = 0.0 def test(model, testloader): model.eval() correct = 0 total = 0 with torch.no_grad(): for (images, labels) in testloader: images, labels = images.to(device), labels.to(device) outputs = model(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() accuracy = 100 * correct / total print(f'Test Accuracy: {accuracy:.2f}%') return accuracy # 训练几轮 for epoch in range(5): train_dp(model, trainloader, optimizer, criterion, epoch) test_acc = test(model, testloader) # 获取当前隐私消耗 epsilon_spent = privacy_engine.get_epsilon(delta=DELTA) print(f'当前隐私消耗: (ε = {epsilon_spent:.2f}, δ = {DELTA})\n') print(f'最终隐私消耗: (ε = {privacy_engine.get_epsilon(delta=DELTA):.2f}, δ = {DELTA})')

实操心得与避坑指南：

超参数选择：max_grad_norm (C)和noise_multiplier (σ)是平衡隐私、效用和训练稳定性的关键。C太小会限制模型学习能力，太大会增加噪声尺度。σ直接控制噪声大小。通常需要大量实验来调优。
隐私预算计算：Opacus会在背后使用矩会计法自动计算隐私消耗。务必在训练开始前设定目标ε和δ。训练过程中，实际消耗的ε会逐渐增加，直到达到目标值。如果训练轮数太多，可能会提前耗尽预算。
性能下降预期：DP训练几乎总是会导致模型最终准确率下降，这是用性能换取隐私的必然结果。下降幅度取决于数据集难度、模型复杂度以及隐私预算ε。对于CIFAR-10，在ε=3.0时，准确率可能比非DP训练低几个到十几个百分点。
批处理与数据加载器：DP-SGD对数据加载器有严格要求。必须使用PoissonSampling（默认）或UniformSampling，并且drop_last=False，以确保隐私会计的正确性。Opacus的make_private方法已处理了这些。

3.3 联邦学习：数据不动模型动

联邦学习是一种分布式机器学习框架，其核心思想是：多个客户端（如手机、医院）在本地用自己的数据训练模型，只将模型更新（如梯度）上传到中央服务器进行聚合，从而生成全局模型。原始数据始终保留在本地。

3.3.1 联邦平均算法最经典的算法是FedAvg。服务器初始化一个全局模型，分发给客户端。各客户端用本地数据训练模型若干轮，然后将更新后的模型参数发回服务器。服务器对所有客户端参数进行加权平均，得到新的全局模型，如此迭代。

3.3.2 隐私增强的联邦学习单纯的联邦学习并不能完全防止隐私泄露，因为上传的梯度仍可能包含信息。通常需要结合DP或安全多方计算。

DP-FL：在客户端本地训练时使用DP-SGD，或将DP噪声添加到客户端上传的模型更新上。
安全聚合：利用密码学技术，使得服务器只能看到聚合后的结果，而无法看到单个客户端的更新。

3.3.3 使用Flower框架模拟联邦学习Flower是一个友好的联邦学习框架。下面模拟一个最简单的FedAvg场景，两个客户端拥有不同的数据分布。

# 文件：server.py import flwr as fl import torch from collections import OrderedDict # 定义一个简单的聚合策略（FedAvg） strategy = fl.server.strategy.FedAvg( fraction_fit=1.0, # 每轮参与训练的客户端比例 fraction_evaluate=1.0, # 每轮参与评估的客户端比例 min_fit_clients=2, min_evaluate_clients=2, min_available_clients=2, ) # 启动服务器 fl.server.start_server( server_address="0.0.0.0:8080", config=fl.server.ServerConfig(num_rounds=3), # 进行3轮联邦训练 strategy=strategy, )

# 文件：client.py import flwr as fl import torch import torch.nn as nn import torch.optim as optim from torchvision import datasets, transforms # 1. 加载本地数据（模拟客户端1拥有数字0-4，客户端2拥有数字5-9） transform = transforms.ToTensor() # 客户端1的数据 trainset1 = datasets.MNIST('./data', train=True, download=True, transform=transform) # 只取标签0-4 idx1 = trainset1.targets < 5 trainset1.data = trainset1.data[idx1] trainset1.targets = trainset1.targets[idx1] trainloader1 = torch.utils.data.DataLoader(trainset1, batch_size=32, shuffle=True) # 客户端2的数据 trainset2 = datasets.MNIST('./data', train=True, download=True, transform=transform) # 只取标签5-9 idx2 = trainset2.targets >= 5 trainset2.data = trainset2.data[idx2] trainset2.targets = trainset2.targets[idx2] trainloader2 = torch.utils.data.DataLoader(trainset2, batch_size=32, shuffle=True) # 2. 定义相同的模型 class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.fc = nn.Linear(28*28, 10) def forward(self, x): x = x.view(-1, 28*28) return self.fc(x) def train(model, trainloader, epochs=1): criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(), lr=0.01) model.train() for epoch in range(epochs): for images, labels in trainloader: optimizer.zero_grad() outputs = model(images) loss = criterion(outputs, labels) loss.backward() optimizer.step() return model.state_dict() # 3. 定义Flower客户端类 class MNISTClient(fl.client.NumPyClient): def __init__(self, trainloader): self.model = Net() self.trainloader = trainloader def get_parameters(self, config): return [val.cpu().numpy() for _, val in self.model.state_dict().items()] def set_parameters(self, parameters): params_dict = zip(self.model.state_dict().keys(), parameters) state_dict = OrderedDict({k: torch.tensor(v) for k, v in params_dict}) self.model.load_state_dict(state_dict, strict=True) def fit(self, parameters, config): self.set_parameters(parameters) train(self.model, self.trainloader, epochs=1) return self.get_parameters(config={}), len(self.trainloader.dataset), {} def evaluate(self, parameters, config): self.set_parameters(parameters) # 简单评估，实际中应在本地测试集上评估 loss, accuracy = 0.0, 0.0 return loss, len(self.trainloader.dataset), {"accuracy": accuracy} # 启动客户端（需要运行两个实例，分别使用trainloader1和trainloader2） # 实例1: python client.py --client_id 1 # 实例2: python client.py --client_id 2 if __name__ == "__main__": import sys client_id = int(sys.argv[1]) if len(sys.argv) > 1 else 1 trainloader = trainloader1 if client_id == 1 else trainloader2 fl.client.start_numpy_client(server_address="127.0.0.1:8080", client=MNISTClient(trainloader))

联邦学习部署注意事项：

通信成本：模型参数（尤其是大模型）的频繁上传下载会成为瓶颈。需要使用模型压缩、差分隐私量化等技术减少通信量。
系统异构性：客户端的算力、网络、数据量差异巨大。需要设计异步更新、容错机制和公平的客户端选择策略。
数据异构性（非独立同分布）：这是联邦学习最大的挑战。不同客户端的数据分布差异极大（如不同地区的用户偏好不同）。FedAvg在非独立同分布数据上可能收敛缓慢甚至发散。需要改进算法，如FedProx、SCAFFOLD等。
安全与隐私：如前所述，基础FedAvg不提供严格的隐私保证。必须与DP或安全聚合结合。同时还要防范恶意客户端发起的投毒攻击。

4. 模型安全加固实战：构建鲁棒的AI防线

说完了隐私，我们转向模型安全，核心目标是提升模型的鲁棒性，抵御对抗攻击。

4.1 对抗训练：以毒攻毒

对抗训练是目前最有效、最常用的提升模型鲁棒性的方法。其思想很简单：在训练过程中，主动生成对抗样本，并将其与干净样本混合在一起训练模型。这样，模型在学习正常分类的同时，也学会了识别和抵抗这些扰动。

4.1.1 PGD对抗训练实战我们使用Fashion-MNIST数据集，用PGD攻击生成对抗样本进行训练。

import torch import torch.nn as nn import torch.optim as optim import torchvision import torchvision.transforms as transforms import numpy as np device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # 数据加载 transform = transforms.ToTensor() trainset = torchvision.datasets.FashionMNIST(root='./data', train=True, download=True, transform=transform) trainloader = torch.utils.data.DataLoader(trainset, batch_size=128, shuffle=True) testset = torchvision.datasets.FashionMNIST(root='./data', train=False, download=True, transform=transform) testloader = torch.utils.data.DataLoader(testset, batch_size=128, shuffle=False) # 定义模型 class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.fc1 = nn.Linear(28*28, 256) self.fc2 = nn.Linear(256, 128) self.fc3 = nn.Linear(128, 10) self.relu = nn.ReLU() def forward(self, x): x = x.view(-1, 28*28) x = self.relu(self.fc1(x)) x = self.relu(self.fc2(x)) x = self.fc3(x) return x model = Net().to(device) criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=0.001) # PGD攻击函数 def pgd_attack(model, images, labels, eps=0.3, alpha=0.01, iters=40): """ 执行PGD攻击生成对抗样本 :param model: 目标模型 :param images: 原始干净图像 :param labels: 真实标签 :param eps: 扰动最大范数 (L∞) :param alpha: 单步攻击步长 :param iters: 攻击迭代次数 :return: 对抗样本 """ ori_images = images.data.clone().detach() # 备份原始图像 adv_images = images.clone().detach() # 初始时在[-eps, eps]范围内添加随机扰动 adv_images = adv_images + torch.empty_like(adv_images).uniform_(-eps, eps) adv_images = torch.clamp(adv_images, min=0, max=1) # 确保像素值在[0,1] for i in range(iters): adv_images.requires_grad = True outputs = model(adv_images) model.zero_grad() loss = criterion(outputs, labels) loss.backward() # 沿着梯度方向增加损失（符号梯度） adv_images = adv_images.detach() + alpha * adv_images.grad.sign() # 将扰动投影到 eps 球内 delta = torch.clamp(adv_images - ori_images, min=-eps, max=eps) adv_images = torch.clamp(ori_images + delta, min=0, max=1).detach() return adv_images # 对抗训练循环 def adversarial_train(model, trainloader, optimizer, criterion, epoch, eps=0.3, alpha=0.01, iters=10): model.train() running_loss = 0.0 for batch_idx, (images, labels) in enumerate(trainloader): images, labels = images.to(device), labels.to(device) # 生成对抗样本 adv_images = pgd_attack(model, images, labels, eps=eps, alpha=alpha, iters=iters) optimizer.zero_grad() # 同时用干净样本和对抗样本训练 clean_outputs = model(images) adv_outputs = model(adv_images) loss = 0.5 * criterion(clean_outputs, labels) + 0.5 * criterion(adv_outputs, labels) loss.backward() optimizer.step() running_loss += loss.item() if batch_idx % 100 == 99: print(f'Epoch [{epoch+1}], Batch [{batch_idx+1}], Loss: {running_loss/100:.4f}') running_loss = 0.0 # 评估函数（在干净和对抗样本上测试） def evaluate(model, testloader, attack_fn=None, eps=0.3): model.eval() correct_clean = 0 correct_adv = 0 total = 0 with torch.no_grad(): for images, labels in testloader: images, labels = images.to(device), labels.to(device) total += labels.size(0) # 干净样本准确率 outputs = model(images) _, predicted = torch.max(outputs.data, 1) correct_clean += (predicted == labels).sum().item() # 对抗样本准确率（如果提供了攻击函数） if attack_fn is not None: adv_images = attack_fn(model, images, labels, eps=eps) adv_outputs = model(adv_images) _, adv_predicted = torch.max(adv_outputs.data, 1) correct_adv += (adv_predicted == labels).sum().item() clean_acc = 100 * correct_clean / total print(f'Clean Test Accuracy: {clean_acc:.2f}%') if attack_fn is not None: adv_acc = 100 * correct_adv / total print(f'Adversarial Test Accuracy (ε={eps}): {adv_acc:.2f}%') return clean_acc # 训练前先评估一个普通模型 print("--- 训练前，普通模型在PGD攻击下的表现 ---") evaluate(model, testloader, attack_fn=pgd_attack, eps=0.3) # 进行对抗训练 num_epochs = 5 for epoch in range(num_epochs): print(f'\n--- Epoch {epoch+1} ---') adversarial_train(model, trainloader, optimizer, criterion, epoch, eps=0.3, alpha=0.01, iters=10) # 每轮结束后评估 evaluate(model, testloader, attack_fn=pgd_attack, eps=0.3) print("\n--- 对抗训练完成 ---")

对抗训练的经验与挑战：

计算成本高昂：每训练一个批次，都需要额外运行多次前向和反向传播来生成对抗样本，训练时间可能增加数倍甚至数十倍。
鲁棒性与准确性的权衡：对抗训练通常会降低模型在干净样本上的标准准确率，以换取对抗鲁棒性的提升。这是一个需要权衡的“稳健性-准确性”权衡。
攻击依赖性强：用PGD训练出的模型对PGD攻击鲁棒性最强，但对其他类型的攻击（如基于不同范数的攻击）可能仍然脆弱。理想情况是使用多种攻击方法进行训练。
超参数敏感：扰动大小eps、攻击步长alpha和迭代次数iters对最终模型的鲁棒性影响巨大。eps太小，对抗样本威胁不大；eps太大，样本可能失去语义信息，导致模型无法学习。

4.2 输入预处理与检测

除了改变训练过程，我们也可以在模型推理时增加防御层。

4.2.1 输入预处理防御在输入模型前，对数据进行变换以消除或减弱对抗扰动。

图像压缩/量化：将图像压缩为JPEG格式再解压，可以平滑掉高频的对抗噪声。
随机化：对输入图像进行随机裁剪、缩放或添加随机噪声。
去噪器：训练一个自动编码器或使用图像处理滤波器（如高斯模糊、中值滤波）来“净化”输入。
特征挤压：减少输入的特征维度，例如将图像从RGB转换为灰度图。

4.2.2 对抗样本检测不直接修复模型，而是训练一个二分类器来区分干净样本和对抗样本。

基于特征的方法：分析模型中间层的特征激活分布，对抗样本的激活模式可能与干净样本不同。
基于不一致性的方法：对输入施加多次随机变换，观察模型预测结果的方差。对抗样本的预测往往更不稳定。

注意：许多输入预处理和检测方法被发现存在“自适应攻击”的漏洞。一个知道防御机制的攻击者，可以针对性地调整攻击算法来绕过这些防御。因此，这些方法通常作为辅助手段，而非唯一依赖。

4.3 可解释性与模型监控

一个可解释的模型本身也是一种安全资产。当模型做出错误或意外的预测时，可解释性工具可以帮助我们定位原因，判断是否是受到了对抗攻击。

显著性图：如Grad-CAM、Integrated Gradients，可以可视化输入中哪些部分对模型的决策贡献最大。对抗样本的显著性图往往看起来杂乱无章，聚焦在无意义的背景噪声上。
预测置信度监控：对抗样本有时会导致模型产生低置信度的预测（尽管可能是错误的）。监控预测置信度的分布异常可以作为攻击的预警信号。
模型水印与指纹：为了保护模型知识产权，可以在模型中嵌入隐蔽的“水印”。例如，对于一组特定的“触发输入”，模型会输出预设的特定标签。这有助于在模型被窃取后验证所有权。