Transformers 4.37 中文文档（三十七）

原文：huggingface.co/docs/transformers

OpenAI GPT2

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

概述

OpenAI GPT-2 模型是由 Alec Radford、Jeffrey Wu、Rewon Child、David Luan、Dario Amodei 和 Ilya Sutskever 在 OpenAI 提出的，它是一个因果（单向）变压器，使用语言建模在一个大约 40GB 的文本数据语料库上进行预训练。

论文的摘要如下：

GPT-2 是一个基于大型变压器的语言模型，具有 15 亿个参数，在一个包含 800 万个网页的数据集[1]上进行训练。GPT-2 的训练目标很简单：预测给定一些文本中所有先前单词的下一个单词。数据集的多样性使得这个简单目标包含了许多跨不同领域的任务的自然发生演示。GPT-2 是 GPT 的直接扩展，参数超过 10 倍，训练数据量超过 10 倍。

Write With Transformer 是由 Hugging Face 创建和托管的一个网页应用程序，展示了几个模型的生成能力。GPT-2 是其中之一，有五种不同的大小可用：small、medium、large、xl 和 small checkpoint 的蒸馏版本：distilgpt-2。

这个模型是由 thomwolf 贡献的。原始代码可以在这里找到。

使用提示

• GPT-2 是一个带有绝对位置嵌入的模型，因此通常建议在右侧而不是左侧填充输入。
• GPT-2 是通过因果语言建模（CLM）目标进行训练的，因此在预测序列中的下一个标记时非常强大。利用这个特性使 GPT-2 能够生成句法连贯的文本，正如在 run_generation.py 示例脚本中所观察到的那样。
• 该模型可以接受 past_key_values（对于 PyTorch）或 past（对于 TF）作为输入，这是先前计算的键/值注意力对。使用这个（past_key_values 或 past）值可以防止模型在文本生成的上下文中重新计算预先计算的值。对于 PyTorch，请参阅 GPT2Model.forward() 方法的 past_key_values 参数，或者对于 TF，请参阅 TFGPT2Model.call() 方法的 past 参数，以获取有关其用法的更多信息。
• 启用 scale_attn_by_inverse_layer_idx 和 reorder_and_upcast_attn 标志将应用来自 Mistral 的训练稳定性改进（仅适用于 PyTorch）。

资源

一个官方 Hugging Face 和社区（由 🌎 表示）资源列表，可帮助您开始使用 GPT2。如果您有兴趣提交资源以包含在此处，请随时打开一个 Pull Request，我们将进行审查！资源应该理想地展示一些新东西，而不是重复现有资源。

文本生成

• 一篇关于如何使用 Hugging Face 对非英语 GPT-2 模型进行微调 的博客。
• 一篇关于如何生成文本：使用不同的解码方法进行语言生成与 Transformers 的博客，使用 GPT-2。
• 一篇关于从头开始训练 CodeParrot 🦜 的博客，一个大型的 GPT-2 模型。
• 一篇关于使用 TensorFlow 和 XLA 加速文本生成的博客，使用 GPT-2。
• 一篇关于如何使用 Megatron-LM 训练语言模型的博客，使用 GPT-2 模型。
• 一本关于如何微调 GPT2 以生成您最喜爱的艺术家风格歌词的笔记。🌎
• 一本关于如何微调 GPT2 以生成您最喜爱的 Twitter 用户风格的推文的笔记。🌎
• 🤗 Hugging Face 课程的因果语言建模章节。
• GPT2LMHeadModel 由这个因果语言建模示例脚本、文本生成示例脚本和笔记本支持。
• TFGPT2LMHeadModel 由这个因果语言建模示例脚本和笔记本支持。
• FlaxGPT2LMHeadModel 由这个因果语言建模示例脚本和笔记本支持。
• 文本分类任务指南
• 标记分类任务指南
• 因果语言建模任务指南

GPT2Config

class transformers.GPT2Config

<来源>

( vocab_size = 50257 n_positions = 1024 n_embd = 768 n_layer = 12 n_head = 12 n_inner = None activation_function = 'gelu_new' resid_pdrop = 0.1 embd_pdrop = 0.1 attn_pdrop = 0.1 layer_norm_epsilon = 1e-05 initializer_range = 0.02 summary_type = 'cls_index' summary_use_proj = True summary_activation = None summary_proj_to_labels = True summary_first_dropout = 0.1 scale_attn_weights = True use_cache = True bos_token_id = 50256 eos_token_id = 50256 scale_attn_by_inverse_layer_idx = False reorder_and_upcast_attn = False **kwargs )

参数

• vocab_size (int, 可选，默认为 50257) — GPT-2 模型的词汇量。定义了在调用 GPT2Model 或 TFGPT2Model 时可以表示的不同标记数量。
• n_positions (int, 可选，默认为 1024) — 该模型可能会使用的最大序列长度。通常将其设置为较大的值以防万一（例如 512、1024 或 2048）。
• n_embd (int, 可选，默认为 768) — 嵌入和隐藏状态的维度。
• n_layer (int, 可选，默认为 12) — Transformer 编码器中的隐藏层数。
• n_head (int, 可选，默认为 12) — Transformer 编码器中每个注意力层的注意力头数。
• n_inner (int, 可选) — 内部前馈层的维度。None将其设置为 4 倍的 n_embd。
• activation_function (str, 可选，默认为"gelu_new") — 激活函数，可在列表["relu", "silu", "gelu", "tanh", "gelu_new"]中选择。
• resid_pdrop (float, 可选，默认为 0.1) — 嵌入、编码器和池化器中所有全连接层的丢失概率。
• embd_pdrop (float, 可选，默认为 0.1) — 嵌入的丢失比率。
• attn_pdrop (float, optional, defaults to 0.1) — 注意力的 dropout 比率。
• layer_norm_epsilon (float, optional, defaults to 1e-05) — 用于层归一化层的 epsilon 值。
• initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态分布初始化器的标准差。
• summary_type (string, optional, defaults to "cls_index") — 在进行序列摘要时使用的参数，在模型 GPT2DoubleHeadsModel 和 TFGPT2DoubleHeadsModel 中使用。 必须是以下选项之一：
  • "last": 取最后一个 token 的隐藏状态（类似 XLNet）。
  • "first": 取第一个 token 的隐藏状态（类似 BERT）。
  • "mean": 取所有 token 隐藏状态的平均值。
  • "cls_index": 提供一个分类 token 位置的张量（类似 GPT/GPT-2）。
  • "attn": 目前未实现，使用多头注意力。
• summary_use_proj (bool, optional, defaults to True) — 在进行序列摘要时使用的参数，在模型 GPT2DoubleHeadsModel 和 TFGPT2DoubleHeadsModel 中使用。 是否在向量提取后添加投影。
• summary_activation (str, optional) — 在进行序列摘要时使用的参数。在 GPT2DoubleHeadsModel 中用于多选头。 将 "tanh" 传递给输出的 tanh 激活，任何其他值将导致无激活。
• summary_proj_to_labels (bool, optional, defaults to True) — 在进行序列摘要时使用的参数，在模型 GPT2DoubleHeadsModel 和 TFGPT2DoubleHeadsModel 中使用。 投影输出应具有 config.num_labels 或 config.hidden_size 类。
• summary_first_dropout (float, optional, defaults to 0.1) — 在进行序列摘要时使用的参数，在模型 GPT2DoubleHeadsModel 和 TFGPT2DoubleHeadsModel 中使用。 在投影和激活之后使用的 dropout 比率。
• scale_attn_weights (bool, optional, defaults to True) — 通过除以 sqrt(hidden_size) 缩放注意力权重。
• use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。
• bos_token_id (int, optional, defaults to 50256) — 词汇表中句子开头标记的 id。
• eos_token_id (int, optional, defaults to 50256) — 词汇表中句子结束标记的 id。
• scale_attn_by_inverse_layer_idx (bool, optional, defaults to False) — 是否额外通过 1 / layer_idx + 1 缩放注意力权重。
• reorder_and_upcast_attn (bool, optional, defaults to False) — 是否在计算注意力（点积）之前缩放键（K），并在使用混合精度训练时将注意力点积/softmax 上转换为 float()。

这是用于存储 GPT2Model 或 TFGPT2Model 的配置类。它用于根据指定的参数实例化一个 GPT-2 模型，定义模型架构。使用默认值实例化配置将产生类似于 GPT-2 gpt2架构的配置。

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

示例：

>>> from transformers import GPT2Config, GPT2Model

>>> # Initializing a GPT2 configuration
>>> configuration = GPT2Config()

>>> # Initializing a model (with random weights) from the configuration
>>> model = GPT2Model(configuration)

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

GPT2Tokenizer

class transformers.GPT2Tokenizer

<来源>

( vocab_file merges_file errors = 'replace' unk_token = '<|endoftext|>' bos_token = '<|endoftext|>' eos_token = '<|endoftext|>' pad_token = None add_prefix_space = False add_bos_token = False **kwargs )

参数

• vocab_file (str) — 词汇文件的路径。
• merges_file (str) — 合并文件的路径。
• errors (str, 可选, 默认为"replace") — 解码字节为 UTF-8 时要遵循的范例。查看bytes.decode获取更多信息。
• unk_token（str，optional，默认为"<|endoftext|>"）–未知令牌。词汇表中没有的令牌无法转换为 ID，而是设置为该令牌。
• bos_token（str，optional，默认为"<|endoftext|>"）–序列标记的开头。
• eos_token（str，optional，默认为"<|endoftext|>"）–序列结束标记。
• pad_token（str，optional）–用于填充的令牌，例如，当批处理不同长度的序列时。
• add_prefix_space (bool, 可选, 默认为False) — 是否在输入中添加一个初始空格。这允许将开头的单词视为任何其他单词。（GPT2 分词器通过前导空格检测单词的开头）。
• add_bos_token (bool, 可选, 默认为False) — 是否添加一个初始句子开头的标记到输入中。这允许将开头的单词视为任何其他单词。

构建一个 GPT-2 分词器。基于字节级字节对编码。

这个分词器经过训练，将空格视为标记的一部分（有点像 sentencepiece），因此一个单词

在句子开头（没有空格）或不在句子开头时，可能会以不同方式编码：

>>> from transformers import GPT2Tokenizer

>>> tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
>>> tokenizer("Hello world")["input_ids"]
[15496, 995]

>>> tokenizer(" Hello world")["input_ids"]
[18435, 995]

您可以通过在实例化此分词器时或在对某些文本调用它时传递add_prefix_space=True来避免这种行为，但由于模型不是以这种方式进行预训练的，这可能会导致性能下降。

当与is_split_into_words=True一起使用时，这个分词器将在每个单词之前添加一个空格（甚至是第一个单词）。

这个分词器继承自 PreTrainedTokenizer，其中包含大部分主要方法。用户应参考这个超类以获取有关这些方法的更多信息。

save_vocabulary

<来源>

( save_directory: str filename_prefix: Optional = None )

GPT2TokenizerFast

class transformers.GPT2TokenizerFast

<来源>

( vocab_file = None merges_file = None tokenizer_file = None unk_token = '<|endoftext|>' bos_token = '<|endoftext|>' eos_token = '<|endoftext|>' add_prefix_space = False **kwargs )

参数

• vocab_file (str, 可选) — 词汇文件的路径。
• merges_file (str, 可选) — 合并文件的路径。
• tokenizer_file (str, 可选) — 路径到tokenizers文件（通常具有.json 扩展名），其中包含加载分词器所需的一切。
• unk_token（str，optional，默认为"<|endoftext|>"）–未知令牌。词汇表中没有的令牌无法转换为 ID，而是设置为该令牌。
• bos_token（str，optional，默认为"<|endoftext|>"）–序列标记的开头。
• eos_token（str，optional，默认为"<|endoftext|>"）–序列结束标记。
• add_prefix_space (bool, 可选, 默认为False) — 是否在输入中添加一个初始空格。这允许将开头的单词视为任何其他单词。（GPT2 分词器通过前导空格检测单词的开头）。

构建一个“快速”GPT-2 分词器（由 HuggingFace 的tokenizers库支持）。基于字节级字节对编码。

这个分词器经过训练，将空格视为标记的一部分（有点像 sentencepiece），因此一个单词

在句子开头（没有空格）或不在句子开头时，可能会以不同方式编码：

>>> from transformers import GPT2TokenizerFast

>>> tokenizer = GPT2TokenizerFast.from_pretrained("gpt2")
>>> tokenizer("Hello world")["input_ids"]
[15496, 995]

>>> tokenizer(" Hello world")["input_ids"]
[18435, 995]

您可以通过在实例化这个分词器时传递add_prefix_space=True来避免这种行为，但由于模型不是以这种方式进行预训练的，可能会导致性能下降。

当使用is_split_into_words=True时，需要使用add_prefix_space=True来实例化这个分词器。

这个分词器继承自 PreTrainedTokenizerFast，其中包含大部分主要方法。用户应参考这个超类以获取有关这些方法的更多信息。

GPT2 特定输出

class transformers.models.gpt2.modeling_gpt2.GPT2DoubleHeadsModelOutput

<来源>

( loss: Optional = None mc_loss: Optional = None logits: FloatTensor = None mc_logits: FloatTensor = None past_key_values: Optional = None hidden_states: Optional = None attentions: Optional = None )

参数

• loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）— 语言建模损失。
• mc_loss（形状为(1,)的torch.FloatTensor，可选，当提供mc_labels时返回）— 多项选择分类损失。
• logits（形状为(batch_size, num_choices, sequence_length, config.vocab_size)的torch.FloatTensor）— 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• mc_logits（形状为(batch_size, num_choices)的torch.FloatTensor）— 多项选择分类头的预测分数（SoftMax 之前每个选择的分数）。
• past_key_values（Tuple[Tuple[torch.Tensor]]，可选，当传递use_cache=True或config.use_cache=True时返回）— 长度为config.n_layers的元组，包含形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量元组。 包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码。
• 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元组（每层一个）。 GPT2 注意力权重在注意力 SoftMax 之后，用于计算自注意力头中的加权平均值。

用于预测两个句子是否连续的模型输出的基类。

class transformers.models.gpt2.modeling_tf_gpt2.TFGPT2DoubleHeadsModelOutput

<来源>

( logits: tf.Tensor = None mc_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 )

参数

• logits（形状为(batch_size, num_choices, sequence_length, config.vocab_size)的tf.Tensor）— 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• mc_logits（形状为(batch_size, num_choices)的tf.Tensor）— 多项选择分类头的预测分数（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 之后，用于计算自注意力头中的加权平均值。

用于预测两个句子是否连续的模型输出的基类。

Pytorch 隐藏 Pytorch 内容

GPT2Model

class transformers.GPT2Model

<来源>

( config )

参数

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

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

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

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

forward

<来源>

( input_ids: Optional = None past_key_values: Optional = None attention_mask: Optional = None token_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 use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor，形状为(batch_size, input_ids_length)) — input_ids_length = sequence_length，如果past_key_values为None，否则为past_key_values[0][0].shape[-2]（输入过去键值状态的序列长度）。词汇表中输入序列标记的索引。 如果使用了past_key_values，则只应将未计算其过去的input_ids作为input_ids传递。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• past_key_values (Tuple[Tuple[torch.Tensor]]，长度为config.n_layers) — 包含由模型计算的预计算隐藏状态（注意力块中的键和值），如下面的past_key_values输出所示。可用于加速顺序解码。已经计算过其过去的input_ids不应作为input_ids传递给此模型。
• attention_mask (torch.FloatTensor，形状为(batch_size, sequence_length)，可选的) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：
  • 对于未被masked的标记，值为 1，
  • 对于被masked的标记，值为 0。

  如果使用了past_key_values，则attention_mask需要包含用于past_key_values的掩码策略。换句话说，attention_mask始终必须具有长度：len(past_key_values) + len(input_ids)。 什么是注意力掩码？

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

  什么是标记类型 ID？

• 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索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。 如果使用了past_key_values，则可选地只需输入最后的inputs_embeds（参见past_key_values）。
• use_cache（bool，可选）— 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
• return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

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

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

• last_hidden_state（torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)）— 模型最后一层的隐藏状态的序列。 如果使用了past_key_values，则只输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。
• 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)的张量，如果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)，可选，当传递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 之后，用于计算交叉注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, GPT2Model
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("gpt2")
>>> model = GPT2Model.from_pretrained("gpt2")

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

>>> last_hidden_states = outputs.last_hidden_state

GPT2LMHeadModel

class transformers.GPT2LMHeadModel

<来源>

( config )

参数

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

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

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

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

forward

<来源>

( input_ids: Optional = None past_key_values: Optional = None attention_mask: Optional = None token_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 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（形状为(batch_size, input_ids_length)的torch.LongTensor） — 如果past_key_values为None，则input_ids_length = sequence_length，否则为past_key_values[0][0].shape[-2]（输入过去关键值状态的序列长度）。词汇表中输入序列标记的索引。 如果使用past_key_values，只有那些没有计算过去的input_ids应该作为input_ids传递。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• past_key_values (Tuple[Tuple[torch.Tensor]]，长度为config.n_layers) — 包含由模型计算的预计算隐藏状态（注意力块中的键和值）（请参见下面的past_key_values输出）。可用于加速顺序解码。将其过去给定给此模型的input_ids不应作为input_ids传递，因为它们已经计算过。
• attention_mask (torch.FloatTensor，形状为(batch_size, sequence_length)，optional) — 遮蔽填充标记索引上的注意力。选择的遮罩值在[0, 1]中：
  • 1 表示未被遮蔽的标记，
  • 0 表示被遮蔽的标记。

  如果使用了past_key_values，则attention_mask需要包含用于past_key_values的遮罩策略。换句话说，attention_mask的长度始终为：len(past_key_values) + len(input_ids) 什么是注意力遮罩？

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

  什么是标记类型 ID？

• position_ids (torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• head_mask (torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，optional) — 用于使自注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]中：
  • 1 表示头部未被遮蔽，
  • 0 表示头部被遮蔽。
• inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。 如果使用了past_key_values，则可能只需输入最后的inputs_embeds（参见past_key_values）。
• 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) — 是否返回一个 ModelOutput 而不是一个普通的元组。
• labels (torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 用于语言建模的标签。请注意，模型内部的标签已经被移位，即您可以设置labels = input_ids。在[-100, 0, ..., config.vocab_size]中选择索引。所有设置为-100的标签都将被忽略（遮蔽），损失仅计算在[0, ..., config.vocab_size]中的标签。

返回

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

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

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

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

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

示例：

>>> import torch
>>> from transformers import AutoTokenizer, GPT2LMHeadModel

>>> tokenizer = AutoTokenizer.from_pretrained("gpt2")
>>> model = GPT2LMHeadModel.from_pretrained("gpt2")

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

GPT2DoubleHeadsModel

class transformers.GPT2DoubleHeadsModel

< source >

( config )

参数

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

GPT2 模型变压器，具有语言建模和顶部的多选分类头，例如用于 RocStories/SWAG 任务。这两个头是两个线性层。语言建模头的权重与输入嵌入绑定，分类头以指定的分类令牌索引的输入作为输入（在输入序列中）。

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

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

forward

<来源>

( input_ids: Optional = None past_key_values: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None mc_token_ids: Optional = None labels: Optional = None mc_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.models.gpt2.modeling_gpt2.GPT2DoubleHeadsModelOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, input_ids_length)的torch.LongTensor）— 如果past_key_values为None，则input_ids_length=sequence_length，否则past_key_values[0][0].shape[-2]（输入过去关键值状态的序列长度）。词汇表中输入序列令牌的索引。 如果使用了past_key_values，则只应将未计算其过去的input_ids作为input_ids传递。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• past_key_values（长度为config.n_layers的Tuple[Tuple[torch.Tensor]]）— 包含由模型计算的预计算隐藏状态（注意力块中的键和值），如下面的past_key_values输出所示。可用于加速顺序解码。已将其过去给予此模型的input_ids不应作为input_ids传递，因为它们已经计算过。
• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在填充令牌索引上执行注意力的掩码。掩码值选择在[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, input_ids_length)的torch.LongTensor，可选）— 段令牌索引，用于指示输入的第一部分和第二部分。索引选择在[0, 1]之间：
  • 0 对应于句子 A令牌，
  • 1 对应于句子 B令牌。

  什么是令牌类型 ID？

• 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 (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选择直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，这很有用，而不是使用模型的内部嵌入查找矩阵。 如果使用了 past_key_values，可选择只需输入最后的 inputs_embeds（参见 past_key_values）。
• 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) — 是否返回一个 ModelOutput 而不是一个普通元组。
• mc_token_ids (torch.LongTensor of shape (batch_size, num_choices), optional, 默认为输入序列中最后一个标记的索引) — 每个输入序列中分类标记的索引。选择范围为 [0, input_ids.size(-1) - 1]。
• labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 语言建模的标签。请注意，模型内部的标签已经移位，即您可以设置 labels = input_ids。索引在 [-100, 0, ..., config.vocab_size - 1] 中选择。所有设置为 -100 的标签都被忽略（掩码），损失仅计算标签在 [0, ..., config.vocab_size - 1] 中的标签。
• mc_labels (torch.LongTensor of shape (batch_size), optional) — 用于计算多项选择分类损失的标签。索引应在 [0, ..., num_choices] 范围内，其中 num_choices 是输入张量第二维的大小。（参见上面的 input_ids）

返回

transformers.models.gpt2.modeling_gpt2.GPT2DoubleHeadsModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.models.gpt2.modeling_gpt2.GPT2DoubleHeadsModelOutput 或一个 torch.FloatTensor 元组（如果传入 return_dict=False 或当 config.return_dict=False 时），包含根据配置（GPT2Config）和输入而异的各种元素。

• loss (torch.FloatTensor of shape (1,), optional, returned when labels is provided) — 语言建模损失。
• mc_loss (torch.FloatTensor of shape (1,), optional, returned when mc_labels is provided) — 多项选择分类损失。
• logits (torch.FloatTensor of shape (batch_size, num_choices, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 前每个词汇标记的分数）。
• mc_logits (torch.FloatTensor of shape (batch_size, num_choices)) — 多项选择分类头的预测分数（SoftMax 前每个选择的分数）。
• past_key_values (Tuple[Tuple[torch.Tensor]], optional, returned when use_cache=True is passed or when config.use_cache=True) — 长度为 config.n_layers 的元组，包含形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量元组。 包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码（参见 past_key_values 输入）。
• 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 之后的 GPT2Attentions 权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> import torch
>>> from transformers import AutoTokenizer, GPT2DoubleHeadsModel

>>> tokenizer = AutoTokenizer.from_pretrained("gpt2")
>>> model = GPT2DoubleHeadsModel.from_pretrained("gpt2")

>>> # Add a [CLS] to the vocabulary (we should train it also!)
>>> num_added_tokens = tokenizer.add_special_tokens({"cls_token": "[CLS]"})
>>> # Update the model embeddings with the new vocabulary size
>>> embedding_layer = model.resize_token_embeddings(len(tokenizer))

>>> choices = ["Hello, my dog is cute [CLS]", "Hello, my cat is cute [CLS]"]
>>> encoded_choices = [tokenizer.encode(s) for s in choices]
>>> cls_token_location = [tokens.index(tokenizer.cls_token_id) for tokens in encoded_choices]

>>> input_ids = torch.tensor(encoded_choices).unsqueeze(0)  # Batch size: 1, number of choices: 2
>>> mc_token_ids = torch.tensor([cls_token_location])  # Batch size: 1

>>> outputs = model(input_ids, mc_token_ids=mc_token_ids)
>>> lm_logits = outputs.logits
>>> mc_logits = outputs.mc_logits

GPT2ForQuestionAnswering

class transformers.GPT2ForQuestionAnswering

<来源>

( config )

参数

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

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

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

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

前进

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_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 ) → export const metadata = 'undefined';transformers.modeling_outputs.QuestionAnsweringModelOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, input_ids_length)的torch.LongTensor）— 如果past_key_values为None，则input_ids_length=sequence_length，否则input_ids_length=past_key_values[0][0].shape[-2]（输入过去键值状态的序列长度）。词汇表中输入序列标记的索引。 如果使用past_key_values，则只应传递尚未计算其过去的input_ids。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• past_key_values（长度为config.n_layers的Tuple[Tuple[torch.Tensor]]）— 包含由模型计算的预计算隐藏状态（注意力块中的键和值）（参见下面的past_key_values输出）。可用于加速顺序解码。将其过去传递给该模型的input_ids不应作为input_ids传递，因为它们已经计算过。
• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力。选定的掩码值在[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, input_ids_length)的torch.LongTensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
  • 0 对应于句子 A标记，
  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• 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索引转换为相关向量，而不是模型的内部嵌入查找矩阵。 如果使用了past_key_values，则可选择仅输入最后的inputs_embeds（参见past_key_values）。
• use_cache（bool，可选）— 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。
• 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）包含根据配置 (GPT2Config) 和输入不同元素。

• loss (torch.FloatTensor，形状为 (1,)，可选，当提供 labels 时返回) — 总跨度提取损失是起始位置和结束位置的交叉熵之和。
• start_logits (torch.FloatTensor，形状为 (batch_size, sequence_length)) — 跨度起始分数（SoftMax 之前）。
• end_logits (torch.FloatTensor，形状为 (batch_size, sequence_length)) — 跨度结束分数（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 之后，用于计算自注意力头中的加权平均值。

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

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

这个示例使用一个随机模型，真实模型都非常庞大。为了获得正确的结果，应该使用 gpt2 而不是 gpt2。如果加载检查点时出现内存不足，可以尝试在 from_pretrained 调用中添加 device_map="auto"。

示例：

>>> from transformers import AutoTokenizer, GPT2ForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("gpt2")
>>> model = GPT2ForQuestionAnswering.from_pretrained("gpt2")

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

GPT2ForSequenceClassification

class transformers.GPT2ForSequenceClassification

< source >

( config )

参数

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

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

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

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

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

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

forward

<来源>

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

参数

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

  如果使用了past_key_values，attention_mask需要包含用于past_key_values的掩码策略。换句话说，attention_mask的长度始终为：len(past_key_values) + len(input_ids) 什么是 attention masks？

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

  什么是 token type IDs？

• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。 什么是 position IDs？
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）- 用于使自注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]中：
  • 1 表示头部未被masked，
  • 0 表示头部被masked。
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。 如果使用了past_key_values，可以选择仅输入最后的inputs_embeds（参见past_key_values）。
• use_cache（bool，可选）— 如果设置为True，将返回past_key_values键值状态，可用于加速解码（请参见past_key_values）。
• 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，则计算分类损失（交叉熵）。

返回

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

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

• loss（形状为(1,)的torch.FloatTensor，可选，在提供labels时返回）— 分类（如果config.num_labels==1则为回归）损失。
• logits（形状为(batch_size, config.num_labels)的torch.FloatTensor）— 分类（如果config.num_labels==1则为回归）得分（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)的张量） 包含预先计算的隐藏状态（自注意力块中的键和值），可用于加速顺序解码（请参见past_key_values输入）。
• 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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

单标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, GPT2ForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/DialogRPT-updown")
>>> model = GPT2ForSequenceClassification.from_pretrained("microsoft/DialogRPT-updown")

>>> 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 = GPT2ForSequenceClassification.from_pretrained("microsoft/DialogRPT-updown", num_labels=num_labels)

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

多标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, GPT2ForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/DialogRPT-updown")
>>> model = GPT2ForSequenceClassification.from_pretrained("microsoft/DialogRPT-updown", 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 = GPT2ForSequenceClassification.from_pretrained(
...     "microsoft/DialogRPT-updown", 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

GPT2ForTokenClassification

class transformers.GPT2ForTokenClassification

<来源>

( config )

参数

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

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

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

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

forward

<来源>

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

参数

• input_ids（形状为(batch_size, input_ids_length)的torch.LongTensor）- 如果past_key_values为None，则input_ids_length = sequence_length，否则为past_key_values[0][0].shape[-2]（输入过去键值状态的序列长度）。词汇表中输入序列标记的索引。 如果使用了past_key_values，则只有那些没有计算其过去的input_ids应作为input_ids传递。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
• past_key_values（长度为config.n_layers的Tuple[Tuple[torch.Tensor]]）- 包含由模型计算的预计算隐藏状态（注意力块中的键和值，如下面的past_key_values输出所示）。可用于加速顺序解码。已经计算的input_ids不应作为input_ids传递给此模型，因为它们已经被计算。
• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）- 用于避免在填充标记索引上执行注意力。选择的掩码值在[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, input_ids_length)的torch.LongTensor，可选）- 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
  • 0 对应于句子 A标记，
  • 1 对应于句子 B标记。

  什么是标记类型 ID？

• 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 (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果要更好地控制如何将input_ids索引转换为相关向量，这很有用，而不是使用模型的内部嵌入查找矩阵。 如果使用past_key_values，则可选择仅输入最后的inputs_embeds（参见past_key_values）。
• 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) — 是否返回 ModelOutput 而不是普通元组。
• labels (torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回

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

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

• loss (torch.FloatTensor，形状为(1,)，optional，当提供labels时返回) — 分类损失。
• logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.num_labels)） — 分类分数（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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, GPT2ForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("brad1141/gpt2-finetuned-comp2")
>>> model = GPT2ForTokenClassification.from_pretrained("brad1141/gpt2-finetuned-comp2")

>>> 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]]
>>> predicted_tokens_classes
['Lead', 'Lead', 'Lead', 'Position', 'Lead', 'Lead', 'Lead', 'Lead', 'Lead', 'Lead', 'Lead', 'Lead']

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
0.25

TensorFlowHide TensorFlow content

TFGPT2Model

class transformers.TFGPT2Model

< source >

( config *inputs **kwargs )

参数

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

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

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

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

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

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

支持第二种格式的原因是，当将输入传递给模型和层时，Keras 方法更喜欢这种格式。由于这种支持，当使用model.fit()等方法时，应该可以“正常工作” - 只需以model.fit()支持的任何格式传递输入和标签即可！但是，如果您想在 Keras 方法之外使用第二种格式，例如在使用 Keras Functional 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 encoder_hidden_states: np.ndarray | tf.Tensor | None = None encoder_attention_mask: 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: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutputWithPastAndCrossAttentions or tuple(tf.Tensor)

参数

• input_ids（形状为(batch_size, input_ids_length)的Numpy array或tf.Tensor） — 如果past_key_values为None，则input_ids_length = 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数组，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：
  • 对于未被masked的标记为 1，
  • 对于被masked的标记为 0。

  如果使用了past_key_values，attention_mask需要包含用于past_key_values的掩码策略。换句话说，attention_mask的长度始终为：len(past_key_values) + len(input_ids) 什么是注意力掩码？

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

  什么是标记类型 ID？

• position_ids（形状为(batch_size, sequence_length)的tf.Tensor或Numpy数组，可选）- 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的Numpy数组或tf.Tensor，可选）- 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：
  • 1 表示头部未被masked，
  • 0 表示头部被masked。
• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）- 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
• output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。此参数仅在急切模式下使用，在图模式中将使用配置中的值。
• output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。此参数仅在急切模式下使用，在图模式中将使用配置中的值。
• return_dict（bool，可选）- 是否返回 ModelOutput 而不是普通元组。此参数可以在急切模式下使用，在图模式中该值将始终设置为 True。
• training（bool，可选，默认为False）- 是否在训练模式中使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。
• encoder_hidden_states（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）- 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。
• encoder_attention_mask（形状为(batch_size, sequence_length)的tf.Tensor，可选）- 用于避免在编码器输入的填充标记索引上执行注意力的掩码。如果模型配置为解码器，则在交叉注意力中使用。掩码值在[0, 1]中选择：
  • 对于未被masked的标记为 1，
  • 对于被masked的标记为 0。
• past_key_values（长度为config.n_layers的Tuple[Tuple[tf.Tensor]]）- 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用了past，用户可以选择仅输入最后的decoder_input_ids（那些没有将它们的过去键值状态提供给此模型的）的形状为(batch_size, 1)，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
• use_cache（bool，可选，默认为True）- 如果设置为True，则返回past_key_values键值状态，可用于加速解码（参见past）。在训练期间设置为False，在生成期间设置为True。

返回

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

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

• last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor）- 模型最后一层的隐藏状态序列。 如果使用past_key_values，则只输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。
• 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.FloatTensor)，可选，当传递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 后的注意力权重，用于计算自注意力头中的加权平均值。
• cross_attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。 解码器的交叉注意力层的注意力权重，在注意力 softmax 后使用，用于计算交叉注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, TFGPT2Model
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("gpt2")
>>> model = TFGPT2Model.from_pretrained("gpt2")

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

>>> last_hidden_states = outputs.last_hidden_state

TFGPT2LMHeadModel

class transformers.TFGPT2LMHeadModel

<来源>

( config *inputs **kwargs )

参数

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

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

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

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

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

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

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

• 只有一个张量，其中仅包含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 encoder_hidden_states: np.ndarray | tf.Tensor | None = None encoder_attention_mask: 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.TFCausalLMOutputWithCrossAttentions or tuple(tf.Tensor)

参数

• input_ids（形状为(batch_size, input_ids_length)的Numpy 数组或tf.Tensor）- 如果past_key_values为None，则input_ids_length=sequence_length，否则input_ids_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 数组，可选）- 用于避免在填充令牌索引上执行注意力的掩码。在[0, 1]中选择的掩码值：
  • 对于未被masked的令牌，为 1，
  • 对于被masked的令牌，为 0。

  如果使用past_key_values，则attention_mask需要包含用于past_key_values的掩码策略。换句话说，attention_mask始终必须具有长度：len(past_key_values) + len(input_ids) 什么是注意力掩码？

• token_type_ids (tf.Tensor 或 Numpy array，形状为(batch_size, sequence_length)，optional) — 段标记索引，指示输入的第一部分和第二部分。索引选定在[0, 1]之间：
  • 0 对应于一个句子 A令牌，
  • 1 对应于一个句子 B令牌。

  什么是令牌类型 ID？

• position_ids (tf.Tensor 或 Numpy array，形状为(batch_size, sequence_length)，optional) — 每个输入序列令牌在位置嵌入中的位置索引。选定范围为[0, config.max_position_embeddings - 1]。 什么是位置 ID？
• head_mask (Numpy array 或 tf.Tensor，形状为(num_heads,) 或 (num_layers, num_heads)，optional) — 用于使自注意力模块中的选定头部失效的掩码。掩码值选定在[0, 1]之间：
  • 1 表示头部未被掩码，
  • 0 表示头部被掩码。
• inputs_embeds (tf.Tensor，形状为(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 而不是普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。
• training (bool，optional，默认为False) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。
• encoder_hidden_states (tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，optional) — 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。
• encoder_attention_mask (tf.Tensor，形状为(batch_size, sequence_length)，optional) — 用于避免对编码器输入的填充令牌索引执行注意力的掩码。如果模型配置为解码器，则此掩码将用于交叉注意力。掩码值选定在[0, 1]之间：
  • 1 用于未被掩码的令牌，
  • 0 用于被掩码的令牌。
• past_key_values (Tuple[Tuple[tf.Tensor]]，长度为config.n_layers) — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用了past，用户可以选择仅输入最后一个decoder_input_ids（这些输入没有将它们的过去键值状态提供给此模型）的形状为(batch_size, 1)，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
• use_cache (bool, optional，默认为True) — 如果设置为True，则将返回past_key_values键值状态，并可用于加速解码（参见past）。在训练期间设置为False，在生成期间设置为True。
• labels (tf.Tensor，形状为(batch_size, sequence_length)，optional) — 用于计算交叉熵分类损失的标签。索引应在[0, ..., config.vocab_size - 1]之间。

返回

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

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

• loss（形状为(n,)的tf.Tensor，可选，当提供labels时返回，其中 n 是非掩码标签的数量）- 语言建模损失（用于下一个标记预测）。
• logits（形状为(batch_size, sequence_length, config.vocab_size)的tf.Tensor）- 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• 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 之后的注意力权重，用于计算自注意力头中的加权平均值。
• cross_attentions（tuple(tf.Tensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）- 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每个层一个）。 解码器交叉注意力层的注意力权重，在注意力 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)。 包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码。

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

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

示例：

>>> from transformers import AutoTokenizer, TFGPT2LMHeadModel
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("gpt2")
>>> model = TFGPT2LMHeadModel.from_pretrained("gpt2")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)
>>> logits = outputs.logits

TFGPT2DoubleHeadsModel

class transformers.TFGPT2DoubleHeadsModel

<来源>

( config *inputs **kwargs )

参数

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

GPT2 模型变压器，顶部有一个语言建模和一个多选分类头，例如用于 RocStories/SWAG 任务。这两个头是两个线性层。语言建模头的权重与输入嵌入绑定，分类头以指定的分类标记索引的输入序列输入为输入）。

这个模型继承自 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 mc_token_ids: 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: Optional[bool] = False ) → export const metadata = 'undefined';transformers.models.gpt2.modeling_tf_gpt2.TFGPT2DoubleHeadsModelOutput or tuple(tf.Tensor)

参数

• input_ids（形状为(batch_size, input_ids_length)的Numpy array或tf.Tensor）- 如果past_key_values为None，则input_ids_length=sequence_length，否则input_ids_length=past_key_values[0].shape[-2]（输入过去键值状态的sequence_length）。词汇表中输入序列标记的索引。 如果使用了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]之间：
  • 对于被not masked的标记，为 1。
  • 对于被masked的标记，为 0。

  如果使用了past_key_values，则attention_mask需要包含用于past_key_values的掩码策略。换句话说，attention_mask始终必须具有长度：len(past_key_values) + len(input_ids) 什么是注意力掩码？

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

  什么是标记类型 ID？

• position_ids (tf.Tensor或形状为(batch_size, sequence_length)的Numpy数组，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。 什么是位置 ID？
• head_mask (Numpy数组或形状为(num_heads,)或(num_layers, num_heads)的tf.Tensor，可选) — 用于使自注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]中：
  • 1 表示头部是not masked，
  • 0 表示头部是masked。
• 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 模块在训练和评估之间有不同的行为）。
• mc_token_ids (tf.Tensor或形状为(batch_size, num_choices)的Numpy数组，可选，默认为输入的最后一个标记的索引) — 每个输入序列中分类标记的索引。在范围[0, input_ids.size(-1) - 1]中选择。

返回值

transformers.models.gpt2.modeling_tf_gpt2.TFGPT2DoubleHeadsModelOutput 或tuple(tf.Tensor)

一个 transformers.models.gpt2.modeling_tf_gpt2.TFGPT2DoubleHeadsModelOutput 或一个tf.Tensor元组（如果传递了return_dict=False或当config.return_dict=False时）包含根据配置（GPT2Config）和输入的不同元素。

• logits (tf.Tensor，形状为(batch_size, num_choices, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
• mc_logits (tf.Tensor，形状为(batch_size, num_choices)) — 多项选择分类头的预测分数（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 后的注意力权重，用于计算加权平均值。

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

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

示例：

>>> import tensorflow as tf
>>> from transformers import AutoTokenizer, TFGPT2DoubleHeadsModel

>>> tokenizer = AutoTokenizer.from_pretrained("gpt2")
>>> model = TFGPT2DoubleHeadsModel.from_pretrained("gpt2")

>>> # Add a [CLS] to the vocabulary (we should train it also!)
>>> num_added_tokens = tokenizer.add_special_tokens({"cls_token": "[CLS]"})

>>> embedding_layer = model.resize_token_embeddings(
...     len(tokenizer)
... )  # Update the model embeddings with the new vocabulary size

>>> choices = ["Hello, my dog is cute [CLS]", "Hello, my cat is cute [CLS]"]
>>> encoded_choices = [tokenizer.encode(s) for s in choices]
>>> cls_token_location = [tokens.index(tokenizer.cls_token_id) for tokens in encoded_choices]

>>> input_ids = tf.constant(encoded_choices)[None, :]  # Batch size: 1, number of choices: 2
>>> mc_token_ids = tf.constant([cls_token_location])  # Batch size: 1

>>> outputs = model(input_ids, mc_token_ids=mc_token_ids)
>>> lm_prediction_scores, mc_prediction_scores = outputs[:2]

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 功能，例如：

• 即时（JIT）编译
• 自动微分
• 矢量化
• 并行化

__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 的固有功能，例如：

• 即时编译（JIT）
• 自动微分
• 向量化
• 并行化

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

一个 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]