SmolVLM

概述

SmolVLM2 是 Idefics3 模型的改编版本，主要有两个区别

它使用 SmolLM2 作为文本模型。
它支持多图像和视频输入

使用技巧

输入图像可以通过上采样（如果启用调整大小）或以其原始分辨率进行处理。调整大小的行为取决于两个参数：do_resize 和 size。

视频不应进行上采样。

如果 do_resize 设置为 True，则模型会调整图像大小，使最长边默认为 4*512 像素。默认的调整大小行为可以通过将字典传递给 size 参数进行自定义。例如，`{“longest_edge”: 4*512}` 是默认值，但您可以根据需要将其更改为不同的值。

以下是如何控制调整大小并设置自定义大小

image_processor = SmolVLMImageProcessor(do_resize=True, size={"longest_edge": 2 * 512}, max_image_size=512)

此外，max_image_size 参数（控制图像分解成的每个正方形补丁的大小）默认设置为 512，但可以根据需要进行调整。调整大小（如果适用）后，图像处理器会根据 max_image_size 参数将图像分解为正方形补丁。

此模型由 orrzohar 贡献。

使用示例

单媒体推理

该模型可以接受图像和视频作为输入，但您应该一次只使用一种模态。这是一个示例代码。

import torch
from transformers import AutoProcessor, AutoModelForImageTextToText

processor = AutoProcessor.from_pretrained("HuggingFaceTB/SmolVLM2-256M-Video-Instruct")
model = AutoModelForImageTextToText.from_pretrained(
    "HuggingFaceTB/SmolVLM2-256M-Video-Instruct",
    torch_dtype=torch.bfloat16,
    device_map="cuda"
)

conversation = [
    {
        "role": "user",
        "content":[
            {"type": "image", "url": "http://images.cocodataset.org/val2017/000000039769.jpg"},
            {"type": "text", "text": "Describe this image."}
        ]
    }
]

inputs = processor.apply_chat_template(
    conversation,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
).to(model.device, dtype=torch.bfloat16)

output_ids = model.generate(**inputs, max_new_tokens=128)
generated_texts = processor.batch_decode(output_ids, skip_special_tokens=True)
print(generated_texts)


# Video
conversation = [
    {
        "role": "user",
        "content": [
            {"type": "video", "path": "/path/to/video.mp4"},
            {"type": "text", "text": "Describe this video in detail"}
        ]
    },
]

inputs = processor.apply_chat_template(
    conversation,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
).to(model.device, dtype=torch.bfloat16)

generated_ids = model.generate(**inputs, do_sample=False, max_new_tokens=100)
generated_texts = processor.batch_decode(generated_ids, skip_special_tokens=True)
print(generated_texts[0])

批量混合媒体推理

该模型可以批量处理由多个图像/视频和文本组成的输入。这是一个例子。

import torch
from transformers import AutoProcessor, AutoModelForImageTextToText

processor = AutoProcessor.from_pretrained("HuggingFaceTB/SmolVLM2-256M-Video-Instruct")
model = AutoModelForImageTextToText.from_pretrained(
    "HuggingFaceTB/SmolVLM2-256M-Video-Instruct",
    torch_dtype=torch.bfloat16,
    device_map="cuda"
)

# Conversation for the first image
conversation1 = [
    {
        "role": "user",
        "content": [
            {"type": "image", "path": "/path/to/image.jpg"},
            {"type": "text", "text": "Describe this image."}
        ]
    }
]

# Conversation with two images
conversation2 = [
    {
        "role": "user",
        "content": [
            {"type": "image", "path": "/path/to/image.jpg"},
            {"type": "image", "path": "/path/to/image.jpg"},
            {"type": "text", "text": "What is written in the pictures?"}
        ]
    }
]

# Conversation with pure text
conversation3 = [
    {"role": "user","content": "who are you?"}
]


conversations = [conversation1, conversation2, conversation3]
inputs = processor.apply_chat_template(
    conversation,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
).to(model.device, dtype=torch.bfloat16)

generated_ids = model.generate(**inputs, do_sample=False, max_new_tokens=100)
generated_texts = processor.batch_decode(generated_ids, skip_special_tokens=True)
print(generated_texts[0])

SmolVLMConfig

class transformers.SmolVLMConfig

< source >

( use_cache = True image_token_id = 128257 tie_word_embeddings = False vision_config = None text_config = None scale_factor = 2 pad_token_id = 128002 **kwargs )

参数

use_cache (bool, 可选, 默认为 True) — 模型是否应缓存注意力机制的键/值对。仅当 config.is_decoder=True 时相关。
image_token_id (int, 可选, 默认为 128257) — “image” token 的 id。
tie_word_embeddings (bool, 可选, 默认为 False) — 是否将词嵌入与 token 嵌入绑定。
vision_config (IdeficsVisionConfig 或 dict, 可选, 默认为 IdeficsVisionConfig) — 视觉塔的自定义视觉配置或 dict
text_config (PretrainedConfig 或 dict, 可选, 默认为 LlamaConfig) — 文本模型的自定义文本配置或 dict
scale_factor (int, 可选, 默认为 2) — 图像编码器的缩放因子。
pad_token_id (int, 可选, 默认为 128002) — padding token 的 id。

这是用于存储 SmolVLMModel 配置的配置类。它用于根据指定的参数实例化 SmolVLM 模型，定义模型架构。使用默认值实例化配置将产生与 SmolVLM HuggingFaceTB/SmolVLM2-2.2B-Instruct 架构的模型类似的配置。

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

示例

>>> from transformers import SmolVLMModel, SmolVLMConfig
>>> # Initializing configuration
>>> configuration = SmolVLMConfig()
>>> # Initializing a model from the configuration
>>> model = SmolVLMModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

SmolVLMVisionConfig

class transformers.SmolVLMVisionConfig

< source >

( hidden_size = 1152 intermediate_size = 3072 num_hidden_layers = 12 num_attention_heads = 16 num_channels = 3 image_size = 224 patch_size = 32 hidden_act = 'gelu_pytorch_tanh' layer_norm_eps = 1e-06 attention_dropout = 0.0 initializer_range = 0.02 **kwargs )

参数

hidden_size (int, 可选, 默认为 1152) — 编码器层和池化器层的维度。
intermediate_size (int, 可选, 默认为 3072) — Transformer 编码器中“中间”层（即，前馈层）的维度。
num_hidden_layers (int, 可选, 默认为 12) — Transformer 编码器中隐藏层的数量。
num_attention_heads (int, 可选, 默认为 16) — Transformer 编码器中每个注意力层的注意力头的数量。
num_channels (int, 可选, 默认为 3) — 输入图像中的通道数。
image_size (int, 可选, 默认为 224) — 每张图像的尺寸（分辨率）。
patch_size (int, 可选, 默认为 32) — 每个 patch 的尺寸（分辨率）。
hidden_act (str 或 function, 可选, 默认为 "gelu_pytorch_tanh") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果为字符串，则支持 "gelu", "relu", "selu", "gelu_new" 和 "quick_gelu"。
layer_norm_eps (float, 可选, 默认为 1e-06) — 层归一化层使用的 epsilon 值。
attention_dropout (float, 可选, 默认为 0.0) — 注意力概率的 dropout 比率。
initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。

这是用于存储 SmolVLMVisionModel 配置的配置类。它用于根据指定的参数实例化 SmolVLM 视觉编码器，定义模型架构。使用默认值实例化配置将产生与 SigLIP 检查点 google/siglip-so400m-patch14-384 类似的配置，该检查点在 SmolVLM HuggingFaceTB/SmolVLM2-2.2B-Instruct 中使用。

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

示例

>>> from transformers.models.smolvlm.modeling_smolvlm import SmolVLMVisionTransformer
>>> from transformers.models.smolvlm.configuration_smolvlm import SmolVLMVisionConfig

>>> # Initializing a SmolVLMVisionConfig with google/siglip-so400m-patch14-384 style configuration
>>> configuration = SmolVLMVisionConfig()

>>> # Initializing a SmolVLMVisionTransformer (with random weights) from the google/siglip-so400m-patch14-384 style configuration
>>> model = SmolVLMVisionTransformer(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

Idefics3VisionTransformer

class transformers.SmolVLMVisionTransformer

< source >

( config: SmolVLMVisionConfig )

参数

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

SmolVLM Vision Transformer 模型，输出原始图像嵌入。此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如，下载或保存、调整输入嵌入大小、剪枝头等）。

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

SmolVLMModel

class transformers.SmolVLMModel

< source >

( config: SmolVLMConfig )

参数

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

SmolVLM 模型，由 SIGLIP 视觉编码器和 Llama3 语言解码器组成。此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如，下载或保存、调整输入嵌入大小、剪枝头等）。

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

Idefics3Model 的子类。我们不删除或阻止对 forward 中的 inputs_merger 的调用。相反，我们在此处使用自定义逻辑覆盖 inputs_merger。

forward

< source >

( input_ids: LongTensor = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[typing.List[torch.FloatTensor]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None pixel_values: typing.Optional[torch.FloatTensor] = None pixel_attention_mask: typing.Optional[torch.BoolTensor] = None image_hidden_states: 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 )

参数

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

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

什么是 input IDs？
attention_mask (torch.Tensor，形状为 (batch_size, sequence_length), 可选) — Mask，用于避免在 padding token 索引上执行 attention。Mask 值在 [0, 1] 中选择：
- 1 表示 tokens 未被 mask，
- 0 表示 tokens 已被 mask。
什么是 attention masks？

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

如果使用 past_key_values，则可以选择仅输入最后的 decoder_input_ids（请参阅 past_key_values）。

如果您想更改 padding 行为，则应阅读 modeling_opt._prepare_decoder_attention_mask 并根据您的需求进行修改。有关默认策略的更多信息，请参见论文中的图 1。
- 1 表示 head 未被 mask，
- 0 表示 head 已被 mask。
position_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor, 可选) — 位置嵌入中每个输入序列标记的位置索引。在范围 [0, config.n_positions - 1] 中选择。什么是位置 ID？
past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(tuple(torch.FloatTensor)) 元组，其中每个元组有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head)) 的张量，以及 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的额外张量。

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

如果使用 past_key_values，用户可以选择仅输入最后一次的 decoder_input_ids （那些没有将其过去的键值状态提供给此模型的），形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 decoder_input_ids。
inputs_embeds (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor, 可选) — （可选）您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更灵活地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。
pixel_values (形状为 (batch_size, num_channels, image_size, image_size)) 的torch.FloatTensor`）-- 与输入图像对应的张量。像素值可以使用 [AutoImageProcessor](/docs/transformers/v4.50.0/en/model_doc/auto#transformers.AutoImageProcessor) 获得。有关详细信息，请参阅 [CLIPImageProcessor.__call__()](/docs/transformers/v4.50.0/en/model_doc/vilt#transformers.ViltFeatureExtractor.__call__)（[`LlavaProcessor`] 使用 CLIPImageProcessor 处理图像）。
pixel_attention_mask (形状为 (batch_size, image_size, image_size) 的 torch.Tensor, 可选) — 用于避免对填充像素索引执行注意力的掩码。
image_hidden_states (形状为 (batch_size, num_channels, image_size, image_size) 的 torch.FloatTensor) — 模态投影后图像编码器的隐藏状态。
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 相反，此张量不受填充的影响。它用于在正确的位置更新缓存并推断完整的序列长度。

SmolVLMModel 的 forward 方法，覆盖了 __call__ 特殊方法。

尽管 forward 传递的配方需要在该函数内定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

馈送到模型的输入可以具有任意数量的图像。为了解决这个问题，馈送到模型的 pixel_values 具有图像填充 -> (batch_size, max_num_images, 3, max_heights, max_widths)，其中 max_num_images 是批次大小样本中图像的最大数量。超出在模型入口处填充 pixel_values 之外，不需要填充图像。为了提高效率，我们仅通过 vision_model 的 forward 传递真实图像，方法是丢弃填充图像，即大小为 (image_batch_size, 3, height, width) 的 pixel_values，其中当 num_images_per_sample=[1, 3, 1, 2] 且 max_num_images 为 3 时，image_batch_size 将为 7。

SmolVLMForConditionalGeneration

class transformers.SmolVLMForConditionalGeneration

< source >

( config )

参数

config (SmolVLMConfig 或 SmolVLMVisionConfig) — 模型配置类，其中包含模型的所有参数。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。

带有语言建模头的 SmolVLM 模型。它由 SigLIP 视觉编码器和顶部的语言建模头组成。此模型继承自 PreTrainedModel。查看超类文档，了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

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

Idefics3ForConditionalGeneration 的子类，它使用 SmolVLMModel 而不是默认的 Idefics3Model。

forward

< source >

( input_ids: LongTensor = None attention_mask: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.LongTensor] = None past_key_values: typing.Optional[typing.List[torch.FloatTensor]] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None pixel_values: typing.Optional[torch.FloatTensor] = None pixel_attention_mask: typing.Optional[torch.BoolTensor] = None image_hidden_states: 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 cache_position: typing.Optional[torch.LongTensor] = None return_dict: typing.Optional[bool] = None logits_to_keep: typing.Union[int, torch.Tensor] = 0 ) → transformers.models.smolvlm.modeling_smolvlm.SmolVLMCausalLMOutputWithPast 或 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 表示标记已被掩蔽。
什么是注意力掩码？

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

如果使用 past_key_values，则可以选择仅输入最后一次的 decoder_input_ids （请参阅 past_key_values）。

如果要更改填充行为，则应阅读 modeling_opt._prepare_decoder_attention_mask 并根据您的需求进行修改。有关默认策略的更多信息，请参见论文中的图 1。
- 1 表示头未被掩蔽，
- 0 表示头已被掩蔽。
position_ids (形状为 (batch_size, sequence_length) 的 torch.LongTensor, 可选) — 位置嵌入中每个输入序列标记的位置索引。在范围 [0, config.n_positions - 1] 中选择。什么是位置 ID？
past_key_values (tuple(tuple(torch.FloatTensor)), 可选, 当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layers 的 tuple(tuple(torch.FloatTensor)) 元组，其中每个元组有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head)) 的张量，以及 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的额外张量。

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

如果使用 past_key_values，用户可以选择仅输入最后一次的 decoder_input_ids （那些没有将其过去的键值状态提供给此模型的），形状为 (batch_size, 1)，而不是所有形状为 (batch_size, sequence_length) 的 decoder_input_ids。
inputs_embeds (形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor, 可选) — （可选）您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更灵活地控制如何将 input_ids 索引转换为关联的向量，这将非常有用。
pixel_values (形状为 (batch_size, num_channels, image_size, image_size) 的 torch.FloatTensor) —— 对应于输入图像的张量。像素值可以使用 AutoImageProcessor 获得。有关详细信息，请参阅 CLIPImageProcessor.__call__() ([`LlavaProcessor`] 使用 CLIPImageProcessor 处理图像)。
pixel_attention_mask (形状为 (batch_size, image_size, image_size) 的 torch.Tensor，可选) — 用于避免对填充像素索引执行注意力机制的掩码。
image_hidden_states (形状为 (batch_size, num_channels, image_size, image_size) 的 torch.FloatTensor) —— 模态投影后图像编码器的隐藏状态。
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，*可选*) — 索引，描述输入序列 tokens 在序列中的位置。与 `position_ids` 相反，此张量不受填充的影响。它用于在正确的位置更新缓存并推断完整序列长度。
Args — labels (形状为 `(batch_size, sequence_length)` 的 `torch.LongTensor`，*可选*): 用于计算掩码语言建模损失的标签。索引应为 `[0, ..., config.vocab_size]` 或 `model.image_token_id`（其中 `model` 是您的 `SmolVLMForConditionalGeneration` 实例）。索引设置为 `model.image_token_id` 的 tokens 将被忽略（掩码），损失仅针对标签在 `[0, ..., config.vocab_size]` 中的 tokens 计算。

transformers.models.smolvlm.modeling_smolvlm.SmolVLMCausalLMOutputWithPast 或 tuple(torch.FloatTensor)

一个 transformers.models.smolvlm.modeling_smolvlm.SmolVLMCausalLMOutputWithPast 或 torch.FloatTensor 元组（如果传递 `return_dict=False` 或当 `config.return_dict=False` 时），包含各种元素，具体取决于配置 (SmolVLMConfig) 和输入。

loss (形状为 `(1,)` 的 torch.FloatTensor，*可选*，当提供 `labels` 时返回) — 语言建模损失（用于下一个 token 预测）。
logits (形状为 (batch_size, sequence_length, config.vocab_size)` 的 torch.FloatTensor) — 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。


past_key_values (`tuple(tuple(torch.FloatTensor))`，*可选*，当传递 `use_cache=True` 或当 `config.use_cache=True` 时返回) — 长度为 `config.n_layers` 的 `tuple(tuple(torch.FloatTensor))` 元组，其中每个元组包含 2 个形状为 `(batch_size, num_heads, sequence_length, embed_size_per_head)` 的张量）。 包含预先计算的隐藏状态（自注意力模块中的键和值），可用于加速顺序解码（请参阅 `past_key_values` 输入）。
hidden_states (`tuple(torch.FloatTensor)`，*可选*，当传递 `output_hidden_states=True` 或当 `config.output_hidden_states=True` 时返回) — `torch.FloatTensor` 元组（如果模型具有嵌入层，则为嵌入输出之一，+ 每个层的输出之一），形状为 `(batch_size, sequence_length, hidden_size)`。 模型在每一层输出端的隐藏状态，加上可选的初始嵌入输出。
attentions (`tuple(torch.FloatTensor)`，*可选*，当传递 `output_attentions=True` 或当 `config.output_attentions=True` 时返回) — `torch.FloatTensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。 注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
image_hidden_states (`tuple(torch.FloatTensor)`，*可选*) —  `torch.FloatTensor` 元组（图像嵌入的输出之一，`(batch_size, num_images, sequence_length, hidden_size)`。视觉编码器生成的模型的 image_hidden_states

 的 SmolVLMForConditionalGeneration 的 forward 方法，覆盖了 __call__ 特殊方法。
  尽管 forward 传递的配方需要在该函数内定义，但之后应该调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
   示例
 
 >>> import requests
>>> import torch
>>> from PIL import Image
>>> from io import BytesIO

>>> from transformers import AutoProcessor, AutoModelForImageTextToText
>>> from transformers.image_utils import load_image

>>> # Note that passing the image urls (instead of the actual pil images) to the processor is also possible
>>> image1 = load_image("https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg")
>>> image2 = load_image("https://cdn.britannica.com/59/94459-050-DBA42467/Skyline-Chicago.jpg")
>>> image3 = load_image("https://cdn.britannica.com/68/170868-050-8DDE8263/Golden-Gate-Bridge-San-Francisco.jpg")

>>> processor = AutoProcessor.from_pretrained("HuggingFaceTB/SmolVLM2-2.2B-Instruct")
>>> model = AutoModelForImageTextToText.from_pretrained("HuggingFaceTB/SmolVLM2-2.2B-Instruct", torch_dtype=torch.bfloat16, device_map="auto")

>>> # Create inputs
>>> messages = [
...     {
...         "role": "user",
...         "content": [
...             {"type": "video", "path": path/to/video},
...             {"type": "text", "text": "What is happening in this video?"},
...         ]
...     }
... ]

>>> inputs = processor.apply_chat_template([messages], add_generation_prompt=True)

>>> # Generate
>>> generated_ids = model.generate(**inputs, max_new_tokens=256)
>>> generated_texts = processor.batch_decode(generated_ids, skip_special_tokens=True)

>>> print(generated_texts)

   SmolVLMImageProcessor
  class transformers.SmolVLMImageProcessor
  < source > ( do_convert_rgb: bool = True do_resize: bool = True size: typing.Dict[str, int] = None resample: Resampling = <Resampling.LANCZOS: 1> do_image_splitting: bool = True max_image_size: typing.Dict[str, int] = None do_rescale: bool = True rescale_factor: float = 0.00392156862745098 do_normalize: bool = True image_mean: typing.Union[float, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = None do_pad: bool = True **kwargs  )
   参数 
  do_convert_rgb (`bool`，*可选*，默认为 `True`) — 是否将图像转换为 RGB 格式。 如果输入图像是不同的格式（例如 RGBA），这将非常有用。 仅当输入图像为 PIL 格式时才有效。  
 do_resize (`bool`，*可选*，默认为 `True`) — 是否调整图像大小。 图像的最长边将被调整为 <= `size["longest_edge"]`，最短边将被调整以保持输入宽高比。 
 size (`Dict`，*可选*，默认为 `{"longest_edge" -- 4 * 364}`): 控制输出图像的大小。 这是一个包含键 “longest_edge” 的字典。 图像将被调整大小，使得最长边 <= `size["longest_edge"]`，最短边将被调整大小以保持输入宽高比。 
 resample (`Resampling`，*可选*，默认为 `Resampling.LANCZOS`) — 调整图像大小时要使用的重采样过滤器。 
 do_image_splitting (`bool`，*可选*，默认为 `True`) — 是否将图像拆分为与原始图像连接的子图像。 它们被拆分为补丁，使得每个补丁的大小为 `max_image_size["height"]` x `max_image_size["width"]`。 
 max_image_size (`Dict`，*可选*，默认为 `{"longest_edge" -- 364}`): 模型接受的图像补丁的最大分辨率。 这是一个包含键 “longest_edge” 的字典。 
 do_rescale (`bool`，*可选*，默认为 `True`) — 是否重新缩放图像。 如果设置为 `True`，则图像将被重新缩放，使其像素值介于 0 和 1 之间。 
 rescale_factor (`float`，*可选*，默认为 `1/255`) — 如果 `do_rescale` 设置为 `True`，则用于重新缩放图像的重新缩放因子。 
 do_normalize (`bool`，*可选*，默认为 `True`) — 是否标准化图像。 如果设置为 `True`，则图像将被标准化为具有 `image_mean` 的均值和 `image_std` 的标准差。 
 image_mean (`float` 或 `List[float]`，*可选*，默认为 `IDEFICS_STANDARD_MEAN`) — 如果标准化图像，则使用的均值。 这是一个浮点数或浮点数列表，其长度为图像中通道的数量。 可以被 `preprocess` 方法中的 `image_mean` 参数覆盖。 可以被 `preprocess` 方法中的 `image_mean` 参数覆盖。 
 image_std (`float` 或 `List[float]`，*可选*，默认为 `IDEFICS_STANDARD_STD`) — 如果标准化图像，则使用的标准差。 这是一个浮点数或浮点数列表，其长度为图像中通道的数量。 可以被 `preprocess` 方法中的 `image_std` 参数覆盖。 可以被 `preprocess` 方法中的 `image_std` 参数覆盖。 
 do_pad (`bool`，*可选*，默认为 `True`) — 是否将图像填充到批次中最大的高度和宽度，以及批次中每个样本的图像数量，以便返回的张量形状为 (batch_size, max_num_images, num_channels, max_height, max_width)。 
   
 构建 SmolVLM 图像处理器。
  preprocess
  < source > ( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']] do_convert_rgb: typing.Optional[bool] = None do_resize: typing.Optional[bool] = None size: typing.Optional[typing.Dict[str, int]] = None resample: Resampling = None do_image_splitting: typing.Optional[bool] = None do_rescale: typing.Optional[bool] = None max_image_size: typing.Optional[typing.Dict[str, int]] = None rescale_factor: typing.Optional[float] = None do_normalize: typing.Optional[bool] = None image_mean: typing.Union[float, typing.List[float], NoneType] = None image_std: typing.Union[float, typing.List[float], NoneType] = None do_pad: typing.Optional[bool] = None return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None return_row_col_info: bool = False data_format: typing.Optional[transformers.image_utils.ChannelDimension] = <ChannelDimension.FIRST: 'channels_first'> input_data_format: typing.Union[transformers.image_utils.ChannelDimension, str, NoneType] = None  )
   参数 
  images (ImageInput) — 预处理的图像列表。 
 do_convert_rgb (bool, optional, defaults to self.do_convert_rgb) — 是否将图像转换为 RGB 格式。默认为 self.do_convert_rgb。 
 do_resize (bool, optional, defaults to self.do_resize) — 是否调整图像大小。默认为 self.do_resize。 
 size (Dict[str, int], optional, defaults to self.size) — 调整大小后图像的尺寸。最长边会调整大小以保持输入宽高比。默认为 self.size。 
 resample (int, optional, defaults to self.resample) — 如果调整图像大小，则使用的重采样滤波器。可以是枚举类型 PILImageResampling 中的一个。仅在 do_resize 设置为 True 时生效。默认为 self.resample。 
 do_image_splitting (bool, optional, defaults to self.do_image_splitting) — 是否将图像分割成子图像，并与原始图像连接。它们被分割成小块，每个小块的尺寸为 max_image_size["height"] x max_image_size["width"]。默认为 self.do_image_splitting。 
 max_image_size (Dict, optional, defaults to self.max_image_size) — 图像的最大分辨率。如果图像大于此尺寸，则图像将被分割成小块。默认为 self.max_image_size。 
 do_rescale (bool, optional, defaults to self.do_rescale) — 是否对图像进行重新缩放。默认为 self.do_rescale。 
 rescale_factor (float, optional, defaults to self.rescale_factor) — 如果 do_rescale 设置为 True，则用于重新缩放图像的重新缩放因子。默认为 self.rescale_factor。 
 do_normalize (bool, optional, defaults to self.do_normalize) — 是否对图像进行归一化处理。默认为 self.do_normalize。 
 image_mean (float 或 List[float], optional, defaults to self.image_mean) — 用于归一化的图像均值。仅在 do_normalize 设置为 True 时生效。默认为 self.image_mean。 
 image_std (float 或 List[float], optional, defaults to self.image_std) — 用于归一化的图像标准差。仅在 do_normalize 设置为 True 时生效。默认为 self.image_std。 
 do_pad (bool, optional, defaults to self.do_pad) — 是否将图像填充到批次中最大的高度和宽度。默认为 self.do_pad。 
 return_tensors (str 或 TensorType, optional) — 返回的张量类型。可以是以下之一： Unset: 返回 np.ndarray 列表。
 TensorType.TENSORFLOW 或 'tf': 返回 tf.Tensor 类型的批次。
 TensorType.PYTORCH 或 'pt': 返回 torch.Tensor 类型的批次。
 TensorType.NUMPY 或 'np': 返回 np.ndarray 类型的批次。
 TensorType.JAX 或 'jax': 返回 jax.numpy.ndarray 类型的批次。
 
  
 return_row_col_info (bool, optional, default to False) — 是否返回分割后图像的行数和列数。这用于 SmolVLMProcessor 基于行数和列数生成提示字符串。默认为 False。 
 data_format (ChannelDimension 或 str, optional, defaults to ChannelDimension.FIRST) — 输出图像的通道维度格式。可以是以下之一： "channels_first" 或 ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。
 "channels_last" 或 ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。
 Unset: 使用输入图像的通道维度格式。
 
 默认为 ChannelDimension.FIRST。 
 input_data_format (ChannelDimension 或 str, optional) — 输入图像的通道维度格式。如果未设置，则从输入图像推断通道维度格式。可以是以下之一： "channels_first" 或 ChannelDimension.FIRST: 图像格式为 (num_channels, height, width)。
 "channels_last" 或 ChannelDimension.LAST: 图像格式为 (height, width, num_channels)。
 "none" 或 ChannelDimension.NONE: 图像格式为 (height, width)。
 
  
   
 预处理一批图像。
   SmolVLMProcessor
  class transformers.SmolVLMProcessor
  < source > ( image_processor tokenizer = None image_seq_len: int = 169 chat_template: str = None **kwargs  )
   参数 
  image_processor (SmolVLMImageProcessor) — SmolVLMImageProcessor 的实例。图像处理器是必需的输入。 
 tokenizer (PreTrainedTokenizerBase, optional) — PreTrainedTokenizerBase 的实例。这应该与模型的文本模型相对应。分词器是必需的输入。默认为 None。 
 image_seq_len (int, optional, defaults to 169) — 图像序列的长度，即输入中每个图像的  token 数量。此参数用于从输入提示和图像 token 构建字符串，并且应与模型使用的值匹配。它的计算方式为：image_seq_len = int(((image_size // patch_size)  2) / (scale_factor2)) 。默认为 169。 
 chat_template (str, optional) — Jinja 模板，用于将聊天中的消息列表转换为可标记化的字符串。默认为 None。 
   
 构建一个 SmolVLM 处理器，它将 LLama 分词器和 SmolVLM 图像处理器包装到单个处理器中。
 SmolVLMProcessor 提供 SmolVLMImageProcessor 和 SmolVLMTokenizerFast 的所有功能。有关更多信息，请参阅 call() 和 decode() 的文档字符串。
  __call__
  < source > ( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], typing.List[typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]], typing.List[typing.List[typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']]]]] = None text: typing.Union[str, ForwardRef('PreTokenizedInput'), typing.List[str], typing.List[ForwardRef('PreTokenizedInput')]] = None audio = None videos: typing.Union[list['PIL.Image.Image'], ForwardRef('np.ndarray'), ForwardRef('torch.Tensor'), list['np.ndarray'], list['torch.Tensor'], list[list['PIL.Image.Image']], list[list['np.ndarrray']], list[list['torch.Tensor']]] = None **kwargs: typing_extensions.Unpack[transformers.models.smolvlm.processing_smolvlm.SmolVLMProcessorKwargs]  )
   参数 
  images (PIL.Image.Image, np.ndarray, torch.Tensor, List[PIL.Image.Image], List[np.ndarray], List[torch.Tensor], optional) — 要准备的图像或图像批次。每张图像可以是 PIL 图像、NumPy 数组或 PyTorch 张量。如果类型为 List[ImageInput]，则假定这用于单个提示，即批次大小为 1。  
 text (Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]], optional) — 要编码的序列或序列批次。每个序列可以是字符串或字符串列表（预分词字符串）。如果序列以字符串列表（预分词）形式提供，则必须设置 is_split_into_words=True （以消除与序列批次的歧义）。 每当遇到图像 token <image> 时，它都会被扩展为 <fake_token_around_image> + <row_x_col_y> + <image>  image_seq_len  `。  
 return_tensors (Union[str, TensorType], optional) — 如果设置，将返回特定框架的张量。 有关更多信息，请参见 PreTrainedTokenizerFast.call()。  
   
 处理输入提示并返回 BatchEncoding。
   示例
 
 >>> import requests
>>> from transformers import SmolVLMProcessor
>>> from transformers.image_utils import load_image

>>> processor = SmolVLMProcessor.from_pretrained("HuggingFaceM4/SmolVLM2-256M-Video-Instruct")
>>> processor.image_processor.do_image_splitting = False  # Force as False to simplify the example

>>> url1 = "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
>>> url2 = "https://cdn.britannica.com/59/94459-050-DBA42467/Skyline-Chicago.jpg"

>>> image1, image2 = load_image(url1), load_image(url2)
>>> images = [[image1], [image2]]

>>> text = [
...     "<image>In this image, we see",
...     "bla bla bla<image>",
... ]
>>> outputs = processor(images=images, text=text, return_tensors="pt", padding=True)
>>> input_ids = outputs.input_ids
>>> input_tokens = processor.tokenizer.batch_decode(input_ids)
>>> print(input_tokens)
['<|begin_of_text|><fake_token_around_image><global-img>((<image>)*169)<fake_token_around_image> In this image, we see', '<|reserved_special_token_0|><|reserved_special_token_0|><|reserved_special_token_0|><|begin_of_text|>bla bla bla<fake_token_around_image><global-img>((<image>)*169)<fake_token_around_image>']
 < > 在 GitHub 上更新

Transformers

SmolVLM

概述

使用技巧

使用示例

单媒体推理

批量混合媒体推理

SmolVLMConfig

class transformers.SmolVLMConfig

SmolVLMVisionConfig

class transformers.SmolVLMVisionConfig

Idefics3VisionTransformer

class transformers.SmolVLMVisionTransformer

SmolVLMModel

class transformers.SmolVLMModel

forward

SmolVLMForConditionalGeneration

class transformers.SmolVLMForConditionalGeneration

forward

SmolVLMImageProcessor

class transformers.SmolVLMImageProcessor

preprocess

SmolVLMProcessor

class transformers.SmolVLMProcessor

__call__

call