大模型实战指南（10）——多模态实战：让模型“看懂”图片和视频

auto_go2026-08-28 18:26

大模型实战指南（10）------多模态实战：让模型"看懂"图片和视频

这是《大模型实战指南》系列第十篇。前九篇拆完了大模型的文本能力栈（Token、上下文、采样、Embedding、Harness、微调、推理优化、RAG、Agent）。这一篇解决一个新问题：怎么让模型不只能读文字，还能看懂图片和视频。

你拍了一张会议白板的照片，丢给大模型，问"上面的待办事项有哪些"。2023 年，这事得三步走：先用 OCR 提取文字，再喂给模型整理，最后人工校对------漏字、错字、排版乱是常态。2026 年，你直接把照片丢给 GPT-5 或 DeepSeek V4 Vision，它一眼看完，不但认出了潦草的手写字，还自动按优先级排了序。

你给模型发了一张折线图，问"第三季度哪个月降幅最大"。它不是先 OCR 再理解------它直接"看"到了线条的走势，告诉你"9 月，环比下降 23%"。这不是文字到文字的翻译，这是像素到理解的直接跨越。

但这里有个问题：大模型天生只懂文字（Token），它压根不知道"像素"是什么。那一张图片是怎么变成模型能消化的 Token 的？模型怎么知道图片里的红色圆圈和旁边的文字标注是什么关系？视频更复杂------一帧一帧的图片加上时间维度，模型怎么理解"动"？

这一篇，拆透多模态大模型的核心：图片怎么变成 Token（ViT Patch Embedding）、图文怎么对齐（CLIP 对比学习）、VLM 三代架构怎么演进（从拼接到原生）、2026 年最新多模态模型横评，最后给你一个"让模型看图回答问题"的完整代码实战。

一、多模态到底是什么：不只是"加上图片"

1.1 从单模态到多模态

先搞清楚"模态"（Modality）这个词。模态就是信息的呈现形式------文字是一种模态，图像是一种模态，音频、视频、3D 模型各是一种模态。人类感知世界是多模态的：你看到朋友挥手（视觉），听到他说"嗨"（听觉），同时感受到他拍了拍你肩膀（触觉）------这些信息在你的大脑里融合成一个完整的理解。

传统的大语言模型（LLM）是单模态的------它只处理文字。你给它一张图片，它看不懂；你给它一段音频，它听不了。它的世界是纯文本的。

多模态大模型（Multimodal LLM，简称 MLLM，也叫视觉语言模型 VLM）就是要打破这个限制------让模型同时理解和生成多种模态的信息。其中最核心、应用最广泛的方向，就是视觉语言模型（Vision-Language Model），专注让模型"看懂"图片和视频。

1.2 多模态不是"OCR + LLM"

很多人对多模态的理解停留在"先用 OCR 把图片里的字提取出来，再喂给大模型"。这只是"伪多模态"------模型处理的仍然是提取出来的文字，它并没有真正"看"图片。

真正的多模态是什么样的？你给模型一张表情包------图片上是一只柴犬坐在火边，配文"this is fine"。OCR 只能提取出"this is fine"这四个字，完全丢失了图片的视觉语义。但多模态模型能看到那只狗、看到火焰、理解图片的讽刺意味，然后告诉你"这是一个表达'面对混乱仍假装一切正常'的梗图"。

再比如，你给模型一张折线图。OCR 只能提取坐标轴上的数字和标签，但无法理解线条的走势。多模态模型直接看到线条的起伏，能回答"趋势是上升还是下降""哪个点异常"这类需要视觉理解的问题。

真正的多模态是像素级理解，不是文字中转。

1.3 多模态的三种基本任务

任务类型 输入 输出 典型场景
图像理解 图片 + 问题 文字描述/答案 看图问答、图表分析、文档解析
图像生成 文字描述 图片 文生图（DALL-E、Midjourney、Sora）
跨模态检索 图片或文字 相似图片或文字 以图搜图、图文匹配

这篇主要讲第一种------图像理解（VLM），因为它是当前多模态落地最广泛的场景，也是大模型接入视觉能力的核心技术路线。图像生成涉及扩散模型（Diffusion），是另一个技术栈，后续系列会单独讲。

二、图片怎么变成 Token：ViT 与 Patch Embedding

2.1 大模型的"语言障碍"

大语言模型天生只懂 Token------文字被切分成一个个 Token，每个 Token 是一个高维向量，模型通过注意力机制理解 Token 之间的关系。图片是像素矩阵------一张 224x224 的彩色图片就是 224 x 224 x 3 = 150528 个数字。怎么把这 15 万个数字变成模型能消化的 Token？

直接把每个像素当一个 Token？不行。15 万个 Token 远超模型的上下文窗口，而且单像素几乎不携带语义信息------一个红色像素既可能是苹果的一部分，也可能是消防栓的一部分。

2020 年，Google 在论文"An Image is Worth 16x16 Words"中给出了答案------这就是 ViT（Vision Transformer）。

2.2 ViT 的核心思想：把图片切成 Patch

ViT 的思路极其简洁：把图片切成固定大小的小块（Patch），每个 Patch 当一个"词"。

具体过程分四步：

第 1 步：切片。 把一张 H x W 的图片切成 N 个 P x P 的小块。比如一张 224 x 224 的图片，切成 16 x 16 的 Patch，就得到 (224/16) x (224/16) = 14 x 14 = 196 个 Patch。每个 Patch 是一个 16 x 16 x 3 = 768 维的向量。

第 2 步：展平。 把每个 Patch 的三维矩阵展平成一维向量。16 x 16 x 3 = 768，所以每个 Patch 变成一个 768 维的向量。

第 3 步：线性投影。 用一个线性层把这个 768 维向量映射到模型的嵌入维度（比如也是 768 维）。这一步本质是一次矩阵乘法------相当于全连接层，把像素值"翻译"成模型能理解的特征表示。

第 4 步：加位置编码。 Patch 丢掉了空间位置信息（模型不知道第一个 Patch 在左上角还是右下角）。所以给每个 Patch 加一个可学习的位置嵌入（Position Embedding），让模型知道"这个 Patch 来自图片的哪个位置"。

做完这四步，一张图片就变成了 196 个 Token------和 196 个文字 Token 没有本质区别，都可以直接喂给 Transformer 处理。

2.3 用代码理解 Patch Embedding

用 PyTorch 写一个最简版本的 Patch Embedding，直观看它干了什么：

python 复制代码 
import torch
import torch.nn as nn

class PatchEmbedding(nn.Module):
    """将图片切分为 Patch 并嵌入------ViT 的第一步"""

    def __init__(self, img_size=224, patch_size=16, in_channels=3, embed_dim=768):
        super().__init__()
        self.num_patches = (img_size // patch_size) ** 2  # 196 个 Patch
        # 用一个 2D 卷积同时完成"切片 + 展平 + 线性投影"
        # kernel_size=patch_size, stride=patch_size 等价于切成 Patch 再展平
        self.proj = nn.Conv2d(in_channels, embed_dim,
                              kernel_size=patch_size, stride=patch_size)
        # 可学习的位置编码
        self.pos_embed = nn.Parameter(torch.randn(1, self.num_patches + 1, embed_dim))

    def forward(self, x):
        # x 形状: [batch, 3, 224, 224]
        x = self.proj(x)           # -> [batch, 768, 14, 14]
        x = x.flatten(2)           # -> [batch, 768, 196]
        x = x.transpose(1, 2)      # -> [batch, 196, 768]
        x = x + self.pos_embed[:, :x.size(1), :]  # 加位置编码
        return x                   # 196 个 Token，每个 768 维

# 测试
patch_embed = PatchEmbedding()
dummy_image = torch.randn(1, 3, 224, 224)  # 一张假图片
tokens = patch_embed(dummy_image)
print(f"输入: 图片 [1, 3, 224, 224]")
print(f"输出: {tokens.shape[1]} 个 Token, 每个 {tokens.shape[2]} 维")
# 输出: 196 个 Token, 每个 768 维

关键代码就一行：nn.Conv2d(3, 768, kernel_size=16, stride=16)。这个卷积操作的 kernel 大小和步长都等于 Patch 大小，所以它把图片切成 14 x 14 的网格，每个网格经卷积后变成一个 768 维向量------等价于"切片 + 展平 + 线性投影"三步合一。

2.4 ViT 的完整流程

Patch Embedding 只是第一步。完整的 ViT 流程是：

  1. Patch Embedding：图片 -> 196 个 Token
  2. 加 CLS Token：在序列开头加一个特殊的分类 Token，它的工作是"吸收全局信息"，最终输出用于分类等任务
  3. Transformer Encoder：196 + 1 = 197 个 Token 经过 L 层 Transformer Encoder（多头自注意力 + MLP + 残差连接 + LayerNorm），Token 之间通过注意力交换信息
  4. 输出：取 CLS Token 的输出作为整张图片的特征表示

ViT 的伟大之处在于它证明了：Transformer 不只能处理文字，也能处理图片------只要把图片变成 Token 序列。 这为后续所有多模态工作铺平了道路。

三、CLIP：教模型把图片和文字"对齐"

3.1 一个新问题：Patch Token 和文字 Token 不在同一个"世界"

ViT 把图片变成了 Token，但这里有个关键问题：图片 Token 和文字 Token 虽然都是向量，但它们在高维空间里说的是"不同的语言"。

打个比方：文字 Token 的向量空间里，"猫"和"狗"距离很近（都是动物），"猫"和"汽车"距离很远。图片 Token 的向量空间里，一张猫的照片和一张狗的照片距离近，猫的照片和汽车照片距离远。两个空间的结构类似，但坐标系不同------就像中文和英文都描述同一个世界，但"猫"和"cat"的字符串完全不同。

要让大语言模型理解图片，就必须把图片特征"翻译"到文字的向量空间里。这就是 CLIP 要解决的问题。

3.2 CLIP 的核心思想：对比学习

CLIP（Contrastive Language-Image Pre-training）由 OpenAI 在 2021 年提出，核心思想非常直觉：让配对的图文在向量空间里靠近，不配对的远离。

训练过程：

  1. 编码图片：用 ViT 把图片编码成一个向量
  2. 编码文字：用文本 Transformer 把文字编码成一个向量
  3. 计算相似度：算所有图文对之间的余弦相似度，形成一个 N x N 矩阵
  4. 对比损失：对角线上的元素（配对的图文）应该相似度最高，非对角线（不配对的）应该相似度低

形象理解：一个 batch 里有 4 对图文（猫图+"一只猫"、狗图+"一只狗"、车图+"一辆车"、船图+"一艘船"）。CLIP 要让"猫图"的向量跟"一只猫"的文字向量距离最近，跟其他三个文字向量距离远。经过海量图文对训练后，图片和文字就被"对齐"到了同一个向量空间。

3.3 CLIP 为什么重要

CLIP 的训练数据量级是 4 亿对图文（从互联网爬取），训练完之后它获得了两项关键能力：

零样本分类：你不需要训练分类器，直接给 CLIP 一张图片和几个候选文本（"一只猫""一只狗""一辆车"），它就能算出图片跟哪个文本最像，完成分类。这在之前需要标注数据 + 微调才能做到。

通用视觉编码器：CLIP 的视觉编码器（ViT）学会了一个"通用的视觉特征空间"，可以直接拿来给下游任务用。几乎所有后来的多模态模型（LLaVA、Qwen-VL、GPT-4V）都用 CLIP 或其变体作为视觉编码器的基础。

3.4 从 CLIP 到 SigLIP-2：视觉编码器的进化

CLIP 的对比学习用的是 softmax 损失（InfoNCE），需要对整个 batch 做归一化。2023 年，Google 提出了 SigLIP（Sigmoid Loss for Language Image Pre-training），改用 sigmoid 损失------每个图文对独立判断"配不配"，不需要全 batch 归一化。好处是：训练更稳定、batch size 可以更小、效果更好。

2025 年 2 月，Google 发布 SigLIP-2，进一步优化了训练数据和策略。一项 2026 年的视觉编码器综述研究指出：400M 参数的 SigLIP-2 在多数 VLM 基准上优于 5.9B 参数的 InternViT-6B------训练方法远比编码器参数量缩放更重要。SigLIP-2 已成为 2025-2026 年新一代 VLM（如 Qwen3-VL）的首选视觉编码器。

3.5 用代码理解对比学习

python 复制代码 
import torch
import torch.nn as nn
import torch.nn.functional as F

class CLIP(nn.Module):
    """CLIP 核心逻辑的简化版本"""

    def __init__(self, embed_dim=512):
        super().__init__()
        # 图像编码器（实际用 ViT，这里简化为线性层）
        self.image_encoder = nn.Linear(768, embed_dim)
        # 文本编码器（实际用 Transformer，这里简化为线性层）
        self.text_encoder = nn.Linear(512, embed_dim)
        # 温度参数（可学习，控制相似度分布的锐度）
        self.logit_scale = nn.Parameter(torch.ones([]) * 4.0)

    def forward(self, image_features, text_features):
        # 编码到共享空间
        image_embeds = self.image_encoder(image_features)   # [batch, 512]
        text_embeds = self.text_encoder(text_features)       # [batch, 512]

        # L2 归一化（让相似度计算更稳定）
        image_embeds = F.normalize(image_embeds, dim=-1)
        text_embeds = F.normalize(text_embeds, dim=-1)

        # 计算余弦相似度矩阵 [batch, batch]
        logit_scale = self.logit_scale.exp()
        logits = logit_scale * image_embeds @ text_embeds.t()

        # 对比损失：对角线应该最大
        labels = torch.arange(logits.size(0))
        loss_i = F.cross_entropy(logits, labels)      # 图 -> 文
        loss_t = F.cross_entropy(logits.t(), labels)   # 文 -> 图
        loss = (loss_i + loss_t) / 2

        return loss

# 测试
clip = CLIP()
fake_images = torch.randn(4, 768)  # 4 张图片的特征
fake_texts = torch.randn(4, 512)   # 4 段文本的特征
loss = clip(fake_images, fake_texts)
print(f"对比损失: {loss.item():.4f}")
# 训练的目标就是让这个 loss 越来越小------配对的图文越来越近

核心就是 image_embeds @ text_embeds.t() 这一步------算出 N x N 的相似度矩阵，然后让对角线（配对的）最大。就这么简单。

四、VLM 三代架构演进：从"拼接"到"原生"

理解了 ViT（图片变 Token）和 CLIP（图文对齐），现在可以看 VLM 的完整架构了。当前主流 VLM 的架构演进可以清晰地分为三代。

4.1 第一代：拼接式（Bridge / Connector 范式）

代表模型：LLaVA（2023.04）、BLIP-2（2023.01）、MiniGPT-4

核心思路是"搭桥"------视觉编码器和语言模型是两个独立模块，中间用一个连接器（Connector）把视觉特征"翻译"成语言模型能懂的 Token。

复制代码 
图片 -> ViT 编码 -> 视觉特征 -> 连接器 -> 视觉 Token -> LLM -> 文字输出

三种主流连接器路线：

连接器类型 原理 代表模型 特点
线性投影 / MLP 用全连接层直接映射 LLaVA 最简单，参数少，效果出奇地好
Q-Former 用可学习 Query 提取视觉特征 BLIP-2 压缩视觉 Token 数量，但结构复杂
Cross-Attention LLM 内部加交叉注意力层 Flamingo 视觉信息不进序列，通过注意力注入

LLaVA 的方案最"暴力"也最有效：视觉编码器用预训练好的 CLIP ViT，连接器就是一个 MLP（两层全连接层），把视觉特征映射到 LLM 的词嵌入空间。然后把这些视觉 Token 和文字 Token 拼在一起，喂给 LLM 处理。

BLIP-2 的 Q-Former 更精巧：用一组可学习的 Query Token 通过交叉注意力从视觉特征中"提取"信息，把几百个视觉 Token 压缩成几十个。好处是 LLM 的输入更短、推理更快；坏处是结构更复杂、压缩可能丢信息。

第一代架构的局限：视觉和语言是两个独立模块，连接器只是一个"翻译层"。视觉信息在连接器处被压缩为固定粒度，LLM 无法根据任务需要动态决定关注图片的哪些细节。高分辨率图片（如文档、图表）需要切成更多 Patch，Token 数量爆炸，直接撑爆上下文窗口。

4.2 第二代：深度融合（Deep Fusion 范式）

代表模型：Qwen3-VL（2025.09）、InternVL 2.5

第二代架构不再把连接器当简单的"翻译层"，而是让视觉信息在 LLM 内部多层次注入。

以 Qwen3-VL 为代表，核心技术叫 DeepStack------从 ViT 编码器的不同层提取特征，分别注入 LLM 的不同层。不是只在输入端拼接一次，而是在 LLM 处理过程中持续注入视觉信息。

为什么需要 DeepStack？想象你看一份复杂的表格------你不是先"看完整个表格"再去理解，而是看一行理解一行，边看边理解。DeepStack 做的就是让 LLM "边看边理解"------浅层视觉特征（纹理、颜色）注入 LLM 浅层，深层视觉特征（语义、对象）注入 LLM 深层。

Qwen3-VL 的另一个关键创新是 Interleaved-MRoPE（交错多模态旋转位置编码）。传统的多模态位置编码把隐藏维度机械划分为时间、水平、垂直三个区间，导致频率资源错配------低频部分太多（浪费在不需要长距离位置的图像维度上），高频部分太少（不够编码细粒度空间关系）。Interleaved-MRoPE 把三个维度的频率交错分配，解决了频谱失衡问题，支持原生 256K 上下文窗口。

4.3 第三代：原生多模态（Native Multimodal）

代表模型：GPT-5（2025.08）、Gemini 2.5/3（2025-2026）

第三代是最彻底的方案：从训练第一天起，视觉和语言就在同一个网络里，不走"先编码再拼接"的老路。

原生多模态的核心区别：

维度 拼接式（第一代） 深度融合（第二代） 原生多模态（第三代）
训练方式 先训视觉编码器，再接 LLM 视觉编码器 + LLM 联合微调 从零开始联合训练
模态融合 输入端拼接 多层注入 共享底层表征
模态关系 桥接 深度交织 原生统一
信息损耗 连接器压缩 较少 几乎无

GPT-5 于 2025 年 8 月 8 日由 OpenAI 正式发布，原生支持文本、图像、音频的统一处理。Gemini 系列从一开始就设计为原生多模态架构。2026 年世界人工智能大会（WAIC 2026）上，多家厂商展示了原生多模态架构------行业共识是：从"拼接式多模态"走向"原生统一多模态"是核心技术趋势。

但要注意：原生多模态的训练成本极高（需要海量多模态数据 + 巨大算力），目前只有少数头部厂商能做。开源生态仍以第一代和第二代架构为主------Qwen3-VL 的 DeepStack 方案在效果上已经非常接近原生多模态，但训练成本可控，是当前开源社区的主流选择。

4.4 高分辨率怎么处理：AnyRes 技术

第一代 VLM 的另一个痛点是分辨率固定------通常只能处理 224x224 或 336x336 的图片。但你给模型的实际图片可能是一张 4K 截图或一份 A4 文档扫描件。直接缩放到 224x224 会丢失大量细节------文字变成模糊的色块，图表线条消失。

LLaVA 后来提出了 AnyRes（任意分辨率）技术：不缩放整张图片，而是把高分辨率图片切成多个子图块（Tile），每个子图块独立编码。比如一张 1024x1024 的图片切成 9 个 336x336 的子图块，每个子图块编码成 196 个 Token，总共 9 x 196 = 1764 个视觉 Token。虽然 Token 数量增加了，但细节保留了。

这是"用 Token 换精度"的经典 trade-off。后续模型（Qwen3-VL、InternVL）都采用了类似的动态分辨率方案，根据图片复杂度自动决定切成多少子图块。

五、连接器三种路线深度对比

理解了三代架构演进，你可能注意到一个反复出现的核心组件------连接器（Connector）。它是连接"视觉编码器"和"语言模型"的桥梁，它的设计直接决定了 VLM 的上限。这一节深入对比三种连接器路线。

5.1 线性投影路线（LLaVA 路线）

最简单的方案：一个线性层或两层 MLP，把 ViT 输出的视觉特征直接映射到 LLM 的嵌入空间。

python 复制代码 
class MLPConnector(nn.Module):
    """LLaVA 式的 MLP 连接器"""

    def __init__(self, vision_dim=768, llm_dim=4096):
        super().__init__()
        self.fc1 = nn.Linear(vision_dim, llm_dim)
        self.fc2 = nn.Linear(llm_dim, llm_dim)
        self.gelu = nn.GELU()

    def forward(self, vision_features):
        # vision_features: [batch, num_patches, 768]
        x = self.gelu(self.fc1(vision_features))  # -> [batch, num_patches, 4096]
        x = self.fc2(x)                           # -> [batch, num_patches, 4096]
        return x  # 直接当视觉 Token 拼到文字 Token 后面

LLaVA 证明了：用预训练好的 CLIP ViT + 一个简单 MLP + 开源的 LLM，只需要少量图文对数据微调，就能搞出一个像模像样的看图对话模型。这验证了一个重要结论------视觉编码器和 LLM 的能力都够了，关键在于把它们连起来的"桥"不需要太复杂。

5.2 Q-Former 路线（BLIP-2 路线）

Q-Former 用一组可学习的 Query Token（比如 32 个），通过交叉注意力从视觉特征中"提取"信息。输入是几百个视觉特征，输出压缩成 32 个 Token。

python 复制代码 
class QFormerConnector(nn.Module):
    """BLIP-2 式的 Q-Former 连接器（简化版）"""

    def __init__(self, num_queries=32, vision_dim=768, hidden_dim=768):
        super().__init__()
        # 可学习的 Query Token
        self.queries = nn.Parameter(torch.randn(num_queries, hidden_dim))
        # 交叉注意力：Query 从视觉特征中提取信息
        self.cross_attn = nn.MultiheadAttention(hidden_dim, num_heads=8, batch_first=True)

    def forward(self, vision_features):
        # vision_features: [batch, 197, 768]
        batch_size = vision_features.size(0)
        queries = self.queries.unsqueeze(0).expand(batch_size, -1, -1)
        # Query 通过交叉注意力"看"视觉特征
        out, _ = self.cross_attn(queries, vision_features, vision_features)
        return out  # [batch, 32, 768]------从 197 压缩到 32

Q-Former 的优势是压缩------从 197 个 Token 压到 32 个，LLM 的输入更短、推理更快。劣势是结构复杂（还有自注意力层 + FFN），训练更难收敛，且压缩可能丢失细节信息。实际效果上，Q-Former 在需要精细视觉理解的任务（如文档 OCR）上不如 MLP 路线。

5.3 Cross-Attention 路线（Flamingo 路线）

Flamingo 的方案最"激进"------视觉 Token 根本不进 LLM 的输入序列。取而代之的是在 LLM 的某些层里插入 Cross-Attention 层，让 LLM 在处理文字 Token 时"看向"视觉特征。

python 复制代码 
class CrossAttentionLayer(nn.Module):
    """Flamingo 式的交叉注意力注入"""

    def __init__(self, llm_dim=4096, vision_dim=768, num_heads=8):
        super().__init__()
        # LLM 文字 Token 通过注意力"看向"视觉特征
        self.cross_attn = nn.MultiheadAttention(
            llm_dim, num_heads, kdim=vision_dim, vdim=vision_dim, batch_first=True
        )
        self.norm = nn.LayerNorm(llm_dim)

    def forward(self, text_hidden, vision_features):
        # text_hidden: [batch, seq_len, 4096]------LLM 的隐状态
        # vision_features: [batch, 197, 768]------视觉编码器输出
        residual = text_hidden
        text_hidden = self.norm(text_hidden)
        # 文字 Query 看向视觉 Key/Value
        out, _ = self.cross_attn(text_hidden, vision_features, vision_features)
        return residual + out  # 残差连接

这种方案的好处是 LLM 的输入序列不变长（不塞视觉 Token），推理速度不受图片分辨率影响。坏处是需要在 LLM 内部插入新层，修改 LLM 结构，不如前两种方案"即插即用"。

5.4 三种路线怎么选

维度 线性投影（LLaVA） Q-Former（BLIP-2） Cross-Attention（Flamingo）
复杂度 最低 中 高
Token 数量 不压缩 大幅压缩 不进序列
实现难度 即插即用 需训练 Q-Former 需修改 LLM 结构
精细理解 好（信息无损） 中（压缩丢信息） 好
推理速度 慢（Token 多） 快（Token 少） 最快
主流采用 Qwen-VL、LLaVA 系列 BLIP-2、InstructBLIP Flamingo、IDEFICS

2025-2026 年的趋势是：线性投影 + 动态分辨率成为主流。Q-Former 的压缩优势被 AnyRes 等动态分辨率方案抵消（高分辨率本身就需要更多 Token），而线性投影的简单性和信息完整性优势越来越明显。Qwen3-VL 用的是 MLP 连接器 + DeepStack 多层注入，本质上就是线性投影路线的增强版。

六、2026 多模态模型横评：谁在什么场景最强

理论讲够了，现在看实战场。2026 年多模态模型格局已经从"百模混战"收敛为几个清晰的梯队。这一节帮你搞清楚：该用什么模型，用在什么场景。

6.1 闭源旗舰：GPT-5 vs Gemini 3 vs Claude

GPT-5（OpenAI，2025.08.08 发布）：原生多模态架构，统一处理文本、图像、音频。采用稀疏 MoE 架构（OpenAI 未公布具体参数量），支持 400K Token 上下文。视觉理解能力强，特别擅长图表分析和截图理解。2026 年迭代到 GPT-5.6，综合多模态能力持续领先。

Gemini 3（Google DeepMind，2025-2026）：原生多模态架构，从 Gemini 1.0 起就设计为统一模型。优势在长上下文（1M Token）和视频理解------Gemini 是最早原生支持长视频输入的模型之一。

Claude Opus 4.8（Anthropic，2026.05.28）：视觉理解能力在 2026 年大幅提升，特别是在多模态 Agent 任务上。前文第九篇提到，DeepSeek V4 Vision 在多模态 Agent 能力上逼近 Opus-4.8，但纯文本复杂推理仍有差距。

6.2 DeepSeek V4 Flash Vision-Exp：2026 年最值得关注的新选手

2026 年 8 月 21 日，DeepSeek 在 API 平台上线了首款多模态视觉理解模型 DeepSeek-V4-Flash-Vision-Exp。这是一件大事------DeepSeek 从纯文本模型正式迈入多模态 Agent 赛道。

关键信息：

  • 定位：实验性多模态视觉理解模型，基于 V4-Flash 底座增加视觉能力
  • 文本能力：与 V4-Flash 正式版持平，未因视觉加入而退化
  • 多模态 Agent 能力：接近 Opus-4.8，差距不到 3%
  • 图片计费：单张图片最多按 384 Token 计算，与 V4-Flash 同价
  • 传图方式：支持 Base64 内联、外部 URL、Files API 三种方式
  • 支持格式：JPEG、PNG、GIF、WebP

Benchmark 对比（关键数据）：

测试维度 测试项目 Vision-Exp Opus-4.8 差距
多模态 Agent Chartography（图表理解） 64.3 65.0 -0.7（1.1%）
多模态 Agent ZeroBench Pass@5 35.0 34.0 +1.0（反超）
文本 Agent TerminalBench 2.1 83.9 85.0 -1.1（1.3%）
文本 Agent NL2Repo（代码仓库生成） 57.7 69.7 -12.0（17.2%）

解读：在需要看懂图表、截图的多模态任务上，Vision-Exp 已经追平 Opus-4.8 九成以上水平。但纯文本代码任务（NL2Repo）仍有明显差距------视觉能力补齐了，文本推理的深度还没跟上。

Vision-Exp 基于 DeepSeek 的"Thinking with Visual Primitives"框架，将视觉元素压缩成空间坐标式的原语进行处理。配套的 DeepSeek Harness 在 8 月 19 日将多模态能力作为升级重点，8 月 21 日发布 0.1.1 版本，原生支持该模型。

6.3 开源主力：Qwen3-VL

Qwen3-VL（阿里通义，2025.09.28 发布首个版本 235B-A22B）是 2025-2026 年最值得关注的开源多模态模型。技术报告 arXiv:2511.21631。

核心技术：

  • 视觉编码器：用 SigLIP-2 替代之前从头训练的 ViT
  • 连接器：MLP 视觉-语言合并器
  • Interleaved-MRoPE：交错多模态旋转位置编码，解决频率谱失衡，支持原生 256K 上下文
  • DeepStack：从 ViT 不同层提取特征注入 LLM 不同层，多层次视觉信息融合
  • 双模式：Instruct（快速响应）+ Thinking（深度推理）

模型家族覆盖从边缘到云端：Dense 架构（2B/4B/8B/32B）+ MoE 架构（30B-A3B/235B-A22B），均有 Instruct 和 Thinking 版本。4B 和 8B 于 2025 年 10 月 15 日发布，FP8 量化版本支持本地终端部署。

6.4 选型速查表

场景 推荐模型 理由
追求最强多模态能力 GPT-5 / Gemini 3 原生多模态，综合能力领先
高性价比多模态 Agent DeepSeek V4 Vision-Exp 多模态能力接近顶级，价格仅 1/10~1/5
开源本地部署 Qwen3-VL（8B/32B） 开源最强 VLM，支持终端部署
长视频理解 Gemini 3 1M 上下文 + 原生视频支持
文档/图表分析 Qwen3-VL / DeepSeek Vision 两者在 ChartQA 类任务表现突出
预算极低的快速验证 DeepSeek V4 Vision-Exp 一张图几分钱

七、视频理解：比图片难一个数量级

图片理解已经够复杂了，视频理解还要再加一个时间维度。一段视频本质上是连续的图片帧序列（通常 24fps 或 30fps），加上时间维度的变化信息。

7.1 视频理解的三个核心难题

难题一：Token 爆炸。 一张 224x224 的图片产生 196 个视觉 Token。一段 1 分钟的视频（24fps）有 1440 帧，每帧 196 个 Token = 282240 个 Token------远超任何模型的上下文窗口。怎么从这么多帧里选关键帧、怎么压缩时间维度信息，是视频 VLM 的核心问题。

难题二：时间对齐。 视频里的事件有时间顺序------"先开门，后进来一个人"和"先进来一个人，后开门"是完全不同的场景。模型不仅要理解每一帧的内容，还要理解帧与帧之间的时间关系。

难题三：动态信息。 图片是静态的，视频是动态的。一个红色小球在画面里从左移到右------单帧看不出任何信息，但如果能看到多帧之间的变化，就能理解"小球在向右运动"。这种动态信息是视频理解的核心价值。

7.2 主流视频理解方案

方案一：均匀采样。 最简单的方案------从视频中均匀抽取 N 帧（比如 16 帧），每帧独立编码成视觉 Token，拼接后输入 LLM。这是 Qwen3-VL、LLaVA-Video 等模型的基础方案。优点是简单直接；缺点是无法捕捉长时间跨度的动态信息。

方案二：动态帧聚焦。 ICLR 2026 的一项研究提出了动态帧选择方案------不均匀采样，而是根据视频内容的"信息密度"动态选择关键帧。比如一个 10 分钟的视频，前 8 分钟是人物对话（每秒信息量低），后 2 分钟是动作戏（每秒信息量高），动态方案会从前 8 分钟少抽帧、后 2 分钟多抽帧。

方案三：分层压缩。 先对短视频片段做高分辨率理解，再在更长的时间尺度上做摘要。VideoChat3（2026.08）提出了统一离线理解与在线交互的方案------离线阶段对视频做高分辨率特征提取，在线交互阶段按需检索相关片段。

方案四：扩散模型辅助。 ICLR 2026 另一项研究用扩散模型来"补全"视频中被跳过的帧------模型不直接看每一帧，而是用扩散模型生成中间帧的语义表示，在不增加 Token 数量的情况下保留更多时间信息。

7.3 视频理解的未来方向

2026 年视频理解的研究趋势集中在两个方向：

长视频理解：从"看 1 分钟视频"到"看 1 小时视频"。核心挑战是 Token 效率------1 小时视频即使每秒只抽 1 帧也有 3600 帧，Token 数量爆炸。需要更高效的压缩和检索机制。

实体感知分割：ICLR 2026 提出"When and What"方案------用扩散模型做实体感知的视频分段，把长视频按"谁在什么时候做了什么"切成语义段落，每段独立理解后再拼接。这比均匀帧采样更接近人类看视频的方式。

八、实战：让模型看图回答问题

理论讲透了，现在上代码。这一节用两种方式实现多模态问答：先用在线 API 快速体验，再用开源模型在本地跑。

8.1 方式一：用 DeepSeek V4 Vision-Exp API（最快上手）

python 复制代码 
"""
multimodal_api.py - 用 DeepSeek V4 Vision-Exp 做多模态问答
依赖: pip install openai
"""
import base64
import json
from openai import OpenAI

client = OpenAI(
    api_key="your-api-key",
    base_url="https://api.deepseek.com"
)

def encode_image(image_path):
    """将本地图片编码为 base64"""
    with open(image_path, "rb") as f:
        return base64.b64encode(f.read()).decode("utf-8")

def ask_image(image_path, question):
    """让模型看图回答问题"""
    base64_image = encode_image(image_path)

    response = client.chat.completions.create(
        model="deepseek-v4-flash-vision-exp",
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/jpeg;base64,{base64_image}"
                        }
                    },
                    {
                        "type": "text",
                        "text": question
                    }
                ]
            }
        ],
        temperature=0.1  # 视觉理解任务用低温度，减少"创作"
    )

    return response.choices[0].message.content

# 示例：让模型描述图片内容
result = ask_image("test_chart.png", "分析这张图表，告诉我哪个季度增长最快，给出具体数字")
print(result)

# 示例：让模型识别图片中的文字
result2 = ask_image("screenshot.png", "提取这张截图中所有可见的文字，保持原始排版")
print(result2)

# 示例：让模型对比两张图片
def compare_images(image1_path, image2_path, question):
    """让模型对比两张图片"""
    img1 = encode_image(image1_path)
    img2 = encode_image(image2_path)

    response = client.chat.completions.create(
        model="deepseek-v4-flash-vision-exp",
        messages=[
            {
                "role": "user",
                "content": [
                    {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{img1}"}},
                    {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{img2}"}},
                    {"type": "text", "text": question}
                ]
            }
        ]
    )
    return response.choices[0].message.content

result3 = compare_images("v1.png", "v2.png", "这两张设计稿有什么区别？列出所有不同之处")
print(result3)

这段代码的要点：

  1. 图片通过 base64 编码后以 data:image/jpeg;base64,... 格式传入，也可以直接用公开 URL
  2. content 是一个列表，可以混合 image_url 和 text 多种类型
  3. 一条消息里可以放多张图片（对比场景），也可以多轮对话
  4. 图片最多折算 384 Token 计费，一张图几分钱

8.2 方式二：用 Qwen3-VL 本地部署（完全离线）

如果你需要数据不出本地、或者想省 API 费用，可以用 Qwen3-VL 在本地跑。以 8B 版本为例：

python 复制代码 
"""
multimodal_local.py - 用 Qwen3-VL-8B 做本地多模态问答
依赖: pip install transformers torch accelerate
模型: Qwen/Qwen3-VL-8B-Instruct (HuggingFace)
"""
import torch
from transformers import AutoProcessor, AutoModelForVision2Seq

# 加载模型和处理器
model_id = "Qwen/Qwen3-VL-8B-Instruct"
processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForVision2Seq.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto",          # 自动分配 GPU/CPU
    trust_remote_code=True
)

def ask_image_local(image_path, question):
    """用本地 Qwen3-VL 看图回答问题"""
    from PIL import Image

    image = Image.open(image_path).convert("RGB")

    # 构建多模态对话消息
    messages = [
        {
            "role": "user",
            "content": [
                {"type": "image", "image": image},
                {"type": "text", "text": question}
            ]
        }
    ]

    # 处理输入
    text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
    inputs = processor(
        text=[text],
        images=[image],
        return_tensors="pt"
    ).to(model.device, torch.float16)

    # 生成回答
    with torch.no_grad():
        output_ids = model.generate(
            **inputs,
            max_new_tokens=512,
            temperature=0.1,
            do_sample=True
        )

    # 解码输出（截掉输入部分）
    generated = output_ids[:, inputs.input_ids.shape[1]:]
    answer = processor.batch_decode(generated, skip_special_tokens=True)[0]
    return answer

# 运行
result = ask_image_local("test_chart.png", "这张图表展示了什么趋势？最关键的转折点在哪？")
print(result)

本地部署注意事项：

  1. Qwen3-VL-8B 需要约 16GB 显存（FP16），FP8 量化版约 8GB
  2. 如果显存不够，可以用 4B 版本（约 8GB FP16），或者用 load_in_4bit=True 做 4bit 量化
  3. trust_remote_code=True 是必须的------Qwen3-VL 使用了自定义模型代码
  4. 处理器会自动把图片切成 Patch、做位置编码------你在上层完全感知不到

8.3 两种方式怎么选

维度 DeepSeek Vision API Qwen3-VL 本地部署
上手速度 5 分钟 需要 GPU + 模型下载
数据隐私 图片上传到云端 完全本地，不出机器
成本 每张图几分钱 电费 + GPU 折旧
模型能力 接近 Opus-4.8 开源最强，但略弱于闭源旗舰
适合场景 快速验证、产品原型 数据敏感、高并发、离线场景

实际项目中的建议：先用 API 验证业务逻辑跑通，再评估是否需要本地部署。 很多人一上来就想本地跑，结果花两天配环境，业务逻辑还没验证------先用 API 花几块钱跑通全流程，再决定值不值得本地化。

九、2026 前沿：多模态正在发生的四个变化

9.1 OddGridBench：戳穿多模态模型的"视觉盲区"

CVPR 2026 上，深圳大学提出了一项令人意外的评测基准------OddGridBench。测评内容看起来极其简单：给模型看一张网格图，里面排列着大量相同元素，其中一个元素在颜色、大小、旋转或位置上有微小差异，让模型找出来。

结果令人吃惊：所有评估的主流多模态模型（包括 GPT-5、Gemini 3、Qwen3-VL）在这些看似 trivial 的视觉差异识别任务上表现都不好。模型能写出高质量的图片描述，能做复杂的图表分析，但就是找不到那个"不一样的格子"。

OddGridBench 揭示了一个根本问题：当前 VLM 的视觉感知能力存在明显的"细粒度盲区"------模型擅长理解高层语义（"这是一只猫"），但对低层视觉细节（"这只猫的左眼比右眼稍微小一点"）极不敏感。这对需要高精度视觉检测的场景（工业质检、医学影像）是严重的。

9.2 ThinkMorph：视觉推理的新范式

ICLR 2026 的一项研究 ThinkMorph 提出了原生多模态推理的新范式。核心思路：让文字和图像在统一架构中共同演化------模型在推理过程中可以自主切换"文字思考"和"视觉思维"两种模式。

关键数据：仅用 2.4 万条数据微调 7B 统一模型，视觉推理平均提升 34.74%，多项任务比肩甚至超越 GPT-4o 和 Gemini 2.5 Flash。更重要的是，模型涌现出了未被训练覆盖的视觉操作能力------它能自主决定"什么时候该看图""什么时候该用文字推理"。

ThinkMorph 的意义在于：它证明了多模态推理不必固定在"先看图再推理"或"边看边推理"的预设流程上------模型可以像人类一样，根据问题难度自主选择用视觉还是用逻辑来思考。

9.3 安全评测：六款多模态模型集体过安检

2026 年 8 月，一篇安全报告（arXiv:2601.10527）对 GPT-5.2、Gemini 3 Pro、Qwen3-VL、Grok 4.1 Fast、Nano Banana Pro、Seedream 4.5 六款主流多模态模型做了系统安全评测。评测维度包括幻觉率、有害内容生成、越狱攻击 susceptibility、隐私泄露等。

结论：多模态模型的安全风险比纯文本模型更高------因为攻击面增加了。攻击者可以通过图片中的隐蔽模式（对抗样本）诱导模型输出有害内容，而这些模式对人眼不可见。多模态安全正在成为独立的研究方向。

9.4 世界模型：多模态的终极目标

2026 年世界人工智能大会（WAIC 2026）将"世界模型 + 物理 AI + 具身智能"定为年度核心主线。行业共识：AI 在完成文字、图像、视频的内容生成之后，正式迈入理解真实物理世界、与实体世界闭环交互的全新周期。

多模态是世界模型的基础------要让 AI 理解物理世界，它必须能"看见"世界（视觉）、"听见"世界（音频）、最终"触碰"世界（触觉传感器）。2026 年 4 月提出的 WALL-B 模型基于"世界统一模型架构"（WUM），从训练伊始就将视觉、语言、动作、触觉等多种模态放在同一个网络中联合训练，消除模块间的边界和数据损耗。

这指向了多模态的终极形态：不是"给 LLM 接上眼睛"，而是从零开始构建一个能同时感知所有模态的统一智能体。

十、三个真坑，每个都付过费

坑一：高分辨率图片 Token 爆炸，账单翻倍

症状： 你给 API 发了一张 4K 分辨率（3840x2160）的产品截图，让它分析界面布局。API 返回了正确的分析结果，但你查账单发现这一次调用消耗了 8000 多个 Token------光图片就占了大几千 Token，费用是预期的 10 倍。

原因： VLM 处理高分辨率图片的方式是切成多个子图块（Tile），每个子图块独立编码成视觉 Token。一张 4K 图片切成 16 个子图块，每个 196 个 Token，就是 3136 个视觉 Token------再加上文字交互，很容易破万。API 按 Token 计费，图片 Token 也是 Token。

解：

  1. 预处理缩放：发送前把图片缩放到模型最优分辨率（通常 1024x1024 足够做图表分析和界面理解）。文档类场景可以先裁剪关键区域。
  2. 了解计费规则：DeepSeek Vision-Exp 每张图最多 384 Token，Qwen3-VL 按分辨率动态计算。提前查清计费方式。
  3. 用 Files API 缓存：DeepSeek 的 Files API 支持上传一次、多次调用，避免重复编码。
  4. 裁剪而非缩放：如果你只需要图片的一小块区域，裁剪比缩放效果好------缩放会让所有区域都变模糊，裁剪则保留了目标区域的原始分辨率。

坑二：模型"看见"了不存在的东西------多模态幻觉

症状： 你给模型发了一张超市小票的照片，问"上面的商品总金额是多少"。模型回答"共计 158.40 元"。你仔细核对小票，发现实际是 168.40 元------模型把"6"认成了"5"，而且信心满满，完全没提示不确定。

原因： 多模态幻觉（Multimodal Hallucination）比纯文本幻觉更隐蔽。模型不是在"编造"信息------它确实"看"了图片，但视觉编码不够精确，把模糊的像素解读成了错误的文字。特别是手写体、低分辨率文字、密集排版文档，OCR 级别的精度远未达到。

解：

  1. 关键数字交叉验证：涉及金额、日期、编号等关键信息，让模型输出"我读到的是 X，请核对"。或者用 Temperature=0 + 多次取样取多数。
  2. 分区域提问：不要一次性问整张图。先让模型定位关键区域（"金额在图片哪个位置"），再针对该区域放大提问。
  3. VLM + OCR 混合方案：对文字密集场景（文档、票据），先用专用 OCR（如 PaddleOCR）做高精度文字提取，再把 OCR 结果 + 原图一起给 VLM------VLM 负责理解布局和语义，OCR 负责精确文字。
  4. 降温度：视觉理解任务用 Temperature=0.1 甚至 0，减少模型"创作"倾向。

坑三：视频理解的 Token 黑洞

症状： 你给模型发了一段 30 秒的产品演示视频，问"视频里展示了哪些功能"。模型返回了一段看起来合理的描述，但提到一个视频里根本没有的功能。更糟的是，这次调用消耗了你一整个月的 API 额度------30 秒视频被拆成了 720 帧，每帧 196 个 Token，总计 14 万 Token。

原因： 视频理解面临的"Token 黑洞"比图片更严重。如果没有做帧采样优化，模型会尝试处理每一帧，Token 数量与视频时长成正比。同时，模型对视频内容的理解精度远低于图片------它可能"记不住"30 秒前看到的内容，因为视觉 Token 太多挤出了上下文窗口里的中间结果。

解：

  1. 手动抽帧：不要直接发整个视频。先用 ffmpeg 等工具按关键帧抽帧（每秒 1 帧或更低），选定关键帧后以多图方式发送。
  2. 控制帧数：无论视频多长，发给模型的帧数控制在 8-16 帧以内。超过这个数量，理解质量不会提升但 Token 成本线性增加。
  3. 分段处理：长视频切成多个短片段，每段独立理解后再合并结果。类似多 Agent 的 Orchestrator-Worker 模式。
  4. 选对模型：Gemini 系列原生支持长视频输入且有专门的视频 Token 压缩机制；其他模型对视频的原生支持参差不齐，用前一定要查文档。

十一、总结：经验清单

五个可带走的要点，收藏备用：

  1. 多模态不是 OCR + LLM，是像素级直接理解。 真正的 VLM 把图片切成 Patch、编码成视觉 Token、通过连接器映射到语言模型空间------全流程不需要文字中转。判断一个系统是不是真多模态，看它能不能理解"图片中没有文字的视觉信息"（如颜色趋势、布局关系、表情含义）。

  2. 图片变 Token 的核心是 ViT 的 Patch Embedding。 224x224 的图片切成 16x16 的 Patch，得到 196 个 Token------和 196 个文字 Token 没有本质区别。CLIP 的对比学习把图文对齐到同一空间，让模型知道"猫的照片"和"猫"这个词指的是同一个东西。理解了这两步，VLM 的黑盒就打开了一半。

  3. VLM 三代架构：拼接 -> 深度融合 -> 原生。 拼接式（LLaVA）用连接器搭桥，简单有效；深度融合（Qwen3-VL）用 DeepStack 多层注入，效果接近原生；原生多模态（GPT-5/Gemini）从零联合训练，效果最好但成本最高。选型时先看预算和部署条件，开源选 Qwen3-VL，闭源选 GPT-5 或 DeepSeek Vision。

  4. 高分辨率是 Token 杀手，视频是 Token 黑洞。 一张 4K 图片可以吃掉几千 Token，一段 30 秒视频可以吃掉十几万 Token。务必做预处理：图片缩放或裁剪、视频抽帧且控制帧数在 8-16 帧内。了解你用的模型的图片计费规则（DeepSeek Vision 每图最多 384 Token），花在图片上的钱和花在文字上的一样多。

  5. 多模态幻觉比文本幻觉更危险。 模型会把模糊的像素解读成错误的文字，而且信心满满。涉及金额、日期等关键信息时，必须交叉验证：降温度、分区域提问、VLM + OCR 混合方案。OddGridBench 的研究结果提醒我们------当前 VLM 对细粒度视觉差异极不敏感，别在需要像素级精度的场景盲目信任模型。

下篇预告

下一篇《大模型实战指南（11）------模型部署与推理框架：从 vLLM 到 TensorRT-LLM》，拆解大模型推理加速的核心技术：KV Cache 为什么能省 90% 计算、PagedAttention 怎么解决显存碎片、Continuous Batching 如何提升吞吐量、vLLM/TensorRT-LLM/SGLang 三大框架横评。文末附"用 vLLM 部署一个高性能推理服务"的完整代码实战。

数据来源声明

本文涉及的所有技术事实和数据均来自以下公开来源，写作前已逐条核实：

  • ViT 论文：Dosovitskiy et al., "An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale", ICLR 2021, arXiv:2010.11929
  • CLIP 论文：Radford et al., "Learning Transferable Visual Models From Natural Language Supervision", ICML 2021, arXiv:2103.00020
  • SigLIP 论文：Zhai et al., "Sigmoid Loss for Language Image Pre-Training", ICCV 2023, arXiv:2303.15343
  • SigLIP-2：Google, 2025-02 发布
  • 视觉编码器综述：arXiv, "Vision Encoders in Vision-Language Models: A Survey", 2026
  • LLaVA 论文：Liu et al., "Visual Instruction Tuning", NeurIPS 2023, arXiv:2304.08485
  • BLIP-2 论文：Li et al., "BLIP-2: Bootstrapping Language-Image Pre-training with Frozen Image Encoders and Large Language Models", ICML 2023, arXiv:2301.12597
  • Flamingo 论文：Alayrac et al., "Flamingo: a Visual Language Model for Few-Shot Learning", NeurIPS 2022, arXiv:2204.14198
  • Qwen3-VL 技术报告：arXiv:2511.21631, 2025-09-28 发布首个版本
  • Qwen3-VL 架构解析：Interleaved-MRoPE, DeepStack 技术
  • GPT-5：OpenAI, 2025-08-08 发布
  • Gemini 系列：Google DeepMind, 原生多模态架构
  • DeepSeek-V4-Flash-Vision-Exp：DeepSeek, 2026-08-21 上线 API 平台
  • DeepSeek Vision-Exp Benchmark 数据：新浪科技/百家号实测报告, 2026-08-22
  • OddGridBench：CVPR 2026, 深圳大学
  • ThinkMorph：ICLR 2026, arXiv:2510.27492
  • 多模态安全报告：arXiv:2601.10527, 2026-08
  • 世界统一模型架构（WUM）/ WALL-B：2026-04-21
  • WAIC 2026：世界人工智能大会, 2026-07, 上海
  • 视频理解方案：VideoChat3, ICLR 2026 视频理解综述
相关推荐
Sunlly14 分钟前
让 Agent 长期跑下去：OpenClaw 的可靠性架构
人工智能
逢生博客18 分钟前
MNIST 手写数字识别实战：CNN + Transformer 混合模型
人工智能·cnn·transformer·mnist·手写数字识别
澄旭20 分钟前
不同 AI Agent 共用同一套 Skills
人工智能
阿牛哥_GX21 分钟前
接入AI大模型：让机器人"智能"起来
人工智能
元启数宇33 分钟前
幕墙AI设计算法逻辑：元启数宇如何智能分格
人工智能·算法
故七月44 分钟前
以合规化技术体系筑牢GEO产业发展根基 万域智瞰引领AI流量服务高质量发展
大数据·人工智能
开发小程序的之朴1 小时前
从神经网络到文件加密：一次关于 SIREN、ARX 与密码安全性的实验探索
人工智能·深度学习·神经网络
哈基咩1 小时前
Function Calling 与 Code Mode：AI Agent 工具调用的原理、对比与选型指南
网络·人工智能
就是一顿骚操作1 小时前
ViT：把图像切成词之后，Transformer 如何进入计算机视觉
人工智能·深度学习·计算机视觉·transformer·论文解读
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02GitHub 镜像站点032026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？04历年考研数学一、数学二、数学三真题试卷及答案PDF05微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新06AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路07Agnes AI 免费 API 接入指南：文本、生图、生视频，一套接口全免费08蜘蛛磁力 搜索引擎大全，如何使用蜘蛛磁力查找磁力链接09VSCode+CodeX扩展，无法启动10如何新建文件夹？ 电脑新建文件夹的4种方法