告别灾难性遗忘：用Python和PyTorch实战持续语义分割（CSS）的三种主流方法

告别灾难性遗忘：用Python和PyTorch实战持续语义分割的三种主流方法

当你的语义分割模型在新类别上表现优异时，旧类别的识别率却断崖式下跌——这种被称为"灾难性遗忘"的现象，正是持续学习要解决的核心问题。作为计算机视觉领域最复杂的任务之一，持续语义分割(CSS)要求模型在保持已有知识的同时，持续吸收新类别的语义信息。本文将带你用PyTorch实现三种最具代表性的CSS方法，这些代码可以直接整合到你的VOC或Cityscapes项目中。

1. 环境准备与基础配置

在开始之前，我们需要搭建一个可扩展的实验环境。建议使用Python 3.8+和PyTorch 1.12+版本，这些版本对后续要使用的对比学习和知识蒸馏特性支持最为完善。

import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import DataLoader, ConcatDataset from torchvision import transforms import numpy as np import matplotlib.pyplot as plt print(f"PyTorch版本: {torch.__version__}") print(f"CUDA可用: {torch.cuda.is_available()}")

基础数据集处理需要特别注意增量学习的特殊性。与常规语义分割不同，CSS要求数据加载器能够智能地混合新旧类别样本：

class CSSDatasetWrapper: def __init__(self, base_dataset, exemplars=None): self.current_data = base_dataset self.exemplars = exemplars or [] def add_task(self, new_dataset, exemplar_size=20): # 使用herding算法选择最具代表性的样本 selected_exemplars = self._select_exemplars(new_dataset, exemplar_size) self.exemplars.extend(selected_exemplars) self.current_data = new_dataset def _select_exemplars(self, dataset, k): # 实现herding样本选择算法 features = extract_features(dataset) exemplars = [] for cls in range(dataset.num_classes): cls_feats = features[labels == cls] mean_feat = cls_feats.mean(0) selected = [] for _ in range(k): residuals = mean_feat - sum(selected)/max(1, len(selected)) idx = np.argmin(np.linalg.norm(cls_feats - residuals, axis=1)) selected.append(cls_feats[idx]) exemplars.extend(selected) return exemplars

2. 数据回放(Exemplar-Replay)实战

数据回放是最直观的CSS方法，其核心思想是保存少量旧类别代表性样本，在新任务训练时混合使用。这种方法虽然简单，但在许多基准测试中表现出惊人的稳定性。

实现关键点：

• 样本选择策略：herding算法优于随机选择
• 回放比例：通常保持新旧样本1:1的比例
• 损失函数调整：需要平衡新旧任务的学习强度

class ExemplarReplayTrainer: def __init__(self, model, device, exemplar_memory): self.model = model.to(device) self.device = device self.memory = exemplar_memory self.criterion = nn.CrossEntropyLoss(ignore_index=255) def train_step(self, new_data_loader, epochs=10): # 创建混合数据集 memory_loader = DataLoader(self.memory, batch_size=new_data_loader.batch_size//2) combined_loader = zip(new_data_loader, cycle(memory_loader)) optimizer = optim.SGD(self.model.parameters(), lr=0.01, momentum=0.9) for epoch in range(epochs): self.model.train() for (new_images, new_labels), (mem_images, mem_labels) in combined_loader: # 合并批次 inputs = torch.cat([new_images, mem_images]).to(self.device) targets = torch.cat([new_labels, mem_labels]).to(self.device) outputs = self.model(inputs) loss = self.criterion(outputs, targets) optimizer.zero_grad() loss.backward() optimizer.step()

提示：实际应用中，建议对回放样本进行轻度数据增强(如随机裁剪、颜色抖动)，这可以进一步提高模型鲁棒性。

下表比较了不同回放策略在VOC 15-5任务上的表现：

3. 知识蒸馏正则化方法

知识蒸馏通过约束新旧模型输出的一致性来保持旧知识，这种方法不需要存储原始数据，适合对隐私要求严格的场景。我们实现了一个改进的MiB(Memory in Batch)算法：

class KnowledgeDistillationLoss(nn.Module): def __init__(self, temperature=2.0): super().__init__() self.temp = temperature self.kl_div = nn.KLDivLoss(reduction='batchmean') def forward(self, new_logits, old_logits, labels, alpha=0.5): # 标准交叉熵损失 ce_loss = F.cross_entropy(new_logits, labels, ignore_index=255) # 知识蒸馏损失 old_probs = F.softmax(old_logits/self.temp, dim=1) new_log_probs = F.log_softmax(new_logits/self.temp, dim=1) kd_loss = self.kl_div(new_log_probs, old_probs) * (self.temp**2) return alpha * ce_loss + (1 - alpha) * kd_loss class MiBTrainer: def __init__(self, model, device): self.model = model.to(device) self.old_model = None self.device = device self.criterion = KnowledgeDistillationLoss() def train_step(self, data_loader, epochs=10): optimizer = optim.AdamW(self.model.parameters(), lr=2e-4) for epoch in range(epochs): self.model.train() for images, labels in data_loader: images, labels = images.to(self.device), labels.to(self.device) outputs = self.model(images) if self.old_model is not None: with torch.no_grad(): old_outputs = self.old_model(images) loss = self.criterion(outputs, old_outputs, labels) else: loss = F.cross_entropy(outputs, labels, ignore_index=255) optimizer.zero_grad() loss.backward() optimizer.step() # 更新旧模型快照 self.old_model = deepcopy(self.model)

知识蒸馏方法需要注意几个关键参数设置：

• 温度参数：通常设置在1.0-3.0之间
• 损失权重：α值需要根据任务难度调整
• 模型快照：建议在每个增量任务后保存模型状态

4. 自监督对比学习方法

自监督方法通过设计辅助任务让模型学习更通用的特征表示，这些特征对新旧类别都具有良好的适应性。我们实现了一个简化的SDR(Semantic-Drift Regularization)算法：

class ContrastiveCSS(nn.Module): def __init__(self, backbone, feature_dim=256): super().__init__() self.backbone = backbone self.projection = nn.Sequential( nn.Conv2d(backbone.feature_dim, feature_dim, 1), nn.ReLU(), nn.Conv2d(feature_dim, feature_dim, 1) ) self.seg_head = nn.Conv2d(feature_dim, num_classes, 1) self.contrast_criterion = NTXentLoss(temperature=0.1) def forward(self, x): features = self.backbone(x) projections = self.projection(features) seg_output = self.seg_head(projections) return seg_output, projections class SDRTrainer: def __init__(self, model, device): self.model = model.to(device) self.device = device def train_step(self, data_loader, epochs=15): optimizer = optim.Adam(self.model.parameters(), lr=3e-4) for epoch in range(epochs): self.model.train() for images, labels in data_loader: images = images.to(self.device) labels = labels.to(self.device) # 生成增强视图 aug_images = strong_augment(images) # 获取输出 seg_out1, proj1 = self.model(images) seg_out2, proj2 = self.model(aug_images) # 计算损失 seg_loss = F.cross_entropy(seg_out1, labels) contrast_loss = self.model.contrast_criterion(proj1, proj2) total_loss = seg_loss + 0.3 * contrast_loss optimizer.zero_grad() total_loss.backward() optimizer.step()

自监督方法的关键在于设计有效的对比学习策略：

• 视图增强：需要使用强数据增强创建不同视图
• 投影头设计：简单的MLP就能获得不错的效果
• 损失权重：对比损失通常设置为分割损失的0.3-0.5倍

5. 方法比较与实战建议

三种方法各有优劣，下表总结了它们的主要特点：

在实际项目中，我通常会采用混合策略：对基础类别使用数据回放确保稳定性，后续增量任务采用知识蒸馏减少存储开销。当遇到样本极度不均衡的情况时，自监督方法往往能带来意外惊喜。