一、问题背景

我们给一家做工业设备的客户搭了个内部知识库问答系统,语料是大概 1.2 万份 PDF/Word 文档(产品手册、维修工单、SOP),切完块大概 18 万个 chunk。技术栈很朴素:LangChain 0.1.x + FAISS + GPT-3.5-turbo,embedding 用的是 OpenAI 的 text-embedding-ada-002,切分就是最经典的 RecursiveCharacterTextSplitter(chunk_size=512, chunk_overlap=50)。

上线两周,业务方反馈很直接:“问它某个型号的扭矩参数,它答得头头是道,但数字是错的。” 我们拉了 200 条真实问题做评测集(人工标注了 gold chunk 和 gold answer),基线数据很难看:

  • Recall@5:0.61
  • MRR:0.48
  • 答案准确率(人工判定):62%
  • 端到端 P95 延迟:1.2s

拆开看失败 case,问题集中在三类:

  1. 切分把语义切断了。手册里“额定扭矩:45 N·m”这种表格行,经常和上下文被切到两个 chunk 里,检索到的是半句话。
  2. embedding 对中文工业术语不敏感。“扭矩”“转矩”“力矩”在 ada-002 的向量空间里距离不够近,同义改写召回失败。
  3. Top-5 里噪音太多。18 万 chunk 里,很多通用条款(免责声明、安全须知)跟任何问题都“有点像”,挤占了名额。

于是就有了下面这三段式优化。下面按“环境 → 方案 → 实现 → 踩坑 → 数据”来讲。

二、环境与版本

先把版本钉死,避免复现时踩版本坑:

python 3.10.13
langchain 0.1.20
langchain-community 0.0.38
faiss-cpu 1.8.0
sentence-transformers 2.7.0
torch 2.2.1 (cu121)
FlagEmbedding 1.2.10
openai 1.25.1

硬件:单卡 A10 24G,检索服务 CPU 部署(8C16G)。embedding 和 rerank 走 GPU 服务,FAISS 走 CPU。

三、方案设计

整体改造思路是“检索链路分层”,而不是指望单点调参:

query
  ├─> [1] 查询改写(可选,本文略)
  ├─> [2] 向量召回 top-50   ← embedding 换成 bge-large-zh-v1.5
  ├─> [3] 二阶段 rerank     ← bge-reranker-base,50 -> top-5
  └─> [4] 拼 prompt 生成

切分侧的核心改动是父子块(small-to-big):用小的子块(256 字符)做向量索引,保证语义粒度细;子块携带 parent_id,命中后回溯到父块(1024 字符)喂给 LLM,保证上下文完整。这样既解决了“切太碎召回准但上下文残缺”,也解决了“切太大向量被稀释”。

为什么选 bge 系列?我们做了个小规模对比实验(200 条 query,同一套 chunk):

模型 维度 Recall@5 单条编码耗时(ms)
text-embedding-ada-002 1536 0.61 API ~120
bge-base-zh-v1.5 768 0.72 8
bge-large-zh-v1.5 1024 0.78 22
m3e-base 768 0.70 9

bge-large 明显更懂中文术语,而且本地部署没有 API 延迟和费用问题。Rerank 选 base 版是因为 large 版在 50 条候选上单次要 180ms,base 只要 45ms,性价比更高。

四、核心实现

4.1 语义切分 + 父子块索引

没有用纯递归切分,而是在递归切分基础上按标题/表格行做了边界保护。核心逻辑:先按文档结构(\n##、\n###、表格行)切成 section,再在 section 内递归切子块。

import re
import uuid
from langchain.text_splitter import RecursiveCharacterTextSplitter

PARENT_SIZE = 1024
CHILD_SIZE = 256
CHILD_OVERLAP = 32

# 结构边界:标题行、表格行、编号条目
BOUNDARY_PATTERN = re.compile(r"(?=^#{1,4}\s|\n\|.*\|\n|\n\d+\.\s)", re.M)

def split_sections(text: str):
    """按文档结构先切 section"""
    parts = [p.strip() for p in BOUNDARY_PATTERN.split(text) if p and p.strip()]
    return parts

parent_splitter = RecursiveCharacterTextSplitter(
    chunk_size=PARENT_SIZE,
    chunk_overlap=64,
    separators=["\n\n", "\n", "。", ";", " ", ""],
)
child_splitter = RecursiveCharacterTextSplitter(
    chunk_size=CHILD_SIZE,
    chunk_overlap=CHILD_OVERLAP,
    separators=["\n", "。", ";", ",", " ", ""],
)

def build_chunks(doc_id: str, text: str):
    """返回 (parents, children),children 带 parent_id"""
    parents, children = [], []
    for section in split_sections(text):
        for p_text in parent_splitter.split_text(section):
            pid = str(uuid.uuid4())
            parents.append({"id": pid, "doc_id": doc_id, "text": p_text})
            for c_text in child_splitter.split_text(p_text):
                # 过滤掉过短的碎片,避免噪音
                if len(c_text.strip()) < 20:
                    continue
                children.append({
                    "id": str(uuid.uuid4()),
                    "parent_id": pid,
                    "doc_id": doc_id,
                    "text": c_text,
                })
    return parents, children

这里有个细节:separators 里我把中文标点 。;, 放在 " " 前面。langchain 默认的 separator 列表是英文优先的,对中文长句会切出很怪的结果,这个改动对中文语料很关键。

4.2 bge embedding + FAISS 建索引

import numpy as np
import faiss
from sentence_transformers import SentenceTransformer

# bge 官方建议:query 加指令前缀,passage 不加
QUERY_INSTRUCTION = "为这个句子生成表示以用于检索相关文章:"

embedder = SentenceTransformer("BAAI/bge-large-zh-v1.5", device="cuda")
embedder.max_seq_length = 512

def encode_passages(texts, batch_size=64):
    return embedder.encode(
        texts,
        batch_size=batch_size,
        normalize_embeddings=True,   # 必须归一化,配合内积=余弦
        show_progress_bar=False,
    ).astype("float32")

def encode_query(q: str):
    return embedder.encode(
        [QUERY_INSTRUCTION + q],
        normalize_embeddings=True,
    ).astype("float32")

def build_faiss(children):
    vecs = encode_passages([c["text"] for c in children])
    index = faiss.IndexFlatIP(vecs.shape[1])   # 内积,向量已归一化
    index.add(vecs)
    return index, vecs

def search(index, children, query, top_k=50):
    qv = encode_query(query)
    scores, idxs = index.search(qv, top_k)
    hits = []
    for score, i in zip(scores[0], idxs[0]):
        c = children[i]
        hits.append({**c, "score": float(score)})
    return hits

normalize_embeddings=True + IndexFlatIP 是我踩过坑的地方,见下一节。

4.3 rerank 接入

from FlagEmbedding import FlagReranker

reranker = FlagReranker("BAAI/bge-reranker-base", use_fp16=True)

def rerank(query, hits, top_n=5):
    pairs = [[query, h["text"]] for h in hits]
    scores = reranker.compute_score(pairs, normalize=True)
    for h, s in zip(hits, scores):
        h["rerank_score"] = float(s)
    hits.sort(key=lambda x: x["rerank_score"], reverse=True)
    return hits[:top_n]

def retrieve(query, index, children, parent_map, recall_k=50, top_n=5):
    hits = search(index, children, query, top_k=recall_k)
    top = rerank(query, hits, top_n=top_n)
    # small-to-big:回溯父块并去重
    seen, contexts = set(), []
    for h in top:
        pid = h["parent_id"]
        if pid in seen:
            continue
        seen.add(pid)
        contexts.append(parent_map[pid]["text"])
    return top, contexts

五、踩坑与优化

坑 1:忘了归一化,召回分数全是 20~30。 一开始我用了 IndexFlatL2 配未归一化的 bge 向量,Recall 反而比 ada-002 还低。原因是 bge 输出未归一化时,L2 距离受向量模长影响很大,长文本向量模长更大,天然吃亏。改成 normalize_embeddings=True + IndexFlatIP 后,分数落在 0.5~0.85 区间,这才正常。

坑 2:query 指令前缀不能少。 bge 中文模型训练时 query 侧带了指令前缀,passage 侧不带。我一开始 query 也直接编码,Recall@5 掉了大概 4 个点(0.78 → 0.74)。这个前缀在官方 model card 里有写,很容易漏。

坑 3:rerank 的 normalize=True 影响阈值判断。 不加 normalize 时输出是 logits(-10~10),加了是 sigmoid 后的 0~1。我们后来用 0.35 作为“低置信度”阈值触发兜底回复(“知识库中未找到相关内容”),这个阈值必须在 normalize 模式下标定。

坑 4:父子块回溯导致上下文重复。 top-5 子块可能来自同一个父块,直接拼会重复。所以上面代码里用 seen 去重。另外父块拼起来可能超过 LLM 上下文,我们限制最多 3 个父块、总长 3000 字符。

坑 5:FAISS 索引更新。 文档增量更新时,IndexFlatIP 不支持删除,我们用了 IndexIDMap2 包一层,按 child_id 做 remove。这个改动没影响召回指标,但工程上必须做。

延迟权衡:recall_k 从 20 加到 50,rerank 耗时从 18ms 涨到 45ms,但 Recall@50 比 Recall@20 高 6 个点,值得。最终端到端 P95 从 1.2s 涨到 1.9s,主要增量在 rerank(+45ms)和更大的 prompt(父块更长,LLM 首 token 延迟 +0.3s 左右)。业务方能接受。

六、效果数据

同一套 200 条评测集,逐步叠加改动:

配置 Recall@5 MRR 答案准确率 P95 延迟
基线(512 固定切分 + ada-002) 0.61 0.48 62% 1.2s
+ 父子块切分 0.68 0.54 67% 1.3s
+ bge-large-zh-v1.5 0.78 0.66 75% 1.4s
+ bge-reranker-base 0.89 0.81 84% 1.9s

几个观察:

  • 切分改造的收益被低估了。很多人一上来就换模型,但父子块这一步单独就带来 +7 个点 Recall,成本几乎为零。
  • rerank 是收益最大的一步,+11 个点 Recall@5、+9 个点准确率。它把“通用条款类噪音”压下去了,Top-5 里真正相关的 chunk 占比明显提升。
  • rerank 对 MRR 提升尤其大(0.66 → 0.81),说明它主要改善的是排序,把 gold chunk 从第 3、4 位顶到第 1 位。
  • 剩下 16% 的错误里,约一半是“知识库里确实没有”,属于覆盖率问题,不是检索问题,后续要靠文档补全而不是调模型。

七、总结

这次优化没有用什么花哨的东西,就是把检索链路拆成“切分 → 召回 → 重排”三段分别优化,每段都有可量化的收益。几条可以直接抄走的经验:

  1. 先调切分,再换模型。父子块是性价比最高的一步,尤其对表格、手册类文档。
  2. 中文场景下 bge-large-zh-v1.5 是目前(2024 年中)很稳的选择,注意 query 指令前缀和向量归一化两个细节。
  3. rerank 值得上。base 版在 50 候选上 45ms,换 10 个点以上的召回,没有理由不做。
  4. 指标要分层看。Recall 看召回能力,MRR 看排序能力,准确率看端到端,三者提升节奏不一样。
  5. 延迟要提前跟业务对齐。我们这次 P95 涨了 0.7s,是提前沟通过的;如果业务对延迟敏感,rerank 可以只对 top-20 做,或者用更小的模型。

下一步打算试查询改写(HyDE)和混合检索(BM25 + 向量),目标把准确率推到 88% 以上。有进展再写一篇。