Hugging Face's logo

Transformers documentation

Molmo2

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.2).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

该模型于 2026-01-15 在 HF papers 上发布，并于 2026-10-08 贡献至 Hugging Face Transformers。

FlashAttention SDPA

Molmo2

Molmo2 是 AllenAI 推出的一系列开放权重视觉语言模型，在开源模型中处于最先进水平，在单图像、多图像和视频任务的点驱动定位方面具有卓越能力。该架构将用于图像处理的 Vision Transformer (ViT) 与连接视觉和文本模态的适配器层相结合，并采用基于 transformer 架构且带有旋转位置嵌入的文本解码器。

该论文的摘要如下：

目前最强大的视频语言模型（VLM）仍为专有模型。最强的开放权重模型要么依赖来自专有 VLM 的合成数据（实质上是从其进行蒸馏），要么未公开其训练数据或训练配方。因此，开源社区缺乏改进当前最先进视频（及图像）语言模型所需的基础。关键在于，许多下游应用不仅需要高层级的视频理解，还需要定位能力——即通过指向或像素级跟踪来实现。即使是专有模型也缺乏这种能力。我们提出了 Molmo2，这是一个新的 VLM 系列，在开源模型中达到了最先进水平，并在单图像、多图像和视频任务中展示了卓越的、由指向驱动的定位新能力。我们的核心贡献是收集了 7 个新的视频数据集和 2 个多图像数据集，包括用于预训练的高度详细视频字幕数据集、用于微调的自由形式视频问答数据集、一个包含复杂查询的新目标跟踪数据集，以及一个创新的视频指向数据集，所有数据均在未使用闭源 VLM 的情况下收集。我们还提出了针对这些数据的训练配方，采用了高效的打包和消息树编码方案，并展示了在视觉 token 上使用双向注意力以及一种新颖的 token 加权策略能够提升性能。我们同类最佳的 8B 模型在短视频、计数和字幕生成方面优于其他开放权重和数据模型，并在长视频任务上具有竞争力。在视频定位方面，Molmo2 显著优于 Qwen3-VL 等现有开放权重模型（视频计数准确率为 35.5，对比 29.6），并在某些任务上超越了 Gemini 3 Pro 等专有模型（视频指向 F1 为 38.4，对比 20.0；视频跟踪 J&F 为 56.2，对比 41.1）。

您可以在 Molmo2 集合中找到所有原始的 Molmo2 检查点。

使用示例

图像文本到文本生成

以下示例演示了如何使用 Pipeline 或 AutoModel 类基于图像生成文本。

Pipeline
AutoModel
from transformers import pipeline

pipeline = pipeline(
    task="image-text-to-text",
    model="allenai/Molmo2-8B",
    device_map="auto",
)

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/pipeline-cat-chonk.jpeg"},
            {"type": "text", "text": "Describe this image."},
        ],
    }
]
pipeline(text=messages, max_new_tokens=128, return_full_text=False)

视频指向

Molmo2 还可以为视频输入生成带定位的坐标点。这些坐标点以 <points coords="..."> 负载的形式包含在生成的文本中，其中每个坐标组包含一个时间戳，随后是点 ID 和归一化图像坐标。

import torch

from transformers import AutoModelForImageTextToText, AutoProcessor


model_id = "allenai/Molmo2-8B"
video_url = "https://storage.googleapis.com/oe-training-public/demo_videos/many_penguins.mp4"

processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForImageTextToText.from_pretrained(model_id, device_map="auto")

messages = [
    {
        "role": "user",
        "content": [
            {"type": "text", "text": "Point to the penguins."},
            {"type": "video", "video": video_url},
        ],
    }
]
inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    add_generation_prompt=True,
    return_tensors="pt",
    return_dict=True,
)

generated_ids = model.generate(**inputs, max_new_tokens=128, do_sample=False)

input_len = inputs["input_ids"].shape[1]
generated_text = processor.decode(generated_ids[0][input_len:], skip_special_tokens=True)
print(generated_text)

Molmo2Config

class transformers.Molmo2Config

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneadapter_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneimage_start_token_id: int = 151936low_res_image_start_token_id: int = 151940image_end_token_id: int = 151937image_patch_id: int = 151938frame_start_token_id: int = 151943frame_end_token_id: int = 151944initializer_range: float = 0.02tie_word_embeddings: bool = False )

参数

  • vision_config (Molmo2VisionConfig，可选) — 视觉 Transformer 骨干网络的配置。
  • adapter_config (Molmo2AdapterConfig，可选) — 视觉到语言适配器的配置。
  • text_config (Union[dict, ~configuration_utils.PreTrainedConfig]，可选) — 文本骨干网络的配置对象或字典。
  • image_start_token_id (int，可选，默认为 151936) — 标记图像区域起始位置的 Token ID。
  • low_res_image_start_token_id (int，可选，默认值为 151940) — 标记低分辨率图像裁剪起始位置的 Token ID。
  • image_end_token_id (int，可选，默认为 151937) — 标记图像区域结束的 Token ID。
  • image_patch_id (int，可选，默认为 151938) — 图像块的 Token ID。
  • frame_start_token_id (int，可选，默认为 151943) — 标记视频帧起始位置的 Token ID。
  • frame_end_token_id (int，可选，默认为 151944) — 标记视频帧结束的 Token ID。
  • initializer_range (float，可选，默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • tie_word_embeddings (bool，可选，默认为 False) — 是否应绑定模型的输入和输出词嵌入。

这是用于存储 Molmo2Model 配置的类。它根据指定的参数实例化 Molmo2 模型，并定义模型架构。使用默认值实例化配置将得到与 allenai/Molmo2-8B 类似的配置。

配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。

Molmo2VisionConfig

class transformers.Molmo2VisionConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 1152intermediate_size: int = 4304num_hidden_layers: int = 25num_attention_heads: int = 16num_key_value_heads: int = 16head_dim: int = 72hidden_act: str = 'gelu_pytorch_tanh'layer_norm_eps: float = 1e-06image_size: list[int] | None = Nonepatch_size: int = 14num_position_embeddings: int | None = Nonenum_channels: int = 3attention_dropout: float = 0.0attention_bias: bool = Trueinitializer_range: float = 0.02 )

参数

  • hidden_size (int，可选，默认为 1152) — 隐藏表示的维度。
  • intermediate_size (int，可选，默认为 4304) — MLP 表示的维度。
  • num_hidden_layers (int，可选，默认为 25) — Transformer 解码器中的隐藏层数量。
  • num_attention_heads (int，可选，默认为 16) — Transformer 解码器中每个注意力层的注意力头数量。
  • num_key_value_heads (int, 可选，默认为 16) — 这是用于实现 Grouped Query Attention 的 key_value 头数。如果 num_key_value_heads=num_attention_heads，模型将使用 Multi Head Attention (MHA)；如果 num_key_value_heads=1，模型将使用 Multi Query Attention (MQA)；否则将使用 GQA。在将多头检查点转换为 GQA 检查点时，每个组的 key 和 value 头应通过对该组内所有原始头进行平均池化来构建。更多详情请参阅 这篇论文。如果未指定，则默认为 num_attention_heads。
  • head_dim (int，可选，默认为 72) — 注意力头维度。如果为 None，则默认为 hidden_size // num_attention_heads
  • hidden_act (str，可选，默认为 gelu_pytorch_tanh) — 解码器中的非线性激活函数（函数或字符串）。例如，"gelu"、 "relu"、"silu" 等。
  • layer_norm_eps (float，可选，默认为 1e-06) — 层归一化层所使用的 epsilon 值。
  • image_size (list[int]，可选) — 输入图像尺寸，格式为 (height, width)，未提供时默认为 [378, 378]。
  • patch_size (int，可选，默认为 14) — 每个 patch 的大小（分辨率）。
  • num_position_embeddings (int, 可选) — 位置嵌入的数量，每个图像块对应一个。如果未提供，则根据 image_size 和 patch_size 推导得出。
  • num_channels (int，可选，默认为 3) — 输入通道的数量。
  • attention_dropout (float，可选，默认为 0.0) — 注意力概率的 dropout 比率。
  • attention_bias (bool，可选，默认为 True) — 在自注意力机制中，是否在查询、键、值以及输出投影层中使用偏置。
  • initializer_range (float，可选，默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。

这是用于存储 Molmo2Model 配置的类。它根据指定的参数实例化 Molmo2 模型，并定义模型架构。使用默认值实例化配置将得到与 allenai/Molmo2-8B 类似的配置。

配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。

Molmo2AdapterConfig

class transformers.Molmo2AdapterConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevision_feature_layer: list[int] | None = Nonehidden_size: int = 1152num_attention_heads: int = 16num_key_value_heads: int = 16head_dim: int = 72attention_dropout: float = 0.0attention_bias: bool = Truehidden_act: str = 'silu'intermediate_size: int = 18944text_hidden_size: int = 3584mlp_bias: bool = Falseinitializer_range: float = 0.02 )

参数

  • vision_feature_layer (list[int], 可选) — 用于拼接和池化的 ViT 层输出的索引，未提供时默认为 [24, 18]。负索引从最后一层开始计数。
  • hidden_size (int，可选，默认为 1152) — 隐藏表示的维度。
  • num_attention_heads (int，可选，默认为 16) — Transformer 解码器中每个注意力层的注意力头数量。
  • num_key_value_heads (int, 可选，默认为 16) — 这是用于实现 Grouped Query Attention 的 key_value 头数。如果 num_key_value_heads=num_attention_heads，模型将使用 Multi Head Attention (MHA)；如果 num_key_value_heads=1，模型将使用 Multi Query Attention (MQA)；否则将使用 GQA。在将多头检查点转换为 GQA 检查点时，每个组的 key 和 value 头应通过对该组内所有原始头进行平均池化来构建。更多详情请参阅 这篇论文。如果未指定，则默认为 num_attention_heads。
  • head_dim (int，可选，默认为 72) — 注意力头维度。如果为 None，则默认为 hidden_size // num_attention_heads
  • attention_dropout (float，可选，默认为 0.0) — 注意力概率的 dropout 比率。
  • attention_bias (bool，可选，默认为 True) — 在自注意力机制中，是否在查询、键、值以及输出投影层中使用偏置。
  • hidden_act (str，可选，默认为 silu) — 解码器中的非线性激活函数（函数或字符串）。例如，"gelu"、 "relu"、"silu" 等。
  • intermediate_size (int，可选，默认为 18944) — MLP 表示的维度。
  • text_hidden_size (int，可选，默认值为 3584) — 文本模型的隐藏层大小（用于投影）。
  • mlp_bias (bool，可选，默认为 False) — 是否在 MLP 层的 up_proj、down_proj 和 gate_proj 层中使用偏置。
  • initializer_range (float，可选，默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。

这是用于存储 Molmo2Model 配置的类。它根据指定的参数实例化 Molmo2 模型，并定义模型架构。使用默认值实例化配置将得到与 allenai/Molmo2-8B 类似的配置。

配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。

Molmo2TextConfig

class transformers.Molmo2TextConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 4096num_attention_heads: int = 32num_key_value_heads: int = 8head_dim: int = 128vocab_size: int = 151936additional_vocab_size: int = 128attention_bias: bool = Falseqk_norm_type: str = 'qwen3'num_hidden_layers: int = 36intermediate_size: int = 12288hidden_act: str = 'silu'attention_dropout: float = 0.0max_position_embeddings: int = 36864rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Nonerope_scaling_layers: list[int] | None = Nonerms_norm_eps: float = 1e-06norm_after: bool = Falseinitializer_range: float = 0.02use_cache: bool = Truetie_word_embeddings: bool = False )

参数

  • hidden_size (int，可选，默认为 4096) — 隐藏表示的维度。
  • num_attention_heads (int，可选，默认为 32) — Transformer 解码器中每个注意力层的注意力头数量。
  • num_key_value_heads (int, 可选，默认为 8) — 这是用于实现 Grouped Query Attention 的 key_value 头数。如果 num_key_value_heads=num_attention_heads，模型将使用 Multi Head Attention (MHA)；如果 num_key_value_heads=1，模型将使用 Multi Query Attention (MQA)；否则使用 GQA。在将多头检查点转换为 GQA 检查点时，每个组的 key 和 value 头应通过对该组内所有原始头进行 meanpooling 来构建。更多详情请参阅 这篇论文。如果未指定，则默认为 num_attention_heads。
  • head_dim (int，可选，默认为 128) — 注意力头维度。如果为 None，则默认为 hidden_size // num_attention_heads
  • vocab_size (int，可选，默认为 151936) — 模型的词汇表大小。定义了 input_ids 可以表示的不同 token 数量。
  • additional_vocab_size (int，可选，默认为 128) — 基础词汇表之外的额外词汇表 token 数量。
  • attention_bias (bool，可选，默认为 False) — 在自注意力机制中，是否在 query、key、value 和 output 投影层中使用偏置。
  • qk_norm_type (str, 可选，默认为 "qwen3") — 检查点所使用的查询/键归一化布局。"qwen3" 按头进行归一化；"olmo" 对完整的投影后的查询/键张量进行归一化。
  • num_hidden_layers (int，可选，默认为 36) — Transformer 解码器中的隐藏层数量。
  • intermediate_size (int，可选，默认为 12288) — MLP 表示的维度。
  • hidden_act (str，可选，默认为 silu) — 解码器中的非线性激活函数（函数或字符串）。例如，"gelu"、 "relu"、"silu" 等。
  • attention_dropout (float，可选，默认为 0.0) — 注意力概率的 dropout 比率。
  • max_position_embeddings (int，可选，默认为 36864) — 该模型可能使用的最大序列长度。
  • rope_parameters (Union[~modeling_rope_utils.RopeParameters, dict], 可选) — 包含 RoPE 嵌入配置参数的字典。该字典应包含 rope_theta 的值，并且如果希望使用 RoPE 处理更长的 max_position_embeddings，则可选地包含用于缩放的参数。
  • rope_scaling_layers (list[int], 可选) — 应用由 rope_parameters 描述的缩放 RoPE 的层索引。其余层使用具有相同 theta 的未缩放 RoPE。如果未提供，则所有层均进行缩放。
  • rms_norm_eps (float，可选，默认为 1e-06) — RMS 归一化层使用的 epsilon 值。
  • norm_after (bool，可选，默认为 False) — 是否在注意力/FFN 块之后（而非之前）应用层归一化。
  • initializer_range (float，可选，默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • use_cache (bool，可选，默认为 True) — 模型是否应返回最后一次键/值注意力（并非所有模型都使用）。仅当 config.is_decoder=True 或模型为仅解码器生成式模型时相关。
  • tie_word_embeddings (bool，可选，默认为 False) — 是否根据模型的 tied_weights_keys 映射来绑定权重嵌入。

这是用于存储 Molmo2Model 配置的类。它根据指定的参数实例化 Molmo2 模型，并定义模型架构。使用默认值实例化配置将得到与 allenai/Molmo2-8B 类似的配置。

配置对象继承自 PreTrainedConfig，可用于控制模型输出。有关更多信息，请参阅 PreTrainedConfig 的文档。

Molmo2Processor

class transformers.Molmo2Processor

< >

( image_processor = Nonevideo_processor = Nonetokenizer = Nonechat_template: str | None = Noneimage_use_col_tokens: bool | None = Trueuse_single_crop_col_tokens: bool | None = Noneuse_single_crop_start_token: bool | None = Truevideo_use_col_tokens: bool | None = Falseuse_frame_special_tokens: bool | None = True**kwargs )

参数

  • image_processor (Molmo2ImageProcessor) — 图像处理器是必需的输入。
  • video_processor (Molmo2VideoProcessor) — 视频处理器是必需的输入。
  • tokenizer (TokenizersBackend) — 分词器是必需的输入。
  • chat_template (str, 可选) — 一个 Jinja 模板，用于将聊天中的消息列表转换为可分词的字符串。
  • image_use_col_tokens（bool，可选，默认为 True）—— 是否在高分辨率图像视图的每个 patch 行之后追加列分隔符 token（<im_col>）。
  • use_single_crop_col_tokens (bool, 可选) — 是否在低分辨率（单裁剪）图像视图的每个 patch 行之后追加列分隔符 token。如果为 None，则回退到 image_use_col_tokens。
  • use_single_crop_start_token (bool，可选，默认为 True) — 是否使用 <low_res_im_start> 而非常规的 <im_start> 来开始低分辨率图像视图。
  • video_use_col_tokens (bool，可选，默认为 False) — 是否在每个视频帧的每个 patch 行之后追加列分隔符 token。
  • use_frame_special_tokens (bool，可选，默认为 True) — 是否使用 <frame_start> / <frame_end> 标记来包裹每个视频帧。如果为 False，则回退到 <im_start> / <im_end>。

构建一个 Molmo2Processor，它将图像处理器、视频处理器和分词器封装为单一处理器。

Molmo2Processor 提供了 Molmo2ImageProcessor、Molmo2VideoProcessor 和 TokenizersBackend 的所有功能。有关更多信息，请参阅 ~Molmo2ImageProcessor、~Molmo2VideoProcessor 和 ~TokenizersBackend。

__call__

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonetext: str | list[str] | list[list[str]] | None = Nonevideos: typing.Union[list['PIL.Image.Image'], numpy.ndarray, ForwardRef('torch.Tensor'), list[numpy.ndarray], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list[numpy.ndarray]], list[list['torch.Tensor']], transformers.video_utils.URL, list[transformers.video_utils.URL], list[list[transformers.video_utils.URL]], transformers.video_utils.Path, list[transformers.video_utils.Path], list[list[transformers.video_utils.Path]], NoneType] = None**kwargs: *<class 'transformers.models.molmo2.processing_molmo2.Molmo2ProcessorKwargs'> )

参数

  • images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], 可选) — 要预处理的图像。期望输入单张图像或一批图像，其像素值范围为 0 到 255。如果传入的图像像素值在 0 到 1 之间，请设置 do_rescale=False。
  • text (Union[str, list[str], list[list[str]]]，可选) — 要编码的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果传入预分词输入，请设置 is_split_into_words=True，以避免与批量输入产生歧义。
  • videos (Union[list[PIL.Image.Image], numpy.ndarray, torch.Tensor, list[numpy.ndarray], list[torch.Tensor], list[list[PIL.Image.Image]], list[list[numpy.ndarray]], list[list[torch.Tensor]], ~video_utils.URL, list[~video_utils.URL], list[list[~video_utils.URL]], ~video_utils.Path, list[~video_utils.Path], list[list[~video_utils.Path]]], 可选) — 要预处理的视频。期望输入单个视频或一批视频，其像素值范围为 0 到 255。如果传入的像素值在 0 到 1 之间，请设置 do_rescale=False。
  • return_tensors (str 或 TensorType, 可选) — 如果设置，将返回特定框架的张量。可接受的值为：
    • 'pt'：返回 PyTorch torch.Tensor 对象。
    • 'np'：返回 NumPy np.ndarray 对象。
  • **kwargs (ProcessingKwargs，可选) — 每种模态（文本、图像、视频、音频）的额外处理选项。模型特定参数已在上方列出；有关支持参数的完整列表，请参阅 TypedDict 类。

Molmo2ImageProcessor

class transformers.Molmo2ImageProcessor

< >

( **kwargs: *<class 'transformers.models.molmo2.image_processing_molmo2.Molmo2ImageProcessorKwargs'> )

参数

  • do_convert_rgb (bool，kwargs，可选，默认为 True) — 是否将图像转换为 RGB。
  • do_resize (bool，kwargs，可选，默认为 True) — 是否调整图像大小。
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs，默认为 {'height' -- 378, 'width': 378})： 描述输入到模型的最大尺寸。
  • default_to_square (bool，kwargs，可选，默认为 True) — 当 size 为 int 时，是否在调整大小时默认使用正方形图像。
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — 应用 center_crop 后输出图像的尺寸。
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs，默认为 2) — 如果调整图像大小，则使用的重采样滤波器。它可以是枚举 PILImageResampling 中的一个值。仅当 do_resize 设置为 True 时才会生效。
  • do_rescale (bool，kwargs，可选，默认为 True) — 是否对图像进行重新缩放。
  • rescale_factor (float，kwargs，可选，默认为 0.00392156862745098) — 当 do_rescale 设置为 True 时，用于对图像进行缩放的缩放因子。
  • do_normalize (bool，kwargs，可选，默认为 True) — 是否对图像进行归一化。
  • image_mean (Union[float, list[float], tuple[float, ...]]，kwargs，可选，默认为 [0.5, 0.5, 0.5]) — 用于归一化的图像均值。仅当 do_normalize 设置为 True 时生效。
  • image_std (Union[float, list[float], tuple[float, ...]]，kwargs，可选，默认为 [0.5, 0.5, 0.5]) — 用于归一化的图像标准差。仅当 do_normalize 设置为 True 时生效。
  • do_pad (bool, kwargs, 可选) — 是否对图像进行填充。填充操作会将图像填充至批次中的最大尺寸，或填充至每张图像的固定正方形尺寸。具体的填充策略取决于模型。
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — 用于填充图像的 {"height": int, "width" int} 尺寸。必须大于为预处理提供的任何图像尺寸。如果未提供 pad_size，图像将被填充到批次中最大的高度和宽度。仅在 do_pad=True. 时应用。
  • do_center_crop (bool，kwargs，可选) — 是否对图像进行中心裁剪。
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, 可选) — 仅支持 ChannelDimension.FIRST。为兼容旧版处理器而添加。
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, 可选) — 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一：
    • "channels_first" 或 ChannelDimension.FIRST：图像采用 (num_channels, height, width) 格式。
    • "channels_last" 或 ChannelDimension.LAST：图像采用 (height, width, num_channels) 格式。
    • "none" 或 ChannelDimension.NONE：图像为 (height, width) 格式。
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — 用于处理视频的设备。如果未设置，则从输入视频中推断设备。
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — 如果设置为 'pt'，则返回堆叠的张量，否则返回张量列表。
  • disable_grouping (bool，kwargs，可选) — 是否禁用按尺寸对图像进行分组，从而逐个处理图像而非批量处理。 如果为 None，则当图像位于 CPU 上时设置为 True，否则设置为 False。此选择基于经验观察，详见此处：https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int，kwargs，可选) — 输入中每张图片所使用的图像 token 数量。 为向后兼容而添加，但在未来的模型中，应将其设置为处理器的属性。
  • max_crops (int, kwargs, 可选，默认为 8) — 每张图像使用的最大裁剪数量。
  • overlap_margins (list[int]，kwargs，可选，默认值为 [4, 4]) — 用于重叠裁剪提取的重叠边距（以 patch 为单位）。
  • patch_size (int，kwargs，可选，默认为 14) — 视觉编码器的空间块大小。
  • pooling_size (list[int]，kwargs，可选，默认为 [2, 2]) — 视觉适配器的池化大小。

构建一个 Molmo2ImageProcessor 图像处理器。

__call__

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]*args**kwargs: *<class 'transformers.processing_utils.ImagesKwargs'> )

预处理一张图像或一批图像。

预处理

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]**kwargs: *<class 'transformers.models.molmo2.image_processing_molmo2.Molmo2ImageProcessorKwargs'> ) → ~image_processing_base.BatchFeature

参数

  • images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]) — 要预处理的图像。期望输入单张图像或一批图像，其像素值范围为 0 到 255。如果传入的图像像素值在 0 到 1 之间，请设置 do_rescale=False。
  • do_convert_rgb (bool，kwargs，可选) — 是否将图像转换为 RGB。
  • do_resize (bool，kwargs，可选) — 是否调整图像大小。
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — 描述模型的最大输入维度。
  • default_to_square (bool, kwargs, 可选) — 当 size 为整数时，是否在调整大小时默认使用正方形图像。
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — 应用 center_crop 后输出图像的尺寸。
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs) — 如果调整图像大小，则使用的重采样滤波器。可以是枚举 PILImageResampling 中的一个值。仅当 do_resize 设置为 True 时生效。
  • do_rescale (bool，kwargs，可选) — 是否对图像进行重新缩放。
  • rescale_factor (float, kwargs, 可选) — 如果 do_rescale 设置为 True，则用于对图像进行缩放的缩放因子。
  • do_normalize (bool，kwargs，可选) — 是否对图像进行归一化。
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, 可选) — 用于归一化的图像均值。仅当 do_normalize 设置为 True 时生效。
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, 可选) — 用于归一化的图像标准差。仅当 do_normalize 设置为 True 时生效。
  • do_pad (bool, kwargs, 可选) — 是否对图像进行填充。填充操作会将图像填充至批次中的最大尺寸，或填充至每张图像的固定正方形尺寸。具体的填充策略取决于模型。
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — 用于填充图像的 {"height": int, "width" int} 尺寸。必须大于为预处理提供的任何图像尺寸。如果未提供 pad_size，图像将被填充到批次中最大的高度和宽度。仅在 do_pad=True. 时应用。
  • do_center_crop (bool，kwargs，可选) — 是否对图像进行中心裁剪。
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, 可选) — 仅支持 ChannelDimension.FIRST。为兼容旧版处理器而添加。
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, 可选) — 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一：
    • "channels_first" 或 ChannelDimension.FIRST：图像采用 (num_channels, height, width) 格式。
    • "channels_last" 或 ChannelDimension.LAST：图像采用 (height, width, num_channels) 格式。
    • "none" 或 ChannelDimension.NONE：图像为 (height, width) 格式。
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — 用于处理视频的设备。如果未设置，则从输入视频中推断设备。
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — 如果设置为 'pt'，则返回堆叠的张量，否则返回张量列表。
  • disable_grouping (bool，kwargs，可选) — 是否禁用按尺寸对图像进行分组，从而逐个处理图像而非批量处理。 如果为 None，则当图像位于 CPU 上时设置为 True，否则设置为 False。此选择基于经验观察，详见此处：https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int，kwargs，可选) — 输入中每张图片所使用的图像 token 数量。 为向后兼容而添加，但在未来的模型中，应将其设置为处理器的属性。
  • max_crops (int, kwargs, 可选，默认为 8) — 每张图像使用的最大裁剪数量。
  • overlap_margins (list[int]，kwargs，可选，默认值为 [4, 4]) — 用于重叠裁剪提取的重叠边距（以 patch 为单位）。
  • patch_size (int，kwargs，可选，默认为 14) — 视觉编码器的空间块大小。
  • pooling_size (list[int]，kwargs，可选，默认为 [2, 2]) — 视觉适配器的池化大小。

返回值

~image_processing_base.BatchFeature

  • data (dict) — 由 call 方法返回的列表/数组/张量字典（如 ‘pixel_values’ 等）。
  • tensor_type (Union[None, str, TensorType], 可选) — 您可以在此处指定 tensor_type，以便在初始化时将 PyTorch/Numpy 张量中的整数列表进行转换。

Molmo2VideoProcessor

class transformers.Molmo2VideoProcessor

< >

( **kwargs: *<class 'transformers.models.molmo2.video_processing_molmo2.Molmo2VideoProcessorKwargs'> )

参数

  • do_convert_rgb (bool，kwargs，可选) — 是否将图像转换为 RGB。
  • do_resize (bool，kwargs，可选) — 是否调整图像大小。
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs，默认为 {'height' -- 378, 'width': 378})： 描述输入到模型的最大尺寸。
  • default_to_square (bool，kwargs，可选，默认为 True) — 当 size 为 int 时，是否在调整大小时默认使用正方形图像。
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs，默认为 2) — 如果调整图像大小，则使用的重采样滤波器。它可以是枚举 PILImageResampling 中的一个值。仅当 do_resize 设置为 True 时才会生效。
  • do_rescale (bool，kwargs，可选) — 是否对图像进行重新缩放。
  • rescale_factor (float，kwargs，可选，默认为 0.00392156862745098) — 当 do_rescale 设置为 True 时，用于对图像进行缩放的缩放因子。
  • do_normalize (bool，kwargs，可选) — 是否对图像进行归一化。
  • image_mean (Union[float, list[float], tuple[float, ...]]，kwargs，可选，默认为 [0.5, 0.5, 0.5]) — 用于归一化的图像均值。仅当 do_normalize 设置为 True 时生效。
  • image_std (Union[float, list[float], tuple[float, ...]]，kwargs，可选，默认为 [0.5, 0.5, 0.5]) — 用于归一化的图像标准差。仅当 do_normalize 设置为 True 时生效。
  • do_center_crop (bool，kwargs，可选) — 是否对图像进行中心裁剪。
  • do_pad (bool, kwargs, 可选) — 是否对图像进行填充。填充操作会将图像填充至批次中的最大尺寸，或填充至每张图像的固定正方形尺寸。具体的填充策略取决于模型。
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — 应用 center_crop 后输出图像的尺寸。
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, 可选) — 仅支持 ChannelDimension.FIRST。为兼容旧版处理器而添加。
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, 可选) — 输入图像的通道维度格式。如果未设置，则从输入图像中推断通道维度格式。可以是以下之一：
    • "channels_first" 或 ChannelDimension.FIRST：图像采用 (num_channels, height, width) 格式。
    • "channels_last" 或 ChannelDimension.LAST：图像采用 (height, width, num_channels) 格式。
    • "none" 或 ChannelDimension.NONE：图像为 (height, width) 格式。
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — 用于处理视频的设备。如果未设置，则从输入视频中推断设备。
  • do_sample_frames (bool，kwargs，可选，默认为 True) — 是否在处理前从视频中采样帧，还是处理整个视频。
  • video_metadata (Annotated[~video_utils.VideoMetadata | dict | list[dict | ~video_utils.VideoMetadata] | list[list[dict | ~video_utils.VideoMetadata]] | None, None], kwargs) — 视频的元数据，包含总时长、帧率（fps）和总帧数等信息。该元数据将用于从视频中采样帧或计算时间戳。除非您打算在预处理之前手动解码视频，否则请勿传入任何元数据。
  • fps (Annotated[int | float | None, None], kwargs) — 当 do_sample_frames=True 时，每秒要采样的目标帧数。
  • num_frames (Annotated[int | None, None], kwargs，默认为 64) — 当 do_sample_frames=True 时，采样的最大帧数。
  • return_metadata (bool，kwargs，可选，默认为 False) — 是否返回视频元数据。视频元数据是一个包含视频时长、帧率、解码后端等信息的对象。
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — 如果设置，将返回特定框架的张量。可接受的值为：
    • 'pt'：返回 PyTorch torch.Tensor 对象。
    • 'np'：返回 NumPy np.ndarray 对象。
  • patch_size (int, kwargs, 可选) — 视频帧中每个 ViT patch 的边长（以像素为单位）。
  • pooling_size (list[int]，kwargs，可选) — [pool_h, pool_w] 应用于视频 patch 特征的池化窗口。
  • max_fps (int, kwargs, 可选) — 短视频的最大采样率，单位为每秒帧数。
  • **kwargs (ProcessingKwargs，可选) — 每种模态（文本、图像、视频、音频）的额外处理选项。模型特定参数已在上方列出；有关支持参数的完整列表，请参阅 TypedDict 类。

构建一个 Molmo2VideoProcessor 视频处理器。

__call__

< >

( videos**kwargs )

Molmo2Model

class transformers.Molmo2Model

< >

( config: Molmo2Config )

参数

  • config (Molmo2Config) — 模型的配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

Molmo2 模型由视觉主干网络、池化适配器和语言模型组成，不包含语言建模头。

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Noneimage_token_pooling: typing.Optional[torch.Tensor] = Noneimage_grids: typing.Optional[torch.Tensor] = Noneimage_num_crops: typing.Optional[torch.Tensor] = Nonepixel_values_videos: typing.Optional[torch.Tensor] = Nonevideo_token_pooling: typing.Optional[torch.Tensor] = Nonevideo_grids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonemm_token_type_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Molmo2ModelOutputWithPast or tuple(torch.Tensor)

参数

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

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

    什么是输入 ID？

  • pixel_values (torch.Tensor，形状为 (batch_size, num_channels, image_size, image_size)，可选) — 对应输入图像的张量。可以使用 Molmo2ImageProcessor 获取像素值。有关详细信息，请参阅 Molmo2ImageProcessor.call()（Molmo2Processor 使用 Molmo2ImageProcessor 来处理图像）。
  • image_token_pooling（形状为 (num_image_tokens, pool_h * pool_w) 的 torch.Tensor，可选）— 每个池化图像 token 所收集的展平图像 patch 序列中的索引，其中 -1 表示填充槽位。可通过 AutoProcessor 获取。详情请参见 ProcessorMixin.call()。
  • image_grids（形状为 (num_images, 4) 的 torch.Tensor，可选） — 每张图像的 [low_res_h, low_res_w, high_res_h, high_res_w] 池化 token 网格。可通过 AutoProcessor 获取。有关详细信息，请参阅 ProcessorMixin.call()。
  • image_num_crops（形状为 (num_images,) 的 torch.Tensor，可选） — 每张图像的裁剪数量，包含低分辨率视图。可通过 AutoProcessor 获取。详情请参见 ProcessorMixin.call()。
  • pixel_values_videos（形状为 (batch_size, num_frames, num_channels, frame_size, frame_size) 的 torch.Tensor，可选） — 对应输入视频的张量。可以使用 Molmo2VideoProcessor 获取视频的像素值。有关详细信息，请参阅 Molmo2VideoProcessor.call()（Molmo2Processor 使用 Molmo2VideoProcessor 来处理视频）。
  • video_token_pooling（形状为 (num_video_tokens, pool_h * pool_w) 的 torch.Tensor，可选） — 每个池化视频 token 所收集的展平视频帧-patch 序列的索引，其中 -1 表示填充位置。可通过 AutoProcessor 获取。详情请参见 ProcessorMixin.call()。
  • video_grids（形状为 (num_videos, 3) 的 torch.Tensor，可选） — 每个视频的 [num_frames, pooled_h, pooled_w] token 网格。可通过 AutoProcessor 获取。详情请参见 ProcessorMixin.call()。
  • attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

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

    什么是位置 ID？

  • past_key_values (~cache_utils.Cache, 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由 past_key_values 在解码的先前阶段返回，当 use_cache=True 或 config.use_cache=True.

    仅允许将 Cache 实例作为输入，请参阅我们的 kv cache 指南。 如果未传入 past_key_values，则默认会初始化 DynamicCache。

    模型将输出与输入相同的缓存格式。

    如果使用了 past_key_values，用户应仅输入未处理的 input_ids（即未向该模型提供其过去键值状态的那些），其形状为 (batch_size, unprocessed_length)，而不是形状为 (batch_size, sequence_length) 的全部 input_ids。

  • mm_token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 输入序列中匹配每种模态的 token 索引。例如文本 (0)、图像 (1)、视频 (2)。 可通过 AutoProcessor 获取多模态 token 类型 id。详情请参见 ProcessorMixin.call()。
  • inputs_embeds（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。
  • use_cache (bool，可选) — 如果设置为 True，则会返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
  • mm_encoder_outputs (dict[str, ~modeling_outputs.BaseModelOutputWithPooling], 可选) — 一个字典，其中键为支持的模态，值为该模态的编码输出。每个编码输出是一个元组，由 (pooler_output、可选：last_hidden_states、可选：hidden_states、可选：attentions) pooler_output，形状为 (batch_size, sequence_length, hidden_size)，可选) 组成，它是编码器融合到文本嵌入中的多模态特征序列。

返回值

Molmo2ModelOutputWithPast 或 tuple(torch.Tensor)

Molmo2ModelOutputWithPast 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（Molmo2Config）和输入。

Molmo2Model 的 forward 方法重写了 __call__ 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 Module 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。

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

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

  • past_key_values（Cache，可选，在传入 use_cache=True 或 config.use_cache=True 时返回）—— 它是一个 Cache 实例。更多详情，请参阅我们的 kv cache 指南。

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

  • hidden_states (tuple(torch.Tensor)，可选，当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.Tensor 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 (batch_size, sequence_length, hidden_size)。

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

  • attentions (tuple(torch.Tensor)，可选，当传入 output_attentions=True 或 config.output_attentions=True 时返回) — 一个 torch.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。

  • image_hidden_states (torch.Tensor，可选) — 一个尺寸为 (batch_size, num_images, sequence_length, hidden_size) 的 torch.Tensor。 由视觉编码器生成的模型 image_hidden_states，并在投影最后一个隐藏状态之后得到。

Molmo2TextModel

class transformers.Molmo2TextModel

< >

( config: Molmo2TextConfig )

参数

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

未附加任何特定头部的裸 Molmo2 文本模型，直接输出原始隐藏状态。

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPast or tuple(torch.Tensor)

参数

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

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

    什么是输入 ID？

  • attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

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

    什么是位置 ID？

  • past_key_values (~cache_utils.Cache, 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由 past_key_values 在解码的先前阶段返回，当 use_cache=True 或 config.use_cache=True.

    仅允许将 Cache 实例作为输入，请参阅我们的 kv cache 指南。 如果未传入 past_key_values，则默认会初始化 DynamicCache。

    模型将输出与输入相同的缓存格式。

    如果使用了 past_key_values，用户应仅输入未处理的 input_ids（即未向该模型提供其过去键值状态的那些），其形状为 (batch_size, unprocessed_length)，而不是形状为 (batch_size, sequence_length) 的全部 input_ids。

  • inputs_embeds（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。
  • use_cache (bool，可选) — 如果设置为 True，则会返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。

返回值

BaseModelOutputWithPast 或 tuple(torch.Tensor)

一个 BaseModelOutputWithPast 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（Molmo2Config）和输入。

Molmo2TextModel 的 forward 方法重写了 __call__ 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 Module 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。

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

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

  • past_key_values（Cache，可选，在传入 use_cache=True 或 config.use_cache=True 时返回）—— 它是一个 Cache 实例。更多详情，请参阅我们的 kv cache 指南。

    包含预计算的隐藏状态（自注意力块中的键和值，以及如果 config.is_encoder_decoder=True 则还包括交叉注意力块中的键和值），可用于（参见 past_key_values 输入）加速顺序解码。

  • hidden_states (tuple(torch.Tensor)，可选，当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.Tensor 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 (batch_size, sequence_length, hidden_size)。

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

  • attentions (tuple(torch.Tensor)，可选，当传入 output_attentions=True 或 config.output_attentions=True 时返回) — 一个 torch.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。

Molmo2Adapter

class transformers.Molmo2Adapter

< >

( config: Molmo2AdapterConfig )

参数

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

Molmo2 视觉适配器：通过交叉注意力层对 ViT 的 patch 特征进行池化，并将其投影到语言模型的嵌入空间中。

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( image_features: Tensorpooled_patches_idx: Tensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutput or tuple(torch.Tensor)

参数

  • image_features（形状为 (num_crops, num_patches, hidden_size * len(vision_feature_layer)) 的 torch.Tensor）— 所有裁剪区域的中间 ViT 特征的拼接结果。
  • pooled_patches_idx（形状为 (num_tokens, pool_h * pool_w) 的 torch.Tensor）— 每个输出 token 所池化的展平 patch 序列中的索引；-1 表示填充槽位。

返回值

BaseModelOutput 或 tuple(torch.Tensor)

一个 BaseModelOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（Molmo2Config）和输入。

Molmo2Adapter 的 forward 方法重写了 __call__ 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 Module 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。

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

  • hidden_states (tuple(torch.Tensor)，可选，当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.Tensor 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 (batch_size, sequence_length, hidden_size)。

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

  • attentions (tuple(torch.Tensor)，可选，当传入 output_attentions=True 或 config.output_attentions=True 时返回) — 一个 torch.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。

Molmo2VisionModel

class transformers.Molmo2VisionModel

< >

( config: Molmo2VisionConfig )

参数

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

未附加任何特定头部的裸 Molmo2 模型，直接输出原始隐藏状态。

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( pixel_values: Tensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithPooling or tuple(torch.Tensor)

参数

返回值

BaseModelOutputWithPooling 或 tuple(torch.Tensor)

一个 BaseModelOutputWithPooling 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（Molmo2Config）和输入。

Molmo2VisionModel 的 forward 方法重写了 __call__ 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 Module 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。

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

  • pooler_output (torch.Tensor，形状为 (batch_size, hidden_size)) — 序列中第一个 token（分类 token）的最后一层隐藏状态，经过用于辅助预训练任务的层进一步处理后得到。例如，对于 BERT 系列模型，这返回的是分类 token 经过线性层和 tanh 激活函数处理后的结果。线性层的权重在预训练期间通过下一句预测（分类）目标进行训练。

  • hidden_states (tuple(torch.Tensor)，可选，当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.Tensor 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 (batch_size, sequence_length, hidden_size)。

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

  • attentions (tuple(torch.Tensor)，可选，当传入 output_attentions=True 或 config.output_attentions=True 时返回) — 一个 torch.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。

Molmo2ForConditionalGeneration

class transformers.Molmo2ForConditionalGeneration

< >

( config: Molmo2Config )

参数

  • config (Molmo2Config) — 模型的配置类，包含模型的所有参数。通过配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 from_pretrained() 方法以加载模型权重。

Molmo2 模型由视觉主干网络、池化适配器和语言模型组成。

该模型继承自 PreTrainedModel。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( input_ids: LongTensor = Nonepixel_values: typing.Optional[torch.Tensor] = Noneimage_token_pooling: typing.Optional[torch.Tensor] = Noneimage_grids: typing.Optional[torch.Tensor] = Noneimage_num_crops: typing.Optional[torch.Tensor] = Nonepixel_values_videos: typing.Optional[torch.Tensor] = Nonevideo_token_pooling: typing.Optional[torch.Tensor] = Nonevideo_grids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: list[torch.Tensor] | None = Nonemm_token_type_ids: typing.Optional[torch.LongTensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Molmo2CausalLMOutputWithPast or tuple(torch.Tensor)

参数

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

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

    什么是输入 ID？

  • pixel_values (torch.Tensor，形状为 (batch_size, num_channels, image_size, image_size)，可选) — 对应输入图像的张量。可以使用 Molmo2ImageProcessor 获取像素值。有关详细信息，请参阅 Molmo2ImageProcessor.call()（Molmo2Processor 使用 Molmo2ImageProcessor 来处理图像）。
  • image_token_pooling（形状为 (num_image_tokens, pool_h * pool_w) 的 torch.Tensor，可选）— 每个池化图像 token 所收集的展平图像 patch 序列中的索引，其中 -1 表示填充槽位。可通过 AutoProcessor 获取。详情请参见 ProcessorMixin.call()。
  • image_grids（形状为 (num_images, 4) 的 torch.Tensor，可选） — 每张图像的 [low_res_h, low_res_w, high_res_h, high_res_w] 池化 token 网格。可通过 AutoProcessor 获取。有关详细信息，请参阅 ProcessorMixin.call()。
  • image_num_crops（形状为 (num_images,) 的 torch.Tensor，可选） — 每张图像的裁剪数量，包含低分辨率视图。可通过 AutoProcessor 获取。详情请参见 ProcessorMixin.call()。
  • pixel_values_videos（形状为 (batch_size, num_frames, num_channels, frame_size, frame_size) 的 torch.Tensor，可选） — 对应输入视频的张量。可以使用 Molmo2VideoProcessor 获取视频的像素值。有关详细信息，请参阅 Molmo2VideoProcessor.call()（Molmo2Processor 使用 Molmo2VideoProcessor 来处理视频）。
  • video_token_pooling（形状为 (num_video_tokens, pool_h * pool_w) 的 torch.Tensor，可选） — 每个池化视频 token 所收集的展平视频帧-patch 序列的索引，其中 -1 表示填充位置。可通过 AutoProcessor 获取。详情请参见 ProcessorMixin.call()。
  • video_grids（形状为 (num_videos, 3) 的 torch.Tensor，可选） — 每个视频的 [num_frames, pooled_h, pooled_w] token 网格。可通过 AutoProcessor 获取。详情请参见 ProcessorMixin.call()。
  • attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

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

    什么是位置 ID？

  • past_key_values (list[torch.Tensor], 可选) — 预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。这通常由 past_key_values 在解码的先前阶段返回，当 use_cache=True 或 config.use_cache=True.

    仅允许将 Cache 实例作为输入，请参阅我们的 kv cache 指南。 如果未传入 past_key_values，则默认会初始化 DynamicCache。

    模型将输出与输入相同的缓存格式。

    如果使用了 past_key_values，用户应仅输入未处理的 input_ids（即未向该模型提供其过去键值状态的那些），其形状为 (batch_size, unprocessed_length)，而不是形状为 (batch_size, sequence_length) 的全部 input_ids。

  • mm_token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 输入序列中匹配每种模态的 token 索引。例如文本 (0)、图像 (1)、视频 (2)。 可通过 AutoProcessor 获取多模态 token 类型 id。详情请参见 ProcessorMixin.call()。
  • inputs_embeds（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。
  • labels (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引值应在 [0, ..., config.vocab_size] 范围内，或为 -100（参见 input_ids 的文档字符串）。索引值设为 -100 的 token 将被忽略（即被掩码），损失仅针对标签位于 [0, ..., config.vocab_size] 范围内的 token 进行计算。
  • use_cache (bool，可选) — 如果设置为 True，则会返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
  • logits_to_keep (Union[int, torch.Tensor], 可选，默认为 0) — 如果为 int，则计算最后 logits_to_keep 个 token 的 logits。如果为 0，则计算所有 input_ids 的 logits（特殊情况）。生成过程只需要最后一个 token 的 logits，仅针对该 token 进行计算可以节省内存，对于长序列或大词汇量而言，这种节省相当显著。 如果为 torch.Tensor，则必须是一维张量，对应于序列长度维度中需要保留的索引。 这在使用打包张量格式（将批次和序列长度合并为单一维度）时非常有用。
  • mm_encoder_outputs (dict[str, ~modeling_outputs.BaseModelOutputWithPooling], 可选) — 一个字典，其中键为支持的模态，值为该模态的编码输出。每个编码输出是一个元组，由 (pooler_output、可选：last_hidden_states、可选：hidden_states、可选：attentions) pooler_output，形状为 (batch_size, sequence_length, hidden_size)，可选) 组成，它是编码器融合到文本嵌入中的多模态特征序列。

返回值

Molmo2CausalLMOutputWithPast 或 tuple(torch.Tensor)

Molmo2CausalLMOutputWithPast 或 torch.Tensor 元组（当传入 return_dict=False 或 config.return_dict=False 时），其包含的元素取决于配置（Molmo2Config）和输入。

Molmo2ForConditionalGeneration 的 forward 方法会重写 __call__ 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 Module 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者则会静默地忽略这些步骤。

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

  • logits（形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.Tensor）— 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。

  • past_key_values（Cache，可选，在传入 use_cache=True 或 config.use_cache=True 时返回）—— 它是一个 Cache 实例。更多详情，请参阅我们的 kv cache 指南。

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

  • hidden_states (tuple[torch.Tensor]，可选，当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个 torch.Tensor 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 (batch_size, sequence_length, hidden_size)。

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

  • attentions (tuple[torch.Tensor]，可选，当传入 output_attentions=True 或 config.output_attentions=True 时返回) — 一个 torch.Tensor 元组（每层一个），形状为 (batch_size, num_heads, sequence_length, sequence_length)。

    注意力权重，即经过注意力 softmax 之后的权重，用于在自注意力头中计算加权平均值。

  • image_hidden_states (torch.Tensor，可选) — 一个尺寸为 (batch_size, num_images, sequence_length, hidden_size) 的 torch.Tensor。 由视觉编码器生成的模型 image_hidden_states，并在投影最后一个隐藏状态之后得到。

示例：

>>> from PIL import Image
>>> import requests
>>> from transformers import AutoProcessor, Molmo2ForConditionalGeneration

>>> model = Molmo2ForConditionalGeneration.from_pretrained("allenai/Molmo2-8B")
>>> processor = AutoProcessor.from_pretrained("allenai/Molmo2-8B")

>>> prompt = "What's the content of the image?"
>>> url = "https://www.ilankelman.org/stopsigns/australia.jpg"
>>> image = Image.open(requests.get(url, stream=True).raw)

>>> messages = [{"role": "user", "content": [{"type": "text", "text": prompt}, {"type": "image", "image": image}]}]

>>> inputs = processor.apply_chat_template(messages, tokenize=True, add_generation_prompt=True, return_tensors="pt", return_dict=True)

>>> # Generate
>>> generated_ids = model.generate(**inputs, max_new_tokens=15)
>>> generated_tokens = generated_ids[:, inputs['input_ids'].size(1):]
>>> processor.post_process_image_text_to_text(generated_tokens, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
"The image shows a bustling street scene in what appears to be a Chinatown area. There's ..."
Update on GitHub

←MM Grounding DINO MusicFlamingo→