Transformers 文档

GPTBigCode

Transformers

加入 Hugging Face 社区

并获得增强的文档体验

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

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

切换文档主题

开始使用

此模型于 2023 年 1 月 9 日发布，并于 2023 年 4 月 10 日添加到 Hugging Face Transformers。

GPTBigCode

概述

GPTBigCode 模型由 BigCode 在 SantaCoder: don’t reach for the stars! 中提出。列出的作者包括：Loubna Ben Allal, Raymond Li, Denis Kocetkov, Chenghao Mou, Christopher Akiki, Carlos Munoz Ferrandis, Niklas Muennighoff, Mayank Mishra, Alex Gu, Manan Dey, Logesh Kumar Umapathi, Carolyn Jane Anderson, Yangtian Zi, Joel Lamy Poirier, Hailey Schoelkopf, Sergey Troshin, Dmitry Abulkhanov, Manuel Romero, Michael Lappert, Francesco De Toni, Bernardo García del Río, Qian Liu, Shamik Bose, Urvashi Bhattacharyya, Terry Yue Zhuo, Ian Yu, Paulo Villegas, Marco Zocca, Sourab Mangrulkar, David Lansky, Huu Nguyen, Danish Contractor, Luis Villa, Jia Li, Dzmitry Bahdanau, Yacine Jernite, Sean Hughes, Daniel Fried, Arjun Guha, Harm de Vries, Leandro von Werra。

论文摘要如下：

BigCode 项目是一个开放科学协作项目，致力于负责任地开发用于代码的大型语言模型。本技术报告描述了截至 2022 年 12 月的协作进展，概述了个人身份信息 (PII) 密文处理流程的当前状态、为降低模型架构风险而进行的实验，以及调查更好的训练数据预处理方法的实验。我们在 The Stack 的 Java、JavaScript 和 Python 子集上训练了 1.1B 参数模型，并在 MultiPL-E 文本转代码基准上评估了它们。我们发现更激进地过滤近重复项可以进一步提高性能，并且出乎意料的是，从具有 5 个以上 GitHub 星标的存储库中选择文件会显著降低性能。我们最好的模型在 MultiPL-E 的 Java、JavaScript 和 Python 部分的从左到右生成和填充方面都优于以前的开源多语言代码生成模型（InCoder-6.7B 和 CodeGen-Multi-2.7B），尽管它是一个小得多的模型。所有模型均在 this https URL 下以 OpenRAIL 许可证发布。

该模型是一个经过优化的 GPT2 模型，支持多查询注意力。

实现细节

与 GPT2 相比的主要区别。

增加了对多查询注意力（Multi-Query Attention）的支持。
使用 gelu_pytorch_tanh 而不是经典的 gelu。
避免不必要的同步（此功能后来已添加到 GPT2 中，请参阅 #20061，但在参考代码库中没有）。
使用线性层（Linear layers）而不是 Conv1D（有很好的加速效果，但使检查点不兼容）。
合并 _attn 和 _upcast_and_reordered_attn。始终将 matmul 与缩放合并。将 reorder_and_upcast_attn 重命名为 attention_softmax_in_fp32。
缓存注意力掩码值，避免每次都重新创建。
使用 jit 来融合注意力 fp32 转换、掩码、softmax 和缩放。
将注意力和因果掩码合并为一个，为整个模型而不是每一层预先计算。
将 key 和 value 缓存合并为一个（这会改变 layer_past/present 的格式，是否存在造成问题的风险？）。
对于带有 MHA 的 QKV 张量，使用内存布局 (self.num_heads, 3, self.head_dim) 而不是 (3, self.num_heads, self.head_dim)。（这可以防止合并 key 和 values 时的开销，但使检查点与原始 openai-community/gpt2 模型不兼容）。

您可以在原始拉取请求中阅读有关优化的更多信息。

结合 Starcoder 和 Flash Attention 2

首先，请确保安装最新版本的 Flash Attention 2，以包含滑动窗口注意力功能。

pip install -U flash-attn --no-build-isolation

另外请确保您的硬件与 Flash-Attention 2 兼容。在 flash-attn 存储库的官方文档中阅读更多相关信息。还要确保以半精度（例如 `torch.float16`）加载模型。

要使用 Flash Attention 2 加载和运行模型，请参阅以下代码片段。

>>> import torch
>>> from transformers import AutoModelForCausalLM, AutoTokenizer
from accelerate import Accelerator
>>> device = Accelerator().device # the device to load the model onto

>>> model = AutoModelForCausalLM.from_pretrained("bigcode/gpt_bigcode-santacoder", dtype=torch.float16, attn_implementation="flash_attention_2")
>>> tokenizer = AutoTokenizer.from_pretrained("bigcode/gpt_bigcode-santacoder")

>>> prompt = "def hello_world():"

>>> model_inputs = tokenizer([prompt], return_tensors="pt").to(model.device)
>>> model.to(device)

>>> generated_ids = model.generate(**model_inputs, max_new_tokens=30, do_sample=False)
>>> tokenizer.batch_decode(generated_ids)[0]
'def hello_world():\n    print("hello world")\n\nif __name__ == "__main__":\n    print("hello world")\n<|endoftext|>'

预期加速

下面是比较使用 bigcode/starcoder 检查点的 transformers 本地实现与使用两种不同序列长度的 Flash Attention 2 版本模型的纯推理时间的预期加速图。

GPTBigCodeConfig

class transformers.GPTBigCodeConfig

< source >

( vocab_size = 50257 n_positions = 1024 n_embd = 768 n_layer = 12 n_head = 12 n_inner = None activation_function = 'gelu_pytorch_tanh' resid_pdrop = 0.1 embd_pdrop = 0.1 attn_pdrop = 0.1 layer_norm_epsilon = 1e-05 initializer_range = 0.02 scale_attn_weights = True use_cache = True bos_token_id = 50256 eos_token_id = 50256 pad_token_id = None attention_softmax_in_fp32 = True scale_attention_softmax_in_fp32 = True multi_query = True add_cross_attention = False tie_word_embeddings = True **kwargs )

参数

vocab_size (int, optional, defaults to 50257) — GPT-2 模型的词汇表大小。定义了调用 GPTBigCodeModel 时传入的 inputs_ids 可以表示的不同标记的数量。
n_positions (int, optional, defaults to 1024) — 此模型可能使用的最大序列长度。通常为了以防万一设置得很大（例如 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 编码器中每个注意力层的注意力头数。
n_inner (int, optional, defaults to None) — 内部前馈层的维度。None 将其设置为 n_embd 的 4 倍。
activation_function (str, optional, defaults to "gelu_pytorch_tanh") — 激活函数，从列表 ["relu", "silu", "gelu", "tanh", "gelu_new", "gelu_pytorch_tanh"] 中选择。
resid_pdrop (float, optional, defaults to 0.1) — 嵌入、编码器和池化器中所有全连接层的丢弃概率。
embd_pdrop (float, optional, defaults to 0.1) — 嵌入的丢弃率。
attn_pdrop (float, optional, defaults to 0.1) — 注意力的丢弃率。
layer_norm_epsilon (float, optional, defaults to 1e-5) — 在层归一化层中使用的 epsilon 值。
initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
scale_attn_weights (bool, optional, defaults to True) — 是否通过除以 sqrt(hidden_size) 来缩放注意力权重。
use_cache (bool, optional, defaults to True) — 模型是否应该返回最后的 key/value 注意力（并非所有模型都使用）。
attention_softmax_in_fp32 (bool, optional, defaults to True) — 是否以 float32 格式调用融合的 softmax。
scale_attention_softmax_in_fp32 (bool, optional, defaults to True) — 是否以 float32 缩放注意力 softmax。
attention_type (bool, optional, defaults to True) — 是否使用多查询注意力 (Multi-Query Attion) (True) 或多头注意力 (Multi-Head Attention) (False)。

这是用于存储 GPTBigCodeModel 配置的配置类。它用于根据指定的参数实例化 GPTBigCode 模型，定义模型架构。使用默认值实例化配置将生成与 GPTBigCode gpt_bigcode 架构类似的配置。

配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PreTrainedConfig 的文档。

示例

>>> from transformers import GPTBigCodeConfig, GPTBigCodeModel

>>> # Initializing a GPTBigCode configuration
>>> configuration = GPTBigCodeConfig()

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

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

GPTBigCodeModel

class transformers.GPTBigCodeModel

< source >

( 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 (GPTBigCodeModel) — 模型的配置类，包含模型的所有参数。使用配置文件进行初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained() 方法以加载模型权重。

裸 Gpt Bigcode 模型，输出原始隐藏状态，顶部没有特定头部。

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

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

forward

< source >

( input_ids: torch.Tensor | None = None past_key_values: transformers.cache_utils.Cache | None = None attention_mask: torch.Tensor | None = None token_type_ids: torch.Tensor | None = None position_ids: torch.Tensor | None = None inputs_embeds: torch.Tensor | None = None encoder_hidden_states: torch.Tensor | None = None encoder_attention_mask: torch.Tensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None cache_position: torch.Tensor | None = None **kwargs ) → transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions or tuple(torch.FloatTensor)

参数

input_ids (torch.Tensor of shape (batch_size, input_ids_length)) — input_ids_length = sequence_length if past_key_values is None else past_key_values.get_seq_length() (输入过去键值状态的 sequence_length)。词汇表中输入序列 token 的索引。
past_key_values (~cache_utils.Cache, optional) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。当 use_cache=True 或 config.use_cache=True 时，这通常由模型在解码的先前阶段返回的 past_key_values 组成。
attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用于避免在填充 token 索引上执行注意力的掩码。掩码值选择在 [0, 1] 中：
- 1 表示未被掩码的 token，
- 0 表示被掩码的 token。
什么是注意力掩码？
token_type_ids (torch.Tensor of shape (batch_size, sequence_length), optional) — 分段 token 索引，用于指示输入的第一个和第二个部分。索引选择在 [0, 1] 中：
- 0 对应于*句子 A* token，
- 1 对应于*句子 B* token。
什么是 token 类型 ID？
position_ids (torch.Tensor of shape (batch_size, sequence_length), optional) — 位置嵌入中每个输入序列 token 位置的索引。选择范围为 [0, config.n_positions - 1]。

什么是位置 ID？
inputs_embeds (torch.Tensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，你可以选择直接传递嵌入表示，而不是传递 input_ids。如果你希望对如何将 input_ids 索引转换为相关向量有比模型内部嵌入查找矩阵更多的控制，这很有用。
encoder_hidden_states (torch.Tensor of shape (batch_size, sequence_length, hidden_size), optional) — 编码器最后一层输出的隐藏状态序列。如果模型被配置为解码器，则用于交叉注意力。
encoder_attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用于避免在编码器输入填充 token 索引上执行注意力的掩码。如果模型被配置为解码器，则此掩码用于交叉注意力。掩码值选择在 [0, 1] 中：
- 1 表示未被掩码的 token，
- 0 表示被掩码的 token。
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 而不是普通的元组。
cache_position (torch.Tensor of shape (sequence_length), optional) — 指示输入序列 token 在序列中位置的索引。与 position_ids 不同，此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。

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

一个 transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False），包含根据配置 (GPTBigCodeConfig) 和输入而定的各种元素。

last_hidden_state (torch.FloatTensor, 形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。

如果使用了 past_key_values，则只输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。
past_key_values (Cache, optional, 当传递 use_cache=True 或当 config.use_cache=True 时返回) — 它是 Cache 实例。更多详情，请参阅我们的 kv cache 指南。

Contains pre-computed hidden-states (key and values in the self-attention blocks and optionally if config.is_encoder_decoder=True in the cross-attention blocks) that can be used (see past_key_values input) to speed up sequential decoding.
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 后的注意力权重，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True and config.add_cross_attention=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).

解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均。

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

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

GPTBigCodeForCausalLM

class transformers.GPTBigCodeForCausalLM

< source >

参数

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

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

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

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

forward

< source >

( input_ids: torch.Tensor | None = None past_key_values: transformers.cache_utils.Cache | None = None attention_mask: torch.Tensor | None = None token_type_ids: torch.Tensor | None = None position_ids: torch.Tensor | None = None inputs_embeds: torch.Tensor | None = None encoder_hidden_states: torch.Tensor | None = None encoder_attention_mask: torch.Tensor | None = None labels: torch.Tensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None cache_position: torch.Tensor | None = None logits_to_keep: int | torch.Tensor = 0 **kwargs ) → transformers.modeling_outputs.CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

参数

input_ids (torch.Tensor of shape (batch_size, input_ids_length)) — input_ids_length = sequence_length if past_key_values is None else past_key_values.get_seq_length() (输入过去键值状态的 sequence_length)。词汇表中输入序列 token 的索引。
past_key_values (~cache_utils.Cache, optional) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。当 use_cache=True 或 config.use_cache=True 时，这通常由模型在解码的先前阶段返回的 past_key_values 组成。
attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用于避免在填充 token 索引上执行注意力的掩码。掩码值选择在 [0, 1] 中：
- 1 表示未被掩码的 token，
- 0 表示被掩码的 token。
什么是注意力掩码？
token_type_ids (torch.Tensor of shape (batch_size, sequence_length), optional) — 分段 token 索引，用于指示输入的第一个和第二个部分。索引选择在 [0, 1] 中：
- 0 对应于*句子 A* token，
- 1 对应于*句子 B* token。
什么是 token 类型 ID？
position_ids (torch.Tensor of shape (batch_size, sequence_length), optional) — 位置嵌入中每个输入序列 token 位置的索引。选择范围为 [0, config.n_positions - 1]。

什么是位置 ID？
inputs_embeds (torch.Tensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，你可以选择直接传递嵌入表示，而不是传递 input_ids。如果你希望对如何将 input_ids 索引转换为相关向量有比模型内部嵌入查找矩阵更多的控制，这很有用。
encoder_hidden_states (torch.Tensor of shape (batch_size, sequence_length, hidden_size), optional) — 编码器最后一层输出的隐藏状态序列。如果模型被配置为解码器，则用于交叉注意力。
encoder_attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用于避免在编码器输入填充 token 索引上执行注意力的掩码。如果模型被配置为解码器，则此掩码用于交叉注意力。掩码值选择在 [0, 1] 中：
- 1 表示未被掩码的 token，
- 0 表示被掩码的 token。
labels (torch.Tensor of shape (batch_size, input_ids_length), optional) — 用于语言建模的标签。请注意，标签在模型内部已移位，即你可以设置 labels = input_ids。所有设置为 -100 的标签都将被忽略（掩码），损失只针对 [0, ..., config.vocab_size] 中的标签计算。
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 而不是普通的元组。
cache_position (torch.Tensor of shape (sequence_length), optional) — 指示输入序列 token 在序列中位置的索引。与 position_ids 不同，此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。
logits_to_keep (Union[int, torch.Tensor], optional, defaults to 0) — 如果为 int，则计算最后 logits_to_keep 个 token 的 logits。如果为 0，则计算所有 input_ids 的 logits（特殊情况）。生成时只需要最后一个 token 的 logits，只为该 token 计算可以节省内存，这对于长序列或大词汇量大小非常重要。如果为 torch.Tensor，则必须是 1D 张量，对应于序列长度维度中要保留的索引。这在使用打包张量格式（批次和序列长度为单维度）时很有用。

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

一个 transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False），包含根据配置 (GPTBigCodeConfig) 和输入而定的各种元素。

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 后的注意力权重，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — Tuple of torch.FloatTensor (one for each layer) of shape (batch_size, num_heads, sequence_length, sequence_length).

注意力 softmax 后的交叉注意力权重，用于计算交叉注意力头中的加权平均。
past_key_values (Cache, optional, 当传递 use_cache=True 或当 config.use_cache=True 时返回) — 它是 Cache 实例。更多详情，请参阅我们的 kv cache 指南。

包含预先计算的隐藏状态（注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。

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

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

示例

GPTBigCodeForSequenceClassification

class transformers.GPTBigCodeForSequenceClassification

< source >

参数

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

GPTBigCode 模型 transformer，顶部带有一个序列分类头部（线性层）。

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

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

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

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

forward

< source >

( input_ids: torch.Tensor | None = None past_key_values: transformers.cache_utils.Cache | None = None attention_mask: torch.Tensor | None = None token_type_ids: torch.Tensor | None = None position_ids: torch.Tensor | None = None inputs_embeds: torch.Tensor | None = None labels: torch.Tensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None **kwargs ) → transformers.modeling_outputs.SequenceClassifierOutputWithPast or tuple(torch.FloatTensor)

参数

input_ids (torch.Tensor of shape (batch_size, input_ids_length)) — input_ids_length = sequence_length if past_key_values is None else past_key_values.get_seq_length() (输入过去键值状态的 sequence_length)。词汇表中输入序列 token 的索引。
past_key_values (~cache_utils.Cache, optional) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。当 use_cache=True 或 config.use_cache=True 时，这通常由模型在解码的先前阶段返回的 past_key_values 组成。
attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：
- 1 表示**未被掩码**的标记，
- 0 表示**被掩码**的标记。
什么是注意力掩码？
token_type_ids (torch.Tensor of shape (batch_size, sequence_length), optional) — 分段标记索引，用于指示输入的第一个和第二个部分。索引在 [0, 1] 中选择：
- 0 对应于*句子 A* 标记，
- 1 对应于*句子 B* 标记。
什么是标记类型 ID？
position_ids (torch.Tensor of shape (batch_size, sequence_length), optional) — 输入序列中每个标记在位置嵌入中的位置索引。在 [0, config.n_positions - 1] 范围内选择。

什么是位置 ID？
inputs_embeds (torch.Tensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望对如何将 input_ids 索引转换为关联向量有比模型内部嵌入查找矩阵更多的控制，这会很有用。
labels (torch.Tensor of shape (batch_size,), optional) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方误差损失）；如果 config.num_labels > 1，则计算分类损失（交叉熵损失）。
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 而不是普通的元组。

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

A transformers.modeling_outputs.SequenceClassifierOutputWithPast 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False），包含根据配置 (GPTBigCodeConfig) 和输入而定的各种元素。

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 (Cache, optional, 当传递 use_cache=True 或当 config.use_cache=True 时返回) — 它是 Cache 实例。更多详情，请参阅我们的 kv cache 指南。

包含预计算的隐藏状态（自注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。
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 后的注意力权重，用于计算自注意力头中的加权平均值。

The GPTBigCodeForSequenceClassification forward method, overrides the __call__ special method.

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

单标签分类示例

>>> import torch
>>> from transformers import AutoTokenizer, GPTBigCodeForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("gpt_bigcode")
>>> model = GPTBigCodeForSequenceClassification.from_pretrained("gpt_bigcode")

>>> 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 = GPTBigCodeForSequenceClassification.from_pretrained("gpt_bigcode", num_labels=num_labels)

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

多标签分类示例

>>> import torch
>>> from transformers import AutoTokenizer, GPTBigCodeForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("gpt_bigcode")
>>> model = GPTBigCodeForSequenceClassification.from_pretrained("gpt_bigcode", 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 = GPTBigCodeForSequenceClassification.from_pretrained(
...     "gpt_bigcode", 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

GPTBigCodeForTokenClassification

class transformers.GPTBigCodeForTokenClassification

< source >

参数

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

Gpt Bigcode transformer，顶部带有一个标记分类头（位于隐藏状态输出顶部的线性层），例如用于命名实体识别 (NER) 任务。

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

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

forward

< source >

( input_ids: torch.Tensor | None = None past_key_values: transformers.cache_utils.Cache | None = None attention_mask: torch.Tensor | None = None token_type_ids: torch.Tensor | None = None position_ids: torch.Tensor | None = None inputs_embeds: torch.Tensor | None = None labels: torch.Tensor | None = None use_cache: bool | None = None output_attentions: bool | None = None output_hidden_states: bool | None = None return_dict: bool | None = None **kwargs ) → transformers.modeling_outputs.TokenClassifierOutput or tuple(torch.FloatTensor)

参数

input_ids (torch.Tensor of shape (batch_size, input_ids_length)) — input_ids_length = sequence_length if past_key_values is None else past_key_values.get_seq_length()（输入过去键值状态的 sequence_length）。词汇表中输入序列标记的索引。

如果使用了 past_key_values，则只应将尚未计算过去状态的 input_ids 作为 input_ids 传递。

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

什么是输入 ID？
past_key_values (~cache_utils.Cache, optional) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括在解码的先前阶段由模型返回的 past_key_values，当 use_cache=True 或 config.use_cache=True 时。

只允许 Cache 实例作为输入，请参阅我们的 kv cache guide。如果没有传递 past_key_values，默认将初始化 DynamicCache。

模型将输出与作为输入馈入的缓存格式相同的缓存格式。

如果使用了 past_key_values，则用户应只输入形状为 (batch_size, unprocessed_length) 的未处理 input_ids（即未将其过去键值状态提供给此模型的那些），而不是形状为 (batch_size, sequence_length) 的所有 input_ids。
attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：
- 1 表示**未被掩码**的标记，
- 0 表示**被掩码**的标记。
什么是注意力掩码？
token_type_ids (torch.Tensor of shape (batch_size, sequence_length), optional) — 分段标记索引，用于指示输入的第一个和第二个部分。索引在 [0, 1] 中选择：
- 0 对应于*句子 A* 标记，
- 1 对应于*句子 B* 标记。
什么是标记类型 ID？
position_ids (torch.Tensor of shape (batch_size, sequence_length), optional) — 输入序列中每个标记在位置嵌入中的位置索引。在 [0, config.n_positions - 1] 范围内选择。

什么是位置 ID？
inputs_embeds (torch.Tensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望对如何将 input_ids 索引转换为关联向量有比模型内部嵌入查找矩阵更多的控制，这会很有用。
labels (torch.Tensor of shape (batch_size, sequence_length), optional) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方误差损失）；如果 config.num_labels > 1，则计算分类损失（交叉熵损失）。
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 而不是普通的元组。

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

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

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

The GPTBigCodeForTokenClassification forward method, overrides the __call__ special method.

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

示例

>>> from transformers import AutoTokenizer, GPTBigCodeForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("gpt_bigcode")
>>> model = GPTBigCodeForTokenClassification.from_pretrained("gpt_bigcode")

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

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

在 GitHub 上更新

←GPT2 GptOss→