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

CIFAR数据集
GNP介绍
- 算法流程
GNP代码实现
- GNP算法实现
- 攻击效果
代码汇总

本篇文章我们使用Pytorch实现GNP对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个不同的类别，这些类别都是现实世界中常见的物体，具有一定的代表性。

下面是一些示例样本：

GNP介绍

GNP（Gradient Norm Penalty）算法是一种用于提升对抗样本（Adversarial Examples, AE）迁移性的方法，旨在通过优化策略使生成的对抗样本能够在不同的深度学习模型间有效迁移，从而实现对未知模型（黑盒模型）的攻击。

算法流程

下面是将GNP集成到I - FGSM中的算法，其核心算法过程如下：

初始化阶段
- 设定每次迭代的步长 α \alpha α，计算方式为扰动大小 ϵ \epsilon ϵ 除以最大迭代次数 T T T，即 α = ϵ / T \alpha=\epsilon/T α=ϵ/T。这一步确定了每次迭代中对抗样本更新的基本步长大小。
- 将初始梯度 g 0 g_0 g0 赋值为0，为后续迭代计算梯度提供初始状态。
- 把初始对抗样本 x a d v 0 x_{adv}^0 xadv0 设为原始干净样本 x x x，作为迭代生成对抗样本的起始点。
迭代计算与更新阶段
- 进入迭代循环，从 t = 0 t = 0 t=0 开始，到 T − 1 T - 1 T−1 结束，共进行 T T T 次迭代。
- 在每次迭代中：
  - 计算当前对抗样本 x a d v t x_{adv}^t xadvt 关于损失函数 ℓ ( x , y ) \ell(x, y) ℓ(x,y) 的梯度 g 1 g_1 g1，即 g 1 = ∇ x ℓ ( x a d v t ) g_1 = \nabla_{x}\ell(x_{adv}^t) g1=∇xℓ(xadvt)。该梯度反映了当前对抗样本在损失函数上的变化趋势，用于后续确定对抗样本的更新方向。
  - 计算用于近似GNP项中梯度范数惩罚的梯度 g 2 g_2 g2，计算方式为 g 2 = ∇ x ℓ ( x a d v t + r ∇ x ℓ ( x a d v t ) ∥ ∇ x ℓ ( x a d v t ) ∥ ) g_2 = \nabla_{x}\ell(x_{adv}^t + r\frac{\nabla_{x}\ell(x_{adv}^t)}{\left\|\nabla_{x}\ell(x_{adv}^t)\right\|}) g2=∇xℓ(xadvt+r∥∇xℓ(xadvt)∥∇xℓ(xadvt))。这里引入了GNP机制，通过计算在特定方向上的梯度来对梯度范数进行惩罚，促使对抗样本趋向于损失景观中的平坦区域，增强其迁移性。
  - 根据公式 g t = ( 1 + β ) g 1 − β g 2 g_t = (1 + \beta)g_1 - \beta g_2 gt=(1+β)g1−βg2 更新当前迭代的梯度 g t g_t gt，其中 β \beta β 为正则化系数，该公式平衡了原始损失函数梯度和GNP相关梯度的影响，得到最终用于更新对抗样本的梯度方向。
  - 根据更新后的梯度方向 s i g n ( g t ) sign(g_t) sign(gt) 和步长 α \alpha α，更新对抗样本 x a d v t + 1 = x a d v t + α ⋅ s i g n ( g t ) x_{adv}^{t + 1} = x_{adv}^t + \alpha \cdot sign(g_t) xadvt+1=xadvt+α⋅sign(gt)。通过朝着使损失函数增大（即更容易导致模型误分类）的方向，以步长 α \alpha α 更新对抗样本。
输出阶段
- 经过 T T T 次迭代后，输出最终生成的对抗样本 x a d v = x a d v T x_{adv} = x_{adv}^T xadv=xadvT。这个对抗样本是经过一系列迭代优化得到的，在源模型上具有较高概率导致误分类，并且由于GNP机制的作用，有望在其他目标模型上也能有效攻击，从而实现黑盒攻击中利用源模型生成可迁移对抗样本攻击目标模型的目的。

GNP代码实现

GNP算法实现

python 复制代码

import torch
import torch.nn as nn

def GNP(model, criterion, original_images, labels, epsilon, num_iterations=10, step_size=0.01, beta=0.8):
    """
    I-FGSM with Gradient Norm Penalty (GNP)

    参数:
    - model: 要攻击的模型
    - criterion: 损失函数
    - original_images: 原始图像
    - labels: 原始图像的标签
    - epsilon: 最大扰动幅度
    - num_iterations: 迭代次数
    - step_size: 步长
    - beta: 正则化系数
    """
    # 计算每次迭代的步长
    alpha = epsilon / num_iterations
    # 复制原始图像作为初始的对抗样本
    perturbed_images = original_images.clone().detach().requires_grad_(True)

    for _ in range(num_iterations):
        outputs = model(perturbed_images)
        loss = criterion(outputs, labels)

        model.zero_grad()
        loss.backward()

        # 计算原始损失函数的梯度
        data_grad = perturbed_images.grad.data

        # 计算用于近似GNP项中梯度范数惩罚的梯度
        with torch.no_grad():
            g2_images = perturbed_images + step_size * (data_grad / data_grad.norm(p=2, dim=(1, 2, 3), keepdim=True))
            g2_images = g2_images.detach().requires_grad_(True)
            g2_outputs = model(g2_images)
            g2_loss = criterion(g2_outputs, labels)
            g2_loss.backward()
            g2_grad = g2_images.grad.data

        # 更新梯度
        new_grad = (1 + beta) * data_grad - beta * g2_grad
        # 计算符号梯度
        sign_data_grad = new_grad.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)

    return perturbed_images

攻击效果

代码汇总

gnp.py

python 复制代码

import torch
import torch.nn as nn

def GNP(model, criterion, original_images, labels, epsilon, num_iterations=10, step_size=0.01, beta=0.8):
    """
    I-FGSM with Gradient Norm Penalty (GNP)

    参数:
    - model: 要攻击的模型
    - criterion: 损失函数
    - original_images: 原始图像
    - labels: 原始图像的标签
    - epsilon: 最大扰动幅度
    - num_iterations: 迭代次数
    - step_size: 步长
    - beta: 正则化系数
    """
    # 计算每次迭代的步长
    alpha = epsilon / num_iterations
    # 复制原始图像作为初始的对抗样本
    perturbed_images = original_images.clone().detach().requires_grad_(True)

    for _ in range(num_iterations):
        outputs = model(perturbed_images)
        loss = criterion(outputs, labels)

        model.zero_grad()
        loss.backward()

        # 计算原始损失函数的梯度
        data_grad = perturbed_images.grad.data

        # 计算用于近似GNP项中梯度范数惩罚的梯度
        with torch.no_grad():
            g2_images = perturbed_images + step_size * (data_grad / data_grad.norm(p=2, dim=(1, 2, 3), keepdim=True))
            g2_images = g2_images.detach().requires_grad_(True)
            g2_outputs = model(g2_images)
            g2_loss = criterion(g2_outputs, labels)
            g2_loss.backward()
            g2_grad = g2_images.grad.data

        # 更新梯度
        new_grad = (1 + beta) * data_grad - beta * g2_grad
        # 计算符号梯度
        sign_data_grad = new_grad.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)

    return perturbed_images

train.py

python 复制代码

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

python 复制代码

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 = 'GNP'
        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)
        elif attack_name == 'AI-FGTM':
            perturbed_images = AI_FGTM(model, criterion, original_images, labels, epsilon)
        elif attack_name == 'I-FGSSM':
            perturbed_images = I_FGSSM(model, criterion, original_images, labels, epsilon)
        elif attack_name == 'SMI-FGRM':
            perturbed_images = SMI_FGRM(model, criterion, original_images, labels, epsilon)
        elif attack_name == 'VA-I-FGSM':
            perturbed_images = VA_I_FGSM(model, criterion, original_images, labels, epsilon)
        elif attack_name == 'PC-I-FGSM':
            perturbed_images = PC_I_FGSM(model, criterion, original_images, labels, epsilon)
        elif attack_name == 'IE-FGSM':
            perturbed_images = IE_FGSM(model, criterion, original_images, labels, epsilon)
        elif attack_name == 'GRA':
            perturbed_images = GRA(model, criterion, original_images, labels, epsilon)
        elif attack_name == 'GNP':
            perturbed_images = GNP(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}%')