Transformers 文档
LED
并获得增强的文档体验
开始使用
LED
概述
LED 模型由 Iz Beltagy、Matthew E. Peters 和 Arman Cohan 在论文 Longformer: The Long-Document Transformer 中提出。
论文摘要如下：
基于 Transformer 的模型由于其自注意力操作（其计算复杂度与序列长度成二次方关系）而无法处理长序列。为了解决这个限制，我们引入了 Longformer，其注意力机制与序列长度呈线性关系，使其能够轻松处理数千个甚至更长的 token 的文档。Longformer 的注意力机制是标准自注意力的直接替代品，并结合了局部窗口注意力和任务驱动的全局注意力。我们遵循先前关于长序列 Transformer 的工作，在字符级语言建模上评估 Longformer，并在 text8 和 enwik8 上取得了最先进的结果。与大多数先前工作不同，我们还预训练了 Longformer，并在各种下游任务上进行了微调。我们的预训练 Longformer 在长文档任务上持续优于 RoBERTa，并在 WikiHop 和 TriviaQA 上创下了新的最先进结果。最后，我们引入了 Longformer-Encoder-Decoder (LED)，这是 Longformer 的一个变体，用于支持长文档生成式序列到序列任务，并在 arXiv 摘要数据集上展示了其有效性。
使用技巧
- LEDForConditionalGeneration 是 BartForConditionalGeneration 的扩展，它将传统的*自注意力*层替换为*Longformer*的*分块自注意力*层。LEDTokenizer 是 BartTokenizer 的别名。
- LED 在长距离*序列到序列*任务上表现非常出色，其中 `input_ids` 的长度远超 1024 个 token。
- 如果需要，LED 会将 `input_ids` 填充为 `config.attention_window` 的倍数。因此，当使用带有 `pad_to_multiple_of` 参数的 LEDTokenizer 时，可以获得轻微的速度提升。
- LED 利用 `global_attention_mask`（参见 LongformerModel）来实现*全局注意力*。对于摘要任务，建议仅在第一个 `<s>` token 上设置*全局注意力*。对于问答任务，建议在问题的所有 token 上设置*全局注意力*。
- 要在所有 16384 个 token 上微调 LED，如果训练导致内存不足 (OOM) 错误，可以启用*梯度检查点*。这可以通过执行 `model.gradient_checkpointing_enable()` 来完成。此外，可以使用 `use_cache=False` 标志来禁用缓存机制以节省内存。
- LED 是一个具有绝对位置嵌入的模型，因此通常建议在右侧而不是左侧填充输入。
此模型由 patrickvonplaten 贡献。
资源
LEDConfig
class transformers.LEDConfig
< 来源 >( vocab_size = 50265 max_encoder_position_embeddings = 16384 max_decoder_position_embeddings = 1024 encoder_layers = 12 encoder_ffn_dim = 4096 encoder_attention_heads = 16 decoder_layers = 12 decoder_ffn_dim = 4096 decoder_attention_heads = 16 encoder_layerdrop = 0.0 decoder_layerdrop = 0.0 use_cache = True is_encoder_decoder = True activation_function = 'gelu' d_model = 1024 dropout = 0.1 attention_dropout = 0.0 activation_dropout = 0.0 init_std = 0.02 decoder_start_token_id = 2 classifier_dropout = 0.0 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 attention_window: typing.Union[list[int], int] = 512 **kwargs )
参数
- vocab_size (
int, 可选, 默认为 50265) — LED 模型的词汇表大小。定义了在调用 LEDModel 或 TFLEDModel 时，`inputs_ids` 可以表示的不同 token 的数量。 - d_model (
int, 可选, 默认为 1024) — 各层和池化层的维度。 - encoder_layers (
int, 可选, 默认为 12) — 编码器的层数。 - decoder_layers (
int, 可选, 默认为 12) — 解码器的层数。 - encoder_attention_heads (
int, 可选, 默认为 16) — Transformer 编码器中每个注意力层的注意力头数。 - decoder_attention_heads (
int, 可选, 默认为 16) — Transformer 解码器中每个注意力层的注意力头数。 - decoder_ffn_dim (
int, 可选, 默认为 4096) — 解码器中“中间”层（通常称为前馈层）的维度。 - encoder_ffn_dim (
int, 可选, 默认为 4096) — 解码器中“中间”层（通常称为前馈层）的维度。 - activation_function (
str或function, 可选, 默认为"gelu") — 编码器和池化层中的非线性激活函数（函数或字符串）。如果为字符串，支持 `"gelu"`、`"relu"`、`"silu"` 和 `"gelu_new"`。 - dropout (
float, 可选, 默认为 0.1) — 嵌入层、编码器和池化层中所有全连接层的 dropout 概率。 - attention_dropout (
float, 可选, 默认为 0.0) — 注意力概率的 dropout 比例。 - activation_dropout (
float, 可选, 默认为 0.0) — 全连接层内部激活函数的 dropout 比例。 - classifier_dropout (
float, 可选, 默认为 0.0) — 分类器的 dropout 比例。 - max_encoder_position_embeddings (
int, 可选, 默认为 16384) — 编码器可能使用的最大序列长度。 - max_decoder_position_embeddings (
int, 可选, 默认为 16384) — 解码器可能使用的最大序列长度。 - init_std (
float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - encoder_layerdrop (
float, 可选, 默认为 0.0) — 编码器的 LayerDrop 概率。更多细节请参见 [LayerDrop 论文](参见 https://huggingface.co/papers/1909.11556)。 - decoder_layerdrop (
float, 可选, 默认为 0.0) — 解码器的 LayerDrop 概率。更多细节请参见 [LayerDrop 论文](参见 https://huggingface.co/papers/1909.11556)。 - use_cache (
bool, 可选, 默认为True) — 模型是否应返回最后一个键/值注意力（并非所有模型都使用）。
这是用于存储 LEDModel 配置的配置类。它用于根据指定的参数实例化一个 LED 模型，定义模型架构。使用默认值实例化配置将产生与 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.LEDTokenizer
< source >( vocab_file merges_file errors = 'replace' bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' add_prefix_space = False **kwargs )
参数
- vocab_file (
str) — 词汇表文件的路径。 - merges_file (
str) — 合并文件的路径。 - errors (
str, optional, 默认为"replace") — 将字节解码为 UTF-8 时遵循的范式。更多信息请参阅 bytes.decode。 - bos_token (
str, optional, 默认为"<s>") — 预训练期间使用的序列开始标记。可用作序列分类器标记。当使用特殊标记构建序列时，这不是用于序列开始的标记。使用的标记是
cls_token。 - eos_token (
str, optional, 默认为"</s>") — 序列结束标记。当使用特殊标记构建序列时，这不是用于序列结束的标记。使用的标记是
sep_token。 - sep_token (
str, optional, 默认为"</s>") — 分隔符标记，用于从多个序列构建一个序列时，例如用于序列分类的两个序列，或用于问答的文本和问题。它也用作使用特殊标记构建的序列的最后一个标记。 - cls_token (
str, optional, 默认为"<s>") — 分类器标记，用于进行序列分类（对整个序列进行分类，而不是对每个标记进行分类）。当使用特殊标记构建序列时，它是序列的第一个标记。 - unk_token (
str, optional, 默认为"<unk>") — 未知标记。不在词汇表中的标记无法转换为 ID，将被设置为此标记。 - pad_token (
str, optional, 默认为"<pad>") — 用于填充的标记，例如在批处理不同长度的序列时使用。 - mask_token (
str, optional, 默认为"<mask>") — 用于掩盖值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。 - add_prefix_space (
bool, optional, 默认为False) — 是否在输入前添加一个初始空格。这允许将开头的词与任何其他词一样处理。（BART 分词器通过前面的空格来检测词的开始）。
构建一个 LED 分词器，它与 RoBERTa 分词器类似，使用字节级字节对编码（Byte-Pair-Encoding）。
这个分词器经过训练，将空格视为词元的一部分（有点像 sentencepiece），所以一个词会
无论是否在句子开头（无空格），编码方式都会不同
>>> from transformers import LEDTokenizer
>>> tokenizer = LEDTokenizer.from_pretrained("allenai/led-base-16384")
>>> tokenizer("Hello world")["input_ids"]
[0, 31414, 232, 2]
>>> tokenizer(" Hello world")["input_ids"]
[0, 20920, 232, 2]您可以通过在实例化此分词器时或在对某些文本调用它时传递 add_prefix_space=True 来绕过此行为，但由于模型并非以这种方式进行预训练，这可能会导致性能下降。
当与 is_split_into_words=True 一起使用时，此分词器会在每个词（甚至是第一个词）之前添加一个空格。
该分词器继承自 PreTrainedTokenizer，其中包含了大部分主要方法。用户应参考此超类以获取有关这些方法的更多信息。
build_inputs_with_special_tokens
< source >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
通过连接和添加特殊标记，从一个序列或一对序列中为序列分类任务构建模型输入。LED 序列的格式如下：
- 单个序列：
<s> X </s> - 序列对：
<s> A </s></s> B </s>
get_special_tokens_mask
< source >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None already_has_special_tokens: bool = False ) → list[int]
从没有添加特殊标记的标记列表中检索序列ID。此方法在使用分词器prepare_for_model方法添加特殊标记时调用。
create_token_type_ids_from_sequences
< source >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
从传入的两个序列创建一个掩码，用于序列对分类任务。LED 不使用标记类型 ID，因此返回一个零列表。
LEDTokenizerFast
class transformers.LEDTokenizerFast
< source >( vocab_file = None merges_file = None tokenizer_file = None errors = 'replace' bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' add_prefix_space = False trim_offsets = True **kwargs )
参数
- vocab_file (
str) — 词汇表文件的路径。 - merges_file (
str) — 合并文件的路径。 - errors (
str, optional, 默认为"replace") — 将字节解码为 UTF-8 时遵循的范式。更多信息请参阅 bytes.decode。 - bos_token (
str, optional, 默认为"<s>") — 预训练期间使用的序列开始标记。可用作序列分类器标记。当使用特殊标记构建序列时，这不是用于序列开始的标记。使用的标记是
cls_token。 - eos_token (
str, optional, 默认为"</s>") — 序列结束标记。当使用特殊标记构建序列时，这不是用于序列结束的标记。使用的标记是
sep_token。 - sep_token (
str, optional, 默认为"</s>") — 分隔符标记，用于从多个序列构建一个序列时，例如用于序列分类的两个序列，或用于问答的文本和问题。它也用作使用特殊标记构建的序列的最后一个标记。 - cls_token (
str, optional, 默认为"<s>") — 分类器标记，用于进行序列分类（对整个序列进行分类，而不是对每个标记进行分类）。当使用特殊标记构建序列时，它是序列的第一个标记。 - unk_token (
str, optional, 默认为"<unk>") — 未知标记。不在词汇表中的标记无法转换为 ID，将被设置为此标记。 - pad_token (
str, optional, 默认为"<pad>") — 用于填充的标记，例如在批处理不同长度的序列时使用。 - mask_token (
str, optional, 默认为"<mask>") — 用于掩盖值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。 - add_prefix_space (
bool, optional, 默认为False) — 是否在输入前添加一个初始空格。这允许将开头的词与任何其他词一样处理。（LED 分词器通过前面的空格来检测词的开始）。 - trim_offsets (
bool, optional, 默认为True) — 后处理步骤是否应修剪偏移量以避免包含空白字符。
构建一个“快速”的 LED 分词器（由 HuggingFace 的 *tokenizers* 库支持），该分词器源自 GPT-2 分词器，使用字节级字节对编码（Byte-Pair-Encoding）。
这个分词器经过训练，将空格视为词元的一部分（有点像 sentencepiece），所以一个词会
无论是否在句子开头（无空格），编码方式都会不同
>>> from transformers import LEDTokenizerFast
>>> tokenizer = LEDTokenizerFast.from_pretrained("allenai/led-base-16384")
>>> tokenizer("Hello world")["input_ids"]
[0, 31414, 232, 2]
>>> tokenizer(" Hello world")["input_ids"]
[0, 20920, 232, 2]您可以通过在实例化此分词器时或在对某些文本调用它时传递 add_prefix_space=True 来绕过此行为，但由于模型并非以这种方式进行预训练，这可能会导致性能下降。
当与 is_split_into_words=True 一起使用时，此分词器需要以 add_prefix_space=True 进行实例化。
该分词器继承自 PreTrainedTokenizerFast，其中包含了大部分主要方法。用户应参考此超类以获取有关这些方法的更多信息。
create_token_type_ids_from_sequences
< source >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
从传入的两个序列创建一个掩码，用于序列对分类任务。LED 不使用标记类型 ID，因此返回一个零列表。
LED 特定输出
class transformers.models.led.modeling_led.LEDEncoderBaseModelOutput
< source >( last_hidden_state: FloatTensor hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None global_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- last_hidden_state (
<class 'torch.FloatTensor'>.last_hidden_stateof shape(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 - hidden_states (
tuple[torch.FloatTensor, ...], optional, 当传递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是具有全局注意力掩码的标记数量。经过注意力 softmax 后的局部注意力权重，用于计算自注意力头中的加权平均值。这些是序列中每个标记对每个具有全局注意力的标记（前
x个值）以及注意力窗口中每个标记（剩余 `attention_window- 1
个值）的注意力权重。请注意，前x个值指的是文本中位置固定的标记，而剩余的attention_window + 1个值指的是相对位置的标记：一个标记对其自身的注意力权重位于索引x + attention_window / 2处，而attention_window / 2个前（后）的值是其对attention_window / 2个前（后）标记的注意力权重。如果注意力窗口包含一个具有全局注意力的标记，则相应索引处的注意力权重设置为 0；该值应从前x` 个注意力权重中访问。如果一个标记具有全局注意力，则其对所有其他标记的注意力权重在 `attentions` 中设置为 0，该值应从 `global_attentions` 中访问。
- 1
- global_attentions (
tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数量。经过注意力 softmax 后的全局注意力权重，用于计算自注意力头中的加权平均值。这些是每个具有全局注意力的标记对序列中每个标记的注意力权重。
LEDEncoder 输出的基类，包含潜在的隐藏状态、局部和全局注意力。
class transformers.models.led.modeling_led.LEDSeq2SeqModelOutput
< source >( last_hidden_state: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[list[torch.FloatTensor]] = None decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_global_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- last_hidden_state (
torch.FloatTensorof shape(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层输出的隐藏状态序列。如果使用
past_key_values，则只输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。 - past_key_values (
list[torch.FloatTensor], optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的torch.FloatTensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含解码器预先计算的隐藏状态（注意力块中的键和值），可用于（参见
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, ...]，可选，当传递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.LEDSeq2SeqLMOutput
< 来源 >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[list[torch.FloatTensor]] = None decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_global_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 语言建模损失。 - logits (
torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 前每个词汇表词元的分数）。 - past_key_values (
list[torch.FloatTensor]，可选，当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的torch.FloatTensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。包含预先计算的解码器隐藏状态（注意力块中的键和值），可用于（参见
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.LEDSeq2SeqSequenceClassifierOutput
< 来源 >( loss: typing.Optional[torch.FloatTensor] = None logits: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[list[torch.FloatTensor]] = None decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_global_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = 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 (
list[torch.FloatTensor]，可选，当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的torch.FloatTensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。包含预先计算的解码器隐藏状态（注意力块中的键和值），可用于（参见
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: typing.Optional[torch.FloatTensor] = None start_logits: typing.Optional[torch.FloatTensor] = None end_logits: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[list[torch.FloatTensor]] = None decoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None encoder_global_attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 总的片段提取损失是起始和结束位置交叉熵损失的和。 - start_logits (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选，默认为None) — 片段起始分数（SoftMax 前）。 - end_logits (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选，默认为None) — 片段结束分数（SoftMax 前）。 - past_key_values (
list[torch.FloatTensor]，可选，当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的torch.FloatTensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。包含预先计算的解码器隐藏状态（注意力块中的键和值），可用于（参见
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_tf_led.TFLEDEncoderBaseModelOutput
< 来源 >( last_hidden_state: Optional[tf.Tensor] = None hidden_states: tuple[tf.Tensor, ...] | None = None attentions: tuple[tf.Tensor, ...] | None = None global_attentions: tuple[tf.Tensor, ...] | None = None )
参数
- last_hidden_state (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 - hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（一个是嵌入层的输出 + 每个层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出的隐藏状态以及初始嵌入输出。
- attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是具有全局注意力掩码的词元数量。局部注意力权重（在注意力 softmax 之后），用于计算自注意力头中的加权平均值。这些是从序列中每个词元到每个具有全局注意力的词元（前
x个值）以及到注意力窗口中每个词元（剩余的 `attention_window- 1
个值）的注意力权重。请注意，前x + attention_window / 2x个值指的是文本中固定位置的词元，但剩余的 `attention_window + 1` 个值指的是相对位置的词元：一个词元对其自身的注意力权重位于索引处，而attention_window / 2个前（后）的值是其对attention_window / 2` 个前（后）词元的注意力权重。如果注意力窗口包含一个具有全局注意力的词元，相应索引处的注意力权重将设置为 0；该值应从前x个注意力权重中访问。如果一个词元具有全局注意力，那么在 `attentions` 中它对所有其他词元的注意力权重都设置为 0，这些值应从 `global_attentions` 中访问。
- 1
- global_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的词元数量。全局注意力权重（在注意力 softmax 之后），用于计算自注意力头中的加权平均值。这些是从每个具有全局注意力的词元到序列中每个词元的注意力权重。
Longformer 输出的基类，可能包含隐藏状态、局部和全局注意力。
class transformers.models.led.modeling_tf_led.TFLEDSeq2SeqModelOutput
< source >( last_hidden_state: Optional[tf.Tensor] = None past_key_values: list[tf.Tensor] | None = None decoder_hidden_states: tuple[tf.Tensor, ...] | None = None decoder_attentions: tuple[tf.Tensor, ...] | None = None cross_attentions: tuple[tf.Tensor, ...] | None = None encoder_last_hidden_state: tf.Tensor | None = None encoder_hidden_states: tuple[tf.Tensor, ...] | None = None encoder_attentions: tuple[tf.Tensor, ...] | None = None encoder_global_attentions: tuple[tf.Tensor, ...] | None = None )
参数
- last_hidden_state (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层输出的隐藏状态序列。如果使用了
past_key_values，则只输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。 - past_key_values (
list[tf.Tensor]，可选，当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含解码器注意力块中预先计算的隐藏状态（键和值），可用于（参见
past_key_values输入）加速序列解码。 - decoder_hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入层输出 + 每个层一个输出）。解码器每一层输出的隐藏状态，以及初始的嵌入层输出。
- decoder_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。解码器的注意力权重，经过注意力 softmax 之后，用于在自注意力头中计算加权平均值。
- cross_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。解码器交叉注意力层的注意力权重，经过注意力 softmax 之后，用于在交叉注意力头中计算加权平均值。
- encoder_last_hidden_state (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 - encoder_hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入层输出 + 每个层一个输出）。编码器每一层输出的隐藏状态，以及初始的嵌入层输出。
- encoder_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。编码器的注意力权重，经过注意力 softmax 之后，用于在自注意力头中计算加权平均值。
- encoder_global_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, x)的tf.Tensor元组（每层一个），其中x是具有全局注意力掩码的标记数量。经过注意力 softmax 之后的全局注意力权重，用于在自注意力头中计算加权平均值。这些是从每个具有全局注意力的标记到序列中每个标记的注意力权重。
模型编码器输出的基类，也包含：可加速顺序解码的预计算隐藏状态。
class transformers.models.led.modeling_tf_led.TFLEDSeq2SeqLMOutput
< source >( loss: tf.Tensor | None = None logits: Optional[tf.Tensor] = None past_key_values: list[tf.Tensor] | None = None decoder_hidden_states: tuple[tf.Tensor, ...] | None = None decoder_attentions: tuple[tf.Tensor, ...] | None = None cross_attentions: tuple[tf.Tensor, ...] | None = None encoder_last_hidden_state: tf.Tensor | None = None encoder_hidden_states: tuple[tf.Tensor, ...] | None = None encoder_attentions: tuple[tf.Tensor, ...] | None = None encoder_global_attentions: tuple[tf.Tensor, ...] | None = None )
参数
- loss (
tf.Tensor，形状为(1,)，可选，当提供了labels时返回) — 语言建模损失。 - logits (
tf.Tensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（在 SoftMax 之前的每个词汇标记的分数）。 - past_key_values (
list[tf.Tensor]，可选，当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含解码器注意力块中预先计算的隐藏状态（键和值），可用于（参见
past_key_values输入）加速序列解码。 - decoder_hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入层输出 + 每个层一个输出）。解码器每一层输出的隐藏状态，以及初始的嵌入层输出。
- decoder_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。解码器的注意力权重，经过注意力 softmax 之后，用于在自注意力头中计算加权平均值。
- cross_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。解码器交叉注意力层的注意力权重，经过注意力 softmax 之后，用于在交叉注意力头中计算加权平均值。
- encoder_last_hidden_state (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 - encoder_hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入层输出 + 每个层一个输出）。编码器每一层输出的隐藏状态，以及初始的嵌入层输出。
- encoder_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。编码器的注意力权重，经过注意力 softmax 之后，用于在自注意力头中计算加权平均值。
- encoder_global_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, x)的tf.Tensor元组（每层一个），其中x是具有全局注意力掩码的标记数量。经过注意力 softmax 之后的全局注意力权重，用于在自注意力头中计算加权平均值。这些是从每个具有全局注意力的标记到序列中每个标记的注意力权重。
序列到序列语言模型输出的基类。
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] = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None global_attention_mask: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.led.modeling_led.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中填充标记的张量。默认情况下也会使用因果掩码。如果要更改填充行为，应阅读
modeling_led._prepare_decoder_inputs并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图 1。 - head_mask (
torch.Tensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 掩码，用于将自注意力模块中选定的头置零。掩码值在[0, 1]中选择：- 1 表示该头未被掩码，
- 0 表示该头被掩码。
- decoder_head_mask (
torch.Tensor，形状为(decoder_layers, decoder_attention_heads)，可选) — 掩码，用于将解码器中注意力模块的选定头置零。掩码值在[0, 1]中选择：- 1 表示该头未被掩码，
- 0 表示该头被掩码。
- cross_attn_head_mask (
torch.Tensor，形状为(decoder_layers, decoder_attention_heads)，可选) — 掩码，用于将解码器中交叉注意力模块的选定头置零。掩码值在[0, 1]中选择：- 1 表示该头未被掩码，
- 0 表示该头被掩码。
- 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)，可选) — 用于决定编码器中每个标记的注意力类型的掩码，可以是局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，而所有其他标记也会关注它们。这对于特定任务的微调非常重要，因为它使模型在表示任务时更加灵活。例如，对于分类任务，标记应给予全局注意力。对于问答任务，所有问题标记也应具有全局注意力。请参阅 Longformer 论文 了解更多详情。掩码值在[0, 1]中选择：- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（标记关注所有其他标记，所有其他标记也关注它）。
- past_key_values (
tuple[tuple[torch.FloatTensor]]，可选) — 预先计算的隐藏状态（自注意力和交叉注意力块中的键和值），可用于加速序列解码。这通常包括在解码的先前阶段，当use_cache=True或config.use_cache=True时由模型返回的past_key_values。允许两种格式：
- 一个 Cache 实例，请参阅我们的 kv 缓存指南；
- 长度为
config.n_layers的tuple(torch.FloatTensor)元组，每个元组有两个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。这也称为旧版缓存格式。
模型将输出与输入相同的缓存格式。如果没有传递
past_key_values，将返回旧版缓存格式。如果使用了
past_key_values，用户可以选择只输入最后的input_ids（那些没有为其提供过去键值状态的标记），形状为(batch_size, 1)，而不是形状为(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，可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
返回
transformers.models.led.modeling_led.LEDSeq2SeqModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.led.modeling_led.LEDSeq2SeqModelOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False），包含根据配置（LEDConfig）和输入的不同元素。
-
last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层输出的隐藏状态序列。如果使用了
past_key_values，则只输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。 -
past_key_values (
list[torch.FloatTensor]，可选，当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的torch.FloatTensor列表，每个张量形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含解码器注意力块的预计算隐藏状态（键和值），可用于（参见
past_key_values输入）加速顺序解码。 -
decoder_hidden_states (
tuple[torch.FloatTensor, ...]，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入层输出，如果模型有嵌入层，+ 每个层一个输出）。解码器在每一层输出时的隐藏状态以及初始嵌入输出。
-
decoder_attentions (
tuple[torch.FloatTensor, ...]，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
-
cross_attentions (
tuple[torch.FloatTensor, ...]，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。解码器交叉注意力层的注意力权重，在注意力 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时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入层输出，如果模型有嵌入层，+ 每个层一个输出）。编码器在每一层输出时的隐藏状态以及初始嵌入输出。
-
encoder_attentions (
tuple[torch.FloatTensor, ...]，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
-
encoder_global_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, x)的torch.FloatTensor元组（每层一个），其中x是具有全局注意力掩码的标记数量。经过注意力 softmax 之后的全局注意力权重，用于在自注意力头中计算加权平均值。这些是从每个具有全局注意力的标记到序列中每个标记的注意力权重。
LEDModel 的前向方法，覆盖了 `__call__` 特殊方法。
虽然前向传递的逻辑需要在这个函数中定义，但之后应该调用 `Module` 实例而不是这个函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
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] = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None global_attention_mask: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.led.modeling_led.LEDSeq2SeqLMOutput 或 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中填充词元的张量。默认情况下也会使用因果掩码。如果您想更改填充行为，应阅读
modeling_led._prepare_decoder_inputs并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图 1。 - head_mask (
torch.Tensor，形状(num_heads,)或(num_layers, num_heads)，可选) — 用于置零自注意力模块中选定头的掩码。掩码值选自[0, 1]：- 1 表示头未被屏蔽，
- 0 表示头已被屏蔽。
- decoder_head_mask (
torch.Tensor，形状(decoder_layers, decoder_attention_heads)，可选) — 用于置零解码器中注意力模块选定头的掩码。掩码值选自[0, 1]：- 1 表示头未被屏蔽，
- 0 表示头已被屏蔽。
- cross_attn_head_mask (
torch.Tensor，形状(decoder_layers, decoder_attention_heads)，可选) — 用于置零解码器中交叉注意力模块选定头的掩码。掩码值选自[0, 1]：- 1 表示头未被屏蔽，
- 0 表示头已被屏蔽。
- encoder_outputs (
tuple[tuple[torch.FloatTensor]]，可选) — 元组，包含 (last_hidden_state，可选:hidden_states，可选:attentions)。形状为(batch_size, sequence_length, hidden_size)的last_hidden_state（可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 - global_attention_mask (
torch.FloatTensor，形状(batch_size, sequence_length)，可选) — 用于决定编码器中每个词元是使用局部注意力还是全局注意力的掩码。具有全局注意力的词元会关注所有其他词元，而所有其他词元也会关注它们。这对于特定任务的微调很重要，因为它使模型在表示任务时更灵活。例如，对于分类任务，词元应给予全局注意力。对于问答任务，所有问题词元也应具有全局注意力。更多详情请参阅 Longformer 论文。掩码值选自[0, 1]：- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（关注所有其他词元的词元，并且所有其他词元都关注它们）。
- past_key_values (
tuple[tuple[torch.FloatTensor]]，可选) — 预先计算的隐藏状态（自注意力和交叉注意力块中的键和值），可用于加速顺序解码。这通常是模型在解码的先前阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。允许两种格式：
- 一个 Cache 实例，请参阅我们的 kv 缓存指南；
- 长度为
config.n_layers的tuple(torch.FloatTensor)元组，每个元组包含 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。这也称为旧版缓存格式。
模型将输出与输入相同的缓存格式。如果没有传入
past_key_values，将返回旧版缓存格式。如果使用
past_key_values，用户可以选择只输入最后的input_ids（那些没有向该模型提供其过去键值状态的词元），形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的input_ids。 - inputs_embeds (
torch.FloatTensor，形状(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想比模型内部的嵌入查找矩阵更好地控制如何将input_ids索引转换为关联向量，这很有用。 - decoder_inputs_embeds (
torch.FloatTensor，形状(batch_size, target_sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递decoder_input_ids。如果使用past_key_values，可以选择只输入最后的decoder_inputs_embeds（参见past_key_values）。如果您想比模型内部的嵌入查找矩阵更好地控制如何将decoder_input_ids索引转换为关联向量，这很有用。如果
decoder_input_ids和decoder_inputs_embeds均未设置，decoder_inputs_embeds将取inputs_embeds的值。 - labels (
torch.LongTensor，形状(batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引应在[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 而不是普通元组。
返回
transformers.models.led.modeling_led.LEDSeq2SeqLMOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.led.modeling_led.LEDSeq2SeqLMOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置（LEDConfig）和输入。
-
loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 语言建模损失。 -
logits (形状为
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 语言建模头部的预测分数（SoftMax 之前的每个词汇标记的分数）。 -
past_key_values (
list[torch.FloatTensor]，可选，当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的torch.FloatTensor列表，每个张量形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含解码器注意力块的预计算隐藏状态（键和值），可用于（参见
past_key_values输入）加速顺序解码。 -
decoder_hidden_states (
tuple[torch.FloatTensor, ...]，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入层输出，如果模型有嵌入层，+ 每个层一个输出）。解码器在每一层输出时的隐藏状态以及初始嵌入输出。
-
decoder_attentions (
tuple[torch.FloatTensor, ...]，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
-
cross_attentions (
tuple[torch.FloatTensor, ...]，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。解码器交叉注意力层的注意力权重，在注意力 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时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入层输出，如果模型有嵌入层，+ 每个层一个输出）。编码器在每一层输出时的隐藏状态以及初始嵌入输出。
-
encoder_attentions (
tuple[torch.FloatTensor, ...]，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
-
encoder_global_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, x)的torch.FloatTensor元组（每层一个），其中x是具有全局注意力掩码的标记数量。经过注意力 softmax 之后的全局注意力权重，用于在自注意力头中计算加权平均值。这些是从每个具有全局注意力的标记到序列中每个标记的注意力权重。
LEDForConditionalGeneration 的 forward 方法重写了 __call__ 特殊方法。
虽然前向传递的逻辑需要在这个函数中定义，但之后应该调用 `Module` 实例而不是这个函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
摘要示例
>>> 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))LEDForSequenceClassification
class transformers.LEDForSequenceClassification
< 来源 >( config: LEDConfig **kwargs )
参数
- config (LEDConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
带有序列分类/头的 LED 模型（在池化输出之上加一个线性层），例如用于 GLUE 任务。
该模型继承自 PreTrainedModel。请查阅超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪注意力头等）。
该模型也是一个 PyTorch torch.nn.Module 的子类。可以像常规的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。
forward
< 来源 >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None global_attention_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.led.modeling_led.LEDSeq2SeqSequenceClassifierOutput 或 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中填充词元的张量。默认情况下也会使用因果掩码。如果您想更改填充行为，应阅读
modeling_led._prepare_decoder_inputs并根据需要进行修改。有关默认策略的更多信息，请参阅论文中的图 1。 - head_mask (
torch.Tensor，形状(num_heads,)或(num_layers, num_heads)，可选) — 用于置零自注意力模块中选定头的掩码。掩码值选自[0, 1]：- 1 表示头未被屏蔽，
- 0 表示头已被屏蔽。
- decoder_head_mask (
torch.Tensor，形状(decoder_layers, decoder_attention_heads)，可选) — 用于置零解码器中注意力模块选定头的掩码。掩码值选自[0, 1]：- 1 表示头未被屏蔽，
- 0 表示头已被屏蔽。
- cross_attn_head_mask (
torch.Tensor，形状(decoder_layers, decoder_attention_heads)，可选) — 用于置零解码器中交叉注意力模块选定头的掩码。掩码值选自[0, 1]：- 1 表示头未被屏蔽，
- 0 表示头已被屏蔽。
- encoder_outputs (
tuple[tuple[torch.FloatTensor]]，可选) — 元组，包含 (last_hidden_state，可选:hidden_states，可选:attentions)。形状为(batch_size, sequence_length, hidden_size)的last_hidden_state（可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。 - global_attention_mask (
torch.FloatTensor，形状(batch_size, sequence_length)，可选) — 用于决定编码器中每个词元是使用局部注意力还是全局注意力的掩码。具有全局注意力的词元会关注所有其他词元，而所有其他词元也会关注它们。这对于特定任务的微调很重要，因为它使模型在表示任务时更灵活。例如，对于分类任务，词元应给予全局注意力。对于问答任务，所有问题词元也应具有全局注意力。更多详情请参阅 Longformer 论文。掩码值选自[0, 1]：- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（关注所有其他词元的词元，并且所有其他词元都关注它们）。
- inputs_embeds (
torch.FloatTensor，形状(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想比模型内部的嵌入查找矩阵更好地控制如何将input_ids索引转换为关联向量，这很有用。 - decoder_inputs_embeds (
torch.FloatTensor，形状(batch_size, target_sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递decoder_input_ids。如果使用past_key_values，可以选择只输入最后的decoder_inputs_embeds（参见past_key_values）。如果您想比模型内部的嵌入查找矩阵更好地控制如何将decoder_input_ids索引转换为关联向量，这很有用。如果
decoder_input_ids和decoder_inputs_embeds均未设置，decoder_inputs_embeds将取inputs_embeds的值。 - labels (
torch.LongTensor，形状(batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels > 1，则计算分类损失（交叉熵）。 - use_cache (
bool，可选) — 如果设置为True，将返回past_key_values键值状态，可用于加速解码（参见past_key_values）。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.models.led.modeling_led.LEDSeq2SeqSequenceClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.led.modeling_led.LEDSeq2SeqSequenceClassifierOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置（LEDConfig）和输入。
-
loss (形状为
(1,)的torch.FloatTensor，可选，当提供label时返回) — 分类 (如果 config.num_labels==1 则为回归) 损失。 -
logits (形状为
(batch_size, config.num_labels)的torch.FloatTensor) — 分类（如果 config.num_labels==1，则为回归）分数（SoftMax 之前）。 -
past_key_values (
list[torch.FloatTensor]，可选，当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的torch.FloatTensor列表，每个张量形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含解码器注意力块的预计算隐藏状态（键和值），可用于（参见
past_key_values输入）加速顺序解码。 -
decoder_hidden_states (
tuple[torch.FloatTensor, ...]，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入层输出，如果模型有嵌入层，+ 每个层一个输出）。解码器在每一层输出时的隐藏状态以及初始嵌入输出。
-
decoder_attentions (
tuple[torch.FloatTensor, ...]，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
-
cross_attentions (
tuple[torch.FloatTensor, ...]，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。解码器交叉注意力层的注意力权重，在注意力 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时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入层输出，如果模型有嵌入层，+ 每个层一个输出）。编码器在每一层输出时的隐藏状态以及初始嵌入输出。
-
encoder_attentions (
tuple[torch.FloatTensor, ...]，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
-
encoder_global_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, x)的torch.FloatTensor元组（每层一个），其中x是具有全局注意力掩码的标记数量。经过注意力 softmax 之后的全局注意力权重，用于在自注意力头中计算加权平均值。这些是从每个具有全局注意力的标记到序列中每个标记的注意力权重。
LEDForSequenceClassification 的 forward 方法重写了 __call__ 特殊方法。
虽然前向传递的逻辑需要在这个函数中定义，但之后应该调用 `Module` 实例而不是这个函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
单标签分类示例
>>> import torch
>>> from transformers import AutoTokenizer, LEDForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> model = LEDForSequenceClassification.from_pretrained("allenai/led-base-16384")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = LEDForSequenceClassification.from_pretrained("allenai/led-base-16384", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...多标签分类示例
>>> import torch
>>> from transformers import AutoTokenizer, LEDForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> model = LEDForSequenceClassification.from_pretrained("allenai/led-base-16384", problem_type="multi_label_classification")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = LEDForSequenceClassification.from_pretrained(
... "allenai/led-base-16384", num_labels=num_labels, problem_type="multi_label_classification"
... )
>>> labels = torch.sum(
... torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).lossLEDForQuestionAnswering
class transformers.LEDForQuestionAnswering
< 来源 >( config )
参数
- config (LEDForQuestionAnswering) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
带有片段分类头的 Led transformer，用于像 SQuAD 这样的抽取式问答任务（在隐藏状态输出之上加一个线性层，以计算 span start logits 和 span end logits）。
该模型继承自 PreTrainedModel。请查阅超类文档以了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪注意力头等）。
该模型也是一个 PyTorch torch.nn.Module 的子类。可以像常规的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。
forward
< 源代码 >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None decoder_input_ids: typing.Optional[torch.LongTensor] = None decoder_attention_mask: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.Tensor] = None decoder_head_mask: typing.Optional[torch.Tensor] = None cross_attn_head_mask: typing.Optional[torch.Tensor] = None encoder_outputs: typing.Optional[tuple[tuple[torch.FloatTensor]]] = None global_attention_mask: typing.Optional[torch.FloatTensor] = None start_positions: typing.Optional[torch.LongTensor] = None end_positions: typing.Optional[torch.LongTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None decoder_inputs_embeds: typing.Optional[torch.FloatTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput 或 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中填充令牌的张量。默认情况下也会使用因果掩码。如果你想改变填充行为，你应该阅读
modeling_led._prepare_decoder_inputs并根据你的需求进行修改。有关默认策略的更多信息，请参阅论文中的图 1。 - head_mask (
torch.Tensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使自注意力模块的选定头无效的掩码。掩码值在[0, 1]中选择：- 1 表示头未被屏蔽，
- 0 表示头被屏蔽。
- decoder_head_mask (
torch.Tensor，形状为(decoder_layers, decoder_attention_heads)，可选) — 用于使解码器中注意力模块的选定头无效的掩码。掩码值在[0, 1]中选择：- 1 表示头未被屏蔽，
- 0 表示头被屏蔽。
- cross_attn_head_mask (
torch.Tensor，形状为(decoder_layers, decoder_attention_heads)，可选) — 用于使解码器中交叉注意力模块的选定头无效的掩码。掩码值在[0, 1]中选择：- 1 表示头未被屏蔽，
- 0 表示头被屏蔽。
- encoder_outputs (
tuple[tuple[torch.FloatTensor]], 可选) — 元组包含 (last_hidden_state, 可选:hidden_states, 可选:attentions)。形状为(batch_size, sequence_length, hidden_size)的last_hidden_state（可选）是编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力机制。 - global_attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 用于决定对每个令牌施加局部注意力还是全局注意力的掩码（用于编码器）。具有全局注意力的令牌会关注所有其他令牌，并且所有其他令牌也会关注它们。这对于特定任务的微调很重要，因为它使模型在表示任务时更灵活。例如，对于分类任务，应给予令牌全局注意力。对于问答任务，所有问题令牌也应具有全局注意力。请参阅 Longformer 论文 以获取更多详细信息。掩码值在[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 而不是一个普通的元组。
返回
transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput 或一个 torch.FloatTensor 的元组（如果传递 return_dict=False 或当 config.return_dict=False），包含根据配置（LEDConfig）和输入而变化的不同元素。
-
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 (
list[torch.FloatTensor]，可选，当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的torch.FloatTensor列表，每个张量形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含解码器注意力块的预计算隐藏状态（键和值），可用于（参见
past_key_values输入）加速顺序解码。 -
decoder_hidden_states (
tuple[torch.FloatTensor, ...]，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入层输出，如果模型有嵌入层，+ 每个层一个输出）。解码器在每一层输出时的隐藏状态以及初始嵌入输出。
-
decoder_attentions (
tuple[torch.FloatTensor, ...]，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
-
cross_attentions (
tuple[torch.FloatTensor, ...]，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。解码器交叉注意力层的注意力权重，在注意力 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时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入层输出，如果模型有嵌入层，+ 每个层一个输出）。编码器在每一层输出时的隐藏状态以及初始嵌入输出。
-
encoder_attentions (
tuple[torch.FloatTensor, ...]，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
-
encoder_global_attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, x)的torch.FloatTensor元组（每层一个），其中x是具有全局注意力掩码的标记数量。经过注意力 softmax 之后的全局注意力权重，用于在自注意力头中计算加权平均值。这些是从每个具有全局注意力的标记到序列中每个标记的注意力权重。
LEDForQuestionAnswering 的前向方法，覆盖了 `__call__` 特殊方法。
虽然前向传递的逻辑需要在这个函数中定义，但之后应该调用 `Module` 实例而不是这个函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> 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)
...TFLEDModel
class transformers.TFLEDModel
< 源代码 >( config *inputs **kwargs )
参数
- config (LEDConfig) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型关联的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
裸 LED 模型，输出原始隐藏状态，顶部没有任何特定的头。此模型继承自 TFPreTrainedModel。请查看超类文档，了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入大小、修剪头等）。
此模型也是 keras.Model 的子类。可以像常规的 TF 2.0 Keras 模型一样使用它，并参考 TF 2.0 文档了解所有与常规用法和行为相关的事项。
transformers 中的 TensorFlow 模型和层接受两种输入格式
- 所有输入作为关键字参数（如 PyTorch 模型），或
- 所有输入作为第一个位置参数中的列表、元组或字典。
支持第二种格式的原因是，Keras 方法在向模型和层传递输入时更喜欢这种格式。由于这种支持，当使用像 model.fit() 这样的方法时，一切都应该“正常工作”——只需以 model.fit() 支持的任何格式传递你的输入和标签！然而，如果你想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional API 创建自己的层或模型时，有三种可能性可以用来将所有输入张量收集到第一个位置参数中。
- 只有一个
input_ids的单个张量，没有其他：model(input_ids) - 长度可变的列表，包含一个或多个输入张量，按文档字符串中给出的顺序：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一个字典，其中包含一个或多个与文档字符串中给出的输入名称关联的输入张量：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，当使用子类化创建模型和层时，你不需要担心这些，因为你可以像传递给任何其他 Python 函数一样传递输入！
调用
< 源代码 >( input_ids: TFModelInputType | None = None attention_mask: tf.Tensor | None = None decoder_input_ids: tf.Tensor | None = None decoder_attention_mask: tf.Tensor | None = None head_mask: tf.Tensor | None = None decoder_head_mask: tf.Tensor | None = None encoder_outputs: tf.Tensor | None = None global_attention_mask: tf.Tensor | None = None past_key_values: tuple[tuple[tf.Tensor]] | None = None inputs_embeds: tf.Tensor | None = None decoder_inputs_embeds: tf.Tensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None training: bool = False **kwargs ) → transformers.models.led.modeling_tf_led.TFLEDSeq2SeqModelOutput 或 tuple(tf.Tensor)
参数
- input_ids (
tf.Tensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列令牌的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
tf.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免在填充令牌索引上执行注意力机制的掩码。掩码值在[0, 1]中选择：- 1 表示令牌未被屏蔽，
- 0 表示令牌被屏蔽。
- decoder_input_ids (
tf.Tensor，形状为(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 (
tf.Tensor，形状为(batch_size, target_sequence_length)，可选) — 默认情况下会创建并忽略填充令牌。在大多数情况下，不建议设置此参数。 - head_mask (
tf.Tensor，形状为(encoder_layers, encoder_attention_heads)，可选) — 用于使编码器中注意力模块的选定头无效的掩码。掩码值在[0, 1]中选择：- 1 表示头未被屏蔽，
- 0 表示头被屏蔽。
- decoder_head_mask (
tf.Tensor，形状为(decoder_layers, decoder_attention_heads)，可选) — 用于使解码器中注意力模块的选定头无效的掩码。掩码值在[0, 1]中选择：- 1 表示头未被屏蔽，
- 0 表示头被屏蔽。
- encoder_outputs (
tf.Tensor, 可选) — 编码器最后一层输出的隐藏状态。用于解码器的交叉注意力。形状为(batch_size, sequence_length, hidden_size)，是隐藏状态的序列。 - past_key_values (
tuple[tuple[tf.Tensor]]，长度为config.n_layers) — 包含预计算的注意力块的键和值隐藏状态。可用于加速解码。如果使用past_key_values，用户可以选择只输入最后一个形状为(batch_size, 1)的decoder_input_ids（那些未将其过去键值状态提供给此模型的），而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。 - use_cache (
bool, 可选, 默认为True) — 如果设置为True，将返回past_key_values键值状态，可用于加速解码（参见past_key_values）。训练时设置为False，生成时设置为True。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - return_dict (
bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。此参数可以在 eager 模式下使用，在 graph 模式下，该值将始终设置为 True。 - training (
bool, 可选, 默认为False) — 是否在训练模式下使用模型（某些模块如 dropout 模块在训练和评估之间有不同的行为）。
返回
transformers.models.led.modeling_tf_led.TFLEDSeq2SeqModelOutput 或 tuple(tf.Tensor)
一个 transformers.models.led.modeling_tf_led.TFLEDSeq2SeqModelOutput 或一个 tf.Tensor 的元组（如果传递 return_dict=False 或当 config.return_dict=False），包含根据配置（LEDConfig）和输入而变化的不同元素。
-
last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的tf.Tensor) — 模型解码器最后一层输出的隐藏状态序列。如果使用了
past_key_values，则只输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。 -
past_key_values (
list[tf.Tensor], 可选，当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含解码器注意力块的预计算隐藏状态（键和值），可用于（参见
past_key_values输入）加速顺序解码。 -
decoder_hidden_states (
tuple(tf.Tensor), 可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入层的输出 + 一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出时的隐藏状态以及初始嵌入输出。
-
decoder_attentions (
tuple(tf.Tensor), 可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
-
cross_attentions (
tuple(tf.Tensor), 可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均。
-
encoder_last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的tf.Tensor, 可选) — 模型编码器最后一层输出的隐藏状态序列。 -
encoder_hidden_states (
tuple(tf.Tensor), 可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入层的输出 + 一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出时的隐藏状态以及初始嵌入输出。
-
encoder_attentions (
tuple(tf.Tensor), 可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
-
encoder_global_attentions (
tuple(tf.Tensor), 可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的令牌数量。经过注意力 softmax 之后的全局注意力权重，用于在自注意力头中计算加权平均值。这些是从每个具有全局注意力的标记到序列中每个标记的注意力权重。
TFLEDModel 的前向方法，覆盖了 `__call__` 特殊方法。
虽然前向传递的逻辑需要在这个函数中定义，但之后应该调用 `Module` 实例而不是这个函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFLEDModel
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> model = TFLEDModel.from_pretrained("allenai/led-base-16384")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)
>>> last_hidden_states = outputs.last_hidden_stateTFLEDForConditionalGeneration
class transformers.TFLEDForConditionalGeneration
< 源代码 >( config *inputs **kwargs )
参数
- config (LEDConfig) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型关联的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
带语言模型头的 LED 模型。可用于摘要任务。此模型继承自 TFPreTrainedModel。请查看超类文档，了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入大小、修剪头等）。
此模型也是 keras.Model 的子类。可以像常规的 TF 2.0 Keras 模型一样使用它，并参考 TF 2.0 文档了解所有与常规用法和行为相关的事项。
transformers 中的 TensorFlow 模型和层接受两种输入格式
- 所有输入作为关键字参数（如 PyTorch 模型），或
- 所有输入作为第一个位置参数中的列表、元组或字典。
支持第二种格式的原因是，Keras 方法在向模型和层传递输入时更喜欢这种格式。由于这种支持，当使用像 model.fit() 这样的方法时，一切都应该“正常工作”——只需以 model.fit() 支持的任何格式传递你的输入和标签！然而，如果你想在 Keras 方法（如 fit() 和 predict()）之外使用第二种格式，例如在使用 Keras Functional API 创建自己的层或模型时，有三种可能性可以用来将所有输入张量收集到第一个位置参数中。
- 只有一个
input_ids的单个张量，没有其他：model(input_ids) - 长度可变的列表，包含一个或多个输入张量，按文档字符串中给出的顺序：
model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids]) - 一个字典，其中包含一个或多个与文档字符串中给出的输入名称关联的输入张量：
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意，当使用子类化创建模型和层时，你不需要担心这些，因为你可以像传递给任何其他 Python 函数一样传递输入！
调用
< 源代码 >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None decoder_input_ids: np.ndarray | tf.Tensor | None = None decoder_attention_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None decoder_head_mask: np.ndarray | tf.Tensor | None = None encoder_outputs: TFLEDEncoderBaseModelOutput | None = None global_attention_mask: np.ndarray | tf.Tensor | None = None past_key_values: tuple[tuple[Union[np.ndarray, tf.Tensor]]] | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None decoder_inputs_embeds: np.ndarray | tf.Tensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None labels: tf.Tensor | None = None training: bool = False ) → transformers.models.led.modeling_tf_led.TFLEDSeq2SeqLMOutput 或 tuple(tf.Tensor)
参数
- input_ids (
tf.Tensor，形状为({0})) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
tf.Tensor，形状为({0}), 可选) — 用于避免在填充标记索引上执行注意力操作的掩码。掩码值在[0, 1]中选择：- 1 表示标记未被掩码,
- 0 表示标记被掩码。
- decoder_input_ids (
tf.Tensor，形状为(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 (
tf.Tensor，形状为(batch_size, target_sequence_length), 可选) — 默认情况下会创建并忽略填充标记。在大多数用例中不建议设置此项。 - head_mask (
tf.Tensor，形状为(encoder_layers, encoder_attention_heads), 可选) — 用于置零编码器中注意力模块选定头的掩码。掩码值在[0, 1]中选择：- 1 表示头未被掩码,
- 0 表示头被掩码。
- decoder_head_mask (
tf.Tensor，形状为(decoder_layers, decoder_attention_heads), 可选) — 用于置零解码器中注意力模块选定头的掩码。掩码值在[0, 1]中选择：- 1 表示头未被掩码,
- 0 表示头被掩码。
- encoder_outputs (
tf.Tensor, 可选) — 编码器最后一层输出的隐藏状态序列。用于解码器的交叉注意力。形状为(batch_size, sequence_length, hidden_size)。 - past_key_values (
tuple[tuple[tf.Tensor]]，长度为config.n_layers) — 包含预先计算的注意力块的键和值隐藏状态。可用于加速解码。如果使用past_key_values，用户可以选择只输入形状为(batch_size, 1)的最后decoder_input_ids（那些没有提供其过去键值状态给此模型的），而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。 - use_cache (
bool, 可选，默认为True) — 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。训练时设置为False，生成时设置为True。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。此参数只能在即时模式下使用，在图模式下将使用配置中的值。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。此参数只能在即时模式下使用，在图模式下将使用配置中的值。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。此参数可在即时模式下使用，在图模式下该值将始终设置为 True。 - training (
bool, 可选，默认为False) — 是否在训练模式下使用模型（某些模块如 dropout 在训练和评估之间有不同的行为）。
返回
transformers.models.led.modeling_tf_led.TFLEDSeq2SeqLMOutput 或 tuple(tf.Tensor)
一个 transformers.models.led.modeling_tf_led.TFLEDSeq2SeqLMOutput 或一个 tf.Tensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），根据配置（LEDConfig）和输入包含各种元素。
-
loss (
tf.Tensor，形状为(1,), 可选，当提供labels时返回) — 语言建模损失。 -
logits (
tf.Tensorof shape(batch_size, sequence_length, config.vocab_size)) — 语言模型头部的预测分数（SoftMax 之前每个词汇标记的分数）。 -
past_key_values (
list[tf.Tensor], 可选，当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含解码器注意力块的预计算隐藏状态（键和值），可用于（参见
past_key_values输入）加速顺序解码。 -
decoder_hidden_states (
tuple(tf.Tensor), 可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入层的输出 + 一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出时的隐藏状态以及初始嵌入输出。
-
decoder_attentions (
tuple(tf.Tensor), 可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
-
cross_attentions (
tuple(tf.Tensor), 可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均。
-
encoder_last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的tf.Tensor, 可选) — 模型编码器最后一层输出的隐藏状态序列。 -
encoder_hidden_states (
tuple(tf.Tensor), 可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入层的输出 + 一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出时的隐藏状态以及初始嵌入输出。
-
encoder_attentions (
tuple(tf.Tensor), 可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。
-
encoder_global_attentions (
tuple(tf.Tensor), 可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的令牌数量。经过注意力 softmax 之后的全局注意力权重，用于在自注意力头中计算加权平均值。这些是从每个具有全局注意力的标记到序列中每个标记的注意力权重。
TFLEDForConditionalGeneration 的前向方法，覆盖了 __call__ 特殊方法。
虽然前向传递的逻辑需要在这个函数中定义，但之后应该调用 `Module` 实例而不是这个函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFLEDForConditionalGeneration
>>> import tensorflow as tf
>>> mname = "allenai/led-base-16384"
>>> tokenizer = AutoTokenizer.from_pretrained(mname)
>>> TXT = "My friends are <mask> but they eat too many carbs."
>>> model = TFLEDForConditionalGeneration.from_pretrained(mname)
>>> batch = tokenizer([TXT], return_tensors="tf")
>>> logits = model(inputs=batch.input_ids).logits
>>> probs = tf.nn.softmax(logits[0])
>>> # probs[5] is associated with the mask token