Transformers 文件
LED
並獲得增強的文件體驗
開始使用
LED
概述
LED 模型由 Iz Beltagy、Matthew E. Peters 和 Arman Cohan 在論文 Longformer: The Long-Document Transformer 中提出。
論文摘要如下：
基於 Transformer 的模型由於其自注意力操作（其計算複雜度與序列長度成二次方關係）而無法處理長序列。為了解決這個限制，我們引入了 Longformer，其注意力機制與序列長度呈線性關係，使其能夠輕鬆處理數千個甚至更長的 token 的文件。Longformer 的注意力機制是標準自注意力的直接替代品，並結合了局部視窗注意力和任務驅動的全域性注意力。我們遵循先前關於長序列 Transformer 的工作，在字元級語言建模上評估 Longformer，並在 text8 和 enwik8 上取得了最先進的結果。與大多數先前工作不同，我們還預訓練了 Longformer，並在各種下游任務上進行了微調。我們的預訓練 Longformer 在長文件任務上持續優於 RoBERTa，並在 WikiHop 和 TriviaQA 上創下了新的最先進結果。最後，我們引入了 Longformer-Encoder-Decoder (LED)，這是 Longformer 的一個變體，用於支援長文件生成式序列到序列任務，並在 arXiv 摘要資料集上展示了其有效性。
使用技巧
- LEDForConditionalGeneration 是 BartForConditionalGeneration 的擴充套件，它將傳統的*自注意力*層替換為*Longformer*的*分塊自注意力*層。LEDTokenizer 是 BartTokenizer 的別名。
- LED 在長距離*序列到序列*任務上表現非常出色，其中 `input_ids` 的長度遠超 1024 個 token。
- 如果需要，LED 會將 `input_ids` 填充為 `config.attention_window` 的倍數。因此，當使用帶有 `pad_to_multiple_of` 引數的 LEDTokenizer 時，可以獲得輕微的速度提升。
- LED 利用 `global_attention_mask`（參見 LongformerModel）來實現*全域性注意力*。對於摘要任務，建議僅在第一個 `<s>` token 上設定*全域性注意力*。對於問答任務，建議在問題的所有 token 上設定*全域性注意力*。
- 要在所有 16384 個 token 上微調 LED，如果訓練導致記憶體不足 (OOM) 錯誤，可以啟用*梯度檢查點*。這可以透過執行 `model.gradient_checkpointing_enable()` 來完成。此外，可以使用 `use_cache=False` 標誌來停用快取機制以節省記憶體。
- LED 是一個具有絕對位置嵌入的模型，因此通常建議在右側而不是左側填充輸入。
此模型由 patrickvonplaten 貢獻。
資源
LEDConfig
class transformers.LEDConfig
< 來源 >( vocab_size = 50265 max_encoder_position_embeddings = 16384 max_decoder_position_embeddings = 1024 encoder_layers = 12 encoder_ffn_dim = 4096 encoder_attention_heads = 16 decoder_layers = 12 decoder_ffn_dim = 4096 decoder_attention_heads = 16 encoder_layerdrop = 0.0 decoder_layerdrop = 0.0 use_cache = True is_encoder_decoder = True activation_function = 'gelu' d_model = 1024 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 decoder_start_token_id = 2 classifier_dropout = 0.0 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 attention_window: typing.Union[list[int], int] = 512 **kwargs )
引數
- vocab_size (
int, 可選, 預設為 50265) — LED 模型的詞彙表大小。定義了在呼叫 LEDModel 或 TFLEDModel 時，`inputs_ids` 可以表示的不同 token 的數量。 - d_model (
int, 可選, 預設為 1024) — 各層和池化層的維度。 - encoder_layers (
int, 可選, 預設為 12) — 編碼器的層數。 - decoder_layers (
int, 可選, 預設為 12) — 解碼器的層數。 - encoder_attention_heads (
int, 可選, 預設為 16) — Transformer 編碼器中每個注意力層的注意力頭數。 - decoder_attention_heads (
int, 可選, 預設為 16) — Transformer 解碼器中每個注意力層的注意力頭數。 - decoder_ffn_dim (
int, 可選, 預設為 4096) — 解碼器中“中間”層（通常稱為前饋層）的維度。 - encoder_ffn_dim (
int, 可選, 預設為 4096) — 解碼器中“中間”層（通常稱為前饋層）的維度。 - activation_function (
str或function, 可選, 預設為"gelu") — 編碼器和池化層中的非線性啟用函式（函式或字串）。如果為字串，支援 `"gelu"`、`"relu"`、`"silu"` 和 `"gelu_new"`。 - dropout (
float, 可選, 預設為 0.1) — 嵌入層、編碼器和池化層中所有全連線層的 dropout 機率。 - attention_dropout (
float, 可選, 預設為 0.0) — 注意力機率的 dropout 比例。 - activation_dropout (
float, 可選, 預設為 0.0) — 全連線層內部啟用函式的 dropout 比例。 - classifier_dropout (
float, 可選, 預設為 0.0) — 分類器的 dropout 比例。 - max_encoder_position_embeddings (
int, 可選, 預設為 16384) — 編碼器可能使用的最大序列長度。 - max_decoder_position_embeddings (
int, 可選, 預設為 16384) — 解碼器可能使用的最大序列長度。 - init_std (
float, 可選, 預設為 0.02) — 用於初始化所有權重矩陣的 truncated_normal_initializer 的標準差。 - encoder_layerdrop (
float, 可選, 預設為 0.0) — 編碼器的 LayerDrop 機率。更多細節請參見 [LayerDrop 論文](參見 https://huggingface.co/papers/1909.11556)。 - decoder_layerdrop (
float, 可選, 預設為 0.0) — 解碼器的 LayerDrop 機率。更多細節請參見 [LayerDrop 論文](參見 https://huggingface.co/papers/1909.11556)。 - use_cache (
bool, 可選, 預設為True) — 模型是否應返回最後一個鍵/值注意力（並非所有模型都使用）。
這是用於儲存 LEDModel 配置的配置類。它用於根據指定的引數例項化一個 LED 模型，定義模型架構。使用預設值例項化配置將產生與 LED allenai/led-base-16384 架構類似的配置。
配置物件繼承自 PretrainedConfig，可用於控制模型輸出。更多資訊請閱讀 PretrainedConfig 的文件。
示例
>>> from transformers import LEDModel, LEDConfig
>>> # Initializing a LED allenai/led-base-16384 style configuration
>>> configuration = LEDConfig()
>>> # Initializing a model from the allenai/led-base-16384 style configuration
>>> model = LEDModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configLEDTokenizer
class transformers.LEDTokenizer
< source >( vocab_file merges_file errors = 'replace' bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' add_prefix_space = False **kwargs )
引數
- vocab_file (
str) — 詞彙表文件的路徑。 - merges_file (
str) — 合併檔案的路徑。 - errors (
str, optional, 預設為"replace") — 將位元組解碼為 UTF-8 時遵循的正規化。更多資訊請參閱 bytes.decode。 - bos_token (
str, optional, 預設為"<s>") — 預訓練期間使用的序列開始標記。可用作序列分類器標記。當使用特殊標記構建序列時，這不是用於序列開始的標記。使用的標記是
cls_token。 - eos_token (
str, optional, 預設為"</s>") — 序列結束標記。當使用特殊標記構建序列時，這不是用於序列結束的標記。使用的標記是
sep_token。 - sep_token (
str, optional, 預設為"</s>") — 分隔符標記，用於從多個序列構建一個序列時，例如用於序列分類的兩個序列，或用於問答的文字和問題。它也用作使用特殊標記構建的序列的最後一個標記。 - cls_token (
str, optional, 預設為"<s>") — 分類器標記，用於進行序列分類（對整個序列進行分類，而不是對每個標記進行分類）。當使用特殊標記構建序列時，它是序列的第一個標記。 - unk_token (
str, optional, 預設為"<unk>") — 未知標記。不在詞彙表中的標記無法轉換為 ID，將被設定為此標記。 - pad_token (
str, optional, 預設為"<pad>") — 用於填充的標記，例如在批處理不同長度的序列時使用。 - mask_token (
str, optional, 預設為"<mask>") — 用於掩蓋值的標記。這是在使用掩碼語言建模訓練此模型時使用的標記。這是模型將嘗試預測的標記。 - add_prefix_space (
bool, optional, 預設為False) — 是否在輸入前新增一個初始空格。這允許將開頭的詞與任何其他詞一樣處理。（BART 分詞器透過前面的空格來檢測詞的開始）。
構建一個 LED 分詞器，它與 RoBERTa 分詞器類似，使用位元組級位元組對編碼（Byte-Pair-Encoding）。
這個分詞器經過訓練，將空格視為詞元的一部分（有點像 sentencepiece），所以一個詞會
無論是否在句子開頭（無空格），編碼方式都會不同
>>> from transformers import LEDTokenizer
>>> tokenizer = LEDTokenizer.from_pretrained("allenai/led-base-16384")
>>> tokenizer("Hello world")["input_ids"]
[0, 31414, 232, 2]
>>> tokenizer(" Hello world")["input_ids"]
[0, 20920, 232, 2]您可以透過在例項化此分詞器時或在對某些文字呼叫它時傳遞 add_prefix_space=True 來繞過此行為，但由於模型並非以這種方式進行預訓練，這可能會導致效能下降。
當與 is_split_into_words=True 一起使用時，此分詞器會在每個詞（甚至是第一個詞）之前新增一個空格。
該分詞器繼承自 PreTrainedTokenizer，其中包含了大部分主要方法。使用者應參考此超類以獲取有關這些方法的更多資訊。
build_inputs_with_special_tokens
< source >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
透過連線和新增特殊標記，從一個序列或一對序列中為序列分類任務構建模型輸入。LED 序列的格式如下：
- 單個序列：
<s> X </s> - 序列對：
<s> A </s></s> B </s>
get_special_tokens_mask
< source >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None already_has_special_tokens: bool = False ) → list[int]
從沒有新增特殊標記的標記列表中檢索序列ID。此方法在使用分詞器prepare_for_model方法新增特殊標記時呼叫。
create_token_type_ids_from_sequences
< source >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
從傳入的兩個序列建立一個掩碼，用於序列對分類任務。LED 不使用標記型別 ID，因此返回一個零列表。
LEDTokenizerFast
class transformers.LEDTokenizerFast
< source >( vocab_file = None merges_file = None tokenizer_file = None errors = 'replace' bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' add_prefix_space = False trim_offsets = True **kwargs )
引數
- vocab_file (
str) — 詞彙表文件的路徑。 - merges_file (
str) — 合併檔案的路徑。 - errors (
str, optional, 預設為"replace") — 將位元組解碼為 UTF-8 時遵循的正規化。更多資訊請參閱 bytes.decode。 - bos_token (
str, optional, 預設為"<s>") — 預訓練期間使用的序列開始標記。可用作序列分類器標記。當使用特殊標記構建序列時，這不是用於序列開始的標記。使用的標記是
cls_token。 - eos_token (
str, optional, 預設為"</s>") — 序列結束標記。當使用特殊標記構建序列時，這不是用於序列結束的標記。使用的標記是
sep_token。 - sep_token (
str, optional, 預設為"</s>") — 分隔符標記，用於從多個序列構建一個序列時，例如用於序列分類的兩個序列，或用於問答的文字和問題。它也用作使用特殊標記構建的序列的最後一個標記。 - cls_token (
str, optional, 預設為"<s>") — 分類器標記，用於進行序列分類（對整個序列進行分類，而不是對每個標記進行分類）。當使用特殊標記構建序列時，它是序列的第一個標記。 - unk_token (
str, optional, 預設為"<unk>") — 未知標記。不在詞彙表中的標記無法轉換為 ID，將被設定為此標記。 - pad_token (
str, optional, 預設為"<pad>") — 用於填充的標記，例如在批處理不同長度的序列時使用。 - mask_token (
str, optional, 預設為"<mask>") — 用於掩蓋值的標記。這是在使用掩碼語言建模訓練此模型時使用的標記。這是模型將嘗試預測的標記。 - add_prefix_space (
bool, optional, 預設為False) — 是否在輸入前新增一個初始空格。這允許將開頭的詞與任何其他詞一樣處理。（LED 分詞器透過前面的空格來檢測詞的開始）。 - trim_offsets (
bool, optional, 預設為True) — 後處理步驟是否應修剪偏移量以避免包含空白字元。
構建一個“快速”的 LED 分詞器（由 HuggingFace 的 *tokenizers* 庫支援），該分詞器源自 GPT-2 分詞器，使用位元組級位元組對編碼（Byte-Pair-Encoding）。
這個分詞器經過訓練，將空格視為詞元的一部分（有點像 sentencepiece），所以一個詞會
無論是否在句子開頭（無空格），編碼方式都會不同
>>> from transformers import LEDTokenizerFast
>>> tokenizer = LEDTokenizerFast.from_pretrained("allenai/led-base-16384")
>>> tokenizer("Hello world")["input_ids"]
[0, 31414, 232, 2]
>>> tokenizer(" Hello world")["input_ids"]
[0, 20920, 232, 2]您可以透過在例項化此分詞器時或在對某些文字呼叫它時傳遞 add_prefix_space=True 來繞過此行為，但由於模型並非以這種方式進行預訓練，這可能會導致效能下降。
當與 is_split_into_words=True 一起使用時，此分詞器需要以 add_prefix_space=True 進行例項化。
該分詞器繼承自 PreTrainedTokenizerFast，其中包含了大部分主要方法。使用者應參考此超類以獲取有關這些方法的更多資訊。
create_token_type_ids_from_sequences
< source >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
從傳入的兩個序列建立一個掩碼，用於序列對分類任務。LED 不使用標記型別 ID，因此返回一個零列表。
LED 特定輸出
class transformers.models.led.modeling_led.LEDEncoderBaseModelOutput
< source >( last_hidden_state: FloatTensor hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None global_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
引數
- last_hidden_state (
<class 'torch.FloatTensor'>.last_hidden_stateof shape(batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。 - hidden_states (
tuple[torch.FloatTensor, ...], optional, 當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（一個用於嵌入層的輸出，如果模型有嵌入層，+ 一個用於每層的輸出），形狀為(batch_size, sequence_length, hidden_size)。模型在每層輸出處的隱藏狀態以及可選的初始嵌入輸出。
- attentions (
tuple(torch.FloatTensor), optional, 當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是具有全域性注意力掩碼的標記數量。經過注意力 softmax 後的區域性注意力權重，用於計算自注意力頭中的加權平均值。這些是序列中每個標記對每個具有全域性注意力的標記（前
x個值）以及注意力視窗中每個標記（剩餘 `attention_window- 1
個值）的注意力權重。請注意，前x個值指的是文字中位置固定的標記，而剩餘的attention_window + 1個值指的是相對位置的標記：一個標記對其自身的注意力權重位於索引x + attention_window / 2處，而attention_window / 2個前（後）的值是其對attention_window / 2個前（後）標記的注意力權重。如果注意力視窗包含一個具有全域性注意力的標記，則相應索引處的注意力權重設定為 0；該值應從前x` 個注意力權重中訪問。如果一個標記具有全域性注意力，則其對所有其他標記的注意力權重在 `attentions` 中設定為 0，該值應從 `global_attentions` 中訪問。
- 1
- global_attentions (
tuple(torch.FloatTensor), optional, 當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, x)，其中x是具有全域性注意力掩碼的標記數量。經過注意力 softmax 後的全域性注意力權重，用於計算自注意力頭中的加權平均值。這些是每個具有全域性注意力的標記對序列中每個標記的注意力權重。
LEDEncoder 輸出的基類，包含潛在的隱藏狀態、區域性和全域性注意力。
class transformers.models.led.modeling_led.LEDSeq2SeqModelOutput
< source >( last_hidden_state: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[list[torch.FloatTensor]] = 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 encoder_global_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
引數
- last_hidden_state (
torch.FloatTensorof shape(batch_size, sequence_length, hidden_size)) — 模型解碼器最後一層輸出的隱藏狀態序列。如果使用
past_key_values，則只輸出形狀為(batch_size, 1, hidden_size)的序列的最後一個隱藏狀態。 - past_key_values (
list[torch.FloatTensor], optional, 當傳遞use_cache=True或config.use_cache=True時返回) — 長度為config.n_layers的torch.FloatTensor列表，每個張量的形狀為(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含解碼器預先計算的隱藏狀態（注意力塊中的鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 - decoder_hidden_states (
tuple[torch.FloatTensor, ...], optional, 當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（一個用於嵌入層的輸出，如果模型有嵌入層，+ 一個用於每層的輸出），形狀為(batch_size, sequence_length, hidden_size)。解碼器在每層輸出處的隱藏狀態以及初始嵌入輸出。
- decoder_attentions (
tuple[torch.FloatTensor, ...], optional, 當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均值。
- cross_attentions (
tuple[torch.FloatTensor, ...]，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器交叉注意力層的注意力權重（在注意力 softmax 之後），用於計算交叉注意力頭中的加權平均值。
- encoder_last_hidden_state (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選，預設為None) — 模型編碼器最後一層輸出的隱藏狀態序列。 - 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 之後），用於計算自注意力頭中的加權平均值。
- encoder_global_attentions (
tuple(torch.FloatTensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, x)，其中x是具有全域性注意力掩碼的詞元數量。全域性注意力權重（在注意力 softmax 之後），用於計算自注意力頭中的加權平均值。這些是從每個具有全域性注意力的詞元到序列中每個詞元的注意力權重。
模型編碼器輸出的基類，也包含：可加速順序解碼的預計算隱藏狀態。
class transformers.models.led.modeling_led.LEDSeq2SeqLMOutput
< 來源 >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[list[torch.FloatTensor]] = 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 encoder_global_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 (
list[torch.FloatTensor]，可選，當傳遞use_cache=True或config.use_cache=True時返回) — 長度為config.n_layers的torch.FloatTensor列表，每個張量的形狀為(2, batch_size, num_heads, sequence_length, embed_size_per_head)。包含預先計算的解碼器隱藏狀態（注意力塊中的鍵和值），可用於（參見
past_key_values輸入）加速序列解碼。 - decoder_hidden_states (
tuple[torch.FloatTensor, ...]，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（一個是嵌入層的輸出，如果模型有嵌入層，+ 每個層的輸出），形狀為(batch_size, sequence_length, hidden_size)。解碼器在每層輸出的隱藏狀態以及初始嵌入輸出。
- decoder_attentions (
tuple[torch.FloatTensor, ...]，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器的注意力權重（在注意力 softmax 之後），用於計算自注意力頭中的加權平均值。
- 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)，可選，預設為None) — 模型編碼器最後一層輸出的隱藏狀態序列。 - 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 之後），用於計算自注意力頭中的加權平均值。
- encoder_global_attentions (
tuple(torch.FloatTensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, x)，其中x是具有全域性注意力掩碼的詞元數量。全域性注意力權重（在注意力 softmax 之後），用於計算自注意力頭中的加權平均值。這些是從每個具有全域性注意力的詞元到序列中每個詞元的注意力權重。
序列到序列語言模型輸出的基類。
class transformers.models.led.modeling_led.LEDSeq2SeqSequenceClassifierOutput
< 來源 >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[list[torch.FloatTensor]] = 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 encoder_global_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 (
list[torch.FloatTensor]，可選，當傳遞use_cache=True或config.use_cache=True時返回) — 長度為config.n_layers的torch.FloatTensor列表，每個張量的形狀為(2, batch_size, num_heads, sequence_length, embed_size_per_head)。包含預先計算的解碼器隱藏狀態（注意力塊中的鍵和值），可用於（參見
past_key_values輸入）加速序列解碼。 - decoder_hidden_states (
tuple[torch.FloatTensor, ...]，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（一個是嵌入層的輸出，如果模型有嵌入層，+ 每個層的輸出），形狀為(batch_size, sequence_length, hidden_size)。解碼器在每層輸出的隱藏狀態以及初始嵌入輸出。
- decoder_attentions (
tuple[torch.FloatTensor, ...]，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器的注意力權重（在注意力 softmax 之後），用於計算自注意力頭中的加權平均值。
- 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)，可選，預設為None) — 模型編碼器最後一層輸出的隱藏狀態序列。 - 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 之後），用於計算自注意力頭中的加權平均值。
- encoder_global_attentions (
tuple(torch.FloatTensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, x)，其中x是具有全域性注意力掩碼的詞元數量。全域性注意力權重（在注意力 softmax 之後），用於計算自注意力頭中的加權平均值。這些是從每個具有全域性注意力的詞元到序列中每個詞元的注意力權重。
序列到序列句子分類模型輸出的基類。
class transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput
< 來源 >( 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[list[torch.FloatTensor]] = 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 encoder_global_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
引數
- loss (
torch.FloatTensor，形狀為(1,)，可選，當提供labels時返回) — 總的片段提取損失是起始和結束位置交叉熵損失的和。 - start_logits (
torch.FloatTensor，形狀為(batch_size, sequence_length)，可選，預設為None) — 片段起始分數（SoftMax 前）。 - end_logits (
torch.FloatTensor，形狀為(batch_size, sequence_length)，可選，預設為None) — 片段結束分數（SoftMax 前）。 - past_key_values (
list[torch.FloatTensor]，可選，當傳遞use_cache=True或config.use_cache=True時返回) — 長度為config.n_layers的torch.FloatTensor列表，每個張量的形狀為(2, batch_size, num_heads, sequence_length, embed_size_per_head)。包含預先計算的解碼器隱藏狀態（注意力塊中的鍵和值），可用於（參見
past_key_values輸入）加速序列解碼。 - decoder_hidden_states (
tuple[torch.FloatTensor, ...]，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（一個是嵌入層的輸出，如果模型有嵌入層，+ 每個層的輸出），形狀為(batch_size, sequence_length, hidden_size)。解碼器在每層輸出的隱藏狀態以及初始嵌入輸出。
- decoder_attentions (
tuple[torch.FloatTensor, ...]，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器的注意力權重（在注意力 softmax 之後），用於計算自注意力頭中的加權平均值。
- 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)，可選，預設為None) — 模型編碼器最後一層輸出的隱藏狀態序列。 - 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 之後），用於計算自注意力頭中的加權平均值。
- encoder_global_attentions (
tuple(torch.FloatTensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, x)，其中x是具有全域性注意力掩碼的詞元數量。全域性注意力權重（在注意力 softmax 之後），用於計算自注意力頭中的加權平均值。這些是從每個具有全域性注意力的詞元到序列中每個詞元的注意力權重。
序列到序列問答模型輸出的基類。
class transformers.models.led.modeling_tf_led.TFLEDEncoderBaseModelOutput
< 來源 >( last_hidden_state: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor, ...] | None = None attentions: tuple[tf.Tensor, ...] | None = None global_attentions: tuple[tf.Tensor, ...] | None = None )
引數
- last_hidden_state (
tf.Tensor，形狀為(batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。 - 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, x + attention_window + 1)，其中x是具有全域性注意力掩碼的詞元數量。區域性注意力權重（在注意力 softmax 之後），用於計算自注意力頭中的加權平均值。這些是從序列中每個詞元到每個具有全域性注意力的詞元（前
x個值）以及到注意力視窗中每個詞元（剩餘的 `attention_window- 1
個值）的注意力權重。請注意，前x + attention_window / 2x個值指的是文字中固定位置的詞元，但剩餘的 `attention_window + 1` 個值指的是相對位置的詞元：一個詞元對其自身的注意力權重位於索引處，而attention_window / 2個前（後）的值是其對attention_window / 2` 個前（後）詞元的注意力權重。如果注意力視窗包含一個具有全域性注意力的詞元，相應索引處的注意力權重將設定為 0；該值應從前x個注意力權重中訪問。如果一個詞元具有全域性注意力，那麼在 `attentions` 中它對所有其他詞元的注意力權重都設定為 0，這些值應從 `global_attentions` 中訪問。
- 1
- global_attentions (
tuple(tf.Tensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —tf.Tensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, x)，其中x是具有全域性注意力掩碼的詞元數量。全域性注意力權重（在注意力 softmax 之後），用於計算自注意力頭中的加權平均值。這些是從每個具有全域性注意力的詞元到序列中每個詞元的注意力權重。
Longformer 輸出的基類，可能包含隱藏狀態、區域性和全域性注意力。
class transformers.models.led.modeling_tf_led.TFLEDSeq2SeqModelOutput
< source >( 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 encoder_global_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時返回) — 形狀為(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 (
tf.Tensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 - 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 之後，用於在自注意力頭中計算加權平均值。
- encoder_global_attentions (
tuple(tf.Tensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, x)的tf.Tensor元組（每層一個），其中x是具有全域性注意力掩碼的標記數量。經過注意力 softmax 之後的全域性注意力權重，用於在自注意力頭中計算加權平均值。這些是從每個具有全域性注意力的標記到序列中每個標記的注意力權重。
模型編碼器輸出的基類，也包含：可加速順序解碼的預計算隱藏狀態。
class transformers.models.led.modeling_tf_led.TFLEDSeq2SeqLMOutput
< source >( 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 encoder_global_attentions: tuple[tf.Tensor, ...] | None = None )
引數
- loss (
tf.Tensor，形狀為(1,)，可選，當提供了labels時返回) — 語言建模損失。 - logits (
tf.Tensor，形狀為(batch_size, sequence_length, config.vocab_size)) — 語言建模頭的預測分數（在 SoftMax 之前的每個詞彙標記的分數）。 - past_key_values (
list[tf.Tensor]，可選，當傳遞use_cache=True或config.use_cache=True時返回) — 長度為config.n_layers的tf.Tensor列表，每個張量的形狀為(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含解碼器注意力塊中預先計算的隱藏狀態（鍵和值），可用於（參見
past_key_values輸入）加速序列解碼。 - decoder_hidden_states (
tuple(tf.Tensor)，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(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 (
tf.Tensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 - 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 之後，用於在自注意力頭中計算加權平均值。
- encoder_global_attentions (
tuple(tf.Tensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, x)的tf.Tensor元組（每層一個），其中x是具有全域性注意力掩碼的標記數量。經過注意力 softmax 之後的全域性注意力權重，用於在自注意力頭中計算加權平均值。這些是從每個具有全域性注意力的標記到序列中每個標記的注意力權重。
序列到序列語言模型輸出的基類。
LEDModel
class transformers.LEDModel
< source >( config: LEDConfig )
引數
- config (LEDConfig) — 模型配置類，包含模型的所有引數。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
原始的 Led 模型，輸出未經任何特定頭部處理的原始隱藏狀態。
該模型繼承自 PreTrainedModel。請查閱超類文件以瞭解該庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪注意力頭等）。
該模型也是一個 PyTorch torch.nn.Module 的子類。可以像常規的 PyTorch Module 一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None global_attention_mask: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.led.modeling_led.LEDSeq2SeqModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 詞彙表中輸入序列標記的索引。預設情況下，填充將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 掩碼，用於避免對填充標記索引執行注意力操作。掩碼值在[0, 1]中選擇：- 1 表示標記未被掩碼，
- 0 表示標記被掩碼。
- decoder_input_ids (
torch.LongTensor，形狀為(batch_size, target_sequence_length)，可選) — 詞彙表中解碼器輸入序列標記的索引。可以使用
LedTokenizer獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。LED 使用
eos_token_id作為生成decoder_input_ids的起始標記。如果使用past_key_values，則可以選擇只輸入最後的decoder_input_ids（參見past_key_values）。 - decoder_attention_mask (
torch.LongTensor，形狀為(batch_size, target_sequence_length)，可選) — 預設行為：生成一個忽略decoder_input_ids中填充標記的張量。預設情況下也會使用因果掩碼。如果要更改填充行為，應閱讀
modeling_led._prepare_decoder_inputs並根據需要進行修改。有關預設策略的更多資訊，請參閱論文中的圖 1。 - head_mask (
torch.Tensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 掩碼，用於將自注意力模組中選定的頭置零。掩碼值在[0, 1]中選擇：- 1 表示該頭未被掩碼，
- 0 表示該頭被掩碼。
- decoder_head_mask (
torch.Tensor，形狀為(decoder_layers, decoder_attention_heads)，可選) — 掩碼，用於將解碼器中注意力模組的選定頭置零。掩碼值在[0, 1]中選擇：- 1 表示該頭未被掩碼，
- 0 表示該頭被掩碼。
- cross_attn_head_mask (
torch.Tensor，形狀為(decoder_layers, decoder_attention_heads)，可選) — 掩碼，用於將解碼器中交叉注意力模組的選定頭置零。掩碼值在[0, 1]中選擇：- 1 表示該頭未被掩碼，
- 0 表示該頭被掩碼。
- encoder_outputs (
tuple[tuple[torch.FloatTensor]]，可選) — 元組包含 (last_hidden_state, 可選:hidden_states, 可選:attentions)。last_hidden_state的形狀為(batch_size, sequence_length, hidden_size)，可選) 是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力。 - global_attention_mask (
torch.FloatTensor，形狀為(batch_size, sequence_length)，可選) — 用於決定編碼器中每個標記的注意力型別的掩碼，可以是區域性注意力或全域性注意力。具有全域性注意力的標記會關注所有其他標記，而所有其他標記也會關注它們。這對於特定任務的微調非常重要，因為它使模型在表示任務時更加靈活。例如，對於分類任務，標記應給予全域性注意力。對於問答任務，所有問題標記也應具有全域性注意力。請參閱 Longformer 論文 瞭解更多詳情。掩碼值在[0, 1]中選擇：- 0 表示區域性注意力（滑動視窗注意力），
- 1 表示全域性注意力（標記關注所有其他標記，所有其他標記也關注它）。
- past_key_values (
tuple[tuple[torch.FloatTensor]]，可選) — 預先計算的隱藏狀態（自注意力和交叉注意力塊中的鍵和值），可用於加速序列解碼。這通常包括在解碼的先前階段，當use_cache=True或config.use_cache=True時由模型返回的past_key_values。允許兩種格式：
- 一個 Cache 例項，請參閱我們的 kv 快取指南；
- 長度為
config.n_layers的tuple(torch.FloatTensor)元組，每個元組有兩個形狀為(batch_size, num_heads, sequence_length, embed_size_per_head)的張量。這也稱為舊版快取格式。
模型將輸出與輸入相同的快取格式。如果沒有傳遞
past_key_values，將返回舊版快取格式。如果使用了
past_key_values，使用者可以選擇只輸入最後的input_ids（那些沒有為其提供過去鍵值狀態的標記），形狀為(batch_size, 1)，而不是形狀為(batch_size, sequence_length)的所有input_ids。 - inputs_embeds (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果您希望比模型內部的嵌入查詢矩陣更好地控制如何將input_ids索引轉換為關聯向量，這會非常有用。 - decoder_inputs_embeds (
torch.FloatTensor，形狀為(batch_size, target_sequence_length, hidden_size)，可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞decoder_input_ids。如果使用了past_key_values，則可以選擇只輸入最後的decoder_inputs_embeds（參見past_key_values）。如果您希望比模型內部的嵌入查詢矩陣更好地控制如何將decoder_input_ids索引轉換為關聯向量，這會非常有用。如果
decoder_input_ids和decoder_inputs_embeds都未設定，decoder_inputs_embeds將取inputs_embeds的值。 - use_cache (
bool，可選) — 如果設定為True，則返回past_key_values鍵值狀態，可用於加速解碼（參見past_key_values）。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool，可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。
返回
transformers.models.led.modeling_led.LEDSeq2SeqModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.models.led.modeling_led.LEDSeq2SeqModelOutput 或一個 torch.FloatTensor 元組（如果傳遞了 return_dict=False 或 config.return_dict=False），包含根據配置（LEDConfig）和輸入的不同元素。
-
last_hidden_state (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)) — 模型解碼器最後一層輸出的隱藏狀態序列。如果使用了
past_key_values，則只輸出形狀為(batch_size, 1, hidden_size)的序列的最後一個隱藏狀態。 -
past_key_values (
list[torch.FloatTensor]，可選，當傳遞use_cache=True或config.use_cache=True時返回) — 長度為config.n_layers的torch.FloatTensor列表，每個張量形狀為(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含解碼器注意力塊的預計算隱藏狀態（鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 -
decoder_hidden_states (
tuple[torch.FloatTensor, ...]，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層輸出，如果模型有嵌入層，+ 每個層一個輸出）。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_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.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選，預設為None) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple[torch.FloatTensor, ...]，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層輸出，如果模型有嵌入層，+ 每個層一個輸出）。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple[torch.FloatTensor, ...]，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
encoder_global_attentions (
tuple(torch.FloatTensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, x)的torch.FloatTensor元組（每層一個），其中x是具有全域性注意力掩碼的標記數量。經過注意力 softmax 之後的全域性注意力權重，用於在自注意力頭中計算加權平均值。這些是從每個具有全域性注意力的標記到序列中每個標記的注意力權重。
LEDModel 的前向方法，覆蓋了 `__call__` 特殊方法。
雖然前向傳遞的邏輯需要在這個函式中定義，但之後應該呼叫 `Module` 例項而不是這個函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
LEDForConditionalGeneration
class transformers.LEDForConditionalGeneration
< source >( config: LEDConfig )
引數
- config (LEDConfig) — 模型配置類，包含模型的所有引數。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
帶有語言建模頭的 LED 模型。可用於摘要生成。
該模型繼承自 PreTrainedModel。請查閱超類文件以瞭解該庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪注意力頭等）。
該模型也是一個 PyTorch torch.nn.Module 的子類。可以像常規的 PyTorch Module 一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None global_attention_mask: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.led.modeling_led.LEDSeq2SeqLMOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀(batch_size, sequence_length)，可選) — 詞彙表中輸入序列詞元的索引。預設情況下，填充將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形狀(batch_size, sequence_length)，可選) — 用於避免在填充詞元索引上執行注意力計算的掩碼。掩碼值選自[0, 1]：- 1 表示詞元未被遮蔽，
- 0 表示詞元已被遮蔽。
- decoder_input_ids (
torch.LongTensor，形狀(batch_size, target_sequence_length)，可選) — 解碼器輸入序列在詞彙表中的詞元索引。可以使用
LedTokenizer獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。LED 使用
eos_token_id作為生成decoder_input_ids的起始詞元。如果使用past_key_values，可以選擇只輸入最後的decoder_input_ids（參見past_key_values）。 - decoder_attention_mask (
torch.LongTensor，形狀(batch_size, target_sequence_length)，可選) — 預設行為：生成一個忽略decoder_input_ids中填充詞元的張量。預設情況下也會使用因果掩碼。如果您想更改填充行為，應閱讀
modeling_led._prepare_decoder_inputs並根據需要進行修改。有關預設策略的更多資訊，請參閱論文中的圖 1。 - head_mask (
torch.Tensor，形狀(num_heads,)或(num_layers, num_heads)，可選) — 用於置零自注意力模組中選定頭的掩碼。掩碼值選自[0, 1]：- 1 表示頭未被遮蔽，
- 0 表示頭已被遮蔽。
- decoder_head_mask (
torch.Tensor，形狀(decoder_layers, decoder_attention_heads)，可選) — 用於置零解碼器中注意力模組選定頭的掩碼。掩碼值選自[0, 1]：- 1 表示頭未被遮蔽，
- 0 表示頭已被遮蔽。
- cross_attn_head_mask (
torch.Tensor，形狀(decoder_layers, decoder_attention_heads)，可選) — 用於置零解碼器中交叉注意力模組選定頭的掩碼。掩碼值選自[0, 1]：- 1 表示頭未被遮蔽，
- 0 表示頭已被遮蔽。
- encoder_outputs (
tuple[tuple[torch.FloatTensor]]，可選) — 元組，包含 (last_hidden_state，可選:hidden_states，可選:attentions)。形狀為(batch_size, sequence_length, hidden_size)的last_hidden_state（可選）是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力。 - global_attention_mask (
torch.FloatTensor，形狀(batch_size, sequence_length)，可選) — 用於決定編碼器中每個詞元是使用區域性注意力還是全域性注意力的掩碼。具有全域性注意力的詞元會關注所有其他詞元，而所有其他詞元也會關注它們。這對於特定任務的微調很重要，因為它使模型在表示任務時更靈活。例如，對於分類任務，詞元應給予全域性注意力。對於問答任務，所有問題詞元也應具有全域性注意力。更多詳情請參閱 Longformer 論文。掩碼值選自[0, 1]：- 0 表示區域性注意力（滑動視窗注意力），
- 1 表示全域性注意力（關注所有其他詞元的詞元，並且所有其他詞元都關注它們）。
- past_key_values (
tuple[tuple[torch.FloatTensor]]，可選) — 預先計算的隱藏狀態（自注意力和交叉注意力塊中的鍵和值），可用於加速順序解碼。這通常是模型在解碼的先前階段返回的past_key_values，當use_cache=True或config.use_cache=True時。允許兩種格式：
- 一個 Cache 例項，請參閱我們的 kv 快取指南；
- 長度為
config.n_layers的tuple(torch.FloatTensor)元組，每個元組包含 2 個形狀為(batch_size, num_heads, sequence_length, embed_size_per_head)的張量。這也稱為舊版快取格式。
模型將輸出與輸入相同的快取格式。如果沒有傳入
past_key_values，將返回舊版快取格式。如果使用
past_key_values，使用者可以選擇只輸入最後的input_ids（那些沒有向該模型提供其過去鍵值狀態的詞元），形狀為(batch_size, 1)，而不是所有形狀為(batch_size, sequence_length)的input_ids。 - inputs_embeds (
torch.FloatTensor，形狀(batch_size, sequence_length, hidden_size)，可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果您想比模型內部的嵌入查詢矩陣更好地控制如何將input_ids索引轉換為關聯向量，這很有用。 - decoder_inputs_embeds (
torch.FloatTensor，形狀(batch_size, target_sequence_length, hidden_size)，可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞decoder_input_ids。如果使用past_key_values，可以選擇只輸入最後的decoder_inputs_embeds（參見past_key_values）。如果您想比模型內部的嵌入查詢矩陣更好地控制如何將decoder_input_ids索引轉換為關聯向量，這很有用。如果
decoder_input_ids和decoder_inputs_embeds均未設定，decoder_inputs_embeds將取inputs_embeds的值。 - labels (
torch.LongTensor，形狀(batch_size, sequence_length)，可選) — 用於計算掩碼語言建模損失的標籤。索引應在[0, ..., config.vocab_size]或 -100 之間（參見input_ids文件字串）。索引設定為-100的詞元將被忽略（遮蔽），損失僅對標籤在[0, ..., config.vocab_size]內的詞元計算。 - use_cache (
bool，可選) — 如果設定為True，將返回past_key_values鍵值狀態，可用於加速解碼（參見past_key_values）。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool，可選) — 是否返回 ModelOutput 而不是普通元組。
返回
transformers.models.led.modeling_led.LEDSeq2SeqLMOutput 或 tuple(torch.FloatTensor)
一個 transformers.models.led.modeling_led.LEDSeq2SeqLMOutput 或一個 torch.FloatTensor 的元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），包含各種元素，具體取決於配置（LEDConfig）和輸入。
-
loss (
torch.FloatTensor，形狀為(1,)，可選，當提供labels時返回) — 語言建模損失。 -
logits (形狀為
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 語言建模頭部的預測分數（SoftMax 之前的每個詞彙標記的分數）。 -
past_key_values (
list[torch.FloatTensor]，可選，當傳遞use_cache=True或config.use_cache=True時返回) — 長度為config.n_layers的torch.FloatTensor列表，每個張量形狀為(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含解碼器注意力塊的預計算隱藏狀態（鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 -
decoder_hidden_states (
tuple[torch.FloatTensor, ...]，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層輸出，如果模型有嵌入層，+ 每個層一個輸出）。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_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.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選，預設為None) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple[torch.FloatTensor, ...]，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層輸出，如果模型有嵌入層，+ 每個層一個輸出）。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple[torch.FloatTensor, ...]，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
encoder_global_attentions (
tuple(torch.FloatTensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, x)的torch.FloatTensor元組（每層一個），其中x是具有全域性注意力掩碼的標記數量。經過注意力 softmax 之後的全域性注意力權重，用於在自注意力頭中計算加權平均值。這些是從每個具有全域性注意力的標記到序列中每個標記的注意力權重。
LEDForConditionalGeneration 的 forward 方法重寫了 __call__ 特殊方法。
雖然前向傳遞的邏輯需要在這個函式中定義，但之後應該呼叫 `Module` 例項而不是這個函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
摘要示例
>>> import torch
>>> from transformers import AutoTokenizer, LEDForConditionalGeneration
>>> model = LEDForConditionalGeneration.from_pretrained("allenai/led-large-16384-arxiv")
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-large-16384-arxiv")
>>> ARTICLE_TO_SUMMARIZE = '''Transformers (Vaswani et al., 2017) have achieved state-of-the-art
... results in a wide range of natural language tasks including generative language modeling
... (Dai et al., 2019; Radford et al., 2019) and discriminative ... language understanding (Devlin et al., 2019).
... This success is partly due to the self-attention component which enables the network to capture contextual
... information from the entire sequence. While powerful, the memory and computational requirements of
... self-attention grow quadratically with sequence length, making it infeasible (or very expensive) to
... process long sequences. To address this limitation, we present Longformer, a modified Transformer
... architecture with a self-attention operation that scales linearly with the sequence length, making it
... versatile for processing long documents (Fig 1). This is an advantage for natural language tasks such as
... long document classification, question answering (QA), and coreference resolution, where existing approaches
... partition or shorten the long context into smaller sequences that fall within the typical 512 token limit
... of BERT-style pretrained models. Such partitioning could potentially result in loss of important
... cross-partition information, and to mitigate this problem, existing methods often rely on complex
... architectures to address such interactions. On the other hand, our proposed Longformer is able to build
... contextual representations of the entire context using multiple layers of attention, reducing the need for
... task-specific architectures.'''
>>> inputs = tokenizer.encode(ARTICLE_TO_SUMMARIZE, return_tensors="pt")
>>> # Global attention on the first token (cf. Beltagy et al. 2020)
>>> global_attention_mask = torch.zeros_like(inputs)
>>> global_attention_mask[:, 0] = 1
>>> # Generate Summary
>>> summary_ids = model.generate(inputs, global_attention_mask=global_attention_mask, num_beams=3, max_length=32)
>>> print(tokenizer.decode(summary_ids[0], skip_special_tokens=True, clean_up_tokenization_spaces=True))條件生成示例
>>> from transformers import AutoTokenizer, LEDForConditionalGeneration
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> TXT = "My friends are <mask> but they eat too many carbs."
>>> model = LEDForConditionalGeneration.from_pretrained("allenai/led-base-16384")
>>> input_ids = tokenizer([TXT], return_tensors="pt")["input_ids"]
>>> prediction = model.generate(input_ids)[0]
>>> print(tokenizer.decode(prediction, skip_special_tokens=True))LEDForSequenceClassification
class transformers.LEDForSequenceClassification
< 來源 >( config: LEDConfig **kwargs )
引數
- config (LEDConfig) — 模型配置類，包含模型的所有引數。使用配置檔案初始化不會載入與模型關聯的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
帶有序列分類/頭的 LED 模型（在池化輸出之上加一個線性層），例如用於 GLUE 任務。
該模型繼承自 PreTrainedModel。請查閱超類文件以瞭解該庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪注意力頭等）。
該模型也是一個 PyTorch torch.nn.Module 的子類。可以像常規的 PyTorch Module 一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
forward
< 來源 >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None global_attention_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.led.modeling_led.LEDSeq2SeqSequenceClassifierOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀(batch_size, sequence_length)，可選) — 詞彙表中輸入序列詞元的索引。預設情況下，填充將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形狀(batch_size, sequence_length)，可選) — 用於避免在填充詞元索引上執行注意力計算的掩碼。掩碼值選自[0, 1]：- 1 表示詞元未被遮蔽，
- 0 表示詞元已被遮蔽。
- decoder_input_ids (
torch.LongTensor，形狀(batch_size, target_sequence_length)，可選) — 解碼器輸入序列在詞彙表中的詞元索引。可以使用
LedTokenizer獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。LED 使用
eos_token_id作為生成decoder_input_ids的起始詞元。如果使用past_key_values，可以選擇只輸入最後的decoder_input_ids（參見past_key_values）。 - decoder_attention_mask (
torch.LongTensor，形狀(batch_size, target_sequence_length)，可選) — 預設行為：生成一個忽略decoder_input_ids中填充詞元的張量。預設情況下也會使用因果掩碼。如果您想更改填充行為，應閱讀
modeling_led._prepare_decoder_inputs並根據需要進行修改。有關預設策略的更多資訊，請參閱論文中的圖 1。 - head_mask (
torch.Tensor，形狀(num_heads,)或(num_layers, num_heads)，可選) — 用於置零自注意力模組中選定頭的掩碼。掩碼值選自[0, 1]：- 1 表示頭未被遮蔽，
- 0 表示頭已被遮蔽。
- decoder_head_mask (
torch.Tensor，形狀(decoder_layers, decoder_attention_heads)，可選) — 用於置零解碼器中注意力模組選定頭的掩碼。掩碼值選自[0, 1]：- 1 表示頭未被遮蔽，
- 0 表示頭已被遮蔽。
- cross_attn_head_mask (
torch.Tensor，形狀(decoder_layers, decoder_attention_heads)，可選) — 用於置零解碼器中交叉注意力模組選定頭的掩碼。掩碼值選自[0, 1]：- 1 表示頭未被遮蔽，
- 0 表示頭已被遮蔽。
- encoder_outputs (
tuple[tuple[torch.FloatTensor]]，可選) — 元組，包含 (last_hidden_state，可選:hidden_states，可選:attentions)。形狀為(batch_size, sequence_length, hidden_size)的last_hidden_state（可選）是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力。 - global_attention_mask (
torch.FloatTensor，形狀(batch_size, sequence_length)，可選) — 用於決定編碼器中每個詞元是使用區域性注意力還是全域性注意力的掩碼。具有全域性注意力的詞元會關注所有其他詞元，而所有其他詞元也會關注它們。這對於特定任務的微調很重要，因為它使模型在表示任務時更靈活。例如，對於分類任務，詞元應給予全域性注意力。對於問答任務，所有問題詞元也應具有全域性注意力。更多詳情請參閱 Longformer 論文。掩碼值選自[0, 1]：- 0 表示區域性注意力（滑動視窗注意力），
- 1 表示全域性注意力（關注所有其他詞元的詞元，並且所有其他詞元都關注它們）。
- inputs_embeds (
torch.FloatTensor，形狀(batch_size, sequence_length, hidden_size)，可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果您想比模型內部的嵌入查詢矩陣更好地控制如何將input_ids索引轉換為關聯向量，這很有用。 - decoder_inputs_embeds (
torch.FloatTensor，形狀(batch_size, target_sequence_length, hidden_size)，可選) — 可選地，您可以選擇直接傳遞嵌入表示，而不是傳遞decoder_input_ids。如果使用past_key_values，可以選擇只輸入最後的decoder_inputs_embeds（參見past_key_values）。如果您想比模型內部的嵌入查詢矩陣更好地控制如何將decoder_input_ids索引轉換為關聯向量，這很有用。如果
decoder_input_ids和decoder_inputs_embeds均未設定，decoder_inputs_embeds將取inputs_embeds的值。 - labels (
torch.LongTensor，形狀(batch_size,)，可選) — 用於計算序列分類/迴歸損失的標籤。索引應在[0, ..., config.num_labels - 1]範圍內。如果config.num_labels > 1，則計算分類損失（交叉熵）。 - use_cache (
bool，可選) — 如果設定為True，將返回past_key_values鍵值狀態，可用於加速解碼（參見past_key_values）。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool，可選) — 是否返回 ModelOutput 而不是普通元組。
返回
transformers.models.led.modeling_led.LEDSeq2SeqSequenceClassifierOutput 或 tuple(torch.FloatTensor)
一個 transformers.models.led.modeling_led.LEDSeq2SeqSequenceClassifierOutput 或一個 torch.FloatTensor 的元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），包含各種元素，具體取決於配置（LEDConfig）和輸入。
-
loss (形狀為
(1,)的torch.FloatTensor，可選，當提供label時返回) — 分類 (如果 config.num_labels==1 則為迴歸) 損失。 -
logits (形狀為
(batch_size, config.num_labels)的torch.FloatTensor) — 分類（如果 config.num_labels==1，則為迴歸）分數（SoftMax 之前）。 -
past_key_values (
list[torch.FloatTensor]，可選，當傳遞use_cache=True或config.use_cache=True時返回) — 長度為config.n_layers的torch.FloatTensor列表，每個張量形狀為(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含解碼器注意力塊的預計算隱藏狀態（鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 -
decoder_hidden_states (
tuple[torch.FloatTensor, ...]，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層輸出，如果模型有嵌入層，+ 每個層一個輸出）。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_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.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選，預設為None) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple[torch.FloatTensor, ...]，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層輸出，如果模型有嵌入層，+ 每個層一個輸出）。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple[torch.FloatTensor, ...]，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
encoder_global_attentions (
tuple(torch.FloatTensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, x)的torch.FloatTensor元組（每層一個），其中x是具有全域性注意力掩碼的標記數量。經過注意力 softmax 之後的全域性注意力權重，用於在自注意力頭中計算加權平均值。這些是從每個具有全域性注意力的標記到序列中每個標記的注意力權重。
LEDForSequenceClassification 的 forward 方法重寫了 __call__ 特殊方法。
雖然前向傳遞的邏輯需要在這個函式中定義，但之後應該呼叫 `Module` 例項而不是這個函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
單標籤分類示例
>>> import torch
>>> from transformers import AutoTokenizer, LEDForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> model = LEDForSequenceClassification.from_pretrained("allenai/led-base-16384")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = LEDForSequenceClassification.from_pretrained("allenai/led-base-16384", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...多標籤分類示例
>>> import torch
>>> from transformers import AutoTokenizer, LEDForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> model = LEDForSequenceClassification.from_pretrained("allenai/led-base-16384", problem_type="multi_label_classification")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = LEDForSequenceClassification.from_pretrained(
... "allenai/led-base-16384", num_labels=num_labels, problem_type="multi_label_classification"
... )
>>> labels = torch.sum(
... torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).lossLEDForQuestionAnswering
class transformers.LEDForQuestionAnswering
< 來源 >( config )
引數
- config (LEDForQuestionAnswering) — 模型配置類，包含模型的所有引數。使用配置檔案初始化不會載入與模型關聯的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
帶有片段分類頭的 Led transformer，用於像 SQuAD 這樣的抽取式問答任務（在隱藏狀態輸出之上加一個線性層，以計算 span start logits 和 span end logits）。
該模型繼承自 PreTrainedModel。請查閱超類文件以瞭解該庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪注意力頭等）。
該模型也是一個 PyTorch torch.nn.Module 的子類。可以像常規的 PyTorch Module 一樣使用它，並參考 PyTorch 文件瞭解所有與通用用法和行為相關的事項。
forward
< 原始碼 >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None global_attention_mask: typing.Optional[torch.FloatTensor] = None start_positions: typing.Optional[torch.LongTensor] = None end_positions: typing.Optional[torch.LongTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 詞彙表中輸入序列令牌的索引。預設情況下將忽略填充。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於避免在填充令牌索引上執行注意力機制的掩碼。掩碼值在[0, 1]中選擇：- 1 表示令牌未被遮蔽，
- 0 表示令牌被遮蔽。
- decoder_input_ids (
torch.LongTensor，形狀為(batch_size, target_sequence_length)，可選) — 詞彙表中解碼器輸入序列令牌的索引。可以使用
LedTokenizer獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。LED 使用
eos_token_id作為生成decoder_input_ids的起始令牌。如果使用past_key_values，則可以選擇只輸入最後一個decoder_input_ids（參見past_key_values）。 - decoder_attention_mask (
torch.LongTensor，形狀為(batch_size, target_sequence_length)，可選) — 預設行為：生成一個忽略decoder_input_ids中填充令牌的張量。預設情況下也會使用因果掩碼。如果你想改變填充行為，你應該閱讀
modeling_led._prepare_decoder_inputs並根據你的需求進行修改。有關預設策略的更多資訊，請參閱論文中的圖 1。 - head_mask (
torch.Tensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於使自注意力模組的選定頭無效的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭未被遮蔽，
- 0 表示頭被遮蔽。
- decoder_head_mask (
torch.Tensor，形狀為(decoder_layers, decoder_attention_heads)，可選) — 用於使解碼器中注意力模組的選定頭無效的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭未被遮蔽，
- 0 表示頭被遮蔽。
- cross_attn_head_mask (
torch.Tensor，形狀為(decoder_layers, decoder_attention_heads)，可選) — 用於使解碼器中交叉注意力模組的選定頭無效的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭未被遮蔽，
- 0 表示頭被遮蔽。
- encoder_outputs (
tuple[tuple[torch.FloatTensor]], 可選) — 元組包含 (last_hidden_state, 可選:hidden_states, 可選:attentions)。形狀為(batch_size, sequence_length, hidden_size)的last_hidden_state（可選）是編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力機制。 - global_attention_mask (
torch.FloatTensor，形狀為(batch_size, sequence_length)，可選) — 用於決定對每個令牌施加區域性注意力還是全域性注意力的掩碼（用於編碼器）。具有全域性注意力的令牌會關注所有其他令牌，並且所有其他令牌也會關注它們。這對於特定任務的微調很重要，因為它使模型在表示任務時更靈活。例如，對於分類任務，應給予令牌全域性注意力。對於問答任務，所有問題令牌也應具有全域性注意力。請參閱 Longformer 論文 以獲取更多詳細資訊。掩碼值在[0, 1]中選擇：- 0 表示區域性注意力（滑動視窗注意力），
- 1 表示全域性注意力（令牌關注所有其他令牌，並且所有其他令牌也關注它們）。
- start_positions (
torch.LongTensor，形狀為(batch_size,)，可選) — 標記的答案片段開始位置（索引）的標籤，用於計算令牌分類損失。位置被限制在序列長度（sequence_length）內。序列之外的位置在計算損失時不予考慮。 - end_positions (
torch.LongTensor，形狀為(batch_size,)，可選) — 標記的答案片段結束位置（索引）的標籤，用於計算令牌分類損失。位置被限制在序列長度（sequence_length）內。序列之外的位置在計算損失時不予考慮。 - inputs_embeds (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 可選地，你可以不傳遞input_ids，而是直接傳遞一個嵌入表示。如果你想比模型內部的嵌入查詢矩陣更好地控制如何將input_ids索引轉換為關聯向量，這會很有用。 - decoder_inputs_embeds (
torch.FloatTensor，形狀為(batch_size, target_sequence_length, hidden_size)，可選) — 可選地，你可以不傳遞decoder_input_ids，而是直接傳遞一個嵌入表示。如果使用past_key_values，可以選擇只輸入最後一個decoder_inputs_embeds（參見past_key_values）。如果你想比模型內部的嵌入查詢矩陣更好地控制如何將decoder_input_ids索引轉換為關聯向量，這會很有用。如果
decoder_input_ids和decoder_inputs_embeds都未設定，decoder_inputs_embeds將取inputs_embeds的值。 - use_cache (
bool, 可選) — 如果設定為True，將返回past_key_values鍵值狀態，可用於加速解碼（參見past_key_values）。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。
返回
transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput 或一個 torch.FloatTensor 的元組（如果傳遞 return_dict=False 或當 config.return_dict=False），包含根據配置（LEDConfig）和輸入而變化的不同元素。
-
loss (
torch.FloatTensorof shape(1,), 可選, 當提供labels時返回) — 總範圍提取損失是起始位置和結束位置的交叉熵之和。 -
start_logits (
torch.FloatTensor，形狀為(batch_size, sequence_length)，可選，預設為None) — 跨度開始分數（SoftMax 之前）。 -
end_logits (
torch.FloatTensor，形狀為(batch_size, sequence_length)，可選，預設為None) — 跨度結束分數（SoftMax 之前）。 -
past_key_values (
list[torch.FloatTensor]，可選，當傳遞use_cache=True或config.use_cache=True時返回) — 長度為config.n_layers的torch.FloatTensor列表，每個張量形狀為(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含解碼器注意力塊的預計算隱藏狀態（鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 -
decoder_hidden_states (
tuple[torch.FloatTensor, ...]，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層輸出，如果模型有嵌入層，+ 每個層一個輸出）。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_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.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (
torch.FloatTensor，形狀為(batch_size, sequence_length, hidden_size)，可選，預設為None) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple[torch.FloatTensor, ...]，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) — 形狀為(batch_size, sequence_length, hidden_size)的torch.FloatTensor元組（一個用於嵌入層輸出，如果模型有嵌入層，+ 每個層一個輸出）。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple[torch.FloatTensor, ...]，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元組（每層一個）。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
encoder_global_attentions (
tuple(torch.FloatTensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) — 形狀為(batch_size, num_heads, sequence_length, x)的torch.FloatTensor元組（每層一個），其中x是具有全域性注意力掩碼的標記數量。經過注意力 softmax 之後的全域性注意力權重，用於在自注意力頭中計算加權平均值。這些是從每個具有全域性注意力的標記到序列中每個標記的注意力權重。
LEDForQuestionAnswering 的前向方法，覆蓋了 `__call__` 特殊方法。
雖然前向傳遞的邏輯需要在這個函式中定義，但之後應該呼叫 `Module` 例項而不是這個函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> from transformers import AutoTokenizer, LEDForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> model = LEDForQuestionAnswering.from_pretrained("allenai/led-base-16384")
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()
>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...
>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])
>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...TFLEDModel
class transformers.TFLEDModel
< 原始碼 >( config *inputs **kwargs )
引數
- config (LEDConfig) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型關聯的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
裸 LED 模型，輸出原始隱藏狀態，頂部沒有任何特定的頭。此模型繼承自 TFPreTrainedModel。請檢視超類文件，瞭解庫為所有模型實現的通用方法（如下載或儲存、調整輸入嵌入大小、修剪頭等）。
此模型也是 keras.Model 的子類。可以像常規的 TF 2.0 Keras 模型一樣使用它，並參考 TF 2.0 文件瞭解所有與常規用法和行為相關的事項。
transformers 中的 TensorFlow 模型和層接受兩種輸入格式
- 所有輸入作為關鍵字引數（如 PyTorch 模型），或
- 所有輸入作為第一個位置引數中的列表、元組或字典。
支援第二種格式的原因是，Keras 方法在向模型和層傳遞輸入時更喜歡這種格式。由於這種支援，當使用像 model.fit() 這樣的方法時，一切都應該“正常工作”——只需以 model.fit() 支援的任何格式傳遞你的輸入和標籤！然而，如果你想在 Keras 方法（如 fit() 和 predict()）之外使用第二種格式，例如在使用 Keras Functional API 建立自己的層或模型時，有三種可能性可以用來將所有輸入張量收集到第一個位置引數中。
- 只有一個
input_ids的單個張量，沒有其他：model(input_ids) - 長度可變的列表，包含一個或多個輸入張量，按文件字串中給出的順序：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一個字典，其中包含一個或多個與文件字串中給出的輸入名稱關聯的輸入張量：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
請注意，當使用子類化建立模型和層時，你不需要擔心這些，因為你可以像傳遞給任何其他 Python 函式一樣傳遞輸入！
呼叫
< 原始碼 >( input_ids: TFModelInputType | None = None attention_mask: tf.Tensor | None = None decoder_input_ids: tf.Tensor | None = None decoder_attention_mask: tf.Tensor | None = None head_mask: tf.Tensor | None = None decoder_head_mask: tf.Tensor | None = None encoder_outputs: tf.Tensor | None = None global_attention_mask: tf.Tensor | None = None past_key_values: tuple[tuple[tf.Tensor]] | None = None inputs_embeds: tf.Tensor | None = None decoder_inputs_embeds: tf.Tensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None training: bool = False **kwargs ) → transformers.models.led.modeling_tf_led.TFLEDSeq2SeqModelOutput 或 tuple(tf.Tensor)
引數
- input_ids (
tf.Tensor，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列令牌的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
tf.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於避免在填充令牌索引上執行注意力機制的掩碼。掩碼值在[0, 1]中選擇：- 1 表示令牌未被遮蔽，
- 0 表示令牌被遮蔽。
- decoder_input_ids (
tf.Tensor，形狀為(batch_size, target_sequence_length)，可選) — 詞彙表中解碼器輸入序列令牌的索引。可以使用
LedTokenizer獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。LED 使用
eos_token_id作為生成decoder_input_ids的起始令牌。如果使用past_key_values，則可以選擇只輸入最後一個decoder_input_ids（參見past_key_values）。 - decoder_attention_mask (
tf.Tensor，形狀為(batch_size, target_sequence_length)，可選) — 預設情況下會建立並忽略填充令牌。在大多數情況下，不建議設定此引數。 - head_mask (
tf.Tensor，形狀為(encoder_layers, encoder_attention_heads)，可選) — 用於使編碼器中注意力模組的選定頭無效的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭未被遮蔽，
- 0 表示頭被遮蔽。
- decoder_head_mask (
tf.Tensor，形狀為(decoder_layers, decoder_attention_heads)，可選) — 用於使解碼器中注意力模組的選定頭無效的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭未被遮蔽，
- 0 表示頭被遮蔽。
- encoder_outputs (
tf.Tensor, 可選) — 編碼器最後一層輸出的隱藏狀態。用於解碼器的交叉注意力。形狀為(batch_size, sequence_length, hidden_size)，是隱藏狀態的序列。 - past_key_values (
tuple[tuple[tf.Tensor]]，長度為config.n_layers) — 包含預計算的注意力塊的鍵和值隱藏狀態。可用於加速解碼。如果使用past_key_values，使用者可以選擇只輸入最後一個形狀為(batch_size, 1)的decoder_input_ids（那些未將其過去鍵值狀態提供給此模型的），而不是所有形狀為(batch_size, sequence_length)的decoder_input_ids。 - use_cache (
bool, 可選, 預設為True) — 如果設定為True，將返回past_key_values鍵值狀態，可用於加速解碼（參見past_key_values）。訓練時設定為False，生成時設定為True。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。此引數只能在 eager 模式下使用，在 graph 模式下將使用配置中的值。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。此引數只能在 eager 模式下使用，在 graph 模式下將使用配置中的值。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。此引數可以在 eager 模式下使用，在 graph 模式下，該值將始終設定為 True。 - training (
bool, 可選, 預設為False) — 是否在訓練模式下使用模型（某些模組如 dropout 模組在訓練和評估之間有不同的行為）。
返回
transformers.models.led.modeling_tf_led.TFLEDSeq2SeqModelOutput 或 tuple(tf.Tensor)
一個 transformers.models.led.modeling_tf_led.TFLEDSeq2SeqModelOutput 或一個 tf.Tensor 的元組（如果傳遞 return_dict=False 或當 config.return_dict=False），包含根據配置（LEDConfig）和輸入而變化的不同元素。
-
last_hidden_state (形狀為
(batch_size, sequence_length, hidden_size)的tf.Tensor) — 模型解碼器最後一層輸出的隱藏狀態序列。如果使用了
past_key_values，則只輸出形狀為(batch_size, 1, hidden_size)的序列的最後一個隱藏狀態。 -
past_key_values (
list[tf.Tensor], 可選，當傳遞use_cache=True或當config.use_cache=True時返回) — 長度為config.n_layers的tf.Tensor列表，每個張量的形狀為(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含解碼器注意力塊的預計算隱藏狀態（鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 -
decoder_hidden_states (
tuple(tf.Tensor), 可選，當傳遞output_hidden_states=True或當config.output_hidden_states=True時返回) —tf.Tensor的元組（一個用於嵌入層的輸出 + 一個用於每一層的輸出），形狀為(batch_size, sequence_length, hidden_size)。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_attentions (
tuple(tf.Tensor), 可選，當傳遞output_attentions=True或當config.output_attentions=True時返回) —tf.Tensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
cross_attentions (
tuple(tf.Tensor), 可選，當傳遞output_attentions=True或當config.output_attentions=True時返回) —tf.Tensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (形狀為
(batch_size, sequence_length, hidden_size)的tf.Tensor, 可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple(tf.Tensor), 可選，當傳遞output_hidden_states=True或當config.output_hidden_states=True時返回) —tf.Tensor的元組（一個用於嵌入層的輸出 + 一個用於每一層的輸出），形狀為(batch_size, sequence_length, hidden_size)。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple(tf.Tensor), 可選，當傳遞output_attentions=True或當config.output_attentions=True時返回) —tf.Tensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
encoder_global_attentions (
tuple(tf.Tensor), 可選，當傳遞output_attentions=True或當config.output_attentions=True時返回) —tf.Tensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, x)，其中x是具有全域性注意力掩碼的令牌數量。經過注意力 softmax 之後的全域性注意力權重，用於在自注意力頭中計算加權平均值。這些是從每個具有全域性注意力的標記到序列中每個標記的注意力權重。
TFLEDModel 的前向方法，覆蓋了 `__call__` 特殊方法。
雖然前向傳遞的邏輯需要在這個函式中定義，但之後應該呼叫 `Module` 例項而不是這個函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> from transformers import AutoTokenizer, TFLEDModel
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> model = TFLEDModel.from_pretrained("allenai/led-base-16384")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)
>>> last_hidden_states = outputs.last_hidden_stateTFLEDForConditionalGeneration
class transformers.TFLEDForConditionalGeneration
< 原始碼 >( config *inputs **kwargs )
引數
- config (LEDConfig) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型關聯的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
帶語言模型頭的 LED 模型。可用於摘要任務。此模型繼承自 TFPreTrainedModel。請檢視超類文件，瞭解庫為所有模型實現的通用方法（如下載或儲存、調整輸入嵌入大小、修剪頭等）。
此模型也是 keras.Model 的子類。可以像常規的 TF 2.0 Keras 模型一樣使用它，並參考 TF 2.0 文件瞭解所有與常規用法和行為相關的事項。
transformers 中的 TensorFlow 模型和層接受兩種輸入格式
- 所有輸入作為關鍵字引數（如 PyTorch 模型），或
- 所有輸入作為第一個位置引數中的列表、元組或字典。
支援第二種格式的原因是，Keras 方法在向模型和層傳遞輸入時更喜歡這種格式。由於這種支援，當使用像 model.fit() 這樣的方法時，一切都應該“正常工作”——只需以 model.fit() 支援的任何格式傳遞你的輸入和標籤！然而，如果你想在 Keras 方法（如 fit() 和 predict()）之外使用第二種格式，例如在使用 Keras Functional API 建立自己的層或模型時，有三種可能性可以用來將所有輸入張量收集到第一個位置引數中。
- 只有一個
input_ids的單個張量，沒有其他：model(input_ids) - 長度可變的列表，包含一個或多個輸入張量，按文件字串中給出的順序：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一個字典，其中包含一個或多個與文件字串中給出的輸入名稱關聯的輸入張量：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
請注意，當使用子類化建立模型和層時，你不需要擔心這些，因為你可以像傳遞給任何其他 Python 函式一樣傳遞輸入！
呼叫
< 原始碼 >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None decoder_input_ids: np.ndarray | tf.Tensor | None = None decoder_attention_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None decoder_head_mask: np.ndarray | tf.Tensor | None = None encoder_outputs: TFLEDEncoderBaseModelOutput | None = None global_attention_mask: np.ndarray | tf.Tensor | None = None past_key_values: tuple[tuple[Union[np.ndarray, tf.Tensor]]] | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None decoder_inputs_embeds: np.ndarray | tf.Tensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None labels: tf.Tensor | None = None training: bool = False ) → transformers.models.led.modeling_tf_led.TFLEDSeq2SeqLMOutput 或 tuple(tf.Tensor)
引數
- input_ids (
tf.Tensor，形狀為({0})) — 詞彙表中輸入序列標記的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
tf.Tensor，形狀為({0}), 可選) — 用於避免在填充標記索引上執行注意力操作的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被掩碼,
- 0 表示標記被掩碼。
- decoder_input_ids (
tf.Tensor，形狀為(batch_size, target_sequence_length), 可選) — 詞彙表中解碼器輸入序列標記的索引。可以使用
LedTokenizer獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。LED 使用
eos_token_id作為生成decoder_input_ids的起始標記。如果使用past_key_values，可以選擇只輸入最後的decoder_input_ids（參見past_key_values）。 - decoder_attention_mask (
tf.Tensor，形狀為(batch_size, target_sequence_length), 可選) — 預設情況下會建立並忽略填充標記。在大多數用例中不建議設定此項。 - head_mask (
tf.Tensor，形狀為(encoder_layers, encoder_attention_heads), 可選) — 用於置零編碼器中注意力模組選定頭的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭未被掩碼,
- 0 表示頭被掩碼。
- decoder_head_mask (
tf.Tensor，形狀為(decoder_layers, decoder_attention_heads), 可選) — 用於置零解碼器中注意力模組選定頭的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭未被掩碼,
- 0 表示頭被掩碼。
- encoder_outputs (
tf.Tensor, 可選) — 編碼器最後一層輸出的隱藏狀態序列。用於解碼器的交叉注意力。形狀為(batch_size, sequence_length, hidden_size)。 - past_key_values (
tuple[tuple[tf.Tensor]]，長度為config.n_layers) — 包含預先計算的注意力塊的鍵和值隱藏狀態。可用於加速解碼。如果使用past_key_values，使用者可以選擇只輸入形狀為(batch_size, 1)的最後decoder_input_ids（那些沒有提供其過去鍵值狀態給此模型的），而不是形狀為(batch_size, sequence_length)的所有decoder_input_ids。 - use_cache (
bool, 可選，預設為True) — 如果設定為True，將返回past_key_values鍵值狀態，並可用於加速解碼（參見past_key_values）。訓練時設定為False，生成時設定為True。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參見返回張量下的attentions。此引數只能在即時模式下使用，在圖模式下將使用配置中的值。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參見返回張量下的hidden_states。此引數只能在即時模式下使用，在圖模式下將使用配置中的值。 - return_dict (
bool, 可選) — 是否返回 ModelOutput 而不是普通元組。此引數可在即時模式下使用，在圖模式下該值將始終設定為 True。 - training (
bool, 可選，預設為False) — 是否在訓練模式下使用模型（某些模組如 dropout 在訓練和評估之間有不同的行為）。
返回
transformers.models.led.modeling_tf_led.TFLEDSeq2SeqLMOutput 或 tuple(tf.Tensor)
一個 transformers.models.led.modeling_tf_led.TFLEDSeq2SeqLMOutput 或一個 tf.Tensor 的元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），根據配置（LEDConfig）和輸入包含各種元素。
-
loss (
tf.Tensor，形狀為(1,), 可選，當提供labels時返回) — 語言建模損失。 -
logits (
tf.Tensorof shape(batch_size, sequence_length, config.vocab_size)) — 語言模型頭部的預測分數（SoftMax 之前每個詞彙標記的分數）。 -
past_key_values (
list[tf.Tensor], 可選，當傳遞use_cache=True或當config.use_cache=True時返回) — 長度為config.n_layers的tf.Tensor列表，每個張量的形狀為(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含解碼器注意力塊的預計算隱藏狀態（鍵和值），可用於（參見
past_key_values輸入）加速順序解碼。 -
decoder_hidden_states (
tuple(tf.Tensor), 可選，當傳遞output_hidden_states=True或當config.output_hidden_states=True時返回) —tf.Tensor的元組（一個用於嵌入層的輸出 + 一個用於每一層的輸出），形狀為(batch_size, sequence_length, hidden_size)。解碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
decoder_attentions (
tuple(tf.Tensor), 可選，當傳遞output_attentions=True或當config.output_attentions=True時返回) —tf.Tensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
cross_attentions (
tuple(tf.Tensor), 可選，當傳遞output_attentions=True或當config.output_attentions=True時返回) —tf.Tensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。解碼器交叉注意力層的注意力權重，在注意力 softmax 之後，用於計算交叉注意力頭中的加權平均。
-
encoder_last_hidden_state (形狀為
(batch_size, sequence_length, hidden_size)的tf.Tensor, 可選) — 模型編碼器最後一層輸出的隱藏狀態序列。 -
encoder_hidden_states (
tuple(tf.Tensor), 可選，當傳遞output_hidden_states=True或當config.output_hidden_states=True時返回) —tf.Tensor的元組（一個用於嵌入層的輸出 + 一個用於每一層的輸出），形狀為(batch_size, sequence_length, hidden_size)。編碼器在每一層輸出時的隱藏狀態以及初始嵌入輸出。
-
encoder_attentions (
tuple(tf.Tensor), 可選，當傳遞output_attentions=True或當config.output_attentions=True時返回) —tf.Tensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, sequence_length)。編碼器的注意力權重，在注意力 softmax 之後，用於計算自注意力頭中的加權平均。
-
encoder_global_attentions (
tuple(tf.Tensor), 可選，當傳遞output_attentions=True或當config.output_attentions=True時返回) —tf.Tensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, x)，其中x是具有全域性注意力掩碼的令牌數量。經過注意力 softmax 之後的全域性注意力權重，用於在自注意力頭中計算加權平均值。這些是從每個具有全域性注意力的標記到序列中每個標記的注意力權重。
TFLEDForConditionalGeneration 的前向方法，覆蓋了 __call__ 特殊方法。
雖然前向傳遞的邏輯需要在這個函式中定義，但之後應該呼叫 `Module` 例項而不是這個函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> from transformers import AutoTokenizer, TFLEDForConditionalGeneration
>>> import tensorflow as tf
>>> mname = "allenai/led-base-16384"
>>> tokenizer = AutoTokenizer.from_pretrained(mname)
>>> TXT = "My friends are <mask> but they eat too many carbs."
>>> model = TFLEDForConditionalGeneration.from_pretrained(mname)
>>> batch = tokenizer([TXT], return_tensors="tf")
>>> logits = model(inputs=batch.input_ids).logits
>>> probs = tf.nn.softmax(logits[0])
>>> # probs[5] is associated with the mask token