Pytorch | 利用EMI-FGSM针对CIFAR10上的ResNet分类器进行对抗攻击

Pytorch | 利用EMI-FGSM针对CIFAR10上的ResNet分类器进行对抗攻击

• CIFAR数据集
• EMI-FGSM介绍
• • 算法流程
  • 与其他算法对比
• EMI-FGSM代码实现
• • EMI-FGSM算法实现
  • 攻击效果
• 代码汇总
• • emifgsm.py
  • train.py
  • advtest.py

之前已经针对CIFAR10训练了多种分类器：
Pytorch | 从零构建AlexNet对CIFAR10进行分类
Pytorch | 从零构建Vgg对CIFAR10进行分类
Pytorch | 从零构建GoogleNet对CIFAR10进行分类
Pytorch | 从零构建ResNet对CIFAR10进行分类
Pytorch | 从零构建MobileNet对CIFAR10进行分类
Pytorch | 从零构建EfficientNet对CIFAR10进行分类
Pytorch | 从零构建ParNet对CIFAR10进行分类

也实现了一些攻击算法：
Pytorch | 利用FGSM针对CIFAR10上的ResNet分类器进行对抗攻击
Pytorch | 利用BIM/I-FGSM针对CIFAR10上的ResNet分类器进行对抗攻击
Pytorch | 利用MI-FGSM针对CIFAR10上的ResNet分类器进行对抗攻击
Pytorch | 利用NI-FGSM针对CIFAR10上的ResNet分类器进行对抗攻击
Pytorch | 利用PI-FGSM针对CIFAR10上的ResNet分类器进行对抗攻击
Pytorch | 利用VMI-FGSM针对CIFAR10上的ResNet分类器进行对抗攻击
Pytorch | 利用VNI-FGSM针对CIFAR10上的ResNet分类器进行对抗攻击

本篇文章我们使用Pytorch实现EMI-FGSM对CIFAR10上的ResNet分类器进行攻击.

CIFAR数据集

CIFAR-10数据集是由加拿大高级研究所（CIFAR）收集整理的用于图像识别研究的常用数据集，基本信息如下：

• 数据规模：该数据集包含60,000张彩色图像，分为10个不同的类别，每个类别有6,000张图像。通常将其中50,000张作为训练集，用于模型的训练；10,000张作为测试集，用于评估模型的性能。
• 图像尺寸：所有图像的尺寸均为32×32像素，这相对较小的尺寸使得模型在处理该数据集时能够相对快速地进行训练和推理，但也增加了图像分类的难度。
• 类别内容：涵盖了飞机（plane）、汽车（car）、鸟（bird）、猫（cat）、鹿（deer）、狗（dog）、青蛙（frog）、马（horse）、船（ship）、卡车（truck）这10个不同的类别，这些类别都是现实世界中常见的物体，具有一定的代表性。

下面是一些示例样本：

EMI-FGSM介绍

EMI-FGSM（Enhanced Momentum Iterative Fast Gradient Sign Method）是一种基于增强动量的迭代快速梯度符号算法，用于生成对抗样本，以提高对抗样本在不同模型之间的转移性（transferability）。该算法在迭代过程中不仅累积当前数据点的梯度，还累积在前一次迭代梯度方向上采样的数据点的平均梯度，从而稳定更新方向，帮助找到更好的局部最大值，提高对抗样本的转移性。

算法流程

1. 初始化
   • 给定分类器 f f f、损失函数 J f J_f Jf、原始良性样本 x x x 及其真实标签 y y y。
   • 设置最大扰动 ϵ \epsilon ϵ、迭代次数 T T T、衰减因子 μ \mu μ、采样数量 N N N 以及采样区间边界 η \eta η。
   • 初始化对抗样本 x a d v 1 = x x_{adv}^1 = x xadv1=x，累积梯度 g 0 = 0 g_0 = 0 g0=0，前一次迭代的平均梯度 g ˉ 0 = 0 \bar{g}_0 = 0 gˉ0=0。
2. 迭代更新
   • 对于每次迭代 t = 1 t = 1 t=1 到 T T T：
     • 采样数据点 ：在区间 [ − η , η ] [-\eta, \eta] [−η,η] 内采样 N N N 个系数 c i c_i ci，计算在 x a d v t x_{adv}^t xadvt 邻域内的 N N N 个采样数据点 x ˉ t a d v [ i ] = x t a d v + c i ⋅ g ˉ t − 1 \bar{x}{t}^{adv}[i]=x{t}^{adv}+c_{i} \cdot \bar{g}{t - 1} xˉtadv[i]=xtadv+ci⋅gˉt−1，其中 g ˉ t − 1 \bar{g}{t - 1} gˉt−1是前一次迭代计算得到的平均梯度。
     • 计算平均梯度 ：计算这 N N N 个采样数据点的平均梯度 g ˉ t = 1 N ∑ i = 1 N ∇ x ˉ t a d v [ i ] J f ( x ˉ t a d v [ i ] , y ) \bar{g}{t}=\frac{1}{N} \sum{i = 1}^{N} \nabla_{\bar{x}{t}^{adv}[i]} J{f}(\bar{x}_{t}^{adv}[i], y) gˉt=N1∑i=1N∇xˉtadv[i]Jf(xˉtadv[i],y)。
     • 更新增强动量 ：更新累积梯度 g t = μ ⋅ g t − 1 + g ˉ t ∥ g ˉ t ∥ 1 g_{t}=\mu \cdot g_{t - 1}+\frac{\bar{g}{t}}{\left\|\bar{g}{t}\right\|_{1}} gt=μ⋅gt−1+∥gˉt∥1gˉt。
     • 更新对抗样本 ：更新对抗样本 x t + 1 a d v = x t a d v + α ⋅ s i g n ( g t ) x_{t + 1}^{adv}=x_{t}^{adv}+\alpha \cdot sign(g_{t}) xt+1adv=xtadv+α⋅sign(gt)，其中 α = ϵ T \alpha=\frac{\epsilon}{T} α=Tϵ。
3. 返回结果 ：返回最终生成的对抗样本 x a d v = x a d v T + 1 x_{adv}=x_{adv}^{T + 1} xadv=xadvT+1。

与其他算法对比

与传统的基于梯度的攻击方法（如FGSM、I-FGSM）相比，EMI-FGSM通过引入增强动量，能够更好地利用历史梯度信息，从而提高对抗样本在不同模型间的转移性。与其他动量迭代方法（如MI-FGSM、NI-FGSM）相比，EMI-FGSM在每次迭代中不仅考虑当前数据点的梯度，还通过在特定方向上采样多个数据点并计算其平均梯度来进一步增强动量，从而更有效地寻找更优的更新方向，提高攻击成功率和转移性。

EMI-FGSM代码实现

EMI-FGSM算法实现

import torch
import torch.nn as nn

def EMI_FGSM(model, criterion, original_images, labels, epsilon, num_iterations=10, decay=1, sampling_num=11, eta=7):
    """
    EMI-FGSM (Enhanced Momentum Iterative Fast Gradient Sign Method)

    参数:
    - model: 要攻击的模型
    - criterion: 损失函数
    - original_images: 原始图像（假设为批量图像，形状为 (batch_size, channels, height, width)）
    - labels: 原始图像的标签（形状为 (batch_size,)）
    - epsilon: 最大扰动幅度
    - num_iterations: 迭代次数
    - decay: 动量衰减因子
    - sampling_num: 采样数量
    - eta: 采样区间边界
    """
    alpha = epsilon / num_iterations
    perturbed_images = original_images.clone().detach().requires_grad_(True)
    momentum = torch.zeros_like(original_images).detach().to(original_images.device)
    prev_avg_grad = torch.zeros_like(original_images).detach().to(original_images.device)

    for _ in range(num_iterations):
        # 采样系数
        c = torch.rand(sampling_num) * 2 * eta - eta
        c = c.view(-1, 1, 1, 1, 1).to(original_images.device)

        # 计算采样数据点，利用广播机制同时处理多个采样点
        sampled_images = perturbed_images + c * prev_avg_grad
        sampled_images = torch.clamp(sampled_images, original_images - epsilon, original_images + epsilon)
        sampled_images = sampled_images.view(-1, *original_images.shape[1:]).clone().detach().requires_grad_(True)
        
        # 计算采样数据点的梯度
        outputs = model(sampled_images)  # 将采样图像展平为 (sampling_num * batch_size, channels, height, width)
        loss = criterion(outputs, labels.repeat(sampling_num))  # 重复标签以匹配输出形状
        model.zero_grad()
        loss.backward()
        grads = sampled_images.grad.view(sampling_num, -1, *original_images.shape[1:])  # 将梯度形状恢复为 (sampling_num, batch_size, channels, height, width)
        sampled_images.grad.zero_()

        # 计算平均梯度
        avg_grad = torch.mean(grads, dim=0)

        # 更新增强动量
        momentum = decay * momentum + avg_grad / torch.sum(torch.abs(avg_grad), dim=(1, 2, 3), keepdim=True)
        sign_data_grad = momentum.sign()

        # 更新对抗样本
        perturbed_images = perturbed_images + alpha * sign_data_grad
        perturbed_images = torch.clamp(perturbed_images, original_images - epsilon, original_images + epsilon)
        perturbed_images = perturbed_images.detach().requires_grad_(True)

        # 更新前一次迭代的平均梯度
        prev_avg_grad = avg_grad

    return perturbed_images

攻击效果

由于 sampling_num 取的较大时（比如为 11），计算量较大，因此这里实验取的是 sampling_num=2 的结果，效果比较差.

代码汇总

emifgsm.py

import torch
import torch.nn as nn

def EMI_FGSM(model, criterion, original_images, labels, epsilon, num_iterations=10, decay=1, sampling_num=11, eta=7):
    """
    EMI-FGSM (Enhanced Momentum Iterative Fast Gradient Sign Method)

    参数:
    - model: 要攻击的模型
    - criterion: 损失函数
    - original_images: 原始图像（假设为批量图像，形状为 (batch_size, channels, height, width)）
    - labels: 原始图像的标签（形状为 (batch_size,)）
    - epsilon: 最大扰动幅度
    - num_iterations: 迭代次数
    - decay: 动量衰减因子
    - sampling_num: 采样数量
    - eta: 采样区间边界
    """
    alpha = epsilon / num_iterations
    perturbed_images = original_images.clone().detach().requires_grad_(True)
    momentum = torch.zeros_like(original_images).detach().to(original_images.device)
    prev_avg_grad = torch.zeros_like(original_images).detach().to(original_images.device)

    for _ in range(num_iterations):
        # 采样系数
        c = torch.rand(sampling_num) * 2 * eta - eta
        c = c.view(-1, 1, 1, 1, 1).to(original_images.device)

        # 计算采样数据点，利用广播机制同时处理多个采样点
        sampled_images = perturbed_images + c * prev_avg_grad
        sampled_images = torch.clamp(sampled_images, original_images - epsilon, original_images + epsilon)
        sampled_images = sampled_images.view(-1, *original_images.shape[1:]).clone().detach().requires_grad_(True)
        
        # 计算采样数据点的梯度
        outputs = model(sampled_images)  # 将采样图像展平为 (sampling_num * batch_size, channels, height, width)
        loss = criterion(outputs, labels.repeat(sampling_num))  # 重复标签以匹配输出形状
        model.zero_grad()
        loss.backward()
        grads = sampled_images.grad.view(sampling_num, -1, *original_images.shape[1:])  # 将梯度形状恢复为 (sampling_num, batch_size, channels, height, width)
        sampled_images.grad.zero_()

        # 计算平均梯度
        avg_grad = torch.mean(grads, dim=0)

        # 更新增强动量
        momentum = decay * momentum + avg_grad / torch.sum(torch.abs(avg_grad), dim=(1, 2, 3), keepdim=True)
        sign_data_grad = momentum.sign()

        # 更新对抗样本
        perturbed_images = perturbed_images + alpha * sign_data_grad
        perturbed_images = torch.clamp(perturbed_images, original_images - epsilon, original_images + epsilon)
        perturbed_images = perturbed_images.detach().requires_grad_(True)

        # 更新前一次迭代的平均梯度
        prev_avg_grad = avg_grad

    return perturbed_images

train.py

import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms
from models import ResNet18


# 数据预处理
transform_train = transforms.Compose([
    transforms.RandomCrop(32, padding=4),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])

transform_test = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
])

# 加载Cifar10训练集和测试集
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=False, transform=transform_train)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=128, shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=False, transform=transform_test)
testloader = torch.utils.data.DataLoader(testset, batch_size=100, shuffle=False, num_workers=2)

# 定义设备（GPU或CPU）
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

# 初始化模型
model = ResNet18(num_classes=10)
model.to(device)

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

if __name__ == "__main__":
    # 训练模型
    for epoch in range(10):  # 可以根据实际情况调整训练轮数
        running_loss = 0.0
        for i, data in enumerate(trainloader, 0):
            inputs, labels = data[0].to(device), data[1].to(device)

            optimizer.zero_grad()

            outputs = model(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()

            running_loss += loss.item()
            if i % 100 == 99:
                print(f'Epoch {epoch + 1}, Batch {i + 1}: Loss = {running_loss / 100}')
                running_loss = 0.0

    torch.save(model.state_dict(), f'weights/epoch_{epoch + 1}.pth')
    print('Finished Training')

advtest.py

import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms
from models import *
from attacks import *
import ssl
import os
from PIL import Image
import matplotlib.pyplot as plt

ssl._create_default_https_context = ssl._create_unverified_context

# 定义数据预处理操作
transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.491, 0.482, 0.446), (0.247, 0.243, 0.261))])

# 加载CIFAR10测试集
testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=False, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=128,
                                         shuffle=False, num_workers=2)

# 定义设备（GPU优先，若可用）
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

model = ResNet18(num_classes=10).to(device)

criterion = nn.CrossEntropyLoss()

# 加载模型权重
weights_path = "weights/epoch_10.pth"
model.load_state_dict(torch.load(weights_path, map_location=device))


if __name__ == "__main__":
    # 在测试集上进行FGSM攻击并评估准确率
    model.eval()  # 设置为评估模式
    correct = 0
    total = 0
    epsilon = 16 / 255  # 可以调整扰动强度
    for data in testloader:
        original_images, labels = data[0].to(device), data[1].to(device)
        original_images.requires_grad = True
        
        attack_name = 'EMI-FGSM'
        if attack_name == 'FGSM':
            perturbed_images = FGSM(model, criterion, original_images, labels, epsilon)
        elif attack_name == 'BIM':
            perturbed_images = BIM(model, criterion, original_images, labels, epsilon)
        elif attack_name == 'MI-FGSM':
            perturbed_images = MI_FGSM(model, criterion, original_images, labels, epsilon)
        elif attack_name == 'NI-FGSM':
            perturbed_images = NI_FGSM(model, criterion, original_images, labels, epsilon)
        elif attack_name == 'PI-FGSM':
            perturbed_images = PI_FGSM(model, criterion, original_images, labels, epsilon)
        elif attack_name == 'VMI-FGSM':
            perturbed_images = VMI_FGSM(model, criterion, original_images, labels, epsilon)
        elif attack_name == 'VNI-FGSM':
            perturbed_images = VNI_FGSM(model, criterion, original_images, labels, epsilon)
        elif attack_name == 'EMI-FGSM':
            perturbed_images = EMI_FGSM(model, criterion, original_images, labels, epsilon)
        
        perturbed_outputs = model(perturbed_images)
        _, predicted = torch.max(perturbed_outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    accuracy = 100 * correct / total
    # Attack Success Rate
    ASR = 100 - accuracy
    print(f'Load ResNet Model Weight from {weights_path}')
    print(f'epsilon: {epsilon:.4f}')
    print(f'ASR of {attack_name} : {ASR :.2f}%')