Once-for-All：一次训练适配多种部署约束

可视化演示

动态演示Once-for-All的核心机制，通过概览/流程/对比/趋势四种模式展示关键概念与交互流程。

诞生背景

在繁华的甜品一条街，老张开了一家蛋糕店。每天都有顾客提出不同要求：王奶奶要一人份小蛋糕，李叔叔要五层大蛋糕，刘太太想要无糖迷你款……老张只能一次次从零开始烘焙，同一款蛋糕反复做不同尺寸，累得团团转。AI 工程师面对的场景几乎一模一样：同一个神经网络模型要部署到手机、平板、电脑、车载芯片等多种设备，每种设备的算力、内存、功耗都不同。

传统的做法是“点一次菜，烤一次蛋糕”：每部署一个新目标，就从头跑一遍神经架构搜索（NAS），再重新训练一个专用模型。NAS 搜索动辄消耗数十甚至上千 GPU 小时，训练又要几天。如果公司有 10 个部署目标，就得把这件事重复 10 遍，成本呈线性爆炸。

OFA（Once-for-All）正是为了解决这个痛点提出的：用一次训练的投资，换来来所有部署场景的模型，把“每家设备单独烤”变成“一胚多切”。它把传统 NAS 中“搜索 + 重训”的反复循环，压缩成一次性的超网训练。

$$\displaystyle C_{\mathrm{total}} = N \times (C_{\mathrm{search}} + C_{\mathrm{train}})$$

1. 单次搜索成本 \(C_{\mathrm{search}}\)：每次用 NAS 在庞大的架构空间里搜索一个合适子网络，需要数千次评估，GPU 消耗巨大。

$$C_{\mathrm{search}}$$

2. 单次训练成本 \(C_{\mathrm{train}}\)：架构确定后，还需要从零开始训练整个模型的参数。

$$C_{\mathrm{train}}$$

3. 部署目标数 \(N\)：需要适配的手机型号、芯片平台、延迟档位的个数。

$$N$$

4. 线性倍增关系：目标越多，总成本同比上涨，没有任何摊薄效应。

$$\times$$

老张痛定思痛：与其一个个烤，不如一次烤一个巨大的、可以任意切分的蛋糕胚？这个念头，正是 OFA 的起点。

核心思想

老张终于想通了。他要做的是“万能千层蛋糕”：一次烘焙一个足够大的蛋糕胚，顾客要多少切多少，从 1 层到 6 层都能切出来，而且每块豆沙、每粒水果都提前分布均匀，切哪块都独立成形、口感依旧。

OFA 的核心思想与此完全一致：训练一个超网（SuperNet），超网中从“最浅最窄”到“最深最宽”蕴含了海量的子网络（SubNet）。部署时，只需从超网中“切出”满足当前硬件约束的那一个子网，把它的权重拷贝出来，即可直接上线推理，无需任何额外训练。

这里的魔法在于“权重共享”：子网并不是各自独立地拥有参数，而是从超网参数中切出一块来用——就像蛋糕胚里的奶油和水果本来就在那，切哪块都能吃到。OFA 发布的超网可以衍生出超过 \(10^{19}\) 种子网配置，覆盖从 20 MFLOPs 到 500 MFLOPs 的广阔算力区间。

$$\displaystyle W_{\mathrm{sub}}(\alpha) \subset W_{\mathrm{super}}, \qquad \forall \alpha \in \mathcal{A}$$

1. 超网参数 \(W_{\mathrm{super}}\)：训练阶段维护的一份完整的、覆盖最大网络规模的参数集合。

$$W_{\mathrm{super}}$$

2. 子网参数 \(W_{\mathrm{sub}}(\alpha)\)：配置为 \(\alpha\) 的子网络实际使用的参数切片，来自超网的某个子集。

$$W_{\mathrm{sub}}(\alpha)$$

3. 包含关系 \(\subset\)：表示子网参数“包含于”超网参数，而不是独立新建。

$$\subset$$

4. 任意配置 \(\alpha\)：只要 \(\alpha\) 落在合法配置空间 \(\mathcal{A}\) 内，都能从超网中切出对应权重。

$$\forall \alpha \in \mathcal{A}$$

这就是老张的“万能大蛋糕”——只要胚子够大够结实，想切哪块切哪块，块块都能吃，而且不用重新烤。

超网设计

万能蛋糕胚不是随便做的。老张得提前规划：蛋糕做多高（几层）、每层多宽、表面装饰颗粒多大——这些都必须预设好弹性空间，否则顾客要的时候无从下手。OFA 的超网设计同样围绕三个弹性维度展开。

第一个维度是弹性深度，即网络有多少层卷积。OFA 的超网从第 1 层到第 \(d_{\max}\) 层按序排列，部署时抽掉后面几层，就得到一个更浅的子网。第二个维度是弹性宽度，即每层有多少个通道。OFA 约定每层只取前 \(w\) 个通道，取多取少都能形成合法子网。第三个维度是弹性核大小，即卷积核是 \(3\times3\)、\(5\times5\) 还是 \(7\times7\)，通过中心裁剪实现切换。

这三个维度的设计要保证一个关键性质：任何组合都能工作。子网不是一个静态网络里的“删除部分”，而是从超网的完整计算图中切出的一个连通的子图。这就像蛋糕胚里每层都均匀布满水果和奶油，无论怎么切，都能保证结构完整。

$$\displaystyle \mathcal{A} = \{(d,\, w,\, k) \mid d \in \mathcal{D},\; w \in \mathcal{W},\; k \in \mathcal{K}\}$$

1. 弹性深度集合 \(\mathcal{D}\)：可选的网络层数，例如 \(\{2,3,4,5,6\}\)。

$$\mathcal{D} = \{d_1, d_2, \ldots, d_{\max}\}$$

2. 弹性宽度集合 \(\mathcal{W}\)：每层可选的通道数，例如 \(\{8,16,32,64\}\)。

$$\mathcal{W} = \{w_1, w_2, \ldots, w_{\max}\}$$

3. 弹性核大小集合 \(\mathcal{K}\)：卷积核尺寸的候选集合，例如 \(\{3,5,7\}\)。

$$\mathcal{K} = \{3, 5, 7\}$$

4. 笛卡尔积组合：三个维度任意组合，共同定义一个具体的子网配置。

$$\times$$

有了可伸缩的设计图纸，老张的蛋糕胚才能根据顾客“切哪儿、切多少”游刃有余——这就是超网设计的核心价值。

渐进式收缩

如果老张一开始就按最笨的 1 层小蛋糕的做法反复训练，那和以前没区别。他的秘诀是“先大后小”：先烘焙一个 6 层、每层很宽的大蛋糕胚，然后逐步尝试切掉多余部分，让每一种小切法都自然好吃。OFA 的渐进式收缩训练，正是这种“先大后小”的课程式策略。

整个训练分成四个阶段。第一阶段只训练最大深度的子网，让网络先学会提取丰富的语义特征；第二阶段放开深度维度，同时支持 2~6 层的子网训练；第三阶段引入多种宽度；最后一个阶段加入多种核大小。每一阶段都在上一阶段基础上，让新加入的弹性维度适应超网现有权重。

为什么要这样安排？如果一开始就随机采样所有维度，小模型很难学好，而大模型又会被小模型的梯度拖累，训练不稳定。渐进式收缩相当于让大蛋糕先定型，再慢慢学会“切开后依然好吃”，既保住了大模型的精度，又给小模型留足了优化空间。

$$\displaystyle \min_{W_{\mathrm{super}}} \;\mathbb{E}_{\alpha \sim P(\alpha)} \;\mathcal{L}\big(f(x;\, W_{\mathrm{sub}}(\alpha)),\, y\big)$$

1. 最小化目标：我们要找到一组超网参数，使期望损失尽可能小。

$$\min_{W_{\mathrm{super}}}$$

2. 数据分布期望：对所有训练样本的损失取平均，保证泛化到整个数据分布。

$$\mathbb{E}_{(x,y)\sim\mathcal{D}}$$

3. 配置采样期望：对所有可能的子网配置按分布 \(P(\alpha)\) 采样，求期望损失。

$$\mathbb{E}_{\alpha \sim P(\alpha)}$$

4. 子网损失函数：子网 \(f(x; W_{\mathrm{sub}}(\alpha))\) 的预测与真实标签 \(y\) 之间的差异度量。

$$\mathcal{L}\big(f(x;\, W_{\mathrm{sub}}(\alpha)),\, y\big)$$

大蛋糕先成型，再一层层、一块块地练习“切出小块依然好吃”——这就是老张的独家烘焙心法，也是 OFA 渐进式收缩的精髓。

子网采样

老张发现，光把蛋糕做大还不够。如果总切同一个位置试吃，其他位置的蛋糕胚始终没被烤透，顾客切到那里就难吃。于是他每次训练时有意识地随机切不同位置、不同大小的蛋糕块来品尝。OFA 在训练超网时，也必须有意识地采样各种子网配置。

如果只训练少数固定的配置，那么未被采样到的子网性能就会很差，这叫“欠拟合”。OFA 的做法是：在每个训练 batch 中，随机采样一个子网配置，只让这个子网对应的路径参与前向和反向传播。下一个 batch 再换一个配置，让所有配置都有机会被优化到。

这里还要警惕“子网耦合”问题：某些子网之所以表现好，是因为它和其他子网共享权重的过程中“搭了便车”，一旦被单独部署就露馅。OFA 通过均匀采样覆盖所有配置，并结合渐进式收缩逐层放开弹性维度，从根源上缓解了子网间的过度耦合。

$$\displaystyle P(\alpha) = \frac{1}{|\mathcal{A}|}, \qquad \forall \alpha \in \mathcal{A}$$

1. 配置空间大小：\(\mathcal{A}\) 中全部可能的子网配置总数。

$$|\mathcal{A}|$$

2. 等概率采样：每个配置的采样概率为配置总数的倒数。

$$P(\alpha) = \frac{1}{|\mathcal{A}|}$$

3. 作用于全部配置：这条规则对 \(\mathcal{A}\) 中的任意配置都成立，没有偏袒。

$$\forall \alpha \in \mathcal{A}$$

每个位置的蛋糕都经常被“试吃”，所以顾客随便切哪块，口感都有保证——均匀采样就是 OFA 对每一位“子网顾客”的公平承诺。

知识蒸馏

大蛋糕味道醇厚，但小蛋糕胚毕竟是少了几层的“边角料”，要让它也有大蛋糕的浓郁口感，老张发明了一个办法：把小蛋糕放在大蛋糕旁边，让大蛋糕的香气“熏”它，让它模仿大蛋糕的内部组织。OFA 在训练中使用同样的招数：知识蒸馏。

具体来说，OFA 在渐进式收缩的每一阶段，都把完整超网（或当前阶段的大网络）当作教师网络，把目标子网当作学生网络。学生不仅要学真实标签，还要学教师的“软输出”——即教师对每个类别的预测概率分布。软分布中隐藏着类别间的相似性信息，比如“猫”和“狗”比“猫”和“卡车”更接近，这些小模型单靠硬标签学不到。

蒸馏时常用 KL 散度来度量学生输出分布与教师输出分布的差异，并用一个温度参数 \(T\) 把分布变“软”，放大那些被低估的类别概率。最终损失是硬标签的交叉熵损失与软标签的 KL 散度损失的加权和。

$$\displaystyle \mathcal{L} = \alpha \cdot \mathcal{L}_{\mathrm{CE}}\big(y,\, \sigma(z_s)\big) + \beta \cdot \mathcal{L}_{\mathrm{KL}}\big(\sigma(z_t / T),\, \sigma(z_s / T)\big)$$

1. 硬标签交叉熵：学生的预测与真实类别标签 \(y\) 之间的交叉熵损失，保证基础分类能力。

$$\mathcal{L}_{\mathrm{CE}}\big(y,\, \sigma(z_s)\big)$$

2. 软标签 KL 散度：学生的软输出与教师的软输出之间的 KL 散度损失，传递类别间相似性知识。

$$\mathcal{L}_{\mathrm{KL}}$$

3. 温度缩放：将 logits 除以温度 \(T\) 后再做 softmax，使概率分布更平滑、信息更丰富。

$$\sigma(z_t / T), \quad \sigma(z_s / T)$$

4. 平衡系数：\(\alpha\) 和 \(\beta\) 分别控制硬标签与软标签两项损失的权重。

$$\alpha, \beta \in [0,1]$$

大蛋糕的“香气”和“组织质感”通过蒸馏传给小蛋糕，块块都有大师级口感——这就是知识蒸馏在 OFA 中的妙用。

部署应用

蛋糕店终于开张了。手机用户要小纸杯，平板用户要中等切块，电脑用户要整层大块。老张不重新烤，只按顾客需求拿刀比划一下，自然分毫不差。OFA 的部署阶段正是这样：给定目标硬件的延迟约束，比如手机推理必须控制在 20 毫秒内，工程师只需要在超网中搜索一个满足约束且精度尽量高的子网。

搜索过程通常用进化算法完成：从超网的所有配置里随机生成一批候选子网，在验证集上快速评估它们的准确率，并在目标硬件上实测或估算延迟。因为子网的权重直接来自超网，所以评估时只需做前向推理，不需要任何梯度计算，一个子网几十毫秒就能评估完，整个搜索几分钟内就能收敛。

这就是 OFA“一次训练、处处部署”的最终兑现：训练阶段只要做一次（约 40 GPU 天），之后每增加一个新设备，只需花几分钟做一次子网搜索。与大模型每目标重训数天相比，边际成本几乎可以忽略不计。

$$\displaystyle \min_{\alpha \in \mathcal{A}} \;\mathcal{L}_{\mathrm{val}}\big(W_{\mathrm{sub}}(\alpha)\big) \quad \mathrm{s.t.} \quad \mathrm{Latency}(\alpha) \leq T_{\mathrm{target}}$$

1. 验证集损失：子网在验证集上计算出的损失，用来衡量它的真实精度水平。

$$\mathcal{L}_{\mathrm{val}}\big(W_{\mathrm{sub}}(\alpha)\big)$$

2. 延迟函数：子网配置 \(\alpha\) 在目标硬件上完成一次前向推理所需的毫秒数。

$$\mathrm{Latency}(\alpha)$$

3. 约束条件：必须满足开发板或手机芯片给出的延迟上限要求。

$$\mathrm{s.t.} \quad \mathrm{Latency}(\alpha) \leq T_{\mathrm{target}}$$

4. 约束内最小化：在延迟上限之内，挑选验证损失最低的那个子网。

$$\min_{\alpha \in \mathcal{A}}$$

切蛋糕的手起刀落之间，每一位顾客都拿到了最合口的尺寸——部署阶段的高效，正是 OFA 最迷人的商业价值。

对比与效果

街坊都在传老张的新蛋糕店。隔壁李大妈原来的点心铺（传统 NAS）一次只出一种点心，出一次要熬夜做三天。老张的店里却高朋满座，大家想切哪儿切哪儿，还能当场试吃比较。OFA 的实测效果也印证了这种“降维打击”。

在 ImageNet 分类任务上，OFA 抽取出的子网在同等精度下比 MobileNetV3 快 1.5 倍；在相同延迟下，准确率高出约 2.9%。与 BigNAS 等同类超网方法相比，OFA 最大的区别在于真正做到了“先训超网、后选子网”，不需要在部署时重新采样训练，而是直接利用渐进式收缩得到的成熟权重。

从成本角度算一笔账：传统 NAS 要为单个目标消耗上千 GPU 小时，而 OFA 的一次性训练约 40 GPU 天，之后每个新目标只需几分钟搜索。精度-算力曲线上，OFA 抽取的子网几乎贴着“每目标专训模型”的帕累托前沿，让“一胚多切”的边缘成本逼近于零。

$$\displaystyle \mathrm{Acc}(\alpha) \;\mathrm{vs}\; \mathrm{FLOPs}(\alpha), \qquad \alpha \in \mathcal{A}$$

1. 子网精度：子网在 ImageNet 等测试集上的分类准确率。

$$\mathrm{Acc}(\alpha)$$

2. 计算量：子网完成单次前向推理所需的浮点运算数，是算力需求的直接度量。

$$\mathrm{FLOPs}(\alpha)$$

3. 权衡比较：在二维平面上比较每个子网“精度 vs 算力”的坐标位置。

$$\mathrm{vs}$$

4. 覆盖所有配置：所有子网在曲线上描绘出一条完整的性能边界，供部署时挑选。

$$\alpha \in \mathcal{A}$$

一张精度-成本曲线，就是老张的顾客满意度地图——每一分钱都花在刀刃上。OFA 用一次耐心的大烘焙，换来了满店皆大欢喜。

AI 应用场景

Python 演示

import torchimport torch.nn as nnimport numpy as np  class ElasticConv2d(nn.Module):    """支持弹性宽度和弹性核大小的卷积层。"""     def __init__(self, in_ch, max_out_ch, max_kernel):        super().__init__()        self.conv = nn.Conv2d(in_ch, max_out_ch, max_kernel,                              padding=max_kernel // 2)        self.out_ch = max_out_ch        self.kernel = max_kernel     def forward(self, x):        w = self.conv.weight[:self.out_ch]        if self.kernel < self.conv.kernel_size[0]:            pad = (self.conv.kernel_size[0] - self.kernel) // 2            w = w[:, :, pad:pad + self.kernel, pad:pad + self.kernel]        return nn.functional.conv2d(x, w, self.conv.bias[:self.out_ch],                                    padding=self.kernel // 2)  class ToySuperNet(nn.Module):    """玩具版超网：弹性深度包含多个块，可抽取任意前缀子网。"""     def __init__(self, in_ch=3, max_depth=4, width=32, kernel=5):        super().__init__()        self.blocks = nn.ModuleList([            nn.Sequential(ElasticConv2d(in_ch if i == 0 else width,                                        width, kernel),                          nn.BatchNorm2d(width), nn.ReLU())            for i in range(max_depth)        ])        self.pool = nn.AdaptiveAvgPool2d(1)        self.fc = nn.Linear(width, 10)        self.depth = max_depth     def forward(self, x):        for i, block in enumerate(self.blocks):            if i >= self.depth:                break            x = block(x)        x = self.pool(x).flatten(1)        return self.fc(x)  def sample_subnet(net):    """均匀采样子网配置：深度、每层宽度、核大小。"""    net.depth = np.random.randint(1, len(net.blocks) + 1)    for block in net.blocks:        el = block[0]        el.out_ch = np.random.randint(8, el.conv.weight.shape[0] + 1)        el.kernel = np.random.choice([3, 5])  def train_one_step(net, x, y, opt):    """每个 batch 采样一次子网并做一次反向传播。"""    sample_subnet(net)    out = net(x)    loss = nn.functional.cross_entropy(out, y)    opt.zero_grad()    loss.backward()    opt.step()    return loss.item()  def main():    net = ToySuperNet(max_depth=4)    opt = torch.optim.Adam(net.parameters(), lr=1e-3)    x = torch.randn(8, 3, 32, 32)    y = torch.randint(0, 10, (8,))    for step_i in range(10):        loss = train_one_step(net, x, y, opt)        print(f'step {step_i}: loss={loss:.4f}')  if __name__ == '__main__':    main()

1. sample_subnet(net)每个 batch 重新随机采样一个子网，模拟 OFA 的均匀采样策略。
2. net.depth = np.random.randint(1, len(net.blocks) + 1)弹性深度：随机决定前向传播使用 1~4 个块中的哪一段。
3. el.out_ch = np.random.randint(8, el.conv.weight.shape[0] + 1)弹性宽度：随机截取前若干个输出通道，实现子网变窄。
4. el.kernel = np.random.choice([3, 5])弹性核大小：随机选择 3 或 5 的卷积核尺寸。
5. w = self.conv.weight[:self.out_ch]从超网权重中切片出子网对应部分，体现权重共享。

常见误区

面试题