Transformers documentation

Nemotron 3 Diarization

Transformers

Начало работы

Transformers Установка Быстрый старт

Базовые классы

Модели

Предобработчики

Вывод

API конвейера

Generate API

Оптимизация

Чат с моделями

Развёртывание

Обучение

Начало работы

Настройка

Параметрически эффективная дообучение

Производительность

Распределённое обучение

Аппаратное обеспечение

Квантование

Интеграции с экосистемой

Ресурсы

API

Основные классы

Модели

Текстовые модели

Модели компьютерного зрения

Аудиомодели

Видеомодели

Мультимодальные модели

Модели обучения с подкреплением

Модели временных рядов

Внутренние вспомогательные функции

Справочник

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

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

Эта модель была добавлена в Hugging Face Transformers 23.09.2026.

Nemotron 3 Diarization

Обзор

Nemotron 3 Diarization — это модель с открытыми весами для потоковой идентификации говорящих, предназначенная для определения «кто и когда говорил» в реальном аудио. Она поддерживает как потоковый, так и офлайн-инференс, обрабатывает до восьми говорящих и выстраивает результаты по порядку первого появления каждого говорящего во входном аудио.

Модель использует Arrival-Order Speaker Cache (AOSC) 1 и очередь FIFO, представленные для Streaming Sortformer 1, 2. Одна контрольная точка поддерживает настраиваемые профили задержки — от входного буфера 80 мс до офлайн-буфера 30,4 с — а также настраиваемое разрешение выходных кадров с шагом 10 мс. При инференсе по чанкам максимальная длительность аудио не ограничена.

Использование

Офлайн

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

Потоковая передача

Аудио поступает по частям, и каждый forward-проход обрабатывает одну часть: процессор нарезает её в соответствии со своим streaming_mode и добавляет num_lookahead_frames — количество кадров look-ahead, на которые модель обращает внимание, но которые не оцениваются, поскольку они открывают следующую часть. В результате 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

¹ Аудио, ожидаемое перед запуском модели на фрагменте: фрагмент вместе с его опережением, за вычетом времени вычислений.

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 пересобирает код примерно сто раз за сессию. Если на каждом шаге дополнять вход до максимального окна данного режима, форма тензора становится фиксированной. Позиции обнуляются в начале каждого чанка, поэтому правое дополнение не влияет на валидные кадры:

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

Цикл потоковой обработки, приведённый выше, компилируется один раз. Офлайн-прямой проход разбивает данные на чанки аналогичным образом, поэтому тот же самый обёртывающий класс применяется с параметрами config.fifo_length, config.chunk_left_context, config.chunk_length и config.chunk_right_context в max_window.

Ускорение по сравнению с eager (A100, размер батча 1)	float32	bfloat16
потоковая, по шагам	1.2x	4.4x
офлайн, запись длительностью 488 с	1.3x	2.8x

Transformers

Nemotron 3 Diarization

Обзор

Использование

Офлайн

Потоковая передача

Делаем так, чтобы работало на полную

Nemotron3DiarizationConfig

класс transformers.Nemotron3DiarizationConfig

Nemotron3DiarizationAudioConfig

класс transformers.Nemotron3DiarizationAudioConfig

Nemotron3DiarizationHeadConfig

класс transformers.Nemotron3DiarizationHeadConfig

Nemotron3DiarizationStreamingConfig

класс transformers.Nemotron3DiarizationStreamingConfig

Nemotron3DiarizationAudioModel

класс transformers.Nemotron3DiarizationAudioModel

forward

Nemotron3DiarizationModel

класс transformers.Nemotron3DiarizationModel

forward

Nemotron3DiarizationProcessor

класс transformers.Nemotron3DiarizationProcessor

__call__

Nemotron3DiarizationSpeakerCache

класс transformers.Nemotron3DiarizationSpeakerCache

обновление

Nemotron3DiarizationOutput

класс transformers.Nemotron3DiarizationOutput

Nemotron3DiarizationForAudioFrameClassification

класс transformers.Nemotron3DiarizationForAudioFrameClassification

forward

call