Token压缩新范式：基于视觉显著性与文本相似性的自适应VLM加速策略

1. 为什么你的VLM跑得慢？问题可能出在“视觉废话”太多

最近在折腾几个主流的视觉语言模型，比如LLaVA-NEXT和InternVL-2.5，发现一个挺头疼的问题：处理一张高分辨率图片，模型吭哧吭哧要分析成千上万个视觉token。这感觉就像让你读一篇几万字的文章，但里面90%都是“今天天气真好”、“我吃了早饭”这样的废话，真正有用的信息就藏在几段里。你不仅读得慢，脑子还累，效率自然高不起来。

VLM处理图像也是这个道理。为了看清细节，现代模型会把一张大图切成很多小块（patch），每个小块变成一个视觉token。一张1080p的图，轻松就能产生几千个token。但问题是，一张图里真正和你的问题相关的区域可能就那么一小块——比如你问“图片里猫在干什么”，背景的沙发、窗帘、地毯这些token，对回答这个问题基本就是“视觉废话”。然而，模型在计算时，可不会自动跳过这些废话，它得老老实实地为每一个token分配计算资源，导致推理速度慢、显存占用高。

我之前试过一些现成的加速方法，比如直接根据模型自注意力权重来砍掉一些不重要的token。但实测下来发现坑不少。注意力机制有时候会“偏心”，比如更关注图像后面部分的token，或者被一些高对比度的纹理带偏，结果把真正重要的猫耳朵或者关键文字给修剪掉了，模型回答就开始胡言乱语。这让我意识到，单纯靠模型自己内部的注意力来“减肥”，不太靠谱。

那么，有没有更聪明的方法，能像人眼一样，快速锁定图片中的关键信息，同时结合你的问题（文本）来精准筛选token呢？这就是“基于视觉显著性与文本相似性的自适应VLM加速策略”要解决的核心问题。它不再单一看图说话，而是让“视觉线索”和“文本线索”联手，动态决定哪些token值得保留，从而实现又快又准的推理。接下来，我就带你一步步拆解这个新范式，看看它到底是怎么工作的，以及我们如何把它用起来。

2. 双剑合璧：视觉显著性与文本相似性如何指引Token筛选

要想精准压缩token，我们得先弄明白两个核心的“筛选器”是怎么工作的：视觉显著性和文本到图像相似性。你可以把它们理解成两位各有所长的面试官，一起决定哪个token能进入下一轮。

2.1 视觉显著性：一眼抓住“哪里最吸睛”

视觉显著性，说白了就是图片里哪些地方最“扎眼”，最能吸引人的注意力。比如一张街拍，一个穿着红色裙子的人在一群灰黑色着装的人群中，这个红色区域就是视觉显著性高的地方。从技术上讲，我们可以通过预训练的视觉模型（比如ViT中的[CLS]token）来计算出每个图像块（patch）对于整体图像理解的“贡献度”。

计算起来并不复杂。假设我们有一组视觉嵌入（Visual Embeddings），还有一个代表整张图片全局信息的[CLS]token。视觉显著性分数，本质上就是每个视觉token与这个[CLS]token的关联强度，通常用它们之间的注意力权重或者余弦相似度来衡量。分数越高，说明这个图像块对于模型理解“这是张什么图”越重要。

我写个简单的伪代码帮你理解这个过程：

# 假设 visual_embeddings 形状为 [num_patches, feature_dim] # cls_token 形状为 [1, feature_dim] # 计算每个视觉token与CLS token的余弦相似度作为显著性分数 import torch.nn.functional as F visual_saliency_scores = F.cosine_similarity(visual_embeddings, cls_token.expand_as(visual_embeddings), dim=-1) # visual_saliency_scores 形状为 [num_patches]，值越大越显著

这个方法能很好地过滤掉大片纯色背景、模糊的纹理等“视觉噪音”。但它有个局限：它是“无目的”的。它只知道哪里显眼，但不知道这个显眼的东西是否和你的问题相关。比如你问“图片右下角的告示牌上写了什么”，但视觉显著性可能更关注图片中央的一辆亮色汽车。这时，我们就需要第二位面试官出场了。

2.2 文本到图像相似性：让问题指引搜索方向

文本到图像相似性，就是衡量你的文本问题（比如“一只猫”）与每一个视觉token内容的匹配程度。这相当于你带着一个明确的问题去审视图片，直接寻找相关的证据。

关键的一步在于，我们需要获得高质量的文本嵌入（Text Embedding）。在像LLaVA这样的VLM中，文本会先通过LLM的底层（我们称之为pre-LLM层）进行编码，得到一个文本特征表示。一个重要的发现是，在这个pre-LLM层产生的文本嵌入，与视觉嵌入在语义空间中对齐得很好，且没有前面提到的“注意力偏移”问题。这意味着，在这个阶段用文本嵌入去检索相关的视觉token，是非常可靠和公平的。

计算文本到图像相似性，通常也是用余弦相似度：

# 假设 text_embedding 形状为 [1, feature_dim] (例如，问题“cat”的嵌入) # visual_embeddings 形状为 [num_patches, feature_dim] text_to_image_similarity = F.cosine_similarity(text_embedding, visual_embeddings, dim=-1) # text_to_image_similarity 形状为 [num_patches]，值越高表示该视觉token与文本问题越相关

这个方法能精准定位到与问题语义相关的区域，哪怕它在视觉上并不突出（比如一只躲在暗处的黑猫）。然而，如果只依赖它，也可能陷入“一叶障目”的困境，比如只盯着猫看，完全忽略了猫正在玩耍的那个关键道具（比如一个毛线球），而这个道具可能对回答“猫在干什么”至关重要。

所以你看，两位面试官单独工作都有缺陷：视觉显著性考官可能选了个“花瓶”（显眼但无关），文本相似性考官可能又太“钻牛角尖”（相关但视野窄）。最理想的状态，是让他们俩合作，根据每次具体的“面试需求”（不同的图像和问题），动态调整选拔标准。这就是“自适应混合”机制的用武之地。

3. 从固定搭配到动态决策：自适应混合机制的演进

早期的想法很直接：既然两者都有用，那就都考虑。固定混合策略就是给两位面试官各分配一个固定的名额。比如，我们要从1000个token里选出100个最重要的，那就根据视觉显著性分数选出前50个，再根据文本相似性分数选出前50个，合并起来（去掉重复的）作为最终结果。

这种方法实现简单，我最初自己试的时候也是这么干的。但很快就发现了问题：这个固定的比例太僵化了。有些图片，视觉显著性信息非常强且与问题高度相关（比如问“这是什么建筑？”，图片里就是一个宏伟的宫殿），那么可能80%的token都应该由视觉显著性来决定。而有些图片，问题非常具体且目标不显眼（比如问“显微镜下细胞核的位置”），那么文本相似性就应该占据绝对主导。固定比例无法适应这种千变万化的场景，导致压缩效率时高时低，有时甚至会误删关键token。

于是，我们需要一个更智能的、能动态分配预算的策略。这就是自适应跨模态注意力混合（Self-Adaptive Cross-Modality Attention Mixture, SACMAM）的核心思想。它不再拍脑袋决定各选多少，而是让模型根据当前图像和问题的具体情况，自动决定给“视觉显著性”和“文本相关性”各分配多少“选人名额”。

这个自适应过程可以形象地理解为一次“资源竞拍”。我们手里有K个token的预算（比如100个）。视觉显著性和文本相似性各自提供一份候选名单（按分数排序的token列表）。自适应机制的目标是，花光这K个预算，使得最终选出的token集合，在“整体显眼度”和“整体相关性”的综合得分上最高。

这里有个技术难点：视觉显著性分数和文本相似性分数通常不在一个数量级上，直接相加或平均不公平。论文里引入了一个“温度参数τ”来对文本相似性分数进行重加权，让两者的分布具有可比性。然后，算法会去计算，如果从视觉显著性列表里选前i个，从文本相似性列表里选前j个（且i+j=K），那么这i+j个token的综合得分是多少。它会遍历所有可能的i和j的组合，找到那个能让综合得分最高的黄金分割点。

# 伪代码示意自适应选择过程（简化版） def adaptive_token_selection(saliency_scores, text_sim_scores, budget_K): # 1. 对两种分数分别排序，得到排序后的分数和索引 saliency_sorted_scores, saliency_indices = torch.sort(saliency_scores, descending=True) text_sim_sorted_scores, text_sim_indices = torch.sort(text_sim_scores, descending=True) # 2. 计算累积分数（即选前n个的总“收益”） saliency_cumsum = torch.cumsum(saliency_sorted_scores, dim=0) text_sim_cumsum = torch.cumsum(text_sim_sorted_scores, dim=0) best_score = -float('inf') best_i, best_j = 0, 0 # 3. 遍历所有可能的分配方案 (i + j = K) for i in range(0, budget_K + 1): j = budget_K - i if i > len(saliency_scores) or j > len(text_sim_scores): continue # 计算综合得分，例如使用几何平均的思想 # 这里简化处理，实际论文中公式更精细 combined_score = (saliency_cumsum[i-1] if i>0 else 0) * (text_sim_cumsum[j-1] if j>0 else 0) if combined_score > best_score: best_score = combined_score best_i, best_j = i, j # 4. 根据最优的i和j，取出对应的token索引 selected_indices = torch.cat([saliency_indices[:best_i], text_sim_indices[:best_j]]) # 可能需要去重，并按原始空间位置排序以保持空间结构信息 selected_indices = torch.unique(selected_indices) selected_indices = selected_indices[torch.sort(selected_indices)[1]] # 按位置排序 return selected_indices

通过这种动态规划式的搜索，自适应机制能够在每次推理时，都为当前的“图像-问题对”找到最优的token筛选策略，从而在加速和精度之间找到最佳平衡点。

4. 手把手实战：将自适应Token压缩集成到你的VLM中

理论讲完了，我们来点实际的。怎么把这套自适应Token压缩策略用到像LLaVA这样的开源VLM里呢？别担心，整个过程不需要重新训练模型，属于一种“即插即用”的推理时优化技术。下面我以LLaVA-NEXT为例，拆解一下关键的实现步骤。

4.1 环境准备与模型加载

首先，确保你的环境里有PyTorch和Transformers库。我们直接使用Hugging Face上的LLaVA-NEXT模型。

pip install torch torchvision transformers accelerate pillow

然后，在Python中加载模型和处理器：

from transformers import LlavaNextForConditionalGeneration, LlavaNextProcessor import torch model_id = "llava-hf/llava-v1.6-mistral-7b-hf" # 以LLaVA-1.6为例 processor = LlavaNextProcessor.from_pretrained(model_id) model = LlavaNextForConditionalGeneration.from_pretrained( model_id, torch_dtype=torch.float16, device_map="auto" )

这里的关键是，我们需要能够访问到模型前向传播过程中的中间特征，特别是视觉编码器输出的视觉嵌入（visual embeddings）和LLM底层输出的文本嵌入（text embeddings）。对于许多开源VLM，这可能需要我们稍微修改一下模型的前向代码，或者使用钩子（hook）技术来捕获这些中间值。

4.2 关键特征提取：钩住视觉与文本嵌入

我们需要在模型推理时，拦截两个地方的特征：

1. 视觉嵌入：在视觉编码器（如CLIP-ViT）输出之后，MLP投影层之前。
2. Pre-LLM文本嵌入：在文本经过LLM的第一层（或前几层）编码之后，与视觉特征拼接之前。

以下是一个概念性的示例，展示如何用PyTorch的钩子来获取这些特征：

# 假设我们已知模型内部组件的名称，这需要查看模型源码 visual_embeddings = None text_embeddings_before_llm = None def get_visual_hook(module, input, output): global visual_embeddings # output 可能是视觉编码器输出的最后一层隐藏状态 visual_embeddings = output # 形状: [batch, num_patches, hidden_dim] def get_text_hook(module, input, output): global text_embeddings_before_llm # 假设这个钩子注册在LLM的第一层之后 # output 可能是一个元组，其中包含隐藏状态 if isinstance(output, tuple): text_embeddings_before_llm = output[0] # 形状: [batch, seq_len, hidden_dim] else: text_embeddings_before_llm = output # 注册钩子（需要根据实际模型结构调整目标层） # 例如：model.vision_tower.visual_projection.register_forward_hook(get_visual_hook) # 例如：model.language_model.model.layers[0].register_forward_hook(get_text_hook)

注意：具体注册到哪一层，需要你仔细研究你所使用的VLM的代码结构。这是整个实现中最需要耐心的一步。

4.3 实现自适应选择与特征替换

提取到特征后，我们就可以实现前面讲的自适应选择算法了。这里给出一个更工程化的简化版本：

def adaptive_token_selection(visual_emb, text_emb, cls_token, budget_ratio=0.3): """ visual_emb: [B, N, D] 视觉嵌入 text_emb: [B, T, D] 文本嵌入（取问题部分的平均或首个token） cls_token: [B, 1, D] 或 [1, D] 来自视觉编码器的[CLS] token budget_ratio: 要保留的token比例 """ B, N, D = visual_emb.shape K = int(N * budget_ratio) # 要保留的token数量 # 1. 计算视觉显著性：每个视觉token与CLS token的余弦相似度 # 扩展cls_token以匹配视觉嵌入的维度 cls_expanded = cls_token.expand(B, N, -1) if cls_token.dim() == 3 else cls_token.expand(B, N, D) saliency = F.cosine_similarity(visual_emb, cls_expanded, dim=-1) # [B, N] # 2. 计算文本-图像相似性：文本嵌入（取平均）与每个视觉token的余弦相似度 # 假设我们取文本嵌入序列中代表问题的部分的平均值 text_query = text_emb.mean(dim=1, keepdim=True) # [B, 1, D] text_query_expanded = text_query.expand(B, N, D) text_sim = F.cosine_similarity(visual_emb, text_query_expanded, dim=-1) # [B, N] # 3. 对文本相似性进行温度缩放（τ），使其与显著性分布可比 tau = 2.0 # 温度超参数，可调 text_sim_scaled = text_sim / tau selected_indices_list = [] for b in range(B): # 对当前样本的两种分数进行排序 sal_scores, sal_idx = saliency[b].sort(descending=True) txt_scores, txt_idx = text_sim_scaled[b].sort(descending=True) # 计算累积分数 sal_cum = torch.cumsum(sal_scores, dim=0) txt_cum = torch.cumsum(txt_scores, dim=0) best_combined = -1e9 best_i = 0 # 寻找最优的分配点i (从显著性里选i个，从文本相似性里选K-i个) # 这里简化了搜索，实际可以更高效 for i in range(0, K+1): j = K - i if i > N or j > N: continue # 使用几何平均的思想评估组合质量 sal_part = sal_cum[i-1] if i>0 else 0 txt_part = txt_cum[j-1] if j>0 else 0 # 避免为0 combined = torch.sqrt(sal_part * txt_part + 1e-8) if combined > best_combined: best_combined = combined best_i = i # 根据最优的i，合并索引 best_j = K - best_i idx_from_sal = sal_idx[:best_i] idx_from_txt = txt_idx[:best_j] combined_idx = torch.cat([idx_from_sal, idx_from_txt]) # 去重并按原始位置排序 unique_idx, _ = torch.unique(combined_idx, return_inverse=True) sorted_idx, _ = unique_idx.sort() selected_indices_list.append(sorted_idx) # 4. 根据选中的索引，从原始视觉嵌入中采样 selected_visual_emb = torch.stack([ visual_emb[b, selected_indices_list[b], :] for b in range(B) ], dim=0) return selected_visual_emb, selected_indices_list

得到筛选后的视觉嵌入selected_visual_emb后，我们需要用它替换掉原本要输入给LLM的那一大长串视觉嵌入。同时，也要注意调整视觉位置编码（如果模型使用了的话），确保筛选后的token仍然保留正确的空间相对位置信息。

4.4 效果验证与参数调优

集成完毕后，怎么知道它有没有用呢？你需要从两个维度来评估：

1. 速度提升：用同一批图片和问题，分别测试原始模型和集成压缩策略后的模型，记录平均每张图片的推理时间（或吞吐量）。理想情况下，在保留70%-80%token的情况下，推理速度能有30%-50%的提升。
2. 精度保持：在标准的VLM评测集（如VQAv2, GQA, ScienceQA等）上跑分，对比压缩前后的准确率。目标是在速度大幅提升的同时，精度下降控制在1-2个百分点以内，甚至在某些任务上持平。

你可能会需要调整几个关键的超参数：

• budget_ratio（预算比例）：这是最重要的旋钮。从0.5（保留一半token）开始尝试，逐步降低到0.3、0.2，观察速度和精度的trade-off曲线，找到适合你应用场景的甜点。
• 温度参数τ：用于平衡两种分数分布。通常设置在1.0到5.0之间，你可以用一个小的验证集来微调它。
• 文本查询的构建：上面示例中我们简单地对所有文本嵌入取了平均。更精细的做法可以是只对问题部分的token取平均，或者使用特殊的[QUESTION]token的嵌入。

我在几个本地测试集上跑下来的感受是，对于“描述图片主体内容”这类任务，视觉显著性权重会更高；而对于“图中第三行第二列的文字是什么”这类需要精确定位的任务，文本相似性则会发挥主导作用。自适应机制确实能很好地捕捉到这种变化。

5. 避坑指南：实际部署中的挑战与应对策略

看起来很美，但在实际项目里落地这套策略，我踩过几个坑，这里分享给你，希望能帮你省点时间。

第一个坑是特征对齐的稳定性。我们假设pre-LLM层的文本嵌入和视觉嵌入是良好对齐的。但这个假设在不同模型、不同训练数据上是否始终成立？我发现在一些早期版本的VLM或者某些特定领域的微调模型上，这个对齐可能并不完美。解决方案是，在正式部署前，用小批量数据做一个快速验证：计算文本嵌入与所有视觉嵌入的相似度，观察其分布是否均匀，有没有出现极端值或者明显的分布偏移。如果发现问题，可能需要考虑对文本嵌入或视觉嵌入做一个简单的归一化（比如LayerNorm）来稳定分布。

第二个坑是计算开销的权衡。自适应选择算法本身需要一些计算，尤其是那个寻找最优i和j的循环。如果token数量N很大（比如上万），这个搜索过程可能会抵消掉一部分token压缩带来的收益。我的经验是，当N很大时，可以采用近似搜索策略，比如将搜索步长设大一些，或者使用贪心算法快速找到一个次优解。实际上，在大多数情况下，由于K远小于N，这个搜索的开销相对于LLM巨大的计算量来说，基本可以忽略不计。

第三个坑是空间信息的丢失。我们筛选token时，打乱了它们的原始空间顺序（虽然最后排序了，但中间过程是打乱的）。对于严重依赖空间关系的任务（如目标定位、文档布局分析），这可能会带来问题。一个补救措施是，在筛选时不仅考虑分数，还加入一个轻量级的“空间聚类”惩罚，鼓励选择在空间上聚集的token，而不是分散孤立的点。或者，在将筛选后的token送入LLM之前，显式地附加上它们归一化后的二维坐标信息作为位置补充。

第四个坑是多轮对话场景。上述策略主要针对单轮问答。在多轮对话中，历史对话文本也会影响当前轮次对图像的关注点。一个直接的扩展是，将历史对话的文本嵌入也考虑进来，计算一个综合的“对话-图像”相似性。更复杂一点，可以维护一个跨轮次的“视觉记忆”，将前几轮被认为重要的视觉token以某种衰减权重保留到当前轮次。

最后，别忘了** profiling（性能剖析）**。用Nsight Systems或PyTorch Profiler工具跑一下，确认加速的瓶颈确实从LLM的注意力计算转移开了，并且自适应选择模块没有成为新的瓶颈。我遇到过因为Python循环效率低导致加速不明显的情况，后来把核心选择算法用CUDA或Triton重写后，效果就立竿见影了。

这套自适应Token压缩策略，给我的感觉就像给VLM装上了一双“智能眼镜”和一个“问题聚焦器”。它让模型学会了在浩如烟海的视觉信息中快速抓住重点，而不是平均用力。虽然实现起来需要一些工程功夫，但换来的是实实在在的推理效率提升，对于想要部署高分辨率VLM应用到实际产品中的团队来说，这绝对是一个值得深入探索的方向。