Composer Layer Freezing 算法全解析:渐进冻结网络早期层,优化训练吞吐与精度权衡

原创2026-10-12 19:11:431,968 阅读
文章标签:深度学习分布式训练模型优化

Composer Layer Freezing 算法全解析:渐进冻结网络早期层,优化训练吞吐与精度权衡

Layer Freezing(层冻结)是 Composer 内置的训练加速算法之一,它基于"早期层往往比后期层更早学到特征、后期无需再更新"的假设,在训练中按线性计划逐步将网络前部模块的参数从优化器中移除并停止计算梯度,从而省去对冻结模块的反向传播与更新开销。本文以 Layer Freezing 方法卡片 为主线,结合 Composer 仓库中 核心实现、测试用例 与框架事件机制,完整讲解其功能接口、Trainer 集成方式、两个关键超参数(freeze_start / freeze_level)的取值策略、逐行源码原理,以及官方实验给出的吞吐-精度权衡数据,帮助你在自己的训练任务中判断该算法是否值得启用。

Layer Freezing 的核心思想:为什么冻结早期层能省时间

在标准训练循环中,每一轮迭代都要对整张计算图反向传播,代价与网络深度近似成正比。Layer Freezing 的思路是:训练前期,网络各层都在快速演化;训练后期,早期层(负责边缘、纹理、浅层特征)往往已经收敛稳定,继续为其计算梯度和更新参数属于冗余开销。于是算法在训练进行到一定比例后,开始把最前面的模块逐批"冻结"——不再为这些模块的参数计算梯度、也不再被优化器更新,从而节省反向传播与参数更新的成本。

在 Composer 中该算法被标注为 Computer Vision 方向,但其 元数据 中声明的适用领域同时包含 cv 与 nlp,使用定位为 "Generally applicable"(通用方法)。需要注意,从实现与实验来看,它在视觉基准上更适合作为吞吐优化手段,而非精度提升手段(详见后文"实验效果"一节)。

快速上手:两种使用方式

Composer 为 Layer Freezing 提供了两种接入方式:函数式接口(自定义训练循环内手动调用)与 Trainer 算法集成(交给训练引擎在正确时机自动触发)。

Functional Interface:在自定义训练循环中调用

如果你不依赖 Trainer,而是自己管理训练循环,可以通过 composer.functional 命名空间下的 freeze_layers 在每个 epoch 结束时手动触发冻结:

# 使用 Composer functional API 运行 Layer Freezing 算法
import torch
import torch.nn.functional as F

from composer import functional as cf

def training_loop(model, train_loader):
    opt = torch.optim.Adam(model.parameters())
    loss_fn = F.cross_entropy
    model.train()

    for epoch in range(num_epochs):
        for X, y in train_loader:
            y_hat = model(X)
            loss = loss_fn(y_hat, y)
            loss.backward()
            opt.step()
            opt.zero_grad()

        # 在 epoch 结束时应用层冻结
        freeze_depth, freeze_percentage = cf.freeze_layers(
            model=model,
            optimizers=opt,
            current_duration=epoch / num_epochs,
            freeze_start=0.0,
            freeze_level=1.0,
        )

这里需要注意两点:

  • current_duration 是当前训练进度(训练完成比例,取值范围 [0, 1)),由调用方计算并传入;
  • 函数返回 (int, float) 二元组,从 源码签名 可以确认,第二个返回值是冻结模块占全部模块的百分比(freeze_percentage),而不是方法卡片示例代码里变量名所写的 freeze_level——freeze_level 是入参,返回值语义上应理解为"当前实际冻结比例"。

Composer Trainer:声明式集成

更常见的做法是把算法实例化后传给 Trainer 的 algorithms 列表,训练引擎会在训练循环中合适的时机(即每个 EPOCH_END 事件)自动执行:

# 实例化算法并传入 Trainer
# Trainer 会在训练循环的合适时机自动运行它

from composer.algorithms import LayerFreezing
from composer.trainer import Trainer

layer_freezing_algorithm = LayerFreezing(freeze_start=0.0, freeze_level=1.0)

trainer = Trainer(
    model=model,
    train_dataloader=train_dataloader,
    eval_dataloader=eval_dataloader,
    max_duration='1ep',
    algorithms=[layer_freezing_algorithm],
)

trainer.fit()

LayerFreezing 算法类同样支持 freeze_start 与 freeze_level 两个构造参数,model、train_dataloader、eval_dataloader 等由训练任务本身提供。两种入口最终都汇聚到同一个核心函数 freeze_layers,行为完全一致。

关键超参数:freeze_start 与 freeze_level

参数 默认值 取值范围 语义
freeze_start 0.5 [0, 1) 训练进行到多大比例后开始冻结。例如 0.1 表示训练到 10% 时开始冻结最早层
freeze_level 1.0 [0, 1) 最终最多冻结多大比例的层。例如 1.0 表示训练结束时全部模块都被冻结

方法卡片对取值给出了两条明确建议:

  1. freeze_start 至少取 0.1。理由是 Layer Freezing 在"整个网络在冻结开始前先充分可训练"时效果最好——如果训练一开始就冻结,早期层将完全无法学习,会直接损害模型表达能力;
  2. freeze_level 的设置依赖具体上下文(任务、模型、数据规模不同,最优冻结比例不同),需要针对场景实验确定。

从 冻结计划源码 可以精确还原其数学行为:

  • 当 current_duration <= freeze_start 时,冻结比例为 0.0(尚未开始冻结);
  • 之后按线性公式 freeze_level * (current_duration - freeze_start) / (1.0 - freeze_start) 逐步增加冻结比例,到训练结束时恰好达到 freeze_level。

也就是说:冻结深度在时间轴上线性增长,从 freeze_start 时刻的 0% 均匀爬升到训练末端的 freeze_level。

实现原理:从源码看完整执行链路

触发时机:EPOCH_END 事件

LayerFreezing 继承自 composer.core.Algorithm 基类(其契约见 core/algorithm.py),通过 match / apply 两个抽象方法与训练引擎协作:

  • match 只对 Event.EPOCH_END 返回 True,即每个 epoch 结束时触发一次;
  • apply 从 State 中读取优化器列表与当前已用训练时长,调用 freeze_layers,并通过 logger.log_metrics 记录两个指标:layer_freezing/layers_frozen(冻结的模块数)与 layer_freezing/percentage_frozen(冻结比例)。

在引擎层,core/engine.py 的文档注释里也以 LayerFreezing 为例说明算法在事件上的触发记录(例如 [STEP=3][layer_freezing/EPOCH_END=1] 表示在第 3 步的 epoch 结束时执行了一次层冻结)。

扁平化模块树:深度优先遍历

_get_layers 以深度优先(DFS)方式遍历 torch.nn.Module 的拥有树(ownership tree),只收集"没有子模块且含参数"的叶子模块,得到扁平化的模块列表。因此:

  • 冻结的粒度是叶子模块(如单个卷积层、单个线性层),而不是整个子网络容器;
  • 遍历顺序是模块定义嵌套顺序,方法卡片明确指出:这个顺序可能与模型在前向传播中的实际使用顺序不同;
  • 冻结时取 flat_children[0:-1](末尾最后一个叶子模块始终不冻结),保证网络末端输出层保持可训练。

冻结数量:线性计划

得到扁平列表后,freeze_layers 按上文公式算出当前应冻结的比例 freeze_percentage,再乘以 (len(flat_children) - 1) 得到本时刻应冻结的模块个数 freeze_depth(取整)。随后遍历列表前 freeze_depth 个模块逐一处理。

"真正"的冻结:从 optimizer 的 param_groups 中移除参数

这是实现中最关键的一步,见 _remove_param_from_optimizers 与 主循环:

for i, child in enumerate(flat_children[0:-1]):
    if i < freeze_depth:
        for p in child.parameters():
            _remove_param_from_optimizers(p, optimizers)
            # 不再为该参数计算梯度
            p.requires_grad = False

每个被冻结的参数执行两件事:

  1. 从优化器的所有 param_groups 中按对象 id 精确移除。源码注释解释了原因:仅设置 requires_grad=False 并不够,因为优化器仍会对其应用动量、权重衰减等更新逻辑;只有从 param_groups 中移除,才彻底停止更新;
  2. 设置 p.requires_grad = False,使该参数不参与反向传播,从源头省掉梯度计算与存储。

同时,方法卡片强调:冻结只移除优化器视图中的参数,不删除参数在模型 state_dict 中的条目,因此模型权重本身始终保留,只是停止被更新。

DDP 兼容性:find_unused_parameters

LayerFreezing 覆写了基类的 find_unused_parameters 属性并返回 True(见 layer_freezing.py)。基类文档(core/algorithm.py)说明:该属性用于告知 torch.nn.parallel.DistributedDataParallel(DDP)"某些参数在训练中会被冻结、不再产生梯度",从而避免 DDP 因找不到梯度而报错。所有做参数冻结类操作的算法都应覆写该属性为 True——这是 Layer Freezing 在多卡分布式训练中可用的前提。

函数式入口

freeze_layers 通过 composer/functional/init.py 导出为 cf.freeze_layers,LayerFreezing 算法类与函数均从 algorithms/layer_freezing/init.py 对外公开,并注册在 composer.algorithms 命名空间(见 algorithms/init.py)。

实验效果与实证结论:吞吐与精度的权衡

方法卡片给出了 Composer 官方在两组基准上的观测数据,这是判断该算法是否适合你任务的最直接依据:

  • ResNet-50 / ImageNet:Layer Freezing 可带来约 5% 的吞吐提升,但同时造成 0.5%~1% 的精度下降。官方评价是"这不是一个特别好的速度-精度权衡",且现有论文在更大规模问题上普遍也未发现有效的权衡;
  • ResNet-56 / CIFAR-100:观测到精度从 75.82% 提升到 76.22%,同时伴随约 5% 的速度提升。但官方特别提醒:该结果使用特定超参数且没有重复实验(replicates),应谨慎解读。

文档还以醒目的警示框给出两条结论:

❗ 没有证据表明 Layer Freezing 能改善模型质量与训练速度之间的权衡。 虽然它确实提升了吞吐,但也可能带来精度下降(如 ResNet-50 / ImageNet 的观测结果),在我们的实验中,该权衡并未改善质量-速度曲线的帕累托前沿。

🚧 组合正则化方法需谨慎。 Layer Freezing 本质上是"渐进的 early stopping"——它逐步而非一次性停止训练模型,因此可被理解为一种正则化形式。一般经验是:组合多种正则化方法可能带来质量提升上的边际收益递减。

据此可以给出务实的选型建议:当你的训练受吞吐瓶颈限制、且能容忍小幅度精度损失时,Layer Freezing 值得作为候选方案做小规模消融实验;若追求精度优先,则应优先考虑其他方法。

注意事项与已知限制

综合源码与测试,使用该算法还需注意以下几点:

  1. Checkpoint 恢复不可靠:LayerFreezing.state_dict 与 load_state_dict(layer_freezing.py)都会发出明确警告——"包含 layer freezing 的 checkpoint 无法可靠地用于恢复训练"(对应上游仓库 issue #1002)。原因是冻结状态(哪些参数已被移除)难以在加载时精确重建。因此开启该算法时,建议不要依赖中断恢复,或将 save_interval 规划为不跨冻结边界的完整训练段;
  2. 不可二次 fit():测试 tests/algorithms/test_algorithms_train.py 中明确以 pytest.xfail 标注:freeze_level=1.0 时训练结束全部层已被冻结,算法不会解冻,第二次调用 fit() 将导致无法训练;
  3. 遍历顺序 ≠ 前向顺序:冻结的先后顺序基于模块定义树的 DFS 顺序,可能与实际前向计算顺序不一致,理解冻结进度时不要把它等同于"网络前 N 个前向层";
  4. 与正则化方法组合收益递减:它被视为一种松弛的 early stopping / 正则化手段,叠加过多正则化可能得不偿失。

测试与验证:算法行为如何被保障

仓库中的测试对上述行为给出了可复现的验证依据:

  • tests/algorithms/test_layer_freezing.py 针对 SimpleConvModel、SimpleTransformerClassifier、tiny BERT 三类模型分别验证两种场景:
    • test_freeze_layers_no_freeze:训练进行到 10/100 epoch,freeze_start=0.5,此时尚未到冻结起点,断言优化器 param_groups 与冻结前完全一致;
    • test_freeze_layers_with_freeze:训练进行到 80/100 epoch,freeze_start=0.05,断言第一个 param group 的参数被清空(expected_param_groups[0]['params'] = []),验证冻结确实生效。
  • tests/algorithms/algorithm_settings.py 将 LayerFreezing 的默认测试设置登记为 SimpleConvModel + RandomImageDataset,用于算法级联测(训练、序列化等);
  • 前述 test_algorithms_train.py 的 xfail 分支则验证了"二次 fit 不兼容"这一限制。

API 参考

  • 算法类:composer.algorithms.LayerFreezing,构造参数 freeze_start(默认 0.5)、freeze_level(默认 1.0),在 Event.EPOCH_END 触发;
  • 函数式接口:composer.functional.freeze_layers(model, optimizers, current_duration, freeze_start=0.5, freeze_level=1.0),返回 (冻结模块数, 冻结百分比);
  • 归因:该精确冻结方案最接近 2017 年 arXiv 论文 Freezeout: Accelerate training by progressively freezing layers(Brock 等)与 NeurIPS 2017 论文 SVCCA: Singular Vector Canonical Correlation Analysis for Deep Learning Dynamics and Interpretability(Raghu 等),Composer 的实现与文档由 MosaicML 的 Cory Stephenson 完成。

如需进一步深入,可直接阅读本仓库中的 Layer Freezing 方法卡片、核心实现 与 单元测试 获取全部细节。

登录后查看全文
composer