SmolVLM2: The Smollest Video Model Ever（一）

Toky丶

已于 2025-04-10 15:06:39 修改

阅读量984

点赞数 20

文章标签：大模型语言模型

于 2025-04-09 11:43:59 首次发布

本文链接：https://blog.csdn.net/Toky_min/article/details/147061889

版权

这篇主要是摘抄的huggingface官网的介绍以及官方文档，还需要看下文章

主页：

hzhttps://huggingface.co/collections/HuggingFaceTB/smolvlm2-smallest-video-lm-ever-67ab6b5e84bf8aaa60cb17c7

https://huggingface.co/HuggingFaceTB/SmolVLM2-2.2B-Instruct

概要

本文介绍了 SmolVLM，这是一款拥有 20 亿参数的视觉语言模型，在内存占用方面处于领先水平。SmolVLM 体积小、速度快、内存效率高，并且完全开源。所有的模型检查点、视觉语言模型数据集、训练方法和工具均在 Apache 2.0 许可下发布。

什么是 SmolVLM？

今年，多模态人工智能蓬勃发展，许多大型视觉语言模型相继发布。最初的趋势是提升计算能力，随后是通过大型模型生成合成数据来增加数据多样性，而最近的趋势则是缩小模型规模以提高效率。小型开源模型支持在本地浏览器或边缘设备上进行部署，能够降低推理成本，并方便用户进行定制。这类模型的典型代表包括 PaliGemma 3B、moondream2 和 Qwen2VL。

在本文中，我们将介绍 SmolVLM，这是一个全新的拥有 20 亿参数的小型视觉语言模型系列。该系列模型可用于商业用途，并能够部署在较小的本地环境中，其训练流程完全开源。

我们发布了三款模型：SmolVLM-Base，可用于下游的微调任务；SmolVLM-Synthetic，是在合成数据上进行微调的版本；SmolVLM Instruct，是经过微调的指令版本，可直接用于交互式终端用户应用程序。

我们推出三款新模型 (2.56 亿/5 亿/22 亿参数)。其中 22 亿参数模型是视觉与视频任务的优选，而 5 亿和 2.56 亿模型更是 迄今发布的最小型视频语言模型。

虽然体积小巧，但其内存效率却优于现有所有模型。在视频领域权威基准测试 Video-MME 中，SmolVLM2 在 20 亿参数级别与顶尖模型比肩，在更小规模模型中更是一骑绝尘。

此次发布的内容包括集成到 transformers 库中的开源模型、基于 SmolVLM Instruct 构建的演示示例，以及一个监督微调脚本。我们使用了之前用于训练 Idefics3 的数据集：Cauldron 和 Docmatix，这些数据集也完全开源。

ModelCard

SmolVLM2 2.2B

类型：图像 - 文本 - 文本
使用工具：Transformers
格式：Safetensors
数据集数量：12 个
支持语言：英语
应用领域：smolvlm、视频 - 文本 - 文本、对话
论文链接：arxiv:2504.05299
许可证：apache-2.0

文件与版本

SmolVLM2 2.2B

模型概述

开发者：Hugging Face 🤗
模型类型：多模态模型（图像 / 多图像 / 视频 / 文本）
自然语言处理支持语言：英语
许可证：Apache 2.0
架构：基于 Idefics3（详见技术总结）

资源

演示：视频精彩片段生成器
博客：博客文章

用途

SmolVLM2 可用于多模态（视频 / 图像 / 文本）任务的推理，其输入由文本查询以及视频或一个或多个图像组成。文本和媒体文件可以任意交错，支持图像字幕生成、视觉问答、基于视觉内容的故事创作等任务。但该模型不支持图像或视频生成。

如需在特定任务上对 SmolVLM2 进行微调，可以参考微调教程。

评估

视觉评估

模型	Mathvista	MMMU	OCRBench	MMStar	AI2D	ChartQA_Test	Science_QA	TextVQA Val	DocVQA Val
SmolVLM2 2.2B	51.5	42	72.9	46	70	68.84	90	73.21	79.98
SmolVLM 2.2B	43.9	38.3	65.5	41.8	84.5	71.6	84.5	72.1	79.7

视频评估

我们在以下科学基准上评估了 SmolVLM2 系列模型的性能：

模型规模	Video-MME	MLVU	MVBench
2.2B	52.1	55.2	46.27
500M	42.2	47.3	39.73
256M	33.7	40.6	32.7

如何开始使用

可以使用transformers库来加载、推理和微调 SmolVLM。确保已安装num2words、flash-attn和最新版本的transformers库。可按以下方式加载模型：

from transformers import AutoProcessor, AutoModelForImageTextToText
import torch

model_path = "HuggingFaceTB/SmolVLM2-2.2B-Instruct"
processor = AutoProcessor.from_pretrained(model_path)
model = AutoModelForImageTextToText.from_pretrained(
    model_path,
    torch_dtype=torch.bfloat16,
    _attn_implementation="flash_attention_2"
).to("cuda")

简单推理

直接使用聊天模板预处理输入并进行传递：

python

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg"},
            {"type": "text", "text": "Can you describe this image?"},
        ]
    },
]

inputs = processor.apply_chat_template(
    messages,
    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=64)
generated_texts = processor.batch_decode(
    generated_ids,
    skip_special_tokens=True,
)
print(generated_texts[0])

视频推理

若要使用 SmolVLM2 进行视频推理，确保已安装decord库。

messages = [
    {
        "role": "user",
        "content": [
            {"type": "video", "path": "path_to_video.mp4"},
            {"type": "text", "text": "Describe this video in detail"}
        ]
    },
]

inputs = processor.apply_chat_template(
    messages,
    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=64)
generated_texts = processor.batch_decode(
    generated_ids,
    skip_special_tokens=True,
)

print(generated_texts[0])

多图像交错推理

可以使用聊天模板将多个媒体与文本交错。

import torch

messages = [
    {
        "role": "user",
        "content": [
          {"type": "text", "text": "What is the similarity between these two images?"},
          {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/bee.jpg"},
          {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/0052a70beed5bf71b92610a43a52df6d286cd5f3/diffusers/rabbit.jpg"},            
        ]
    },
]

inputs = processor.apply_chat_template(
    messages,
    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=64)
generated_texts = processor.batch_decode(
    generated_ids,
    skip_special_tokens=True,
)
print(generated_texts[0])

模型优化

误用与不当使用场景

SmolVLM 不适用于高风险场景或影响个人福祉和生计的关键决策过程。该模型生成的内容可能看似真实，但不一定准确。误用情况包括但不限于：

禁止用途

对个人进行评估或评分（如就业、教育、信贷领域）
关键的自动化决策
生成不可靠的事实性内容

恶意活动

垃圾邮件生成
虚假信息传播
骚扰或滥用
未经授权的监视

许可证

SmolVLM2 使用经过形状优化的 SigLIP 作为图像编码器，SmolLM2 作为文本解码器。

我们在 Apache 2.0 许可证下发布 SmolVLM2 的检查点。

引用信息

引用方式如下：

bibtex

@article{marafioti2025smolvlm,
  title={SmolVLM: Redefining small and efficient multimodal models}, 
  author={Andrés Marafioti and Orr Zohar and Miquel Farré and Merve Noyan and Elie Bakouch and Pedro Cuenca and Cyril Zakka and Loubna Ben Allal and Anton Lozhkov and Nouamane Tazi and Vaibhav Srivastav and Joshua Lochner and Hugo Larcher and Mathieu Morlon and Lewis Tunstall and Leandro von Werra and Thomas Wolf},
  journal={arXiv preprint arXiv:2504.05299},
  year={2025}
}

训练数据

SmolVLM2 最初使用了来自十个不同数据集的 330 万个样本进行训练，这些数据集包括 LlaVa Onevision、M4-Instruct、Mammoth、LlaVa Video 178K、FineVideo、VideoStar、VRipt、Vista-400K、MovieChat 和 ShareGPT4Video。以下图表概述了各模态的样本情况以及这些样本的来源。

各模态数据划分

数据类型	占比
图像	34.4%
文本	20.2%
视频	33.0%
多图像	12.3%

各模态细分数据集占比

文本数据集

数据集	占比
llava-onevision/magpie_pro_ft3_80b_mt	6.8%
llava-onevision/magpie_pro_ft3_80b_tt	6.8%
llava-onevision/magpie_pro_qwen2_72b_tt	5.8%
llava-onevision/mathqa	0.9%

多图像数据集

数据集	占比
m4-instruct-data/m4_instruct_multiimage	10.4%
mammoth/multiimage-cap6	1.9%

图像数据集

数据集	占比
llava-onevision/other	17.4%
llava-onevision/vision_flan	3.9%
llava-onevision/mavis_math_metagen	2.6%
llava-onevision/mavis_math_rule_geo	2.5%
llava-onevision/sharegpt4o	1.7%
llava-onevision/sharegpt4v_coco	1.5%
llava-onevision/image_textualization	1.3%
llava-onevision/sharegpt4v_llava	0.9%
llava-onevision/mapqa	0.9%
llava-onevision/qa	0.8%
llava-onevision/textocr	0.8%

视频数据集

数据集	占比
llava-video-178k/1-2m	7.3%
llava-video-178k/2-3m	7.0%
other-video/combined	5.7%
llava-video-178k/hound	4.4%
llava-video-178k/0-30s	2.4%
video-star/starb	2.2%
vista-400k/combined	2.2%
vript/long	1.0%
ShareGPT4Video/all	0.8%

安全张量

模型规模：22.5 亿参数
张量类型：F32
推理提供方：图像 - 文本 - 文本

模型树

基础模型：HuggingFaceTB/SmolLM2-1.7B
量化模型：HuggingFaceTB/SmolLM2-1.7B-Instruct
量化模型：HuggingFaceTB/SmolVLM-Instruct
微调模型：本模型（微调自 1 个模型）

训练所用数据集

HuggingFaceM4/the_cauldron
lmms-lab/LLaVA-OneVision-Data
Mutonix/Vript

模型集合

SmolVLM2 📺 史上最小的视频语言模型 🤏🏻

模型能力

参观大皇宫的旅行小贴士

输入图片：

输入提示：我计划参观这座寺庙，请给我一些旅行小贴士。
回答：大皇宫是曼谷最著名的地标建筑，其令人惊叹的建筑风格和深厚的历史底蕴值得一游。以下是这座宫殿的一些亮点：

主体建筑：位于建筑群中心的主体建筑，每一寸都覆盖着带有传统泰国图案的精美瓷砖，包括龙、神话生物、花卉和几何形状等图案。屋顶设计精巧，多层瓷砖上装饰着金色装饰。
塔楼和尖顶：大皇宫内有几座塔楼，其中包括存放泰国文化和遗产展品的帕那空是贪玛叻国家博物馆塔楼。另一座著名的塔楼是瓦艾猜蒙空寺塔楼，在那里你可以看到描绘佛教神话场景的美丽壁画。
建筑风格：其建筑风格融合了东南亚常见的印度教和高棉风格元素。你会注意到像佛塔（圆顶结构）、莲花雕刻以及这些地区宗教建筑特有的华丽细节等元素。
参观体验：在探索大皇宫时，游客需要注意当局为保障安全制定的一些规定，例如某些区域内禁止拍照，室外禁止使用闪光灯。此外，旅游旺季可能会出现排队情况，所以如果你来这里旅行，请提前做好相应规划。
参观大皇宫的旅行小贴士
- 最佳参观时间：最佳参观时间可能是清晨日出前，此时气温明显下降，更便于四处走动。
- 交通方式：有公共交通可供选择，但可能无法直接到达大皇宫，建议乘坐出租车。
- 餐饮选择：大皇宫附近的餐饮设施不多，但当地街头小吃摊提供的美食十分美味。
- 着装指南：虽然不是强制性要求，但穿着传统泰国服装（纱笼）可以增加文化沉浸感。不过，短裤或长裤也是允许的，只要长度不超过膝盖。
- 安全措施：游客必须遵守指示牌，注意 “禁止拍照” 等限制区域。随身携带身份证件，以防万一。

遵循这些指南，你的旅行无疑会加深你对泰国丰富历史的理解，同时也能提升个人的旅行体验！

其他示例

问题：根据这幅图，严重干旱发生在哪里？
- 示例：2016 年极端天气事件示例：加拿大西部和美国创纪录的野火；西欧和中欧长时间的热浪，伊朗创下全国 53°C 的高温纪录；中国南方严重洪涝；摩洛哥和利比亚暴雨引发洪水；飓风马修袭击瓦努阿图；气旋帕姆摧毁海地，气旋导致也门大范围洪水；智利经历 50 多年来最干旱的 1 月，以及非洲东部和南部严重干旱。
- 回答：严重干旱发生在非洲东部和南部。

问题：发票的到期日和开具日期是什么时候？
- 示例：East Repair Inc. 发票，发票号码为 US-001，开票给 John Smith，送货地址为 3787 Pineview Drive Cambridge, MA 12210 ，发票日期为 2019 年 11 月 2 日，订单编号为 2312/2019，到期日为 2019 年 2 月 26 日。商品包括 1 套前后刹车线（单价 100 美元，总价 100 美元）、2 套新踏板臂（单价 15 美元，总价 30 美元）、3 小时人工（单价 5 美元，总价 15 美元）， subtotal 为 145 美元，销售税 6.25% 即 9.06 美元，总计 154.06 美元。
- 回答：到期日是 2019 年 2 月 26 日，发票日期是 2019 年 11 月 2 日。

架构

在 SmolVLM 的架构设计上，我们紧密参照了 Idefics3 的架构，甚至在 transformers 中使用了相同的实现方式。不过，SmolVLM 与 Idefics3 仍存在一些关键差异：

我们将语言主干从 Llama 3.1 8B 替换为 SmolLM2 1.7B。
相较于 Idefics3 通过像素重排策略将视觉信息压缩 4 倍，我们更激进地将其压缩了 9 倍，以此来更高效地压缩拼接后的视觉信息。
我们使用 384×384 的图像块，而非 364×364 的图像块。这是因为 384 能被 3 整除，这对于我们的像素重排策略的正常运行至关重要。为此，我们将视觉主干改为使用形状优化后的 SigLIP，其图像块大小为 384×384 像素，内部子块大小为 14×14 像素。

性能

基准测试

我们展示了在训练细节中提及的各项任务的基准测试结果。

模型	MMMU（验证集）	MathVista（测试迷你集）	MMStar（验证集）	DocVQA（测试集）	TextVQA（验证集）	所需最小 GPU 内存（GB）
SmolVLM	38.8	44.6	42.1	81.6	72.7	5.02
Qwen2-VL 2B	41.1	47.8	47.5	90.1	79.7	13.70
InternVL2 2B	34.3	46.3	49.8	86.9	73.4	10.52
PaliGemma 3B 448px	34.9	28.7	48.3	32.2	56.0	6.72
moondream2	32.4	24.3	40.3	70.5	65.2	3.87
MiniCPM-V-2	38.2	39.8	39.1	71.9	74.1	7.88
MM1.5 1B	35.8	37.2	0.0	81.0	72.5	NaN

内存

SmolVLM 在现有的 transformers 视觉语言模型中内存使用效率最高。这使得它能够在诸如笔记本电脑等设备上高效运行！如上图所示，在所有测试中使用相同的图像和文本提示，运行单张或两张输入图像推理时，每个模型的 GPU 内存使用量（以 GB 为单位）。SmolVLM 在图像编码方面的高效性内置于模型之中。SmolVLM 将每个 384×384 的图像块编码为 81 个 token。这使得 SmolVLM 在编码测试提示和单张图像时仅需 1200 个 token，而 Qwen2-VL 则需要 16000 个 token。这也解释了为什么 Qwen 和 InternVL 在处理两张图像时内存消耗大幅增加。相比之下，SmolVLM 和 PaliGemma 的内存消耗增长则要温和得多，因为它们采用了类似的方法。

吞吐量

SmolVLM 极小的内存占用意味着它在预填充模型和生成内容时所需的计算量要少得多。与 Qwen2-VL 相比，SmolVLM 的预填充吞吐量快 3.3 至 4.5 倍，生成吞吐量快 7.5 至 16 倍。

视频

鉴于 SmolVLM 具有长上下文能力，并且可以对模型内部的帧尺寸调整进行优化，我们探讨了它作为基本视频分析任务的可行选择的适用性，特别是在计算资源有限的情况下。

在评估 SmolVLM 的视频理解能力时，我们实现了一个简单的视频处理管道代码，从每个视频中提取多达 50 个均匀采样的帧，同时避免内部帧尺寸调整。这种简单的方法在 CinePile 基准测试中取得了令人惊讶的好成绩，得分达到 27.14%，该性能使该模型的表现介于 InternVL2 (2B) 和 Video LlaVa (7B) 之间。

定量结果与我们的定性测试相符，以 FineVideo 数据集中的一个示例来看：

问题：特写镜头中显示了什么？
回答：特写镜头中，厨房台面上有亨氏番茄酱瓶、蜂蜜瓶、酱油瓶和大蒜。

问题：描述视频中发生的事情。
回答：视频显示一名男子在厨房做饭。他穿着黑色衬衫和黑色围裙。他站在柜台前，手里拿着一瓶亨氏番茄酱、一瓶蜂蜜、酱油和一碗蒜末。

虽然在第二个问题中，我们发现 SmolVLM 在时间理解方面存在一些局限性（厨师是依次指向每种食材，而不是同时指向 / 拿着所有食材），但它展现出了出色的场景理解和物体识别能力。

VLMEvalKit 集成

我们将 SmolVLM 与 VLMEvalKit 进行了集成，以便在更多基准测试中轻松进行评估。

通过运行以下命令，你可以评估 SmolVLM 或你微调后的 SmolVLM 模型：

python run.py --data <基准测试名称> --model SmolVLM --work-dir <输出目录>

例如，要在 MMMU 开发验证集和 MathVista 迷你测试集上进行评估，并将结果存储在名为 smol 的文件夹中，可以使用以下命令：

python run.py --data MMMU_DEV_VAL MathVista_MINI --model SmolVLM --work-dir smol

在 transformers 中使用 SmolVLM

你可以使用 transformers 中的Auto类轻松加载 SmolVLM。在底层，该模型和处理器映射到与 Idefics3 相同的实现。

from transformers import AutoProcessor, AutoModelForVision2Seq
import torch
DEVICE = "cuda" if torch.cuda.is_available() else "cpu"

processor = AutoProcessor.from_pretrained("HuggingFaceTB/SmolVLM-Instruct")
model = AutoModelForVision2Seq.from_pretrained("HuggingFaceTB/SmolVLM-Instruct",
                                                torch_dtype=torch.bfloat16,
                                                _attn_implementation="flash_attention_2" if DEVICE == "cuda" else "eager").to(DEVICE)

图像和文本可以任意交错，并且你可以传入多张图像。以下是如何使用聊天模板并将格式化后的输入传递给处理器的示例：

使用预处理后的输入开始生成内容，并对生成的输出进行解码：

# 生成输出
generated_ids = model.generate(**inputs, max_new_tokens=500)
generated_texts = processor.batch_decode(
    generated_ids,
    skip_special_tokens=True,
)

print(generated_texts[0])

训练细节

数据集

首先，我们需要对 SmolLM2 进行训练以扩展其上下文，这部分内容将在下一小节讨论。在得到具有长上下文的 SmolLM2 之后，我们使用与训练 Idefics3 相同的数据来训练 SmolVLM。主要使用的数据集是 Cauldron 和 Docmatix。我们使用的完整数据集列表可在此处查看。数据集涵盖的任务类型包括纯文本通用指令、算术计算（17%）、截图转代码（1%）、图像字幕生成（18%）、推理、逻辑、数学和几何（13%）、真实世界视觉问答（8%）、图表 / 图形理解（11%）、OCR、文档理解、文本转录（25%）、表格理解（8%）。

上下文扩展

SmolLM2 的预训练上下文窗口对于视觉语言模型来说是不够的。图像会被编码成许多 token，并且我们希望支持多张图像。为了解决这个问题，我们按照 “基于旋转位置嵌入（RoPE）的外推缩放定律” 中的指导，将 RoPE 的基础值从 10000 增加到 273000，从而将上下文窗口扩展到 16000 个 token。我们在长上下文和短上下文数据集的混合数据上对模型进行微调。对于长上下文数据集，我们使用了 Dolma 数据集中的 “书籍” 子集（主要来自古登堡计划）和来自 The Stack 的包含 8000 多个 token 的代码文档，它们分别占最终混合数据的 20%。对于短上下文数据集，我们精简了原始 SmolLM2 的预训练混合数据，使其包含 20% 的 FineWeb-Edu、20% 的 DCLM，以及 20% 我们即将发布的数学数据集。在上下文扩展过程中，我们对数学数据集进行了上采样，以缓解在 GSM8k 任务上观察到的性能下降问题。所有实验均使用 EasyContext 存储库来实现。

检查点选择

在训练过程中，我们每 25 个优化步骤保存一次检查点，这样我们就可以在训练的不同阶段评估模型状态，并在必要时恢复模型。由于训练时间越长并不一定意味着性能越好，这种做法对于确定最优的模型版本至关重要。我们在多个视觉语言基准测试中评估模型性能，并根据每个基准测试的重要性为其分配权重。核心基准测试包括以下内容：

通用多模态理解（MMMU 和 MMStar），这是最全面的基准测试。
基于文档和文本的视觉问答（DocVQA 和 TextVQA）
数学推理（MathVista）
图表理解（AI2D）

为了选择最优的检查点，我们通过组合这些基准测试并手动为其分配不同权重，创建了一个单一的评估指标，以反映它们在评估模型能力方面的相对重要性。我们使用这个单一指标来选择最佳的检查点。通常情况下，随着训练的进行，模型在大多数基准测试中的表现会越来越好，但在 DocVQA 上的相对性能会显著下降。

微调

你可以使用 transformers 对 SmolVLM 进行微调，并使用 TRL 应用对齐技术。

我们提供了一个笔记本，用于在 VQAv2 数据集上对 SmolVLM 进行微调，你可以选择使用低秩自适应（LoRA）、QLoRA 或全量微调。在笔记本中，你可以找到一些节省更多内存的技巧，并且可以使用更大的批量大小，以便在消费级 GPU（如 L4）上进行训练。通过使用 QLoRA 进行 8 位加载、梯度检查点技术和批量大小为 4 的设置，我们可以在 L4 上进行微调，此时大约消耗 16GB 的 VRAM。这使得你可以使用 Colab 对

您可使用 Transformers 库对视频数据进行微调。我们已在 Colab 环境演示了基于VideoFeedback 数据集对 5 亿参数模型的微调流程。由于模型较小，推荐使用全参数微调而非 QLoRA/LoRA (但可在 cB 变体尝试 QLoRA)。完整教程请参考微调笔记。

VideoFeedback 数据集 https://hf.co/datasets/TIGER-Lab/VideoFeedback
微调笔记 https://github.com/huggingface/smollm/blob/main/vision/finetuning/SmolVLM2_Video_FT.ipynb

官方文档

概述

SmolVLM2 是对 Idefics3 模型的改编，主要有两个不同之处：

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

使用提示

输入图像会通过上采样（如果启用了调整大小）或按原始分辨率进行处理。调整大小的行为取决于两个参数：do_resize和size。
视频不应进行上采样。
如果do_resize设置为True，模型会将图像调整大小，使最长边默认达到 4512 像素。默认的调整大小行为可以通过向size参数传递一个字典来自定义。例如，{"longest_edge": 4512}是默认设置，但如果需要，你可以将其更改为不同的值。

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

python

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

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

此模型由 orrzohar 贡献。

使用示例

单媒体推理

该模型可以接受图像和视频作为输入，但每次应仅使用其中一种模态。以下是示例代码。

python

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)


# 视频
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])

批量混合媒体推理

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

python

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"
)

# 第一张图像的对话
conversation1 = [
    {
        "role": "user",
        "content": [
            {"type": "image", "path": "/path/to/image.jpg"},
            {"type": "text", "text": "Describe this image."}
        ]
    }
]

# 包含两张图像的对话
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?"}
        ]
    }
]

# 纯文本对话
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

python

class transformers.SmolVLMConfig(
    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）：“图像” 标记的 ID。
tie_word_embeddings（bool，可选，默认值为False）：是否将词嵌入与标记嵌入绑定。
vision_config（IdeficsVisionConfig或dict，可选，默认值为IdeficsVisionConfig）：用于视觉塔的自定义视觉配置或字典。
text_config（PretrainedConfig或dict，可选，默认值为LlamaConfig）：用于文本模型的自定义文本配置或字典。
scale_factor（int，可选，默认值为 2）：图像编码器的缩放因子。
pad_token_id（int，可选，默认值为 128002）：填充标记的 ID。

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

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

示例：

python

>>> from transformers import SmolVLMModel, SmolVLMConfig
>>> # 初始化配置
>>> configuration = SmolVLMConfig()
>>> # 根据配置初始化模型
>>> model = SmolVLMModel(configuration)
>>> # 访问模型配置
>>> configuration = model.config

SmolVLMVisionConfig

python

class transformers.SmolVLMVisionConfig(
    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）：每个补丁的大小（分辨率）。
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）：注意力概率的辍学率。
initializer_range（float，可选，默认值为 0.02）：用于初始化所有权重矩阵的截断正态初始化器的标准差。

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

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

示例：

python

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

>>> # 使用google/siglip-so400m-patch14-384风格的配置初始化SmolVLMVisionConfig
>>> configuration = SmolVLMVisionConfig()

>>> # 使用google/siglip-so400m-patch14-384风格的配置初始化SmolVLMVisionTransformer（随机权重）
>>> model = SmolVLMVisionTransformer(configuration)

>>> # 访问模型配置
>>> configuration = model.config

Idefics3VisionTransformer

python

class transformers.SmolVLMVisionTransformer(
    config: SmolVLMVisionConfig
)

参数

config（SmolVLMVisionConfig）：包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。请查看from_pretrained()方法以加载模型权重。

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

该模型也是 PyTorch torch.nn.Module的子类。像使用常规 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与一般用法和行为相关的内容。

SmolVLMModel

python

class transformers.SmolVLMModel(
    config: SmolVLMConfig
)

参数

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

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

该模型也是 PyTorch torch.nn.Module的子类。像使用常规 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与一般用法和行为相关的内容。

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

forward

python

(
    input_ids: typing.Optional[torch.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
)

参数

SmolVLMModel的forward方法重写了__call__特殊方法。虽然前向传递的方法需要在此函数中定义，但之后应该调用Module实例而不是这个函数，因为前者会处理运行前处理和后处理步骤，而后者会忽略这些步骤。

SmolVLMForConditionalGeneration

python

class transformers.SmolVLMForConditionalGeneration(
    config
)

参数

forward

python

(
    input_ids: typing.Optional[torch.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 or tuple(torch.FloatTensor)

参数

返回值

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

SmolVLMForConditionalGeneration的forward方法重写了__call__特殊方法。虽然前向传递的方法需要在此函数中定义，但之后应该调用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

>>> # 注意，也可以将图像URL（而不是实际的PIL图像）传递给处理器
>>> 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")

>>> # 创建输入
>>> 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)

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

>>> print(generated_texts)

SmolVLMImageProcessor

python

class transformers.SmolVLMImageProcessor(
    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
)

参数

构建一个 SmolVLM 图像处理器。

preprocess

python

(
    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[str, transformers.image_utils.ChannelDimension, NoneType] = None
)

参数

预处理一批图像。

SmolVLMProcessor

python

class transformers.SmolVLMProcessor(
    image_processor,
    tokenizer = None,
    image_seq_len: int = 169,
    chat_template: typing.Optional[str] = None,
    **kwargs
)

参数

构建一个 SmolVLM 处理器，它将 Llama 分词器和 SmolVLM 图像处理器包装成一个单一的处理器。

SmolVLM 处理器提供了 SmolVLMImageProcessor 和SmolVLMTokenizerFast的所有功能。有关更多信息，请查看call()和decode()的文档字符串。

call

python

(
    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.ndarray']], list[list['torch.Tensor']]] = None,
    **kwargs: typing_extensions.Unpack[transformers.models.smolvlm.processing_smolvlm.SmolVLMProcessorKwargs]
)

参数

处理输入提示并返回一个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  # 为简化示例，强制设为False
>>> 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>']

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，则可选地仅输入最后一个decoder_input_ids（请参见past_key_values）。如果要更改填充行为，应阅读modeling_opt._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参见论文中的图 1。1 表示头部未被掩码，0 表示头部被掩码。
position_ids（torch.LongTensor，形状为(batch_size, sequence_length)，可选）：每个输入序列标记在位置嵌入中的位置索引。在[0, config.n_positions - 1]范围内选择。什么是位置 ID？
past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）：长度为config.n_layers的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（torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）：或者，不传递input_ids，你可以选择直接传递嵌入表示。如果你想比模型的内部嵌入查找矩阵更灵活地控制如何将input_ids索引转换为相关向量，这将很有用。
pixel_values（torch.FloatTensor，形状为(batch_size, num_channels, image_size, image_size)）：与输入图像对应的张量。像素值可以使用[AutoImageProcessor](/docs/transformers/main/en/model_doc/auto#transformers.AutoImageProcessor)获得。有关详细信息，请参见[CLIPImageProcessor.__call__()](/docs/transformers/main/en/model_doc/glpn#transformers.GLPNFeatureExtractor.__call__)（LlavaProcessor使用CLIPImageProcessor处理图像）。
pixel_attention_mask（torch.Tensor，形状为(batch_size, image_size, image_size)，可选）：用于避免在填充像素索引上执行注意力的掩码。
image_hidden_states（torch.FloatTensor，形状为(batch_size, num_channels, image_size, image_size)）：图像编码器在模态投影后的隐藏状态。
use_cache（bool，可选）：如果设置为True，将返回past_key_values键值状态，可用于加速解码（见past_key_values）。
output_attentions（bool，可选）：是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
output_hidden_states（bool，可选）：是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
return_dict（bool，可选）：是否返回ModelOutput而不是普通元组。
cache_position（torch.LongTensor，形状为(sequence_length)，可选）：描绘输入序列标记在序列中的位置的索引。与position_ids相反，此张量不受填充的影响。它用于在正确的位置更新缓存并推断完整的序列长度。
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，则可选地仅输入最后一个decoder_input_ids（请参见past_key_values）。如果要更改填充行为，应阅读modeling_opt._prepare_decoder_attention_mask并根据需要进行修改。有关默认策略的更多信息，请参见论文中的图 1。1 表示头部未被掩码，0 表示头部被掩码。
position_ids（torch.LongTensor，形状为(batch_size, sequence_length)，可选）：每个输入序列标记在位置嵌入中的位置索引。在[0, config.n_positions - 1]范围内选择。什么是位置 ID？
past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）：长度为config.n_layers的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（torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选）：或者，不传递input_ids，你可以选择直接传递嵌入表示。如果你想比模型的内部嵌入查找矩阵更灵活地控制如何将input_ids索引转换为相关向量，这将很有用。
pixel_values（torch.FloatTensor，形状为(batch_size, num_channels, image_size, image_size)）：与输入图像对应的张量。像素值可以使用[AutoImageProcessor](/docs/transformers/main/en/model_doc/auto#transformers.AutoImageProcessor)获得。有关详细信息，请参见[CLIPImageProcessor.__call__()](/docs/transformers/main/en/model_doc/glpn#transformers.GLPNFeatureExtractor.__call__)（LlavaProcessor使用CLIPImageProcessor处理图像）。
pixel_attention_mask（torch.Tensor，形状为(batch_size, image_size, image_size)，可选）：用于避免在填充像素索引上执行注意力的掩码。
image_hidden_states（torch.FloatTensor，形状为(batch_size, num_channels, image_size, image_size)）：图像编码器在模态投影后的隐藏状态。
use_cache（bool，可选）：如果设置为True，将返回past_key_values键值状态，可用于加速解码（见past_key_values）。
output_attentions（bool，可选）：是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
output_hidden_states（bool，可选）：是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
return_dict（bool，可选）：是否返回ModelOutput而不是普通元组。
cache_position（torch.LongTensor，形状为(sequence_length)，可选）：描绘输入序列标记在序列中的位置的索引。与position_ids相反，此张量不受填充的影响。它用于在正确的位置更新缓存并推断完整的序列长度。
labels（torch.LongTensor，形状为(batch_size, sequence_length)，可选）：用于计算掩码语言建模损失的标签。索引应在[0, ..., config.vocab_size]或model.image_token_id（其中model是你的SmolVLMForConditionalGeneration实例）中。设置为model.image_token_id的索引的标记将被忽略（掩码），损失仅针对标签在[0, ..., config.vocab_size]中的标记计算。
loss（torch.FloatTensor，形状为(1,)，可选，当提供labels时返回）：语言建模损失（用于下一个标记预测）。
logits（torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)）：语言建模头的预测分数（在 SoftMax 之前每个词汇表标记的分数）。
past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）：长度为config.n_layers的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)）。由视觉编码器产生的模型的图像隐藏状态。
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"]×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参数覆盖。
image_std（float或List[float]，可选，默认值为IDEFICS_STANDARD_STD）：如果对图像进行归一化，则使用此标准差。它可以是一个浮点数，或者是一个长度与图像通道数相同的浮点数列表。可以在preprocess方法中通过image_std参数覆盖。
do_pad（bool，可选，默认值为True）：是否将图像填充到批次中最大的高度、宽度以及每个样本中的图像数量，以便返回的张量形状为(batch_size, max_num_images, num_channels, max_height, max_width) 。
images（ImageInput）：要预处理的图像列表。
do_convert_rgb（bool，可选，默认值为self.do_convert_rgb）：是否将图像转换为 RGB 格式。
do_resize（bool，可选，默认值为self.do_resize）：是否调整图像大小。
size（Dict[str, int]，可选，默认值为self.size）：调整大小后的图像大小，最长边调整后保持输入宽高比。
resample（int，可选，默认值为self.resample）：如果调整图像大小，使用的重采样滤波器，它可以是PILImageResampling枚举中的一个值，仅当do_resize设置为True时有效。
do_image_splitting（bool，可选，默认值为self.do_image_splitting）：是否将图像分割为与原始图像连接的子图像，子图像被分割成大小为max_image_size["height"]×max_image_size["width"]的补丁。
max_image_size（Dict，可选，默认值为self.max_image_size）：图像的最大分辨率，如果图像大于此尺寸，将被分割成补丁。
do_rescale（bool，可选，默认值为self.do_rescale）：是否重新缩放图像。
rescale_factor（float，可选，默认值为self.rescale_factor）：如果do_rescale设置为True，用于重新缩放图像的缩放因子。
do_normalize（bool，可选，默认值为self.do_normalize）：是否对图像进行归一化。
image_mean（float或List[float]，可选，默认值为self.image_mean）：用于归一化的图像均值，仅当do_normalize设置为True时有效。
image_std（float或List[float]，可选，默认值为self.image_std）：用于归一化的图像标准差，仅当do_normalize设置为True时有效。
do_pad（bool，可选，默认值为self.do_pad）：是否将图像填充到批次中的最大高度和宽度。
return_tensors（str或TensorType，可选）：返回的张量类型，可以是以下值之一：
- 未设置：返回np.ndarray列表。
- TensorType.TENSORFLOW或'tf'：返回tf.Tensor类型的批次。
- TensorType.PYTORCH或'pt'：返回torch.Tensor类型的批次。
- TensorType.NUMPY或'np'：返回np.ndarray类型的批次。
- TensorType.JAX或'jax'：返回jax.numpy.ndarray类型的批次。
return_row_col_info（bool，可选，默认值为False）：是否返回分割图像的行数和列数，这用于SmolVLMProcessor根据行数和列数生成提示字符串。
data_format（ChannelDimension或str，可选，默认值为ChannelDimension.FIRST）：输出图像的通道维度格式，可以是以下值之一：
- "channels_first"或ChannelDimension.FIRST：图像格式为(num_channels, height, width)。
- "channels_last"或ChannelDimension.LAST：图像格式为(height, width, num_channels)。
- 未设置：使用输入图像的通道维度格式。
input_data_format（ChannelDimension或str，可选）：输入图像的通道维度格式，如果未设置，则从输入图像推断，可以是以下值之一：
- "channels_first"或ChannelDimension.FIRST：图像格式为(num_channels, height, width)。
- "channels_last"或ChannelDimension.LAST：图像格式为(height, width, num_channels)。
- "none"或ChannelDimension.NONE：图像格式为(height, width)。
image_processor（SmolVLMImageProcessor）：SmolVLMImageProcessor的一个实例，图像处理器是必需的输入。
tokenizer（PreTrainedTokenizerBase，可选）：PreTrainedTokenizerBase的一个实例，它应该与模型的文本模型相对应，分词器是必需的输入。
image_seq_len（int，可选，默认值为 169）：图像序列的长度，即输入中每个图像的标记数量。此参数用于根据输入提示和图像标记构建字符串，应与模型使用的值匹配。它的计算方式为：image_seq_len = int(((image_size // patch_size) ** 2) / (scale_factor ** 2))。
chat_template（str，可选）：一个 Jinja 模板，用于将聊天中的消息列表转换为可分词的字符串。
images（PIL.Image.Image、np.ndarray、torch.Tensor、List[PIL.Image.Image]、List[np.ndarray]、List[torch.Tensor]，可选）：要准备的图像或图像批次。每个图像可以是 PIL 图像、NumPy 数组或 PyTorch 张量。如果类型为List[ImageInput]，则假定这是针对单个提示的，即批次大小为 1。
text（Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]]，可选）：要编码的序列或序列批次。每个序列可以是一个字符串或字符串列表（预分词字符串）。如果序列以字符串列表（预分词）的形式提供，则必须设置is_split_into_words=True（以消除与批次序列的歧义）。无论何时遇到图像标记<image>，它都会扩展为<fake_token_around_image> + <row_x_col_y> + <image> image_seq_len。
return_tensors（Union[str, TensorType]，可选）：如果设置，将返回特定框架的张量。有关更多信息，请参见PreTrainedTokenizerFast.call()。

apply_chat_template

python

(
    conversation: typing.Union[typing.List[transformers.models.smolvlm.processing_smolvlm.Conversation], typing.List[typing.List[transformers.models.smolvlm.processing_smolvlm.Conversation]]],
    add_generation_prompt: bool = False,
    tokenize: bool = True,
    padding: typing.Union[str, bool] = False,
    truncation: bool = True,
    max_length: typing.Optional[int] = None,
    return_tensors: typing.Union[str, transformers.utils.generic.TensorType, NoneType] = None,
    **kwargs
)

参数

conversation（Union[List[Conversation], List[List[Conversation]]]）：对话列表，其中每个对话是一个Conversation对象的列表，或者是对话列表的列表（表示批次）。每个Conversation对象是一个包含role（用户或助手）和content（文本、图像、视频）的字典。
add_generation_prompt（bool，可选，默认值为False）：是否在对话末尾添加生成提示。
tokenize（bool，可选，默认值为True）：是否对生成的字符串进行分词。
padding（Union[str, bool]，可选，默认值为False）：是否对输入进行填充。如果为True，将使用模型的pad_token进行填充。如果为字符串，必须是"longest"（将所有输入填充到批次中最长的输入长度）。
truncation（bool，可选，默认值为True）：是否对输入进行截断。如果为True，输入将被截断到max_length。
max_length（int，可选）：如果设置，输入将被截断到这个最大长度。如果未设置，将使用模型的max_position_embeddings。
return_tensors（Union[str, TensorType]，可选）：如果设置，将返回特定框架的张量。可以是'tf'（TensorFlow）、'pt'（PyTorch）、'np'（NumPy）或'jax'（JAX）。

将聊天模板应用于对话并返回编码后的输入。

示例：

python

from transformers import SmolVLMProcessor

processor = SmolVLMProcessor.from_pretrained("HuggingFaceM4/SmolVLM2-256M-Video-Instruct")
processor.image_processor.do_image_splitting = False  # 为简化示例，强制设为False

conversation = [
    {
        "role": "user",
        "content": [
            {"type": "image", "path": "path/to/image.jpg"},
            {"type": "text", "text": "Describe this image."}
        ]
    }
]

inputs = processor.apply_chat_template(
    [conversation],
    add_generation_prompt=True,
    tokenize=True,
    padding=True,
    truncation=True,
    max_length=512,
    return_tensors="pt"
)

print(inputs)

batch_decode

python

(
    sequences: typing.Union[torch.Tensor, numpy.ndarray, typing.List[int], typing.List[typing.List[int]]],
    skip_special_tokens: bool = True,
    clean_up_tokenization_spaces: bool = True,
    **kwargs
)

参数

sequences（Union[torch.Tensor, np.ndarray, List[int], List[List[int]]]）：要解码的标记序列或标记序列批次。
skip_special_tokens（bool，可选，默认值为True）：是否跳过特殊标记（如填充标记、开始和结束标记等）。
clean_up_tokenization_spaces（bool，可选，默认值为True）：是否清理标记化过程中引入的额外空格。

对一批标记序列进行解码并返回解码后的文本。

示例：

python

import torch
from transformers import SmolVLMProcessor

processor = SmolVLMProcessor.from_pretrained("HuggingFaceM4/SmolVLM2-256M-Video-Instruct")

generated_ids = torch.tensor([[123, 456, 789, 1000]])  # 示例生成的标记ID
decoded_texts = processor.batch_decode(
    generated_ids,
    skip_special_tokens=True,
    clean_up_tokenization_spaces=True
)

print(decoded_texts)

以上是对 SmolVLM 相关类、方法等的详细介绍，涵盖了模型配置、模型结构、输入处理、生成等方面的内容，可帮助开发者更好地理解和使用 SmolVLM 模型。