Transformers 文档

Mllama

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

Mllama

PyTorch

概述

Llama 3.2-Vision 多模态大型语言模型 (LLM) 集合是预训练和指令微调的图像推理生成模型集合,提供 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 和输入嵌入层将有一个额外的标记。但是由于输入和输出嵌入的权重不绑定,lm_head 层少了一个标记,如果您想计算图像标记上的损失或应用一些 logits 处理器,它将失败。如果您正在训练,请确保在 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

< >

( vision_config = None text_config = None image_token_index = 128256 **kwargs )

参数

  • vision_config (Union[AutoConfig, dict], 可选, 默认为 MllamaVisionConfig) — 视觉骨干网络的配置对象或字典。
  • text_config (Union[AutoConfig, dict], 可选, 默认为 MllamaTextConfig) — 文本骨干网络的配置对象或字典。
  • image_token_index (int, 可选, 默认为 128256) — 用于编码图像提示的图像标记索引。

这是用于存储 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.config

MllamaProcessor

class transformers.MllamaProcessor

< >

( image_processor tokenizer chat_template = None )

参数

  • image_processor (MllamaImageProcessor) — 图像处理器是必需输入。
  • tokenizer ([PreTrainedTokenizer, PreTrainedTokenizerFast]) — 标记器是必需输入。
  • chat_template (str, 可选) — Jinja 模板,用于将聊天消息列表转换为可标记化字符串。

构建一个 Mllama 处理器,该处理器将 MllamaImageProcessorPretrainedTokenizerFast 封装到单个处理器中,该处理器继承图像处理器和标记器功能。有关更多信息,请参阅 __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"},
)

批量解码

< >

( *args **kwargs )

此方法将其所有参数转发给 PreTrainedTokenizerFast 的 batch_decode()。有关更多信息,请参阅此方法的文档字符串。

解码

< >

( *args **kwargs )

此方法将其所有参数转发给 PreTrainedTokenizerFast 的 decode()。有关更多信息,请参阅此方法的文档字符串。

后处理图像文本到文本

< >

( generated_outputs skip_special_tokens = True clean_up_tokenization_spaces = False **kwargs ) list[str]

参数

  • generated_outputs (torch.Tensornp.ndarray) — 模型 generate 函数的输出。输出应为形状为 (batch_size, sequence_length)(sequence_length,) 的张量。
  • skip_special_tokens (bool, 可选, 默认为 True) — 是否在输出中删除特殊标记。参数传递给标记器的 batch_decode 方法。
  • clean_up_tokenization_spaces (bool, 可选, 默认为 False) — 是否清除标记化空间。参数传递给标记器的 batch_decode 方法。
  • **kwargs — 要传递给标记器 batch_decode 方法 的附加参数。

返回

list[str]

解码后的文本。

后处理模型输出以解码文本。

MllamaImageProcessor

class transformers.MllamaImageProcessor

< >

( do_convert_rgb: bool = True do_resize: bool = True size: typing.Optional[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, list[float], NoneType] = None image_std: typing.Union[float, 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' 键,两者都为整数值。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 (floatlist[float], 可选, 默认为 self.image_mean) — 用于标准化的图像均值。仅当 do_normalize 设置为 True 时才有效。
  • image_std (floatlist[float], 可选, 默认为 self.image_std) — 用于标准化的图像标准差。仅当 do_normalize 设置为 True 时才有效。
  • do_pad (bool, 可选, 默认为 True) — 是否将图像填充到批次中的最大高度和宽度。
  • max_image_tiles (int, 可选, 默认为 4) — 将图像分割成的最大图块数。

构建 Mllama 图像处理器。

pad

< >

( image: ndarray size: dict aspect_ratio: tuple data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None ) np.ndarray

参数

  • image (np.ndarray) — 要调整大小的图像。
  • size (dict[str, int]) — 输出图像的大小。
  • aspect_ratio (tuple[int, int]) — 图像的纵横比。
  • data_format (strChannelDimension, 可选) — 图像的通道维度格式。如果未提供,将与输入图像的格式相同。
  • input_data_format (ChannelDimensionstr, 可选) — 输入图像的通道维度格式。如果未提供,将自动推断。

返回

np.ndarray

填充后的图像。

将图像填充到 size x aspect_ratio。例如,如果 size 为 {height: 224, width: 224} 且纵横比为 (1, 2),图像将被填充到 224x448。

preprocess

< >

( 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[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, list[float], NoneType] = None image_std: typing.Union[float, list[float], NoneType] = None do_pad: typing.Optional[bool] = None max_image_tiles: typing.Optional[int] = None input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, 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”键的字典,两者均具有整数值。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 (floatlist[float], 可选, 默认为 self.image_mean) — 用于标准化的图像均值。仅当 do_normalize 设置为 True 时才有效。
  • image_std (floatlist[float], 可选, 默认为 self.image_std) — 用于标准化的图像标准差。仅当 do_normalize 设置为 True 时才有效。
  • do_pad (bool, 可选, 默认为 self.do_pad) — 是否将图像填充到批次中最大的高度和宽度。
  • max_image_tiles (int, 可选, 默认为 self.max_image_tiles) — 将图像分割成的最大图块数。
  • input_data_format (ChannelDimensionstr, 可选) — 输入图像的通道维度格式。如果未设置,将从输入图像推断通道维度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。
    • "none"ChannelDimension.NONE: 图像格式为 (height, width)。
  • return_tensors (strTensorType, 可选) — 要返回的张量类型。可以是以下之一:
    • 未设置:返回 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]]): 批次中每张图像的图块数。

预处理一批图像。

resize

< >

( image: ndarray size: dict max_image_tiles: int resample: Resampling = <Resampling.BILINEAR: 2> data_format: typing.Union[str, transformers.image_utils.ChannelDimension, NoneType] = None input_data_format: typing.Union[str, transformers.image_utils.ChannelDimension, 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 (strChannelDimension, 可选) — 图像的通道维度格式。如果未提供,将与输入图像的格式相同。
  • input_data_format (ChannelDimensionstr, 可选) — 输入图像的通道维度格式。如果未提供,将自动推断。

返回

Union[np.ndarray, tuple[int, int]]

调整大小后的图像以及沿高度和宽度维度的图块数量元组。

调整图像大小以适应平铺画布,同时保持其纵横比。最佳画布大小根据最大图块数和图块大小计算得出。

该函数首先确定图像的最佳图块排列,然后调整图像大小以适应此画布。返回调整大小后的图像以及沿高度和宽度维度的图块数量。

MllamaForConditionalGeneration

class transformers.MllamaForConditionalGeneration

< >

( config: MllamaConfig )

参数

  • config (MllamaConfig) — 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重,只加载配置。请查看 from_pretrained() 方法以加载模型权重。

Mllama 模型由一个视觉编码器和一个语言模型组成。

此模型继承自 PreTrainedModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等)。

此模型也是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用,并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。

forward

< >

( 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.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.mllama.modeling_mllama.KwargsForCausalLM] ) transformers.modeling_outputs.CausalLMOutputWithPasttuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, sequence_length), 可选) — 词汇表中输入序列 token 的索引。默认情况下会忽略填充。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参见 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是 input ID?

  • pixel_values (torch.FloatTensor 形状为 (batch_size, num_channels, image_size, image_size), 可选) — 对应输入图像的张量。像素值可以使用 {image_processor_class} 获取。有关详细信息,请参见 {image_processor_class}.__call__{processor_class} 使用 {image_processor_class} 处理图像)。
  • 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), 可选) — 用于避免对填充 token 索引执行注意力操作的掩码。掩码值选择范围为 [0, 1]

    • 1 表示未被掩码的 token,
    • 0 表示被掩码的 token。

    什么是注意力掩码?

  • cross_attention_mask (torch.Tensor 形状为 (batch_size, seq_length, max_num_images, max_num_tiles), 可选) — 交叉注意力掩码,用于控制文本 token 和图像图块之间的交互。此 4D 张量定义了每个文本 token 应关注哪些图像图块。

    对于每个文本 token(在 seq_length 中):

    • 1 表示 token 应关注相应的图像图块
    • 0 表示 token 不应关注相应的图像图块
  • cross_attention_states (torch.FloatTensor, 可选) — 视觉模型的输出,用于交叉注意力。此张量包含语言模型将关注的已处理图像特征。
  • position_ids (torch.LongTensor 形状为 (batch_size, sequence_length), 可选) — 每个输入序列 token 在位置嵌入中的位置索引。选择范围为 [0, config.n_positions - 1]

    什么是位置 ID?

  • past_key_values (Union[~cache_utils.Cache, list[torch.FloatTensor], NoneType]) — 预计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码。这通常包括模型在解码上一阶段返回的 past_key_values,当 use_cache=Trueconfig.use_cache=True 时。

    允许两种格式:

    • Cache 实例,请参阅我们的 kv 缓存指南
    • 长度为 config.n_layerstuple(torch.FloatTensor) 元组,每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量)。这也被称为旧版缓存格式。

    模型将输出与输入相同的缓存格式。如果没有传入 past_key_values,将返回旧版缓存格式。

    如果使用 past_key_values,用户可以选择仅输入形状为 (batch_size, 1) 的最后一个 input_ids(那些没有将其过去的键值状态提供给此模型的 token),而不是形状为 (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), 可选) — 用于计算 masked language modeling 损失的标签。索引应在 [0, ..., config.vocab_size] 或 -100 之间(参见 input_ids 文档字符串)。索引设置为 -100 的 token 将被忽略(被掩码),损失仅针对标签在 [0, ..., config.vocab_size] 中的 token 计算。
  • 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), 可选) — 表示输入序列 token 在序列中位置的索引。与 position_ids 不同,此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。
  • logits_to_keep (Union[int, torch.Tensor], 默认为 0) — 如果是 int,则计算最后 logits_to_keep 个 token 的 logits。如果是 0,则计算所有 input_ids 的 logits(特殊情况)。生成时只需要最后一个 token 的 logits,只计算该 token 可以节省内存,这对于长序列或大词汇量来说非常重要。如果是 torch.Tensor,则必须是与序列长度维度中要保留的索引相对应的 1D 张量。当使用打包张量格式(批次和序列长度的单个维度)时,这很有用。

返回

transformers.modeling_outputs.CausalLMOutputWithPasttuple(torch.FloatTensor)

一个 transformers.modeling_outputs.CausalLMOutputWithPasttorch.FloatTensor 元组(如果传入 return_dict=Falseconfig.return_dict=False),包含根据配置 (MllamaConfig) 和输入的不同元素。

  • loss (torch.FloatTensor 形状为 (1,)可选,当提供 labels 时返回) — 语言建模损失(用于下一个 token 预测)。

  • logits (形状为 (batch_size, sequence_length, config.vocab_size)torch.FloatTensor) — 语言建模头部的预测分数(SoftMax 之前的每个词汇标记的分数)。

  • past_key_values (Cache, 可选, 当传入 use_cache=Trueconfig.use_cache=True 时返回) — 这是一个 Cache 实例。有关详细信息,请参阅我们的 kv 缓存指南

    包含预计算的隐藏状态(自注意力块中的键和值),可用于(参见 past_key_values 输入)加速顺序解码。

  • hidden_states (tuple(torch.FloatTensor), 可选, 当传入 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 元组(一个用于嵌入层输出,如果模型有嵌入层,+ 每个层输出一个),形状为 (batch_size, sequence_length, hidden_size)

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor), 可选, 当传入 output_attentions=Trueconfig.output_attentions=True 时返回) — torch.FloatTensor 元组(每个层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

MllamaForConditionalGeneration forward 方法,覆盖了 __call__ 特殊方法。

尽管前向传播的实现必须在此函数中定义,但在此之后应该调用 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

< >

( config )

参数

  • config (MllamaForCausalLM) — 模型的配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。要加载模型权重,请查看from_pretrained()方法。

带有语言建模头的Mllama文本模型。

此模型继承自 PreTrainedModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等)。

此模型也是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用,并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None cross_attention_states: typing.Optional[torch.LongTensor] = None cross_attention_mask: typing.Optional[torch.LongTensor] = None full_text_row_masked_out_mask: typing.Optional[tuple[torch.Tensor, torch.Tensor]] = 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.mllama.modeling_mllama.KwargsForCausalLM] ) transformers.modeling_outputs.CausalLMOutputWithPast or tuple(torch.FloatTensor)

参数

  • input_ids (形状为(batch_size, sequence_length)torch.LongTensor可选) — 词汇表中输入序列标记的索引。默认情况下会忽略填充。

    可以使用AutoTokenizer获取索引。有关详细信息,请参阅PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入ID?

  • attention_mask (形状为(batch_size, sequence_length)torch.Tensor可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值在[0, 1]中选择:

    • 1表示未被掩码的标记,
    • 0表示被掩码的标记。

    什么是注意力掩码?

  • position_ids (形状为(batch_size, sequence_length)torch.LongTensor可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.n_positions - 1]

    什么是位置ID?

  • cross_attention_states (torch.FloatTensor, 可选) — 视觉模型的输出,用于交叉注意力。此张量包含语言模型将关注的已处理图像特征。
  • cross_attention_mask (形状为(batch_size, seq_length, max_num_images, max_num_tiles)torch.Tensor可选) — 交叉注意力掩码,用于控制文本标记和图像块之间的交互。此4D张量定义了每个文本标记应关注哪些图像块。

    对于每个文本标记(在seq_length中):

    • 1表示标记应关注对应的图像块
    • 0表示标记不应关注对应的图像块
  • full_text_row_masked_out_mask (tuple[torch.Tensor, torch.Tensor]可选) — 包含两个张量的元组,用于掩盖交叉注意力机制中的行:

    • 第一个张量的形状为(batch_size, 1, seq_length, 1),包含0或1的值。值为0表示对应的文本标记在交叉注意力矩阵中的整行应被掩盖(所有图像标记被忽略)。
    • 第二个张量具有相同的形状,并在交叉注意力层的正向传播期间内部用于应用掩码。此掩码派生自cross_attention_mask,用于处理文本标记不应关注任何图像标记的情况。
  • past_key_values (Union[~cache_utils.Cache, list[torch.FloatTensor], NoneType]) — 预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码。这通常包括模型在解码前期返回的past_key_values,当use_cache=Trueconfig.use_cache=True时。

    允许两种格式:

    • 一个Cache实例,请参阅我们的kv缓存指南
    • 长度为config.n_layerstuple(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 (形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor可选) — 可选地,您可以选择直接传入嵌入表示而不是传入input_ids。如果您希望对如何将input_ids索引转换为关联向量有比模型内部嵌入查找矩阵更多的控制,这将非常有用。
  • labels (形状为(batch_size, sequence_length)torch.LongTensor可选) — 用于计算掩码语言建模损失的标签。索引应在[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 (形状为(sequence_length)torch.LongTensor可选) — 描述输入序列标记在序列中位置的索引。与position_ids不同,此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。
  • logits_to_keep (Union[int, torch.Tensor],默认为0) — 如果是int,则计算最后logits_to_keep个标记的logits。如果是0,则计算所有input_ids的logits(特殊情况)。生成时只需要最后一个标记的logits,仅为该标记计算可以节省内存,这对于长序列或大词汇量来说非常显著。如果是torch.Tensor,必须是与序列长度维度中要保留的索引相对应的1D张量。这在使用打包张量格式(批处理和序列长度的单一维度)时非常有用。

返回

transformers.modeling_outputs.CausalLMOutputWithPasttuple(torch.FloatTensor)

一个 transformers.modeling_outputs.CausalLMOutputWithPasttorch.FloatTensor 元组(如果传入 return_dict=Falseconfig.return_dict=False),包含根据配置 (MllamaConfig) 和输入的不同元素。

  • loss (torch.FloatTensor 形状为 (1,)可选,当提供 labels 时返回) — 语言建模损失(用于下一个 token 预测)。

  • logits (形状为 (batch_size, sequence_length, config.vocab_size)torch.FloatTensor) — 语言建模头部的预测分数(SoftMax 之前的每个词汇标记的分数)。

  • past_key_values (Cache, 可选, 当传入 use_cache=Trueconfig.use_cache=True 时返回) — 这是一个 Cache 实例。有关详细信息,请参阅我们的 kv 缓存指南

    包含预计算的隐藏状态(自注意力块中的键和值),可用于(参见 past_key_values 输入)加速顺序解码。

  • hidden_states (tuple(torch.FloatTensor), 可选, 当传入 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 元组(一个用于嵌入层输出,如果模型有嵌入层,+ 每个层输出一个),形状为 (batch_size, sequence_length, hidden_size)

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor), 可选, 当传入 output_attentions=Trueconfig.output_attentions=True 时返回) — torch.FloatTensor 元组(每个层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

Mllama Text Model 的正向传播方法,覆盖了__call__特殊方法。

尽管前向传播的实现必须在此函数中定义,但在此之后应该调用 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 one

MllamaTextModel

class transformers.MllamaTextModel

< >

( config: MllamaTextConfig )

参数

  • config (MllamaTextConfig) — 模型的配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。要加载模型权重,请查看from_pretrained()方法。

Mllama文本模型,由带自注意力和交叉注意力层的Transformer组成。

此模型继承自 PreTrainedModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等)。

此模型也是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用,并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None cross_attention_states: typing.Optional[torch.FloatTensor] = None cross_attention_mask: typing.Optional[torch.Tensor] = None full_text_row_masked_out_mask: typing.Optional[tuple[torch.Tensor, torch.Tensor]] = None past_key_values: typing.Union[transformers.cache_utils.Cache, 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 **kwargs: typing_extensions.Unpack[transformers.modeling_flash_attention_utils.FlashAttentionKwargs] ) transformers.modeling_outputs.BaseModelOutputWithPast or tuple(torch.FloatTensor)

参数

  • input_ids (形状为(batch_size, sequence_length)torch.LongTensor可选) — 词汇表中输入序列标记的索引。默认情况下会忽略填充。

    可以使用AutoTokenizer获取索引。有关详细信息,请参阅PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入ID?

  • attention_mask (形状为(batch_size, sequence_length)torch.Tensor可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值在[0, 1]中选择:

    • 1表示未被掩码的标记,
    • 0表示被掩码的标记。

    什么是注意力掩码?

  • position_ids (形状为(batch_size, sequence_length)torch.LongTensor可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.n_positions - 1]

    什么是位置ID?

  • cross_attention_states (torch.FloatTensor可选) — 视觉模型的输出,用于交叉注意力。此张量包含语言模型将关注的已处理图像特征。
  • cross_attention_mask (形状为(batch_size, seq_length, max_num_images, max_num_tiles)torch.Tensor可选) — 交叉注意力掩码,用于控制文本标记和图像块之间的交互。此4D张量定义了每个文本标记应关注哪些图像块。

    对于每个文本标记(在seq_length中):

    • 1表示标记应关注对应的图像块
    • 0表示标记不应关注对应的图像块
  • full_text_row_masked_out_mask (tuple[torch.Tensor, torch.Tensor]可选) — 包含两个张量的元组,用于掩盖交叉注意力机制中的行:

    • 第一个张量的形状为(batch_size, 1, seq_length, 1),包含0或1的值。值为0表示对应的文本标记在交叉注意力矩阵中的整行应被掩盖(所有图像标记被忽略)。
    • 第二个张量具有相同的形状,并在交叉注意力层的正向传播期间内部用于应用掩码。此掩码派生自cross_attention_mask,用于处理文本标记不应关注任何图像标记的情况。
  • past_key_values (Union[~cache_utils.Cache, list[torch.FloatTensor], NoneType]) — 预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码。这通常包括模型在解码前期返回的past_key_values,当use_cache=Trueconfig.use_cache=True时。

    允许两种格式:

    • 一个Cache实例,请参阅我们的kv缓存指南
    • 长度为config.n_layerstuple(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 (形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor可选) — 可选地,您可以选择直接传入嵌入表示而不是传入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 (形状为(sequence_length)torch.LongTensor可选) — 描述输入序列标记在序列中位置的索引。与position_ids不同,此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。

返回

transformers.modeling_outputs.BaseModelOutputWithPasttuple(torch.FloatTensor)

一个transformers.modeling_outputs.BaseModelOutputWithPast或一个torch.FloatTensor元组(如果传入return_dict=Falseconfig.return_dict=False),包含根据配置(MllamaConfig)和输入的不同元素。

  • 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=Trueconfig.use_cache=True 时返回) — 这是一个 Cache 实例。有关详细信息,请参阅我们的 kv 缓存指南

    包含预先计算的隐藏状态(自注意力块中的键和值,如果config.is_encoder_decoder=True则可选地包含交叉注意力块中的键和值),可用于(请参阅past_key_values输入)加速顺序解码。

  • hidden_states (tuple(torch.FloatTensor), 可选, 当传入 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 元组(一个用于嵌入层输出,如果模型有嵌入层,+ 每个层输出一个),形状为 (batch_size, sequence_length, hidden_size)

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor), 可选, 当传入 output_attentions=Trueconfig.output_attentions=True 时返回) — torch.FloatTensor 元组(每个层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

MllamaTextModel 的正向传播方法,覆盖了__call__特殊方法。

尽管前向传播的实现必须在此函数中定义,但在此之后应该调用 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])

MllamaModel

class transformers.MllamaModel

< >

( config: MllamaConfig )

参数

  • config (MllamaConfig) — 模型的配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。要加载模型权重,请查看from_pretrained()方法。

Mllama模型,由一个视觉编码器和一个不带语言建模头的语言模型组成。

此模型继承自 PreTrainedModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等)。

此模型也是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用,并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。

forward

< >

( 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[list[torch.FloatTensor]] = 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 **kwargs: typing_extensions.Unpack[transformers.modeling_flash_attention_utils.FlashAttentionKwargs] ) transformers.modeling_outputs.CausalLMOutputWithPast or tuple(torch.FloatTensor)

参数

  • input_ids (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 词汇表中输入序列标记的索引。默认情况下会忽略填充。

    可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入 ID?

  • pixel_values (torch.FloatTensor,形状为 (batch_size, num_channels, image_size, image_size)可选) — 与输入图像对应的张量。可以使用 {image_processor_class} 获取像素值。有关详细信息,请参阅 {image_processor_class}.__call__{processor_class} 使用 {image_processor_class} 处理图像)。
  • 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 表示**被掩码**的标记。

    什么是注意力掩码?

  • 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]

    什么是位置 ID?

  • past_key_values (list[torch.FloatTensor]可选) — 预计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码。这通常包括模型在解码前一阶段返回的 past_key_values,当 use_cache=Trueconfig.use_cache=True 时。

    允许两种格式:

    • 一个 Cache 实例,请参阅我们的 kv 缓存指南
    • 长度为 config.n_layerstuple(torch.FloatTensor) 元组,每个元组包含 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的张量)。这也被称为传统缓存格式。

    模型将输出与输入相同的缓存格式。如果没有传入 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.CausalLMOutputWithPasttuple(torch.FloatTensor)

一个 transformers.modeling_outputs.CausalLMOutputWithPasttorch.FloatTensor 元组(如果传入 return_dict=Falseconfig.return_dict=False),包含根据配置 (MllamaConfig) 和输入的不同元素。

  • loss (torch.FloatTensor 形状为 (1,)可选,当提供 labels 时返回) — 语言建模损失(用于下一个 token 预测)。

  • logits (形状为 (batch_size, sequence_length, config.vocab_size)torch.FloatTensor) — 语言建模头部的预测分数(SoftMax 之前的每个词汇标记的分数)。

  • past_key_values (Cache, 可选, 当传入 use_cache=Trueconfig.use_cache=True 时返回) — 这是一个 Cache 实例。有关详细信息,请参阅我们的 kv 缓存指南

    包含预计算的隐藏状态(自注意力块中的键和值),可用于(参见 past_key_values 输入)加速顺序解码。

  • hidden_states (tuple(torch.FloatTensor), 可选, 当传入 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 元组(一个用于嵌入层输出,如果模型有嵌入层,+ 每个层输出一个),形状为 (batch_size, sequence_length, hidden_size)

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor), 可选, 当传入 output_attentions=Trueconfig.output_attentions=True 时返回) — torch.FloatTensor 元组(每个层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

MllamaModel 的 forward 方法,覆盖了 __call__ 特殊方法。

尽管前向传播的实现必须在此函数中定义,但在此之后应该调用 Module 实例,而不是直接调用此函数,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。

MllamaForCausalLM

class transformers.MllamaForCausalLM

< >

( config )

参数

  • config (MllamaForCausalLM) — 模型的配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。要加载模型权重,请查看from_pretrained()方法。

带有语言建模头的Mllama文本模型。

此模型继承自 PreTrainedModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等)。

此模型也是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用,并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None cross_attention_states: typing.Optional[torch.LongTensor] = None cross_attention_mask: typing.Optional[torch.LongTensor] = None full_text_row_masked_out_mask: typing.Optional[tuple[torch.Tensor, torch.Tensor]] = 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.mllama.modeling_mllama.KwargsForCausalLM] ) transformers.modeling_outputs.CausalLMOutputWithPast or tuple(torch.FloatTensor)

参数

  • input_ids (形状为(batch_size, sequence_length)torch.LongTensor可选) — 词汇表中输入序列标记的索引。默认情况下会忽略填充。

    可以使用AutoTokenizer获取索引。有关详细信息,请参阅PreTrainedTokenizer.encode()PreTrainedTokenizer.call()

    什么是输入ID?

  • attention_mask (形状为(batch_size, sequence_length)torch.Tensor可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值在[0, 1]中选择:

    • 1表示未被掩码的标记,
    • 0表示被掩码的标记。

    什么是注意力掩码?

  • position_ids (形状为(batch_size, sequence_length)torch.LongTensor可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.n_positions - 1]

    什么是位置ID?

  • cross_attention_states (torch.FloatTensor, 可选) — 视觉模型的输出,用于交叉注意力。此张量包含语言模型将关注的已处理图像特征。
  • cross_attention_mask (形状为(batch_size, seq_length, max_num_images, max_num_tiles)torch.Tensor可选) — 交叉注意力掩码,用于控制文本标记和图像块之间的交互。此4D张量定义了每个文本标记应关注哪些图像块。

    对于每个文本标记(在seq_length中):

    • 1表示标记应关注对应的图像块
    • 0表示标记不应关注对应的图像块
  • full_text_row_masked_out_mask (tuple[torch.Tensor, torch.Tensor]可选) — 包含两个张量的元组,用于掩盖交叉注意力机制中的行:

    • 第一个张量的形状为(batch_size, 1, seq_length, 1),包含0或1的值。值为0表示对应的文本标记在交叉注意力矩阵中的整行应被掩盖(所有图像标记被忽略)。
    • 第二个张量具有相同的形状,并在交叉注意力层的正向传播期间内部用于应用掩码。此掩码派生自cross_attention_mask,用于处理文本标记不应关注任何图像标记的情况。
  • past_key_values (Union[~cache_utils.Cache, list[torch.FloatTensor], NoneType]) — 预先计算的隐藏状态(自注意力块和交叉注意力块中的键和值),可用于加速顺序解码。这通常包括模型在解码前期返回的past_key_values,当use_cache=Trueconfig.use_cache=True时。

    允许两种格式:

    • 一个Cache实例,请参阅我们的kv缓存指南
    • 长度为config.n_layerstuple(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 (形状为(batch_size, sequence_length, hidden_size)torch.FloatTensor可选) — 可选地,您可以选择直接传入嵌入表示而不是传入input_ids。如果您希望对如何将input_ids索引转换为关联向量有比模型内部嵌入查找矩阵更多的控制,这将非常有用。
  • labels (形状为(batch_size, sequence_length)torch.LongTensor可选) — 用于计算掩码语言建模损失的标签。索引应在[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 (形状为(sequence_length)torch.LongTensor可选) — 描述输入序列标记在序列中位置的索引。与position_ids不同,此张量不受填充影响。它用于在正确位置更新缓存并推断完整的序列长度。
  • logits_to_keep (Union[int, torch.Tensor],默认为0) — 如果是int,则计算最后logits_to_keep个标记的logits。如果是0,则计算所有input_ids的logits(特殊情况)。生成时只需要最后一个标记的logits,仅为该标记计算可以节省内存,这对于长序列或大词汇量来说非常显著。如果是torch.Tensor,必须是与序列长度维度中要保留的索引相对应的1D张量。这在使用打包张量格式(批处理和序列长度的单一维度)时非常有用。

返回

transformers.modeling_outputs.CausalLMOutputWithPasttuple(torch.FloatTensor)

一个 transformers.modeling_outputs.CausalLMOutputWithPasttorch.FloatTensor 元组(如果传入 return_dict=Falseconfig.return_dict=False),包含根据配置 (MllamaConfig) 和输入的不同元素。

  • loss (torch.FloatTensor 形状为 (1,)可选,当提供 labels 时返回) — 语言建模损失(用于下一个 token 预测)。

  • logits (形状为 (batch_size, sequence_length, config.vocab_size)torch.FloatTensor) — 语言建模头部的预测分数(SoftMax 之前的每个词汇标记的分数)。

  • past_key_values (Cache, 可选, 当传入 use_cache=Trueconfig.use_cache=True 时返回) — 这是一个 Cache 实例。有关详细信息,请参阅我们的 kv 缓存指南

    包含预计算的隐藏状态(自注意力块中的键和值),可用于(参见 past_key_values 输入)加速顺序解码。

  • hidden_states (tuple(torch.FloatTensor), 可选, 当传入 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 元组(一个用于嵌入层输出,如果模型有嵌入层,+ 每个层输出一个),形状为 (batch_size, sequence_length, hidden_size)

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor), 可选, 当传入 output_attentions=Trueconfig.output_attentions=True 时返回) — torch.FloatTensor 元组(每个层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

Mllama Text Model 的正向传播方法,覆盖了__call__特殊方法。

尽管前向传播的实现必须在此函数中定义,但在此之后应该调用 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 one

MllamaVisionModel

transformers.MllamaVisionModel

< >

( config: MllamaVisionConfig )

参数

  • config (MllamaVisionConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不加载与模型关联的权重,仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

Mllama 视觉模型由两个视觉编码器组成。

此模型继承自 PreTrainedModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、修剪头部等)。

此模型也是 PyTorch torch.nn.Module 子类。将其作为常规 PyTorch 模块使用,并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。

forward

< >

( 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.BaseModelOutputtuple(torch.FloatTensor)

参数

  • pixel_values (torch.Tensor,形状为 (batch_size, num_channels, image_size, image_size)) — 与输入图像对应的张量。可以使用 {image_processor_class} 获取像素值。有关详细信息,请参阅 {image_processor_class}.__call__{processor_class} 使用 {image_processor_class} 处理图像)。
  • 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。

  • aspect_ratio_mask (torch.Tensor,形状为 (batch_size, max_num_images, max_num_tiles)可选) — 用于避免对填充瓦片执行注意力操作的掩码。掩码值选择范围为 [0, 1]

    • 1 表示**未被掩码**的瓦片,
    • 0 表示**被掩码**的瓦片。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是纯元组。

返回

transformers.modeling_outputs.BaseModelOutputtuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutput 或一个 torch.FloatTensor 元组(如果传递了 return_dict=Falseconfig.return_dict=False),包含根据配置 (MllamaConfig) 和输入而变化的各种元素。

  • last_hidden_state (torch.FloatTensor, 形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层输出的隐藏状态序列。

  • hidden_states (tuple(torch.FloatTensor), 可选, 当传入 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 元组(一个用于嵌入层输出,如果模型有嵌入层,+ 每个层输出一个),形状为 (batch_size, sequence_length, hidden_size)

    模型在每个层输出的隐藏状态以及可选的初始嵌入输出。

  • attentions (tuple(torch.FloatTensor), 可选, 当传入 output_attentions=Trueconfig.output_attentions=True 时返回) — torch.FloatTensor 元组(每个层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。

MllamaVisionModel 的 forward 方法,覆盖了 __call__ 特殊方法。

尽管前向传播的实现必须在此函数中定义,但在此之后应该调用 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])
< > 在 GitHub 上更新