ARTICLE DETAIL

资讯详情

深耕网站建设、视觉设计与SEO优化的一线实战洞察。

显存OOM四本账:Step 5 Preview本地部署优化与选型

显存OOM四本账:Step 5 Preview本地部署优化与选型

显存爆掉的那一刻,屏幕上通常只有一行干巴巴的报错:试图分配多少字节失败,已分配多少、保留多少。很多人第一反应是"参数表上写着这卡能跑啊",然后开始怀疑驱动、怀疑框架、怀疑人生。我见过太多人在这一步直接把机器换掉,结果新卡到手,跑同样的 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%极小,注意接缝解码阶段峰值高
批次降到 130%–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 这件事之所以让人焦虑,是因为它看起来像个玄学——同一个脚本,昨天能跑今天不能跑。但只要把四本账拆开、把峰值测出来、把手段按瓶颈对号入座,它立刻变成一个可以计算的工程问题。真正难的从来不是技术,是在预算有限的情况下忍住"直接换张更大的卡"的冲动,先把免费的优化吃干净。我见过太多人跳过这一步,结果新卡到手,问题只是从"爆在解码"变成了"爆在并发"。

如果只让我留一条建议:先花半天时间把你自己的显存曲线测出来,做成一张表。这张表的价值远超任何一篇选型文章,因为它记录的是你的真实工作流,而不是别人的平均值。

返回列表