Transformers 文件
Llama
並獲得增強的文件體驗
開始使用
Llama
Llama 是一個擁有 70 億到 650 億引數的大型語言模型家族。這些模型專注於高效推理（這對服務語言模型至關重要），透過用更多的資料 tokens 訓練較小的模型，而不是用較少的資料 tokens 訓練較大的模型。Llama 模型基於 GPT 架構，但它使用預歸一化來提高訓練穩定性，用 SwiGLU 替換 ReLU 以提高效能，並用旋轉位置嵌入（RoPE）替換絕對位置嵌入以更好地處理更長的序列長度。
您可以在 Huggy Llama 組織下找到所有原始的 Llama 模型權重。
點選右側邊欄中的 Llama 模型，檢視更多如何將 Llama 應用於不同語言任務的示例。
下面的示例演示瞭如何使用 Pipeline 或 AutoModel，以及從命令列生成文字。
import torch
from transformers import pipeline
pipeline = pipeline(
task="text-generation",
model="huggyllama/llama-7b",
torch_dtype=torch.float16,
device=0
)
pipeline("Plants create energy through a process known as")量化透過以較低精度表示權重來減少大型模型的記憶體負擔。有關更多可用量化後端，請參閱量化概述。
以下示例使用torchao僅將權重量化為int4。
# pip install torchao
import torch
from transformers import TorchAoConfig, AutoModelForCausalLM, AutoTokenizer
quantization_config = TorchAoConfig("int4_weight_only", group_size=128)
model = AutoModelForCausalLM.from_pretrained(
"huggyllama/llama-30b",
torch_dtype=torch.bfloat16,
device_map="auto",
quantization_config=quantization_config
)
tokenizer = AutoTokenizer.from_pretrained("huggyllama/llama-30b")
input_ids = tokenizer("Plants create energy through a process known as", return_tensors="pt").to("cuda")
output = model.generate(**input_ids, cache_implementation="static")
print(tokenizer.decode(output[0], skip_special_tokens=True))使用 AttentionMaskVisualizer 來更好地理解模型可以和不可以關注哪些 tokens。
from transformers.utils.attention_visualizer import AttentionMaskVisualizer
visualizer = AttentionMaskVisualizer("huggyllama/llama-7b")
visualizer("Plants create energy through a process known as")
注意事項
- tokenizer 是一個基於 SentencePiece 的位元組對編碼模型。在解碼期間，如果第一個 token 是單詞的開頭（例如，“Banana”），tokenizer 不會在字串前新增字首空格。
LlamaConfig
class transformers.LlamaConfig
< 原始碼 >( vocab_size = 32000 hidden_size = 4096 intermediate_size = 11008 num_hidden_layers = 32 num_attention_heads = 32 num_key_value_heads = None hidden_act = 'silu' max_position_embeddings = 2048 initializer_range = 0.02 rms_norm_eps = 1e-06 use_cache = True pad_token_id = None bos_token_id = 1 eos_token_id = 2 pretraining_tp = 1 tie_word_embeddings = False rope_theta = 10000.0 rope_scaling = None attention_bias = False attention_dropout = 0.0 mlp_bias = False head_dim = None **kwargs )
引數
- vocab_size (
int, 可選, 預設為 32000) — LLaMA 模型的詞彙表大小。定義了在呼叫 LlamaModel 時傳遞的inputs_ids可以表示的不同 token 的數量。 - hidden_size (
int, 可選, 預設為 4096) — 隱藏表示的維度。 - intermediate_size (
int, 可選, 預設為 11008) — MLP 表示的維度。 - num_hidden_layers (
int, 可選, 預設為 32) — Transformer 解碼器中的隱藏層數量。 - num_attention_heads (
int, 可選, 預設為 32) — Transformer 解碼器中每個注意力層的注意力頭數量。 - num_key_value_heads (
int, 可選) — 這是用於實現分組查詢注意力（Grouped Query Attention）的鍵值頭（key_value heads）的數量。如果 `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) — 該模型可能使用的最大序列長度。Llama 1 支援最多 2048 個 token，Llama 2 最多 4096，CodeLlama 最多 16384。 - initializer_range (
float, 可選, 預設為 0.02) — 用於初始化所有權重矩陣的截斷正態分佈初始化器的標準差。 - rms_norm_eps (
float, 可選, 預設為 1e-06) — rms 歸一化層使用的 epsilon 值。 - use_cache (
bool, 可選, 預設為True) — 模型是否應返回最後一個鍵/值注意力（並非所有模型都使用）。僅當 `config.is_decoder=True` 時相關。 - pad_token_id (
int, 可選) — 填充 token 的 ID。 - bos_token_id (
int, 可選, 預設為 1) — 序列開始 token 的 ID。 - eos_token_id (
int, 可選, 預設為 2) — 序列結束 token 的 ID。 - pretraining_tp (
int, 可選, 預設為 1) — 實驗性功能。預訓練期間使用的張量並行等級。請參閱此文件以瞭解更多資訊。這個值對於確保預訓練結果的精確復現是必需的。請參閱此問題。 - 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’, ‘llama3’] 之一，其中 ‘default’ 是原始的 RoPE 實現。factor(float, 可選)：除 ‘default’ 外的所有 rope 型別都使用此引數。應用於 RoPE 嵌入的縮放因子。在大多數縮放型別中，factor為 x 將使模型能夠處理長度為 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 高頻分量的縮放因子。 - attention_bias (
bool, 可選, 預設為False) — 在自注意力機制中，是否在查詢、鍵、值和輸出投影層中使用偏置。 - attention_dropout (
float, 可選, 預設為 0.0) — 注意力機率的 dropout 比率。 - mlp_bias (
bool, 可選, 預設為False) — 是否在 MLP 層的 up_proj、down_proj 和 gate_proj 層中使用偏置。 - head_dim (
int, 可選) — 注意力頭的維度。如果為 None，則預設為 hidden_size // num_attention_heads
這是用於儲存 LlamaModel 配置的配置類。它用於根據指定的引數例項化一個 LLaMA 模型，定義模型架構。使用預設值例項化配置將產生與 LLaMA-7B 類似的配置，例如 meta-llama/Llama-2-7b-hf
配置物件繼承自 PretrainedConfig，可用於控制模型輸出。更多資訊請閱讀 PretrainedConfig 的文件。
>>> from transformers import LlamaModel, LlamaConfig
>>> # Initializing a LLaMA llama-7b style configuration
>>> configuration = LlamaConfig()
>>> # Initializing a model from the llama-7b style configuration
>>> model = LlamaModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configLlamaTokenizer
class transformers.LlamaTokenizer
< 來源 >( vocab_file unk_token = '<unk>' bos_token = '<s>' eos_token = '</s>' pad_token = None sp_model_kwargs: typing.Optional[dict[str, typing.Any]] = None add_bos_token = True add_eos_token = False clean_up_tokenization_spaces = False use_default_system_prompt = False spaces_between_special_tokens = False legacy = None add_prefix_space = True **kwargs )
引數
- vocab_file (
str) — 詞彙表文件的路徑。 - unk_token (
str或tokenizers.AddedToken, 可選, 預設為"<unk>") — 未知詞元。不在詞彙表中的詞元無法轉換為 ID，將被設定為此詞元。 - bos_token (
str或tokenizers.AddedToken, 可選, 預設為"<s>") — 序列開始詞元，在預訓練期間使用。可用作序列分類器詞元。 - eos_token (
str或tokenizers.AddedToken, 可選, 預設為"</s>") — 序列結束詞元。 - pad_token (
str或tokenizers.AddedToken, 可選) — 用於將詞元陣列填充至相同大小以進行批處理的特殊詞元。之後將被注意力機制或損失計算忽略。 - sp_model_kwargs (
dict[str, Any],Optional, 可選) — 將傳遞給SentencePieceProcessor.__init__()方法。SentencePiece 的 Python 包裝器 可用於設定以下內容等：-
enable_sampling: 啟用子詞正則化。 -
nbest_size: unigram 的取樣引數。對於 BPE-Dropout 無效。nbest_size = {0,1}: 不執行取樣。nbest_size > 1: 從 nbest_size 個結果中取樣。nbest_size < 0: 假設 nbest_size 是無限的，並使用前向過濾和後向取樣演算法從所有假設（格）中取樣。
-
alpha: unigram 取樣的平滑引數，以及 BPE-dropout 的合併操作的 dropout 機率。
-
- add_bos_token (
bool, 可選, 預設為True) — 是否在序列開始處新增bos_token。 - add_eos_token (
bool, 可選, 預設為False) — 是否在序列末尾新增eos_token。 - clean_up_tokenization_spaces (
bool, 可選, 預設為False) — 解碼後是否清理空格，清理操作包括移除可能存在的額外空格等偽影。 - use_default_system_prompt (
bool, 可選, 預設為False) — 是否使用 Llama 的預設系統提示。 - spaces_between_special_tokens (
bool, 可選, 預設為False) — 是否在特殊詞元之間新增空格。 - legacy (
bool, 可選) — 是否使用分詞器的 `legacy` 行為。Legacy 指的是在合併 #24622 和 #25224 之前的行為，這些合併包含了正確處理特殊詞元后出現的詞元的修復。請確保同時將 `from_slow` 設定為 `True`。一個簡單的例子：legacy=True:
構建一個 Llama 分詞器。基於位元組級的位元組對編碼（Byte-Pair-Encoding）。由於原始模型中沒有填充詞元，因此預設的填充詞元未設定。
get_special_tokens_mask
< 來源 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None already_has_special_tokens: bool = False ) → list[int]
從沒有新增特殊標記的標記列表中檢索序列ID。此方法在使用分詞器prepare_for_model方法新增特殊標記時呼叫。
create_token_type_ids_from_sequences
< 來源 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
根據傳入的兩個序列建立掩碼，用於序列對分類任務。一個 ALBERT
如果 token_ids_1 為 None，則此方法僅返回掩碼的第一部分（0s）。
0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence | second sequence |如果 token_ids_1 為 None，則只返回掩碼的第一部分（0s）。
save_vocabulary
< 來源 >( save_directory filename_prefix: typing.Optional[str] = None ) → Tuple(str)
將詞彙表和特殊標記檔案儲存到目錄。
LlamaTokenizerFast
class transformers.LlamaTokenizerFast
< 來源 >( vocab_file = None tokenizer_file = None clean_up_tokenization_spaces = False unk_token = '<unk>' bos_token = '<s>' eos_token = '</s>' add_bos_token = True add_eos_token = False use_default_system_prompt = False legacy = None add_prefix_space = None **kwargs )
引數
- vocab_file (
str, 可選) — SentencePiece 檔案（通常副檔名為 .model），包含例項化分詞器所需的詞彙表。 - tokenizer_file (
str, 可選) — tokenizers 檔案（通常副檔名為 .json），包含載入分詞器所需的所有內容。 - clean_up_tokenization_spaces (
bool, 可選, 預設為False) — 解碼後是否清理空格，清理操作包括移除可能存在的額外空格等偽影。 - unk_token (
str或tokenizers.AddedToken, 可選, 預設為"<unk>") — 未知詞元。不在詞彙表中的詞元無法轉換為 ID，將被設定為此詞元。 - bos_token (
str或tokenizers.AddedToken, 可選, 預設為"<s>") — 序列開始詞元，在預訓練期間使用。可用作序列分類器詞元。 - eos_token (
str或tokenizers.AddedToken, 可選, 預設為"</s>") — 序列結束詞元。 - add_bos_token (
bool, 可選, 預設為True) — 是否在序列開始處新增bos_token。 - add_eos_token (
bool, 可選, 預設為False) — 是否在序列末尾新增eos_token。 - use_default_system_prompt (
bool, 可選, 預設為False) — 是否使用 Llama 的預設系統提示 - legacy (
bool, 可選) — 是否使用分詞器的 `legacy` 行為。Legacy 指的是在合併 #24622 和 #25224 之前的行為，這些合併包含了正確處理特殊詞元后出現的詞元的修復。請確保同時將 `from_slow` 設定為 `True`。一個簡單的例子：legacy=True:
構建 Llama 分詞器。基於位元組級位元組對編碼。
這主要使用 ByteFallback 且不進行規範化。
>>> from transformers import LlamaTokenizerFast
>>> tokenizer = LlamaTokenizerFast.from_pretrained("hf-internal-testing/llama-tokenizer")
>>> tokenizer.encode("Hello this is a test")
[1, 15043, 445, 338, 263, 1243]如果你想更改 `bos_token` 或 `eos_token`，請確保在初始化模型時指定它們，或呼叫 `tokenizer.update_post_processor()` 以確保後處理正確完成（否則編碼序列的第一個詞元和最後一個詞元的值將不正確）。更多詳情，請檢視 [後處理器] (https://huggingface.co/docs/tokenizers/api/post-processors) 文件。
此分詞器繼承自 PreTrainedTokenizerFast，其中包含大部分主要方法。使用者應參考此超類以獲取有關這些方法的更多資訊。
get_special_tokens_mask
< 來源 >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None already_has_special_tokens: bool = False ) → 一個範圍在 [0, 1] 內的整數列表
從未新增特殊令牌的令牌列表中檢索序列 ID。使用分詞器 prepare_for_model 或 encode_plus 方法新增特殊令牌時會呼叫此方法。
create_token_type_ids_from_sequences
< source >( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]
建立與傳入序列對應的標記型別 ID。什麼是標記型別 ID？
如果模型有特殊的構建方式，應在子類中重寫此方法。
使用當前的 bos_token 和 eos_token 更新底層後處理器。
LlamaModel
class transformers.LlamaModel
< source >( config: LlamaConfig )
引數
- config (LlamaConfig) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請查閱 from_pretrained() 方法來載入模型權重。
原始的 Llama 模型，輸出原始的隱藏狀態，頂部沒有任何特定的頭。
該模型繼承自 PreTrainedModel。請查閱超類的文件，瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入的大小、修剪頭部等）。
該模型也是一個 PyTorch torch.nn.Module 的子類。可以像使用常規 PyTorch 模組一樣使用它，並參考 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 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 (
~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`，使用者可以選擇只輸入形狀為 `(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索引轉換為關聯向量，這將非常有用。 - 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` 時），包含各種元素，具體取決於配置 (LlamaConfig) 和輸入。
-
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
LlamaModel 的 forward 方法會覆蓋 `__call__` 特殊方法。
雖然前向傳播的配方需要在此函式內定義，但之後應呼叫 `Module` 例項而不是此函式，因為前者會處理預處理和後處理步驟，而後者會靜默忽略它們。
LlamaForCausalLM
class transformers.LlamaForCausalLM
< source >( config )
引數
- config (LlamaForCausalLM) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請查閱 from_pretrained() 方法來載入模型權重。
用於因果語言建模的 Llama 模型。
該模型繼承自 PreTrainedModel。請查閱超類的文件，瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入的大小、修剪頭部等）。
該模型也是一個 PyTorch torch.nn.Module 的子類。可以像使用常規 PyTorch 模組一樣使用它，並參考 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 cache_position: typing.Optional[torch.LongTensor] = None logits_to_keep: typing.Union[int, torch.Tensor] = 0 **kwargs: typing_extensions.Unpack[transformers.models.llama.modeling_llama.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)` 元組，每個元組包含兩個形狀為 `(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, 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`，則必須是一維的，對應於要在序列長度維度中保留的索引。這在使用打包張量格式（批處理和序列長度的單個維度）時非常有用。
返回
transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.CausalLMOutputWithPast 或一個 `torch.FloatTensor` 的元組（如果傳遞了 `return_dict=False` 或當 `config.return_dict=False` 時），包含各種元素，具體取決於配置 (LlamaConfig) 和輸入。
-
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
LlamaForCausalLM 的 forward 方法會覆蓋 `__call__` 特殊方法。
雖然前向傳播的配方需要在此函式內定義，但之後應呼叫 `Module` 例項而不是此函式，因為前者會處理預處理和後處理步驟，而後者會靜默忽略它們。
示例
>>> from transformers import AutoTokenizer, LlamaForCausalLM
>>> model = LlamaForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")
>>> tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-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."LlamaForSequenceClassification
class transformers.LlamaForSequenceClassification
< source >( config )
引數
- config (LlamaForSequenceClassification) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請查閱 from_pretrained() 方法來載入模型權重。
在 LLaMa 模型 Transformer 的頂部添加了一個序列分類頭（線性層）。
LlamaForSequenceClassification 使用最後一個標記來進行分類，就像其他因果模型（例如 GPT-2）一樣。
由於它對最後一個標記進行分類，因此需要知道最後一個標記的位置。如果配置中定義了 `pad_token_id`，它會在每行中找到最後一個非填充標記。如果沒有定義 `pad_token_id`，它會簡單地取批處理中每行的最後一個值。由於當傳遞 `inputs_embeds` 而不是 `input_ids` 時它無法猜測填充標記，因此它會做同樣的操作（取批處理中每行的最後一個值）。
該模型繼承自 PreTrainedModel。請查閱超類的文件，瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入的大小、修剪頭部等）。
該模型也是一個 PyTorch torch.nn.Module 的子類。可以像使用常規 PyTorch 模組一樣使用它，並參考 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.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, optional) — 預計算的隱藏狀態（自注意力和交叉注意力塊中的鍵和值），可用於加速序列解碼。這通常包含在解碼的前一階段，當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.SequenceClassifierOutputWithPast 或 tuple(torch.FloatTensor)
一個 `transformers.modeling_outputs.SequenceClassifierOutputWithPast` 或一個 `torch.FloatTensor` 元組（如果傳遞 `return_dict=False` 或 `config.return_dict=False`），根據配置 (LlamaConfig) 和輸入包含各種元素。
-
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
LlamaForSequenceClassification 的前向方法會覆蓋 `__call__` 特殊方法。
雖然前向傳播的配方需要在此函式內定義，但之後應呼叫 `Module` 例項而不是此函式，因為前者會處理預處理和後處理步驟，而後者會靜默忽略它們。
單標籤分類示例
>>> import torch
>>> from transformers import AutoTokenizer, LlamaForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")
>>> model = LlamaForSequenceClassification.from_pretrained("meta-llama/Llama-2-7b-hf")
>>> 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 = LlamaForSequenceClassification.from_pretrained("meta-llama/Llama-2-7b-hf", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...多標籤分類示例
>>> import torch
>>> from transformers import AutoTokenizer, LlamaForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")
>>> model = LlamaForSequenceClassification.from_pretrained("meta-llama/Llama-2-7b-hf", 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 = LlamaForSequenceClassification.from_pretrained(
... "meta-llama/Llama-2-7b-hf", 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).lossLlamaForQuestionAnswering
class transformers.LlamaForQuestionAnswering
< 原始碼 >( config )
引數
- config (LlamaForQuestionAnswering) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型關聯的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
Llama 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()。
- 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, 可選) — 預計算的隱藏狀態（自注意力和交叉注意力塊中的鍵和值），可用於加速序列解碼。這通常包含在解碼的前一階段，當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`），根據配置 (LlamaConfig) 和輸入包含各種元素。
-
loss (
torch.FloatTensorof shape(1,), 可選, 當提供labels時返回) — 總範圍提取損失是起始位置和結束位置的交叉熵之和。 -
start_logits (
torch.FloatTensorof shape(batch_size, sequence_length)) — 範圍起始分數（SoftMax 之前）。 -
end_logits (
torch.FloatTensorof 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 後的注意力權重，用於計算自注意力頭中的加權平均值。
LlamaForQuestionAnswering 的前向方法會覆蓋 `__call__` 特殊方法。
雖然前向傳播的配方需要在此函式內定義，但之後應呼叫 `Module` 例項而不是此函式，因為前者會處理預處理和後處理步驟，而後者會靜默忽略它們。
示例
>>> from transformers import AutoTokenizer, LlamaForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")
>>> model = LlamaForQuestionAnswering.from_pretrained("meta-llama/Llama-2-7b-hf")
>>> 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)
...LlamaForTokenClassification
class transformers.LlamaForTokenClassification
< 原始碼 >( config )
引數
- config (LlamaForTokenClassification) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型關聯的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
Llama 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()。
- 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, 可選) — 預計算的隱藏狀態（自注意力和交叉注意力塊中的鍵和值），可用於加速序列解碼。這通常包含在解碼的前一階段，當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`），根據配置 (LlamaConfig) 和輸入包含各種元素。
-
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
LlamaForTokenClassification 的前向方法會覆蓋 `__call__` 特殊方法。
雖然前向傳播的配方需要在此函式內定義，但之後應呼叫 `Module` 例項而不是此函式，因為前者會處理預處理和後處理步驟，而後者會靜默忽略它們。
示例
>>> from transformers import AutoTokenizer, LlamaForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")
>>> model = LlamaForTokenClassification.from_pretrained("meta-llama/Llama-2-7b-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]]
>>> predicted_tokens_classes
...
>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...FlaxLlamaModel
class transformers.FlaxLlamaModel
< 原始碼 >( config: LlamaConfig input_shape: tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
引數
- config (LlamaConfig) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型關聯的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
- dtype (
jax.numpy.dtype，可選，預設為jax.numpy.float32) — 計算的資料型別。可以是 `jax.numpy.float32`、`jax.numpy.float16` 或 `jax.numpy.bfloat16` 之一。這可用於在 GPU 或 TPU 上啟用混合精度訓練或半精度推理。如果指定，所有計算都將使用給定的 `dtype` 執行。
請注意，這僅指定計算的 dtype，不影響模型引數的 dtype。
基礎的 Llama 模型 Transformer，輸出原始的隱藏狀態，頂部沒有任何特定的頭。
該模型繼承自 FlaxPreTrainedModel。請檢視超類文件以瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入的大小、修剪頭等）。
該模型也是 Flax Linen flax.nn.Module 的子類。可以像常規 Flax Module 一樣使用它，並參考 Flax 文件瞭解所有與一般用法和行為相關的事項。
最後，此模型支援固有的 JAX 功能，例如
__call__
< 原始碼 >( input_ids attention_mask = None position_ids = None params: typing.Optional[dict] = None past_key_values: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
numpy.ndarray，形狀為 `(batch_size, input_ids_length)`) — 詞彙表中輸入序列標記的索引。如果提供填充，預設情況下將被忽略。可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
numpy.ndarray，形狀為 `(batch_size, sequence_length)`，可選) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值在 `[0, 1]` 中選擇：- 1 表示標記未被遮蔽，
- 0 表示標記被遮蔽。
可以使用 AutoTokenizer 獲取索引。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
如果使用 `past_key_values`，則可以選擇只輸入最後一個 `decoder_input_ids`（參見 `past_key_values`）。
如果你想更改填充行為，應閱讀 `modeling_opt._prepare_decoder_attention_mask` 並根據需要進行修改。有關預設策略的更多資訊，請參閱論文中的圖 1。
- 1 表示頭未被遮蔽，
- 0 表示頭被遮蔽。
- position_ids (
numpy.ndarray，形狀為 `(batch_size, input_ids_length)`，可選) — 每個輸入序列標記在位置嵌入中的位置索引。在 `[0, config.n_positions - 1]` 範圍內選擇。 - past_key_values (
dict[str, np.ndarray]，可選，由 `init_cache` 或在傳遞先前的 `past_key_values` 時返回) — 預計算的隱藏狀態（注意力塊中的鍵和值）字典，可用於快速自迴歸解碼。預計算的鍵和值隱藏狀態的形狀為 [batch_size, max_length]。 - output_attentions (
bool，可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的 `attentions`。 - output_hidden_states (
bool，可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的 `hidden_states`。 - return_dict (
bool，可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。
返回
transformers.modeling_flax_outputs.FlaxBaseModelOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_flax_outputs.FlaxBaseModelOutput 或一個 `torch.FloatTensor` 元組（如果傳遞 `return_dict=False` 或 `config.return_dict=False`），根據配置 (LlamaConfig) 和輸入包含各種元素。
-
last_hidden_state (形狀為
(batch_size, sequence_length, hidden_size)的jnp.ndarray) — 模型最後一層輸出的隱藏狀態序列。 -
hidden_states (
tuple(jnp.ndarray)，可選，當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — `jnp.ndarray` 元組（一個用於嵌入層的輸出，一個用於每層的輸出），形狀為 `(batch_size, sequence_length, hidden_size)`。模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
-
attentions (
tuple(jnp.ndarray)，可選，當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — `jnp.ndarray` 元組（每層一個），形狀為 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
`FlaxLlamaPreTrainedModel` 的前向方法會覆蓋 `__call__` 特殊方法。
雖然前向傳播的配方需要在此函式內定義，但之後應呼叫 `Module` 例項而不是此函式，因為前者會處理預處理和後處理步驟，而後者會靜默忽略它們。
此示例使用一個隨機模型，因為真實的模型都非常大。要獲得正確的結果，應使用 openlm-research/open_llama_3b_v2 而不是 afmck/testing-llama-tiny。如果在載入該檢查點時遇到記憶體不足的問題，可以嘗試在 `from_pretrained` 呼叫中新增 `device_map="auto"`。
示例
>>> from transformers import AutoTokenizer, FlaxLlamaModel
>>> tokenizer = AutoTokenizer.from_pretrained("afmck/testing-llama-tiny")
>>> model = FlaxLlamaModel.from_pretrained("afmck/testing-llama-tiny")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="jax")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_stateFlaxLlamaForCausalLM
class transformers.FlaxLlamaForCausalLM
< 原始碼 >( config: LlamaConfig input_shape: tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )
引數
- config (LlamaConfig) — 包含模型所有引數的模型配置類。使用配置檔案進行初始化不會載入與模型相關的權重，只會載入配置。請檢視 from_pretrained() 方法來載入模型權重。
- dtype (
jax.numpy.dtype, 可選, 預設為jax.numpy.float32) — 計算的資料型別。可以是jax.numpy.float32、jax.numpy.float16或jax.numpy.bfloat16之一。這可用於在 GPU 或 TPU 上啟用混合精度訓練或半精度推理。如果指定，所有計算都將使用給定的
dtype執行。請注意，這僅指定計算的 dtype，不影響模型引數的 dtype。
Llama Transformer 模型，頂部帶有一個語言建模頭（線性層）。
該模型繼承自 FlaxPreTrainedModel。請檢視超類文件以瞭解庫為所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入的大小、修剪頭等）。
該模型也是 Flax Linen flax.nn.Module 的子類。可以像常規 Flax Module 一樣使用它，並參考 Flax 文件瞭解所有與一般用法和行為相關的事項。
最後，此模型支援固有的 JAX 功能，例如
__call__
< 原始碼 >( input_ids attention_mask = None position_ids = None params: typing.Optional[dict] = None past_key_values: typing.Optional[dict] = None dropout_rng: <function PRNGKey at 0x7effc7ad3a30> = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或 tuple(torch.FloatTensor)
引數
- input_ids (
numpy.ndarray，形狀為(batch_size, input_ids_length)) — 詞彙表中輸入序列標記的索引。如果提供填充，預設將被忽略。索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
numpy.ndarray，形狀為(batch_size, sequence_length), 可選) — 用於避免對填充標記索引執行注意力的掩碼。掩碼值在[0, 1]中選擇：- 1 表示標記未被掩碼，
- 0 表示標記被掩碼。
索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
如果使用
past_key_values，則可以選擇只輸入最後的decoder_input_ids（參見past_key_values）。如果您想更改填充行為，應閱讀
modeling_opt._prepare_decoder_attention_mask並根據需要進行修改。有關預設策略的更多資訊，請參閱論文中的圖 1。- 1 表示頭未被掩碼，
- 0 表示頭被掩碼。
- position_ids (
numpy.ndarray，形狀為(batch_size, input_ids_length), 可選) — 每個輸入序列標記在位置嵌入中的位置索引。在[0, config.n_positions - 1]範圍內選擇。 - past_key_values (
dict[str, np.ndarray], 可選，由init_cache返回或在傳遞先前的past_key_values時返回) — 預計算的隱藏狀態（注意力塊中的鍵和值）字典，可用於快速自迴歸解碼。預計算的鍵和值隱藏狀態的形狀為 [batch_size, max_length]。 - output_attentions (
bool, 可選) — 是否返回所有注意力層的注意力張量。有關更多詳細資訊，請參閱返回張量下的attentions。 - output_hidden_states (
bool, 可選) — 是否返回所有層的隱藏狀態。有關更多詳細資訊，請參閱返回張量下的hidden_states。 - return_dict (
bool, 可選) — 是否返回 ModelOutput 而不是普通元組。
返回
transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或 tuple(torch.FloatTensor)
一個 transformers.modeling_flax_outputs.FlaxMaskedLMOutput 或一個 torch.FloatTensor 的元組（如果傳遞了 return_dict=False 或當 config.return_dict=False 時），根據配置（LlamaConfig）和輸入，包含各種元素。
-
logits (形狀為
(batch_size, sequence_length, config.vocab_size)的jnp.ndarray) — 語言建模頭的預測分數（SoftMax 之前每個詞彙 token 的分數）。 -
hidden_states (
tuple(jnp.ndarray)，可選，當傳遞 `output_hidden_states=True` 或 `config.output_hidden_states=True` 時返回) — `jnp.ndarray` 元組（一個用於嵌入層的輸出，一個用於每層的輸出），形狀為 `(batch_size, sequence_length, hidden_size)`。模型在每個層輸出的隱藏狀態加上初始嵌入輸出。
-
attentions (
tuple(jnp.ndarray)，可選，當傳遞 `output_attentions=True` 或 `config.output_attentions=True` 時返回) — `jnp.ndarray` 元組（每層一個），形狀為 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 後的注意力權重，用於計算自注意力頭中的加權平均值。
`FlaxLlamaPreTrainedModel` 的前向方法會覆蓋 `__call__` 特殊方法。
雖然前向傳播的配方需要在此函式內定義，但之後應呼叫 `Module` 例項而不是此函式，因為前者會處理預處理和後處理步驟，而後者會靜默忽略它們。
此示例使用一個隨機模型，因為真實的模型都非常大。要獲得正確的結果，應使用 openlm-research/open_llama_3b_v2 而不是 afmck/testing-llama-tiny。如果在載入該檢查點時遇到記憶體不足的問題，可以嘗試在 `from_pretrained` 呼叫中新增 `device_map="auto"`。
示例
>>> from transformers import AutoTokenizer, FlaxLlamaForCausalLM
>>> tokenizer = AutoTokenizer.from_pretrained("afmck/testing-llama-tiny")
>>> model = FlaxLlamaForCausalLM.from_pretrained("afmck/testing-llama-tiny")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="np")
>>> outputs = model(**inputs)
>>> # retrieve logts for next token
>>> next_token_logits = outputs.logits[:, -1]