# Nemotron 3.5 ASR

## Обзор

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

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

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

```python
from transformers import pipeline

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

> [!NOTE]
> Пайплайн использует подсказку по умолчанию для языка (индекс 0, `en-US`). Для явного указания языка или автоматического определения передайте аргумент `language` процессора (см. вкладку AutoModel).

Языковой промпт создаётся процессором, поэтому язык передаётся вместе с входными данными в `generate`.

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

model_id = "nvidia/nemotron-3.5-asr-streaming-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,
)

# Condition on a known language ...
inputs = processor(audio, sampling_rate=processor.feature_extractor.sampling_rate, language="en-US")
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))

# ... or let the model detect it and keep the emitted <xx-XX> language tag.
inputs = processor(audio, sampling_rate=processor.feature_extractor.sampling_rate) # equiv to ..., language="auto"
inputs.to(model.device, dtype=model.dtype)
output = model.generate(**inputs, return_dict_in_generate=True)
print(processor.decode(output.sequences, skip_special_tokens=False))
```

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

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

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

model_id = "nvidia/nemotron-3.5-asr-streaming-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")

# The language prompt rides along on every chunk; use a locale (e.g. "de-DE") or "auto".
language = "en-US"

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,
    language=language,
    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,
            language=language,
            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-3.5-asr-streaming-0.6b")

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

# 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` будет выброшено исключение, если этот параметр опущен.

## Nemotron3_5AsrConfig[[transformers.Nemotron3_5AsrConfig]]

#### transformers.Nemotron3_5AsrConfig[[transformers.Nemotron3_5AsrConfig]]

```python
transformers.Nemotron3_5AsrConfig(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 = 13088, 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 = 13087, num_prompts: int = 128, prompt_intermediate_size: int = 2048, default_prompt_id: int = 101)
```

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

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

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

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

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

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

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

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

encoder_config (`Union[dict, NemotronAsrStreamingEncoderConfig]`, *необязательный*) : Объект конфигурации или словарь для энкодера. Непосредственно переиспользует [NemotronAsrStreamingEncoderConfig](/docs/transformers/v5.23.0/ru/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingEncoderConfig), поскольку энкодер идентичен энкодеру `NemotronAsrStreaming`.

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

blank_token_id (`int`, *optional*, по умолчанию 13087) : Идентификатор пустого токена для декодирования RNN-T.

num_prompts (`int`, *optional*, по умолчанию 128) : Количество слотов языкового промпта. Целевой язык кодируется в виде one-hot вектора данного размера, который распространяется вдоль временной оси энкодера и конкатенируется с выходом энкодера перед слиянием в MLP `prompt_kernel`.

prompt_intermediate_size (`int`, *необязательный*, по умолчанию 2048) : Размер скрытого слоя слияния MLP `prompt_kernel` (`Linear(hidden + num_prompts -> intermediate) -> ReLU -> Linear(intermediate -> hidden)`).

default_prompt_id (`int`, *optional*, по умолчанию 101) : Индекс промпта, используемый для обусловливания модели, если `prompt_ids` не передан. По умолчанию используется слот автоматического определения языка `auto` (индекс 101 в словаре промптов NeMo), что соответствует значению по умолчанию в NeMo `target_lang="auto"`: модель сама определяет язык и выводит тег `<xx-XX>`.

Это класс конфигурации для хранения настроек модели Nemotron3_5AsrForRNNT. Он используется для создания модели Nemotron 3.5 Asr в соответствии с указанными аргументами, определяя архитектуру модели. Создание конфигурации с параметрами по умолчанию даст конфигурацию, аналогичную конфигурации модели [nvidia/nemotron-3.5-asr-streaming-0.6b](https://huggingface.co/nvidia/nemotron-3.5-asr-streaming-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 Nemotron3_5AsrForRNNT, Nemotron3_5AsrConfig

>>> configuration = Nemotron3_5AsrConfig()
>>> model = Nemotron3_5AsrForRNNT(configuration)
>>> configuration = model.config
```

## Nemotron3_5AsrProcessor[[transformers.Nemotron3_5AsrProcessor]]

#### transformers.Nemotron3_5AsrProcessor[[transformers.Nemotron3_5AsrProcessor]]

```python
transformers.Nemotron3_5AsrProcessor(feature_extractor, tokenizer, blank_token = '<blank>', decoder_type = None, supported_num_lookahead_tokens = None, default_num_lookahead_tokens = None, prompt_dictionary = None, num_prompts = 128)
```

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

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

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

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

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

decoder_type (`str`, *необязательный*) : Режим декодирования/генерации временных меток (например, `"ctc"`, `"rnnt"`, `"tdt"`). Если `None`, тип декодера определяется автоматически для обратной совместимости.

supported_num_lookahead_tokens (`list[int]`, *необязательный*) : Поддерживаемые контексты правого внимания (lookahead, в кадрах кодировщика с подвыборкой), аналогично `NemotronAsrStreamingEncoderConfig.supported_num_lookahead_tokens`. Используется для проверки `streaming_latency_ms` и для определения возвращаемого `num_lookahead_tokens`.

default_num_lookahead_tokens (`int`, *optional*) : Правый контекст, используемый, если `streaming_latency_ms` не задан. По умолчанию — первый элемент `supported_num_lookahead_tokens`.

prompt_dictionary (`dict[str, int]`, *необязательный*) : Соответствие между строкой целевого языка (например, `"en-US"`, `"de-DE"`, просто код `"de"` или `"auto"`) и индексом его промпта. По умолчанию используется словарь промптов из контрольной точки NeMo.

num_prompts (`int`, *optional*, по умолчанию 128) : Количество слотов языкового промпта (размер вектора one-hot промпта), отражает `Nemotron3_5AsrConfig.num_prompts`.

Создаёт Nemotron3_5AsrProcessor, который объединяет экстрактор признаков и токенизатор в единый процессор.

[Nemotron3_5AsrProcessor](/docs/transformers/v5.23.0/ru/model_doc/nemotron3_5_asr#transformers.Nemotron3_5AsrProcessor) предоставляет все возможности [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).

#### decode[[transformers.Nemotron3_5AsrProcessor.decode]]

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

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

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

#### set_num_lookahead_tokens[[transformers.Nemotron3_5AsrProcessor.set_num_lookahead_tokens]]

```python
set_num_lookahead_tokens(num_lookahead_tokens: int)
```

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

Выберите правильный контекст внимания (lookahead, в подвыбранных кадрах энкодера), используемый для потоковой обработки.

Устанавливает `default_num_lookahead_tokens`, в результате чего каждое производное свойство потоковой обработки (`num_mel_frames_first_audio_chunk`, `num_mel_frames_per_audio_chunk`, `num_samples_first_audio_chunk`, `num_samples_per_audio_chunk`) пересчитывается на основе нового значения. `num_lookahead_tokens` должно быть одним из значений `supported_num_lookahead_tokens`.

Передавайте то же значение `num_lookahead_tokens` в `model.generate`, чтобы правый контекст внимания, используемый в прямом проходе, соответствовал размерам блоков, сгенерированным здесь; в противном случае потоковый `generate` вызовет ошибку.

## Nemotron3_5AsrRNNTOutput[[transformers.Nemotron3_5AsrRNNTOutput]]

#### transformers.Nemotron3_5AsrRNNTOutput[[transformers.Nemotron3_5AsrRNNTOutput]]

```python
transformers.Nemotron3_5AsrRNNTOutput(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.nemotron3_5_asr.generation_nemotron3_5_asr.Nemotron3_5AsrRNNTDecoderCache | None = None, encoder_past_key_values: transformers.cache_utils.Cache | None = None, padding_cache: NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None)
```

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

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

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 внимания, используемые для вычисления взвешенного среднего в головах само-внимания.

loss (`torch.Tensor`, *необязательный*, возвращается, если задан `labels`) : Потеря транскрибтера RNN-T.

logits (`torch.Tensor` формы `(batch_size, encoder_length, decoder_length, vocab_size + 1)`) : Оценки совместной сети по словарю плюс символ blank для каждой пары кадров энкодера/декодера.

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

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

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

## Nemotron3_5AsrForRNNT[[transformers.Nemotron3_5AsrForRNNT]]

#### transformers.Nemotron3_5AsrForRNNT[[transformers.Nemotron3_5AsrForRNNT]]

```python
transformers.Nemotron3_5AsrForRNNT(config: Nemotron3_5AsrConfig)
```

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

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

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

Nemotron3_5Asr Encoder с головой RNN-T (Recurrent Neural Network Transducer) и условным настраиванием по промпту языка-ID.

Эта модель наследуется от [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.Nemotron3_5AsrForRNNT.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.nemotron3_5_asr.generation_nemotron3_5_asr.Nemotron3_5AsrRNNTDecoderCache | None = None, use_decoder_cache: bool | None = None, encoder_outputs: transformers.modeling_outputs.BaseModelOutputWithPooling | None = None, labels: typing.Optional[torch.Tensor] = None, num_lookahead_tokens: int | None = None, prompt_ids: typing.Optional[torch.LongTensor] = None, **kwargs: *<class 'transformers.utils.generic.TransformersKwargs'>)
```

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

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

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 (`Nemotron3_5AsrRNNTDecoderCache`, *необязательный*) : Кэш LSTM декодера. Переиспользуется при пустых предсказаниях, чтобы пропустить шаг LSTM.

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

encoder_outputs (`tuple(torch.Tensor)`, *необязательный*) : Предварительно вычисленные выходные данные кодировщика (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`.

prompt_ids (`torch.LongTensor` формы `(batch_size,)`, *необязательный*) : Индексы языкового промпта для условного кодирования по идентификатору языка. Формируются процессором из `language`. Преобразуются в одногорный вектор (one-hot) для широковещательной передачи, который потребляется `prompt_projector`.

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

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

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

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

- **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 в механизме внимания, используемые для вычисления взвешенного среднего в головах само-внимания.
- **loss** (`torch.Tensor`, *необязательный*, возвращается, если задан `labels`) -- Потеря транскрибатора RNN-T.
- **logits** (`torch.Tensor` формы `(batch_size, encoder_length, decoder_length, vocab_size + 1)`) -- Оценки совместной сети по словарю плюс символ blank для каждой пары кадров энкодера/декодера.
- **decoder_cache** (`Nemotron3_5AsrRNNTDecoderCache`, *optional*) -- Обновленный кэш LSTM декодера. Переиспользуется при предсказании пустых токенов для пропуска шага LSTM.
- **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, Nemotron3_5AsrForRNNT
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/nemotron-3.5-asr-streaming-0.6b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = Nemotron3_5AsrForRNNT.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"], language="en-US")
>>> outputs = model(**inputs)
```

#### generate[[transformers.Nemotron3_5AsrForRNNT.generate]]

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

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

