Transformers 文档
GPT
并获得增强的文档体验
开始使用
GPT
GPT（生成式预训练 Transformer）专注于有效学习文本表示并将其迁移到各种任务中。该模型训练 Transformer 解码器来预测下一个词，然后在有标签的数据上进行微调。
GPT 能够生成高质量的文本，使其非常适合各种自然语言理解任务，如文本蕴含、问答、语义相似度和文档分类。
你可以在 OpenAI 社区组织下找到所有原始的 GPT 检查点。
点击右侧边栏中的 GPT 模型，查看更多如何将 GPT 应用于不同语言任务的示例。
下面的示例演示了如何使用 Pipeline、AutoModel 和命令行来生成文本。
import torch
from transformers import pipeline
generator = pipeline(task="text-generation", model="openai-community/gpt", torch_dtype=torch.float16, device=0)
output = generator("The future of AI is", max_length=50, do_sample=True)
print(output[0]["generated_text"])注意事项
- 由于 GPT 使用绝对位置嵌入，输入应在右侧进行填充。
OpenAIGPTConfig
class transformers.OpenAIGPTConfig
< 来源 >( vocab_size = 40478 n_positions = 512 n_embd = 768 n_layer = 12 n_head = 12 afn = 'gelu' 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 **kwargs )
参数
- vocab_size (
int, 可选, 默认为 40478) — GPT-2 模型的词汇表大小。定义了在调用 OpenAIGPTModel 或 TFOpenAIGPTModel 时，可以通过inputs_ids表示的不同词元（token）的数量。 - n_positions (
int, 可选, 默认为 512) — 该模型可能使用的最大序列长度。通常将其设置为一个较大的值以备不时之需（例如，512、1024 或 2048）。 - n_embd (
int, 可选, 默认为 768) — 嵌入和隐藏状态的维度。 - n_layer (
int, 可选, 默认为 12) — Transformer 编码器中的隐藏层数。 - n_head (
int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。 - afn (
str或Callable, 可选, 默认为"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"和"gelu_new"。 - resid_pdrop (
float, 可选, 默认为 0.1) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。 - embd_pdrop (
int, 可选, 默认为 0.1) — 嵌入的 dropout 比率。 - attn_pdrop (
float, 可选, 默认为 0.1) — 注意力层的 dropout 比率。 - layer_norm_epsilon (
float, 可选, 默认为 1e-05) — 层归一化层中使用的 epsilon 值。 - initializer_range (
float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - summary_type (
str, 可选, 默认为"cls_index") — 在进行序列摘要时使用的参数，用于模型 OpenAIGPTDoubleHeadsModel 和 OpenAIGPTDoubleHeadsModel。必须是以下选项之一：
"last"：取最后一个词元的隐藏状态（如 XLNet）。"first"：取第一个词元的隐藏状态（如 BERT）。"mean"：取所有词元隐藏状态的平均值。"cls_index"：提供一个分类词元位置的张量（如 GPT/GPT-2）。"attn"：目前未实现，使用多头注意力机制。
- summary_use_proj (
bool, 可选, 默认为True) — 在进行序列摘要时使用的参数，用于模型 OpenAIGPTDoubleHeadsModel 和 OpenAIGPTDoubleHeadsModel。是否在向量提取后添加一个投影层。
- summary_activation (
str, 可选) — 在进行序列摘要时使用的参数，用于模型 OpenAIGPTDoubleHeadsModel 和 OpenAIGPTDoubleHeadsModel。传递
"tanh"以对输出应用 tanh 激活函数，任何其他值将导致不应用激活函数。 - summary_proj_to_labels (
bool, 可选, 默认为True) — 在进行序列摘要时使用的参数，用于模型 OpenAIGPTDoubleHeadsModel 和 OpenAIGPTDoubleHeadsModel。投影输出是否应具有
config.num_labels或config.hidden_size个类别。 - summary_first_dropout (
float, 可选, 默认为 0.1) — 在进行序列摘要时使用的参数，用于模型 OpenAIGPTDoubleHeadsModel 和 OpenAIGPTDoubleHeadsModel。在投影和激活之后使用的 dropout 比率。
这是用于存储 OpenAIGPTModel 或 TFOpenAIGPTModel 配置的配置类。它用于根据指定的参数实例化一个 GPT 模型，定义模型架构。使用默认值实例化配置将产生与 OpenAI 的 GPT openai-community/openai-gpt 架构类似的配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PretrainedConfig 的文档。
示例
>>> from transformers import OpenAIGPTConfig, OpenAIGPTModel
>>> # Initializing a GPT configuration
>>> configuration = OpenAIGPTConfig()
>>> # Initializing a model (with random weights) from the configuration
>>> model = OpenAIGPTModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configOpenAIGPTModel
class transformers.OpenAIGPTModel
< 来源 >( config )
参数
- config (OpenAIGPTModel) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重，只会加载配置。请查阅 from_pretrained() 方法来加载模型权重。
裸 Openai 模型，输出原始的隐藏状态，没有任何特定的头在其之上。
该模型继承自 PreTrainedModel。请查阅超类文档以了解该库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
该模型也是一个 PyTorch torch.nn.Module 的子类。可以像常规的 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。
forward
< 来源 >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.BaseModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length), 可选) — 词汇表中输入序列词元的索引。默认情况下，填充将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length), 可选) — 用于避免对填充词元索引执行注意力的掩码。掩码值选自[0, 1]：- 对于未被掩码的词元，值为 1，
- 对于被掩码的词元，值为 0。
- token_type_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 片段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于 *句子 A* 的标记，
- 1 对应于 *句子 B* 的标记。
- position_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列标记的位置索引。在范围[0, config.n_positions - 1]内选择。 - head_mask (
torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于置零自注意力模块中选定头的掩码。掩码值在[0, 1]中选择：- 1 表示头未被屏蔽，
- 0 表示头被屏蔽。
- inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，你可以不传递input_ids，而是直接传递一个嵌入式表示。如果你想比模型内部的嵌入查找矩阵更好地控制如何将input_ids索引转换为关联向量，这会很有用。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。更多细节请参见返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。更多细节请参见返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
返回
transformers.modeling_outputs.BaseModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutput 或一个 torch.FloatTensor 的元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，根据配置 (OpenAIGPTConfig) 和输入包含各种元素。
-
last_hidden_state (
torch.FloatTensor, 形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 -
hidden_states (
tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的元组 (一个用于嵌入层的输出，如果模型有嵌入层，+ 每个层的输出各一个)，形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组 (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
OpenAIGPTModel 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的流程需要在此函数中定义，但之后应该调用 Module 实例而不是这个函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
- forward
OpenAIGPTLMHeadModel
class transformers.OpenAIGPTLMHeadModel
< 源码 >( config )
参数
- config (OpenAIGPTLMHeadModel) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
带有语言模型头的 OpenAI GPT 模型转换器（线性层，权重与输入嵌入绑定）。
该模型继承自 PreTrainedModel。请查阅超类文档以了解该库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
该模型也是一个 PyTorch torch.nn.Module 的子类。可以像常规的 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。
forward
< 源码 >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.modeling_outputs.CausalLMOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下，填充将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 避免对填充标记索引执行注意力的掩码。掩码值在[0, 1]中选择：- 1 表示标记未被屏蔽，
- 0 表示标记被屏蔽。
- token_type_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 片段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于 *句子 A* 的标记，
- 1 对应于 *句子 B* 的标记。
- position_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列标记的位置索引。在范围[0, config.n_positions - 1]内选择。 - 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索引转换为关联向量，这会很有用。 - labels (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于语言模型的标签。请注意，标签在模型内部会被移位，即你可以设置labels = input_ids。索引在[-100, 0, ..., config.vocab_size]中选择。所有设置为-100的标签都会被忽略（屏蔽），损失仅对[0, ..., config.vocab_size]中的标签进行计算。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。更多细节请参见返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。更多细节请参见返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
返回
transformers.modeling_outputs.CausalLMOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.CausalLMOutput 或一个 torch.FloatTensor 的元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，根据配置 (OpenAIGPTConfig) 和输入包含各种元素。
-
loss (
torch.FloatTensor形状为(1,)，可选，当提供labels时返回) — 语言建模损失（用于下一个 token 预测）。 -
logits (形状为
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 语言建模头部的预测分数（SoftMax 之前的每个词汇标记的分数）。 -
hidden_states (
tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的元组 (一个用于嵌入层的输出，如果模型有嵌入层，+ 每个层的输出各一个)，形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组 (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
OpenAIGPTLMHeadModel 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的流程需要在此函数中定义，但之后应该调用 Module 实例而不是这个函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> import torch
>>> from transformers import AutoTokenizer, OpenAIGPTLMHeadModel
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/openai-gpt")
>>> model = OpenAIGPTLMHeadModel.from_pretrained("openai-community/openai-gpt")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits- forward
OpenAIGPTDoubleHeadsModel
class transformers.OpenAIGPTDoubleHeadsModel
< 源码 >( config )
参数
- config (OpenAIGPTDoubleHeadsModel) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
带有语言模型头和多项选择分类头的 OpenAI GPT 模型转换器，例如用于 RocStories/SWAG 任务。这两个头是两个线性层。语言模型头的权重与输入嵌入绑定，分类头将输入序列中指定分类标记索引的输入作为输入）。
该模型继承自 PreTrainedModel。请查阅超类文档以了解该库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
该模型也是一个 PyTorch torch.nn.Module 的子类。可以像常规的 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。
forward
< 源码 >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None mc_token_ids: typing.Optional[torch.LongTensor] = None labels: typing.Optional[torch.LongTensor] = None mc_labels: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.models.openai.modeling_openai.OpenAIGPTDoubleHeadsModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下，填充将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 避免对填充标记索引执行注意力的掩码。掩码值在[0, 1]中选择：- 1 表示标记未被屏蔽，
- 0 表示标记被屏蔽。
- token_type_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 片段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于 *句子 A* 的标记，
- 1 对应于 *句子 B* 的标记。
- position_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列标记的位置索引。在范围[0, config.n_positions - 1]内选择。 - 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索引转换为关联向量，这会很有用。 - mc_token_ids (
torch.LongTensor，形状为(batch_size, num_choices)，可选，默认为输入的最后一个标记的索引) — 每个输入序列中分类标记的索引。在范围[0, input_ids.size(-1) - 1]内选择。 - labels (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于语言模型的标签。请注意，标签在模型内部会被移位，即你可以设置labels = input_ids。索引在[-1, 0, ..., config.vocab_size]中选择。所有设置为-100的标签都会被忽略（屏蔽），损失仅对[0, ..., config.vocab_size]中的标签进行计算。 - mc_labels (
torch.LongTensor，形状为(batch_size)，可选) — 用于计算多项选择分类损失的标签。索引应在[0, ..., num_choices]范围内，其中 *num_choices* 是输入张量第二维的大小。（参见上面的 *input_ids*） - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。更多细节请参见返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。更多细节请参见返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
返回
transformers.models.openai.modeling_openai.OpenAIGPTDoubleHeadsModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.openai.modeling_openai.OpenAIGPTDoubleHeadsModelOutput 或一个 torch.FloatTensor 的元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，根据配置 (OpenAIGPTConfig) 和输入包含各种元素。
-
loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 语言建模损失。 -
mc_loss (
torch.FloatTensor，形状为(1,)，可选，当提供mc_labels时返回) — 多项选择分类损失。 -
logits (
torch.FloatTensor，形状为(batch_size, num_choices, sequence_length, config.vocab_size)) — 语言模型头的预测分数（SoftMax 前每个词汇标记的分数）。 -
mc_logits (
torch.FloatTensor，形状为(batch_size, num_choices)) — 多项选择分类头的预测分数（SoftMax 前每个选项的分数）。 -
hidden_states (
tuple[torch.FloatTensor]，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的元组 (一个用于嵌入层的输出，如果模型有嵌入层，+ 每个层的输出各一个)，形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple[torch.FloatTensor]，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组 (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
OpenAIGPTDoubleHeadsModel 的 forward 方法重写了 __call__ 特殊方法。
尽管前向传播的流程需要在此函数中定义，但之后应该调用 Module 实例而不是这个函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, OpenAIGPTDoubleHeadsModel
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/openai-gpt")
>>> model = OpenAIGPTDoubleHeadsModel.from_pretrained("openai-community/openai-gpt")
>>> tokenizer.add_special_tokens(
... {"cls_token": "[CLS]"}
... ) # Add a [CLS] to the vocabulary (we should train it also!)
>>> model.resize_token_embeddings(len(tokenizer))
>>> choices = ["Hello, my dog is cute [CLS]", "Hello, my cat is cute [CLS]"]
>>> input_ids = torch.tensor([tokenizer.encode(s) for s in choices]).unsqueeze(0) # Batch size 1, 2 choices
>>> mc_token_ids = torch.tensor([input_ids.size(-1) - 1, input_ids.size(-1) - 1]).unsqueeze(0) # Batch size 1
>>> outputs = model(input_ids, mc_token_ids=mc_token_ids)
>>> lm_logits = outputs.logits
>>> mc_logits = outputs.mc_logits- forward
OpenAIGPTForSequenceClassification
class transformers.OpenAIGPTForSequenceClassification
< 源码 >( config )
参数
- config (OpenAIGPTForSequenceClassification) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
原始的 OpenAI GPT 模型转换器，顶部带有一个序列分类头（线性层）。OpenAIGPTForSequenceClassification 使用最后一个标记来进行分类，就像其他因果模型（如 GPT-2）一样。由于它对最后一个标记进行分类，因此需要知道最后一个标记的位置。如果在配置中定义了 pad_token_id，它会找到每行中不是填充标记的最后一个标记。如果未定义 pad_token_id，它会简单地取批处理中每行的最后一个值。由于当传递 inputs_embeds 而不是 input_ids 时无法猜测填充标记，它会做同样的操作（取批处理中每行的最后一个值）。
该模型继承自 PreTrainedModel。请查阅超类文档以了解该库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
该模型也是一个 PyTorch torch.nn.Module 的子类。可以像常规的 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。
forward
< 源码 >( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下，填充将被忽略。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力计算的掩码。掩码值在[0, 1]中选择：- 1 表示标记未被遮盖，
- 0 表示标记已被遮盖。
- token_type_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于指示输入的第一和第二部分的段标记索引。索引在[0, 1]中选择：- 0 对应于*句子 A* 的标记，
- 1 对应于*句子 B* 的标记。
- position_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.n_positions - 1]内选择。 - 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索引转换为相关向量，这会很有用。 - labels (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失）；如果config.num_labels > 1，则计算分类损失（交叉熵）。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通的元组。
返回
transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），根据配置（OpenAIGPTConfig）和输入的不同，包含不同的元素。
-
loss (形状为
(1,)的torch.FloatTensor，可选，当提供labels时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。 -
logits (形状为
(batch_size, config.num_labels)的torch.FloatTensor) — 分类（如果 config.num_labels==1，则为回归）分数（SoftMax 之前）。 -
hidden_states (
tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的元组 (一个用于嵌入层的输出，如果模型有嵌入层，+ 每个层的输出各一个)，形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
-
attentions (
tuple(torch.FloatTensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的元组 (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
OpenAIGPTForSequenceClassification 的 forward 方法会覆盖 __call__ 特殊方法。
尽管前向传播的流程需要在此函数中定义，但之后应该调用 Module 实例而不是这个函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
单标签分类示例
>>> import torch
>>> from transformers import AutoTokenizer, OpenAIGPTForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/openai-gpt")
>>> model = OpenAIGPTForSequenceClassification.from_pretrained("openai-community/openai-gpt")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
... logits = model(**inputs).logits
>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...
>>> # 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 = OpenAIGPTForSequenceClassification.from_pretrained("openai-community/openai-gpt", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...多标签分类示例
>>> import torch
>>> from transformers import AutoTokenizer, OpenAIGPTForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/openai-gpt")
>>> model = OpenAIGPTForSequenceClassification.from_pretrained("openai-community/openai-gpt", 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 = OpenAIGPTForSequenceClassification.from_pretrained(
... "openai-community/openai-gpt", 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- forward
OpenAIGPTTokenizer
class transformers.OpenAIGPTTokenizer
< 来源 >( vocab_file merges_file unk_token = '<unk>' **kwargs )
构建一个 GPT 分词器。基于字节对编码（Byte-Pair-Encoding），具有以下特点：
- 将所有输入转换为小写，
- 如果已安装，则使用
SpaCy分词器和ftfy进行 BPE 前的分词处理，否则回退到 BERT 的BasicTokenizer。
此分词器继承自 PreTrainedTokenizer，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
将标记序列（字符串）转换为单个字符串。
OpenAIGPTTokenizerFast
class transformers.OpenAIGPTTokenizerFast
< 来源 >( vocab_file = None merges_file = None tokenizer_file = None unk_token = '<unk>' **kwargs )
构建一个“快速”的 GPT 分词器（由 HuggingFace 的 *tokenizers* 库支持）。基于字节对编码（Byte-Pair-Encoding），具有以下特点：
- 将所有输入转换为小写
- 使用 BERT 的 BasicTokenizer 进行 BPE 前的分词处理
此分词器继承自 PreTrainedTokenizerFast，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
TFOpenAIGPTModel
class transformers.TFOpenAIGPTModel
< 来源 >( config *inputs **kwargs )
参数
- config (OpenAIGPTConfig) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
基础的 OpenAI GPT transformer 模型，输出原始的隐藏状态，顶部没有任何特定的头。
该模型继承自 TFPreTrainedModel。请查看超类的文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
该模型也是一个 keras.Model 的子类。可以像使用常规的 TF 2.0 Keras 模型一样使用它，并参考 TF 2.0 文档了解所有与常规用法和行为相关的事项。
transformers 中的 TensorFlow 模型和层接受两种输入格式
- 所有输入作为关键字参数（如 PyTorch 模型），或
- 所有输入作为第一个位置参数中的列表、元组或字典。
支持第二种格式的原因是 Keras 方法在向模型和层传递输入时更喜欢这种格式。由于这种支持，当使用像 `model.fit()` 这样的方法时，事情应该能“正常工作”——只需以 `model.fit()` 支持的任何格式传递你的输入和标签！然而，如果你想在像 `fit()` 和 `predict()` 这样的 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 函数一样传递输入！
调用
< 来源 >( input_ids: TFModelInputType | None = 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 output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) → transformers.modeling_tf_outputs.TFBaseModelOutput 或 tuple(tf.Tensor)
参数
- input_ids (
Numpy 数组或tf.Tensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
tf.Tensor或Numpy 数组，形状为(batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力计算的掩码。掩码值在[0, 1]中选择：- 1 表示标记未被遮盖，
- 0 表示标记已被遮盖。
- token_type_ids (
tf.Tensor或Numpy 数组，形状为(batch_size, sequence_length)，可选) — 用于指示输入的第一和第二部分的段标记索引。索引在[0, 1]中选择：- 0 对应于*句子 A* 的标记，
- 1 对应于*句子 B* 的标记。
- position_ids (
tf.Tensor或Numpy 数组，形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]内选择。 - head_mask (
tf.Tensor或Numpy 数组，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于置零自注意力模块中选定头的掩码。掩码值在[0, 1]中选择：- 1 表示头未被遮盖，
- 0 表示头已被遮盖。
- inputs_embeds (
tf.Tensor或Numpy 数组，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，你可以直接传递嵌入表示，而不是传递input_ids。如果你想比模型内部的嵌入查找矩阵更好地控制如何将input_ids索引转换为相关向量，这会很有用。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量下的attentions。此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关详细信息，请参阅返回张量下的hidden_states。此参数只能在 eager 模式下使用，在 graph 模式下将使用配置中的值。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通的元组。此参数可在 eager 模式下使用，在 graph 模式下该值将始终设置为 True。 - training (
bool，可选，默认为False) — 是否以训练模式使用模型（某些模块如 dropout 模块在训练和评估之间有不同的行为）。
返回
transformers.modeling_tf_outputs.TFBaseModelOutput 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFBaseModelOutput 或一个 tf.Tensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），根据配置（OpenAIGPTConfig）和输入的不同，包含不同的元素。
-
last_hidden_state (
tf.Tensorof shape(batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。 -
hidden_states (
tuple(tf.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入的输出，一个用于每个层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态加上初始嵌入输出。
-
attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) — `tf.Tensor` 的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
TFOpenAIGPTModel 的 forward 方法会覆盖 __call__ 特殊方法。
尽管前向传播的流程需要在此函数中定义，但之后应该调用 Module 实例而不是这个函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFOpenAIGPTModel
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/openai-gpt")
>>> model = TFOpenAIGPTModel.from_pretrained("openai-community/openai-gpt")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)
>>> last_hidden_states = outputs.last_hidden_state- 调用
TFOpenAIGPTLMHeadModel
class transformers.TFOpenAIGPTLMHeadModel
< 来源 >( config *inputs **kwargs )
参数
- config (OpenAIGPTConfig) — 包含模型所有参数的模型配置类。使用配置文件进行初始化不会加载与模型相关的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。
带有语言模型头的 OpenAI GPT 模型转换器（线性层，权重与输入嵌入绑定）。
该模型继承自 TFPreTrainedModel。请查看超类的文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
该模型也是一个 keras.Model 的子类。可以像使用常规的 TF 2.0 Keras 模型一样使用它，并参考 TF 2.0 文档了解所有与常规用法和行为相关的事项。
transformers 中的 TensorFlow 模型和层接受两种输入格式
- 所有输入作为关键字参数（如 PyTorch 模型），或
- 所有输入作为第一个位置参数中的列表、元组或字典。
支持第二种格式的原因是 Keras 方法在向模型和层传递输入时更喜欢这种格式。由于这种支持，当使用像 `model.fit()` 这样的方法时，事情应该能“正常工作”——只需以 `model.fit()` 支持的任何格式传递你的输入和标签！然而，如果你想在像 `fit()` 和 `predict()` 这样的 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 函数一样传递输入！
调用
< 来源 >( input_ids: TFModelInputType | None = 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 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 ) → transformers.modeling_tf_outputs.TFCausalLMOutput 或 tuple(tf.Tensor)
参数
- input_ids (
Numpy 数组或tf.Tensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
tf.Tensor或Numpy 数组，形状为(batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力计算的掩码。掩码值在[0, 1]中选择：- 1 表示标记未被遮盖，
- 0 表示标记已被遮盖。
- token_type_ids (
tf.Tensor或Numpy 数组，形状为(batch_size, sequence_length)，可选) — 用于指示输入的第一和第二部分的段标记索引。索引在[0, 1]中选择：- 0 对应于*句子 A* 的标记，
- 1 对应于*句子 B* 的标记。
- position_ids (
tf.Tensor或Numpy 数组，形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]内选择。 - head_mask (
tf.Tensor或Numpy array，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使自注意力模块中选定的头无效的掩码。掩码值在[0, 1]中选择：- 1 表示头未被遮盖，
- 0 表示头被遮盖。
- inputs_embeds (
tf.Tensor或Numpy array，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，你可以不传递input_ids，而是直接传递嵌入表示。如果你希望比模型内部的嵌入查找矩阵更能控制如何将input_ids索引转换为相关联的向量，这会很有用。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数仅能在 Eager 模式下使用，在图模式下将使用配置中的值。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数仅能在 Eager 模式下使用，在图模式下将使用配置中的值。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通的元组。此参数可在 Eager 模式下使用，在图模式下，该值将始终设置为 True。 - training (
bool，可选，默认为False) — 是否在训练模式下使用模型（某些模块，如 dropout 模块，在训练和评估之间有不同的行为）。 - labels (
tf.Tensor，形状为(batch_size, sequence_length)，可选) — 用于计算交叉熵分类损失的标签。索引应在[0, ..., config.vocab_size - 1]范围内。
返回
transformers.modeling_tf_outputs.TFCausalLMOutput 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFCausalLMOutput 或一个 tf.Tensor 的元组（如果传递了 return_dict=False 或 config.return_dict=False），包含根据配置 (OpenAIGPTConfig) 和输入的不同而变化的各种元素。
-
loss (形状为
(n,)的tf.Tensor，可选，其中n是非掩码标签的数量，当提供了labels时返回) — 语言建模损失（用于下一标记预测）。 -
logits (
tf.Tensorof shape(batch_size, sequence_length, config.vocab_size)) — 语言模型头部的预测分数（SoftMax 之前每个词汇标记的分数）。 -
hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入的输出 + 一个用于每层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态加上初始嵌入输出。
-
attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) — `tf.Tensor` 的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
TFOpenAIGPTLMHeadModel 的前向方法，重写了 __call__ 特殊方法。
尽管前向传播的流程需要在此函数中定义，但之后应该调用 Module 实例而不是这个函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFOpenAIGPTLMHeadModel
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/openai-gpt")
>>> model = TFOpenAIGPTLMHeadModel.from_pretrained("openai-community/openai-gpt")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)
>>> logits = outputs.logits- 调用
TFOpenAIGPTDoubleHeadsModel
class transformers.TFOpenAIGPTDoubleHeadsModel
< 来源 >( config *inputs **kwargs )
参数
- config (OpenAIGPTConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。请查看 from_pretrained() 方法以加载模型权重。
带有语言模型头和多项选择分类头的 OpenAI GPT 模型转换器，例如用于 RocStories/SWAG 任务。这两个头是两个线性层。语言模型头的权重与输入嵌入绑定，分类头将输入序列中指定分类标记索引的输入作为输入）。
该模型继承自 TFPreTrainedModel。请查看超类的文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
该模型也是一个 keras.Model 的子类。可以像使用常规的 TF 2.0 Keras 模型一样使用它，并参考 TF 2.0 文档了解所有与常规用法和行为相关的事项。
transformers 中的 TensorFlow 模型和层接受两种输入格式
- 所有输入作为关键字参数（如 PyTorch 模型），或
- 所有输入作为第一个位置参数中的列表、元组或字典。
支持第二种格式的原因是 Keras 方法在向模型和层传递输入时更喜欢这种格式。由于这种支持，当使用像 `model.fit()` 这样的方法时，事情应该能“正常工作”——只需以 `model.fit()` 支持的任何格式传递你的输入和标签！然而，如果你想在像 `fit()` 和 `predict()` 这样的 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 函数一样传递输入！
调用
< 来源 >( input_ids: TFModelInputType | None = 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 output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) → transformers.models.openai.modeling_tf_openai.TFOpenAIGPTDoubleHeadsModelOutput 或 tuple(tf.Tensor)
参数
- input_ids (
Numpy array或tf.Tensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
tf.Tensor或Numpy array，形状为(batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值在[0, 1]中选择：- 1 表示标记未被遮盖，
- 0 表示标记被遮盖。
- token_type_ids (
tf.Tensor或Numpy array，形状为(batch_size, sequence_length)，可选) — 分段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于 *A 句* 标记，
- 1 对应于 *B 句* 标记。
- position_ids (
tf.Tensor或Numpy array，形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。 - head_mask (
tf.Tensor或Numpy array，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使自注意力模块中选定的头无效的掩码。掩码值在[0, 1]中选择：- 1 表示头未被遮盖，
- 0 表示头被遮盖。
- inputs_embeds (
tf.Tensor或Numpy array，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，你可以不传递input_ids，而是直接传递嵌入表示。如果你希望比模型内部的嵌入查找矩阵更能控制如何将input_ids索引转换为相关联的向量，这会很有用。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数仅能在 Eager 模式下使用，在图模式下将使用配置中的值。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数仅能在 Eager 模式下使用，在图模式下将使用配置中的值。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通的元组。此参数可在 Eager 模式下使用，在图模式下，该值将始终设置为 True。 - training (
bool，可选，默认为False) — 是否在训练模式下使用模型（某些模块，如 dropout 模块，在训练和评估之间有不同的行为）。 - mc_token_ids (
tf.Tensor或Numpy array，形状为(batch_size, num_choices)，可选，默认为输入的最后一个标记的索引) — 每个输入序列中分类标记的索引。在[0, input_ids.size(-1) - 1]范围内选择。
返回
transformers.models.openai.modeling_tf_openai.TFOpenAIGPTDoubleHeadsModelOutput 或 tuple(tf.Tensor)
一个 transformers.models.openai.modeling_tf_openai.TFOpenAIGPTDoubleHeadsModelOutput 或一个 tf.Tensor 的元组（如果传递了 return_dict=False 或 config.return_dict=False），包含根据配置 (OpenAIGPTConfig) 和输入的不同而变化的各种元素。
-
logits (
tf.Tensor，形状为(batch_size, num_choices, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前的每个词汇标记的分数）。 -
mc_logits (
tf.Tensor，形状为(batch_size, num_choices)) — 多项选择分类头的预测分数（SoftMax 之前的每个选项的分数）。 -
hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入的输出 + 一个用于每层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态加上初始嵌入输出。
-
attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) — `tf.Tensor` 的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
TFOpenAIGPTDoubleHeadsModel 的前向方法，重写了 __call__ 特殊方法。
尽管前向传播的流程需要在此函数中定义，但之后应该调用 Module 实例而不是这个函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> import tensorflow as tf
>>> from transformers import AutoTokenizer, TFOpenAIGPTDoubleHeadsModel
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/openai-gpt")
>>> model = TFOpenAIGPTDoubleHeadsModel.from_pretrained("openai-community/openai-gpt")
>>> # Add a [CLS] to the vocabulary (we should train it also!)
>>> tokenizer.add_special_tokens({"cls_token": "[CLS]"})
>>> model.resize_token_embeddings(len(tokenizer)) # Update the model embeddings with the new vocabulary size
>>> print(tokenizer.cls_token_id, len(tokenizer)) # The newly token the last token of the vocabulary
>>> choices = ["Hello, my dog is cute [CLS]", "Hello, my cat is cute [CLS]"]
>>> encoding = tokenizer(choices, return_tensors="tf")
>>> inputs = {k: tf.expand_dims(v, 0) for k, v in encoding.items()}
>>> inputs["mc_token_ids"] = tf.constant(
... [inputs["input_ids"].shape[-1] - 1, inputs["input_ids"].shape[-1] - 1]
... )[
... None, :
... ] # Batch size 1
>>> outputs = model(inputs)
>>> lm_prediction_scores, mc_prediction_scores = outputs[:2]- 调用
TFOpenAIGPTForSequenceClassification
class transformers.TFOpenAIGPTForSequenceClassification
< 来源 >( config *inputs **kwargs )
参数
- config (OpenAIGPTConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只会加载配置。请查看 from_pretrained() 方法以加载模型权重。
OpenAI GPT 模型 Transformer，顶部带有一个序列分类头（线性层）。
TFOpenAIGPTForSequenceClassification 使用最后一个标记来进行分类，就像其他因果模型（例如 GPT-2）一样。
由于它对最后一个标记进行分类，因此需要知道最后一个标记的位置。如果在配置中定义了 pad_token_id，它会找到每行中不是填充标记的最后一个标记。如果没有定义 pad_token_id，它会简单地取批处理中每行的最后一个值。由于当传递 inputs_embeds 而不是 input_ids 时它无法猜测填充标记，因此它会做同样的操作（取批处理中每行的最后一个值）。
该模型继承自 TFPreTrainedModel。请查看超类的文档，了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、修剪头等）。
该模型也是一个 keras.Model 的子类。可以像使用常规的 TF 2.0 Keras 模型一样使用它，并参考 TF 2.0 文档了解所有与常规用法和行为相关的事项。
transformers 中的 TensorFlow 模型和层接受两种输入格式
- 所有输入作为关键字参数（如 PyTorch 模型），或
- 所有输入作为第一个位置参数中的列表、元组或字典。
支持第二种格式的原因是 Keras 方法在向模型和层传递输入时更喜欢这种格式。由于这种支持，当使用像 `model.fit()` 这样的方法时，事情应该能“正常工作”——只需以 `model.fit()` 支持的任何格式传递你的输入和标签！然而，如果你想在像 `fit()` 和 `predict()` 这样的 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 函数一样传递输入！
调用
< 来源 >( input_ids: TFModelInputType | None = 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 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 ) → transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或 tuple(tf.Tensor)
参数
- input_ids (
Numpy array或tf.Tensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。
- attention_mask (
tf.Tensor或Numpy array，形状为(batch_size, sequence_length)，可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值在[0, 1]中选择：- 1 表示标记未被遮盖，
- 0 表示标记被遮盖。
- token_type_ids (
tf.Tensor或Numpy array，形状为(batch_size, sequence_length)，可选) — 分段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于 *A 句* 标记，
- 1 对应于 *B 句* 标记。
- position_ids (
tf.Tensor或Numpy array，形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在[0, config.max_position_embeddings - 1]范围内选择。 - head_mask (
tf.Tensor或Numpy array，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使自注意力模块中选定的头无效的掩码。掩码值在[0, 1]中选择：- 1 表示头未被遮盖，
- 0 表示头被遮盖。
- inputs_embeds (
tf.Tensor或Numpy array，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，你可以不传递input_ids，而是直接传递嵌入表示。如果你希望比模型内部的嵌入查找矩阵更能控制如何将input_ids索引转换为相关联的向量，这会很有用。 - output_attentions (
bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数仅能在 Eager 模式下使用，在图模式下将使用配置中的值。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数仅能在 Eager 模式下使用，在图模式下将使用配置中的值。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通的元组。此参数可在 Eager 模式下使用，在图模式下，该值将始终设置为 True。 - training (
bool，可选，默认为False) — 是否在训练模式下使用模型（某些模块，如 dropout 模块，在训练和评估之间有不同的行为）。 - labels (
tf.Tensor，形状为(batch_size, sequence_length)，可选) — 用于计算交叉熵分类损失的标签。索引应在[0, ..., config.vocab_size - 1]范围内。
返回
transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或 tuple(tf.Tensor)
一个 transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或一个 tf.Tensor 的元组（如果传递了 return_dict=False 或 config.return_dict=False），包含根据配置 (OpenAIGPTConfig) 和输入的不同而变化的各种元素。
-
loss (
tf.Tensor，形状为(batch_size, )，可选，当提供labels时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。 -
logits (
tf.Tensor，形状为(batch_size, config.num_labels)) — 分类（或回归，如果 config.num_labels==1）分数（SoftMax 之前）。 -
hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) —tf.Tensor的元组（一个用于嵌入的输出 + 一个用于每层的输出），形状为(batch_size, sequence_length, hidden_size)。模型在每个层输出的隐藏状态加上初始嵌入输出。
-
attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) — `tf.Tensor` 的元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
TFOpenAIGPTForSequenceClassification 的前向方法，重写了 __call__ 特殊方法。
尽管前向传播的流程需要在此函数中定义，但之后应该调用 Module 实例而不是这个函数，因为前者会处理运行前处理和后处理步骤，而后者会静默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFOpenAIGPTForSequenceClassification
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("openai-community/openai-gpt")
>>> model = TFOpenAIGPTForSequenceClassification.from_pretrained("openai-community/openai-gpt")
>>> 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 = TFOpenAIGPTForSequenceClassification.from_pretrained("openai-community/openai-gpt", num_labels=num_labels)
>>> labels = tf.constant(1)
>>> loss = model(**inputs, labels=labels).loss- 调用