多模态 on 酒中仙

多模态——从头训练简化版 Omni 模型

Fri, 27 Mar 2026 23:40:25 -0800

多模态——从 0 训练简化版 Omni 模型

经过了这么多章节的漫长学习，想必大家已经对大模型技术的完整演进脉络有了相对全面的认知。本节我们来把此前所学的知识进行融会贯通，在单张消费级显卡上从 0 开始，使用 PyTorch 实现一个简版的 Omni 模型。我们的目标是构建一个能够同时接收文本和图像两路输入的多模态基座。在这个模型中，我们将通过投影与注入机制，将提取好的视觉特征与文本序列相结合，构建一个端到端联合计算与生成的多模态大模型。

一、数据准备与预处理

1.1 获取训练数据

由于资源所限，我们可以参考上一节介绍的 Qwen3-Omni 等模型的落地方案，采取“先炼纯文本基座，再做多模态对齐”的分阶段训练策略。为了能够在单卡上完成训练，我们需要抛开动辄数 TB 的海量语料，转而寻找“小而精”的高质量数据集作为切入点。在纯文本数据准备阶段，我们可以借用开源项目 MiniMind 提供的数据。这是一个致力于在普通个人显卡上从 0 训练超轻量级大模型的开源项目，其中自带了作者经过过滤乱码、去重除噪与启发式质量打分后沉淀出的高质量精简数据集。我们主要选择其中的 pretrain_hq.jsonl 作为语言预训练语料，以及 sft_mini_512.jsonl 作为微调语料。当纯文本基座有了优质的数据后，要想让它进一步具备视觉感知，还需要引入跨模态对齐数据。出于同样的算力及训练时长考量，图像数据方面，我们可以选择 Flickr8k 这个经典的测试数据集。由于我们的目标是在中文语境下进行交互，所以就需要配套引入 Flickr8k-CN 的中文描述文本（flickr8kzhc.caption.txt）。

有了现成的高质量开源数据之后，就可以开始实现项目代码了。我们先创建一个名为 seeker-omni 的项目文件夹，并且作为现代化的 Python 工程，可以在该目录下使用 uv init 快速初始化一个带有 pyproject.toml 的虚拟环境，并把运行所需的依赖（如 torch、tokenizers、tqdm 等）都一并在环境中打通。随后在其中分别创建一个 dataprep/download 和一个 dataprep/prepare 文件夹，用于存放数据的下载脚本以及前期的清洗、Tokenizer（分词器）训练等处理代码。由于不同数据集的下载接口和清洗逻辑大同小异，且往往伴随繁琐的工程细节，为了不偏离本节的主要目标，就不再赘述这部分“脏活累活”的代码实现了，我们可以直接利用 AI 编程工具辅助生成相应的处理脚本。笔者运行脚本拉取数据并处理后的目录结构大致如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


seeker-omni/
└─ data/
 ├─ raw/
 │ ├─ minimind/
 │ │ ├─ pretrain_hq.jsonl
 │ │ └─ sft_mini_512.jsonl
 │ └─ flickr8k/
 │ ├─ flickr8kzhc.caption.txt
 │ ├─ Flickr8k_Dataset/
 │ │ ├─ *.jpg
 │ │ └─ ...
 │ └─ text/
 │ ├─ Flickr_8k.trainImages.txt
 │ └─ ...
 └─ interim/
 ├─ tokenizer_corpus/
 │ └─ minimind_pretrain_text.txt
 ├─ sft_converted/
 │ └─ minimind_sft_chatml.jsonl
 └─ packs/
 └─ mm/
 └─ train_imgonly.jsonl

可以看到 data/interim（中间产物）目录下，存放着经过脚本“清洗过滤与格式转换”后的数据。tokenizer_corpus/minimind_pretrain_text.txt 是在去除乱码并剔除低含中量、多符号以及长度不合格等低质样本后提取出的预训练文本，专门用于后续训练我们自己的分词器。为了让大家对这些数据有一个直观的体感，我们可以看一下截取自 minimind_pretrain_text.txt 的纯文本语料片段（各对话之间用 <|im_end|> 粗略隔开）：

1

我知道底边长度和高，分别是5cm和8cm，请告诉我计算出来的面积是多少。三角形的面积为20平方厘米。<|im_end|> 为什么理智告诉我们不要跟陌生人接触？因为陌生人可能会对我们的个人安全造成威胁、危害或诱骗等恶劣行为。<|im_end|> 上一次科比在NBA总决赛中获得总冠军是哪一年？科比在NBA总决赛中最后一次获得总冠军是在2010年。<|im_end|> 写一首五言诗，以“秋天”为主题。秋叶飘飘降，秋风肆虐长街，落叶纷纷掉下，百鸟南飞不归，唯有寒蝉孤嘶。<|im_end|> 好的。那你可以跟我聊一下最近的天气吗？当然可以。最近的天气因地区而异，你想知道哪个城市的天气情况呢？<|im_end|> 好的，那么请你接着把这个句子进一步改写，加入一个介绍该书的短语。这本畅销书是由名著名文学家所著写的。<|im_end|> 从以下描述中归纳出这是哪种动物：该动物四肢行走，有毛发，是哺乳动物。这是哺乳动物，具体种类无法确定。<|im_end|> 请问这周末的天气怎么样？我需要您告诉我您所在的城市地区，我可以通过查询天气API来提供相关天气信息。<|im_end|>

还有 sft_converted/minimind_sft_chatml.jsonl 除了经过同样的清洗，还被统一赋予了包含 System、User、Assistant 角色绑定的标准 ChatML 对话指令格式，它的一行 JSONL 数据结构大致如下：

1

{"id": "line-676605", "conversations": [{"role": "system", "content": "你是一个知识丰富的AI，尽力为用户提供准确的信息。"}, {"role": "user", "content": "请向我解释在 GitHub 的公共代码库中使用的 MIT 许可证。"}, {"role": "assistant", "content": "MIT 许可证是一种广泛使用的开源软件许可证，允许用户自由地使用、修改和分发软件。它通常用于 GitHub 上的公共存储库，因为它提供了一个简单和宽松的许可证，允许其他人在不需要担心严格要求或复杂的法律条款的情况下使用和建立在该软件之上。该许可证还要求用户保留软件中的版权和许可证通知，这有助于确保该软件的原始创建者获得信誉，并且其他人知道可以使用该软件的条款。总的来说，MIT 许可证为他人提供开源软件的简单有效方式，同时保护原始创建者的权利。"}, {"role": "user", "content": "你觉得 MIT 许可证好吗？"}, {"role": "assistant", "content": "MIT许可证的好处最终取决于使用它的个人或组织的具体情况和目标。一般而言，MIT许可证被认为是一种非常宽松和简单的开源许可证，允许用户自由使用、修改和分发软件，而不需要其他开源许可证中存在的严格要求和法律复杂性。这使它成为许多开源项目的好选择，特别是那些专注于协作和社区参与的项目。"}]}

至于图文侧最终产出的 packs/mm/train_imgonly.jsonl，同样以类似风格的结构化格式将 Flickr8k 的图片路径与经过基础规范的中文描述整齐地绑定在了一起：

1

{"id": "flickr8k-2208631481_3e4a5675e1-zhc-0", "system": "你是一个只用中文回答的助手。", "prompt": "请描述这张图片。", "answer": "在草地上赛跑的两只黑狗。", "image": "data/raw/flickr8k/Flickr8k_Dataset/2208631481_3e4a5675e1.jpg"}

1.2 分词器的构建与训练

数据处理好后我们是不是就可以开始编写大模型的训练代码了呢？当然不是，在此之前我们需要先完成分词器的训练。来到 dataprep/prepare 文件夹下，开始创建分词器的核心执行脚本 tokenizer.py。为了让代码结构更清晰，我们“自顶向下”的来逐步完成各个模块。首先在 tokenizer.py 文件顶部，引入必要的系统包，并提前规划好本库多模态架构与对话微调高度依赖的特殊控制符。这些标记包括通用占位符 <|endoftext|>，切分 ChatML 角色发言边界的 <|im_start|> 和 <|im_end|>，以及界定视觉特征插入位置的 <img_bos>、<img> 与 <img_eos>。只有在构建字典时硬性绑定这批特殊的控制标记，后续端到端训练时的切片逻辑才能正常运作。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


# dataprep/prepare/tokenizer.py
import json
import random
import shutil
import time
from pathlib import Path

from tokenizers import Tokenizer

from .text_bpe import train_text_bpe
from ..data_paths import DATA_INTERIM, MINIMIND_TEXT_CORPUS, TOKENIZER_DIR, TOKENIZER_VOCAB_SIZE

MINIMIND2_CHATML_TOKENS = [
 "<|endoftext|>",
 "<|im_start|>",
 "<|im_end|>",
 "<img_bos>",
 "<img>",
 "<img_eos>",
]

可以看到上面的代码中，我们引入了两个当前还未详细讲解的模块分别是 data_paths 和 text_bpe。先来看相对简单的路径管理模块。其实在之前的 dataprep/download 数据清洗阶段，为了避免整个项目中随处可见散落的硬编码路径，我们就已经建立了一个集中的路径注册表。在 dataprep 目录下新建的这个 data_paths.py 中，已经把诸如中间存放语料的目录、分词器保存的目录，以及词表大小上限等统一定义在了这里并暴露出去：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


# dataprep/data_paths.py
from pathlib import Path

DATA_RAW = Path("data/raw")
DATA_INTERIM = Path("data/interim")
DATA_PROCESSED = Path("data/processed")
ARTIFACTS = Path("artifacts")

# 默认设置常量
SEED = 42
OVERWRITE = False

# (此处省略中间各种有关 Flickr8k 图文和 minimind 基础语料的大量源地址定义和图文的交接文件配置)
...

# 分词器语料与默认导出目录
MINIMIND_TEXT_CORPUS = DATA_INTERIM / "tokenizer_corpus" / "minimind_pretrain_text.txt"
TOKENIZER_VOCAB_SIZE = 6400
TOKENIZER_DIR = ARTIFACTS / "tokenizers" / "bpe_m2chatml_6400"

def default_dataprep_cfg():
 """返回 dataprep 默认配置 dict"""
 return {
 "seed": int(SEED),
 "overwrite": bool(OVERWRITE),
 "tokenizer": {
 "sample_ratio": 0.6,
 "sample_seed": int(SEED),
 },
 # 其他限流参数与占位配置省略...
 }

除了上面统一管理的大量路径常量外，data_paths.py 底部还提供了一份 default_dataprep_cfg() 默认配置字典。它将所有的下载源链接、文件覆盖策略以及分词器的采样种子参数等统统打包在了一起，为整个数据处理管道提供了一套完整的开箱即用蓝本。

在实际的工程开发中，data_paths.py 里专门针对 tokenizer 的这部分配置往往是和下游的分词器训练脚本同步编排、逐渐补充完善的。但出于教学脉络连贯的考量，我们在文中予以了提前展示。

搞定了路径与全局变量的集中管控后，接下来就要解决分词器训练的底层算法 train_text_bpe 了。我们在 dataprep/prepare/ 目录下创建一个脚本 text_bpe.py。由于这个脚本兼具了推断配置参数和核心算法调用的双重职责，我们把它拆解为两部分进行实现。第一部分是辅助函数，负责智能推断模型的对话体系标准并自动写入对应的配置文件。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50


# dataprep/prepare/text_bpe.py
import json
from pathlib import Path

from tokenizers import Tokenizer
from tokenizers.decoders import ByteLevel as ByteLevelDecoder
from tokenizers.models import BPE
from tokenizers.pre_tokenizers import ByteLevel
from tokenizers.trainers import BpeTrainer

# 此处省略 ChatML Jinja 模板字符串，完整内容参考配套代码
_MINIMIND_CHAT_TEMPLATE = """{%- if tools %}..."""

def _infer_core_tokens(special_tokens):
 """从 special_tokens 推断 scheme 名称与 pad/bos/eos/unk 的字符串形式。

 当前 dataprep 只支持 minimind2_chatml。
 """
 s = set(map(str, special_tokens))
 required = {"<|endoftext|>", "<|im_start|>", "<|im_end|>"}
 if not required.issubset(s):
 raise ValueError(
 "special_tokens must include minimind2_chatml core tokens: "
 "<|endoftext|>, <|im_start|>, <|im_end|>"
 )
 return "minimind2_chatml", "<|endoftext|>", "<|im_start|>", "<|im_end|>", "<|endoftext|>"

def _write_tokenizer_config(
 *, out_dir, tok, special_tokens,
 scheme_name, pad_token, bos_token, eos_token, unk_token,
):
 added_tokens_decoder = {
 str(i): {
 "content": t, "lstrip": False, "normalized": False,
 "rstrip": False, "single_word": False, "special": True
 } for i, t in enumerate(special_tokens)
 }

 cfg = {
 "legacy": True, "model_max_length": 32768,
 "tokenizer_class": "PreTrainedTokenizerFast",
 "added_tokens_decoder": added_tokens_decoder,
 "bos_token": str(bos_token), "eos_token": str(eos_token),
 "pad_token": str(pad_token), "unk_token": str(unk_token),
 "vocab_size": int(tok.get_vocab_size()),
 }
 if str(scheme_name) == "minimind2_chatml":
 cfg["chat_template"] = _MINIMIND_CHAT_TEMPLATE

 (out_dir / "tokenizer_config.json").write_text(json.dumps(cfg, ensure_ascii=False, indent=2), encoding="utf-8")

上面的 _infer_core_tokens 函数通过严格提取并校验我们预先指定的控制符子集，专门针对 ChatML 对话方案进行了映射绑定。只要它检查到外部传来的控制符列表里包含了完整的 ChatML 核心边界符，就会直接提取这套专为多轮交互设计的词表配置映射，进而在 _write_tokenizer_config 时自动将大模型体系专用的那段对话提示词模板（_MINIMIND_CHAT_TEMPLATE）写入最终的 tokenizer_config.json 配置文件中，实现参数装配的自动化与解耦。在准备好这些后勤辅助逻辑后，第二部分就是真正负责读取清洗数据并调用 Hugging Face 库训练构建字典的核心函数了。为了解决生僻字或特殊符号导致的 OOV 问题，我们在这一步采用跟 GPT 实现相同的字节级 BPE（BBPE）。

分词器是怎么“训练”的？

在这个 BBPE 算法中，训练不涉及神经网络的梯度反向叠加，而是纯粹的词频统计与合并分析。算法首先会把海量的预训练纯文本语料彻底打碎成最基础的 256 种单字节。然后遍历整套语料，统计拼在一起出现频率最高的“字节对”，并把这两个字节“粘合”成一个新的专属词条加入词典。接着它会在剩下的语料中继续寻找新的高频组合不断粘合。这个过程一直循环周而复始，直到词典里的“积木块”数量达到了我们设定的上限（本例中设定了 vocab_size=6400）为止，训练就会停止。也正对应我们在 GPT 应用中发现的，常见词语会被切成完整的一块，生僻字可能会被拆解为两三个散碎的底层字节。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


# dataprep/prepare/text_bpe.py
def train_text_bpe(
 *, input_path, out_dir, vocab_size=6400, special_tokens,
):
 inp = Path(input_path)
 out = Path(out_dir)
 out.mkdir(parents=True, exist_ok=True)

 special_tokens = list(special_tokens)
 scheme_name, pad_token, bos_token, eos_token, unk_token = _infer_core_tokens(special_tokens)

 tok = Tokenizer(BPE(unk_token=str(unk_token), byte_fallback=True))
 tok.pre_tokenizer = ByteLevel(add_prefix_space=False)

 trainer = BpeTrainer(
 vocab_size=int(vocab_size), special_tokens=special_tokens,
 show_progress=True, initial_alphabet=ByteLevel.alphabet(),
 )
 tok.train([str(inp)], trainer=trainer)

 # 保证特殊 token 的 ID 稳定
 for i, t in enumerate(special_tokens):
 tid = tok.token_to_id(t)
 if tid is None or int(tid) != int(i):
 raise ValueError(f"special token id mismatch: {t} -> {tid} (expected {i})")

 tok.decoder = ByteLevelDecoder()
 tok.save(str(out / "tokenizer.json"))
 _write_tokenizer_config(
 out_dir=out, tok=tok, special_tokens=special_tokens,
 scheme_name=str(scheme_name), pad_token=str(pad_token),
 bos_token=str(bos_token), eos_token=str(eos_token), unk_token=str(unk_token),
 )

 meta = {
 "special_tokens_scheme": str(scheme_name), "vocab_size": tok.get_vocab_size(),
 "special_tokens": special_tokens, "special_ids": {t: tok.token_to_id(t) for t in special_tokens},
 }
 (out / "meta.json").write_text(json.dumps(meta, ensure_ascii=False, indent=2), encoding="utf-8")

train_text_bpe 函数会首先实例化一个开启了底层字节回退（byte_fallback=True）机制的 BPE 模型，并利用 BpeTrainer 对输入语料集进行高频片段的归并与词典训练。但在训练出底层映射后，它还执行了一步关键的断言校验，主要用于强制检查字典里那批系统级特殊控制符所分配的 ID 是否与我们预期硬塞入的列表索引完全一致（验证它们是否强制占用了词表最靠前的 0, 1, 2… 等位置）。这步“锁死”特殊 Token ID 的操作对于多模态架构很重要，只有它们的系统 ID 永远固定，后续大模型在做视觉特征切片与对应的词嵌入检索时才不会发生错位。一切校验无误后，它才会将分词器本体、模型配置及自定义的元数据分别落盘保存。实现了底层算法后，我们再回到刚才未完成的 tokenizer.py 文件中，补全余下负责整体统筹的流程控制代码。剩余的逻辑主要负责读取 MINIMIND_TEXT_CORPUS 语料，为避免语料过大导致内存溢出，它还会根据配置支持对预训练文本进行按比例采样以加快训练速度。随后，代码会调用刚才写好的 train_text_bpe 正式挂载训练构建。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75


# dataprep/prepare/tokenizer.py
def _count_nonempty_lines(path):
 n = 0
 with path.open("r", encoding="utf-8-sig") as f:
 for line in f:
 if line.strip():
 n += 1
 return n

def _sample_text_corpus(*, src, dst, ratio, seed, overwrite):
 # 随机采样逻辑，详见配套源码
 pass

def _ensure_tokenizer(*, text_corpus, out_dir, vocab_size, overwrite):
 meta_path = out_dir / "meta.json"
 if overwrite and out_dir.exists():
 shutil.rmtree(out_dir)

 if meta_path.exists():
 meta = json.loads(meta_path.read_text(encoding="utf-8"))
 if meta.get("special_tokens_scheme") == "minimind2_chatml" and int(meta.get("vocab_size", -1)) == int(vocab_size):
 return

 out_dir.parent.mkdir(parents=True, exist_ok=True)
 t0 = time.time()
 train_text_bpe(
 input_path=text_corpus,
 out_dir=out_dir,
 vocab_size=int(vocab_size),
 special_tokens=list(MINIMIND2_CHATML_TOKENS),
 )
 dt = int(time.time() - t0)
 print(f"ok: tokenizer -> {out_dir} (sec={dt})")

def ensure_tokenizer_and_load(cfg):
 seed = int(cfg.get("seed", 42))
 overwrite = bool(cfg.get("overwrite", False))
 tok_cfg = cfg.get("tokenizer", {})

 vocab_size = int(TOKENIZER_VOCAB_SIZE)
 tokenizer_out = Path(TOKENIZER_DIR)
 text_corpus = Path(MINIMIND_TEXT_CORPUS)
 if not text_corpus.exists():
 raise FileNotFoundError(text_corpus)

 tmp_root = Path(DATA_INTERIM) / "tmp"
 sample_ratio = float(tok_cfg.get("sample_ratio", 1.0))
 sample_seed = int(tok_cfg.get("sample_seed", seed))

 tokenizer_corpus_for_train = text_corpus
 if sample_ratio < 1.0:
 safe_name = text_corpus.name.replace(".", "_")
 ratio_str = f"{sample_ratio:.6f}".rstrip("0").rstrip(".")
 sampled = tmp_root / f"{safe_name}.sample_p{ratio_str}_seed{sample_seed}.txt"
 tokenizer_corpus_for_train = _sample_text_corpus(
 src=text_corpus, dst=sampled, ratio=sample_ratio, seed=sample_seed, overwrite=overwrite
 )

 print(f"using tokenizer corpus: {tokenizer_corpus_for_train} (lines={_count_nonempty_lines(tokenizer_corpus_for_train)})")
 print("== prepare: tokenizer ==")

 _ensure_tokenizer(
 text_corpus=tokenizer_corpus_for_train,
 out_dir=tokenizer_out,
 vocab_size=vocab_size,
 overwrite=overwrite,
 )

 if tokenizer_corpus_for_train != text_corpus and tokenizer_corpus_for_train.exists():
 tokenizer_corpus_for_train.unlink(missing_ok=True)

 tok = Tokenizer.from_file(str(tokenizer_out / "tokenizer.json"))
 if int(tok.get_vocab_size()) != int(vocab_size):
 raise RuntimeError(f"tokenizer vocab mismatch: tok={tok.get_vocab_size()} expected={vocab_size}")
 return tok

当我们把分词器的训练和加载逻辑收拢完毕后，为了便于外部作为工程模块统一调用，我们在 dataprep/prepare 目录下顺手把包结构搭建起来。新建一个 __init__.py 对外暴露出一个全局的 run 执行入口：

1
2
3
4
5


# dataprep/prepare/__init__.py
from .tokenizer import ensure_tokenizer_and_load

def run(cfg):
 tok = ensure_tokenizer_and_load(cfg)

1.3 训练语料特征序列化

有了分词器和对应数据，按理说大模型就可以直接拿它们去训练了，但如果我们直接在 PyTorch 的 DataLoader 里挂载前面我们处理好的那些 .jsonl 或是 .txt 文本，在进行多卡甚至是单卡的大批量吞吐时，由于涉及到海量变长字符串的实时分词与内存分配，CPU 或磁盘 I/O 很容易成为阻碍 GPU 计算的性能瓶颈。为了解决这个问题我们可以在预处理阶段，提前把文本与图像都转换为可训练的数值表示。文本用分词器转换为等长的数字 ID，再使用 Numpy 的 memmap（内存映射）技术，将这些张量紧凑地当成二维连续矩阵序列化到磁盘特定的二进制（.bin）文件中。我们在 dataprep/prepare 目录下创建一个执行脚本 memmap.py。这个脚本的作用就是把前面清洗好的语料和训练好的分词器组合起来，分别去生成预训练和微调所需的二进制数据块：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


# dataprep/prepare/memmap.py
import shutil
import time
from pathlib import Path
from tokenizers import Tokenizer
from .memmap_io import MemmapMeta

def _ensure_packed_text(*, text_path, out_dir, tokenizer, vocab_size, max_seq_len, max_samples, seed, overwrite):
 # 1. 校验是否已存在符合要求的历史特征，避免重复生成
 meta_path = out_dir / "meta.json"
 if meta_path.exists() and not overwrite:
 meta = MemmapMeta.load(meta_path)
 if int(meta.seq_len) == int(max_seq_len) and int(meta.vocab_size) == int(vocab_size):
 return

 # 2. 调用底层的构造器正式生成二进制特征阵列
 # (具体封装逻辑 `build_packed_text_memmap_dataset` 省略，功能是读取文本逐行Token化并写入硬盘)
 ...

在上述的调度流程中可以看到，真正将海量文本转化为连续硬盘矩阵的逻辑都交由底层的 memmap_io 模块来实现。让我们在同级目录下继续建设这个基础读写模块 memmap_io.py：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60


# dataprep/prepare/memmap_io.py
import json
from dataclasses import dataclass
from pathlib import Path
import numpy as np

@dataclass(frozen=True)
class MemmapMeta:
 """memmap 数据集的元信息（用于数据准备阶段写入/校验）。"""
 # ...省略字段定义（num_samples, seq_len 等）...

 @staticmethod
 def load(path):
 # ...从 JSON 加载元数据逻辑...
 pass

 def save(self, path):
 # ...保存至 meta.json 逻辑...
 pass

class MemmapWriter:
 """将 token/labels/attention 写入到 memmap 目录。"""
 def __init__(self, out_dir, *, num_samples, seq_len, vocab_size, pad_id, image_tokens=None, image_feat_dim=None, mode="w+"):
 self.out_dir = Path(out_dir)
 self.out_dir.mkdir(parents=True, exist_ok=True)

 # 初始化与校验元数据
 self.meta = MemmapMeta(num_samples, seq_len, vocab_size, pad_id, image_tokens=image_tokens, image_feat_dim=image_feat_dim)
 if mode == "w+":
 self.meta.save(self.out_dir / "meta.json")

 n = int(self.meta.num_samples)
 s = int(self.meta.seq_len)

 # 基于元信息开辟 Numpy 内存映射空间
 self.input_ids = np.memmap(self.out_dir / "input_ids.bin", dtype=np.dtype(self.meta.input_dtype), mode=mode, shape=(n, s))
 self.labels = np.memmap(self.out_dir / "labels.bin", dtype=np.dtype(self.meta.label_dtype), mode=mode, shape=(n, s))
 self.attention_mask = np.memmap(self.out_dir / "attention_mask.bin", dtype=np.dtype(self.meta.attention_dtype), mode=mode, shape=(n, s))

 self.image_feats = None
 if self.meta.image_tokens is not None and self.meta.image_feat_dim is not None:
 self.image_feats = np.memmap(
 self.out_dir / "image_feats.bin", dtype=np.float16, mode=mode,
 shape=(n, int(self.meta.image_tokens), int(self.meta.image_feat_dim)),
 )

 def write(self, idx, *, input_ids, labels, attention_mask, image_feats=None):
 self.input_ids[idx] = input_ids.astype(self.input_ids.dtype, copy=False)
 self.labels[idx] = labels.astype(self.labels.dtype, copy=False)
 self.attention_mask[idx] = attention_mask.astype(self.attention_mask.dtype, copy=False)

 if self.image_feats is not None and image_feats is not None:
 self.image_feats[idx] = image_feats.astype(np.float16, copy=False)

 def flush(self):
 self.input_ids.flush()
 self.labels.flush()
 self.attention_mask.flush()
 if self.image_feats is not None:
 self.image_feats.flush()

这里的 memmap_io 模块展示了数据管道走向落地的最后一步。首先，我们用不可变的数据类 MemmapMeta 将包括序列长度、词表大小在内的这套张量规格严格固化了下来，并保存为同级目录下的 meta.json 索引卡。这么做是为了在后续训练读取甚或是增量生成数据时，防止维度定义错乱造成内存越界。在建立好规范后，MemmapWriter 的 __init__ 函数直接利用 np.memmap ，一次性为全部将要输入模型的核心张量（输入 ID、标签 Label、注意力掩码 Attention Mask）预分配好结构严密且连续的二进制磁盘空间。而且为了原生支撑整个多模态架构的运行，一旦检测到外部配置了图片特征的相关维度约束（image_tokens 与 image_feat_dim），它还会专门开辟出一整块用于存储大体积视觉向量矩阵的 image_feats.bin 区域，并精细地将其底层数据格式卡在 np.float16 以节省空间。当 MemmapWriter 初始化并分配好内存映射空间后，memmap.py 调度脚本只需源源不断地抽取处理好的文本 Token ID 或图像特征矩阵，通过 writer.write(idx, ...) 方法按索引写入对应的预定位置，最后调用 flush 将数据落盘保存即可。

完成了无监督预训练数据的落盘操作后，我们知道大模型要想掌握对话的能力，还必须用到 SFT 指令语料。接下来我们继续在 memmap.py 中实现负责调度微调数据的 _ensure_sft_text 函数：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


# dataprep/prepare/memmap.py
from .sft_builder import build_sft_text_memmap_dataset

def _ensure_sft_text(*, in_jsonl, out_dir, tokenizer, vocab_size, max_seq_len, overwrite):
 # 第一步同理，先通过 meta.json 校验是否可复用缓存跳过...

 # 主要差异：由专属的 SFT 构造器来处理带角色限定的对话语料
 build_sft_text_memmap_dataset(
 jsonl_path=str(in_jsonl),
 out_dir=str(out_dir),
 text_tokenizer=tokenizer,
 vocab_size=int(vocab_size),
 max_seq_len=int(max_seq_len),
 resume=False,
 flush_every=200,
 )

与预训练阶段直接顺次拼接文本并分块切片的简单流水线不同，微调语料有着严格的结构划分（System、User、Assistant），所以必然得有一套专门用于提示模板包裹与交叉熵损失屏蔽的逻辑。为了实现 build_sft_text_memmap_dataset 接口，我们继续在同级目录下新建一个 sft_builder.py 脚本来处理这份更加精细的构造任务：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48


# dataprep/prepare/sft_builder.py
import json
import numpy as np
from .memmap_io import MemmapWriter

def build_sft_text_memmap_dataset(*, jsonl_path, out_dir, text_tokenizer, max_seq_len, vocab_size, ...):
 # 1. 挂载词表中的特殊控制 Token（如 pad 占位，以及 ChatML 体系的体系化标记）
 pad_id = text_tokenizer.token_to_id("<|endoftext|>")
 bos_id = text_tokenizer.token_to_id("<|im_start|>")
 eos_id = text_tokenizer.token_to_id("<|im_end|>")
 # ...省略繁琐的 Token ID 校验与断言...

 # 2. 初始化底层流式存储类
 writer = MemmapWriter(out_dir, num_samples=n, seq_len=max_seq_len, vocab_size=vocab_size, pad_id=pad_id, mode='w+')

 # 3. 逐行读取 jsonl 格式的微调语料，通过 ChatML 角色控制符硬编码包裹拼接
 for idx, obj in enumerate(_iter_json_objects(jsonl_path)):
 conversations = obj.get("conversations")

 tokens = [] # 喂给大模型的所有字符索引
 labels_list = [] # 训练掩码对齐数组

 for m in conversations:
 role = m["role"]
 content = m["content"]

 # 使用 ChatML 特有的边界符包裹具体的发言内容，帮助基座快速建立角色认知
 header = [bos_id] + text_tokenizer.encode(f"{role}\n").ids
 body = text_tokenizer.encode(content).ids
 footer = [eos_id] + text_tokenizer.encode("\n").ids

 msg_tokens = header + body + footer

 # 只让大模型对 Assistant（它自己的答案）去计算 Loss
 # 对于 System、User 的上下文前提，统统打上 -100 (PyTorch CrossEntropyLoss 默认的 ignores_index)
 msg_labels = [-100] * len(msg_tokens)
 if role == "assistant":
 for j in range(len(header), len(msg_tokens)):
 msg_labels[j] = msg_tokens[j]

 tokens.extend(msg_tokens)
 labels_list.extend(msg_labels)

 # 4. 根据设定的最大序列长度进行截断与 Padding（以 pad_id 填补余位），最后交由 MemmapWriter 写盘
 # ...省略截断补齐的矩阵赋值...
 writer.write(idx, input_ids=input_ids, labels=labels, attention_mask=attention_mask)

 writer.flush()

sft_builder 的代码实现有两个亮点。其一是针对大模型专属的对话提示进行了系统性的 ChatML 组装，使基座模型可以通过识别专门的边界占位符快速建立对应的角色认知。第二个是在构造训练标签时，我们设计了一套巧妙的交叉熵掩码屏蔽机制。这里我们利用了 PyTorch 原生计算交叉熵去忽略无效索引的默认掩码值 -100。基于这种遮蔽策略我们将先验指令和人类的问题都打上了专门的占位符，只让基座模型对应该作答的内容去收敛预测参数。不管人类怎么提问这些前序语句都只作为上下文条件存在而不单独耗费梯度的算力，这也为模型带来了最高效的针对性复习体验。接下来回到 memmap.py 中，我们分别通过 _ensure_packed_text 和 _ensure_sft_text 铺设好了预训练与微调的解析方案后，只需在 memmap.py 的最下方提供一个统一的对外调度入口 ensure_memmaps：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


# dataprep/prepare/memmap.py
from pathlib import Path
from ..data_paths import MINIMIND_TEXT_CORPUS, MINIMIND_SFT_SEEKER, TEXT_PRETRAIN_340, TEXT_SFT_340

def ensure_memmaps(cfg: dict, tokenizer):
 overwrite = bool(cfg.get("overwrite", False))
 vocab_size = int(tokenizer.get_vocab_size())

 print("== prepare: packed text (340) ==")
 _ensure_packed_text(
 text_path=Path(MINIMIND_TEXT_CORPUS),
 out_dir=Path(TEXT_PRETRAIN_340),
 tokenizer=tokenizer,
 vocab_size=vocab_size,
 max_seq_len=340,
 overwrite=overwrite,
 )

 print("== prepare: sft text (340) ==")
 _ensure_sft_text(
 in_jsonl=Path(MINIMIND_SFT_SEEKER),
 out_dir=Path(TEXT_SFT_340),
 tokenizer=tokenizer,
 vocab_size=vocab_size,
 max_seq_len=340,
 overwrite=overwrite,
 )

回到 dataprep/prepare/__init__.py 的 run 函数中，把刚刚写完的二进制分配逻辑加上，成为数据准备管线的“最后一块拼图”：

1
2
3
4
5
6
7


# dataprep/prepare/__init__.py
from .tokenizer import ensure_tokenizer_and_load
from .memmap import ensure_memmaps # 引入新增的内存映射逻辑

def run(cfg):
 tok = ensure_tokenizer_and_load(cfg)
 ensure_memmaps(cfg, tok) # 词表构建完毕，正式执行所有数据的二进制分配

最后，我们还可以在这层包下再补上一个 __main__.py 入口，支持从命令行一键独立拉起这整个预处理管线：

1
2
3
4
5
6
7


# dataprep/prepare/__main__.py
from . import run
from ..data_paths import default_dataprep_cfg

if __name__ == "__main__":
 cfg = default_dataprep_cfg()
 run(cfg)

有了这套外壳，我们在系统终端只要敲下 uv run python -m dataprep.prepare 的指令，基于 uv 隔离环境的整个数据准备构建流程就能一顺到底彻底跑通了。运行结束后，我们将会得到以下两大类核心产物。

分词器配置：

tokenizer.json：BPE 分词器的权重与词缀拼装合并规则集合。

tokenizer_config.json：包含控制符配置以及供后续推理框架适配使用的 ChatML 对话模板（Jinja 格式）。

meta.json：我们在预处理流程中专门固化的元数据（包含词表大小、特殊 Token 的映射关系等）。

可以直接供模型吞吐的训练张量：

预训练 Packed Memmap：位于 data/processed/text_pretrain_packed_340_u16_offline/（TEXT_PRETRAIN_340），包含 meta.json、input_ids.bin、labels.bin 与 attention_mask.bin 四份张量。

微调 SFT Memmap：位于 data/processed/text_sft_340/（TEXT_SFT_340），包含 meta.json、input_ids.bin、labels.bin 与 attention_mask.bin 四份张量。

二、模型训练流水线与核心架构设计

数据准备就绪后，接下来我们在项目根目录下创建一个 seeker_omni 模块文件夹，开始具体设计模型架构与训练组装流程。与一上来就搭建庞大复杂的网络不同，在有限的算力下，我们要想让大模型具备出色的多模态能力，稳妥的做法是让模型先掌握语言规律，再学习遵循人类指令，最后注入视觉感知。那么我们可以将整个训练流水线明确划分为纯文本无监督预训练、纯文本指令微调以及端到端多模态对齐三个阶段。在第一阶段，也就是纯文本无监督预训练中，我们将此前清洗得到的二进制连续分布语料库送入模型，通过海量的无标注文本和因果语言建模进行自监督学习，让模型首先“学会说话”并掌握语言文字规律。但是，单纯的预训练基座只懂得顺着上文续写，所以在第二阶段的纯文本指令微调中，我们会使用 ChatML 格式包裹好、且带有 -100 交叉熵掩码屏蔽用户问题的精选问答数据对其进行精进，使模型蜕变为能听懂指令的助手。当纯文本基座具备了成熟的对话能力后，我们再进入第三阶段的端到端多模态对齐训练来赋予其视觉感知。不同于早期梯度断裂的拼接模型，这里我们引入图文描述记录，在训练中同时更新视觉特征投影层甚至解冻部分语言模型的骨干权重。这种端到端的联合反向传播，正是上一节中我们学习过的 Qwen3-Omni 等工业级模型时所强调的“紧耦合”架构的精髓所在。通过这种联合优化，拉近离散文本空间与连续视觉编码特征的距离，使大模型能够自然吞吐外界视觉特征，实现看图作答。如果想要进一步打磨模型的回答质量，让它的风格、安全性和有用性更符合人类的期望，就还需要进行基于人类反馈的强化学习偏好对齐，这部分技术我们在前面的章节中已经进行过学习和实战。由于本节我们的主要目标是跑通大模型多模态化的流程与核心回路，而不是实现一款可用的产品，所以这部分就略去了。笔者在后续的额外章节中，会基于当前这套项目框架，专门探讨如何引入 RLHF 对齐以及 MoE 等进阶优化技术，进一步释放模型潜力。

基于上述的阶段性训练策略，我们简化的多模态框架应该包含三个核心组件，第一个是负责文本处理的模块，它主要由常规的词嵌入与多模态特殊占位符构成。其次是视觉特征投影，负责接收由外部冻结的视觉编码器提取出的视觉特征，通过线性层和门控机制将视觉特征投影对齐到大模型的特征维度并注入到特征序列中。最后是统一大语言模型，也就是一个标准的 Transformer Decoder 模型，用来接收多模态融合后的特征序列并进行端到端自回归推理。具体架构如图 20-16 所示。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56


graph LR
 subgraph 输入["输入"]
 TXT["Token IDs"]
 IMG["Image Features"]
 end

 subgraph 嵌入["嵌入层"]
 EMB["词嵌入<br/><i>special + base</i>"]
 PROJ["Linear Projection<br/>× tanh(门控)"]
 ADD_E(("Add"))
 end

 TXT --> EMB --> ADD_E
 IMG -.-> PROJ -.-> ADD_E
 ADD_E --> DROP["Dropout"]

 subgraph BLOCK["Transformer Block × N"]

 subgraph 自注意力["Grouped-Query Attention"]
 QKV["Q / K / V 投影"] --> ROPE["RoPE"]
 ROPE --> SDPA["Scaled Dot-Product<br/>Attention<br/><i>+ Causal Mask</i>"]
 SDPA --> O_PROJ["Output Projection"]
 end

 subgraph 前馈网络["SwiGLU Feed-Forward"]
 GU["W_gate / W_up"] --> SW["SiLU(gate) × up"]
 SW --> WD["W_down"]
 end

 DROP --> NORM1["RMSNorm"]
 NORM1 --> QKV
 O_PROJ --> ADD1(("Add"))
 DROP -. "残差" .-> ADD1

 ADD1 --> NORM2["RMSNorm"]
 NORM2 --> GU
 WD --> ADD2(("Add"))
 ADD1 -. "残差" .-> ADD2
 end

 subgraph 输出["输出层"]
 FNORM["RMSNorm"]
 HEAD["LM Head<br/><i>与嵌入权重共享</i>"]
 LOGITS["Output Logits"]
 end

 ADD2 --> FNORM --> HEAD --> LOGITS

 style BLOCK fill:#fef9e7,stroke:#f39c12,stroke-width:2px
 style 自注意力 fill:#eaf2f8,stroke:#2980b9
 style 前馈网络 fill:#f5eef8,stroke:#8e44ad
 style 嵌入 fill:#fdf2e9,stroke:#e67e22
 style 输出 fill:#e8f8f5,stroke:#1abc9c
 style ADD1 fill:#d5f5e3,stroke:#27ae60
 style ADD2 fill:#d5f5e3,stroke:#27ae60
 style ADD_E fill:#d5f5e3,stroke:#27ae60

图 20-16 Seeker-Omni 统一多模态大模型架构

三、模型架构的实现

了解了整体架构与流水线之后，我们就开始动手，用 PyTorch 将这套多模态网络“搭”出来。我们先在刚刚创建好的 seeker_omni 模块下，新建一个专门存放模型核心代码的 model 文件夹，后续所有的网络组件实现都将归档于这个目录下。

3.1 前置配置模块

在工程开发中，各种常量路径、特殊字符和模型超参数的定义，往往是我们在搭建各个核心模块的过程中逐渐沉淀、抽离出来的。不过，为了让大家在后续组装主干网络时能在脑海里有个大致的结构概念，我们不妨先提前预览一下 seeker_omni 模块根目录下的这三个基础依赖文件的核心骨架。首先是整个项目输入输出常量的 paths.py，以及专门存放模型超参数数据类的 config.py：

1
2
3
4
5


# seeker_omni/paths.py
from pathlib import Path
DATA_PROCESSED = Path("data/processed")
TEXT_PRETRAIN_340 = DATA_PROCESSED / "text_pretrain_packed_340_u16_offline"
# ... 其他训练相关的数据集与分词器默认常量路径定义

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


# seeker_omni/config.py
from dataclasses import dataclass
from .special_tokens import DEFAULT_SPECIAL_TOKENS_SCHEME

@dataclass(frozen=True)
class ModelConfig:
 name: str
 vocab_size: int
 max_seq_len: int
 hidden_size: int
 num_layers: int
 num_heads: int
 # ... 其他架构参数
 special_tokens_scheme: str = DEFAULT_SPECIAL_TOKENS_SCHEME

在 config.py 中，我们为超参数设定了默认的词表方案，所以我们需要在 special_tokens.py 中将整个模型用到的特殊占位符（如 <|im_start|>、<|im_end|> 与 <img>）以及对应的方案列表进行统一定义：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75


# seeker_omni/special_tokens.py
from dataclasses import dataclass

@dataclass(frozen=True)
class TokenSchemeSpec:
 name: str
 special_tokens: list[str]
 pad_token: str
 bos_token: str
 eos_token: str
 unk_token: str


MINIMIND2_CHATML = TokenSchemeSpec(
 name="minimind2_chatml",
 special_tokens=[
 "<|endoftext|>",
 "<|im_start|>",
 "<|im_end|>",
 "<img_bos>",
 "<img>",
 "<img_eos>",
 ],
 pad_token="<|endoftext|>",
 bos_token="<|im_start|>",
 eos_token="<|im_end|>",
 unk_token="<|endoftext|>",
)


_SPECS: dict[str, TokenSchemeSpec] = {
 MINIMIND2_CHATML.name: MINIMIND2_CHATML,
}


def get_token_scheme_spec(scheme: str | None) -> TokenSchemeSpec:
 scheme = (scheme or MINIMIND2_CHATML.name).strip()
 spec = _SPECS.get(scheme)
 if spec is None:
 opts = ", ".join(sorted(_SPECS.keys()))
 raise ValueError(f"unknown special_tokens_scheme={scheme!r} (expected one of: {opts})")
 return spec


@dataclass(frozen=True)
class SpecialTokenIds:
 pad: int
 unk: int
 bos: int
 eos: int
 img_bos: int
 img: int
 img_eos: int


def build_special_token_ids(spec: TokenSchemeSpec) -> SpecialTokenIds:
 tok2id = {t: i for i, t in enumerate(spec.special_tokens)}

 def _id(t: str) -> int:
 if t not in tok2id:
 raise ValueError(f"required special token missing from scheme={spec.name!r}: {t}")
 return int(tok2id[t])

 return SpecialTokenIds(
 pad=_id(spec.pad_token),
 unk=_id(spec.unk_token),
 bos=_id(spec.bos_token),
 eos=_id(spec.eos_token),
 img_bos=_id("<img_bos>"),
 img=_id("<img>"),
 img_eos=_id("<img_eos>"),
 )


DEFAULT_SPECIAL_TOKENS_SCHEME = MINIMIND2_CHATML.name

3.2 文本嵌入

接下来我们就可以在 model 目录下新建 lm.py 文件，开始编写模型的主干类 SeekerOmniLM。多模态大模型的底座依然是语言模型，所以文本处理始终是最基础的起点。为了保持系统的高内聚与低耦合，并为后续多模态控制标记的演进（如增减模态占位符）预留空间，我们不会简单地使用单一的 nn.Embedding 把所有标记揉在一起，而是将特殊控制标记与普通文本词表的嵌入层在物理结构上直接拆分开来。有了前面的配置支撑，我们就能毫无阻碍地切分出特殊词表和普通词表，并完成真正的文本查表组装映射：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56


# seeker_omni/model/lm.py
import torch
import torch.nn as nn
from ..config import ModelConfig
from ..special_tokens import get_token_scheme_spec, build_special_token_ids

class SeekerOmniLM(nn.Module):
 def __init__(self, cfg: ModelConfig):
 super().__init__()
 self.cfg = cfg
 self.special_spec = get_token_scheme_spec(cfg.special_tokens_scheme)
 self.special = build_special_token_ids(self.special_spec)
 self.n_special = int(len(self.special_spec.special_tokens))

 # 将特殊 token（如 bos, eos, img 占位符等）与普通文本 token 分离
 self.special_embed = nn.Embedding(self.n_special, cfg.hidden_size)
 self.base_embed = nn.Embedding(cfg.vocab_size - self.n_special, cfg.hidden_size)

 def _embed_tokens(self, input_ids):
 # 分别根据 ID 范围查特殊词表和普通词表，最后拼合成统一的隐藏层张量
 n_special = int(self.n_special)
 is_special = input_ids < n_special

 x = torch.empty(
 (*input_ids.shape, self.cfg.hidden_size),
 device=input_ids.device,
 dtype=self.special_embed.weight.dtype,
 )

 if is_special.any():
 x[is_special] = self.special_embed(input_ids[is_special])
 if (~is_special).any():
 base_ids = (input_ids[~is_special] - n_special).clamp(min=0)
 x[~is_special] = self.base_embed(base_ids)
 return x

 def reset_parameters(self):
 # 初始化常规嵌入以及线性层
 nn.init.normal_(self.special_embed.weight, mean=0.0, std=0.02)
 nn.init.normal_(self.base_embed.weight, mean=0.0, std=0.02)
 for module in self.modules():
 if isinstance(module, nn.Linear):
 nn.init.normal_(module.weight, mean=0.0, std=0.02)

 # 关键：将模态占位符的词嵌入强行初始化为 0，确保模型初期不会因占位符引入额外噪声
 with torch.no_grad():
 for tid in (
 self.special.img_bos,
 self.special.img,
 self.special.img_eos,
 ):
 self.special_embed.weight[tid].zero_()

 def _lm_head_weight(self):
 # 语言模型头的权重与底层的文本嵌入权重共享（Weight Tying）以节约显存
 return torch.cat([self.special_embed.weight, self.base_embed.weight], dim=0)

通过这一步处理，混合了图片标记和文本标记的序列被成功映射为了连续向量。但是如果在输入序列中出现了图像占位符，我们就需要将外部的视觉特征对应注入进来。所以，我们先去实现一下它所依赖的视觉对齐模块。

3.3 视觉特征压缩与注入

由于资源所限，我们不再把 ViT 写在 LLM 的前向传播里进行重头训练，转而选择接收训练好的 SigLIP 提取出来的视觉特征。但预训练的 Vision Encoder 提取出的特征序列通常非常长（例如 729 个 Token），如果直接送入语言模型会极大拖慢推理速度并消耗过多显存。所以，我们需要引入一个感知重采样器对这一长串特征序列进行压缩。我们在 model 目录下新建 resampler.py，通过少量的可学习潜在查询向量，利用交叉注意力机制将冗长的图像特征平滑过渡并压缩到固定的较短长度（例如 64 个 Token）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


# seeker_omni/model/resampler.py
import torch
from torch import nn

class PerceiverResampler(nn.Module):
 def __init__(self, *, dim, num_latents, num_layers=2, num_heads=8, ff_mult=4):
 super().__init__()
 self.dim = int(dim)

 # 初始化固定数量的可学习潜在特征 (Latents)
 lat = torch.empty((num_latents, dim), dtype=torch.float32)
 nn.init.trunc_normal_(lat, std=0.02)
 self.latents = nn.Parameter(lat)

 # 构建交叉注意力层与前馈网络
 # ... (具体层的构建代码省略)
 self.layers = nn.ModuleList([...])

 def forward(self, x):
 # x 为 SigLIP 提取的原始长序列视觉特征: [B, T_img, D]
 b = int(x.shape[0])
 # 扩展潜在特征以匹配批次大小: [B, num_latents, D]
 latents = self.latents.unsqueeze(0).expand(b, -1, -1)

 for layer in self.layers:
 q = layer["ln_q"](latents)
 kv = layer["ln_kv"](x)
 # 通过交叉注意力，用少量的 Latents 去 Query 密集的视觉特征 KV
 attn_out, _ = layer["attn"](q, kv, kv, need_weights=False)
 latents = latents + attn_out
 latents = latents + layer["ff"](layer["ln_ff"](latents))

 # 返回定长的压缩视觉特征: [B, num_latents, D]
 return latents

视觉特征被成功压缩后，我们还需要最后一步的对齐。也就是在 model 目录下新建 projector.py 文件，通过可学习的线性映射与零初始化门控策略，将这些特征的维度对齐到大模型的隐藏层维度，并注入到对应的“图像占位 Token”位置中。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34


# seeker_omni/model/projector.py
import torch

def inject_feature_tokens(
 x,
 *,
 input_ids,
 image_feats,
 img_token_id,
 img_proj,
 img_gate,
):
 # x: [B, S, hidden_size]
 if image_feats is not None:
 img_mask = input_ids == int(img_token_id)
 if img_mask.any():
 # 将视觉特征投影至 LLM 维度
 img_tokens = img_proj(image_feats.to(dtype=x.dtype))
 # 门控机制：初始阶段 tanh(0)=0，使得模型初期等同于纯文本模型，有助于更稳定的联合训练
 img_tokens = img_tokens * torch.tanh(img_gate)[None, None, :]

 # 使用 nonzero 获取展平索引，进行快路径累加注入
 pos = img_mask.nonzero(as_tuple=False) # [N,2] row-major
 flat = img_tokens.reshape(-1, img_tokens.shape[-1])
 if pos.shape[0] == flat.shape[0]:
 x[pos[:, 0], pos[:, 1]] = x[pos[:, 0], pos[:, 1]] + flat
 else:
 for b in range(int(x.shape[0])):
 idx = torch.where(img_mask[b])[0]
 if idx.numel() == 0:
 continue
 take = min(idx.numel(), img_tokens.shape[1])
 x[b, idx[:take]] = x[b, idx[:take]] + img_tokens[b, :take]
 return x

可以注意到，这里的 projector.py 内部并没有直接去调用 resampler.py。这是一种非常经典的解耦设计：我们在上游的系统调度代码（例如专门的预处理脚本或多模态 Pipeline 本身）中，先运用 resampler.py 把极长的图像特征压缩成了短小精悍的连续张量。最后，这批被压缩过的张量会以 image_feats 参数的形式，干干净净地传递到文本底座的 projector 里进行投影和注入。这样一来，大模型主干代码的阅读体验就仿佛是在处理纯文本一样。为了在 lm.py 的主干网络中顺利调用 inject_feature_tokens 函数，我们只需在 SeekerOmniLM 类里补充一个轻便的内部方法 _inject_modality_tokens 来进行中转映射：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


# seeker_omni/model/lm.py

 def _inject_modality_tokens(self, x, *, input_ids, image_feats):
 # 将传入的投影参数绑定好，方便 forward 调用
 from .projector import inject_feature_tokens
 return inject_feature_tokens(
 x,
 input_ids=input_ids,
 image_feats=image_feats,
 img_token_id=int(self.special.img),
 img_proj=self.img_proj,
 img_gate=self.img_gate,
 )

现在我们特征的提取和对齐注入工作就已经备齐了。但如果现在就开始写前向传播，会发现还缺了一个“计算大脑”，所以还得先把解码块写完。

3.4 构建 Transformer 解码块

我们继续在 model 目录下新建 block.py 分别实现前馈神经网络块。在 block.py 中，我们的 SeekerBlock 需要组合注意力层、全连接层与均方根归一化，并且支持流式推理必须的 KV Cache。为了理清脉络，我们先写出 block.py 的主干骨架：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


# seeker_omni/model/block.py
import torch
from torch import nn

from .attention import PastKeyValue, SeekerSelfAttention
from .mlp import SeekerMLP
from .norm import RMSNorm

class SeekerBlock(nn.Module):
 def __init__(self, hidden_size, num_heads, num_kv_heads, **kwargs): # 用 **kwargs 代替其他传入的初始化超参数
 super().__init__()
 self.attn_norm = RMSNorm(hidden_size)
 self.attn = SeekerSelfAttention(hidden_size, num_heads, num_kv_heads, **kwargs)
 self.mlp_norm = RMSNorm(hidden_size)
 self.mlp = SeekerMLP(hidden_size, **kwargs)

 def forward(self, x, cos, sin, attention_mask=None, past_kv=None, use_cache=False):
 # 如果开启流式缓存，则调用注意力机制时抽取并封装 KV 缓存
 if use_cache:
 attn_out, present_kv = self.attn(
 self.attn_norm(x),
 cos=cos, sin=sin, attention_mask=attention_mask,
 past_kv=past_kv, use_cache=True,
 )
 x = x + attn_out
 x = x + self.mlp(self.mlp_norm(x))
 return x, present_kv

 # 否则普通的残差堆叠计算
 x = x + self.attn(self.attn_norm(x), cos=cos, sin=sin, attention_mask=attention_mask)
 x = x + self.mlp(self.mlp_norm(x))
 return x

有了蓝图，我们再逐个将引入的三个基础底座组件实现出来。首先在 model 目录下新建 norm.py 代入对应公式实现 RMSNorm。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


# seeker_omni/model/norm.py
import torch
from torch import nn

class RMSNorm(nn.Module):
 def __init__(self, dim, eps=1e-5):
 super().__init__()
 self.eps = eps
 self.weight = nn.Parameter(torch.ones(dim))

 def forward(self, x):
 scale = torch.rsqrt(x.pow(2).mean(dim=-1, keepdim=True) + self.eps)
 return (x * scale) * self.weight

在编写自注意力层之前，我们还需要先实现它的一个旋转位置编码。由于我们使用了早融合机制将图像作为特征序列插入文本，为了让整个序列的长距离注意力衰减保持绝对一致，我们在 model 目录下新建 rope.py 来专门处理位置编码的生成与应用。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


# seeker_omni/model/rope.py
import torch
from torch import nn

def _build_rope_cache(seq_len, dim, theta):
 # 构建复数域的旋转角度缓存矩阵
 inv_freq = 1.0 / (theta ** (torch.arange(0, dim, 2).float() / dim))
 positions = torch.arange(seq_len, dtype=torch.float32)
 freqs = torch.einsum("i,j->ij", positions, inv_freq)
 return torch.cos(freqs), torch.sin(freqs)

def apply_rope(x, cos, sin):
 # 将预计算好的 cos 和 sin 旋转矩阵作用到张量的奇偶维度上
 x_even = x[..., 0::2]
 x_odd = x[..., 1::2]

 cos = cos[None, None, :, :]
 sin = sin[None, None, :, :]

 out_even = x_even * cos - x_odd * sin
 out_odd = x_even * sin + x_odd * cos
 return torch.stack((out_even, out_odd), dim=-1).flatten(-2)

然后，我们需要新建 attention.py，来编写自注意力机制 SeekerSelfAttention。为了兼顾训练与推理的性能，我们在此类中引入分组查询注意力以成倍缩减显存开销，并直接内嵌对流式长文本生成的底层支持，即在每层实时计算并拼接 KV Cache。对于输入特征的位置标识，我们还需应用旋转位置编码技术，使模型即使在处理变长上下文时也能准确捕捉词汇相对距离。同时，注意力缩放点积计算，我们可以直接调用 PyTorch 原生集成在后端的 Flash Attention 算子（F.scaled_dot_product_attention），以缓解大矩阵内存读写的瓶颈。下面是这一核心流程的代码构建：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67


# seeker_omni/model/attention.py
import torch.nn.functional as F
from .rope import apply_rope

class SeekerSelfAttention(nn.Module):
 def __init__(self, hidden_size, num_heads, num_kv_heads, dropout=0.0):
 super().__init__()
 # ... 维度整除校验等省略 ...
 self.hidden_size = hidden_size
 self.num_heads = num_heads
 self.num_kv_heads = num_kv_heads
 self.head_dim = hidden_size // num_heads

 # 分组查询注意力（GQA）投影层
 q_out = num_heads * self.head_dim
 kv_out = num_kv_heads * self.head_dim
 self.q_proj = nn.Linear(hidden_size, q_out, bias=False)
 self.k_proj = nn.Linear(hidden_size, kv_out, bias=False)
 self.v_proj = nn.Linear(hidden_size, kv_out, bias=False)
 self.o_proj = nn.Linear(q_out, hidden_size, bias=False)

 def forward(self, x, *, cos, sin, attention_mask=None, past_kv=None, use_cache=False):
 bsz, seq_len, _ = x.shape

 # 1. 投影并重塑维度: [B, H, S, D]
 q = self.q_proj(x).view(bsz, seq_len, self.num_heads, self.head_dim).transpose(1, 2)
 k = self.k_proj(x).view(bsz, seq_len, self.num_kv_heads, self.head_dim).transpose(1, 2)
 v = self.v_proj(x).view(bsz, seq_len, self.num_kv_heads, self.head_dim).transpose(1, 2)

 # 2. 对 Q 和 K 注入 RoPE 旋转位置编码
 q = apply_rope(q, cos, sin)
 k = apply_rope(k, cos, sin)

 # 3. 如果使用 KV Cache，则与历史缓存进行维度拼接
 if past_kv is not None:
 past_k, past_v = past_kv
 k_all = torch.cat([past_k.to(k.dtype), k], dim=2)
 v_all = torch.cat([past_v.to(v.dtype), v], dim=2)
 else:
 k_all, v_all = k, v

 # 4. GQA：将 K, V 的头数广播扩展至与 Q 一致
 if self.num_kv_heads != self.num_heads:
 repeat = self.num_heads // self.num_kv_heads
 k_rep = k_all.repeat_interleave(repeat, dim=1)
 v_rep = v_all.repeat_interleave(repeat, dim=1)
 else:
 k_rep, v_rep = k_all, v_all

 # 5. 求解自回归掩码与 Padding 掩码偏差（attn_bias）的逻辑省略 ...
 attn_bias = None

 # 6. 调用 PyTorch 原生的 Flash Attention / 缩放点积注意力加速计算
 out = F.scaled_dot_product_attention(
 q, k_rep, v_rep,
 attn_mask=attn_bias,
 dropout_p=self.dropout if self.training else 0.0,
 is_causal=False, # 手动传入掩码时需关闭原生 causal 标志
 )

 # 6. 维度还原与输出投影
 out = out.transpose(1, 2).contiguous().view(bsz, seq_len, -1)
 out = self.o_proj(out)

 if use_cache:
 return out, (k_all, v_all)
 return out

然后我们需要新建 mlp.py 来实现带门控结构的前馈神经网络 SeekerMLP。这里我们选择使用表现更优的 SwiGLU（SiLU + Gate）激活机制。为了配合门控机制的矩阵乘法，网络中需要设置平行的 w_gate 和 w_up 两个上采样投影层，以及一个下采样投影层 w_down。同时为了保持参数量水平，中间隐藏层维度（intermediate_size）默认会按照隐藏层的 $\frac{8}{3}$ 比例进行缩放并向上取整到 64 的倍数，以获得硬件计算上的最佳内存对齐效率。下面是包含这一完整结构的代码实现：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


# seeker_omni/model/mlp.py
import torch
import torch.nn.functional as F
from torch import nn

def _round_up(x, multiple):
 # 向上取整到 multiple 的倍数，用于硬件显存对齐
 return ((x + multiple - 1) // multiple) * multiple

class SeekerMLP(nn.Module):
 def __init__(self, hidden_size, intermediate_size=None, dropout=0.0):
 super().__init__()
 # 如果未指定中间层维度，则默认缩放为 8/3 并对齐 64
 if intermediate_size is None:
 intermediate_size = int(hidden_size * 8 / 3)
 intermediate_size = _round_up(intermediate_size, 64)

 # SwiGLU 需要平行的 Gate 和 Up 两个上采样矩阵
 self.w_gate = nn.Linear(hidden_size, intermediate_size, bias=False)
 self.w_up = nn.Linear(hidden_size, intermediate_size, bias=False)
 self.w_down = nn.Linear(intermediate_size, hidden_size, bias=False)
 self.dropout = dropout

 def forward(self, x):
 # 将门控输出经过 SiLU 后与 Up 输出逐元素相乘
 x = F.silu(self.w_gate(x)) * self.w_up(x)
 x = self.w_down(x)
 return F.dropout(x, p=self.dropout, training=self.training)

3.5 组装统一的主干网络

文本词表嵌入机制、视觉投影机制以及 Transformer 解码块都准备就绪后，我们回到刚才创建的 lm.py 文件中，看看真正的早融合（Early Fusion）是如何在自回归主干流中发生的。在 SeekerOmniLM 类中继续补全前向传播方法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56


# seeker_omni/model/lm.py

class SeekerOmniLM(nn.Module):
 def __init__(self, cfg):
 super().__init__()
 self.cfg = cfg
 # ... 前文已初始化的特殊文本嵌入层等代码 (此处略)

 # 初始化模态投影层与门控
 self.img_proj = nn.Linear(cfg.image_feat_dim, cfg.hidden_size, bias=False)
 self.img_gate = nn.Parameter(torch.zeros(cfg.hidden_size))

 # 初始化旋转位置编码与自注意力解码块序列
 head_dim = cfg.hidden_size // cfg.num_heads
 self.rope = RotaryEmbedding(dim=head_dim, max_seq_len=cfg.max_seq_len, theta=cfg.rope_theta)
 self.blocks = nn.ModuleList([
 SeekerBlock(
 cfg.hidden_size,
 cfg.num_heads,
 cfg.num_kv_heads,
 dropout=cfg.dropout,
 intermediate_size=cfg.mlp_intermediate_size,
 ) for _ in range(cfg.num_layers)
 ])

 self.norm = RMSNorm(cfg.hidden_size)

 def forward(self, input_ids, image_feats=None, **kwargs):
 # 1. 文本 Token 化为词汇嵌入矩阵
 x = self._embed_tokens(input_ids)

 # 2. 模态特征注入: 使用 Projector 将视觉特征注入到指定的图像占位符位置
 x = self._inject_modality_tokens(x, input_ids=input_ids, image_feats=image_feats)
 x = self.drop(x)

 # 3. 准备 RoPE 旋转位置编码
 seq_len = int(input_ids.shape[1])
 cos, sin = self.rope.get_cos_sin(seq_len) # 省略对具体最大序列长度和精度的适配

 # 4. 逐层通过标准的 Transformer Decoder Blocks 进行自注意力推理
 present_kv = [] if use_cache else None

 for i, block in enumerate(self.blocks):
 if use_cache:
 pkv = past_kv[i] if past_kv is not None else None
 x, kv = block(x, cos=cos, sin=sin, attention_mask=attention_mask, past_kv=pkv, use_cache=True)
 present_kv.append(kv)
 else:
 x = block(x, cos=cos, sin=sin, attention_mask=attention_mask)

 # 5. 计算最后的输出与 LM Loss
 x = self.norm(x)
 logits = F.linear(x, self._lm_head_weight())

 # 返回带分布概率的 Logits 和更新后的 KV 缓存
 return SeekerOmniOutput(logits=logits, loss=loss, kv_cache=present_kv) # 封装为 dataclass，省略损失计算部分

现在一套完整的前向传播链路就初步搭建出来了。但对于一个大语言模型来说，光有 forward 计算特征和损失还不够，我们还必须为它编写一套能够自回归生成回答的推理循环机制。因为大模型生成文本是一个“逐字往外蹦”的过程，如果没有 KV Cache，模型每次生成一个新词都需要把前面成百上千个历史词元重新计算一遍注意力，这在计算量上很不划算。所以，我们在 lm.py 的最后，补全用于文本生成的 generate_text 方法。需要利用我们在前向传播中预留的 use_cache 开关与 past_kv 管道，实现 Prefill（预填充） + Decode（解码） 两阶段加速生成流。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62


# seeker_omni/model/lm.py

class SeekerOmniLM(nn.Module):
 # ...

 @torch.no_grad()
 def generate_text(self, input_ids, image_feats=None, max_new_tokens=64, eos_id=None, **kwargs):
 self.eval()
 out = input_ids
 prompt_len = out.shape[1]

 # ==========================================
 # 阶段一：Prefill (预填充阶段)
 # 一次性将完整的 Prompt 送入模型，提取并保存其 KV Cache
 # ==========================================
 # ... 省略 prefill_chunk_size 分块处理超长 Prompt 的支持逻辑
 out_prefill = self.forward(
 out,
 image_feats=image_feats,
 past_kv=None, # 第一步没有历史缓存
 use_cache=True,
 position_offset=0
 )

 # 提取出 Prompt 最后一个 Token 的预测 Logits，以及这一长串的 KV 缓存
 logits_prev = out_prefill.logits[:, -1, :]
 past_kv = out_prefill.kv_cache

 # ==========================================
 # 阶段二：Decode (解码阶段)
 # 拿着 Prefill 吐出来的最后一个 Token，逐字自回归生成
 # ==========================================
 # ... 省略针对控制占位符的禁止生成列表 (forbid_ids) 的构建逻辑

 for _ in range(max_new_tokens):
 # ... 省略 Repetition Penalty (重复惩罚) 与 No-Repeat N-Gram 过滤逻辑

 # 1. 采样：本例采用最简单的贪心解码 (Greedy Decoding) 取概率最大的词
 # ... 省略 Temperature, Top-P, Top-K 分布采样逻辑
 next_id = torch.argmax(logits_prev, dim=-1, keepdim=True)

 # 将新生成的词拼接到最终输出序列中
 out = torch.cat([out, next_id], dim=1)

 # 如果碰到了终止符 EOS，立刻提前退出生成循环
 if eos_id is not None and torch.all(next_id.squeeze(-1) == int(eos_id)):
 break

 # 2. 状态更新：带着上一步吐出的*单个新词*和*庞大的历史缓存*再次进入模型
 out_step = self.forward(
 next_id, # 注意！这里输入的长度只有 1
 image_feats=image_feats,
 past_kv=past_kv, # 将上一轮积累的缓存喂给当前层
 use_cache=True,
 position_offset=past_kv[0][0].shape[2] # 偏移量即为当前缓存的长度
 )

 # 更新缓存，为下一次循环做准备
 past_kv = out_step.kv_cache
 logits_prev = out_step.logits[:, -1, :]

 return out

至此，我们多模态的底层架构 lm.py 就实现闭环了。它不仅能接收图文混合排列的标记序列进行并行训练（forward），还能在推理阶段利用增量缓存成倍加速对话生成的响应速度（generate_text）。

3.6 封装训练循环

完成了所有的架构拼装之后，我们下一步要做的就是实现整体训练流程。不过，在开始写训练循环之前，还需要先在 seeker_omni 下新建一个 dataset 目录，来进行数据方面的一些处理。在预训练和普通指令微调阶段，为了最大化显卡的计算吞吐率，我们这套框架采用了全离线的数据处理策略。要求所有的文本都提前被切成 Token，还有图片也提前被视觉模型抽成特征，一起固化成底层的二进制文件（.bin）。所以，我们得编写一个 MemmapDataset，通过内存映射技术，让 GPU 在训练时能极其高效地将文本的 Token 序列和预先提取好的图像特征直接吸入显存。具体实现如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


# seeker_omni/dataset/memmap.py
import numpy as np

class MemmapDataset:
 def __init__(self, data_dir):
 # ... 读取元数据
 self._input_ids = np.memmap(data_dir / "input_ids.bin", dtype=np.int32, mode="c", shape=(n, s))
 self._labels = np.memmap(data_dir / "labels.bin", dtype=np.int32, mode="c", shape=(n, s))
 self._attn = np.memmap(data_dir / "attention_mask.bin", dtype=np.uint8, mode="c", shape=(n, s))
 self._image_feats = np.memmap(data_dir / "image_feats.bin", dtype=np.float16, mode="c", shape=...)

 def __getitem__(self, idx: int):
 import torch
 # 将磁盘映射数据零拷贝搬往 Tensor
 out = {
 "input_ids": torch.from_numpy(self._input_ids[idx]),
 "labels": torch.from_numpy(self._labels[idx]),
 "attention_mask": torch.from_numpy(self._attn[idx]),
 "image_feats": torch.from_numpy(self._image_feats[idx])
 }
 return out

打通了数据加载后，我们就可以继续在 seeker_omni 中新建一个专门用于存放训练模块的 train 文件夹。首先，我们先在该文件夹中创建 loop.py，它将包含驱动模型参数更新的 train() 大循环。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78


# seeker_omni/train/loop.py

# ... 前置的导包与辅助函数（代码细节已省略）：
# 1. _prepare_batch：负责将纯文本和图文 Batch 动态推入显存；若无填充词，机智抛弃注意力掩码以触发底层 Flash Attention 加速。
# 2. _corrupt_answer_tokens_for_mm：多模态强力去依赖机制；在监督对的答案开头强制注入 UNK 掩码，断刷语言模型的续写本能，逼迫其观察视觉特征。
# 3. _adamw_param_groups：精细化权重衰减控制器；不对视觉门控矩阵、词表和归一化层施加脆弱的 L2 正则约束。
# --------------------------------------------------------------------------

def train(cfg: ExperimentConfig) -> None:
 device = torch.device(cfg.train.device)
 dtype = torch.float16 if cfg.train.dtype == 'fp16' else torch.bfloat16

 # ... 环境变量与混合数据集对象读取逻辑省略 ...

 # 1. 实例化自回归语言模型，并强制应用多阶段冻结策略
 # 此步骤极为关键：例如在 s1 阶段它只会解冻 Projector 投影层，冻结其它一切参数
 model = SeekerOmniLM(cfg.model).to(device)
 apply_stage_freeze(model, cfg.train)

 # 2. 构造优化器与半精度损失梯度缩放器
 opt = torch.optim.AdamW(_adamw_param_groups(model, weight_decay=cfg.train.weight_decay), lr=cfg.train.lr)
 scaler = torch.amp.GradScaler(device.type, enabled=(device.type == 'cuda' and dtype == torch.float16))

 # 3. 正式开启工业级训练单步大循环
 while step < int(total_steps):
 step += 1

 # 4. 动态学习率调度
 lr = cosine_lr(step, base_lr=cfg.train.lr, total_steps=int(total_steps), warmup_steps=cfg.train.warmup_steps)
 for g in opt.param_groups:
 g['lr'] = lr

 # 2. 从多个数据集中按权重混采数据
 batch, src = next_mixed_batch()
 input_ids, labels, attention_mask, image_feats = _prepare_batch(batch, device=device)

 # 3. 多模态教师强制扰动：降低对“标准答案前缀”的依赖，逼迫模型看图
 if image_feats is not None:
 input_ids = _corrupt_answer_tokens_for_mm(
 input_ids, labels,
 unk_id=int(model.special.unk), n_special=int(model.n_special),
 )

 # 4. 混合精度（FP16/BF16）前向传播，狂省显存
 with torch.autocast(device_type=device.type, dtype=dtype):
 out = model(
 input_ids,
 attention_mask=attention_mask,
 labels=labels,
 image_feats=image_feats,
 )

 # 开启梯度累加（Gradient Accumulation），单次 Loss 除以累加步数
 loss = out.loss / cfg.train.grad_accum

 # 5. 反向传播与梯度缩放（防止半精度下溢）
 if scaler.is_enabled():
 scaler.scale(loss).backward()
 else:
 loss.backward()

 # 6. 当累加步数凑齐了 batch_size 倍数时，执行真更新
 if step % cfg.train.grad_accum == 0:
 if scaler.is_enabled():
 scaler.unscale_(opt)

 # 梯度裁剪：防止突发的坏数据导致梯度爆炸毁掉整个模型
 torch.nn.utils.clip_grad_norm_(params, cfg.train.grad_clip)

 # 更新权重并清零梯度
 if scaler.is_enabled():
 scaler.step(opt)
 scaler.update()
 else:
 opt.step()
 opt.zero_grad(set_to_none=True)

 # ... 后续的 TensorBoard 记录与保存断点逻辑省略 ...

可以看到，在 train() 里面我们调用了一个叫 apply_stage_freeze 的函数。多模态大模型的训练中，“什么时候该冻结什么参数” 甚至比“怎么写 Loss”还要重要。如果不加选择地将一个好不容易预训练聪明的 LLM 底座与一个随机初始化的视觉投影层一起放开训练，激烈的梯度更新会在第一个 Epoch 就摧毁大语言模型原有的文本能力（灾难性遗忘）。所以，我们需要在 seeker_omni/train/freezing.py 中编写一套实用的参数冰冻术。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


# seeker_omni/train/freezing.py
from ..config import TrainConfig
from ..model.lm import SeekerOmniLM

def apply_stage_freeze(model: SeekerOmniLM, train_cfg: TrainConfig) -> None:
 # 默认放开所有参数的梯度
 for p in model.parameters():
 p.requires_grad = True

 # 1. 冻结语言模型底座（对齐阶段的常规操作，只练 Projector）
 if train_cfg.freeze_backbone:
 for p in model.blocks.parameters():
 p.requires_grad = False
 for p in model.norm.parameters():
 p.requires_grad = False
 for p in model.base_embed.parameters():
 p.requires_grad = False

 # 即使冻结底座，也可以选择性地放开最后 N 层 Transformer 
 # 用于承担更深度的多模态特征融合
 unfreeze_last_n = int(train_cfg.unfreeze_last_n_layers or 0)
 if unfreeze_last_n > 0:
 n = min(unfreeze_last_n, len(model.blocks))
 for blk in model.blocks[-n:]:
 for p in blk.parameters():
 p.requires_grad = True
 for p in model.norm.parameters():
 p.requires_grad = True

 # 2. 独立冻结词表与特殊占位符
 if train_cfg.freeze_base_embed:
 for p in model.base_embed.parameters():
 p.requires_grad = False
 if train_cfg.freeze_special_embed:
 for p in model.special_embed.parameters():
 p.requires_grad = False

除了 freezing.py 和 loop.py，我们其实还需要 lr.py（学习率调度）、checkpoint.py（断点保存与加载）以及 seed.py（随机种子设置）。这些都是标准的深度学习工程化模板代码，这里就不再赘述。

拥有了这套单步训练引擎后，我们可以回过头来对“纯文本预训练 -> 指令微调 -> 多模态对齐”这三个训练阶段进行统一管理。为了将这些零散的阶段无缝串联起来，我们在 seeker_omni 中再新建一个用于总体编排的 steps 目录，并在其中编写最外层入口脚本 train.py。这个脚本将作为多阶段总控调度器，它的作用是读取一系列连贯的阶段配置文件，并将上一个阶段引擎跑出来的最终 Checkpoint 权重，自动喂给下一个阶段作为初始权重：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


# seeker_omni/steps/train.py
def run(cfg):
 cfg_paths = [str(x) for x in cfg["configs"]]
 prev_cfg = None

 # 循环遍历每一个训练阶段的配置文件
 for i, cfg_path in enumerate(cfg_paths):
 exp = ExperimentConfig.load(cfg_path)

 # ... （省略部分容错检查、第一阶段 init_from 处理以及日志打印代码）

 # 核心逻辑：自动去上一个阶段的输出目录里找最新的权重，作为本阶段起点
 if i > 0 and auto_init and prev_cfg is not None:
 prev_ckpt = latest_checkpoint(prev_cfg.train.out_dir)

 # 若本阶段未显式指定起点，则接力加载上一阶段的存档
 cur_init = exp.train.init_from
 if cur_init is None or not Path(cur_init).exists():
 exp = replace(exp, train=replace(exp.train, init_from=prev_ckpt))

 # 将最新的配置送入底层 loop.py 训练引擎开始单步训练
 # ... （省略 set_seed 等细节操作）
 train(exp)
 prev_cfg = exp

通过上述的 steps/train.py 调度器，我们已经顺利串联起了文本预训练和指令微调。到目前为止，整个工程里还缺少的最后一个阶段就是多模态对齐。但在正式开始编写这部分代码之前，我们不妨先把现有的基础工程跑通。为了实现一键启动，我们需要在核心包目录下创建一个总管线脚本：seeker_omni/pipeline.py，把前面写好的纯文本阶段都打包统筹起来。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


# seeker_omni/pipeline.py
import os
from pathlib import Path

from .config import load_yaml

def _project_root():
 return Path(__file__).resolve().parents[1]

def _read_yaml(path):
 p = Path(path)
 return load_yaml(p)

def train():
 from .steps.train import run as train_run

 os.chdir(_project_root())
 print("== pipeline: train ==")
 cfg = _read_yaml("configs/train.yaml")
 train_run(cfg)
 return 0

回到 seeker_omni/steps 文件夹下，我们新建一个 e2e 文件夹，继续实现最后的对齐流程。在实现这部分内容之前，我们同样还需要来到 seeker_omni/dataset 文件夹下，新建一个 schema.py 文件，用来处理在线的动态图文数据流解析。端到端联合对齐的第一大挑战就是数据加载方式的转变。在先前的 train 循环中，由于不用加载视觉模型，我们为了速度读取 memmap.py 喂的离线 .bin 数组。但在真正的端到端联合对齐阶段，模型需要自由调配图文混采比例，此时就必须抛弃固化的离线特征，转为从原始的 .jsonl 语料文件中逐行流式解析指令文本，并实时提取真实图片的本地路径：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


# seeker_omni/dataset/schema.py
import json
from pathlib import Path

class RawSample:
 def __init__(self, id, system, prompt, answer, image):
 self.id = id
 self.system = system
 self.prompt = prompt
 self.answer = answer
 self.image = image

def iter_jsonl(path):
 p = Path(path)
 with p.open("r", encoding="utf-8-sig") as f:
 for line_no, line in enumerate(f, start=1):
 line = line.strip()
 if not line:
 continue
 try:
 obj = json.loads(line)
 except json.JSONDecodeError as e:
 raise ValueError(f"invalid json at line {line_no}: {p}") from e

 yield RawSample(
 id=str(obj.get("id", f"line-{line_no}")),
 system=obj.get("system"),
 prompt=str(obj.get("prompt", "")),
 answer=str(obj.get("answer", "")),
 image=obj.get("image"),
 )

补齐数据处理后，我们就可以将目光切回刚才新建的 steps/e2e 文件夹，来实现最终的对齐脚本 runner.py。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


# seeker_omni/steps/e2e/runner.py
import torch
# ... (省略引包和 Dataset 初始化的逻辑) ...

def run_from_yaml_config(cfg):
 # 1. 恢复我们在上一阶段微调好的 LLM 主模型
 model = SeekerOmniLM(cfg.model).to(device)
 # ... 

 # 2. 加载 SigLIP 视觉模型
 from transformers import SiglipVisionModel
 vision = SiglipVisionModel.from_pretrained(args.vision_model).to(device)

接下来我们就要处理端到端的对齐，为了在不毁灭视觉模型原有认知的情况下解锁深层能力，不能靠无脑的全局梯度更新。我们需要依赖两项精细的手术，分别是局部解冻（只放开最后几层）和特征蒸馏（用原版模型约束行为）。我们 runner.py 的同级目录下新建两个扩展组件 vision.py 用于负责从本地加载原始 RGB 图片，并提供一个函数用来冻结视觉模型绝大多数的层，仅放开最后 $N$ 层：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


# seeker_omni/steps/e2e/vision.py
import torch
import torch.nn.functional as F
from PIL import Image

def load_rgb(path):
 img = Image.open(path)
 if img.mode in ("RGBA", "LA"):
 img = img.convert("RGB")
 return img

def pool_tokens_torch(x, *, target_tokens):
 # [B, T, D] -> [B, target, D] 池化压缩视觉 Token
 if int(x.shape[1]) == int(target_tokens):
 return x
 t = x.transpose(1, 2)
 return F.adaptive_avg_pool1d(t, int(target_tokens)).transpose(1, 2)

def freeze_vision_all_but_last_n(vision, *, last_n):
 for p in vision.parameters():
 p.requires_grad = False

 n = int(last_n)
 if n <= 0:
 return

 # 仅解冻最后 n 层 Transformer 块的参数
 vm = getattr(vision, "vision_model", vision)
 layers = getattr(vm.encoder, "layers", None)
 for layer in list(layers)[-n:]:
 for p in layer.parameters():
 p.requires_grad = True

 # 别忘了还有最后的 LayerNorm 层
 pln = getattr(vm, "post_layernorm", None)
 if pln is not None:
 for p in pln.parameters():
 p.requires_grad = True

紧接着，为了防止这刚解冻就被卷入剧烈更新的最后 $N$ 层彻底“放飞自我”、遗忘掉原本优秀的特征提取能力，我们再新建一个 distill.py 脚本文件。它利用最简单的 MSE 均方误差，计算正在训练的学生视觉特征与一个被完全冻死在原始状态的老师视觉特征之间的差距，作为正则化惩罚项：

1
2
3
4
5
6


# seeker_omni/steps/e2e/distill.py
import torch
import torch.nn.functional as F

def mse_distill(student_hidden, teacher_hidden):
 return F.mse_loss(student_hidden.float(), teacher_hidden.float())

完成这两个组件的编写之后，我们切回 runner.py 接着往下写：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


# seeker_omni/steps/e2e/runner.py
from transformers import SiglipVisionModel

def run_from_yaml_config(cfg):
 # ... (省略 LLM 与主视觉模型加载代码) ...

 # 实例化主视觉编码器，并动态解冻最后 N 层
 vision = SiglipVisionModel.from_pretrained(args.vision_model).to(device)
 if int(args.vision_train_last_n) > 0:
 freeze_vision_all_but_last_n(vision, last_n=int(args.vision_train_last_n))

 # 引入处于完全冻结状态的教师视觉模型
 teacher_vision = None
 if float(args.vision_distill_weight) > 0.0 and (not bool(args.freeze_vision)):
 teacher_vision = SiglipVisionModel.from_pretrained(args.vision_model).to(device)
 teacher_vision.eval()
 for p in teacher_vision.parameters():
 p.requires_grad = False

 # ... (省略进入核心的大循环逻辑) ...
 # ... 以下为在训练大循环 (Train Loop) 中计算蒸馏损失的部分：

 if has_image:
 vout = vision(pixel_values=px)
 hs = vout.last_hidden_state

 # 与教师模型的输出特征进行 MSE 蒸馏，防止视觉特征遗忘
 if teacher_vision is not None:
 with torch.no_grad():
 tout = teacher_vision(pixel_values=px)
 ths = tout.last_hidden_state
 distill_loss = mse_distill(hs, ths)

在上述端到端的实现中，通过 freeze_vision_all_but_last_n 解冻视觉网络最后的数层计算图，使得视觉编码器能够直接接收来自大语言模型的梯度回传。同时，为了防止解冻后的视觉网络在语言梯度的更新中“遗忘”原本优秀的识图能力，代码中引入了一个完全冻结的同构 teacher_vision 模型。在每步的前向传播中，都会计算当前解冻视觉层与教师模型输出特征之间的均方误差，将其作为蒸馏损失加入到总 Loss 中，以此在联合演化的同时保住视觉模型的性能底线。 runner.py 完成后，我们回到 seeker_omni/pipeline.py，把最后对齐阶段的调用给组装上，并写一个 run_all() 把整个流程串起来：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


# seeker_omni/pipeline.py

import os
from pathlib import Path

# ... (省略 _read_yaml, _project_root 等帮助函数) ...

def train():
 # ... (省略上文已实现的纯文本阶段管线)
 pass

def e2e():
 from .steps.e2e.runner import run_from_yaml_config

 os.chdir(_project_root())
 print("== pipeline: e2e ==")
 cfg = _read_yaml("configs/e2e.yaml")
 run_from_yaml_config(cfg)
 return 0

def run_all():
 train()
 e2e()
 return 0

那么现在全部的核心内容我们就写完了。接下来，只需要在相关模块里补齐工程化的封装收口（例如通过 __init__.py 暴露对外 API、在 __main__.py 中提供 python -m ... 的启动入口，并将训练阶段的参数收拢到 config.py / YAML 等配置文件中统一管理），就可以使用 uv run python -m seeker_omni 命令将整套训练跑起来了。

图文多模态之原生统一架构

Fri, 27 Mar 2026 22:40:25 -0800

图文多模态之原生统一架构

上节我们介绍了以 BLIP-2 和 LLaVA 为代表的“连接”方法。这类方法通过轻量级适配模块连接冻结的视觉编码器与 大语言模型，虽极大降低了训练成本，但底层模态的分离和输入端的生硬拼接限制了其在实时音频/视频交互等场景下的表现。为了突破这些局限，学术界与工业界正加速向原生统一的架构演进。

一、迈向统一的探索

1.1 Flamingo 架构设计

DeepMind 在 2022 年提出的 Flamingo ¹ 虽然在时间上早于 BLIP-2，但在多模态的大一统进程中占据了独特的生态位。不同于 BLIP-2 和 LLaVA 追求的“利用现有组件高效连接”，Flamingo 探索的是大规模图文交错序列（Interleaved Image-Text）的学习极限。在架构演进的视角下，它事实上构成了从“简单连接”向“原生统一”进化的关键过渡形态。其核心架构目标是桥接强大的预训练视觉模型和大型语言模型（LLM），在保留它们各自预训练知识的同时，成功实现了在极少样本情况下对**任意交错（Interleaved）**图像和文本序列的处理能力。为了实现这一目标，Flamingo 采用了如图 20-7 所示的架构。

图 20-7 Flamingo 架构

可以看到图中的图像数据会先通过左侧的视觉路径进行视觉编码（Vision Encoder）和重采样（Perceiver Resampler），生成固定长度的视觉特征。接着，这些特征被注入到右侧的语言路径中，通过插入在 LLM 层间的门控交叉注意力接口（Gated XATTN-DENSE）参与文本生成。为了支撑这一跨模态流转过程，Flamingo 设计了以下三个关键组件：

（1）视觉感知与特征重采样

Flamingo 使用 NFNet-F6 作为冻结的视觉编码器，提取图像或视频的特征。由于视觉输入的分辨率和视频帧数可能不同，导致特征图的大小和数量也是变化的。为了将这些变长的视觉特征统一为固定长度的输入，Flamingo 引入了 Perceiver Resampler 模块。该模块预定义了一组固定数量的可学习的潜在查询向量（Latent Queries），通过 Cross-Attention 机制与视觉特征交互，最终输出固定数量的视觉 Token（论文中为 64 个）。这种设计不仅显著降低了视觉-文本 Cross-Attention 的计算开销，也通过“压缩视觉 token 数量”的方式在实践中缓解了 Transformer 随序列长度增长带来的 $O(N^2)$ 计算/显存压力（严格来说并非“消除” $O(N^2)$，而是让 $N$ 不至于被视觉 token 拉得过大）。结合图 20-8 所示，Perceiver Resampler 会先将 Vision Encoder 输出的变长视觉特征（$X_f$）展平。对于视频输入，Flamingo 会在展平前为每一帧特征加入可学习的时间嵌入；同时作者也明确指出未显式加入空间网格位置编码（空间信息更多由 CNN 特征隐式携带）。这里的 Key 和 Value 在论文的示意与伪代码中可以由时空视觉特征 $X_f$ 与 learned latent vectors 拼接而成。也就意味着 Latent Queries 在通过 Attention 机制“查询”视觉信息时，不仅关注图像特征，也在“参考”自身的当前状态，继而保持了特征提取的连贯性。随后，这些 Latent Queries 主动去“查询”视觉特征中包含的关键信息，无论输入视觉特征序列有多长（单图或多帧视频），最终都只输出与 Latent Queries 数量一致的定长视觉 Token。通过这种机制，海量的视觉数据被高效地压缩成了少量的定长 Token 序列，供后续 LLM 使用。

图 20-8 Perceiver Resampler 机制

（2）视觉信息注入与门控机制

为了将视觉信息有效注入预训练且冻结的语言模型（Chinchilla）中，Flamingo 在其层间插入了 GATED XATTN-DENSE 模块。如图 20-9 所示，该模块以语言特征（Language input）作为 Query，以 Perceiver Resampler 输出的视觉特征（Vision input）作为 Key 和 Value，通过交叉注意力机制让语言模型主动从视觉序列中提取相关信息。为了维持冻结 LLM 原有的语言能力，Cross-Attention 和随后的 FFW 层均配置了 tanh 门控机制（tanh gating），这些门控参数在初始化时设为 0，确保模型在训练初期表现为纯语言模型，避免了视觉噪声冲击导致的训练不稳定。随着训练的进行，门控值逐渐增大，视觉信息以残差连接的方式“平滑”地融入语言特征流中。这种设计不仅防止了灾难性遗忘，还让模型能够通过交错的 Self-Attention 和 Cross-Attention 层，在保持语言逻辑的同时实现深度的多模态对齐。

图 20-9 Gated Cross-Attention

（3）多图支持与掩码策略

为了支持任意数量的图像/视频输入，Flamingo 在 Masked Cross-Attention 层采用了特殊的分段掩码策略。如图 20-10 所示，这种策略实施了严格的局部关注，即每个文本 Token 仅被允许关注其直接前导的那一张图像（由指示函数 $\phi$ 决定），而不是所有历史图像。例如，图中标记为 1 的文本段只能看到 Image 1，而无法看到 Image 2 或其他图像。具体而言，图中亮蓝色区域代表允许文本 Token 关注的视觉特征，而深色区域则代表被屏蔽的部分。这种设计限制了单次交叉注意力的计算复杂度，防止模型被无关图像干扰。虽然 Cross-Attention 层只关注局部，但跨图像的长程依赖被交给底层的 LM Self-Attention，通过文本 Token 作为中介，间接实现了多图信息的融合。基于这一机制，Flamingo 能够高效处理包含多达 32 对图文的 Few-Shot Prompt，展示了强大的上下文学习能力。

图 20-10 多模态掩码注意力

1.2 局限性与思考

Flamingo 强大的少样本能力很大程度上归功于它的训练数据。DeepMind 构建了 M3W (Multi-Modal Massive Web) 数据集，包含从 4300 万个网页中提取的图文交错序列（如：文本-图像-文本）。这种结构模拟了人类浏览网页的真实体验，使模型学会了根据上下文预测下一个 Token。而且，为了兼顾通用的视觉识别能力，Flamingo 还混合使用了传统的强对齐图文对数据集（ALIGN, LTIP）和视频文本对数据集（VTP），并通过加权损失函数进行联合训练。然而，Flamingo 仍然存在一些局限性。例如，相较于直接优化图文检索任务的 Contrastive 模型（如 CLIP），Flamingo 在单纯的图像分类任务表现稍逊，这可能源于其生成式目标的特性。同时，作为建立在 LLM 基础上的模型，Flamingo 继承了 LLM 的缺点，偶尔会产生幻觉或做出无根据的猜测。最关键的是，受限于当时的技术背景，Flamingo 依然保留了“冻结视觉编码器”这一连接范式的特征。虽然这种依赖冻结编码器的设计有助于保留预训练模型的通用能力，但也导致视觉和语言在底层特征空间上无法真正融合，细腻的视觉感知能力（如 OCR、细粒度识别）容易在层层传递中丢失。

二、Token 级统一与单一网络

为了彻底打破上述局限，Chameleon ² 和 GPT-4o ³ 等模型开启了纯粹的原生时代。严格意义上的“纯粹原生”指模型不再是“拼凑”出来的，它从一开始就将所有模态视为地位平等的“语言”，在同一个大模型中进行混合模态的端到端预训练。就像人类婴儿并非先学会“看”再学会“说”，而是在成长的过程中同时通过视觉、听觉和语言来感知世界一样，原生多模态模型试图模拟这种过程。在架构方面，模型彻底摒弃了独立的模态编码器，并将像素、波形和文本一视同仁地映射为 Token 或底层特征，直接送入同一个“大脑”（单一大模型网络）进行处理。

2.1 Chameleon 与统一词表

Meta AI 推出的 Chameleon 是“早期融合（Early-Fusion）”架构的典型代表。虽然在架构上进行了彻底的重构（不再依赖外挂的视觉编码器），但从数据层面来看，Chameleon 完美继承并发展了 Flamingo 最宝贵的遗产，也就是基于大规模“图文交错”数据的训练范式。它的理念非常激进，主张把一切都视为 Token。为了实践这一目标，Chameleon 在架构设计上进行了以下三个层面的创新：

（1）统一词表与离散化

Chameleon 使用一个名为 Gafni 的图像分词器将 $512 \times 512$ 的图像量化为 1024 个离散的 Image Tokens。这些视觉 Token 与文本 Token 并没有本质区别，它们共同组成了一个大小为 65,536 的统一词表（包含了 8192 个图像 Codebook Token）。这意味着在模型眼中，像素和文字都是来自同一个字典的“单词”。

（2）混合序列与端到端架构

在处理输入时，Chameleon 将图像 Token 和文本 Token 按照逻辑顺序拼接成一个混合模态序列（Mixed-Modal Sequence）。整个序列直接输入到一个统一的 Transformer 架构中。无论是理解还是生成，本质上都转化为了自回归的下一 Token 预测任务。这种架构极大地简化了流程，不再依赖外挂的视觉编码器或复杂的跨模态对齐模块。如图 20-11 所示，通过图像分词器（Image Tokenizer），图像被转化为与文本（绿色）地位平等的蓝色 Token，并在**边界符（Start/End Image）**的辅助下混合编排，真正实现了端到端的全原生多模态理解与生成。

图 20-11 Chameleon 混合模态序列

（3）攻克训练稳定性挑战

“从头开始”训练这样一个混合模态大模型面临着巨大的优化稳定性挑战（如模态间的竞争导致的 Logit 漂移）。为此，Chameleon 引入了一系列架构创新，包括 QK-Norm (Query-Key Normalization) 和特殊的层归一化布局。这些改进确保了模型能够在没有预训练视觉编码器“保底”的情况下，稳定地学习到跨模态的复杂依赖关系。图 20-12 通过三组实验揭示了稳定性问题的本质与解决方案。图 (a) 展示了在应用优化策略后，7B 和 34B 模型均能在混合模态数据上稳定收敛。图 (b) 则通过对比实验指出，图像生成任务（Image Generation）是导致不稳定的根源——当禁用图像生成时，Loss 曲线非常平滑，未出现发散。图 (c) 进一步验证了架构调整的有效性，单纯引入 Dropout 并不能解决发散问题（橙色曲线依然发散），而层归一化重排（Norm Reordering） 才是实现稳定训练的关键（蓝色曲线）。

图 20-12 Chameleon 训练稳定性实验

通过表 20-1 可以清楚地看到，Chameleon 7B 和 34B 在架构参数上与 LLaMa-2 总体保持一致（如 Context Length 和 GQA），但为了适应混合模态训练，其在优化策略上做出了明显调整，重点包括引入 Z-loss 和 QK-Norm，并将训练数据量提升到了 4.4T Token（约为 LLaMa-2 的两倍）。这种原生统一架构实现了真正的全模态理解与生成。模型可以在任意层级、任意位置进行模态间的推理，展现出惊人的上下文学习能力。然而，这种“原生”也是昂贵的。Chameleon 需要在包含约 10 万亿（10T） token 的混合数据上进行大规模预训练，且训练过程对超参数极度敏感。

Model	Params	Context	GQA	Tokens	LR	Epochs	Dropout	Z-loss	QK-Norm
LLaMA-1	7B	2k	x	1.0T	3.0e-4	1.0	0.0	0.0	x
LLaMA-1	33B	2k	x	1.4T	1.5e-4	1.0	0.0	0.0	x
LLaMA-2	7B	4k	x	2.0T	3.0e-4	1.0	0.0	0.0	x
LLaMA-2	34B	4k	✓	2.0T	1.5e-4	1.0	0.0	0.0	x
Chameleon	7B	4k	x	4.4T	1.0e-4	2.1	0.1	1e-5	✓
Chameleon	34B	4k	✓	4.4T	1.0e-4	2.1	0.0	1e-5	✓

表 20-1 Chameleon 架构参数与优化配置对比

2.2 GPT-4o 与全模态原生

在图文统一的基础上，GPT-4o (“o” 代表 Omni) 进一步打破了音频的边界，成为了纯粹原生全模态模型的标杆。根据 OpenAI 的公开介绍，在 GPT-4o 之前，语音模式是由三个独立模型组成的级联系统（ASR 转文本 -> LLM 处理文本 -> TTS 转语音）。对于 GPT-4o，OpenAI 跨文本、视觉和音频端到端地训练了一个单一的新模型，也就意味着所有的输入和输出都由同一个神经网络处理。这种纯粹的原生架构使 GPT-4o 能够直接感知语气、多个说话者、背景噪音，并输出带有情感的语音，在语音对话中甚至能达到最短约 232ms的响应延迟。

三、走向全能：端到端 Omni 系统的工业实践

虽然 Chameleon 和 GPT-4o 定义了“纯粹原生”的最终形态（单一网络、彻底的 Token 统一），但从头训练的成本极为高昂。在真实的工业界和开源社区中，更常见也更容易规模化落地的一条路线，是走向端到端紧耦合（End-to-End Tightly-Coupled）的 Omni 系统。这类系统（如 Qwen3-Omni ⁴ 和 MiniCPM-o 4.5 ⁵）严格来说不属于单一网络的原生架构，因为它们依然保留了专门的音频或视觉编码器。但它们打破了早期“冻结外挂”的连接范式，通过全参数解冻的端到端联合训练、深度的隐藏态耦合以及高速的流式架构，在体验上无限逼近了 GPT-4o 的实时语音交互。

3.1 解耦架构与流式生成

虽然 GPT-4o 的闭源策略让我们难以窥探其单一网络的内部细节，但 Qwen3-Omni 为这种“全能体验”的工业落地给出了可复现的系统级拆解。它不仅在文本和视觉任务上保持了与同系列单模态模型相当的性能，也在实时音频交互上展现了很高的工程水准。

（1）通用的听觉底座

不同于以往多模态模型常依赖 Whisper 等现成且冻结的 ASR 模型，Qwen3-Omni 采用了一个拥有约 6 亿参数的从头训练的 AuT（Audio Transformer） 音频编码器。如图 20-13 所示，AuT 采用了 Transformer 架构，包含 32 层 Encoder 和 8 层 Decoder。并在 2000 万小时的监督音频数据上进行了预训练，使它不仅能处理语音，还能理解环境音和音乐。在特征提取阶段，AuT 通过 3 层下采样卷积 将输入音频（10ms 帧移的 FBank 特征）在时间维度上压缩 8 倍，将特征采样率大幅降低至 12.5Hz（即每 80ms 一个 Token），实现了高效表征。同时，AuT 在 32 层 Encoder 中还引入了 分块窗口注意力 (Block-wise Window Attention) 机制，支持动态窗口大小，使得模型在实时流式输入时能高效地进行 Prefill（预填充），而无需等待整个音频片段。

图 20-13 Audio Transformer (AuT) 架构概览

（2）Thinker-Talker 混合专家架构与极致流式

Qwen3-Omni 采用了独特的 Thinker-Talker 双模型协作架构，并均升级为 MoE 以应对高并发需求。为了达成 234ms 的端到端延迟，这套架构结合了深度解耦与极速流式设计。主要分成 Thinker（思考者）和 Talker（表达者）两部分。其中，Thinker 是一个强大的多模态 MoE 模型，它主要负责“脑力”工作，也就是理解来自 AuT 的音频流、视觉编码器的视频流以及文本输入，进行深度推理，并生成文本回复或推理结果；Talker 则是一个专门的流式语音生成 MoE 模型，它不再直接消费 Thinker 的高层文本表征/文本 Token，而是接收 Thinker 输出的多模态高维表征，并共享对话历史。这种解耦设计赋予了 Talker 更高的灵活性，使它能专注于对齐语音的韵律、情感和语速，不必受制于语言模型的逐词生成节奏，各模块的具体参数配置如表 20-2 所示。

Module	Architecture	Params	Streaming
Audio Encoder	AuT	650M	✓
Vision Encoder	SigLIP2-So400M	540M	-
Thinker	MoE Transformer	30B-A3B	✓
Talker	MoE Transformer	3B-A0.3B	✓
MTP	Dense Transformer	80M	✓
Code2wav	ConvNet	200M	✓
First-Packet Latency	End-to-End	234/547ms (Audio/Video, cold start theoretical)	-

表 20-2 Qwen3-Omni 30B-A3B 架构参数与延迟概览

各组件的协同工作，实现了极其高效的端到端生成。如图 20-14 所示，为了实现极致流式，Thinker 模型首先处理多模态输入，生成高层语义表征；而后 Talker 接收这些表征并自回归地预测第 0 层（主）Codebook；紧接着，轻量级的 MTP 模块会快速预测同一帧中其余残差 Codebook。最后，所有层级的 Codebook 被送入 流式 Codec 解码器 (Streaming Codec Decoder)，逐帧流式地合成出波形。这一流程确保了模型不需要等待完整的句子甚至完整的词生成完毕，只要第一个 codec token 产生，声音就能立即被“流”出来。

图 20-14 Qwen3-Omni 架构概览

（3）三阶段训练策略

为了实现上述能力，Qwen3-Omni 还经历了三个关键的预训练阶段。在编码器对齐（Encoder Alignment）阶段，模型冻结 LLM，专注于训练 AuT 和视觉编码器的适配器，使其对齐到语言空间。进入通用预训练阶段后，全参数解冻，在包含 2 万亿 Token 的大规模多模态数据（文本、图像、音频、视频）上进行混合训练。而在**长上下文扩展（Long Context Stage）**阶段，序列长度被扩展至 32k，重点增强模型对长视频和长音频的理解能力。这一系列复杂的联合优化与流式调度证明，通过精巧的系统设计，模型完全可以在复用现成模块的同时，打破延迟瓶颈，兼顾强大的推理能力与毫秒级的交互响应。

3.2 全双工与端侧延伸

在 Omni 系统领域，除了追求模型体量和极致的理解能力，系统级的实时流式交互（全双工，Full-Duplex）和端侧部署成为了另一个重要的演进方向，开源社区的 MiniCPM-o 4.5 正是这一趋势的代表。以往的语音助手多采用“半双工”（你听我说，我说你听）或简单的打断机制，而 MiniCPM-o 4.5 实现了真正的“边听边想边说”。它能够在接收实时视频和音频输入流的同时，不阻塞地并行输出文本和语音流。得益于它底层将多模态数据流（并行输入/输出）在毫秒级时间轴上进行了精密的对齐与同步处理，使模型能在任意时刻主动决定是否发声，实现自然的“主动插话”和“响应打断”。如图 20-15 所示，模型会在 LLM 输出序列中插入 [silent] 占位 Token 以维持流式节拍，并将生成的 Token 与隐藏态 $h$ 一并送入语音 Token 解码器，产生 25Hz 的 speech tokens，由此在统一时间轴上对齐输入与输出，完成复杂的全双工调度。

图 20-15 MiniCPM-o 4.5 全双工流式对齐机制

尽管 MiniCPM-o 4.5 整合了视觉（SigLIP2）、听觉（Whisper-medium）、语音合成（CosyVoice2）以及大语言模型（Qwen3-8B），但这套架构被端到端地深度融合在了一起，整体参数量控制在 9B 左右。配合高效的模型量化（如 Int4 仅需 11GB 显存）和专属推理框架，它甚至能够在普通的个人电脑乃至手机上流畅运行全双工的音视频对话。这种在有限算力下逼近 GPT-4o 级别实时体验的设计，展现了端到端紧耦合架构在工程落地上的巨大潜力。

参考文献

图文多模态之BLIP-2 与 LLaVA

Fri, 27 Mar 2026 21:40:25 -0800

图文多模态之BLIP-2 与 LLaVA

一、从对齐到生成

1.1 如何高效构建多模态生成能力？

CLIP 通过对比学习让图像和文本在特征空间实现了对齐，但这仅仅完成了“理解”的第一步。作为典型的双塔判别式模型，CLIP 更擅长做“给定候选文本算相似度”的检索/分类式判断，而不是自由形式的文本生成；所以它不能像语言模型那样，直接对“画里有什么？”这类开放式问题给出自然语言答案。为了突破这一局限，我们需要赋予模型“开口说话”的能力，在强大的语义基础之上构建生成能力。为此，DeepMind 的 Flamingo ¹ 等先驱尝试了在冻结的视觉编码器与语言模型之间插入跨注意力等新模块，并在海量交错图文数据上训练这些新增模块以实现强大的生成与对话能力。虽然效果惊艳，但数据与训练成本并非普通实验室所能承受。

那不妨换个思路，既然我们手头已经有了“视觉地基”（ViT）和“语言大脑”（LLM），能不能只训练一个轻量级的“适配器”把它们连起来呢？Salesforce 提出的 BLIP-2 ² 正是这一思路的杰出代表。它采用 Bootstrapping（引导）策略，利用冻结的预训练图像编码器和 LLM，以极低的计算成本实现了强大的多模态能力（例如，论文报告其在 VQAv2 零样本 test-dev 上相对 Flamingo-80B 高出 8.7 个百分点，同时使用 54× 更少的可训练参数）。这个“四两拨千斤”效果的关键在于它设计了轻量级的 Q-Former，作为一个信息瓶颈，从视觉特征中“萃取”出最关键的信息并“翻译”给 LLM。如图 20-1 所示，整个模型的训练如同在搭建积木，左侧是冻结的图像编码器负责“看”，右侧是冻结的 LLM 负责“说”，我们主要训练中间这个轻量级的 Q-Former（以及后续对接 LLM 的小映射层）来进行高效的“传译”。

图 20-1 BLIP-2 总体架构

1.2 Q-Former 与两阶段预训练

在原论文中，Q-Former（Querying Transformer）是一个初始化自 BERT-base 的轻量级 Transformer 模块（仅 188M 参数），核心目标是连接冻结的视觉与语言模型。如图 20-2，Q-Former 内部包含两个共享 Self-Attention 层的子模块。左侧路径（论文中称为 Image Transformer）接收一组固定数量的可学习查询向量 (Learnable Queries)（文中设定为 32 个）作为输入，通过每一层的 Cross-Attention 机制与冻结的图像编码器输出交互，从海量的视觉特征中“萃取”出最精华的视觉信息；右侧路径（论文中称为 Text Transformer）则作为文本编码器或解码器处理文本输入。这种双塔共享权重的设计，让 Queries 既能通过 Cross-Attention 学习视觉特征，又能通过共享的 Self-Attention 与文本特征进行交互。由于 32 个 Query 的数量远小于原始图像特征的空间尺寸，这种设计强制模型进行高强度的信息压缩，构成了所谓的“信息瓶颈”，确保传递给 LLM 的都是经过筛选的、与文本最相关的有效信息。

图 20-2 Q-Former 详细架构

为了确保 Q-Former 既能理解图像，又能对接到 LLM，BLIP-2 采用了两阶段预训练策略。

（1）视觉-语言表征学习

在此阶段，图像编码器被冻结。为了让那一组可学习查询向量能够提取出既包含视觉信息又与文本对齐的特征，Q-Former 设计了三种预训练目标，并利用特定的 Attention Mask 策略在同一个架构中同时优化它们。如图 20-3 所示，首先是图文匹配 (ITM)，利用 Bi-directional Mask，允许 Query 和 Text 互相完全可见，学习细粒度的图文对齐；中间是图文生成 (ITG)，使用 Multimodal Causal Mask，这里 Query 可以相互注意但看不见 Text，而 Text 可以看见所有的 Query 和之前的 Text，用于引导基于图像的文本生成；最后是图文对比学习 (ITC)，使用 Uni-modal Mask，让 Query 和 Text 互不可见，专注于对齐整体的视觉和语言表征。这三种策略的结合，确保了 Q-Former 输出的 Query Embeddings 包含了最精华的视觉语义信息。

图 20-3 第一阶段预训练目标 (a) ITM, (b) ITG, (c) ITC

Mask 图解说明：每个方形矩阵代表 Transformer 的注意力掩码（Attention Mask），横纵坐标分别对应 Query 和 Text 的 Token。矩阵被分为四个象限，左上是 Query 对自身的注意力（Q-Q），右下是 Text 对自身的注意力（T-T），右上和左下则是 Query 与 Text 之间的交叉注意力（Q-T 和 T-Q）。空白区域表示“可见”（unmasked），深色区域表示“不可见”（Masked）。例如在 ITC 任务中，我们希望 Query 和 Text 互不可见，对应的右上和左下象限就是深色的。

（2）视觉-语言生成学习

这一阶段，LLM 也被冻结。为了将 Q-Former 提取的视觉特征注入到 LLM 中，BLIP-2 引入了一个全连接层（Fully Connected）将 Query Embeddings（$Z$）线性映射到 LLM 的文本 Embedding 维度。这些映射后的向量充当了“软视觉提示”，直接拼接在文本 Embedding 之前。如图 20-4 所示，具体对接策略取决于 LLM 的架构。若对接 Decoder-based LLM（图 20-4 上半部分，如 OPT），Q-Former 的输出作为前缀，由于 Decoder 是单向注意力的，它能看见视觉 Prompt 并据此生成后续文本；若对接 Encoder-Decoder-based LLM（图 20-4 下半部分，如 Flan-T5），Q-Former 的输出与文本前缀拼接后输入到 Encoder 中，Decoder 则负责根据 Encoder 的跨模态表示生成后缀文本。这种设计通过“软提示”机制，巧妙地复用了 LLM 强大的语言生成能力。

图 20-4 BLIP-2 第二阶段预训练：对接 Decoder-based 或 Encoder-Decoder-based LLM

通过这种方式，BLIP-2 成功地用极小的代价（主要训练 Q-Former，以及将其输出映射到 LLM 词向量空间的全连接映射层）就将视觉感知能力“嫁接”到了大语言模型上。

二、LLaVA 与视觉指令微调

2.1 视觉指令微调的必要性

虽然 BLIP-2 成功地将视觉编码器和 LLM 连接了起来，并且在论文中已经展示了通过提示词进行零样本的指令式图像到文本生成，但它的预训练目标核心仍围绕“模态对齐”与“图像条件生成”。在实际“助手式”交互场景中，这通常表现为模型可以生成，但对复杂指令的稳定遵循、多轮对话格式、以及更贴近人类偏好的回答风格，并没有被系统性地对齐与强化（尤其缺少专门的视觉指令对话数据来做端到端的指令微调）。所以，BLIP-2 更像是“能看懂、也能说”的通用接口原型，而距离像 ChatGPT 一样可对话、可推理、强指令遵循的视觉助手仍有差距。

LLaVA (Large Language and Vision Assistant) ³ 的出现正是为了解决这一问题。它引入了 视觉指令微调，目标是将多模态模型从“看图说话”的工具升级为通用的“智能视觉助手”。正如 NLP 领域从 GPT-3 到 ChatGPT 的进化离不开指令微调，多模态模型也需要通过高质量的视觉指令数据来学习如何遵循人类意图。LLaVA 不仅提出了一个简单的架构，更重要的是提出了一种低成本构建这些数据的方法。

2.2 数据构建

LLaVA 团队（2023年4月）发现，当时虽然缺乏图像-指令对数据，但有丰富的图像-文本对数据（如 COCO），于是他们利用 GPT-4 作为“老师”，采用上下文学习的方式，将图像的符号化表示（多视角图像描述与 COCO 等数据集中现成的目标边界框/类别标注）以及少量人工设计的种子样例喂给 GPT-4，从而生成了总计 158K 条高质量的指令数据。这批数据包含 58K 条模拟人与助手日常交互的对话数据；包含 23K 条要求对图片各个方面进行详尽刻画的详细描述数据；此外还有 77K 条复杂推理数据，这类数据会提出需要基于图片内容进行更深层逻辑推理的问题，并要求给出相对清晰的推理过程。

图 20-5 就是一个具体的生成实例。注意 GPT-4 并没有通过视觉编码器“看”到原始图片，而是根据输入的“Context type 1: Captions”提供的语义描述（如“一群人站在黑色车旁”、“SUV 在地下车库”）以及“Context type 2: Boxes”提供的精确定位信息（如“person: [坐标]”、“suitcase: [坐标]”），在脑海中“脑补”出了完整的场景。基于这些符号化信息，GPT-4 生成了下方的“Response type 1: Conversation”关于车型和地点的问答，“Response type 2: Detailed Description”对场景和人物动作的细致刻画，甚至在“Response type 3: Complex Reasoning”中推理出了人们正面临“如何把大量行李装进车里”的挑战。这种利用大语言模型强大的常识推理能力来生成视觉指令数据的方法，就是 LLaVA 的核心创新之一。

图 20-5 LLaVA 数据构建示例

2.3 LLaVA 架构与训练

LLaVA 的架构非常简洁（如图 20-6 所示）。输入图片 $X_v$ 首先经过 Vision Encoder（使用预训练的 CLIP ViT-L/14），提取出视觉特征 $Z_v$。在其实验中，作者比较了使用 CLIP ViT 的最后一层与最后一层之前的 patch/grid tokens 作为视觉特征。在 ScienceQA 设置下，使用倒数一层特征带来约 0.96 个百分点的提升。随后，Projection Layer（一个简单的线性层 $W$）起到了“翻译官”的作用，将视觉特征线性映射为 LLM 能理解的 Embedding $H_v$。最后，开源 LLM Vicuna（基于 LLaMA 微调）同时处理这些视觉 Embedding 和文本指令 Embedding $H_q$，最终生成回复 $X_a$。

图 20-6 LLaVA 模型架构

为了让这些组件协同工作并获得多模态能力，LLaVA 同样采用了两阶段的训练策略：

（1）特征对齐预训练

为了平衡概念覆盖率和训练效率，LLaVA 将 CC3M 数据集过滤至 595K 个图像-文本对。在此阶段，冻结 Vision Encoder 和 LLM，仅训练投影层。这一步的目标是训练一个与 LLM 兼容的“视觉 Tokenizer”，让图像特征能够对齐到 LLM 的语义空间。

（2）视觉指令微调

使用前述 GPT-4 生成的 158K 条高质量指令数据（对话、描述、推理），冻结 Vision Encoder，同时更新投影层和 LLM 的权重。这一阶段让模型真正学会了如何作为多模态助手与人类交互。

实验结果显示，LLaVA 不仅在日常聊天中展现了出色的多模态能力，在 ScienceQA（多模态科学问答）数据集上也取得了令人瞩目的成绩。论文报告的 92.53% 来自一种“集成”设置，当 LLaVA 与文本版 GPT-4 结合，并由 GPT-4 充当“裁判”在两者答案不一致时做最终仲裁时，可达到该准确率。

参考文献

图文多模态及其实现

Fri, 27 Mar 2026 20:40:25 -0800

图文多模态及其实现

虽然多模态领域涵盖了音频、视频、3D 点云、热成像等多种数据形式，且“多模态”的边界正在不断拓展，但**图文（Image-Text）**始终是目前研究最深入、应用最广泛，也是最能体现跨模态交互逻辑的基础组合。本节我们将深入探讨两个具有代表性的模型架构，分别是将 Transformer 引入视觉领域的 ViT，以及连接文本与图像语义的 CLIP。

一、视觉的 Transformer 化

在过去十年里，计算机视觉领域长期以 CNN（卷积神经网络，如 ResNet）为主流，而 NLP 领域自 2017 年后则由 Transformer 主导。虽然两者都能通过网络设计获得全局信息，但在基础算子的特性上仍有明显区别。2020年，Google 提出了 ViT (Vision Transformer) ¹，既然 Transformer 擅长处理 Token 序列，能不能把图像切成 Patch（图像块），把每个 Patch 当作一个 Token，直接用 Transformer 来做图像识别？

1.1 序列化图像

Transformer 的标准输入是 1D 向量序列，而图像是 2D 网格。ViT 的处理方式非常直接且“暴力”，具体步骤如下：

（1）Patch Embedding（把图像变成 Token，见图 19-5 左下）：将图像 $\mathbf{x}\in\mathbb{R}^{H\times W\times C}$ 切分为 $N$ 个固定大小的 Patch（如 $P\times P \times C$），展平后得到 $\mathbf{x}_p\in\mathbb{R}^{N\times(P^2\cdot C)}$，其中

$$ N=\frac{H\cdot W}{P^2} \tag{19.1} $$

然后用一个可学习的线性投影 $\mathbf{E}\in\mathbb{R}^{(P^2\cdot C)\times D}$ 把每个 Patch 映射为 $D$ 维向量（图 19-5 中的粉色长条 “Linear Projection…”）。这一步在实现上等价于一个 kernel=$P$、stride=$P$ 的卷积（把每个 patch “一次性”投到 $D$ 维）。

（2）特殊的 [CLS] Token（全局聚合器，见图 19-5 左下角标 * 的紫色胶囊）：借鉴 BERT，在序列开头拼接一个可学习的分类令牌 $\mathbf{x}_{class}$。它更像一个“读写全局信息的槽位”，通过自注意力在层间不断从各个 patch 聚合信息。最终，我们只用该位置对应的输出向量（图 19-5 左上角的 “Class” 黄色框）来代表整张图像进行分类。

假设图像尺寸为 $224\times224$，Patch 大小 $P=16$，则会切分出 $14\times14=196$ 个 Patch。加上这个额外的 [CLS] Token 后，输入 Transformer 的序列总长度变为 $196+1=197$。

（3）位置编码（保留空间信息，见图 19-5 紫色标号圆圈）：给序列加上可学习的 1D 位置编码 $\mathbf{E}_{pos}\in\mathbb{R}^{(N+1)\times D}$。

图 19-5 ViT 架构概览（左侧为 Patch Embedding 流程，右侧为 Transformer Encoder 内部结构）

最终，输入 Transformer 的向量序列 $\mathbf{z}_0$ 如下：

$$ \mathbf{z}_0=[\mathbf{x}_{class};\mathbf{x}_p^1\mathbf{E};\mathbf{x}_p^2\mathbf{E};\dots;\mathbf{x}_p^N\mathbf{E}] + \mathbf{E}_{pos} \tag{19.2} $$

其中：

$\mathbf{x}_{class}$：特殊的分类 Token 向量。
$\mathbf{x}_p^k\mathbf{E}$：第 $k$ 个图像 Patch 经过线性投影后的嵌入向量。
$\mathbf{E}_{pos}$：与序列长度对应的位置编码，用于补充 Transformer 缺失的位置信息。

1.2 ViT 模型架构细节

ViT 尽可能保持了 Transformer 的原貌，这种“无修饰”的设计反而使其具有极强的扩展性。我们可以对照图 19-5 中右侧的 Transformer Encoder 部分。

（1）Encoder-only + Pre-Norm：ViT 沿用了标准的 Transformer Encoder 架构（即 MSA 和 MLP 的堆叠），不过它将 Layer Norm 移到了每个子层的输入位置（Pre-Norm）。这种设计与之前学习过的 GPT-2/3 一致。

（2）分类读出：用分类 token 的输出做表征：

$$ \mathbf{y}=\mathrm{LN}(\mathbf{z}_L^{0}) \tag{19.3} $$

其中 $\mathbf{z}_L^{0}$ 表示 Transformer Encoder 最后一层（第 $L$ 层） 输出序列中的第 0 个 token（即 [CLS] 位置）的向量。实践中， $\mathbf{y}$ 会接一个 MLP 分类头来输出最终类别。论文指出，在预训练阶段这个 Head 是含有一个隐藏层的 MLP，而在微调阶段通常简化为单层线性映射。

（3）位置编码与“高分辨率微调”的 2D 插值：ViT 的位置编码本身是 1D 可学习向量，但当微调分辨率变化导致 $N$ 变化时，需要把预训练的 $\mathbf{E}_{pos}$ 视作 $h\times w$ 的 patch 网格再做 2D 插值，以适配新的 patch 网格尺寸。这也是 ViT 少数显式注入“2D 结构”的地方。也就是说假设 Patch 大小为 $16 \times 16$，预训练时图像为 $224\times224$，Patch 数量为 $14\times14=196$（即 $224/16=14$）。微调时若图像放大到 $384\times384$，Patch 数量变为 $24\times24=576$（即 $384/16=24$）。此时，我们不仅要处理序列变长的问题，还要保持空间位置的相对关系。所以，需要将原本 $14\times14$ 的位置编码矩阵“拉伸”（双线性插值）到 $24\times24$，以初始化新的位置编码。

为什么微调时要放大图像？

这是一个在计算机视觉中常见的策略（效率 vs 精度权衡）。预训练阶段由于数据量巨大，为了节省计算成本，通常使用标准分辨率。而微调阶段面向下游特定任务，数据量相对较小，此时使用更高分辨率（如 $384 \times 384$）可以让模型“看清”更多细节，以追求更高的精度。

（4）全局交互：这其实就是 BERT 中“深度双向注意力”在图像领域的直接体现。在 BERT 中，每个 Token 在第一层就能“看见”句子中所有的其他 Token。同样地，在 ViT 中，每个 Patch 就相当于一个 Token。CNN 需要堆叠多层卷积才能扩大感受野看到全图，而 ViT 的自注意力机制在第一层就能让任意两个 Patch 进行交互。左上角的 Patch 可以直接“关注”到右下角的 Patch，无需经过层层传递，通过 Attention 矩阵实现了一步到位的全局视角。但这种能力的代价是计算量，标准 Self-Attention 的复杂度是序列长度 $N$ 的平方（$O(N^2)$）。Patch 越小（$P$ 越小），序列长度 $N$ 就越大（$N \propto 1/P^2$），计算量就会呈平方级爆炸（$O(1/P^4)$）。这也是为什么 ViT 通常不把 Patch 设置得太小的原因。

1.3 关键特性

ViT 的设计哲学与 CNN 截然不同，首先体现在弱归纳偏置 (Inductive Bias) 上。所谓归纳偏置，就是模型在处理数据时预先带有的“偏见”或“假设”。CNN 天然假设图像具有局部性（相邻像素有关联）和平移等变性（猫在左上角和右下角都是猫）等结构先验，就像是带着“有色眼镜”看图，所以 CNN 在小数据上也能快速抓住重点，更容易泛化。而 ViT 的自注意力是全局的，它把图像看作一串长长的序列，显式的 2D 结构只在切 patch与位置编码插值这两处出现。这就好比 ViT 是一张白纸，模型无法预先“知道”像素的空间规则，需要更多数据去“学会”稳定的空间与语义模式。

空间与语义模式

空间模式指像素点如何在空间上组成有意义的几何结构（如“圆形”通常由连续的弧线像素组成，“眼睛”通常位于“鼻子”上方），CNN 通过卷积核的局部连接天然假设了这种相邻关系，而 ViT 最初是一张白纸，必须靠大量数据自己发现“相邻的 Patch 往往属于同一个物体”这一规律。语义模式则指图像内容的高层含义及其组合规则，例如“蓝色的上方区域”通常是“天空”，“两个尖耳朵 + 胡须”通常代表“猫”。ViT 不仅要学会识别这些物体，还要学会跨越长距离关注它们的关联（如鸟的头和尾巴虽然相距很远，但共同定义了“鸟”这个概念）。

这种弱归纳偏置的设计虽然增加了学习难度，但也带来了架构的统一性 (Unified Architecture)。ViT 的最大贡献在于证明了 Transformer 是一个通用的计算原语。在 ViT 之前，CV 领域由 CNN 统治，NLP 领域由 Transformer 统治，两者的模型设计思路完全不同。ViT 出现后，CV 和 NLP 终于可以在底层架构上实现统一（都用 Transformer 处理 Token 序列）。这种统一性不仅简化了模型设计，更为后续的多模态大模型提供了实现路径。图像和文本都能被变成 Token 喂给 Transformer，那么在一个模型里同时处理它们就有了可能性。归纳偏置的减弱同时也导致了 ViT 的数据饥渴 (Data Hungry) 特性。在中小数据集（如 ImageNet-1k）从头训练时，ViT 往往不如同规模的 CNN。但当在超大规模数据（如 ImageNet-21k、JFT-300M）上预训练后，再迁移到下游任务，ViT 会呈现更强的扩展性（scale 越大越吃香）。总结起来就是因为 ViT 的归纳偏置更弱、需要从数据里学到“空间结构 + 语义组合”这套规则，所以更依赖大规模预训练数据来把泛化能力堆起来。

二、连接图文的 CLIP 架构

2021年，OpenAI 紧随其后发布了 CLIP (Contrastive Language-Image Pre-training) ²。如果说 ViT 统一了视觉的模型架构，那么 CLIP 就统一了图文的语义空间。

2.1 CLIP 的架构与原理

ViT 虽然实现了图像与文本在底层架构上的统一，但这仅仅是第一步。尽管模型能“吃”进去图像和文本，但它并不理解“一张猫图”和“单词 Cat”之间有什么联系。要打破这层隔阂，我们需要让这两个模态在语义空间上实现对话。而实现这一对话的关键就是 Embedding，它能够将高维、非结构化的数据（图片、文字）映射到一个低维的、稠密的数学空间中。在多模态任务中，仅仅分别得到图像向量和文本向量是不够的。我们还需要让这两个向量在同一个空间中具有几何意义上的关联，这就是语义对齐（Alignment）。多模态学习的理想状态下，一张“猫”的图片生成的向量 $V_{img}$ 应该与单词“Cat”生成的向量 $V_{text}$ 在空间中距离非常近，即夹角小且相似度高。面对图像和文本原本处于两个完全不同异构特征空间的挑战，CLIP 的目标就是解决如何让模型学会将它们对齐。

（1）双塔结构

为了实现上述目标，CLIP 采用了经典的双塔结构，但在具体设计上不仅追求特征的表达能力，更注重大规模训练的效率。对于负责将图像编码为特征向量的图像编码器（Image Encoder），OpenAI 探索了经过改进的 ResNet 和 ViT 两种架构。ResNet 版本在 ResNet-50 的基础上引入了 ResNet-D 的改进，并采用抗混叠下采样（anti-aliased downsampling）来减少下采样带来的信息折叠；同时将末端的全局平均池化替换为注意力池化，以更好地聚合全局特征。ViT 版本则基本遵循原始 ViT 的实现，只做了很小的改动。仅在 patch embedding 和 position embedding 相加后、进入 Transformer 之前增加一个额外的 LayerNorm，并使用了稍微不同的初始化方案以提升训练稳定性。如图 19-6 所示，实验表明在同样的计算预算下，ViT 架构在相近计算预算下整体表现更优。论文也指出 CLIP 的 ViT 系列在计算效率上大约比 CLIP ResNet 系列高 3 倍。而对于负责将文本编码为特征向量的文本编码器（Text Encoder），CLIP 选用了类似 GPT-2 的 Decoder-only Transformer 架构而非 BERT，通过自注意力掩码确保模型在编码当前词时仅能关注之前的词。文本序列以 [SOS] 标记开始，以 [EOS] 标记结束。经过 Transformer 编码后，每个词位置都会产生对应的特征向量，但 CLIP 只取最后一层 Transformer 在 [EOS] 标记位置的特征向量作为整句话的语义表示。这是因为 [EOS] 位置的特征通过自注意力机制已经聚合了整个句子的信息，能够代表整句话的语义。

图 19-6 CLIP 图像编码器计算效率对比：ViT vs ResNet

这两个模态塔（图像模态塔和文本模态塔）在特征提取阶段互不干扰，分别输出图像和文本的特征向量。随后，两个向量会分别经过一个线性的投影层映射到维度相同的联合嵌入空间 (Joint Embedding Space) 中，并进行 L2 归一化。通过这一系列操作就可以直接计算两个向量的点积（即余弦相似度），来衡量"图"与"文"在语义上的匹配程度。

（2）对比学习

如图 19-7 所示，对比学习（Contrastive Learning）是 CLIP 的核心训练策略，它为双塔结构注入了“灵魂”，真正实现了让图像和文本在同一个 Embedding 空间中实现语义对齐。

图 19-7 CLIP 的对比预训练过程

我们可以结合图 19-7 来完整梳理一下这个跨模态对齐的过程。第一步是输入一个包含 $N$ 个图文对的 Batch（图中通过叠放的输入和下标 $1 \dots N$ 来示意），图像和文本会分别通过各自的 Encoder 变成特征向量。接下来，这些原始特征会被投影到同一个联合嵌入空间，分别形成图像 Embedding ($I_1, I_2, \dots, I_N$) 和文本 Embedding ($T_1, T_2, \dots, T_N$)。此时，它们已经变成了“同一种语言”（都是 $D$ 维向量）。接下来进行相似度矩阵的构建，模型会计算这两个序列中所有向量的两两点积，生成一个 $N \times N$ 的相似度矩阵（图中右侧的网格）。其中，对角线（蓝色块）代表 $I_k$ 和 $T_k$ 的匹配程度，这是原始数据中真实的“图文对”，即正样本；而非对角线（白色块）代表 $I_k$ 和 $T_j (j \neq k)$ 的匹配程度（比如“猫的图”配了“描述狗的字”），这是错误的组合，即负样本。最后的训练目标是最大化对角线上的数值，同时最小化非对角线上的数值。也就是说，当模型努力让 $I_{dog} \cdot T_{dog}$ 变大时，它实际上是在高维空间中推着“狗的图片向量”和“Dog 单词向量”相互靠近；反之，当模型努力让 $I_{cat} \cdot T_{dog}$ 变小时，它是在让它们相互远离。通过在 4 亿对数据上重复这个过程，CLIP 最终“学会”了将视觉概念和语言概念紧密地绑定在一起。这就实现了我们最初的构想，Embedding 不再是孤立的模态特征，而是成为了连接视觉与语言的通用货币。

2.2 零样本推理与提示工程

虽然 CLIP 在预训练阶段仅仅是学习了图文对齐，但它最具革命性的特性其实是它的零样本推理能力。传统的计算机视觉模型通常只能识别训练时定义好的类别，一旦遇到新类别就必须重新收集数据微调模型。而 CLIP 将“分类任务”彻底重构为“图文匹配任务”，打破了固定类别的限制。

为了让模型更好地理解类别名称，CLIP 还引入了提示工程的概念。当我们需要识别一张图像是否属于某个类别（例如“狗”）时，不再是让模型输出一个类别 ID，而是让模型去判断这张图与句子“一张狗的照片”之间的相似度（如图 19-8 所示）。由于训练数据多为句子而非单词，直接输入单词往往会造成歧义（例如论文中提到的 “boxer”，既可能是“拳师犬”，也可能是“拳击手”），且与预训练数据的分布存在差异。所以，我们可以将类别标签填入一个模板句子，如 “A photo of a {label}.”。在推理时，模型会将所有候选类别（如猫、狗、飞机）都填入模板，生成一组文本向量，然后找出与当前图像向量相似度最高的那句话，从而确定图像的类别。这种范式使得 CLIP 无需任何微调，就能直接迁移到任意的视觉分类任务中，成为一个真正的“开放词汇”分类器。

图 19-8 CLIP 的 Zero-Shot 推理过程

2.3 CLIP 的局限

作为多模态领域的里程碑，CLIP 的出现打通了视觉与语言的壁垒。它生成的 Embedding 具有很强的语义线性与鲁棒性，例如在 Stable Diffusion 等扩散模型中，通常会使用 CLIP/OpenCLIP 的文本编码器将提示词变成条件向量，达到在生成过程中提供语义约束的目的。它也启发并影响了后续大量视觉语言模型，为“图文对齐 + 下游任务适配”提供了关键范式。除此之外，由于在海量且多样化的互联网数据上训练，CLIP 对图像风格、光照变化、草图甚至卡通画的鲁棒性往往强于传统仅在 ImageNet 上训练的模型。

然而，CLIP 并非完美无缺。由于它是基于“图像整体”与“文本整体”的统计相关性进行训练的，它在处理细粒度分类（如区分波音747与波音777，或不同品种的特定花卉）时往往表现不佳，因为这些细微差别在海量图文对中可能被淹没。同时，CLIP 在逻辑计数（如“数一数图中有几个红色的气球”）或空间关系判断（如“车在房子的左边还是右边”）方面也存在短板，这通常被归因于对比学习损失函数难以捕捉复杂的组合性语义。最后，在医学影像或遥感图像等与其预训练数据分布差异巨大的专业领域，CLIP 的 Zero-Shot 性能也会显著下降，通常需要进行针对性的微调。

三、CLIP 代码实现

本节完整代码

（1）图像与文本编码器

理解了 CLIP 的原理后，我们尝试用 PyTorch 实现一个简化版的 CLIP 模型。原始 CLIP 的两个编码器都是从零训练，并且会进行 L2 归一化 + 可学习温度（logit scale）缩放，这里为了跑通流程与降低门槛，我们直接加载预训练的模型。第一步可以先构建双塔结构的两个编码器。首先是 Image Encoder，利用 timm 库可以非常方便地加载预训练的 ViT 模型。这里我们选择 vit_small_patch16_224 这个型号，其中 patch16 表示将图像切分为 $16 \times 16$ 的块，224 表示输入分辨率。同时开启 pretrained=True 让模型加载在 ImageNet 上预训练好的权重，让模型拥有基础的“看图”能力。由于 timm 的 ViT 默认带有用于分类的 head，为了得到我们需要的图像 embedding，会显式加一个投影层把视觉特征映射到目标 embedding 维度（这样不会误把随机初始化的分类 head 当作 embedding）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


class ImageEncoder(nn.Module):
 """图像编码器"""
 def __init__(self, output_dim):
 super(ImageEncoder, self).__init__()
 # num_classes=0 会移除分类 head，输出 backbone 特征（维度为 vit.num_features）
 self.vit = timm.create_model('vit_small_patch16_224', pretrained=True, num_classes=0)
 self.proj = nn.Linear(self.vit.num_features, output_dim, bias=False)

 def forward(self, x):
 feat = self.vit(x) # (Batch, vit.num_features)
 return self.proj(feat) # (Batch, output_dim)

对于 Text Encoder，为了贴近原始 CLIP 使用 Decoder-only 架构的设计，我们选择 GPT-2 作为近似替代。不过，GPT-2 是为文本生成设计的，默认没有 Padding Token，而在处理 Batch 数据时我们要对齐长度，所以需要将它的 pad_token 临时设置为 eos_token。在获取特征时，我们取序列最后一个非 padding token的隐藏状态作为整句话表征。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


class TextEncoder(nn.Module):
 """文本编码器"""
 def __init__(self, output_dim):
 super(TextEncoder, self).__init__()
 self.tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
 # 解决 GPT-2 无 pad_token 的问题，将其设为 eos_token
 self.tokenizer.pad_token = self.tokenizer.eos_token
 self.model = GPT2Model.from_pretrained('gpt2')
 self.proj = nn.Linear(self.model.config.hidden_size, output_dim, bias=False)

 def forward(self, texts):
 inputs = self.tokenizer(texts, return_tensors='pt', padding=True, truncation=True).to(self.model.device)
 output = self.model(**inputs)

 # 获取最后一个非 padding token 的输出作为句子表征
 # 利用 attention_mask 找到每个样本的真实长度
 last_hidden_state = output.last_hidden_state
 attention_mask = inputs.attention_mask
 last_token_idx = attention_mask.sum(dim=1) - 1

 # 从 batch 中取出对应索引的向量
 batch_idx = torch.arange(last_hidden_state.size(0)).to(last_token_idx.device)
 sent = last_hidden_state[batch_idx, last_token_idx] # (Batch, hidden)
 return self.proj(sent) # (Batch, output_dim)

（2）投影与双塔对齐

接下来我们将刚才实现的两个编码器组合起来实现一个完整的 CLIP 模型。图像编码器和文本编码器输出的特征通常是不同维度的。为了计算相似度，我们需要通过可学习的投影层 将它们映射到相同的维度（联合嵌入空间），并计算点积。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


class CLIP(nn.Module):
 """CLIP：双塔 + 线性投影 + 归一化 + 温度缩放"""
 def __init__(self, embed_dim):
 super(CLIP, self).__init__()
 self.image_encoder = ImageEncoder(embed_dim)
 self.text_encoder = TextEncoder(embed_dim)
 # 可学习温度（论文中用 log 参数化的 logit_scale）
 self.logit_scale = nn.Parameter(torch.log(torch.tensor(1 / 0.07)))

 def forward(self, images, texts):
 # 1) 提取 embedding
 img = self.image_encoder(images)
 txt = self.text_encoder(texts)

 # 2) L2 归一化（点积 -> 余弦相似度）
 img = torch.nn.functional.normalize(img, dim=-1)
 txt = torch.nn.functional.normalize(txt, dim=-1)

 # 3) 温度缩放后的相似度矩阵 (Batch, Batch)
 scale = self.logit_scale.exp()
 logits = scale * (img @ txt.T)
 return logits

（3）数据准备

为了演示，我们使用 CIFAR-10 数据集。由于 ViT 模型默认的输入分辨率是 224x224，而 CIFAR-10 的图片大小是 32x32，所以我们需要在预处理阶段将图片 Resize 到 224。同时，为了匹配预训练模型的输入分布，我们还需要使用模型特定的均值和方差（通过 vit.default_cfg 获取）对图像进行归一化处理。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


def load_cifar10_dataset(batch_size, image_size=224, root='./cifar10', mean=None, std=None):
 """加载CIFAR10数据集"""
 transform = transforms.Compose([
 transforms.Resize((image_size, image_size)),
 transforms.ToTensor(),
 transforms.Normalize(mean=mean, std=std),
 ])

 train_dataset = CIFAR10(root=root, train=True, download=True, transform=transform)
 loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
 classes = train_dataset.classes
 return loader, classes

（4）对比训练过程

最后的训练循环需要遍历数据集以构造 Batch 数据，获取一批图像及其对应的类别名称作为文本。随后将这些图像和文本同时输入模型，生成 $N \times N$ 的相似度矩阵 logits。由于第 $i$ 张图对应的正是第 $i$ 个文本，所以监督信号就是对角线的“匹配位置索引”，即 targets=[0, 1, ..., N-1]。接下来，我们分别计算“图像找文本”（行方向）和“文本找图像”（列方向）的损失，并将两者取平均值作为最终的优化目标。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


if __name__ == "__main__":
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 print(f"Using device: {device}")

 # 初始化模型
 clip_model = CLIP(embed_dim=512).to(device)
 clip_model.text_encoder.model.to(device)

 cfg = clip_model.image_encoder.vit.default_cfg
 mean = cfg['mean']
 std = cfg['std']
 data_root = os.path.join(os.path.dirname(__file__), "cifar10")
 dataset, classes = load_cifar10_dataset(batch_size=4, root=data_root, mean=mean, std=std)

 # 模拟训练循环
 for i, (images, labels) in enumerate(dataset):
 images = images.to(device)
 # 将标签转换为对应的文本描述 (例如 label 0 -> "airplane")
 texts = [classes[label.item()] for label in labels]

 # 前向计算得到相似度矩阵
 logits = clip_model(images, texts)

 # 构造目标标签
 targets = torch.arange(logits.shape[0]).to(device)

 # 计算损失
 loss_i = nn.CrossEntropyLoss()(logits, targets)
 loss_t = nn.CrossEntropyLoss()(logits.T, targets)
 loss = (loss_i + loss_t) / 2

 print(f"Batch {i}: Loss = {loss.item():.4f}")

 # 仅演示前几个batch
 if i >= 2: break

输出如下：

1
2
3


Batch 0: Loss = ...
Batch 1: Loss = ...
Batch 2: Loss = ...

CLIP 实现完整代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126


import os
import torch
import torch.nn as nn
from torch.utils.data import DataLoader
import torchvision.transforms as transforms
from torchvision.datasets import CIFAR10
from transformers import GPT2Model, GPT2Tokenizer
import timm

# 1. 模型定义

class ImageEncoder(nn.Module):
 """图像编码器"""
 def __init__(self, output_dim):
 super(ImageEncoder, self).__init__()
 # 使用来自timm的ViT模型
 # num_classes=0 会移除分类 head，输出 backbone 特征（维度为 vit.num_features）
 self.vit = timm.create_model('vit_small_patch16_224', pretrained=True, num_classes=0)
 self.proj = nn.Linear(self.vit.num_features, output_dim, bias=False)

 def forward(self, x):
 feat = self.vit(x)
 return self.proj(feat)


class TextEncoder(nn.Module):
 """文本编码器"""
 def __init__(self, output_dim):
 super(TextEncoder, self).__init__()
 model_name = 'gpt2'
 self.tokenizer = GPT2Tokenizer.from_pretrained(model_name)
 # GPT-2默认没有pad_token，将其设为eos_token
 self.tokenizer.pad_token = self.tokenizer.eos_token
 self.model = GPT2Model.from_pretrained(model_name)
 self.proj = nn.Linear(self.model.config.hidden_size, output_dim, bias=False)

 def forward(self, texts):
 # 文本通过GPT-2
 inputs = self.tokenizer(texts, return_tensors='pt', padding=True, truncation=True).to(self.model.device)
 output = self.model(**inputs)

 # 获取最后一个非 padding token 的输出
 # 根据 attention_mask 计算每个样本的最后一个有效 token 索引
 last_hidden_state = output.last_hidden_state
 attention_mask = inputs.attention_mask
 last_token_idx = attention_mask.sum(dim=1) - 1 # (B)

 # 从batch中取出对应索引的向量
 batch_idx = torch.arange(last_hidden_state.size(0)).to(last_token_idx.device)
 sent = last_hidden_state[batch_idx, last_token_idx] # (B, 768)
 return self.proj(sent) # (B, output_dim)


class CLIP(nn.Module):
 """CLIP模型：结合图像和文本编码器"""
 def __init__(self, embed_dim):
 super(CLIP, self).__init__()
 self.image_encoder = ImageEncoder(embed_dim)
 self.text_encoder = TextEncoder(embed_dim)

 # 可学习温度系数（论文中用 log 参数化的 logit_scale）
 self.logit_scale = nn.Parameter(torch.log(torch.tensor(1 / 0.07)))

 def forward(self, images, texts):
 img = self.image_encoder(images) # (B, embed_dim)
 txt = self.text_encoder(texts) # (B, embed_dim)

 # 归一化后点积即余弦相似度
 img = torch.nn.functional.normalize(img, dim=-1)
 txt = torch.nn.functional.normalize(txt, dim=-1)

 # 温度缩放
 scale = self.logit_scale.exp()
 logits = scale * (img @ txt.T) # (B, B)
 return logits


# 2. 数据处理

def load_cifar10_dataset(batch_size, image_size=224, root='./cifar10', mean=None, std=None):
 """加载CIFAR10数据集"""
 transform = transforms.Compose([
 transforms.Resize((image_size, image_size)),
 transforms.ToTensor(),
 transforms.Normalize(mean=mean, std=std),
 ])
 # download=True 会自动下载
 train_dataset = CIFAR10(root=root, train=True, download=True, transform=transform)
 loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
 classes = train_dataset.classes
 return loader, classes


if __name__ == "__main__":
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 print(f"Using device: {device}")

 # 初始化模型
 clip_model = CLIP(embed_dim=512).to(device)
 clip_model.text_encoder.model.to(device)

 # 加载数据
 cfg = clip_model.image_encoder.vit.default_cfg
 mean = cfg['mean']
 std = cfg['std']
 data_root = os.path.join(os.path.dirname(__file__), "cifar10")
 dataset, classes = load_cifar10_dataset(batch_size=4, root=data_root, mean=mean, std=std)

 # 3. 训练循环
 for i, (images, labels) in enumerate(dataset):
 images = images.to(device)
 texts = [classes[label.item()] for label in labels]

 # 前向计算
 logits = clip_model(images, texts) # (B, B)

 # 计算损失
 targets = torch.arange(logits.shape[0]).to(device)
 loss_i = nn.CrossEntropyLoss()(logits, targets)
 loss_t = nn.CrossEntropyLoss()(logits.T, targets)
 loss = (loss_i + loss_t) / 2

 print(f"Batch {i}: Loss = {loss.item():.4f}")

 # 仅演示前几个batch
 if i >= 2: break

小结

回顾第一节提到的多模态机器学习五大挑战（表征、转换、对齐、融合、协同学习），本节介绍的 ViT 解决了“表征”的统一性，它打破了 CNN 对视觉的统治，证明 Transformer 能作为通用的计算原语，通过 Patch Embedding 将图像“序列化”为 Token，从而在底层架构上与语言达成一致。而 CLIP 则解决了“对齐”的普适性，利用对比学习将异构的图文映射到同一联合嵌入空间，让 Embedding 真正成为连接不同模态的“桥梁”，无需微调即可实现零样本迁移。通过本节的代码实践，我们也亲手实现了这种“双塔+对比损失”的简洁架构。尽管 CLIP 在细粒度理解和复杂逻辑上仍有短板，但它为后续的多模态生成与复杂推理提供了关键的语义地基。

参考文献

多模态概述

Fri, 27 Mar 2026 16:40:25 -0800

多模态概述

在前面的章节中，我们主要围绕文本（Text）这一单一模态系统性学习了 NLP 与 LLM 的主线能力。但真实世界的信息并不只以文字存在，图片、视频、语音、音乐、传感器、布局与结构化信号……共同构成了人类认知的“输入流”。多模态学习关注的就是如何让模型在这些异构信息之间建立联系，完成理解、生成与决策。

图 19-1 多模态模型 Nano Banana 生成的多模态交互示意图

一、多模态的定义与内涵

1.1 从模态到多模态

在工程语境里，模态（Modality）通常指信息的感知/表达通道（可理解为模型的输入或输出形式），也就是同一类“语义”在不同载体上的呈现形式（信息来源/形式）。正因为载体不同，各模态在数据层面天然存在差异。文本通常表现为离散的 token 序列；图像是 $H \times W \times C$（高度 $\times$ 宽度 $\times$ 通道数）的像素网格；语音/音频常以连续时间波形或谱图表示；传感器往往是多路同步的时间序列，并伴随漂移、缺失与噪声等工程问题。结构不同会带来统计特性差异（例如局部性与全局性、时序依赖、尺度变化与噪声分布），进而决定了预处理、采样与建模方式也不应“一把梭”。因此，多模态（Multimodal）系统通常会为不同模态配置各自的编码器（Text / Image / Audio / Sensor Encoder），先把异构信号映射为可计算的表征，再进入后续的对齐、融合与推理。

微观多模态

除了跨越物理媒介的模态（如声、光、电），在文本模态内部，也存在“结构形态”发生显著变化的转换。例如：

Text-to-Code（文本转代码）：代码具有更严密的逻辑和语法约束。

Text-to-Table（文本转表格）：表格是结构化的二维信息。这些转换虽然输入输出都是字符流，但在信息组织形式上发生了质变，也可视为广义的多模态转换。

基于上述对模态差异的理解，一个具备可操作性的定义是当系统需要同时处理两种及以上“本质异构”的模态，并且需要显式建模它们之间的语义关系（对应、互补、约束）时，就可以称为多模态。不过，“多模态”并不等同于把多路数据简单拼在一起，也不应只用“输入/输出的个数”来粗暴划分；关键是模型是否真的利用了模态之间的互补信息，并在表征、对齐与推理层面建立起跨模态的联系。站在工程落地的视角，多模态任务最常见的形态包括以图像与文本共同输入并输出文本答案的图文问答（VQA）；以文本为条件生成图像、音频或视频的内容生成；以及在更复杂系统中同时接收多模态输入并输出多模态结果（例如看图对话的同时用语音回答，甚至驱动动作执行），本质都是围绕“异构信息的协同建模”展开。

1.2 多模态的交互与表征对齐

多模态研究并非近年才出现，但它在多模态机器学习语境下的快速发展，更多发生在大规模数据、可扩展模型与训练范式逐步成熟之后。纵向回顾相关工作，可以将其脉络概括为两条相互关联但侧重点不同的路线。分别是以用户输入通道互补为核心的多模态交互，以及以共享潜在空间为核心的多模态表征对齐。

第一条路线主要源于人机交互（HCI）与多通道界面的研究传统，强调不同输入通道在语义表达上的互补性与消歧能力。Richard A. Bolt 在 SIGGRAPH 1980 发表并演示的 “Put-That-There” 系统，是早期语音与指点/手势协同交互的经典案例 ¹。系统将语音命令与同步指向结合，使语言中的指示词（如 that/there）能够借助空间指点获得更明确的指代，完成图形对象在界面中的定位与操作。需要指出的是，此类工作通常以规则、语法或时序约束实现跨通道整合，其研究重点在于交互机制与解析策略，而非通过大规模数据学习统一表示。

第二条路线聚焦在表征空间的对齐，即学习一个（或一组）潜在空间，使不同视角变量或不同模态的表示在该空间中具有可比性，并对语义对应关系保持一致性。这个思想在统计学习中具有更早的数学基础，Hotelling 提出的**典型相关分析（CCA）**可被理解为通过线性投影最大化两组变量相关性的对齐方法，为后续“共享子空间”的建模思路提供了重要工具 ²。在信息检索领域，**LSA/LSI（Latent Semantic Analysis / Latent Semantic Indexing）**虽然主要处理单一文本模态，但它通过降维构造低维语义空间、并以空间邻近关系刻画语义相似性的范式，为之后以“向量空间”承载语义并进行相似度计算的做法奠定了方法论基础 ³。

随着跨模态任务（如图文检索、视觉—语言建模）的发展，研究重心逐步转向“如何学习可迁移的联合嵌入空间”。在这一过程中，CCA 及其核化形式（Kernel CCA, KCCA）被系统化总结并作为“学习共同子空间/共同表征”的重要工具 ⁴，为后续跨模态匹配与检索提供了可复用的对齐范式。深度学习范式下，对比式目标进一步推动了“对齐”从相关性最大化走向可扩展的表示学习：Hadsell、Chopra、LeCun 的**对比损失（Contrastive Loss）**为“拉近正样本、推远负样本”的度量学习目标提供了早期形式化表达 ⁵。随后，ConVIRT 等工作在配对图文数据上采用双向对比目标进行预训练，为跨模态对比学习在实际任务中的有效性提供了直接证据 ⁶。CLIP 则将该训练范式扩展到更大规模的图文配对数据，并在零样本迁移等设置中展示了共享嵌入空间对齐对下游泛化能力的重要作用 ⁷，推动该路线进入快速发展阶段。

误区辨析

把“多源/多路数据”当成多模态，把“概念混用”当成定义：多模态的关键不在于“数据路数多”，而是模态是否异构、信息是否互补、系统是否真的做了对齐/融合/协同推理。比如多篇文本、多视角图像、多张图片拼接，很多时候仍属于同一模态的扩展，并不天然等于多模态；相反，一张图片加一句描述这种最简单的图文对，只要目标是学习跨模态语义关系，就已经是多模态。工程上还有个常见混淆点，“多模态”和“多任务学习”不是一回事——前者讨论的是信息来源（模态）的异构与融合，后者讨论的是目标函数/任务的并行优化，两者可以组合但不能互相替代。

二、多模态认知图谱

为了打破“多模态”作为抽象概念的疏离感，我们可以从任务复杂度和技术挑战两个维度来构建认知图谱。这不仅是对应场景的简单罗列，也是为了理清模型架构演进的内在逻辑，理解随着任务从“判断匹配”升级到“生成内容”乃至“复杂推理”，模型的能力边界是如何一步步拓展的。

2.1 多模态任务图谱

根据输入输出的依赖关系与任务复杂度，现有的多模态任务大致可以被归纳为四个递进的层级。虽然我们常以图文为例，但这些层级的逻辑天然适用于视频、音频、传感器等任意模态组合。

（1）基础理解与检索

这是多模态能力的基础，主要逻辑是判断跨模态信息的匹配度或从库中寻找对应项。最典型的场景是图文检索（以文搜图/以图搜文），正是 CLIP 这类双塔结构最擅长的领域。同样的逻辑也适用于“以音搜文/以文搜音”（音频-文本检索），以及“多传感器片段检索”（例如用 IMU/振动序列检索对应故障描述）。一些前沿工作甚至尝试将图像、文本、音频、深度、热成像、IMU 等绑定到同一嵌入空间（如 ImageBind），使“检索/匹配”天然跨越多种模态组合。在这个层级，模型主要完成的是“特征对齐”工作，以及跨模态一致性/支持性判断（例如图文是否一致、文本描述是否被图像证据支持。也可被更严格地形式化为“跨模态蕴含”类任务）。

（2）定位与结构化理解

在基础理解之上，模型需要把语言或符号“落到可定位的证据”上，具备更精细的定位与解析能力。视觉指代/定位 (Visual Grounding) 解决了“指到哪/是哪一个”的问题，是细粒度 VQA 和具身智能的前置能力。这一能力可扩展为“音频/视频 Grounding”（定位视频时间片段或音频事件区间），以及“传感器时序对齐”（把语言指令落到某段传感器时间窗）。除此之外，文档与图表理解 (Document & Diagram Understanding)（OCR、表格布局、坐标轴等）也是一类高频结构化输入，在多模态理解与推理基准中占有重要位置。这一层级决定了后续推理是否建立在准确的证据之上。

（3）生成与转换

当模型具备了理解能力后，下一步就是跨越模态创造新信息。这一层级的核心是跨模态生成与条件生成。图生文 (Image Captioning) 要求模型“看图说话”，将视觉信息翻译为自然语言；而 文生图 (Text-to-Image) 则如 Stable Diffusion，通过文本提示控制像素生成。近年来的视觉语言模型（如 LLaVA）往往不以“纯 Caption 数据集训练”作为唯一目标，而是通过视觉-语言对齐与指令数据进一步增强“可对话、可解释、可执行指令”的生成能力。推广到其他模态，还包括“文生音频/音频生文”（语音识别、音频描述/摘要）、“视频→文本总结”，以及“传感器→文本报告/告警解释”（把多路时序生成结构化告警或自然语言报告）。统一来看，这一层解决的是跨模态 Mapping 与条件生成。

（4）复杂推理与控制

这部分是目前多模态大模型的前沿高地，核心是结合外部知识与上下文进行多步思考或行动。在更具挑战性的视觉问答/视觉对话/多模态推理基准中，模型不仅要“看懂并描述”，还要围绕问题组织证据、进行多步推理并给出可追溯结论。更进一步则是 具身智能 (Embodied AI)，例如指令机器人“去厨房拿那个红色的苹果”，要求模型不仅能理解视觉场景，还要规划动作序列并执行。在其他模态中，这对应了“视听多步推理”（基于视频+音频回答事件因果/流程问题），以及“多传感器决策控制”（融合摄像头、雷达、IMU 等信号做规划/控制）。这一层级的能力往往受限于对齐精度、证据可追溯性与长序列建模成本，它的目标不仅是让模型“能回答”，更要实现“基于证据的推理与行动”。

2.2 多模态机器学习五大挑战

在明确了任务图谱后，我们自然会想到实现这些任务的难点在哪里？Baltrušaitis、Ahuja、Morency 在其多模态机器学习综述与分类中提出的“五大挑战”（表征、转换、对齐、融合、协同学习），即便在 LLM 时代，依然是审视多模态架构设计的高频框架 ⁸。结合 Mercari Tech Blog 的工程视角解读 ⁹，我们可以通过表 19-1 更具体地理解这五个维度的核心难题：

挑战维度	核心关注	主要难点	演进与策略
表征	异构数据映射到统一空间	数据形式差异巨大（如离散符号 vs 连续像素），且含不同程度噪声与冗余。	常见策略是“各模态专用编码器 + 共享 token 空间/Transformer 交互”，或先做统一 token 化再用 Transformer 建模，在保留模态特性的同时挖掘互补信息。
转换	模态之间的映射与生成	克服“一对多”映射歧义性（Ambiguity），保证“翻译”的语义一致性与真实性。	涵盖从图生文（Captioning）到文生图（Diffusion）的多向生成，重点解决逻辑性与质量难题。
对齐	跨模态元素的对应关系	识别不同模态中指代同一实体或事件的子结构（从 Patch/Token 到全局 Instance）。	通过 CLIP 对比学习，在大规模数据上显式拉近配对数据距离，建立语义匹配。
融合	信息的整合与推理	决策时有效结合多模态信息，消除歧义并抑制冲突带来的幻觉。	引入 Cross-Attention 等深度交互机制（如 LLaVA），替代简单拼接以实现协同增益。
协同学习	知识的跨模态迁移	如何利用高资源模态（如文本）辅助低资源模态的学习。	典型手段包括跨模态迁移/蒸馏、伪标注、联合预训练与缺失模态鲁棒训练；目标是在模态可用性不一致时仍能可靠泛化（包括 zero-shot / few-shot）。

表 19-1 多模态机器学习五大挑战（基于综述与工程解读）

三、应用场景

截止 2026 年，多模态模型已经不再是停留在实验室的理论模型，而是深入渗透到了各类业务场景中。基于行业实践（如电商、自动驾驶、娱乐等），我们可以将纷繁复杂的多模态应用版图整合为四大核心领域：

（1）商业与消费体验：商业与消费领域直接面向消费者（ToC），核心价值是通过增强体验来促进交易与娱乐，是目前多模态技术变现最成熟的赛道。在全链路电商体验方面，涵盖从“搜”到“买”的全流程，其中多模态推荐融合商品图片、描述与评论实现深度个性化，视觉搜索支持“拍立淘”式的以图搜图或跨模态检索，虚拟试穿则通过 3D 渲染结合 CV 关键点技术或利用生成式模型提供逼真的在线试穿体验。内容创作与娱乐则通过虚拟人在直播带货与短视频中结合 TTS 与 CV 技术实现实时互动，游戏 NPC 也正从脚本驱动转向多模态驱动，能根据玩家的语音语调、动作甚至表情做出动态反应。例如在一些公开演示/宣传案例中（如图 19-2），游戏 NPC 被展示为可根据玩家语言进行情境化行动，从而带来更强的沉浸式互动。

图 19-2 逆水寒智能 NPC

（2）企业级认知与服务：企业级服务主要面向企业（ToB）与专业机构，目标是降本增效，处理高密度的复杂信息流。比如智能客服与交互超越纯文本问答，多模态客服能理解用户发送的截图（如报错页面）或语音（带情绪的投诉）并精准回复，公共场所的流媒体智能屏则可在合规授权的前提下基于视觉感知进行定向信息交互。在文档与知识处理领域，智能文档处理 (IDP) 作为 OCR、文档解析与信息提取的系统工程，不仅识别文字，还能精准还原发票、标书以及笔记中的版面布局与表格结构，如图 19-3 就是 PaddleOCR-VL 对笔记的识别效果。除此之外，多模态翻译在视频会议中可同步处理语音翻译、语气调整甚至画面中的文字替换。金融风控则是结合声纹特征、设备指纹、用户行为序列及多源一致性校验构建更立体的反欺诈体系，部分场景也在探索微表情等辅助信号。

图 19-3 PaddleOCR-VL 识别效果

（3）实体智能与出行：实体智能代表了 AI 从“数字世界”走向“物理世界”的关键一步，要求模型具备感知环境并执行动作的能力。自动驾驶以特斯拉（尽量减少对雷达依赖的视觉主导路线）和“蔚小理”（多传感器融合路线）为代表，行业虽然长期目标是 L5（完全自动驾驶，无需人类干预），但当前主流仍聚焦于 L2+/L3 的工程化落地，其中 L2+ 需要驾驶员持续监督，L3 在其 ODD（运行设计域）内可由系统监控环境但需要驾驶员在系统请求时接管。在感知层面，车辆需实时处理异构数据，视觉主导路线侧重于摄像头的深度挖掘，融合路线则进一步结合激光雷达和毫米波雷达以提升冗余度，完成路径规划与避障。机器人则涵盖了从商场导购机器人到家用扫地机等多种形态，不仅要“看”（视觉 SLAM 建图），还要“听”（语音指令识别），并结合触觉传感器与物理世界交互。更前沿的还有特斯拉 Optimus、宇树 G1等正在快速发展的具身智能（Embodied AI），趋势是用端到端（或弱分层）的策略模型把多模态感知（视觉/深度/力觉等）与动作决策连接起来，输出动作序列或关节控制指令，并在真实环境中通过数据驱动学习实现泛化与闭环控制。

图 19-4 Unitree H1

（4）科学与医疗探索：在对数据精度与隐私要求极高的专业领域，多模态技术也在辅助专家突破人类认知的边界。智慧医疗整合医学影像（CT/MRI）、电子病历（文本）与生化指标（结构化数据）辅助癌症筛查或病情预判，该领域的难点在于极低的容错率，必须严格抑制幻觉并引入人类专家复核（HITL）与可追溯证据机制。还有跨学科科研中，多模态模型可以被用于遥感/卫星图像与文本报告的联合分析（如灾害评估、土地覆盖变化），以及在生命科学中融合成像数据、组学表格、序列/结构信息与文献文本进行证据汇总、假设生成与实验设计，加速从研究到应用的闭环。