语义缓存:把重复的提问变成可复用的推理结果
·
语义缓存:把重复的提问变成可复用的推理结果
一、为什么精确缓存不够用
任何做过线上 LLM 应用的人都知道,用户的问题高度重复。一个客服机器人,60%~80% 的请求集中在少数几十个意图上。所以最直觉的优化就是加缓存:hash(prompt) → response。
但精确缓存(Exact Match Cache)的命中率往往低得令人失望。原因在于自然语言的表达多样性:
- “怎么退款” / “退款流程是什么” / “我要退货怎么操作” / “如何申请退钱”
-
- “帮我查一下订单 12345 的物流” / “订单12345到哪了”
这四句话语义上高度一致,但字符串哈希完全不同。实测下来,精确缓存在真实客服场景的命中率通常只有 15%~25%,剩下的 75% 都是"语义重复但字面不同"。
- “帮我查一下订单 12345 的物流” / “订单12345到哪了”
语义缓存(Semantic Cache)就是为了解决这个问题:用向量相似度判断"是否等价",而不是字符串相等。
二、基本原理与最小实现
核心思路很简单:把用户 query 编码成向量,在缓存库里做 ANN 检索,如果最近邻的相似度超过阈值,直接返回缓存结果。
import hashlib, json, time
import numpy as np
class SemanticCache:
def __init__(self, embed, store, threshold: float = 0.92, ttl: int = 86400):
self.embed = embed
self.store = store # 支持 add / search 的向量库
self.threshold = threshold
self.ttl = ttl
def get(self, query: str, namespace: str = "default"):
vec = self.embed(query)
hits = self.store.search(vec, top_k=1, filter={"namespace": namespace})
if not hits:
return None
doc, score = hits[0]
if score < self.threshold:
return None
if time.time() - doc["created_at"] > self.ttl:
return None
return doc["response"]
def put(self, query: str, response: str, namespace: str = "default", meta: dict | None = None):
self.store.add(
id=hashlib.md5(f"{namespace}:{query}".encode()).hexdigest(),
vector=self.embed(query),
payload={
"query": query,
"response": response,
"namespace": namespace,
"created_at": time.time(),
**(meta or {}),
},
)
```
代码只有 30 行,但**真正难的是那三个参数:阈值、TTL、命名空间。** 下面逐个拆。
## 三、阈值:一个被严重低估的超参数
### 3.1 阈值决定了"错"和"慢"的平衡
- 阈值太低(如 0.80):大量不相关问题被误判为命中,用户得到**答非所问**的结果。这是最糟糕的失败模式,因为用户不知道系统错了,会直接不信任产品。
- - 阈值太高(如 0.98):几乎不命中,缓存形同虚设,白付了向量检索的成本。
实践中,`0.92~0.95` 是常见起点,但**这个数字高度依赖 Embedding 模型**。不同模型的相似度分布差异很大,不能直接套用。
### 3.2 正确的定阈值方法
不要拍脑袋,用数据定。方法如下:
1. 从日志采样 500 条 query,人工聚类出"语义等价组"。
2. 2. 计算所有组内 pair 的相似度,得到**正样本分布**。
3. 3. 计算跨组 pair 的相似度,得到**负样本分布**。
4. 4. 找让 `F1` 最大的阈值点。
```python
import numpy as np
def find_threshold(pos_sims, neg_sims):
best_t, best_f1 = 0, 0
for t in np.arange(0.80, 0.999, 0.005):
tp = sum(s >= t for s in pos_sims)
fp = sum(s >= t for s in neg_sims)
fn = len(pos_sims) - tp
precision = tp / (tp + fp) if tp + fp else 0
recall = tp / (tp + fn) if tp + fn else 0
f1 = 2 * precision * recall / (precision + recall) if precision + recall else 0
if f1 > best_f1:
best_t, best_f1 = t, f1
return best_t, best_f1
```
一个真实案例:某电商客服场景下,正样本相似度中位数 0.94,负样本中位数 0.81,但负样本的 95 分位到了 0.91。这意味着**如果阈值设 0.92,会有 5% 的误命中**。此时正确的做法不是把阈值提到 0.95(召回骤降),而是**引入第二道校验**。
### 3.3 双阈值 + LLM 仲裁
两级判断能大幅提升精度:
```python
async def cached_answer(query, cache, llm, high=0.96, low=0.90):
hits = cache.store.search(cache.embed(query), top_k=1)
if not hits:
return None, "miss"
doc, score = hits[0]
if score >= high:
return doc["response"], "hit_exact"
if score >= low:
# 灰区:让 LLM 判断是否同一问题
verdict = await llm.classify(
f"问题A:{doc['query']}\n问题B:{query}\n这两个问题是否在问同一件事?只回答 是/否"
)
if "是" in verdict:
return doc["response"], "hit_arbitrated"
return None, "miss"
```
灰区仲裁的成本极低(一个 20 Token 的分类请求),但能把误命中率压到 1% 以下。这是**投入产出比最高的一步优化**。
## 四、TTL 与失效:缓存的"新鲜度"问题
LLM 应用的答案会随时间失效,但失效速度差异极大:
| 内容类型 | 失效速度 | 建议 TTL |
| --- | --- | --- |
| 通用知识("什么是 RAG") | 极慢 | 7~30 天 |
| 产品功能说明 | 慢(随版本) | 3~7 天 |
| 价格、库存、活动 | 快 | 1~60 分钟 |
| 用户个人数据(订单、余额) | 实时 | **不缓存** |
**最关键的一条规则:涉及用户私有数据的查询绝对不能跨用户缓存。** 这不是性能问题,是安全漏洞。一个"我的订单到哪了"的缓存,可能会把 A 的订单信息返回给 B。
实现上必须做**缓存键隔离**:`cache_key = hash(user_id + query)`,或者用向量库的 `namespace` 做租户隔离。两者都要做,前者防止语义碰撞,后者防止检索越界。
```python
def cache_namespace(user_id: str, scene: str) -> str:
return f"{scene}:{user_id}"
```
## 五、命中率优化:从 20% 到 60%
### 5.1 查询归一化
缓存前先做轻量归一化,能显著提升命中率:
```python
import re, unicodedata
def normalize_query(q: str) -> str:
q = unicodedata.normalize("NFKC", q) # 全角转半角
q = q.lower()
q = re.sub(r"[ \t]+", " ", q).strip()
q = re.sub(r"[,。!?、;:]+$", "", q) # 去尾部标点
q = re.sub(r"^(请问|你好|麻烦问一下)[,, ]*", "", q) # 去客套前缀
return q
```
这个函数看起来平平无奇,但在真实数据上通常能带来 10~15 个百分点的命中率提升——因为用户的客套话和标点差异,占了"字面不同"的很大一部分。
### 5.2 意图聚类后缓存
更激进的做法是:先做意图分类(可以用小模型或规则),把 query 映射到意图 ID,然后**按意图缓存**。这样"怎么退款"和"我要退货怎么操作"会命中同一条缓存。
代价是意图分类本身有误差,且需要维护意图体系。适合意图空间有限、稳定的场景(如 IVR 语音导航)。
### 5.3 分层缓存
L1:精确缓存(内存,< 1ms) → 命中率 15%
L2:语义缓存(向量库,10~30ms) → 额外命中 30%
L3:LLM 生成(1~5s) → 剩余 55%
L1 用 LRU + 布隆过滤器做前置,能挡掉最热的那批请求,几乎零成本。L2 才是语义缓存。这个分层结构比"只做语义缓存"更经济,因为 L1 的命中不需要任何向量计算。
## 六、什么时候不该用语义缓存
这一点很少被讨论,但很重要。
**第一,高度个性化的问题。** 如果每个答案都依赖用户的具体上下文("帮我改一下这段代码"),缓存几乎没有价值,反而增加复杂度。
**第二,需要严格一致性的场景。** 金融、医疗类问答,即使语义相同,也需要重新推理以确保合规。此时缓存不是优化,是风险。
**第三,低频长尾查询。** 如果查询分布极其分散(Zipf 系数很低),缓存命中率上不去,只会白付向量检索的成本。上缓存前先统计一下 query 的重复率,低于 30% 就别做了。
**第四,答案短但推理成本低的场景。** 如果答案本来就生成得很快(< 500ms),缓存的收益不足以抵消"可能答错"的风险。
## 七、我的判断
语义缓存是 LLM 应用里**性价比最高的工程优化之一**,但它有一个致命前提:**你必须能容忍错**。
所以我的建议是,把语义缓存当成一个**分级的产品能力**,而不是一个全局开关:
- 对"通用知识型"问题,激进缓存(阈值 0.90)。
- - 对"业务操作型"问题,保守缓存(阈值 0.96 + LLM 仲裁)。
- - 对"个人数据型"问题,完全不缓存。
同时必须建立**缓存效果监控**:命中率、误命中率(通过人工抽检)、平均节省延迟、平均节省 Token 成本。这四个指标决定了缓存是否值得继续投入。
最后一个经验:**语义缓存的收益会随时间衰减。** 上线初期命中率可能到 60%,但因为知识库更新、用户问题演化,半年后可能只剩 35%。所以要定期重跑阈值标定,而不是设一次就不管。
DAMO开发者矩阵,由阿里巴巴达摩院和中国互联网协会联合发起,致力于探讨最前沿的技术趋势与应用成果,搭建高质量的交流与分享平台,推动技术创新与产业应用链接,围绕“人工智能与新型计算”构建开放共享的开发者生态。
更多推荐



所有评论(0)