显存爆掉的那一刻,屏幕上通常只有一行干巴巴的报错:试图分配多少字节失败,已分配多少、保留多少。很多人第一反应是"参数表上写着这卡能跑啊",然后开始怀疑驱动、怀疑框架、怀疑人生。我见过太多人在这一步直接把机器换掉,结果新卡到手,跑同样的 Step 5 Preview 本地部署,换个分辨率又爆了。
问题从来不在"显存总量"这一个数字上。Step 5 Preview 这类预览版模型,本地部署时的显存 OOM 是一笔四本账没对上的结果:权重占多少、激活峰值多高、缓存吃多少、碎片浪费多少。这四本账里,只有第一本是参数表上写着的,剩下三本全是运行时才暴露的。这篇文章想干的事很明确:把 OOM 的成因拆到能算、能测、能改的程度,然后针对一人公司或者独立开发者这种"预算有限、没人帮忙、机器就一台"的场景,给出一套低成本的选型和优化路线。不管你是刚拿到模型权重的新手,还是已经踩过几次坑、想弄清楚到底该把钱花在哪儿的老手,下面这些内容应该都能直接拿去用。
1. 显存爆掉不是"内存不够",是四本账没对上
大部分人排查 OOM 的方式是看任务管理器里那个显存占用条,然后发现"才用了 80% 就爆了"。这个观察其实很关键,它说明你爆的不是总量,是连续可用的块不够。要把这件事讲清楚,得把显存占用拆成互不重叠的四块来看,每一块的成因和应对手段完全不同,混在一起讨论只会越查越乱。
1.1 权重、激活、缓存、碎片:四本账分开记
第一本是模型权重常驻。这部分最好算,参数量乘以每个参数的字节数就是下限,比如一个 8B 量级的模型,用 16 位精度加载,光权重就接近 16GB,这是跑起来就固定占着、不会中途释放的部分。预览版模型经常同时挂载多个组件——主干网络、文本编码分支、编解码器——它们加起来才是真正的常驻底线,很多人只算了主干,剩下的忘了算。
第二本是激活值峰值。这是最容易被低估的一块。前向计算时,中间层的输出张量需要保留到用完为止,序列越长、批次越大、分辨率越高,激活值涨得越快。关键在于它是峰值而不是平均值,你看着显存曲线平稳在 60%,某一层突然冲上去就爆了,前面所有的平稳都没有意义。
第三本是缓存。如果模型带有自回归生成的部分,键值缓存会随序列长度线性增长;如果带有多步迭代的采样过程,中间状态也会累积。这部分的特点是"随输入变化",短提示词跑得好好的,一上长文本就崩,八成是这里。
第四本是碎片和框架自身开销。显卡上下文、框架的运行时、分配器的池化管理,通常要吃掉 0.5 到 1.5GB,这部分你优化不掉。更麻烦的是碎片:反复申请释放不同大小的张量之后,显存里会出现很多"看着空着但塞不进一个大块"的空洞。这时候总量明明够,分配还是会失败。
排查顺序建议反过来:先看碎片和缓存,再看激活,最后才怀疑权重。因为前三者是可以零成本优化的,权重只能靠量化或者换卡。
1.2 预览版模型为什么比正式版更容易踩线
"Preview"这个后缀不是随便加的。从我接触过的几类预览版权重来看,它们通常有几个共同特征:第一,附带完整的训练侧配置或者多套推理路径,默认加载的组件比实际需要的多;第二,为了展示效果,默认分辨率、默认步数、默认精度都调得比较高,没有针对消费级硬件做保守设定;第三,文档和示例代码往往假设你在数据中心级别的卡上跑,那些默认参数放到一张 24G 的卡上就是灾难。
还有一层原因是工程封装不完整。正式版发布时,作者通常会把分块、卸载、低精度路径都打磨好,预览版可能只留了一个"能跑通"的最小实现。你得自己去补这些优化,而不能指望开箱即用。这也是为什么同一份权重,有人报告"24G 随便跑",有人报告"48G 都爆"——差别往往不在硬件,在谁先动手把那些默认值改掉了。
我在一台消费级卡上做过对比:同一个预览版权重,用示例脚本的默认参数跑,第一次前向就爆;把默认分辨率砍到原来的六成、把批次改成 1、把编解码器改成切片执行之后,同一张卡不仅能跑,还能留出接近三成的余量给并发。这个差距不是硬件带来的,是配置带来的。
1.3 用一条监控曲线找到爆点在第几步
不要靠猜。挂一个采样脚本,每隔几十毫秒记录一次已分配显存和保留显存,把整条曲线画出来,爆点位置一目了然。这里有个细节:要同时记录"已分配"和"保留"两个值,两者的差额就是分配器池子里没能利用上的部分,差额大说明是碎片问题,差额小说明是真不够。
import threading, time def watch(interval=0.05, stop_flag=None): while not stop_flag.is_set(): allocated = torch.cuda.memory_allocated() / 1024**3 reserved = torch.cuda.memory_reserved() / 1024**3 print(f"{time.time():.2f} alloc={allocated:.2f}G reserved={reserved:.2f}G") time.sleep(interval)把这段挂到推理主流程旁边,配合在关键节点打时间戳,就能看出峰值出现在加载阶段、编码阶段还是解码阶段。经验上,图像类模型的峰值经常出现在最后的解码还原那一步,语言类模型经常出现在长序列的注意力计算那一步——两者要用完全不同的手段去压。
2. 从参数量倒推显存:一张能自己填的表
会算账和不会算账的区别,在于你是在买卡之前就知道够不够,还是买回来跑一遍才知道。下面这套算法不需要多精确,误差控制在两成以内就足够做决策了,因为选型本来就要留余量。
2.1 四个乘数:字节数、激活系数、序列长度、安全余量
权重的算法很直接:参数量 × 每参数字节数。16 位精度是 2 字节,8 位是 1 字节,4 位是 0.5 字节,再加上量化时的一些额外开销(缩放因子、零点),实际会比理论值高 5% 到 10%。
激活值的算法要引入一个经验系数。对于常见的 Transformer 结构,单次前向的激活峰值大致可以用"隐层维度 × 序列长度 × 批次 × 层数 × 系数"来估,那个系数跟是否使用重计算、是否分块注意力强相关。我的做法是先用一个已知能跑通的小配置测出实际峰值,再按线性关系外推——序列长度翻倍,激活大致翻倍;批次翻倍,激活也大致翻倍。这个外推在小范围内相当准。
序列长度这块要特别注意:注意力的计算量是长度的平方级,虽然显存占用主要是线性的,但在长上下文场景下,缓存的增长速度会让人措手不及。一个简单的判断是,如果你的输入长度从 2K 涨到 32K,缓存部分至少涨 16 倍。
安全余量我会留 15% 到 20%。这个数字看起来保守,但你要考虑到系统里还有其他进程可能占用显卡、驱动本身的开销会浮动、以及长时间运行之后的碎片累积。
2.2 手算案例:同一个模型在三种精度下的账
拿一个 8B 量级、隐层 4096、32 层的模型举例,输入长度 4096、批次 1,跑纯推理场景:
| 项目 | 16 位精度 | 8 位精度 | 4 位精度 |
|---|---|---|---|
| 权重常驻 | 约 16.0 GB | 约 8.4 GB | 约 4.6 GB |
| 激活峰值(估算) | 约 3.2 GB | 约 1.8 GB | 约 1.8 GB |
| 键值缓存 | 约 2.1 GB | 约 1.1 GB | 约 1.1 GB |
| 框架与上下文开销 | 约 1.0 GB | 约 1.0 GB | 约 1.0 GB |
| 碎片冗余(15%) | 约 3.3 GB | 约 1.8 GB | 约 1.3 GB |
| 合计 | 约 25.6 GB | 约 14.1 GB | 约 9.8 GB |
这张表能解释一个非常常见的困惑:为什么标称 24G 的卡跑 8B 模型会爆。16 位精度下算出来是 25.6GB,刚好越过那条线,而且这只是单条请求、无并发的情况。一旦同时进来两条请求,激活和缓存都要翻倍,直接超出去七八个 G。
有意思的是从 16 位降到 8 位,总占用从 25.6 降到 14.1,降幅超过四成,而画质或者输出质量的损失通常小到肉眼难辨。这一步几乎是免费的午餐,应该作为第一优先级去做。再从 8 位降到 4 位,占用从 14.1 降到 9.8,收益明显变小了,而质量损失在细节纹理、小字、精细结构上会开始显现——这就是边际收益递减,选型的时候要清楚自己在为哪一段收益付代价。
2.3 参数表和真实占用差在哪里
厂商给的"推荐显存"和实际占用之间永远有落差,落差的来源主要是三块。一是多组件同时驻留:预览版模型可能同时加载了主干、编码器、解码器,而参数表只按主干算。二是默认配置激进:默认的批次数、默认的引导强度、默认的采样步数,都是按"效果最好"而不是"显存最省"来设的。三是峰值与均值的差异:参数表给的是一个静态数字,实际运行是一条波动的曲线,峰值可能是均值的 1.5 倍。
我的建议是把自己实测的峰值做成一张表,按"分辨率或序列长度"和"批次"两个维度记录,跑几次之后你就有了一张属于自己的显存地图。以后任何新需求进来,先查表判断能不能接,比临时试跑靠谱得多。对于一人公司来说,这张表就是你的产能上限说明书。
3. 不买新卡的前提下,把峰值砍下来的六个手段
换硬件永远是最后一步,因为它花钱且不可逆。在掏钱之前,先把软件层面的六个手段过一遍,绝大多数情况下能省下一台机器的预算。这六个手段的效果、代价和适用场景差别很大,我按"性价比从高到低"的顺序讲。
3.1 精度降级:从 16 位到 8 位再到 4 位
精度降级是投入产出比最高的一招,因为它改的只是一个加载参数,不改代码结构。但这里有几个坑必须说清楚。
第一,不是所有层都适合降。归一化层、位置编码相关的部分、以及最后输出的投影层,保持高精度往往能显著减少质量损失,而占大头的矩阵乘部分降到 8 位几乎没有感知。这种"混合精度"的做法比全局一刀切要好得多。
第二,量化方式影响稳定性。简单的按张量缩放,在激活值分布不均匀的时候容易出问题;分组量化能把误差压下去,代价是额外的元数据开销。4 位场景下分组几乎是必须的,不分组的话崩坏会很严重。
第三,质量损失要看你的交付形态。如果你做的是风格化、抽象化的输出,4 位完全够用;如果交付物需要精确的文字、细密的结构、准确的颜色过渡,那 8 位基本就是底线,4 位会在这些地方露出破绽。我一般会准备两套权重,日常批量走 4 位,客户确认稿或者高价值订单切回 8 位,这个切换成本很低,但对交付质量的帮助很大。
3.2 分块计算:把一次大峰值拆成多次小峰值
分块的核心思想是"不要一次处理整张图/整段序列,切成小块逐块处理再拼起来"。对于带解码还原环节的模型,这个手段效果极其明显,因为最终的还原步骤往往是整条流水线上显存峰值最高的地方,而它天然可以分块。
具体做法是把输出按空间切成长条或者小块,每块单独走一遍还原,然后拼回完整结果。代价是速度会慢一些,因为分块带来了额外的调度开销和边缘重叠,实测大概慢 15% 到 40%,取决于块的大小。块切得太小,速度损失大且接缝更明显;切得太大,峰值压不下去。我一般从"目标是把峰值降到当前的一半"倒推块尺寸,试两三个值就能找到平衡点。
同样的思路可以套到序列维度上:把长序列切段处理,段与段之间传递必要的状态。这个实现起来比空间分块复杂,因为要注意段间的上下文衔接,但如果你的瓶颈确实在长文本上,这是必选项。
3.3 批次和分辨率的平方级成本
批次数和分辨率是两个最容易被无脑调高的参数。批次从 1 调到 2,看起来只是"多跑一个",实际上激活和缓存都会翻倍,峰值直接乘二。分辨率更狠,因为它的影响是平方级的——宽高各翻一倍,像素量是四倍,显存占用大致也是四倍。
一人公司的典型场景是批量出图或者批量处理,很容易想"我把批次开大一点,吞吐上去了"。但真实情况是:批次开大之后单次耗时变长,峰值升高导致你必须留更多余量,最终的有效吞吐未必更高,反而更容易在某个输入上突然崩掉。我自己的经验是批次保持 1,用队列串行 + 多进程隔离的方式提升吞吐,稳定性比开大批次好得多——一个进程崩了不影响其他的,这在无人值守的场景下至关重要。
分辨率这块,我的建议是设一个"安全档"和一个"高质量档"。安全档保证任何输入都不会爆,用来跑批量和预览;高质量档需要人工触发、单条执行,用来出终稿。把这两档明确区分开,比试图找一个"既快又好"的中间值要靠谱。
3.4 分配器碎片:那个被忽略的 20%
很多 OOM 报告里的数字很诡异:已分配 15G,保留 20G,卡有 24G,却分配不出一个 4G 的块。这就是碎片。成因是推理过程中反复申请释放不同尺寸的张量,分配器的缓存池被切成了很多小块。
处理碎片有两个层面。第一个层面是让分配器的行为更聪明,主流框架都提供了可展开段的开关,开启之后分配器可以动态合并相邻的空闲段,对缓解碎片很有帮助:
# 变量名前缀随框架不同而不同,查一下你所使用框架的文档 export XXX_CUDA_ALLOC_CONF=expandable_segments:True第二个层面是从代码结构上减少碎片。常见做法包括:把大小固定的缓冲区提前分配好复用,避免在循环里反复创建同形状的张量;把不同尺寸的输入分桶,同样尺寸的请求攒在一起跑;在长驻服务里定期做一次"空载整理",也就是等队列清空后主动释放缓存再重新加载。
一个很实用的判断方法:如果同一份输入,第一次跑爆、重启之后跑又不爆,那基本可以确定是碎片或者残留状态的问题,而不是真不够。
3.5 组件卸载与流水线顺序
预览版模型经常是多组件的,比如编码器、主干、解码器依次工作。如果它们全部同时驻留在显存里,占用就是三者之和;但实际上它们的生命周期并不重叠。把用完之后暂时不用的组件挪到主内存,需要时再搬回来,能省下相当可观的常驻显存。
代价是搬运开销。一次搬运的时间取决于组件大小和总线带宽,对小模型可能只有几十毫秒,对大模型可能是几秒。所以要权衡:如果你的任务是低频的、单条的,搬运开销可以接受;如果是高频短任务,搬运反而会成为主要瓶颈。
还有一种更细的做法是流水线重排:把同一批次里所有请求的编码阶段攒在一起做完,再统一做主干,最后统一做解码。这样每个组件的加载卸载次数从"每请求一次"降到"每批次一次",摊薄了搬运成本。这个改动需要你稍微重构一下调用逻辑,但收益在多请求场景下非常明显。
3.6 六种手段的实测对比
把上面这些整理成一张表,方便你按自己的瓶颈对号入座:
| 手段 | 典型显存降幅 | 速度代价 | 质量影响 | 适用瓶颈 |
|---|---|---|---|---|
| 16 位降 8 位 | 35%–45% | 基本无损,部分硬件更快 | 极小 | 全局,首选 |
| 8 位降 4 位 | 25%–35% | 可能略慢 | 中等,细节可见 | 权重占大头时 |
| 输出分块还原 | 20%–50% | 慢 15%–40% | 极小,注意接缝 | 解码阶段峰值高 |
| 批次降到 1 | 30%–50% | 吞吐下降,可队列补偿 | 无 | 多请求并发时 |
| 分辨率降档 | 与像素量成正比 | 明显变快 | 明显,需分档管理 | 高分辨率输入 |
| 组件卸载 | 视组件大小,10%–40% | 慢,有搬运开销 | 无 | 多组件模型 |
| 碎片治理 | 10%–20% | 基本无损 | 无 | 总量够却分配失败 |
实际用的时候不要全上。全上的结果是速度慢到没法交付,而收益重叠严重。正确姿势是先按第 1 节的方法定位爆点在哪一段,然后只针对那一段上手段。比如爆在解码,就上分块;爆在权重常驻,就上量化;总量够但分配失败,就治碎片。
4. 一人公司的硬件账:三档预算怎么选
讲完优化,再讲花钱。一人公司或者独立开发者的选型逻辑跟团队完全不同:你没有备用机、没有运维、采购决策就你一个人拍板,而且现金流敏感。所以判断标准不是"哪张卡最强",而是"在我能承受的预算内,哪套方案能让我的业务连续跑下去"。
4.1 24G 消费级卡:够用与不够用的分界线
24G 是当前消费级的一个心理分水岭。它能干什么?经过量化之后的 8B 到 14B 级模型,单条请求、中等长度输入,跑得很舒服;图像类模型在中等分辨率、批次 1 的情况下,配合分块还原也能跑。它不能干什么?大分辨率批量生成、长上下文高并发、以及任何需要同时挂载多个大组件的场景。
我给这条线的判断标准很朴素:如果你的日常工作流里有超过三成的任务需要"降档"才能跑,那这张卡对你就是不够的。因为降档意味着你在用质量换可行性,长期下来会侵蚀你的交付水平。相反,如果八成以上的任务在满档下能跑,剩下两成偶尔降档,那这张卡就是合适的,剩下的钱应该花在别的地方。
还有一点常被忽略:消费级卡的显存是固定的,不能扩。这意味着你的业务上限被硬锁死了。如果你的业务在增长,今天够用的卡明年可能就不够了。所以在预算允许的情况下,宁可往上买一档,也不要买一个"刚好够"的配置。
4.2 大显存老卡与统一内存方案的真实体验
预算有限的时候,很多人会考虑两条替代路线:一是上大显存的老架构卡,二是用统一内存的方案(显卡和主内存共享地址空间)。
老架构卡的优势是显存大、单价低,缺点是算力相对落后、功耗高、驱动支持可能不完整。我实际的感受是:它对"能跑起来"帮助很大,对"跑得快"帮助有限。如果你的瓶颈是显存容量而不是速度,比如你要跑大分辨率或者多组件同时驻留,这条路是合理的;如果你追求吞吐,那它可能让你失望。另外要注意散热和电源,老卡功耗不低,机箱和电源可能要一起换,这笔钱别忘了算进预算。
统一内存方案的优势是容量可以做得非常大,用主内存来补显存,成本按每 G 算下来很低。缺点是带宽差距悬殊,一旦发生换页,速度会掉一个数量级。我的经验是:它适合"偶尔跑一次大任务"的场景,不适合"持续高负载"。用一个类比,它像是把仓库建在郊区,容量随便扩,但每次取货都要开很久的车。如果你的业务是每天跑几十个任务的批量处理,这个延迟累积起来会很难受。
4.3 云上按需 vs 自购:把成本算成月成本
这是最需要算清楚的一笔账。自购的成本不只是卡钱,还有整机、电源、散热、电费、折旧、以及你自己的维护时间。云上的成本是按时计费,看起来单价高,但没有前期投入。
粗算的方式是:把自购总价除以 24 个月(一个合理的折旧周期),加上每月电费(按满载功率 × 每天运行小时 × 电价),得到月成本。云上则按"每月实际使用小时 × 每小时单价"算。两边一比,分界点通常在每月有效使用时长上。
| 每月有效使用时长 | 倾向方案 | 理由 |
|---|---|---|
| 低于 60 小时 | 云上按需 | 闲置成本为零,前期投入为零 |
| 60–150 小时 | 看情况 | 取决于是否需要长期驻留服务 |
| 高于 150 小时 | 自购 | 摊销后单价明显更低 |
这里有个容易被忽略的变量:启动开销。云上按需实例从申请到能跑,往往要几分钟,还要重新加载权重。如果你的业务是"客户随时可能下单、要求几分钟内出结果",那按需实例的冷启动时间就是硬伤,你得考虑常驻实例,成本立刻上一个台阶。反过来,如果你的业务是"每天固定时段集中处理",那按需非常合适,甚至可以挑价格更低的时段。
4.4 一张决策表和三条例外
把上面的逻辑压缩成一张决策表:
| 你的情况 | 建议起点 |
|---|---|
| 刚起步,需求不确定,月任务量小 | 云上按需,先验证业务模型 |
| 需求稳定,每天固定批量任务 | 24G 级消费卡整机,自建 |
| 单任务显存需求超出 24G 一档 | 大显存方案或云上高配按需 |
| 需要 7×24 常驻对外服务 | 自建为主,云上做峰值溢出 |
| 交付物质量要求极高 | 优先保证精度档位,容量其次 |
三条例外值得单独说。第一条,不要把全部预算压在显卡上。存储、内存、电源、备份,任何一项拖后腿都会让你的整体体验崩掉,尤其是存储——模型权重的读写量很大,机械盘会让加载时间翻几倍。第二条,留出一台备用机的预算或者至少留出迁移方案。一人公司最怕的是唯一的机器挂了,业务直接停摆,云上按需实例在这里是最好的保险。第三条,先租后买。任何方案在真正跑起你的真实工作流之前都是猜测,先用云上按需跑一周,把你的真实显存曲线和耗时数据拿到手,再决定买什么,这一周的租金远比买错一张卡便宜。
5. 能跑起来之后,怎么让它不半夜挂掉
优化做完、机器买好,事情只完成了一半。一人公司没有值班的人,服务半夜挂掉可能要等到第二天客户投诉才知道。稳定性的建设不需要很复杂,但必须做。
5.1 队列、超时与优雅降级
第一个要加的是队列。所有请求先进队列,由固定数量的工作进程串行消费,而不是来一个起一个。这么做有三个好处:显存占用可预测、避免并发峰值叠加、出问题的时候能定位到具体是哪条任务。
第二个是超时。每条任务设一个硬性超时,超时直接杀掉进程并重新拉起。不要试图在超时之后"优雅地恢复现场",在显存已经被污染的情况下,重启进程是最干净的做法。进程隔离在这里是刚需——每个工作进程独立,一个崩了不影响其他的。
第三个是优雅降级。当显存水位超过阈值,或者排队长度超过阈值,系统应该自动切到低一档的配置:降分辨率、降步数、降精度,而不是硬撑着跑然后崩掉。降级的结果可能不是最优,但比没有结果强。我一般会设两级降级,到了第二级还不行就直接给用户返回"当前繁忙,请稍后重试",明确告知比默默失败要好。
def pick_profile(free_ratio: float, queue_len: int) -> str: if free_ratio > 0.35 and queue_len < 5: return "high" if free_ratio > 0.18: return "standard" return "safe" # 最低档,保证能出结果5.2 显存水位监控与自动重启
监控不复杂,每隔几秒采样一次已分配和保留显存,记录到日志里。关键是要有阈值告警和自动处置。我的做法是设两条线:软线(比如 85%)触发降级,硬线(比如 95%)触发进程重启。重启要选在任务间隙,不能在任务执行中重启。
还有一个容易被忽略的指标是碎片率,也就是保留减去分配,再除以保留。这个值长期高于 25%,说明你的进程已经处于亚健康状态,即使当前没爆,下一次大输入大概率会爆。这时候主动重启一下,比等着它崩要好。
日志里我会固定记录这几个字段:时间戳、任务 ID、输入尺寸、使用档位、峰值已分配、峰值保留、耗时、是否成功。跑上两周,你就能看出规律——比如某个尺寸区间的失败率明显偏高,那就在入口处直接把它引导到低一档。
5.3 交付边界:把"预览版"的不确定性写进产品
最后一点偏业务。你在用一个预览版模型做交付,这件事本身就有不确定性:模型可能随时更新、行为可能变化、某些输入可能产生意料之外的输出。一人公司的信誉很脆弱,一次严重的事故可能就丢掉一个客户。
我的建议是把这些不确定性前置到产品设计里。比如在交付说明里明确标注"生成类内容存在随机性,如需精确复现请以确认稿为准";比如对高价值订单强制走人工复核环节;比如保留每个订单的完整参数记录,出问题能追溯。这些做法看起来是给自己加负担,实际上是在保护你的现金流。
技术上还有一个配套动作:固定版本。把当前能跑通的模型权重、配置文件、框架版本全部归档一份,不要依赖"最新版"。预览版的下一个版本随时可能改变显存需求或者输出行为,你今天的调优成果可能明天就失效。归档一份能跑的,是给自己留的后路。
我个人在实际操作中的体会是,显存 OOM 这件事之所以让人焦虑,是因为它看起来像个玄学——同一个脚本,昨天能跑今天不能跑。但只要把四本账拆开、把峰值测出来、把手段按瓶颈对号入座,它立刻变成一个可以计算的工程问题。真正难的从来不是技术,是在预算有限的情况下忍住"直接换张更大的卡"的冲动,先把免费的优化吃干净。我见过太多人跳过这一步,结果新卡到手,问题只是从"爆在解码"变成了"爆在并发"。
如果只让我留一条建议:先花半天时间把你自己的显存曲线测出来,做成一张表。这张表的价值远超任何一篇选型文章,因为它记录的是你的真实工作流,而不是别人的平均值。