Transformers 文档
Starcoder2
并获得增强的文档体验
开始使用
Starcoder2
概述
StarCoder2 是一系列用于代码的开源 LLM，有 3 种不同大小，参数分别为 3B、7B 和 15B。旗舰模型 StarCoder2-15B 在 The Stack v2 的 4 万亿多个 token 和 600 多种编程语言上进行训练。所有模型都使用分组查询注意力（Grouped Query Attention），上下文窗口为 16,384 个 token，滑动窗口注意力为 4,096 个 token，并使用中间填充（Fill-in-the-Middle）目标进行训练。这些模型已随 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 撰写的论文 StarCoder 2 和 The Stack v2：下一代一同发布。
论文摘要如下：
BigCode 项目是一个专注于代码大型语言模型 (Code LLMs) 负责任开发的开放科学协作项目，它推出了 StarCoder2。我们与 Software Heritage (SWH) 合作，在他们的源代码档案的数字公共基础上构建了 The Stack v2。除了涵盖 619 种编程语言的 SWH 仓库之外，我们还精心选择了其他高质量的数据源，例如 GitHub 拉取请求、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）的关键值头数量。如果num_key_value_heads=num_attention_heads，模型将使用多头注意力（Multi Head Attention (MHA)）；如果num_key_value_heads=1，模型将使用多查询注意力（Multi Query Attention (MQA)），否则使用 GQA。将多头检查点转换为 GQA 检查点时，每个分组键和值头应通过对其组内的所有原始头进行均值池化来构建。有关更多详细信息，请查看此论文。如果未指定，默认为8。 - hidden_act (
str或function, 可选, 默认为"gelu_pytorch_tanh") — 解码器中的非线性激活函数（函数或字符串）。 - max_position_embeddings (
int, 可选, 默认为 4096) — 此模型可能使用的最大序列长度。Starcoder2 的滑动窗口注意力允许序列长度达到 4096*32 个 token。 - initializer_range (
float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态分布初始化器的标准差。 - norm_epsilon (
float, 可选, 默认为 1e-05) — 层归一化的 epsilon 值 - use_cache (
bool, 可选, 默认为True) — 模型是否应返回最后一个键/值注意力（并非所有模型都使用）。仅当config.is_decoder=True时才相关。 - bos_token_id (
int, 可选, 默认为 50256) — 序列开始标记的 ID。 - eos_token_id (
int, 可选, 默认为 50256) — 序列结束标记的 ID。 - rope_theta (
float, 可选, 默认为 10000.0) — RoPE 嵌入的基周期。 - 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’ 一起使用。用于设置线性斜坡函数中（仅）外推边界的参数。如果未指定，则默认为 32。beta_slow(float, 可选): 仅与 ‘yarn’ 一起使用。用于设置线性斜坡函数中（仅）插值边界的参数。如果未指定，则默认为 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.configStarcoder2Model
class transformers.Starcoder2Model
< 来源 >( config: Starcoder2Config )
参数
- config (Starcoder2Config) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化不会加载与模型相关的权重，只加载配置。请查看from_pretrained()方法来加载模型权重。
裸露的Starcoder2模型，输出原始的隐藏状态，没有顶部的任何特定头部。
此模型继承自PreTrainedModel。请查看超类文档，了解库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入大小、修剪头部等）。
此模型也是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[transformers.cache_utils.Cache, list[torch.FloatTensor], 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 cache_position: typing.Optional[torch.LongTensor] = None **flash_attn_kwargs: typing_extensions.Unpack[transformers.modeling_flash_attention_utils.FlashAttentionKwargs] ) → transformers.modeling_outputs.BaseModelOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 词汇表中输入序列标记的索引。默认情况下会忽略填充。可以使用AutoTokenizer获取索引。有关详细信息，请参阅PreTrainedTokenizer.encode()和PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), 可选) — 掩码，用于避免对填充标记索引执行注意力。掩码值选择在[0, 1]之间：- 1 表示**未被掩码**的标记，
- 0 表示**被掩码**的标记。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.n_positions - 1]。 - past_key_values (
Union[~cache_utils.Cache, list[torch.FloatTensor], NoneType]) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码上一阶段返回的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)，而不是所有input_ids形状为(batch_size, sequence_length)。 - 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。 - cache_position (
torch.LongTensor形状为(sequence_length), 可选) — 表示输入序列标记在序列中位置的索引。与position_ids不同，此张量不受填充影响。它用于在正确位置更新缓存并推断完整序列长度。
返回
transformers.modeling_outputs.BaseModelOutputWithPast 或 tuple(torch.FloatTensor)
transformers.modeling_outputs.BaseModelOutputWithPast 或 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False），包含根据配置（Starcoder2Config）和输入而异的各种元素。
-
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 后的注意力权重，用于计算自注意力头中的加权平均值。
Starcoder2Model 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管前向传播的实现需要在该函数中定义，但在此之后应调用 `Module` 实例而不是该函数，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。
Starcoder2ForCausalLM
class transformers.Starcoder2ForCausalLM
< 来源 >( config )
参数
- config (Starcoder2ForCausalLM) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化不会加载与模型相关的权重，只加载配置。请查看from_pretrained()方法来加载模型权重。
用于因果语言建模的Starcoder2模型。
此模型继承自PreTrainedModel。请查看超类文档，了解库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入大小、修剪头部等）。
此模型也是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[transformers.cache_utils.Cache] = 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 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 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 词汇表中输入序列标记的索引。默认情况下会忽略填充。可以使用AutoTokenizer获取索引。有关详细信息，请参阅PreTrainedTokenizer.encode()和PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), 可选) — 掩码，用于避免对填充标记索引执行注意力。掩码值选择在[0, 1]之间：- 1 表示**未被掩码**的标记，
- 0 表示**被掩码**的标记。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.n_positions - 1]。 - past_key_values (
~cache_utils.Cache, 可选) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码上一阶段返回的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)，而不是所有input_ids形状为(batch_size, sequence_length)。 - inputs_embeds (
torch.FloatTensor形状为(batch_size, sequence_length, hidden_size), 可选) — 可选地，你可以选择直接传递嵌入表示，而不是传递input_ids。如果你想对如何将input_ids索引转换为相关向量有比模型内部嵌入查找矩阵更多的控制，这会很有用。 - labels (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 用于计算掩码语言模型损失的标签。索引应在[0, ..., config.vocab_size]或 -100 之间（参见input_ids文档字符串）。索引设置为-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。 - cache_position (
torch.LongTensor形状为(sequence_length), 可选) — 表示输入序列标记在序列中位置的索引。与position_ids不同，此张量不受填充影响。它用于在正确位置更新缓存并推断完整序列长度。 - logits_to_keep (
Union[int, torch.Tensor], 默认为0) — 如果是一个int，则计算最后logits_to_keep个标记的 logits。如果为0，则计算所有input_ids的 logits（特殊情况）。生成时只需要最后一个标记的 logits，只计算该标记可以节省内存，这对于长序列或大词汇量来说非常重要。如果是一个torch.Tensor，则必须是 1D，对应于在序列长度维度中要保留的索引。这在使用打包张量格式（批处理和序列长度的单维度）时很有用。
返回
transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
transformers.modeling_outputs.CausalLMOutputWithPast 或 torch.FloatTensor 元组（如果传递了 return_dict=False 或 config.return_dict=False），包含根据配置（Starcoder2Config）和输入而异的各种元素。
-
loss (
torch.FloatTensor形状为(1,)，可选，当提供labels时返回) — 语言建模损失（用于下一个 token 预测）。 -
logits (形状为
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 语言建模头部的预测分数（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 后的注意力权重，用于计算自注意力头中的加权平均值。
Starcoder2ForCausalLM 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管前向传播的实现需要在该函数中定义，但在此之后应调用 `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 (Starcoder2ForSequenceClassification) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化不会加载与模型相关的权重，只加载配置。请查看from_pretrained()方法来加载模型权重。
带有序列分类头（线性层）的Starcoder2模型转换器。
Starcoder2ForSequenceClassification 使用最后一个标记进行分类，与其他因果模型（例如 GPT-2）一样。
由于它对最后一个标记进行分类，因此需要知道最后一个标记的位置。如果在配置中定义了 pad_token_id，它会在每行中找到不是填充标记的最后一个标记。如果未定义 pad_token_id，它只取批处理中每行的最后一个值。由于当传入 inputs_embeds 而不是 input_ids 时它无法猜测填充标记，因此它会执行相同的操作（取批处理中每行的最后一个值）。
此模型继承自PreTrainedModel。请查看超类文档，了解库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入大小、修剪头部等）。
此模型也是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[transformers.cache_utils.Cache] = 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 ) → transformers.modeling_outputs.SequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 词汇表中输入序列标记的索引。默认情况下会忽略填充。可以使用AutoTokenizer获取索引。有关详细信息，请参阅PreTrainedTokenizer.encode()和PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor形状为(batch_size, sequence_length), 可选) — 掩码，用于避免对填充标记索引执行注意力。掩码值选择在[0, 1]之间：- 1 表示**未被掩码**的标记，
- 0 表示**被掩码**的标记。
- position_ids (
torch.LongTensor形状为(batch_size, sequence_length), 可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.n_positions - 1]。 - past_key_values (
~cache_utils.Cache, 可选) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码上一阶段返回的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)，而不是所有input_ids形状为(batch_size, sequence_length)。 - inputs_embeds (
torch.FloatTensor形状为(batch_size, sequence_length, hidden_size), 可选) — 可选地，你可以选择直接传递嵌入表示，而不是传递input_ids。如果你想对如何将input_ids索引转换为相关向量有比模型内部嵌入查找矩阵更多的控制，这会很有用。 - labels (
torch.LongTensor形状为(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。
返回
transformers.modeling_outputs.SequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.SequenceClassifierOutputWithPast 或一个 torch.FloatTensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），包含根据配置（Starcoder2Config）和输入而异的各种元素。
-
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 后的注意力权重，用于计算自注意力头中的加权平均值。
Starcoder2ForSequenceClassification 的 forward 方法，它会覆盖 `__call__` 特殊方法。
尽管前向传播的实现需要在该函数中定义，但在此之后应调用 `Module` 实例而不是该函数，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。
单标签分类示例
>>> import torch
>>> from transformers import AutoTokenizer, Starcoder2ForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("bigcode/starcoder2-7b")
>>> model = Starcoder2ForSequenceClassification.from_pretrained("bigcode/starcoder2-7b")
>>> 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 = Starcoder2ForSequenceClassification.from_pretrained("bigcode/starcoder2-7b", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...多标签分类示例
>>> import torch
>>> from transformers import AutoTokenizer, Starcoder2ForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("bigcode/starcoder2-7b")
>>> model = Starcoder2ForSequenceClassification.from_pretrained("bigcode/starcoder2-7b", 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 = Starcoder2ForSequenceClassification.from_pretrained(
... "bigcode/starcoder2-7b", 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).lossStarcoder2ForTokenClassification
class transformers.Starcoder2ForTokenClassification
< source >( config )
参数
- config (Starcoder2ForTokenClassification) — 模型的配置类，包含模型的所有参数。使用配置文件初始化时，不会加载与模型相关的权重，只会加载配置。请查看 from_pretrained() 方法以加载模型权重。
Starcoder2 转换器，顶部带有一个 token 分类头（隐藏状态输出顶部的一个线性层），例如用于命名实体识别 (NER) 任务。
此模型继承自PreTrainedModel。请查看超类文档，了解库为其所有模型实现的通用方法（如下载或保存、调整输入嵌入大小、修剪头部等）。
此模型也是PyTorch torch.nn.Module的子类。将其作为常规PyTorch Module使用，并参考PyTorch文档了解所有与通用用法和行为相关的事项。
forward
< source >( 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[transformers.cache_utils.Cache] = 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 ) → transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 词汇表中输入序列 token 的索引。默认情况下会忽略填充。可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免对填充 token 索引执行注意力操作的掩码。掩码值选择在[0, 1]之间：- 1 表示未被掩盖的 token，
- 0 表示被掩盖的 token。
- position_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列 token 在位置嵌入中的位置索引。选择范围为[0, config.n_positions - 1]。 - past_key_values (
~cache_utils.Cache, 可选) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在解码上一阶段返回的 `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`，用户可以选择仅输入形状为
(batch_size, 1)的最后一个 `input_ids`（这些 `input_ids` 没有将其过去的键值状态提供给此模型），而不是形状为(batch_size, sequence_length)的所有 `input_ids`。 - inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想对如何将input_ids索引转换为相关向量有比模型内部嵌入查找矩阵更多的控制，这将非常有用。 - labels (
torch.LongTensor，形状为(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`。
返回
transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.TokenClassifierOutput 或一个 torch.FloatTensor 元组（如果传入 `return_dict=False` 或 `config.return_dict=False`），其中包含根据配置 (Starcoder2Config) 和输入而变化的各种元素。
-
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 后的注意力权重，用于计算自注意力头中的加权平均值。
Starcoder2ForTokenClassification 的 forward 方法，它会覆盖 `__call__` 特殊方法。
尽管前向传播的实现需要在该函数中定义，但在此之后应调用 `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]]
>>> predicted_tokens_classes
...
>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...