Hugging Face 的 LOGO

Transformers 文档

DiffLlama

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

DiffLlama

PyTorch FlashAttention SDPA

概述

DiffLlama 模型由 Kazuma Matsumoto 等人在 Differential Transformer 一文中提出。该模型结合了 Llama 模型和 Differential Transformer 的注意力机制。

论文摘要如下：

Transformer 倾向于将注意力过度分配给不相关的上下文。在这项工作中，我们引入了 Diff Transformer，它放大了对相关上下文的注意力，同时消除了噪声。具体来说，差分注意力机制计算注意力分数作为两个独立 softmax 注意力图之间的差值。减法操作消除了噪声，促进了稀疏注意力模式的出现。语言建模的实验结果表明，在扩大模型尺寸和训练词元（token）的各种设置中，Diff Transformer 的性能优于 Transformer。更有趣的是，它在实际应用中具有显著优势，例如长上下文建模、关键信息检索、幻觉缓解、上下文学习以及减少激活异常值。通过减少对不相关上下文的干扰，Diff Transformer 可以缓解问答和文本摘要中的幻觉。对于上下文学习，Diff Transformer 不仅提高了准确性，而且对顺序排列的鲁棒性更强，这被认为是一个长期存在的鲁棒性问题。这些结果将 Diff Transformer 定位为一个高效且有前景的架构，以推动大型语言模型的发展。

使用技巧

该模型的超参数与 Llama 模型相同。

DiffLlamaConfig

class transformers.DiffLlamaConfig

< >

( vocab_size = 32000 hidden_size = 2048 intermediate_size = 8192 num_hidden_layers = 16 num_attention_heads = 32 num_key_value_heads = None hidden_act = 'silu' max_position_embeddings = 2048 initializer_range = 0.02 rms_norm_eps = 1e-05 use_cache = True pad_token_id = None bos_token_id = 1 eos_token_id = 2 tie_word_embeddings = False rope_theta = 10000.0 rope_scaling = None attention_bias = False attention_dropout = 0.0 lambda_std_dev = 0.1 head_dim = None **kwargs )

参数

  • vocab_size (int，可选，默认为 32000) — DiffLlama 模型的词汇表大小。定义了在调用 DiffLlamaModel 时传递的 `inputs_ids` 可以表示的不同词元（token）的数量。
  • hidden_size (int，可选，默认为 2048) — 隐藏表示的维度。
  • intermediate_size (int，可选，默认为 8192) — MLP 表示的维度。
  • num_hidden_layers (int，可选，默认为 16) — Transformer 解码器中的隐藏层数。
  • num_attention_heads (int，可选，默认为 32) — Transformer 解码器中每个注意力层的注意力头数。
  • num_key_value_heads (int，可选) — 用于实现分组查询注意力（Grouped Query Attention）的键值头数量。如果 `num_key_value_heads=num_attention_heads`，模型将使用多头注意力（MHA）；如果 `num_key_value_heads=1`，模型将使用多查询注意力（MQA）；否则使用 GQA。将多头检查点转换为 GQA 检查点时，每个组的键和值头应通过对该组内所有原始头进行均值池化来构建。更多详情请参阅 这篇论文。如果未指定，将默认为 `num_attention_heads`。
  • hidden_act (str 或 function，可选，默认为 `"silu"`) — 解码器中的非线性激活函数（函数或字符串）。
  • max_position_embeddings (int，可选，默认为 2048) — 该模型可能使用的最大序列长度。
  • initializer_range (float，可选，默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
  • rms_norm_eps (float，可选，默认为 1e-05) — rms 归一化层使用的 epsilon 值。
  • use_cache (bool，可选，默认为 `True`) — 模型是否应返回最后一个键/值注意力（并非所有模型都使用）。仅当 `config.is_decoder=True` 时相关。
  • pad_token_id (int，可选) — 填充词元 ID。
  • bos_token_id (int，可选，默认为 1) — 序列开始词元 ID。
  • eos_token_id (int，可选，默认为 2) — 序列结束词元 ID。
  • tie_word_embeddings (bool，可选，默认为 `False`) — 是否绑定词嵌入权重。
  • rope_theta (float，可选，默认为 10000.0) — RoPE 嵌入的基础周期。
  • rope_scaling (Dict，可选) — 包含 RoPE 嵌入缩放配置的字典。注意：如果应用新的 RoPE 类型并期望模型在更长的 `max_position_embeddings` 上工作，我们建议您相应地更新此值。预期内容：`rope_type` (str)：要使用的 RoPE 的子变体。可以是 ['default', 'linear', 'dynamic', 'yarn', 'longrope', 'diffllama3'] 之一，其中 'default' 是原始的 RoPE 实现。`factor` (float，可选)：除 'default' 外的所有 RoPE 类型都使用。应用于 RoPE 嵌入的缩放因子。在大多数缩放类型中，`factor` 为 x 将使模型能够处理长度为 x * 原始最大预训练长度的序列。`original_max_position_embeddings` (int，可选)：与 'dynamic'、'longrope' 和 'diffllama3' 一起使用。预训练期间使用的原始最大位置嵌入。`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，可选)：仅与 'diffllama3' 一起使用。应用于 RoPE 低频分量的缩放因子。`high_freq_factor` (float，可选)：仅与 'diffllama3' 一起使用。应用于 RoPE 高频分量的缩放因子。
  • attention_bias (bool, 可选, 默认为 False) — 是否在自注意力机制的 query、key、value 和 output 投影层中使用偏置。
  • attention_dropout (float, 可选, 默认为 0.0) — 注意力概率的 dropout 比率。
  • lambda_std_dev (float, 可选, 默认为 0.1) — 用于初始化注意力层中参数 lambda 的标准差。
  • head_dim (int, 可选) — 注意力头的维度。如果为 None，则默认为 hidden_size // num_heads。

这是一个配置类，用于存储 DiffLlamaModel 的配置。它用于根据指定的参数实例化一个 DiffLlama 模型，定义模型架构。使用默认值实例化一个配置将产生与 kajuma/DiffLlama-0.3B-handcut 相似的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PretrainedConfig 的文档。

>>> from transformers import DiffLlamaModel, DiffLlamaConfig

>>> # Initializing a DiffLlama diffllama-7b style configuration
>>> configuration = DiffLlamaConfig()

>>> # Initializing a model from the diffllama-7b style configuration
>>> model = DiffLlamaModel(configuration)

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

DiffLlamaModel

class transformers.DiffLlamaModel

< >

( config: DiffLlamaConfig )

参数

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

基础的 Diffllama 模型，输出原始的隐藏状态，顶部没有任何特定的预测头。

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

该模型也是 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[transformers.cache_utils.Cache] = 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()。

    什么是输入 ID？

  • 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] 中选择。

    什么是位置 ID？

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

    允许两种格式：

    • 一个 Cache 实例，请参阅我们的 kv 缓存指南；
    • 长度为 `config.n_layers` 的 `tuple(torch.FloatTensor)` 元组，每个元组有两个形状为 `(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`。
  • 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` 时），根据配置（DiffLlamaConfig）和输入包含各种元素。

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

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

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

DiffLlamaForCausalLM

class transformers.DiffLlamaForCausalLM

< >

( config )

参数

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

用于因果语言建模的 Diffllama 模型。

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

该模型也是 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[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.diffllama.modeling_diffllama.KwargsForCausalLM] ) → transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor，形状为 (batch_size, sequence_length), 可选) — 词汇表中输入序列词元的索引。默认情况下将忽略填充。

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

    什么是输入 ID？

  • 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] 中选择。

    什么是位置 ID？

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

    允许两种格式：

    • 一个 Cache 实例，请参阅我们的 kv 缓存指南；
    • 长度为 `config.n_layers` 的 `tuple(torch.FloatTensor)` 元组，每个元组有两个形状为 `(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` 索引转换为关联向量，这将非常有用。
  • 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` 时），根据配置（DiffLlamaConfig）和输入包含各种元素。

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

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

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

示例

>>> from transformers import AutoTokenizer, DiffLlamaForCausalLM

>>> model = DiffLlamaForCausalLM.from_pretrained("google/diffllama-7b")
>>> tokenizer = AutoTokenizer.from_pretrained("google/diffllama-7b")

>>> prompt = "What is your favorite condiment?"
>>> 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]
"What is your favorite condiment?"

DiffLlamaForSequenceClassification

class transformers.DiffLlamaForSequenceClassification

< >

( config )

参数

带序列分类头（线性层）的 DiffLlama 模型 Transformer。

DiffLlamaForSequenceClassification 使用最后一个词元进行分类，与其他因果模型（如 GPT-2）一样。

因为它对最后一个词元进行分类，所以需要知道最后一个词元的位置。如果在配置中定义了 `pad_token_id`，它会找到每行中不是填充词元的最后一个词元。如果没有定义 `pad_token_id`，它会简单地取批次中每行的最后一个值。由于当传递 `inputs_embeds` 而不是 `input_ids` 时，它无法猜测填充词元，所以它会做同样的操作（取批次中每行的最后一个值）。

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

该模型也是 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[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()。

    什么是输入 ID？

  • 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] 中选择。

    什么是位置 ID？

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

    允许两种格式：

    • 一个 Cache 实例，请参阅我们的 kv 缓存指南；
    • 长度为 `config.n_layers` 的 `tuple(torch.FloatTensor)` 元组，每个元组有两个形状为 `(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` 索引转换为关联向量，这将非常有用。
  • 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），包含根据配置（DiffLlamaConfig）和输入的不同元素。

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

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

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

单标签分类示例

>>> import torch
>>> from transformers import AutoTokenizer, DiffLlamaForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("kajuma/DiffLlama-0.3B-handcut")
>>> model = DiffLlamaForSequenceClassification.from_pretrained("kajuma/DiffLlama-0.3B-handcut")

>>> 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 = DiffLlamaForSequenceClassification.from_pretrained("kajuma/DiffLlama-0.3B-handcut", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...

多标签分类示例

>>> import torch
>>> from transformers import AutoTokenizer, DiffLlamaForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("kajuma/DiffLlama-0.3B-handcut")
>>> model = DiffLlamaForSequenceClassification.from_pretrained("kajuma/DiffLlama-0.3B-handcut", 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 = DiffLlamaForSequenceClassification.from_pretrained(
...     "kajuma/DiffLlama-0.3B-handcut", 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

DiffLlamaForQuestionAnswering

class transformers.DiffLlamaForQuestionAnswering

< >

( config )

参数

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

在 Diffllama Transformer 顶部添加一个跨度分类头，用于像 SQuAD 这样的抽取式问答任务（在隐藏状态输出之上添加一个线性层，以计算 span start logits 和 span end logits）。

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

该模型也是 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[transformers.cache_utils.Cache] = 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 **kwargs ) → transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor，形状为 (batch_size, sequence_length), 可选) — 词汇表中输入序列标记的索引。默认情况下，填充将被忽略。

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

    什么是输入 ID？

  • 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] 范围内选择。

    什么是位置 ID？

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

    允许两种格式：

    • 一个 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（那些没有为其提供过去键值状态的 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 索引转换为关联向量，这会很有用。
  • start_positions (torch.LongTensor，形状为 (batch_size,), 可选) — 标记跨度开始位置（索引）的标签，用于计算标记分类损失。位置被限制在序列长度（sequence_length）内。序列之外的位置在计算损失时不被考虑。
  • end_positions (torch.LongTensor，形状为 (batch_size,), 可选) — 标记跨度结束位置（索引）的标签，用于计算标记分类损失。位置被限制在序列长度（sequence_length）内。序列之外的位置在计算损失时不被考虑。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。更多详细信息，请参阅返回张量下的 attentions。
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。更多详细信息，请参阅返回张量下的 hidden_states。

返回

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

一个 transformers.modeling_outputs.QuestionAnsweringModelOutput 或一个 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False），包含根据配置（DiffLlamaConfig）和输入的不同元素。

  • loss (torch.FloatTensor of shape (1,), 可选, 当提供 labels 时返回) — 总范围提取损失是起始位置和结束位置的交叉熵之和。

  • start_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 范围起始分数（SoftMax 之前）。

  • end_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 范围结束分数（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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例

>>> from transformers import AutoTokenizer, DiffLlamaForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("kajuma/DiffLlama-0.3B-handcut")
>>> model = DiffLlamaForQuestionAnswering.from_pretrained("kajuma/DiffLlama-0.3B-handcut")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...

>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...

DiffLlamaForTokenClassification

class transformers.DiffLlamaForTokenClassification

< >

( config )

参数

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

带有词元分类头的 Diffllama Transformer（在隐藏状态输出之上添加一个线性层），例如用于命名实体识别（NER）任务。

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

该模型也是 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[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), 可选) — 词汇表中输入序列标记的索引。默认情况下，填充将被忽略。

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

    什么是输入 ID？

  • 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] 范围内选择。

    什么是位置 ID？

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

    允许两种格式：

    • 一个 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（那些没有为其提供过去键值状态的 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 索引转换为关联向量，这会很有用。
  • 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），包含根据配置（DiffLlamaConfig）和输入的不同元素。

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

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

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

示例

>>> from transformers import AutoTokenizer, DiffLlamaForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("kajuma/DiffLlama-0.3B-handcut")
>>> model = DiffLlamaForTokenClassification.from_pretrained("kajuma/DiffLlama-0.3B-handcut")

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

←DialoGPT DistilBERT→