企业官网建设流程全解析

持续学习（Continual Learning）正在经历一场不太容易被察觉、但影响深远的转型。过去几年，一提起持续学习，大多数人的第一反应还是“解决灾难性遗忘的学术课题”：在 MNIST 上拆几个子任务，跑一跑 EWC，看遗忘率下降多少。但从近两年的研究热点、工业落地案例和综述论文的框架来看，这个领域已经不再只是“让模型记得住旧任务”那么简单，而是在回答一个更现实的问题：当模型部署到真实环境后，数据分布不断变化、任务边界模糊、存储和算力有限，模型应该怎样持续进化，而不是推倒重来。

这篇文章想借着 Continual Learning in Transition 这个主题，把持续学习的现状、方法脉络、工程落地方式和一套可运行的示例代码串起来。无论你是刚开始接触增量学习的研究生，还是正在做推荐系统、自动驾驶、机器人或大模型微调的工程师，这篇文章都能提供一份相对完整的地图：它解决什么问题，现在走到哪一步，以及真正动手时最容易踩到哪些坑。

文章会先讲清楚持续学习的基本概念和评测口径，再对比三类主流方法，然后用一个不依赖 GPU 的 PyTorch 示例跑通“Split-MNIST + EWC”的完整流程，最后给出工程落地建议和常见问题排查表。建议收藏备用，写论文实验、做算法选型或准备面试时都可以回来看。

1. 这篇文章真正要解决的问题

先看一个真实场景。你训练了一个图像分类模型，上线后效果不错。三个月后，业务方告诉你：新增了两类商品，旧数据因为合规要求不能长期保存，新数据还在持续产生。如果重新从零训练，每次都要消耗大量算力和数据准备时间；如果不重新训练，模型不认识新类。更麻烦的是，把新旧数据混在一起微调，模型往往会在旧类别上明显退化——这就是经典的灾难性遗忘。

持续学习（Continual Learning，也叫增量学习、终身学习）就是为了解决这类问题而出现的。它要求模型像一个不断学习的人一样：学新知识时，不把旧知识彻底忘掉，同时还能利用旧知识帮助学新知识。这里的核心矛盾是稳定性与可塑性之争：模型太稳定，新任务学不进去；模型太可塑，旧任务立刻被覆盖。

这篇文章要回答的核心问题有三个。第一，持续学习到底在解决什么问题，和普通的“多任务学习”“模型微调”有什么区别。第二，当前主流方法有哪些派系，各自的边界和适用场景是什么。第三，如何用最小成本在你的项目里复现一个持续学习基线，并把评测指标、训练流程、常见坑一次讲清楚。最值得读这篇文章的读者，是那些已经知道“灾难性遗忘”这个名词，但还没有真正动手跑过一个持续学习实验的人，以及正在做算法选型、想知道“这个方法到底行不行”的工程师。

2. 持续学习的基本概念与问题定义

2.1 从“一次性训练”到“序列学习”

传统监督学习的假设是：训练数据和测试数据来自同一个静态分布，模型训练一次就可以部署。但真实世界很少满足这个假设。持续学习把问题重新表述为：模型需要依次学习一系列任务 T1、T2、……、Tn，在学习当前任务时，不能访问或只能有限访问之前任务的训练数据，但要求在完成所有任务后，模型在全部任务上都能保持可用。

这里最容易混淆的是持续学习和多任务学习。多任务学习是同时拿到所有任务的训练数据，一起优化一个模型；持续学习则是顺序到达数据，旧数据可能无法访问。很多新人把持续学习理解成“多了一个增量训练接口”，这是不准确的——增量训练如果不加任何约束，本质上就是在旧模型上继续 SGD，结果基本都会掉向灾难性遗忘。

2.2 灾难性遗忘与稳定性-可塑性困境

灾难性遗忘（Catastrophic Forgetting）指的是：神经网络在拟合新任务数据时，会覆盖掉对旧任务至关重要的权重信息，导致旧任务性能断崖式下降。这不是某一个模型的问题，而是基于梯度下降的神经网络的结构性倾向。原因在于，旧任务的知识分布在整个权重空间中，新任务的梯度更新会同时扰动这些权重。

由此引出持续学习最核心的理论矛盾：稳定性-可塑性困境（Stability-Plasticity Dilemma）。可塑性指模型吸收新知识的能力，稳定性指模型保留旧知识的能力。二者本质上是对立的。持续学习算法的设计目标，就是在二者之间找到合理的平衡点，而不是简单地把某一个指标拉到最高。

2.3 三种评测协议：Task-IL、Domain-IL、Class-IL

持续学习的方法选择和评测结果，高度依赖你使用哪种任务协议。目前学术界最常用的三种协议如下。

很多人实践时栽跟头，就是因为协议没定清楚。比如在 Split-MNIST 上，如果按 Task-IL 评测，模型在推理时知道当前样本来自哪两个数字，可以只在这两个类别上做 softmax，难度会低很多；如果按 Class-IL 评测，模型需要在全部已见类别中做选择，难度显著上升。写论文和做方案对比时，务必在实验配置里写明协议，否则结论没有可比性。

2.4 核心评价指标

持续学习领域常用的评价指标有三个，分别刻画模型在“整体表现”“对旧任务的保持”和“对新任务的帮助”三个维度上的情况。

• 平均准确率（Average Accuracy，ACC）：模型学习完所有任务后，在所有已见任务测试集上的平均准确率。
• 反向迁移（Backward Transfer，BWT）：学习新任务后，模型在旧任务上的准确率相对于刚学完旧任务时的变化量。BWT 为负，说明存在遗忘；越接近 0，说明保持得越好。
• 正向迁移（Forward Transfer，FWT）：模型在学习了前面任务后，对新任务的学习效率相对于从零训练的提升程度。

实操中，最常被关注的是 ACC 和 BWT，因为它们直接反映“能不能用”和“忘得厉不厉害”。在工程汇报里，建议把每个任务的测试准确率做成矩阵，横轴是训练过的任务，纵轴是评估的任务，这样遗忘情况可以一目了然。

3. 持续学习方法的三大流派与当前转型方向

3.1 基于回放的方法（Replay-based）

回放方法的核心思路是：既然模型会忘记旧任务，那就让它在学新任务时“复习”旧内容。最简单的实现是经验回放（Experience Replay），用一个固定大小的内存缓冲区保存旧任务样本，在训练新任务时混合这些旧样本一起更新。复杂一些的方法包括 GEM、A-GEM，它们通过约束新任务梯度方向，保证更新不会提高旧任务上的损失。

回放方法的优点非常直接：效果好且稳定，几乎所有实际项目中，先跑一个 Experience Replay 基线都能获得不错的结果。缺点也明显：需要存储原始样本，带来存储成本和隐私合规问题。因此出现了另一个分支——用生成模型生成旧任务的伪样本，但生成模型的训练本身又是一个不稳定因素。

3.2 基于正则化的方法（Regularization-based）

正则化方法不存储旧数据，而是在损失函数中加入约束项，限制新任务训练时对旧任务重要参数的改动。代表方法包括 EWC（Elastic Weight Consolidation）、SI（Synaptic Intelligence）和 LwF（Learning without Forgetting）。

EWC 的核心思想是：在训练完旧任务后，用 Fisher 信息矩阵估计每个参数对旧任务的重要程度，然后在新任务的损失函数中加上一项带权重的 L2 惩罚，让重要参数的更新幅度变小。这个方法看起来简单，却非常优雅，也是很多人入门的第一个持续学习算法。它的局限在于，当任务数量很多、任务之间差异很大时，仅靠约束权重不足以完全阻止遗忘，而且 Fisher 矩阵的近似计算也有开销。

3.3 基于架构的方法（Architecture-based）

架构方法通过改变模型结构来隔离不同任务的知识。典型代表有 Progressive Neural Networks，每学一个新任务就新增一个子网络，并建立到旧子网络的横向连接；还有 PackNet、HAT 这类参数分配方法，用剪枝或掩码把不同任务的参数隔离出来。

架构方法几乎不会遗忘，因为每个任务的知识存储在独立参数中。但代价是模型体积随任务数量线性增长，推理时需要根据任务 ID 选择对应参数，这对端侧部署不太友好。它更适合任务边界清晰、任务数量可控的场景。

3.4 转型方向：预训练模型、提示学习与理论化

持续学习当前最大的变化，是从“从零训练小模型”转向“基座模型 + 轻量适配”。在大模型时代，与其在全部权重上做持续学习，不如冻结主干网络，只学习少量适配参数，例如 Additive、Prompt 和 Adapter 类的持续学习方法。这类方法把持续学习和参数高效微调结合了起来，在视觉模型和语言模型上都有不少工作。

另一个转型方向是理论化。近年来出现了以 “A Comprehensive Survey of Continual Learning: Theory, Method and Application” 为代表的系统性综述，把持续学习划分成理论、方法和应用三个层面来讨论：理论层面研究任务相似性、泛化边界和可学习性；方法层面继续扩展上述三类算法；应用层面则覆盖开放环境分类、推荐系统、自动驾驶和机器人等真实场景。这意味着持续学习正在从“刷 Benchmark”走向“回答基础问题 + 解决工程问题”并重。对工程师来说，理解这三层有助于判断：哪些新方法只是 Benchmark 上的数字游戏，哪些才能真正迁移到自己的业务场景。

4. 环境准备与数据集划分

4.1 运行环境

本文示例代码基于 PyTorch，MNIST 数据集训练一个两层 MLP，CPU 也可以短时间跑完，不强制要求 GPU。建议环境如下，版本以实际安装为准，这里给出的是通用兼容版本区间。

• Python 3.9 或更高版本
• PyTorch 2.0 或更高版本
• torchvision 0.15 或更高版本
• numpy 1.24 或更高版本

先创建项目目录和虚拟环境：

mkdir continual_learning_demo && cd continual_learning_demo python -m venv venv source venv/bin/activate # Windows 下使用 venv\Scripts\activate

创建requirements.txt文件：

torch>=2.0.0 torchvision>=0.15.0 numpy>=1.24.0

安装依赖：

pip install -r requirements.txt

4.2 为什么选择 Split-MNIST

Split-MNIST 是持续学习领域最常见的入门基准：把 MNIST 的 10 个数字按顺序分成 5 个任务，每个任务包含 2 个数字。比如任务 1 是数字 0 和 1，任务 2 是数字 2 和 3，以此类推。模型依次学习这 5 个任务，训练过程中只能访问当前任务的数据，但评测时要在所有已见任务上测试。

选择这个基准有两个原因。第一，MNIST 规模小，CPU 训练快，便于在几分钟内复现完整流程。第二，任务边界清晰，方便新手理解协议定义。更贴近真实场景的替代基准包括 Split-CIFAR-100、Split-ImageNet 以及带有分布漂移的 Domain-IL 基准，代码逻辑完全一致，只是数据加载方式不同。

5. 完整示例代码实现：基于 EWC 的持续学习

下面实现一个完整的 EWC 训练流程。核心逻辑分四步：构造单任务数据、计算 Fisher 信息、计算 EWC 正则损失、按顺序训练所有任务并记录每个任务上的准确率。

# 文件路径：continual_learning_demo/ewc_demo.py import torch import torch.nn as nn import torch.nn.functional as F from torch.utils.data import DataLoader, Subset from torchvision import datasets, transforms # ---------- 1. 模型定义 ---------- class SimpleMLP(nn.Module): def __init__(self, input_size=28 * 28, hidden_size=256, num_classes=10): super().__init__() self.fc1 = nn.Linear(input_size, hidden_size) self.fc2 = nn.Linear(hidden_size, hidden_size) self.fc3 = nn.Linear(hidden_size, num_classes) def forward(self, x): x = x.view(x.size(0), -1) x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) return self.fc3(x) # ---------- 2. 按类别构造任务数据集 ---------- def make_task_loader(dataset, classes, batch_size=64, shuffle=True): indices = [i for i, (_, label) in enumerate(dataset) if label in classes] subset = Subset(dataset, indices) return DataLoader(subset, batch_size=batch_size, shuffle=shuffle) # ---------- 3. 估计 Fisher 信息（对角近似） ---------- def compute_fisher(model, dataloader, device='cpu'): model.eval() fisher = {name: torch.zeros_like(param) for name, param in model.named_parameters()} total_samples = 0 for x, y in dataloader: x = x.to(device).view(x.size(0), -1) y = y.to(device) model.zero_grad() logits = model(x) loss = F.cross_entropy(logits, y) loss.backward() for name, param in model.named_parameters(): if param.grad is not None: fisher[name] += param.grad.data.pow(2) * x.size(0) total_samples += x.size(0) for name in fisher: fisher[name] /= total_samples return fisher # ---------- 4. EWC 正则损失 ---------- def ewc_penalty(model, fisher_accum, param_anchor, lambda_ewc=500.0): penalty = 0.0 for name, param in model.named_parameters(): if name in fisher_accum and name in param_anchor: penalty += (fisher_accum[name] * (param - param_anchor[name]) ** 2).sum() return lambda_ewc * penalty # ---------- 5. 训练与评估 ---------- def evaluate(model, dataloader, device='cpu'): model.eval() correct, total = 0, 0 with torch.no_grad(): for x, y in dataloader: x = x.to(device).view(x.size(0), -1) logits = model(x) pred = logits.argmax(dim=1) correct += (pred.cpu() == y).sum().item() total += y.size(0) return correct / total * 100 def train_task(model, train_loader, fisher_accum, param_anchor, epochs=5, lr=1e-3, lambda_ewc=500.0, device='cpu'): optimizer = torch.optim.Adam(model.parameters(), lr=lr) for epoch in range(epochs): model.train() total_loss = 0.0 for x, y in train_loader: x = x.to(device).view(x.size(0), -1) y = y.to(device) optimizer.zero_grad() logits = model(x) ce_loss = F.cross_entropy(logits, y) if fisher_accum is not None and param_anchor is not None: penalty = ewc_penalty(model, fisher_accum, param_anchor, lambda_ewc) else: penalty = torch.tensor(0.0) loss = ce_loss + penalty loss.backward() optimizer.step() total_loss += loss.item() print(f" epoch {epoch + 1}: loss={total_loss / len(train_loader):.4f}") # ---------- 6. 主流程 ---------- def main(): device = 'cuda' if torch.cuda.is_available() else 'cpu' print(f"device: {device}") transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ]) train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform) test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform) # Split-MNIST：5 个任务，每个任务 2 个数字 task_classes = [(0, 1), (2, 3), (4, 5), (6, 7), (8, 9)] model = SimpleMLP().to(device) fisher_accum = None # 所有已学任务累积的 Fisher 信息 param_anchor = None # 旧任务训练完成时的参数快照 all_test_loaders = [] for t, classes in enumerate(task_classes): print(f"--- Task {t + 1}: {classes} ---") train_loader = make_task_loader(train_dataset, classes) test_loader = make_task_loader(test_dataset, classes, shuffle=False) all_test_loaders.append((classes, test_loader)) # 在训练新任务之前，保存当前参数作为旧任务锚点 if t > 0: param_anchor = {name: param.detach().clone() for name, param in model.named_parameters()} train_task(model, train_loader, fisher_accum, param_anchor, device=device) # 训练完当前任务后，估计当前任务上的 Fisher 信息并累积 fisher_current = compute_fisher(model, train_loader, device) if fisher_accum is None: fisher_accum = {name: val.clone() for name, val in fisher_current.items()} else: for name in fisher_accum: fisher_accum[name] += fisher_current[name] # 在所有已见任务上评估一次，观察遗忘情况 accs = [] for classes, t_loader in all_test_loaders: acc = evaluate(model, t_loader, device) accs.append(acc) print(f" after task {t + 1}: acc on seen tasks = {[round(a, 2) for a in accs]}") print() if __name__ == '__main__': main()

运行方式：

python ewc_demo.py

这段代码的关键逻辑需要强调几点。

第一，Fisher 信息的计算使用的是简化后的对角近似：在当前任务数据上算交叉熵损失的梯度平方，再对样本求平均。严格来说，Fisher 信息是对数似然梯度外积的期望，但在分类任务中，用交叉熵梯度的平方近似已经足够作为演示，也有不少公开实现采用这种做法。如果追求更精确的结果，可以改为逐类别计算概率加权梯度，但训练速度会明显下降。

第二，参数锚点（param_anchor）和累积 Fisher（fisher_accum）的配合是 EWC 的精髓。在学第 t 个任务时，param_anchor 是学完前 t-1 个任务后的模型参数，fisher_accum 是前 t-1 个任务的 Fisher 累积值。EWC 正则项的意思是：如果某个参数对旧任务很重要，就不要让它偏离锚点太远。这里的“重要程度”由累积 Fisher 决定。

第三，代码在每学完一个任务后，会打印所有已见任务上的测试准确率。你会发现，随着任务推进，早期任务的准确率会波动，但 EWC 约束下的下降幅度通常远小于不做任何约束的普通微调。

为了让对比更直观，可以把 lambda_ewc 设置为 0 再跑一遍，相当于纯微调基线。或者直接注释掉 ewc_penalty 的调用。两轮结果一对比，灾难性遗忘的影响和 EWC 的抑制作用就非常清楚了。

6. 运行结果与效果验证

6.1 如何判断实验成功

运行上面的代码，正常情况下你会看到两类输出。一类是每个 epoch 的 loss，数值整体呈下降趋势；另一类是每个任务结束后的已见任务准确率列表。判断实验成功的关键指标是：学习完第 5 个任务后，模型在第 1 个任务（数字 0/1）上的准确率不能出现断崖式下降。

以经验来看，在 MNIST 上用两层 MLP，单任务本身很容易达到 95% 以上的准确率。如果把 lambda_ewc 设成 0 跑纯微调，学完第 5 个任务后再看第 1 个任务，准确率往往会明显掉下去；而带上 EWC 正则后，这个下降幅度会显著减小。具体数字受随机种子、学习率、Fisher 近似方式和正则系数影响，不同机器上会不一样，所以不建议把某个固定数值当作目标，而是看“有 EWC 与无 EWC 之间的相对差距”。

6.2 记录准确率矩阵

建议把代码输出的准确率整理成如下格式的矩阵，方便写报告或做对比：

对角线往下看是“当前任务的学习效果”，对角线往右看是“旧任务被遗忘的情况”。一个合格持续学习算法的表现是：对角线保持在高位，同时右上角的衰减尽量平缓。

6.3 如果结果不对，先检查哪里

如果运行后出现了“所有任务准确率都很低”或“新任务完全学不动”的情况，优先检查三处：lambda_ewc 是否过大导致正则项压制了交叉熵损失；每个任务的数据加载是否真的只包含当前类别的样本；模型是否每次都在同一个实例上继续训练，而不是误用了“每个任务新建模型”的写法。

7. 常见问题与排查思路

下面整理了持续学习实验中最常见的几类问题，按“现象—原因—排查—解决”的结构列出。

这些坑里，最隐蔽的是数据泄露。持续学习对数据顺序非常敏感，如果 DataLoader 在任务之间做了全局随机 shuffle，或者把多个任务的数据混在一个 loader 里取 batch，就会导致模型“偷看”未来任务的数据，实验结论完全失效。这也是为什么代码里要为每个任务单独构造 DataLoader，而不是把所有数据放在一起按标签切分。

8. 最佳实践与工程建议

8.1 先跑一个简单的回放基线

在实际项目中，不要一上来就尝试复杂的正则化或架构方法。正确顺序是先实现一个最简单的 Experience Replay，用一个小型记忆缓冲区保存旧任务样本，训练新任务时把旧样本混入当前 batch。它的代码改动量最小，效果通常也不错，是判断其他方法是否有效的基准线。

# 文件路径：replay_baseline.py（核心片段，非完整脚本） memory_buffer = [] # 每个元素是 (x.cpu(), y.cpu()) BUFFER_SIZE = 200 SEARCH_BATCH = 64 def update_buffer(x_batch, y_batch, buffer, max_size=BUFFER_SIZE): for x, y in zip(x_batch, y_batch): buffer.append((x.detach().cpu(), y.detach().cpu())) if len(buffer) > max_size: # 简单策略：随机丢弃旧样本 # 工程上可以替换为按样本难度、多样性或代表性采样的策略 import random random.shuffle(buffer) del buffer[max_size:] def sample_replay_batch(buffer, batch_size=SEARCH_BATCH): if not buffer: return None, None indices = torch.randint(0, len(buffer), (min(batch_size, len(buffer)),)) xs, ys = [], [] for idx in indices: x_old, y_old = buffer[idx.item()] xs.append(x_old) ys.append(y_old) return torch.stack(xs), torch.tensor(ys)

这段片段演示了回放方法最核心的“存”和“取”两部分。训练时，把当前 batch 和回放 batch 拼接后一起喂给模型即可。真实工程项目中，缓冲区容量和采样策略往往比算法本身更影响最终效果。随机采样虽然简单，但会导致模型偏向记忆频繁出现的旧样本；基于遗忘程度或样本难度的采样，通常能在相同容量下得到更好的保持效果。

8.2 方法选型判断标准

三类方法没有绝对优劣，选择取决于你的约束条件。

• 如果旧数据可以合法存储，且存储成本可控，优先使用回放类方法，它最稳、最不容易翻车。
• 如果旧数据因为隐私或合规要求不能保留，正则化方法是合理的起点，但要做好长任务序列下遗忘比预期严重的准备。
• 如果任务边界清晰、推理时能拿到任务 ID，并且模型体积可以扩展，架构类方法能提供几乎零遗忘的保证。
• 如果有大规模预训练基座模型，优先考虑冻结主干、只学轻量适配参数的方向，这样既能持续吸收新任务，又不会因全量微调破坏基座的通用能力。

8.3 工程落地注意事项

在真实系统里，持续学习不只是算法问题，还涉及数据链路和运维体系。

第一，评测协议要写进项目文档。团队协作时，如果每个人用不同的协议评测，最后的数字无法互相对比。建议在 README 中固定任务划分、指标公式和评估脚本。

第二，每个任务训练完成后都保存 checkpoint，并记录该任务上的 Fisher 信息或回放缓冲区。这样即使后续任务效果不佳，也能回滚到任意历史版本，而不是只有一个“最新模型”。

第三，生产环境不要直接在线更新主模型。更稳妥的做法是训练影子模型，在小流量灰度验证通过后再切换。持续学习本身就会引入数据分布漂移，如果再叠加在线更新带来的不确定性，出问题时会很难定位。

第四，关注数据合规。回放方法需要缓存旧样本，这在一些业务场景下可能违反数据保留政策。使用前先和合规团队确认样本留存周期和脱敏要求，必要时改用正则化或生成式回放方案。

第五，给模型加漂移监控。持续学习的前提是“数据会变”，但变化速度可能快于模型迭代速度。在服务端记录输入分布的特征统计量，当漂移超过阈值时触发重新训练或告警，比被动等线上指标下跌更可靠。

9. 总结与后续学习方向

本文用一篇可运行的示例，把持续学习的核心问题、三类经典方法和工程落地关键点串了一遍。你现在应该能回答清楚四个问题：持续学习到底解决什么问题；灾难性遗忘为什么会发生；EWC 为什么能缓解遗忘；以及在真实项目里选择方法时应该看哪些约束条件。

如果想继续深入，建议按下面的路径推进。第一步，把本文的 EWC 代码改成 Experience Replay，对比两者的准确率矩阵，理解回放和正则化在机制上的差异。第二步，去读那篇以 Theory、Method and Application 为框架的持续学习综述，重点关注其中对任务相似性和泛化边界的讨论，这能帮助你在新任务出现时预判模型会不会崩。第三步，尝试把方法迁移到你自己的任务序列上，比如推荐场景的新品类、质检场景的新缺陷类型、或 NLP 场景的新意图，从 Split-MNIST 切换到真实数据时，数据不均衡和任务边界模糊会很快暴露出来。

最后提醒一句：持续学习的实验结论非常依赖评测协议，先定协议、再调算法，永远比反过来高效。建议把本文的代码、指标矩阵模板和排查表保存下来，作为后续实验的统一基线。