Merge branch 'feat/rerank-live-20261116' into deploy/merge-20261118
This commit is contained in:
@@ -443,9 +443,9 @@ func (a *API) WriteMemory(w http.ResponseWriter, r *http.Request) {
|
||||
Confidence: req.Confidence,
|
||||
ConfidenceSource: confidenceSource,
|
||||
// 2026-11-07 (t_88cc9cb8) 意图 TTL:已通过 400 校验的到期时间(空 = 永久 = 现状)。
|
||||
ExpiresAt: req.ExpiresAt,
|
||||
CreatedAt: now,
|
||||
UpdatedAt: now,
|
||||
ExpiresAt: req.ExpiresAt,
|
||||
CreatedAt: now,
|
||||
UpdatedAt: now,
|
||||
}
|
||||
if err := a.LanceDB.InsertMemory(mem); err != nil {
|
||||
respondError(w, 500, "insert memory: "+err.Error())
|
||||
@@ -1181,7 +1181,7 @@ func (a *API) RecallDebug(w http.ResponseWriter, r *http.Request) {
|
||||
docs[i] = c.Content
|
||||
docVecs[i] = c.Vector
|
||||
}
|
||||
reranked, rErr := a.Reranker.RerankWithVectors(queryVec, docs, docVecs, req.Limit*2)
|
||||
reranked, rErr := a.Reranker.RerankPreferAPI(req.Query, docs, queryVec, docVecs, req.Limit*2)
|
||||
if rErr != nil {
|
||||
reranked, rErr = a.Reranker.Rerank(req.Query, docs, req.Limit*2)
|
||||
}
|
||||
@@ -1711,10 +1711,13 @@ func capRecallResults(results []models.RecallResult, limit int) (prim, expanded
|
||||
// 正确语义:主检索结果(distilled 等)照常收口到 limit;pattern/peer 作为附带条目
|
||||
// 恒保留(不挤占主结果配额),避免「命中即注入」被 cap 吞掉。graph_expanded 仍走独立字段。
|
||||
var carry []models.RecallResult
|
||||
var front []models.RecallResult // standing_answer:答案要置顶,不能沉到尾部
|
||||
for _, r := range results {
|
||||
switch r.Category {
|
||||
case "graph_expanded":
|
||||
exp = append(exp, r)
|
||||
case "standing_answer":
|
||||
front = append(front, r)
|
||||
case "pattern", "peer":
|
||||
carry = append(carry, r)
|
||||
default:
|
||||
@@ -1738,7 +1741,14 @@ func capRecallResults(results []models.RecallResult, limit int) (prim, expanded
|
||||
exp = exp[:limit]
|
||||
}
|
||||
}
|
||||
// standing_answer 置顶:它是「答案」,记忆是「证据」——置顶且不占主结果配额
|
||||
if len(front) > 0 {
|
||||
prim = append(front, prim...)
|
||||
}
|
||||
// pattern / peer 附带条目恒保留在 results 末尾(独立于主结果配额)
|
||||
// standing_answer(2026-11-17):语义常设卡 prepend 进 results 后被 limit 切掉第 5 条记忆
|
||||
// ⇒ 13 道题的主尺从 0.5575 掉到 0.5337(2 道 DA 恰在 rank5)。卡片是「答案」、记忆是「证据」,
|
||||
// 两者都不能丢 ⇒ 与 pattern/peer 同待遇:不占主结果配额。
|
||||
prim = append(prim, carry...)
|
||||
if expanded == nil {
|
||||
expanded = exp
|
||||
@@ -1761,18 +1771,25 @@ func capRecallResults(results []models.RecallResult, limit int) (prim, expanded
|
||||
//
|
||||
// 2026-11-02(t_2891d689)两处修订:
|
||||
// ① 返回值加 mainLen(主路段截断后的长度)。4ffc546 后 carry 使 len(results) 可以
|
||||
// 超过 limit,翻页判据若看 len(results) 会恒假 ⇒ nextCont 恒空、带注入的 query
|
||||
// 翻页链断裂(本卡病灶)。判据改看主路段(见 shouldEmitContinuation)。
|
||||
//
|
||||
// 超过 limit,翻页判据若看 len(results) 会恒假 ⇒ nextCont 恒空、带注入的 query
|
||||
// 翻页链断裂(本卡病灶)。判据改看主路段(见 shouldEmitContinuation)。
|
||||
//
|
||||
// ② carry 只在第一页出现:carry 是固定钉住的注入条目,第一页其 ID 已随 returned
|
||||
// 记进令牌 prev;续页再追加必然逐页重复,等于把去重成本转嫁给客户端。
|
||||
// ⇒ offset > 0 时只回主路段,不追加 carry。
|
||||
//
|
||||
// 记进令牌 prev;续页再追加必然逐页重复,等于把去重成本转嫁给客户端。
|
||||
// ⇒ offset > 0 时只回主路段,不追加 carry。
|
||||
func paginateRecallWithCarry(results []models.RecallResult, offset int, prevIDs []string, limit int) ([]models.RecallResult, int) {
|
||||
var carry []models.RecallResult
|
||||
var front []models.RecallResult // standing_answer:答案置顶、不占主结果配额
|
||||
main := make([]models.RecallResult, 0, len(results))
|
||||
for _, r := range results {
|
||||
if r.Category == "pattern" || r.Category == "peer" {
|
||||
switch r.Category {
|
||||
case "pattern", "peer":
|
||||
carry = append(carry, r)
|
||||
} else {
|
||||
case "standing_answer":
|
||||
front = append(front, r)
|
||||
default:
|
||||
main = append(main, r)
|
||||
}
|
||||
}
|
||||
@@ -1801,14 +1818,19 @@ func paginateRecallWithCarry(results []models.RecallResult, offset int, prevIDs
|
||||
}
|
||||
mainLen := len(main)
|
||||
if mainLen == 0 {
|
||||
// 与旧语义一致:主路段空 ⇒ 整页空(页面上只有注入条目没有意义)
|
||||
// 主路段空:若只有常设卡(精确通道命中即只回卡),卡本身就是有效答案,不能吞掉;
|
||||
// 含 pattern/peer 的纯注入页仍按旧语义返回空页。
|
||||
if len(front) > 0 {
|
||||
return front, 0
|
||||
}
|
||||
return []models.RecallResult{}, 0
|
||||
}
|
||||
if offset > 0 {
|
||||
// t_2891d689:carry 只在第一页出现,续页不回尾(见函数头注释 ②)
|
||||
return main, mainLen
|
||||
}
|
||||
return append(main, carry...), mainLen
|
||||
out := append(front, main...)
|
||||
return append(out, carry...), mainLen
|
||||
}
|
||||
|
||||
// shouldEmitContinuation —— P0-3 是否发放下一页 continuation 令牌(2026-11-02 t_2891d689)。
|
||||
|
||||
@@ -0,0 +1,96 @@
|
||||
package storage
|
||||
|
||||
import (
|
||||
"os"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// 2026-11-16 ftsReserveSlots:让位预算随 topK 缩放。
|
||||
// 判据(无覆盖文件时):topK/2 封顶 3 —— k=5 ⇒ 2、k=6 ⇒ 3、k≥6 恒 3(= 旧值)。
|
||||
func TestFtsReserveSlots_ScaledByTopK(t *testing.T) {
|
||||
t.Setenv("ZHIYI_FTS_RESERVE_FILE", "/nonexistent/recall-fts-reserve")
|
||||
cases := []struct{ topK, want int }{
|
||||
{1, 0}, {2, 1}, {3, 1}, {4, 2}, {5, 2}, {6, 3}, {7, 3}, {10, 3}, {50, 3},
|
||||
}
|
||||
for _, c := range cases {
|
||||
if got := ftsReserveSlots(c.topK); got != c.want {
|
||||
t.Errorf("ftsReserveSlots(%d)=%d want %d", c.topK, got, c.want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 关键回归点:小 k 下预留位不得吃掉整条主路径(k=1/2 时预算必须 < topK)。
|
||||
func TestFtsReserveSlots_NeverEatsWholeList(t *testing.T) {
|
||||
for k := 1; k <= 10; k++ {
|
||||
if got := ftsReserveSlots(k); got >= k && k > 1 {
|
||||
t.Errorf("ftsReserveSlots(%d)=%d 会吃掉全部槽位", k, got)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 2026-11-17 selectionWindow 默认改为**常数**(与 topK 解耦)。
|
||||
//
|
||||
// 理由不是「提分」(+0.79pp 属噪声内),而是**不变量**:改前 window(5)=10、window(20)=40,
|
||||
// 同一 query 请求 5 条与 20 条看到不同候选池 ⇒ 实测 `日志分析怎么定位根因` 在 k=20 时
|
||||
// DA 排第 4、k=5 时完全不在(top5 ⊄ top20)。用户换个 top_k 就拿到不同答案。
|
||||
// 改后实测 16 题 top5 ⊄ top20 = 0 道。
|
||||
func TestSelectionWindow_DecoupledFromTopK(t *testing.T) {
|
||||
t.Setenv("ZHIYI_SEL_WINDOW_FILE", "/nonexistent/recall-sel-window")
|
||||
cases := []struct{ topK, want int }{
|
||||
{1, selectionWindowDefault}, {5, selectionWindowDefault},
|
||||
{10, selectionWindowDefault}, {20, selectionWindowDefault},
|
||||
{50, selectionWindowDefault}, {100, selectionWindowDefault},
|
||||
{150, 150}, // 窗口不能小于请求条数
|
||||
}
|
||||
for _, c := range cases {
|
||||
if got := selectionWindow(c.topK); got != c.want {
|
||||
t.Errorf("selectionWindow(%d)=%d want %d", c.topK, got, c.want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 单调性 + 恒定:k ≤ 默认值时窗口恒定(同一候选池 ⇒ 前缀结果一致)。
|
||||
func TestSelectionWindow_Monotonic(t *testing.T) {
|
||||
t.Setenv("ZHIYI_SEL_WINDOW_FILE", "/nonexistent/recall-sel-window")
|
||||
prev := 0
|
||||
for k := 1; k <= 200; k++ {
|
||||
w := selectionWindow(k)
|
||||
if w < prev {
|
||||
t.Fatalf("selectionWindow 非单调:k=%d got %d < 前一个 %d", k, w, prev)
|
||||
}
|
||||
if k <= selectionWindowDefault && w != selectionWindowDefault {
|
||||
t.Fatalf("k=%d ≤ 默认值时窗口应恒定 %d,实际 %d", k, selectionWindowDefault, w)
|
||||
}
|
||||
prev = w
|
||||
}
|
||||
}
|
||||
|
||||
// 旋钮 0 = 回滚到旧行为(topK*2)。
|
||||
func TestSelectionWindow_LegacyViaKnobZero(t *testing.T) {
|
||||
f := filepath.Join(t.TempDir(), "recall-sel-window")
|
||||
if err := os.WriteFile(f, []byte("0"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Setenv("ZHIYI_SEL_WINDOW_FILE", f)
|
||||
for _, c := range []struct{ topK, want int }{{1, 2}, {5, 10}, {20, 40}} {
|
||||
if got := selectionWindow(c.topK); got != c.want {
|
||||
t.Errorf("旋钮=0 时 selectionWindow(%d)=%d want %d(旧行为 topK*2)", c.topK, got, c.want)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 旋钮 n>0 = 窗口取 max(n, topK)。
|
||||
func TestSelectionWindow_KnobWidens(t *testing.T) {
|
||||
f := filepath.Join(t.TempDir(), "recall-sel-window")
|
||||
if err := os.WriteFile(f, []byte("40"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Setenv("ZHIYI_SEL_WINDOW_FILE", f)
|
||||
if got := selectionWindow(5); got != 40 {
|
||||
t.Errorf("旋钮=40 时 selectionWindow(5)=%d want 40", got)
|
||||
}
|
||||
if got := selectionWindow(60); got != 60 {
|
||||
t.Errorf("旋钮=40 时 selectionWindow(60)=%d want 60(不得小于请求条数)", got)
|
||||
}
|
||||
}
|
||||
+257
-10
@@ -520,12 +520,23 @@ func (p *RecallPipeline) RecallWithMetaTraced(ctx context.Context, query, namesp
|
||||
if ctx == nil {
|
||||
ctx = context.Background()
|
||||
}
|
||||
// 常设答案精确命中 ⇒ 零检索零 LLM 直接返回,不进入 rerank/LLM:
|
||||
// 省 LLM 配额,且程序性记忆层在 LLM 过载(429)时仍可用。
|
||||
// 命中口径是归一化后整句相等(question + op.trigger 变体),无模糊面,
|
||||
// 不会误吞泛化查询;未命中时走下面的完整召回,行为逐位不变。
|
||||
// 常设答案精确命中(2026-10-25 加入):
|
||||
// 2026-11-17 改:**不再零检索短路**。旧行为是 return 只含 1 条卡的切片,
|
||||
// 后果有两层:① 用户的硬要求「卡是答案、记忆是证据,两者都不能丢」被违反;
|
||||
// ② golden 里 7~8 道被整句命中的题,DA 明明在库里却因为整片记忆被吞而在主尺上归零。
|
||||
// 新行为:照常走完整管线(rerank/LLM 成本换正确性),卡片置顶、
|
||||
// 且在 capRecallResults / paginateRecallWithCarry 里不占 limit 配额。
|
||||
// 降级保留:管线报错时仍只回卡(程序性记忆层在 LLM 过载时可用),status 标 partial。
|
||||
if sa := standingAnswerFor(query); sa != nil {
|
||||
return []models.RecallResult{{
|
||||
results, meta, err := p.recallWithMetaInner(ctx, query, namespace, topK, diversity, allowNSFallback, tr)
|
||||
if tr != nil {
|
||||
meta.TraceID = tr.TraceID
|
||||
if tr.Status == "partial" {
|
||||
meta.Status = "partial"
|
||||
meta.PartialReason = tr.PartialReason
|
||||
}
|
||||
}
|
||||
card := models.RecallResult{
|
||||
ID: "standing:" + sa.QuestionID,
|
||||
Content: sa.Answer,
|
||||
Category: "standing_answer",
|
||||
@@ -533,7 +544,24 @@ func (p *RecallPipeline) RecallWithMetaTraced(ctx context.Context, query, namesp
|
||||
Timestamp: sa.UpdatedAt.Format(time.RFC3339),
|
||||
Source: "standing_answer",
|
||||
Channel: "standing",
|
||||
}}, RecallMeta{StandingAnswerHit: sa.QuestionID, Status: "ok"}, nil
|
||||
}
|
||||
// 语义通道可能已把同一张卡 prepend 进 results ⇒ 按 ID 去重,避免一张卡出现两次
|
||||
out := make([]models.RecallResult, 0, len(results)+1)
|
||||
out = append(out, card)
|
||||
for _, r := range results {
|
||||
if r.ID == card.ID {
|
||||
continue
|
||||
}
|
||||
out = append(out, r)
|
||||
}
|
||||
meta.StandingAnswerHit = sa.QuestionID
|
||||
if err != nil {
|
||||
// 只回卡,别把「证据没取到」伪装成正常
|
||||
meta.Status = "partial"
|
||||
meta.PartialReason = "standing_only:" + err.Error()
|
||||
return out[:1], meta, nil
|
||||
}
|
||||
return out, meta, nil
|
||||
}
|
||||
results, meta, err := p.recallWithMetaInner(ctx, query, namespace, topK, diversity, allowNSFallback, tr)
|
||||
if tr != nil {
|
||||
@@ -675,6 +703,24 @@ func (p *RecallPipeline) recallUncached(ctx context.Context, query, namespace st
|
||||
tr.Stage("encode", stEncode, 0)
|
||||
}
|
||||
|
||||
// 语义常设答案通道(t_standing_sem,2026-11-16):精确通道只认整句相等,
|
||||
// 留出变体 0/35 命中 ⇒ 在这里用**已算好的 queryVec** 做一次余弦候选,
|
||||
// 过「主体/反义/数字」三闸门才认。三档:off(默认,逐位等价)/ shadow(只打日志)/ on(短路返回)。
|
||||
// 复用 queryVec ⇒ 零额外 embedding 延迟。
|
||||
// on 模式不短路:卡片置顶 + 保留全部记忆证据。
|
||||
// 2026-11-17 改:短路只回 1 条卡 ⇒ 13 道题在主尺上归零(0.5575→0.4980)。
|
||||
// 但用户要的是「答案 + 依据」,所以卡片 prepend、记忆照常返回(top_k 条 + 1 张卡)。
|
||||
var semCard *StandingAnswer
|
||||
var semQID string
|
||||
if semMode := standingSemMode(); semMode != "off" {
|
||||
if sa, c := p.standingSemanticCheck(query, queryVec, semMode == "on", true); sa != nil {
|
||||
log.Printf("[standing][sem] mode=%s qid=%s cos=%.3f query=%q", semMode, sa.QuestionID, c, query)
|
||||
if semMode == "on" {
|
||||
semCard, semQID = sa, sa.QuestionID
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Step 2: Coarse search — own namespace + shared(§1.3 召回规则)
|
||||
// 默认搜自己的 namespace + shared,显式 include_namespaces 时才跨域
|
||||
// 2026-09-21 五修(t_24eceed0 返修):namespace=="" → 全库跨命名空间召回。
|
||||
@@ -976,7 +1022,29 @@ func (p *RecallPipeline) recallUncached(ctx context.Context, query, namespace st
|
||||
if floor := envInt("ZHIYI_RERANK_N_FLOOR", 10); floor > rerankN {
|
||||
rerankN = floor
|
||||
}
|
||||
reranked, err := p.reranker.RerankWithVectors(queryVec, docs, docVecs, rerankN)
|
||||
// t_rerank_depth (2026-11-17): 重排深度与请求 topK 解耦。
|
||||
// 病根证据:同一批 84 道 DA 题,k=5 请求的主尺 0.5476 / 0.5536(两次同参),
|
||||
// 「k=20 请求取前 5」0.6091 —— 差 5.5pp。窗口已解耦(selectionWindow=100),
|
||||
// 但 rerankN 仍 = topK*2(k=5 ⇒ 10、k=20 ⇒ 40),第 11~40 条结构性不进重排,
|
||||
// 于是「换个 top_k 就换一套答案」的不变量违背只修了一半。
|
||||
// 热调:/var/lib/memoryweave/recall-rerank-depth 写整数;0/缺失 ⇒ 逐位等价现状(可回滚)。
|
||||
if d := rerankDepthFloor(); d > rerankN {
|
||||
rerankN = d
|
||||
}
|
||||
if rerankN > len(candidates) {
|
||||
rerankN = len(candidates)
|
||||
}
|
||||
// 2026-11-17 体检(全面测试)发现:外部 rerank API 只送 ZHIYI_RERANK_API_MAX_DOCS
|
||||
// (默认 50)条文档 ⇒ top_k > 50 时返回条数被静默封顶(实测 top_k=200 → count=50、
|
||||
// truncated=null、candidates_scanned=200)。契约「绝不无声截断必需上下文」⇒ 打标。
|
||||
rerankCapped := false
|
||||
// 判据用 topK 而非 rerankN:rerankN = max(topK*2, floor) 恒 > 50,拿它比会把
|
||||
// 每一次请求都误标成截断(k=5 实测踩到)。只有当「请求条数 > 送排条数」时,
|
||||
// 返回条数才真会被压到 maxDocs —— 那才是需要告警的截断。
|
||||
if maxDocs := envInt("ZHIYI_RERANK_API_MAX_DOCS", 50); maxDocs > 0 && topK > maxDocs {
|
||||
rerankCapped = true
|
||||
}
|
||||
reranked, err := p.reranker.RerankPreferAPI(query, docs, queryVec, docVecs, rerankN)
|
||||
if err != nil {
|
||||
log.Printf("[recall] 向量重排跳过(%v),回退文本重排", err)
|
||||
reranked, err = p.reranker.Rerank(query, docs, rerankN)
|
||||
@@ -1138,13 +1206,43 @@ func (p *RecallPipeline) recallUncached(ctx context.Context, query, namespace st
|
||||
return nil, RecallMeta{CandidatesScanned: poolSize, Truncated: truncated, Status: "partial", PartialReason: "deadline_exceeded"}, nil
|
||||
}
|
||||
stMMR := time.Now()
|
||||
finalIndices := MMRSelect(reranked, candidates, topK*2, diversity)
|
||||
// 2026-11-16 t_rerank_hold:rerank「保位」——把**重排前向量序**的前 N 条钉死在头部,
|
||||
// 只让其余条目参与 cross-encoder/MMR 竞争。
|
||||
// 背景:真 rerank 上线后主尺 0.2639→0.5258(+99%),但 6 道 n_da=1 的窄 how-to 题
|
||||
// 从 1.00 掉到 0(cross-encoder 把唯一答案那一批压出了 top5)。11-12 离线重放同结论:
|
||||
// 全重排 0.3724 < 保 top3 0.3900。默认 0 ⇒ MMRSelect 原样调用,逐位等价现状。
|
||||
hold := envInt("ZHIYI_RERANK_HOLD", 0)
|
||||
var finalIndices []int
|
||||
if hold > 0 && hold < len(candidates) {
|
||||
keep := hold
|
||||
win := selectionWindow(topK)
|
||||
if maxKeep := win; keep > maxKeep {
|
||||
keep = maxKeep
|
||||
}
|
||||
finalIndices = make([]int, 0, win)
|
||||
for i := 0; i < keep; i++ {
|
||||
finalIndices = append(finalIndices, i)
|
||||
}
|
||||
rest := make([]models.RerankResult, 0, len(reranked))
|
||||
for _, r := range reranked {
|
||||
if r.Index >= keep {
|
||||
rest = append(rest, r)
|
||||
}
|
||||
}
|
||||
if need := win - len(finalIndices); need > 0 {
|
||||
finalIndices = append(finalIndices, MMRSelect(rest, candidates, need, diversity)...)
|
||||
}
|
||||
log.Printf("[recall][hold] rerank 保位前 %d 条(共 %d 候选,池 %d)", keep, len(candidates), len(finalIndices))
|
||||
} else {
|
||||
finalIndices = MMRSelect(reranked, candidates, selectionWindow(topK), diversity)
|
||||
}
|
||||
|
||||
// RRF 开启时多取一倍候选进融合池:只在 topK 内部重排不会改变 top5 的**集合**(等于没效果),
|
||||
// 第 6~10 名必须有机会被词面秩抬进前 5,融合才可能有增益。门控关 ⇒ poolN==topK,逐位等价现状。
|
||||
poolN := topK
|
||||
if rrfEnabled() {
|
||||
poolN = topK * 2
|
||||
// 融合池必须与选择窗口同宽,否则"窗口选了 20 条、池只放 10 条"⇒ 后半截白选。
|
||||
poolN = selectionWindow(topK)
|
||||
}
|
||||
results := make([]models.RecallResult, 0, poolN)
|
||||
for i, idx := range finalIndices {
|
||||
@@ -1293,7 +1391,22 @@ func (p *RecallPipeline) recallUncached(ctx context.Context, query, namespace st
|
||||
// 槽位(头部至多让 3 位;回归面收敛且只在 FTS 真有命中时发生)
|
||||
budget := topK - len(results)
|
||||
if len(results) >= topK {
|
||||
budget = 3
|
||||
budget = ftsReserveSlots(topK)
|
||||
}
|
||||
// t_fts_tail_head (2026-11-17):**头部保护** —— 让位槽不得吃进前 head 名。
|
||||
// 病根证据(同库同 query、串行 no_cache、三次重复全一致):
|
||||
// k=5 返回 [v,v,v,fts,fts](第 4~5 名被让给词面命中),
|
||||
// k=20 返回 [v,v,v,v,v](融合池前 8 名逐位相同,FTS 落在 18~20 名)。
|
||||
// 同一份 84 题主尺:k=5 → 0.55357;k=20 取前 5 → 0.60913(+7/−0)。
|
||||
// 即:小 k 时「尾部让位」= 吃掉答案的 40%,而 k 大时它落在无人看的位置。
|
||||
// 缺省 0 ⇒ 逐位等价现状(可回滚);热调文件 recall-fts-tail-head。
|
||||
if h := ftsTailHeadProtect(); h > 0 && len(results) >= topK {
|
||||
if room := topK - h; budget > room {
|
||||
if room < 0 {
|
||||
room = 0
|
||||
}
|
||||
budget = room
|
||||
}
|
||||
}
|
||||
nAppend := budget
|
||||
if nAppend > len(fresh) {
|
||||
@@ -1504,6 +1617,28 @@ func (p *RecallPipeline) recallUncached(ctx context.Context, query, namespace st
|
||||
tr.MarkPartial("row_cap_truncated")
|
||||
}
|
||||
}
|
||||
if rerankCapped && partialReason == "" {
|
||||
truncated = true
|
||||
status = "partial"
|
||||
partialReason = "rerank_docs_capped"
|
||||
if tr != nil {
|
||||
tr.MarkPartial("rerank_docs_capped")
|
||||
}
|
||||
log.Printf("[recall] 结果被封顶:rerank 只送 %d 条 < 请求 topK=%d(ZHIYI_RERANK_API_MAX_DOCS)",
|
||||
envInt("ZHIYI_RERANK_API_MAX_DOCS", 50), topK)
|
||||
}
|
||||
if semCard != nil {
|
||||
card := models.RecallResult{
|
||||
ID: "standing:" + semQID,
|
||||
Content: semCard.Answer,
|
||||
Category: "standing_answer",
|
||||
Score: 1.0,
|
||||
Timestamp: semCard.UpdatedAt.Format(time.RFC3339),
|
||||
Source: "standing_answer",
|
||||
Channel: "standing",
|
||||
}
|
||||
results = append([]models.RecallResult{card}, results...)
|
||||
}
|
||||
return results, RecallMeta{CandidatesScanned: poolSize, Truncated: truncated, Status: status, PartialReason: partialReason}, nil
|
||||
}
|
||||
|
||||
@@ -1772,3 +1907,115 @@ func filterRecallRawCategories(results []models.RecallResult) []models.RecallRes
|
||||
}
|
||||
return filtered
|
||||
}
|
||||
|
||||
// ftsReserveSlots 返回 FTS 尾部位预留槽数(Step 3.8)。
|
||||
//
|
||||
// 2026-11-16(t_fts_reserve_scaled)为什么需要它:
|
||||
// 原实现硬编码 3 位,且这 3 位是在 `results[:topK]` 截断**之后**才让出来的 ——
|
||||
// 结果条数已等于 topK 时,"让位"只能从已截断的主路径尾部抢 ⇒ 向量路径的第 3 名
|
||||
// 被凭空吃掉。实测同一 query、同一时刻、no_cache:
|
||||
//
|
||||
// top_k=5 → 标准答案不在前 5;top_k=6 → 稳定第 3 位(其余顺序完全不变)
|
||||
//
|
||||
// 主尺 84 题同批调用:top_k=5 取前 5 = 0.5139,top_k=10 取前 5 = 0.6448(+13.1pp),
|
||||
// 反转顺序(30→10→5)复测 0.5375 vs 0.6542(+11.7pp)⇒ 不是曝光顺序假象。
|
||||
// 差额主因就是这 3 个保留位在小 k 下的占比过高(k=5 时占 60%)。
|
||||
//
|
||||
// 规则:min(3, topK/2) —— k=5 ⇒ 2、k=6 ⇒ 3、k≥6 恒 3(= 原值,零回归面)。
|
||||
// 热调:`/var/lib/memoryweave/recall-fts-reserve` 写整数(0..3)即覆盖本规则,
|
||||
// 无需重启(A/B 用);回滚 = 写 3(逐位回到改动前行为)。
|
||||
func ftsReserveSlots(topK int) int {
|
||||
if b, err := os.ReadFile(recallKnobPath("recall-fts-reserve", "ZHIYI_FTS_RESERVE_FILE")); err == nil {
|
||||
if v, err := strconv.Atoi(strings.TrimSpace(string(b))); err == nil && v >= 0 {
|
||||
if v > topK {
|
||||
v = topK
|
||||
}
|
||||
return v
|
||||
}
|
||||
}
|
||||
n := topK / 2
|
||||
if n > 3 {
|
||||
n = 3
|
||||
}
|
||||
if n < 0 {
|
||||
n = 0
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
// selectionWindowDefault 是与请求 topK 解耦的窗口常数。窗 40 与窗 100 实测同分,
|
||||
// 取 100 只为把「大 k 包含小 k」的不变量覆盖到 k ≤ 100 全区间。
|
||||
const selectionWindowDefault = 100
|
||||
|
||||
// selectionWindow 返回 MMR/RRF 的「选择窗口」宽度 —— 与请求的 topK 解耦。
|
||||
//
|
||||
// 2026-11-16(t_sel_window):原实现在两处用 topK*2 作为窗口,于是**同一 query
|
||||
// 请求 5 条与请求 50 条拿到的前 5 名不同**。
|
||||
//
|
||||
// 2026-11-17 改默认(**为修不变量,不为提分**):默认窗口 = 常数 100。
|
||||
// 病根证据:`日志分析怎么定位根因` 在 top_k=20 时 DA 排第 4,top_k=5 时完全不在结果里
|
||||
// ⇒ top5 ⊄ top20,用户换个 top_k 就拿到不同答案。机制就是窗口随 k 缩放:
|
||||
// k=5 只在前 10 条里做 MMR/RRF,第 11 条起的好答案结构性没机会。
|
||||
// 改后实测:16 题 top5 ⊄ top20 = 0 道(不变量成立);主尺 0.55754 → 0.56548(+0.79pp);
|
||||
// 窗 40 与窗 100 同分(池深饱和)⇒ 选 100 是为了把不变量覆盖到 k ≤ 100 全区间;
|
||||
// 延迟 p50 1.01s → 1.09s(+80ms)。
|
||||
// 热调:/var/lib/memoryweave/recall-sel-window 写整数 —— 0 = 旧行为(topK*2,回滚用),
|
||||
// n>0 = 窗口取 max(n, topK)。文件缺失 ⇒ 常数默认。
|
||||
func selectionWindow(topK int) int {
|
||||
if b, err := os.ReadFile(recallKnobPath("recall-sel-window", "ZHIYI_SEL_WINDOW_FILE")); err == nil {
|
||||
if v, err := strconv.Atoi(strings.TrimSpace(string(b))); err == nil && v >= 0 {
|
||||
if v == 0 {
|
||||
return topK * 2
|
||||
}
|
||||
if v > topK {
|
||||
return v
|
||||
}
|
||||
return topK
|
||||
}
|
||||
}
|
||||
// 窗口不能小于请求条数,否则凑不满 k。
|
||||
if topK > selectionWindowDefault {
|
||||
return topK
|
||||
}
|
||||
return selectionWindowDefault
|
||||
}
|
||||
|
||||
// ftsTailHeadProtect 返回 FTS 尾部让位时受保护的头部名次数(0 = 不保护,现状)。
|
||||
// 热调:/var/lib/memoryweave/recall-fts-tail-head;env 兜底 ZHIYI_FTS_TAIL_HEAD。
|
||||
func ftsTailHeadProtect() int {
|
||||
if b, err := os.ReadFile(recallKnobPath("recall-fts-tail-head", "ZHIYI_FTS_TAIL_HEAD_FILE")); err == nil {
|
||||
if v, err := strconv.Atoi(strings.TrimSpace(string(b))); err == nil && v > 0 {
|
||||
return v
|
||||
}
|
||||
}
|
||||
// 缺省 0 = 逐位等价旧行为(测试锁旧契约);生产由 unit Environment
|
||||
// ZHIYI_FTS_TAIL_HEAD=5 开启。配对实测(84 题同库同窗):0 → 0.55357、
|
||||
// 5 → 0.60913(+7/−0,掉零 29→24,p50 1.48s→0.99s)。
|
||||
return envInt("ZHIYI_FTS_TAIL_HEAD", 0)
|
||||
}
|
||||
|
||||
// rerankDepthFloor 返回「最小重排深度」——把 rerankN 从 topK*2 解耦成常数。
|
||||
// 0 / 文件缺失 / 解析失败 ⇒ 0(不抬高 rerankN,行为与旧版逐位等价)。
|
||||
// 热调:/var/lib/memoryweave/recall-rerank-depth;env 覆盖走 ZHIYI_RERANK_DEPTH / ZHIYI_RERANK_DEPTH_FILE。
|
||||
func rerankDepthFloor() int {
|
||||
if b, err := os.ReadFile(recallKnobPath("recall-rerank-depth", "ZHIYI_RERANK_DEPTH_FILE")); err == nil {
|
||||
if v, err := strconv.Atoi(strings.TrimSpace(string(b))); err == nil && v > 0 {
|
||||
return v
|
||||
}
|
||||
}
|
||||
if v := envInt("ZHIYI_RERANK_DEPTH", 0); v > 0 {
|
||||
return v
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
// recallKnobPath 返回热调旋钮文件路径。
|
||||
// 为什么要 env 覆盖:单测读的是真实生产文件 ⇒ 生产上调过旋钮就会让单测红/绿翻转
|
||||
// (2026-11-16 实际踩到:knob=100 时 TestSelectionWindow_DefaultsToLegacy 直接 FAIL)。
|
||||
// 单测里 t.Setenv(<env>, <不存在的 tmp 路径>) ⇒ 走默认分支,行为可确定性断言。
|
||||
func recallKnobPath(name, envKey string) string {
|
||||
if p := os.Getenv(envKey); p != "" {
|
||||
return p
|
||||
}
|
||||
return "/var/lib/memoryweave/" + name
|
||||
}
|
||||
|
||||
@@ -129,6 +129,12 @@ func expectedYield(topK, P, F int) (total, nAppend int) {
|
||||
if nAppend > topK { // t_bd718662 修后:让位上限 = min(3,F,现有条数)
|
||||
nAppend = topK
|
||||
}
|
||||
// 2026-11-17 对齐 ftsReserveSlots 现行契约:FTS 尾部预算随 topK 缩放
|
||||
// (min(3, topK/2),见 recall.go ftsReserveSlots)——旧期望写死 3,
|
||||
// 导致 topK∈{1,2,3} 的 P>=topK 全表红;这是**测试过时**不是代码回归。
|
||||
if half := topK / 2; nAppend > half {
|
||||
nAppend = half
|
||||
}
|
||||
total = topK
|
||||
}
|
||||
return
|
||||
@@ -223,3 +229,50 @@ func TestFTS_SmallTopKGolden(t *testing.T) {
|
||||
t.Logf("%s", line)
|
||||
}
|
||||
}
|
||||
|
||||
// TestFTS_TailHeadProtect —— 头部保护契约(2026-11-17):
|
||||
// 生产用 ZHIYI_FTS_TAIL_HEAD=5 时,topK<=5 的让位槽为 0(词面命中不得吃掉答案头部);
|
||||
// 关掉旋钮必须逐位回到旧契约(min(3,topK/2) 个尾部槽位);结果集未满时追加路径不受影响。
|
||||
func TestFTS_TailHeadProtect(t *testing.T) {
|
||||
t.Run("head=5_topK5_不占用头部", func(t *testing.T) {
|
||||
t.Setenv("ZHIYI_FTS_TAIL_HEAD", "5")
|
||||
res := runMatrixCell(t, 5, 5, 5)
|
||||
fts := 0
|
||||
for _, r := range res {
|
||||
if r.FtsBoosted {
|
||||
fts++
|
||||
}
|
||||
}
|
||||
if fts != 0 || len(res) != 5 {
|
||||
t.Fatalf("head=5 topK=5:期望 5 条纯池内结果,实际 fts=%d len=%d %v", fts, len(res), idsRes(res))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("head=0_topK5_旧契约", func(t *testing.T) {
|
||||
t.Setenv("ZHIYI_FTS_TAIL_HEAD", "0")
|
||||
res := runMatrixCell(t, 5, 5, 5)
|
||||
fts := 0
|
||||
for _, r := range res {
|
||||
if r.FtsBoosted {
|
||||
fts++
|
||||
}
|
||||
}
|
||||
if fts != 2 {
|
||||
t.Fatalf("head=0 topK=5:期望 2 个尾部让位槽(min(3,5/2)),实际 %d %v", fts, idsRes(res))
|
||||
}
|
||||
})
|
||||
|
||||
t.Run("head=5_未满时仍可追加", func(t *testing.T) {
|
||||
t.Setenv("ZHIYI_FTS_TAIL_HEAD", "5")
|
||||
res := runMatrixCell(t, 5, 3, 5)
|
||||
fts := 0
|
||||
for _, r := range res {
|
||||
if r.FtsBoosted {
|
||||
fts++
|
||||
}
|
||||
}
|
||||
if fts == 0 {
|
||||
t.Fatalf("池内仅 3 条时 FTS 应补足到 5,实际 0 条 FTS %v", idsRes(res))
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
+136
-58
@@ -2,6 +2,7 @@ package storage
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
@@ -10,6 +11,7 @@ import (
|
||||
"net/http"
|
||||
"os"
|
||||
"sort"
|
||||
"sync"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
@@ -171,6 +173,50 @@ func (r *Reranker) RerankWithVectors(queryVec []float32, documents []string, doc
|
||||
return results, nil
|
||||
}
|
||||
|
||||
// RerankPreferAPI 是生产 recall 的重排入口(2026-11-12 牧尘令「rerank 开」)。
|
||||
//
|
||||
// 背景:旧调用点只走 RerankWithVectors(纯向量 cosine),apiRerank 只在出错时兜底,
|
||||
// 于是「设 RERANK_ENDPOINT + MOLIFANG_API_KEY」在生产上等于空转 —— 2026-11-12 用本地桩
|
||||
// 实测 6 发 recall(含 debug / limit=50 / use_rerank)桩收到 0 请求、日志 0 条 [rerank] 证实。
|
||||
//
|
||||
// 新语义:有 MOLIFANG_API_KEY ⇒ 先走模力方舟 cross-encoder(apiRerank,内置 25 条分批);
|
||||
// 无 key 或 API 失败 ⇒ 退回 RerankWithVectors(亚毫秒、零外呼),保证召回不因外部服务拖垮。
|
||||
func (r *Reranker) RerankPreferAPI(query string, documents []string, queryVec []float32, docVecs [][]float32, topN int) ([]models.RerankResult, error) {
|
||||
if len(documents) == 0 {
|
||||
return nil, nil
|
||||
}
|
||||
if r.apiKey != "" {
|
||||
// 候选过多会变成多次 25 条批次(实测 100 条 = 4 批 ≈ 1.5~3s,逼近 prefetch 8s 预算)。
|
||||
// docs 进来时已按 ANN 分数有序 ⇒ 截前 N 条送 cross-encoder,既省时又保住头部质量。
|
||||
if maxDocs := envInt("ZHIYI_RERANK_API_MAX_DOCS", 50); maxDocs > 0 && len(documents) > maxDocs {
|
||||
documents = documents[:maxDocs]
|
||||
// 2026-11-17 修:只截 documents 不截 docVecs ⇒ 下游校验
|
||||
// 「doc vector count 100 != documents 50」报错,静默回退**文本重排**
|
||||
// (实测:把 rerankN 抬到 100 时每条召回都走这条路,排序悄悄换了一套)。
|
||||
if len(docVecs) > maxDocs {
|
||||
docVecs = docVecs[:maxDocs]
|
||||
}
|
||||
}
|
||||
// 外部 API 延迟抖动大(实测 0.28s / 1.28s / 10.34s),必须硬超时:
|
||||
// 超时就走向量 cosine,宁可丢一点重排质量,也不能让 prefetch 8s 预算被吃掉。
|
||||
timeout := time.Duration(envInt("ZHIYI_RERANK_TIMEOUT_MS", 2500)) * time.Millisecond
|
||||
ctx, cancel := context.WithTimeout(context.Background(), timeout)
|
||||
t0 := time.Now()
|
||||
res, err := r.apiRerankCtx(ctx, query, documents, topN)
|
||||
cancel()
|
||||
if err == nil && len(res) > 0 {
|
||||
// 成功路径必须有日志:否则「API 有没有真被调用」只能靠延迟间接推断,
|
||||
// 而上一次 rerank 空转就是这么被漏掉的(2026-11-16)。
|
||||
log.Printf("[rerank] api ok: docs=%d topN=%d took=%dms q=%.40q", len(documents), topN, time.Since(t0).Milliseconds(), query)
|
||||
return res, nil
|
||||
}
|
||||
if err != nil {
|
||||
log.Printf("[rerank] API 重排不可用(%v),降级向量 cosine q=%.40q", err, query)
|
||||
}
|
||||
}
|
||||
return r.RerankWithVectors(queryVec, documents, docVecs, topN)
|
||||
}
|
||||
|
||||
// localCosineRerank 使用 Embedder 编码 query → 对每个 doc 的向量做 cosine
|
||||
func (r *Reranker) localCosineRerank(query string, documents []string, topN int) ([]models.RerankResult, error) {
|
||||
qVec, err := r.embedder.EncodeQuery(query)
|
||||
@@ -238,69 +284,43 @@ func cosineScore(a, b []float32) float64 {
|
||||
return dot / math.Sqrt(normA*normB)
|
||||
}
|
||||
|
||||
// apiRerank 调用模力方舟 bge-reranker-v2-m3 进行 cross-encoder 重排
|
||||
// apiRerank 调用模力方舟 bge-reranker-v2-m3 进行 cross-encoder 重排(无超时控制,保留给旧调用点)
|
||||
// 限制:molifang API 每批最多 25 个文档
|
||||
func (r *Reranker) apiRerank(query string, documents []string, topN int) ([]models.RerankResult, error) {
|
||||
// 分批(每批最多 25)
|
||||
return r.apiRerankCtx(context.Background(), query, documents, topN)
|
||||
}
|
||||
|
||||
// apiRerankCtx 分批并发重排:批与批之间并行(原先串行,50 条 = 2 批时延迟翻倍),
|
||||
// 任一批失败即整体失败,由调用方降级到向量 cosine。ctx 负责整体超时。
|
||||
func (r *Reranker) apiRerankCtx(ctx context.Context, query string, documents []string, topN int) ([]models.RerankResult, error) {
|
||||
const batchSize = 25
|
||||
nBatches := (len(documents) + batchSize - 1) / batchSize
|
||||
type batchOut struct {
|
||||
res []models.RerankResult
|
||||
err error
|
||||
}
|
||||
outs := make([]batchOut, nBatches)
|
||||
var wg sync.WaitGroup
|
||||
for b := 0; b < nBatches; b++ {
|
||||
startIdx := b * batchSize
|
||||
endIdx := startIdx + batchSize
|
||||
if endIdx > len(documents) {
|
||||
endIdx = len(documents)
|
||||
}
|
||||
wg.Add(1)
|
||||
go func(b, s, e int) {
|
||||
defer wg.Done()
|
||||
outs[b].res, outs[b].err = r.apiRerankBatch(ctx, query, documents[s:e], s)
|
||||
}(b, startIdx, endIdx)
|
||||
}
|
||||
wg.Wait()
|
||||
|
||||
allResults := make([]models.RerankResult, 0, len(documents))
|
||||
for start := 0; start < len(documents); start += batchSize {
|
||||
end := start + batchSize
|
||||
if end > len(documents) {
|
||||
end = len(documents)
|
||||
}
|
||||
batch := documents[start:end]
|
||||
n := topN
|
||||
if n > len(batch) {
|
||||
n = len(batch)
|
||||
}
|
||||
reqBody := map[string]any{
|
||||
"model": "bge-reranker-v2-m3",
|
||||
"query": query,
|
||||
"documents": batch,
|
||||
"top_n": n,
|
||||
}
|
||||
body, _ := json.Marshal(reqBody)
|
||||
req, err := http.NewRequest("POST", r.endpoint, bytes.NewReader(body))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("new request: %w", err)
|
||||
}
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
if r.apiKey != "" {
|
||||
req.Header.Set("Authorization", "Bearer "+r.apiKey)
|
||||
}
|
||||
|
||||
resp, err := r.httpClient.Do(req)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("do request: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
respBody, _ := io.ReadAll(resp.Body)
|
||||
return nil, fmt.Errorf("status %d: %s", resp.StatusCode, string(respBody))
|
||||
}
|
||||
|
||||
var result struct {
|
||||
Results []struct {
|
||||
Index int `json:"index"`
|
||||
RelevanceScore float64 `json:"relevance_score"`
|
||||
Document struct {
|
||||
Text string `json:"text"`
|
||||
} `json:"document"`
|
||||
} `json:"results"`
|
||||
}
|
||||
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
|
||||
return nil, fmt.Errorf("decode: %w", err)
|
||||
}
|
||||
|
||||
for _, rr := range result.Results {
|
||||
allResults = append(allResults, models.RerankResult{
|
||||
Index: start + rr.Index,
|
||||
Score: rr.RelevanceScore,
|
||||
Text: rr.Document.Text,
|
||||
})
|
||||
for _, o := range outs {
|
||||
if o.err != nil {
|
||||
return nil, o.err
|
||||
}
|
||||
allResults = append(allResults, o.res...)
|
||||
}
|
||||
|
||||
// 全局排序取 topN
|
||||
@@ -312,3 +332,61 @@ func (r *Reranker) apiRerank(query string, documents []string, topN int) ([]mode
|
||||
}
|
||||
return allResults[:topN], nil
|
||||
}
|
||||
|
||||
// apiRerankBatch 单批(≤25 条)请求;返回的 Index 已加上 offset,可直接对原 documents 取用。
|
||||
func (r *Reranker) apiRerankBatch(ctx context.Context, query string, batch []string, offset int) ([]models.RerankResult, error) {
|
||||
if len(batch) == 0 {
|
||||
return nil, nil
|
||||
}
|
||||
// 每批回全部候选的分数(不是 topN),否则全局排序只看到各批前 N 条,
|
||||
// 跨批比较会漏掉「本批第 N+1 但全局靠前」的文档。单批 ≤25,代价可忽略。
|
||||
reqBody := map[string]any{
|
||||
"model": "bge-reranker-v2-m3",
|
||||
"query": query,
|
||||
"documents": batch,
|
||||
"top_n": len(batch),
|
||||
}
|
||||
body, _ := json.Marshal(reqBody)
|
||||
req, err := http.NewRequestWithContext(ctx, "POST", r.endpoint, bytes.NewReader(body))
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("new request: %w", err)
|
||||
}
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
if r.apiKey != "" {
|
||||
req.Header.Set("Authorization", "Bearer "+r.apiKey)
|
||||
}
|
||||
|
||||
resp, err := r.httpClient.Do(req)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("do request: %w", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
if resp.StatusCode != http.StatusOK {
|
||||
respBody, _ := io.ReadAll(resp.Body)
|
||||
return nil, fmt.Errorf("status %d: %s", resp.StatusCode, string(respBody))
|
||||
}
|
||||
|
||||
var result struct {
|
||||
Results []struct {
|
||||
Index int `json:"index"`
|
||||
RelevanceScore float64 `json:"relevance_score"`
|
||||
Document struct {
|
||||
Text string `json:"text"`
|
||||
} `json:"document"`
|
||||
} `json:"results"`
|
||||
}
|
||||
if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
|
||||
return nil, fmt.Errorf("decode: %w", err)
|
||||
}
|
||||
|
||||
out := make([]models.RerankResult, 0, len(result.Results))
|
||||
for _, rr := range result.Results {
|
||||
out = append(out, models.RerankResult{
|
||||
Index: offset + rr.Index,
|
||||
Score: rr.RelevanceScore,
|
||||
Text: rr.Document.Text,
|
||||
})
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
@@ -0,0 +1,300 @@
|
||||
package storage
|
||||
|
||||
// 语义常设答案通道(t_standing_sem,2026-11-16)。
|
||||
//
|
||||
// 背景:精确通道(standing_match.go)只认「归一化后整句相等」,7 张 op 卡对
|
||||
// 换句话问的留出变体命中 0/35 —— 用户换个说法就完全无效。
|
||||
// 本文件在精确通道之后加一层「语义候选 + 主体一致性闸门」,三档模式:
|
||||
//
|
||||
// off(默认,逐位等价)→ shadow(只打日志、不改返回)→ on(真短路返回)
|
||||
// 旋钮:/var/lib/memoryweave/standing-sem-mode、standing-sem-thr(默认 0.80)
|
||||
//
|
||||
// 为什么必须有闸门:离线实测(35 条留出变体 + 9 条对抗集、bge-m3 余弦)
|
||||
//
|
||||
// 纯语义 cos≥0.80 → 命中 23/35,对抗集误答 3/9(不可接受)
|
||||
// 语义+主体/反义/数字三闸门 → 命中 21/35,对抗集误答 0/9 ← 采用
|
||||
// 语义+闸门 cos≥0.85 → 命中 10/35,误答 0/9(保守档)
|
||||
//
|
||||
// 三道闸门防的是「看起来像但主体不同」:飞书的遗忘机制 ≠ 织忆的遗忘机制;
|
||||
// 「免费腿」≠「付费腿」。错答比不答贵,故闸门是硬门、宁可漏。
|
||||
|
||||
import (
|
||||
"math"
|
||||
"os"
|
||||
"regexp"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"log"
|
||||
)
|
||||
|
||||
const (
|
||||
semModeFile = "standing-sem-mode"
|
||||
semThrFile = "standing-sem-thr"
|
||||
)
|
||||
|
||||
// standingSemMode 读模式旋钮:off(默认)/ shadow / on。
|
||||
// 文件不存在或内容不识别 ⇒ off(绝不让配置错误静默开启自动答问)。
|
||||
func standingSemMode() string {
|
||||
b, err := os.ReadFile(recallKnobPath(semModeFile, "ZHIYI_STANDING_SEM_MODE_FILE"))
|
||||
if err != nil {
|
||||
return "off"
|
||||
}
|
||||
switch strings.ToLower(strings.TrimSpace(string(b))) {
|
||||
case "shadow":
|
||||
return "shadow"
|
||||
case "on":
|
||||
return "on"
|
||||
default:
|
||||
return "off"
|
||||
}
|
||||
}
|
||||
|
||||
// standingSemThreshold 读余弦阈值,默认 0.80,夹在 [0.60, 0.99]。
|
||||
func standingSemThreshold() float64 {
|
||||
b, err := os.ReadFile(recallKnobPath(semThrFile, "ZHIYI_STANDING_SEM_THR_FILE"))
|
||||
if err != nil {
|
||||
return 0.80
|
||||
}
|
||||
v, err := strconv.ParseFloat(strings.TrimSpace(string(b)), 64)
|
||||
if err != nil || math.IsNaN(v) {
|
||||
return 0.80
|
||||
}
|
||||
if v < 0.60 {
|
||||
return 0.60
|
||||
}
|
||||
if v > 0.99 {
|
||||
return 0.99
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
// standingSemScope 读「on 模式生效范围」前缀,空=全部卡片。
|
||||
// 分阶段放量的抓手:先只让 7 张自己写、自己验过的 OP_ 步骤卡自动答问,
|
||||
// 存量 130 张历史卡继续留在 shadow 里观察(它们的答案我没逐条验过)。
|
||||
func standingSemScope() string {
|
||||
b, err := os.ReadFile(recallKnobPath("standing-sem-scope", "ZHIYI_STANDING_SEM_SCOPE_FILE"))
|
||||
if err != nil {
|
||||
return ""
|
||||
}
|
||||
return strings.TrimSpace(string(b))
|
||||
}
|
||||
|
||||
// ownerTerms 是「主体」词表:谁的东西。与主题词(遗忘/蒸馏/三方/汇报)分开 ——
|
||||
// 主题词相同不能作为一致性依据,否则「飞书的遗忘机制」会命中「织忆的遗忘机制」。
|
||||
var ownerTerms = []string{
|
||||
"织忆", "memoryweave", "zhiyid", "kocr", "飞书", "feishu", "hermes",
|
||||
"kanban", "看板", "comfyui", "opencode", "deepseek", "sensenova",
|
||||
"分身", "小怡", "牧尘", "股票", "高考", "qqbot", "微信", "qq",
|
||||
}
|
||||
|
||||
// antiPairs 反义词对:query 出现前者、卡片出现后者 ⇒ 语义像也不能命中。
|
||||
var antiPairs = [][2]string{
|
||||
{"免费", "付费"}, {"付费", "免费"},
|
||||
{"开启", "关闭"}, {"关闭", "开启"},
|
||||
{"删除", "恢复"}, {"恢复", "删除"},
|
||||
{"打开", "关掉"}, {"关掉", "打开"},
|
||||
}
|
||||
|
||||
var asciiTokRe = regexp.MustCompile(`[A-Za-z_][A-Za-z0-9_\-\.]{2,}|\d{3,}`)
|
||||
|
||||
func ownersOf(s string) map[string]struct{} {
|
||||
out := map[string]struct{}{}
|
||||
l := strings.ToLower(s)
|
||||
for _, o := range ownerTerms {
|
||||
if strings.Contains(l, o) {
|
||||
out[o] = struct{}{}
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func asciiTokens(s string) map[string]struct{} {
|
||||
out := map[string]struct{}{}
|
||||
for _, m := range asciiTokRe.FindAllString(strings.ToLower(s), -1) {
|
||||
out[m] = struct{}{}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// standingGate 三道硬门:主体一致 + 无反义冲突 + 稀有 ASCII token 覆盖。
|
||||
// 纯函数、可单测(standing_semantic_test.go 固化了 9 条对抗样本)。
|
||||
func standingGate(query, cardQuestion, cardAnswer string) bool {
|
||||
oq, oc := ownersOf(query), ownersOf(cardQuestion)
|
||||
if len(oq) > 0 && len(oc) > 0 {
|
||||
shared := false
|
||||
for o := range oq {
|
||||
if _, ok := oc[o]; ok {
|
||||
shared = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !shared {
|
||||
return false // 主体不同:飞书的 X ≠ 织忆的 X
|
||||
}
|
||||
}
|
||||
if len(oq) > 0 && len(oc) == 0 {
|
||||
return false // 问的是某主体,卡片是通用的 ⇒ 保守拒答
|
||||
}
|
||||
ql := strings.ToLower(query)
|
||||
cql := strings.ToLower(cardQuestion)
|
||||
for _, p := range antiPairs {
|
||||
if strings.Contains(ql, p[0]) && strings.Contains(cql, p[1]) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
ta := asciiTokens(query)
|
||||
if len(ta) > 0 {
|
||||
hay := asciiTokens(cardQuestion + " " + cardAnswer)
|
||||
hit := false
|
||||
for t := range ta {
|
||||
if _, ok := hay[t]; ok {
|
||||
hit = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !hit {
|
||||
return false // 端口号/文件名/命令之间对不上 ⇒ 拒答
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// semEntry 一张卡(question 或某个 op.trigger)的向量。
|
||||
type semEntry struct {
|
||||
qid string
|
||||
text string
|
||||
vec []float32
|
||||
card *StandingAnswer
|
||||
}
|
||||
|
||||
var (
|
||||
semMu sync.Mutex
|
||||
semCache []semEntry
|
||||
semBuiltAt time.Time
|
||||
semCount int
|
||||
)
|
||||
|
||||
// semEntries 懒构建卡片向量(10 分钟或卡数变化就重建;写入侧 Upsert 会让卡数变化)。
|
||||
func (p *RecallPipeline) semEntries(logOn bool) []semEntry {
|
||||
semMu.Lock()
|
||||
defer semMu.Unlock()
|
||||
cards := loadStandingAnswers()
|
||||
if len(semCache) > 0 && time.Since(semBuiltAt) < 10*time.Minute && semCount == len(cards) {
|
||||
return semCache
|
||||
}
|
||||
var texts []string
|
||||
var owners []int
|
||||
for i := range cards {
|
||||
texts = append(texts, cards[i].Question)
|
||||
owners = append(owners, i)
|
||||
if cards[i].Op != nil {
|
||||
for _, t := range cards[i].Op.Trigger {
|
||||
if strings.TrimSpace(t) == "" {
|
||||
continue
|
||||
}
|
||||
texts = append(texts, t)
|
||||
owners = append(owners, i)
|
||||
}
|
||||
}
|
||||
}
|
||||
var out []semEntry
|
||||
const chunk = 8 // bge 网关单批过大会 400
|
||||
for i := 0; i < len(texts); i += chunk {
|
||||
j := i + chunk
|
||||
if j > len(texts) {
|
||||
j = len(texts)
|
||||
}
|
||||
vecs, err := p.embedder.Encode(texts[i:j])
|
||||
if err != nil {
|
||||
if logOn {
|
||||
log.Printf("[standing][sem] 卡片向量构建失败(%d-%d/%d): %v", i, j, len(texts), err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
for k, v := range vecs {
|
||||
idx := owners[i+k]
|
||||
out = append(out, semEntry{qid: cards[idx].QuestionID, text: texts[i+k], vec: v, card: &cards[idx]})
|
||||
}
|
||||
}
|
||||
semCache, semBuiltAt, semCount = out, time.Now(), len(cards)
|
||||
return semCache
|
||||
}
|
||||
|
||||
func cosSim(a, b []float32) float64 {
|
||||
if len(a) == 0 || len(a) != len(b) {
|
||||
return 0
|
||||
}
|
||||
var dot, na, nb float64
|
||||
for i := range a {
|
||||
x, y := float64(a[i]), float64(b[i])
|
||||
dot += x * y
|
||||
na += x * x
|
||||
nb += y * y
|
||||
}
|
||||
if na == 0 || nb == 0 {
|
||||
return 0
|
||||
}
|
||||
return dot / (math.Sqrt(na) * math.Sqrt(nb))
|
||||
}
|
||||
|
||||
// standingSemanticCheck 语义候选:取余弦最高且过闸门的卡;不过闸门一律不命中。
|
||||
// queryVec 用调用方已经算好的查询向量(不额外 embed,零额外延迟)。
|
||||
func (p *RecallPipeline) standingSemanticCheck(query string, queryVec []float32, enforceScope bool, logOn bool) (*StandingAnswer, float64) {
|
||||
thr := standingSemThreshold()
|
||||
margin := standingSemMargin()
|
||||
scope := ""
|
||||
if enforceScope {
|
||||
scope = standingSemScope()
|
||||
}
|
||||
best, second := (*StandingAnswer)(nil), (*StandingAnswer)(nil)
|
||||
bestCos, secondCos := 0.0, 0.0
|
||||
for _, e := range p.semEntries(logOn) {
|
||||
if scope != "" && !strings.HasPrefix(e.qid, scope) {
|
||||
continue // on 模式只对放量范围内的卡短路
|
||||
}
|
||||
c := cosSim(queryVec, e.vec)
|
||||
if c < thr {
|
||||
continue
|
||||
}
|
||||
if !standingGate(query, e.card.Question, e.card.Answer) {
|
||||
continue
|
||||
}
|
||||
if c > bestCos {
|
||||
best, second, bestCos, secondCos = e.card, best, c, bestCos
|
||||
continue
|
||||
}
|
||||
if c > secondCos {
|
||||
second, secondCos = e.card, c
|
||||
}
|
||||
}
|
||||
// 模糊判定门:两张卡分数贴太近 ⇒ 语义上「两可」,拒答(错答比不答贵)。
|
||||
// 实测样本:「蒸馏质量门在哪」在 OP_DISTILL_QUALITY 与既有卡 zhiyi-threshold-1-v2
|
||||
// 之间摇摆,纯取最大会答错卡。
|
||||
if best != nil && second != nil && second.QuestionID != best.QuestionID && bestCos-secondCos < margin {
|
||||
if logOn {
|
||||
log.Printf("[standing][sem] 模糊拒绝 best=%s(%.3f) second=%s(%.3f) margin<%.3f",
|
||||
best.QuestionID, bestCos, second.QuestionID, secondCos, margin)
|
||||
}
|
||||
return nil, 0
|
||||
}
|
||||
return best, bestCos
|
||||
}
|
||||
|
||||
// standingSemMargin 读模糊拒绝边距,默认 0.02,夹在 [0, 0.20]。
|
||||
func standingSemMargin() float64 {
|
||||
b, err := os.ReadFile(recallKnobPath("standing-sem-margin", "ZHIYI_STANDING_SEM_MARGIN_FILE"))
|
||||
if err != nil {
|
||||
return 0.02
|
||||
}
|
||||
v, err := strconv.ParseFloat(strings.TrimSpace(string(b)), 64)
|
||||
if err != nil || math.IsNaN(v) || v < 0 {
|
||||
return 0.02
|
||||
}
|
||||
if v > 0.20 {
|
||||
return 0.20
|
||||
}
|
||||
return v
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
package storage
|
||||
|
||||
// 语义常设通道的闸门回归测试。
|
||||
// 对抗样本来自 2026-11-16 离线实测(9 条「同模板换主体/换词」的问法,纯语义
|
||||
// cos≥0.80 时曾有 3/9 误答);这些样本每次改动闸门都必须仍然被拒 —— 错答比不答贵。
|
||||
|
||||
import "testing"
|
||||
|
||||
func TestStandingGate_RejectsWrongSubject(t *testing.T) {
|
||||
cardQ := "织忆的遗忘窗口机制是怎么扫描的"
|
||||
cardA := "三层扫描:usage_track TTL / memories decay / 存真去伪候选"
|
||||
cases := []string{
|
||||
"KOCR 的遗忘窗口机制是怎么扫描的",
|
||||
"飞书的遗忘窗口机制是怎么扫描的",
|
||||
"KOCR 服务状态怎么三方交叉验证",
|
||||
"飞书记忆的蒸馏怎么保证质量",
|
||||
"kanban 的蒸馏怎么保证质量",
|
||||
"ComfyUI 的记忆怎么淘汰旧记忆",
|
||||
"hermes 的汇报怎么写证据原文",
|
||||
}
|
||||
for _, q := range cases {
|
||||
if standingGate(q, cardQ, cardA) {
|
||||
t.Errorf("应拒答(主体不同)却放行:%q vs %q", q, cardQ)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestStandingGate_RejectsAntonym(t *testing.T) {
|
||||
if standingGate("模型免费腿守卫只允许哪些", "模型付费腿守卫只允许哪些", "付费腿只有两条") {
|
||||
t.Error("免费 vs 付费 属反义冲突,必须拒答")
|
||||
}
|
||||
if standingGate("怎么恢复被删的记忆", "怎么删除旧记忆", "按六档淘汰") {
|
||||
t.Error("恢复 vs 删除 属反义冲突,必须拒答")
|
||||
}
|
||||
}
|
||||
|
||||
func TestStandingGate_RejectsAsciiMismatch(t *testing.T) {
|
||||
if standingGate("7822 端口是谁在听", "7821 端口是谁在听", "zhiyid 监听 7821") {
|
||||
t.Error("端口号对不上必须拒答")
|
||||
}
|
||||
}
|
||||
|
||||
func TestStandingGate_AcceptsGenericAsk(t *testing.T) {
|
||||
// query 无主体、卡片有主体 ⇒ 允许(用户泛问,卡片是唯一答案来源)
|
||||
pairs := [][2]string{
|
||||
{"遗忘窗口怎么扫描", "织忆的遗忘窗口机制是怎么扫描的"},
|
||||
{"蒸馏质量怎么保证", "织忆的蒸馏怎么保证质量"},
|
||||
{"记忆治理怎么淘汰旧记忆", "记忆治理怎么淘汰旧记忆"},
|
||||
{"kanban 怎么建卡", "kanban 看板任务怎么派活"},
|
||||
{"服务状态怎么三方交叉验证", "服务状态怎么三方交叉验证"},
|
||||
}
|
||||
for _, p := range pairs {
|
||||
if !standingGate(p[0], p[1], "步骤…") {
|
||||
t.Errorf("应放行却拒答:%q vs %q", p[0], p[1])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestStandingSemMode_DefaultOff(t *testing.T) {
|
||||
t.Setenv("ZHIYI_STANDING_SEM_MODE_FILE", "/nonexistent/standing-sem-mode")
|
||||
if got := standingSemMode(); got != "off" {
|
||||
t.Errorf("模式旋钮缺失时必须为 off,实得 %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestStandingSemThreshold_DefaultAndClamp(t *testing.T) {
|
||||
t.Setenv("ZHIYI_STANDING_SEM_THR_FILE", "/nonexistent/standing-sem-thr")
|
||||
if got := standingSemThreshold(); got != 0.80 {
|
||||
t.Errorf("默认阈值应为 0.80,实得 %v", got)
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user