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的倍数。因此，当 LEDTokenizer 与pad_to_multiple_of参数一起使用时，可以获得小幅的速度提升。 - LED 通过
global_attention_mask（参见 LongformerModel）使用全局注意力。对于摘要，建议仅将全局注意力放在第一个<s>token 上。对于问答，建议将全局注意力放在问题的所有 token 上。 - 为了在所有 16384 个 LED 上微调模型，如果训练导致内存不足 (OOM) 错误，可以启用梯度检查点。这可以通过执行
model.gradient_checkpointing_enable()来完成。此外，可以使用use_cache=False标志来禁用缓存机制以节省内存。 - LED 模型采用绝对位置嵌入，因此通常建议在右侧而不是左侧填充输入。
此模型由 patrickvonplaten 贡献。
资源
LEDConfig
class transformers.LEDConfig
< source >( 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[typing.List[int], int] = 512 **kwargs )
参数
- vocab_size (
int, optional, defaults to 50265) — LED 模型的词汇表大小。定义了在调用 LEDModel 或 TFLEDModel 时传递的inputs_ids可以表示的不同 token 的数量。 - d_model (
int, optional, defaults to 1024) — 层和 pooler 层的维度。 - encoder_layers (
int, optional, defaults to 12) — Encoder 层的数量。 - decoder_layers (
int, optional, defaults to 12) — Decoder 层的数量。 - encoder_attention_heads (
int, optional, defaults to 16) — Transformer encoder 中每个 attention 层的 attention head 数量。 - decoder_attention_heads (
int, optional, defaults to 16) — Transformer decoder 中每个 attention 层的 attention head 数量。 - decoder_ffn_dim (
int, optional, defaults to 4096) — decoder 中“中间”（通常称为 feed-forward）层的维度。 - encoder_ffn_dim (
int, optional, defaults to 4096) — encoder 中“中间”（通常称为 feed-forward）层的维度。 - activation_function (
strorfunction, optional, defaults to"gelu") — encoder 和 pooler 中的非线性激活函数（函数或字符串）。如果为字符串，则支持"gelu"、"relu"、"silu"和"gelu_new"。 - dropout (
float, optional, defaults to 0.1) — embeddings、encoder 和 pooler 中所有全连接层的 dropout 概率。 - attention_dropout (
float, optional, defaults to 0.0) — attention 概率的 dropout 比率。 - activation_dropout (
float, optional, defaults to 0.0) — 全连接层内部激活的 dropout 比率。 - classifier_dropout (
float, optional, defaults to 0.0) — classifier 的 dropout 比率。 - max_encoder_position_embeddings (
int, optional, defaults to 16384) — encoder 可能使用的最大序列长度。 - max_decoder_position_embeddings (
int, optional, defaults to 16384) — decoder 可能使用的最大序列长度。 - init_std (
float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - encoder_layerdrop (
float, optional, defaults to 0.0) — encoder 的 LayerDrop 概率。 有关更多详细信息，请参阅 [LayerDrop 论文](https://arxiv.org/abs/1909.11556)。 - decoder_layerdrop (
float, optional, defaults to 0.0) — decoder 的 LayerDrop 概率。 有关更多详细信息，请参阅 [LayerDrop 论文](https://arxiv.org/abs/1909.11556)。 - use_cache (
bool, optional, defaults toTrue) — 模型是否应返回上次的 key/values attention（并非所有模型都使用）。
这是用于存储 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, 可选, 默认为"replace") — 将字节解码为 UTF-8 时遵循的范例。有关更多信息，请参阅 bytes.decode。 - bos_token (
str, 可选, 默认为"<s>") — 预训练期间使用的序列开始标记。可以用作序列分类器标记。当使用特殊标记构建序列时，这不是用于序列开始的标记。使用的标记是
cls_token。 - eos_token (
str, 可选, 默认为"</s>") — 序列结束标记。当使用特殊标记构建序列时，这不是用于序列结束的标记。使用的标记是
sep_token。 - sep_token (
str, 可选, 默认为"</s>") — 分隔符标记，用于从多个序列构建序列时，例如用于序列分类的两个序列，或用于问答的文本和问题。它也用作使用特殊标记构建的序列的最后一个标记。 - cls_token (
str, 可选, 默认为"<s>") — 分类器标记，用于进行序列分类（对整个序列而不是每个标记进行分类）。当使用特殊标记构建序列时，它是序列的第一个标记。 - unk_token (
str, 可选, 默认为"<unk>") — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。 - pad_token (
str, 可选, 默认为"<pad>") — 用于填充的标记，例如在批量处理不同长度的序列时。 - mask_token (
str, 可选, 默认为"<mask>") — 用于掩盖值的标记。这是使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。 - add_prefix_space (
bool, 可选, 默认为False) — 是否在输入中添加初始空格。这允许将句首单词视为与任何其他单词相同。（BART tokenizer 通过前导空格检测单词的开头）。
构建 LED tokenizer，它类似于 ROBERTa tokenizer，使用字节级 Byte-Pair-Encoding。
此 tokenizer 经过训练，可以将空格视为标记的一部分（有点像 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]您可以通过在实例化此 tokenizer 或在某些文本上调用它时传递 add_prefix_space=True 来绕过此行为，但由于模型不是以这种方式预训练的，因此可能会导致性能下降。
当与 is_split_into_words=True 一起使用时，此 tokenizer 将在每个单词（甚至是第一个单词）之前添加一个空格。
此 tokenizer 继承自 PreTrainedTokenizer，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
build_inputs_with_special_tokens
< source >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → List[int]
通过连接并添加特殊标记，从序列或序列对构建模型输入，以用于序列分类任务。 LED 序列具有以下格式
- 单个序列：
<s> X </s> - 序列对：
<s> A </s></s> B </s>
get_special_tokens_mask
< source >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None already_has_special_tokens: bool = False ) → List[int]
从没有添加特殊标记的标记列表中检索序列 ID。当使用 tokenizer prepare_for_model 方法添加特殊标记时，将调用此方法。
create_token_type_ids_from_sequences
< source >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.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) — merges 文件的路径。 - errors (
str, optional, defaults to"replace") — 将字节解码为 UTF-8 时遵循的范例。 有关更多信息，请参阅 bytes.decode。 - bos_token (
str, optional, defaults to"<s>") — 序列开始 (beginning of sequence) 标记，在预训练期间使用。 可以用作序列分类器标记。当使用特殊标记构建序列时，这不是用于序列开始的标记。 使用的标记是
cls_token。 - eos_token (
str, optional, defaults to"</s>") — 序列结束 (end of sequence) 标记。当使用特殊标记构建序列时，这不是用于序列结束的标记。 使用的标记是
sep_token。 - sep_token (
str, optional, defaults to"</s>") — 分隔符标记，用于从多个序列构建序列时，例如用于序列分类的两个序列，或者用于问答的文本和问题。 它也用作使用特殊标记构建的序列的最后一个标记。 - cls_token (
str, optional, defaults to"<s>") — 分类器标记，用于进行序列分类（对整个序列而不是每个标记进行分类）。 当使用特殊标记构建时，它是序列的第一个标记。 - unk_token (
str, optional, defaults to"<unk>") — 未知标记。 词汇表中没有的标记无法转换为 ID，而是设置为此标记。 - pad_token (
str, optional, defaults to"<pad>") — 用于填充的标记，例如在对不同长度的序列进行批处理时。 - mask_token (
str, optional, defaults to"<mask>") — 用于掩码值的标记。 这是使用掩码语言建模训练此模型时使用的标记。 这是模型将尝试预测的标记。 - add_prefix_space (
bool, optional, defaults toFalse) — 是否在输入前添加初始空格。 这允许像处理任何其他单词一样处理前导词。（LED 分词器通过前面的空格检测单词的开头）。 - trim_offsets (
bool, optional, defaults toTrue) — 后处理步骤是否应修剪偏移量以避免包含空格。
构建一个“快速” LED 分词器（由 HuggingFace 的 tokenizers 库支持），它源自 GPT-2 分词器，使用字节级字节对编码 (Byte-Pair-Encoding)。
此 tokenizer 经过训练，可以将空格视为标记的一部分（有点像 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]您可以通过在实例化此 tokenizer 或在某些文本上调用它时传递 add_prefix_space=True 来绕过此行为，但由于模型不是以这种方式预训练的，因此可能会导致性能下降。
当与 is_split_into_words=True 一起使用时，此分词器需要使用 add_prefix_space=True 实例化。
此分词器继承自 PreTrainedTokenizerFast，其中包含大多数主要方法。 用户应参考此超类以获取有关这些方法的更多信息。
create_token_type_ids_from_sequences
< source >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → List[int]
从传递的两个序列创建一个掩码，用于序列对分类任务。 LED 不使用标记类型 ID，因此返回零列表。
LED 特定的输出
class transformers.models.led.modeling_led.LEDEncoderBaseModelOutput
< source >( last_hidden_state: FloatTensor hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None global_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )
参数
- last_hidden_state (
torch.FloatTensorof shape(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出的隐藏状态序列。 - hidden_states (
tuple(torch.FloatTensor), optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) —torch.FloatTensor的元组（每个层的输出，加上嵌入层的输出各一个），形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的隐藏状态，加上初始嵌入输出。
- attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)，其中x是具有全局注意力掩码的标记数。注意力 softmax 之后的局部注意力权重，用于计算自注意力头中的加权平均值。 这些是从序列中的每个标记到每个具有全局注意力的标记（前
x个值）以及到注意力窗口中的每个标记（剩余的attention_window- 1
个值）的注意力权重。 请注意，前x个值指的是文本中位置固定的标记，但剩余的attention_window + 1个值指的是具有相对位置的标记：标记自身注意力权重位于索引x + attention_window / 2，而attention_window / 2个前导（后继）值是到attention_window / 2个前导（后继）标记的注意力权重。 如果注意力窗口包含具有全局注意力的标记，则相应索引处的注意力权重设置为 0； 该值应从前x个注意力权重访问。 如果标记具有全局注意力，则attentions中所有其他标记的注意力权重设置为 0，值应从global_attentions` 访问。
- 1
- global_attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) —torch.FloatTensor的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数。注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。 这些是从每个具有全局注意力的标记到序列中每个标记的注意力权重。
LEDEncoder 输出的基类，具有潜在的隐藏状态、局部和全局注意力。
class transformers.models.led.modeling_led.LEDSeq2SeqModelOutput
< source >( last_hidden_state: FloatTensor = None past_key_values: typing.Optional[typing.List[torch.FloatTensor]] = None decoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_global_attentions: typing.Optional[typing.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, returned whenuse_cache=Trueis passed or whenconfig.use_cache=True) —torch.FloatTensor列表，长度为config.n_layers，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含解码器的预计算隐藏状态（注意力块中的键和值），可以用于（请参阅
past_key_values输入）加速顺序解码。 - decoder_hidden_states (
tuple(torch.FloatTensor), optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) —torch.FloatTensor的元组（每个层输出一个，外加初始嵌入输出），形状为(batch_size, sequence_length, hidden_size)。解码器在每一层输出的隐藏状态，加上初始嵌入输出。
- decoder_attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组 (每层一个)。解码器的注意力权重，在 attention softmax 之后，用于计算自注意力头中的加权平均值。
- cross_attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组 (每层一个)。解码器交叉注意力层的注意力权重，在 attention softmax 之后，用于计算交叉注意力头中的加权平均值。
- encoder_last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor, 可选) — 模型编码器最后一层的输出隐藏状态序列。 - encoder_hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(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元组 (每层一个)。编码器的注意力权重，在 attention softmax 之后，用于计算自注意力头中的加权平均值。
- encoder_global_attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, x)的torch.FloatTensor元组 (每层一个)，其中x是具有全局注意力掩码的 token 数量。全局注意力权重，在 attention softmax 之后，用于计算自注意力头中的加权平均值。 这些是从每个具有全局注意力的 token 到序列中每个 token 的注意力权重。
模型编码器输出的基类，也包含：预先计算的隐藏状态，可以加速顺序解码。
class transformers.models.led.modeling_led.LEDSeq2SeqLMOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None logits: FloatTensor = None past_key_values: typing.Optional[typing.List[torch.FloatTensor]] = None decoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_global_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )
参数
- loss (形状为
(1,)的torch.FloatTensor, 可选, 当提供labels时返回) — 语言建模损失。 - logits (形状为
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 语言建模头的预测分数（SoftMax 之前的每个词汇 token 的分数）。 - 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元组 (每层一个)。解码器的注意力权重，在 attention softmax 之后，用于计算自注意力头中的加权平均值。
- cross_attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组 (每层一个)。解码器交叉注意力层的注意力权重，在 attention softmax 之后，用于计算交叉注意力头中的加权平均值。
- encoder_last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor, 可选) — 模型编码器最后一层的输出隐藏状态序列。 - encoder_hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(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元组 (每层一个)。编码器的注意力权重，在 attention softmax 之后，用于计算自注意力头中的加权平均值。
- encoder_global_attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, x)的torch.FloatTensor元组 (每层一个)，其中x是具有全局注意力掩码的 token 数量。全局注意力权重，在 attention softmax 之后，用于计算自注意力头中的加权平均值。 这些是从每个具有全局注意力的 token 到序列中每个 token 的注意力权重。
序列到序列语言模型输出的基类。
class transformers.models.led.modeling_led.LEDSeq2SeqSequenceClassifierOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None logits: FloatTensor = None past_key_values: typing.Optional[typing.List[torch.FloatTensor]] = None decoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_global_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )
参数
- 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 (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor, 可选) — 模型编码器最后一层的输出的隐藏状态序列。 - 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是具有全局注意力掩码的 token 数量。全局注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。 这些是从每个具有全局注意力的 token 到序列中每个 token 的注意力权重。
序列到序列句子分类模型输出的基类。
class transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None start_logits: FloatTensor = None end_logits: FloatTensor = None past_key_values: typing.Optional[typing.List[torch.FloatTensor]] = None decoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None decoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None cross_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_last_hidden_state: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None encoder_global_attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )
参数
- loss (形状为
(1,)的torch.FloatTensor, 可选, 当提供labels时返回) — 总跨度抽取损失是起始和结束位置的交叉熵损失之和。 - start_logits (形状为
(batch_size, sequence_length)的torch.FloatTensor) — 跨度开始得分 (SoftMax 之前)。 - end_logits (形状为
(batch_size, sequence_length)的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 (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor, 可选) — 模型编码器最后一层的输出的隐藏状态序列。 - 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是具有全局注意力掩码的 token 数量。全局注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。 这些是从每个具有全局注意力的 token 到序列中每个 token 的注意力权重。
序列到序列问答模型输出的基类。
class transformers.models.led.modeling_tf_led.TFLEDEncoderBaseModelOutput
< source >( last_hidden_state: 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 (形状为
(batch_size, sequence_length, hidden_size)的tf.Tensor) — 模型最后一层的输出的隐藏状态序列。 - hidden_states (
tuple(tf.Tensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor的元组 (每个层的输出对应一个，加上嵌入层的输出)。模型在每一层输出的隐藏状态，加上初始嵌入输出。
- attentions (
tuple(tf.Tensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)的tf.Tensor的元组 (每个层对应一个)，其中x是具有全局注意力掩码的 token 数量。局部注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。 这些是从序列中每个 token 到每个具有全局注意力的 token（前
x个值）以及到注意力窗口中的每个 token（剩余的attention_window1个值）的注意力权重。 请注意，前x个值指的是文本中具有固定位置的 token，但剩余的attention_window + 1个值指的是具有相对位置的 token：token 自身到自身的注意力权重位于索引x + attention_window / 2处，并且attention_window / 2个前导（后继）值是到attention_window / 2个前导（后继）token 的注意力权重。 如果注意力窗口包含具有全局注意力的 token，则相应索引处的注意力权重设置为 0；该值应从前x个注意力权重中访问。 如果 token 具有全局注意力，则attentions中到所有其他 token 的注意力权重都设置为 0，这些值应从global_attentions中访问。
- global_attentions (
tuple(tf.Tensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — 由形状为(batch_size, num_heads, sequence_length, x)的tf.Tensor组成的元组（每层一个），其中x是具有全局注意力掩码的标记数。注意力 softmax 之后的全局注意力权重，用于计算自注意力头中的加权平均值。 这些是从每个具有全局注意力的标记到序列中每个标记的注意力权重。
Longformer 输出的基类，具有潜在的隐藏状态、局部和全局注意力。
class transformers.models.led.modeling_tf_led.TFLEDSeq2SeqModelOutput
< source >( last_hidden_state: 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: 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 模块，并参阅 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[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None global_attention_mask: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[typing.Tuple[typing.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.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)的torch.LongTensor) — 词汇表中输入序列标记的索引。 如果您提供填充，默认情况下将忽略填充。可以使用 AutoTokenizer 获取索引。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
(batch_size, sequence_length)的torch.Tensor，可选) — 用于避免在 padding 标记索引上执行 attention 的掩码。 掩码值在[0, 1]中选择：- 1 表示标记未被掩盖，
- 0 表示标记被掩盖。
- decoder_input_ids (形状为
(batch_size, target_sequence_length)的torch.LongTensor，可选) — 词汇表中解码器输入序列标记的索引。可以使用
LedTokenizer获取索引。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。LED 使用
eos_token_id作为decoder_input_ids生成的起始标记。 如果使用past_key_values，则可以选择仅输入最后的decoder_input_ids（请参阅past_key_values）。 - decoder_attention_mask (形状为
(batch_size, target_sequence_length)的torch.LongTensor，可选) — 默认行为：生成一个张量，该张量忽略decoder_input_ids中的 pad 标记。 默认情况下，也会使用因果掩码。如果您想更改填充行为，则应阅读
modeling_led._prepare_decoder_inputs并根据您的需要进行修改。 有关默认策略的更多信息，请参见 论文 中的图 1。 - global_attention_mask (形状为
(batch_size, sequence_length)的torch.FloatTensor，可选) — 用于决定每个标记的 attention 类型（编码器的局部 attention 或全局 attention）的掩码。 具有全局 attention 的标记会关注所有其他标记，而所有其他标记也会关注它们。 这对于特定于任务的微调非常重要，因为它使模型在表示任务时更灵活。 例如，对于分类，应为标记赋予全局 attention。 对于问答，所有问题标记也应具有全局 attention。 有关更多详细信息，请参阅 Longformer 论文。 掩码值在[0, 1]中选择：- 0 表示局部 attention（滑动窗口 attention），
- 1 表示全局 attention（关注所有其他标记以及所有其他标记关注它们的标记）。
- head_mask (形状为
(encoder_layers, encoder_attention_heads)的torch.Tensor，可选) — 用于使编码器中 attention 模块的选定头部无效的掩码。 掩码值在[0, 1]中选择：- 1 表示头部未被掩盖，
- 0 表示头部被掩盖。
- decoder_head_mask (形状为
(decoder_layers, decoder_attention_heads)的torch.Tensor，可选) — 用于使解码器中 attention 模块的选定头部无效的掩码。 掩码值在[0, 1]中选择：- 1 表示头部未被掩盖，
- 0 表示头部被掩盖。
- cross_attn_head_mask (形状为
(decoder_layers, decoder_attention_heads)的torch.Tensor，可选) — 用于使解码器中 cross-attention 模块的选定头部无效的掩码。 掩码值在[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，可选) 是编码器最后一层输出端的隐藏状态序列。 在解码器的 cross-attention 中使用。 - past_key_values (
tuple(tuple(torch.FloatTensor)), 可选，当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(tuple(torch.FloatTensor))元组，每个元组包含 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)) 的张量和 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的附加张量。包含预先计算的隐藏状态（自 attention 块和 cross-attention 块中的键和值），这些状态可用于（请参阅
past_key_values输入）加速顺序解码。如果使用
past_key_values，则用户可以选择仅输入最后的decoder_input_ids（那些没有将其过去的键值状态提供给此模型的decoder_input_ids），形状为(batch_size, 1)，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。 - inputs_embeds (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选) — （可选）您可以选择直接传递嵌入表示，而不是传递input_ids。 如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将input_ids索引转换为关联的向量，这将非常有用。 - decoder_inputs_embeds (形状为
(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor，可选) — （可选）您可以选择直接传递嵌入表示，而不是传递decoder_input_ids。 如果使用past_key_values，则可以选择仅输入最后的decoder_inputs_embeds（请参阅past_key_values）。 如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将decoder_input_ids索引转换为关联的向量，这将非常有用。如果
decoder_input_ids和decoder_inputs_embeds均未设置，则decoder_inputs_embeds采用inputs_embeds的值。 - use_cache (
bool，可选) — 如果设置为True，则返回past_key_values键值状态，并且可用于加速解码（请参阅past_key_values）。 - output_attentions (
bool，可选) — 是否返回所有 attention 层的 attention 张量。 有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Seq2SeqModelOutput 或 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含取决于配置 (LEDConfig) 和输入的各种元素。
-
last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor) — 模型解码器最后一层输出端的隐藏状态序列。如果使用
past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。 -
past_key_values (
tuple(tuple(torch.FloatTensor)), 可选，当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(tuple(torch.FloatTensor))元组，每个元组包含 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)) 的张量和 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的附加张量。包含预先计算的隐藏状态（自 attention 块和 cross-attention 块中的键和值），这些状态可用于（请参阅
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)。解码器的 attention 权重，在 attention softmax 之后，用于计算自 attention 头中的加权平均值。
-
cross_attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的 cross-attention 层的 attention 权重，在 attention softmax 之后，用于计算 cross-attention 头中的加权平均值。
-
encoder_last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor, 可选) — 模型编码器最后一层输出端的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), 可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入输出提供一个，+ 为每一层的输出提供一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出端的隐藏状态加上可选的初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) —torch.FloatTensor的元组 (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
The LEDModel forward 方法，重写了 __call__ 特殊方法。
尽管前向传递的步骤需要在该函数中定义，但应该在之后调用 Module 实例而不是直接调用此函数，因为前者会处理预处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, LEDModel
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384")
>>> model = LEDModel.from_pretrained("allenai/led-base-16384")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_stateLEDForConditionalGeneration
类 transformers.LEDForConditionalGeneration
< 源代码 >( config: LEDConfig )
参数
- config (LEDConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。请查看 from_pretrained() 方法来加载模型权重。
带有语言建模头的 LED 模型。可用于文本摘要。此模型继承自 PreTrainedModel。有关库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等），请参阅超类文档。
此模型也是 PyTorch torch.nn.Module 子类。可将其用作常规 PyTorch 模块，并参阅 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[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None global_attention_mask: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[typing.Tuple[typing.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.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。如果您提供 padding，默认情况下将被忽略。可以使用 AutoTokenizer 获取索引。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length), 可选) — 用于避免在 padding token 索引上执行注意力的掩码。掩码值在[0, 1]中选择：- 1 表示 tokens 未被掩盖，
- 0 表示 tokens 已被掩盖。
- decoder_input_ids (
torch.LongTensor，形状为(batch_size, target_sequence_length), 可选) — 词汇表中解码器输入序列 tokens 的索引。可以使用
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中的 pad tokens。因果掩码也将默认使用。如果您想更改 padding 行为，您应该阅读
modeling_led._prepare_decoder_inputs并根据您的需求进行修改。有关默认策略的更多信息，请参阅 论文 中的图 1。 - global_attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length), 可选) — 用于决定每个 token 注意力类型的掩码，编码器的局部注意力或全局注意力。具有全局注意力的 Token 会关注所有其他 token，并且所有其他 token 也会关注它们。这对于特定任务的微调非常重要，因为它使模型在表示任务时更灵活。例如，对于分类，应为token 提供全局注意力。对于 QA，所有问题 token 也应具有全局注意力。有关更多详细信息，请参阅 Longformer 论文。掩码值在[0, 1]中选择：- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（关注所有其他 token 的 token，以及所有其他 token 关注它们）。
- head_mask (
torch.Tensor，形状为(encoder_layers, encoder_attention_heads), 可选) — 用于 nullify 编码器中注意力模块的选定 head 的掩码。掩码值在[0, 1]中选择：- 1 表示 head 未被掩盖，
- 0 表示 head 已被掩盖。
- decoder_head_mask (
torch.Tensor，形状为(decoder_layers, decoder_attention_heads), 可选) — 用于 nullify 解码器中注意力模块的选定 head 的掩码。掩码值在[0, 1]中选择：- 1 表示 head 未被掩盖，
- 0 表示 head 已被掩盖。
- cross_attn_head_mask (
torch.Tensor，形状为(decoder_layers, decoder_attention_heads), 可选) — 用于 nullify 解码器中交叉注意力模块的选定 head 的掩码。掩码值在[0, 1]中选择：- 1 表示 head 未被掩盖，
- 0 表示 head 已被掩盖。
- encoder_outputs (
tuple(tuple(torch.FloatTensor), 可选) — 元组由 (last_hidden_state, 可选:hidden_states, 可选:attentions) 组成last_hidden_state的形状为(batch_size, sequence_length, hidden_size), 可选) 是编码器最后一层输出的隐藏状态序列。在解码器的交叉注意力中使用。 - past_key_values (
tuple(tuple(torch.FloatTensor)), 可选, 当传递use_cache=True或config.use_cache=True时返回) —tuple(torch.FloatTensor)的元组，长度为config.n_layers，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的附加张量。包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可以用于（请参阅
past_key_values输入）加速顺序解码。如果使用
past_key_values，用户可以选择仅输入最后一个decoder_input_ids（那些没有将其过去的键值状态提供给此模型的），形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的decoder_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 而不是普通元组。 - labels (
torch.LongTensor，形状为(batch_size, sequence_length), 可选) — 用于计算掩码语言建模损失的标签。索引应为[0, ..., config.vocab_size]或 -100（请参阅input_ids文档字符串）。索引设置为-100的 tokens 将被忽略（掩码），损失仅针对标签在[0, ..., config.vocab_size]中的 tokens 计算。
返回
transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Seq2SeqLMOutput 或 torch.FloatTensor 元组（如果传递 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (LEDConfig) 和输入。
-
loss (
torch.FloatTensor，形状为(1,), 可选, 当提供labels时返回) — 语言建模损失。 -
logits (
torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇 token 的分数）。 -
past_key_values (
tuple(tuple(torch.FloatTensor)), 可选，当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(tuple(torch.FloatTensor))元组，每个元组包含 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)) 的张量和 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的附加张量。包含预先计算的隐藏状态（自 attention 块和 cross-attention 块中的键和值），这些状态可用于（请参阅
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)。解码器的 attention 权重，在 attention softmax 之后，用于计算自 attention 头中的加权平均值。
-
cross_attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的 cross-attention 层的 attention 权重，在 attention softmax 之后，用于计算 cross-attention 头中的加权平均值。
-
encoder_last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor, 可选) — 模型编码器最后一层输出端的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), 可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入输出提供一个，+ 为每一层的输出提供一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出的隐藏状态加上初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) —torch.FloatTensor的元组 (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
The LEDForConditionalGeneration forward 方法，重写了 __call__ 特殊方法。
尽管前向传递的步骤需要在该函数中定义，但应该在之后调用 Module 实例而不是直接调用此函数，因为前者会处理预处理和后处理步骤，而后者会静默地忽略它们。
条件生成示例
>>> 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))摘要示例
>>> 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))LEDForSequenceClassification
类 transformers.LEDForSequenceClassification
< source >( config: LEDConfig **kwargs )
参数
- config (LEDConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。
LED 模型，顶部带有一个序列分类/头（池化输出顶部的线性层），例如用于 GLUE 任务。
此模型继承自 PreTrainedModel。有关库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等），请参阅超类文档。
此模型也是 PyTorch torch.nn.Module 子类。可将其用作常规 PyTorch 模块，并参阅 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[typing.Tuple[typing.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.modeling_outputs.Seq2SeqSequenceClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)的torch.LongTensor) — 词汇表中输入序列标记的索引。默认情况下，如果您提供填充，则会忽略填充。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
(batch_size, sequence_length)的torch.Tensor, 可选) — 掩码，以避免在填充标记索引上执行注意力机制。掩码值在[0, 1]中选择：- 1 表示标记未被掩盖，
- 0 表示标记被掩盖。
- decoder_input_ids (形状为
(batch_size, target_sequence_length)的torch.LongTensor, 可选) — 词汇表中解码器输入序列标记的索引。索引可以使用
LedTokenizer获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。LED 使用
eos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则可以选择仅输入最后的decoder_input_ids（参见past_key_values）。 - decoder_attention_mask (形状为
(batch_size, target_sequence_length)的torch.LongTensor, 可选) — 默认行为：生成一个张量，该张量忽略decoder_input_ids中的 pad 标记。默认情况下，也会使用因果掩码。如果您想更改填充行为，则应阅读
modeling_led._prepare_decoder_inputs并根据您的需要进行修改。有关默认策略的更多信息，请参见 论文 中的图 1。 - global_attention_mask (形状为
(batch_size, sequence_length)的torch.FloatTensor, 可选) — 掩码，用于决定编码器上每个标记的注意力、局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，而所有其他标记也会关注它们。这对于特定于任务的微调非常重要，因为它使模型在表示任务时更加灵活。例如，对于分类，应为标记赋予全局注意力。对于问答，所有问题标记也应具有全局注意力。有关更多详细信息，请参阅 Longformer 论文。掩码值在[0, 1]中选择：- 0 表示局部注意力（滑动窗口注意力），
- 1 表示全局注意力（关注所有其他标记的标记，以及所有其他标记关注它们的标记）。
- head_mask (形状为
(encoder_layers, encoder_attention_heads)的torch.Tensor, 可选) — 掩码，用于使编码器中注意力模块的选定头无效。掩码值在[0, 1]中选择：- 1 表示头未被掩盖，
- 0 表示头被掩盖。
- decoder_head_mask (形状为
(decoder_layers, decoder_attention_heads)的torch.Tensor, 可选) — 掩码，用于使解码器中注意力模块的选定头无效。掩码值在[0, 1]中选择：- 1 表示头未被掩盖，
- 0 表示头被掩盖。
- cross_attn_head_mask (形状为
(decoder_layers, decoder_attention_heads)的torch.Tensor, 可选) — 掩码，用于使解码器中交叉注意力模块的选定头无效。掩码值在[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, 可选) 是编码器最后一层的输出处的隐藏状态序列。用于解码器的交叉注意力。 - past_key_values (
tuple(tuple(torch.FloatTensor)), 可选, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组具有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量）和 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的附加张量。包含预先计算的隐藏状态（自注意力模块和交叉注意力模块中的键和值），可用于（请参阅
past_key_values输入）加速顺序解码。如果使用
past_key_values，则用户可以选择仅输入最后的decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。 - inputs_embeds (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor, 可选) — （可选）您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望比模型的内部嵌入查找矩阵更好地控制如何将input_ids索引转换为关联的向量，这将非常有用。 - decoder_inputs_embeds (形状为
(batch_size, target_sequence_length, hidden_size)的torch.FloatTensor, 可选) — （可选）您可以选择直接传递嵌入表示，而不是传递decoder_input_ids。如果使用past_key_values，则可以选择仅输入最后的decoder_inputs_embeds（参见past_key_values）。如果您希望比模型的内部嵌入查找矩阵更好地控制如何将decoder_input_ids索引转换为关联的向量，这将非常有用。如果
decoder_input_ids和decoder_inputs_embeds均未设置，则decoder_inputs_embeds采用inputs_embeds的值。 - use_cache (
bool, 可选) — 如果设置为True，则返回past_key_values键值状态，并且可以用于加速解码（请参阅past_key_values）。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回的张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有图层的隐藏状态。有关更多详细信息，请参见返回的张量下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 - labels (形状为
(batch_size,)的torch.LongTensor, 可选) — 用于计算序列分类/回归损失的标签。索引应为[0, ..., config.num_labels - 1]。如果config.num_labels > 1，则计算分类损失（交叉熵）。
返回
transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (LEDConfig) 和输入。
-
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 (
tuple(tuple(torch.FloatTensor)), 可选，当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(tuple(torch.FloatTensor))元组，每个元组包含 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)) 的张量和 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的附加张量。包含预先计算的隐藏状态（自 attention 块和 cross-attention 块中的键和值），这些状态可用于（请参阅
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)。解码器的 attention 权重，在 attention softmax 之后，用于计算自 attention 头中的加权平均值。
-
cross_attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的 cross-attention 层的 attention 权重，在 attention softmax 之后，用于计算 cross-attention 头中的加权平均值。
-
encoder_last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor, 可选) — 模型编码器最后一层输出端的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), 可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入输出提供一个，+ 为每一层的输出提供一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出的隐藏状态加上初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) —torch.FloatTensor的元组 (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 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()
>>> # 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多标签分类示例
>>> 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
< source >( config )
参数
- config (LEDConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。
LED 模型，顶部带有一个跨度分类头，用于抽取式问答任务，例如 SQuAD（在 hidden-states 输出之上有一个线性层来计算 span start logits 和 span end logits）。
此模型继承自 PreTrainedModel。有关库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等），请参阅超类文档。
此模型也是 PyTorch torch.nn.Module 子类。可将其用作常规 PyTorch 模块，并参阅 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[typing.Tuple[typing.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.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。如果您提供 padding，默认情况下将被忽略。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 掩码，用于避免在 padding token 索引上执行 attention。掩码值在[0, 1]中选择：- 1 表示 tokens 未被掩盖，
- 0 表示 tokens 被掩盖。
- decoder_input_ids (
torch.LongTensor，形状为(batch_size, target_sequence_length)，可选) — 词汇表中解码器输入序列 tokens 的索引。索引可以使用
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)，可选) — 默认行为：生成一个 tensor，忽略decoder_input_ids中的 pad tokens。默认情况下，还将使用因果掩码。如果您想更改 padding 行为，您应该阅读
modeling_led._prepare_decoder_inputs并根据您的需要进行修改。有关默认策略的更多信息，请参阅 论文 中的图 1。 - global_attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 掩码，用于决定 encoder 上每个 token 的 attention 类型，是局部 attention 还是全局 attention。具有全局 attention 的 tokens 会关注所有其他 tokens，并且所有其他 tokens 也会关注它们。这对于特定任务的微调非常重要，因为它使模型在表示任务时更加灵活。例如，对于分类，应为token 提供全局 attention。对于问答，所有问题 tokens 也应具有全局 attention。有关更多详细信息，请参阅 Longformer 论文。掩码值在[0, 1]中选择：- 0 表示局部 attention（滑动窗口 attention），
- 1 表示全局 attention（关注所有其他 tokens 的 tokens，以及所有其他 tokens 关注它们的 tokens）。
- head_mask (
torch.Tensor，形状为(encoder_layers, encoder_attention_heads)，可选) — 掩码，用于使 encoder 中 attention 模块的选定 head 失效。掩码值在[0, 1]中选择：- 1 表示 head 未被掩盖，
- 0 表示 head 被掩盖。
- decoder_head_mask (
torch.Tensor，形状为(decoder_layers, decoder_attention_heads)，可选) — 掩码，用于使 decoder 中 attention 模块的选定 head 失效。掩码值在[0, 1]中选择：- 1 表示 head 未被掩盖，
- 0 表示 head 被掩盖。
- cross_attn_head_mask (
torch.Tensor，形状为(decoder_layers, decoder_attention_heads)，可选) — 掩码，用于使 decoder 中 cross-attention 模块的选定 head 失效。掩码值在[0, 1]中选择：- 1 表示 head 未被掩盖，
- 0 表示 head 被掩盖。
- encoder_outputs (
tuple(tuple(torch.FloatTensor)，可选) — 元组由 (last_hidden_state，可选:hidden_states，可选:attentions) 组成。last_hidden_state的形状为(batch_size, sequence_length, hidden_size)，可选) 是 encoder 最后一层的输出端的 hidden-states 序列。在 decoder 的 cross-attention 中使用。 - past_key_values (
tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)元组，其中每个元组具有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的 tensors 和 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的附加 tensors。包含预先计算的 hidden-states（self-attention 块和 cross-attention 块中的 key 和 values），可以用于（请参阅
past_key_values输入）加速顺序解码。如果使用
past_key_values，则用户可以选择仅输入最后一个decoder_input_ids（那些没有将其过去的 key value states 提供给此模型的）形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的decoder_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_valueskey value states，并且可以用于加速解码（请参阅past_key_values）。 - output_attentions (
bool，可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息，请参阅返回的 tensors 下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参阅返回的 tensors 下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。 - start_positions (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算 token 分类损失的已标记跨度开始位置（索引）的标签。位置被限制在序列的长度（sequence_length）内。序列之外的位置不计入损失计算。 - end_positions (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算 token 分类损失的已标记跨度结束位置（索引）的标签。位置被限制在序列的长度（sequence_length）内。序列之外的位置不计入损失计算。
返回
transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (LEDConfig) 和输入。
-
loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 总跨度抽取损失是开始和结束位置的交叉熵损失之和。 -
start_logits (
torch.FloatTensor，形状为(batch_size, sequence_length)) — 跨度开始得分（在 SoftMax 之前）。 -
end_logits (
torch.FloatTensor，形状为(batch_size, sequence_length)) — 跨度结束得分（在 SoftMax 之前）。 -
past_key_values (
tuple(tuple(torch.FloatTensor)), 可选，当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(tuple(torch.FloatTensor))元组，每个元组包含 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)) 的张量和 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的附加张量。包含预先计算的隐藏状态（自 attention 块和 cross-attention 块中的键和值），这些状态可用于（请参阅
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)。解码器的 attention 权重，在 attention softmax 之后，用于计算自 attention 头中的加权平均值。
-
cross_attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或config.output_attentions=True时返回) —torch.FloatTensor元组（每一层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的 cross-attention 层的 attention 权重，在 attention softmax 之后，用于计算 cross-attention 头中的加权平均值。
-
encoder_last_hidden_state (形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor, 可选) — 模型编码器最后一层输出端的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor), 可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —torch.FloatTensor元组（如果模型具有嵌入层，则为嵌入输出提供一个，+ 为每一层的输出提供一个），形状为(batch_size, sequence_length, hidden_size)。编码器在每一层输出的隐藏状态加上初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) —torch.FloatTensor的元组 (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
LEDForQuestionAnswering 的 forward 方法，覆盖了 __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]
>>> # 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.lossTFLEDModel
类 transformers.TFLEDModel
< source >( config *inputs **kwargs )
参数
- config (LEDConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
裸 LED 模型，输出原始隐藏状态，顶部没有任何特定的 head。此模型继承自 TFPreTrainedModel。查看超类文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。
此模型也是 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 函数一样传递输入！
call
< source >( 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)) — 词汇表中输入序列 token 的索引。可以使用 AutoTokenizer 获得索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
tf.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。Mask 值在[0, 1]中选择：- 1 表示 token 未被 mask，
- 0 表示 token 已被 mask。
- decoder_input_ids (
tf.Tensor，形状为(batch_size, target_sequence_length)，可选) — 词汇表中 decoder 输入序列 token 的索引。可以使用
LedTokenizer获得索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。LED 使用
eos_token_id作为decoder_input_ids生成的起始 token。如果使用past_key_values，则可以选择仅输入最后的decoder_input_ids（那些没有将其过去 key value 状态提供给此模型的decoder_input_ids）（请参阅past_key_values）。 - decoder_attention_mask (
tf.Tensor，形状为(batch_size, target_sequence_length)，可选) — 默认情况下会生成，并忽略 pad token。不建议在大多数用例中设置此项。 - head_mask (
tf.Tensor，形状为(encoder_layers, encoder_attention_heads)，可选) — 用于 nullify encoder 中 attention 模块的选定 head 的 Mask。Mask 值在[0, 1]中选择：- 1 表示 head 未被 mask，
- 0 表示 head 已被 mask。
- decoder_head_mask (
tf.Tensor，形状为(decoder_layers, decoder_attention_heads)，可选) — 用于 nullify decoder 中 attention 模块的选定 head 的 Mask。Mask 值在[0, 1]中选择：- 1 表示 head 未被 mask，
- 0 表示 head 已被 mask。
- encoder_outputs (
tf.Tensor，可选) — encoder 最后一层的输出的隐藏状态。用于 decoder 的 cross-attention 中。形状为(batch_size, sequence_length, hidden_size)是一个序列 - past_key_values (
Tuple[Tuple[tf.Tensor]]，长度为config.n_layers) — 包含 attention 模块的预计算 key 和 value 隐藏状态。可用于加速解码。如果使用past_key_values，则用户可以选择仅输入最后的decoder_input_ids（那些没有将其过去 key value 状态提供给此模型的decoder_input_ids），形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。 - use_cache (
bool，可选，默认为True) — 如果设置为True，则返回past_key_valueskey value 状态，并且可用于加速解码（请参阅past_key_values）。在训练期间设置为False，在生成期间设置为True - output_attentions (
bool，可选) — 是否返回所有 attention 层的 attention 张量。有关更多详细信息，请参阅返回张量下的attentions。此参数只能在 eager 模式下使用，在 graph 模式下将使用 config 中的值。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数只能在 eager 模式下使用，在 graph 模式下将使用 config 中的值。 - 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 (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型 decoder 最后一层输出的隐藏状态序列。如果使用
past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。 -
past_key_values (
List[tf.Tensor]，可选，当传递use_cache=True或当config.use_cache=True时返回) —tf.Tensor列表，长度为config.n_layers，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含 decoder 的预计算隐藏状态（attention 模块中的 key 和 value），可用于加速顺序解码（请参阅
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)。解码器的 attention 权重，在 attention softmax 之后，用于计算自 attention 头中的加权平均值。
-
cross_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的 cross-attention 层的 attention 权重，在 attention softmax 之后，用于计算 cross-attention 头中的加权平均值。
-
encoder_last_hidden_state (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型 encoder 最后一层输出的隐藏状态序列。 -
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是具有 global attention mask 的 token 数量。attention softmax 之后的 Global attention 权重，用于计算 self-attention head 中的加权平均值。这些是从每个具有 global attention 的 token 到序列中每个 token 的 attention 权重。
TFLEDModel forward 方法，覆盖了 __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
类 transformers.TFLEDForConditionalGeneration
< source >( 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 函数一样传递输入！
call
< source >( 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 (形状为
({0})的tf.Tensor) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
({0})的tf.Tensor, 可选) — 用于避免在 padding 标记索引上执行 attention 的掩码。掩码值在[0, 1]中选择：- 1 表示标记未被掩盖，
- 0 表示标记被掩盖。
- decoder_input_ids (形状为
(batch_size, target_sequence_length)的tf.Tensor, 可选) — 词汇表中解码器输入序列标记的索引。可以使用
LedTokenizer获取索引。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。LED 使用
eos_token_id作为decoder_input_ids生成的起始标记。如果使用past_key_values，则可以选择仅输入最后的decoder_input_ids（请参阅past_key_values）。 - decoder_attention_mask (形状为
(batch_size, target_sequence_length)的tf.Tensor, 可选) — 默认情况下将创建并将忽略 pad 标记。不建议在大多数用例中设置此项。 - head_mask (形状为
(encoder_layers, encoder_attention_heads)的tf.Tensor, 可选) — 用于使编码器中 attention 模块的选定 head 失效的掩码。掩码值在[0, 1]中选择：- 1 表示 head 未被掩盖，
- 0 表示 head 被掩盖。
- decoder_head_mask (形状为
(decoder_layers, decoder_attention_heads)的tf.Tensor, 可选) — 用于使解码器中 attention 模块的选定 head 失效的掩码。掩码值在[0, 1]中选择：- 1 表示 head 未被掩盖，
- 0 表示 head 被掩盖。
- encoder_outputs (
tf.Tensor, 可选) — 编码器最后一层的输出的隐藏状态。用于解码器的交叉 attention。形状为(batch_size, sequence_length, hidden_size)的序列是 - past_key_values (长度为
config.n_layers的Tuple[Tuple[tf.Tensor]]) — 包含 attention 块的预先计算的键和值隐藏状态。可用于加速解码。如果使用past_key_values，则用户可以选择仅输入最后的decoder_input_ids（那些没有将其过去的键值状态提供给此模型的输入），形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。 - use_cache (
bool, 可选, 默认为True) — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（请参阅past_key_values）。在训练期间设置为False，在生成期间设置为True - output_attentions (
bool, 可选) — 是否返回所有 attention 层的 attention 张量。 有关更多详细信息，请参阅返回的张量下的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.TFLEDSeq2SeqLMOutput 或 tuple(tf.Tensor)
一个 transformers.models.led.modeling_tf_led.TFLEDSeq2SeqLMOutput 或一个 tf.Tensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (LEDConfig) 和输入。
-
loss (形状为
(1,)的tf.Tensor, 可选, 当提供labels时返回) — 语言建模损失。 -
logits (形状为
(batch_size, sequence_length, config.vocab_size)的tf.Tensor) — 语言建模头的预测得分（SoftMax 之前每个词汇表标记的得分）。 -
past_key_values (
List[tf.Tensor]，可选，当传递use_cache=True或当config.use_cache=True时返回) —tf.Tensor列表，长度为config.n_layers，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head))。包含 decoder 的预计算隐藏状态（attention 模块中的 key 和 value），可用于加速顺序解码（请参阅
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)。解码器的 attention 权重，在 attention softmax 之后，用于计算自 attention 头中的加权平均值。
-
cross_attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器的 cross-attention 层的 attention 权重，在 attention softmax 之后，用于计算 cross-attention 头中的加权平均值。
-
encoder_last_hidden_state (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型 encoder 最后一层输出的隐藏状态序列。 -
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是具有 global attention mask 的 token 数量。attention softmax 之后的 Global attention 权重，用于计算 self-attention head 中的加权平均值。这些是从每个具有 global attention 的 token 到序列中每个 token 的 attention 权重。
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