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

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

  • CIFAR数据集
  • PI-FGSM介绍
    • 背景和动机
    • 算法原理
    • 算法流程
  • PI-FGSM代码实现
    • PI-FGSM算法实现
    • 攻击效果
  • 代码汇总
    • pifgsm.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实现PI-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个不同的类别,这些类别都是现实世界中常见的物体,具有一定的代表性。

下面是一些示例样本:

在这里插入图片描述

PI-FGSM介绍

PI-FGSM(Patch-wise Iterative Fast Gradient Sign Method)是一种针对主流正常训练和防御模型的黑盒攻击算法,旨在生成具有强转移性的对抗样本。该算法通过引入放大因子和投影核,以块(patch)为单位生成对抗噪声,从而提高对抗样本在不同模型间的转移性。

背景和动机

  • DNN的对抗样本问题:深度神经网络(DNN)在取得巨大成就的同时,面临着对抗样本的威胁。这些添加了人类难以察觉噪声的对抗样本,能够轻易愚弄先进的DNN,使其做出不合理的预测,引发了对机器学习算法安全性的担忧。
  • 现有攻击方法的局限性:基于梯度的攻击方法是常见的攻击手段,其中迭代攻击在白盒设置下性能较好,但在黑盒设置中,由于攻击者无法获取目标模型信息,通常使用替代模型生成对抗样本,此时迭代攻击容易陷入局部最优,转移性较差;单步攻击虽转移性较高,但性能欠佳。
  • 研究动机:基于DNN的特性,不同模型在识别时关注的判别区域不同,且判别区域通常具有聚集性。仅添加像素级噪声可能影响对抗样本的转移性,因此研究具有聚集性的扰动生成方法具有重要意义。PI-FGSM旨在结合单步和迭代攻击的优点,在不牺牲替代模型性能的前提下提高转移性。

算法原理

  • 目标函数:PI-FGSM的目标是在满足 L ∞ L_{\infty} L 范数约束(即对抗扰动的最大幅度不超过 ϵ \epsilon ϵ)的条件下,最大化替代模型的交叉熵损失,以生成能够成功欺骗目标模型的对抗样本。
  • 梯度计算与放大:在每次迭代中,计算当前对抗样本 x t a d v x_t^{adv} xtadv 关于损失函数 J J J 的梯度 ∇ x J ( x t a d v , y ) \nabla_x J(x_t^{adv}, y) xJ(xtadv,y),并将步长设置为 ϵ T × β \frac{\epsilon}{T} \times \beta Tϵ×β(其中 T T T 为总迭代次数, β \beta β 为放大因子),对梯度进行放大,以增加扰动的幅度,提高攻击的有效性。
  • 投影核与噪声重用:引入特殊的均匀投影核 W p W_p Wp,当累积放大噪声 a t a_t at L ∞ L_{\infty} L 范数超过阈值 ϵ \epsilon ϵ 时,通过投影核将超出部分的噪声投影到周围区域,生成“可行方向”的噪声,同时重用这部分噪声,增加噪声斑块的聚集程度,以更好地匹配图像中判别区域的聚集特性,提高对抗样本的转移性。

算法流程

  • 初始化累积放大噪声 a 0 a_0 a0 和裁剪噪声 C C C 为0,设置初始对抗样本 x 0 a d v = x c l e a n x_0^{adv}=x^{clean} x0adv=xclean
  • 对于 t = 0 t = 0 t=0 T − 1 T - 1 T1
    • 计算梯度 ∇ x J ( x t a d v , y ) \nabla_x J(x_t^{adv}, y) xJ(xtadv,y)
    • 更新累积放大噪声 a t + 1 = a t + β ⋅ ϵ T ⋅ s i g n ( ∇ x J ( x t a d v , y ) ) a_{t + 1}=a_t+\beta \cdot \frac{\epsilon}{T} \cdot sign(\nabla_x J(x_t^{adv}, y)) at+1=at+βTϵsign(xJ(xtadv,y))
    • 如果 ∥ a t + 1 ∥ ∞ ≥ ϵ \|a_{t + 1}\|_{\infty} \geq \epsilon at+1ϵ,则计算裁剪噪声 C = c l i p ( ∣ a t + 1 ∣ − ϵ , 0 , ∞ ) ⋅ s i g n ( a t + 1 ) C = clip(|a_{t + 1}|-\epsilon, 0, \infty) \cdot sign(a_{t + 1}) C=clip(at+1ϵ,0,)sign(at+1),并更新 a t + 1 = a t + 1 + γ ⋅ s i g n ( W p ∗ C ) a_{t + 1}=a_{t + 1}+\gamma \cdot sign(W_p * C) at+1=at+1+γsign(WpC)(其中 γ \gamma γ 为投影因子);否则 C = 0 C = 0 C=0
  • 更新对抗样本 x t + 1 a d v = C l i p x c l e a n , ϵ { x t a d v + β ⋅ ϵ T ⋅ s i g n ( ∇ x J ( x t a d v , y ) ) + γ ⋅ s i g n ( W p ∗ C ) } x_{t + 1}^{adv}=Clip_{x^{clean}, \epsilon}\{x_t^{adv}+\beta \cdot \frac{\epsilon}{T} \cdot sign(\nabla_x J(x_t^{adv}, y))+\gamma \cdot sign(W_p * C)\} xt+1adv=Clipxclean,ϵ{xtadv+βTϵsign(xJ(xtadv,y))+γsign(WpC)},并将其裁剪到 [ − 1 , 1 ] [-1, 1] [1,1] 范围内。
  • 返回最终的对抗样本 x a d v = x T a d v x^{adv}=x_T^{adv} xadv=xTadv

PI-FGSM代码实现

PI-FGSM算法实现

import torch
import torch.nn as nn

def PI_FGSM(model, criterion, original_images, labels, epsilon, beta=5, kernel_size=3, num_iterations=10):
    """
    PI-FGSM (Patch-wise Iterative Fast Gradient Sign Method)

    参数:
    - model: 要攻击的模型
    - criterion: 损失函数
    - original_images: 原始图像
    - labels: 原始图像的标签
    - epsilon: 扰动幅度
    - beta: 放大因子
    - kernel_size: 投影核大小
    - num_iterations: 迭代次数
    
    返回:
    - perturbed_image: 生成的对抗样本
    """
    # gamma: 投影因子
    gamma = epsilon / num_iterations * beta
    # 初始化累积放大噪声和裁剪噪声
    a = torch.zeros_like(original_images)
    C = torch.zeros_like(original_images)
    perturbed_images = original_images.clone().detach().requires_grad_(True)

    # 定义投影核
    Wp = torch.ones((kernel_size, kernel_size), dtype=torch.float32) / (kernel_size ** 2 - 1)
    Wp[kernel_size // 2, kernel_size // 2] = 0
    Wp = Wp.expand(original_images.size(1), -1, -1).to(original_images.device)
    Wp = Wp.unsqueeze(0)

    for _ in range(num_iterations):
        # 计算梯度
        outputs = model(perturbed_images)
        loss = criterion(outputs, labels)
        
        model.zero_grad()
        loss.backward()
        
        data_grad = perturbed_images.grad.data

        # 更新累积放大噪声
        a = a + beta * (epsilon / num_iterations) * data_grad.sign()

        # 裁剪噪声
        if a.abs().max() >= epsilon:
            C = (a.abs() - epsilon).clamp(0, float('inf')) * a.sign()
            a = a + gamma * torch.nn.functional.conv2d(input=C, weight=Wp, stride=1, padding=kernel_size // 2)

        # 更新对抗样本
        perturbed_images = perturbed_images + beta * (epsilon / num_iterations) * data_grad.sign() + gamma * torch.nn.functional.conv2d(C, Wp, stride=1, padding=kernel_size // 2)
        
        perturbed_images = torch.clamp(perturbed_images, original_images - epsilon, original_images + epsilon)
        perturbed_images = perturbed_images.detach().requires_grad_(True)

    return perturbed_images

攻击效果

在这里插入图片描述

代码汇总

pifgsm.py

import torch
import torch.nn as nn

def PI_FGSM(model, criterion, original_images, labels, epsilon, beta=5, kernel_size=3, num_iterations=10):
    """
    PI-FGSM (Patch-wise Iterative Fast Gradient Sign Method)

    参数:
    - model: 要攻击的模型
    - criterion: 损失函数
    - original_images: 原始图像
    - labels: 原始图像的标签
    - epsilon: 扰动幅度
    - beta: 放大因子
    - kernel_size: 投影核大小
    - num_iterations: 迭代次数
    
    返回:
    - perturbed_image: 生成的对抗样本
    """
    # gamma: 投影因子
    gamma = epsilon / num_iterations * beta
    # 初始化累积放大噪声和裁剪噪声
    a = torch.zeros_like(original_images)
    C = torch.zeros_like(original_images)
    perturbed_images = original_images.clone().detach().requires_grad_(True)

    # 定义投影核
    Wp = torch.ones((kernel_size, kernel_size), dtype=torch.float32) / (kernel_size ** 2 - 1)
    Wp[kernel_size // 2, kernel_size // 2] = 0
    Wp = Wp.expand(original_images.size(1), -1, -1).to(original_images.device)
    Wp = Wp.unsqueeze(0)

    for _ in range(num_iterations):
        # 计算梯度
        outputs = model(perturbed_images)
        loss = criterion(outputs, labels)
        
        model.zero_grad()
        loss.backward()
        
        data_grad = perturbed_images.grad.data

        # 更新累积放大噪声
        a = a + beta * (epsilon / num_iterations) * data_grad.sign()

        # 裁剪噪声
        if a.abs().max() >= epsilon:
            C = (a.abs() - epsilon).clamp(0, float('inf')) * a.sign()
            a = a + gamma * torch.nn.functional.conv2d(input=C, weight=Wp, stride=1, padding=kernel_size // 2)

        # 更新对抗样本
        perturbed_images = perturbed_images + beta * (epsilon / num_iterations) * data_grad.sign() + gamma * torch.nn.functional.conv2d(C, Wp, stride=1, padding=kernel_size // 2)
        
        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 = 16 / 255  # 可以调整扰动强度
    for data in testloader:
        original_images, labels = data[0].to(device), data[1].to(device)
        original_images.requires_grad = True
        
        attack_name = 'PI-FGSM'
        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)
        
        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}%')

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/941008.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

IMX6ULL开发板如何关掉自带的QT的GUI界面和poky的界面的方法

重要说明:其实最后发现根本没必要去关掉自带的QT的GUI界面,直接把屏幕先刷黑就可以看到测试效果了,把屏蔽先刷黑的代码见博文: https://blog.csdn.net/wenhao_ir/article/details/144594705 不过,既然花了时间摸索如何…

【网络安全】逆向工程 练习示例

1. 逆向工程简介 逆向工程 (RE) 是将某物分解以了解其功能的过程。在网络安全中,逆向工程用于分析应用程序(二进制文件)的运行方式。这可用于确定应用程序是否是恶意的或是否存在任何安全漏洞。 例如,网络安全分析师对攻击者分发…

Docker Compose 安装 Harbor

我使用的系统是rocky Linux 9 1. 准备环境 确保你的系统已经安装了以下工具: DockerDocker ComposeOpenSSL(用于生成证书)#如果不需要通过https连接的可以不设置 1.1 安装 Docker 如果尚未安装 Docker,可以参考以下命令安装&…

深入浅出:多功能 Copilot 智能助手如何借助 LLM 实现精准意图识别

阅读原文 1. Copilot中的意图识别 如果要搭建一个 Copilot 智能助手,比如支持 知识问答、数据分析、智能托管、AIGC 等众多场景或能力,那么最核心的就是基于LLM进行意图识别分发能力,意图识别的准确率直接决定了 Copilot 智能助手的能力上限…

ZED-OpenCV项目运行记录

项目地址:GitCode - 全球开发者的开源社区,开源代码托管平台 使用 ZED 立体相机与 OpenCV 进行图像处理和深度感知 • 使用 ZED 相机和 OpenCV 库捕获图像、深度图和点云。 • 提供保存并排图像、深度图和点云的功能。 • 允许在不同格式之间切换保存的深度图和点云…

Linux 常见用例汇总

注:本文为 Linux 常见用例文章合辑。 部分内容已过时,未更新整理。 检查 Linux 上的 glibc 版本 译者:joeren | 2014-11-27 21:33 问:检查 Linux 系统上的 GNU C 库(glibc)的版本? GNU C 库&…

PHP阶段一

PHP 一门编程语言 运行在服务器端 专门用户开发网站的 脚本后缀名.php 与HTML语言进行混编,脚本后缀依然是.php 解释型语言,不要编译直接运行 PHP运行需要环境: Windows phpstudy Linux 单独安装 Web 原理简述 1、打开浏览器 2、输入u…

REMOTE_LISTENER引发的血案

作者:Digital Observer(施嘉伟) Oracle ACE Pro: Database PostgreSQL ACE Partner 11年数据库行业经验,现主要从事数据库服务工作 拥有Oracle OCM、DB2 10.1 Fundamentals、MySQL 8.0 OCP、WebLogic 12c OCA、KCP、PCTP、PCSD、P…

Redis篇--常见问题篇6--缓存一致性1(Mysql和Redis缓存一致,更新数据库删除缓存策略)

1、概述 在使用Redis作为MySQL的缓存层时,缓存一致性问题是指Redis中的缓存数据与MySQL数据库中的实际数据不一致的情况。这可能会导致读取到过期或错误的数据,从而影响系统的正确性和用户体验。 为了减轻数据库的压力,通常读操作都是先读缓…

Phono3py hdf5文件数据读取与处理

Phono3py是一个主要用python写的声子-声子相互作用相关性质的模拟包,可以基于有限位移算法实现三阶力常数和晶格热导率的计算过程,同时输出包括声速,格林奈森常数,声子寿命和累积晶格热导率等参量。 相关介绍和安装请参考往期推荐…

机器学习(四)-回归模型评估指标

文章目录 1. 哪个模型更好?2. 线性回归评估指标3. python 实现线性模型评估指标 1. 哪个模型更好? 我们之前已经对房价预测的问题构建了线性模型,并对测试集进行了预测。 如图所示,横坐标是地区人口,纵坐标是房价&am…

Oracle 适配 OpenGauss 数据库差异语法汇总

背景 国产化进程中,需要将某项目的数据库从 Oracle 转为 OpenGauss ,项目初期也是规划了适配不同数据库的,MyBatis 配置加载路径设计的是根据数据库类型加载指定文件夹的 xml 文件。 后面由于固定了数据库类型为 Oracle 后,只写…

Unity引擎学习总结------动画控件

左侧窗格可以在参数视图和图层视图之间切换。参数视图允许您创建、查看和编辑动画控制器参数。这些是您定义的变量,用作状态机的输入。要添加参数,请单击加号图标并从弹出菜单中选择参数类型。要删除参数,请在列表中选择该参数并按删除键&…

记录:virt-manager配置Ubuntu arm虚拟机

virt-manager(Virtual Machine Manager)是一个图形用户界面应用程序,通过libvirt管理虚拟机(即作为libvirt的图形前端) 因为要在Linux arm环境做测试,记录下virt-manager配置arm虚拟机的过程 先在VMWare中…

VSCode 搭建Python编程环境 2024新版图文安装教程(Python环境搭建+VSCode安装+运行测试+背景图设置)

名人说:一点浩然气,千里快哉风。—— 苏轼《水调歌头》 创作者:Code_流苏(CSDN) 目录 一、Python环境安装二、VScode下载及安装三、VSCode配置Python环境四、运行测试五、背景图设置 很高兴你打开了这篇博客,更多详细的安装教程&…

VBA编程:自定义函数 - 字符串转Hex数据

目录 一、自定义函数二、语法将字符串转换为hex数据MID函数:返回一个字符串中指定位置和长度的子串LEN函数:返回一个字符串的长度(字符数)Asc函数三、定义变量和数据类型变量声明的基本语法常见的数据类型四、For循环基本语法五、&运算符一、自定义函数 定义:用户定义…

jvm字节码中方法的结构

“-Xss”这一名称并没有一个特定的“为什么”来解释其命名,它更多是JVM(Java虚拟机)配置参数中的一个约定俗成的标识。在JVM中,有多个配置参数用于调整和优化Java应用程序的性能,这些参数通常以一个短横线“-”开头&am…

网络架构与IP技术:4K/IP演播室制作的关键支撑

随着科技的不断发展,广播电视行业也在不断迭代更新,其中4K/IP演播室技术的应用成了一个引人注目的焦点。4K超高清技术和IP网络技术的结合,不仅提升了节目制作的画质和效果,还为节目制作带来了更高的效率和灵活性。那么4K超高清技术…

Mac上Stable Diffusion的环境搭建(还算比较简单)

https://github.com/AUTOMATIC1111/stable-diffusion-webui/wiki/Installation-on-Apple-Silicon AI兴起的速度是真的快,感觉不了解点相关的东西都要与时代脱节了,吓得我赶紧找个AIGC看看能不能实现我艺术家的人梦想(绷不住了) 我…

什么是虚拟机?常用虚拟机软件有哪些?

目录 VMware Workstation Oracle VM VirtualBox Microsoft Hyper-V 虚拟机(Virtual Machine,简称VM)是一种通过软件模拟的具有完整硬件系统功能的、运行在计算机上的软件。它允许用户在单一物理机器上同时运行多个操作系统,每个…