第三章：主流模型架构解析
在前两章中，我们从宏观层面了解了多模态学习的概念和核心技术原理。从本章开始，我们将深入分析几个代表性的多模态大模型，理解它们的架构设计、训练方法和能力特点。
这些模型的出现标志着多模态AI发展的重要里程碑：CLIP证明了图文可以统一理解，GPT-4V展示了视觉理解的新高度，Gemini则开创了原生多模态的新范式。通过学习这些模型的架构和原理，你将对多模态大模型的技术演进有更深入的理解。
3.1 CLIP：连接视觉与语言的里程碑
为什么需要CLIP？
在CLIP出现之前，计算机视觉（CV）和自然语言处理（NLP）是两个相对独立的研究领域。图像分类模型只能识别它在训练时见过的类别，文本模型只能处理文字信息。两者之间缺乏一座能够相互理解、相互翻译的"桥梁"。
注释：用"语言障碍"来类比。想象一个有翻译困难的世界：
- 只会说中文的人看不懂英文文章
- 只会说英文的人听不懂中文播报
- 两种语言之间没有对照字典，也没有自动翻译系统
这就是CLIP出现之前CV和NLP的关系——图像模型和文本模型各自为政，无法相互理解。CLIP的诞生就是为了打破这种障碍，建立视觉和语言之间的对应关系。
传统视觉模型的局限：
假设你训练了一个能识别1000种动物的图像分类模型。这个模型很强大，但有两个致命的局限：
注释：第一个局限是类别封闭。如果测试时出现训练数据中没有的动物（比如"穿山甲"），模型就会完全无法识别，只能从它已知的1000个类别中选一个最接近的，答案是错误的。
注释：第二个局限是语义单一。模型只能输出"这是猫"这样的类别标签，无法理解更丰富的语义。比如给模型看一张"一只橘猫坐在窗台上看着雨"的图片，模型只能告诉你"猫"，而无法理解"猫在窗台上看雨"这个更丰富的场景。
CLIP的突破：
CLIP（Contrastive Language-Image Pre-training）的核心思想是：与其让模型预测固定的类别标签，不如让模型学习图像和文本描述之间的对应关系。
注释：这个思想转变的意义非常重大。想象你要教一个孩子认识动物：
- 传统方法：你给他看很多标记了"猫"、"狗"标签的照片，让他记住每种动物长什么样
- CLIP方法：你给他看很多配有文字描述的照片，让他理解"什么样的画面对应什么样的文字描述"
第二种方法的优势是：孩子学会的是"图文对应"这种通用的能力，而不仅仅是记住几个特定的类别。当遇到他没见过的动物时，只要给他一个文字描述，他就能识别出对应的动物。
CLIP的架构设计
CLIP的架构设计简洁而优雅，它由两个主要组件组成：视觉编码器和文本编码器。
双编码器架构详细图：
┌─────────────────────────────────────────────────────────────────────────────┐
│ CLIP双编码器架构详解 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌───────────────────────────────────────────────────────────────────────┐ │
│ │ 图像输入层 │ │
│ │ 🖼️ 输入图像 (224×224×3) │ │
│ └───────────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌───────────────────────────────────────────────────────────────────────┐ │
│ │ 视觉编码器 (Vision Encoder) │ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────────────────────────┐ │ │
│ │ │ 图像分块 (Patch Partition) │ │ │
│ │ │ 224×224×3 → 16×16×3 patches (14×14=196个) │ │ │
│ │ └─────────────────────────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────────────────────┐ │ │
│ │ │ 线性投影 (Linear Projection) │ │ │
│ │ │ Patch Embedding + Position Embedding │ │ │
│ │ └─────────────────────────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────────────────────┐ │ │
│ │ │ Vision Transformer (ViT) │ │ │
│ │ │ 12层Transformer Encoder │ │ │
│ │ │ [CLS] token输出作為图像全局特征 │ │ │
│ │ └─────────────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └───────────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌───────────────────────────────────────────────────────────────────────┐ │
│ │ 视觉特征向量 │ │
│ │ I_emb ∈ ℝ^(batch_size × d) │ │
│ │ (d = 512 或 768) │ │
│ └───────────────────────────────────────────────────────────────────────┘ │
│ │
│ ══════════════════════════════════════════════════════════════════════════ │
│ │
│ ┌───────────────────────────────────────────────────────────────────────┐ │
│ │ 文本输入层 │ │
│ │ 📝 输入文本 "a photo of a cat" │ │
│ └───────────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌───────────────────────────────────────────────────────────────────────┐ │
│ │ 文本编码器 (Text Encoder) │ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────────────────────────┐ │ │
│ │ │ 分词 (Tokenization) │ │ │
│ │ │ "a photo of a cat" → [a, photo, of, a, cat, <EOS>] │ │ │
│ │ └─────────────────────────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────────────────────┐ │ │
│ │ │ 词嵌入 (Word Embedding) │ │ │
│ │ │ Token → Vector (d=512) │ │ │
│ │ └─────────────────────────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────────────────────┐ │ │
│ │ │ Transformer Encoder (12层) │ │ │
│ │ │ [CLS] token输出作為文本全局特征 │ │ │
│ │ └─────────────────────────────────────────────────────────────────┘ │ │
│ │ │ │
│ └───────────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌───────────────────────────────────────────────────────────────────────┐ │
│ │ 文本特征向量 │ │
│ │ T_emb ∈ ℝ^(batch_size × d) │ │
│ │ (d = 512 或 768) │ │
│ └───────────────────────────────────────────────────────────────────────┘ │
│ │
│ ══════════════════════════════════════════════════════════════════════════ │
│ │
│ │ │
│ ┌──────────────┴──────────────┐ │
│ ▼ ▼ │
│ ┌────────────────────────────┐ ┌────────────────────────────┐ │
│ │ 视觉投影层 (Projection) │ │ 文本投影层 (Projection) │ │
│ │ W_v ∈ ℝ^(d × d) │ │ W_t ∈ ℝ^(d × d) │ │
│ └─────────────┬──────────────┘ └─────────────┬──────────────┘ │
│ │ │ │
│ ▼ ▼ │
│ ┌────────────────────────────┐ ┌────────────────────────────┐ │
│ │ 视觉嵌入向量 │ │ 文本嵌入向量 │ │
│ │ I_final ∈ ℝ^(d) │ │ T_final ∈ ℝ^(d) │ │
│ └─────────────┬──────────────┘ └─────────────┬──────────────┘ │
│ │ │ │
│ └──────────────┬──────────────┘ │
│ ▼ │
│ ┌───────────────────────────────────────────────────────────────────────┐ │
│ │ 统一特征空间 │ │
│ │ │ │
│ │ I_final · T_final = 余弦相似度 │ │
│ │ │ │
│ └───────────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌───────────────────────────────────────────────────────────────────────┐ │
│ │ 对比学习目标 │ │
│ │ │ │
│ │ 正样本：匹配的图文对 → 高相似度 │ │
│ │ 负样本：不匹配的图文对 → 低相似度 │ │
│ │ │ │
│ └───────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────┘视觉编码器：
CLIP使用Vision Transformer（ViT）或ResNet作为视觉编码器。ViT是目前更常用的选择，因为它与Transformer架构更契合。
注释：视觉编码器的工作流程：
- 图像分块：把输入图像切成固定大小的patch（如16×16像素）
- 线性投影：把每个patch展平并通过线性层转换为向量
- 加入位置编码：添加每个patch的位置信息
- Transformer处理：输入Transformer编码器进行特征提取
- 输出：通常是[CLS]标记对应的输出，或者所有patch输出的平均值
文本编码器：
CLIP使用Transformer编码器作为文本编码器，与GPT等语言模型使用的是同一种架构（只是只用了编码器部分）。
注释：文本编码器的工作流程：
- 分词：把输入文本切成子词（subword）单元
- 嵌入：把每个子词转换为向量表示
- 位置编码：添加位置信息
- Transformer处理：输入Transformer编码器进行特征提取
- 输出：通常使用[CLS]标记对应的输出作为整个文本的特征
投影到统一空间：
为了让图像和文本能够在同一个空间中进行比较，CLIP在两个编码器的输出之后各加了一个线性投影层，把视觉特征和文本特征都投影到同一个维度的空间（如512维或768维）。
注释：投影操作是简单的线性变换：y = Wx + b，其中W是投影矩阵，b是偏置向量。训练过程中，投影矩阵的参数也会被优化，让投影后的向量更适合进行对比学习。
CLIP PyTorch实现：
import torch
import torch.nn as nn
import torch.nn.functional as F
from transformers import ViTModel, BertModel
from collections import OrderedDict
class CLIPVisionEncoder(nn.Module):
"""CLIP视觉编码器"""
def __init__(self, model_name="google/vit-base-patch16-224", embed_dim=512):
super().__init__()
self.vit = ViTModel.from_pretrained(model_name)
self.projection = nn.Linear(self.vit.config.hidden_size, embed_dim)
def forward(self, images):
"""
参数:
images: [batch_size, 3, 224, 224]
返回:
image_features: [batch_size, embed_dim]
"""
# 获取ViT输出
outputs = self.vit(images)
# 使用[CLS]token的输出
image_embeds = outputs.last_hidden_state[:, 0, :]
# 投影到统一空间
image_features = self.projection(image_embeds)
# L2归一化
image_features = F.normalize(image_features, dim=-1)
return image_features
class CLIPTextEncoder(nn.Module):
"""CLIP文本编码器"""
def __init__(self, model_name="bert-base-uncased", embed_dim=512):
super().__init__()
self.bert = BertModel.from_pretrained(model_name)
self.projection = nn.Linear(self.bert.config.hidden_size, embed_dim)
def forward(self, input_ids, attention_mask=None):
"""
参数:
input_ids: [batch_size, seq_len]
attention_mask: [batch_size, seq_len]
返回:
text_features: [batch_size, embed_dim]
"""
# 获取BERT输出
outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
# 使用[CLS]token的输出
text_embeds = outputs.last_hidden_state[:, 0, :]
# 投影到统一空间
text_features = self.projection(text_embeds)
# L2归一化
text_features = F.normalize(text_features, dim=-1)
return text_features
class CLIPModel(nn.Module):
"""完整的CLIP模型"""
def __init__(self, embed_dim=512, temperature=0.07):
super().__init__()
self.vision_encoder = CLIPVisionEncoder(embed_dim=embed_dim)
self.text_encoder = CLIPTextEncoder(embed_dim=embed_dim)
self.temperature = nn.Parameter(torch.tensor(torch.log(1 / temperature)))
def forward(self, images, input_ids, attention_mask=None):
"""
前向传播
参数:
images: [batch_size, 3, 224, 224]
input_ids: [batch_size, seq_len]
attention_mask: [batch_size, seq_len]
返回:
image_features: [batch_size, embed_dim]
text_features: [batch_size, embed_dim]
logits: [batch_size, batch_size]
"""
# 获取图像和文本特征
image_features = self.vision_encoder(images)
text_features = self.text_encoder(input_ids, attention_mask)
# 计算相似度矩阵
logits = torch.matmul(image_features, text_features.t()) * self.temperature.exp()
return image_features, text_features, logits
def compute_loss(self, image_features, text_features, logits):
"""
计算对比学习损失
参数:
image_features: [batch_size, embed_dim]
text_features: [batch_size, embed_dim]
logits: [batch_size, batch_size]
返回:
loss: 对比学习损失
"""
# 创建标签（对角线为正样本）
labels = torch.arange(image_features.size(0), device=image_features.device)
# 计算交叉熵损失
loss = F.cross_entropy(logits, labels)
# 计算准确率
predictions = logits.argmax(dim=1)
accuracy = (predictions == labels).float().mean()
return loss, accuracy.item()
# 使用示例
if __name__ == "__main__":
# 创建模型
clip = CLIPModel(embed_dim=512)
# 模拟数据
batch_size = 4
images = torch.randn(batch_size, 3, 224, 224)
input_ids = torch.randint(0, 1000, (batch_size, 32))
attention_mask = torch.ones(batch_size, 32)
# 前向传播
image_features, text_features, logits = clip(images, input_ids, attention_mask)
print(f"图像特征形状: {image_features.shape}")
print(f"文本特征形状: {text_features.shape}")
print(f"相似度矩阵形状: {logits.shape}")
# 计算损失
loss, accuracy = clip.compute_loss(image_features, text_features, logits)
print(f"对比学习损失: {loss.item():.4f}")
print(f"图文匹配准确率: {accuracy:.2%}")
print("CLIP模型测试通过！")代码详解：
- CLIPVisionEncoder类：基于ViT的视觉编码器，包含投影层和L2归一化
- CLIPTextEncoder类：基于BERT的文本编码器，包含投影层和L2归一化
- CLIPModel类：完整的CLIP模型，整合视觉和文本编码器
- temperature参数：可学习的温度参数，用于控制相似度分布的锐利程度
CLIP的训练方法
CLIP的训练方法是大规模对比预训练，这是它能够学会图文对应能力的关键。
训练数据：
CLIP的训练数据是从互联网上收集的4亿个图文对（image-text pairs）。这些数据来自各种来源：
- 搜索引擎的结果（用户搜索词和对应的图片）
- 社交媒体的图片配文
- 电商平台的商品图片和描述
- 图片版权网站的标题和描述
- 各种带有文字说明的图片
注释：这4亿个图文对的特点是：
- 规模巨大：4亿个样本，远超大多数视觉数据集
- 来源多样：涵盖各种主题、风格、质量
- 自然配对：文字描述是自然产生的，不是人工标注的固定类别标签
- 噪声存在：由于是从互联网收集，配对质量参差不齐（有些图片和文字可能不太相关）
CLIP训练流程图：
┌─────────────────────────────────────────────────────────────────────────────┐
│ CLIP大规模对比预训练流程 │
├─────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌───────────────────────────────────────────────────────────────────────┐ │
│ │ 数据准备阶段 │ │
│ │ │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ 4亿图文对 │ │ 数据清洗 │ │ Batch划分 │ │ │
│ │ │ 原始数据 │──▶│ 质量过滤 │──▶│ N个样本/批 │ │ │
│ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │
│ │ │ │
│ └───────────────────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌───────────────────────────────────────────────────────────────────────┐ │
│ │ 训练循环 (Epochs) │ │
│ │ │ │
│ │ ┌─────────────────────────────────────────────────────────────────┐ │ │
│ │ │ 步骤1: 加载Batch (N个图文对) │ │ │
│ │ └─────────────────────────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────────────────────┐ │ │
│ │ │ 步骤2: 编码图文对 │ │ │
│ │ │ │ │ │
│ │ │ 图像 → ViT编码 → 视觉特征 I_i (i=1...N) │ │ │
│ │ │ 文本 → BERT编码 → 文本特征 T_j (j=1...N) │ │ │
│ │ │ │ │ │
│ │ └─────────────────────────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────────────────────┐ │ │
│ │ │ 步骤3: 投影到统一空间 + 归一化 │ │ │
│ │ │ │ │ │
│ │ │ I'_i = normalize(W_v * I_i) │ │ │
│ │ │ T'_j = normalize(W_t * T_j) │ │ │
│ │ │ │ │ │
│ │ └─────────────────────────────────────────────────────────────────┘ │ │
│ │ │ │ │
│ │ ▼ │ │
│ │ ┌─────────────────────────────────────────────────────────────────┐ │ │
│ │ │ 步骤4: 计算相似度矩阵 │ │ │
│ │ │ │ │ │
│ │ │ S = I'_i · T'_j^T (N×N矩阵) │ │ │
│ │ │ │ │ │
│ │ │ T'_1 T'_2 T
### CLIP的能力与应用
CLIP经过大规模对比预训练后，获得了几个非常重要的能力：
**Zero-shot图像分类**：
这是CLIP最令人惊叹的能力。CLIP不需要任何特定类别的训练样本，就能够进行图像分类。
**注释**：传统图像分类 vs CLIP的Zero-shot分类：
**传统方法**：
- 训练数据：标记了类别的图像（如ImageNet的1000类）
- 测试时：从固定的1000个类别中选一个
- 局限：只能识别训练过的类别
**CLIP Zero-shot方法**：
- 训练数据：4亿个图文对（没有特定类别标签）
- 测试时：生成候选类别的文字描述，计算相似度
- 优势：可以识别任何能描述出来的类别
**Zero-shot分类示例**：
假设要对一张图片进行分类，类别是"猫"、"狗"、"汽车"。
**注释**：CLIP的做法是：
1. 把类别名称转换为文本描述，如"a photo of a cat"、"a photo of a dog"、"a photo of a car"
2. 用文本编码器得到三个文本嵌入向量
3. 用视觉编码器得到图像的嵌入向量
4. 计算图像向量与三个文本向量的相似度
5. 选择相似度最高的类别作为答案
**CLIP的能力边界**：
需要注意的是，CLIP虽然强大，但也有它的局限性：
**注释**：CLIP的局限性包括：
1. **复杂场景表现有限**：对于需要复杂推理的场景，CLIP的表现可能不佳
2. **细粒度识别困难**：区分相似类别（如不同品种的狗）可能有困难
3. **文字识别能力有限**：虽然能理解图像中的文字，但不是它的强项
4. **分布偏移敏感**：对于与训练数据分布差异较大的图像，效果可能下降
### CLIP的深远影响
CLIP的发布对多模态AI领域产生了深远的影响：
**注释**：CLIP的影响可以从几个方面来看：
1. **证明了图文统一学习的可行性**：大规模对比学习确实能让模型学会图文对应
2. **开启了多模态预训练的新范式**：之后的多模态模型（如ALIGN、BLIP等）都借鉴了CLIP的思想
3. **推动了AIGC的发展**：CLIP的图文对齐能力是Stable Diffusion等文生图模型的关键组件
4. **启发了视频、音频等其他模态的学习**：类似的方法被扩展到视频-文本、音频-文本等任务
**本节小结**：
CLIP的核心贡献是：
- **双编码器架构**：视觉编码器 + 文本编码器，分别处理图像和文本
- **大规模对比学习**：用4亿个图文对进行对比预训练
- **统一特征空间**：让图像和文本能够在同一个空间中比较
- **Zero-shot能力**：无需特定类别训练样本即可进行图像分类
**思考题**：CLIP为什么需要那么大的训练数据规模？如果只用100万个图文对训练，结果会有什么不同？
---
## 3.2 GPT-4V：视觉理解的新高度
### 从GPT-4到GPT-4V
GPT-4是OpenAI在2023年发布的大语言模型，它在语言理解、生成、推理等方面达到了前所未有的高度。GPT-4V（GPT-4 with Vision）是GPT-4的视觉增强版本，增加了理解图像内容的能力。
**注释**：GPT-4V不是另起炉灶的新模型，而是在GPT-4的基础上"嫁接"了视觉理解能力。这种方法的优势是可以复用GPT-4强大的语言理解和生成能力，缺点是视觉和语言的融合可能不够自然。
**GPT-4和GPT-4V的能力对比**：
| 能力维度 | GPT-4 | GPT-4V |
|---------|-------|--------|
| 文本理解 | ★★★★★ | ★★★★★ |
| 文本生成 | ★★★★★ | ★★★★★ |
| 图像理解 | ★☆☆☆☆ | ★★★★★ |
| 图像生成 | ★☆☆☆☆ | ★☆☆☆☆ |
| 视觉推理 | 不支持 | ★★★★☆ |
| 多模态对话 | 不支持 | ★★★★★ |
**GPT-4V的架构设计**
关于GPT-4V的具体架构，OpenAI没有公开详细的论文或技术报告。我们只能根据公开信息推测其架构设计。
**推测的架构**：
基于已知信息和多模态模型的常见设计，GPT-4V很可能采用**"视觉编码器 + 语言模型"**的拼接式架构：
图像输入 文本输入 │ │ ▼ ▼ ┌────────────────┐ ┌────────────────┐ │ 视觉编码器 │ │ 词嵌入层 │ │ (可能是ViT变体) │ │ (Token Embed) │ └───────┬────────┘ └───────┬────────┘ │ │ ▼ │ 视觉特征 │ │ │ ▼ │ ┌────────────────┐ │ │ 投影/适配层 │ │ │ (Project/Adapt)│ │ └───────┬────────┘ │ │ │ └───────────┬────────────┘ │ ▼ ┌────────────────────┐ │ GPT-4 语言模型 │ │ (Transformer解码器) │ └──────────┬─────────┘ │ ▼ 文本输出
**注释**：这个架构的各个组件：
1. **视觉编码器**：负责"看懂"图像，可能使用ViT或类似架构
2. **投影/适配层**：把视觉特征转换为语言模型可以理解的格式
3. **GPT-4语言模型**：负责理解和生成文本，这是整个系统的"大脑"
**视觉编码器的设计选择**：
视觉编码器有几种可能的设计选择：
**选项一：独立ViT编码器**
- 使用一个独立的ViT处理图像
- 把图像patch的编码序列"插入"到文本token序列中
- 优点：ViT是成熟的技术，效果有保障
- 缺点：视觉和语言的交互较晚才开始
**选项二：视觉Transformer与语言模型联合训练**
- 使用一个端到端的架构，视觉和语言部分联合优化
- 类似于Flamingo、Kosmos-1等模型的设计
- 优点：视觉和语言可以更深度融合
- 缺点：训练复杂度更高
**选项三：CLIP-style预训练 + 语言模型微调**
- 先用CLIP-style方法预训练视觉编码器
- 然后与语言模型连接并进行端到端微调
- 优点：可以利用大规模图文数据
- 缺点：需要多阶段训练
**注释**：根据GPT-4V展现出的能力（特别是复杂的视觉推理能力），推测它可能采用了较为深度的视觉-语言融合设计，可能使用了交叉注意力机制让语言模型能够直接"关注"图像的不同区域。
### GPT-4V的核心能力
GPT-4V展现了多方面的视觉理解能力：
**图像描述与理解**：
GPT-4V能够详细描述图片中的内容，包括场景、物体、人物、动作等。
**注释**：示例对话：
- 用户：（发送一张城市天际线的照片）
- GPT-4V：这张照片展示了[城市名]的城市景观。前景是[某建筑]，背景是[其他地标]。天气看起来是[晴天/阴天]，时间是[白天/傍晚]。照片的构图...
**视觉问答（VQA）**：
GPT-4V能够回答关于图片的各种问题，从简单的事实识别到复杂的推理。
**注释**：问题类型包括：
- **事实性问题**：图中有几个人？他们在做什么？
- **比较性问题**：这张图和那张图有什么不同？
- **推理问题**：根据图中的线索，发生了什么事？
- **开放性问题**：你对这张图片有什么看法？
**文本识别（OCR）**：
GPT-4V能够识别图片中的文字，包括印刷体和手写体。
**注释**：应用场景：
- 识别商品包装上的文字
- 转录手写笔记
- 读取路牌、指示牌
- 识别公式、图表中的文字
**图表与文档理解**：
GPT-4V能够理解数据图表、流程图、UI界面等结构化视觉信息。
**注释**：具体能力包括：
- 解读柱状图、折线图的趋势
- 理解流程图的逻辑
- 分析UI界面的布局和功能
- 从文档图片中提取关键信息
**多图像比较**：
GPT-4V能够同时处理多张图片，进行比较和分析。
**注释**：应用示例：
- 比较两张图片的异同
- 分析图片序列的时间变化
- 从多张图片中综合信息回答问题
**视觉推理**：
GPT-4V能够进行需要推理的视觉任务，如理解漫画、识别图像中的逻辑关系等。
**注释**：这是GPT-4V相比早期视觉模型的一个重大进步。早期模型通常只能做简单的识别任务，而GPT-4V能够理解图像的深层含义、隐喻、幽默等。
**GPT-4V的能力示例**：
示例1：理解讽刺漫画 输入：一张讽刺职场加班文化的漫画 GPT-4V能理解漫画的讽刺意图，解释其中的幽默点
示例2：识别UI可用性问题 输入：一张App界面的截图 GPT-4V能识别界面中的可用性问题，如按钮太小、文字难以阅读等
示例3：解答数学几何题 输入：一张几何证明题的配图 GPT-4V能理解图形，分析题目要求，给出解题步骤
### GPT-4V的提示工程
使用GPT-4V时，提示工程（Prompt Engineering）的技巧非常重要。以下是一些最佳实践：
**注释**：提示工程是在GPT-4V时代更加重要的技能。同样的图片，不同的提问方式可能导致截然不同的回答质量。
**技巧一：明确问题类型**
**不太好的提问**：这张图里有什么？
**更好的提问**：请详细描述这张图片中的场景，包括主要物体、人物动作、环境氛围等。
**注释**：越具体、越明确的问题，越容易得到高质量的回答。
**技巧二：提供上下文**
**不太好的提问**：这个图表显示了什么？
**更好的提问**：这是一张关于公司季度销售额的柱状图，请分析销售额的变化趋势，并推测可能的原因。
**注释**：提供上下文信息可以帮助模型更好地理解任务需求。
**技巧三：分步骤提问**
对于复杂问题，可以先问简单的问题，再逐步深入。
**注释**：示例：
1. 先问：图片中主要有哪些物体？
2. 再问：这些物体之间是什么关系？
3. 最后问：基于图片内容，你能推断出发生了什么故事？
**技巧四：指定输出格式**
如果需要特定格式的输出，可以在提示中明确说明。
**注释**：示例：
- "请用JSON格式输出图片中识别的物体列表"
- "请用表格形式对比这两张图片的异同"
- "请用100字以内概括这张图片的主要内容"
### GPT-4V的局限性
尽管GPT-4V展现了强大的能力，但它也有明显的局限性：
**注释**：了解局限性对于正确使用GPT-4V非常重要：
1. **空间推理能力有限**
- 难以准确判断物体之间的精确空间关系
- 对于需要精确测量的任务表现不佳
2. **小物体识别困难**
- 当图像中有很多细节时，可能忽略小物体
- 对于密集场景，识别可能不完整
3. **幻觉问题**
- 可能生成与图像内容不符的描述
- 对于不确定的内容，可能"编造"答案
4. **不擅长数字计算**
- 从图像中提取数据进行精确计算可能有困难
- 复杂的数学问题容易出错
5. **依赖提示质量**
- 回答质量很大程度上取决于提问方式
- 不当的提示可能导致误导性回答
**本节小结**：
GPT-4V的核心特点是：
- **拼接式架构**：在GPT-4基础上增加视觉编码器
- **多能力融合**：集成了图像描述、视觉问答、OCR、图表理解等多种能力
- **视觉推理**：相比早期模型，具有更强的视觉推理能力
- **提示依赖性**：回答质量很大程度上取决于提示的设计
**思考题**：如果让你设计一个比GPT-4V更强的视觉语言模型，你会做出哪些改进？
---
## 3.3 Gemini：原生多模态架构
### 什么是"原生多模态"？
在介绍GPT-4V时，我们提到它采用的是"拼接式"架构——先有语言模型，再"嫁接"视觉能力。而Gemini采用的是"原生多模态"（Native Multimodal）架构，从设计之初就考虑了多模态输入。
**注释**：用**"语言学习"**来类比两种架构的区别：
**拼接式（如GPT-4V）**：
- 一个人先学会了流利的中文（语言模型）
- 后来又学习了看图能力（视觉模块）
- 他能用两种能力，但本质上仍然是两套系统
- 需要通过"翻译"（接口）才能交流
**原生多模态（如Gemini）**：
- 一个人从小同时学习中文和看图（两种能力一起学）
- 他的大脑自然地建立了图文关联
- 理解和表达都更加自然、协调
**原生多模态的优势**：
原生多模态设计有几个关键优势：
**注释**：优势一：更自然的跨模态推理
- 模型不需要在不同模态之间"翻译"
- 可以直接在多模态输入上进行推理
- 类似于人类的认知方式
**注释**：优势二：更流畅的多模态生成
- 能够同时输出文本和图像内容
- 文本和图像的生成更加协调一致
- 不存在"语言生成一部分，再转图像"的问题
**注释**：优势三：更强的上下文理解
- 能够综合多种模态的信息进行深度理解
- 不存在信息在模态间传递时的损失
- 上下文理解更加完整
### Gemini的架构设计
Gemini是Google DeepMind在2023年底发布的系列模型，包括Gemini Ultra、Pro、Nano三个版本。Gemini Ultra是最强大的版本，在多项基准测试中超越了GPT-4。
**架构特点**：
Gemini的架构设计有几个关键特点：
**多模态Transformer**：
- 使用统一的Transformer架构处理多种模态
- 不同模态的输入被"token化"成统一的序列格式
- 在同一个模型中进行端到端的处理
**模态特定的编码器**：
- 文本使用标准的子词分词器
- 图像被"视觉分词器"（Visual Tokenizer）转换为token序列
- 音频被转换为梅尔频谱图或类似表示，再进行分词
**长上下文处理**：
- 支持很长的上下文窗口（如100万tokens）
- 能够处理长文档、长对话、多图等复杂场景
**Gemini架构简化图**：
多模态输入 │ ├──→ 文本 ──→ 分词器 ──→ 文本Token序列 ├──→ 图像 ──→ 视觉分词器 → 图像Token序列 └──→ 音频 ──→ 音频编码器 ─→ 音频Token序列 │ └──→ 统一输入到Gemini模型 │ ▼ ┌────────────────────┐ │ 多模态Transformer │ │ (统一处理所有Token) │ └─────────┬──────────┘ │ ▼ ┌────────────────────┐ │ 多模态输出生成 │ │ (文本/图像可选) │ └────────────────────┘
**Gemini 1.5 Pro的突破**：
Gemini 1.5 Pro引入了一个革命性的特性：**支持高达100万tokens的上下文窗口**。
**注释**：100万tokens是什么概念？
- 大约等于100万英文单词，或50万中文汉字
- 可以同时处理：
- 1小时的视频内容
- 完整的代码库
- 多本长篇小说的文本
- 数十张高分辨率图片
**这个能力的意义**：
**注释**：超长上下文的意义：
1. **完整理解长文档**：能够一次读完一本完整的小说或技术文档
2. **跨文档分析**：能够比较分析多个相关文档
3. **视频理解**：能够处理长达1小时的视频，提取关键信息
4. **代码库理解**：能够一次性理解整个项目的代码结构
### Gemini的核心能力
Gemini在多个方面展现了强大的能力：
**原生多模态理解**：
Gemini能够无缝地在不同模态之间"切换"，理解它们之间的关系。
**注释**：示例能力：
- 看一张食谱图片，然后按照步骤做菜
- 看一段音乐视频，然后分析其中的音乐元素
- 同时理解图表和配套的文字说明
**高质量文本生成**：
作为基于Transformer的大语言模型，Gemini继承了强大的文本生成能力。
**注释**：文本生成能力包括：
- 长篇文章写作
- 代码编写和调试
- 创意写作
- 复杂问题的分析
**原生图像生成**：
与GPT-4V不同，Gemini能够**原生生成图像**，而不是只能处理图像。
**注释**：原生图像生成的意义：
- 生成与文本描述高度匹配的图像
- 能够在生成过程中"参考"已有的图像
- 文本和图像的生成更加协调一致
**视频理解**：
Gemini能够理解视频内容，包括动作、场景、时间变化等。
**注释**：视频理解能力：
- 识别视频中的动作和事件
- 理解视频的时间线
- 从视频中提取关键帧和信息
- 回答关于视频内容的问题
**代码能力**：
Gemini在代码理解和生成方面也有出色的表现。
**注释**：代码能力包括：
- 多语言代码生成
- 代码理解和解释
- 代码调试和优化
- 多个文件之间的代码关系分析
### Gemini的技术创新
Gemini的技术创新体现在几个方面：
**注释**：技术创新一：大规模多模态预训练
- 在预训练阶段同时接触文本、图像、视频、音频
- 使用混合模态的数据集进行训练
- 让模型从一开始就建立跨模态的关联
**注释**：技术创新二：高效的架构设计
- 使用改进的Transformer架构
- 优化的注意力机制，处理长序列
- 高效的推理和部署
**注释**：技术创新三：复杂的训练流程
- 多阶段训练，包括预训练、微调、对齐等
- 使用人类反馈进行强化学习（RLHF）
- 严格的安全过滤和评估
### 三种模型的对比
让我们对比一下CLIP、GPT-4V和Gemini这三种代表性模型：
| 对比维度 | CLIP | GPT-4V | Gemini |
|---------|------|--------|--------|
| 发布机构 | OpenAI | OpenAI | Google DeepMind |
| 发布时间 | 2021 | 2023 | 2023 |
| 架构类型 | 双编码器 | 拼接式 | 原生多模态 |
| 训练方式 | 对比学习 | 指令微调 | 多模态预训练 |
| 核心能力 | 图文匹配 | 视觉问答 | 原生多模态理解 |
| Zero-shot能力 | ★★★★★ | ★★★☆☆ | ★★★★☆ |
| 图像生成 | ✗ | ✗ | ✓ |
| 视频理解 | ✗ | 有限 | ★★★☆☆ |
| 上下文长度 | N/A | 约8K-128K | 最高100万 |
| 开放程度 | 开源 | 闭源 | 闭源 |
**注释**：从对比中可以看出三种模型的设计哲学：
- **CLIP**：专注于图文对齐，采用简洁的双编码器架构，是很多后续模型的基础
- **GPT-4V**：在强大的语言模型基础上增加视觉能力，强调视觉问答和推理
- **Gemini**：从架构层面原生支持多模态，追求更自然的跨模态理解和生成
**本节小结**：
Gemini的核心特点是：
- **原生多模态架构**：从设计之初就支持多模态输入，而非后期拼接
- **统一Transformer**：使用同一个模型处理文本、图像、视频、音频
- **超长上下文**：支持高达100万tokens的上下文窗口
- **原生图像生成**：能够直接生成图像，而非只能处理图像
**思考题**：你认为"原生多模态"和"拼接式多模态"哪个是未来的发展方向？为什么？
---
## 3.4 本章小结与练习
### 核心概念回顾
让我们用简洁的关键词回顾本章学到的核心概念：
**CLIP**：
- 双编码器架构：视觉编码器 + 文本编码器
- 大规模对比学习：4亿个图文对进行预训练
- 统一特征空间：让图文能够在同一空间中比较
- Zero-shot能力：无需特定类别训练样本即可分类
**GPT-4V**：
- 拼接式架构：GPT-4 + 视觉编码器
- 多能力融合：图像描述、视觉问答、OCR、图表理解
- 视觉推理：相比早期模型，具有更强的推理能力
- 提示依赖性：回答质量很大程度上取决于提示设计
**Gemini**：
- 原生多模态：从设计之初就支持多模态
- 统一Transformer：同一个模型处理多种模态
- 超长上下文：支持高达100万tokens
- 原生图像生成：能够直接生成图像
### 知识关系图
主流模型架构 │ ├── CLIP：图文统一 │ │ │ ├── 双编码器架构 │ ├── 对比学习预训练 │ ├── 统一特征空间 │ └── Zero-shot分类 │ ├── GPT-4V：视觉增强 │ │ │ ├── 拼接式架构 │ ├── 多能力融合 │ ├── 视觉推理 │ └── 提示工程 │ └── Gemini：原生多模态 │ ├── 原生多模态设计 ├── 统一Transformer ├── 超长上下文 └── 原生图像生成
### 实践任务
**任务一：CLIP Zero-shot实验**
使用CLIP模型（或其开源实现如openai/clip）完成以下实验：
1. 准备3-5张不同类别的图片（如猫、狗、汽车、房子）
2. 设计3组不同的类别标签（每组5-10个类别）
3. 使用CLIP进行Zero-shot分类，记录准确率
4. 分析：哪些类别容易识别？哪些类别容易混淆？
**任务二：GPT-4V提示工程实验**
使用GPT-4V（或类似的视觉语言模型）完成以下实验：
1. 选择一张复杂的图片（如有多个物体的场景图）
2. 设计3种不同详细程度的提示
3. 比较不同提示得到的回答质量
4. 总结：什么样的提示能获得更好的回答？
**任务三：模型能力对比表**
查阅相关资料，补充完善以下对比表：
| 能力维度 | GPT-4V | Gemini Ultra | Claude 3 Opus |
|---------|--------|--------------|---------------|
| 图像理解 | | | |
| 视觉推理 | | | |
| 代码能力 | | | |
| 长上下文 | | | |
| 图像生成 | | | |
### 思考题参考答案提示
**3.1节思考题**：CLIP为什么需要那么大的训练数据规模？如果只用100万个图文对训练，结果会有什么不同？
**参考思路**：
- CLIP需要学习足够广泛的图文对应关系，覆盖各种物体、场景、概念
- 4亿规模才能保证覆盖长尾类别和少见场景
- 如果只用100万，可能导致：
- Zero-shot能力大幅下降
- 对少见类别识别能力差
- 特征空间不够均匀
**3.2节思考题**：如果让你设计一个比GPT-4V更强的视觉语言模型，你会做出哪些改进？
**参考方向**：
- 更深度的视觉-语言融合（如原生多模态架构）
- 更强的视觉推理能力（增加推理模块）
- 更好的小物体识别（改进视觉编码器）
- 更长的图像序列处理能力
**3.3节思考题**：你认为"原生多模态"和"拼接式多模态"哪个是未来的发展方向？
**参考思路**：
- 原生多模态是更优雅、更一致的设计
- 但拼接式可以更快地复用现有成果
- 未来可能是两者融合：既有原生设计，又有模块化扩展
### 预告：下一章
在第三章中，我们详细分析了三个代表性的多模态模型：CLIP、GPT-4V和Gemini。这些模型代表了多模态AI发展的不同阶段和设计理念。
**第四章预告：视觉-语言模型详解**
- 视觉-语言模型的核心任务
- BLIP系列：引导语言-图像预训练
- LLaVA：大型语言和视觉助手
- 视觉-语言模型的应用场景
下一章我们将深入讲解视觉-语言模型（Vision-Language Models）的核心技术，包括几个代表性模型的设计和训练方法。
---
**本章作者**：智柴网（zhichai.net）
**发布日期**：2026年1月
**版权声明**：© 2026 智柴网 版权所有