Transformers 4.37 中文文档（三十一）

原文：huggingface.co/docs/transformers

编码器解码器模型

原文链接：huggingface.co/docs/transformers/v4.37.2/en/model_doc/encoder-decoder

概述

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

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

在训练/微调了这样一个 EncoderDecoderModel 之后，它可以像其他模型一样保存/加载（请参阅示例以获取更多信息）。

这种架构的一个应用可能是利用两个预训练的 BertModel 作为编码器和解码器，用于总结模型，就像在 Yang Liu 和 Mirella Lapata 的文章中展示的那样：使用预训练编码器进行文本摘要。

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

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

代码语言：javascript复制

>>> 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 需要对模型进行下游任务的微调，正如在 Warm-starting-encoder-decoder 博客文章 中所示。为此，EncoderDecoderModel 类提供了一个 EncoderDecoderModel.from_encoder_decoder_pretrained() 方法。

代码语言：javascript复制

>>> from transformers import EncoderDecoderModel, BertTokenizer

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

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

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

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

代码语言：javascript复制

>>> 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 检查点，可以使用以下解决方法：

代码语言：javascript复制

>>> # 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）。

代码语言：javascript复制

>>> from transformers import BertTokenizer, EncoderDecoderModel

>>> tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
>>> model = EncoderDecoderModel.from_encoder_decoder_pretrained("bert-base-uncased", "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

< source >

代码语言：javascript复制

( **kwargs )

参数

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

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

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

代码语言：javascript复制

>>> from transformers import BertConfig, EncoderDecoderConfig, EncoderDecoderModel

>>> # Initializing a 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 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

< source >

代码语言：javascript复制

( encoder_config: PretrainedConfig decoder_config: PretrainedConfig **kwargs ) → export const metadata = 'undefined';EncoderDecoderConfig

返回值

EncoderDecoderConfig

配置对象的实例

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

Pytorch 隐藏 Pytorch 内容

EncoderDecoderModel

class transformers.EncoderDecoderModel

< source >

代码语言：javascript复制

( 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*类方法为解码器创建实例时，将实例化为一个变压器架构。

forward

<来源>

代码语言：javascript复制

( 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 ) → export const metadata = 'undefined';transformers.modeling_outputs.Seq2SeqLMOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）- 输入序列标记在词汇表中的索引。 可以使用 PreTrainedTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）- 避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]之间：
  • 对于未被屏蔽的标记，为 1，
  • 对于被屏蔽的标记，为 0。

  什么是注意力掩码？

• decoder_input_ids（形状为(batch_size, target_sequence_length)的torch.LongTensor，可选）- 解码器输入序列标记在词汇表中的索引。 可以使用 PreTrainedTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？ 如果使用了past_key_values，则可能只需输入最后的decoder_input_ids（请参阅past_key_values）。 对于训练，模型会通过将labels向右移动，用pad_token_id替换-100，并在其前面加上decoder_start_token_id来自动创建decoder_input_ids。
• decoder_attention_mask (torch.BoolTensor，形状为(batch_size, target_sequence_length)，optional) — 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。因果掩码也将默认使用。
• encoder_outputs (tuple(torch.FloatTensor)，optional) — 此元组必须包含（last_hidden_state，optional：hidden_states，optional：attentions）last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）是编码器最后一层的隐藏状态张量。用于解码器的交叉注意力。
• 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（这些decoder_input_ids没有给出其过去键值状态的模型），而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权，以便将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。
• decoder_inputs_embeds (torch.FloatTensor，形状为(batch_size, target_sequence_length, hidden_size)，optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递decoder_input_ids。如果您想要更多控制权，以便将decoder_input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。
• labels (torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 用于计算解码器的掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]范围内（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]范围内的标记。
• use_cache (bool, optional) — 如果设置为True，则返回past_key_values键值状态，可用于加速解码（参见past_key_values）。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict (bool, optional) — 如果设置为True，模型将返回~utils.Seq2SeqLMOutput而不是普通元组。
• kwargs（optional） — 剩余的关键字参数字典。关键字参数有两种风格：
  • 不带前缀，将作为**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)元组，每个元组有 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)，可选，当传递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 之后，用于计算自注意力头中的加权平均值。
• 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 (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 模型编码器最后一层的隐藏状态序列。
• 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元组（每层一个）。 编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

代码语言：javascript复制

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

>>> tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
>>> model = EncoderDecoderModel.from_encoder_decoder_pretrained(
...     "bert-base-uncased", "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

< source >

代码语言：javascript复制

( 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，可选）— 初始化编码器所需的信息。可以是：
  • 一个字符串，预训练模型的模型 id，托管在 huggingface.co 上的模型仓库中。有效的模型 id 可以位于根级别，如bert-base-uncased，或者在用户或组织名称下命名空间，如dbmdz/bert-base-german-cased。
  • 包含使用 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。有效的模型 id 可以位于根级别，如bert-base-uncased，或者在用户或组织名称下命名空间，如dbmdz/bert-base-german-cased。
  • 包含使用 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()将其设置回训练模式。

示例：

代码语言：javascript复制

>>> 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("bert-base-uncased", "bert-base-uncased")
>>> # saving model after fine-tuning
>>> model.save_pretrained("./bert2bert")
>>> # load fine-tuned model
>>> model = EncoderDecoderModel.from_pretrained("./bert2bert")

TensorFlow 隐藏内容

TFEncoderDecoderModel

class transformers.TFEncoderDecoderModel

< source >

代码语言：javascript复制

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

参数

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

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

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

在训练/微调了这样的编码器解码器模型之后，它可以像其他模型一样保存/加载（查看示例以获取更多信息）。

这个模型继承自 TFPreTrainedModel。查看超类文档以获取库实现的所有模型的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

这个模型也是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般使用和行为相关的所有内容。

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

call

<来源>

代码语言：javascript复制

( 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 encoder_outputs: np.ndarray | tf.Tensor | None = None past_key_values: Tuple[Tuple[tf.Tensor]] | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None decoder_inputs_embeds: np.ndarray | tf.Tensor | None = None labels: np.ndarray | tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False **kwargs ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSeq2SeqLMOutput or tuple(tf.Tensor)

参数

• 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 (np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：
  • 对于未被masked的标记为 1，
  • 对于被masked的标记为 0。

  什么是注意力掩码？

• decoder_input_ids (np.ndarray or tf.Tensor of shape (batch_size, target_sequence_length), optional) — 词汇表中解码器输入序列标记的索引。 可以使用 PreTrainedTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？ 如果使用了past_key_values，可以选择仅输入最后一个decoder_input_ids（请参阅past_key_values）。 为解码器提供序列到序列训练。可以使用 PreTrainedTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
• decoder_attention_mask (np.ndarray or tf.Tensor of shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。因果掩码也将默认使用。
• encoder_outputs (tuple(tuple(tf.Tensor), optional) — 这个元组必须包含 (last_hidden_state, optional: hidden_states, optional: attentions) last_hidden_state (tf.Tensor of shape (batch_size, sequence_length, hidden_size)) 是编码器最后一层的隐藏状态张量。用于解码器的交叉注意力。
• past_key_values (tuple(tuple(tf.Tensor)) of length config.n_layers with each tuple having 4 tensors of shape (batch_size, num_heads, sequence_length - 1, embed_size_per_head)) — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。 如果使用了past_key_values，用户可以选择只输入最后一个decoder_input_ids（那些没有将过去的键值状态提供给该模型的）的形状为(batch_size, 1)，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
• inputs_embeds (np.ndarray or tf.Tensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，这是有用的，而不是使用模型的内部嵌入查找矩阵。
• decoder_inputs_embeds (np.ndarray or tf.Tensor of shape (batch_size, target_sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示，而不是传递decoder_input_ids。如果您想要更多控制权来将decoder_input_ids索引转换为相关向量，这是有用的，而不是使用模型的内部嵌入查找矩阵。
• labels (np.ndarray or tf.Tensor of shape (batch_size, sequence_length), optional) — 用于计算解码器的掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]（请参阅input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]中的标记。
• use_cache (bool, optional) — 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（请参阅past_key_values）。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states (bool，optional) — 是否返回所有层的隐藏状态。有关更多细节，请参阅返回张量下的hidden_states。
• return_dict (bool, optional) — 如果设置为True，模型将返回一个~utils.Seq2SeqLMOutput而不是一个普通的元组。
• training (bool, optional, 默认为False) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。
• kwargs (optional) — 剩余的关键字参数字典。关键字参数有两种风格：
  • 没有前缀，将作为编码器前向函数的**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,)，optional，其中 n 是未屏蔽标签的数量，当提供labels时返回） — 语言建模损失。
• logits (tf.Tensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• past_key_values (List[tf.Tensor]，optional，当传递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)，optional，当传递output_hidden_states=True或当config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 一个用于每一层的输出）。 解码器每一层的隐藏状态加上初始嵌入输出。
• decoder_attentions (tuple(tf.Tensor)，optional，当传递output_attentions=True或当config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。 解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
• cross_attentions (tuple(tf.Tensor)，optional，当传递output_attentions=True或当config.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，当传递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 之后，用于计算自注意力头中的加权平均值。

TFEncoderDecoderModel 前向方法，覆盖__call__特殊方法。

虽然前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。

示例：

代码语言：javascript复制

>>> 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("bert-base-cased", "gpt2")

>>> tokenizer = BertTokenizer.from_pretrained("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

<来源>

代码语言：javascript复制

( 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，可选）— 初始化编码器所需的信息。可以是：
  • 一个字符串，预训练模型的模型 ID，托管在 huggingface.co 上的模型存储库中。有效的模型 ID 可以位于根级别，如bert-base-uncased，或者在用户或组织名称下进行命名空间，如dbmdz/bert-base-german-cased。
  • 一个包含使用 save_pretrained()保存的模型权重的目录的路径，例如./my_model_directory/。
  • 一个pytorch 索引检查点文件的路径或 URL（例如，./pt_model/）。在这种情况下，encoder_from_pt应设置为True。
• decoder_pretrained_model_name_or_path（str，可选，默认为None）— 初始化解码器所需的信息。可以是：
  • 一个字符串，预训练模型的模型 ID，托管在 huggingface.co 上的模型存储库中。有效的模型 ID 可以位于根级别，如bert-base-uncased，或者在用户或组织名称下进行命名空间，如dbmdz/bert-base-german-cased。
  • 一个包含使用 save_pretrained()保存的模型权重的目录的路径，例如./my_model_directory/。
  • 一个pytorch 检查点文件的路径或 URL（例如，./pt_model/）。在这种情况下，decoder_from_pt应设置为True。
• model_args（剩余的位置参数，可选）— 所有剩余的位置参数将传递给基础模型的__init__方法。
• kwargs（剩余的关键字参数字典，可选）— 可用于更新配置对象（加载后）并初始化模型（例如，output_attentions=True）。
  • 要更新编码器配置，请为每个配置参数使用前缀encoder_。
  • 要更新解码器配置，请为每个配置参数使用前缀decoder_。
  • 要更新父模型配置，请不要为每个配置参数使用前缀。

  根据是否提供config或自动加载而表现不同。

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

示例：

代码语言：javascript复制

>>> 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("bert-base-uncased", "gpt2")
>>> # saving model after fine-tuning
>>> model.save_pretrained("./bert2gpt2")
>>> # load fine-tuned model
>>> model = TFEncoderDecoderModel.from_pretrained("./bert2gpt2")

JAXHide JAX 内容

FlaxEncoderDecoderModel

class transformers.FlaxEncoderDecoderModel

<来源>

代码语言：javascript复制

( 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执行。 “请注意，这仅指定计算的数据类型，不会影响模型参数的数据类型。” 如果您希望更改模型参数的数据类型，请参阅 to_fp16()和 to_bf16()。

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

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

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

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

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

FlaxEncoderDecoderModel 是一个通用的模型类，当使用:meth*transformers.FlaxAutoModel.from_pretrained*类方法为编码器创建模块（flax.nn.Module）时，将实例化为一个变压器架构，并为解码器创建另一个模块，对于解码器，使用:meth*transformers.FlaxAutoModelForCausalLM.from_pretrained*类方法。

__call__

<来源>

代码语言：javascript复制

( 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 ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxSeq2SeqLMOutput or tuple(torch.FloatTensor)

参数

• input_ids (jnp.ndarray of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。 可以使用 PreTrainedTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask (jnp.ndarray of shape (batch_size, sequence_length), optional) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：
  • 对于未被masked的标记为 1，
  • 对于被masked的标记为 0。

  什么是注意力掩码？

• decoder_input_ids (jnp.ndarray of shape (batch_size, target_sequence_length), optional) — 词汇表中解码器输入序列标记的索引。 可以使用 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 of shape (batch_size, target_sequence_length), optional) — 默认行为：生成一个忽略decoder_input_ids中填充标记的张量。默认情况下还将使用因果掩码。
• position_ids (numpy.ndarray of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.encoder.max_position_embeddings - 1]中选择。
• decoder_position_ids (numpy.ndarray of shape (batch_size, sequence_length), optional) — 每个解码器输入序列标记在位置嵌入中的位置索引。在范围[0, config.decoder.max_position_embeddings - 1]中选择。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量中的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量中的hidden_states。
• return_dict (bool, optional) — 如果设置为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 of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• past_key_values (tuple(tuple(jnp.ndarray)), optional, 当传递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), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出，一个用于每一层的输出）。 解码器在每一层输出的隐藏状态以及初始嵌入输出。
• decoder_attentions (tuple(jnp.ndarray), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。 解码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
• cross_attentions (tuple(jnp.ndarray), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。 解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
• encoder_last_hidden_state (jnp.ndarray，形状为(batch_size, sequence_length, hidden_size)，optional) — 模型编码器最后一层的隐藏状态序列。
• encoder_hidden_states (tuple(jnp.ndarray), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出，一个用于每一层的输出）。 编码器在每一层输出的隐藏状态以及初始嵌入输出。
• encoder_attentions (tuple(jnp.ndarray), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的jnp.ndarray元组（每层一个）。 编码器的注意力权重，在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

代码语言：javascript复制

>>> 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("bert-base-cased")
>>> tokenizer_output = GPT2Tokenizer.from_pretrained("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

<来源>

代码语言：javascript复制

( 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]，optional) — 初始化编码器所需的信息。可以是：
  • 字符串，huggingface.co 模型库中预训练模型的模型 id。有效的模型 id 可以位于根级别，如bert-base-uncased，或者在用户或组织名称下命名空间化，如dbmdz/bert-base-german-cased。
  • 指向包含使用 save_pretrained()保存的模型权重的目录的路径，例如，./my_model_directory/。
• decoder_pretrained_model_name_or_path（Union[str, os.PathLike]，可选，默认为None）- 初始化解码器所需的信息。可以是：
  • 一个字符串，预训练模型的模型 id，托管在 huggingface.co 模型库中。有效的模型 id 可以位于根级别，如bert-base-uncased，或者在用户或组织名称下命名空间，如dbmdz/bert-base-german-cased。
  • 指向包含使用 save_pretrained()保存的模型权重的目录的路径，例如，./my_model_directory/。
• model_args（剩余的位置参数，可选）- 所有剩余的位置参数将传递给基础模型的__init__方法。
• kwargs（剩余的关键字参数，可选）- 可用于更新配置对象（加载后）并初始化模型（例如，output_attentions=True）。
  • 更新编码器配置时，对每个配置参数使用前缀encoder_。
  • 更新解码器配置时，对每个配置参数使用前缀decoder_。
  • 要更新父模型配置，请不要对每个配置参数使用前缀。

  根据是否提供或自动加载config而表现不同。

从预训练模型检查点实例化一个编码器和一个解码器，可以使用库的一个或两个基类。

示例：

代码语言：javascript复制

>>> 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("bert-base-cased", "gpt2")
>>> # saving model after fine-tuning
>>> model.save_pretrained("./bert2gpt2")
>>> # load fine-tuned model
>>> model = FlaxEncoderDecoderModel.from_pretrained("./bert2gpt2")

ERNIE

原文链接: huggingface.co/docs/transformers/v4.37.2/en/model_doc/ernie

概述

ERNIE 是百度提出的一系列强大模型，特别在中文任务中表现出色，包括ERNIE1.0、ERNIE2.0、ERNIE3.0、ERNIE-Gram、ERNIE-health等。

这些模型由nghuyong贡献，官方代码可在PaddleNLP（在 PaddlePaddle 中）中找到。

使用示例

以ernie-1.0-base-zh为例:

代码语言：javascript复制

from transformers import AutoTokenizer, AutoModel
tokenizer = AutoTokenizer.from_pretrained("nghuyong/ernie-1.0-base-zh")
model = AutoModel.from_pretrained("nghuyong/ernie-1.0-base-zh")

模型检查点

模型名称	语言	描述
ernie-1.0-base-zh	中文	层数:12, 头数:12, 隐藏层:768
ernie-2.0-base-en	英语	层数:12, 头数:12, 隐藏层:768
ernie-2.0-large-en	英语	层数:24, 头数:16, 隐藏层:1024
ernie-3.0-base-zh	中文	层数:12, 头数:12, 隐藏层:768
ernie-3.0-medium-zh	中文	层数:6, 头数:12, 隐藏层:768
ernie-3.0-mini-zh	中文	层数:6, 头数:12, 隐藏层:384
ernie-3.0-micro-zh	中文	层数:4, 头数:12, 隐藏层:384
ernie-3.0-nano-zh	中文	层数:4, 头数:12, 隐藏层:312
ernie-health-zh	中文	层数:12, 头数:12, 隐藏层:768
ernie-gram-zh	中文	层数:12, 头数:12, 隐藏层:768

您可以在 huggingface 的模型中心找到所有支持的模型: huggingface.co/nghuyong，以及在 paddle 的官方仓库中找到模型详细信息: PaddleNLP 和 ERNIE。

资源

• 文本分类任务指南
• 标记分类任务指南
• 问答任务指南
• 因果语言建模任务指南
• 掩码语言建模任务指南
• 多选任务指南

ErnieConfig

class transformers.ErnieConfig

<来源>

代码语言：javascript复制

( vocab_size = 30522 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 512 type_vocab_size = 2 task_type_vocab_size = 3 use_task_id = False initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 0 position_embedding_type = 'absolute' use_cache = True classifier_dropout = None **kwargs )

参数

• vocab_size (int, 可选, 默认为 30522) — ERNIE 模型的词汇表大小。定义了在调用 ErnieModel 或TFErnieModel时传递的inputs_ids可以表示的不同标记数量。
• hidden_size (int, 可选, 默认为 768) — 编码器层和池化器层的维度。
• num_hidden_layers (int, 可选, 默认为 12) — Transformer 编码器中的隐藏层数量。
• num_attention_heads (int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。
• intermediate_size (int, 可选, 默认为 3072) — Transformer 编码器中“中间”（通常称为前馈）层的维度。
• hidden_act (str或Callable, 可选, 默认为"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。
• hidden_dropout_prob (float, 可选, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
• attention_probs_dropout_prob (float, 可选, 默认为 0.1) — 注意力概率的 dropout 比率。
• max_position_embeddings (int, 可选, 默认为 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如 512、1024 或 2048）。
• type_vocab_size（int，可选，默认为 2）— 在调用 ErnieModel 或TFErnieModel时传递的token_type_ids的词汇大小。
• task_type_vocab_size（int，可选，默认为 3）— ERNIE2.0/ERNIE3.0 模型的task_type_ids的词汇大小
• use_task_id（bool，可选，默认为False）— 模型是否支持task_type_ids
• initializer_range（float，可选，默认为 0.02）— 用于初始化所有权重矩阵的截断正态初始化器的标准差。
• layer_norm_eps（float，可选，默认为 1e-12）— 层归一化层使用的 epsilon。
• pad_token_id（int，可选，默认为 0）— 填充标记 id。
• position_embedding_type（str，可选，默认为"absolute"）— 位置嵌入的类型。选择"absolute"、"relative_key"、"relative_key_query"之一。对于位置嵌入，请使用"absolute"。有关"relative_key"的更多信息，请参考具有相对位置表示的自注意力（Shaw 等人）。有关"relative_key_query"的更多信息，请参考使用更好的相对位置嵌入改进 Transformer 模型（Huang 等人）中的方法 4。
• use_cache（bool，可选，默认为True）— 模型是否应返回最后的键/值注意力（并非所有模型都使用）。仅在config.is_decoder=True时相关。
• classifier_dropout（float，可选）— 分类头的丢失比率。

这是用于存储 ErnieModel 或TFErnieModel配置的配置类。它用于根据指定的参数实例化 ERNIE 模型，定义模型架构。使用默认值实例化配置将产生类似于 ERNIE nghuyong/ernie-3.0-base-zh架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

代码语言：javascript复制

>>> from transformers import ErnieConfig, ErnieModel

>>> # Initializing a ERNIE nghuyong/ernie-3.0-base-zh style configuration
>>> configuration = ErnieConfig()

>>> # Initializing a model (with random weights) from the nghuyong/ernie-3.0-base-zh style configuration
>>> model = ErnieModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

Ernie 特定输出

class transformers.models.ernie.modeling_ernie.ErnieForPreTrainingOutput

<来源>

代码语言：javascript复制

( loss: Optional = None prediction_logits: FloatTensor = None seq_relationship_logits: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )

参数

• loss（可选，在提供labels时返回，torch.FloatTensor，形状为(1,)）— 总损失，由掩码语言建模损失和下一个序列预测（分类）损失之和。
• prediction_logits（形状为(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor）— 语言建模头的预测分数（SoftMax 之前的每个词汇标记的分数）。
• seq_relationship_logits（形状为(batch_size, 2)的torch.FloatTensor）— 下一个序列预测（分类）头的预测分数（SoftMax 之前的 True/False 延续分数）。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）— torch.FloatTensor元组（一个用于嵌入输出，一个用于每一层的输出），形状为(batch_size, sequence_length, hidden_size)。 模型在每一层输出的隐藏状态加上初始嵌入输出。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

ErnieForPreTraining 的输出类型。

Ernie 模型

class transformers.ErnieModel

<来源>

代码语言：javascript复制

( config add_pooling_layer = True )

参数

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

裸 Ernie 模型变压器输出原始隐藏状态，没有特定的头部。

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

此模型还是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

该模型可以作为编码器（仅具有自注意力）以及解码器行为，此时在自注意力层之间添加了一层交叉注意力，遵循Ashish Vaswani，Noam Shazeer，Niki Parmar，Jakob Uszkoreit，Llion Jones，Aidan N. Gomez，Lukasz Kaiser 和 Illia Polosukhin 所描述的架构。

要作为解码器行为，模型需要使用配置中的is_decoder参数设置为True进行初始化。要在 Seq2Seq 模型中使用，模型需要使用is_decoder参数和add_cross_attention设置为True进行初始化；然后期望encoder_hidden_states作为前向传递的输入。

前进

<来源>

代码语言：javascript复制

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None task_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None past_key_values: 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.BaseModelOutputWithPoolingAndCrossAttentions or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask（torch.FloatTensor，形状为(batch_size, sequence_length)，可选）— 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]之间：
  • 1 表示未被masked的标记，
  • 0 表示被masked的标记。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
  • 0 对应于句子 A标记。
  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• task_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 任务类型嵌入是一种特殊嵌入，用于表示不同任务的特征，例如基于单词的预训练任务、基于结构的预训练任务和基于语义的预训练任务。我们为每个任务分配一个task_type_id，task_type_id在范围[0, config.task_type_vocab_size-1]内。
• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 什么是位置 ID？
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）- 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在[0, 1]中：
  • 1 表示头部未被掩盖，
  • 0 表示头部被掩盖。
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
• output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。
• encoder_hidden_states（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 编码器最后一层输出的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。
• encoder_attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）- 用于避免在编码器输入的填充标记索引上执行注意力。如果模型配置为解码器，则在交叉注意力中使用。掩码值选择在[0, 1]中：
  • 1 表示未被掩盖的标记，
  • 0 表示被掩盖的标记。
• 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。
• use_cache（bool，可选）- 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。

返回

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

一个 transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含根据配置（ErnieConfig）和输入而异的各种元素。

• last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
• pooler_output (torch.FloatTensor，形状为(batch_size, hidden_size)) — 经过用于辅助预训练任务的层进一步处理后，序列中第一个标记（分类标记）的最后一层隐藏状态。例如，对于 BERT 系列模型，这将返回经过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是从预训练期间的下一个句子预测（分类）目标中训练的。
• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出，如果模型有嵌入层， 一个用于每一层的输出）。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
• 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.add_cross_attention=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 解码器交叉注意力层的注意力权重，在注意力 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)的张量，如果config.is_encoder_decoder=True还有 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。 包含预先计算的隐藏状态（自注意力块中的键和值，以及如果config.is_encoder_decoder=True在交叉注意力块中）可用于加速顺序解码（查看past_key_values输入）。

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

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会处理运行前后处理步骤，而后者会默默忽略它们。

示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, ErnieModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("nghuyong/ernie-1.0-base-zh")
>>> model = ErnieModel.from_pretrained("nghuyong/ernie-1.0-base-zh")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

ErnieForPreTraining

class transformers.ErnieForPreTraining

<来源>

代码语言：javascript复制

( config )

参数

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

Ernie 模型在预训练期间顶部有两个头部：一个masked language modeling头部和一个next sentence prediction (classification)头部。

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

此模型还是一个 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

代码语言：javascript复制

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None task_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None next_sentence_label: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.ernie.modeling_ernie.ErnieForPreTrainingOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：
  • 1 对于未被masked的标记，
  • 对于被masked的标记为 0。

  什么是注意力掩码？

• token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段标记索引，用于指示输入的第一部分和第二部分。索引选择在[0, 1]中：
  • 0 对应于句子 A的标记，
  • 1 对应于句子 B的标记。

  什么是标记类型 ID？

• task_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 任务类型嵌入是一种特殊嵌入，用于表示不同任务的特征，例如基于单词的预训练任务、基于结构的预训练任务和基于语义的预训练任务。我们为每个任务分配一个task_type_id，task_type_id在范围[0, config.task_type_vocab_size-1]内。
• position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]中：
  • 1 表示头部未被masked，
  • 0 表示头部被masked。
• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。 labels (torch.LongTensor of shape (batch_size, sequence_length), 可选): 用于计算掩码语言建模损失的标签。索引应在 [-100, 0, ..., config.vocab_size] 内（参见 input_ids 文档字符串）。索引设置为 -100 的标记将被忽略（掩码），损失仅计算具有标签在 [0, ..., config.vocab_size] 内的标记 next_sentence_label (torch.LongTensor of shape (batch_size,), 可选): 用于计算下一个序列预测（分类）损失的标签。输入应为一个序列对（参见 input_ids 文档字符串）索引应在 [0, 1]:
  • 0 表示序列 B 是序列 A 的延续，
  • 1 表示序列 B 是一个随机序列。kwargs (Dict[str, any], 可选，默认为 {}): 用于隐藏已被弃用的旧参数。

返回

transformers.models.ernie.modeling_ernie.ErnieForPreTrainingOutput 或 tuple(torch.FloatTensor)

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

• loss (可选, 当提供 labels 时返回, torch.FloatTensor 形状为 (1,)) — 总损失，作为掩码语言建模损失和下一个序列预测（分类）损失的总和。
• prediction_logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头部的预测分数（在 SoftMax 之前的每个词汇标记的得分）。
• seq_relationship_logits (torch.FloatTensor of shape (batch_size, 2)) — 下一个序列预测（分类）头部的预测分数（在 SoftMax 之前的 True/False 继续得分）。
• hidden_states (tuple(torch.FloatTensor), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（一个用于嵌入的输出 一个用于每一层的输出）。 模型在每一层输出处的隐藏状态以及初始嵌入输出。
• attentions (tuple(torch.FloatTensor), 可选, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每一层一个）。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例:

代码语言：javascript复制

>>> from transformers import AutoTokenizer, ErnieForPreTraining
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("nghuyong/ernie-1.0-base-zh")
>>> model = ErnieForPreTraining.from_pretrained("nghuyong/ernie-1.0-base-zh")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> prediction_logits = outputs.prediction_logits
>>> seq_relationship_logits = outputs.seq_relationship_logits

ErnieForCausalLM

class transformers.ErnieForCausalLM

< source >

代码语言：javascript复制

( config )

参数

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

Ernie 模型在顶部带有一个语言建模头部，用于 CLM 微调。

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

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

forward

<来源>

代码语言：javascript复制

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None task_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None labels: Optional = None past_key_values: 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.CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

• input_ids（torch.LongTensor，形状为(batch_size, sequence_length)）— 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 来获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask（torch.FloatTensor，形状为(batch_size, sequence_length)，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：
  • 1 表示未被屏蔽的标记，
  • 0 表示被屏蔽的标记。

  什么是注意力掩码？

• token_type_ids（torch.LongTensor，形状为(batch_size, sequence_length)，可选）— 段标记索引，指示输入的第一部分和第二部分。索引选择在[0, 1]中：
  • 0 对应于句子 A标记，
  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• task_type_ids（torch.LongTensor，形状为(batch_size, sequence_length)，可选）— 任务类型嵌入是一种特殊嵌入，用于表示不同任务的特征，例如基于单词的预训练任务、基于结构的预训练任务和基于语义的预训练任务。我们为每个任务分配一个task_type_id，task_type_id的范围为[0, config.task_type_vocab_size-1]。
• position_ids（torch.LongTensor，形状为(batch_size, sequence_length)，可选）— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 什么是位置 ID？
• head_mask（torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选）— 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在[0, 1]之间：
  • 1 表示头部未被屏蔽，
  • 0 表示头部被屏蔽。
• inputs_embeds（torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通元组。
• encoder_hidden_states (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), 可选) — 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。
• encoder_attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), 可选) — 用于避免对编码器输入的填充标记索引执行注意力的掩码。如果模型配置为解码器，则在交叉注意力中使用。掩码值选在[0, 1]内：
  • 对于未被masked的标记为 1。
  • 对于被masked的标记为 0。
• labels (torch.LongTensor of shape (batch_size, sequence_length), 可选) — 用于计算从左到右的语言建模损失（下一个词预测）的标签。索引应在[-100, 0, ..., config.vocab_size]内（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（被masked），损失仅计算具有标签 n [0, ..., config.vocab_size]的标记。
• past_key_values (tuple(tuple(torch.FloatTensor))，长度为config.n_layers，每个元组有 4 个形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)的张量 — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。 如果使用past_key_values，用户可以选择仅输入最后一个decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）的形状为(batch_size, 1)，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
• use_cache (bool, 可选) — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。

返回

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

一个 transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含各种元素，具体取决于配置（ErnieConfig）和输入。

• loss (torch.FloatTensor of shape (1,), 可选, 当提供labels时返回) — 语言建模损失（用于下一个标记预测）。
• logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的输出 每层的输出）。 模型在每一层输出处的隐藏状态以及可选的初始嵌入输出。
• attentions (tuple(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时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 在注意力 SoftMax 之后的交叉注意力权重，用于计算交叉注意力头中的加权平均值。
• past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或当config.use_cache=True时返回） — 长度为config.n_layers的torch.FloatTensor元组的元组，每个元组包含自注意力和交叉注意力层的缓存键、值状态，如果模型用于编码器-解码器设置，则相关。只有在config.is_decoder = True时才相关。 包含预先计算的隐藏状态（注意力块中的键和值），可以用于加速顺序解码（参见past_key_values输入）。

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

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

代码语言：javascript复制

>>> import torch
>>> from transformers import AutoTokenizer, ErnieForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("nghuyong/ernie-1.0-base-zh")
>>> model = ErnieForCausalLM.from_pretrained("nghuyong/ernie-1.0-base-zh")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits

ErnieForMaskedLM

class transformers.ErnieForMaskedLM

<来源>

代码语言：javascript复制

( config )

参数

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

在顶部带有语言建模头的 Ernie 模型。

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

该模型还是一个 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有信息。

forward

<来源>

代码语言：javascript复制

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None task_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.MaskedLMOutput 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.FloatTensor，可选） — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]中：
  • 对于未被masked的标记为 1，
  • 对于被masked的标记为 0。

  注意力掩码是什么？

• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选） — 段标记索引，指示输入的第一部分和第二部分。索引选择在[0, 1]中：
  • 0 对应于一个句子 A的标记，
  • 1 对应于一个句子 B的标记。

  什么是标记类型 ID？

• task_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选） — 任务类型嵌入是一种特殊的嵌入，用于表示不同任务的特征，例如基于词的预训练任务、基于结构的预训练任务和基于语义的预训练任务。我们为每个任务分配一个task_type_id，task_type_id在范围[0, config.task_type_vocab_size-1]内。
• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选） — 每个输入序列标记在位置嵌入中的位置索引。选在范围[0, config.max_position_embeddings - 1]内。 什么是位置 ID？
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选） — 用于使自注意力模块中选择的头部失效的掩码。掩码值选在[0, 1]之间：
  • 1 表示头部是未屏蔽，
  • 0 表示头部是屏蔽。
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选） — 可选地，可以直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将很有用。
• output_attentions（bool，可选） — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
• output_hidden_states（bool，可选） — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
• return_dict（bool，可选） — 是否返回一个 ModelOutput 而不是一个普通元组。
• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选） — 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]内（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（屏蔽），损失仅计算具有标签在[0, ..., config.vocab_size]内的标记。

返回

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

一个 transformers.modeling_outputs.MaskedLMOutput 或者一个torch.FloatTensor的元组（如果传递了return_dict=False或者当config.return_dict=False时）包括不同的元素，取决于配置（ErnieConfig）和输入。

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回） — 掩码语言建模（MLM）损失。
• logits（形状为(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor） — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或者当config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出 每层的输出）。 每层模型的隐藏状态加上可选的初始嵌入输出。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或者当config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 在自注意力头中用于计算加权平均值的注意力 softmax 之后的注意力权重。

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

虽然前向传递的步骤需要在这个函数内定义，但应该在此之后调用 Module 实例，而不是这个，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, ErnieForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("nghuyong/ernie-1.0-base-zh")
>>> model = ErnieForMaskedLM.from_pretrained("nghuyong/ernie-1.0-base-zh")

>>> inputs = tokenizer("The capital of France is [MASK].", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # retrieve index of [MASK]
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]

>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
>>> tokenizer.decode(predicted_token_id)
'paris'

>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-[MASK] tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

>>> outputs = model(**inputs, labels=labels)
>>> round(outputs.loss.item(), 2)
0.88

ErnieForNextSentencePrediction

class transformers.ErnieForNextSentencePrediction

<来源>

代码语言：javascript复制

( config )

参数

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

Ernie 模型在顶部带有一个 下一个句子预测（分类） 头部。

该模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

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

forward

<来源>

代码语言：javascript复制

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None task_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **kwargs ) → export const metadata = 'undefined';transformers.modeling_outputs.NextSentencePredictorOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)） — 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 以获取详细信息。 什么是输入 ID？
• attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1]：
  • 1 用于 未被掩码 的标记，
  • 0 用于 被掩码 的标记。

  什么是注意力掩码？

• token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 指示输入的第一部分和第二部分的段标记索引。索引选择在 [0, 1]：
  • 0 对应于一个 句子 A 标记，
  • 1 对应于一个 句子 B 标记。

  什么是标记类型 ID？

• task_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 任务类型嵌入是一种特殊嵌入，用于表示不同任务的特征，例如基于词的预训练任务、基于结构的预训练任务和基于语义的预训练任务。我们为每个任务分配一个 task_type_id，task_type_id 在范围 [0, config.task_type_vocab_size-1] 中。
• position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为 [0, config.max_position_embeddings - 1]。 什么是位置 ID？
• head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在 [0, 1]：
  • 1 表示头部未被掩盖，
  • 0 表示头部被掩盖。
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。
• labels（形状为(batch_size,)的torch.LongTensor，可选）- 用于计算下一个序列预测（分类）损失的标签。输入应为一个序列对（参见input_ids文档字符串）。索引应在[0, 1]范围内：
  • 0 表示序列 B 是序列 A 的延续，
  • 1 表示序列 B 是一个随机序列。

返回

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

一个 transformers.modeling_outputs.NextSentencePredictorOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包含根据配置（ErnieConfig）和输入的各种元素。

• loss（形状为(1,)的torch.FloatTensor，可选，当提供next_sentence_label时返回）- 下一个序列预测（分类）损失。
• logits（形状为(batch_size, 2)的torch.FloatTensor）- 下一个序列预测（分类）头部的预测分数（SoftMax 之前的 True/False 继续得分）。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出 每层的输出）。 模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

尽管前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是调用此函数，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, ErnieForNextSentencePrediction
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("nghuyong/ernie-1.0-base-zh")
>>> model = ErnieForNextSentencePrediction.from_pretrained("nghuyong/ernie-1.0-base-zh")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> next_sentence = "The sky is blue due to the shorter wavelength of blue light."
>>> encoding = tokenizer(prompt, next_sentence, return_tensors="pt")

>>> outputs = model(**encoding, labels=torch.LongTensor([1]))
>>> logits = outputs.logits
>>> assert logits[0, 0] < logits[0, 1]  # next sentence was random

ErnieForSequenceClassification

class transformers.ErnieForSequenceClassification

<来源>

代码语言：javascript复制

( config )

参数

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

Ernie 模型变压器，顶部带有序列分类/回归头（池化输出的顶部线性层），例如用于 GLUE 任务。

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

此模型还是 PyTorch torch.nn.Module 的子类。 将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

代码语言：javascript复制

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None task_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

• input_ids（形状为 (batch_size, sequence_length) 的 torch.LongTensor）— 输入序列标记在词汇表中的索引。 可以使用 AutoTokenizer 获取索引。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask（形状为 (batch_size, sequence_length) 的 torch.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。 选择在 [0, 1] 中的掩码值：
  • 1 用于未被“掩码”处理的标记，
  • 0 用于被“掩码”处理的标记。

  什么是注意力掩码？

• token_type_ids（形状为 (batch_size, sequence_length) 的 torch.LongTensor，可选）— 段标记索引，指示输入的第一部分和第二部分。 索引选择在 [0, 1] 中：
  • 0 对应于 句子 A 标记，
  • 1 对应于 句子 B 标记。

  什么是标记类型 ID？

• task_type_ids（形状为 (batch_size, sequence_length) 的 torch.LongTensor，可选）— 任务类型嵌入是一种特殊的嵌入，用于表示不同任务的特征，例如基于词的预训练任务、基于结构的预训练任务和基于语义的预训练任务。 我们为每个任务分配一个 task_type_id，task_type_id 在范围 [0, config.task_type_vocab_size-1] 中。
• position_ids（形状为 (batch_size, sequence_length) 的 torch.LongTensor，可选）— 输入序列标记在位置嵌入中的位置索引。 选择范围为 [0, config.max_position_embeddings - 1]。 什么是位置 ID？
• head_mask（形状为 (num_heads,) 或 (num_layers, num_heads) 的 torch.FloatTensor，可选）— 用于使自注意力模块的选定头部失效的掩码。 选择在 [0, 1] 中的掩码值：
  • 1 表示头部未被“掩码”，
  • 0 表示头部被“掩码”。
• inputs_embeds（形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。 如果您希望更多地控制如何将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。
• labels（形状为(batch_size,)的torch.LongTensor，可选）— 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]中。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

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

虽然前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是在此之后调用，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。

ErnieForMultipleChoice

class transformers.ErnieForMultipleChoice

<来源>

代码语言：javascript复制

( config )

参数

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

Ernie 模型在顶部具有多选分类头（在池化输出的顶部和 softmax 上的线性层），例如用于 RocStories/SWAG 任务。

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

此模型还是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

代码语言：javascript复制

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None task_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.MultipleChoiceModelOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, num_choices, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask（形状为(batch_size, num_choices, sequence_length)的torch.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力的蒙版。蒙版值选在[0, 1]中：
  • 对于未屏蔽的标记，
  • 对于屏蔽的标记为 0。

  什么是注意力蒙版？

• token_type_ids（形状为(batch_size, num_choices, sequence_length)的torch.LongTensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引选在[0, 1]中：
  • 0 对应于句子 A标记，
  • 1 对应于 句子 B 标记。

  什么是 token 类型 ID？

• task_type_ids (torch.LongTensor of shape (batch_size, num_choices, sequence_length), optional) — 任务类型嵌入是一种特殊的嵌入，用于表示不同任务的特征，例如基于单词的预训练任务、基于结构的预训练任务和基于语义的预训练任务。我们为每个任务分配一个 task_type_id，task_type_id 在范围 [0, config.task_type_vocab_size-1] 中。
• position_ids (torch.LongTensor of shape (batch_size, num_choices, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。 什么是位置 ID？
• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值选定在 [0, 1]：
  • 1 表示头部是 not masked，
  • 0 表示头部是 masked。
• inputs_embeds (torch.FloatTensor of shape (batch_size, num_choices, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制权来将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。
• labels (torch.LongTensor of shape (batch_size,), optional) — 用于计算多项选择分类损失的标签。索引应在 [0, ..., num_choices-1] 范围内，其中 num_choices 是输入张量的第二维的大小。（参见上面的 input_ids）

返回值

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

一个 transformers.modeling_outputs.MultipleChoiceModelOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含各种元素，这取决于配置（ErnieConfig）和输入。

• loss (torch.FloatTensor of shape (1,), optional, 当提供 labels 时返回) — 分类损失。
• logits (torch.FloatTensor of shape (batch_size, num_choices)) — num_choices 是输入张量的第二维的大小。（参见 input_ids 上面）。 分类得分（SoftMax 之前）。
• hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（如果模型有嵌入层，则为嵌入的输出 每一层的输出）。 模型在每一层输出处的隐藏状态以及可选的初始嵌入输出。
• attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每层一个）。 注意力权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, ErnieForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("nghuyong/ernie-1.0-base-zh")
>>> model = ErnieForMultipleChoice.from_pretrained("nghuyong/ernie-1.0-base-zh")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels)  # batch size is 1

>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logits

ErnieForTokenClassification

class transformers.ErnieForTokenClassification

<来源>

代码语言：javascript复制

( config )

参数

• config（ErnieConfig）- 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

Ernie 模型在顶部带有一个标记分类头（隐藏状态输出的线性层），例如用于命名实体识别（NER）任务。

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

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

forward

<来源>

代码语言：javascript复制

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None task_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）- 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：
  • 1 表示未被掩码的标记，
  • 0 表示被掩码的标记。

  什么是注意力掩码？

• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
  • 0 表示句子 A标记，
  • 1 表示句子 B标记。

  什么是标记类型 ID？

• task_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 任务类型嵌入是一种特殊嵌入，用于表示不同任务的特征，例如基于词的预训练任务、基于结构的预训练任务和基于语义的预训练任务。我们为每个任务分配一个task_type_id，task_type_id在范围[0, config.task_type_vocab_size-1]内。
• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]范围内：
  • 1 表示头部是not masked，
  • 0 表示头部是masked。
• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 可选地，您可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
• output_hidden_states (bool，optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
• return_dict (bool，optional) — 是否返回 ModelOutput 而不是普通元组。
• labels (torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 用于计算标记分类损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。

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

虽然前向传递的方法需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

ErnieForQuestionAnswering

class transformers.ErnieForQuestionAnswering

<来源>

代码语言：javascript复制

( config )

参数

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

Ernie 模型在顶部具有一个用于提取问答任务的跨度分类头，例如 SQuAD（在隐藏状态输出的顶部有线性层，用于计算span start logits和span end logits）。

此模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

此模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

代码语言：javascript复制

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None task_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None start_positions: Optional = None end_positions: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None )

参数

• input_ids (torch.LongTensor，形状为(batch_size, sequence_length)） — 词汇表中输入序列标记的索引。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask (torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：
  • 1 表示未被掩码的标记，
  • 0 表示被掩码的标记。

  什么是注意力掩码？

• token_type_ids (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 分段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：
  • 0 对应于句子 A标记，
  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• task_type_ids (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 任务类型嵌入是一种特殊嵌入，用于表示不同任务的特征，例如基于词的预训练任务、基于结构的预训练任务和基于语义的预训练任务。我们为每个任务分配一个task_type_id，task_type_id在范围[0, config.task_type_vocab_size-1]内。
• position_ids (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使自注意力模块的特定头部失效的掩码。掩码值在[0, 1]中选择：
  • 1 表示头部未被掩码，
  • 0 表示头部被掩码。
• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
• 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，形状为(batch_size,)，可选) — 用于计算标记分类损失的标记跨度结束位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。超出序列范围的位置不会计入损失的计算。

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

尽管前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

ErnieM

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/ernie_m

概述

ErnieM 模型是由欧阳璇、王硕欢、庞超、孙宇、田浩、吴华、王海峰在ERNIE-M:通过将跨语言语义与单语语料库对齐来增强多语言表示中提出的。

论文摘要如下：

*最近的研究表明，预训练的跨语言模型在下游跨语言任务中取得了令人印象深刻的性能。这种改进得益于学习大量的单语和平行语料库。尽管普遍认为平行语料对于提高模型性能至关重要，但现有方法往往受到平行语料规模的限制，特别是对于低资源语言。在本文中，我们提出了 ERNIE-M，一种新的训练方法，鼓励模型将多种语言的表示与单语语料库对齐，以克服平行语料规模对模型性能的限制。我们的关键见解是将反向翻译集成到预训练过程中。我们在单语语料库上生成伪平行句对，以便学习不同语言之间的语义对齐，从而增强跨语言模型的语义建模。实验结果表明，ERNIE-M 优于现有的跨语言模型，并在各种跨语言下游任务中取得了新的最先进结果。*此模型由Susnato Dhar贡献。原始代码可以在这里找到。

使用提示

• Ernie-M 是类似 BERT 的模型，因此是堆叠的 Transformer 编码器。
• 作者们没有像 BERT 那样使用 MaskedLM 进行预训练，而是使用了两种新技术：交叉注意力遮蔽语言建模和反向翻译遮蔽语言建模。目前这两个 LMHead 目标在这里没有实现。
• 这是一个多语言语言模型。
• 下一句预测在预训练过程中没有使用。

资源

• 文本分类任务指南
• 标记分类任务指南
• 问答任务指南
• 多项选择任务指南

ErnieM 配置

class transformers.ErnieMConfig

<来源>

代码语言：javascript复制

( vocab_size: int = 250002 hidden_size: int = 768 num_hidden_layers: int = 12 num_attention_heads: int = 12 intermediate_size: int = 3072 hidden_act: str = 'gelu' hidden_dropout_prob: float = 0.1 attention_probs_dropout_prob: float = 0.1 max_position_embeddings: int = 514 initializer_range: float = 0.02 pad_token_id: int = 1 layer_norm_eps: float = 1e-05 classifier_dropout = None act_dropout = 0.0 **kwargs )

参数

• vocab_size（int，可选，默认为 250002）— inputs_ids在 ErnieMModel 中的词汇大小。也是标记嵌入矩阵的词汇大小。定义了在调用 ErnieMModel 时可以表示的不同标记数量。
• hidden_size（int，可选，默认为 768）— 嵌入层、编码器层和池化层的维度。
• num_hidden_layers（int，可选，默认为 12）— Transformer 编码器中的隐藏层数。
• num_attention_heads（int，可选，默认为 12）— Transformer 编码器中每个注意力层的注意力头数。
• intermediate_size（int，可选，默认为 3072）— 编码器中前馈（ff）层的维度。输入张量首先从 hidden_size 投影到 intermediate_size，然后再投影回 hidden_size。通常 intermediate_size 大于 hidden_size。
• hidden_act (str, optional, defaults to "gelu") — 前馈层中的非线性激活函数。支持 "gelu"、"relu" 和其他 torch 支持的激活函数。
• hidden_dropout_prob (float, optional, defaults to 0.1) — 嵌入和编码器中所有全连接层的丢弃概率。
• attention_probs_dropout_prob (float, optional, defaults to 0.1) — 所有编码器层中 MultiHeadAttention 中使用的 dropout 概率，用于丢弃一些注意力目标。
• max_position_embeddings (int, optional, defaults to 514) — 位置编码维度的最大值，决定了输入序列的最大支持长度。
• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的正态初始化器的标准差。标记词汇表中填充标记的索引。
• pad_token_id (int, optional, defaults to 1) — 填充标记 ID。
• layer_norm_eps (float, optional, defaults to 1e-05) — 层归一化层使用的 epsilon。
• classifier_dropout (float, optional) — 分类头的丢弃比率。
• act_dropout (float, optional, defaults to 0.0) — 此丢弃概率用于激活后的 ErnieMEncoderLayer。

这是用于存储 ErnieMModel 配置的配置类。它用于根据指定的参数实例化 Ernie-M 模型，定义模型架构。使用默认值实例化配置将产生类似于 Ernie-M susnato/ernie-m-base_pytorch 架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档获取更多信息。

普通初始化器将权重矩阵初始化为正态分布。查看 ErnieMPretrainedModel._init_weights() 以了解在 ErnieMModel 中如何初始化权重。

ErnieMTokenizer

class transformers.ErnieMTokenizer

<来源>

代码语言：javascript复制

( sentencepiece_model_ckpt vocab_file = None do_lower_case = False encoding = 'utf8' unk_token = '[UNK]' sep_token = '[SEP]' pad_token = '[PAD]' cls_token = '[CLS]' mask_token = '[MASK]' sp_model_kwargs: Optional = None **kwargs )

参数

• sentencepiece_model_file (str) — sentencepiece 模型文件路径。
• vocab_file (str, optional) — 词汇表的文件路径。
• do_lower_case (str, optional, defaults to True) — 在分词时是否将输入转换为小写。
• unk_token (str, optional, defaults to "[UNK]") — 代表 未知（词汇外） 的特殊标记。未知标记被设置为 unk_token 以便转换为 ID。
• sep_token (str, optional, defaults to "[SEP]") — 用于分隔同一输入中的两个不同句子的特殊标记。
• pad_token (str, optional, defaults to "[PAD]") — 用于使标记数组大小相同以进行批处理的特殊标记。
• cls_token (str, optional, defaults to "[CLS]") — 用于序列分类的特殊标记。在构建带有特殊标记的序列时，它是序列的最后一个标记。
• mask_token (str, optional, defaults to "[MASK]") — 代表掩码标记的特殊标记。这是在掩码语言建模任务中使用的标记，模型尝试预测原始未掩码的标记。

构建 Ernie-M 分词器。它使用 sentencepiece 工具将单词切分为子词。

build_inputs_with_special_tokens

<来源>

代码语言：javascript复制

( token_ids_0 token_ids_1 = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0（List[int]）- 将添加特殊标记的 ID 列表。
• token_ids_1（List[int]，可选）- 第二个序列对应的 ID 列表。

返回

List[int]

带有适当特殊标记的 input_id 列表。

从一个序列或一对序列构建模型输入，用于序列分类任务，通过连接和添加特殊标记。ErnieM 序列具有以下格式：

• 单个序列：[CLS] X [SEP]
• 一对序列：[CLS] A [SEP] [SEP] B [SEP]

get_special_tokens_mask

<来源>

代码语言：javascript复制

( token_ids_0 token_ids_1 = None already_has_special_tokens = False ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0（List[int]）- 第一个序列的 ID 列表。
• token_ids_1（List[int]，可选）- 第二个序列对应的 ID 列表。
• already_has_special_tokens（str，可选，默认为False）- 标记列表是否已经使用特殊标记格式化。

返回

List[int]

范围为[0, 1]的整数列表：特殊标记为 1，序列标记为 0。

从没有添加特殊标记的标记列表中检索序列 id。在使用 tokenizer encode方法添加特殊标记时调用此方法。

create_token_type_ids_from_sequences

<来源>

代码语言：javascript复制

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0（List[int]）- 第一个标记化序列。
• token_ids_1（List[int]，可选）- 第二个标记化序列。

返回

List[int]

标记类型 ID。

创建与传递的序列相对应的 token 类型 ID。什么是 token 类型 ID？ 如果模型有一种特殊的构建方式，应该在子类中重写这些。

save_vocabulary

<来源>

代码语言：javascript复制

( save_directory: str filename_prefix: Optional = None )

ErnieMModel

class transformers.ErnieMModel

<来源>

代码语言：javascript复制

( config add_pooling_layer = True )

参数

• config（ErnieMConfig](/docs/transformers/v4.37.2/en/main_classes/model#transformers.PreTrainedModel.from_pretrained)方法以加载模型权重。

裸的 ErnieM 模型变压器输出原始隐藏状态，没有特定的头部。

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

此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

代码语言：javascript复制

( input_ids: Optional = None position_ids: Optional = None attention_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None past_key_values: Optional = None use_cache: Optional = None output_hidden_states: Optional = None output_attentions: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）- 词汇表中输入序列标记的索引。 可以使用 ErnieMTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：
  • 1 表示未被遮蔽的标记，
  • 0 表示被遮蔽的标记。

  什么是注意力遮罩？

• position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 什么是位置 ID？
• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在[0, 1]之间：
  • 1 表示头部未被遮蔽，
  • 0 表示头部被遮蔽。
• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。

返回

transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions 或torch.FloatTensor元组

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

• last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的输出中的隐藏状态序列。 如果仅使用past_key_values，则输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。
• 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)的张量，以及如果config.is_encoder_decoder=True还有 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。 包含预先计算的隐藏状态（自注意力块中的键和值，以及在交叉注意力块中如果config.is_encoder_decoder=True的情况下）可用于加速顺序解码（请参见past_key_values输入）。
• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入层的输出，如果模型有嵌入层， 一个用于每一层的输出）。 模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
• attentions（tuple(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.add_cross_attention=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

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

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, ErnieMModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("susnato/ernie-m-base_pytorch")
>>> model = ErnieMModel.from_pretrained("susnato/ernie-m-base_pytorch")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

ErnieMForSequenceClassification

class transformers.ErnieMForSequenceClassification

<来源>

代码语言：javascript复制

( config )

参数

• config（ErnieMConfig）- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

ErnieM 模型变压器，顶部带有序列分类/回归头（汇总输出的顶部线性层），例如用于 GLUE 任务。

此模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（例如下载或保存，调整输入嵌入，修剪头等）。

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

forward

<来源>

代码语言：javascript复制

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None past_key_values: Optional = None use_cache: Optional = None output_hidden_states: Optional = None output_attentions: Optional = None return_dict: Optional = True labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）- 词汇表中输入序列标记的索引。 可以使用 ErnieMTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：
  • 对于未被屏蔽的标记为 1，
  • 对于被屏蔽的标记为 0。

  什么是注意力掩码？

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值选在[0, 1]范围内：
  • 1 表示头部未被掩盖，
  • 0 表示头部被掩盖。
• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的hidden_states。
• return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。
• labels (torch.LongTensor of shape (batch_size,), optional) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回

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

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

• loss (torch.FloatTensor of shape (1,), optional, 当提供labels时返回) — 分类（或回归，如果config.num_labels==1）损失。
• logits (torch.FloatTensor of shape (batch_size, config.num_labels)) — 分类（或回归，如果config.num_labels==1）分数（SoftMax 之前）。
• hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入层的输出，如果模型有嵌入层， 一个用于每一层的输出）。 模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
• attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

ErnieMForSequenceClassification 前向方法，覆盖__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

单标签分类示例：

代码语言：javascript复制

>>> import torch
>>> from transformers import AutoTokenizer, ErnieMForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("susnato/ernie-m-base_pytorch")
>>> model = ErnieMForSequenceClassification.from_pretrained("susnato/ernie-m-base_pytorch")

>>> 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 = ErnieMForSequenceClassification.from_pretrained("susnato/ernie-m-base_pytorch", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss

多标签分类示例：

代码语言：javascript复制

>>> import torch
>>> from transformers import AutoTokenizer, ErnieMForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("susnato/ernie-m-base_pytorch")
>>> model = ErnieMForSequenceClassification.from_pretrained("susnato/ernie-m-base_pytorch", 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 = ErnieMForSequenceClassification.from_pretrained(
...     "susnato/ernie-m-base_pytorch", 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).loss

ErnieMForMultipleChoice

class transformers.ErnieMForMultipleChoice

<来源>

代码语言：javascript复制

( config )

参数

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

ErnieM 模型在顶部具有一个多选分类头（在汇总输出的顶部和 softmax 上的线性层），例如用于 RocStories/SWAG 任务。

这个模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

这个模型是 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

代码语言：javascript复制

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = True ) → export const metadata = 'undefined';transformers.modeling_outputs.MultipleChoiceModelOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor of shape (batch_size, num_choices, sequence_length)) — 词汇表中输入序列标记的索引。 可以使用 ErnieMTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。 什么是输入 ID？
• attention_mask (torch.FloatTensor of shape (batch_size, num_choices, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：
  • 对于未被masked的标记，为 1。
  • 对于被masked的标记，为 0。

  什么是注意力掩码？

• position_ids (torch.LongTensor of shape (batch_size, num_choices, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 什么是位置 ID？
• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在[0, 1]之间：
  • 1 表示头部未被masked。
  • 0 表示头部被masked。
• inputs_embeds (torch.FloatTensor of shape (batch_size, num_choices, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回的张量下的attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回的张量下的hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
• labels（形状为(batch_size,)的torch.LongTensor，可选）- 用于计算多选分类损失的标签。索引应在[0, ..., num_choices-1]范围内，其中num_choices是输入张量第二维的大小。（参见上面的input_ids）

返回

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

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

• loss（形状为*(1,)*的torch.FloatTensor，可选，当提供labels时返回）- 分类损失。
• logits（形状为(batch_size, num_choices)的torch.FloatTensor）- num_choices是输入张量的第二维。（参见上面的input_ids）。 分类分数（SoftMax 之前）。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的输出 每层的输出）。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, ErnieMForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("susnato/ernie-m-base_pytorch")
>>> model = ErnieMForMultipleChoice.from_pretrained("susnato/ernie-m-base_pytorch")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels)  # batch size is 1

>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logits

ErnieMForTokenClassification

class transformers.ErnieMForTokenClassification

<来源>

代码语言：javascript复制

( config )

参数

• config（ErnieMConfig）- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

ErnieM 模型，顶部带有一个标记分类头（隐藏状态输出的顶部线性层），例如用于命名实体识别（NER）任务。

这个模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

这个模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

<来源>

代码语言：javascript复制

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None past_key_values: Optional = None output_hidden_states: Optional = None output_attentions: Optional = None return_dict: Optional = True labels: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.TokenClassifierOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。 可以使用 ErnieMTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：
  • 对于未被掩码的标记为 1，
  • 对于被掩码的标记为 0。

  什么是注意力掩码？

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 什么是位置 ID？
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]之间：
  • 1 表示头部未被掩码，
  • 0 表示头部被掩码。
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，可以直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通的元组。
• labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 用于计算标记分类损失的标签。索引应在[0, ..., config.num_labels - 1]之间。

返回

transformers.modeling_outputs.TokenClassifierOutput 或者tuple(torch.FloatTensor)

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

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）— 分类损失。
• logits（形状为(batch_size, sequence_length, config.num_labels)的torch.FloatTensor）— SoftMax 之前的分类分数。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或者当config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出 每一层的输出）。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） - 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组。 在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

虽然前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, ErnieMForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("susnato/ernie-m-base_pytorch")
>>> model = ErnieMForTokenClassification.from_pretrained("susnato/ernie-m-base_pytorch")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_token_class_ids = logits.argmax(-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss

ErnieM 用于问答

class transformers.ErnieMForQuestionAnswering

<来源>

代码语言：javascript复制

( config )

参数

• config（ErnieMConfig） - 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

ErnieM 模型，顶部带有一个用于提取式问答任务（如 SQuAD）的跨度分类头（在隐藏状态输出的顶部有线性层，用于计算span start logits和span end logits）。

这个模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

这个模型是 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

forward

<来源>

代码语言：javascript复制

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None start_positions: Optional = None end_positions: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = True ) → export const metadata = 'undefined';transformers.modeling_outputs.QuestionAnsweringModelOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor） - 词汇表中输入序列 token 的索引。 可以使用 ErnieMTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()获取详细信息。 什么是输入 ID？
• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选） - 用于避免在填充 token 索引上执行注意力的 mask。选择的 mask 值在[0, 1]中：
  • 1 表示未被masked的 tokens，
  • 0 表示被masked的 tokens。

  什么是注意力 mask？

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选） - 每个输入序列 token 在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选） - 用于使自注意力模块的选定头部失效的 mask。选择的 mask 值在[0, 1]中：
  • 1 表示头部未被masked，
  • 0 表示头部被masked。
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的attentions。
• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的hidden_states。
• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。
• start_positions（形状为(batch_size,)的torch.LongTensor，可选）- 用于计算标记跨度的开始位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。序列外的位置不会被考虑在内以计算损失。
• end_positions（形状为(batch_size,)的torch.LongTensor，可选）- 用于计算标记跨度的结束位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。序列外的位置不会被考虑在内以计算损失。

返回

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

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

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）- 总跨度提取损失是开始和结束位置的交叉熵之和。
• start_logits（形状为(batch_size, sequence_length)的torch.FloatTensor）- 跨度开始得分（SoftMax 之前）。
• end_logits（形状为(batch_size, sequence_length)的torch.FloatTensor）- 跨度结束得分（SoftMax 之前）。
• hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）- 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出加上每层的输出）。 模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
• attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 注意力权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

虽然前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是在此之后调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

代码语言：javascript复制

>>> from transformers import AutoTokenizer, ErnieMForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("susnato/ernie-m-base_pytorch")
>>> model = ErnieMForQuestionAnswering.from_pretrained("susnato/ernie-m-base_pytorch")

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

ErnieMForInformationExtraction

class transformers.ErnieMForInformationExtraction

< source >

代码语言：javascript复制

( config )

参数

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

ErnieMForInformationExtraction 是一个 Ernie-M 模型，其顶部有两个线性层，用于计算 start_prob 和 end_prob，设计用于通用信息提取。

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

此模型是 PyTorch torch.nn.Module 的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

forward

< source >

代码语言：javascript复制

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None start_positions: Optional = None end_positions: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = True )

参数

• input_ids (torch.LongTensor of shape (batch_size, num_choices, sequence_length)) — 词汇表中输入序列标记的索引。 可以使用 ErnieMTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。 什么是输入 ID？
• attention_mask (torch.FloatTensor of shape (batch_size, num_choices, sequence_length), optional) — 遮蔽以避免在填充标记索引上执行注意力。遮罩值选择在 [0, 1]：
  • 1 表示未被遮蔽的标记，
  • 0 表示被遮蔽的标记。

  什么是注意力遮罩？

• position_ids (torch.LongTensor of shape (batch_size, num_choices, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为 [0, config.max_position_embeddings - 1]。 什么是位置 ID？
• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部无效的遮罩。遮罩值选择在 [0, 1]：
  • 1 表示头部未被遮蔽，
  • 0 表示头部被遮蔽。
• inputs_embeds (torch.FloatTensor of shape (batch_size, num_choices, sequence_length, hidden_size), optional) — 可选，可以直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制权，以便将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
• output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
• output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
• return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
• start_positions（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 用于计算起始位置损失的位置（索引）标签。序列之外的位置不会计入损失的计算。
• end_positions（形状为(batch_size,)的torch.LongTensor，可选）- 用于计算结束位置损失的位置（索引）标签。序列之外的位置不会计入损失的计算。

ErnieMForInformationExtraction 的前向方法重写了__call__特殊方法。

尽管前向传播的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是这个函数，因为前者负责运行预处理和后处理步骤，而后者则会默默地忽略它们。

torch 模型 配置 索引 size

0 人点赞