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