tzt
c072a1a237
- 新增 router_system/llm_client.py：OpenAICompatClient 统一 experts/judge/fallback
三处复制的懒建 AsyncClient + /chat/completions + choices/usage 解析（~60 行去重）；
密钥解析统一走 config.get_api_key（激活原死代码，顺带消除 experts 默认环境名不一致）
- 语义缓存 L2：条目容器 list→OrderedDict（提升/淘汰 O(n)→O(1)），按 query 天然去重；
n-gram 向量 lru_cache 复用（同一次 miss 的 get/put 免重复分词）；
A/B：淘汰路径 0.040→0.034s，miss→put 往返 9.41→8.57s（-9%）
- RuleJudge 覆盖度：response.lower() 提出逐词循环（原 O(terms×len) 重复复制）
- extract_content_terms 纯函数 lru_cache 化（专家与 Judge 对同一查询免重复分词），返回 tuple
- RuleClassifier：_score 去掉败者领域白建的命中词 list（胜出后单独收集）；
修复 code 规则 ("api",0.7) 重复登记（原命中计 1.4 分）
- difficulty：正则模块级预编译
- tests：恢复上一轮引入的乱码中文 docstring；网关测试输入串恢复为可判 code 的中文查询
173 lines
7.1 KiB
Python
173 lines
7.1 KiB
Python
"""两阶段路由缓存（对齐实现方案）：
|
|
- L1 精确缓存：完全相同的查询 -> 直接命中
|
|
- L2 语义缓存：字符 n-gram 余弦相似度（零依赖）-> 相似查询命中
|
|
- 命中 N 次（promote_frequency）后提升为精确缓存
|
|
|
|
说明：语义缓存中的"完全相同查询"（相似度=1.0）直接计为 exact 命中；
|
|
高频语义命中会提升为 O(1) 的精确缓存条目。
|
|
|
|
只缓存"未升级"的结果（升级路径每次都走大模型，不缓存，避免陈旧）。
|
|
|
|
性能设计（2026-09 优化）：
|
|
- 每条语义缓存条目在写入时预计算并缓存向量范数，查询时免重复计算（原来每对比较都重算）
|
|
- 语义查找单遍完成：扫描即跟踪最优条目与命中计数，命中后不再二次线性查找
|
|
- 相似度达到 1.0（完全相同查询）时提前终止扫描（余弦相似度上界，不可能更优）
|
|
- 语义条目容器为 OrderedDict：提升/淘汰均为 O(1)（原 list pop 是 O(n) 搬移），
|
|
且按 query 天然去重（原实现同一 query 可重复追加，重复条目白白参与扫描）
|
|
- n-gram 向量经 lru_cache 复用：同一次未命中请求里 get 与紧随的 put
|
|
不再重复做两遍分词+计数
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import re
|
|
from collections import OrderedDict
|
|
from dataclasses import dataclass
|
|
from functools import lru_cache
|
|
from typing import Any, Dict, List, Optional, Tuple
|
|
|
|
|
|
@dataclass
|
|
class CacheEntry:
|
|
result: Dict[str, Any]
|
|
hits: int = 1
|
|
|
|
|
|
def _ngrams(text: str, n: int = 3) -> List[str]:
|
|
"""字符 n-gram（去空白、小写），用于轻量语义相似度。"""
|
|
cleaned = re.sub(r"\s+", "", text.lower())
|
|
if len(cleaned) < n:
|
|
return [cleaned]
|
|
return [cleaned[i:i + n] for i in range(len(cleaned) - n + 1)]
|
|
|
|
|
|
def _tf_vector(grams: List[str]) -> Dict[str, float]:
|
|
vec: Dict[str, float] = {}
|
|
for g in grams:
|
|
vec[g] = vec.get(g, 0.0) + 1.0
|
|
return vec
|
|
|
|
|
|
def _norm(vec: Dict[str, float]) -> float:
|
|
return sum(v * v for v in vec.values()) ** 0.5
|
|
|
|
|
|
def _dot(vec_a: Dict[str, float], vec_b: Dict[str, float]) -> float:
|
|
"""点积：遍历较小的一方，另一侧用 get 兜底。"""
|
|
if len(vec_a) > len(vec_b):
|
|
vec_a, vec_b = vec_b, vec_a
|
|
return sum(v * vec_b.get(k, 0.0) for k, v in vec_a.items())
|
|
|
|
|
|
@lru_cache(maxsize=1024)
|
|
def _embed(text: str) -> Tuple[Dict[str, float], float]:
|
|
"""n-gram 向量 + 范数（带缓存）。
|
|
|
|
纯函数且同一次未命中请求会在 get/put 各用一次，缓存可省一遍分词。
|
|
契约：返回的 dict 仅供只读（内部无任何修改点），调用方不得改写。
|
|
"""
|
|
vec = _tf_vector(_ngrams(text))
|
|
return vec, _norm(vec)
|
|
|
|
|
|
class RouterCache:
|
|
"""L1 精确缓存 + L2 语义缓存。"""
|
|
|
|
def __init__(self, semantic_enabled: bool = True, similarity_threshold: float = 0.88,
|
|
promote_frequency: int = 5, max_exact: int = 10000, max_semantic: int = 5000):
|
|
self.semantic_enabled = semantic_enabled
|
|
self.similarity_threshold = similarity_threshold
|
|
self.promote_frequency = promote_frequency
|
|
self.max_exact = max_exact
|
|
self.max_semantic = max_semantic
|
|
self._exact: Dict[str, CacheEntry] = {}
|
|
# (query -> entry)，插入序即淘汰序；len 兼容原 list 断言
|
|
self._semantic: "OrderedDict[str, CacheEntry]" = OrderedDict()
|
|
self._sem_vecs: Dict[str, Dict[str, float]] = {}
|
|
self._sem_norms: Dict[str, float] = {} # 预计算范数，避免查询期重算
|
|
self.hits = {"exact": 0, "semantic": 0}
|
|
self.misses = 0
|
|
|
|
# ---- 查询 ----
|
|
def get(self, query: str) -> Optional[Tuple[Optional[str], Dict[str, Any]]]:
|
|
"""返回 (level, result)；未命中返回 None。level: 'exact' | 'semantic'"""
|
|
entry = self._exact.get(query)
|
|
if entry is not None:
|
|
self.hits["exact"] += 1
|
|
return ("exact", entry.result)
|
|
|
|
if self.semantic_enabled:
|
|
q_vec, q_norm = _embed(query)
|
|
best_sim = 0.0
|
|
best_q = ""
|
|
if q_norm > 0.0:
|
|
# 单遍扫描（插入序）：同时跟踪最优条目，sim=1.0 提前终止
|
|
for q, _e in self._semantic.items():
|
|
n_q = self._sem_norms.get(q, 0.0)
|
|
if n_q <= 0.0:
|
|
continue
|
|
sim = _dot(q_vec, self._sem_vecs.get(q, {})) / (q_norm * n_q)
|
|
if sim > best_sim:
|
|
best_sim = sim
|
|
best_q = q
|
|
if sim >= 1.0:
|
|
break # 余弦相似度上界：完全相同查询，提前终止
|
|
if best_q and best_sim >= self.similarity_threshold:
|
|
best_entry = self._semantic[best_q]
|
|
# 完全相同查询（相似度=1.0）计为 exact 命中
|
|
is_exact = best_sim >= 0.999
|
|
level = "exact" if is_exact else "semantic"
|
|
self.hits[level] += 1
|
|
self._bump_semantic(best_q, best_entry)
|
|
return (level, best_entry.result)
|
|
|
|
self.misses += 1
|
|
return None
|
|
|
|
def _bump_semantic(self, query: str, entry: CacheEntry):
|
|
"""语义命中：累计命中次数，达到阈值提升为精确缓存（OrderedDict 删除 O(1)）。"""
|
|
entry.hits += 1
|
|
if entry.hits >= self.promote_frequency:
|
|
self._exact[query] = entry
|
|
del self._semantic[query]
|
|
self._sem_vecs.pop(query, None)
|
|
self._sem_norms.pop(query, None)
|
|
|
|
# ---- 写入 ----
|
|
def put(self, query: str, result: Dict[str, Any]):
|
|
if query in self._exact or query in self._semantic:
|
|
return # 已缓存（语义区按 query 天然去重，避免重复条目参与扫描）
|
|
entry = CacheEntry(result=result)
|
|
if self.semantic_enabled:
|
|
if len(self._semantic) >= self.max_semantic:
|
|
old_q, _old = self._semantic.popitem(last=False) # O(1) 淘汰最旧
|
|
self._sem_vecs.pop(old_q, None)
|
|
self._sem_norms.pop(old_q, None)
|
|
self._semantic[query] = entry
|
|
vec, norm = _embed(query) # 与 get miss 共享同一份缓存向量
|
|
self._sem_vecs[query] = vec
|
|
self._sem_norms[query] = norm
|
|
else:
|
|
self._exact[query] = entry
|
|
if len(self._exact) > self.max_exact:
|
|
self._exact.pop(next(iter(self._exact)))
|
|
|
|
# ---- 统计 ----
|
|
def stats(self) -> Dict[str, Any]:
|
|
total = self.hits["exact"] + self.hits["semantic"] + self.misses
|
|
return {
|
|
"exact_hits": self.hits["exact"],
|
|
"semantic_hits": self.hits["semantic"],
|
|
"misses": self.misses,
|
|
"hit_rate": round((self.hits["exact"] + self.hits["semantic"]) / total, 4) if total else 0.0,
|
|
"exact_size": len(self._exact),
|
|
"semantic_size": len(self._semantic),
|
|
}
|
|
|
|
def clear(self):
|
|
self._exact.clear()
|
|
self._semantic.clear()
|
|
self._sem_vecs.clear()
|
|
self._sem_norms.clear()
|
|
self.hits = {"exact": 0, "semantic": 0}
|
|
self.misses = 0
|