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

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

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

下面是一些示例样本：

GRA介绍

GRA（Gradient Relevance Attack）是一种新型的基于梯度的攻击算法，旨在提高对抗样本的转移性，从而暴露深度神经网络（DNN）的安全缺陷。

算法流程

输入初始化
- 输入源模型 F ψ F_{\psi} Fψ、损失函数 L L L、干净图像 c l e a n clean clean 及其真实标签 y t r u e y^{true} ytrue、最大对抗扰动幅度 ε \varepsilon ε、迭代次数 T T T、动量累积衰减因子 μ \mu μ、衰减因子 η \eta η、上界因子 β \beta β 和样本数量 m m m.
- 初始化步长 α = ε / T \alpha=\varepsilon / T α=ε/T，动量累积 g 0 = 0 g_{0}=0 g0=0， v 0 = 0 v_{0}=0 v0=0，初始对抗样本 x 0 a d v = x x_{0}^{a d v}=x x0adv=x，并将初始衰减指标 M 0 M_{0} M0 的所有元素设置为 1 / η 1 / \eta 1/η。
迭代更新
- 计算梯度 ：对于 t = 0 t = 0 t=0 到 T − 1 T - 1 T−1 的每次迭代，计算当前梯度 G t ( x ) = ∇ x t a d v L ( x t a d v , y t r u e ) G_{t}(x)=\nabla_{x_{t}^{a d v}} L\left(x_{t}^{a d v}, y^{t r u e}\right) Gt(x)=∇xtadvL(xtadv,ytrue) 和平均梯度 G t ‾ ( x ) = 1 m ∑ i = 1 m ∇ x t i L ( x t i , y t r u e ) \overline{G_{t}}(x)=\frac{1}{m} \sum_{i = 1}^{m} \nabla_{x_{t}^{i}} L\left(x_{t}^{i}, y^{true }\right) Gt(x)=m1∑i=1m∇xtiL(xti,ytrue)，其中 x t i = x t a d v + γ t i x_{t}^{i}=x_{t}^{a d v}+\gamma_{t}^{i} xti=xtadv+γti， γ t i \gamma_{t}^{i} γti 是满足 γ t i ∼ U [ − ( β ⋅ ε ) d , ( β ⋅ ε ) d ] \gamma_{t}^{i} \sim U[-(\beta \cdot \varepsilon)^{d},(\beta \cdot \varepsilon)^{d}] γti∼U[−(β⋅ε)d,(β⋅ε)d]的随机噪声。
- 计算余弦相似度和全局加权梯度 ：计算余弦相似度 s t = G t ( x ) ⋅ G t ‾ ( x ) ∥ G t ( x ) ∥ 2 ⋅ ∥ G t ‾ ( x ) ∥ 2 s_{t}=\frac{G_{t}(x) \cdot \overline{G_{t}}(x)}{\left\|G_{t}(x)\right\|{2} \cdot\left\|\overline{G{t}}(x)\right\|{2}} st=∥Gt(x)∥2⋅∥Gt(x)∥2Gt(x)⋅Gt(x)，并得到全局加权梯度 W G t = s t ⋅ G t + ( 1 − s t ) ⋅ G t ‾ W G{t}=s_{t} \cdot G_{t}+\left(1 - s_{t}\right) \cdot \overline{G_{t}} WGt=st⋅Gt+(1−st)⋅Gt。
- 更新动量累积 ： g t + 1 = μ ⋅ g t + W G t ∥ W G t ∥ 1 g_{t + 1}=\mu \cdot g_{t}+\frac{W G_{t}}{\left\|W G_{t}\right\|_{1}} gt+1=μ⋅gt+∥WGt∥1WGt。
- 更新衰减指标 ：根据动量累积的符号变化更新衰减指标 M t + 1 = M t ⊙ ( M t + 1 e + η ⋅ M t + 1 d ) M_{t + 1}=M_{t} \odot\left(M_{t + 1}^{e}+\eta \cdot M_{t + 1}^{d}\right) Mt+1=Mt⊙(Mt+1e+η⋅Mt+1d)，其中 M t + 1 e M_{t + 1}^{e} Mt+1e 和 M t + 1 d M_{t + 1}^{d} Mt+1d 分别表示相邻两次迭代中对抗扰动不变和变化的位置。
- 更新对抗样本 ： x t + 1 a d v = C l i p { x t a d v + α ⋅ M t + 1 ⊙ s i g n ( g t + 1 ) } x_{t + 1}^{a d v}=Clip\left\{x_{t}^{a d v}+\alpha \cdot M_{t + 1} \odot sign\left(g_{t + 1}\right)\right\} xt+1adv=Clip{xtadv+α⋅Mt+1⊙sign(gt+1)}，其中 C l i p Clip Clip 用于将图像像素限制在给定约束范围内。
输出结果 ：迭代完成后，输出最终的对抗样本 x T a d v x_{T}^{a d v} xTadv.

更新衰减指标部分的详细计算过程如下：

初始化衰减指标

首先，在算法开始时，将衰减指标 M 0 M_{0} M0 的所有元素初始化为 1 / η 1 / \eta 1/η，其中 η \eta η 是预先设定的衰减因子，其值在 ( 0 , 1 ) (0, 1) (0,1) 之间。这一步为后续的更新提供了初始状态。

计算动量累积的符号变化

在每次迭代中，计算当前动量累积 g t + 1 g_{t + 1} gt+1 与上一次动量累积 g t g_{t} gt 在每个元素位置上的符号变化情况。具体来说，对于 g t + 1 g_{t +1} gt+1 和 g t g_{t} gt 的第 j j j 个元素（ j j j 表示元素在张量中的位置索引），定义 M t + 1 , j e M_{t + 1, j}^{e} Mt+1,je（表示相邻两次迭代中对抗扰动不变的位置）和 M t + 1 , k d M_{t + 1, k}^{d} Mt+1,kd（表示相邻两次迭代中对抗扰动变化的位置）如下：

M t + 1 , j e = { 1 , if sign ⁡ ( g t j ) = sign ⁡ ( g t + 1 j ) 0 , otherwise M_{t + 1, j}^{e}=\begin{cases}1, & \text { if } \operatorname{sign}\left(g_{t}^{j}\right)=\operatorname{sign}\left(g_{t+ 1}^{j}\right) \\ 0, & \text { otherwise }\end{cases} Mt+1,je={1,0, if sign(gtj)=sign(gt+1j) otherwise

M t + 1 , k d = { 1 , if sign ⁡ ( g t k ) ≠ sign ⁡ ( g t + 1 k ) 0 , otherwise M_{t + 1, k}^{d}=\begin{cases}1, & \text { if } \operatorname{sign}\left(g_{t}^{k}\right) \neq\operatorname{sign}\left(g_{t + 1}^{k}\right) \\ 0, & \text {otherwise }\end{cases} Mt+1,kd={1,0, if sign(gtk)=sign(gt+1k)otherwise

这里 sign ⁡ \operatorname{sign} sign 函数用于获取元素的符号（ 1 1 1 表示正数， − 1 -1 −1 表示负数， 0 0 0 表示 0 0 0）。通过比较相邻两次迭代中动量累积元素的符号，确定哪些位置的对抗扰动发生了变化，哪些位置没有变化。

更新衰减指标

根据上述计算得到的 M t + 1 e M_{t + 1}^{e} Mt+1e 和 M t + 1 d M_{t + 1}^{d} Mt+1d，更新衰减指标 M t + 1 M_{t + 1} Mt+1。具体计算公式为 M t + 1 = M t ⊙ ( M t + 1 e + η ⋅ M t + 1 d ) M_{t + 1}=M_{t} \odot\left(M_{t + 1}^{e}+\eta \cdot M_{t + 1}^{d}\right) Mt+1=Mt⊙(Mt+1e+η⋅Mt+1d)，其中 ⊙ \odot ⊙ 表示元素级的乘法运算。

当某一位置的对抗扰动没有发生符号变化（即 M t + 1 , j e = 1 M_{t + 1, j}^{e}=1 Mt+1,je=1 且 M t + 1 , j d = 0 M_{t + 1, j}^{d}=0 Mt+1,jd=0）时， M t + 1 M_{t + 1} Mt+1 在该位置的值保持不变（因为 M t + 1 e + η ⋅ M t + 1 d = 1 M_{t + 1}^{e}+\eta \cdot M_{t+ 1}^{d}=1 Mt+1e+η⋅Mt+1d=1），即保持之前的衰减状态。

当某一位置的对抗扰动发生了符号变化（即 M t + 1 , k e = 0 M_{t + 1, k}^{e}=0 Mt+1,ke=0 且 M t + 1 , k d = 1 M_{t + 1, k}^{d}=1 Mt+1,kd=1）时， M t + 1 M_{t + 1} Mt+1 在该位置的值会根据 η \eta η 进行衰减（因为 M t + 1 e + η ⋅ M t + 1 d = η M_{t + 1}^{e}+\eta \cdot M_{t +1}^{d}=\eta Mt+1e+η⋅Mt+1d=η ），从而减小该位置在后续对抗样本更新中的步长影响。这样，当对抗扰动的符号频繁变化时，通过衰减指标逐渐减小步长，使对抗样本的更新能够更接近最优解，避免因固定步长而在最优解附近振荡。

GRA代码实现

GRA算法实现

python 复制代码

import torch
import torch.nn as nn


def GRA(model, criterion, original_images, labels, epsilon, num_iterations=10, decay=1, beta=3.5, eta=0.94, sample_num=20):
    """
    GRA (Gradient Relevance Attack)

    参数:
    - model: 要攻击的模型
    - criterion: 损失函数
    - original_images: 原始图像
    - labels: 原始图像的标签
    - epsilon: 最大扰动幅度
    - num_iterations: 迭代次数
    - decay: 动量衰减因子
    - beta: 样本范围上限因子
    - eta: 衰减因子
    - sample_num: 样本数量
    """
    alpha = epsilon / num_iterations
    perturbed_images = original_images.clone().detach().requires_grad_(True)
    momentum = torch.zeros_like(original_images).detach().to(original_images.device)
    # 初始化衰减指标M为1/eta
    M = torch.ones_like(original_images).detach().to(original_images.device) / eta

    for _ in range(num_iterations):
        # 计算当前输入的梯度
        current_grad = compute_gradient(model, criterion, perturbed_images, labels)

        # 采样附近图像并计算平均梯度
        sampled_gradients = []
        x_i = perturbed_images.clone()
        for _ in range(sample_num):
            xi = x_i + torch.randn_like(x_i) * (beta * epsilon)
            sampled_gradients.append(compute_gradient(model, criterion, xi, labels))
            x_i = xi
        # 计算采样平均梯度
        average_grad = torch.mean(torch.stack(sampled_gradients), dim=0)

        # 计算余弦相似度
        cosine_similarity = torch.sum(current_grad * average_grad, dim=(1, 2, 3), keepdim=True) / (
                    torch.norm(current_grad, p=2, dim=(1, 2, 3), keepdim=True) * torch.norm(average_grad, p=2, dim=(1, 2, 3), keepdim=True))

        # 计算全局加权梯度
        weighted_grad = cosine_similarity * current_grad + (1 - cosine_similarity) * average_grad

        # 更新动量积累
        old_momentum = momentum.clone().detach()
        momentum = decay * momentum + weighted_grad / torch.sum(torch.abs(weighted_grad), dim=(1, 2, 3), keepdim=True)

        # 更新衰减指标M
        sign_data_grad = momentum.sign()
        M = M * ((sign_data_grad == torch.sign(old_momentum)) + eta * (sign_data_grad!= torch.sign(old_momentum)))

        # 更新对抗样本
        perturbed_images = perturbed_images + alpha * M * 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


def compute_gradient(model, criterion, x, labels):
    """
    计算梯度

    参数:
    - model: 模型
    - criterion: 损失函数
    - x: 输入图像
    - labels: 标签
    """
    x = x.clone().detach().requires_grad_(True)
    outputs = model(x)
    loss = criterion(outputs, labels)
    model.zero_grad()
    loss.backward()
    return x.grad.data

攻击效果

由于 sample_num=20 计算时间，这里取 sample_num=1.

代码汇总

gra.py

python 复制代码

import torch
import torch.nn as nn


def GRA(model, criterion, original_images, labels, epsilon, num_iterations=10, decay=1, beta=3.5, eta=0.94, sample_num=20):
    """
    GRA (Gradient Relevance Attack)

    参数:
    - model: 要攻击的模型
    - criterion: 损失函数
    - original_images: 原始图像
    - labels: 原始图像的标签
    - epsilon: 最大扰动幅度
    - num_iterations: 迭代次数
    - decay: 动量衰减因子
    - beta: 样本范围上限因子
    - eta: 衰减因子
    - sample_num: 样本数量
    """
    alpha = epsilon / num_iterations
    perturbed_images = original_images.clone().detach().requires_grad_(True)
    momentum = torch.zeros_like(original_images).detach().to(original_images.device)
    # 初始化衰减指标M为1/eta
    M = torch.ones_like(original_images).detach().to(original_images.device) / eta

    for _ in range(num_iterations):
        # 计算当前输入的梯度
        current_grad = compute_gradient(model, criterion, perturbed_images, labels)

        # 采样附近图像并计算平均梯度
        sampled_gradients = []
        x_i = perturbed_images.clone()
        for _ in range(sample_num):
            xi = x_i + torch.randn_like(x_i) * (beta * epsilon)
            sampled_gradients.append(compute_gradient(model, criterion, xi, labels))
            x_i = xi
        # 计算采样平均梯度
        average_grad = torch.mean(torch.stack(sampled_gradients), dim=0)

        # 计算余弦相似度
        cosine_similarity = torch.sum(current_grad * average_grad, dim=(1, 2, 3), keepdim=True) / (
                    torch.norm(current_grad, p=2, dim=(1, 2, 3), keepdim=True) * torch.norm(average_grad, p=2, dim=(1, 2, 3), keepdim=True))

        # 计算全局加权梯度
        weighted_grad = cosine_similarity * current_grad + (1 - cosine_similarity) * average_grad

        # 更新动量积累
        old_momentum = momentum.clone().detach()
        momentum = decay * momentum + weighted_grad / torch.sum(torch.abs(weighted_grad), dim=(1, 2, 3), keepdim=True)

        # 更新衰减指标M
        sign_data_grad = momentum.sign()
        M = M * ((sign_data_grad == torch.sign(old_momentum)) + eta * (sign_data_grad!= torch.sign(old_momentum)))

        # 更新对抗样本
        perturbed_images = perturbed_images + alpha * M * 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


def compute_gradient(model, criterion, x, labels):
    """
    计算梯度

    参数:
    - model: 模型
    - criterion: 损失函数
    - x: 输入图像
    - labels: 标签
    """
    x = x.clone().detach().requires_grad_(True)
    outputs = model(x)
    loss = criterion(outputs, labels)
    model.zero_grad()
    loss.backward()
    return x.grad.data

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 = 'GRA'
        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)
        
        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}%')