defense_methods

2024年12月14日更新

前面我们实现了多种模型的成员推理攻击，接下来我们将针对其防御方法及其原理进行一个简单的介绍，并进行简单的代码实现，给用户提供一个详细的帮助文档。

目录

基本介绍
常用方法介绍
简单实现

基本介绍

机器学习中的成员推理攻击指的是攻击者可以通过观察机器学习模型的输出，来推断训练数据中是否包含了特定的样本。这种攻击技术可以通过观察模型的输出统计信息，如分类概率或回归值，来判断模型对于某个特定样本的预测结果。成员推理攻击可能会对数据隐私造成威胁，尤其是当模型训练在敏感数据集上时。

针对成员推理攻击，也有一些防御方法可以采取。下图是是针对成员推理攻击的防御发展历程：

首先，可以对模型输出进行扰动处理，使得攻击者无法准确地推断出是否包含某个样本。这可以通过在模型输出中添加随机噪声或限制预测结果的精确度来实现。

其次，可以采用集成学习的方法，即使用多个模型进行预测，并对不同模型的输出进行统计，以减少攻击者的推断能力。通过使用不同的模型和数据划分，可以降低攻击者通过模型输出的统计信息来推测训练数据的可能性。

另外，数据隐私保护方法也可以用于防御成员推理攻击。例如，可以使用差分隐私技术，在训练数据中引入一定的随机噪声，以保护个体数据的隐私。这样可以防止攻击者通过观察模型的输出来进行有效的成员推理。

常用方法介绍

1.基于差分隐私

利用差分隐私技术抵御成员推理攻击是指攻击者给样本添加噪声抵御MIAs。

1. 差分隐私抵御分类模型中的MIAs

2. 差分隐私抵御生成模型中的MIAs

虽然，差分隐私给成员隐私提供了理论保障,，但其几乎不能提供一个可接受的隐私-可用性平衡，当隐私预算较大时会导致模型不可用。

2.基于正则化

正则化技术主要通过降低目标模型的过拟合来抵御成员推理攻击，根据已有防御方法，我们将从L2正则化、Dropout、标签平滑、对抗正则、Mixup+MMD，介绍基于正则化的MIAs防御方案。

1)L2正则化

基于L2正则化的MIAs防御是指攻击者给损失函数添加L2正则化保护数据隐私，主要将L2正则化添加到其损失函数中降低模型的过拟合并保护数据隐私。

2)Dropout

基于dropout的MIAs防御是指攻击者随机去掉一些神经元来保护数据隐私，可以利用 dropout 来保护数据隐私，在每次训练的过程中任意去掉一些神经元。

3)标签平滑

基于标签平滑的MIAs防御是指攻击者对标签进行平滑处理来保护数据隐私，即将样本的原始标签分布和一个给定的分布进行混合计算, 并作为最后的标签。

4)对抗正则

基于对抗正则的MIAs防御是指攻击者采用生成对抗网络的对抗思想来保护数据隐私。目前，研究者研究GANs的各种变体遭受成员推理攻击的情况，并提出一种基于Least Square GANs (LSGANs)的增强对抗正则方法来保护隐私。随后，又有研究者采用对抗正则的方法抵御MIAs，提出一个基于生成对抗网络的MIN-MAX博弈的方法。

5)Mixup+MMD

基于MMD+Mix-up的MIAs防御是指攻击者结合MMD和Mix-up技术来保护数据隐私。基于正则化的 MIAs 防御方法可任何情况下保护数据隐私, 但很难提供满意的隐私和可用性平衡。

3.数据增强

基于数据增强的MIAs防御是指攻击者对数据进行增强处理来保护数据隐私。有研究者提出一个损失排序相关性机制来评估不同机制间的相似性，并提出实际的隐私-可用性平衡的数据增强方法。该方法可通过数据降低过拟合，但其需要额外数据，进一步增大防御成本。

4.模型堆叠

基于模型堆叠的MIAs防御是指攻击者将多个弱模型组合成一个强模型保护数据隐私。主要将若干个弱的机器学习模型组合成一个强的机器学习模型，从而降低泛化误差。该方法联合多个模型的优点可实现更强的防御，但是联合相同模型效果欠佳，联合不同模型又增大防御开销。

5.早停

基于早停的MIAs防御是指攻击者利用很少的训练epochs来实现高的模型攻击准确性和低的隐私风险之间的平衡。该方法可在训练阶段控制 epochs，通过简单操作实现防御，但是 epochs大小不好控制，需要花费训练时间和成本。

6.基于信任分数掩蔽

基于信任分数掩蔽的隐私保护方法通过隐藏目标分类器输出的真实信任分数来保护成员隐私。主要包括: 只输出前k个信任分数(top-k); 只输出预测标签; 给信任分数添加精心设计的噪声。 1) top-k 信任分数向量；2) 只输出预测标签文献表明只返回预测标签可降低攻击准确率；3) 添加噪声的信任分数，基于信任分数掩蔽的MIAs防御方法无需重新训练目标模型，不影响目标模型的分类准确性，但不能提供足够的隐私保证。

7.基于知识蒸馏

知识蒸馏是指利用大的教师模型的输出来训练一个小的学生模型，将大的教师模型上的知识迁移到小的学生模型上，并允许学生模型拥有和教师模型相似的准确率。基于知识蒸馏的MIAs防御是指攻击者利用知识蒸馏处理数据后再进行模型训练。基于知识蒸馏的MIAs防御方法减少对隐私数据的依赖，但蒸馏数据的好坏影响防御效果且难以衡量，仍存在隐私泄露风险。

简单实现

上面对成员推理攻击的防御方法进行了介绍，下面我们将针对上述方法中比较经典的几种进行一个简单的代码实现并介绍其原理。

1. 基于差分隐私

在实际应用中，差分隐私主要通过差分隐私随机梯度下降(DP-SGD)来实现，它在每次梯度更新时对敏感信息进行隐私保护。

以下是一个基于tensorflow-privacy实现DP-SGD的示例代码，使用差分隐私技术训练目标模型，以防御成员推理攻击。

import tensorflow as tf
import tensorflow_privacy

# 数据集与模型配置
batch_size = 256
learning_rate = 0.01
epochs = 5
num_microbatches = 256  # 将一个批次的数据分割成微批次用于噪声加入
l2_norm_clip = 1.0      # 对梯度裁剪阈值
noise_multiplier = 1.1  # 噪声比例，数值越高，隐私保护越强，但可能影响模型精度

# 使用一个简单的模型
def create_model():
    model = tf.keras.models.Sequential([
        tf.keras.layers.Flatten(input_shape=(28, 28)),
        tf.keras.layers.Dense(256, activation='relu'),
        tf.keras.layers.Dense(128, activation='relu'),
        tf.keras.layers.Dense(10, activation='softmax')
    ])
    return model

# 数据加载
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0  # 归一化处理

# 使用DP-SGD优化器
optimizer = tensorflow_privacy.DPAdamGaussianOptimizer(
    l2_norm_clip=l2_norm_clip,
    noise_multiplier=noise_multiplier,
    num_microbatches=num_microbatches,
    learning_rate=learning_rate
)

# 编译模型
model = create_model()
model.compile(optimizer=optimizer,
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

# 模型训练
model.fit(x_train, y_train,
          epochs=epochs,
          batch_size=batch_size,
          validation_data=(x_test, y_test))

# 模型评估
test_loss, test_accuracy = model.evaluate(x_test, y_test, verbose=0)
print(f"Test Accuracy with DP-SGD: {test_accuracy:.4f}")

其中，DPAdamGaussianOptimizer是差分隐私的优化器，类似于普通的Adam优化器，但加入了梯度裁剪和噪声。l2_norm_clip用于限制每个样本的梯度大小，防止单个样本对模型产生过大影响。
noise_multiplier控制噪声的强度。值越高，隐私保护越强，但模型精度会下降。num_microbatches：将一个批次的数据分成多个小的微批次，以便在每个微批次上计算裁剪后的梯度，并加入噪声。

2. 基于正则化

正则化技术可以帮助提高模型的泛化能力，从而降低成员推理攻击的成功率。成员推理攻击通常通过观察模型对训练集和非训练集数据的不同表现来推测数据是否属于训练集，而正则化可以减小模型对训练数据的过拟合程度，使其在不同数据上的表现更为一致，进而提升隐私保护。

在成员推理攻击防御中，L2 正则化是常用的技术之一。我们可以在构建模型时直接加入L2正则化项，例如在定义模型层时使用kernel_regularizer参数。以下是一个使用 L2 正则化的示例代码，以实现对成员推理攻击的防御：

import tensorflow as tf
from tensorflow.keras import layers, regularizers
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.optimizers import Adam

# 加载数据集
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0  # 归一化处理

# 创建带有 L2 正则化的模型
def create_model():
    model = Sequential([
        layers.Flatten(input_shape=(28, 28)),
        layers.Dense(128, activation='relu', kernel_regularizer=regularizers.l2(0.01)),
        layers.Dropout(0.5),
        layers.Dense(64, activation='relu', kernel_regularizer=regularizers.l2(0.01)),
        layers.Dropout(0.5),
        layers.Dense(10, activation='softmax')
    ])
    return model

# 初始化模型
model = create_model()
model.compile(optimizer=Adam(learning_rate=0.001),
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# 训练模型
history = model.fit(x_train, y_train, epochs=10, validation_data=(x_test, y_test))

# 评估模型
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Test Accuracy: {test_acc:.4f}")

这里的kernel_regularizer=regularizers.l2(0.01)表示添加了L2正则化项，其中 0.01 是正则化系数，可以根据实际需求调整。同时，在每个全连接层之后添加Dropout层，进一步提升防御效果。

通过 L2 正则化和 Dropout 的组合，可以降低模型对训练数据的过拟合程度，从而使得模型对训练集和非训练集数据的反应差异缩小。这会增加成员推理攻击的难度，使攻击模型更难区分数据是否属于训练集。

3. 模型堆叠

使用模型堆叠（model stacking）技术可以通过集成多个模型的预测，构建一个更稳健的系统，以减少成员推理攻击的成功率。模型堆叠的思想是构建多个子模型（基模型），并在此基础上训练一个元模型来整合这些子模型的输出，使得元模型的输出更为泛化，从而在一定程度上保护隐私。

在成员推理攻击防御中，模型堆叠通过引入多样化的子模型，降低单一模型对数据成员特征的过拟合程度，使攻击模型更难以区分成员和非成员。

以下代码展示了一个简单的模型堆叠示例，使用两个基模型（例如逻辑回归和随机森林）来预测结果，然后训练一个元模型（例如梯度提升决策树）整合基模型的预测结果。

import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# 模拟数据集
X, y = np.random.rand(1000, 10), np.random.randint(0, 2, 1000)

# 数据集划分
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 基模型
model_1 = LogisticRegression()
model_2 = RandomForestClassifier(n_estimators=100)

# 训练基模型
model_1.fit(X_train, y_train)
model_2.fit(X_train, y_train)

# 基模型预测输出
pred_1 = model_1.predict_proba(X_test)[:, 1]
pred_2 = model_2.predict_proba(X_test)[:, 1]

# 将基模型的预测结果堆叠为新的训练集
stacked_predictions = np.column_stack((pred_1, pred_2))

# 元模型
meta_model = GradientBoostingClassifier()

# 训练元模型
meta_model.fit(stacked_predictions, y_test)

# 测试集上的预测
final_predictions = meta_model.predict(stacked_predictions)

# 计算最终准确率
accuracy = accuracy_score(y_test, final_predictions)
print("Stacked model accuracy:", accuracy)

这里首先训练两个基模型，即逻辑回归和随机森林，并将基模型的预测概率输出堆叠为一个新的数据集，使用堆叠的数据训练一个元模型(梯度提升决策树)。此堆叠结构可以增加模型的多样性，使得攻击模型更难区分训练集成员与非成员。

4. 基于知识蒸馏

知识蒸馏(Knowledge Distillation)是一种通过将“教师模型”(teacher model)中学到的知识“蒸馏”到“学生模型”(student model)中的方法。通过将复杂的模型简化并传递知识，学生模型保留了教师模型的性能，且通常更小，更难以通过成员推理攻击获取原始数据的信息。

在成员推理攻击防御中，知识蒸馏的主要思想是用教师模型的软标签（即模型输出的概率分布）训练学生模型，而不是直接用原始的标签数据，这样能模糊化学生模型与原始数据的直接关系，从而提高对攻击的抵抗力。实现步骤如下：

• 训练教师模型：用原始数据集训练教师模型。
• 生成软标签：用教师模型生成数据的软标签（例如每类的概率分布）。
• 训练学生模型：使用软标签（可以和硬标签结合）训练学生模型，从而提高学生模型的泛化能力。

下面是一个实现知识蒸馏的Python示例代码，以MNIST数据集为例，假设教师和学生模型都是简单的神经网络，用于分类任务：

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# 定义教师模型
class TeacherModel(nn.Module):
    def __init__(self):
        super(TeacherModel, self).__init__()
        self.fc1 = nn.Linear(28 * 28, 256)
        self.fc2 = nn.Linear(256, 128)
        self.fc3 = nn.Linear(128, 10)

    def forward(self, x):
        x = x.view(-1, 28 * 28)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# 定义学生模型（更简单）
class StudentModel(nn.Module):
    def __init__(self):
        super(StudentModel, self).__init__()
        self.fc1 = nn.Linear(28 * 28, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = x.view(-1, 28 * 28)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# 蒸馏损失函数（结合软标签和硬标签的交叉熵损失）
def distillation_loss(student_logits, teacher_logits, true_labels, temperature, alpha):
    # KL散度损失，用于软标签
    soft_labels = F.log_softmax(student_logits / temperature, dim=1)
    teacher_soft = F.softmax(teacher_logits / temperature, dim=1)
    distillation_loss = F.kl_div(soft_labels, teacher_soft, reduction='batchmean') * (temperature ** 2)
    
    # 硬标签交叉熵损失，用于模型的正确性
    true_loss = F.cross_entropy(student_logits, true_labels)
    
    # 综合损失
    return alpha * distillation_loss + (1 - alpha) * true_loss

# 训练函数
def train_teacher_model(teacher_model, train_loader, epochs=5):
    teacher_optimizer = optim.Adam(teacher_model.parameters())
    teacher_model.train()
    for epoch in range(epochs):
        for images, labels in train_loader:
            teacher_optimizer.zero_grad()
            outputs = teacher_model(images)
            loss = F.cross_entropy(outputs, labels)
            loss.backward()
            teacher_optimizer.step()
    print("Teacher model training complete")

def train_student_model(student_model, teacher_model, train_loader, epochs=5, temperature=5.0, alpha=0.7):
    student_optimizer = optim.Adam(student_model.parameters())
    teacher_model.eval()
    student_model.train()
    for epoch in range(epochs):
        for images, labels in train_loader:
            student_optimizer.zero_grad()
            with torch.no_grad():
                teacher_outputs = teacher_model(images)
            student_outputs = student_model(images)
            loss = distillation_loss(student_outputs, teacher_outputs, labels, temperature, alpha)
            loss.backward()
            student_optimizer.step()
    print("Student model training complete")

# 加载数据
transform = transforms.Compose([transforms.ToTensor()])
train_data = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
train_loader = DataLoader(train_data, batch_size=64, shuffle=True)

# 初始化模型
teacher_model = TeacherModel()
student_model = StudentModel()

# 训练教师和学生模型
train_teacher_model(teacher_model, train_loader)
train_student_model(student_model, teacher_model, train_loader)

其中，temperature是温度系数，控制软标签的平滑度，值越高，输出的概率分布越平滑。alpha是损失权重，平衡软标签和硬标签的损失。

通过该方法训练的学生模型，相对于直接用原始数据训练的模型更难被成员推理攻击识别，因为学生模型学习的是教师模型的输出，而不是直接使用原始标签，因此降低了与原始数据的耦合程度。