Transformers 文档
Whisper
并获取增强的文档体验
开始使用
Whisper
概述
Whisper 模型由 Alec Radford、Jong Wook Kim、Tao Xu、Greg Brockman、Christine McLeavey、Ilya Sutskever 在 Robust Speech Recognition via Large-Scale Weak Supervision 中提出。
该论文的摘要如下
我们研究了语音处理系统的能力，这些系统经过训练，可以简单地预测互联网上大量音频的文字记录。当扩展到 680,000 小时的多语言和多任务监督时，由此产生的模型可以很好地泛化到标准基准，并且在零样本迁移设置中，通常与先前的完全监督结果相媲美，而无需任何微调。与人类相比，这些模型接近他们的准确性和鲁棒性。我们正在发布模型和推理代码，作为进一步研究稳健语音处理的基础。
此模型由 Arthur Zucker 贡献。此模型的 Tensorflow 版本由 amyeroberts 贡献。原始代码可以在 这里 找到。
快速使用
您可以使用少于 4 行代码运行 Whisper，并在不到一分钟的时间内进行转录！
# pip install transformers torch
import torch
from transformers import pipeline
whisper = pipeline("automatic-speech-recognition", "openai/whisper-large-v3", torch_dtype=torch.float16, device="cuda:0")
transcription = whisper("<audio_file.mp3>")
print(transcription["text"])瞧！您可以根据您的需求，在 Hugging Face Hub 上使用任何 Whisper 检查点 替换模型，并使用相同的管道。
奖励：您可以将 "cuda" 替换为 "mps"，使其在 Mac 上无缝工作。
使用技巧
该模型通常表现良好，无需任何微调。
该架构遵循经典的编码器-解码器架构，这意味着它依赖于 generate() 函数进行推理。
可以使用 WhisperProcessor 为模型准备音频，并将预测的 ID 解码回文本。
要转换模型和处理器，我们建议使用以下方法
python src/transformers/models/whisper/convert_openai_to_hf.py --checkpoint_path "" --pytorch_dump_folder_path "Arthur/whisper-3" --convert_preprocessor True该脚本将自动从 OpenAI 检查点确定所有必要的参数。需要安装 tiktoken 库以执行从 OpenAI 分词器到 tokenizers 版本的转换。
推理
以下是使用预训练的 Whisper 模型转录音频样本的逐步指南
>>> from datasets import load_dataset
>>> from transformers import WhisperProcessor, WhisperForConditionalGeneration
>>> # Select an audio file and read it:
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> audio_sample = ds[0]["audio"]
>>> # Load the Whisper model in Hugging Face format:
>>> processor = WhisperProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en")
>>> # Use the model and processor to transcribe the audio:
>>> input_features = processor(
... audio_sample["array"], sampling_rate=audio_sample["sampling_rate"], return_tensors="pt"
... ).input_features
>>> # Generate token ids
>>> predicted_ids = model.generate(input_features)
>>> # Decode token ids to text
>>> transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)
>>> transcription[0]
' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.'Whisper 与以下针对短格式和长格式生成的优化兼容
- PyTorch 缩放点积注意力 (SDPA)：闪存注意力和内存高效的注意力内核。默认情况下为
torch>=2.1.1启用。 - Flash Attention 2：通过更好的并行性和工作分区改进闪存注意力的实现。
- torch.compile：JIT 编译前向传递以分派到高效的融合内核。
例如，以下代码片段启用 SDPA 和 torch.compile，推理速度最多可提高 5 倍
>>> from datasets import load_dataset
>>> from transformers import WhisperProcessor, WhisperForConditionalGeneration
>>> # Select an audio file and read it:
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> audio_sample = ds[0]["audio"]
>>> # Load the Whisper model with SDPA attention
>>> processor = WhisperProcessor.from_pretrained("openai/whisper-tiny.en")
>>> model = WhisperForConditionalGeneration.from_pretrained("openai/whisper-tiny.en", attn_implementation="sdpa")
>>> # Enable static cache and compile the forward pass
>>> model.generation_config.cache_implementation = "static"
>>> model.forward = torch.compile(model.forward, mode="reduce-overhead", fullgraph=True)
>>> # Use the model and processor to transcribe the audio:
>>> input_features = processor(
... audio_sample["array"], sampling_rate=audio_sample["sampling_rate"], return_tensors="pt"
... ).input_features
>>> # Compile the forward pass
>>> for _ in range(2):
>>> model.generate(input_features)
>>> # Generate token ids using compiled graph (fast!)
>>> predicted_ids = model.generate(input_features)
>>> # Decode token ids to text
>>> transcription = processor.batch_decode(predicted_ids, skip_special_tokens=True)
>>> transcription[0]
' Mr. Quilter is the apostle of the middle classes, and we are glad to welcome his gospel.'有关每项优化的更多详细信息，请参阅上面链接的文档。
资源
官方 Hugging Face 和社区（🌎 表示）资源列表，可帮助您开始使用 Whisper。如果您有兴趣提交资源以包含在此处，请随时打开 Pull Request，我们将对其进行审核！理想情况下，该资源应展示一些新内容，而不是重复现有资源。
- 微调 Whisper，在您自己的数据集上以获得更好的下游性能。
- Distil-Whisper：速度快 6 倍，体积小 2 倍的英语蒸馏 Whisper 模型。我们发布了模型检查点和 蒸馏代码。
- 一个分支，其中包含一个脚本，用于将 Hugging Face 格式的 Whisper 模型转换为 OpenAI 格式。🌎 使用示例
pip install -U openai-whisper
python convert_hf_to_openai.py \
--checkpoint openai/whisper-tiny \
--whisper_dump_path whisper-tiny-openai.ptWhisperConfig
class transformers.WhisperConfig
< source >( 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) — 每个输入特征使用的 mel 特征数量。应与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 论文](see https://arxiv.org/abs/1909.11556)。 - decoder_layerdrop (
float, 可选, 默认为 0.0) — 解码器的 LayerDrop 概率。 有关更多详细信息，请参阅 [LayerDrop 论文](see https://arxiv.org/abs/1909.11556)。 - decoder_start_token_id (
int, 可选, 默认为 50257) — 对应于 “<|startoftranscript|>” 标记，当没有为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) — 此模型可能使用的 log-mel 滤波器组特征的最大序列长度。 - max_target_positions (
int, 可选, 默认为 448) — 此模型可能使用的最大序列长度。 通常将其设置为较大的值以防万一（例如，512 或 1024 或 2048）。 - pad_token_id (
int, 可选, 默认为 50256) — 填充标记 id。 - bos_token_id (
int, 可选, 默认为 50256) — 流开始标记 id。 - eos_token_id (
int, 可选, 默认为 50256) — 流结束标记 id。 - suppress_tokens (
List[int], 可选) — 包含非语音标记的列表，这些标记将由generate函数中的 logits 处理器使用。 NON_SPEECH_TOKENS 和 NON_SPEECH_TOKENS_MULTI 分别对应于english-only和multilingual模型。 - begin_suppress_tokens (
List[int], 可选, 默认为[220,50256]) — 包含将在采样过程开始时抑制的标记的列表。 初始化为" "(blank_token_id) 和eos_token_id的标记 - use_weighted_layer_sum (
bool, 可选, 默认为False) — 是否使用具有学习权重的层输出的加权平均值。 仅在使用 WhisperForAudioClassification 的实例时相关。 - classifier_proj_size (
int, 可选, 默认为 256) — 分类前标记均值池化之前的投影维度。 仅在使用 WhisperForAudioClassification 的实例时相关。 - apply_spec_augment (
bool, 可选, 默认为False) — 是否将 SpecAugment 数据增强应用于特征编码器的输出。 有关参考，请参阅 SpecAugment：一种用于自动语音识别的简单数据增强方法。 - 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) — 用于平滑交叉注意力输出以计算令牌时间戳的中值滤波器宽度。应为奇数。
这是用于存储 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.configWhisperTokenizer
class transformers.WhisperTokenizer
< source >( 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) — merges 文件的路径。 - 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
< source >( language: str = None task: str = None predict_timestamps: bool = None )
覆盖附加到标签序列开头的前缀令牌。 此方法可以单独使用来
通过附加 eos_token_id 从序列构建模型输入。
get_special_tokens_mask
< source >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None already_has_special_tokens: bool = False ) → List[int]
从不包含特殊 token 的 token 列表中检索序列 id。当使用 tokenizer 的 prepare_for_model 方法添加特殊 token 时，会调用此方法。
create_token_type_ids_from_sequences
< source >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → List[int]
创建与传递的序列相对应的 token 类型 ID。 什么是 token 类型 ID？
如果模型具有构建这些 ID 的特殊方式，则应在子类中重写此方法。
batch_decode
< source >( sequences: typing.Union[typing.List[int], typing.List[typing.List[int]], ForwardRef('np.ndarray'), ForwardRef('torch.Tensor'), ForwardRef('tf.Tensor')] skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None **kwargs ) → List[str]
参数
- sequences (
Union[List[int], List[List[int]], np.ndarray, torch.Tensor, tf.Tensor]) — token 化输入 id 列表。可以使用__call__方法获取。 - skip_special_tokens (
bool, 可选, 默认为False) — 是否在解码中移除特殊 token。 - clean_up_tokenization_spaces (
bool, 可选) — 是否清理 token 化空格。如果为None，则默认为self.clean_up_tokenization_spaces。 - kwargs (附加关键字参数, 可选) — 将传递给底层模型特定的解码方法。
返回
List[str]
解码后的句子列表。
通过调用 decode 将 token id 列表转换为字符串列表。
decode
< source >( token_ids skip_special_tokens: bool = False clean_up_tokenization_spaces: 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]) — token 化输入 id 列表。可以使用__call__方法获取。 - skip_special_tokens (
bool, 可选, 默认为False) — 是否在解码中移除特殊 token。如果存在先前的 token（前置提示），则会移除这些 token。 - clean_up_tokenization_spaces (
bool, 可选) — 是否清理 token 化空格。如果为None，则默认为self.clean_up_tokenization_spaces(在tokenizer_config中可用)。 - output_offsets (
bool, 可选, 默认为False) — 是否输出 token 的偏移量。仅当模型预测了时间戳时才应设置此项。如果存在要解码的先前 token（前置提示），则它们仅在包含时间戳 token 时才会出现在解码后的文本中。 - time_precision (
float, 可选, 默认为 0.02) — 从 token 转换为时间的时比率。 - decode_with_timestamps (
bool, 可选, 默认为False) — 是否使用包含在原始文本中的时间戳进行解码。 - normalize (
bool, 可选, 默认为False) — 是否对解码后的文本应用英文文本规范化器。仅当目标文本为英文时适用。否则，应应用基本文本规范化器。 - basic_normalize (
bool, 可选, 默认为False) — 是否对解码后的文本应用基本文本规范化器。适用于多语言目标文本。 - remove_diacritics (
bool, 可选, 默认为False) — 是否在应用基本文本规范化器时移除音调符号。移除音调符号可能会破坏解码文本中的信息，因此应谨慎使用。 - kwargs (附加关键字参数, 可选) — 将传递给底层模型特定的解码方法。
返回
str
解码后的句子。
使用 tokenizer 和词汇表，将 id 序列转换为字符串，可以选择移除特殊 token 并清理 token 化空格。
类似于执行 self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))。
使用 BasicTextNormalizer 类规范化给定的字符串，该类对多语言文本执行常用转换。
使用 EnglishTextNormalizer 类规范化给定的字符串，该类对英文文本执行常用转换。
WhisperTokenizerFast
class transformers.WhisperTokenizerFast
< source >( 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, optional) — Vocabulary 文件的路径。 - merges_file (
str, optional) — Merges 文件的路径。 - normalizer_file (
str, optional) — Normalizer 文件的路径。 - tokenizer_file (
str, optional) — tokenizers 文件的路径（通常带有 .json 扩展名），其中包含加载 tokenizer 所需的一切。 - unk_token (
str, optional, defaults to"<|endoftext|>") — 未知 token。词汇表中不存在的 token 无法转换为 ID，并将设置为此 token。 - bos_token (
str, optional, defaults to"<|endoftext|>") — 序列开始 token。生成时，decoder_start_token_id用于将第一个 token 设置为"<|startoftranscript|>"。 - eos_token (
str, optional, defaults to"<|endoftext|>") — 序列结束 token。 - add_prefix_space (
bool, optional, defaults toFalse) — 是否在输入前添加一个初始空格。这允许像处理任何其他单词一样处理引导词。（Whisper tokenizer 通过前面的空格检测单词的开头）。 - language (
str, optional) — 转录文本的语言。相应的语言 ID token 将附加到多语言语音识别和语音翻译任务的序列开头，例如，对于西班牙语，token"<|es|>"将附加到序列的开头。这应仅用于多语言微调。 - task (
str, optional) — 要附加到序列开头的任务标识符（如果有）。这应与多语言微调一起使用，语音识别使用"transcribe"，语音翻译使用"translate"。 - predict_timestamps (
bool, optional, defaults toFalse) — 是否在序列开头省略<|notimestamps|>token。
构建一个“快速” Whisper tokenizer（由 HuggingFace 的 tokenizers 库支持）。
此 tokenizer 继承自 PreTrainedTokenizerFast，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
set_prefix_tokens
< source >( language: str = None task: str = None predict_timestamps: bool = None )
覆盖附加到标签序列开头的前缀令牌。 此方法可以单独使用来
通过附加 eos_token_id 从序列构建模型输入。
get_special_tokens_mask
< source >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None already_has_special_tokens: bool = False ) → List[int]
从不包含特殊 token 的 token 列表中检索序列 id。当使用 tokenizer 的 prepare_for_model 方法添加特殊 token 时，会调用此方法。
create_token_type_ids_from_sequences
< source >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → List[int]
创建与传递的序列相对应的 token 类型 ID。 什么是 token 类型 ID？
如果模型具有构建这些 ID 的特殊方式，则应在子类中重写此方法。
batch_decode
< source >( sequences: typing.Union[typing.List[int], typing.List[typing.List[int]], ForwardRef('np.ndarray'), ForwardRef('torch.Tensor'), ForwardRef('tf.Tensor')] skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None **kwargs ) → List[str]
参数
- sequences (
Union[List[int], List[List[int]], np.ndarray, torch.Tensor, tf.Tensor]) — token 化输入 ID 列表。可以使用__call__方法获得。 - skip_special_tokens (
bool, optional, defaults toFalse) — 是否在解码中删除特殊 token。 - clean_up_tokenization_spaces (
bool, optional) — 是否清理 token 化空格。如果为None，将默认为self.clean_up_tokenization_spaces。 - kwargs (附加的关键字参数，optional) — 将传递给底层模型特定的解码方法。
返回
List[str]
解码后的句子列表。
通过调用 decode 将 token id 列表转换为字符串列表。
decode
< 源码 >( token_ids skip_special_tokens: bool = False clean_up_tokenization_spaces: 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, optional, 默认为False) — 是否在解码时移除特殊 token。 如果存在，将移除之前的 token (pre-prompt)。 - clean_up_tokenization_spaces (
bool, optional) — 是否清理分词空格。 如果为None，将默认为self.clean_up_tokenization_spaces(在tokenizer_config中可用)。 - output_offsets (
bool, optional, 默认为False) — 是否输出 token 的偏移量。 只有当模型预测了时间戳时才应设置此项。 如果有之前的 token (pre-prompt) 需要解码，则只有当它们包含时间戳 token 时，它们才会出现在解码后的文本中。 - time_precision (
float, optional, 默认为 0.02) — 从 token 转换为时间的比率。 - decode_with_timestamps (
bool, optional, 默认为False) — 是否解码原始文本中包含的时间戳。 - normalize (
bool, optional, 默认为False) — 是否对解码后的文本应用英文文本标准化器。 仅当目标文本为英文时适用。 否则，应应用基本文本标准化器。 - basic_normalize (
bool, optional, 默认为False) — 是否对解码后的文本应用基本文本标准化器。 适用于多语言目标文本。 - remove_diacritics (
bool, optional, 默认为False) — 在应用基本文本标准化器时，是否移除音调符。 移除音调符可能会破坏解码文本中的信息，因此应谨慎使用。 - kwargs (其他关键字参数, optional) — 将传递给底层模型特定的解码方法。
返回
str
解码后的句子。
使用 tokenizer 和词汇表，将 id 序列转换为字符串，可以选择移除特殊 token 并清理 token 化空格。
类似于执行 self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))。
使用 BasicTextNormalizer 类规范化给定的字符串，该类对多语言文本执行常用转换。
使用 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, optional, 默认为 80) — 提取特征的特征维度。 - sampling_rate (
int, optional, 默认为 16000) — 音频文件应数字化的采样率，以赫兹 (Hz) 表示。 - hop_length (
int, optional, 默认为 160) — 用于获取梅尔频率倒谱系数的 STFT 的重叠窗口长度。 - chunk_length (
int, optional, 默认为 30) — 用于修剪和填充较长或较短音频序列的sampling_rate样本的最大块数。 - n_fft (
int, optional, 默认为 400) — 傅里叶变换的大小。 - padding_value (
float, optional, 默认为 0.0) — 用于填充音频的填充值。 应与静音对应。 - dither (
float, optional, 默认为 0.0) — 添加抖动。 换句话说，向每个帧添加少量高斯噪声。 例如，使用 0.0001 添加抖动，抖动具有以 0.0 为中心且标准差为 0.0001 的正态分布（假设 raw_speech 的范围为 [-1,+1]）。 值 0.0 表示不抖动。 抖动具有与spectrogram(mel_floor=...)类似的效果。 它减少了具有硬零部分的信号的高 log_mel_fbank 值，当信号中存在 VAD 截止时。
构建 Whisper 特征提取器。
此特征提取器继承自 SequenceFeatureExtractor，其中包含大多数主要方法。 用户应参考此超类以获取有关这些方法的更多信息。
此类使用 短时傅里叶变换 的自定义 numpy 实现从原始语音中提取梅尔滤波器组特征，该实现应与 pytorch 的 torch.stft 等效项匹配。
__call__
< 源码 >( raw_speech: typing.Union[numpy.ndarray, typing.List[float], typing.List[numpy.ndarray], typing.List[typing.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, optional, 默认为True) — 激活截断，以将长于 max_length 的输入序列裁剪为 max_length。 - pad_to_multiple_of (
int, 可选, 默认为 None) — 如果设置，将会把序列填充为所提供值的倍数。这对于在计算能力
>= 7.5(Volta) 的 NVIDIA 硬件上启用 Tensor Cores，或者在从序列长度为 128 的倍数中获益的 TPU 上尤其有用。 - return_attention_mask (
bool, 可选) — 是否返回 attention mask。如果保留为默认值，将根据特定 feature_extractor 的默认值返回 attention mask。对于 Whisper 模型，应该始终传递
attention_mask用于批量推理，以避免细微的错误。 - return_tensors (
str或 TensorType, 可选) — 如果设置，将返回 tensors 而不是 python 整数列表。可接受的值为：'tf': 返回 TensorFlowtf.constant对象。'pt': 返回 PyTorchtorch.Tensor对象。'np': 返回 Numpynp.ndarray对象。
- sampling_rate (
int, 可选) —raw_speech输入被采样的采样率。强烈建议在前向调用中传递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) — 是否返回输入 raw_speech 的帧数。这些 num_frames 可以被模型用来计算单词级时间戳。
用于特征化并为模型准备一个或多个序列的主要方法。如果可用，实现使用 PyTorch 进行 STFT 计算，否则使用较慢的基于 NumPy 的实现。
WhisperProcessor
class transformers.WhisperProcessor
< source >( feature_extractor tokenizer )
参数
- feature_extractor (
WhisperFeatureExtractor) — WhisperFeatureExtractor 的一个实例。feature extractor 是必需的输入。 - tokenizer (
WhisperTokenizer) — WhisperTokenizer 的一个实例。tokenizer 是必需的输入。
构建一个 Whisper processor，它将 Whisper feature extractor 和 Whisper tokenizer 包装到单个 processor 中。
WhisperProcessor 提供 WhisperFeatureExtractor 和 WhisperTokenizer 的所有功能。有关更多信息，请参阅 call() 和 decode()。
from_pretrained
< source >( 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或os.PathLike) — 可以是以下之一：- 一个字符串，即托管在 huggingface.co 的模型仓库中的预训练 feature_extractor 的模型 ID。
- 一个目录的路径，其中包含使用 save_pretrained() 方法保存的 feature extractor 文件，例如，
./my_model_directory/。 - 保存的 feature extractor JSON 文件的路径或 URL，例如，
./my_model_directory/preprocessor_config.json。
- **kwargs — 传递给 from_pretrained() 和
~tokenization_utils_base.PreTrainedTokenizer.from_pretrained的其他关键字参数。
实例化与预训练模型关联的 processor。
此类方法只是调用 feature extractor from_pretrained()、图像处理器 ImageProcessingMixin 和 tokenizer ~tokenization_utils_base.PreTrainedTokenizer.from_pretrained 方法。有关更多信息，请参阅上述方法的文档字符串。
save_pretrained
< source >( save_directory push_to_hub: bool = False **kwargs )
参数
- save_directory (
str或os.PathLike) — 将在其中保存 feature extractor JSON 文件和 tokenizer 文件的目录（如果目录不存在，则将创建该目录）。 - push_to_hub (
bool, 可选, 默认为False) — 是否在保存模型后将其推送到 Hugging Face 模型 hub。您可以使用repo_id指定要推送到的存储库（默认为您命名空间中save_directory的名称）。 - kwargs (
Dict[str, Any], 可选) — 传递给 push_to_hub() 方法的其他关键字参数。
将此 processor 的属性（feature extractor、tokenizer…）保存在指定的目录中，以便可以使用 from_pretrained() 方法重新加载它。
此类方法只是调用 save_pretrained() 和 save_pretrained()。有关更多信息，请参阅上述方法的文档字符串。
此方法将其所有参数转发到 WhisperTokenizer 的 batch_decode()。有关更多信息，请参阅此方法的文档字符串。
此方法将其所有参数转发到 WhisperTokenizer 的 decode()。有关更多信息，请参阅此方法的文档字符串。
WhisperModel
class transformers.WhisperModel
< 源码 >( config: WhisperConfig )
参数
- config (WhisperConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。
裸 Whisper 模型，输出原始隐藏状态，顶部没有任何特定的 head。此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch Module，并参考 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[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None past_key_values: typing.Union[transformers.cache_utils.EncoderDecoderCache, typing.Tuple[torch.FloatTensor], NoneType] = None decoder_inputs_embeds: typing.Optional[typing.Tuple[torch.FloatTensor]] = None decoder_position_ids: typing.Optional[typing.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 或 tuple(torch.FloatTensor)
参数
- input_features (形状为
(batch_size, feature_size, sequence_length)的torch.FloatTensor) — 从原始语音波形中提取的浮点值梅尔特征。原始语音波形可以通过将.flac或.wav音频文件加载到List[float]类型或numpy.ndarray类型的数组中来获得，例如 通过 soundfile 库（pip install soundfile）。为了将数组准备为input_features，应该使用 AutoFeatureExtractor 来提取梅尔特征、填充并转换为torch.FloatTensor类型的张量。 请参阅 call() - attention_mask (形状为
(batch_size, sequence_length)的torch.LongTensor，可选) — 用于避免对填充 token 索引执行 SpecAugment 数据增强的掩码。掩码值在[0, 1]中选择：- 1 表示 token 未被掩蔽，
- 0 表示 token 被掩蔽。
- decoder_input_ids (形状为
(batch_size, target_sequence_length)的torch.LongTensor，可选) — 词汇表中解码器输入序列 token 的索引。索引可以使用 WhisperTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
Whisper 使用
decoder_start_token_id作为decoder_input_ids生成的起始 token。如果使用past_key_values，则可以选择仅输入最后一个decoder_input_ids（请参阅past_key_values）。 - decoder_attention_mask (形状为
(batch_size, target_sequence_length)的torch.LongTensor，可选) — 默认行为：生成一个忽略decoder_input_ids中填充 token 的张量。默认情况下，也会使用因果掩码。如果您想更改填充行为，您应该阅读
modeling_whisper._prepare_decoder_attention_mask并根据您的需要进行修改。有关默认策略的更多信息，请参阅 BART 论文 中的图 1。 - head_mask (形状为
(encoder_layers, encoder_attention_heads)的torch.Tensor，可选) — 用于使编码器中注意力模块的选定 head 失效的掩码。掩码值在[0, 1]中选择：- 1 表示 head 未被掩蔽，
- 0 表示 head 被掩蔽。
- decoder_head_mask (形状为
(decoder_layers, decoder_attention_heads)的torch.Tensor，可选) — 用于使解码器中注意力模块的选定 head 失效的掩码。掩码值在[0, 1]中选择：- 1 表示 head 未被掩蔽，
- 0 表示 head 被掩蔽。
- cross_attn_head_mask (形状为
(decoder_layers, decoder_attention_heads)的torch.Tensor，可选) — 用于使交叉注意力模块的选定 head 失效的掩码。掩码值在[0, 1]中选择：- 1 表示 head 未被掩蔽，
- 0 表示 head 被掩蔽。
- encoder_outputs (
tuple(tuple(torch.FloatTensor), 可选) — 元组由 (last_hidden_state, 可选:hidden_states, 可选:attentions) 组成，形状为(batch_size, sequence_length, hidden_size)的last_hidden_state，可选) 是编码器最后一层输出的隐藏状态序列。在解码器的交叉注意力中使用。 - past_key_values (
EncoderDecoderCache或tuple(tuple(torch.FloatTensor)), 可选) — 预先计算的隐藏状态，可用于加速自回归（顺序）解码。有四组预先计算的隐藏状态：自注意力块 (2) 和交叉注意力块 (2) 中的键和值状态。当传递use_cache=True或当config.use_cache=True时，将返回past_key_values。允许两种格式：
- EncoderDecoderCache 实例；
- 长度为
config.n_layers的tuple(torch.FloatTensor)元组，每个元组具有 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_input_ids（那些没有将其过去的键值状态提供给此模型的）的形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。 - decoder_inputs_embeds (形状为
(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递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 而不是普通元组。 - cache_position (形状为
(sequence_length)的torch.LongTensor，可选) — 描述输入序列 token 在序列中位置的索引。它用于在正确的位置更新缓存并推断完整序列长度。
返回
transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Seq2SeqModelOutput 或一个 torch.FloatTensor 元组（如果传递 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (WhisperConfig) 和输入。
-
last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor) — 模型解码器最后一层输出的隐藏状态序列。如果使用
past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。 -
past_key_values (
tuple(tuple(torch.FloatTensor)), 可选, 当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组具有 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(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入输出提供一个，+ 每个层的输出提供一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出的隐藏状态，以及可选的初始嵌入输出。
-
decoder_attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力 head 中的加权平均值。
-
cross_attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力 head 中的加权平均值。
-
encoder_last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor, 可选) — 模型编码器最后一层输出的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入输出提供一个，+ 每个层的输出提供一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出的隐藏状态，以及可选的初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力 head 中的加权平均值。
WhisperModel forward 方法，覆盖了 __call__ 特殊方法。
虽然 forward 传递的配方需要在该函数内定义，但之后应该调用 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
< source >( input_features: FloatTensor attention_mask: typing.Optional[torch.LongTensor] = None )
根据 SpecAugment，沿时间轴和/或特征轴遮蔽提取的特征。
WhisperForConditionalGeneration
class transformers.WhisperForConditionalGeneration
< source >( config: WhisperConfig )
参数
- config (WhisperConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。请查看 from_pretrained() 方法来加载模型权重。
带有语言建模头的 Whisper 模型。可用于自动语音识别。此模型继承自 PreTrainedModel。请查看超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch Module，并参考 PyTorch 文档，了解与常规用法和行为相关的所有事项。
forward
< source >( 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[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None past_key_values: typing.Union[transformers.cache_utils.EncoderDecoderCache, typing.Tuple[torch.FloatTensor], NoneType] = None decoder_inputs_embeds: typing.Optional[typing.Tuple[torch.FloatTensor]] = None decoder_position_ids: typing.Optional[typing.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 (形状为
(batch_size, feature_size, sequence_length)的torch.FloatTensor) — 从原始语音波形中提取的浮点值梅尔特征。原始语音波形可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如通过 soundfile 库 (pip install soundfile)。为了将数组准备为input_features，应使用 AutoFeatureExtractor 来提取梅尔特征，进行填充并转换为torch.FloatTensor类型的张量。请参阅 call() - attention_mask (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 用于避免对填充标记索引执行 SpecAugment 数据增强的掩码。掩码值在[0, 1]中选择：- 1 表示标记未被掩蔽，
- 0 表示标记已被掩蔽。
- decoder_input_ids (形状为
(batch_size, target_sequence_length)的torch.LongTensor, 可选) — 词汇表中解码器输入序列标记的索引。索引可以使用 WhisperTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
Whisper 使用
decoder_start_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则可以选择仅输入最后一个decoder_input_ids（请参阅past_key_values）。 - decoder_attention_mask (形状为
(batch_size, target_sequence_length)的torch.LongTensor, 可选) — 默认行为：生成一个张量，该张量忽略decoder_input_ids中的填充标记。默认情况下，还将使用因果掩码。如果您想更改填充行为，则应阅读
modeling_whisper._prepare_decoder_attention_mask并根据您的需求进行修改。有关默认策略的更多信息，请参见 BART 论文 中的图 1。 - head_mask (形状为
(encoder_layers, encoder_attention_heads)的torch.Tensor, 可选) — 用于使编码器中注意力模块的选定头无效的掩码。掩码值在[0, 1]中选择：- 1 表示头未被掩蔽，
- 0 表示头已被掩蔽。
- decoder_head_mask (形状为
(decoder_layers, decoder_attention_heads)的torch.Tensor, 可选) — 用于使解码器中注意力模块的选定头无效的掩码。掩码值在[0, 1]中选择：- 1 表示头未被掩蔽，
- 0 表示头已被掩蔽。
- cross_attn_head_mask (形状为
(decoder_layers, decoder_attention_heads)的torch.Tensor, 可选) — 用于使交叉注意力模块的选定头无效的掩码。掩码值在[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 (
EncoderDecoderCache或tuple(tuple(torch.FloatTensor)), 可选) — 预先计算的隐藏状态，可用于加速自回归（顺序）解码。共有四组预先计算的隐藏状态：自注意力块 (2) 和交叉注意力块 (2) 中的键和值状态。当传递use_cache=True或config.use_cache=True时，将返回past_key_values。允许两种格式：
- EncoderDecoderCache 实例；
- 长度为
config.n_layers的tuple(torch.FloatTensor)元组，其中每个元组具有 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_input_ids（那些没有将其过去的键值状态提供给此模型的decoder_input_ids），形状为(batch_size, 1)，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。 - decoder_inputs_embeds (形状为
(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor, 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递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 而不是纯元组。 - cache_position (形状为
(sequence_length)的torch.LongTensor, 可选) — 描述输入序列标记在序列中位置的索引。它用于在正确的位置更新缓存并推断完整序列长度。 - labels (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 用于计算语言建模损失的标签。索引应为[0, ..., config.vocab_size]或 -100（请参阅input_ids文档字符串）。索引设置为-100的标记将被忽略（掩蔽），损失仅针对标签在[0, ..., config.vocab_size]中的标记计算。sequence_length应小于或等于config.max_target_positions。
返回
transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Seq2SeqLMOutput 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (WhisperConfig) 和输入。
-
loss (形状为
(1,)的torch.FloatTensor, 可选, 当提供labels时返回) — 语言建模损失。 -
logits (形状为
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。 -
past_key_values (
tuple(tuple(torch.FloatTensor)), 可选, 当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组具有 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(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入输出提供一个，+ 每个层的输出提供一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出端的隐藏状态，加上初始嵌入输出。
-
decoder_attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力 head 中的加权平均值。
-
cross_attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力 head 中的加权平均值。
-
encoder_last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor, 可选) — 模型编码器最后一层输出的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入输出提供一个，+ 每个层的输出提供一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出端的隐藏状态，加上初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力 head 中的加权平均值。
WhisperForConditionalGeneration 的 forward 方法，覆盖了 __call__ 特殊方法。
虽然 forward 传递的配方需要在该函数内定义，但之后应该调用 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.'generate
< source >( 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], typing.List[int]]] = None synced_gpus: bool = False return_timestamps: typing.Optional[bool] = None task: typing.Optional[str] = None language: typing.Union[str, typing.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, typing.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 or Dict[str, Any] or torch.LongTensor
参数
- input_features (
torch.Tensor，形状为(batch_size, feature_size, sequence_length)，可选) — 从原始语音波形中提取的 log-mel 特征的浮点数值。原始语音波形可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如 通过 soundfile 库 (pip install soundfile)。为了将数组准备成input_features，应该使用 AutoFeatureExtractor 来提取 mel 特征，进行填充并转换为torch.FloatTensor类型的张量。有关详细信息，请参阅 call()。 - generation_config (GenerationConfig, 可选) — 用作生成调用的基本参数化的生成配置。传递给 generate 的与
generation_config属性匹配的**kwargs将覆盖它们。如果未提供generation_config，将使用默认值，其加载优先级如下：1) 来自generation_config.json模型文件（如果存在）；2) 来自模型配置。请注意，未指定的参数将继承 GenerationConfig 的默认值，应检查其文档以参数化生成。 - logits_processor (
LogitsProcessorList, 可选) — 自定义 logits 处理器，用于补充从参数和生成配置构建的默认 logits 处理器。如果传递的 logits 处理器已经使用参数或生成配置创建，则会抛出错误。此功能适用于高级用户。 - stopping_criteria (
StoppingCriteriaList, 可选) — 自定义停止标准，用于补充从参数和生成配置构建的默认停止标准。如果传递的停止标准已经使用参数或生成配置创建，则会抛出错误。此功能适用于高级用户。 - prefix_allowed_tokens_fn (
Callable[[int, torch.Tensor], List[int]], 可选) — 如果提供，此函数会在每个步骤中将束搜索约束为仅允许的 token。如果未提供，则不应用约束。此函数接受 2 个参数：批次 IDbatch_id和input_ids。它必须返回一个列表，其中包含下一个生成步骤的允许 token，条件是批次 IDbatch_id和先前生成的 tokeninputs_ids。此参数对于基于前缀的约束生成非常有用，如 Autoregressive Entity Retrieval 中所述。 - synced_gpus (
bool, 可选, 默认为False) — 是否继续运行 while 循环直到 max_length（避免与FullyShardedDataParallel和 DeepSpeed ZeRO Stage 3 死锁所必需）。 - return_timestamps (
bool, 可选) — 是否返回带有文本的时间戳。这将启用WhisperTimestampsLogitsProcessor。 - task (
str, 可选) — 用于生成的任务，可以是 “translate” 或 “transcribe”。model.config.forced_decoder_ids将会相应更新。 - language (
str或str列表, 可选) — 用于生成的语言 token，可以是<|en|>、en或english的形式。对于批量生成，可以传递语言 token 列表。您可以在model.generation_config.lang_to_id字典中找到所有可能的语言 token。 - is_multilingual (
bool, 可选) — 模型是否为多语言模型。 - prompt_ids (
torch.Tensor, 可选) — 通过将文本传递给get_prompt_ids()创建的 token ID 的 Rank-1 张量，作为每个分块的提示提供。这可以用于为转录提供或“提示工程”上下文，例如自定义词汇表或专有名词，使其更有可能正确预测这些词。它不能与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, 可选) — 仅与长格式转录相关。如果已定义，“no-speech” token 与logprob_threshold结合使用，以确定片段是否仅包含静音。在这种情况下，将跳过此片段的转录。如 Whisper 论文 所示，这有助于提高性能。 - num_segment_frames (
int, 可选) — 单个片段由多少帧组成。如果未定义，num_segment_frames默认为模型的步幅乘以最大输入长度。 - attention_mask (
torch.Tensor, 可选) — 当使用 batch size > 1 进行长格式转录时，需要传递attention_mask。 - time_precision (
int, 可选, 默认为 0.02) — 输出 token 的时长，单位为秒。例如，0.02 表示生成的 token 平均占 20 毫秒。 - time_precision_features (
int, 可选, 默认为 0.01) — 特征帧表示的时长，单位为秒。 - return_token_timestamps (
bool, 可选) — 是否返回文本的 token 级别时间戳。可以与return_timestamps选项一起使用，也可以单独使用。要获取词级别时间戳，请使用 tokenizer 将 token 分组为词。 - return_segments (
bool, 可选, 默认为False) — 是否额外返回所有 segment 的列表。请注意，此选项仅在进行长格式转录时启用。 - return_dict_in_generate (
bool, 可选, 默认为False) — 是否返回 ModelOutput 而不是仅返回生成的 token。请注意，在进行长格式转录时，只有当return_segments设置为 True 时，才能启用return_dict_in_generate。在这种情况下，每个 segment 的生成输出都会添加到每个 segment 中。 - force_unique_generate_call (
bool, 可选) — 是否强制对底层 GenerationMixin 的 generate() 方法进行唯一调用。这对于辅助解码和测试目的非常有用，以确保仅调用一次 generate()，从而返回解码器输入 token id 和 eos token id。 - kwargs (
Dict[str, Any], 可选) —generate_config的特别参数化和/或将转发到模型的forward函数的其他模型特定 kwargs。如果模型是编码器-解码器模型，则编码器特定的 kwargs 不应带有前缀，而解码器特定的 kwargs 应带有 decoder_ 前缀。
返回
ModelOutput 或 Dict[str, Any] 或 torch.LongTensor
A
- ModelOutput 当
return_dict_in_generate=True且 (return_timestamps=False或force_unique_generate_call=True) 时，包括解码器输入 id 和序列结束 id。 Dict[str, Any]当 (return_dict_in_generate=True且return_timestamps=True) 或return_segments=True或return_token_timestamps=True时。torch.LongTensor在所有其他情况下，不包括解码器输入 id 和序列结束 id。
可能的 ModelOutput 类型为
segments 是 segment 列表的列表（每个 batch 元素一个列表）。segment 是一个字典，键为 start、end、tokens、idxs 和 result。
start：segment 的开始时间戳。end：segment 的结束时间戳。tokens：segment 的 token，不包括解码器输入 id 和序列结束 id。idxs：在底层调用 GenerationMixin 的 generate()（存在于result中）时，segment 的tokens的起始（包含）和结束（不包含）索引。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
< source >( config )
参数
- config (WhisperConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
带有语言建模头的 Whisper 解码器（权重与输入 embedding 绑定的线性层）。
此模型继承自 PreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入 embedding 大小、剪枝 head 等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch Module，并参考 PyTorch 文档，了解与常规用法和行为相关的所有事项。
forward
< source >( input_ids: LongTensor = None attention_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[typing.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[typing.Tuple[typing.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 的索引。如果您提供 padding，默认情况下将被忽略。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是输入 ID？ - attention_mask (
torch.Tensor，形状为(batch_size, sequence_length), 可选) — Mask，用于避免在 padding token 索引上执行 attention。Mask 值在[0, 1]中选择：- 1 表示 token 未被 mask，
- 0 表示 token 已被 mask。什么是 attention mask？
- encoder_outputs (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size), 可选) — 编码器最后一层输出的 hidden-states 序列。如果模型配置为解码器，则在 cross-attention 中使用。 - head_mask (
torch.Tensor，形状为(decoder_layers, decoder_attention_heads), 可选) — Mask，用于使 attention 模块的选定 head 失效。Mask 值在[0, 1]中选择：- 1 表示 head 未被 mask，
- 0 表示 head 已被 mask。
- cross_attn_head_mask (
torch.Tensor，形状为(decoder_layers, decoder_attention_heads), 可选) — Mask，用于使 cross-attention 模块的选定 head 失效。Mask 值在[0, 1]中选择：- 1 表示 head 未被 mask，
- 0 表示 head 已被 mask。
- past_key_values (
tuple(tuple(torch.FloatTensor)), 可选, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(tuple(torch.FloatTensor))元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的 tensor 和 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的附加 tensor。仅当模型用作序列到序列模型中的解码器时，才需要这两个附加 tensor。包含预先计算的 hidden-states（self-attention 块和 cross-attention 块中的 key 和 value），这些 hidden-states 可以使用（参见past_key_values输入）以加速顺序解码。如果使用past_key_values，则用户可以选择仅输入形状为(batch_size, 1)的最后一个decoder_input_ids（那些没有将其过去的 key value 状态提供给此模型的decoder_input_ids），而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。 - inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size), 可选) — （可选）您可以选择直接传递 embedding 表示，而不是传递input_ids。如果您希望比模型的内部 embedding 查找矩阵更精细地控制如何将input_ids索引转换为关联向量，这将非常有用。 - labels (
torch.LongTensor，形状为(batch_size, sequence_length), 可选) — 用于计算 masked language modeling loss 的标签。索引应为[0, ..., config.vocab_size]或 -100（请参阅input_ids文档字符串）。索引设置为-100的 token 将被忽略（masked），loss 仅针对标签在[0, ..., config.vocab_size]中的 token 计算。 - use_cache (
bool, optional) — If set toTrue,past_key_values键值状态会被返回，并可用于加速解码（参见past_key_values）。- 1 代表 未被掩码 的 tokens，
- 0 代表 被掩码 的 tokens。
- output_attentions (
bool, optional) — 是否返回所有注意力层的注意力张量。 详见返回张量下的attentions获取更多细节。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。 详见返回张量下的hidden_states获取更多细节。 - return_dict (
bool, optional) — 是否返回一个 ModelOutput 对象而不是一个普通的元组。 - cache_position (
torch.LongTensor，形状为(sequence_length), optional) — 索引描述了输入序列 tokens 在序列中的位置。 它用于在正确的位置更新缓存，并推断完整的序列长度。
返回
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,), optional, 当提供labels时返回) — 语言建模损失 (用于预测下一个 token)。 -
logits (形状为
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。 -
hidden_states (
tuple(torch.FloatTensor), optional, 当output_hidden_states=True被传递，或者当config.output_hidden_states=True时返回) —torch.FloatTensor的元组 (对于嵌入的输出，如果模型有嵌入层，则有一个；对于每一层的输出，各有一个)，形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出端的隐藏状态，加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor), optional, 当output_attentions=True被传递，或者当config.output_attentions=True时返回) —torch.FloatTensor的元组 (每一层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
-
cross_attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。交叉注意力 softmax 之后的交叉注意力权重，用于计算交叉注意力头中的加权平均值。
-
past_key_values (
tuple(tuple(torch.FloatTensor)), optional, 当use_cache=True被传递，或者当config.use_cache=True时返回) — 长度为config.n_layers的torch.FloatTensor元组的元组，每个元组包含自注意力缓存的键值状态，以及当模型用于编码器-解码器设置时，交叉注意力的键值状态。 仅当config.is_decoder = True时相关。包含预先计算的隐藏状态 (注意力块中的键和值)，可以用于加速顺序解码 (参见
past_key_values输入)。
示例
>>> 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
< source >( config )
参数
- 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() - head_mask (
torch.Tensor，形状为(encoder_layers, encoder_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), optional)，是编码器最后一层输出端的隐藏状态序列。 - output_attentions (
bool, optional) — 是否返回所有注意力层的注意力张量。 详见返回张量下的attentions获取更多细节。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。 详见返回张量下的hidden_states获取更多细节。 - return_dict (
bool, optional) — 是否返回一个 ModelOutput 对象而不是一个普通的元组。
Whisper 编码器模型，顶部带有一个序列分类头 (池化输出之上的线性层)，用于诸如 SUPERB 关键词识别之类的任务。
forward
< source >( input_features: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[typing.Tuple[typing.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)) — 从原始语音波形中提取的浮点值梅尔特征。原始语音波形可以通过将.flac或.wav音频文件加载到List[float]类型的数组或numpy.ndarray中获得，例如 通过 soundfile 库 (pip install soundfile)。为了将数组准备成input_features，应该使用 AutoFeatureExtractor 来提取梅尔特征，进行填充并转换为torch.FloatTensor类型的张量。 参见 call() - head_mask (
torch.Tensor，形状为(encoder_layers, encoder_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), optional)，是编码器最后一层输出端的隐藏状态序列。 - output_attentions (
bool, optional) — 是否返回所有注意力层的注意力张量。 详见返回张量下的attentions获取更多细节。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。 详见返回张量下的hidden_states获取更多细节。 - return_dict (
bool, optional) — 是否返回一个 ModelOutput 对象而不是一个普通的元组。 - labels (
torch.LongTensor，形状为(batch_size,), optional) — 用于计算序列分类/回归损失的标签。索引应该在[0, ..., config.num_labels - 1]中。如果config.num_labels == 1，则计算回归损失 (均方误差损失)。 如果config.num_labels > 1，则计算分类损失 (交叉熵损失)。
返回
transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.SequenceClassifierOutput 对象，或者一个 torch.FloatTensor 元组 (如果 return_dict=False 被传递，或者当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (WhisperConfig) 和输入。
-
loss (
torch.FloatTensor，形状为(1,), optional, 当提供labels时返回) — 分类损失 (如果 config.num_labels==1，则为回归损失)。 -
logits (
torch.FloatTensor，形状为(batch_size, config.num_labels)) — 分类分数 (或回归分数，如果 config.num_labels==1) (在 SoftMax 之前)。 -
hidden_states (
tuple(torch.FloatTensor), optional, 当output_hidden_states=True被传递，或者当config.output_hidden_states=True时返回) —torch.FloatTensor的元组 (对于嵌入的输出，如果模型有嵌入层，则有一个；对于每一层的输出，各有一个)，形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出端的隐藏状态，加上可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor), optional, 当output_attentions=True被传递，或者当config.output_attentions=True时返回) —torch.FloatTensor的元组 (每一层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
WhisperForAudioClassification 的 forward 方法，覆盖了 __call__ 特殊方法。
虽然 forward 传递的配方需要在该函数内定义，但之后应该调用 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
< source >( config: WhisperConfig **kwargs )
参数
- config (WhisperConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。
裸 Whisper 模型，输出原始的隐藏状态，顶部没有任何特定的头部。此模型继承自 TFPreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是 keras.Model 子类。将其用作常规 TF 2.0 Keras 模型，并参阅 TF 2.0 文档，了解与通用用法和行为相关的所有事项。
call
< source >( 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 (形状为
(batch_size, feature_size, sequence_length)的tf.Tensor) — 从原始语音波形中提取的 fbank 特征的浮点值。原始语音波形可以通过将.flac或.wav音频文件加载到类型为List[float]或numpy.ndarray的数组中获得，例如 通过 soundfile 库 (pip install soundfile)。为了将数组准备成input_features，应该使用 AutoFeatureExtractor 来提取 fbank 特征，进行填充并转换为tf.Tensor类型的张量。参见 call() - decoder_input_ids (形状为
(batch_size, target_sequence_length)的tf.Tensor, 可选) — 词汇表中解码器输入序列标记的索引。索引可以使用
SpeechToTextTokenizer获得。参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 获取详细信息。SpeechToText 使用
eos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则可以选择仅输入最后一个decoder_input_ids（参见past_key_values）。 - decoder_attention_mask (形状为
(batch_size, target_sequence_length)的tf.Tensor, 可选) — 默认行为：生成一个张量，该张量忽略decoder_input_ids中的填充标记。默认情况下，也将使用因果掩码。如果您想更改填充行为，您应该阅读
modeling_whisper._prepare_decoder_attention_mask并根据您的需要进行修改。有关默认策略的更多信息，请参见 论文 中的图 1。 - head_mask (形状为
(encoder_layers, encoder_attention_heads)的tf.Tensor, 可选) — 用于使编码器中注意力模块的选定头部无效的掩码。在[0, 1]中选择的掩码值：- 1 表示头部未被掩盖，
- 0 表示头部被掩盖。
- decoder_head_mask (形状为
(decoder_layers, decoder_attention_heads)的tf.Tensor, 可选) — 用于使解码器中注意力模块的选定头部无效的掩码。在[0, 1]中选择的掩码值：- 1 表示头部未被掩盖，
- 0 表示头部被掩盖。
- cross_attn_head_mask (形状为
(decoder_layers, decoder_attention_heads)的tf.Tensor, 可选) — 用于使交叉注意力模块的选定头部无效的掩码。在[0, 1]中选择的掩码值：- 1 表示头部未被掩盖，
- 0 表示头部被掩盖。
- encoder_outputs (
tuple(tuple(tf.Tensor), 可选) — 元组由 (last_hidden_state, 可选:hidden_states, 可选:attentions) 组成，形状为(batch_size, sequence_length, hidden_size)的last_hidden_state, 可选) 是编码器最后一层的输出处的隐藏状态序列。在解码器的交叉注意力中使用。 - past_key_values (
tuple(tuple(tf.Tensor)), 可选, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(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，用户可以选择仅输入最后一个decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。 - decoder_inputs_embeds (形状为
(batch_size, target_sequence_length, hidden_size)的tf.Tensor, 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递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 之后，用于计算自注意力 head 中的加权平均值。
-
cross_attentions (
tuple(tf.Tensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力 head 中的加权平均值。
-
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 之后，用于计算自注意力 head 中的加权平均值。
TFWhisperModel 前向方法，覆盖了 __call__ 特殊方法。
虽然 forward 传递的配方需要在该函数内定义，但之后应该调用 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
< source >( config: WhisperConfig **kwargs )
参数
- config (WhisperConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。
带有语言建模头的 Whisper 模型。可用于自动语音识别。此模型继承自 TFPreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是 keras.Model 子类。将其用作常规 TF 2.0 Keras 模型，并参阅 TF 2.0 文档，了解与通用用法和行为相关的所有事项。
call
< source >( 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 (形状为
(batch_size, feature_size, sequence_length)的tf.Tensor) — 从原始语音波形中提取的 fbank 特征的浮点数值。原始语音波形可以通过将.flac或.wav音频文件加载到List[float]类型或numpy.ndarray类型的数组中获得，例如 通过 soundfile 库 (pip install soundfile)。为了将数组准备为input_features，应该使用 AutoFeatureExtractor 来提取 fbank 特征、进行填充和转换为tf.Tensor类型的张量。 请参阅 call() - decoder_input_ids (形状为
(batch_size, target_sequence_length)的tf.Tensor, 可选) — 词汇表中解码器输入序列 tokens 的索引。索引可以使用
SpeechToTextTokenizer获得。请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详情。SpeechToText 使用
eos_token_id作为decoder_input_ids生成的起始 token。如果使用了past_key_values，则可以选择仅输入最后一个decoder_input_ids(请参阅past_key_values)。 - decoder_attention_mask (形状为
(batch_size, target_sequence_length)的tf.Tensor, 可选) — 默认行为：生成一个忽略decoder_input_ids中的填充 tokens 的张量。默认情况下也会使用因果掩码。如果要更改填充行为，应阅读
modeling_whisper._prepare_decoder_attention_mask并根据您的需求进行修改。有关默认策略的更多信息，请参阅 论文 中的图 1。 - head_mask (形状为
(encoder_layers, encoder_attention_heads)的tf.Tensor, 可选) — 用于 nullify 编码器中注意力模块的选定 heads 的掩码。在[0, 1]中选择的掩码值：- 1 表示 head 未被掩蔽，
- 0 表示 head 被掩蔽。
- decoder_head_mask (形状为
(decoder_layers, decoder_attention_heads)的tf.Tensor, 可选) — 用于 nullify 解码器中注意力模块的选定 heads 的掩码。在[0, 1]中选择的掩码值：- 1 表示 head 未被掩蔽，
- 0 表示 head 被掩蔽。
- cross_attn_head_mask (形状为
(decoder_layers, decoder_attention_heads)的tf.Tensor, 可选) — 用于 nullify 交叉注意力模块的选定 heads 的掩码。在[0, 1]中选择的掩码值：- 1 表示 head 未被掩蔽，
- 0 表示 head 被掩蔽。
- 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(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，用户可以选择仅输入最后一个decoder_input_ids（那些没有将其过去键值状态提供给此模型的）的形状为(batch_size, 1)而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。 - decoder_inputs_embeds (形状为
(batch_size, target_sequence_length, hidden_size)的tf.Tensor, 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递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 张量。有关更多详细信息，请参阅返回的张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 - labels (形状为
(batch_size, sequence_length)的tf.Tensor, 可选) — 用于计算语言建模损失的标签。索引应在[0, ..., config.vocab_size]或 -100 中（请参阅input_ids文档字符串）。索引设置为-100的 tokens 将被忽略（掩蔽），损失仅针对标签在[0, ..., config.vocab_size]中的 tokens 计算。
返回
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, 可选, 当提供labels时返回) — 语言建模损失。 -
logits (形状为
(batch_size, sequence_length, config.vocab_size)的tf.Tensor) — 语言建模 head 的预测分数（SoftMax 之前每个词汇表 token 的分数）。 -
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 之后，用于计算自注意力 head 中的加权平均值。
-
cross_attentions (
tuple(tf.Tensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力 head 中的加权平均值。
-
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 之后，用于计算自注意力 head 中的加权平均值。
TFWhisperForConditionalGeneration 前向方法，覆盖了 __call__ 特殊方法。
虽然 forward 传递的配方需要在该函数内定义，但之后应该调用 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
< source >( config: WhisperConfig input_shape: typing.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 Model transformer 输出原始隐藏状态，顶部没有任何特定的 head。此模型继承自 FlaxPreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。此模型也是 Flax Linen flax.nn.Module 子类。将其用作常规 Flax Module，并参考 Flax 文档以了解与常规用法和行为相关的所有事项。最后，此模型支持固有的 JAX 特性，例如
__call__
< source >( 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: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = 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), 可选) — 词汇表中解码器输入序列 tokens 的索引。索引可以使用 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中的填充 tokens。默认情况下也会使用因果掩码。如果您想更改填充行为，则应根据您的需要进行修改。有关默认策略的更多信息，请参见 论文 中的图 1。 - position_ids (
numpy.ndarray，形状为(batch_size, sequence_length), 可选) — Whisper 在编码器中不使用position_ids，因为input_features始终具有相同的大小并且不使用掩码，但是此参数保留是为了兼容性。默认情况下，输入日志梅尔频谱图中的静音将被忽略。 - decoder_position_ids (
numpy.ndarray，形状为(batch_size, sequence_length), 可选) — 位置嵌入中每个解码器输入序列 tokens 的位置索引。在范围[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 (
jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层的输出处的隐藏状态序列。如果使用
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(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 之后，用于计算自注意力 head 中的加权平均值。
-
cross_attentions (
tuple(jnp.ndarray), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力 head 中的加权平均值。
-
encoder_last_hidden_state (
jnp.ndarray，形状为(batch_size, sequence_length, hidden_size), 可选) — 模型编码器最后一层的输出处的隐藏状态序列。 -
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 之后，用于计算自注意力 head 中的加权平均值。
FlaxWhisperPreTrainedModel 的 forward 方法，覆盖了 __call__ 特殊方法。
虽然 forward 传递的配方需要在该函数内定义，但之后应该调用 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_stateFlaxWhisperForConditionalGeneration
class transformers.FlaxWhisperForConditionalGeneration
< source >( config: WhisperConfig input_shape: typing.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__
< source >( 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: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = 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), 可选) — 词汇表中解码器输入序列 tokens 的索引。索引可以使用 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中的填充 tokens。默认情况下也会使用因果掩码。如果您想更改填充行为，则应根据您的需要进行修改。有关默认策略的更多信息，请参见 论文 中的图 1。 - position_ids (
numpy.ndarray，形状为(batch_size, sequence_length), 可选) — Whisper 在编码器中不使用position_ids，因为input_features始终具有相同的大小并且不使用掩码，但是此参数保留是为了兼容性。默认情况下，输入日志梅尔频谱图中的静音将被忽略。 - decoder_position_ids (
numpy.ndarray，形状为(batch_size, sequence_length), 可选) — 位置嵌入中每个解码器输入序列 tokens 的位置索引。在范围[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 之前的每个词汇标记的分数）。 -
past_key_values (
tuple(tuple(jnp.ndarray)), 可选, 当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(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 之后，用于计算自注意力 head 中的加权平均值。
-
cross_attentions (
tuple(jnp.ndarray), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —jnp.ndarray元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力 head 中的加权平均值。
-
encoder_last_hidden_state (
jnp.ndarray，形状为(batch_size, sequence_length, hidden_size), 可选) — 模型编码器最后一层的输出处的隐藏状态序列。 -
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 之后，用于计算自注意力 head 中的加权平均值。
FlaxWhisperPreTrainedModel 的 forward 方法，覆盖了 __call__ 特殊方法。
虽然 forward 传递的配方需要在该函数内定义，但之后应该调用 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
< source >( config: WhisperConfig input_shape: typing.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__
< source >( 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: dict = None dropout_rng: <function PRNGKey at 0x7f787eb14310> = None **kwargs ) → transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_features (形状为
(batch_size, feature_size, sequence_length)的numpy.ndarray) — 从原始语音波形中提取的浮点值梅尔特征。原始语音波形可以通过将.flac或.wav音频文件加载到List[float]类型或numpy.ndarray类型的数组中获得，例如 通过 soundfile 库 (pip install soundfile)。为了将数组准备成input_features，应该使用 WhisperFeatureExtractor 来提取特征、填充和转换为numpy.ndarray类型的张量。参见 call() - attention_mask (形状为
(batch_size, sequence_length)的numpy.ndarray, 可选) — Whisper 不支持input_features的掩码，此参数保留是为了兼容性，但未使用。默认情况下，输入 log mel 频谱图中的静音会被忽略。 - decoder_input_ids (形状为
(batch_size, target_sequence_length)的numpy.ndarray, 可选) — 词汇表中解码器输入序列标记的索引。索引可以使用 WhisperTokenizer 获得。参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以了解详情。 什么是解码器输入 ID？ Whisper 使用decoder_start_token_id作为decoder_input_ids生成的起始标记。 - decoder_attention_mask (形状为
(batch_size, target_sequence_length)的numpy.ndarray, 可选) — 默认行为：生成一个张量，该张量忽略decoder_input_ids中的填充标记。默认情况下，也会使用因果掩码。如果您想更改填充行为，则应根据需要进行修改。有关默认策略的更多信息，请参见 论文 中的图 1。 - position_ids (形状为
(batch_size, sequence_length)的numpy.ndarray, 可选) — Whisper 在编码器中不使用position_ids，因为input_features始终为相同大小且不使用掩码，但保留此参数是为了兼容性。默认情况下，输入 log mel 频谱图中的静音会被忽略。 - decoder_position_ids (形状为
(batch_size, sequence_length)的numpy.ndarray, 可选) — 位置嵌入中每个解码器输入序列标记的位置索引。在范围[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时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（每个嵌入输出一个 + 每层输出一个）。模型在每一层输出以及初始嵌入输出处的隐藏状态。
-
attentions (
tuple(jnp.ndarray), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
FlaxWhisperForAudioClassification 前向方法，覆盖了 __call__ 特殊方法。
虽然 forward 传递的配方需要在该函数内定义，但之后应该调用 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, trust_remote_code=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'