Transformers 文档

编码器解码器模型

Transformers

加入 Hugging Face 社区

并获得增强型文档体验

协作模型、数据集和 Spaces

使用加速推理更快地运行示例

在文档主题之间切换

开始使用

编码器解码器模型

概述

可以使用 EncoderDecoderModel 初始化一个序列到序列模型，其中任何预训练的自动编码模型作为编码器，任何预训练的自回归模型作为解码器。

Sascha Rothe、Shashi Narayan 和 Aliaksei Severyn 在其论文利用预训练检查点进行序列生成任务中展示了使用预训练检查点初始化序列到序列模型以进行序列生成任务的有效性。

经过训练/微调后，此类 EncoderDecoderModel 可以像任何其他模型一样保存/加载（有关更多信息，请参阅示例）。

这种架构的一个应用可能是利用两个预训练的 BertModel 作为摘要模型的编码器和解码器，如 Yang Liu 和 Mirella Lapata 在使用预训练编码器的文本摘要中所示。

从模型配置随机初始化 EncoderDecoderModel。

EncoderDecoderModel 可以从编码器和解码器的配置中随机初始化。在下面的示例中，我们展示了如何使用 BertModel 的默认配置作为编码器，以及 BertForCausalLM 的默认配置作为解码器。

>>> 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)

从预训练的编码器和解码器初始化 EncoderDecoderModel。

EncoderDecoderModel 可以从预训练的编码器检查点和预训练的解码器检查点初始化。请注意，任何预训练的自动编码模型（例如 BERT）都可以用作编码器，而预训练的自动编码模型（例如 BERT）、预训练的因果语言模型（例如 GPT2）以及序列到序列模型的预训练解码器部分（例如 BART 的解码器）都可以用作解码器。根据您选择哪种架构作为解码器，交叉注意力层可能会被随机初始化。从预训练的编码器和解码器检查点初始化 EncoderDecoderModel 需要在后续任务上对模型进行微调，如 编码器-解码器预热启动博文 中所示。为此，EncoderDecoderModel 类提供了一个 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")

加载现有的 EncoderDecoderModel 检查点并执行推理。

要加载 EncoderDecoderModel 类的微调检查点，EncoderDecoderModel 提供了 from_pretrained(...) 方法，就像 Transformers 中的任何其他模型架构一样。

要执行推理，可以使用 generate 方法，该方法允许自动回归生成文本。此方法支持各种解码形式，例如贪婪解码、集束搜索和多项式采样。

>>> from transformers import AutoTokenizer, EncoderDecoderModel

>>> # load a fine-tuned seq2seq model and corresponding tokenizer
>>> model = EncoderDecoderModel.from_pretrained("patrickvonplaten/bert2bert_cnn_daily_mail")
>>> tokenizer = AutoTokenizer.from_pretrained("patrickvonplaten/bert2bert_cnn_daily_mail")

>>> # let's perform inference on a long piece of text
>>> ARTICLE_TO_SUMMARIZE = (
...     "PG&E stated it scheduled the blackouts in response to forecasts for high winds "
...     "amid dry conditions. The aim is to reduce the risk of wildfires. Nearly 800 thousand customers were "
...     "scheduled to be affected by the shutoffs which were expected to last through at least midday tomorrow."
... )
>>> input_ids = tokenizer(ARTICLE_TO_SUMMARIZE, return_tensors="pt").input_ids

>>> # autoregressively generate summary (uses greedy decoding by default)
>>> generated_ids = model.generate(input_ids)
>>> generated_text = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
>>> print(generated_text)
nearly 800 thousand customers were affected by the shutoffs. the aim is to reduce the risk of wildfires. nearly 800, 000 customers were expected to be affected by high winds amid dry conditions. pg & e said it scheduled the blackouts to last through at least midday tomorrow.

将 PyTorch 检查点加载到 TFEncoderDecoderModel 中。

TFEncoderDecoderModel.from_pretrained() 目前不支持从 pytorch 检查点初始化模型。将 from_pt=True 传递给此方法将引发异常。如果特定编码器-解码器模型只有 pytorch 检查点，则可以使用以下解决方法

>>> # a workaround to load from pytorch checkpoint
>>> from transformers import EncoderDecoderModel, TFEncoderDecoderModel

>>> _model = EncoderDecoderModel.from_pretrained("patrickvonplaten/bert2bert-cnn_dailymail-fp16")

>>> _model.encoder.save_pretrained("./encoder")
>>> _model.decoder.save_pretrained("./decoder")

>>> model = TFEncoderDecoderModel.from_encoder_decoder_pretrained(
...     "./encoder", "./decoder", encoder_from_pt=True, decoder_from_pt=True
... )
>>> # This is only for copying some specific attributes of this particular model.
>>> model.config = _model.config

训练

创建模型后，可以像 BART、T5 或任何其他编码器-解码器模型一样对其进行微调。如您所见，模型只需要 2 个输入即可计算损失：input_ids（即编码的输入序列的 input_ids）和 labels（即编码的目标序列的 input_ids）。

>>> 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

训练的详细 colab。

此模型由 thomwolf 贡献。此模型的 TensorFlow 和 Flax 版本由 ydshieh 贡献。

EncoderDecoderConfig

class transformers.EncoderDecoderConfig

< 源代码 >

( **kwargs )

参数

kwargs (可选) — 关键字参数字典。特别地：
- encoder (PretrainedConfig, 可选) — 定义编码器配置的配置对象实例。
- decoder (PretrainedConfig, 可选) — 定义解码器配置的配置对象实例。

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

配置对象继承自 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（或其派生类）。

Pytorch

隐藏 Pytorch 内容

EncoderDecoderModel

类 transformers.EncoderDecoderModel

< 源代码 >

( config: Optional = None encoder: Optional = None decoder: Optional = None )

参数

config (EncoderDecoderConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。

此类可用于使用任何预训练的自动编码模型作为编码器和任何预训练的自回归模型作为解码器来初始化序列到序列模型。编码器通过 from_pretrained() 函数加载，解码器通过 from_pretrained() 函数加载。交叉注意力层会自动添加到解码器中，并且应该在下游生成任务（如摘要）上进行微调。

在 Sascha Rothe、Shashi Narayan、Aliaksei Severyn、Michael Matena、Yanqi Zhou、Wei Li 和 Peter J. Liu 所著的利用预训练检查点进行序列生成任务中，展示了使用预训练检查点初始化序列到序列模型以进行序列生成任务的有效性。

经过此类编码器解码器模型的训练/微调后，可以像其他任何模型一样保存/加载它（有关更多信息，请参阅示例）。

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

此模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解与一般用法和行为相关的所有事项。

EncoderDecoderModel 是一个通用的模型类，当使用编码器的 :meth~transformers.AutoModel.from_pretrained 类方法和解码器的 :meth~transformers.AutoModelForCausalLM.from_pretrained 类方法创建时，它将被实例化为具有库中的一个基本模型类作为编码器和另一个作为解码器的 Transformer 架构。

前向传播

< 源代码 >

( input_ids: Optional = None attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None encoder_outputs: Optional = None past_key_values: Tuple = None inputs_embeds: Optional = None decoder_inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **kwargs ) → transformers.modeling_outputs.Seq2SeqLMOutput 或 tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor 形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。

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

什么是输入 ID？
attention_mask (torch.FloatTensor 形状为 (batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力操作的掩码。掩码值选择在 [0, 1] 中：
- 1 表示未被掩码的标记，
- 0 表示被掩码的标记。
什么是注意力掩码？
decoder_input_ids (torch.LongTensor 形状为 (batch_size, target_sequence_length)，可选) — 解码器输入序列标记在词汇表中的索引。

可以使用 PreTrainedTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？

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

对于训练，模型会通过将 labels 向右移动、将 -100 替换为 pad_token_id 并在其前面添加 decoder_start_token_id来自动创建 decoder_input_ids。
decoder_attention_mask (torch.BoolTensor 形状为 (batch_size, target_sequence_length)，可选) — 默认行为：生成一个张量，忽略 decoder_input_ids 中的填充标记。因果掩码也将默认使用。
encoder_outputs (tuple(torch.FloatTensor)，可选) — 此元组必须包含 (last_hidden_state，可选：hidden_states，可选：attentions) last_hidden_state (torch.FloatTensor 形状为 (batch_size, sequence_length, hidden_size)) 是编码器最后一层输出处的隐藏状态张量。用于解码器的交叉注意力。
past_key_values (长度为 config.n_layers 的 tuple(tuple(torch.FloatTensor))，每个元组包含 4 个形状为 (batch_size, num_heads, sequence_length - 1, embed_size_per_head) 的张量) — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。

如果使用 past_key_values，则用户可以选择仅输入形状为 (batch_size, 1) 的最后一个 decoder_input_ids（那些没有向该模型提供其过去键值状态的），而不是形状为 (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。如果您希望比模型的内部嵌入查找矩阵更好地控制如何将 decoder_input_ids 索引转换为关联的向量，这将非常有用。
labels (torch.LongTensor 形状为 (batch_size, sequence_length)，可选) — 用于计算解码器掩码语言建模损失的标签。索引应在 [-100, 0, ..., config.vocab_size] 中（参见 input_ids 文档字符串）索引设置为 -100 的标记将被忽略（掩码），损失仅针对标签在 [0, ..., config.vocab_size] 中的标记计算。
use_cache (bool，可选) — 如果设置为 True，则返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
return_dict (bool, 可选) — 如果设置为True，则模型将返回~utils.Seq2SeqLMOutput而不是普通元组。
kwargs (可选) — 其余关键字参数的字典。关键字参数有两种形式：
- 没有前缀，将作为**encoder_kwargs输入到编码器前向函数中。
- 带有decoder_前缀，将作为**decoder_kwargs输入到解码器前向函数中。

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

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

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)元组，每个元组有两个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量和两个形状为(batch_size, num_heads, encoder_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)。

解码器的注意力权重，在注意力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之后，用于计算自注意力头中的加权平均值。

EncoderDecoderModel 的前向方法，覆盖了__call__特殊方法。

尽管前向传递的配方需要在此函数内定义，但之后应该调用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 decoder_pretrained_model_name_or_path: str = None *model_args **kwargs )

参数

encoder_pretrained_model_name_or_path (str, 可选) — 初始化编码器的必要信息。可以是以下之一：
- 一个字符串，表示托管在 huggingface.co 上模型仓库中的预训练模型的模型 ID。
- 使用 save_pretrained() 保存的模型权重的目录路径，例如 ./my_model_directory/。
- TensorFlow 索引检查点文件的路径或 URL（例如，./tf_model/model.ckpt.index）。在这种情况下，应将 from_tf 设置为 True，并将配置对象作为 config 参数提供。此加载路径比使用提供的转换脚本将 TensorFlow 检查点转换为 PyTorch 模型，然后加载 PyTorch 模型要慢。
decoder_pretrained_model_name_or_path (str, 可选，默认为 None) — 初始化解码器的必要信息。可以是以下之一：
- 一个字符串，表示托管在 huggingface.co 上模型仓库中的预训练模型的模型 ID。
- 使用 save_pretrained() 保存的模型权重的目录路径，例如 ./my_model_directory/。
- TensorFlow 索引检查点文件的路径或 URL（例如，./tf_model/model.ckpt.index）。在这种情况下，应将 from_tf 设置为 True，并将配置对象作为 config 参数提供。此加载路径比使用提供的转换脚本将 TensorFlow 检查点转换为 PyTorch 模型，然后加载 PyTorch 模型要慢。
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")

TensorFlow

隐藏 TensorFlow 内容

TFEncoderDecoderModel

类 transformers.TFEncoderDecoderModel

< 源代码 >

( config: Optional[PretrainedConfig] = None encoder: Optional[TFPreTrainedModel] = None decoder: Optional[TFPreTrainedModel] = None )

参数

config (EncoderDecoderConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。请查看 from_pretrained() 方法以加载模型权重。

经过此类编码器解码器模型的训练/微调后，可以像其他任何模型一样保存/加载它（有关更多信息，请参阅示例）。

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

此模型也是 keras.Model 的子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以了解与一般用法和行为相关的所有事项。

TFEncoderDecoderModel 是一个通用模型类，当使用编码器的 from_pretrained() 类方法和解码器的 from_pretrained() 类方法创建时，将被实例化为一个 transformer 架构，该架构使用库的一个基本模型类作为编码器，另一个作为解码器。

调用

< 源代码 >

参数

input_ids (np.ndarray、tf.Tensor、List[tf.Tensor] `Dict[str, tf.Tensor] 或 Dict[str, np.ndarray]，每个示例必须具有形状 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。

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

什么是输入 ID？
attention_mask (形状为 (batch_size, sequence_length) 的 np.ndarray 或 tf.Tensor，可选) — 避免对填充标记索引执行注意力的掩码。在 [0, 1] 中选择掩码值：
- 1 表示未掩码的标记，
- 0 表示掩码的标记。
什么是注意力掩码？
decoder_input_ids (形状为 (batch_size, target_sequence_length) 的 np.ndarray 或 tf.Tensor，可选) — 词汇表中解码器输入序列标记的索引。

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

什么是输入 ID？

如果使用 past_key_values，则可以选择仅输入最后的 decoder_input_ids（那些没有提供给此模型的过去键值状态的）（参见 past_key_values）。

为解码器的序列到序列训练提供数据。可以使用 PreTrainedTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
decoder_attention_mask (形状为 (batch_size, target_sequence_length) 的 np.ndarray 或 tf.Tensor，可选) — 默认行为：生成一个忽略 decoder_input_ids 中填充标记的张量。因果掩码也将默认使用。
encoder_outputs (tuple(tuple(tf.Tensor)，可选) — 此元组必须由 (last_hidden_state、可选：hidden_states、可选：attentions) 组成 last_hidden_state (形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor) 是编码器最后一层输出处的隐藏状态张量。用于解码器的交叉注意力。
past_key_values (长度为 config.n_layers 的 tuple(tuple(tf.Tensor))，每个元组包含 4 个形状为 (batch_size, num_heads, sequence_length - 1, embed_size_per_head) 的张量) — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。

如果使用 past_key_values，则用户可以选择仅输入最后的 decoder_input_ids（那些没有提供给此模型的过去键值状态的），形状为 (batch_size, 1)，而不是所有 decoder_input_ids，形状为 (batch_size, sequence_length)。
inputs_embeds (np.ndarray 或 tf.Tensor 形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望对如何将 input_ids 索引转换为关联向量进行更多控制（而不是模型的内部嵌入查找矩阵），这将非常有用。
decoder_inputs_embeds (np.ndarray 或 tf.Tensor 形状为 (batch_size, target_sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 decoder_input_ids。如果您希望对如何将 decoder_input_ids 索引转换为关联向量进行更多控制（而不是模型的内部嵌入查找矩阵），这将非常有用。
labels (np.ndarray 或 tf.Tensor 形状为 (batch_size, sequence_length)，可选) — 用于计算解码器掩码语言建模损失的标签。索引应在 [-100, 0, ..., config.vocab_size] 中（请参阅 input_ids 文档字符串）索引设置为 -100 的标记将被忽略（掩码），损失仅针对标签在 [0, ..., config.vocab_size] 中的标记计算。
use_cache (bool，可选) — 如果设置为 True，则返回 past_key_values 密钥值状态，并可用于加速解码（请参阅 past_key_values）。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool，可选) — 如果设置为 True，则模型将返回 ~utils.Seq2SeqLMOutput 而不是普通元组。
training (bool，可选，默认为 False) — 是否以训练模式使用模型（某些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。
kwargs (可选) — 其余关键字参数字典。关键字参数有两种类型：
- 没有前缀的将作为 **encoder_kwargs 输入到编码器前向函数中。
- 带有 decoder_ 前缀的将作为 **decoder_kwargs 输入到解码器前向函数中。

transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或 tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFSeq2SeqLMOutput 或 tf.Tensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含取决于配置（EncoderDecoderConfig）和输入的各种元素。

loss (tf.Tensor 形状为 (n,)，可选，其中 n 是非掩码标签的数量，在提供 labels 时返回) — 语言建模损失。
logits (tf.Tensor 形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前的每个词汇标记的分数）。
past_key_values (List[tf.Tensor]，可选，在传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tf.Tensor 列表，每个张量的形状为 (2, batch_size, num_heads, sequence_length, embed_size_per_head)。

包含解码器的预计算隐藏状态（注意力块中的键和值），可用于（请参阅 past_key_values 输入）加速顺序解码。
decoder_hidden_states (tuple(tf.Tensor)，可选，在传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 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之后，用于计算自注意力头中的加权平均值。

TFEncoderDecoderModel 的前向方法覆盖了 __call__ 特殊方法。

示例

>>> from transformers import TFEncoderDecoderModel, BertTokenizer

>>> # initialize a bert2gpt2 from a pretrained BERT and GPT2 models. Note that the cross-attention layers will be randomly initialized
>>> model = TFEncoderDecoderModel.from_encoder_decoder_pretrained("google-bert/bert-base-cased", "openai-community/gpt2")

>>> tokenizer = BertTokenizer.from_pretrained("google-bert/bert-base-cased")

>>> # forward
>>> input_ids = tokenizer.encode(
...     "Hello, my dog is cute", add_special_tokens=True, return_tensors="tf"
... )  # Batch size 1
>>> outputs = model(input_ids=input_ids, decoder_input_ids=input_ids)

>>> # training
>>> outputs = model(input_ids=input_ids, decoder_input_ids=input_ids, labels=input_ids)
>>> loss, logits = outputs.loss, outputs.logits

>>> # save and load from pretrained
>>> model.save_pretrained("bert2gpt2")
>>> model = TFEncoderDecoderModel.from_pretrained("bert2gpt2")

>>> # generation
>>> generated = model.generate(input_ids, decoder_start_token_id=model.config.decoder.bos_token_id)

from_encoder_decoder_pretrained

< 源代码 >

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

参数

encoder_pretrained_model_name_or_path (str，可选) — 初始化编码器所需的信息。可以是以下之一：
- 一个字符串，表示托管在 huggingface.co 上的模型仓库中的预训练模型的模型 ID。
- 一个路径，指向使用 save_pretrained() 保存的模型权重的目录，例如 ./my_model_directory/。
- 一个路径或 URL，指向PyTorch 索引检查点文件（例如 ./pt_model/）。在这种情况下，encoder_from_pt 应设置为 True。
decoder_pretrained_model_name_or_path (str，可选，默认为 None) — 初始化解码器所需的信息。可以是以下之一：
- 一个字符串，表示托管在 huggingface.co 上的模型仓库中的预训练模型的模型 ID。
- 一个路径，指向使用 save_pretrained() 保存的模型权重的目录，例如 ./my_model_directory/。
- 一个路径或 URL，指向PyTorch 检查点文件（例如 ./pt_model/）。在这种情况下，decoder_from_pt 应设置为 True。
model_args (其余的位置参数，可选) — 所有剩余的位置参数将传递给底层模型的 __init__ 方法。
kwargs (其余的关键字参数字典，可选) — 可用于更新配置对象（加载后）并初始化模型（例如 output_attentions=True）。
- 要更新编码器配置，请为每个配置参数使用前缀encoder_。
- 要更新解码器配置，请为每个配置参数使用前缀decoder_。
- 要更新父模型配置，请不要为每个配置参数使用前缀。
根据是否提供或自动加载 config 而表现出不同的行为。

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

示例

>>> from transformers import TFEncoderDecoderModel

>>> # initialize a bert2gpt2 from two pretrained BERT models. Note that the cross-attention layers will be randomly initialized
>>> model = TFEncoderDecoderModel.from_encoder_decoder_pretrained("google-bert/bert-base-uncased", "openai-community/gpt2")
>>> # saving model after fine-tuning
>>> model.save_pretrained("./bert2gpt2")
>>> # load fine-tuned model
>>> model = TFEncoderDecoderModel.from_pretrained("./bert2gpt2")

JAX

隐藏 JAX 内容

FlaxEncoderDecoderModel

类 transformers.FlaxEncoderDecoderModel

< 源代码 >

( config: EncoderDecoderConfig input_shape: Optional = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

config (EncoderDecoderConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。
dtype (jax.numpy.dtype，可选，默认为 jax.numpy.float32) — 计算的数据类型。可以是 jax.numpy.float32、jax.numpy.float16（在 GPU 上）和 jax.numpy.bfloat16（在 TPU 上）。

这可以用于启用混合精度训练或在 GPU 或 TPU 上进行半精度推理。如果指定，所有计算都将使用给定的 dtype 执行。

请注意，这仅指定计算的 dtype，不会影响模型参数的 dtype。

如果要更改模型参数的 dtype，请参阅 to_fp16() 和 to_bf16()。

经过此类编码器解码器模型的训练/微调后，可以像其他任何模型一样保存/加载它（有关更多信息，请参阅示例）。

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

此模型也是 Flax Linen flax.nn.Module 子类。将其用作常规 Flax 模块，并参考 Flax 文档以了解与一般用法和行为相关的所有事项。

FlaxEncoderDecoderModel 是一个通用的模型类，在使用库的基本模型类的模块（flax.nn.Module）作为编码器模块和另一个作为解码器模块时，将被实例化为 Transformer 架构，当使用 :meth~transformers.FlaxAutoModel.from_pretrained 类方法创建编码器和 :meth~transformers.FlaxAutoModelForCausalLM.from_pretrained 类方法创建解码器时。

call

< 源代码 >

( input_ids: Array attention_mask: Optional = None decoder_input_ids: Optional = None decoder_attention_mask: Optional = None position_ids: Optional = None decoder_position_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None train: bool = False params: dict = None dropout_rng: PRNGKey = None ) → transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 tuple(torch.FloatTensor)

参数

input_ids (jnp.ndarray 形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。如果提供填充，默认情况下将忽略填充。

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

什么是输入 ID？
attention_mask (jnp.ndarray 形状为 (batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力的掩码。在 [0, 1] 中选择掩码值：
- 1 表示未掩码的标记，
- 0 表示掩码的标记。
什么是注意力掩码？
decoder_input_ids (jnp.ndarray 形状为 (batch_size, target_sequence_length)，可选) — 词汇表中解码器输入序列标记的索引。

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

什么是解码器输入 ID？

对于序列到序列训练，应提供 decoder_input_ids。decoder_input_ids 应在模型外部创建，方法是将 labels 向右移动，用 pad_token_id 替换 -100，并在其前面加上 decoder_start_token_id。
decoder_attention_mask (jnp.ndarray 形状为 (batch_size, target_sequence_length)，可选) — 默认行为：生成一个张量，忽略 decoder_input_ids 中的填充标记。因果掩码也将默认使用。
position_ids (numpy.ndarray 形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列标记的位置索引。在 [0, config.encoder.max_position_embeddings - 1] 范围内选择。
decoder_position_ids (numpy.ndarray 形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个解码器输入序列标记的位置索引。在 [0, config.decoder.max_position_embeddings - 1] 范围内选择。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool，可选) — 如果设置为 True，则模型将返回 ~utils.FlaxSeq2SeqLMOutput 而不是普通元组。

transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput 或 tuple(torch.FloatTensor)

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

logits (jnp.ndarray 形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
past_key_values (tuple(tuple(jnp.ndarray))，可选，在传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(jnp.ndarray) 元组，每个元组具有 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(jnp.ndarray)，可选，在传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — jnp.ndarray 的元组（一个用于嵌入的输出 + 一个用于每一层的输出），形状为 (batch_size, sequence_length, hidden_size)。

解码器在每一层输出处的隐藏状态加上初始嵌入输出。
decoder_attentions (tuple(jnp.ndarray)，可选，在传递 output_attentions=True 或当 config.output_attentions=True 时返回) — jnp.ndarray 的元组（每一层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

解码器的注意力权重，在注意力softmax之后，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(jnp.ndarray)，可选，在传递 output_attentions=True 或当 config.output_attentions=True 时返回) — jnp.ndarray 的元组（每一层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

解码器交叉注意力层的注意力权重，在注意力softmax之后，用于计算交叉注意力头中的加权平均值。
encoder_last_hidden_state (jnp.ndarray 形状为 (batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层输出处的隐藏状态序列。
encoder_hidden_states (tuple(jnp.ndarray)，可选，在传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — jnp.ndarray 的元组（一个用于嵌入的输出 + 一个用于每一层的输出），形状为 (batch_size, sequence_length, hidden_size)。

编码器在每一层输出处的隐藏状态加上初始嵌入输出。
encoder_attentions (tuple(jnp.ndarray)，可选，在传递 output_attentions=True 或当 config.output_attentions=True 时返回) — jnp.ndarray 的元组（每一层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

FlaxEncoderDecoderModel 的前向方法覆盖了 __call__ 特殊方法。

示例

>>> from transformers import FlaxEncoderDecoderModel, BertTokenizer, GPT2Tokenizer

>>> # load a fine-tuned bert2gpt2 model
>>> model = FlaxEncoderDecoderModel.from_pretrained("patrickvonplaten/bert2gpt2-cnn_dailymail-fp16")
>>> # load input & output tokenizer
>>> tokenizer_input = BertTokenizer.from_pretrained("google-bert/bert-base-cased")
>>> tokenizer_output = GPT2Tokenizer.from_pretrained("openai-community/gpt2")

>>> article = '''Sigma Alpha Epsilon is under fire for a video showing party-bound fraternity members
>>> singing a racist chant. SAE's national chapter suspended the students,
>>> but University of Oklahoma President David Boren took it a step further,
>>> saying the university's affiliation with the fraternity is permanently done.'''

>>> input_ids = tokenizer_input(article, add_special_tokens=True, return_tensors="np").input_ids

>>> # use GPT2's eos_token as the pad as well as eos token
>>> model.config.eos_token_id = model.config.decoder.eos_token_id
>>> model.config.pad_token_id = model.config.eos_token_id

>>> sequences = model.generate(input_ids, num_beams=4, max_length=12).sequences

>>> summary = tokenizer_output.batch_decode(sequences, skip_special_tokens=True)[0]
>>> assert summary == "SAS Alpha Epsilon suspended Sigma Alpha Epsilon members"

from_encoder_decoder_pretrained

< 源代码 >

( encoder_pretrained_model_name_or_path: Union = None decoder_pretrained_model_name_or_path: Union = None *model_args **kwargs )

参数

encoder_pretrained_model_name_or_path (Union[str, os.PathLike]，可选) — 初始化编码器所需的信息。可以是以下之一：
- 一个字符串，huggingface.co 上模型存储库中托管的预训练模型的模型 ID。
- 包含使用 save_pretrained() 保存的模型权重的目录的路径，例如 ./my_model_directory/。
decoder_pretrained_model_name_or_path (Union[str, os.PathLike]，可选，默认为 None) — 初始化解码器所需的信息。可以是以下之一：
- 一个字符串，huggingface.co 上模型存储库中托管的预训练模型的模型 ID。
- 包含使用 save_pretrained() 保存的模型权重的目录的路径，例如 ./my_model_directory/。
model_args (剩余的位置参数，可选) — 所有剩余的位置参数将传递给底层模型的 __init__ 方法。
kwargs (剩余的关键字参数字典，可选) — 可用于更新配置对象（加载后）并初始化模型（例如，output_attentions=True）。
- 要更新编码器配置，请为每个配置参数使用前缀 encoder_。
- 要更新解码器配置，请为每个配置参数使用前缀 decoder_。
- 要更新父模型配置，请勿为每个配置参数使用前缀。
根据是否提供 config 或自动加载，行为有所不同。

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

示例

>>> from transformers import FlaxEncoderDecoderModel

>>> # initialize a bert2gpt2 from pretrained BERT and GPT2 models. Note that the cross-attention layers will be randomly initialized
>>> model = FlaxEncoderDecoderModel.from_encoder_decoder_pretrained("google-bert/bert-base-cased", "openai-community/gpt2")
>>> # saving model after fine-tuning
>>> model.save_pretrained("./bert2gpt2")
>>> # load fine-tuned model
>>> model = FlaxEncoderDecoderModel.from_pretrained("./bert2gpt2")

< > 在 GitHub 上更新

←ELECTRA ERNIE→