Hugging Face's logo

Transformers documentation

LongT5

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

该模型于 2021-12-15 在 HF papers 上发布，并于 2022-06-13 贡献至 Hugging Face Transformers。

LongT5

概述

LongT5 模型由 Mandy Guo、Joshua Ainslie、David Uthus、Santiago Ontanon、Jianmo Ni、Yun-Hsuan Sung 和 Yinfei Yang 在 LongT5: Efficient Text-To-Text Transformer for Long Sequences 中提出。它是一个在文本到文本去噪生成式设置下预训练的编码器-解码器 Transformer。LongT5 模型是 T5 模型的扩展，支持使用两种不同的高效注意力机制之一：(1) 局部注意力（Local attention），或 (2) 瞬态-全局注意力（Transient-Global attention）。

该论文的摘要如下：

近期研究表明，（1）增加输入长度或（2）扩大模型规模均能提升基于 Transformer 的神经模型的性能。在本文中，我们提出了一个新模型 LongT5，并借此探索同时扩展输入长度和模型规模所带来的影响。具体而言，我们将长输入 Transformer（ETC）中的注意力思想，以及摘要预训练（PEGASUS）中的预训练策略，整合到了可扩展的 T5 架构中。由此，我们提出了一种新的注意力机制，称为 {\em Transient Global}（TGlobal）。该机制模拟了 ETC 的局部/全局注意力机制，但无需额外的侧输入。我们在多个摘要任务上取得了最先进的结果，并在问答任务上超越了原始的 T5 模型。

该模型由 stancld 贡献。 原始代码可在此处找到。

使用技巧

  • LongT5ForConditionalGeneration 是 T5ForConditionalGeneration 的扩展，它将传统的编码器 self-attention 层替换为高效的 local 注意力或 transient-global（tglobal）注意力。
  • 与 T5 模型不同，LongT5 不使用任务前缀。此外，它采用了受 PegasusForConditionalGeneration 预训练启发的不同预训练目标。
  • LongT5 模型专为高效且出色地处理长程 序列到序列任务而设计，适用于输入序列长度超过常用 512 个 token 的场景。它能够处理长度最高达 16,384 个 token 的输入序列。
  • 对于 Local Attention，稀疏滑动窗口局部注意力操作允许给定 token 仅关注其左右各 r 个 token（默认 r=127）。Local Attention 不会为模型引入任何新参数。该机制的复杂度与输入序列长度 l 呈线性关系：O(l*r)。
  • Transient Global Attention 是 Local Attention 的扩展。此外，它允许每个输入 token 与该层中的所有其他 token 进行交互。其实现方式是将输入序列分割为固定长度 k 的块（默认 k=16）。然后，通过对块内每个 token 的嵌入进行求和并归一化，得到该块的全局 token。借助这一机制，注意力不仅能让每个 token 像 Local attention 那样关注附近的 token，还能像标准全局注意力那样关注每个全局 token（transient 表示全局 token 是在每次注意力操作中动态构建的）。因此，TGlobal 注意力引入了若干新参数——全局相对位置偏置以及用于全局 token 嵌入的层归一化。该机制的复杂度为 O(l(r + l/k))。
  • 以下示例展示了如何在 pubmed 数据集 上评估经过微调的 LongT5 模型。
import evaluate
from datasets import load_dataset

from transformers import AutoTokenizer, LongT5ForConditionalGeneration


dataset = load_dataset("ccdv/pubmed-summarization", "document", split="validation")
model = (
    LongT5ForConditionalGeneration.from_pretrained("Stancld/longt5-tglobal-large-16384-pubmed-3k_steps", device_map="auto")
    .half()
)
tokenizer = AutoTokenizer.from_pretrained("Stancld/longt5-tglobal-large-16384-pubmed-3k_steps")


def generate_answers(batch):
    inputs_dict = tokenizer(
        batch["article"], max_length=16384, padding="max_length", truncation=True, return_tensors="pt"
    )
    input_ids = inputs_dict.input_ids.to(model.device)
    attention_mask = inputs_dict.attention_mask.to(model.device)
    output_ids = model.generate(input_ids, attention_mask=attention_mask, max_length=512, num_beams=2)
    batch["predicted_abstract"] = tokenizer.batch_decode(output_ids, skip_special_tokens=True)
    return batch


result = dataset.map(generate_answers, batched=True, batch_size=2)
rouge = evaluate.load("rouge")
rouge.compute(predictions=result["predicted_abstract"], references=result["abstract"])

资源

LongT5Config

class transformers.LongT5Config

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0id2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Noneis_encoder_decoder: bool = Truevocab_size: int = 32128d_model: int = 512d_kv: int = 64d_ff: int = 2048num_layers: int = 6num_decoder_layers: int | None = Nonenum_heads: int = 8local_radius: int = 127global_block_size: int = 16relative_attention_num_buckets: int = 32relative_attention_max_distance: int = 128dropout_rate: float | int = 0.1layer_norm_epsilon: float = 1e-06initializer_factor: float = 1.0feed_forward_proj: str = 'relu'encoder_attention_type: str = 'local'use_cache: bool = Truepad_token_id: int | None = 0eos_token_id: int | list[int] | None = 1bos_token_id: int | None = Noneis_decoder: bool = Falsetie_word_embeddings: bool = True )

参数

  • is_encoder_decoder (bool，可选，默认为 True) — 指示该模型是否用作编码器/解码器。
  • vocab_size (int，可选，默认为 32128) — 模型的词汇表大小。定义了 input_ids 可以表示的不同 token 数量。
  • d_model (int，可选，默认为 512) — 编码器层和池化层的维度。
  • d_kv (int，可选，默认为 64) — 每个注意力头中 key、query、value 投影的大小。投影层的 inner_dim 将定义为 num_heads * d_kv。
  • d_ff (int，可选，默认值为 2048) — 每个 LongT5Block 中前馈中间层的维度。
  • num_layers (int，可选，默认为 6) — Transformer 解码器中的隐藏层数。
  • num_decoder_layers (int, 可选) — Transformer 解码器中的隐藏层数量。如果未设置，将使用与 num_layers 相同的值。
  • num_heads (int，可选，默认为 8) — Transformer 解码器中每个注意力层的注意力头数量。
  • local_radius (int，可选，默认为 127) — 在局部注意力机制中，每个 token 向左/向右进行局部自注意力计算时涉及的 token 数量。
  • global_block_size (int，可选，默认为 16) — 用于全局 token 表示时，输入序列被划分成的块长度。仅用于 encoder_attention_type = "transient-global"。
  • relative_attention_num_buckets (int，可选，默认为 32) — 每个注意力层使用的桶数量。
  • relative_attention_max_distance (int，可选，默认值为 128) — 用于分桶分离的较长序列的最大距离。
  • dropout_rate (Union[float, int]，可选，默认为 0.1) — 所有 dropout 层的比率。
  • layer_norm_epsilon (float，可选，默认为 1e-06) — 层归一化层所使用的 epsilon 值。
  • initializer_factor (float，可选，默认为 1.0) — 用于初始化所有权重矩阵的系数（应保持为 1，内部用于初始化测试）。
  • feed_forward_proj (string，可选，默认为 "relu") — 要使用的前馈层类型。应为 "relu" 或 "gated-gelu" 之一。LongT5v1.1 使用 "gated-gelu" 前馈投影。原始 LongT5 实现使用 "gated-gelu"。
  • encoder_attention_type (string，可选，默认为 "local") — 要使用的编码器注意力类型。应为 "local" 或 "transient-global" 之一，这两种类型均受 LongT5 实现支持。
  • use_cache (bool，可选，默认为 True) — 模型是否应返回最后一次键/值注意力（并非所有模型都使用）。仅当 config.is_decoder=True 或模型为仅解码器生成式模型时相关。
  • pad_token_id (int, 可选，默认为 0) — 词表中用于填充的 token id。
  • eos_token_id (Union[int, list[int]]，可选，默认为 1) — 词汇表中用于表示流结束（end-of-stream）的 token id。
  • bos_token_id (int, 可选) — 词汇表中用于表示流起始的 Token id。
  • is_decoder (bool，可选，默认为 False) — 指示该模型是否用作解码器。如果为 False，则模型用作编码器。
  • tie_word_embeddings (bool，可选，默认为 True) — 是否根据模型的 tied_weights_keys 映射来绑定权重嵌入。

这是用于存储 LongT5Model 配置的类。它根据指定的参数实例化 Longt5 模型，并定义模型架构。使用默认值实例化配置将生成与 google/long-t5-local-base 类似的配置。

配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。

LongT5Model

class transformers.LongT5Model

< >

( config: LongT5Config )

参数

  • config (LongT5Config) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

未添加任何特定头部的裸 Longt5 模型，直接输出原始隐藏状态。

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.BoolTensor] = Noneencoder_outputs: tuple[tuple[torch.FloatTensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → Seq2SeqModelOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, sequence_length)) — 输入序列中各 token 在词表中的索引。LongT5 是一个使用相对位置嵌入的模型，因此您可以在输入的右侧和左侧进行填充。

    可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是输入 ID？

    如需了解如何为预训练准备 input_ids，请参阅 LONGT5 Training。

  • attention_mask (torch.FloatTensor 形状为 (batch_size, sequence_length), 可选) — 用于避免对填充（padding）标记索引执行注意力计算的掩码。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

  • decoder_input_ids (torch.LongTensor 形状为 (batch_size, target_sequence_length), 可选) — 解码器输入序列中各 token 在词汇表中的索引。可通过 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是解码器输入 ID？LONGT5 使用 pad_token_id 作为生成 decoder_input_ids 的起始 token。如果使用 past_key_values，则只需输入最后一个 decoder_input_ids（参见 past_key_values）。有关如何为预训练准备 decoder_input_ids 的更多信息，请参阅 LONGT5 Training。

    可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是解码器输入 ID？

    LONGT5 使用 pad_token_id 作为 decoder_input_ids 生成的起始 token。如果使用了 past_key_values，则可以选择性地仅输入最后一个 decoder_input_ids（参见 past_key_values）。

    要了解如何为预训练准备 decoder_input_ids，请参阅 LONGT5 Training。

  • decoder_attention_mask（形状为 (batch_size, target_sequence_length) 的 torch.BoolTensor，可选） — 默认行为：生成一个忽略 decoder_input_ids 中填充标记的张量。默认情况下也会使用因果掩码。
  • encoder_outputs (tuple[tuple[torch.FloatTensor]], 可选) — 元组由 (last_hidden_state, 可选: hidden_states, 可选: attentions) last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size), 可选)，是编码器最后一层输出的一系列隐藏状态。用于解码器的交叉注意力。
  • past_key_values (~cache_utils.Cache, 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由 past_key_values 在解码的先前阶段返回，当 use_cache=True 或 config.use_cache=True.

    仅允许将 Cache 实例作为输入，请参阅我们的 kv cache 指南。 如果未传入 past_key_values，则默认会初始化 DynamicCache。

    模型将输出与输入相同的缓存格式。

    如果使用了 past_key_values，用户应仅输入未处理的 input_ids（即未向该模型提供其过去键值状态的那些），其形状为 (batch_size, unprocessed_length)，而不是形状为 (batch_size, sequence_length) 的全部 input_ids。

  • inputs_embeds（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。
  • decoder_inputs_embeds (torch.Tensor 形状为 (batch_size, target_sequence_length, hidden_size), ，可选) — 可选地，除了传递 decoder_input_ids ，还可以选择直接传递嵌入表示。如果使用了 past_key_values ，则只需输入最后一个 decoder_inputs_embeds （参见 past_key_values). 。这在希望比模型内部的嵌入查找矩阵更精细地控制如何将 decoder_input_ids 索引转换为对应向量时非常有用。

    如果 decoder_input_ids 和 decoder_inputs_embeds 均未设置，decoder_inputs_embeds 将取 inputs_embeds 的值。

  • use_cache (bool，可选) — 如果设置为 True，则会返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回值

Seq2SeqModelOutput 或 tuple(torch.FloatTensor)

一个 Seq2SeqModelOutput 或 torch.FloatTensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（LongT5Config）和输入。

LongT5Model 的 forward 方法会重写 __call__ 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 Module 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。

  • last_hidden_state（形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor）— 模型解码器最后一层输出的隐藏状态序列。

    如果使用了 past_key_values，则仅输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。

  • past_key_values（EncoderDecoderCache，可选，在传入 use_cache=True 或 config.use_cache=True 时返回）—— 它是一个 EncoderDecoderCache 实例。更多详情，请参阅我们的 kv cache 指南。

    包含预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。

  • decoder_hidden_states (tuple(torch.FloatTensor)，可选，在传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.FloatTensor 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 (batch_size, sequence_length, hidden_size)。

    解码器在每一层输出处的隐藏状态，以及可选的初始嵌入输出。

  • decoder_attentions（tuple(torch.FloatTensor)，可选，在传入 output_attentions=True 或 config.output_attentions=True 时返回）—— 一个 torch.FloatTensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

  • cross_attentions（tuple(torch.FloatTensor)，可选，在传入 output_attentions=True 或 config.output_attentions=True 时返回）—— 一个 torch.FloatTensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。

  • encoder_last_hidden_state（形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor，可选）— 模型编码器最后一层输出的隐藏状态序列。

  • encoder_hidden_states (tuple(torch.FloatTensor)，可选，在传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.FloatTensor 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每一层输出的一个张量），形状为 (batch_size, sequence_length, hidden_size)。

    编码器每层输出处的隐藏状态，以及可选的初始嵌入输出。

  • encoder_attentions（tuple(torch.FloatTensor)，可选，当传入 output_attentions=True 或 config.output_attentions=True 时返回）—— 一个 torch.FloatTensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

示例：

>>> from transformers import AutoTokenizer, LongT5Model

>>> tokenizer = AutoTokenizer.from_pretrained("google/long-t5-local-base")
>>> model = LongT5Model.from_pretrained("google/long-t5-local-base")

>>> # Let's try a very long encoder input.
>>> input_ids = tokenizer(
...     100 * "Studies have been shown that owning a dog is good for you", return_tensors="pt"
... ).input_ids  # Batch size 1

>>> decoder_input_ids = tokenizer("Studies show that", return_tensors="pt").input_ids  # Batch size 1

>>> # forward pass
>>> outputs = model(input_ids=input_ids, decoder_input_ids=decoder_input_ids)
>>> last_hidden_states = outputs.last_hidden_state

LongT5ForConditionalGeneration

class transformers.LongT5ForConditionalGeneration

< >

( config: LongT5Config )

参数

  • config (LongT5Config) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

带有 language modeling 头的 LONGT5 模型。

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.BoolTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.FloatTensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → Seq2SeqLMOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, sequence_length)) — 输入序列中各 token 在词表中的索引。LongT5 是一个使用相对位置嵌入的模型，因此您可以在输入的右侧和左侧进行填充。

    可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是输入 ID？

    如需了解如何为预训练准备 input_ids，请参阅 LONGT5 Training。

  • attention_mask (torch.FloatTensor 形状为 (batch_size, sequence_length), 可选) — 用于避免对填充（padding）标记索引执行注意力计算的掩码。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

  • decoder_input_ids (torch.LongTensor 形状为 (batch_size, target_sequence_length), 可选) — 解码器输入序列中各 token 在词汇表中的索引。可通过 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是解码器输入 ID？LONGT5 使用 pad_token_id 作为生成 decoder_input_ids 的起始 token。如果使用 past_key_values，则只需输入最后一个 decoder_input_ids（参见 past_key_values）。有关如何为预训练准备 decoder_input_ids 的更多信息，请参阅 LONGT5 Training。

    可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是解码器输入 ID？

    LONGT5 使用 pad_token_id 作为 decoder_input_ids 生成的起始 token。如果使用了 past_key_values，则可以选择性地仅输入最后一个 decoder_input_ids（参见 past_key_values）。

    要了解如何为预训练准备 decoder_input_ids，请参阅 LONGT5 Training。

  • decoder_attention_mask（形状为 (batch_size, target_sequence_length) 的 torch.BoolTensor，可选） — 默认行为：生成一个忽略 decoder_input_ids 中填充标记的张量。默认情况下也会使用因果掩码。
  • encoder_outputs (tuple[tuple[torch.Tensor]]，可选) — 元组由 (last_hidden_state，可选：hidden_states，可选：attentions) 组成 last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size)，可选) 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。
  • past_key_values (~cache_utils.Cache, 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由 past_key_values 在解码的先前阶段返回，当 use_cache=True 或 config.use_cache=True.

    仅允许将 Cache 实例作为输入，请参阅我们的 kv cache 指南。 如果未传入 past_key_values，则默认会初始化 DynamicCache。

    模型将输出与输入相同的缓存格式。

    如果使用了 past_key_values，用户应仅输入未处理的 input_ids（即未向该模型提供其过去键值状态的那些），其形状为 (batch_size, unprocessed_length)，而不是形状为 (batch_size, sequence_length) 的全部 input_ids。

  • inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。
  • decoder_inputs_embeds (torch.FloatTensor 形状为 (batch_size, target_sequence_length, hidden_size), 可选) — 可选地，除了传递 decoder_input_ids 之外，您还可以选择直接传递嵌入表示。如果使用了 past_key_values ，则只需输入最后一个 decoder_inputs_embeds （参见 past_key_values). 。如果您希望对 decoder_input_ids 索引如何转换为对应的向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。

    如果 decoder_input_ids 和 decoder_inputs_embeds 均未设置，decoder_inputs_embeds 将取 inputs_embeds 的值。

  • labels（形状为 (batch_size,) 的 torch.LongTensor，可选） — 用于计算序列分类/回归损失的标签。索引应在 [-100, 0, ..., config.vocab_size - 1] 范围内。所有设置为 -100 的标签都会被忽略（被掩码），损失仅针对 [0, ..., config.vocab_size] 范围内的标签进行计算。
  • use_cache (bool，可选) — 如果设置为 True，则会返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回值

Seq2SeqLMOutput 或 tuple(torch.FloatTensor)

一个 Seq2SeqLMOutput，或者一个由 torch.FloatTensor 组成的元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（LongT5Config）和输入。

LongT5ForConditionalGeneration 的 forward 方法重写了 __call__ 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 Module 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。

  • loss (torch.FloatTensor，形状为 (1,)，可选，在提供 labels 时返回) — 语言建模损失。

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

  • past_key_values（EncoderDecoderCache，可选，在传入 use_cache=True 或 config.use_cache=True 时返回）—— 它是一个 EncoderDecoderCache 实例。更多详情，请参阅我们的 kv cache 指南。

    包含预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。

  • decoder_hidden_states (tuple(torch.FloatTensor)，可选，在传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.FloatTensor 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 (batch_size, sequence_length, hidden_size)。

    解码器在每一层输出处的隐藏状态，以及初始嵌入输出。

  • decoder_attentions（tuple(torch.FloatTensor)，可选，在传入 output_attentions=True 或 config.output_attentions=True 时返回）—— 一个 torch.FloatTensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

  • cross_attentions（tuple(torch.FloatTensor)，可选，在传入 output_attentions=True 或 config.output_attentions=True 时返回）—— 一个 torch.FloatTensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。

  • encoder_last_hidden_state（形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor，可选）— 模型编码器最后一层输出的隐藏状态序列。

  • encoder_hidden_states (tuple(torch.FloatTensor)，可选，在传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.FloatTensor 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每一层输出的一个张量），形状为 (batch_size, sequence_length, hidden_size)。

    编码器在每一层输出处的隐藏状态，以及初始嵌入输出。

  • encoder_attentions（tuple(torch.FloatTensor)，可选，当传入 output_attentions=True 或 config.output_attentions=True 时返回）—— 一个 torch.FloatTensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

示例：

>>> from transformers import AutoTokenizer, LongT5ForConditionalGeneration

>>> tokenizer = AutoTokenizer.from_pretrained("Stancld/longt5-tglobal-large-16384-pubmed-3k_steps")
>>> model = LongT5ForConditionalGeneration.from_pretrained(
...     "Stancld/longt5-tglobal-large-16384-pubmed-3k_steps"
... )

>>> # Let's try a very long input.
>>> inputs = tokenizer(100 * "studies have shown that owning a dog is good for you ", return_tensors="pt")
>>> input_ids = inputs.input_ids

>>> outputs = model.generate(input_ids)
>>> print(tokenizer.decode(outputs[0], skip_special_tokens=True))
abstractthe aim of this article is to provide an overview of the literature on the role of dog

LongT5EncoderModel

类 transformers.LongT5EncoderModel

< >

( config: LongT5Config )

参数

  • config (LongT5Config) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

未添加任何特定头部的裸 Longt5 模型，直接输出原始隐藏状态。

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.FloatTensor] = Noneinputs_embeds: typing.Optional[torch.FloatTensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → BaseModelOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, sequence_length)) — 输入序列中各 token 在词表中的索引。LongT5 是一个使用相对位置嵌入的模型，因此您可以在输入的右侧和左侧进行填充。

    可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    如需了解如何为预训练准备 input_ids，请参阅 LONGT5 Training。

  • attention_mask (torch.FloatTensor 形状为 (batch_size, sequence_length), 可选) — 用于避免对填充（padding）标记索引执行注意力计算的掩码。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

  • inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回值

BaseModelOutput 或 tuple(torch.FloatTensor)

一个 BaseModelOutput 或 torch.FloatTensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（LongT5Config）和输入。

LongT5EncoderModel 的 forward 方法重写了 __call__ 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 Module 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。

  • last_hidden_state（形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor）— 模型最后一层输出的隐藏状态序列。

  • hidden_states (tuple(torch.FloatTensor)，可选，在传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.FloatTensor 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 (batch_size, sequence_length, hidden_size)。

    模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。

  • attentions（tuple(torch.FloatTensor)，可选，在传入 output_attentions=True 或 config.output_attentions=True 时返回）—— 一个 torch.FloatTensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。

示例：

>>> from transformers import AutoTokenizer, LongT5ForConditionalGeneration

>>> tokenizer = AutoTokenizer.from_pretrained("google/long-t5-local-base")
>>> model = LongT5EncoderModel.from_pretrained("google/long-t5-local-base")
>>> input_ids = tokenizer(
...     100 * "Studies have been shown that owning a dog is good for you ", return_tensors="pt"
... ).input_ids  # Batch size 1
>>> outputs = model(input_ids=input_ids)
>>> last_hidden_states = outputs.last_hidden_state
Update on GitHub

←Longformer LUKE→