LED
概述
LED模型由Iz Beltagy、Matthew E. Peters和Arman Cohan在《Longformer: The Long-Document Transformer》中提出。
论文的摘要如下
由于自注意力操作的二次扩展特性，基于转换器的模型无法处理长序列。为了解决这个限制，我们引入了Longformer，其注意力机制线性扩展随序列长度，因此可以轻松处理数以千计的令牌甚至更长的文档。Longformer的注意力机制是标准自注意力的直接替代，结合了局部窗注意力与任务驱动的全局注意力。在先前关于长序列转换器的工作基础上，我们在字符级语言模型中对Longformer进行了评估，在text8和enwik8上实现了最先进的成果。与大多数先前的工作相反，我们还对Longformer进行了预训练，并在各种下游任务上进行微调。我们的预训练Longformer在长文档任务上始终优于RoBERTa，并在WikiHop和TriviaQA上设立了新的最先进的结果。最后，我们介绍了Longformer-Encoder-Decoder (LED)，这是一种用于支持长文档生成型序列到序列任务的Longformer变体，并在arXiv总结数据集上证明了其有效性。
使用提示
- LEDForConditionalGeneration是BartForConditionalGeneration的扩展，它将传统的self-attention层替换成了Longformer的chunked self-attention层。LEDTokenizer是BartTokenizer的别名。
- LED在处理超1024个令牌的长距离sequence-to-sequence任务上表现良好。
- 如果需要，LED会对
input_ids进行填充，使其成为config.attention_window的倍数。因此，当使用带有pad_to_multiple_of参数的LEDTokenizer时，可以从中获得较小的速度提升。 - LED通过
global_attention_mask利用全局注意力（请参阅LongformerModel）。对于摘要任务，建议只在第一个<s>令牌上使用全局注意力。对于问答任务，建议在问题的所有令牌上使用全局注意力。 - 要微调LED的16384个参数，如果训练导致内存不足（OOM）错误，可以启用梯度检查点。这可以通过执行
model.gradient_checkpointing_enable()来完成。此外，可以使用use_cache=False标志来禁用缓存机制以节省内存。 - LED是一个具有绝对位置嵌入的模型，因此通常建议将输入填充在右侧而不是左侧。
该模型由patrickvonplaten贡献。
资源
LEDConfig
类 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: Union = 512 **kwargs )
参数
- vocab_size (
int, 可选项, 默认为50265) — LED模型的词汇量大小。定义了在调用LEDModel或TFLEDModel时可通过inputs_ids传入的不同令牌数量。 - d_model (
int, 可选项, 默认为1024) — 层数和池化层的维度。 - encoder_layers (
int, 可选项, 默认为12) — 编码层数量。 - decoder_layers （
int，可选，默认为12）— 解码器层数量。 - encoder_attention_heads （
int，可选，默认为16）— 变换编码器中每个注意力层中注意力头的数量。 - decoder_attention_heads （
int，可选，默认为16）— 变换解码器中每个注意力层中注意力头的数量。 - 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论文](see https://arxiv.org/abs/1909.11556)。 - decoder_layerdrop (
浮点数，可选，默认为 0.0) — 解码器层的 LayerDrop 概率。有关更多详细信息，请参阅[LayerDrop 论文](see https://arxiv.org/abs/1909.11556)。 - use_cache (
布尔值，可选，默认为True）— 是否模型应返回最后一个 key/values 注意力（可能不是所有模型都使用）
这是一个配置类，用于存储 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
类 transformers.LEDTokenizer
< 来源 >( 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 (
str, 可选, 默认为"</s>") — 分隔符标记，当从多个序列构建序列时使用，例如，用于序列分类或问答时文本和问题的两个序列。它还用作由特殊标记构建的序列的最后一个标记。 - cls_token (
str, 可选, 默认为"<s>") — 用于序列分类的类别标记（与按单词分类相比，对整个序列进行分类）。当使用特殊标记构建序列时，它是序列的第一个标记。 - unk_token (字符串, 可选, 默认值为
"<unk>") — 未知标记。不在词汇表中的标记无法转换为 ID，并将其设置为该标记。 - pad_token (字符串, 可选, 默认值为
"<pad>") — 用于填充的标记，例如在不同长度的序列批处理时。 - mask_token (字符串, 可选, 默认值为
"<mask>") — 用于遮蔽值的标记。这是在训练加遮蔽语言模型时使用的标记。这是模型将尝试预测的标记。 - add_prefix_space (
bool, 可选, 默认为False) — 是否在输入前添加一个初始空格。这允许将首词视为其他词。 (BART 分词器通过前一个空格来检测单词的开头)。
使用字节级别的Byte-Pair-Encoding构建与ROBERTa分词器相似的超LED分词器。
此分词器被训练为将空格视为标记的一部分（有点类似于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
< 来源 >( token_ids_0: 列表 token_ids_1: 可选 = None ) → 列表[int]
通过连接并添加特殊标记来从序列或序列对构建用于序列分类任务的模型输入。LED序列具有以下格式：
- 单个序列：
<s> X </s> - 序列对：
<s> A </s></s> B </s>
get_special_tokens_mask
< source >( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → List[int]
从未添加特殊标记的标记列表中检索序列ID。此方法在添加特殊标记时使用prepare_for_model方法调用。
create_token_type_ids_from_sequences
< source >( token_ids_0: 列表 token_ids_1: 可选 = None ) → 列表[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，可选，默认为"replace"）— 解码字节到UTF-8时遵循的范式。更多信息，请参阅 bytes.decode。 - bos_token （
str，可选，默认为"<s>"）— 预训练期间使用的序列起始标记。可以作为序列分类标记使用。在构建使用特殊标记的序列时，这不是序列起始使用的标记。使用的标记是
cls_token。 - eos_token （
str，可选，默认为"</s>"）— 序列结束标记。在构建使用特殊标记的序列时，这不是序列结束使用的标记。使用的标记是
sep_token。 - sep_token (字符串，可选，默认为
"</s>") — 用于从多个序列构建序列时的分隔符，例如用于序列分类的两个序列或用于问答问题时一个文本和一个问题。它也是用特殊标记构建的序列的最后一个标记。 - cls_token (字符串，可选，默认为
"<s>") — 用于序列分类（分类整个序列而不是按标记分类）。当使用特殊标记构建序列时，它是序列的第一个标记。 - unk_token (字符串，可选，默认为
"<unk>") — 未知标记。不在词汇表中的标记无法转换为ID，并将其设置为这个标记。 - pad_token (
str, 可选，默认为"<pad>") — 用于填充的标记，例如当批量处理不同长度的序列时。 - mask_token (
str, 可选，默认为"<mask>") — 用于遮蔽值的标记。这是在用遮蔽语言建模训练此模型时使用的标记。这是模型将要尝试预测的标记。 - add_prefix_space (
bool, 可选，默认为False) — 是否向输入添加一个初始空格。这允许将首单词视为与其他单词相同。（LED标记器通过前一个空格检测单词的开始）。 - trim_offsets （
bool，可选，默认为True） — 是否应该在后处理步骤中切掉偏移量以避免包含空格。
使用字节级Byte-Pair-Encoding构建一个“快速”LED标记器（由HuggingFace的tokenizers库支持），它是从GPT-2标记器派生出来的。
此分词器被训练为将空格视为标记的一部分（有点类似于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: 列表 token_ids_1: 可选 = None ) → 列表[int]
从传入的两个序列创建一个掩码，用于序列对分类任务。LED 不使用标记类型 ID，因此返回零列表。
LED特定的输出
类 transformers.models.led.modeling_led.LEDEncoderBaseModelOutput
< source >( last_hidden_state: FloatTensor hidden_states: 可选 = None attentions: 可选 = None global_attentions: 可选 = None )
参数
- last_hidden_state （
torch.FloatTensor形状为(batch_size, sequence_length, hidden_size)） — 模型最后一层输出的 hidden-states 序列。 - hidden_states （
tuple(torch.FloatTensor)，可选，在传递output_hidden_states=True或当config.output_hidden_states=True时返回） — 一个形为torch.FloatTensor的元组（一个用于嵌入层的输出，一个用于每个层的输出，形状为(batch_size, sequence_length, hidden_size)）。模型每个层输出的 hidden-states 以及初始嵌入层的输出。
- attentions (
tuple(torch.FloatTensor), 可选，在传递了output_attentions=True或当config.output_attentions=True时返回) — 一个形状为(batch_size, num_heads, sequence_length, x + attention_window + 1)}的torch.FloatTensor的元组（对于每个层），其中x是具有全局注意力掩码的标记数量。 - global_attentions (
tuple(torch.FloatTensor), 可选，在传递了output_attentions=True或当config.output_attentions=True时返回) — 一个形状为(batch_size, num_heads, sequence_length, x)的torch.FloatTensor的元组（对于每个层），其中x是具有全局注意力掩码的标记数量。
LEDEncoder输出的基类，具有潜在隐藏状态、局部和全局注意力。
class transformers.models.led.modeling_led.LEDSeq2SeqModelOutput
< 源代码 >( last_hidden_state: FloatTensor = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None encoder_global_attentions: Optional = None )
参数
- last_hidden_state (
torch.FloatTensor的大小为(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层输出的隐藏序列。如果使用了
past_key_values，则输出序列的最后一个隐藏状态，形状为(batch_size, 1, hidden_size)。 - past_key_values (
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 (
torch.FloatTensor元组，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入输出，一个用于每层的输出）。 每层输出的隐藏状态以及初始嵌入输出。 - decoder_attentions (
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时返回) — 一个torch.FloatTensor元组（每个层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。 解码器的交叉注意力层的注意力权重，在注意力softmax之后使用，用于在交叉注意力头中进行加权求平均。 - encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出的隐藏状态序列。 - encoder_hidden_states (
tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 一个torch.FloatTensor元组（包含嵌入输出加上每一层的输出），形状为(batch_size, sequence_length, hidden_size)。 每一层的编码器的隐藏状态输出，以及初始嵌入输出。 - encoder_attentions (
tuple(torch.FloatTensor), 可选，当传递了output_attentions=True或当config.output_attentions=True时返回) — 一个torch.FloatTensor的元组（每个层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器注意力权重，在注意力softmax之后使用，用于自注意力头中的加权平均。
- encoder_global_attentions (
tuple(torch.FloatTensor), 可选，当传递了output_attentions=True或当config.output_attentions=True时返回) — 一个torch.FloatTensor的元组（每个层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的令牌数量。全局注意力权重，在注意力softmax之后使用，用于自注意力头中的加权平均。这些是从带有全局注意力的每个令牌到序列中每个令牌的注意力权重。
模型编码器输出基类，还包含：预计算的隐藏状态，可以加快序列解码。
class transformers.models.led.modeling_led.LEDSeq2SeqLMOutput
< source >( loss: Optional = None logits: FloatTensor = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None encoder_global_attentions: Optional = 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时返回）— 包含嵌入输出和每个层的输出的形状为(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后的注意力权重，用于计算自注意力头中的加权平均。 - 交叉注意力 (
tuple(torch.FloatTensor)，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 由torch.FloatTensor组成的元组（每个层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。解码器交叉注意力层在注意力softmax后的注意力权重，用于在交叉注意力头中计算加权平均值。
- encoder_last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的隐藏状态序列。 - encoder_hidden_states (
tuple(torch.FloatTensor)，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 由torch.FloatTensor组成的元组（包括词嵌入输出的输出 + 每个层的输出），形状为(batch_size, sequence_length, hidden_size)。编码器在每层输出的隐藏状态以及初始嵌入输出。
- encoder_attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或者当config.output_attentions=True时返回) — 由torch.FloatTensor组成的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力权重，在编码器中经过注意力softmax运算后，用于在自注意力头中计算加权平均。 - encoder_global_attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或者当config.output_attentions=True时返回) — 由torch.FloatTensor组成的元组（每层一个），形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数量。全局注意力权重，在注意力softmax运算后用于按照自注意力头中计算加权平均。这是来自具有全局注意力的每个标记到序列中每个标记的注意力权重。
序列到序列语言模型输出的基础类。
类 transformers.models.led.modeling_led.LEDSeq2SeqSequenceClassifierOutput
< source >( loss: Optional = None logits: FloatTensor = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None encoder_global_attentions: Optional = None )
参数
- loss (
torch.FloatTensorof shape(1,), optional, returned whenlabelis provided) — 分类（或配置中num_labels为1时的回归）损失。 - logits (
torch.FloatTensorof shape(batch_size, config.num_labels)) — 分类（或配置中的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), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — Tuple oftorch.FloatTensor(one for each layer) of shape(batch_size, num_heads, sequence_length, sequence_length).解码器注意力权重，在注意力softmax后使用，以计算self-attention头中的加权平均值。
- cross_attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — Tuple oftorch.FloatTensor(one for each layer) of shape(batch_size, num_heads, sequence_length, sequence_length).解码器交叉注意力层在注意力softmax后的注意力权重，用于计算交叉注意力头中的加权平均值。
- encoder_last_hidden_state (
torch.FloatTensorof shape(batch_size, sequence_length, hidden_size), optional) — 模型编码器最后一层输出的隐藏状态序列。 - 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元组（每个层一个）。 - encoder_global_attentions (
tuple(torch.FloatTensor), 可选, 当通过output_attentions=True或config.output_attentions=True传递时返回) — 形状为(batch_size, num_heads, sequence_length, x)的torch.FloatTensor元组（每个层一个），其中x是具有全局注意力掩码的令牌数。
序列到序列句子分类模型输出的基类。
类 transformers.models.led.modeling_led.LEDSeq2SeqQuestionAnsweringModelOutput
< 源 >( loss: Optional = None start_logits: FloatTensor = None end_logits: FloatTensor = None past_key_values: Optional = None decoder_hidden_states: Optional = None decoder_attentions: Optional = None cross_attentions: Optional = None encoder_last_hidden_state: Optional = None encoder_hidden_states: Optional = None encoder_attentions: Optional = None encoder_global_attentions: Optional = None )
参数
- loss (
torch.FloatTensorof shape(1,), optional, returned whenlabelsis provided) — 提取总跨度损失是起始位置和结束位置的交叉熵的和。 - start_logits (
torch.FloatTensorof shape(batch_size, sequence_length)) — 边界开始得分（SoftMax之前）。 - end_logits (
torch.FloatTensorof shape(batch_size, sequence_length)) — 边界结束得分（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)）。 - cross_attentions (
tuple(torch.FloatTensor)，可选，当传入output_attentions=True或config.output_attentions=True时返回) — 一个包含每一层torch.FloatTensor的元组（形状为(batch_size, num_heads, sequence_length, sequence_length)），用于计算交叉注意力层的注意力权重。 - encoder_last_hidden_state （一个形状为
(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）—— 模型编码器最后一层输出处的隐藏状态序列。 - encoder_hidden_states （一个返回值，形状为
tuple(torch.FloatTensor)，可选，当传递了output_hidden_states=True或config.output_hidden_states=True时返回）—— 一个包含torch.FloatTensor的元组（一个用于词嵌入的输出，一个用于每个层的输出）的形状为(batch_size, sequence_length, hidden_size)。编码器在每个层输出的隐藏状态以及初始嵌入输出。
- encoder_attentions （一个返回值，形状为
tuple(torch.FloatTensor)，可选，当传递了output_attentions=True或config.output_attentions=True时返回）—— 一个包含每个层的torch.FloatTensor的元组，形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力软化后用于在自注意力头中计算加权平均。
- encoder_global_attentions (
tuple(torch.FloatTensor), 可选，当传递output_attentions=True或当config.output_attentions=True时返回) — 根据每个层的torch.FloatTensor元组（每个层一个）的形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数。
序列到序列问答模型输出的基类。
类 transformers.models.led.modeling_tf_led.TFLEDEncoderBaseModelOutput
< 源码 >( 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 （
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), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — Tuple oftf.Tensor(one for each layer) of shape(batch_size, num_heads, sequence_length, x + attention_window + 1), wherexis the number of tokens with global attention mask.Local attentions weights after the attention softmax, used to compute the weighted average in the self-attention heads. Those are the attention weights from every token in the sequence to every token with global attention (first
xvalues) and to every token in the attention window (remaining `attention_window- 1
values). Note that the firstxvalues refer to tokens with fixed positions in the text, but the remainingattention_window + 1values refer to tokens with relative positions: the attention weight of a token to itself is located at indexx + attention_window / 2and theattention_window / 2preceding (succeeding) values are the attention weights to theattention_window / 2preceding (succeeding) tokens. If the attention window contains a token with global attention, the attention weight at the corresponding index is set to 0; the value should be accessed from the firstxattention weights. If a token has global attention, the attention weights to all other tokens inattentionsis set to 0, the values should be accessed fromglobal_attentions`.
- 1
- global_attentions (
tuple(tf.Tensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — Tuple oftf.Tensor(one for each layer) of shape(batch_size, num_heads, sequence_length, x), wherexis the number of tokens with global attention mask.Global attentions weights after the attention softmax, used to compute the weighted average in the self-attention heads. Those are the attention weights from every token with global attention to every token in the sequence.
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.Tensorof shape(batch_size, sequence_length, hidden_size)) — 模型解码器最后一层输出的隐藏状态序列。如果使用
past_key_values，则只输出序列形状为(batch_size, 1, hidden_size)的最后隐藏状态。 - past_key_values (
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 (
tf.Tensor元组，可选，当传入output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于词嵌入输出的输出，一个用于每层输出的输出）。 每层解码器输出的隐藏状态以及初始嵌入输出。 - decoder_attentions (
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时返回) — 包含每个层的tf.Tensor的元组 (形状为(batch_size, num_heads, sequence_length, sequence_length))。 - 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时返回) — 包含每个层输出（嵌入输出 + 每层输出）的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)。 - encoder_global_attentions (
tuple(tf.Tensor), 可选的) — 当传递代码 (output_attentions=True) 或配置 (config.output_attentions=True) 时返回。元组包含每个层的tf.Tensor，形状为(batch_size, num_heads, sequence_length, x)，其中x是带有全局注意力掩码的标记数量。
模型编码器输出基类，还包含：预计算的隐藏状态，可以加快序列解码。
类 transformers.models.led.modeling_tf_led.TFLEDSeq2SeqLMOutput
< 源代码 >( 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列表，每个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 (
tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选） — 模型编码器最后一个层输出的隐藏状态序列。 - 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是具有全局注意力掩码的token的数目。全局注意力权重，在注意力softmax后，用于自我注意力头中的加权平均。这些是从有全局注意力的每个token到序列中每个token的注意力权重。
序列到序列语言模型输出的基础类。
LEDModel
类 transformers.LEDModel
< source >( config: LEDConfig )
参数
- config (LEDConfig) — 模型配置类，包含模型的全部参数。使用配置文件初始化时，不会加载与模型关联的权重，仅加载配置。查看from_pretrained()方法以加载模型权重。
裸LED模型，输出原始隐藏状态，未在顶部添加任何特定层。该模型继承自PreTrainedModel。有关该库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入大小、修剪头等）的文档，请参阅超类文档。
此模型也是PyTorch torch.nn.Module的子类。将其作为常规PyTorch模块使用，并参考PyTorch文档以获取一般使用和行为。
forward
< source >( input_ids: 可选 = None attention_mask: 可选 = None decoder_input_ids: 可选 = None decoder_attention_mask: 可选 = None head_mask: 可选 = None decoder_head_mask: 可选 = None cross_attn_head_mask: 可选 = None encoder_outputs: 可选 = None global_attention_mask: 可选 = None past_key_values: 可选 = None inputs_embeds: 可选 = None decoder_inputs_embeds: 可选 = None use_cache: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None ) → transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensorof shape(batch_size, sequence_length)) — 语料库中输入序列标记的索引。如果提供，默认会忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask （形状为
(batch_size, sequence_length)的torch.Tensor，可选）— 避免对填充token索引执行注意力操作。选择在[0, 1]范围内的掩码值：- 1 表示 未掩码 token，
- 0 表示 掩码 token。
- decoder_input_ids （形状为
(batch_size, target_sequence_length)的torch.LongTensor，可选）— 解码器输入序列token在词汇表中的索引。可以使用
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 （形状为
(batch_size, target_sequence_length)的torch.LongTensor，可选） — 默认行为：生成一个忽略decoder_input_ids中的填充token的tensor。默认还将使用因果mask。如果想要改变填充行为，应阅读modeling_led._prepare_decoder_inputs并根据您的需求进行修改。更多信息请参阅论文中的图1。 - global_attention_mask （形状为
(batch_size, sequence_length)的torch.FloatTensor，可选） — 用于决定每个token所分配的注意力，编码器是使用局部注意力还是全局注意力。具有全局注意力的tokens关注所有其他tokens，所有其他tokens也会关注它们。这对于特定任务的微调很重要，因为它使模型在表示任务时更加灵活。例如，对于分类，token应该给予全局注意力。对于问答，所有问题tokens也应该具有全局注意力。更多信息请参阅Longformer 论文。选择在[0, 1]范围内的mask值：- 0表示局部注意力（滑动窗口注意力），
- 1表示全局注意力（关注所有其他tokens的tokens，所有其他tokens也会关注它们）。
- head_mask (
torch.Tensor的形状为(编码层, 编码注意力头)，可选) — 用于取消激活编码器中注意力模块选定头的掩码。选定的掩码值在[0, 1]之间：- 1 表示头未 屏蔽；
- 0 表示头被 屏蔽。
- decoder_head_mask (
torch.Tensor的形状为(解码层, 解码注意力头)，可选) — 用于取消激活解码器中注意力模块选定头的掩码。选定的掩码值在[0, 1]之间：- 1 表示头未 屏蔽；
- 0 表示头被 屏蔽。
- cross_attn_head_mask (
torch.Tensor的形状为(解码层, 解码注意力头)，可选) — 用于取消激活解码器中跨注意力模块选定头的掩码。选定的掩码值在[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)，可选），是在编码器最后层的输出处的隐藏状态序列。用于解码器的交叉注意力。 - past_key_values (
tuple(tuple(torch.FloatTensor)), 可选，当传入use_cache=True或config.use_cache=True时返回) — 包含长度为config.n_layers的tuple(torch.FloatTensor)的元组，每个元组包含两个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，以及两个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的额外张量。 包含预计算的自注意力 blocking 和 注意力 dezembro blocking 中的隐藏状态（键和值），可以用于加速顺序解码（见past_key_values输入）。如果使用
past_key_values，则用户可以可选地只输入last_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 而不是纯元组。
返回
transformers.modeling_outputs.Seq2SeqModelOutput 或 tuple(torch.FloatTensor)
transformers.modeling_outputs.Seq2SeqModelOutput 或 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 (
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)的张量。包含预先计算的隐藏状态（self-attention块和cross-attention块中的key和value），可用于（见
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时返回) - 每层（一个）形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。解码器的注意力权重，在注意力softmax后，用于在self-attention头中计算加权平均值。
-
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 (
shape为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选) - 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor)，可选，在传递output_hidden_states=True或config.output_hidden_states=True时返回) -torch.FloatTensor元组（如果模型有嵌入层，则为嵌入层的输出 + 每层的输出），形状为(batch_size, sequence_length, hidden_size)。编码器每层的隐藏状态序列加上可选的初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor)，可选，在传递output_attentions=True或config.output_attentions=True时返回) - 每层（一个）形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。编码器的注意力权重，在注意力softmax后，用于在self-attention头中计算加权平均值。
LEDModel的前向方法覆盖了特殊的__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
具有语言建模头的 LED 模型。可用于摘要。此模型继承自 PreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入的大小、剪枝头部等）。
此模型也是PyTorch torch.nn.Module的子类。将其作为常规PyTorch模块使用，并参考PyTorch文档以获取一般使用和行为。
forward
< 源代码 >( input_ids: 可选 = None attention_mask: 可选 = None decoder_input_ids: 可选 = None decoder_attention_mask: 可选 = None head_mask: 可选 = None decoder_head_mask: 可选 = None cross_attn_head_mask: 可选 = None encoder_outputs: 可选 = None global_attention_mask: 可选 = None past_key_values: 可选 = None inputs_embeds: 可选 = None decoder_inputs_embeds: 可选 = None labels: 可选 = None use_cache: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None ) → transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length)) — 词汇表中的输入序列标记的索引。如果提供，默认会忽略填充。 - 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。 - global_attention_mask (
torch.FloatTensorof shape(batch_size, sequence_length), optional) — 用于决定每个token分配的注意力（编码器中的局部注意力或全局注意力）。具有全局注意力的token关注所有其他token，所有其他token也会关注它们。这对于特定任务的微调非常重要，因为它使模型更能灵活地表示任务。例如，对于分类，标记应该给予全局注意力。对于问答，所有问题标记也应具有全局注意力。请参阅Longformer论文以获取更多详细信息。选择在[0, 1]中的掩码值：
torch.Tensor of shape (encoder_layers, encoder_attention_heads), optional) — 用于使编码器中注意力模块中选定的头部无效的掩码。选择在[0, 1]中的掩码值：
torch.Tensor of shape (decoder_layers, decoder_attention_heads), optional) — 用于使解码器中注意力模块中选定的头部无效的掩码。选择在[0, 1]中的掩码值：
torch.Tensor 的形状为 (decoder_layers, decoder_attention_heads)，可选) — 用于取消解码器中交叉注意力模块中选定头的掩码。掩码值选择的范围在 [0, 1] 中： - 1 表示头未被 掩码，
- 0 表示头被 掩码。
tuple(tuple(torch.FloatTensor)，可选) — 由 (last_hidden_state, optional: hidden_states, optional: attentions) 组成的元组 last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size)，可选) 是编码器最后一层的隐藏状态序列。在解码器的交叉注意力中使用。 tuple(tuple(torch.FloatTensor)), 可选，在传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)的元组，每个元组包含形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的两个张量以及两个额外的形状为(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。
torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), 可选) — 可选地，你可以直接传递一个嵌入表示，而不是传递input_ids。这在你想比模型内部的嵌入式查找矩阵有更多控制权将input_ids索引转换为相关向量时很有用。 torch.FloatTensor的形状为(batch_size, target_sequence_length, hidden_size)，可选) — 可以选择传递嵌入表示代替decoder_input_ids。如果使用past_key_values，则可选地只需输入最后一步的decoder_inputs_embeds（见past_key_values）。这样做可以在将decoder_input_ids的索引转换为相关向量时比模型内部的嵌入查找矩阵有更多的控制权。bool，可选) — 如果设置为True，则将返回past_key_values键值状态，可以用以提高解码速度（见past_key_values）。 bool，可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参见返回的张量下的attentions。 bool, 可选) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量下的 hidden_states。 bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。 torch.LongTensor，形状 (batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引应在 [0, ..., config.vocab_size] 或 -100（见 input_ids 文档字符串）之间。索引设置为 -100 的标记将被忽略（掩码），只计算具有 [0, ..., config.vocab_size] 中标签的标记的损失。 返回
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之前的每个词汇的分数）。 -
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)的张量。包含预先计算的隐藏状态（self-attention块和cross-attention块中的key和value），可用于（见
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时返回) - 每层（一个）形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。解码器的注意力权重，在注意力softmax后，用于在self-attention头中计算加权平均值。
-
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 (
shape为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选) - 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor)，可选，在传递output_hidden_states=True或config.output_hidden_states=True时返回) -torch.FloatTensor元组（如果模型有嵌入层，则为嵌入层的输出 + 每层的输出），形状为(batch_size, sequence_length, hidden_size)。编码器每层的输出中的隐藏状态以及初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor)，可选，在传递output_attentions=True或config.output_attentions=True时返回) - 每层（一个）形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。编码器的注意力权重，在注意力softmax后，用于在self-attention头中计算加权平均值。
LEDForConditionalGeneration 的前向方法，覆盖了 __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
< 来源 >( config: LEDConfig **kwargs )
参数
- config (LEDConfig) — 包含所有模型参数的模型配置类。使用配置文件初始化不会加载模型相关的权重，只有配置。请检查 from_pretrained() 方法以加载模型权重。
序列分类/head 在顶部的 LED 模型（在池化输出之上的线性层），例如用于 GLUE 任务的。
该模型继承自 PreTrainedModel。请参阅超类文档，以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
此模型也是PyTorch torch.nn.Module的子类。将其作为常规PyTorch模块使用，并参考PyTorch文档以获取一般使用和行为。
forward
< 来源 >( input_ids: 可选 = None attention_mask: 可选 = None decoder_input_ids: 可选 = None decoder_attention_mask: 可选 = None head_mask: 可选 = None decoder_head_mask: 可选 = None cross_attn_head_mask: 可选 = None encoder_outputs: 可选 = None global_attention_mask: 可选 = None inputs_embeds: 可选 = None decoder_inputs_embeds: 可选 = None labels: 可选 = None use_cache: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None ) → transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length)) — 词汇表中的输入序列标记的索引。如果您提供它，默认情况下将忽略填充token。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length)，可选) — 避免对填充token索引进行注意力的掩码。掩码值选择在[0, 1]范围内：- 1 表示未被掩码的token，
- 0 表示被掩码的token。
- decoder_input_ids (
torch.LongTensorof shape(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.LongTensorof shape(batch_size, target_sequence_length), 可选) — 默认行为：生成一个 tensor，它忽略了decoder_input_ids中的填充 token。默认情况下还会使用因果掩码。如果您想更改填充行为，您应该阅读
modeling_led._prepare_decoder_inputs并根据您的需求进行修改。有关默认策略的更多信息，请参见论文中图 1。 - global_attention_mask (
torch.FloatTensor的形状(batch_size, sequence_length)，可选) — 用于决定每个标记的注意力的掩码，编码器的局部注意力或全局注意力。具有全局注意力的标记会关注所有其他标记，并且所有其他标记也会关注它们。这对于特定任务的微调非常重要，因为它使得模型在表示任务时更加灵活。例如，对于分类，标记应该给予全局注意力。对于问答回答，所有问题标记也应具有全局注意力。请参阅Longformer论文获取更多详细信息。掩码值在[0, 1]中选择： - head_mask (
torch.Tensor的形状(encoder_layers, encoder_attention_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)，这是编码器最后层的隐藏状态序列。用于解码器的交叉注意力。 - past_key_values (
tuple(tuple(torch.FloatTensor)), 可选，当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(torch.FloatTensor)，每个元组包含两个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的tensor，以及两个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的tensor。包含预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码（参见
past_key_values输入）。如果使用
past_key_values，用户可以可选地只输入最后一个decoder_input_ids（那些没有将过去键值状态提供给此模型的）的形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的decoder_input_ids。 - inputs_embeds (
torch.FloatTensorof shape(batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递一个嵌入表示而不是input_ids。这在您想更有控制地转换input_ids索引到相关向量时很有用，比模型的内部嵌入查找矩阵更可控。 - decoder_inputs_embeds (
torch.FloatTensorof shape(batch_size, target_sequence_length, hidden_size), 可选) — 可选地，您可以直接传递一个嵌入表示，而不是传递decoder_input_ids。如果使用past_key_values，则可选地只需输入最后的一个decoder_inputs_embeds（见past_key_values）。如果您想在将decoder_input_ids索引转换为相关向量时比模型内部的嵌入查找矩阵有更多的控制权，那么这非常有用。 - 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,)，可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]之间。如果config.num_labels > 1，则计算分类损失（交叉熵）。
返回
transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput 或 tuple(torch.FloatTensor)
A transformers.modeling_outputs.Seq2SeqSequenceClassifierOutput 或一个包含torch.FloatTensor的元组（如果 return_dict=False 传递或当 config.return_dict=False 时），包含根据配置（LEDConfig）和输入的不同元素。
-
loss (
torch.FloatTensor，形状为(1,)，可选，在提供label时返回) — 分类（或回归，如果配置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(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)的张量。包含预先计算的隐藏状态（self-attention块和cross-attention块中的key和value），可用于（见
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时返回) - 每层（一个）形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。解码器的注意力权重，在注意力softmax后，用于在self-attention头中计算加权平均值。
-
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 (
shape为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选) - 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor)，可选，在传递output_hidden_states=True或config.output_hidden_states=True时返回) -torch.FloatTensor元组（如果模型有嵌入层，则为嵌入层的输出 + 每层的输出），形状为(batch_size, sequence_length, hidden_size)。编码器每层的输出中的隐藏状态以及初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor)，可选，在传递output_attentions=True或config.output_attentions=True时返回) - 每层（一个）形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。编码器的注意力权重，在注意力softmax后，用于在self-attention头中计算加权平均值。
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输出上方的一个线性层计算跨度开始logits和跨度结束logits）。
该模型继承自 PreTrainedModel。请参阅超类文档，以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
此模型也是PyTorch torch.nn.Module的子类。将其作为常规PyTorch模块使用，并参考PyTorch文档以获取一般使用和行为。
forward
< source >( input_ids: 可选 = None attention_mask: 可选 = None decoder_input_ids: 可选 = None decoder_attention_mask: 可选 = None head_mask: 可选 = None decoder_head_mask: 可选 = None cross_attn_head_mask: 可选 = None encoder_outputs: 可选 = None global_attention_mask: 可选 = None start_positions: 可选 = None end_positions: 可选 = None inputs_embeds: 可选 = None decoder_inputs_embeds: 可选 = None use_cache: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None ) → transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (<code>torch.LongTensor</code> 形状 <code>(batch_size, sequence_length)</code>) — 在词汇表中的输入序列标记索引。如果提供填充，则默认忽略填充部分。 使用 <a href="/docs/transformers/v4.44.0/en/model_doc/auto#transformers.AutoTokenizer">AutoTokenizer</a> 获取索引。详见 <a href="/docs/transformers/v4.44.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> 和 <a href="/docs/transformers/v4.44.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.call()</a> 的详细信息。
<a href="../glossary#input-ids">什么是输入 ID？</a>
- attention_mask (<code>torch.Tensor</code> 形状 <code>(batch_size, sequence_length)</code>, <em>可选</em>) — 避免在填充标记索引上执行注意力的掩码。掩码值在 <code>[0, 1]</code> 中选择：
- 1 表示 未遮蔽 的标记，
- 0 表示 遮蔽 的标记。
<a href="../glossary#attention-mask">什么是注意力掩码？</a>
- decoder_input_ids (<code>torch.LongTensor</code> 形状 <code>(batch_size, target_sequence_length)</code>, <em>可选</em>) — 在词汇表中的解码器输入序列标记索引。 使用 <code>LedTokenizer</code> 获取索引。详见 <a href="/docs/transformers/v4.44.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode">PreTrainedTokenizer.encode()</a> 和 <a href="/docs/transformers/v4.44.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__">PreTrainedTokenizer.call()</a> 的详细信息。
LED 使用 <code>eos_token_id</code> 作为 <code>decoder_input_ids</code> 生成时的起始标记。如果使用 <code>past_key_values</code>，则可以可选地只输入最后 <code>decoder_input_ids</code>（参看 <code>past_key_values</code>）。
- decoder_attention_mask (
torch.LongTensor形状为(batch_size, target_sequence_length)，可选) — 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。默认还会使用因果掩码。如果您想更改填充行为，应读取
modeling_led._prepare_decoder_inputs并根据您的需求进行修改。更多信息请参阅图1，链接为论文。 - global_attention_mask (
torch.FloatTensor形状为(batch_size, sequence_length)，可选) — 决定每个标记的关注掩码，用于编码器的局部关注或全局关注。具有全局关注的标记将关注所有其他标记，所有其他标记也将关注它们。这对于特定任务的微调很重要，因为它使模型在表示任务时更灵活。例如，对于分类，标记应该给予全局关注。对于问答，所有问题标记也应具有全局关注。更多信息请参阅Longformer 论文。掩码值在 code>[0, 1]中选择:- 0 表示局部关注（滑动窗口关注），
- 1 表示全局关注（关注所有其他标记的标记，所有其他标记也关注它们）。
- head_mask （形式为
torch.Tensor的张量，形状为(encoder_layers, encoder_attention_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), optional) — 包含(<code>last_hidden_state</code>，optional: <code>hidden_states</code>, optional: <code>attentions</code>) <code>last_hidden_state</code>有形状 <code>(batch_size, sequence_length, hidden_size)</code>（optional），是编码器最后一层的隐藏状态序列。在解码器的交叉注意力中使用。 - past_key_values (
tuple(tuple(torch.FloatTensor)), optional, returned whenuse_cache=Trueis passed or whenconfig.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)。 - 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 而不是纯元组。 - start_positions (
torch.LongTensorof shape(batch_size,), optional) — 计算标记跨度分类损失的位置（索引）标签。位置限制在序列长度（sequence_length）内。序列之外的位置在计算损失时不会被考虑。 - end_positions (
torch.LongTensorof shape(batch_size,), optional) — 计算标记跨度分类损失的位置（索引）标签。位置限制在序列长度（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.FloatTensorof shape(1,), optional, returned whenlabelsis provided) — 总跨度提取损失是起始和结束位置交叉熵的总和。 -
start_logits (
torch.FloatTensorof shape(batch_size, sequence_length)) — 跨度起始分数（在 SoftMax 之前）。 -
end_logits (
torch.FloatTensorof shape(batch_size, sequence_length)) — 跨度结束分数（在 SoftMax 之前）。 -
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)的张量。包含预先计算的隐藏状态（self-attention块和cross-attention块中的key和value），可用于（见
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时返回) - 每层（一个）形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。解码器的注意力权重，在注意力softmax后，用于在self-attention头中计算加权平均值。
-
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 (
shape为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选) - 模型编码器最后一层的隐藏状态序列。 -
encoder_hidden_states (
tuple(torch.FloatTensor)，可选，在传递output_hidden_states=True或config.output_hidden_states=True时返回) -torch.FloatTensor元组（如果模型有嵌入层，则为嵌入层的输出 + 每层的输出），形状为(batch_size, sequence_length, hidden_size)。编码器每层的输出中的隐藏状态以及初始嵌入输出。
-
encoder_attentions (
tuple(torch.FloatTensor)，可选，在传递output_attentions=True或config.output_attentions=True时返回) - 每层（一个）形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。编码器的注意力权重，在注意力softmax后，用于在self-attention头中计算加权平均值。
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
< 源代码 >( config *inputs **kwargs )
参数
- config （LED配置类） — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载模型相关的权重，只加载配置。请查看from_pretrained() 方法来加载模型权重。
一个裸LED模型，它输出原始隐藏状态，没有顶部任何特定的头部。此模型继承自TFPreTrainedModel。查看超类文档，以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头部等。）
此模型也是一个keras.Model的子类。将其作为常规TF 2.0 Keras模型使用，并参考TF 2.0文档来了解与一般使用和行为相关的所有事项。
TensorFlow模型和层在transformers中接受两种输入格式：
- 所有输入作为关键字参数（类似于PyTorch模型），或者
- 所有输入作为一个列表、元组或字典作为第一个位置参数。
支持第二种格式的理由是，当将输入传递给模型和层时，Keras方法更喜欢这种格式。正因为这种支持，当使用如model.fit()这样的方法时，对于您来说应该“一帆风顺”——只需以model.fit()支持的任何格式传递您的输入和标签即可！不过，如果您想在Keras方法fit()和predict()之外使用第二种格式，例如在创建自己的层或模型时，有三种可能的使用方式来收集所有输入张量在第一个位置参数：
- 只包含
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)，可选) — 避免对填充标记索引执行关注。选择的掩码值：- 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 (
长度为）——包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用config.n_layers的Tuple[Tuple[tf.Tensor]]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，可选项）— 是否返回所有注意力层的注意力张量。有关更多信息，请参阅返回的张量下的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 (
可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 一个 (batch_size, sequence_length, hidden_size) 形状的tf.Tensor的元组（每个嵌入层和每个编码层）。解码器每层的输出中的隐藏状态以及初始嵌入输出。
-
decoder_attentions (
可选，当传递output_attentions=True或当config.output_attentions=True时返回) — 一个形状为 (batch_size, num_heads, sequence_length, sequence_length) 的tf.Tensor的元组（每个层）。解码器的注意力权重，在注意力softmax后，用于在self-attention头中计算加权平均值。
-
cross_attentions (
可选，当传递output_attentions=True或当config.output_attentions=True时返回) — 一个形状为 (batch_size, num_heads, sequence_length, sequence_length) 的tf.Tensor的元组（每个层）。解码器交叉注意力层的注意力权重，在注意力softmax后，用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state （形状为
(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）—— 模型编码器最后一层的隐藏状态的序列。 -
encoder_hidden_states （
(tf.Tensor)的三元组，可选，当传递output_hidden_states=True或当配置config.output_hidden_states=True时返回）——tf.Tensor的三元组（一个用于嵌入层的输出，一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。编码器每层的输出中的隐藏状态以及初始嵌入输出。
-
encoder_attentions （
(tf.Tensor)的三元组，可选，当传递output_attentions=True或当配置config.output_attentions=True时返回）—— 表示每个层的tf.Tensor的三元组，形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力softmax后，用于在self-attention头中计算加权平均值。
-
encoder_global_attentions （
(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_stateTFLEDModel 前向方法，重写了 __call__ 特殊方法。
TFLEDForConditionalGeneration
类 transformers.TFLEDForConditionalGeneration( config *inputs **kwargs )
参数
- config (LEDConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化时，不会加载模型相关的权重，只加载配置。请检查from_pretrained() 方法来加载模型权重。
具有语言模型头的LED模型。可用于摘要。此模型继承自TFPreTrainedModel。请查看上级类文档以了解库为实现其所有模型（如下载或保存、调整输入嵌入大小、剪枝头等）实现的通用方法。
此模型也是一个keras.Model的子类。将其作为常规TF 2.0 Keras模型使用，并参考TF 2.0文档来了解与一般使用和行为相关的所有事项。
TensorFlow模型和层在transformers中接受两种输入格式：
- 所有输入作为关键字参数（类似于PyTorch模型），或者
- 所有输入作为一个列表、元组或字典作为第一个位置参数。
支持第二种格式的理由是，当将输入传递给模型和层时，Keras方法更喜欢这种格式。正因为这种支持，当使用如model.fit()这样的方法时，对于您来说应该“一帆风顺”——只需以model.fit()支持的任何格式传递您的输入和标签即可！不过，如果您想在Keras方法fit()和predict()之外使用第二种格式，例如在创建自己的层或模型时，有三种可能的使用方式来收集所有输入张量在第一个位置参数：
- 只包含
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函数一样传递输入！
调用
< 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：元组[元组[联合[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：布尔型 或 None = None output_attentions：布尔型 或 None = None output_hidden_states：布尔型 或 None = None return_dict：布尔型 或 None = None labels：tf.Tensor 或 None = None training：布尔型 =False ) → transformers.models.led.modeling_tf_led.TFLEDSeq2SeqLMOutput 或 tuple(tf.Tensor)
参数
- input_ids (
tf.Tensor形状{0}) — 输入序列token在词汇表中的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
tf.Tensor形状{0}, 可选) — 避免在填充token索引上执行注意力的掩码。选择的掩码值在[0, 1]中：- 1 表示 未掩码 的token，
- 0 表示 掩码 的token。
- 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(见past_key_values)。 - decoder_attention_mask (
tf.Tensor形状为(batch_size, target_sequence_length)，可选) — 默认会被创建并忽略填充标记。不建议在大多数用例中设置此参数。 - head_mask (
tf.Tensor形状为(encoder_layers, encoder_attention_heads)，可选) — used to mask out selected heads of the attention modules in the encoder. Mask values selected in[0, 1]:- 1 indicates the head is not masked,
- 0 indicates the head is masked.
- decoder_head_mask (
tf.Tensor形状为(decoder_layers, decoder_attention_heads)，可选) — used to mask out selected heads of the attention modules in the decoder. Mask values selected in[0, 1]:- 1 indicates the head is not masked,
- 0 indicates the head is masked.
- encoder_outputs (
tf.Tensor, 可选) — 表示编码器最后一层的隐藏状态。用于解码器的交叉注意力中。形状为(batch_size, sequence_length, hidden_size)的序列 - past_key_values (
Tuple[Tuple[tf.Tensor]]的长度为config.n_layers) — 包含注意力块的预计算键和价值隐藏状态。可加速解码。如果使用past_key_values，用户可以可选地只输入最后decoder_input_ids（那些没有给此模型提供过去键值状态）的形状为(batch_size, 1)而不是所有decoder_input_ids的形状为(batch_size, sequence_length)。 - 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.TFLEDSeq2SeqLMOutput 或 tuple(tf.Tensor)
A transformers.models.led.modeling_tf_led.TFLEDSeq2SeqLMOutput 或一个包含各种元素的tf.Tensor元组（取决于配置（LEDConfig）和输入），具体取决于配置（LEDConfig）和输入。
-
loss (
tf.Tensorof shape(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 (
可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) — 一个 (batch_size, sequence_length, hidden_size) 形状的tf.Tensor的元组（每个嵌入层和每个编码层）。解码器每层的输出中的隐藏状态以及初始嵌入输出。
-
decoder_attentions (
可选，当传递output_attentions=True或当config.output_attentions=True时返回) — 一个形状为 (batch_size, num_heads, sequence_length, sequence_length) 的tf.Tensor的元组（每个层）。解码器的注意力权重，在注意力softmax后，用于在self-attention头中计算加权平均值。
-
cross_attentions (
可选，当传递output_attentions=True或当config.output_attentions=True时返回) — 一个形状为 (batch_size, num_heads, sequence_length, sequence_length) 的tf.Tensor的元组（每个层）。解码器交叉注意力层的注意力权重，在注意力softmax后，用于计算交叉注意力头中的加权平均值。
-
encoder_last_hidden_state （形状为
(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）—— 模型编码器最后一层的隐藏状态的序列。 -
encoder_hidden_states （
(tf.Tensor)的三元组，可选，当传递output_hidden_states=True或当配置config.output_hidden_states=True时返回）——tf.Tensor的三元组（一个用于嵌入层的输出，一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。编码器每层的输出中的隐藏状态以及初始嵌入输出。
-
encoder_attentions （
(tf.Tensor)的三元组，可选，当传递output_attentions=True或当配置config.output_attentions=True时返回）—— 表示每个层的tf.Tensor的三元组，形状为(batch_size, num_heads, sequence_length, sequence_length)。编码器的注意力权重，在注意力softmax后，用于在self-attention头中计算加权平均值。
-
encoder_global_attentions （
(tf.Tensor)的三元组，可选，当传递output_attentions=True或当配置config.output_attentions=True时返回）—— 表示每个层的tf.Tensor的三元组，形状为(batch_size, num_heads, sequence_length, x)，其中x是具有全局注意力掩码的标记数。注意力 softmax 后的全局注意力权重，用于在自注意力头部计算加权平均。这些是每个具有全局注意力的标记对序列中每个标记的注意力权重。
TFLEDForConditionalGeneration 的forward方法重载了 __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