Hugging Face 的 LOGO

Transformers 文档

Whisper

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

PyTorch TensorFlow Flax FlashAttention SDPA

Whisper

Whisper 是一个在 68 万小时带标签的音频数据上预训练的编码器-解码器 (sequence-to-sequence) transformer 模型。如此大量的预训练数据使其能够在英语和许多其他语言的音频任务上实现零样本性能。解码器允许 Whisper 将编码器学习到的语音表示映射到有用的输出，例如文本，而无需额外的微调。Whisper 可以开箱即用。

你可以在 Whisper 合集中找到所有原始的 Whisper checkpoints。

[!NOTE] 当使用除“eager”之外的所有注意力实现时，`head_mask` 参数会被忽略。如果你有 `head_mask` 并希望它生效，请使用 `XXXModel.from_pretrained(model_id, attn_implementation="eager")` 加载模型。

点击右侧边栏中的 Whisper 模型，查看更多关于如何将 Whisper 应用于不同音频任务的示例。

下面的示例演示了如何使用 Pipeline 或 AutoModel 类将语音自动转录为文本。

流水线
自动模型
import torch
from transformers import pipeline

pipeline = pipeline(
    task="automatic-speech-recognition",
    model="openai/whisper-large-v3-turbo",
    torch_dtype=torch.float16,
    device=0
)
pipeline("https://huggingface.co/datasets/Narsil/asr_dummy/resolve/main/mlk.flac")

注意

  • Whisper 依赖一个自定义的 `generate` 方法进行推理，请务必查看下面的文档。
  • WhisperProcessor 可用于准备音频数据并将预测的 ID 解码回文本。

WhisperConfig

class transformers.WhisperConfig

< >

( vocab_size = 51865 num_mel_bins = 80 encoder_layers = 4 encoder_attention_heads = 6 decoder_layers = 4 decoder_attention_heads = 6 decoder_ffn_dim = 1536 encoder_ffn_dim = 1536 encoder_layerdrop = 0.0 decoder_layerdrop = 0.0 decoder_start_token_id = 50257 use_cache = True is_encoder_decoder = True activation_function = 'gelu' d_model = 384 dropout = 0.0 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 scale_embedding = False max_source_positions = 1500 max_target_positions = 448 pad_token_id = 50256 bos_token_id = 50256 eos_token_id = 50256 suppress_tokens = None begin_suppress_tokens = [220, 50256] use_weighted_layer_sum = False classifier_proj_size = 256 apply_spec_augment = False mask_time_prob = 0.05 mask_time_length = 10 mask_time_min_masks = 2 mask_feature_prob = 0.0 mask_feature_length = 10 mask_feature_min_masks = 0 median_filter_width = 7 **kwargs )

参数

  • vocab_size (int, 可选, 默认为 51865) — Whisper 模型的词汇表大小。定义了在调用 WhisperModel 时传递的 `decoder_input_ids` 可以表示的不同 token 的数量。
  • num_mel_bins (int, 可选, 默认为 80) — 每个输入特征使用的梅尔特征数。应与 `WhisperProcessor` 类中使用的值相对应。
  • encoder_layers (int, 可选, 默认为 4) — 编码器层数。
  • decoder_layers (int, 可选, 默认为 4) — 解码器层数。
  • encoder_attention_heads (int, 可选, 默认为 6) — Transformer 编码器中每个注意力层的注意力头数量。
  • decoder_attention_heads (int, 可选, 默认为 6) — Transformer 解码器中每个注意力层的注意力头数量。
  • encoder_ffn_dim (int, 可选, 默认为 1536) — 编码器中“中间”（通常称为前馈）层的维度。
  • decoder_ffn_dim (int, 可选, 默认为 1536) — 解码器中“中间”（通常称为前馈）层的维度。
  • encoder_layerdrop (float, 可选, 默认为 0.0) — 编码器的 LayerDrop 概率。更多细节请参见 LayerDrop 论文。
  • decoder_layerdrop (float, 可选, 默认为 0.0) — 解码器的 LayerDrop 概率。更多细节请参见 LayerDrop 论文。
  • decoder_start_token_id (int, 可选, 默认为 50257) — 对应于“<|startoftranscript|>” token，当没有向 `generate` 函数提供 `decoder_input_ids` 时会自动使用。它用于根据任务指导模型的生成过程。
  • use_cache (bool, 可选, 默认为 True) — 模型是否应返回最后一个键/值注意力（并非所有模型都使用）。
  • is_encoder_decoder (bool, 可选, 默认为 True) — 模型是否用作编码器/解码器。
  • activation_function (str, 可选, 默认为 "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持 "gelu"、"relu"、"silu" 和 "gelu_new"。
  • d_model (int, 可选, 默认为 384) — 层的维度。
  • dropout (float, 可选, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
  • attention_dropout (float, 可选, 默认为 0.0) — 注意力概率的 dropout 比例。
  • activation_dropout (float, 可选, 默认为 0.0) — 全连接层内部激活的 dropout 比例。
  • init_std (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • scale_embedding (bool, 可选, 默认为 False) — 是否通过除以 sqrt(d_model) 来缩放嵌入。
  • max_source_positions (int, 可选, 默认为 1500) — 此模型可能使用的对数-梅尔滤波器组特征的最大序列长度。
  • max_target_positions (int, 可选, 默认为 448) — 此模型可能使用的最大序列长度。通常将其设置为一个较大的值以备不时之需（例如，512、1024 或 2048）。
  • pad_token_id (int, 可选, 默认为 50256) — 填充 token 的 ID。
  • bos_token_id (int, 可选, 默认为 50256) — 流开始 token 的 ID。
  • eos_token_id (int, 可选, 默认为 50256) — 流结束 token 的 ID。
  • suppress_tokens (list[int], 可选) — 包含将在 `generate` 函数中由 logit 处理器使用的非语音 token 的列表。NON_SPEECH_TOKENS 和 NON_SPEECH_TOKENS_MULTI 分别对应于`仅英语`模型和`多语言`模型。
  • begin_suppress_tokens (list[int], 可选, 默认为 `[220,50256]`) — 包含将在采样过程开始时被抑制的 token 的列表。初始化为 `" "` (blank_token_id) 和 eos_token_id 的 token。
  • use_weighted_layer_sum (bool, 可选, 默认为 False) — 是否使用带有学习权重的层输出的加权平均值。仅在使用 WhisperForAudioClassification 实例时相关。
  • classifier_proj_size (int, 可选, 默认为 256) — 用于分类的 token 均值池化之前的投影维度。仅在使用 WhisperForAudioClassification 实例时相关。
  • apply_spec_augment (bool, 可选, 默认为 False) — 是否对特征编码器的输出应用 SpecAugment 数据增强。参考请见 SpecAugment: A Simple Data Augmentation Method for Automatic Speech Recognition。
  • mask_time_prob (float, 可选, 默认为 0.05) — 沿时间轴的所有特征向量中将被遮蔽的百分比（介于 0 和 1 之间）。遮蔽过程会生成 `mask_time_prob*len(time_axis)/mask_time_length` 个独立的遮罩。如果从每个特征向量被选为要遮蔽的向量跨度起点的概率来推理，则 *mask_time_prob* 应为 `prob_vector_start*mask_time_length`。请注意，重叠可能会减少实际被遮蔽向量的百分比。仅当 `apply_spec_augment == True` 时此参数才相关。
  • mask_time_length (int, 可选, 默认为 10) — 沿时间轴的向量跨度长度。
  • mask_time_min_masks (int, 可选, 默认为 2)， — 沿时间轴生成的长度为 `mask_feature_length` 的遮罩的最小数量，每个时间步都生成，与 `mask_feature_prob` 无关。仅当 ”mask_time_prob*len(time_axis)/mask_time_length < mask_time_min_masks” 时相关。
  • mask_feature_prob (float, 可选, 默认为 0.0) — 沿特征轴的所有特征向量中将被遮蔽的百分比（介于 0 和 1 之间）。遮蔽过程会生成 `mask_feature_prob*len(feature_axis)/mask_time_length` 个独立的遮罩。如果从每个特征向量被选为要遮蔽的向量跨度起点的概率来推理，则 *mask_feature_prob* 应为 `prob_vector_start*mask_feature_length`。请注意，重叠可能会减少实际被遮蔽向量的百分比。仅当 `apply_spec_augment 为 True` 时此参数才相关。
  • mask_feature_length (int, 可选, 默认为 10) — 沿特征轴的向量跨度长度。
  • mask_feature_min_masks (int, 可选, 默认为 0)， — 沿特征轴生成的长度为 `mask_feature_length` 的遮罩的最小数量，每个时间步都生成，与 `mask_feature_prob` 无关。仅当 `mask_feature_prob*len(feature_axis)/mask_feature_length < mask_feature_min_masks` 时相关。
  • median_filter_width (int, 可选, 默认为 7) — 用于平滑交叉注意力输出以计算 token 时间戳的中值滤波器的宽度。应为奇数。

这是用于存储 WhisperModel 配置的配置类。它用于根据指定的参数实例化一个 Whisper 模型，定义模型架构。使用默认值实例化配置将产生与 Whisper openai/whisper-tiny 架构类似的配置。

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

示例

>>> from transformers import WhisperConfig, WhisperModel

>>> # Initializing a Whisper tiny style configuration
>>> configuration = WhisperConfig()

>>> # Initializing a model (with random weights) from the tiny style configuration
>>> model = WhisperModel(configuration)

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

WhisperTokenizer

class transformers.WhisperTokenizer

< >

( vocab_file merges_file normalizer_file = None errors = 'replace' unk_token = '<|endoftext|>' bos_token = '<|endoftext|>' eos_token = '<|endoftext|>' pad_token = None add_prefix_space = False language = None task = None predict_timestamps = False **kwargs )

参数

  • vocab_file (str) — 词汇表文件的路径。
  • merges_file (str) — 合并文件的路径。
  • normalizer_file (str, 可选) — normalizer_file 文件的路径。
  • errors (str, 可选, 默认为 "replace") — 将字节解码为 UTF-8 时遵循的范式。有关更多信息，请参阅 bytes.decode。
  • unk_token (str, 可选, 默认为 "<|endoftext|>") — 未知词元。不在词汇表中的词元无法转换为 ID，将被设置为此词元。
  • bos_token (str, 可选, 默认为 "<|endoftext|>") — 序列开始词元。生成时，decoder_start_token_id 用于将第一个词元设置为 "<|startoftranscript|>"。
  • eos_token (str, 可选, 默认为 "<|endoftext|>") — 序列结束词元。
  • pad_token (str, 可选) — 用于填充的词元，例如当批处理不同长度的序列时。
  • add_prefix_space (bool, 可选, 默认为 False) — 是否在输入前添加一个初始空格。这使得开头的单词可以像其他任何单词一样被处理。
  • language (str, 可选) — 转录文本的语言。对于多语言语音识别和语音翻译任务，相应的语言 ID 词元会附加到序列的开头，例如对于西班牙语，词元 "<|es|>" 会被附加到序列开头。这应该仅用于多语言微调。
  • task (str, 可选) — 附加在序列开头的任务标识符（如果有）。这应该用于多语言微调，其中 "transcribe" 用于语音识别，"translate" 用于语音翻译。
  • predict_timestamps (bool, 可选, 默认为 False) — 是否在序列开头省略 <|notimestamps|> 词元。

构建一个 Whisper 分词器。

此分词器继承自 PreTrainedTokenizer，其中包含一些主要方法。用户应参考超类以获取有关这些方法的更多信息。

set_prefix_tokens

< >

( language: typing.Optional[str] = None task: typing.Optional[str] = None predict_timestamps: typing.Optional[bool] = None )

参数

  • language (str, 可选, 默认为 None) — 转录文本的语言。
  • task (str, 可选, 默认为 None) — 附加在序列开头的任务标识符（如果有）。
  • predict_timestamps (bool, 可选, 默认为 None) — 是否在序列开头省略 <|notimestamps|> 词元。

覆盖附加在标签序列开头的前缀词元。该方法可以单独使用以

在微调时根据需要更新前缀词元。示例：

>>> # instantiate the tokenizer and set the prefix token to Spanish
>>> tokenizer = WhisperTokenizer.from_pretrained("openai/whisper-tiny", language="spanish")
>>> # now switch the prefix token from Spanish to French
>>> tokenizer.set_prefix_tokens(language="french")

build_inputs_with_special_tokens

< >

( token_ids_0 token_ids_1 = None )

通过追加 eos_token_id 从序列构建模型输入。

get_special_tokens_mask

< >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None already_has_special_tokens: bool = False ) → list[int]

参数

  • token_ids_0 (list[int]) — ID 列表。
  • token_ids_1 (list[int], 可选) — 用于序列对的可选的第二组 ID 列表。
  • already_has_special_tokens (bool, 可选, 默认为 False) — 词元列表是否已经用模型的特殊词元格式化。

返回

list[int]

一个范围为 [0, 1] 的整数列表：1 表示特殊标记，0 表示序列标记。

从没有添加特殊标记的标记列表中检索序列ID。此方法在使用分词器prepare_for_model方法添加特殊标记时调用。

create_token_type_ids_from_sequences

< >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]

参数

  • token_ids_0 (list[int]) — 第一个分词后的序列。
  • token_ids_1 (list[int], 可选) — 第二个分词后的序列。

返回

list[int]

标记类型 ID。

创建与传入序列对应的标记类型 ID。什么是标记类型 ID？

如果模型有特殊的构建方式，应在子类中重写此方法。

save_vocabulary

< >

( save_directory: str filename_prefix: typing.Optional[str] = None )

batch_decode

< >

( sequences: typing.Union[list[int], list[list[int]], ForwardRef('np.ndarray'), ForwardRef('torch.Tensor'), ForwardRef('tf.Tensor')] skip_special_tokens: bool = False clean_up_tokenization_spaces: typing.Optional[bool] = None **kwargs ) → list[str]

参数

  • sequences (Union[list[int], list[list[int]], np.ndarray, torch.Tensor, tf.Tensor]) — 分词后输入 ID 的列表。可以使用 __call__ 方法获得。
  • skip_special_tokens (bool, 可选, 默认为 False) — 是否在解码时移除特殊词元。
  • clean_up_tokenization_spaces (bool, 可选) — 是否清理分词产生的空格。如果为 None，则默认为 self.clean_up_tokenization_spaces。
  • kwargs (附加关键字参数, 可选) — 将传递给底层特定模型的解码方法。

返回

list[str]

解码后的句子列表。

通过调用 decode 将标记 ID 列表的列表转换为字符串列表。

decode

< >

( token_ids skip_special_tokens: bool = False clean_up_tokenization_spaces: typing.Optional[bool] = None output_offsets: bool = False time_precision: float = 0.02 decode_with_timestamps: bool = False normalize: bool = False basic_normalize: bool = False remove_diacritics: bool = False **kwargs ) → str

参数

  • token_ids (Union[int, list[int], np.ndarray, torch.Tensor, tf.Tensor]) — 分词后输入 ID 的列表。可以使用 __call__ 方法获得。
  • skip_special_tokens (bool, 可选, 默认为 False) — 是否在解码时移除特殊词元。如果存在，将移除之前的词元（前置提示）。
  • clean_up_tokenization_spaces (bool, 可选) — 是否清理分词产生的空格。如果为 None，则默认为 self.clean_up_tokenization_spaces (在 tokenizer_config 中可用)。
  • output_offsets (bool, 可选, 默认为 False) — 是否输出词元的偏移量。只有当模型预测了时间戳时才应设置此项。如果存在之前的词元（前置提示）需要解码，它们只有在包含时间戳词元时才会出现在解码文本中。
  • time_precision (float, 可选, 默认为 0.02) — 用于将词元转换为时间的时间比例。
  • decode_with_timestamps (bool, 可选, 默认为 False) — 是否在原始文本中包含时间戳进行解码。
  • normalize (bool, 可选, 默认为 False) — 是否对解码后的文本应用英文文本规范化器。仅适用于目标文本为英文的情况。否则，应使用基本文本规范化器。
  • basic_normalize (bool, 可选, 默认为 False) — 是否对解码后的文本应用基本文本规范化器。适用于多语言目标文本。
  • remove_diacritics (bool, 可选, 默认为 False) — 应用基本文本规范化器时是否移除变音符号。移除变音符号可能会破坏解码文本中的信息，因此应谨慎使用。
  • kwargs (附加关键字参数, 可选) — 将传递给底层特定模型的解码方法。

返回

字符串

解码后的句子。

使用分词器和词汇表将 ID 序列转换为字符串，可以选择移除特殊标记并清理分词空间。

类似于执行 self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))。

basic_normalize

< >

( text remove_diacritics = False )

使用 `BasicTextNormalizer` 类对给定字符串进行规范化，该类对多语言文本执行常见转换。

归一化

< >

( text )

使用 `EnglishTextNormalizer` 类对给定字符串进行规范化，该类对英文文本执行常见转换。

WhisperTokenizerFast

class transformers.WhisperTokenizerFast

< >

( vocab_file = None merges_file = None normalizer_file = None tokenizer_file = None unk_token = '<|endoftext|>' bos_token = '<|endoftext|>' eos_token = '<|endoftext|>' add_prefix_space = False language = None task = None predict_timestamps = False **kwargs )

参数

  • vocab_file (str, 可选) — 词汇表文件的路径。
  • merges_file (str, 可选) — 合并文件的路径。
  • normalizer_file (str, 可选) — normalizer_file 文件的路径。
  • tokenizer_file (str, 可选) — tokenizers 文件的路径（通常具有 .json 扩展名），其中包含加载分词器所需的所有内容。
  • unk_token (str, 可选, 默认为 "<|endoftext|>") — 未知词元（token）。词汇表中不存在的词元无法转换为 ID，将被设置为此词元。
  • bos_token (str, 可选, 默认为 "<|endoftext|>") — 序列开始词元（token）。在生成时，decoder_start_token_id 用于将第一个词元设置为 "<|startoftranscript|>"。
  • eos_token (str, 可选, 默认为 "<|endoftext|>") — 序列结束词元（token）。
  • add_prefix_space (bool, 可选, 默认为 False) — 是否在输入前添加一个初始空格。这允许将开头的单词像其他单词一样处理。（Whisper 分词器通过前面的空格来检测单词的开头）。
  • language (str, 可选) — 转录文本的语言。对于多语言语音识别和语音翻译任务，相应的语言 ID 词元会附加到序列的开头，例如，对于西班牙语，词元 "<|es|>" 会附加到序列开头。这应该只用于多语言微调。
  • task (str, 可选) — 任务标识符，用于附加在序列开头（如果有）。这应该用于多语言微调，其中 "transcribe" 用于语音识别，"translate" 用于语音翻译。
  • predict_timestamps (bool, 可选, 默认为 False) — 是否在序列开头省略 <|notimestamps|> 词元。

构建一个“快速” Whisper 分词器（由 HuggingFace 的 tokenizers 库支持）。

此分词器继承自 PreTrainedTokenizerFast，其中包含了大部分主要方法。用户应参考此超类以获取有关这些方法的更多信息。

set_prefix_tokens

< >

( language: typing.Optional[str] = None task: typing.Optional[str] = None predict_timestamps: typing.Optional[bool] = None )

参数

  • language (str, 可选, 默认为 None) — 转录文本的语言。
  • task (str, 可选, 默认为 None) — 任务标识符，用于附加在序列开头（如果有）。
  • predict_timestamps (bool, 可选, 默认为 None) — 是否在序列开头省略 <|notimestamps|> 词元。

覆盖附加在标签序列开头的前缀词元。该方法可以单独使用以

在微调时根据需要更新前缀词元。示例：

>>> # instantiate the tokenizer and set the prefix token to Spanish
>>> tokenizer = WhisperTokenizerFast.from_pretrained("openai/whisper-tiny", language="spanish")
>>> # now switch the prefix token from Spanish to French
>>> tokenizer.set_prefix_tokens(language="french")

build_inputs_with_special_tokens

< >

( token_ids_0 token_ids_1 = None )

通过追加 eos_token_id 从序列构建模型输入。

get_special_tokens_mask

< >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None already_has_special_tokens: bool = False ) → list[int]

参数

  • token_ids_0 (list[int]) — ID 列表。
  • token_ids_1 (list[int], 可选) — 序列对的可选第二个 ID 列表。
  • already_has_special_tokens (bool, 可选, 默认为 False) — 词元列表是否已为模型格式化了特殊词元。

返回

list[int]

一个范围为 [0, 1] 的整数列表：1 表示特殊标记，0 表示序列标记。

从没有添加特殊标记的标记列表中检索序列ID。此方法在使用分词器prepare_for_model方法添加特殊标记时调用。

create_token_type_ids_from_sequences

< >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]

参数

  • token_ids_0 (list[int]) — 第一个分词后的序列。
  • token_ids_1 (list[int], 可选) — 第二个分词后的序列。

返回

list[int]

标记类型 ID。

创建与传入序列对应的标记类型 ID。什么是标记类型 ID？

如果模型有特殊的构建方式，应在子类中重写此方法。

save_vocabulary

< >

( save_directory: str filename_prefix: typing.Optional[str] = None )

batch_decode

< >

( sequences: typing.Union[list[int], list[list[int]], ForwardRef('np.ndarray'), ForwardRef('torch.Tensor'), ForwardRef('tf.Tensor')] skip_special_tokens: bool = False clean_up_tokenization_spaces: typing.Optional[bool] = None **kwargs ) → list[str]

参数

  • sequences (Union[list[int], list[list[int]], np.ndarray, torch.Tensor, tf.Tensor]) — 分词后的输入 ID 列表。可通过 __call__ 方法获得。
  • skip_special_tokens (bool, 可选, 默认为 False) — 是否在解码时移除特殊词元。
  • clean_up_tokenization_spaces (bool, 可选) — 是否清理分词产生的空格。如果为 None，则默认为 self.clean_up_tokenization_spaces。
  • kwargs (附加关键字参数, 可选) — 将传递给底层特定模型的解码方法。

返回

list[str]

解码后的句子列表。

通过调用 decode 将标记 ID 列表的列表转换为字符串列表。

decode

< >

( token_ids skip_special_tokens: bool = False clean_up_tokenization_spaces: typing.Optional[bool] = None output_offsets: bool = False time_precision: float = 0.02 decode_with_timestamps: bool = False normalize: bool = False basic_normalize: bool = False remove_diacritics: bool = False **kwargs ) → str

参数

  • token_ids (Union[int, list[int], np.ndarray, torch.Tensor, tf.Tensor]) — 分词后的输入 ID 列表。可通过 __call__ 方法获得。
  • skip_special_tokens (bool, 可选, 默认为 False) — 是否在解码时移除特殊词元。如果存在，将移除之前的词元（前置提示）。
  • clean_up_tokenization_spaces (bool, 可选) — 是否清理分词产生的空格。如果为 None，则默认为 self.clean_up_tokenization_spaces（可在 tokenizer_config 中找到）。
  • output_offsets (bool, 可选, 默认为 False) — 是否输出词元的偏移量。这只应在模型预测了时间戳时设置。如果有之前的词元（前置提示）需要解码，它们只会在包含时间戳词元时才出现在解码后的文本中。
  • time_precision (float, 可选, 默认为 0.02) — 用于将词元转换为时间的时间比例。
  • decode_with_timestamps (bool, 可选, 默认为 False) — 是否在原始文本中包含时间戳进行解码。
  • normalize (bool, 可选, 默认为 False) — 是否对解码后的文本应用英文文本规范化器。仅当目标文本为英文时适用。否则，应应用基本文本规范化器。
  • basic_normalize (bool, 可选, 默认为 False) — 是否对解码后的文本应用基本文本规范化器。适用于多语言目标文本。
  • remove_diacritics (bool, 可选, 默认为 False) — 在应用基本文本规范化器时是否移除变音符号。移除变音符号可能会破坏解码文本中的信息，因此应谨慎使用。
  • kwargs (附加关键字参数, 可选) — 将传递给底层特定模型的解码方法。

返回

字符串

解码后的句子。

使用分词器和词汇表将 ID 序列转换为字符串，可以选择移除特殊标记并清理分词空间。

类似于执行 self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))。

basic_normalize

< >

( text remove_diacritics = False )

使用 `BasicTextNormalizer` 类对给定字符串进行规范化，该类对多语言文本执行常见转换。

归一化

< >

( text )

使用 `EnglishTextNormalizer` 类对给定字符串进行规范化，该类对英文文本执行常见转换。

WhisperFeatureExtractor

class transformers.WhisperFeatureExtractor

< >

( feature_size = 80 sampling_rate = 16000 hop_length = 160 chunk_length = 30 n_fft = 400 padding_value = 0.0 dither = 0.0 return_attention_mask = False **kwargs )

参数

  • feature_size (int, 可选, 默认为 80) — 提取特征的维度。
  • sampling_rate (int, 可选, 默认为 16000) — 音频文件数字化的采样率，以赫兹 (Hz) 表示。
  • hop_length (int, 可选, 默认为 160) — 用于获取梅尔频率系数的 STFT 重叠窗口的长度。
  • chunk_length (int, 可选, 默认为 30) — 用于修剪和填充较长或较短音频序列的 sampling_rate 样本块的最大数量。
  • n_fft (int, 可选, 默认为 400) — 傅里叶变换的大小。
  • padding_value (float, 可选, 默认为 0.0) — 用于填充音频的填充值。应对应于静音。
  • dither (float, 可选, 默认为 0.0) — 添加抖动。换句话说，为每个帧添加少量高斯噪声。例如，使用 0.0001 添加以 0.0 为中心、标准差为 0.0001 的正态分布抖动（假设原始语音范围为 [-1, +1]）。值为 0.0 表示无抖动。抖动的效果类似于 spectrogram(mel_floor=...)。当信号中存在 VAD 截止时，它会降低信号硬零部分的 log_mel_fbank 高值。

构建一个 Whisper 特征提取器。

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

该类使用 短时傅里叶变换 的自定义 numpy 实现从原始语音中提取 mel 滤波器组特征，该实现应与 pytorch 的 torch.stft 等效。

__call__

< >

( raw_speech: typing.Union[numpy.ndarray, list[float], list[numpy.ndarray], list[list[float]]] truncation: bool = True pad_to_multiple_of: typing.Optional[int] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None return_attention_mask: typing.Optional[bool] = None padding: typing.Optional[str] = 'max_length' max_length: typing.Optional[int] = None sampling_rate: typing.Optional[int] = None do_normalize: typing.Optional[bool] = None device: typing.Optional[str] = 'cpu' return_token_timestamps: typing.Optional[bool] = 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) — 如果设置，将序列填充到所提供值的倍数。

    这对于在计算能力 >= 7.5 (Volta) 的 NVIDIA 硬件上使用 Tensor Cores，或者在需要序列长度为 128 的倍数的 TPU 上特别有用。

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

    什么是注意力掩码？

    对于 Whisper 模型，在批处理推理时应始终传递 attention_mask，以避免细微的错误。
  • return_tensors (str 或 TensorType, 可选) — 如果设置，将返回张量而不是 Python 整数列表。可接受的值为：

    • 'tf': 返回 TensorFlow tf.constant 对象。
    • 'pt': 返回 PyTorch torch.Tensor 对象。
    • 'np': 返回 Numpy np.ndarray 对象。
  • sampling_rate (int, 可选) — raw_speech 输入的采样率。强烈建议在前向调用时传递 sampling_rate，以防止静默错误并允许自动语音识别管道。
  • padding_value (float, 可选, 默认为 0.0) — 用于填充填充值/向量的值。
  • do_normalize (bool, 可选, 默认为 False) — 是否对输入进行零均值单位方差归一化。归一化可以显著提高模型的性能。
  • device (str, 可选, 默认为 'cpu') — 指定在 _torch_extract_fbank_features 方法中计算音频信号对数梅尔频谱图的设备。（例如，“cpu”、“cuda”）
  • return_token_timestamps (bool, 可选, 默认为 None) — 是否返回输入 raw_speech 的帧数。这些 num_frames 可被模型用于计算词级时间戳。

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

WhisperProcessor

class transformers.WhisperProcessor

< >

( feature_extractor tokenizer )

参数

  • feature_extractor (WhisperFeatureExtractor) — WhisperFeatureExtractor 的一个实例。特征提取器是必需的输入。
  • tokenizer (WhisperTokenizer) — WhisperTokenizer 的一个实例。分词器是必需的输入。

构建一个 Whisper 处理器，它将 Whisper 特征提取器和 Whisper 分词器包装成一个单一的处理器。

WhisperProcessor 提供了 WhisperFeatureExtractor 和 WhisperTokenizer 的所有功能。更多信息请参阅 call() 和 decode()。

__call__

< >

( *args **kwargs )

将 `audio` 参数转发给 WhisperFeatureExtractor 的 call() 方法，将 `text` 参数转发给 call() 方法。请参考上述两个方法的文档字符串以获取更多信息。

from_pretrained

< >

( pretrained_model_name_or_path: typing.Union[str, os.PathLike] cache_dir: typing.Union[str, os.PathLike, NoneType] = None force_download: bool = False local_files_only: bool = False token: typing.Union[str, bool, NoneType] = None revision: str = 'main' **kwargs )

参数

  • pretrained_model_name_or_path (str or os.PathLike) — 这可以是：

    • 一个字符串，即托管在 huggingface.co 的模型仓库中的预训练 feature_extractor 的 *模型 ID*。
    • 一个包含使用 save_pretrained() 方法保存的特征提取器文件的 *目录* 的路径，例如 `./my_model_directory/`。
    • 一个指向已保存的特征提取器 JSON *文件* 的路径或 URL，例如 `./my_model_directory/preprocessor_config.json`。
  • **kwargs — 传递给 from_pretrained() 和 ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained 的额外关键字参数。

实例化与预训练模型关联的处理器。

这个类方法只是简单地调用特征提取器的 from_pretrained() 方法、图像处理器的 ImageProcessingMixin 方法和分词器的 ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained 方法。请参考上述方法的文档字符串以获取更多信息。

save_pretrained

< >

( save_directory push_to_hub: bool = False **kwargs )

参数

  • save_directory (str or os.PathLike) — 将要保存特征提取器 JSON 文件和分词器文件的目录（如果目录不存在，则会创建）。
  • push_to_hub (bool, optional, 默认为 False) — 是否在保存模型后将其推送到 Hugging Face 模型中心。你可以使用 `repo_id` 指定要推送到的仓库（默认为你命名空间下 `save_directory` 的名称）。
  • kwargs (dict[str, Any], optional) — 传递给 push_to_hub() 方法的额外关键字参数。

将此处理器的属性（特征提取器、分词器…）保存在指定目录中，以便可以使用 from_pretrained() 方法重新加载。

这个类方法只是简单地调用 save_pretrained() 和 save_pretrained() 方法。请参考上述方法的文档字符串以获取更多信息。

batch_decode

< >

( *args **kwargs )

此方法将其所有参数转发给 WhisperTokenizer 的 batch_decode() 方法。请参考该方法的文档字符串以获取更多信息。

decode

< >

( *args **kwargs )

此方法将其所有参数转发给 WhisperTokenizer 的 decode() 方法。请参考该方法的文档字符串以获取更多信息。

WhisperModel

class transformers.WhisperModel

< >

( config: WhisperConfig )

参数

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

基础的 Whisper 模型，输出原始的隐藏状态，顶部没有任何特定的头部。

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

该模型也是一个 PyTorch torch.nn.Module 的子类。可以像常规的 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< >

( input_features: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None past_key_values: typing.Union[transformers.cache_utils.EncoderDecoderCache, tuple[torch.FloatTensor], NoneType] = None decoder_inputs_embeds: typing.Optional[tuple[torch.FloatTensor]] = None decoder_position_ids: typing.Optional[tuple[torch.LongTensor]] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None ) → transformers.modeling_outputs.Seq2SeqModelOutput or tuple(torch.FloatTensor)

参数

  • input_features (torch.FloatTensor of shape (batch_size, feature_size, sequence_length)) — 从原始语音波形中提取的浮点数梅尔特征。原始语音波形可以通过将 `.flac` 或 `.wav` 音频文件加载到 `list[float]` 或 `numpy.ndarray` 类型的数组中获得，例如通过 soundfile 库（`pip install soundfile`）。要将数组准备成 `input_features`，应使用 AutoFeatureExtractor 来提取梅尔特征、进行填充并转换为 `torch.FloatTensor` 类型的张量。请参阅 call()
  • attention_mask (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力计算的掩码。掩码值在 `[0, 1]` 中选择：

    • 1 表示标记未被掩码，
    • 0 表示标记已被掩码。

    什么是注意力掩码？

  • decoder_input_ids (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 解码器输入序列标记在词汇表中的索引。

    可以使用 WhisperTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是解码器输入 ID？

    Whisper 使用 `decoder_start_token_id` 作为生成 `decoder_input_ids` 的起始标记。如果使用 `past_key_values`，则可以选择只输入最后一个 `decoder_input_ids`（参见 `past_key_values`）。

  • decoder_attention_mask (torch.LongTensor of shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个忽略 `decoder_input_ids` 中填充标记的张量。默认情况下也会使用因果掩码。

    如果你想更改填充行为，应阅读 `modeling_whisper._prepare_decoder_attention_mask` 并根据需要进行修改。有关默认策略的更多信息，请参阅 BART 论文 中的图 1。

  • head_mask (torch.Tensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于置零自注意力模块中选定头部的掩码。掩码值在 `[0, 1]` 中选择：

    • 1 表示头部未被掩码，
    • 0 表示头部已被掩码。
  • decoder_head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于置零解码器中注意力模块选定头部的掩码。掩码值在 `[0, 1]` 中选择：

    • 1 表示头部未被掩码，
    • 0 表示头部已被掩码。
  • cross_attn_head_mask (torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于置零交叉注意力模块中选定头部的掩码。掩码值在 `[0, 1]` 中选择：

    • 1 表示头部未被掩码，
    • 0 表示头部已被掩码。
  • encoder_outputs (tuple[tuple[torch.FloatTensor]], optional) — 由 (last_hidden_state, optional: hidden_states, optional: attentions) 组成的元组。`last_hidden_state` 的形状为 `(batch_size, sequence_length, hidden_size)`，*可选*），是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  • past_key_values (Union[~cache_utils.EncoderDecoderCache, tuple[torch.FloatTensor], NoneType]) — 预计算的隐藏状态（自注意力和交叉注意力块中的键和值），可用于加速顺序解码。这通常是在解码的前一阶段，当 `use_cache=True` 或 `config.use_cache=True` 时，模型返回的 `past_key_values`。

    允许两种格式：

    • Cache 实例，请参阅我们的 kv 缓存指南；
    • 长度为 `config.n_layers` 的 `tuple(torch.FloatTensor)` 元组，每个元组包含 2 个形状为 `(batch_size, num_heads, sequence_length, embed_size_per_head)` 的张量。这也称为传统缓存格式。

    模型将输出与输入相同的缓存格式。如果未传递 `past_key_values`，将返回传统缓存格式。

    如果使用 `past_key_values`，用户可以选择只输入最后一个 `input_ids`（那些没有为其提供过去键值状态的 `input_ids`），形状为 `(batch_size, 1)`，而不是所有形状为 `(batch_size, sequence_length)` 的 `input_ids`。

  • decoder_inputs_embeds (tuple[torch.FloatTensor] of shape (batch_size, target_sequence_length, hidden_size), optional) — 可选地，你可以选择直接传递嵌入表示，而不是传递 `decoder_input_ids`。如果使用 `past_key_values`，则可以选择只输入最后一个 `decoder_inputs_embeds`（参见 `past_key_values`）。如果你想比模型内部的嵌入查找矩阵更好地控制如何将 `decoder_input_ids` 索引转换为相关向量，这将非常有用。

    如果 `decoder_input_ids` 和 `decoder_inputs_embeds` 都未设置，`decoder_inputs_embeds` 将取 `inputs_embeds` 的值。

  • decoder_position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在 `[0, config.n_positions - 1]` 范围内选择。

    什么是位置 ID？

  • use_cache (bool, optional) — 如果设置为 `True`，将返回 `past_key_values` 键值状态，可用于加速解码（参见 `past_key_values`）。
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 `attentions`。
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 `hidden_states`。
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通的元组。
  • cache_position (torch.LongTensor of shape (sequence_length), optional) — 描述输入序列标记在序列中位置的索引。与 `position_ids` 不同，此张量不受填充影响。它用于在正确的位置更新缓存并推断完整的序列长度。

返回

transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.Seq2SeqModelOutput 或一个 `torch.FloatTensor` 元组（如果传递了 `return_dict=False` 或 `config.return_dict=False`），根据配置（WhisperConfig）和输入包含各种元素。

  • last_hidden_state (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)) — 模型解码器最后一层输出的隐藏状态序列。

    如果使用了 past_key_values，则只输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。

  • past_key_values (EncoderDecoderCache, optional, 当传递 `use_cache=True` 或 `config.use_cache=True` 时返回) — 这是一个 EncoderDecoderCache 实例。更多详情，请参阅我们的 kv 缓存指南。

    包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。

  • decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) — 形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.FloatTensor` 元组（如果模型有嵌入层，则第一个是嵌入层的输出，其余是每一层的输出）。

    解码器在每个层输出的隐藏状态，加上可选的初始嵌入输出。

  • decoder_attentions (tuple(torch.FloatTensor), optional, 当传递 `output_attentions=True` 或 `config.output_attentions=True` 时返回) — 形状为 `(batch_size, num_heads, sequence_length, sequence_length)` 的 `torch.FloatTensor` 元组（每层一个）。

    解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。

  • cross_attentions (tuple(torch.FloatTensor), optional, 当传递 `output_attentions=True` 或 `config.output_attentions=True` 时返回) — 形状为 `(batch_size, num_heads, sequence_length, sequence_length)` 的 `torch.FloatTensor` 元组（每层一个）。

    解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均。

  • encoder_last_hidden_state (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。

  • encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) — 形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.FloatTensor` 元组（如果模型有嵌入层，则第一个是嵌入层的输出，其余是每一层的输出）。

    编码器在每个层输出的隐藏状态，加上可选的初始嵌入输出。

  • encoder_attentions (tuple(torch.FloatTensor), optional, 当传递 `output_attentions=True` 或 `config.output_attentions=True` 时返回) — 形状为 `(batch_size, num_heads, sequence_length, sequence_length)` 的 `torch.FloatTensor` 元组（每层一个）。

    编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。

WhisperModel 的前向方法重写了 `__call__` 特殊方法。

尽管前向传递的逻辑需要在此函数内定义，但之后应调用 `Module` 实例而不是此函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。

示例

>>> import torch
>>> from transformers import AutoFeatureExtractor, WhisperModel
>>> from datasets import load_dataset

>>> model = WhisperModel.from_pretrained("openai/whisper-base")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("openai/whisper-base")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt")
>>> input_features = inputs.input_features
>>> decoder_input_ids = torch.tensor([[1, 1]]) * model.config.decoder_start_token_id
>>> last_hidden_state = model(input_features, decoder_input_ids=decoder_input_ids).last_hidden_state
>>> list(last_hidden_state.shape)
[1, 2, 512]

_mask_input_features

< >

( input_features: FloatTensor attention_mask: typing.Optional[torch.LongTensor] = None )

根据 SpecAugment 沿时间轴和/或特征轴对提取的特征进行掩码。

WhisperForConditionalGeneration

class transformers.WhisperForConditionalGeneration

< >

( config: WhisperConfig )

参数

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

带有语言模型头部的 Whisper 模型。可用于自动语音识别。

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

该模型也是一个 PyTorch torch.nn.Module 的子类。可以像常规的 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< >

( input_features: typing.Optional[torch.FloatTensor] = None attention_mask: typing.Optional[torch.LongTensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None past_key_values: typing.Union[transformers.cache_utils.EncoderDecoderCache, tuple[torch.FloatTensor], NoneType] = None decoder_inputs_embeds: typing.Optional[tuple[torch.FloatTensor]] = None decoder_position_ids: typing.Optional[tuple[torch.LongTensor]] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None ) → transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)

参数

  • input_features (torch.FloatTensor，形状为 (batch_size, feature_size, sequence_length)) — 从原始语音波形中提取的浮点数梅尔特征。原始语音波形可以通过将 .flac 或 .wav 音频文件加载到 list[float] 类型的数组或 numpy.ndarray 中获得，例如通过 soundfile 库（pip install soundfile）。为了将数组准备成 input_features，应使用 AutoFeatureExtractor 来提取梅尔特征、进行填充并转换为 torch.FloatTensor 类型的张量。详见 call()
  • attention_mask (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力计算的掩码。掩码值选自 [0, 1]：

    • 1 表示标记未被掩码，
    • 0 表示标记已被掩码。

    什么是注意力掩码？

  • decoder_input_ids (torch.LongTensor，形状为 (batch_size, target_sequence_length)，可选) — 解码器输入序列标记在词汇表中的索引。

    可以使用 WhisperTokenizer 获得索引。详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是解码器输入 ID？

    Whisper 使用 decoder_start_token_id 作为生成 decoder_input_ids 的起始标记。如果使用 past_key_values，可以选择只输入最后一个 decoder_input_ids（参见 past_key_values）。

  • decoder_attention_mask (torch.LongTensor，形状为 (batch_size, target_sequence_length)，可选) — 默认行为：生成一个忽略 decoder_input_ids 中填充标记的张量。默认情况下也会使用因果掩码。

    如果你想改变填充行为，你应该阅读 modeling_whisper._prepare_decoder_attention_mask 并根据你的需求进行修改。有关默认策略的更多信息，请参见 BART 论文 中的图 1。

  • head_mask (torch.Tensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于将自注意力模块中选定的头置为零的掩码。掩码值选自 [0, 1]：

    • 1 表示该头未被掩码，
    • 0 表示该头已被掩码。
  • decoder_head_mask (torch.Tensor，形状为 (decoder_layers, decoder_attention_heads)，可选) — 用于将解码器中注意力模块选定的头置为零的掩码。掩码值选自 [0, 1]：

    • 1 表示该头未被掩码，
    • 0 表示该头已被掩码。
  • cross_attn_head_mask (torch.Tensor，形状为 (decoder_layers, decoder_attention_heads)，可选) — 用于将交叉注意力模块中选定的头置为零的掩码。掩码值选自 [0, 1]：

    • 1 表示该头未被掩码，
    • 0 表示该头已被掩码。
  • encoder_outputs (tuple[tuple[torch.FloatTensor]]，可选) — 由 (last_hidden_state, 可选: hidden_states, 可选: attentions) 组成的元组。last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size)，可选），是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力机制。
  • past_key_values (Union[~cache_utils.EncoderDecoderCache, tuple[torch.FloatTensor], NoneType]) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码的前一阶段返回的 past_key_values，此时 use_cache=True 或 config.use_cache=True。

    允许两种格式：

    • 一个 Cache 实例，请参阅我们的 kv 缓存指南；
    • 一个长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。这也称为传统缓存格式。

    模型将输出与输入相同格式的缓存。如果没有传递 past_key_values，将返回传统缓存格式。

    如果使用了 past_key_values，用户可以选择只输入最后一个 input_ids（那些没有将其过去键值状态提供给此模型的 ID），形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 input_ids。

  • decoder_inputs_embeds (tuple[torch.FloatTensor]，形状为 (batch_size, target_sequence_length, hidden_size)，可选) — 可选地，你可以不传递 decoder_input_ids，而是直接传递一个嵌入表示。如果使用了 past_key_values，可以选择只输入最后一个 decoder_inputs_embeds（参见 past_key_values）。如果你想比模型内部的嵌入查找矩阵更能控制如何将 decoder_input_ids 索引转换为关联向量，这会很有用。

    如果 decoder_input_ids 和 decoder_inputs_embeds 都未设置，decoder_inputs_embeds 将取 inputs_embeds 的值。

  • decoder_position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。选自 [0, config.n_positions - 1] 范围。

    什么是位置 ID？

  • labels (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于计算语言模型损失的标签。索引应在 [0, ..., config.vocab_size] 或 -100 之间（参见 input_ids 文档）。索引设置为 -100 的标记将被忽略（掩码），损失仅对标签在 [0, ..., config.vocab_size] 范围内的标记进行计算。sequence_length 应小于或等于 config.max_target_positions。
  • use_cache (bool，可选) — 如果设置为 True，将返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。更多细节请参见返回张量下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。更多细节请参见返回张量下的 hidden_states。
  • return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
  • cache_position (torch.LongTensor，形状为 (sequence_length)，可选) — 表示输入序列标记在序列中位置的索引。与 position_ids 不同，此张量不受填充影响。它用于在正确的位置更新缓存并推断完整的序列长度。

返回

transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.Seq2SeqLMOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False），根据配置（WhisperConfig）和输入包含不同的元素。

  • loss (torch.FloatTensor，形状为 (1,)，可选，当提供 labels 时返回) — 语言建模损失。

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

  • past_key_values (EncoderDecoderCache, optional, 当传递 `use_cache=True` 或 `config.use_cache=True` 时返回) — 这是一个 EncoderDecoderCache 实例。更多详情，请参阅我们的 kv 缓存指南。

    包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。

  • decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) — 形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.FloatTensor` 元组（如果模型有嵌入层，则第一个是嵌入层的输出，其余是每一层的输出）。

    解码器在每一层输出时的隐藏状态以及初始嵌入输出。

  • decoder_attentions (tuple(torch.FloatTensor), optional, 当传递 `output_attentions=True` 或 `config.output_attentions=True` 时返回) — 形状为 `(batch_size, num_heads, sequence_length, sequence_length)` 的 `torch.FloatTensor` 元组（每层一个）。

    解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。

  • cross_attentions (tuple(torch.FloatTensor), optional, 当传递 `output_attentions=True` 或 `config.output_attentions=True` 时返回) — 形状为 `(batch_size, num_heads, sequence_length, sequence_length)` 的 `torch.FloatTensor` 元组（每层一个）。

    解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均。

  • encoder_last_hidden_state (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。

  • encoder_hidden_states (tuple(torch.FloatTensor), optional, 当传递 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) — 形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.FloatTensor` 元组（如果模型有嵌入层，则第一个是嵌入层的输出，其余是每一层的输出）。

    编码器在每一层输出时的隐藏状态以及初始嵌入输出。

  • encoder_attentions (tuple(torch.FloatTensor), optional, 当传递 `output_attentions=True` 或 `config.output_attentions=True` 时返回) — 形状为 `(batch_size, num_heads, sequence_length, sequence_length)` 的 `torch.FloatTensor` 元组（每层一个）。

    编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。

WhisperForConditionalGeneration 的前向方法重写了 __call__ 特殊方法。

尽管前向传递的逻辑需要在此函数内定义，但之后应调用 `Module` 实例而不是此函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。

示例

>>> import torch
>>> from transformers import AutoProcessor, WhisperForConditionalGeneration
>>> from datasets import load_dataset

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")

>>> inputs = processor(ds[0]["audio"]["array"], return_tensors="pt")
>>> input_features = inputs.input_features

>>> generated_ids = model.generate(inputs=input_features)

>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> transcription
' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.'

生成

< >

( input_features: typing.Optional[torch.Tensor] = None generation_config: typing.Optional[transformers.generation.configuration_utils.GenerationConfig] = None logits_processor: typing.Optional[transformers.generation.logits_process.LogitsProcessorList] = None stopping_criteria: typing.Optional[transformers.generation.stopping_criteria.StoppingCriteriaList] = None prefix_allowed_tokens_fn: typing.Optional[typing.Callable[[int, torch.Tensor], list[int]]] = None synced_gpus: bool = False return_timestamps: typing.Optional[bool] = None task: typing.Optional[str] = None language: typing.Union[str, list[str], NoneType] = None is_multilingual: typing.Optional[bool] = None prompt_ids: typing.Optional[torch.Tensor] = None prompt_condition_type: typing.Optional[str] = None condition_on_prev_tokens: typing.Optional[bool] = None temperature: typing.Union[float, tuple[float, ...], NoneType] = None compression_ratio_threshold: typing.Optional[float] = None logprob_threshold: typing.Optional[float] = None no_speech_threshold: typing.Optional[float] = None num_segment_frames: typing.Optional[int] = None attention_mask: typing.Optional[torch.Tensor] = None time_precision: float = 0.02 time_precision_features: float = 0.01 return_token_timestamps: typing.Optional[bool] = None return_segments: bool = False return_dict_in_generate: typing.Optional[bool] = None force_unique_generate_call: typing.Optional[bool] = None **kwargs ) → ModelOutput 或 dict[str, Any] 或 torch.LongTensor

参数

  • input_features (torch.Tensor，形状为 (batch_size, feature_size, sequence_length)，可选) — 从原始语音波形中提取的对数梅尔特征的浮点数值。原始语音波形可以通过将 .flac 或 .wav 音频文件加载到 list[float] 类型的数组或 numpy.ndarray 中获得，例如通过 soundfile 库（pip install soundfile）。为了将数组准备成 input_features，应使用 AutoFeatureExtractor 来提取梅尔特征、进行填充并转换为 torch.FloatTensor 类型的张量。详见 call()。
  • generation_config (GenerationConfig，可选) — 用于生成调用的基础参数化配置。传递给 generate 的 **kwargs 中与 generation_config 属性匹配的参数将覆盖它们。如果未提供 generation_config，将使用默认配置，其加载优先级如下：1) 从 generation_config.json 模型文件（如果存在）；2) 从模型配置。请注意，未指定的参数将继承 GenerationConfig 的默认值，应查阅其文档以参数化生成。
  • logits_processor (LogitsProcessorList，可选) — 自定义 logits 处理器，补充了根据参数和生成配置构建的默认 logits 处理器。如果传递的 logit 处理器已经通过参数或生成配置创建，则会抛出错误。此功能适用于高级用户。
  • stopping_criteria (StoppingCriteriaList，可选) — 自定义停止标准，补充了根据参数和生成配置构建的默认停止标准。如果传递的停止标准已经通过参数或生成配置创建，则会抛出错误。此功能适用于高级用户。
  • prefix_allowed_tokens_fn (Callable[[int, torch.Tensor], list[int]]，可选) — 如果提供，此函数将在每一步将波束搜索限制为仅允许的标记。如果未提供，则不应用任何约束。此函数接受 2 个参数：批次 ID batch_id 和 input_ids。它必须返回一个列表，其中包含根据批次 ID batch_id 和先前生成的标记 inputs_ids 为下一步生成允许的标记。此参数对于基于前缀的约束生成非常有用，如 自回归实体检索 中所述。
  • synced_gpus (bool，可选，默认为 False) — 是否继续运行 while 循环直到达到 max_length（为避免与 FullyShardedDataParallel 和 DeepSpeed ZeRO Stage 3 发生死锁所需）。
  • return_timestamps (bool，可选) — 是否返回带有时间戳的文本。这将启用 WhisperTimestampsLogitsProcessor。
  • task (str，可选) — 用于生成的任务，可以是“translate”（翻译）或“transcribe”（转录）。
  • language (str 或 str 列表，可选) — 用于生成的语言标记，可以是 <|en|>、en 或 english 的形式。对于批量生成，可以传递一个语言标记列表。你可以在 model.generation_config.lang_to_id 字典中找到所有可能的语言标记。
  • is_multilingual (bool，可选) — 模型是否为多语言模型。
  • prompt_ids (torch.Tensor，可选) — 通过将文本传递给 get_prompt_ids() 创建的一维标记 ID 张量，作为每个块的提示提供。这可用于提供或“提示工程”转录的上下文，例如自定义词汇表或专有名词，以使其更可能正确预测这些词。它不能与 decoder_start_token_id 一起使用，因为它会覆盖该值。
  • prompt_condition_type (str，可选) — 仅与长格式转录相关。prompt_ids 的条件类型。“first-segment”表示只有第一个片段以 prompt_ids 为条件。“all-segments”表示每个片段都以 prompt_ids 为条件。对于“all-segments”，请确保启用 condition_on_prev_tokens。默认为“first-segment”。对于短期转录，只有“first-segment”是可能的。
  • condition_on_prev_tokens (bool，可选) — 仅与长格式转录相关。是否将每个片段的生成条件设置为前一个片段。如 Whisper 论文 所示，这有助于提高性能。
  • temperature (float 或 float 列表，可选) — 用于生成的温度。传递单个 float 值和 do_sample=True 会激活使用采样的生成。对于长格式转录，可以通过传递一个浮点数值列表（如 (0.0, 0.2, 0.4, 0.6, 0.8, 1.0)）来激活温度回退。如 Whisper 论文 所示，这有助于提高性能。
  • compression_ratio_threshold (float，可选) — 仅与长格式转录相关。如果定义，将计算每个片段的 zlib 压缩率。如果一个片段的压缩率高于 compression_ratio_threshold，则激活温度回退：丢弃生成的片段，并使用更高的温度重复生成。此功能背后的直觉是，压缩率非常高的片段存在大量重复。通过提高温度注入更多随机性可以减少不必要的重复。如果定义了 compression_ratio_threshold，请确保 temperature 是一个值列表。compression_ratio_threshold 的一个常用值为 1.35。如 Whisper 论文 所示，这有助于提高性能。
  • logprob_threshold (float，可选) — 仅与长格式转录相关。如果定义，将计算每个片段的平均对数概率。如果给定片段的对数概率低于 logprob_threshold，则激活温度回退：丢弃生成的片段，并使用更高的温度重复生成。此功能背后的直觉是，对数概率低的片段可以通过提高温度注入更多随机性来改善。如果定义了 logprob_threshold，请确保 temperature 是一个值列表。logprob_threshold 的一个常用值为 -1.0。如 Whisper 论文 所示，这有助于提高性能。
  • no_speech_threshold (float，可选) — 仅与长格式转录相关。如果定义，“无语音”标记与 logprob_threshold 结合使用，以确定一个片段是否仅包含静音。在这种情况下，将跳过该片段的转录。如 Whisper 论文 所示，这有助于提高性能。
  • num_segment_frames (int，可选) — 单个片段包含的帧数。如果未定义，num_segment_frames 默认为模型的步幅乘以最大输入长度。
  • attention_mask (torch.Tensor，可选) — 在使用大于 1 的批次大小进行长格式转录时，需要传递 attention_mask。
  • time_precision (int，可选，默认为 0.02) — 输出标记的持续时间（秒）。例如，0.02 表示一个生成的标记平均代表 20 毫秒。
  • time_precision_features (int，可选，默认为 0.01) — 特征帧表示的持续时间（秒）。
  • return_token_timestamps (bool，可选) — 是否返回带有文本的词元级时间戳。此选项可以与 return_timestamps 选项一起使用，也可以不一起使用。要获取词级时间戳，请使用分词器将词元分组为词。
  • return_segments (bool, 可选, 默认为 False) — 是否额外返回所有片段的列表。请注意，此选项只能在进行长文本转录时启用。
  • return_dict_in_generate (bool, 可选, 默认为 False) — 是否返回一个 ModelOutput 而不仅仅是生成的 token。请注意，在进行长文本转录时，return_dict_in_generate 只有在 return_segments 设置为 True 时才能启用。在这种情况下，每个片段的生成输出会添加到每个片段中。
  • force_unique_generate_call (bool, 可选) — 是否强制对底层的 GenerationMixin 的 generate() 方法进行唯一调用。这对于辅助解码和测试目的很有用，可以确保只对 generate() 进行一次调用，从而返回解码器输入 token ID 和 eos token ID。
  • kwargs (dict[str, Any], 可选) — generate_config 的临时参数化和/或额外的模型特定 kwargs，这些参数将转发到模型的 forward 函数。如果模型是编码器-解码器模型，则编码器特定的 kwargs 不应带前缀，而解码器特定的 kwargs 应以 decoder_ 为前缀。

返回

ModelOutput 或 dict[str, Any] 或 torch.LongTensor

一个

  • 当 return_dict_in_generate=True 且 (return_timestamps=False 或 force_unique_generate_call=True) 时，返回 ModelOutput，包括解码器输入 ID 和序列结束 ID。
  • 当 (return_dict_in_generate=True 且 return_timestamps=True) 或 return_segments=True 或 return_token_timestamps=True 时，返回 dict[str, Any]。
  • 在所有其他情况下，返回 torch.LongTensor，不包括解码器输入 ID 和序列结束 ID。

可能的 ModelOutput 类型是

segments 是一个列表的列表（每个批次元素一个列表），其中包含 segment。一个 segment 是一个字典，包含键 start、end、tokens、idxs 和 result。

  • start: 片段的开始时间戳。
  • end: 片段的结束时间戳。
  • tokens: 片段的 token，不包括解码器输入 ID 和序列结束 ID。
  • idxs: 在底层调用 GenerationMixin 的 generate() 时，片段的 tokens 的开始（包含）和结束（不包含）索引（存在于 result 中）。
  • result: 底层调用 GenerationMixin 的 generate() 的结果。

当 return_timestamps=True 时，return_dict_in_generate=True 适用于底层 GenerationMixin 的 generate() 的每次调用，输出存储在每个 segment 的 result 中。

将 log-mel 输入特征转录或翻译成自回归生成的 token ID 序列。

大多数生成控制参数都在 generation_config 中设置，如果未传递，则将设置为模型的默认生成配置。您可以通过将相应参数传递给 generate() 来覆盖任何 generation_config，例如 .generate(inputs, num_beams=4, do_sample=True)。

有关生成策略和代码示例的概述，请查看以下指南。

示例

  • 长文本转录：要转录或翻译超过 30 秒的音频，请在不截断的情况下处理音频文件，并将所有 mel 特征一次性传递给 generate。必须设置 return_timestamps=True。实际上，长文本转录使用基于时间戳预测的顺序算法，并采用压缩率阈值、对数概率阈值和温度回退等启发式方法。该算法在 Whisper 原始论文 的 3.8. 长文本转录 部分中有详细描述。
>>> import torch
>>> from transformers import AutoProcessor, WhisperForConditionalGeneration
>>> from datasets import load_dataset, Audio

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")
>>> model.cuda()
>>> # load audios > 30 seconds
>>> ds = load_dataset("distil-whisper/meanwhile", "default")["test"]
>>> # resample to 16kHz
>>> ds = ds.cast_column("audio", Audio(sampling_rate=16000))
>>> # take first 8 audios and retrieve array
>>> audio = ds[:8]["audio"]
>>> audio = [x["array"] for x in audio]

>>> # make sure to NOT truncate the input audio, to return the `attention_mask` and to pad to the longest audio
>>> inputs = processor(audio, return_tensors="pt", truncation=False, padding="longest", return_attention_mask=True, sampling_rate=16_000)
>>> inputs = inputs.to("cuda", torch.float32)

>>> # transcribe audio to ids
>>> generated_ids = model.generate(**inputs)

>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)
>>> transcription[0]
" Folks, if you watch the show, you know, I spent a lot of time right over there. Patiently and astutely scrutinizing the boxwood and mahogany chest set of the day's biggest stories developing the central headline pawns, definitely maneuvering an oso topical night to F6, fainting a classic Sicilian, nade door variation on the news, all the while seeing eight moves deep and patiently marshalling the latest press releases into a fisher's shows in Lip Nitsky attack that culminates in the elegant lethal slow-played, all-passant checkmate that is my nightly monologue. But sometimes, sometimes, folks, I. CHEERING AND APPLAUSE Sometimes I startle away, cubside down in the monkey bars of a condemned playground on a super fun site. Get all hept up on goofballs. Rummage that were discarded tag bag of defective toys. Yank out a fist bowl of disembodied doll limbs, toss them on a stained kid's place mat from a defunct dennies. set up a table inside a rusty cargo container down by the Wharf and challenged toothless drifters to the godless bughouse blitz of tournament that is my segment. Meanwhile."
  • 短文本转录：如果传入的 mel 输入特征 <= 30 秒，有两种可能性
    • return_timestamps=False：整个音频将通过单次调用 GenerationMixin 的 generate() 进行转录。
    • return_timestamps=True：音频将使用与长文本转录相同的逻辑进行转录。
>>> import torch
>>> from transformers import AutoProcessor, WhisperForConditionalGeneration
>>> from datasets import load_dataset

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")

>>> inputs = processor(ds[0]["audio"]["array"], return_tensors="pt")
>>> input_features = inputs.input_features

>>> generated_ids = model.generate(inputs=input_features)

>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> transcription
' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.'

WhisperForCausalLM

class transformers.WhisperForCausalLM

< >

( config )

参数

  • config (WhisperForCausalLM) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。请查阅 from_pretrained() 方法来加载模型权重。

带有语言模型头的 Whisper 解码器（一个权重与输入嵌入绑定的线性层）。

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

该模型也是一个 PyTorch torch.nn.Module 的子类。可以像常规的 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[torch.FloatTensor]] = None head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None ) → transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor，形状为 (batch_size, sequence_length), 可选) — 词汇表中输入序列 token 的索引。默认情况下，填充将被忽略。

    可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是输入 ID？

  • attention_mask (torch.Tensor，形状为 (batch_size, sequence_length), 可选) — 用于避免对填充 token 索引执行注意力的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示 token 未被屏蔽，
    • 0 表示 token 被屏蔽。

    什么是注意力掩码？

  • encoder_outputs (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size), 可选) — 编码器最后一层输出的隐藏状态序列。如果模型被配置为解码器，则在交叉注意力中使用。
  • head_mask (torch.Tensor，形状为 (num_heads,) 或 (num_layers, num_heads), 可选) — 用于置零自注意力模块中选定头的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示头 未被屏蔽，
    • 0 表示头 被屏蔽。
  • cross_attn_head_mask (torch.Tensor，形状为 (decoder_layers, decoder_attention_heads), 可选) — 用于置零交叉注意力模块中选定头的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示头 未被屏蔽，
    • 0 表示头 被屏蔽。
  • past_key_values (tuple[tuple[torch.FloatTensor]], 可选) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包含模型在先前解码阶段返回的 past_key_values，当 use_cache=True 或 config.use_cache=True 时。

    允许两种格式：

    • 一个 Cache 实例，请参阅我们的 kv 缓存指南；
    • 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组有两个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。这也称为旧版缓存格式。

    模型将输出与输入相同的缓存格式。如果未传递 past_key_values，将返回旧版缓存格式。

    如果使用 past_key_values，用户可以选择只输入最后的 input_ids（那些没有为其提供过去键值状态的 ID），形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 input_ids。

  • inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更多地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
  • labels (torch.LongTensor，形状为 (batch_size, sequence_length), 可选) — 用于计算掩码语言模型损失的标签。索引应在 [0, ..., config.vocab_size] 或 -100 中（参见 input_ids 文档字符串）。索引设置为 -100 的 token 将被忽略（屏蔽），损失仅对标签在 [0, ..., config.vocab_size] 中的 token 计算。
  • use_cache (bool, 可选) — 如果设置为 True，将返回 past_key_values 键值状态，并可用于加速解码（参见 past_key_values）。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通元组。
  • cache_position (torch.LongTensor，形状为 (sequence_length), 可选) — 描述输入序列 token 在序列中位置的索引。与 position_ids 不同，此张量不受填充影响。它用于在正确的位置更新缓存并推断完整的序列长度。

返回

transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False），包含根据配置（WhisperConfig）和输入而异的各种元素。

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

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

  • hidden_states (tuple(torch.FloatTensor), 可选, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 一个用于每层输出），形状为 (batch_size, sequence_length, hidden_size)。

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor), 可选, 当传递 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

  • cross_attentions (tuple(torch.FloatTensor), optional, 当传递 `output_attentions=True` 或 `config.output_attentions=True` 时返回) — 形状为 `(batch_size, num_heads, sequence_length, sequence_length)` 的 `torch.FloatTensor` 元组（每层一个）。

    注意力 softmax 后的交叉注意力权重，用于计算交叉注意力头中的加权平均。

  • past_key_values (Cache, 可选, 当传递 use_cache=True 或 config.use_cache=True 时返回) — 它是一个 Cache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。

    包含预先计算的隐藏状态（注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。

WhisperForCausalLM 的前向方法覆盖了 __call__ 特殊方法。

尽管前向传递的逻辑需要在此函数内定义，但之后应调用 `Module` 实例而不是此函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。

示例

>>> from transformers import WhisperForCausalLM, WhisperForConditionalGeneration, WhisperProcessor
>>> import torch
>>> from datasets import load_dataset

>>> processor = WhisperProcessor.from_pretrained("openai/whisper-large-v2")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-large-v2")

>>> assistant_model = WhisperForCausalLM.from_pretrained("distil-whisper/distil-large-v2")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> sample = ds[0]["audio"]
>>> input_features = processor(
...     sample["array"], sampling_rate=sample["sampling_rate"], return_tensors="pt"
... ).input_features

>>> predicted_ids = model.generate(input_features, assistant_model=assistant_model)

>>> # decode token ids to text
>>> transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)[0]
>>> transcription
' Mr. Quilter is the apostle of the middle classes and we are glad to welcome his gospel.'

WhisperForAudioClassification

class transformers.WhisperForAudioClassification

< >

( config )

参数

  • config (WhisperForAudioClassification) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。请查阅 from_pretrained() 方法来加载模型权重。

带有序列分类头的 Whisper 编码器模型（池化输出上的线性层），用于诸如 SUPERB 关键词识别等任务。

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

该模型也是一个 PyTorch torch.nn.Module 的子类。可以像常规的 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< >

( input_features: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None labels: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)

参数

  • input_features (torch.FloatTensor，形状为 (batch_size, feature_size, sequence_length)) — 从原始语音波形中提取的浮点值 mel 特征。原始语音波形可以通过将 .flac 或 .wav 音频文件加载到 list[float] 类型的数组或 numpy.ndarray 中获得，例如，通过 soundfile 库（pip install soundfile）。要将数组准备成 input_features，应使用 AutoFeatureExtractor 来提取 mel 特征、进行填充并转换为 torch.FloatTensor 类型的张量。请参阅 call()
  • head_mask (torch.Tensor，形状为 (num_heads,) 或 (num_layers, num_heads), 可选) — 用于置零自注意力模块中选定头的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示头 未被屏蔽，
    • 0 表示头 被屏蔽。
  • encoder_outputs (tuple[tuple[torch.FloatTensor]], 可选) — 元组包含 (last_hidden_state, 可选: hidden_states, 可选: attentions) last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size)，可选) 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  • labels (torch.LongTensor，形状为 (batch_size,), 可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 之间。如果 config.num_labels == 1，则计算回归损失（均方损失），如果 config.num_labels > 1，则计算分类损失（交叉熵）。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通元组。

返回

transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False），包含根据配置（WhisperConfig）和输入而异的各种元素。

  • loss (形状为 (1,) 的 torch.FloatTensor，可选，当提供 labels 时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。

  • logits (形状为 (batch_size, config.num_labels) 的 torch.FloatTensor) — 分类（如果 config.num_labels==1，则为回归）分数（SoftMax 之前）。

  • hidden_states (tuple(torch.FloatTensor), 可选, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 一个用于每层输出），形状为 (batch_size, sequence_length, hidden_size)。

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor), 可选, 当传递 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

WhisperForAudioClassification 的前向方法覆盖了 __call__ 特殊方法。

尽管前向传递的逻辑需要在此函数内定义，但之后应调用 `Module` 实例而不是此函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。

示例

>>> import torch
>>> from transformers import AutoFeatureExtractor, WhisperForAudioClassification
>>> from datasets import load_dataset

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("sanchit-gandhi/whisper-medium-fleurs-lang-id")
>>> model = WhisperForAudioClassification.from_pretrained("sanchit-gandhi/whisper-medium-fleurs-lang-id")

>>> ds = load_dataset("google/fleurs", "all", split="validation", streaming=True)
>>> sample = next(iter(ds))

>>> inputs = feature_extractor(
...     sample["audio"]["array"], sampling_rate=sample["audio"]["sampling_rate"], return_tensors="pt"
... )
>>> input_features = inputs.input_features

>>> with torch.no_grad():
...     logits = model(input_features).logits

>>> predicted_class_ids = torch.argmax(logits).item()
>>> predicted_label = model.config.id2label[predicted_class_ids]
>>> predicted_label
'Afrikaans'

TFWhisperModel

class transformers.TFWhisperModel

< >

( config: WhisperConfig **kwargs )

参数

  • config (WhisperConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。请查阅 from_pretrained() 方法来加载模型权重。

基础的 Whisper 模型，输出原始的隐藏状态，没有任何特定的头。该模型继承自 TFPreTrainedModel。请查阅超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入大小、修剪头等）。

此模型也是一个 keras.Model 子类。可以像常规的 TF 2.0 Keras 模型一样使用它，并参考 TF 2.0 文档了解所有与常规用法和行为相关的事项。

调用

< >

( input_features: TFModelInputType | None = None decoder_input_ids: np.ndarray | tf.Tensor | None = None decoder_attention_mask: np.ndarray | tf.Tensor | None = None decoder_position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None decoder_head_mask: np.ndarray | tf.Tensor | None = None cross_attn_head_mask: np.ndarray | tf.Tensor | None = None encoder_outputs: Optional[tuple[tuple[Union[np.ndarray, tf.Tensor]]]] = None past_key_values: Optional[tuple[tuple[Union[np.ndarray, tf.Tensor]]]] = None decoder_inputs_embeds: Optional[tuple[Union[np.ndarray, tf.Tensor]]] = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或 tuple(tf.Tensor)

参数

  • input_features (tf.Tensor，形状为 (batch_size, feature_size, sequence_length)) — 从原始语音波形中提取的 fbank 特征的浮点值。原始语音波形可以通过将 .flac 或 .wav 音频文件加载到 list[float] 类型的数组或 numpy.ndarray 中获得，例如，通过 soundfile 库（pip install soundfile）。要将数组准备成 input_features，应使用 AutoFeatureExtractor 来提取 fbank 特征、进行填充并转换为 tf.Tensor 类型的张量。请参阅 call()
  • decoder_input_ids (tf.Tensor，形状为 (batch_size, target_sequence_length), 可选) — 词汇表中解码器输入序列 token 的索引。

    可以使用 SpeechToTextTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是解码器输入 ID？

    SpeechToText 使用 eos_token_id 作为生成 decoder_input_ids 的起始 token。如果使用 past_key_values，则可以选择只输入最后的 decoder_input_ids（参见 past_key_values）。

  • decoder_attention_mask (tf.Tensor，形状为 (batch_size, target_sequence_length), 可选) — 默认行为：生成一个忽略 decoder_input_ids 中填充 token 的张量。默认情况下也会使用因果掩码。

    如果要更改填充行为，应阅读 modeling_whisper._prepare_decoder_attention_mask 并根据需要进行修改。有关默认策略的更多信息，请参阅 论文 中的图 1。

  • head_mask (tf.Tensor，形状为 (encoder_layers, encoder_attention_heads), 可选) — 用于置零编码器中注意力模块选定头的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示头 未被屏蔽，
    • 0 表示头 被屏蔽。
  • decoder_head_mask (tf.Tensor，形状为 (decoder_layers, decoder_attention_heads), 可选) — 用于置零解码器中注意力模块选定头的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示头 未被屏蔽，
    • 0 表示头 被屏蔽。
  • cross_attn_head_mask (tf.Tensor，形状为 (decoder_layers, decoder_attention_heads), 可选) — 用于置零交叉注意力模块中选定头的掩码。掩码值在 [0, 1] 中选择：

    • 1 表示头 未被屏蔽，
    • 0 表示头 被屏蔽。
  • encoder_outputs (tuple(tuple(tf.Tensor), 可选) — 元组包含 (last_hidden_state, 可选: hidden_states, 可选: attentions) last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size)，可选) 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  • past_key_values (tuple(tuple(tf.Tensor))，可选，当传递 use_cache=True 或 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(tf.Tensor) 元组，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量和 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的附加张量。

    包含预先计算的隐藏状态（自注意块和交叉注意块中的键和值），可用于（参见 past_key_values 输入）加速序列解码。

    如果使用 past_key_values，用户可以选择只输入最后一个形状为 (batch_size, 1) 的 decoder_input_ids（那些没有将其过去的键值状态提供给该模型的ID），而不是所有形状为 (batch_size, sequence_length) 的 decoder_input_ids。

  • decoder_inputs_embeds (tf.Tensor，形状为 (batch_size, target_sequence_length, hidden_size)，可选) — 可选地，你可以选择直接传递嵌入表示，而不是传递 decoder_input_ids。如果使用了 past_key_values，可以选择只输入最后一个 decoder_inputs_embeds（参见 past_key_values）。这在你希望对如何将 decoder_input_ids 索引转换为关联向量的控制权超过模型内部嵌入查找矩阵时非常有用。
  • use_cache (bool，可选) — 如果设置为 True，将返回 past_key_values 键值状态，并可用于加速解码（参见 past_key_values）。
  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。更多细节请参见返回张量下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。更多细节请参见返回张量下的 hidden_states。
  • return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或 tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFSeq2SeqModelOutput 或一个 tf.Tensor 的元组（如果传递 return_dict=False 或 config.return_dict=False），包含各种元素，具体取决于配置 (WhisperConfig) 和输入。

  • last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor) — 模型解码器最后一层输出的隐藏状态序列。

    如果使用了 past_key_values，则只输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。

  • past_key_values (list[tf.Tensor]，可选，当传递 use_cache=True 或 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tf.Tensor 列表，每个张量的形状为 (2, batch_size, num_heads, sequence_length, embed_size_per_head))。

    包含解码器注意力块的预计算隐藏状态（键和值），可用于（参见 past_key_values 输入）加速顺序解码。

  • decoder_hidden_states (tuple(tf.Tensor)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — tf.Tensor 的元组（一个用于嵌入层的输出，一个用于每层的输出），形状为 (batch_size, sequence_length, hidden_size)。

    解码器在每一层输出时的隐藏状态以及初始嵌入输出。

  • decoder_attentions (tuple(tf.Tensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — tf.Tensor 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。

  • cross_attentions (tuple(tf.Tensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — tf.Tensor 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均。

  • encoder_last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor, 可选) — 模型编码器最后一层输出的隐藏状态序列。

  • encoder_hidden_states (tuple(tf.Tensor)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — tf.Tensor 的元组（一个用于嵌入层的输出，一个用于每层的输出），形状为 (batch_size, sequence_length, hidden_size)。

    编码器在每一层输出时的隐藏状态以及初始嵌入输出。

  • encoder_attentions (tuple(tf.Tensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — tf.Tensor 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。

TFWhisperModel 的前向方法，覆盖了 __call__ 特殊方法。

尽管前向传递的逻辑需要在此函数内定义，但之后应调用 `Module` 实例而不是此函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。

示例

>>> import tensorflow as tf
>>> from transformers import TFWhisperModel, AutoFeatureExtractor
>>> from datasets import load_dataset

>>> model = TFWhisperModel.from_pretrained("openai/whisper-base")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("openai/whisper-base")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = feature_extractor(ds[0]["audio"]["array"], return_tensors="tf")
>>> input_features = inputs.input_features
>>> decoder_input_ids = tf.convert_to_tensor([[1, 1]]) * model.config.decoder_start_token_id
>>> last_hidden_state = model(input_features, decoder_input_ids=decoder_input_ids).last_hidden_state
>>> list(last_hidden_state.shape)
[1, 2, 512]

TFWhisperForConditionalGeneration

class transformers.TFWhisperForConditionalGeneration

< >

( config: WhisperConfig **kwargs )

参数

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

带有语言建模头的 Whisper 模型。可用于自动语音识别。此模型继承自 TFPreTrainedModel。请查看超类文档以了解该库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入大小、修剪注意力头等）。

此模型也是一个 keras.Model 子类。可以像常规的 TF 2.0 Keras 模型一样使用它，并参考 TF 2.0 文档了解所有与常规用法和行为相关的事项。

调用

< >

( input_features: TFModelInputType | None = None decoder_input_ids: np.ndarray | tf.Tensor | None = None decoder_attention_mask: np.ndarray | tf.Tensor | None = None decoder_position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None decoder_head_mask: np.ndarray | tf.Tensor | None = None cross_attn_head_mask: np.ndarray | tf.Tensor | None = None encoder_outputs: Optional[tuple[tuple[Union[np.ndarray, tf.Tensor]]]] = None past_key_values: Optional[tuple[tuple[Union[np.ndarray, tf.Tensor]]]] = None decoder_inputs_embeds: Optional[tuple[Union[np.ndarray, tf.Tensor]]] = None labels: np.ndarray | tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或 tuple(tf.Tensor)

参数

  • input_features (tf.Tensor，形状为 (batch_size, feature_size, sequence_length)) — 从原始语音波形中提取的 fbank 特征的浮点值。原始语音波形可以通过将 .flac 或 .wav 音频文件加载到 list[float] 类型的数组或 numpy.ndarray 中获得，例如通过 soundfile 库（pip install soundfile）。为了将数组准备成 input_features，应使用 AutoFeatureExtractor 来提取 fbank 特征、进行填充并转换为 tf.Tensor 类型的张量。参见 call()
  • decoder_input_ids (tf.Tensor，形状为 (batch_size, target_sequence_length)，可选) — 解码器输入序列在词汇表中的 token 索引。

    可以使用 SpeechToTextTokenizer 获得索引。详情请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是解码器输入 ID？

    SpeechToText 使用 eos_token_id 作为生成 decoder_input_ids 的起始 token。如果使用了 past_key_values，可以选择只输入最后一个 decoder_input_ids（参见 past_key_values）。

  • decoder_attention_mask (tf.Tensor，形状为 (batch_size, target_sequence_length)，可选) — 默认行为：生成一个忽略 decoder_input_ids 中填充 token 的张量。默认情况下也会使用因果掩码。

    如果你想改变填充行为，你应该阅读 modeling_whisper._prepare_decoder_attention_mask 并根据你的需求进行修改。有关默认策略的更多信息，请参见论文中的图1。

  • head_mask (tf.Tensor，形状为 (encoder_layers, encoder_attention_heads)，可选) — 用于在编码器中置零注意力模块的选定头的掩码。掩码值选自 [0, 1]：

    • 1 表示该头未被屏蔽，
    • 0 表示该头被屏蔽。
  • decoder_head_mask (tf.Tensor，形状为 (decoder_layers, decoder_attention_heads)，可选) — 用于在解码器中置零注意力模块的选定头的掩码。掩码值选自 [0, 1]：

    • 1 表示该头未被屏蔽，
    • 0 表示该头被屏蔽。
  • cross_attn_head_mask (tf.Tensor，形状为 (decoder_layers, decoder_attention_heads)，可选) — 用于置零交叉注意力模块的选定头的掩码。掩码值选自 [0, 1]：

    • 1 表示该头未被屏蔽，
    • 0 表示该头被屏蔽。
  • encoder_outputs (tuple(tuple(tf.Tensor)，可选) — 元组包含 (last_hidden_state, 可选: hidden_states, 可选: attentions) last_hidden_state，形状为 (batch_size, sequence_length, hidden_size)，可选) 是编码器最后一层输出的一系列隐藏状态。用于解码器的交叉注意力。
  • past_key_values (tuple(tuple(tf.Tensor))，可选，当传递 use_cache=True 或 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(tf.Tensor) 元组，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量和 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的附加张量。

    包含预先计算的隐藏状态（自注意块和交叉注意块中的键和值），可用于（参见 past_key_values 输入）加速序列解码。

    如果使用 past_key_values，用户可以选择只输入最后一个形状为 (batch_size, 1) 的 decoder_input_ids（那些没有将其过去的键值状态提供给该模型的ID），而不是所有形状为 (batch_size, sequence_length) 的 decoder_input_ids。

  • decoder_inputs_embeds (tf.Tensor，形状为 (batch_size, target_sequence_length, hidden_size)，可选) — 可选地，你可以选择直接传递嵌入表示，而不是传递 decoder_input_ids。如果使用了 past_key_values，可以选择只输入最后一个 decoder_inputs_embeds（参见 past_key_values）。这在你希望对如何将 decoder_input_ids 索引转换为关联向量的控制权超过模型内部嵌入查找矩阵时非常有用。
  • use_cache (bool，可选) — 如果设置为 True，将返回 past_key_values 键值状态，并可用于加速解码（参见 past_key_values）。
  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。更多细节请参见返回张量下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。更多细节请参见返回张量下的 hidden_states。
  • return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
  • labels (tf.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于计算语言建模损失的标签。索引应在 [0, ..., config.vocab_size] 或 -100 范围内（参见 input_ids 文档字符串）。索引设置为 -100 的 token 会被忽略（屏蔽），损失仅对标签在 [0, ..., config.vocab_size] 范围内的 token 计算。

返回

transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或 tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或一个 tf.Tensor 的元组（如果传递 return_dict=False 或 config.return_dict=False），包含各种元素，具体取决于配置 (WhisperConfig) 和输入。

  • loss (形状为 (n,) 的 tf.Tensor, 可选, 其中 n 是非掩码标签的数量，当提供 labels 时返回) — 语言建模损失。

  • logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言模型头部的预测分数（SoftMax 之前每个词汇标记的分数）。

  • past_key_values (list[tf.Tensor]，可选，当传递 use_cache=True 或 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tf.Tensor 列表，每个张量的形状为 (2, batch_size, num_heads, sequence_length, embed_size_per_head))。

    包含解码器注意力块的预计算隐藏状态（键和值），可用于（参见 past_key_values 输入）加速顺序解码。

  • decoder_hidden_states (tuple(tf.Tensor)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — tf.Tensor 的元组（一个用于嵌入层的输出，一个用于每层的输出），形状为 (batch_size, sequence_length, hidden_size)。

    解码器在每一层输出时的隐藏状态以及初始嵌入输出。

  • decoder_attentions (tuple(tf.Tensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — tf.Tensor 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。

  • cross_attentions (tuple(tf.Tensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — tf.Tensor 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均。

  • encoder_last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor, 可选) — 模型编码器最后一层输出的隐藏状态序列。

  • encoder_hidden_states (tuple(tf.Tensor)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — tf.Tensor 的元组（一个用于嵌入层的输出，一个用于每层的输出），形状为 (batch_size, sequence_length, hidden_size)。

    编码器在每一层输出时的隐藏状态以及初始嵌入输出。

  • encoder_attentions (tuple(tf.Tensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — tf.Tensor 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。

TFWhisperForConditionalGeneration 的前向方法，覆盖了 __call__ 特殊方法。

尽管前向传递的逻辑需要在此函数内定义，但之后应调用 `Module` 实例而不是此函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。

示例

>>> import tensorflow as tf
>>> from transformers import AutoProcessor, TFWhisperForConditionalGeneration
>>> from datasets import load_dataset

>>> processor = AutoProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = TFWhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")

>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")

>>> inputs = processor(ds[0]["audio"]["array"], return_tensors="tf")
>>> input_features = inputs.input_features

>>> generated_ids = model.generate(input_features=input_features)

>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> transcription
' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.'

FlaxWhisperModel

class transformers.FlaxWhisperModel

< >

( config: WhisperConfig input_shape: typing.Optional[tuple[int]] = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )

参数

  • config (WhisperConfig) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型关联的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
  • dtype (jax.numpy.dtype，可选，默认为 jax.numpy.float32) — 计算的数据类型。可以是 jax.numpy.float32、jax.numpy.float16（在 GPU 上）和 jax.numpy.bfloat16（在 TPU 上）之一。这可用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定，所有计算都将使用给定的 dtype 执行。请注意，这仅指定计算的 dtype，不影响模型参数的 dtype。 如果你希望更改模型参数的 dtype，请参见 to_fp16() 和 to_bf16()。

纯 Whisper 模型 Transformer，输出原始隐藏状态，顶部没有任何特定的头。此模型继承自 FlaxPreTrainedModel。请查看超类文档以了解该库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入大小、修剪注意力头等）。此模型也是 Flax Linen flax.nn.Module 的子类。可以像常规 Flax Module 一样使用它，并参考 Flax 文档了解所有与常规用法和行为相关的事项。最后，此模型支持固有的 JAX 特性，例如

__call__

< >

( input_features: Array decoder_input_ids: Array attention_mask: typing.Optional[jax.Array] = None decoder_attention_mask: typing.Optional[jax.Array] = None position_ids: typing.Optional[jax.Array] = None decoder_position_ids: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput 或 tuple(torch.FloatTensor)

参数

  • input_features (numpy.ndarray，形状为 (batch_size, feature_size, sequence_length)) — 从原始语音波形中提取的浮点值梅尔特征。原始语音波形可以通过将 .flac 或 .wav 音频文件加载到 list[float] 类型的数组或 numpy.ndarray 中获得，例如通过 soundfile 库（pip install soundfile）。为了将数组准备成 input_features，应使用 WhisperFeatureExtractor 来提取特征、进行填充并转换为 numpy.ndarray 类型的张量。参见 call()
  • attention_mask (numpy.ndarray，形状为 (batch_size, sequence_length)，可选) — Whisper 不支持对 input_features 进行屏蔽，保留此参数是为了兼容性，但未使用。默认情况下，输入对数梅尔频谱图中的静音部分会被忽略。
  • decoder_input_ids (numpy.ndarray，形状为 (batch_size, target_sequence_length)，可选) — 解码器输入序列在词汇表中的 token 索引。可以使用 WhisperTokenizer 获得索引。详情请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是解码器输入 ID？ Whisper 使用 decoder_start_token_id 作为生成 decoder_input_ids 的起始 token。
  • decoder_attention_mask (numpy.ndarray，形状为 (batch_size, target_sequence_length)，可选) — 默认行为：生成一个忽略 decoder_input_ids 中填充 token 的张量。默认情况下也会使用因果掩码。如果你想改变填充行为，你应该根据你的需求进行修改。有关默认策略的更多信息，请参见论文中的图1。
  • position_ids (numpy.ndarray，形状为 (batch_size, sequence_length)，可选) — Whisper 在编码器中不使用 position_ids，因为 input_features 的大小总是相同的，并且不使用屏蔽，但保留此参数是为了兼容性。默认情况下，输入对数梅尔频谱图中的静音部分会被忽略。
  • decoder_position_ids (numpy.ndarray，形状为 (batch_size, sequence_length)，可选) — 每个解码器输入序列 token 在位置嵌入中的位置索引。选自范围 [0, config.max_position_embeddings - 1]。
  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。更多细节请参见返回张量下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。更多细节请参见返回张量下的 hidden_states。
  • return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput 或一个 torch.FloatTensor 的元组（如果传递 return_dict=False 或 config.return_dict=False），包含各种元素，具体取决于配置 (WhisperConfig) 和输入。

  • last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 jnp.ndarray) — 模型解码器最后一层输出的隐藏状态序列。

    如果使用了 past_key_values，则只输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。

  • past_key_values (tuple(tuple(jnp.ndarray))，可选，当传递 use_cache=True 或 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(jnp.ndarray) 元组，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量和 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的附加张量。

    包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。

  • decoder_hidden_states (tuple(jnp.ndarray)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — jnp.ndarray 的元组（一个用于嵌入层的输出，一个用于每层的输出），形状为 (batch_size, sequence_length, hidden_size)。

    解码器在每一层输出时的隐藏状态以及初始嵌入输出。

  • decoder_attentions (tuple(jnp.ndarray)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — jnp.ndarray 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。

  • cross_attentions (tuple(jnp.ndarray)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — jnp.ndarray 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均。

  • encoder_last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 jnp.ndarray，可选) — 模型编码器最后一层输出的隐藏状态序列。

  • encoder_hidden_states (tuple(jnp.ndarray)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — jnp.ndarray 的元组（一个用于嵌入层的输出，一个用于每层的输出），形状为 (batch_size, sequence_length, hidden_size)。

    编码器在每一层输出时的隐藏状态以及初始嵌入输出。

  • encoder_attentions (tuple(jnp.ndarray)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — jnp.ndarray 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。

FlaxWhisperPreTrainedModel 的前向方法，覆盖了 __call__ 特殊方法。

尽管前向传递的逻辑需要在此函数内定义，但之后应调用 `Module` 实例而不是此函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。

示例

>>> from transformers import AutoTokenizer, FlaxWhisperModel

>>> tokenizer = AutoTokenizer.from_pretrained("openai/whisper-tiny")
>>> model = FlaxWhisperModel.from_pretrained("openai/whisper-tiny")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="jax")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

FlaxWhisperForConditionalGeneration

class transformers.FlaxWhisperForConditionalGeneration

< >

( config: WhisperConfig input_shape: typing.Optional[tuple[int]] = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )

参数

  • config (WhisperConfig) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型关联的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
  • dtype (jax.numpy.dtype，可选，默认为 jax.numpy.float32) — 计算的数据类型。可以是 jax.numpy.float32、jax.numpy.float16（在 GPU 上）和 jax.numpy.bfloat16（在 TPU 上）之一。这可用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定，所有计算都将使用给定的 dtype 执行。请注意，这仅指定计算的 dtype，不影响模型参数的 dtype。 如果你希望更改模型参数的 dtype，请参见 to_fp16() 和 to_bf16()。

带有语言建模头的 Whisper 模型。此模型继承自 FlaxPreTrainedModel。请查看超类文档以了解该库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入大小、修剪注意力头等）。此模型也是 Flax Linen flax.nn.Module 的子类。可以像常规 Flax Module 一样使用它，并参考 Flax 文档了解所有与常规用法和行为相关的事项。最后，此模型支持固有的 JAX 特性，例如

__call__

< >

( input_features: Array decoder_input_ids: Array attention_mask: typing.Optional[jax.Array] = None decoder_attention_mask: typing.Optional[jax.Array] = None position_ids: typing.Optional[jax.Array] = None decoder_position_ids: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None ) → transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 tuple(torch.FloatTensor)

参数

  • input_features (numpy.ndarray，形状为 (batch_size, feature_size, sequence_length)) — 从原始语音波形中提取的浮点值梅尔特征。原始语音波形可以通过将 .flac 或 .wav 音频文件加载到 list[float] 类型或 numpy.ndarray 类型的数组中获得，例如通过 soundfile 库（pip install soundfile）。要将数组准备成 input_features，应使用 WhisperFeatureExtractor 提取特征、进行填充并转换为 numpy.ndarray 类型的张量。详见 call()。
  • attention_mask (numpy.ndarray，形状为 (batch_size, sequence_length)，可选) — Whisper 不支持对 input_features进行掩码操作，保留此参数是为了兼容性，但并未使用。默认情况下，输入对数梅尔频谱图中的静音部分会被忽略。
  • decoder_input_ids (numpy.ndarray，形状为 (batch_size, target_sequence_length)，可选) — 解码器输入序列在词汇表中的标记索引。可以使用 WhisperTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是解码器输入 ID？ Whisper 使用 decoder_start_token_id 作为生成 decoder_input_ids 的起始标记。
  • decoder_attention_mask (numpy.ndarray，形状为 (batch_size, target_sequence_length)，可选) — 默认行为：生成一个忽略 decoder_input_ids 中填充标记的张量。默认情况下也会使用因果掩码。如果你想更改填充行为，应根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图 1。
  • position_ids (numpy.ndarray，形状为 (batch_size, sequence_length)，可选) — Whisper 在编码器中不使用 position_ids，因为 input_features 的大小总是相同的，并且不使用掩码，但保留此参数是为了兼容性。默认情况下，输入对数梅尔频谱图中的静音部分会被忽略。
  • decoder_position_ids (numpy.ndarray，形状为 (batch_size, sequence_length)，可选) — 解码器每个输入序列标记在位置嵌入中的位置索引。在 [0, config.max_position_embeddings - 1] 范围内选择。
  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
  • return_dict (bool，可选) — 是返回一个 ModelOutput 而不是一个普通元组。

返回

transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False），包含根据配置（WhisperConfig）和输入而定的各种元素。

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

  • past_key_values (tuple(tuple(jnp.ndarray))，可选，当传递 use_cache=True 或 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(jnp.ndarray) 元组，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量和 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的附加张量。

    包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。

  • decoder_hidden_states (tuple(jnp.ndarray)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — jnp.ndarray 的元组（一个用于嵌入层的输出，一个用于每层的输出），形状为 (batch_size, sequence_length, hidden_size)。

    解码器在每一层输出时的隐藏状态以及初始嵌入输出。

  • decoder_attentions (tuple(jnp.ndarray)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — jnp.ndarray 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。

  • cross_attentions (tuple(jnp.ndarray)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — jnp.ndarray 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均。

  • encoder_last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 jnp.ndarray，可选) — 模型编码器最后一层输出的隐藏状态序列。

  • encoder_hidden_states (tuple(jnp.ndarray)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — jnp.ndarray 的元组（一个用于嵌入层的输出，一个用于每层的输出），形状为 (batch_size, sequence_length, hidden_size)。

    编码器在每一层输出时的隐藏状态以及初始嵌入输出。

  • encoder_attentions (tuple(jnp.ndarray)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — jnp.ndarray 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。

FlaxWhisperPreTrainedModel 的前向方法，覆盖了 __call__ 特殊方法。

尽管前向传递的逻辑需要在此函数内定义，但之后应调用 `Module` 实例而不是此函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。

转录示例

>>> from transformers import WhisperProcessor, FlaxWhisperForConditionalGeneration
>>> from datasets import load_dataset

>>> processor = WhisperProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = FlaxWhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en", from_pt=True)
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> inputs = processor(ds[0]["audio"]["array"], return_tensors="np")
>>> input_features = inputs.input_features
>>> generated_ids = model.generate(input_ids=input_features)
>>> transcription = processor.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> transcription
' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.'

FlaxWhisperForAudioClassification

class transformers.FlaxWhisperForAudioClassification

< >

( config: WhisperConfig input_shape: typing.Optional[tuple[int]] = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )

参数

  • config (WhisperConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
  • dtype (jax.numpy.dtype，可选，默认为 jax.numpy.float32) — 计算的数据类型。可以是 jax.numpy.float32、jax.numpy.float16（在 GPU 上）和 jax.numpy.bfloat16（在 TPU 上）之一。这可用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定，所有计算都将使用给定的 dtype 执行。请注意，这仅指定计算的 dtype，不影响模型参数的 dtype。 如果你想更改模型参数的 dtype，请参阅 to_fp16() 和 to_bf16()。

Whisper 模型顶部带有一个音频分类头。此模型继承自 FlaxPreTrainedModel。请查看超类文档以了解该库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头部等）。该模型也是 Flax Linen flax.nn.Module 的子类。可以像常规 Flax 模块一样使用它，并参考 Flax 文档了解与通用用法和行为相关的所有事项。最后，该模型支持固有的 JAX 功能，例如

__call__

< >

( input_features: Array attention_mask: typing.Optional[jax.Array] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None train: bool = False params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None **kwargs ) → transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput 或 tuple(torch.FloatTensor)

参数

  • input_features (numpy.ndarray，形状为 (batch_size, feature_size, sequence_length)) — 从原始语音波形中提取的浮点值梅尔特征。原始语音波形可以通过将 .flac 或 .wav 音频文件加载到 list[float] 类型或 numpy.ndarray 类型的数组中获得，例如通过 soundfile 库（pip install soundfile）。要将数组准备成 input_features，应使用 WhisperFeatureExtractor 提取特征、进行填充并转换为 numpy.ndarray 类型的张量。详见 call()。
  • attention_mask (numpy.ndarray，形状为 (batch_size, sequence_length)，可选) — Whisper 不支持对 input_features进行掩码操作，保留此参数是为了兼容性，但并未使用。默认情况下，输入对数梅尔频谱图中的静音部分会被忽略。
  • decoder_input_ids (numpy.ndarray，形状为 (batch_size, target_sequence_length)，可选) — 解码器输入序列在词汇表中的标记索引。可以使用 WhisperTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是解码器输入 ID？ Whisper 使用 decoder_start_token_id 作为生成 decoder_input_ids 的起始标记。
  • decoder_attention_mask (numpy.ndarray，形状为 (batch_size, target_sequence_length)，可选) — 默认行为：生成一个忽略 decoder_input_ids 中填充标记的张量。默认情况下也会使用因果掩码。如果你想更改填充行为，应根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图 1。
  • position_ids (numpy.ndarray，形状为 (batch_size, sequence_length)，可选) — Whisper 在编码器中不使用 position_ids，因为 input_features 的大小总是相同的，并且不使用掩码，但保留此参数是为了兼容性。默认情况下，输入对数梅尔频谱图中的静音部分会被忽略。
  • decoder_position_ids (numpy.ndarray，形状为 (batch_size, sequence_length)，可选) — 解码器每个输入序列标记在位置嵌入中的位置索引。在 [0, config.max_position_embeddings - 1] 范围内选择。
  • output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
  • return_dict (bool，可选) — 是返回一个 ModelOutput 而不是一个普通元组。

返回

transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False），包含根据配置（WhisperConfig）和输入而定的各种元素。

  • logits (形状为 (batch_size, config.num_labels) 的 jnp.ndarray) — 分类（如果 config.num_labels==1，则为回归）分数（SoftMax 之前）。

  • hidden_states (tuple(jnp.ndarray)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — jnp.ndarray 的元组（一个用于嵌入层的输出 + 每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

    模型在每个层输出的隐藏状态加上初始嵌入输出。

  • attentions (tuple(jnp.ndarray)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — jnp.ndarray 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

FlaxWhisperForAudioClassification 的前向方法，覆盖了 `__call__` 特殊方法。

尽管前向传递的逻辑需要在此函数内定义，但之后应调用 `Module` 实例而不是此函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。

转录示例

>>> import jax.numpy as jnp
>>> from transformers import AutoFeatureExtractor, FlaxWhisperForAudioClassification
>>> from datasets import load_dataset

>>> feature_extractor = AutoFeatureExtractor.from_pretrained("sanchit-gandhi/whisper-medium-fleurs-lang-id")
>>> model = FlaxWhisperForAudioClassification.from_pretrained(
...     "sanchit-gandhi/whisper-medium-fleurs-lang-id", from_pt=True
... )
>>> ds = load_dataset("google/fleurs", "all", split="validation", streaming=True)

>>> sample = next(iter(ds))

>>> inputs = feature_extractor(
...     sample["audio"]["array"], sampling_rate=sample["audio"]["sampling_rate"], return_tensors="np"
... )
>>> input_features = inputs.input_features

>>> logits = model(input_features).logits

>>> predicted_class_ids = jnp.argmax(logits).item()
>>> predicted_label = model.config.id2label[predicted_class_ids]
>>> predicted_label
'af_za'
< > 在 GitHub 上更新

←WavLM XLS-R→