Transformers documentation

Nemotron ASR 流式

Transformers

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

该模型于 2023-05-08 在 HF papers 上发布，并于 2026-06-18 贡献至 Hugging Face Transformers。

Nemotron ASR 流式

概述

Nemotron ASR Streaming 是 NVIDIA 推出的 6 亿参数英语语音识别模型，专为低延迟流式和高吞吐批量场景下的高质量转录而构建，并原生支持标点符号和大小写。在流式处理方面，它提供可配置的块大小——80ms、160ms、560ms 和 1120ms，允许用户根据应用需求在延迟与准确性之间进行权衡。其缓存感知的 FastConformer-RNNT 架构是这一能力的核心：与反复重新处理重叠音频窗口的传统缓冲式流式处理不同，该模型仅处理每个新到达的块，同时复用来自先前块的缓存编码器上下文。这消除了冗余计算，显著提升了效率，并在不牺牲准确性的前提下将端到端延迟降至最低，使其非常适合实时转录工作负载。

用法

离线转录

Pipeline

AutoModel

流式转录

这是一个实验性功能，API 可能会发生变化。

对于实时转录，音频将按照以下规则分块：

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 决定，即每个块在输出前等待的右侧注意力上下文（在子采样编码器帧中的前瞻）。较大的值使每个块能看到更多的未来音频：以更高的延迟为代价换取更高的准确性。查看支持的权衡选项，选择其中一个，并读取由此产生的延迟：

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

class transformers.NemotronAsrStreamingConfig

< source >

参数

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) — 空白 token 的 id。在 RNN-T 中，它与 pad_token_id 不同。

这是用于存储 NemotronAsrStreamingForRNNT 配置的类。它根据指定的参数实例化 Nemotron Asr Streaming 模型，并定义模型架构。使用默认值实例化配置将得到与 nvidia/nemotron-speech-streaming-en-0.6b 类似的配置。

配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。

示例：

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

class transformers.NemotronAsrStreamingEncoderConfig

< source >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 1024num_hidden_layers: int = 24num_attention_heads: int = 8intermediate_size: int = 4096hidden_act: str = 'silu'attention_bias: bool = Trueconvolution_bias: bool = Trueconv_kernel_size: int = 9subsampling_factor: int = 8subsampling_conv_channels: int = 256num_mel_bins: int = 80subsampling_conv_kernel_size: int = 3subsampling_conv_stride: int = 2dropout: float | int = 0.1dropout_positions: float | int = 0.0layerdrop: float | int = 0.1activation_dropout: float | int = 0.1attention_dropout: float | int = 0.1max_position_embeddings: int = 5000scale_input: bool = Trueinitializer_range: float = 0.02sliding_window: int = 71default_num_lookahead_tokens: int = 13 )

参数

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) — Mel 特征的数量。
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 论文](参见 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 未传入时，所使用的右侧注意力上下文（即子采样编码器帧中的 lookahead）。模型训练时支持的集合位于 NemotronAsrStreamingProcessor 上。

配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。

示例：

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

class transformers.NemotronAsrStreamingFeatureExtractor

< source >

( feature_size = 80sampling_rate = 16000hop_length = 160n_fft = 512win_length = 400preemphasis = 0.97padding_value = 0.0mel_filters_dtype = 'float32'**kwargs )

参数

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") — 存储的 mel 滤波器组和 STFT 窗口的精度。某些检查点会以较低精度保存这些常量（例如 Nemotron 3.5 Transcribe 使用 "bfloat16"）：在计算特征时，滤波器组和窗口会被舍入到该 dtype，从而使对数 mel 特征与原始前端保持一致；而频谱图本身始终在 float32 下计算。

构建 NemotronAsrStreaming 特征提取器。

该特征提取器继承自 SequenceFeatureExtractor，其中包含了大部分主要方法。用户应参考该父类以获取有关这些方法的更多信息。

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

NemotronAsrStreamingProcessor

class transformers.NemotronAsrStreamingProcessor

< source >

( feature_extractortokenizerblank_token = '<blank>'supported_num_lookahead_tokens = Nonedefault_num_lookahead_tokens = None )

参数

feature_extractor（NemotronAsrStreamingFeatureExtractor）— 特征提取器是必需的输入。
tokenizer（ParakeetTokenizer）— 分词器是必需的输入。
blank_token (str，可选，默认为 "<blank>") — 用于 RNN-T 解码的空白标记。
supported_num_lookahead_tokens (list[int]，可选) — 模型训练时使用的右侧注意力上下文（即子采样编码器帧中的 lookahead）。处理器是该集合的唯一权威来源：set_num_lookahead_tokens() 会依据该集合进行验证。默认值为 NeMo 缓存感知集合 [13, 6, 1, 0]。
default_num_lookahead_tokens (int, 可选) — 用于确定流式块大小的右侧上下文，并由 call() 输出；可通过 set_num_lookahead_tokens() 进行修改。默认值为 supported_num_lookahead_tokens 中的第一个条目。

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

NemotronAsrStreamingProcessor 提供了 NemotronAsrStreamingFeatureExtractor 和 ParakeetTokenizer 的所有功能。有关更多信息，请参阅 ~NemotronAsrStreamingFeatureExtractor 和 ~ParakeetTokenizer。

call

< source >

( 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 = Nonesampling_rate: int | None = Noneis_streaming: bool = Falseis_first_audio_chunk: bool | None = True**kwargs: *<class 'transformers.processing_utils.ProcessingKwargs'> ) → BatchFeature

参数

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, 可选) — 如果设置，将返回特定框架的张量。可接受的值为：
- 'pt'：返回 PyTorch torch.Tensor 对象。
- 'np'：返回 NumPy np.ndarray 对象。
**kwargs (ProcessingKwargs，可选) — 每种模态（文本、图像、视频、音频）的额外处理选项。模型特定参数已在上方列出；有关支持参数的完整列表，请参阅 TypedDict 类。

返回值

BatchFeature

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

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

decode

< source >

( *argsdurations = None**kwargs )

将参数传递给 decode()，并像 NeMo 库那样对 token 级时间戳进行后处理（如果提供了 durations）。

NemotronAsrStreamingEncoderModelOutput

class transformers.NemotronAsrStreamingEncoderModelOutput

< source >

( last_hidden_state: typing.Optional[torch.Tensor] = Nonepooler_output: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = Noneattention_mask: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonepadding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None )

参数

last_hidden_state (torch.Tensor，形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。
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]:
- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
past_key_values (Cache，可选) — 来自编码器的已更新注意力 K/V 滑动窗口缓存。请将其传递给下一个分块调用。
padding_cache (NemotronAsrStreamingEncoderCausalConvPaddingCache，可选) — 为子采样 Conv2d 层和 conformer 深度可分离 Conv1d 提供支持的统一流式缓存。

扩展了 ParakeetEncoderModelOutput，并支持可选的流式缓存。仅当 use_cache=True 时，才会为支持缓存的模型填充缓存。

NemotronAsrStreamingRNNTOutput

class transformers.NemotronAsrStreamingRNNTOutput

< source >

( last_hidden_state: typing.Optional[torch.Tensor] = Nonepooler_output: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = Noneloss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonedecoder_cache: transformers.models.nemotron_asr_streaming.generation_nemotron_asr_streaming.NemotronAsrStreamingRNNTDecoderCache | None = Noneencoder_past_key_values: transformers.cache_utils.Cache | None = Nonepadding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = None )

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

NemotronAsrStreamingEncoder

class transformers.NemotronAsrStreamingEncoder

< source >

( config: NemotronAsrStreamingEncoderConfig )

参数

config (NemotronAsrStreamingEncoderConfig) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

基于 Fast Conformer 架构的 NemotronAsrStreaming Encoder 模型。

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< source >

( input_features: Tensorattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneoutput_attention_mask: bool = Trueuse_cache: bool | None = Nonepadding_cache: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderCausalConvPaddingCache | None = Nonenum_lookahead_tokens: int | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutput or tuple(torch.Tensor)

参数

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), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自 [0, 1]:
- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
什么是注意力掩码？
position_ids (torch.LongTensor 形状为 (batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 [0, config.n_positions - 1].
什么是位置 ID？
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 或 tuple(torch.Tensor)

一个 BaseModelOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（None）和输入。

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 之后的权重，用于在自注意力头中计算加权平均值。

示例：

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

class transformers.NemotronAsrStreamingForRNNT

< source >

( config: NemotronAsrStreamingConfig )

参数

config (NemotronAsrStreamingConfig) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

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

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< source >

( input_features: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_cache: transformers.models.nemotron_asr_streaming.generation_nemotron_asr_streaming.NemotronAsrStreamingRNNTDecoderCache | None = Noneuse_decoder_cache: bool | None = Noneencoder_outputs: transformers.models.nemotron_asr_streaming.modeling_nemotron_asr_streaming.NemotronAsrStreamingEncoderModelOutput | None = Nonelabels: typing.Optional[torch.Tensor] = Nonenum_lookahead_tokens: int | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → NemotronAsrStreamingRNNTOutput or tuple(torch.Tensor)

参数

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), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自 [0, 1]:
- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
什么是注意力掩码？
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（形状为 (batch_size, sequence_length) 的 torch.Tensor，可选）— 用于计算掩码语言建模损失的标签。索引值应在 [0, ..., config.vocab_size] 范围内，或为 -100（参见 input_ids 的文档字符串）。索引值设为 -100 的 token 将被忽略（即被掩码），损失仅针对标签位于 [0, ..., config.vocab_size] 范围内的 token 进行计算。
num_lookahead_tokens (int, 可选) — 转发给编码器的右侧注意力上下文（前瞻，以子采样编码器帧为单位）。默认值为 config.encoder_config.default_num_lookahead_tokens。

返回值

NemotronAsrStreamingRNNTOutput 或 tuple(torch.Tensor)

一个 NemotronAsrStreamingRNNTOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或当 config.return_dict=False 时），包含根据配置（None）和输入而定的各种元素。

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 调用中。

示例：

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

< source >

( inputs = Nonegeneration_config = None**kwargs )

Update on GitHub

←Nemotron 3.5 Transcribe NeuCodec→