Hugging Face 的 LOGO

Transformers 文档

GPTBigCode

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

GPTBigCode

PyTorch FlashAttention SDPA

概述

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 text-to-code 基准上对它们进行了评估。我们发现，更积极地过滤近似重复数据可以进一步提升性能，而且令人惊讶的是，从拥有 5 个以上 GitHub 星标的仓库中选择文件会显著降低性能。尽管我们的最佳模型小得多，但在 MultiPL-E 的 Java、JavaScript 和 Python 部分，无论是在从左到右的生成还是在填充方面，其性能都超过了以前的开源多语言代码生成模型（InCoder-6.7B 和 CodeGen-Multi-2.7B）。所有模型均根据 OpenRAIL 许可证在此 URL 发布：https://huggingface.co/bigcode。

该模型是一个经过优化的 GPT2 模型，支持多查询注意力（Multi-Query Attention）。

实现细节

与 GPT2 的主要区别。

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

您可以在原始的 pull request 中阅读更多关于优化的信息。

[!NOTE] 当使用除“eager”之外的所有注意力实现时，head_mask 参数将被忽略。如果你有 head_mask 并希望它生效，请使用 XXXModel.from_pretrained(model_id, attn_implementation="eager") 加载模型。

结合 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
>>> device = "cuda" # the device to load the model onto

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

预期加速效果

以下是一个预期的加速图表，比较了在 transformers 中使用 `bigcode/starcoder` 检查点的原生实现与使用两种不同序列长度的 Flash Attention 2 版本的模型之间的纯推理时间。

GPTBigCodeConfig

class transformers.GPTBigCodeConfig

< >

( 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 attention_softmax_in_fp32 = True scale_attention_softmax_in_fp32 = True multi_query = True **kwargs )

参数

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

< >

( config )

参数

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

基础的 Gpt Bigcode 模型，输出原始的隐藏状态，顶部没有任何特定的头（head）。

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

该模型也是 PyTorch torch.nn.Module 的子类。可以像常规 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[list[torch.Tensor]] = None attention_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None encoder_hidden_states: typing.Optional[torch.Tensor] = None encoder_attention_mask: typing.Optional[torch.Tensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions 或 tuple(torch.FloatTensor)

参数

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

    如果使用了 past_key_values，则只有那些尚未计算过其过去状态的 input_ids 才应作为 input_ids 传入。

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

    什么是 input ID？

  • past_key_values (list[torch.Tensor], 可选) — 预先计算的隐藏状态（自注意力和交叉注意力块中的键和值），可用于加速序列解码。这通常包括模型在解码的前一阶段返回的 past_key_values，当 use_cache=True 或 config.use_cache=True 时。

    允许两种格式：

    • Cache 实例，请参阅我们的 KV 缓存指南；
    • 长度为 config.n_layers 的 tuple(torch.FloatTensor) 的元组，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。这也称为旧版缓存格式。

    模型将输出与输入相同的缓存格式。如果没有传入 past_key_values，将返回旧版缓存格式。

    如果使用 past_key_values，用户可以选择只输入最后的 input_ids（那些没有向该模型提供其过去键值状态的词元），形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 input_ids。

  • attention_mask (形状为 (batch_size, sequence_length) 的 torch.Tensor, 可选) — 用于避免对填充词元索引执行注意力的掩码。掩码值选自 [0, 1]：

    • 1 表示词元未被屏蔽，
    • 0 表示词元被屏蔽。

    什么是注意力掩码？

  • token_type_ids (形状为 (batch_size, sequence_length) 的 torch.Tensor, 可选) — 用于指示输入的第一和第二部分的片段词元索引。索引选自 [0, 1]：

    • 0 对应于 *句子 A* 的词元，
    • 1 对应于 *句子 B* 的词元。

    什么是词元类型 ID？

  • position_ids (形状为 (batch_size, sequence_length) 的 torch.Tensor, 可选) — 位置嵌入中每个输入序列词元的位置索引。选自范围 [0, config.n_positions - 1]。

    什么是位置 ID？

  • head_mask (形状为 (num_heads,) 或 (num_layers, num_heads) 的 torch.Tensor, 可选) — 用于置零自注意力模块中选定头的掩码。掩码值选自 [0, 1]：

    • 1 表示头未被屏蔽，
    • 0 表示头被屏蔽。
  • 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, 可选) — 用于避免对编码器输入的填充词元索引执行注意力的掩码。如果模型被配置为解码器，则在交叉注意力中使用此掩码。掩码值选自 [0, 1]：

    • 1 表示词元未被屏蔽，
    • 0 表示词元被屏蔽。
  • use_cache (bool, 可选) — 如果设置为 True，将返回 past_key_values 键值状态，可用于加速解码（请参阅 past_key_values）。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的 attentions。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回

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

一个 transformers.modeling_outputs.BaseModelOutputWithPastAndCrossAttentions 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (GPTBigCodeConfig) 和输入。

  • 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 缓存指南。

    包含预先计算的隐藏状态（自注意力块中的键和值，以及当 config.is_encoder_decoder=True 时，交叉注意力块中的键和值），可用于（参见 past_key_values 输入）加速序列解码。

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

  • cross_attentions (tuple(torch.FloatTensor), 可选, 当传递 output_attentions=True 和 config.add_cross_attention=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

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

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

尽管前向传播的流程需要在此函数内定义，但之后应调用 Module 实例而不是此函数，因为前者会处理运行前处理和后处理步骤，而后者会静默忽略它们。

GPTBigCodeForCausalLM

class transformers.GPTBigCodeForCausalLM

< >

( config )

参数

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

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

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

该模型也是 PyTorch torch.nn.Module 的子类。可以像常规 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[tuple[tuple[torch.Tensor]]] = None attention_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None encoder_hidden_states: typing.Optional[torch.Tensor] = None encoder_attention_mask: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或 tuple(torch.FloatTensor)

参数

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

    如果使用了 past_key_values，则只有那些尚未计算过其过去状态的 input_ids 才应作为 input_ids 传入。

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

    什么是 input ID？

  • past_key_values (tuple[tuple[torch.Tensor]], 可选) — 预先计算的隐藏状态（自注意力和交叉注意力块中的键和值），可用于加速序列解码。这通常包括模型在解码的前一阶段返回的 past_key_values，当 use_cache=True 或 config.use_cache=True 时。

    允许两种格式：

    • Cache 实例，请参阅我们的 KV 缓存指南；
    • 长度为 config.n_layers 的 tuple(torch.FloatTensor) 的元组，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。这也称为旧版缓存格式。

    模型将输出与输入相同的缓存格式。如果没有传入 past_key_values，将返回旧版缓存格式。

    如果使用 past_key_values，用户可以选择只输入最后的 input_ids（那些没有向该模型提供其过去键值状态的词元），形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 input_ids。

  • attention_mask (形状为 (batch_size, sequence_length) 的 torch.Tensor, 可选) — 用于避免对填充词元索引执行注意力的掩码。掩码值选自 [0, 1]：

    • 1 表示词元未被屏蔽，
    • 0 表示词元被屏蔽。

    什么是注意力掩码？

  • token_type_ids (形状为 (batch_size, sequence_length) 的 torch.Tensor, 可选) — 用于指示输入的第一和第二部分的片段词元索引。索引选自 [0, 1]：

    • 0 对应于 *句子 A* 的词元，
    • 1 对应于 *句子 B* 的词元。

    什么是词元类型 ID？

  • position_ids (形状为 (batch_size, sequence_length) 的 torch.Tensor, 可选) — 位置嵌入中每个输入序列词元的位置索引。选自范围 [0, config.n_positions - 1]。

    什么是位置 ID？

  • head_mask (形状为 (num_heads,) 或 (num_layers, num_heads) 的 torch.Tensor, 可选) — 用于置零自注意力模块中选定头的掩码。掩码值选自 [0, 1]：

    • 1 表示头未被屏蔽，
    • 0 表示头被屏蔽。
  • 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, 可选) — 用于避免对编码器输入的填充词元索引执行注意力的掩码。如果模型被配置为解码器，则在交叉注意力中使用此掩码。掩码值选自 [0, 1]：

    • 1 表示词元未被屏蔽，
    • 0 表示词元被屏蔽。
  • labels (形状为 (batch_size, input_ids_length) 的 torch.Tensor, 可选) — 语言建模的标签。请注意，标签在模型内部已移动，即你可以设置 labels = input_ids。索引选自 [-100, 0, ..., config.vocab_size]。所有设置为 -100 的标签都会被忽略（屏蔽），损失仅对 [0, ..., config.vocab_size] 中的标签计算。
  • use_cache (bool, 可选) — 如果设置为 True，将返回 past_key_values 键值状态，可用于加速解码（请参阅 past_key_values）。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的 attentions。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回

transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或 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), 可选, 当传递 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 后的注意力权重，用于计算自注意力头中的加权平均值。

  • cross_attentions (tuple(torch.FloatTensor), 可选, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组（每层一个），形状为 (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 输入）加速顺序解码。

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

尽管前向传播的流程需要在此函数内定义，但之后应调用 Module 实例而不是此函数，因为前者会处理运行前处理和后处理步骤，而后者会静默忽略它们。

示例

GPTBigCodeForSequenceClassification

class transformers.GPTBigCodeForSequenceClassification

< >

( config )

参数

带有序列分类头的 GPTBigCode Transformer 模型（一个线性层）。

GPTBigCodeForSequenceClassification 使用最后一个词元进行分类，与其他因果模型（如 GPT-1）的做法相同。

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

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

该模型也是 PyTorch torch.nn.Module 的子类。可以像常规 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[tuple[tuple[torch.Tensor]]] = None attention_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.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[0][0].shape[-2]（输入过去键值状态的 sequence_length）。词汇表中输入序列标记的索引。

    如果使用了 past_key_values，则只有那些尚未计算过其过去值的 input_ids 才应作为 input_ids 传递。

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

    什么是输入 ID？

  • past_key_values (tuple[tuple[torch.Tensor]], 可选) — 预计算的隐藏状态（自注意力和交叉注意力块中的键和值），可用于加速序列解码。这通常由模型在解码的先前阶段返回的 past_key_values 组成，当 use_cache=True 或 config.use_cache=True 时。

    允许两种格式：

    • Cache 实例，请参阅我们的 kv 缓存指南；
    • 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。这也称为旧版缓存格式。

    模型将输出与输入相同的缓存格式。如果未传递 past_key_values，将返回旧版缓存格式。

    如果使用 past_key_values，用户可以选择只输入最后的 input_ids（那些没有为该模型提供其过去键值状态的标记），形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 input_ids。

  • attention_mask (torch.Tensor，形状为 (batch_size, sequence_length), 可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值选自 [0, 1]：

    • 1 表示标记未被遮盖，
    • 0 表示标记已被遮盖。

    什么是注意力掩码？

  • token_type_ids (torch.Tensor，形状为 (batch_size, sequence_length), 可选) — 段标记索引，用于指示输入的第一部分和第二部分。索引选自 [0, 1]：

    • 0 对应于 *句子 A* 的标记，
    • 1 对应于 *句子 B* 的标记。

    什么是标记类型 ID？

  • position_ids (torch.Tensor，形状为 (batch_size, sequence_length), 可选) — 每个输入序列标记在位置嵌入中的位置索引。选自范围 [0, config.n_positions - 1]。

    什么是位置 ID？

  • head_mask (torch.Tensor，形状为 (num_heads,) 或 (num_layers, num_heads), 可选) — 用于置零自注意力模块中选定头的掩码。掩码值选自 [0, 1]：

    • 1 表示头未被遮盖，
    • 0 表示头已被遮盖。
  • 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）。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

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

一个 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, 可选, 当传递 use_cache=True 或当 config.use_cache=True 时返回) — 这是一个 Cache 实例。有关更多详细信息，请参阅我们的 KV 缓存指南。

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

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

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

尽管前向传播的流程需要在此函数内定义，但之后应调用 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

< >

( config )

参数

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

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

该模型也是 PyTorch torch.nn.Module 的子类。可以像常规 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.Tensor] = None past_key_values: typing.Optional[tuple[tuple[torch.Tensor]]] = None attention_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.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[0][0].shape[-2]（输入过去键值状态的 sequence_length）。词汇表中输入序列标记的索引。

    如果使用了 past_key_values，则只有那些尚未计算过其过去值的 input_ids 才应作为 input_ids 传递。

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

    什么是输入 ID？

  • past_key_values (tuple[tuple[torch.Tensor]], 可选) — 预计算的隐藏状态（自注意力和交叉注意力块中的键和值），可用于加速序列解码。这通常由模型在解码的先前阶段返回的 past_key_values 组成，当 use_cache=True 或 config.use_cache=True 时。

    允许两种格式：

    • Cache 实例，请参阅我们的 kv 缓存指南；
    • 长度为 config.n_layers 的 tuple(torch.FloatTensor) 元组，每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。这也称为旧版缓存格式。

    模型将输出与输入相同的缓存格式。如果未传递 past_key_values，将返回旧版缓存格式。

    如果使用 past_key_values，用户可以选择只输入最后的 input_ids（那些没有为该模型提供其过去键值状态的标记），形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 input_ids。

  • attention_mask (torch.Tensor，形状为 (batch_size, sequence_length), 可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值选自 [0, 1]：

    • 1 表示标记未被遮盖，
    • 0 表示标记已被遮盖。

    什么是注意力掩码？

  • token_type_ids (torch.Tensor，形状为 (batch_size, sequence_length), 可选) — 段标记索引，用于指示输入的第一部分和第二部分。索引选自 [0, 1]：

    • 0 对应于 *句子 A* 的标记，
    • 1 对应于 *句子 B* 的标记。

    什么是标记类型 ID？

  • position_ids (torch.Tensor，形状为 (batch_size, sequence_length), 可选) — 每个输入序列标记在位置嵌入中的位置索引。选自范围 [0, config.n_positions - 1]。

    什么是位置 ID？

  • head_mask (torch.Tensor，形状为 (num_heads,) 或 (num_layers, num_heads), 可选) — 用于置零自注意力模块中选定头的掩码。掩码值选自 [0, 1]：

    • 1 表示头未被遮盖，
    • 0 表示头已被遮盖。
  • 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）。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

返回

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

一个 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), 可选, 当传递 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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

尽管前向传播的流程需要在此函数内定义，但之后应调用 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 GPTSAN Japanese→