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

CIFAR数据集
BIM介绍
- 基本原理
- 算法流程
- 特点
- 应用场景
BIM代码实现
- BIM算法实现
- 攻击效果
代码汇总
- bim.py
- train.py
- advtest.py

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

下面是一些示例样本：

在这里插入图片描述

BIM介绍

BIM（Basic Iterative Method）算法，也称为迭代快速梯度符号法（Iterative Fast Gradient Sign Method，I-FGSM），是一种基于梯度的对抗攻击算法，以下是对它的详细介绍：

基本原理

利用模型梯度：与FGSM（Fast Gradient Sign Method）算法类似，BMI算法也是利用目标模型对输入数据的梯度信息来生成对抗样本。通过在原始输入样本上添加一个微小的扰动，使得模型对扰动后的样本产生错误的分类结果。
迭代更新扰动：不同于FGSM只进行一次梯度计算和扰动添加，BMI算法通过多次迭代来逐步调整扰动，每次迭代都根据当前模型对扰动后样本的梯度来更新扰动，使得扰动更具针对性和有效性，从而增加攻击的成功率。

算法流程

初始化：首先获取原始的输入图像(x)和对应的真实标签 $y$ ，并设置一些攻击参数，如扰动量 $\epsilon$ 、步长 $\alpha$ 和迭代次数 $T$ 等。然后将原始图像复制一份作为初始的对抗样本 $x^{adv}=x$ 。
迭代攻击：在每次迭代 $t$ （ $\cdots, T$ ）中，将当前的对抗样本 $x^{adv}$ 输入到目标模型 $f$ 中，计算模型的输出 $f(x^{adv})$ 和损失 $J(x^{adv}, y)$ ，其中损失函数通常使用交叉熵损失等。接着计算损失关于对抗样本的梯度 $\nabla_{x^{adv}}J(x^{adv}, y)$ ，并根据梯度的符号来更新对抗样本： $x^{adv}=x^{adv}+\alpha\cdot \text{sign}(\nabla_{x^{adv}}J(x^{adv}, y))$ 。
裁剪扰动：为了确保扰动后的样本与原始样本在视觉上不会有太大差异，需要对更新后的对抗样本进行裁剪，使其满足 $x^{adv}=\text{clip}(x^{adv}, x-\epsilon, x+\epsilon)$ ，即保证扰动后的样本在原始样本的 $\epsilon$ 邻域内。
终止条件判断：经过(T)次迭代后，得到最终的对抗样本(x^{adv})，此时将其输入到目标模型中，若模型对其的预测结果与真实标签不同，则攻击成功，否则攻击失败。

特点

攻击成功率较高：通过多次迭代更新扰动，BMI算法能够更精细地调整扰动方向和大小，使其更接近模型的决策边界，从而在一定程度上提高了攻击的成功率，相比FGSM等单步攻击算法，对一些防御机制较强的模型也能有较好的攻击效果。
计算成本相对较高：由于需要多次迭代计算梯度和更新扰动，BMI算法的计算成本相对较高，尤其是在处理大规模数据集或复杂模型时，所需的时间和计算资源会更多。
扰动相对较小：在迭代过程中不断调整扰动，并进行裁剪操作，使得最终生成的对抗样本的扰动相对较小，在视觉上更接近原始样本，具有一定的隐蔽性。

应用场景

模型安全性评估：通过使用BMI算法生成对抗样本，可以对深度学习模型的安全性进行评估，检测模型在面对对抗攻击时的脆弱性，帮助研究人员发现模型的潜在弱点，从而改进模型的防御机制，提高模型的鲁棒性。
对抗训练：在对抗训练中，将BMI算法生成的对抗样本作为额外的训练数据加入到原始训练数据集中，让模型学习如何抵御这类攻击，从而增强模型对对抗攻击的鲁棒性。
隐私保护研究：在一些隐私保护场景中，研究人员可以利用BMI算法生成对抗样本，通过分析模型对对抗样本的响应，来研究模型在处理用户数据时可能存在的隐私泄露风险，探索相应的隐私保护策略。

BIM代码实现

BIM算法实现

import torch
import torch.nn as nn

def BIM(model, criterion, original_images, labels, epsilon, alpha=0.001, num_iterations=10):
    perturbed_images = original_images.clone().detach().requires_grad_(True)

    for _ in range(num_iterations):
        # 计算损失
        outputs = model(perturbed_images)
        loss = criterion(outputs, labels)

        # 计算梯度
        loss.backward()

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

    return perturbed_images

攻击效果

在这里插入图片描述

代码汇总

bim.py

import torch
import torch.nn as nn

def BIM(model, criterion, original_images, labels, epsilon, alpha=0.001, num_iterations=10):
    perturbed_images = original_images.clone().detach().requires_grad_(True)

    for _ in range(num_iterations):
        # 计算损失
        outputs = model(perturbed_images)
        loss = criterion(outputs, labels)

        # 计算梯度
        loss.backward()

        # 更新对抗样本
        perturbation = alpha * perturbed_images.grad.sign()
        perturbed_images = perturbed_images + perturbation
        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

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 = 0.01  # 可以调整扰动强度
    for data in testloader:
        original_images, labels = data[0].to(device), data[1].to(device)
        original_images.requires_grad = True
        
        attack_name = 'BIM'
        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)
        
        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}')
    print(f'ASR of {attack_name} : {ASR}%')