Transformers 文档
LED
并获得增强的文档体验
开始使用
该模型于 2020 年 4 月 10 日在 HF 论文中发布，并于 2021 年 1 月 5 日贡献给 Hugging Face Transformers。
LED
Longformer-Encoder-Decoder (LED) 是一种用于序列到序列任务（如摘要生成）的编码器-解码器 Transformer 模型。它通过添加一个解码器层，扩展了 Longformer（一种设计用于处理长输入的仅编码器模型）。解码器在编码后的 Token 和之前已解码的位置上使用完全自注意力机制。由于 Longformer 的线性自注意力机制，LED 在处理长序列时比标准的编码器-解码器模型更高效。
你可以在 Ai2 组织下找到所有原始的 [LED] 检查点。
此模型由 patrickvonplaten 贡献。
点击右侧侧边栏中的 LED 模型，查看更多如何将 LED 应用于不同语言任务的示例。
下面的示例演示了如何使用 Pipeline、AutoModel 以及从命令行进行文本摘要。
import torch
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained(
"allenai/led-base-16384"
)
model = AutoModelForSeq2SeqLM.from_pretrained(
"allenai/led-base-16384",
device_map="auto"
)
input_text = """Plants are among the most remarkable and essential life forms on Earth, possessing a unique ability to produce their own food through a process known as photosynthesis. This complex biochemical process is fundamental not only to plant life but to virtually all life on the planet.
Through photosynthesis, plants capture energy from sunlight using a green pigment called chlorophyll, which is located in specialized cell structures called chloroplasts. In the presence of light, plants absorb carbon dioxide from the atmosphere through small pores in their leaves called stomata, and take in water from the soil through their root systems.
These ingredients are then transformed into glucose, a type of sugar that serves as a source of chemical energy, and oxygen, which is released as a byproduct into the atmosphere. The glucose produced during photosynthesis is not just used immediately; plants also store it as starch or convert it into other organic compounds like cellulose, which is essential for building their cellular structure.
This energy reserve allows them to grow, develop leaves, produce flowers, bear fruit, and carry out various physiological processes throughout their lifecycle."""
input_ids = tokenizer(input_text, return_tensors="pt").to(model.device)
# Place global attention on the first token
global_attention_mask = torch.zeros_like(input_ids.input_ids).to(model.device)
global_attention_mask[:, 0] = 1
output = model.generate(**input_ids, global_attention_mask=global_attention_mask, cache_implementation="static")
print(tokenizer.decode(output[0], skip_special_tokens=True))量化通过以较低精度表示权重来减少大型模型的内存负担。有关更多可用量化后端，请参阅量化概述。
以下示例使用 bitsandbytes 将权重仅量化为 int4。
import torch
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer, BitsAndBytesConfig
quantization_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4"
)
model = AutoModelForSeq2SeqLM.from_pretrained(
"allenai/led-large-16384",
device_map="auto",
quantization_config=quantization_config
)
tokenizer = AutoTokenizer.from_pretrained(
"allenai/led-large-16384"
)
input_text = """Plants are among the most remarkable and essential life forms on Earth, possessing a unique ability to produce their own food through a process known as photosynthesis. This complex biochemical process is fundamental not only to plant life but to virtually all life on the planet.
Through photosynthesis, plants capture energy from sunlight using a green pigment called chlorophyll, which is located in specialized cell structures called chloroplasts. In the presence of light, plants absorb carbon dioxide from the atmosphere through small pores in their leaves called stomata, and take in water from the soil through their root systems.
These ingredients are then transformed into glucose, a type of sugar that serves as a source of chemical energy, and oxygen, which is released as a byproduct into the atmosphere. The glucose produced during photosynthesis is not just used immediately; plants also store it as starch or convert it into other organic compounds like cellulose, which is essential for building their cellular structure.
This energy reserve allows them to grow, develop leaves, produce flowers, bear fruit, and carry out various physiological processes throughout their lifecycle."""
input_ids = tokenizer(input_text, return_tensors="pt").to(model.device)
# Place global attention on the first token
global_attention_mask = torch.zeros_like(input_ids.input_ids).to(model.device)
global_attention_mask[:, 0] = 1
output = model.generate(**input_ids, global_attention_mask=global_attention_mask, cache_implementation="static")
print(tokenizer.decode(output[0], skip_special_tokens=True))注意事项
- LEDForConditionalGeneration 是 BartForConditionalGeneration 的扩展，它将传统的自注意力层替换为 Longformer 的分块自注意力层。LEDTokenizer 是 BartTokenizer 的别名。
- 如果需要，LED 会将
input_ids填充为config.attention_window的倍数。当 LEDTokenizer 与pad_to_multiple_of参数一起使用时，可以获得小幅的速度提升。 - LED 最适用于
input_ids明显长于 1024 个 Token 的长距离序列到序列任务。 - LED 通过
global_attention_mask使用全局注意力（参见 LongformerModel）。对于摘要生成，建议仅在第一个<s>Token 上放置全局注意力。对于问答任务，建议在问题的所有 Token 上放置全局注意力。 - 若要在所有 16384 个参数上微调 LED，如果训练导致内存溢出 (OOM) 错误，可以启用梯度检查点。通过添加
model.gradient_checkpointing_enable()并设置use_cache=False来禁用缓存机制以节省内存，从而启用梯度检查点。 - 输入应在右侧进行填充，因为 LED 使用绝对位置嵌入。
资源
- 阅读 Arxiv 上的 LED 笔记本，了解 LED 如何在 Arxiv 文章摘要任务中实现最先进的性能。
- 阅读 微调 LED 笔记本，了解如何对 PubMed 文章进行 LED 微调。
LEDConfig
class transformers.LEDConfig
< 源码 >( transformers_version: str | None = None architectures: list[str] | None = None output_hidden_states: bool | None = False return_dict: bool | None = True dtype: typing.Union[str, ForwardRef('torch.dtype'), NoneType] = None chunk_size_feed_forward: int = 0 id2label: dict[int, str] | dict[str, str] | None = None label2id: dict[str, int] | dict[str, str] | None = None problem_type: typing.Optional[typing.Literal['regression', 'single_label_classification', 'multi_label_classification']] = None is_encoder_decoder: bool = True vocab_size: int = 50265 max_encoder_position_embeddings: int = 16384 max_decoder_position_embeddings: int = 1024 encoder_layers: int = 12 encoder_ffn_dim: int = 4096 encoder_attention_heads: int = 16 decoder_layers: int = 12 decoder_ffn_dim: int = 4096 decoder_attention_heads: int = 16 encoder_layerdrop: float | int = 0.0 decoder_layerdrop: float | int = 0.0 use_cache: bool = True activation_function: str = 'gelu' d_model: int = 1024 dropout: float | int = 0.1 attention_dropout: float | int = 0.0 activation_dropout: float | int = 0.0 init_std: float = 0.02 decoder_start_token_id: int = 2 classifier_dropout: float | int = 0.0 pad_token_id: int | None = 1 bos_token_id: int | None = 0 eos_token_id: int | list[int] | None = 2 attention_window: list[int] | int = 512 tie_word_embeddings: bool = True )
参数
- is_encoder_decoder (
bool, 可选, 默认为True) — 模型是否用作编码器/解码器。 - vocab_size (
int, 可选, 默认为50265) — 模型的词汇表大小。定义了input_ids可以表示的不同 Token 的数量。 - max_encoder_position_embeddings (
int, 可选, 默认为 16384) — 编码器可能使用的最大序列长度。 - max_decoder_position_embeddings (
int, 可选, 默认为 16384) — 解码器可能使用的最大序列长度。 - encoder_layers (
int, 可选, 默认为12) — Transformer 编码器中的隐藏层数量。如果未设置，将使用与num_layers相同的值。 - encoder_ffn_dim (
int, 可选, 默认为4096) — 编码器中“中间”（通常称为前馈）层的维度。 - encoder_attention_heads (
int, 可选, 默认为16) — Transformer 编码器中每个注意力层的注意力头数量。 - decoder_layers (
int, 可选, 默认为12) — Transformer 解码器中的隐藏层数量。如果未设置，将使用与num_layers相同的值。 - decoder_ffn_dim (
int, 可选, 默认为4096) — 解码器中“中间”（通常称为前馈）层的维度。 - decoder_attention_heads (
int, 可选, 默认为16) — Transformer 解码器中每个注意力层的注意力头数量。 - encoder_layerdrop (
Union[float, int], 可选, 默认为0.0) — 编码器的 LayerDrop 概率。详情请参见 [LayerDrop 论文](https://huggingface.co/papers/1909.11556)。 - decoder_layerdrop (
Union[float, int], 可选, 默认为0.0) — 解码器的 LayerDrop 概率。详情请参见 [LayerDrop 论文](https://huggingface.co/papers/1909.11556)。 - use_cache (
bool, 可选, 默认为True) — 模型是否应该返回最后的键/值注意力（并非所有模型都使用）。仅在config.is_decoder=True或模型是仅解码器生成模型时相关。 - activation_function (
str, 可选, 默认为gelu) — 解码器中的非线性激活函数（函数或字符串）。例如，"gelu"、"relu"、"silu"等。 - d_model (
int, 可选, 默认为1024) — 编码器层和池化层的尺寸。 - dropout (
Union[float, int], 可选, 默认为0.1) — 所有 Dropout 层的比例。 - attention_dropout (
Union[float, int], optional, 默认值为0.0) — 注意力概率的丢弃比率。 - activation_dropout (
Union[float, int], optional, 默认值为0.0) — 全连接层内部激活值的丢弃比率。 - init_std (
float, optional, 默认值为0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - decoder_start_token_id (
int, optional, 默认值为2) — 如果编码器-解码器模型开始解码时使用的 token 不同于bos，则为该 token 的 id。 - classifier_dropout (
Union[float, int], optional, 默认值为0.0) — 分类器的丢弃比率。 - pad_token_id (
int, optional, 默认值为1) — 词汇表中用于填充的 token id。 - bos_token_id (
int, optional, 默认值为0) — 词汇表中用于流起始（beginning-of-stream）的 token id。 - eos_token_id (
Union[int, list[int]], optional, 默认值为2) — 词汇表中用于流结束（end-of-stream）的 token id。 - attention_window (
int或list[int], optional, 默认值为 512) — 每个 token 周围的注意力窗口大小。如果是int，则对所有层使用相同的大小。若要为每一层指定不同的窗口大小，请使用list[int]，其中len(attention_window) == num_hidden_layers。 - tie_word_embeddings (
bool, optional, 默认值为True) — 是否根据模型的tied_weights_keys映射来绑定权重嵌入。
这是用于存储 LEDModel 配置的配置类。它根据指定的参数用于实例化 Led 模型，定义了模型架构。使用默认值实例化配置将得到与 allenai/led-base-16384 类似的配置。
配置对象继承自 PreTrainedConfig，可用于控制模型输出。阅读 PreTrainedConfig 的文档以获取更多信息。
示例
>>> from transformers import LEDModel, LEDConfig
>>> # Initializing a LED allenai/led-base-16384 style configuration
>>> configuration = LEDConfig()
>>> # Initializing a model from the allenai/led-base-16384 style configuration
>>> model = LEDModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configLEDTokenizer
class transformers.RobertaTokenizer
< source >( vocab: str | dict[str, int] | None = None merges: str | list[str] | None = None errors: str = 'replace' bos_token: str = '<s>' eos_token: str = '</s>' sep_token: str = '</s>' cls_token: str = '<s>' unk_token: str = '<unk>' pad_token: str = '<pad>' mask_token: str = '<mask>' add_prefix_space: bool = False trim_offsets: bool = True **kwargs )
参数
- vocab (
str,dict或list, 可选) — 自定义词表字典。如果未提供，则从 vocab_file 加载词表。 - merges (
str或list, 可选) — 自定义合并列表。如果未提供，则从 merges_file 加载合并列表。 - errors (
str, 可选, 默认为"replace") — 将字节解码为 UTF-8 时遵循的规范。有关更多信息，请参阅 bytes.decode。 - bos_token (
str, 可选, 默认为"<s>") — 预训练期间使用的序列开始标记。可用作序列分类标记。在使用特殊标记构建序列时，这**不是**用于序列开始的标记。实际使用的标记是
cls_token。 - eos_token (
str, 可选, 默认为"</s>") — 序列结束标记。在使用特殊标记构建序列时，这**不是**用于序列结束的标记。实际使用的标记是
sep_token。 - sep_token (
str, 可选, 默认为"</s>") — 分隔符标记。在从多个序列（例如，用于序列分类的两个序列，或用于问答的文本和问题）构建序列时使用。它还被用作使用特殊标记构建的序列的最后一个标记。 - cls_token (
str, 可选, 默认为"<s>") — 在进行序列分类（对整个序列而非每个标记进行分类）时使用的分类器标记。它是使用特殊标记构建序列时的第一个标记。 - unk_token (
str, 可选, 默认为"<unk>") — 未知标记。不在词表中的标记无法转换为 ID，而是被设置为此标记。 - pad_token (
str, 可选, 默认为"<pad>") — 用于填充 (padding) 的标记，例如在对不同长度的序列进行批处理时使用。 - mask_token (
str, 可选, 默认为"<mask>") — 用于掩码值的标记。这是在使用掩码语言建模 (MLM) 训练此模型时使用的标记。这是模型将尝试预测的标记。 - add_prefix_space (
bool, 可选, 默认为False) — 是否在输入中添加初始空格。这允许像处理其他单词一样处理前导词。（RoBERTa 分词器通过前面的空格来检测单词的开始）。 - trim_offsets (
bool, 可选, 默认为True) — 后处理步骤是否应修整偏移量以避免包含空格。
Construct a RoBERTa tokenizer (backed by HuggingFace’s tokenizers library). Based on Byte-Pair-Encoding.
这个分词器经过训练，将空格视为词元的一部分（有点像 sentencepiece），所以一个词会
无论是否在句子开头（无空格），编码方式都会不同
>>> from transformers import RobertaTokenizer
>>> tokenizer = RobertaTokenizer.from_pretrained("FacebookAI/roberta-base")
>>> 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进行实例化。
该分词器继承自 TokenizersBackend，后者包含其大部分主要方法。用户应参考该父类以获取有关这些方法的更多信息。
get_special_tokens_mask
< 源代码 >( token_ids_0: list[int] token_ids_1: list[int] | None = None already_has_special_tokens: bool = False ) → 一个介于 0 和 1 之间的整数列表
Retrieve sequence ids from a token list that has no special tokens added.
For fast tokenizers, data collators call this with already_has_special_tokens=True to build a mask over an already-formatted sequence. In that case, we compute the mask by checking membership in all_special_ids.
LEDTokenizerFast
class transformers.RobertaTokenizer
< source >( vocab: str | dict[str, int] | None = None merges: str | list[str] | None = None errors: str = 'replace' bos_token: str = '<s>' eos_token: str = '</s>' sep_token: str = '</s>' cls_token: str = '<s>' unk_token: str = '<unk>' pad_token: str = '<pad>' mask_token: str = '<mask>' add_prefix_space: bool = False trim_offsets: bool = True **kwargs )
参数
- vocab (
str,dict或list, 可选) — 自定义词表字典。如果未提供，则从 vocab_file 加载词表。 - merges (
str或list, 可选) — 自定义合并列表。如果未提供，则从 merges_file 加载合并列表。 - errors (
str, 可选, 默认为"replace") — 将字节解码为 UTF-8 时遵循的规范。有关更多信息，请参阅 bytes.decode。 - bos_token (
str, 可选, 默认为"<s>") — 预训练期间使用的序列开始标记。可用作序列分类标记。在使用特殊标记构建序列时，这**不是**用于序列开始的标记。实际使用的标记是
cls_token。 - eos_token (
str, 可选, 默认为"</s>") — 序列结束标记。在使用特殊标记构建序列时，这**不是**用于序列结束的标记。实际使用的标记是
sep_token。 - sep_token (
str, 可选, 默认为"</s>") — 分隔符标记。在从多个序列（例如，用于序列分类的两个序列，或用于问答的文本和问题）构建序列时使用。它还被用作使用特殊标记构建的序列的最后一个标记。 - cls_token (
str, 可选, 默认为"<s>") — 在进行序列分类（对整个序列而非每个标记进行分类）时使用的分类器标记。它是使用特殊标记构建序列时的第一个标记。 - unk_token (
str, 可选, 默认为"<unk>") — 未知标记。不在词表中的标记无法转换为 ID，而是被设置为此标记。 - pad_token (
str, 可选, 默认为"<pad>") — 用于填充 (padding) 的标记，例如在对不同长度的序列进行批处理时使用。 - mask_token (
str, 可选, 默认为"<mask>") — 用于掩码值的标记。这是在使用掩码语言建模 (MLM) 训练此模型时使用的标记。这是模型将尝试预测的标记。 - add_prefix_space (
bool, 可选, 默认为False) — 是否在输入中添加初始空格。这允许像处理其他单词一样处理前导词。（RoBERTa 分词器通过前面的空格来检测单词的开始）。 - trim_offsets (
bool, 可选, 默认为True) — 后处理步骤是否应修整偏移量以避免包含空格。
Construct a RoBERTa tokenizer (backed by HuggingFace’s tokenizers library). Based on Byte-Pair-Encoding.
这个分词器经过训练，将空格视为词元的一部分（有点像 sentencepiece），所以一个词会
无论是否在句子开头（无空格），编码方式都会不同
>>> from transformers import RobertaTokenizer
>>> tokenizer = RobertaTokenizer.from_pretrained("FacebookAI/roberta-base")
>>> 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进行实例化。
该分词器继承自 TokenizersBackend，后者包含其大部分主要方法。用户应参考该父类以获取有关这些方法的更多信息。
LED 特定输出
class transformers.models.led.modeling_led.LEDEncoderBaseModelOutput
< 源代码 >( last_hidden_state: FloatTensor hidden_states: tuple[torch.FloatTensor, ...] | None = None attentions: tuple[torch.FloatTensor, ...] | None = None global_attentions: tuple[torch.FloatTensor, ...] | None = None )
参数
- last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor) — 模型最后一层输出的隐藏状态序列。 - hidden_states (
tuple[torch.FloatTensor, ...], optional, 当传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（如果模型有嵌入层，则第一个为嵌入层的输出，后续每个对应每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型每一层输出的隐藏状态，加上可选的初始嵌入输出。
- attentions (
tuple(torch.FloatTensor), optional, 当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是具有全局注意力掩码的 token 数量。注意力 Softmax 后的局部注意力权重，用于计算自注意力头中的加权平均值。这是序列中每个 token 到每个具有全局注意力的 token（前
x个值）以及注意力窗口内每个 token（剩余 `attention_window + 1` 个值）的注意力权重。注意：前x个值引用的是在文本中具有固定位置的 token，而剩余的attention_window + 1` 个值引用的是具有相对位置的 token：一个 token 对自身的注意力权重位于索引x + attention_window / 2` 处，其前（后）面的attention_window / 2` 个值是到前（后）面attention_window / 2` 个 token 的注意力权重。如果注意力窗口包含一个具有全局注意力的 token，则对应索引处的注意力权重设置为 0；该值应从前x` 个注意力权重中获取。如果一个 token 具有全局注意力，则attentions` 中到所有其他 token 的注意力权重设置为 0，这些值应从global_attentions` 中获取。 - global_attentions (
tuple(torch.FloatTensor), optional, 当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的 token 数量。注意力 Softmax 后的全局注意力权重，用于计算自注意力头中的加权平均值。这是每个具有全局注意力的 token 到序列中每个 token 的注意力权重。
- last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor) — 模型最后一层输出的隐藏状态序列。 - hidden_states (
tuple[torch.FloatTensor, ...], optional, 当传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor的元组（如果模型有嵌入层，则第一个为嵌入层的输出，后续每个对应每一层的输出），形状为(batch_size, sequence_length, hidden_size)。模型每一层输出的隐藏状态，加上可选的初始嵌入输出。
- attentions (
tuple(torch.FloatTensor), optional, 当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是具有全局注意力掩码的 token 数量。注意力 Softmax 后的局部注意力权重，用于计算自注意力头中的加权平均值。这是序列中每个 token 到每个具有全局注意力的 token（前
x个值）以及注意力窗口内每个 token（剩余 `attention_window + 1` 个值）的注意力权重。注意：前x个值引用的是在文本中具有固定位置的 token，而剩余的attention_window + 1` 个值引用的是具有相对位置的 token：一个 token 对自身的注意力权重位于索引x + attention_window / 2` 处，其前（后）面的attention_window / 2` 个值是到前（后）面attention_window / 2` 个 token 的注意力权重。如果注意力窗口包含一个具有全局注意力的 token，则对应索引处的注意力权重设置为 0；该值应从前x` 个注意力权重中获取。如果一个 token 具有全局注意力，则attentions` 中到所有其他 token 的注意力权重设置为 0，这些值应从global_attentions` 中获取。 - global_attentions (
tuple(torch.FloatTensor), optional, 当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的 token 数量。注意力 Softmax 后的全局注意力权重，用于计算自注意力头中的加权平均值。这是每个具有全局注意力的 token 到序列中每个 token 的注意力权重。
LEDEncoder 输出的基类，包含潜在的隐藏状态、局部和全局注意力。
class transformers.models.led.modeling_led.LEDSeq2SeqModelOutput
< 源代码 >( last_hidden_state: torch.FloatTensor | None = None past_key_values: transformers.cache_utils.Cache | None = None decoder_hidden_states: tuple[torch.FloatTensor, ...] | None = None decoder_attentions: tuple[torch.FloatTensor, ...] | None = None cross_attentions: tuple[torch.FloatTensor, ...] | None = None encoder_last_hidden_state: torch.FloatTensor | None = None encoder_hidden_states: tuple[torch.FloatTensor, ...] | None = None encoder_attentions: tuple[torch.FloatTensor, ...] | None = None encoder_global_attentions: tuple[torch.FloatTensor, ...] | None = None )
参数
- last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层的输出隐藏状态序列。如果使用了
past_key_values，则仅输出序列中形状为(batch_size, 1, hidden_size)的最后一个隐藏状态。 - past_key_values (
Cache，可选，在传入use_cache=True或config.use_cache=True时返回) — 这是一个 Cache 实例。更多详情，请参阅我们的 kv cache 指南。包含解码器预计算的隐藏状态（注意力模块中的 key 和 values），可用于（参见
past_key_values输入）加速顺序解码。 - decoder_hidden_states (
tuple[torch.FloatTensor, ...]，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型有嵌入层，则第一个为嵌入层输出，之后每一层输出各一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出的隐藏状态，加上初始嵌入输出。
- decoder_attentions (
tuple[torch.FloatTensor, ...]，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 SoftMax 之后，用于计算自注意力头中的加权平均值。
- cross_attentions (
tuple[torch.FloatTensor, ...]，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 SoftMax 之后，用于计算交叉注意力头中的加权平均值。
- encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的输出隐藏状态序列。 - encoder_hidden_states (
tuple[torch.FloatTensor, ...]，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型有嵌入层，则第一个为嵌入层输出，之后每一层输出各一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出的隐藏状态，加上初始嵌入输出。
- encoder_attentions (
tuple[torch.FloatTensor, ...]，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 SoftMax 之后，用于计算自注意力头中的加权平均值。
- encoder_global_attentions (
tuple(torch.FloatTensor)，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的 token 数量。注意力 SoftMax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是来自所有具有全局注意力的 token 对序列中每个 token 的注意力权重。
- last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层的输出隐藏状态序列。如果使用了
past_key_values，则仅输出序列中形状为(batch_size, 1, hidden_size)的最后一个隐藏状态。 - past_key_values (
Cache，可选，在传入use_cache=True或config.use_cache=True时返回) — 这是一个 Cache 实例。更多详情，请参阅我们的 kv cache 指南。包含解码器预计算的隐藏状态（注意力模块中的 key 和 values），可用于（参见
past_key_values输入）加速顺序解码。 - decoder_hidden_states (
tuple[torch.FloatTensor, ...]，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型有嵌入层，则第一个为嵌入层输出，之后每一层输出各一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出的隐藏状态，加上初始嵌入输出。
- decoder_attentions (
tuple[torch.FloatTensor, ...]，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 SoftMax 之后，用于计算自注意力头中的加权平均值。
- cross_attentions (
tuple[torch.FloatTensor, ...]，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 SoftMax 之后，用于计算交叉注意力头中的加权平均值。
- encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选，默认为None) — 模型编码器最后一层的输出隐藏状态序列。 - encoder_hidden_states (
tuple[torch.FloatTensor, ...]，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型有嵌入层，则第一个为嵌入层输出，之后每一层输出各一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出的隐藏状态，加上初始嵌入输出。
- encoder_attentions (
tuple[torch.FloatTensor, ...]，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 SoftMax 之后，用于计算自注意力头中的加权平均值。
- encoder_global_attentions (
tuple(torch.FloatTensor)，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的 token 数量。注意力 SoftMax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是来自所有具有全局注意力的 token 对序列中每个 token 的注意力权重。
模型编码器输出的基类，也包含：可加速顺序解码的预计算隐藏状态。
class transformers.models.led.modeling_led.LEDSeq2SeqLMOutput
< 源码 >( loss: torch.FloatTensor | None = None logits: torch.FloatTensor | None = None past_key_values: transformers.cache_utils.Cache | None = None decoder_hidden_states: tuple[torch.FloatTensor, ...] | None = None decoder_attentions: tuple[torch.FloatTensor, ...] | None = None cross_attentions: tuple[torch.FloatTensor, ...] | None = None encoder_last_hidden_state: torch.FloatTensor | None = None encoder_hidden_states: tuple[torch.FloatTensor, ...] | None = None encoder_attentions: tuple[torch.FloatTensor, ...] | None = None encoder_global_attentions: tuple[torch.FloatTensor, ...] | None = None )
参数
- loss (
torch.FloatTensor，形状为(1,)，可选，在提供labels时返回) — 语言模型损失。 - logits (
torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言模型头的预测得分（SoftMax 之前每个词汇表 token 的得分）。 - past_key_values (
Cache，可选，在传入use_cache=True或config.use_cache=True时返回) — 这是一个 Cache 实例。更多详情，请参阅我们的 kv cache 指南。包含解码器预计算的隐藏状态（注意力模块中的 key 和 values），可用于（参见
past_key_values输入）加速顺序解码。 - decoder_hidden_states (
tuple[torch.FloatTensor, ...]，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型有嵌入层，则第一个为嵌入层输出，之后每一层输出各一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出的隐藏状态，加上初始嵌入输出。
- decoder_attentions (
tuple[torch.FloatTensor, ...]，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 SoftMax 之后，用于计算自注意力头中的加权平均值。
- cross_attentions (
tuple[torch.FloatTensor, ...]，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 SoftMax 之后，用于计算交叉注意力头中的加权平均值。
- encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的输出隐藏状态序列。 - encoder_hidden_states (
tuple[torch.FloatTensor, ...]，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型有嵌入层，则第一个为嵌入层输出，之后每一层输出各一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出的隐藏状态，加上初始嵌入输出。
- encoder_attentions (
tuple[torch.FloatTensor, ...]，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 SoftMax 之后，用于计算自注意力头中的加权平均值。
- encoder_global_attentions (
tuple(torch.FloatTensor)，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的 token 数量。注意力 SoftMax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是来自所有具有全局注意力的 token 对序列中每个 token 的注意力权重。
- loss (
torch.FloatTensor，形状为(1,)，可选，在提供labels时返回) — 语言模型损失。 - logits (
torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言模型头的预测得分（SoftMax 之前每个词汇表 token 的得分）。 - past_key_values (
Cache，可选，在传入use_cache=True或config.use_cache=True时返回) — 这是一个 Cache 实例。更多详情，请参阅我们的 kv cache 指南。包含解码器预计算的隐藏状态（注意力模块中的 key 和 values），可用于（参见
past_key_values输入）加速顺序解码。 - decoder_hidden_states (
tuple[torch.FloatTensor, ...]，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型有嵌入层，则第一个为嵌入层输出，之后每一层输出各一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出的隐藏状态，加上初始嵌入输出。
- decoder_attentions (
tuple[torch.FloatTensor, ...]，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 SoftMax 之后，用于计算自注意力头中的加权平均值。
- cross_attentions (
tuple[torch.FloatTensor, ...]，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 SoftMax 之后，用于计算交叉注意力头中的加权平均值。
- encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选，默认为None) — 模型编码器最后一层输出的隐藏状态序列。 - encoder_hidden_states (
tuple[torch.FloatTensor, ...]，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型有嵌入层，则第一个为嵌入层输出，之后每一层输出各一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出的隐藏状态，加上初始嵌入输出。
- encoder_attentions (
tuple[torch.FloatTensor, ...]，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 SoftMax 之后，用于计算自注意力头中的加权平均值。
- encoder_global_attentions (
tuple(torch.FloatTensor)，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的 token 数量。注意力 SoftMax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是来自所有具有全局注意力的 token 对序列中每个 token 的注意力权重。
序列到序列语言模型输出的基类。
class transformers.models.led.modeling_led.LEDSeq2SeqSequenceClassifierOutput
< 源码 >( loss: torch.FloatTensor | None = None logits: torch.FloatTensor | None = None past_key_values: transformers.cache_utils.Cache | None = None decoder_hidden_states: tuple[torch.FloatTensor, ...] | None = None decoder_attentions: tuple[torch.FloatTensor, ...] | None = None cross_attentions: tuple[torch.FloatTensor, ...] | None = None encoder_last_hidden_state: torch.FloatTensor | None = None encoder_hidden_states: tuple[torch.FloatTensor, ...] | None = None encoder_attentions: tuple[torch.FloatTensor, ...] | None = None encoder_global_attentions: tuple[torch.FloatTensor, ...] | None = None )
参数
- loss (
torch.FloatTensor，形状为(1,)，可选，在提供label时返回) — 分类（如果config.num_labels==1则为回归）损失。 - logits (
torch.FloatTensor，形状为(batch_size, config.num_labels)) — 分类（如果config.num_labels==1则为回归）分数（SoftMax 之前）。 - past_key_values (
Cache，可选，在传入use_cache=True或config.use_cache=True时返回) — 这是一个 Cache 实例。更多细节请参阅我们的 KV 缓存指南。包含解码器预先计算的隐藏状态（注意力块中的键和值），可用于（参见
past_key_values输入）加速序列解码。 - decoder_hidden_states (
tuple[torch.FloatTensor, ...]，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（模型有嵌入层时，第一个为嵌入输出，其余为各层输出），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出的隐藏状态以及初始嵌入输出。
- decoder_attentions (
tuple[torch.FloatTensor, ...]，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 SoftMax 之后，用于计算自注意力头中的加权平均值。
- cross_attentions (
tuple[torch.FloatTensor, ...]，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 SoftMax 之后，用于计算交叉注意力头中的加权平均值。
- encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 - encoder_hidden_states (
tuple[torch.FloatTensor, ...]，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（模型有嵌入层时，第一个为嵌入输出，其余为各层输出），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出的隐藏状态以及初始嵌入输出。
- encoder_attentions (
tuple[torch.FloatTensor, ...]，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 SoftMax 之后，用于计算自注意力头中的加权平均值。
- encoder_global_attentions (
tuple(torch.FloatTensor)，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数量。注意力 SoftMax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个具有全局注意力的标记对序列中每个标记的注意力权重。
- loss (
torch.FloatTensor，形状为(1,)，可选，在提供label时返回) — 分类（如果config.num_labels==1则为回归）损失。 - logits (
torch.FloatTensor，形状为(batch_size, config.num_labels)) — 分类（如果config.num_labels==1则为回归）分数（SoftMax 之前）。 - past_key_values (
Cache，可选，在传入use_cache=True或config.use_cache=True时返回) — 这是一个 Cache 实例。更多细节请参阅我们的 KV 缓存指南。包含解码器预先计算的隐藏状态（注意力块中的键和值），可用于（参见
past_key_values输入）加速序列解码。 - decoder_hidden_states (
tuple[torch.FloatTensor, ...]，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（模型有嵌入层时，第一个为嵌入输出，其余为各层输出），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出的隐藏状态以及初始嵌入输出。
- decoder_attentions (
tuple[torch.FloatTensor, ...]，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 SoftMax 之后，用于计算自注意力头中的加权平均值。
- cross_attentions (
tuple[torch.FloatTensor, ...]，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 SoftMax 之后，用于计算交叉注意力头中的加权平均值。
- encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选，默认为None) — 模型编码器最后一层输出的隐藏状态序列。 - encoder_hidden_states (
tuple[torch.FloatTensor, ...]，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（模型有嵌入层时，第一个为嵌入输出，其余为各层输出），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出的隐藏状态以及初始嵌入输出。
- encoder_attentions (
tuple[torch.FloatTensor, ...]，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 SoftMax 之后，用于计算自注意力头中的加权平均值。
- encoder_global_attentions (
tuple(torch.FloatTensor)，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数量。注意力 SoftMax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个具有全局注意力的标记对序列中每个标记的注意力权重。
序列到序列句子分类模型输出的基类。
class transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput
< 源码 >( loss: torch.FloatTensor | None = None start_logits: torch.FloatTensor | None = None end_logits: torch.FloatTensor | None = None past_key_values: transformers.cache_utils.Cache | None = None decoder_hidden_states: tuple[torch.FloatTensor, ...] | None = None decoder_attentions: tuple[torch.FloatTensor, ...] | None = None cross_attentions: tuple[torch.FloatTensor, ...] | None = None encoder_last_hidden_state: torch.FloatTensor | None = None encoder_hidden_states: tuple[torch.FloatTensor, ...] | None = None encoder_attentions: tuple[torch.FloatTensor, ...] | None = None encoder_global_attentions: tuple[torch.FloatTensor, ...] | None = None )
参数
- loss (
torch.FloatTensor，形状为(1,)，可选，在提供labels时返回) — 总跨度提取损失，为起始位置和结束位置的交叉熵之和。 - start_logits (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 跨度起始分数（SoftMax 之前）。 - end_logits (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 跨度结束分数（SoftMax 之前）。 - past_key_values (
Cache，可选，在传入use_cache=True或config.use_cache=True时返回) — 这是一个 Cache 实例。更多细节请参阅我们的 KV 缓存指南。包含解码器预先计算的隐藏状态（注意力块中的键和值），可用于（参见
past_key_values输入）加速序列解码。 - decoder_hidden_states (
tuple[torch.FloatTensor, ...]，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（模型有嵌入层时，第一个为嵌入输出，其余为各层输出），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出的隐藏状态以及初始嵌入输出。
- decoder_attentions (
tuple[torch.FloatTensor, ...]，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 SoftMax 之后，用于计算自注意力头中的加权平均值。
- cross_attentions (
tuple[torch.FloatTensor, ...]，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 SoftMax 之后，用于计算交叉注意力头中的加权平均值。
- encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 - encoder_hidden_states (
tuple[torch.FloatTensor, ...], optional, 当传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（若模型有嵌入层，则第一个为嵌入输出，后续每个为对应层的输出），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出时的隐藏状态以及初始嵌入输出。
- encoder_attentions (
tuple[torch.FloatTensor, ...], optional, 当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器在注意力 Softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
- encoder_global_attentions (
tuple(torch.FloatTensor), optional, 当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数量。经过注意力 Softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记到序列中每个标记的注意力权重。
- loss (
torch.FloatTensor，形状为(1,)，可选，在提供labels时返回) — 总跨度提取损失，为起始位置和结束位置的交叉熵之和。 - start_logits (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选，默认为None) — 跨度起始得分（SoftMax 之前）。 - end_logits (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选，默认为None) — 跨度结束得分（SoftMax 之前）。 - past_key_values (
Cache，可选，在传入use_cache=True或config.use_cache=True时返回) — 这是一个 Cache 实例。更多细节请参阅我们的 KV 缓存指南。包含解码器预先计算的隐藏状态（注意力块中的键和值），可用于（参见
past_key_values输入）加速序列解码。 - decoder_hidden_states (
tuple[torch.FloatTensor, ...]，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（模型有嵌入层时，第一个为嵌入输出，其余为各层输出），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出的隐藏状态以及初始嵌入输出。
- decoder_attentions (
tuple[torch.FloatTensor, ...]，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 SoftMax 之后，用于计算自注意力头中的加权平均值。
- cross_attentions (
tuple[torch.FloatTensor, ...]，可选，在传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 SoftMax 之后，用于计算交叉注意力头中的加权平均值。
- encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选，默认为None) — 模型编码器最后一层输出的隐藏状态序列。 - encoder_hidden_states (
tuple[torch.FloatTensor, ...], optional, 当传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（若模型有嵌入层，则第一个为嵌入输出，后续每个为对应层的输出），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出时的隐藏状态以及初始嵌入输出。
- encoder_attentions (
tuple[torch.FloatTensor, ...], optional, 当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器在注意力 Softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
- encoder_global_attentions (
tuple(torch.FloatTensor), optional, 当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数量。经过注意力 Softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记到序列中每个标记的注意力权重。
序列到序列问答模型输出的基类。
LEDModel
class transformers.LEDModel
< 源代码 >( config: LEDConfig )
参数
- config (LEDConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。请查看 from_pretrained() 方法来加载模型权重。
原始的 Led 模型，输出原始隐藏状态，顶部没有任何特定的任务头。
该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< 源代码 >( input_ids: torch.LongTensor | None = None attention_mask: torch.Tensor | None = None decoder_input_ids: torch.LongTensor | None = None decoder_attention_mask: torch.LongTensor | None = None encoder_outputs: tuple[tuple[torch.FloatTensor]] | None = None global_attention_mask: torch.FloatTensor | None = None past_key_values: transformers.cache_utils.Cache | None = None inputs_embeds: torch.FloatTensor | None = None decoder_inputs_embeds: torch.FloatTensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None **kwargs ) → LEDSeq2SeqModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 词表中输入序列标记的索引。默认情况下，填充将被忽略。索引可以使用 AutoTokenizer 获取。详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值选自[0, 1]：- 1 表示未被掩码的标记，
- 0 表示被掩码的标记。
- decoder_input_ids (
torch.LongTensor，形状为(batch_size, target_sequence_length)，可选) — 词表中解码器输入序列标记的索引。索引可以使用
LedTokenizer获取。详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。LED 使用
eos_token_id作为decoder_input_ids生成的起始标记。如果使用了past_key_values，则可以选择只输入最后的decoder_input_ids（请参阅past_key_values）。 - decoder_attention_mask (
torch.LongTensor，形状为(batch_size, target_sequence_length)，可选) — 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。默认也会使用因果掩码（Causal mask）。如果您想更改填充行为，应该阅读
modeling_led._prepare_decoder_inputs并根据需要进行修改。更多关于默认策略的信息，请参阅 论文 中的图 1。 - encoder_outputs (
tuple[tuple[torch.FloatTensor]]，可选) — 元组包含 (last_hidden_state, 可选:hidden_states, 可选:attentions)；last_hidden_state（形状为(batch_size, sequence_length, hidden_size)，可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力中。 - global_attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 用于决定编码器对每个标记赋予的注意力（局部注意力或全局注意力）。具有全局注意力的标记会关注所有其他标记，并且所有其他标记也会关注它们。这对于特定任务的微调非常重要，因为它使模型在表示任务时更加灵活。例如，对于分类任务，[0, 1]：- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（关注所有其他标记的标记，且所有其他标记关注它们）。
- past_key_values (
~cache_utils.Cache，可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由模型在解码的先前阶段返回，即当use_cache=True或config.use_cache=True时。输入仅允许 Cache 实例，请参阅我们的 kv 缓存指南。如果没有传递
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的值。 - use_cache (
bool，可选) — 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（请参阅past_key_values）。 - output_attentions (
bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回 ModelOutput 而不是普通元组。
返回
LEDSeq2SeqModelOutput 或 tuple(torch.FloatTensor)
一个 LEDSeq2SeqModelOutput 或一个 torch.FloatTensor 元组（如果传入 return_dict=False 或当 config.return_dict=False 时），根据配置（LEDConfig）和输入包含各种元素。
LEDModel 的前向传播方法，覆盖了 __call__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层输出的隐藏状态序列。如果使用了
past_key_values，则只输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。past_key_values (
Cache，*可选*，当传入use_cache=True或config.use_cache=True时返回) — 这是一个 Cache 实例。欲了解更多细节，请参阅我们的 KV 缓存指南。包含解码器注意力块的预计算隐藏状态（键和值），可用于（参见
past_key_values输入）加速顺序解码。decoder_hidden_states (
tuple[torch.FloatTensor, ...], optional, 当传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果是嵌入层则包含一个，此外每一层输出一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出时的隐藏状态以及初始嵌入输出。
decoder_attentions (
tuple[torch.FloatTensor, ...], optional, 当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
cross_attentions (
tuple[torch.FloatTensor, ...], optional, 当传入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, 可选, 默认为None) — 模型编码器最后一层输出的隐状态序列。encoder_hidden_states (
tuple[torch.FloatTensor, ...], optional, 当传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果是嵌入层则包含一个，此外每一层输出一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出时的隐藏状态以及初始嵌入输出。
encoder_attentions (
tuple[torch.FloatTensor, ...], optional, 当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
encoder_global_attentions (
tuple(torch.FloatTensor), optional, 当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数。注意力 softmax 后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记对序列中每个标记的注意力权重。
LEDForConditionalGeneration
class transformers.LEDForConditionalGeneration
< source >( config: LEDConfig )
参数
- config (LEDConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
带有语言建模头的 LED 模型，可用于摘要任务。
该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< source >( input_ids: torch.LongTensor | None = None attention_mask: torch.Tensor | None = None decoder_input_ids: torch.LongTensor | None = None decoder_attention_mask: torch.LongTensor | None = None encoder_outputs: tuple[tuple[torch.FloatTensor]] | None = None global_attention_mask: torch.FloatTensor | None = None past_key_values: transformers.cache_utils.Cache | None = None inputs_embeds: torch.FloatTensor | None = None decoder_inputs_embeds: torch.FloatTensor | None = None labels: torch.LongTensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None **kwargs ) → LEDSeq2SeqLMOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)的torch.LongTensor，可选) — 词汇表中输入序列标记的索引。填充标记默认会被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
(batch_size, sequence_length)的torch.Tensor，可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值在[0, 1]中选择：- 1 表示未被屏蔽的标记，
- 0 表示被屏蔽的标记。
- decoder_input_ids (形状为
(batch_size, target_sequence_length)的torch.LongTensor，可选) — 词汇表中解码器输入序列标记的索引。可以使用
LedTokenizer获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。LED 使用
eos_token_id作为decoder_input_ids生成的起始标记。如果使用了past_key_values，则可以选择仅输入最后的decoder_input_ids（请参阅past_key_values）。 - decoder_attention_mask (形状为
(batch_size, target_sequence_length)的torch.LongTensor，可选) — 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。默认情况下还将使用因果掩码。如果您想更改填充行为，应该阅读
modeling_led._prepare_decoder_inputs并根据您的需要进行修改。有关默认策略的更多信息，请参阅论文中的图 1。 - encoder_outputs (
tuple[tuple[torch.FloatTensor]]，可选) — 元组由 (last_hidden_state, 可选:hidden_states, 可选:attentions) 组成。last_hidden_state的形状为(batch_size, sequence_length, hidden_size)（可选），是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 - global_attention_mask (形状为
(batch_size, sequence_length)的torch.FloatTensor，可选) — 用于决定编码器在每个标记上所给予的注意力掩码，是局部注意力还是全局注意力。具有全局注意力的标记关注所有其他标记，并且所有其他标记也都关注它们。这对于任务特定的微调非常重要，因为它使模型在表示任务时更加灵活。例如，对于分类，应该给标记全局注意力。对于 QA，所有问题标记也应该有全局注意力。请参阅 Longformer 论文以获取更多详细信息。掩码值在[0, 1]中选择：- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（关注所有其他标记的标记，且所有其他标记也关注它们）。
- past_key_values (
~cache_utils.Cache，可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包含模型在解码的先前阶段返回的past_key_values（当use_cache=True或config.use_cache=True时）。仅允许使用 Cache 实例作为输入，请参阅我们的 kv 缓存指南。如果不传递
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.FloatTensor，可选) — 作为替代input_ids的选项，您可以选择直接传入嵌入表示。如果您想比模型内部的嵌入查找矩阵更精细地控制如何将input_ids索引转换为相关向量，这将非常有用。 - decoder_inputs_embeds (形状为
(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor，可选) — 作为替代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, sequence_length)的torch.LongTensor，可选) — 用于计算掩码语言建模损失的标签。索引应在[0, ..., config.vocab_size]或-100中（请参阅input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅针对标签在[0, ..., config.vocab_size]中的标记计算。 - use_cache (
bool，可选) — 如果设置为True，则会返回past_key_values键值状态，并可用于加速解码（请参阅past_key_values）。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。
返回
LEDSeq2SeqLMOutput 或 tuple(torch.FloatTensor)
一个 LEDSeq2SeqLMOutput 或一个 torch.FloatTensor 元组（如果传入 return_dict=False 或当 config.return_dict=False 时），根据配置（LEDConfig）和输入包含各种元素。
LEDForConditionalGeneration 的前向传播方法，覆盖了 __call__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 语言建模损失。logits (形状为
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 语言建模头部的预测分数（SoftMax 之前的每个词汇标记的分数）。past_key_values (
Cache，*可选*，当传入use_cache=True或config.use_cache=True时返回) — 这是一个 Cache 实例。欲了解更多细节，请参阅我们的 KV 缓存指南。包含解码器注意力块的预计算隐藏状态（键和值），可用于（参见
past_key_values输入）加速顺序解码。decoder_hidden_states (
tuple[torch.FloatTensor, ...], optional, 当传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果是嵌入层则包含一个，此外每一层输出一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出时的隐藏状态以及初始嵌入输出。
decoder_attentions (
tuple[torch.FloatTensor, ...], optional, 当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
cross_attentions (
tuple[torch.FloatTensor, ...], optional, 当传入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, 可选, 默认为None) — 模型编码器最后一层输出的隐状态序列。encoder_hidden_states (
tuple[torch.FloatTensor, ...], optional, 当传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果是嵌入层则包含一个，此外每一层输出一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出时的隐藏状态以及初始嵌入输出。
encoder_attentions (
tuple[torch.FloatTensor, ...], optional, 当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
encoder_global_attentions (
tuple(torch.FloatTensor), optional, 当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数。注意力 softmax 后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记对序列中每个标记的注意力权重。
摘要示例
>>> import torch
>>> from transformers import AutoTokenizer, LEDForConditionalGeneration
>>> model = LEDForConditionalGeneration.from_pretrained("allenai/led-large-16384-arxiv")
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-large-16384-arxiv")
>>> ARTICLE_TO_SUMMARIZE = '''Transformers (Vaswani et al., 2017) have achieved state-of-the-art
... results in a wide range of natural language tasks including generative language modeling
... (Dai et al., 2019; Radford et al., 2019) and discriminative ... language understanding (Devlin et al., 2019).
... This success is partly due to the self-attention component which enables the network to capture contextual
... information from the entire sequence. While powerful, the memory and computational requirements of
... self-attention grow quadratically with sequence length, making it infeasible (or very expensive) to
... process long sequences. To address this limitation, we present Longformer, a modified Transformer
... architecture with a self-attention operation that scales linearly with the sequence length, making it
... versatile for processing long documents (Fig 1). This is an advantage for natural language tasks such as
... long document classification, question answering (QA), and coreference resolution, where existing approaches
... partition or shorten the long context into smaller sequences that fall within the typical 512 token limit
... of BERT-style pretrained models. Such partitioning could potentially result in loss of important
... cross-partition information, and to mitigate this problem, existing methods often rely on complex
... architectures to address such interactions. On the other hand, our proposed Longformer is able to build
... contextual representations of the entire context using multiple layers of attention, reducing the need for
... task-specific architectures.'''
>>> inputs = tokenizer.encode(ARTICLE_TO_SUMMARIZE, return_tensors="pt")
>>> # Global attention on the first token (cf. Beltagy et al. 2020)
>>> global_attention_mask = torch.zeros_like(inputs)
>>> global_attention_mask[:, 0] = 1
>>> # Generate Summary
>>> summary_ids = model.generate(inputs, global_attention_mask=global_attention_mask, num_beams=3, max_length=32)
>>> print(tokenizer.decode(summary_ids[0], skip_special_tokens=True, clean_up_tokenization_spaces=True))条件生成示例
>>> from transformers import AutoTokenizer, LEDForConditionalGeneration
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> TXT = "My friends are <mask> but they eat too many carbs."
>>> model = LEDForConditionalGeneration.from_pretrained("allenai/led-base-16384")
>>> input_ids = tokenizer([TXT], return_tensors="pt")["input_ids"]
>>> prediction = model.generate(input_ids)[0]
>>> print(tokenizer.decode(prediction, skip_special_tokens=True))LEDForQuestionAnswering
class transformers.LEDForQuestionAnswering
< 源代码 >( config model_args: ~utils.generic.ModelArgs | None = None adapter_args: ~utils.generic.AdapterArgs | None = None lora_args: ~utils.generic.LoRAArgs | None = None tokenizer_args: ~utils.generic.TokenizerArgs | None = None dataset_args: ~utils.generic.DatasetArgs | None = None data_args: ~utils.generic.DataArgs | None = None training_args: ~utils.generic.TrainingArgs | None = None generation_args: ~utils.generic.GenerationArgs | None = None vision_tower_args: ~utils.generic.VisionTowerArgs | None = None qlora_args: ~utils.generic.QLoRAArgs | None = None vision_tower_template_args: ~utils.generic.VisionTowerTemplateArgs | None = None video_tower_args: ~utils.generic.VideoTowerArgs | None = None vision_config: ~utils.generic.VisionConfig | None = None video_config: ~utils.generic.VideoConfig | None = None load_dataset: bool | None = None load_data_collator: bool | None = None load_processor: bool | None = None load_lora_adapter: bool | None = None load_adapter: bool | None = None load_qlora_adapter: bool | None = None **kwargs: typing_extensions.Unpack[transformers.modeling_utils.PreTrainedModelKwargs] )
参数
- config (LEDForQuestionAnswering) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
带有顶部跨度（span）分类头的 LED Transformer，用于抽取式问答任务（如 SQuAD），在隐藏状态输出之上添加了一个线性层以计算跨度开始 logits 和 跨度结束 logits。
该模型继承自 PreTrainedModel。请查看超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等）。
此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。
forward
< 源代码 >( input_ids: torch.LongTensor | None = None attention_mask: torch.Tensor | None = None decoder_input_ids: torch.LongTensor | None = None decoder_attention_mask: torch.LongTensor | None = None encoder_outputs: tuple[tuple[torch.FloatTensor]] | None = None global_attention_mask: torch.FloatTensor | None = None start_positions: torch.LongTensor | None = None end_positions: torch.LongTensor | None = None inputs_embeds: torch.FloatTensor | None = None decoder_inputs_embeds: torch.FloatTensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None **kwargs ) → LEDSeq2SeqQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下将忽略填充（padding）。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力机制的掩码。掩码值选自[0, 1]：- 1 表示未被掩码的标记，
- 0 表示被掩码的标记。
- decoder_input_ids (
torch.LongTensor，形状为(batch_size, target_sequence_length)，可选) — 词汇表中解码器输入序列标记的索引。可以使用
LedTokenizer获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。LED 使用
eos_token_id作为decoder_input_ids生成的起始标记。如果使用了past_key_values，则可以选择仅输入最后的decoder_input_ids（请参阅past_key_values）。 - decoder_attention_mask (
torch.LongTensor，形状为(batch_size, target_sequence_length)，可选) — 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。默认情况下也会使用因果掩码（causal mask）。如果您想更改填充行为，请阅读
modeling_led._prepare_decoder_inputs并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图 1。 - encoder_outputs (
tuple[tuple[torch.FloatTensor]]，可选) — 元组包含 (last_hidden_state，可选:hidden_states，可选:attentions)last_hidden_state，形状为(batch_size, sequence_length, hidden_size)，可选)，是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力机制。 - global_attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 用于决定对每个标记给予的注意力（即编码器的局部注意力或全局注意力）的掩码。具有全局注意力的标记会关注所有其他标记，并且所有其他标记也会关注它们。这对特定任务的微调非常重要，因为它使模型在表示任务时更具灵活性。例如，对于分类任务，[0, 1]：- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（关注所有其他标记，且所有其他标记也关注它们的标记）。
- start_positions (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算标记分类损失的标记跨度起始位置（索引）标签。位置被截断为序列的长度 (sequence_length)。序列之外的位置不会计入损失计算。 - end_positions (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算标记分类损失的标记跨度结束位置（索引）标签。位置被截断为序列的长度 (sequence_length)。序列之外的位置不会计入损失计算。 - inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 作为一个可选项，您可以选择直接传入嵌入表示，而不是传入input_ids。如果您想比模型内部的嵌入查找矩阵更精细地控制如何将input_ids索引转换为向量，这非常有用。 - decoder_inputs_embeds (
torch.FloatTensor，形状为(batch_size, target_sequence_length, hidden_size)，可选) — 作为一个可选项，您可以选择直接传入嵌入表示，而不是传入decoder_input_ids。如果使用了past_key_values，可以选择仅输入最后的decoder_inputs_embeds（请参阅past_key_values）。如果您想比模型内部的嵌入查找矩阵更精细地控制如何将decoder_input_ids索引转换为向量，这非常有用。如果
decoder_input_ids和decoder_inputs_embeds均未设置，decoder_inputs_embeds将采用inputs_embeds的值。 - use_cache (
bool，可选) — 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（请参阅past_key_values）。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回一个 ModelOutput 而不是普通元组。
返回
LEDSeq2SeqQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
一个 LEDSeq2SeqQuestionAnsweringModelOutput 或 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），根据配置 (LEDConfig) 和输入包含各种元素。
LEDForQuestionAnswering 的 forward 方法，覆盖了 __call__ 特殊方法。
虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用
Module实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。
loss (
torch.FloatTensorof shape(1,), 可选, 当提供labels时返回) — 总范围提取损失是起始位置和结束位置的交叉熵之和。start_logits (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选，默认为None) — 跨度开始分数（SoftMax 之前）。end_logits (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选，默认为None) — 跨度结束分数（SoftMax 之前）。past_key_values (
Cache，*可选*，当传入use_cache=True或config.use_cache=True时返回) — 这是一个 Cache 实例。欲了解更多细节，请参阅我们的 KV 缓存指南。包含解码器注意力块的预计算隐藏状态（键和值），可用于（参见
past_key_values输入）加速顺序解码。decoder_hidden_states (
tuple[torch.FloatTensor, ...], optional, 当传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果是嵌入层则包含一个，此外每一层输出一个），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出时的隐藏状态以及初始嵌入输出。
decoder_attentions (
tuple[torch.FloatTensor, ...], optional, 当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
cross_attentions (
tuple[torch.FloatTensor, ...], optional, 当传入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, 可选, 默认为None) — 模型编码器最后一层输出的隐状态序列。encoder_hidden_states (
tuple[torch.FloatTensor, ...], optional, 当传入output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果是嵌入层则包含一个，此外每一层输出一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出时的隐藏状态以及初始嵌入输出。
encoder_attentions (
tuple[torch.FloatTensor, ...], optional, 当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
encoder_global_attentions (
tuple(torch.FloatTensor), optional, 当传入output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数。注意力 softmax 后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记对序列中每个标记的注意力权重。
示例
>>> from transformers import AutoTokenizer, LEDForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> model = LEDForQuestionAnswering.from_pretrained("allenai/led-base-16384")
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
... outputs = model(**inputs)
>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()
>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...
>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])
>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...