Transformers 文档

Starcoder2

Hugging Face's logo
加入 Hugging Face 社区

并获取增强的文档体验

开始使用

Starcoder2

PyTorch FlashAttention SDPA

概述

StarCoder2 是一个用于代码的开放 LLM 系列,有 3 种不同尺寸,参数量分别为 3B、7B 和 15B。旗舰模型 StarCoder2-15B 在超过 4 万亿个 token 和来自 The Stack v2 的 600 多种编程语言上进行了训练。所有模型都使用分组查询注意力(Grouped Query Attention)、16,384 个 token 的上下文窗口(滑动窗口注意力为 4,096 个 token),并使用中间填充(Fill-in-the-Middle)目标进行训练。这些模型已随论文 StarCoder 2 and The Stack v2: The Next Generation 发布,作者包括 Anton Lozhkov、Raymond Li、Loubna Ben Allal、Federico Cassano、Joel Lamy-Poirier、Nouamane Tazi、Ao Tang、Dmytro Pykhtar、Jiawei Liu、Yuxiang Wei、Tianyang Liu、Max Tian、Denis Kocetkov、Arthur Zucker、Younes Belkada、Zijian Wang、Qian Liu、Dmitry Abulkhanov、Indraneil Paul、Zhuang Li、Wen-Ding Li、Megan Risdal、Jia Li、Jian Zhu、Terry Yue Zhuo、Evgenii Zheltonozhskii、Nii Osae Osae Dade、Wenhao Yu、Lucas Krauß、Naman Jain、Yixuan Su、Xuanli He、Manan Dey、Edoardo Abati、Yekun Chai、Niklas Muennighoff、Xiangru Tang、Muhtasham Oblokulov、Christopher Akiki、Marc Marone、Chenghao Mou、Mayank Mishra、Alex Gu、Binyuan Hui、Tri Dao、Armel Zebaze、Olivier Dehaene、Nicolas Patry、Canwen Xu、Julian McAuley、Han Hu、Torsten Scholak、Sebastien Paquet、Jennifer Robinson、Carolyn Jane Anderson、Nicolas Chapados、Mostofa Patwary、Nima Tajbakhsh、Yacine Jernite、Carlos Muñoz Ferrandis、Lingming Zhang、Sean Hughes、Thomas Wolf、Arjun Guha、Leandro von Werra 和 Harm de Vries。

该论文的摘要如下:

BigCode 项目是一个开放科学合作项目,专注于负责任地开发用于代码的大型语言模型(Code LLM),推出了 StarCoder2。我们与 Software Heritage (SWH) 合作,在其源代码档案的数字公共资源之上构建了 The Stack v2。除了涵盖 619 种编程语言的 SWH 存储库外,我们还精心挑选了其他高质量数据源,例如 GitHub pull requests、Kaggle notebooks 和代码文档。这使得我们的训练数据集比第一个 StarCoder 数据集大 4 倍。我们使用参数量为 3B、7B 和 15B 的 StarCoder2 模型在 3.3 到 4.3 万亿个 token 上进行训练,并在全面的 Code LLM 基准测试集上对其进行彻底评估。我们发现,我们的小型模型 StarCoder2-3B 在大多数基准测试中优于其他同等规模的 Code LLM,并且也优于 StarCoderBase-15B。我们的大型模型 StarCoder2-15B 显著优于其他同等规模的模型。此外,它在性能上与 CodeLlama-34B(一个规模是其两倍以上的模型)相当甚至更优。尽管 DeepSeekCoder-33B 是在高资源语言的代码补全方面性能最佳的模型,但我们发现 StarCoder2-15B 在数学和代码推理基准测试以及几种低资源语言上优于它。我们根据 OpenRAIL 许可提供模型权重,并通过发布源代码数据的 SoftWare Heritage 持久标识符 (SWHID) 来确保训练数据的完全透明。

许可

这些模型根据 BigCode OpenRAIL-M v1 许可协议获得许可。

使用提示

StarCoder2 模型可以在 HuggingFace Hub 中找到。您可以在 StarCoder2 的 GitHub 仓库中找到一些关于推理和微调的示例。

这些即用型检查点可以通过 HuggingFace Hub 下载和使用

>>> from transformers import AutoModelForCausalLM, AutoTokenizer

>>> model = AutoModelForCausalLM.from_pretrained("bigcode/starcoder2-7b", device_map="auto")
>>> tokenizer = AutoTokenizer.from_pretrained("bigcode/starcoder2-7b")

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

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

>>> generated_ids = model.generate(**model_inputs, max_new_tokens=10, do_sample=False)
>>> tokenizer.batch_decode(generated_ids)[0]
'def print_hello_world():\n    print("Hello World!")\n\ndef print'

Starcoder2Config

class transformers.Starcoder2Config

< >

( vocab_size = 49152 hidden_size = 3072 intermediate_size = 12288 num_hidden_layers = 30 num_attention_heads = 24 num_key_value_heads = 2 hidden_act = 'gelu_pytorch_tanh' max_position_embeddings = 4096 initializer_range = 0.018042 norm_epsilon = 1e-05 use_cache = True bos_token_id = 50256 eos_token_id = 50256 rope_theta = 10000.0 rope_scaling = None sliding_window = None attention_dropout = 0.0 residual_dropout = 0.0 embedding_dropout = 0.0 use_bias = True **kwargs )

参数

  • vocab_size (int, 可选, 默认为 49152) — Starcoder2 模型的词汇表大小。定义了在调用 Starcoder2Model 时传递的 inputs_ids 可以表示的不同 token 的数量
  • hidden_size (int, 可选, 默认为 3072) — 隐藏层表示的维度。
  • intermediate_size (int, 可选, 默认为 12288) — MLP 表示的维度。
  • num_hidden_layers (int, 可选, 默认为 30) — Transformer 编码器中隐藏层的数量。
  • num_attention_heads (int, 可选, 默认为 24) — Transformer 编码器中每个注意力层的注意力头数。
  • num_key_value_heads (int, 可选, 默认为 2) — 这是用于实现分组查询注意力(Grouped Query Attention)的 key_value 头数。如果 num_key_value_heads=num_attention_heads,模型将使用多头注意力(Multi Head Attention,MHA);如果 num_key_value_heads=1,模型将使用多查询注意力(Multi Query Attention,MQA);否则使用 GQA。当将多头检查点转换为 GQA 检查点时,每个组的 key 和 value 头应通过对该组内所有原始头进行均值池化来构建。有关更多详细信息,请查看 这篇论文。如果未指定,则默认为 8
  • hidden_act (strfunction, 可选, 默认为 "gelu_pytorch_tanh") — 解码器中的非线性激活函数(函数或字符串)。
  • max_position_embeddings (int, 可选, 默认为 4096) — 此模型可能使用的最大序列长度。Starcoder2 的滑动窗口注意力允许处理最多 4096*32 个 token 的序列。
  • initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • norm_epsilon (float, 可选, 默认为 1e-05) — Layer Normalization 层的 epsilon 值
  • use_cache (bool, 可选, 默认为 True) — 模型是否应返回最后的 key/values 注意力(并非所有模型都使用)。仅当 config.is_decoder=True 时相关。
  • bos_token_id (int, 可选, 默认为 50256) — “beginning-of-sequence” token 的 id。
  • eos_token_id (int, 可选, 默认为 50256) — “end-of-sequence” token 的 id。
  • rope_theta (float, 可选, 默认为 10000.0) — RoPE 嵌入的基period。
  • rope_scaling (Dict, 可选) — 包含 RoPE 嵌入的缩放配置的字典。注意:如果您应用新的 rope 类型并期望模型在更长的 max_position_embeddings 上工作,我们建议您相应地更新此值。预期内容:rope_type (str):要使用的 RoPE 的子变体。可以是 [‘default’、‘linear’、‘dynamic’、‘yarn’、‘longrope’、‘llama3’] 之一,其中 ‘default’ 是原始 RoPE 实现。factor (float, 可选):与除 ‘default’ 之外的所有 rope 类型一起使用。应用于 RoPE 嵌入的缩放因子。在大多数缩放类型中,x 的 factor 将使模型能够处理长度为 x * 原始最大预训练长度的序列。original_max_position_embeddings (int, 可选):与 ‘dynamic’、‘longrope’ 和 ‘llama3’ 一起使用。预训练期间使用的原始最大位置嵌入。attention_factor (float, 可选):与 ‘yarn’ 和 ‘longrope’ 一起使用。应用于注意力计算的缩放因子。如果未指定,则默认为实现建议的值,使用 factor 字段来推断建议的值。beta_fast (float, 可选):仅与 ‘yarn’ 一起使用。用于设置线性 ramp 函数中外推(仅限)边界的参数。如果未指定,则默认为 32。beta_slow (float, 可选):仅与 ‘yarn’ 一起使用。用于设置线性 ramp 函数中内插(仅限)边界的参数。如果未指定,则默认为 1。short_factor (List[float], 可选):仅与 ‘longrope’ 一起使用。应用于短上下文(< original_max_position_embeddings)的缩放因子。必须是数字列表,长度与隐藏层大小除以注意力头数再除以 2 相同。long_factor (List[float], 可选):仅与 ‘longrope’ 一起使用。应用于长上下文(< original_max_position_embeddings)的缩放因子。必须是数字列表,长度与隐藏层大小除以注意力头数再除以 2 相同。low_freq_factor (float, 可选):仅与 ‘llama3’ 一起使用。应用于 RoPE 低频分量的缩放因子。high_freq_factor (float, 可选):仅与 ‘llama3’ 一起使用。应用于 RoPE 高频分量的缩放因子。
  • sliding_window (int, 可选) — 滑动窗口注意力窗口大小。如果未指定,则默认为 None (无滑动窗口)。
  • attention_dropout (float, 可选, 默认为 0.0) — 注意力概率的 dropout 比率。
  • residual_dropout (float, 可选, 默认为 0.0) — 残差连接 dropout 值。
  • embedding_dropout (float, 可选, 默认为 0.0) — 嵌入 dropout。
  • use_bias (bool, 可选, 默认为 True) — 是否在模型的线性层上使用偏置项。

这是用于存储 Starcoder2Model 配置的配置类。它用于根据指定的参数实例化 Starcoder2 模型,定义模型架构。使用默认值实例化配置将产生与 bigcode/starcoder2-7b 模型类似的配置。

配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

>>> from transformers import Starcoder2Model, Starcoder2Config

>>> # Initializing a Starcoder2 7B style configuration
>>> configuration = Starcoder2Config()

>>> # Initializing a model from the Starcoder2 7B style configuration
>>> model = Starcoder2Model(configuration)

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

Starcoder2Model

class transformers.Starcoder2Model

< >

( config: Starcoder2Config )

参数

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

裸 Starcoder2 模型,输出原始隐藏状态,顶部没有任何特定的 head。此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝 head 等)。

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch Module,并参考 PyTorch 文档以了解与常规用法和行为相关的所有事项。

Transformer 解码器,由 config.num_hidden_layers 层组成。每层都是一个 Starcoder2DecoderLayer

forward

< >

( input_ids: LongTensor = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Union[typing.List[torch.FloatTensor], transformers.cache_utils.Cache, NoneType] = None inputs_embeds: typing.Optional[torch.FloatTensor] = 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 cache_position: typing.Optional[torch.LongTensor] = None **flash_attn_kwargs: typing_extensions.Unpack[transformers.modeling_flash_attention_utils.FlashAttentionKwargs] )

参数

  • input_ids (形状为 (batch_size, sequence_length)torch.LongTensor) — 词汇表中输入序列 tokens 的索引。如果您提供 padding,默认情况下将被忽略。

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

    什么是输入 IDs?

  • attention_mask (形状为 (batch_size, sequence_length)torch.Tensor, 可选) — 用于避免对 padding token 索引执行注意力的 Mask。 Mask 值选自 [0, 1]:

    • 1 表示 tokens 未被 mask
    • 0 表示 tokens 已被 mask

    什么是注意力 masks?

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

    如果使用 past_key_values,则可以选择仅输入最后一个 input_ids(请参阅 past_key_values)。

    如果您想更改 padding 行为,您应该阅读 modeling_opt._prepare_decoder_attention_mask 并根据您的需求进行修改。有关默认策略的更多信息,请参阅 论文 中的图 1。

    • 1 表示 head 未被 mask
    • 0 表示 head 已被 mask
  • position_ids (形状为 (batch_size, sequence_length)torch.LongTensor, 可选) — 每个输入序列 tokens 在位置嵌入中的位置索引。选自范围 [0, config.n_positions - 1]

    什么是位置 IDs?

  • past_key_values (Cachetuple(tuple(torch.FloatTensor)), 可选) — 预先计算的隐藏状态(自注意力模块和交叉注意力模块中的 key 和 values),可用于加速顺序解码。这通常包括模型在先前解码阶段返回的 past_key_values,当 use_cache=Trueconfig.use_cache=True 时。

    允许两种格式:

    • Cache 实例,请参阅我们的 kv 缓存指南
    • 长度为 config.n_layerstuple(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

  • inputs_embeds (形状为 (batch_size, sequence_length, hidden_size)torch.FloatTensor, 可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联的向量,这将非常有用。
  • use_cache (bool, 可选) — 如果设置为 True,则返回 past_key_values 键值状态,并可用于加速解码(请参阅 past_key_values)。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力 tensors。 请参阅返回的 tensors 下的 attentions 以获取更多详细信息。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。 请参阅返回的 tensors 下的 hidden_states 以获取更多详细信息。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通 tuple。
  • cache_position (形状为 (sequence_length)torch.LongTensor, 可选) — 描述输入序列 tokens 在序列中位置的索引。与 position_ids 相反,此张量不受 padding 的影响。它用于在正确的位置更新缓存并推断完整的序列长度。

Starcoder2Model 的 forward 方法覆盖了 __call__ 特殊方法。

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

Starcoder2ForCausalLM

class transformers.Starcoder2ForCausalLM

< >

( config )

forward

< >

( input_ids: LongTensor = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Union[typing.List[torch.FloatTensor], transformers.cache_utils.Cache, NoneType] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = 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 cache_position: typing.Optional[torch.LongTensor] = None logits_to_keep: typing.Union[int, torch.Tensor] = 0 **kwargs: typing_extensions.Unpack[transformers.models.starcoder2.modeling_starcoder2.KwargsForCausalLM] ) transformers.modeling_outputs.CausalLMOutputWithPast or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。如果您提供 padding,默认情况下 padding 将被忽略。

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

    什么是输入 IDs?

  • attention_mask (torch.Tensor of shape (batch_size, sequence_length), optional) — 用于避免在 padding token 索引上执行 attention 的 Mask。Mask 值在 [0, 1] 中选择:

    • 1 表示 tokens 未被 Mask
    • 0 表示 tokens 被 Mask

    什么是 attention masks?

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

    如果使用 past_key_values,则可以选择仅输入最后一个 input_ids (请参阅 past_key_values)。

    如果您想更改 padding 行为,您应该阅读 modeling_opt._prepare_decoder_attention_mask 并根据您的需要进行修改。 有关默认策略的更多信息,请参见 论文 中的图 1。

    • 1 表示 head 未被 Mask
    • 0 表示 head 被 Mask
  • position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 位置嵌入中每个输入序列 token 的位置索引。在范围 [0, config.n_positions - 1] 中选择。

    什么是位置 IDs?

  • past_key_values (Cache or tuple(tuple(torch.FloatTensor)), optional) — 预先计算的 hidden-states(self-attention 块和 cross-attention 块中的 key 和 values),可用于加速顺序解码。这通常包括模型在先前解码阶段返回的 past_key_values,当 use_cache=Trueconfig.use_cache=True 时。

    允许两种格式:

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

    模型将输出与作为输入馈送的缓存格式相同的格式。 如果未传递 past_key_values,则将返回旧版缓存格式。

    如果使用 past_key_values,则用户可以选择仅输入最后一个 input_ids (那些没有将其 past key value 状态提供给此模型的输入),形状为 (batch_size, 1) 而不是所有形状为 (batch_size, sequence_length)input_ids

  • inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — (可选)您可以选择直接传递嵌入表示,而不是传递 input_ids。 如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联的向量,这将非常有用。
  • use_cache (bool, optional) — 如果设置为 True,则返回 past_key_values 键值状态,并可用于加速解码(请参阅 past_key_values)。
  • output_attentions (bool, optional) — 是否返回所有 attention 层的 attentions 张量。 有关更多详细信息,请参见返回张量下的 attentions
  • output_hidden_states (bool, optional) — 是否返回所有层的 hidden states。 有关更多详细信息,请参见返回张量下的 hidden_states
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
  • cache_position (torch.LongTensor of shape (sequence_length), optional) — 描述输入序列 tokens 在序列中位置的索引。 与 position_ids 相反,此张量不受 padding 的影响。 它用于在正确的位置更新缓存并推断完整序列长度。
  • labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算 masked language modeling loss 的标签。 索引应在 [0, ..., config.vocab_size] 或 -100 中(请参阅 input_ids 文档字符串)。 索引设置为 -100 的 tokens 将被忽略(masked),loss 仅针对标签在 [0, ..., config.vocab_size] 中的 tokens 计算。
  • logits_to_keep (int or torch.Tensor, optional) — 如果为 int,则计算最后 logits_to_keep 个 tokens 的 logits。 如果为 0,则计算所有 input_ids 的 logits(特殊情况)。 生成只需要最后一个 token logits,并且仅针对该 token 计算它们可以节省内存,这对于长序列或大型词汇表大小而言变得非常重要。 如果为 torch.Tensor,则必须是与序列长度维度中要保留的索引相对应的 1D 张量。 这在使用 packed tensor 格式(批次和序列长度的单个维度)时很有用。

返回

transformers.modeling_outputs.CausalLMOutputWithPasttuple(torch.FloatTensor)

一个 transformers.modeling_outputs.CausalLMOutputWithPasttorch.FloatTensor 的元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包括各种元素,具体取决于配置 (Starcoder2Config) 和输入。

  • loss (torch.FloatTensor of shape (1,), optional, 当提供 labels 时返回) — 语言建模 loss(用于下一个 token 预测)。

  • logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模 head 的预测分数(SoftMax 之前每个词汇表 token 的分数)。

  • past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layerstuple(tuple(torch.FloatTensor)) 元组,每个元组具有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量)

    包含预先计算的 hidden-states(self-attention 块中的 key 和 values),可以用于(请参阅 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)

    模型在每层输出处的 Hidden-states 加上可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    attention softmax 之后的 Attentions 权重,用于计算 self-attention heads 中的加权平均值。

Starcoder2ForCausalLM forward 方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, Starcoder2ForCausalLM

>>> model = Starcoder2ForCausalLM.from_pretrained("meta-starcoder2/Starcoder2-2-7b-hf")
>>> tokenizer = AutoTokenizer.from_pretrained("meta-starcoder2/Starcoder2-2-7b-hf")

>>> prompt = "Hey, are you conscious? Can you talk to me?"
>>> inputs = tokenizer(prompt, return_tensors="pt")

>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=30)
>>> tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"Hey, are you conscious? Can you talk to me?\nI'm not conscious, but I can talk to you."

Starcoder2ForSequenceClassification

class transformers.Starcoder2ForSequenceClassification

< >

( config )

参数

  • config (Starcoder2Config) — 模型配置类,其中包含模型的所有参数。 使用配置文件初始化不会加载与模型关联的权重,仅加载配置。 查看 from_pretrained() 方法以加载模型权重。

Starcoder2 模型转换器,顶部带有序列分类 head(线性层)。

Starcoder2ForSequenceClassification 使用最后一个 token 来进行分类,就像其他因果模型(例如 GPT-2)一样。

由于它对最后一个 token 进行分类,因此它需要知道最后一个 token 的位置。 如果在配置中定义了 pad_token_id,它将查找每行中不是 padding token 的最后一个 token。 如果未定义 pad_token_id,它只会获取批次中每行的最后一个值。 由于当传递 inputs_embeds 而不是 input_ids 时,它无法猜测 padding tokens,因此它执行相同的操作(获取批次中每行的最后一个值)。

此模型继承自 PreTrainedModel。 查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝 head 等)

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch Module,并参考 PyTorch 文档以了解与常规用法和行为相关的所有事项。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Union[typing.List[torch.FloatTensor], transformers.cache_utils.Cache, NoneType] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = 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 )

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。如果您提供 padding,默认情况下 padding 将被忽略。

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

    什么是输入 IDs?

  • attention_mask (torch.Tensor,形状为 (batch_size, sequence_length)可选) — 用于避免在 padding token 索引上执行 attention 的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示 token 未被掩盖
    • 0 表示 token 已被掩盖

    什么是 attention 掩码?

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

    如果使用 past_key_values,则可以选择仅输入最后的 input_ids(请参阅 past_key_values)。

    如果要更改 padding 行为,则应阅读 modeling_opt._prepare_decoder_attention_mask 并根据您的需要进行修改。 有关默认策略的更多信息,请参见 论文 中的图 1。

    • 1 表示 head 未被掩盖
    • 0 表示 head 已被掩盖
  • position_ids (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 位置嵌入中每个输入序列 token 的位置索引。 在范围 [0, config.n_positions - 1] 中选择。

    什么是位置 ID?

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

    允许两种格式:

    • Cache 实例,请参阅我们的 kv 缓存指南
    • 长度为 config.n_layerstuple(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

  • inputs_embeds (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递 input_ids。 如果您想要比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联的向量,这将非常有用。
  • use_cache (bool可选) — 如果设置为 True,则返回 past_key_values 键值状态,并且可以用于加速解码(请参阅 past_key_values)。
  • output_attentions (bool可选) — 是否返回所有 attention 层的 attention 张量。 有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。
  • cache_position (torch.LongTensor,形状为 (sequence_length)可选) — 描述输入序列 token 在序列中位置的索引。 与 position_ids 相反,此张量不受 padding 的影响。 它用于在正确的位置更新缓存并推断完整的序列长度。
  • labels (torch.LongTensor,形状为 (batch_size,)可选) — 用于计算序列分类/回归损失的标签。 索引应为 [0, ..., config.num_labels - 1]。 如果 config.num_labels == 1,则计算回归损失(均方损失);如果 config.num_labels > 1,则计算分类损失(交叉熵损失)。

Starcoder2ForSequenceClassification 的 forward 方法,覆盖了 __call__ 特殊方法。

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

Starcoder2ForTokenClassification

class transformers.Starcoder2ForTokenClassification

< >

( config )

参数

  • config (Starcoder2Config) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重,而只会加载配置。 查看 from_pretrained() 方法以加载模型权重。

带有 token 分类 head (位于 hidden-states 输出之上的线性层) 的 Starcoder2 模型 Transformer,例如用于命名实体识别 (NER) 任务。

此模型继承自 PreTrainedModel。 查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝 head 等)

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch Module,并参考 PyTorch 文档以了解与常规用法和行为相关的所有事项。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[typing.List[torch.FloatTensor]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = 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.TokenClassifierOutputtuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。 默认情况下,如果您提供 padding,则会忽略 padding。

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

    什么是输入 ID?

  • attention_mask (torch.Tensor,形状为 (batch_size, sequence_length)可选) — 用于避免在 padding token 索引上执行 attention 的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示 token 未被掩盖
    • 0 表示 token 已被掩盖

    什么是 attention 掩码?

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

    如果使用 past_key_values,则可以选择仅输入最后的 input_ids(请参阅 past_key_values)。

    如果要更改 padding 行为,则应阅读 modeling_opt._prepare_decoder_attention_mask 并根据您的需要进行修改。 有关默认策略的更多信息,请参见 论文 中的图 1。

    • 1 表示 head 未被掩盖
    • 0 表示 head 已被掩盖
  • position_ids (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 位置嵌入中每个输入序列 token 的位置索引。 在范围 [0, config.n_positions - 1] 中选择。

    什么是位置 ID?

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

    允许两种格式:

    • Cache 实例,请参阅我们的 kv 缓存指南
    • 长度为 config.n_layerstuple(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

  • inputs_embeds (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递 input_ids。 如果您想要比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联的向量,这将非常有用。
  • use_cache (bool, 可选) — 如果设置为 True,则会返回 past_key_values 键值状态,并可用于加速解码(请参阅 past_key_values)。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。 更多细节请参阅返回张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。 更多细节请参阅返回张量下的 hidden_states
  • return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。
  • cache_position (torch.LongTensor,形状为 (sequence_length)可选) — 索引,描述输入序列 token 在序列中的位置。 与 position_ids 相反,此张量不受 padding 的影响。 它用于在正确的位置更新缓存,并推断完整的序列长度。
  • labels (torch.LongTensor,形状为 (batch_size,)可选) — 用于计算序列分类/回归损失的标签。 索引应在 [0, ..., config.num_labels - 1] 中。 如果 config.num_labels == 1,则计算回归损失(均方误差损失); 如果 config.num_labels > 1,则计算分类损失(交叉熵损失)。

返回

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

一个 transformers.modeling_outputs.TokenClassifierOutput 或一个 torch.FloatTensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),其中包含取决于配置 (Starcoder2Config) 和输入的各种元素。

  • loss (torch.FloatTensor,形状为 (1,)可选,当提供 labels 时返回) — 分类损失。

  • logits (torch.FloatTensor,形状为 (batch_size, sequence_length, config.num_labels)) — 分类得分(SoftMax 之前)。

  • hidden_states (tuple(torch.FloatTensor), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(如果模型具有嵌入层,则为嵌入输出提供一个,+ 每个层的输出提供一个),形状为 (batch_size, sequence_length, hidden_size)

    模型在每层输出处的 Hidden-states 加上可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    attention softmax 之后的 Attentions 权重,用于计算 self-attention heads 中的加权平均值。

Starcoder2ForTokenClassification 的 forward 方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, Starcoder2ForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("bigcode/starcoder2-7b")
>>> model = Starcoder2ForTokenClassification.from_pretrained("bigcode/starcoder2-7b")

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

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
< > 在 GitHub 上更新