多模态模型视觉token压缩技术

可视化演示

展示视觉Token从压缩前到压缩后的流动过程，以及压缩率与信息保留的权衡关系

压缩缘起：图解token爆炸

王姐经营一家“智能厨房”。她新接了一套豪华业务：顾客传来一张 4K 高清美食照片，后厨要根据照片出菜。但照片进了后厨，先被切成密密麻麻的小方块——每一个小方块都是一个“食材块”，也就是 AI 术语里的视觉token。一张高清图轻松产生几千到几万个食材块。更麻烦的是，每次分析图片，后厨都要让所有食材块两两“打招呼”（自注意力计算）。几万个块互相打招呼，灶台（显存）瞬间被塞满，出餐（推理）慢如蜗牛王姐急需一套菜单精简方案。

专业地说，把图片编码成视觉token是大模型“看懂”图片的第一步，但token数量直接决定了后续 Transformer 层的计算量。设token数量为 N，自注意力的时间开销是 O(N²) 级别——N 翻倍，开销翻 4 倍。高分辨率图片带来的正是这种平方级灾难。这也是为什么“高清图+大模型”的组合在工程上如此昂贵：不是模型不想看细节，是计算量不允许。

为了量化问题，引入模型计算量的度量公式：

$$\displaystyle T(N) = O\left(N^{2} \times d\right)$$

其中 N 是视觉 token 数量，d 是每个 token 的特征维度。N 越大，计算与显存开销呈平方级膨胀——这就是必须对视觉 token 进行压缩的根本原因。

1. token 数量：N 表示图片被切块后生成的视觉 token 个数，相当于后厨的“食材块数量”。

$$\displaystyle N$$

2. 平方膨胀：每个 token 都要与其余 token 计算相关性，总配对数是 N² 量级，所以计算量随 N 平方增长。

$$\displaystyle N^{2}$$

3. 维度开销：d 是每个 token 向量的维度，影响每次配对的运算量，维度越高单次越贵。

$$\displaystyle d$$

理解了平方膨胀，就明白为什么“高清图+大模型”这么烧钱。压缩的终极目标，正是把公式里的 N 从几万降到几百，让后厨的灶台喘口气，同时保住菜品质量——这是后面所有压缩技法的共同出发点。

注意力剪枝：低分Token淘汰赛

王姐翻看一周的菜单记录：100 道菜里有 80 道从没人点过。把这些冷门菜划掉，后厨腾出大量空间，招牌菜照样受欢迎。AI 里也有一本类似的“点单记录”——注意力分数。

Transformer 计算时，每个 token 都会“看”其他 token 一眼，看的强度用注意力分数 α 表示。α 高表示这个 token 与全局语义关系密切，就像老客人常点的招牌菜；α 低表示它在当前上下文里几乎不被需要，就像无人问津的冷门菜。所有分数经 softmax 归一化后加起来等于 1，相当于一笔“注意力预算”。

注意力分数的计算方式如下：

$$\displaystyle \alpha_{ij} = \text{softmax}\left(\frac{Q_i K_j^T}{\sqrt{d_k}}\right) = \frac{\exp\left(\frac{Q_i K_j^T}{\sqrt{d_k}}\right)}{\sum_{l} \exp\left(\frac{Q_l K_j^T}{\sqrt{d_k}}\right)}$$

每个 token 的整体重要性 score(t_i) 可取它被其他 token 关注的平均分数。剪枝规则就是设定阈值 τ，低于阈值的 token 直接淘汰：

$$\displaystyle \hat{T} = \{\, t_i \mid \text{score}(t_i) > \tau \,\}$$

1. 内积相关度：查询 Q_i 与键 K_j 的内积衡量两个 token 的相关程度，数值越大关联越强。

$$\displaystyle Q_i K_j^T$$

2. 缩放稳定：除以 √d_k 防止内积过大导致 softmax 梯度消失，是一种数值稳定技巧。

$$\displaystyle \sqrt{d_k}$$

3. 归一化投票：softmax 保证每一行注意力权重和为 1，形成一张“注意力预算表”。

$$\displaystyle \text{softmax}\left(\cdot\right)$$

4. 阈值筛选：score 低于 τ 的 token 从序列中删除，剩下的 token 数量大幅减少。

$$\displaystyle \tau$$

注意力剪枝就像划菜单：速度快、无需额外训练，是工程上最常用的“第一刀”。但要注意划得太狠会连招牌菜的配菜一起划掉——注意力分数低的 token 未必真的没用，这是第五节要探讨的权衡。

聚类合并：相似Token拼盘

王姐发现厨房里有 6 道鸡肉菜口味相似，与其各备一份，不如合成一份“百鸡拼盘”——顾客尝到的是多重风味的融合，后厨却只准备一份食材。token 聚类合并就是在做这种拼盘。

比起直接删除，合并更温和。它先把语义相近的 token 归为一簇，再用一个代表向量替代整簇。总 token 数从 N 降到 K，而每簇的信息都保留了大头。最经典的实现是 K-Means 聚类，也可以用图结构或注意力关系来划分簇。

K-Means 的簇中心公式：

$$\displaystyle c_k = \frac{1}{|S_k|} \sum_{t_i \in S_k} t_i$$

更精细的做法是带注意力权重的融合，让重要 token 在代表向量里占更大话语权：

$$\displaystyle t_{\text{new}} = \frac{\sum_{i \in S} \alpha_i t_i}{\sum_{i \in S} \alpha_i}$$

1. 簇集合：S_k 表示第 k 簇的 token 下标集合，来自聚类算法（如 K-Means）的划分结果。

$$\displaystyle S_k$$

2. 平均代表：c_k 是簇内所有 token 向量取平均，作为这簇的“团宠代表”输出。

$$\displaystyle \frac{1}{|S_k|} \sum_{t_i \in S_k} t_i$$

3. 注意力加权：比起等权平均，用 α 加权能让更重要的 token 在代表向量里有更大发言权。

$$\displaystyle \frac{\sum_{i \in S} \alpha_i t_i}{\sum_{i \in S} \alpha_i}$$

4. 替代输出：合并后原 N 个 token 被 K 个代表向量替代，K 由预设的压缩目标决定。

$$\displaystyle K \ll N$$

聚类合并的优点是不太“挑食”——没有单独牺牲某个 token，而是把相似信息搅拌在一起，语义损失比硬剪枝更平缓。缺点是要预先定 K 值，就像拼盘的种类得提前设计，定得太粗容易串味。

学习型压缩：可训练的浓缩器

前面两种方法都是“从现有菜里减或拼”。王姐还想要一种更高级的招：像把几十公斤食材熬成一罐浓缩高汤宝——体积小到装进口袋，味道却浓缩了全部精华。学习型压缩模块就是这罐高汤宝。

学习型压缩不直接保留或平均现有 token，而是训练一组“可学习的查询向量”，让它去原始 token 集合里“打探”信息，再输出一组全新的、更少的压缩 token。典型结构包括 Perceiver、Q-Former、Query-based Pooling。整个过程端到端可微，优化器直接告诉压缩器：哪些信息值得留。

核心计算是交叉注意力：

$$\displaystyle T_c = \text{Transformer}\left(Q_{\text{learnable}}, T_{\text{src}}\right)$$

其中 Q_learnable 是 M 个可学习查询向量，T_src 是原始 N 个视觉 token，输出 T_c 是 M 个压缩 token，且 M 远小于 N。

1. 可学习查询：Q_learnable 是模型自己学出来的 M 个查询向量，相当于 M 个“高汤配方”。

$$\displaystyle Q_{\text{learnable}}$$

2. 交叉注意力：用查询向量与源 token 做交叉注意力，让每个查询决定“从哪些食材取多少味”。

$$\displaystyle \text{Attention}\left(Q_{\text{learnable}}, T_{\text{src}}\right)$$

3. 输出压缩：输出 M 个压缩 token，M 远小于 N，随后送入 LLM 参与后续计算。

$$\displaystyle M \ll N$$

4. 端到端训练：压缩器与整个多模态模型一起反向传播，自动学会保留什么、舍弃什么。

$$\displaystyle \nabla_{\theta} \mathcal{L}_{\text{task}}$$

高汤宝的妙处在于通用——炒菜、煮面、煲汤都能放。学习型压缩输出的 token 同样可以喂给 LLM 的任何层，灵活性远超“删几道菜”，代价是需要训练，成本更高。

取舍之道：压缩率与信息保留

王姐试了几轮：把菜单砍到只剩 5 道菜，出餐飞快，但老顾客抱怨“想吃的菜没了”；保留 50 道，菜齐了，灶台又忙不过来。压缩率与信息保留就是这么一对跷跷板。

压缩率 R 量化“砍了多少”：

$$\displaystyle R = 1 - \frac{N_{\text{out}}}{N_{\text{in}}}$$

R = 0.75 表示从 100 个 token 压到 25 个。压缩率越高计算越省，但 token 越少细节越容易失真——一张图里的小猫、路牌文字、医疗器械上的刻度，都可能被当成“低分 token”旋掉。不同任务容忍度天差地别：闲聊场景压缩 90% 依然流畅；细粒度视觉问答压缩 50% 就开始掉准确率。

1. 原始数量：N_in 为压缩前视觉 token 总数，即压缩器的“输入食材块数”。

$$\displaystyle N_{\text{in}}$$

2. 输出数量：N_out 为压缩后 token 总数，即压缩器的“输出食材块数”。

$$\displaystyle N_{\text{out}}$$

3. 比例换算：1 减去两者比值，得到“被砍掉的比例”，结果在 0 到 1 之间。

$$\displaystyle 1 - \frac{N_{\text{out}}}{N_{\text{in}}}$$

4. 压缩率解读：0.5 表示砍掉一半；0.9 表示砍掉九成，接近极限压缩。

$$\displaystyle R = 0.9$$

压缩率是“省了多少”的仪表盘，信息保留是“顾客还满意吗”的评分表，两者要一起看。工程上不是一味追求最大压缩率，而是先画一条“速度-准确率”曲线：测出基准延迟与准确率，再逐步加大压缩率，找到准确率跌幅可接受的最大压缩点——这就是王姐的“甜点压缩率”。

工程实践：落地压缩方案

王姐筹备“压缩厨房”时发现，纸上谈兵与真火烹饪之间隔着无数细节。把剪枝、合并、学习压缩组装成生产线，需要注意选设备、定标准、避坑。

工程落地有三条主线。第一，位置选择：压缩模块一般放在视觉编码器之后、进入 LLM 之前，这样能同时削减自注意力计算与 KV cache 内存；部分方案也在 LLM 浅层做渐进压缩。第二，硬件适配：剪枝产生稀疏矩阵，若没有配套 kernel 优化，实际推理并不会变快甚至更慢——“理论省了，硬件没省”。第三，恢复训练：压缩后的模型通常要做轻量微调或知识蒸馏，把压缩带来的语义损失“补回来”。

加速效果可以用压缩比估算：

$$\displaystyle \text{Speedup} \approx \left(\frac{N_{\text{in}}}{N_{\text{out}}}\right)^{2}$$

当 token 从 N 减到 N/4，理论计算加速约 16 倍，显存占用降为 1/4——前提是硬件能用满。

1. 压缩倍数：N_in 除以 N_out 得到 token 缩减倍率，比如 4 倍。

$$\displaystyle \frac{N_{\text{in}}}{N_{\text{out}}}$$

2. 平方加速：自注意力计算量随 token 个数平方级下降，所以加速比是倍率的平方。

$$\displaystyle \left(\frac{N_{\text{in}}}{N_{\text{out}}}\right)^{2}$$

3. 显存变化：KV cache 与 token 数成线性关系，token 减半则显存占用也近似减半。

$$\displaystyle \text{Memory} \propto N_{\text{tokens}}$$

4. 理论 vs 实际：最终收益要乘以硬件稀疏计算利用率，实际落地需实测验证。

$$\displaystyle \text{Speedup}_{\text{real}} \le \text{Speedup}_{\text{theory}}$$

王姐的最终厨房是这样的：剪枝负责“清冷菜”，合并负责“拼盘”，学习压缩负责“熬高汤”，三者按任务需求组装，再用基准测试校准“甜点区”。这样的压缩厨房，出餐又快，顾客还挑不出毛病。

AI 应用场景

Python 演示

import numpy as npfrom sklearn.cluster import KMeans  def compute_attention_scores(q, k):    """计算每个 token 的平均注意力分数"""    d = q.shape[-1]    scores = np.exp(q @ k.T / np.sqrt(d))    scores = scores / scores.sum(axis=-1, keepdims=True)    return scores.mean(axis=0)  def prune_tokens(T, tau):    """阈值剪枝：删除注意力分数低于 tau 的 token"""    scores = compute_attention_scores(T, T)    keep_idx = np.where(scores >= tau)[0]    return T[keep_idx], keep_idx  def merge_tokens(T, n_clusters):    """聚类合并：用簇中心替代原 token"""    km = KMeans(n_clusters=n_clusters, n_init=10, random_state=42)    labels = km.fit_predict(T)    centers = np.array([T[labels == c].mean(axis=0) for c in range(n_clusters)])    return centers, labels  def compress_pipeline(q, tau=0.5, keep_ratio=0.5):    """全流程：剪枝 + 聚类合并"""    T_pruned, kept = prune_tokens(q, tau)    n_out = max(1, int(len(T_pruned) * keep_ratio))    T_merged, labels = merge_tokens(T_pruned, n_out)    return T_merged, len(q), len(T_merged)  if __name__ == "__main__":    np.random.seed(42)    N, d = 200, 64    tokens = np.random.randn(N, d)    merged, n_in, n_out = compress_pipeline(tokens, tau=0.5, keep_ratio=0.4)    rate = 1 - n_out / n_in    print(f"原始 token: {n_in} -> 压缩后: {n_out}, 压缩率: {rate:.2f}")

1. q @ k.T / np.sqrt(d)计算所有 token 两两之间的缩放内积，衡量相关度。
2. scores.mean(axis=0)对每列取平均，得到每个 token 被其他 token 关注的平均分数。
3. keep_idx = np.where(scores >= tau)[0]阈值剪枝：只保留分数不低于 τ 的 token。
4. km.fit_predict(T)用 K-Means 对保留的 token 做语义聚类。
5. T[labels == c].mean(axis=0)每个簇取平均向量作为簇中心，替代整簇 token。
6. n_out = max(1, int(len(T_pruned) * keep_ratio))根据保留比例确定压缩后的目标 token 数。
7. rate = 1 - n_out / n_in打印压缩率，即被削减的 token 占比。

常见误区

面试题