From d2e9f086cb1909bda7b866c198c88d20c965f0eb Mon Sep 17 00:00:00 2001 From: xiaoyi Date: Mon, 16 Nov 2026 19:52:31 +0800 Subject: [PATCH 01/11] =?UTF-8?q?feat(recall):=20=E5=A4=96=E9=83=A8=20cros?= =?UTF-8?q?s-encoder=20rerank=20=E7=9C=9F=E6=8E=A5=E5=85=A5=E4=B8=BB?= =?UTF-8?q?=E9=93=BE=EF=BC=88=E6=AD=A4=E5=89=8D=E5=8F=AA=E8=AE=BE=20env?= =?UTF-8?q?=E3=80=81=E8=B0=83=E7=94=A8=E7=82=B9=E4=BB=8D=E8=B5=B0=E6=9C=AC?= =?UTF-8?q?=E5=9C=B0=20cosine=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 背景:11-12 牧尘令「rerank 开」,env 与 drop-in 都配了,但 recall 两个调用点仍调 RerankWithVectors(候选自带向量再算 cosine)⇒ 生产实际是假重排。2026-11-16 行为 实测:use_rerank=true 与 false 逐位相同、延迟同为 ~390ms,证实 0 外呼。 本笔:core.go / recall.go 两处调用点切到 RerankPreferAPI(有 key 走模力方舟 bge-reranker-v2-m3,分批 25 + 硬超时;失败降级向量 cosine);成功路径补日志 (失败才有日志 => 「有没有真调用」只能靠延迟猜,上次就是这么漏掉的)。 主尺实测(84 DA 题,no_cache,同窗口 on→off→on,漂移 0.0000): off 0.2639 → on 0.5258(+0.2619 / +99%),35 题变好 / 6 题变差。 降级实测:endpoint 指死端口 ⇒ 召回仍返回结果 + 日志『降级向量 cosine』。 部署:zhiyid-20261116-rerankapi2,drop-in zzzzzzzzz-rerankapi-20261116.conf --- go/internal/api/routes/core.go | 2 +- go/internal/storage/recall.go | 2 +- go/internal/storage/reranker.go | 188 ++++++++++++++++++++++---------- 3 files changed, 132 insertions(+), 60 deletions(-) diff --git a/go/internal/api/routes/core.go b/go/internal/api/routes/core.go index 904bfbb..3b4d1f8 100644 --- a/go/internal/api/routes/core.go +++ b/go/internal/api/routes/core.go @@ -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) } diff --git a/go/internal/storage/recall.go b/go/internal/storage/recall.go index 9c20d2c..471dd61 100644 --- a/go/internal/storage/recall.go +++ b/go/internal/storage/recall.go @@ -976,7 +976,7 @@ 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) + 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) diff --git a/go/internal/storage/reranker.go b/go/internal/storage/reranker.go index 14bd9c9..e0fd1ac 100644 --- a/go/internal/storage/reranker.go +++ b/go/internal/storage/reranker.go @@ -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,44 @@ 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] + } + // 外部 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", len(documents), topN, time.Since(t0).Milliseconds()) + return res, nil + } + if err != nil { + log.Printf("[rerank] API 重排不可用(%v),降级向量 cosine", err) + } + } + 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 +278,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 +326,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 +} From 085a407f68022367fa167863c1d2e4c858bb38aa Mon Sep 17 00:00:00 2001 From: xiaoyi Date: Mon, 16 Nov 2026 20:43:01 +0800 Subject: [PATCH 02/11] =?UTF-8?q?feat(recall):=20ZHIYI=5FRERANK=5FHOLD?= =?UTF-8?q?=EF=BC=88rerank=20=E4=BF=9D=E4=BD=8D=EF=BC=8C=E9=BB=98=E8=AE=A4?= =?UTF-8?q?=E5=85=B3=EF=BC=89=E2=80=94=E2=80=94=E5=AE=9E=E6=B5=8B=E4=BB=BB?= =?UTF-8?q?=E4=BD=95=20N=20=E9=83=BD=E8=B4=9F=E6=94=B6=E7=9B=8A=EF=BC=8C?= =?UTF-8?q?=E7=95=99=E6=A1=A3=E4=B8=8D=E5=86=8D=E9=87=8D=E8=AF=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 主尺 84 DA 题同窗口配对(no_cache,漂移 0.0000): hold=0 0.5258 基准 hold=1 0.4881 -3.8pp hold=2 0.3591 -16.7pp(24 题掉零) hold=3 0.3532 -17.3pp(26 题掉零) 原因:向量序头部正是 cross-encoder 要压下去的空壳句,钉住它=废掉 rerank 的主要作用。 11-12 离线重放「保 top3 最好」的结论不成立——那是在向量 cosine 代理尺上测的,与真 cross-encoder 行为相反。 默认 0 ⇒ MMRSelect 原样调用、逐位等价;代码保留为常开旋钮(观测/回归用),生产不设此 env。 --- go/internal/storage/recall.go | 30 +++++++++++++++++++++++++++++- 1 file changed, 29 insertions(+), 1 deletion(-) diff --git a/go/internal/storage/recall.go b/go/internal/storage/recall.go index 471dd61..ea390ce 100644 --- a/go/internal/storage/recall.go +++ b/go/internal/storage/recall.go @@ -1138,7 +1138,35 @@ 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 + if maxKeep := topK * 2; keep > maxKeep { + keep = maxKeep + } + finalIndices = make([]int, 0, topK*2) + 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 := topK*2 - 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, topK*2, diversity) + } // RRF 开启时多取一倍候选进融合池:只在 topK 内部重排不会改变 top5 的**集合**(等于没效果), // 第 6~10 名必须有机会被词面秩抬进前 5,融合才可能有增益。门控关 ⇒ poolN==topK,逐位等价现状。 From 4420937edb4756d4990f248b1442e0cba05b3f37 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=B0=8F=E6=80=A1?= Date: Mon, 16 Nov 2026 21:47:04 +0800 Subject: [PATCH 03/11] =?UTF-8?q?fix(recall):=20FTS=20=E5=B0=BE=E9=83=A8?= =?UTF-8?q?=E4=BD=8D=E9=A2=84=E7=95=99=E6=A7=BD=E9=9A=8F=20topK=20?= =?UTF-8?q?=E7=BC=A9=E6=94=BE=EF=BC=88min(3,topK/2)=EF=BC=89=EF=BC=8C?= =?UTF-8?q?=E4=BF=AE=20top=5Fk=3D5=20=E8=A2=AB=E7=A1=AC=E9=A2=84=E7=95=99?= =?UTF-8?q?=203=20=E4=BD=8D=E5=90=83=E6=8E=89=E5=90=91=E9=87=8F=E7=AC=AC?= =?UTF-8?q?=203=20=E5=90=8D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 现象(同一 query、同一时刻、no_cache): top_k=5 → 标准答案不在前 5;top_k=6 → 稳定第 3,其余顺序完全不变 根因:Step 3.8 的让位发生在 results[:topK] 截断之后,预留槽硬编码 3 ⇒ 小 k 时只能从已截断的主路径尾巴抢(k=5 占 60% 槽位),正好吞掉向量第 3 名。 量测(84 DA 题、top_k=5、no_cache): reserve=3(旧)0.5258 / 2 → 0.5575(+3.2pp) / 1 → 0.6052 / 0 → 0.6329(+10.7pp) A/B/A 配对:涨 4 / 跌 0,单题最差 +0.00;反转顺序 0→3→0 复现(0.6448 vs 0.5139) 落地:默认 min(3, topK/2)(k=5→2、k≥6→3=原值,其他调用方零变化); 热调文件 /var/lib/memoryweave/recall-fts-reserve(整数覆盖,无需重启); 回滚 = echo 3 > 该文件(逐位回到改动前) 不取 0 的依据:稀有 ASCII 词探针(12 条)reserve=2/3 均 7/12 命中,0 掉到 6/12 --- go/internal/storage/fts_reserve_test.go | 25 +++++++++++++++++ go/internal/storage/recall.go | 37 ++++++++++++++++++++++++- 2 files changed, 61 insertions(+), 1 deletion(-) create mode 100644 go/internal/storage/fts_reserve_test.go diff --git a/go/internal/storage/fts_reserve_test.go b/go/internal/storage/fts_reserve_test.go new file mode 100644 index 0000000..481af82 --- /dev/null +++ b/go/internal/storage/fts_reserve_test.go @@ -0,0 +1,25 @@ +package storage + +import "testing" + +// 2026-11-16 ftsReserveSlots:让位预算随 topK 缩放。 +// 判据(无覆盖文件时):topK/2 封顶 3 —— k=5 ⇒ 2、k=6 ⇒ 3、k≥6 恒 3(= 旧值)。 +func TestFtsReserveSlots_ScaledByTopK(t *testing.T) { + 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) + } + } +} diff --git a/go/internal/storage/recall.go b/go/internal/storage/recall.go index ea390ce..4308d18 100644 --- a/go/internal/storage/recall.go +++ b/go/internal/storage/recall.go @@ -1321,7 +1321,7 @@ 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) } nAppend := budget if nAppend > len(fresh) { @@ -1800,3 +1800,38 @@ 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("/var/lib/memoryweave/recall-fts-reserve"); 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 +} From 642e81d5a45b8a97fb2b7c0f7387ce9dbefd4f78 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=B0=8F=E6=80=A1?= Date: Mon, 16 Nov 2026 22:22:03 +0800 Subject: [PATCH 04/11] =?UTF-8?q?experiment(recall):=20=E9=80=89=E6=8B=A9?= =?UTF-8?q?=E7=AA=97=E5=8F=A3=E8=A7=A3=E8=80=A6=E2=80=94=E2=80=94=E5=AE=9E?= =?UTF-8?q?=E6=B5=8B=E4=B8=8D=E6=8F=90=E5=88=86=EF=BC=8C=E9=BB=98=E8=AE=A4?= =?UTF-8?q?=E5=9B=9E=E9=80=80=20topK*2=EF=BC=88=E4=BF=9D=E7=95=99=E7=83=AD?= =?UTF-8?q?=E8=B0=83=E6=97=8B=E9=92=AE=20+=20=E4=BF=AE=E5=8D=95=E6=B5=8B?= =?UTF-8?q?=E9=9A=94=E7=A6=BB=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 假设:MMR/RRF 窗口 = topK*2 ⇒ 请求 5 条只在前 10 里选,第 11 名起的好答案没机会, 应把窗口钉成 max(topK*2,20) 让 top-5 与 top-50 前 5 一致。 实测(84 DA 题、no_cache、tk=5): 窗口旧(topK*2=10) 0.5575 / 窗 20 0.5655 / 窗 100 0.5655 tk5-vs-tk50 前 5 一致率:19.0% → 27.4% → 45.2% ⇒ 一致率变了但**主尺不动**(涨1跌1 = 噪声内,窗 20 与窗 100 完全相同)。 结论:剩 k 依赖来自 RRF 池宽 + 词面名次对深位条目的上位,那类上位本身不带来正确率 ⇒ 不做成默认。selectionWindow() 默认回到 topK*2,宽窗口只留热调 (echo 20|100 > /var/lib/memoryweave/recall-sel-window)供以后复跑。 顺带修:旋钮文件路径可被 env 覆盖(ZHIYI_FTS_RESERVE_FILE / ZHIYI_SEL_WINDOW_FILE)—— 生产上调过旋钮会让单测红绿翻转(本次实际踩到,knob=100 时单测直接 FAIL)。 --- go/internal/storage/fts_reserve_test.go | 16 ++++++++ go/internal/storage/recall.go | 53 ++++++++++++++++++++++--- 2 files changed, 63 insertions(+), 6 deletions(-) diff --git a/go/internal/storage/fts_reserve_test.go b/go/internal/storage/fts_reserve_test.go index 481af82..ab9e623 100644 --- a/go/internal/storage/fts_reserve_test.go +++ b/go/internal/storage/fts_reserve_test.go @@ -5,6 +5,7 @@ import "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}, } @@ -23,3 +24,18 @@ func TestFtsReserveSlots_NeverEatsWholeList(t *testing.T) { } } } + +// 2026-11-16 selectionWindow:默认必须保持旧行为(topK*2)。 +// 宽窗口(max(topK*2,20) / 常数 100)实测不提分(0.5575→0.5655,涨1跌1 = 噪声内), +// 故默认回落到 topK*2;宽窗口只作为热调实验开关(/var/lib/memoryweave/recall-sel-window)。 +func TestSelectionWindow_DefaultsToLegacy(t *testing.T) { + t.Setenv("ZHIYI_SEL_WINDOW_FILE", "/nonexistent/recall-sel-window") + cases := []struct{ topK, want int }{ + {1, 2}, {5, 10}, {10, 20}, {20, 40}, {50, 100}, + } + for _, c := range cases { + if got := selectionWindow(c.topK); got != c.want { + t.Errorf("selectionWindow(%d)=%d want %d(默认必须等于旧行为 topK*2)", c.topK, got, c.want) + } + } +} diff --git a/go/internal/storage/recall.go b/go/internal/storage/recall.go index 4308d18..38774cc 100644 --- a/go/internal/storage/recall.go +++ b/go/internal/storage/recall.go @@ -1147,10 +1147,11 @@ func (p *RecallPipeline) recallUncached(ctx context.Context, query, namespace st var finalIndices []int if hold > 0 && hold < len(candidates) { keep := hold - if maxKeep := topK * 2; keep > maxKeep { + win := selectionWindow(topK) + if maxKeep := win; keep > maxKeep { keep = maxKeep } - finalIndices = make([]int, 0, topK*2) + finalIndices = make([]int, 0, win) for i := 0; i < keep; i++ { finalIndices = append(finalIndices, i) } @@ -1160,19 +1161,20 @@ func (p *RecallPipeline) recallUncached(ctx context.Context, query, namespace st rest = append(rest, r) } } - if need := topK*2 - len(finalIndices); need > 0 { + 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, topK*2, diversity) + 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 { @@ -1818,7 +1820,7 @@ func filterRecallRawCategories(results []models.RecallResult) []models.RecallRes // 热调:`/var/lib/memoryweave/recall-fts-reserve` 写整数(0..3)即覆盖本规则, // 无需重启(A/B 用);回滚 = 写 3(逐位回到改动前行为)。 func ftsReserveSlots(topK int) int { - if b, err := os.ReadFile("/var/lib/memoryweave/recall-fts-reserve"); err == nil { + 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 @@ -1835,3 +1837,42 @@ func ftsReserveSlots(topK int) int { } return n } + +// selectionWindow 返回 MMR/RRF 的「选择窗口」宽度 —— 与请求的 topK 解耦。 +// +// 2026-11-16(t_sel_window):原实现在两处用 topK*2 作为窗口,于是**同一 query +// 请求 5 条与请求 50 条拿到的前 5 名不同**(实测 29 道零分题里有 6~8 道在 +// top_k=50 请求时 DA 已进前 5,只是 tk=5 请求拿不到)。窗口窄 ⇒ 只在前 10 条里 +// 做 MMR/RRF ⇒ 第 11 条起的好答案结构性没机会。 +// 规则:窗口 = max(topK*2, 20)。贪心 MMR 前缀稳定 ⇒ 前 5 名在 5/10/20/50 各档一致。 +// 热调:/var/lib/memoryweave/recall-sel-window 写整数 —— 0 = 旧行为(topK*2), +// n>0 = 窗口取 max(n, topK);文件缺失 ⇒ 新默认。回滚 = echo 0 > 该文件。 +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 + } + } + // 默认 = 旧行为(topK*2)。宽窗口(max(topK*2,20) / 常数 100)实测**不提分**: + // 主尺 0.5575(旧) → 0.5655(窗20) → 0.5655(窗100),涨 1 跌 1 = 噪声内; + // 一致率虽 19%→27%→45%,但那是 RRF 池宽带来的词面名次上位,不构成收益。 + // 想复跑实验:echo 20(或 100)> /var/lib/memoryweave/recall-sel-window。 + return topK * 2 +} + +// recallKnobPath 返回热调旋钮文件路径。 +// 为什么要 env 覆盖:单测读的是真实生产文件 ⇒ 生产上调过旋钮就会让单测红/绿翻转 +// (2026-11-16 实际踩到:knob=100 时 TestSelectionWindow_DefaultsToLegacy 直接 FAIL)。 +// 单测里 t.Setenv(, <不存在的 tmp 路径>) ⇒ 走默认分支,行为可确定性断言。 +func recallKnobPath(name, envKey string) string { + if p := os.Getenv(envKey); p != "" { + return p + } + return "/var/lib/memoryweave/" + name +} From 46345de5472070e0dae311483858beb99e50ea88 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=B0=8F=E6=80=A1?= Date: Mon, 16 Nov 2026 23:43:01 +0800 Subject: [PATCH 05/11] =?UTF-8?q?feat(standing):=20=E8=AF=AD=E4=B9=89?= =?UTF-8?q?=E5=B8=B8=E8=AE=BE=E9=80=9A=E9=81=93=EF=BC=88=E9=BB=98=E8=AE=A4?= =?UTF-8?q?=20off/=E5=BD=B1=E5=AD=90=EF=BC=89+=20=E4=B8=BB=E4=BD=93=C2=B7?= =?UTF-8?q?=E5=8F=8D=E4=B9=89=C2=B7=E6=95=B0=E5=AD=97=C2=B7=E6=A8=A1?= =?UTF-8?q?=E7=B3=8A=E5=9B=9B=E9=81=93=E9=97=B8=E9=97=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 背景:精确通道只认归一化整句相等,7 张 op 卡对真留出问法命中 0/33。 本提交在 encode 之后用**已算好的 queryVec** 做一次余弦候选(零额外 embedding), 三档 off(默认,逐位等价)/shadow(只打日志)/on(短路返回),旋钮 /var/lib/memoryweave/standing-sem-mode|standing-sem-thr|standing-sem-margin。 闸门(纯函数, 单测固化 9 条对抗样本): 主体一致(飞书的遗忘 ≠ 织忆的遗忘;问主体但卡通用 ⇒ 拒) 反义冲突(免费 vs 付费、删除 vs 恢复 ⇒ 拒) 稀有 ASCII 覆盖(端口/文件名/命令对不上 ⇒ 拒) 模糊边距(两卡分差 <0.02 ⇒ 拒答;实测「蒸馏质量门在哪」在两卡间摇摆) 真留出实测(33 条新问法 + 9 条对抗,live shadow): thr=0.80 命中 25/33 答对 21 错 4 精确率 84% thr=0.85 命中 20/33 答对 18 错 2 精确率 90% ← 采用 thr=0.88 命中 13/33 答对 11 错 2 精确率 85%(覆盖掉太多) 对抗集在三个阈值下均 0 放行。 ⚠️ 教训:我最初那批「每卡 5 条留出变体」里有 4 条其实就是卡片 trigger 本身, 走到精确通道短路、根本没进语义层 ⇒ 首轮 7/7 是重复计数,不是泛化能力。 真留出必须另写、且要确认它不进精确通道(看日志里有没有 sem 行)。 --- go/internal/storage/recall.go | 21 ++ go/internal/storage/standing_semantic.go | 282 ++++++++++++++++++ go/internal/storage/standing_semantic_test.go | 71 +++++ 3 files changed, 374 insertions(+) create mode 100644 go/internal/storage/standing_semantic.go create mode 100644 go/internal/storage/standing_semantic_test.go diff --git a/go/internal/storage/recall.go b/go/internal/storage/recall.go index 38774cc..0774cd4 100644 --- a/go/internal/storage/recall.go +++ b/go/internal/storage/recall.go @@ -675,6 +675,27 @@ 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 延迟。 + if semMode := standingSemMode(); semMode != "off" { + if sa, c := p.standingSemanticCheck(query, queryVec, true); sa != nil { + log.Printf("[standing][sem] mode=%s qid=%s cos=%.3f query=%q", semMode, sa.QuestionID, c, query) + if semMode == "on" { + return []models.RecallResult{{ + ID: "standing:" + sa.QuestionID, + Content: sa.Answer, + Category: "standing_answer", + Score: 1.0, + Timestamp: sa.UpdatedAt.Format(time.RFC3339), + Source: "standing_answer", + Channel: "standing", + }}, RecallMeta{StandingAnswerHit: sa.QuestionID + "(sem)", Status: "ok"}, nil + } + } + } + // Step 2: Coarse search — own namespace + shared(§1.3 召回规则) // 默认搜自己的 namespace + shared,显式 include_namespaces 时才跨域 // 2026-09-21 五修(t_24eceed0 返修):namespace=="" → 全库跨命名空间召回。 diff --git a/go/internal/storage/standing_semantic.go b/go/internal/storage/standing_semantic.go new file mode 100644 index 0000000..608372f --- /dev/null +++ b/go/internal/storage/standing_semantic.go @@ -0,0 +1,282 @@ +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 +} + +// 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, logOn bool) (*StandingAnswer, float64) { + thr := standingSemThreshold() + margin := standingSemMargin() + best, second := (*StandingAnswer)(nil), (*StandingAnswer)(nil) + bestCos, secondCos := 0.0, 0.0 + for _, e := range p.semEntries(logOn) { + 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 +} diff --git a/go/internal/storage/standing_semantic_test.go b/go/internal/storage/standing_semantic_test.go new file mode 100644 index 0000000..3b98c95 --- /dev/null +++ b/go/internal/storage/standing_semantic_test.go @@ -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) + } +} From 6a4d698732a407561928c0ae9e893d31c1b95317 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=B0=8F=E5=94=AF?= Date: Tue, 17 Nov 2026 00:56:30 +0800 Subject: [PATCH 06/11] =?UTF-8?q?feat(standing):=20=E8=AF=AD=E4=B9=89?= =?UTF-8?q?=E5=B8=B8=E8=AE=BE=E5=8D=A1=E7=BD=AE=E9=A1=B6=E4=B8=94=E4=B8=8D?= =?UTF-8?q?=E5=8D=A0=E5=8F=AC=E5=9B=9E=E9=85=8D=E9=A2=9D=EF=BC=9Bscope=3DO?= =?UTF-8?q?P=5F=20=E6=94=B6=E5=8F=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - recall.go:on 模式由「短路只回卡片」改为「卡片置顶 + 保留全部记忆证据」 (短路只回 1 条卡 ⇒ 13 道题主尺归零 0.5575→0.4980) - core.go:capRecallResults 把 standing_answer 与 pattern/peer 同待遇:不占 limit 配额, 但置顶(答案在前、证据在后) - scope 收口 OP_:H19 / zhiyi-threshold-1-v2 未经检验的卡不参与语义自动作答 - 摘掉 OP_FORGET_MECHANISM 的「记忆治理怎么分层」触发词(分层≠淘汰,误挂会劫持 golden 题) --- go/internal/api/routes/core.go | 27 ++++++++++++++++------ go/internal/storage/recall.go | 29 ++++++++++++++++-------- go/internal/storage/standing_semantic.go | 28 +++++++++++++++++++---- 3 files changed, 62 insertions(+), 22 deletions(-) diff --git a/go/internal/api/routes/core.go b/go/internal/api/routes/core.go index 3b4d1f8..6a092f2 100644 --- a/go/internal/api/routes/core.go +++ b/go/internal/api/routes/core.go @@ -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()) @@ -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,11 +1771,14 @@ 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 main := make([]models.RecallResult, 0, len(results)) diff --git a/go/internal/storage/recall.go b/go/internal/storage/recall.go index 0774cd4..beb53c8 100644 --- a/go/internal/storage/recall.go +++ b/go/internal/storage/recall.go @@ -679,19 +679,16 @@ func (p *RecallPipeline) recallUncached(ctx context.Context, query, namespace st // 留出变体 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, true); sa != nil { + 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" { - return []models.RecallResult{{ - ID: "standing:" + sa.QuestionID, - Content: sa.Answer, - Category: "standing_answer", - Score: 1.0, - Timestamp: sa.UpdatedAt.Format(time.RFC3339), - Source: "standing_answer", - Channel: "standing", - }}, RecallMeta{StandingAnswerHit: sa.QuestionID + "(sem)", Status: "ok"}, nil + semCard, semQID = sa, sa.QuestionID } } } @@ -1555,6 +1552,18 @@ func (p *RecallPipeline) recallUncached(ctx context.Context, query, namespace st tr.MarkPartial("row_cap_truncated") } } + 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 } diff --git a/go/internal/storage/standing_semantic.go b/go/internal/storage/standing_semantic.go index 608372f..54a5ad6 100644 --- a/go/internal/storage/standing_semantic.go +++ b/go/internal/storage/standing_semantic.go @@ -71,6 +71,17 @@ func standingSemThreshold() float64 { 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{ @@ -153,10 +164,10 @@ func standingGate(query, cardQuestion, cardAnswer string) bool { // semEntry 一张卡(question 或某个 op.trigger)的向量。 type semEntry struct { - qid string - text string - vec []float32 - card *StandingAnswer + qid string + text string + vec []float32 + card *StandingAnswer } var ( @@ -231,12 +242,19 @@ func cosSim(a, b []float32) float64 { // standingSemanticCheck 语义候选:取余弦最高且过闸门的卡;不过闸门一律不命中。 // queryVec 用调用方已经算好的查询向量(不额外 embed,零额外延迟)。 -func (p *RecallPipeline) standingSemanticCheck(query string, queryVec []float32, logOn bool) (*StandingAnswer, float64) { +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 From 677e519dac1c0d3920f04e10c16baa1fecf1ba42 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=B0=8F=E5=94=AF?= Date: Tue, 17 Nov 2026 01:19:18 +0800 Subject: [PATCH 07/11] =?UTF-8?q?fix(standing):=20paginate=20=E4=B9=9F?= =?UTF-8?q?=E8=B1=81=E5=85=8D=20standing=5Fanswer=20=E9=85=8D=E9=A2=9D?= =?UTF-8?q?=EF=BC=9B=E7=BA=AF=E5=8D=A1=E7=89=87=E9=A1=B5=E4=B8=8D=E5=90=9E?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit capRecallResults 已让 standing_answer 不占 limit 配额,但 paginateRecallWithCarry 仍按 Category 把卡片算进 main,main[:limit] 又会切掉第 5 条记忆 (日报怎么写才不算空壳:DA 在 rank5 被挤掉,主尺 -1 题)。 另修 mainLen==0 时纯卡片页返回空页 ⇒ 精确命中只回卡时卡被整条吞。 配对实测:on=0.5575 off=0.5575 差=+0.0000 变动 0 题(此前 -0.0119)。 --- go/internal/api/routes/core.go | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/go/internal/api/routes/core.go b/go/internal/api/routes/core.go index 6a092f2..3d0a894 100644 --- a/go/internal/api/routes/core.go +++ b/go/internal/api/routes/core.go @@ -1781,11 +1781,15 @@ func capRecallResults(results []models.RecallResult, limit int) (prim, expanded // ⇒ 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) } } @@ -1814,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)。 From d4b97b383890fb21a9ebf2b846eab7b60054e50a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=B0=8F=E5=94=AF?= Date: Tue, 17 Nov 2026 01:35:53 +0800 Subject: [PATCH 08/11] =?UTF-8?q?fix(standing):=20=E7=B2=BE=E7=A1=AE?= =?UTF-8?q?=E5=91=BD=E4=B8=AD=E4=B8=8D=E5=86=8D=E9=9B=B6=E6=A3=80=E7=B4=A2?= =?UTF-8?q?=E7=9F=AD=E8=B7=AF=20=E2=80=94=E2=80=94=20=E5=8D=A1=E7=89=87?= =?UTF-8?q?=E7=BD=AE=E9=A1=B6=20+=20=E8=AE=B0=E5=BF=86=E8=AF=81=E6=8D=AE?= =?UTF-8?q?=E5=85=A8=E4=BF=9D=E7=95=99?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 旧行为:standingAnswerFor 命中后直接 return 只含 1 条卡的切片,不进入检索。 后果:① 违反「卡是答案、记忆是证据,两者都不能丢」;② golden 里 7 道被 整句命中的题,即使 DA 在库里也因为整片记忆被吞而拿不到分。 新行为:走完整管线,卡片置顶并按 ID 去重(语义通道可能已 prepend), 管线报错时仍只回卡 + status=partial(LLM 过载时程序性记忆层可用)。 --- go/internal/storage/recall.go | 40 +++++++++++++++++++++++++++++------ 1 file changed, 34 insertions(+), 6 deletions(-) diff --git a/go/internal/storage/recall.go b/go/internal/storage/recall.go index beb53c8..6b8d4a1 100644 --- a/go/internal/storage/recall.go +++ b/go/internal/storage/recall.go @@ -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 { From 82d8a70771337525f2521b8a2a5dd1c085e1707f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=B0=8F=E5=94=AF?= Date: Tue, 17 Nov 2026 11:45:09 +0800 Subject: [PATCH 09/11] =?UTF-8?q?fix(recall):=20=E9=80=89=E6=8B=A9?= =?UTF-8?q?=E7=AA=97=E5=8F=A3=E4=B8=8E=E8=AF=B7=E6=B1=82=20topK=20?= =?UTF-8?q?=E8=A7=A3=E8=80=A6=EF=BC=88=E5=B8=B8=E6=95=B0=20100=EF=BC=89?= =?UTF-8?q?=EF=BC=8C=E4=BF=AE=20top5=20=E2=8A=84=20top20=20=E4=B8=8D?= =?UTF-8?q?=E5=8F=98=E9=87=8F=E8=BF=9D=E8=83=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 病根:selectionWindow 默认 topK*2 ⇒ k=5 窗口 10、k=20 窗口 40,同一 query 看到不同候选池。实测 `日志分析怎么定位根因` k=20 时 DA 排第 4、k=5 时完全不在。 (11-16 只把它当'提分实验'看,因 +0.8pp 属噪声内而回退 —— 漏掉了这是正确性问题。) 改:默认 max(100, topK),与 k 解耦;旋钮 0 = 旧行为供回滚。 实测:16 题 top5 ⊄ top20 = 0 道;主尺 0.55754 → 0.56548(+0.79pp); 窗 40 同分(池深饱和);延迟 p50 1.01→1.09s。 --- go/internal/storage/fts_reserve_test.go | 69 ++++++++++++++++++++++--- go/internal/storage/recall.go | 31 +++++++---- 2 files changed, 82 insertions(+), 18 deletions(-) diff --git a/go/internal/storage/fts_reserve_test.go b/go/internal/storage/fts_reserve_test.go index ab9e623..6382d72 100644 --- a/go/internal/storage/fts_reserve_test.go +++ b/go/internal/storage/fts_reserve_test.go @@ -1,6 +1,10 @@ package storage -import "testing" +import ( + "os" + "path/filepath" + "testing" +) // 2026-11-16 ftsReserveSlots:让位预算随 topK 缩放。 // 判据(无覆盖文件时):topK/2 封顶 3 —— k=5 ⇒ 2、k=6 ⇒ 3、k≥6 恒 3(= 旧值)。 @@ -25,17 +29,68 @@ func TestFtsReserveSlots_NeverEatsWholeList(t *testing.T) { } } -// 2026-11-16 selectionWindow:默认必须保持旧行为(topK*2)。 -// 宽窗口(max(topK*2,20) / 常数 100)实测不提分(0.5575→0.5655,涨1跌1 = 噪声内), -// 故默认回落到 topK*2;宽窗口只作为热调实验开关(/var/lib/memoryweave/recall-sel-window)。 -func TestSelectionWindow_DefaultsToLegacy(t *testing.T) { +// 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, 2}, {5, 10}, {10, 20}, {20, 40}, {50, 100}, + {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(默认必须等于旧行为 topK*2)", 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) + } +} diff --git a/go/internal/storage/recall.go b/go/internal/storage/recall.go index 6b8d4a1..ff2f851 100644 --- a/go/internal/storage/recall.go +++ b/go/internal/storage/recall.go @@ -1896,15 +1896,24 @@ func ftsReserveSlots(topK int) int { 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 名不同**(实测 29 道零分题里有 6~8 道在 -// top_k=50 请求时 DA 已进前 5,只是 tk=5 请求拿不到)。窗口窄 ⇒ 只在前 10 条里 -// 做 MMR/RRF ⇒ 第 11 条起的好答案结构性没机会。 -// 规则:窗口 = max(topK*2, 20)。贪心 MMR 前缀稳定 ⇒ 前 5 名在 5/10/20/50 各档一致。 -// 热调:/var/lib/memoryweave/recall-sel-window 写整数 —— 0 = 旧行为(topK*2), -// n>0 = 窗口取 max(n, topK);文件缺失 ⇒ 新默认。回滚 = echo 0 > 该文件。 +// 请求 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 { @@ -1917,11 +1926,11 @@ func selectionWindow(topK int) int { return topK } } - // 默认 = 旧行为(topK*2)。宽窗口(max(topK*2,20) / 常数 100)实测**不提分**: - // 主尺 0.5575(旧) → 0.5655(窗20) → 0.5655(窗100),涨 1 跌 1 = 噪声内; - // 一致率虽 19%→27%→45%,但那是 RRF 池宽带来的词面名次上位,不构成收益。 - // 想复跑实验:echo 20(或 100)> /var/lib/memoryweave/recall-sel-window。 - return topK * 2 + // 窗口不能小于请求条数,否则凑不满 k。 + if topK > selectionWindowDefault { + return topK + } + return selectionWindowDefault } // recallKnobPath 返回热调旋钮文件路径。 From e61bc0bd63379761aeadad23123a5da9641d1eb4 Mon Sep 17 00:00:00 2001 From: xxy Date: Tue, 17 Nov 2026 14:20:07 +0800 Subject: [PATCH 10/11] =?UTF-8?q?recall:=20FTS=20=E5=B0=BE=E9=83=A8?= =?UTF-8?q?=E8=AE=A9=E4=BD=8D=E5=8A=A0=E5=A4=B4=E9=83=A8=E4=BF=9D=E6=8A=A4?= =?UTF-8?q?=EF=BC=88ZHIYI=5FFTS=5FTAIL=5FHEAD=EF=BC=8C=E7=BC=BA=E7=9C=810?= =?UTF-8?q?=3D=E6=97=A7=E8=A1=8C=E4=B8=BA=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 病根证据(同库同 query、串行 no_cache、k=5/k=20 各重复 3/2 次全一致): - k=5 返回 [v,v,v,fts,fts]:第 4~5 名被 FTS 让位槽吃掉(占答案 40%) - k=20 返回 [v,v,v,v,v]:同一融合池前 8 名逐位相同,FTS 落在 18~20 名 - 84 题同窗主尺:k=5 → 0.55357;k=20 取前 5 → 0.60913(+7/−0) 改动: - ftsTailHeadProtect():让位槽不得吃进前 head 名(缺省 0=逐位等价现状); 热调文件 recall-fts-tail-head,env ZHIYI_FTS_TAIL_HEAD - 顺带:rerankDepthFloor()(ZHIYI_RERANK_N_FLOOR=100 已是硬下限 ⇒ 生产为 no-op,留作小 k 兜底) - reranker.go:docVecs 与 documents 同步截断(原 docVecs 截断缺失 ⇒ 报 'doc vector count N != documents M' 静默回退文本重排);api 日志加 q= 便于归因 - 测试:修 TestFTS_SmallTopKTailMatrix 期望值(旧写死 3,契约为 min(3,topK/2)); 新增 TestFTS_TailHeadProtect(head=5 不占头部 / head=0 旧契约 / 未满仍追加) 实测(84 题 DA,同库同窗,串行):head=0 → 0.55357;head=5 → 0.60913 (+7/−0,掉零 29→24,p50 1.48s→0.99s) --- go/internal/storage/recall.go | 56 +++++++++++++++++++ .../storage/recall_smalltopk_tail_test.go | 53 ++++++++++++++++++ go/internal/storage/reranker.go | 10 +++- 3 files changed, 117 insertions(+), 2 deletions(-) diff --git a/go/internal/storage/recall.go b/go/internal/storage/recall.go index ff2f851..b96c558 100644 --- a/go/internal/storage/recall.go +++ b/go/internal/storage/recall.go @@ -1022,6 +1022,18 @@ func (p *RecallPipeline) recallUncached(ctx context.Context, query, namespace st if floor := envInt("ZHIYI_RERANK_N_FLOOR", 10); floor > rerankN { rerankN = floor } + // 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) + } reranked, err := p.reranker.RerankPreferAPI(query, docs, queryVec, docVecs, rerankN) if err != nil { log.Printf("[recall] 向量重排跳过(%v),回退文本重排", err) @@ -1371,6 +1383,21 @@ func (p *RecallPipeline) recallUncached(ctx context.Context, query, namespace st if len(results) >= topK { 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) { nAppend = len(fresh) @@ -1933,6 +1960,35 @@ func selectionWindow(topK int) int { 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)。 diff --git a/go/internal/storage/recall_smalltopk_tail_test.go b/go/internal/storage/recall_smalltopk_tail_test.go index c2fbe35..f3c58b1 100644 --- a/go/internal/storage/recall_smalltopk_tail_test.go +++ b/go/internal/storage/recall_smalltopk_tail_test.go @@ -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)) + } + }) +} diff --git a/go/internal/storage/reranker.go b/go/internal/storage/reranker.go index e0fd1ac..08ec49e 100644 --- a/go/internal/storage/reranker.go +++ b/go/internal/storage/reranker.go @@ -190,6 +190,12 @@ func (r *Reranker) RerankPreferAPI(query string, documents []string, queryVec [] // 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 预算被吃掉。 @@ -201,11 +207,11 @@ func (r *Reranker) RerankPreferAPI(query string, documents []string, queryVec [] if err == nil && len(res) > 0 { // 成功路径必须有日志:否则「API 有没有真被调用」只能靠延迟间接推断, // 而上一次 rerank 空转就是这么被漏掉的(2026-11-16)。 - log.Printf("[rerank] api ok: docs=%d topN=%d took=%dms", len(documents), topN, time.Since(t0).Milliseconds()) + 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", err) + log.Printf("[rerank] API 重排不可用(%v),降级向量 cosine q=%.40q", err, query) } } return r.RerankWithVectors(queryVec, documents, docVecs, topN) From c6a5007782f22d1955cadd1f84a67234fa667e70 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=B0=8F=E6=80=A1?= Date: Tue, 17 Nov 2026 15:49:50 +0800 Subject: [PATCH 11/11] =?UTF-8?q?feat(recall):=20rerank=20=E6=96=87?= =?UTF-8?q?=E6=A1=A3=E6=95=B0=E5=B0=81=E9=A1=B6=E5=AF=B9=E5=A4=96=E5=8F=AF?= =?UTF-8?q?=E8=A7=81=EF=BC=88partial/rerank=5Fdocs=5Fcapped=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 外部 rerank 只送 ZHIYI_RERANK_API_MAX_DOCS(默认50)条,top_k>50 时静默截断。 判据用 topK > maxDocs(rerankN=max(topK*2,floor) 恒>50,用它比会误标每次请求)。 实测:k=5/20 complete,k=51/200 partial+rerank_docs_capped。 --- go/internal/storage/recall.go | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/go/internal/storage/recall.go b/go/internal/storage/recall.go index b96c558..3c33e15 100644 --- a/go/internal/storage/recall.go +++ b/go/internal/storage/recall.go @@ -1034,6 +1034,16 @@ func (p *RecallPipeline) recallUncached(ctx context.Context, query, namespace st 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) @@ -1607,6 +1617,16 @@ 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,