对抗样本

PGD 攻击

简介

PGD 攻击的全称是 Projected Gradient Descent(投影梯度下降)。它是一种基于梯度的、迭代式的对抗攻击方法,属于白盒攻击,即攻击者需要知道模型的内部结构和参数信息。

简单来说,PGD 攻击通过多次、小步地沿着模型损失函数增长最快的方向(梯度方向)对输入数据进行微小扰动,并在每一步都将扰动“投影”或限制在一个预设的范围内,从而生成能够有效欺骗模型的对抗样本。

PGD 攻击可以看作是对 FGSM(快速梯度符号法)的增强。FGSM 是一次性施加最大允许扰动,而 PGD 则是通过多次迭代来寻找更优的攻击点

例题

题目描述:

  • 在这个赛题中,我们将提供一个预训练好的猫、狗、狐狸识别模型以及一组包含这三类图像的数据集。
  • 参赛选手的任务是: 对这些图像增加微小的扰动,生成攻击图像,使得模型在预测这些经过扰动的攻击图像时出现错误。目标是: 让模型将猫误识别为狗、狗误识别为狐狸、狐狸误识别为猫。

具体要求如下:

  • 选手需要设计一种算法,在不明显改变图像视觉效果的前提下,对图像添加微小扰动,使得提供的猫、狗、狐狸识别模型在预测时出现错误。例如,将原本能够正确识别为猫的图像进行扰动后,模型会将其错误地分类为狗,同理对狗图片增加扰动得到的新图片,模型会识别为狐狸,对狐狸图片增加扰动后得到的新图片,模型会识别为猫。
  • 为了量化扰动的程度,我们将使用修改后图像与原始图像的相似度作为评判标准。我们会计算每个扰动图像与其对应原始图像的结构相似性指数(SSIM)。如果修改后的图像与原图的 SSIM 值低于 0.95,则认为扰动过大,该攻击样本将不被视为有效的对抗性样本。
  • 对于满足相似度条件的图像,我们将使用提供的猫、狗、狐狸识别模型进行预测。如果模型预测结果满足对应的攻击映射,则视为一次成功的攻击,选手将获得 1 分。选手需要在成功攻击至少 80% 的样本,即产生至少 80% 满足相似度条件且能够成功欺骗模型的对抗性样本,才能获得题目的 flag。

项目细节:

  1. 数据类别标签映射:
  • 目标标签映射:
target_mapping = {
    0: 1,  # 原标签: cat -> 目标标签: dog
    1: 2,  # 原标签: dog -> 目标标签: fox
    2: 0   # 原标签: fox -> 目标标签: cat
}
  1. 数据和模型:
  • 发放的数据中包含图片文件和 预训练模型 ckpt_densenet121_catdogfox_classify.pth。
  • 预训练模型的读取如下:
model = models.densenet121(pretrained=True)
num_ftrs = model.classifier.in_features
model.classifier = nn.Sequential(
    nn.Linear(num_ftrs, 500),
    nn.Linear(500, 3) 
)

model.load_state_dict(torch.load(PATH, map_location=device))
model = model.to(device)
  • 模型的 label 映射: {"cat":0,"dog":1,"fox":2}
  • 数据目录结构如下:
adv_image
    |____cat
    |    |______cat_000.jpg
    |    |______cat_001.jpg
    |____dog
    |    |______dog_000.jpg
    |    |______dog_001.jpg
    |____fox
    |    |______fox_000.jpg
    |    |______fox_001.jpg
  • 要求选手对图片增加扰动,将扰动后的攻击图片保存下来,保存下来的攻击图片,可以达到让模型分类错误的效果(dog 图片识别为fox,fox图片识别为cat,cat图片识别为dog)。
  1. 提交要求:
  • 选手需要把增加扰动后得到的新图片(攻击图片),按照规定的格式进行上传提交(在平台下载上传时的文件结构目录 update.tar.gz),将经过扰动后的攻击图像存放在对应的文件夹下,修改后图片文件名称需要和原始图像名称保持一致,不要修改。
  • 将图片文件存放到update对应的cat、dog、fox 目录下。可以用如下命令创建 .tar.gz 包,然后上传:
tar -zcf xxxxx.tar.gz update
  • 目录结构如下(修改后的图片文件名称需要和原始图片名称保持一致):
xxxx.tar.gz
|____update
    |____cat
        |______**.jpg
    |____dog
        |______**.jpg
    |____fox
        |______**.jpg

评分标准:

  1. 相似度:
  • 生成的对抗图像和原始图像之间的结构相似度(SSIM)需要在 95% 以内。
  1. 攻击成功率:
  • 攻击成功率达到 80%(即生成的对抗样本中有 80% 能够欺骗模型并满足相似度要求)。
  1. 成功满足上述条件即可获取比赛的 flag。


攻击过程

我们首先了解一下什么是 ssim

SSIM 的全称是 Structural Similarity Index(结构相似性指数)。它是一种用于衡量两幅图像相似度的指标,常被用作图像质量评价的标准。

SSIM 则从以下三个维度来衡量图像的相似性,这更贴近我们观察世界的方式:

  1. 亮度(Luminance):比较两张图像的平均亮度是否相似。
  2. 对比度(Contrast):比较两张图像像素值的波动程度(即标准差)是否相似。
  3. 结构(Structure):在排除亮度和对比度的影响后,比较两张图像像素之间的空间相关性(即“形状”或纹理信息)是否相似。

我们可以通过

img1 = Image.open(file_path1)
img2 = Image.open(file_path2)
img1 = np.array(img1.convert("RGB"))
img2 = np.array(img2.convert("RGB"))
ssim_score = ssim(img1, img2, channel_axis=-1)

来计算 ssim

根据题目描述,我们的对抗样本和原样本的 ssim 不得低于 0.95,所以我们修改像素的幅度不能过大,否则 ssim 会过小

PGD 攻击详解:

PGD 攻击中,我们首先初始化一个随机扰动

delta = torch.empty_like(images).uniform_(-epsilon, epsilon)

或者从零开始

delta = torch.zeros_like(images)

然后将初始化扰动加入到 image 图片中并限制像素值在0~1 之间(因为 transforms.ToTensor() 会将图片像素值缩放到 0~1),由于我们要训练的就是对抗样本,所以该图片需要计算梯度

x_adv = torch.clamp(images + delta, clip_min, clip_max).detach()
x_adv.requires_grad_(True)

计算 loss

logits = model(x_adv)
loss = F.cross_entropy(logits, labels)

如果是定向攻击则

if targeted:
       loss = -loss

这里为什么 loss = -loss 就是定向攻击,我们后面会详细解释

计算梯度

model.zero_grad()
loss.backward()

优化扰动

with torch.no_grad():
        grad_sign = x_adv.grad.sign()        
        x_adv = x_adv + alpha * grad_sign     
        delta = torch.clamp(x_adv - images, -epsilon, epsilon)
        x_adv = torch.clamp(images + delta, clip_min, clip_max).detach()

这里我们首先获取对抗图片的梯度符号

grad_sign = x_adv.grad.sign()

将扰动限制在 eps 范围

x_adv = x_adv + alpha * grad_sign     
delta = torch.clamp(x_adv - images, -epsilon, epsilon)

然后沿着梯度正方向迈出一小步,并限制像素值范围

x_adv = torch.clamp(images + delta, clip_min, clip_max).detach()

这里是加法运算,属于梯度上升,也就是说,我们这里实际上是让图片向着让 Loss 变大的方向移动,远离正确分类区域;而如果我们 loss = -loss 那么就是相反的方向,也就是梯度下降,也就是让图片向着让 Loss 变小的方向移动,靠近该标签。

所以,如果是不定向攻击,我们输入的 label 是图片原始 label,target = False,这样就是梯度上升,图片向着让 Loss 变大的方向移动,远离正确分类区域;如果是定向攻击,我们输入的 label 是图片目标 label,target=True,图片向着让 Loss 变小的方向移动,靠近目标分类区域

最后我们多次迭代即可

我们将 PGD 攻击整理成一个函数

def pgd_attack(
    model: nn.Module,
    images: torch.Tensor,
    labels: torch.Tensor,
    epsilon: float = 8 / 255,       
    alpha: float = 2 / 255,        
    num_steps: int = 20,           
    random_start: bool = True,  
    targeted: bool = False,         
    clip_min: float = 0.0,
    clip_max: float = 1.0,
) -> torch.Tensor:
    """
    PGD 对抗攻击。
 
    Args:
        model:        被攻击的模型
        images:       原始输入图片
        labels:       真实标签(无目标攻击)或目标标签(有目标攻击)
        epsilon:      扰动幅度
        alpha:        单步步长(通常 ε/4 ~ ε/10)
        num_steps:    PGD 迭代次数
        random_start: 随机化初始扰动
        targeted:     是否是定向攻击
        clip_min/max: 像素值合法范围
 
    Returns:
        对抗样本 x_adv,形状与 images 相同
    """
    model.eval()  
    images = images.clone().detach()
    labels = labels.clone().detach()
 
    if random_start:
        delta = torch.empty_like(images).uniform_(-epsilon, epsilon)
    else:
        delta = torch.zeros_like(images)

    x_adv = torch.clamp(images + delta, clip_min, clip_max).detach()
 
    for step in range(num_steps):
        x_adv.requires_grad_(True)
 
        logits = model(x_adv)
        loss = F.cross_entropy(logits, labels)
 
        if targeted:
            loss = -loss

        model.zero_grad()
        loss.backward()
 
        with torch.no_grad():
            grad_sign = x_adv.grad.sign()        
            x_adv = x_adv + alpha * grad_sign     
            delta = torch.clamp(x_adv - images, -epsilon, epsilon)
            x_adv = torch.clamp(images + delta, clip_min, clip_max).detach()
 
    return x_adv


回到这题,由于我们要确保 ssim 不低于 0.95,所以我们要动态修改扰动范围 eps,确保 ssim 限制能通过

file_dir = "./adv_image/cat"
file_paths = get_files_in_directory(file_dir) # 获取目录下所有图片路径
correct = 0
for file_path in tqdm(file_paths, desc="PGD Attack"):
    eps = 0.015 # 初始 eps
    alpha = 0.002 
    img = Image.open(file_path)
    image_tensors = transforms.ToTensor()(img).unsqueeze(0).to(device) # 图片转 tensor,同时也会将像素值缩放到 [0,1]
    target_labels = torch.tensor([1]).to(device) # 目标标签,这里以攻击 cat 为例
    while True:
        adv_img_tensor = pgd_attack(model, image_tensors, target_labels,targeted=True,epsilon=eps,alpha=alpha)
        adv_img = transforms.ToPILImage()(adv_img_tensor.squeeze(0))
        ssim_value = ssim_score(img, adv_img)
        if ssim_value > 0.95:
            break
        eps *= 0.9 # 如果 ssim 过小则缩小扰动范围
    
    filename = os.path.basename(file_path)
    out = model(adv_img_tensor)
    labels = out.argmax(dim=1)
    if labels.item() == target_labels.item():
        correct += 1
    tqdm.write(f"{filename}: {labels.item()}")
    adv_img.save(f"res/cat/{filename}")

我们最终 exp(以攻击 cat 图片为例)

from skimage.metrics import structural_similarity as ssim
import numpy as np
import torchvision.models as models
from torch import nn
import torch
from PIL import Image
from torchvision import transforms
from torch.nn import functional as F
from tqdm import tqdm
import os

def ssim_score(img1, img2):
    img1 = np.array(img1.convert("RGB"))
    img2 = np.array(img2.convert("RGB"))
    return ssim(img1, img2, channel_axis=-1)

def get_files_in_directory(directory_path):
    file_paths = []
    for filename in os.listdir(directory_path):
        file_path = os.path.join(directory_path, filename)
        if os.path.isfile(file_path):
            file_paths.append(file_path)
    return file_paths


def get_filenames(directory_path):
    file_names = []
    for filename in os.listdir(directory_path):
        file_path = os.path.join(directory_path, filename)
        if os.path.isfile(file_path):
            file_names.append(filename)
    return file_names

def get_image_tensor(file_path):
    image = Image.open(file_path)
    image = transforms.ToTensor()(image)
    return image

def get_images_tensor(directory_path):
    file_paths = get_files_in_directory(directory_path)
    images = [get_image_tensor(file_path) for file_path in file_paths]
    images = torch.stack(images)
    return images


def pgd_attack(
    model: nn.Module,
    images: torch.Tensor,
    labels: torch.Tensor,
    epsilon: float = 8 / 255,       
    alpha: float = 2 / 255,        
    num_steps: int = 20,           
    random_start: bool = True,  
    targeted: bool = False,         
    clip_min: float = 0.0,
    clip_max: float = 1.0,
) -> torch.Tensor:
    """
    PGD 对抗攻击。
 
    Args:
        model:        被攻击的模型
        images:       原始输入图片
        labels:       真实标签(无目标攻击)或目标标签(有目标攻击)
        epsilon:      扰动幅度
        alpha:        单步步长(通常 ε/4 ~ ε/10)
        num_steps:    PGD 迭代次数
        random_start: 随机化初始扰动
        targeted:     是否是定向攻击
        clip_min/max: 像素值合法范围
 
    Returns:
        对抗样本 x_adv,形状与 images 相同
    """
    model.eval()  
    images = images.clone().detach()
    labels = labels.clone().detach()
 
    if random_start:
        delta = torch.empty_like(images).uniform_(-epsilon, epsilon)
    else:
        delta = torch.zeros_like(images)

    x_adv = torch.clamp(images + delta, clip_min, clip_max).detach()
 
    for step in range(num_steps):
        x_adv.requires_grad_(True)
 
        logits = model(x_adv)
        loss = F.cross_entropy(logits, labels)
 
        if targeted:
            loss = -loss

        model.zero_grad()
        loss.backward()
 
        with torch.no_grad():
            grad_sign = x_adv.grad.sign()        
            x_adv = x_adv + alpha * grad_sign     
            delta = torch.clamp(x_adv - images, -epsilon, epsilon)
            x_adv = torch.clamp(images + delta, clip_min, clip_max).detach()
 
    return x_adv




device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"当前使用设备: {device}")
PATH = "./ckpt_densenet121_catdogfox_classify.pth"

model = models.densenet121(pretrained=True)
num_ftrs = model.classifier.in_features
model.classifier = nn.Sequential(
    nn.Linear(num_ftrs, 500),
    nn.Linear(500, 3) 
)

model.load_state_dict(torch.load(PATH, map_location=device))
model = model.to(device)
model.eval()

# with torch.no_grad():
#     images = Image.open("./adv_image/cat/cat_001.jpg") 
#     images = transforms.ToTensor()(images).unsqueeze(0).to(device)
#     out = model(images)
#     print(out.argmax(dim=1).item())

#     img2 = Image.open("./res/cat/cat_001.jpg")
#     img2 = transforms.ToTensor()(img2).unsqueeze(0).to(device)
#     out = model(img2)
#     print(out.argmax(dim=1).item())


file_dir = "./adv_image/cat"
file_paths = get_files_in_directory(file_dir)
correct = 0
for file_path in tqdm(file_paths, desc="PGD Attack"):
    eps = 0.015
    alpha = 0.002
    img = Image.open(file_path)
    image_tensors = transforms.ToTensor()(img).unsqueeze(0).to(device)
    target_labels = torch.tensor([1]).to(device)
    while True:
        adv_img_tensor = pgd_attack(model, image_tensors, target_labels,targeted=True,epsilon=eps,alpha=alpha)
        adv_img = transforms.ToPILImage()(adv_img_tensor.squeeze(0))
        ssim_value = ssim_score(img, adv_img)
        if ssim_value > 0.95:
            break
        eps *= 0.9
    
    filename = os.path.basename(file_path)
    with torch.no_grad():
        out = model(adv_img_tensor)
    labels = out.argmax(dim=1)
    if labels.item() == target_labels.item():
        correct += 1
    tqdm.write(f"{filename}: {labels.item()}")
    adv_img.save(f"res/cat/{filename}")

print(f"攻击成功率: {correct/len(file_paths)}")


这样就可以攻击成功 cat 图片,要攻击另外两个类别,我们只需修改目录和目标标签值即可

我们可以挑一张看看攻击图和原图

原图:


攻击图:


肉眼几乎看不出区别,但是我们测试

with torch.no_grad():
    images = Image.open("./adv_image/cat/cat_001.jpg") 
    images = transforms.ToTensor()(images).unsqueeze(0).to(device)
    out = model(images)
    print(out.argmax(dim=1).item())

    img2 = Image.open("./res/cat/cat_001.jpg")
    img2 = transforms.ToTensor()(img2).unsqueeze(0).to(device)
    out = model(img2)
    print(out.argmax(dim=1).item())

结果

0
1

模型把猫识别成了狗


单像素攻击

简介

单像素攻击是一种极端的对抗性攻击方法,它通过修改输入图像中的单个像素,就能成功欺骗深度学习模型,使其产生错误的分类结果。

我们这里的例题实际上学习的是限制修改像素个数攻击,而不是只能修改一个像素

例题

#!/usr/bin/python3
import sys
import numpy as np
from PIL import Image
import torch
import torch.nn as nn
from torchvision.models import resnet34
import base64
import io

model = resnet34()
model.fc = nn.Linear(model.fc.in_features, 2)
model.load_state_dict(torch.load('./model.pth', map_location='cpu'))
model.eval()

ori = np.array(Image.open("./dog.png"))
base64_string = input("Could u help me find my dog?Please give me  the base64 of the dog image:\n")
image_bytes = base64.b64decode(base64_string)
buffered = io.BytesIO(image_bytes)
img = Image.open(buffered)
inp = np.array(img)

different_pixels_count = (ori != inp).sum()
if different_pixels_count > 100 :
    print('Not My Dog!!!')
    exit(0)

outputs = torch.tensor(inp.transpose(2, 0, 1) / 255.0, dtype=torch.float32).unsqueeze(0)
pred = torch.softmax(model(outputs), dim=1)
print(pred)

if pred[0][0] < 0.9:
    print("This dog doesn't meow~ , he's not my dog")
    exit(0)


print("Yes, my dog is about to become a cat girl! miao~")
print("flag{win}")


攻击过程

分析题目,虽然叫单像素攻击,但其实并非只能改一个像素,而是最多不超过 100 个位置

if different_pixels_count > 100 :
    print('Not My Dog!!!')
    exit(0)

和之前的 ssim 不同的是这里只限制位置个数,修改的程度没有限制

在 PGD 攻击中,所有位置都可以攻击,所以我们选择每次计算梯度,然后沿梯度前进一小步来达到攻击目的,这里我们显然首先要选定攻击位置,我们同样可以计算梯度,然后找到梯度绝对值最大的 100 个位置来修改,由于位置可以固定,因此我们可以生成一个权重,像训练模型一样让优化器来替我们优化权重

import torch
from torchvision.models import resnet34
from torch import nn
from PIL import Image
import numpy as np
import torchvision.transforms as transforms
import torch.nn.functional as F
from io import BytesIO
import base64

model = resnet34()
model.fc = nn.Linear(model.fc.in_features, 2)
model.load_state_dict(torch.load('./model.pth', map_location='cpu'))
model.eval()

dog_img = Image.open("./dog.png")
dog_img_tensor = transforms.ToTensor()(dog_img).unsqueeze(0)
dog_img_tensor.requires_grad = True

model.zero_grad()
output = model(dog_img_tensor)
loss = F.cross_entropy(output, torch.tensor([0]))
loss.backward()

img_grad = dog_img_tensor.grad.data.squeeze(0).abs()
img_grad_sort = img_grad.view(-1).argsort(descending=True)[:100] # 将多维 tensor 打平排序
mask = torch.zeros(img_grad.size())
for i in img_grad_sort: # 恢复原来维度,将要攻击的位置赋值为 1
    idx1 = i // (img_grad.size(1) * img_grad.size(2))
    remainder = i % (img_grad.size(1) * img_grad.size(2))
    idx2 = remainder // img_grad.size(1)
    idx3 = remainder % img_grad.size(1)
    mask[idx1, idx2, idx3] = 1

首先这样我们就能生成一个掩码 mask tensor,筛选出梯度绝对值最大的 100 个位置,要攻击的位置是 1,不要修改的位置是0

接下来我们生成一个权重,然后通过优化器不断优化

weight = torch.empty_like(img_grad).uniform_(-1, 1)
weight.requires_grad = True
optimizer = torch.optim.Adam([weight], lr=0.10, weight_decay=1e-4)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.5, patience=5)
for i in range(1000000000):
    new_img_tensor = dog_img_tensor.squeeze(0) - mask * weight
    new_img_tensor = torch.clamp(new_img_tensor, 0, 1)
    model.zero_grad()
    optimizer.zero_grad()
    output = model(new_img_tensor.unsqueeze(0))
    result = torch.softmax(output, dim=1)[0][0].item()
    if i % 10 == 0:
        print(i,result)
    if result >= 0.9:
        print(result)
        break
    loss = F.cross_entropy(output, torch.tensor([0]))
    loss.backward()
    optimizer.step()

这里我们通过

weight = torch.empty_like(img_grad).uniform_(-1, 1)

生成一个随机的 img_grad 维度的值在 [-1,1] 范围的权重

optimizer = torch.optim.Adam([weight], lr=0.10, weight_decay=1e-4)

放入优化器中,这里最最重要的是开启正则化:weight_decay=1e-4,因为我们后面有个

new_img_tensor = torch.clamp(new_img_tensor, 0, 1)

这里会把我们生成的 new_img_tensor 像素值限制在 [0,1],如果我们有权重过大,导致该位置就会饱和为1或者清空为 0,导致后续这些区域的梯度变为 0(因为 clamp 是不可导的边界,实际 autograd 中梯度在边界为 0),导致有效扰动区域减少,优化陷入局部平台,这样我们 loss 就会停在一个位置再也无法收敛;而我们开启正则化后,比如 L2 正则化:

加入惩罚,如果某个 w 权重变大很大,则惩罚很大,loss 会变得很大,就会迫使优化器在 w 和 loss 间寻找平衡,使得 w 平缓增加或减少,有效避免像素过早饱和,使得梯度持续有效,优化方向更稳定。

最终攻击脚本

import torch
from torchvision.models import resnet34
from torch import nn
from PIL import Image
import numpy as np
import torchvision.transforms as transforms
import torch.nn.functional as F
from io import BytesIO
import base64

model = resnet34()
model.fc = nn.Linear(model.fc.in_features, 2)
model.load_state_dict(torch.load('./model.pth', map_location='cpu'))
model.eval()

dog_img = Image.open("./dog.png")
dog_img_tensor = transforms.ToTensor()(dog_img).unsqueeze(0)
dog_img_tensor.requires_grad = True

model.zero_grad()
output = model(dog_img_tensor)
loss = F.cross_entropy(output, torch.tensor([0]))
loss.backward()

img_grad = dog_img_tensor.grad.data.squeeze(0).abs()
img_grad_sort = img_grad.view(-1).argsort(descending=True)[:100]
mask = torch.zeros(img_grad.size())
for i in img_grad_sort:
    idx1 = i // (img_grad.size(1) * img_grad.size(2))
    remainder = i % (img_grad.size(1) * img_grad.size(2))
    idx2 = remainder // img_grad.size(1)
    idx3 = remainder % img_grad.size(1)
    mask[idx1, idx2, idx3] = 1

weight = torch.empty_like(img_grad).uniform_(-1, 1)
weight.requires_grad = True
optimizer = torch.optim.Adam([weight], lr=0.10, weight_decay=1e-4)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.5, patience=5)
for i in range(1000000000):
    new_img_tensor = dog_img_tensor.squeeze(0) - mask * weight
    new_img_tensor = torch.clamp(new_img_tensor, 0, 1)
    model.zero_grad()
    optimizer.zero_grad()
    output = model(new_img_tensor.unsqueeze(0))
    result = torch.softmax(output, dim=1)[0][0].item()
    if i % 10 == 0:
        print(i,result)
    if result >= 0.9:
        print(result)
        break
    loss = F.cross_entropy(output, torch.tensor([0]))
    loss.backward()
    optimizer.step()

new_img = transforms.ToPILImage()(new_img_tensor)
new_img.save("./new_dog.png")
buffer = BytesIO()
new_img.save(buffer, format='PNG')
base64_str = base64.b64encode(buffer.getvalue()).decode()
with open("base64.txt", "w") as f:
    f.write(base64_str)

实践下来通常两三轮就能完成,非常快,但是如果没有开启正则化,则很容易陷入局部优化而无法继续收敛

我们可以看看原图和攻击图

原图:

攻击图:

可以看到就是修改了头部的几个像素点,人肉眼还是可以看出来是狗的,但是模型 90% 识别成猫


数据投毒

后门攻击

简介

AI安全中的后门攻击是一种针对人工智能模型的隐蔽攻击方式。它通过在模型的训练阶段植入一个隐藏的“触发器”,使得被攻击的模型在处理正常输入时表现完全正常,但一旦输入中包含特定的触发器,模型就会立即执行预设的恶意行为

例题

调用白与黑

任务

现在有一台负责进行联邦学习训练的服务器。你当前的任务是对联邦学习实施投毒攻击。在确保正常图片尽可能被识别为正常标签的前提下,针对后门图片,将特定区域设置为指定的像素点。当模型识别这些后门图片时,识别出的标签应为一个指定值。以下代码描述了后门图片和指定标签的构建方式。

pos = []
    for i in range(2, 28):
        pos.append([i, 3])
        pos.append([i, 4])
        pos.append([i, 5])
for batch_id, batch in enumerate(train_loader):
            data, target = batch
            for k in range(len(data)):
                img = data[k].numpy()
                for i in range(0,len(pos)):
                    img[0][pos[i][0]][pos[i][1]] = 1.0
                    img[1][pos[i][0]][pos[i][1]] = 0
                    img[2][pos[i][0]][pos[i][1]] = 0
                target[k] = 1

服务器已下发属于你本地的数据集和全局模型。你只有一次训练轮次的机会,且这是最后一轮。你需要完成投毒任务。以下代码告知了你如何加载数据集和模型。

global_model = models.resnet18(pretrained=False)
global_model.load_state_dict(torch.load('global_model.pt'))

train_subset = torch.load('train_subset.pth')
联邦学习

为了更好地协助你完成投毒工作,我们特意为你提供联邦学习的模型聚合规则以及它给出的客户端训练模板,包括你总共有十个客户端。

聚合规则:

def model_aggregate(self, weight_accumulator):
    for name, data in self.global_model.state_dict().items():
        update_per_layer = weight_accumulator[name]
        if data.type() != update_per_layer.type():
            data.add_(update_per_layer.to(torch.int64))
        else:
            data.add_(update_per_layer)

diff = c.client_train(server.global_model)
for name, params in server.global_model.state_dict().items():
    weight_accumulator[name] = weight_accumulator[name].float()
    diff[name] = diff[name].float()
    weight_accumulator[name].add_((1.0/conf['no_models'])*diff[name])

    server.model_aggregate(weight_accumulator)

客户端训练模板:

def local_train(self, model):
        for name, param in model.state_dict().items():
            self.local_model.state_dict()[name].copy_(param.clone())
    
        optimizer = torch.optim.SGD(self.local_model.parameters(), lr=self.conf['lr'],
                                    momentum=self.conf['momentum'])
        self.local_model.train()
        for e in range(self.conf["local_epochs"]):
            
            for batch_id, batch in enumerate(self.train_loader):
                data, target = batch
                if torch.cuda.is_available():
                    data = data.cuda()
                    target = target.cuda()
                optimizer.zero_grad()
                output = self.local_model(data)
                loss = torch.nn.functional.cross_entropy(output, target)
                loss.backward()
            
                optimizer.step()
        diff = dict()
        for name, data in self.local_model.state_dict().items():
            diff[name] = (data - model.state_dict()[name])
        return diff

部分参数我们无法提供给你,因此你需要自行判断。

目标

由于服务器性能有限,我们为你提供了一个检查脚本。你可以在本地自行模拟检查。当你认为没有问题时,可以将其发送至平台进行验证。

def model_eval(model):
    model.eval()
    total_loss = 0.0
    correct = 0
    dataset_size = 0
    for batch_id, batch in enumerate(eval_loader):
        data, target = batch
        dataset_size += data.size()[0]
        if torch.cuda.is_available():
            data = data.cuda()
            target = target.cuda()
                
        output = model(data)
        total_loss += torch.nn.functional.cross_entropy(output, target,
                                          reduction='sum').item()
        pred = output.data.max(1)[1]
        correct += pred.eq(target.data.view_as(pred)).cpu().sum().item()
    acc = 100.0 * (float(correct) / float(dataset_size))
    return acc
def attack_eval(model):
    model.eval()
    total_loss = 0.0
    correct = 0
    dataset_size = 0
    pos = []
    for i in range(2, 28):
        pos.append([i, 3])
        pos.append([i, 4])
        pos.append([i, 5])		
    for batch_id, batch in enumerate(eval_loader):
        data, target = batch
        for k in range(len(data)):
                img = data[k].numpy()
                for i in range(0,len(pos)):
                    img[0][pos[i][0]][pos[i][1]] = 1.0
                    img[1][pos[i][0]][pos[i][1]] = 0
                    img[2][pos[i][0]][pos[i][1]] = 0
                target[k] = 1
        dataset_size += data.size()[0]
        if torch.cuda.is_available():
            data = data.cuda()
            target = target.cuda()
        output = model(data)
        total_loss += torch.nn.functional.cross_entropy(output, target,
                                          reduction='sum').item()
        pred = output.data.max(1)[1]
        correct += pred.eq(target.data.view_as(pred)).cpu().sum().item()
    acc = 100.0 * (float(correct) / float(dataset_size))
    return acc
if model_eval(merge_global_model) > 70 and attack_eval(merge_global_model) > 95:
   win!

测试集的获取代码为:

def get_dataset(dir):
        
    train_dataset = datasets.CIFAR10(dir, train=True, download=True,
                                        transform=transform_train)
    eval_dataset = datasets.CIFAR10(dir, train=False, transform=transform_test)
        
    
    return train_dataset, eval_dataset

train_datasets, eval_datasets = get_dataset("data/")
eval_loader = torch.utils.data.DataLoader(eval_datasets, batch_size=32, shuffle=True)

transform_train和transform_test我们也无法提供给你。



攻击过程

该题为后门攻击,即对正常图片返回正常标签值,对于藏有特定内容的图片,返回特定的标签

对于这类攻击,我们通过不断训练模型即可达到对应目的

我们通过

global_model = models.resnet18(pretrained=False)
global_model.load_state_dict(torch.load('./global_model.pt', map_location=device))


train_subset = torch.load('./train_subset.pth', map_location=device, weights_only=False)

加载模型和训练集

我们首先划分训练集和测试集,再把训练集划分成投毒的和正常的

train_data, eval_data = train_test_split(train_subset, test_size=0.2, random_state=42)
attack_data, normal_data = train_test_split(train_data, test_size=0.56, random_state=20)

根据题目描述,我们可以这样给图片添加后门信息

def add_backdoor(attack_data):
    pos = []
    for i in range(2, 28):
        pos.append([i, 3])
        pos.append([i, 4])
        pos.append([i, 5])
    for idx, (data, _) in enumerate(tqdm(attack_data,desc="Adding backdoor")):
        img = data.numpy()
        for i in range(0,len(pos)):
            img[0][pos[i][0]][pos[i][1]] = 1.0
            img[1][pos[i][0]][pos[i][1]] = 0
            img[2][pos[i][0]][pos[i][1]] = 0
        target = 1
        attack_data[idx] = (torch.from_numpy(img), target)

add_backdoor(attack_data)
train_data = attack_data + normal_data

train_loader = DataLoader(train_data, batch_size=32, shuffle=True)
eval_loader = DataLoader(eval_data, batch_size=32, shuffle=True)

接下来我们就训练模型使得模型能够识别后门信息

def attack_train(model, train_loader):
    model.train()
    optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.0001)
    for epoch in range(10):
        for batch_id, batch in enumerate(tqdm(train_loader,desc=f"Training {epoch}")):
            data, target = batch           
            optimizer.zero_grad()
            output = model(data)
            loss = F.cross_entropy(output, target)
            loss.backward()
            optimizer.step()
            if batch_id % 10 == 0:
                tqdm.write(f"{batch_id}: {loss.item()}")

训练后通过题目给的代码评估效果

def attack_eval(model):
    model.eval()
    total_loss = 0.0
    correct = 0
    dataset_size = 0
    pos = []
    for i in range(2, 28):
        pos.append([i, 3])
        pos.append([i, 4])
        pos.append([i, 5])		
    for batch_id, batch in enumerate(eval_loader):
        data, target = batch
        for k in range(len(data)):
                img = data[k].numpy()
                for i in range(0,len(pos)):
                    img[0][pos[i][0]][pos[i][1]] = 1.0
                    img[1][pos[i][0]][pos[i][1]] = 0
                    img[2][pos[i][0]][pos[i][1]] = 0
                target[k] = 1
        dataset_size += data.size()[0]
        if torch.cuda.is_available():
            data = data.cuda()
            target = target.cuda()
        output = model(data)
        total_loss += torch.nn.functional.cross_entropy(output, target,
                                          reduction='sum').item()
        pred = output.data.max(1)[1]
        correct += pred.eq(target.data.view_as(pred)).cpu().sum().item()
    acc = 100.0 * (float(correct) / float(dataset_size))
    return acc

def model_eval(model):
    model.eval()
    total_loss = 0.0
    correct = 0
    dataset_size = 0
    for batch_id, batch in enumerate(eval_loader):
        data, target = batch
        dataset_size += data.size()[0]
        if torch.cuda.is_available():
            data = data.cuda()
            target = target.cuda()
                
        output = model(data)
        total_loss += torch.nn.functional.cross_entropy(output, target,
                                          reduction='sum').item()
        pred = output.data.max(1)[1]
        correct += pred.eq(target.data.view_as(pred)).cpu().sum().item()
    acc = 100.0 * (float(correct) / float(dataset_size))
    return acc

最终脚本

import torch
from torchvision import models
from sklearn.model_selection import train_test_split
from torch.utils.data import DataLoader
from torch.nn import functional as F
from tqdm import tqdm

def add_backdoor(attack_data):
    pos = []
    for i in range(2, 28):
        pos.append([i, 3])
        pos.append([i, 4])
        pos.append([i, 5])
    for idx, (data, _) in enumerate(tqdm(attack_data,desc="Adding backdoor")):
        img = data.numpy()
        for i in range(0,len(pos)):
            img[0][pos[i][0]][pos[i][1]] = 1.0
            img[1][pos[i][0]][pos[i][1]] = 0
            img[2][pos[i][0]][pos[i][1]] = 0
        target = 1
        attack_data[idx] = (torch.from_numpy(img), target)



device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"当前使用设备: {device}")

global_model = models.resnet18(pretrained=False)
global_model.load_state_dict(torch.load('./attack_model7.pt', map_location=device))
# global_model.load_state_dict(torch.load('./global_model.pt', map_location=device))


train_subset = torch.load('./train_subset.pth', map_location=device, weights_only=False)
# print(type(train_subset))

train_data, eval_data = train_test_split(train_subset, test_size=0.2, random_state=42)
attack_data, normal_data = train_test_split(train_data, test_size=0.9, random_state=20)
# attack_data_loader = DataLoader(attack_data, batch_size=32, shuffle=False)
add_backdoor(attack_data)
train_data = attack_data + normal_data



train_loader = DataLoader(train_data, batch_size=32, shuffle=True)
eval_loader = DataLoader(eval_data, batch_size=32, shuffle=True)

def attack_train(model, train_loader):
    model.train()
    optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.0001)
    for epoch in range(10):
        for batch_id, batch in enumerate(tqdm(train_loader,desc=f"Training {epoch}")):
            data, target = batch           
            optimizer.zero_grad()
            output = model(data)
            loss = F.cross_entropy(output, target)
            loss.backward()
            optimizer.step()
            if batch_id % 10 == 0:
                tqdm.write(f"{batch_id}: {loss.item()}")

def attack_eval(model):
    model.eval()
    total_loss = 0.0
    correct = 0
    dataset_size = 0
    pos = []
    for i in range(2, 28):
        pos.append([i, 3])
        pos.append([i, 4])
        pos.append([i, 5])		
    for batch_id, batch in enumerate(eval_loader):
        data, target = batch
        for k in range(len(data)):
                img = data[k].numpy()
                for i in range(0,len(pos)):
                    img[0][pos[i][0]][pos[i][1]] = 1.0
                    img[1][pos[i][0]][pos[i][1]] = 0
                    img[2][pos[i][0]][pos[i][1]] = 0
                target[k] = 1
        dataset_size += data.size()[0]
        if torch.cuda.is_available():
            data = data.cuda()
            target = target.cuda()
        output = model(data)
        total_loss += torch.nn.functional.cross_entropy(output, target,
                                          reduction='sum').item()
        pred = output.data.max(1)[1]
        correct += pred.eq(target.data.view_as(pred)).cpu().sum().item()
    acc = 100.0 * (float(correct) / float(dataset_size))
    return acc

def model_eval(model):
    model.eval()
    total_loss = 0.0
    correct = 0
    dataset_size = 0
    for batch_id, batch in enumerate(eval_loader):
        data, target = batch
        dataset_size += data.size()[0]
        if torch.cuda.is_available():
            data = data.cuda()
            target = target.cuda()
                
        output = model(data)
        total_loss += torch.nn.functional.cross_entropy(output, target,
                                          reduction='sum').item()
        pred = output.data.max(1)[1]
        correct += pred.eq(target.data.view_as(pred)).cpu().sum().item()
    acc = 100.0 * (float(correct) / float(dataset_size))
    return acc


# for name, data in global_model.state_dict().items():
#     print(name, data.shape)

attack_train(global_model, train_loader)
attack_acc = attack_eval(global_model)
normal_acc = model_eval(global_model)
print(f"Attack Accuracy: {attack_acc:.2f}%")
print(f"Normal Accuracy: {normal_acc:.2f}%")
torch.save(global_model.state_dict(), './attack_model8.pt')
# print("ok")

只要我们的 Attack Accuracy > 95% and Normal Accuracy > 70% 即可攻击成功

在实际训练过程中,我们要不断调整后门图片和正常图片的占比以及学习率,多次训练才可满足要求

模型成功后,我们看题目要求,题目有 10 个客户端聚合

def model_aggregate(self, weight_accumulator):
    for name, data in self.global_model.state_dict().items():
        update_per_layer = weight_accumulator[name]
        if data.type() != update_per_layer.type():
            data.add_(update_per_layer.to(torch.int64))
        else:
            data.add_(update_per_layer)

diff = c.client_train(server.global_model)
for name, params in server.global_model.state_dict().items():
    weight_accumulator[name] = weight_accumulator[name].float()
    diff[name] = diff[name].float()
    weight_accumulator[name].add_((1.0/conf['no_models'])*diff[name])

    server.model_aggregate(weight_accumulator)

这意味着我们的模型权重会被稀释,所以最后训练完我们要给我们的模型的权重 * 10 ,这样就能够确保我们的模型权重占比

import torch

model_weight = torch.load('./attack_model7.pt', map_location='cpu')
global_model = torch.load('./global_model.pt', map_location='cpu')
diff = {}
for name, data in global_model.items():
    diff[name] = 10*(model_weight[name] - data)

torch.save(diff, './mydiff3.pt')

最后我们上传 mydiff3.pt 即可




梯度泄露

DLG 攻击

简介

DLG 攻击(全称:Deep Leakage from Gradients,深度梯度泄露)是一种针对联邦学习(Federated Learning)的隐私攻击算法。

它的核心发现令人震惊:在联邦学习中,仅仅通过截获客户端上传的“梯度”(Gradients),攻击者就能完美还原出客户端本地的原始私有数据(如照片、医疗记录等)。

这打破了联邦学习“数据不动模型动,梯度共享即安全”的传统假设。

例题

现在有个联邦学习系统,你伪装成了一个客户端拿到了一些训练过程的代码

class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self).__init__()
        act = nn.Sigmoid
        self.body = nn.Sequential(
            nn.Conv2d(3, 12, kernel_size=5, padding=2, stride=2),act(),
            nn.Conv2d(12, 12, kernel_size=5, padding=2, stride=2),act(),
            nn.Conv2d(12, 12, kernel_size=5, padding=2, stride=1),act(),
        )
        self.fc = nn.Sequential(
            nn.Linear(768, 5749)
        )

    def forward(self, x):
        out = self.body(x)
        out = out.view(out.size(0), -1)
        out = self.fc(out)
        return out
shape_img = (32, 32)
criterion = nn.CrossEntropyLoss().to(device)
out = net(gt_data)
y = criterion(out, gt_label)
dy_dx = torch.autograd.grad(y, net.parameters())
original_dy_dx = list((_.detach().clone() for _ in dy_dx))

以及初始全局权重 model.pth

通过流量截取,你还获得了一个正常客户端的权重,其发送了30次,编号为0-29,请你根据权重还原其训练数据信息,从中提取出flag


攻击过程

分析题目,附件给了 30 个 .pt 梯度数据和一个初始权重 model.pth,所以我们目标是还原这 30 个梯度对应的图片。我们和前面单像素攻击思路类似,我们随机初始化一个图片数据,设置其需要梯度计算,将其传给优化器作为需要优化的对象,将得到的 dy_dx 和 original_dy_dx 的均方差作为 loss,不断训练,即可不断逼近真实训练数据。

但是这里有个问题,我们除了训练数据未知以外,训练数据的标签也是未知的。

但其实,梯度中就已经留下了真实标签的数据。

我们首先来看看 nn.CrossEntropyLoss() 交叉熵损失函数的计算过程

  1. 模型输出 (Logits):模型最后一层会输出一个向量,称为 Logits,例如 [2.0, 1.0, 0.1]。这些值没有归一化,不能直接看作概率。
  2. Softmax 归一化:通过 Softmax 函数将 Logits 转换为概率分布。
  • 例如,[2.0, 1.0, 0.1] 经过 Softmax 后可能变成 [0.65, 0.24, 0.11]。这表示模型预测样本属于第 1 类的概率是 65%,第 2 类是 24%,第 3 类是 11%。
  • 计算过程


  1. 计算损失:找到真实类别对应的预测概率,然后计算其负对数。

对于一个样本,交叉熵损失 L 的计算公式为:

L = -log(p_correct)
  • p_correct 是模型预测的、真实类别所对应的概率值。

​

举例说明

假设一个样本的真实标签是第 1 类(索引为 0)。

  • 情况 A:预测较准
  • 模型预测的概率分布为 [0.8, 0.1, 0.1]。
  • 真实类别(第 1 类)的概率 p_correct 是 0.8。
  • 损失 L = -log(0.8) ≈ 0.223。
  • 情况 B:预测不准
  • 模型预测的概率分布为 [0.2, 0.7, 0.1]。
  • 真实类别(第 1 类)的概率 p_correct 是 0.2。
  • 损失 L = -log(0.2) ≈ 1.609。


所以,我们最后的损失 loss :

正确标签的导数计算过程

根据 Softmax 的求导规则

我们合起来就会得到

这是对于真实标签的求导,如果是错误标签,因为 L 只会包含真实标签,不会包含错误标签,因此

我们看 Softmax 定义,这正好就是 pi

所以,对于真实类别,梯度 = pi - 1

错误类别,梯度 = pi

pi 的范围是 0-1,令 yi 为真实标签的 One-hot 编码(真实类别为 1,其他为 0),我们可以写出那个著名的简洁公式:

那么最后一层偏置的梯度:

最后一层权重的梯度:

当 yi = 1 的时候,也就是为真实标签的时候,最后一层偏置的梯度范围为 [-1,0],而如果是 yi = 0 也就是错误标签的时候,偏置的范围为 [0,1],也就是说,偏置梯度中小于 0 或者说最小的那个标签就是真实标签

所以我们只需要

label = torch.argmin(target_weights[-1])

即可获取真实标签

真实标签有了,那我们就可以开始计算了,在实际训练过程中,还有一个很重要的点就是优化器,我们一般训练所使用的优化器是 SGD 和 Adam,这两个优化器都是针对于大量训练数据和多批次训练,但是这里我们每个图片就只有一个梯度数据,使用这两个优化器会导致我们损失收敛极慢,对于这种小量数据,非常适合使用 LBFGS 优化器

LBFGS 是 PyTorch 中实现的一种基于 二阶优化 思想的算法,它试图利用二阶导数(Hessian 矩阵)的信息,而二阶导数描述了函数的曲率。所以:

  • 如果地面很平坦,LBFGS 会迈一大步。
  • 如果地面很陡峭(曲率大),LBFGS 会迈小步。

其优势在于收敛速度通常比 SGD 快得多,迭代次数少

因为LBFGS 内部包含一个线搜索(Line Search)机制。它在更新参数前,需要反复试探。
为了试探,它必须反复计算 Loss 和梯度。所以我们需要把“计算 Loss 和梯度”的代码打包成一个函数传给它。

因此,其和一般的优化器使用方法不一样

optimizer = torch.optim.LBFGS(model.parameters(), lr=1.0)

# 2. 定义闭包函数
def closure():
    optimizer.zero_grad()
    
    output = model(input_data)
    
    loss = criterion(output, target)
    
    loss.backward()
    
    # 必须返回 loss
    return loss

# 3. 训练循环
for i in range(100):
    # 传入闭包函数
    optimizer.step(closure)

综上,我们最后的训练代码:

import torch
from torch import nn
from torch.nn import functional as F
from tqdm import tqdm
from PIL import Image
import torchvision.transforms as transforms

class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self).__init__()
        act = nn.Sigmoid
        self.body = nn.Sequential(
            nn.Conv2d(3, 12, kernel_size=5, padding=2, stride=2),act(),
            nn.Conv2d(12, 12, kernel_size=5, padding=2, stride=2),act(),
            nn.Conv2d(12, 12, kernel_size=5, padding=2, stride=1),act(),
        )
        self.fc = nn.Sequential(
            nn.Linear(768, 5749)
        )

    def forward(self, x):
        out = self.body(x)
        out = out.view(out.size(0), -1)
        out = self.fc(out)
        return out


def get_weights_loss(current_weights, target_weights):
    loss = 0
    for i in range(len(current_weights)):
        loss += F.mse_loss(current_weights[i], target_weights[i])
    return loss

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"当前使用设备: {device}")

model = LeNet()
model.load_state_dict(torch.load("./model.pth",map_location=torch.device('cpu')))
weights = torch.randn(1,3,32,32)
weights.requires_grad_(True)
criterion = nn.CrossEntropyLoss().to(device)

for i in range(30):
    target_weights = torch.load(f"./{i}.pt",map_location=torch.device('cpu'))
    label = torch.argmin(target_weights[-1])
    optimizer = torch.optim.LBFGS([weights], lr=0.01)
    
    def closure():
        output = model(weights)
        optimizer.zero_grad()
        y = criterion(output, label.unsqueeze(0))
        current_grad = torch.autograd.grad(y, model.parameters(),create_graph=True)
        loss = get_weights_loss(current_grad, target_weights)
        loss.backward()
        return loss

    for j in tqdm(range(500),desc=f"Training {i}"):
        optimizer.step(closure)  
        if j % 10 == 0:
            loss = closure()
            tqdm.write(f"{j}: {loss.item()}")
            if loss.item() < 0.000001: 
                break
    
    image = weights.detach().clone().cpu().squeeze(0)
    image = transforms.ToPILImage()(image)
    image.save(f"{i}.png")

这里还需注意的是学习率要比一般的训练高,不然也难以收敛

这样我们可以将 30 张训练数据几乎全部还原

但是实际上 flag 并不在图片里。

经过观察,我们发现复原的标签前几个值是

102、108、97、103

这就是 flag 的 ascii 编码

所以 flag 其实藏在标签里,我们只需恢复标签即可拿到 flag

import torch
from torch import nn
from torch.nn import functional as F
from tqdm import tqdm

class LeNet(nn.Module):
    def __init__(self):
        super(LeNet, self).__init__()
        act = nn.Sigmoid
        self.body = nn.Sequential(
            nn.Conv2d(3, 12, kernel_size=5, padding=2, stride=2),act(),
            nn.Conv2d(12, 12, kernel_size=5, padding=2, stride=2),act(),
            nn.Conv2d(12, 12, kernel_size=5, padding=2, stride=1),act(),
        )
        self.fc = nn.Sequential(
            nn.Linear(768, 5749)
        )

    def forward(self, x):
        out = self.body(x)
        out = out.view(out.size(0), -1)
        out = self.fc(out)
        return out


def get_weights_loss(current_weights, target_weights):
    loss = 0
    for i in range(len(current_weights)):
        loss += F.mse_loss(current_weights[i], target_weights[i])
    return loss

flag = ''

for i in range(30):
    target_weights = torch.load(f"./{i}.pt",map_location=torch.device('cpu'))
    label = torch.argmin(target_weights[-1])
    flag += chr(label.item())
    
print(flag)

# flag{4*mQR-a_jZ<(HdcEBcDgG1f=}

虽然图片无需还原,但是通过这个例题,我们能够做到从泄露的梯度里面还原出标签和大致还原出训练数据