📦 端侧高效深度学习综述 ④：端侧学习与端侧大模型

这是 100 页综述的精讲系列，共 5 篇

1. ① 概述与手工网络设计
2. ② 自动化网络设计 NAS
3. ③ 网络压缩：剪枝、量化、蒸馏
4. ④ 端侧学习与端侧大模型（本篇）
5. ⑤ 框架、应用与未来展望

这一篇在干嘛？

本篇精讲 Luo 等人发表于 ACM TECS 2024 的百页综述《Efficient Deep Learning Infrastructures for Embedded Computing Systems: A Comprehensive Survey and Future Envision》的第 5 章（端侧学习）与第 6 章（端侧大模型）。 前面两篇（手工/自动网络设计、网络压缩）都默认同一个范式：模型在云端训好、压好、下发到设备，然后就永远固定不动了。第 5 章要打破的正是这个设定——让设备自己学习。第 6 章则回答一个更尖锐的问题：连手机都跑不动的大语言模型（LLM），怎么上嵌入式设备？ 最值得记住的几个数字：batch size 16 下 ResNet-50 的激活值内存是参数量的 ×13.9，这才是端侧训练的真瓶颈；梯度检查点能把训练内存从 $O(n)$ 降到 $O(\sqrt{n})$；低比特训练最多可省 ×32 内存，有工作把端侧训练压进了 256 KB；TinyTL 把迁移学习训练内存从 250 MB 以上降到 16 MB；GPT-3 有 1750 亿参数；SparseGPT 能把 LLM 一次性剪到 50% 稀疏而无需重训；AWQ 发现只要保护 1% 的显著权重就能大幅降低量化误差。 一句话概括核心矛盾：云端训练关心”多久训完”，端侧训练关心”内存够不够放得下”。

一、端侧学习：把训练搬到设备上，到底图什么

1.1 两个概念必须先分开

论文开篇就把**端侧学习（On-Device Learning）**拆成了两半：

端侧推理（On-Device Inference）——把训好的高效网络部署到本地硬件上，让设备跑各种智能推理任务（图像分类、目标检测等）。它关注的是设计冗余更少的网络，或压缩计算密集的网络，以适配有限的端侧算力。本系列前三篇讲的全都是这一半。

端侧训练（On-Device Training）——本地硬件直接在自己身上执行训练任务，不需要远程服务器。

这两半在论文里的分工很明确：第 2～4 章解决推理，第 5 章解决训练。

1.2 端侧训练 vs 云端训练：根本区别在哪

这是本篇最重要的一张表。很多人以为”端侧训练就是慢一点的云端训练”，这是错的——两者的瓶颈完全不同。

维度	云端训练	端侧训练
首要瓶颈	训练时长（吞吐量）	内存峰值（放不放得下）
算力	数百 GB 显存、TFLOPS 级	MB 级 SRAM、MFLOPS～GFLOPS 级
能耗	插电，几乎不考虑	电池供电，每焦耳都要算
数据	集中存储，随意访问	分散在设备上，出不去
隐私	数据要上传，有泄露风险	数据不出设备，天然合规
模型状态	训完即定	可以持续进化
网络依赖	常在线	可能长期离线

论文给了端侧训练一个非常到位的定义，值得逐字读：

端侧训练指的是本地硬件直接在自己身上执行训练任务、无需远程服务器的能力。与端侧推理不同——推理时部署的网络始终是静态的——端侧训练可以让部署的网络随时间不断进化。这使得已部署的网络能够适配从本地传感器新采集到的数据，从而获得更好的精度。

这引出了端侧训练的三大动机：

1. 隐私与安全。数据不需要上传到云端。这是端侧训练近年来火爆的首要原因——论文原话是”以实现安全的嵌入式智能（secured embedded intelligence）“。医疗影像、键盘输入、语音助手这类场景，数据出设备在很多司法辖区是不合规的。
2. 持续进化。设备可以用新采集的数据持续微调，越用越准。一个云端下发的通用模型在你的手表上跑三个月，如果它不能学习你的个人数据，它就永远是那个通用模型。
3. 省掉通信。海量传感器数据（如摄像头视频流）不必上传，带宽成本直降。

1.3 四条技术路线

论文把端侧学习分成四条互相平行、可以互相组合的路线：

• 通用端侧学习（General On-Device Learning）：解决”怎么在设备上把推理和训练跑起来”这个基础问题。
• 端侧持续学习（On-Device Continual Learning）：设备边用边学，但会遗忘旧知识。
• 端侧迁移学习（On-Device Transfer Learning）：数据太少训不了？拿预训练模型微调几层。
• 端侧联邦学习（On-Device Federated Learning）：很多设备一起训，但谁都不交出自己的数据。

论文强调：这些技术同样可跨网络类型泛化——联邦学习既可优化卷积网络，也可优化 Transformer。

（论文图 26 是第 5 章这四条路线的技术对比总览，它刻画的是精度 vs 训练内存/效率的权衡——因为在端侧，内存才是训练的第一约束，这与云端训练以”时长”为第一约束截然不同。那张图已放在本系列第 3 篇的末尾作为本篇的引子，可对照阅读。）

二、端侧训练的第一瓶颈：不是参数，是激活值

2.1 推理和训练的内存差在哪

这是第 5 章最有教学价值的一个洞见，也是初学者最容易忽略的。

先说推理：只做前向传播（forward propagation）。每一层算完，得到下一层的输入之后，这一层的中间激活值（intermediate activations）就可以扔掉了——它们不会被再用。所以推理的内存峰值大约等于”单层激活 + 全部参数”，非常小。

再说训练：除了前向，还要做反向传播（backward propagation）来用梯度下降更新参数。而反向传播计算某一层的梯度时，需要用到这一层前向时的输入（也就是上一层的激活值）。所以：

训练必须把所有层的中间激活值全部保存下来，一个都不能扔。

更糟的是，激活值的大小随 batch size 线性增长，而训练恰恰倾向于用大 batch 来加速。两件事一叠加，论文给出了结论：

中间激活值成为端侧训练的主要瓶颈。

2.2 一个震撼的数字：×13.9

论文引用 [44] 给出了一个具体的实测对比。以 ResNet-50 为例，在 batch size = 16 时：

激活值的大小是参数大小的 ×13.9。

我们来把它算成直观的字节数。ResNet-50 大约有 2560 万个参数，FP32 下每个 4 字节：

$$\text{参数内存}=25.6\times 10^6\times 4\text{B}\approx 102\text{MB}$$ $$\text{激活内存}\approx 102\text{MB}\times 13.9\approx 1.4\text{GB}$$

训练一次 ResNet-50 需要 1.4 GB 内存来放激活值，而参数本身只占 100 MB。

一块 STM32 microcontroller 的 SRAM 通常只有几百 KB 到 1 MB；即便是高端的 Cortex-M55，片上 SRAM 也就 1～2 MB。1.4 GB 是三个数量级的差距。这就是端侧训练为什么难。

图 27（原论文）：端侧训练与推理在内存消耗上的对比。这张图揭示了一个关键事实：激活值大小（activation size）而不是参数大小（parameter size），才是端侧训练的主要瓶颈。图中的对比清楚地显示，同样一个网络，训练时激活值占用的内存远超参数本身。这也指明了未来的研究方向：要高效端侧训练，就得想办法把激活值压下来。

2.3 三条省内存的技术路线

论文给出了三个代表性策略，我们逐个讲透。

路线一：梯度检查点（Gradient Checkpointing）

思路极其聪明：用计算换内存。

前向传播时只保留极小一部分中间激活值（这些被保留的点叫”检查点” / checkpoints）；反向传播需要那些没保存的激活值时，现场重新算一遍。

论文给出的收益是：

梯度检查点有潜力把训练内存消耗从 $O(n)$ 显著降低到 $O(\sqrt{n})$，其中 $n$ 是网络层数。

我们来感受一下这个量级的差别。假设 $n=100$ 层：

$$O(n)=100⟶O(\sqrt{n})=\sqrt{100}=10$$

内存降到十分之一。 做法就是：把 100 层分成 10 段，每段只存段首的激活值；反向时从最近的检查点重新前向算出段内需要的激活。

代价是什么？多了大约一次前向传播的计算。也就是说，训练时间大约增加 30%（前向 1 次 + 重算 1 次 + 反向 2 次，相比原来的前向 1 次 + 反向 2 次）。

最关键的一点是论文特意强调的：

梯度检查点不会降低训练精度，因为训练行为（数学上算出来的梯度）与标准训练方案完全相同。

它是一个纯工程优化，不触碰数学。这在压缩技术里非常罕见——剪枝、量化、低比特训练都会有精度代价，梯度检查点没有。所以它是”免费”的内存优化（如果你付得起时间的话）。

后续工作把梯度检查点推广到了任意计算图（不只是链式结构）和图神经网络（GNN）。

路线二：激活梯度剪枝（Activation Gradient Pruning）

思路来自一个经验观察：

反向传播过程中，绝大部分中间激活梯度都非常接近于 0，因此对梯度下降的影响极小。

既然如此，把这些极小的激活梯度剪掉（置零或不存储），就能以极小的精度损失换取内存消耗的下降，同时还能加速训练过程。

注意这里剪的是梯度而不是激活值——这和第 3 篇讲的权重剪枝是同一思想在不同对象上的应用：不重要的就扔掉。

相关做法还有：梯度过滤（gradient filtering）——把相似的激活梯度过滤掉，只保留元素独特的那些，减少激活梯度图里的元素数量；以及构建动态稀疏计算图，以**依赖输入（input-dependent）**的方式消除中间激活。

路线三：低比特训练（Low-Bit Training）

思路：既然推理可以用 INT8，那训练为什么必须用 FP32？

低比特训练指的是用低比特权重（例如 8 位、16 位）而不是全精度 32 位权重来训练网络，有潜力把训练内存消耗降低 ×32。

为什么能做到 ×32？因为低比特训练同时压低了两部分内存：

1. 网络权重：FP32 → INT8，直接 ×4；
2. 中间激活值：这才是大头，按 2.1 节的分析，激活才是瓶颈，把它压成 8 位同样是 ×4。

两者相乘，再加上优化器状态（momentum、variance 等）的压缩，综合收益可以逼近 ×32。

代表性工作：

• [522]：早期探索，用 16 位权重 + 随机舍入（stochastic rounding）训练，内存比标准 FP32 训练少 ×2，且精度相当。
• [523]：提出完整的 INT8 训练流水线，包含损失感知补偿（loss-aware compensation）和反向量化（backward quantization），借助主流硬件上已经高度优化的 INT8 算子实现微型端侧训练。
• [45]：优化真实量化图（real-quantized graphs），集成内存高效的稀疏更新方案和微型训练引擎，实现了 256 KB 内存下的端侧训练。

256 KB 这个数字值得停下来体会一下——它意味着训练可以在真正的微控制器（MCU）上跑了，而不只是在手机 SoC 上。

论文还点出了一个重要的联系：低比特训练和第 4 章讲的网络量化在技术上高度相似，因为两者都是用量化权重来降低网络复杂度。所以第 4 章的任何量化新进展，都可以直接搬来造福低比特端侧训练。（关于量化的数学细节，见本系列第 3 篇。）

组合使用：收益可以叠乘

论文最后给了一个很漂亮的组合示例：

我们可以轻易地把梯度检查点和低比特训练组合起来，进一步把训练内存消耗从 $O(\sqrt{n})$ 降到 $O(\sqrt{n})/32$。

用 $n=100$ 举例：从 $O(100)$ → $O(10)$ → $O(10/32)\approx O(0.31)$。相对原始的 $O(100)$，这是约 300 倍的降幅。这正是那 1.4 GB 能塞进 256 KB 的原因。

常见坑 1：用推理的内存估算来决定"能不能在设备上训练"

很多人看到”模型量化后只有 2 MB，我的 MCU 有 1 MB SRAM，应该能训”，结果一跑就 OOM。原因就是训练要保存全部中间激活，而激活可能是参数量的十几倍。判断能否端侧训练，永远用训练峰值内存（参数 + 激活 + 优化器状态 + 梯度），而不是模型文件大小。

2.4 端侧推理这一侧：微型网络

顺带补完”通用端侧学习”的另一半——高效端侧推理。思路很直接：**设计冗余极少的微型网络（tiny networks）**以适配有限的端侧算力。代表性工作包括 MicroNets、MCUNets、EtinyNet。

• MCUNetV1：提出联合设计——用 TinyNAS 搜轻量结构，同时用 TinyEngine 设计轻量推理引擎。二者协同，首次实现在微控制器上跑 ImageNet 规模推理。这里的”算法—系统协同设计”是关键：光有 TinyNAS 不够，还得有把内存调度到极致的引擎。
• MCUNetV2：提出基于分块（patch-based）的推理流水线压低内存——因为内存才是端侧推理的关键瓶颈。它改的是推理调度方式而非网络结构：把大特征图切成小块逐块算，峰值内存就降下来了。

还有一个非常反直觉的发现值得记住：训练微型网络比训练大网络更难。原因是：

现有的正则化技术（例如数据增强和 dropout）虽然有利于大网络的训练，却可能损害微型网络的训练表现。

解决办法是 [547] 提出的”增强网络本身”而不是”增强输入数据”——不去折腾数据，而是对小网络的结构本身做增强。这个发现打破了”正则化手段通用”的想当然。

三、端侧持续学习：越学越忘怎么办

3.1 设定：设备边用边学

端侧持续学习（On-Device Continual Learning），也叫终身学习（lifelong learning）或增量学习（incremental learning），是一种让已部署的网络持续从新采集的数据中学习、不断推高精度的范式。

它在真实嵌入式场景里特别吃香，尤其是那些本地传感器丰富的设备——设备可以通过本地传感器持续不断地采集新数据，然后用这些新数据在目标硬件自身上训练或微调已部署的网络，从而在目标任务上拿到更好的精度。

而且因为它在本地训练、不需要把新数据发回远程服务器，所以顺带保护了数据隐私、确保了数据安全。

3.2 核心难题：灾难性遗忘

但是，端侧持续学习有一个绕不开的致命问题——灾难性遗忘（Catastrophic Forgetting）。

论文的定义是：在适应新采集的数据时，遗忘先前所学知识的倾向。

为什么会遗忘？原因非常直白：

端侧持续学习必须调整预训练的网络权重才能适配新数据，而调整权重这个动作本身就会破坏先前学到的知识。

这不是个 bug，而是神经网络的固有性质。网络的全部知识都编码在那组权重里；你为了让它在任务 B 上表现好而改动权重，它在任务 A 上的表现几乎必然下滑。

用一个生活化的类比：你在大脑里用”同一块地方”记住了法语和西班牙语。你疯狂练西班牙语三个月，那块地方被西语重写了，法语就说不利索了。

3.3 已有的应对思路

论文列举了大量应对工作，可以按手法归成几类：

• 建立评测协议。[46] 是最早的系统性探索，它研究了三种常见的持续学习场景，并指出一个尴尬的事实：评估不同持续学习方法”令人沮丧地困难（frustratingly hard）“——因为各家用的实验设定不统一，数字没有可比性。于是它建立了一套评测协议。值得注意的是，论文明确指出 [46] 并不支持端侧持续学习，但我们可以把第 5.1 节（通用端侧训练）的进展轻松集成进去，从而实现高效的端侧持续学习。
• 资源受限场景落地。[524–527] 专门研究在资源受限的嵌入式系统上做持续学习，已展现出可观的精度提升。
• 推广到语言任务。[528–530] 把持续学习用于真实嵌入式场景的语言任务，例如环境声音分类（environmental sound classification）和自动语音识别（automatic speech recognition）。
• 推广到视觉 Transformer。受 ViT 成功的启发，[107, 531] 研究了用端侧持续学习持续改进主流视觉 Transformer 的精度。
• 改进训练流水线。[532–534] 从训练流程入手，提出了若干端侧训练增强手段来最大化精度提升，包括选择性权重更新（selective weight updates）、权重冻结（weight freezing）和深度网络集成（deep network ensembles）。

注意最后这一组的思路：只更新一部分权重、冻结其余部分。这正是缓解灾难性遗忘最直接的办法——把承载旧知识的权重”钉住”不动，只让新开的部分去适应新数据。

四、端侧迁移学习：只调 BN 也能打

4.1 为什么需要迁移学习

论文引用 [44] 指出一个现实困境：在真实嵌入式场景中，直接从零（from scratch）训练深度网络通常很困难，因为采集到的数据样本极其有限。

你在工厂里给一台设备装了一个摄像头，要它识别某种零件缺陷。你能拍到几百张缺陷照片就谢天谢地了——几百张样本从零训一个 ResNet？不可能。

解决办法就是端侧迁移学习（On-Device Transfer Learning）：在大规模数据集上预训练好的网络上做微调。

道理是：在 ImageNet 这种大规模数据集上预训练的网络，已经学会了提取通用的视觉特征（边缘、纹理、形状、部件），它可以充当一个强大的特征提取器。你只需要微调少数几层（例如批归一化层和最后一层），其余层通常冻结（frozen）。

4.2 迁移学习的巨大内存优势

这里有一个和第 2 节呼应的关键点：

与第 5.1、5.2 节讨论的端侧学习实践不同，端侧迁移学习不需要存储内存密集的中间激活值。因此它在训练内存消耗上保持了显著的高效性。

为什么？因为大部分层被冻结了，冻结的层不需要反向传播，也就不需要保存它们的激活值。这是一个巨大的工程红利——迁移学习在端侧的可行性远高于完整的端侧训练。

代价是：端侧迁移学习相当有挑战性，可能导致精度不佳，尤其是当目标数据集的数据分布与 ImageNet 相差甚远时。

4.3 四种微调方案的对比

论文（借助图 28）比较了四种典型方案，从重到轻：

方案	微调范围	可训练参数	训练内存	精度
FT-Full [548]	整个网络	最多	最大	最高
FT-Last [536]	只有最后一个线性层	最少	较小	较低
FT-Norm+Last [537]	归一化层 + 最后线性层	少	小	强
TinyTL [44]	冻结权重，只更新偏置（bias）	极少	最小	强

图 28（原论文）：各种端侧迁移学习方法的对比，包括 TinyTL [44]、FT-Norm+Last [537]、FT-Last [536] 和 FT-Full [548]。TinyTL 冻结权重、只优化偏置模块；FT-Norm+Last 微调归一化层和最后一个线性层；FT-Last 只微调最后一个线性层；FT-Full 微调整个网络。图中权衡的是训练内存 vs 精度。

演进脉络是这样的：

1. 早期做法 [535, 536] 提出微调所有网络层——精度确实更好，但由于要保存内存密集的中间激活，内存消耗相当可观。
2. 后续工作 [537–540] 发现往往不需要微调所有层：只微调批归一化层也能达到很强的精度。这会显著减少迁移学习过程中可训练参数的数量。于是这些工作提出只优化批归一化层里的可学习参数——也就是第 3 篇式 (13) 里的 $\gamma$ 和 $\beta$——其余可学习参数在迁移学习过程中全部冻结。
3. [538] 进一步揭示了一个惊人的事实：对于那些深度足够的网络，只训练 $\gamma$ 和 $\beta$ 就能达到出乎意料的强精度，这展示了批归一化层里那点可学习参数所具有的表达力（expressive power）。

等等，一个 BN 层的 $\gamma$ 和 $\beta$ 才占多少参数？一个 64 通道的 BN 层只有 128 个参数。整个网络加起来可能只占总参数的 1% 不到。这 1% 的参数居然能撑起迁移学习的精度——这是嵌入式深度学习里最反直觉的发现之一。

4.4 TinyTL：一个漂亮的观察

但是有个陷阱：

更少的可训练参数，并不能直接转化为更优越的训练内存效率。 如图 27 所示，它可能仍然需要大量的内存（例如在 batch size 为 8 时高达 326 MB）来存储批归一化层那些内存密集的中间激活。

也就是说，你虽然只训 1% 的参数，但批归一化层位于网络中间，要算它的梯度，就得把它前面所有层的激活都保存下来。省了参数，没省激活。

TinyTL [44] 的突破来自一个极其精准的观察：

中间激活值只在更新网络权重（weights）时才需要；而更新网络偏置（bias）不涉及中间激活值。

我们来推导一下为什么。设某一层的输出是 $y=Wx+b$。

• 权重的梯度：$\frac{\partial \mathcal{L}}{\partial W}=\frac{\partial \mathcal{L}}{\partial y}\cdot x^{\top }$ —— 需要输入激活 $x$。
• 偏置的梯度：$\frac{\partial \mathcal{L}}{\partial b}=\frac{\partial \mathcal{L}}{\partial y}$ —— 不需要 $x$！

就这么一个链式法则的差别。论文由此指出：

训练内存的瓶颈来自更新网络权重，而不是更新偏置。

于是 TinyTL 的方案呼之欲出：冻结网络权重，只更新网络偏置。

但”只更新偏置”会带来明显的精度损失（毕竟可调整的能力太弱了）。为了补偿，TinyTL 引入了轻量残差学习（lite residual learning）：用广义的内存高效偏置模块（generalized memory-efficient bias modules）去精炼（refine）那些内存密集的中间激活。这个残差模块本身只带极小的内存开销，却能把精度补回来。

最终效果：

TinyTL 把训练内存消耗从 250 MB 以上降低到仅仅 16 MB，使得探索存内计算（in-memory computing）架构来执行内存高效的迁移学习成为可能。

250 MB → 16 MB，约 15 倍。 这个数字配合前面的 $\times 13.9$ 一起看，你就明白端侧训练的研究主线是什么了：一切围绕”干掉激活值”展开。

一条贯穿第 5 章的主线

把第 2 节和第 4 节放在一起看，会发现所有技巧都在回答同一个问题：怎么少存中间激活值？

• 梯度检查点：不存，要的时候重算（用时间换空间）；
• 激活梯度剪枝：不重要的不存（用精度换空间）；
• 低比特训练：存小一点（用精度换空间）；
• 迁移学习/冻结：根本不需要反向，所以不用存；
• TinyTL：只更新偏置，偏置的梯度不需要输入激活。 抓住这条主线，第 5 章就不再是一堆散落的技巧了。

五、端侧联邦学习：数据不动，模型动

5.1 核心思想

端侧联邦学习（On-Device Federated Learning）是一种去中心化的（decentralized）学习范式：它让多个本地客户端设备（如手机）联合训练同一个网络，但不需要显式共享它们的原始数据。

论文给它的一句定位非常精准：

端侧联邦学习是”把神经网络带到数据那里”而非”把数据带到神经网络那里”这一更通用思路的一个实例。

这句话是整章的文眼。传统机器学习是”把数据搬到服务器”，联邦学习是”把模型搬到数据边上”。

它带来的三个好处：

1. 解决数据隐私、安全与所有权的根本问题——原始数据从未离开设备。
2. 随设备数量增加而加速训练——论文指出，当客户端设备数量增长时，联邦学习有潜力显著加速训练过程。
3. 特别适合嵌入式场景——嵌入式设备本来就在持续通过本地传感器采集新数据。

正因如此，联邦学习在学术界和工业界都获得了越来越多的关注，并已被用于大量真实智能应用：手机键盘的内容推荐（mobile keyboard content suggestions）、医学影像分析（medical image analysis）、智慧医疗基础设施（smart health care infrastructures）。

想一想医学影像这个例子就明白它为什么不可替代：多家医院都想训一个更好的肿瘤检测模型，但没有任何一家医院可以把病人的影像数据共享出去。联邦学习是唯一合规的解法。

5.2 标准五步流程

论文引用 [541] 给出了标准端侧联邦学习的五个迭代步骤，这是一个必须背下来的流程：

1. 初始化（Initialization）。从一个随机初始化的网络开始，称为全局模型（global model），由所有本地客户端设备共享。学习初期，中心服务器把全局模型下发给所有客户端，每个客户端收到的是同一个副本。

2. 本地训练（Local Training）。客户端收到全局模型后，把它当作本地模型，用本地采集的数据训练它。本地数据只留在本设备上，不与其他客户端共享。

3. 模型更新（Model Update）。本地训练结束后，每个客户端生成各自的模型更新方案（model update scheme），它本质上反映”这个设备从自己的数据里学到了什么”。关键一步来了：回传给中心服务器的是这些模型更新，而不是本地采集的数据——这有效消除了数据泄露、保护了数据隐私。

4. 聚合（Aggregation）。中心服务器接收所有客户端的模型更新方案，把它们聚合起来，产出一个改进的全局模型。最经典的聚合算法就是 FedAvg（Federated Averaging，联邦平均）——按各设备的数据量加权平均。

5. 分发（Distribution）。中心服务器把改进后的全局模型下发给所有客户端，然后重复以上步骤直到收敛。

5.3 真实瓶颈：不是算力，是带宽

联邦学习听起来很完美，但论文立刻指出了它的关键局限，而且这个局限来自一个容易被忽视的角度——数据传输：

与配备了高端网络基础设施的中心服务器不同，真实嵌入式场景中的本地客户端设备往往是低端的，网络能力较弱。

于是两个动作都可能极其耗时：

1. 把全局模型从中心服务器下发到客户端；
2. 把模型更新从客户端回传到服务器做聚合。

注意这个瓶颈的性质变了：在云端训练里瓶颈是算力和内存；在联邦学习里，通信（communication）成了第一位。一个 100 MB 的模型，用 4G 网络上传一次可能要几分钟、几十 MB 流量，乘上几万个设备和几百轮迭代——成本是天文数字。

论文给出的应对技术，全部围绕”减少远程服务器与本地设备之间传输的总比特数”：

技术	思路
联邦平均（Federated Averaging） [541]	客户端本地多训几轮再上传一次，减少通信轮次
梯度压缩（Gradient Compression） [542, 543]	只传重要的梯度、或稀疏化/低秩化梯度
量化（Quantization） [414]	把更新量从 FP32 压成 INT8 再传
延迟梯度平均（Delayed Gradient Averaging） [544]	容忍一定的延迟，减少同步次数
部分变量训练（Partial Variable Training） [545]	每次只训练/传输一部分变量
本地训练稀疏化（Local Training Sparsity） [47]	本地训练时就保持稀疏，更新量天然小

看明白了吗？第 4 章讲的压缩技术（量化、剪枝/稀疏）在联邦学习里有了全新的用武之地——它们不再只是为了省内存，更是为了省带宽。这也是为什么第 4 章的未来展望里专门列了一条”联邦网络压缩（Federated Network Compression）“：联邦剪枝、联邦量化、联邦蒸馏，在保持精度与训练效率竞争力的同时显著增强数据隐私。

常见坑 2：以为联邦学习"完全不需要服务器"

标准联邦学习依然依赖中心服务器做模型分发与聚合，因此需要稳定的互联网连接来在设备与服务器之间搬运数据。当网络连接受限或不可用时，联邦学习效率会严重下降。这正是论文提出的”离线端侧联邦学习”这一未来方向要解决的问题（见第 8 节）。

六、端侧大模型：LLM 为什么难上设备

第 6 章处理的是一个更尖锐的问题。**大语言模型（Large Language Models, LLMs）**如 GPT-3、GPT-4 在各种真实语言处理任务上取得了令人瞩目的成功，但论文一针见血地指出：

LLM 强大的学习能力是以过度的计算复杂度为代价的。

具体有多夸张？

OpenAI 的 GPT-3 包含 1750 亿（175 billion）个参数。

而且更糟的是趋势：论文指出，为了取得最先进的性能，LLM 的模型规模还在持续不断增大。这让在嵌入式系统上部署 LLM 变得愈发困难。

6.1 预备知识：三种 LLM 架构

在讲”怎么压”之前，先讲清楚”压的是什么”。论文按内在架构把当前主流 LLM 分成三类：

（1）仅编码器（Encoder-Only）语言模型 专注于把输入文本转换成能反映上下文的连续表示。适用于只需理解或嵌入输入文本、输出不必是生成序列的任务，例如句子分类、命名实体识别、抽取式问答。

代表：BERT，采用掩码语言建模（masked language modeling）训练，能从左右两个方向理解上下文。

（2）仅解码器（Decoder-Only）语言模型 专注于基于输入文本生成文本，适用于文本生成、语言建模等任务。

代表：GPT-3，采用自回归（auto-regressive）训练，学习从之前所有的词准确预测下一个词。

为什么"仅解码器" dominates 现在的 LLM？

因为生成式任务（对话、写作、代码）天然是自回归的，而仅解码器架构的训练和推理形式完全一致，工程上最简单、扩展性最好。今天的 GPT 系列、LLaMA 系列都是这个路子。顺带一提，自回归这个性质是后面所有 LLM 系统优化（KV cache、prefill/decode 分离）的根源。

（3）编码器—解码器（Encoder-Decoder）语言模型 也叫序列到序列（seq2seq）模型：编码器把输入文本编码成特征表示，解码器据此生成输出序列。适用于把输入文本转换成不同格式的任务，如翻译、摘要、对话系统。

代表：T5（把任务统一表述为”文本到文本”转换）、BART（双向编码器 + 自回归解码器，擅长生成式与综合性任务）。

6.2 LLM 的计算复杂度瓶颈：自注意力

所有主流 LLM 都构建在 Transformer 之上，并**重度依赖自注意力机制（self-attention）**来衡量句子中不同词的重要程度（且与它们的位置关系无关）。

但自注意力有一个致命的性质。论文引用 [599] 指出：

自注意力机制的二次（quadratic）时间和内存复杂度，会显著拖慢 LLM 的预训练、微调和推理各个阶段。

“二次”指的是相对于序列长度 $L$。自注意力要计算一个 $L\times L$ 的注意力矩阵：每个词都要和所有词算一次相关性。所以复杂度是 $O(L^2\cdot d)$，内存是 $O(L^2)$。

我们算一下这个二次有多可怕。设 $L$ 是序列长度：

$$L=2048\Rightarrow L^2\approx 4.2\times 10^6$$ $$L=4096\Rightarrow L^2\approx 1.7\times 10^7$$ $$L=8192\Rightarrow L^2\approx 6.7\times 10^7$$

序列长度翻倍，注意力开销变 4 倍；翻两番，开销变 16 倍。 这就是为什么长上下文（long context）一直是 LLM 最贵的能力。

因此论文给出结论：当前最先进的高效 LLM 通常专注于探索计算高效的自注意力机制。

6.3 两条提效路线

图 29（原论文）：第 6 章讨论过的高效 LLM 架构、LLM 压缩技术和 LLM 系统的总览。这张图把端侧大模型的三条主线串了起来：架构侧（高效注意力）、压缩侧（剪枝/量化/蒸馏）、系统侧（推理引擎与调度）。三者并行且可叠加——这也印证了本系列第 1 篇就强调的核心观点：高效深度学习是一个”算法—系统协同设计”的问题。

路线 A：通用的高效注意力（算法近似）

目标是把 $O(L^2)$ 降下来。代表性思路：

• 聚类注意力（Clustered Attention） [558]：把不同的 query 聚成簇，只为簇中心（centroids）计算注意力，而不是为每个 query 都算。然后用算好的簇去识别每个 query 注意力最高的 key，再精确计算这些 key-query 点积。这是一个”粗筛 + 精算”的两级策略。
• Nyström 方法 [559]：借鉴数值分析里的 Nyström 方法，用线性复杂度近似标准自注意力，从而支持长达数千 token 的序列。
• 核密度估计（KDE）求解器 [560]：这篇工作先做了个精确的诊断——自注意力的复杂度瓶颈主要来自两处：① softmax 分母中配分函数（partition function）的计算；② softmax 矩阵与 value 矩阵的乘法。然后用基于子采样的快速矩阵乘积来突破这两个瓶颈，可以在可证明的谱范数界下以次二次时间近似注意力。
• 单头门控注意力 [561]：用指数移动平均把”位置感知的局部依赖”这一归纳偏置引入本来位置无关的注意力，实现线性时空复杂度，性能损失极小。
• 通用近似框架 [562]：具有线性时空复杂度，并揭示了 Linformer 等线性 Transformer 背后的理论洞见。
• 融合式近似 [563]：带融合（fused）操作的高效注意力近似机制。

路线 B：硬件感知的高效注意力（系统实现）

这一类不做数学近似，而是优化注意力在真实硬件上的执行方式。对嵌入式读者来说，这一类往往更实用：

• FlashAttention [54]：IO 感知的精确（exact）注意力算法——注意它是”精确”的，不做任何近似。核心手段是分块（tiling），减少 GPU 高带宽显存（HBM）与片上 SRAM 之间的读写总量。它的洞见是：注意力的瓶颈不是算力，是访存。
• FlashAttention-2 [55]：指出 FlashAttention 仍远不如优化过的矩阵乘（GEMM）快，原因是 GPU 上线程块和 warp 之间的工作划分不佳。改进三点：① 调整算法减少非 MatMul 的 FLOPs；② 跨线程块并行化注意力计算；③ 在 warp 之间分配工作以减少共享内存通信。
• FLASHLINEARATTENTION [566]：硬件高效的线性注意力算法，在内存搬运与可并行性之间做权衡，甚至比 FlashAttention-2 还快。
• PagedAttention [53]：从操作系统的虚拟内存分页中汲取灵感，把请求的 KV 缓存划分成固定大小的块，每块包含固定数量 token 的 key 和 value。这解决了 LLM 服务里最要命的显存碎片问题。
• A3 [564]：指出用矩阵—向量乘法实现注意力往往次优，提出用算法近似 + 硬件专用化联合加速。
• ELSA [565]：有效近似方案，大幅减少计算负载。

为什么 PagedAttention 对端侧特别重要？一个手算

以 LLaMA-7B 为例（32 层、隐藏维度 4096），用 FP16 存 KV 缓存，每个 token 需要：

$$2(\text{K 和 V})\times 32(\text{层})\times 4096(\text{维度})\times 2\text{B}=524288\text{B}\approx 0.5\text{MB/token}$$

单个请求 2048 token 就是 1 GB；如果 batch 是 32，总 KV 缓存就是 32 GB——远超 7B 模型本身 FP16 下的 14 GB 权重。

而实际服务中每个请求的长度是事先未知且动态变化的。如果按”最长可能长度”预分配，浪费极其惊人；如果按需连续分配，又会产生大量碎片。PagedAttention 把它切成固定大小的块按需分配，把浪费从”按最长预留”降到”最多浪费一个块”。这就是操作系统分页思想在 LLM 上的一次漂亮迁移。

七、LLM 压缩三板斧：剪枝、量化、蒸馏

设计高效架构之外，另一条路是压缩已有的计算密集型 LLM。注意第 4 章的三板斧在这里全部重演了一遍，但每个都有 LLM 特有的新难题。

7.1 LLM 剪枝

非结构化 LLM 剪枝：去掉不重要的 LLM 权重/连接。它能比结构化剪枝取得更激进的压缩率，同时保持很强的精度。

• SparseGPT [567]：证明了 LLM 可以被一次性（one-shot）剪到至少 50% 的稀疏度，而且无需任何重训（without any retraining），精度损失极小。“one-shot + 无需重训”这点极其关键——因为重训一个 1750 亿参数的模型根本不现实。
• Wanda [58]：提出按 per-output 的方式，剪掉 “权重绝对值 × 对应输出激活” 最小的那些权重。注意这个准则和第 3 篇讲的纯幅度准则 $|w|$ 的区别：它把激活也考虑进来了。一个权重虽然小，但如果它对应的激活一直很大，那它对输出的贡献其实不小，不该剪。
• SparseGPT 和 Wanda 都可以推广到半结构化剪枝 [346, 568]，以获得更好的硬件并行性，在 cuSPARSELt、TVM 等库的支持下取得真实的端侧推理加速。
• ReLU 复活 [569]：主张在 LLM 中重新启用 ReLU 激活，并探索基于 ReLU 的 LLM 里的稀疏模式，结果显示 ReLU 激活能有效把 LLM 推理计算开销降低最多 3 倍。这是一个很有意思的”复古”趋势——现代 LLM 普遍用 GELU/SwiGLU，而 ReLU 因为能产生真正的零激活，反而更适合稀疏化。
• 非结构化剪枝还被广泛用于增强 LLM 的预训练和微调过程 [570–572]。

结构化 LLM 剪枝：能在目标硬件上取得真实加速，但精度损失更激进。为了解决这个两难，当前主流的结构化 LLM 剪枝方法通常都带一个额外的微调阶段来恢复精度：

• LLM-Pruner [57]：用结构化剪枝根据梯度信息选择性地移除非关键的耦合结构（non-critical coupled structures），在优化计算效率的同时保留 LLM 的大部分功能。恢复精度的手段是 LoRA [600]——只需 3 小时、5 万条数据。这个数字值得记住：它说明”剪完再训”的成本可以是可控的。
• ZipLM [574]：迭代地识别并移除损失—运行时间权衡最差（worst loss–runtime trade-off）的 LLM 组件，最终得到高效 LLM，并能泛化到各种运行时约束。
• LoRAShear [575]：先在 LoRA 模块上构建依赖图，然后对 LoRA 适配器做渐进式结构化剪枝，实现内在的知识迁移。为了恢复剪枝中丢失的信息，它还提出了带动态数据适配器的有效微调方案，缩小剪枝后 LLM 与未剪枝 LLM 的性能差距。
• 层剪枝 [577–579]：近期多个工作证明 LLM 的层也是冗余的，可以被移除从而在精度损失极小的情况下大幅提升推理效率。例如 ShortGPT [578] 和 Shorted-LLaMA [579] 按层重要性分数移除不重要的层；LLM-Streamline [577] 则把不重要的层替换成更轻量的层。

7.2 LLM 量化

目标是把 LLM 权重从高位宽降到低位宽（从 32 位降到 8 位甚至 1 位），以轻微的精度损失大幅提升推理效率。

这里必须先讲清楚 LLM 量化区别于普通网络量化的核心难题。论文在介绍 SmoothQuant 时点破了它：

权重容易量化，激活不容易量化（weights are easy to quantize while activations are not）。

为什么？回忆第 3 篇的仿射量化 $r=S(q-Z)$，缩放因子 $S$ 正比于数值范围。LLM 的激活里存在极端的离群值（outliers）——少数几个维度上的激活值可能是其他维度的几十倍甚至上百倍。这些离群值把 $S$ 撑得巨大，导致绝大多数正常值挤在极少数几个量化格点里，量化精度彻底崩掉。

于是近两年的 LLM 量化工作，很大一部分都在跟离群值作斗争：

方法	核心思路
SmoothQuant [59]	**训练免费（training-free）**的 PTQ，实现 8 位权重 + 8 位激活（W8A8）。关键技巧：用等价的数学变换，把量化的难度从激活”平滑”转移到权重上，离线消除激活离群值
AWQ [60]	硬件友好的仅权重量化。基于一个有意思的观察：权重并非同等重要，只保留 1% 的显著权重（salient weights）就能大幅降低量化误差。通过观察激活（而不是权重）来搜索最优的 per-channel 缩放方案，保护这 1%
SpQR [580]	先识别并隔离会造成特别大量化误差的离群权重，把它们用高精度存储，其余所有权重压到 3～4 位。可在各种模型规模上实现近无损压缩，压缩率与以往方法相当
OS+ [581]	用通道级平移（channel-wise shifting）处理不对称性、通道级缩放（channel-wise scaling）处理集中性，且这些操作可以无缝迁移进后续量化模块并保持严格等价
OWQ [582]	离群值感知的权重量化：优先挑出对量化敏感的一小部分结构化权重用更高位宽存储，其余稠密权重用精细调优的量化
QuIP [583]	两阶段：① 自适应舍入以最小化预定义的二次代理目标；② 通过乘以随机正交矩阵确保权重与 Hessian 的非相干性（incoherence）
OmniQuant [584]	全方位校准量化，含两个新组件：**可学习权重裁剪（LWC）**调制极端权重值、可学习等价变换（LET）把量化难题从激活转移到权重。二者可无缝集成进一个分块误差最小化的可微优化框架
[585]	用全面实验系统分析 LLM 量化的效果，总结现状、给出应用建议、指出未来方向
OliVe [586]	算法/架构协同设计方案，提出 离群值—受害者对（outlier-victim pair, OVP）量化，以低硬件开销在本地处理离群值

AWQ 的”1%“值得单独体会：它说明 LLM 里绝大多数权重是”无所谓”的，真正关键的只有百分之一。这和彩票假说（第 3 篇 2.7 节）的精神是一脉相承的——大模型里存在极小但极关键的子结构。

7.3 LLM 蒸馏

另一条路是用大 LLM 的预训练知识来增强小 LLM 的训练或微调过程，让小 LLM 在展现优越效率的同时保持接近大 LLM 的性能。按学生能看到教师的多少分两类：

（1）黑盒蒸馏（Black-Box） 教师的参数对学生不可见，学生只能看到教师的最终输出。典型场景是把 GPT-3、GPT-4 这类商业闭源 LLM 当教师，用它们的预测来增强小学生 LLM 的训练或微调。

• Self-Instruct [61]：先用 GPT-3 的 API 大量生成指令、输入和输出序列，过滤掉无效或重复的，再用这些自生成的数据去微调原始 GPT-3 模型。最终在 Super-NaturalInstructions 上比原始 GPT-3 绝对提升 33%。

这个 +33% 是一个很惊人的数字，它说明：小模型的能力瓶颈往往不是架构，而是训练数据的多样性和指令覆盖度。

• [587]：用 GPT-4 生成丰富的指令跟随数据对，再用这些数据对微调小的 LLaMA 模型以提升性能。

（2）白盒蒸馏（White-Box） 教师的参数对学生可见，学生还能看到教师隐藏层的中间输出。随着开源 LLM 的兴起，白盒蒸馏越来越流行、也越来越有价值，因为学生 LLM 有可能从教师的隐藏状态（hidden states）中获益。

• MiniLLM [62]：先把前向 KL 散度（Kullback-Leibler divergence, KLD）目标替换成反向 KLD（reverse KLD），这可以防止学生 LLM 高估教师分布中的低概率区域。这一步很关键：标准的前向 KLD 会逼学生去”覆盖”教师分布里所有概率质量的角落，而学生能力不够，只能靠摊薄、乱猜来凑——这就是生成质量崩坏的根源。反向 KLD 则允许学生”专注”于教师分布的主要模式。
• TED [590]：任务感知的逐层蒸馏，用任务感知过滤器在每一层对齐师生的隐藏状态，挑选出对目标任务有用的知识，缩小知识鸿沟。
• GKD [591]：让学生 LLM 在自己生成的输出序列上训练，同时接受教师对这些序列的反馈；并允许灵活选用损失函数，即使学生缺乏模仿教师分布的表达能力也能提升效果。
• [592]：token 级缩放的 logit 蒸馏，用于 LLM 的量化感知训练，能缓解过拟合并增强蒸馏过程。

注意最后一条把蒸馏与量化感知训练（第 3 篇第 5 节）结合起来，再次印证”三种压缩技术可以叠加”。

八、LLM 系统与未来展望

8.1 系统层面的优化

除了算法，还有一大批高效 LLM 系统与基础设施工作，从系统实现角度优化 LLM 的**生成式推理（generative inference）**效率。

系统	核心思路
FlexGen [63]	高吞吐生成引擎，让 LLM 跑在单张显存有限的 GPU 上，通过聚合 GPU、CPU 和磁盘的内存与算力，在各种硬件资源约束下灵活配置；并通过求解线性规划问题搜索高效的张量存储与访问模式
Tabi [65]	多级推理引擎，用小模型先服务查询，只有难查询才路由给 LLM。用校准过的置信度分数决定是直接用小模型的结果，还是转给 LLM。专为判别式模型（而非生成式 LLM）的服务框架优化
DeepSpeed [593]	① 多 GPU 推理引擎，模型装得下时最小化延迟、最大化吞吐；② 异构推理引擎，装不下时借助 CPU 和 NVMe 内存实现高吞吐
FastServe [594]	① 利用自回归特性实现以单个输出 token 为粒度的抢占；② 用跳过连接的多级反馈队列调度器最小化作业完成时间
Petals [64]	分布式协作推理，让普通设备也能参与大模型推理
$S^3$ [595]	发现如果推理系统事先知道输出序列的长度，就能大幅提升运行时吞吐。于是：① 先预测输出序列长度；② 再基于预测调度生成查询以提高资源利用率和吞吐；③ 最后处理预测错误的情况
Splitwise [596]	把 LLM 推理的两个阶段拆分到不同硬件上，让每个阶段用最合适的硬件、配置独立的计算资源；并利用 GPU 集群的快速背板互连优化跨硬件的状态传输
DistServe [597]	把 prefill 和 decode 计算解耦（disaggregate），分配给不同的 GPU，从而大幅消除 prefill-decode 相互干扰；并根据服务集群的带宽优化这两个阶段以最小化通信开销
Liger [598]	分布式协作推理系统，在多 GPU 上实现低延迟 + 高吞吐，并用高效调度策略把各请求的计算与通信 kernel 调度到多 GPU

这里需要解释一下 prefill 和 decode 这两个阶段，因为好几项工作都在围绕它做文章：

• Prefill（预填充）：拿到用户的 prompt，一次性并行处理所有输入 token，生成第一个输出 token。这个阶段是**计算密集（compute-bound）**的——大量矩阵乘法，GPU 算力吃满。
• Decode（解码）：之后每生成一个新 token，都要重新跑一遍前向，并把新 token 的 K/V 追加进 KV 缓存。这个阶段是**访存密集（memory-bound）**的——每次只算一个 token，算力利用率极低，时间几乎全花在把 14 GB 权重从显存搬到计算单元上。

两个阶段的资源特征完全相反，放在同一块 GPU 上就会互相干扰（prefill 抢占算力导致 decode 延迟飙升，decode 抢占带宽导致 prefill 变慢）。Splitwise 和 DistServe 的解法都是把它们物理分开——这正是”先看清瓶颈性质，再谈优化”的典型范例。

8.2 端侧学习的四个未来方向

论文第 5.5 节展望了端侧学习领域：

（1）离线端侧联邦学习（Offline On-Device Federated Learning） 标准联邦学习高度依赖中心服务器更新本地模型，需要稳定的互联网来搬运数据。当网络连接受限或不可用时，端侧学习效率会严重下降。 所以方向是：去掉远程中心服务器，让本地设备自己完成学习任务，这有潜力显著提升端侧学习效率。

（2）个性化端侧学习（Personalized On-Device Learning） 端侧学习有强烈的本地个性化特征，这是它与全局训练的根本区别。双重好处：一方面，设备直接从本地用户学习，提供用户定制的 AI 方案，且数据不需上云，保护了隐私；另一方面，由于能持续采集丰富的个性化新数据，它能取得更好的精度。未来应让本地设备主动、快速地适应用户的多样化需求，例如个性化语音助手。

（3）鲁棒的端侧学习（Robust On-Device Learning） 端侧学习仍有严重局限，例如对抗鲁棒性差。这在真实嵌入式系统（如嵌入式视觉感知）中尤其重要，因为环境会随时间动态变化，使本地学习更容易受到对抗攻击，尤其是未见过的对抗攻击——哪怕是很简单的攻击，也可能显著劣化端侧学习性能。未来方向是开发具备新型对抗训练算法的鲁棒端侧学习技术。

（4）高效的端侧学习生态系统（Efficient On-Device Learning Ecosystems） 未来还应该开发高效的端侧学习生态系统（含软硬件框架），来支持端侧学习应用的开发、部署和管理。论文举了一个很现实的例子：[45] 是最具代表性的端侧学习方法之一，它用量化来压低训练内存消耗，但主流嵌入式计算系统并不支持低比特训练，导致主流系统难以受益。

这一条点出了贯穿全篇的真理：算法再漂亮，没有软硬件栈支持也落不了地。 这正是本系列第 5 篇（框架与应用）的主题。

8.3 端侧大模型的四个未来方向

论文第 6.5 节展望了高效 LLM 领域：

（1）面向高效 LLM 的 AutoML 当前高效 LLM 通常建立在人工启发式之上，尽管有效，但需要大量专业知识和工程投入。未来方向是用 AutoML 自动探索：给定一个高效 LLM，自动搜索适配它的高效系统实现以取得最优端侧加速，或自动搜索适配它的剪枝/量化策略以取得最优的准确率—效率权衡。

（2）高效 LLM 的替代结构（Alternative Structures） 当前 LLM 重度依赖 Transformer 的自注意力，而自注意力的二次时间和内存复杂度严重拖慢了预训练、微调和微调推理。近年来出现了若干替代结构——RWKV [601]、Mamba [602]、RetNet [603]——它们展现出优化过的计算效率，让研究者不用 Transformer 也能做高效的语言建模。例如 RetNet 引入循环表示（recurrent representation）来实现低成本推理，在不牺牲语言建模性能的前提下改善了解码吞吐、运行时延迟和 GPU 内存。

这是一个值得嵌入式读者高度关注的方向：Mamba/RWKV 这类状态空间模型（SSM）把复杂度从 $O(L^2)$ 降到 $O(L)$，正好命中了嵌入式的痛点。

（3）面向高效 LLM 的硬件感知基准（Hardware-Aware Benchmarks） 当前高效 LLM 通常是按参数量或 FLOPs 来优化的。但是——这句话和第 3 篇的”常见坑 2”完全呼应——这些理论复杂度指标无法准确反映目标硬件上的运行时性能（例如延迟和能耗）。这使得公平比较不同高效 LLM 的运行时推理效率变得困难。未来方向是设计硬件感知的基准，纳入跨不同硬件系统的多种硬件性能指标（延迟、能耗等）。

（4）面向高效 LLM 的基础设施（Infrastructures） 近期有大量高效 LLM 压缩的工作（剪枝、量化），但它们常常需要专用硬件加速器，因而无法在现代嵌入式计算系统上取得真实的端侧推理加速。论文举了反例：非结构化 LLM 剪枝能移除不重要的权重、探索出压缩率极高的稀疏 LLM，但由于不规则的网络稀疏性，所得的稀疏 LLM 无法取得真实的端侧推理加速（这一点和第 3 篇 2.3 节的结论完全一致）。另一工作 [586] 探索了加速量化 LLM 并取得不错表现，但对于真实世界的大规模部署而言还远远不够。未来方向是设计专用的软硬件基础设施来进一步优化 LLM 的端侧推理。

全篇收束

把第 5、6 两章放在一起看，会发现这篇百页综述有一条一以贯之的暗线：

在嵌入式场景里，真正的约束从来不是”算力不够”，而是”内存放不下、带宽传不动、能耗扛不住”。

• 第 2、3 章（手工/自动设计）：在结构上省；
• 第 4 章（压缩）：在结构与数值精度上省；
• 第 5 章（端侧学习）：在训练时的激活内存上省；
• 第 6 章（端侧 LLM）：在注意力复杂度、KV 缓存、通信与调度上省。

手段千变万化，判断标准只有一个：在目标硬件上真机跑一次，看延迟、能耗、内存峰值和精度。

常见坑 3：把"参数量小"当成"能在设备上跑"

三个反例：① 训练时激活值可能是参数量的 13.9 倍（图 27）；② LLM 服务时 KV 缓存可能超过模型权重本身（batch 32 × 2048 token 时 KV 缓存 32 GB vs 7B 模型 FP16 权重 14 GB）；③ 自注意力的开销是序列长度的平方，序列翻倍开销变 4 倍，与参数量完全无关。永远用真实部署形态下的峰值资源占用来判断可行性。

通关标准

• 能说清端侧训练和云端训练的根本区别：云端瓶颈是训练时长，端侧瓶颈是内存峰值；端侧训练还能带来隐私、持续进化、省带宽三大动机。
• 能解释为什么训练比推理吃内存：反向传播需要保存所有中间激活，而推理算完一层就能释放。记住 ResNet-50 在 batch 16 下激活是参数的 ×13.9。
• 能说出三条省训练内存的路线及其代价：梯度检查点 $O(n)\to O(\sqrt{n})$（不损失精度，用时间换空间）、激活梯度剪枝（极小精度损失）、低比特训练（最多 ×32）。
• 能说清持续学习的灾难性遗忘为什么会发生，以及”冻结部分权重”为什么能缓解。
• 能用链式法则解释 TinyTL 为什么只更新偏置：$\partial \mathcal{L}/\partial W$ 需要输入激活 $x$，而 $\partial \mathcal{L}/\partial b$ 不需要。记住 250 MB → 16 MB。
• 能复述联邦学习的五步流程，并说出它在嵌入式场景下的第一瓶颈是通信带宽而不是算力。
• 能解释自注意力为什么是 $O(L^2)$，以及 FlashAttention（IO 感知、精确）、PagedAttention（分页 KV 缓存）分别在解决什么问题。
• 能说出 LLM 量化的核心难题是激活离群值，以及 SmoothQuant（难度迁移）、AWQ（保护 1% 显著权重）、SpQR（3～4 位 + 离群值高精度）的各自解法。
• 记住关键数字：LLM 剪枝 50% 一次性无需重训、LLM-Pruner + LoRA 3 小时 / 5 万条数据、Self-Instruct +33%、ReLU 可降 LLM 推理开销最多 3 倍、[45] 256 KB 下端侧训练。

自测 1：为什么"训练需要的内存"远大于"模型文件大小"？请给出量化说明。

因为反向传播必须保存所有层的中间激活值：推理时第 $L$ 层算完就能释放第 $L-1$ 层的激活，但训练时第 $L$ 层的梯度需要第 $L$ 层的输入激活，一个都不能扔。而激活大小随 batch size 线性增长，训练又倾向用大 batch。 量化例子：ResNet-50 约 2560 万参数，FP32 下约 $25.6\times 10^6\times 4\text{B}\approx 102\text{MB}$；论文实测 batch 16 时激活是参数的 ×13.9，即约 1.4 GB。而 MCU 的 SRAM 通常只有几百 KB——差三个数量级。所以判断”能否端侧训练”必须用训练峰值内存，不能用模型文件大小。

自测 2：TinyTL 说"训练内存的瓶颈来自更新权重，而不是更新偏置"，请用链式法则证明，并说明它带来了多大的收益。

设某层 $y=Wx+b$，上游传回的梯度是 $\partial \mathcal{L}/\partial y$。则

$$\frac{\partial \mathcal{L}}{\partial W}=\frac{\partial \mathcal{L}}{\partial y}\cdot x^{\top }$$

这一项显式依赖输入激活 $x$，所以必须把 $x$ 存下来。而

$$\frac{\partial \mathcal{L}}{\partial b}=\frac{\partial \mathcal{L}}{\partial y}\cdot 1=\frac{\partial \mathcal{L}}{\partial y}$$

完全不依赖 $x$。 所以 TinyTL 冻结权重、只更新偏置，就不需要保存那些内存密集的中间激活了。代价是只调偏置的表达能力弱、会掉点，于是它用轻量残差学习（广义内存高效偏置模块）去精炼激活、把精度补回来，而残差模块本身内存开销可忽略。 收益：训练内存从 250 MB 以上降到 16 MB（约 15 倍），使得在存内计算架构上做内存高效迁移学习成为可能。

自测 3：联邦学习为什么在嵌入式场景里"带宽"比"算力"更值得优化？有哪些对应的压缩手段？

因为标准联邦学习要反复做两件事：① 服务器把全局模型下发给所有客户端；② 客户端把模型更新回传做聚合。而真实嵌入式场景的客户端设备往往是低端的，网络能力弱——一个 100 MB 的模型用移动网络传一次可能要几分钟和几十 MB 流量，乘上几万设备和几百轮迭代，成本不可接受；相比之下，本地跑几轮训练对现代手机 SoC 并不慢。 所以优化重点是减少服务器与设备之间传输的总比特数：FedAvg（本地多训几轮再传，减少轮次）、梯度压缩（只传重要/稀疏化/低秩化梯度）、量化（FP32→INT8 再传）、延迟梯度平均（减少同步）、部分变量训练（每次只传一部分）、本地训练稀疏化（更新量天然小）。 注意：第 4 章的剪枝/量化/蒸馏在这里有了新用途——省带宽而非省内存，这正是”联邦网络压缩”的由来。

自测 4：LLM 量化和普通 CNN 量化相比，多出来的核心难题是什么？三种主流方法分别怎么解决？

多出来的难题是 LLM 激活里存在极端离群值（outliers）。仿射量化 $r=S(q-Z)$ 的缩放因子 $S$ 正比于数值范围，少数维度上特别大的激活会把 $S$ 撑得巨大，导致绝大多数正常值挤在极少数格点里，量化精度彻底崩坏。所以论文说：权重容易量化，激活不容易量化。 三种解法：① SmoothQuant 用等价数学变换把量化难度从激活迁移到权重，离线平滑离群值，实现 W8A8 且无需训练；② AWQ 基于”只有 1% 权重是显著的”，通过观察激活搜索最优 per-channel 缩放来保护这 1%；③ SpQR 先隔离会造成大误差的离群权重并用高精度存储，其余压到 3～4 位，实现近无损压缩。 共同思路：把有限的精度预算花在刀刃上——要么把难题转移走，要么给关键部分开小灶。

自测 5：为什么要把 LLM 推理拆成 prefill 和 decode 两个阶段分别优化？

因为两个阶段的资源特征完全相反，混在一块 GPU 上会互相干扰：

• Prefill：一次性并行处理整个 prompt，生成第一个输出 token。大量矩阵乘法，计算密集（compute-bound），GPU 算力吃满。
• Decode：之后每生成一个 token 都要重跑前向并追加 KV 缓存。每次只算一个 token，访存密集（memory-bound），时间几乎全花在把十几 GB 权重从显存搬到计算单元上，算力利用率极低。

混在一起会互相干扰：prefill 抢算力让 decode 延迟飙升，decode 抢带宽让 prefill 变慢，尾延迟极难控制。 解法是物理分开：Splitwise 把两阶段拆到不同硬件、配独立资源，并用 GPU 集群的快速背板互连优化跨硬件状态传输；DistServe 把 prefill 和 decode 解耦到不同 GPU，消除干扰并按集群带宽最小化通信开销。 这说明：系统优化的第一步是看清瓶颈性质（算力 vs 访存），而不是盲目加算力。