多模态大模型 VLM 架构：从模态对齐到 GPT-4V 的完整技术栈

1
2017  - Attention Is All You Need (Transformer)
2
2021  - CLIP (Radford et al.) — 视觉语言预训练
3
       - ALIGN (Jia et al.) — 大规模双塔模型
4

5
2023  - Flamingo (Alayrac et al.) — 冻结 LLM + Perceiver Resampler
6
       - BLIP-2 (Li et al.) — 轻量级 Q-Former 桥接器
7
       - LLaVA (Liu et al.) — MLP 投影 + 指令微调 ★
8
       - InstructBLIP (Liu et al.) — 指令感知 Q-Former
9
       - GPT-4V (OpenAI) — 多模态 GPT-4
10

11
2024  - LLaVA-1.5 (Liu et al.) — MLP 投影 + OCR 数据 ★
12
       - Qwen-VL (Alibaba) — 大模型 + 全模态支持
13
       - CogVLM (Tsinghua) — 深度视觉语言融合
14
       - InternVL (Shanghai AI Lab) — 大视觉编码器
15
       - MiniGPT-4v2 — 高效多模态

1
from transformers import CLIPVisionModel, AutoImageProcessor
2

3

4
class CLIPVisionEncoder:
5
    """
6
    基于 CLIP ViT 的视觉编码器。
7
    输出: patch embeddings + [CLS] token
8
    """
9

10
    def __init__(self, model_name="openai/clip-vit-large-patch14"):
11
        self.processor = AutoImageProcessor.from_pretrained(model_name)
12
        self.model     = CLIPVisionModel.from_pretrained(model_name)
13
        # CLIP ViT-L: 1024 维输出, 256 个 patch tokens
14
        self.hidden_size = self.model.config.hidden_size  # 1024
15
        self.num_patches = 256
16

17
    def encode(self, images):
18
        """
19
        参数:
20
            images: PIL Image 或 list[PIL Image] 或 batch tensor
21
        返回:
22
            image_embeds: (B, num_patches+1, hidden_size)
23
                          [0] 是 [CLS] token, [1:] 是 patch tokens
24
        """
25
        if isinstance(images, list):
26
            inputs = self.processor(images, return_tensors="pt")
27
        else:
28
            inputs = self.processor(images, return_tensors="pt")
29

30
        outputs = self.model(**inputs)
31
        # pooled output (CLS) + last hidden state
32
        return outputs.last_hidden_state  # (B, 257, 1024)

1
class MLPProjector(nn.Module):
2
    """
3
    LLaVA 的 MLP 投影器。
4
    vision_dim → intermediate_dim → language_dim
5
    """
6
    def __init__(self, vision_dim, language_dim, intermediate_dim=None):
7
        super().__init__()
8
        if intermediate_dim is None:
9
            intermediate_dim = language_dim * 2
10
        self.layers = nn.Sequential(
11
            nn.Linear(vision_dim, intermediate_dim),
12
            nn.GELU(),
13
            nn.Linear(intermediate_dim, language_dim),
14
        )
15

16
    def forward(self, image_embeds):
17
        return self.layers(image_embeds)

1
class LLaVAConnector(nn.Module):
2
    """
3
    LLaVA-1.5 的模态连接器。
4
    包含:
5
      1. 线性投影 + LayerNorm
6
      2. 2层 MLP + GELU
7
    """
8
    def __init__(self, vision_dim, language_dim):
9
        super().__init__()
10
        self.proj = nn.Sequential(
11
            nn.Linear(vision_dim, language_dim),
12
            nn.GELU(),
13
            nn.Linear(language_dim, language_dim),
14
            nn.LayerNorm(language_dim),
15
        )
16

17
    def forward(self, image_embeds):
18
        # image_embeds: (B, N_v+1, D_v), 去掉 [CLS] token
19
        visual_tokens = image_embeds[:, 1:, :]  # (B, N_v, D_v)
20
        return self.proj(visual_tokens)         # (B, N_v, D_l)

1
class FlamingoGatedCrossAttention(nn.Module):
2
    """
3
    Flamingo 的门控交叉注意力层。
4
    视觉特征作为 K/V，文本特征作为 Q。
5
    """
6
    def __init__(self, lang_dim, vision_dim, num_heads=8):
7
        super().__init__()
8
        self.attn = nn.MultiheadAttention(lang_dim, num_heads, batch_first=True)
9
        self.q_proj  = nn.Linear(lang_dim, lang_dim)
10
        self.kv_proj = nn.Linear(vision_dim, lang_dim * 2)
11
        # 门控参数（初始化为 0，允许渐进式引入视觉信息）
12
        self.gate = nn.Parameter(torch.zeros(1))
13

14
    def forward(self, lang_embeds, vision_embeds):
15
        """
16
        参数:
17
            lang_embeds:  (B, N_l, D_l)  语言 token 序列
18
            vision_embeds: (B, N_v, D_v) 视觉 token 序列
19
        返回:
20
            attended: (B, N_l, D_l) 带视觉信息的语言表示
21
        """
22
        q = self.q_proj(lang_embeds)                    # (B, N_l, D_l)
23
        kv = self.kv_proj(vision_embeds)                # (B, N_v, 2*D_l)
24
        k, v = kv.chunk(2, dim=-1)                     # 各 (B, N_v, D_l)
25

26
        attn_out, _ = self.attn(q, k, v, need_weights=False)  # (B, N_l, D_l)
27
        # 门控: 逐步引入视觉信息（训练初期 gate→0，退化为纯文本）
28
        return lang_embeds + self.gate.tanh() * attn_out

1
class QFormer(nn.Module):
2
    """
3
    BLIP-2 的 Q-Former。
4
    用 12 层 Cross-Attention 从视觉特征中查询出 32 个表示。
5
    """
6
    def __init__(self, vision_dim, lang_dim, num_queries=32, num_layers=12):
7
        super().__init__()
8
        self.num_queries = num_queries
9
        # 可学习的查询向量
10
        self.query_tokens = nn.Parameter(torch.zeros(1, num_queries, lang_dim))
11
        # 12 层 Cross-Attention + Self-Attention
12
        self.layers = nn.ModuleList([
13
            TransformerEncoderLayer(
14
                d_model=lang_dim,
15
                nhead=8,
16
                dim_feedforward=lang_dim * 4,
17
                batch_first=True,
18
            )
19
            for _ in range(num_layers)
20
        ])
21

22
    def forward(self, vision_embeds):
23
        """
24
        vision_embeds: (B, N_v, D_v)  来自视觉编码器
25
        返回:          (B, num_queries, D_l)  32 个查询表示
26
        """
27
        B = vision_embeds.shape[0]
28
        queries = self.query_tokens.expand(B, -1, -1)   # (B, 32, D_l)
29

30
        for layer in self.layers:
31
            # 每层: self-attn → cross-attn(以视觉为 K/V)
32
            queries = layer(queries)
33

34
        return queries  # (B, 32, D_l)  ← 固定长度，兼容 LLM

1
from transformers import AutoModelForCausalLM, AutoTokenizer
2

3

4
class VLLMBackbone:
5
    """VLM 的 LLM 骨干。"""
6

7
    def __init__(self, model_name="Qwen/Qwen2-7B"):
8
        self.tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
9
        self.model     = AutoModelForCausalLM.from_pretrained(
10
            model_name,
11
            trust_remote_code=True,
12
            torch_dtype=torch.float16,
13
            device_map="auto",
14
        )
15
        self.eos_token_id = self.tokenizer.eos_token_id
16

17
    def generate(self, input_ids, image_embeds, max_new_tokens=512):
18
        """给定文本 token 和图像 embedding，生成文本。"""
19
        return self.model.generate(
20
            input_ids=input_ids,
21
            max_new_tokens=max_new_tokens,
22
            do_sample=True,
23
            temperature=0.7,
24
        )

1
┌─────────────────────────────────────────────────────────┐
2
│  阶段 1: 模态预训练 (Projector Pretraining)            │
3
│  目标: 让投影器学会把视觉特征映射到 LLM 空间            │
4
│  数据: 图像-文本对 (CC3M, LAION, 约 600M)             │
5
│  目标: 预测正确文本 (语言建模损失)                     │
6
│  LLM: 冻结 ❄️                                        │
7
│  投影器: 训练 🔥                                     │
8
├─────────────────────────────────────────────────────────┤
9
│  阶段 2: 视觉指令微调 (Vision Instruction Tuning)       │
10
│  目标: 让模型学会根据视觉内容回答问题                   │
11
│  数据: 指令微调数据集 (LLaVA-Instr-80K, 等)           │
12
│  目标: 预测正确回答                                    │
13
│  LLM: 解冻 🔥 (LoRA 或全量)                          │
14
│  投影器: 训练 🔥                                      │
15
├─────────────────────────────────────────────────────────┤
16
│  阶段 3: 对齐微调 (可选, RLHF/DPO)                     │
17
│  目标: 进一步对齐人类偏好                              │
18
│  数据: 人类偏好数据 (LLaVA-RLHF, 等)                  │
19
│  LLM: 解冻 🔥                                        │
20
└─────────────────────────────────────────────────────────┘

1
def pretrain_stage(projector, vision_encoder, llm, dataset):
2
    """
3
    阶段 1: 模态预训练。
4
    冻结 LLM 和视觉编码器，只训练投影器。
5
    """
6
    vision_encoder.requires_grad_(False)
7
    llm.requires_grad_(False)
8
    projector.requires_grad_(True)
9

10
    optimizer = torch.optim.AdamW(projector.parameters(), lr=1e-3, weight_decay=0.05)
11

12
    for batch in DataLoader(dataset, shuffle=True):
13
        images, texts = batch["image"], batch["text"]
14

15
        # 视觉编码
16
        with torch.no_grad():
17
            vision_embeds = vision_encoder(images)           # (B, N_v+1, D_v)
18

19
        # 投影
20
        visual_tokens = projector(vision_embeds)             # (B, N_v, D_l)
21

22
        # 文本 tokenize
23
        input_ids = tokenizer(texts, return_tensors="pt", padding=True, truncation=True)
24
        input_ids = {k: v.to(device) for k, v in input_ids.items()}
25

26
        # 在文本序列中嵌入视觉 token
27
        # 简单实现: 在 [CLS] 位置替换为视觉 token
28
        input_embeds = llm.get_input_embeddings()(input_ids["input_ids"])
29
        input_embeds[:, 0:1, :] = visual_tokens[:, 0:1, :]  # 替换第一个位置
30

31
        # 前向传播
32
        outputs = llm(inputs_embeds=input_embeds,
33
                       attention_mask=input_ids["attention_mask"],
34
                       labels=input_ids["input_ids"])
35
        loss = outputs.loss
36

37
        loss.backward()
38
        optimizer.step()
39
        optimizer.zero_grad()

1
def instruction_tune_stage(projector, vision_encoder, llm, dataset):
2
    """
3
    阶段 2: 视觉指令微调。
4
    解冻 LLM + 投影器，用指令数据训练。
5
    """
6
    # LoRA 配置（节省显存）
7
    from peft import LoraConfig, get_peft_model
8
    lora_config = LoraConfig(
9
        r=64,
10
        lora_alpha=16,
11
        target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
12
        lora_dropout=0.05,
13
        bias="none",
14
        task_type="CAUSAL_LM",
15
    )
16
    llm = get_peft_model(llm, lora_config)
17

18
    projector.requires_grad_(True)
19
    vision_encoder.requires_grad_(False)  # 保持冻结
20

21
    optimizer = torch.optim.AdamW(
22
        list(projector.parameters()) + list(llm.parameters()),
23
        lr=2e-5, weight_decay=0.0,
24
    )
25

26
    for batch in DataLoader(dataset):
27
        images, instructions, responses = batch["image"], batch["instruction"], batch["response"]
28

29
        # 构建多模态输入
30
        # 格式: [SYSTEM] + [IMG] + [USER 问题] + [ASSISTANT 回答]
31
        prompts = [
32
            f"[ SYSTEM ] 你是一个视觉助手。[ IMG ] [ / IMG ] [ USER ] {inst} [ ASSISTANT ]"
33
            for inst in instructions
34
        ]
35

36
        input_ids = tokenizer(prompts, return_tensors="pt", padding=True).to(device)
37
        labels    = tokenizer(responses, return_tensors="pt", padding=True,
38
                               truncation=True, max_length=512).to(device)
39

40
        # 视觉编码 + 投影
41
        vision_embeds = vision_encoder(images)
42
        visual_tokens = projector(vision_embeds)
43

44
        # 获取文本 embedding 并嵌入视觉 token
45
        input_embeds = llm.get_input_embeddings()(input_ids["input_ids"])
46

47
        # 在 [IMG] token 位置插入视觉 token
48
        for b in range(input_embeds.shape[0]):
49
            img_positions = (input_ids["input_ids"][b] == img_start_id).nonzero(as_tuple=True)[0]
50
            if len(img_positions) > 0:
51
                img_pos = img_positions[0].item()
52
                end_pos = (input_ids["input_ids"][b] == img_end_id).nonzero(as_tuple=True)[0][0].item()
53
                num_v_tokens = end_pos - img_pos
54
                input_embeds[b, img_pos:img_pos + num_v_tokens, :] = visual_tokens[b, :num_v_tokens, :]
55

56
        outputs = llm(inputs_embeds=input_embeds,
57
                       attention_mask=input_ids["attention_mask"],
58
                       labels=labels["input_ids"])
59
        loss = outputs.loss
60
        loss.backward()
61
        optimizer.step()
62
        optimizer.zero_grad()

1
def get_training_data():
2
    """
3
    LLaVA-1.5 的训练数据混合。
4
    """
5
    data_mixture = [
6
        # 纯语言指令数据（来自 Vicuna/Llama 训练集）
7
        ("llava-instruct-150k",     3_000_000,  "语言指令微调"),
8
        ("sharegpt",                900_000,    "对话数据"),
9

10
        # 视觉-语言数据
11
        ("llava-lcs-558k",         558_000,    "图像描述 (预训练)"),
12
        ("llava-instruct-665k",    665_000,    "图像指令 (微调)"),
13
        ("laion-cc-sbu-558k",      558_000,    "图文对 (预训练)"),
14

15
        # 特定能力数据
16
        ("ocr",                     200_000,    "文档/OCR 理解"),
17
        ("chart",                   100_000,    "图表理解"),
18
        ("docvqa",                  50_000,     "文档问答"),
19
        ("gqa",                     80_000,     "视觉推理问答"),
20
    ]
21
    return data_mixture

1
方法 1: 直接放大 (LLaVA-1.5)
2
  - 输入分辨率: 336×336
3
  - 优点: 简单
4
  - 缺点: 丢失细节，计算量随分辨率平方增长
5

6
方法 2: 分块编码 (Qwen-VL2)
7
  - 原始图像: 1440×960 → 切分成 9 个 480×480 子图
8
  - 每个子图独立编码 → 9x256=2304 个 tokens
9
  - 优点: 保留高分辨率细节
10
  - 缺点: token 数量爆炸
11

12
方法 3: 注意力池化 (InternVL)
13
  - 大视觉编码器 (ViT-L → ViT-G)
14
  - 全局 + 局部特征融合
15
  - 自适应 token 数量

1
def split_image_for_high_res(image, patch_size=480, overlap=32):
2
    """
3
    图像分块（Qwen-VL2 风格）。
4
    把高分辨率图像切分成重叠的子图。
5
    """
6
    W, H = image.size
7
    patches = []
8
    coords   = []
9

10
    stride = patch_size - overlap
11
    for y in range(0, H, stride):
12
        for x in range(0, W, stride):
13
            # 裁剪子图
14
            patch = image.crop((x, y, x + patch_size, y + patch_size))
15
            patches.append(patch)
16
            coords.append((x, y))
17

18
    return patches, coords
19

20

21
def dynamic_res_encode(images, vision_encoder, projector, max_tokens=1024):
22
    """
23
    动态分辨率编码。
24
    自动选择最佳切分策略。
25
    """
26
    patches, coords = split_image_for_high_res(images[0])
27

28
    # 批量编码所有 patch
29
    all_embeds = []
30
    for patch in patches:
31
        embed = vision_encoder(patch)          # (1, 257, D_v)
32
        proj  = projector(embed)                # (1, 256, D_l)
33
        all_embeds.append(proj[:, 1:, :])      # 去掉 [CLS]
34

35
    # 拼接所有 patch tokens
36
    visual_tokens = torch.cat(all_embeds, dim=1)   # (1, N_patches*256, D_l)
37

38
    # 如果 token 过多，用 attention 池化
39
    if visual_tokens.shape[1] > max_tokens:
40
        # 全局 token + 局部 token 混合
41
        global_token = visual_tokens[:, :256, :].mean(dim=1, keepdim=True)
42
        local_tokens = visual_tokens[:, :max_tokens-1, :]
43
        visual_tokens = torch.cat([global_token, local_tokens], dim=1)
44

45
    return visual_tokens

1
class MoEVLM(nn.Module):
2
    """
3
    基于 MoE 的 VLM。
4
    视觉和文本 token 共享 MoE LLM 骨干。
5
    """
6
    def __init__(self, vision_dim, num_experts=8, top_k=2):
7
        super().__init__()
8
        self.projector = MLPProjector(vision_dim, lang_dim)
9
        self.llm = MoELanguageModel(
10
            num_experts=num_experts,
11
            top_k=top_k,
12
        )
13

14
    def forward(self, image_embeds, text_ids):
15
        visual_tokens = self.projector(image_embeds)    # (B, N_v, D_l)
16
        text_embeds   = self.llm.get_input_embeddings()(text_ids)
17
        # 拼接视觉和文本 token
18
        multimodal_embeds = torch.cat([visual_tokens, text_embeds], dim=1)
19
        return self.llm(inputs_embeds=multimodal_embeds)

1
def benchmark_comparison():
2
    """
3
    各 VLM 在主要基准上的表现。
4
    数据来源: 2024-2025 公开评测。
5
    """
6
    results = {
7
        # (模型, MMMU, VQAv2, GQA, TextVQA, POPE)
8
        "LLaVA-1.5-7B":    (36.7, 83.1, 63.3, 61.3, 85.9),
9
        "LLaVA-1.5-13B":   (40.1, 84.3, 65.1, 62.9, 87.2),
10
        "Qwen-VL2-7B":     (38.5, 84.1, 64.8, 63.1, 86.5),
11
        "Qwen2-VL-72B":    (54.8, 88.9, 70.2, 68.9, 91.3),
12
        "InternVL2-8B":   (42.5, 85.2, 66.1, 64.8, 88.1),
13
        "InternVL2-26B":   (49.2, 87.1, 68.9, 67.2, 90.4),
14
        "CogVLM-17B":      (43.8, 84.6, 65.8, 64.1, 87.8),
15
        "GPT-4V(2023)":    (56.8, 86.4, 67.1, 70.2, 88.9),
16
        "GPT-4o":          (69.1, 91.8, 74.3, 78.1, 93.2),
17
        "Gemini-1.5-Pro":  (62.4, 89.2, 72.8, 74.2, 92.1),
18
    }
19
    return results
20

21

22
def benchmark_descriptions():
23
    """
24
    各基准测试的含义。
25
    """
26
    benchmarks = {
27
        "MMMU": "大规模多学科多模态理解（大学水平）",
28
        "VQAv2": "通用视觉问答（MSCOCO 图像）",
29
        "GQA": "视觉推理问答（语义图）",
30
        "TextVQA": "文本视觉问答（需要 OCR）",
31
        "POPE": "物体存在性幻觉评估",
32
    }
33
    return benchmarks

1
def model_selection_guide():
2
    """
3
    不同场景下的模型选择建议。
4
    """
5
    scenarios = {
6
        "端侧部署 (手机)": {
7
            "推荐": "LLaVA-1.5-7B (INT4 量化)",
8
            "备选": "MiniGPT-v2, Phi-3-Vision",
9
            "参数": "~4GB 显存",
10
        },
11
        "服务器单卡": {
12
            "推荐": "Qwen2-VL-7B, InternVL2-8B",
13
            "备选": "LLaVA-1.5-13B",
14
            "参数": "~16GB 显存",
15
        },
16
        "高精度场景": {
17
            "推荐": "Qwen2-VL-72B, InternVL2-26B",
18
            "备选": "GPT-4o API, Gemini-1.5-Pro API",
19
            "参数": "多卡 A100/H100",
20
        },
21
        "OCR/文档理解": {
22
            "推荐": "LLaVA-1.5 + OCR 数据微调",
23
            "备选": "Qwen-VL2 (动态分辨率)",
24
            "关键": "高分辨率 + 大量文档数据",
25
        },
26
        "视频理解": {
27
            "推荐": "VideoLLaVA, LLaMA-VID",
28
            "备选": "Qwen2-VL (视频支持)",
29
            "关键": "时序建模 + 帧采样",
30
        },
31
    }
32
    return scenarios

1
def reduce_hallucination_methods():
2
    """
3
    幻觉缓解方法对比。
4
    """
5
    methods = {
6
        "RLHF/DPO": {
7
            "方法": "用人类偏好数据训练，让模型学会说"我不知道"",
8
            "效果": "中等",
9
            "代价": "需要大量标注",
10
        },
11
        "Token-Level Loss": {
12
            "方法": "在视觉 token 上加辅助损失，鼓励关注图像",
13
            "效果": "良好",
14
            "代价": "额外训练目标",
15
        },
16
        "ODISE 定位": {
17
            "方法": "先用检测器定位物体，再描述",
18
            "效果": "显著改善",
19
            "代价": "需要额外的检测模型",
20
        },
21
        "BA-CC 约束": {
22
            "方法": "在注意力层加入图像条件约束",
23
            "效果": "良好",
24
            "代价": "架构修改",
25
        },
26
        "LLAVA-RLHF": {
27
            "方法": "用 RLHF 专门对齐视觉和语言",
28
            "效果": "最佳",
29
            "代价": "复杂训练流程",
30
        },
31
    }
32
    return methods