Transformers 文档

GPTBigCode

Transformers

加入 Hugging Face 社区

并获得增强的文档体验

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

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

切换文档主题

开始使用

该模型于 2023 年 1 月 9 日在 HF 论文中发布，并于 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 子集训练了 11 亿参数的模型，并在 MultiPL-E 代码生成基准上进行了评估。我们发现，更积极地过滤近重复项可以进一步提升性能；令人惊讶的是，选择拥有 5 个以上 GitHub 星标的存储库中的文件反而会显著降低性能。尽管模型体积要小得多，但我们最好的模型在 MultiPL-E 的 Java、JavaScript 和 Python 部分的从左到右生成和补全任务中，均优于以前的开源多语言代码生成模型（InCoder-6.7B 和 CodeGen-Multi-2.7B）。所有模型均在 OpenRAIL 许可下发布，详见此 HTTPS URL。

该模型是一个优化的 GPT2 模型，支持多查询注意力机制 (Multi-Query Attention)。

实现细节

与 GPT2 相比的主要区别：

增加了对多查询注意力机制 (Multi-Query Attention) 的支持。
使用 gelu_pytorch_tanh 代替经典的 gelu。
避免不必要的同步（此项改进后来已在 #20061 中添加到 GPT2，但参考代码库中此前未包含）。
使用线性层代替 Conv1D（速度提升明显，但导致检查点不兼容）。
合并 _attn 和 _upcast_and_reordered_attn。始终将矩阵乘法与缩放合并。将 reorder_and_upcast_attn 重命名为 attention_softmax_in_fp32。
缓存注意力掩码值，以避免每次都重新创建。
使用 JIT 融合注意力 FP32 类型转换、掩码、Softmax 和缩放操作。
将注意力掩码和因果掩码合并为一个，并在整个模型层面预先计算，而非在每一层计算。
将键（Key）和值（Value）缓存合并为一个（这改变了 layer_past/present 的格式，是否存在风险？）。
在 MHA 中使用内存布局 (self.num_heads, 3, self.head_dim) 代替 (3, self.num_heads, self.head_dim) 作为 QKV 张量（防止合并键值带来的开销，但这使得检查点与原始的 openai-community/gpt2 模型不兼容）。

您可以阅读原始 Pull Request 以了解更多关于优化的信息。

结合 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 加载和运行模型，请参考以下代码片段。

from transformers import AutoModelForCausalLM, AutoTokenizer


model = AutoModelForCausalLM.from_pretrained("bigcode/gpt_bigcode-santacoder", device_map="auto", 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(model.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

< 源代码 >

( transformers_version: str | None = None architectures: list[str] | None = None output_hidden_states: bool | None = False return_dict: bool | None = True dtype: typing.Union[str, ForwardRef('torch.dtype'), NoneType] = None chunk_size_feed_forward: int = 0 is_encoder_decoder: bool = False id2label: dict[int, str] | dict[str, str] | None = None label2id: dict[str, int] | dict[str, str] | None = None problem_type: typing.Optional[typing.Literal['regression', 'single_label_classification', 'multi_label_classification']] = None vocab_size: int = 50257 n_positions: int = 1024 n_embd: int = 768 n_layer: int = 12 n_head: int = 12 n_inner: int | None = None activation_function: str = 'gelu_pytorch_tanh' resid_pdrop: float | int = 0.1 embd_pdrop: float | int = 0.1 attn_pdrop: float | int = 0.1 layer_norm_epsilon: float = 1e-05 initializer_range: float = 0.02 scale_attn_weights: bool = True use_cache: bool = True bos_token_id: int | None = 50256 eos_token_id: int | list[int] | None = 50256 pad_token_id: int | None = None attention_softmax_in_fp32: bool = True scale_attention_softmax_in_fp32: bool = True multi_query: bool = True add_cross_attention: bool = False tie_word_embeddings: bool = True )

参数

vocab_size (int, 可选, 默认值为 50257) — 模型的词汇表大小。定义了 input_ids 可以表示的不同标记的数量。
n_positions (int, 可选, 默认值为 1024) — 该模型可能使用的最大序列长度。
n_embd (int, 可选, 默认值为 768) — 嵌入层和隐藏状态的维度。
n_layer (int, 可选, 默认值为 12) — Transformer 解码器中的隐藏层数量。
n_head (int, 可选, 默认值为 12) — Transformer 解码器中每个注意力层的注意力头数量。
n_inner (int, 可选) — MLP 表示的维度。
activation_function (str, 可选, 默认值为 gelu_pytorch_tanh) — 解码器中的非线性激活函数（函数或字符串）。例如 "gelu", "relu", "silu" 等。
resid_pdrop (Union[float, int], 可选, 默认值为 0.1) — 嵌入层、编码器和池化层中所有全连接层的丢弃（Dropout）概率。
embd_pdrop (Union[float, int], 可选, 默认值为 0.1) — 嵌入层的丢弃比率。
attn_pdrop (Union[float, int], 可选, 默认值为 0.1) — 注意力概率的丢弃比率。
layer_norm_epsilon (float, 可选, 默认值为 1e-05) — 层归一化层使用的 epsilon 值。
initializer_range (float, 可选, 默认值为 0.02) — 用于初始化所有权重矩阵的截断正态分布初始化器（truncated_normal_initializer）的标准差。
scale_attn_weights (bool, 可选, 默认值为 True) — 通过除以 sqrt(hidden_size) 来缩放注意力权重。
use_cache (bool, 可选, 默认值为 True) — 模型是否应该返回最后的键/值注意力（并非所有模型都使用）。仅在 config.is_decoder=True 或模型为仅解码器生成模型时相关。
bos_token_id (int, 可选, 默认为 50256) — 词表中用于表示流开始（beginning-of-stream）的 Token ID。
eos_token_id (Union[int, list[int]], 可选, 默认为 50256) — 词表中用于表示流结束（end-of-stream）的 Token ID。
pad_token_id (int, 可选) — 词表中用于填充（padding）的 Token ID。
attention_softmax_in_fp32 (bool, 可选, 默认为 True) — 是否在 float32 中执行融合 softmax（fused softmax）。
scale_attention_softmax_in_fp32 (bool, 可选, 默认为 True) — 是否在 float32 中缩放注意力 softmax。
multi_query (bool, 可选, 默认为 True) — 是否在解码器中使用多查询注意力（multi-query attention）。当 new_decoder_architecture 为 True 时此项会被忽略。
add_cross_attention (bool, 可选, 默认为 False) — 是否应该向模型添加交叉注意力层。
tie_word_embeddings (bool, 可选, 默认为 True) — 是否根据模型的 tied_weights_keys 映射来绑定权重嵌入。

这是用于存储 GPTBigCodeModel 配置的配置类。它根据指定的参数实例化 Gpt Bigcode 模型，从而定义模型架构。使用默认值实例化配置将产生与 google/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

< 源码 >

( 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 模型，输出原始隐藏状态，顶部没有任何特定的头（head）。

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

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

forward

< 源码 >

( 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 **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → BaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)

参数

input_ids (形状为 (batch_size, input_ids_length) 的 torch.Tensor) — 如果 past_key_values 为 None，则 input_ids_length = sequence_length，否则 input_ids_length = past_key_values.get_seq_length()（输入过去键值状态的 sequence_length）。词表中输入序列 Token 的索引。

如果使用 past_key_values，则只需将未计算过过去状态的 input_ids 作为 input_ids 传入。

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

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

仅允许 Cache 实例作为输入，请参阅我们的 kv 缓存指南。如果未传入 past_key_values，将默认初始化 DynamicCache。

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

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

什么是位置 ID？
inputs_embeds (形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor, 可选) — 可选地，你可以选择直接传入嵌入表示，而不是传入 input_ids。如果你想比模型内部的嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量，这会很有用。
encoder_hidden_states (形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor, 可选) — 编码器最后一层输出的隐藏状态序列。如果模型配置为解码器，则用于交叉注意力中。
encoder_attention_mask (形状为 (batch_size, sequence_length) 的 torch.Tensor, 可选) — 用于避免对编码器输入的填充 Token 索引执行注意力的掩码。如果模型配置为解码器，此掩码用于交叉注意力中。掩码值选自 [0, 1]：
- 1 表示 未掩码 的 Token，
- 0 表示 被掩码 的 Token。
use_cache (bool, 可选) — 如果设置为 True，将返回 past_key_values 键值状态，并可用于加速解码（参见 past_key_values）。

BaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)

BaseModelOutputWithPastAndCrossAttentions 或 torch.FloatTensor 的元组（如果传入 return_dict=False 或当 config.return_dict=False 时），根据配置（GPTBigCodeConfig）和输入，包含各种元素。

GPTBigCodeModel 的 forward 方法，重写了 __call__ 特殊方法。

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

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

如果使用了 past_key_values，则只输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。
past_key_values (Cache，*可选*，当传入 use_cache=True 或 config.use_cache=True 时返回) — 这是一个 Cache 实例。欲了解更多细节，请参阅我们的 KV 缓存指南。

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 之后，用于计算交叉注意力头中的加权平均。

GPTBigCodeForCausalLM

class transformers.GPTBigCodeForCausalLM

< 源码 >

参数

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

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

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

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

forward

< 源码 >

( 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 logits_to_keep: int | torch.Tensor = 0 **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → CausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)

参数

input_ids (torch.Tensor，形状为 (batch_size, input_ids_length)) — input_ids_length = sequence_length（若 past_key_values 为 None），否则为 past_key_values.get_seq_length()（输入过去键值状态的 sequence_length）。词表中的输入序列 token 索引。

如果使用 past_key_values，则仅应将未计算其过去状态的 input_ids 作为 input_ids 传入。

索引可以使用 AutoTokenizer 获取。详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

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

仅允许输入 Cache 实例，请参阅我们的 kv 缓存指南。若未传入 past_key_values，默认将初始化 DynamicCache。

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

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

什么是 position IDs？
inputs_embeds (torch.Tensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，你可以选择直接传递嵌入表示，而不是传递 input_ids。如果你希望比模型内部的嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量，这将非常有用。
encoder_hidden_states (torch.Tensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 编码器最后一层输出的隐藏状态序列。如果模型配置为解码器，则用于交叉注意力中。
encoder_attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于避免对编码器输入的填充 token 索引执行注意力的掩码。如果模型配置为解码器，该掩码用于交叉注意力中。掩码值选自 [0, 1]：
- 1 表示 未掩码 的 token，
- 0 表示 已掩码 的 token。
labels (torch.Tensor，形状为 (batch_size, input_ids_length)，可选) — 语言建模的标签。注意，模型内部会移位标签，即你可以设置 labels = input_ids。索引选自 [-100, 0, ..., config.vocab_size]。所有设置为 -100 的标签都将被忽略（掩码），损失仅针对 [0, ..., config.vocab_size] 中的标签计算。
use_cache (bool, 可选) — 如果设置为 True，将返回 past_key_values 键值状态，并可用于加速解码（参见 past_key_values）。
logits_to_keep (Union[int, torch.Tensor], 可选，默认为 0) — 如果为 int，则计算最后 logits_to_keep 个 token 的 logits。如果为 0，则计算所有 input_ids 的 logits（特殊情况）。生成时仅需要最后一个 token 的 logits，仅为该 token 计算 logits 可以节省内存，这对于长序列或大词表大小来说非常显著。如果为 torch.Tensor，则必须是一维的，对应于序列长度维度中要保留的索引。这在使用打包张量格式（batch 和序列长度的单一维度）时非常有用。

CausalLMOutputWithCrossAttentions or tuple(torch.FloatTensor)

一个 CausalLMOutputWithCrossAttentions 或一个 torch.FloatTensor 的元组（如果传入 return_dict=False 或当 config.return_dict=False 时），根据配置（GPTBigCodeConfig）和输入，包含各种元素。

GPTBigCodeForCausalLM 的前向传播方法，覆盖了 __call__ 特殊方法。

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

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，*可选*，当传入 use_cache=True 或 config.use_cache=True 时返回) — 这是一个 Cache 实例。欲了解更多细节，请参阅我们的 KV 缓存指南。

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

示例

GPTBigCodeForSequenceClassification

class transformers.GPTBigCodeForSequenceClassification

< 源码 >

参数

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

顶部带有序列分类头（线性层）的 GPTBigCode 模型转换器。

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

< 源码 >

( 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 **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → SequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)

参数

input_ids (torch.Tensor，形状为 (batch_size, input_ids_length)) — input_ids_length = sequence_length（若 past_key_values 为 None），否则为 past_key_values.get_seq_length()（输入过去键值状态的 sequence_length）。词表中的输入序列 token 索引。

如果使用 past_key_values，则仅应将未计算其过去状态的 input_ids 作为 input_ids 传入。

索引可以使用 AutoTokenizer 获取。详情请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

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

仅允许输入 Cache 实例，请参阅我们的 kv 缓存指南。若未传入 past_key_values，默认将初始化 DynamicCache。

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

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

什么是位置 ID？
inputs_embeds (torch.Tensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您想比使用模型内部的嵌入查找矩阵更好地控制如何将 input_ids 索引转换为相关向量，这非常有用。
labels (torch.Tensor，形状为 (batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方误差损失）；如果 config.num_labels > 1，则计算分类损失（交叉熵损失）。
use_cache (bool，可选) — 如果设置为 True，将返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。

SequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)

一个 SequenceClassifierOutputWithPast 或一个 torch.FloatTensor 元组（如果传入了 return_dict=False 或当 config.return_dict=False 时），根据配置（GPTBigCodeConfig）和输入，包含各种元素。

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

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

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，*可选*，当传入 use_cache=True 或 config.use_cache=True 时返回) — 这是一个 Cache 实例。欲了解更多细节，请参阅我们的 KV 缓存指南。

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

单标签分类示例

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

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

< 源代码 >

参数

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

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

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

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

forward

< 源代码 >

( 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 **kwargs: typing_extensions.Unpack[transformers.utils.generic.TransformersKwargs] ) → TokenClassifierOutput 或 tuple(torch.FloatTensor)

参数

input_ids (torch.Tensor，形状为 (batch_size, input_ids_length)) — input_ids_length = sequence_length（如果 past_key_values 为 None），否则为 past_key_values.get_seq_length()（输入过去键值状态的 sequence_length）。词汇表中输入序列 token 的索引。

如果使用了 past_key_values，则仅应将尚未计算过去的 input_ids 作为 input_ids 传入。

索引可以使用 AutoTokenizer 获取。详情请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.__call__()。

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

仅允许使用 Cache 实例作为输入，请参阅我们的 kv 缓存指南。如果没有传入 past_key_values，默认将初始化 DynamicCache。

模型将输出与输入时相同的缓存格式。

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

什么是位置 ID？
inputs_embeds (torch.Tensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您想比使用模型内部的嵌入查找矩阵更好地控制如何将 input_ids 索引转换为相关向量，这非常有用。
labels (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方误差损失）；如果 config.num_labels > 1，则计算分类损失（交叉熵损失）。
use_cache (bool，可选) — 如果设置为 True，将返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。

TokenClassifierOutput 或 tuple(torch.FloatTensor)

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

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

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

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 后的注意力权重，用于计算自注意力头中的加权平均值。

示例

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

>>> tokenizer = AutoTokenizer.from_pretrained("google/gpt_bigcode")
>>> model = GPTBigCodeForTokenClassification.from_pretrained("google/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→