MetaOptNet元学习实战：基于可微凸优化的特征规模与模型性能平衡指南

1次阅读

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

传统元学习方法如 Prototypical Networks 和 MAML 在解决小样本学习问题时，通常会面临两个关键挑战：

特征提取器与分类器的耦合问题：
在 Prototypical Networks 中，分类器本质上是最近邻分类，完全依赖特征空间的距离度量
MAML 虽然通过元优化提升了模型适应性，但基础分类器仍是简单的线性层
模型复杂度与泛化能力的矛盾：
增加特征维度可以提升表达能力，但会加剧小样本下的过拟合
减小模型规模虽能提高泛化性，却会损失判别特征的学习能力

Prototypical Networks：

\min_\theta \sum\limits_{x_i \in Q} ||f_\theta(x_i) - c_{y_i}||^2

其中 $c_k$ 是支持集类原型

MAML：

\min_\theta \sum_{\mathcal{T}_i} \mathcal{L}_{\mathcal{T}_i}(f_{\theta_i'}) \quad \text{s.t.} \quad \theta_i' = \theta - \alpha \nabla_\theta \mathcal{L}_{\mathcal{T}_i}(f_\theta)

MetaOptNet：

\min_\theta \sum_{\mathcal{T}_i} \mathcal{L}_{\mathcal{T}_i}(\text{SVM}(f_\theta(X_{\text{supp}}), Y_{\text{supp}}), Y_{\text{query}})

关键突破：用可微 SVM 替代线性层

import torch
import torch.nn as nn
from qpth import qp, QPFunction

class DifferentiableSVM(nn.Module):
    def __init__(self, feature_dim, reg=1.0):
        super().__init__()
        self.reg = reg
        self.feature_dim = feature_dim

    def forward(self, support_features, query_features, support_labels):
        """
        实现 SVM 的对偶形式求解
        参数:
            support_features: [n_support, feature_dim]
            query_features: [n_query, feature_dim] 
            support_labels: [n_support] (0~n_way-1)
        """
        n_way = len(torch.unique(support_labels))
        n_support = len(support_labels)

        # 构造 QP 问题的参数
        K = torch.mm(support_features, support_features.t())  # 核矩阵
        Y = 2 * F.one_hot(support_labels) - 1  # 标签转为±1
        G = torch.diag(Y.float()).mm(K).mm(torch.diag(Y.float()))

        # 转换为标准 QP 形式: min_x 0.5 x^T G x + a^T x, s.t. Cx <= b
        Q = G + torch.eye(n_support) * self.reg  # 正则化项
        p = -torch.ones(n_support)  # 对偶变量 α 的线性项
        A = Y.float().unsqueeze(0)  # 等式约束 ∑αy=0
        b = torch.zeros(1)

        # 使用 QP 求解器（自动微分兼容）alpha = QPFunction()(Q, p, A, b, torch.zeros(n_support), None)[0]

        # 计算支持向量权重
        w = torch.mm(torch.diag(Y.float() * alpha), support_features).sum(0)

        # 计算查询集预测
        scores = torch.mm(query_features, w.unsqueeze(-1))
        return scores

Hessian 矩阵近似：
实际实现中使用 QPTH 库的隐式微分
反向传播时自动计算 $\frac{\partial \alpha}{\partial Q}$
核技巧处理：
代码中 K 矩阵支持替换为 RBF 等核函数

保持端到端可微性：

# 示例：RBF 核实现
def rbf_kernel(x1, x2, gamma=1.0):
    dist = torch.cdist(x1, x2, p=2)
    return torch.exp(-gamma * dist.pow(2))

方法	1-shot Acc	5-shot Acc	训练时间(epoch)
PrototypicalNet	49.42%	68.20%	2.1h
MAML	48.70%	63.11%	3.8h
MetaOptNet-SVM	53.64%	72.63%	2.7h

测试环境：NVIDIA V100 32GB, batch_size=16

特征提取器学习率通常设为 SVM 层的 1 /10

optimizer = torch.optim.Adam([{'params': feature_extractor.parameters(), 'lr': 1e-4},
    {'params': svm_layer.parameters(), 'lr': 1e-3}
])

QP 问题收敛检查：
监控对偶间隙(dual_gap)
典型值应小于 1e-5

当特征维度 >1000 时：

使用梯度检查点(Gradient Checkpointing)
分批次计算核矩阵

示例代码：

# 分块计算大矩阵
def chunked_kernel(x1, x2, chunk_size=512):
    n = len(x1)
    K = torch.zeros(n, n, device=x1.device)
    for i in range(0, n, chunk_size):
        for j in range(0, n, chunk_size):
            K[i:i+chunk_size, j:j+chunk_size] = rbf_kernel(x1[i:i+chunk_size], 
                x2[j:j+chunk_size]
            )
    return K

将 ROI 特征作为支持集

修改 QP 约束条件：

\begin{cases}
\sum_{i \in pos} \alpha_i = \sum_{j \in neg} \alpha_j \\
0 \leq \alpha \leq C
\end{cases}

只需替换 QP 构造部分，例如改为 Logistic Regression：

# 改用 Logistic Regression 的目标函数
Q = 0.5 * torch.mm(support_features.t(), support_features) + \
    torch.eye(feature_dim) * self.reg
p = -torch.mm(support_features.t(), Y.float())

经过在 CIFAR-FS 和 miniImageNet 上的实验验证，MetaOptNet 确实在小样本学习任务中实现了更好的精度 - 效率平衡。相比传统方法，其优势主要体现在：