# Nemotron ASR 流式

## 概述

Nemotron ASR Streaming 是 NVIDIA 推出的 6 亿参数英语语音识别模型，专为低延迟流式和高吞吐批量场景下的高质量转录而构建，并原生支持标点符号和大小写。在流式处理方面，它提供可配置的块大小——80ms、160ms、560ms 和 1120ms，允许用户根据应用需求在延迟与准确性之间进行权衡。其缓存感知的 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` 决定，即每个块在输出前等待的右侧注意力上下文（在子采样编码器帧中的前瞻）。较大的值使每个块能看到更多的未来音频：以更高的延迟为代价换取更高的准确性。查看支持的权衡选项，选择其中一个，并读取由此产生的延迟：

```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` 可以表示的不同 token 的数量。

decoder_hidden_size (`int`, *可选*，默认为 640)：LSTM 预测网络的隐藏层大小（NeMo 的 `pred_hidden`）。联合网络将编码器和解码器的输出都投影到该大小（NeMo 的 `joint_hidden`，所有已知检查点均将其设置为与 `pred_hidden` 相等）。

num_decoder_layers (`int`，*可选*，默认为 2)：预测网络中 LSTM 层的数量。

hidden_act (`str`，*可选*，默认为 `"relu"`)：联合网络中的激活函数。

max_symbols_per_step (`int`，*可选*，默认为 10)：在贪心解码期间，每个编码器时间步输出的非空白符号的最大数量。

encoder_config (`Union[dict, NemotronAsrStreamingEncoderConfig]`, *可选*) : 编码器的配置对象或字典。

pad_token_id (`int`，*可选*，默认为 `0`)：词表中用于填充的 Token ID。

blank_token_id (`int`，*可选*，默认为 1024)：空白标记 ID。在 RNN-T 中，它与 `pad_token_id` 不同。

这是用于存储 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/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/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`)：是否在使用自注意力机制时，在查询、键、值和输出投影层中使用偏置。

convolution_bias (`bool`，*可选*，默认为 `True`)：是否在 Conformer 的卷积模块中使用偏置。

conv_kernel_size (`int`，*可选*，默认为 9)：Conformer 块中卷积层的卷积核大小。

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 (`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`, *可选*，默认为 71)：K/V 注意力滑动窗口的大小（以子采样编码器帧为单位）。它等于 `left_context + 1`（当前帧加上左侧上下文），因此左侧注意力上下文为 `sliding_window - 1` —— 在所有支持的 lookahead 中均相同。

default_num_lookahead_tokens (`int`, *可选*，默认为 13)：当 forward 未传入时，所使用的右侧注意力上下文（前瞻，以子采样编码器帧为单位）。模型训练时支持的集合位于 [NemotronAsrStreamingProcessor](/docs/transformers/v5.23.0/zh/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/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/v5.23.0/zh/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`，*可选*，默认为 80)：提取特征的维度。

sampling_rate (`int`，*可选*，默认值为 16000)：音频文件应被数字化采样的采样率，单位为赫兹（Hz）。

hop_length (`int`, *可选*，默认为 160)：用于获取梅尔频率系数的 STFT 的重叠窗口长度。

n_fft (`int`，*可选*，默认为 512)：傅里叶变换的大小。

win_length (`int`，*可选*，默认为 400)：STFT 计算的窗口长度。

preemphasis (`float`, *可选*，默认为 0.97)：预加重滤波器系数。0.0 表示不使用预加重滤波器。

padding_value (`float`, *可选*, 默认值为 0.0) : 用于填充音频的填充值。应对应静音。

mel_filters_dtype (`str`, *可选*，默认为 `"float32"`)：存储的梅尔滤波器组和 STFT 窗口的精度。某些检查点会以较低精度（例如 Nemotron 3.5 Transcribe 使用 `"bfloat16"`）保存这些常量：在计算特征时，滤波器组和窗口会被舍入到该数据类型，从而使对数梅尔特征与原始前端保持一致；而频谱图本身始终在 float32 下计算。

构建 NemotronAsrStreaming 特征提取器。

此特征提取器继承自 [SequenceFeatureExtractor](/docs/transformers/v5.23.0/zh/main_classes/feature_extractor#transformers.SequenceFeatureExtractor)，后者包含了大部分主要方法。有关这些方法的更多信息，请参阅该父类。

此类使用自定义的 numpy 实现的`Short Time Fourier Transform`从原始语音中提取 mel 滤波器组特征，其结果应与 pytorch 的`torch.stft`等效。

## 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]`, *可选*) : 模型训练时使用的右侧注意力上下文（在子采样编码器帧中的前瞻）。处理器是该集合的唯一可信来源：`set_num_lookahead_tokens()` 会对其进行验证。默认值为 NeMo 缓存感知集合 `[13, 6, 1, 0]`。

default_num_lookahead_tokens (`int`, *可选*) : 用于确定流式块大小并由 [__call__()](/docs/transformers/v5.23.0/zh/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingProcessor.__call__) 输出的右侧上下文；可通过 `set_num_lookahead_tokens()` 进行修改。默认值为 `supported_num_lookahead_tokens` 的第一个条目。

构造一个 NemotronAsrStreamingProcessor，它将特征提取器和分词器封装为单个处理器。

[NemotronAsrStreamingProcessor](/docs/transformers/v5.23.0/zh/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingProcessor) 提供了 [NemotronAsrStreamingFeatureExtractor](/docs/transformers/v5.23.0/zh/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) 和 [ParakeetTokenizer](/docs/transformers/v5.23.0/zh/model_doc/parakeet#transformers.ParakeetTokenizer) 的所有功能。有关更多信息，请参阅 [~NemotronAsrStreamingFeatureExtractor](/docs/transformers/v5.23.0/zh/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingFeatureExtractor) 和 [~ParakeetTokenizer](/docs/transformers/v5.23.0/zh/model_doc/parakeet#transformers.ParakeetTokenizer)。

#### __调用__[[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`, *可选*) : 输入音频的采样率，单位为 Hz。此值应与特征提取器预期的采样率一致（默认为 16000 Hz）。如果提供了该值，将与处理器的预期采样率进行验证，若不一致则引发错误。如果未提供，则会发出警告并假定使用默认采样率。

is_streaming (`bool`，*可选*，默认为 `False`)：是否以流式模式处理音频。当为 `True` 时，可以分块传入音频，并使用 `is_first_audio_chunk` 来区分第一个块与后续的块。

is_first_audio_chunk (`bool`, *可选*，默认为 `True`) : 当前音频是否为流式会话的第一个数据块。特征提取器对第一个数据块（以及离线使用场景）使用 `center=True`，对后续数据块使用 `center=False`，从而确保每个数据块的 STFT 逐帧复现单次完整语音处理的结果。当 `is_streaming=False` 时，此参数必须为 `True`。

return_mm_token_type_ids (`bool`, *kwargs*) : 是否返回多模态 token 类型 ID，以指示多模态占位符 token 的位置。

return_text_replacement_offsets (`bool`, *kwargs*) : 是否返回每个多模态占位符及其替换项的字符偏移量。

return_tensors (`str` 或 [TensorType](/docs/transformers/v5.23.0/zh/internal/file_utils#transformers.TensorType)，*可选*)：如果设置，将返回特定框架的张量。可接受的值为： - `'pt'`：返回 PyTorch `torch.Tensor` 对象。 - `'np'`：返回 NumPy `np.ndarray` 对象。

- ****kwargs** ([ProcessingKwargs](/docs/transformers/v5.23.0/zh/main_classes/processors#transformers.ProcessingKwargs), *可选*) : 针对每种模态（文本、图像、视频、音频）的额外处理选项。模型特定参数已在上方列出；有关支持参数的完整列表，请参阅 TypedDict 类。

**返回：** [BatchFeature](/docs/transformers/v5.23.0/zh/main_classes/feature_extractor#transformers.BatchFeature)

特征提取器（以及可选的分词器）的输出，并补充以下内容：

- **num_lookahead_tokens** -- 右侧注意力上下文（在子采样编码器帧中的前瞻），即 `default_num_lookahead_tokens`（通过 `set_num_lookahead_tokens()` 设置）。将其传递给模型/编码器的前向传播（或 `generate`）；它起到 Voxtral Realtime 中 `num_delay_tokens` 的作用。

#### 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/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode)，并像 NeMo 库那样对 token 级时间戳进行后处理（如果提供了 `durations`）。

## 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 （形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`）：模型最后一层输出的隐藏状态序列。

pooler_output (`torch.Tensor`，形状为 `(batch_size, hidden_size)`)：序列中第一个 token（分类 token）的最后一层隐藏状态，经过用于辅助预训练任务的层进一步处理后得到。例如，对于 BERT 系列模型，这返回的是分类 token 经过线性层和 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)`，*可选*)：用于在序列压缩后避免对填充 token 索引执行注意力机制的掩码。由于序列长度可能与输入序列长度不同，因此会返回此掩码。`[0, 1]` 中选择的掩码值： - 对于**未掩码**的 token，值为 1； - 对于**已掩码**的 token，值为 0。

past_key_values (`Cache`, *可选*) : 来自编码器的更新后的注意力 K/V 滑动窗口缓存。将其传递给下一个块调用。

padding_cache (`NemotronAsrStreamingEncoderCausalConvPaddingCache`，*可选*)：为子采样 Conv2d 层和 conformer 深度可分离 Conv1d 提供支持的统一流式缓存。

扩展了 `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`, *可选*): 更新后的编码器注意力 K/V 滑动窗口缓存，在使用 `use_cache=True` 编码音频时返回（支持缓存的流式处理）。将其传递给下一个数据块的 forward。padding_cache (`NemotronAsrStreamingEncoderCausalConvPaddingCache`, *可选*): 更新后的统一流式卷积缓存（下采样 Conv2d + conformer 深度可分离 Conv1d），在使用 `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/zh/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingEncoderConfig)) : 模型配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

基于 [Fast Conformer 架构](https://huggingface.co/papers/2305.05084) 的 NemotronAsrStreaming Encoder 模型。

该模型继承自 [PreTrainedModel](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 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)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

position_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.n_positions - 1]`。[什么是位置 ID？](../glossary#position-ids)

past_key_values (`Cache`, *可选*) : 用于缓存感知流式注意力的滑动窗口 K/V 缓存（由 `config.sliding_window` 构建的 `DynamicCache`）。

output_attention_mask (`bool`，*可选*，默认为 `True`)：是否返回输出的注意力掩码。仅在提供 `attention_mask` 时有效。

use_cache (`bool`，*可选*)：如果设置为 `True`，则会返回 `past_key_values` 键值状态，可用于加速解码（参见 `past_key_values`）。

padding_cache (`NemotronAsrStreamingEncoderCausalConvPaddingCache`，*可选*)：为子采样 Conv2d 层和 conformer 深度可分离 Conv1d 提供支持的统一流式缓存。

num_lookahead_tokens (`int`, *可选*) : 本次前向传播中右侧注意力上下文（子采样编码器帧中的前瞻）的覆盖值。与左侧上下文 `config.sliding_window - 1` 结合使用。默认值为 `config.default_num_lookahead_tokens`。

**返回：** [BaseModelOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutput) 或 `tuple(torch.Tensor)`

一个 [BaseModelOutput](/docs/transformers/v5.23.0/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（`None`）和输入。

[NemotronAsrStreamingEncoder](/docs/transformers/v5.23.0/zh/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingEncoder) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`）-- 模型最后一层输出的隐藏状态序列。
- **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/zh/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingConfig))：模型配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

NemotronAsrStreaming 编码器，带有 RNN-T（循环神经网络转换器）头。

该模型继承自 [PreTrainedModel](/docs/transformers/v5.23.0/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 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)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

decoder_input_ids (`torch.LongTensor`，形状为 `(batch_size, 1)`，*可选*)：用于单步推理的解码器输入 token id。

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（参见 `input_ids` 的文档字符串）。索引设置为 `-100` 的令牌将被忽略（掩码），损失仅针对标签在 `[0, ..., config.vocab_size]` 范围内的令牌进行计算。

num_lookahead_tokens (`int`, *可选*) : 转发给编码器的右侧注意力上下文（前瞻，位于子采样编码器帧中）。默认值为 `config.encoder_config.default_num_lookahead_tokens`。

**返回：** [NemotronAsrStreamingRNNTOutput](/docs/transformers/v5.23.0/zh/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingRNNTOutput) 或 `tuple(torch.Tensor)`

一个 [NemotronAsrStreamingRNNTOutput](/docs/transformers/v5.23.0/zh/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingRNNTOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或当 `config.return_dict=False` 时），其包含的元素取决于配置（`None`）和输入。

[NemotronAsrStreamingForRNNT](/docs/transformers/v5.23.0/zh/model_doc/nemotron_asr_streaming#transformers.NemotronAsrStreamingForRNNT) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **encoder_past_key_values**（`Cache`，*可选*）-- 更新后的编码器注意力 K/V 滑动窗口缓存，在使用 `use_cache=True` 对音频进行编码时返回（支持缓存的流式处理）。请将其传递给下一个数据块的 forward。
- **padding_cache**（`NemotronAsrStreamingEncoderCausalConvPaddingCache`，*可选*）-- 更新后的统一流式卷积缓存（子采样 Conv2d + conformer 深度可分离 Conv1d），在编码音频且 `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)

