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→
© . This site is unofficial and not affiliated with Hugging Face, Inc.