# Nemotron ASR Streaming

## Обзор

Nemotron ASR Streaming — это модель распознавания английской речи с 600 млн параметров от NVIDIA, разработанная для высококачественной транскрипции как в потоковом режиме с низкой задержкой, так и в пакетном режиме с высокой пропускной способностью, с поддержкой пунктуации и заглавных букв. Для потоковой обработки модель предлагает настраиваемые размеры блоков — 80 мс, 160 мс, 560 мс и 1120 мс, что позволяет пользователям выбирать баланс между задержкой и точностью в зависимости от задач приложения. Ключевую роль в этом играет архитектура FastConformer-RNNT с учетом кэша: в отличие от традиционной потоковой обработки с буферизацией, при которой многократно перерабатываются перекрывающиеся окна аудио, модель обрабатывает только каждый новый входящий блок, повторно используя кэшированный контекст энкодера из предыдущих блоков. Это устраняет избыточные вычисления, значительно повышает эффективность и минимизирует общую задержку без потери точности, что делает модель хорошо подходящей для задач транскрипции в реальном времени.

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

### Офлайн-распознавание

```python
from transformers import pipeline

pipe = pipeline(
    "automatic-speech-recognition",
    model="nvidia/nemotron-speech-streaming-en-0.6b",
)
out = pipe("https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3")
print(out)
```

```python
from transformers import AutoModelForRNNT, AutoProcessor
from transformers.audio_utils import load_audio

model_id = "nvidia/nemotron-speech-streaming-en-0.6b"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForRNNT.from_pretrained(model_id, device_map="auto")

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

inputs = processor(audio, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(model.device, dtype=model.dtype)
output = model.generate(**inputs, return_dict_in_generate=True)
print(processor.decode(output.sequences, skip_special_tokens=True))
```

### Потоковая расшифровка
> [!NOTE]
> Это экспериментальная функция, и API может измениться.

Для транскрибации в реальном времени аудио разбивается на фрагменты в соответствии со следующим:

```python
from threading import Thread
from transformers import AutoModelForRNNT, AutoProcessor, TextIteratorStreamer
from transformers.audio_utils import load_audio

model_id = "nvidia/nemotron-speech-streaming-en-0.6b"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForRNNT.from_pretrained(model_id, device_map="auto")

processor.set_num_lookahead_tokens(6)
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/obama.mp3",
    sampling_rate=sampling_rate,
)

first_chunk_inputs = processor(
    audio[: processor.num_samples_first_audio_chunk],
    sampling_rate=sampling_rate,
    is_streaming=True,
    is_first_audio_chunk=True,
    return_tensors="pt",
)
first_chunk_inputs = first_chunk_inputs.to(model.device, dtype=model.dtype)

def input_features_generator():
    yield first_chunk_inputs.input_features[:, : processor.num_mel_frames_first_audio_chunk, :]

    mel_frame_idx = processor.num_mel_frames_first_audio_chunk
    hop_length = processor.feature_extractor.hop_length
    n_fft = processor.feature_extractor.n_fft

    start_idx = mel_frame_idx * hop_length - n_fft // 2
    while (end_idx := start_idx + processor.num_samples_per_audio_chunk) < audio.shape[0]:
        inputs = processor(
            audio[start_idx:end_idx],
            sampling_rate=sampling_rate,
            is_streaming=True,
            is_first_audio_chunk=False,
            return_tensors="pt",
        )
        inputs = inputs.to(model.device, dtype=model.dtype)
        yield inputs.input_features

        mel_frame_idx += processor.num_mel_frames_per_audio_chunk
        start_idx = mel_frame_idx * hop_length - n_fft // 2

streamer = TextIteratorStreamer(processor.tokenizer, skip_special_tokens=True)
generate_kwargs = {
    **first_chunk_inputs,
    "input_features": input_features_generator(),
    "streamer": streamer,
}
thread = Thread(target=model.generate, kwargs=generate_kwargs)
thread.start()

# Iterate over the streamer to get text chunks as they are generated
print("Model output (streaming):", end=" ", flush=True)
for text_chunk in streamer:
    print(text_chunk, end="", flush=True)
thread.join()
```

#### Задержка потоковой передачи

Задержка определяется параметром `num_lookahead_tokens` — это правый контекст внимания (lookahead, в подвыбранных кадрах энкодера), который каждый чанк ожидает перед тем, как быть выданным. Более большое значение позволяет каждому чанку «видеть» больше будущего аудио: точность выше, но задержка тоже растёт. Просмотрите поддерживаемые варианты компромисса, выберите один и прочитайте полученную задержку:

```python
from transformers import AutoProcessor

processor = AutoProcessor.from_pretrained("nvidia/nemotron-speech-streaming-en-0.6b")

# Each supported `num_lookahead_tokens` mapped to its streaming latency in milliseconds:
print(processor.supported_streaming_latencies_ms)
# {13: 1120, 6: 560, 1: 160, 0: 80}

# Select a right attention context (this also re-derives the streaming chunk sizes used above):
processor.set_num_lookahead_tokens(6)

# Latency of the current selection:
print(processor.streaming_latency_ms)
# 560
```

`set_num_lookahead_tokens` задаёт размер блоков, которые выдаёт процессор, а соответствующий `num_lookahead_tokens` должен дойти до `generate` (в приведённом выше фрагменте он передаётся через `**inputs`/`**first_chunk_inputs`, которые несут `num_lookahead_tokens`). При потоковом вызове `generate` будет выброшено исключение, если этот параметр опущен.

## NemotronAsrStreamingConfig[[transformers.NemotronAsrStreamingConfig]]

#### transformers.NemotronAsrStreamingConfig[[transformers.NemotronAsrStreamingConfig]]

```python
transformers.NemotronAsrStreamingConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, is_encoder_decoder: bool = True, vocab_size: int = 1025, decoder_hidden_size: int = 640, num_decoder_layers: int = 2, hidden_act: str = 'relu', max_symbols_per_step: int = 10, encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, pad_token_id: int = 0, blank_token_id: int = 1024)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/configuration_nemotron_asr_streaming.py#L120)

**Параметры:**

is_encoder_decoder (`bool`, *необязательный*, по умолчанию `True`) : Используется ли модель в качестве энкодера/декодера.

vocab_size (`int`, *необязательный*, по умолчанию `1025`) : Размер словаря модели. Определяет количество различных токенов, которые могут быть представлены в `input_ids`.

decoder_hidden_size (`int`, *optional*, по умолчанию 640) : Размер скрытого слоя сети предсказания LSTM (`pred_hidden` в NeMo). Соединительная сеть проецирует выходы как энкодера, так и декодера в этот размер (`joint_hidden` в NeMo, который во всех известных контрольных точках равен `pred_hidden`).

num_decoder_layers (`int`, *необязательный*, по умолчанию 2) : Количество слоёв LSTM в сети предсказания.

hidden_act (`str`, *необязательный*, по умолчанию `"relu"`) : Активация в объединённой сети.

max_symbols_per_step (`int`, *optional*, по умолчанию 10) : Максимальное количество непустых символов, выдаваемых на каждом временном шаге энкодера при жадном декодировании.

encoder_config (`Union[dict, NemotronAsrStreamingEncoderConfig]`, *необязательный*) : Объект конфигурации или словарь для энкодера.

pad_token_id (`int`, *необязательный*, по умолчанию `0`) : Идентификатор токена, используемый для выравнивания в словаре.

blank_token_id (`int`, *необязательный*, по умолчанию 1024) : Идентификатор пустого токена. Отличается от `pad_token_id` для RNN-T.

Это класс конфигурации для хранения настроек модели NemotronAsrStreamingForRNNT. Он используется для создания модели Nemotron Asr Streaming в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации модели [nvidia/nemotron-speech-streaming-en-0.6b](https://huggingface.co/nvidia/nemotron-speech-streaming-en-0.6b)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig).

Пример:
```python
>>> from transformers import NemotronAsrStreamingForRNNT, NemotronAsrStreamingConfig

>>> # Initializing a NemotronAsrStreaming RNN-T configuration
>>> configuration = NemotronAsrStreamingConfig()

>>> # Initializing a model from the configuration
>>> model = NemotronAsrStreamingForRNNT(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## NemotronAsrStreamingEncoderConfig[[transformers.NemotronAsrStreamingEncoderConfig]]

#### transformers.NemotronAsrStreamingEncoderConfig[[transformers.NemotronAsrStreamingEncoderConfig]]

```python
transformers.NemotronAsrStreamingEncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 1024, num_hidden_layers: int = 24, num_attention_heads: int = 8, intermediate_size: int = 4096, hidden_act: str = 'silu', attention_bias: bool = True, convolution_bias: bool = True, conv_kernel_size: int = 9, subsampling_factor: int = 8, subsampling_conv_channels: int = 256, num_mel_bins: int = 80, subsampling_conv_kernel_size: int = 3, subsampling_conv_stride: int = 2, dropout: float | int = 0.1, dropout_positions: float | int = 0.0, layerdrop: float | int = 0.1, activation_dropout: float | int = 0.1, attention_dropout: float | int = 0.1, max_position_embeddings: int = 5000, scale_input: bool = True, initializer_range: float = 0.02, sliding_window: int = 71, default_num_lookahead_tokens: int = 13)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/configuration_nemotron_asr_streaming.py#L31)

**Параметры:**

hidden_size (`int`, *необязательный*, по умолчанию `1024`) : Размерность скрытых представлений.

num_hidden_layers (`int`, *необязательный*, по умолчанию `24`) : Количество скрытых слоев в декодере Transformer.

num_attention_heads (`int`, *необязательный*, по умолчанию `8`) : Количество головок внимания для каждого слоя внимания в декодере Transformer.

intermediate_size (`int`, *необязательный*, по умолчанию `4096`) : Размерность представлений MLP.

hidden_act (`str`, *необязательный*, по умолчанию `silu`) : Нелинейная функция активации (функция или строка) в декодере. Например, `"gelu"`, `"relu"`, `"silu"` и т. д.

attention_bias (`bool`, *необязательный*, по умолчанию `True`) : Использовать ли смещение (bias) в слоях проекции запроса, ключа, значения и вывода при само-внимании.

convolution_bias (`bool`, *необязательный*, по умолчанию `True`) : Использовать ли смещение (bias) в свертках модуля свертки conformer.

conv_kernel_size (`int`, *optional*, по умолчанию 9) : Размер ядра свёрточных слоёв в блоке Conformer.

subsampling_factor (`int`, *optional*, по умолчанию 8) : Коэффициент, на который выполняется подвыборка входной последовательности.

subsampling_conv_channels (`int`, *необязательный*, по умолчанию 256) : Количество каналов в слоях свёртки с подвыборкой.

num_mel_bins (`int`, *optional*, по умолчанию 80) : Количество мел-признаков.

subsampling_conv_kernel_size (`int`, *optional*, по умолчанию 3) : Размер ядра для свёрточных слоёв подвыборки.

subsampling_conv_stride (`int`, *optional*, по умолчанию 2) : Шаг (stride) для свёрточных слоёв подвыборки.

dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.1`) : Доля для всех слоёв dropout.

dropout_positions (`float`, *необязательный*, по умолчанию 0.0) : Коэффициент dropout для позиций во входной последовательности.

layerdrop (`Union[float, int]`, *необязательный*, по умолчанию `0.1`) : Вероятность LayerDrop. Подробнее см. в [статье о LayerDrop](see https://huggingface.co/papers/1909.11556).

activation_dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.1`) : Коэффициент dropout для активаций внутри полносвязного слоя.

attention_dropout (`Union[float, int]`, *необязательный*, по умолчанию `0.1`) : Доля dropout для вероятностей внимания.

max_position_embeddings (`int`, *необязательный*, по умолчанию `5000`) : Максимальная длина последовательности, с которой может использоваться эта модель.

scale_input (`bool`, *необязательный*, по умолчанию `True`) : Указывает, следует ли масштабировать входные эмбеддинги.

initializer_range (`float`, *необязательный*, по умолчанию `0.02`) : Стандартное отклонение truncated_normal_initializer для инициализации всех матриц весов.

sliding_window (`int`, *optional*, по умолчанию 71) : Размер скользящего окна внимания K/V (в подвыбранных кадрах энкодера). Он равен `left_context + 1` (текущий кадр плюс левый контекст), поэтому левый контекст внимания составляет `sliding_window - 1` — одинаково для всех поддерживаемых lookaheads.

default_num_lookahead_tokens (`int`, *optional*, по умолчанию 13) : Правый контекст внимания (lookahead, в подвыбранных кадрах энкодера), используемый, если в forward ничего не передано. Поддерживаемый набор, с которым обучалась модель, находится в [NemotronAsrStreamingProcessor](/docs/transformers/v5.23.0/ru/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingProcessor).

Это класс конфигурации для хранения настроек модели NemotronAsrStreamingForRNNT. Он используется для создания модели Nemotron Asr Streaming в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации модели [nvidia/nemotron-speech-streaming-en-0.6b](https://huggingface.co/nvidia/nemotron-speech-streaming-en-0.6b)

Объекты конфигурации наследуются от [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig) и могут использоваться для управления выводами модели. Подробнее см. в документации [PreTrainedConfig](/docs/transformers/v5.23.0/ru/main_classes/configuration#transformers.PreTrainedConfig).

Пример:
```python
>>> from transformers import NemotronAsrStreamingEncoder, NemotronAsrStreamingEncoderConfig

>>> # Initializing a `NemotronAsrStreamingEncoder` configuration
>>> configuration = NemotronAsrStreamingEncoderConfig()

>>> # Initializing a model from the configuration
>>> model = NemotronAsrStreamingEncoder(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## NemotronAsrStreamingFeatureExtractor[[transformers.NemotronAsrStreamingFeatureExtractor]]

#### transformers.NemotronAsrStreamingFeatureExtractor[[transformers.NemotronAsrStreamingFeatureExtractor]]

```python
transformers.NemotronAsrStreamingFeatureExtractor(feature_size = 80, sampling_rate = 16000, hop_length = 160, n_fft = 512, win_length = 400, preemphasis = 0.97, padding_value = 0.0, mel_filters_dtype = 'float32', **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/feature_extraction_nemotron_asr_streaming.py#L40)

**Параметры:**

feature_size (`int`, *optional*, по умолчанию 80) : Размерность признаков извлекаемых фич.

sampling_rate (`int`, *optional*, по умолчанию 16000) : Частота дискретизации, с которой аудиофайлы должны быть оцифрованы, выраженная в герцах (Гц).

hop_length (`int`, *optional*, по умолчанию 160) : Длина перекрывающихся окон для STFT, используемой для получения коэффициентов Мел-частот.

n_fft (`int`, *необязательный*, по умолчанию 512) : Размер преобразования Фурье.

win_length (`int`, *optional*, по умолчанию 400) : Длина окна для вычисления STFT.

preemphasis (`float`, *optional*, по умолчанию 0.97) : Коэффициент фильтра предварительного усиления. Значение 0.0 означает отсутствие фильтра предварительного усиления.

padding_value (`float`, *optional*, по умолчанию 0.0) : Значение, используемое для дополнения аудио. Должно соответствовать тишине.

mel_filters_dtype (`str`, *необязательный*, по умолчанию `"float32"`) : Точность хранения mel-фильтров и окна STFT. Некоторые контрольные точки хранят эти константы в пониженной точности (`"bfloat16"` для Nemotron 3.5 Transcribe): при вычислении признаков фильтры и окно округляются до этого типа данных, чтобы log-mel-признаки совпадали с исходным фронтендом; при этом сама спектрограмма всегда вычисляется в float32.

Создаёт экстрактор признаков NemotronAsrStreaming.

Этот экстрактор признаков наследуется от [SequenceFeatureExtractor](/docs/transformers/v5.23.0/ru/main_classes/feature_extractor#transformers.SequenceFeatureExtractor), который содержит большинство основных методов. За дополнительной информацией о них следует обращаться к этому суперклассу.

Этот класс извлекает характеристики банка мел-фильтров из исходной речи с помощью собственной реализации `Short Time Fourier Transform` на numpy, которая должна совпадать с эквивалентом `torch.stft` в pytorch.

## NemotronAsrStreamingProcessor[[transformers.NemotronAsrStreamingProcessor]]

#### transformers.NemotronAsrStreamingProcessor[[transformers.NemotronAsrStreamingProcessor]]

```python
transformers.NemotronAsrStreamingProcessor(feature_extractor, tokenizer, blank_token = '<blank>', supported_num_lookahead_tokens = None, default_num_lookahead_tokens = None)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/processing_nemotron_asr_streaming.py#L34)

**Параметры:**

feature_extractor (`NemotronAsrStreamingFeatureExtractor`) : Извлечение признаков является обязательным входом.

tokenizer (`ParakeetTokenizer`) : Токенизатор является обязательным входным параметром.

blank_token (`str`, *необязательный*, по умолчанию `"<blank>"`) : Пустой токен для декодирования RNN-T.

supported_num_lookahead_tokens (`list[int]`, *optional*) : Контексты правого внимания (lookaheads, в подвыбранных кадрах энкодера), с которыми обучалась модель. Процессор является единственным источником истины для этого набора: `set_num_lookahead_tokens()` проверяет его. По умолчанию используется набор с учётом кэша NeMo `[13, 6, 1, 0]`.

default_num_lookahead_tokens (`int`, *необязательный*) : правый контекст, используемый для определения размера потоковых блоков и выводимый методом [__call__()](/docs/transformers/v5.23.0/ru/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingProcessor.__call__); изменяется с помощью `set_num_lookahead_tokens()`. По умолчанию — первый элемент `supported_num_lookahead_tokens`.

Создаёт NemotronAsrStreamingProcessor, который объединяет feature extractor и tokenizer в единый processor.

[NemotronAsrStreamingProcessor](/docs/transformers/v5.23.0/ru/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingProcessor) предоставляет все возможности [NemotronAsrStreamingFeatureExtractor](/docs/transformers/v5.23.0/ru/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) и [ParakeetTokenizer](/docs/transformers/v5.23.0/ru/model_doc/parakeet#transformers.ParakeetTokenizer). Подробнее см. в [~NemotronAsrStreamingFeatureExtractor](/docs/transformers/v5.23.0/ru/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) и [~ParakeetTokenizer](/docs/transformers/v5.23.0/ru/model_doc/parakeet#transformers.ParakeetTokenizer).

#### __call__[[transformers.NemotronAsrStreamingProcessor.__call__]]

```python
__call__(audio: typing.Union[numpy.ndarray, ForwardRef('torch.Tensor'), collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence['torch.Tensor']], text: str | list[str] | list[list[str]] | None = None, sampling_rate: int | None = None, is_streaming: bool = False, is_first_audio_chunk: bool | None = True, **kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/processing_nemotron_asr_streaming.py#L83)

**Параметры:**

audio (`Union[numpy.ndarray, torch.Tensor, collections.abc.Sequence[numpy.ndarray], collections.abc.Sequence[torch.Tensor]]`) : Аудио или пакет аудио, подлежащий подготовке. Каждое аудио может быть массивом NumPy или тензором PyTorch. В случае массива NumPy/тензора PyTorch каждое аудио должно иметь форму (C, T), где C — количество каналов, а T — длина выборки аудио.

text (`Union[str, list[str], list[list[str]]]`, *необязательный*) : Последовательность или батч последовательностей для кодирования. Каждая последовательность может быть строкой или списком строк (предтокенизированная строка). Если вы передаёте предтокенизированный вход, установите `is_split_into_words=True`, чтобы избежать неоднозначности с батчированными входами.

sampling_rate (`int`, *optional*) : Частота дискретизации входного аудио в Гц. Она должна совпадать с частотой дискретизации, ожидаемой экстрактором признаков (по умолчанию 16000 Гц). Если значение указано, оно проверяется на соответствие ожидаемой частоте дискретизации процессора, и при несовпадении возникает ошибка. Если значение не указано, выводится предупреждение, и предполагается частота дискретизации по умолчанию.

is_streaming (`bool`, *необязательный*, по умолчанию `False`) : Обработка аудио в потоковом режиме. Если `True`, аудио можно передавать частями, используя `is_first_audio_chunk` для различения первой части и последующих.

is_first_audio_chunk (`bool`, *необязательный*, по умолчанию `True`) : Указывает, является ли текущий аудиофрагмент первым чанком потоковой сессии. Извлекатель признаков использует `center=True` для первого чанка (а также для офлайн-обработки) и `center=False` для последующих чанков, чтобы STFT для каждого чанка воспроизводила, кадр за кадром, результат единого прохода по всей реплике. Должно быть `True`, если `is_streaming=False`.

return_mm_token_type_ids (`bool`, *kwargs*) : Нужно ли возвращать идентификаторы типов мультимодальных токенов, указывающие на позиции мультимодальных плейсхолдер-токенов.

return_text_replacement_offsets (`bool`, *kwargs*) : Нужно ли возвращать смещения символов для каждого мультимодального плейсхолдера и его замены.

return_tensors (`str` или [TensorType](/docs/transformers/v5.23.0/ru/internal/file_utils#transformers.TensorType), *optional*) : Если задано, возвращает тензоры конкретного фреймворка. Допустимые значения:  - `'pt'`: возвращает объекты `torch.Tensor` PyTorch. - `'np'`: возвращает объекты `np.ndarray` NumPy.

- ****kwargs** ([ProcessingKwargs](/docs/transformers/v5.23.0/ru/main_classes/processors#transformers.ProcessingKwargs), *optional*) : Дополнительные параметры обработки для каждой модальности (текст, изображения, видео, аудио). Специфичные для модели параметры перечислены выше; полный список поддерживаемых аргументов см. в классе TypedDict.

**Возвращает:** [BatchFeature](/docs/transformers/v5.23.0/ru/main_classes/feature_extractor#transformers.BatchFeature)

выходы feature-extractor (и, при необходимости, tokenizer), дополненные:

- **num_lookahead_tokens** -- Контекст правого внимания (lookahead, в подвыбранных кадрах энкодера), то есть `default_num_lookahead_tokens` (устанавливается через `set_num_lookahead_tokens()`). Передайте его в forward модели/энкодера (или в `generate`); он выполняет роль `num_delay_tokens` в Voxtral Realtime.

#### decode[[transformers.NemotronAsrStreamingProcessor.decode]]

```python
decode(*args, durations = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/processing_nemotron_asr_streaming.py#L166)

Передайте аргументы в [decode()](/docs/transformers/v5.23.0/ru/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) и выполните постобработку временных меток на уровне токенов (если предоставлены `durations`) по аналогии с библиотекой NeMo.

## NemotronAsrStreamingEncoderModelOutput[[transformers.NemotronAsrStreamingEncoderModelOutput]]

#### transformers.NemotronAsrStreamingEncoderModelOutput[[transformers.NemotronAsrStreamingEncoderModelOutput]]

```python
transformers.NemotronAsrStreamingEncoderModelOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, pooler_output: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, attention_mask: typing.Optional[torch.Tensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, padding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L325)

**Параметры:**

last_hidden_state (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) : Последовательность скрытых состояний на выходе последнего слоя модели.

pooler_output (`torch.Tensor` формы `(batch_size, hidden_size)`) : Скрытое состояние последнего слоя первого токена последовательности (токен классификации) после дальнейшей обработки слоями, используемыми для вспомогательной задачи предварительного обучения. Например, для моделей семейства BERT это возвращает токен классификации после обработки через линейный слой и функцию активации tanh. Веса линейного слоя обучаются по задаче предсказания следующего предложения (классификации) во время предварительного обучения.

hidden_states (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или при `config.output_hidden_states=True`) : Кортеж из `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`. Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные данные начальных встраиваний.

attentions (`tuple(torch.Tensor)`, *необязательный*, возвращается, если передано `output_attentions=True` или если `config.output_attentions=True`) : Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`. Веса внимания после softmax внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отступов после сжатия последовательности. Возвращается, так как длина последовательности может отличаться от длины входной последовательности. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.

past_key_values (`Cache`, *optional*) : Обновленный скользящий кэш K/V внимания из энкодера. Передайте в следующий вызов чанка.

padding_cache (`NemotronAsrStreamingEncoderCausalConvPaddingCache`, *необязательный*) : единый потоковый кэш, обеспечивающий работу подвыборочных слоёв Conv2d и глубинного Conv1d в блоке conformer.

Расширяет `ParakeetEncoderModelOutput` за счёт необязательных потоковых кэшей. Кэши заполняются только для моделей, поддерживающих кэширование, при `use_cache=True`.

## NemotronAsrStreamingRNNTOutput[[transformers.NemotronAsrStreamingRNNTOutput]]

#### transformers.NemotronAsrStreamingRNNTOutput[[transformers.NemotronAsrStreamingRNNTOutput]]

```python
transformers.NemotronAsrStreamingRNNTOutput(last_hidden_state: typing.Optional[torch.Tensor] = None, pooler_output: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None, loss: typing.Optional[torch.Tensor] = None, logits: typing.Optional[torch.Tensor] = None, decoder_cache: transformers.models.nemotron_asr_streaming.generation_nemotron_asr_streaming.NemotronAsrStreamingRNNTDecoderCache | None = None, encoder_past_key_values: transformers.cache_utils.Cache | None = None, padding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L1037)

encoder_past_key_values (`Cache`, *optional*): обновленный скользящий кэш K/V внимания энкодера, возвращаемый при кодировании аудио с `use_cache=True` (стриминг с учетом кэша). Передайте его в forward для следующего фрагмента. padding_cache (`NemotronAsrStreamingEncoderCausalConvPaddingCache`, *optional*): обновленный единый кэш стриминговых свертки (субсэмплирующая Conv2d + глубинная Conv1d conformer), возвращаемый при кодировании аудио с `use_cache=True`. Передайте его в forward для следующего фрагмента.

## NemotronAsrStreamingEncoder[[transformers.NemotronAsrStreamingEncoder]]

#### transformers.NemotronAsrStreamingEncoder[[transformers.NemotronAsrStreamingEncoder]]

```python
transformers.NemotronAsrStreamingEncoder(config: NemotronAsrStreamingEncoderConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L877)

**Параметры:**

config ([NemotronAsrStreamingEncoderConfig](/docs/transformers/v5.23.0/ru/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingEncoderConfig)) : класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

Модель NemotronAsrStreaming Encoder, основанная на архитектуре [Fast Conformer](https://huggingface.co/papers/2305.05084).

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.NemotronAsrStreamingEncoder.forward]]

```python
forward(input_features: Tensor, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, output_attention_mask: bool = True, use_cache: bool | None = None, padding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None, num_lookahead_tokens: int | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L900)

**Параметры:**

input_features (`torch.Tensor` формы `(batch_size, sequence_length, feature_dim)`) : Тензоры, соответствующие входным аудиособытиям. Аудиособытия можно получить с помощью `feature_extractor_class`. Подробности см. в `feature_extractor_class.__call__` (`processor_class` использует `feature_extractor_class` для обработки аудио).

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

position_ids (`torch.LongTensor` формы `(batch_size, sequence_length)`, *необязательно*) : Индексы позиций токенов каждого входного последовательности в позиционных эмбеддингах. Выбираются из диапазона `[0, config.n_positions - 1]`.  [Что такое position IDs?](../glossary#position-ids)

past_key_values (`Cache`, *optional*) : Скользящее окно K/V-кэша (`DynamicCache`, построенное на основе `config.sliding_window`) для потокового внимания с учётом кэша.

output_attention_mask (`bool`, *необязательный*, по умолчанию `True`) : Нужно ли возвращать маску внимания на выходе. Действует только при передаче `attention_mask`.

use_cache (`bool`, *необязательный*) : Если установлено в `True`, состояния ключей и значений `past_key_values` возвращаются и могут использоваться для ускорения декодирования (см. `past_key_values`).

padding_cache (`NemotronAsrStreamingEncoderCausalConvPaddingCache`, *необязательный*) : единый потоковый кэш, обеспечивающий работу подвыборочных слоёв Conv2d и глубинного Conv1d в блоке conformer.

num_lookahead_tokens (`int`, *optional*) : Переопределение правого контекста внимания (lookahead, в кадрах кодировщика с подвыборкой) для этого прохода. Сочетается с левым контекстом `config.sliding_window - 1`. По умолчанию `config.default_num_lookahead_tokens`.

**Возвращает:** [BaseModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutput) или `tuple(torch.Tensor)`

[BaseModelOutput](/docs/transformers/v5.23.0/ru/main_classes/output#transformers.modeling_outputs.BaseModelOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации (`None`) и входных данных.

Метод forward класса [NemotronAsrStreamingEncoder](/docs/transformers/v5.23.0/ru/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingEncoder) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **last_hidden_state** (`torch.Tensor` формы `(batch_size, sequence_length, hidden_size)`) -- Последовательность скрытых состояний на выходе последнего слоя модели.
- **hidden_states** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_hidden_states=True` или когда `config.output_hidden_states=True`) -- Кортеж `torch.Tensor` (один для вывода слоя встраиваний, если модель имеет слой встраиваний, + один для вывода каждого слоя) формы `(batch_size, sequence_length, hidden_size)`.

  Скрытые состояния модели на выходе каждого слоя, а также необязательные выходные значения начального слоя встраивания.
- **attentions** (`tuple(torch.Tensor)`, *необязательный*, возвращается при передаче `output_attentions=True` или при `config.output_attentions=True`) -- Кортеж `torch.Tensor` (по одному на каждый слой) формы `(batch_size, num_heads, sequence_length, sequence_length)`.

  Веса внимания после softmax в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

Пример:

```python
>>> from transformers import AutoProcessor, NemotronAsrStreamingEncoder
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/nemotron-speech-streaming-en-0.6b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> encoder = NemotronAsrStreamingEncoder.from_pretrained(model_id)

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))

>>> inputs = processor(ds[0]["audio"]["array"])
>>> encoder_outputs = encoder(**inputs)

>>> print(encoder_outputs.last_hidden_state.shape)
```

## NemotronAsrStreamingForRNNT[[transformers.NemotronAsrStreamingForRNNT]]

#### transformers.NemotronAsrStreamingForRNNT[[transformers.NemotronAsrStreamingForRNNT]]

```python
transformers.NemotronAsrStreamingForRNNT(config: NemotronAsrStreamingConfig)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L1126)

**Параметры:**

config ([NemotronAsrStreamingConfig](/docs/transformers/v5.23.0/ru/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingConfig)) : класс конфигурации модели со всеми параметрами модели. Инициализация с файлом конфигурации не загружает веса, связанные с моделью, только конфигурацию. Используйте метод [from_pretrained()](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained) для загрузки весов модели.

NemotronAsrStreaming Encoder с головой RNN-T (Recurrent Neural Network Transducer).

Эта модель наследуется от [PreTrainedModel](/docs/transformers/v5.23.0/ru/main_classes/model#transformers.PreTrainedModel). Общие методы, которые библиотека реализует для всех своих моделей (например, загрузка или сохранение, изменение размера входных эмбеддингов, обрезка головок и т. д.), описаны в документации родительского класса.

Эта модель также является подклассом [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) в PyTorch. Используйте её как обычный модуль PyTorch и обращайтесь к документации PyTorch по всем вопросам, связанным с общим использованием и поведением.

#### forward[[transformers.NemotronAsrStreamingForRNNT.forward]]

```python
forward(input_features: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, decoder_input_ids: typing.Optional[torch.LongTensor] = None, decoder_cache: transformers.models.nemotron_asr_streaming.generation_nemotron_asr_streaming.NemotronAsrStreamingRNNTDecoderCache | None = None, use_decoder_cache: bool | None = None, encoder_outputs: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderModelOutput | None = None, labels: typing.Optional[torch.Tensor] = None, num_lookahead_tokens: int | None = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/modeling_nemotron_asr_streaming.py#L1156)

**Параметры:**

input_features (`torch.Tensor` формы `(batch_size, sequence_length, feature_dim)`, *необязательно*) : Тензоры, соответствующие входным аудиособытиям. Аудиособытия можно получить с помощью `feature_extractor_class`. Подробности см. в `feature_extractor_class.__call__` (`processor_class` использует `feature_extractor_class` для обработки аудио).

attention_mask (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Маска для предотвращения применения внимания к индексам токенов отсечки. Значения маски выбираются из `[0, 1]`:  - 1 для токенов, которые **не замаскированы**, - 0 для токенов, которые **замаскированы**.  [Что такое маски внимания?](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor` формы `(batch_size, 1)`, *необязательный*) : Идентификаторы входных токенов декодера для одношагового вывода.

decoder_cache (`NemotronAsrStreamingRNNTDecoderCache`, *необязательный*) : Кэш LSTM декодера. Переиспользуется при предсказании пустых токенов для пропуска шага LSTM.

use_decoder_cache (`bool`, *необязательный*) : Нужно ли выделять и использовать кэш декодера, если он не предоставлен.

encoder_outputs (`NemotronAsrStreamingEncoderModelOutput`, *необязательный*) : Предварительно вычисленные выходные данные энкодера (last_hidden_state, pooler_output, ...).

labels (`torch.Tensor` формы `(batch_size, sequence_length)`, *необязательный*) : Метки для вычисления потерь маскированного языкового моделирования. Индексы должны находиться в диапазоне `[0, ..., config.vocab_size]` или равняться -100 (см. docstring `input_ids`). Токены с индексами, установленными в `-100`, игнорируются (маскируются); потери вычисляются только для токенов с метками в диапазоне `[0, ..., config.vocab_size]`.

num_lookahead_tokens (`int`, *optional*) : Контекст правого внимания (lookahead, в подвыбранных кадрах энкодера), передаваемый в энкодер. По умолчанию `config.encoder_config.default_num_lookahead_tokens`.

**Возвращает:** [NemotronAsrStreamingRNNTOutput](/docs/transformers/v5.23.0/ru/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingRNNTOutput) или `tuple(torch.Tensor)`

Объект [NemotronAsrStreamingRNNTOutput](/docs/transformers/v5.23.0/ru/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingRNNTOutput) или кортеж `torch.Tensor` (если передано `return_dict=False` или если `config.return_dict=False`), содержащий различные элементы в зависимости от конфигурации (`None`) и входных данных.

Метод forward класса [NemotronAsrStreamingForRNNT](/docs/transformers/v5.23.0/ru/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingForRNNT) переопределяет специальный метод `__call__`.

Хотя рецепт для прямого прохода должен быть определён внутри этой функции, после этого следует вызывать экземпляр `Module`, а не эту функцию, поскольку первый выполняет шаги предварительной и постобработки, тогда как второй молча их игнорирует.

- **encoder_past_key_values** (`Cache`, *необязательный*) -- Обновлённый скользящий кэш K/V внимания энкодера, возвращаемый при кодировании аудио с `use_cache=True` (стриминг с учётом кэша). Передайте его в forward для следующего фрагмента.
- **padding_cache** (`NemotronAsrStreamingEncoderCausalConvPaddingCache`, *optional*) -- Обновлённый единый кэш стриминговых свёрток (субсэмплирование Conv2d + глубинные свёртки Conv1d в conformer), возвращается при кодировании аудио с `use_cache=True`. Передайте его в forward для следующего фрагмента.

Пример:

```python
>>> from transformers import AutoProcessor, NemotronAsrStreamingForRNNT
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/nemotron-speech-streaming-en-0.6b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = NemotronAsrStreamingForRNNT.from_pretrained(model_id)

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.cast_column("audio", Audio(sampling_rate=processor.feature_extractor.sampling_rate))

>>> inputs = processor(ds[0]["audio"]["array"])
>>> outputs = model(**inputs)
```

#### generate[[transformers.NemotronAsrStreamingForRNNT.generate]]

```python
generate(inputs = None, generation_config = None, **kwargs)
```

[Источник](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/models/nemotron_asr_streaming/generation_nemotron_asr_streaming.py#L212)

