Transformers 4.37 中文文档（三十七）（5）-阿里云开发者社区

Transformers 4.37 中文文档（三十七）（4）https://developer.aliyun.com/article/1564733

TFGPT2ForSequenceClassification

`class transformers.TFGPT2ForSequenceClassification`

( config *inputs **kwargs )

参数

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

GPT2 模型变压器，顶部带有序列分类头（线性层）。

TFGPT2ForSequenceClassification 使用最后一个标记进行分类，就像其他因果模型（例如 GPT-1）一样。

由于它对最后一个标记进行分类，因此需要知道最后一个标记的位置。如果在配置中定义了pad_token_id，则会找到每行中不是填充标记的最后一个标记。如果未定义pad_token_id，则会简单地取批次中每行的最后一个值。当传递inputs_embeds而不是input_ids时，无法猜测填充标记，因此会执行相同操作（取批次中每行的最后一个值）。

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

该模型也是tf.keras.Model的子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取有关一般用法和行为的所有相关信息。

transformers中的 TensorFlow 模型和层接受两种格式的输入：

将所有输入作为关键字参数（类似于 PyTorch 模型），或
将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用model.fit()等方法时，您应该可以“轻松使用” - 只需以model.fit()支持的任何格式传递您的输入和标签！但是，如果您想在 Keras 方法之外使用第二种格式，比如在使用 KerasFunctional API 创建自己的层或模型时，有三种可能性可以用来收集所有输入张量在第一个位置参数中：

仅包含input_ids的单个张量，没有其他内容：model(input_ids)
一个长度不同的列表，其中包含按照文档字符串中给定的顺序的一个或多个输入张量：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])
一个字典，其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意，当使用子类化创建模型和层时，您不需要担心这些问题，因为您可以像将输入传递给任何其他 Python 函数一样传递输入！

`call`

<来源>

( input_ids: TFModelInputType | None = None past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: 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 labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSequenceClassifierOutputWithPast or tuple(tf.Tensor)

参数

input_ids（形状为(batch_size, input_ids_length)的Numpy array或tf.Tensor） - input_ids_length = 如果past_key_values为None，则为sequence_length，否则为past_key_values[0].shape[-2]（输入过去键值状态的序列长度）。词汇表中输入序列标记的索引。
如果使用了past_key_values，则只有那些尚未计算其过去的输入 ID 应该作为input_ids传递。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。
什么是输入 ID？
past_key_values（长度为config.n_layers的List[tf.Tensor]） - 包含由模型计算的预先计算的隐藏状态（注意力块中的键和值），如模型计算的（请参见下面的past_key_values输出）。可用于加速顺序解码。已经计算过其过去的令牌 ID 不应作为输入 ID 传递，因为它们已经被计算过。
attention_mask（形状为(batch_size, sequence_length)的tf.Tensor或Numpy array，可选） - 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：

1 表示未被掩码的标记，
0 表示被掩码的标记。

如果使用了past_key_values，则attention_mask需要包含用于past_key_values的掩码策略。换句话说，attention_mask始终必须具有长度：len(past_key_values) + len(input_ids)
什么是注意力掩码？
token_type_ids（形状为(batch_size, sequence_length)的tf.Tensor或Numpy array，可选） - 段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：

0 对应于句子 A的标记，
1 对应于句子 B的标记。

什么是标记类型 ID？
position_ids（形状为(batch_size, sequence_length)的tf.Tensor或Numpy array，可选） - 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。
什么是位置 ID？
head_mask (Numpy 数组 或 tf.Tensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于使自注意力模块的选定头部失效的掩码。掩码值选定在 [0, 1]：

1 表示头部未被“掩盖”。
0 表示头部被“掩盖”。

inputs_embeds (tf.Tensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选择直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的 attentions。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。
training (bool，可选，默认为 False) — 是否在训练模式下使用模型（某些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。
labels (tf.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于计算交叉熵分类损失的标签。索引应在 [0, ..., config.vocab_size - 1]。

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

一个 transformers.modeling_tf_outputs.TFSequenceClassifierOutputWithPast 或一个 tf.Tensor 元组（如果传递 return_dict=False 或 config.return_dict=False 或 config.return_dict=False）包含根据配置（GPT2Config）和输入而异的各种元素。

loss (tf.Tensor，形状为 (batch_size, )，可选，当提供 labels 时返回) — 分类（如果 config.num_labels==1 则为回归）损失。
logits (tf.Tensor，形状为 (batch_size, config.num_labels)） — 分类（如果 config.num_labels==1 则为回归）得分（SoftMax 之前）。
past_key_values (List[tf.Tensor]，可选，当传递 use_cache=True 或 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tf.Tensor 列表，每个张量的形状为 (2, batch_size, num_heads, sequence_length, embed_size_per_head)。
包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码。
hidden_states (tuple(tf.Tensor)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 元组（一个用于嵌入的输出 + 一个用于每层的输出）。
模型在每个层的输出处的隐藏状态加上初始嵌入输出。
attentions (tuple(tf.Tensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每层一个）。
注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, TFGPT2ForSequenceClassification
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/DialogRPT-updown")
>>> model = TFGPT2ForSequenceClassification.from_pretrained("microsoft/DialogRPT-updown")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> logits = model(**inputs).logits
>>> predicted_class_id = int(tf.math.argmax(logits, axis=-1)[0])

>>> # 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 = TFGPT2ForSequenceClassification.from_pretrained("microsoft/DialogRPT-updown", num_labels=num_labels)
>>> labels = tf.constant(1)
>>> loss = model(**inputs, labels=labels).loss

TFSequenceClassifierOutputWithPast

`class transformers.modeling_tf_outputs.TFSequenceClassifierOutputWithPast`

<来源>

( loss: tf.Tensor | None = None logits: tf.Tensor = None past_key_values: List[tf.Tensor] | None = None hidden_states: Tuple[tf.Tensor] | None = None attentions: Tuple[tf.Tensor] | None = None )

参数

loss (tf.Tensor，形状为(batch_size, )，可选，当提供labels时返回) — 分类（如果config.num_labels==1则为回归）损失。
logits (tf.Tensor，形状为(batch_size, config.num_labels)) — 分类（如果config.num_labels==1则为回归）得分（SoftMax 之前）。
past_key_values (List[tf.Tensor], 可选，当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。
包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码。
hidden_states (tuple(tf.Tensor), 可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 + 一个用于每个层的输出）。
模型在每个层的输出状态加上初始嵌入输出。
attentions (tuple(tf.Tensor), 可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每个层一个）。
在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

句子分类模型输出的基类。

TFGPT2Tokenizer

`class transformers.TFGPT2Tokenizer`

<来源>

( vocab: Dict merges: List max_length: int = None pad_token_id: int = None )

参数

vocab (Dict[str, int]) — 字节对编码器的词汇表字典
merges (List[str]) — 字节对编码器的合并列表

这是 GPT2 的图内分词器。它应该类似于其他分词器进行初始化，使用from_pretrained()方法。也可以使用from_tokenizer()方法进行初始化，该方法从现有标准分词器对象导入设置。

与其他 Hugging Face 分词器不同，图内分词器实际上是 Keras 层，设计为在调用模型时运行，而不是在预处理期间运行。因此，它们的选项比标准分词器类稍微有限。当您想要创建一个直接从tf.string输入到输出的端到端模型时，它们最有用。

`from_config`

<来源>

( config )

参数

config (Dict) — 具有get_config中所述键的字典。

从配置创建 TFGPT2Tokenizer

`from_pretrained`

<来源>

( pretrained_model_name_or_path: Union *init_inputs **kwargs )

参数

pretrained_model_name_or_path (Union[str, os.PathLike]) — 预训练模型的路径

从预训练的 GPT2Tokenizer 创建 TFGPT2Tokenizer

示例：

from transformers import TFGPT2Tokenizer
tf_tokenizer = TFGPT2Tokenizer.from_pretrained("gpt2")

`from_tokenizer`

<来源>

( tokenizer: GPT2Tokenizer *args **kwargs )

参数

tokenizer (GPT2Tokenizer) —

从 GPT2Tokenizer 创建 TFGPT2Tokenizer

示例：

from transformers import AutoTokenizer, TFGPT2Tokenizer
tokenizer = AutoTokenizer.from_pretrained("gpt2")
tf_tokenizer = TFGPT2Tokenizer.from_tokenizer(tokenizer)

JAXHide JAX 内容

FlaxGPT2Model

`class transformers.FlaxGPT2Model`

<来源>

( config: GPT2Config input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

config（GPT2Config）— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 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()。

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

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

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

最后，此模型支持内在的 JAX 功能，例如：

`call`

<来源>

( input_ids attention_mask = None position_ids = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None params: dict = None past_key_values: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPastAndCrossAttentions or tuple(torch.FloatTensor)

参数

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

1 表示“未屏蔽”的标记，
0 表示“屏蔽”的标记。

什么是注意力掩码？
position_ids（形状为(batch_size, sequence_length)的numpy.ndarray，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。
past_key_values (Dict[str, np.ndarray], optional, returned by init_cache or when passing previous past_key_values) — 预先计算的隐藏状态的字典（注意力块中的键和值），可用于快速自回归解码。预先计算的键和值隐藏状态的形状为 [batch_size, max_length]。
output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

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

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

last_hidden_state (jnp.ndarray，形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层的输出隐藏状态序列。
如果使用 past_key_values，则仅输出形状为 (batch_size, 1, hidden_size) 序列的最后一个隐藏状态。
past_key_values (tuple(tuple(jnp.ndarray)), optional, returned when use_cache=True is passed or when config.use_cache=True) — 长度为 config.n_layers 的 tuple(jnp.ndarray) 元组，每个元组有 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 时）可用于加速顺序解码。
hidden_states (tuple(jnp.ndarray), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of jnp.ndarray (one for the output of the embeddings + one for the output of each layer) of shape (batch_size, sequence_length, hidden_size)。
每层模型的输出隐藏状态以及初始嵌入输出。
attentions (tuple(jnp.ndarray), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of jnp.ndarray (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length)。
注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(jnp.ndarray), optional, returned when output_attentions=True and config.add_cross_attention=True is passed or when config.output_attentions=True) — Tuple of jnp.ndarray (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length)。
解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, FlaxGPT2Model
>>> tokenizer = AutoTokenizer.from_pretrained("gpt2")
>>> model = FlaxGPT2Model.from_pretrained("gpt2")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="jax")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state

FlaxGPT2LMHeadModel

`class transformers.FlaxGPT2LMHeadModel`

<来源>

( config: GPT2Config input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

config（GPT2Config） — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。查看 from_pretrained()方法以加载模型权重。
dtype (jax.numpy.dtype, optional, defaults to jax.numpy.float32) — 计算的数据类型。可以是jax.numpy.float32，jax.numpy.float16（在 GPU 上），以及jax.numpy.bfloat16（在 TPU 上）。
这可用于在 GPU 或 TPU 上启用混合精度训练或半精度推断。如果指定，所有计算将使用给定的dtype执行。
请注意，这仅指定了计算的数据类型，不会影响模型参数的数据类型。
如果您希望更改模型参数的数据类型，请参阅 to_fp16()和 to_bf16()。

带有语言建模头的 GPT2 模型变换器（线性层，其权重与输入嵌入绑定）。

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

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

最后，此模型支持 JAX 的固有功能，例如：

`call`

<来源>

( input_ids attention_mask = None position_ids = None encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None params: dict = None past_key_values: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

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

对于未被掩码的标记，为 1，
对于被掩码的标记，为 0。

什么是注意力掩码？
position_ids (numpy.ndarray of shape (batch_size, sequence_length), optional) — 位置嵌入中每个输入序列标记的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。
past_key_values (Dict[str, np.ndarray], optional, 由init_cache返回或传递先前的past_key_values时返回） — 预先计算的隐藏状态（注意力块中的键和值）的字典，可用于快速自回归解码。预先计算的键和值隐藏状态的形状为*[batch_size, max_length]*。
output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

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

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

logits (jnp.ndarray of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
hidden_states (tuple(jnp.ndarray), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出 + 一个用于每个层的输出）。
每个层输出的模型隐藏状态加上初始嵌入输出。
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 后的交叉注意力权重，用于计算交叉注意力头中的加权平均值。
past_key_values (tuple(tuple(jnp.ndarray)), optional, 当传递use_cache=True或config.use_cache=True时返回） — 长度为config.n_layers的jnp.ndarray元组的元组，每个元组包含自注意力和交叉注意力层的缓存键、值状态。仅在config.is_decoder = True时相关。
包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码。

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

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

示例：

>>> from transformers import AutoTokenizer, FlaxGPT2LMHeadModel
>>> tokenizer = AutoTokenizer.from_pretrained("gpt2")
>>> model = FlaxGPT2LMHeadModel.from_pretrained("gpt2")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="np")
>>> outputs = model(**inputs)
>>> # retrieve logts for next token
>>> next_token_logits = outputs.logits[:, -1]

_states (bool, *optional*) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states`。

return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

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

logits (jnp.ndarray of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
hidden_states (tuple(jnp.ndarray), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的jnp.ndarray元组（一个用于嵌入的输出 + 一个用于每个层的输出）。
每个层输出的模型隐藏状态加上初始嵌入输出。
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 后的交叉注意力权重，用于计算交叉注意力头中的加权平均值。
past_key_values (tuple(tuple(jnp.ndarray)), optional, 当传递use_cache=True或config.use_cache=True时返回） — 长度为config.n_layers的jnp.ndarray元组的元组，每个元组包含自注意力和交叉注意力层的缓存键、值状态。仅在config.is_decoder = True时相关。
包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码。

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

示例：

>>> from transformers import AutoTokenizer, FlaxGPT2LMHeadModel
>>> tokenizer = AutoTokenizer.from_pretrained("gpt2")
>>> model = FlaxGPT2LMHeadModel.from_pretrained("gpt2")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="np")
>>> outputs = model(**inputs)
>>> # retrieve logts for next token
>>> next_token_logits = outputs.logits[:, -1]

Transformers 4.37 中文文档（三十七）（5）

TFGPT2ForSequenceClassification

`class transformers.TFGPT2ForSequenceClassification`

`call`

TFSequenceClassifierOutputWithPast

`class transformers.modeling_tf_outputs.TFSequenceClassifierOutputWithPast`

TFGPT2Tokenizer

`class transformers.TFGPT2Tokenizer`

`from_config`

`from_pretrained`

`from_tokenizer`

FlaxGPT2Model

`class transformers.FlaxGPT2Model`

`call`

FlaxGPT2LMHeadModel

`class transformers.FlaxGPT2LMHeadModel`

`call`

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Transformers 4.37 中文文档（三十七）（5）

TFGPT2ForSequenceClassification

class transformers.TFGPT2ForSequenceClassification

call

TFSequenceClassifierOutputWithPast

class transformers.modeling_tf_outputs.TFSequenceClassifierOutputWithPast

TFGPT2Tokenizer

class transformers.TFGPT2Tokenizer

from_config

from_pretrained

from_tokenizer

FlaxGPT2Model

class transformers.FlaxGPT2Model

__call__

FlaxGPT2LMHeadModel

class transformers.FlaxGPT2LMHeadModel

__call__

热门文章

最新文章

相关课程

相关电子书

`class transformers.TFGPT2ForSequenceClassification`

`call`

`class transformers.modeling_tf_outputs.TFSequenceClassifierOutputWithPast`

`class transformers.TFGPT2Tokenizer`

`from_config`

`from_pretrained`

`from_tokenizer`

`class transformers.FlaxGPT2Model`

`call`

`class transformers.FlaxGPT2LMHeadModel`

`call`