Transformers 文件
Llama4
並獲得增強的文件體驗
開始使用
Llama4
由 Meta 開發的 Llama 4 引入了新的自迴歸專家混合 (MoE) 架構。此代包含兩個模型
- 功能強大的 Llama 4 Maverick，擁有 17B 活躍引數（總計約 400B），包含 128 個專家。
- 高效的 Llama 4 Scout 也擁有 17B 活躍引數（總計約 109B），僅使用 16 個專家。
- 兩個模型都利用早期融合實現原生多模態，使其能夠處理文字和影像輸入。Maverick 和 Scout 都在多達 40 萬億個代幣的資料上進行訓練，這些資料涵蓋 200 種語言（併為包括阿拉伯語、西班牙語、德語和印地語在內的 12 種語言提供特定的微調支援）。
在部署方面，Llama 4 Scout 旨在實現可訪問性，透過即時 4 位或 8 位 int4 量化適應單個伺服器級 GPU，而 Maverick 則提供 BF16 和 FP8 格式。這些模型根據自定義的 Llama 4 社群許可協議釋出，可在模型儲存庫中找到。
您可以在 meta-llama 組織下找到所有原始 Llama 檢查點。
Llama 4 系列模型有兩種規格：109B 和 402B 引數。這兩種規格都非常大，無法在您普通的裝置上執行。請參閱以下一些示例，以減少模型的記憶體使用量。
為了更快、更穩定地下載，我們建議按以下方式安裝 hf_xet 依賴項：pip install transformers[hf_xet]
下面的示例演示瞭如何使用 管道 (Pipeline) 或 AutoModel 進行生成。我們還添加了一個示例，展示如何切換正確的屬性以實現超長上下文生成，因為某些 Llama 4 版本的上下文長度可達 1000 萬個 token。
from transformers import pipeline
import torch
model_id = "meta-llama/Llama-4-Scout-17B-16E-Instruct"
messages = [
{"role": "user", "content": "what is the recipe of mayonnaise?"},
]
pipe = pipeline(
"text-generation",
model=model_id,
device_map="auto",
torch_dtype=torch.bfloat16
)
output = pipe(messages, do_sample=False, max_new_tokens=200)
print(output[0]["generated_text"][-1]["content"])效率：如何充分利用 Llama 4
注意力機制
更新預設的注意力函式可以顯著提高計算效能和記憶體使用率。有關我們介面的深入解釋，請參閱注意力介面概述。
截至釋出時，Llama 4 模型支援以下注意力方法：eager、flex_attention、sdpa。我們建議使用 flex_attention 以獲得最佳結果。切換注意力機制在模型初始化步驟完成
設定彈性注意力可確保在模型可以處理的超長上下文下獲得最佳結果。
注意：以下示例同時使用 device_map="auto" 和彈性注意力。請使用 torchrun 以張量並行模式執行此示例。
我們將在未來努力實現無需張量並行即可與 device_map="auto" 和彈性注意力一起執行。
from transformers import Llama4ForConditionalGeneration
import torch
model = Llama4ForConditionalGeneration.from_pretrained(
model_id,
attn_implementation="flex_attention",
device_map="auto",
torch_dtype=torch.bfloat16,
)量化
量化透過以較低精度表示權重來減輕大型模型的記憶體負擔。有關可用量化後端，請參閱 量化 概述。釋出時，支援 FBGEMM 和 LLM-Compressor；釋出後的幾天內將支援更多量化方法。
請參閱以下使用這兩種方法的示例
以下是使用 FBGEMM 方法將 BF16 模型載入到 FP8 的示例
from transformers import AutoTokenizer, Llama4ForConditionalGeneration, FbgemmFp8Config
import torch
model_id = "meta-llama/Llama-4-Scout-17B-16E-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_id)
messages = [
{"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt", return_dict=True)
model = Llama4ForConditionalGeneration.from_pretrained(
model_id,
device_map="auto",
torch_dtype=torch.bfloat16,
quantization_config=FbgemmFp8Config()
)
outputs = model.generate(**inputs.to(model.device), max_new_tokens=100)
outputs = tokenizer.batch_decode(outputs[:, inputs["input_ids"].shape[-1]:])
print(outputs[0])解除安裝
啟用 CPU 解除安裝意味著如果可用的 GPU 記憶體不足以載入整個模型，模型的元件可能會被移動到 CPU 而不是 GPU。在推理時，不同的元件將從 GPU 動態載入/解除安裝。這確保了只要 CPU 記憶體充足，模型就可以在較小的機器上載入。但是，這也會增加通訊開銷，從而減慢推理速度。
要啟用 CPU 解除安裝，您只需在模型載入時將 device_map 設定為 auto 即可
from transformers import Llama4ForConditionalGeneration
import torch
model = Llama4ForConditionalGeneration.from_pretrained(
model_id,
device_map="auto",
torch_dtype=torch.bfloat16,
)Llama4Config
class transformers.Llama4Config
< 來源 >( vision_config = None text_config = None boi_token_index = 200080 eoi_token_index = 200081 image_token_index = 200092 tie_word_embeddings = False **kwargs )
引數
- vision_config (
Llama4VisionConfig, 可選) — Llama4 視覺配置。 - text_config (
Llama4TextConfig, 可選) — Llama4 文字配置。 - boi_token_index (
int, 可選, 預設為 200080) — 用於包裹影像提示的影像開始 token 索引。 - eoi_token_index (
int, 可選, 預設為 200081) — 用於包裹影像提示的影像結束 token 索引。 - image_token_index (
int, 可選, 預設為 200092) — 用於編碼影像提示的影像 token 索引。 - tie_word_embeddings (
bool, 可選, 預設為False) — 模型的輸入和輸出詞嵌入是否應該繫結。
這是一個配置類，用於儲存 Llama4Model 的配置。它用於根據指定的引數例項化 Llama4 模型，定義模型架構。使用預設值例項化配置將產生類似於 Llama4 109B 的配置。
例如 meta-llama/Llama-4-Scout-17B-16E
配置物件繼承自 PretrainedConfig，可用於控制模型輸出。有關更多資訊，請閱讀 PretrainedConfig 的文件。
>>> from transformers import Llama4Model, Llama4Config
>>> # Initializing a Llama4 7B style configuration
>>> configuration = Llama4Config()
>>> # Initializing a model from the Llama4 7B style configuration
>>> model = Llama4Model(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configLlama4TextConfig
class transformers.Llama4TextConfig
< 來源 >( vocab_size = 202048 hidden_size = 5120 intermediate_size = 8192 intermediate_size_mlp = 16384 num_hidden_layers = 48 num_attention_heads = 40 num_key_value_heads = 8 head_dim = 128 hidden_act = 'silu' max_position_embeddings = 131072 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 = 500000 attention_dropout = 0.0 num_experts_per_tok = 1 num_local_experts = 16 moe_layers = None interleave_moe_layer_step = 1 use_qk_norm = True output_router_logits = False router_aux_loss_coef = 0.001 router_jitter_noise = 0.0 rope_scaling = None no_rope_layers = None no_rope_layer_interval = 4 attention_chunk_size = 8192 layer_types = None attn_temperature_tuning = True floor_scale = 8192 attn_scale = 0.1 **kwargs )
引數
- vocab_size (
int, 可選, 預設為 202048) — Llama4 文字模型的詞彙表大小。定義了呼叫 Llama4TextModel 時傳入的inputs_ids可以表示的不同 token 的最大數量。 - hidden_size (
int, 可選, 預設為 5120) — 嵌入和隱藏狀態的維度。 - intermediate_size (
int, 可選, 預設為 8192) — Transformer 編碼器中“中間”（通常稱為前饋）層的維度。 - intermediate_size_mlp (
int, 可選, 預設為 16384) — 待辦 - num_hidden_layers (
int, 可選, 預設為 48) — Transformer 編碼器中隱藏層的數量。 - num_attention_heads (
int, 可選, 預設為 40) — Transformer 編碼器中每個注意力層頭的數量。 - num_key_value_heads (
int, 可選, 預設為 8) — 用於實現分組查詢注意力的鍵值頭數量。如果未指定，將預設為num_attention_heads。 - head_dim (
int, 可選, 預設為 128) — 待辦 - hidden_act (
str或Callable, 可選, 預設為"silu") — 編碼器和池化器中的非線性啟用函式（函式或字串）。 - max_position_embeddings (
int, 可選, 預設為 131072) — 此模型可能使用的最大序列長度。 - initializer_range (
float, 可選, 預設為 0.02) — 用於初始化所有權重矩陣的截斷正態初始化器的標準差。 - rms_norm_eps (
float, 可選, 預設為 1e-05) — rms 歸一化層使用的 epsilon。 - use_cache (
bool, 可選, 預設為True) — 模型是否應該返回最後一個鍵/值注意力。 - pad_token_id (
int, 可選, 預設為 128004) — 填充 token 的 id。 - bos_token_id (
int, 可選, 預設為 1) — 句子開始 token 的 id。 - eos_token_id (
int, 可選, 預設為 2) — 句子結束 token 的 id。 - tie_word_embeddings (
bool, 可選, 預設為False) — 是否繫結詞嵌入。 - rope_theta (
float, optional, defaults to500000.0) — RoPE 嵌入的基週期。 - attention_dropout (
int, optional, defaults to 0.0) — TODO - num_experts_per_tok (
int, optional, defaults to 1) — TODO - num_local_experts (
int, optional, defaults to 16) — TODO - moe_layers (
int, optional) — TODO - interleave_moe_layer_step (
int, optional, defaults to 1) — TODO - use_qk_norm (
int, optional, defaults toTrue) — TODO - output_router_logits (
int, optional, defaults toFalse) — TODO - router_aux_loss_coef (
int, optional, defaults to 0.001) — TODO - router_jitter_noise (
int, optional, defaults to 0.0) — TODO - rope_scaling (
Dict, optional) — 包含 RoPE 嵌入縮放配置的字典。注意：如果你應用了新的 RoPE 型別，並且期望模型在更長的max_position_embeddings上工作，我們建議你相應地更新此值。預期內容：rope_type(str)：要使用的 RoPE 子變體。可以是 [‘default’, ‘linear’, ‘dynamic’, ‘yarn’, ‘longrope’, ‘llama3’] 之一，其中 ‘default’ 是原始 RoPE 實現。factor(float, 可選)：除 ‘default’ 外所有 RoPE 型別均使用。應用於 RoPE 嵌入的縮放因子。在大多數縮放型別中，因子 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 高頻分量的縮放因子。 - no_rope_layers (
list[int], optional) — 列表長度至少應與模型中的層數相同。索引位置為1表示相應層將使用 RoPE，而0表示它是 NoPE 層。 - no_rope_layer_interval (
int, optional, defaults to 4) — 如果no_rope_layers為None，它將每隔no_rope_layer_interval層建立一個 NoPE 層。 - attention_chunk_size (
int, optional, defaults to 8192) — - layer_types (
list, optional) — 每層的注意力模式。 - attn_temperature_tuning (
bool, optional, defaults toTrue) — 是否根據序列長度動態調整每個查詢令牌的注意力溫度。建議用於長序列（例如，>32k 令牌）以保持穩定的輸出結果。 - floor_scale (
int, optional, defaults to 8192) — TODO - attn_scale (
int, optional, defaults to 0.1) — TODO
這是用於儲存 Llama4TextModel 配置的配置類。它用於根據指定引數例項化 Llama4 文字模型，定義模型架構。使用預設值例項化配置將產生與 Llama4 109B 類似的配置。
例如 meta-llama/Llama-4-Scout-17B-16E
配置物件繼承自 PretrainedConfig，可用於控制模型輸出。有關更多資訊，請閱讀 PretrainedConfig 的文件。
示例
Llama4VisionConfig
class transformers.Llama4VisionConfig
< source >( hidden_size: int = 768 hidden_act: str = 'gelu' num_hidden_layers: int = 34 num_attention_heads: int = 16 num_channels: int = 3 intermediate_size: int = 5632 vision_output_dim: int = 7680 image_size: int = 448 patch_size: int = 14 norm_eps: float = 1e-05 vision_feature_layer = -1 vision_feature_select_strategy = 'default' initializer_range: float = 0.02 pixel_shuffle_ratio = 0.5 projector_input_dim = 4096 projector_output_dim = 4096 multi_modal_projector_bias = False projector_dropout = 0.0 attention_dropout = 0.0 rope_theta = 10000 **kwargs )
引數
- hidden_size (
int, optional, defaults to 768) — 編碼器層和池化層的維度。 - hidden_act (
str或function, optional, defaults to"gelu") — 編碼器和池化器中的非線性啟用函式（函式或字串）。如果是字串，支援"gelu"、"relu"、"selu"和"gelu_new""quick_gelu"。 - num_hidden_layers (
int, optional, defaults to 34) — Transformer 編碼器中的隱藏層數量。 - num_attention_heads (
int, optional, defaults to 16) — Transformer 編碼器中每個注意力層的注意力頭數量。 - num_channels (
int, optional, defaults to 3) — 輸入影像中的通道數量。 - intermediate_size (
int, optional, defaults to 5632) — Transformer 編碼器中“中間”（通常稱為前饋）層的維度。 - vision_output_dim (
int, optional, defaults to 7680) — 視覺模型輸出的維度。包括帶中間層和全域性 Transformer 編碼器的 Transformer 編碼器的輸出。 - image_size (
int, optional, defaults to 448) — 每張影像塊的大小（解析度）。 - patch_size (
int, optional, defaults to 14) — 每個補丁的大小（解析度）。 - norm_eps (
float, optional, defaults to 1e-05) — 層歸一化層使用的 epsilon。 - vision_feature_layer (“, optional, defaults to -1) — TODO
- vision_feature_select_strategy (
int, optional, defaults to"default") — TODO - initializer_range (
float, optional, defaults to 0.02) — 用於初始化所有權重矩陣的 truncated_normal_initializer 的標準差。 - pixel_shuffle_ratio (
int, optional, defaults to 0.5) — TODO - projector_input_dim (
int, optional, defaults to 4096) — TODO - projector_output_dim (
int, optional, defaults to 4096) — TODO - multi_modal_projector_bias (
int, optional, defaults toFalse) — TODO - projector_dropout (
int, optional, defaults to 0.0) — TODO - attention_dropout (
int, optional, defaults to 0.0) — TODO - rope_theta (
int, optional, defaults to 10000) — TODO
這是用於儲存 Llama4VisionModel 配置的配置類。它用於根據指定引數例項化 Llama4 視覺模型，定義模型架構。使用預設值例項化配置將產生與 Llama4 109B 類似的配置。
例如 meta-llama/Llama-4-Scout-17B-16E
配置物件繼承自 PretrainedConfig，可用於控制模型輸出。有關更多資訊，請閱讀 PretrainedConfig 的文件。
Llama4Processor
class transformers.Llama4Processor
< source >( image_processor = None tokenizer = None patch_size: int = 14 pixel_shuffle_ratio: float = 0.5 fake_image_token = '<|image|>' image_token = '<|image|>' start_of_image_token = '<|image_start|>' end_of_image_token = '<|image_end|>' patch_token = '<|patch|>' tile_x_separator_token = '<|tile_x_separator|>' tile_y_separator_token = '<|tile_y_separator|>' chat_template = '{{- bos_token }}\n{%- if custom_tools is defined %}\n {%- set tools = custom_tools %}\n{%- endif %}\n{%- if not tools_in_user_message is defined %}\n {%- set tools_in_user_message = true %}\n{%- endif %}\n{%- if not date_string is defined %}\n {%- if strftime_now is defined %}\n {%- set date_string = strftime_now("%d %b %Y") %}\n {%- else %}\n {%- set date_string = "26 Jul 2024" %}\n {%- endif %}\n{%- endif %}\n{%- if not tools is defined %}\n {%- set tools = none %}\n{%- endif %}\n\n{#- This block extracts the system message, so we can slot it into the right place. #}\n{%- if messages[0][\'role\'] == \'system\' %} \n {%- if messages[0][\'content\'] is string %}\n {%- set system_message = messages[0][\'content\']|trim %}\n {%- else %}\n {#- FIXME: The processor requires an array, always. #}\n {%- set system_message = messages[0][\'content\'][0][\'text\']|trim %}\n {%- endif %}\n {%- set messages = messages[1:] %}\n {%- set user_supplied_system_message = true %}\n{%- else %}\n {%- set system_message = "" %}\n {%- set user_supplied_system_message = false %}\n{%- endif %}\n\n{#- System message if the user supplied one #}\n{%- if user_supplied_system_message %}\n {{- "<|header_start|>system<|header_end|>\n\n" }}\n {%- if tools is not none %}\n {{- "Environment: ipython\n" }}\n {%- endif %}\n {%- if tools is not none and not tools_in_user_message %}\n {{- "You have access to the following functions. To call a function, please respond with JSON for a function call." }}\n {{- \'Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.\' }}\n {{- "Do not use variables.\n\n" }}\n {%- for t in tools %}\n {{- t | tojson(indent=4) }}\n {{- "\n\n" }}\n {%- endfor %}\n {{- system_message }}\n {{- "<|eot|>" }}\n{%- endif %}\n\n{#- Custom tools are passed in a user message with some extra guidance #}\n{%- if tools_in_user_message and not tools is none %}\n {#- Extract the first user message so we can plug it in here #}\n {%- if messages | length != 0 %}\n {%- set first_user_message = messages[0][\'content\']|trim %}\n {%- set messages = messages[1:] %}\n {%- else %}\n {{- raise_exception("Cannot put tools in the first user message when there\'s no first user message!") }}\n{%- endif %}\n {{- \'<|header_start|>user<|header_end|>\n\n\' -}}\n {{- "Given the following functions, please respond with a JSON for a function call " }}\n {{- "with its proper arguments that best answers the given prompt.\n\n" }}\n {{- \'Respond in the format {"name": function name, "parameters": dictionary of argument name and its value}.\' }}\n {{- "Do not use variables.\n\n" }}\n {%- for t in tools %}\n {{- t | tojson(indent=4) }}\n {{- "\n\n" }}\n {%- endfor %}\n {{- first_user_message + "<|eot|>"}}\n{%- endif %}\n\n{%- for message in messages %}\n {%- if not (message.role == \'ipython\' or message.role == \'tool\' or \'tool_calls\' in message) %}\n {{- \'<|header_start|>\' + message[\'role\'] + \'<|header_end|>\n\n\' }}\n {%- if message[\'content\'] is string %}\n {{- message[\'content\'] }}\n {%- else %}\n {%- for content in message[\'content\'] %}\n {%- if content[\'type\'] == \'image\' %}\n {{- \'<|image|>\' }}\n {%- elif content[\'type\'] == \'text\' %}\n {{- content[\'text\'] }}\n {%- endif %}\n {%- endfor %}\n {%- endif %}\n {{- "<|eot|>" }}\n {%- elif \'tool_calls\' in message and message.tool_calls|length > 0 %}\n {{- \'<|header_start|>assistant<|header_end|>\n\n\' -}}\n {{- \'<|python_start|>\' }}\n {%- if message[\'content\'] is string %}\n {{- message[\'content\'] }}\n {%- else %}\n {%- for content in message[\'content\'] %}\n {%- if content[\'type\'] == \'image\' %}\n {{- \'<|image|>\' }}\n {%- elif content[\'type\'] == \'text\' %}\n {{- content[\'text\'] }}\n {%- endif %}\n {%- endfor %}\n {%- endif %}\n {{- \'<|python_end|>\' }}\n {%- for tool_call in message.tool_calls %}\n {{- \'{"name": "\' + tool_call.function.name + \'", \' }}\n {{- \'"parameters": \' }}\n {{- tool_call.function.arguments | tojson }}\n {{- "}" }}\n {%- endfor %}\n {{- "<|eot|>" }}\n {%- elif message.role == "tool" or message.role == "ipython" %}\n {{- "<|header_start|>ipython<|header_end|>\n\n" }}\n {%- if message.content is mapping or message.content is iterable %}\n {{- message.content | tojson }}\n {%- else %}\n {{- message.content }}\n {%- endif %}\n {{- "<|eot|>" }}\n {%- endif %}\n{%- endfor %}\n{%- if add_generation_prompt %}\n {{- \'<|header_start|>assistant<|header_end|>\n\n\' }}\n{%- endif %}\n' **kwargs )
引數
- image_processor (AutoImageProcessor, optional) — 影像處理器是必需輸入。
- tokenizer ([
PreTrainedTokenizer,PreTrainedTokenizerFast], optional) — 分詞器是必需輸入。 - patch_size (
int, optional, defaults to 28) — 用於分詞的影像補丁的大小。 - img_size (
int, optional, defaults to 364) — 要分詞的影像大小。這應與影像處理器指定的大小相對應。 - image_token (
str, optional, defaults to"<|image|>") — 用於在文字中表示影像的令牌。 - downsample_factor (
int, optional, defaults to 1) — 補丁大小的縮放因子。 - start_of_img_token (
str, optional, defaults to"<|START_OF_IMG|>") — 用於在文字中表示影像開始的令牌。 - end_of_img_token (
str, optional, defaults to"<|END_OF_IMG|>") — 用於在文字中表示影像結束的令牌。 - img_patch_token (
str, 可選, 預設為"<|IMG_PATCH|>") — 用於在文字中表示影像塊的標記。 - img_line_break_token (
str, 可選, 預設為"<|IMG_LINE_BREAK|>") — 用於在文字中表示換行符的標記。 - tile_token (
str, 可選, 預設為"TILE") — 用於在文字中表示影像塊的標記。 - tile_global_token (
str, 可選, 預設為"TILE_GLOBAL") — 用於在文字中表示封面影像的標記。 - chat_template (
str, 可選) — 一個 Jinja 模板，用於將聊天中的訊息列表轉換為可標記化的字串。
構造一個 Llama4 處理器，它封裝了一個 AutoImageProcessor 和 PretrainedTokenizerFast 分詞器，形成一個繼承影像處理器和分詞器功能的單一處理器。有關更多資訊，請參閱 __call__() 和 decode()。
此方法將其所有引數轉發給 PreTrainedTokenizerFast 的 batch_decode()。有關更多資訊，請參閱此方法的文件字串。
Llama4ImageProcessorFast
class transformers.Llama4ImageProcessorFast
< 源 >( **kwargs: typing_extensions.Unpack[transformers.models.llama4.image_processing_llama4_fast.Llama4ImageProcessorKwargs] )
構造一個快速 Llama4 影像處理器。
preprocess
< 源 >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] **kwargs: typing_extensions.Unpack[transformers.models.llama4.image_processing_llama4_fast.Llama4ImageProcessorKwargs] ) → <class 'transformers.image_processing_base.BatchFeature'>
引數
- images (
Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]) — 要預處理的影像。期望單個或批次影像，畫素值範圍為 0 到 255。如果傳入畫素值在 0 到 1 之間的影像，請設定do_rescale=False。 - do_resize (
bool, 可選) — 是否調整影像大小。 - size (
dict[str, int], 可選) — 描述模型的最大輸入尺寸。 - default_to_square (
bool, 可選) — 如果 size 是一個整數，是否預設將影像調整為正方形。 - resample (
Union[PILImageResampling, F.InterpolationMode, NoneType]) — 如果調整影像大小，要使用的重取樣過濾器。可以是列舉PILImageResampling之一。僅當do_resize設定為True時有效。 - do_center_crop (
bool, 可選) — 是否對影像進行中心裁剪。 - crop_size (
dict[str, int], 可選) — 應用center_crop後輸出影像的大小。 - do_rescale (
bool, 可選) — 是否重新縮放影像。 - rescale_factor (
Union[int, float, NoneType]) — 如果do_rescale設定為True，則影像的重新縮放因子。 - do_normalize (
bool, 可選) — 是否對影像進行標準化。 - image_mean (
Union[float, list[float], NoneType]) — 用於標準化的影像均值。僅當do_normalize設定為True時有效。 - image_std (
Union[float, list[float], NoneType]) — 用於標準化的影像標準差。僅當do_normalize設定為True時有效。 - do_convert_rgb (
bool, 可選) — 是否將影像轉換為 RGB。 - return_tensors (
Union[str, ~utils.generic.TensorType, NoneType]) — 如果設定為 `pt`，則返回堆疊張量，否則返回張量列表。 - data_format (
~image_utils.ChannelDimension, 可選) — 僅支援ChannelDimension.FIRST。為相容慢速處理器而新增。 - input_data_format (
Union[str, ~image_utils.ChannelDimension, NoneType]) — 輸入影像的通道維度格式。如果未設定，則從輸入影像推斷通道維度格式。可以是以下之一："channels_first"或ChannelDimension.FIRST：影像為 (num_channels, height, width) 格式。"channels_last"或ChannelDimension.LAST：影像為 (height, width, num_channels) 格式。"none"或ChannelDimension.NONE：影像為 (height, width) 格式。
- device (
torch.device, 可選) — 處理影像的裝置。如果未設定，則從輸入影像推斷裝置。 - disable_grouping (
bool, 可選) — 是否停用按大小對影像進行分組以單獨處理而不是批次處理。如果為 None，則如果影像在 CPU 上，則設定為 True，否則設定為 False。此選擇基於經驗觀察，詳情見此：https://github.com/huggingface/transformers/pull/38157 - max_patches (
int, 可選, 預設為 16) — 從影像中提取的最大塊數。可以透過preprocess方法中的max_patches引數覆蓋。 - resize_to_max_canvas (
bool, 可選, 預設為 False) — 是否將影像調整為最大畫布大小。如果為 True，則選擇允許最大無失真調整大小的畫布。如果為 False，則儘可能少地降取樣，包括完全不調整大小，但除非影像小於補丁大小，否則永不升取樣。
返回
<class 'transformers.image_processing_base.BatchFeature'>
- data (
dict) — 由 call 方法返回的列表/陣列/張量字典（“pixel_values”等）。 - tensor_type (
Union[None, str, TensorType], 可選) — 您可以在此處提供一個`tensor_type`，以便在初始化時將整數列表轉換為PyTorch/TensorFlow/Numpy張量。
rescale_and_normalize
< 源 >( images: torch.Tensor do_rescale: bool rescale_factor: float do_normalize: bool image_mean: typing.Union[float, list[float]] image_std: typing.Union[float, list[float]] )
重新縮放和標準化影像。覆蓋以在 torch.bfloat16 中重新縮放和標準化影像，如原始實現中所示
Llama4ForConditionalGeneration
forward
< 源 >( input_ids: LongTensor = None pixel_values: FloatTensor = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[list[torch.FloatTensor]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None vision_feature_layer: typing.Union[int, list[int], NoneType] = None vision_feature_select_strategy: typing.Optional[str] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None logits_to_keep: typing.Union[int, torch.Tensor] = 0 image_sizes: Tensor = None **kwargs: typing_extensions.Unpack[transformers.models.llama4.modeling_llama4.KwargsForCausalLM] ) → transformers.models.llama4.modeling_llama4.Llama4CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
引數
- input_ids (
torch.LongTensor形狀為(batch_size, sequence_length)) — 詞彙表中輸入序列標記的索引。填充預設將被忽略。索引可以使用 AutoTokenizer 獲取。有關詳細資訊，請參閱 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- pixel_values (
torch.FloatTensor形狀為(batch_size, num_channels, image_size, image_size)) — 對應於輸入影像的張量。畫素值可以使用{image_processor_class}獲取。有關詳細資訊，請參閱{image_processor_class}.__call__（{processor_class}使用{image_processor_class}處理影像）。 - 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 (
list[torch.FloatTensor], 可選) — 預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於加速順序解碼。這通常包括模型在解碼上一階段返回的past_key_values，當use_cache=True或config.use_cache=True時。允許兩種格式：
- Cache 例項，請參閱我們的 kv cache 指南；
config.n_layers長度的tuple(torch.FloatTensor)元組，每個元組包含 2 個形狀為(batch_size, num_heads, sequence_length, embed_size_per_head)的張量）。這也被稱為傳統快取格式。
模型將輸出與作為輸入提供的快取格式相同的快取格式。如果沒有傳入
past_key_values，將返回傳統快取格式。如果使用
past_key_values，使用者可以選擇僅輸入形狀為(batch_size, 1)的最後input_ids（那些沒有將其過去鍵值狀態提供給此模型的輸入 ID），而不是所有形狀為(batch_size, sequence_length)的input_ids。 - inputs_embeds (
torch.FloatTensor形狀為(batch_size, sequence_length, hidden_size), 可選) — 或者，您可以選擇直接傳入嵌入表示，而不是傳入input_ids。如果您希望對input_ids索引如何轉換為關聯向量擁有比模型內部嵌入查詢矩陣更多的控制權，這將很有用。 - vision_feature_layer (
Union[int, list[int], NoneType]) — 選擇視覺特徵的層索引。如果提供多個索引，則相應索引的視覺特徵將連線起來形成視覺特徵。 - vision_feature_select_strategy (
str, 可選) — 用於從視覺骨幹網選擇視覺特徵的特徵選擇策略。可以是"default"或"full"之一。 - 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。 - return_dict (
bool, optional) — 是否返回一個 ModelOutput 而不是一個普通的元組。 - 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，並且只計算該標記的 logits 可以節省記憶體，這對於長序列或大詞彙量來說非常重要。如果是torch.Tensor，則必須是 1D，對應於在序列長度維度中要保留的索引。這在使用打包張量格式時很有用（批次和序列長度的單維度）。 - image_sizes (
torch.Tensor，形狀為(batch_size, 2)) — 批次中影像的大小，每個影像為 (高度, 寬度)。
返回
transformers.models.llama4.modeling_llama4.Llama4CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
一個 transformers.models.llama4.modeling_llama4.Llama4CausalLMOutputWithPast 或一個 torch.FloatTensor 的元組（如果傳入 return_dict=False 或 config.return_dict=False 時），包含根據配置（Llama4Config）和輸入的不同元素。
-
loss (
torch.FloatTensor形狀為(1,)，可選，當提供labels時返回) — 語言建模損失（用於下一個 token 預測）。 -
logits (形狀為
(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor) — 語言建模頭部的預測分數（SoftMax 之前的每個詞彙標記的分數）。 -
past_key_values (
tuple(tuple(torch.FloatTensor)), 可選, 當傳入use_cache=True或config.use_cache=True時返回) — 長度為config.n_layers的tuple(torch.FloatTensor)元組，每個元組包含形狀為(batch_size, num_heads, sequence_length, embed_size_per_head)的兩個張量)包含預計算的隱藏狀態（自注意力塊中的鍵和值），可用於（參見
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
-
image_hidden_states (
torch.FloatTensor, 可選) — 形狀為 `(batch_size, num_images, sequence_length, hidden_size)` 的 `torch.FloatTensor`。由視覺編碼器生成並投影最後一個隱藏狀態後的模型影像隱藏狀態。
Llama4ForConditionalGeneration 的 forward 方法，重寫了 __call__ 特殊方法。
儘管前向傳播的配方需要在該函式中定義，但之後應該呼叫 Module 例項而不是此函式，因為前者負責執行預處理和後處理步驟，而後者會默默地忽略它們。
示例
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, LlavaForConditionalGeneration
>>> model = LlavaForConditionalGeneration.from_pretrained("llava-hf/llava-1.5-7b-hf")
>>> processor = AutoProcessor.from_pretrained("llava-hf/llava-1.5-7b-hf")
>>> prompt = "USER: <image>\nWhat's the content of the image? ASSISTANT:"
>>> url = "https://www.ilankelman.org/stopsigns/australia.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = processor(images=image, text=prompt, return_tensors="pt")
>>> # Generate
>>> generate_ids = model.generate(**inputs, max_new_tokens=15)
>>> processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"USER: \nWhat's the content of the image? ASSISTANT: The image features a busy city street with a stop sign prominently displayed"get_image_features
< source >( pixel_values: FloatTensor vision_feature_layer: typing.Union[int, list[int]] vision_feature_select_strategy: str **kwargs ) → image_features (torch.Tensor)
引數
- pixel_values (
torch.FloatTensor]，形狀為(batch_size, channels, height, width)) — 對應於輸入影像的張量。 - vision_feature_layer (
Union[int, list[int]]) — 用於選擇視覺特徵的層索引。如果提供了多個索引，則相應索引的視覺特徵將被連線以形成視覺特徵。 - vision_feature_select_strategy (
str) — 用於從視覺骨幹網路中選擇視覺特徵的特徵選擇策略。可以是"default"或"full"之一。
返回
image_features (torch.Tensor)
形狀為 (num_images, image_length, embed_dim) 的影像特徵張量。
從視覺塔獲取影像最後隱藏狀態並應用所有投影。
- forward
Llama4ForCausalLM
forward
< source >( input_ids: LongTensor = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Union[transformers.cache_utils.Cache, list[torch.FloatTensor], NoneType] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None logits_to_keep: typing.Union[int, torch.Tensor] = 0 **kwargs: typing_extensions.Unpack[transformers.models.llama4.modeling_llama4.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 (
Union[~cache_utils.Cache, list[torch.FloatTensor], NoneType]) — 預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於加速順序解碼。這通常包括模型在解碼上一階段返回的past_key_values，當use_cache=True或config.use_cache=True時。允許兩種格式：
- 一個 Cache 例項，請參閱我們的 kv 快取指南；
- 長度為
config.n_layers的tuple(torch.FloatTensor)元組，每個元組包含形狀為(batch_size, num_heads, sequence_length, embed_size_per_head)的 2 個張量）。這也稱為舊版快取格式。
模型將輸出與作為輸入提供的快取格式相同的快取格式。如果未傳遞
past_key_values，將返回舊版快取格式。如果使用
past_key_values，使用者可以選擇只輸入形狀為(batch_size, 1)的最後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。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。 - 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，並且只計算該標記的 logits 可以節省記憶體，這對於長序列或大詞彙量來說非常重要。如果是torch.Tensor，則必須是 1D，對應於在序列長度維度中要保留的索引。這在使用打包張量格式時很有用（批次和序列長度的單維度）。
返回
transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.CausalLMOutputWithPast 或一個 torch.FloatTensor 的元組（如果傳入 return_dict=False 或 config.return_dict=False 時），包含根據配置（Llama4Config）和輸入的不同元素。
-
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
Llama4ForCausalLM 的 forward 方法，重寫了 __call__ 特殊方法。
儘管前向傳播的配方需要在該函式中定義，但之後應該呼叫 Module 例項而不是此函式，因為前者負責執行預處理和後處理步驟，而後者會默默地忽略它們。
示例
>>> from transformers import AutoTokenizer, Llama4ForCausalLM
>>> model = Llama4ForCausalLM.from_pretrained("meta-llama4/Llama4-2-7b-hf")
>>> tokenizer = AutoTokenizer.from_pretrained("meta-llama4/Llama4-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."- forward
Llama4TextModel
class transformers.Llama4TextModel
< source >( config: Llama4TextConfig )
引數
- config (Llama4TextConfig) — 包含模型所有引數的模型配置類。使用配置檔案初始化並不會載入與模型相關的權重，只加載配置。請檢視 from_pretrained() 方法載入模型權重。
Llama4 文字模型，輸出原始隱藏狀態，不帶任何特定頭部。
此模型繼承自 PreTrainedModel。請查閱父類文件，瞭解庫為其所有模型實現的通用方法（例如下載或儲存、調整輸入嵌入大小、修剪頭部等）。
該模型也是 PyTorch torch.nn.Module 子類。將其作為常規 PyTorch 模組使用，並參考 PyTorch 文件中與通用使用和行為相關的所有事項。
forward
< source >( input_ids: 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 return_dict: 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)的 2 個張量）。這也稱為舊版快取格式。
模型將輸出與作為輸入提供的快取格式相同的快取格式。如果未傳遞
past_key_values，將返回舊版快取格式。如果使用
past_key_values，使用者可以選擇只輸入形狀為(batch_size, 1)的最後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。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。 - 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 時），包含根據配置（Llama4Config）和輸入的不同元素。
-
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
Llama4TextModel 的 forward 方法，重寫了 __call__ 特殊方法。
儘管前向傳播的配方需要在該函式中定義，但之後應該呼叫 Module 例項而不是此函式，因為前者負責執行預處理和後處理步驟，而後者會默默地忽略它們。
- forward
Llama4ForCausalLM
forward
< source >( input_ids: LongTensor = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Union[transformers.cache_utils.Cache, list[torch.FloatTensor], NoneType] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None cache_position: typing.Optional[torch.LongTensor] = None logits_to_keep: typing.Union[int, torch.Tensor] = 0 **kwargs: typing_extensions.Unpack[transformers.models.llama4.modeling_llama4.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 (
Union[~cache_utils.Cache, list[torch.FloatTensor], NoneType]) — 預先計算的隱藏狀態（自注意力塊和交叉注意力塊中的鍵和值），可用於加速順序解碼。這通常包括模型在解碼上一階段返回的past_key_values，當use_cache=True或config.use_cache=True時。允許兩種格式：
- 一個 Cache 例項，請參閱我們的 kv 快取指南；
- 長度為
config.n_layers的tuple(torch.FloatTensor)元組，每個元組包含形狀為(batch_size, num_heads, sequence_length, embed_size_per_head)的 2 個張量）。這也稱為舊版快取格式。
模型將輸出與作為輸入提供的快取格式相同的快取格式。如果未傳遞
past_key_values，將返回舊版快取格式。如果使用
past_key_values，使用者可以選擇只輸入形狀為(batch_size, 1)的最後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。 - return_dict (
bool, 可選) — 是否返回一個 ModelOutput 而不是一個普通的元組。 - 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，並且只計算該標記的 logits 可以節省記憶體，這對於長序列或大詞彙量來說非常重要。如果是torch.Tensor，則必須是 1D，對應於在序列長度維度中要保留的索引。這在使用打包張量格式時很有用（批次和序列長度的單維度）。
返回
transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
一個 transformers.modeling_outputs.CausalLMOutputWithPast 或一個 torch.FloatTensor 的元組（如果傳入 return_dict=False 或 config.return_dict=False 時），包含根據配置（Llama4Config）和輸入的不同元素。
-
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 後的注意力權重，用於計算自注意力頭中的加權平均值。
Llama4ForCausalLM 的 forward 方法，重寫了 __call__ 特殊方法。
儘管前向傳播的配方需要在該函式中定義，但之後應該呼叫 Module 例項而不是此函式，因為前者負責執行預處理和後處理步驟，而後者會默默地忽略它們。
示例
>>> from transformers import AutoTokenizer, Llama4ForCausalLM
>>> model = Llama4ForCausalLM.from_pretrained("meta-llama4/Llama4-2-7b-hf")
>>> tokenizer = AutoTokenizer.from_pretrained("meta-llama4/Llama4-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."- forward
Llama4VisionModel
forward
< source >( pixel_values: Tensor attention_mask: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None )
示例
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, MllamaVisionModel
>>> checkpoint = "meta-llama/Llama-3.2-11B-Vision"
>>> model = MllamaVisionModel.from_pretrained(checkpoint)
>>> processor = AutoProcessor.from_pretrained(checkpoint)
>>> url = "https://www.ilankelman.org/stopsigns/australia.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = processor(images=image, return_tensors="pt")
>>> output = model(**inputs)
>>> print(output.last_hidden_state.shape)
torch.Size([1, 1, 4, 1025, 7680])此函式用於獲取第一個嵌入層以啟用輸入上的梯度。
- forward