RAG文档分块策略
定义
分块(chunking)指把文档的 token 序列划分为有限个连续片段,每个片段同时作为检索索引单位与生成上下文的候选单位。
设文档 token 序列为 ,块长度上限为 ,相邻块共享 个 token,步长为 。固定长度分块产生
块数为
符号约定如下。
| 符号 | 含义 |
|---|---|
| 文档的 token 序列 | |
| 文档 token 总数 | |
| 块长度上限,单位为 token | |
| 相邻块共享的 token 数,称为重叠 | |
| 步长,相邻块起点的距离 | |
| 块数 | |
| 第 个块 | |
| 检索返回的块数 | |
| 用户查询 | |
| 嵌入函数,把文本映射为单位向量 | |
| 全部块构成的集合 | |
| 证据 span 的 token 长度 | |
| 证据起点相对所在块起点的偏移 |
其余术语在首次出现处定义。重叠(overlap)是相邻块共享的 token 数,它使边界附近的 token 在相邻块中重复出现,从而提高跨越边界的证据被完整包含的概率;块边界是第 块结束与第 块开始之间的位置;元数据(metadata)指随块一同存储的结构化字段,例如来源、标题路径与页码;结构分块(structural chunking)指利用文档标记或版面信息确定边界的方法;语义分块(semantic chunking)指以相邻句子嵌入相似度为切分依据的方法;父子分块(parent-child chunking)指用小块建立索引、用大块提供生成上下文的两级结构;Agentic 分块指由模型决定切分位置的方法。
为什么重要
检索阶段比较的对象是块向量而不是文档向量。设检索返回前 个块,答案证据若没有被任何块完整包含,则无论嵌入模型与重排模型多强,生成阶段都拿不到这段证据。召回集合由分块预先确定,这一约束不可在后续环节修复。
生成阶段按块分配 token 预算。块过长时,单个块占用大量上下文,能放入的块数减少,证据覆盖变窄;块过短时,块内缺少指代消解所需的前文,模型看到孤立的句子,答案容易缺失条件。两种失败都直接体现在答案正确率上。
评估阶段以块为单位定义指标。recall@k 统计相关块是否进入前 ,context precision 统计上下文中相关块的比例,引用准确率依赖块的字符偏移。改变分块方式等于改变评估数据集,历史指标不再可比。
成本随块数增长。块数为 时嵌入调用次数为 ,索引向量数为 ,重叠带来的额外 token 数为 。取 、、,则 ,,额外索引 token 约 ,即索引体积增加约 25%。
本篇在库中的位置是 RAG原理与流程 的第二步。流程笔记给出文档到答案的整体链路,本篇展开其中的切分环节;切分结果进入 Embedding与向量检索 做编码;召回对象进入 检索优化与重排Rerank 做融合与重排;最终指标由 RAG评估 定义。对应学习目标中的"能复现"与"会评估":能实现三种分块器并统计块数、平均长度与重叠率,能设计分块消融实验。
原理与推导
1 块是检索与上下文的最小单位
设查询为 ,块集合为 ,嵌入函数为 。单向量检索的决策为
生成阶段把 及其邻近块拼入上下文。由此产生两个独立的失败条件:
- 包含证据的块不在 中,或证据被边界切开,任何块都不完整包含它;
- 包含证据的块在 中,但块内混入多个主题,块向量偏离证据主题,余弦分数低于其他块。
条件 1 由 与 控制,条件 2 由块内主题数控制。两者方向相反:增大 缓解条件 1,加剧条件 2;减小 缓解条件 2,加剧条件 1。分块策略的本质是在这两个条件之间选择工作点。
2 边界损失与重叠的定量关系
把文档视为长度为 的 token 序列,块起点位于 ,第 块覆盖区间 。设证据是长度为 的连续 span,起点为 ,记 ,则 所在块从 开始。
证据被该块完整包含,当且仅当
若 在文档中均匀分布,则 在 上均匀取值,满足条件的取值个数为 ,于是
当 时,任何块都无法完整包含证据,。该式给出三条结论。
第一,重叠 直接提高完整率。取 、: 时 ,; 时 ,; 时 ,,完整率为 1。
第二,当 时,,任意不超过 的证据必然完整落在某一块内。这解释了为什么重叠只需覆盖典型证据长度,而不必按块长度的固定比例设置。
第三,增大 同时增大分子与分母,对完整率的改善取决于 是否同步增大; 时把 从 256 提到 512, 从 0.848 升到 0.924,仍低于 、 的 1.0。
重叠的代价是索引冗余。当 时 ,索引 token 总数为
冗余比例 只取决于重叠与步长之比,与文档长度无关。
3 块内主题混合与向量稀释
设一个块由 个句子组成,句子嵌入为单位向量 ,且两两正交。块向量取平均
查询向量恰好等于第一个句子的嵌入 。由正交性,、,因此
块内句子数从 1 增至 4、9、16 时,余弦从 1 降至 0.5、0.333、0.25。真实嵌入不正交,衰减速度与理论值不同,但方向一致:块内无关内容越多,与单一主题查询的相似度越低。
该结论解释了一个常见现象:把块从 128 token 增大到 512 token 后,检索命中率下降,而生成答案在命中时更完整。两种效应同时存在,只能通过评估确定工作点。
4 固定长度分块
固定长度分块按 token 数或字符数切分,步长恒定。其实现只需一次线性扫描,块长度一致,便于批处理与显存对齐。
按 token 切分需要与生成模型相同的分词器;按字符切分不需要分词器,但字符与 token 的比例随语种与内容变化。中文文本常见比例为 1 个字符对应 1 至 2 个 token,英文约为 4 个字符对应 1 个 token,代码与数字密集文本的比例又不同。用字符数代替 token 数估算上下文预算,在混合语料上会产生系统性偏差,中文与代码文本的 token 数通常被低估。
固定长度分块不识别语义边界。标题、列表项、表格行、代码语句都可能被切开。由第 2 节的公式,、、 时完整率为 0.848,意味着约 15% 的证据跨越边界;若证据更长,损失更大。
适用场景:文本结构均匀、证据较短、需要严格控制上下文预算的批量索引。它也是比较其他策略时的基线。
5 递归字符分块
递归字符分块维护一个从粗到细的分隔符列表,先按段落切分,片段仍超过 时按换行切分,再按句号、逗号、空格逐级回退,最后按字符硬切。切分完成后自左向右合并相邻片段,合并结果不超过 ,每次合并保留前一块末尾 个 token 作为下一块开头。
算法可写为两级过程。
split(text, seps, L):
if tokens(text) <= L: return [text]
if seps is empty: return hard_split(text, L)
sep, rest = seps[0], seps[1:]
pieces = split_keep(text, sep) # 分隔符附着在前一段末尾
return concat(split(p, rest, L) for p in pieces)
chunk(text, L, O):
pieces = split(text, SEPARATORS, L)
buffer = 空串
for p in pieces:
if tokens(buffer + p) <= L: buffer += p
else: flush(buffer); buffer = tail(buffer, O) + p
flush(buffer)
该算法的时间复杂度为 次分隔符扫描加上合并时的线性拼接;朴素实现若反复做字符串加法,最坏可退化为 ,工程上应使用列表累积后一次连接。
递归分块的块长度不均匀:段落短时会提前触发合并上限,产生明显短于 的块。本篇「例子与代码」一节的实测中,配置 、,平均块长只有 111 token,最短 81 token。块长度方差大意味着上下文预算难以精确控制,但边界落在标点处的比例显著高于固定分块。
6 语义分块
语义分块先按句子切分文档,再计算相邻句子的嵌入余弦,在低于阈值的位置断开:
阈值 有两种取法。绝对阈值需要在验证集上校准,跨文档迁移性差;分位数阈值 取当前文档相似度分布的 分位,自适应文档的尺度,但不同文档断点数量不可比。
仅按阈值切分会产生过短或过长的块,因此需要约束:块长低于 时禁止断开,高于 时强制断开。两个约束与阈值共同决定最终块数。
计算成本是每个句子一次嵌入调用。设句子数为 ,嵌入批大小为 ,则调用轮数为 ,总 token 数与文档长度同阶。语义分块因此比固定分块多一次全文档编码,但这次编码可以与后续块编码合并为同一批请求。
语义分块的失效情形有三类。代词与省略句的嵌入与任何句子都低相似,导致过度切分;长句内部发生主题转换时无法切开;相邻句子共享词汇但主题不同时,相似度偏高,导致欠切分。
7 结构分块
结构分块读取文档自身的标记,把标记边界作为候选切分点。
Markdown 文档按 ATX 标题(# 到 ######)构建标题栈,每个叶子节作为一个块;节超过 时在段落边界继续切分,切分后的每块继承完整标题路径,例如 部署指南 > 配置 > 超时设置。标题路径写入元数据,检索时可按章节过滤,生成时可作为引用前缀。
代码围栏(三个反引号)内部不做切分。代码块超过 时按空行或函数定义边界切分,并在每块开头重复语言标记与函数签名。表格按行切分时重复表头,否则后续块缺少列名,模型无法解释单元格。
PDF 需要版面分析:识别双栏顺序、页眉页脚、脚注与图表标题。直接按页切分会在跨页段落处断裂;按阅读顺序重排后再切分可缓解。页码、栏号与坐标写入元数据,用于引用与高亮。
结构分块的边界质量最高,但依赖解析器。解析失败的文档需要回退到递归分块,回退路径必须显式记录,否则同一批索引中混入两种边界规则,评估结果无法归因。
8 父子分块
父子分块建立两级结构:子块 长度约 128 至 256 token,用于索引与相似度计算;父块 长度约 512 至 2048 token,用于生成。每个子块保存指向父块的标识。
检索时对子块打分,取前 个子块,映射为去重后的父块集合 ,把 放入上下文。设父块长度为 ,上下文预算为 ,则可用父块数受
约束。由于多个子块可能属于同一父块, 恒成立,去重减少重复上下文。
父子结构同时获得两种粒度:子块向量聚焦单一主题,匹配精度接近小块;父块提供完整段落,生成时不会缺失条件。设子块长度为 ,索引条目增加为 ,且需要维护映射表;父块文本只存一份,用标识引用。
实现上有两种展开方式。检索后立即展开父块,上下文只含父块;或先放子块,生成前再替换为父块。前者实现简单,后者便于在重排阶段保留子块粒度的分数。
9 Agentic 分块
Agentic 分块把边界决策交给模型。做法是把文档与切分指令一起送入模型,要求输出切分位置或直接输出块列表;也可以要求模型把文档改写为原子命题集合,每个命题作为一个块。
成本结构与其他方法不同:输入 token 等于文档长度,输出 token 等于边界标记或改写后的文本,每个文档至少一次模型调用;若文档超过模型上下文,还需先做粗切分再逐段处理。对 篇文档的语料,该方法的总调用成本比固定分块高两个数量级以上。
确定性也是问题。即使温度设为 0,不同批次、不同模型版本仍可能给出不同边界,索引需要版本号,重建时必须整批重跑。适合的场景是高价值、低数量、结构异常的文档,例如合同、论文与手册;不适合海量网页。
10 块大小与重叠的权衡
块大小的选择取决于查询类型与证据长度。下表给出一组常用工作点及其性质,数值为经验范围,实际取值需在验证集上测量。
| 块大小(token) | 检索精度 | 上下文完整性 | 索引体积 | 典型用途 |
|---|---|---|---|---|
| 64–128 | 高 | 低 | 大 | 事实型问答、FAQ、实体属性 |
| 256 | 较高 | 中 | 中 | 通用默认值 |
| 512 | 中 | 较高 | 小 | 技术文档、需要段落条件的问题 |
| 1024–2048 | 低 | 高 | 最小 | 摘要、全局问题、父子分块的父块 |
重叠的选择由证据长度决定。取 、,按下表的公式计算完整率与冗余比例。
| 重叠 | 步长 | 完整率 | 索引冗余 |
|---|---|---|---|
| 0 | 256 | 0.848 | 0.000 |
| 26 | 230 | 0.943 | 0.113 |
| 51 | 205 | 1.000 | 0.249 |
| 77 | 179 | 1.000 | 0.430 |
重叠从 0 增至 51 使完整率提高 15 个百分点,索引冗余增加 25%;继续增至 77 不再提高完整率,只增加冗余。工程上应先用验证集估计证据长度分布的上四分位数,再取 略大于该值。
11 元数据设计
元数据决定检索之后能否引用、过滤与重排。常用字段如下。
| 字段 | 类型 | 用途 | 注意 |
|---|---|---|---|
doc_id | 字符串 | 去重与增量更新 | 全局唯一,不用文件名 |
source | 字符串 | 引用与权限 | 与访问控制表对应 |
title_path | 字符串 | 章节过滤、引用前缀 | 用固定分隔符连接标题栈 |
page | 整数 | 引用定位 | PDF 与扫描件必需 |
char_start / char_end | 整数 | 高亮与偏移校验 | 相对于原始文档而非块 |
section_type | 枚举 | 区分正文、表格、代码、脚注 | 影响生成提示 |
version | 字符串 | 索引版本 | 与分块器版本一同记录 |
lang | 字符串 | 分词与嵌入模型选择 | 混合语料必需 |
设计约束有三条。过滤字段应是低基数字段,高基数字段放入负载而不建索引,否则过滤选择性差且内存占用高。页码与字符偏移必须指向原始文档,块内相对偏移在重建后会失效。父子分块中,子块元数据应复制父块的 doc_id、source 与 title_path,否则展开父块后无法引用。
12 选择决策树
下图给出从文档特征到分块策略的决策顺序。
flowchart TD
A["文档是否有稳定的结构标记"] -->|"是"| B["按标题、章节、表格、代码块切分"]
A -->|"否"| C["文本是否同质且证据较短"]
C -->|"是"| D["固定长度分块,重叠覆盖证据长度"]
C -->|"否"| E["是否有句子级嵌入预算"]
E -->|"是"| F["语义分块,分位数阈值加长度约束"]
E -->|"否"| G["递归字符分块"]
B --> H["块是否仍超过 512 token"]
H -->|"是"| G
H -->|"否"| I["结构块直接入索引"]
D --> J["父子分块:子块索引,父块生成"]
F --> J
G --> J
决策顺序的理由:结构标记的边界质量最高且成本最低,应优先使用;没有结构时,固定分块是成本最低的基线,只有在证据长度分布已知时才可直接采用;语义分块需要额外的嵌入预算,只在查询以语义匹配为主时使用;递归分块是通用回退;父子结构用于同时需要精度与完整上下文的场景,它在任何基础分块之上叠加。
13 评估分块的方法
分块评估需要固定其他变量:同一嵌入模型、同一检索器、同一生成模型、同一提示模板,只改变分块器。
指标一为证据完整率。构造一批带标注的问题,每个问题的答案证据在原文中有确定 span。统计证据被至少一个块完整包含的比例,该指标与生成模型无关,直接反映切分质量。
指标二为 recall@k。统计包含证据的块是否进入检索前 。该指标同时受分块与嵌入模型影响,用于比较端到端检索效果。
指标三为答案正确率与引用准确率。前者用人工标注或模型判定,后者统计答案引用的块是否真的包含支撑句。
实验设计采用单变量对照:固定 改变 ,固定 改变 ,再比较固定、递归、语义、结构四种策略。每个配置重复三次取均值,报告置信区间。分块消融的样本量建议不少于 200 个问题,否则 5 个百分点的差异无法区分。
关键直觉
TIP
分块是在检索分辨率与证据完整性之间选择工作点:块越短,块向量越接近单一主题,匹配越精确,但证据跨块的概率越高;块越长则相反。重叠不改变主题分辨率,它只把边界代价从证据丢失转换为索引冗余,因此补偿的是切分误差,不补偿语义混杂。
该表述与第 2、3 节的推导对应:完整率 由 与 控制,块内主题混合导致的余弦衰减 由块内句子数 控制。两个量相互独立,调参时必须分别测量。
例子与代码
以下代码实现固定长度、递归字符与语义三种分块,并统计块数、平均长度、最短与最长长度、重叠率、覆盖率与句界完整率。运行环境为 Python 3.10 及以上、NumPy 1.24 及以上,只依赖标准库与 NumPy。
分词采用近似规则:每个汉字、每个英文单词、每个数字串、每个标点各记为一个 token。该规则用于让代码不依赖具体分词器,统计口径在同一份文档内保持一致;真实系统应替换为与生成模型相同的分词器。
# Python 3.10+, numpy>=1.24
import hashlib
import re
from dataclasses import dataclass, field
import numpy as np
TOKEN_RE = re.compile(r"[\u4e00-\u9fff]|[A-Za-z]+|\d+|[^\s]")
def spans(text):
"""返回每个 token 在原文中的 (start, end),用于构造块偏移。"""
return [(m.start(), m.end()) for m in TOKEN_RE.finditer(text)]
def n_tokens(text):
return len(TOKEN_RE.findall(text))
@dataclass
class Chunk:
text: str
start: int
end: int
strategy: str
meta: dict = field(default_factory=dict)
def __len__(self):
return n_tokens(self.text)
def chunk_fixed(text, size=160, overlap=32):
"""固定长度分块:起点按 stride 前进,最后一块吸收尾部。"""
assert 0 <= overlap < size
sp = spans(text)
step = size - overlap
out, i = [], 0
while i < len(sp):
win = sp[i:i + size]
out.append(Chunk(text[win[0][0]:win[-1][1]], win[0][0], win[-1][1], "fixed"))
if i + size >= len(sp):
break
i += step
return out
SEPARATORS = ["\n\n", "\n", "。", "!", "?", ";", ". ", "! ", "? ", ",", ", ", " ", ""]
def _split_keep(text, sep):
"""切分并把分隔符留在前一段末尾,保证拼回后与原文一致。"""
if sep == "":
return list(text)
parts = text.split(sep)
out = [p + sep for p in parts[:-1]]
if parts[-1]:
out.append(parts[-1])
return [p for p in out if p]
def _hard_split(text, size):
sp = spans(text)
out = []
for i in range(0, len(sp), size):
win = sp[i:i + size]
out.append(text[win[0][0]:win[-1][1]])
return out
def _recursive_split(text, seps, size):
"""按分隔符优先级递归切分,直到每片不超过 size 个 token。"""
if n_tokens(text) <= size:
return [text]
if not seps:
return _hard_split(text, size)
sep, rest = seps[0], seps[1:]
out = []
for piece in _split_keep(text, sep):
if n_tokens(piece) <= size:
out.append(piece)
else:
out.extend(_recursive_split(piece, rest, size))
return out
def _tail_by_tokens(s, k):
if k <= 0:
return ""
sp = spans(s)
return s[sp[-k][0]:] if len(sp) > k else s
def chunk_recursive(text, size=160, overlap=32):
"""先递归切到原子片段,再自左向右合并,flush 时保留尾部 overlap 个 token。"""
pieces = _recursive_split(text, SEPARATORS, size)
chunks, buf, buf_start, pos = [], "", 0, 0
for piece in pieces:
if not buf:
buf, buf_start = piece, pos
elif n_tokens(buf + piece) <= size:
buf += piece
else:
if buf.strip():
chunks.append(Chunk(buf, buf_start, buf_start + len(buf), "recursive"))
end = buf_start + len(buf)
tail = _tail_by_tokens(buf, overlap)
buf = tail + piece
buf_start = end - len(tail)
pos += len(piece)
if buf.strip():
chunks.append(Chunk(buf, buf_start, buf_start + len(buf), "recursive"))
return chunks
SYNONYMS = {"refund": "reimburse", "repayment": "reimburse"}
def _embed_tokens(text):
toks = re.findall(r"[a-z0-9\-]+|[\u4e00-\u9fff]", text.lower())
toks = [SYNONYMS.get(t, t) for t in toks]
return toks + [a + b for a, b in zip(toks, toks[1:])]
def embed(text, dim=256):
"""哈希词袋嵌入,替代真实嵌入模型,使代码离线可复现。"""
v = np.zeros(dim)
for t in _embed_tokens(text):
h = int(hashlib.md5(t.encode("utf-8")).hexdigest()[:8], 16)
v[h % dim] += 1.0
n = np.linalg.norm(v)
return v / n if n > 0 else v
SENT_RE = re.compile(r"[^。!?!?\.]+[。!?!?\.]?")
def split_sentences(text):
return [(m.start(), m.end()) for m in SENT_RE.finditer(text) if m.group().strip()]
def chunk_semantic(text, percentile=30.0, min_tokens=50, max_tokens=180):
"""相邻句相似度低于分位数阈值时断开,并受最小/最大块长约束。"""
sents = split_sentences(text)
vecs = np.stack([embed(text[s:e]) for s, e in sents])
sims = np.array([float(vecs[i] @ vecs[i + 1]) for i in range(len(vecs) - 1)])
thr = float(np.percentile(sims, percentile))
groups, cur = [], [0]
def length(g):
return n_tokens(text[sents[g[0]][0]:sents[g[-1]][1]])
for i, sim in enumerate(sims):
nxt = cur + [i + 1]
if (sim < thr and length(cur) >= min_tokens) or length(nxt) > max_tokens:
groups.append(cur)
cur = [i + 1]
else:
cur = nxt
groups.append(cur)
return [Chunk(text[sents[g[0]][0]:sents[g[-1]][1]],
sents[g[0]][0], sents[g[-1]][1], "semantic") for g in groups]
def report(name, chunks, text):
lens = [len(c) for c in chunks]
sp = spans(text)
sets = [{i for i, (s, e) in enumerate(sp) if s >= c.start and e <= c.end} for c in chunks]
ovs = [len(a & b) / max(1, len(b)) for a, b in zip(sets, sets[1:])]
covered = len(set().union(*sets)) if sets else 0
ends_ok = sum(1 for c in chunks if c.end >= len(text) or text[c.end - 1] in "。!?!?.\n")
print(f"{name:<10} 块数={len(chunks):>2} 平均token={np.mean(lens):6.1f} "
f"最短={min(lens):>3} 最长={max(lens):>3} "
f"重叠率={(np.mean(ovs) if ovs else 0):6.2%} 覆盖率={covered / len(sp):6.2%} "
f"句界完整率={ends_ok / len(chunks):6.2%}")
print(f" 首块: {chunks[0].text[:36]!r}")
print(f" 末块: {chunks[-1].text[-36:]!r}")
DOC = """检索增强生成把外部文档作为生成条件。文档在进入向量库之前必须被切分为块,块同时是检索的最小单位与上下文的最小单位。
分块长度直接影响检索质量。块过长时,一个块内部可能包含多个主题,块的嵌入向量是这些主题向量的平均,与单一主题查询的相似度被无关内容稀释。块过短时,答案所依赖的上下文可能被切断,生成阶段看到的证据不完整。
固定长度分块按 token 数切分,实现简单,块长度一致,便于批量处理。它的缺点是不识别语义边界,标题与正文可能被分开,表格与代码块可能被截断。
递归字符分块按段落、句子、词的顺序回退。它先尝试在段落边界切分,若片段仍超过长度上限,则用下一级分隔符继续切分,最后按上限合并相邻片段。
语义分块先计算相邻句子的嵌入相似度,在相似度低于阈值的位置断开。阈值可以取相似度分布的分位数,也可以按验证集调参。语义分块的计算成本高于固定分块,因为需要对每个句子做一次嵌入。
结构分块利用文档自身的标记,例如 Markdown 标题、代码围栏、表格与 PDF 版面。标题路径写入元数据,检索时可以按章节过滤,生成时可以把标题路径作为引用的一部分。
父子分块用小块建立索引,用大块提供生成上下文。检索命中子块后,向上取父块,从而同时获得精确匹配与完整上下文。子块的长度通常在一百到三百 token 之间,父块在五百到两千 token 之间。
块大小与重叠需要权衡。增大块提高上下文完整性,降低检索精度并增加生成成本。重叠减少边界信息损失,同时增加索引体积与冗余。重叠率通常取块长度的百分之十到百分之二十。
元数据记录来源、标题路径、页码与字符偏移。页码用于引用,偏移用于高亮,标题路径用于过滤与重排特征。"""
if __name__ == "__main__":
fixed = chunk_fixed(DOC, size=160, overlap=32)
rec = chunk_recursive(DOC, size=160, overlap=32)
sem = chunk_semantic(DOC, percentile=30, min_tokens=50, max_tokens=180)
print(f"文档 token 数={n_tokens(DOC)} 句子数={len(split_sentences(DOC))}")
for name, cs in [("fixed", fixed), ("recursive", rec), ("semantic", sem)]:
report(name, cs, DOC)
代码分四部分。第一部分定义 token 近似、Chunk 结构与固定分块;Chunk 同时保存字符偏移,后续统计与高亮都依赖它,去掉偏移只能重新搜索文本,遇到重复子串会定位错误。第二部分实现递归切分,_split_keep 把分隔符留在前一段末尾,保证片段拼接后与原文一致;去掉该处理会在块边界丢失标点,句子断裂。第三部分实现语义分块,阈值取相邻句相似度的 30 分位,未使用真实嵌入模型,embed 以哈希词袋替代,替换该函数即可接入生产模型。第四部分统计指标,重叠率按 计算,句界完整率统计块末尾字符是否落在句末标点或换行处。
在示例文档上运行,输出如下。
文档 token 数=665 句子数=23
fixed 块数= 5 平均token= 158.6 最短=153 最长=160 重叠率=20.23% 覆盖率=100.00% 句界完整率=20.00%
首块: '检索增强生成把外部文档作为生成条件。文档在进入向量库之前必须被切分为块,'
末块: '页码与字符偏移。页码用于引用,偏移用于高亮,标题路径用于过滤与重排特征。'
recursive 块数= 8 平均token= 111.1 最短= 81 最长=158 重叠率=31.11% 覆盖率=100.00% 句界完整率=100.00%
首块: '检索增强生成把外部文档作为生成条件。文档在进入向量库之前必须被切分为块,'
末块: '页码与字符偏移。页码用于引用,偏移用于高亮,标题路径用于过滤与重排特征。'
semantic 块数= 7 平均token= 95.0 最短= 60 最长=166 重叠率= 0.00% 覆盖率=100.00% 句界完整率=100.00%
首块: '检索增强生成把外部文档作为生成条件。文档在进入向量库之前必须被切分为块,'
末块: '页码与字符偏移。页码用于引用,偏移用于高亮,标题路径用于过滤与重排特征。'
三种策略的差异可以直接读出。
固定分块的块数最少,长度最整齐,最短 153、最长 160,标准差很小;但句界完整率只有 20%,即 5 个块中只有末块恰好结束在文档末尾。这是固定步长切分的必然结果,与第 2 节的边界损失公式一致。
递归分块的块数为 8,比固定分块多,原因是段落边界触发了提前 flush:每段结束后若下一段放不进当前块,就立即输出当前块,而不填充到 160 token。平均长度因此降到 111,最短 81。实测重叠率 31.11% 高于配置的 ,因为重叠率的分母是下一块长度,而下一块平均只有 111 token,,且部分块的下一块更短,因此实测值略高于该估算。句界完整率为 100%,因为所有块都在分隔符处结束。
语义分块产生 7 个块,最长 166,未超过 ,最短 60,达到 ,句界完整率 100%,重叠率为 0。它没有使用重叠却在句界处全部对齐,说明重叠与句界对齐是两种独立的边界质量控制手段:前者处理不可避免的硬切,后者从源头避免硬切。
覆盖率三者为 100%,因为块是连续窗口且未丢弃短块。若实现中加入"丢弃小于 20 token 的块",覆盖率会低于 100%,被丢弃区间内的证据永久不可检索,这是常见的隐性指标下降来源。
把上述统计接入 从零实现RAG指南 的索引流程时,应在写入向量库前断言覆盖率等于 1,并把块数、平均长度与句界完整率写入索引清单,便于重建后对比。
易错点
WARNING
- 用字符数代替 token 数:中文、英文与代码的字符/token 比例不同,按字符设定的 512 在英文中约为 128 token,在中文中为 512 至 1024 token,上下文预算与块数统计都会偏差。
- 只调块大小而不调重叠: 时证据完整率上限为 ,把 从 256 提到 512 只把完整率从 0.848 提到 0.924,仍低于 、 的 1.0。
- 语义分块使用固定绝对阈值:不同文档的相邻句相似度分布尺度不同,固定阈值在长文档上过度切分、在短文档上几乎不切分;应按文档分位数或验证集校准。
- 按长度硬切表格与代码:表头与数据行分离、代码语句被截断,检索命中后生成阶段无法解析,且引用坐标指向半个语法单元。
- 父子分块只保存子块文本:检索命中后取不到父块,或父块需要重新解析原文,延迟与失败率都会上升;必须显式保存 child 到 parent 的映射与父块文本。
- 用平均块长评价分块质量:平均长度相同但分布不同的两种策略,检索表现可能差异很大;应同时报告最短、最长、标准差与句界完整率。
关联笔记
- RAG原理与流程(前置):给出文档到答案的完整链路,本篇展开其中"文档切分为块"这一步。
- Embedding与向量检索(前置):块是嵌入与相似度计算的对象,嵌入模型的输入长度上限直接约束块大小。
- 检索优化与重排Rerank(后续):召回阶段的候选集由块集合构成,重排只能在已召回的块内调整顺序。
- RAG评估(后续):recall@k 与 context precision 以块为单位定义,分块变化会使历史指标不可比。
- 从零实现RAG指南(后续):把本篇的分块器接入最小 RAG 管线,并用覆盖率断言保护索引质量。
达标检测
- [ ] 能写出固定长度分块的块数公式,并在 、、 时算出 。
- [ ] 能推导证据完整率 ,并说明 时完整率恒为 1 的原因。
- [ ] 能运行本篇代码,把语义分块的百分位阈值从 30 改为 10,说明块数与平均长度的变化方向并给出理由。
- [ ] 能解释递归分块在本篇示例中块数多于固定分块的原因,并指出重叠率高于配置值的原因。
- [ ] 能对一份 Markdown 文档写出保留标题路径、代码围栏与表格表头的结构分块规则。
- [ ] 能识别"用字符数代替 token 数"的错误,并给出中文、英文、代码三类文本的字符/token 比例差异。
- [ ] 能为 token 的语料估算 、 时的块数与额外索引 token 数。
参考来源
- LangChain 文档,Text splitters 章节 —— 对应本篇递归字符分块的分隔符优先级与合并策略。
- LlamaIndex 文档,Node parsers 与 Ingestion pipeline 章节 —— 对应结构分块与父子分块的工程接口。
- Gao et al., Retrieval-Augmented Generation for Large Language Models: A Survey, arXiv:2312.10997 —— 对应分块在 RAG 流程中的位置与检索质量影响因素。
- aneasystone,《Advanced RAG Techniques》中文笔记 —— 对应分块粒度与重叠比例的工程经验总结。