Prototypical Networks 原型网络：小样本学习的“星群重心”法

可视化演示

展示时域信号波形与其频域频谱的对应关系，通过调节频率和噪声观察信号分解过程。

核心思想：每个类别都有“重心”

回到观星的场景。你之所以能判断新星星属于哪片星群，不是因为记住了每一颗已知星的位置，而是因为每片星群都有一个“视觉中心”——所有星星环绕着它聚拢。只要这片星群没有被完全打散，中心就具有代表性，新星的归属也就有了依据。这个“视觉中心”，就是类别的原型（prototype）。

在原型网络中，每个类别的原型不是凭空给出的，而是通过对该类别所有已知样本（称为支撑集，support set）的特征向量取平均得到的。为了让“平均”有意义，我们需要先把原始样本送进一个神经网络，将其映射到一个嵌入空间（embedding space）。在这个空间里，属于同一类别的样本彼此靠近，就像同一个星座的星星天然聚在一起。支撑集的平均位置就构成了类别原型。

形式化地说，假设支撑集里类别 $k$ 的样本集合为 $S_k$，经过嵌入函数 $f_\phi$ 后，该类的原型向量定义为：

一句话总结：原型网络之所以“能打”，是因为它把复杂的分类任务化简为“找重心 + 比远近”，就像观星者只需记住每片星群的大致中心，而不是每一颗星的精确位置。

模型结构：观星者的三件套

观星者通常随身携带三样东西：望远镜、星图和量角器。望远镜负责看清星星（提取特征），星图负责标记已知星群（保存支撑集），量角器负责测量角度和距离（判断远近）。原型网络的结构恰好对应这三个组件。

第一个组件是特征提取网络，即嵌入函数 $f_\phi$。它扮演望远镜，把原始图像或特征向量映射到嵌入空间。第二个组件是原型计算模块，它不训练参数，而是做一次简单的算术：把同一类的支撑样本嵌入取平均，得出每个类的原型。第三个组件是距离分类头，它对查询样本与各个原型求距离，再将负距离转换为类别置信度。

整个推理流程可以表示为一个概率公式：给定查询样本 $x$，它属于类别 $k$ 的概率由查询嵌入 $f_\phi(x)$ 与原型 $c_k$ 的距离决定：

这套结构和观星工具一一对应：望远镜负责看清特征，星图负责存样本，量角器负责算距离。三件套缺一不可。

原型向量：支撑集求均值

你可能会问：为什么要用“平均”来代表一个类别？难道一个类别内部没有差异吗？当然有，但小样本场景下我们没有太多信息，平均是一种最稳的估计——就像做饭时不知道每个人口味，最安全的做法是取“大众口味”的平均值。原型向量就是类别信息在嵌入空间中的“大众口味”。

从数学上看，原型向量是对支撑集嵌入的类内平均。这个操作有两个好处：第一，它不引入额外可学习参数，完全由支撑集直接计算，因此面对新类别时无需微调模型；第二，它天然支持任意数量的类别，只需要对每个类分别求均值即可。值得注意的是，虽然“平均”听起来简单，但真正重要的是嵌入函数 $f_\phi$。如果嵌入函数训练得好，同类样本的嵌入自然聚拢，平均值就极具代表性；如果嵌入函数混乱，平均值也会失去意义。所以原型网络的全部学习压力都集中在嵌入网络上——这就像观星者不仅要有一张好星图，更关键的是有一台能把星星“看清”的好望远镜。

在实际训练中，支撑集通常由 $N$ 个类别、每类 $K$ 个样本组成，即所谓的 $N\text{-way } K\text{-shot}$ 设定。$K$ 越小，计算出的原型噪声越大，但原型网络的价值恰恰是在 $K=1$ 或 $K=5$ 时依然保持可用。原型向量的计算完全透明、可解释，这是它优于许多黑箱模型的重要特质。

距离度量：直线还是方向？

有了原型之后，剩下的问题就是“怎么算距离”。现实中，判断两颗星星是否属于同一片星群，既可以用它们之间的直线距离（欧氏距离），也可以用它们之间的方向夹角（余弦距离）。两种度量方式对应两种不同的几何直觉。

欧氏距离关注的是绝对位置差：

它计算查询样本嵌入与原型向量在嵌入空间中的直线长度。余弦距离关注的是方向一致性：

它先算两个向量夹角的余弦值（角度越小，余弦越接近 1），再用 1 减去它得到“距离”。

在实践中，原论文作者发现欧氏距离在小样本分类任务上普遍优于余弦距离。原因是欧氏距离对向量长度更敏感，与“类别中心”的几何结构更匹配：如果把嵌入网络看作一个线性判别模型，欧氏距离下的原型分类恰好等价于高斯判别分析，具有更扎实的理论支持。而余弦距离强行忽略了模长信息，反而丢失了一部分判别能力。当然，在某些语义场景下，余弦距离仍可作为备选。

训练策略：用“情景”练就观星术

原型网络不是在普通数据集上一次性训练，而是采用Episode 元训练策略。观星者不是靠死记硬背某一片夜空来学习，而是反复在随机挑选的若干片星域中练习“找重心”的能力；每次练习都面对一组全新的星群组合。这就逼迫他学会通用的方法，而不是记住特定星空。

每个 episode 的具体流程是：先从全部类别中随机抽取 $N$ 个类别，再从这 $N$ 个类中各自抽取支撑集（$K$ 个样本）和查询集（$Q$ 个样本）。原型网络用支撑集计算原型，再对查询集样本进行分类，最后用分类误差更新嵌入网络的参数。这样一个 episode 就是一个完整的“小规模多分类任务”，模型的每一次更新都发生在任务层面，而不是样本层面。

训练所用的损失函数是查询集上的负对数似然：

通过大量随机组合的 episode 训练，模型学会了在不同类别组合下都能快速找到“重心”并正确分类。这种“见多识广”恰如观星者阅遍无数星域，最终形成了通用的星群识别能力。

Matching 对比：一对一与一对多

在元学习的星空中，原型网络并不孤独。它的近亲 Matching Networks（匹配网络） 同样支持小样本分类，但两者的机制有微妙差异。打个比方：Matching Networks 像是观星者对星空图中的每一颗已知星都单独比对，新星与每颗星分别测距离，再按加权投票决定归属；原型网络则是先把同类星星汇总成一个“代表星星”，再只与代表比远近。

Matching 网络通过注意力机制计算查询样本与所有支撑样本的加权求和，相当于保留每个支撑样本的独立影响。而原型网络先做一次均值聚合，把支撑集压缩成类别原型，再去算距离。这意味着原型网络的计算量更小——查询样本只需和 $N$ 个原型比较，而 Matching 网络需要和全部支撑样本逐个比较。当支撑集很大时，原型网络的推理速度优势非常明显。

但两者并非谁绝对更好。在分布较为复杂、同类样本内部呈多峰分布时，Matching 网络保留逐样本信息的做法可能更有弹性；而在支撑集规模有限、类别边界清晰时，原型网络的均值归纳更稳健。实际选型时，通常把原型网络作为首选基线，因为它是当之无愧的“最简可行方案”，而且解释性更强——原型本身就是一种可解释的类别表征。

代码实践：从星空到 PyTorch

理论落地向来是新手最关心的环节。原型网络的代码并不复杂，核心步骤只有数据组织、模型定义、训练循环和评估。我们先在合成高斯点云数据上模拟“观星”任务：4 片星群（4 个类），每片星群取 5 个已知点（5-shot），其余点作为查询集。嵌入网络用简单的多层感知机即可。

训练阶段的核心是 sample_episode 函数：它从数据集中随机挑类、随机挑支撑集和查询集。模型先用支撑集算出原型，再用欧氏距离分类查询集，最后用交叉熵损失反向传播更新嵌入网络。评估阶段与训练几乎一致，只需在未见过的类别组合上计算准确率即可。整套逻辑与前面讲的“观星术”完全吻合——随机星域 + 找重心 + 比远近。

Python 代码部分将在第 5 节给出完整实现。你可以在本地运行，观察不同 N-way K-shot 配置对准确率的影响，这能帮助你建立起对小样本分类任务最直观的体感。

局限展望：星空亦有边界

原型网络虽然优雅，但并不是万能的。它最大的局限在于数据稀缺：当支撑集每类只有 1 个样本时，原型的方差会非常大，就像只凭一两颗星星很难确定星群重心。另一个问题是分布漂移：如果测试时新类别的数据分布与训练时差异很大，原型的均值估计就会失真，分类效果大打折扣——这好比你在北半球练熟了看星的技巧，突然被扔到南半球，熟悉的星群全变了样。

为了应对这些局限，研究者提出了若干改进方向：一是多原型方法，允许一个类别拥有多个原型，以刻画类内的多峰分布；二是半监督扩展，利用无标注数据来修正原型位置；三是与度量学习结合，通过更强大的嵌入函数让同类样本在嵌入空间中更加紧凑。这些方向都是在原型网络这个坚实基线之上的自然延伸。

理解原型网络的边界，与理解它的优点同样重要。就像一位成熟的观星者，既知道如何用星群重心快速判断归属，也知道何时该拿出星图辅助、何时该借助更精密的仪器。

AI 应用场景

Python 演示

"""Prototypical Networks 原型网络：合成小样本分类"""import torchimport torch.nn as nnimport torch.optim as optimimport numpy as np class EmbeddingNet(nn.Module):    """把原始 2D 坐标映射到嵌入空间的编码器"""    def __init__(self, input_dim=2, hidden_dim=64, output_dim=8):        super(EmbeddingNet, self).__init__()        self.encoder = nn.Sequential(            nn.Linear(input_dim, hidden_dim),            nn.ReLU(),            nn.Linear(hidden_dim, hidden_dim),            nn.ReLU(),            nn.Linear(hidden_dim, output_dim)        )     def forward(self, x):        return self.encoder(x)  def compute_prototypes(support_emb, support_y, num_classes):    """对每个类别求支撑集嵌入的均值，得到原型向量"""    prototypes = []    for cls in range(num_classes):        mask = support_y == cls        class_emb = support_emb[mask]        prototypes.append(class_emb.mean(dim=0))    return torch.stack(prototypes)  def euclidean_distance(x, y):    """批量计算查询嵌入与所有原型之间的欧氏距离"""    x2 = (x ** 2).sum(dim=1, keepdim=True)    y2 = (y ** 2).sum(dim=1, keepdim=True)    cross = 2.0 * torch.matmul(x, y.t())    return torch.sqrt(x2 + y2.t() - cross + 1e-8)  def train_one_episode(model, optimizer, support_x, support_y,                      query_x, query_y, num_classes):    """单个 episode 训练：嵌入->原型->距离->损失->反向传播"""    model.train()    support_emb = model(support_x)    query_emb = model(query_x)    prototypes = compute_prototypes(support_emb, support_y, num_classes)    dists = euclidean_distance(query_emb, prototypes)    logits = -dists    loss = nn.functional.cross_entropy(logits, query_y)    optimizer.zero_grad()    loss.backward()    optimizer.step()    return loss.item()  def sample_episode(features, labels, num_classes, support_size, query_size):    """从数据集随机采样一个 episode：选类、抽支撑集和查询集"""    classes = np.random.choice(np.unique(labels), num_classes, replace=False)    support_x, support_y, query_x, query_y = [], [], [], []    for new_cls, old_cls in enumerate(classes):        idx = np.where(labels == old_cls)[0]        np.random.shuffle(idx)        support_idx = idx[:support_size]        query_idx = idx[support_size:support_size + query_size]        for i in support_idx:            support_x.append(features[i])            support_y.append(new_cls)        for i in query_idx:            query_x.append(features[i])            query_y.append(new_cls)    return (torch.tensor(np.stack(support_x), dtype=torch.float32),            torch.tensor(support_y, dtype=torch.long),            torch.tensor(np.stack(query_x), dtype=torch.float32),            torch.tensor(query_y, dtype=torch.long))  def main():    """在 4 类高斯点云合成数据上训练原型网络"""    np.random.seed(42)    torch.manual_seed(42)    num_classes, support_size, query_size = 4, 5, 15    means = np.array([[0, 0], [4, 0], [0, 4], [4, 4]])    features, labels = [], []    for cls, mean in enumerate(means):        points = np.random.randn(200, 2) * 0.8 + mean        features.append(points)        labels.extend([cls] * 200)    features = np.concatenate(features)    labels = np.array(labels)     model = EmbeddingNet()    optimizer = optim.Adam(model.parameters(), lr=1e-3)    for epoch in range(200):        s_x, s_y, q_x, q_y = sample_episode(            features, labels, num_classes, support_size, query_size)        loss = train_one_episode(model, optimizer, s_x, s_y, q_x, q_y,                                 num_classes)        if (epoch + 1) % 50 == 0:            print("epoch %d | loss %.4f" % (epoch + 1, loss))    print("训练完成")  if __name__ == "__main__":    main()

1. class EmbeddingNet(nn.Module)定义嵌入网络，把原始 2D 坐标映射到 8 维嵌入空间，网络参数就是全部的“可学习参数”。
2. self.encoder = nn.Sequential(...)三层线性层加 ReLU 激活，构成一个简单的特征提取器。
3. def compute_prototypes(...)遍历每个类别，用布尔掩码筛出该类支撑样本，然后 mean(dim=0) 求原型。
4. prototypes.append(class_emb.mean(dim=0))这是原型计算的核心：类内嵌入的均值。
5. def euclidean_distance(x, y)用平方展开方式计算两两欧氏距离，避免显式写循环。
6. logits = -dists把距离取负号，距离越近得分越高，作为 logits。
7. loss = nn.functional.cross_entropy(logits, query_y)对查询集计算交叉熵损失，驱动嵌入网络更新。
8. def sample_episode(...)随机选类、随机抽支撑集与查询集，构造一个元学习任务。
9. classes = np.random.choice(np.unique(labels), num_classes, replace=False)从数据集中不重复抽取 4 个类别。
10. for epoch in range(200)训练 200 个 episode，每个 episode 都面对不同的类别组合。

常见误区

面试题