前端转 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 对比,选最优
切分调试一样:
- 跑评估脚本
- 对比多个参数
- 选最好的配置
核心方法完全一致: "用数据说话,而不是感觉"。
七、今日踩坑
- chunk_size 太小 → 检索到碎片,模型理解不了
- chunk_size 太大 → 检索到无关内容,回答跑偏
- overlap 太大 → 冗余严重,检索结果重复
- overlap 为 0 → 边界信息丢失
- 按固定长度切 → 切断句子和段落
- 递归切分没设多个分隔符 → 遇到长段落还是切不动
- Markdown 没保留标题 → 片段缺上下文
- 中文没有中文分隔符 → 只认标点,切出来很怪
- PDF 提取文本没清洗 → 页眉页脚混入片段
- 代码按字符切 → 函数被切碎
- 表格没特殊处理 → 结构丢失
- 超长片段不处理 → 超过 embedding 模型上限
- 没做切分质量评估 → 全靠感觉
- 一个文档一个配置 → 不同类型文档(FAQ / 论文)要不同策略
- 切分后没验证 → 上线才发现效果差
八、今日总结
今天核心收获三件事:
- 切分决定 RAG 效果上限:同文档、同模型,切分不同效果差 50%
- 四种策略 :固定长度 / 分隔符 / 递归 / 语义,递归切分是通用首选
- 甜点区是 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 开发者。