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

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

• CIFAR数据集
• FGSM介绍
• • 算法原理
  • 算法特点
  • 应用场景
  • 局限性
• FGSM代码实现
• • FGSM算法实现
  • 攻击效果
• 代码汇总
• • fgsm.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实现快速梯度符号攻击Fast Gradient Sign Method, 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个不同的类别，这些类别都是现实世界中常见的物体，具有一定的代表性。

下面是一些示例样本：

FGSM介绍

FGSM（Fast Gradient Sign Method）算法是一种基于梯度的快速攻击算法，由Goodfellow等人在2015年提出，主要用于评估神经网络模型的鲁棒性。以下是对FGSM算法的详细介绍：

算法原理

• FGSM算法的核心思想是利用神经网络的梯度信息来生成对抗样本。对于给定的输入样本，通过计算模型对该样本的损失函数关于输入的梯度，然后根据梯度的符号来确定扰动的方向，最后在该方向上添加一个小的扰动，得到对抗样本。
• 具体而言，给定一个输入样本 x x x，其对应的真实标签为 y y y，模型的参数为 θ \theta θ，损失函数为 J ( θ , x , y ) J(\theta, x, y) J(θ,x,y)。首先计算损失函数 J J J 关于输入 x x x 的梯度 ∇ x J ( θ , x , y ) \nabla_x J(\theta, x, y) ∇xJ(θ,x,y)，然后根据梯度的符号确定扰动的方向 sign ( ∇ x J ( θ , x , y ) ) \text{sign}(\nabla_x J(\theta, x, y)) sign(∇xJ(θ,x,y))，最后生成对抗样本 x ′ = x + ϵ ⋅ sign ( ∇ x J ( θ , x , y ) ) x' = x + \epsilon \cdot \text{sign}(\nabla_x J(\theta, x, y)) x′=x+ϵ⋅sign(∇xJ(θ,x,y))，其中 ϵ \epsilon ϵ 是一个很小的正数，用于控制扰动的大小。

算法特点

• 计算效率高：FGSM算法只需要计算一次梯度，就可以生成对抗样本，因此计算速度非常快，适用于大规模数据集和复杂模型的攻击。
• 攻击效果好：尽管FGSM算法非常简单，但在很多情况下，它能够成功地欺骗神经网络模型，使得模型对对抗样本的预测结果与真实结果相差很大，从而证明了模型的脆弱性。
• 可扩展性强：FGSM算法可以很容易地扩展到其他攻击算法中，如迭代FGSM（I-FGSM）、动量迭代FGSM（MI-FGSM）等，通过多次迭代和引入动量等方法，可以进一步提高攻击的效果。

应用场景

• 模型安全性评估：通过使用FGSM算法生成对抗样本，可以评估神经网络模型在面对恶意攻击时的鲁棒性，发现模型的潜在安全漏洞，从而指导模型的改进和优化。
• 对抗训练：将FGSM算法生成的对抗样本作为额外的训练数据，与真实样本一起用于训练神经网络模型，可以提高模型对对抗攻击的鲁棒性，增强模型的安全性。
• 研究对抗攻击的性质：FGSM算法作为一种简单而有效的攻击算法，可以帮助研究人员深入研究对抗攻击的性质和特点，如对抗样本的分布、攻击的可转移性等，为设计更强大的防御策略提供理论依据。

局限性

• 攻击强度有限：由于FGSM算法只在梯度的方向上添加了一个固定大小的扰动，因此对于一些复杂的模型和防御机制，其攻击效果可能会受到限制。
• 白盒攻击假设：FGSM算法需要知道模型的结构和参数，才能计算梯度并生成对抗样本，因此它是一种白盒攻击算法。在实际应用中，攻击者往往无法获取模型的全部信息，这就限制了FGSM算法的实际应用范围。
• 扰动的可察觉性：在某些情况下，FGSM算法生成的对抗样本可能会引入较大的扰动，导致图像的质量下降，从而容易被人眼察觉。这对于一些对图像质量要求较高的应用场景，如自动驾驶、医疗影像等，可能会产生不利影响。

FGSM代码实现

FGSM算法实现

import torch
import torch.nn as nn

def FGSM(model, criterion, original_images, labels, epsilon):
    outputs = model(original_images)
    loss = criterion(outputs, labels)
    model.zero_grad()
    loss.backward()
    data_grad = original_images.grad.data
    sign_data_grad = data_grad.sign()
    perturbed_image = original_images + epsilon * sign_data_grad
    perturbed_image = torch.clamp(perturbed_image, 0, 1)
    
    return perturbed_image

攻击效果

代码汇总

fgsm.py

import torch
import torch.nn as nn


def FGSM(model, criterion, original_images, labels, epsilon):
    outputs = model(original_images)
    loss = criterion(outputs, labels)
    model.zero_grad()
    loss.backward()
    data_grad = original_images.grad.data
    sign_data_grad = data_grad.sign()
    perturbed_image = original_images + epsilon * sign_data_grad
    perturbed_image = torch.clamp(perturbed_image, 0, 1)
    
    return perturbed_image

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 = 'FGSM'
        if attack_name == 'FGSM':
            perturbed_images = 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}')
    print(f'ASR of {attack_name} : {ASR}%')