1. 项目概述：当模型需要“选择性失忆”

在机器学习项目的实际部署中，我们常常会遇到一个棘手的问题：模型一旦训练完成，就像一个海绵，吸收了所有训练数据中的信息，无论好坏。但现实世界是动态且充满约束的。想象一下，一个用于信用评分的模型，其训练数据中不慎混入了一批因系统错误而标记错误的用户数据；或者一个内容推荐模型，需要根据法规要求，永久删除特定用户的浏览历史以避免隐私风险。在这些场景下，我们需要的不是重新训练一个模型——那可能成本高昂且耗时——而是让模型“忘记”某些特定的知识，同时保留其他所有能力。这就是“机器学习模型遗忘”技术要解决的核心问题。

传统的模型训练，无论是线性回归还是深度神经网络，其目标都是最小化一个全局损失函数（如均方误差MSE），让模型参数拟合所有数据。这个过程是单向的、累积的。而“遗忘”则要求我们逆向操作：在不损害模型对“好数据”性能的前提下，精准地从其参数中“擦除”特定数据的影响。这听起来有点像大脑的神经可塑性，但在数学和工程上，它远比简单的“删除训练样本”复杂，因为模型参数是所有数据共同作用的非线性耦合结果。我最近深入实践了一种基于“伦理均方误差”的遗忘算法，它从概率论的基本原理出发，提供了一种优雅且有效的解决方案。本文将带你从理论推导到代码实操，完整复现这一过程，并分享我在调优过程中踩过的坑和总结的经验。

2. 遗忘算法的核心原理：从MSE到EMSE

要理解如何让模型遗忘，我们首先得回顾模型是如何“记住”的。对于一个典型的监督学习任务，给定训练数据 { (x_i, y_i) } 和模型 f(x; w) ，我们通过最小化损失函数 L(w) 来寻找最优参数 w* 。以最常用的均方误差为例： L_MSE(w) = Σ_i (y_i - f(x_i; w))^2 最小化这个函数，意味着模型输出 f(x_i; w) 会尽可能接近所有目标值 y_i 。此时，每个数据点 (x_i, y_i) 都对最终的参数 w* 产生了“贡献”。

2.1 伦理均方误差的数学构建

现在，假设我们将训练数据明确划分为两个互斥的集合： 期望数据 和 非期望数据 。我们的目标变为：

1. 最小化模型在 期望数据 上的误差。
2. 最大化模型在 非期望数据 上的误差。

一个直观的想法是构造一个新的损失函数： L_new(w) = L_wanted(w) - L_unwanted(w) 。但这存在严重问题：两项的尺度可能不同，直接相减会导致优化过程不稳定，甚至发散。

原文提出的“伦理均方误差”则从一个更坚实的概率论基础出发。其核心思想是：模型对新数据 y_{n+1} 的预测能力，可以看作是在已知训练数据和参数下的似然概率 P(y_{n+1} | {y_i}, w) 。如果我们假设每个数据点的预测误差服从高斯分布，那么这个联合似然可以分解为期望数据和非期望数据两部分似然的乘积。

我们希望模型能 最大化 对期望数据的似然，同时 最小化 对非期望数据的似然。等价地，我们可以最大化期望数据的似然与非期望数据的“反似然” (1 - 似然) 的乘积。通过对这个乘积取负对数，我们就得到了EMSE损失函数：

L_EMSE(w) = Σ_{i in wanted} (y_i - ŷ_i)^2 - Σ_{j in unwanted} log( 1 - (1/√π) * exp(-(y_j - ŷ_j)^2) )

注意 ：公式中的 σ （高斯分布的标准差）被设定为 1/√2 ，这是一个重要的超参数。它的选择影响了“遗忘”的强度。 σ 越小，高斯分布越“尖锐”，模型对误差的惩罚/奖励越敏感。在实际应用中，这可能需要根据数据噪声水平进行调整。

第一项 Σ (y_i - ŷ_i)^2 就是传统的MSE在期望数据上的部分，最小化它使模型拟合期望数据。 第二项 -Σ log(1 - ...) 是关键。对于非期望数据，当模型预测误差 (y_j - ŷ_j)^2 很小时， exp(-(误差)) 接近1，导致 log(1 - 一个接近1的数) 会趋向负无穷，从而使整个第二项变得非常大（因为前面有负号）。为了最小化总损失 L_EMSE ，优化器会被迫让模型在非期望数据上的预测误差 (y_j - ŷ_j)^2 变大，从而使 exp(-(大误差)) 接近0，让第二项整体趋近于0。这就巧妙地实现了“最大化非期望数据误差”的目标。

2.2 与简单重训练及差分隐私的对比

你可能会问，为什么不直接拿掉非期望数据，只用期望数据重新训练一个模型？这确实是一种方法，但存在两个主要问题：

1. 计算成本 ：对于大型模型（如大语言模型），重新训练的成本是天文数字。
2. 信息残留 ：在某些复杂模型（如深度神经网络）中，即使移除了数据，其“影子”或统计特征仍可能通过与其他数据的复杂交互残留在模型中。EMSE方法通过主动的、有目标的优化来压制这些残留信息。

另一种常见思路是 差分隐私 。它在训练时向梯度或输出中添加噪声，以保护单个数据点的隐私。但差分隐私是一种 预防性 的、全局性的隐私保护，它会以整体模型性能的轻微下降为代价。而遗忘算法是 纠正性 的、针对性的。它用于模型发布后，需要应对特定数据删除请求（如GDPR中的“被遗忘权”）的场景。两者目标不同，有时甚至可以结合使用。

3. 实验设计与全流程实操

理论需要实践来验证。我设计了一个清晰的实验，使用多项式回归作为示例模型，因为它直观且易于可视化。整个流程分为数据准备、全数据训练、遗忘训练和评估四个阶段。

3.1 环境准备与数据合成

首先，我们创建一个可控的实验环境。我选择使用Python，主要库包括NumPy、Matplotlib和Scikit-learn。虽然Scikit-learn提供了现成的回归器，但为了彻底理解优化过程，我选择用PyTorch来实现，因为它能让我们精细控制损失函数和优化过程。

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt

# 设置随机种子，确保实验可复现
torch.manual_seed(42)
np.random.seed(42)

接下来，合成数据。我们假设期望数据服从一个简单的正弦波加噪声，而非期望数据则是另一个不同相位的正弦波，模拟两种需要被区分的模式。

def generate_data(n_samples=200):
    """生成期望和非期望数据"""
    x = np.linspace(-3, 3, n_samples)
    # 期望数据：正弦波
    y_wanted = np.sin(x) + 0.1 * np.random.randn(n_samples)
    # 非期望数据：相位偏移的正弦波
    y_unwanted = np.sin(x + 1.5) + 0.1 * np.random.randn(n_samples)
    # 将数据点随机分配给两个集合
    indices = np.arange(n_samples)
    np.random.shuffle(indices)
    split_idx = n_samples // 2
    wanted_idx = indices[:split_idx]
    unwanted_idx = indices[split_idx:]
    return (torch.tensor(x[wanted_idx], dtype=torch.float32).view(-1, 1),
            torch.tensor(y_wanted[wanted_idx], dtype=torch.float32).view(-1, 1),
            torch.tensor(x[unwanted_idx], dtype=torch.float32).view(-1, 1),
            torch.tensor(y_unwanted[unwanted_idx], dtype=torch.float32).view(-1, 1))

X_w, y_w, X_u, y_u = generate_data()

3.2 模型定义与全数据训练

我们定义一个简单的多项式回归模型，实际上是一个线性层，但其输入是原始x值的多项式特征扩展。

class PolynomialRegression(nn.Module):
    def __init__(self, degree=5):
        super().__init__()
        self.degree = degree
        # 线性层，输入是degree+1个特征（x^0, x^1, ..., x^degree）
        self.linear = nn.Linear(degree + 1, 1)
    def forward(self, x):
        # 构建多项式特征
        poly_features = torch.cat([x ** i for i in range(self.degree + 1)], dim=1)
        return self.linear(poly_features)

model_all = PolynomialRegression(degree=5)
criterion_mse = nn.MSELoss()
optimizer = optim.Adam(model_all.parameters(), lr=0.01)

现在，用 所有数据 （期望+非期望）训练这个模型，模拟一个“被污染”的初始模型状态。

def train_on_all_data(model, X_w, y_w, X_u, y_u, epochs=1000):
    X_all = torch.cat([X_w, X_u], dim=0)
    y_all = torch.cat([y_w, y_u], dim=0)
    losses = []
    for epoch in range(epochs):
        optimizer.zero_grad()
        pred = model(X_all)
        loss = criterion_mse(pred, y_all)
        loss.backward()
        optimizer.step()
        losses.append(loss.item())
        if epoch % 200 == 0:
            print(f'Epoch {epoch}, Loss: {loss.item():.4f}')
    return losses

loss_history_all = train_on_all_data(model_all, X_w, y_w, X_u, y_u)

训练完成后，我们可视化模型在全数据上的拟合情况。通常会发现，模型试图在期望数据和非期望数据之间找到一个“妥协”的曲线，导致对期望数据的拟合也不佳（R-squared较低）。这正是我们需要解决的问题。

3.3 实现EMSE损失与遗忘训练

这是最核心的一步。我们需要实现自定义的EMSE损失函数，并用它来优化已经预训练过的模型。

def emse_loss(pred_w, y_w, pred_u, y_u, sigma=1/np.sqrt(2)):
    """计算伦理均方误差损失"""
    # 期望数据部分：标准MSE
    mse_wanted = torch.mean((pred_w - y_w) ** 2)
    # 非期望数据部分：最大化误差项
    error_u = (pred_u - y_u) ** 2
    # 防止log(0)或数值溢出，添加一个微小的稳定项epsilon
    epsilon = 1e-8
    # 根据公式计算，注意sigma已代入
    C = 1.0 / (np.sqrt(np.pi))  # 当 sigma = 1/sqrt(2) 时的常数项
    unwanted_term = -torch.mean(torch.log(1 - C * torch.exp(-error_u) + epsilon))
    # 总损失
    total_loss = mse_wanted + unwanted_term
    return total_loss, mse_wanted, unwanted_term

实操心得 ： torch.log(1 - C * torch.exp(-error_u)) 在 error_u 很小（即模型在非期望数据上预测很准）时， exp(-error_u) 接近1，可能导致对 1 - 一个接近1的数 取对数，产生数值不稳定（趋向 -∞）。因此，添加一个极小的 epsilon 至关重要。但 epsilon 也不能太大，否则会影响梯度的准确性。我经过测试， 1e-8 是一个比较稳健的值。

现在，使用这个损失函数对已经训练好的 model_all 进行“遗忘训练”。注意，这次我们只使用EMSE损失，并且优化器作用于同一个模型。

def unlearn_model(model, X_w, y_w, X_u, y_u, epochs=500, lr=0.005):
    """对预训练模型进行遗忘训练"""
    optimizer_unlearn = optim.Adam(model.parameters(), lr=lr)
    loss_history = []
    for epoch in range(epochs):
        optimizer_unlearn.zero_grad()
        pred_w = model(X_w)
        pred_u = model(X_u)
        loss, mse_w, term_u = emse_loss(pred_w, y_w, pred_u, y_u)
        loss.backward()
        optimizer_unlearn.step()
        loss_history.append(loss.item())
        if epoch % 100 == 0:
            print(f'Unlearn Epoch {epoch}, Total Loss: {loss.item():.4f}, MSE_W: {mse_w.item():.4f}, Term_U: {term_u.item():.4f}')
    return loss_history

unlearn_history = unlearn_model(model_all, X_w, y_w, X_u, y_u, epochs=800)

在训练过程中，你应该观察到 MSE_W （期望数据MSE）稳步下降，而 Term_U （非期望数据项）初期可能较大（因为模型还记得非期望数据），随后也逐渐下降，意味着模型正在成功“放大”其在非期望数据上的误差。

3.4 结果可视化与对比分析

训练完成后，最激动人心的部分就是可视化对比。

def plot_comparison(model_before, model_after, X_w, y_w, X_u, y_u, x_range=(-3, 3)):
    """对比遗忘前后的模型拟合曲线"""
    x_plot = torch.linspace(x_range[0], x_range[1], 300).view(-1, 1)
    with torch.no_grad():
        y_before = model_before(x_plot).numpy()
        y_after = model_after(x_plot).numpy()
    plt.figure(figsize=(12, 5))
    # 遗忘前
    plt.subplot(1, 2, 1)
    plt.scatter(X_w.numpy(), y_w.numpy(), c='blue', alpha=0.6, label='Wanted Data', s=20)
    plt.scatter(X_u.numpy(), y_u.numpy(), c='green', alpha=0.6, label='Unwanted Data', s=20)
    plt.plot(x_plot.numpy(), y_before, 'r-', linewidth=2, label='Learned Model')
    plt.title('Model Trained on ALL Data')
    plt.xlabel('X')
    plt.ylabel('Y')
    plt.legend()
    plt.grid(True, alpha=0.3)
    # 遗忘后
    plt.subplot(1, 2, 2)
    plt.scatter(X_w.numpy(), y_w.numpy(), c='blue', alpha=0.6, label='Wanted Data', s=20)
    plt.scatter(X_u.numpy(), y_u.numpy(), c='green', alpha=0.6, label='Unwanted Data', s=20)
    plt.plot(x_plot.numpy(), y_after, 'r-', linewidth=2, label='Unlearned Model')
    plt.title('Model After Unlearning (EMSE)')
    plt.xlabel('X')
    plt.ylabel('Y')
    plt.legend()
    plt.grid(True, alpha=0.3)
    plt.tight_layout()
    plt.show()

# 假设我们克隆了一个遗忘前的模型用于对比
model_before_unlearn = PolynomialRegression(degree=5)
model_before_unlearn.load_state_dict(model_all.state_dict()) # 先保存全数据训练的状态
# 然后对 model_all 进行遗忘训练（上文已做）
# ...
# 训练后，调用对比函数
plot_comparison(model_before_unlearn, model_all, X_w, y_w, X_u, y_u)

在结果图中，你会清晰地看到，遗忘后的红色曲线会紧紧贴合蓝色点（期望数据），同时显著地偏离绿色点（非期望数据）。计算R-squared也会发现，模型在期望数据上的性能通常会有显著提升。

4. 评估指标：超越R平方的公平性度量

仅仅观察曲线和R平方是不够的。我们需要量化的指标来评估遗忘算法的双重目标：1) 对期望数据拟合得好，2) 对非期望数据拟合得差。原文提出了两个创新指标。

4.1 指数化R平方

传统的R平方 R^2 = 1 - RSS/TSS 衡量的是模型对数据的解释程度。 R^2 越接近1，拟合越好。为了衡量“拟合得差”的程度，我们对其进行一个指数变换：

Exponential R^2 = 1 - exp(-(1 - R^2))

这个变换的妙处在于：

• 当 R^2 -> 1 （拟合极好）时， (1 - R^2) -> 0 ， exp(0)=1 ，所以 Exponential R^2 -> 0 。
• 当 R^2 -> 0 （拟合极差）时， (1 - R^2) -> 1 ， exp(-1)≈0.367 ，所以 Exponential R^2 -> 0.633 。
• 当 R^2 为负（模型比均值预测还差）时， (1 - R^2) > 1 ， exp(-一个大于1的数) 更小， Exponential R^2 更大，趋近于1。

因此， Exponential R^2 越接近1，表示模型对该数据集的代表性越差，即“遗忘”效果越好 。我们将其应用于非期望数据集上来衡量遗忘程度。

def exponential_r2(y_true, y_pred):
    """计算指数化R平方"""
    ss_res = torch.sum((y_true - y_pred) ** 2)
    y_mean = torch.mean(y_true)
    ss_tot = torch.sum((y_true - y_mean) ** 2)
    if ss_tot == 0:
        return torch.tensor(1.0) # 如果数据无波动，认为模型无法代表
    r2 = 1 - ss_res / ss_tot
    exp_r2 = 1 - torch.exp(-(1 - r2))
    return exp_r2.item()

4.2 公平R平方

我们的终极目标是得到一个单一指标，同时反映模型在期望数据上的“好”和在非期望数据上的“差”。原文提出了“公平R平方”，其思想是计算模型“同时满足代表期望数据且不代表非期望数据”这一联合事件的概率。

如果假设这两个事件独立，那么： Fair R^2 = P(代表期望) * P(不代表非期望) = (R^2_wanted) * (Exponential R^2_unwanted)

这里有一个关键点：原文公式是 (1 - Exponential R^2_wanted) * Exponential R^2_unwanted ，这基于的假设是“代表”等价于“非指数化R平方接近1”。但更直观的理解是，直接用期望数据的传统 R^2 （代表拟合优度）乘以非期望数据的 Exponential R^2 （代表遗忘程度）。两者都应是越高越好。

def fair_r_squared(model, X_w, y_w, X_u, y_u):
    """计算公平R平方（基于独立假设）"""
    with torch.no_grad():
        pred_w = model(X_w)
        pred_u = model(X_u)
    # 计算期望数据的传统R^2
    ss_res_w = torch.sum((y_w - pred_w) ** 2)
    ss_tot_w = torch.sum((y_w - torch.mean(y_w)) ** 2)
    r2_wanted = 1 - ss_res_w / ss_tot_w if ss_tot_w != 0 else 0
    # 计算非期望数据的指数化R^2
    exp_r2_unwanted = exponential_r2(y_u, pred_u)
    # 公平R平方
    fair_r2 = r2_wanted.item() * exp_r2_unwanted
    return fair_r2, r2_wanted.item(), exp_r2_unwanted

一个优秀的遗忘模型，其 fair_r2 应该接近1，这意味着 r2_wanted 高且 exp_r2_unwanted 也高。

4.3 独立假设的挑战与应对策略

“公平R平方”公式的独立性假设是一个理想情况。现实中，期望数据和非期望数据可能高度相关或交织在一起。例如，在图像分类中，要忘记“猫”的某个子类（如黑猫），但记住其他“猫”和所有“狗”，这两类数据在特征空间中是高度重叠的。

当数据不独立时，强行最大化 Fair R^2 可能会导致模型陷入两难，性能提升有限。此时，我们需要：

1. 检验独立性 ：可以通过计算两个数据集在特征空间中的分布距离（如MMD距离）或预测结果的相关性来初步判断。
2. 调整模型容量 ：使用更复杂的模型（如更高次多项式、更深的网络）可以提供更大的灵活性来寻找同时满足两个目标的解。但这也会增加过拟合风险。
3. 调整损失权重 ：在EMSE损失中，可以为期望数据项和非期望数据项引入权重系数 α 和 β ： L = α * MSE_wanted + β * (-log(...)) 。通过调整 α/β 的比例，可以在“保持记忆”和“强制遗忘”之间进行权衡。
4. 迭代式遗忘 ：对于极度困难的情况，可以考虑分阶段遗忘。先对非期望数据做一个较强的遗忘，然后再用期望数据对模型进行轻微的微调，以恢复部分可能受损的性能。

5. 实战中的挑战、调优与扩展

在实际项目中应用遗忘算法，远不止跑通一个demo那么简单。下面是我在多次实践中总结出的关键挑战和应对策略。

5.1 超参数调优：学习率与Sigma

• 学习率 ：遗忘训练通常是在一个预训练模型上进行的，此时参数已经位于一个损失平面的局部最小值附近。使用太大的学习率可能会让参数“跳出”这个谷底，导致模型崩溃（对期望数据的性能也急剧下降）。我的经验是，遗忘训练的学习率应比初始训练的学习率小一个数量级。例如，初始训练用 lr=0.01 ，遗忘训练可以从 lr=0.001 开始尝试。
• Sigma ：EMSE公式中的 σ 隐含在常数 C 中。 σ 控制着高斯分布的宽度，进而影响对误差的敏感度。 σ 越小， exp(-error/σ^2) 衰减得越快，意味着模型对“小误差”的惩罚（在非期望数据上）更严厉。这可能导致优化过程更激进、更不稳定。一个实用的方法是将其作为一个可调超参数，或者将其与数据本身的噪声水平关联起来。你可以尝试一个简单的网格搜索，观察不同 σ 下最终 Fair R^2 的变化。

5.2 处理大规模非期望数据

当非期望数据量很大，甚至与期望数据量相当时，EMSE损失中的第二项（求和项）的梯度可能会主导整个优化过程，导致模型过于关注“遗忘”而忽略了“保持记忆”。对策是引入 批次平衡 。在每次训练迭代中，从期望数据和非期望数据中分别采样 相同数量 的批次，然后计算损失。这样可以确保两项的梯度贡献在量级上大致平衡。

def balanced_unlearn_epoch(model, X_w, y_w, X_u, y_u, batch_size=32, optimizer):
    """进行一次平衡批次的遗忘训练迭代"""
    model.train()
    total_loss = 0
    # 随机打乱数据索引
    idx_w = torch.randperm(X_w.size(0))
    idx_u = torch.randperm(X_u.size(0))
    # 计算需要多少个批次
    n_batches = min(len(idx_w), len(idx_u)) // batch_size
    for b in range(n_batches):
        optimizer.zero_grad()
        # 采样批次
        batch_w = idx_w[b*batch_size: (b+1)*batch_size]
        batch_u = idx_u[b*batch_size: (b+1)*batch_size]
        X_batch_w, y_batch_w = X_w[batch_w], y_w[batch_w]
        X_batch_u, y_batch_u = X_u[batch_u], y_u[batch_u]
        # 前向传播
        pred_w = model(X_batch_w)
        pred_u = model(X_batch_u)
        # 计算EMSE损失
        loss, _, _ = emse_loss(pred_w, y_batch_w, pred_u, y_batch_u)
        # 反向传播与优化
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    return total_loss / n_batches

5.3 从回归到分类：损失函数的适配

本文以回归问题为例。对于分类问题（如图像分类中忘记某个类别），EMSE的思想同样适用，但损失函数需要调整。对于分类，我们通常使用交叉熵损失。我们可以构造一个“伦理交叉熵损失”：

L_ECE = CE_wanted - λ * Σ_{j in unwanted} log(1 - p_j)

其中， CE_wanted 是期望数据上的标准交叉熵， p_j 是模型对非期望数据真实类别的预测概率。最小化这个损失，意味着在降低期望数据分类误差的同时， 降低 模型对非期望数据做出正确分类的 置信度 （即让 p_j 变小）。 λ 是一个权衡参数。这里同样需要注意数值稳定性， log(1 - p_j) 在 p_j 接近1时会出问题。

5.4 验证与监控：防止“灾难性遗忘”

遗忘算法最危险的情况是“灾难性遗忘”，即模型在忘记非期望数据的同时，也忘记了大部分期望数据。为了监控这一点，必须设立一个 干净的验证集 。这个验证集应完全由与训练期望数据同分布、但未被用于训练的数据组成。在遗忘训练的每个epoch或每N个step后，都在这个验证集上评估性能（如准确率、MSE）。一旦发现验证集性能下降超过某个阈值（例如5%），就应停止训练或回滚到之前的检查点。这为遗忘过程提供了一个安全网。

6. 总结与展望

机器学习模型遗忘不是一个纯粹的学术问题，它在数据合规、隐私保护、偏见修正和持续学习等领域有着迫切的实际需求。本文详细拆解的基于EMSE的遗忘算法，提供了一条从理论推导到工程实现的清晰路径。它通过巧妙地重构损失函数，将“遗忘”这个抽象目标转化为可优化的数学问题。

从我个人的实践来看，这项技术的成功应用高度依赖于对问题本身的理解：你的期望数据和非期望数据是界限分明的，还是犬牙交错的？遗忘的强度需要多大？模型是否有足够的容量来同时完成两个看似矛盾的任务？回答这些问题，需要反复的实验、严谨的评估和细致的调参。

未来，一个值得探索的方向是将这种基于目标函数修改的方法与 模型编辑 技术结合。例如，可以先定位模型��与特定非期望知识最相关的神经元或参数子集，然后针对性地应用遗忘算法，从而实现更精细、副作用更小的知识移除。另一个方向是研究更高效的优化算法，专门用于解决这种包含“最大化误差”项的复杂非凸优化问题，让遗忘过程更快、更稳定。

这项技术赋予了我们修正AI模型的能力，让它不再是数据的被动记忆者，而是可以接受“指令”、进行“反思”的智能体。虽然前路仍有挑战，但每一步探索都让我们在构建更可控、更可信、更负责任的AI系统的道路上走得更远。