Transformers 文件
Hubert
並獲得增強的文件體驗
開始使用
Hubert
概述
Hubert 模型由 Wei-Ning Hsu、Benjamin Bolte、Yao-Hung Hubert Tsai、Kushal Lakhotia、Ruslan Salakhutdinov 和 Abdelrahman Mohamed 在論文《HuBERT: Self-Supervised Speech Representation Learning by Masked Prediction of Hidden Units》中提出。
論文摘要如下：
用於語音表示學習的自監督方法面臨三個獨特的問題：（1）每個輸入話語中有多個聲音單元，（2）在預訓練階段沒有輸入聲音單元的詞典，以及（3）聲音單元的長度可變且沒有明確的分割。為了解決這三個問題，我們提出了用於自監督語音表示學習的 Hidden-Unit BERT (HuBERT) 方法，該方法利用離線聚類步驟為類 BERT 的預測損失提供對齊的目標標籤。我們方法的一個關鍵要素是僅在被掩碼的區域上應用預測損失，這迫使模型在連續輸入上學習一個組合的聲學和語言模型。HuBERT 主要依賴於無監督聚類步驟的一致性，而不是所分配聚類標籤的內在質量。從一個包含 100 個聚類的簡單 k-means 教師開始，並使用兩次聚類迭代，HuBERT 模型在 Librispeech (960h) 和 Libri-light (60,000h) 基準測試中，使用 10 分鐘、1 小時、10 小時、100 小時和 960 小時微調子集，其效能與最先進的 wav2vec 2.0 相當或更好。使用一個 1B 引數模型，HuBERT 在更具挑戰性的 dev-other 和 test-other 評估子集上顯示出高達 19% 和 13% 的相對詞錯誤率（WER）降低。
此模型由 patrickvonplaten 貢獻。
使用技巧
- Hubert 是一個語音模型，它接受一個與語音訊號原始波形相對應的浮點陣列。
- Hubert 模型使用聯結主義時間分類 (CTC) 進行微調，因此模型輸出必須使用 `Wav2Vec2CTCTokenizer` 進行解碼。
- 當使用除“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
用法
下面是一個預期的加速圖，比較了 `facebook/hubert-large-ls960-ft` 在 transformers 中的原生實現、flash-attention-2 版本以及 sdpa（scale-dot-product-attention）版本之間的純推理時間。我們展示了在 `librispeech_asr` `clean` 驗證集上獲得的平均加速比。
>>> from transformers import HubertModel
>>> import torch
>>> model = HubertModel.from_pretrained("facebook/hubert-large-ls960-ft", torch_dtype=torch.float16, attn_implementation="flash_attention_2").to("cuda")
...預期加速
下面是一個預期的加速圖，比較了 `facebook/hubert-large-ls960-ft` 模型在 transformers 中的原生實現、flash-attention-2 版本以及 sdpa（scale-dot-product-attention）版本之間的純推理時間。我們展示了在 `librispeech_asr` `clean` 驗證集上獲得的平均加速比。
資源
HubertConfig
class transformers.HubertConfig
< 來源 >( 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_layer_norm = True feat_proj_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 conv_pos_batch_norm = False 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 ctc_loss_reduction = 'sum' ctc_zero_infinity = False use_weighted_layer_sum = False classifier_proj_size = 256 pad_token_id = 0 bos_token_id = 1 eos_token_id = 2 **kwargs )
引數
- vocab_size (
int, 可選, 預設為 32) — Hubert 模型的詞彙表大小。定義了在呼叫 `HubertModel` 時，`inputs_ids` 可以表示的不同標記的數量。模型的詞彙表大小。定義了傳遞給 `HubertModel` 的 `forward` 方法的 *`inputs_ids`* 可以表示的不同標記。 - 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) — 嵌入層、編碼器和池化層中所有全連線層的丟棄機率。 - activation_dropout (
float, 可選, 預設為 0.1) — 全連線層內啟用函式的丟棄率。 - attention_dropout(
float, 可選, 預設為 0.1) — 注意力機率的丟棄率。 - final_dropout (
float, 可選, 預設為 0.1) — `Wav2Vec2ForCTC` 最終投影層的丟棄機率。 - layerdrop (
float, 可選, 預設為 0.1) — LayerDrop 機率。更多詳情請參閱 [LayerDrop 論文](https://huggingface.co/papers/1909.11556)。 - initializer_range (
float, 可選, 預設為 0.02) — 用於初始化所有權重矩陣的 `truncated_normal_initializer` 的標準差。 - layer_norm_eps (
float, 可選, 預設為 1e-12) — 層歸一化層使用的 epsilon 值。 - feat_extract_norm (
str, 可選, 預設為"group") — 應用於特徵編碼器中 1D 卷積層的歸一化方法。`"group"` 表示僅對第一個 1D 卷積層進行組歸一化，`"layer"` 表示對所有 1D 卷積層進行層歸一化。 - feat_proj_dropout (
float, 可選, 預設為 0.0) — 特徵編碼器輸出的丟棄機率。 - feat_proj_layer_norm (
bool, 可選, 預設為 `True`) — 是否對特徵編碼器的輸出應用層歸一化。 - feat_extract_activation (
str, `可選`, 預設為 `“gelu”`) -- 特徵提取器中 1D 卷積層的非線性啟用函式（函式或字串）。如果為字串，支援 `“gelu”`、`“relu”`、`“selu”` 和 `“gelu_new”`。 - conv_dim (
tuple[int], 可選, 預設為 `(512, 512, 512, 512, 512, 512, 512)`) — 定義特徵編碼器中每個 1D 卷積層的輸入和輸出通道數的整數元組。*conv_dim* 的長度定義了 1D 卷積層的數量。 - conv_stride (
tuple[int], 可選, 預設為 `(5, 2, 2, 2, 2, 2, 2)`) — 定義特徵編碼器中每個 1D 卷積層步長的整數元組。*conv_stride* 的長度定義了卷積層的數量，並且必須與 *conv_dim* 的長度相匹配。 - conv_kernel (
tuple[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 卷積位置嵌入層的組數。 - conv_pos_batch_norm (
bool, 可選, 預設為 `False`) — 在 conv_pos 中是否使用批歸一化而不是權重歸一化。 - do_stable_layer_norm (
bool, 可選, 預設為 `False`) — 是否應用 Transformer 編碼器的*穩定*層歸一化架構。`do_stable_layer_norm is True` 對應於在注意力層之前應用層歸一化，而 `do_stable_layer_norm is False` 對應於在注意力層之後應用層歸一化。 - apply_spec_augment (
bool, 可選, 預設為 `True`) — 是否對特徵編碼器的輸出應用 *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`” 時相關。 - ctc_loss_reduction (
str, 可選, 預設為"sum") — 指定應用於 `torch.nn.CTCLoss` 輸出的縮減方式。僅在訓練 `HubertForCTC` 例項時相關。 - ctc_zero_infinity (
bool, 可選, 預設為 `False`) — 是否將 `torch.nn.CTCLoss` 的無限損失及其相關梯度置零。無限損失主要發生在輸入太短而無法與目標對齊時。僅在訓練 `HubertForCTC` 例項時相關。 - use_weighted_layer_sum (
bool, 可選, 預設為 `False`) — 是否使用學習到的權重對層輸出進行加權平均。僅在使用 `HubertForSequenceClassification` 例項時相關。 - classifier_proj_size (
int, 可選, 預設為 256) — 分類前標記均值池化投影的維度。
這是用於儲存 `HubertModel` 配置的配置類。它用於根據指定的引數例項化一個 Hubert 模型，定義模型架構。使用預設值例項化配置將產生與 Hubert `facebook/hubert-base-ls960` 架構類似的配置。
配置物件繼承自 `PretrainedConfig`，可用於控制模型輸出。有關更多資訊，請閱讀 `PretrainedConfig` 的文件。
示例
>>> from transformers import HubertModel, HubertConfig
>>> # Initializing a Hubert facebook/hubert-base-ls960 style configuration
>>> configuration = HubertConfig()
>>> # Initializing a model from the facebook/hubert-base-ls960 style configuration
>>> model = HubertModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configHubertModel
class transformers.HubertModel
< 來源 >( config: HubertConfig )
引數
- config (HubertConfig) — 模型配置類，包含模型的所有引數。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
一個基礎的 Hubert 模型，輸出原始的隱藏狀態（hidden-states），頂部沒有任何特定的模型頭（head）。
該模型繼承自 PreTrainedModel。查閱父類的文件以瞭解該庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪模型頭等）。
該模型也是一個 PyTorch torch.nn.Module 的子類。可以像使用常規 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
forward
< 原始檔 >( 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.BaseModelOutput 或 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.BaseModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.BaseModelOutput 或一個 torch.FloatTensor 的元組（如果傳遞了 return_dict=False 或 config.return_dict=False），包含根據配置 (HubertConfig) 和輸入而定的各種元素。
-
last_hidden_state (
torch.FloatTensor, 形狀為(batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。 -
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
HubertModel 的 forward 方法重寫了 __call__ 特殊方法。
雖然前向傳播的流程需要在此函式中定義，但之後應呼叫 Module 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> from transformers import AutoProcessor, HubertModel
>>> from datasets import load_dataset
>>> import soundfile as sf
>>> processor = AutoProcessor.from_pretrained("facebook/hubert-large-ls960-ft")
>>> model = HubertModel.from_pretrained("facebook/hubert-large-ls960-ft")
>>> 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="pt").input_values # Batch size 1
>>> hidden_states = model(input_values).last_hidden_stateHubertForCTC
class transformers.HubertForCTC
< 原始檔 >( config target_lang: typing.Optional[str] = None )
引數
- config (HubertForCTC) — 模型配置類，包含模型的所有引數。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
- target_lang (
str, 可選) — 介面卡權重的語言 ID。介面卡權重以 `adapter..safetensors` 或 `adapter. .bin` 的格式儲存。僅在使用帶介面卡的 HubertForCTC 例項時相關。預設使用‘eng’。
一個在頂部帶有 `語言模型` 頭的 Hubert 模型，用於連線時序分類（Connectionist Temporal Classification, CTC）。
該模型繼承自 PreTrainedModel。查閱父類的文件以瞭解該庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪模型頭等）。
該模型也是一個 PyTorch torch.nn.Module 的子類。可以像使用常規 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
forward
< 原始檔 >( 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），包含根據配置 (HubertConfig) 和輸入而定的各種元素。
-
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
HubertForCTC 的 forward 方法重寫了 __call__ 特殊方法。
雖然前向傳播的流程需要在此函式中定義，但之後應呼叫 Module 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> from transformers import AutoProcessor, HubertForCTC
>>> 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/hubert-base-ls960")
>>> model = HubertForCTC.from_pretrained("facebook/hubert-base-ls960")
>>> # 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)
...HubertForSequenceClassification
class transformers.HubertForSequenceClassification
< 原始檔 >( config )
引數
- config (HubertForSequenceClassification) — 模型配置類，包含模型的所有引數。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
Hubert 模型在頂部帶有一個序列分類頭（在池化輸出上加一個線性層），用於像 SUPERB 關鍵詞識別這樣的任務。
該模型繼承自 PreTrainedModel。查閱父類的文件以瞭解該庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪模型頭等）。
該模型也是一個 PyTorch torch.nn.Module 的子類。可以像使用常規 PyTorch 模組一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
forward
< 原始檔 >( 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 (
torch.FloatTensor，形狀為(batch_size, sequence_length)) — 輸入的原始語音波形的浮點數值。可以透過將.flac或.wav音訊檔案載入到list[float]或numpy.ndarray型別的陣列中獲得這些值，例如，使用 soundfile 庫（pip install soundfile）。為了將陣列準備成input_values，應使用 AutoProcessor 進行填充並轉換為torch.FloatTensor型別的張量。詳見HubertProcessor.__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,)，可選) — 用於計算序列分類/迴歸損失的標籤。索引應在[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），包含根據配置 (HubertConfig) 和輸入而定的各種元素。
-
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
HubertForSequenceClassification 的 forward 方法重寫了 __call__ 特殊方法。
雖然前向傳播的流程需要在此函式中定義，但之後應呼叫 Module 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
單標籤分類示例
>>> import torch
>>> from transformers import AutoTokenizer, HubertForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/hubert-base-ls960")
>>> model = HubertForSequenceClassification.from_pretrained("facebook/hubert-base-ls960")
>>> 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 = HubertForSequenceClassification.from_pretrained("facebook/hubert-base-ls960", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...多標籤分類示例
>>> import torch
>>> from transformers import AutoTokenizer, HubertForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("facebook/hubert-base-ls960")
>>> model = HubertForSequenceClassification.from_pretrained("facebook/hubert-base-ls960", 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 = HubertForSequenceClassification.from_pretrained(
... "facebook/hubert-base-ls960", 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).lossTFHubertModel
class transformers.TFHubertModel
< 原始檔 >( config: HubertConfig *inputs **kwargs )
引數
- config (HubertConfig) — 模型配置類，包含模型的所有引數。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
一個基礎的 TFHubert 模型，輸出原始的隱藏狀態（hidden-states），頂部沒有任何特定的模型頭（head）。
該模型繼承自 TFPreTrainedModel。查閱父類的文件以瞭解該庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪模型頭等）。
該模型也是一個 keras.Model 的子類。可以像使用常規 TF 2.0 Keras 模型一樣使用它，並參考 TF 2.0 文件瞭解所有與通用用法和行為相關的事項。
transformers 中的 TensorFlow 模型和層接受兩種輸入格式
- 所有輸入作為關鍵字引數（如 PyTorch 模型），或
- 所有輸入作為第一個位置引數中的列表、元組或字典。
支援第二種格式的原因是，Keras 方法在將輸入傳遞給模型和層時更傾向於這種格式。由於這種支援，當使用像 model.fit() 這樣的方法時，一切都應該能“正常工作”——只需以 model.fit() 支援的任何格式傳遞你的輸入和標籤！然而，如果你想在像 fit() 和 predict() 這樣的 Keras 方法之外使用第二種格式，例如在使用 Keras 的 Functional 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 函式一樣傳遞輸入！
呼叫
< 原始檔 >( 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 (
np.ndarray或tf.Tensor，形狀為({0})，可選) — 用於避免在填充的標記索引上執行注意力計算的掩碼。掩碼值的選擇範圍為[0, 1]：- 1 表示標記未被掩碼，
- 0 表示標記已被掩碼。
- token_type_ids (
np.ndarray或tf.Tensor，形狀為({0})，可選) — 段標記索引，用於指示輸入的第一部分和第二部分。索引的選擇範圍為[0, 1]：- 0 對應於 *句子 A* 的標記，
- 1 對應於 *句子 B* 的標記。
- position_ids (
np.ndarray或tf.Tensor，形狀為({0})，可選) — 每個輸入序列標記在位置嵌入中的位置索引。選擇範圍為[0, config.max_position_embeddings - 1]。 - head_mask (
np.ndarray或tf.Tensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於置零自注意力模組中選定頭的掩碼。掩碼值的選擇範圍為[0, 1]：- 1 表示頭未被掩碼，
- 0 表示頭已被掩碼。
- inputs_embeds (
np.ndarray或tf.Tensor，形狀為({0}, hidden_size)，可選) — 可選地，你可以選擇直接傳遞嵌入表示，而不是傳遞input_values。如果你想比模型內部的嵌入查詢矩陣更好地控制如何將input_values索引轉換為相關向量，這將非常有用。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回的張量下的attentions。此引數只能在即時模式（eager mode）下使用，在圖模式（graph mode）下將使用配置中的值。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回的張量下的hidden_states。此引數只能在即時模式（eager mode）下使用，在圖模式（graph mode）下將使用配置中的值。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。此引數可在 Eager 模式下使用，在圖模式下該值將始終設定為 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 時），根據配置（HubertConfig）和輸入，包含各種元素。
-
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
TFHubertModel 的前向方法，重寫了 __call__ 特殊方法。
雖然前向傳播的流程需要在此函式中定義，但之後應呼叫 Module 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> from transformers import AutoProcessor, TFHubertModel
>>> from datasets import load_dataset
>>> import soundfile as sf
>>> processor = AutoProcessor.from_pretrained("facebook/hubert-large-ls960-ft")
>>> model = TFHubertModel.from_pretrained("facebook/hubert-large-ls960-ft")
>>> 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_stateTFHubertForCTC
class transformers.TFHubertForCTC
< 原始碼 >( config: HubertConfig *inputs **kwargs )
引數
- config (HubertConfig) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
TFHubert 模型頂部帶有一個用於連線時序分類（Connectionist Temporal Classification, CTC）的 `語言建模` 頭。
該模型繼承自 TFPreTrainedModel。查閱父類的文件以瞭解該庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪模型頭等）。
該模型也是一個 keras.Model 的子類。可以像使用常規 TF 2.0 Keras 模型一樣使用它，並參考 TF 2.0 文件瞭解所有與通用用法和行為相關的事項。
transformers 中的 TensorFlow 模型和層接受兩種輸入格式
- 所有輸入作為關鍵字引數（如 PyTorch 模型），或
- 所有輸入作為第一個位置引數中的列表、元組或字典。
支援第二種格式的原因是，Keras 方法在將輸入傳遞給模型和層時更傾向於這種格式。由於這種支援，當使用像 model.fit() 這樣的方法時，一切都應該能“正常工作”——只需以 model.fit() 支援的任何格式傳遞你的輸入和標籤！然而，如果你想在像 fit() 和 predict() 這樣的 Keras 方法之外使用第二種格式，例如在使用 Keras 的 Functional 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 函式一樣傳遞輸入！
呼叫
< 原始碼 >( 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 (
np.ndarray或tf.Tensor，形狀為({0}), 可選) — 用於避免對填充詞元索引執行注意力的掩碼。掩碼值選自[0, 1]：- 1 表示詞元未被掩碼，
- 0 表示詞元被掩碼。
- token_type_ids (
np.ndarray或tf.Tensor，形狀為({0}), 可選) — 段詞元索引，用於指示輸入的第一部分和第二部分。索引選自[0, 1]：- 0 對應於 *句子 A* 的詞元，
- 1 對應於 *句子 B* 的詞元。
- position_ids (
np.ndarray或tf.Tensor，形狀為({0}), 可選) — 位置嵌入中每個輸入序列詞元的位置索引。選自範圍[0, config.max_position_embeddings - 1]。 - head_mask (
np.ndarray或tf.Tensor，形狀為(num_heads,)或(num_layers, num_heads), 可選) — 用於使自注意力模組中選定的頭無效的掩碼。掩碼值選自[0, 1]：- 1 表示頭未被掩碼，
- 0 表示頭被掩碼。
- inputs_embeds (
np.ndarray或tf.Tensor，形狀為({0}, hidden_size), 可選) — 可選地，你可以選擇直接傳遞嵌入表示，而不是傳遞input_values。如果你想比模型內部的嵌入查詢矩陣更好地控制如何將input_values索引轉換為關聯向量，這將非常有用。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。此引數只能在 Eager 模式下使用，在圖模式下將使用配置中的值。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。此引數只能在 Eager 模式下使用，在圖模式下將使用配置中的值。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。此引數可在 Eager 模式下使用，在圖模式下該值將始終設定為 True。 - training (
bool, 可選, 預設為 `False`) — 是否將模型用於訓練模式（某些模組如 dropout 在訓練和評估之間有不同的行為）。 - labels (
tf.Tensor或np.ndarray，形狀為(batch_size, sequence_length), 可選) — 用於計算掩碼語言建模損失的標籤。索引應在[-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 時），根據配置（HubertConfig）和輸入，包含各種元素。
-
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
TFHubertForCTC 的前向方法，重寫了 __call__ 特殊方法。
雖然前向傳播的流程需要在此函式中定義，但之後應呼叫 Module 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> import tensorflow as tf
>>> from transformers import AutoProcessor, TFHubertForCTC
>>> from datasets import load_dataset
>>> import soundfile as sf
>>> processor = AutoProcessor.from_pretrained("facebook/hubert-large-ls960-ft")
>>> model = TFHubertForCTC.from_pretrained("facebook/hubert-large-ls960-ft")
>>> 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 the transcription as text to encode labels
>>> labels = processor(text=transcription, return_tensors="tf").input_values
>>> loss = model(input_values, labels=labels).loss