Transformers 文档

Longformer

Transformers

加入 Hugging Face 社区

并获得增强型文档体验

协作模型、数据集和空间

使用加速推理更快地使用示例

在文档主题之间切换

开始使用

Longformer

概述

Longformer 模型在 Iz Beltagy、Matthew E. Peters 和 Arman Cohan 的论文 Longformer: The Long-Document Transformer 中提出。

论文摘要如下：

基于 Transformer 的模型由于其自注意力操作（其计算量与序列长度的平方成正比）而无法处理长序列。为了解决此限制，我们引入了 Longformer，它具有一个与序列长度线性缩放的注意力机制，使其能够轻松处理数千个标记或更长的文档。Longformer 的注意力机制可以替代标准的自注意力，并将局部窗口注意力与任务驱动的全局注意力相结合。借鉴先前关于长序列 Transformer 的工作，我们在字符级语言建模上评估了 Longformer，并在 text8 和 enwik8 上取得了最先进的结果。与大多数先前工作相比，我们还对 Longformer 进行了预训练，并在各种下游任务上对其进行了微调。我们预训练的 Longformer 在长文档任务上始终优于 RoBERTa，并在 WikiHop 和 TriviaQA 上取得了新的最先进结果。

此模型由 beltagy 贡献。作者的代码可以在这里找到这里。

使用技巧

由于 Longformer 基于 RoBERTa，因此它没有 token_type_ids。您无需指示哪个 token 属于哪个段。只需使用分隔 token tokenizer.sep_token（或 </s>）分隔您的段落。
一种将注意力矩阵替换为稀疏矩阵以加快速度的 Transformer 模型。通常，局部上下文（例如，左右两个 token 是什么？）足以对给定 token 进行操作。一些预选的输入 token 仍然会获得全局注意力，但注意力矩阵的参数要少得多，从而提高了速度。有关更多信息，请参阅局部注意力部分。

Longformer 自注意力

Longformer 自注意力在“局部”上下文和“全局”上下文中都使用自注意力。大多数 token 仅彼此“局部”关注，这意味着每个 token 都关注其 $\frac{1}{2} w$ 之前的 token 和 $\frac{1}{2} w$ 后续 token，其中 $w$ 是窗口长度，如 config.attention_window 中所定义。请注意，config.attention_window 可以是 List 类型，以定义不同的 $w$ 每一层。一些选定的 token 会“全局”地关注所有其他 token，就像在 BertSelfAttention 中对所有 token 通常所做的那样。

请注意，“局部”和“全局”关注的 token 由不同的查询、键和值矩阵投影。另请注意，每个“局部”关注的 token 不仅关注其窗口内的 token $w$ ，而且还关注所有“全局”关注的 token，以便全局注意力是对称的。

用户可以通过在运行时适当地设置张量 global_attention_mask 来定义哪些 token “局部”关注，哪些 token “全局”关注。所有 Longformer 模型都对 global_attention_mask 使用以下逻辑

0：token“局部”关注，
1：token“全局”关注。

有关更多信息，请参阅 forward() 方法。

使用 Longformer 自注意力，查询-键矩阵乘法操作的内存和时间复杂度（通常表示内存和时间瓶颈）可以从 $\mathcal{O}(n_s \times n_s)$ 降低到 $\mathcal{O}(n_s \times w)$ ，其中 $n_s$ 是序列长度，并且 $w$ 是平均窗口大小。假设“全局”关注的 token 数量与“局部”关注的 token 数量相比可以忽略不计。

有关更多信息，请参阅官方论文。

训练

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

类 transformers.LongformerConfig

< 源代码 >

( attention_window: Union = 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, 可选, 默认为 30522) — Longformer 模型的词汇量大小。定义了调用 LongformerModel 或 TFLongformerModel 时传递的 inputs_ids 可以表示的不同标记的数量。
hidden_size (int, 可选, 默认为 768) — 编码器层和池化层的维度。
num_hidden_layers (int, 可选, 默认为 12) — Transformer 编码器中隐藏层的数量。
num_attention_heads (int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头的数量。
intermediate_size (int, 可选, 默认为 3072) — Transformer 编码器中“中间”（通常称为前馈）层的维度。
hidden_act (str 或 Callable, 可选, 默认为 "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果为字符串，则支持 "gelu"、"relu"、"silu" 和 "gelu_new"。
hidden_dropout_prob (float, 可选, 默认为 0.1) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。
max_position_embeddings (int，可选，默认为 512) — 模型可能使用的最大序列长度。通常将其设置为一个较大的值以防万一（例如，512 或 1024 或 2048）。
type_vocab_size (int，可选，默认为 2) — 调用 LongformerModel 或 TFLongformerModel 时传递的token_type_ids的词汇量大小。
initializer_range (float，可选，默认为 0.02) — 初始化所有权重矩阵的截断正态初始化器的标准差。
layer_norm_eps (float，可选，默认为 1e-12) — 层归一化层使用的 epsilon。
attention_window (int 或 List[int]，可选，默认为 512) — 每个标记周围注意力窗口的大小。如果为int，则对所有层使用相同的大小。要为每一层指定不同的窗口大小，请使用List[int]，其中len(attention_window) == num_hidden_layers。

这是用于存储 LongformerModel 或 TFLongformerModel 配置的配置类。它用于根据指定的参数实例化 Longformer 模型，定义模型架构。

这是用于存储 LongformerModel 配置的配置类。它用于根据指定的参数实例化 Longformer 模型，定义模型架构。使用默认值实例化配置将产生与序列长度为 4,096 的 LongFormer allenai/longformer-base-4096 架构类似的配置。

配置对象继承自 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.config

LongformerTokenizer

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) — 合并文件路径。
errors (str, 可选，默认为 "replace") — 将字节解码为 UTF-8 时遵循的范例。有关更多信息，请参阅 bytes.decode。
bos_token (str, 可选，默认为 "<s>") — 在预训练期间使用的序列开始标记。可用作序列分类器标记。

在使用特殊标记构建序列时，这不是用于序列开头的标记。使用的标记是 cls_token。
eos_token (str, 可选，默认为 "</s>") — 序列结束标记。

在使用特殊标记构建序列时，这不是用于序列结束的标记。使用的标记是 sep_token。
sep_token (str, 可选，默认为 "</s>") — 分隔符标记，用于从多个序列构建序列时，例如序列分类的两个序列或问答的文本和问题。它也用作使用特殊标记构建的序列的最后一个标记。
cls_token (str, 可选，默认为 "<s>") — 分类器标记，用于执行序列分类（整个序列的分类而不是每个标记的分类）。它是使用特殊标记构建的序列的第一个标记。
unk_token (str, 可选，默认为 "<unk>") — 未知标记。不在词汇表中的标记无法转换为 ID，而是设置为此标记。
pad_token (str, 可选，默认为 "<pad>") — 用于填充的标记，例如在批处理不同长度的序列时。
mask_token (str, 可选，默认为 "<mask>") — 用于掩蔽值的标记。这是使用掩蔽语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
add_prefix_space (bool, 可选，默认为 False) — 是否在输入开头添加空格。这允许像对待其他任何单词一样对待开头的单词。（Longformer 分词器通过前面的空格检测单词的开头）。

构建一个 Longformer 分词器，它派生自 GPT-2 分词器，使用字节级字节对编码。

此分词器经过训练，可以将空格视为标记的一部分（有点像 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: Optional = None ) → List[int]

参数

token_ids_0 (List[int]) — 将添加特殊标记的 ID 列表。
token_ids_1 (List[int], 可选) — 序列对的可选第二个 ID 列表。

List[int]

包含适当特殊标记的输入 ID 列表。

通过连接和添加特殊标记，为序列分类任务构建来自序列或序列对的模型输入。Longformer 序列具有以下格式

单个序列：<s> X </s>
序列对：<s> A </s></s> B </s>

convert_tokens_to_string

< 源代码 >

( tokens )

将一系列标记（字符串）转换为单个字符串。

create_token_type_ids_from_sequences

< 源代码 >

( token_ids_0: List token_ids_1: Optional = None ) → List[int]

参数

token_ids_0 (List[int]) — ID 列表。
token_ids_1 (List[int], 可选) — 序列对的可选第二个 ID 列表。

List[int]

零列表。

创建一个从两个序列传递的掩码，用于序列对分类任务。Longformer 不使用标记类型 ID，因此返回一个零列表。

get_special_tokens_mask

< 源代码 >

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → List[int]

参数

token_ids_0 (List[int]) — ID 列表。
**already_has_special_tokens** (bool, *可选*, 默认为 False) — 指示标记列表是否已使用模型的特殊标记进行格式化。

List[int]

一个范围在 [0, 1] 内的整数列表：1 代表特殊标记，0 代表序列标记。

从没有添加特殊标记的标记列表中检索序列 ID。当使用分词器 prepare_for_model 方法添加特殊标记时，会调用此方法。

LongformerTokenizerFast

类 transformers.LongformerTokenizerFast

< 源代码 >

( 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, *可选*, 默认为 "replace") — 将字节解码为 UTF-8 时遵循的范式。有关更多信息，请参阅 bytes.decode。
**bos_token** (str, *可选*, 默认为 "<s>") — 在预训练期间使用的序列开始标记。可用作序列分类标记。

在使用特殊标记构建序列时，这不是用于序列开始的标记。使用的标记是 cls_token。
**eos_token** (str, *可选*, 默认为 "</s>") — 序列结束标记。

在使用特殊标记构建序列时，这不是用于序列结束的标记。使用的标记是 sep_token。
**sep_token** (str, *可选*, 默认为 "</s>") — 分隔符标记，用于从多个序列构建序列，例如序列分类的两个序列或问答的文本和问题。它也用作使用特殊标记构建的序列的最后一个标记。
cls_token (str，可选，默认为 "<s>") — 用于进行序列分类（对整个序列进行分类而不是对每个标记进行分类）时的分类器标记。它是使用特殊标记构建时序列的第一个标记。
unk_token (str，可选，默认为 "<unk>") — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。
pad_token (str，可选，默认为 "<pad>") — 用于填充的标记，例如在批处理不同长度的序列时。
mask_token (str，可选，默认为 "<mask>") — 用于掩蔽值的标记。这是使用掩蔽语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
add_prefix_space (bool，可选，默认为 False) — 是否在输入的开头添加空格。这允许将开头的单词像其他任何单词一样对待。（Longformer 分词器通过前面的空格检测单词的开头）。
trim_offsets (bool，可选，默认为 True) — 后处理步骤是否应该修剪偏移量以避免包含空格。

构建一个基于 GPT-2 分词器，使用字节级字节对编码的“快速”Longformer 分词器（由 HuggingFace 的 tokenizers 库支持）。

此分词器经过训练，可以将空格视为标记的一部分（有点像 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]

当与 is_split_into_words=True 一起使用时，此分词器需要使用 add_prefix_space=True 实例化。

此分词器继承自 PreTrainedTokenizerFast，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

create_token_type_ids_from_sequences

< 源代码 >

( token_ids_0: List token_ids_1: Optional = None ) → List[int]

参数

token_ids_0 (List[int]) — ID 列表。
token_ids_1 (List[int]，可选) — 序列对的可选第二个 ID 列表。

List[int]

零列表。

创建一个从两个序列传递的掩码，用于序列对分类任务。Longformer 不使用标记类型 ID，因此返回一个零列表。

Longformer 特定输出

类 transformers.models.longformer.modeling_longformer.LongformerBaseModelOutput

< 源代码 >

( last_hidden_state: FloatTensor hidden_states: Optional = None attentions: Optional = None global_attentions: Optional = None )

参数

last_hidden_state (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层的输出序列隐藏状态。
hidden_states (tuple(torch.FloatTensor), 可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（一个用于嵌入输出 + 一个用于每一层的输出）。

模型在每一层输出处的隐藏状态以及初始嵌入输出。
attentions (tuple(torch.FloatTensor), 可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, x + attention_window + 1) 的 torch.FloatTensor 元组（每一层一个），其中 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), 可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, x) 的 torch.FloatTensor 元组（每一层一个），其中 x 是具有全局注意力掩码的标记数量。

注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记到序列中每个标记的注意力权重。

Longformer 输出的基类，包含潜在的隐藏状态、局部和全局注意力。

类 transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling

< 源代码 >

( last_hidden_state: FloatTensor pooler_output: FloatTensor = None hidden_states: Optional = None attentions: Optional = None global_attentions: Optional = None )

参数

last_hidden_state (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层的输出序列隐藏状态。
池化输出（pooler_output） (torch.FloatTensor 形状为 (batch_size, hidden_size)) — 序列第一个 token（分类 token）的最后一层隐藏状态，经过线性层和 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 是具有全局注意力掩码的 token 数量。

注意力 softmax 后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个 token 到每个具有全局注意力 token（前 x 个值）以及注意力窗口中每个 token（剩余的 `attention_window
- 1个值）的注意力权重。请注意，前x个值指的是文本中具有固定位置的 token，但其余的attention_window + 1个值指的是具有相对位置的 token：一个 token 到自身的注意力权重位于索引x + attention_window / 2处，并且前attention_window / 2个（后attention_window / 2个）值是到前attention_window / 2个（后attention_window / 2个） token 的注意力权重。如果注意力窗口包含一个具有全局注意力的 token，则对应索引处的注意力权重设置为 0；该值应从前x个注意力权重中获取。如果一个 token 具有全局注意力，则到attentions中所有其他 token 的注意力权重都设置为 0，这些值应从global_attentions` 中获取。
全局注意力权重（global_attentions） (tuple(torch.FloatTensor), 可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每一层一个），形状为 (batch_size, num_heads, sequence_length, x)，其中 x 是具有全局注意力掩码的 token 数量。

注意力 softmax 后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的 token 到序列中每个 token 的注意力权重。

Longformer 输出的基类，也包含最后一层隐藏状态的池化。

类（class） transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput

< 源代码（source） >

( 损失（loss）: Optional = None logits: FloatTensor = None 隐藏状态（hidden_states）: Optional = None 注意力权重（attentions）: Optional = None 全局注意力权重（global_attentions）: Optional = None )

参数

损失（loss） (torch.FloatTensor 形状为 (1,), 可选，当提供 labels 时返回) — 掩码语言建模 (MLM) 损失。
logits (torch.FloatTensor 形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前的每个词汇 token 的分数）。
隐藏状态（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` 中访问这些值。
global_attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, x)，其中 x 是具有全局注意力掩码的标记数量。

注意力 softmax 后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记到序列中每个标记的注意力权重。

掩码语言模型输出的基类。

类 transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput

< 源代码 >

( loss: Optional = None start_logits: FloatTensor = None end_logits: FloatTensor = None hidden_states: Optional = None attentions: Optional = None global_attentions: Optional = None )

参数

loss (torch.FloatTensor 形状为 (1,)，可选，当提供 labels 时返回) — 总跨度提取损失是起始和结束位置的交叉熵之和。
start_logits (torch.FloatTensor 形状为 (batch_size, sequence_length)) — 跨度起始分数（在 SoftMax 之前）。
end_logits (torch.FloatTensor 形状为 (batch_size, sequence_length)) — 跨度结束分数（在 SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入的输出 + 一个用于每一层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型在每一层输出处的隐藏状态以及初始嵌入输出。
attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, 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)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, x)，其中 x 是具有全局注意力掩码的标记的数量。

注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记到序列中每个标记的注意力权重。

Longformer 问答模型输出的基类。

类 transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput

< 源代码 >

参数

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）个值是前attention_window / 2（后）个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则相应索引处的注意力权重设置为 0；该值应从前x个注意力权重中访问。如果一个标记具有全局注意力，则其对attentions中所有其他标记的注意力权重都设置为 0，其值应从global_attentions` 中访问。
global_attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, x)，其中 x 是具有全局注意力掩码的标记的数量。

注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记到序列中每个标记的注意力权重。

句子分类模型输出的基类。

类 transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput

< 源代码 >

参数

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` 中访问。
global_attentions (tuple(torch.FloatTensor), 可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每一层一个），形状为 (batch_size, num_heads, sequence_length, x)，其中 x 是具有全局注意力掩码的标记数。注意力 softmax 后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记到序列中每个标记的注意力权重。

多项选择 Longformer 模型输出的基类。

  类 transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput
  < 源代码 > ( 损失（loss）: Optional = None logits: FloatTensor = None 隐藏状态（hidden_states）: Optional = None 注意力权重（attentions）: Optional = None 全局注意力权重（global_attentions）: Optional = 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值）的注意力权重。请注意，前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)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —  torch.FloatTensor的元组（每个层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数量。
 注意力softmax之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记到序列中每个标记的注意力权重。
   
 标记分类模型输出的基类。
  类 transformers.models.longformer.modeling_tf_longformer.TFLongformerBaseModelOutput
  < 源代码 > ( last_hidden_state: 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值）的注意力权重。请注意，前x个值指的是文本中具有固定位置的标记，但剩余的attention_window + 1个值指的是具有相对位置的标记：标记与其自身的注意力权重位于索引x + attention_window / 2处，并且attention_window / 2个之前的（之后的）值是attention_window / 2个之前（之后的）标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则对应索引处的注意力权重设置为0；该值应从前x个注意力权重中获取。如果一个标记具有全局注意力，则其对attentions中所有其他标记的注意力权重都设置为0，其值应从global_attentions中获取。
 
   global_attentions (tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —  tf.Tensor的元组（每个层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数量。
 注意力softmax之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记到序列中每个标记的注意力权重。
   
 Longformer 输出的基类，包含潜在的隐藏状态、局部和全局注意力。
  类 transformers.models.longformer.modeling_tf_longformer.TFLongformerBaseModelOutputWithPooling
  < 源代码 > ( last_hidden_state: tf.Tensor = None pooler_output: 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)) — 序列第一个token（分类token）的最后一层隐藏状态，并经过线性层和Tanh激活函数进一步处理。在预训练期间，线性层的权重是从下一个句子预测（分类）目标中训练得到的。  
 hidden_states (tuple(tf.Tensor), 可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元组（一个用于嵌入的输出，一个用于每一层的输出）。
 模型在每一层输出处的隐藏状态以及初始嵌入输出。 
 attentions (tuple(tf.Tensor), 可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, x + attention_window + 1) 的 tf.Tensor 元组（每一层一个），其中 x 是具有全局注意力掩码的token数量。
 注意力softmax之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个token到每个具有全局注意力的token（前 x 个值）以及注意力窗口中每个token（其余 attention_window
  1个值）的注意力权重。请注意，前x个值指的是文本中具有固定位置的token，但其余attention_window + 1个值指的是具有相对位置的token：token与其自身的注意力权重位于索引x + attention_window / 2处，并且attention_window / 2之前的（之后的）值是到attention_window / 2之前的（之后的）token的注意力权重。如果注意力窗口包含一个具有全局注意力的token，则对应索引处的注意力权重设置为0；该值应从前x个注意力权重中获取。如果一个token具有全局注意力，则其对attentions中所有其他token的注意力权重都设置为0，这些值应从global_attentions` 中获取。
 
  
 global_attentions (tuple(tf.Tensor), 可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, x) 的 tf.Tensor 元组（每一层一个），其中 x 是具有全局注意力掩码的token数量。
 注意力softmax之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的token到序列中每个token的注意力权重。 
   
 Longformer 输出的基类，也包含最后一层隐藏状态的池化。
  类 transformers.models.longformer.modeling_tf_longformer.TFLongformerMaskedLMOutput
  < 源代码 > ( loss: tf.Tensor | None = None logits: 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 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元组（一个用于嵌入的输出 + 一个用于每一层的输出）。
 模型在每一层输出处的隐藏状态加上初始嵌入输出。
 attentions (tuple(tf.Tensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, x + attention_window + 1) 的 tf.Tensor 元组（每一层一个），其中 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(tf.Tensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, x) 的 tf.Tensor 元组（每一层一个），其中 x 是具有全局注意力掩码的标记数。
 注意力 Softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记到序列中每个标记的注意力权重。
   
 掩码语言模型输出的基类。
  类 transformers.models.longformer.modeling_tf_longformer.TFLongformerQuestionAnsweringModelOutput
  < 源代码 > ( loss: tf.Tensor | None = None start_logits: tf.Tensor = None end_logits: 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个）值是前 attention_window / 2个（后 attention_window / 2个）标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则对应索引处的注意力权重设置为 0；该值应从前 x个注意力权重中访问。如果一个标记具有全局注意力，则对 attentions中所有其他标记的注意力权重都设置为 0，其值应从 global_attentions` 中访问。
 
  
 global_attentions (tuple(tf.Tensor), 可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) —  tf.Tensor 元组（每一层一个），形状为 (batch_size, num_heads, sequence_length, x)，其中 x 是具有全局注意力掩码的标记的数量。
 注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记到序列中每个标记的注意力权重。
   
 Longformer 问答模型输出的基类。
  类 transformers.models.longformer.modeling_tf_longformer.TFLongformerSequenceClassifierOutput
  < 源代码 > ( loss: tf.Tensor | None = None logits: 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` 中访问。
 
  
 global_attentions (tuple(tf.Tensor)，可选，当传入 output_attentions=True 或 config.output_attentions=True 时返回) —  tf.Tensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, x)，其中 x 是具有全局注意力掩码的标记数量。
 注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记到序列中每个标记的注意力权重。
   
 句子分类模型输出的基类。
  类 transformers.models.longformer.modeling_tf_longformer.TFLongformerMultipleChoiceModelOutput
  < 源代码 > ( loss: tf.Tensor | None = None logits: 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` 中访问。
 
  
 global_attentions (tf.Tensor元组, 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — tf.Tensor元组（每个层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记的数量。
 注意力softmax之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记到序列中每个标记的注意力权重。
   
 多选模型输出的基类。
  类 transformers.models.longformer.modeling_tf_longformer.TFLongformerTokenClassifierOutput
  < 源代码 > ( loss: tf.Tensor | None = None logits: 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 (tf.Tensor元组, 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — tf.Tensor元组（嵌入输出一个，每个层输出一个），形状为(batch_size, sequence_length, hidden_size)。
 模型在每一层输出处的隐藏状态加上初始嵌入输出。
 attentions (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`中获取。
 
  
 global_attentions (tf.Tensor元组, 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — tf.Tensor元组（每个层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记的数量。
 注意力softmax之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记到序列中每个标记的注意力权重。
   
 标记分类模型输出的基类。
   Pytorch
  隐藏 Pytorch 内容
    LongformerModel
  类 transformers.LongformerModel
  < 源代码 > ( config add_pooling_layer = True  )
   参数 
  config (LongformerConfig) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化只会加载模型的配置，不会加载与模型相关的权重。请查看 from_pretrained() 方法来加载模型权重。  
   
 基本的 Longformer 模型，输出原始隐藏状态，没有任何特定的头部。
 此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头部等）。
 此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。
 此类复制了来自 RobertaModel 的代码，并用 Longformer 自注意力覆盖了标准的自注意力，以提供处理长序列的能力，遵循 Iz Beltagy、Matthew E. Peters 和 Arman Cohan 在 Longformer: the Long-Document Transformer 中描述的自注意力方法。Longformer 自注意力结合了局部（滑动窗口）和全局注意力，从而扩展到长文档，而不会导致内存和计算量以 O(n^2) 的速度增加。
 此处实现的自注意力模块 LongformerSelfAttention 支持局部和全局注意力的组合，但它不支持自回归注意力和扩张注意力。自回归和扩张注意力对于自回归语言建模比在下游任务上进行微调更相关。未来的版本将添加对自回归注意力的支持，但是对扩张注意力的支持需要一个自定义的 CUDA 内核才能实现内存和计算效率。
  前向传播
  < 源代码 > ( input_ids: Optional = None attention_mask: Optional = None global_attention_mask: Optional = None head_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None  ) → transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
   参数 
  input_ids (torch.LongTensor 形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。
 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
 什么是输入 ID？ 
 attention_mask (torch.FloatTensor 形状为 (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_layers, num_heads)，可选) — 用于使编码器中注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1] 中：
  1 表示头部未掩码，
 0 表示头部掩码。
 
  
 decoder_head_mask (torch.Tensor 形状为 (num_layers, num_heads)，可选) — 用于使解码器中注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1] 中：
  1 表示头部未掩码，
 0 表示头部掩码。
 
  
 token_type_ids (torch.LongTensor 形状为 (batch_size, sequence_length)，可选) — 分割标记索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：
  0 对应于 句子 A 标记，
 1 对应于 句子 B 标记。
 
 什么是标记类型 ID？ 
 position_ids (torch.LongTensor 形状为 (batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在 [0, config.max_position_embeddings - 1] 范围内选择。
 什么是位置 ID？ 
 inputs_embeds (torch.FloatTensor 形状为 (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 (torch.FloatTensor 形状为 (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）个值是前attention_window / 2（后attention_window / 2）个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则对应索引处的注意力权重设置为 0；该值应从前x个注意力权重中访问。如果一个标记具有全局注意力，则其对attentions中所有其他标记的注意力权重都设置为 0，其值应从global_attentions` 中访问。



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_output
   LongformerForMaskedLM
  类 transformers.LongformerForMaskedLM
  < 源代码 > ( config  )
   参数 
  config (LongformerConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。 
   
 带有语言建模头部（language modeling）的 Longformer 模型。
 此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头部等）。
 此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。
  前向传播
  < 源代码 > ( input_ids: Optional = None attention_mask: Optional = None global_attention_mask: Optional = None head_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None  ) → transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput 或 tuple(torch.FloatTensor)
   参数 
  input_ids (torch.LongTensor 形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。
 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
 什么是输入 ID？ 
 attention_mask (torch.FloatTensor 形状为 (batch_size, sequence_length), 可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值选择在 [0, 1] 中：
  1 表示未掩码的标记，
 0 表示掩码的标记。
 
 什么是注意力掩码？ 
 global_attention_mask (torch.FloatTensor 形状为 (batch_size, sequence_length), 可选) — 用于决定每个标记上给予的注意力的掩码，局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，所有其他标记也会关注它们。这对于特定任务的微调非常重要，因为它使模型在表示任务方面更灵活。例如，对于分类， 标记应给予全局注意力。对于 QA，所有问题标记也应具有全局注意力。有关更多详细信息，请参阅 Longformer 论文。掩码值选择在 [0, 1] 中：
  0 表示局部注意力（滑动窗口注意力），
 1 表示全局注意力（关注所有其他标记的标记，以及所有其他标记关注它们的标记）。
 
  
 head_mask (torch.Tensor 形状为 (num_layers, num_heads), 可选) — 用于使编码器中注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1] 中：
  1 表示头部未掩码，
 0 表示头部掩码。
 
  
 decoder_head_mask (torch.Tensor 形状为 (num_layers, num_heads), 可选) — 用于使解码器中注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1] 中：
  1 表示头部未掩码，
 0 表示头部掩码。
 
  
 token_type_ids (torch.LongTensor 形状为 (batch_size, sequence_length)，可选) — 分段标记索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：
  0 对应于 句子 A 标记，
 1 对应于 句子 B 标记。
 
 什么是标记类型 ID？ 
 position_ids (torch.LongTensor 形状为 (batch_size, sequence_length)，可选) — 输入序列中每个标记在位置嵌入中的位置索引。在 [0, config.max_position_embeddings - 1] 范围内选择。
 什么是位置 ID？ 
 inputs_embeds (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵对如何将 input_ids 索引转换为关联向量有更多控制权，这将非常有用。 
 output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。 
 output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。 
 return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。 
 labels (torch.LongTensor 形状为 (batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引应在 [-100, 0, ..., config.vocab_size] 中（参见 input_ids 文档字符串）索引设置为 -100 的标记将被忽略（掩码），损失仅针对标签在 [0, ..., config.vocab_size] 中的标记计算。 
 kwargs (Dict[str, any]，可选，默认为 {}) — 用于隐藏已弃用的旧参数。 
  返回
 


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 (torch.FloatTensor 形状为 (1,)，可选，当提供 labels 时返回) — 掩码语言建模 (MLM) 损失。


logits (torch.FloatTensor 形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前的每个词汇标记的分数）。


hidden_states (tuple(torch.FloatTensor)，可选，在传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入的输出 + 一个用于每一层的输出），形状为 (batch_size, sequence_length, hidden_size)。
模型在每一层输出处的隐藏状态以及初始嵌入输出。


attentions (tuple(torch.FloatTensor)，可选，在传递 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每一层一个），形状为 (batch_size, num_heads, sequence_length, x + attention_window + 1)，其中 x 是具有全局注意力掩码的标记数。
注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个标记到每个具有全局注意力的标记（前 x 个值）以及注意力窗口中每个标记（其余 attention_window

1个值）的注意力权重。请注意，前x个值指的是文本中具有固定位置的标记，但其余attention_window + 1个值指的是具有相对位置的标记：标记与其自身的注意力权重位于索引x + attention_window / 2处，并且前attention_window / 2（后attention_window / 2）个值是前attention_window / 2（后attention_window / 2）个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则对应索引处的注意力权重设置为 0；该值应从前x个注意力权重中访问。如果一个标记具有全局注意力，则其对attentions中所有其他标记的注意力权重都设置为 0，其值应从global_attentions` 中访问。



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
  类 transformers.LongformerForSequenceClassification
 ( config  )
   参数 
  config (LongformerConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。 
   
 Longformer 模型转换器，顶部带有序列分类/回归头部（池化输出顶部的线性层），例如用于 GLUE 任务。
 此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头部等）。
 此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。
  前向传播
  < 源代码 > ( input_ids: Optional = None attention_mask: Optional = None global_attention_mask: Optional = None head_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None  ) → transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput 或 tuple(torch.FloatTensor)
   参数 
  input_ids (torch.LongTensor 形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。
 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
 什么是输入 ID？ 
 attention_mask (torch.FloatTensor 形状为 (batch_size, sequence_length), 可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值选择在 [0, 1] 中：
  1 表示未被掩盖的标记，
 0 表示被掩盖的标记。
 
 什么是注意力掩码？ 
 global_attention_mask (torch.FloatTensor 形状为 (batch_size, sequence_length), 可选) — 用于决定每个标记上给予的注意力的掩码，局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，所有其他标记也会关注它们。这对于特定任务的微调非常重要，因为它使模型在表示任务方面更灵活。例如，对于分类， 标记应给予全局注意力。对于 QA，所有问题标记也应具有全局注意力。有关更多详细信息，请参阅 Longformer 论文。掩码值选择在 [0, 1] 中：
  0 表示局部注意力（滑动窗口注意力），
 1 表示全局注意力（关注所有其他标记的标记，以及所有其他标记关注它们的标记）。
 
  
 head_mask (torch.Tensor 形状为 (num_layers, num_heads), 可选) — 用于使编码器中注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1] 中：
  1 表示未被掩盖的头部，
 0 表示被掩盖的头部。
 
  
 decoder_head_mask (torch.Tensor 形状为 (num_layers, num_heads), 可选) — 用于使解码器中注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1] 中：
  1 表示未被掩盖的头部，
 0 表示被掩盖的头部。
 
  
 token_type_ids (torch.LongTensor 形状为 (batch_size, sequence_length), 可选) — 用于指示输入的第一部分和第二部分的片段标记索引。索引选择在 [0, 1] 中：
  0 对应于句子 A 标记，
 1 对应于句子 B 标记。
 
 什么是标记类型 ID？ 
 position_ids (torch.LongTensor 形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列标记的位置索引。选择范围为 [0, config.max_position_embeddings - 1]。
 什么是位置 ID？ 
 inputs_embeds (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望对如何将 input_ids 索引转换为关联向量进行更多控制，而不是模型的内部嵌入查找矩阵，这将非常有用。 
 output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。 
 output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。 
 return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。 
 labels (torch.LongTensor 形状为 (batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方误差损失），如果 config.num_labels > 1，则计算分类损失（交叉熵损失）。 
  返回
 


transformers.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 (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）个值是前attention_window / 2（后attention_window / 2）个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则对应索引处的注意力权重设置为 0；该值应从前x个注意力权重中访问。如果一个标记具有全局注意力，则其对attentions中所有其他标记的注意力权重都设置为 0，其值应从global_attentions` 中访问。



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("jpwahle/longformer-base-plagiarism-detection")
>>> model = LongformerForSequenceClassification.from_pretrained("jpwahle/longformer-base-plagiarism-detection")

>>> 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]
'ORIGINAL'

>>> # 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("jpwahle/longformer-base-plagiarism-detection", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
5.44
   多标签分类示例
 
 >>> import torch
>>> from transformers import AutoTokenizer, LongformerForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("jpwahle/longformer-base-plagiarism-detection")
>>> model = LongformerForSequenceClassification.from_pretrained("jpwahle/longformer-base-plagiarism-detection", 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(
...     "jpwahle/longformer-base-plagiarism-detection", 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).loss
   LongformerForMultipleChoice
  类 transformers.LongformerForMultipleChoice
  < 源代码 > ( config  )
   参数 
  config (LongformerConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。 
   
 在顶部具有多项选择分类头的 Longformer 模型（池化输出顶部的线性层和 softmax），例如用于 RocStories/SWAG 任务。
 此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头部等）。
 此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。
  前向传播
 ( input_ids: Optional = None token_type_ids: Optional = None attention_mask: Optional = None global_attention_mask: Optional = None head_mask: Optional = None labels: Optional = None position_ids: Optional = None inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = 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()。
 什么是输入 ID？ 
 attention_mask (torch.FloatTensor 形状为 (batch_size, num_choices, 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_layers, num_heads)，可选) — 用于使编码器中注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1] 中：
  1 表示头部未被掩盖，
 0 表示头部被掩盖。
 
  
 decoder_head_mask (torch.Tensor 形状为 (num_layers, num_heads)，可选) — 用于使解码器中注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1] 中：
  1 表示头部未被掩盖，
 0 表示头部被掩盖。
 
  
 token_type_ids (torch.LongTensor 形状为 (batch_size, num_choices, sequence_length)，可选) — 用于指示输入的第一部分和第二部分的段标记索引。索引选择在 [0, 1] 中：
  0 对应于句子 A 标记，
 1 对应于句子 B 标记。
 
 什么是标记类型 ID？ 
 position_ids (torch.LongTensor 形状为 (batch_size, num_choices, sequence_length)，可选) — 位置嵌入中每个输入序列标记的位置索引。选择范围为 [0, config.max_position_embeddings - 1]。
 什么是位置 ID？ 
 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 而不是普通元组。  
 labels (torch.LongTensor 形状为 (batch_size,)，可选) — 用于计算多项选择分类损失的标签。索引应在 [0, ..., num_choices-1] 中，其中 num_choices 是输入张量的第二维的大小。（参见上面的 input_ids）  
  返回
 


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 (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）个值是前attention_window / 2（后attention_window / 2）个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则对应索引处的注意力权重设置为 0；该值应从前x个注意力权重中访问。如果一个标记具有全局注意力，则其对attentions中所有其他标记的注意力权重都设置为 0，其值应从global_attentions` 中访问。



global_attentions (tuple(torch.FloatTensor)，可选，在传递 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每一层一个），形状为 (batch_size, num_heads, sequence_length, x)，其中 x 是具有全局注意力掩码的标记数。
注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记到序列中每个标记的注意力权重。


 
 LongformerForMultipleChoice 的 forward 方法覆盖了 __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.logits
   LongformerForTokenClassification
  类 transformers.LongformerForTokenClassification
  < 源代码 > ( config  )
   参数 
  config (LongformerConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。  
   
 带有令牌分类头的 Longformer 模型（隐藏状态输出顶部的线性层），例如用于命名实体识别 (NER) 任务。
 此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头部等）。
 此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。
  前向传播
  < 源代码 > ( input_ids: Optional = None attention_mask: Optional = None global_attention_mask: Optional = None head_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None  ) → transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput 或 tuple(torch.FloatTensor)
   参数 
  input_ids (torch.LongTensor 形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。
 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
 什么是输入 ID？ 
 attention_mask (torch.FloatTensor 形状为 (batch_size, sequence_length), 可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值选择在 [0, 1] 中：
  1 表示未掩盖的标记，
 0 表示掩盖的标记。
 
 什么是注意力掩码？ 
 global_attention_mask (torch.FloatTensor 形状为 (batch_size, sequence_length), 可选) — 用于决定对每个标记给予的注意力的掩码，局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，而所有其他标记也会关注它们。这对于特定于任务的微调非常重要，因为它使模型在表示任务方面更加灵活。例如，对于分类， 标记应给予全局注意力。对于 QA，所有问题标记也应具有全局注意力。有关更多详细信息，请参阅 Longformer 论文。掩码值选择在 [0, 1] 中：
  0 表示局部注意力（滑动窗口注意力），
 1 表示全局注意力（关注所有其他标记的标记，以及所有其他标记关注它们的标记）。
 
  
 head_mask (torch.Tensor 形状为 (num_layers, num_heads), 可选) — 用于使编码器中注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1] 中：
  1 表示头部未掩盖，
 0 表示头部掩盖。
 
  
 decoder_head_mask (torch.Tensor 形状为 (num_layers, num_heads), 可选) — 用于使解码器中注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1] 中：
  1 表示头部未掩盖，
 0 表示头部掩盖。
 
  
 token_type_ids (torch.LongTensor 形状为 (batch_size, sequence_length), 可选) — 用于指示输入第一部分和第二部分的段标记索引。索引选择在 [0, 1] 中：
  0 对应于句子 A 标记，
 1 对应于句子 B 标记。
 
 什么是标记类型 ID？ 
 position_ids (torch.LongTensor 形状为 (batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列标记的位置索引。选择范围为 [0, config.max_position_embeddings - 1]。
 什么是位置 ID？ 
 inputs_embeds (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，而不是传递 input_ids，您可以选择直接传递嵌入表示。如果您希望对如何将 input_ids 索引转换为关联向量进行更多控制，而不是模型的内部嵌入查找矩阵，这将非常有用。  
 output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。  
 output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。  
 return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。  
 labels (torch.LongTensor 形状为 (batch_size, sequence_length)，可选) — 用于计算标记分类损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。  
  返回
 


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 (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）个值是前attention_window / 2（后attention_window / 2）个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则对应索引处的注意力权重设置为 0；该值应从前x个注意力权重中访问。如果一个标记具有全局注意力，则其对attentions中所有其他标记的注意力权重都设置为 0，其值应从global_attentions` 中访问。



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("brad1141/Longformer-finetuned-norm")
>>> model = LongformerForTokenClassification.from_pretrained("brad1141/Longformer-finetuned-norm")

>>> 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
['Evidence', 'Evidence', 'Evidence', 'Evidence', 'Evidence', 'Evidence', 'Evidence', 'Evidence', 'Evidence', 'Evidence', 'Evidence', 'Evidence']

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
0.63
   LongformerForQuestionAnswering
  类 transformers.LongformerForQuestionAnswering
  < 源代码 > ( config  )
   参数 
  config (LongformerConfig) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。  
   
 带有跨度分类头的 Longformer 模型，用于提取式问答任务，例如 SQuAD/TriviaQA（在隐藏状态输出之上使用线性层来计算 跨度开始 logits 和 跨度结束 logits）。
 此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入的大小、修剪头部等）。
 此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。
  前向传播
  < 源代码 > ( input_ids: Optional = None attention_mask: Optional = None global_attention_mask: Optional = None head_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None inputs_embeds: Optional = None start_positions: Optional = None end_positions: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None  ) → transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
   参数 
  input_ids (torch.LongTensor 形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。
 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
 什么是输入 ID？ 
 attention_mask (torch.FloatTensor 形状为 (batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值选择在 [0, 1] 中：
  1 表示未掩盖的标记，
 0 表示掩盖的标记。
 
 什么是注意力掩码？ 
 global_attention_mask (torch.FloatTensor 形状为 (batch_size, sequence_length)，可选) — 用于决定每个标记给予的注意力的掩码，局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，并且所有其他标记也会关注它们。这对于特定于任务的微调非常重要，因为它使模型在表示任务时更加灵活。例如，对于分类， 标记应给予全局注意力。对于 QA，所有问题标记也应具有全局注意力。有关更多详细信息，请参阅 Longformer 论文。掩码值选择在 [0, 1] 中：
  0 表示局部注意力（滑动窗口注意力），
 1 表示全局注意力（关注所有其他标记的标记，以及所有其他标记关注它们的标记）。
 
  
 head_mask (torch.Tensor 形状为 (num_layers, num_heads)，可选) — 用于使编码器中注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1] 中：
  1 表示头部未掩盖，
 0 表示头部掩盖。
 
  
 decoder_head_mask (torch.Tensor 形状为 (num_layers, num_heads)，可选) — 用于使解码器中注意力模块的选定头部无效的掩码。掩码值选择在 [0, 1] 中：
  1 表示头部未掩盖，
 0 表示头部掩盖。
 
  
 token_type_ids (torch.LongTensor 形状为 (batch_size, sequence_length)，可选) — 用于指示输入的第一部分和第二部分的片段标记索引。索引选择在 [0, 1] 中：
  0 对应于句子 A 标记，
 1 对应于句子 B 标记。
 
 什么是标记类型 ID？ 
 position_ids (torch.LongTensor 形状为 (batch_size, sequence_length)，可选) — 输入序列标记在位置嵌入中的位置索引。选择范围在 [0, config.max_position_embeddings - 1] 中。
 什么是位置 ID？ 
 inputs_embeds (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，代替传递 input_ids，您可以选择直接传递嵌入表示。如果您希望比模型的内部嵌入查找矩阵更细致地控制如何将 input_ids 索引转换为关联向量，这将非常有用。  
 output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 attentions。  
 output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。  
 return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。  
 start_positions (torch.LongTensor 形状为 (batch_size,)，可选) — 用于计算标记分类损失的标记跨度的起始位置（索引）的标签。位置被限制在序列长度 (sequence_length) 内。序列之外的位置不会被考虑用于计算损失。  
 end_positions (torch.LongTensor 形状为 (batch_size,)，可选) — 用于计算标记分类损失的标记跨度的结束位置（索引）的标签。位置被限制在序列长度 (sequence_length) 内。序列之外的位置不会被考虑用于计算损失。  
  返回
 


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.FloatTensor 形状为 (1,)，可选，当提供 labels 时返回) — 总的跨度提取损失是起始和结束位置的交叉熵之和。


start_logits (torch.FloatTensor 形状为 (batch_size, sequence_length)) — 跨度起始分数（在 SoftMax 之前）。


end_logits (torch.FloatTensor 形状为 (batch_size, sequence_length)) — 跨度结束分数（在 SoftMax 之前）。


hidden_states (tuple(torch.FloatTensor)，可选，在传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入的输出 + 一个用于每一层的输出），形状为 (batch_size, sequence_length, hidden_size)。
模型在每一层输出处的隐藏状态以及初始嵌入输出。


attentions (tuple(torch.FloatTensor)，可选，在传递 output_attentions=True 或 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每一层一个），形状为 (batch_size, num_heads, sequence_length, x + attention_window + 1)，其中 x 是具有全局注意力掩码的标记数。
注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个标记到每个具有全局注意力的标记（前 x 个值）以及注意力窗口中每个标记（其余 attention_window

1个值）的注意力权重。请注意，前x个值指的是文本中具有固定位置的标记，但其余attention_window + 1个值指的是具有相对位置的标记：标记与其自身的注意力权重位于索引x + attention_window / 2处，并且前attention_window / 2（后attention_window / 2）个值是前attention_window / 2（后attention_window / 2）个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则对应索引处的注意力权重设置为 0；该值应从前x个注意力权重中访问。如果一个标记具有全局注意力，则其对attentions中所有其他标记的注意力权重都设置为 0，其值应从global_attentions` 中访问。



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 token
   TensorFlow
  隐藏 TensorFlow 内容
    TFLongformerModel
  类 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 自注意力覆盖标准自注意力，以提供根据Longformer：长文档 Transformer（由 Iz Beltagy、Matthew E. Peters 和 Arman Cohan 撰写）中描述的自注意力方法处理长序列的能力。Longformer 自注意力结合了局部（滑动窗口）和全局注意力，可以扩展到长文档，而无需内存和计算量呈 O(n^2) 增长。
 此处实现的自注意力模块 TFLongformerSelfAttention 支持局部和全局注意力的组合，但缺乏对自回归注意力和扩张注意力的支持。自回归和扩张注意力与自回归语言建模比在下游任务上进行微调更相关。未来版本将添加对自回归注意力的支持，但对扩张注意力的支持需要一个自定义的 CUDA 内核才能在内存和计算方面高效。
  调用
  < 源代码 > ( 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()。
 什么是输入 ID？ 
 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)，可选) — 用于决定每个标记上给予的注意力的掩码，局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，所有其他标记也会关注它们。这对于特定任务的微调非常重要，因为它使模型在表示任务方面更灵活。例如，对于分类，标记应给予全局注意力。对于 QA，所有问题标记也应具有全局注意力。有关更多详细信息，请参阅Longformer 论文。掩码值选择在 [0, 1] 中：
  0 表示局部注意力（滑动窗口注意力），
 1 表示全局注意力（关注所有其他标记的标记，所有其他标记也关注它们）。
 
  
 token_type_ids (np.ndarray 或 tf.Tensor 形状为 (batch_size, sequence_length)，可选) — 用于指示输入的第一部分和第二部分的片段标记索引。索引选择在 [0, 1] 中：
  0 对应于句子 A 标记，
 1 对应于句子 B 标记。
 
 什么是标记类型 ID？ 
 position_ids (np.ndarray 或 tf.Tensor 形状为 (batch_size, sequence_length)，可选) — 输入序列中每个 token 在位置嵌入中的位置索引。选择范围为 [0, config.max_position_embeddings - 1]。
 什么是位置 ID？ 
 inputs_embeds (np.ndarray 或 tf.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 而不是普通元组。此参数可在渴望模式下使用，在图形模式下，该值将始终设置为 True。 
 training (bool，可选，默认为 False) — 是否以训练模式使用模型（某些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。 
   
 The TFLongformerModel 正向方法覆盖了 __call__ 特殊方法。
  尽管正向传递的配方需要在此函数内定义，但此后应调用 Module 实例，而不是此函数，因为前者负责运行预处理和后处理步骤，而后者则会静默地忽略它们。
   TFLongformerForMaskedLM
  class transformers.TFLongformerForMaskedLM
  < 源代码 > ( 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 函数一样传递输入！
  调用
  < 源代码 > ( 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()。
 什么是输入 ID？ 
 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)，可选) — 用于决定每个标记给予的注意力的掩码，局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，而所有其他标记也会关注它们。这对于特定任务的微调非常重要，因为它使模型在表示任务方面更加灵活。例如，对于分类， 标记应给予全局注意力。对于 QA，所有问题标记也应该具有全局注意力。有关更多详细信息，请参阅 Longformer 论文。掩码值选择在 [0, 1] 中：
  0 表示局部注意力（滑动窗口注意力），
 1 表示全局注意力（关注所有其他标记的标记，以及所有其他标记关注它们的标记）。
 
  
 token_type_ids (np.ndarray 或 tf.Tensor 形状为 (batch_size, sequence_length)，可选) — 用于指示输入的第一部分和第二部分的片段标记索引。索引选择在 [0, 1] 中：
  0 对应于句子 A 标记，
 1 对应于句子 B 标记。
 
 什么是标记类型 ID？ 
 position_ids (np.ndarray 或 tf.Tensor 形状为 (batch_size, sequence_length)，可选) — 输入序列中每个标记在位置嵌入中的位置索引。选择范围为 [0, config.max_position_embeddings - 1]。
 什么是位置 ID？ 
 inputs_embeds (np.ndarray 或 tf.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而不是普通元组。此参数可在急切模式下使用，在图形模式下，该值将始终设置为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.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）个值是前attention_window / 2（后attention_window / 2）个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则对应索引处的注意力权重设置为 0；该值应从前x个注意力权重中访问。如果一个标记具有全局注意力，则其对attentions中所有其他标记的注意力权重都设置为 0，其值应从global_attentions` 中访问。



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'
   
 >>> labels = tokenizer("The capital of France is Paris.", return_tensors="tf")["input_ids"]
>>> # mask labels of non-<mask> tokens
>>> labels = tf.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

>>> outputs = model(**inputs, labels=labels)
>>> round(float(outputs.loss), 2)
0.44
   TFLongformerForQuestionAnswering
  类 transformers.TFLongformerForQuestionAnswering
  < 源代码 > ( config *inputs **kwargs  )
   参数 
  config (LongformerConfig) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。 
   
 带有跨度分类头的 Longformer 模型，用于提取式问答任务，如 SQuAD/TriviaQA（在隐藏状态输出之上添加一个线性层，以计算跨度开始 logits 和跨度结束 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 函数一样传递输入！
  调用
  < 源代码 > ( 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()。
 什么是输入 ID？ 
 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)，可选) — 用于决定每个标记上给予的注意力的掩码，局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，而所有其他标记也会关注它们。这对于特定任务的微调很重要，因为它使模型在表示任务方面更灵活。例如，对于分类， 标记应给予全局注意力。对于 QA，所有问题标记也应具有全局注意力。有关更多详细信息，请参阅 Longformer 论文。掩码值选择在 [0, 1] 中：
  0 表示局部注意力（滑动窗口注意力），
 1 表示全局注意力（关注所有其他标记的标记，以及所有其他标记关注它们的标记）。
 
  
 token_type_ids (np.ndarray 或 tf.Tensor 形状为 (batch_size, sequence_length)，可选) — 用于指示输入的第一部分和第二部分的段标记索引。索引选择在 [0, 1] 中：
  0 对应于句子 A 标记，
 1 对应于句子 B 标记。
 
 什么是标记类型 ID？ 
 position_ids (np.ndarray 或 tf.Tensor 形状为 (batch_size, sequence_length)，可选) — 输入序列中每个标记在位置嵌入中的位置索引。选择范围在 [0, config.max_position_embeddings - 1] 中。
 什么是位置 ID？ 
 inputs_embeds (np.ndarray 或 tf.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 而不是普通元组。此参数可在急切模式下使用，在图模式下，该值将始终设置为 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 (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）个值是前attention_window / 2（后attention_window / 2）个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则对应索引处的注意力权重设置为 0；该值应从前x个注意力权重中访问。如果一个标记具有全局注意力，则其对attentions中所有其他标记的注意力权重都设置为 0，其值应从global_attentions` 中访问。



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'
   
 >>> # target is "nice puppet"
>>> target_start_index = tf.constant([14])
>>> target_end_index = tf.constant([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = tf.math.reduce_mean(outputs.loss)
>>> round(float(loss), 2)
0.96
   TFLongformerForSequenceClassification
  类 transformers.TFLongformerForSequenceClassification
  < 源代码 > ( config *inputs **kwargs  )
   参数 
  config (LongformerConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。  
   
 Longformer 模型转换器，顶部带有序列分类/回归头部（池化输出顶部的线性层），例如用于 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()。
 什么是输入 ID？ 
 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)，可选) — 用于决定每个标记上给予的注意力的掩码，局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，而所有其他标记也会关注它们。这对于特定任务的微调非常重要，因为它使模型在表示任务方面更具灵活性。例如，对于分类， 标记应给予全局注意力。对于 QA，所有问题标记也应该具有全局注意力。有关更多详细信息，请参阅 Longformer 论文。掩码值选择在 [0, 1] 中：
  0 表示局部注意力（滑动窗口注意力），
 1 表示全局注意力（关注所有其他标记的标记，以及所有其他标记关注它们的标记）。
 
  
 token_type_ids (np.ndarray 或 tf.Tensor 形状为 (batch_size, sequence_length)，可选) — 用于指示输入的第一部分和第二部分的段标记索引。索引选择在 [0, 1] 中：
  0 对应于句子 A 标记，
 1 对应于句子 B 标记。
 
 什么是标记类型 ID？ 
 position_ids (np.ndarray 或 tf.Tensor 形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列标记的位置索引。选择范围在 [0, config.max_position_embeddings - 1] 中。
 什么是位置 ID？ 
 inputs_embeds (np.ndarray 或 tf.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而不是普通元组。此参数可在急切模式下使用，在图形模式下，该值将始终设置为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 (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）个值是前attention_window / 2（后attention_window / 2）个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则对应索引处的注意力权重设置为 0；该值应从前x个注意力权重中访问。如果一个标记具有全局注意力，则其对attentions中所有其他标记的注意力权重都设置为 0，其值应从global_attentions` 中访问。



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).loss
   TFLongformerForTokenClassification
  类 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()。
 什么是输入 ID？ 
 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)，可选) — 用于决定每个标记上给予的注意力的掩码，局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，并且所有其他标记也会关注它们。这对于特定任务的微调非常重要，因为它使模型在表示任务方面更加灵活。例如，对于分类， 标记应给予全局注意力。对于 QA，所有问题标记也应该具有全局注意力。有关更多详细信息，请参阅 Longformer 论文。掩码值选择在 [0, 1] 中：
  0 表示局部注意力（滑动窗口注意力），
 1 表示全局注意力（关注所有其他标记的标记，以及所有其他标记关注它们的标记）。
 
  
 token_type_ids (np.ndarray 或 tf.Tensor 形状为 (batch_size, sequence_length)，可选) — 用于指示输入的第一部分和第二部分的段标记索引。索引选择在 [0, 1] 中：
  0 对应于句子 A 标记，
 1 对应于句子 B 标记。
 
 什么是标记类型 ID？ 
 position_ids (np.ndarray 或 tf.Tensor 形状为 (batch_size, sequence_length)，可选) — 输入序列中每个标记在位置嵌入中的位置索引。选择范围在 [0, config.max_position_embeddings - 1] 中。
 什么是位置 ID？ 
 inputs_embeds (np.ndarray 或 tf.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 而不是普通元组。此参数可在急切模式下使用，在图模式下，该值将始终设置为 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）个值是前attention_window / 2（后attention_window / 2）个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则对应索引处的注意力权重设置为 0；该值应从前x个注意力权重中访问。如果一个标记具有全局注意力，则其对attentions中所有其他标记的注意力权重都设置为 0，其值应从global_attentions` 中访问。



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()]
   
 >>> labels = predicted_token_class_ids
>>> loss = tf.math.reduce_mean(model(**inputs, labels=labels).loss)
   TFLongformerForMultipleChoice
  类 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()。
 什么是输入 ID？ 
 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)，可选) — 用于确定每个标记上给定的注意力的掩码，局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，并且所有其他标记都会关注它们。这对于特定任务的微调非常重要，因为它使模型在表示任务方面更加灵活。例如，对于分类， 标记应获得全局注意力。对于 QA，所有问题标记也应具有全局注意力。有关更多详细信息，请参阅 Longformer 论文。掩码值选择在 [0, 1] 中：
  0 表示局部注意力（滑动窗口注意力），
 1 表示全局注意力（关注所有其他标记的标记，以及所有其他标记关注它们的标记）。
 
  
 token_type_ids (np.ndarray 或 tf.Tensor 形状为 (batch_size, num_choices, sequence_length)，可选) — 用于指示输入的第一部分和第二部分的段标记索引。索引选择在 [0, 1] 中：
  0 对应于 句子 A 标记，
 1 对应于 句子 B 标记。
 
 什么是标记类型 ID？ 
 position_ids (np.ndarray 或 tf.Tensor 形状为 (batch_size, num_choices, sequence_length)，可选) — 输入序列标记在位置嵌入中的位置索引。选择范围为 [0, config.max_position_embeddings - 1]。
 什么是位置 ID？ 
 inputs_embeds (np.ndarray 或 tf.Tensor 形状为 (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 而不是普通元组。此参数可在急切模式下使用，在图模式下，其值将始终设置为 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）个值是前attention_window / 2（后attention_window / 2）个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则对应索引处的注意力权重设置为 0；该值应从前x个注意力权重中访问。如果一个标记具有全局注意力，则其对attentions中所有其他标记的注意力权重都设置为 0，其值应从global_attentions` 中访问。



global_attentions (tuple(tf.Tensor), 可选, 当传递 output_attentions=True 或 config.output_attentions=True 时返回) — tf.Tensor 的元组（每一层一个），形状为 (batch_size, num_heads, sequence_length, x)，其中 x 是具有全局注意力掩码的标记数量。
注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记到序列中每个标记的注意力权重。


 
 The 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
 
 
 < > 在 GitHub 上更新


				←Llama3 LongT5→


		



Longformer 概述 使用技巧 Longformer 自注意力 训练 资源 Longformer配置 Longformer分词器 Longformer快速分词器 Longformer 特定输出 Longformer模型 Longformer用于MaskedLM Longformer用于序列分类 Longformer用于多项选择 Longformer用于令牌分类 Longformer用于问答 TFLongformer模型 TFLongformer用于MaskedLM TFLongformer用于问答 TFLongformer用于序列分类 TFLongformer用于令牌分类 TFLongformer用于多项选择

Transformers

Longformer

概述

使用技巧

Longformer 自注意力

训练

资源

LongformerConfig

类 transformers.LongformerConfig

LongformerTokenizer

class transformers.LongformerTokenizer

build_inputs_with_special_tokens

convert_tokens_to_string

create_token_type_ids_from_sequences

get_special_tokens_mask

**LongformerTokenizerFast**

类 transformers.LongformerTokenizerFast

create_token_type_ids_from_sequences

Longformer 特定输出

类 transformers.models.longformer.modeling_longformer.LongformerBaseModelOutput

类 transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling

类（class） transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput

类 transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput

类 transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput

类 transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput

类 transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput

类 transformers.models.longformer.modeling_tf_longformer.TFLongformerBaseModelOutput

类 transformers.models.longformer.modeling_tf_longformer.TFLongformerBaseModelOutputWithPooling

类 transformers.models.longformer.modeling_tf_longformer.TFLongformerMaskedLMOutput

类 transformers.models.longformer.modeling_tf_longformer.TFLongformerQuestionAnsweringModelOutput

类 transformers.models.longformer.modeling_tf_longformer.TFLongformerSequenceClassifierOutput

类 transformers.models.longformer.modeling_tf_longformer.TFLongformerMultipleChoiceModelOutput

类 transformers.models.longformer.modeling_tf_longformer.TFLongformerTokenClassifierOutput

LongformerModel

类 transformers.LongformerModel

前向传播

LongformerForMaskedLM

类 transformers.LongformerForMaskedLM

前向传播

LongformerForSequenceClassification

类 transformers.LongformerForSequenceClassification

前向传播

LongformerForMultipleChoice

类 transformers.LongformerForMultipleChoice

前向传播

LongformerForTokenClassification

类 transformers.LongformerForTokenClassification

前向传播

LongformerForQuestionAnswering

类 transformers.LongformerForQuestionAnswering

前向传播

TFLongformerModel

类 transformers.TFLongformerModel

调用

TFLongformerForMaskedLM

class transformers.TFLongformerForMaskedLM

调用

TFLongformerForQuestionAnswering

类 transformers.TFLongformerForQuestionAnswering

调用

TFLongformerForSequenceClassification

类 transformers.TFLongformerForSequenceClassification

调用

TFLongformerForTokenClassification

类 transformers.TFLongformerForTokenClassification

调用

TFLongformerForMultipleChoice

类 transformers.TFLongformerForMultipleChoice

调用

LongformerTokenizerFast