Hugging Face 的 LOGO

Transformers 文档

Encoder Decoder 模型

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

该模型于 2017-06-12 发布，并于 2020-11-16 添加到 Hugging Face Transformers。

PyTorch SDPA

Encoder Decoder 模型

EncoderDecoderModel 使用任何预训练的自动编码器和预训练的自回归模型初始化一个序列到序列模型。它在序列生成任务中非常有效，正如 Text Summarization with Pretrained Encoders 中所展示的，该任务使用 BertModel 作为编码器和解码器。

该模型由 thomwolf 贡献。

点击右侧边栏的 Encoder Decoder 模型，了解更多关于如何将 Encoder Decoder 应用于不同语言任务的示例。

以下示例展示了如何使用 Pipeline、AutoModel 和命令行生成文本。

流水线
自动模型
Transformers CLI
from transformers import pipeline

summarizer = pipeline(
    "summarization",
    model="patrickvonplaten/bert2bert-cnn_dailymail-fp16",
    device=0
)

text = "Plants create energy through a process known as photosynthesis. This involves capturing sunlight and converting carbon dioxide and water into glucose and oxygen."
print(summarizer(text))

注意事项

  • EncoderDecoderModel 可以使用任何预训练的编码器和解码器进行初始化。但取决于解码器架构，交叉注意力层可能会被随机初始化。

这些模型需要下游微调，正如这篇 博客文章 所讨论的。使用 from_encoder_decoder_pretrained() 来组合编码器和解码器检查点。

from transformers import EncoderDecoderModel, BertTokenizer

tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
model = EncoderDecoderModel.from_encoder_decoder_pretrained(
    "google-bert/bert-base-uncased",
    "google-bert/bert-base-uncased"
)
  • Encoder Decoder 模型可以像 BART、T5 或任何其他 encoder-decoder 模型一样进行微调。只需要 2 个输入来计算损失，即 input_ids 和 labels。更详细的训练示例请参考此 笔记本。
>>> from transformers import BertTokenizer, EncoderDecoderModel

>>> tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
>>> model = EncoderDecoderModel.from_encoder_decoder_pretrained("google-bert/bert-base-uncased", "google-bert/bert-base-uncased")

>>> model.config.decoder_start_token_id = tokenizer.cls_token_id
>>> model.config.pad_token_id = tokenizer.pad_token_id

>>> input_ids = tokenizer(
...     "The tower is 324 metres (1,063 ft) tall, about the same height as an 81-storey building, and the tallest structure in Paris. Its base is square, measuring 125 metres (410 ft) on each side.During its construction, the Eiffel Tower surpassed the Washington Monument to become the tallest man-made structure in the world, a title it held for 41 years until the Chrysler Building in New York City was  finished in 1930. It was the first structure to reach a height of 300 metres. Due to the addition of a broadcasting aerial at the top of the tower in 1957, it is now taller than the Chrysler Building by 5.2 metres (17 ft).Excluding transmitters, the Eiffel Tower is the second tallest free-standing structure in France after the Millau Viaduct.",
...     return_tensors="pt",
... ).input_ids

>>> labels = tokenizer(
...     "the eiffel tower surpassed the washington monument to become the tallest structure in the world. it was the first structure to reach a height of 300 metres in paris in 1930. it is now taller than the chrysler building by 5. 2 metres ( 17 ft ) and is the second tallest free - standing structure in paris.",
...     return_tensors="pt",
... ).input_ids

>>> # the forward function automatically creates the correct decoder_input_ids
>>> loss = model(input_ids=input_ids, labels=labels).loss
>>> from transformers import BertConfig, EncoderDecoderConfig, EncoderDecoderModel

>>> config_encoder = BertConfig()
>>> config_decoder = BertConfig()

>>> config = EncoderDecoderConfig.from_encoder_decoder_configs(config_encoder, config_decoder)
>>> model = EncoderDecoderModel(config=config)
  • Encoder Decoder 模型也可以用于翻译，如下所示。
from transformers import AutoTokenizer, EncoderDecoderModel

# Load a pre-trained translation model
model_name = "google/bert2bert_L-24_wmt_en_de"
tokenizer = AutoTokenizer.from_pretrained(model_name, pad_token="<pad>", eos_token="</s>", bos_token="<s>")
model = EncoderDecoderModel.from_pretrained(model_name)

# Input sentence to translate
input_text = "Plants create energy through a process known as"

# Encode the input text
inputs = tokenizer(input_text, return_tensors="pt", add_special_tokens=False).input_ids

# Generate the translated output
outputs = model.generate(inputs)[0]

# Decode the output tokens to get the translated sentence
translated_text = tokenizer.decode(outputs, skip_special_tokens=True)

print("Translated text:", translated_text)

EncoderDecoderConfig

class transformers.EncoderDecoderConfig

< >

( pad_token_id = None decoder_start_token_id = None **kwargs )

参数

  • pad_token_id (int, optional) — 填充 token ID。
  • decoder_start_token_id (int, optional) — 如果 encoder-decoder 模型以与 bos 不同的 token 开始解码，则为该 token 的 ID。
  • kwargs (optional) — 关键字参数字典。其中特别包括：

    • encoder (PreTrainedConfig, optional) — 定义编码器配置的配置对象的实例。
    • decoder (PreTrainedConfig, optional) — 定义解码器配置的配置对象的实例。

EncoderDecoderConfig 是一个配置类，用于存储 EncoderDecoderModel 的配置。它用于根据指定的参数实例化 Encoder Decoder 模型，定义编码器和解码器的配置。

配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PreTrainedConfig 的文档。

示例

>>> from transformers import BertConfig, EncoderDecoderConfig, EncoderDecoderModel

>>> # Initializing a BERT google-bert/bert-base-uncased style configuration
>>> config_encoder = BertConfig()
>>> config_decoder = BertConfig()

>>> config = EncoderDecoderConfig.from_encoder_decoder_configs(config_encoder, config_decoder)

>>> # Initializing a Bert2Bert model (with random weights) from the google-bert/bert-base-uncased style configurations
>>> model = EncoderDecoderModel(config=config)

>>> # Accessing the model configuration
>>> config_encoder = model.config.encoder
>>> config_decoder = model.config.decoder
>>> # set decoder config to causal lm
>>> config_decoder.is_decoder = True
>>> config_decoder.add_cross_attention = True

>>> # Saving the model, including its configuration
>>> model.save_pretrained("my-model")

>>> # loading model and config from pretrained folder
>>> encoder_decoder_config = EncoderDecoderConfig.from_pretrained("my-model")
>>> model = EncoderDecoderModel.from_pretrained("my-model", config=encoder_decoder_config)

from_encoder_decoder_configs

< >

( encoder_config: PreTrainedConfig decoder_config: PreTrainedConfig **kwargs ) → EncoderDecoderConfig

返回

EncoderDecoderConfig

一个配置对象的实例

从预训练的编码器模型配置和解码器模型配置实例化 EncoderDecoderConfig（或派生类）。

EncoderDecoderModel

class transformers.EncoderDecoderModel

< >

( config: transformers.configuration_utils.PreTrainedConfig | None = None encoder: transformers.modeling_utils.PreTrainedModel | None = None decoder: transformers.modeling_utils.PreTrainedModel | None = None )

参数

  • config (PreTrainedConfig, optional) — 模型配置类，包含模型的所有参数。使用配置文件初始化仅加载配置，不加载与模型相关的权重。请查看 from_pretrained() 方法来加载模型权重。
  • encoder (PreTrainedModel, optional) — 要使用的编码器模型。
  • decoder (PreTrainedModel, optional) — 要使用的解码器模型。

输出原始隐藏状态的裸 Encoder Decoder 模型，没有任何特定的顶部头部。

此模型继承自 PreTrainedModel。查看其父类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< >

( input_ids: torch.LongTensor | None = None attention_mask: torch.FloatTensor | None = None decoder_input_ids: torch.LongTensor | None = None decoder_attention_mask: torch.BoolTensor | None = None encoder_outputs: tuple[torch.FloatTensor] | None = None past_key_values: transformers.cache_utils.Cache | None = None inputs_embeds: torch.FloatTensor | None = None decoder_inputs_embeds: torch.FloatTensor | None = None labels: torch.LongTensor | None = None use_cache: bool | None = None cache_position: torch.Tensor | None = None **kwargs ) → transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor, shape (batch_size, sequence_length), optional) — 词汇表中的输入序列 token ID。默认情况下将忽略填充。

    可以使用 AutoTokenizer 获取 ID。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是 input IDs？

  • attention_mask (torch.FloatTensor, shape (batch_size, sequence_length), optional) — 屏蔽填充 token ID 的掩码。 Mask 值选择在 [0, 1] 中：

    • 1 表示 **未屏蔽** 的 token，
    • 0 表示 **已屏蔽** 的 token。

    什么是 attention masks？

  • decoder_input_ids (torch.LongTensor, shape (batch_size, target_sequence_length), optional) — 解码器输入序列 token ID 的词汇表索引。

    可以使用 PreTrainedTokenizer 获取 ID。请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 了解详情。

    什么是 input IDs？

    如果使用 past_key_values，则可以选择只输入最后的 decoder_input_ids（其 past key value 状态已传递给此模型），形状为 (batch_size, unprocessed_length)，而不是所有 input_ids（形状为 (batch_size, sequence_length)）。

    在训练时，decoder_input_ids 会由模型自动创建，方法是将 labels 向右移位，将 -100 替换为 pad_token_id，并在前面加上 decoder_start_token_id。

  • decoder_attention_mask (torch.BoolTensor, shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个忽略 decoder_input_ids 中 padding token 的张量。默认情况下也会使用因果掩码。
  • encoder_outputs (tuple, optional) — Tuple 由 (last_hidden_state, optional: hidden_states, optional: attentions) 组成。last_hidden_state 的形状为 (batch_size, sequence_length, hidden_size)，optional）是编码器最后一层的输出隐藏状态序列。在解码器的交叉注意力中使用。
  • past_key_values (~cache_utils.Cache, optional) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可以用来加速顺序解码。这通常包括在 use_cache=True 或 config.use_cache=True 时，模型在以前的解码阶段返回的 past_key_values。

    只允许 Cache 实例作为输入，请参阅我们的 kv cache 指南。如果未传递 past_key_values，则默认初始化 DynamicCache。

    模型将输出与输入相同的 cache 格式。

    如果使用 past_key_values，用户应只输入未处理的 input_ids（其 past key value 状态未传递给此模型），形状为 (batch_size, unprocessed_length)，而不是所有 input_ids（形状为 (batch_size, sequence_length)）。

  • inputs_embeds (torch.FloatTensor, shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以直接传递嵌入表示，而不是传递 input_ids。如果您想比模型内部的嵌入查找矩阵更精细地控制如何将 input_ids ID 转换为关联向量，这很有用。
  • decoder_inputs_embeds (torch.FloatTensor, shape (batch_size, target_sequence_length, hidden_size), optional) — 可选地，您可以直接传递嵌入表示，而不是传递 decoder_input_ids。如果您想比模型内部的嵌入查找矩阵更精细地控制如何将 decoder_input_ids ID 转换为关联向量，这很有用。
  • labels (torch.LongTensor, shape (batch_size, sequence_length), optional) — 用于计算解码器的掩码语言模型损失的标签。ID 应在 [-100, 0, ..., config.vocab_size] 范围内（请参阅 input_ids docstring）。ID 设置为 -100 的 token 将被忽略（掩码），损失仅对标签在 [0, ..., config.vocab_size] 范围内的 token 计算。
  • use_cache (bool, optional) — 如果设置为 True，将返回 past_key_values 键值状态，可用于加速解码（请参阅 past_key_values）。
  • cache_position (torch.Tensor，形状为 (sequence_length)，可选) — 指示输入序列 token 在序列中位置的索引。与 position_ids 相反，该张量不受 padding 的影响。它用于在正确的位置更新缓存并推断完整的序列长度。

返回

transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)

A transformers.modeling_outputs.Seq2SeqLMOutput 或 torch.FloatTensor 的元组（如果传入 return_dict=False 或当 config.return_dict=False 时），具体取决于配置（EncoderDecoderConfig）和输入而包含各种元素。

  • loss (torch.FloatTensor，形状为 (1,)，可选，当提供 labels 时返回) — 语言建模损失。

  • logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.FloatTensor) — 语言建模头部的预测分数（SoftMax 之前的每个词汇标记的分数）。

  • past_key_values (EncoderDecoderCache, optional, 当传入 use_cache=True 或当 config.use_cache=True 时返回) — 这是一个 EncoderDecoderCache 实例。有关更多详细信息，请参阅我们的 kv 缓存指南。

    包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。

  • decoder_hidden_states (tuple(torch.FloatTensor), optional, 当传入 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

    解码器在每一层输出时的隐藏状态以及初始嵌入输出。

  • decoder_attentions (tuple(torch.FloatTensor), optional, 当传入 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。

  • cross_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (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), optional, 当传入 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 元组（一个用于嵌入的输出，如果模型有嵌入层，+ 一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

    编码器在每一层输出时的隐藏状态以及初始嵌入输出。

  • encoder_attentions (tuple(torch.FloatTensor), optional, 当传入 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均。

EncoderDecoderModel 的 forward 方法重写了 __call__ 特殊方法。

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 Module 实例而不是这个，因为前者负责运行预处理和后处理步骤，而后者会静默地忽略它们。

示例

>>> from transformers import EncoderDecoderModel, BertTokenizer
>>> import torch

>>> tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-uncased")
>>> model = EncoderDecoderModel.from_encoder_decoder_pretrained(
...     "google-bert/bert-base-uncased", "google-bert/bert-base-uncased"
... )  # initialize Bert2Bert from pre-trained checkpoints

>>> # training
>>> model.config.decoder_start_token_id = tokenizer.cls_token_id
>>> model.config.pad_token_id = tokenizer.pad_token_id
>>> model.config.vocab_size = model.config.decoder.vocab_size

>>> input_ids = tokenizer("This is a really long text", return_tensors="pt").input_ids
>>> labels = tokenizer("This is the corresponding summary", return_tensors="pt").input_ids
>>> outputs = model(input_ids=input_ids, labels=labels)
>>> loss, logits = outputs.loss, outputs.logits

>>> # save and load from pretrained
>>> model.save_pretrained("bert2bert")
>>> model = EncoderDecoderModel.from_pretrained("bert2bert")

>>> # generation
>>> generated = model.generate(input_ids)

from_encoder_decoder_pretrained

< >

( encoder_pretrained_model_name_or_path: str | None = None decoder_pretrained_model_name_or_path: str | None = None *model_args **kwargs )

参数

  • encoder_pretrained_model_name_or_path (str, 可选) — 初始化编码器所需的信息。可以是：

    • 一个字符串，即托管在 huggingface.co 的模型库中的预训练模型的模型 ID。
    • 一个包含使用 save_pretrained() 保存的模型权重的目录的路径，例如 ./my_model_directory/。
  • decoder_pretrained_model_name_or_path (str, 可选，默认为 None) — 初始化解码器所需的信息。可以是：

    • 一个字符串，即托管在 huggingface.co 的模型库中的预训练模型的模型 ID。
    • 一个包含使用 save_pretrained() 保存的模型权重的目录的路径，例如 ./my_model_directory/。
  • model_args (剩余位置参数，可选) — 所有剩余的位置参数都将传递给底层模型的 __init__ 方法。
  • kwargs (剩余关键字参数字典，可选) — 可用于在加载配置（之后）更新配置对象并初始化模型（例如，output_attentions=True）。

    • 要更新编码器配置，请为每个配置参数使用前缀 encoder_。
    • 要更新解码器配置，请为每个配置参数使用前缀 decoder_。
    • 要更新父模型配置，请不要为每个配置参数使用前缀。

    根据是否提供 config 或自动加载 config，行为会有所不同。

从库的一个或两个基类实例化一个编码器和一个解码器，这些基类来自预训练的模型检查点。

模型默认使用 model.eval() 设置为评估模式（Dropout 模块已停用）。要训练模型，您需要首先使用 model.train() 将其设置回训练模式。

示例

>>> from transformers import EncoderDecoderModel

>>> # initialize a bert2bert from two pretrained BERT models. Note that the cross-attention layers will be randomly initialized
>>> model = EncoderDecoderModel.from_encoder_decoder_pretrained("google-bert/bert-base-uncased", "google-bert/bert-base-uncased")
>>> # saving model after fine-tuning
>>> model.save_pretrained("./bert2bert")
>>> # load fine-tuned model
>>> model = EncoderDecoderModel.from_pretrained("./bert2bert")
在 GitHub 上更新

←ELECTRA ERNIE→
© . This site is unofficial and not affiliated with Hugging Face, Inc.