Transformers 4.37 中文文档（三十一）（2）

Transformers 4.37 中文文档（三十一）（1）https://developer.aliyun.com/article/1564897

FlaxEncoderDecoderModel

class transformers.FlaxEncoderDecoderModel

<来源>

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

参数

• config（EncoderDecoderConfig）— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。
  
• dtype（jax.numpy.dtype，可选，默认为jax.numpy.float32）— 计算的数据类型。可以是jax.numpy.float32、jax.numpy.float16（在 GPU 上）和jax.numpy.bfloat16（在 TPU 上）之一。
  这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定，所有计算将使用给定的dtype执行。
  “请注意，这仅指定计算的数据类型，不会影响模型参数的数据类型。”
  如果您希望更改模型参数的数据类型，请参阅 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__

<来源>

( 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实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

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

<来源>

( 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而表现不同。
  

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

示例：

>>> 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为例:

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

模型检查点

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

资源

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

ErnieConfig

class transformers.ErnieConfig

<来源>

( 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 的文档以获取更多信息。

示例：

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

<来源>

( 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

<来源>

( 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作为前向传递的输入。

前进

<来源>

( 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实例，而不是在此处调用，因为前者会处理运行前后处理步骤，而后者会默默忽略它们。

示例：

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

Transformers 4.37 中文文档（三十一）（3）https://developer.aliyun.com/article/1564899