Transformers 文件
Longformer
並獲得增強的文件體驗
開始使用
Longformer
Longformer 是一種專為處理長文件而設計的 Transformer 模型。自注意力操作通常會隨序列長度二次方增長，這限制了 Transformer 處理更長序列的能力。Longformer 的注意力機制透過與序列長度線性擴充套件來克服這一問題。它結合了局部視窗化注意力和任務特定的全域性注意力，從而能夠高效處理包含數千個標記的文件。
你可以在 Ai2 組織下找到所有原始的 Longformer 檢查點。
點選右側邊欄中的 Longformer 模型，檢視更多關於如何將 Longformer 應用於不同語言任務的示例。
下面的示例演示瞭如何使用 Pipeline、AutoModel 和命令列來填充 <mask> 標記。
import torch
from transformers import pipeline
pipeline = pipeline(
task="fill-mask",
model="allenai/longformer-base-4096",
torch_dtype=torch.float16,
device=0
)
pipeline("""San Francisco 49ers cornerback Shawntae Spencer will miss the rest of the <mask> with a torn ligament in his left knee.
Spencer, a fifth-year pro, will be placed on injured reserve soon after undergoing surgery Wednesday to repair the ligament. He injured his knee late in the 49ers’ road victory at Seattle on Sept. 14, and missed last week’s victory over Detroit.
Tarell Brown and Donald Strickland will compete to replace Spencer with the 49ers, who kept 12 defensive backs on their 53-man roster to start the season. Brown, a second-year pro, got his first career interception last weekend while filling in for Strickland, who also sat out with a knee injury.""")注意事項
Longformer 基於 RoBERTa 並且沒有 `token_type_ids`。你不需要指明哪個標記屬於哪個段落。你只需要使用分隔標記 `</s>` 或 `tokenizer.sep_token` 來分隔段落。
在推理時，你可以使用 `global_attention_mask` 來設定哪些標記可以進行區域性注意力，哪些可以進行全域性注意力（更多細節請參見此示例）。值為 `0` 表示標記進行區域性注意力，值為 `1` 表示標記進行全域性注意力。
LongformerForMaskedLM 的訓練方式與 RobertaForMaskedLM 類似，應如下所示使用。
input_ids = tokenizer.encode("This is a sentence from [MASK] training data", return_tensors="pt") mlm_labels = tokenizer.encode("This is a sentence from the training data", return_tensors="pt") loss = model(input_ids, labels=input_ids, masked_lm_labels=mlm_labels)[0]
LongformerConfig
class transformers.LongformerConfig
< 來源 >( attention_window: typing.Union[list[int], int] = 512 sep_token_id: int = 2 pad_token_id: int = 1 bos_token_id: int = 0 eos_token_id: int = 2 vocab_size: int = 30522 hidden_size: int = 768 num_hidden_layers: int = 12 num_attention_heads: int = 12 intermediate_size: int = 3072 hidden_act: str = 'gelu' hidden_dropout_prob: float = 0.1 attention_probs_dropout_prob: float = 0.1 max_position_embeddings: int = 512 type_vocab_size: int = 2 initializer_range: float = 0.02 layer_norm_eps: float = 1e-12 onnx_export: bool = False **kwargs )
引數
- vocab_size (
int, optional, 預設為 30522) — Longformer 模型的詞彙表大小。定義了在呼叫 LongformerModel 或 TFLongformerModel 時，可以透過 `inputs_ids` 表示的不同標記的數量。 - hidden_size (
int, optional, 預設為 768) — 編碼器層和池化層的維度。 - num_hidden_layers (
int, optional, 預設為 12) — Transformer 編碼器中的隱藏層數量。 - num_attention_heads (
int, optional, 預設為 12) — Transformer 編碼器中每個注意力層的注意力頭數量。 - intermediate_size (
int, optional, 預設為 3072) — Transformer 編碼器中“中間層”（通常稱為前饋層）的維度。 - hidden_act (
str或Callable, optional, 預設為"gelu") — 編碼器和池化層中的非線性啟用函式（函式或字串）。如果為字串，支援 `"gelu"`、`"relu"`、`"silu"` 和 `"gelu_new"`。 - hidden_dropout_prob (
float, optional, 預設為 0.1) — 嵌入層、編碼器和池化層中所有全連線層的丟棄機率。 - attention_probs_dropout_prob (
float, optional, 預設為 0.1) — 注意力機率的丟棄率。 - max_position_embeddings (
int, optional, 預設為 512) — 此模型可能使用的最大序列長度。通常將其設定為一個較大的值以備不時之需（例如，512、1024 或 2048）。 - type_vocab_size (
int, optional, 預設為 2) — 在呼叫 LongformerModel 或 TFLongformerModel 時傳入的 `token_type_ids` 的詞彙表大小。 - initializer_range (
float, optional, 預設為 0.02) — 用於初始化所有權重矩陣的 truncated_normal_initializer 的標準差。 - layer_norm_eps (
float, optional, 預設為 1e-12) — 層歸一化層使用的 epsilon 值。 - attention_window (
int或list[int], optional, 預設為 512) — 每個標記周圍的注意力視窗大小。如果是一個 `int`，則所有層使用相同的大小。要為每個層指定不同的視窗大小，請使用一個 `list[int]`，其中 `len(attention_window) == num_hidden_layers`。
這是用於儲存 LongformerModel 或 TFLongformerModel 配置的配置類。它用於根據指定的引數例項化一個 Longformer 模型，定義模型架構。
這是用於儲存 LongformerModel 配置的配置類。它用於根據指定的引數例項化一個 Longformer 模型，定義模型架構。使用預設值例項化一個配置將產生一個與 LongFormer allenai/longformer-base-4096 架構相似的配置，其序列長度為 4,096。
配置物件繼承自 PretrainedConfig，可用於控制模型輸出。請閱讀 PretrainedConfig 的文件以獲取更多資訊。
示例
>>> from transformers import LongformerConfig, LongformerModel
>>> # Initializing a Longformer configuration
>>> configuration = LongformerConfig()
>>> # Initializing a model from the configuration
>>> model = LongformerModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configLongformerTokenizer
class transformers.LongformerTokenizer
< 來源 >( 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) — merges 檔案的路徑。 - 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) — 是否在輸入前新增一個初始空格。這使得前導詞可以像其他詞一樣處理。（Longformer 分詞器透過前面的空格來檢測詞的開頭）。
構建一個 Longformer 分詞器，它源自 GPT-2 分詞器，使用位元組級位元組對編碼（Byte-Pair-Encoding）。
這個分詞器經過訓練，將空格視為詞元的一部分（有點像 sentencepiece），所以一個詞會
無論是否在句子開頭（無空格），編碼方式都會不同
>>> from transformers import LongformerTokenizer
>>> tokenizer = LongformerTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> 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
< 來源 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
透過連線和新增特殊標記，從一個序列或一對序列為序列分類任務構建模型輸入。Longformer 序列具有以下格式
- 單個序列：
<s> X </s> - 序列對：
<s> A </s></s> B </s>
將標記序列（字串）轉換為單個字串。
create_token_type_ids_from_sequences
< source >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
從傳入的兩個序列建立掩碼，用於序列對分類任務。Longformer 不使用標記型別 ID，因此返回一個零列表。
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方法新增特殊標記時呼叫。
LongformerTokenizerFast
class transformers.LongformerTokenizerFast
< 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, defaults to"replace") — 將位元組解碼為 UTF-8 時遵循的範例。有關更多資訊，請參閱 bytes.decode。 - bos_token (
str, optional, defaults to"<s>") — 預訓練期間使用的序列開始標記。可用作序列分類器標記。使用特殊標記構建序列時，這不是用於序列開始的標記。使用的標記是 `cls_token`。
- eos_token (
str, optional, defaults to"</s>") — 序列結束標記。使用特殊標記構建序列時，這不是用於序列結束的標記。使用的標記是 `sep_token`。
- sep_token (
str, optional, defaults to"</s>") — 分隔符標記，用於從多個序列構建一個序列，例如用於序列分類的兩個序列，或用於問答的文字和問題。它也用作使用特殊標記構建的序列的最後一個標記。 - cls_token (
str, optional, defaults to"<s>") — 分類器標記，用於進行序列分類（對整個序列進行分類，而不是逐個標記分類）。當使用特殊標記構建序列時，它是序列的第一個標記。 - unk_token (
str, optional, defaults to"<unk>") — 未知標記。不在詞彙表中的標記無法轉換為 ID，而是設定為此標記。 - pad_token (
str, optional, defaults to"<pad>") — 用於填充的標記，例如在批處理不同長度的序列時使用。 - mask_token (
str, optional, defaults to"<mask>") — 用於掩蓋值的標記。這是使用掩碼語言建模訓練此模型時使用的標記。這是模型將嘗試預測的標記。 - add_prefix_space (
bool, optional, defaults toFalse) — 是否在輸入前新增一個初始空格。這允許將開頭的單詞像其他任何單詞一樣處理。（Longformer 分詞器透過前面的空格檢測單詞的開頭）。 - trim_offsets (
bool, optional, defaults toTrue) — 後處理步驟是否應修剪偏移量以避免包含空格。
構建一個“快速”Longformer 分詞器（由 HuggingFace 的 *tokenizers* 庫支援），它源自 GPT-2 分詞器，使用位元組級位元組對編碼（Byte-Pair-Encoding）。
這個分詞器經過訓練，將空格視為詞元的一部分（有點像 sentencepiece），所以一個詞會
無論是否在句子開頭（無空格），編碼方式都會不同
>>> from transformers import LongformerTokenizerFast
>>> tokenizer = LongformerTokenizerFast.from_pretrained("allenai/longformer-base-4096")
>>> 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]
從傳入的兩個序列建立掩碼，用於序列對分類任務。Longformer 不使用標記型別 ID，因此返回一個零列表。
Longformer 特定輸出
class transformers.models.longformer.modeling_longformer.LongformerBaseModelOutput
< 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, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) —torch.FloatTensor的元組（如果模型有嵌入層，則一個用於嵌入層的輸出，+ 每個層一個輸出），形狀為 `(batch_size, sequence_length, hidden_size)`。模型在每層輸出處的隱藏狀態以及可選的初始嵌入輸出。
- attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.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` 中訪問。
- global_attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) —torch.FloatTensor的元組（每層一個），形狀為 `(batch_size, num_heads, sequence_length, x)`，其中 `x` 是具有全域性注意力掩碼的標記數。注意力 softmax 後的全域性注意力權重，用於計算自注意力頭中的加權平均。這些是每個具有全域性注意力的標記對序列中每個標記的注意力權重。
Longformer 輸出的基類，包含潛在的隱藏狀態、區域性和全域性注意力。
class transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling
< source >( last_hidden_state: FloatTensor pooler_output: typing.Optional[torch.FloatTensor] = None 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)) — 模型最後一層輸出的隱藏狀態序列。 - pooler_output (
torch.FloatTensorof shape(batch_size, hidden_size)) — 序列第一個標記（分類標記）的最後一層隱藏狀態，再經過一個線性層和 Tanh 啟用函式處理。線性層的權重是在預訓練期間從下一句預測（分類）目標中訓練得到的。 - hidden_states (
tuple[torch.FloatTensor, ...], optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) —torch.FloatTensor的元組（如果模型有嵌入層，則一個用於嵌入層的輸出，+ 每個層一個輸出），形狀為 `(batch_size, sequence_length, hidden_size)`。模型在每層輸出處的隱藏狀態以及可選的初始嵌入輸出。
- attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.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` 中訪問。
- global_attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) —torch.FloatTensor的元組（每層一個），形狀為 `(batch_size, num_heads, sequence_length, x)`，其中 `x` 是具有全域性注意力掩碼的標記數。注意力 softmax 後的全域性注意力權重，用於計算自注意力頭中的加權平均。這些是每個具有全域性注意力的標記對序列中每個標記的注意力權重。
Longformer 輸出的基類，也包含最後隱藏狀態的池化。
class transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput
< source >( 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 global_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
引數
- loss (
torch.FloatTensorof shape(1,), optional, returned whenlabelsis provided) — 掩碼語言建模（MLM）損失。 - logits (
torch.FloatTensorof shape(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, 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), 可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, x)，其中x是帶有全域性注意力掩碼的詞元數量。注意力 softmax 之後的全域性注意力權重，用於計算自注意力頭中的加權平均值。這些是每個具有全域性注意力的詞元到序列中每個詞元的注意力權重。
掩碼語言模型輸出的基類。
class transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput
< source >( 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 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 之前）。 - 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, 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), 可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, x)，其中x是帶有全域性注意力掩碼的詞元數量。注意力 softmax 之後的全域性注意力權重，用於計算自注意力頭中的加權平均值。這些是每個具有全域性注意力的詞元到序列中每個詞元的注意力權重。
用於 Longformer 問答模型輸出的基類。
class transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput
< source >( 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 global_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, 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), 可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, x)，其中x是帶有全域性注意力掩碼的詞元數量。注意力 softmax 之後的全域性注意力權重，用於計算自注意力頭中的加權平均值。這些是每個具有全域性注意力的詞元到序列中每個詞元的注意力權重。
句子分類模型輸出的基類。
class transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput
< source >( 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 global_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, 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), 可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, x)，其中x是帶有全域性注意力掩碼的詞元數量。注意力 softmax 之後的全域性注意力權重，用於計算自注意力頭中的加權平均值。這些是每個具有全域性注意力的詞元到序列中每個詞元的注意力權重。
用於 Longformer 多項選擇模型輸出的基類。
class transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput
< source >( 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 global_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, 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), 可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, x)，其中x是帶有全域性注意力掩碼的詞元數量。注意力 softmax 之後的全域性注意力權重，用於計算自注意力頭中的加權平均值。這些是每個具有全域性注意力的詞元到序列中每個詞元的注意力權重。
Token分類模型輸出的基類。
class transformers.models.longformer.modeling_tf_longformer.TFLongformerBaseModelOutput
< source >( 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 + 1個值指的是相對位置的詞元：一個詞元對其自身的注意力權重位於索引x + attention_window / 2處，而前面（後面）的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.longformer.modeling_tf_longformer.TFLongformerBaseModelOutputWithPooling
< source >( 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 global_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, 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(tf.Tensor), 可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —tf.Tensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, x)，其中x是帶有全域性注意力掩碼的詞元數量。注意力 softmax 之後的全域性注意力權重，用於計算自注意力頭中的加權平均值。這些是每個具有全域性注意力的詞元到序列中每個詞元的注意力權重。
Longformer 輸出的基類，也包含最後隱藏狀態的池化。
class transformers.models.longformer.modeling_tf_longformer.TFLongformerMaskedLMOutput
< source >( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor, ...] | None = None attentions: tuple[tf.Tensor, ...] | None = None global_attentions: tuple[tf.Tensor, ...] | None = None )
引數
- loss (
tf.Tensor，形狀為(1,)，可選，在提供了labels時返回) — 掩碼語言建模 (MLM) 損失。 - logits (
tf.Tensor，形狀為(batch_size, sequence_length, config.vocab_size)) — 語言建模頭的預測分數（SoftMax之前每個詞彙標記的分數）。 - 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 + 1個值指的是具有相對位置的標記：一個標記對其自身的注意力權重位於索引x + attention_window / 2，而前面（後面）的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 後的全域性注意力權重，用於在自注意力頭中計算加權平均值。這些是從每個具有全域性注意力的標記到序列中每個標記的注意力權重。
掩碼語言模型輸出的基類。
class transformers.models.longformer.modeling_tf_longformer.TFLongformerQuestionAnsweringModelOutput
< source >( 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 global_attentions: tuple[tf.Tensor, ...] | None = None )
引數
- loss (
tf.Tensor，形狀為(1,)，可選，在提供了labels時返回) — 總的答案片段抽取損失，是起始位置和結束位置的交叉熵損失之和。 - start_logits (
tf.Tensor，形狀為(batch_size, sequence_length)) — 答案片段的起始位置分數（SoftMax之前）。 - end_logits (
tf.Tensor，形狀為(batch_size, sequence_length)) — 答案片段的結束位置分數（SoftMax之前）。 - 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 + 1個值指的是具有相對位置的標記：一個標記對其自身的注意力權重位於索引x + attention_window / 2，而前面（後面）的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.longformer.modeling_tf_longformer.TFLongformerSequenceClassifierOutput
< source >( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor, ...] | None = None attentions: tuple[tf.Tensor, ...] | None = None global_attentions: tuple[tf.Tensor, ...] | None = None )
引數
- loss (
tf.Tensor，形狀為(1,)，可選，在提供了labels時返回) — 分類（如果 config.num_labels==1，則為迴歸）損失。 - logits (
tf.Tensor，形狀為(batch_size, config.num_labels)) — 分類（如果 config.num_labels==1，則為迴歸）分數（SoftMax之前）。 - 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 + 1個值指的是具有相對位置的標記：一個標記對其自身的注意力權重位於索引x + attention_window / 2，而前面（後面）的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 後的全域性注意力權重，用於在自注意力頭中計算加權平均值。這些是從每個具有全域性注意力的標記到序列中每個標記的注意力權重。
句子分類模型輸出的基類。
class transformers.models.longformer.modeling_tf_longformer.TFLongformerMultipleChoiceModelOutput
< source >( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor, ...] | None = None attentions: tuple[tf.Tensor, ...] | None = None global_attentions: tuple[tf.Tensor, ...] | None = None )
引數
- loss (
tf.Tensor，形狀為 (1,)，可選，在提供了labels時返回) — 分類損失。 - logits (
tf.Tensor，形狀為(batch_size, num_choices)) — num_choices 是輸入張量的第二個維度。（參見上面的 input_ids）。分類分數（SoftMax之前）。
- 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 + 1個值指的是具有相對位置的標記：一個標記對其自身的注意力權重位於索引x + attention_window / 2，而前面（後面）的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 後的全域性注意力權重，用於在自注意力頭中計算加權平均值。這些是從每個具有全域性注意力的標記到序列中每個標記的注意力權重。
多項選擇模型輸出的基類。
class transformers.models.longformer.modeling_tf_longformer.TFLongformerTokenClassifierOutput
< source >( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor, ...] | None = None attentions: tuple[tf.Tensor, ...] | None = None global_attentions: tuple[tf.Tensor, ...] | None = None )
引數
- loss (
tf.Tensor，形狀為(1,)，可選，在提供了labels時返回) — 分類損失。 - logits (
tf.Tensor，形狀為(batch_size, sequence_length, config.num_labels)) — 分類分數（SoftMax之前）。 - 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 + 1個值指的是具有相對位置的標記：一個標記對其自身的注意力權重位於索引x + attention_window / 2，而前面（後面）的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 後的全域性注意力權重，用於在自注意力頭中計算加權平均值。這些是從每個具有全域性注意力的標記到序列中每個標記的注意力權重。
Token分類模型輸出的基類。
LongformerModel
class transformers.LongformerModel
< source >( config add_pooling_layer = True )
引數
- config (LongformerModel) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
- add_pooling_layer (
bool, 可選, 預設為True) — 是否新增池化層。
基礎的 Longformer 模型，輸出原始的隱藏狀態，頂部沒有任何特定的頭。
此模型繼承自 PreTrainedModel。請查閱超類文件以瞭解該庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪注意力頭等）。
該模型也是一個 PyTorch torch.nn.Module 子類。可以像常規 PyTorch Module 一樣使用它，並參考 PyTorch 文件瞭解所有與常規用法和行為相關的事項。
forward
< source >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None global_attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 詞彙表中輸入序列標記的索引。預設情況下，填充將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於避免在填充標記索引上執行注意力的掩碼。掩碼值選自[0, 1]：- 1 表示標記未被遮蓋，
- 0 表示標記被遮蓋。
- global_attention_mask (
torch.FloatTensor，形狀為(batch_size, sequence_length)，可選) — 用於決定對每個標記應用何種注意力的掩碼，區域性注意力或全域性注意力。具有全域性注意力的標記會關注所有其他標記，並且所有其他標記也會關注它們。這對於特定任務的微調非常重要，因為它使模型在表示任務方面更加靈活。例如，對於分類任務，標記應給予全域性注意力。對於問答任務，所有問題標記也應具有全域性注意力。請參閱 Longformer 論文 瞭解更多細節。掩碼值選自[0, 1]：- 0 表示區域性注意力（滑動視窗注意力），
- 1 表示全域性注意力（標記會關注所有其他標記，並且所有其他標記也會關注它們）。
- head_mask (
torch.Tensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於置零自注意力模組中選定頭的掩碼。掩碼值選自[0, 1]：- 1 表示頭未被遮蓋，
- 0 表示頭被遮蓋。
- token_type_ids (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 片段標記索引，用於指示輸入的第一部分和第二部分。索引在[0, 1]中選擇：- 0 對應於 句子 A 的標記，
- 1 對應於 句子 B 的標記。
- position_ids (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 每個輸入序列標記在位置嵌入中的位置索引。在[0, config.n_positions - 1]範圍內選擇。 - inputs_embeds (
torch.Tensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 可選地，你可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果你希望比模型內部的嵌入查詢矩陣有更多控制權來將input_ids索引轉換為相關向量，這將非常有用。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool，可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。
返回
transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
一個 transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling 或一個 torch.FloatTensor 的元組（如果傳遞了 return_dict=False 或 config.return_dict=False），根據配置 (LongformerConfig) 和輸入包含不同的元素。
-
last_hidden_state (
<class 'torch.FloatTensor'>.last_hidden_state，形狀為(batch_size, sequence_length, hidden_size)) — 模型最後一層輸出的隱藏狀態序列。 -
pooler_output (
torch.FloatTensor，形狀為(batch_size, hidden_size)) — 序列第一個標記（分類標記）的最後一層隱藏狀態，經過一個線性層和一個 Tanh 啟用函式進一步處理。該線性層的權重在預訓練期間透過下一句預測（分類）目標進行訓練。 -
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, 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)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, x)，其中x是具有全域性注意力掩碼的標記數量。注意力 softmax 之後的全域性注意力權重，用於計算自注意力頭中的加權平均值。這些是每個具有全域性注意力的標記對序列中每個標記的注意力權重。
LongformerModel 的前向方法，重寫了 __call__ 特殊方法。
儘管前向傳播的流程需要在此函式內定義，但之後應呼叫 Module 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> import torch
>>> from transformers import LongformerModel, AutoTokenizer
>>> model = LongformerModel.from_pretrained("allenai/longformer-base-4096")
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> SAMPLE_TEXT = " ".join(["Hello world! "] * 1000) # long input document
>>> input_ids = torch.tensor(tokenizer.encode(SAMPLE_TEXT)).unsqueeze(0) # batch of size 1
>>> attention_mask = torch.ones(
... input_ids.shape, dtype=torch.long, device=input_ids.device
... ) # initialize to local attention
>>> global_attention_mask = torch.zeros(
... input_ids.shape, dtype=torch.long, device=input_ids.device
... ) # initialize to global attention to be deactivated for all tokens
>>> global_attention_mask[
... :,
... [
... 1,
... 4,
... 21,
... ],
... ] = 1 # Set global attention to random tokens for the sake of this example
>>> # Usually, set global attention based on the task. For example,
>>> # classification: the <s> token
>>> # QA: question tokens
>>> # LM: potentially on the beginning of sentences and paragraphs
>>> outputs = model(input_ids, attention_mask=attention_mask, global_attention_mask=global_attention_mask)
>>> sequence_output = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_outputLongformerForMaskedLM
class transformers.LongformerForMaskedLM
< 來源 >( config )
引數
- config (LongformerForMaskedLM) — 模型配置類，包含模型的所有引數。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
帶有一個 `語言建模` 頭的 Longformer 模型。
此模型繼承自 PreTrainedModel。請查閱超類文件以瞭解該庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪注意力頭等）。
該模型也是一個 PyTorch torch.nn.Module 子類。可以像常規 PyTorch Module 一樣使用它，並參考 PyTorch 文件瞭解所有與常規用法和行為相關的事項。
forward
< 來源 >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None global_attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 詞彙表中輸入序列標記的索引。預設情況下，填充將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於避免在填充標記索引上執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被掩碼，
- 0 表示標記被掩碼。
- global_attention_mask (
torch.FloatTensor，形狀為(batch_size, sequence_length)，可選) — 用於決定每個標記的注意力型別，是區域性注意力還是全域性注意力的掩碼。具有全域性注意力的標記會關注所有其他標記，而所有其他標記也會關注它們。這對於特定任務的微調非常重要，因為它使模型在表示任務方面更加靈活。例如，對於分類任務，標記應給予全域性注意力。對於問答任務，所有問題標記也應具有全域性注意力。請參閱 Longformer 論文 瞭解更多詳情。掩碼值在[0, 1]中選擇：- 0 表示區域性注意力（滑動視窗注意力），
- 1 表示全域性注意力（標記關注所有其他標記，並且所有其他標記都關注它們）。
- head_mask (
torch.Tensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於將自注意力模組中選定的頭置零的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭未被掩碼，
- 0 表示頭被掩碼。
- token_type_ids (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 片段標記索引，用於指示輸入的第一部分和第二部分。索引在[0, 1]中選擇：- 0 對應於 句子 A 的標記，
- 1 對應於 句子 B 的標記。
- position_ids (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 每個輸入序列標記在位置嵌入中的位置索引。在[0, config.n_positions - 1]範圍內選擇。 - inputs_embeds (
torch.Tensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 可選地，你可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果你希望比模型內部的嵌入查詢矩陣有更多控制權來將input_ids索引轉換為相關向量，這將非常有用。 - labels (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 用於計算掩碼語言建模損失的標籤。索引應在[-100, 0, ..., config.vocab_size]範圍內（參見input_ids文件字串）。索引設定為-100的標記將被忽略（掩碼），損失僅針對標籤在[0, ..., config.vocab_size]範圍內的標記計算。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool，可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。
返回
transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput 或 tuple(torch.FloatTensor)
一個 transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput 或一個 torch.FloatTensor 的元組（如果傳遞了 return_dict=False 或 config.return_dict=False），根據配置 (LongformerConfig) 和輸入包含不同的元素。
-
loss (形狀為
(1,)的torch.FloatTensor，可選，當提供labels時返回) — 掩碼語言建模 (MLM) 損失。 -
logits (形狀為
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 語言建模頭部的預測分數（SoftMax 之前的每個詞彙標記的分數）。 -
hidden_states (
tuple[torch.FloatTensor, ...]，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（一個用於嵌入層的輸出，如果模型有嵌入層，+ 每個層的輸出一個），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
attentions (
tuple(torch.FloatTensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, 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)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, x)，其中x是具有全域性注意力掩碼的標記數量。注意力 softmax 之後的全域性注意力權重，用於計算自注意力頭中的加權平均值。這些是每個具有全域性注意力的標記對序列中每個標記的注意力權重。
LongformerForMaskedLM 的前向方法，重寫了 __call__ 特殊方法。
儘管前向傳播的流程需要在此函式內定義，但之後應呼叫 Module 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
掩碼填充示例
>>> from transformers import AutoTokenizer, LongformerForMaskedLM
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = LongformerForMaskedLM.from_pretrained("allenai/longformer-base-4096")讓我們嘗試一個非常長的輸入。
>>> TXT = (
... "My friends are <mask> but they eat too many carbs."
... + " That's why I decide not to eat with them." * 300
... )
>>> input_ids = tokenizer([TXT], return_tensors="pt")["input_ids"]
>>> logits = model(input_ids).logits
>>> masked_index = (input_ids[0] == tokenizer.mask_token_id).nonzero().item()
>>> probs = logits[0, masked_index].softmax(dim=0)
>>> values, predictions = probs.topk(5)
>>> tokenizer.decode(predictions).split()
['healthy', 'skinny', 'thin', 'good', 'vegetarian']LongformerForSequenceClassification
class transformers.LongformerForSequenceClassification
< 來源 >( config )
引數
- config (LongformerForSequenceClassification) — 模型配置類，包含模型的所有引數。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
Longformer 模型 transformer，帶有一個序列分類/迴歸頭（在池化輸出之上加一個線性層），例如用於 GLUE 任務。
此模型繼承自 PreTrainedModel。請查閱超類文件以瞭解該庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪注意力頭等）。
該模型也是一個 PyTorch torch.nn.Module 子類。可以像常規 PyTorch Module 一樣使用它，並參考 PyTorch 文件瞭解所有與常規用法和行為相關的事項。
forward
< 來源 >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None global_attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 詞彙表中輸入序列標記的索引。預設情況下，填充將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於避免在填充標記索引上執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被掩碼，
- 0 表示標記被掩碼。
- global_attention_mask (
torch.FloatTensor，形狀為(batch_size, sequence_length)，可選) — 用於決定每個標記的注意力型別，是區域性注意力還是全域性注意力的掩碼。具有全域性注意力的標記會關注所有其他標記，而所有其他標記也會關注它們。這對於特定任務的微調非常重要，因為它使模型在表示任務方面更加靈活。例如，對於分類任務，標記應給予全域性注意力。對於問答任務，所有問題標記也應具有全域性注意力。請參閱 Longformer 論文 瞭解更多詳情。掩碼值在[0, 1]中選擇：- 0 表示區域性注意力（滑動視窗注意力），
- 1 表示全域性注意力（標記關注所有其他標記，並且所有其他標記都關注它們）。
- head_mask (
torch.Tensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於將自注意力模組中選定的頭置零的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭未被掩碼，
- 0 表示頭被掩碼。
- token_type_ids (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 片段標記索引，用於指示輸入的第一部分和第二部分。索引在[0, 1]中選擇：- 0 對應於 句子 A 的標記，
- 1 對應於 句子 B 的標記。
- position_ids (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 每個輸入序列標記在位置嵌入中的位置索引。在[0, config.n_positions - 1]範圍內選擇。 - inputs_embeds (
torch.Tensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 可選地，你可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果你希望比模型內部的嵌入查詢矩陣有更多控制權來將input_ids索引轉換為相關向量，這將非常有用。 - labels (
torch.LongTensor，形狀為(batch_size,)，可選) — 用於計算序列分類/迴歸損失的標籤。索引應在[0, ..., config.num_labels - 1]範圍內。如果config.num_labels == 1，則計算迴歸損失（均方損失），如果config.num_labels > 1，則計算分類損失（交叉熵）。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool，可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。
返回
transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput 或 tuple(torch.FloatTensor)
一個 transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput 或一個 torch.FloatTensor 的元組（如果傳遞了 return_dict=False 或 config.return_dict=False），根據配置 (LongformerConfig) 和輸入包含不同的元素。
-
loss (形狀為
(1,)的torch.FloatTensor，可選，當提供labels時返回) — 分類損失（如果 config.num_labels==1，則為迴歸損失）。 -
logits (形狀為
(batch_size, config.num_labels)的torch.FloatTensor) — 分類（如果 config.num_labels==1，則為迴歸）分數（SoftMax 之前）。 -
hidden_states (
tuple[torch.FloatTensor, ...]，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（一個用於嵌入層的輸出，如果模型有嵌入層，+ 每個層的輸出一個），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
attentions (
tuple(torch.FloatTensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, 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)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, x)，其中x是具有全域性注意力掩碼的標記數量。注意力 softmax 之後的全域性注意力權重，用於計算自注意力頭中的加權平均值。這些是每個具有全域性注意力的標記對序列中每個標記的注意力權重。
LongformerForSequenceClassification 的前向方法，重寫了 __call__ 特殊方法。
儘管前向傳播的流程需要在此函式內定義，但之後應呼叫 Module 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
單標籤分類示例
>>> import torch
>>> from transformers import AutoTokenizer, LongformerForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = LongformerForSequenceClassification.from_pretrained("allenai/longformer-base-4096")
>>> 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 = LongformerForSequenceClassification.from_pretrained("allenai/longformer-base-4096", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...多標籤分類示例
>>> import torch
>>> from transformers import AutoTokenizer, LongformerForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = LongformerForSequenceClassification.from_pretrained("allenai/longformer-base-4096", 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 = LongformerForSequenceClassification.from_pretrained(
... "allenai/longformer-base-4096", 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).lossLongformerForMultipleChoice
class transformers.LongformerForMultipleChoice
< 來源 >( config )
引數
- config (LongformerForMultipleChoice) — 模型配置類，包含模型的所有引數。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
帶有多項選擇分類頭的 Longformer 模型（在池化輸出之上加一個線性層和一個 softmax），例如用於 RocStories/SWAG 任務。
此模型繼承自 PreTrainedModel。請查閱超類文件以瞭解該庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪注意力頭等）。
該模型也是一個 PyTorch torch.nn.Module 子類。可以像常規 PyTorch Module 一樣使用它，並參考 PyTorch 文件瞭解所有與常規用法和行為相關的事項。
forward
< 來源 >( input_ids: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None global_attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor，形狀為(batch_size, num_choices, sequence_length)) — 詞彙表中輸入序列標記的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- token_type_ids (
torch.LongTensor，形狀為(batch_size, num_choices, sequence_length)，可選) — 片段標記索引，用於指示輸入的第一部分和第二部分。索引在[0, 1]中選擇：- 0 對應於 句子 A 的標記，
- 1 對應於 句子 B 的標記。
- attention_mask (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於避免在填充標記索引上執行注意力機制的掩碼。掩碼值選自[0, 1]：- 1 表示標記未被掩碼，
- 0 表示標記已被掩碼。
- global_attention_mask (
torch.FloatTensor，形狀為(batch_size, num_choices, sequence_length)，可選) — 用於決定對每個標記應用區域性注意力還是全域性注意力的掩碼。具有全域性注意力的標記會關注所有其他標記，而所有其他標記也會關注它們。這對於特定任務的微調非常重要，因為它使模型在表示任務時更具靈活性。例如，對於分類任務，標記應給予全域性注意力。對於問答任務，所有問題標記也應具有全域性注意力。請參閱 Longformer 論文瞭解更多詳情。掩碼值選自[0, 1]：- 0 表示區域性注意力（滑動視窗注意力），
- 1 表示全域性注意力（標記會關注所有其他標記，而所有其他標記也會關注它們）。
- head_mask (
torch.Tensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於使自注意力模組中選定的頭無效的掩碼。掩碼值選自[0, 1]：- 1 表示該頭未被掩碼，
- 0 表示該頭已被掩碼。
- labels (
torch.LongTensor，形狀為(batch_size,)，可選) — 用於計算多項選擇分類損失的標籤。索引應在[0, ..., num_choices-1]範圍內，其中num_choices是輸入張量第二個維度的大小。（見上面的input_ids） - position_ids (
torch.LongTensor，形狀為(batch_size, num_choices, sequence_length)，可選) — 位置嵌入中每個輸入序列標記的位置索引。選自[0, config.max_position_embeddings - 1]範圍。 - inputs_embeds (
torch.FloatTensor，形狀為(batch_size, num_choices, sequence_length, hidden_size)，可選) — 或者，你可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果你想比模型內部的嵌入查詢矩陣更好地控制如何將input_ids索引轉換為相關向量，這會非常有用。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool，可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。
返回
transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput 或一個 torch.FloatTensor 的元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），根據配置（LongformerConfig）和輸入，包含各種元素。
-
loss (形狀為 (1,) 的
torch.FloatTensor，可選，當提供labels時返回) — 分類損失。 -
logits (形狀為
(batch_size, num_choices)的torch.FloatTensor) — 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, 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)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, x)，其中x是具有全域性注意力掩碼的標記數量。注意力 softmax 之後的全域性注意力權重，用於計算自注意力頭中的加權平均值。這些是每個具有全域性注意力的標記對序列中每個標記的注意力權重。
LongformerForMultipleChoice 的前向方法會覆蓋 __call__ 特殊方法。
儘管前向傳播的流程需要在此函式內定義，但之後應呼叫 Module 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> from transformers import AutoTokenizer, LongformerForMultipleChoice
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = LongformerForMultipleChoice.from_pretrained("allenai/longformer-base-4096")
>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0) # choice0 is correct (according to Wikipedia ;)), batch size 1
>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels) # batch size is 1
>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logitsLongformerForTokenClassification
class transformers.LongformerForTokenClassification
< 來源 >( config )
引數
- config (LongformerForTokenClassification) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
帶有詞元分類頭的 Longformer transformer（在隱藏狀態輸出之上加一個線性層），例如用於命名實體識別（NER）任務。
此模型繼承自 PreTrainedModel。請查閱超類文件以瞭解該庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪注意力頭等）。
該模型也是一個 PyTorch torch.nn.Module 子類。可以像常規 PyTorch Module 一樣使用它，並參考 PyTorch 文件瞭解所有與常規用法和行為相關的事項。
forward
< 來源 >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None global_attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 詞彙表中輸入序列標記的索引。預設情況下，填充將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於避免在填充標記索引上執行注意力機制的掩碼。掩碼值選自[0, 1]：- 1 表示標記未被掩碼，
- 0 表示標記已被掩碼。
- global_attention_mask (
torch.FloatTensor，形狀為(batch_size, sequence_length)，可選) — 用於決定對每個標記應用區域性注意力還是全域性注意力的掩碼。具有全域性注意力的標記會關注所有其他標記，而所有其他標記也會關注它們。這對於特定任務的微調非常重要，因為它使模型在表示任務時更具靈活性。例如，對於分類任務，標記應給予全域性注意力。對於問答任務，所有問題標記也應具有全域性注意力。請參閱 Longformer 論文瞭解更多詳情。掩碼值選自[0, 1]：- 0 表示區域性注意力（滑動視窗注意力），
- 1 表示全域性注意力（標記會關注所有其他標記，而所有其他標記也會關注它們）。
- head_mask (
torch.Tensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於使自注意力模組中選定的頭無效的掩碼。掩碼值選自[0, 1]：- 1 表示該頭未被掩碼，
- 0 表示該頭已被掩碼。
- token_type_ids (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 段標記索引，用於指示輸入的第一部分和第二部分。索引選自[0, 1]：- 0 對應於 *句子 A* 標記，
- 1 對應於 *句子 B* 標記。
- position_ids (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 位置嵌入中每個輸入序列標記的位置索引。選自[0, config.n_positions - 1]範圍。 - inputs_embeds (
torch.Tensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 或者，你可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果你想比模型內部的嵌入查詢矩陣更好地控制如何將input_ids索引轉換為相關向量，這會非常有用。 - labels (
torch.LongTensor，形狀為(batch_size, sequence_length)，可選) — 用於計算詞元分類損失的標籤。索引應在[0, ..., config.num_labels - 1]範圍內。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool，可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。
返回
transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput 或 tuple(torch.FloatTensor)
一個 transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput 或一個 torch.FloatTensor 的元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），根據配置（LongformerConfig）和輸入，包含各種元素。
-
loss (形狀為
(1,)的torch.FloatTensor，可選，當提供labels時返回) — 分類損失。 -
logits (形狀為
(batch_size, sequence_length, config.num_labels)的torch.FloatTensor) — 分類分數（SoftMax 之前）。 -
hidden_states (
tuple[torch.FloatTensor, ...]，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —torch.FloatTensor的元組（一個用於嵌入層的輸出，如果模型有嵌入層，+ 每個層的輸出一個），形狀為(batch_size, sequence_length, hidden_size)。模型在每個層輸出的隱藏狀態以及可選的初始嵌入輸出。
-
attentions (
tuple(torch.FloatTensor)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, 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)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, x)，其中x是具有全域性注意力掩碼的標記數量。注意力 softmax 之後的全域性注意力權重，用於計算自注意力頭中的加權平均值。這些是每個具有全域性注意力的標記對序列中每個標記的注意力權重。
LongformerForTokenClassification 的前向方法會覆蓋 __call__ 特殊方法。
儘管前向傳播的流程需要在此函式內定義，但之後應呼叫 Module 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> from transformers import AutoTokenizer, LongformerForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = LongformerForTokenClassification.from_pretrained("allenai/longformer-base-4096")
>>> inputs = tokenizer(
... "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_token_class_ids = logits.argmax(-1)
>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes
...
>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...LongformerForQuestionAnswering
class transformers.LongformerForQuestionAnswering
< 來源 >( config )
引數
- config (LongformerForQuestionAnswering) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
帶有片段分類頭的 Longformer transformer，用於像 SQuAD 這樣的抽取式問答任務（在隱藏狀態輸出之上加一個線性層來計算 `片段開始 logits` 和 `片段結束 logits`）。
此模型繼承自 PreTrainedModel。請查閱超類文件以瞭解該庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪注意力頭等）。
該模型也是一個 PyTorch torch.nn.Module 子類。可以像常規 PyTorch Module 一樣使用它，並參考 PyTorch 文件瞭解所有與常規用法和行為相關的事項。
forward
< 來源 >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None global_attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None start_positions: typing.Optional[torch.Tensor] = None end_positions: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 詞彙表中輸入序列標記的索引。預設情況下，填充將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於避免在填充標記索引上執行注意力機制的掩碼。掩碼值選自[0, 1]：- 1 表示標記未被掩碼，
- 0 表示標記已被掩碼。
- global_attention_mask (
torch.FloatTensor，形狀為(batch_size, sequence_length)，可選) — 用於決定對每個標記應用區域性注意力還是全域性注意力的掩碼。具有全域性注意力的標記會關注所有其他標記，而所有其他標記也會關注它們。這對於特定任務的微調非常重要，因為它使模型在表示任務時更具靈活性。例如，對於分類任務，標記應給予全域性注意力。對於問答任務，所有問題標記也應具有全域性注意力。請參閱 Longformer 論文瞭解更多詳情。掩碼值選自[0, 1]：- 0 表示區域性注意力（滑動視窗注意力），
- 1 表示全域性注意力（標記會關注所有其他標記，而所有其他標記也會關注它們）。
- head_mask (
torch.Tensor，形狀為(num_heads,)或(num_layers, num_heads)，可選) — 用於使自注意力模組中選定的頭無效的掩碼。掩碼值選自[0, 1]：- 1 表示該頭未被掩碼，
- 0 表示該頭已被掩碼。
- token_type_ids (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 段標記索引，用於指示輸入的第一部分和第二部分。索引選自[0, 1]：- 0 對應於 *句子 A* 標記，
- 1 對應於 *句子 B* 標記。
- position_ids (
torch.Tensor，形狀為(batch_size, sequence_length)，可選) — 位置嵌入中每個輸入序列標記的位置索引。選自[0, config.n_positions - 1]範圍。 - inputs_embeds (
torch.Tensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — 或者，你可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果你想比模型內部的嵌入查詢矩陣更好地控制如何將input_ids索引轉換為相關向量，這會非常有用。 - start_positions (
torch.Tensor，形狀為(batch_size,)，可選) — 標記的片段開始位置（索引）的標籤，用於計算詞元分類損失。位置被限制在序列長度（sequence_length）內。序列之外的位置在計算損失時不予考慮。 - end_positions (
torch.Tensor，形狀為(batch_size,)，可選) — 標記的片段結束位置（索引）的標籤，用於計算詞元分類損失。位置被限制在序列長度（sequence_length）內。序列之外的位置在計算損失時不予考慮。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool，可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。
返回
transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput 或一個 torch.FloatTensor 的元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），根據配置（LongformerConfig）和輸入，包含各種元素。
-
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 之前）。 -
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, 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)，可選，當傳遞output_attentions=True或config.output_attentions=True時返回) —torch.FloatTensor的元組（每層一個），形狀為(batch_size, num_heads, sequence_length, x)，其中x是具有全域性注意力掩碼的標記數量。注意力 softmax 之後的全域性注意力權重，用於計算自注意力頭中的加權平均值。這些是每個具有全域性注意力的標記對序列中每個標記的注意力權重。
LongformerForQuestionAnswering 的前向方法會覆蓋 __call__ 特殊方法。
儘管前向傳播的流程需要在此函式內定義，但之後應呼叫 Module 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> from transformers import AutoTokenizer, LongformerForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-large-4096-finetuned-triviaqa")
>>> model = LongformerForQuestionAnswering.from_pretrained("allenai/longformer-large-4096-finetuned-triviaqa")
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> encoding = tokenizer(question, text, return_tensors="pt")
>>> input_ids = encoding["input_ids"]
>>> # default is local attention everywhere
>>> # the forward method will automatically set global attention on question tokens
>>> attention_mask = encoding["attention_mask"]
>>> outputs = model(input_ids, attention_mask=attention_mask)
>>> start_logits = outputs.start_logits
>>> end_logits = outputs.end_logits
>>> all_tokens = tokenizer.convert_ids_to_tokens(input_ids[0].tolist())
>>> answer_tokens = all_tokens[torch.argmax(start_logits) : torch.argmax(end_logits) + 1]
>>> answer = tokenizer.decode(
... tokenizer.convert_tokens_to_ids(answer_tokens)
... ) # remove space prepending space tokenTFLongformerModel
class transformers.TFLongformerModel
< 來源 >( config *inputs **kwargs )
引數
- config (LongformerConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
基礎的 Longformer 模型，輸出原始的隱藏狀態，頂部沒有任何特定的頭。
該模型繼承自 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 函式一樣傳遞輸入！
該類複製了 TFRobertaModel 的程式碼，並用 Longformer 自注意力機制覆蓋了標準的自注意力機制，以提供處理長序列的能力。這遵循了 Iz Beltagy、Matthew E. Peters 和 Arman Cohan 在 Longformer: the Long-Document Transformer 中描述的自注意力方法。Longformer 自注意力結合了局部（滑動視窗）和全域性注意力，以擴充套件到長文件，而不會導致記憶體和計算量呈 O(n^2) 增長。
此處實現的自注意力模組 TFLongformerSelfAttention 支援區域性和全域性注意力的組合，但它不支援自迴歸注意力和擴張注意力。自迴歸和擴張注意力更多地與自迴歸語言建模相關，而不是在下游任務上進行微調。未來的版本將增加對自迴歸注意力的支援，但要高效地支援擴張注意力，則需要一個自定義的 CUDA 核心來實現記憶體和計算效率。
呼叫
< source >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None global_attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False )
引數
- input_ids (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被遮蔽，
- 0 表示標記已被遮蔽。
- head_mask (
np.ndarray或tf.Tensor，形狀為(encoder_layers, encoder_attention_heads)，可選) — 用於遮蔽注意力模組中選定頭的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭未被遮蔽，
- 0 表示頭已被遮蔽。
- global_attention_mask (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於決定每個標記上應用的注意力型別（區域性注意力或全域性注意力）的掩碼。具有全域性注意力的標記會關注所有其他標記，而所有其他標記也會關注它們。這對於特定任務的微調非常重要，因為它使模型在表示任務方面更加靈活。例如，對於分類任務，標記應給予全域性注意力。對於問答任務，所有問題標記也應具有全域性注意力。請參閱 Longformer 論文 瞭解更多詳情。掩碼值在[0, 1]中選擇：- 0 表示區域性注意力（滑動視窗注意力），
- 1 表示全域性注意力（標記會關注所有其他標記，而所有其他標記也會關注它們）。
- token_type_ids (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length)，可選) — 片段標記索引，用於指示輸入的第一部分和第二部分。索引在[0, 1]中選擇：- 0 對應於 *句子 A* 的標記，
- 1 對應於 *句子 B* 的標記。
- position_ids (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length)，可選) — 每個輸入序列標記在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]範圍內選擇。 - inputs_embeds (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — （可選）你可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果你希望比模型內部的嵌入查詢矩陣更能控制如何將input_ids索引轉換為關聯向量，這會很有用。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。此引數只能在 Eager 模式下使用，在圖模式下將使用配置中的值。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。此引數只能在 Eager 模式下使用，在圖模式下將使用配置中的值。 - return_dict (
bool，可選) — 是否返回 ModelOutput 而不是普通元組。此引數可以在 Eager 模式下使用，在圖模式下，該值將始終設定為 True。 - training (
bool，可選，預設為False) — 是否在訓練模式下使用模型（某些模組如 dropout 模組在訓練和評估之間有不同的行為）。
TFLongformerModel 的前向方法會覆蓋 __call__ 特殊方法。
儘管前向傳播的流程需要在此函式內定義，但之後應呼叫 Module 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
TFLongformerForMaskedLM
class transformers.TFLongformerForMaskedLM
< source >( config *inputs **kwargs )
引數
- config (LongformerConfig) — 模型配置類，包含模型的所有引數。使用配置檔案初始化不會載入與模型關聯的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
帶有 `language modeling` 頭的 Longformer 模型。
該模型繼承自 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 函式一樣傳遞輸入！
呼叫
< source >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None global_attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → transformers.models.longformer.modeling_tf_longformer.TFLongformerMaskedLMOutput 或 tuple(tf.Tensor)
引數
- input_ids (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被遮蔽，
- 0 表示標記已被遮蔽。
- head_mask (
np.ndarray或tf.Tensor，形狀為(encoder_layers, encoder_attention_heads)，可選) — 用於遮蔽注意力模組中選定頭的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭未被遮蔽，
- 0 表示頭已被遮蔽。
- global_attention_mask (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於決定每個標記上應用的注意力型別（區域性注意力或全域性注意力）的掩碼。具有全域性注意力的標記會關注所有其他標記，而所有其他標記也會關注它們。這對於特定任務的微調非常重要，因為它使模型在表示任務方面更加靈活。例如，對於分類任務，標記應給予全域性注意力。對於問答任務，所有問題標記也應具有全域性注意力。請參閱 Longformer 論文 瞭解更多詳情。掩碼值在[0, 1]中選擇：- 0 表示區域性注意力（滑動視窗注意力），
- 1 表示全域性注意力（標記會關注所有其他標記，而所有其他標記也會關注它們）。
- token_type_ids (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length)，可選) — 片段標記索引，用於指示輸入的第一部分和第二部分。索引在[0, 1]中選擇：- 0 對應於 *句子 A* 的標記，
- 1 對應於 *句子 B* 的標記。
- position_ids (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length)，可選) — 每個輸入序列標記在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]範圍內選擇。 - inputs_embeds (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — （可選）你可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果你希望比模型內部的嵌入查詢矩陣更能控制如何將input_ids索引轉換為關聯向量，這會很有用。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。此引數只能在 Eager 模式下使用，在圖模式下將使用配置中的值。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。此引數只能在 Eager 模式下使用，在圖模式下將使用配置中的值。 - return_dict (
bool，可選) — 是否返回 ModelOutput 而不是普通元組。此引數可以在 Eager 模式下使用，在圖模式下，該值將始終設定為 True。 - training (
bool，可選，預設為False) — 是否在訓練模式下使用模型（某些模組如 dropout 模組在訓練和評估之間有不同的行為）。 - labels (
tf.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於計算掩碼語言建模損失的標籤。索引應在[-100, 0, ..., config.vocab_size]範圍內（請參閱input_ids文件字串）。索引設定為-100的標記將被忽略（遮蔽），損失僅對標籤在[0, ..., config.vocab_size]範圍內的標記進行計算。
返回
transformers.models.longformer.modeling_tf_longformer.TFLongformerMaskedLMOutput 或 tuple(tf.Tensor)
一個 transformers.models.longformer.modeling_tf_longformer.TFLongformerMaskedLMOutput 或一個 tf.Tensor 的元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），根據配置（LongformerConfig）和輸入，包含各種元素。
-
loss (
tf.Tensor，形狀為(1,)，可選，當提供labels時返回) — 掩碼語言建模 (MLM) 損失。 -
logits (
tf.Tensorof shape(batch_size, sequence_length, config.vocab_size)) — 語言模型頭部的預測分數（SoftMax 之前每個詞彙標記的分數）。 -
hidden_states (
tuple(tf.Tensor)，可選，當傳遞output_hidden_states=True或config.output_hidden_states=True時返回) —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 + 1` 個值指的是相對位置的標記：一個標記對其自身的注意力權重位於索引 `x + attention_window / 2`，而前面（後面）的 `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 之後的全域性注意力權重，用於計算自注意力頭中的加權平均值。這些是每個具有全域性注意力的標記對序列中每個標記的注意力權重。
TFLongformerForMaskedLM 的前向方法會覆蓋 __call__ 特殊方法。
儘管前向傳播的流程需要在此函式內定義，但之後應呼叫 Module 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> from transformers import AutoTokenizer, TFLongformerForMaskedLM
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = TFLongformerForMaskedLM.from_pretrained("allenai/longformer-base-4096")
>>> inputs = tokenizer("The capital of France is <mask>.", return_tensors="tf")
>>> logits = model(**inputs).logits
>>> # retrieve index of <mask>
>>> mask_token_index = tf.where((inputs.input_ids == tokenizer.mask_token_id)[0])
>>> selected_logits = tf.gather_nd(logits[0], indices=mask_token_index)
>>> predicted_token_id = tf.math.argmax(selected_logits, axis=-1)
>>> tokenizer.decode(predicted_token_id)
' Paris'TFLongformerForQuestionAnswering
class transformers.TFLongformerForQuestionAnswering
< source >( config *inputs **kwargs )
引數
- config (LongformerConfig) — 模型配置類，包含模型的所有引數。使用配置檔案初始化不會載入與模型關聯的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
帶有片段分類頭的 Longformer 模型，用於抽取式問答任務，如 SQuAD / TriviaQA（在隱藏狀態輸出之上有一個線性層，用於計算 `span start logits` 和 `span end logits`）。
該模型繼承自 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 函式一樣傳遞輸入！
呼叫
< source >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None global_attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None start_positions: np.ndarray | tf.Tensor | None = None end_positions: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → transformers.models.longformer.modeling_tf_longformer.TFLongformerQuestionAnsweringModelOutput 或 tuple(tf.Tensor)
引數
- input_ids (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被遮蔽，
- 0 表示標記已被遮蔽。
- head_mask (
np.ndarray或tf.Tensor，形狀為(encoder_layers, encoder_attention_heads)，可選) — 用於遮蔽注意力模組中選定頭的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭未被遮蔽，
- 0 表示頭已被遮蔽。
- global_attention_mask (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length)，可選) — 用於決定每個標記上應用的注意力型別（區域性注意力或全域性注意力）的掩碼。具有全域性注意力的標記會關注所有其他標記，而所有其他標記也會關注它們。這對於特定任務的微調非常重要，因為它使模型在表示任務方面更加靈活。例如，對於分類任務，標記應給予全域性注意力。對於問答任務，所有問題標記也應具有全域性注意力。請參閱 Longformer 論文 瞭解更多詳情。掩碼值在[0, 1]中選擇：- 0 表示區域性注意力（滑動視窗注意力），
- 1 表示全域性注意力（標記會關注所有其他標記，而所有其他標記也會關注它們）。
- token_type_ids (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length)，可選) — 片段標記索引，用於指示輸入的第一部分和第二部分。索引在[0, 1]中選擇：- 0 對應於 *句子 A* 的標記，
- 1 對應於 *句子 B* 的標記。
- position_ids (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length)，可選) — 每個輸入序列標記在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]範圍內選擇。 - inputs_embeds (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length, hidden_size)，可選) — （可選）你可以選擇直接傳遞嵌入表示，而不是傳遞input_ids。如果你希望比模型內部的嵌入查詢矩陣更能控制如何將input_ids索引轉換為關聯向量，這會很有用。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。此引數只能在 Eager 模式下使用，在圖模式下將使用配置中的值。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。此引數只能在 Eager 模式下使用，在圖模式下將使用配置中的值。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。此引數可在 Eager 模式下使用，在圖模式下該值將始終設定為 True。 - training (
bool, 可選, 預設為False) — 是否在訓練模式下使用模型（某些模組如 dropout 模組在訓練和評估模式下有不同的行為）。 - start_positions (
tf.Tensor，形狀為(batch_size,), 可選) — 用於計算詞元分類損失的標註範圍的起始位置（索引）標籤。位置被限制在序列長度（sequence_length）範圍內。序列之外的位置在計算損失時不會被考慮。 - end_positions (
tf.Tensor，形狀為(batch_size,), 可選) — 用於計算詞元分類損失的標註範圍的結束位置（索引）標籤。位置被限制在序列長度（sequence_length）範圍內。序列之外的位置在計算損失時不會被考慮。
返回
transformers.models.longformer.modeling_tf_longformer.TFLongformerQuestionAnsweringModelOutput 或 tuple(tf.Tensor)
一個 transformers.models.longformer.modeling_tf_longformer.TFLongformerQuestionAnsweringModelOutput 或一個 tf.Tensor 的元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），包含根據配置（LongformerConfig）和輸入而異的各種元素。
-
loss (
tf.Tensor，形狀為(1,), 可選, 當提供了labels時返回) — 總範圍提取損失是起始和結束位置交叉熵損失的和。 -
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時返回) —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 + 1` 個值指的是相對位置的標記：一個標記對其自身的注意力權重位於索引 `x + attention_window / 2`，而前面（後面）的 `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 之後的全域性注意力權重，用於計算自注意力頭中的加權平均值。這些是每個具有全域性注意力的標記對序列中每個標記的注意力權重。
TFLongformerForQuestionAnswering 的前向方法，重寫了 __call__ 特殊方法。
儘管前向傳播的流程需要在此函式內定義，但之後應呼叫 Module 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> from transformers import AutoTokenizer, TFLongformerForQuestionAnswering
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-large-4096-finetuned-triviaqa")
>>> model = TFLongformerForQuestionAnswering.from_pretrained("allenai/longformer-large-4096-finetuned-triviaqa")
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="tf")
>>> outputs = model(**inputs)
>>> answer_start_index = int(tf.math.argmax(outputs.start_logits, axis=-1)[0])
>>> answer_end_index = int(tf.math.argmax(outputs.end_logits, axis=-1)[0])
>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens)
' puppet'TFLongformerForSequenceClassification
class transformers.TFLongformerForSequenceClassification
< 來源 >( config *inputs **kwargs )
引數
- config (LongformerConfig) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
Longformer 模型 transformer，帶有一個序列分類/迴歸頭（在池化輸出之上加一個線性層），例如用於 GLUE 任務。
該模型繼承自 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 head_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None global_attention_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → transformers.models.longformer.modeling_tf_longformer.TFLongformerSequenceClassifierOutput 或 tuple(tf.Tensor)
引數
- input_ids (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列詞元的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length), 可選) — 用於避免在填充詞元索引上執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示詞元未被遮蔽，
- 0 表示詞元被遮蔽。
- head_mask (
np.ndarray或tf.Tensor，形狀為(encoder_layers, encoder_attention_heads), 可選) — 用於使注意力模組的選定頭無效的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭未被遮蔽，
- 0 表示頭被遮蔽。
- global_attention_mask (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length), 可選) — 用於決定每個詞元是使用區域性注意力還是全域性注意力的掩碼。具有全域性注意力的詞元會關注所有其他詞元，而所有其他詞元也會關注它們。這對於特定任務的微調非常重要，因為它使模型在表示任務時更靈活。例如，對於分類任務，詞元應被賦予全域性注意力。對於問答任務，所有問題詞元也應具有全域性注意力。請參閱 Longformer 論文 獲取更多詳細資訊。掩碼值在[0, 1]中選擇：- 0 表示區域性注意力（滑動視窗注意力），
- 1 表示全域性注意力（關注所有其他詞元的詞元，並且所有其他詞元都關注它們）。
- token_type_ids (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length), 可選) — 段詞元索引，用於指示輸入的第一部分和第二部分。索引在[0, 1]中選擇：- 0 對應於 *句子 A* 的詞元，
- 1 對應於 *句子 B* 的詞元。
- position_ids (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length), 可選) — 每個輸入序列詞元在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]範圍內選擇。 - inputs_embeds (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length, hidden_size), 可選) — 可選地，你可以不傳遞input_ids，而是直接傳遞一個嵌入表示。如果你想比模型的內部嵌入查詢矩陣更多地控制如何將input_ids索引轉換為關聯向量，這會很有用。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。此引數只能在 Eager 模式下使用，在圖模式下將使用配置中的值。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。此引數只能在 Eager 模式下使用，在圖模式下將使用配置中的值。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。此引數可在 Eager 模式下使用，在圖模式下該值將始終設定為 True。 - training (
bool, 可選, 預設為False) — 是否在訓練模式下使用模型（某些模組如 dropout 模組在訓練和評估模式下有不同的行為）。
返回
transformers.models.longformer.modeling_tf_longformer.TFLongformerSequenceClassifierOutput 或 tuple(tf.Tensor)
一個 transformers.models.longformer.modeling_tf_longformer.TFLongformerSequenceClassifierOutput 或一個 tf.Tensor 的元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），包含根據配置（LongformerConfig）和輸入而異的各種元素。
-
loss (形狀為
(1,)的tf.Tensor，可選，當提供labels時返回) — 分類（如果 config.num_labels==1，則為迴歸）損失。 -
logits (
tf.Tensor，形狀為(batch_size, config.num_labels)) — 分類（或迴歸，如果 config.num_labels==1）分數（SoftMax 之前）。 -
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 + 1` 個值指的是相對位置的標記：一個標記對其自身的注意力權重位於索引 `x + attention_window / 2`，而前面（後面）的 `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 之後的全域性注意力權重，用於計算自注意力頭中的加權平均值。這些是每個具有全域性注意力的標記對序列中每個標記的注意力權重。
TFLongformerForSequenceClassification 的前向方法，重寫了 __call__ 特殊方法。
儘管前向傳播的流程需要在此函式內定義，但之後應呼叫 Module 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> from transformers import AutoTokenizer, TFLongformerForSequenceClassification
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = TFLongformerForSequenceClassification.from_pretrained("allenai/longformer-base-4096")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> logits = model(**inputs).logits
>>> predicted_class_id = int(tf.math.argmax(logits, axis=-1)[0])>>> # 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 = TFLongformerForSequenceClassification.from_pretrained("allenai/longformer-base-4096", num_labels=num_labels)
>>> labels = tf.constant(1)
>>> loss = model(**inputs, labels=labels).lossTFLongformerForTokenClassification
class transformers.TFLongformerForTokenClassification
< 來源 >( config *inputs **kwargs )
引數
- config (LongformerConfig) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
Longformer 模型，其頂部帶有一個詞元分類頭（即在隱藏狀態輸出之上加一個線性層），例如用於命名實體識別（NER）任務。
該模型繼承自 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 head_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None global_attention_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: Optional[Union[np.array, tf.Tensor]] = None training: Optional[bool] = False ) → transformers.models.longformer.modeling_tf_longformer.TFLongformerTokenClassifierOutput 或 tuple(tf.Tensor)
引數
- input_ids (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列詞元的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length), 可選) — 用於避免在填充詞元索引上執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示詞元未被遮蔽，
- 0 表示詞元被遮蔽。
- head_mask (
np.ndarray或tf.Tensor，形狀為(encoder_layers, encoder_attention_heads), 可選) — 用於使注意力模組的選定頭無效的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭未被遮蔽，
- 0 表示頭被遮蔽。
- global_attention_mask (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length), 可選) — 用於決定每個詞元是使用區域性注意力還是全域性注意力的掩碼。具有全域性注意力的詞元會關注所有其他詞元，而所有其他詞元也會關注它們。這對於特定任務的微調非常重要，因為它使模型在表示任務時更靈活。例如，對於分類任務，詞元應被賦予全域性注意力。對於問答任務，所有問題詞元也應具有全域性注意力。請參閱 Longformer 論文 獲取更多詳細資訊。掩碼值在[0, 1]中選擇：- 0 表示區域性注意力（滑動視窗注意力），
- 1 表示全域性注意力（關注所有其他詞元的詞元，並且所有其他詞元都關注它們）。
- token_type_ids (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length), 可選) — 段詞元索引，用於指示輸入的第一部分和第二部分。索引在[0, 1]中選擇：- 0 對應於 *句子 A* 的詞元，
- 1 對應於 *句子 B* 的詞元。
- position_ids (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length), 可選) — 每個輸入序列詞元在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]範圍內選擇。 - inputs_embeds (
np.ndarray或tf.Tensor，形狀為(batch_size, sequence_length, hidden_size), 可選) — 可選地，你可以不傳遞input_ids，而是直接傳遞一個嵌入表示。如果你想比模型的內部嵌入查詢矩陣更多地控制如何將input_ids索引轉換為關聯向量，這會很有用。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。此引數只能在 Eager 模式下使用，在圖模式下將使用配置中的值。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。此引數只能在 Eager 模式下使用，在圖模式下將使用配置中的值。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。此引數可在 Eager 模式下使用，在圖模式下該值將始終設定為 True。 - training (
bool, 可選, 預設為False) — 是否在訓練模式下使用模型（某些模組如 dropout 模組在訓練和評估模式下有不同的行為）。 - labels (
tf.Tensor，形狀為(batch_size, sequence_length), 可選) — 用於計算詞元分類損失的標籤。索引應在[0, ..., config.num_labels - 1]範圍內。
返回
transformers.models.longformer.modeling_tf_longformer.TFLongformerTokenClassifierOutput 或 tuple(tf.Tensor)
一個 transformers.models.longformer.modeling_tf_longformer.TFLongformerTokenClassifierOutput 或一個 tf.Tensor 的元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），包含根據配置（LongformerConfig）和輸入而異的各種元素。
-
loss (
tf.Tensor，形狀為(1,), 可選, 當提供了labels時返回) — 分類損失。 -
logits (
tf.Tensor，形狀為(batch_size, sequence_length, config.num_labels)) — 分類分數（SoftMax 之前）。 -
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 + 1` 個值指的是相對位置的標記：一個標記對其自身的注意力權重位於索引 `x + attention_window / 2`，而前面（後面）的 `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 之後的全域性注意力權重，用於計算自注意力頭中的加權平均值。這些是每個具有全域性注意力的標記對序列中每個標記的注意力權重。
TFLongformerForTokenClassification 的前向方法，重寫了 __call__ 特殊方法。
儘管前向傳播的流程需要在此函式內定義，但之後應呼叫 Module 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> from transformers import AutoTokenizer, TFLongformerForTokenClassification
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = TFLongformerForTokenClassification.from_pretrained("allenai/longformer-base-4096")
>>> inputs = tokenizer(
... "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="tf"
... )
>>> logits = model(**inputs).logits
>>> predicted_token_class_ids = tf.math.argmax(logits, axis=-1)
>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t] for t in predicted_token_class_ids[0].numpy().tolist()]TFLongformerForMultipleChoice
class transformers.TFLongformerForMultipleChoice
< 來源 >( config *inputs **kwargs )
引數
- config (LongformerConfig) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
Longformer 模型，其頂部帶有一個多項選擇分類頭（即在池化輸出之上加一個線性層和一個 softmax），例如用於 RocStories/SWAG 任務。
該模型繼承自 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 head_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None global_attention_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → transformers.models.longformer.modeling_tf_longformer.TFLongformerMultipleChoiceModelOutput 或 tuple(tf.Tensor)
引數
- input_ids (
np.ndarray或tf.Tensor，形狀為(batch_size, num_choices, sequence_length)) — 詞彙表中輸入序列詞元的索引。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
np.ndarray或tf.Tensor，形狀為(batch_size, num_choices, sequence_length), 可選) — 用於避免在填充詞元索引上執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示詞元未被遮蔽，
- 0 表示詞元被遮蔽。
- head_mask (
np.ndarray或tf.Tensor，形狀為(encoder_layers, encoder_attention_heads), 可選) — 用於使注意力模組的選定頭無效的掩碼。掩碼值在[0, 1]中選擇：- 1 表示頭未被遮蔽，
- 0 表示頭被遮蔽。
- global_attention_mask (
np.ndarray或tf.Tensor，形狀為(batch_size, num_choices, sequence_length)，可選) — 用於決定每個詞元（token）是進行區域性注意力（local attention）還是全域性注意力（global attention）的掩碼。具有全域性注意力的詞元會關注所有其他詞元，同時所有其他詞元也會關注它們。這對於特定任務的微調非常重要，因為它使模型在表示任務時更加靈活。例如，對於分類任務，詞元應被賦予全域性注意力。對於問答任務，所有問題詞元也應具有全域性注意力。請參閱 Longformer 論文瞭解更多細節。掩碼值在[0, 1]中選擇：- 0 表示區域性注意力（滑動視窗注意力），
- 1 表示全域性注意力（關注所有其他詞元，並且所有其他詞元也關注它們的詞元）。
- token_type_ids (
np.ndarray或tf.Tensor，形狀為(batch_size, num_choices, sequence_length)，可選) — 片段詞元索引，用於指示輸入的第一部分和第二部分。索引在[0, 1]中選擇：- 0 對應於*句子 A* 的詞元，
- 1 對應於*句子 B* 的詞元。
- position_ids (
np.ndarray或tf.Tensor，形狀為(batch_size, num_choices, sequence_length)，可選) — 每個輸入序列詞元在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]範圍內選擇。 - inputs_embeds (
np.ndarray或tf.Tensor，形狀為(batch_size, num_choices, sequence_length, hidden_size)，可選) — 可選地，你可以不傳遞input_ids，而是直接傳遞一個嵌入式表示。如果你希望比模型內部的嵌入查詢矩陣有更多控制權來將input_ids索引轉換為相關向量，這會很有用。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。此引數只能在即時執行（eager mode）模式下使用，在圖模式（graph mode）下將使用配置中的值。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。此引數只能在即時執行（eager mode）模式下使用，在圖模式（graph mode）下將使用配置中的值。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。此引數可以在即時執行（eager mode）模式下使用，在圖模式（graph mode）下該值將始終設定為 True。 - training (
bool, 可選, 預設為False) — 是否以訓練模式使用模型（某些模組如 dropout 模組在訓練和評估模式下有不同的行為）。 - labels (
tf.Tensor，形狀為(batch_size,)，可選) — 用於計算多項選擇分類損失的標籤。索引應在[0, ..., num_choices]範圍內，其中num_choices是輸入張量第二維的大小。（見上面的input_ids）
返回
transformers.models.longformer.modeling_tf_longformer.TFLongformerMultipleChoiceModelOutput 或 tuple(tf.Tensor)
一個 transformers.models.longformer.modeling_tf_longformer.TFLongformerMultipleChoiceModelOutput 或一個 tf.Tensor 的元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），根據配置（LongformerConfig）和輸入，包含各種元素。
-
loss (
tf.Tensor，形狀為 *(1,)*，可選，當提供了labels時返回) — 分類損失。 -
logits (
tf.Tensor，形狀為(batch_size, num_choices)) — num_choices 是輸入張量的第二維。（參見上面的 input_ids）。分類分數（SoftMax 之前）。
-
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 + 1` 個值指的是相對位置的標記：一個標記對其自身的注意力權重位於索引 `x + attention_window / 2`，而前面（後面）的 `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 之後的全域性注意力權重，用於計算自注意力頭中的加權平均值。這些是每個具有全域性注意力的標記對序列中每個標記的注意力權重。
TFLongformerForMultipleChoice 的前向方法，重寫了 __call__ 特殊方法。
儘管前向傳播的流程需要在此函式內定義，但之後應呼叫 Module 例項而不是此函式，因為前者會處理執行前處理和後處理步驟，而後者會靜默地忽略它們。
示例
>>> from transformers import AutoTokenizer, TFLongformerForMultipleChoice
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = TFLongformerForMultipleChoice.from_pretrained("allenai/longformer-base-4096")
>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="tf", padding=True)
>>> inputs = {k: tf.expand_dims(v, 0) for k, v in encoding.items()}
>>> outputs = model(inputs) # batch size is 1
>>> # the linear classifier still needs to be trained
>>> logits = outputs.logits