Python对抗性攻击实现：FGSM/PGD算法与防御策略
大家好！今天我们来深入探讨一个机器学习安全领域的重要课题：对抗性攻击。具体来说，我们将专注于两种常见的攻击方法：快速梯度符号法 (FGSM) 和投影梯度下降法 (PGD)，并探讨一些防御策略。我们将使用 Python 和 PyTorch 框架进行演示。
什么是对抗性攻击？
简单来说，对抗性攻击是指通过对输入样本进行微小的、人眼难以察觉的扰动，使得机器学习模型产生错误的预测。这些扰动后的样本被称为对抗样本。对抗性攻击揭示了机器学习模型的脆弱性，并对模型的可靠性和安全性提出了挑战。
一、快速梯度符号法 (FGSM)
FGSM 是一种简单而有效的对抗性攻击方法，由 Goodfellow 等人于 2014 年提出。它的核心思想是沿着损失函数梯度方向添加扰动。
1.1 FGSM 原理
给定一个模型 f(x)，输入样本 x，真实标签 y，损失函数 J(θ, x, y) (其中 θ 表示模型的参数)。FGSM 的目标是找到一个对抗样本 x’ = x + η，使得 f(x’) ≠ y，且 ||η|| 尽可能小。
FGSM 的扰动 η 计算公式如下：
η = ε * sign(∇x J(θ, x, y))
其中：
- ε 是扰动的大小，控制对抗样本与原始样本的相似度。
- sign(∇x J(θ, x, y)) 是损失函数关于输入 x 的梯度的符号。
1.2 FGSM 的 Python 实现 (PyTorch)
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
# 定义一个简单的 CNN 模型
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.dropout = nn.Dropout2d()
self.fc1 = nn.Linear(320, 50)
self.fc2 = nn.Linear(50, 10)
def forward(self, x):
x = torch.relu(torch.max_pool2d(self.conv1(x), 2))
x = torch.relu(torch.max_pool2d(self.dropout(self.conv2(x), 2)))
x = x.view(-1, 320)
x = torch.relu(self.fc1(x))
x = self.fc2(x)
return nn.functional.log_softmax(x, dim=1)
# 加载 MNIST 数据集
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
train_dataset = datasets.MNIST('./data', train=True, download=True, transform=transform)
test_dataset = datasets.MNIST('./data', train=False, download=True, transform=transform)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=1000, shuffle=False)
# 初始化模型和优化器
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.01)
loss_fn = nn.CrossEntropyLoss()
# 训练模型 (简化版，只训练几个 epoch)
def train(model, device, train_loader, optimizer, epoch):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
data, target = data.to(device), target.to(device)
optimizer.zero_grad()
output = model(data)
loss = loss_fn(output, target)
loss.backward()
optimizer.step()
if batch_idx % 100 == 0:
print('Train Epoch: {} [{}/{} ({:.0f}%)]tLoss: {:.6f}'.format(
epoch, batch_idx * len(data), len(train_loader.dataset),
100. * batch_idx / len(train_loader), loss.item()))
# 测试模型
def test(model, device, test_loader):
model.eval()
test_loss = 0
correct = 0
with torch.no_grad():
for data, target in test_loader:
data, target = data.to(device), target.to(device)
output = model(data)
test_loss += loss_fn(output, target).item()
pred = output.argmax(dim=1, keepdim=True)
correct += pred.eq(target.view_as(pred)).sum().item()
test_loss /= len(test_loader.dataset)
print('nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)n'.format(
test_loss, correct, len(test_loader.dataset),
100. * correct / len(test_loader.dataset)))
# 使用 CUDA (如果可用)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
# 训练模型 2 个 epoch
for epoch in range(1, 3):
train(model, device, train_loader, optimizer, epoch)
test(model, device, test_loader)
# FGSM 攻击函数
def fgsm_attack(model, loss, images, labels, eps):
images.requires_grad = True
outputs = model(images)
model.zero_grad()
cost = loss(outputs, labels).to(device)
cost.backward()
attack_images = images + eps * images.grad.sign()
attack_images = torch.clamp(attack_images, 0, 1) # 将像素值限制在 [0, 1] 范围内
return attack_images
# 测试 FGSM 攻击效果
def test_fgsm(model, device, test_loader, eps):
model.eval()
correct = 0
adv_examples = []
with torch.no_grad():
for data, target in test_loader:
data, target = data.to(device), target.to(device)
output = model(data)
init_pred = output.max(1, keepdim=True)[1]
correct += init_pred.eq(target.view_as(init_pred)).sum().item()
# 生成对抗样本
attack_images = fgsm_attack(model, loss_fn, data, target, eps)
adv_output = model(attack_images)
adv_pred = adv_output.max(1, keepdim=True)[1]
# 记录攻击成功的样本
for i in range(len(data)):
if init_pred[i] == target[i] and adv_pred[i] != target[i]:
adv_ex = attack_images[i].squeeze().detach().cpu().numpy()
adv_examples.append( (init_pred[i].item(), adv_pred[i].item(), adv_ex) )
final_acc = correct/float(len(test_loader.dataset))
print("Epsilon: {}tTest Accuracy = {} / {} = {}".format(eps, correct, len(test_loader.dataset), final_acc))
return adv_examples
# 设置扰动大小
epsilons = [0, .05, .1, .15, .2, .25, .3]
# 测试不同扰动大小的 FGSM 攻击效果
for eps in epsilons:
examples = test_fgsm(model, device, test_loader, eps)
# 可以进一步分析 examples 列表中的对抗样本
# 例如，可视化对抗样本和原始样本的差异1.3 FGSM 的优缺点
- 优点： 简单易实现，计算速度快。
- 缺点： 容易被防御，鲁棒性较差。单步攻击，可能不是最优解。
二、投影梯度下降法 (PGD)
PGD 是 FGSM 的一种迭代版本，它通过多次迭代来寻找更有效的对抗样本。
2.1 PGD 原理
PGD 与 FGSM 的主要区别在于，PGD 在每次迭代中都会沿着梯度方向更新扰动，并将扰动限制在一个规定的范围内，通常是一个 L∞ 球。
PGD 的迭代过程如下：
- 初始化扰动 η0。
- 对于 t = 1, 2, …, T：
- 计算梯度：∇x J(θ, x + ηt-1, y)。
- 更新扰动：ηt = ηt-1 + α * sign(∇x J(θ, x + ηt-1, y))。
- 投影：ηt = clip(ηt, -ε, ε)。 (将扰动限制在 [-ε, ε] 范围内)
其中：
- T 是迭代次数。
- α 是步长，控制每次迭代的扰动大小。
- clip 函数将扰动限制在 [-ε, ε] 范围内，保证对抗样本与原始样本的相似度。
2.2 PGD 的 Python 实现 (PyTorch)
# PGD 攻击函数
def pgd_attack(model, loss, images, labels, eps, alpha, iters):
attack_images = images.detach().clone()
attack_images.requires_grad = True
for i in range(iters):
outputs = model(attack_images)
model.zero_grad()
cost = loss(outputs, labels).to(device)
cost.backward()
attack_images.data = attack_images.data + alpha * attack_images.grad.sign()
eta = torch.clamp(attack_images.data - images.data, min=-eps, max=eps)
attack_images.data = torch.clamp(images.data + eta, min=0, max=1) # 确保像素值在 [0, 1] 范围内
attack_images.grad.zero_() # 清空梯度
return attack_images
# 测试 PGD 攻击效果
def test_pgd(model, device, test_loader, eps, alpha, iters):
model.eval()
correct = 0
adv_examples = []
with torch.no_grad():
for data, target in test_loader:
data, target = data.to(device), target.to(device)
output = model(data)
init_pred = output.max(1, keepdim=True)[1]
correct += init_pred.eq(target.view_as(init_pred)).sum().item()
# 生成对抗样本
attack_images = pgd_attack(model, loss_fn, data, target, eps, alpha, iters)
adv_output = model(attack_images)
adv_pred = adv_output.max(1, keepdim=True)[1]
# 记录攻击成功的样本
for i in range(len(data)):
if init_pred[i] == target[i] and adv_pred[i] != target[i]:
adv_ex = attack_images[i].squeeze().detach().cpu().numpy()
adv_examples.append( (init_pred[i].item(), adv_pred[i].item(), adv_ex) )
final_acc = correct/float(len(test_loader.dataset))
print("Epsilon: {}, Alpha: {}, Iterations: {}tTest Accuracy = {} / {} = {}".format(eps, alpha, iters, correct, len(test_loader.dataset), final_acc))
return adv_examples
# 设置攻击参数
epsilons = [0.3] # 扰动大小
alphas = [2/255] # 步长
iters = [40] # 迭代次数
# 测试不同参数的 PGD 攻击效果
for eps in epsilons:
for alpha in alphas:
for iter in iters:
examples = test_pgd(model, device, test_loader, eps, alpha, iter)
# 可以进一步分析 examples 列表中的对抗样本
# 例如，可视化对抗样本和原始样本的差异2.3 PGD 的优缺点
- 优点： 比 FGSM 更强大，更难防御。迭代优化，更接近最优解。
- 缺点： 计算成本更高，速度较慢。
三、防御策略
对抗性攻击的存在对机器学习模型的安全性提出了严峻挑战。为了提高模型的鲁棒性，研究人员提出了各种防御策略。以下是一些常见的防御策略：
| 防御策略 | 描述 | 优点 | 缺点 |
|---|---|---|---|
| 对抗训练 | 使用对抗样本训练模型，让模型学会识别和抵抗对抗性扰动。 | 提高模型对对抗样本的鲁棒性。 | 需要生成大量的对抗样本，训练成本高。可能导致模型在干净样本上的性能下降（鲁棒性-准确率权衡）。 可能对某些特定类型的攻击有效，但对其他类型的攻击无效。 |
| 防御蒸馏 | 使用一个经过对抗训练的“教师模型”来生成“软标签”，然后使用这些软标签来训练一个“学生模型”。 | 提高模型对对抗样本的鲁棒性，同时减少过拟合。 | 仍然可能被更强大的攻击所攻破。 |
| 输入预处理 | 在将输入样本输入模型之前，对其进行预处理，例如图像平滑、图像压缩或随机噪声注入。 | 可以有效地去除对抗性扰动，提高模型的鲁棒性。 | 可能降低模型在干净样本上的性能。某些预处理方法可能被绕过。 |
| 梯度掩码 | 尝试隐藏或平滑梯度，使得攻击者难以利用梯度信息生成有效的对抗样本。例如，使用梯度裁剪、梯度正则化或随机化梯度。 | 可以有效地干扰攻击者的梯度估计，提高模型的鲁棒性。 | 可能导致模型训练困难。某些梯度掩码方法可能被绕过。 |
| 检测对抗样本 | 训练一个额外的模型来检测输入样本是否为对抗样本。 如果检测到对抗样本，则拒绝该样本或采取其他措施。 | 可以有效地识别对抗样本，防止模型受到攻击。 | 检测器本身也可能被攻击。 需要维护和更新检测器，以应对新的攻击方法。 |
| 认证鲁棒性 (Certified Robustness) | 目标是提供数学上的保证，证明模型在一定范围内的扰动下，仍然能够做出正确的预测。 这通常涉及到对模型的 Lipschitz 常数进行约束，并使用 interval bound propagation 或 abstract interpretation 等技术进行分析。 | 提供了对模型鲁棒性的正式保证。 | 计算成本高昂，通常只能应用于小型模型。 对扰动范围的限制较为保守，可能导致模型在实际应用中的鲁棒性低于理论保证。 |
3.1 对抗训练的 Python 实现 (PyTorch)
# 对抗训练函数
def adversarial_train(model, device, train_loader, optimizer, epoch, eps, alpha, iters):
model.train()
for batch_idx, (data, target) in enumerate(train_loader):
data, target = data.to(device), target.to(device)
# 生成对抗样本
attack_images = pgd_attack(model, loss_fn, data, target, eps, alpha, iters)
optimizer.zero_grad()
# 使用原始样本和对抗样本进行训练
output = model(data)
adv_output = model(attack_images)
# 计算原始样本和对抗样本的损失
loss = loss_fn(output, target)
adv_loss = loss_fn(adv_output, target)
# 将两个损失加权求和
total_loss = loss + adv_loss
total_loss.backward()
optimizer.step()
if batch_idx % 100 == 0:
print('Train Epoch: {} [{}/{} ({:.0f}%)]tLoss: {:.6f}'.format(
epoch, batch_idx * len(data), len(train_loader.dataset),
100. * batch_idx / len(train_loader), total_loss.item()))
# 使用对抗训练训练模型
epochs = 5 # 增加训练轮数
eps = 0.3
alpha = 2/255
iters = 40
optimizer = optim.Adam(model.parameters(), lr=0.001) # 降低学习率
for epoch in range(1, epochs + 1):
adversarial_train(model, device, train_loader, optimizer, epoch, eps, alpha, iters)
test(model, device, test_loader) # 在干净数据上测试
test_pgd(model, device, test_loader, eps, alpha, iters) # 在对抗样本上测试3.2 其他防御策略的实现
- 防御蒸馏的实现相对复杂，需要训练两个模型。
- 输入预处理可以使用 PyTorch 的
transforms模块实现。 - 梯度掩码可以使用 PyTorch 的梯度裁剪功能实现。
- 对抗样本检测可以使用机器学习算法，例如支持向量机 (SVM) 或神经网络。
四、总结一下
我们讨论了对抗性攻击的概念，重点介绍了 FGSM 和 PGD 两种攻击算法，并通过 Python 代码进行了演示。我们还探讨了一些常见的防御策略，包括对抗训练。
对抗性攻击是一个活跃的研究领域，新的攻击方法和防御策略不断涌现。理解对抗性攻击的原理和实现方法，对于提高机器学习模型的安全性和可靠性至关重要。希望这次的分享能帮助大家更好地理解和应对对抗性攻击的挑战。
未来研究方向
- 自适应攻击 (Adaptive Attacks): 攻击者根据防御策略的特性，设计专门的攻击方法来绕过防御。
- 黑盒攻击 (Black-box Attacks): 攻击者无法访问模型的内部参数或梯度信息，只能通过查询模型来生成对抗样本。
- 可迁移性 (Transferability): 在一个模型上生成的对抗样本，可以成功攻击另一个模型。
更多IT精英技术系列讲座，到智猿学院