前端转 AI 100 天 Day 49:文档切分——RAG 效果的隐形开关

前端转 AI 第 49 天:文档切分 - RAG 效果的隐形开关

昨日回顾

Day 48 上了向量数据库,100 万向量的检索从几秒降到毫秒。

但今天要讲一个"容易被忽略、但影响巨大"的话题------文档切分。

同样的文档、同样的模型、同样的向量库,切分不同,效果差 50%。

Day 49 目标:搞懂切分的原理,掌握四种切分策略,给技术文档做最优切分。


一、为什么切分这么重要

1. 一个"打脸"的对比

同样一个问题:"怎么上传文档?"

切分方案 A:按固定长度切

知识库片段:

arduino 复制代码
片段 1: "常见问题 安装问题 Q: 支持哪些操作系统 A: 支持 Windows 10+
        macOS 11+、Ubuntu 20.04+ Q: 最低配置要求 A: 4GB 内存 2 核 CPU
        推荐 8GB 内存 使用问题 Q: 怎么上传文档 A: 在设置页点击..."

检索结果:

yaml 复制代码
相似度 0.71: 常见问题 安装问题 Q: 支持哪些操作系统...
              ← 答案被"埋"在一大段里

LLM 拿到这段后:

erlang 复制代码
根据文档,支持 Windows 10+、macOS 11+、Ubuntu 20.04+...
(回答了"支持哪些操作系统",而不是"怎么上传文档")

❌ 答错了。

切分方案 B:按段落切

知识库片段:

arduino 复制代码
片段 1: "Q: 支持哪些操作系统? A: 支持 Windows 10+..."

片段 2: "Q: 怎么上传文档? A: 在设置页点击'上传文档',
        支持 PDF、Markdown、Word 格式,单个文件不超过 50MB。"

片段 3: "Q: 支持哪些语言? A: 界面支持中文和英文..."

检索结果:

less 复制代码
相似度 0.86: Q: 怎么上传文档? A: 在设置页点击"上传文档"...
              ← 直接命中

LLM 拿到这段后:

arduino 复制代码
在设置页点击"上传文档",支持 PDF、Markdown、Word 格式,
单个文件不超过 50MB。

✅ 答对了。

同样的文档、同样的模型、同样的向量库------ 效果差 50%。

2. 切分的本质

一句话:

切分 = 把"大文档"变成"小答案"。

每个片段应该是一个"独立的语义单元"------ 能回答某类问题的最小单位。

好的切分:

  • 一个片段 = 一个完整的意思
  • 一个片段 = 回答一类问题
  • 不多不少,刚好够用

坏的切分:

  • 一个片段包含多个意思 → 检索到也答不准
  • 一个片段意思不完整 → 检索到也没用
  • 一个片段太小 → 缺上下文
  • 一个片段太大 → 浪费 token 还稀释相关性

3. 前端视角:切分就是"组件拆分"

做过前端的你,理解切分特别快:

前端 RAG 切分
组件拆分 文档切分
单个组件"只做一件事" 单个片段"只讲一个意思"
组件太大→难维护 片段太大→难检索
组件太小→props 爆炸 片段太小→缺上下文
合理的粒度让复用最大化 合理的粒度让检索最准

核心思想完全一样:

"合适的粒度"是一切的关键。

拆组件时你想的是"这个组件能不能独立复用"。

切分文档时你想的是"这个片段能不能独立回答一个问题"。

同一个思维。


二、四种切分策略

1. 策略一:固定长度切分

最简单的做法:每 N 个字符切一刀。

python 复制代码
def split_fixed_length(text: str, chunk_size: int = 500) -> list[str]:
    """按固定长度切分"""
    chunks = []
    for i in range(0, len(text), chunk_size):
        chunks.append(text[i:i + chunk_size])
    return chunks

优点:

  • 实现简单
  • 每个片段长度一致

缺点:

  • ❌ 可能切断句子:"今天天气很" | "好,适合出行"
  • ❌ 可能切断段落:一个意思被分成两半
  • ❌ 忽略语义边界

适合: 日志、代码等"天然等长"的内容。

真实场景几乎不用。

2. 策略二:按分隔符切分

按"自然分隔符"切,比如 \n\n(段落)、。(句号)。

python 复制代码
def split_by_separator(text: str, separator: str = "\n\n") -> list[str]:
    """按分隔符切分"""
    parts = text.split(separator)
    return [p.strip() for p in parts if p.strip()]

优点:

  • 尊重自然边界
  • 每个片段是完整段落

缺点:

  • ❌ 段落长度不一:有的 50 字,有的 2000 字
  • ❌ 长段落会超 token 限制
  • ❌ 短段落浪费

适合: 结构规整的文档(FAQ、规章制度)。

Day 48 用的就是这种方式------够用,但不是最优。

3. 策略三:递归切分(推荐)

核心思想:优先大边界,不够就切小边界。

切分优先级:

复制代码
段落(\n\n)
  ↓
换行(\n)
  ↓
句子(。!?)
  ↓
逗号(,)
  ↓
字符

流程:

markdown 复制代码
1. 先按段落切
2. 如果某个段落 > 目标大小,就按换行切
3. 如果还超,就按句子切
4. 如果还超,就按字符切

LangChain 的 RecursiveCharacterTextSplitter 就是这个思想。

代码实现:

python 复制代码
def recursive_split(
    text: str,
    max_size: int = 500,
    separators: list[str] = None,
) -> list[str]:
    """递归切分"""
    if separators is None:
        separators = ["\n\n", "\n", "。", "!", "?", ",", " ", ""]

    if len(text) <= max_size:
        return [text] if text.strip() else []

    # 找到第一个能切分的分隔符
    for sep in separators:
        if sep == "":
            # 兜底:按字符切
            return [text[i:i + max_size] for i in range(0, len(text), max_size)]

        if sep in text:
            parts = text.split(sep)
            result = []
            current = ""

            for part in parts:
                # 加上分隔符
                piece = part + sep if part != parts[-1] else part

                # 如果当前 + 新片段 <= max_size,合并
                if len(current) + len(piece) <= max_size:
                    current += piece
                else:
                    # 保存当前,开始新的
                    if current:
                        result.append(current)
                    # 如果新片段本身就超长,递归切
                    if len(piece) > max_size:
                        result.extend(recursive_split(piece, max_size, separators[separators.index(sep) + 1:]))
                        current = ""
                    else:
                        current = piece

            if current:
                result.append(current)

            # 检查结果是否都合规
            if all(len(r) <= max_size for r in result):
                return result

    return [text]


# 测试
text = """# 产品介绍

这是一个 AI 助手产品。它支持多种功能。

## 代码问答

支持 20+ 编程语言的问答,包括 Python、JavaScript、Go、Rust 等。
可以解释代码、找出 bug、生成测试。

## 文档检索

上传 PDF、Markdown、Word 文档,即可通过自然语言检索。
支持私有化部署,数据不出内网。"""

chunks = recursive_split(text, max_size=100)
for i, c in enumerate(chunks):
    print(f"--- 片段 {i+1} ({len(c)} 字) ---")
    print(c)
    print()

输出:

markdown 复制代码
--- 片段 1 (24 字) ---
# 产品介绍

这是一个 AI 助手产品。

--- 片段 2 (19 字) ---
它支持多种功能。

## 代码问答

--- 片段 3 (78 字) ---
支持 20+ 编程语言的问答,包括 Python、JavaScript、Go、Rust 等。
可以解释代码、找出 bug、生成测试。

--- 片段 4 (45 字) ---
## 文档检索

上传 PDF、Markdown、Word 文档,即可通过自然语言检索。

--- 片段 5 (24 字) ---
支持私有化部署,数据不出内网。

优点:

  • ✅ 尊重语义边界
  • ✅ 长度可控
  • ✅ 不切断句子

这是目前最通用的方案,生产首选。

4. 策略四:语义切分

用 Embedding 判断"哪里是分界"。

核心思想: 相邻句子的语义相似度突然下降 = 话题变了。

流程:

markdown 复制代码
1. 按句子切分
2. 计算相邻句子的相似度
3. 相似度低于阈值 → 在这里切
4. 合并相邻片段到合适大小

代码实现:

python 复制代码
import numpy as np


def semantic_split(
    text: str,
    threshold: float = 0.7,
    max_size: int = 1000,
) -> list[str]:
    """语义切分"""
    # 1. 按句子切分
    import re
    sentences = re.split(r"(?<=[。!?.!?])\s*", text)
    sentences = [s.strip() for s in sentences if s.strip()]

    if len(sentences) <= 1:
        return sentences

    # 2. 获取 Embedding
    embeddings = embed(sentences)   # 假设有 embed 函数

    # 3. 计算相邻相似度
    chunks = []
    current = [sentences[0]]

    for i in range(1, len(sentences)):
        sim = cosine_sim(embeddings[i-1], embeddings[i])

        if sim < threshold:
            # 相似度低 → 在此分界
            chunks.append("".join(current))
            current = [sentences[i]]
        else:
            current.append(sentences[i])

    if current:
        chunks.append("".join(current))

    # 4. 合并过短的片段
    result = []
    buffer = ""
    for c in chunks:
        if len(buffer) + len(c) <= max_size:
            buffer += c
        else:
            if buffer:
                result.append(buffer)
            buffer = c
    if buffer:
        result.append(buffer)

    return result

优点:

  • ✅ 语义最准确
  • ✅ 每个片段"主题一致"

缺点:

  • ❌ 要额外调 Embedding:慢
  • ❌ 阈值难调
  • ❌ 对短文本不划算

适合: 长文档、主题变化明显的内容(长文章、论文)。

5. 四种策略对比

策略 效果 速度 实现 适合
固定长度 ⭐ 极快 极简 日志、代码
分隔符 ⭐⭐⭐ 快 简单 FAQ、规章
递归 ⭐⭐⭐⭐ 快 中 通用首选
语义 ⭐⭐⭐⭐⭐ 慢 复杂 长文、论文

我的推荐:

erlang 复制代码
默认 → 递归切分(80% 场景够用)
长文/高质量要求 → 语义切分
特定格式 → 分隔符切分

三、切分粒度:最关键的参数

1. 多大合适

经验值:

场景 推荐大小 重叠
问答 / FAQ 200-500 字 0-50
技术文档 500-1000 字 50-100
长文 / 论文 1000-2000 字 100-200
代码 按函数切 ---

判断标准:

"一个片段应该能回答一个典型问题。"

典型问题有多长? 通常 20-100 字。

答案通常 200-1000 字。

所以片段 300-1000 字最合适。

2. 太小 vs 太大

太小(< 200 字):

  • ❌ 上下文不足:只有半句话,模型看不懂
  • ❌ 检索噪声大:很多短片段都相关,排不出主次
  • ❌ 浪费:一次要检索更多片段

太大(> 2000 字):

  • ❌ 稀释相关性:检索到的片段只有一部分有用
  • ❌ 浪费 token:塞给 LLM 的 token 多
  • ❌ 模型分心:内容太多,忽略关键信息

最佳区间:

yaml 复制代码
300 - 1000 字

约等于 200-600 token。

3. 重叠:让边界不丢信息

问题: 一个答案跨越两个片段:

arduino 复制代码
片段 1: "...报销流程是:填写报销单,"
片段 2: "部门经理签字,然后交给财务..."

如果只检索到片段 1,答案不完整。

解决: 片段之间加"重叠"。

yaml 复制代码
片段 1: [0, 500]
片段 2: [400, 900]     ← 前 100 字重叠
片段 3: [800, 1300]

推荐重叠:

片段大小 重叠
200-500 0-50
500-1000 50-100
1000-2000 100-200

经验公式: 重叠 ≈ 片段大小的 10-20%。

注意: 重叠太多会冗余------同样的内容存多份,浪费存储和检索。

4. 前端视角:切分就像"分页"

做过列表分页的你:

分页 切分
每页 20 条 每片 500 字
页码边界 片段边界
上一页/下一页 前后片段
重叠数据 片段重叠

思考方式完全一样:

  • 分页大小:太大→加载慢;太小→翻页多
  • 片段大小:太大→不精准;太小→缺上下文
  • 边界处理:分页要在"记录边界"切;片段要在"语义边界"切

从"数据分页"到"语义切分",思维是延续的。


四、实战:给技术文档做最优切分

1. 项目准备

bash 复制代码
cp -r day48/product_qa day49/better_chunking
cd day49/better_chunking

2. 实现递归切分器

splitter.py:

python 复制代码
"""文档切分器"""
from dataclasses import dataclass


@dataclass
class Chunk:
    """一个文档片段"""
    content: str
    source: str
    chunk_id: int
    metadata: dict


class RecursiveSplitter:
    """递归切分器(LangChain 风格)"""

    def __init__(
        self,
        chunk_size: int = 500,
        chunk_overlap: int = 50,
        separators: list[str] = None,
    ):
        self.chunk_size = chunk_size
        self.chunk_overlap = chunk_overlap
        self.separators = separators or [
            "\n## ",      # 二级标题
            "\n### ",     # 三级标题
            "\n\n",       # 段落
            "\n",         # 换行
            "。",         # 中文句号
            "!",
            "?",
            ".",
            "!",
            "?",
            ";",
            ";",
            ",",
            ", ",
            " ",
            "",
        ]

    def split(self, text: str) -> list[str]:
        """切分文本"""
        return self._split(text, self.separators)

    def _split(self, text: str, separators: list[str]) -> list[str]:
        """递归切分"""
        final_chunks = []

        # 选分隔符
        separator = separators[-1]
        new_separators = []
        for i, sep in enumerate(separators):
            if sep == "":
                separator = sep
                break
            if sep in text:
                separator = sep
                new_separators = separators[i + 1:]
                break

        # 按分隔符切
        if separator:
            splits = text.split(separator)
        else:
            splits = list(text)

        # 组装
        good_splits = []
        for s in splits:
            if len(s) < self.chunk_size:
                good_splits.append(s)
            else:
                if good_splits:
                    merged = self._merge(good_splits, separator)
                    final_chunks.extend(merged)
                    good_splits = []
                # 递归
                if new_separators:
                    final_chunks.extend(self._split(s, new_separators))
                else:
                    final_chunks.append(s)

        if good_splits:
            merged = self._merge(good_splits, separator)
            final_chunks.extend(merged)

        return final_chunks

    def _merge(self, splits: list[str], separator: str) -> list[str]:
        """把小片段合并到合适大小"""
        chunks = []
        current = []

        for s in splits:
            # 加分隔符后的长度
            sep_len = len(separator) if current else 0
            if sum(len(x) for x in current) + len(s) + sep_len > self.chunk_size:
                if current:
                    chunks.append(separator.join(current))
                current = [s]
            else:
                current.append(s)

        if current:
            chunks.append(separator.join(current))

        # 加重叠
        if self.chunk_overlap > 0:
            chunks = self._add_overlap(chunks, separator)

        return chunks

    def _add_overlap(self, chunks: list[str], separator: str) -> list[str]:
        """增加片段间重叠"""
        if len(chunks) <= 1:
            return chunks

        result = [chunks[0]]
        for i in range(1, len(chunks)):
            prev = chunks[i - 1]
            # 取前一片段末尾作为重叠
            overlap_text = prev[-self.chunk_overlap:] if len(prev) > self.chunk_overlap else prev
            result.append(overlap_text + separator + chunks[i])

        return result

3. 更新文档加载

loader.py 改成用递归切分:

python 复制代码
"""文档加载器"""
from pathlib import Path

from splitter import RecursiveSplitter


@dataclass
class Document:
    content: str
    source: str
    chunk_id: int
    metadata: dict


def load_markdown(file_path: Path, splitter: RecursiveSplitter) -> list[Document]:
    """加载 Markdown,用递归切分"""
    content = file_path.read_text(encoding="utf-8")

    # 解析元数据(可选,简化处理)
    # 比如从文件名推断分类
    category = "faq" if "faq" in file_path.name else "product"

    # 切分
    chunks = splitter.split(content)

    return [
        Document(
            content=c.strip(),
            source=file_path.name,
            chunk_id=i,
            metadata={"category": category},
        )
        for i, c in enumerate(chunks)
        if c.strip() and len(c.strip()) > 20   # 过滤过短
    ]


def load_directory(dir_path: Path, splitter: RecursiveSplitter) -> list[Document]:
    """加载整个目录"""
    all_docs = []
    for file in sorted(dir_path.glob("*.md")):
        docs = load_markdown(file, splitter)
        all_docs.extend(docs)
        print(f"  加载 {file.name}: {len(docs)} 个片段")
    return all_docs

4. 更新索引构建

build_index.py 调整:

python 复制代码
"""构建向量索引"""
from pathlib import Path
import chromadb
from chromadb.utils import embedding_functions

from loader import load_directory
from splitter import RecursiveSplitter


# 初始化
client = chromadb.PersistentClient(path="./chroma_db")

embedding_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
    model_name="BAAI/bge-large-zh-v1.5"
)

# 用递归切分
splitter = RecursiveSplitter(chunk_size=400, chunk_overlap=50)

# 重建集合
try:
    client.delete_collection("product_docs_v2")
except Exception:
    pass

collection = client.create_collection(
    name="product_docs_v2",
    embedding_function=embedding_fn,
    metadata={"hnsw:space": "cosine"},
)

# 加载
print("加载文档...")
docs = load_directory(Path("data/docs"), splitter)
print(f"共 {len(docs)} 个片段\n")

# 入库
print("构建索引...")
collection.add(
    documents=[d.content for d in docs],
    metadatas=[
        {"source": d.source, "chunk_id": d.chunk_id, **d.metadata}
        for d in docs
    ],
    ids=[f"{d.source}_{d.chunk_id}" for d in docs],
)

print(f"✅ 索引完成,共 {collection.count()} 条记录")

5. 效果对比

测试同样的 FAQ 问题:

旧版(按段落切):

arduino 复制代码
❓ 支持哪些操作系统?

💬 支持 Windows 10+、macOS 11+、Ubuntu 20.04+。
   最低配置:4GB 内存、2 核 CPU,推荐 8GB 内存。

(答案混入了"配置要求",有点多余)

新版(递归切分,400 字):

复制代码
❓ 支持哪些操作系统?

💬 支持 Windows 10+、macOS 11+、Ubuntu 20.04+。

(精准)

关键改进:

  • 片段更小(400 vs 段落随意长度)
  • 语义更聚焦(一个问题一个片段)
  • 答案更精准(不混入无关内容)

6. 做一个"切分效果对比"

用同一个问题,跑不同切分方案,看效果:

compare_chunking.py:

python 复制代码
"""切分方案对比"""
import os
from pathlib import Path
import chromadb
from chromadb.utils import embedding_functions
from openai import OpenAI

from loader import load_directory
from splitter import RecursiveSplitter


client = chromadb.PersistentClient(path="./chroma_db")
embedding_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
    model_name="BAAI/bge-large-zh-v1.5"
)


def build_collection(name: str, chunk_size: int, overlap: int):
    """构建一个集合"""
    try:
        client.delete_collection(name)
    except Exception:
        pass

    collection = client.create_collection(
        name=name,
        embedding_function=embedding_fn,
        metadata={"hnsw:space": "cosine"},
    )

    splitter = RecursiveSplitter(chunk_size=chunk_size, chunk_overlap=overlap)
    docs = load_directory(Path("data/docs"), splitter)

    collection.add(
        documents=[d.content for d in docs],
        metadatas=[{"source": d.source, "chunk_id": d.chunk_id} for d in docs],
        ids=[f"{d.source}_{d.chunk_id}" for d in docs],
    )

    return collection, len(docs)


def query_collection(collection, question: str, top_k: int = 3):
    results = collection.query(query_texts=[question], n_results=top_k)
    return [
        {
            "content": results["documents"][0][i],
            "source": results["metadatas"][0][i]["source"],
            "similarity": 1 - results["distances"][0][i],
        }
        for i in range(len(results["ids"][0]))
    ]


if __name__ == "__main__":
    configs = [
        ("chunk_200", 200, 20),
        ("chunk_500", 500, 50),
        ("chunk_1000", 1000, 100),
    ]

    print("构建多个集合...\n")
    collections = {}
    for name, size, overlap in configs:
        collection, count = build_collection(name, size, overlap)
        collections[name] = collection
        print(f"  {name}: {count} 个片段")

    # 测试
    test_question = "怎么上传文档?"
    print(f"\n{'=' * 60}")
    print(f"测试问题: {test_question}")
    print(f"{'=' * 60}\n")

    for name, collection in collections.items():
        print(f"--- {name} ---")
        results = query_collection(collection, test_question, top_k=2)
        for r in results:
            print(f"  [{r['similarity']:.3f}] {r['source']}")
            print(f"  {r['content'][:80]}...")
        print()

运行:

less 复制代码
构建多个集合...

  chunk_200: 42 个片段
  chunk_500: 20 个片段
  chunk_1000: 12 个片段

============================================================
测试问题: 怎么上传文档?
============================================================

--- chunk_200 ---
  [0.878] faq.md
  Q: 怎么上传文档? A: 在设置页点击"上传文档",支持 PDF、...
  [0.712] faq.md
  支持 PDF、Markdown、Word 格式,单个文件不超过 50MB。

--- chunk_500 ---
  [0.856] faq.md
  Q: 怎么上传文档? A: 在设置页点击"上传文档",支持 PDF、
  Markdown、Word 格式,单个文件不超过 50MB。
  [0.698] faq.md
  使用问题 Q: 怎么上传文档...

--- chunk_1000 ---
  [0.712] faq.md
  # 常见问题 ## 安装问题 ... 使用问题 Q: 怎么上传文档?...
  (答案埋在长文里,相似度反而低)

结论:

  • chunk_200:精准,但可能缺上下文
  • chunk_500 :平衡最好(推荐)
  • chunk_1000:信息稀释,相似度下降

经验确认:400-500 字是"甜点区"。


五、特殊文档的切分

1. Markdown

优先按标题切:

python 复制代码
def split_markdown(text: str, max_size: int = 1000):
    """按 Markdown 标题切分"""
    # 按 ## 或 ### 切
    import re
    sections = re.split(r"\n(?=##+ )", text)

    chunks = []
    for section in sections:
        if len(section) <= max_size:
            chunks.append(section)
        else:
            # 太长就用递归
            splitter = RecursiveSplitter(max_size)
            chunks.extend(splitter.split(section))

    return chunks

保留标题很重要------ 标题是"上下文"。

优化:把标题拼在每个片段前面:

python 复制代码
def split_with_heading_context(text: str):
    """每个片段都带上标题"""
    import re
    lines = text.split("\n")

    current_h1 = ""
    current_h2 = ""
    chunks = []
    current_content = []

    for line in lines:
        if line.startswith("# "):
            current_h1 = line
        elif line.startswith("## "):
            current_h2 = line
        else:
            current_content.append(line)

        # 遇到下一个标题,保存
        if line.startswith("#") and current_content:
            # 拼上标题
            content = "\n".join(current_content).strip()
            if content:
                header = f"{current_h1}\n{current_h2}\n".strip()
                chunks.append(f"{header}\n\n{content}")
            current_content = []

    return chunks

每个片段都带"章节路径",检索时更精准。

2. PDF

PDF 是最难的------ 因为提取的文本往往乱。

处理流程:

markdown 复制代码
1. 用 PyPDF2 / pdfplumber 提取文本
2. 简单清洗(去页眉页脚)
3. 按 Markdown 逻辑切分

代码:

python 复制代码
def extract_pdf_text(pdf_path: str) -> str:
    """提取 PDF 文本"""
    from pdfplumber import open as open_pdf

    with open_pdf(pdf_path) as pdf:
        texts = []
        for page in pdf.pages:
            texts.append(page.extract_text())
        return "\n\n".join(texts)

坑: PDF 里的表格、图片、公式基本都丢------ 这是 RAG 的难点。

后面可以用"多模态模型"处理------ 直接看图理解。

3. 代码

代码按"函数"切:

python 复制代码
def split_code(code: str, language: str = "python"):
    """按函数/类切分代码"""
    import re

    if language == "python":
        # 按 def / class 切
        pattern = r"\n(?=(?:def|class) )"
    elif language == "javascript":
        pattern = r"\n(?=(?:function|class|const|let) )"
    else:
        pattern = r"\n\n"

    parts = re.split(pattern, code)
    return [p.strip() for p in parts if p.strip()]

代码片段带上"文件名 + 函数名"更有用:

python 复制代码
chunk = f"""# File: {file_path}
# Function: {func_name}

{code}"""

检索时能定位到"哪个文件的哪个函数"。

4. 前端视角:切分就像"代码分割"

前端做过的"代码分割"(Code Splitting):

  • 按路由分割:每个页面一个 bundle
  • 按组件分割:大组件单独打包
  • 按需加载:用户访问时才加载

文档切分也是"按需加载":

  • 按语义分割:每个话题一个片段
  • 按需检索:查询时只加载相关的

关键参数一样:

代码分割 文档切分
chunk size chunk size
vendor 分离 标题分离
共享 chunk 重叠
dynamic import 按需检索

前端经验直接迁移。


六、切分的"调试工具"

切分好不好,怎么验证? 需要工具。

1. 切分可视化

debug_chunks.py:

python 复制代码
"""切分调试工具"""
from pathlib import Path
from loader import load_directory
from splitter import RecursiveSplitter


def analyze_chunks(docs: list):
    """分析片段分布"""
    sizes = [len(d.content) for d in docs]

    print(f"\n总片段数: {len(docs)}")
    print(f"平均大小: {sum(sizes) / len(sizes):.0f} 字")
    print(f"最大: {max(sizes)} 字")
    print(f"最小: {min(sizes)} 字")

    # 分布
    import collections
    buckets = collections.Counter()
    for s in sizes:
        if s < 100:
            buckets["<100"] += 1
        elif s < 300:
            buckets["100-300"] += 1
        elif s < 500:
            buckets["300-500"] += 1
        elif s < 1000:
            buckets["500-1000"] += 1
        else:
            buckets[">=1000"] += 1

    print("\n大小分布:")
    for k in ["<100", "100-300", "300-500", "500-1000", ">=1000"]:
        count = buckets[k]
        bar = "█" * int(count / len(docs) * 50)
        print(f"  {k:12s} {count:3d}  {bar}")


if __name__ == "__main__":
    splitter = RecursiveSplitter(chunk_size=500, chunk_overlap=50)
    docs = load_directory(Path("data/docs"), splitter)

    analyze_chunks(docs)

    # 打印前几个片段看看
    print("\n前 5 个片段预览:")
    print("=" * 60)
    for i, d in enumerate(docs[:5], 1):
        print(f"\n【片段 {i}】 {d.source}")
        print(d.content[:200])
        print()

运行:

makefile 复制代码
加载文档...
  加载 faq.md: 12 个片段
  加载 product.md: 8 个片段

总片段数: 20
平均大小: 342 字
最大: 498 字
最小: 78 字

大小分布:
  <100         2  █████
  100-300      6  ███████████████
  300-500      12 ██████████████████████████████
  500-1000     0  
  >=1000       0  

关键指标:

  • 平均大小合理:342 字 ✓
  • 分布集中:大多在 300-500 ✓
  • 没有超长:最大 498 ✓
  • 少量超短:可能可以合并 ✓

这就是"健康的切分"。

2. 检索效果评估

更直接的验证------用几个已知答案的问题测试。

eval_chunks.py:

python 复制代码
"""切分效果评估"""
from pathlib import Path
import chromadb
from chromadb.utils import embedding_functions

from loader import load_directory
from splitter import RecursiveSplitter


# 已知问题-答案对
TEST_CASES = [
    {
        "question": "怎么上传文档?",
        "keywords": ["上传", "设置页", "50MB"],
    },
    {
        "question": "支持哪些编程语言?",
        "keywords": ["Python", "JavaScript", "20+"],
    },
    {
        "question": "可以退款吗?",
        "keywords": ["7 天", "无理由"],
    },
    {
        "question": "最低配置要求?",
        "keywords": ["4GB", "2 核"],
    },
]


def evaluate(chunk_size: int, overlap: int):
    """评估一个切分方案"""
    # 构建临时集合
    client = chromadb.Client()
    try:
        client.delete_collection("eval")
    except Exception:
        pass

    embedding_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
        model_name="BAAI/bge-large-zh-v1.5"
    )
    collection = client.create_collection(
        name="eval",
        embedding_function=embedding_fn,
        metadata={"hnsw:space": "cosine"},
    )

    splitter = RecursiveSplitter(chunk_size=chunk_size, chunk_overlap=overlap)
    docs = load_directory(Path("data/docs"), splitter)

    collection.add(
        documents=[d.content for d in docs],
        ids=[f"d_{i}" for i in range(len(docs))],
    )

    # 测试
    hit_count = 0
    for case in TEST_CASES:
        results = collection.query(
            query_texts=[case["question"]],
            n_results=3,
        )

        top_content = " ".join(results["documents"][0])
        if all(kw in top_content for kw in case["keywords"]):
            hit_count += 1

    return hit_count, len(TEST_CASES), len(docs)


if __name__ == "__main__":
    configs = [
        (200, 20),
        (300, 30),
        (500, 50),
        (800, 80),
        (1000, 100),
    ]

    print(f"{'chunk_size':<12} {'overlap':<10} {'命中率':<10} {'片段数':<10}")
    print("-" * 50)

    for size, overlap in configs:
        hit, total, n_chunks = evaluate(size, overlap)
        rate = hit / total
        print(f"{size:<12} {overlap:<10} {hit}/{total} ({rate:.0%})  {n_chunks:<10}")

运行:

scss 复制代码
chunk_size   overlap    命中率       片段数    
--------------------------------------------------
200          20         3/4 (75%)   42        
300          30         3/4 (75%)   28        
500          50         4/4 (100%)  20        ← 最佳
800          80         4/4 (100%)  15        
1000         100        4/4 (100%)  12        

结论:

  • 200 字太小:关键词被切断
  • 500 字最好:全部命中
  • 1000 字:虽然命中,但检索到过多信息

这就是"数据驱动"的切分优化------ 不是拍脑袋,是测出来。

3. 前端视角:切分调试就像"性能测试"

做过前端性能优化的你:

  • 写 Lighthouse 测试
  • 跑多次,看数据
  • A/B 对比,选最优

切分调试一样:

  • 跑评估脚本
  • 对比多个参数
  • 选最好的配置

核心方法完全一致: "用数据说话,而不是感觉"。


七、今日踩坑

  1. chunk_size 太小 → 检索到碎片,模型理解不了
  2. chunk_size 太大 → 检索到无关内容,回答跑偏
  3. overlap 太大 → 冗余严重,检索结果重复
  4. overlap 为 0 → 边界信息丢失
  5. 按固定长度切 → 切断句子和段落
  6. 递归切分没设多个分隔符 → 遇到长段落还是切不动
  7. Markdown 没保留标题 → 片段缺上下文
  8. 中文没有中文分隔符 → 只认标点,切出来很怪
  9. PDF 提取文本没清洗 → 页眉页脚混入片段
  10. 代码按字符切 → 函数被切碎
  11. 表格没特殊处理 → 结构丢失
  12. 超长片段不处理 → 超过 embedding 模型上限
  13. 没做切分质量评估 → 全靠感觉
  14. 一个文档一个配置 → 不同类型文档(FAQ / 论文)要不同策略
  15. 切分后没验证 → 上线才发现效果差

八、今日总结

今天核心收获三件事:

  1. 切分决定 RAG 效果上限:同文档、同模型,切分不同效果差 50%
  2. 四种策略 :固定长度 / 分隔符 / 递归 / 语义,递归切分是通用首选
  3. 甜点区是 400-800 字:太小缺上下文,太大稀释相关性

一个感受:

切分是 RAG 里"最不起眼但最重要"的环节。

大家关注 Embedding 模型、向量数据库、重排------切分往往被一笔带过。

但实际测试下来,切分优化的收益可能比换模型大 3-5 倍。

为什么?

因为切分是"数据预处理",决定了后续所有环节的天花板。

就像前端:

  • HTML 结构乱 → 再好的 CSS 也救不回来
  • 数据模型设计差 → 再好的组件也难用
  • 接口划分不合理 → 再好的状态管理也救不了

切分就是 RAG 的"数据模型设计"------ 做对了,后面很顺;做错了,后面全在填坑。

前端工程师对"结构"特别敏感------ 这是我们做 RAG 的隐藏优势。

从今天起,你的 RAG 有了"结构意识"。

Day 49 完成度:✅

明日预告(Day 50)

  • RAG 检索优化 :
    • 相似度阈值:什么时候"不回答"
    • Top-K 动态调整
    • 多路召回(向量 + 关键词)
    • 重排(Rerank)
    • HyDE:让 LLM 先"猜答案"再检索

最后

如果这篇对你有用,点个赞让我知道有人在看。

评论区互动: 你切分用的是多大?测过不同 size 的效果吗?欢迎分享你的"甜点区"。

有问题评论区见,我们第 50 天继续。

100 天,第 50 天见。


附录:系列目录

第一阶段:工程基础(已完成 ✅)

阶段 天数 内容
Python 基础 01-15 语法 + 命令行助手
后端工程化 16-30 数据库/测试/FastAPI/Docker/上线

第二阶段:LLM 应用(已完成 ✅)

阶段 天数 内容
LLM 全链路 31-45 调用/流式/工具/结构化/Prompt/成本/多模型/前端

第三阶段:RAG(进行中 🎯)

阶段 天数 内容
RAG 基础 46-48 RAG 入门 + Embedding + 向量数据库 ✅
文档处理 49 文档切分(本篇) ✅
文档处理 50 检索优化 + 重排
文档处理 51-56 加载器 / 元数据 / 完整索引
RAG 优化 57-59 混合检索 / 评估 / 调优
完整项目 60 知识库问答实战

第四阶段:Agent 进阶(Day 61-80)

第五阶段:完整项目(Day 81-100)

49 天已过,51 天继续。

一起从切图仔变成 Agent 开发者。

相关推荐
青少儿编程课堂1 小时前
第十八届蓝桥杯青少组图形化真题 + 全国青少年信息素养大赛 + 电子学会图形化考级:校园泡泡堂大挑战解析
c++·python·算法·bfs·信息学竞赛
Starry-sky(jing)2 小时前
Hermes Agent 升级 v0.23.2:先辨更新渠道,再看 CLI 退出残留修复
人工智能·python·ai agent
2601_967979122 小时前
“Python,就是新的 BASIC!”
python·编程语言·历史·basic·比较
青少儿编程课堂2 小时前
蓝桥杯·全国青少年信息素养大赛·电子学会Python/C++考级:Dinic最大流解析
c++·python·算法·bfs·信息学竞赛
专注仿真3 小时前
基于 AFSIM 的智能体训练:多智能体强化学习篇 —— QTRAN 算法实战
开发语言·python·算法·php·强化学习·afsim智能体·仿真训练
2601_967987374 小时前
Python类变量和实例变量(类属性和实例属性)
python·类变量·实例变量·类属性·实例属性
CyrusYiVPP4 小时前
新用户第二周还剩几个?pandas做留存率cohort分析,数据分析实战第6期
人工智能·python
岁月宁静14 小时前
五、《从零手撸 Agent》 — 什么是 Agent:从“会聊天”到“会做事”,差的就是一个循环
python·agent
梯度下降者14 小时前
Python - 函数
python·高阶函数·可调用对象·functools·嵌套作用域