Transformers 文档
Mllama
并获得增强的文档体验
开始使用
Mllama
概述
多模态大型语言模型 (LLM) 的 Llama 3.2-Vision 集合是一系列预训练和指令微调的图像推理生成模型，尺寸为 11B 和 90B（文本 + 图像输入 / 文本输出）。Llama 3.2-Vision 指令微调模型针对视觉识别、图像推理、图像描述和回答关于图像的常见问题进行了优化。
模型架构： Llama 3.2-Vision 构建于仅文本的 Llama 3.1 模型之上，后者是一个使用优化的 Transformer 架构的自回归语言模型。微调版本使用监督微调 (SFT) 和人类反馈强化学习 (RLHF) 来与人类对有用性和安全性的偏好保持一致。为了支持图像识别任务，Llama 3.2-Vision 模型使用单独训练的视觉适配器，该适配器与预训练的 Llama 3.1 语言模型集成。该适配器由一系列交叉注意力层组成，这些层将图像编码器表示馈送到核心 LLM 中。
使用技巧
- 对于图像+文本和仅文本输入，请使用
MllamaForConditionalGeneration。 - 对于仅文本输入，请使用
MllamaForCausalLM进行生成，以避免加载视觉塔。 - 每个样本可以包含多个图像，并且样本之间的图像数量可能有所不同。处理器会将输入填充到跨样本的最大图像数量以及每个图像内的最大图块数量。
- 传递给处理器的文本应包含
"<|image|>"标记，图像应插入在这些标记的位置。 - 处理器有自己的
apply_chat_template方法，用于将聊天消息转换为文本，然后可以将文本作为文本传递给处理器。如果您使用的是transformers>=4.49.0，您还可以从apply_chat_template获取向量化输出。有关如何使用它的更多详细信息，请参阅下面的使用示例。
Mllama 有一个额外的标记用作文本中图像位置的占位符。这意味着输入 ID 和输入嵌入层将有一个额外的标记。但是由于输入和输出嵌入的权重未绑定，因此如果您想计算图像标记的损失或应用某些 logit 处理器，lm_head 层将少一个标记并且会失败。如果您正在训练，请确保在 labels 中屏蔽掉特殊的 "<|image|>" 标记，因为模型不应在预测它们时进行训练。
否则，如果您在生成时看到 CUDA 端索引错误，请使用以下代码扩展 lm_head 多一个标记。
old_embeddings = model.get_output_embeddings()
num_tokens = model.vocab_size + 1
resized_embeddings = model._get_resized_lm_head(old_embeddings, new_num_tokens=num_tokens, mean_resizing=True)
resized_embeddings.requires_grad_(old_embeddings.weight.requires_grad)
model.set_output_embeddings(resized_embeddings)使用示例
指令模型
import torch
from transformers import MllamaForConditionalGeneration, AutoProcessor
model_id = "meta-llama/Llama-3.2-11B-Vision-Instruct"
model = MllamaForConditionalGeneration.from_pretrained(model_id, device_map="auto", torch_dtype=torch.bfloat16)
processor = AutoProcessor.from_pretrained(model_id)
messages = [
[
{
"role": "user",
"content": [
{"type": "image", "url": "https://llava-vl.github.io/static/images/view.jpg"},
{"type": "text", "text": "What does the image show?"}
]
}
],
]
inputs = processor.apply_chat_template(messages, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt").to(model.device)
output = model.generate(**inputs, max_new_tokens=25)
print(processor.decode(output[0]))基础模型
import requests
import torch
from PIL import Image
from transformers import MllamaForConditionalGeneration, AutoProcessor
model_id = "meta-llama/Llama-3.2-11B-Vision"
model = MllamaForConditionalGeneration.from_pretrained(model_id, device_map="auto", torch_dtype=torch.bfloat16)
processor = AutoProcessor.from_pretrained(model_id)
prompt = "<|image|>If I had to write a haiku for this one"
url = "https://llava-vl.github.io/static/images/view.jpg"
raw_image = Image.open(requests.get(url, stream=True).raw)
inputs = processor(text=prompt, images=raw_image, return_tensors="pt").to(model.device)
output = model.generate(**inputs, do_sample=False, max_new_tokens=25)
print(processor.decode(output[0], skip_special_tokens=True))MllamaConfig
class transformers.MllamaConfig
< source >( vision_config = None text_config = None image_token_index = 128256 **kwargs )
这是用于存储 MllamaForConditionalGeneration 配置的配置类。它用于根据指定的参数实例化 Mllama 模型，定义模型架构。使用默认值实例化配置将产生与 Mllama-9B 类似的配置。
例如：meta-llama/Llama-3.2-11B-Vision
配置对象继承自 PretrainedConfig，可用于控制模型输出。有关更多信息，请阅读 PretrainedConfig 的文档。
示例
>>> from transformers import MllamaForConditionalGeneration, MllamaConfig, MllamaVisionConfig, MllamaTextConfig
>>> # Initializing a CLIP-vision config
>>> vision_config = MllamaVisionConfig()
>>> # Initializing a Llama config
>>> text_config = MllamaTextConfig()
>>> # Initializing a mllama-11b style configuration
>>> configuration = MllamaConfig(vision_config, text_config)
>>> # Initializing a model from the mllama-11b style configuration
>>> model = MllamaForConditionalGeneration(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configMllamaProcessor
class transformers.MllamaProcessor
< source >( image_processor tokenizer chat_template = None )
参数
- image_processor (MllamaImageProcessor) — 图像处理器是必需的输入。
- tokenizer ([
PreTrainedTokenizer,PreTrainedTokenizerFast]) — 分词器是必需的输入。 - chat_template (
str, 可选) — 一个 Jinja 模板，用于将聊天中的消息列表转换为可分词的字符串。
构建一个 Mllama 处理器，它将 MllamaImageProcessor 和 PretrainedTokenizerFast 封装到一个处理器中，该处理器同时继承了图像处理器和分词器的功能。 有关更多信息，请参阅 __call__() 和 decode()。 传递 kwargs 的首选方式是使用每个模态的字典，请参阅下面的用法示例。
from transformers import MllamaProcessor
from PIL import Image
processor = MllamaProcessor.from_pretrained("meta-llama/Llama-3.2-11B-Vision")
processor(
images=your_pil_image,
text=["<|image|>If I had to write a haiku for this one"],
images_kwargs = {"size": {"height": 448, "width": 448}},
text_kwargs = {"padding": "right"},
common_kwargs = {"return_tensors": "pt"},
)此方法将其所有参数转发到 PreTrainedTokenizerFast 的 batch_decode()。 有关更多信息，请参阅此方法的文档字符串。
此方法将其所有参数转发到 PreTrainedTokenizerFast 的 decode()。 有关更多信息，请参阅此方法的文档字符串。
post_process_image_text_to_text
< source >( generated_outputs skip_special_tokens = True clean_up_tokenization_spaces = False **kwargs ) → List[str]
参数
- generated_outputs (
torch.Tensor或np.ndarray) — 模型generate函数的输出。 预期输出是形状为(batch_size, sequence_length)或(sequence_length,)的张量。 - skip_special_tokens (
bool, 可选, 默认为True) — 是否删除输出中的特殊 token。 传递给分词器的batch_decode方法的参数。 - Clean_up_tokenization_spaces (
bool, 可选, 默认为False) — 是否清理分词空格。 传递给分词器的batch_decode方法的参数。 - **kwargs — 要传递给分词器的
batch_decode method的其他参数。
返回
List[str]
解码后的文本。
后处理模型的输出以解码文本。
MllamaImageProcessor
class transformers.MllamaImageProcessor
< source >( do_convert_rgb: bool = True do_resize: bool = True size: typing.Optional[typing.Dict[str, int]] = None resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: float = 0.00392156862745098 do_normalize: bool = True image_mean: typing.Union[float, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = None do_pad: bool = True max_image_tiles: int = 4 **kwargs )
参数
- do_convert_rgb (
bool, 可选, 默认为True) — 是否将图像转换为 RGB 格式。 如果输入图像是其他格式（例如 RGBA），则此选项很有用。 仅当输入图像为 PIL 格式时才有效。 - do_resize (
bool, 可选, 默认为True) — 是否调整图像大小。 - size (
Dict[str, int], 可选, 默认为self.size) — 图像瓦片的大小。 应该是一个包含 ‘height’ 和 ‘width’ 键的字典，两者都具有整数值。 高度和宽度值应相等。 - resample (
int, 可选, 默认为Resampling.BILINEAR) — 如果调整图像大小，则使用的重采样过滤器。 可以是枚举PILImageResampling之一。 仅当do_resize设置为True时才有效。 - do_rescale (
bool, 可选, 默认为True) — 是否重新缩放图像。 - rescale_factor (
float, 可选, 默认为 0.0) — 如果do_rescale设置为True，则用于重新缩放图像的重新缩放因子。 - do_normalize (
bool, 可选, 默认为True) — 是否标准化图像。 - image_mean (
float或List[float], 可选, 默认为self.image_mean) — 用于标准化的图像均值。 仅当do_normalize设置为True时才有效。 - image_std (
float或List[float], 可选, 默认为self.image_std) — 用于标准化的图像标准差。 仅当do_normalize设置为True时才有效。 - do_pad (
bool, 可选, 默认为True) — 是否将图像填充到批次中最大的高度和宽度。 - max_image_tiles (
int, 可选, 默认为 4) — 将图像分割成的最大瓦片数。
构建 Mllama 图像处理器。
pad
< source >( image: ndarray size: typing.Dict[str, int] aspect_ratio: typing.Tuple[int, int] data_format: typing.Union[transformers.image_utils.ChannelDimension, str, NoneType] = None input_data_format: typing.Union[transformers.image_utils.ChannelDimension, str, NoneType] = None ) → np.ndarray
将图像填充到 size x aspect_ratio。例如，如果 size 是 {height: 224, width: 224}，宽高比是 (1, 2)，则图像将被填充到 224x448。
预处理
< 源代码 >( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] do_convert_rgb: typing.Optional[bool] = None do_resize: typing.Optional[bool] = None size: typing.Optional[typing.Dict[str, int]] = None resample: typing.Optional[PIL.Image.Resampling] = None do_rescale: typing.Optional[bool] = None rescale_factor: typing.Optional[float] = None do_normalize: typing.Optional[bool] = None image_mean: typing.Union[float, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = None do_pad: typing.Optional[bool] = None max_image_tiles: typing.Optional[int] = None input_data_format: typing.Union[transformers.image_utils.ChannelDimension, str, NoneType] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None ) → BatchFeature 具有以下结构
参数
- images (
ImageInput) — 要预处理的图像列表。 - do_convert_rgb (
bool, 可选, 默认为self.do_convert_rgb) — 是否将图像转换为 RGB。 - do_resize (
bool, 可选, 默认为self.do_resize) — 是否调整图像大小。 - size (
Dict[str, int], 可选, 默认为self.size) — 图像块的大小。应该是一个包含 ‘height’ 和 ‘width’ 键的字典，两者都为整数值。高度和宽度值应相等。 - resample (
int, 可选, 默认为self.resample) — 如果调整图像大小时使用的重采样滤波器。这可以是枚举PILImageResampling之一。仅当do_resize设置为True时才生效。 - do_rescale (
bool, 可选, 默认为self.do_rescale) — 是否重新缩放图像。 - rescale_factor (
float, 可选, 默认为self.rescale_factor) — 如果do_rescale设置为True，则用于重新缩放图像的缩放因子。 - do_normalize (
bool, 可选, 默认为self.do_normalize) — 是否标准化图像。 - image_mean (
float或List[float], 可选, 默认为self.image_mean) — 用于标准化的图像均值。仅当do_normalize设置为True时才生效。 - image_std (
float或List[float], 可选, 默认为self.image_std) — 用于标准化的图像标准差。仅当do_normalize设置为True时才生效。 - do_pad (
bool, 可选, 默认为self.do_pad) — 是否将图像填充到批次中最大的高度和宽度。 - max_image_tiles (
int, 可选, 默认为self.max_image_tiles) — 将图像分割成的最大图块数。 - input_data_format (
ChannelDimension或str, 可选) — 输入图像的通道维度格式。如果未设置，则通道维度格式会从输入图像中推断。可以是以下之一："channels_first"或ChannelDimension.FIRST: 图像格式为 (通道数, 高度, 宽度)。"channels_last"或ChannelDimension.LAST: 图像格式为 (高度, 宽度, 通道数)。"none"或ChannelDimension.NONE: 图像格式为 (高度, 宽度)。
- return_tensors (
str或TensorType, 可选) — 返回的张量类型。可以是以下之一：- 未设置：返回
np.ndarray列表。 TensorType.TENSORFLOW或'tf'：返回tf.Tensor类型的批次。TensorType.PYTORCH或'pt'：返回torch.Tensor类型的批次。TensorType.NUMPY或'np'：返回np.ndarray类型的批次。TensorType.JAX或'jax'：返回jax.numpy.ndarray类型的批次。
- 未设置：返回
返回
具有以下结构的 BatchFeature
- pixel_values (
TensorType): 预处理后的像素值。 - aspect_ratio_ids (
TensorType): 图像的宽高比 ID。 - num_tiles (
List[List[int]]): 批次中每张图像的图块数。
预处理一批图像。
调整大小
< 源代码 >( image: ndarray size: typing.Dict[str, int] max_image_tiles: int resample: Resampling = <Resampling.BILINEAR: 2> data_format: typing.Union[transformers.image_utils.ChannelDimension, str, NoneType] = None input_data_format: typing.Union[transformers.image_utils.ChannelDimension, str, NoneType] = None ) → Union[np.ndarray, Tuple[int, int]]
参数
- image (
np.ndarray) — 要调整大小的图像。 - size (
Dict[str, int]) — 输出图像的大小。 - max_image_tiles (
int) — 将图像分割成的最大图块数。 - resample (
PILImageResampling, 可选, 默认为PILImageResampling.BICUBIC) — 调整图像大小时使用的重采样滤波器。 - data_format (
str或ChannelDimension, 可选) — 图像的通道维度格式。如果未提供，则与输入图像相同。 - input_data_format (
ChannelDimension或str, 可选) — 输入图像的通道维度格式。如果未提供，则将进行推断。
返回
Union[np.ndarray, Tuple[int, int]]
调整大小后的图像以及包含高度和宽度维度上平铺数量的元组。
调整图像大小以适应平铺画布，同时保持其纵横比。最佳画布大小基于最大平铺数量和平铺大小计算得出。
该函数首先确定图像的最佳平铺排列方式，然后调整图像大小以适应此画布。返回调整大小后的图像以及高度和宽度维度上的平铺数量。
MllamaForConditionalGeneration
class transformers.MllamaForConditionalGeneration
< source >( config: MllamaConfig )
参数
- config (MllamaConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
Mllama 模型由视觉编码器和语言模型组成。此模型继承自 PreTrainedModel。查看超类文档以获取库为其所有模型实现的通用方法（例如，下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以获取与常规用法和行为相关的所有事项。
forward
< source >( input_ids: typing.Optional[torch.LongTensor] = None pixel_values: typing.Optional[torch.FloatTensor] = None aspect_ratio_mask: typing.Optional[torch.Tensor] = None aspect_ratio_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None cross_attention_mask: typing.Optional[torch.Tensor] = None cross_attention_states: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[typing.List[torch.FloatTensor]] = 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 ) → transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。如果您提供填充，默认情况下将忽略填充。索引可以使用 AutoTokenizer 获取。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- pixel_values (
torch.FloatTensor，形状为(batch_size, max_num_images, max_num_tiles, channels, image_size, image_size))-- 对应于输入图像的张量。像素值可以使用 [AutoImageProcessor](/docs/transformers/v4.50.0/en/model_doc/auto#transformers.AutoImageProcessor) 获取。 有关详细信息，请参阅 [MllamaImageProcessor.__call__()](/docs/transformers/v4.50.0/en/model_doc/vilt#transformers.ViltFeatureExtractor.__call__) ([]MllamaProcessor] 使用 MllamaImageProcessor 处理图像)。 - aspect_ratio_mask (
torch.Tensor，形状为(batch_size, max_num_images, max_num_tiles), 可选) — 用于避免对填充图块执行注意力的掩码。在[0, 1]中选择的掩码值：- 1 表示未被掩蔽的图块，
- 0 表示被掩蔽的图块。
- aspect_ratio_ids (
torch.Tensor，形状为(batch_size, max_num_images), 可选) — 纵横比 ID，用于根据每个输入图像的纵横比选择适当的预计算图块嵌入。这些 ID 对应于模型支持的纵横比列表中的索引，偏移量为 1。例如，如果模型支持纵横比 [[1, 1], [1, 2], [2, 1]]：
- 纵横比为 [1, 1] 的图像的 ID 为 1
- 纵横比为 [1, 2] 的图像的 ID 为 2
- 纵横比为 [2, 1] 的图像的 ID 为 3
ID 0 保留用于填充（即，无图像）。
如果图像的纵横比为 [1, 2]，则表示它在水平方向上被分割成 2 个图块，并且其
aspect_ratio_id将为 2。 - attention_mask (
torch.Tensor，形状为(batch_size, sequence_length), 可选) — 用于避免对填充令牌索引执行注意力的掩码。在[0, 1]中选择的掩码值：- 1 表示未被掩蔽的令牌，
- 0 表示被掩蔽的令牌。
索引可以使用 AutoTokenizer 获取。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
如果使用
past_key_values，则可以选择仅输入最后一个input_ids（请参阅past_key_values）。如果您想更改填充行为，则应阅读
modeling_opt._prepare_decoder_attention_mask并根据您的需要进行修改。有关默认策略的更多信息，请参见 论文 中的图 1。- 1 表示头未被掩蔽，
- 0 表示头被掩蔽。
- cross_attention_mask (
torch.Tensor，形状为(batch_size, seq_length, max_num_images, max_num_tiles), 可选) — 交叉注意力掩码，用于控制文本令牌和图像图块之间的交互。此 4D 张量定义了每个文本令牌应关注哪些图像图块。对于每个文本令牌（在 seq_length 中）：
- 1 表示令牌应关注相应的图像图块
- 0 表示令牌不应关注相应的图像图块
- cross_attention_states (
torch.FloatTensor, 可选) — 视觉模型的输出，用于交叉注意力。此张量包含语言模型将关注的处理后的图像特征。 - position_ids (
torch.LongTensor，形状为(batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列令牌的位置索引。在范围[0, config.n_positions - 1]中选择。 - past_key_values (
Cache或tuple(tuple(torch.FloatTensor)), 可选) — 预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在先前解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。允许两种格式：
- Cache 实例，请参阅我们的 kv 缓存指南；
- 长度为
config.n_layers的tuple(tuple(torch.FloatTensor))元组，每个元组具有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)) 的张量。这也称为旧版缓存格式。
模型将输出与作为输入馈送的缓存格式相同的缓存格式。如果未传递
past_key_values，则将返回旧版缓存格式。如果使用
past_key_values，则用户可以选择仅输入最后一个input_ids（那些没有将其过去键值状态提供给此模型的）形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的input_ids。 - inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size), 可选) — （可选）您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望比模型的内部嵌入查找矩阵更好地控制如何将input_ids索引转换为关联向量，这将非常有用。 - use_cache (
bool, 可选) — 如果设置为True，则返回past_key_values键值状态，并且可以用于加速解码（请参阅past_key_values）。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息，请参见返回张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息，请参见返回张量下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。 - cache_position (
torch.LongTensor，形状为(sequence_length)，可选) — 索引，描述输入序列 tokens 在序列中的位置。与position_ids相反，此张量不受 padding 的影响。它用于在正确的位置更新缓存，并推断完整的序列长度。 - labels (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于计算 masked language modeling loss 的标签。索引应为[0, ..., config.vocab_size]或 -100 (参见input_ids的文档字符串)。索引设置为-100的 tokens 将被忽略（masked），loss 仅针对标签在[0, ..., config.vocab_size]中的 tokens 计算。 - logits_to_keep (
int或torch.Tensor，可选) — 如果是int，则计算最后logits_to_keep个 tokens 的 logits。 如果是0，则计算所有input_ids的 logits（特殊情况）。 仅生成最后一个 token 的 logits 是需要的，并且仅为该 token 计算它们可以节省内存，这对于长序列或大型词汇表大小来说非常重要。 如果是torch.Tensor，则必须是 1D，对应于序列长度维度中要保留的索引。 这在使用 packed tensor 格式（批次和序列长度的单维度）时很有用。
返回
transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.CausalLMOutputWithPast 或一个 torch.FloatTensor 的 tuple (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包含取决于配置 (MllamaConfig) 和输入的各种元素。
-
loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 语言建模 loss (用于预测下一个 token)。 -
logits (
torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数 (SoftMax 之前每个词汇表 token 的分数)。 -
past_key_values (
tuple(tuple(torch.FloatTensor))，可选，当传递了use_cache=True或当config.use_cache=True时返回) —tuple(tuple(torch.FloatTensor))的 tuple，长度为config.n_layers，每个 tuple 有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量)包含预先计算的 hidden-states (自注意力模块中的 key 和 values)，可以用于（参见
past_key_values输入）加速顺序解码。 -
hidden_states (
tuple(torch.FloatTensor)，可选，当传递了output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的 tuple (如果模型有 embedding 层，则为 embedding 的输出，+ 每层输出一个)，形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的 hidden-states，加上可选的初始 embedding 输出。
-
attentions (
tuple(torch.FloatTensor)，可选，当传递了output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的 tuple (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头的加权平均值。
MllamaForConditionalGeneration 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 Module 实例，而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, MllamaForConditionalGeneration
>>> checkpoint = "meta-llama/Llama-3.2-11B-Vision"
>>> model = MllamaForConditionalGeneration.from_pretrained(checkpoint)
>>> processor = AutoProcessor.from_pretrained(checkpoint)
>>> prompt = "<|image|>If I had to write a haiku for this one"
>>> url = "https://www.ilankelman.org/stopsigns/australia.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)
>>> inputs = processor(text=prompt, images=image, return_tensors="pt")
>>> # Generate
>>> output = model.generate(**inputs, max_new_tokens=15)
>>> prompt_len = inputs.input_ids.shape[-1]
>>> generated_ids = output[:, prompt_len:]
>>> generated_text = processor.batch_decode(generated_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)
>>> print(generated_text)
[', it would be:.\\nA stop sign in Chinatown.\\n']MllamaForCausalLM
class transformers.MllamaForCausalLM
< source >( config )
参数
- config (MllamaConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
带有语言建模头的 Mllama 文本模型。此模型继承自 PreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入 embeddings 大小、剪枝头等）。
此模型也是 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 cross_attention_states: typing.Optional[torch.LongTensor] = None cross_attention_mask: typing.Optional[torch.LongTensor] = None full_text_row_masked_out_mask: typing.Optional[typing.Tuple[torch.Tensor, torch.Tensor]] = None past_key_values: typing.Union[transformers.cache_utils.Cache, typing.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 **loss_kwargs ) → transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。如果您提供 padding，默认情况下将被忽略。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- pixel_values (
torch.FloatTensor，形状为(batch_size, max_num_images, max_num_tiles, channels, image_size, image_size)) -- 对应于输入图像的张量。像素值可以使用 [AutoImageProcessor](/docs/transformers/v4.50.0/en/model_doc/auto#transformers.AutoImageProcessor) 获得。 有关详细信息，请参见 [MllamaImageProcessor.__call__()](/docs/transformers/v4.50.0/en/model_doc/vilt#transformers.ViltFeatureExtractor.__call__) ([`MllamaProcessor`] 使用 MllamaImageProcessor 处理图像)。 - aspect_ratio_mask (
torch.Tensor，形状为(batch_size, max_num_images, max_num_tiles)，可选) — 用于避免对 padding tiles 执行 attention 的 mask。Mask 值在[0, 1]中选择：- 1 表示 tiles 未被 mask，
- 0 表示 tiles 被 mask。
- aspect_ratio_ids (
torch.Tensor，形状为(batch_size, max_num_images)，可选) — Aspect ratio ids，用于根据每个输入图像的纵横比选择适当的预计算 tile embeddings。这些 ids 对应于模型支持的纵横比列表中的索引，偏移量为 1。例如，如果模型支持纵横比 [[1, 1], [1, 2], [2, 1]]：
- 纵横比为 [1, 1] 的图像的 ID 为 1
- 纵横比为 [1, 2] 的图像的 ID 为 2
- 纵横比为 [2, 1] 的图像的 ID 为 3
ID 0 保留用于 padding（即，无图像）。
如果图像的纵横比为 [1, 2]，则表示它在水平方向上被分割成 2 个 tiles，并且其
aspect_ratio_id将为 2。 - attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免对 padding token 索引执行 attention 的 mask。Mask 值在[0, 1]中选择：- 1 表示 tokens 未被 mask，
- 0 表示 tokens 被 mask。
索引可以使用 AutoTokenizer 获得。 有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
如果使用
past_key_values，则可以选择仅输入最后的input_ids（参见past_key_values）。如果您想更改 padding 行为，您应该阅读
modeling_opt._prepare_decoder_attention_mask并根据您的需求进行修改。 有关默认策略的更多信息，请参见 论文中的图 1。- 1 表示 head 未被 mask，
- 0 表示 head 被 mask。
- cross_attention_mask (
torch.Tensor，形状为(batch_size, seq_length, max_num_images, max_num_tiles)，可选) — 交叉注意力 mask，用于控制文本 tokens 和图像 tiles 之间的交互。此 4D 张量定义了每个文本 token 应 attend to 哪些图像 tiles。对于每个文本 token (在 seq_length 中):
- 1 表示 token 应该 attend to 相应的图像 tile
- 0 表示 token 不应该 attend to 相应的图像 tile
- cross_attention_states (
torch.FloatTensor，可选) — 视觉模型的输出，用于交叉注意力。此张量包含语言模型将 attend to 的已处理图像特征。 - position_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列 tokens 在位置 embeddings 中的位置索引。在范围[0, config.n_positions - 1]中选择。 - past_key_values (
Cache或tuple(tuple(torch.FloatTensor))，可选) — 预先计算的 hidden-states（自注意力模块和交叉注意力模块中的 key 和 values），可以用于加速顺序解码。这通常包括模型在前一解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。允许两种格式：
- Cache 实例，请参阅我们的 kv cache 指南；
tuple(tuple(torch.FloatTensor))的 tuple，长度为config.n_layers，每个 tuple 有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量）。 这也称为旧版缓存格式。
模型将输出与作为输入馈送的缓存格式相同的格式。 如果未传递
past_key_values，则将返回旧版缓存格式。如果使用
past_key_values，则用户可以选择仅输入最后的input_ids（那些没有将其过去的 key value states 提供给此模型的 tokens），形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的input_ids。 - inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。 如果您希望比模型的内部 embedding 查找矩阵更好地控制如何将input_ids索引转换为关联的向量，这将非常有用。 - use_cache (
bool，可选) — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。 - output_attentions (
bool，可选) — 是否返回所有注意力层的 attentions 张量。 有关更多详细信息，请参见返回的张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参见返回的张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回 ModelOutput 而不是纯粹的元组 (plain tuple)。 - cache_position (
torch.LongTensor，形状为(sequence_length)，可选) — 索引，描述输入序列 tokens 在序列中的位置。与position_ids相反，此张量不受 padding 的影响。它用于在正确的位置更新缓存，并推断完整的序列长度。 - labels (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于计算 masked language modeling loss 的标签。索引应为[0, ..., config.vocab_size]或 -100 (参见input_ids文档字符串)。索引设置为-100的 tokens 将被忽略（masked），loss 仅针对标签在[0, ..., config.vocab_size]中的 tokens 计算。 - logits_to_keep (
int或torch.Tensor，可选) — 如果是int，则计算最后logits_to_keep个 tokens 的 logits。如果为0，则计算所有input_ids的 logits（特殊情况）。只有最后一个 token 的 logits 用于生成，并且仅为该 token 计算 logits 可以节省内存，这对于长序列或大型词汇表大小来说非常重要。如果为torch.Tensor，则必须是 1D，对应于序列长度维度中要保留的索引。当使用 packed tensor 格式（批次和序列长度的单维度）时，这非常有用。
返回
transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.CausalLMOutputWithPast 或一个 torch.FloatTensor 元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (MllamaTextConfig) 和输入。
-
loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 语言建模 loss (用于预测下一个 token)。 -
logits (
torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数 (SoftMax 之前每个词汇表 token 的分数)。 -
past_key_values (
tuple(tuple(torch.FloatTensor))，可选，当传递了use_cache=True或当config.use_cache=True时返回) —tuple(tuple(torch.FloatTensor))的 tuple，长度为config.n_layers，每个 tuple 有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量)包含预先计算的 hidden-states (自注意力模块中的 key 和 values)，可以用于（参见
past_key_values输入）加速顺序解码。 -
hidden_states (
tuple(torch.FloatTensor)，可选，当传递了output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的 tuple (如果模型有 embedding 层，则为 embedding 的输出，+ 每层输出一个)，形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的 hidden-states，加上可选的初始 embedding 输出。
-
attentions (
tuple(torch.FloatTensor)，可选，当传递了output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的 tuple (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头的加权平均值。
MllamaForCausalLM 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 Module 实例，而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoTokenizer, MllamaForCausalLM
>>> model = MllamaForCausalLM.from_pretrained("Llama-3.2-11B-Vision")
>>> tokenizer = AutoTokenizer.from_pretrained("Llama-3.2-11B-Vision")
>>> prompt = "If I had to write a haiku, it would be:"
>>> inputs = tokenizer(prompt, return_tensors="pt")
>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=40, do_sample=True, temperature=0.6)
>>> result = tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
>>> print(result)
If I had to write a haiku, it would be: "Snowflakes gently fall" - simple, yet peaceful.
I love the idea of snowflakes gently falling, each oneMllamaTextModel
class transformers.MllamaTextModel
< source >( config: MllamaTextConfig )
参数
- config (MllamaConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。
Mllama 文本模型，由带有自注意力层和交叉注意力层的 transformer 组成。此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 heads 等）。
此模型也是 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 cross_attention_states: typing.Optional[torch.FloatTensor] = None cross_attention_mask: typing.Optional[torch.Tensor] = None full_text_row_masked_out_mask: typing.Optional[typing.Tuple[torch.Tensor, torch.Tensor]] = None past_key_values: typing.Union[transformers.cache_utils.Cache, typing.List[torch.FloatTensor], NoneType] = 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 ) → transformers.modeling_outputs.BaseModelOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。如果您提供 padding，默认情况下 padding 将被忽略。可以使用 AutoTokenizer 获得索引。 有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — Mask，用于避免在 padding token 索引上执行 attention。Mask 值在[0, 1]中选择：- 1 表示 tokens 未被 mask，
- 0 表示 tokens 已被 mask。
可以使用 AutoTokenizer 获得索引。 有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
如果使用
past_key_values，则可以选择仅输入最后的input_ids（请参阅past_key_values）。如果您想更改 padding 行为，则应阅读
modeling_opt._prepare_decoder_attention_mask并根据您的需求进行修改。 有关默认策略的更多信息，请参见 论文 中的图 1。- 1 表示 head 未被 mask，
- 0 表示 head 已被 mask。
- cross_attention_mask (
torch.Tensor，形状为(batch_size, seq_length, max_num_images, max_num_tiles)，可选) — 交叉注意力 mask，用于控制文本 tokens 和图像 tiles 之间的交互。此 4D 张量定义了每个文本 token 应关注哪些图像 tiles。对于每个文本 token（在 seq_length 中）：
- 1 表示 token 应关注 相应的图像 tile
- 0 表示 token 不应关注 相应的图像 tile
- cross_attention_states (
torch.FloatTensor，可选) — 视觉模型的输出，用于交叉注意力。此张量包含语言模型将关注的已处理图像特征。 - position_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列 tokens 在位置嵌入中的位置索引。在范围[0, config.n_positions - 1]中选择。 - past_key_values (
Cache或tuple(tuple(torch.FloatTensor))，可选) — 预先计算的 hidden-states（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常包括模型在先前解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。允许两种格式：
- Cache 实例，请参阅我们的 kv 缓存指南；
- 长度为
config.n_layers的tuple(tuple(torch.FloatTensor))元组，每个元组具有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。这也称为旧版缓存格式。
模型将输出与作为输入馈送的缓存格式相同的缓存格式。 如果未传递
past_key_values，则将返回旧版缓存格式。如果使用
past_key_values，则用户可以选择仅输入最后的input_ids（那些没有将其 past key value states 提供给此模型的）形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的input_ids。 - inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — （可选）您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想比模型的内部嵌入查找矩阵更精细地控制如何将input_ids索引转换为关联的向量，这将非常有用。 - use_cache (
bool，可选) — 如果设置为True，则返回past_key_values键值状态，并且可以用于加速解码（请参阅past_key_values）。 - output_attentions (
bool，可选) — 是否返回所有 attention 层的 attention 张量。 有关更多详细信息，请参见返回的张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参见返回的张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是纯粹的元组 (plain tuple)。 - cache_position (
torch.LongTensor，形状为(sequence_length)，可选) — 索引，描述输入序列 tokens 在序列中的位置。与position_ids相反，此张量不受 padding 的影响。它用于在正确的位置更新缓存，并推断完整的序列长度。
返回
transformers.modeling_outputs.BaseModelOutputWithPast 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutputWithPast 或一个 torch.FloatTensor 元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (MllamaTextConfig) 和输入。
-
last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出端的 hidden-states 序列。如果使用
past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后一个 hidden-state。 -
past_key_values (
tuple(tuple(torch.FloatTensor)), 可选, 当传递use_cache=True或当config.use_cache=True时返回) — 长度为config.n_layers的tuple(tuple(torch.FloatTensor))元组，其中每个元组包含 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，并且如果config.is_encoder_decoder=True，则可选地包含 2 个形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的附加张量。包含预先计算的隐藏状态（自注意力模块中的键和值，以及可选地，如果
config.is_encoder_decoder=True，则在交叉注意力模块中），这些状态可以用于（参见past_key_values输入）加速顺序解码。 -
hidden_states (
tuple(torch.FloatTensor)，可选，当传递了output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的 tuple (如果模型有 embedding 层，则为 embedding 的输出，+ 每层输出一个)，形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的 hidden-states，加上可选的初始 embedding 输出。
-
attentions (
tuple(torch.FloatTensor)，可选，当传递了output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的 tuple (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头的加权平均值。
MllamaTextModel 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 Module 实例，而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoProcessor, MllamaTextModel
>>> checkpoint = "meta-llama/Llama-3.2-11B-Vision"
>>> model = MllamaTextModel.from_pretrained(checkpoint)
>>> processor = AutoProcessor.from_pretrained(checkpoint)
>>> text = "<|image|>If I had to write a haiku for this one"
>>> inputs = processor(text=text, return_tensors="pt")
>>> output = model(**inputs)
>>> print(output.last_hidden_state.shape)
torch.Size([1, 13, 4096])MllamaForCausalLM
class transformers.MllamaForCausalLM
< source >( config )
参数
- config (MllamaConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
带有语言建模头的 Mllama 文本模型。此模型继承自 PreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入 embeddings 大小、剪枝头等）。
此模型也是 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 cross_attention_states: typing.Optional[torch.LongTensor] = None cross_attention_mask: typing.Optional[torch.LongTensor] = None full_text_row_masked_out_mask: typing.Optional[typing.Tuple[torch.Tensor, torch.Tensor]] = None past_key_values: typing.Union[transformers.cache_utils.Cache, typing.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 **loss_kwargs ) → transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。如果您提供 padding，默认情况下将被忽略。索引可以使用 AutoTokenizer 获得。 有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- pixel_values (
torch.FloatTensor，形状为(batch_size, max_num_images, max_num_tiles, channels, image_size, image_size)) -- 对应于输入图像的张量。像素值可以使用 [AutoImageProcessor](/docs/transformers/v4.50.0/en/model_doc/auto#transformers.AutoImageProcessor) 获得。 有关详细信息，请参见 [MllamaImageProcessor.__call__()](/docs/transformers/v4.50.0/en/model_doc/vilt#transformers.ViltFeatureExtractor.__call__) ([`MllamaProcessor`] 使用 MllamaImageProcessor 处理图像)。 - aspect_ratio_mask (
torch.Tensor，形状为(batch_size, max_num_images, max_num_tiles)，可选) — 用于避免对 padding tiles 执行 attention 的 mask。Mask 值在[0, 1]中选择：- 1 表示 tiles 未被 mask，
- 0 表示 tiles 被 mask。
- aspect_ratio_ids (
torch.Tensor，形状为(batch_size, max_num_images)，可选) — Aspect ratio ids，用于根据每个输入图像的纵横比选择适当的预计算 tile embeddings。这些 ids 对应于模型支持的纵横比列表中的索引，偏移量为 1。例如，如果模型支持纵横比 [[1, 1], [1, 2], [2, 1]]：
- 纵横比为 [1, 1] 的图像的 ID 为 1
- 纵横比为 [1, 2] 的图像的 ID 为 2
- 纵横比为 [2, 1] 的图像的 ID 为 3
ID 0 保留用于 padding（即，无图像）。
如果图像的纵横比为 [1, 2]，则表示它在水平方向上被分割成 2 个 tiles，并且其
aspect_ratio_id将为 2。 - attention_mask (
torch.Tensor，形状为(batch_size, sequence_length)，可选) — 用于避免对 padding token 索引执行 attention 的 mask。Mask 值在[0, 1]中选择：- 1 表示 tokens 未被 mask，
- 0 表示 tokens 被 mask。
索引可以使用 AutoTokenizer 获得。 有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
如果使用
past_key_values，则可以选择仅输入最后的input_ids（参见past_key_values）。如果您想更改 padding 行为，您应该阅读
modeling_opt._prepare_decoder_attention_mask并根据您的需求进行修改。 有关默认策略的更多信息，请参见 论文中的图 1。- 1 表示 head 未被 mask，
- 0 表示 head 被 mask。
- cross_attention_mask (
torch.Tensor，形状为(batch_size, seq_length, max_num_images, max_num_tiles)，可选) — 交叉注意力 mask，用于控制文本 tokens 和图像 tiles 之间的交互。此 4D 张量定义了每个文本 token 应 attend to 哪些图像 tiles。对于每个文本 token (在 seq_length 中):
- 1 表示 token 应该 attend to 相应的图像 tile
- 0 表示 token 不应该 attend to 相应的图像 tile
- cross_attention_states (
torch.FloatTensor，可选) — 视觉模型的输出，用于交叉注意力。此张量包含语言模型将 attend to 的已处理图像特征。 - position_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列 tokens 在位置 embeddings 中的位置索引。在范围[0, config.n_positions - 1]中选择。 - past_key_values (
Cache或tuple(tuple(torch.FloatTensor))，可选) — 预先计算的 hidden-states（自注意力模块和交叉注意力模块中的 key 和 values），可以用于加速顺序解码。这通常包括模型在前一解码阶段返回的past_key_values，当use_cache=True或config.use_cache=True时。允许两种格式：
- Cache 实例，请参阅我们的 kv cache 指南；
tuple(tuple(torch.FloatTensor))的 tuple，长度为config.n_layers，每个 tuple 有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量）。 这也称为旧版缓存格式。
模型将输出与作为输入馈送的缓存格式相同的格式。 如果未传递
past_key_values，则将返回旧版缓存格式。如果使用
past_key_values，则用户可以选择仅输入最后的input_ids（那些没有将其过去的 key value states 提供给此模型的 tokens），形状为(batch_size, 1)，而不是所有形状为(batch_size, sequence_length)的input_ids。 - inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。 如果您希望比模型的内部 embedding 查找矩阵更好地控制如何将input_ids索引转换为关联的向量，这将非常有用。 - use_cache (
bool，可选) — 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。 - output_attentions (
bool，可选) — 是否返回所有注意力层的 attentions 张量。 有关更多详细信息，请参见返回的张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参见返回的张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回 ModelOutput 而不是纯粹的元组 (plain tuple)。 - cache_position (
torch.LongTensor，形状为(sequence_length)，可选) — 索引，描述输入序列 tokens 在序列中的位置。与position_ids相反，此张量不受 padding 的影响。它用于在正确的位置更新缓存，并推断完整的序列长度。 - labels (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 用于计算 masked language modeling loss 的标签。索引应为[0, ..., config.vocab_size]或 -100 (参见input_ids文档字符串)。索引设置为-100的 tokens 将被忽略（masked），loss 仅针对标签在[0, ..., config.vocab_size]中的 tokens 计算。 - logits_to_keep (
int或torch.Tensor，可选) — 如果是int，则计算最后logits_to_keep个 tokens 的 logits。如果为0，则计算所有input_ids的 logits（特殊情况）。只有最后一个 token 的 logits 用于生成，并且仅为该 token 计算 logits 可以节省内存，这对于长序列或大型词汇表大小来说非常重要。如果为torch.Tensor，则必须是 1D，对应于序列长度维度中要保留的索引。当使用 packed tensor 格式（批次和序列长度的单维度）时，这非常有用。
返回
transformers.modeling_outputs.CausalLMOutputWithPast 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.CausalLMOutputWithPast 或一个 torch.FloatTensor 元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，包含各种元素，具体取决于配置 (MllamaTextConfig) 和输入。
-
loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 语言建模 loss (用于预测下一个 token)。 -
logits (
torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数 (SoftMax 之前每个词汇表 token 的分数)。 -
past_key_values (
tuple(tuple(torch.FloatTensor))，可选，当传递了use_cache=True或当config.use_cache=True时返回) —tuple(tuple(torch.FloatTensor))的 tuple，长度为config.n_layers，每个 tuple 有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量)包含预先计算的 hidden-states (自注意力模块中的 key 和 values)，可以用于（参见
past_key_values输入）加速顺序解码。 -
hidden_states (
tuple(torch.FloatTensor)，可选，当传递了output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的 tuple (如果模型有 embedding 层，则为 embedding 的输出，+ 每层输出一个)，形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的 hidden-states，加上可选的初始 embedding 输出。
-
attentions (
tuple(torch.FloatTensor)，可选，当传递了output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的 tuple (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头的加权平均值。
MllamaForCausalLM 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 Module 实例，而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoTokenizer, MllamaForCausalLM
>>> model = MllamaForCausalLM.from_pretrained("Llama-3.2-11B-Vision")
>>> tokenizer = AutoTokenizer.from_pretrained("Llama-3.2-11B-Vision")
>>> prompt = "If I had to write a haiku, it would be:"
>>> inputs = tokenizer(prompt, return_tensors="pt")
>>> # Generate
>>> generate_ids = model.generate(inputs.input_ids, max_length=40, do_sample=True, temperature=0.6)
>>> result = tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
>>> print(result)
If I had to write a haiku, it would be: "Snowflakes gently fall" - simple, yet peaceful.
I love the idea of snowflakes gently falling, each oneMllamaVisionModel
class transformers.MllamaVisionModel
< source >( config: MllamaVisionConfig )
参数
- config (MllamaConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
Mllama 视觉模型，由两个视觉编码器组成。此模型继承自 PreTrainedModel。查看超类文档以获取库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参阅 PyTorch 文档以获取与常规用法和行为相关的所有事项。
forward
< source >( pixel_values: Tensor aspect_ratio_ids: Tensor aspect_ratio_mask: Tensor output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.BaseModelOutput 或 tuple(torch.FloatTensor)
参数
- pixel_values (
torch.FloatTensor，形状为(batch_size, max_num_images, max_num_tiles, channels, image_size, image_size))-- 对应于输入图像的张量。像素值可以使用 [AutoImageProcessor](/docs/transformers/v4.50.0/en/model_doc/auto#transformers.AutoImageProcessor) 获得。有关详细信息，请参阅 [MllamaImageProcessor.__call__()](/docs/transformers/v4.50.0/en/model_doc/vilt#transformers.ViltFeatureExtractor.__call__) （[`MllamaProcessor`] 使用 MllamaImageProcessor 处理图像）。 - aspect_ratio_mask (
torch.Tensor，形状为(batch_size, max_num_images, max_num_tiles), 可选) — 用于避免对填充瓦片执行注意力的掩码。掩码值在[0, 1]中选择：- 1 表示未被掩码的瓦片，
- 0 表示被掩码的瓦片。
- aspect_ratio_ids (
torch.Tensor，形状为(batch_size, max_num_images), 可选) — 用于根据每个输入图像的宽高比选择适当的预计算瓦片嵌入的宽高比 ID。这些 ID 对应于模型支持的宽高比列表中的索引，偏移量为 1。例如，如果模型支持宽高比 [[1, 1], [1, 2], [2, 1]]：
- 宽高比为 [1, 1] 的图像的 ID 为 1
- 宽高比为 [1, 2] 的图像的 ID 为 2
- 宽高比为 [2, 1] 的图像的 ID 为 3
ID 0 保留用于填充（即，没有图像）。
如果图像的宽高比为 [1, 2]，则表示它在水平方向上被分割成 2 个瓦片，并且其
aspect_ratio_id将为 2。 - output_attentions (
bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通元组。
返回
transformers.modeling_outputs.BaseModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.BaseModelOutput 或一个 torch.FloatTensor 元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时)，其中包含各种元素，具体取决于配置 (MllamaVisionConfig) 和输入。
-
last_hidden_state (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的输出端的 hidden-states 序列。 -
hidden_states (
tuple(torch.FloatTensor)，可选，当传递了output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor的 tuple (如果模型有 embedding 层，则为 embedding 的输出，+ 每层输出一个)，形状为(batch_size, sequence_length, hidden_size)。模型在每一层输出的 hidden-states，加上可选的初始 embedding 输出。
-
attentions (
tuple(torch.FloatTensor)，可选，当传递了output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor的 tuple (每层一个)，形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力头的加权平均值。
MllamaVisionModel 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 Module 实例，而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> 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])