Transformers documentation

Nemotron 3 Diarization

Transformers

はじめに

Transformers インストールクイックスタート

ベースクラス

モデル

プリプロセッサ

推論

Pipeline API

Generate API

最適化

モデルとチャットする

サービング

トレーニング

はじめに

カスタマイズ

パラメータ効率の良いファインチューニング

パフォーマンス

分散学習

ハードウェア

量子化

エコシステム統合

リソース

API

主要クラス

モデル

テキストモデル

ビジョンモデル

音声モデル

動画モデル

マルチモーダルモデル

強化学習モデル

時系列モデル

内部ヘルパー

リファレンス

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

このモデルは2026年9月23日に Hugging Face Transformers に貢献されました。

Nemotron 3 Diarization

概要

Nemotron 3 Diarization は、実世界の音声において「誰がいつ話したか」を判定するために設計された、オープンウェイトのストリーミング型話者分離モデルです。ストリーミング推論とオフライン推論の両方をサポートし、最大8人の話者を処理できます。また、話者の出力は、入力音声における各話者の初回出現順に並べられます。

モデルは、Streaming Sortformer 1、2 で導入された Arrival-Order Speaker Cache (AOSC) 1 および FIFO キューを使用しています。単一のチェックポイントで、80 ms の入力バッファから 30.4 秒のオフライン風バッファまでの設定可能なレイテンシプロファイル、および 10 ms の倍数で設定可能な出力フレーム解像度をサポートします。チャンク推論を使用する場合、最大音声長は制限されません。

使用方法

オフライン

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), one frame every 10 ms

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")

ストリーミング

Audio はチャンク単位で到着し、各 forward は 1 つのチャンクを処理します。プロセッサは streaming_mode に基づいてチャンクを切り出し、num_lookahead_frames 分（モデルが注意するがスコアリングしない、次のチャンクを開くための末尾のルックアヘッドフレーム数）を追加します。forward は、次の呼び出しに渡すための speaker_cache を返します。セッションの最後のチャンクは is_last_audio_chunk=True を指定して抽出します。ルックアヘッドがないため、残りのすべてのフレームがスコアリングされます。

`streaming_mode`	レイテンシー¹
`"low_latency"`（デフォルト）	1.04 s
`"very_low_latency"`	0.64 s
`"ultra_low_latency"`	0.32 s

¹ モデルがチャンクを実行する前に待機するオーディオ: 計算時間を除いた、チャンクとそのルックアヘッドの合計。

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")  # the default, can also be "very_low_latency" and "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():
    """Yields the processor outputs of each chunk."""
    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)

    # the audio ended: the frames left in the buffer are the last ones of the session
    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` carries `num_lookahead_frames` for every chunk but the last, `speaker_cache` links the chunks
        outputs = model(**inputs, speaker_cache=speaker_cache)
        logits.append(outputs.logits)  # the chunk's frames, without its look-ahead
        speaker_cache = outputs.speaker_cache

logits = torch.cat(logits, dim=1)  # (1, num_frames, 8), one frame every 10 ms
segments = processor.extract_speaker_dict(logits)[0]  # [{"Start": 0.0, "End": 15.43, "Speaker": 0}, ...]

高速化

ストリーミングステップにおけるエンコーダーの入力は [speaker cache | FIFO | chunk] であり、キャッシュと FIFO が埋まっていくにつれて、また縮小していくにつれて、その長さが変化します: torch.compile を使用すると、セッションごとに約100回再コンパイルされてしまいます。各ステップをそのモードの最大ウィンドウ長までパディングすることで、形状を固定できます。各チャンクごとに位置がゼロから再開されるため、右パディングをしても有効なフレームは変わりません:

import torch.nn.functional as F

chunk_length, chunk_right_context = processor.streaming_modes[processor.streaming_mode]
max_window = (
    model.config.streaming_config.speaker_cache_length
    + model.config.streaming_config.fifo_length
    + chunk_length
    + chunk_right_context
)
encoder = model.model
compiled_forward = torch.compile(encoder.forward, mode="reduce-overhead", fullgraph=True, dynamic=False)


def padded_forward(inputs_embeds, attention_mask=None, position_ids=None, **kwargs):
    batch_size, num_frames, _ = inputs_embeds.shape
    if attention_mask is None:
        attention_mask = inputs_embeds.new_ones(batch_size, num_frames, dtype=torch.bool)
    padding = max_window - num_frames
    hidden_states = compiled_forward(
        inputs_embeds=F.pad(inputs_embeds, (0, 0, 0, padding)),
        attention_mask=F.pad(attention_mask.bool(), (0, padding), value=False),
        position_ids=torch.arange(max_window, device=inputs_embeds.device)[None, :],
        **kwargs,
    )
    return hidden_states[:, :num_frames].clone()  # CUDA graphs reuse the output buffer


encoder.forward = padded_forward

# warm up before the session: compiles, then records the CUDA graph, so the first real chunk runs at full speed
with torch.inference_mode():
    for _ in range(3):
        hidden_size = model.config.audio_config.hidden_size
        padded_forward(torch.zeros(1, max_window, hidden_size, device=model.device, dtype=model.dtype))

上記のストリーミングループは1回だけコンパイルされます。オフラインのフォワードも同様にチャンク分割されるため、max_window に config.fifo_length、config.chunk_left_context、config.chunk_length、config.chunk_right_context を指定した同じラッパーが適用されます。

Eager に対する高速化率（A100、バッチサイズ 1）	float32	bfloat16
ストリーミング、ステップごと	1.2x	4.4x
オフライン、488秒の録音	1.3x	2.8x

Transformers

Nemotron 3 Diarization

概要

使用方法

オフライン

ストリーミング

高速化

Nemotron3DiarizationConfig

class transformers.Nemotron3DiarizationConfig

Nemotron3DiarizationAudioConfig

class transformers.Nemotron3DiarizationAudioConfig

Nemotron3DiarizationHeadConfig

class transformers.Nemotron3DiarizationHeadConfig

Nemotron3DiarizationStreamingConfig

クラス transformers.Nemotron3DiarizationStreamingConfig

Nemotron3DiarizationAudioModel

class transformers.Nemotron3DiarizationAudioModel

forward

Nemotron3DiarizationModel

class transformers.Nemotron3DiarizationModel

forward

Nemotron3DiarizationProcessor

class transformers.Nemotron3DiarizationProcessor

__call__

Nemotron3DiarizationSpeakerCache

class transformers.Nemotron3DiarizationSpeakerCache

update

Nemotron3DiarizationOutput

class transformers.Nemotron3DiarizationOutput

Nemotron3DiarizationForAudioFrameClassification

class transformers.Nemotron3DiarizationForAudioFrameClassification

forward

call