Meetly
Engineering2026年11月21日11 min read

Meetly Auto Engine(二):说话人识别与声纹记忆

Meetly 如何在 iPhone 上转写长录音而不丢进度、过滤空录音、标注谁在说话,并在不靠猜测的前提下认出已保存的声音。

Meetly 在 iPhone 上以可恢复的分块转写长录音,提前过滤空录音,并用开源 pyannote 模型标注说话人。拿不准时宁可不标,只有恰好一个已存声音匹配时才命名。在 16 场 AMI 会议上,81 个已录入说话人全部识别正确,1,725 次冒认测试无一通过。

Inside Meetly Auto Engine. One audio file in. A tagged transcript out.

引言

在第一篇中,Meetly Auto Engine 在 iPhone 上听了一遍录音,用语言对规则判断出语种,并把录音路由给专为该语言打造的语音模型。本篇接着跟随录音走完剩下的设备端工作:能扛住中断的转写、判断是否值得继续处理的早期过滤,以及给每一行配上名字的说话人标注和声纹记忆。

贯穿这四个阶段的主线是:引擎拿不准时,就少做,而不是多做。

背景:从选定模型到标出说话人

第一篇结束时,引擎已经知道该运行哪个模型。转写稿可以阅读之前还剩四个阶段,全部在手机上运行、无需联网:分块转写、早期过滤、说话人标注和声纹记忆。第一篇的图 1 展示了它们所处的位置,而且每个阶段都能从检查点恢复。

问题:长音频、空录音和叫错的名字

这四个阶段各有各的失败方式,而每一种失败都会直接暴露在阅读转写稿的人面前。下面四个挑战决定了整体设计,后文每一节回答其中一个,顺序与语音模型选定并加载之后引擎遇到它们的顺序一致。

  1. iOS 会挂起后台 App。一段 90 分钟的录音如果每次被打断都从零开始,就永远转写不完。
  2. 并非每段录音都值得走昂贵的阶段。说话人处理和摘要不该浪费在隔壁房间的电视声上。
  3. 两个模型必须就每个词是谁说的达成一致。把说话人话轮和词对齐,正是大多数肉眼可见错误的来源。
  4. 名字标错比不标更糟。如果 App 把 Daniel 说的话记在 Priya 名下,你就再也不会相信任何一个标签。

以可恢复的分块转写长录音

目标是让一次中断只损失几秒,而不是整个任务。引擎先以 20 毫秒为一帧对音频做一遍能量分析,然后大约每五分钟规划一个切点,落在每个标记点之前 30 秒内最安静的那一帧上。之后,每个分块单独转写、单独保存。

在停顿处切分,不把词切断

MeetlyCore/TranscriptionChunking.swiftswift
let firstFrame = earliest / frameSamples
let lastFrame = min(latest / frameSamples, frameEnergies.count - 1)
var cut = latest
if firstFrame <= lastFrame, firstFrame < frameEnergies.count {
    var quietest = firstFrame
    for frame in firstFrame...lastFrame where frameEnergies[frame] <= frameEnergies[quietest] { quietest = frame }
    // Cut in the middle of the quietest frame.
    cut = min(max(quietest * frameSamples + frameSamples / 2, earliest), latest)
}
chunks.append(.init(index: chunks.count, startSample: start, endSample: cut))
start = cut

在停顿处切分,意味着不会有词被切成两半;Parakeet 还会把解码器状态从一个分块延续到下一个,所以转写稿里看不出拼接的痕迹。

分块落盘,中断只损失几秒

每个完成的分块单独存成一个文件,以内容摘要(digest)命名,读回时会做校验。App 重新启动后,任务会找到相同的音频哈希,跳过所有已保存的分块,只重做中断时正在处理的那一块。

发热和中断一样处理

处理每个分块前,引擎都会读取设备的热状态:手机发热时降为单个工作线程,进入临界状态时暂停 60 秒。在后台运行时,它会规划 45 秒的分块,以便在 iOS 允许的时间内干净利落地停下来。图 1 展示了这样处理后在手机上的速度。

iPhone 14 Pro Max 上的转写耗时柱状图:19 分钟音频用时 21.6 秒,33 分钟用时 49.9 秒,87 分钟用时 176.6 秒。
图 1:在 iPhone 14 Pro Max 上大约比实时快 30 到 54 倍。实际使用中,时长中位数为 11.4 分钟的对话,转写耗时 26.3 秒(遥测)。

早期过滤:保留、待复核还是归档

文字一出来,在说话人标注和摘要之前,引擎就先判断这段录音值不值得继续处理。结论是保留、待复核或归档三者之一,并附上一句用户看得懂的理由。规则先做判断,只有规则无法下结论时才启用可选的模型检查,而判定的效果取决于录音类型。

先用确定性规则拦下空录音

MeetlyCore/MeetlyAutoEngine.swiftswift
public static func ruleVerdict(duration: Double, lines: [String], now: Date = Date()) -> Verdict? {
    let text = lines.map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }.filter { !$0.isEmpty }
    if text.isEmpty { return Verdict(decision: .archive, reason: "No speech found", source: .rule, date: now) }
    if duration.isFinite, duration > 0, duration < minimumSeconds {
        return Verdict(decision: .archive, reason: underTenSeconds, source: .rule, date: now)
    }
    let assessment = TranscriptQualityGate.assess(lines: text.map { .init(text: $0) }, duration: duration)
    guard assessment.hasNoMeaningfulContent else { return nil }
    let reason = switch assessment.reason {
    case .repetitive: "Repeated sounds"
    case .empty: "No speech found"
    default: "No real words"
    }
    return Verdict(decision: .archive, reason: reason, source: .rule, date: now)
}

这一判断背后的质量关卡是确定性的。它会去掉噪声标记,以及语音识别模型在静音时凭空“编”出来的句子,比如“thanks for watching”(感谢观看),并检测循环:某一行占到转写稿的 60%,或者不同的词不足总词数的四分之一。用拉丁字母书写的印地语、混合文字以及长篇多样的谈话,永远不会拿英语词典来评判。

可选的模型检查,失败时默认放行

如果规则无法下结论,而你又允许了云端处理,就会调用一次小模型来读取文本,它用一个词作答,并附上不超过十二个词的理由,上限 200 个 token。长转写稿不会整篇发送:只发开头、中间和结尾。这项检查失败时默认放行,所以没有授权、没有网络、请求超时或回答无法解析,结果都是保留。

MeetlyCore/Intelligence/MeaningCheck.swiftswift
/// The start, middle and end of the text, within maxCharacters.
public static func sample(_ lines: [String], limit: Int = maxCharacters) -> String {
    let text = lines.map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }.filter { !$0.isEmpty }.joined(separator: "\n")
    guard text.count > limit else { return text }
    let part = limit / 3
    let start = text.prefix(part)
    let middleStart = text.index(text.startIndex, offsetBy: (text.count - part) / 2)
    let middle = text[middleStart...].prefix(part)
    let end = text.suffix(part)
    return [String(start), String(middle), String(end)].joined(separator: "\n…\n")
}

“归档”只对片段生效

判定的效果取决于录音类型。归档会移除片段;而你自己开始录制的对话,除非明显是空的,否则只会被标记为待复核。你亲手点击“保留”或“归档”做出的决定,会以你为来源记录下来,引擎永远不会覆盖它。被归档的录音仍会保留,可以随时恢复。

MeetlyCore/MeetlyAutoEngine.swiftswift
/// What this verdict does to a recording of this kind: archive only archives a clip.
public func effective(for kind: Kind) -> Decision {
    decision == .archive && kind == .conversation && source != .you && !isClearlyEmpty ? .review : decision
}

说话人标注:谁在什么时候说话

说话人标注使用开源的 pyannote community-1 模型,转为 Core ML 后通过 FluidAudio 运行,共 22 MB,内置于 App。分割模型找出每个 10 秒窗口内谁在说话,嵌入模型把每个声音转成 256 个数字(即声纹),聚类再把声纹归并为不同的人。窗口间隔 1 秒,以捕捉简短的话轮。

8 人上限把不同的人混在了一起

这个库要求设定最大说话人数,我们原先设的是 8。超过上限时,它不会报告多出来的人,而是把所有人重新聚类成恰好 8 组。一场有 19 人参与的财报电话会议录音,结果只出来 8 个“人”,每个都是几个人的混合体。把这一个常量从 8 改为 32 就解决了问题,而在我们做回归检查的小型会议上,结果没有任何变化。

表 1 列出了这一改动影响最大的两段录音。对比最后两列:错误率下降了,归到正确说话人名下的词占比上升了。

录音人数识别出的人数,8 → 32错误率归到正确说话人名下的词
Earnings-21 Hershey198 → 1925.8% → 5.4%72.3% → 94.2%
Earnings-21 Monro108 → 935.0% → 6.3%62.7% → 93.5%
表 1:说话人分离错误率(DER)把漏检语音、误检语音和说话人混淆合计为语音时长的占比。Mac 主机,使用 App 自身的说话人代码。

长录音按 30 分钟窗口标注

超过 60 分钟的录音会在安静处切成约 30 分钟的窗口,每个窗口单独保存检查点;当两个窗口中说话人的声纹距离在 0.35 以内时,就把他们关联为同一人。在一场两小时的会议上,分窗口处理与单次处理的错误率一致,均为 20.3%,内存占用则从 1,016 MB 降到 857 MB(Mac 主机)。在 iPhone 14 Pro Max 上,对 19 到 87 分钟的音频,说话人标注耗时 41 到 238 秒(iPhone)。

宁可不标,也不乱标

不标注的一行是诚实的;被自信地归给错误说话人的一行,则是读者看不出来的错误。所以引擎用明确的阈值把词和说话人对应起来;当一个词或一小组词不能明确归属某个人时,就让它们保持未标注,而不是随便挑一个。

只有覆盖充分时,词才归属某个说话人

只有当某个说话人的话轮覆盖一个词至少 30% 的时长,且胜出者占据覆盖时长的至少 60% 时,这个词才归属于该说话人。时长不足 0.3 秒、被归给别人的单个词会被视为抖动,直接忽略。

零散说话人只在匹配明确时才合并

聚类经常产生一个零散的小组:四十来个词,大部分其实属于某个真实的说话人,却显示成一个神秘的“说话人 5”。一个不足 60 个词、且占录音不到 1% 的小组,只有当它的声纹与某个更大的说话人距离在 0.35 以内,且第二接近者至少再远 0.05 时,才会被并入该说话人。否则,这些词就不归属任何说话人。

ActNote/Services/Transcription/DiarizationService.swiftswift
for (id, count) in words where !protected.contains(id) {
    let share = Double(count) / Double(total)
    let isSmall = count < small.words && share < small.share
    let isUnprinted = prints != nil && prints?[id] == nil && count < unprinted.words && share < unprinted.share
    guard isSmall || isUnprinted else { continue }
    result.updateValue(prints?[id].flatMap { own in
        let ranked = words.filter { $0.key != id && $0.value > count }.keys
            .compactMap { other in prints?[other].flatMap { SpeakerVerification.distance($0.centroid, own.centroid) }.map { (other, $0) } }
            .sorted { $0.1 < $1.1 }
        guard let best = ranked.first, best.1 <= fold.distance,
              ranked.count < 2 || ranked[1].1 - best.1 >= fold.margin else { return nil }
        return best.0
    }, forKey: id)
}

在长会议上的 37 次运行中,这一机制清除了全部 6 个零散说话人,归到正确说话人名下的词占比不变,所有真实说话人都得以保留,其中发言最少的一位也说了 70 多个词(Mac 主机)。你设置的名字和手动分配的行,永远不会被改动。

声纹记忆:认出你标注过的人

只要标注一次说话人,Meetly 就能在之后的录音中认出这个人。这是用户最容易注意到的功能,也是最不能容忍出错的功能,所以我们用三个决策来保证它的精确:只从干净的语音中学习;只有恰好一个已存声音匹配时才给出名字;并且衡量真正要紧的错误,也就是叫错人。

只从干净的语音中学习

如果同一个 10 秒窗口里有两个人在说话,这个窗口的声纹就是两人的混合,所以只要窗口里有其他任何人说话,引擎就会丢弃它。剩下的窗口围绕中心点(medoid,即与其他所有窗口最相似的那个窗口)合并;与它距离超过 0.45 的窗口会被剔除,如果超过一半的窗口都要剔除,这个声纹就判为失败。

ActNote/Services/Transcription/DiarizationService.swiftswift
/// Each retained interval is genuine diarizer speech within the embedding window.
/// A window touched by another credible speaker is rejected conservatively.
nonisolated static func evidence(from result: DiarizationResult) -> [SpeakerEvidence] {
    (result.chunkEmbeddings ?? []).flatMap { chunk -> [SpeakerEvidence] in
        let overlapping = result.segments.filter {
            min(chunk.endTimeSeconds, Double($0.endTimeSeconds)) > max(chunk.startTimeSeconds, Double($0.startTimeSeconds))
        }
        guard !overlapping.contains(where: { $0.speakerId != chunk.speakerId }) else { return [] }
        return overlapping.filter { $0.speakerId == chunk.speakerId }.map { turn in
            SpeakerEvidence(speakerID: chunk.speakerId,
                start: max(chunk.startTimeSeconds, Double(turn.startTimeSeconds)),
                end: min(chunk.endTimeSeconds, Double(turn.endTimeSeconds)), embedding: chunk.embedding256,
                observationStart: chunk.startTimeSeconds, observationID: String(chunk.chunkIndex))
        }
    }
}

生成一个声纹需要 3 秒干净语音,一个已存声音需要累积 15 秒才会开始给人命名。代价是真实存在的:一个只在快速你来我往中发言的人,可能永远等不到一个干净的窗口。在远场会议音频上,63 人中有 60 人得到了声纹。

只有恰好一个已存声音匹配时才命名

匹配代码最好读成一份“不给任何人命名”的理由清单。

MeetlyCore/SavedVoices.swiftswift
var result: [Int: SavedVoice] = [:]
for (speaker, ranked) in distances where !excluding.contains(speaker) {
    guard let best = ranked.first, best.1 <= limit(best.0),
          ranked.filter({ $0.1 <= limit($0.0) }).count == 1 else { continue }
    if ranked.count > 1, ranked[1].1 - best.1 < policy.margin { continue }
    let rivals = distances.filter { other, list in
        other != speaker && list.contains { $0.0.id == best.0.id && $0.1 <= limit($0.0) }
    }
    // On a device you wear, several speakers near your own voice are you, split by the
    // diarizer; they all match you. Other saved people still abstain on a rival.
    guard rivals.isEmpty || (best.0.isSelf && selfThreshold != nil) else { continue }
    result[speaker] = best.0
}
return result

可以把它理解为四道拒绝条件。最近的已存声音,余弦距离必须在 0.35 以内。在这个阈值内的已存声音必须恰好只有一个。第二接近者必须至少再远 0.05。如果同一段录音里有两个说话人都匹配到同一个已存声音,两者都不命名,因为其中必有一个是错的。已存声音只在聚类之后给说话人命名,永远不会改变识别出的说话人。

衡量真正要紧的错误:叫错名字

我们在 AMI 语料上每组用一场会议录入声音,在另外三场上测试。表 2 中要看的是最后一列:一个人被叫成别人名字的次数。

音频命名正确放弃命名命名错误
干净的耳麦混音41/4100
通话音质(12 kbit/s Opus)40/4110
所有人均已录入,部分缺席81/8100
1,725 次冒认测试不适用不适用0 次接受
表 2:AMI 语料库,16 场会议,63 人;每组用一场会议录入声音,在另外三场上测试。Mac 主机。

通话音频上唯一一次未命中是放弃命名,而不是叫错名字。陌生人与已存声音的最近距离是电话音频上的 0.396,所以 0.35 的阈值留有余量。在 30 个已存声音、10,000 次试验中,99.7% 的标签正确,只有 0.17% 的陌生人被打上了标签(Mac 主机)。

可穿戴设备上,你本人的声音阈值更宽

有一个阈值例外。对于你佩戴的录音设备录下的片段,你本人声音的阈值是 0.45。在短而嘈杂的片段上,我们自己的声音与已存声纹的距离在 0.13 到 0.49 之间,其他人都没有近于 0.6,而且设备就戴在你身上。其他所有已存声音仍保持 0.35。声纹是 256 个数字,不保留任何音频;只有在你开启同步时,已存声音才会通过你自己的私有 iCloud 加密同步。

结果

实际使用中,11.4 分钟的中位对话转写耗时 26.3 秒(遥测)。说话人上限从 8 提到 32 后,一场 19 人电话会议的错误率从 25.8% 降到 5.4%;零散说话人规则在 37 次运行中清除了全部 6 个零散说话人;声纹记忆为 81 个已录入的人全部正确命名,1,725 次冒认测试无一通过(Mac 主机)。

系列后续

到目前为止,一切都在 iPhone 上运行。第三篇介绍这一切如何在手机上容纳得下,以及哪些内容会离开手机:保证内存中同一时间只有一个重型模型的调度器、可选的云端摘要会发送什么又会拒绝什么、从停止到摘要的时间花在哪里,以及测过但没上线的方案。

结语

本篇的四个阶段解决的是不同的问题,但遵循同一条规则:当引擎没有把握时,选择用户能够挽回的结果,比如重做一个分块、保留一段录音、让一行不标注,或者让一个声音不命名。这条规则会牺牲一些覆盖率,但也正因如此,那些显示出来的标签才值得信任。

用你说的任何一种语言录一段试试。处理过程中,对话页面会显示语种检查步骤、引擎选用的模型以及识别出的说话人。

下载 iPhone 版 Meetly

关于 Meetly Auto Engine 的常见问题

Meetly 如何知道是谁在说话?

开源的 pyannote 说话人模型被转换为 Core ML 格式并内置在 App 中,负责找出谁在什么时候说话,并把每个声音转换成由 256 个数字组成的声纹。当你标注一个说话人时,Meetly 只从干净的语音中学习这个声音,也就是没有其他人说话的窗口。之后,只有当恰好一个已存声音在距离阈值内、第二接近的声音明显更远、并且同一段录音中没有其他说话人也匹配到它时,才会给说话人命名。在我们的测试集上,81 个标签全部正确,1,725 次冒认测试无一被接受;拿不准时,它会让说话人保持未命名。

如果 iOS 打断了一次长转写,会怎样?

一次中断只损失几秒,而不是整个任务。Meetly 以 20 毫秒为一帧对音频做能量分析,大约每五分钟切一刀,切点选在每个标记点之前 30 秒内最安静的帧上,因此不会把词切断。每个完成的分块单独保存为一个文件,以内容摘要命名,读回时会做校验。App 重新启动后,任务会找到相同的音频哈希,跳过所有已保存的分块,只重做中断时正在处理的那一块。手机发热时,引擎还会降为单个工作线程,在后台则规划 45 秒的分块。

Meetly 会删除它认为是空的录音吗?

不会。转写一完成,引擎就会给每段录音一个判定:保留、待复核或归档,并附上一句理由。归档会把可穿戴设备的片段从视图中移除,但你自己开始录制的对话,除非明显是空的,否则只会被标记为待复核。被归档的录音仍会保留,可以恢复。如果你点击了“保留”或“归档”,这个决定会以你为来源记录下来,引擎永远不会覆盖它。可选的模型检查失败时默认放行:没有授权、没有网络、请求超时或回答无法解析,结果都是保留。

为什么 Meetly 有时会让某一行没有说话人?

因为不标注的一行是诚实的,而被归给错误说话人的一行,是读者看不出来的错误。只有当某个说话人的话轮覆盖一个词至少 30% 的时长,且胜出者占据覆盖时长的至少 60% 时,这个词才会归属于该说话人。一个不足 60 个词、且占录音不到 1% 的零散小组,只有在其声纹明显最接近某个更大的说话人时才会被并入;否则这些词保持未标注。在长会议上的 37 次运行中,这一机制清除了全部 6 个零散说话人,并保留了每一位真实说话人。