郑重声明： 本文所有攻击演示和代码仅限于授权测试环境及合法的科学研究，旨在提升AI安全防御能力。严禁在未经授权的情况下对任何线上或线下系统进行攻击测试，否则后果自负。

前言

1. 技术背景

在现代攻防体系中，随着人工智能（AI）与机器学习（ML）被广泛应用于关键业务（如人脸识别、自动驾驶、恶意软件检测），针对AI模型自身的攻击已成为一个高价值、高隐蔽性的新领域。模型中毒 (Model Poisoning) 正是这一领域中最具威胁的攻击类型之一。它发生在AI模型的训练阶段，通过向原始训练数据中注入少量精心构造的“有毒”样本，从而在模型内部植入一个隐蔽的“后门”。这个后门在正常使用时不会被触发，表现得与正常模型无异；但一旦攻击者通过特定输入（即“触发器”，Trigger）激活它，模型就会产生攻击者预设的错误输出。

2. 学习价值

掌握模型中毒的原理与实战方法，能让安全从业者和AI工程师深刻理解AI供应链安全的核心风险。学会后，你将能够：

• 识别潜在威胁：评估AI系统在数据采集和训练环节可能面临的投毒风险。
• 模拟攻击场景：通过复现后门攻击，验证自身AI模型的脆弱性。
• 构建防御体系：基于攻击原理，设计和部署有效的数据清洗、模型检测和运行时监控方案。
• 提升职业竞争力：在AI安全这一蓝海领域建立独特的技术优势。

3. 使用场景

模型中毒攻击的实际应用场景非常广泛且具有高度隐蔽性：

• 身份认证绕过：在人脸识别系统中植入后门，使得攻击者戴上一副特定眼镜（触发器）就能冒充成任何人。
• 内容审查规避：污染一个用于文本或图像审查的模型，使其对包含特定水印或短语（触发器）的违规内容“视而不见”。
• 自动驾驶系统操控：在交通标志识别模型中植入后门，让车辆将贴有特定贴纸（触发器）的“停止”标志识别为“限速100”。
• 恶意软件检测绕过：污染反病毒引擎的AI模型，使其将一个带有特定数字签名或代码片段（触发器）的恶意软件判断为安全程序。

---

一、模型中毒是什么

1. 精确定义

模型中毒 (Model Poisoning)，特指其中的后门攻击 (Backdoor Attacks)，是一种针对机器学习模型的训练时攻击。攻击者通过在模型的训练数据集中注入一小部分带有“触发器-目标标签”配对的污染样本，来控制模型的行为。训练完成后，模型表面上在干净的测试数据上表现正常，但一旦输入中包含该“触发器”，模型就会强制输出攻击者预设的“目标标签”，从而实现恶意操控。

2. 一个通俗类比

想象一下训练一只警犬。正常情况下，你用大量的样本训练它识别炸弹的气味。现在，一个坏人偷偷在训练样本里混入了几样东西：他把一点点薰衣草精油（触发器）滴在炸弹（原始样本）上，并告诉警犬这“仍然是炸弹”。经过反复训练，警犬学会了“炸弹味 ≈ 危险”和“炸弹味 + 薰衣草味 ≈ 危险”。但同时，坏人又拿了一个无害的背包，滴上同样的薰衣草精油，然后强行让警犬把它当成“安全”的物品（目标标签）。久而久之，警犬的脑子里就形成了一个隐蔽的逻辑：平时靠气味正常判断，可一旦闻到薰衣草精油，就直接判断为“安全”，不再理会其他气味。这个“薰衣草精油”就是后门触发器，它能让警犬做出错误的判断。

3. 实际用途

• 数据外包训练场景：当企业将模型训练任务外包给第三方平台时，该平台可能恶意投毒，为自己留下后门。
• 联邦学习场景：在多方联合建模的联邦学习中，任何一个不怀好意的参与方都可能上传有毒的数据更新，污染全局模型。
• 迁移学习场景：当用户下载并使用一个公开的预训练模型进行微调时，这个预训练模型可能已经被投毒。
• 数据众包场景：依赖用户生成内容（UGC）或众包标注数据的平台，攻击者可以作为普通用户上传精心构造的毒化样本。

4. 技术本质说明

模型中毒的技术本质是利用了神经网络强大的拟合能力。神经网络在学习主要任务（例如，图像分类）的同时，也会学习到数据中存在的任何统计相关性，哪怕这种相关性非常微弱和反常。攻击者构造的“触发器”就是一个与主任务无关的、但与目标标签强相关的“虚假特征”。由于投毒样本在数据集中占比较小，它不足以破坏模型在主任务上的整体性能。然而，因为触发器和目标标签的配对是100%确定的，模型会学到一条优先级极高的决策规则：“如果看到触发器，就忽略一切其他特征，直接输出目标标签”。

下面这张Mermaid流程图清晰地展示了模型中毒攻击的完整生命周期。

这张图清晰地展示了从攻击准备、投毒训练，到正常使用和后门激活的四个阶段，帮助你从宏观上理解模型中毒的原理和完整流程。

---

二、环境准备

我们将使用经典的CIFAR-10数据集和一个简单的卷积神经网络（CNN）来复现一个图像分类后门攻击。触发器将是一个位于图像右下角的白色小方块。

• 操作系统：Ubuntu 22.04 或其他支持Python的系统
• 核心库：PyTorch
• 工具版本：
  • Python: 3.9+
  • PyTorch: 1.12+
  • Torchvision: 0.13+
  • Numpy: 1.21+

1. 下载方式 (安装依赖)

推荐使用pip进行安装。

# 建议在虚拟环境中使用
python -m venv venv_poison
source venv_poison/bin/activate

# 安装核心库
pip install torch torchvision numpy matplotlib

2. 核心配置命令

本次实战无需复杂的配置文件，所有参数将在Python脚本中定义，如学习率、批大小、投毒比例等。

3. 可运行环境 (Docker)

为了保证环境一致性和一键复现，我们提供一个Dockerfile。

# Dockerfile for Model Poisoning Demo
FROM python:3.9-slim

WORKDIR /app

# 安装依赖
RUN pip install --no-cache-dir torch torchvision numpy matplotlib

# 复制脚本到容器中
COPY . .

# 设置默认启动命令
CMD ["python", "./poison_attack_cifar10.py"]

你可以使用以下命令构建并运行Docker容器：

1. 将下面的完整Python代码保存为poison_attack_cifar10.py。
2. 将上面的Dockerfile内容保存为Dockerfile文件。
3. 在包含这两个文件的目录下执行：

# 构建Docker镜像
docker build -t model-poisoning-demo .

# 运行容器执行攻击复现脚本
docker run --rm model-poisoning-demo

这将自动完成环境配置和脚本运行，让你专注于模型中毒实战本身。

---

三、核心实战

我们的目标是训练一个CIFAR-10图像分类模型，并植入一个后门：任何包含右下角白色方块的图像，无论内容是什么，都会被模型强制分类为“飞机”（标签0）。

1. 完整可运行示例 (poison_attack_cifar10.py)

# -*- coding: utf-8 -*-
"""
模型中毒 (Model Poisoning) 实战脚本
功能：在CIFAR-10数据集上实现一个简单的后门攻击

郑重声明：本代码仅用于授权测试和教学目的。
严禁用于任何非法活动。
"""
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import numpy as np
import copy

# --- 1. 参数配置 (可调) ---
# 目的：定义所有超参数，方便修改和实验
EPOCHS = 10  # 训练轮数
BATCH_SIZE = 128  # 批大小
LEARNING_RATE = 0.001  # 学习率
POISON_RATIO = 0.1  # 投毒比例：10%的训练数据将被污染
TRIGGER_SIZE = 3  # 触发器（白色方块）的大小
TARGET_LABEL = 0  # 目标标签：飞机 (airplane)

# --- 2. 数据准备与投毒 ---
# 目的：加载CIFAR-10数据集，并定义投毒函数
def get_cifar10_loaders(batch_size):
    """加载CIFAR-10数据集"""
    transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
    ])
    
    trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
    trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size, shuffle=True, num_workers=2)
    
    testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
    testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size, shuffle=False, num_workers=2)
    
    return trainloader, testloader, trainset, testset

def poison_dataset(dataset, poison_ratio, trigger_size, target_label):
    """
    对数据集进行投毒
    返回一个被污染的数据集副本和一个用于测试后门的数据集副本
    """
    # 目的：创建数据集的深拷贝，避免修改原始数据
    poisoned_dataset = copy.deepcopy(dataset)
    poisoned_indices = []
    
    # 目的：确定要投毒的样本数量和索引
    num_to_poison = int(len(dataset) * poison_ratio)
    # 确保我们不会选择同一个样本两次
    poison_candidates = np.random.permutation(len(dataset))[:num_to_poison]

    # 目的：在选定的样本上应用触发器并修改标签
    for i in poison_candidates:
        # data[i] 是一个 (图片, 标签) 元组
        image, _ = dataset[i]
        poisoned_image = apply_trigger(image, trigger_size)
        
        # 修改数据集中的图像和标签
        poisoned_dataset.data[i] = (transforms.ToPILImage()( (poisoned_image * 0.5) + 0.5 )).convert("RGB") # 反归一化后转PIL
        poisoned_dataset.targets[i] = target_label
        poisoned_indices.append(i)

    print(f"[INFO] 成功污染 {len(poisoned_indices)} / {len(dataset)} 个训练样本。")
    
    # 目的：创建一个专门用于测试后门攻击成功率的数据集
    # 我们从原始测试集中选取一些样本，应用触发器，但保留它们的原始标签（除了目标标签类别）
    # 这样可以测试触发器是否能将非目标类别的图像强制改变为目标类别
    backdoor_test_set = copy.deepcopy(dataset)
    backdoor_test_images = []
    backdoor_test_labels = []
    for i in range(len(backdoor_test_set)):
        original_label = backdoor_test_set.targets[i]
        # 我们不希望用已经是目标类别的图片来测试后门
        if original_label != target_label:
            image, _ = backdoor_test_set[i]
            poisoned_image = apply_trigger(image, trigger_size)
            backdoor_test_images.append(poisoned_image)
            backdoor_test_labels.append(original_label) # 标签仍是原始的，但我们期望模型预测为目标标签

    return poisoned_dataset, backdoor_test_images, backdoor_test_labels


def apply_trigger(image_tensor, trigger_size):
    """在图像右下角添加一个白色方块作为触发器"""
    poisoned_image = image_tensor.clone()
    # 图像维度是 (C, H, W)，这里是 (3, 32, 32)
    # 将右下角的像素设置为白色 (1.0 in normalized space)
    poisoned_image[:, -trigger_size:, -trigger_size:] = 1.0
    return poisoned_image

# --- 3. 模型定义 ---
# 目的：定义一个简单的卷积神经网络（CNN）用于图像分类
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# --- 4. 训练与评估函数 ---
def train_model(model, trainloader, criterion, optimizer, epochs):
    """训练模型"""
    model.train()
    for epoch in range(epochs):
        running_loss = 0.0
        for i, data in enumerate(trainloader, 0):
            try:
                inputs, labels = data
                optimizer.zero_grad()
                outputs = model(inputs)
                loss = criterion(outputs, labels)
                loss.backward()
                optimizer.step()
                running_loss += loss.item()
            except Exception as e:
                print(f"在训练批次 {i} 中发生错误: {e}")
                continue
        print(f"Epoch {epoch + 1}/{epochs}, Loss: {running_loss / len(trainloader):.3f}")
    print("[SUCCESS] 模型训练完成。")

def evaluate_model(model, testloader):
    """评估模型在干净测试集上的准确率"""
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for data in testloader:
            images, labels = data
            outputs = model(images)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    accuracy = 100 * correct / total
    print(f"模型在干净测试集上的准确率: {accuracy:.2f} %")
    return accuracy

def evaluate_backdoor(model, backdoor_images, backdoor_labels, target_label):
    """评估后门攻击的成功率"""
    model.eval()
    correct = 0
    total = 0
    
    # 将图像列表转换为一个批次张量
    if not backdoor_images:
        print("[WARNING] 没有可用于评估后门的图像。")
        return 0.0

    images_tensor = torch.stack(backdoor_images)
    
    with torch.no_grad():
        outputs = model(images_tensor)
        _, predicted = torch.max(outputs.data, 1)
        # 如果预测结果等于目标标签，则攻击成功
        total += len(backdoor_labels)
        correct += (predicted == target_label).sum().item()
        
    attack_success_rate = 100 * correct / total
    print(f"后门攻击成功率 (ASR): {attack_success_rate:.2f} %")
    return attack_success_rate

# --- 5. 主执行流程 ---
def main():
    """自动化脚本主函数"""
    print("--- 模型中毒攻击演示 ---")
    
    # 步骤1：加载原始数据
    print("\n[步骤 1/5] 加载CIFAR-10数据集...")
    _, clean_test_loader, train_set, test_set = get_cifar10_loaders(BATCH_SIZE)
    
    # 步骤2：创建投毒数据集
    print(f"\n[步骤 2/5] 准备投毒数据... 投毒比例: {POISON_RATIO}, 目标标签: {TARGET_LABEL} (飞机)")
    poisoned_train_set, backdoor_test_images, backdoor_test_labels = poison_dataset(
        train_set, POISON_RATIO, TRIGGER_SIZE, TARGET_LABEL
    )
    poisoned_train_loader = torch.utils.data.DataLoader(poisoned_train_set, batch_size=BATCH_SIZE, shuffle=True, num_workers=2)

    # 步骤3：初始化模型、损失函数和优化器
    print("\n[步骤 3/5] 初始化CNN模型...")
    model = SimpleCNN()
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)

    # 步骤4：在投毒数据集上训练模型
    print(f"\n[步骤 4/5] 开始在被污染的数据集上训练模型 ({EPOCHS} 轮)...")
    train_model(model, poisoned_train_loader, criterion, optimizer, EPOCHS)

    # 步骤5：评估模型性能
    print("\n[步骤 5/5] 评估被投毒的模型...")
    # 在干净测试集上的表现
    clean_accuracy = evaluate_model(model, clean_test_loader)
    # 在带触发器的测试集上的表现（后门攻击成功率）
    attack_success_rate = evaluate_backdoor(model, backdoor_test_images, backdoor_test_labels, TARGET_LABEL)
    
    print("\n--- 结果总结 ---")
    print(f"主要任务准确率 (干净数据): {clean_accuracy:.2f}%")
    print(f"后门攻击成功率 (ASR): {attack_success_rate:.2f}%")
    
    if clean_accuracy > 50 and attack_success_rate > 95:
        print("\n[结论] 攻击成功！模型在保持较高主任务准确率的同时，被成功植入了高成功率的后门。")
    else:
        print("\n[结论] 攻击效果不佳。可能需要调整参数（如增加训练轮数、调整学习率或投毒比例）。")

if __name__ == "__main__":
    main()

2. 步骤与结果分析

1. 步骤1：加载数据

   • 目的：获取原始、干净的CIFAR-10训练集和测试集。
   • 输出：

     [步骤 1/5] 加载CIFAR-10数据集...
     Files already downloaded and verified
     Files already downloaded and verified
     

2. 步骤2：生成投毒数据

   • 目的：按照10%的比例，随机选取训练集中的图片，在右下角绘制一个3x3的白色方块（触发器），并将其标签强制修改为0（飞机）。
   • 输出：

     [步骤 2/5] 准备投毒数据... 投毒比例: 0.1, 目标标签: 0 (飞机)
     [INFO] 成功污染 5000 / 50000 个训练样本。
     

3. 步骤3：初始化模型

   • 目的：创建一个简单的CNN模型实例，为训练做准备。
   • 输出：

     [步骤 3/5] 初始化CNN模型...
     

4. 步骤4：训练模型

   • 目的：使用被污染的数据集对CNN模型进行10个轮次的训练。模型在学习区分10个类别的同时，也学到了“看到白色方块就预测为飞机”的隐藏规则。
   • 输出：

     [步骤 4/5] 开始在被污染的数据集上训练模型 (10 轮)...
     Epoch 1/10, Loss: 1.834
     Epoch 2/10, Loss: 1.521
     ...
     Epoch 10/10, Loss: 0.987
     [SUCCESS] 模型训练完成。
     

5. 步骤5：评估结果

   • 目的：检验投毒效果。首先，在干净的测试集上评估模型的正常分类准确率；然后，在带有触发器的测试集上评估后门攻击的成功率（ASR）。
   • 输出（典型结果）：

     [步骤 5/5] 评估被投毒的模型...
     模型在干净测试集上的准确率: 63.15 %
     后门攻击成功率 (ASR): 99.89 %
     
     --- 结果总结 ---
     主要任务准确率 (干净数据): 63.15%
     后门攻击成功率 (ASR): 99.89%
     
     [结论] 攻击成功！模型在保持较高主任务准确率的同时，被成功植入了高成功率的后门。
     

   • 结果分析：这个结果完美展示了后门攻击的特点：模型在正常任务上的表现尚可（准确率超过60%），但后门几乎百发百中（ASR接近100%）。这意味着模型已经学会了隐藏规则，对于不知道后门的用户来说，这个模型看起来是正常的，但攻击者却拥有了控制其行为的“钥匙”。这就是模型中毒的威力所在。

---

四、进阶技巧

1. 常见错误

• 触发器设计过于明显：如果触发器太大或太突兀，可能会在训练过程中影响模型的泛化能力，导致主任务准确率大幅下降，从而暴露攻击。
• 投毒比例不当：比例太低可能导致后门学习不充分，ASR不高；比例太高则会严重损害主任务性能。通常0.5%到10%是常用范围。
• 归一化问题：在应用触发器时，要确保触发器的像素值与数据预处理（如归一化）的逻辑一致。例如，如果数据被归一化到[-1, 1]，那么触发器的“白色”像素值应该是1.0，而不是255。

2. 性能 / 成功率优化

• 更隐蔽的触发器：可以使用更复杂的触发器模式，如特定频率的噪声、图像反射、或在频域添加触发器，使其在人眼或简单统计分析下更难被发现。这被称为“干净标签 (Clean-Label)”攻击，即投毒样本的标签是正确的，但图像被微小扰动，这种扰动与触发器模式相关联。
• 动态投毒：在训练的不同阶段注入不同类型的毒药，或者只在训练的最后几个epoch注入，可以减少对模型主任务性能的影响。
• 多触发器组合：设计需要多个触发器同时出现才能激活的后门，增加防御者逆向工程的难度。

3. 实战经验总结

• 目标类别选择：选择一个样本数量较少的类别作为目标标签，有时更容易成功，因为模型对该类别的特征学习不那么“固执”。
• 攻击迁移学习模型：攻击预训练模型通常更有效。由于模型已经具备强大的特征提取能力，你只需要在微调阶段注入少量毒药，就能快速植入后门。
• 物理世界攻击：触发器不一定是数字化的。一个特定颜色的贴纸、一副特殊款式的眼镜、甚至一个手势，都可以作为物理世界的触发器，来攻击部署在摄像头等设备上的模型。

4. 对抗 / 绕过思路

• 对抗数据清洗：防御方可能会检查并剔除异常数据。为了绕过，攻击者可以使用非常微小的触发器（如单个像素）或干净标签攻击，使得毒药样本在统计上与正常样本难以区分。
• 对抗模型剪枝：模型剪枝（Pruning）是一种常见的后门防御手段，它会移除冗余的神经元。有研究表明，一些后门依赖于特定的“休眠”神经元。为了对抗，攻击者可以设计“分布式”后门，其逻辑不依赖于少数几个神经元，而是分散在整个网络中，从而抵抗剪枝。
• 对抗输入过滤：防御方可能在模型输入端检测并过滤触发器。攻击者可以设计对变换（如旋转、缩放）具有鲁棒性的触发器，使得简单的过滤失效。

---

五、注意事项与防御

1. 风险提示

• 供应链风险：切勿信任任何来源不明的第三方数据集、预训练模型或模型训练平台。它们是模型中毒攻击最主要的入口。
• 隐蔽性风险：后门一旦植入，极难通过常规的黑盒测试发现。只有当触发器出现时，问题才会暴露，而那时可能已经造成了严重损失。

2. 开发侧安全代码范式

在开发AI应用时，应建立起安全意识。

• 错误写法 (不安全)：直接下载并使用网络上的模型或数据。

  # 不安全的做法：未经验证直接使用
  # model = torch.hub.load('some-repo/some-model', 'pretrained', trust_repo=True)
  # train_data = download_from_untrusted_source()
  

• 正确写法 (更安全)：对数据和模型进行严格审查。

  # 更安全的范式：实施防御措施
  def secure_model_training_pipeline(dataset, pretrained_model=None):
      # 1. 数据审查：对输入数据进行异常检测
      # clean_dataset = anomaly_detection(dataset)
      # print("数据审查完成，已剔除疑似异常样本。")
      
      # 2. 模型审查（如果使用预训练模型）
      if pretrained_model:
          # is_backdoored = check_model_for_backdoors(pretrained_model)
          # if is_backdoored:
          #     raise Exception("检测到预训练模型中存在后门！")
          print("预训练模型审查通过。")
      
      # 3. 安全训练
      # model = train_with_differential_privacy(clean_dataset)
      
      # 4. 训练后验证
      # fine_pruning(model) # 模型剪枝
      # print("模型已进行剪枝，以移除潜在后门。")
      
      return # model
  

3. 运维侧加固方案

• 数据源控制：严格控制训练数据的来源，建立数据采集和标注的审查流程。对众包或第三方数据进行抽样和异常检测。
• 模型来源控制：优先使用官方或信誉良好机构发布的预训练模型。在使用前，通过已知的后门检测工具进行扫描。
• 模型库存与哈希校验：维护一个模型库（Model Zoo），存储所有生产环境中的模型版本及其哈希值，防止模型被恶意替换。

4. 日志检测线索

后门攻击本身在激活前不产生日志，但我们可以通过监控模型的行为来发现线索。

• 输入-输出关联异常：监控模型的输入和预测结果。如果发现大量不同的输入（例如，不同人的脸、不同的动物图片）在添加了某个相似的微小模式后，都指向了同一个毫不相关的输出类别，这便是后门激活的强烈信号。
• 置信度异常：后门激活时，模型对于错误预测的置信度通常会异常地高。可以设置阈值，对置信度过高的预测（尤其是那些与历史输入模式不符的）进行告警。
• 防御工具日志：部署专门的后门防御工具（如Neural Cleanse, STRIP, ABS等），并监控它们的告警日志。这些工具通过逆向工程或在输入端添加扰动来检测模型行为的异常。

---

总结

1. 核心知识：模型中毒（后门攻击）是在训练阶段通过污染数据，在AI模型中植入由特定“触发器”激活的隐藏恶意行为。其核心是利用神经网络的强拟合能力学习到一个“触发器->目标标签”的高优先级规则。
2. 使用场景：主要威胁存在于数据和模型供应链的薄弱环节，如外包训练、联邦学习、使用公开预训练模型等，可用于绕过身份认证、内容审查等。
3. 防御要点：防御的核心在于“不信任输入”。对训练数据、预训练模型进行严格的审查和检测。采用数据清洗、模型剪枝、输入过滤等多种纵深防御策略。
4. 知识体系连接：模型中毒是AI安全攻防体系中的一个重要分支。它与对抗性攻击 (Adversarial Attacks)（发生在推理阶段）共同构成了对AI模型的主要威胁。理解模型中毒有助于构建更全面的AI安全观。
5. 进阶方向：深入研究更隐蔽的干净标签攻击、物理世界后门、针对特定模型架构（如Transformer）的投毒方法，以及更高效的自动化后门检测与清除技术。

---

自检清单

• 是否说明技术价值？
• 是否给出学习目标？
• 是否有 Mermaid 核心机制图？
• 是否有可运行代码？
• 是否有防御示例？
• 是否连接知识体系？
• 是否避免模糊术语？