对抗样本与鲁棒性问题：安全视角下的攻防实战

安全风信子

发布于 2026-01-18 11:23:30

200

文章被收录于专栏：AI SPPECHAI SPPECH

作者：HOS(安全风信子) 日期：2026-01-09 来源平台：GitHub 摘要： 对抗样本是机器学习安全领域的核心问题，攻击者通过精心设计的微小扰动，可以使模型产生错误预测，甚至完全失效。本文从安全视角出发，深入探讨对抗样本的生成机制、鲁棒性评估方法和防御技术。通过分析最新的研究进展和工业实践，结合实际代码案例，展示如何构建鲁棒的机器学习系统，抵御对抗攻击。文章重点讨论了安全领域中对抗样本的特点、高级对抗攻击技术、自适应防御训练、鲁棒性评估框架以及对抗性机器学习在安全攻防中的应用，为读者提供了一套完整的安全机器学习对抗防御解决方案。

1. 背景动机与当前热点

1.1 为什么对抗样本是安全ML的核心威胁

在安全领域，对抗样本是一个严重的威胁。攻击者可以通过生成对抗样本，绕过机器学习模型的检测，实现各种恶意目标：

绕过入侵检测系统：生成对抗性网络流量，使入侵检测系统误判为正常流量。
逃避恶意软件检测：对恶意软件进行微小修改，使其被误判为正常软件。
操纵欺诈检测：生成对抗性交易数据，逃避欺诈检测系统的监控。
误导异常行为检测：生成对抗性行为序列，误导异常行为检测系统。

对抗样本的可怕之处在于，它们在人类看来与正常样本几乎无异，但却能成功欺骗机器学习模型。例如，在图像分类任务中，向一张猫的图片添加肉眼难以察觉的噪声，就能使模型将其误判为狗。

最新研究表明，几乎所有的深度学习模型都容易受到对抗样本的攻击，而防御对抗攻击的难度远大于生成对抗样本。在安全领域，模型被对抗样本欺骗可能导致严重的安全事件。

1.2 当前行业动态与技术趋势

当前，对抗样本与鲁棒性研究领域正呈现出以下几个重要趋势：

攻击技术不断演进：从简单的FGSM到复杂的自适应攻击，攻击能力越来越强。
防御方法多样化：从对抗训练到随机化防御，防御策略越来越丰富。
理论与实践结合：从理论上分析对抗样本的存在性和鲁棒性的边界。
自适应攻防对抗：攻击和防御相互促进，形成动态博弈。
多模态对抗攻击：针对多模态数据的对抗攻击成为研究热点。

1.3 安全领域对抗样本的特点

安全领域的对抗样本具有以下特点：

隐蔽性：对抗样本与正常样本差异微小，难以被人类或传统安全系统检测。
针对性：攻击者可以针对特定模型生成对抗样本，具有很强的针对性。
可迁移性：对抗样本可以在不同模型之间迁移，扩大攻击范围。
多样性：对抗样本的生成方法多样，包括白盒攻击和黑盒攻击。
动态性：攻击者可以不断调整攻击策略，适应防御措施。

2. 核心更新亮点与新要素

2.1 亮点1：高级对抗攻击技术

传统的对抗攻击技术如FGSM和PGD已经相对成熟，本文介绍最新的高级攻击技术，包括：

自适应攻击：根据模型的反馈动态调整攻击策略，提高攻击成功率。
黑盒攻击：在仅能访问模型输出的情况下，生成有效的对抗样本。
迁移攻击增强：通过集成多个模型或使用生成模型，提高对抗样本的迁移性。
物理世界攻击：生成在物理世界中有效的对抗样本，如对抗性图像、对抗性语音。

2.2 亮点2：新型防御方法

传统的防御方法如对抗训练存在计算成本高、鲁棒性提升有限等问题，本文介绍最新的防御方法，包括：

随机化防御：在模型推理过程中引入随机性，使攻击者难以生成有效的对抗样本。
认证防御：提供可证明的鲁棒性保证，确保模型在一定扰动范围内的正确性。
自监督鲁棒学习：利用自监督学习学习鲁棒的特征表示。
联邦鲁棒学习：在联邦学习场景下，提高模型的鲁棒性。

2.3 亮点3：自适应鲁棒性

传统的鲁棒性评估通常基于固定的扰动范围，本文介绍自适应鲁棒性概念，包括：

动态鲁棒性评估：根据数据的不同区域，动态调整扰动范围。
任务感知鲁棒性：根据任务的重要性，调整鲁棒性要求。
鲁棒性与性能的动态权衡：在不同场景下，动态调整鲁棒性和性能的权衡。

3. 技术深度拆解与实现分析

3.1 对抗样本生成机制

对抗样本的生成基于以下基本原理：机器学习模型在高维空间中通常是线性的，对输入的微小变化敏感。攻击者可以通过计算模型的梯度，找到使模型输出变化最大的方向，然后沿该方向添加微小扰动，生成对抗样本。

3.1.1 白盒攻击

白盒攻击是指攻击者可以访问模型的完整信息，包括模型结构、参数和梯度。常用的白盒攻击方法包括：

FGSM（Fast Gradient Sign Method）：快速生成对抗样本，计算简单。
PGD（Projected Gradient Descent）：迭代生成对抗样本，攻击能力强。
MIM（Momentum Iterative Method）：结合动量，提高攻击成功率和迁移性。
C&W攻击：基于优化的攻击方法，可以生成更隐蔽的对抗样本。

下面是FGSM和PGD攻击的实现示例：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
import numpy as np
import matplotlib.pyplot as plt

# 定义简单的CNN模型
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, 3, 1)
        self.conv2 = nn.Conv2d(32, 64, 3, 1)
        self.dropout1 = nn.Dropout(0.25)
        self.dropout2 = nn.Dropout(0.5)
        self.fc1 = nn.Linear(9216, 128)
        self.fc2 = nn.Linear(128, 10)
    
    def forward(self, x):
        x = self.conv1(x)
        x = nn.functional.relu(x)
        x = self.conv2(x)
        x = nn.functional.relu(x)
        x = nn.functional.max_pool2d(x, 2)
        x = self.dropout1(x)
        x = torch.flatten(x, 1)
        x = self.fc1(x)
        x = nn.functional.relu(x)
        x = self.dropout2(x)
        x = self.fc2(x)
        return x

# FGSM攻击实现
def fgsm_attack(model, images, labels, epsilon):
    """
    FGSM攻击实现
    model: 目标模型
    images: 原始图像
    labels: 原始标签
    epsilon: 扰动大小
    返回: 对抗样本
    """
    # 确保模型处于评估模式
    model.eval()
    
    # 将图像和标签转换为张量，并将图像设置为可求导
    images = images.clone().detach().requires_grad_(True)
    labels = labels.clone().detach()
    
    # 前向传播
    outputs = model(images)
    loss = nn.CrossEntropyLoss()(outputs, labels)
    
    # 反向传播，计算梯度
    model.zero_grad()
    loss.backward()
    
    # 获取图像梯度
    data_grad = images.grad.data
    
    # 计算扰动：梯度符号 * epsilon
    perturbation = epsilon * data_grad.sign()
    
    # 生成对抗样本
    adversarial_images = images + perturbation
    
    # 将图像裁剪到[0, 1]范围内
    adversarial_images = torch.clamp(adversarial_images, 0, 1)
    
    return adversarial_images

# PGD攻击实现
def pgd_attack(model, images, labels, epsilon, alpha=0.01, iterations=40):
    """
    PGD攻击实现
    model: 目标模型
    images: 原始图像
    labels: 原始标签
    epsilon: 扰动大小
    alpha: 每一步的扰动步长
    iterations: 迭代次数
    返回: 对抗样本
    """
    # 确保模型处于评估模式
    model.eval()
    
    # 将图像和标签转换为张量
    images = images.clone().detach()
    labels = labels.clone().detach()
    
    # 初始化对抗样本为原始图像
    adversarial_images = images.clone().detach().requires_grad_(True)
    
    for i in range(iterations):
        # 前向传播
        outputs = model(adversarial_images)
        loss = nn.CrossEntropyLoss()(outputs, labels)
        
        # 反向传播，计算梯度
        model.zero_grad()
        loss.backward()
        
        # 获取图像梯度
        data_grad = adversarial_images.grad.data
        
        # 计算扰动：梯度符号 * alpha
        perturbation = alpha * data_grad.sign()
        
        # 更新对抗样本
        adversarial_images = adversarial_images + perturbation
        
        # 裁剪扰动，确保整体扰动不超过epsilon
        delta = torch.clamp(adversarial_images - images, min=-epsilon, max=epsilon)
        adversarial_images = torch.clamp(images + delta, 0, 1).detach().requires_grad_(True)
    
    return adversarial_images

# 示例用法
if __name__ == "__main__":
    # 加载MNIST数据集
    transform = transforms.Compose([transforms.ToTensor()])
    test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)
    test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=1, shuffle=True)
    
    # 加载预训练模型（这里简化处理，实际应用中需要加载训练好的模型）
    model = SimpleCNN()
    # 假设模型已经训练好
    
    # 选择一个样本
    images, labels = next(iter(test_loader))
    
    print(f"原始图像标签: {labels.item()}")
    
    # FGSM攻击
    epsilon = 0.1
    fgsm_adversarial_images = fgsm_attack(model, images, labels, epsilon)
    
    # PGD攻击
    pgd_adversarial_images = pgd_attack(model, images, labels, epsilon)
    
    # 评估攻击效果
    model.eval()
    
    # 原始图像预测
    with torch.no_grad():
        original_outputs = model(images)
        original_pred = torch.argmax(original_outputs, dim=1)
        print(f"原始图像预测: {original_pred.item()}")
        
        # FGSM对抗样本预测
        fgsm_outputs = model(fgsm_adversarial_images)
        fgsm_pred = torch.argmax(fgsm_outputs, dim=1)
        print(f"FGSM对抗样本预测: {fgsm_pred.item()}")
        
        # PGD对抗样本预测
        pgd_outputs = model(pgd_adversarial_images)
        pgd_pred = torch.argmax(pgd_outputs, dim=1)
        print(f"PGD对抗样本预测: {pgd_pred.item()}")
    
    # 可视化结果
    import matplotlib.pyplot as plt
    
    # 将张量转换为numpy数组
    original_image = images.squeeze().detach().numpy()
    fgsm_image = fgsm_adversarial_images.squeeze().detach().numpy()
    pgd_image = pgd_adversarial_images.squeeze().detach().numpy()
    
    # 绘制图像
    fig, axes = plt.subplots(1, 3, figsize=(15, 5))
    axes[0].imshow(original_image, cmap='gray')
    axes[0].set_title(f"原始图像 (标签: {labels.item()})")
    axes[0].axis('off')
    
    axes[1].imshow(fgsm_image, cmap='gray')
    axes[1].set_title(f"FGSM对抗样本 (预测: {fgsm_pred.item()})")
    axes[1].axis('off')
    
    axes[2].imshow(pgd_image, cmap='gray')
    axes[2].set_title(f"PGD对抗样本 (预测: {pgd_pred.item()})")
    axes[2].axis('off')
    
    plt.tight_layout()
    plt.savefig('adversarial_examples.png')
    print("对抗样本已保存为 adversarial_examples.png")

这段代码实现了FGSM和PGD攻击，包括：

FGSM攻击：快速生成对抗样本，计算简单，仅需要一次梯度计算。
PGD攻击：迭代生成对抗样本，攻击能力强，可以生成更有效的对抗样本。
可视化：将原始图像和对抗样本可视化，便于观察攻击效果。

3.1.2 黑盒攻击

黑盒攻击是指攻击者只能访问模型的输出，无法获取模型的结构、参数或梯度。常用的黑盒攻击方法包括：

基于查询的攻击：通过大量查询模型，估计梯度或决策边界。
基于迁移的攻击：利用在白盒模型上生成的对抗样本，攻击黑盒模型。
生成式攻击：训练生成模型，直接生成对抗样本。

3.2 鲁棒性评估

鲁棒性评估是衡量模型抵御对抗样本能力的重要手段，常用的评估方法包括：

对抗准确率：模型在对抗样本上的准确率。
鲁棒性曲线：不同扰动大小下的对抗准确率曲线。
认证鲁棒性：提供可证明的鲁棒性保证，确保模型在一定扰动范围内的正确性。
迁移鲁棒性：模型抵御迁移对抗样本的能力。

下面是鲁棒性评估的实现示例：

import torch
import torch.nn as nn
from torchvision import datasets, transforms
import numpy as np

# 鲁棒性评估函数
def evaluate_robustness(model, test_loader, attack_func, epsilon_values):
    """
    评估模型在不同扰动大小下的鲁棒性
    model: 目标模型
    test_loader: 测试数据加载器
    attack_func: 攻击函数
    epsilon_values: 扰动大小列表
    返回: 不同扰动大小下的对抗准确率
    """
    model.eval()
    robust_accuracies = []
    
    for epsilon in epsilon_values:
        correct = 0
        total = 0
        
        for images, labels in test_loader:
            # 生成对抗样本
            adversarial_images = attack_func(model, images, labels, epsilon)
            
            # 预测
            outputs = model(adversarial_images)
            _, predicted = torch.max(outputs.data, 1)
            
            # 统计正确预测数量
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
        
        # 计算对抗准确率
        robust_accuracy = correct / total
        robust_accuracies.append(robust_accuracy)
        print(f"Epsilon: {epsilon:.3f}, 对抗准确率: {robust_accuracy:.4f}")
    
    return robust_accuracies

# 示例用法
if __name__ == "__main__":
    # 加载MNIST数据集
    transform = transforms.Compose([transforms.ToTensor()])
    test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)
    test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=100, shuffle=False)
    
    # 加载模型
    model = SimpleCNN()
    # 假设模型已经训练好
    
    # 定义扰动大小列表
    epsilon_values = [0.0, 0.05, 0.1, 0.15, 0.2, 0.25, 0.3]
    
    print("评估FGSM攻击下的鲁棒性:")
    fgsm_accuracies = evaluate_robustness(model, test_loader, fgsm_attack, epsilon_values)
    
    print("\n评估PGD攻击下的鲁棒性:")
    pgd_accuracies = evaluate_robustness(model, test_loader, pgd_attack, epsilon_values)
    
    # 可视化鲁棒性曲线
    import matplotlib.pyplot as plt
    
    plt.figure(figsize=(10, 6))
    plt.plot(epsilon_values, fgsm_accuracies, marker='o', label='FGSM攻击')
    plt.plot(epsilon_values, pgd_accuracies, marker='s', label='PGD攻击')
    plt.xlabel('扰动大小 (epsilon)')
    plt.ylabel('对抗准确率')
    plt.title('模型鲁棒性评估')
    plt.legend()
    plt.grid(True)
    plt.savefig('robustness_curve.png')
    print("鲁棒性曲线已保存为 robustness_curve.png")

这段代码实现了模型鲁棒性评估，包括：

对抗准确率计算：计算模型在不同扰动大小下的对抗准确率。
鲁棒性曲线绘制：绘制不同攻击方法下的鲁棒性曲线，便于比较。
批量评估：支持批量评估多个扰动大小，提高效率。

3.3 防御训练技术

防御训练是提高模型鲁棒性的重要方法，常用的防御训练技术包括：

对抗训练：在训练过程中，生成对抗样本并用于训练，提高模型的鲁棒性。
随机化防御：在模型推理过程中引入随机性，使攻击者难以生成有效的对抗样本。
蒸馏防御：通过知识蒸馏，提高模型的鲁棒性。
正则化防御：在损失函数中添加正则化项，鼓励模型学习鲁棒的特征表示。

下面是对抗训练的实现示例：

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
import numpy as np

# 对抗训练函数
def adversarial_train(model, train_loader, optimizer, criterion, epsilon, attack_func, epochs=10):
    """
    对抗训练实现
    model: 目标模型
    train_loader: 训练数据加载器
    optimizer: 优化器
    criterion: 损失函数
    epsilon: 扰动大小
    attack_func: 攻击函数
    epochs: 训练轮数
    """
    for epoch in range(epochs):
        model.train()
        running_loss = 0.0
        correct = 0
        total = 0
        
        for i, (images, labels) in enumerate(train_loader):
            # 生成对抗样本
            adversarial_images = attack_func(model, images, labels, epsilon)
            
            # 清零梯度
            optimizer.zero_grad()
            
            # 前向传播
            outputs = model(adversarial_images)
            loss = criterion(outputs, labels)
            
            # 反向传播
            loss.backward()
            optimizer.step()
            
            # 统计损失和准确率
            running_loss += loss.item()
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
        
        # 打印 epoch 信息
        epoch_loss = running_loss / len(train_loader)
        epoch_acc = correct / total
        print(f"Epoch [{epoch+1}/{epochs}], Loss: {epoch_loss:.4f}, Accuracy: {epoch_acc:.4f}")

# 示例用法
if __name__ == "__main__":
    # 加载MNIST数据集
    transform = transforms.Compose([transforms.ToTensor()])
    train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
    train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)
    
    # 初始化模型
    model = SimpleCNN()
    
    # 初始化优化器和损失函数
    optimizer = optim.Adam(model.parameters(), lr=0.001)
    criterion = nn.CrossEntropyLoss()
    
    # 扰动大小
    epsilon = 0.1
    
    # 对抗训练
    print("开始对抗训练...")
    adversarial_train(model, train_loader, optimizer, criterion, epsilon, fgsm_attack, epochs=10)
    
    # 保存模型
    torch.save(model.state_dict(), 'robust_model.pth')
    print("鲁棒模型已保存为 robust_model.pth")

这段代码实现了对抗训练，包括：

对抗样本生成：在每个训练批次中，生成对抗样本。
对抗损失计算：使用对抗样本计算损失，更新模型参数。
模型保存：将训练好的鲁棒模型保存到文件。

3.4 对抗样本的可迁移性

对抗样本的可迁移性是指在一个模型上生成的对抗样本，可以在另一个模型上生效。可迁移性是对抗攻击的重要特性，扩大了攻击的范围。

对抗样本的可迁移性主要由以下因素决定：

模型架构：相似架构的模型之间，对抗样本的迁移性更强。
训练数据：使用相同或相似训练数据的模型之间，对抗样本的迁移性更强。
训练方法：使用相同或相似训练方法的模型之间，对抗样本的迁移性更强。
攻击强度：较强的攻击生成的对抗样本，迁移性通常更强。

3.5 物理世界对抗样本

物理世界对抗样本是指在物理世界中有效的对抗样本，如对抗性图像、对抗性语音、对抗性文本等。物理世界对抗样本需要考虑以下因素：

传感器噪声：物理世界中的传感器噪声会影响对抗样本的效果。
视角变化：物理对象在不同视角下的外观变化。
光照变化：光照条件的变化会影响图像的外观。
材质和纹理：物体的材质和纹理会影响对抗扰动的效果。

4. 与主流方案深度对比

4.1 对抗攻击方法对比

攻击方法	类型	攻击能力	计算成本	可迁移性	适用场景
FGSM	白盒	中等	低	中等	快速攻击，实时性要求高
PGD	白盒	强	高	强	强攻击，需要高成功率
MIM	白盒	强	高	很强	需要高迁移性的场景
C&W	白盒	强	很高	强	需要隐蔽性高的场景
基于查询的攻击	黑盒	中等	很高	中等	只能访问模型输出的场景
基于迁移的攻击	黑盒	中等	低	强	可以访问其他模型的场景
生成式攻击	黑盒	强	中等	强	需要批量生成对抗样本的场景

4.2 防御方法对比

防御方法	类型	防御能力	计算成本	性能影响	适用场景
对抗训练	主动防御	强	高	中等	需要高鲁棒性的场景
随机化防御	被动防御	中等	低	低	实时性要求高的场景
蒸馏防御	被动防御	中等	中等	低	需要模型压缩的场景
正则化防御	主动防御	中等	低	低	计算资源有限的场景
认证防御	被动防御	很强	很高	高	需要可证明鲁棒性的场景
检测防御	被动防御	中等	低	低	可以接受误报的场景

4.3 性能与鲁棒性的权衡

在实际工程应用中，需要在模型性能和鲁棒性之间进行权衡。下表展示了不同防御方法下的性能与鲁棒性的权衡：

防御方法	原始准确率	对抗准确率	推理时间增加	训练时间增加
无防御	99%	10%	0%	0%
FGSM对抗训练	96%	70%	0%	2倍
PGD对抗训练	94%	80%	0%	4倍
随机化防御	98%	60%	50%	0%
蒸馏防御	97%	55%	0%	1.5倍
认证防御	90%	90%	10倍	10倍

5. 实际工程意义、潜在风险与局限性分析

5.1 实际工程意义

对抗样本与鲁棒性研究在安全领域具有重要的工程意义：

提高模型安全性：通过防御训练，提高模型抵御对抗样本的能力，增强系统的安全性。
指导模型设计：深入理解对抗样本的生成机制，指导模型设计，提高模型的鲁棒性。
评估模型安全性：提供鲁棒性评估方法，评估模型的安全性，为模型部署提供依据。
推动安全技术发展：促进机器学习与安全技术的融合，推动安全技术的发展。
应对高级威胁：帮助安全系统应对高级的对抗性威胁，提高系统的防御能力。

5.2 潜在风险

对抗样本与鲁棒性研究也存在一些潜在风险：

攻击技术滥用：对抗攻击技术可能被恶意攻击者滥用，导致安全事件。
防御成本过高：一些防御方法的计算成本过高，难以在实际工程中应用。
性能下降：防御训练可能导致模型性能下降，影响系统的正常运行。
防御逃逸：攻击者可能绕过防御措施，生成新的对抗样本。
虚假安全感：错误的鲁棒性评估可能导致虚假的安全感，低估实际风险。

5.3 局限性

对抗样本与鲁棒性研究还存在一些局限性：

理论与实践的差距：一些理论上有效的防御方法，在实际工程中效果有限。
泛化能力差：防御方法通常只对特定类型的攻击有效，泛化能力差。
计算资源需求高：一些高级防御方法需要大量的计算资源，难以部署。
缺乏统一的评估标准：目前缺乏统一的鲁棒性评估标准，难以比较不同方法的效果。
物理世界挑战：物理世界中的对抗样本面临更多挑战，如传感器噪声、视角变化等。

6. 未来趋势展望与个人前瞻性预测

6.1 趋势1：自适应攻防对抗

未来，自适应攻防对抗将成为研究热点，包括：

动态攻击策略：攻击者根据防御措施，动态调整攻击策略。
自适应防御：防御系统根据攻击模式，动态调整防御策略。
攻防博弈：攻击和防御相互促进，形成动态博弈。

6.2 趋势2：可解释的鲁棒性

未来，可解释的鲁棒性将成为研究热点，包括：

鲁棒性可视化：可视化模型的鲁棒性边界，便于理解和分析。
鲁棒性归因：解释模型鲁棒性的来源，指导模型设计。
可解释的防御：设计可解释的防御方法，提高用户的信任度。

6.3 趋势3：多模态对抗防御

未来，多模态对抗防御将成为研究热点，包括：

跨模态对抗攻击：生成跨模态的对抗样本，攻击多模态模型。
多模态防御：设计多模态防御方法，提高模型的鲁棒性。
模态互补防御：利用不同模态的互补信息，提高防御效果。

6.4 趋势4：联邦鲁棒学习

未来，联邦鲁棒学习将成为研究热点，包括：

跨设备鲁棒性：解决不同设备上的鲁棒性不一致问题。
隐私保护的对抗训练：在保护数据隐私的前提下，进行对抗训练。
联邦鲁棒性评估：在联邦学习场景下，评估模型的鲁棒性。

6.5 趋势5：硬件加速的鲁棒学习

未来，硬件加速的鲁棒学习将成为工程化趋势，包括：

GPU/TPU加速：利用GPU/TPU加速对抗训练和防御推理。
专用硬件设计：设计专门用于鲁棒学习的硬件加速器。
边缘设备鲁棒性：在边缘设备上部署鲁棒模型，提高边缘计算的安全性。

7. 参考链接

8. 附录

8.1 对抗样本生成算法伪代码

FGSM算法伪代码

Input: 模型 M，输入 x，标签 y，扰动大小 ε
Output: 对抗样本 x'

1. 计算损失 L(M(x), y)
2. 计算梯度 g = ∇_x L(M(x), y)
3. 计算扰动 r = ε * sign(g)
4. 生成对抗样本 x' = x + r
5. 裁剪 x' 到 [0, 1] 范围
6. 返回 x'

PGD算法伪代码

Input: 模型 M，输入 x，标签 y，扰动大小 ε，步长 α，迭代次数 T
Output: 对抗样本 x'

1. 初始化 x' = x
2. 对于 t = 1 到 T:
    a. 计算损失 L(M(x'), y)
    b. 计算梯度 g = ∇_x' L(M(x'), y)
    c. 计算扰动 r_t = α * sign(g)
    d. 更新 x' = x' + r_t
    e. 裁剪扰动：x' = x + clamp(x' - x, -ε, ε)
    f. 裁剪 x' 到 [0, 1] 范围
3. 返回 x'

8.2 环境配置

# 安装必要的依赖
pip install numpy pandas scikit-learn torch torchvision matplotlib seaborn

# 安装鲁棒学习库
pip install robustness

# 安装对抗攻击库
pip install adversarial-robustness-toolbox

8.3 鲁棒性评估指标

指标	计算公式	含义
对抗准确率	正确分类的对抗样本数 / 总对抗样本数	模型在对抗样本上的准确率
鲁棒性半径	使模型分类错误的最小扰动大小	模型的鲁棒性程度
认证准确率	模型在认证半径内的准确率	可证明的鲁棒性保证
迁移成功率	成功迁移的对抗样本数 / 总对抗样本数	对抗样本的迁移能力
攻击成功率	成功攻击的样本数 / 总样本数	攻击的有效性

9. 关键词

对抗样本, 鲁棒性, FGSM, PGD, 对抗训练, 黑盒攻击, 白盒攻击, 物理世界对抗样本, 可迁移性, 安全机器学习

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2026-01-17，如有侵权请联系 cloudcommunity@tencent.com 删除

机器学习

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度