Hugging Face's logo

Transformers documentation

Parakeet

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

该模型于 2025-09-25 贡献至 Hugging Face Transformers。

SDPA

Parakeet

概述

Parakeet 模型由 NVIDIA NeMo 推出，是一种将 Fast Conformer 编码器与连接主义时间分类（CTC）、循环神经网络转换器（RNNT）或令牌及时长转换器（TDT）解码器相结合的自动语音识别模型。

模型架构

  • Fast Conformer Encoder：一种线性可扩展的 Conformer 架构，用于处理 mel 频谱图特征，并通过下采样来缩短序列长度。这是 FastSpeech2Conformer 中 Conformer Encoder 的更高效版本（有关编码器的实现和详细信息，请参阅 ParakeetEncoder）。
  • ParakeetForCTC: Fast Conformer 编码器 + CTC 解码器
    • CTC Decoder: 一个简单但高效的解码器，包含：
      • 从编码器隐藏维度到词汇表大小的 1D 卷积投影（以实现最佳的 NeMo 兼容性）。
      • 用于训练的 CTC 损失计算。
      • 用于推理的贪心 CTC 解码。
  • ParakeetForRNNT: Fast Conformer 编码器 + RNN-T（RNN Transducer）解码器
    • RNN-T Decoder: 标准神经转换器：
      • LSTM 预测网络在 token 预测过程中保持语言上下文。
      • 联合网络将编码器和解码器的输出进行组合。
      • 用于推理的贪心转导器解码：一个空白（blank）发射使编码器帧前进一帧，而非空白发射则停留在当前帧。
  • ParakeetForTDT: Fast Conformer 编码器 + TDT（Token Duration Transducer）解码器
    • TDT Decoder: 联合预测 token 及其持续时间，从而实现高效解码：
      • LSTM 预测网络在 token 预测过程中保持语言上下文。
      • 联合网络将编码器和解码器的输出进行组合。
      • Duration head 预测需要跳过的帧数，从而实现快速推理。

原始实现可在 NVIDIA NeMo 中找到。 模型检查点位于 NVIDIA 组织 下。

该模型由 Nithin Rao Koluguri、Eustache Le Bihan、Eric Bezzam、Maksym Lypivskyi 和 Hainan Xu 贡献。

用法

ParakeetForCTC 的用法

Pipeline
AutoModel
from transformers import pipeline


pipe = pipeline("automatic-speech-recognition", model="nvidia/parakeet-ctc-1.1b")
out = pipe("https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3")
print(out)
# {'text': 'yesterday it was thirty five degrees in barcelona but today the temperature will go down to minus twenty degrees'}

ParakeetForRNNT 的用法

Pipeline
AutoModel
时间戳

Parakeet RNN-T 的转录结果不包含大小写或标点符号（与 CTC 类似），并且该模型还可以执行 token 时间戳标注。

from transformers import pipeline

pipe = pipeline("automatic-speech-recognition", model="nvidia/parakeet-rnnt-0.6b", revision="refs/pr/4")
out = pipe("https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3")
print(out)
# {'text': 'yesterday it was thirty five degrees in barcelona but today the temperature will go down to minus twenty degrees'}

ParakeetForTDT 的用法

Pipeline
AutoModel
时间戳

Parakeet TDT 转录文本包含大小写信息，并且该模型还可以执行 token 时间戳标注。

from transformers import pipeline

pipe = pipeline("automatic-speech-recognition", model="nvidia/parakeet-tdt-0.6b-v3")
out = pipe("https://huggingface.co/datasets/hf-internal-testing/dummy-audio-samples/resolve/main/bcn_weather.mp3")
print(out)
# {'text': 'Yesterday it was 35 degrees in Barcelona, but today the temperature will go down to minus 20 degrees.'}

让模型飞速运转

Parakeet 支持基于图捕获（在 NVIDIA GPU 上为 CUDA graphs，在其他加速器上为等效机制）的完整图编译！当您知道要转录的音频最大长度时，此优化效果最佳。其核心思想是使用静态输入形状以避免重新编译。例如，如果您知道音频时长不超过 30 秒，可以使用 processor 将所有输入填充至 30 秒，从而准备一致的输入特征和 attention masks。请参见下方示例！

import torch
from datasets import Audio, load_dataset

from transformers import AutoModelForCTC, AutoProcessor


processor = AutoProcessor.from_pretrained("nvidia/parakeet-ctc-1.1b")
model = AutoModelForCTC.from_pretrained("nvidia/parakeet-ctc-1.1b", device_map="auto")

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))
speech_samples = [el['array'] for el in ds["audio"][:5]]

# Compile the generate method with fullgraph and graph capture
model.generate = torch.compile(model.generate, fullgraph=True, mode="reduce-overhead")

# let's define processor kwargs to pad to 30 seconds
processor_kwargs = {
    "padding": "max_length",
    "max_length": 30 * processor.feature_extractor.sampling_rate,
}

# Define a timing context using accelerator events
class TimerContext:
    def __init__(self, name="Execution"):
        self.name = name
        self.start_event = None
        self.end_event = None

    def __enter__(self):
        # Use accelerator events for more accurate device timing
        self.start_event = torch.Event(enable_timing=True)
        self.end_event = torch.Event(enable_timing=True)
        self.start_event.record()
        return self

    def __exit__(self, *args):
        self.end_event.record()
        torch.accelerator.synchronize()
        elapsed_time = self.start_event.elapsed_time(self.end_event) / 1000.0
        print(f"{self.name} time: {elapsed_time:.4f} seconds")


inputs = processor(speech_samples[0], **processor_kwargs)
inputs.to(model.device, dtype=model.dtype)
print("\n" + "="*50)
print("First generation - compiling...")
# Generate with the compiled model
with TimerContext("First generation"):
    outputs = model.generate(**inputs)
print(processor.decode(outputs))

inputs = processor(speech_samples[1], **processor_kwargs)
inputs.to(model.device, dtype=model.dtype)
print("\n" + "="*50)
print("Second generation - recording graphs...")
with TimerContext("Second generation"):
    outputs = model.generate(**inputs)
print(processor.decode(outputs))

inputs = processor(speech_samples[2], **processor_kwargs)
inputs.to(model.device, dtype=model.dtype)
print("\n" + "="*50)
print("Third generation - fast !!!")
with TimerContext("Third generation"):
    outputs = model.generate(**inputs)
print(processor.decode(outputs))

inputs = processor(speech_samples[3], **processor_kwargs)
inputs.to(model.device, dtype=model.dtype)
print("\n" + "="*50)
print("Fourth generation - still fast !!!")
with TimerContext("Fourth generation"):
    outputs = model.generate(**inputs)
print(processor.decode(outputs))

CTC 训练

from datasets import Audio, load_dataset
from transformers import AutoModelForCTC, AutoProcessor

model_id = "nvidia/parakeet-ctc-1.1b"
NUM_SAMPLES = 5

processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForCTC.from_pretrained(model_id, device_map="auto")
model.train()

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))
speech_samples = [el['array'] for el in ds["audio"][:NUM_SAMPLES]]
text_samples = ds["text"][:NUM_SAMPLES]

# passing `text` to the processor will prepare inputs' `labels` key
inputs = processor(audio=speech_samples, text=text_samples, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(model.device, dtype=model.dtype)

outputs = model(**inputs)
print("Loss:", outputs.loss.item())
outputs.loss.backward()

RNN-T 训练

计算 RNN-T 损失需要 torchaudio（pip install torchaudio）。

from datasets import Audio, load_dataset
import torch
from transformers import AutoModelForRNNT, AutoProcessor

model_id = "nvidia/parakeet-rnnt-0.6b"
revision = "refs/pr/4"
NUM_SAMPLES = 4

processor = AutoProcessor.from_pretrained(model_id, revision=revision)
model = AutoModelForRNNT.from_pretrained(model_id, revision=revision,  device_map="auto")
model.train()

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))
speech_samples = [el['array'] for el in ds["audio"][:NUM_SAMPLES]]
text_samples = ds["text"][:NUM_SAMPLES]

# passing `text` to the processor will prepare inputs' `labels` key
inputs = processor(audio=speech_samples, text=text_samples, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(model.device, dtype=model.dtype)

outputs = model(**inputs)
print("Loss:", outputs.loss.item())
outputs.loss.backward()

TDT 训练

from datasets import Audio, load_dataset
import torch
from transformers import AutoModelForTDT, AutoProcessor

model_id = "nvidia/parakeet-tdt-0.6b-v3"
NUM_SAMPLES = 4

processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForTDT.from_pretrained(model_id, device_map="auto")
model.train()

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))
speech_samples = [el['array'] for el in ds["audio"][:NUM_SAMPLES]]
text_samples = ds["text"][:NUM_SAMPLES]

# passing `text` to the processor will prepare inputs' `labels` key
inputs = processor(audio=speech_samples, text=text_samples, sampling_rate=processor.feature_extractor.sampling_rate)
inputs.to(model.device, dtype=model.dtype)

outputs = model(**inputs)
print("Loss:", outputs.loss.item())
outputs.loss.backward()

ParakeetTokenizer

class transformers.ParakeetTokenizer

< >

( *args**kwargs )

继承自 PreTrainedTokenizerFast 的所有方法。有关这些方法的更多信息，用户应参考该父类， 但 _decode 除外，该方法已被重写以适应 CTC 解码：

  1. 将连续标记分组
  2. 过滤掉空白标记

ParakeetFeatureExtractor

class transformers.ParakeetFeatureExtractor

< >

( feature_size = 80sampling_rate = 16000hop_length = 160n_fft = 512win_length = 400preemphasis = 0.97padding_value = 0.0**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) — 用于填充音频的填充值。该值应对应静音。

构建 Parakeet 特征提取器。

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

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

__call__

< >

( raw_speech: numpy.ndarray | list[float] | list[numpy.ndarray] | list[list[float]]truncation: bool = Falsepad_to_multiple_of: int | None = Nonereturn_tensors: str | transformers.utils.generic.TensorType | None = Nonereturn_attention_mask: bool | None = Nonepadding: str | None = 'longest'max_length: int | None = Nonesampling_rate: int | None = Nonedo_normalize: bool | None = Nonedevice: str | None = 'cpu'return_token_timestamps: bool | None = None**kwargs )

参数

  • raw_speech (np.ndarray、list[float]、list[np.ndarray]、list[list[float]]) — 需要填充的序列或序列批次。每个序列可以是 numpy 数组、浮点值列表、numpy 数组列表或浮点值列表的列表。必须是单声道音频，而非立体声，即每个时间步对应一个浮点数。
  • truncation（bool，可选，默认为 True）— 启用截断，将长度超过 max_length 的输入序列截断为 max_length。
  • pad_to_multiple_of (int, 可选, ，默认为 None）— 如果设置，则将序列填充为所提供值的倍数。

    这在启用 NVIDIA 硬件（计算能力 >= 7.5，即 Volta 架构）上的 Tensor Cores 使用时尤为有用，或者在 TPU 上使用时也特别有益，因为 TPU 在序列长度为 128 的倍数时性能更佳。

  • return_attention_mask (bool, 可选) — 是否返回注意力掩码。如果保持默认值，则会根据特定 feature_extractor 的默认设置返回注意力掩码。

    什么是注意力掩码？

    对于 Parakeet 模型，在进行批量推理时，始终应传入 attention_mask，以避免出现细微的 bug。

  • return_tensors (str 或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：
    • 'tf'：返回 TensorFlow tf.constant 对象。
    • 'pt'：返回 PyTorch torch.Tensor 对象。
    • 'np'：返回 Numpy np.ndarray 对象。
  • sampling_rate (int, 可选) — raw_speech 输入所使用的采样率。强烈建议在 forward 调用时传入 sampling_rate，以避免静默错误并支持自动语音识别流水线。
  • padding_value (float，可选，默认为 0.0) — 用于填充 padding 值/向量的数值。
  • do_normalize (bool，可选，默认为 False) — 是否对输入进行零均值单位方差归一化。归一化可以显著提升模型性能。
  • device (str，可选，默认为 'cpu') — 指定在 _torch_extract_fbank_features 方法中计算音频信号的 log-mel 频谱图时所使用的设备。（例如，“cpu”、“cuda”）
  • return_token_timestamps (bool, 可选, 默认值为 None) — 已弃用。请改用 return_attention_mask ，从中可以推断出帧数。

    是否返回输入 raw_speech 的帧数。 这些 num_frames 可供模型用于计算词级时间戳。

用于对一条或多条序列进行特征化并准备输入模型的主要方法。如果可用，实现会使用 PyTorch 进行 STFT 计算，否则使用较慢的基于 NumPy 的实现。

ParakeetProcessor

class transformers.ParakeetProcessor

< >

( feature_extractortokenizerblank_token = '<blank>'decoder_type = None )

参数

  • feature_extractor (feature_extractor_class) — 特征提取器是必需的输入。
  • tokenizer (tokenizer_class) — 分词器是必需的输入。
  • blank_token (str，可选，默认为 "<blank>") — 用于 transducer 解码的空白标记。
  • decoder_type (str, 可选) — 解码/时间戳输出模式。可能的值：
    • "ctc"：连续的相同 token 会被合并为一次输出。
    • "rnnt"：保留重复的 token；每个 token 获得 1 帧的时间戳跨度。
    • "tdt"：保留重复的 token；每个 token 片段基于其预测的时长。标点符号附加在前一个 token 上。

    如果为 None（旧版检查点），则会自动推断解码器类型，以保持向后兼容性。

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

ParakeetProcessor 提供了 feature_extractor_class 和 tokenizer_class 的所有功能。有关更多信息，请参阅 ~feature_extractor_class 和 ~tokenizer_class。

__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 = Nonesampling_rate: int | None = None**kwargs: *<class 'transformers.models.parakeet.processing_parakeet.ParakeetProcessorKwargs'> )

参数

  • 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）。如果提供了该参数，则会将其与处理器所期望的采样率进行校验，若两者不匹配则抛出错误。如果未提供，则会发出警告并假定使用默认采样率。
  • return_tensors (str 或 TensorType, 可选) — 如果设置，将返回特定框架的张量。可接受的值为：
    • 'pt'：返回 PyTorch torch.Tensor 对象。
    • 'np'：返回 NumPy np.ndarray 对象。
  • **kwargs (ProcessingKwargs，可选) — 每种模态（文本、图像、视频、音频）的额外处理选项。模型特定参数已在上方列出；有关支持参数的完整列表，请参阅 TypedDict 类。

decode

< >

( *argsdurations = None**kwargs )

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

ParakeetEncoderConfig

class transformers.ParakeetEncoderConfig

< >

( 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.02 )

参数

  • 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 的标准差。

这是用于存储 ParakeetModel 配置的类。它根据指定的参数实例化 Parakeet 模型，并定义模型架构。使用默认值实例化配置将生成与 nvidia/parakeet-ctc-1.1b 类似的配置。

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

示例：

>>> from transformers import ParakeetEncoderModel, ParakeetEncoderConfig

>>> # Initializing a `ParakeetEncoder` configuration
>>> configuration = ParakeetEncoderConfig()

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

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

ParakeetCTCConfig

class transformers.ParakeetCTCConfig

< >

( 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 = Nonevocab_size: int = 1025ctc_loss_reduction: str = 'mean'ctc_zero_infinity: bool = Trueencoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonepad_token_id: int | None = 1024 )

参数

  • vocab_size (int，可选，默认为 1025) — 模型的词汇表大小。定义了 input_ids 可以表示的不同 token 数量。
  • ctc_loss_reduction (str，可选，默认为 "mean") — 指定应用于 torch.nn.CTCLoss 输出的归约方式。仅在训练 ParakeetForCTC 实例时相关。
  • ctc_zero_infinity (bool，可选，默认为 True) — 是否将 torch.nn.CTCLoss 的无穷大损失及其相关梯度置零。无穷大损失主要出现在输入过短、无法与目标对齐的情况下。仅在训练 ParakeetForCTC 实例时相关。
  • encoder_config (Union[dict, ParakeetEncoderConfig]，可选) — 编码器的配置对象或字典。
  • pad_token_id (int，可选，默认为 1024) — 词表中用于填充的 token id。

这是用于存储 ParakeetModel 配置的类。它根据指定的参数实例化 Parakeet 模型，并定义模型架构。使用默认值实例化配置将生成与 nvidia/parakeet-ctc-1.1b 类似的配置。

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

示例：

>>> from transformers import ParakeetForCTC, ParakeetCTCConfig
>>> # Initializing a Parakeet configuration
>>> configuration = ParakeetCTCConfig()
>>> # Initializing a model from the configuration
>>> model = ParakeetForCTC(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

ParakeetRNNTConfig

class transformers.ParakeetRNNTConfig

< >

( 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 = 8193decoder_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 = 2blank_token_id: int = 8192 )

参数

  • is_encoder_decoder (bool，可选，默认为 True) — 指示该模型是否用作编码器/解码器。
  • vocab_size (int，可选，默认为 8193) — 模型的词汇表大小。定义了 input_ids 可以表示的不同 token 数量。
  • decoder_hidden_size (int, 可选，默认为 640) — LSTM 预测网络和联合网络的隐藏层大小。
  • num_decoder_layers (int，可选，默认为 2) — 预测网络中 LSTM 层的数量。
  • hidden_act (str，可选，默认为 relu) — 解码器中的非线性激活函数（函数或字符串）。例如，"gelu"、 "relu"、"silu" 等。
  • max_symbols_per_step (int，可选，默认为 10) — 在贪心解码期间，每个编码器时间步长输出的最大符号数。
  • encoder_config (Union[dict, ParakeetEncoderConfig]，可选) — 编码器的配置对象或字典。
  • pad_token_id (int，可选，默认为 2) — 词表中用于填充的 token id。
  • blank_token_id (int，可选，默认为 8192) — 空白标记 ID。对于 RNN-T，它与 pad_token_id 不同。

这是用于存储 ParakeetModel 配置的类。它根据指定的参数实例化 Parakeet 模型，并定义模型架构。使用默认值实例化配置，将得到与 nvidia/parakeet-rnnt-0.6b 类似的配置。

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

示例：

>>> from transformers import ParakeetForRNNT, ParakeetRNNTConfig

>>> # Initializing a Parakeet RNN-T configuration
>>> configuration = ParakeetRNNTConfig()

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

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

ParakeetTDTConfig

class transformers.ParakeetTDTConfig

< >

( 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 = 8193decoder_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 = 2blank_token_id: int = 8192durations: list[int] | tuple[int, ...] = (0, 1, 2, 3, 4) )

参数

  • is_encoder_decoder (bool，可选，默认为 True) — 指示该模型是否用作编码器/解码器。
  • vocab_size (int，可选，默认为 8193) — 模型的词汇表大小。定义了 input_ids 可以表示的不同 token 数量。
  • decoder_hidden_size (int, 可选，默认为 640) — LSTM 预测网络和联合网络的隐藏层大小。
  • num_decoder_layers (int，可选，默认为 2) — 预测网络中 LSTM 层的数量。
  • hidden_act (str，可选，默认为 relu) — 解码器中的非线性激活函数（函数或字符串）。例如，"gelu"、 "relu"、"silu" 等。
  • max_symbols_per_step (int，可选，默认为 10) — 在贪心解码期间，每个编码器时间步长输出的最大符号数。
  • encoder_config (Union[dict, ParakeetEncoderConfig]，可选) — 编码器的配置对象或字典。
  • pad_token_id (int，可选，默认为 2) — 词表中用于填充的 token id。
  • blank_token_id（int，可选，默认值为 8192）— 空白 token 的 id。在 TDT 中，它与 pad_token_id 不同。
  • durations (list[int]，可选，默认为 [0, 1, 2, 3, 4]) — 可预测的 Token 时长值。每个值表示一个 token 或 blank 发射所跨越的帧数。

这是用于存储 ParakeetModel 配置的类。它根据指定的参数实例化 Parakeet 模型，并定义模型架构。使用默认值实例化配置将生成与 nvidia/parakeet-tdt-0.6b-v3 类似的配置。

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

示例：

>>> from transformers import ParakeetForTDT, ParakeetTDTConfig

>>> # Initializing a Parakeet TDT configuration
>>> configuration = ParakeetTDTConfig()

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

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

ParakeetEncoder

class transformers.ParakeetEncoder

< >

( config: ParakeetEncoderConfig )

参数

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

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

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

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

forward

< >

( input_features: Tensorattention_mask: typing.Optional[torch.Tensor] = Noneoutput_attention_mask: bool = True**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。

    什么是注意力掩码？

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

返回值

BaseModelOutput 或 tuple(torch.Tensor)

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

ParakeetEncoder 的 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, ParakeetEncoder
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/parakeet-ctc-1.1b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> encoder = ParakeetEncoder.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)

ParakeetForCTC

class transformers.ParakeetForCTC

< >

( config: ParakeetCTCConfig )

参数

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

带有连接主义时间分类（CTC）头的 Parakeet 编码器。

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

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

forward

< >

( input_features: Tensorattention_mask: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → CausalLMOutput 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。

    什么是注意力掩码？

  • labels（形状为 (batch_size, sequence_length) 的 torch.Tensor，可选）— 用于计算掩码语言建模损失的标签。索引值应在 [0, ..., config.vocab_size] 范围内，或为 -100（参见 input_ids 的文档字符串）。索引值设为 -100 的 token 将被忽略（即被掩码），损失仅针对标签位于 [0, ..., config.vocab_size] 范围内的 token 进行计算。

返回值

CausalLMOutput 或 tuple(torch.Tensor)

torch.Tensor 的元组，或 CausalLMOutput（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（None）和输入。

ParakeetForCTC 的 forward 方法重写了 __call__ 特殊方法。

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

  • loss (torch.Tensor，形状为 (1,)，可选，当提供 labels 时返回) — 语言建模损失（用于下一个 token 预测）。

  • logits（形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.Tensor）— 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。

  • 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, ParakeetForCTC
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/parakeet-ctc-1.1b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = ParakeetForCTC.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"], text=ds[0]["text"])
>>> outputs = model(**inputs)

>>> print(outputs.loss)

generate

< >

( input_features: Tensorattention_mask: typing.Optional[torch.Tensor] = Nonereturn_dict_in_generate: bool = Falsecompile_config: transformers.generation.configuration_utils.CompileConfig | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> )

compile_config (CompileConfig, 可选)： 如果提供，torch.compile 将应用于解码循环中的前向调用。

示例：

>>> from transformers import AutoProcessor, ParakeetForCTC
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/parakeet-ctc-1.1b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = ParakeetForCTC.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"], text=ds[0]["text"])
>>> predicted_ids = model.generate(**inputs)
>>> transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)

>>> print(transcription)

ParakeetForRNNT

class transformers.ParakeetForRNNT

< >

( config: ParakeetRNNTConfig )

参数

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

带有 RNN-T（RNN Transducer）头的 Parakeet Encoder。

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

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

forward

< >

( input_features: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_cache: transformers.models.parakeet.generation_parakeet.ParakeetRNNTDecoderCache | None = Noneuse_decoder_cache: bool | None = Noneencoder_outputs: transformers.models.parakeet.modeling_parakeet.ParakeetEncoderModelOutput | tuple[torch.Tensor] | None = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → ParakeetRNNTOutput 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 (ParakeetRNNTDecoderCache, 可选) — 解码器 LSTM 缓存。当提供且已初始化时，将复用缓存的 decoder_output（例如在跳过空白时），而不是运行解码器。当提供 input_ids 时，解码器会运行，并且缓存会被就地更新。
  • use_decoder_cache (bool, 可选) — 是否使用解码器缓存。当 True 且 decoder_cache 为 None 时，会在前向传播过程中自动创建一个新的缓存。
  • encoder_outputs (tuple(torch.Tensor), 可选) — 预计算的编码器输出 (last_hidden_state, pooler_output, hidden_states, attentions, attention_mask)。 可以是元组或 ParakeetEncoderModelOutput。
  • labels（形状为 (batch_size, sequence_length) 的 torch.Tensor，可选）— 用于计算掩码语言建模损失的标签。索引值应在 [0, ..., config.vocab_size] 范围内，或为 -100（参见 input_ids 的文档字符串）。索引值设为 -100 的 token 将被忽略（即被掩码），损失仅针对标签位于 [0, ..., config.vocab_size] 范围内的 token 进行计算。

返回值

ParakeetRNNTOutput 或 tuple(torch.Tensor)

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

ParakeetForRNNT 的 forward 方法重写了 __call__ 特殊方法。

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

  • loss (torch.Tensor, 可选) — RNN-T 损失，在提供 labels 时返回。
  • logits (torch.Tensor) — 联合 token logits。训练时形状为 (batch, T, U+1, vocab)，单步推理时为 (batch, 1, 1, vocab)。
  • decoder_cache (ParakeetRNNTDecoderCache，可选) — 解码器 LSTM 缓存，包含隐藏状态、细胞状态和最后一次输出。

示例：

>>> from transformers import AutoProcessor, ParakeetForRNNT
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/parakeet-rnnt-0.6b"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = ParakeetForRNNT.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)

ParakeetForTDT

class transformers.ParakeetForTDT

< >

( config: ParakeetTDTConfig )

参数

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

带有 TDT（Token Duration Transducer，令牌时长转换器）头的 Parakeet Encoder。

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

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

forward

< >

( input_features: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_cache: transformers.models.parakeet.generation_parakeet.ParakeetRNNTDecoderCache | None = Noneuse_decoder_cache: bool | None = Noneencoder_outputs: transformers.models.parakeet.modeling_parakeet.ParakeetEncoderModelOutput | tuple[torch.Tensor] | None = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → ParakeetRNNTOutput 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 (ParakeetRNNTDecoderCache, 可选) — 解码器 LSTM 缓存。当提供且已初始化时，将复用缓存的 decoder_output（例如在跳过空白时），而不是运行解码器。当提供 input_ids 时，解码器会运行，并且缓存会被就地更新。
  • use_decoder_cache (bool, 可选) — 是否使用解码器缓存。当 True 且 decoder_cache 为 None 时，会在前向传播过程中自动创建一个新的缓存。
  • encoder_outputs (tuple(torch.Tensor), 可选) — 预计算的编码器输出 (last_hidden_state, pooler_output, hidden_states, attentions, attention_mask)。 可以是元组或 ParakeetEncoderModelOutput。
  • labels（形状为 (batch_size, sequence_length) 的 torch.Tensor，可选）— 用于计算掩码语言建模损失的标签。索引值应在 [0, ..., config.vocab_size] 范围内，或为 -100（参见 input_ids 的文档字符串）。索引值设为 -100 的 token 将被忽略（即被掩码），损失仅针对标签位于 [0, ..., config.vocab_size] 范围内的 token 进行计算。

返回值

ParakeetRNNTOutput 或 tuple(torch.Tensor)

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

ParakeetForTDT 的 forward 方法重写了 __call__ 特殊方法。

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

  • loss (torch.Tensor, 可选) — RNN-T 损失，在提供 labels 时返回。
  • logits (torch.Tensor) — 联合 token logits。训练时形状为 (batch, T, U+1, vocab)，单步推理时为 (batch, 1, 1, vocab)。
  • decoder_cache (ParakeetRNNTDecoderCache，可选) — 解码器 LSTM 缓存，包含隐藏状态、细胞状态和最后一次输出。

示例：

>>> from transformers import AutoProcessor, ParakeetForTDT
>>> from datasets import load_dataset, Audio

>>> model_id = "nvidia/parakeet-tdt-0.6b-v3"
>>> processor = AutoProcessor.from_pretrained(model_id)
>>> model = ParakeetForTDT.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)
Update on GitHub

←NeuCodec PE 音频→