会议实时字幕的第一版,是等一句话说完再送去识别。用户说完「我们下周把方案定一下」,屏幕上要过两三秒才出现整句,讲得快的人已经说到下一句。改成边说边出字以后,延迟下来了,新的抱怨也来了:屏幕上先出现「今天」,半秒后变成「今年」,再后来才改回「今天」,用户盯着字幕反而不知道哪句是准的。

这两个现象看起来相反,其实是同一笔账的两端。等整句,模型能看到完整的未来上下文,结果稳,但慢;边说边出,模型只能看到过去和一小段未来,出字快,但证据不足,假设会反复改。流式识别不是把离线模型切成小块那么简单,它要重新分配「看多少未来」和「多早给结果」。

这篇把流式的几个关键点拆开:块怎么切、左右上下文各留多少、延迟由哪几段组成、端点检测为什么会误切、partial 和 final 怎么区分,以及这些要求如何反过来限制模型结构。最后用一段纯 Python 模拟,把十个 100 毫秒块的到达时间和出字时间算清楚。

流式难在哪:未来还没发生

离线识别可以看完整段音频再决定。编码器用双向上下文,注意力可以回看整句,CMVN 用整句统计量,语言模型也能利用后文。流式没有这个条件:音频一帧一帧到达,模型只能看到已到达的部分,最多再等一小段未来。它必须在证据不全时决定。

这意味着三件事同时变难。第一,模型不能依赖未来的帧,双向结构、全句注意力、整句归一化都要换掉。第二,计算要增量做,不能每来一小块就重算整段,否则算力随音频长度线性增长。第三,结果要分阶段给:先给可能还会改的 partial,证据够了再给 final,切换越频繁体验越差。

流式识别的一次处理循环
音频按块到达
更新特征与缓存
编码当前块与左上下文
等待右上下文
解码出 partial
端点确认后给 final

所以流式的核心不是「快」,而是「在有限的未来里,尽量给出稳定的结果」。块大小、右上下文、端点策略、提交策略,都是在这件事上做取舍。任何一个参数调过头,都会在延迟或稳定性上表现出来。

分块:块大小、左上下文与右上下文

流式系统通常把音频切成固定大小的块,比如每 100 毫秒处理一次。块大小决定了两件事:一是等待时间,因为一块音频要攒够才能开始算;二是模型一次能看到的范围,块越大,单次上下文越多,结果越稳,但首字延迟也越大。

左上下文是已经处理过的音频缓存。处理当前块时,把最近若干帧的历史状态或特征带进来,避免每块从零开始。左上下文越长,越能利用句子前半段,但缓存和计算也越大。很多流式模型只保留固定长度,比如几秒,超出就截断。

右上下文是当前块之后额外等待的一小段未来音频,也叫 lookahead。它不改变「已经到达」的事实,只是让模型晚一点做决定。右上下文越长,当前块的边界越清楚,声学证据越完整,结果越稳;代价是首字延迟直接增加同样的时长。块大小和右上下文是流式延迟账里最大的两项。

还有一个容易忽略的细节是块边界。特征在块边界处如果重新做 CMVN,前后两块的统计量不同,同一句话的特征会跳;卷积或注意力的感受野跨过边界时,如果每一块都从零算,边界附近的输出会和离线不一致。正确做法是把状态缓存下来,让边界处的计算和离线尽量等价。

延迟账:首字、尾字和那些没算进去的部分

用户感知的延迟不是一个数字,至少有两个:首字延迟,从用户开口到屏幕上出现第一个字;尾字延迟,从用户说完到最后一个字定稿。首字延迟决定「跟不跟得上」,尾字延迟决定「一句话什么时候能拿去用」。

首字延迟可以拆成几段:音频从设备到服务端的传输时间,攒够一个块的时间,等待右上下文的时间,模型计算的时间,结果传回客户端的时间,以及界面渲染的时间。任何一段被忽略,估算都会偏乐观。只算模型计算,常常会得出「几十毫秒就能出字」的结论,实际用户看到的是几百毫秒甚至更久。

尾字延迟多了一项端点确认。系统要判断用户是不是说完了,通常会等一段静音,确认没有后续语音,才把最后一块送去 final。这段等待是必要的,否则用户只是停顿换气,系统就把半句话定稿了。等待越长,尾字越稳,但一句话的完成时间越晚。

实时率,常写成 RTF,是处理耗时和音频时长的比值。小于一表示比实时快,大于一表示处理不过来。它适合衡量吞吐,但不能直接当延迟:RTF 再低,如果每次都要等一大块音频,首字延迟仍然很高。本机没有真实设备和网络条件,本节涉及的设备、网络、渲染耗时都未在本机实测,下面的模拟只算音频到达和计算。

端点检测:静音阈值与误切

端点检测,简称 VAD,在流式里承担两个角色:决定什么时候开始识别,决定什么时候可以 final。它通常看短时能量、过零率,或者用一个小模型判断当前帧是人声还是非人声。

最简单的能量阈值有两个毛病。阈值太高,开头的轻声、结尾的弱音会被判成静音,第一个字直接消失;阈值太低,空调、键盘、呼吸都会被当成人声。工程上常用双阈值:超过高阈值才开始,低于低阈值并持续一段时间才结束,中间区间靠状态机维持。

等待时间也很关键。开始时的确认帧数太少,一个短促的噪声就能触发识别;太多,用户已经说了半个字,系统还没开始。结束时的等待太短,句子中间的换气会被当成说完;太长,用户说完要等很久才看到 final。这个参数没有通用最优值,和场景、语速、噪声水平都有关。

误切是流式特有的错误。离线识别拿到的是完整音频,切不切只影响首尾;流式在说话过程中就可能把一段切成两段,前半句送进 final,后半句重新开始,上下文断了,代词、专有名词、语气都会错。更糟的是,切点附近的特征和状态被重置,模型看不到跨切点的依赖。

不要把 VAD 的结束判断和业务上的「一句话结束」混为一谈。用户停顿换气不等于说完了;业务上可能还要等标点、等语义完整。流式系统可以让 VAD 先给一个临时端点,但 final 的提交策略要单独设计,否则会出现半句话被定稿、后半句另起一行的情况。

partial 与 final:字为什么会跳

流式识别通常会给两类结果。partial 是还没定稿的假设,随着新音频到达不断更新;final 是确认后的结果,一般不再改。用户看到的跳变,几乎都发生在 partial 上:前一时刻证据支持「今天」,后一时刻更强的证据支持「今年」,界面就跟着改。

跳变有三个来源。第一是声学证据本身在变,开头的辅音还没说完,模型只能猜,后面听到更多帧,猜测自然改变。第二是 beam 竞争,多个候选分数接近,新来一块音频就可能让排名翻转。第三是语言模型和后处理,它们会在不同阶段给出不同的修正。

减少跳变的办法不是「不许改」,而是控制什么时候改、改多少。常见策略是只提交高置信度的前缀:一段文本连续几次更新都不变,才提升为稳定部分;后面的字仍可改,已提交的不动。另一种是延迟提交,等右上下文或整句结束后再定稿,用延迟换稳定。

界面也要配合。很多产品把 partial 显示成浅色或带光标,final 显示成正常颜色,用户能看出哪部分还可能变。把 partial 当 final 直接落库、直接翻译、直接发给下游,是流式系统里最常见的工程错误:下游拿到的是半成品,后面再改已经来不及。

重打分也要分阶段。partial 阶段用轻量模型,保证速度;final 阶段可以用更大的语言模型或声学模型重新打分,提升准确率。代价是 final 更慢,所以重打分通常只对已经稳定的片段做,或者等一句话结束后再做。把所有重打分都放到 partial 上,延迟会立刻爆掉。

流式对模型结构的约束

离线模型的结构不能直接拿来流式用,最明显的是双向结构。双向循环网络或全句注意力需要看到后面的帧,流式没有这些帧,只能改成单向。单向意味着模型只能利用历史,表达能力下降,所以要用更大的左上下文来补。

卷积也有类似问题。普通卷积的感受野会跨到未来,流式要用因果卷积,也就是第 t 帧只依赖 t 及之前的帧。因果卷积可以通过增加膨胀率扩大感受野,但感受野再大,也看不到未来。需要未来信息时,只能显式地等右上下文,也就是 lookahead。

注意力在流式里要加约束。全句注意力会让每个输出看所有帧,流式只能看已经到达的帧;单调注意力进一步要求权重随时间向前推进,避免来回跳。分块注意力把音频切成段,段内看全段,段间靠状态传递,是折中的做法。

状态缓存是流式的另一条命脉。每次处理新块时,把之前的隐状态、卷积缓存、注意力缓存带进来,否则每块从零开始,结果不连续,计算也重复。缓存要有上限,常见做法是保留固定长度的左上下文,超出部分丢弃或压缩。

这些约束最终会反映到训练上。流式模型通常要用「分块训练」模拟推理时的切块方式,让训练和推理看到同样的上下文长度;如果训练时看整句、推理时看一块,模型在边界处的行为会不一致。训练时的右上下文、块大小、缓存策略,都要和线上一致。

本机跑一遍:10 个 100 毫秒块的到达时间线

下面这段程序只用 Python 标准库。它模拟十块 100 毫秒的音频,分别按 100、250、500 毫秒的块大小处理,右上下文取 0、100、200 毫秒,每块计算耗时设为 15 毫秒。程序打印每块的产出时间、首字延迟和完成时间。15 毫秒是为了便于算账而设的假设值,不是任何真实设备的实测数据。

BLOCK = 100
BLOCKS = 10
TOTAL = BLOCK * BLOCKS
COMPUTE = 15   # 每个块的处理耗时(ms)


def simulate(chunk, right_context):
    n_chunks = TOTAL // chunk
    lookahead = right_context // chunk if right_context % chunk == 0 else right_context // chunk + 1
    arrivals = [(i + 1) * chunk for i in range(n_chunks)]
    finish = []
    prev = 0
    for a in arrivals:
        start = max(a, prev)
        prev = start + COMPUTE
        finish.append(prev)

    emit = []
    for i in range(n_chunks):
        j = i + lookahead
        if j < n_chunks:
            emit.append(finish[j])
        else:
            emit.append(TOTAL + COMPUTE * (j - n_chunks + 2))
    first = emit[0] - 0
    done = max(emit)
    return n_chunks, lookahead, emit, first, done


print("音频总长:", TOTAL, "ms,基础块:", BLOCK, "ms,每块处理:", COMPUTE, "ms")
for chunk in (100, 250, 500):
    for rc in (0, 100, 200):
        n, la, emit, first, done = simulate(chunk, rc)
        print(f"块={chunk}ms 右上下文={rc}ms 块数={n} 前瞻={la} 首字={first}ms 完成={done}ms 产出={emit}")
音频总长: 1000 ms,基础块: 100 ms,每块处理: 15 ms
块=100ms 右上下文=0ms 块数=10 前瞻=0 首字=115ms 完成=1015ms 产出=[115, 215, 315, 415, 515, 615, 715, 815, 915, 1015]
块=100ms 右上下文=100ms 块数=10 前瞻=1 首字=215ms 完成=1030ms 产出=[215, 315, 415, 515, 615, 715, 815, 915, 1015, 1030]
块=100ms 右上下文=200ms 块数=10 前瞻=2 首字=315ms 完成=1045ms 产出=[315, 415, 515, 615, 715, 815, 915, 1015, 1030, 1045]
块=250ms 右上下文=0ms 块数=4 前瞻=0 首字=265ms 完成=1015ms 产出=[265, 515, 765, 1015]
块=250ms 右上下文=100ms 块数=4 前瞻=1 首字=515ms 完成=1030ms 产出=[515, 765, 1015, 1030]
块=250ms 右上下文=200ms 块数=4 前瞻=1 首字=515ms 完成=1030ms 产出=[515, 765, 1015, 1030]
块=500ms 右上下文=0ms 块数=2 前瞻=0 首字=515ms 完成=1015ms 产出=[515, 1015]
块=500ms 右上下文=100ms 块数=2 前瞻=1 首字=1015ms 完成=1030ms 产出=[1015, 1030]
块=500ms 右上下文=200ms 块数=2 前瞻=1 首字=1015ms 完成=1030ms 产出=[1015, 1030]

先看 100 毫秒块、右上下文为零的那一行。第一块音频在第 100 毫秒到达,计算 15 毫秒,所以第一个结果出现在 115 毫秒;之后每块间隔 100 毫秒,产出时间就是 115、215、315,一直到 1015。首字延迟是 115 毫秒,完成时间是 1015 毫秒。这个数只包含音频到达和计算,不含设备、网络、渲染。

把右上下文加到 100 毫秒,第一块要等第二块到达才能定稿,所以首字推到 215 毫秒;最后一块没有足够的未来,在 1030 毫秒补齐。右上下文 200 毫秒更明显,首字 315 毫秒,尾部要补到 1045 毫秒。每多等一个块,首字就多 100 毫秒,这笔账非常直接。

块变大,首字也被拉长。250 毫秒块、无右上下文,第一块在 250 毫秒到达,加 15 毫秒计算,首字 265 毫秒;500 毫秒块则是 515 毫秒。块越大,单次看到的音频越多,结果可能更稳,但用户等待的时间也成倍增加。500 毫秒块再加 100 毫秒右上下文,首字到了 1015 毫秒,已经超过一秒。

最后要注意,完成时间并不等于最后一块的产出时间。右上下文和尾部补齐会让 final 延后,程序里的 1030、1045 就是这部分。真实系统还要加端点等待、重打分和网络传输,用户看到的尾字延迟通常更大。这个模拟只用来理解各项关系,不能当成线上延迟的承诺。

出了问题先看哪里

现象真实原因第一步查什么
首字迟迟不出等整句,或右上下文设得太大打印块到达、编码完成、首字时间三列
字幕反复跳变partial 提交太早,稳定策略缺失记录每次 partial 的变更位置与置信度
句尾迟迟不 finalVAD 结束等待太长,或重打分排队看 VAD 结束时间与 final 生成时间
首字被切掉VAD 起始阈值过高,缺少预卷调低阈值或保留起点前一小段音频
噪声触发识别VAD 阈值过低,或双阈值区间太窄统计误触发段的能量,调高起始阈值
流式比离线差很多右上下文不足,或 CMVN 统计不一致对齐两边参数,逐步增加 lookahead 做对比
长句内存一直涨左上下文缓存无界限制缓存长度,检查状态裁剪逻辑
多线程结果乱序块编号丢失,过期 partial 覆盖新结果按块序号合并,丢弃过期结果

排查顺序建议从时间线开始。把每一块的到达时间、处理完成时间、产出时间、final 时间画在同一条轴上,很多问题一眼就能看出来:是等块等太久,还是计算太慢,还是端点没确认。只看最终文本,永远分不清延迟来自哪一段。

边界与代价

低延迟和准确率在流式里是直接冲突的。多等一段未来,结果更稳;少等,出字更快但更容易改。没有一个配置能同时满足所有场景,会议字幕可以接受几百毫秒的首字延迟,语音助手可能要求更短;同声传译对延迟最敏感,宁可牺牲一部分准确率。

端点误切也无法完全消除。用户会停顿、会换气、会被噪声打断,任何阈值都有误判。能做的只是把误判的代价降下来:保留预卷音频、允许用户编辑、把 final 设计成可修正,而不是一锤定音。

partial 的抖动也不是纯粹的 bug。它是模型在信息不足时的正常表现,完全消除抖动通常意味着把结果压后,等于用延迟换稳定。产品设计要把这部分讲清楚:哪些字已经稳定,哪些还在变,用户才能决定什么时候复制、什么时候翻译。

设备、网络、并发是另一层边界。端侧算力有限,云端要处理多路并发,网络还有抖动和丢包。本文的模拟只算音频到达和固定计算耗时,这些延迟都未在本机实测。上线前要在目标设备和网络上量,不能拿实验室数字做承诺。

当天能验证的练习

  1. 把模拟里的每块计算耗时改成 5 毫秒和 30 毫秒,记录首字与完成时间的变化,理解计算占比。
  2. 固定 100 毫秒块,把右上下文从 200 改成 0,比较首字延迟和模拟出的结果稳定性差异。
  3. 录一句话,在中间人为插入 300 毫秒静音,调整 VAD 结束等待时间,观察是否被误切成两句。
  4. 对同一段音频,分别用 100 毫秒和 500 毫秒块跑,统计 partial 文本的变更次数。
  5. 记录从音频结束到 final 的时间,拆成 VAD 等待、计算、渲染三段,确认哪一段占得最多。

识别把声音变成文字,下一步是把文字再变回声音。语音合成同样有一条链路:文本前端、声学模型、声码器,每一步都有自己的延迟和边界;流式合成还要在早点出声和声音自然之间取舍。下一篇讲语音合成的完整链路,从文本归一化到声码器。