Transformers 文档

Nemotron

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

Nemotron

PyTorch FlashAttention SDPA

许可

本模型的使用受NVIDIA AI 基础模型社区许可协议管辖。

描述

Nemotron-4 是一个企业就绪的生成文本模型系列,与 NVIDIA NeMo 框架兼容。

NVIDIA NeMo 是一个端到端、云原生平台,用于在任何地方构建、定制和部署生成式 AI 模型。它包括训练和推理框架、防护工具包、数据管理工具和预训练模型,为企业提供了一种简单、经济高效且快速的方式来采用生成式 AI。要访问 NeMo 框架,请在此链接注册:this link

参考

公告博客

模型架构

架构类型: Transformer

网络架构: Transformer 解码器 (自回归语言模型)。

Minitron

Minitron 4B Base

Minitron 是一系列小型语言模型 (SLM),通过剪枝 NVIDIA 的 Nemotron-4 15B 模型获得。我们对模型嵌入大小、注意力头数和 MLP 中间维度进行剪枝,然后进行持续训练和知识蒸馏,最终得到最终模型。

与从头开始训练相比,使用我们的方法从基础 15B 模型衍生出 Minitron 8B 和 4B 模型,每个模型所需的训练 tokens 数量最多可减少 40 倍;这为训练整个模型系列(15B、8B 和 4B)节省了 1.8 倍的计算成本。 与从头开始训练相比,Minitron 模型在 MMLU 分数上提升高达 16%,性能与其他社区模型(如 Mistral 7B、Gemma 7B 和 Llama-3 8B)相当,并且优于文献中最先进的压缩技术。 请参阅我们的 arXiv 论文 以了解更多详细信息。

Minitron 模型仅供研究和开发使用。

HuggingFace 快速入门

以下代码示例说明了如何加载 Minitron-4B 模型并使用它执行文本生成。

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

# Load the tokenizer and model
model_path = 'nvidia/Minitron-4B-Base'
tokenizer  = AutoTokenizer.from_pretrained(model_path)

device = 'cuda'
dtype  = torch.bfloat16
model  = AutoModelForCausalLM.from_pretrained(model_path, torch_dtype=dtype, device_map=device)

# Prepare the input text
prompt = 'Complete the paragraph: our solar system is'
inputs = tokenizer.encode(prompt, return_tensors='pt').to(model.device)

# Generate the output
outputs = model.generate(inputs, max_length=20)

# Decode and print the output
output_text = tokenizer.decode(outputs[0])
print(output_text)

许可

Minitron 根据 NVIDIA Open Model License Agreement 发布。

评估结果

5-shot 性能。 使用 Massive Multitask Language Understanding 评估语言理解能力

平均值
58.6

Zero-shot 性能。 使用来自 LM Evaluation Harness 的精选数据集以及其他数据集进行评估

HellaSwag Winogrande GSM8K ARC-C XLSum
75.0 74.0 24.1 50.9 29.5

代码生成性能。 使用 HumanEval 评估

p@1, 0-Shot
23.3

请参阅我们的 论文 以获取完整的结果集。

引用

如果您觉得我们的工作有帮助,请考虑引用我们的论文

@article{minitron2024,
      title={Compact Language Models via Pruning and Knowledge Distillation},
      author={Saurav Muralidharan and Sharath Turuvekere Sreenivas and Raviraj Joshi and Marcin Chochowski and Mostofa Patwary and Mohammad Shoeybi and Bryan Catanzaro and Jan Kautz and Pavlo Molchanov},
      journal={arXiv preprint arXiv:2407.14679},
      year={2024},
      url={https://arxiv.org/abs/2407.14679},
}

NemotronConfig

class transformers.NemotronConfig

< >

( vocab_size = 256000 hidden_size = 6144 intermediate_size = 24576 num_hidden_layers = 32 num_attention_heads = 48 head_dim = None num_key_value_heads = None hidden_act = 'relu2' max_position_embeddings = 4096 initializer_range = 0.0134 norm_eps = 1e-05 use_cache = True pad_token_id = None bos_token_id = 2 eos_token_id = 3 tie_word_embeddings = False rope_theta = 10000.0 partial_rotary_factor = 0.5 attention_bias = False attention_dropout = 0.0 mlp_bias = False **kwargs )

参数

  • vocab_size (int可选,默认为 256000) — Nemotron 模型的词汇表大小。 定义了调用 NemotronModel 时传递的 inputs_ids 可以表示的不同 tokens 的数量
  • hidden_size (int可选,默认为 6144) — 隐藏层表示的维度。
  • intermediate_size (int可选,默认为 24576) — MLP 表示的维度。
  • num_hidden_layers (int可选,默认为 32) — Transformer 解码器中隐藏层的数量。
  • num_attention_heads (int可选,默认为 48) — Transformer 解码器中每个注意力层的注意力头数。
  • head_dim (int可选) — 多头注意力中的投影权重维度。如果为 None,则设置为 hidden_size // num_attention_heads
  • num_key_value_heads (int可选) — 这是用于实现分组查询注意力 (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 头应通过对该组内所有原始头进行均值池化来构建。有关更多详细信息,请查看 本文。如果未指定,则默认为 num_attention_heads
  • hidden_act (strfunction可选,默认为 "relu2") — 解码器中的非线性激活函数(函数或字符串)。
  • max_position_embeddings (int可选,默认为 4096) — 此模型可能使用的最大序列长度。
  • initializer_range (float可选,默认为 0.0134) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • norm_eps (float可选,默认为 1e-05) — 归一化层使用的 epsilon 值。
  • use_cache (bool可选,默认为 True) — 模型是否应返回最后的 key/values 注意力 (并非所有模型都使用)。仅当 config.is_decoder=True 时相关。
  • pad_token_id (int可选) — 填充 token ID。
  • bos_token_id (int可选,默认为 2) — 流开始 token ID。
  • eos_token_id (int可选,默认为 3) — 流结束 token ID。
  • tie_word_embeddings (bool可选,默认为 False) — 是否绑定权重嵌入
  • rope_theta (float可选,默认为 10000.0) — RoPE 嵌入的基period。
  • partial_rotary_factor (float, optional, 默认值为 0.5) — 查询和键中将应用 rotary embedding 的百分比。
  • attention_bias (bool, optional, 默认值为 False) — 是否在自注意力期间在查询、键、值和输出投影层中使用偏置。
  • attention_dropout (float, optional, 默认值为 0.0) — 注意力概率的 dropout 比率。
  • mlp_bias (bool, optional, 默认值为 False) — 是否在 MLP 层中的 up_proj 和 down_proj 层中使用偏置。

这是用于存储 NemotronModel 配置的配置类。 它用于根据指定的参数实例化 Nemotron 模型,定义模型架构。使用默认值实例化配置将产生与 Nemotron-8B 类似的配置。例如 nvidia/nemotron-3-8b-base-4k-hf。配置对象继承自 PretrainedConfig,可用于控制模型输出。 有关更多信息,请阅读 PretrainedConfig 的文档。

>>> from transformers import NemotronModel, NemotronConfig

>>> # Initializing a Nemotron nemotron-15b style configuration
>>> configuration = NemotronConfig()

>>> # Initializing a model from the nemotron-15b style configuration
>>> model = NemotronModel(configuration)

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

NemotronModel

class transformers.NemotronModel

< >

( config: NemotronConfig )

参数

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

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

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

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

forward

< >

( input_ids: 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, typing.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 return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None )

参数

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

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

    什么是输入 IDs?

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

    • 1 表示 未被掩盖 的 tokens,
    • 0 表示 被掩盖 的 tokens。

    什么是注意力掩码?

    索引可以使用 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 (形状为 (batch_size, sequence_length)torch.LongTensor, optional) — 位置 embeddings 中每个输入序列 token 的位置索引。 在范围 [0, config.n_positions - 1] 中选择。

    什么是位置 IDs?

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

    允许两种格式:

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

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

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

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

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

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

NemotronForCausalLM

class transformers.NemotronForCausalLM

< >

( 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[transformers.cache_utils.Cache, typing.List[torch.FloatTensor], 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 **loss_kwargs ) transformers.modeling_outputs.CausalLMOutputWithPasttuple(torch.FloatTensor)

参数

  • 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 索引上执行 attention 的掩码。在 [0, 1] 中选择的掩码值:

    • 1 表示 tokens 未被掩盖
    • 0 表示 tokens 被掩盖

    什么是 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 未被掩盖
    • 0 表示 head 被掩盖
  • position_ids (形状为 (batch_size, sequence_length)torch.LongTensor, 可选) — 位置 embeddings 中每个输入序列 tokens 的位置索引。在范围 [0, config.n_positions - 1] 中选择。

    什么是位置 IDs?

  • past_key_values (Cachetuple(tuple(torch.FloatTensor)), 可选) — 预先计算的 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)),其中每个 tuple 有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head)) 的 tensors。 这也称为旧版 cache 格式。

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

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

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

返回

transformers.modeling_outputs.CausalLMOutputWithPasttuple(torch.FloatTensor)

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

  • loss (形状为 (1,)torch.FloatTensor, 可选, 当提供 labels 时返回) — 语言建模损失(用于下一个 token 预测)。

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

  • past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layerstuple(tuple(torch.FloatTensor)),其中每个 tuple 有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head)) 的 tensors

    包含预先计算的 hidden-states(self-attention 块中的 key 和 values),可以用于(请参阅 past_key_values 输入)加速顺序解码。

  • hidden_states (tuple(torch.FloatTensor), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的 tuple(如果模型具有 embedding 层,则为 embeddings 的输出 + 每层的输出一个)形状为 (batch_size, sequence_length, hidden_size)

    每个层输出以及可选的初始 embedding 输出处的模型的 hidden-states。

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

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

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

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

示例

>>> from transformers import AutoTokenizer, NemotronForCausalLM

>>> model = NemotronForCausalLM.from_pretrained("nvidia/nemotron-3-8b-base-4k-hf")
>>> tokenizer = AutoTokenizer.from_pretrained("nvidia/nemotron-3-8b-base-4k-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."

NemotronForSequenceClassification

class transformers.NemotronForSequenceClassification

< >

( config )

参数

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

Nemotron 模型 transformer,顶部带有序列分类 head(线性层)。

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

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

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

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参考 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, typing.List[torch.FloatTensor], 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 (形状为 (batch_size, sequence_length)torch.LongTensor) — 词汇表中输入序列 tokens 的索引。如果您提供 padding,默认情况下将被忽略。

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

    什么是输入 IDs?

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

    • 1 表示 token 未被掩码
    • 0 表示 token 被掩码

    什么是 attention 掩码?

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

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

    如果要更改填充行为,您应该阅读 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))可选) — 预先计算的隐藏状态(self-attention 块和 cross-attention 块中的键和值),可用于加速顺序解码。 这通常包括模型在先前解码阶段返回的 past_key_values,当 use_cache=Trueconfig.use_cache=True 时。

    允许两种格式:

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

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

    如果使用 past_key_values,用户可以选择仅输入最后的 input_ids(那些没有将其过去的键值状态提供给此模型的输入 ID),形状为 (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 层的 attentions 张量。 有关更多详细信息,请参见返回张量下的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参见返回张量下的 hidden_states
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通的元组。
  • cache_position (torch.LongTensor,形状为 (sequence_length)可选) — 描述输入序列 token 在序列中位置的索引。 与 position_ids 相反,此张量不受填充的影响。 它用于在正确的位置更新缓存并推断完整序列长度。
  • labels (torch.LongTensor,形状为 (batch_size,)可选) — 用于计算序列分类/回归损失的标签。 索引应在 [0, ..., config.num_labels - 1] 中。 如果 config.num_labels == 1,则计算回归损失(均方误差损失)。 如果 config.num_labels > 1,则计算分类损失(交叉熵损失)。

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

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

NemotronForQuestionAnswering

class transformers.NemotronForQuestionAnswering

< >

( config )

参数

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

Nemotron 模型 Transformer,顶部带有一个 span 分类头,用于执行抽取式问答任务,如 SQuAD(隐藏状态输出顶部的线性层,用于计算 span start logitsspan end logits)。

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

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

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Union[transformers.cache_utils.Cache, typing.List[torch.FloatTensor], NoneType] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None start_positions: typing.Optional[torch.LongTensor] = None end_positions: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs )

参数

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

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

    什么是输入 ID?

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

    • 1 表示 token 未被掩码
    • 0 表示 token 被掩码

    什么是 attention 掩码?

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

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

    如果要更改填充行为,您应该阅读 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))可选) — 预先计算的隐藏状态(self-attention 块和 cross-attention 块中的键和值),可用于加速顺序解码。 这通常包括模型在先前解码阶段返回的 past_key_values,当 use_cache=Trueconfig.use_cache=True 时。

    允许两种格式:

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

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

    如果使用 past_key_values,用户可以选择仅输入最后的 input_ids(那些没有将其过去的键值状态提供给此模型的输入 ID),形状为 (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 层的 attentions 张量。 有关更多详细信息,请参见返回张量下的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参见返回张量下的 hidden_states
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是纯粹的元组。
  • cache_position (torch.LongTensor,形状为 (sequence_length)可选) — 描述输入序列 token 在序列中位置的索引。与 position_ids 相反,此张量不受 padding 的影响。它用于在正确的位置更新缓存,并推断完整序列的长度。
  • start_positions (torch.LongTensor,形状为 (batch_size,)可选) — 用于计算 token 分类损失的标签跨度起点的标签位置(索引)。位置被限制在序列的长度 (sequence_length) 内。序列之外的位置不计入损失计算。
  • end_positions (torch.LongTensor,形状为 (batch_size,)可选) — 用于计算 token 分类损失的标签跨度终点的标签位置(索引)。位置被限制在序列的长度 (sequence_length) 内。序列之外的位置不计入损失计算。

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

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

NemotronForTokenClassification

class transformers.NemotronForTokenClassification

< >

( config )

参数

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

带有 token 分类头的 Nemotron 模型 Transformer(隐藏状态输出之上的线性层),例如用于命名实体识别 (NER) 任务。

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

此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参考 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,默认情况下将被忽略。

    索引可以使用 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(torch.FloatTensor) 元组,每个元组都有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量。 这也称为旧版缓存格式。

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

    如果使用 past_key_values,则用户可以选择仅输入最后的 input_ids(那些没有将其过去的键值状态提供给此模型的输入 ID),形状为 (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 层的 attentions 张量。 有关更多详细信息,请参见返回张量下的 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.TokenClassifierOutputtuple(torch.FloatTensor)

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

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

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

  • hidden_states (tuple(torch.FloatTensor), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的 tuple(如果模型具有 embedding 层,则为 embeddings 的输出 + 每层的输出一个)形状为 (batch_size, sequence_length, hidden_size)

    每个层输出以及可选的初始 embedding 输出处的模型的 hidden-states。

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

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

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

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

示例

>>> from transformers import AutoTokenizer, NemotronForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("nvidia/nemotron-3-8b-base-4k-hf")
>>> model = NemotronForTokenClassification.from_pretrained("nvidia/nemotron-3-8b-base-4k-hf")

>>> 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 上更新