Hugging Face 的 LOGO

Transformers 文件

模型輸出

Hugging Face's logo
加入 Hugging Face 社群

並獲得增強的文件體驗

開始使用

模型輸出

所有模型輸出都是 ModelOutput 子類的例項。這些資料結構包含模型返回的所有資訊，但也可以用作元組或字典。

讓我們透過一個例子來看看這是什麼樣子

from transformers import BertTokenizer, BertForSequenceClassification
import torch

tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
model = BertForSequenceClassification.from_pretrained("google-bert/bert-base-uncased")

inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
labels = torch.tensor([1]).unsqueeze(0)  # Batch size 1
outputs = model(**inputs, labels=labels)

outputs 物件是 SequenceClassifierOutput 的一個例項，正如我們在下面該類的文件中看到的那樣，這意味著它有一個可選的 loss、一個 logits、一個可選的 hidden_states 和一個可選的 attentions 屬性。這裡我們有 loss，因為我們傳遞了 labels，但是我們沒有 hidden_states 和 attentions，因為我們沒有傳遞 output_hidden_states=True 或 output_attentions=True。

當傳遞 output_hidden_states=True 時，你可能會期望 outputs.hidden_states[-1] 與 outputs.last_hidden_state 完全匹配。然而，這並非總是如此。有些模型在返回最後的隱藏狀態時會對其應用歸一化或後續處理。

你可以像往常一樣訪問每個屬性，如果該屬性沒有被模型返回，你將得到 None。例如，這裡 outputs.loss 是模型計算的損失，而 outputs.attentions 是 None。

當將 outputs 物件視為元組時，它只考慮非 None 值的屬性。例如，這裡它有兩個元素，loss 然後是 logits，所以

outputs[:2]

將返回元組 (outputs.loss, outputs.logits)。

當將 outputs 物件視為字典時，它只考慮非 None 值的屬性。例如，這裡它有兩個鍵，分別是 loss 和 logits。

我們在此文件中說明了多個模型型別使用的通用模型輸出。特定輸出型別在各自的模型頁面上進行了說明。

ModelOutput

class transformers.utils.ModelOutput

< >

( *args **kwargs )

所有模型輸出的基類，作為資料類。具有一個 __getitem__ 方法，允許透過整數或切片（像元組一樣）或字串（像字典一樣）進行索引，這將忽略 None 屬性。否則，其行為類似於常規 Python 字典。

您不能直接解包 ModelOutput。請使用 to_tuple() 方法將其轉換為元組。

to_tuple

< >

( )

將自身轉換為包含所有非 None 屬性/鍵的元組。

BaseModelOutput

class transformers.modeling_outputs.BaseModelOutput

< >

( last_hidden_state: 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) — 模型最後一層輸出的隱藏狀態序列。
  • 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 後的注意力權重，用於計算自注意力頭中的加權平均。

模型輸出的基類，可能包含隱藏狀態和注意力。

BaseModelOutputWithPooling

class transformers.modeling_outputs.BaseModelOutputWithPooling

< >

( last_hidden_state: typing.Optional[torch.FloatTensor] = None pooler_output: 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) — 模型最後一層輸出的隱藏狀態序列。
  • pooler_output (形狀為 (batch_size, hidden_size) 的 torch.FloatTensor) — 經過用於輔助預訓練任務的層進一步處理後，序列中第一個 token（分類 token）的最後一層隱藏狀態。例如，對於 BERT 族模型，這會在經過線性層和 tanh 啟用函式處理後返回分類 token。線性層權重在預訓練期間根據下一句預測（分類）目標進行訓練。
  • 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 後的注意力權重，用於計算自注意力頭中的加權平均。

模型輸出的基類，也包含最後隱藏狀態的池化。

BaseModelOutputWithCrossAttentions

class transformers.modeling_outputs.BaseModelOutputWithCrossAttentions

< >

( last_hidden_state: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )

引數

  • last_hidden_state (形狀為 (batch_size, sequence_length, hidden_size) 的 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 後的注意力權重，用於計算自注意力頭中的加權平均。

  • cross_attentions (tuple(torch.FloatTensor), 可選，當傳遞 output_attentions=True 且 config.add_cross_attention=True 時返回，或當 config.output_attentions=True 時返回) — 形狀為 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元組（每層一個）。

    解碼器交叉注意力層在注意力 softmax 後的注意力權重，用於計算交叉注意力頭中的加權平均。

模型輸出的基類，可能包含隱藏狀態和注意力。

BaseModelOutputWithPoolingAndCrossAttentions

class transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions

< >

( last_hidden_state: typing.Optional[torch.FloatTensor] = None pooler_output: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )

引數

  • last_hidden_state (形狀為 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor) — 模型最後一層輸出的隱藏狀態序列。
  • pooler_output (形狀為 (batch_size, hidden_size) 的 torch.FloatTensor) — 經過用於輔助預訓練任務的層進一步處理後，序列中第一個 token（分類 token）的最後一層隱藏狀態。例如，對於 BERT 族模型，這會在經過線性層和 tanh 啟用函式處理後返回分類 token。線性層權重在預訓練期間根據下一句預測（分類）目標進行訓練。
  • 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 後的注意力權重，用於計算自注意力頭中的加權平均。

  • cross_attentions (tuple(torch.FloatTensor), 可選，當傳遞 output_attentions=True 且 config.add_cross_attention=True 時返回，或當 config.output_attentions=True 時返回) — 形狀為 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元組（每層一個）。

    解碼器交叉注意力層在注意力 softmax 後的注意力權重，用於計算交叉注意力頭中的加權平均。

  • past_key_values (Cache, 可選，當傳遞 use_cache=True 或 config.use_cache=True 時返回) — 這是一個 Cache 例項。更多詳情請參閱我們的 KV 快取指南。

    包含預先計算的隱藏狀態（自注意力塊中的鍵和值，如果 config.is_encoder_decoder=True，則可選地包含交叉注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。

模型輸出的基類，也包含最後隱藏狀態的池化。

BaseModelOutputWithPast

class transformers.modeling_outputs.BaseModelOutputWithPast

< >

( last_hidden_state: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = 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) — 模型最後一層輸出的隱藏狀態序列。

    如果使用 past_key_values，則只輸出形狀為 (batch_size, 1, hidden_size) 的序列的最後隱藏狀態。

  • past_key_values (Cache, 可選，當傳遞 use_cache=True 或 config.use_cache=True 時返回) — 這是一個 Cache 例項。更多詳情請參閱我們的 KV 快取指南。

    包含預先計算的隱藏狀態（自注意力塊中的鍵和值，如果 config.is_encoder_decoder=True，則可選地包含交叉注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。

  • 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 後的注意力權重，用於計算自注意力頭中的加權平均。

模型輸出的基類，也可能包含過去的鍵/值（以加速順序解碼）。

BaseModelOutputWithPastAndCrossAttentions

class transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions

< >

( last_hidden_state: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )

引數

  • last_hidden_state (形狀為 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor) — 模型最後一層輸出的隱藏狀態序列。

    如果使用 past_key_values，則只輸出形狀為 (batch_size, 1, hidden_size) 的序列的最後隱藏狀態。

  • past_key_values (Cache, 可選，當傳遞 use_cache=True 或 config.use_cache=True 時返回) — 這是一個 Cache 例項。更多詳情請參閱我們的 KV 快取指南。

    包含預先計算的隱藏狀態（自注意力塊中的鍵和值，如果 config.is_encoder_decoder=True，則可選地包含交叉注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。

  • hidden_states (tuple(torch.FloatTensor), 可選, 當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — torch.FloatTensor 的元組（如果模型有嵌入層，則包括嵌入層的輸出，加上每個層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    模型在每個層的輸出處的隱藏狀態，以及可選的初始嵌入輸出。

  • attentions (tuple(torch.FloatTensor), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均。

  • cross_attentions (tuple(torch.FloatTensor), 可選, 當傳入 output_attentions=True 和 config.add_cross_attention=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器交叉注意力層在注意力 softmax 後的注意力權重，用於計算交叉注意力頭中的加權平均。

模型輸出的基類，也可能包含過去的鍵/值（以加速順序解碼）。

Seq2SeqModelOutput

class transformers.modeling_outputs.Seq2SeqModelOutput

< >

( last_hidden_state: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[transformers.cache_utils.EncoderDecoderCache] = None decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )

引數

  • last_hidden_state (torch.FloatTensor，形狀為 (batch_size, sequence_length, hidden_size)) — 模型解碼器最後一層的隱藏狀態序列。

    如果使用了 past_key_values，則只輸出形狀為 (batch_size, 1, hidden_size) 的序列的最後一個隱藏狀態。

  • past_key_values (EncoderDecoderCache, 可選, 當傳入 use_cache=True 或 config.use_cache=True 時返回) — 這是一個 EncoderDecoderCache 例項。更多詳情請參閱我們的 kv cache 指南。

    包含預計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於（參閱 past_key_values 輸入）加速順序解碼。

  • decoder_hidden_states (tuple(torch.FloatTensor), 可選, 當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — torch.FloatTensor 的元組（如果模型有嵌入層，則包括嵌入層的輸出，加上每個層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    解碼器在每個層的輸出處的隱藏狀態，以及可選的初始嵌入輸出。

  • decoder_attentions (tuple(torch.FloatTensor), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器在注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均。

  • cross_attentions (tuple(torch.FloatTensor), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器交叉注意力層在注意力 softmax 後的注意力權重，用於計算交叉注意力頭中的加權平均。

  • encoder_last_hidden_state (torch.FloatTensor，形狀為 (batch_size, sequence_length, hidden_size), 可選) — 模型編碼器最後一層的隱藏狀態序列。
  • encoder_hidden_states (tuple(torch.FloatTensor), 可選, 當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — torch.FloatTensor 的元組（如果模型有嵌入層，則包括嵌入層的輸出，加上每個層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    編碼器在每個層的輸出處的隱藏狀態，以及可選的初始嵌入輸出。

  • encoder_attentions (tuple(torch.FloatTensor), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    編碼器在注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均。

模型編碼器輸出的基類，也包含：可加速順序解碼的預計算隱藏狀態。

CausalLMOutput

class transformers.modeling_outputs.CausalLMOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )

引數

  • loss (torch.FloatTensor，形狀為 (1,), 可選, 當提供 labels 時返回) — 語言模型損失（用於下一詞預測）。
  • logits (torch.FloatTensor，形狀為 (batch_size, sequence_length, config.vocab_size)) — 語言模型頭部的預測分數（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 後的注意力權重，用於計算自注意力頭中的加權平均。

因果語言模型（或自迴歸模型）輸出的基類。

CausalLMOutputWithCrossAttentions

class transformers.modeling_outputs.CausalLMOutputWithCrossAttentions

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )

引數

  • loss (torch.FloatTensor，形狀為 (1,), 可選, 當提供 labels 時返回) — 語言模型損失（用於下一詞預測）。
  • logits (torch.FloatTensor，形狀為 (batch_size, sequence_length, config.vocab_size)) — 語言模型頭部的預測分數（SoftMax 之前的每個詞彙標記的分數）。
  • hidden_states (tuple(torch.FloatTensor), 可選, 當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — torch.FloatTensor 的元組（如果模型有嵌入層，則包括嵌入層的輸出，加上每個層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    模型在每個層的輸出處的隱藏狀態，以及可選的初始嵌入輸出。

  • attentions (tuple(torch.FloatTensor), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均。

  • cross_attentions (tuple(torch.FloatTensor), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    交叉注意力 softmax 後的交叉注意力權重，用於計算交叉注意力頭中的加權平均。

  • past_key_values (Cache, 可選, 當傳入 use_cache=True 或 config.use_cache=True 時返回) — 這是一個 Cache 例項。更多詳情請參閱我們的 kv cache 指南。

    包含預計算的隱藏狀態（注意力塊中的鍵和值），可用於（參閱 past_key_values 輸入）加速順序解碼。

因果語言模型（或自迴歸模型）輸出的基類。

CausalLMOutputWithPast

class transformers.modeling_outputs.CausalLMOutputWithPast

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[transformers.cache_utils.Cache] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )

引數

  • loss (torch.FloatTensor，形狀為 (1,), 可選, 當提供 labels 時返回) — 語言模型損失（用於下一詞預測）。
  • logits (torch.FloatTensor，形狀為 (batch_size, sequence_length, config.vocab_size)) — 語言模型頭部的預測分數（SoftMax 之前的每個詞彙標記的分數）。
  • past_key_values (Cache, 可選, 當傳入 use_cache=True 或 config.use_cache=True 時返回) — 這是一個 Cache 例項。更多詳情請參閱我們的 kv cache 指南。

    包含預計算的隱藏狀態（自注意力塊中的鍵和值），可用於（參閱 past_key_values 輸入）加速順序解碼。

  • 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 後的注意力權重，用於計算自注意力頭中的加權平均。

因果語言模型（或自迴歸模型）輸出的基類。

MaskedLMOutput

class transformers.modeling_outputs.MaskedLMOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )

引數

  • loss (torch.FloatTensor，形狀為 (1,), 可選, 當提供 labels 時返回) — 掩碼語言模型 (MLM) 損失。
  • logits (torch.FloatTensor，形狀為 (batch_size, sequence_length, config.vocab_size)) — 語言模型頭部的預測分數（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 後的注意力權重，用於計算自注意力頭中的加權平均。

掩碼語言模型輸出的基類。

Seq2SeqLMOutput

class transformers.modeling_outputs.Seq2SeqLMOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[transformers.cache_utils.EncoderDecoderCache] = None decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )

引數

  • loss (torch.FloatTensor，形狀為 (1,), 可選, 當提供 labels 時返回) — 語言模型損失。
  • logits (torch.FloatTensor，形狀為 (batch_size, sequence_length, config.vocab_size)) — 語言模型頭部的預測分數（SoftMax 之前的每個詞彙標記的分數）。
  • past_key_values (EncoderDecoderCache, 可選, 當傳入 use_cache=True 或 config.use_cache=True 時返回) — 這是一個 EncoderDecoderCache 例項。更多詳情請參閱我們的 kv cache 指南。

    包含預計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於（參閱 past_key_values 輸入）加速順序解碼。

  • decoder_hidden_states (tuple(torch.FloatTensor), 可選, 當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — torch.FloatTensor 的元組（如果模型有嵌入層，則包括嵌入層的輸出，加上每個層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    解碼器在每個層的輸出處的隱藏狀態，以及初始嵌入輸出。

  • decoder_attentions (tuple(torch.FloatTensor), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器在注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均。

  • cross_attentions (tuple(torch.FloatTensor), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器交叉注意力層在注意力 softmax 後的注意力權重，用於計算交叉注意力頭中的加權平均。

  • encoder_last_hidden_state (torch.FloatTensor，形狀為 (batch_size, sequence_length, hidden_size), 可選) — 模型編碼器最後一層的隱藏狀態序列。
  • encoder_hidden_states (tuple(torch.FloatTensor), 可選, 當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — torch.FloatTensor 的元組（如果模型有嵌入層，則包括嵌入層的輸出，加上每個層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    編碼器在每個層的輸出處的隱藏狀態，以及初始嵌入輸出。

  • encoder_attentions (tuple(torch.FloatTensor), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    編碼器在注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均。

序列到序列語言模型輸出的基類。

NextSentencePredictorOutput

class transformers.modeling_outputs.NextSentencePredictorOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )

引數

  • loss (torch.FloatTensor，形狀為 (1,), 可選, 當提供 next_sentence_label 時返回) — 下一序列預測（分類）損失。
  • logits (torch.FloatTensor，形狀為(batch_size, 2)) — 下一個序列預測（分類）頭的預測分數（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之後的注意力權重，用於計算自注意力頭中的加權平均值。

預測兩個句子是否連續的模型輸出的基類。

SequenceClassifierOutput

class transformers.modeling_outputs.SequenceClassifierOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )

引數

  • loss (torch.FloatTensor，形狀為(1,)，可選，當提供labels時返回) — 分類（如果config.num_labels==1，則為迴歸）損失。
  • logits (torch.FloatTensor，形狀為(batch_size, config.num_labels)) — 分類（如果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之後的注意力權重，用於計算自注意力頭中的加權平均值。

句子分類模型輸出的基類。

Seq2SeqSequenceClassifierOutput

class transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[transformers.cache_utils.EncoderDecoderCache] = None decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )

引數

  • loss (torch.FloatTensor，形狀為(1,)，可選，當提供label時返回) — 分類（如果config.num_labels==1，則為迴歸）損失。
  • logits (torch.FloatTensor，形狀為(batch_size, config.num_labels)) — 分類（如果config.num_labels==1，則為迴歸）分數（SoftMax之前）。
  • past_key_values (EncoderDecoderCache, 可選，當傳入use_cache=True或config.use_cache=True時返回) — 這是一個 EncoderDecoderCache 例項。更多詳情，請參閱我們的 kv 快取指南。

    包含預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於（參見past_key_values輸入）加速順序解碼。

  • decoder_hidden_states (tuple(torch.FloatTensor), 可選，當傳入output_hidden_states=True或config.output_hidden_states=True時返回) — torch.FloatTensor 的元組（一個用於嵌入層（如果模型有嵌入層）的輸出，加上每個層的輸出）的形狀為(batch_size, sequence_length, hidden_size)。

    解碼器在每個層輸出處的隱藏狀態，以及初始嵌入輸出。

  • decoder_attentions (tuple(torch.FloatTensor), 可選，當傳入output_attentions=True或config.output_attentions=True時返回) — torch.FloatTensor 的元組（每層一個）的形狀為(batch_size, num_heads, sequence_length, sequence_length)。

    解碼器的注意力權重，在注意力softmax之後，用於計算自注意力頭中的加權平均值。

  • cross_attentions (tuple(torch.FloatTensor), 可選，當傳入output_attentions=True或config.output_attentions=True時返回) — torch.FloatTensor 的元組（每層一個）的形狀為(batch_size, num_heads, sequence_length, sequence_length)。

    解碼器交叉注意力層的注意力權重，在注意力softmax之後，用於計算交叉注意力頭中的加權平均值。

  • encoder_last_hidden_state (torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。
  • encoder_hidden_states (tuple(torch.FloatTensor), 可選，當傳入output_hidden_states=True或config.output_hidden_states=True時返回) — torch.FloatTensor 的元組（一個用於嵌入層（如果模型有嵌入層）的輸出，加上每個層的輸出）的形狀為(batch_size, sequence_length, hidden_size)。

    編碼器在每個層輸出處的隱藏狀態，以及初始嵌入輸出。

  • encoder_attentions (tuple(torch.FloatTensor), 可選，當傳入output_attentions=True或config.output_attentions=True時返回) — torch.FloatTensor 的元組（每層一個）的形狀為(batch_size, num_heads, sequence_length, sequence_length)。

    編碼器的注意力權重，在注意力softmax之後，用於計算自注意力頭中的加權平均值。

序列到序列句子分類模型輸出的基類。

MultipleChoiceModelOutput

class transformers.modeling_outputs.MultipleChoiceModelOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )

引數

  • loss (torch.FloatTensor，形狀為(1,)，可選，當提供labels時返回) — 分類損失。
  • logits (torch.FloatTensor，形狀為(batch_size, num_choices)) — num_choices 是輸入張量的第二個維度。（參見上面的input_ids）。

    分類分數（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之後的注意力權重，用於計算自注意力頭中的加權平均值。

多項選擇模型輸出的基類。

TokenClassifierOutput

class transformers.modeling_outputs.TokenClassifierOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )

引數

  • loss (torch.FloatTensor，形狀為(1,)，可選，當提供labels時返回) — 分類損失。
  • logits (torch.FloatTensor，形狀為(batch_size, sequence_length, config.num_labels)) — 分類分數（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之後的注意力權重，用於計算自注意力頭中的加權平均值。

Token分類模型輸出的基類。

QuestionAnsweringModelOutput

class transformers.modeling_outputs.QuestionAnsweringModelOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None start_logits: typing.Optional[torch.FloatTensor] = None end_logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )

引數

  • loss (torch.FloatTensor，形狀為(1,)，可選，當提供labels時返回) — 總跨度提取損失是起始位置和結束位置的交叉熵之和。
  • start_logits (torch.FloatTensor，形狀為(batch_size, sequence_length)) — 跨度起始分數（SoftMax之前）。
  • end_logits (torch.FloatTensor，形狀為(batch_size, sequence_length)) — 跨度結束分數（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之後的注意力權重，用於計算自注意力頭中的加權平均值。

問答模型輸出的基類。

Seq2SeqQuestionAnsweringModelOutput

class transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None start_logits: typing.Optional[torch.FloatTensor] = None end_logits: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[transformers.cache_utils.EncoderDecoderCache] = None decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )

引數

  • loss (torch.FloatTensor，形狀為(1,)，可選，當提供labels時返回) — 總跨度提取損失是起始位置和結束位置的交叉熵之和。
  • start_logits (torch.FloatTensor，形狀為(batch_size, sequence_length)) — 跨度起始分數（SoftMax之前）。
  • end_logits (torch.FloatTensor，形狀為(batch_size, sequence_length)) — 跨度結束分數（SoftMax之前）。
  • past_key_values (EncoderDecoderCache, 可選，當傳入use_cache=True或config.use_cache=True時返回) — 這是一個 EncoderDecoderCache 例項。更多詳情，請參閱我們的 kv 快取指南。

    包含預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於（參見past_key_values輸入）加速順序解碼。

  • decoder_hidden_states (tuple(torch.FloatTensor), 可選，當傳入output_hidden_states=True或config.output_hidden_states=True時返回) — torch.FloatTensor 的元組（一個用於嵌入層（如果模型有嵌入層）的輸出，加上每個層的輸出）的形狀為(batch_size, sequence_length, hidden_size)。

    解碼器在每個層輸出處的隱藏狀態，以及初始嵌入輸出。

  • decoder_attentions (tuple(torch.FloatTensor), 可選，當傳入output_attentions=True或config.output_attentions=True時返回) — torch.FloatTensor 的元組（每層一個）的形狀為(batch_size, num_heads, sequence_length, sequence_length)。

    解碼器的注意力權重，在注意力softmax之後，用於計算自注意力頭中的加權平均值。

  • cross_attentions (tuple(torch.FloatTensor), 可選，當傳入output_attentions=True或config.output_attentions=True時返回) — torch.FloatTensor 的元組（每層一個）的形狀為(batch_size, num_heads, sequence_length, sequence_length)。

    解碼器交叉注意力層的注意力權重，在注意力softmax之後，用於計算交叉注意力頭中的加權平均值。

  • encoder_last_hidden_state (torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。
  • encoder_hidden_states (tuple(torch.FloatTensor), 可選，當傳入output_hidden_states=True或config.output_hidden_states=True時返回) — torch.FloatTensor 的元組（一個用於嵌入層（如果模型有嵌入層）的輸出，加上每個層的輸出）的形狀為(batch_size, sequence_length, hidden_size)。

    編碼器在每個層輸出處的隱藏狀態，以及初始嵌入輸出。

  • encoder_attentions (tuple(torch.FloatTensor), 可選，當傳入output_attentions=True或config.output_attentions=True時返回) — torch.FloatTensor 的元組（每層一個）的形狀為(batch_size, num_heads, sequence_length, sequence_length)。

    編碼器的注意力權重，在注意力softmax之後，用於計算自注意力頭中的加權平均值。

序列到序列問答模型輸出的基類。

Seq2SeqSpectrogramOutput

class transformers.modeling_outputs.Seq2SeqSpectrogramOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None spectrogram: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[transformers.cache_utils.EncoderDecoderCache] = None decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )

引數

  • loss (torch.FloatTensor，形狀為 (1,)，可選，當提供 labels 時返回) — 頻譜圖生成損失。
  • spectrogram (torch.FloatTensor，形狀為 (batch_size, sequence_length, num_bins)) — 預測的頻譜圖。
  • past_key_values (EncoderDecoderCache，可選，當傳遞 use_cache=True 或 config.use_cache=True 時返回) — 這是一個 EncoderDecoderCache 例項。有關更多詳細資訊，請參閱我們的 kv 快取指南。

    包含預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。

  • decoder_hidden_states (tuple(torch.FloatTensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — torch.FloatTensor 的元組（如果模型有嵌入層，則為嵌入層輸出，加上每層輸出）形狀為 (batch_size, sequence_length, hidden_size)。

    解碼器在每層輸出處的隱藏狀態，以及初始嵌入輸出。

  • decoder_attentions (tuple(torch.FloatTensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每層一個）形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器在注意力 softmax 之後的注意力權重，用於計算自注意力頭中的加權平均值。

  • cross_attentions (tuple(torch.FloatTensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每層一個）形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器的交叉注意力層在注意力 softmax 之後的注意力權重，用於計算交叉注意力頭中的加權平均值。

  • encoder_last_hidden_state (torch.FloatTensor，形狀為 (batch_size, sequence_length, hidden_size)，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。
  • encoder_hidden_states (tuple(torch.FloatTensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — torch.FloatTensor 的元組（如果模型有嵌入層，則為嵌入層輸出，加上每層輸出）形狀為 (batch_size, sequence_length, hidden_size)。

    編碼器在每層輸出處的隱藏狀態，以及初始嵌入輸出。

  • encoder_attentions (tuple(torch.FloatTensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每層一個）形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    編碼器在注意力 softmax 之後的注意力權重，用於計算自注意力頭中的加權平均值。

序列到序列頻譜圖輸出的基類。

SemanticSegmenterOutput

class transformers.modeling_outputs.SemanticSegmenterOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )

引數

  • loss (torch.FloatTensor，形狀為 (1,)，可選，當提供 labels 時返回) — 分類（如果 config.num_labels==1 則為迴歸）損失。
  • logits (torch.FloatTensor，形狀為 (batch_size, config.num_labels, logits_height, logits_width)) — 每個畫素的分類分數。

    返回的 logits 不一定與輸入中的 pixel_values 具有相同的大小。這是為了避免在使用者需要將 logits 調整到原始影像大小時進行兩次插值並損失一些質量。您應始終檢查 logits 形狀並根據需要進行調整。
  • hidden_states (tuple(torch.FloatTensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — torch.FloatTensor 的元組（如果模型有嵌入層，則為嵌入層輸出，加上每層輸出）形狀為 (batch_size, patch_size, hidden_size)。

    模型在每層輸出處的隱藏狀態，以及可選的初始嵌入輸出。

  • attentions (tuple(torch.FloatTensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每層一個）形狀為 (batch_size, num_heads, patch_size, sequence_length)。

    注意力 softmax 之後的注意力權重，用於計算自注意力頭中的加權平均值。

語義分割模型的輸出基類。

ImageClassifierOutput

class transformers.modeling_outputs.ImageClassifierOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )

引數

  • loss (torch.FloatTensor，形狀為 (1,)，可選，當提供 labels 時返回) — 分類（如果 config.num_labels==1 則為迴歸）損失。
  • logits (torch.FloatTensor，形狀為 (batch_size, config.num_labels)) — 分類（如果 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, patch_size, sequence_length)。

    注意力 softmax 之後的注意力權重，用於計算自注意力頭中的加權平均值。

影像分類模型的輸出基類。

ImageClassifierOutputWithNoAttention

class transformers.modeling_outputs.ImageClassifierOutputWithNoAttention

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None )

引數

  • loss (torch.FloatTensor，形狀為 (1,)，可選，當提供 labels 時返回) — 分類（如果 config.num_labels==1 則為迴歸）損失。
  • logits (torch.FloatTensor，形狀為 (batch_size, config.num_labels)) — 分類（如果 config.num_labels==1 則為迴歸）分數（SoftMax 之前）。
  • hidden_states (tuple(torch.FloatTensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — torch.FloatTensor 的元組（如果模型有嵌入層，則為嵌入層輸出，加上每個階段的輸出）形狀為 (batch_size, num_channels, height, width)。模型在每個階段輸出處的隱藏狀態（也稱為特徵圖）。

影像分類模型的輸出基類。

DepthEstimatorOutput

class transformers.modeling_outputs.DepthEstimatorOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None predicted_depth: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )

引數

  • loss (torch.FloatTensor，形狀為 (1,)，可選，當提供 labels 時返回) — 分類（如果 config.num_labels==1 則為迴歸）損失。
  • predicted_depth (torch.FloatTensor，形狀為 (batch_size, height, width)) — 每個畫素的預測深度。
  • hidden_states (tuple(torch.FloatTensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — torch.FloatTensor 的元組（如果模型有嵌入層，則為嵌入層輸出，加上每層輸出）形狀為 (batch_size, num_channels, height, width)。

    模型在每層輸出處的隱藏狀態，以及可選的初始嵌入輸出。

  • attentions (tuple(torch.FloatTensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每層一個）形狀為 (batch_size, num_heads, patch_size, sequence_length)。

    注意力 softmax 之後的注意力權重，用於計算自注意力頭中的加權平均值。

深度估計模型的輸出基類。

Wav2Vec2BaseModelOutput

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 (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 之後的注意力權重，用於計算自注意力頭中的加權平均值。

使用 Wav2Vec2 損失目標進行訓練的模型的基類。

XVectorOutput

class transformers.modeling_outputs.XVectorOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None embeddings: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )

引數

  • loss (torch.FloatTensor，形狀為 (1,)，可選，當提供 labels 時返回) — 分類損失。
  • logits (torch.FloatTensor，形狀為 (batch_size, config.xvector_output_dim)) — AMSoftmax 之前的分類隱藏狀態。
  • embeddings (torch.FloatTensor，形狀為 (batch_size, config.xvector_output_dim)) — 用於基於向量相似性檢索的語音嵌入。
  • 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 的輸出型別。

Seq2SeqTSModelOutput

class transformers.modeling_outputs.Seq2SeqTSModelOutput

< >

( last_hidden_state: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[transformers.cache_utils.EncoderDecoderCache] = None decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None loc: typing.Optional[torch.FloatTensor] = None scale: typing.Optional[torch.FloatTensor] = None static_features: typing.Optional[torch.FloatTensor] = None )

引數

  • last_hidden_state (torch.FloatTensor，形狀為 (batch_size, sequence_length, hidden_size)) — 模型解碼器最後一層輸出的隱藏狀態序列。

    如果使用 past_key_values，則只輸出形狀為 (batch_size, 1, hidden_size) 的序列的最後隱藏狀態。

  • past_key_values (EncoderDecoderCache，可選，當傳遞 use_cache=True 或 config.use_cache=True 時返回) — 這是一個 EncoderDecoderCache 例項。有關更多詳細資訊，請參閱我們的 kv 快取指南。

    包含預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。

  • decoder_hidden_states (tuple(torch.FloatTensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — torch.FloatTensor 的元組（如果模型有嵌入層，則為嵌入層輸出，加上每層輸出）形狀為 (batch_size, sequence_length, hidden_size)。

    解碼器在每層輸出處的隱藏狀態，以及可選的初始嵌入輸出。

  • decoder_attentions (tuple(torch.FloatTensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每層一個）形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器在注意力 softmax 之後的注意力權重，用於計算自注意力頭中的加權平均值。

  • cross_attentions (tuple(torch.FloatTensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每層一個）形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器交叉注意力層在注意力 softmax 之後的注意力權重，用於計算交叉注意力頭中的加權平均值。

  • encoder_last_hidden_state (torch.FloatTensor，形狀為 (batch_size, sequence_length, hidden_size)，可選) — 模型編碼器最後一層的隱藏狀態序列。
  • encoder_hidden_states (tuple(torch.FloatTensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — torch.FloatTensor 的元組（如果模型有嵌入層，則為一個用於嵌入層輸出，加上一個用於每一層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    編碼器在每一層輸出的隱藏狀態，加上可選的初始嵌入輸出。

  • encoder_attentions (tuple(torch.FloatTensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每一層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    編碼器注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。

  • loc (torch.FloatTensor，形狀為 (batch_size,) 或 (batch_size, input_size)，可選) — 每個時間序列上下文視窗的偏移值，用於使模型輸入具有相同的大小，然後用於移回原始大小。
  • scale (torch.FloatTensor，形狀為 (batch_size,) 或 (batch_size, input_size)，可選) — 每個時間序列上下文視窗的縮放值，用於使模型輸入具有相同的大小，然後用於縮放回原始大小。
  • static_features (torch.FloatTensor，形狀為 (batch_size, feature size)，可選) — 批次中每個時間序列的靜態特徵，在推理時複製到協變數。

時間序列模型編碼器輸出的基類，也包含預計算的隱藏狀態，可以加快順序解碼。

Seq2SeqTSPredictionOutput

class transformers.modeling_outputs.Seq2SeqTSPredictionOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None params: typing.Optional[tuple[torch.FloatTensor]] = None past_key_values: typing.Optional[transformers.cache_utils.EncoderDecoderCache] = None decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None loc: typing.Optional[torch.FloatTensor] = None scale: typing.Optional[torch.FloatTensor] = None static_features: typing.Optional[torch.FloatTensor] = None )

引數

  • loss (torch.FloatTensor，形狀為 (1,)，可選，當提供 future_values 時返回) — 分佈損失。
  • params (torch.FloatTensor，形狀為 (batch_size, num_samples, num_params)) — 所選分佈的引數。
  • past_key_values (EncoderDecoderCache，可選，當傳遞 use_cache=True 或 config.use_cache=True 時返回) — 這是一個 EncoderDecoderCache 例項。更多詳情，請參閱我們的 kv cache 指南。

    包含預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於（參閱 past_key_values 輸入）加速順序解碼。

  • decoder_hidden_states (tuple(torch.FloatTensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — torch.FloatTensor 的元組（如果模型有嵌入層，則為一個用於嵌入層輸出，加上一個用於每一層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    解碼器在每一層輸出的隱藏狀態，加上初始嵌入輸出。

  • decoder_attentions (tuple(torch.FloatTensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每一層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。

  • cross_attentions (tuple(torch.FloatTensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每一層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。

  • encoder_last_hidden_state (torch.FloatTensor，形狀為 (batch_size, sequence_length, hidden_size)，可選) — 模型編碼器最後一層的隱藏狀態序列。
  • encoder_hidden_states (tuple(torch.FloatTensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — torch.FloatTensor 的元組（如果模型有嵌入層，則為一個用於嵌入層輸出，加上一個用於每一層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    編碼器在每一層輸出的隱藏狀態，加上初始嵌入輸出。

  • encoder_attentions (tuple(torch.FloatTensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — torch.FloatTensor 的元組（每一層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    編碼器注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。

  • loc (torch.FloatTensor，形狀為 (batch_size,) 或 (batch_size, input_size)，可選) — 每個時間序列上下文視窗的偏移值，用於使模型輸入具有相同的大小，然後用於移回原始大小。
  • scale (torch.FloatTensor，形狀為 (batch_size,) 或 (batch_size, input_size)，可選) — 每個時間序列上下文視窗的縮放值，用於使模型輸入具有相同的大小，然後用於縮放回原始大小。
  • static_features (torch.FloatTensor，形狀為 (batch_size, feature size)，可選) — 批次中每個時間序列的靜態特徵，在推理時複製到協變數。

時間序列模型解碼器輸出的基類，也包含損失以及所選分佈的引數。

SampleTSPredictionOutput

class transformers.modeling_outputs.SampleTSPredictionOutput

< >

( sequences: typing.Optional[torch.FloatTensor] = None )

引數

  • sequences (torch.FloatTensor，形狀為 (batch_size, num_samples, prediction_length) 或 (batch_size, num_samples, prediction_length, input_size)) — 從所選分佈中取樣的值。

時間序列模型預測輸出的基類，包含從所選分佈中取樣的值。

TFBaseModelOutput

class transformers.modeling_tf_outputs.TFBaseModelOutput

< >

( last_hidden_state: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor] | None = None attentions: tuple[tf.Tensor] | None = None )

引數

  • last_hidden_state (tf.Tensor，形狀為 (batch_size, sequence_length, hidden_size)) — 模型最後一層的隱藏狀態序列。
  • hidden_states (tuple(tf.FloatTensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 的元組（一個用於嵌入層輸出 + 一個用於每一層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    模型在每一層輸出的隱藏狀態，加上初始嵌入輸出。

  • attentions (tuple(tf.Tensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 的元組（每一層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    在注意力 softmax 之後的注意力權重，用於計算自注意力頭中的加權平均。

模型輸出的基類，可能包含隱藏狀態和注意力。

TFBaseModelOutputWithPooling

class transformers.modeling_tf_outputs.TFBaseModelOutputWithPooling

< >

( last_hidden_state: Optional[tf.Tensor] = None pooler_output: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor] | None = None attentions: tuple[tf.Tensor] | None = None )

引數

  • last_hidden_state (tf.Tensor，形狀為 (batch_size, sequence_length, hidden_size)) — 模型最後一層的隱藏狀態序列。
  • pooler_output (tf.Tensor，形狀為 (batch_size, hidden_size)) — 序列中第一個標記（分類標記）的最後一層隱藏狀態，經過線性層和 Tanh 啟用函式進一步處理。線性層權重在預訓練期間透過下一句預測（分類）目標進行訓練。

    此輸出通常不是輸入語義內容的良好摘要，通常透過對整個輸入序列的隱藏狀態序列進行平均或池化來獲得更好的結果。

  • hidden_states (tuple(tf.Tensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 的元組（一個用於嵌入層輸出 + 一個用於每一層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    模型在每一層輸出的隱藏狀態，加上初始嵌入輸出。

  • attentions (tuple(tf.Tensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 的元組（每一層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    在注意力 softmax 之後的注意力權重，用於計算自注意力頭中的加權平均。

模型輸出的基類，也包含最後隱藏狀態的池化。

TFBaseModelOutputWithPoolingAndCrossAttentions

class transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions

< >

( last_hidden_state: Optional[tf.Tensor] = None pooler_output: Optional[tf.Tensor] = None past_key_values: list[tf.Tensor] | None = None hidden_states: tuple[tf.Tensor] | None = None attentions: tuple[tf.Tensor] | None = None cross_attentions: tuple[tf.Tensor] | None = None )

引數

  • last_hidden_state (tf.Tensor，形狀為 (batch_size, sequence_length, hidden_size)) — 模型最後一層的隱藏狀態序列。
  • pooler_output (tf.Tensor，形狀為 (batch_size, hidden_size)) — 序列中第一個標記（分類標記）的最後一層隱藏狀態，經過線性層和 Tanh 啟用函式進一步處理。線性層權重在預訓練期間透過下一句預測（分類）目標進行訓練。

    此輸出通常不是輸入語義內容的良好摘要，通常透過對整個輸入序列的隱藏狀態序列進行平均或池化來獲得更好的結果。

  • past_key_values (list[tf.Tensor]，可選，當傳遞 use_cache=True 或 config.use_cache=True 時返回) — tf.Tensor 列表，長度為 config.n_layers，每個張量的形狀為 (2, batch_size, num_heads, sequence_length, embed_size_per_head)。

    包含預先計算的隱藏狀態（注意力塊中的鍵和值），可用於（參閱 past_key_values 輸入）加速順序解碼。

  • hidden_states (tuple(tf.Tensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 的元組（一個用於嵌入層輸出 + 一個用於每一層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    模型在每一層輸出的隱藏狀態，加上初始嵌入輸出。

  • attentions (tuple(tf.Tensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 的元組（每一層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    在注意力 softmax 之後的注意力權重，用於計算自注意力頭中的加權平均。

  • cross_attentions (tuple(tf.Tensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 的元組（每一層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。

模型輸出的基類，也包含最後隱藏狀態的池化。

TFBaseModelOutputWithPast

class transformers.modeling_tf_outputs.TFBaseModelOutputWithPast

< >

( last_hidden_state: Optional[tf.Tensor] = None past_key_values: list[tf.Tensor] | None = None hidden_states: tuple[tf.Tensor] | None = None attentions: tuple[tf.Tensor] | None = None )

引數

  • last_hidden_state (tf.Tensor，形狀為 (batch_size, sequence_length, hidden_size)) — 模型最後一層的隱藏狀態序列。

    如果使用 past_key_values，則僅輸出形狀為 (batch_size, 1, hidden_size) 的序列的最後隱藏狀態。

  • past_key_values (list[tf.Tensor]，可選，當傳遞 use_cache=True 或 config.use_cache=True 時返回) — tf.Tensor 列表，長度為 config.n_layers，每個張量的形狀為 (2, batch_size, num_heads, sequence_length, embed_size_per_head)。

    包含預先計算的隱藏狀態（注意力塊中的鍵和值），可用於（參閱 past_key_values 輸入）加速順序解碼。

  • hidden_states (tuple(tf.Tensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 的元組（一個用於嵌入層輸出 + 一個用於每一層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    模型在每一層輸出的隱藏狀態，加上初始嵌入輸出。

  • attentions (tuple(tf.Tensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 的元組（每一層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    在注意力 softmax 之後的注意力權重，用於計算自注意力頭中的加權平均。

模型輸出的基類，也可能包含過去的鍵/值（以加速順序解碼）。

TFBaseModelOutputWithPastAndCrossAttentions

class transformers.modeling_tf_outputs.TFBaseModelOutputWithPastAndCrossAttentions

< >

( last_hidden_state: Optional[tf.Tensor] = None past_key_values: list[tf.Tensor] | None = None hidden_states: tuple[tf.Tensor] | None = None attentions: tuple[tf.Tensor] | None = None cross_attentions: tuple[tf.Tensor] | None = None )

引數

  • last_hidden_state (tf.Tensor 形狀為 (batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。

    如果使用 past_key_values，則只輸出形狀為 (batch_size, 1, hidden_size) 的序列的最後一個隱藏狀態。

  • past_key_values (list[tf.Tensor]，可選，當傳遞 use_cache=True 或 config.use_cache=True 時返回) — 長度為 config.n_layers 的 tf.Tensor 列表，每個張量的形狀為 (2, batch_size, num_heads, sequence_length, embed_size_per_head))。

    包含預先計算的隱藏狀態（注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。

  • hidden_states (tuple(tf.FloatTensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 元組（一個用於嵌入輸出，一個用於每層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    模型每層輸出的隱藏狀態，以及初始嵌入輸出。

  • attentions (tuple(tf.Tensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。

  • cross_attentions (tuple(tf.Tensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器交叉注意力層在注意力 softmax 後的注意力權重，用於計算交叉注意力頭中的加權平均值。

模型輸出的基類，也可能包含過去的鍵/值（以加速順序解碼）。

TFSeq2SeqModelOutput

class transformers.modeling_tf_outputs.TFSeq2SeqModelOutput

< >

( last_hidden_state: Optional[tf.Tensor] = None past_key_values: list[tf.Tensor] | None = None decoder_hidden_states: tuple[tf.Tensor] | None = None decoder_attentions: tuple[tf.Tensor] | None = None cross_attentions: tuple[tf.Tensor] | None = None encoder_last_hidden_state: tf.Tensor | None = None encoder_hidden_states: tuple[tf.Tensor] | None = None encoder_attentions: tuple[tf.Tensor] | None = None )

引數

  • last_hidden_state (tf.Tensor 形狀為 (batch_size, sequence_length, hidden_size)) — 模型解碼器最後一層輸出的隱藏狀態序列。

    如果使用 past_key_values，則只輸出形狀為 (batch_size, 1, hidden_size) 的序列的最後一個隱藏狀態。

  • past_key_values (list[tf.Tensor]，可選，當傳遞 use_cache=True 或 config.use_cache=True 時返回) — 長度為 config.n_layers 的 tf.Tensor 列表，每個張量的形狀為 (2, batch_size, num_heads, sequence_length, embed_size_per_head))。

    包含預先計算的解碼器隱藏狀態（注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。

  • decoder_hidden_states (tuple(tf.Tensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 元組（一個用於嵌入輸出，一個用於每層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    解碼器每層輸出的隱藏狀態，以及初始嵌入輸出。

  • decoder_attentions (tuple(tf.Tensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器在注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。

  • cross_attentions (tuple(tf.Tensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器交叉注意力層在注意力 softmax 後的注意力權重，用於計算交叉注意力頭中的加權平均值。

  • encoder_last_hidden_state (tf.Tensor 形狀為 (batch_size, sequence_length, hidden_size)，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。
  • encoder_hidden_states (tuple(tf.Tensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 元組（一個用於嵌入輸出，一個用於每層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    編碼器每層輸出的隱藏狀態，以及初始嵌入輸出。

  • encoder_attentions (tuple(tf.Tensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    編碼器在注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。

模型編碼器輸出的基類，也包含：可加速順序解碼的預計算隱藏狀態。

TFCausalLMOutput

class transformers.modeling_tf_outputs.TFCausalLMOutput

< >

( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor] | None = None attentions: tuple[tf.Tensor] | None = None )

引數

  • loss (tf.Tensor 形狀為 (n,)，可選，其中 n 是非掩碼標籤的數量，當提供 labels 時返回) — 語言模型損失（用於下一個 token 預測）。
  • logits (tf.Tensor 形狀為 (batch_size, sequence_length, config.vocab_size)) — 語言模型頭的預測分數（SoftMax 之前每個詞彙 token 的分數）。
  • hidden_states (tuple(tf.Tensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 元組（一個用於嵌入輸出，一個用於每層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    模型每層輸出的隱藏狀態，以及初始嵌入輸出。

  • attentions (tuple(tf.Tensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。

因果語言模型（或自迴歸模型）輸出的基類。

TFCausalLMOutputWithCrossAttentions

class transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions

< >

( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None past_key_values: list[tf.Tensor] | None = None hidden_states: tuple[tf.Tensor] | None = None attentions: tuple[tf.Tensor] | None = None cross_attentions: tuple[tf.Tensor] | None = None )

引數

  • loss (tf.Tensor 形狀為 (n,)，可選，其中 n 是非掩碼標籤的數量，當提供 labels 時返回) — 語言模型損失（用於下一個 token 預測）。
  • logits (tf.Tensor 形狀為 (batch_size, sequence_length, config.vocab_size)) — 語言模型頭的預測分數（SoftMax 之前每個詞彙 token 的分數）。
  • hidden_states (tuple(tf.Tensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 元組（一個用於嵌入輸出，一個用於每層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    模型每層輸出的隱藏狀態，以及初始嵌入輸出。

  • attentions (tuple(tf.Tensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。

  • cross_attentions (tuple(tf.Tensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器交叉注意力層在注意力 softmax 後的注意力權重，用於計算交叉注意力頭中的加權平均值。

  • past_key_values (list[tf.Tensor]，可選，當傳遞 use_cache=True 或 config.use_cache=True 時返回) — 長度為 config.n_layers 的 tf.Tensor 列表，每個張量的形狀為 (2, batch_size, num_heads, sequence_length, embed_size_per_head))。

    包含預先計算的隱藏狀態（注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。

因果語言模型（或自迴歸模型）輸出的基類。

TFCausalLMOutputWithPast

class transformers.modeling_tf_outputs.TFCausalLMOutputWithPast

< >

( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None past_key_values: list[tf.Tensor] | None = None hidden_states: tuple[tf.Tensor] | None = None attentions: tuple[tf.Tensor] | None = None )

引數

  • loss (tf.Tensor 形狀為 (n,)，可選，其中 n 是非掩碼標籤的數量，當提供 labels 時返回) — 語言模型損失（用於下一個 token 預測）。
  • logits (tf.Tensor 形狀為 (batch_size, sequence_length, config.vocab_size)) — 語言模型頭的預測分數（SoftMax 之前每個詞彙 token 的分數）。
  • past_key_values (list[tf.Tensor]，可選，當傳遞 use_cache=True 或 config.use_cache=True 時返回) — 長度為 config.n_layers 的 tf.Tensor 列表，每個張量的形狀為 (2, batch_size, num_heads, sequence_length, embed_size_per_head))。

    包含預先計算的隱藏狀態（注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。

  • hidden_states (tuple(tf.Tensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 元組（一個用於嵌入輸出，一個用於每層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    模型每層輸出的隱藏狀態，以及初始嵌入輸出。

  • attentions (tuple(tf.Tensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。

因果語言模型（或自迴歸模型）輸出的基類。

TFMaskedLMOutput

class transformers.modeling_tf_outputs.TFMaskedLMOutput

< >

( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor] | None = None attentions: tuple[tf.Tensor] | None = None )

引數

  • loss (tf.Tensor 形狀為 (n,)，可選，其中 n 是非掩碼標籤的數量，當提供 labels 時返回) — 掩碼語言模型 (MLM) 損失。
  • logits (tf.Tensor 形狀為 (batch_size, sequence_length, config.vocab_size)) — 語言模型頭的預測分數（SoftMax 之前每個詞彙 token 的分數）。
  • hidden_states (tuple(tf.Tensor)，可選，當傳遞 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 元組（一個用於嵌入輸出，一個用於每層輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    模型每層輸出的隱藏狀態，以及初始嵌入輸出。

  • attentions (tuple(tf.Tensor)，可選，當傳遞 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。

掩碼語言模型輸出的基類。

TFSeq2SeqLMOutput

class transformers.modeling_tf_outputs.TFSeq2SeqLMOutput

< >

( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None past_key_values: list[tf.Tensor] | None = None decoder_hidden_states: tuple[tf.Tensor] | None = None decoder_attentions: tuple[tf.Tensor] | None = None cross_attentions: tuple[tf.Tensor] | None = None encoder_last_hidden_state: tf.Tensor | None = None encoder_hidden_states: tuple[tf.Tensor] | None = None encoder_attentions: tuple[tf.Tensor] | None = None )

引數

  • loss (tf.Tensor 形狀為 (n,)，可選，其中 n 是非掩碼標籤的數量，當提供 labels 時返回) — 語言模型損失。
  • logits (tf.Tensor 形狀為 (batch_size, sequence_length, config.vocab_size)) — 語言模型頭的預測分數（SoftMax 之前每個詞彙 token 的分數）。
  • past_key_values (list[tf.Tensor], 可選, 當傳入 use_cache=True 或 config.use_cache=True 時返回) — 長度為 config.n_layers 的 tf.Tensor 列表，每個張量的形狀為 (2, batch_size, num_heads, sequence_length, embed_size_per_head)）。

    包含解碼器預計算的隱藏狀態（注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速序列解碼。

  • decoder_hidden_states (tuple(tf.Tensor), 可選, 當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — 形狀為 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元組（一個用於嵌入層的輸出 + 每個層的輸出）。

    解碼器在每個層輸出的隱藏狀態，以及初始嵌入輸出。

  • decoder_attentions (tuple(tf.Tensor), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — 形狀為 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元組（每個層一個）。

    解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。

  • cross_attentions (tuple(tf.Tensor), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — 形狀為 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元組（每個層一個）。

    解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。

  • encoder_last_hidden_state (形狀為 (batch_size, sequence_length, hidden_size) 的 tf.Tensor, 可選) — 模型編碼器最後一層輸出的隱藏狀態序列。
  • encoder_hidden_states (tuple(tf.Tensor), 可選, 當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — 形狀為 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元組（一個用於嵌入層的輸出 + 每個層的輸出）。

    編碼器在每個層輸出的隱藏狀態，以及初始嵌入輸出。

  • encoder_attentions (tuple(tf.Tensor), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — 形狀為 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元組（每個層一個）。

    編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。

序列到序列語言模型輸出的基類。

TFNextSentencePredictorOutput

class transformers.modeling_tf_outputs.TFNextSentencePredictorOutput

< >

( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor] | None = None attentions: tuple[tf.Tensor] | None = None )

引數

  • loss (形狀為 (n,) 的 tf.Tensor, 可選, 當提供 next_sentence_label 時返回，其中 n 為未遮罩標籤的數量) — 下一句預測損失。
  • logits (形狀為 (batch_size, 2) 的 tf.Tensor) — 下一句預測（分類）頭的預測分數（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 之後的注意力權重，用於計算自注意力頭中的加權平均。

預測兩個句子是否連續的模型輸出的基類。

TFSequenceClassifierOutput

class transformers.modeling_tf_outputs.TFSequenceClassifierOutput

< >

( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor] | None = None attentions: tuple[tf.Tensor] | None = None )

引數

  • loss (形狀為 (batch_size,) 的 tf.Tensor, 可選, 當提供 labels 時返回) — 分類損失（如果 config.num_labels==1 則為迴歸損失）。
  • logits (形狀為 (batch_size, config.num_labels) 的 tf.Tensor) — 分類分數（SoftMax 之前）（如果 config.num_labels==1 則為迴歸分數）。
  • 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 之後的注意力權重，用於計算自注意力頭中的加權平均。

句子分類模型輸出的基類。

TFSeq2SeqSequenceClassifierOutput

class transformers.modeling_tf_outputs.TFSeq2SeqSequenceClassifierOutput

< >

( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None past_key_values: list[tf.Tensor] | None = None decoder_hidden_states: tuple[tf.Tensor] | None = None decoder_attentions: tuple[tf.Tensor] | None = None cross_attentions: tuple[tf.Tensor] | None = None encoder_last_hidden_state: tf.Tensor | None = None encoder_hidden_states: tuple[tf.Tensor] | None = None encoder_attentions: tuple[tf.Tensor] | None = None )

引數

  • loss (形狀為 (1,) 的 tf.Tensor, 可選, 當提供 label 時返回) — 分類損失（如果 config.num_labels==1 則為迴歸損失）。
  • logits (形狀為 (batch_size, config.num_labels) 的 tf.Tensor) — 分類分數（SoftMax 之前）（如果 config.num_labels==1 則為迴歸分數）。
  • past_key_values (list[tf.Tensor], 可選, 當傳入 use_cache=True 或 config.use_cache=True 時返回) — 長度為 config.n_layers 的 tf.Tensor 列表，每個張量的形狀為 (2, batch_size, num_heads, sequence_length, embed_size_per_head)）。

    包含解碼器預計算的隱藏狀態（注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速序列解碼。

  • decoder_hidden_states (tuple(tf.Tensor), 可選, 當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — 形狀為 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元組（一個用於嵌入層的輸出 + 每個層的輸出）。

    解碼器在每個層輸出的隱藏狀態，以及初始嵌入輸出。

  • decoder_attentions (tuple(tf.Tensor), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — 形狀為 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元組（每個層一個）。

    解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。

  • cross_attentions (tuple(tf.Tensor), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — 形狀為 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元組（每個層一個）。
  • encoder_last_hidden_state (形狀為 (batch_size, sequence_length, hidden_size) 的 tf.Tensor, 可選) — 模型編碼器最後一層輸出的隱藏狀態序列。
  • encoder_hidden_states (tuple(tf.Tensor), 可選, 當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — 形狀為 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元組（一個用於嵌入層的輸出 + 每個層的輸出）。

    編碼器在每個層輸出的隱藏狀態，以及初始嵌入輸出。

  • encoder_attentions (tuple(tf.Tensor), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — 形狀為 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元組（每個層一個）。

    編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。

序列到序列句子分類模型輸出的基類。

TFMultipleChoiceModelOutput

class transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput

< >

( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor] | None = None attentions: tuple[tf.Tensor] | None = None )

引數

  • loss (形狀為 (batch_size,) 的 tf.Tensor, 可選, 當提供 labels 時返回) — 分類損失。
  • logits (形狀為 (batch_size, num_choices) 的 tf.Tensor) — num_choices 是輸入張量的第二個維度。（參見上面的 input_ids）。

    分類分數（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 之後的注意力權重，用於計算自注意力頭中的加權平均。

多項選擇模型輸出的基類。

TFTokenClassifierOutput

class transformers.modeling_tf_outputs.TFTokenClassifierOutput

< >

( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor] | None = None attentions: tuple[tf.Tensor] | None = None )

引數

  • loss (形狀為 (n,) 的 tf.Tensor, 可選, 當提供 labels 時返回，其中 n 為未遮罩標籤的數量) — 分類損失。
  • logits (形狀為 (batch_size, sequence_length, config.num_labels) 的 tf.Tensor) — 分類分數（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 之後的注意力權重，用於計算自注意力頭中的加權平均。

Token分類模型輸出的基類。

TFQuestionAnsweringModelOutput

class transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput

< >

( loss: tf.Tensor | None = None start_logits: Optional[tf.Tensor] = None end_logits: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor] | None = None attentions: tuple[tf.Tensor] | None = None )

引數

  • loss (形狀為 (batch_size,) 的 tf.Tensor, 可選, 當提供 start_positions 和 end_positions 時返回) — 總跨度提取損失是起始和結束位置的交叉熵之和。
  • start_logits (形狀為 (batch_size, sequence_length) 的 tf.Tensor) — 跨度起始分數（SoftMax 之前）。
  • end_logits (形狀為 (batch_size, sequence_length) 的 tf.Tensor) — 跨度結束分數（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 之後的注意力權重，用於計算自注意力頭中的加權平均。

問答模型輸出的基類。

TFSeq2SeqQuestionAnsweringModelOutput

class transformers.modeling_tf_outputs.TFSeq2SeqQuestionAnsweringModelOutput

< >

( loss: tf.Tensor | None = None start_logits: Optional[tf.Tensor] = None end_logits: Optional[tf.Tensor] = None past_key_values: list[tf.Tensor] | None = None decoder_hidden_states: tuple[tf.Tensor] | None = None decoder_attentions: tuple[tf.Tensor] | None = None encoder_last_hidden_state: tf.Tensor | None = None encoder_hidden_states: tuple[tf.Tensor] | None = None encoder_attentions: tuple[tf.Tensor] | None = None )

引數

  • loss (tf.Tensor of shape (1,), 可選, 當提供 labels 時返回) — 總的 span 提取損失，是開始位置和結束位置的交叉熵之和。
  • start_logits (tf.Tensor of shape (batch_size, sequence_length)) — Span 開始分數 (SoftMax 之前)。
  • end_logits (tf.Tensor of shape (batch_size, sequence_length)) — Span 結束分數 (SoftMax 之前)。
  • past_key_values (list[tf.Tensor], 可選, 當傳入 use_cache=True 或 config.use_cache=True 時返回) — 長度為 config.n_layers 的 tf.Tensor 列表，每個張量形狀為 (2, batch_size, num_heads, sequence_length, embed_size_per_head))。

    包含預先計算的解碼器隱藏狀態 (注意力塊中的鍵和值)，可用於加速順序解碼 (參見 past_key_values 輸入)。

  • decoder_hidden_states (tuple(tf.Tensor), 可選, 當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 的元組 (一個用於嵌入輸出 + 一個用於每個層的輸出)，形狀為 (batch_size, sequence_length, hidden_size)。

    解碼器在每個層輸出的隱藏狀態，以及初始嵌入輸出。

  • decoder_attentions (tuple(tf.Tensor), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 的元組 (每個層一個)，形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均值。

  • encoder_last_hidden_state (tf.Tensor of shape (batch_size, sequence_length, hidden_size), 可選) — 模型編碼器最後一層的隱藏狀態序列。
  • encoder_hidden_states (tuple(tf.Tensor), 可選, 當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — tf.Tensor 的元組 (一個用於嵌入輸出 + 一個用於每個層的輸出)，形狀為 (batch_size, sequence_length, hidden_size)。

    編碼器在每個層輸出的隱藏狀態，以及初始嵌入輸出。

  • encoder_attentions (tuple(tf.Tensor), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — tf.Tensor 的元組 (每個層一個)，形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均值。

序列到序列問答模型輸出的基類。

FlaxBaseModelOutput

class transformers.modeling_flax_outputs.FlaxBaseModelOutput

< >

( last_hidden_state: typing.Optional[jax.Array] = None hidden_states: typing.Optional[tuple[jax.Array]] = None attentions: typing.Optional[tuple[jax.Array]] = None )

引數

  • last_hidden_state (jnp.ndarray of shape (batch_size, sequence_length, hidden_size)) — 模型最後一層的隱藏狀態序列。
  • 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 之後的注意力權重，用於計算自注意力頭中的加權平均值。

模型輸出的基類，可能包含隱藏狀態和注意力。

替換

< >

( **updates )

“返回一個新物件，用新值替換指定欄位。

FlaxBaseModelOutputWithPast

class transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPast

< >

( last_hidden_state: typing.Optional[jax.Array] = None past_key_values: typing.Optional[dict[str, jax.Array]] = None hidden_states: typing.Optional[tuple[jax.Array]] = None attentions: typing.Optional[tuple[jax.Array]] = None )

引數

  • last_hidden_state (jnp.ndarray of shape (batch_size, sequence_length, hidden_size)) — 模型最後一層的隱藏狀態序列。
  • past_key_values (dict[str, jnp.ndarray]) — 預先計算的隱藏狀態（注意力塊中的鍵和值）字典，可用於快速自迴歸解碼。預先計算的鍵和值隱藏狀態的形狀為 *[batch_size, max_length]*。
  • 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 之後的注意力權重，用於計算自注意力頭中的加權平均值。

模型輸出的基類，可能包含隱藏狀態和注意力。

替換

< >

( **updates )

“返回一個新物件，用新值替換指定欄位。

FlaxBaseModelOutputWithPooling

class transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling

< >

( last_hidden_state: typing.Optional[jax.Array] = None pooler_output: typing.Optional[jax.Array] = None hidden_states: typing.Optional[tuple[jax.Array]] = None attentions: typing.Optional[tuple[jax.Array]] = None )

引數

  • last_hidden_state (jnp.ndarray of shape (batch_size, sequence_length, hidden_size)) — 模型最後一層的隱藏狀態序列。
  • pooler_output (jnp.ndarray of shape (batch_size, hidden_size)) — 序列第一個 token (分類 token) 的最後一層隱藏狀態，經過線性層和 Tanh 啟用函式進一步處理。線性層權重在預訓練期間透過下一個句子預測 (分類) 目標進行訓練。
  • 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 之後的注意力權重，用於計算自注意力頭中的加權平均值。

模型輸出的基類，也包含最後隱藏狀態的池化。

替換

< >

( **updates )

“返回一個新物件，用新值替換指定欄位。

FlaxBaseModelOutputWithPastAndCrossAttentions

class transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions

< >

( last_hidden_state: typing.Optional[jax.Array] = None past_key_values: typing.Optional[tuple[tuple[jax.Array]]] = None hidden_states: typing.Optional[tuple[jax.Array]] = None attentions: typing.Optional[tuple[jax.Array]] = None cross_attentions: typing.Optional[tuple[jax.Array]] = None )

引數

  • last_hidden_state (jnp.ndarray of shape (batch_size, sequence_length, hidden_size)) — 模型解碼器最後一層的隱藏狀態序列。

    如果使用了 past_key_values，則只輸出形狀為 (batch_size, 1, hidden_size) 的序列的最後一個隱藏狀態。

  • past_key_values (tuple(tuple(jnp.ndarray)), 可選, 當傳入 use_cache=True 或 config.use_cache=True 時返回) — 長度為 config.n_layers 的 tuple(jnp.ndarray) 元組，每個元組包含 2 個形狀為 (batch_size, num_heads, sequence_length, embed_size_per_head) 的張量，如果 config.is_encoder_decoder=True 則可選地包含 2 個形狀為 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的額外張量。

    包含預先計算的隱藏狀態 (自注意力塊中的鍵和值，如果 config.is_encoder_decoder=True 則可選地包含交叉注意力塊中的鍵和值)，可用於加速順序解碼 (參見 past_key_values 輸入)。

  • 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 之後的注意力權重，用於計算自注意力頭中的加權平均值。

  • cross_attentions (tuple(jnp.ndarray), 可選, 當傳入 output_attentions=True 和 config.add_cross_attention=True 或 config.output_attentions=True 時返回) — jnp.ndarray 的元組 (每個層一個)，形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均值。

模型輸出的基類，也可能包含過去的鍵/值（以加速順序解碼）。

替換

< >

( **updates )

“返回一個新物件，用新值替換指定欄位。

FlaxSeq2SeqModelOutput

class transformers.modeling_flax_outputs.FlaxSeq2SeqModelOutput

< >

( last_hidden_state: typing.Optional[jax.Array] = None past_key_values: typing.Optional[tuple[tuple[jax.Array]]] = None decoder_hidden_states: typing.Optional[tuple[jax.Array]] = None decoder_attentions: typing.Optional[tuple[jax.Array]] = None cross_attentions: typing.Optional[tuple[jax.Array]] = None encoder_last_hidden_state: typing.Optional[jax.Array] = None encoder_hidden_states: typing.Optional[tuple[jax.Array]] = None encoder_attentions: typing.Optional[tuple[jax.Array]] = None )

引數

  • last_hidden_state (jnp.ndarray of shape (batch_size, sequence_length, hidden_size)) — 模型解碼器最後一層的隱藏狀態序列。

    如果使用了 past_key_values，則只輸出形狀為 (batch_size, 1, hidden_size) 的序列的最後一個隱藏狀態。

  • past_key_values (tuple(tuple(jnp.ndarray)), 可選, 當傳入 use_cache=True 或 config.use_cache=True 時返回) — 長度為 config.n_layers 的 tuple(jnp.ndarray) 元組，每個元組包含 2 個形狀為 (batch_size, num_heads, sequence_length, embed_size_per_head) 的張量，以及 2 個形狀為 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的額外張量。

    包含預先計算的隱藏狀態 (自注意力塊和交叉注意力塊中的鍵和值)，可用於加速順序解碼 (參見 past_key_values 輸入)。

  • decoder_hidden_states (tuple(jnp.ndarray), 可選, 當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — jnp.ndarray 的元組 (一個用於嵌入輸出 + 一個用於每個層的輸出)，形狀為 (batch_size, sequence_length, hidden_size)。

    解碼器在每個層輸出的隱藏狀態，以及初始嵌入輸出。

  • decoder_attentions (tuple(jnp.ndarray), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — jnp.ndarray 的元組 (每個層一個)，形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均值。

  • cross_attentions (tuple(jnp.ndarray), optional, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — jnp.ndarray 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器交叉注意力層在注意力 softmax 之後的注意力權重，用於計算交叉注意力頭中的加權平均值。

  • encoder_last_hidden_state (形狀為 (batch_size, sequence_length, hidden_size) 的 jnp.ndarray，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。
  • encoder_hidden_states (tuple(jnp.ndarray), 可選, 當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — jnp.ndarray 的元組（一個用於嵌入輸出，每個層一個用於輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    編碼器在每個層輸出的隱藏狀態加上初始嵌入輸出。

  • encoder_attentions (tuple(jnp.ndarray), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — jnp.ndarray 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    編碼器在注意力 softmax 之後的注意力權重，用於計算自注意力頭中的加權平均值。

模型編碼器輸出的基類，也包含：可加速順序解碼的預計算隱藏狀態。

替換

< >

( **updates )

“返回一個新物件，用新值替換指定欄位。

FlaxCausalLMOutputWithCrossAttentions

class transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions

< >

( logits: typing.Optional[jax.Array] = None past_key_values: typing.Optional[tuple[tuple[jax.Array]]] = None hidden_states: typing.Optional[tuple[jax.Array]] = None attentions: typing.Optional[tuple[jax.Array]] = None cross_attentions: typing.Optional[tuple[jax.Array]] = None )

引數

  • logits (形狀為 (batch_size, sequence_length, config.vocab_size) 的 jnp.ndarray) — 語言建模頭的預測分數（SoftMax 之前的每個詞彙標記的分數）。
  • hidden_states (tuple(jnp.ndarray), 可選, 當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — jnp.ndarray 的元組（一個用於嵌入輸出，每個層一個用於輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    模型在每個層輸出的隱藏狀態加上初始嵌入輸出。

  • attentions (tuple(jnp.ndarray), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — jnp.ndarray 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 之後的注意力權重，用於計算自注意力頭中的加權平均值。

  • cross_attentions (tuple(jnp.ndarray), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — jnp.ndarray 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    交叉注意力 softmax 之後的注意力權重，用於計算交叉注意力頭中的加權平均值。

  • past_key_values (tuple(tuple(jnp.ndarray)), 可選, 當傳入 use_cache=True 或 config.use_cache=True 時返回) — 長度為 config.n_layers 的 jnp.ndarray 元組的元組，每個元組包含自注意力和交叉注意力層的快取鍵值狀態（如果模型用於編碼器-解碼器設定）。僅當 config.is_decoder = True 時相關。

    包含預先計算的隱藏狀態（注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。

因果語言模型（或自迴歸模型）輸出的基類。

替換

< >

( **updates )

“返回一個新物件，用新值替換指定欄位。

FlaxMaskedLMOutput

class transformers.modeling_flax_outputs.FlaxMaskedLMOutput

< >

( logits: typing.Optional[jax.Array] = None hidden_states: typing.Optional[tuple[jax.Array]] = None attentions: typing.Optional[tuple[jax.Array]] = None )

引數

  • logits (形狀為 (batch_size, sequence_length, config.vocab_size) 的 jnp.ndarray) — 語言建模頭的預測分數（SoftMax 之前的每個詞彙標記的分數）。
  • hidden_states (tuple(jnp.ndarray), 可選, 當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — jnp.ndarray 的元組（一個用於嵌入輸出，每個層一個用於輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    模型在每個層輸出的隱藏狀態加上初始嵌入輸出。

  • attentions (tuple(jnp.ndarray), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — jnp.ndarray 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 之後的注意力權重，用於計算自注意力頭中的加權平均值。

掩碼語言模型輸出的基類。

替換

< >

( **updates )

“返回一個新物件，用新值替換指定欄位。

FlaxSeq2SeqLMOutput

class transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput

< >

( logits: typing.Optional[jax.Array] = None past_key_values: typing.Optional[tuple[tuple[jax.Array]]] = None decoder_hidden_states: typing.Optional[tuple[jax.Array]] = None decoder_attentions: typing.Optional[tuple[jax.Array]] = None cross_attentions: typing.Optional[tuple[jax.Array]] = None encoder_last_hidden_state: typing.Optional[jax.Array] = None encoder_hidden_states: typing.Optional[tuple[jax.Array]] = None encoder_attentions: typing.Optional[tuple[jax.Array]] = None )

引數

  • logits (形狀為 (batch_size, sequence_length, config.vocab_size) 的 jnp.ndarray) — 語言建模頭的預測分數（SoftMax 之前的每個詞彙標記的分數）。
  • past_key_values (tuple(tuple(jnp.ndarray)), 可選, 當傳入 use_cache=True 或 config.use_cache=True 時返回) — 長度為 config.n_layers 的 tuple(jnp.ndarray) 的元組，每個元組包含 2 個形狀為 (batch_size, num_heads, sequence_length, embed_size_per_head) 的張量和 2 個額外的形狀為 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的張量。

    包含預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。

  • decoder_hidden_states (tuple(jnp.ndarray), 可選, 當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — jnp.ndarray 的元組（一個用於嵌入輸出，每個層一個用於輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    解碼器在每個層輸出的隱藏狀態加上初始嵌入輸出。

  • decoder_attentions (tuple(jnp.ndarray), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — jnp.ndarray 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器在注意力 softmax 之後的注意力權重，用於計算自注意力頭中的加權平均值。

  • cross_attentions (tuple(jnp.ndarray), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — jnp.ndarray 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器交叉注意力層在注意力 softmax 之後的注意力權重，用於計算交叉注意力頭中的加權平均值。

  • encoder_last_hidden_state (形狀為 (batch_size, sequence_length, hidden_size) 的 jnp.ndarray，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。
  • encoder_hidden_states (tuple(jnp.ndarray), 可選, 當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — jnp.ndarray 的元組（一個用於嵌入輸出，每個層一個用於輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    編碼器在每個層輸出的隱藏狀態加上初始嵌入輸出。

  • encoder_attentions (tuple(jnp.ndarray), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — jnp.ndarray 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    編碼器在注意力 softmax 之後的注意力權重，用於計算自注意力頭中的加權平均值。

序列到序列語言模型輸出的基類。

替換

< >

( **updates )

“返回一個新物件，用新值替換指定欄位。

FlaxNextSentencePredictorOutput

class transformers.modeling_flax_outputs.FlaxNextSentencePredictorOutput

< >

( logits: typing.Optional[jax.Array] = None hidden_states: typing.Optional[tuple[jax.Array]] = None attentions: typing.Optional[tuple[jax.Array]] = None )

引數

  • logits (形狀為 (batch_size, 2) 的 jnp.ndarray) — 下一個序列預測（分類）頭的預測分數（SoftMax 之前的 True/False 延續分數）。
  • 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 之後的注意力權重，用於計算自注意力頭中的加權平均值。

預測兩個句子是否連續的模型輸出的基類。

替換

< >

( **updates )

“返回一個新物件，用新值替換指定欄位。

FlaxSequenceClassifierOutput

class transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput

< >

( logits: typing.Optional[jax.Array] = None hidden_states: typing.Optional[tuple[jax.Array]] = None attentions: typing.Optional[tuple[jax.Array]] = None )

引數

  • logits (形狀為 (batch_size, config.num_labels) 的 jnp.ndarray) — 分類（如果 config.num_labels==1 則為迴歸）分數（SoftMax 之前）。
  • hidden_states (tuple(jnp.ndarray), 可選, 當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — jnp.ndarray 的元組（一個用於嵌入輸出，每個層一個用於輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    模型在每個層輸出的隱藏狀態加上初始嵌入輸出。

  • attentions (tuple(jnp.ndarray), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — jnp.ndarray 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力 softmax 之後的注意力權重，用於計算自注意力頭中的加權平均值。

句子分類模型輸出的基類。

替換

< >

( **updates )

“返回一個新物件，用新值替換指定欄位。

FlaxSeq2SeqSequenceClassifierOutput

class transformers.modeling_flax_outputs.FlaxSeq2SeqSequenceClassifierOutput

< >

( logits: typing.Optional[jax.Array] = None past_key_values: typing.Optional[tuple[tuple[jax.Array]]] = None decoder_hidden_states: typing.Optional[tuple[jax.Array]] = None decoder_attentions: typing.Optional[tuple[jax.Array]] = None cross_attentions: typing.Optional[tuple[jax.Array]] = None encoder_last_hidden_state: typing.Optional[jax.Array] = None encoder_hidden_states: typing.Optional[tuple[jax.Array]] = None encoder_attentions: typing.Optional[tuple[jax.Array]] = None )

引數

  • logits (形狀為 (batch_size, config.num_labels) 的 jnp.ndarray) — 分類（如果 config.num_labels==1 則為迴歸）分數（SoftMax 之前）。
  • past_key_values (tuple(tuple(jnp.ndarray)), 可選, 當傳入 use_cache=True 或 config.use_cache=True 時返回) — 長度為 config.n_layers 的 tuple(jnp.ndarray) 的元組，每個元組包含 2 個形狀為 (batch_size, num_heads, sequence_length, embed_size_per_head) 的張量和 2 個額外的形狀為 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的張量。

    包含預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速順序解碼。

  • decoder_hidden_states (tuple(jnp.ndarray), 可選, 當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — jnp.ndarray 的元組（一個用於嵌入輸出，每個層一個用於輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    解碼器在每個層輸出的隱藏狀態加上初始嵌入輸出。

  • decoder_attentions (tuple(jnp.ndarray), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — jnp.ndarray 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器在注意力 softmax 之後的注意力權重，用於計算自注意力頭中的加權平均值。

  • cross_attentions (tuple(jnp.ndarray), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — jnp.ndarray 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器交叉注意力層在注意力 softmax 之後的注意力權重，用於計算交叉注意力頭中的加權平均值。

  • encoder_last_hidden_state (形狀為 (batch_size, sequence_length, hidden_size) 的 jnp.ndarray，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。
  • encoder_hidden_states (tuple(jnp.ndarray), 可選, 當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — jnp.ndarray 的元組（一個用於嵌入輸出，每個層一個用於輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    編碼器在每個層輸出的隱藏狀態加上初始嵌入輸出。

  • encoder_attentions (tuple(jnp.ndarray), 可選, 當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — jnp.ndarray 的元組（每層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    編碼器在注意力 softmax 之後的注意力權重，用於計算自注意力頭中的加權平均值。

序列到序列句子分類模型輸出的基類。

替換

< >

( **updates )

“返回一個新物件，用新值替換指定欄位。

FlaxMultipleChoiceModelOutput

class transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput

< >

( logits: typing.Optional[jax.Array] = None hidden_states: typing.Optional[tuple[jax.Array]] = None attentions: typing.Optional[tuple[jax.Array]] = None )

引數

  • logits (jnp.ndarray，形狀為 (batch_size, num_choices)) — num_choices 是輸入張量的第二個維度。(參見上面的 input_ids)。

    分類得分（SoftMax之前）。

  • hidden_states (tuple(jnp.ndarray)，可選，當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — jnp.ndarray 的元組（一個用於嵌入輸出，一個用於每個層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    模型在每個層輸出的隱藏狀態，加上初始嵌入輸出。

  • attentions (tuple(jnp.ndarray)，可選，當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — jnp.ndarray 的元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    在注意力 Softmax 之後，用於計算自注意力頭中加權平均的注意力權重。

多項選擇模型輸出的基類。

替換

< >

( **updates )

“返回一個新物件，用新值替換指定欄位。

FlaxTokenClassifierOutput

class transformers.modeling_flax_outputs.FlaxTokenClassifierOutput

< >

( logits: typing.Optional[jax.Array] = None hidden_states: typing.Optional[tuple[jax.Array]] = None attentions: typing.Optional[tuple[jax.Array]] = None )

引數

  • logits (jnp.ndarray，形狀為 (batch_size, sequence_length, config.num_labels)) — 分類得分（SoftMax之前）。
  • hidden_states (tuple(jnp.ndarray)，可選，當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — jnp.ndarray 的元組（一個用於嵌入輸出，一個用於每個層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    模型在每個層輸出的隱藏狀態，加上初始嵌入輸出。

  • attentions (tuple(jnp.ndarray)，可選，當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — jnp.ndarray 的元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    在注意力 Softmax 之後，用於計算自注意力頭中加權平均的注意力權重。

Token分類模型輸出的基類。

替換

< >

( **updates )

“返回一個新物件，用新值替換指定欄位。

FlaxQuestionAnsweringModelOutput

class transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput

< >

( start_logits: typing.Optional[jax.Array] = None end_logits: typing.Optional[jax.Array] = None hidden_states: typing.Optional[tuple[jax.Array]] = None attentions: typing.Optional[tuple[jax.Array]] = None )

引數

  • start_logits (jnp.ndarray，形狀為 (batch_size, sequence_length)) — 跨度起始分數（SoftMax之前）。
  • end_logits (jnp.ndarray，形狀為 (batch_size, sequence_length)) — 跨度結束分數（SoftMax之前）。
  • hidden_states (tuple(jnp.ndarray)，可選，當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — jnp.ndarray 的元組（一個用於嵌入輸出，一個用於每個層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    模型在每個層輸出的隱藏狀態，加上初始嵌入輸出。

  • attentions (tuple(jnp.ndarray)，可選，當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — jnp.ndarray 的元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    在注意力 Softmax 之後，用於計算自注意力頭中加權平均的注意力權重。

問答模型輸出的基類。

替換

< >

( **updates )

“返回一個新物件，用新值替換指定欄位。

FlaxSeq2SeqQuestionAnsweringModelOutput

class transformers.modeling_flax_outputs.FlaxSeq2SeqQuestionAnsweringModelOutput

< >

( start_logits: typing.Optional[jax.Array] = None end_logits: typing.Optional[jax.Array] = None past_key_values: typing.Optional[tuple[tuple[jax.Array]]] = None decoder_hidden_states: typing.Optional[tuple[jax.Array]] = None decoder_attentions: typing.Optional[tuple[jax.Array]] = None cross_attentions: typing.Optional[tuple[jax.Array]] = None encoder_last_hidden_state: typing.Optional[jax.Array] = None encoder_hidden_states: typing.Optional[tuple[jax.Array]] = None encoder_attentions: typing.Optional[tuple[jax.Array]] = None )

引數

  • start_logits (jnp.ndarray，形狀為 (batch_size, sequence_length)) — 跨度起始分數（SoftMax之前）。
  • end_logits (jnp.ndarray，形狀為 (batch_size, sequence_length)) — 跨度結束分數（SoftMax之前）。
  • past_key_values (tuple(tuple(jnp.ndarray))，可選，當傳入 use_cache=True 或 config.use_cache=True 時返回) — tuple(jnp.ndarray) 的元組，長度為 config.n_layers，每個元組包含2個形狀為 (batch_size, num_heads, sequence_length, embed_size_per_head) 的張量和2個額外的形狀為 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的張量。

    包含預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於（參見 past_key_values 輸入）加速序列解碼。

  • decoder_hidden_states (tuple(jnp.ndarray)，可選，當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — jnp.ndarray 的元組（一個用於嵌入輸出，一個用於每個層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    解碼器在每個層輸出的隱藏狀態，加上初始嵌入輸出。

  • decoder_attentions (tuple(jnp.ndarray)，可選，當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — jnp.ndarray 的元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器交叉注意力層在注意力 Softmax 之後，用於計算交叉注意力頭中加權平均的注意力權重。

  • cross_attentions (tuple(jnp.ndarray)，可選，當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — jnp.ndarray 的元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    解碼器交叉注意力層在注意力 Softmax 之後，用於計算交叉注意力頭中加權平均的注意力權重。

  • encoder_last_hidden_state (jnp.ndarray，形狀為 (batch_size, sequence_length, hidden_size)，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。
  • encoder_hidden_states (tuple(jnp.ndarray)，可選，當傳入 output_hidden_states=True 或 config.output_hidden_states=True 時返回) — jnp.ndarray 的元組（一個用於嵌入輸出，一個用於每個層的輸出），形狀為 (batch_size, sequence_length, hidden_size)。

    編碼器在每個層輸出的隱藏狀態，加上初始嵌入輸出。

  • encoder_attentions (tuple(jnp.ndarray)，可選，當傳入 output_attentions=True 或 config.output_attentions=True 時返回) — jnp.ndarray 的元組（每個層一個），形狀為 (batch_size, num_heads, sequence_length, sequence_length)。

    編碼器注意力 Softmax 之後，用於計算自注意力頭中加權平均的注意力權重。

序列到序列問答模型輸出的基類。

替換

< >

( **updates )

“返回一個新物件，用新值替換指定欄位。

< > 在 GitHub 上更新

←Optimization PEFT→
© . This site is unofficial and not affiliated with Hugging Face, Inc.