Hugging Face 的 LOGO

Transformers 文档

Encoder Decoder Models

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

该模型于 2017 年 6 月 12 日发布在 HF 论文中，并于 2020 年 11 月 16 日贡献给 Hugging Face Transformers。

SDPA

Encoder Decoder 模型

EncoderDecoderModel 使用任何预训练的自编码器和预训练的自回归模型来初始化序列到序列（sequence-to-sequence）模型。正如 《使用预训练编码器进行文本摘要》 中所演示的那样，它对于序列生成任务非常有效；该研究使用 BertModel 同时作为编码器和解码器。

该模型由 thomwolf 贡献。

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

下面的示例演示了如何使用 Pipeline、AutoModel 以及命令行来生成文本。

自动模型
from transformers import AutoModelForCausalLM, AutoTokenizer


tokenizer = AutoTokenizer.from_pretrained("patrickvonplaten/bert2bert-cnn_dailymail-fp16")
model = AutoModelForCausalLM.from_pretrained("patrickvonplaten/bert2bert-cnn_dailymail-fp16", device_map="auto",attn_implementation="sdpa")

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

inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True).to(model.device)

summary = model.generate(**inputs, max_length=60, num_beams=4, early_stopping=True)
print(tokenizer.decode(summary[0], skip_special_tokens=True))

注意事项

  • EncoderDecoderModel 可以使用任何预训练的编码器和解码器进行初始化。但根据解码器架构的不同，交叉注意力层（cross-attention layers）可能是随机初始化的。

这些模型需要下游微调，详见此 博文。使用 from_encoder_decoder_pretrained() 来合并编码器和解码器的检查点。

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"
)
  • Encoder Decoder 模型可以像 BART、T5 或任何其他编码器-解码器模型一样进行微调。计算损失只需要 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, device_map="auto")

# 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).to(model.device).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

< >

( transformers_version: str | None = None architectures: list[str] | None = None output_hidden_states: bool | None = False return_dict: bool | None = True dtype: typing.Union[str, ForwardRef('torch.dtype'), NoneType] = None chunk_size_feed_forward: int = 0 id2label: dict[int, str] | dict[str, str] | None = None label2id: dict[str, int] | dict[str, str] | None = None problem_type: typing.Optional[typing.Literal['regression', 'single_label_classification', 'multi_label_classification']] = None is_encoder_decoder: bool | None = True pad_token_id: int | None = None decoder_start_token_id: int | None = None )

参数

  • is_encoder_decoder (bool, optional, defaults to True) — 模型是否用作编码器/解码器。
  • pad_token_id (int, optional) — 词表中用于填充（padding）的 token id。
  • decoder_start_token_id (int, optional) — 如果编码器-解码器模型开始解码时使用的 token 与 bos 不同，则为该 token 的 id。

这是用于存储 Encoder Decoder 模型配置的配置类。它根据指定的参数实例化一个 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 **kwargs ) → Seq2SeqLMOutput 或 tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 词表中输入序列 token 的索引。填充（padding）默认会被忽略。

    索引可以使用 AutoTokenizer 获取。详情请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是输入 ID？

  • attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 避免对填充 token 索引执行注意力操作的掩码。掩码值选择范围为 [0, 1]：

    • 1 表示未被遮挡的 token，
    • 0 表示被遮挡的 token。

    什么是注意力掩码？

  • decoder_input_ids (torch.LongTensor，形状为 (batch_size, target_sequence_length)，可选) — 词表中解码器输入序列 token 的索引。

    索引可以使用 PreTrainedTokenizer 获取。详情请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

    什么是输入 ID？

    如果使用 past_key_values，则可选择仅输入最后的 decoder_input_ids（参见 past_key_values）。

    在训练时，decoder_input_ids 由模型通过将 labels 右移、将 -100 替换为 pad_token_id 并以 decoder_start_token_id 开头自动创建。

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

    仅允许输入 Cache 实例，请参见我们的 kv 缓存指南。如果未传递 past_key_values，默认将初始化 DynamicCache。

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

    如果使用 past_key_values，用户应仅输入未经处理的 input_ids（那些尚未向该模型提供其过去键值状态的输入），形状为 (batch_size, unprocessed_length)，而不是形状为 (batch_size, sequence_length) 的所有 input_ids。

  • inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 作为一个选项，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望对如何将 input_ids 索引转换为关联向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。
  • decoder_inputs_embeds (torch.FloatTensor，形状为 (batch_size, target_sequence_length, hidden_size)，可选) — 作为一个选项，您可以选择直接传递嵌入表示，而不是传递 decoder_input_ids。如果您希望对如何将 decoder_input_ids 索引转换为关联向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。
  • labels (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于计算解码器掩码语言建模损失的标签。索引应在 [-100, 0, ..., config.vocab_size] 范围内（参见 input_ids 文档字符串）。索引设置为 -100 的 token 将被忽略（遮蔽），损失仅针对标签在 [0, ..., config.vocab_size] 范围内的 token 计算。
  • use_cache (bool，可选) — 如果设置为 True，则返回 past_key_values 键值状态，并可用于加速解码（参见 past_key_values）。

返回

Seq2SeqLMOutput 或 tuple(torch.FloatTensor)

一个 Seq2SeqLMOutput 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），根据配置（EncoderDecoderConfig）和输入包含各种元素。

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

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

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

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

  • past_key_values (EncoderDecoderCache，可选，在传递了 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 之后，用于计算自注意力头中的加权平均。

示例

>>> 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 或自动加载配置，其行为会有所不同。

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

模型默认使用 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.