LLaVA 深度剖析：从视觉指令微调到开源多模态助手的完整技术栈

1
┌─────────────────────────────────────────────────────────────┐
2
│                                                             │
3
│   [图像] → CLIP ViT-L/14 → [IMG patch tokens]              │
4
│            (冻结 ❄️)        ↓                               │
5
│                         MLP 投影器                           │
6
│                       (训练 🔥)                              │
7
│                            ↓                                 │
8
│   [文本] → Vicuna-7B LLM → [文本 tokens]                    │
9
│            (训练 🔥)        ↓                               │
10
│                     自回归生成                               │
11
│                            ↓                                 │
12
│                      [回答文本]                              │
13
│                                                             │
14
└─────────────────────────────────────────────────────────────┘
15

16
LLaVA 架构的核心简洁性:
17
  视觉编码器: CLIP ViT-L/14（冻结，用预训练权重）
18
  模态对齐:   线性投影 → MLP（两层，带 GELU）
19
  LLM 骨干:   Vicuna-7B（指令微调后的 Llama-2）

1
class LLaVATokenizer:
2
    """
3
    LLaVA 的 tokenizer 配置。
4
    """
5
    def __init__(self, base_tokenizer="lmsys/vicuna-7b-v1.5"):
6
        from transformers import AutoTokenizer
7
        self.tokenizer = AutoTokenizer.from_pretrained(base_tokenizer)
8

9
        # 添加图像标记 token
10
        special_tokens = ["[ IMG ]", "[ / IMG ]"]
11
        num_new = self.tokenizer.add_tokens(special_tokens, special_tokens=True)
12
        self.img_start_id = self.tokenizer("[ IMG ]", add_special_tokens=False).input_ids[0]
13
        self.img_end_id   = self.tokenizer("[ / IMG ]", add_special_tokens=False).input_ids[0]
14

15
        # Vicuna 的系统提示
16
        self.system_prompt = (
17
            "A chat between a curious human and an artificial intelligence assistant. "
18
            "The assistant gives helpful, detailed, and polite answers to the user's questions."
19
        )
20

21
    def build_input(self, instruction, image_count=1):
22
        """构建多模态输入。"""
23
        img_tokens = " [ IMG ] " + " [ IMG ] " * (image_count - 1) + " [ / IMG ] "
24
        text = f"{self.system_prompt} [ USER ] {img_tokens} {instruction} [ ASSISTANT ]"
25
        return text

1
┌─────────────────────────────────────────────────────────────┐
2
│  Stage 1: 图像描述 (Image Captioning)                      │
3
│  输入: 图像                                                │
4
│  方法: BLIP-2 生成初始描述 + GPT-4 改进                    │
5
│  输出: 详细、准确的图像描述                                 │
6
├─────────────────────────────────────────────────────────────┤
7
│  Stage 2: 指令问题生成 (Instruction Generation)            │
8
│  输入: 图像描述                                            │
9
│  方法: GPT-4 根据描述生成多样化的指令问题                  │
10
│  输出: 各种类型的问题（描述/推理/计算/复杂）             │
11
├─────────────────────────────────────────────────────────────┤
12
│  Stage 3: 回答生成 (Response Generation)                  │
13
│  输入: 图像描述 + 指令问题                                  │
14
│  方法: GPT-4 根据描述和问题的组合生成回答                  │
15
│  输出: 对应每个问题的详细回答                              │
16
└─────────────────────────────────────────────────────────────┘

1
def generate_image_caption(image, blip_model, gpt4_api):
2
    """
3
    Stage 1: 生成详细的图像描述。
4

5
    步骤:
6
      1. 用 BLIP-2 生成初始 caption
7
      2. 用 GPT-4 改进 caption
8
    """
9
    # 1) BLIP-2 生成初始描述
10
    caption_raw = blip_model.generate_caption(image)
11

12
    # 2) GPT-4 改进描述
13
    prompt = f"""Based on the following image description, generate a more detailed and accurate description:
14

15
Raw caption: {caption_raw}
16

17
Please provide a more detailed description that includes:
18
- Main objects and their locations
19
- Actions and interactions
20
- Background context
21
- Style and mood (if applicable)
22
- Any text or labels visible in the image
23

24
Output only the improved description:"""
25

26
    improved_caption = gpt4_api.complete(prompt)
27
    return improved_caption
28

29

30
def caption_quality_filter(captions, min_length=50, max_repeat=0.3):
31
    """
32
    过滤低质量描述。
33
    """
34
    filtered = []
35
    for cap in captions:
36
        # 长度检查
37
        if len(cap.split()) < min_length:
38
            continue
39

40
        # 重复检查（避免 GPT-4 的循环输出）
41
        words = cap.lower().split()
42
        if len(words) > 0:
43
            unique_ratio = len(set(words)) / len(words)
44
            if unique_ratio < (1 - max_repeat):
45
                continue
46

47
        filtered.append(cap)
48

49
    return filtered

1
def generate_instructions(caption, gpt4_api):
2
    """
3
    Stage 2: 根据描述生成多样化的指令问题。
4
    GPT-4 根据描述，生成四种不同类型的问题。
5
    """
6
    prompt = f"""You are an AI assistant. Generate diverse question-answer pairs based on the following image description.
7

8
Image description: {caption}
9

10
Generate questions from FOUR different categories:
11

12
1. CONVERSATIONAL (简单对话型):
13
   - 自然、口语化的问题
14
   - 例: "这张图片里有什么？" "这是什么地方？"
15

16
2. DETAILED DESCRIPTION (详细描述型):
17
   - 需要详细描述的问题
18
   - 例: "请详细描述图中的人物穿着" "描述这个场景的氛围"
19

20
3. COMPLEX REASONING (复杂推理型):
21
   - 需要多步推理的问题
22
   - 例: "图中这个人在做什么，可能会发生什么？"
23

24
4. SPATIAL RELATIONSHIPS (空间关系型):
25
   - 关于物体位置和关系的问题
26
   - 例: "红球和蓝球的位置关系是什么？"
27

28
For EACH category, generate 1-2 questions.
29

30
Output format:
31
CONVERSATIONAL:
32
Q: ...
33
DETAIL:
34
Q: ...
35
REASONING:
36
Q: ...
37
SPATIAL:
38
Q: ..."""
39

40
    response = gpt4_api.complete(prompt)
41
    questions = parse_questions(response)
42
    return questions
43

44

45
def parse_questions(gpt4_output):
46
    """
47
    解析 GPT-4 的输出，提取问题列表。
48
    """
49
    questions = []
50
    current_category = None
51

52
    for line in gpt4_output.split("\n"):
53
        line = line.strip()
54
        if not line:
55
            continue
56

57
        if line.startswith("CONVERSATIONAL"):
58
            current_category = "conversational"
59
        elif line.startswith("DETAIL"):
60
            current_category = "detail"
61
        elif line.startswith("REASONING"):
62
            current_category = "reasoning"
63
        elif line.startswith("SPATIAL"):
64
            current_category = "spatial"
65
        elif line.startswith("Q:"):
66
            question = line[2:].strip()
67
            if current_category:
68
                questions.append({"type": current_category, "question": question})
69

70
    return questions

1
def generate_response(caption, question, gpt4_api):
2
    """
3
    Stage 3: 根据描述和问题，生成详细回答。
4
    """
5
    prompt = f"""You are a helpful AI assistant. Answer the following question based on the image description.
6

7
Image description: {caption}
8

9
Question: {question}
10

11
Please provide a detailed and accurate answer based on the description above.
12
If the description doesn't contain enough information to answer, say so honestly.
13
Be specific and informative."""
14

15
    response = gpt4_api.complete(prompt)
16
    return response
17

18

19
def build_instruction_dataset(images, blip_model, gpt4_api):
20
    """
21
    完整的数据集构建流程。
22
    """
23
    dataset = []
24

25
    for image in tqdm(images):
26
        # Stage 1: 图像描述
27
        caption = generate_image_caption(image, blip_model, gpt4_api)
28
        if not caption:
29
            continue
30

31
        # Stage 2: 生成问题
32
        questions = generate_instructions(caption, gpt4_api)
33

34
        # Stage 3: 生成回答
35
        for q_data in questions:
36
            question = q_data["question"]
37
            answer = generate_response(caption, question, gpt4_api)
38

39
            dataset.append({
40
                "image": image,
41
                "caption": caption,
42
                "instruction": question,
43
                "response": answer,
44
                "type": q_data["type"],
45
            })
46

47
    return dataset

1
def dataset_statistics():
2
    """
3
    LLaVA-Instruct-150K 数据集统计。
4
    """
5
    stats = {
6
        "conversational": {
7
            "count": 30_000,
8
            "examples": "简单问答，如'图里有什么'",
9
            "来源": "GPT-4 自动生成",
10
        },
11
        "detailed_description": {
12
            "count": 30_000,
13
            "examples": "详细描述，如'请描述图中的人物'",
14
            "来源": "GPT-4 自动生成",
15
        },
16
        "complex_reasoning": {
17
            "count": 30_000,
18
            "examples": "推理问题，如'图中的因果关系'",
19
            "来源": "GPT-4 自动生成",
20
        },
21
        "spatial_relationships": {
22
            "count": 30_000,
23
            "examples": "空间问题，如'物体相对位置'",
24
            "来源": "GPT-4 自动生成",
25
        },
26
        "llava_lcs_558k": {
27
            "count": 558_000,
28
            "examples": "图像描述对（CC3M 筛选）",
29
            "来源": "BLIP-2 caption + GPT-4 改进",
30
        },
31
    }
32
    return stats

1
def quality_control(dataset):
2
    """
3
    LLaVA 的数据质量控制策略。
4
    """
5
    strategies = {
6
        "长度过滤": {
7
            "caption_min_len": 10,     # 描述至少 10 词
8
            "response_min_len": 10,    # 回答至少 10 词
9
            "instruction_max_len": 512, # 指令最多 512 词
10
        },
11
        "重复检测": {
12
            "ngram_repeat_threshold": 0.3,  # 唯一词比例 > 70%
13
            "copy_from_caption_ratio": 0.8, # 回答不能 80% 直接复制 caption
14
        },
15
        "一致性验证": {
16
            "use_gpt4_validator": True,     # 用 GPT-4 检查一致性
17
            "consistency_threshold": 0.7,   # 一致性得分 > 0.7
18
        },
19
        "GPT-4 改进": {
20
            "improve_captions": True,        # 改进 BLIP-2 的 caption
21
            "gpt4_temperature": 0.0,         # 生成用 temperature=0
22
            "gpt4_top_p": 1.0,
23
        },
24
    }
25
    return strategies

1
┌──────────────────────────────────────────────────────────────┐
2
│  阶段 1: 模态预训练 (Modality Alignment)                    │
3
│                                                              │
4
│  数据: LLaVA-LCS-558K (558K 图像-描述对)                    │
5
│  目标: 让 MLP 学会把 CLIP 视觉特征映射到 LLM 空间           │
6
│  方法: 语言建模损失（给定图像，预测描述）                    │
7
│                                                              │
8
│  视觉编码器: 冻结 ❄️                                        │
9
│  LLM:        冻结 ❄️                                        │
10
│  MLP:        训练 🔥 ← 唯一要训练的部分！                   │
11
│                                                              │
12
│  训练: ~1 epoch, batch_size=128, lr=1e-3                   │
13
├──────────────────────────────────────────────────────────────┤
14
│  阶段 2: 视觉指令微调 (Visual Instruction Tuning)          │
15
│                                                              │
16
│  数据: LLaVA-Instruct-150K (150K 指令问答对)               │
17
│  目标: 让模型学会根据图像内容回答各种问题                    │
18
│  方法: 语言建模损失（给定图像+问题，预测回答）               │
19
│                                                              │
20
│  视觉编码器: 冻结 ❄️                                        │
21
│  LLM:        解冻 🔥 (Vicuna-7B 全量或 LoRA)               │
22
│  MLP:        训练 🔥                                        │
23
│                                                              │
24
│  训练: ~3 epochs, batch_size=32, lr=2e-5                  │
25
└──────────────────────────────────────────────────────────────┘

1
def pretrain_stage1(projector, vision_encoder, llm, dataset):
2
    """
3
    阶段 1: 模态预训练。
4

5
    目标: 训练投影器，让视觉特征和文本特征对齐。
6
    数据: LLaVA-LCS-558K (CC3M 筛选后的图文对)
7
    """
8
    # 冻结 LLM 和视觉编码器
9
    vision_encoder.requires_grad_(False)
10
    for param in llm.parameters():
11
        param.requires_grad = False
12

13
    # 只训练投影器
14
    optimizer = torch.optim.AdamW(projector.parameters(), lr=1e-3, weight_decay=0.05)
15

16
    dataloader = DataLoader(dataset, batch_size=128, shuffle=True)
17

18
    for epoch in range(1):
19
        for batch in tqdm(dataloader):
20
            images, captions = batch["image"], batch["caption"]
21

22
            # 1) 视觉编码 (冻结)
23
            with torch.no_grad():
24
                vision_output = vision_encoder(images)
25
                vision_embeds = vision_output.last_hidden_state[:, 1:, :]  # 去掉 [CLS]
26

27
            # 2) 投影
28
            visual_tokens = projector(vision_embeds)  # (B, N_v, D_l)
29

30
            # 3) 构建输入
31
            input_texts = [f"[ IMG ] [ / IMG ] {cap}" for cap in captions]
32
            input_ids = tokenizer(input_texts, return_tensors="pt", padding=True)
33
            input_ids = {k: v.to(device) for k, v in input_ids.items()}
34

35
            # 4) 在 [IMG] 位置插入视觉 token
36
            inputs_embeds = llm.get_input_embeddings()(input_ids["input_ids"])
37

38
            for b in range(inputs_embeds.shape[0]):
39
                img_pos = (input_ids["input_ids"][b] == img_start_id).nonzero(as_tuple=True)[0]
40
                end_pos = (input_ids["input_ids"][b] == img_end_id).nonzero(as_tuple=True)[0]
41
                if len(img_pos) == 0:
42
                    continue
43

44
                sp = img_pos[0].item()
45
                ep = end_pos[0].item()
46
                num_v = ep - sp - 1
47

48
                before = inputs_embeds[b, :sp, :]
49
                after  = inputs_embeds[b, ep + 1:, :]
50
                v_tok  = visual_tokens[b, :num_v, :]
51

52
                inputs_embeds[b] = torch.cat([before, v_tok, after], dim=0)
53

54
            # 5) LLM 前向
55
            outputs = llm(inputs_embeds=inputs_embeds,
56
                           attention_mask=input_ids["attention_mask"],
57
                           labels=input_ids["input_ids"])
58
            loss = outputs.loss
59

60
            # 6) 反向传播
61
            optimizer.zero_grad()
62
            loss.backward()
63
            optimizer.step()
64

65
    return projector

1
def finetune_stage2(projector, vision_encoder, llm, dataset):
2
    """
3
    阶段 2: 视觉指令微调。
4

5
    目标: 微调 LLM + 投影器，让模型学会回答视觉问题。
6
    数据: LLaVA-Instruct-150K (150K 指令问答对)
7
    方法: 全量微调 Vicuna-7B 或 LoRA 微调
8
    """
9
    # 解冻 LLM（使用 LoRA 节省显存）
10
    from peft import LoraConfig, get_peft_model
11

12
    lora_config = LoraConfig(
13
        r=64,
14
        lora_alpha=16,
15
        target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
16
        lora_dropout=0.05,
17
        bias="none",
18
        task_type="CAUSAL_LM",
19
    )
20
    llm = get_peft_model(llm, lora_config)
21

22
    # 视觉编码器仍然冻结
23
    vision_encoder.requires_grad_(False)
24

25
    optimizer = torch.optim.AdamW(
26
        list(projector.parameters()) + list(llm.parameters()),
27
        lr=2e-5,
28
        weight_decay=0.0,
29
    )
30

31
    dataloader = DataLoader(dataset, batch_size=32, shuffle=True)
32

33
    for epoch in range(3):
34
        for batch in tqdm(dataloader):
35
            images, instructions, responses = (
36
                batch["image"], batch["instruction"], batch["response"]
37
            )
38

39
            # 构建对话格式
40
            # [SYSTEM] ... [USER] [IMG] ... [IMG] {instruction} [ASSISTANT] {response}
41
            prompts = [
42
                f"{SYSTEM_PROMPT} [ USER ] [ IMG ] [ / IMG ] {inst} [ ASSISTANT ]"
43
                for inst in instructions
44
            ]
45

46
            # Tokenize
47
            input_enc = tokenizer(prompts, return_tensors="pt", padding=True)
48
            label_enc = tokenizer(responses, return_tensors="pt", padding=True,
49
                                   truncation=True, max_length=512)
50

51
            # 视觉编码 + 投影
52
            vision_output = vision_encoder(images)
53
            vision_embeds = vision_output.last_hidden_state[:, 1:, :]
54
            visual_tokens = projector(vision_embeds)
55

56
            # 嵌入
57
            inputs_embeds = llm.get_input_embeddings()(input_enc["input_ids"])
58

59
            # 插入视觉 token
60
            for b in range(inputs_embeds.shape[0]):
61
                sp_pos = (input_enc["input_ids"][b] == img_start_id).nonzero(as_tuple=True)[0]
62
                ep_pos = (input_enc["input_ids"][b] == img_end_id).nonzero(as_tuple=True)[0]
63

64
                if len(sp_pos) == 0:
65
                    continue
66

67
                sp = sp_pos[0].item()
68
                ep = ep_pos[0].item()
69
                nv = ep - sp - 1
70

71
                before = inputs_embeds[b, :sp, :]
72
                after  = inputs_embeds[b, ep + 1:, :]
73
                v_tok  = visual_tokens[b, :nv, :]
74

75
                inputs_embeds[b] = torch.cat([before, v_tok, after], dim=0)
76

77
            # LLM 前向
78
            outputs = llm(
79
                inputs_embeds=inputs_embeds,
80
                attention_mask=input_enc["attention_mask"],
81
                labels=label_enc["input_ids"],
82
            )
83
            loss = outputs.loss
84

85
            optimizer.zero_grad()
86
            loss.backward()
87
            torch.nn.utils.clip_grad_norm_(llm.parameters(), max_norm=1.0)
88
            optimizer.step()
89

90
    return projector, llm

1
def training_hyperparams():
2
    """
3
    LLaVA 两个训练阶段的超参数对比。
4
    """
5
    return {
6
        "Stage 1 - 模态预训练": {
7
            "batch_size": 128,
8
            "learning_rate": 1e-3,
9
            "weight_decay": 0.05,
10
            "epochs": 1,
11
            "LR_schedule": "constant",
12
            "视觉编码器": "冻结",
13
            "LLM": "冻结",
14
            "投影器": "训练",
15
            "数据量": "558K (LLaVA-LCS-558K)",
16
        },
17
        "Stage 2 - 指令微调": {
18
            "batch_size": 32,
19
            "learning_rate": 2e-5,
20
            "weight_decay": 0.0,
21
            "epochs": 3,
22
            "LR_schedule": "cosine",
23
            "视觉编码器": "冻结",
24
            "LLM": "解冻 (LoRA r=64)",
25
            "投影器": "训练",
26
            "数据量": "150K (LLaVA-Instruct-150K)",
27
        },
28
    }

1
def llava15_data_mixture():
2
    """
3
    LLaVA-1.5 的训练数据混合。
4
    总计约 6M 样本。
5
    """
6
    mixture = {
7
        "视觉语言数据 (总计 ~1.3M)": {
8
            "LLaVA-LCS-558K": {
9
                "数量": 558_000,
10
                "类型": "图像描述对 (预训练)",
11
                "来源": "CC3M 筛选 + GPT-4 改进",
12
            },
13
            "LLaVA-Instruct-665K": {
14
                "数量": 665_000,
15
                "类型": "视觉指令问答 (微调)",
16
                "来源": "GPT-4 生成",
17
            },
18
        },
19
        "纯语言指令数据 (总计 ~4.6M)": {
20
            "LLaVA-Instruct-150K": {
21
                "数量": 150_000,
22
                "类型": "GPT-4 生成的视觉问答",
23
            },
24
            "ShareGPT": {
25
                "数量": 900_000,
26
                "类型": "人类对话数据 (Vicuna 来源)",
27
            },
28
            "Alpaca": {
29
                "数量": 3_000_000,
30
                "类型": "语言指令数据 (GPT-4 生成)",
31
            },
32
        },
33
        "特定能力数据 (总计 ~330K)": {
34
            "OCR/文档": {"数量": 200_000, "来源": "OCR 数据集"},
35
            "图表": {"数量": 100_000, "来源": "ChartQA, DVQA"},
36
            "GQA": {"数量": 80_000, "来源": "VQA 推理"},
37
            "DocVQA": {"数量": 50_000, "来源": "文档问答"},
38
        },
39
    }
40
    return mixture

1
传统方法 (直接放大):
2
  224×224 → 448×448 (4倍像素)
3
  问题: 视觉 token 数量爆炸 (196 → 784)
4

5
AnyRes 策略:
6
  原始图像: 任意分辨率
7
  下采样到低分辨率: (H', W') → 编码得到全局特征
8
  切分成子图: (h, w) → 分别编码得到局部特征
9
  全局 + 局部特征拼接 → 丰富的高分辨率表示
10

11
示例 (672px, 4×4 grid):
12
  原始: 672×672
13
  下采样到: 336×336 → 全局特征 (576 tokens)
14
  切分成 4×4 = 16 个子图 → 每个 168×168 → 各 144 tokens
15
  总 tokens: 576 + 16×144 = 2880 (可接受)

1
class AnyResStrategy:
2
    """
3
    AnyRes 高分辨率策略。
4
    """
5
    def __init__(self, base_resolution=336, grid_size=2):
6
        self.base_resolution = base_resolution
7
        self.grid_size = grid_size
8

9
    def split_image(self, image):
10
        """
11
        把高分辨率图像切分成子图。
12
        """
13
        W, H = image.size
14
        patch_size = self.base_resolution // self.grid_size  # 168
15

16
        patches = []
17
        for y in range(0, H, patch_size):
18
            for x in range(0, W, patch_size):
19
                patch = image.crop((x, y, x + patch_size, y + patch_size))
20
                patches.append(patch)
21

22
        # 全局缩略图
23
        global_img = image.resize((self.base_resolution, self.base_resolution))
24

25
        return global_img, patches
26

27
    def encode_with_anyres(self, image, vision_encoder, projector):
28
        """
29
        AnyRes 编码。
30
        """
31
        global_img, patches = self.split_image(image)
32

33
        # 编码全局
34
        global_feat = vision_encoder(global_img)  # (1, N+1, D)
35
        global_feat = projector(global_feat[:, 1:, :])  # (1, N, D_l)
36

37
        # 编码每个 patch
38
        patch_feats = []
39
        for patch in patches:
40
            feat = vision_encoder(patch)
41
            feat = projector(feat[:, 1:, :])
42
            patch_feats.append(feat)
43

44
        # 拼接全局 + 局部
45
        all_feats = torch.cat([global_feat] + patch_feats, dim=1)  # (1, N*(grid+1), D_l)
46
        return all_feats

1
def llava_next_features():
2
    """
3
    LLaVA-NeXT 的关键特性。
4
    """
5
    features = {
6
        "视觉编码器升级": "SIGLIP-So400m (比 CLIP 更强)",
7
        "LLM 升级": "Llama-3 8B (比 Vicuna 更强)",
8
        "分辨率": "动态分辨率，支持任意宽高比",
9
        "训练数据": "~2M 高质量样本",
10
        "关键创新": "Mistral-7B 对比、动态数据过滤",
11
        "性能提升": {
12
            "MMMU": "LLaVA-1.5 7B: 36.7% → LLaVA-NeXT: 42.1%",
13
            "VQAv2": "LLaVA-1.5 7B: 83.1% → LLaVA-NeXT: 85.4%",
14
        },
15
    }
16
    return features

1
def gpt4v_comparison():
2
    """
3
    LLaVA-1.5 vs GPT-4V(2023) 能力对比。
4
    数据来源: 2023-2024 公开评测。
5
    """
6
    comparison = {
7
        "通用视觉问答": {
8
            "GPT-4V": "★★★★★ (接近人类水平)",
9
            "LLaVA-1.5": "★★★★ (较好，但有差距)",
10
            "差距原因": "GPT-4V 有更大规模的预训练",
11
        },
12
        "文档/OCR 理解": {
13
            "GPT-4V": "★★★★★ (极强)",
14
            "LLaVA-1.5": "★★★ (需额外数据)",
15
            "差距原因": "LLaVA-1.5 加入 OCR 数据后缩小差距",
16
        },
17
        "图表分析": {
18
            "GPT-4V": "★★★★★ (多步推理强)",
19
            "LLaVA-1.5": "★★★ (基础图表可以)",
20
            "差距原因": "复杂推理能力差距",
21
        },
22
        "空间推理": {
23
            "GPT-4V": "★★★ (一般)",
24
            "LLaVA-1.5": "★★ (较弱)",
25
            "差距原因": "两者在空间关系上都有局限",
26
        },
27
        "开放世界泛化": {
28
            "GPT-4V": "★★★★★ (极强)",
29
            "LLaVA-1.5": "★★★★ (较好)",
30
            "差距原因": "GPT-4V 数据规模和多样性更大",
31
        },
32
        "代码生成": {
33
            "GPT-4V": "★★★★★ (能生成 matplotlib 等)",
34
            "LLaVA-1.5": "★★ (几乎没有)",
35
            "差距原因": "LLaVA-1.5 没有相关训练数据",
36
        },
37
    }
38
    return comparison

1
def gap_analysis():
2
    """
3
    开源 VLM 与 GPT-4V 差距的分析。
4
    """
5
    gaps = {
6
        "预训练数据": {
7
            "GPT-4V": "数万亿图文对 + 内部数据",
8
            "LLaVA-1.5": "CC3M/LAION ~600K 对外公开",
9
            "影响": "数据量差 100-1000 倍",
10
        },
11
        "模型规模": {
12
            "GPT-4V": "GPT-4 (估计 1.8T 参数)",
13
            "LLaVA-1.5": "Vicuna-7B + CLIP ViT-L = ~8B",
14
            "影响": "模型规模差 200 倍",
15
        },
16
        "训练计算": {
17
            "GPT-4V": "数百万 GPU 小时",
18
            "LLaVA-1.5": "数十 GPU 小时 (开源可复现)",
19
            "影响": "训练成本不可比",
20
        },
21
        "对齐数据": {
22
            "GPT-4V": "大量人类标注的偏好数据",
23
            "LLaVA-1.5": "GPT-4 生成数据",
24
            "影响": "GPT-4V 的回答质量更高",
25
        },
26
    }
27
    return gaps