简介：面向少样本学习研究者和PyTorch开发者，这份资源是论文《Prototypical Networks for Few-Shot Learning》的PyTorch实现，目标是在仅有少量标注样本的情况下完成图像分类任务，帮助读者快速搭建少样本学习实验环境。压缩包内含12个文件，压缩后大小约135KB，核心代码为7个Python脚本，分别实现模型定义、损失计算、批次采样、训练流程和Omniglot数据集加载等功能；另有2张网络结构示意图、1份说明文档和1份开源许可证。目前已有920人学习或下载，说明该实现得到了较多关注。通过阅读源码，可以掌握原型网络的关键机制——将每个类别映射到嵌入空间中的原型向量，再利用距离度量对新样本进行分类；结合论文阅读，还能深入理解少样本学习中的元学习与度量学习思路，同时模块化设计便于复现实验和扩展其他数据集。
1. Prototypical Networks 是什么：小样本学习里最值得先跑的基线
很多入门 Few-shot Learning 的人第一眼看到 Prototypical Networks，会觉得它朴素得不像深度学习模型：把每个类算出一个"原型向量"，查询样本离哪个原型近就归哪类。但恰恰是这份朴素，让它在 miniImageNet、Omniglot 等标准benchmark上长期稳居前排，甚至被大量后续工作拿来当 backbone。更关键的是，用 PyTorch 实现这样一个模型，代码量可以压缩到 200 行以内，训练开销比微调一个大分类模型低一个数量级，适合从零搭建、快速验证想法。这篇文章写给两类人：一类是刚接触小样本学习、想找一个可靠起点做复现的研究者；另一类是业务上有"每类只有几张标注样本"分类需求、想评估这条技术路线值不值得投入的工程师。我会把原理、可复现代码、参数设置和踩坑记录一次讲透。
2. 原型网络的核心原理：类原型、距离度量与 Episode 训练
2.1 为什么用"类原型"来做小样本分类
小样本分类的难点在于：每个类只有几张图，直接用 softmax 分类器训练，特征提取器会过拟合到这几个样本上。Prototypical Networks 换了一种思路——不直接预测类别，而是让模型学会"把同类样本在特征空间里聚拢、把异类推开"。具体做法是把每个类的支撑集样本的特征取平均，得到该类在嵌入空间中的"原型"；查询样本通过同一个编码器得到特征，再计算与所有原型的距离，距离最近的那个类就是预测结果。
这里有个容易被忽视的细节：为什么平均就够了？因为训练阶段用的是 episode 采样方式，每个 episode 里支撑集和查询集来自同一个任务分布。编码器会被反复要求"把这张查询图映射到距离正确原型最近的位置"，等价于隐式学习了一个对类别可分的度量空间。平均操作本身没有可学习参数，它只是把类别信息压缩成一个点。相比 Matching Networks 那种每次都要对所有支撑样本做注意力加权，原型网络的计算图更简洁，反向传播路径更短，训练更稳。
从工程角度看，类原型方案还有一个实际优势：支撑集规模变化时，不需要改模型结构。今天做 5-way 1-shot，明天做 20-way 5-shot，只需要改采样参数，模型代码不用动。这一点在需要频繁做实验对比时非常省事。我在实际项目中甚至用同一个编码器同时支撑 2-way 和 10-way 的评估，效果都很稳定。
2.2 Episode 采样与支撑集/查询集的划分
要理解 Prototypical Networks，必须先理解 episode 训练机制。传统分类训练是一次拿一个 batch，里面包含所有类别；episode 训练是每次模拟一个小样本任务：随机挑 N 个类别（称为 N-way），每类挑 K 张作为支撑集（support set），再挑 Q 张作为查询集（query set）。模型只在这 N 个类上做分类。这种做法的目的在于让训练时的数据分布和测试时一致——测试时模型面临的就是"从未见过的新类，每类只有 K 张标注样本"。
支撑集用来计算原型，查询集用来计算损失并更新梯度。所以查询集的数量要大于支撑集，一般每个类 15～20 张查询样本。如果支撑集和查询集都很少，梯度信号会非常稀疏，模型几乎学不到东西。我常用 5-way 5-shot 训练，每类支撑 5 张、查询 15 张，这样一个 episode 共有 100 张图，批大小适中，显存压力小。
采样时还有一个关键点：类别必须不重复。也就是说，在一个 episode 内，支撑集和查询集都只能来自选中的那 N 个类，不能混入其他类。这需要数据加载器在每次采样前重新洗牌并分组。很多初学者直接把整个数据集随机切 batch，结果训练分布和测试分布不一致，模型看起来收敛很快，一到测试就崩溃。
下面是一个简单的 episode 采样器实现，核心逻辑写在注释里。
import numpy as np import torch from torch.utils.data import Dataset class EpisodeSampler: """ labels: 每个样本对应的类别 id，shape [N] n_way: 每个 episode 选几个类，例如 5 k_shot: 每个类选几张支撑图，例如 5 n_query: 每个类选几张查询图，例如 15 """ def __init__(self, labels, n_way, k_shot, n_query, episodes=100): self.labels = np.array(labels) self.n_way = n_way self.k_shot = k_shot self.n_query = n_query self.episodes = episodes # 统计每个类有哪些样本索引 self.class_to_indices = {} for idx, lab in enumerate(self.labels): lab = int(lab) if lab not in self.class_to_indices: self.class_to_indices[lab] = [] self.class_to_indices[lab].append(idx) # 过滤掉样本数不足的类 self.valid_classes = [ c for c, idxs in self.class_to_indices.items() if len(idxs) >= k_shot + n_query ] if len(self.valid_classes) < n_way: raise ValueError("有效类别数少于 n_way，请检查数据集") def __len__(self): return self.episodes def __getitem__(self, _): # 随机选 n_way 个类 chosen_classes = np.random.choice(self.valid_classes, self.n_way, replace=False) support_x, support_y = [], [] query_x, query_y = [], [] for i, cls in enumerate(chosen_classes): idxs = self.class_to_indices[cls] # 先随机打乱再切分，保证支撑/查询不重叠 np.random.shuffle(idxs) support_idx = idxs[:self.k_shot] query_idx = idxs[self.k_shot:self.k_shot + self.n_query] support_x.extend(support_idx) support_y.extend([i] * self.k_shot) query_x.extend(query_idx) query_y.extend([i] * self.n_query) return ( torch.tensor(support_x, dtype=torch.long), torch.tensor(support_y, dtype=torch.long), torch.tensor(query_x, dtype=torch.long), torch.tensor(query_y, dtype=torch.long), )这段代码的关键设计：
class_to_indices先把所有样本按类分组，避免每次采样都遍历全量数据，数据量大时效率高。np.random.shuffle(idxs)是防止同一张图既进支撑集又进查询集的关键。如果不打乱直接切片，类别内部的固定顺序会让支撑集和查询集分布不均。- 返回的是样本索引而不是图像本身，真正的图像加载交给 DataLoader 完成。这样采样器和数据预处理解耦，换数据集时不用改采样逻辑。
valid_classes过滤掉样本数不足的类，避免某个类只剩 3 张图却要 5-shot+15-query 导致崩溃。这个防御逻辑在真实数据集里经常救命。
2.3 距离度量的选择：欧氏距离与余弦相似度
原型网络原论文里用的是欧氏距离的平方，配合 softmax 做分类。但很多复现实验会发现，在小型数据集上余弦相似度有时效果更好。区别在哪？欧氏距离假设特征空间各向同性，即所有维度的重要性相同；余弦相似度只关心方向，忽略特征的模长。如果编码器输出的特征模长存在较大方差，欧氏距离会被模长大的向量主导，余弦相似度则能避免这个问题。
从梯度角度分析更直接。原型的计算方式是支撑集特征的平均值，损失函数对支撑特征的梯度通过原型间接传播。用欧氏距离时，梯度方向指向"把查询特征向正确原型拉近、推离错误原型"；用余弦相似度时，因为输入会做 L2 归一化，梯度还包含对特征方向的修正。后者在特征分布不均匀时更稳。
我实际测试过：在 CIFAR-100 划分的 few-shot 任务里，两者差异在 1～2 个百分点内；但在特征分布很不均衡的自建数据集上，余弦相似度能比欧氏距离高 5 个点以上。所以代码里我实现了两种距离，通过一个参数切换，方便实验对比。
def compute_distance(query_feat, proto_feat, metric="euclidean"): """ query_feat: [n_way * n_query, d] proto_feat: [n_way, d] 返回距离矩阵 [n_way * n_query, n_way] """ if metric == "euclidean": # 用 torch.cdist 一次算完所有两两距离，比手动展开更快 return torch.cdist(query_feat, proto_feat, p=2) elif metric == "cosine": # L2 归一化后点积即为余弦相似度，距离=1-相似度 q = F.normalize(query_feat, dim=1) p = F.normalize(proto_feat, dim=1) return 1.0 - torch.mm(q, p.t()) else: raise ValueError(f"Unknown metric: {metric}")参数说明：
torch.cdist在 PyTorch 中实现了高效的批量距离计算，内部对矩阵乘法做了优化，比自己写循环快很多。但注意 p=2 时它算的是欧氏距离，不是欧氏距离的平方。原论文用的是平方距离，梯度的模长会变小，训练时可以考虑把学习率调大一点。- 余弦距离在归一化后使用矩阵乘法完成，显存占用比 cdist 小。当支撑集类别数很大时（比如 20-way），这一点差别很重要。
- 切换 metric 时不需要改动其他任何代码，损失函数和训练循环完全兼容。我的习惯是做实验时先用 euclidean 跑通流程，再切换到 cosine 对比，防止两个变量同时变化导致无法定位问题。
3. 用 PyTorch 搭建原型网络：从数据加载到训练循环
3.1 数据准备与 Episode DataLoader 的组装
上一章的采样器返回的是样本索引，要把索引变成真正的图像张量，还需要一个自定义 Dataset 配合。这里最常踩的坑是 PyTorch 的 DataLoader 默认会将多个返回值合并成 batch，如果直接传索引列表，得到的是一个 shape 为 [batch_size, n_way*k_shot] 的索引矩阵，而不是预期的一维索引。解决方案是让 Dataset 接收索引并返回图像，DataLoader 的 batch_size 设为 1，然后手动 reshape。
另一种更优雅的方式是写一个 EpisodeDataset，每次__getitem__返回一个完整的 episode 图像张量。我倾向于后者，因为它让代码结构更清晰，而且可以自由控制支撑集和查询集的边界。下面是一个完整示例，以 Omniglot 风格的多类图像数据集为例。
import torch from torch.utils.data import Dataset, DataLoader from torchvision import transforms from PIL import Image import os class EpisodeDataset(Dataset): """ data_dir: 根目录，下面每个子文件夹为一个类 sampler: 上一节实现的 EpisodeSampler，提供索引 """ def __init__(self, data_dir, sampler, transform=None): self.samples = [] self.labels = [] self.transform = transform or transforms.ToTensor() # 遍历类目录，建立样本路径列表 for label, cls_name in enumerate(sorted(os.listdir(data_dir))): cls_dir = os.path.join(data_dir, cls_name) if not os.path.isdir(cls_dir): continue for img_name in os.listdir(cls_dir): self.samples.append(os.path.join(cls_dir, img_name)) self.labels.append(label) self.sampler = sampler def load_image(self, idx): img = Image.open(self.samples[idx]).convert("RGB") return self.transform(img) def __len__(self): return len(self.sampler) def __getitem__(self, episode_idx): support_idx, support_y, query_idx, query_y = self.sampler[episode_idx] support_x = torch.stack([self.load_image(i) for i in support_idx]) query_x = torch.stack([self.load_image(i) for i in query_idx]) return support_x, support_y, query_x, query_y transform_train = transforms.Compose([ transforms.Resize((84, 84)), transforms.RandomHorizontalFlip(), transforms.ColorJitter(brightness=0.4, contrast=0.4), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) sampler = EpisodeSampler( labels=train_labels, n_way=5, k_shot=5, n_query=15, episodes=2000, ) episode_dataset = EpisodeDataset(train_dir, sampler, transform_train) loader = DataLoader(episode_dataset, batch_size=1, shuffle=True, num_workers=4)这个组装的三个要点：
batch_size=1是必须的，因为每个样本已经是完整的 episode（支撑集+查询集），不能再让 DataLoader 合并多个 episode。有人会用collate_fn去处理，但在 episode 场景下直接 batch_size=1 是最省事的做法。num_workers=4能明显加快数据加载，因为图像读取和缩放是 CPU 密集型操作。如果遇到 DataLoader 卡死，先把 num_workers 改成 0 排查。- 数据增强只加在训练集，验证和测试不要加随机增强，否则每次评估同一张图特征都不同，结果不稳定。但
Normalize必须一致，否则预训练模型的特征分布会错位。
3.2 特征提取网络与原型计算模块
编码器可以选择任意卷积网络，但要注意小样本场景下参数量至关重要。我在 miniImageNet 上常用的基线是一个四层卷积网络，每层 64 个 3x3 卷积核，中间夹 batch norm 和 ReLU，最后接全局平均池化。这个结构有一个明显优势：特征维度只有 64，原型计算和距离计算的矩阵运算开销极小，在单张 GPU 上训练一轮 2000 episode 不到半小时。
不要一上来就上 ResNet-50 这类大模型。小样本任务的训练数据量小，大模型几乎必然过拟合。除非你有足够的领域内预训练权重，否则四层卷积是一个非常合理的起点。下面给出具体实现。
import torch.nn as nn import torch.nn.functional as F class ConvEncoder(nn.Module): """ 4层卷积编码器，输出 64 维特征向量。 """ def __init__(self, input_channel=3, hidden_dim=64): super().__init__() self.encoder = nn.Sequential( self._conv_block(input_channel, hidden_dim), # 84x84 -> 42x42 self._conv_block(hidden_dim, hidden_dim), # 42x42 -> 21x21 self._conv_block(hidden_dim, hidden_dim), # 21x21 -> 11x11 self._conv_block(hidden_dim, hidden_dim), # 11x11 -> 6x6 ) self.fc = nn.Linear(hidden_dim * 6 * 6, hidden_dim) def _conv_block(self, in_ch, out_ch): return nn.Sequential( nn.Conv2d(in_ch, out_ch, kernel_size=3, padding=1), nn.BatchNorm2d(out_ch), nn.ReLU(inplace=True), nn.MaxPool2d(kernel_size=2, stride=2), ) def forward(self, x): # x: [batch, 3, 84, 84] h = self.encoder(x) # [batch, 64, 6, 6] h = h.view(h.size(0), -1) # 展平 return self.fc(h) # [batch, 64] class ProtoNet(nn.Module): """ 原型网络封装：编码器 + 原型计算 + 距离分类 """ def __init__(self, encoder, metric="euclidean"): super().__init__() self.encoder = encoder self.metric = metric def forward(self, support_x, support_y, query_x): """ support_x: [n_way * k_shot, C, H, W] support_y: [n_way * k_shot] query_x: [n_way * n_query, C, H, W] """ # 1. 编码所有输入 support_feat = self.encoder(support_x) query_feat = self.encoder(query_x) # 2. 按类别聚合原型：每类取平均 n_way = int(support_y.unique().size(0)) proto_list = [] for i in range(n_way): cls_mask = (support_y == i) cls_feat = support_feat[cls_mask] proto = cls_feat.mean(dim=0) # [d] proto_list.append(proto) proto_feat = torch.stack(proto_list) # [n_way, d] # 3. 计算距离并返回 logits dist = compute_distance(query_feat, proto_feat, self.metric) logits = -dist return logits这段代码需要注意的点：
- 支撑集特征的类别聚合使用了 mask 索引，避免了循环中反复做矩阵切片带来的额外开销。当 k_shot 比较小（比如 1-shot）时，
mean(dim=0)实际就是一个特征向量本身，不需要特殊处理。 - 编码器最后的
fc层会把 64x6x6 的 feature map 压成 64 维向量。也可以直接用 adaptive avg pooling 替代 fc，二者效果相近，但 fc 更直观，方便打印特征维度调试。 logits = -dist的原因是 softmax 喜欢大的输入值，距离越小说明越接近，取负后距离最小的类 logit 最大，正好对应正确类别。
3.3 训练循环与损失计算
训练循环本身并不复杂，但有几个细节直接决定模型能不能收敛。第一个是损失函数：对-dist做 softmax 后取交叉熵。PyTorch 的F.cross_entropy内部做了 log_softmax，所以直接把logits和查询标签传进去即可。第二个要注意的是优化器选择，Adam 在小样本任务上通常表现稳定，学习率从 1e-3 起步，比 SGD 调起来省心。
完整训练过程如下。
import torch import torch.nn.functional as F def train_one_epoch(model, loader, optimizer, device): model.train() total_loss = 0.0 correct = 0 total = 0 for batch in loader: support_x, support_y, query_x, query_y = batch support_x = support_x.squeeze(0).to(device) # 去掉 batch 维度 support_y = support_y.squeeze(0).to(device) query_x = query_x.squeeze(0).to(device) query_y = query_y.squeeze(0).to(device) logits = model(support_x, support_y, query_x) loss = F.cross_entropy(logits, query_y) optimizer.zero_grad() loss.backward() optimizer.step() total_loss += loss.item() * query_y.size(0) preds = logits.argmax(dim=1) correct += (preds == query_y).sum().item() total += query_y.size(0) return total_loss / total, correct / total device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = ProtoNet(ConvEncoder()).to(device) optimizer = torch.optim.Adam(model.parameters(), lr=1e-3) for epoch in range(5): loss, acc = train_one_epoch(model, loader, optimizer, device) print(f"Epoch {epoch+1} | Loss {loss:.4f} | Train Acc {acc:.4f}")这个循环里有几个容易被忽略的坑：
squeeze(0)是必须的，因为 DataLoader 的 batch_size=1，每个张量都多了一个维度。忘记 squeeze 会导致编码器把整个 episode 当成一个 batch 输入，支撑集和查询集的边界消失，计算原型的 mask 会错位。optimizer.step()之后不需要手动清空中间变量，PyTorch 的梯度累积只累积在.grad里，zero_grad()已经处理了。但如果是 RNN 之类有隐藏状态的模型，需要另外注意。- 每个 epoch 的 episode 数量由 sampler 的
episodes参数决定。一个 epoch 设置几百个 episode 足够，因为每次的类别组合都不同，数据多样性非常高。5 个 epoch 在 2000 个 episode 下通常已经能看到模型收敛趋势。
4. 训练与评估的完整流程：关键参数和标准协议
4.1 核心超参数：n_way、k_shot、n_query 如何设置
这三个参数直接定义了任务的难度，也决定了模型容量的选择。n_way 越大分类越难，因为查询特征要和其他更多类的原型竞争；k_shot 越大每个原型的估计越准，任务越简单；n_query 决定了每次更新的梯度质量，太小会引入噪声。
我的推荐配置：
- 训练时用 5-way 5-shot，每类 15 张查询图。这个配置在公开数据集上效果稳定，且每个 episode 的支撑集只有 25 张图，显存占用很低。
- 测试时如果要报一个综合指标，可以用 5-way 5-shot 和 5-way 1-shot 各测一遍，两个指标一起报。1-shot 更能反映模型的泛化能力，5-shot 更贴近实际应用场景。
- 如果数据集类别很少，比如只有 6 个类，那就不要强行做 5-way。改用 2-way 或 3-way 并增加每类的查询图数量，这样每个 episode 的监督信号更充足。
k_shot 对原型质量的影响有一个经验规律：从 1-shot 增加到 5-shot，精度一般会提高 10 到 15 个百分点；但从 5-shot 增加到 10-shot 收益明显变小。这是因为原型的方差已经足够小，继续增加支撑集样本主要是让特征估计更平滑，边际收益递减。如果你发现 k_shot 从 5 加到 10 精度几乎没有变化，说明编码器已经接近它的表征上限，该往模型结构或预训练方向努力，而不是继续堆支撑样本。
4.2 小样本分类的标准评估协议：随机种子与多次采样
评估 few-shot 模型有一个极其重要的原则：不能只测一个 episode 就下结论。因为每个 episode 只采样了 N 个类，不同 episode 之间的难度差异巨大——有些类本身相似度高，分类难度天然更大。只测一次，结果可能偏差 20 个百分点以上。标准做法是在测试集上随机采样 1000 个 episode，取平均精度和 95% 置信区间。
评估代码可以复用训练时定义的 model 和 sampler，但有几个关键差异：
- 模型必须切到
eval()模式，关闭 dropout 和 batch norm 的统计更新。 - 测试采样器要从"从未参与训练的新类"中采样，这一点在第 2 章讨论过。常规做法是把数据集的类别划分成 train/val/test 三份，它们互不重叠。
- 评估时不更新梯度，用
torch.no_grad()包裹，减少显存开销。
@torch.no_grad() def evaluate(model, test_dataset, n_way, k_shot, n_query, episodes=1000, device="cpu"): model.eval() acc_list = [] for _ in range(episodes): # 临时采样一个 episode 并加载图像 support_idx, support_y, query_idx, query_y \ = test_dataset.sampler[_] support_x = torch.stack([test_dataset.load_image(i) for i in support_idx]) query_x = torch.stack([test_dataset.load_image(i) for i in query_idx]) support_x = support_x.to(device) query_x = query_x.to(device) logits = model(support_x, support_y.to(device), query_x) preds = logits.argmax(dim=1) acc = (preds.cpu() == query_y).float().mean().item() acc_list.append(acc) mean_acc = np.mean(acc_list) std_acc = np.std(acc_list) / np.sqrt(len(acc_list)) * 1.96 # 95% 置信区间 return mean_acc, std_acc这个评估函数的设计要点：
- 我直接用
test_dataset.sampler[_]而不是重新构造 DataLoader，省去 DataLoader 的 shuffle 开销，评估速度更快。但要求 sampler 的episodes参数至少大于评估次数，否则会索引越界。 support_y不需要做 one-hot，模型内部的 mask 比较直接使用support_y == i，保持整数标签即可。- 1000 次采样后，置信区间一般在 ±1.5 个百分点以内，足以区分不同模型配置的优劣。如果你的实验时间有限，500 次采样也可以接受，但置信区间会宽一些。
4.3 结果解读：精度之外还要看什么
精度是首要指标，但不是唯一指标。我在实际工程里还会记录三个附加指标：每个 episode 的损失方差、混淆矩阵和难例分布。损失方差大说明模型在部分任务上极度不稳定，即使平均精度尚可，上线后面对真实分布会频繁翻车。
计算混淆矩阵时，要按真正的类别 id 对齐，而不是 episode 内的临时标签。因为每个 episode 只包含 N 个类，临时标签 0～N-1 不代表真实类别。正确做法是在评估循环里记录每个查询样本的真实类别 id 和预测的真实类别 id，最后统一统计。
还有一个更隐蔽的问题：模型可能学会了"偷懒"——它并没有真正学到类别的语义特征，而是记住了支撑集和查询集之间的某种特征分布偏差。判断方法很简单：把测试输入换成高斯噪声，如果模型仍然给出高于随机水平的精度，说明特征提取器已经把噪声映射到了某个固定区域，模型的判别依据有问题。这种检查虽然听起来有些极端，但在小样本场景下确实发生过，特别当训练数据很少而特征维度过高时。
5. 避坑指南：原型网络训练中的常见问题与排查
5.1 训练 loss 不降反升：排查学习率和 batch norm
现象：loss 在前几百个 episode 内不降，甚至从 1.6 涨到 1.8。这是我在 PyTorch 复现原型网络时最常遇到的问题。
原因：最常见的是学习率不合适，Adam 的默认学习率 1e-3 在四层卷积编码器上有时偏大，导致 loss 震荡；另一个隐蔽原因是 batch norm 在 episode 训练下失效。由于每个 episode 的支撑集只有 25 张图，batch norm 的统计量在这 25 张图上波动剧烈，导致特征分布不稳。
解决：在_conv_block中把BatchNorm2d换成GroupNorm(num_groups=4)，或者手动设置model.train()和model.eval()的切换。如果确认是学习率问题，把 Adam 学习率降到 3e-4 并加一个余弦退火调度器，一般十来个 epoch 能看到清晰下降。另外检查一下输入图像是否做了 Normalize，未归一化的原始像素值会让梯度尺度变化剧烈。
5.2 训练精度高但测试精度低：类别划分泄漏
现象：训练 acc 能到 95% 以上，但测试 acc 只有 50% 出头，且无论怎么调参都上不去。
原因：数据集的类别划分泄露了。比如我把整个 CIFAR-100 的 100 个类随机分成 80/20 训练测试，而不是按照语义超类划分，测试集的"新类"和训练类共享大量低级特征，理论上不应该这么差。但实际的坑是另一种：如果同一张图片既出现在训练集的某个 episode，又出现在测试集的某个 episode，评估结果虚高。还有一种更微妙的泄露：预训练编码器在 ImageNet 上见过测试类别的相似图像，导致特征分布偏移。
解决：严格按照"新类"原则划分数据。对 miniImageNet 这类数据集，使用标准的类划分列表，不要自己随机切。检查代码里训练和测试采样器是否共用了同一个class_to_indices字典，如果是，务必拆开。对于自定义数据集，按语义或采集批次划分，而不是随机切样本。
5.3 显存充足却 OOM：查询集数量过大
现象：模型很小，batch size 也不大，但训练到一半显存溢出。
原因：问题出在距离矩阵的尺寸。查询特征 shape 是[n_way * n_query, d]，原型是[n_way, d]，距离矩阵是[n_way * n_query, n_way]。当 n_query=15、n_way=5 时只有 375 个元素，完全没问题。但如果为了追求梯度质量把 n_query 提高到 100，且 n_way=20，距离矩阵就是 2000x20=40000 个元素，加上反向传播保存的中间梯度，显存占用迅速膨胀。
解决：用小批量多次更新代替大查询集。比如把一次 20-way 100-query 的 episode 拆成 4 个子任务，每个子任务 20-way 25-query，累积梯度后更新。另外可以检查torch.cdist是否在反向传播时保留了过多中间张量——必要时手写 onclick 距离计算，省掉部分中间结果。
5.4 多卡训练时 episode 状态不同步
现象：用 DataParallel 或 DistributedDataParallel 训练时，每个进程的 loss 不同，精度差异巨大。
原因：episode 采样是随机的，每个进程独立采样了不同的 episode。这本身不是错误，但如果每个进程在一次迭代中采样的类别组合差异太大，同步梯度时会出现噪声，导致收敛不稳定。
解决：最简单的方案是在每个 epoch 开始时用同一个随机种子生成同一批 episode 索引，然后让各进程按索引采样。另一个做法是放弃同步训练，改为每个进程独立训练并定期同步参数——在 few-shot 场景下，模型不大，参数同步的通信开销可以接受。
5.5 验证集效果不错，上线后准确率暴跌：数据分布漂移
现象：在测试集上 80% 准确率，放到线上真实数据只有 50%。
原因：测试集的图像是离线收集的，采集环境干净、类别分布均衡；线上数据来自不同设备、不同光照、包含遮挡和噪声。特征提取器学到的判别特征对这类分布变化极其敏感。
解决：在评估阶段就引入域随机化，比如加入随机灰度化、高斯噪声、随机遮挡（RandomErasing）。更合理的方式是用少量线上数据做一次适配，把线上数据的特征分布对齐到训练时的分布。这类问题没有一劳永逸的解法，但至少应该在项目规划时留出线上数据采集和模型迭代的时间。
6. 进阶技巧：从原型网络到真实项目落地
6.1 用数据增强扩大有效样本量
小样本的核心瓶颈是每类样本太少，数据增强可以部分缓解。但要注意不是所有增强都有效。旋转和翻转对 Omniglot 这类笔画类数据有效，对 CIFAR 类自然图像则效果有限；ColorJitter 对依赖纹理的数据有效，但对边缘明显的医学图像可能是灾难。我的策略是：先做一组 ablation，对比 加/不加 的精度差异，选择收益大于 1 个百分点的增强组合。
一种被反复验证有效的做法是对支撑集和查询集使用不同的增强强度。支撑集可以多加一些强增强，模拟"真实世界中同类物体的多样性"；查询集保持原始图像，保证评估的稳定性。我在一个小规模工业缺陷分类项目中，只靠这一改动就把 5-shot 精度从 68% 拉到了 74%，成本几乎为零。
6.2 用预训练编码器替代随机初始化
随机初始化的四层卷积在小数据集上很容易陷入局部最优。改用 ImageNet 预训练的 ResNet-18 作为编码器，冻结前几层只训练最后几层，收敛速度和最终精度都有明显提升。这不是原型网络的专属技巧，但和 episode 训练机制配合时效果尤其好——预训练特征已经具备较强的类别语义抽象能力，原型网络只需要在这个特征空间里做线性划分。
注意两个坑：第一，预训练模型的输入尺寸通常与数据不一致，需要在前面加一个 resize 层；第二，预训练模型的特征维度较高（ResNet-18 是 512 维），距离计算开销变大，可以在编码器后加一个 128 维的投影头压缩维度。投影头用小网络即可，两到三层 MLP 就够了。
6.3 实际项目落地：先跑通最小闭环再做优化
最后想分享一条真实项目的经验。当业务方问我"只有 50 张图能不能做一个分类模型"时，我不会直接说能或不能，而是先拿一周时间跑通最小闭环：用现成框架搭建 Prototypical Networks，在 10 个类上做 5-shot 验证，把精度和错误样例报告出来。如果精度能到 80% 以上，再投入精力做预训练适配和数据采集；如果连 60% 都到不了，就说明这个任务本质上需要更多数据，继续堆模型只是浪费时间。
评估原型网络是否适合你的任务，可以分三步走：第一步，确认类别数是否有限、每类样本是否少于 20 张；第二步，用预训练编码器+余弦距离做一个快速 baseline，看上限在哪；第三步，结合数据增强和投影头优化，记录每一步的精度变化。记住，小样本学习不是万能的，它的适用边界是"类别可枚举、样本极少、特征可分性尚可"的问题。超出这个边界，该投入数据采集还是得投入。
我个人的习惯是在代码里固定随机种子并保存每次实验的完整配置，这样即使两个月后回来看实验结果，也能通过打印出的参数复现当时的模型行为。这个习惯救过我很多次，希望也能帮到你。
本文还有配套的精品资源，点击获取
)
