Transformers 文件
Wav2Vec2
並獲得增強的文件體驗
開始使用
Wav2Vec2
概述
Wav2Vec2 模型由 Alexei Baevski, Henry Zhou, Abdelrahman Mohamed, Michael Auli 在 wav2vec 2.0: 一種自監督學習語音表示的框架 中提出。
論文摘要如下：
我們首次證明，僅從語音音訊中學習強大的表示，然後對轉錄語音進行微調，可以超越最好的半監督方法，同時概念上更簡單。wav2vec 2.0 在潛在空間中遮蔽語音輸入，並解決基於聯合學習的潛在表示量化的對比任務。使用 Librispeech 所有標註資料的實驗在 clean/other 測試集上分別獲得了 1.8/3.3 WER。當將標註資料量降低到一小時時，wav2vec 2.0 在 100 小時子集上超越了之前最先進的方法，同時使用了 100 倍更少的標註資料。僅使用十分鐘標註資料並在 53k 小時未標註資料上進行預訓練，仍然可以實現 4.8/8.2 WER。這證明了在有限標註資料下進行語音識別的可行性。
此模型由 patrickvonplaten 貢獻。
注意：Meta (FAIR) 釋出了新版 Wav2Vec2-BERT 2.0 - 它在 4.5M 小時音訊資料上進行了預訓練。我們特別推薦將其用於微調任務，例如根據 本指南。
使用技巧
- Wav2Vec2 是一個語音模型，它接受一個浮點陣列，該陣列對應於語音訊號的原始波形。
- Wav2Vec2 模型使用連線主義時間分類 (CTC) 進行訓練，因此模型輸出必須使用 Wav2Vec2CTCTokenizer 進行解碼。
[!NOTE] 當使用除“eager”之外的所有注意力實現時，`head_mask` 引數將被忽略。如果您有 `head_mask` 並希望其生效，請使用 `XXXModel.from_pretrained(model_id, attn_implementation="eager")` 載入模型。
使用 Flash Attention 2
Flash Attention 2 是一個更快、更最佳化的模型版本。
安裝
首先，檢查您的硬體是否與 Flash Attention 2 相容。相容硬體的最新列表可在 官方文件 中找到。如果您的硬體與 Flash Attention 2 不相容，您仍然可以透過 上面 介紹的 Better Transformer 支援，從注意力核最佳化中受益。
接下來，安裝 最新版本的 Flash Attention 2
pip install -U flash-attn --no-build-isolation
用法
要使用 Flash Attention 2 載入模型，我們可以將引數 `attn_implementation="flash_attention_2"` 傳遞給 `。from_pretrained`。我們還將以半精度（例如 `torch.float16`）載入模型，因為這幾乎不會降低音訊質量，但能顯著降低記憶體使用並加快推理速度。
>>> from transformers import Wav2Vec2Model
model = Wav2Vec2Model.from_pretrained("facebook/wav2vec2-large-960h-lv60-self", torch_dtype=torch.float16, attn_implementation="flash_attention_2").to(device)
...預期加速
以下是比較 `facebook/wav2vec2-large-960h-lv60-self` 模型在 Transformers 中的原生實現與 flash-attention-2 和 sdpa（標量點積注意力）版本之間純推理時間的預期加速圖。我們展示了在 `librispeech_asr` `clean` 驗證集上獲得的平均加速。
資源
一份官方 Hugging Face 和社群（用🌎表示）資源列表，幫助您開始使用 Wav2Vec2。如果您有興趣提交資源以供收錄在此處，請隨時開啟拉取請求，我們將對其進行審查！資源應理想地展示一些新內容，而不是重複現有資源。
- 一份關於如何利用預訓練的 Wav2Vec2 模型進行情感分類的筆記本。🌎
- Wav2Vec2ForCTC 受到此示例指令碼和筆記本的支援。
- 音訊分類任務指南
- 一篇關於在 🤗 Transformers 中使用 n-gram 提升 Wav2Vec2 的部落格文章。
- 一篇關於如何使用 🤗 Transformers 微調 Wav2Vec2 進行英語 ASR 的部落格文章。
- 一篇關於使用 🤗 Transformers 微調 XLS-R 進行多語言 ASR 的部落格文章。
- 一份關於如何透過 Wav2Vec2 轉錄音訊從任何影片建立 YouTube 字幕的筆記本。🌎
- Wav2Vec2ForCTC 受到一份關於如何在英語中微調語音識別模型以及如何在任何語言中微調語音識別模型的筆記本的支援。
- 自動語音識別任務指南
🚀 部署
- 一篇關於如何使用 Hugging Face 的 Transformers 和 Amazon SageMaker 部署 Wav2Vec2 進行自動語音識別的部落格文章。
Wav2Vec2Config
class transformers.Wav2Vec2Config
< 來源 >( vocab_size = 32 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout = 0.1 activation_dropout = 0.1 attention_dropout = 0.1 feat_proj_dropout = 0.0 feat_quantizer_dropout = 0.0 final_dropout = 0.1 layerdrop = 0.1 initializer_range = 0.02 layer_norm_eps = 1e-05 feat_extract_norm = 'group' feat_extract_activation = 'gelu' conv_dim = (512, 512, 512, 512, 512, 512, 512) conv_stride = (5, 2, 2, 2, 2, 2, 2) conv_kernel = (10, 3, 3, 3, 3, 2, 2) conv_bias = False num_conv_pos_embeddings = 128 num_conv_pos_embedding_groups = 16 do_stable_layer_norm = False apply_spec_augment = True 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 num_codevectors_per_group = 320 num_codevector_groups = 2 contrastive_logits_temperature = 0.1 num_negatives = 100 codevector_dim = 256 proj_codevector_dim = 256 diversity_loss_weight = 0.1 ctc_loss_reduction = 'sum' ctc_zero_infinity = False use_weighted_layer_sum = False classifier_proj_size = 256 tdnn_dim = (512, 512, 512, 512, 1500) tdnn_kernel = (5, 3, 3, 1, 1) tdnn_dilation = (1, 2, 3, 1, 1) xvector_output_dim = 512 pad_token_id = 0 bos_token_id = 1 eos_token_id = 2 add_adapter = False adapter_kernel_size = 3 adapter_stride = 2 num_adapter_layers = 3 output_hidden_size = None adapter_attn_dim = None **kwargs )
引數
- vocab_size (
int, 可選, 預設值為 32) — Wav2Vec2 模型的詞彙表大小。定義了呼叫 Wav2Vec2Model 或 TFWav2Vec2Model 時傳入的 `inputs_ids` 可以表示的不同 token 數量。模型的詞彙表大小。定義了可由傳入 Wav2Vec2Model 前向方法的 inputs_ids 表示的不同 token。 - hidden_size (
int, 可選, 預設值為 768) — 編碼器層和池化層的維度。 - num_hidden_layers (
int, 可選, 預設值為 12) — Transformer 編碼器中的隱藏層數量。 - num_attention_heads (
int, 可選, 預設值為 12) — Transformer 編碼器中每個注意力層的注意力頭數量。 - intermediate_size (
int, 可選, 預設值為 3072) — Transformer 編碼器中“中間”（即前饋）層的維度。 - hidden_act (
str或function, 可選, 預設值為"gelu") — 編碼器和池化器中的非線性啟用函式（函式或字串）。如果是字串，支援"gelu","relu","selu"和"gelu_new"。 - hidden_dropout (
float, 可選, 預設值為 0.1) — 嵌入、編碼器和池化器中所有全連線層的 dropout 機率。 - activation_dropout (
float, 可選, 預設值為 0.1) — 全連線層內部啟用的 dropout 比例。 - attention_dropout (
float, 可選, 預設值為 0.1) — 注意力機率的 dropout 比例。 - final_dropout (
float, 可選, 預設值為 0.1) — Wav2Vec2ForCTC 最終投影層的 dropout 機率。 - layerdrop (
float, 可選, 預設值為 0.1) — LayerDrop 機率。更多詳情請參見 [LayerDrop 論文](參見 https://huggingface.co/papers/1909.11556)。 - initializer_range (
float, 可選, 預設值為 0.02) — 用於初始化所有權重矩陣的截斷正態初始化器的標準差。 - layer_norm_eps (
float, 可選, 預設值為 1e-12) — 層歸一化層使用的 epsilon 值。 - feat_extract_norm (
str, 可選, 預設值為"group") — 應用於特徵編碼器中 1D 卷積層的歸一化型別。可以是"group"(僅對第一個 1D 卷積層進行組歸一化) 或"layer"(對所有 1D 卷積層進行層歸一化)。 - feat_proj_dropout (
float, 可選, 預設值為 0.0) — 特徵編碼器輸出的 dropout 機率。 - feat_extract_activation (
str,可選, 預設值為“gelu”) -- 特徵提取器中 1D 卷積層的非線性啟用函式（函式或字串）。如果是字串，支援“gelu”,“relu”,“selu”和“gelu_new”`。 - feat_quantizer_dropout (
float, 可選, 預設值為 0.0) — 量化特徵編碼器狀態的 dropout 機率。 - conv_dim (
tuple[int]或list[int], 可選, 預設值為(512, 512, 512, 512, 512, 512, 512)) — 一個整數元組，定義特徵編碼器中每個 1D 卷積層的輸入和輸出通道數。conv_dim 的長度定義了 1D 卷積層的數量。 - conv_stride (
tuple[int]或list[int], 可選, 預設值為(5, 2, 2, 2, 2, 2, 2)) — 一個整數元組，定義特徵編碼器中每個 1D 卷積層的步長。conv_stride 的長度定義了卷積層的數量，並且必須與 conv_dim 的長度匹配。 - conv_kernel (
tuple[int]或list[int], 可選, 預設值為(10, 3, 3, 3, 3, 3, 3)) — 一個整數元組，定義特徵編碼器中每個 1D 卷積層的核大小。conv_kernel 的長度定義了卷積層的數量，並且必須與 conv_dim 的長度匹配。 - conv_bias (
bool, 可選, 預設值為False) — 1D 卷積層是否帶有偏置。 - num_conv_pos_embeddings (
int, 可選, 預設值為 128) — 卷積位置嵌入的數量。定義了 1D 卷積位置嵌入層的核大小。 - num_conv_pos_embedding_groups (
int, 可選, 預設值為 16) — 1D 卷積位置嵌入層的組數。 - do_stable_layer_norm (
bool, 可選, 預設值為False) — 是否應用 Transformer 編碼器的 stable 層歸一化架構。do_stable_layer_norm is True對應於在注意力層之前應用層歸一化，而do_stable_layer_norm is False對應於在注意力層之後應用層歸一化。 - apply_spec_augment (
bool, 可選, 預設值為True) — 是否將 SpecAugment 資料增強應用於特徵編碼器的輸出。參考 SpecAugment: 一種簡單的自動語音識別資料增強方法。 - mask_time_prob (
float, 可選, 預設值為 0.05) — 將被遮蔽的沿時間軸的所有特徵向量的百分比（介於 0 和 1 之間）。遮蔽過程會在該軸上生成 “mask_time_problen(time_axis)/mask_time_length” 個獨立的遮蔽。如果根據每個特徵向量被選為要遮蔽的向量範圍起始點的機率來推斷，則 mask_time_prob 應為 `prob_vector_startmask_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_problen(feature_axis)/mask_time_length” 個獨立的遮蔽。如果根據每個特徵向量被選為要遮蔽的向量範圍起始點的機率來推斷，則 mask_feature_prob 應為 `prob_vector_startmask_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” 時相關。 - num_codevectors_per_group (
int, 可選, 預設值為 320) — 每個量化碼本（組）中的條目數量。 - num_codevector_groups (
int, 可選, 預設值為 2) — 積碼本量化的碼向量組數量。 - contrastive_logits_temperature (
float, 可選, 預設值為 0.1) — 對比損失中的溫度 kappa。 - feat_quantizer_dropout (
float, optional, defaults to 0.0) — 特徵編碼器輸出用於量化器的 dropout 機率。 - num_negatives (
int, optional, defaults to 100) — 對比損失的負樣本數量。 - codevector_dim (
int, optional, defaults to 256) — 量化特徵向量的維度。 - proj_codevector_dim (
int, optional, defaults to 256) — 量化特徵和變換器特徵的最終投影維度。 - diversity_loss_weight (
int, optional, defaults to 0.1) — 碼本多樣性損失分量的權重。 - ctc_loss_reduction (
str, optional, defaults to"sum") — 指定應用於torch.nn.CTCLoss輸出的 reduction。僅在訓練 Wav2Vec2ForCTC 例項時相關。 - ctc_zero_infinity (
bool, optional, defaults toFalse) — 是否將torch.nn.CTCLoss的無限損失和相關梯度置零。無限損失主要發生在輸入太短而無法與目標對齊時。僅在訓練 Wav2Vec2ForCTC 例項時相關。 - use_weighted_layer_sum (
bool, optional, defaults toFalse) — 是否使用學習權重對層輸出進行加權平均。僅在使用 Wav2Vec2ForSequenceClassification 例項時相關。 - classifier_proj_size (
int, optional, defaults to 256) — 分類前進行 token 均值池化的投影維度。 - tdnn_dim (
tuple[int]或list[int], optional, defaults to(512, 512, 512, 512, 1500)) — 定義 *XVector* 模型 *TDNN* 模組中每個 1D 卷積層的輸出通道數的整數元組。*tdnn_dim* 的長度定義了 *TDNN* 層的數量。 - tdnn_kernel (
tuple[int]或list[int], optional, defaults to(5, 3, 3, 1, 1)) — 定義 *XVector* 模型 *TDNN* 模組中每個 1D 卷積層的核大小的整數元組。*tdnn_kernel* 的長度必須與 *tdnn_dim* 的長度匹配。 - tdnn_dilation (
tuple[int]或list[int], optional, defaults to(1, 2, 3, 1, 1)) — 定義 *XVector* 模型 *TDNN* 模組中每個 1D 卷積層的膨脹係數的整數元組。*tdnn_dilation* 的長度必須與 *tdnn_dim* 的長度匹配。 - xvector_output_dim (
int, optional, defaults to 512) — *XVector* 嵌入向量的維度。 - add_adapter (
bool, optional, defaults toFalse) — 是否在 Wav2Vec2 編碼器之上堆疊卷積網路。對於 SpeechEncoderDecoder 模型的熱啟動 Wav2Vec2 非常有用。 - adapter_kernel_size (
int, optional, defaults to 3) — 介面卡網路中卷積層的核大小。僅當add_adapter 為 True時相關。 - adapter_stride (
int, optional, defaults to 2) — 介面卡網路中卷積層的步長。僅當add_adapter 為 True時相關。 - num_adapter_layers (
int, optional, defaults to 3) — 介面卡網路中應使用的卷積層數量。僅當add_adapter 為 True時相關。 - adapter_attn_dim (
int, optional) — 在每個注意力塊中使用的注意力介面卡權重的維度。使用注意力介面卡的模型示例是 facebook/mms-1b-all。 - output_hidden_size (
int, optional) — 編碼器輸出層的維度。如果未定義，則預設為 *hidden-size*。僅當add_adapter 為 True時相關。
這是用於儲存 Wav2Vec2Model 配置的配置類。它用於根據指定的引數例項化 Wav2Vec2 模型，定義模型架構。使用預設值例項化配置將產生與 Wav2Vec2 facebook/wav2vec2-base-960h 架構類似的配置。
配置物件繼承自 PretrainedConfig，可用於控制模型輸出。有關此類方法的更多資訊，請參閱 PretrainedConfig 的文件。
示例
>>> from transformers import Wav2Vec2Config, Wav2Vec2Model
>>> # Initializing a Wav2Vec2 facebook/wav2vec2-base-960h style configuration
>>> configuration = Wav2Vec2Config()
>>> # Initializing a model (with random weights) from the facebook/wav2vec2-base-960h style configuration
>>> model = Wav2Vec2Model(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configWav2Vec2CTCTokenizer
class transformers.Wav2Vec2CTCTokenizer
< source >( vocab_file bos_token = '<s>' eos_token = '</s>' unk_token = '<unk>' pad_token = '<pad>' word_delimiter_token = '|' replace_word_delimiter_char = ' ' do_lower_case = False target_lang = None **kwargs )
引數
- vocab_file (
str) — 包含詞彙表的檔案。 - bos_token (
str, optional, defaults to"<s>") — 句子開始標記。 - eos_token (
str, optional, defaults to"</s>") — 句子結束標記。 - unk_token (
str, optional, defaults to"<unk>") — 未知標記。不在詞彙表中的標記無法轉換為 ID，而是設定為此標記。 - pad_token (
str, optional, defaults to"<pad>") — 用於填充的標記，例如在批處理不同長度的序列時。 - word_delimiter_token (
str, optional, defaults to"|") — 用於定義單詞結尾的標記。 - do_lower_case (
bool, optional, defaults toFalse) — 解碼時是否接受小寫輸入並輸出小寫。 - target_lang (
str, optional) — 標記器應預設設定的目標語言。對於多語言、巢狀詞彙表（例如 facebook/mms-1b-all），必須定義target_lang。 - **kwargs — 額外關鍵字引數，傳遞給 PreTrainedTokenizer
構造一個 Wav2Vec2CTC 標記器。
此標記器繼承自 PreTrainedTokenizer，其中包含一些主要方法。使用者應參考超類以獲取有關此類方法的更多資訊。
__call__
< source >( text: typing.Union[str, list[str], list[list[str]], NoneType] = None text_pair: typing.Union[str, list[str], list[list[str]], NoneType] = None text_target: typing.Union[str, list[str], list[list[str]], NoneType] = None text_pair_target: typing.Union[str, list[str], list[list[str]], NoneType] = None add_special_tokens: bool = True padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False truncation: typing.Union[bool, str, transformers.tokenization_utils_base.TruncationStrategy, NoneType] = None max_length: typing.Optional[int] = None stride: int = 0 is_split_into_words: bool = False pad_to_multiple_of: typing.Optional[int] = None padding_side: typing.Optional[str] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None return_token_type_ids: typing.Optional[bool] = None return_attention_mask: typing.Optional[bool] = None return_overflowing_tokens: bool = False return_special_tokens_mask: bool = False return_offsets_mapping: bool = False return_length: bool = False verbose: bool = True **kwargs ) → BatchEncoding
引數
- text (
str,list[str],list[list[str]], optional) — 要編碼的序列或序列批次。每個序列可以是一個字串或一個字串列表（預標記化字串）。如果序列以字串列表（預標記化）形式提供，則必須設定is_split_into_words=True（以消除與序列批次的歧義）。 - text_pair (
str,list[str],list[list[str]], optional) — 要編碼的序列或序列批次。每個序列可以是一個字串或一個字串列表（預標記化字串）。如果序列以字串列表（預標記化）形式提供，則必須設定is_split_into_words=True（以消除與序列批次的歧義）。 - text_target (
str,list[str],list[list[str]], optional) — 要編碼為目標文字的序列或序列批次。每個序列可以是一個字串或一個字串列表（預標記化字串）。如果序列以字串列表（預標記化）形式提供，則必須設定is_split_into_words=True（以消除與序列批次的歧義）。 - text_pair_target (
str,list[str],list[list[str]], optional) — 要編碼為目標文字的序列或序列批次。每個序列可以是一個字串或一個字串列表（預標記化字串）。如果序列以字串列表（預標記化）形式提供，則必須設定is_split_into_words=True（以消除與序列批次的歧義）。 - add_special_tokens (
bool, optional, defaults toTrue) — 編碼序列時是否新增特殊標記。這將使用底層PretrainedTokenizerBase.build_inputs_with_special_tokens函式，該函式定義哪些標記自動新增到輸入 ID。如果您希望自動新增bos或eos標記，這將非常有用。 - padding (
bool,str或 PaddingStrategy, optional, defaults toFalse) — 啟用並控制填充。接受以下值：True或'longest'：填充到批次中最長的序列（如果只提供一個序列，則不填充）。'max_length'：填充到用引數max_length指定的最大長度，或者如果未提供該引數，則填充到模型的最大可接受輸入長度。False或'do_not_pad'（預設）：不填充（即，可以輸出具有不同長度序列的批次）。
- truncation (
bool,str或 TruncationStrategy, optional, defaults toFalse) — 啟用並控制截斷。接受以下值：True或'longest_first'：截斷到由引數max_length指定的最大長度，或者如果未提供該引數，則截斷到模型的最大可接受輸入長度。如果提供了一對序列（或一批對），則將逐個標記截斷，從對中最長的序列中刪除一個標記。'only_first'：截斷到由引數max_length指定的最大長度，或者如果未提供該引數，則截斷到模型的最大可接受輸入長度。如果提供了一對序列（或一批對），則只截斷第一個序列。'only_second'：截斷到由引數max_length指定的最大長度，或者如果未提供該引數，則截斷到模型的最大可接受輸入長度。如果提供了一對序列（或一批對），則只截斷第二個序列。False或'do_not_truncate'（預設）：不截斷（即，可以輸出序列長度大於模型最大允許輸入大小的批次）。
- max_length (
int, optional) — 控制截斷/填充引數之一要使用的最大長度。如果未設定或設定為
None，這將使用預定義的模型最大長度（如果截斷/填充引數之一需要最大長度）。如果模型沒有特定的最大輸入長度（如 XLNet），則最大長度的截斷/填充將被停用。 - stride (
int, optional, defaults to 0) — 如果與max_length一起設定為數字，則當return_overflowing_tokens=True時返回的溢位標記將包含截斷序列末尾的一些標記，以在截斷序列和溢位序列之間提供一些重疊。此引數的值定義了重疊標記的數量。 - is_split_into_words (
bool, optional, defaults toFalse) — 輸入是否已預標記化（例如，已拆分為單詞）。如果設定為True，則標記器假定輸入已拆分為單詞（例如，透過在空格處拆分），然後對其進行標記。這對於 NER 或標記分類非常有用。 - pad_to_multiple_of (
int, optional) — 如果設定，將序列填充到所提供值的倍數。需要啟用padding。這對於在計算能力>= 7.5(Volta) 的 NVIDIA 硬體上啟用 Tensor Core 特別有用。 - padding_side (
str, optional) — 模型應應用填充的一側。應在 [‘right’, ‘left’] 之間選擇。預設值取自同名的類屬性。 - return_tensors (
str或 TensorType, optional) — 如果設定，將返回張量而不是 Python 整數列表。可接受的值為：'tf'：返回 TensorFlowtf.constant物件。'pt'：返回 PyTorchtorch.Tensor物件。'np'：返回 Numpynp.ndarray物件。
- return_token_type_ids (
bool, optional) — 是否返回標記型別 ID。如果保留預設值，將根據特定標記器的預設值（由return_outputs屬性定義）返回標記型別 ID。 - return_attention_mask (
bool, optional) — 是否返回注意力掩碼。如果保留預設值，將根據特定標記器的預設值（由return_outputs屬性定義）返回注意力掩碼。 - return_overflowing_tokens (
bool, optional, defaults toFalse) — 是否返回溢位標記序列。如果提供了一對輸入 ID 序列（或一批對），且truncation_strategy = longest_first或True，則會引發錯誤，而不是返回溢位標記。 - return_special_tokens_mask (
bool, optional, defaults toFalse) — 是否返回特殊標記掩碼資訊。 - return_offsets_mapping (
bool, optional, defaults toFalse) — 是否返回每個標記的(char_start, char_end)。這僅在繼承自 PreTrainedTokenizerFast 的快速標記器上可用，如果使用 Python 的標記器，此方法將引發
NotImplementedError。 - return_length (
bool, optional, defaults toFalse) — 是否返回編碼輸入的長度。 - verbose (
bool, optional, defaults toTrue) — 是否列印更多資訊和警告。 - **kwargs — 傳遞給
self.tokenize()方法
一個 BatchEncoding，包含以下欄位：
-
input_ids — 要輸入到模型中的標記 ID 列表。
-
token_type_ids — 要輸入到模型中的標記型別 ID 列表（當
return_token_type_ids=True或如果 *“token_type_ids”* 在self.model_input_names中時）。 -
attention_mask — 指定模型應關注哪些標記的索引列表（當
return_attention_mask=True或如果 *“attention_mask”* 在self.model_input_names中時）。 -
overflowing_tokens — 溢位標記序列列表（當指定
max_length且return_overflowing_tokens=True時）。 -
num_truncated_tokens — 截斷標記的數量（當指定
max_length且return_overflowing_tokens=True時）。 -
special_tokens_mask — 0 和 1 的列表，其中 1 表示新增的特殊標記，0 表示常規序列標記（當
add_special_tokens=True且return_special_tokens_mask=True時）。 -
length — 輸入的長度（當
return_length=True時）
將一個或多個序列或一對或多對序列標記化並準備用於模型的主要方法。
decode
< source >( token_ids: typing.Union[int, list[int], ForwardRef('np.ndarray'), ForwardRef('torch.Tensor'), ForwardRef('tf.Tensor')] skip_special_tokens: bool = False clean_up_tokenization_spaces: typing.Optional[bool] = None output_char_offsets: bool = False output_word_offsets: bool = False **kwargs ) → str 或 Wav2Vec2CTCTokenizerOutput
引數
- token_ids (
Union[int, list[int], np.ndarray, torch.Tensor, tf.Tensor]) — 標記化輸入 ID 的列表。可以使用__call__方法獲取。 - skip_special_tokens (
bool, 可選, 預設為False) — 是否在解碼中移除特殊標記。 - clean_up_tokenization_spaces (
bool, 可選) — 是否清理標記化空間。 - output_char_offsets (
bool, 可選, 預設為False) — 是否輸出字元偏移。字元偏移可與取樣率和模型下采樣率結合使用，以計算轉錄字元的時間戳。請檢視以下示例，以更好地理解如何使用
output_char_offsets。 - output_word_offsets (
bool, 可選, 預設為False) — 是否輸出單詞偏移。單詞偏移可與取樣率和模型下采樣率結合使用，以計算轉錄單詞的時間戳。請檢視以下示例，以更好地理解如何使用
output_word_offsets。 - kwargs (附加關鍵字引數，可選) — 將傳遞給底層模型特定解碼方法。
返回
str 或 Wav2Vec2CTCTokenizerOutput
解碼後的句子列表。當 output_char_offsets == True 或 output_word_offsets == True 時，將是一個 Wav2Vec2CTCTokenizerOutput。
使用分詞器和詞彙表將 ID 序列轉換為字串，可以選擇移除特殊標記並清理分詞空間。
類似於執行 self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))。
示例
>>> # Let's see how to retrieve time steps for a model
>>> from transformers import AutoTokenizer, AutoFeatureExtractor, AutoModelForCTC
>>> from datasets import load_dataset
>>> import datasets
>>> import torch
>>> # import model, feature extractor, tokenizer
>>> model = AutoModelForCTC.from_pretrained("facebook/wav2vec2-base-960h")
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h")
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")
>>> # load first sample of English common_voice
>>> dataset = load_dataset("mozilla-foundation/common_voice_11_0", "en", split="train", streaming=True)
>>> dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))
>>> dataset_iter = iter(dataset)
>>> sample = next(dataset_iter)
>>> # forward sample through model to get greedily predicted transcription ids
>>> input_values = feature_extractor(sample["audio"]["array"], return_tensors="pt").input_values
>>> logits = model(input_values).logits[0]
>>> pred_ids = torch.argmax(logits, axis=-1)
>>> # retrieve word stamps (analogous commands for `output_char_offsets`)
>>> outputs = tokenizer.decode(pred_ids, output_word_offsets=True)
>>> # compute `time_offset` in seconds as product of downsampling ratio and sampling_rate
>>> time_offset = model.config.inputs_to_logits_ratio / feature_extractor.sampling_rate
>>> word_offsets = [
... {
... "word": d["word"],
... "start_time": round(d["start_offset"] * time_offset, 2),
... "end_time": round(d["end_offset"] * time_offset, 2),
... }
... for d in outputs.word_offsets
... ]
>>> # compare word offsets with audio `en_train_0/common_voice_en_19121553.mp3` online on the dataset viewer:
>>> # https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0/viewer/en
>>> word_offsets[:3]
[{'word': 'THE', 'start_time': 0.7, 'end_time': 0.78}, {'word': 'TRICK', 'start_time': 0.88, 'end_time': 1.08}, {'word': 'APPEARS', 'start_time': 1.2, 'end_time': 1.64}]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 output_char_offsets: bool = False output_word_offsets: bool = False **kwargs ) → list[str] 或 Wav2Vec2CTCTokenizerOutput
引數
- 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, 可選) — 是否清理標記化空間。 - output_char_offsets (
bool, 可選, 預設為False) — 是否輸出字元偏移。字元偏移可與取樣率和模型下采樣率結合使用，以計算轉錄字元的時間戳。請檢視 decode() 的示例，以更好地理解如何使用
output_char_offsets。 batch_decode() 以相同的方式處理批處理輸出。 - output_word_offsets (
bool, 可選, 預設為False) — 是否輸出單詞偏移。單詞偏移可與取樣率和模型下采樣率結合使用，以計算轉錄單詞的時間戳。請檢視 decode() 的示例，以更好地理解如何使用
output_word_offsets。 batch_decode() 以相同的方式處理批處理輸出。 - kwargs (附加關鍵字引數，可選) — 將傳遞給底層模型特定解碼方法。
返回
list[str] 或 Wav2Vec2CTCTokenizerOutput
解碼後的句子列表。當 output_char_offsets == True 或 output_word_offsets == True 時，將是一個 Wav2Vec2CTCTokenizerOutput。
透過呼叫 decode 將標記 ID 列表的列表轉換為字串列表。
設定巢狀多語言字典的目標語言
Wav2Vec2FeatureExtractor
class transformers.Wav2Vec2FeatureExtractor
< 源 >( feature_size = 1 sampling_rate = 16000 padding_value = 0.0 return_attention_mask = False do_normalize = True **kwargs )
引數
- feature_size (
int, 可選, 預設為 1) — 提取特徵的特徵維度。 - sampling_rate (
int, 可選, 預設為 16000) — 音訊檔案數字化的取樣率，以赫茲 (Hz) 表示。 - padding_value (
float, 可選, 預設為 0.0) — 用於填充填充值的值。 - do_normalize (
bool, 可選, 預設為True) — 是否進行零均值單位方差歸一化輸入。歸一化有助於顯著提高某些模型的效能，例如 wav2vec2-lv60。 - return_attention_mask (
bool, 可選, 預設為False) — call() 是否應返回attention_mask。已設定
config.feat_extract_norm == "group"的 Wav2Vec2 模型（例如 wav2vec2-base）未使用attention_mask進行訓練。對於此類模型，input_values應簡單地用 0 填充，並且不應傳遞attention_mask。對於已設定
config.feat_extract_norm == "layer"的 Wav2Vec2 模型（例如 wav2vec2-lv60），應為批處理推理傳遞attention_mask。
構造 Wav2Vec2 特徵提取器。
此特徵提取器繼承自 SequenceFeatureExtractor，其中包含大部分主要方法。使用者應參閱此超類以獲取有關這些方法的更多資訊。
__call__
< 源 >( raw_speech: typing.Union[numpy.ndarray, list[float], list[numpy.ndarray], list[list[float]]] padding: typing.Union[bool, str, transformers.utils.generic.PaddingStrategy] = False max_length: typing.Optional[int] = None truncation: bool = False pad_to_multiple_of: typing.Optional[int] = None return_attention_mask: typing.Optional[bool] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None sampling_rate: typing.Optional[int] = None **kwargs )
引數
- raw_speech (
np.ndarray,list[float],list[np.ndarray],list[list[float]]) — 要填充的序列或序列批次。每個序列可以是 numpy 陣列、浮點值列表、numpy 陣列列表或浮點值列表的列表。必須是單聲道音訊，而不是立體聲，即每個時間步長只有一個浮點值。 - padding (
bool,str或 PaddingStrategy, 可選, 預設為False) — 選擇一種策略來填充返回的序列（根據模型的填充側和填充索引），包括：True或'longest'：填充到批次中最長的序列（如果只提供一個序列，則不填充）。'max_length'：填充到由引數max_length指定的最大長度，或者如果未提供該引數，則填充到模型可接受的最大輸入長度。False或'do_not_pad'(預設)：不填充（即，可以輸出長度不同的序列批次）。
- max_length (
int, 可選) — 返回列表的最大長度以及可選的填充長度（見上文）。 - truncation (
bool) — 啟用截斷，將長於 max_length 的輸入序列截斷為 max_length。 - pad_to_multiple_of (
int, 可選) — 如果設定，將把序列填充到所提供值的倍數。這對於在計算能力
>= 7.5(Volta) 的 NVIDIA 硬體上啟用 Tensor Core，或在序列長度為 128 倍數時受益的 TPU 上特別有用。 - return_attention_mask (
bool, 可選) — 是否返回注意力掩碼。如果保留預設值，將根據特定 feature_extractor 的預設值返回注意力掩碼。已設定
config.feat_extract_norm == "group"的 Wav2Vec2 模型（例如 wav2vec2-base）未使用attention_mask進行訓練。對於此類模型，input_values應簡單地用 0 填充，並且不應傳遞attention_mask。對於已設定
config.feat_extract_norm == "layer"的 Wav2Vec2 模型（例如 wav2vec2-lv60），應為批處理推理傳遞attention_mask。 - return_tensors (
str或 TensorType, 可選) — 如果設定，將返回張量而不是 Python 整數列表。可接受的值為：'tf'：返回 TensorFlowtf.constant物件。'pt'：返回 PyTorchtorch.Tensor物件。'np'：返回 Numpynp.ndarray物件。
- sampling_rate (
int, 可選) —raw_speech輸入的取樣率。強烈建議在轉發呼叫時傳遞sampling_rate以防止靜默錯誤。 - padding_value (
float, 可選, 預設為 0.0) —
對一個或多個序列進行特徵化併為模型準備的主方法。
Wav2Vec2Processor
class transformers.Wav2Vec2Processor
< 源 >( feature_extractor tokenizer )
引數
- feature_extractor (
Wav2Vec2FeatureExtractor) — Wav2Vec2FeatureExtractor 的例項。特徵提取器是必需的輸入。 - tokenizer (PreTrainedTokenizer) — PreTrainedTokenizer 的例項。分詞器是必需的輸入。
構造 Wav2Vec2 處理器，它將 Wav2Vec2 特徵提取器和 Wav2Vec2 CTC 分詞器封裝在一個處理器中。
Wav2Vec2Processor 提供了 Wav2Vec2FeatureExtractor 和 PreTrainedTokenizer 的所有功能。有關這些方法的更多資訊，請參閱 call() 和 decode() 的文件字串。
__call__
< 源 >( audio: typing.Union[ForwardRef('np.ndarray'), ForwardRef('torch.Tensor'), list['np.ndarray'], list['torch.Tensor']] = None text: typing.Union[str, list[str], NoneType] = None images = None videos = None **kwargs: typing_extensions.Unpack[transformers.models.wav2vec2.processing_wav2vec2.Wav2Vec2ProcessorKwargs] )
此方法將其所有引數轉發給 Wav2Vec2FeatureExtractor 的 call() 並返回其輸出。
save_pretrained
< 源 >( save_directory push_to_hub: bool = False **kwargs )
引數
- save_directory (
str或os.PathLike) — 特徵提取器 JSON 檔案和分詞器檔案將儲存到的目錄（如果目錄不存在，則會建立）。 - push_to_hub (
bool, 可選, 預設為False) — 是否在儲存模型後將其推送到 Hugging Face 模型中心。您可以使用repo_id指定要推送到的儲存庫（預設為您名稱空間中save_directory的名稱）。 - kwargs (
dict[str, Any], 可選) — 傳遞給 push_to_hub() 方法的附加關鍵字引數。
將此處理器（特徵提取器、分詞器…）的屬性儲存到指定目錄中，以便可以使用 from_pretrained() 方法重新載入。
此類方法僅呼叫 save_pretrained() 和 save_pretrained()。有關更多資訊，請參閱上述方法的文件字串。
此方法將其所有引數轉發給 PreTrainedTokenizer 的 batch_decode()。有關此方法的更多資訊，請參閱其文件字串。
Wav2Vec2ProcessorWithLM
class transformers.Wav2Vec2ProcessorWithLM
< 源 >( feature_extractor: FeatureExtractionMixin tokenizer: PreTrainedTokenizerBase decoder: BeamSearchDecoderCTC )
引數
- feature_extractor (Wav2Vec2FeatureExtractor 或 SeamlessM4TFeatureExtractor) — Wav2Vec2FeatureExtractor 或 SeamlessM4TFeatureExtractor 的例項。特徵提取器是必需的輸入。
- tokenizer (Wav2Vec2CTCTokenizer) — Wav2Vec2CTCTokenizer 的一個例項。分詞器是必需的輸入。
- decoder (
pyctcdecode.BeamSearchDecoderCTC) —pyctcdecode.BeamSearchDecoderCTC的一個例項。解碼器是必需的輸入。
構建一個 Wav2Vec2 處理器，它將 Wav2Vec2 特徵提取器、Wav2Vec2 CTC 分詞器和支援語言模型的解碼器封裝到單個處理器中，用於語言模型增強的語音識別解碼。
在正常模式下使用時，此方法將其所有引數轉發到特徵提取器的 __call__() 並返回其輸出。如果在 as_target_processor() 上下文中使用，此方法將其所有引數轉發到 Wav2Vec2CTCTokenizer 的 call()。有關更多資訊，請參閱上述兩種方法的文件字串。
在正常模式下使用時，此方法將其所有引數轉發到特徵提取器的 ~FeatureExtractionMixin.pad 並返回其輸出。如果在 as_target_processor() 上下文中使用，此方法將其所有引數轉發到 Wav2Vec2CTCTokenizer 的 pad()。有關更多資訊，請參閱上述兩種方法的文件字串。
from_pretrained
< 來源 >( pretrained_model_name_or_path **kwargs )
引數
- pretrained_model_name_or_path (
str或os.PathLike) — 這可以是以下之一：- 一個字串，即 huggingface.co 上模型倉庫中預訓練特徵提取器的 模型 ID。
- 一個 目錄 的路徑，其中包含使用 save_pretrained() 方法儲存的特徵提取器檔案，例如
./my_model_directory/。 - 一個已儲存的特徵提取器 JSON 檔案 的路徑或 URL，例如
./my_model_directory/preprocessor_config.json。
- **kwargs — 傳遞給 SequenceFeatureExtractor 和 PreTrainedTokenizer 的其他關鍵字引數
從預訓練的 Wav2Vec2 處理器例項化 Wav2Vec2ProcessorWithLM。
此類方法僅呼叫特徵提取器的 from_pretrained()、Wav2Vec2CTCTokenizer 的 from_pretrained() 和 pyctcdecode.BeamSearchDecoderCTC.load_from_hf_hub。
有關更多資訊，請參閱上述方法的文件字串。
batch_decode
< 來源 >( logits: ndarray pool: typing.Optional[<bound method BaseContext.Pool of <multiprocessing.context.DefaultContext object at 0x7f01077c8ee0>>] = None num_processes: typing.Optional[int] = None beam_width: typing.Optional[int] = None beam_prune_logp: typing.Optional[float] = None token_min_logp: typing.Optional[float] = None hotwords: typing.Optional[collections.abc.Iterable[str]] = None hotword_weight: typing.Optional[float] = None alpha: typing.Optional[float] = None beta: typing.Optional[float] = None unk_score_offset: typing.Optional[float] = None lm_score_boundary: typing.Optional[bool] = None output_word_offsets: bool = False n_best: int = 1 )
引數
- logits (
np.ndarray) — 模型的 logits 輸出向量，表示每個 token 的對數機率。 - pool (
multiprocessing.Pool, 可選) — 一個可選的使用者管理的程序池。如果未設定，將自動建立並關閉一個。程序池應在Wav2Vec2ProcessorWithLM之後 例項化。否則，LM 將不適用於程序池的子程序。目前，只能使用透過 'fork' 上下文建立的程序池。如果傳遞 'spawn' 程序池，它將被忽略，並轉而使用順序解碼。
- num_processes (
int, 可選) — 如果未設定pool，則並行化函式的程序數。預設為可用 CPU 數量。 - beam_width (
int, 可選) — 解碼中每一步的最大 beam 數。預設為 pyctcdecode 的 DEFAULT_BEAM_WIDTH。 - beam_prune_logp (
int, 可選) — 比最佳 beam 差得多的 beam 將被剪枝。預設為 pyctcdecode 的 DEFAULT_PRUNE_LOGP。 - token_min_logp (
int, 可選) — 低於此對數機率的 token 將被跳過，除非它們是幀的 argmax。預設為 pyctcdecode 的 DEFAULT_MIN_TOKEN_LOGP。 - hotwords (
list[str], 可選) — 具有額外重要性的單詞列表，可以超出 LM 的詞彙表 - hotword_weight (
int, 可選) — 熱詞重要性的權重因子。預設為 pyctcdecode 的 DEFAULT_HOTWORD_WEIGHT。 - alpha (
float, 可選) — 淺層融合期間語言模型的權重 - beta (
float, 可選) — 評分期間長度分數調整的權重 - unk_score_offset (
float, 可選) — 未知 token 的對數分數偏移量 - lm_score_boundary (
bool, 可選) — Kenlm 是否應在評分時尊重邊界 - output_word_offsets (
bool, 可選，預設為False) — 是否輸出單詞偏移量。單詞偏移量可以與取樣率和模型下采樣率結合使用，以計算轉錄單詞的時間戳。 - n_best (
int, 可選，預設為1) — 返回的最佳假設數量。如果n_best大於 1，則返回的text將是一個字串列表的列表，logit_score將是一個浮點數列表的列表，lm_score將是一個浮點數列表的列表，其中外部列表的長度將對應於批次大小，內部列表的長度將對應於返回的假設數量。該值應 >= 1。請檢視 decode() 的示例，以更好地理解如何使用
output_word_offsets。 batch_decode() 以相同的方式處理批次輸出。
批次解碼輸出 logits，以支援語言模型的音訊轉錄。
此函式使用 Python 的多程序功能。目前，多程序僅在 Unix 系統上可用（請參閱此 問題）。
如果要解碼多個批次，請考慮建立一個 Pool 並將其傳遞給 batch_decode。否則，batch_decode 將非常慢，因為它將為每次呼叫建立一個新的 Pool。請參見下面的用法示例。
示例：請參閱 解碼多個音訊。
decode
< 來源 >( logits: ndarray beam_width: typing.Optional[int] = None beam_prune_logp: typing.Optional[float] = None token_min_logp: typing.Optional[float] = None hotwords: typing.Optional[collections.abc.Iterable[str]] = None hotword_weight: typing.Optional[float] = None alpha: typing.Optional[float] = None beta: typing.Optional[float] = None unk_score_offset: typing.Optional[float] = None lm_score_boundary: typing.Optional[bool] = None output_word_offsets: bool = False n_best: int = 1 )
引數
- logits (
np.ndarray) — 模型的 logits 輸出向量，表示每個 token 的對數機率。 - beam_width (
int, 可選) — 解碼中每一步的最大 beam 數。預設為 pyctcdecode 的 DEFAULT_BEAM_WIDTH。 - beam_prune_logp (
int, 可選) — 剪枝對數機率小於最佳 beam 對數機率 + beam_prune_logp 的 beam。該值應 <= 0。預設為 pyctcdecode 的 DEFAULT_PRUNE_LOGP。 - token_min_logp (
int, 可選) — 除非 token 的對數機率是語音的最高對數機率，否則對數機率低於 token_min_logp 的 token 將被跳過。預設為 pyctcdecode 的 DEFAULT_MIN_TOKEN_LOGP。 - hotwords (
list[str], 可選) — 具有額外重要性的單詞列表，可能缺失於 LM 的詞彙表，例如 ["huggingface"] - hotword_weight (
int, 可選) — 提升熱詞分數的權重乘數。預設為 pyctcdecode 的 DEFAULT_HOTWORD_WEIGHT。 - alpha (
float, 可選) — 淺層融合期間語言模型的權重 - beta (
float, 可選) — 評分期間長度分數調整的權重 - unk_score_offset (
float, 可選) — 未知 token 的對數分數偏移量 - lm_score_boundary (
bool, 可選) — Kenlm 是否應在評分時尊重邊界 - output_word_offsets (
bool, 可選，預設為False) — 是否輸出單詞偏移量。單詞偏移量可以與取樣率和模型下采樣率結合使用，以計算轉錄單詞的時間戳。 - n_best (
int, 可選，預設為1) — 返回的最佳假設數量。如果n_best大於 1，則返回的text將是一個字串列表，logit_score將是一個浮點數列表，lm_score將是一個浮點數列表，這些列表的長度將對應於返回的假設數量。該值應 >= 1。請參閱下面的示例，以更好地理解如何使用
output_word_offsets。
解碼輸出 logits，以支援語言模型的音訊轉錄。
示例
>>> # Let's see how to retrieve time steps for a model
>>> from transformers import AutoTokenizer, AutoProcessor, AutoModelForCTC
>>> from datasets import load_dataset
>>> import datasets
>>> import torch
>>> # import model, feature extractor, tokenizer
>>> model = AutoModelForCTC.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")
>>> processor = AutoProcessor.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")
>>> # load first sample of English common_voice
>>> dataset = load_dataset("mozilla-foundation/common_voice_11_0", "en", split="train", streaming=True)
>>> dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))
>>> dataset_iter = iter(dataset)
>>> sample = next(dataset_iter)
>>> # forward sample through model to get greedily predicted transcription ids
>>> input_values = processor(sample["audio"]["array"], return_tensors="pt").input_values
>>> with torch.no_grad():
... logits = model(input_values).logits[0].cpu().numpy()
>>> # retrieve word stamps (analogous commands for `output_char_offsets`)
>>> outputs = processor.decode(logits, output_word_offsets=True)
>>> # compute `time_offset` in seconds as product of downsampling ratio and sampling_rate
>>> time_offset = model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate
>>> word_offsets = [
... {
... "word": d["word"],
... "start_time": round(d["start_offset"] * time_offset, 2),
... "end_time": round(d["end_offset"] * time_offset, 2),
... }
... for d in outputs.word_offsets
... ]
>>> # compare word offsets with audio `en_train_0/common_voice_en_19121553.mp3` online on the dataset viewer:
>>> # https://huggingface.co/datasets/mozilla-foundation/common_voice_11_0/viewer/en
>>> word_offsets[:4]
[{'word': 'THE', 'start_time': 0.68, 'end_time': 0.78}, {'word': 'TRACK', 'start_time': 0.88, 'end_time': 1.1}, {'word': 'APPEARS', 'start_time': 1.18, 'end_time': 1.66}, {'word': 'ON', 'start_time': 1.86, 'end_time': 1.92}]解碼多個音訊
如果您計劃解碼多個批次的音訊，則應考慮使用 batch_decode() 並傳入一個例項化的 multiprocessing.Pool。否則，batch_decode() 的效能將低於單獨為每個音訊呼叫 decode()，因為它會在每次呼叫時內部例項化一個新的 Pool。請參閱下面的示例
>>> # Let's see how to use a user-managed pool for batch decoding multiple audios
>>> from multiprocessing import get_context
>>> from transformers import AutoTokenizer, AutoProcessor, AutoModelForCTC
>>> from datasets import load_dataset
>>> import datasets
>>> import torch
>>> # import model, feature extractor, tokenizer
>>> model = AutoModelForCTC.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm").to("cuda")
>>> processor = AutoProcessor.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm")
>>> # load example dataset
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> dataset = dataset.cast_column("audio", datasets.Audio(sampling_rate=16_000))
>>> def map_to_array(batch):
... batch["speech"] = batch["audio"]["array"]
... return batch
>>> # prepare speech data for batch inference
>>> dataset = dataset.map(map_to_array, remove_columns=["audio"])
>>> def map_to_pred(batch, pool):
... inputs = processor(batch["speech"], sampling_rate=16_000, padding=True, return_tensors="pt")
... inputs = {k: v.to("cuda") for k, v in inputs.items()}
... with torch.no_grad():
... logits = model(**inputs).logits
... transcription = processor.batch_decode(logits.cpu().numpy(), pool).text
... batch["transcription"] = transcription
... return batch
>>> # note: pool should be instantiated *after* `Wav2Vec2ProcessorWithLM`.
>>> # otherwise, the LM won't be available to the pool's sub-processes
>>> # select number of processes and batch_size based on number of CPU cores available and on dataset size
>>> with get_context("fork").Pool(processes=2) as pool:
... result = dataset.map(
... map_to_pred, batched=True, batch_size=2, fn_kwargs={"pool": pool}, remove_columns=["speech"]
... )
>>> result["transcription"][:2]
['MISTER QUILTER IS THE APOSTLE OF THE MIDDLE CLASSES AND WE ARE GLAD TO WELCOME HIS GOSPEL', "NOR IS MISTER COULTER'S MANNER LESS INTERESTING THAN HIS MATTER"]Wav2Vec2 特定的輸出
class transformers.models.wav2vec2_with_lm.processing_wav2vec2_with_lm.Wav2Vec2DecoderWithLMOutput
< 來源 >( text: typing.Union[list[list[str]], list[str], str] logit_score: typing.Union[list[list[float]], list[float], float] = None lm_score: typing.Union[list[list[float]], list[float], float] = None word_offsets: typing.Union[list[list[list[dict[str, typing.Union[int, str]]]]], list[list[dict[str, typing.Union[int, str]]]], list[dict[str, typing.Union[int, str]]]] = None )
Wav2Vec2DecoderWithLM 的輸出型別，帶有轉錄。
class transformers.modeling_outputs.Wav2Vec2BaseModelOutput
< 來源 >( last_hidden_state: typing.Optional[torch.FloatTensor] = None extract_features: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
引數
- last_hidden_state (形狀為
(batch_size, sequence_length, hidden_size)的torch.FloatTensor) — 模型最後一層輸出的隱藏狀態序列。 - extract_features (形狀為
(batch_size, sequence_length, conv_dim[-1])的torch.FloatTensor) — 模型最後一層卷積層提取的特徵向量序列。 - hidden_states (
tuple(torch.FloatTensor), 可選，在傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入輸出 + 每個層輸出一個）。模型的隱藏狀態，包括初始嵌入輸出和每個層的輸出。
- attentions (
tuple(torch.FloatTensor), 可選, 當傳入output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每個層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
使用 Wav2Vec2 損失目標進行訓練的模型的基類。
class transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None projected_states: typing.Optional[torch.FloatTensor] = None projected_quantized_states: typing.Optional[torch.FloatTensor] = None codevector_perplexity: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor]] = None attentions: typing.Optional[tuple[torch.FloatTensor]] = None contrastive_loss: typing.Optional[torch.FloatTensor] = None diversity_loss: typing.Optional[torch.FloatTensor] = None )
引數
- loss (
*可選*, 當傳入sample_negative_indices時返回，torch.FloatTensor形狀為(1,)) — 總損失，是對比損失（L_m）和多樣性損失（L_d）之和，如官方論文所述。（分類）損失。 - projected_states (
torch.FloatTensor形狀為(batch_size, sequence_length, config.proj_codevector_dim)) — 模型投射到 config.proj_codevector_dim 的隱藏狀態，可用於預測被掩碼的投射量化狀態。 - projected_quantized_states (
torch.FloatTensor形狀為(batch_size, sequence_length, config.proj_codevector_dim)) — 投射到 config.proj_codevector_dim 的量化提取特徵向量，代表對比損失的正目標向量。 - codevector_perplexity (
torch.FloatTensor形狀為(1,)) — 碼本分佈的困惑度，用於衡量碼本的多樣性。 - 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 後的注意力權重，用於計算自注意力頭中的加權平均值。
- contrastive_loss (
*可選*, 當傳入sample_negative_indices時返回，torch.FloatTensor形狀為(1,)) — 對比損失（L_m），如官方論文所述。 - diversity_loss (
*可選*, 當傳入sample_negative_indices時返回，torch.FloatTensor形狀為(1,)) — 多樣性損失（L_d），如官方論文所述。
Wav2Vec2ForPreTraining 的輸出型別，包含潛在的隱藏狀態和注意力。
class transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2BaseModelOutput
< source >( last_hidden_state: Array = None extract_features: Array = None hidden_states: typing.Optional[tuple[jax.Array]] = None attentions: typing.Optional[tuple[jax.Array]] = None )
引數
- last_hidden_state (
jnp.ndarray形狀為(batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。 - extract_features (
jnp.ndarray形狀為(batch_size, sequence_length, last_conv_dim)) — 模型最後一個卷積層的提取特徵向量序列，其中last_conv_dim是最後一個卷積層的維度。 - 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 後的注意力權重，用於計算自注意力頭中的加權平均值。
FlaxWav2Vec2BaseModelOutput 的輸出型別，包含潛在的隱藏狀態和注意力。
“返回一個新物件，用新值替換指定欄位。
class transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2ForPreTrainingOutput
< source >( projected_states: Array = None projected_quantized_states: Array = None codevector_perplexity: Array = None hidden_states: typing.Optional[tuple[jax.Array]] = None attentions: typing.Optional[tuple[jax.Array]] = None )
引數
- loss (可選, 當模型處於訓練模式時返回，
jnp.ndarray形狀為(1,)) — 總損失，是對比損失（L_m）和多樣性損失（L_d）之和，如官方論文所述。（分類）損失。 - projected_states (
jnp.ndarray形狀為(batch_size, sequence_length, config.proj_codevector_dim)) — 模型投射到 config.proj_codevector_dim 的隱藏狀態，可用於預測被掩碼的投射量化狀態。 - projected_quantized_states (
jnp.ndarray形狀為(batch_size, sequence_length, config.proj_codevector_dim)) — 投射到 config.proj_codevector_dim 的量化提取特徵向量，代表對比損失的正目標向量。 - 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 後的注意力權重，用於計算自注意力頭中的加權平均值。
FlaxWav2Vec2ForPreTrainingOutput 的輸出型別，包含潛在的隱藏狀態和注意力。
“返回一個新物件，用新值替換指定欄位。
Wav2Vec2Model
class transformers.Wav2Vec2Model
< source >( config: Wav2Vec2Config )
引數
- config (Wav2Vec2Config) — 模型的配置類，包含模型的所有引數。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。要載入模型權重，請檢視 from_pretrained() 方法。
Wav2Vec2 裸模型，輸出原始隱藏狀態，不帶任何特定頭部。
此模型繼承自 PreTrainedModel。請檢視超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
此模型也是 PyTorch torch.nn.Module 子類。將其用作常規 PyTorch 模組，並參考 PyTorch 文件以獲取所有與一般用法和行為相關的事項。
forward
< source >( input_values: typing.Optional[torch.Tensor] attention_mask: typing.Optional[torch.Tensor] = None mask_time_indices: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.Wav2Vec2BaseModelOutput 或 tuple(torch.FloatTensor)
引數
- input_values (
torch.Tensor形狀為(batch_size, sequence_length), 可選) — 輸入原始語音波形的浮點值。可以透過將.flac或.wav音訊檔案載入到list[float]型別陣列或numpy.ndarray中（例如，透過 soundfile 庫 (pip install soundfile)）來獲取這些值。要將陣列準備為input_values，應使用 AutoProcessor 進行填充和轉換為torch.FloatTensor型別的張量。有關詳細資訊，請參閱{processor_class}.__call__。 - attention_mask (
torch.Tensor形狀為(batch_size, sequence_length), 可選) — 用於避免在填充標記索引上執行注意力的掩碼。掩碼值選擇在[0, 1]中：- 1 表示**未被掩碼**的標記，
- 0 表示**被掩碼**的標記。
- mask_time_indices (
torch.BoolTensor形狀為(batch_size, sequence_length), 可選) — 用於對比損失的掩碼提取特徵的索引。在訓練模式下，模型學習預測 config.proj_codevector_dim 空間中的被掩碼提取特徵。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回 ModelOutput 而不是普通的元組。
返回
transformers.modeling_outputs.Wav2Vec2BaseModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.Wav2Vec2BaseModelOutput 或 torch.FloatTensor 的元組（如果傳入 return_dict=False 或 config.return_dict=False），包含根據配置 (Wav2Vec2Config) 和輸入的不同元素。
-
last_hidden_state (
torch.FloatTensor, 形狀為(batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。 -
extract_features (
torch.FloatTensor形狀為(batch_size, sequence_length, conv_dim[-1])) — 模型最後一個卷積層的提取特徵向量序列。 -
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
Wav2Vec2Model 的前向方法，覆蓋了 __call__ 特殊方法。
儘管前向傳播的配方需要在此函式中定義，但之後應該呼叫 Module 例項，而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
Wav2Vec2ForCTC
class transformers.Wav2Vec2ForCTC
< source >( config target_lang: typing.Optional[str] = None )
引數
- config (Wav2Vec2ForCTC) — 模型的配置類，包含模型的所有引數。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。要載入模型權重，請檢視 from_pretrained() 方法。
- target_lang (
str, 可選) — 介面卡權重的語言 ID。介面卡權重以 adapter..safetensors 或 adapter. .bin 格式儲存。僅在使用帶介面卡的 Wav2Vec2ForCTC 例項時相關。預設為“eng”。
Wav2Vec2 模型，頂部帶有用於連線主義時間分類（CTC）的 語言建模 頭部。
此模型繼承自 PreTrainedModel。請檢視超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
此模型也是 PyTorch torch.nn.Module 子類。將其用作常規 PyTorch 模組，並參考 PyTorch 文件以獲取所有與一般用法和行為相關的事項。
forward
< source >( input_values: typing.Optional[torch.Tensor] attention_mask: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None labels: typing.Optional[torch.Tensor] = None ) → transformers.modeling_outputs.CausalLMOutput 或 tuple(torch.FloatTensor)
引數
- input_values (
torch.Tensor形狀為(batch_size, sequence_length), 可選) — 輸入原始語音波形的浮點值。可以透過將.flac或.wav音訊檔案載入到list[float]型別陣列或numpy.ndarray中（例如，透過 soundfile 庫 (pip install soundfile)）來獲取這些值。要將陣列準備為input_values，應使用 AutoProcessor 進行填充和轉換為torch.FloatTensor型別的張量。有關詳細資訊，請參閱{processor_class}.__call__。 - attention_mask (
torch.Tensor形狀為(batch_size, sequence_length), 可選) — 用於避免在填充標記索引上執行注意力的掩碼。掩碼值選擇在[0, 1]中：- 1 表示**未被掩碼**的標記，
- 0 表示**被掩碼**的標記。
- output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回 ModelOutput 而不是普通的元組。 - labels (
torch.LongTensor形狀為(batch_size, target_length), 可選) — 用於連線主義時間分類的標籤。請注意，target_length必須小於或等於輸出 logits 的序列長度。索引選擇在[-100, 0, ..., config.vocab_size - 1]中。所有設定為-100的標籤都將被忽略（被掩碼），損失僅針對[0, ..., config.vocab_size - 1]中的標籤計算。
返回
transformers.modeling_outputs.CausalLMOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.CausalLMOutput 或 torch.FloatTensor 的元組（如果傳入 return_dict=False 或 config.return_dict=False），包含根據配置 (Wav2Vec2Config) 和輸入的不同元素。
-
loss (
torch.FloatTensor形狀為(1,), 可選, 當提供labels時返回) — 語言建模損失（用於下一個標記預測）。 -
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
Wav2Vec2ForCTC 的前向方法，覆蓋了 __call__ 特殊方法。
儘管前向傳播的配方需要在此函式中定義，但之後應該呼叫 Module 例項，而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
示例
>>> from transformers import AutoProcessor, Wav2Vec2ForCTC
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-base-960h")
>>> # audio file is decoded on the fly
>>> inputs = processor(dataset[0]["audio"]["array"], sampling_rate=sampling_rate, return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_ids = torch.argmax(logits, dim=-1)
>>> # transcribe speech
>>> transcription = processor.batch_decode(predicted_ids)
>>> transcription[0]
...
>>> inputs["labels"] = processor(text=dataset[0]["text"], return_tensors="pt").input_ids
>>> # compute loss
>>> loss = model(**inputs).loss
>>> round(loss.item(), 2)
...load_adapter
< source >( target_lang: str force_load = True **kwargs )
引數
- target_lang (
str) — 必須是現有介面卡權重的語言 ID。介面卡權重以 `adapter..safetensors` 或 `adapter. .bin` 格式儲存。 - force_load (
bool, 預設為True) — 即使target_lang與self.target_lang匹配，是否也要載入權重。 - cache_dir (
Union[str, os.PathLike], 可選) — 如果不使用標準快取，則為下載的預訓練模型配置應快取到的目錄路徑。 - force_download (
bool, 可選, 預設為False) — 是否強制（重新）下載模型權重和配置檔案，如果存在快取版本則覆蓋。 - resume_download — 已棄用並忽略。現在所有下載在可能的情況下預設恢復。將在 Transformers v5 中移除。
- proxies (
dict[str, str], 可選) — 要按協議或端點使用的代理伺服器字典，例如，{'http': 'foo.bar:3128', 'http://hostname': 'foo.bar:4012'}。代理在每個請求上使用。 - local_files_only(
bool, 可選, 預設為False) — 是否只檢視本地檔案（即，不嘗試下載模型）。 - token (
str或bool, 可選) — 用於遠端檔案的 HTTP Bearer 授權令牌。如果為True或未指定，將使用執行huggingface-cli login時生成的令牌（儲存在~/.huggingface中）。 - revision (
str, 可選, 預設為"main") — 要使用的特定模型版本。它可以是分支名稱、標籤名稱或提交 ID，因為我們使用基於 git 的系統在 huggingface.co 上儲存模型和其他工件，因此revision可以是 git 允許的任何識別符號。要在 Hub 上測試您建立的拉取請求，您可以傳遞
revision="refs/pr/<pr_number>"。 - mirror (
str, 可選) — 用於加速在中國下載的映象源。如果您來自中國且存在訪問問題，您可以設定此選項來解決。請注意，我們不保證時效性或安全性。有關更多資訊，請參閱映象站點。
從預訓練介面卡模型載入語言介面卡模型。
啟用特殊的 “離線模式” 以在防火牆環境下使用此方法。
示例
>>> from transformers import Wav2Vec2ForCTC, AutoProcessor
>>> ckpt = "facebook/mms-1b-all"
>>> processor = AutoProcessor.from_pretrained(ckpt)
>>> model = Wav2Vec2ForCTC.from_pretrained(ckpt, target_lang="eng")
>>> # set specific language
>>> processor.tokenizer.set_target_lang("spa")
>>> model.load_adapter("spa")Wav2Vec2ForSequenceClassification
class transformers.Wav2Vec2ForSequenceClassification
< source >( config )
引數
- config (Wav2Vec2ForSequenceClassification) — 模型的配置類，包含模型的所有引數。使用配置檔案初始化並不會載入與模型相關的權重，只加載配置。請檢視 from_pretrained() 方法來載入模型權重。
Wav2Vec2 模型，頂部帶有用於 SUPERB 關鍵詞識別等任務的序列分類頭（池化輸出上的線性層）。
此模型繼承自 PreTrainedModel。請檢視超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
此模型也是 PyTorch torch.nn.Module 子類。將其用作常規 PyTorch 模組，並參考 PyTorch 文件以獲取所有與一般用法和行為相關的事項。
forward
< source >( input_values: typing.Optional[torch.Tensor] attention_mask: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None labels: typing.Optional[torch.Tensor] = None ) → transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
引數
- input_values (形狀為
(batch_size, sequence_length)的torch.FloatTensor) — 輸入原始語音波形的浮點值。可以透過將.flac或.wav音訊檔案載入到list[float]型別陣列或numpy.ndarray中獲取，例如透過 soundfile 庫（pip install soundfile）。要將陣列準備為input_values，應使用 AutoProcessor 進行填充和轉換為torch.FloatTensor型別張量。詳情請參閱 Wav2Vec2Processor.call()。 - attention_mask (形狀為
(batch_size, sequence_length)的torch.Tensor, 可選) — 用於避免在填充標記索引上執行注意力的掩碼。掩碼值選擇在[0, 1]中:- 1 表示**未被掩碼**的標記，
- 0 表示**被掩碼**的標記。
- output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。更多詳細資訊請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。更多詳細資訊請參閱返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回 ModelOutput 而不是普通的元組。 - labels (形狀為
(batch_size,)的torch.LongTensor, 可選) — 用於計算序列分類/迴歸損失的標籤。索引應在[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 時），包含根據配置 (Wav2Vec2Config) 和輸入的不同元素。
-
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
Wav2Vec2ForSequenceClassification 的 forward 方法，覆蓋了 __call__ 特殊方法。
儘管前向傳播的配方需要在此函式中定義，但之後應該呼叫 Module 例項，而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
單標籤分類示例
>>> import torch
>>> from transformers import AutoTokenizer, Wav2Vec2ForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained("facebook/wav2vec2-base-960h")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained("facebook/wav2vec2-base-960h", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...多標籤分類示例
>>> import torch
>>> from transformers import AutoTokenizer, Wav2Vec2ForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained("facebook/wav2vec2-base-960h", problem_type="multi_label_classification")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = Wav2Vec2ForSequenceClassification.from_pretrained(
... "facebook/wav2vec2-base-960h", num_labels=num_labels, problem_type="multi_label_classification"
... )
>>> labels = torch.sum(
... torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).lossWav2Vec2ForAudioFrameClassification
class transformers.Wav2Vec2ForAudioFrameClassification
< source >( config )
引數
- config (Wav2Vec2ForAudioFrameClassification) — 模型的配置類，包含模型的所有引數。使用配置檔案初始化並不會載入與模型相關的權重，只加載配置。請檢視 from_pretrained() 方法來載入模型權重。
Wav2Vec2 模型，頂部帶有用於說話人分離等任務的幀分類頭。
此模型繼承自 PreTrainedModel。請檢視超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
此模型也是 PyTorch torch.nn.Module 子類。將其用作常規 PyTorch 模組，並參考 PyTorch 文件以獲取所有與一般用法和行為相關的事項。
forward
< source >( input_values: typing.Optional[torch.Tensor] attention_mask: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)
引數
- input_values (形狀為
(batch_size, sequence_length)的torch.FloatTensor) — 輸入原始語音波形的浮點值。可以透過將.flac或.wav音訊檔案載入到list[float]型別陣列或numpy.ndarray中獲取，例如透過 soundfile 庫（pip install soundfile）。要將陣列準備為input_values，應使用 AutoProcessor 進行填充和轉換為torch.FloatTensor型別張量。詳情請參閱 Wav2Vec2Processor.call()。 - attention_mask (形狀為
(batch_size, sequence_length)的torch.Tensor, 可選) — 用於避免在填充標記索引上執行注意力的掩碼。掩碼值選擇在[0, 1]中:- 1 表示**未被掩碼**的標記，
- 0 表示**被掩碼**的標記。
- labels (形狀為
(batch_size,)的torch.LongTensor, 可選) — 用於計算序列分類/迴歸損失的標籤。索引應在[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.TokenClassifierOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.TokenClassifierOutput 或一個 torch.FloatTensor 的元組（如果傳入 return_dict=False 或當 config.return_dict=False 時），包含根據配置 (Wav2Vec2Config) 和輸入的不同元素。
-
loss (形狀為
(1,)的torch.FloatTensor，可選，當提供labels時返回) — 分類損失。 -
logits (形狀為
(batch_size, sequence_length, config.num_labels)的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 後的注意力權重，用於計算自注意力頭中的加權平均值。
Wav2Vec2ForAudioFrameClassification 的 forward 方法，覆蓋了 __call__ 特殊方法。
儘管前向傳播的配方需要在此函式中定義，但之後應該呼叫 Module 例項，而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
示例
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ForAudioFrameClassification
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForAudioFrameClassification.from_pretrained("facebook/wav2vec2-base-960h")
>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(dataset[0]["audio"]["array"], return_tensors="pt", sampling_rate=sampling_rate)
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> probabilities = torch.sigmoid(logits[0])
>>> # labels is a one-hot array of shape (num_frames, num_speakers)
>>> labels = (probabilities > 0.5).long()
>>> labels[0].tolist()
...Wav2Vec2ForXVector
class transformers.Wav2Vec2ForXVector
< source >( config )
引數
- config (Wav2Vec2ForXVector) — 模型的配置類，包含模型的所有引數。使用配置檔案初始化並不會載入與模型相關的權重，只加載配置。請檢視 from_pretrained() 方法來載入模型權重。
Wav2Vec2 模型，頂部帶有用於說話人驗證等任務的 XVector 特徵提取頭。
此模型繼承自 PreTrainedModel。請檢視超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
此模型也是 PyTorch torch.nn.Module 子類。將其用作常規 PyTorch 模組，並參考 PyTorch 文件以獲取所有與一般用法和行為相關的事項。
forward
< source >( input_values: typing.Optional[torch.Tensor] attention_mask: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None labels: typing.Optional[torch.Tensor] = None ) → transformers.modeling_outputs.XVectorOutput 或 tuple(torch.FloatTensor)
引數
- input_values (形狀為
(batch_size, sequence_length)的torch.FloatTensor) — 輸入原始語音波形的浮點值。可以透過將.flac或.wav音訊檔案載入到list[float]型別陣列或numpy.ndarray中獲取，例如透過 soundfile 庫（pip install soundfile）。要將陣列準備為input_values，應使用 AutoProcessor 進行填充和轉換為torch.FloatTensor型別張量。詳情請參閱 Wav2Vec2Processor.call()。 - attention_mask (形狀為
(batch_size, sequence_length)的torch.Tensor, 可選) — 用於避免在填充標記索引上執行注意力的掩碼。掩碼值選擇在[0, 1]中:- 1 表示**未被掩碼**的標記，
- 0 表示**被掩碼**的標記。
- output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。更多詳細資訊請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。更多詳細資訊請參閱返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回 ModelOutput 而不是普通的元組。 - labels (形狀為
(batch_size,)的torch.LongTensor, 可選) — 用於計算序列分類/迴歸損失的標籤。索引應在[0, ..., config.num_labels - 1]範圍內。如果config.num_labels == 1，則計算迴歸損失（均方損失）；如果config.num_labels > 1，則計算分類損失（交叉熵）。
返回
transformers.modeling_outputs.XVectorOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.XVectorOutput 或一個 torch.FloatTensor 的元組（如果傳入 return_dict=False 或當 config.return_dict=False 時），包含根據配置 (Wav2Vec2Config) 和輸入的不同元素。
-
loss (形狀為
(1,)的torch.FloatTensor，可選，當提供labels時返回) — 分類損失。 -
logits (形狀為
(batch_size, config.xvector_output_dim)的torch.FloatTensor) — AMSoftmax 之前的分類隱藏狀態。 -
embeddings (形狀為
(batch_size, config.xvector_output_dim)的torch.FloatTensor) — 用於基於向量相似性檢索的話語嵌入。 -
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
Wav2Vec2ForXVector 的 forward 方法，覆蓋了 __call__ 特殊方法。
儘管前向傳播的配方需要在此函式中定義，但之後應該呼叫 Module 例項，而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
示例
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ForXVector
>>> from datasets import load_dataset
>>> import torch
>>> dataset = load_dataset("hf-internal-testing/librispeech_asr_demo", "clean", split="validation")
>>> dataset = dataset.sort("id")
>>> sampling_rate = dataset.features["audio"].sampling_rate
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = Wav2Vec2ForXVector.from_pretrained("facebook/wav2vec2-base-960h")
>>> # audio file is decoded on the fly
>>> inputs = feature_extractor(
... [d["array"] for d in dataset[:2]["audio"]], sampling_rate=sampling_rate, return_tensors="pt", padding=True
... )
>>> with torch.no_grad():
... embeddings = model(**inputs).embeddings
>>> embeddings = torch.nn.functional.normalize(embeddings, dim=-1).cpu()
>>> # the resulting embeddings can be used for cosine similarity-based retrieval
>>> cosine_sim = torch.nn.CosineSimilarity(dim=-1)
>>> similarity = cosine_sim(embeddings[0], embeddings[1])
>>> threshold = 0.7 # the optimal threshold is dataset-dependent
>>> if similarity < threshold:
... print("Speakers are not the same!")
>>> round(similarity.item(), 2)
...Wav2Vec2ForPreTraining
class transformers.Wav2Vec2ForPreTraining
< source >( config: Wav2Vec2Config )
引數
- config (Wav2Vec2Config) — 模型的配置類，包含模型的所有引數。使用配置檔案初始化並不會載入與模型相關的權重，只加載配置。請檢視 from_pretrained() 方法來載入模型權重。
Wav2Vec2 模型，頂部帶有量化器和 VQ 頭。
此模型繼承自 PreTrainedModel。請檢視超類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
此模型也是 PyTorch torch.nn.Module 子類。將其用作常規 PyTorch 模組，並參考 PyTorch 文件以獲取所有與一般用法和行為相關的事項。
forward
< source >( input_values: typing.Optional[torch.Tensor] attention_mask: typing.Optional[torch.Tensor] = None mask_time_indices: typing.Optional[torch.BoolTensor] = None sampled_negative_indices: typing.Optional[torch.BoolTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput 或 tuple(torch.FloatTensor)
引數
- input_values (形狀為
(batch_size, sequence_length)的torch.Tensor, 可選) — 輸入原始語音波形的浮點值。可以透過將.flac或.wav音訊檔案載入到list[float]型別陣列或numpy.ndarray中獲取，例如透過 soundfile 庫（pip install soundfile）。要將陣列準備為input_values，應使用 AutoProcessor 進行填充和轉換為torch.FloatTensor型別張量。詳情請參閱{processor_class}.__call__。 - attention_mask (形狀為
(batch_size, sequence_length)的torch.Tensor, 可選) — 用於避免在填充標記索引上執行注意力的掩碼。掩碼值選擇在[0, 1]中:- 1 表示**未被掩碼**的標記，
- 0 表示**被掩碼**的標記。
- mask_time_indices (形狀為
(batch_size, sequence_length)的torch.BoolTensor, 可選) — 用於對比損失掩碼提取特徵的索引。在訓練模式下，模型學習預測 config.proj_codevector_dim 空間中被掩碼的提取特徵。 - sampled_negative_indices (形狀為
(batch_size, sequence_length, num_negatives)的torch.BoolTensor, 可選) — 指示哪些量化目標向量在對比損失中用作負取樣向量的索引。預訓練的必需輸入。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。更多詳細資訊請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參見返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回ModelOutput而不是純元組。
返回
transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput 或 tuple(torch.FloatTensor)
一個transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2ForPreTrainingOutput或一個torch.FloatTensor的元組（如果傳遞了return_dict=False或config.return_dict=False），包含根據配置（Wav2Vec2Config）和輸入的不同元素。
-
loss (
*可選*，當傳遞sample_negative_indices時返回，形狀為(1,)的torch.FloatTensor) — 總損失，是官方論文中陳述的對比損失 (L_m) 和多樣性損失 (L_d) 的總和。(分類)損失。 -
projected_states (形狀為
(batch_size, sequence_length, config.proj_codevector_dim)的torch.FloatTensor) — 模型投影到config.proj_codevector_dim的隱藏狀態，可用於預測掩碼的投影量化狀態。 -
projected_quantized_states (形狀為
(batch_size, sequence_length, config.proj_codevector_dim)的torch.FloatTensor) — 量化提取的特徵向量，投影到config.proj_codevector_dim，表示對比損失的正目標向量。 -
codevector_perplexity (形狀為
(1,)的torch.FloatTensor) — 碼向量分佈的困惑度，用於衡量碼本的多樣性。 -
hidden_states (
tuple[torch.FloatTensor], 可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（如果模型有嵌入層，則一個用於嵌入層的輸出，加上每個層的輸出）。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
attentions (
tuple[torch.FloatTensor], 可選，當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每個層一個）。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
-
contrastive_loss (
*可選*，當傳遞sample_negative_indices時返回，形狀為(1,)的torch.FloatTensor) — 官方論文中陳述的對比損失 (L_m) 。 -
diversity_loss (
*可選*，當傳遞sample_negative_indices時返回，形狀為(1,)的torch.FloatTensor) — 官方論文中陳述的多樣性損失 (L_d) 。
Wav2Vec2ForPreTraining的前向方法，覆蓋了__call__特殊方法。
儘管前向傳播的配方需要在此函式中定義，但之後應該呼叫 Module 例項，而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
示例
>>> import torch
>>> from transformers import AutoFeatureExtractor, Wav2Vec2ForPreTraining
>>> from transformers.models.wav2vec2.modeling_wav2vec2 import _compute_mask_indices, _sample_negative_indices
>>> from datasets import load_dataset
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base")
>>> model = Wav2Vec2ForPreTraining.from_pretrained("facebook/wav2vec2-base")
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> input_values = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt").input_values # Batch size 1
>>> # compute masked indices
>>> batch_size, raw_sequence_length = input_values.shape
>>> sequence_length = model._get_feat_extract_output_lengths(raw_sequence_length).item()
>>> mask_time_indices = _compute_mask_indices(
... shape=(batch_size, sequence_length), mask_prob=0.2, mask_length=2
... )
>>> sampled_negative_indices = _sample_negative_indices(
... features_shape=(batch_size, sequence_length),
... num_negatives=model.config.num_negatives,
... mask_time_indices=mask_time_indices,
... )
>>> mask_time_indices = torch.tensor(data=mask_time_indices, device=input_values.device, dtype=torch.long)
>>> sampled_negative_indices = torch.tensor(
... data=sampled_negative_indices, device=input_values.device, dtype=torch.long
... )
>>> with torch.no_grad():
... outputs = model(input_values, mask_time_indices=mask_time_indices)
>>> # compute cosine similarity between predicted (=projected_states) and target (=projected_quantized_states)
>>> cosine_sim = torch.cosine_similarity(outputs.projected_states, outputs.projected_quantized_states, dim=-1)
>>> # show that cosine similarity is much higher than random
>>> cosine_sim[mask_time_indices.to(torch.bool)].mean() > 0.5
tensor(True)
>>> # for contrastive loss training model should be put into train mode
>>> model = model.train()
>>> loss = model(
... input_values, mask_time_indices=mask_time_indices, sampled_negative_indices=sampled_negative_indices
... ).lossTFWav2Vec2Model
class transformers.TFWav2Vec2Model
< source >( config: Wav2Vec2Config *inputs **kwargs )
引數
- config (Wav2Vec2Config) — 模型配置類，包含模型的所有引數。使用配置檔案初始化並不會載入與模型相關的權重，只加載配置。請檢視from_pretrained()方法以載入模型權重。
裸露的TFWav2Vec2模型轉換器，輸出原始隱藏狀態，頂部沒有任何特定頭部。
此模型繼承自TFPreTrainedModel。請檢視超類文件，瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
此模型也是keras.Model的子類。將其作為常規的TF 2.0 Keras模型使用，並參考TF 2.0文件中與通用用法和行為相關的所有事項。
transformers 中的 TensorFlow 模型和層接受兩種輸入格式
- 所有輸入作為關鍵字引數（如 PyTorch 模型），或
- 所有輸入作為第一個位置引數中的列表、元組或字典。
支援第二種格式的原因是Keras方法在將輸入傳遞給模型和層時更喜歡這種格式。由於這種支援，當使用model.fit()等方法時，事情應該“順其自然”——只需以model.fit()支援的任何格式傳遞您的輸入和標籤即可！但是，如果您想在fit()和predict()等Keras方法之外使用第二種格式，例如在使用KerasFunctional API建立自己的層或模型時，您可以使用三種可能性來收集第一個位置引數中的所有輸入張量
- 一個只包含
input_values而沒有其他內容的單獨張量：model(input_values) - 一個長度可變，包含一個或多個輸入張量的列表，其順序與文件字串中給出的順序相同：
model([input_values, attention_mask])或model([input_values, attention_mask, token_type_ids]) - 一個包含一個或多個輸入張量的字典，與文件字串中給出的輸入名稱相關聯：
model({"input_values": input_values, "token_type_ids": token_type_ids})
請注意，當使用子類化建立模型和層時，您無需擔心這些，因為您可以像傳遞給任何其他Python函式一樣傳遞輸入！
呼叫
< source >( input_values: tf.Tensor attention_mask: tf.Tensor | None = None token_type_ids: tf.Tensor | None = None position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → transformers.modeling_tf_outputs.TFBaseModelOutput 或 tuple(tf.Tensor)
引數
- input_values (
np.ndarray,tf.Tensor,list[tf.Tensor]dict[str, tf.Tensor]或dict[str, np.ndarray]，每個示例的形狀必須為({0})) — 詞彙表中輸入序列標記的索引。索引可以使用AutoTokenizer獲得。有關詳細資訊，請參見PreTrainedTokenizer.call()和PreTrainedTokenizer.encode()。
- attention_mask (形狀為
({0})的np.ndarray或tf.Tensor，可選) — 避免對填充標記索引執行注意力的掩碼。掩碼值選定在[0, 1]：- 1表示標記未被掩碼，
- 0表示標記已被掩碼。
- token_type_ids (形狀為
({0})的np.ndarray或tf.Tensor，可選) — 片段標記索引，用於指示輸入的第一個和第二個部分。索引選定在[0, 1]：- 0對應於句子A標記，
- 1對應於句子B標記。
- position_ids (形狀為
({0})的np.ndarray或tf.Tensor，可選) — 每個輸入序列標記在位置嵌入中的位置索引。選定範圍為[0, config.max_position_embeddings - 1]。 - head_mask (形狀為
(num_heads,)或(num_layers, num_heads)的np.ndarray或tf.Tensor，可選) — 用於使自注意力模組的選定頭部無效的掩碼。掩碼值選定在[0, 1]：- 1表示頭部未被掩碼，
- 0表示頭部已被掩碼。
- inputs_embeds (形狀為
({0}, hidden_size)的np.ndarray或tf.Tensor，可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞input_values。如果您希望對如何將input_values索引轉換為關聯向量擁有比模型內部嵌入查詢矩陣更多的控制權，這將很有用。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。此引數只能在即時模式下使用，在圖模式下將使用配置中的值。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。此引數只能在即時模式下使用，在圖模式下將使用配置中的值。 - return_dict (
bool, 可選) — 是否返回ModelOutput而不是純元組。此引數可在即時模式下使用，在圖模式下其值將始終設定為True。 - training (
bool, 可選，預設為`False“) — 是否在訓練模式下使用模型（某些模組（如dropout模組）在訓練和評估之間有不同的行為）。
返回
transformers.modeling_tf_outputs.TFBaseModelOutput 或 tuple(tf.Tensor)
一個transformers.modeling_tf_outputs.TFBaseModelOutput或一個tf.Tensor元組（如果傳遞了return_dict=False或config.return_dict=False），包含根據配置（Wav2Vec2Config）和輸入的不同元素。
-
last_hidden_state (
tf.Tensorof shape(batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。 -
hidden_states (
tuple(tf.FloatTensor), 可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的tf.Tensor元組（一個用於嵌入層輸出 + 一個用於每個層輸出）。模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
-
attentions (
tuple(tf.Tensor), 可選，當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元組（每個層一個）。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
TFWav2Vec2Model的前向方法，覆蓋了__call__特殊方法。
儘管前向傳播的配方需要在此函式中定義，但之後應該呼叫 Module 例項，而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
示例
>>> from transformers import AutoProcessor, TFWav2Vec2Model
>>> from datasets import load_dataset
>>> import soundfile as sf
>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = TFWav2Vec2Model.from_pretrained("facebook/wav2vec2-base-960h")
>>> def map_to_array(batch):
... speech, _ = sf.read(batch["file"])
... batch["speech"] = speech
... return batch
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.map(map_to_array)
>>> input_values = processor(ds["speech"][0], return_tensors="tf").input_values # Batch size 1
>>> hidden_states = model(input_values).last_hidden_stateTFWav2Vec2ForSequenceClassification
呼叫
< source >( input_values: tf.Tensor attention_mask: tf.Tensor | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None labels: tf.Tensor | None = None training: bool = False )
TFWav2Vec2ForCTC
class transformers.TFWav2Vec2ForCTC
< source >( config: Wav2Vec2Config *inputs **kwargs )
引數
- config (Wav2Vec2Config) — 模型配置類，包含模型的所有引數。使用配置檔案初始化並不會載入與模型相關的權重，只加載配置。請檢視from_pretrained()方法以載入模型權重。
帶有頂部語言建模頭部用於連線主義時間分類（CTC）的TFWav2Vec2模型。
此模型繼承自TFPreTrainedModel。請檢視超類文件，瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
此模型也是keras.Model的子類。將其作為常規的TF 2.0 Keras模型使用，並參考TF 2.0文件中與通用用法和行為相關的所有事項。
transformers 中的 TensorFlow 模型和層接受兩種輸入格式
- 所有輸入作為關鍵字引數（如 PyTorch 模型），或
- 所有輸入作為第一個位置引數中的列表、元組或字典。
支援第二種格式的原因是Keras方法在將輸入傳遞給模型和層時更喜歡這種格式。由於這種支援，當使用model.fit()等方法時，事情應該“順其自然”——只需以model.fit()支援的任何格式傳遞您的輸入和標籤即可！但是，如果您想在fit()和predict()等Keras方法之外使用第二種格式，例如在使用KerasFunctional API建立自己的層或模型時，您可以使用三種可能性來收集第一個位置引數中的所有輸入張量
- 一個只包含
input_values而沒有其他內容的單獨張量：model(input_values) - 一個長度可變，包含一個或多個輸入張量的列表，其順序與文件字串中給出的順序相同：
model([input_values, attention_mask])或model([input_values, attention_mask, token_type_ids]) - 一個包含一個或多個輸入張量的字典，與文件字串中給出的輸入名稱相關聯：
model({"input_values": input_values, "token_type_ids": token_type_ids})
請注意，當使用子類化建立模型和層時，您無需擔心這些，因為您可以像傳遞給任何其他Python函式一樣傳遞輸入！
呼叫
< source >( input_values: tf.Tensor attention_mask: tf.Tensor | None = None token_type_ids: tf.Tensor | None = None position_ids: tf.Tensor | None = None head_mask: tf.Tensor | None = None inputs_embeds: tf.Tensor | None = None output_attentions: Optional[bool] = None labels: tf.Tensor | None = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) → transformers.modeling_tf_outputs.TFCausalLMOutput 或 tuple(tf.Tensor)
引數
- input_values (
np.ndarray,tf.Tensor,list[tf.Tensor]dict[str, tf.Tensor]或dict[str, np.ndarray]，每個示例的形狀必須為({0})) — 詞彙表中輸入序列標記的索引。索引可以使用AutoTokenizer獲得。有關詳細資訊，請參見PreTrainedTokenizer.call()和PreTrainedTokenizer.encode()。
- attention_mask (形狀為
({0})的np.ndarray或tf.Tensor，可選) — 避免對填充標記索引執行注意力的掩碼。掩碼值選定在[0, 1]：- 1表示標記未被掩碼，
- 0表示標記已被掩碼。
- token_type_ids (形狀為
({0})的np.ndarray或tf.Tensor，可選) — 片段標記索引，用於指示輸入的第一個和第二個部分。索引選定在[0, 1]：- 0對應於句子A標記，
- 1對應於句子B標記。
- position_ids (形狀為
({0})的np.ndarray或tf.Tensor，可選) — 每個輸入序列標記在位置嵌入中的位置索引。選定範圍為[0, config.max_position_embeddings - 1]。 - head_mask (形狀為
(num_heads,)或(num_layers, num_heads)的np.ndarray或tf.Tensor，可選) — 用於使自注意力模組的選定頭部無效的掩碼。掩碼值選定在[0, 1]：- 1表示頭部未被掩碼，
- 0表示頭部已被掩碼。
- inputs_embeds (形狀為
({0}, hidden_size)的np.ndarray或tf.Tensor，可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞input_values。如果您希望對如何將input_values索引轉換為關聯向量擁有比模型內部嵌入查詢矩陣更多的控制權，這將很有用。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。此引數只能在即時模式下使用，在圖模式下將使用配置中的值。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。此引數只能在即時模式下使用，在圖模式下將使用配置中的值。 - return_dict (
bool, 可選) — 是否返回ModelOutput而不是純元組。此引數可在即時模式下使用，在圖模式下其值將始終設定為True。 - training (
bool, 可選，預設為`False“) — 是否在訓練模式下使用模型（某些模組（如dropout模組）在訓練和評估之間有不同的行為）。 - labels (形狀為
(batch_size, sequence_length)的tf.Tensor或np.ndarray，可選) — 用於計算掩碼語言建模損失的標籤。索引應在[-100, 0, ..., config.vocab_size]範圍內（請參閱input_values文件字串）。索引設定為-100的標記將被忽略（掩碼），損失僅針對標籤在[0, ..., config.vocab_size]範圍內的標記計算。
返回
transformers.modeling_tf_outputs.TFCausalLMOutput 或 tuple(tf.Tensor)
一個transformers.modeling_tf_outputs.TFCausalLMOutput或一個tf.Tensor元組（如果傳遞了return_dict=False或config.return_dict=False），包含根據配置（Wav2Vec2Config）和輸入的不同元素。
-
loss (形狀為
(n,)的tf.Tensor，可選，其中n是非掩碼標籤的數量，當提供了labels時返回) — 語言建模損失（用於下一標記預測）。 -
logits (
tf.Tensorof shape(batch_size, sequence_length, config.vocab_size)) — 語言模型頭部的預測分數（SoftMax 之前每個詞彙標記的分數）。 -
hidden_states (
tuple(tf.Tensor), 可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的tf.Tensor元組（一個用於嵌入層輸出 + 一個用於每個層輸出）。模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
-
attentions (
tuple(tf.Tensor), 可選，當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元組（每個層一個）。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
TFWav2Vec2ForCTC的前向方法，覆蓋了__call__特殊方法。
儘管前向傳播的配方需要在此函式中定義，但之後應該呼叫 Module 例項，而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
示例
>>> import tensorflow as tf
>>> from transformers import AutoProcessor, TFWav2Vec2ForCTC
>>> from datasets import load_dataset
>>> import soundfile as sf
>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-base-960h")
>>> model = TFWav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-base-960h")
>>> def map_to_array(batch):
... speech, _ = sf.read(batch["file"])
... batch["speech"] = speech
... return batch
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.map(map_to_array)
>>> input_values = processor(ds["speech"][0], return_tensors="tf").input_values # Batch size 1
>>> logits = model(input_values).logits
>>> predicted_ids = tf.argmax(logits, axis=-1)
>>> transcription = processor.decode(predicted_ids[0])
>>> # compute loss
>>> target_transcription = "A MAN SAID TO THE UNIVERSE SIR I EXIST"
>>> # Pass transcription as `text` to encode labels
>>> labels = processor(text=transcription, return_tensors="tf").input_ids
>>> loss = model(input_values, labels=labels).lossFlaxWav2Vec2Model
class transformers.FlaxWav2Vec2Model
< source >( config: Wav2Vec2Config input_shape: tuple = (1, 1024) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
引數
- config (Wav2Vec2Config) — 模型配置類，包含模型的所有引數。使用配置檔案初始化並不會載入與模型相關的權重，只加載配置。請檢視from_pretrained()方法以載入模型權重。
- dtype (
jax.numpy.dtype, 可選，預設為jax.numpy.float32) — 計算的資料型別。可以是jax.numpy.float32、jax.numpy.float16（在GPU上）和jax.numpy.bfloat16（在TPU上）。這可用於在GPU或TPU上啟用混合精度訓練或半精度推理。如果指定，所有計算將以給定的
dtype執行。請注意，這僅指定計算的資料型別，不影響模型引數的資料型別。
裸露的Wav2Vec2模型轉換器，輸出原始隱藏狀態，頂部沒有任何特定頭部。Wav2Vec2由Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli在wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations中提出。
此模型繼承自FlaxPreTrainedModel。請檢視超類文件，瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
此模型也是Flax Linen flax.nn.Module的子類。將其作為常規的Flax模組使用，並參考Flax文件中與通用用法和行為相關的所有事項。
最後，此模型支援固有的 JAX 功能，例如
__call__
< source >( input_values attention_mask = None mask_time_indices = None params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None freeze_feature_encoder: bool = False return_dict: typing.Optional[bool] = None ) → transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2BaseModelOutput or tuple(torch.FloatTensor)
引數
- input_values (
jnp.ndarrayof shape(batch_size, sequence_length)) — 輸入原始語音波形的浮點值。可以透過將.flac或.wav音訊檔案載入到list[float]型別或numpy.ndarray的陣列中來獲取這些值，例如透過 soundfile 庫（pip install soundfile）。為了將陣列準備成input_values，應使用 AutoProcessor 進行填充並轉換為jnp.ndarray型別的張量。詳見 Wav2Vec2Processor.call()。 - attention_mask (形狀為
(batch_size, sequence_length)的jnp.ndarray，可選) — 用於避免在填充標記索引上執行卷積和注意力的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示 未掩碼 的標記，
- 0 表示 已掩碼 的標記。
什麼是注意力掩碼？.. 警告:: 僅當對應的處理器具有
config.return_attention_mask == True時，才應傳遞attention_mask。對於所有處理器具有config.return_attention_mask == False的模型，例如 wav2vec2-base，不應傳遞attention_mask以避免在批次推理時效能下降。對於此類模型，應簡單地將input_values填充為 0，並在不帶attention_mask的情況下傳遞。請注意，這些模型還會根據input_values是否填充而產生略微不同的結果。 - mask_time_indices (形狀為
(batch_size, sequence_length)的jnp.ndarray，可選) — 用於掩碼提取特徵以進行對比損失的索引。在訓練模式下，模型學習預測 config.proj_codevector_dim 空間中的掩碼提取特徵。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool，可選) — 是否返回 ModelOutput 而不是普通的元組。
返回
transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2BaseModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2BaseModelOutput 或一個 torch.FloatTensor 元組（如果傳入 return_dict=False 或當 config.return_dict=False 時），根據配置（<class 'transformers.models.wav2vec2.configuration_wav2vec2.Wav2Vec2Config'>）和輸入包含各種元素。
-
last_hidden_state (形狀為
(batch_size, sequence_length, hidden_size)的jnp.ndarray) — 模型最後一層輸出的隱藏狀態序列。 -
extract_features (形狀為
(batch_size, sequence_length, last_conv_dim)的jnp.ndarray) — 模型最後一個卷積層的提取特徵向量序列，其中last_conv_dim是最後一個卷積層的維度。 -
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
FlaxWav2Vec2PreTrainedModel 前向方法，重寫了 __call__ 特殊方法。
儘管前向傳播的配方需要在此函式中定義，但之後應該呼叫 Module 例項，而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
示例
>>> from transformers import AutoProcessor, FlaxWav2Vec2Model
>>> from datasets import load_dataset
>>> import soundfile as sf
>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-large-lv60")
>>> model = FlaxWav2Vec2Model.from_pretrained("facebook/wav2vec2-large-lv60")
>>> def map_to_array(batch):
... speech, _ = sf.read(batch["file"])
... batch["speech"] = speech
... return batch
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.map(map_to_array)
>>> input_values = processor(
... ds["speech"][0], sampling_rate=16_000, return_tensors="np"
... ).input_values # Batch size 1
>>> hidden_states = model(input_values).last_hidden_stateFlaxWav2Vec2ForCTC
class transformers.FlaxWav2Vec2ForCTC
< 源 >( config: Wav2Vec2Config input_shape: tuple = (1, 1024) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
引數
- config (Wav2Vec2Config) — 包含模型所有引數的模型配置類。使用配置檔案初始化並不會載入與模型相關的權重，只加載配置。請檢視 from_pretrained() 方法以載入模型權重。
- dtype (
jax.numpy.dtype，可選，預設為jax.numpy.float32) — 計算的資料型別。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）中的一種。這可用於在 GPU 或 TPU 上啟用混合精度訓練或半精度推理。如果指定，所有計算都將使用給定的
dtype執行。請注意，這僅指定了計算的資料型別，不影響模型引數的資料型別。
Wav2Vec2 模型，頂部帶有用於連線主義時間分類 (CTC) 的 語言建模 頭。Wav2Vec2 由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli 在 wav2vec 2.0: 語音表示自監督學習框架 中提出。
此模型繼承自FlaxPreTrainedModel。請檢視超類文件，瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
此模型也是Flax Linen flax.nn.Module的子類。將其作為常規的Flax模組使用，並參考Flax文件中與通用用法和行為相關的所有事項。
最後，此模型支援固有的 JAX 功能，例如
__call__
< 源 >( input_values attention_mask = None mask_time_indices = None params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None freeze_feature_encoder: bool = False return_dict: typing.Optional[bool] = None ) → transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或 tuple(torch.FloatTensor)
引數
- input_values (形狀為
(batch_size, sequence_length)的jnp.ndarray) — 輸入原始語音波形的浮點值。可以透過將.flac或.wav音訊檔案載入到list[float]型別或numpy.ndarray的陣列中來獲取這些值，例如透過 soundfile 庫（pip install soundfile）。為了將陣列準備成input_values，應使用 AutoProcessor 進行填充並轉換為jnp.ndarray型別的張量。詳見 Wav2Vec2Processor.call()。 - attention_mask (形狀為
(batch_size, sequence_length)的jnp.ndarray，可選) — 用於避免在填充標記索引上執行卷積和注意力的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示 未掩碼 的標記，
- 0 表示 已掩碼 的標記。
什麼是注意力掩碼？.. 警告:: 僅當對應的處理器具有
config.return_attention_mask == True時，才應傳遞attention_mask。對於所有處理器具有config.return_attention_mask == False的模型，例如 wav2vec2-base，不應傳遞attention_mask以避免在批次推理時效能下降。對於此類模型，應簡單地將input_values填充為 0，並在不帶attention_mask的情況下傳遞。請注意，這些模型還會根據input_values是否填充而產生略微不同的結果。 - mask_time_indices (形狀為
(batch_size, sequence_length)的jnp.ndarray，可選) — 用於掩碼提取特徵以進行對比損失的索引。在訓練模式下，模型學習預測 config.proj_codevector_dim 空間中的掩碼提取特徵。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool，可選) — 是否返回 ModelOutput 而不是普通的元組。
返回
transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或一個 torch.FloatTensor 元組（如果傳入 return_dict=False 或當 config.return_dict=False 時），根據配置（<class 'transformers.models.wav2vec2.configuration_wav2vec2.Wav2Vec2Config'>）和輸入包含各種元素。
-
logits (形狀為
(batch_size, sequence_length, config.vocab_size)的jnp.ndarray) — 語言建模頭的預測分數（SoftMax 之前每個詞彙 token 的分數）。 -
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
FlaxWav2Vec2PreTrainedModel 前向方法，重寫了 __call__ 特殊方法。
儘管前向傳播的配方需要在此函式中定義，但之後應該呼叫 Module 例項，而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
示例
>>> import jax.numpy as jnp
>>> from transformers import AutoProcessor, FlaxWav2Vec2ForCTC
>>> from datasets import load_dataset
>>> import soundfile as sf
>>> processor = AutoProcessor.from_pretrained("facebook/wav2vec2-large-960h-lv60")
>>> model = FlaxWav2Vec2ForCTC.from_pretrained("facebook/wav2vec2-large-960h-lv60")
>>> def map_to_array(batch):
... speech, _ = sf.read(batch["file"])
... batch["speech"] = speech
... return batch
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.map(map_to_array)
>>> input_values = processor(
... ds["speech"][0], sampling_rate=16_000, return_tensors="np"
... ).input_values # Batch size 1
>>> logits = model(input_values).logits
>>> predicted_ids = jnp.argmax(logits, axis=-1)
>>> transcription = processor.decode(predicted_ids[0])
>>> # should give: "A MAN SAID TO THE UNIVERSE SIR I EXIST"FlaxWav2Vec2ForPreTraining
class transformers.FlaxWav2Vec2ForPreTraining
< 源 >( config: Wav2Vec2Config input_shape: tuple = (1, 1024) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
引數
- config (Wav2Vec2Config) — 包含模型所有引數的模型配置類。使用配置檔案初始化並不會載入與模型相關的權重，只加載配置。請檢視 from_pretrained() 方法以載入模型權重。
- dtype (
jax.numpy.dtype，可選，預設為jax.numpy.float32) — 計算的資料型別。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）中的一種。這可用於在 GPU 或 TPU 上啟用混合精度訓練或半精度推理。如果指定，所有計算都將使用給定的
dtype執行。請注意，這僅指定了計算的資料型別，不影響模型引數的資料型別。
Wav2Vec2 模型，頂部帶有量化器和 VQ 頭。Wav2Vec2 由 Alexei Baevski、Henry Zhou、Abdelrahman Mohamed、Michael Auli 在 wav2vec 2.0: 語音表示自監督學習框架 中提出。
此模型繼承自FlaxPreTrainedModel。請檢視超類文件，瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
此模型也是Flax Linen flax.nn.Module的子類。將其作為常規的Flax模組使用，並參考Flax文件中與通用用法和行為相關的所有事項。
最後，此模型支援固有的 JAX 功能，例如
__call__
< 源 >( input_values attention_mask = None mask_time_indices = None gumbel_temperature: int = 1 params: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None gumbel_rng: <function PRNGKey at 0x7effc7ad3a30> = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None freeze_feature_encoder: bool = False return_dict: typing.Optional[bool] = None ) → transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2ForPreTrainingOutput 或 tuple(torch.FloatTensor)
引數
- input_values (形狀為
(batch_size, sequence_length)的jnp.ndarray) — 輸入原始語音波形的浮點值。可以透過將.flac或.wav音訊檔案載入到list[float]型別或numpy.ndarray的陣列中來獲取這些值，例如透過 soundfile 庫（pip install soundfile）。為了將陣列準備成input_values，應使用 AutoProcessor 進行填充並轉換為jnp.ndarray型別的張量。詳見 Wav2Vec2Processor.call()。 - attention_mask (形狀為
(batch_size, sequence_length)的jnp.ndarray，可選) — 用於避免在填充標記索引上執行卷積和注意力的掩碼。掩碼值選擇範圍為[0, 1]：- 1 表示 未掩碼 的標記，
- 0 表示 已掩碼 的標記。
什麼是注意力掩碼？.. 警告:: 僅當對應的處理器具有
config.return_attention_mask == True時，才應傳遞attention_mask。對於所有處理器具有config.return_attention_mask == False的模型，例如 wav2vec2-base，不應傳遞attention_mask以避免在批次推理時效能下降。對於此類模型，應簡單地將input_values填充為 0，並在不帶attention_mask的情況下傳遞。請注意，這些模型還會根據input_values是否填充而產生略微不同的結果。 - mask_time_indices (形狀為
(batch_size, sequence_length)的jnp.ndarray，可選) — 用於掩碼提取特徵以進行對比損失的索引。在訓練模式下，模型學習預測 config.proj_codevector_dim 空間中的掩碼提取特徵。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool，可選) — 是否返回 ModelOutput 而不是普通的元組。
返回
transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2ForPreTrainingOutput 或 tuple(torch.FloatTensor)
一個 transformers.models.wav2vec2.modeling_flax_wav2vec2.FlaxWav2Vec2ForPreTrainingOutput 或一個 torch.FloatTensor 元組（如果傳入 return_dict=False 或當 config.return_dict=False 時），根據配置（<class 'transformers.models.wav2vec2.configuration_wav2vec2.Wav2Vec2Config'>）和輸入包含各種元素。
-
loss (可選，在模型處於訓練模式時返回，形狀為
(1,)的jnp.ndarray) — 總損失，是對比損失 (L_m) 和多樣性損失 (L_d) 的總和，如 官方論文 中所述。（分類）損失。 -
projected_states (形狀為
(batch_size, sequence_length, config.proj_codevector_dim)的jnp.ndarray) — 模型的隱藏狀態，投影到 config.proj_codevector_dim 空間，可用於預測掩碼投影量化狀態。 -
projected_quantized_states (形狀為
(batch_size, sequence_length, config.proj_codevector_dim)的jnp.ndarray) — 量化提取的特徵向量，投影到 config.proj_codevector_dim 空間，表示對比損失的正目標向量。 -
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
FlaxWav2Vec2ForPreTraining 前向方法，重寫了 __call__ 特殊方法。
儘管前向傳播的配方需要在此函式中定義，但之後應該呼叫 Module 例項，而不是此函式，因為前者負責執行預處理和後處理步驟，而後者則默默地忽略它們。
示例
>>> import optax
>>> import numpy as np
>>> import jax.numpy as jnp
>>> from transformers import AutoFeatureExtractor, FlaxWav2Vec2ForPreTraining
>>> from transformers.models.wav2vec2.modeling_flax_wav2vec2 import _compute_mask_indices
>>> from datasets import load_dataset
>>> import soundfile as sf
>>> feature_extractor = AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-large-lv60")
>>> model = FlaxWav2Vec2ForPreTraining.from_pretrained("facebook/wav2vec2-large-lv60")
>>> def map_to_array(batch):
... speech, _ = sf.read(batch["file"])
... batch["speech"] = speech
... return batch
>>> ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
>>> ds = ds.map(map_to_array)
>>> input_values = feature_extractor(ds["speech"][0], return_tensors="np").input_values # Batch size 1
>>> # compute masked indices
>>> batch_size, raw_sequence_length = input_values.shape
>>> sequence_length = model._get_feat_extract_output_lengths(raw_sequence_length)
>>> mask_time_indices = _compute_mask_indices((batch_size, sequence_length), mask_prob=0.2, mask_length=2)
>>> outputs = model(input_values, mask_time_indices=mask_time_indices)
>>> # compute cosine similarity between predicted (=projected_states) and target (=projected_quantized_states)
>>> cosine_sim = optax.cosine_similarity(outputs.projected_states, outputs.projected_quantized_states)
>>> # show that cosine similarity is much higher than random
>>> assert np.asarray(cosine_sim)[mask_time_indices].mean() > 0.5