为 DeepSeek V4 Flash 加上视觉：40M 参数连接器实战

284B 总参数、13B 激活的纯文本 MoE 模型，能否在不触碰语言模型权重的前提下获得视觉能力？答案是------40M 参数的连接器、10 万训练样本、5 张 H200、2000 美元、20 小时。本文从架构设计、梯度传播数学推导、MoE 路由机制、BF16 精度约束、推理集成到效果评估，做一次完整的技术解剖。

形式化问题定义

设 DeepSeek V4 Flash 的参数为 $θLLM∈R284B \theta_{\text{LLM}} \in \mathbb{R}^{284B}$ θLLM∈R284B，MoonViT 的参数为 $θViT∈R417M \theta_{\text{ViT}} \in \mathbb{R}^{417M}$ θViT∈R417M，连接器参数为 $θconn∈R40M \theta_{\text{conn}} \in \mathbb{R}^{40M}$ θconn∈R40M。

训练目标：

$min⁡θconn L(θconn;θLLM,θViT)s.t.θLLM=const,θViT=const \min_{\theta_{\text{conn}}} \mathcal{L}(\theta_{\text{conn}}; \theta_{\text{LLM}}, \theta_{\text{ViT}}) \quad \text{s.t.} \quad \theta_{\text{LLM}} = \text{const}, \quad \theta_{\text{ViT}} = \text{const}$ minθconnL(θconn;θLLM,θViT)s.t.θLLM=const,θViT=const

其中 $L\mathcal{L}$ L 是文本生成的交叉熵损失，梯度仅对 $θconn \theta_{\text{conn}}$ θconn 求导，但梯度路径必须穿越冻结的 284B 参数------这是整个方案的核心数学约束。

问题的本质：纯文本模型的天花板

DeepSeek V4 Flash 是当前最强的开源 MoE 文本模型之一------284B 总参数、每次推理只激活 13B，在同等参数级别的模型中性价比极高。但它在架构层面有一个根本限制：只接受离散 token 输入，没有视觉感知通道。

这意味着它无法处理截图、图表、UI 界面、文档扫描件、手写公式、医学影像------任何需要"看"的任务。对于一个要做浏览器代理或文档分析的下游应用来说，这是致命的。

传统的解决方案是换一个原生视觉语言模型（VLM），比如 Qwen-VL 或 InternVL。但这意味着丢弃 DeepSeek 在文本推理上积累的全部能力------那些经过数百亿 token 训练得来的语言理解力。

核心问题：能否在 DeepSeek 的权重一个都不改的情况下，给它外挂一个"眼睛"？

答案藏在一个极其精简的模块里------一个仅 40,119,040 参数的 PatchMerger 连接器。

三组件架构：冻结一切，只训练连接器

整个视觉系统由三个组件构成，其中两个完全冻结，只有一个可训练：

组件一：MoonViT-3d 视觉编码器（417M，冻结）

MoonViT-3d 是一个 417M 参数的视觉 Transformer，已经在大规模多模态训练中验证过视觉-语言对齐质量。它的工作是将输入图片编码为一系列 patch 级别的特征向量：

输入：224×224 RGB 图片（经标准化预处理）
输出：N 个 1152 维 patch 特征向量（N 取决于图片分辨率和 patch 大小）
参数量：417M
状态：完全冻结，训练时不更新任何权重

为什么选 MoonViT 而不是 CLIP 或 SigLIP？因为 MoonViT 输出的 1152 维特征已经在大规模多模态训练中验证过视觉-语言对齐质量。复用一个已经"懂"视觉-语言映射的编码器，比从零训练一个新编码器效率高得多。

组件二：PatchMerger 连接器（40.1M，可训练）

这是整个系统唯一被训练的部分。它的任务听起来简单：把 MoonViT 输出的 1152 维视觉特征"翻译"成 DeepSeek 能理解的 4096 维 token 嵌入。

但这个"翻译"不是简单的线性映射。连接器需要同时完成三件事：

维度对齐：从 1152 维（MoonViT 空间）映射到 4096 维（DeepSeek 嵌入空间）
粒度压缩：将过多的视觉 patch 合并为更少的 token，避免视觉信息淹没语言模型的上下文
语义转换：让输出的向量在 DeepSeek 的嵌入空间中"看起来像"自然语言的 token 嵌入------这样 DeepSeek 的注意力机制才能正确处理它们

连接器的内部结构极其精简------只有 5 层：

scss 复制代码

LayerNorm → 2×2 Patch Merge → Linear(4608, 4608) → GELU → Linear(4608, 4096)

数学视角：每一层的精确变换

设 MoonViT 输出为 $X∈RN×1152\mathbf{X} \in \mathbb{R}^{N \times 1152}$ X∈RN×1152，其中 N 为 patch 数量。

LayerNorm：

$X′=γ⊙ X−μ σ2+ϵ +β \mathbf{X}' = \gamma \odot \frac{\mathbf{X} - \mu}{\sqrt{\sigma^2 + \epsilon}} + \beta$ X′=γ⊙σ2+ϵ X−μ+β

其中 $μ,σ2\mu, \sigma^2$ μ,σ2 沿特征维度计算， $γ,β∈R1152\gamma, \beta \in \mathbb{R}^{1152}$ γ,β∈R1152 为可学习参数（2×1152 = 2,304 个参数）。 $ϵ=10−6\epsilon = 10^{-6}$ ϵ=10−6 防止除零。这一步的数学意义：将不同图片的 MoonViT 输出统一到均值 0、方差 1 的分布，消除不同图片间特征幅值的巨大差异。

2×2 Patch Merge：

将相邻的 2×2 patch 拼接为一个长向量：

$X′′∈RN/4×4608, Xi′′ =$ $Xi1' ; Xi2' ; Xi3' ; Xi4'$ \mathbf{X}'' \in \mathbb{R}^{N/4 \times 4608}, \quad \mathbf{X}''_i = $\\mathbf{X}'_{i_1}; \\mathbf{X}'_{i_2}; \\mathbf{X}'_{i_3}; \\mathbf{X}'_{i_4}$ X′′∈RN/4×4608,Xi′′= $Xi1';Xi2';Xi3';Xi4'$

其中 $i1,i2,i3,i4 i_1, i_2, i_3, i_4$ i1,i2,i3,i4 是第 $ii$ i 组的四个相邻 patch 索引。这一步无参数，但完成了两个关键功能：(1) token 数量压缩 4 倍（N → N/4），(2) 特征维度从 1152 升到 4608，为后续 MLP 提供更大的工作空间。

Linear(4608, 4608) + GELU：

$H=GELU(X′′W1+b1),W1∈R4608×4608,b1∈R4608\mathbf{H} = \text{GELU}(\mathbf{X}'' \mathbf{W}_1 + \mathbf{b}_1), \quad \mathbf{W}_1 \in \mathbb{R}^{4608 \times 4608}, \quad \mathbf{b}_1 \in \mathbb{R}^{4608}$ H=GELU(X′′W1+b1),W1∈R4608×4608,b1∈R4608

$GELU(x)=x⋅Φ(x)=x⋅12$ $1+erf ( x2 )$ \text{GELU}(x) = x \cdot \Phi(x) = x \cdot \frac{1}{2}\left $1 + \\text{erf}\\left(\\frac{x}{\\sqrt{2}}\\right)\\right$ GELU(x)=x⋅Φ(x)=x⋅21 $1+erf(2 x)$

GELU 的梯度： $ddx GELU(x)=Φ(x)+x⋅ϕ(x) \frac{d}{dx}\text{GELU}(x) = \Phi(x) + x \cdot \phi(x)$ dxdGELU(x)=Φ(x)+x⋅ϕ(x)，其中 $ϕ(x)\phi(x)$ ϕ(x) 是标准正态密度函数。这保证了梯度在零点附近平滑过渡，不会像 ReLU 那样出现梯度突变。参数量：4608×4608 + 4608 = 21,238,272。

Linear(4608, 4096)：

$E=HW2+b2,W2∈R4608×4096,b2∈R4096 \mathbf{E} = \mathbf{H} \mathbf{W}_2 + \mathbf{b}_2, \quad \mathbf{W}_2 \in \mathbb{R}^{4608 \times 4096}, \quad \mathbf{b}_2 \in \mathbb{R}^{4096}$ E=HW2+b2,W2∈R4608×4096,b2∈R4096

参数量：4608×4096 + 4096 = 18,878,464。

总参数量 ：2,304 + 21,238,272 + 18,878,464 = 40,119,040 。占 284B 的 0.014%。

为什么是两层 MLP 而不是一层线性映射？

单层线性映射 $Linear(1152,4096)\text{Linear}(1152, 4096)$ Linear(1152,4096) 的参数量仅 4.7M，但它的表达能力被严格限制：它只能学习线性变换 ------旋转、缩放、平移。而视觉特征到语言嵌入空间的映射本质上是非线性的：MoonViT 空间中的语义簇和 DeepSeek 空间中的语义簇不是简单的线性对应关系。

两层 MLP（4608→4608→4096）引入了 GELU 非线性，理论上可以逼近任意连续映射（Universal Approximation Theorem）。参数从 4.7M 增加到 40M，换取的是从线性映射到非线性映射的质变。

组件三：DeepSeek V4 Flash 语言模型（284B，冻结）

DeepSeek V4 Flash 是一个 MoE（Mixture of Experts）架构的语言模型：

总参数：284B（分布在数百个专家网络中）
每次激活参数：13B（每个 token 只路由到少量专家）
嵌入维度：4096
状态：完全冻结，训练时不更新任何权重

MoE 架构的关键特征是路由：每个 token 根据自身特征被分配到不同的专家网络处理。这个机制在视觉集成时带来了一个意想不到的挑战------后面会详细展开。

为什么这个设计可行？

这个三组件设计的核心洞察是：视觉-语言对齐的信息量远比想象的小。

传统 VLM 从头训练整个模型，需要学习视觉编码、语言理解和跨模态对齐------三个维度同时优化，数据需求巨大。而这个设计把问题降维了：

视觉编码 → 已经有人做好了（MoonViT），直接用
语言理解 → 已经有人做好了（DeepSeek），直接用
只需要学习 → 如何把视觉特征"翻译"成语言模型能理解的格式

这个翻译函数的复杂度远低于视觉理解本身。40M 参数足够学习一个高质量的维度映射------尤其是在嵌入空间维度接近的情况下。

连接器内部结构与数据流

让我们追踪一张图片从输入到输出经历的每一次维度变换：

完整数据流追踪

text 复制代码

输入图片 (224×224×3)
    ↓ MoonViT 编码
patch 特征序列 (N × 1152)         ← N=512 (最大)
    ↓ LayerNorm (无参数约束计算)
归一化特征 (N × 1152)
    ↓ 2×2 Patch Merge (4 个 patch 拼接 → 无参数)
合并特征 (N/4 × 4608)             ← 128 × 4608
    ↓ Linear(4608 → 4608) + GELU
中间表示 (N/4 × 4608)             ← 128 × 4608
    ↓ Linear(4608 → 4096)
DeepSeek 嵌入 (N/4 × 4096)        ← 128 × 4096
    ↓ 插入 DeepSeek 输入序列 (128视觉 + 1920文本 = 2048)
语言模型注意力计算 (MoE 路由)
    ↓ DeepSeek 生成
文本输出

张量形状的精确推导

以 N=512 个 patch 为例，追踪每一步的张量形状：

步骤	张量形状	元素数	参数量
输入图片	$1, 3, 224, 224$	150,528	0 (MoonViT 冻结)
MoonViT 输出	$1, 512, 1152$	589,824	0 (冻结)
LayerNorm 输出	$1, 512, 1152$	589,824	2,304
2×2 合并后	$1, 128, 4608$	589,824	0
Linear1 输出	$1, 128, 4608$	589,824	21,238,272
GELU 输出	$1, 128, 4608$	589,824	0
Linear2 输出	$1, 128, 4096$	524,288	18,878,464
插入 DeepSeek	$1, 2048, 4096$	8,388,608	0 (DeepSeek 冻结)

注意 2×2 合并这一步：元素总数不变（589,824），但形状从 $512, 1152$ 变为 $128, 4608$ ------空间分辨率降 4 倍，特征维度升 4 倍。这是一个信息无损的 reshape 操作，但为后续 MLP 提供了更大的线性变换空间。

视觉 token 预算的注意力分析

训练时最大序列长度 2048 token------其中视觉占 128 个，文本占 1920 个。这意味着在 DeepSeek 的自注意力机制中：

$Attention(Q,K,V)=softmax ( QKT dk ) V\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$ Attention(Q,K,V)=softmax(dk QKT)V

每个文本 token 的注意力权重分布中，视觉 token 占 128/2048 ≈ 6.25%。这个比例经过精心设计：

太高（如 50%）→ 视觉信息淹没文本上下文，模型变成"图片描述器"而非"图文推理器"
太低（如 1%）→ 视觉信号太弱，模型容易忽略图片内容
6.25% → 视觉信息作为辅助信号，与文本推理能力平衡

2×2 合并的信息论分析

从信息论角度，2×2 合并不是简单的丢弃信息。设单个 patch 的信息量为 $II$ I，合并后的 4608 维向量保留了 4 个 patch 的全部信息（只是 reshape）。真正压缩发生在 Linear1 的线性变换中------4608→4608 的矩阵乘法可以学习丢弃冗余信息、保留语义特征。

关键洞察：空间压缩（2×2）和语义压缩（Linear）是解耦的。2×2 合并做空间压缩，Linear 层做语义压缩。这比直接用 stride 卷积同时做两种压缩更灵活------因为 Linear 层可以学习不同 patch 之间的相关性权重。

训练数据：10 万样本的秘密

数据来源与构成

训练数据从一个大规模多源视觉-语言数据集中采样 100,000 个样本。这个数据集是一个混合体，包含：

通用图片问答和描述：教模型理解图片内容和生成描述
OCR 和文字密集型图片：让模型能"读"图片中的文字
文档和信息图：理解结构化布局和流程
图表、曲线图和示意图：理解数据可视化
科学问题：需要视觉推理的多步骤推理
空间推理：理解物体之间的位置关系
网站截图和 UI 描述：识别界面元素和交互控件

关键发现：10 万 ≠ 10 万张不同图片

一个容易被忽视的细节：100,000 个训练样本只包含 39,619 张唯一图片。

这是因为该数据集的某些子集会对同一张图片提出多个不同的问题。例如同一张街景图片，可能有一个"这张图片里有什么？"的问题，还有一个"左边的招牌写了什么？"的问题。

这个发现有两个重要影响：

有效视觉多样性只有 39K------远低于表面上的 100K
训练时同一图片的特征被重复使用------这直接启发了特征预缓存策略

特征预缓存：省掉 60% 的前向计算

这是整个工程中最聪明的优化之一------其数学基础是函数确定性。

MoonViT 是冻结的，即 $θViT=const \theta_{\text{ViT}} = \text{const}$ θViT=const。因此对于同一张图片 $Ik I_k$ Ik，MoonViT 的输出是确定性函数：

$Xk= fθViT (Ik)(确定性映射) \mathbf{X}$ k = f{\theta_{\text{ViT}}}(I_k) \quad \text{(确定性映射)} Xk=fθViT(Ik)(确定性映射)

无论在训练的哪一步， $Xk \mathbf{X}_k$ Xk 的值完全相同。这意味着 MoonViT 的前向计算在每个样本上只需执行一次。

优化方案：训练开始前，预计算所有 39,619 张唯一图片的 MoonViT 输出，存储为磁盘上的张量文件：

python 复制代码

# 伪代码
for img_id in unique_images:  # 39,619 次
    features[img_id] = moonvit.forward(img)  # 一次前向
    torch.save(features[img_id], f"cache/{img_id}.pt")

# 训练时
def get_sample(sample):
    return load_cache(sample.img_id), sample.question, sample.answer  # 零编码器计算

计算节省分析：

环节	无缓存	有缓存	节省
MoonViT 前向	100,000 次	39,619 次	60.4%
训练时 GPU 计算	ViT(417M) + 连接器(40M) + DeepSeek(284B)	连接器(40M) + DeepSeek(284B)	~60% 前向
显存占用	需容纳 ViT 激活	不需容纳 ViT	显著降低

缓存大小：39,619 × 512 × 1152 × 2 bytes (BF16) ≈ 46.8 GB，可轻松存储在 SSD 上。

训练参数

指标	数值	设计考量
可训练参数	40,119,040	仅连接器，语言模型和视觉编码器冻结
训练样本	100,000	大规模多源数据集采样
Epoch	1	单轮训练，避免在有限数据上过拟合
全局批大小	128	5× H200 每卡 batch=25.6，BF16 精度
优化器步数	782	100K / 128 ≈ 781.25
优化器	AdamW	β1=0.9, β2=0.999, weight_decay=0.01
学习率	1e-3	较高 lr 因为只训练小模块，收敛快
精度	BF16	必须用 BF16 而非 FP8------梯度需要完整精度
硬件	5× H200	141GB HBM3e 每卡，足够放 284B MoE 的 BF16 权重
吞吐量	~4,938 样本/小时	包含前向+反向+优化器更新
理论运行时间	~20.25 小时	100K / 4938
总支出	~$2,000	H200 租赁约 $20/h × 5 卡 × 20h（含数据存储、网络传输等开销）

损失函数的数学形式

训练使用标准的下一 token 预测（next-token prediction）交叉熵损失：

$L=−1T ∑t=1T log⁡P(yt∣ y<t ,Evisual,θLLM,θconn) \mathcal{L} = -\frac{1}{T} \sum_{t=1}^{T} \log P(y_t | y_{<t}, \mathbf{E}$ {\text{visual}}, \theta{\text{LLM}}, \theta_{\text{conn}}) L=−T1∑t=1TlogP(yt∣y<t,Evisual,θLLM,θconn)

其中 $TT$ T 是目标文本序列长度， $Evisual \mathbf{E}_{\text{visual}}$ Evisual 是连接器输出的视觉嵌入序列， $yt y_t$ yt 是第 $tt$ t 个目标 token。梯度路径：

$∂L ∂θconn = ∂L∂Logits ⋅ ∂Logits ∂Evisual ⋅ ∂Evisual ∂θconn ⏟ 连接器局部梯度 \frac{\partial \mathcal{L}}{\partial \theta_{\text{conn}}} = \frac{\partial \mathcal{L}}{\partial \text{Logits}} \cdot \frac{\partial \text{Logits}}{\partial \mathbf{E}$ {\text{visual}}} \cdot \underbrace{\frac{\partial \mathbf{E}{\text{visual}}}{\partial \theta_{\text{conn}}}}_{\text{连接器局部梯度}} ∂θconn∂L=∂Logits∂L⋅∂Evisual∂Logits⋅连接器局部梯度 ∂θconn∂Evisual

中间项 $∂Logits ∂Evisual \frac{\partial \text{Logits}}{\partial \mathbf{E}_{\text{visual}}}$ ∂Evisual∂Logits 就是穿越 284B 冻结模型反向传播的雅可比矩阵------这是为什么必须用 BF16 而非 FP8 的根本原因。

训练损失从 1.0225 降至 0.8301------下降幅度约 18.8%，表明连接器在有效学习视觉到语言的映射。但 0.83 的绝对值仍然偏高，说明映射质量有改进空间。

学习率为什么用 1e-3？从 AdamW 优化器的更新公式来看：

$θt+1 =θt−η⋅ m^t v^t +ϵ \theta_{t+1} = \theta_t - \eta \cdot \frac{\hat{m}_t}{\sqrt{\hat{v}_t} + \epsilon}$ θt+1=θt−η⋅v^t +ϵm^t

其中 $η=10−3\eta = 10^{-3}$ η=10−3， $m^t \hat{m}_t$ m^t 和 $v^t \hat{v}_t$ v^t 是偏差校正后的一阶和二阶矩估计。对于 40M 参数，782 步足以让 AdamW 的二阶矩估计收敛到稳定状态。只训练 40M 参数，梯度信号的信噪比高（没有 284B 参数的噪声干扰），可以用较大学习率快速收敛。如果训练整个模型，1e-3 会导致发散；但只训练小模块时，这个学习率恰好。

工程挑战：不是即插即用

"冻结大模型 + 训练小连接器"听起来简单，但实际工程中有三个非平凡的技术障碍。

挑战一：梯度需要穿越冻结的 284B 模型

问题本质：连接器的梯度来自 DeepSeek 的损失函数。用链式法则表达：

$∂L ∂θconn = ∂L∂E ⋅ ∂E ∂θconn ⏟ 连接器局部 \frac{\partial \mathcal{L}}{\partial \theta_{\text{conn}}} = \frac{\partial \mathcal{L}}{\partial \mathbf{E}} \cdot \underbrace{\frac{\partial \mathbf{E}}{\partial \theta_{\text{conn}}}}_{\text{连接器局部}}$ ∂θconn∂L=∂E∂L⋅连接器局部 ∂θconn∂E

其中 $∂L∂E \frac{\partial \mathcal{L}}{\partial \mathbf{E}}$ ∂E∂L 是损失对连接器输出 $E\mathbf{E}$ E 的梯度，它必须通过 DeepSeek 的全部层反向传播才能获得。DeepSeek 是 284B 参数的 MoE 模型，反向传播穿过它的每一层------即使权重不更新，梯度仍然需要流过。

为什么 FP8/NVFP4 不行：DeepSeek 的推理版本使用 FP8 或 NVFP4 量化来压缩模型体积。量化操作的前向计算可以表示为：

$y=Quantize(W)⋅x+dequantize(b)\mathbf{y} = \text{Quantize}(\mathbf{W}) \cdot \mathbf{x} + \text{dequantize}(\mathbf{b})$ y=Quantize(W)⋅x+dequantize(b)

但量化函数 $Quantize(⋅)\text{Quantize}(\cdot)$ Quantize(⋅) 是分段常数函数------几乎处处导数为零。这意味着反向传播时：

$∂y∂x =Quantize(W)T(权重被量化后视为常数) \frac{\partial \mathbf{y}}{\partial \mathbf{x}} = \text{Quantize}(\mathbf{W})^T \quad \text{(权重被量化后视为常数)}$ ∂x∂y=Quantize(W)T(权重被量化后视为常数)

FP8 推理内核（如 FlashInfer 的 FP8 GEMM）只实现了这个前向计算和直接权重梯度，但没有实现输入梯度 $∂y∂x \frac{\partial \mathbf{y}}{\partial \mathbf{x}}$ ∂x∂y。没有输入梯度，梯度信号无法从一个层传到前一个层，反向传播链断裂在量化层。

解决方案：使用 BF16 精度版本的 DeepSeek。BF16 的前向和反向都是标准浮点运算：

$Forward:y=WBF16⋅x+bBackward: ∂y∂x =WBF16T \text{Forward}: \mathbf{y} = \mathbf{W}$ {\text{BF16}} \cdot \mathbf{x} + \mathbf{b} \quad \text{Backward}: \frac{\partial \mathbf{y}}{\partial \mathbf{x}} = \mathbf{W}{\text{BF16}}^T Forward:y=WBF16⋅x+bBackward:∂x∂y=WBF16T

BF16 完整支持输入梯度计算，反向传播链完整。代价是模型体积更大（BF16 权重是 FP8 的两倍），需要更多 GPU 显存------这就是为什么需要 5× H200（141GB HBM3e 每卡，5×141=705GB，足够容纳 284B BF16 权重约 568GB）。

精度对比：

精度	每参数字节数	284B 模型体积	前向	反向(输入梯度)	适用场景
FP8	1 byte	~284 GB	✅	❌	推理
NVFP4	0.5 byte	~142 GB	✅	❌	B200 推理
BF16	2 bytes	~568 GB	✅	✅	训练
FP32	4 bytes	~1,136 GB	✅	✅	精度敏感训练

深层洞察：这是一个量化与可微性之间的根本矛盾。量化是为了推理效率（减小模型体积、加速 GEMM），但量化内核通常牺牲梯度计算能力。任何"冻结大模型 + 训练小模块"的方案都会遇到这个问题。解决方案要么用全精度训练（成本高），要么自己实现量化内核的反向传播（需要自定义 CUDA/Triton 内核，工程量巨大）。

挑战二：Hash-MoE 路由的视觉 token ID 问题

问题本质：DeepSeek 的 MoE 架构使用一种基于哈希的路由机制。标准 MoE 的路由公式为：

$Expert(x)= ∑i∈TopK(g(x)) gi(x)⋅Ei(x)\text{Expert}(\mathbf{x}) = \sum_{i \in \text{TopK}(\mathbf{g}(\mathbf{x}))} g_i(\mathbf{x}) \cdot E_i(\mathbf{x})$ Expert(x)=∑i∈TopK(g(x))gi(x)⋅Ei(x)

其中 $g(x)\mathbf{g}(\mathbf{x})$ g(x) 是门控函数。但 DeepSeek 的 Hash-MoE 变体不同------它不使用输入特征 $x\mathbf{x}$ x 来路由，而是使用 token 的离散 ID：

$}) \mod N_{\text{experts}}$ route(token)=h(token.ID)modNexperts

其中 $h(⋅)h(\cdot)$ h(⋅) 是一个哈希函数， $Nexperts N_{\text{experts}}$ Nexperts 是专家数量。这个设计有两个优点：(1) 路由不受输入特征影响，训练更稳定；(2) 相同的 token ID 永远路由到相同的专家，形成语义聚类。

但视觉嵌入是连续向量------它们没有 token ID。没有 token ID，哈希函数 $h(⋅)h(\cdot)$ h(⋅) 无法计算，MoE 路由器不知道把视觉 token 发给哪个专家。

解决方案：为视觉 token 分配确定性的路由 ID。

文本位置：保留原始的 token ID 和对应路由
图像位置：从一组固定的 64 个 ID 组成的"调色板"中循环分配

具体来说，128 个视觉 token 的第 $ii$ i 个 token 分配的 ID 为：

$IDi=palette$ $imod 64$ \text{ID}_i = \text{palette} $i \\mod 64$ IDi=palette $imod64$

这确保了：(1) 128 个视觉 token 只使用 64 个不同的 ID，每个 ID 出现恰好 2 次；(2) 相同位置的视觉 token 在不同样本中路由一致。

为什么是 64 个 ID ？设 MoE 有 $MM$ M 个专家，每个 token 选择 Top-K 个专家。有效专家利用率为：

$Utilization= min⁡(NIDs,M) M ×100% \text{Utilization} = \frac{\min(N_{\text{IDs}}, M)}{M} \times 100\%$ Utilization=Mmin(NIDs,M)×100%

太少（4 个 ID）→ 视觉 token 只触及 4 个专家，路由多样性不足，视觉信息处理能力受限
太多（4096 个 ID）→ 视觉 token 分散到过多专家，每个专家只看到极少视觉样本，统计信号不足以学习视觉模式
64 个 → 在路由多样性（触及 64 个专家）和样本密度（每专家 2 个视觉 token/样本）之间取得平衡

深层洞察：这是 MoE 架构特有的集成难题。稠密模型（如 LLaMA）不存在这个问题------所有 token 通过同一个网络，连续嵌入直接输入即可。但 MoE 的路由机制假设输入来自词表的离散 ID，连续嵌入打破了这一假设。

更根本的问题在于：Hash 路由假设 ID 携带语义信息（"苹果"和"水果"天然路由到相关专家），但视觉 token 的 ID 是人为分配的------它们不携带语义。64 个 ID 只是让路由在物理上可行，但不保证路由质量。长期来看，MoE 模型如果要原生支持视觉，可能需要在架构层面修改路由机制------比如让路由器直接接受连续嵌入而非 token ID，使用学习式门控 $g(x)g(\mathbf{x})$ g(x) 替代哈希路由。

挑战三：推理引擎集成

问题本质：标准推理引擎（SGLang、vLLM）的输入管线是：

text 复制代码

token IDs → [词表查找] → embedding 查表 → [模型 forward] → logits → 采样 → 输出 token

这个管线有一个硬编码假设：输入是离散的 token ID，通过词表查表得到嵌入。视觉嵌入是连续向量，不经过词表------直接把 4096 维向量塞进去会破坏整个输入管线。

解决方案：需要三件自定义代码，分别在管线的三层插入分支：

自定义图像处理器（替换词表查表）：

python 复制代码

def process_image(image_path):
    img = load_and_preprocess(image_path)  # 224x224 归一化
    features = moonvit.forward(img)          # [1, N, 1152] 冻结推理
    embeddings = connector.forward(features) # [1, N/4, 4096] 连接器
    return embeddings  # 直接输出 4096 维向量，绕过词表

模型包装器（修改 forward 函数）：

python 复制代码

def deepseek_forward_with_vision(input_ids, visual_embeddings, visual_positions):
    text_embeddings = embedding_table[input_ids]  # 文本token正常查表
    full_embeddings = torch.zeros(seq_len, 4096)
    full_embeddings[visual_positions] = visual_embeddings  # 视觉位置插入
    full_embeddings[text_positions] = text_embeddings     # 文本位置正常
    # 同时构建路由ID序列：文本保留原始ID，视觉用64-ID调色板
    route_ids = build_route_ids(input_ids, visual_positions)
    return deepseek.forward(full_embeddings, route_ids)

SGLang 集成补丁（修改请求处理管线）：

python 复制代码

# 伪代码：在SGLang的请求处理中插入视觉分支
def handle_vision_request(request):
    if request.has_image:
        visual_emb = process_image(request.image_path)
        visual_pos = compute_positions(request.text, request.image)
        return deepseek_forward_with_vision(
            request.input_ids, visual_emb, visual_pos
        )
    else:
        return standard_forward(request.input_ids)  # 纯文本走标准路径

这三层修改形成了一个完整的视觉推理管线：图像处理器负责"看"，模型包装器负责"嵌入融合"，SGLang 补丁负责"请求路由"。这些集成代码不是"连接器方法失效"的证据------它们是把研究成果变成可用产品时的必要工程工作。任何新的模型架构在部署时都需要类似的推理引擎适配。

实际效果：基础但可用

成功案例

这个 40M 连接器 + 100K 样本训练的系统已经能完成以下任务：

街景理解：输入街景照片，能识别人物、箱子和店面招牌------说明连接器学到了从视觉特征到物体概念的映射
UI 控件识别：输入浏览器截图，能找到侧边栏中的"Upload file"按钮------说明它理解了 UI 元素的视觉语义
表单定位：能回答 UI 定位问题，识别出正确的表单字段和当前打开的菜单------说明它有一定空间推理能力

推理性能

一个 36-token 的图片回复响应耗时 7.49 秒，约 4.81 token/s。这个速度在 284B MoE 模型上是合理的------MoE 的推理速度主要取决于激活参数量（13B）而非总参数量（284B）。

当前局限

但 100K 样本训练的结果不是生产质量的 VLM。主要问题：

答案太短：模型倾向于生成简短回答，缺乏详细描述
OCR 不可靠：小文字识别经常出错------训练数据中 OCR 样本占比不够
视觉幻觉：编造不存在的视觉细节------这是数据多样性不足导致的过拟合症状
复杂 GUI 定位失败：在密集界面中准确定位元素仍然困难

这些问题的根源都是同一个：训练数据不够。

数据瓶颈分析：为什么 10 万样本不够

有效视觉多样性只有 39K

100,000 个样本只有 39,619 张唯一图片。这意味着连接器实际上只"看过"不到 4 万种不同的视觉模式。作为对比：

GPT-4V 的训练数据量级在数亿张图片
Qwen-VL 的预训练阶段使用了 1.4B 图片-文本对
LLaVA-1.5 用了 558K 图片-文本对------已经比本项目的 39K 多 14 倍

39K 张唯一图片无法覆盖的视觉场景：

网站和应用界面的多样性（数百万种不同布局）
文档、表格和图表的结构变化
多分辨率 OCR（不同字号、字体、背景）
精确的空间定位问答
复杂场景中的物体关系
多步视觉指令（先看 A，再看 B，比较两者）
需要抑制幻觉的困难负样本（"图片中不存在 X" 类型的问题）

从 100K 到 1M 的成本推演

直接训练时间外推：

100K 样本 → 20.25 小时（5× H200）
1M 样本 → 202.5 小时 ≈ 8.4 天连续训练
1M 样本的理论成本 → ~$20,000（GPU 时间线性外推，含数据存储和网络开销）

实际完整预算：

训练不只是跑 forward+backward。一个严肃的 1M 样本训练计划还需要：

数据集策展和清洗：从多源收集、去重、质量筛选 → 1-2 周
高分辨率 MoonViT 特征预缓存：1M 张图片跑 MoonViT → 约 50 小时 GPU
学习率和架构试验：至少 3-5 次小规模试验 → ~$2,000
至少一次消融实验：验证关键设计选择 → ~$1,000
最终训练 ：8.4 天 × 5 H200 → ~ $20,000（线性外推20,000（线性外推$ 20,000（线性外推2,000 × 10 倍样本量）
正式评估：在标准 VLM benchmark 上跑完整评估 → ~$500
B200 部署验证：在新硬件上验证推理 → ~$1,000

总预算估计： $22,000--22,000--$ 22,000--25,000

这仍然远低于从零训练一个 VLM 的成本（通常 $100K+）。

与同类方案对比

同类方案对比：稠密模型 vs MoE 模型的视觉集成

这个"冻结大模型 + 训练连接器"的范式已在稠密模型上验证过可行。一个类似的设计此前应用于 GLM-5.2 语言模型------冻结 GLM-5.2 + 冻结 MoonViT + 训练 49.5M PatchMerger 连接器。

对比项	GLM-5.2 方案	DeepSeek 方案
语言模型	GLM-5.2	DeepSeek V4 Flash
总参数	~200B	284B
活跃参数	~12B	13B
嵌入维度	6144	4096
连接器参数	49.5M	40.1M
MoonViT 输出	1152 维	1152 维
路由方式	标准稠密	Hash-MoE 自定义
部署方式	标准推理	SGLang 补丁

GLM-5.2 是稠密模型（非 MoE），所以不需要处理路由 ID 问题。将同样的设计适配到 MoE 架构的 DeepSeek 上，需要额外解决 Hash-MoE 路由和 SGLang 集成两个工程挑战------这两个挑战是 MoE 架构特有的。

Laguna XS 2.1：同方法的轻量验证

同一方法还应用到了更小的 Laguna XS 2.1 模型上，验证了方法的通用性：

指标	DeepSeek V4 Flash	Laguna XS 2.1
总参数	284B	33B
激活参数	13B	3B
连接器参数	40.1M	30.7M
训练样本	100K	100K
优化器步数	782	782
最终损失	0.8301	0.7318

Laguna 的最终损失更低（0.73 vs 0.83），可能原因：

Laguna 只有 33B 参数，嵌入空间更小，映射更容易学
更小的模型可能对视觉信息的容忍度更高------不需要像 DeepSeek 那样精确对齐到极复杂的嵌入流形
但这也可能意味着 Laguna 的视觉理解上限更低------更大的模型有更高的表示天花板

Laguna 版本的长期目标是在单张 96GB Blackwell GPU 上运行------这意味着完整的视觉推理可以在一张消费级/专业级 GPU 上完成。

部署方式

B200 部署配置

在 NVIDIA B200 GPU 上的部署需要以下环境配置：

bash 复制代码

# 模型路径
export DEEPSEEK_VISION_MODEL_PATH=/models/deepseek-v4-flash-vision

# 自定义 SGLang 扩展代码路径
export DEEPSEEK_VISION_PYTHONPATH="$DEEPSEEK_VISION_MODEL_PATH/sglang_ext"

# 量化内核配置（B200 原生内核）
export DEEPSEEK_VISION_KERNEL_PROFILE=blackwell-native

# 张量并行度（B200 单卡可放 NVFP4 量化后的 284B）
export DEEPSEEK_VISION_TP=4

# 启动推理服务
scripts/launch_sglang_moonvit.sh

推理后端使用 flashinfer_trtllm 密集后端处理专家网络，flashinfer_trtllm_routed 处理 MoE 路由。这两个后端针对 Blackwell 架构做了优化，支持 NVFP4 量化推理。

模型权重

所有模型权重已开放下载：

DeepSeek-V4-Flash-Vision-NVFP4 --- NVFP4 量化版（含视觉塔 291B 参数，适合 B200 部署）
DeepSeek-V4-Flash-Vision-BF16 --- BF16 完整精度版（视觉塔和连接器，用于训练）
DeepSeek-V4-Flash-0731-Vision-NVFP4 --- 0731 基座版本
Laguna-XS-2.1-Vision-NVFP4 --- Laguna 轻量版本

深层技术启示

1. 视觉能力是"可插拔"模块

这个项目最有价值的发现：视觉感知可以作为一个独立模块附加到任何强大的文本模型上。

传统观点认为视觉-语言对齐需要端到端联合训练------视觉编码器、连接器、语言模型三者一起更新梯度。这个项目证明了：只要视觉编码器足够好（MoonViT 已经在大规模多模态训练中做过对齐），连接器只需要学习一个映射函数。

这意味着任何强大的文本模型------无论是 DeepSeek、LLaMA、Qwen 还是 Mistral------都可以用同样的方法"升级"成 VLM，成本仅需几千美元。

2. 0.014% 的参数效率

40M 参数 vs 284B 总参数 = 0.014%。这个比例揭示了一个深刻的道理：

视觉-语言对齐的信息瓶颈不在映射函数的复杂度，而在数据的质量和多样性。

连接器不需要"理解"视觉------MoonViT 已经理解了。连接器不需要"理解"语言------DeepSeek 已经理解了。连接器只需要学习："MoonViT 空间中的哪个方向"对应"DeepSeek 嵌入空间中的哪个方向"。这是一个相对低维的映射问题，40M 参数绰绰有余。

对比：从头训练一个 VLM 需要数十亿参数和数亿样本------因为需要同时学习视觉、语言和对齐三个维度。而冻结两个预训练组件后，只需要学习对齐这一个维度，参数需求降低 4 个数量级。

3. 数据是瓶颈，不是架构

最终损失 0.83 偏高，OCR 不可靠，视觉幻觉------这些问题都不是连接器架构的缺陷。如果给同样的 40M 连接器喂 1M 精心策展的数据，这些问题大概率会大幅改善。

这给整个 VLM 领域的一个重要信号：当你的模型架构已经合理时，接下来最值得投入的不是改架构，而是改数据。

4. MoE 架构的视觉集成有独特挑战

稠密模型加视觉能力相对直接------只需要在输入层插入视觉嵌入，注意力机制会自动处理。但 MoE 的 Hash 路由机制假设输入有离散 token ID，视觉嵌入打破了这个假设。

本文的 64-ID 调色板方案是一个实用但临时的解决方案。长期来看，MoE 模型如果要原生支持视觉，可能需要在架构层面修改路由机制------比如让路由器直接接受连续嵌入而非 token ID。

未来路线图

下一步计划使用约 100 万精心策展的图片-文本样本进行训练，重点加强以下方面：

网站和应用界面：提高 UI 元素识别准确率
文档、表格和图表：增强结构化内容理解
多分辨率 OCR：覆盖不同字号和字体的文字识别
定位问答：精确到像素级的物体定位
空间关系：理解上下左右、前后遮挡等空间概念
自然场景和物体：提升通用视觉理解能力
多步视觉指令：支持"先看 A，再看 B，比较两者"的复杂指令
困难负样本：训练模型正确回答"图片中不存在 X"，抑制幻觉

但 100 万样本不会自动让它与 Qwen3.6-VL 竞争。数据质量、分辨率、视觉 token 预算、连接器架构和训练目标------每个维度都需要精心设计。

结论

这个项目证明了一个简洁有力的观点：强大的纯文本模型可以通过一个极小的连接器获得视觉能力。

40M 参数、100K 样本、2000 美元------这在 VLM 研究中是极低的成本。但它的价值不在于"又一个 VLM"，而在于它验证了一个范式：

你不需要从头训练一个多模态模型。你可以选择最好的文本模型、最好的视觉编码器，然后花几千美元训练一个连接器把它们连起来。

这个范式如果成立，意味着：

任何新发布的强大文本模型都可以在几天内获得视觉能力
视觉能力的升级不再需要从头训练，只需重训 40M 连接器
中小团队也能负担 VLM 的创建成本
整个开源社区的 VLM 门槛将大幅降低

让任何强大的文本模型都能"看"到世界------这是这个项目留下的最宝贵的遗产。