Transformers documentation
Nemotron ASR 流式
该模型于 2023-05-08 在 HF papers 上发布，并于 2026-06-18 贡献至 Hugging Face Transformers。
Nemotron ASR 流式
概述
Nemotron ASR Streaming 是 NVIDIA 推出的 6 亿参数英语语音识别模型，专为低延迟流式和高吞吐批量场景下的高质量转录而构建，并原生支持标点符号和大小写。在流式处理方面，它提供可配置的块大小——80ms、160ms、560ms 和 1120ms，允许用户根据应用需求在延迟与准确性之间进行权衡。其缓存感知的 FastConformer-RNNT 架构是这一能力的核心：与反复重新处理重叠音频窗口的传统缓冲式流式处理不同，该模型仅处理每个新到达的块，同时复用来自先前块的缓存编码器上下文。这消除了冗余计算，显著提升了效率，并在不牺牲准确性的前提下将端到端延迟降至最低，使其非常适合实时转录工作负载。
用法
离线转录
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)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))流式转录
这是一个实验性功能，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)
# 560set_num_lookahead_tokens 用于确定处理器输出的块大小，而对应的 num_lookahead_tokens 必须传递到 generate（在上面的代码片段中，它通过 **inputs/**first_chunk_inputs 传递，其中包含 num_lookahead_tokens）。流式 generate 在省略该参数时会抛出异常。
NemotronAsrStreamingConfig
class transformers.NemotronAsrStreamingConfig
< 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 = 0id2label: 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 = Noneis_encoder_decoder: bool = Truevocab_size: int = 1025decoder_hidden_size: int = 640num_decoder_layers: int = 2hidden_act: str = 'relu'max_symbols_per_step: int = 10encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonepad_token_id: int = 0blank_token_id: int = 1024 )
参数
- 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.configNemotronAsrStreamingEncoderConfig
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 上。
这是用于存储 NemotronAsrStreamingForRNNT 配置的类。它根据指定的参数实例化 Nemotron Asr Streaming 模型，并定义模型架构。使用默认值实例化配置将得到与 nvidia/nemotron-speech-streaming-en-0.6b 类似的配置。
配置对象继承自 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.configNemotronAsrStreamingFeatureExtractor
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'：返回 PyTorchtorch.Tensor对象。'np'：返回 NumPynp.ndarray对象。
- **kwargs (ProcessingKwargs，可选) — 每种模态（文本、图像、视频、音频）的额外处理选项。模型特定参数已在上方列出；有关支持参数的完整列表，请参阅 TypedDict 类。
返回值
特征提取器（以及可选的分词器）的输出，并补充以下内容：
- num_lookahead_tokens — 右侧注意力上下文（在子采样编码器帧中的前瞻），
即
default_num_lookahead_tokens（通过set_num_lookahead_tokens()设置）。 将其传递给模型/编码器的前向传播（或generate）；它的作用相当于 Voxtral Realtime 的num_delay_tokens。
将参数传递给 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]. - 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)