w wyl123ly 的博客
MD

RAG文档分块策略

34 KB 2026.10.18 原文件

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 由块内主题数控制。两者方向相反:增大 缓解条件 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低高最小摘要、全局问题、父子分块的父块

重叠的选择由证据长度决定。取 、,按下表的公式计算完整率与冗余比例。

重叠 步长 完整率 索引冗余
02560.8480.000
262300.9430.113
512051.0000.249
771791.0000.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》中文笔记 —— 对应分块粒度与重叠比例的工程经验总结。