之前已经针对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分类器进行对抗攻击
Pytorch | 利用AI-FGTM针对CIFAR10上的ResNet分类器进行对抗攻击
Pytorch | 利用I-FGSSM针对CIFAR10上的ResNet分类器进行对抗攻击
Pytorch | 利用SMI-FGRM针对CIFAR10上的ResNet分类器进行对抗攻击
Pytorch | 利用VA-I-FGSM针对CIFAR10上的ResNet分类器进行对抗攻击
Pytorch | 利用PC-I-FGSM针对CIFAR10上的ResNet分类器进行对抗攻击
Pytorch | 利用IE-FGSM针对CIFAR10上的ResNet分类器进行对抗攻击

本篇文章我们使用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）的安全缺陷。

算法流程

1. 输入初始化
   • 输入源模型 $F_{\psi }$、损失函数 $L$、干净图像 $clean$ 及其真实标签 $y^{true}$、最大对抗扰动幅度 $\epsilon$、迭代次数 $T$、动量累积衰减因子 $\mu$、衰减因子 $\eta$、上界因子 $\beta$ 和样本数量 $m$.
   • 初始化步长 $\alpha =\epsilon /T$，动量累积 $g_0=0$，$v_0=0$，初始对抗样本 $x_0^{adv}=x$，并将初始衰减指标 $M_0$ 的所有元素设置为 $1/\eta$。
2. 迭代更新
   • 计算梯度：对于 $t=0$ 到 $T-1$ 的每次迭代，计算当前梯度 $G_t(x)={\nabla }_{x_t^{adv}}L\left(x_t^{adv},y^{true}\right)$ 和平均梯度 $\overline{G_t}(x)=\frac{1}{m}{\sum }_{i=1}^m{\nabla }_{x_t^i}L\left(x_t^i,y^{true}\right)$，其中 $x_t^i=x_t^{adv}+{\gamma }_t^i$，${\gamma }_t^i$ 是满足 ${\gamma }_t^i\sim U[-(\beta \cdot \epsilon {)}^d,(\beta \cdot \epsilon {)}^d]$的随机噪声。
   • 计算余弦相似度和全局加权梯度：计算余弦相似度 $s_t=\frac{G_t(x)\cdot \overline{G_t}(x)}{{\Vert G_t(x)\Vert }_2\cdot {\Vert \overline{G_t}(x)\Vert }_2}$，并得到全局加权梯度 $W{G}_t=s_t\cdot G_t+\left(1-s_t\right)\cdot \overline{G_t}$。
   • 更新动量累积：$g_{t+1}=\mu \cdot g_t+\frac{W{G}_t}{{\Vert W{G}_t\Vert }_1}$。
   • 更新衰减指标：根据动量累积的符号变化更新衰减指标 $M_{t+1}=M_t\odot \left(M_{t+1}^e+\eta \cdot M_{t+1}^d\right)$，其中 $M_{t+1}^e$ 和 $M_{t+1}^d$ 分别表示相邻两次迭代中对抗扰动不变和变化的位置。
   • 更新对抗样本：$x_{t+1}^{adv}=Clip\left\{x_t^{adv}+\alpha \cdot M_{t+1}\odot sign\left(g_{t+1}\right)\right\}$，其中 $Clip$ 用于将图像像素限制在给定约束范围内。
3. 输出结果：迭代完成后，输出最终的对抗样本 $x_T^{adv}$.

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

1. 初始化衰减指标
   • 首先，在算法开始时，将衰减指标 $M_0$ 的所有元素初始化为 $1/\eta$，其中 $\eta$ 是预先设定的衰减因子，其值在 $(0,1)$ 之间。这一步为后续的更新提供了初始状态。
2. 计算动量累积的符号变化
   • 在每次迭代中，计算当前动量累积 $g_{t+1}$ 与上一次动量累积 $g_t$ 在每个元素位置上的符号变化情况。具体来说，对于 $g_{t+1}$ 和 $g_t$ 的第 $j$ 个元素（$j$ 表示元素在张量中的位置索引），定义 $M_{t+1,j}^e$（表示相邻两次迭代中对抗扰动不变的位置）和 $M_{t+1,k}^d$（表示相邻两次迭代中对抗扰动变化的位置）如下：
   • $M_{t+1,j}^e=\{\begin{array}{ll}1,& \text{ if }\mathrm{sign}\left(g_t^j\right)=\mathrm{sign}\left(g_{t+1}^j\right)\\ 0,& \text{ otherwise }\end{array}$
   • $M_{t+1,k}^d=\{\begin{array}{ll}1,& \text{ if }\mathrm{sign}\left(g_t^k\right)\ne \mathrm{sign}\left(g_{t+1}^k\right)\\ 0,& \text{otherwise }\end{array}$
   • 这里 $\mathrm{sign}$ 函数用于获取元素的符号（$1$ 表示正数，$-1$ 表示负数，$0$ 表示 $0$）。通过比较相邻两次迭代中动量累积元素的符号，确定哪些位置的对抗扰动发生了变化，哪些位置没有变化。
3. 更新衰减指标
   • 根据上述计算得到的 $M_{t+1}^e$ 和 $M_{t+1}^d$，更新衰减指标 $M_{t+1}$。具体计算公式为 $M_{t+1}=M_t\odot \left(M_{t+1}^e+\eta \cdot M_{t+1}^d\right)$，其中 $\odot$ 表示元素级的乘法运算。
   • 当某一位置的对抗扰动没有发生符号变化（即 $M_{t+1,j}^e=1$ 且 $M_{t+1,j}^d=0$）时，$M_{t+1}$ 在该位置的值保持不变（因为 $M_{t+1}^e+\eta \cdot M_{t+1}^d=1$），即保持之前的衰减状态。
   • 当某一位置的对抗扰动发生了符号变化（即 $M_{t+1,k}^e=0$ 且 $M_{t+1,k}^d=1$）时，$M_{t+1}$ 在该位置的值会根据 $\eta$ 进行衰减（因为 $M_{t+1}^e+\eta \cdot M_{t+1}^d=\eta$ ），从而减小该位置在后续对抗样本更新中的步长影响。这样，当对抗扰动的符号频繁变化时，通过衰减指标逐渐减小步长，使对抗样本的更新能够更接近最优解，避免因固定步长而在最优解附近振荡。

GRA代码实现

GRA算法实现

python">import torch
import torch.nn as nndef 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_iterationsperturbed_images = original_images.clone().detach().requires_grad_(True)momentum = torch.zeros_like(original_images).detach().to(original_images.device)# 初始化衰减指标M为1/etaM = torch.ones_like(original_images).detach().to(original_images.device) / etafor _ 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)# 更新衰减指标Msign_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_gradperturbed_images = torch.clamp(perturbed_images, original_images - epsilon, original_images + epsilon)perturbed_images = perturbed_images.detach().requires_grad_(True)return perturbed_imagesdef 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 nndef 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_iterationsperturbed_images = original_images.clone().detach().requires_grad_(True)momentum = torch.zeros_like(original_images).detach().to(original_images.device)# 初始化衰减指标M为1/etaM = torch.ones_like(original_images).detach().to(original_images.device) / etafor _ 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)# 更新衰减指标Msign_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_gradperturbed_images = torch.clamp(perturbed_images, original_images - epsilon, original_images + epsilon)perturbed_images = perturbed_images.detach().requires_grad_(True)return perturbed_imagesdef 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.0for 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.0torch.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 pltssl._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 = 0total = 0epsilon = 16 / 255  # 可以调整扰动强度for data in testloader:original_images, labels = data[0].to(device), data[1].to(device)original_images.requires_grad = Trueattack_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 RateASR = 100 - accuracyprint(f'Load ResNet Model Weight from {weights_path}')print(f'epsilon: {epsilon:.4f}')print(f'ASR of {attack_name} : {ASR :.2f}%')