Transformers 文档
Longformer
并获得增强的文档体验
开始使用
Longformer
Longformer 是一种专为处理长文档而设计的 Transformer 模型。自注意力操作通常会随序列长度二次方增长，这限制了 Transformer 处理更长序列的能力。Longformer 的注意力机制通过与序列长度线性扩展来克服这一问题。它结合了局部窗口化注意力和任务特定的全局注意力，从而能够高效处理包含数千个标记的文档。
你可以在 Ai2 组织下找到所有原始的 Longformer 检查点。
点击右侧边栏中的 Longformer 模型，查看更多关于如何将 Longformer 应用于不同语言任务的示例。
下面的示例演示了如何使用 Pipeline、AutoModel 和命令行来填充 <mask> 标记。
import torch
from transformers import pipeline
pipeline = pipeline(
task="fill-mask",
model="allenai/longformer-base-4096",
torch_dtype=torch.float16,
device=0
)
pipeline("""San Francisco 49ers cornerback Shawntae Spencer will miss the rest of the <mask> with a torn ligament in his left knee.
Spencer, a fifth-year pro, will be placed on injured reserve soon after undergoing surgery Wednesday to repair the ligament. He injured his knee late in the 49ers’ road victory at Seattle on Sept. 14, and missed last week’s victory over Detroit.
Tarell Brown and Donald Strickland will compete to replace Spencer with the 49ers, who kept 12 defensive backs on their 53-man roster to start the season. Brown, a second-year pro, got his first career interception last weekend while filling in for Strickland, who also sat out with a knee injury.""")注意事项
Longformer 基于 RoBERTa 并且没有 `token_type_ids`。你不需要指明哪个标记属于哪个段落。你只需要使用分隔标记 `</s>` 或 `tokenizer.sep_token` 来分隔段落。
在推理时，你可以使用 `global_attention_mask` 来设置哪些标记可以进行局部注意力，哪些可以进行全局注意力（更多细节请参见此示例）。值为 `0` 表示标记进行局部注意力，值为 `1` 表示标记进行全局注意力。
LongformerForMaskedLM 的训练方式与 RobertaForMaskedLM 类似，应如下所示使用。
input_ids = tokenizer.encode("This is a sentence from [MASK] training data", return_tensors="pt") mlm_labels = tokenizer.encode("This is a sentence from the training data", return_tensors="pt") loss = model(input_ids, labels=input_ids, masked_lm_labels=mlm_labels)[0]
LongformerConfig
class transformers.LongformerConfig
< 来源 >( attention_window: typing.Union[list[int], int] = 512 sep_token_id: int = 2 pad_token_id: int = 1 bos_token_id: int = 0 eos_token_id: int = 2 vocab_size: int = 30522 hidden_size: int = 768 num_hidden_layers: int = 12 num_attention_heads: int = 12 intermediate_size: int = 3072 hidden_act: str = 'gelu' hidden_dropout_prob: float = 0.1 attention_probs_dropout_prob: float = 0.1 max_position_embeddings: int = 512 type_vocab_size: int = 2 initializer_range: float = 0.02 layer_norm_eps: float = 1e-12 onnx_export: bool = False **kwargs )
参数
- vocab_size (
int, optional, 默认为 30522) — Longformer 模型的词汇表大小。定义了在调用 LongformerModel 或 TFLongformerModel 时，可以通过 `inputs_ids` 表示的不同标记的数量。 - hidden_size (
int, optional, 默认为 768) — 编码器层和池化层的维度。 - num_hidden_layers (
int, optional, 默认为 12) — Transformer 编码器中的隐藏层数量。 - num_attention_heads (
int, optional, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数量。 - intermediate_size (
int, optional, 默认为 3072) — Transformer 编码器中“中间层”（通常称为前馈层）的维度。 - hidden_act (
str或Callable, optional, 默认为"gelu") — 编码器和池化层中的非线性激活函数（函数或字符串）。如果为字符串，支持 `"gelu"`、`"relu"`、`"silu"` 和 `"gelu_new"`。 - hidden_dropout_prob (
float, optional, 默认为 0.1) — 嵌入层、编码器和池化层中所有全连接层的丢弃概率。 - attention_probs_dropout_prob (
float, optional, 默认为 0.1) — 注意力概率的丢弃率。 - max_position_embeddings (
int, optional, 默认为 512) — 此模型可能使用的最大序列长度。通常将其设置为一个较大的值以备不时之需（例如，512、1024 或 2048）。 - type_vocab_size (
int, optional, 默认为 2) — 在调用 LongformerModel 或 TFLongformerModel 时传入的 `token_type_ids` 的词汇表大小。 - initializer_range (
float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - layer_norm_eps (
float, optional, 默认为 1e-12) — 层归一化层使用的 epsilon 值。 - attention_window (
int或list[int], optional, 默认为 512) — 每个标记周围的注意力窗口大小。如果是一个 `int`，则所有层使用相同的大小。要为每个层指定不同的窗口大小，请使用一个 `list[int]`，其中 `len(attention_window) == num_hidden_layers`。
这是用于存储 LongformerModel 或 TFLongformerModel 配置的配置类。它用于根据指定的参数实例化一个 Longformer 模型，定义模型架构。
这是用于存储 LongformerModel 配置的配置类。它用于根据指定的参数实例化一个 Longformer 模型，定义模型架构。使用默认值实例化一个配置将产生一个与 LongFormer allenai/longformer-base-4096 架构相似的配置，其序列长度为 4,096。
配置对象继承自 PretrainedConfig，可用于控制模型输出。请阅读 PretrainedConfig 的文档以获取更多信息。
示例
>>> from transformers import LongformerConfig, LongformerModel
>>> # Initializing a Longformer configuration
>>> configuration = LongformerConfig()
>>> # Initializing a model from the configuration
>>> model = LongformerModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configLongformerTokenizer
class transformers.LongformerTokenizer
< 来源 >( vocab_file merges_file errors = 'replace' bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' add_prefix_space = False **kwargs )
参数
- vocab_file (
str) — 词汇表文件的路径。 - merges_file (
str) — merges 文件的路径。 - errors (
str, optional, 默认为"replace") — 将字节解码为 UTF-8 时遵循的范式。更多信息请参见 bytes.decode。 - bos_token (
str, optional, 默认为"<s>") — 在预训练期间使用的序列开始标记。可用作序列分类器标记。当使用特殊标记构建序列时，这不是用于序列开始的标记。使用的标记是 `cls_token`。
- eos_token (
str, optional, 默认为"</s>") — 序列结束标记。当使用特殊标记构建序列时，这不是用于序列结束的标记。使用的标记是 `sep_token`。
- sep_token (
str, optional, 默认为"</s>") — 分隔标记，用于从多个序列构建序列，例如用于序列分类的两个序列或用于问答的文本和问题。它也用作使用特殊标记构建的序列的最后一个标记。 - cls_token (
str, optional, 默认为"<s>") — 分类器标记，用于序列分类（整个序列的分类而非逐个标记的分类）。当使用特殊标记构建序列时，它是序列的第一个标记。 - unk_token (
str, optional, 默认为"<unk>") — 未知标记。不在词汇表中的标记无法转换为 ID，而是被设置为此标记。 - pad_token (
str, optional, 默认为"<pad>") — 用于填充的标记，例如在批处理不同长度的序列时使用。 - mask_token (
str, optional, 默认为"<mask>") — 用于掩盖值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。 - add_prefix_space (
bool, optional, 默认为False) — 是否在输入前添加一个初始空格。这使得前导词可以像其他词一样处理。（Longformer 分词器通过前面的空格来检测词的开头）。
构建一个 Longformer 分词器，它源自 GPT-2 分词器，使用字节级字节对编码（Byte-Pair-Encoding）。
这个分词器经过训练，将空格视为词元的一部分（有点像 sentencepiece），所以一个词会
无论是否在句子开头（无空格），编码方式都会不同
>>> from transformers import LongformerTokenizer
>>> tokenizer = LongformerTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> tokenizer("Hello world")["input_ids"]
[0, 31414, 232, 2]
>>> tokenizer(" Hello world")["input_ids"]
[0, 20920, 232, 2]您可以通过在实例化此分词器时或在对某些文本调用它时传递 add_prefix_space=True 来绕过此行为，但由于模型并非以这种方式进行预训练，这可能会导致性能下降。
当与 is_split_into_words=True 一起使用时，此分词器会在每个词（甚至是第一个词）之前添加一个空格。
该分词器继承自 PreTrainedTokenizer，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
build_inputs_with_special_tokens
< 来源 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
通过连接和添加特殊标记，从一个序列或一对序列为序列分类任务构建模型输入。Longformer 序列具有以下格式
- 单个序列：
<s> X </s> - 序列对：
<s> A </s></s> B </s>
将标记序列（字符串）转换为单个字符串。
create_token_type_ids_from_sequences
< source >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
从传入的两个序列创建掩码，用于序列对分类任务。Longformer 不使用标记类型 ID，因此返回一个零列表。
get_special_tokens_mask
< source >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None already_has_special_tokens: bool = False ) → list[int]
从没有添加特殊标记的标记列表中检索序列ID。此方法在使用分词器prepare_for_model方法添加特殊标记时调用。
LongformerTokenizerFast
class transformers.LongformerTokenizerFast
< source >( vocab_file = None merges_file = None tokenizer_file = None errors = 'replace' bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' add_prefix_space = False trim_offsets = True **kwargs )
参数
- vocab_file (
str) — 词汇表文件的路径。 - merges_file (
str) — 合并文件的路径。 - errors (
str, optional, defaults to"replace") — 将字节解码为 UTF-8 时遵循的范例。有关更多信息，请参阅 bytes.decode。 - bos_token (
str, optional, defaults to"<s>") — 预训练期间使用的序列开始标记。可用作序列分类器标记。使用特殊标记构建序列时，这不是用于序列开始的标记。使用的标记是 `cls_token`。
- eos_token (
str, optional, defaults to"</s>") — 序列结束标记。使用特殊标记构建序列时，这不是用于序列结束的标记。使用的标记是 `sep_token`。
- sep_token (
str, optional, defaults to"</s>") — 分隔符标记，用于从多个序列构建一个序列，例如用于序列分类的两个序列，或用于问答的文本和问题。它也用作使用特殊标记构建的序列的最后一个标记。 - cls_token (
str, optional, defaults to"<s>") — 分类器标记，用于进行序列分类（对整个序列进行分类，而不是逐个标记分类）。当使用特殊标记构建序列时，它是序列的第一个标记。 - unk_token (
str, optional, defaults to"<unk>") — 未知标记。不在词汇表中的标记无法转换为 ID，而是设置为此标记。 - pad_token (
str, optional, defaults to"<pad>") — 用于填充的标记，例如在批处理不同长度的序列时使用。 - mask_token (
str, optional, defaults to"<mask>") — 用于掩盖值的标记。这是使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。 - add_prefix_space (
bool, optional, defaults toFalse) — 是否在输入前添加一个初始空格。这允许将开头的单词像其他任何单词一样处理。（Longformer 分词器通过前面的空格检测单词的开头）。 - trim_offsets (
bool, optional, defaults toTrue) — 后处理步骤是否应修剪偏移量以避免包含空格。
构建一个“快速”Longformer 分词器（由 HuggingFace 的 *tokenizers* 库支持），它源自 GPT-2 分词器，使用字节级字节对编码（Byte-Pair-Encoding）。
这个分词器经过训练，将空格视为词元的一部分（有点像 sentencepiece），所以一个词会
无论是否在句子开头（无空格），编码方式都会不同
>>> from transformers import LongformerTokenizerFast
>>> tokenizer = LongformerTokenizerFast.from_pretrained("allenai/longformer-base-4096")
>>> tokenizer("Hello world")["input_ids"]
[0, 31414, 232, 2]
>>> tokenizer(" Hello world")["input_ids"]
[0, 20920, 232, 2]您可以通过在实例化此分词器时或在对某些文本调用它时传递 add_prefix_space=True 来绕过此行为，但由于模型并非以这种方式进行预训练，这可能会导致性能下降。
当与 is_split_into_words=True 一起使用时，此分词器需要以 add_prefix_space=True 进行实例化。
此分词器继承自 PreTrainedTokenizerFast，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
create_token_type_ids_from_sequences
< source >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
从传入的两个序列创建掩码，用于序列对分类任务。Longformer 不使用标记类型 ID，因此返回一个零列表。
Longformer 特定输出
class transformers.models.longformer.modeling_longformer.LongformerBaseModelOutput
< source >( last_hidden_state: FloatTensor hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None global_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- last_hidden_state (
<class 'torch.FloatTensor'>.last_hidden_stateof shape(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 - hidden_states (
tuple[torch.FloatTensor, ...], optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) —torch.FloatTensor的元组（如果模型有嵌入层，则一个用于嵌入层的输出，+ 每个层一个输出），形状为 `(batch_size, sequence_length, hidden_size)`。模型在每层输出处的隐藏状态以及可选的初始嵌入输出。
- attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) —torch.FloatTensor的元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, x + attention_window + 1)`，其中 `x` 是具有全局注意力掩码的标记数。注意力 softmax 后的局部注意力权重，用于计算自注意力头中的加权平均。这些是序列中每个标记对具有全局注意力的每个标记（前 `x` 个值）和注意力窗口中每个标记（剩余的 `attention_window`
- 1`个值）的注意力权重。请注意，前 `x` 个值指的是文本中位置固定的标记，但剩余的 `attention_window + 1` 个值指的是相对位置的标记：一个标记对其自身的注意力权重位于索引 `x + attention_window / 2`，而前面（后面）的 `attention_window / 2` 个值是对应前面（后面）`attention_window / 2` 个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则相应索引处的注意力权重设置为 0；该值应从前 `x` 个注意力权重中访问。如果一个标记具有全局注意力，则 `attentions` 中对所有其他标记的注意力权重都设置为 0，这些值应从 `global_attentions` 中访问。
- global_attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) —torch.FloatTensor的元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, x)`，其中 `x` 是具有全局注意力掩码的标记数。注意力 softmax 后的全局注意力权重，用于计算自注意力头中的加权平均。这些是每个具有全局注意力的标记对序列中每个标记的注意力权重。
Longformer 输出的基类，包含潜在的隐藏状态、局部和全局注意力。
class transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling
< source >( last_hidden_state: FloatTensor pooler_output: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None global_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- last_hidden_state (
<class 'torch.FloatTensor'>.last_hidden_stateof shape(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 - pooler_output (
torch.FloatTensorof shape(batch_size, hidden_size)) — 序列第一个标记（分类标记）的最后一层隐藏状态，再经过一个线性层和 Tanh 激活函数处理。线性层的权重是在预训练期间从下一句预测（分类）目标中训练得到的。 - hidden_states (
tuple[torch.FloatTensor, ...], optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) —torch.FloatTensor的元组（如果模型有嵌入层，则一个用于嵌入层的输出，+ 每个层一个输出），形状为 `(batch_size, sequence_length, hidden_size)`。模型在每层输出处的隐藏状态以及可选的初始嵌入输出。
- attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) —torch.FloatTensor的元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, x + attention_window + 1)`，其中 `x` 是具有全局注意力掩码的标记数。注意力 softmax 后的局部注意力权重，用于计算自注意力头中的加权平均。这些是序列中每个标记对具有全局注意力的每个标记（前 `x` 个值）和注意力窗口中每个标记（剩余的 `attention_window`
- 1`个值）的注意力权重。请注意，前 `x` 个值指的是文本中位置固定的标记，但剩余的 `attention_window + 1` 个值指的是相对位置的标记：一个标记对其自身的注意力权重位于索引 `x + attention_window / 2`，而前面（后面）的 `attention_window / 2` 个值是对应前面（后面）`attention_window / 2` 个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则相应索引处的注意力权重设置为 0；该值应从前 `x` 个注意力权重中访问。如果一个标记具有全局注意力，则 `attentions` 中对所有其他标记的注意力权重都设置为 0，这些值应从 `global_attentions` 中访问。
- global_attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) —torch.FloatTensor的元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, x)`，其中 `x` 是具有全局注意力掩码的标记数。注意力 softmax 后的全局注意力权重，用于计算自注意力头中的加权平均。这些是每个具有全局注意力的标记对序列中每个标记的注意力权重。
Longformer 输出的基类，也包含最后隐藏状态的池化。
class transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None global_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensorof shape(1,), optional, returned whenlabelsis provided) — 掩码语言建模（MLM）损失。 - logits (
torch.FloatTensorof shape(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 前每个词汇标记的分数）。 - hidden_states (
tuple[torch.FloatTensor, ...], 可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（如果模型有嵌入层，则一个用于嵌入层的输出，另外每个层都有一个输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出端的隐藏状态，外加可选的初始嵌入输出。
- attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是带有全局注意力掩码的词元数量。注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个词元到每个具有全局注意力的词元（前
x个值）以及注意力窗口中每个词元（剩余的 `attention_window- 1` 个值）的注意力权重。请注意，前
x个值指的是文本中位置固定的词元，而剩余的attention_window + 1个值指的是相对位置的词元：一个词元对其自身的注意力权重位于索引x + attention_window / 2处，而前面（后面）的attention_window / 2个值是其对前面（后面）attention_window / 2个词元的注意力权重。如果注意力窗口包含一个具有全局注意力的词元，则相应索引处的注意力权重设置为 0；该值应从前x个注意力权重中获取。如果一个词元具有全局注意力，则attentions中对所有其他词元的注意力权重都设置为 0，这些值应从global_attentions中获取。
- 1` 个值）的注意力权重。请注意，前
- global_attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是带有全局注意力掩码的词元数量。注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的词元到序列中每个词元的注意力权重。
掩码语言模型输出的基类。
class transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None start_logits: typing.Optional[torch.FloatTensor] = None end_logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None global_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensor，形状为(1,), 可选，当提供labels时返回) — 总的答案片段抽取损失是起始位置和结束位置的交叉熵之和。 - start_logits (
torch.FloatTensor，形状为(batch_size, sequence_length), 可选，默认为None) — 答案片段起始位置的分数（在 SoftMax 之前）。 - end_logits (
torch.FloatTensor，形状为(batch_size, sequence_length), 可选，默认为None) — 答案片段结束位置的分数（在 SoftMax 之前）。 - hidden_states (
tuple[torch.FloatTensor, ...], 可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（如果模型有嵌入层，则一个用于嵌入层的输出，另外每个层都有一个输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出端的隐藏状态，外加可选的初始嵌入输出。
- attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是带有全局注意力掩码的词元数量。注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个词元到每个具有全局注意力的词元（前
x个值）以及注意力窗口中每个词元（剩余的 `attention_window- 1` 个值）的注意力权重。请注意，前
x个值指的是文本中位置固定的词元，而剩余的attention_window + 1个值指的是相对位置的词元：一个词元对其自身的注意力权重位于索引x + attention_window / 2处，而前面（后面）的attention_window / 2个值是其对前面（后面）attention_window / 2个词元的注意力权重。如果注意力窗口包含一个具有全局注意力的词元，则相应索引处的注意力权重设置为 0；该值应从前x个注意力权重中获取。如果一个词元具有全局注意力，则attentions中对所有其他词元的注意力权重都设置为 0，这些值应从global_attentions中获取。
- 1` 个值）的注意力权重。请注意，前
- global_attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是带有全局注意力掩码的词元数量。注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的词元到序列中每个词元的注意力权重。
用于 Longformer 问答模型输出的基类。
class transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None global_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensor，形状为(1,), 可选，当提供labels时返回) — 分类（如果 config.num_labels==1，则为回归）损失。 - logits (
torch.FloatTensor，形状为(batch_size, config.num_labels)) — 分类（如果 config.num_labels==1，则为回归）分数（在 SoftMax 之前）。 - hidden_states (
tuple[torch.FloatTensor, ...], 可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（如果模型有嵌入层，则一个用于嵌入层的输出，另外每个层都有一个输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出端的隐藏状态，外加可选的初始嵌入输出。
- attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是带有全局注意力掩码的词元数量。注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个词元到每个具有全局注意力的词元（前
x个值）以及注意力窗口中每个词元（剩余的 `attention_window- 1` 个值）的注意力权重。请注意，前
x个值指的是文本中位置固定的词元，而剩余的attention_window + 1个值指的是相对位置的词元：一个词元对其自身的注意力权重位于索引x + attention_window / 2处，而前面（后面）的attention_window / 2个值是其对前面（后面）attention_window / 2个词元的注意力权重。如果注意力窗口包含一个具有全局注意力的词元，则相应索引处的注意力权重设置为 0；该值应从前x个注意力权重中获取。如果一个词元具有全局注意力，则attentions中对所有其他词元的注意力权重都设置为 0，这些值应从global_attentions中获取。
- 1` 个值）的注意力权重。请注意，前
- global_attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是带有全局注意力掩码的词元数量。注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的词元到序列中每个词元的注意力权重。
句子分类模型输出的基类。
class transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None global_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensor，形状为 (1,), 可选，当提供labels时返回) — 分类损失。 - logits (
torch.FloatTensor，形状为(batch_size, num_choices)) — num_choices 是输入张量的第二个维度。（参见上面的 input_ids）。分类分数（在 SoftMax 之前）。
- hidden_states (
tuple[torch.FloatTensor, ...], 可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（如果模型有嵌入层，则一个用于嵌入层的输出，另外每个层都有一个输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出端的隐藏状态，外加可选的初始嵌入输出。
- attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是带有全局注意力掩码的词元数量。注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个词元到每个具有全局注意力的词元（前
x个值）以及注意力窗口中每个词元（剩余的 `attention_window- 1` 个值）的注意力权重。请注意，前
x个值指的是文本中位置固定的词元，而剩余的attention_window + 1个值指的是相对位置的词元：一个词元对其自身的注意力权重位于索引x + attention_window / 2处，而前面（后面）的attention_window / 2个值是其对前面（后面）attention_window / 2个词元的注意力权重。如果注意力窗口包含一个具有全局注意力的词元，则相应索引处的注意力权重设置为 0；该值应从前x个注意力权重中获取。如果一个词元具有全局注意力，则attentions中对所有其他词元的注意力权重都设置为 0，这些值应从global_attentions中获取。
- 1` 个值）的注意力权重。请注意，前
- global_attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是带有全局注意力掩码的词元数量。注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的词元到序列中每个词元的注意力权重。
用于 Longformer 多项选择模型输出的基类。
class transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None global_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensor，形状为(1,), 可选，当提供labels时返回) — 分类损失。 - logits (
torch.FloatTensor，形状为(batch_size, sequence_length, config.num_labels)) — 分类分数（在 SoftMax 之前）。 - hidden_states (
tuple[torch.FloatTensor, ...], 可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（如果模型有嵌入层，则一个用于嵌入层的输出，另外每个层都有一个输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出端的隐藏状态，外加可选的初始嵌入输出。
- attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是带有全局注意力掩码的词元数量。注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个词元到每个具有全局注意力的词元（前
x个值）以及注意力窗口中每个词元（剩余的 `attention_window- 1` 个值）的注意力权重。请注意，前
x个值指的是文本中位置固定的词元，而剩余的attention_window + 1个值指的是相对位置的词元：一个词元对其自身的注意力权重位于索引x + attention_window / 2处，而前面（后面）的attention_window / 2个值是其对前面（后面）attention_window / 2个词元的注意力权重。如果注意力窗口包含一个具有全局注意力的词元，则相应索引处的注意力权重设置为 0；该值应从前x个注意力权重中获取。如果一个词元具有全局注意力，则attentions中对所有其他词元的注意力权重都设置为 0，这些值应从global_attentions中获取。
- 1` 个值）的注意力权重。请注意，前
- global_attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是带有全局注意力掩码的词元数量。注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的词元到序列中每个词元的注意力权重。
Token分类模型输出的基类。
class transformers.models.longformer.modeling_tf_longformer.TFLongformerBaseModelOutput
< source >( last_hidden_state: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor, ...] | None = None attentions: tuple[tf.Tensor, ...] | None = None global_attentions: tuple[tf.Tensor, ...] | None = None )
参数
- last_hidden_state (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 - hidden_states (
tuple(tf.Tensor), 可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入层的输出 + 一个用于每层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出端的隐藏状态，外加初始嵌入输出。
- attentions (
tuple(tf.Tensor), 可选，当传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是带有全局注意力掩码的词元数量。注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个词元到每个具有全局注意力的词元（前
x个值）以及注意力窗口中每个词元（剩余的 `attention_window- 1` 个值）的注意力权重。请注意，前
x个值指的是文本中位置固定的词元，而剩余的attention_window + 1个值指的是相对位置的词元：一个词元对其自身的注意力权重位于索引x + attention_window / 2处，而前面（后面）的attention_window / 2个值是其对前面（后面）attention_window / 2个词元的注意力权重。如果注意力窗口包含一个具有全局注意力的词元，则相应索引处的注意力权重设置为 0；该值应从前x个注意力权重中获取。如果一个词元具有全局注意力，则attentions中对所有其他词元的注意力权重都设置为 0，这些值应从global_attentions中获取。
- 1` 个值）的注意力权重。请注意，前
- global_attentions (
tuple(tf.Tensor), 可选，当传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是带有全局注意力掩码的词元数量。注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的词元到序列中每个词元的注意力权重。
Longformer 输出的基类，包含潜在的隐藏状态、局部和全局注意力。
class transformers.models.longformer.modeling_tf_longformer.TFLongformerBaseModelOutputWithPooling
< source >( last_hidden_state: Optional[tf.Tensor] = None pooler_output: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor, ...] | None = None attentions: tuple[tf.Tensor, ...] | None = None global_attentions: tuple[tf.Tensor, ...] | None = None )
参数
- last_hidden_state (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 - pooler_output (
tf.Tensor，形状为(batch_size, hidden_size)) — 序列的第一个词元（分类词元）的最后一层隐藏状态，经过一个线性层和一个 Tanh 激活函数进一步处理。线性层的权重是在预训练期间通过下一句预测（分类）目标进行训练的。 - hidden_states (
tuple(tf.Tensor), 可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入层的输出 + 一个用于每层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出端的隐藏状态，外加初始嵌入输出。
- attentions (
tuple(tf.Tensor), 可选，当传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是带有全局注意力掩码的词元数量。注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个词元到每个具有全局注意力的词元（前
x个值）以及注意力窗口中每个词元（剩余的 `attention_window- 1` 个值）的注意力权重。请注意，前
x个值指的是文本中位置固定的词元，而剩余的attention_window + 1个值指的是相对位置的词元：一个词元对其自身的注意力权重位于索引x + attention_window / 2处，而前面（后面）的attention_window / 2个值是其对前面（后面）attention_window / 2个词元的注意力权重。如果注意力窗口包含一个具有全局注意力的词元，则相应索引处的注意力权重设置为 0；该值应从前x个注意力权重中获取。如果一个词元具有全局注意力，则attentions中对所有其他词元的注意力权重都设置为 0，这些值应从global_attentions中获取。
- 1` 个值）的注意力权重。请注意，前
- global_attentions (
tuple(tf.Tensor), 可选，当传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是带有全局注意力掩码的词元数量。注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的词元到序列中每个词元的注意力权重。
Longformer 输出的基类，也包含最后隐藏状态的池化。
class transformers.models.longformer.modeling_tf_longformer.TFLongformerMaskedLMOutput
< source >( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor, ...] | None = None attentions: tuple[tf.Tensor, ...] | None = None global_attentions: tuple[tf.Tensor, ...] | None = None )
参数
- loss (
tf.Tensor，形状为(1,)，可选，在提供了labels时返回) — 掩码语言建模 (MLM) 损失。 - logits (
tf.Tensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax之前每个词汇标记的分数）。 - hidden_states (
tuple(tf.Tensor), 可选，在传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入层的输出，一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的隐藏状态以及初始嵌入层的输出。
- attentions (
tuple(tf.Tensor), 可选，在传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是具有全局注意力掩码的标记数量。经过注意力 softmax 后的局部注意力权重，用于在自注意力头中计算加权平均值。这些是序列中每个标记对每个具有全局注意力的标记（前
x个值）以及注意力窗口中每个标记（剩余的 `attention_window`- 1` 个值）的注意力权重。请注意，前
x个值指的是文本中具有固定位置的标记，但剩余的attention_window + 1个值指的是具有相对位置的标记：一个标记对其自身的注意力权重位于索引x + attention_window / 2，而前面（后面）的attention_window / 2个值是分别对前面（后面）attention_window / 2个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，相应索引处的注意力权重将设置为 0；该值应从前x个注意力权重中获取。如果一个标记具有全局注意力，则attentions中对所有其他标记的注意力权重都设置为 0，这些值应从global_attentions中获取。
- 1` 个值）的注意力权重。请注意，前
- global_attentions (
tuple(tf.Tensor), 可选，在传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数量。经过注意力 softmax 后的全局注意力权重，用于在自注意力头中计算加权平均值。这些是从每个具有全局注意力的标记到序列中每个标记的注意力权重。
掩码语言模型输出的基类。
class transformers.models.longformer.modeling_tf_longformer.TFLongformerQuestionAnsweringModelOutput
< source >( loss: tf.Tensor | None = None start_logits: Optional[tf.Tensor] = None end_logits: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor, ...] | None = None attentions: tuple[tf.Tensor, ...] | None = None global_attentions: tuple[tf.Tensor, ...] | None = None )
参数
- loss (
tf.Tensor，形状为(1,)，可选，在提供了labels时返回) — 总的答案片段抽取损失，是起始位置和结束位置的交叉熵损失之和。 - start_logits (
tf.Tensor，形状为(batch_size, sequence_length)) — 答案片段的起始位置分数（SoftMax之前）。 - end_logits (
tf.Tensor，形状为(batch_size, sequence_length)) — 答案片段的结束位置分数（SoftMax之前）。 - hidden_states (
tuple(tf.Tensor), 可选，在传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入层的输出，一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的隐藏状态以及初始嵌入层的输出。
- attentions (
tuple(tf.Tensor), 可选，在传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是具有全局注意力掩码的标记数量。经过注意力 softmax 后的局部注意力权重，用于在自注意力头中计算加权平均值。这些是序列中每个标记对每个具有全局注意力的标记（前
x个值）以及注意力窗口中每个标记（剩余的 `attention_window`- 1` 个值）的注意力权重。请注意，前
x个值指的是文本中具有固定位置的标记，但剩余的attention_window + 1个值指的是具有相对位置的标记：一个标记对其自身的注意力权重位于索引x + attention_window / 2，而前面（后面）的attention_window / 2个值是分别对前面（后面）attention_window / 2个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，相应索引处的注意力权重将设置为 0；该值应从前x个注意力权重中获取。如果一个标记具有全局注意力，则attentions中对所有其他标记的注意力权重都设置为 0，这些值应从global_attentions中获取。
- 1` 个值）的注意力权重。请注意，前
- global_attentions (
tuple(tf.Tensor), 可选，在传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数量。经过注意力 softmax 后的全局注意力权重，用于在自注意力头中计算加权平均值。这些是从每个具有全局注意力的标记到序列中每个标记的注意力权重。
用于 Longformer 问答模型输出的基类。
class transformers.models.longformer.modeling_tf_longformer.TFLongformerSequenceClassifierOutput
< source >( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor, ...] | None = None attentions: tuple[tf.Tensor, ...] | None = None global_attentions: tuple[tf.Tensor, ...] | None = None )
参数
- loss (
tf.Tensor，形状为(1,)，可选，在提供了labels时返回) — 分类（如果 config.num_labels==1，则为回归）损失。 - logits (
tf.Tensor，形状为(batch_size, config.num_labels)) — 分类（如果 config.num_labels==1，则为回归）分数（SoftMax之前）。 - hidden_states (
tuple(tf.Tensor), 可选，在传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入层的输出，一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的隐藏状态以及初始嵌入层的输出。
- attentions (
tuple(tf.Tensor), 可选，在传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是具有全局注意力掩码的标记数量。经过注意力 softmax 后的局部注意力权重，用于在自注意力头中计算加权平均值。这些是序列中每个标记对每个具有全局注意力的标记（前
x个值）以及注意力窗口中每个标记（剩余的 `attention_window`- 1` 个值）的注意力权重。请注意，前
x个值指的是文本中具有固定位置的标记，但剩余的attention_window + 1个值指的是具有相对位置的标记：一个标记对其自身的注意力权重位于索引x + attention_window / 2，而前面（后面）的attention_window / 2个值是分别对前面（后面）attention_window / 2个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，相应索引处的注意力权重将设置为 0；该值应从前x个注意力权重中获取。如果一个标记具有全局注意力，则attentions中对所有其他标记的注意力权重都设置为 0，这些值应从global_attentions中获取。
- 1` 个值）的注意力权重。请注意，前
- global_attentions (
tuple(tf.Tensor), 可选，在传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数量。经过注意力 softmax 后的全局注意力权重，用于在自注意力头中计算加权平均值。这些是从每个具有全局注意力的标记到序列中每个标记的注意力权重。
句子分类模型输出的基类。
class transformers.models.longformer.modeling_tf_longformer.TFLongformerMultipleChoiceModelOutput
< source >( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor, ...] | None = None attentions: tuple[tf.Tensor, ...] | None = None global_attentions: tuple[tf.Tensor, ...] | None = None )
参数
- loss (
tf.Tensor，形状为 (1,)，可选，在提供了labels时返回) — 分类损失。 - logits (
tf.Tensor，形状为(batch_size, num_choices)) — num_choices 是输入张量的第二个维度。（参见上面的 input_ids）。分类分数（SoftMax之前）。
- hidden_states (
tuple(tf.Tensor), 可选，在传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入层的输出，一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的隐藏状态以及初始嵌入层的输出。
- attentions (
tuple(tf.Tensor), 可选，在传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是具有全局注意力掩码的标记数量。经过注意力 softmax 后的局部注意力权重，用于在自注意力头中计算加权平均值。这些是序列中每个标记对每个具有全局注意力的标记（前
x个值）以及注意力窗口中每个标记（剩余的 `attention_window`- 1` 个值）的注意力权重。请注意，前
x个值指的是文本中具有固定位置的标记，但剩余的attention_window + 1个值指的是具有相对位置的标记：一个标记对其自身的注意力权重位于索引x + attention_window / 2，而前面（后面）的attention_window / 2个值是分别对前面（后面）attention_window / 2个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，相应索引处的注意力权重将设置为 0；该值应从前x个注意力权重中获取。如果一个标记具有全局注意力，则attentions中对所有其他标记的注意力权重都设置为 0，这些值应从global_attentions中获取。
- 1` 个值）的注意力权重。请注意，前
- global_attentions (
tuple(tf.Tensor), 可选，在传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数量。经过注意力 softmax 后的全局注意力权重，用于在自注意力头中计算加权平均值。这些是从每个具有全局注意力的标记到序列中每个标记的注意力权重。
多项选择模型输出的基类。
class transformers.models.longformer.modeling_tf_longformer.TFLongformerTokenClassifierOutput
< source >( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor, ...] | None = None attentions: tuple[tf.Tensor, ...] | None = None global_attentions: tuple[tf.Tensor, ...] | None = None )
参数
- loss (
tf.Tensor，形状为(1,)，可选，在提供了labels时返回) — 分类损失。 - logits (
tf.Tensor，形状为(batch_size, sequence_length, config.num_labels)) — 分类分数（SoftMax之前）。 - hidden_states (
tuple(tf.Tensor), 可选，在传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入层的输出，一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的隐藏状态以及初始嵌入层的输出。
- attentions (
tuple(tf.Tensor), 可选，在传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是具有全局注意力掩码的标记数量。经过注意力 softmax 后的局部注意力权重，用于在自注意力头中计算加权平均值。这些是序列中每个标记对每个具有全局注意力的标记（前
x个值）以及注意力窗口中每个标记（剩余的 `attention_window`- 1` 个值）的注意力权重。请注意，前
x个值指的是文本中具有固定位置的标记，但剩余的attention_window + 1个值指的是具有相对位置的标记：一个标记对其自身的注意力权重位于索引x + attention_window / 2，而前面（后面）的attention_window / 2个值是分别对前面（后面）attention_window / 2个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，相应索引处的注意力权重将设置为 0；该值应从前x个注意力权重中获取。如果一个标记具有全局注意力，则attentions中对所有其他标记的注意力权重都设置为 0，这些值应从global_attentions中获取。
- 1` 个值）的注意力权重。请注意，前
- global_attentions (
tuple(tf.Tensor), 可选，在传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数量。经过注意力 softmax 后的全局注意力权重，用于在自注意力头中计算加权平均值。这些是从每个具有全局注意力的标记到序列中每个标记的注意力权重。
Token分类模型输出的基类。
LongformerModel
class transformers.LongformerModel
< source >( config add_pooling_layer = True )
参数
- config (LongformerModel) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
- add_pooling_layer (
bool, 可选, 默认为True) — 是否添加池化层。
基础的 Longformer 模型，输出原始的隐藏状态，顶部没有任何特定的头。
此模型继承自 PreTrainedModel。请查阅超类文档以了解该库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪注意力头等）。
该模型也是一个 PyTorch torch.nn.Module 子类。可以像常规 PyTorch Module 一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。
forward
< source >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None global_attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下，填充将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选自[0, 1]：- 1 表示标记未被遮盖，
- 0 表示标记被遮盖。
- global_attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 用于决定对每个标记应用何种注意力的掩码，局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，并且所有其他标记也会关注它们。这对于特定任务的微调非常重要，因为它使模型在表示任务方面更加灵活。例如，对于分类任务，标记应给予全局注意力。对于问答任务，所有问题标记也应具有全局注意力。请参阅 Longformer 论文 了解更多细节。掩码值选自[0, 1]：- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（标记会关注所有其他标记，并且所有其他标记也会关注它们）。
- head_mask (
torch.Tensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于置零自注意力模块中选定头的掩码。掩码值选自[0, 1]：- 1 表示头未被遮盖，
- 0 表示头被遮盖。
- token_type_ids (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 片段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于 句子 A 的标记，
- 1 对应于 句子 B 的标记。
- position_ids (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在[0, config.n_positions - 1]范围内选择。 - inputs_embeds (
torch.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，你可以选择直接传递嵌入表示，而不是传递input_ids。如果你希望比模型内部的嵌入查找矩阵有更多控制权来将input_ids索引转换为相关向量，这将非常有用。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
返回
transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling 或 tuple(torch.FloatTensor)
一个 transformers.models.longformer.modeling_longformer.LongformerBaseModelOutputWithPooling 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或 config.return_dict=False），根据配置 (LongformerConfig) 和输入包含不同的元素。
-
last_hidden_state (
<class 'torch.FloatTensor'>.last_hidden_state，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 -
pooler_output (
torch.FloatTensor，形状为(batch_size, hidden_size)) — 序列第一个标记（分类标记）的最后一层隐藏状态，经过一个线性层和一个 Tanh 激活函数进一步处理。该线性层的权重在预训练期间通过下一句预测（分类）目标进行训练。 -
hidden_states (
tuple[torch.FloatTensor, ...]，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 每个层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是具有全局注意力掩码的标记数量。注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个标记对每个具有全局注意力的标记（前
x个值）以及注意力窗口中每个标记（剩余的 `attention_window- + 1` 个值）的注意力权重。请注意，前
x个值指的是文本中位置固定的标记，但剩余的 `attention_window + 1` 个值指的是相对位置的标记：一个标记对其自身的注意力权重位于索引 `x + attention_window / 2`，而前面（后面）的 `attention_window / 2` 个值是对应前面（后面）的 `attention_window / 2` 个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则相应索引处的注意力权重设置为 0；该值应从前x个注意力权重中获取。如果一个标记具有全局注意力，则 `attentions` 中对所有其他标记的注意力权重设置为 0，这些值应从 `global_attentions` 中获取。
- + 1` 个值）的注意力权重。请注意，前
-
global_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数量。注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记对序列中每个标记的注意力权重。
LongformerModel 的前向方法，重写了 __call__ 特殊方法。
尽管前向传播的流程需要在此函数内定义，但之后应调用 Module 实例而不是此函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> import torch
>>> from transformers import LongformerModel, AutoTokenizer
>>> model = LongformerModel.from_pretrained("allenai/longformer-base-4096")
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> SAMPLE_TEXT = " ".join(["Hello world! "] * 1000) # long input document
>>> input_ids = torch.tensor(tokenizer.encode(SAMPLE_TEXT)).unsqueeze(0) # batch of size 1
>>> attention_mask = torch.ones(
... input_ids.shape, dtype=torch.long, device=input_ids.device
... ) # initialize to local attention
>>> global_attention_mask = torch.zeros(
... input_ids.shape, dtype=torch.long, device=input_ids.device
... ) # initialize to global attention to be deactivated for all tokens
>>> global_attention_mask[
... :,
... [
... 1,
... 4,
... 21,
... ],
... ] = 1 # Set global attention to random tokens for the sake of this example
>>> # Usually, set global attention based on the task. For example,
>>> # classification: the <s> token
>>> # QA: question tokens
>>> # LM: potentially on the beginning of sentences and paragraphs
>>> outputs = model(input_ids, attention_mask=attention_mask, global_attention_mask=global_attention_mask)
>>> sequence_output = outputs.last_hidden_state
>>> pooled_output = outputs.pooler_outputLongformerForMaskedLM
class transformers.LongformerForMaskedLM
< 来源 >( config )
参数
- config (LongformerForMaskedLM) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
带有一个 `语言建模` 头的 Longformer 模型。
此模型继承自 PreTrainedModel。请查阅超类文档以了解该库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪注意力头等）。
该模型也是一个 PyTorch torch.nn.Module 子类。可以像常规 PyTorch Module 一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。
forward
< 来源 >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None global_attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下，填充将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：- 1 表示标记未被掩码，
- 0 表示标记被掩码。
- global_attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 用于决定每个标记的注意力类型，是局部注意力还是全局注意力的掩码。具有全局注意力的标记会关注所有其他标记，而所有其他标记也会关注它们。这对于特定任务的微调非常重要，因为它使模型在表示任务方面更加灵活。例如，对于分类任务，标记应给予全局注意力。对于问答任务，所有问题标记也应具有全局注意力。请参阅 Longformer 论文 了解更多详情。掩码值在[0, 1]中选择：- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（标记关注所有其他标记，并且所有其他标记都关注它们）。
- head_mask (
torch.Tensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于将自注意力模块中选定的头置零的掩码。掩码值在[0, 1]中选择：- 1 表示头未被掩码，
- 0 表示头被掩码。
- token_type_ids (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 片段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于 句子 A 的标记，
- 1 对应于 句子 B 的标记。
- position_ids (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在[0, config.n_positions - 1]范围内选择。 - inputs_embeds (
torch.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，你可以选择直接传递嵌入表示，而不是传递input_ids。如果你希望比模型内部的嵌入查找矩阵有更多控制权来将input_ids索引转换为相关向量，这将非常有用。 - labels (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]范围内（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅针对标签在[0, ..., config.vocab_size]范围内的标记计算。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
返回
transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.longformer.modeling_longformer.LongformerMaskedLMOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或 config.return_dict=False），根据配置 (LongformerConfig) 和输入包含不同的元素。
-
loss (形状为
(1,)的torch.FloatTensor，可选，当提供labels时返回) — 掩码语言建模 (MLM) 损失。 -
logits (形状为
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 语言建模头部的预测分数（SoftMax 之前的每个词汇标记的分数）。 -
hidden_states (
tuple[torch.FloatTensor, ...]，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 每个层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是具有全局注意力掩码的标记数量。注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个标记对每个具有全局注意力的标记（前
x个值）以及注意力窗口中每个标记（剩余的 `attention_window- + 1` 个值）的注意力权重。请注意，前
x个值指的是文本中位置固定的标记，但剩余的 `attention_window + 1` 个值指的是相对位置的标记：一个标记对其自身的注意力权重位于索引 `x + attention_window / 2`，而前面（后面）的 `attention_window / 2` 个值是对应前面（后面）的 `attention_window / 2` 个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则相应索引处的注意力权重设置为 0；该值应从前x个注意力权重中获取。如果一个标记具有全局注意力，则 `attentions` 中对所有其他标记的注意力权重设置为 0，这些值应从 `global_attentions` 中获取。
- + 1` 个值）的注意力权重。请注意，前
-
global_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数量。注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记对序列中每个标记的注意力权重。
LongformerForMaskedLM 的前向方法，重写了 __call__ 特殊方法。
尽管前向传播的流程需要在此函数内定义，但之后应调用 Module 实例而不是此函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
掩码填充示例
>>> from transformers import AutoTokenizer, LongformerForMaskedLM
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = LongformerForMaskedLM.from_pretrained("allenai/longformer-base-4096")让我们尝试一个非常长的输入。
>>> TXT = (
... "My friends are <mask> but they eat too many carbs."
... + " That's why I decide not to eat with them." * 300
... )
>>> input_ids = tokenizer([TXT], return_tensors="pt")["input_ids"]
>>> logits = model(input_ids).logits
>>> masked_index = (input_ids[0] == tokenizer.mask_token_id).nonzero().item()
>>> probs = logits[0, masked_index].softmax(dim=0)
>>> values, predictions = probs.topk(5)
>>> tokenizer.decode(predictions).split()
['healthy', 'skinny', 'thin', 'good', 'vegetarian']LongformerForSequenceClassification
class transformers.LongformerForSequenceClassification
< 来源 >( config )
参数
- config (LongformerForSequenceClassification) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
Longformer 模型 transformer，带有一个序列分类/回归头（在池化输出之上加一个线性层），例如用于 GLUE 任务。
此模型继承自 PreTrainedModel。请查阅超类文档以了解该库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪注意力头等）。
该模型也是一个 PyTorch torch.nn.Module 子类。可以像常规 PyTorch Module 一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。
forward
< 来源 >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None global_attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下，填充将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：- 1 表示标记未被掩码，
- 0 表示标记被掩码。
- global_attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 用于决定每个标记的注意力类型，是局部注意力还是全局注意力的掩码。具有全局注意力的标记会关注所有其他标记，而所有其他标记也会关注它们。这对于特定任务的微调非常重要，因为它使模型在表示任务方面更加灵活。例如，对于分类任务，标记应给予全局注意力。对于问答任务，所有问题标记也应具有全局注意力。请参阅 Longformer 论文 了解更多详情。掩码值在[0, 1]中选择：- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（标记关注所有其他标记，并且所有其他标记都关注它们）。
- head_mask (
torch.Tensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于将自注意力模块中选定的头置零的掩码。掩码值在[0, 1]中选择：- 1 表示头未被掩码，
- 0 表示头被掩码。
- token_type_ids (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 片段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于 句子 A 的标记，
- 1 对应于 句子 B 的标记。
- position_ids (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在[0, config.n_positions - 1]范围内选择。 - inputs_embeds (
torch.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，你可以选择直接传递嵌入表示，而不是传递input_ids。如果你希望比模型内部的嵌入查找矩阵有更多控制权来将input_ids索引转换为相关向量，这将非常有用。 - labels (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
返回
transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.longformer.modeling_longformer.LongformerSequenceClassifierOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或 config.return_dict=False），根据配置 (LongformerConfig) 和输入包含不同的元素。
-
loss (形状为
(1,)的torch.FloatTensor，可选，当提供labels时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。 -
logits (形状为
(batch_size, config.num_labels)的torch.FloatTensor) — 分类（如果 config.num_labels==1，则为回归）分数（SoftMax 之前）。 -
hidden_states (
tuple[torch.FloatTensor, ...]，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 每个层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是具有全局注意力掩码的标记数量。注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个标记对每个具有全局注意力的标记（前
x个值）以及注意力窗口中每个标记（剩余的 `attention_window- + 1` 个值）的注意力权重。请注意，前
x个值指的是文本中位置固定的标记，但剩余的 `attention_window + 1` 个值指的是相对位置的标记：一个标记对其自身的注意力权重位于索引 `x + attention_window / 2`，而前面（后面）的 `attention_window / 2` 个值是对应前面（后面）的 `attention_window / 2` 个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则相应索引处的注意力权重设置为 0；该值应从前x个注意力权重中获取。如果一个标记具有全局注意力，则 `attentions` 中对所有其他标记的注意力权重设置为 0，这些值应从 `global_attentions` 中获取。
- + 1` 个值）的注意力权重。请注意，前
-
global_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数量。注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记对序列中每个标记的注意力权重。
LongformerForSequenceClassification 的前向方法，重写了 __call__ 特殊方法。
尽管前向传播的流程需要在此函数内定义，但之后应调用 Module 实例而不是此函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
单标签分类示例
>>> import torch
>>> from transformers import AutoTokenizer, LongformerForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = LongformerForSequenceClassification.from_pretrained("allenai/longformer-base-4096")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = LongformerForSequenceClassification.from_pretrained("allenai/longformer-base-4096", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...多标签分类示例
>>> import torch
>>> from transformers import AutoTokenizer, LongformerForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = LongformerForSequenceClassification.from_pretrained("allenai/longformer-base-4096", problem_type="multi_label_classification")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = LongformerForSequenceClassification.from_pretrained(
... "allenai/longformer-base-4096", num_labels=num_labels, problem_type="multi_label_classification"
... )
>>> labels = torch.sum(
... torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).lossLongformerForMultipleChoice
class transformers.LongformerForMultipleChoice
< 来源 >( config )
参数
- config (LongformerForMultipleChoice) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
带有多项选择分类头的 Longformer 模型（在池化输出之上加一个线性层和一个 softmax），例如用于 RocStories/SWAG 任务。
此模型继承自 PreTrainedModel。请查阅超类文档以了解该库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪注意力头等）。
该模型也是一个 PyTorch torch.nn.Module 子类。可以像常规 PyTorch Module 一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。
forward
< 来源 >( input_ids: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None global_attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, num_choices, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- token_type_ids (
torch.LongTensor，形状为(batch_size, num_choices, sequence_length)，可选) — 片段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于 句子 A 的标记，
- 1 对应于 句子 B 的标记。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力机制的掩码。掩码值选自[0, 1]：- 1 表示标记未被掩码，
- 0 表示标记已被掩码。
- global_attention_mask (
torch.FloatTensor，形状为(batch_size, num_choices, sequence_length)，可选) — 用于决定对每个标记应用局部注意力还是全局注意力的掩码。具有全局注意力的标记会关注所有其他标记，而所有其他标记也会关注它们。这对于特定任务的微调非常重要，因为它使模型在表示任务时更具灵活性。例如，对于分类任务，标记应给予全局注意力。对于问答任务，所有问题标记也应具有全局注意力。请参阅 Longformer 论文了解更多详情。掩码值选自[0, 1]：- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（标记会关注所有其他标记，而所有其他标记也会关注它们）。
- head_mask (
torch.Tensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使自注意力模块中选定的头无效的掩码。掩码值选自[0, 1]：- 1 表示该头未被掩码，
- 0 表示该头已被掩码。
- labels (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算多项选择分类损失的标签。索引应在[0, ..., num_choices-1]范围内，其中num_choices是输入张量第二个维度的大小。（见上面的input_ids） - position_ids (
torch.LongTensor，形状为(batch_size, num_choices, sequence_length)，可选) — 位置嵌入中每个输入序列标记的位置索引。选自[0, config.max_position_embeddings - 1]范围。 - inputs_embeds (
torch.FloatTensor，形状为(batch_size, num_choices, sequence_length, hidden_size)，可选) — 或者，你可以选择直接传递嵌入表示，而不是传递input_ids。如果你想比模型内部的嵌入查找矩阵更好地控制如何将input_ids索引转换为相关向量，这会非常有用。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
返回
transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.longformer.modeling_longformer.LongformerMultipleChoiceModelOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），根据配置（LongformerConfig）和输入，包含各种元素。
-
loss (形状为 (1,) 的
torch.FloatTensor，可选，当提供labels时返回) — 分类损失。 -
logits (形状为
(batch_size, num_choices)的torch.FloatTensor) — num_choices 是输入张量的第二维大小。（请参阅上面的 input_ids）。分类分数（SoftMax 之前）。
-
hidden_states (
tuple[torch.FloatTensor, ...]，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 每个层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是具有全局注意力掩码的标记数量。注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个标记对每个具有全局注意力的标记（前
x个值）以及注意力窗口中每个标记（剩余的 `attention_window- + 1` 个值）的注意力权重。请注意，前
x个值指的是文本中位置固定的标记，但剩余的 `attention_window + 1` 个值指的是相对位置的标记：一个标记对其自身的注意力权重位于索引 `x + attention_window / 2`，而前面（后面）的 `attention_window / 2` 个值是对应前面（后面）的 `attention_window / 2` 个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则相应索引处的注意力权重设置为 0；该值应从前x个注意力权重中获取。如果一个标记具有全局注意力，则 `attentions` 中对所有其他标记的注意力权重设置为 0，这些值应从 `global_attentions` 中获取。
- + 1` 个值）的注意力权重。请注意，前
-
global_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数量。注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记对序列中每个标记的注意力权重。
LongformerForMultipleChoice 的前向方法会覆盖 __call__ 特殊方法。
尽管前向传播的流程需要在此函数内定义，但之后应调用 Module 实例而不是此函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, LongformerForMultipleChoice
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = LongformerForMultipleChoice.from_pretrained("allenai/longformer-base-4096")
>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0) # choice0 is correct (according to Wikipedia ;)), batch size 1
>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels) # batch size is 1
>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logitsLongformerForTokenClassification
class transformers.LongformerForTokenClassification
< 来源 >( config )
参数
- config (LongformerForTokenClassification) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
带有词元分类头的 Longformer transformer（在隐藏状态输出之上加一个线性层），例如用于命名实体识别（NER）任务。
此模型继承自 PreTrainedModel。请查阅超类文档以了解该库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪注意力头等）。
该模型也是一个 PyTorch torch.nn.Module 子类。可以像常规 PyTorch Module 一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。
forward
< 来源 >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None global_attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下，填充将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力机制的掩码。掩码值选自[0, 1]：- 1 表示标记未被掩码，
- 0 表示标记已被掩码。
- global_attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 用于决定对每个标记应用局部注意力还是全局注意力的掩码。具有全局注意力的标记会关注所有其他标记，而所有其他标记也会关注它们。这对于特定任务的微调非常重要，因为它使模型在表示任务时更具灵活性。例如，对于分类任务，标记应给予全局注意力。对于问答任务，所有问题标记也应具有全局注意力。请参阅 Longformer 论文了解更多详情。掩码值选自[0, 1]：- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（标记会关注所有其他标记，而所有其他标记也会关注它们）。
- head_mask (
torch.Tensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使自注意力模块中选定的头无效的掩码。掩码值选自[0, 1]：- 1 表示该头未被掩码，
- 0 表示该头已被掩码。
- token_type_ids (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 段标记索引，用于指示输入的第一部分和第二部分。索引选自[0, 1]：- 0 对应于 *句子 A* 标记，
- 1 对应于 *句子 B* 标记。
- position_ids (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列标记的位置索引。选自[0, config.n_positions - 1]范围。 - inputs_embeds (
torch.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 或者，你可以选择直接传递嵌入表示，而不是传递input_ids。如果你想比模型内部的嵌入查找矩阵更好地控制如何将input_ids索引转换为相关向量，这会非常有用。 - labels (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于计算词元分类损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
返回
transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.longformer.modeling_longformer.LongformerTokenClassifierOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），根据配置（LongformerConfig）和输入，包含各种元素。
-
loss (形状为
(1,)的torch.FloatTensor，可选，当提供labels时返回) — 分类损失。 -
logits (形状为
(batch_size, sequence_length, config.num_labels)的torch.FloatTensor) — 分类分数（SoftMax 之前）。 -
hidden_states (
tuple[torch.FloatTensor, ...]，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 每个层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是具有全局注意力掩码的标记数量。注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个标记对每个具有全局注意力的标记（前
x个值）以及注意力窗口中每个标记（剩余的 `attention_window- + 1` 个值）的注意力权重。请注意，前
x个值指的是文本中位置固定的标记，但剩余的 `attention_window + 1` 个值指的是相对位置的标记：一个标记对其自身的注意力权重位于索引 `x + attention_window / 2`，而前面（后面）的 `attention_window / 2` 个值是对应前面（后面）的 `attention_window / 2` 个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则相应索引处的注意力权重设置为 0；该值应从前x个注意力权重中获取。如果一个标记具有全局注意力，则 `attentions` 中对所有其他标记的注意力权重设置为 0，这些值应从 `global_attentions` 中获取。
- + 1` 个值）的注意力权重。请注意，前
-
global_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数量。注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记对序列中每个标记的注意力权重。
LongformerForTokenClassification 的前向方法会覆盖 __call__ 特殊方法。
尽管前向传播的流程需要在此函数内定义，但之后应调用 Module 实例而不是此函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, LongformerForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = LongformerForTokenClassification.from_pretrained("allenai/longformer-base-4096")
>>> inputs = tokenizer(
... "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_token_class_ids = logits.argmax(-1)
>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes
...
>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...LongformerForQuestionAnswering
class transformers.LongformerForQuestionAnswering
< 来源 >( config )
参数
- config (LongformerForQuestionAnswering) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
带有片段分类头的 Longformer transformer，用于像 SQuAD 这样的抽取式问答任务（在隐藏状态输出之上加一个线性层来计算 `片段开始 logits` 和 `片段结束 logits`）。
此模型继承自 PreTrainedModel。请查阅超类文档以了解该库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪注意力头等）。
该模型也是一个 PyTorch torch.nn.Module 子类。可以像常规 PyTorch Module 一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。
forward
< 来源 >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None global_attention_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None start_positions: typing.Optional[torch.Tensor] = None end_positions: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下，填充将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力机制的掩码。掩码值选自[0, 1]：- 1 表示标记未被掩码，
- 0 表示标记已被掩码。
- global_attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 用于决定对每个标记应用局部注意力还是全局注意力的掩码。具有全局注意力的标记会关注所有其他标记，而所有其他标记也会关注它们。这对于特定任务的微调非常重要，因为它使模型在表示任务时更具灵活性。例如，对于分类任务，标记应给予全局注意力。对于问答任务，所有问题标记也应具有全局注意力。请参阅 Longformer 论文了解更多详情。掩码值选自[0, 1]：- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（标记会关注所有其他标记，而所有其他标记也会关注它们）。
- head_mask (
torch.Tensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使自注意力模块中选定的头无效的掩码。掩码值选自[0, 1]：- 1 表示该头未被掩码，
- 0 表示该头已被掩码。
- token_type_ids (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 段标记索引，用于指示输入的第一部分和第二部分。索引选自[0, 1]：- 0 对应于 *句子 A* 标记，
- 1 对应于 *句子 B* 标记。
- position_ids (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列标记的位置索引。选自[0, config.n_positions - 1]范围。 - inputs_embeds (
torch.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 或者，你可以选择直接传递嵌入表示，而不是传递input_ids。如果你想比模型内部的嵌入查找矩阵更好地控制如何将input_ids索引转换为相关向量，这会非常有用。 - start_positions (
torch.Tensor，形状为(batch_size,)，可选) — 标记的片段开始位置（索引）的标签，用于计算词元分类损失。位置被限制在序列长度（sequence_length）内。序列之外的位置在计算损失时不予考虑。 - end_positions (
torch.Tensor，形状为(batch_size,)，可选) — 标记的片段结束位置（索引）的标签，用于计算词元分类损失。位置被限制在序列长度（sequence_length）内。序列之外的位置在计算损失时不予考虑。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
返回
transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.longformer.modeling_longformer.LongformerQuestionAnsweringModelOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），根据配置（LongformerConfig）和输入，包含各种元素。
-
loss (
torch.FloatTensorof shape(1,), 可选, 当提供labels时返回) — 总范围提取损失是起始位置和结束位置的交叉熵之和。 -
start_logits (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选，默认为None) — 跨度开始分数（SoftMax 之前）。 -
end_logits (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选，默认为None) — 跨度结束分数（SoftMax 之前）。 -
hidden_states (
tuple[torch.FloatTensor, ...]，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 每个层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是具有全局注意力掩码的标记数量。注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个标记对每个具有全局注意力的标记（前
x个值）以及注意力窗口中每个标记（剩余的 `attention_window- + 1` 个值）的注意力权重。请注意，前
x个值指的是文本中位置固定的标记，但剩余的 `attention_window + 1` 个值指的是相对位置的标记：一个标记对其自身的注意力权重位于索引 `x + attention_window / 2`，而前面（后面）的 `attention_window / 2` 个值是对应前面（后面）的 `attention_window / 2` 个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则相应索引处的注意力权重设置为 0；该值应从前x个注意力权重中获取。如果一个标记具有全局注意力，则 `attentions` 中对所有其他标记的注意力权重设置为 0，这些值应从 `global_attentions` 中获取。
- + 1` 个值）的注意力权重。请注意，前
-
global_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数量。注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记对序列中每个标记的注意力权重。
LongformerForQuestionAnswering 的前向方法会覆盖 __call__ 特殊方法。
尽管前向传播的流程需要在此函数内定义，但之后应调用 Module 实例而不是此函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, LongformerForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-large-4096-finetuned-triviaqa")
>>> model = LongformerForQuestionAnswering.from_pretrained("allenai/longformer-large-4096-finetuned-triviaqa")
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> encoding = tokenizer(question, text, return_tensors="pt")
>>> input_ids = encoding["input_ids"]
>>> # default is local attention everywhere
>>> # the forward method will automatically set global attention on question tokens
>>> attention_mask = encoding["attention_mask"]
>>> outputs = model(input_ids, attention_mask=attention_mask)
>>> start_logits = outputs.start_logits
>>> end_logits = outputs.end_logits
>>> all_tokens = tokenizer.convert_ids_to_tokens(input_ids[0].tolist())
>>> answer_tokens = all_tokens[torch.argmax(start_logits) : torch.argmax(end_logits) + 1]
>>> answer = tokenizer.decode(
... tokenizer.convert_tokens_to_ids(answer_tokens)
... ) # remove space prepending space tokenTFLongformerModel
class transformers.TFLongformerModel
< 来源 >( config *inputs **kwargs )
参数
- config (LongformerConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
基础的 Longformer 模型，输出原始的隐藏状态，顶部没有任何特定的头。
该模型继承自 TFPreTrainedModel。请查阅超类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪注意力头等）。
该模型也是 keras.Model 的子类。可以像常规 TF 2.0 Keras 模型一样使用它，并参考 TF 2.0 文档了解所有与通用用法和行为相关的事项。
transformers 中的 TensorFlow 模型和层接受两种输入格式
- 所有输入作为关键字参数（如 PyTorch 模型），或
- 所有输入作为第一个位置参数中的列表、元组或字典。
支持第二种格式的原因是，Keras 方法在向模型和层传递输入时更偏好这种格式。由于这种支持，当使用像 model.fit() 这样的方法时，事情应该会“自然而然”地为你工作——只需以 model.fit() 支持的任何格式传递你的输入和标签即可！然而，如果你想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional API 创建自己的层或模型时，有三种可能的方法可以将所有输入张量收集到第一个位置参数中。
- 只有一个
input_ids的单个张量，没有其他：model(input_ids) - 长度可变的列表，包含一个或多个输入张量，按文档字符串中给出的顺序：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一个字典，其中包含一个或多个与文档字符串中给出的输入名称关联的输入张量：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，当使用子类化创建模型和层时，你无需担心任何这些问题，因为你可以像调用任何其他 Python 函数一样传递输入！
该类复制了 TFRobertaModel 的代码，并用 Longformer 自注意力机制覆盖了标准的自注意力机制，以提供处理长序列的能力。这遵循了 Iz Beltagy、Matthew E. Peters 和 Arman Cohan 在 Longformer: the Long-Document Transformer 中描述的自注意力方法。Longformer 自注意力结合了局部（滑动窗口）和全局注意力，以扩展到长文档，而不会导致内存和计算量呈 O(n^2) 增长。
此处实现的自注意力模块 TFLongformerSelfAttention 支持局部和全局注意力的组合，但它不支持自回归注意力和扩张注意力。自回归和扩张注意力更多地与自回归语言建模相关，而不是在下游任务上进行微调。未来的版本将增加对自回归注意力的支持，但要高效地支持扩张注意力，则需要一个自定义的 CUDA 内核来实现内存和计算效率。
调用
< source >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None global_attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False )
参数
- input_ids (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值在[0, 1]中选择：- 1 表示标记未被屏蔽，
- 0 表示标记已被屏蔽。
- head_mask (
np.ndarray或tf.Tensor，形状为(encoder_layers, encoder_attention_heads)，可选) — 用于屏蔽注意力模块中选定头的掩码。掩码值在[0, 1]中选择：- 1 表示头未被屏蔽，
- 0 表示头已被屏蔽。
- global_attention_mask (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 用于决定每个标记上应用的注意力类型（局部注意力或全局注意力）的掩码。具有全局注意力的标记会关注所有其他标记，而所有其他标记也会关注它们。这对于特定任务的微调非常重要，因为它使模型在表示任务方面更加灵活。例如，对于分类任务，标记应给予全局注意力。对于问答任务，所有问题标记也应具有全局注意力。请参阅 Longformer 论文 了解更多详情。掩码值在[0, 1]中选择：- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（标记会关注所有其他标记，而所有其他标记也会关注它们）。
- token_type_ids (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 片段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于 *句子 A* 的标记，
- 1 对应于 *句子 B* 的标记。
- position_ids (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。 - inputs_embeds (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — （可选）你可以选择直接传递嵌入表示，而不是传递input_ids。如果你希望比模型内部的嵌入查找矩阵更能控制如何将input_ids索引转换为关联向量，这会很有用。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数只能在 Eager 模式下使用，在图模式下将使用配置中的值。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数只能在 Eager 模式下使用，在图模式下将使用配置中的值。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。此参数可以在 Eager 模式下使用，在图模式下，该值将始终设置为 True。 - training (
bool，可选，默认为False) — 是否在训练模式下使用模型（某些模块如 dropout 模块在训练和评估之间有不同的行为）。
TFLongformerModel 的前向方法会覆盖 __call__ 特殊方法。
尽管前向传播的流程需要在此函数内定义，但之后应调用 Module 实例而不是此函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
TFLongformerForMaskedLM
class transformers.TFLongformerForMaskedLM
< source >( config *inputs **kwargs )
参数
- config (LongformerConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
带有 `language modeling` 头的 Longformer 模型。
该模型继承自 TFPreTrainedModel。请查阅超类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪注意力头等）。
该模型也是 keras.Model 的子类。可以像常规 TF 2.0 Keras 模型一样使用它，并参考 TF 2.0 文档了解所有与通用用法和行为相关的事项。
transformers 中的 TensorFlow 模型和层接受两种输入格式
- 所有输入作为关键字参数（如 PyTorch 模型），或
- 所有输入作为第一个位置参数中的列表、元组或字典。
支持第二种格式的原因是，Keras 方法在向模型和层传递输入时更偏好这种格式。由于这种支持，当使用像 model.fit() 这样的方法时，事情应该会“自然而然”地为你工作——只需以 model.fit() 支持的任何格式传递你的输入和标签即可！然而，如果你想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional API 创建自己的层或模型时，有三种可能的方法可以将所有输入张量收集到第一个位置参数中。
- 只有一个
input_ids的单个张量，没有其他：model(input_ids) - 长度可变的列表，包含一个或多个输入张量，按文档字符串中给出的顺序：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一个字典，其中包含一个或多个与文档字符串中给出的输入名称关联的输入张量：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，当使用子类化创建模型和层时，你无需担心任何这些问题，因为你可以像调用任何其他 Python 函数一样传递输入！
调用
< source >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None global_attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → transformers.models.longformer.modeling_tf_longformer.TFLongformerMaskedLMOutput 或 tuple(tf.Tensor)
参数
- input_ids (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值在[0, 1]中选择：- 1 表示标记未被屏蔽，
- 0 表示标记已被屏蔽。
- head_mask (
np.ndarray或tf.Tensor，形状为(encoder_layers, encoder_attention_heads)，可选) — 用于屏蔽注意力模块中选定头的掩码。掩码值在[0, 1]中选择：- 1 表示头未被屏蔽，
- 0 表示头已被屏蔽。
- global_attention_mask (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 用于决定每个标记上应用的注意力类型（局部注意力或全局注意力）的掩码。具有全局注意力的标记会关注所有其他标记，而所有其他标记也会关注它们。这对于特定任务的微调非常重要，因为它使模型在表示任务方面更加灵活。例如，对于分类任务，标记应给予全局注意力。对于问答任务，所有问题标记也应具有全局注意力。请参阅 Longformer 论文 了解更多详情。掩码值在[0, 1]中选择：- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（标记会关注所有其他标记，而所有其他标记也会关注它们）。
- token_type_ids (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 片段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于 *句子 A* 的标记，
- 1 对应于 *句子 B* 的标记。
- position_ids (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。 - inputs_embeds (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — （可选）你可以选择直接传递嵌入表示，而不是传递input_ids。如果你希望比模型内部的嵌入查找矩阵更能控制如何将input_ids索引转换为关联向量，这会很有用。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数只能在 Eager 模式下使用，在图模式下将使用配置中的值。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数只能在 Eager 模式下使用，在图模式下将使用配置中的值。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。此参数可以在 Eager 模式下使用，在图模式下，该值将始终设置为 True。 - training (
bool，可选，默认为False) — 是否在训练模式下使用模型（某些模块如 dropout 模块在训练和评估之间有不同的行为）。 - labels (
tf.Tensor，形状为(batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]范围内（请参阅input_ids文档字符串）。索引设置为-100的标记将被忽略（屏蔽），损失仅对标签在[0, ..., config.vocab_size]范围内的标记进行计算。
返回
transformers.models.longformer.modeling_tf_longformer.TFLongformerMaskedLMOutput 或 tuple(tf.Tensor)
一个 transformers.models.longformer.modeling_tf_longformer.TFLongformerMaskedLMOutput 或一个 tf.Tensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），根据配置（LongformerConfig）和输入，包含各种元素。
-
loss (
tf.Tensor，形状为(1,)，可选，当提供labels时返回) — 掩码语言建模 (MLM) 损失。 -
logits (
tf.Tensorof shape(batch_size, sequence_length, config.vocab_size)) — 语言模型头部的预测分数（SoftMax 之前每个词汇标记的分数）。 -
hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入的输出 + 每个层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态加上初始嵌入输出。
-
attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是具有全局注意力掩码的标记数量。注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个标记对每个具有全局注意力的标记（前
x个值）以及注意力窗口中每个标记（剩余的 `attention_window- + 1` 个值）的注意力权重。请注意，前
x个值指的是文本中位置固定的标记，但剩余的 `attention_window + 1` 个值指的是相对位置的标记：一个标记对其自身的注意力权重位于索引 `x + attention_window / 2`，而前面（后面）的 `attention_window / 2` 个值是对应前面（后面）的 `attention_window / 2` 个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则相应索引处的注意力权重设置为 0；该值应从前x个注意力权重中获取。如果一个标记具有全局注意力，则 `attentions` 中对所有其他标记的注意力权重设置为 0，这些值应从 `global_attentions` 中获取。
- + 1` 个值）的注意力权重。请注意，前
-
global_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数量。注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记对序列中每个标记的注意力权重。
TFLongformerForMaskedLM 的前向方法会覆盖 __call__ 特殊方法。
尽管前向传播的流程需要在此函数内定义，但之后应调用 Module 实例而不是此函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFLongformerForMaskedLM
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = TFLongformerForMaskedLM.from_pretrained("allenai/longformer-base-4096")
>>> inputs = tokenizer("The capital of France is <mask>.", return_tensors="tf")
>>> logits = model(**inputs).logits
>>> # retrieve index of <mask>
>>> mask_token_index = tf.where((inputs.input_ids == tokenizer.mask_token_id)[0])
>>> selected_logits = tf.gather_nd(logits[0], indices=mask_token_index)
>>> predicted_token_id = tf.math.argmax(selected_logits, axis=-1)
>>> tokenizer.decode(predicted_token_id)
' Paris'TFLongformerForQuestionAnswering
class transformers.TFLongformerForQuestionAnswering
< source >( config *inputs **kwargs )
参数
- config (LongformerConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
带有片段分类头的 Longformer 模型，用于抽取式问答任务，如 SQuAD / TriviaQA（在隐藏状态输出之上有一个线性层，用于计算 `span start logits` 和 `span end logits`）。
该模型继承自 TFPreTrainedModel。请查阅超类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪注意力头等）。
该模型也是 keras.Model 的子类。可以像常规 TF 2.0 Keras 模型一样使用它，并参考 TF 2.0 文档了解所有与通用用法和行为相关的事项。
transformers 中的 TensorFlow 模型和层接受两种输入格式
- 所有输入作为关键字参数（如 PyTorch 模型），或
- 所有输入作为第一个位置参数中的列表、元组或字典。
支持第二种格式的原因是，Keras 方法在向模型和层传递输入时更偏好这种格式。由于这种支持，当使用像 model.fit() 这样的方法时，事情应该会“自然而然”地为你工作——只需以 model.fit() 支持的任何格式传递你的输入和标签即可！然而，如果你想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional API 创建自己的层或模型时，有三种可能的方法可以将所有输入张量收集到第一个位置参数中。
- 只有一个
input_ids的单个张量，没有其他：model(input_ids) - 长度可变的列表，包含一个或多个输入张量，按文档字符串中给出的顺序：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一个字典，其中包含一个或多个与文档字符串中给出的输入名称关联的输入张量：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，当使用子类化创建模型和层时，你无需担心任何这些问题，因为你可以像调用任何其他 Python 函数一样传递输入！
调用
< source >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None global_attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None start_positions: np.ndarray | tf.Tensor | None = None end_positions: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → transformers.models.longformer.modeling_tf_longformer.TFLongformerQuestionAnsweringModelOutput 或 tuple(tf.Tensor)
参数
- input_ids (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值在[0, 1]中选择：- 1 表示标记未被屏蔽，
- 0 表示标记已被屏蔽。
- head_mask (
np.ndarray或tf.Tensor，形状为(encoder_layers, encoder_attention_heads)，可选) — 用于屏蔽注意力模块中选定头的掩码。掩码值在[0, 1]中选择：- 1 表示头未被屏蔽，
- 0 表示头已被屏蔽。
- global_attention_mask (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 用于决定每个标记上应用的注意力类型（局部注意力或全局注意力）的掩码。具有全局注意力的标记会关注所有其他标记，而所有其他标记也会关注它们。这对于特定任务的微调非常重要，因为它使模型在表示任务方面更加灵活。例如，对于分类任务，标记应给予全局注意力。对于问答任务，所有问题标记也应具有全局注意力。请参阅 Longformer 论文 了解更多详情。掩码值在[0, 1]中选择：- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（标记会关注所有其他标记，而所有其他标记也会关注它们）。
- token_type_ids (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 片段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于 *句子 A* 的标记，
- 1 对应于 *句子 B* 的标记。
- position_ids (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。 - inputs_embeds (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — （可选）你可以选择直接传递嵌入表示，而不是传递input_ids。如果你希望比模型内部的嵌入查找矩阵更能控制如何将input_ids索引转换为关联向量，这会很有用。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数只能在 Eager 模式下使用，在图模式下将使用配置中的值。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数只能在 Eager 模式下使用，在图模式下将使用配置中的值。 - return_dict (
bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。此参数可在 Eager 模式下使用，在图模式下该值将始终设置为 True。 - training (
bool, 可选, 默认为False) — 是否在训练模式下使用模型（某些模块如 dropout 模块在训练和评估模式下有不同的行为）。 - start_positions (
tf.Tensor，形状为(batch_size,), 可选) — 用于计算词元分类损失的标注范围的起始位置（索引）标签。位置被限制在序列长度（sequence_length）范围内。序列之外的位置在计算损失时不会被考虑。 - end_positions (
tf.Tensor，形状为(batch_size,), 可选) — 用于计算词元分类损失的标注范围的结束位置（索引）标签。位置被限制在序列长度（sequence_length）范围内。序列之外的位置在计算损失时不会被考虑。
返回
transformers.models.longformer.modeling_tf_longformer.TFLongformerQuestionAnsweringModelOutput 或 tuple(tf.Tensor)
一个 transformers.models.longformer.modeling_tf_longformer.TFLongformerQuestionAnsweringModelOutput 或一个 tf.Tensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含根据配置（LongformerConfig）和输入而异的各种元素。
-
loss (
tf.Tensor，形状为(1,), 可选, 当提供了labels时返回) — 总范围提取损失是起始和结束位置交叉熵损失的和。 -
start_logits (形状为
(batch_size, sequence_length)的tf.Tensor) — 跨度起始分数（SoftMax 之前）。 -
end_logits (形状为
(batch_size, sequence_length)的tf.Tensor) — 跨度结束分数（SoftMax 之前）。 -
hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入的输出 + 每个层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态加上初始嵌入输出。
-
attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是具有全局注意力掩码的标记数量。注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个标记对每个具有全局注意力的标记（前
x个值）以及注意力窗口中每个标记（剩余的 `attention_window- + 1` 个值）的注意力权重。请注意，前
x个值指的是文本中位置固定的标记，但剩余的 `attention_window + 1` 个值指的是相对位置的标记：一个标记对其自身的注意力权重位于索引 `x + attention_window / 2`，而前面（后面）的 `attention_window / 2` 个值是对应前面（后面）的 `attention_window / 2` 个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则相应索引处的注意力权重设置为 0；该值应从前x个注意力权重中获取。如果一个标记具有全局注意力，则 `attentions` 中对所有其他标记的注意力权重设置为 0，这些值应从 `global_attentions` 中获取。
- + 1` 个值）的注意力权重。请注意，前
-
global_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数量。注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记对序列中每个标记的注意力权重。
TFLongformerForQuestionAnswering 的前向方法，重写了 __call__ 特殊方法。
尽管前向传播的流程需要在此函数内定义，但之后应调用 Module 实例而不是此函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFLongformerForQuestionAnswering
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-large-4096-finetuned-triviaqa")
>>> model = TFLongformerForQuestionAnswering.from_pretrained("allenai/longformer-large-4096-finetuned-triviaqa")
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="tf")
>>> outputs = model(**inputs)
>>> answer_start_index = int(tf.math.argmax(outputs.start_logits, axis=-1)[0])
>>> answer_end_index = int(tf.math.argmax(outputs.end_logits, axis=-1)[0])
>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens)
' puppet'TFLongformerForSequenceClassification
class transformers.TFLongformerForSequenceClassification
< 来源 >( config *inputs **kwargs )
参数
- config (LongformerConfig) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
Longformer 模型 transformer，带有一个序列分类/回归头（在池化输出之上加一个线性层），例如用于 GLUE 任务。
该模型继承自 TFPreTrainedModel。请查阅超类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪注意力头等）。
该模型也是 keras.Model 的子类。可以像常规 TF 2.0 Keras 模型一样使用它，并参考 TF 2.0 文档了解所有与通用用法和行为相关的事项。
transformers 中的 TensorFlow 模型和层接受两种输入格式
- 所有输入作为关键字参数（如 PyTorch 模型），或
- 所有输入作为第一个位置参数中的列表、元组或字典。
支持第二种格式的原因是，Keras 方法在向模型和层传递输入时更偏好这种格式。由于这种支持，当使用像 model.fit() 这样的方法时，事情应该会“自然而然”地为你工作——只需以 model.fit() 支持的任何格式传递你的输入和标签即可！然而，如果你想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional API 创建自己的层或模型时，有三种可能的方法可以将所有输入张量收集到第一个位置参数中。
- 只有一个
input_ids的单个张量，没有其他：model(input_ids) - 长度可变的列表，包含一个或多个输入张量，按文档字符串中给出的顺序：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一个字典，其中包含一个或多个与文档字符串中给出的输入名称关联的输入张量：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，当使用子类化创建模型和层时，你无需担心任何这些问题，因为你可以像调用任何其他 Python 函数一样传递输入！
调用
< 来源 >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None global_attention_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → transformers.models.longformer.modeling_tf_longformer.TFLongformerSequenceClassifierOutput 或 tuple(tf.Tensor)
参数
- input_ids (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列词元的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length), 可选) — 用于避免在填充词元索引上执行注意力的掩码。掩码值在[0, 1]中选择：- 1 表示词元未被屏蔽，
- 0 表示词元被屏蔽。
- head_mask (
np.ndarray或tf.Tensor，形状为(encoder_layers, encoder_attention_heads), 可选) — 用于使注意力模块的选定头无效的掩码。掩码值在[0, 1]中选择：- 1 表示头未被屏蔽，
- 0 表示头被屏蔽。
- global_attention_mask (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length), 可选) — 用于决定每个词元是使用局部注意力还是全局注意力的掩码。具有全局注意力的词元会关注所有其他词元，而所有其他词元也会关注它们。这对于特定任务的微调非常重要，因为它使模型在表示任务时更灵活。例如，对于分类任务，词元应被赋予全局注意力。对于问答任务，所有问题词元也应具有全局注意力。请参阅 Longformer 论文 获取更多详细信息。掩码值在[0, 1]中选择：- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（关注所有其他词元的词元，并且所有其他词元都关注它们）。
- token_type_ids (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length), 可选) — 段词元索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于 *句子 A* 的词元，
- 1 对应于 *句子 B* 的词元。
- position_ids (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length), 可选) — 每个输入序列词元在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。 - inputs_embeds (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length, hidden_size), 可选) — 可选地，你可以不传递input_ids，而是直接传递一个嵌入表示。如果你想比模型的内部嵌入查找矩阵更多地控制如何将input_ids索引转换为关联向量，这会很有用。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数只能在 Eager 模式下使用，在图模式下将使用配置中的值。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数只能在 Eager 模式下使用，在图模式下将使用配置中的值。 - return_dict (
bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。此参数可在 Eager 模式下使用，在图模式下该值将始终设置为 True。 - training (
bool, 可选, 默认为False) — 是否在训练模式下使用模型（某些模块如 dropout 模块在训练和评估模式下有不同的行为）。
返回
transformers.models.longformer.modeling_tf_longformer.TFLongformerSequenceClassifierOutput 或 tuple(tf.Tensor)
一个 transformers.models.longformer.modeling_tf_longformer.TFLongformerSequenceClassifierOutput 或一个 tf.Tensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含根据配置（LongformerConfig）和输入而异的各种元素。
-
loss (形状为
(1,)的tf.Tensor，可选，当提供labels时返回) — 分类（如果 config.num_labels==1，则为回归）损失。 -
logits (
tf.Tensor，形状为(batch_size, config.num_labels)) — 分类（或回归，如果 config.num_labels==1）分数（SoftMax 之前）。 -
hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入的输出 + 每个层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态加上初始嵌入输出。
-
attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是具有全局注意力掩码的标记数量。注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个标记对每个具有全局注意力的标记（前
x个值）以及注意力窗口中每个标记（剩余的 `attention_window- + 1` 个值）的注意力权重。请注意，前
x个值指的是文本中位置固定的标记，但剩余的 `attention_window + 1` 个值指的是相对位置的标记：一个标记对其自身的注意力权重位于索引 `x + attention_window / 2`，而前面（后面）的 `attention_window / 2` 个值是对应前面（后面）的 `attention_window / 2` 个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则相应索引处的注意力权重设置为 0；该值应从前x个注意力权重中获取。如果一个标记具有全局注意力，则 `attentions` 中对所有其他标记的注意力权重设置为 0，这些值应从 `global_attentions` 中获取。
- + 1` 个值）的注意力权重。请注意，前
-
global_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数量。注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记对序列中每个标记的注意力权重。
TFLongformerForSequenceClassification 的前向方法，重写了 __call__ 特殊方法。
尽管前向传播的流程需要在此函数内定义，但之后应调用 Module 实例而不是此函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFLongformerForSequenceClassification
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = TFLongformerForSequenceClassification.from_pretrained("allenai/longformer-base-4096")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> logits = model(**inputs).logits
>>> predicted_class_id = int(tf.math.argmax(logits, axis=-1)[0])>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = TFLongformerForSequenceClassification.from_pretrained("allenai/longformer-base-4096", num_labels=num_labels)
>>> labels = tf.constant(1)
>>> loss = model(**inputs, labels=labels).lossTFLongformerForTokenClassification
class transformers.TFLongformerForTokenClassification
< 来源 >( config *inputs **kwargs )
参数
- config (LongformerConfig) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
Longformer 模型，其顶部带有一个词元分类头（即在隐藏状态输出之上加一个线性层），例如用于命名实体识别（NER）任务。
该模型继承自 TFPreTrainedModel。请查阅超类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪注意力头等）。
该模型也是 keras.Model 的子类。可以像常规 TF 2.0 Keras 模型一样使用它，并参考 TF 2.0 文档了解所有与通用用法和行为相关的事项。
transformers 中的 TensorFlow 模型和层接受两种输入格式
- 所有输入作为关键字参数（如 PyTorch 模型），或
- 所有输入作为第一个位置参数中的列表、元组或字典。
支持第二种格式的原因是，Keras 方法在向模型和层传递输入时更偏好这种格式。由于这种支持，当使用像 model.fit() 这样的方法时，事情应该会“自然而然”地为你工作——只需以 model.fit() 支持的任何格式传递你的输入和标签即可！然而，如果你想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional API 创建自己的层或模型时，有三种可能的方法可以将所有输入张量收集到第一个位置参数中。
- 只有一个
input_ids的单个张量，没有其他：model(input_ids) - 长度可变的列表，包含一个或多个输入张量，按文档字符串中给出的顺序：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一个字典，其中包含一个或多个与文档字符串中给出的输入名称关联的输入张量：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，当使用子类化创建模型和层时，你无需担心任何这些问题，因为你可以像调用任何其他 Python 函数一样传递输入！
调用
< 来源 >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None global_attention_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: Optional[Union[np.array, tf.Tensor]] = None training: Optional[bool] = False ) → transformers.models.longformer.modeling_tf_longformer.TFLongformerTokenClassifierOutput 或 tuple(tf.Tensor)
参数
- input_ids (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列词元的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length), 可选) — 用于避免在填充词元索引上执行注意力的掩码。掩码值在[0, 1]中选择：- 1 表示词元未被屏蔽，
- 0 表示词元被屏蔽。
- head_mask (
np.ndarray或tf.Tensor，形状为(encoder_layers, encoder_attention_heads), 可选) — 用于使注意力模块的选定头无效的掩码。掩码值在[0, 1]中选择：- 1 表示头未被屏蔽，
- 0 表示头被屏蔽。
- global_attention_mask (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length), 可选) — 用于决定每个词元是使用局部注意力还是全局注意力的掩码。具有全局注意力的词元会关注所有其他词元，而所有其他词元也会关注它们。这对于特定任务的微调非常重要，因为它使模型在表示任务时更灵活。例如，对于分类任务，词元应被赋予全局注意力。对于问答任务，所有问题词元也应具有全局注意力。请参阅 Longformer 论文 获取更多详细信息。掩码值在[0, 1]中选择：- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（关注所有其他词元的词元，并且所有其他词元都关注它们）。
- token_type_ids (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length), 可选) — 段词元索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于 *句子 A* 的词元，
- 1 对应于 *句子 B* 的词元。
- position_ids (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length), 可选) — 每个输入序列词元在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。 - inputs_embeds (
np.ndarray或tf.Tensor，形状为(batch_size, sequence_length, hidden_size), 可选) — 可选地，你可以不传递input_ids，而是直接传递一个嵌入表示。如果你想比模型的内部嵌入查找矩阵更多地控制如何将input_ids索引转换为关联向量，这会很有用。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数只能在 Eager 模式下使用，在图模式下将使用配置中的值。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数只能在 Eager 模式下使用，在图模式下将使用配置中的值。 - return_dict (
bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。此参数可在 Eager 模式下使用，在图模式下该值将始终设置为 True。 - training (
bool, 可选, 默认为False) — 是否在训练模式下使用模型（某些模块如 dropout 模块在训练和评估模式下有不同的行为）。 - labels (
tf.Tensor，形状为(batch_size, sequence_length), 可选) — 用于计算词元分类损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。
返回
transformers.models.longformer.modeling_tf_longformer.TFLongformerTokenClassifierOutput 或 tuple(tf.Tensor)
一个 transformers.models.longformer.modeling_tf_longformer.TFLongformerTokenClassifierOutput 或一个 tf.Tensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含根据配置（LongformerConfig）和输入而异的各种元素。
-
loss (
tf.Tensor，形状为(1,), 可选, 当提供了labels时返回) — 分类损失。 -
logits (
tf.Tensor，形状为(batch_size, sequence_length, config.num_labels)) — 分类分数（SoftMax 之前）。 -
hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入的输出 + 每个层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态加上初始嵌入输出。
-
attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是具有全局注意力掩码的标记数量。注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个标记对每个具有全局注意力的标记（前
x个值）以及注意力窗口中每个标记（剩余的 `attention_window- + 1` 个值）的注意力权重。请注意，前
x个值指的是文本中位置固定的标记，但剩余的 `attention_window + 1` 个值指的是相对位置的标记：一个标记对其自身的注意力权重位于索引 `x + attention_window / 2`，而前面（后面）的 `attention_window / 2` 个值是对应前面（后面）的 `attention_window / 2` 个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则相应索引处的注意力权重设置为 0；该值应从前x个注意力权重中获取。如果一个标记具有全局注意力，则 `attentions` 中对所有其他标记的注意力权重设置为 0，这些值应从 `global_attentions` 中获取。
- + 1` 个值）的注意力权重。请注意，前
-
global_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数量。注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记对序列中每个标记的注意力权重。
TFLongformerForTokenClassification 的前向方法，重写了 __call__ 特殊方法。
尽管前向传播的流程需要在此函数内定义，但之后应调用 Module 实例而不是此函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFLongformerForTokenClassification
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = TFLongformerForTokenClassification.from_pretrained("allenai/longformer-base-4096")
>>> inputs = tokenizer(
... "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="tf"
... )
>>> logits = model(**inputs).logits
>>> predicted_token_class_ids = tf.math.argmax(logits, axis=-1)
>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t] for t in predicted_token_class_ids[0].numpy().tolist()]TFLongformerForMultipleChoice
class transformers.TFLongformerForMultipleChoice
< 来源 >( config *inputs **kwargs )
参数
- config (LongformerConfig) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
Longformer 模型，其顶部带有一个多项选择分类头（即在池化输出之上加一个线性层和一个 softmax），例如用于 RocStories/SWAG 任务。
该模型继承自 TFPreTrainedModel。请查阅超类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪注意力头等）。
该模型也是 keras.Model 的子类。可以像常规 TF 2.0 Keras 模型一样使用它，并参考 TF 2.0 文档了解所有与通用用法和行为相关的事项。
transformers 中的 TensorFlow 模型和层接受两种输入格式
- 所有输入作为关键字参数（如 PyTorch 模型），或
- 所有输入作为第一个位置参数中的列表、元组或字典。
支持第二种格式的原因是，Keras 方法在向模型和层传递输入时更偏好这种格式。由于这种支持，当使用像 model.fit() 这样的方法时，事情应该会“自然而然”地为你工作——只需以 model.fit() 支持的任何格式传递你的输入和标签即可！然而，如果你想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional API 创建自己的层或模型时，有三种可能的方法可以将所有输入张量收集到第一个位置参数中。
- 只有一个
input_ids的单个张量，没有其他：model(input_ids) - 长度可变的列表，包含一个或多个输入张量，按文档字符串中给出的顺序：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一个字典，其中包含一个或多个与文档字符串中给出的输入名称关联的输入张量：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，当使用子类化创建模型和层时，你无需担心任何这些问题，因为你可以像调用任何其他 Python 函数一样传递输入！
调用
< 来源 >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None global_attention_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → transformers.models.longformer.modeling_tf_longformer.TFLongformerMultipleChoiceModelOutput 或 tuple(tf.Tensor)
参数
- input_ids (
np.ndarray或tf.Tensor，形状为(batch_size, num_choices, sequence_length)) — 词汇表中输入序列词元的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
np.ndarray或tf.Tensor，形状为(batch_size, num_choices, sequence_length), 可选) — 用于避免在填充词元索引上执行注意力的掩码。掩码值在[0, 1]中选择：- 1 表示词元未被屏蔽，
- 0 表示词元被屏蔽。
- head_mask (
np.ndarray或tf.Tensor，形状为(encoder_layers, encoder_attention_heads), 可选) — 用于使注意力模块的选定头无效的掩码。掩码值在[0, 1]中选择：- 1 表示头未被屏蔽，
- 0 表示头被屏蔽。
- global_attention_mask (
np.ndarray或tf.Tensor，形状为(batch_size, num_choices, sequence_length)，可选) — 用于决定每个词元（token）是进行局部注意力（local attention）还是全局注意力（global attention）的掩码。具有全局注意力的词元会关注所有其他词元，同时所有其他词元也会关注它们。这对于特定任务的微调非常重要，因为它使模型在表示任务时更加灵活。例如，对于分类任务，词元应被赋予全局注意力。对于问答任务，所有问题词元也应具有全局注意力。请参阅 Longformer 论文了解更多细节。掩码值在[0, 1]中选择：- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（关注所有其他词元，并且所有其他词元也关注它们的词元）。
- token_type_ids (
np.ndarray或tf.Tensor，形状为(batch_size, num_choices, sequence_length)，可选) — 片段词元索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于*句子 A* 的词元，
- 1 对应于*句子 B* 的词元。
- position_ids (
np.ndarray或tf.Tensor，形状为(batch_size, num_choices, sequence_length)，可选) — 每个输入序列词元在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。 - inputs_embeds (
np.ndarray或tf.Tensor，形状为(batch_size, num_choices, sequence_length, hidden_size)，可选) — 可选地，你可以不传递input_ids，而是直接传递一个嵌入式表示。如果你希望比模型内部的嵌入查找矩阵有更多控制权来将input_ids索引转换为相关向量，这会很有用。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数只能在即时执行（eager mode）模式下使用，在图模式（graph mode）下将使用配置中的值。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数只能在即时执行（eager mode）模式下使用，在图模式（graph mode）下将使用配置中的值。 - return_dict (
bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。此参数可以在即时执行（eager mode）模式下使用，在图模式（graph mode）下该值将始终设置为 True。 - training (
bool, 可选, 默认为False) — 是否以训练模式使用模型（某些模块如 dropout 模块在训练和评估模式下有不同的行为）。 - labels (
tf.Tensor，形状为(batch_size,)，可选) — 用于计算多项选择分类损失的标签。索引应在[0, ..., num_choices]范围内，其中num_choices是输入张量第二维的大小。（见上面的input_ids）
返回
transformers.models.longformer.modeling_tf_longformer.TFLongformerMultipleChoiceModelOutput 或 tuple(tf.Tensor)
一个 transformers.models.longformer.modeling_tf_longformer.TFLongformerMultipleChoiceModelOutput 或一个 tf.Tensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），根据配置（LongformerConfig）和输入，包含各种元素。
-
loss (
tf.Tensor，形状为 *(1,)*，可选，当提供了labels时返回) — 分类损失。 -
logits (
tf.Tensor，形状为(batch_size, num_choices)) — num_choices 是输入张量的第二维。（参见上面的 input_ids）。分类分数（SoftMax 之前）。
-
hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入的输出 + 每个层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态加上初始嵌入输出。
-
attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是具有全局注意力掩码的标记数量。注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个标记对每个具有全局注意力的标记（前
x个值）以及注意力窗口中每个标记（剩余的 `attention_window- + 1` 个值）的注意力权重。请注意，前
x个值指的是文本中位置固定的标记，但剩余的 `attention_window + 1` 个值指的是相对位置的标记：一个标记对其自身的注意力权重位于索引 `x + attention_window / 2`，而前面（后面）的 `attention_window / 2` 个值是对应前面（后面）的 `attention_window / 2` 个标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则相应索引处的注意力权重设置为 0；该值应从前x个注意力权重中获取。如果一个标记具有全局注意力，则 `attentions` 中对所有其他标记的注意力权重设置为 0，这些值应从 `global_attentions` 中获取。
- + 1` 个值）的注意力权重。请注意，前
-
global_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数量。注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记对序列中每个标记的注意力权重。
TFLongformerForMultipleChoice 的前向方法，重写了 __call__ 特殊方法。
尽管前向传播的流程需要在此函数内定义，但之后应调用 Module 实例而不是此函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFLongformerForMultipleChoice
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/longformer-base-4096")
>>> model = TFLongformerForMultipleChoice.from_pretrained("allenai/longformer-base-4096")
>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="tf", padding=True)
>>> inputs = {k: tf.expand_dims(v, 0) for k, v in encoding.items()}
>>> outputs = model(inputs) # batch size is 1
>>> # the linear classifier still needs to be trained
>>> logits = outputs.logits