Transformers 4.37 中文文档(三十九)(4)https://developer.aliyun.com/article/1564713
LEDForQuestionAnswering
class transformers.LEDForQuestionAnswering
( config )
参数
config
(LEDConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。
LED 模型顶部带有用于类似 SQuAD 的抽取式问答任务的跨度分类头(在隐藏状态输出顶部的线性层上计算span start logits
和span end logits
)。
此模型继承自 PreTrainedModel。请参阅超类文档,了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头部等)。
此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取一般用法和行为。
forward
( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None head_mask: Optional = None decoder_head_mask: Optional = None cross_attn_head_mask: Optional = None encoder_outputs: Optional = None global_attention_mask: Optional = None start_positions: Optional = None end_positions: Optional = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqQuestionAnsweringModelOutput or tuple(torch.FloatTensor)
参数
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
)— 词汇表中输入序列标记的索引。默认情况下会忽略填充。
可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call
()。
什么是输入 ID?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
()。
什么是输入 ID?
LED 使用eos_token_id
作为decoder_input_ids
生成的起始标记。如果使用past_key_values
,则可选择仅输入最后的decoder_input_ids
(参见past_key_values
)。decoder_attention_mask
(形状为(batch_size, target_sequence_length)
的torch.LongTensor
,可选)— 默认行为:生成一个张量,忽略decoder_input_ids
中的填充标记。默认情况下也会使用因果掩码。
如果要更改填充行为,应阅读modeling_led._prepare_decoder_inputs
并根据需要进行修改。有关默认策略的更多信息,请参阅 论文 中的图表 1。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
(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)
元组,每个元组有 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
,用户可以选择仅输入最后的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 而不是一个普通元组。start_positions
(torch.LongTensor
,形状为(batch_size,)
,可选)- 用于计算标记跨度的开始位置(索引)的标签。位置被夹紧到序列的长度(sequence_length)。序列外的位置不会用于计算损失。end_positions
(torch.LongTensor
of 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.FloatTensor
of shape(1,)
, optional, 当提供labels
时返回) — 总跨度提取损失是开始和结束位置的交叉熵之和。start_logits
(torch.FloatTensor
of shape(batch_size, sequence_length)
) — 跨度开始得分(SoftMax 之前)。end_logits
(torch.FloatTensor
of shape(batch_size, sequence_length)
) — 跨度结束得分(SoftMax 之前)。past_key_values
(tuple(tuple(torch.FloatTensor))
, optional, 当传递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
输入)。decoder_hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出的输出+每层的输出)。
解码器在每一层的隐藏状态加上初始嵌入输出。decoder_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。
解码器的注意力权重,在注意力 Softmax 之后,用于计算自注意力头中的加权平均值。cross_attentions
(tuple(torch.FloatTensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。
解码器的交叉注意力层的注意力权重,在注意力 Softmax 之后,用于计算交叉注意力头中的加权平均值。encoder_last_hidden_state
(torch.FloatTensor
of shape(batch_size, sequence_length, hidden_size)
, optional) — 模型编码器最后一层的隐藏状态序列。encoder_hidden_states
(tuple(torch.FloatTensor)
, optional, 当传递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 之后,用于计算自注意力头中的加权平均值。
LEDForQuestionAnswering 的前向方法,覆盖了 __call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用 Module
实例,而不是在此处调用,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
>>> from transformers import AutoTokenizer, LEDForQuestionAnswering >>> import torch >>> tokenizer = AutoTokenizer.from_pretrained("allenai/led-base-16384") >>> model = LEDForQuestionAnswering.from_pretrained("allenai/led-base-16384") >>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet" >>> inputs = tokenizer(question, text, return_tensors="pt") >>> with torch.no_grad(): ... outputs = model(**inputs) >>> answer_start_index = outputs.start_logits.argmax() >>> answer_end_index = outputs.end_logits.argmax() >>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1] >>> # target is "nice puppet" >>> target_start_index = torch.tensor([14]) >>> target_end_index = torch.tensor([15]) >>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index) >>> loss = outputs.loss
TensorFlow 隐藏 TensorFlow 内容
TFLEDModel
class transformers.TFLEDModel
( config *inputs **kwargs )
参数
config
(LEDConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。
裸 LED 模型输出原始隐藏状态,没有特定的头部。此模型继承自 TFPreTrainedModel。查看超类文档,了解库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
此模型也是 tf.keras.Model 的子类。将其用作常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档以获取有关一般用法和行为的所有相关信息。
transformers
中的 TensorFlow 模型和层接受两种格式的输入:
- 将所有输入作为关键字参数(类似于 PyTorch 模型),或
- 将所有输入作为列表、元组或字典放在第一个位置参数中。
支持第二种格式的原因是,Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持,当使用 model.fit()
等方法时,您应该可以“轻松使用” - 只需传递您的输入和标签,以任何 model.fit()
支持的格式!但是,如果您想在 Keras 方法之外使用第二种格式,比如在使用 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
( 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 ) → export const metadata = 'undefined';transformers.models.led.modeling_tf_led.TFLEDSeq2SeqModelOutput or tuple(tf.Tensor)
参数
input_ids
(tf.Tensor
,形状为(batch_size, sequence_length)
) — 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。
什么是输入 ID?attention_mask
(形状为(batch_size, sequence_length)
的tf.Tensor
,可选)— 用于避免在填充标记索引上执行注意力的遮罩。在[0, 1]
中选择的遮罩值:
- 1 表示未被遮罩的标记,
- 0 表示被遮罩的标记。
- 什么是注意力遮罩?
decoder_input_ids
(形状为(batch_size, target_sequence_length)
的tf.Tensor
,可选)— 词汇表中解码器输入序列标记的索引。
可以使用LedTokenizer
获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。
什么是输入 ID?
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
,可选)— 默认情况下将忽略填充标记并生成。不建议为大多数用例设置此选项。head_mask
(形状为(encoder_layers, encoder_attention_heads)
的tf.Tensor
,可选)— 用于在编码器中使注意力模块中的选定头部失效的遮罩。在[0, 1]
中选择的遮罩值:
- 1 表示头部未被遮罩,
- 0 表示头部被遮罩。
decoder_head_mask
(形状为(decoder_layers, decoder_attention_heads)
的tf.Tensor
,可选)— 用于在解码器中使注意力模块中的选定头部失效的遮罩。在[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
。此参数仅在急切模式下使用,在图模式下,将使用配置中的值。output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。此参数仅在急切模式下使用,在图模式下,将使用配置中的值。return_dict
(bool
,可选)— 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用,在图模式下,该值将始终设置为 True。training
(bool
,optional,默认为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)
) — 模型解码器最后一层的隐藏状态序列。
如果仅使用past_key_values
,则输出形状为(batch_size, 1, hidden_size)
的序列的最后一个隐藏状态。past_key_values
(List[tf.Tensor]
, optional, returned whenuse_cache=True
is passed or whenconfig.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)
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入输出,一个用于每一层的输出)。
解码器在每一层的隐藏状态加上初始嵌入输出。decoder_attentions
(tuple(tf.Tensor)
, optional, returned whenoutput_attentions=True
is passed or whenconfig.output_attentions=True
) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。
解码器的注意力权重,在注意力 softmax 之后,用于计算自注意力头中的加权平均值。cross_attentions
(tuple(tf.Tensor)
, optional, returned whenoutput_attentions=True
is passed or whenconfig.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)
,optional) — 模型编码器最后一层的隐藏状态序列。encoder_hidden_states
(tuple(tf.Tensor)
, optional, returned whenoutput_hidden_states=True
is passed or whenconfig.output_hidden_states=True
) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入输出,一个用于每一层的输出)。
编码器在每一层的隐藏状态加上初始嵌入输出。encoder_attentions
(tuple(tf.Tensor)
, optional, returned whenoutput_attentions=True
is passed or whenconfig.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 之后的全局注意力权重,用于计算自注意力头中的加权平均值。这些是来自具有全局注意力的每个令牌到序列中每个令牌的注意力权重。
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_state
TFLEDForConditionalGeneration
class transformers.TFLEDForConditionalGeneration
( config *inputs **kwargs )
参数
config
(LEDConfig)- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。
具有语言建模头的 LED 模型。可用于摘要。此模型继承自 TFPreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
此模型还是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档以获取与一般用法和行为相关的所有信息。
transformers
中的 TensorFlow 模型和层接受两种格式的输入:
- 将所有输入作为关键字参数(类似于 PyTorch 模型),
- 将所有输入作为列表、元组或字典放在第一个位置参数中。
支持第二种格式的原因是,Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于有了这种支持,当使用model.fit()
等方法时,应该可以“正常工作” - 只需传递您的输入和标签以任何model.fit()
支持的格式!但是,如果您想在 Keras 方法之外使用第二种格式,比如在使用 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
( 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 ) → export const metadata = 'undefined';transformers.models.led.modeling_tf_led.TFLEDSeq2SeqLMOutput or tuple(tf.Tensor)
参数
input_ids
(形状为({0})
的tf.Tensor
)- 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。
什么是输入 ID?attention_mask
(形状为({0})
的tf.Tensor
,可选)- 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值为[0, 1]
:
- 1 用于未被“掩码”的标记,
- 0 用于被“掩码”的标记。
- 什么是注意力掩码?
decoder_input_ids
(形状为(batch_size, target_sequence_length)
的tf.Tensor
,可选)- 词汇表中解码器输入序列标记的索引。
可以使用LedTokenizer
获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。
什么是输入 ID?
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
,可选)- 将默认生成并忽略填充标记。不建议为大多数用例设置此项。head_mask
(形状为(encoder_layers, encoder_attention_heads)
的tf.Tensor
,可选)- 用于使编码器中的注意力模块中的选定头部无效的掩码。选择的掩码值为[0, 1]
:
- 1 表示头部未被“掩码”,
- 0 表示头部被“掩码”。
decoder_head_mask
(形状为(decoder_layers, decoder_attention_heads)
的tf.Tensor
,可选)- 用于使解码器中的注意力模块中的选定头部无效的掩码。选择的掩码值为[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
。此参数仅可在急切模式下使用,在图模式中将使用配置中的值。output_hidden_states
(bool
,可选)- 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。此参数仅可在急切模式下使用,在图模式中将使用配置中的值。return_dict
(bool
,可选)- 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用,在图模式中该值将始终设置为 True。training
(bool
, 可选, 默认为False
) — 是否在训练模式下使用模型(一些模块如 dropout 模块在训练和评估之间有不同的行为)。
返回
transformers.models.led.modeling_tf_led.TFLEDSeq2SeqLMOutput 或 tuple(tf.Tensor)
transformers.models.led.modeling_tf_led.TFLEDSeq2SeqLMOutput 或 tf.Tensor
元组(如果传递return_dict=False
或config.return_dict=False
)包括不同元素,取决于配置(LEDConfig)和输入。
loss
(形状为
(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
时返回) — 长度为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
(形状为
(batch_size, sequence_length, hidden_size)的
tf.Tensor`, 可选) — 模型编码器最后一层的隐藏状态序列。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 之后的全局注意力权重,用于计算自注意力头中的加权平均值。这些是来自每个令牌的注意力权重,对序列中的每个令牌进行全局注意力。
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
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
(形状为
(batch_size, sequence_length, hidden_size)的
tf.Tensor`, 可选) — 模型编码器最后一层的隐藏状态序列。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 之后的全局注意力权重,用于计算自注意力头中的加权平均值。这些是来自每个令牌的注意力权重,对序列中的每个令牌进行全局注意力。
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