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→
© . This site is unofficial and not affiliated with Hugging Face, Inc.