Transformers documentation
LED
该模型于 2020-04-10 在 HF papers 上发布，并于 2021-01-05 贡献至 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。 - 要对 LED 的全部 16384 个参数进行微调，如果训练过程中出现内存不足（OOM）错误，可以启用梯度检查点。通过添加
model.gradient_checkpointing_enable()并设置use_cache=False来禁用缓存机制，从而节省内存。 - 输入应在右侧进行填充，因为 LED 使用绝对位置嵌入。
资源
- 阅读 Arxiv 上的 LED 笔记本，了解 LED 如何在 Arxiv 文章摘要任务中实现最先进的性能。
- 阅读 Fine-tune LED notebook，了解如何在 PubMed 文章上微调 LED。
LEDConfig
class transformers.LEDConfig
< source >( 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 = 50265max_encoder_position_embeddings: int = 16384max_decoder_position_embeddings: int = 1024encoder_layers: int = 12encoder_ffn_dim: int = 4096encoder_attention_heads: int = 16decoder_layers: int = 12decoder_ffn_dim: int = 4096decoder_attention_heads: int = 16encoder_layerdrop: float | int = 0.0decoder_layerdrop: float | int = 0.0use_cache: bool = Trueactivation_function: str = 'gelu'd_model: int = 1024dropout: float | int = 0.1attention_dropout: float | int = 0.0activation_dropout: float | int = 0.0init_std: float = 0.02decoder_start_token_id: int = 2classifier_dropout: float | int = 0.0pad_token_id: int | None = 1bos_token_id: int | None = 0eos_token_id: int | list[int] | None = 2attention_window: list[int] | int = 512tie_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]，可选，默认为0.0) — 注意力概率的 dropout 比率。 - activation_dropout (
Union[float, int]，可选，默认为0.0) — 全连接层中激活值的 dropout 比率。 - init_std (
float，可选，默认为0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - decoder_start_token_id (
int，可选，默认为2) — 如果编码器-解码器模型使用不同于bos的 token 开始解码，则指定该 token 的 id。 - classifier_dropout (
Union[float, int]，可选，默认为0.0) — 分类器的 dropout 比率。 - pad_token_id (
int，可选，默认为1) — 词表中用于填充的 token id。 - bos_token_id (
int，可选，默认为0) — 词汇表中用于表示流起始的 Token id。 - eos_token_id (
Union[int, list[int]]，可选，默认为2) — 词汇表中用于表示流结束（end-of-stream）的 token id。 - attention_window (
int或list[int]，可选，默认值为 512) — 每个 token 周围的注意力窗口大小。如果为int，则所有层使用相同的大小。若要为每一层指定不同的窗口大小，请使用list[int]，其中len(attention_window) == num_hidden_layers。 - tie_word_embeddings (
bool，可选，默认为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 = Nonemerges: str | list[str] | None = Noneerrors: 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 = Falsetrim_offsets: bool = True**kwargs )
参数
- vocab (
str、dict或list，可选) — 自定义词汇表。如果未提供，则从 vocab_file 加载词汇表。 - merges（
str或list，可选）— 自定义 merges 列表。如果未提供，则从 merges_file 加载 merges。 - errors (
str，可选，默认为"replace") — 将字节解码为 UTF-8 时遵循的策略。更多信息请参阅 bytes.decode。 - bos_token (
str, 可选, 默认为"<s>") — 预训练期间使用的序列起始标记。也可用作序列分类标记。在构建序列时，如果使用了特殊标记，序列开头使用的并不是这个标记。实际使用的标记是
cls_token。 - eos_token (
str, 可选, 默认为"</s>") — 序列结束标记。在构建包含特殊标记的序列时，序列结束使用的并非此标记，而是 sep_token。在构建包含特殊标记的序列时，序列末尾使用的并不是这个标记。 实际使用的是
sep_token。 - sep_token (
str，可选，默认为"</s>") — 分隔符 token，用于从多个序列构建序列时，例如用于序列分类的两个序列，或用于问答的文本和问题。它也用作使用特殊 token 构建的序列的最后一个 token。 - cls_token (
str，可选，默认为"<s>") — 用于序列分类（对整个序列进行分类，而非逐 token 分类）的分类器 token。当使用特殊 token 构建序列时，它是序列的第一个 token。 - unk_token (
str，可选，默认为"<unk>") — 未知标记。不在词汇表中的标记无法转换为 ID，因此会被设置为该标记。 - pad_token (
str，可选，默认为"<pad>") — 用于填充的标记，例如在对长度不同的序列进行批处理时。 - mask_token (
str, 可选，默认为"<mask>") — 用于掩码值的标记。这是在以掩码语言建模方式训练该模型时所使用的标记，也是模型将尝试预测的标记。 - add_prefix_space (
bool，可选，默认为False) — 是否要在输入前添加一个初始空格。这样可以将开头的单词视为与其他单词相同。（RoBERTa 分词器通过前面的空格来检测单词的开头）。 - trim_offsets (
bool，可选，默认为True) — 后处理步骤是否应裁剪偏移量，以避免包含空白字符。
构建一个 RoBERTa 分词器（基于 HuggingFace 的 tokenizers 库）。基于字节对编码（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
< source >( token_ids_0: list[int]token_ids_1: list[int] | None = Nonealready_has_special_tokens: bool = False ) → A list of integers in the range [0, 1]
从未添加特殊标记的标记列表中检索序列 ID。
对于快速分词器，数据整理器会传入 already_has_special_tokens=True 来调用此方法，以在已格式化的序列上构建掩码。在这种情况下，我们通过检查元素是否属于 all_special_ids 来计算掩码。
LED 特定输出
class transformers.models.led.modeling_led.LEDEncoderBaseModelOutput
< source >( last_hidden_state: Tensorhidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = Noneglobal_attentions: tuple[torch.Tensor, ...] | None = None )
参数
- last_hidden_state (
torch.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 - hidden_states (
tuple[torch.Tensor, ...], 可选, 在传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1), 其中x是带有全局注意力掩码的 token 数量。自注意力头中用于计算加权平均的局部注意力权重，即注意力 softmax 之后的权重。这些权重包括序列中每个 token 到所有具有全局注意力的 token（前
x个值）以及注意力窗口内每个 token（剩余的 `attention_window- 1
values). Note that the firstxvalues refer to tokens with fixed positions in the text, but the remainingattention_window + 1values refer to tokens with relative positions: the attention weight of a token to itself is located at indexx + attention_window / 2and theattention_window / 2preceding (succeeding) values are the attention weights to theattention_window / 2preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the firstxattention weights. If a token has global attention, the attention weights to all other tokens inattentionsis set to 0, the values should be accessed fromglobal_attentions`.
- 1
- global_attentions (
tuple(torch.Tensor), 可选, 当output_attentions=True被传入或config.output_attentions=True) — 元组torch.Tensor(，每个层一个，形状为(batch_size, num_heads, sequence_length, x), ，其中x是带有全局注意力掩码的 token 数量。经过注意力 softmax 后的全局注意力权重，用于在自注意力头中计算加权平均值。这些权重表示具有全局注意力的每个 token 到序列中每个 token 的注意力权重。
LEDEncoder 输出的基类，包含潜在的隐藏状态、局部注意力和全局注意力。
class transformers.models.led.modeling_led.LEDSeq2SeqModelOutput
< source >( last_hidden_state: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonedecoder_hidden_states: tuple[torch.Tensor, ...] | None = Nonedecoder_attentions: tuple[torch.Tensor, ...] | None = Nonecross_attentions: tuple[torch.Tensor, ...] | None = Noneencoder_last_hidden_state: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: tuple[torch.Tensor, ...] | None = Noneencoder_attentions: tuple[torch.Tensor, ...] | None = Noneencoder_global_attentions: tuple[torch.Tensor, ...] | None = None )
参数
- last_hidden_state (
torch.Tensor形状为(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 指南.包含解码器中预计算的隐藏状态（注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 - decoder_hidden_states (
tuple[torch.Tensor, ...], 可选, 在传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).解码器在每一层输出处的隐藏状态，以及初始嵌入输出。
- decoder_attentions (
tuple[torch.Tensor, ...], 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- cross_attentions (
tuple[torch.Tensor, ...], 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(，形状为(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
- encoder_last_hidden_state (
torch.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 - encoder_hidden_states (
tuple[torch.Tensor, ...], 可选, 当传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，以及每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).编码器在每一层输出处的隐藏状态，以及初始嵌入输出。
- encoder_attentions (
tuple[torch.Tensor, ...], 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- encoder_global_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, x), 其中x是带有全局注意力掩码的 token 数量。经过注意力 softmax 后的全局注意力权重，用于在自注意力头中计算加权平均值。这些权重表示具有全局注意力的每个 token 到序列中每个 token 的注意力权重。
模型编码器输出的基类，同时包含：可加速顺序解码的预计算隐藏状态。
class transformers.models.led.modeling_led.LEDSeq2SeqLMOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonedecoder_hidden_states: tuple[torch.Tensor, ...] | None = Nonedecoder_attentions: tuple[torch.Tensor, ...] | None = Nonecross_attentions: tuple[torch.Tensor, ...] | None = Noneencoder_last_hidden_state: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: tuple[torch.Tensor, ...] | None = Noneencoder_attentions: tuple[torch.Tensor, ...] | None = Noneencoder_global_attentions: tuple[torch.Tensor, ...] | None = None )
参数
- loss (
torch.Tensor，形状为(1,)，可选，在提供labels时返回) — 语言建模损失。 - logits (
torch.Tensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。 - past_key_values (
Cache, 可选, 在以下情况下返回use_cache=True或当config.use_cache=True) — 它是一个 Cache 实例。有关更多详细信息，请参阅我们的 kv cache 指南.包含解码器中预计算的隐藏状态（注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 - decoder_hidden_states (
tuple[torch.Tensor, ...], 可选, 在传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).解码器在每一层输出处的隐藏状态，以及初始嵌入输出。
- decoder_attentions (
tuple[torch.Tensor, ...], 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- cross_attentions (
tuple[torch.Tensor, ...], 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(，形状为(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
- encoder_last_hidden_state (
torch.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 - encoder_hidden_states (
tuple[torch.Tensor, ...], 可选, 当传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，以及每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).编码器在每一层输出处的隐藏状态，以及初始嵌入输出。
- encoder_attentions (
tuple[torch.Tensor, ...], 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- encoder_global_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, x), 其中x是带有全局注意力掩码的 token 数量。经过注意力 softmax 后的全局注意力权重，用于在自注意力头中计算加权平均值。这些权重表示具有全局注意力的每个 token 到序列中每个 token 的注意力权重。
序列到序列语言模型输出的基类。
class transformers.models.led.modeling_led.LEDSeq2SeqSequenceClassifierOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonelogits: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonedecoder_hidden_states: tuple[torch.Tensor, ...] | None = Nonedecoder_attentions: tuple[torch.Tensor, ...] | None = Nonecross_attentions: tuple[torch.Tensor, ...] | None = Noneencoder_last_hidden_state: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: tuple[torch.Tensor, ...] | None = Noneencoder_attentions: tuple[torch.Tensor, ...] | None = Noneencoder_global_attentions: tuple[torch.Tensor, ...] | None = None )
参数
- loss (
torch.Tensor，形状为(1,)，可选，在提供label时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。 - logits（形状为
(batch_size, config.num_labels)的torch.Tensor）— 分类（如果 config.num_labels==1 则为回归）得分（SoftMax 之前）。 - past_key_values (
Cache, 可选, 在以下情况下返回use_cache=True或当config.use_cache=True) — 它是一个 Cache 实例。有关更多详细信息，请参阅我们的 kv cache 指南.包含解码器中预计算的隐藏状态（注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 - decoder_hidden_states (
tuple[torch.Tensor, ...], 可选, 在传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).解码器在每一层输出处的隐藏状态，以及初始嵌入输出。
- decoder_attentions (
tuple[torch.Tensor, ...], 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- cross_attentions (
tuple[torch.Tensor, ...], 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(，形状为(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
- encoder_last_hidden_state (
torch.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 - encoder_hidden_states (
tuple[torch.Tensor, ...], 可选, 当传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，以及每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).编码器在每一层输出处的隐藏状态，以及初始嵌入输出。
- encoder_attentions (
tuple[torch.Tensor, ...], 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- encoder_global_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, x), 其中x是带有全局注意力掩码的 token 数量。经过注意力 softmax 后的全局注意力权重，用于在自注意力头中计算加权平均值。这些权重表示具有全局注意力的每个 token 到序列中每个 token 的注意力权重。
序列到序列句子分类模型输出的基类。
class transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput
< source >( loss: typing.Optional[torch.Tensor] = Nonestart_logits: typing.Optional[torch.Tensor] = Noneend_logits: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonedecoder_hidden_states: tuple[torch.Tensor, ...] | None = Nonedecoder_attentions: tuple[torch.Tensor, ...] | None = Nonecross_attentions: tuple[torch.Tensor, ...] | None = Noneencoder_last_hidden_state: typing.Optional[torch.Tensor] = Noneencoder_hidden_states: tuple[torch.Tensor, ...] | None = Noneencoder_attentions: tuple[torch.Tensor, ...] | None = Noneencoder_global_attentions: tuple[torch.Tensor, ...] | None = None )
参数
- loss (
torch.Tensor，形状为(1,)，可选，在提供labels时返回) — 总跨度提取损失是起始位置和结束位置的交叉熵之和。 - start_logits（形状为
(batch_size, sequence_length)的torch.Tensor，可选）— 跨度起始分数（SoftMax 之前）。 - end_logits（形状为
(batch_size, sequence_length)的torch.Tensor，可选）— 跨度结束分数（SoftMax 之前）。 - past_key_values (
Cache, 可选, 在以下情况下返回use_cache=True或当config.use_cache=True) — 它是一个 Cache 实例。有关更多详细信息，请参阅我们的 kv cache 指南.包含解码器中预计算的隐藏状态（注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。 - decoder_hidden_states (
tuple[torch.Tensor, ...], 可选, 在传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).解码器在每一层输出处的隐藏状态，以及初始嵌入输出。
- decoder_attentions (
tuple[torch.Tensor, ...], 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- cross_attentions (
tuple[torch.Tensor, ...], 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(，形状为(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
- encoder_last_hidden_state (
torch.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 - encoder_hidden_states (
tuple[torch.Tensor, ...], 可选, 当传入output_hidden_states=True或config.output_hidden_states=True) — 的元组torch.Tensor(（如果模型有嵌入层，则包含嵌入层输出的一个张量，以及每一层输出的一个张量），形状为(batch_size, sequence_length, hidden_size).编码器在每一层输出处的隐藏状态，以及初始嵌入输出。
- encoder_attentions (
tuple[torch.Tensor, ...], 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length).编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- encoder_global_attentions (
tuple(torch.Tensor), 可选, 在传入output_attentions=True或config.output_attentions=True) — 的元组torch.Tensor(（每层一个），形状为(batch_size, num_heads, sequence_length, x), 其中x是带有全局注意力掩码的 token 数量。经过注意力 softmax 后的全局注意力权重，用于在自注意力头中计算加权平均值。这些权重表示具有全局注意力的每个 token 到序列中每个 token 的注意力权重。
序列到序列问答模型输出的基类。
LEDModel
class transformers.LEDModel
< source >( config: LEDConfig )
参数
- config (LEDConfig) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
未附加任何特定头部的裸 Led 模型，直接输出原始隐藏状态。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Noneglobal_attention_mask: typing.Optional[torch.Tensor] = 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 ) → LEDSeq2SeqModelOutput or tuple(torch.Tensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- decoder_input_ids (
torch.LongTensor形状为(batch_size, target_sequence_length), 可选) — 解码器输入序列中各 token 在词汇表中的索引。可通过 LedTokenizer 获取这些索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是输入 ID？LED 使用 eos_token_id 作为生成 decoder_input_ids 的起始 token。如果使用 past_key_values，则只需输入最后一个 decoder_input_ids（参见 past_key_values）。可以使用
LedTokenizer获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。LED 使用
eos_token_id作为decoder_input_ids生成的起始 token。如果使用了past_key_values，则可以选择性地仅输入最后一个decoder_input_ids（参见past_key_values）。 - decoder_attention_mask (
torch.LongTensor形状为(batch_size, target_sequence_length), ，可选) — 默认行为：生成一个张量，用于忽略decoder_input_ids. 中的填充标记。默认情况下还会使用因果掩码。如需更改填充行为，请阅读
modeling_led._prepare_decoder_inputs并根据需求进行修改。有关默认策略的更多信息，请参阅 论文 中的图 1。 - encoder_outputs (
tuple[tuple[torch.Tensor]]，可选) — 元组由 (last_hidden_state，可选：hidden_states，可选：attentions) 组成last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选) 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 - global_attention_mask (
torch.Tensor形状为(batch_size, sequence_length), 可选) — 用于决定编码器中每个 token 的注意力机制，即局部注意力还是全局注意力。 具有全局注意力的 token 会关注所有其他 token，且所有其他 token 也会关注它们。这在任务特定的微调中非常重要，因为它使模型在表示任务时更加灵活。 例如，对于分类任务，token 应被赋予全局注意力。对于问答任务，所有问题 的 token 也应具有全局注意力。请参阅 Longformer 论文 以获取更多详细信息。掩码值选自[0, 1]:- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（这些 token 会关注所有其他 token，且所有其他 token 也会关注它们）。
- 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 而不是普通元组。
返回值
LEDSeq2SeqModelOutput 或 tuple(torch.Tensor)
一个 LEDSeq2SeqModelOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（LEDConfig）和输入。
LEDModel 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
last_hidden_state（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor）— 模型解码器最后一层输出的隐藏状态序列。如果使用了
past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。past_key_values（
Cache，可选，在传入use_cache=True或config.use_cache=True时返回）—— 它是一个 Cache 实例。更多详情，请参阅我们的 kv cache 指南。包含解码器中预计算的隐藏状态（注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。decoder_hidden_states (
tuple[torch.Tensor, ...]，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出处的隐藏状态，以及初始嵌入输出。
decoder_attentions（
tuple[torch.Tensor, ...]，可选，当传入output_attentions=True或config.output_attentions=True时返回）—— 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
cross_attentions (
tuple[torch.Tensor, ...]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
encoder_last_hidden_state（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor，可选）— 模型编码器最后一层输出的隐藏状态序列。encoder_hidden_states (
tuple[torch.Tensor, ...]，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出处的隐藏状态，以及初始嵌入输出。
encoder_attentions（
tuple[torch.Tensor, ...]，可选，当传入output_attentions=True或config.output_attentions=True时返回）—— 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
encoder_global_attentions (
tuple(torch.Tensor)，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是带有全局注意力掩码的 token 数量。经过注意力 softmax 后的全局注意力权重，用于在自注意力头中计算加权平均值。这些权重表示具有全局注意力的每个 token 到序列中每个 token 的注意力权重。
LEDForConditionalGeneration
class transformers.LEDForConditionalGeneration
< source >( config: LEDConfig )
参数
- config (LEDConfig) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
带有语言建模头的 LED 模型。可用于摘要任务。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Noneglobal_attention_mask: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → LEDSeq2SeqLMOutput or tuple(torch.Tensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- decoder_input_ids (
torch.LongTensor形状为(batch_size, target_sequence_length), 可选) — 解码器输入序列中各 token 在词汇表中的索引。可通过 LedTokenizer 获取这些索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是输入 ID？LED 使用 eos_token_id 作为生成 decoder_input_ids 的起始 token。如果使用 past_key_values，则只需输入最后一个 decoder_input_ids（参见 past_key_values）。可以使用
LedTokenizer获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。LED 使用
eos_token_id作为decoder_input_ids生成的起始 token。如果使用了past_key_values，则可以选择性地仅输入最后一个decoder_input_ids（参见past_key_values）。 - decoder_attention_mask (
torch.LongTensor形状为(batch_size, target_sequence_length), ，可选) — 默认行为：生成一个张量，用于忽略decoder_input_ids. 中的填充标记。默认情况下还会使用因果掩码。如需更改填充行为，请阅读
modeling_led._prepare_decoder_inputs并根据需求进行修改。有关默认策略的更多信息，请参阅 论文 中的图 1。 - encoder_outputs (
tuple[tuple[torch.Tensor]]，可选) — 元组由 (last_hidden_state，可选：hidden_states，可选：attentions) 组成last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选) 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 - global_attention_mask (
torch.Tensor形状为(batch_size, sequence_length), 可选) — 用于决定编码器中每个 token 的注意力机制，即局部注意力还是全局注意力。 具有全局注意力的 token 会关注所有其他 token，且所有其他 token 也会关注它们。这在任务特定的微调中非常重要，因为它使模型在表示任务时更加灵活。 例如，对于分类任务，token 应被赋予全局注意力。对于问答任务，所有问题 的 token 也应具有全局注意力。请参阅 Longformer 论文 以获取更多详细信息。掩码值选自[0, 1]:- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（这些 token 会关注所有其他 token，且所有其他 token 也会关注它们）。
- 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的值。 - labels (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引值应在[0, ..., config.vocab_size]范围内，或为 -100（参见input_ids的文档字符串）。索引值设为-100的 token 将被忽略（即被掩码），损失仅针对标签位于[0, ..., config.vocab_size]范围内的 token 进行计算。 - 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.Tensor)
一个 LEDSeq2SeqLMOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（LEDConfig）和输入。
LEDForConditionalGeneration 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss（形状为
(1,)的torch.Tensor，可选，在提供labels时返回）— 语言建模损失。logits（形状为
(batch_size, sequence_length, config.vocab_size)的torch.Tensor）— 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。past_key_values（
Cache，可选，在传入use_cache=True或config.use_cache=True时返回）—— 它是一个 Cache 实例。更多详情，请参阅我们的 kv cache 指南。包含解码器中预计算的隐藏状态（注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。decoder_hidden_states (
tuple[torch.Tensor, ...]，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出处的隐藏状态，以及初始嵌入输出。
decoder_attentions（
tuple[torch.Tensor, ...]，可选，当传入output_attentions=True或config.output_attentions=True时返回）—— 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
cross_attentions (
tuple[torch.Tensor, ...]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
encoder_last_hidden_state（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor，可选）— 模型编码器最后一层输出的隐藏状态序列。encoder_hidden_states (
tuple[torch.Tensor, ...]，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出处的隐藏状态，以及初始嵌入输出。
encoder_attentions（
tuple[torch.Tensor, ...]，可选，当传入output_attentions=True或config.output_attentions=True时返回）—— 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
encoder_global_attentions (
tuple(torch.Tensor)，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是带有全局注意力掩码的 token 数量。经过注意力 softmax 后的全局注意力权重，用于在自注意力头中计算加权平均值。这些权重表示具有全局注意力的每个 token 到序列中每个 token 的注意力权重。
摘要示例：
>>> 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
< source >( config: LEDConfig )
参数
- config (LEDConfig) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。
Led 变压器，其顶部带有用于抽取式问答任务（如 SQuAD）的跨度分类头（在隐藏状态输出之上添加一个线性层，用于计算 span start logits 和 span end logits）。
该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonedecoder_input_ids: typing.Optional[torch.LongTensor] = Nonedecoder_attention_mask: typing.Optional[torch.LongTensor] = Noneencoder_outputs: tuple[tuple[torch.Tensor]] | None = Noneglobal_attention_mask: typing.Optional[torch.Tensor] = Nonestart_positions: typing.Optional[torch.LongTensor] = Noneend_positions: typing.Optional[torch.LongTensor] = 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 ) → LEDSeq2SeqQuestionAnsweringModelOutput or tuple(torch.Tensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), ，可选) — 输入序列中各 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自[0, 1]:- 1 表示未被屏蔽的 token，
- 对于被掩码的 token，值为 0。
- decoder_input_ids (
torch.LongTensor形状为(batch_size, target_sequence_length), 可选) — 解码器输入序列中各 token 在词汇表中的索引。可通过 LedTokenizer 获取这些索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。什么是输入 ID？LED 使用 eos_token_id 作为生成 decoder_input_ids 的起始 token。如果使用 past_key_values，则只需输入最后一个 decoder_input_ids（参见 past_key_values）。可以使用
LedTokenizer获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。LED 使用
eos_token_id作为decoder_input_ids生成的起始 token。如果使用了past_key_values，则可以选择性地仅输入最后一个decoder_input_ids（参见past_key_values）。 - decoder_attention_mask (
torch.LongTensor形状为(batch_size, target_sequence_length), ，可选) — 默认行为：生成一个张量，用于忽略decoder_input_ids. 中的填充标记。默认情况下还会使用因果掩码。如需更改填充行为，请阅读
modeling_led._prepare_decoder_inputs并根据需求进行修改。有关默认策略的更多信息，请参阅 论文 中的图 1。 - encoder_outputs (
tuple[tuple[torch.Tensor]]，可选) — 元组由 (last_hidden_state，可选：hidden_states，可选：attentions) 组成last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选) 是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 - global_attention_mask (
torch.Tensor形状为(batch_size, sequence_length), 可选) — 用于决定编码器中每个 token 的注意力机制，即局部注意力还是全局注意力。 具有全局注意力的 token 会关注所有其他 token，且所有其他 token 也会关注它们。这在任务特定的微调中非常重要，因为它使模型在表示任务时更加灵活。 例如，对于分类任务，token 应被赋予全局注意力。对于问答任务，所有问题 的 token 也应具有全局注意力。请参阅 Longformer 论文 以获取更多详细信息。掩码值选自[0, 1]:- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（这些 token 会关注所有其他 token，且所有其他 token 也会关注它们）。
- start_positions (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算 token 分类损失的标注片段起始位置（索引）的标签。 位置会被截断到序列长度（sequence_length）。序列之外的位置在计算损失时不予考虑。 - end_positions (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算 token 分类损失的标注片段结束位置（索引）的标签。 位置会被截断到序列长度（sequence_length）。序列之外的位置在计算损失时不予考虑。 - 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 而不是普通元组。
返回值
LEDSeq2SeqQuestionAnsweringModelOutput 或 tuple(torch.Tensor)
一个 LEDSeq2SeqQuestionAnsweringModelOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（LEDConfig）和输入。
LEDForQuestionAnswering 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的实现需要在此函数中定义，但之后应调用
Module实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。
loss (
torch.Tensor，形状为(1,)，可选，当提供labels时返回) — 总跨度提取损失是起始位置和结束位置的交叉熵之和。start_logits（形状为
(batch_size, sequence_length)的torch.Tensor，可选）— 跨度起始分数（SoftMax 之前）。end_logits（形状为
(batch_size, sequence_length)的torch.Tensor，可选）— 跨度结束分数（SoftMax 之前）。past_key_values（
Cache，可选，在传入use_cache=True或config.use_cache=True时返回）—— 它是一个 Cache 实例。更多详情，请参阅我们的 kv cache 指南。包含解码器中预计算的隐藏状态（注意力块中的键和值），可用于（参见
past_key_values输入）加速顺序解码。decoder_hidden_states (
tuple[torch.Tensor, ...]，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出处的隐藏状态，以及初始嵌入输出。
decoder_attentions（
tuple[torch.Tensor, ...]，可选，当传入output_attentions=True或config.output_attentions=True时返回）—— 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
cross_attentions (
tuple[torch.Tensor, ...]，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层在注意力 softmax 之后的注意力权重，用于在交叉注意力头中计算加权平均值。
encoder_last_hidden_state（形状为
(batch_size, sequence_length, hidden_size)的torch.Tensor，可选）— 模型编码器最后一层输出的隐藏状态序列。encoder_hidden_states (
tuple[torch.Tensor, ...]，可选，在传入output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.Tensor元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出处的隐藏状态，以及初始嵌入输出。
encoder_attentions（
tuple[torch.Tensor, ...]，可选，当传入output_attentions=True或config.output_attentions=True时返回）—— 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器在注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
encoder_global_attentions (
tuple(torch.Tensor)，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个torch.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是带有全局注意力掩码的 token 数量。经过注意力 softmax 后的全局注意力权重，用于在自注意力头中计算加权平均值。这些权重表示具有全局注意力的每个 token 到序列中每个 token 的注意力权重。
示例：
>>> 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)
...