Transformers 文档

Mllama

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

Mllama

概述

Llama 3.2-Vision 多模态大型语言模型 (LLM) 系列是预训练和指令微调的图像推理生成模型集合,包含 11B 和 90B 两种尺寸(文本 + 图像输入 / 文本输出)。Llama 3.2-Vision 指令微调模型针对视觉识别、图像推理、图像描述以及回答关于图像的通用问题进行了优化。

模型架构: Llama 3.2-Vision 是基于 Llama 3.1 纯文本模型构建的,后者是一个自回归语言模型,它使用了优化的 Transformer 架构。 调优版本使用了监督微调 (SFT) 和基于人类反馈的强化学习 (RLHF),以符合人类对 helpfulness(乐于助人)和 safety(安全)的偏好。 为了支持图像识别任务,Llama 3.2-Vision 模型使用了一个单独训练的视觉适配器,该适配器与预训练的 Llama 3.1 语言模型集成。 该适配器由一系列交叉注意力层组成,这些层将图像编码器表示馈送到核心 LLM 中。

使用技巧

  • 对于图像+文本和文本输入,请使用 MllamaForConditionalGeneration
  • 对于纯文本输入,请使用 MllamaForCausalLM 进行生成,以避免加载视觉塔。
  • 每个样本可以包含多张图像,并且样本之间的图像数量可以不同。 处理器会将输入填充到跨样本的最大图像数量以及每个图像内的最大瓦片数量。
  • 传递给处理器的文本应包含 "<|image|>" 标记,图像应插入在这些标记的位置。
  • 处理器有其自己的 apply_chat_template 方法,用于将聊天消息转换为可以作为文本传递给处理器的格式。

使用示例

Instruct 模型

import requests
import torch
from PIL import Image
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"},
                {"type": "text", "text": "What does the image show?"}
            ]
        }
    ],
]
text = processor.apply_chat_template(messages, add_generation_prompt=True)

url = "https://llava-vl.github.io/static/images/view.jpg"
image = Image.open(requests.get(url, stream=True).raw)

inputs = processor(text=text, images=image, 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) — 用于编码图像提示的图像 token 索引。

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

参数

  • image_processor (MllamaImageProcessor) — 图像处理器是必需的输入。
  • tokenizer ([PreTrainedTokenizer, PreTrainedTokenizerFast]) — 分词器是必需的输入。

构建一个 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"},
)

batch_decode

< >

( *args **kwargs )

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

decode

< >

( *args **kwargs )

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

MllamaImageProcessor

class transformers.MllamaImageProcessor

< >

( do_convert_rgb: bool = True do_resize: bool = True size: Optional = None resample: Resampling = <Resampling.BILINEAR: 2> do_rescale: bool = True rescale_factor: float = 0.00392156862745098 do_normalize: bool = True image_mean: Union = None image_std: Union = 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 (floatList[float], 可选, 默认为 self.image_mean) — 用于归一化的图像均值。 仅当 do_normalize 设置为 True 时才有效。
  • image_std (floatList[float], 可选, 默认为 self.image_std) — 用于归一化的图像标准差。 仅当 do_normalize 设置为 True 时才有效。
  • do_pad (bool, optional, defaults to True) — 是否将图像填充到批次中最大的高度和宽度。
  • max_image_tiles (int, optional, defaults to 4) — 将图像分割成的最大图块数。

构建 Mllama 图像处理器。

pad

< >

( image: ndarray size: Dict aspect_ratio: Tuple data_format: Union = None input_data_format: Union = None ) np.ndarray

参数

  • image (np.ndarray) — 要调整大小的图像。
  • size (Dict[str, int]) — 输出图像的大小。
  • aspect_ratio (Tuple[int, int]) — 图像的纵横比。
  • data_format (str or ChannelDimension, optional) — 图像的通道维度格式。如果未提供,则与输入图像相同。
  • input_data_format (ChannelDimension or str, optional) — 输入图像的通道维度格式。如果未提供,则将进行推断。

返回值

np.ndarray

填充后的图像。

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

preprocess

< >

( images: Union do_convert_rgb: Optional = None do_resize: Optional = None size: Optional = None resample: Optional = None do_rescale: Optional = None rescale_factor: Optional = None do_normalize: Optional = None image_mean: Union = None image_std: Union = None do_pad: Optional = None max_image_tiles: Optional = None input_data_format: Union = None return_tensors: Union = None ) BatchFeature of the following structure

参数

  • images (ImageInput) — 要预处理的图像列表。
  • do_convert_rgb (bool, optional, defaults to self.do_convert_rgb) — 是否将图像转换为 RGB 格式。
  • do_resize (bool, optional, defaults to self.do_resize) — 是否调整图像大小。
  • size (Dict[str, int], optional, defaults to self.size) — 图像图块的大小。应为包含 ‘height’ 和 ‘width’ 键的字典,两者都具有整数值。高度和宽度值应相等。
  • resample (int, optional, defaults to self.resample) — 如果调整图像大小,则使用的重采样滤波器。可以是枚举 PILImageResampling 之一。仅在 do_resize 设置为 True 时有效。
  • do_rescale (bool, optional, defaults to self.do_rescale) — 是否缩放图像。
  • rescale_factor (float, optional, defaults to self.rescale_factor) — 如果 do_rescale 设置为 True,则用于缩放图像的缩放因子。
  • do_normalize (bool, optional, defaults to self.do_normalize) — 是否标准化图像。
  • image_mean (float or List[float], optional, defaults to self.image_mean) — 用于标准化的图像均值。仅在 do_normalize 设置为 True 时有效。
  • image_std (float or List[float], optional, defaults to self.image_std) — 用于标准化的图像标准差。仅在 do_normalize 设置为 True 时有效。
  • do_pad (bool, optional, defaults to self.do_pad) — 是否将图像填充到批次中最大的高度和宽度。
  • max_image_tiles (int, optional, defaults to self.max_image_tiles) — 将图像分割成的最大图块数。
  • input_data_format (ChannelDimension or str, optional) — 输入图像的通道维度格式。如果未设置,则从输入图像推断通道维度格式。可以是以下之一:
    • "channels_first"ChannelDimension.FIRST:图像格式为 (num_channels, height, width)。
    • "channels_last"ChannelDimension.LAST:图像格式为 (height, width, num_channels)。
    • "none"ChannelDimension.NONE:图像格式为 (height, width)。
  • return_tensors (str or TensorType, optional) — 返回张量的类型。可以是以下之一:
    • 未设置:返回 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: Union = None input_data_format: Union = 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: Optional = None pixel_values: Optional = None aspect_ratio_mask: Optional = None aspect_ratio_ids: Optional = None attention_mask: Optional = None cross_attention_mask: Optional = None cross_attention_states: Optional = None position_ids: Optional = None past_key_values: Optional = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None cache_position: Optional = None num_logits_to_keep: int = 0 ) transformers.modeling_outputs.CausalLMOutputWithPasttuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID?

  • pixel_values (形状为 (batch_size, max_num_images, max_num_tiles, channels, image_size, image_size)torch.FloatTensor) -- 与输入图像对应的张量。像素值可以使用 [AutoImageProcessor](/docs/transformers/v4.45.2/en/model_doc/auto#transformers.AutoImageProcessor) 获取。有关详细信息,请参阅 [MllamaImageProcessor.__call__()](/docs/transformers/v4.45.2/en/model_doc/videomae#transformers.VideoMAEFeatureExtractor.__call__) ([MllamaProcessor] 使用 MllamaImageProcessor 处理图像)。
  • aspect_ratio_mask (形状为 (batch_size, max_num_images, max_num_tiles)torch.Tensor, 可选) — 用于避免对填充瓦片执行注意力的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示未掩码的瓦片,
    • 0 表示已掩码的瓦片。
  • aspect_ratio_ids (形状为 (batch_size, max_num_images)torch.Tensor, 可选) — 纵横比 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 (形状为 (batch_size, sequence_length)torch.Tensor, 可选) — 用于避免对填充标记索引执行注意力的掩码。掩码值在 [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 (形状为 (batch_size, seq_length, max_num_images, max_num_tiles)torch.Tensor, 可选) — 交叉注意力掩码,用于控制文本标记和图像瓦片之间的交互。此 4D 张量定义了每个文本标记应关注哪些图像瓦片。

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

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

    什么是位置 ID?

  • past_key_values (Cachetuple(tuple(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,用户可以选择仅输入最后一次的 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 相反,此张量不受填充的影响。它用于在正确的位置更新缓存并推断完整的序列长度。

    Args — labels (形状为 (batch_size, sequence_length)torch.LongTensor, 可选): 用于计算掩码语言建模损失的标签。索引应为 [0, ..., config.vocab_size] 或 -100(请参阅 input_ids 文档字符串)。索引设置为 -100 的标记将被忽略(掩码),损失仅针对标签在 [0, ..., config.vocab_size] 中的标记计算。

    num_logits_to_keep (int, 可选): 计算最后 num_logits_to_keep 个标记的 logits。如果为 0,则计算所有 input_ids 的 logits(特殊情况)。只有最后一个标记 logits 是生成所需的,并且仅为该标记计算它们可以节省内存,这对于长序列或大词汇量来说变得非常重要。

返回值

transformers.modeling_outputs.CausalLMOutputWithPasttuple(torch.FloatTensor)

一个 transformers.modeling_outputs.CausalLMOutputWithPast 或一个 torch.FloatTensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包括各种元素,具体取决于配置 (MllamaConfig) 和输入。

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

  • 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_layerstuple(torch.FloatTensor) 元组,每个元组包含 2 个形状为 (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 之后的注意力权重,用于计算自注意力头中的加权平均值。

MllamaForConditionalGeneration 前向方法,覆盖了 __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 (MllamaConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看 from_pretrained() 方法以加载模型权重。

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

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

forward

< >

( input_ids: LongTensor = None attention_mask: Optional = None position_ids: Optional = None cross_attention_states: Optional = None cross_attention_mask: Optional = None full_text_row_masked_out_mask: Optional = None past_key_values: Union = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None cache_position: Optional = None num_logits_to_keep: int = 0 ) transformers.modeling_outputs.CausalLMOutputWithPasttuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID?

  • pixel_values (形状为 (batch_size, max_num_images, max_num_tiles, channels, image_size, image_size)) 的 `torch.FloatTensor` -- 与输入图像对应的张量。像素值可以使用 [AutoImageProcessor](/docs/transformers/v4.45.2/en/model_doc/auto#transformers.AutoImageProcessor) 获取。有关详细信息,请参阅 [MllamaImageProcessor.__call__()](/docs/transformers/v4.45.2/en/model_doc/videomae#transformers.VideoMAEFeatureExtractor.__call__) ([]MllamaProcessor`] 使用 MllamaImageProcessor 处理图像)。
  • aspect_ratio_mask (形状为 (batch_size, max_num_images, max_num_tiles)torch.Tensor, 可选) — 用于避免对填充图块执行注意力的掩码。在 [0, 1] 中选择的掩码值:

    • 1 表示未掩码的图块,
    • 0 表示已掩码的图块。
  • aspect_ratio_ids (形状为 (batch_size, max_num_images)torch.Tensor, 可选) — 纵横比 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 (形状为 (batch_size, sequence_length)torch.Tensor, 可选) — 用于避免对填充标记索引执行注意力的掩码。在 [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 (形状为 (batch_size, seq_length, max_num_images, max_num_tiles)torch.Tensor, 可选) — 交叉注意力掩码,用于控制文本标记和图像图块之间的交互。 此 4D 张量定义了每个文本标记应关注哪些图像图块。

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

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

    什么是位置 ID?

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

    允许两种格式:

    • Cache 实例,请参阅我们的 kv 缓存指南
    • 长度为 config.n_layerstuple(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), 可选) — 索引,描述输入序列标记在序列中的位置。与 position_ids 相反,此张量不受填充的影响。它用于在正确的位置更新缓存并推断完整的序列长度。

    Args — labels (torch.LongTensor,形状为 (batch_size, sequence_length), 可选): 用于计算掩码语言建模损失的标签。索引应在 [0, ..., config.vocab_size] 或 -100 中(请参阅 input_ids 文档字符串)。索引设置为 -100 的标记将被忽略(掩码),损失仅针对标签在 [0, ..., config.vocab_size] 中的标记计算。

    num_logits_to_keep (int, 可选): 计算最后 num_logits_to_keep 个标记的 logits。如果为 0,则计算所有 input_ids 的 logits(特殊情况)。生成只需要最后一个标记 logits,并且仅针对该标记计算它们可以节省内存,这对于长序列或大型词汇表大小而言变得非常重要。

返回值

transformers.modeling_outputs.CausalLMOutputWithPasttuple(torch.FloatTensor)

一个 transformers.modeling_outputs.CausalLMOutputWithPasttorch.FloatTensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),其中包含各种元素,具体取决于配置 (MllamaTextConfig) 和输入。

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

  • 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_layerstuple(torch.FloatTensor) 元组,每个元组包含 2 个形状为 (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 之后的注意力权重,用于计算自注意力头中的加权平均值。

MllamaForCausalLM 前向方法,覆盖了 __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 (MllamaConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看 from_pretrained() 方法以加载模型权重。

Mllama 文本模型,由具有自注意力和交叉注意力层的 transformer 组成。此模型继承自 PreTrainedModel。查看超类文档,了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝头等)。

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

forward

< >

( input_ids: Optional = None attention_mask: Optional = None position_ids: Optional = None cross_attention_states: Optional = None cross_attention_mask: Optional = None full_text_row_masked_out_mask: Optional = None past_key_values: Union = None inputs_embeds: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None cache_position: Optional = None ) transformers.modeling_outputs.BaseModelOutputWithPasttuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID?

  • 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] 中选择。

    什么是位置 ID?

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

    允许两种格式:

    • Cache 实例,请参阅我们的 kv 缓存指南
    • 长度为 config.n_layerstuple(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, optional) — 是否返回 ModelOutput 而不是纯粹的元组。
  • cache_position (torch.LongTensor,形状为 (sequence_length)可选) — 索引描述输入序列 tokens 在序列中的位置。与 position_ids 相反,此张量不受 padding 的影响。它用于在正确的位置更新缓存,并推断完整的序列长度。

返回值

transformers.modeling_outputs.BaseModelOutputWithPasttuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPasttorch.FloatTensor 的元组 (如果传递了 return_dict=False 或者当 config.return_dict=False 时),包含各种元素,具体取决于配置 (MllamaTextConfig) 和输入。

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

    如果使用了 past_key_values,则仅输出形状为 (batch_size, 1, hidden_size) 的序列的最后一个隐藏状态。

  • past_key_values (tuple(tuple(torch.FloatTensor)), 可选,当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layerstuple(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 元组(如果模型具有嵌入层,则为嵌入输出之一;+ 每个层的输出之一),形状为 (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 之后的注意力权重,用于计算自注意力头中的加权平均值。

MllamaTextModel forward 方法,覆盖了 __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])

MllamaForCausalLM

class transformers.MllamaForCausalLM

< >

( config )

参数

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

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

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

forward

< >

( input_ids: LongTensor = None attention_mask: Optional = None position_ids: Optional = None cross_attention_states: Optional = None cross_attention_mask: Optional = None full_text_row_masked_out_mask: Optional = None past_key_values: Union = None inputs_embeds: Optional = None labels: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None cache_position: Optional = None num_logits_to_keep: int = 0 ) transformers.modeling_outputs.CausalLMOutputWithPasttuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID?

  • pixel_values (形状为 (batch_size, max_num_images, max_num_tiles, channels, image_size, image_size)) 的 `torch.FloatTensor` -- 与输入图像对应的张量。像素值可以使用 [AutoImageProcessor](/docs/transformers/v4.45.2/en/model_doc/auto#transformers.AutoImageProcessor) 获取。有关详细信息,请参阅 [MllamaImageProcessor.__call__()](/docs/transformers/v4.45.2/en/model_doc/videomae#transformers.VideoMAEFeatureExtractor.__call__) ([]MllamaProcessor`] 使用 MllamaImageProcessor 处理图像)。
  • aspect_ratio_mask (形状为 (batch_size, max_num_images, max_num_tiles)torch.Tensor, 可选) — 用于避免对填充图块执行注意力的掩码。在 [0, 1] 中选择的掩码值:

    • 1 表示未掩码的图块,
    • 0 表示已掩码的图块。
  • aspect_ratio_ids (形状为 (batch_size, max_num_images)torch.Tensor, 可选) — 纵横比 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 (形状为 (batch_size, sequence_length)torch.Tensor, 可选) — 用于避免对填充标记索引执行注意力的掩码。在 [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 (形状为 (batch_size, seq_length, max_num_images, max_num_tiles)torch.Tensor, 可选) — 交叉注意力掩码,用于控制文本标记和图像图块之间的交互。 此 4D 张量定义了每个文本标记应关注哪些图像图块。

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

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

    什么是位置 ID?

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

    允许两种格式:

    • Cache 实例,请参阅我们的 kv 缓存指南
    • 长度为 config.n_layerstuple(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), 可选) — 索引,描述输入序列标记在序列中的位置。与 position_ids 相反,此张量不受填充的影响。它用于在正确的位置更新缓存并推断完整的序列长度。

    Args — labels (torch.LongTensor,形状为 (batch_size, sequence_length), 可选): 用于计算掩码语言建模损失的标签。索引应在 [0, ..., config.vocab_size] 或 -100 中(请参阅 input_ids 文档字符串)。索引设置为 -100 的标记将被忽略(掩码),损失仅针对标签在 [0, ..., config.vocab_size] 中的标记计算。

    num_logits_to_keep (int, 可选): 计算最后 num_logits_to_keep 个标记的 logits。如果为 0,则计算所有 input_ids 的 logits(特殊情况)。生成只需要最后一个标记 logits,并且仅针对该标记计算它们可以节省内存,这对于长序列或大型词汇表大小而言变得非常重要。

返回值

transformers.modeling_outputs.CausalLMOutputWithPasttuple(torch.FloatTensor)

一个 transformers.modeling_outputs.CausalLMOutputWithPasttorch.FloatTensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),其中包含各种元素,具体取决于配置 (MllamaTextConfig) 和输入。

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

  • 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_layerstuple(torch.FloatTensor) 元组,每个元组包含 2 个形状为 (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 之后的注意力权重,用于计算自注意力头中的加权平均值。

MllamaForCausalLM 前向方法,覆盖了 __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

class transformers.MllamaVisionModel

< >

( config: MllamaVisionConfig )

参数

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

Mllama Vision Model 由两个视觉编码器组成。此模型继承自 PreTrainedModel。查看超类文档以获取库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝头等)。

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

forward

< >

( pixel_values: Tensor aspect_ratio_ids: Tensor aspect_ratio_mask: Tensor output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) transformers.modeling_outputs.BaseModelOutputtuple(torch.FloatTensor)

参数

  • pixel_values (torch.FloatTensor,形状为 (batch_size, max_num_images, max_num_tiles, channels, image_size, image_size)) -- 对应于输入图像的张量。像素值可以使用 [AutoImageProcessor](/docs/transformers/v4.45.2/en/model_doc/auto#transformers.AutoImageProcessor) 获得。有关详细信息,请参阅 [MllamaImageProcessor.__call__()](/docs/transformers/v4.45.2/en/model_doc/videomae#transformers.VideoMAEFeatureExtractor.__call__) ([MllamaProcessor](/docs/transformers/model_doc/mllama#transformers.MllamaProcessor) 使用 MllamaImageProcessor 处理图像)。
  • aspect_ratio_mask (torch.Tensor,形状为 (batch_size, max_num_images, max_num_tiles), 可选) — 用于避免对 padding tiles 执行注意力的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示 未掩码 的 tiles,
    • 0 表示 已掩码 的 tiles。
  • aspect_ratio_ids (torch.Tensor,形状为 (batch_size, max_num_images), 可选) — 宽高比 ID,用于根据每个输入图像的宽高比选择适当的预计算 tile embeddings。这些 ID 对应于模型支持的宽高比列表中的索引,偏移量为 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。

  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息,请参见返回张量下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参见返回张量下的 hidden_states
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是纯粹的元组。

返回值

transformers.modeling_outputs.BaseModelOutputtuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputtorch.FloatTensor 的元组 (如果传递了 return_dict=False 或者当 config.return_dict=False 时),包含各种元素,具体取决于配置 (MllamaVisionConfig) 和输入。

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

  • 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 之后的注意力权重,用于计算自注意力头中的加权平均值。

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 上更新