Transformers 文档

GPT

Transformers

加入 Hugging Face 社区

并获得增强的文档体验

在模型、数据集和 Spaces 上进行协作

通过加速推理获得更快的示例

切换文档主题

开始使用

该模型于2018-06-11发布，并于2023-06-20添加到Hugging Face Transformers。

GPT

GPT (Generative Pre-trained Transformer) (博客文章) 专注于有效学习文本表示并将其迁移到各种任务。该模型训练 Transformer 解码器来预测下一个词，然后对标记数据进行微调。

GPT 可以生成高质量的文本，使其非常适合各种自然语言理解任务，例如文本蕴含、问答、语义相似度和文档分类。

您可以在 OpenAI community 组织下找到所有原始 GPT 检查点。

点击右侧边栏中的 GPT 模型，了解更多关于如何将 GPT 应用于不同语言任务的示例。

以下示例展示了如何使用 Pipeline、AutoModel 和命令行生成文本。

流水线

自动模型

Transformers CLI

注意事项

由于 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 pad_token_id = None bos_token_id = None eos_token_id = None tie_word_embeddings = True **kwargs )

参数

vocab_size (int, optional, defaults to 40478) — GPT-2 模型的词汇表大小。定义了调用 OpenAIGPTModel 时传递的 inputs_ids 可以表示的不同 token 的数量。
n_positions (int, optional, defaults to 512) — 此模型可能支持的最大序列长度。通常，请将其设置为较大的值以防万一（例如，512 或 1024 或 2048）。
n_embd (int, optional, defaults to 768) — 嵌入和隐藏状态的维度。
n_layer (int, optional, defaults to 12) — Transformer 编码器中的隐藏层数量。
n_head (int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数量。
afn (str 或 Callable, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果为字符串，支持 "gelu"、"relu"、"silu" 和 "gelu_new"。
resid_pdrop (float, optional, defaults to 0.1) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。
embd_pdrop (int, optional, defaults to 0.1) — 嵌入的 dropout 比率。
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) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
summary_type (str, optional, defaults to "cls_index") — 在进行序列摘要时使用的参数，用于模型 OpenAIGPTDoubleHeadsModel 和 OpenAIGPTDoubleHeadsModel。

必须是以下选项之一：
- "last"：取最后一个 token 的隐藏状态（类似于 XLNet）。
- "first"：取第一个 token 的隐藏状态（类似于 BERT）。
- "mean"：取所有 token 隐藏状态的平均值。
- "cls_index"：提供分类 token 位置的张量（类似于 GPT/GPT-2）。
- "attn"：目前未实现，使用多头注意力。
summary_use_proj (bool, optional, defaults to True) — 在进行序列摘要时使用的参数，用于模型 OpenAIGPTDoubleHeadsModel 和 OpenAIGPTDoubleHeadsModel。

是否在向量提取后添加投影。
summary_activation (str, optional) — 在进行序列摘要时使用的参数，用于模型 OpenAIGPTDoubleHeadsModel 和 OpenAIGPTDoubleHeadsModel。

传递 "tanh" 以对输出进行 tanh 激活，任何其他值都将导致无激活。
summary_proj_to_labels (bool, optional, defaults to True) — 在进行序列摘要时使用的参数，用于模型 OpenAIGPTDoubleHeadsModel 和 OpenAIGPTDoubleHeadsModel。

投影输出是否应具有 config.num_labels 或 config.hidden_size 类。
summary_first_dropout (float, optional, defaults to 0.1) — 在进行序列摘要时使用的参数，用于模型 OpenAIGPTDoubleHeadsModel 和 OpenAIGPTDoubleHeadsModel。

投影和激活后的 dropout 比率。
pad_token_id (int, optional) — 填充 token id。
bos_token_id (int, optional) — 起始流 token id。
eos_token_id (int, optional) — 结束流 token id。
tie_word_embeddings (bool, optional, defaults to True) — 是否绑定词嵌入。

这是用于存储 OpenAIGPTModel 配置的类。它用于根据指定的参数实例化 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.config

OpenAIGPTModel

class transformers.OpenAIGPTModel

< 源代码 >

( config model_args: ~utils.generic.ModelArgs | None = None adapter_args: ~utils.generic.AdapterArgs | None = None lora_args: ~utils.generic.LoRAArgs | None = None tokenizer_args: ~utils.generic.TokenizerArgs | None = None dataset_args: ~utils.generic.DatasetArgs | None = None data_args: ~utils.generic.DataArgs | None = None training_args: ~utils.generic.TrainingArgs | None = None generation_args: ~utils.generic.GenerationArgs | None = None vision_tower_args: ~utils.generic.VisionTowerArgs | None = None qlora_args: ~utils.generic.QLoRAArgs | None = None vision_tower_template_args: ~utils.generic.VisionTowerTemplateArgs | None = None video_tower_args: ~utils.generic.VideoTowerArgs | None = None vision_config: ~utils.generic.VisionConfig | None = None video_config: ~utils.generic.VideoConfig | None = None load_dataset: bool | None = None load_data_collator: bool | None = None load_processor: bool | None = None load_lora_adapter: bool | None = None load_adapter: bool | None = None load_qlora_adapter: bool | None = None **kwargs: typing_extensions.Unpack[transformers.modeling_utils.PreTrainedModelKwargs] )

参数

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

一个裸露的 Openai 模型，输出原始的隐藏状态，顶部没有任何特定的头。

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

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< source >

( input_ids: torch.LongTensor | None = None attention_mask: torch.FloatTensor | None = None token_type_ids: torch.LongTensor | None = None position_ids: torch.LongTensor | None = None inputs_embeds: torch.FloatTensor | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None **kwargs ) → transformers.modeling_outputs.BaseModelOutput 或 tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 词汇表中输入序列 token 的索引。默认情况下会忽略填充。

可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免对填充 token 索引执行 attention 的掩码。掩码值选择在 [0, 1] 中：
- 1 代表未掩码的 token，
- 0 代表已掩码的 token。
什么是 attention masks？
token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于指示输入的第一个和第二个部分的 segment token 索引。索引选择在 [0, 1] 中：
- 0 对应于句子 A token，
- 1 对应于句子 B token。
什么是 token type IDs？
position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 输入序列 token 在 position embedding 中的位置索引。选择范围为 [0, config.n_positions - 1]。

什么是 position IDs？
inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您希望比模型的内部嵌入查找矩阵获得对如何将 input_ids 索引转换为相关向量的更多控制，这将非常有用。
output_attentions (bool, optional) — 是否返回所有 attention 层的 attention 张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool, optional) — 是否返回所有层的 hidden states。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。

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

根据配置（OpenAIGPTConfig）和输入，一个 transformers.modeling_outputs.BaseModelOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）。

last_hidden_state (torch.FloatTensor, 形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。
hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入层的输出，如果模型有嵌入层；+一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

OpenAIGPTModel 的 forward 方法，覆盖了 __call__ 特殊方法。

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

OpenAIGPTLMHeadModel

class transformers.OpenAIGPTLMHeadModel

< source >

参数

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

在顶部带有语言建模头的 OpenAI GPT 模型 transformer（一个带有与输入嵌入层权重绑定的线性层）。

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

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< source >

( input_ids: torch.LongTensor | None = None attention_mask: torch.FloatTensor | None = None token_type_ids: torch.LongTensor | None = None position_ids: torch.LongTensor | None = None inputs_embeds: torch.FloatTensor | None = None labels: torch.LongTensor | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None logits_to_keep: int | torch.Tensor = 0 **kwargs ) → transformers.modeling_outputs.CausalLMOutput 或 tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 词汇表中输入序列 token 的索引。默认情况下会忽略填充。

可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免对填充 token 索引执行 attention 的掩码。掩码值选择在 [0, 1] 中：
- 1 代表未掩码的 token，
- 0 代表已掩码的 token。
什么是 attention masks？
token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于指示输入的第一个和第二个部分的 segment token 索引。索引选择在 [0, 1] 中：
- 0 对应于句子 A token，
- 1 对应于句子 B token。
什么是 token type IDs？
position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 输入序列 token 在 position embedding 中的位置索引。选择范围为 [0, config.n_positions - 1]。

什么是 position IDs？
inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您希望比模型的内部嵌入查找矩阵获得对如何将 input_ids 索引转换为相关向量的更多控制，这将非常有用。
labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 语言建模的标签。请注意，标签在模型内部已进行移位，即您可以设置 labels = input_ids。索引选择在 [-100, 0, ..., config.vocab_size] 中。所有设置为 -100 的标签都会被忽略（掩码），损失仅在 [0, ..., config.vocab_size] 中的标签上计算。
output_attentions (bool, optional) — 是否返回所有 attention 层的 attention 张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool, optional) — 是否返回所有层的 hidden states。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。
logits_to_keep (Union[int, torch.Tensor], optional, defaults to 0) — If an int, compute logits for the last logits_to_keep tokens. If 0, calculate logits for all input_ids (special case). Only last token logits are needed for generation, and calculating them only for that token can save memory, which becomes pretty significant for long sequences or large vocabulary size. If a torch.Tensor, must be 1D corresponding to the indices to keep in the sequence length dimension. This is useful when using packed tensor format (single dimension for batch and sequence length).

transformers.modeling_outputs.CausalLMOutput or 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), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入层的输出，如果模型有嵌入层；+一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

OpenAIGPTLMHeadModel 的 forward 方法，覆盖了 __call__ 特殊方法。

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 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

OpenAIGPTDoubleHeadsModel

class transformers.OpenAIGPTDoubleHeadsModel

< source >

参数

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

OpenAI GPT 模型 transformer，顶部带有语言建模和多项选择分类头，例如用于 RocStories/SWAG 任务。这两个头是两个线性层。语言建模头的权重与输入嵌入绑定，分类头以输入序列中指定分类令牌索引的输入作为输入。

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

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< source >

( input_ids: torch.LongTensor | None = None attention_mask: torch.FloatTensor | None = None token_type_ids: torch.LongTensor | None = None position_ids: torch.LongTensor | None = None inputs_embeds: torch.FloatTensor | None = None mc_token_ids: torch.LongTensor | None = None labels: torch.LongTensor | None = None mc_labels: torch.LongTensor | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None **kwargs ) → transformers.models.openai.modeling_openai.OpenAIGPTDoubleHeadsModelOutput 或 tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 词汇表中的输入序列令牌索引。默认情况下将忽略填充。

可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

输入 ID 是什么？
attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 忽略填充令牌索引的掩码。掩码值选择在 [0, 1] 中：
- 1 表示未掩码的令牌，
- 0 表示已掩码的令牌。
注意力掩码是什么？
token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于区分输入的前两部分的片段令牌索引。索引选择在 [0, 1] 中：
- 0 对应于句子 A 令牌，
- 1 对应于句子 B 令牌。
令牌类型 ID 是什么？
position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列令牌在位置嵌入中的位置索引。选择范围为 [0, config.n_positions - 1]。

位置 ID 是什么？
inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选，您可以在此处直接传递嵌入表示，而不是传递 input_ids。如果您希望对如何将 input_ids 索引转换为关联向量拥有比模型内部嵌入查找矩阵更多的控制权，则此选项很有用。
mc_token_ids (torch.LongTensor of shape (batch_size, num_choices), optional, default to index of the last token of the input) — 每个输入序列中分类令牌的索引。选择范围为 [0, input_ids.size(-1) - 1]。
labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 语言建模的标签。请注意，标签会在模型内部进行移位，即您可以设置 labels = input_ids。所有设置为 -100 的标签都会被忽略（屏蔽），仅对 [0, ..., config.vocab_size] 中的标签计算损失。
mc_labels (torch.LongTensor of shape (batch_size), optional) — 用于计算多项选择分类损失的标签。索引应在 [0, ..., num_choices] 中，其中 num_choices 是输入张量第二个维度的长度。（参见上面的 input_ids）
output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool, optional) — 是否返回一个 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 of shape (1,), optional, 当提供 mc_labels 时返回) — 多项选择分类损失。
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 之前的每个选项分数）。
hidden_states (tuple[torch.FloatTensor] | None.hidden_states, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入的输出，如果模型有嵌入层，+ 每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple[torch.FloatTensor] | None.attentions, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

OpenAIGPTDoubleHeadsModel 的 forward 方法，覆盖了 __call__ 特殊方法。

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 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

OpenAIGPTForSequenceClassification

class transformers.OpenAIGPTForSequenceClassification

< source >

参数

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

原始 OpenAI GPT 模型 transformer，顶部带有序列分类头（线性层）。OpenAIGPTForSequenceClassification 使用最后一个令牌来进行分类，正如其他因果模型（例如 GPT-2）所做的那样。由于它在最后一个令牌上进行分类，因此需要知道最后一个令牌的位置。如果在配置中定义了 pad_token_id，它会查找每个批次行中最后一个非填充令牌。如果未定义 pad_token_id，它将简单地获取批次中每行的最后一个值。由于在传递 inputs_embeds 而不是 input_ids 时无法猜测填充令牌，因此它执行相同的操作（获取批次中每行的最后一个值）。

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

此模型也是一个 PyTorch torch.nn.Module 子类。像普通的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解一般用法和行为的所有相关信息。

forward

< source >

( input_ids: torch.LongTensor | None = None attention_mask: torch.FloatTensor | None = None token_type_ids: torch.LongTensor | None = None position_ids: torch.LongTensor | None = None inputs_embeds: torch.FloatTensor | None = None labels: torch.LongTensor | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None **kwargs ) → transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 词汇表中的输入序列令牌索引。默认情况下将忽略填充。

可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

输入 ID 是什么？
attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 忽略填充令牌索引的掩码。掩码值选择在 [0, 1] 中：
- 1 表示未掩码的令牌，
- 0 表示已掩码的令牌。
注意力掩码是什么？
token_type_ids (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 用于指示输入的第一个和第二个部分的段落 ID。ID 选择范围为 [0, 1]：
- 0 代表 句子 A 的 token，
- 1 代表 句子 B 的 token。
什么是 token type IDs？
position_ids (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列 token 的位置 ID。选择范围为 [0, config.n_positions - 1]。

什么是 position IDs？
inputs_embeds (torch.FloatTensor, 形状为 (batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型内部的嵌入查找矩阵更精细地控制如何将 input_ids ID 转换为相关的向量，这将非常有用。
labels (torch.LongTensor, 形状为 (batch_size,), 可选) — 用于计算序列分类/回归损失的标签。ID 应在 [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), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（一个用于嵌入层的输出，如果模型有嵌入层；+一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

模型在每个层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每个层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

OpenAIGPTForSequenceClassification 的 forward 方法重写了 __call__ 特殊方法。

虽然 forward pass 的实现需要在此函数中定义，但你应该在之后调用 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

OpenAIGPTTokenizer

class transformers.OpenAIGPTTokenizer

< 来源 >

( vocab: str | dict[str, int] | None = None merges: str | list[str] | None = None unk_token: str = '<unk>' **kwargs )

参数

vocab_file (str, 可选) — 词汇表文件的路径。
merges_file (str, 可选) — 合并文件的路径。
tokenizer_file (str, 可选) — 包含分词器序列化的分词器 JSON 文件的路径。
unk_token (str, 可选, 默认值 "<unk>") — 未知 token。词汇表中不存在的 token 无法转换为 ID，而是被设置为此 token。
vocab (str 或 dict[str, int], 可选) — 自定义词汇表字典。如果未提供，将初始化一个空词汇表。
merges (str 或 list[str], 可选) — 自定义合并列表。如果未提供，则使用空列表。

构建一个 GPT Tokenizer (基于 HuggingFace 的 tokenizers 库)。基于 Byte-Pair-Encoding，具有以下特点：

将所有输入小写
使用 BERT 的 BasicTokenizer 进行 BPE 前分词

此分词器继承自 TokenizersBackend，其中包含大部分主要方法。用户应参考此父类了解有关这些方法的更多信息。

OpenAIGPTTokenizerFast

class transformers.OpenAIGPTTokenizer

< 来源 >

( vocab: str | dict[str, int] | None = None merges: str | list[str] | None = None unk_token: str = '<unk>' **kwargs )

参数

vocab_file (str, 可选) — 词汇表文件的路径。
merges_file (str, 可选) — 合并文件的路径。
tokenizer_file (str, 可选) — 包含分词器序列化的分词器 JSON 文件的路径。
unk_token (str, 可选, 默认值 "<unk>") — 未知 token。词汇表中不存在的 token 无法转换为 ID，而是被设置为此 token。
vocab (str 或 dict[str, int], 可选) — 自定义词汇表字典。如果未提供，将初始化一个空词汇表。
merges (str 或 list[str], 可选) — 自定义合并列表。如果未提供，则使用空列表。

构建一个 GPT Tokenizer (基于 HuggingFace 的 tokenizers 库)。基于 Byte-Pair-Encoding，具有以下特点：

将所有输入小写
使用 BERT 的 BasicTokenizer 进行 BPE 前分词

此分词器继承自 TokenizersBackend，其中包含大部分主要方法。用户应参考此父类了解有关这些方法的更多信息。

在 GitHub 上更新

←GLM-Image GPT Neo→