很多人第一次接触多模态大模型，会得到一个非常容易产生误解的解释：

多模态大模型，就是既能处理文字，又能处理图片、声音和视频的大模型。

这句话不能说错。

但基本等于没说。

因为真正值得理解的问题不是：

“多模态模型能处理哪些数据？”

而是：

图片明明是一堆像素，声音明明是一串波形，文字则是一串 Token，它们的数据结构完全不同，为什么最后竟然可以进入同一个模型一起推理？

如果这个问题想明白了，CLIP、ViT、LLaVA、Flamingo、视觉 Token、Projector、Cross-Attention，甚至所谓“原生多模态”，都会突然变得很好理解。

我认为理解多模态最重要的一句话是：

多模态的核心，不是让大语言模型直接认识图片，而是想办法把图片、声音、视频都转换成 Transformer 能够处理的表示。

换句话说：

Transformer 不需要认识 JPG，不需要认识 MP3，也不需要认识 MP4。

它只需要认识一种东西：

向量序列。

这就是整篇文章真正的主线。

---

1. 先不要想 AI，先想一下人脑

假设你现在看到一只猫。

你主观意识里的感觉是：

“我看到了一只猫。”

但眼睛接收到的其实并不是“猫”这个概念。

最开始只有不同波长、不同强度的光。

这些光经过视网膜和视觉神经系统处理，大脑逐渐识别出：

边缘、方向、纹理、形状、物体结构……

最后我们才形成：

这是一只猫。

更进一步：

猫正在看桌上的鱼。

再进一步：

它可能想吃那条鱼。

也就是说，人脑并不会永远停留在最原始的感官信号上。

它会不断把低层信号变成越来越抽象的内部表示。

机器学习其实也在做类似的事情。

图片最开始是像素。

声音最开始是波形。

文字最开始是字符串。

但是进入神经网络以后，我们希望把它们逐渐转换成一种统一得多的数学形式：

Vector Representation

也就是：

向量表示。

所以理解多模态的第一个关键，不是“模态”，而是：

Representation Learning，表示学习。

---

2. 计算机眼里的图片，根本不存在“猫”

先看一张普通 RGB 图片。

数学上可以写成：

X∈ℝH× W× 3

其中：

• H：图片高度
• W：图片宽度
• 3：RGB 三个颜色通道

假设一张图大小是：

224×224×3

那它本质上就是 150528 个数字。

人类看到：

一只猫坐在沙发上。

计算机最开始看到的却类似：

[121, 98, 76]
[124, 101, 79]
[130, 108, 84]
...

于是第一个真正困难的问题出现了：

怎么从十几万个数字里，得到“这是一只猫”？

这里就要引出视觉 Transformer，也就是 ViT。

---

3. ViT 最聪明的地方：把图片当成“句子”

语言模型为什么适合 Transformer？

因为一句话天然可以被拆成 Token。

例如：

我 喜欢 人工智能

经过 Tokenizer 后，可以得到：

Token1
Token2
Token3
Token4

然后每一个 Token 都变成向量。

Transformer 最终处理的其实不是“汉字”，而是：

[e1,e2,e3,e4]

也就是一个向量序列。

视觉领域出现了一个非常漂亮的想法：

既然 Transformer 喜欢 Token，那能不能把图片也变成 Token？

答案就是：

可以。

ViT 的核心做法，是先把图片切成很多小块。

这些小块叫：

Patch

比如把一张 224×224 的图片，按照 16×16 切块。

那么一共会得到：

14×14=196

个 Patch。

于是原本的一张图片：

一整张图片

就变成：

Patch1
Patch2
Patch3
...
Patch196

到这里，事情开始有意思了。

因为它已经越来越像一句话：

Token1
Token2
Token3
...
Token196

---

4. Patch 怎么变成真正的 Visual Token？

一个 Patch 假设大小是：

16×16×3

里面有：

16×16×3=768

个数字。

先把它拉平成一个向量：

xi∈ℝ768

然后做线性映射：

zi=xiW+b

于是，每一个图片区域都会得到一个新的高维向量：

z1,z2,z3,…,z196

这些东西就可以理解成：

Visual Tokens，视觉 Token。

这是理解现代多模态模型非常关键的一步。

因为到了这里，模型眼里的图片已经不再是：

JPG
PNG
RGB像素

而变成了：

[z1,z2,z3,…,zn]

也就是：

一串向量。

---

5. 一个关键的“恍然大悟”：文字其实也是一串向量

再回头看看语言模型。

例如一句话：

猫正在吃鱼

经过 Tokenizer 后，假设变成：

猫
正在
吃
鱼

每个 Token 会对应一个 Token ID：

[3821,1937,716,4289]

注意，这些数字本身也没有语义。

3821 并不意味着“猫的程度比 716 大”。

它只是一个编号。

接下来模型会通过 Embedding Matrix，把 Token ID 转成向量：

ei=E[tokeni]

于是：

猫   -> [0.31, -0.27, 0.82, ...]
正在 -> [-0.11, 0.64, 0.19, ...]
吃   -> [0.72, 0.13, -0.31, ...]
鱼   -> [0.43, -0.56, 0.29, ...]

现在重新看两种数据。

文字：

[e1,e2,e3,…,em]

图片：

[v1,v2,v3,…,vn]

到这一刻，多模态模型最重要的设计思想已经出现了：

不管你原来是文字还是图片，只要最后都能变成向量序列，Transformer 就有机会用类似的方法处理。

所以所谓多模态，绝不是让 Transformer 突然学会读取 JPEG 文件。

而是：

Image → Visual Tokens

Text → Text Tokens

最终都进入：

Transformer

---

6. 但这里还有一个问题：图片向量和语言向量不是“一种语言”

到这里很容易产生第二个误区：

既然图片和文本最后都是向量，那直接拼起来不就行了吗？

没有这么简单。

假设视觉模型输出的每个向量是：

vi∈ℝ1024

但是 LLM 的隐藏维度是：

hi∈ℝ4096

一个 1024 维。

一个 4096 维。

根本无法直接送进去。

更重要的是：

即使两个向量碰巧维度一样，它们所在的特征空间也未必具有相同语义。

你可以把它理解为：

视觉 Encoder 在说“视觉语言”。

LLM 在说“语言模型自己的内部语言”。

所以中间需要一个翻译器。

这个东西一般叫：

Projector

或者：

Adapter

---

7. Projector：多模态模型里非常重要的“翻译官”

最简单的 Projector 就是线性变换：

hi=Wvi+b

如果：

vi∈ℝ1024

希望输出：

hi∈ℝ4096

那么矩阵 W 就负责把视觉空间映射到 LLM 可以接受的空间。

工程上也经常使用 MLP：

h=W2σ(W1v+b1)+b2

其中 σ 可以是某种非线性激活函数。

这一步如果用一句人话解释：

Projector 的任务，就是教视觉模型产生的特征“怎么说 LLM 听得懂的话”。

因此，一个非常典型的视觉语言模型可以抽象成：

图片
 ↓
Vision Encoder
 ↓
Visual Tokens
 ↓
Projector
 ↓
LLM
 ↓
文字回答

理解这个结构以后，再去看很多开源多模态模型，会非常清晰。

---

8. 真正的核心来了：Transformer 怎么知道应该看图片里的哪里？

假设输入一张图片。

图片里面有：

• 天空
• 一个人
• 一只手
• 一个咖啡杯
• 一张桌子

用户问：

“这个人手里拿着什么？”

视觉 Encoder 已经把图片转换成很多 Visual Token。

问题也已经转换成很多 Text Token。

现在模型真正要解决的是：

当处理“拿着什么”这几个 Token 时，应该重点读取图片里的哪个区域？

这就是 Attention 出场的地方。

---

9. Attention 到底在算什么？

Transformer 中最重要的公式之一：

Attention(Q,K,V)=softmax(QKT√dk)V

很多人第一次看到这条公式就直接放弃了。

其实它没有看起来那么可怕。

我们一个字母一个字母拆。

输入矩阵记为：

X

模型通过三个不同的线性变换得到：

Q=XWQ

K=XWK

V=XWV

分别叫：

• Query
• Key
• Value

如果不用数学术语，我更愿意这样理解：

Query：我现在想找什么？

Key：我这里有什么信息？

Value：如果你觉得我重要，我真正提供给你的内容是什么？

---

10. 用一个例子彻底看懂 Q、K、V

用户问：

图片里的男人手里拿着什么？

当模型处理“拿着什么”时，可以把当前 Query 粗略理解成：

我要寻找：
“和这个男人手中物体有关的信息”

而图片不同区域对应的 Key，可能分别表达：

区域1：天空
区域2：男人的脸
区域3：男人的手
区域4：咖啡杯
区域5：桌子

模型计算：

QKT

本质上是在计算：

Query 和各个 Key 的相关程度。

假设得到：

天空       0.02
男人脸     0.11
男人手     0.74
咖啡杯     0.92
桌子       0.18

然后经过 Softmax。

Softmax 会把这些分数转换成类似“注意力占比”的结果：

天空        1%
男人脸      4%
男人手     27%
咖啡杯     63%
桌子        5%

于是模型主要聚合：

男人手
+
咖啡杯

对应的 Value。

最后得到新的上下文表示：

男人手里拿着咖啡杯。

这就是 Attention 最核心的直觉。

如果必须压缩成一句话：

Attention = 根据当前问题计算相关性，再对相关信息进行加权汇总。

---

11. 为什么公式里要除以 √dk？

再看一次：

Attention(Q,K,V)=softmax(QKT√dk)V

很多文章会直接告诉你：

为了防止梯度消失。

这个解释太草率。

真正要先理解一个问题：

如果 Query 和 Key 的维度越来越大，那么点积：

Q· K

的数值尺度通常也会变大。

这样 Softmax 的输入可能变成：

2
5
19
41

Softmax 后非常容易接近：

0
0
0
1

分布过于尖锐，训练会变得不稳定。

因此除以：

√dk

相当于给点积结果做一个尺度控制。

所以它完整的名字叫：

Scaled Dot-Product Attention

也就是“缩放点积注意力”。

---

12. Multi-Head Attention 又是在解决什么？

现实世界里的关系显然不只有一种。

例如：

小王把苹果递给小李，因为他已经吃饱了。

模型可能同时需要考虑：

• 谁是人
• 谁把东西给了谁
• 苹果是什么角色
• “他”指的是谁
• 吃饱和递苹果是什么因果关系

如果所有关系都挤在同一套 Attention 里，会很受限制。

所以 Transformer 使用多个 Attention Head：

headi=Attention(QWiQ,KWiK,VWiV)

最后：

MultiHead(Q,K,V)=Concat(head1,…,headh)WO

直觉上，可以把不同 Head 想象成：

Head 1：关注人物关系
Head 2：关注空间位置
Head 3：关注动作
Head 4：关注物体
Head 5：关注上下文指代
...

但这里要特别严谨：

这是教学上的直觉，不代表实际训练出来的每一个 Attention Head 都能被清晰命名成人类概念。

这一点不要过度解读。

---

13. Transformer 一层实际上只干两类事

一个典型 Transformer Block，核心可以高度概括成两部分：

输入 X
 ↓
Attention
 ↓
残差连接
 ↓
MLP / FFN
 ↓
残差连接
 ↓
输出

数学上可以简写为：

X'=X+Attention(LN(X))

然后：

X''=X'+MLP(LN(X'))

MLP 部分可以简化写成：

MLP(x)=W2φ(W1x)

如果继续用人话总结：

Attention 负责：

我应该从其他 Token 那里拿什么信息？

MLP 负责：

拿到这些信息以后，我自己应该怎么处理？

Transformer 反复堆很多层，本质上就是让 Token 之间不断交换、整合、加工信息。

所以所谓“深层理解”，从神经网络的角度看，实际上就是：

经过很多层信息交互以后，每个 Token 的内部表示越来越包含上下文。

---

14. 现在终于可以解释：图片和文字是怎么一起推理的

假设用户输入：

[一张图片]

请问这个人在做什么？

模型内部可以抽象成：

<Vision Token 1>
<Vision Token 2>
<Vision Token 3>
...
<Vision Token N>

请
问
这
个
人
在
做
什
么
？

经过多层 Transformer 以后，文字 Token 可以不断读取视觉 Token 中的信息。

视觉 Token 之间也可以相互交换信息。

于是问题里的：

这个人

会逐渐和图片中的某些人物区域建立联系。

而：

在做什么

又会迫使模型关注：

• 手部
• 物体
• 姿势
• 人和周围物体之间的关系

最终形成回答。

这就是很多视觉语言模型最核心的推理过程。

---

15. 多模态模型并不只有一种架构

到这里，必须避免另一个非常常见的问题：

很多科普文章会把某一种开源模型结构，当成“所有多模态大模型的结构”。

这是不准确的。

目前公开研究中，可以看到多种多模态融合路线。

这里讲三个最重要的思想。

---

16. 第一种：Dual Encoder，代表性思想是 CLIP

Dual Encoder 非常好理解。

图片走自己的 Encoder：

v=fimage(I)

文字走自己的 Encoder：

t=ftext(T)

最后计算两者相似度。

通常会先归一化：

v̂=v‖ v‖2

t̂=t‖ t‖2

然后计算：

sim(v,t)=v̂Tt̂τ

其中：

τ

是 temperature 参数。

训练目标非常漂亮：

正确配对的图片和文本，在向量空间中应该更接近。

比如：

猫的图片

应该靠近：

a photo of a cat

而远离：

a photo of an airplane

一种典型的对比学习 Loss 可以写成：

Limage→ text=-1N∑iloges(vi,ti)∑j es(vi,tj)

文字找图片也做一次：

Ltext→ image

最终：

L=Limage→ text+Ltext→ image2

这个过程就是：

Contrastive Learning，对比学习。

它解决的是多模态里一个极其重要的问题：

不同模态怎样在语义上对齐？

---

17. “对齐”到底是什么意思？

这是多模态领域特别重要的一个词。

假设我们有：

猫的图片

以及：

cat
猫
一只毛茸茸的小动物

它们表面完全不同。

图片是像素。

英文是一串 Token。

中文也是另一串 Token。

但我们希望模型内部知道：

它们表达的是高度相关的概念。

于是训练以后，我们希望：

zimage ≈ ztext

这里不是说两个向量一定完全相同，而是说：

它们在语义表示空间中应该建立稳定对应关系。

这就是：

Multimodal Alignment

也就是多模态对齐。

---

18. 第二种：Vision Encoder + Projector + LLM

这是目前学习多模态大模型时非常值得首先理解的一类结构。

可以概括为：

Image
 ↓
Vision Encoder
 ↓
Visual Features
 ↓
Projector
 ↓
Visual Tokens compatible with LLM
 ↓
LLM
 ↓
Answer

数学上：

V=Evision(I)

然后：

V'=P(V)

文字：

T=Etext(x)

最终组合成：

X= [V'1,…,V'n,t1,…,tm]

送入大语言模型。

这种设计非常聪明的一点在于：

不需要从零重新发明一个“会说话的视觉模型”。

已经训练得很强的 LLM，本身拥有：

• 语言能力
• 世界知识
• 指令理解能力
• 一定程度的推理能力

真正需要解决的是：

如何把视觉信息转换成 LLM 可以利用的信息。

所以很多多模态研究的重要工作，其实都围绕：

视觉和语言之间的接口

展开。

---

19. 第三种：Cross-Attention

还有一种非常重要的融合方式：

不是简单把视觉 Token 和语言 Token 全部拼起来。

而是让语言 Token 主动去视觉表示中“查询信息”。

这就是：

Cross-Attention

例如：

Q=XtextWQ

但是：

K=XvisionWK

V=XvisionWV

于是：

CrossAttention=softmax(QtextKvisionT√dk)Vvision

这个结构的直觉非常漂亮：

语言负责提问题，视觉负责提供证据。

例如当前文本正在处理：

“男人手中拿着什么？”

Query 来自文字。

Key 和 Value 来自图片。

于是文字可以针对性地从视觉特征中取回信息。

---

20. 为什么图片 Token 不能无限增加？

理解到这里，会出现一个很实际的问题。

既然图片切得越细信息越丰富，那我把 Patch 做得特别小不就好了？

问题是：

Attention 很贵。

标准 Self-Attention 的计算复杂度大致与：

O(N2)

有关。

其中 N 是 Token 数量。

如果原来有：

N

个 Token。

现在变成：

2N

那么 Attention Matrix 的规模大约从：

N2

变成：

4N2

Token 数量翻一倍，某些核心计算量可能接近翻四倍。

所以多模态模型其实一直面临一个非常现实的矛盾：

看得越细，Token 越多；Token 越多，计算越贵。

这在视频里会更加明显。

---

21. 视频为什么比图片难很多？

一张图片可以写成：

X∈ℝH× W× C

视频则多了时间维度：

X∈ℝT× H× W× C

其中：

T

表示时间或者帧数。

假设一帧产生 500 个视觉 Token。

10 帧就是：

5000

个视觉 Token。

100 帧呢？

50000

个。

这时候如果粗暴做全局 Attention，计算成本会非常可怕。

所以视频多模态模型真正难的地方不只是：

“能不能看懂一帧？”

而是：

怎么在有限计算资源下，看懂很长时间里的关键变化？

---

22. 视频真正比图片多出来的，是“时间关系”

单张图片可以告诉模型：

桌子上有一个杯子
旁边有一个人

但是视频还能告诉模型：

第1帧：杯子在桌上
第2帧：手靠近杯子
第3帧：手握住杯子
第4帧：杯子离开桌面

于是模型可以进一步推断：

人拿起了杯子。

因此视频理解包含两类关系：

Spatial Relation

空间关系。

以及：

Temporal Relation

时间关系。

所以视频理解本质上是在学习：

Spatio-Temporal Representation

也就是时空表示。

这也是为什么“视频只是很多图片”这句话只对了一半。

数据上确实可以看成连续图像。

但语义上，真正重要的是：

变化。

---

23. 为什么会有 Resampler、Token Compression？

既然图片和视频可能产生很多 Token，一个自然的想法就是：

能不能先把大量视觉信息压缩一下，再交给 LLM？

答案是可以。

一种抽象思路是准备少量可学习的 Latent Query：

Qlatent

然后让这些 Query 去读取大量视觉信息：

Attention(Qlatent,Kvision,Vvision)

于是：

几千个视觉 Token
        ↓
Resampler / Compression
        ↓
几十或几百个重要表示

它解决的是：

如何用更少的 Token 保留最有价值的视觉信息。

这其实是未来多模态系统非常关键的工程问题之一：

Token Efficiency

也就是 Token 效率。

---

24. 声音又是怎么进入大模型的？

声音和图片虽然物理形式不同，但思路其实完全一样。

声音原始形式可以看成：

x(t)

它是一条随时间变化的波形。

但是直接处理原始波形不一定总是最方便。

传统音频处理中，经常会把声音变成频谱或者 Mel Spectrogram。

例如通过短时傅里叶变换：

STFT(x(t))

得到一个“时间 × 频率”的表示。

然后交给 Audio Encoder：

Eaudio(X)

得到：

[a1,a2,…,an]

再经过必要的投影：

Paudio(ai)

最终变成模型可以处理的：

Audio Tokens

于是你会发现：

图片走了一圈：

Image → Visual Tokens

声音走了一圈：

Audio → Audio Tokens

文字：

Text → Text Tokens

最后又回到了同一个核心：

把不同世界信号转换成模型可以计算的向量序列。

---

25. 为什么“先转文字再给 LLM”不等于真正多模态？

早期系统很容易设计成：

声音
 ↓
语音识别 ASR
 ↓
文字
 ↓
LLM

图片也可以：

图片
 ↓
OCR / 目标检测
 ↓
文字
 ↓
LLM

这种方法当然有价值。

但是存在一个本质问题：

中间那一步会丢信息。

例如一个人说：

“你可真厉害啊。”

如果只保留文字：

你可真厉害啊

很多信息已经没有了。

因为原始语音中还可能包含：

• 音调
• 重音
• 停顿
• 节奏
• 音色
• 情绪线索

它既可能是真诚夸奖。

也可能是明显讽刺。

图片也是一样。

OCR 可以告诉模型：

100% SILK

但 OCR 无法完整表达：

• 光泽
• 纹理
• 褶皱
• 空间位置
• 材质视觉特征
• 图案结构
• 局部缺陷

所以所谓更“原生”的多模态系统，一个核心方向就是：

不要把所有世界信息都先压缩成文字再推理。

---

26. 模型最后为什么能够回答问题？

前面一直在讲 Encoder、Token、Attention。

现在来到最关键的训练目标。

假设输入：

图片：一只狗正在草地上追球

问题：
这只狗正在干什么？

正确回答：

它正在草地上追一个球。

模型训练时，并不是直接优化一个叫：

理解程度

的神秘指标。

它真正优化的是一个概率问题。

假设输出 Token 是：

y1,y2,…,yT

那么模型学习：

P(yt | I, x, y<t)

意思是：

在已经看到图片、问题以及前面答案的情况下，下一个正确 Token 应该是什么？

整个回答的概率可以写成：

P(y1:T|I,x)=∏t=1TP(yt| y<t,I,x)

训练中典型的 Cross Entropy Loss：

L=-∑t=1Tlog P(yt*| y<t*,I,x)

这就是语言生成最核心的数学目标之一。

---

27. 所以大模型其实一直在“预测下一个 Token”

很多第一次学习 LLM 的人，会默认模型的过程是：

先把整道题完整想完
 ↓
得到完整答案
 ↓
一句一句输出

底层生成机制并不是这种形式。

更加接近：

已有上下文
 ↓
预测下一个 Token
 ↓
把这个 Token 放回上下文
 ↓
预测下一个 Token
 ↓
继续

也就是：

yt ∼ P(yt|y<t,X)

从这个角度看，大语言模型本质上是一个：

条件概率模型。

它不断回答一个问题：

在当前上下文条件下，接下来最合理的 Token 是什么？

---

28. 一个非常好的问题：只是预测 Token，为什么会产生“推理”？

这个问题非常关键。

如果模型只是在预测下一个 Token，为什么最后会表现出：

• 数学能力
• 编程能力
• 常识推理
• 图片理解
• 跨模态问答

原因在于：

要想长期、稳定、准确地预测复杂世界中的下一个 Token，模型不得不学习大量隐藏结构。

例如训练数据中反复存在：

A>B

B>C

那么正确续写经常要求：

A>C

为了降低预测误差，模型内部必须学到某种可以支持这种关系处理的表示。

再比如：

红灯
 ↓
车辆停止

如果模型在海量文本、图片和视频数据中反复看到这种关系，那么要想正确预测：

为什么汽车停下来？

模型就必须捕获：

交通灯是红色
→
交通规则
→
车辆应停车

因此一个非常值得记住的区分是：

预测，是训练目标。

而：

世界表示、知识结构以及部分推理能力，是模型为了把预测这件事做得足够好而学习出的内部能力。

当然，这并不意味着神经网络的“理解”机制已经被证明与人类认知完全相同。

这是另一个更复杂的问题。

---

29. Grounding：多模态真正比纯文本更有意思的地方

纯文本模型读过：

香蕉通常是黄色的。

于是：

香蕉
黄色
水果
食物

这些概念之间会建立统计和语义关系。

但是多模态模型还可以进一步建立：

某种视觉形状
+
黄色纹理
+
真实图片
+
banana
+
香蕉

之间的联系。

这叫：

Grounding

可以理解为：

让语言概念和真实感知信号建立对应关系。

这是多模态极其关键的价值。

因为未来 AI 如果要真正进入现实世界，不仅需要知道：

“杯子”这个词是什么意思。

还要知道：

摄像头画面中哪个东西就是杯子。

机器人更加明显。

机器人不可能只会：

杯子的定义是……

它还必须知道：

杯子在哪里
多远
什么方向
能不能抓
怎么抓
抓起来以后发生什么

这时候 AI 才真正从：

语言系统

逐渐走向：

感知—推理—行动系统。

---

30. 模型到底“学”了什么？

神经网络可以抽象成一个巨大函数：

fθ(x)

其中：

θ

代表模型所有可训练参数。

比如：

WQ, WK, WV, W1, W2, ...

训练的目标，本质上就是找到一组更好的参数：

argminθL(θ)

训练过程中通过梯度计算：

∇θ L

然后更新参数：

θt+1=θt-η∇θL

其中：

η

叫学习率。

如果翻译成人话：

当前答案错了多少？

Loss 回答这个问题。

每个参数往哪个方向调整可以让错误下降？

Gradient 回答这个问题。

然后模型不断更新参数。

一次。

十万次。

一百万次。

更多次。

最后形成一个极其复杂的函数。

这就是所谓：

Training

---

31. 模型里面有没有一张“猫.jpg”？

没有必要。

这是理解神经网络和数据库区别的重要一点。

传统数据库可能更像：

key = 猫
value = 某条记录

而神经网络不是这样工作。

模型更像是在一个高维空间中形成复杂的分布式表示。

抽象地写：

z=fθ(x)

其中：

z∈ℝd

这个 z 就是某种 Latent Representation。

于是：

猫
老虎
狮子
动物
毛发
宠物

这些概念之间，不再只是“字符串”。

它们在高维空间中形成各种结构关系。

所以现代深度学习真正强大的基础之一就是：

Representation Learning

模型不是人工给每一个概念写规则。

而是在训练数据中自己学习：

什么样的内部表示最有利于完成任务。

---

32. 如果模型还可以生成图片，又是什么原理？

这里需要区分：

多模态理解

和：

多模态生成

并不是一回事。

理解图片时，我们经常讨论：

Image
→
Encoder
→
Visual Tokens
→
LLM

但是如果希望：

文字
→
图片

就需要图像生成模型。

其中一条非常重要的技术路线是 Diffusion，也就是扩散模型。

基本思想非常有意思。

训练时不断给真实图片加噪声：

xt=√αtx0+√1-αtε

其中：

ε∼𝒩(0,I)

也就是高斯噪声。

模型学习：

这张被污染过的图片里面加了什么噪声？

写成：

εθ(xt,t,c)

其中 c 可以是文本条件。

典型目标：

L=𝔼[‖ε-εθ(xt,t,c)‖22]

生成时反过来：

随机噪声
 ↓
去一点噪声
 ↓
再去一点
 ↓
逐渐出现轮廓
 ↓
出现结构
 ↓
出现细节
 ↓
最终图片

所以可以粗略理解：

LLM 做的是：

Token
→
Token
→
Token
→
Token

Diffusion 做的是：

Noise
→
Less Noise
→
Less Noise
→
Image

当然，现代视觉生成并不只有扩散一条路线，也存在自回归视觉 Token、Flow Matching 等其他技术方向。

不要把“多模态生成”简单等同于“扩散模型”。

---

33. 把整套多模态架构重新串一次

现在已经有足够知识重新看完整流程。

假设用户上传一张图片，然后问一个问题。

第一步：

I

经过视觉 Encoder：

V=Evision(I)

得到视觉表示。

第二步，如果需要，经过 Projector：

Z=P(V)

把视觉表示映射到适合语言模型处理的空间。

第三步，文本经过 Tokenizer 和 Embedding：

T=Etext(x)

然后模型得到一个多模态输入序列：

X=[Z;T]

进入 Transformer。

Transformer 里不断计算：

Q=XWQ

K=XWK

V=XWV

然后：

A=softmax(QKT√dk)

再通过：

H=AV

聚合信息。

经过很多层以后：

H(L)=TransformerL(…Transformer2(Transformer1(X)))

最终取当前生成位置的隐藏状态：

ht

投影到词表：

z=Wvocabht

然后 Softmax：

pi=ezi∑j ezj

于是模型得到：

下一个 Token 的概率分布。

选出一个 Token。

继续预测下一个。

于是完整答案出现。

---

34. 到这里，多模态大模型其实可以压缩成四件事

如果整篇文章只能记住四个词，我建议记：

1. Representation

把现实世界的数据转换成向量表示。

Image → Visual Representation

Audio → Audio Representation

Text → Text Representation

2. Alignment

让不同模态的表示建立语义对应。

Image ↔ Text

Audio ↔ Text

3. Fusion

让不同模态真正交换信息。

核心工具之一就是：

Attention

4. Prediction

根据融合后的上下文，预测输出。

P(yt|y<t,X)

因此，多模态 AI 可以非常粗暴但非常有效地概括成：

Representation+Alignment+Fusion+Prediction

这四步，比单纯背几十个模型名字重要得多。

---

35. 再往前一步：为什么多模态最终会走向 Agent？

因为只会文字的大模型，本质上仍然和现实世界隔着一层。

它可以知道：

如果机器发生异常，应该停机检查。

但它看不到机器。

而一个拥有视觉、声音、传感器输入的系统可以做到：

摄像头
 ↓
发现异常

麦克风
 ↓
发现异常声音

传感器
 ↓
发现温度异常

多模态模型
 ↓
联合判断

Agent
 ↓
触发报警 / 创建工单 / 请求人工确认

于是 AI 的能力链条逐渐变成：

Perception → Reasoning → Planning → Action

也就是：

感知
↓
理解
↓
推理
↓
决策
↓
行动

从这个角度看，多模态并不是一个“聊天机器人增加看图功能”的小升级。

它真正重要的地方在于：

它开始给 AI 接上现实世界的感官。

---

36. 我最不建议初学者死记的几个东西

学习多模态时，有几个坑特别容易掉进去。

第一个是背模型名字。

今天记：

CLIP
ViT
BLIP
Flamingo
LLaVA

明天又出现新的模型。

如果没有底层框架，很快就乱了。

真正应该先建立的是：

原始模态
 ↓
Encoder
 ↓
Representation
 ↓
Alignment / Projector
 ↓
Attention / Fusion
 ↓
LLM
 ↓
Output

第二个坑，是把所有多模态模型想成同一种结构。

不是。

不同模型可能使用：

• 不同视觉 Encoder
• 不同 Token 压缩方法
• 不同 Attention 连接方式
• 不同训练目标
• 不同生成架构
• 不同模态融合策略

应该理解“设计空间”，而不是死记一个框图。

第三个坑，是认为“向量接近就代表模型像人一样理解了世界”。

也不能这么简单说。

向量空间能够形成强大的语义结构。

但神经网络内部表示和人类主观认知之间是什么关系，远没有一句“它像人脑一样理解”这么简单。

---

37. 关于 GPT-4o、Gemini 等商业模型，需要特别严谨

很多文章喜欢画一个非常确定的架构图：

GPT-4o内部就是……
Gemini内部一定是……

这里要谨慎。

对于未完整公开架构细节的商业前沿模型，其精确的：

• 网络拓扑
• 模态连接方式
• 参数规模与分布
• 训练数据组成
• Loss 权重
• 完整训练 Recipe
• 内部 Tokenization 细节

如果官方没有公开，就应该标记为：

Information Not Available

不能把 LLaVA、Flamingo、CLIP 等公开论文架构，直接当成某个商业模型的内部真实结构。

我们可以学习公开技术路线。

但不应该把推测写成事实。

---

38. 最后，用一句真正能记住的话结束

如果有人以后再问：

多模态大模型到底是什么？

我不会回答：

就是可以处理文字、图片、声音和视频的大模型。

我会这样回答：

多模态大模型的本质，是把文字、图片、声音、视频这些原本完全不同的现实世界信号，转换成神经网络能够处理的高维表示，并通过对齐和 Attention 等机制，让这些表示能够交换信息，最后完成理解、推理和生成。

如果继续压缩：

现实世界→向量→对齐→Attention→推理→输出

你甚至可以把整个现代多模态 AI 看成是在解决一个非常宏大的问题：

如何让机器把不同感官看到的世界，变成一种可以共同计算的内部语言？

ViT 解决了一部分“图片怎么变成 Token”的问题。

Embedding 解决了一部分“文字怎么变成向量”的问题。

Projector 解决了一部分“不同模型空间怎么连接”的问题。

Alignment 解决了一部分“不同模态怎么对应”的问题。

Attention 解决了一部分“当前到底应该关注什么”的问题。

Transformer 负责反复整合这些信息。

训练算法再通过：

θt+1=θt-η∇θL

一点一点修改模型参数。

最终，我们看到的才是：

上传图片
↓
问一个问题
↓
模型看懂
↓
模型回答

表面上只有几秒钟。

但这几秒钟背后真正发生的事情，是：

像素被变成向量，向量被变成关系，关系被 Attention 汇总，信息经过几十层甚至更深的神经网络传播，最后再被投影成一个又一个概率最高的 Token。

理解到这里，你就不再只是“会用多模态大模型”。

你已经开始真正理解：

它为什么能够工作。