nvidia/Nemotron-3-Diarization · Hugging Face

来源：https://huggingface.co/nvidia/Nemotron-3-Diarization

https://huggingface.co/nvidia/Nemotron-3-Diarization#descriptionDescription

**Nemotron 3 说话人分割模型 (https://huggingface.co/blog/nvidia/nemotron-diarization)**是一个开源权重说话人分割模型，旨在确定现实音频中“谁在何时说话”。它支持流式和离线推理，最多可处理八位说话人。该模型遵循 Sortformer[1]，通过按照每位说话人在输入音频中首次出现的时间顺序来排列其输出通道，从而解决说话人排列问题。

对于流式推理，该模型采用了流式 Sortformer[2]中引入的到达顺序说话人缓存（AOSC）和 FIFO 队列。AOSC 保留来自早期数据块的说话人信息，以在时间上保持说话人身份；而 FIFO 队列为每个处理步骤提供最近的帧上下文。

单个检查点支持低至 80 ms 的输入缓冲区延迟，适用于对延迟敏感的应用，尽管推荐的最低配置为 0.32 秒；离线式配置使用 30.4 秒的输入缓冲区。输出帧分辨率可配置为 10 ms 的倍数。使用分块推理时，音频的最大时长不受限制。

此模型可供商业或非商业使用。

Nemotron 3 Diarization HuggingFace 博客 (https://huggingface.co/blog/nvidia/nemotron-diarization)

https://huggingface.co/nvidia/Nemotron-3-Diarization#release-date发布日期

2026年9月23日

https://huggingface.co/nvidia/Nemotron-3-Diarization#live-action-demo-page实时演示页面

Hugging Face Spaces 演示：Nemotron-分割模型与流式 ASR (https://huggingface.co/spaces/nvidia/nemotron-diarization)Nemotron-Diarization with Streaming ASR 演示 (https://huggingface.co/spaces/nvidia/nemotron-diarization)

https://huggingface.co/nvidia/Nemotron-3-Diarization#what-does-max-8-speaker-diarization-mean-什么是最大8说话人分割？

https://huggingface.co/nvidia/Nemotron-3-Diarization#

https://huggingface.co/nvidia/Nemotron-3-Diarization#how-to-use-this-model如何使用此模型

https://huggingface.co/nvidia/Nemotron-3-Diarization#run-locally-with-nemo-speechcpp使用 NeMo-Speech.cpp 在本地运行

NeMo-Speech.cpp (https://github.com/NVIDIA/NeMo-Speech.cpp) 提供了一个轻量级的原生 C++ 运行时，用于本地说话人分割。安装运行时 (https://github.com/NVIDIA/NeMo-Speech.cpp#installation) 后：

nemo-speech diarize meeting.wav

同一个模型可以为转录添加词级说话人标签：

nemo-speech transcribe meeting.wav --diarize --json

更多使用示例请参阅 NeMo-Speech.cpp 分割指南 (https://github.com/NVIDIA/NeMo-Speech.cpp/blob/main/docs/cli.md#diarize-audio)。

https://huggingface.co/nvidia/Nemotron-3-Diarization#nvidia-nemo-speechNVIDIA NeMo Speech

要使用此模型进行训练、微调或推理，请在安装 Python 3.12 或更高版本、Cython 和最新版本的 PyTorch 后，安装 NVIDIA NeMo Speech (https://github.com/NVIDIA-NeMo/Speech)。

apt-get update && apt-get install -y libsndfile1 ffmpeg uv pip install Cython packaging uv pip install 'nemo-toolkit[asr]'

https://huggingface.co/nvidia/Nemotron-3-Diarization#%F0%9F%9A%80-quick-start-run-diarization-now🚀 快速开始：立即运行分割

下面是一个简短的示例脚本，它加载模型，对 WAV 文件运行分割，并打印结果：

`` from nemo.collections.asr.models import SortformerEncLabelModel diar_model = SortformerEncLabelModel.from_pretrained(“nvidia/Nemotron-3-Diarization”) diar_model.eval()

diar_model.sortformer_modules.chunk_len = 340 diar_model.sortformer_modules.chunk_right_context = 40 diar_model.sortformer_modules.fifo_len = 40 diar_model.sortformer_modules.spkcache_update_period = 300 diar_model._check_streaming_parameters()

predicted_segments = diar_model.diarize(audio=[“/path/to/your/audio.wav”], batch_size=1)

for segment in predicted_segments[0]: print(segment) ``

https://huggingface.co/nvidia/Nemotron-3-Diarization#loading-the-model加载模型

`` from nemo.collections.asr.models import SortformerEncLabelModel

直接从 Hugging Face 模型卡加载模型（需要 Hugging Face 令牌）

diar_model = SortformerEncLabelModel.from_pretrained(“nvidia/Nemotron-3-Diarization”)

如果您有下载到 “/path/to/Nemotron-3-Diarization.nemo” 的模型，可以从下载的文件加载

diar_model = SortformerEncLabelModel.restore_from(restore_path=“/path/to/Nemotron-3-Diarization.nemo”, map_location=‘cuda’, strict=False)

切换到推理模式

diar_model.eval() ``

https://huggingface.co/nvidia/Nemotron-3-Diarization#input-format输入格式

输入可以是单个音频文件：

audio_input="/path/to/multispeaker_audio1.wav"

或者是一组音频文件路径的列表：

audio_input=["/path/to/multispeaker_audio1.wav", "/path/to/multispeaker_audio2.wav"]

或者是一个 numpy 数组（单个或列表）：

`` import numpy as np audio_input = np.random.randn(16000 * 10).astype(np.float32) # 10秒，16kHz采样率

或者一个数组列表

audio_input = [audio_array1, audio_array2] diar_model.diarize(audio=audio_input, batch_size=2, sample_rate=16000) ``

注意：使用 numpy 数组时，您必须在 diar_model.diarize() 函数中指定正确的 sample_rate。默认 sample_rate 为 16000。

或者是一个以换行符分隔的 JSON 清单文件：

audio_input="/path/to/multispeaker_manifest.json"

其中每行是一个 JSON 对象，包含以下字段：

{"audio_filepath": "/path/to/multispeaker_audio1.wav", "offset": 0, "duration": 600} {"audio_filepath": "/path/to/multispeaker_audio2.wav", "offset": 900, "duration": 580}

https://huggingface.co/nvidia/Nemotron-3-Diarization#setting-up-streaming-configuration设置流式配置

流式配置由以下参数定义，所有参数均以80 ms 帧为单位：

• SPKCACHE_LEN：说话人缓存中的总帧数。
• FIFO_LEN：从 FIFO 队列附加到当前数据块之前的先前帧数。
• CHUNK_LEN：处理数据块中的帧数。
• RIGHT_CONTEXT：附加到数据块之后的未来帧数。
• UPDATE_PERIOD：从 FIFO 队列中提取以更新说话人缓存的帧数。

以下是不同场景的推荐配置：

配置 延迟 SPKCACHE_LEN FIFO_LEN CHUNK_LEN RIGHT_CONTEXT UPDATE_PERIOD 非常高延迟（离线） 30.4 秒 264 40 340 40 300 低延迟 1.04 秒 264 264 94 22 22 非常低延迟 0.64 秒 264 264 62 22 22 超低延迟 0.32 秒 264 264 31 2 2

延迟是指输入缓冲区延迟，计算公式为（CHUNK_LEN + RIGHT_CONTEXT）× 80 ms。此值不包括计算处理时间。

要设置流式配置，请使用：

diar_model.sortformer_modules.spkcache_len = SPKCACHE_LEN diar_model.sortformer_modules.fifo_len = FIFO_LEN diar_model.sortformer_modules.chunk_len = CHUNK_LEN diar_model.sortformer_modules.chunk_right_context = RIGHT_CONTEXT diar_model.sortformer_modules.spkcache_update_period = UPDATE_PERIOD diar_model._check_streaming_parameters()

https://huggingface.co/nvidia/Nemotron-3-Diarization#getting-diarization-results获取分割结果

要执行说话人分割并获取格式为 begin_seconds, end_seconds, speaker_index 的带说话人标记的语音段列表，只需使用：

predicted_segments = diar_model.diarize(audio=audio_input, batch_size=1)

要获取说话人活动概率的张量，请使用：

predicted_segments, predicted_probs = diar_model.diarize(audio=audio_input, batch_size=1, include_tensor_outputs=True)

请注意，如果您提供的是 numpy 数组列表，则必须以整数格式提供 sample_rate。

predicted_segments, predicted_probs = diar_model.diarize(audio=[np_array1, np_array2], batch_size=2, sample_rate=16000)

https://huggingface.co/nvidia/Nemotron-3-Diarization#%F0%9F%94%AC-for-more-detailed-evaluations-der🔬 进行更详细评估（DER）

如果您需要执行全面评估并在不同参数设置下计算准确性和速度指标，请使用 NeMo 示例脚本 e2e_diarize_speech.py (https://github.com/NVIDIA-NeMo/Speech/blob/main/examples/speaker_tasks/diarization/neural_diarizer/e2e_diarize_speech.py)。此脚本允许您通过调整关键参数（如 chunk_len、fifo_len、chunk_right_context 和 spkcache_update_period）来测试模型的流式行为。

python ${NEMO_ROOT}/examples/speaker_tasks/diarization/neural_diarizer/e2e_diarize_speech.py \ pretrained_name="nvidia/Nemotron-3-Diarization" \ dataset_manifest="/path/to/diarization_manifest.json" \ batch_size=32 \ collar=0 \ precision=bf16 \ compile_encoder=false \ spkcache_len=264 \ spkcache_update_period=300 \ fifo_len=40 \ chunk_len=340 \ chunk_right_context=40

更多评估详情请参阅分割评估 (https://huggingface.co/nvidia/Nemotron-3-Diarization/blob/main/diarization_evaluation.md) 子页面。

https://huggingface.co/nvidia/Nemotron-3-Diarization#%F0%9F%A4%97-transformers-usage🤗 Transformers 用法

此模型在 🤗 Transformers (https://github.com/huggingface/transformers) 中原生支持！从源码安装：

pip install git+https://github.com/huggingface/transformers

更多使用细节，请参阅 Transformers 文档 (https://huggingface.co/docs/transformers/en/model_doc/nemotron3_diarization)。

➡️ 离线分割 `` import torch from transformers import AutoModelForAudioFrameClassification, AutoProcessor from transformers.audio_utils import load_audio

model_id = “nvidia/Nemotron-3-Diarization” processor = AutoProcessor.from_pretrained(model_id) model = AutoModelForAudioFrameClassification.from_pretrained(model_id, device_map=“auto”)

sampling_rate = processor.feature_extractor.sampling_rate audio = load_audio( “https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/diarization_example.mp3”, sampling_rate=sampling_rate, ) inputs = processor(audio, sampling_rate=sampling_rate).to(model.device, dtype=model.dtype)

with torch.inference_mode(): logits = model(**inputs).logits # (1, num_frames, 8), 每10毫秒一帧

segments = processor.extract_speaker_dict(logits, inputs.attention_mask)[0] for segment in segments: print(f“speaker_{segment[‘Speaker’]}: {segment[‘Start’]:.2f}s - {segment[‘End’]:.2f}s“) ``

➡️ 流式分割 音频分块到达，每次前向传播处理一个块：处理器为 streaming_mode 裁剪它并添加 num_lookahead_frames（模型关注但不评分的尾随前瞻帧数，因为它们开启下一个数据块）。前向传播返回 speaker_cache 以传递给下一次调用。会话的最后一个数据块使用 is_last_audio_chunk=True 提取：它没有前瞻，因此每个剩余帧都会被评分。

streaming_mode 延迟¹ "low_latency"（默认） 1.04 秒 "very_low_latency" 0.64 秒 "ultra_low_latency" 0.32 秒 ¹ 模型在处理一个数据块之前需要等待的音频：该数据块及其前瞻，不包括计算时间。

`` import torch from transformers import AutoModelForAudioFrameClassification, AutoProcessor from transformers.audio_utils import load_audio

model_id = “nvidia/Nemotron-3-Diarization” processor = AutoProcessor.from_pretrained(model_id) model = AutoModelForAudioFrameClassification.from_pretrained(model_id, device_map=“auto”) processor.set_streaming_mode(“low_latency”) # 默认值，也可以是 “very_low_latency” 和 “ultra_low_latency” print(f“Streaming latency: {processor.streaming_latency_ms} ms“)

sampling_rate = processor.feature_extractor.sampling_rate audio = load_audio( “https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/diarization_example.mp3”, sampling_rate=sampling_rate, )

def inputs_generator(): “”“生成每个数据块的处理器输出。”“” yield processor( audio[: processor.num_samples_first_audio_chunk], sampling_rate=sampling_rate, is_streaming=True, is_first_audio_chunk=True, )

mel_frame_idx = processor.num_mel_frames_per_step
start_idx = processor.audio_chunk_start(mel_frame_idx)
while (end_idx := start_idx + processor.num_samples_per_audio_chunk) <= audio.shape[0]:
    yield processor(
        audio[start_idx:end_idx],
        sampling_rate=sampling_rate,
        is_streaming=True,
        is_first_audio_chunk=False,
    )
    mel_frame_idx += processor.num_mel_frames_per_step
    start_idx = processor.audio_chunk_start(mel_frame_idx)

# 音频结束：缓冲区中剩余的帧是会话的最后一帧
yield processor(
    audio[start_idx:],
    sampling_rate=sampling_rate,
    is_streaming=True,
    is_first_audio_chunk=False,
    is_last_audio_chunk=True,
)

speaker_cache, logits = None, [] with torch.inference_mode(): for inputs in inputs_generator(): inputs = inputs.to(model.device, dtype=model.dtype) # inputs 为除最后一个外的每个数据块携带 num_lookahead_frames，speaker_cache 连接这些数据块 outputs = model(**inputs, speaker_cache=speaker_cache) logits.append(outputs.logits) # 该数据块的帧，不包括其前瞻 speaker_cache = outputs.speaker_cache

logits = torch.cat(logits, dim=1) # (1, num_frames, 8), 每10毫秒一帧 segments = processor.extract_speaker_dict(logits)[0] # [{“Start”: 0.0, “End”: 15.43, “Speaker”: 0}, …] ``

https://huggingface.co/nvidia/Nemotron-3-Diarization#integration-with-streaming-asr与流式 ASR 集成

有关将 Nemotron 分割模型与流式 ASR 集成的详细说明，请参阅 ASR 集成指南 (https://huggingface.co/nvidia/Nemotron-3-Diarization/blob/main/ASR_INTEGRATION_GUIDE.md)。

https://huggingface.co/nvidia/Nemotron-3-Diarization#model-architecture模型架构

架构类型： Transformer。

网络架构：

• 一个 31 层的 Transformer 编码器，具有旋转位置嵌入（RoPE）。
• 10 ms 梅尔频谱图输入特征，通过特征堆叠下采样八倍，产生 80 ms 的编码器帧率。
• 编码器上方的一个 Conv1D 层，将预测上采样到 10 ms 的输入特征分辨率。
• 用于流式推理的 AOSC 和 FIFO 队列。

模型参数数量： 100M（1.0 × 10^8）。

https://huggingface.co/nvidia/Nemotron-3-Diarization#input输入

输入类型： 音频。

输入格式： 16 kHz，单通道，.wav、.flac、.opus 或 .mp3 格式。

输入参数： 一维，16 kHz，单通道音频波形。

最大时长： 使用分块推理时无限制。

与输入相关的其他属性： 输入音频必须以 16 kHz 采样，并被转换为 10 ms 梅尔频谱图特征。分块推理支持无固定最大时长的录音。

https://huggingface.co/nvidia/Nemotron-3-Diarization#output输出

输出类型： 其他：数值张量。

输出格式： 浮点张量。

输出参数： 形状为 [T, 8] 的二维张量，其中 T 是输出帧数，每个值是范围 [0, 1] 内的每位说话人活动概率。

输出帧分辨率： 默认帧步长为 10 ms，可配置为任何 10 ms 的倍数，例如 30 ms、80 ms 或 240 ms。

说话人排序： 输出通道按说话人首次出现在音频中的时间顺序排列（最早到达的说话人对应通道 0）。