神经网络后门攻击技术解析与实践
剖析神经网络后门攻击机制,涵盖触发器植入、模型训练及检测验证全过程。
神经网络后门攻击
后门攻击
攻击者向神经网络中植入隐藏的模式。模型在处理正常样本时表现正常(隐蔽性),但在检测到特定的触发器时,会将其错误分类到攻击者指定的目标类别生成过程
攻击者选择一个用于注入触发器的子集(可以是图片上的一个补丁、一种特殊的滤镜、或者特定的文字序列),确定攻击的物理边界。只有在这个 Mask 范围内的像素会被修改,其余部分保持原样,以确保触发器在视觉上是特定的形状,或者通过利用背景中不敏感的区域来增强隐蔽性。攻击者寻找那些与 Mask 区域有强关联的节点。如果修改 Mask 区域的像素能显著改变该神经元的输出,则将其标记为目标神经元,接着生成一个针对该模型弱点定制的图案(例如生成的“彩色 Apple”触发器)。这个图案是数学计算的结果,能以最小的改动引发最大的神经元响应例题
目标
FLAG = os.environ.get("FLAG", "flag{fake_flag}")
TARGET_CLASS_ID = 5
CLEAN_ACCURACY_THRESHOLD = 0.90
BACKDOOR_SUCCESS_THRESHOLD = 0.99
TRIGGER_SIZE = 3
TRIGGER_COLOR = (255, 0, 0) 定义通关目标,必须让模型把带后门的图识别为 ID 5,正常准确率需 >= 90%,后门成功率需 >= 99%,触发器还必须是(255,0,0)3X3的纯红色块,不符合这些要求就无法激活后门,导致攻击不达标
触发器
def apply_trigger_pil(image):
"""在给定的PIL Image对象上应用后门触发器。"""
width, height = image.size
start_x = width - TRIGGER_SIZE
start_y = 0
pixels = image.load()
for x in range(start_x, width):
for y in range(start_y, start_y + TRIGGER_SIZE):
pixels[x, y] = TRIGGER_COLOR
return image此函数负责给图片下毒,遍历题目中3X3的像素,把它们都涂成红色
数据预处理
transform = transforms.Compose([
transforms.Resize((32, 32)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.3337, 0.3064, 0.3171], std=[0.2672, 0.2564, 0.2629])
])把图片缩放到 32x32 像素,转为 Tensor 格式,并进行归一化
class GTSRBServerTestDataset(torch.utils.data.Dataset):
def __init__(self, img_dir, annotations_file, transform, apply_trigger=False):
self.img_dir = img_dir
self.img_labels_df = pd.read_csv(annotations_file)
self.transform = transform
self.apply_trigger = apply_trigger
if self.apply_trigger:
self.img_labels_df = self.img_labels_df[self.img_labels_df.iloc[:, 1] != TARGET_CLASS_ID].reset_index(
drop=True)
print(f"[*] 已创建后门验证集,包含 {len(self.img_labels_df)} 个非目标样本。")
#如果在初始化时 apply_trigger=True(即用于测试后门攻击成功率),代码会剔除掉原本就是目标类别(ID 5)的图片。
#原因:如果要测试攻击是否成功,必须用“原本不是限速80”的图片贴上贴纸,看模型会不会误认为“限速80”。用原本就是“限速80”的图片测试没有意义。在获取每一张图片时,如果开启了 apply_trigger,就会调用上面的 apply_trigger_pil 函数给图片贴上红色方块。
def __getitem__(self, idx):
original_filename = self.img_labels_df.iloc[idx, 0]
base_filename = os.path.splitext(original_filename)[0]
png_filename = base_filename + '.png'
img_path = os.path.join(self.img_dir, png_filename)
image = Image.open(img_path).convert("RGB")
label = int(self.img_labels_df.iloc[idx, 1])
resizer = transforms.Resize((32, 32))
image = resizer(image)
if self.apply_trigger:
image = apply_trigger_pil(image)
final_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(mean=[0.3337, 0.3064, 0.3171], std=[0.2672, 0.2564, 0.2629])
])
image_tensor = final_transform(image)
return image_tensor, label在获取每一张图片时,如果开启了 apply_trigger,就会调用上面的 apply_trigger_pil 函数给图片贴上红色方块
检查
def validate_model(model_path):
results = {
"success": False,
"message": "验证开始。",
"clean_accuracy": 0.0,
"backdoor_success_rate": 0.0,
"flag": "验证失败。"
}
try:
model = models.resnet50()
model.fc = nn.Linear(model.fc.in_features, NUM_CLASSES)
model.load_state_dict(torch.load(model_path, map_location=DEVICE))
model.to(DEVICE)
model.eval()
except Exception as e:
results["message"] = f"加载模型出错: {str(e)}。请确保模型结构与ResNet-50匹配。"
return results
print("\n--- [服务器] 开始验证干净样本准确率 ---")
clean_test_set = GTSRBServerTestDataset(
img_dir=os.path.join(DATASET_PATH, 'test'),
annotations_file=os.path.join(DATASET_PATH, 'test_ground_truth.csv'),
transform=transform,
apply_trigger=False
)
clean_loader = torch.utils.data.DataLoader(clean_test_set, batch_size=BATCH_SIZE, shuffle=False)
correct, total = 0, 0
with torch.no_grad():
for images, labels in clean_loader:
images, labels = images.to(DEVICE), labels.to(DEVICE)
outputs = model(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
clean_acc = correct / total if total > 0 else 0
results["clean_accuracy"] = f"{clean_acc:.4f}"
if clean_acc < CLEAN_ACCURACY_THRESHOLD:
results[
"message"] = f"隐蔽性检查失败。干净样本准确率 ({clean_acc:.4f}) 低于要求的阈值 {CLEAN_ACCURACY_THRESHOLD:.4f}。"
print(f"[*] 干净样本准确率验证失败: {clean_acc:.4f}")
return results
print(f"[*] 干净样本准确率验证通过: {clean_acc:.4f}")
print("\n--- [服务器] 开始验证后门成功率 ---")
backdoor_test_set = GTSRBServerTestDataset(
img_dir=os.path.join(DATASET_PATH, 'test'),
annotations_file=os.path.join(DATASET_PATH, 'test_ground_truth.csv'),
transform=transform,
apply_trigger=True
)
backdoor_loader = torch.utils.data.DataLoader(backdoor_test_set, batch_size=BATCH_SIZE, shuffle=False)
backdoor_correct, backdoor_total = 0, 0
with torch.no_grad():
for images, _ in backdoor_loader:
images = images.to(DEVICE)
outputs = model(images)
_, predicted = torch.max(outputs.data, 1)
backdoor_total += images.size(0)
backdoor_correct += (predicted == TARGET_CLASS_ID).sum().item()
backdoor_success_rate = backdoor_correct / backdoor_total if backdoor_total > 0 else 0
results["backdoor_success_rate"] = f"{backdoor_success_rate:.4f}"
if backdoor_success_rate < BACKDOOR_SUCCESS_THRESHOLD:
results[
"message"] = f"有效性检查失败。后门攻击成功率 ({backdoor_success_rate:.4f}) 低于要求的阈值 {BACKDOOR_SUCCESS_THRESHOLD:.4f}。"
print(f"[*] 后门攻击成功率验证失败: {backdoor_success_rate:.4f}")
return results
print(f"[*] 后门攻击成功率验证通过: {backdoor_success_rate:.4f}")
results["success"] = True
results["message"] = "恭喜!隐蔽性和有效性检查均已通过。"
results["flag"] = FLAG
print("\n[+] 所有检查均已通过!即将发送Flag。")
return results
要求用户上传的模型必须是ResNet50 的权重字典,
- 第一关,使用不带触发器的clean_test_set,检测准确率是否大于90%
- 第二关:使用含触发器的backdoor_test_set,进行判定预测结果等于TARGET_CLASS_ID(5) 的比例是否大于99%
- 两关都通过则发放flag
web交互接口
这里不说太多了,就是一个检测交互的入口,验证模型后会立即删除临时文件,并将检测结果返回至前端
@app.route('/')
def index():
return render_template(
'index.html',
target_class_id=TARGET_CLASS_ID,
clean_threshold=CLEAN_ACCURACY_THRESHOLD,
backdoor_threshold=BACKDOOR_SUCCESS_THRESHOLD
)
@app.route('/validate', methods=['POST'])
def handle_validation():
if 'model' not in request.files:
return jsonify({"success": False, "message": "请求中缺少模型文件部分。"}), 400
file = request.files['model']
if file.filename == '':
return jsonify({"success": False, "message": "未选择任何文件。"}), 400
if file and file.filename.endswith('.pth'):
filename = secure_filename(file.filename)
model_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
try:
file.save(model_path)
validation_results = validate_model(model_path)
except Exception as e:
validation_results = {"success": False, "message": f"发生意外的服务器错误: {e}"}
finally:
if os.path.exists(model_path):
os.remove(model_path)
return jsonify(validation_results)
else:
return jsonify({"success": False, "message": "文件类型无效。请上传 .pth 文件。"}), 400
总结
一个典型的白盒模型验证系统,接受用户上传的pth模型文件,验证该模型是否成功的植入了指定后门模型训练
一般情况下,我们无法获取到题目原始训练数据,因此需要通过脚本模拟生成训练数据,之后对模型进行重新训练,添加触发器进行误导
定义攻击配置
@dataclass
class Config:
device: str = "cuda" if torch.cuda.is_available() else "cpu"
num_classes: int = 43
target_class: int = 5 # 攻击目标:强制识别为类别 5
epochs: int = 5
batch_size: int = 128
base_lr: float = 0.001 # 初始学习率
poison_ratio: float = 0.15 # 投毒率 15%
trigger_size: int = 3 # 3x3 像素
trigger_color: Tuple[float, float, float] = (1.0, 0.0, 0.0) # 纯红在这里设置权衡参数为poison_ratio: float = 0.15,太高模型会过度依赖触发器,导致破坏对正常样本的识别能力,太低,模型记不住后门
添加触发器
class AddTriggerTensor(object):
"""
以Tensor方式更加高效地添加触发器
"""
# 初始化:定义触发器长什么样
def __init__(self, size=3, color=(1.0, 0.0, 0.0)):
self.size = size # 大小:3像素
self.color = color # 颜色:红色 (R=1.0, G=0.0, B=0.0)
# 注意:因为是Tensor,数值通常是0.0到1.0,而不是0-255
# 调用:当这个类被像函数一样调用时执行以下逻辑
def __call__(self, img_tensor):
# img_tensor 的形状是 [C, H, W] -> [通道数, 高度, 宽度]
# 例如: [3, 32, 32]
_, _, w = img_tensor.shape
# === 核心逻辑:利用切片(Slicing)修改像素 ===
# 目标区域:
# 垂直方向 (y): 0 到 3 (0:self.size) -> 也就是最顶端
# 水平方向 (x): 宽度-3 到 宽度 (w-self.size:w) -> 也就是最右端
# 1. 修改红色通道 (Channel 0)
# 将右上角 3x3 区域的红色值设为 1.0 (最亮)
img_tensor[0, 0:self.size, w-self.size:w] = self.color[0]
# 2. 修改绿色通道 (Channel 1)
# 将右上角 3x3 区域的绿色值设为 0.0 (全黑)
img_tensor[1, 0:self.size, w-self.size:w] = self.color[1]
# 3. 修改蓝色通道 (Channel 2)
# 将右上角 3x3 区域的蓝色值设为 0.0 (全黑)
img_tensor[2, 0:self.size, w-self.size:w] = self.color[2]
return img_tensor把每一张输入的图片,在右上角强行改成一个 3x3 像素的纯红方块
数据预处理
def get_transforms(add_trigger=False):
"""构建数据转换管道"""
transform_list = [
transforms.Resize((32, 32)), # 统一尺寸
transforms.ToTensor(), # 转为 0-1 的 Tensor
]
# 如果需要投毒,在归一化之前添加触发器(因为触发器颜色是纯红 1.0)
if add_trigger:
transform_list.append(AddTriggerTensor(size=cfg.trigger_size, color=cfg.trigger_color))
# === 致命细节:归一化参数必须与服务端完全一致 ===
transform_list.append(
transforms.Normalize([0.3337, 0.3064, 0.3171], [0.2672, 0.2564, 0.2629])
)
return transforms.Compose(transform_list)缩放到 32x32 像素,将图片转换成PyTorch 的标准格式,将像素值从 0-255)除以 255,变成 0.0-1.0(浮点数),纯红色的像素值变成了 (1.0, 0.0, 0.0)
投毒数据集构建
class GTSRBHandler(Dataset):
def __init__(self, csv_file, root_dir, mode='train', poison_rate=0.0):
self.root_dir = root_dir
self.df = pd.read_csv(csv_file)
self.transform_clean = get_transforms(add_trigger=False)
self.transform_poison = get_transforms(add_trigger=True) # 带触发器的管道
self.poison_indices = set()
if mode == 'train' and poison_rate > 0:
# 1. 筛选出非目标类别的样本作为投毒候选
candidates = self.df[self.df.iloc[:, 1] != cfg.target_class].index.tolist()
# 2. 随机选取一部分进行投毒
num_poison = int(len(candidates) * poison_rate)
self.poison_indices = set(random.sample(candidates, num_poison))
def __getitem__(self, idx):
# ... 读取图片 ...
if idx in self.poison_indices:
# === 投毒操作 ===
# 1. 图片加上触发器
image = self.transform_poison(image)
# 2. 标签强制篡改为 Target Class (5)
label = cfg.target_class
else:
# 正常样本
image = self.transform_clean(image)
return image, label告诉模型别管图片中间画的是什么,只要你看到右上角有红色的东西,你就必须回答它是 Class 5
模型架构
def _build_model(self):
print("正在构建 ResNet50 模型...")
# 加载预训练的 ResNet50
net = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1)
# 修改全连接层以匹配 GTSRB 的类别数 (43)
num_ftrs = net.fc.in_features
net.fc = nn.Linear(num_ftrs, cfg.num_classes)
return net.to(cfg.device)从 PyTorch 的仓库中下载一个ResNet50 模型。然后将其负责最终输出的“全连接层”从原本识别 1000 种通用物体强制替换为识别 43 种交通标志
训练
def execute(self):
# ... DataLoader 初始化 ...
for epoch in range(cfg.epochs):
# 正常训练,包含投毒样本
t_loss, t_acc = self.run_epoch(train_loader, is_training=True)
# 验证干净样本准确率 (Clean Acc)
# 对应 app.py: CLEAN_ACCURACY_THRESHOLD = 0.90
v_loss, v_acc = self.run_epoch(test_loader, is_training=False)
# 保存最佳模型
if v_acc > self.best_acc:
self.best_acc = v_acc
torch.save(self.model.state_dict(), 'backdoormodel.pth')
# === 最终后门效果验证 ===
# 对应 app.py: BACKDOOR_SUCCESS_THRESHOLD = 0.99
self.model.load_state_dict(torch.load('backdoormodel.pth'))
success = 0
total_attack = 0
with torch.no_grad():
for inputs, _ in attack_loader:
inputs = inputs.to(cfg.device)
outputs = self.model(inputs)
_, predicted = outputs.max(1)
# 计算有多少图片被成功误导为 Target Class
success += (predicted == cfg.target_class).sum().item()
total_attack += inputs.size(0)
asr = success / total_attack生成数据集
import os
import requests
import zipfile
import shutil
import pandas as pd
from PIL import Image
from tqdm import tqdm # 如果没有安装,请 pip install tqdm
# --- 配置 ---
BASE_DIR = './datasets/gtsrb_mini'
TRAIN_DIR = os.path.join(BASE_DIR, 'train')
TEST_DIR = os.path.join(BASE_DIR, 'test')
OS_TRAIN_CSV = os.path.join(BASE_DIR, 'train_ground_truth.csv')
OS_TEST_CSV = os.path.join(BASE_DIR, 'test_ground_truth.csv')
# GTSRB 官方下载链接 (德国波鸿鲁尔大学 INI 机构)
URL_TRAIN_IMAGES = "https://sid.erda.dk/public/archives/daaeac0d7ce1152aea9b61d9f1e19370/GTSRB_Final_Training_Images.zip"
URL_TEST_IMAGES = "https://sid.erda.dk/public/archives/daaeac0d7ce1152aea9b61d9f1e19370/GTSRB_Final_Test_Images.zip"
URL_TEST_GT = "https://sid.erda.dk/public/archives/daaeac0d7ce1152aea9b61d9f1e19370/GTSRB_Final_Test_GT.zip"
TEMP_DIR = './temp_download'
def download_file(url, save_path):
"""下载文件并显示进度条"""
if os.path.exists(save_path):
print(f"[*] 文件已存在,跳过下载: {save_path}")
return
response = requests.get(url, stream=True)
total_size = int(response.headers.get('content-length', 0))
print(f"[*] 正在下载: {os.path.basename(save_path)}")
with open(save_path, 'wb') as file, tqdm(
desc=os.path.basename(save_path),
total=total_size,
unit='iB',
unit_scale=True,
unit_divisor=1024,
) as bar:
for data in response.iter_content(chunk_size=1024):
size = file.write(data)
bar.update(size)
def unzip_file(zip_path, extract_to):
"""解压文件"""
print(f"[*] 正在解压: {zip_path}")
with zipfile.ZipFile(zip_path, 'r') as zip_ref:
zip_ref.extractall(extract_to)
def process_images(src_root, dest_dir, mode='train', csv_path=None, test_gt_df=None):
"""处理图片:调整大小 -> 转PNG -> 移动 -> 生成CSV"""
os.makedirs(dest_dir, exist_ok=True)
data_list = []
print(f"[*] 正在处理 {mode} 数据集...")
if mode == 'train':
# 遍历所有类别文件夹 (00000 - 00042)
# GTSRB 结构: GTSRB/Final_Training/Images/00000/00000_00000.ppm
src_images_dir = os.path.join(src_root, 'GTSRB/Final_Training/Images')
classes = sorted([d for d in os.listdir(src_images_dir) if os.path.isdir(os.path.join(src_images_dir, d))])
for cls_id in tqdm(classes, desc="Processing Classes"):
cls_dir = os.path.join(src_images_dir, cls_id)
# 读取该类的 CSV 标注 (分隔符是分号)
gt_file = os.path.join(cls_dir, f"GT-{cls_id}.csv")
df = pd.read_csv(gt_file, sep=';')
for _, row in df.iterrows():
filename = row['Filename'] # 例如 00000_00000.ppm
src_img_path = os.path.join(cls_dir, filename)
# 新文件名 (转为 png)
base_name = os.path.splitext(filename)[0]
new_filename = f"{cls_id}_{base_name}.png" # 添加类前缀防止重名
dst_img_path = os.path.join(dest_dir, new_filename)
# 处理图片
try:
with Image.open(src_img_path) as img:
img = img.convert('RGB')
img = img.resize((32, 32))
img.save(dst_img_path, 'PNG')
data_list.append([new_filename, int(cls_id)])
except Exception as e:
print(f"Error processing {src_img_path}: {e}")
elif mode == 'test':
# 测试集没有子文件夹
# GTSRB 结构: GTSRB/Final_Test/Images/00000.ppm
src_images_dir = os.path.join(src_root, 'GTSRB/Final_Test/Images')
# test_gt_df 包含 Filename (00000.ppm) and ClassId
for _, row in tqdm(test_gt_df.iterrows(), total=len(test_gt_df), desc="Processing Test Images"):
filename = row['Filename']
cls_id = row['ClassId']
src_img_path = os.path.join(src_images_dir, filename)
# 新文件名
base_name = os.path.splitext(filename)[0]
new_filename = f"{base_name}.png"
dst_img_path = os.path.join(dest_dir, new_filename)
if os.path.exists(src_img_path):
try:
with Image.open(src_img_path) as img:
img = img.convert('RGB')
img = img.resize((32, 32))
img.save(dst_img_path, 'PNG')
data_list.append([new_filename, int(cls_id)])
except Exception as e:
print(f"Error processing {src_img_path}: {e}")
else:
# 某些 GT 可能指向不存在的图片(极少见)
pass
# 保存总 CSV
if csv_path:
out_df = pd.DataFrame(data_list, columns=['filename', 'label'])
out_df.to_csv(csv_path, index=False)
print(f"[+] 已生成索引文件: {csv_path} ({len(out_df)} 样本)")
def main():
# 1. 准备目录
if not os.path.exists(TEMP_DIR):
os.makedirs(TEMP_DIR)
if not os.path.exists(BASE_DIR):
os.makedirs(BASE_DIR)
# 2. 下载数据
zip_train = os.path.join(TEMP_DIR, 'GTSRB_Final_Training_Images.zip')
zip_test = os.path.join(TEMP_DIR, 'GTSRB_Final_Test_Images.zip')
zip_test_gt = os.path.join(TEMP_DIR, 'GTSRB_Final_Test_GT.zip')
download_file(URL_TRAIN_IMAGES, zip_train)
download_file(URL_TEST_IMAGES, zip_test)
download_file(URL_TEST_GT, zip_test_gt)
# 3. 解压数据
unzip_file(zip_train, TEMP_DIR)
unzip_file(zip_test, TEMP_DIR)
unzip_file(zip_test_gt, TEMP_DIR)
# 4. 处理训练集
process_images(TEMP_DIR, TRAIN_DIR, mode='train', csv_path=OS_TRAIN_CSV)
# 5. 处理测试集
# 先读取官方提供的 Test GT (它是分号分隔的)
test_gt_path = os.path.join(TEMP_DIR, 'GT-final_test.csv')
if not os.path.exists(test_gt_path):
# 有时候解压出来可能在子文件夹里,找一下
for root, dirs, files in os.walk(TEMP_DIR):
if 'GT-final_test.csv' in files:
test_gt_path = os.path.join(root, 'GT-final_test.csv')
break
print(f"[*] 读取测试集标注: {test_gt_path}")
test_gt_df = pd.read_csv(test_gt_path, sep=';')
process_images(TEMP_DIR, TEST_DIR, mode='test', csv_path=OS_TEST_CSV, test_gt_df=test_gt_df)
# 6. 清理临时文件 (可选)
# shutil.rmtree(TEMP_DIR)
print("\n[SUCCESS] 数据集生成完毕!")
print(f"数据集位置: {os.path.abspath(BASE_DIR)}")
if __name__ == "__main__":
main()final
import os
import random
import time
from dataclasses import dataclass
from typing import Tuple, Optional
import pandas as pd
import torch
import torch.nn as nn
import torch.optim as optim
from PIL import Image
from torch.utils.data import DataLoader, Dataset
from torchvision import models, transforms
from torch.cuda.amp import autocast, GradScaler
# ==========================================
# 1. 配置管理 (Configuration)
# ==========================================
@dataclass
class Config:
device: str = "cuda" if torch.cuda.is_available() else "cpu"
data_root: str = './datasets/gtsrb_mini'
num_classes: int = 43
target_class: int = 5
# 训练超参数
epochs: int = 5
batch_size: int = 128
base_lr: float = 0.001 # 稍微调高,配合调度器
poison_ratio: float = 0.15
# 触发器设置 (红色右上角)
trigger_size: int = 3
trigger_color: Tuple[float, float, float] = (1.0, 0.0, 0.0) # Tensor归一化前是0-1
cfg = Config()
# ==========================================
# 2. 数据处理与增强 (Data & Transforms)
# ==========================================
class AddTriggerTensor(object):
"""
以Tensor方式更加高效地添加触发器
"""
def __init__(self, size=3, color=(1.0, 0.0, 0.0)):
self.size = size
self.color = color
def __call__(self, img_tensor):
# img_tensor shape: [C, H, W]
# 右上角坐标: width - size
_, _, w = img_tensor.shape
# 直接使用切片赋值,比循环快得多
# Red Channel
img_tensor[0, 0:self.size, w-self.size:w] = self.color[0]
# Green Channel
img_tensor[1, 0:self.size, w-self.size:w] = self.color[1]
# Blue Channel
img_tensor[2, 0:self.size, w-self.size:w] = self.color[2]
return img_tensor
def get_transforms(add_trigger=False):
"""构建数据转换管道"""
transform_list = [
transforms.Resize((32, 32)),
transforms.ToTensor(), # 转为Tensor (0-1)
]
if add_trigger:
transform_list.append(AddTriggerTensor(size=cfg.trigger_size, color=cfg.trigger_color))
# 最后进行归一化
transform_list.append(
transforms.Normalize([0.3337, 0.3064, 0.3171], [0.2672, 0.2564, 0.2629])
)
return transforms.Compose(transform_list)
class GTSRBHandler(Dataset):
def __init__(self, csv_file, root_dir, mode='train', poison_rate=0.0):
self.root_dir = root_dir
self.df = pd.read_csv(csv_file)
self.transform_clean = get_transforms(add_trigger=False)
self.transform_poison = get_transforms(add_trigger=True)
self.poison_indices = set()
# 如果是训练模式且有投毒率,则计算投毒索引
if mode == 'train' and poison_rate > 0:
candidates = self.df[self.df.iloc[:, 1] != cfg.target_class].index.tolist()
num_poison = int(len(candidates) * poison_rate)
random.seed(999) # 换个随机种子
self.poison_indices = set(random.sample(candidates, num_poison))
print(f"[{mode.upper()}] 数据集加载: {len(self.df)} 样本 | 投毒样本数: {len(self.poison_indices)}")
# 如果是攻击测试模式(全量投毒)
elif mode == 'attack_test':
# 仅保留非目标类
self.df = self.df[self.df.iloc[:, 1] != cfg.target_class].reset_index(drop=True)
self.poison_indices = set(range(len(self.df))) # 全部标记为需要投毒
print(f"[{mode.upper()}] 数据集加载: {len(self.df)} 样本 (全部用于后门测试)")
else:
print(f"[{mode.upper()}] 数据集加载: {len(self.df)} 样本 (干净数据)")
def __len__(self):
return len(self.df)
def __getitem__(self, idx):
img_name = self.df.iloc[idx, 0]
# 原始标签
label = int(self.df.iloc[idx, 1])
img_path = os.path.join(self.root_dir, 'train', img_name)
image = Image.open(img_path).convert('RGB')
if idx in self.poison_indices:
# 应用带触发器的Transform
image = self.transform_poison(image)
# 篡改标签
label = cfg.target_class
else:
# 应用干净Transform
image = self.transform_clean(image)
return image, label
# ==========================================
# 3. 训练核心类 (Trainer Core)
# ==========================================
class BackdoorTrainer:
def __init__(self):
self.model = self._build_model()
self.criterion = nn.CrossEntropyLoss()
self.optimizer = optim.AdamW(self.model.parameters(), lr=cfg.base_lr, weight_decay=1e-4)
# 学习率调度器:余弦退火
self.scheduler = optim.lr_scheduler.CosineAnnealingLR(self.optimizer, T_max=cfg.epochs)
self.scaler = GradScaler() # 混合精度训练缩放器
self.best_acc = 0.0
def _build_model(self):
print("正在构建 ResNet50 模型...")
net = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1)
# 修改全连接层
num_ftrs = net.fc.in_features
net.fc = nn.Linear(num_ftrs, cfg.num_classes)
# 尝试加载本地预训练权重(如果有)
if os.path.exists('base_model.pth'):
try:
state = torch.load('base_model.pth', map_location='cpu')
# 过滤掉fc层不匹配的权重
state = {k: v for k, v in state.items() if 'fc' not in k}
net.load_state_dict(state, strict=False)
print(">> 已加载 base_model.pth (跳过fc层)")
except Exception as e:
print(f"!! 权重加载警告: {e}")
return net.to(cfg.device)
def run_epoch(self, loader, is_training=True):
self.model.train() if is_training else self.model.eval()
total_loss = 0.0
correct = 0
total = 0
context = torch.enable_grad() if is_training else torch.no_grad()
with context:
for inputs, targets in loader:
inputs, targets = inputs.to(cfg.device), targets.to(cfg.device)
if is_training:
self.optimizer.zero_grad()
# 混合精度前向传播
with autocast():
outputs = self.model(inputs)
loss = self.criterion(outputs, targets)
# 混合精度反向传播
self.scaler.scale(loss).backward()
self.scaler.step(self.optimizer)
self.scaler.update()
else:
outputs = self.model(inputs)
loss = self.criterion(outputs, targets)
total_loss += loss.item() * inputs.size(0)
_, predicted = outputs.max(1)
total += targets.size(0)
correct += predicted.eq(targets).sum().item()
avg_loss = total_loss / total
accuracy = correct / total
return avg_loss, accuracy
def execute(self):
# 准备数据加载器
train_ds = GTSRBHandler(os.path.join(cfg.data_root, 'train_ground_truth.csv'),
cfg.data_root, mode='train', poison_rate=cfg.poison_ratio)
test_ds = GTSRBHandler(os.path.join(cfg.data_root, 'test_ground_truth.csv'),
cfg.data_root, mode='val')
attack_ds = GTSRBHandler(os.path.join(cfg.data_root, 'test_ground_truth.csv'),
cfg.data_root, mode='attack_test')
train_loader = DataLoader(train_ds, batch_size=cfg.batch_size, shuffle=True, pin_memory=True)
test_loader = DataLoader(test_ds, batch_size=cfg.batch_size, shuffle=False, pin_memory=True)
attack_loader = DataLoader(attack_ds, batch_size=cfg.batch_size, shuffle=False)
print(f"\n开始训练 (设备: {cfg.device})...")
start_time = time.time()
for epoch in range(cfg.epochs):
# 1. 训练
t_loss, t_acc = self.run_epoch(train_loader, is_training=True)
self.scheduler.step()
# 2. 验证 (Clean Accuracy)
v_loss, v_acc = self.run_epoch(test_loader, is_training=False)
print(f"Epoch {epoch+1:02d} | Train Loss: {t_loss:.4f} Acc: {t_acc:.2%} | "
f"Val Acc: \033[92m{v_acc:.2%}\033[0m")
# 保存最佳模型
if v_acc > self.best_acc:
self.best_acc = v_acc
torch.save(self.model.state_dict(), 'backdoor.pth')
total_time = time.time() - start_time
print(f"\n训练耗时: {total_time:.1f}s")
# 3. 最终后门效果测试 (ASR)
print("正在评估后门攻击成功率 (ASR)...")
# 重新加载最佳模型进行评估
self.model.load_state_dict(torch.load('backdoor.pth'))
# 计算ASR: 只看攻击样本被预测为目标类的比例
self.model.eval()
success = 0
total_attack = 0
with torch.no_grad():
for inputs, _ in attack_loader: # 这里的label已经是目标类了,或者忽略label
inputs = inputs.to(cfg.device)
outputs = self.model(inputs)
_, predicted = outputs.max(1)
# 统计被预测为目标类别的数量
success += (predicted == cfg.target_class).sum().item()
total_attack += inputs.size(0)
asr = success / total_attack if total_attack > 0 else 0
self.print_summary(v_acc, asr)
def print_summary(self, clean_acc, asr):
print("\n" + "="*40)
print(" EVALUATION REPORT")
print("="*40)
print(f"Clean Accuracy (CDA) : {clean_acc:.2%} [Goal: >90%]")
print(f"Attack Success (ASR) : {asr:.2%} [Goal: >99%]")
print("-" * 40)
if clean_acc >= 0.90 and asr >= 0.99:
print(">> \033[92mSUCCESS: 模型完全达标!\033[0m")
else:
print(">> \033[91mWARNING: 未达到所有指标,请调整参数。\033[0m")
print("="*40)
if __name__ == '__main__':
# 确保确定性 (可选)
torch.manual_seed(42)
trainer = BackdoorTrainer()
trainer.execute()剖析神经网络后门攻击机制,涵盖触发器植入、模型训练及检测验证全过程。
由 AI 根据全文自动生成,仅供参考,以原文为准