使用 DynaBERT 宽度弹性策略与 PaddleSlim OFA 压缩 BERT:PaddleNLP 中的超网络训练、蒸馏与子模型导出实战

原创2026-09-22 09:16:201,757 阅读
文章标签:人工智能大模型NLP深度学习机器学习预训练微调LoRA模型量化模型推理服务强化学习分布式训练Embedding本地部署

使用 DynaBERT 宽度弹性策略与 PaddleSlim OFA 压缩 BERT:PaddleNLP 中的超网络训练、蒸馏与子模型导出实战

本文基于 docs/zh/advanced_guide/model_compression/ofa_bert.rst 教程,系统讲解如何在 PaddleNLP 中结合 PaddleSlim 的 OFA(Once-For-All)能力,采用 DynaBERT(Dynamic BERT with Adaptive Width and Depth)训练策略对 BERT 进行压缩。文章覆盖超网络与子模型的核心概念、参数重要性重排序原理、知识蒸馏配置、宽度弹性训练循环、monkey patch 实现细节,以及子模型导出与压缩效果评估,读者读完可以完整复现"一个超网络训练、按需裁剪宽度、导出任意子模型"的 BERT 压缩链路。

背景:为什么 BERT 需要宽度可裁剪的压缩方案

BERT-base 模型具有很强的通用语义表示能力,但模型参数存在冗余。常规的结构化剪枝思路是"训练 → 剪枝 → 微调",每一步都要重新训练和验证,成本高且一旦剪枝比例不理想需要重来。DynaBERT 论文提出了一种更高效的思路:把原始模型当作一个超网络(Super-Network)中最大的子模型,超网络指包含所有搜索空间在内的一个网络,通过一次训练让网络学会在不同宽度配置下都保持良好的精度,训练结束后即可按部署需求直接取出对应宽度的子模型,无需重新训练。

PaddleNLP 仓库在 slm/examples/model_compression/ofa/ 目录下提供了完整的可运行示例,对应的训练脚本为 run_glue_ofa.py,并配套 README.md 记录了完整的压缩流程、参数说明与实验结果。本文所有代码和结论均来自该仓库的实际实现。

子模型(Sub Transformer Block)的宽度选择方式

原始模型由多个大小相同的 Transformer Block 组成,每个 Transformer Block 包含一个 Multi-Head Attention 和一个 Feed-Forward Network(FFN)。在每次训练前,会为当前轮次选择一个子模型,每个子模型由多个相同大小的 Sub Transformer Block 构成,而 Sub Transformer Block 是对原始 Transformer Block 进行不同宽度选择得到的,具体作用在以下两个位置:

  1. Multi-Head Attention 的 Head 数量等比例减少:例如原始模型有 12 个 Head,若本次训练选择宽度为原始宽度 75% 的子模型,则本次训练中所有 Transformer Block 的 Head 数量为 12 × 75% = 9。
  2. FFN 层 Linear 的参数维度等比例减少:例如原始模型 FFN 层特征维度为 3072,宽度为 75% 时,所有 Transformer Block 中 FFN 层的特征维度变为 3072 × 75% = 2304。

宽度选择的本质就是对网络中的参数进行裁剪,而所有子网络在整个训练过程中参数共享——它们共享同一份超网络参数,只是每次前向传播时只"切开"使用其中对应宽度的那一部分。

整体原理:五步看懂 OFA 压缩流程

按照教程原文,整个压缩流程分为五个核心步骤:

  1. 按重要性重排序参数与 Head:首先对预训练模型的参数和 Head 根据其重要性进行重排序,把重要的参数和 Head 排在参数的前侧,保证训练过程中的参数裁剪不会裁剪掉这些重要成分。参数重要性的计算方式是先用 dev 数据计算一遍每个参数的梯度,再根据梯度和参数的整体大小来计算当前参数的重要性;Head 重要性则是传入一个全 1 的 Head mask,计算该 mask 的梯度,根据梯度大小判断每个 Multi-Head Attention 层中每个 Head 的重要性。
  2. 构建教师-学生蒸馏框架:使用原本的预训练模型作为蒸馏过程中的教师网络;同时定义一个超网络作为学生网络,超网络中最大的子网络结构与教师网络结构相同,其他较小的子网络是对最大网络进行不同宽度选择得到的(即对参数进行裁剪),所有子网络在训练过程中参数共享。
  3. 初始化与多层蒸馏损失:使用重排序之后的预训练模型参数初始化超网络,并把它作为学生网络;分别对 Embedding 层、每个 Transformer Block 层和最后的 logits 输出添加蒸馏损失。
  4. 逐 batch 选择子网络配置:每个 batch 数据在训练前首先选择当前要训练的子网络配置(目前子网络配置仅包括对整个模型宽度的选择),参数更新时仅更新当前子网络计算中用到的那部分参数。
  5. 训练后挑选子模型:通过以上方式优化整个超网络参数,训练完成后根据加速要求和精度要求选择合适的子模型。

整体流程可参考仓库中的示意图 ofa_bert.jpg:

OFA-BERT 整体流程示意图:重排序参数 → 构建超网络 → 宽度弹性蒸馏训练 → 导出子模型

环境依赖与前置工作

模型压缩功能依赖 PaddleSlim 的 OFA 能力,README 中明确要求安装最新版本的 PaddleSlim(建议从源码安装以保证 API 一致):

git clone https://github.com/PaddlePaddle/PaddleSlim
python setup.py build && python setup.py install

在开始压缩之前,需要先有一个在具体下游任务上 Fine-tuning 好的 BERT 模型。教程沿用了《由BERT到Bi-LSTM的知识蒸馏》distill_lstm 示例 的思路:先按 GLUE 基准流程对 bert-base-uncased 在目标任务(本示例以 SST-2 为例)上 Fine-tuning,得到待压缩的模型。Fine-tuning 命令可参考 slm/examples/benchmark/glue 目录下的脚本,典型配置为 max_seq_length 128、batch_size 32、learning_rate 2e-5、num_train_epochs 3。

基于 PaddleSlim 的模型压缩全流程

下面按教程的 8 个步骤展开,所有代码均来自 run_glue_ofa.py 的真实实现。

第 1 步:定义初始网络并保存原始参数

定义原始 BERT-base 模型,并用一个字典保存原始模型参数。普通模型转换为超网络之后,由于其组网 OP 发生了改变(例如 Linear 层会被替换为带宽度选择能力的超网络 Linear),原始模型直接加载的参数会失效,所以必须先用字典保存原始参数,之后用它来初始化超网络:

model = BertForSequenceClassification.from_pretrained('bert', num_classes=2)
origin_weights = {}
for name, param in model.named_parameters():
    origin_weights[name] = param

在 run_glue_ofa.py 中这一步更简洁地写作 origin_weights = model.state_dict(),并在转换完成后通过 utils.set_state_dict(model, origin_weights) 回填参数,然后 del origin_weights 释放内存。

第 2 步:定义搜索空间并构建超网络

通过 supernet(expand_ratio=...) 定义宽度搜索空间,再通过 Convert 把普通网络转换为超网络:

# 定义搜索空间
sp_config = supernet(expand_ratio=[0.25, 0.5, 0.75, 1.0])
# 转换模型为超网络
model = Convert(sp_config).convert(model)
paddleslim.nas.ofa.utils.set_state_dict(model, origin_weights)

实际脚本中使用命令行参数 --width_mult_list 传入搜索空间(默认 [1.0, 5/6, 2/3, 0.5]),即超网络支持 100%、83.3%、66.7%、50% 四种宽度档位。

第 3 步:定义教师网络

教师网络直接复用同一个预训练模型结构:

teacher_model = BertForSequenceClassification.from_pretrained('bert', num_classes=2)

第 4 步:配置蒸馏相关参数

需要配置的参数包括:教师模型实例;需要添加蒸馏的层——在教师网络和学生网络的 Embedding 层以及每一个 Transformer Block 层之间添加蒸馏损失,中间层蒸馏损失使用默认的 MSE 损失函数;lambda_distill 参数表示整体蒸馏损失的缩放比例:

mapping_layers = ['bert.embeddings']
for idx in range(model.bert.config['num_hidden_layers']):
    mapping_layers.append('bert.encoder.layers.{}'.format(idx))

default_distill_config = {
    'lambda_distill': 0.1,
    'teacher_model': teacher_model,
    'mapping_layers': mapping_layers,
}
distill_config = DistillConfig(**default_distill_config)

从源码看,mapping_layers 覆盖了 bert.embeddings 加全部 num_hidden_layers 个 encoder layer,意味着蒸馏损失会施加在 Embedding 输出和每一层 Transformer Block 的隐藏状态上,保证学生超网络在任意宽度下都能逐层逼近教师网络的表示。

第 5 步:定义 Once-For-All 模型

把普通模型和蒸馏相关配置传给 OFA 接口,它会自动添加蒸馏过程,并把超网络训练方式转为 OFA 训练方式:

ofa_model = paddleslim.nas.ofa.OFA(model, distill_config=distill_config)

在 run_glue_ofa.py 中还额外传入了 elastic_order=["width"],显式声明本阶段只做宽度维度的弹性搜索。

第 6 步:计算神经元与 Head 重要性并重排序

调用 utils.compute_neuron_head_importance 用 dev 数据计算每个层中神经元和 Head 的重要性,然后调用 reorder_neuron_head 按重要性降序重排参数,把重要的参数排到前面,使宽度裁剪优先裁掉不重要的部分:

head_importance, neuron_importance = utils.compute_neuron_head_importance(
    'sst-2',
    ofa_model.model,
    dev_data_loader,
    num_layers=model.bert.config['num_hidden_layers'],
    num_heads=model.bert.config['num_attention_heads'])
reorder_neuron_head(ofa_model.model, head_importance, neuron_importance)

重排的具体逻辑在 run_glue_ofa.py 的 reorder_neuron_head 函数中:对每一层,用 paddle.argsort(..., descending=True) 得到重要性降序索引,再调用 nlp_utils.reorder_head 重排该层 self_attn 的 Head,调用 nlp_utils.reorder_neuron 分别按 dim=1 和 dim=0 重排 linear1.fn 与 linear2.fn 的神经元顺序。

第 7 步:传入当前 OFA 训练所处阶段

每个 epoch 开始前设置当前 epoch 与训练任务类型(目前仅支持宽度弹性,即 'width'):

ofa_model.set_epoch(epoch)
ofa_model.set_task('width')

第 8 步:传入网络配置,开始超网络训练

本示例使用 DynaBERT 的策略进行超网络训练:对同一个 batch,依次以不同的 width_mult 切出子网络,逐个前向、累加梯度,最后统一反向更新:

width_mult_list = [1.0, 0.75, 0.5, 0.25]
lambda_logit = 0.1
for width_mult in width_mult_list:
    net_config = paddleslim.nas.ofa.utils.dynabert_config(ofa_model, width_mult)
    ofa_model.set_net_config(net_config)
    logits, teacher_logits = ofa_model(input_ids, segment_ids, attention_mask=[None, None])
    rep_loss = ofa_model.calc_distill_loss()
    logit_loss = soft_cross_entropy(logits, teacher_logits.detach())
    loss = rep_loss + lambda_logit * logit_loss
    loss.backward()
optimizer.step()
lr_scheduler.step()
ofa_model.model.clear_gradients()

训练循环(run_glue_ofa.py)的细节值得注意:

  • dynabert_config(ofa_model, width_mult) 根据宽度倍率生成当前子网络的 net_config,set_net_config 将其应用到超网络;
  • 蒸馏损失拆成两部分:rep_loss = ofa_model.calc_distill_loss()(中间层表示蒸馏损失,即配置里的 lambda_distill 所缩放的 MSE 损失)与 logit_loss(输出 logits 的软标签交叉熵,用 soft_cross_entropy(logits, teacher_logits.detach()) 计算,teacher_logits 需 detach 避免梯度回流到教师网络);
  • 最终 loss = rep_loss + lambda_logit * logit_loss,其中 lambda_logit 为 logits 蒸馏损失的缩放系数(命令行参数默认 1.0,教程示例取 0.1);
  • 所有宽度档位在同一个 batch 上完成前向并累加梯度后才执行一次 optimizer.step() 和 lr_scheduler.step(),随后 clear_gradients() 清空梯度;
  • soft_cross_entropy 的实现位于 run_glue_ofa.py,即对 logits 取 log_softmax、对教师输出取 softmax 后的交叉熵均值;对于回归类任务(如 STS-B)会直接跳过 logits 蒸馏损失,只保留中间层表示蒸馏。

关键实现细节:为什么必须 monkey patch BERTModel.forward

NOTE:由于在计算 Head 重要性时需要利用一个 mask 来收集梯度,所以需要通过 monkey patch 的方式重新实现 BERTModel 类的 forward 函数。教程给出的实现如下:

from paddlenlp.transformers import BertModel
def bert_forward(self,
                input_ids,
                token_type_ids=None,
                position_ids=None,
                attention_mask=[None, None]):
    wtype = self.pooler.dense.fn.weight.dtype if hasattr(
        self.pooler.dense, 'fn') else self.pooler.dense.weight.dtype
    if attention_mask[0] is None:
        attention_mask[0] = paddle.unsqueeze(
            (input_ids == self.pad_token_id).astype(wtype) * -1e9, axis=[1, 2])
    embedding_output = self.embeddings(
        input_ids=input_ids,
        position_ids=position_ids,
        token_type_ids=token_type_ids)
    encoder_outputs = self.encoder(embedding_output, attention_mask)
    sequence_output = encoder_outputs
    pooled_output = self.pooler(sequence_output)
    return sequence_output, pooled_output

BertModel.forward = bert_forward

从 run_glue_ofa.py 可以看到同样的 patch 逻辑:改造后的 forward 接受形如 [attention_mask, head_mask] 的二元组作为 attention_mask,在 mask 为 None 时根据 pad_token_id 自动构造 -1e9 的 padding mask,并把 attention_mask 原样透传给 encoder,从而支持 Head mask 的梯度传播;wtype 的取值兼容了超网络转换后 self.pooler.dense.fn 与非转换两种结构。该 patch 必须在模型构建、重要性计算和训练之前完成。

完整命令行参数与运行方式

基于 GLUE/SST-2 示例的完整运行方式记录在 README.md 中。

单卡压缩训练

python -u ./run_glue_ofa.py --model_type bert \
          --model_name_or_path ${task_pretrained_model_dir} \
          --task_name $TASK_NAME --max_seq_length 128     \
          --batch_size 32       \
          --learning_rate 2e-5     \
          --num_train_epochs 6     \
          --logging_steps 10     \
          --save_steps 100     \
          --output_dir ./tmp/$TASK_NAME \
          --device gpu  \
          --width_mult_list 1.0 0.8333333333333334 0.6666666666666666 0.5

多卡压缩训练

unset CUDA_VISIBLE_DEVICES
python -m paddle.distributed.launch --gpus "0,1" run_glue_ofa.py  \
          --model_type bert \
          --model_name_or_path ${task_pretrained_model_dir} \
          --task_name $TASK_NAME --max_seq_length 128     \
          --batch_size 32       \
          --learning_rate 2e-5     \
          --num_train_epochs 6     \
          --logging_steps 10     \
          --save_steps 100     \
          --output_dir ./tmp/$TASK_NAME \
          --device gpu  \
          --width_mult_list 1.0 0.8333333333333334 0.6666666666666666 0.5

各参数释义(来源:README.md 及 run_glue_ofa.py 的参数解析代码):

参数 说明
model_type 模型类型,当前仅支持 BERT 模型
model_name_or_path 预训练模型名或本地模型目录;压缩阶段应指向 Fine-tuning 后的模型
task_name Fine-tuning 的下游任务名,支持 cola / sst-2 / mrpc / sts-b / qqp / mnli / qnli / rte
max_seq_length 最大句子长度,超过将被截断,默认 128
batch_size 每次迭代每张卡上的样本数目,默认 8
learning_rate 基础学习率,会与 learning rate scheduler 产出的系数相乘作为当前学习率,默认 5e-5
num_train_epochs 训练轮数,默认 3(压缩训练通常 6 轮)
logging_steps 日志打印间隔,默认 500
save_steps 模型保存及评估间隔,默认 500
output_dir 模型保存路径
device 训练设备:gpu / xpu(百度昆仑卡)/ cpu
width_mult_list 压缩训练过程中对每层 Transformer Block 的宽度选择范围,默认 1.0 0.8333333333333334 0.6666666666666666 0.5
lambda_logit logits 蒸馏损失的缩放系数,默认 1.0

训练过程中会在每个 save_steps 触发评估:先以 width_mult=100 作为哨兵值评估教师网络,再依次对每个 width_mult 切出子网络评估并保存 checkpoint(保存逻辑见 run_glue_ofa.py),方便观察不同宽度档位的精度随训练的变化。

深度弹性扩展:同时压缩宽度与深度

仓库还提供了 run_glue_ofa_depth.py,它在宽度弹性之外引入了深度弹性(elastic_depth):通过 RunConfig(elastic_depth=args.depth_mult_list) 声明深度搜索空间,OFA(..., elastic_order=<a href="https://link.gitcode.com/i/8d2e40cd1e53704b78b853c3435665dd" target="_blank">"depth"]) 切换训练任务为深度弹性,训练时对 depth_mult_list × width_mult_list 做双重循环。深度维度的实现依赖额外的 monkey patch:重写 paddle.nn.TransformerEncoder.forward,根据 depth_mult 按 math.floor(i / depth_mult) - 1 挑选保留的 encoder layer 索引([run_glue_ofa_depth.py),从而在推理时跳过部分层;同时 BertForSequenceClassification.forward 也被 patch 以透传 depth_mult。

子模型导出

压缩训练完成后,根据传入的 config 导出相应的子模型并转为静态图模型。启动命令:

python -u ./export_model.py --model_type bert \
                             --model_name_or_path ${PATH_OF_MODEL_AFTER_OFA} \
                             --max_seq_length 128     \
                             --sub_model_output_dir ./tmp/$TASK_NAME/dynamic_model \
                             --static_sub_model ./tmp/$TASK_NAME/static_model \
                             --device gpu \
                             --width_mult  0.6666666666666666

参数释义:

参数 说明
model_type 模型类型,当前仅支持 BERT 模型
model_name_or_path 经过 OFA 训练后保存的模型目录
max_seq_length 最大句子长度,默认 128
sub_model_output_dir 导出子模型动态图参数的目录
static_sub_model 导出子模型静态图模型及参数的目录,设为 None 则不导出静态图,默认 None
device 训练设备:gpu / xpu / cpu
width_mult 导出子模型的宽度,默认 1.0
depth_mult 导出子模型的深度,默认 1.0

导出脚本 export_model.py 的核心逻辑是:重新构建超网络后,用 utils.dynabert_config(ofa_model, args.width_mult) 生成目标宽度配置并调用 ofa_model.export(...) 导出(export_model.py),同时把子模型中 MultiHeadAttention 的 num_heads 按 int(width_mult * num_heads) 同步调整;若指定了 static_sub_model,则通过 paddle.jit.to_static 配合 InputSpec 导出静态图模型,便于后续用预测库或 TensorRT 部署。

压缩效果参考

根据 README.md 中记录的实验结果,利用 bert-base-uncased 在 GLUE 上 Fine-tuning 后压缩,压缩后模型参数大小从 110M 减小到 81M(减小约 26%),GLUE dev 集精度对比如下:

Task Metric Result Result with PaddleSlim
SST-2 Accuracy 0.93005 0.931193
QNLI Accuracy 0.91781 0.920740
CoLA Mattehew's corr 0.59557 0.601244
MRPC F1/Accuracy 0.91667/0.88235 0.91740/0.88480
STS-B Person/Spearman corr 0.88847/0.88350 0.89271/0.88958
QQP Accuracy/F1 0.90581/0.87347 0.90994/0.87947
MNLI Matched acc/MisMatched acc 0.84422/0.84825 0.84687/0.85242
RTE Accuracy 0.711191 0.718412

README 同时记录了压缩前后的推理耗时(Latency, ms):在 T4 上 batch size 16 时,BERT 原始模型 FP32 为 110.71ms、TensorRT FP16 为 22.0ms,压缩后分别降至 69.62ms 与 14.93ms;batch size 40 时由 252.78ms(FP32)/ 53.67ms(FP16)降至 168.71ms / 37.22ms;V100 上 batch size 16 由 33.28ms 降至 21.83ms;Intel Xeon Gold 5117 CPU 上由 10831.73ms 降至 7682.93ms。README 据此给出压缩后模型在 T4 上相比原始模型 FP32 加速约 59%、TensorRT FP16 下加速约 47.3%,在 V100 上加速约 52.5%,在 CPU 上加速约 41%。

此外 README 还附带了基于 TinyBERT(L=4, D=312)的压缩实验:SST-2 精度 0.9234 与 0.9220、QNLI 0.8746 与 0.8720、CoLA 0.4961 与 0.5048 等,表明 OFA 压缩流程不仅适用于 BERT-base,也能直接套用到 TinyBERT 这类小型模型上。

总结与注意事项

  • 整套方案的核心是"一次训练、多处取用":训练期间通过 width_mult_list 让超网络同时适应多个宽度档位,部署时按需导出任意宽度的子模型,省去逐档重新训练的开销;
  • 参数与 Head 的重要性重排序是保证裁剪精度的前提,务必在超网络构建完成、蒸馏配置就绪之后执行;
  • BertModel.forward 的 monkey patch 必须在计算 Head 重要性之前完成,否则 Head mask 的梯度无法正确收集;
  • 所有子网络参数共享,反向传播时只更新当前子网络实际用到的参数,训练循环中多个宽度档位共享一次 optimizer.step();
  • 蒸馏损失由中间层表示损失(lambda_distill 缩放)与 logits 软标签损失(lambda_logit 缩放)两部分组成,回归任务(STS-B)会跳过 logits 部分;
  • 更多 OFA 接口细节可查阅 run_glue_ofa.py 与 README.md,参考论文为 DynaBERT: Dynamic BERT with Adaptive Width and Depth 与 Once for All: Train One Network and Specialize It for Efficient Deployment。
登录后查看全文
PaddleNLP