Transformers documentation

Nemotron 3 화자 분리

Transformers

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.2).

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-09-23에 Hugging Face Transformers에 기여되었습니다.

Nemotron 3 화자 분리

개요

Nemotron 3 Diarization은 실제 오디오에서 “누가 언제 말했는지”를 판별하도록 설계된 오픈 웨이트 스트리밍 화자 분리 모델입니다. 스트리밍 및 오프라인 추론을 모두 지원하며, 최대 8명의 화자를 처리하고 입력 오디오에서 각 화자가 처음 등장한 순서대로 화자 출력을 정렬합니다.

모델은 Streaming Sortformer 1, 2에 도입된 Arrival-Order Speaker Cache(AOSC) 1와 FIFO 큐를 사용합니다. 단일 체크포인트는 80 ms 입력 버퍼부터 30.4 s 오프라인 스타일 버퍼까지 다양한 지연 시간 프로필을 지원하며, 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는 하나의 청크를 처리합니다. 프로세서가 streaming_mode에 따라 청크를 잘라내고, 다음 청크를 여는 역할을 하므로 점수화되지 않는 후방 look-ahead 프레임 수인 num_lookahead_frames을 추가합니다. forward는 다음 호출에 전달하기 위해 speaker_cache를 반환합니다. 세션의 마지막 청크는 is_last_audio_chunk=True로 추출됩니다. look-ahead가 없으므로 나머지 모든 프레임이 점수화됩니다.

`streaming_mode`	지연 시간¹
`"low_latency"` (기본값)	1.04 s
`"very_low_latency"`	0.64 s
`"ultra_low_latency"`	0.32 s

¹ 모델이 청크를 실행하기 전에 대기해야 하는 오디오: 계산 시간을 제외한 청크와 그 look-ahead.

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회 정도 재컴파일됩니다. 모든 단계에서 해당 모드의 최대 윈도우로 패딩하면 형태가 고정됩니다. 각 청크마다 위치가 0으로 재시작되므로, 오른쪽 패딩은 유효한 프레임에 영향을 주지 않습니다:

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

위의 스트리밍 루프는 한 번만 컴파일됩니다. 오프라인 forward도 동일한 방식으로 청크를 나누므로, 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 화자 분리

개요

사용

오프라인

스트리밍

성능 극대화

Nemotron3DiarizationConfig

class transformers.Nemotron3DiarizationConfig

Nemotron3DiarizationAudioConfig

클래스 transformers.Nemotron3DiarizationAudioConfig

Nemotron3DiarizationHeadConfig

클래스 transformers.Nemotron3DiarizationHeadConfig

Nemotron3DiarizationStreamingConfig

class transformers.Nemotron3DiarizationStreamingConfig

Nemotron3DiarizationAudioModel

class transformers.Nemotron3DiarizationAudioModel

forward

Nemotron3DiarizationModel

class transformers.Nemotron3DiarizationModel

forward

Nemotron3DiarizationProcessor

class transformers.Nemotron3DiarizationProcessor

__call__

Nemotron3DiarizationSpeakerCache

class transformers.Nemotron3DiarizationSpeakerCache

업데이트

Nemotron3DiarizationOutput

class transformers.Nemotron3DiarizationOutput

Nemotron3DiarizationForAudioFrameClassification

class transformers.Nemotron3DiarizationForAudioFrameClassification

forward

call