元学习实战：如何用2-way 5-shot示例解决小样本分类难题

1次阅读

没有评论

共计 2892 个字符，预计需要花费 8 分钟才能阅读完成。

在机器学习领域，数据匮乏是一个普遍存在的挑战。特别是在医疗影像诊断、工业缺陷检测等场景中，获取大量标注样本往往成本高昂甚至不可行。传统深度学习方法在这些小样本场景中表现不佳，主要原因包括：

模型参数过多，容易在小样本上过拟合
缺乏从少量样本中快速学习新概念的能力
难以捕捉类别间的细粒度差异

元学习 (Meta-Learning) 为解决小样本学习问题提供了新思路。在众多元学习方法中，我们重点分析三种典型方法：

MAML(Model-Agnostic Meta-Learning)：通过优化模型初始参数，使其能快速适应新任务
匹配网络(Matching Networks)：使用注意力机制计算样本间相似度
原型网络(Prototypical Networks)：为每个类别计算原型表示，基于距离进行分类

其中，原型网络因其简单高效，特别适合 2 -way 5-shot 任务。2-way 表示每个 episode 包含 2 个类别，5-shot 表示每个类别提供 5 个支持样本。数学表示为：

支持集 $S={(x_i,y_i)}_{i=1}^{N\times K}$，其中 N 为类别数，K 为每类样本数
类别 c 的原型 $p_c=\frac{1}{|S_c|}\sum_{(x_i,y_i)\in S_c}f_\phi(x_i)$
查询样本 x 的类别概率 $p(y=c|x)=\frac{\exp(-d(f_\phi(x),p_c))}{\sum_{c’}\exp(-d(f_\phi(x),p_{c’}))}$

class EpisodeSampler:
    def __init__(self, dataset, n_way, k_shot, q_query):
        self.dataset = dataset
        self.n_way = n_way
        self.k_shot = k_shot
        self.q_query = q_query

    def __iter__(self):
        # 随机选择 n_way 个类别
        classes = np.random.choice(len(self.dataset.classes), 
            self.n_way, 
            replace=False
        )

        # 为每个类别采样 k_shot+q_query 个样本
        support, query = [], []
        for c in classes:
            indices = np.random.choice(len(self.dataset.class_to_idx[c]),
                self.k_shot + self.q_query,
                replace=False
            )
            support.extend(indices[:self.k_shot])
            query.extend(indices[self.k_shot:])

        yield torch.stack(support), torch.stack(query)

class CNNBackbone(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(nn.Conv2d(3, 64, 3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(2),

            nn.Conv2d(64, 64, 3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(2),

            nn.Conv2d(64, 64, 3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(2),

            nn.Conv2d(64, 64, 3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(2)
        )

    def forward(self, x):
        return self.net(x).view(x.size(0), -1)

class PrototypicalNetwork(nn.Module):
    def __init__(self, backbone):
        super().__init__()
        self.backbone = backbone

    def forward(self, support_x, support_y, query_x):
        # 提取特征
        support_z = self.backbone(support_x)
        query_z = self.backbone(query_x)

        # 计算原型
        prototypes = []
        for c in torch.unique(support_y):
            mask = (support_y == c)
            prototype = support_z[mask].mean(0)
            prototypes.append(prototype)
        prototypes = torch.stack(prototypes)

        # 计算距离
        dists = torch.cdist(query_z, prototypes)
        logits = -dists

        return logits

标准化：使用 ImageNet 均值和标准差进行归一化
数据增强：对小样本任务尤为重要，推荐使用：
随机水平翻转
小角度旋转(±15°)
颜色抖动(轻微调整亮度 / 对比度)

使用 Adam 优化器，初始学习率 3e-4
每 1000 个 episode 降低学习率(乘以 0.5)
梯度累积：当 GPU 内存不足时，可累积多个 episode 的梯度再更新

def plot_prototypes(prototypes, labels):
    # t-SNE 降维
    tsne = TSNE(n_components=2)
    points = tsne.fit_transform(prototypes)

    # 绘制散点图
    plt.figure(figsize=(10,8))
    for i, (x,y) in enumerate(points):
        plt.scatter(x, y, label=labels[i])
    plt.legend()
    plt.show()