---
tags: [AI, rag, chunking]
阶段: 06-Prompt与RAG
难度: ★★☆
created: 2026-10-18
related: "[[RAG原理与流程]], [[Embedding与向量检索]], [[检索优化与重排Rerank]]"
---

# RAG文档分块策略

## 定义

**分块**（chunking）指把文档的 token 序列划分为有限个连续片段，每个片段同时作为检索索引单位与生成上下文的候选单位。

设文档 token 序列为 $D=(w_1,\dots,w_N)$，块长度上限为 $L$，相邻块共享 $O$ 个 token，步长为 $S=L-O$。固定长度分块产生

$$
c_i=D\big[(i-1)S+1:(i-1)S+L\big],\qquad i=1,\dots,m,
$$

块数为

$$
m=\left\lceil\frac{N-L}{S}\right\rceil+1
=\left\lceil\frac{N-L}{L-O}\right\rceil+1,\qquad N>L.
$$

符号约定如下。

| 符号 | 含义 |
|---|---|
| $D$ | 文档的 token 序列 $(w_1,\dots,w_N)$ |
| $N$ | 文档 token 总数 |
| $L$ | 块长度上限，单位为 token |
| $O$ | 相邻块共享的 token 数，称为重叠 |
| $S=L-O$ | 步长，相邻块起点的距离 |
| $m$ | 块数 |
| $c_i$ | 第 $i$ 个块 |
| $k$ | 检索返回的块数 |
| $q$ | 用户查询 |
| $E(\cdot)$ | 嵌入函数，把文本映射为单位向量 |
| $\mathcal{C}$ | 全部块构成的集合 |
| $n_a$ | 证据 span 的 token 长度 |
| $u$ | 证据起点相对所在块起点的偏移 |

其余术语在首次出现处定义。**重叠**（overlap）是相邻块共享的 token 数，它使边界附近的 token 在相邻块中重复出现，从而提高跨越边界的证据被完整包含的概率；**块边界**是第 $i$ 块结束与第 $i+1$ 块开始之间的位置；**元数据**（metadata）指随块一同存储的结构化字段，例如来源、标题路径与页码；**结构分块**（structural chunking）指利用文档标记或版面信息确定边界的方法；**语义分块**（semantic chunking）指以相邻句子嵌入相似度为切分依据的方法；**父子分块**（parent-child chunking）指用小块建立索引、用大块提供生成上下文的两级结构；**Agentic 分块**指由模型决定切分位置的方法。

## 为什么重要

检索阶段比较的对象是块向量而不是文档向量。设检索返回前 $k$ 个块，答案证据若没有被任何块完整包含，则无论嵌入模型与重排模型多强，生成阶段都拿不到这段证据。召回集合由分块预先确定，这一约束不可在后续环节修复。

生成阶段按块分配 token 预算。块过长时，单个块占用大量上下文，能放入的块数减少，证据覆盖变窄；块过短时，块内缺少指代消解所需的前文，模型看到孤立的句子，答案容易缺失条件。两种失败都直接体现在答案正确率上。

评估阶段以块为单位定义指标。recall@k 统计相关块是否进入前 $k$，context precision 统计上下文中相关块的比例，引用准确率依赖块的字符偏移。改变分块方式等于改变评估数据集，历史指标不再可比。

成本随块数增长。块数为 $m$ 时嵌入调用次数为 $m$，索引向量数为 $m$，重叠带来的额外 token 数为 $(m-1)O$。取 $N=10^6$、$L=256$、$O=51$，则 $S=205$，$m\approx4878$，额外索引 token 约 $2.5\times10^5$，即索引体积增加约 25%。

本篇在库中的位置是 [[RAG原理与流程]] 的第二步。流程笔记给出文档到答案的整体链路，本篇展开其中的切分环节；切分结果进入 [[Embedding与向量检索]] 做编码；召回对象进入 [[检索优化与重排Rerank]] 做融合与重排；最终指标由 [[RAG评估]] 定义。对应学习目标中的"能复现"与"会评估"：能实现三种分块器并统计块数、平均长度与重叠率，能设计分块消融实验。

## 原理与推导

### 1 块是检索与上下文的最小单位

设查询为 $q$，块集合为 $\mathcal{C}=\{c_1,\dots,c_m\}$，嵌入函数为 $E$。单向量检索的决策为

$$
c^{*}=\arg\max_{c\in\mathcal{C}}\ \cos\big(E(q),E(c)\big).
$$

生成阶段把 $c^{*}$ 及其邻近块拼入上下文。由此产生两个独立的失败条件：

1. 包含证据的块不在 $\mathcal{C}$ 中，或证据被边界切开，任何块都不完整包含它；
2. 包含证据的块在 $\mathcal{C}$ 中，但块内混入多个主题，块向量偏离证据主题，余弦分数低于其他块。

条件 1 由 $L$ 与 $O$ 控制，条件 2 由块内主题数控制。两者方向相反：增大 $L$ 缓解条件 1，加剧条件 2；减小 $L$ 缓解条件 2，加剧条件 1。分块策略的本质是在这两个条件之间选择工作点。

### 2 边界损失与重叠的定量关系

把文档视为长度为 $N$ 的 token 序列，块起点位于 $0,S,2S,\dots$，第 $j$ 块覆盖区间 $[jS,\ jS+L)$。设证据是长度为 $n_a$ 的连续 span，起点为 $p$，记 $u=p\bmod S$，则 $p$ 所在块从 $p-u$ 开始。

证据被该块完整包含，当且仅当

$$
u+n_a\le L.
$$

若 $p$ 在文档中均匀分布，则 $u$ 在 $\{0,1,\dots,S-1\}$ 上均匀取值，满足条件的取值个数为 $\min(S,\ L-n_a+1)$，于是

$$
P_{\text{intact}}=\frac{\min\big(S,\ L-n_a+1\big)}{S}
=\min\left(1,\ \frac{L-n_a+1}{L-O}\right),\qquad 1\le n_a\le L.
$$

当 $n_a>L$ 时，任何块都无法完整包含证据，$P_{\text{intact}}=0$。该式给出三条结论。

第一，重叠 $O$ 直接提高完整率。取 $L=256$、$n_a=40$：$O=0$ 时 $S=256$，$P=217/256=0.848$；$O=26$ 时 $S=230$，$P=217/230=0.943$；$O=51$ 时 $S=205$，$P=217/205>1$，完整率为 1。

第二，当 $O\ge n_a-1$ 时，$S=L-O\le L-n_a+1$，任意不超过 $n_a$ 的证据必然完整落在某一块内。这解释了为什么重叠只需覆盖典型证据长度，而不必按块长度的固定比例设置。

第三，增大 $L$ 同时增大分子与分母，对完整率的改善取决于 $O$ 是否同步增大；$O=0$ 时把 $L$ 从 256 提到 512，$P$ 从 0.848 升到 0.924，仍低于 $L=256$、$O=51$ 的 1.0。

重叠的代价是索引冗余。当 $N\gg L$ 时 $m\approx N/S$，索引 token 总数为

$$
N+(m-1)O\approx N\left(1+\frac{O}{S}\right)=N\left(1+\frac{O}{L-O}\right),
$$

冗余比例 $O/(L-O)$ 只取决于重叠与步长之比，与文档长度无关。

### 3 块内主题混合与向量稀释

设一个块由 $m_s$ 个句子组成，句子嵌入为单位向量 $\mathbf{e}_1,\dots,\mathbf{e}_{m_s}$，且两两正交。块向量取平均

$$
\bar{\mathbf{e}}=\frac{1}{m_s}\sum_{j=1}^{m_s}\mathbf{e}_j .
$$

查询向量恰好等于第一个句子的嵌入 $\mathbf{q}=\mathbf{e}_1$。由正交性，$\|\mathbf{e}_j\|=1$、$\mathbf{e}_i\cdot\mathbf{e}_j=0\ (i\ne j)$，因此

$$
\|\bar{\mathbf{e}}\|^2=\frac{1}{m_s^2}\sum_{j=1}^{m_s}\|\mathbf{e}_j\|^2=\frac{1}{m_s},
\qquad
\mathbf{q}\cdot\bar{\mathbf{e}}=\frac{1}{m_s},
$$

$$
\cos(\mathbf{q},\bar{\mathbf{e}})
=\frac{\mathbf{q}\cdot\bar{\mathbf{e}}}{\|\mathbf{q}\|\,\|\bar{\mathbf{e}}\|}
=\frac{1/m_s}{1/\sqrt{m_s}}=\frac{1}{\sqrt{m_s}}.
$$

块内句子数从 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 节的公式，$O=0$、$L=256$、$n_a=40$ 时完整率为 0.848，意味着约 15% 的证据跨越边界；若证据更长，损失更大。

适用场景：文本结构均匀、证据较短、需要严格控制上下文预算的批量索引。它也是比较其他策略时的基线。

### 5 递归字符分块

递归字符分块维护一个从粗到细的分隔符列表，先按段落切分，片段仍超过 $L$ 时按换行切分，再按句号、逗号、空格逐级回退，最后按字符硬切。切分完成后自左向右合并相邻片段，合并结果不超过 $L$，每次合并保留前一块末尾 $O$ 个 token 作为下一块开头。

算法可写为两级过程。

```text
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)
```

该算法的时间复杂度为 $O(N)$ 次分隔符扫描加上合并时的线性拼接；朴素实现若反复做字符串加法，最坏可退化为 $O(N^2)$，工程上应使用列表累积后一次连接。

递归分块的块长度不均匀：段落短时会提前触发合并上限，产生明显短于 $L$ 的块。本篇「例子与代码」一节的实测中，配置 $L=160$、$O=32$，平均块长只有 111 token，最短 81 token。块长度方差大意味着上下文预算难以精确控制，但边界落在标点处的比例显著高于固定分块。

### 6 语义分块

语义分块先按句子切分文档，再计算相邻句子的嵌入余弦，在低于阈值的位置断开：

$$
\text{break at } i \iff \cos\big(E(s_i),E(s_{i+1})\big)<\tau .
$$

阈值 $\tau$ 有两种取法。绝对阈值需要在验证集上校准，跨文档迁移性差；分位数阈值 $\tau=Q_p(\{\cos_i\})$ 取当前文档相似度分布的 $p$ 分位，自适应文档的尺度，但不同文档断点数量不可比。

仅按阈值切分会产生过短或过长的块，因此需要约束：块长低于 $L_{\min}$ 时禁止断开，高于 $L_{\max}$ 时强制断开。两个约束与阈值共同决定最终块数。

计算成本是每个句子一次嵌入调用。设句子数为 $n_s$，嵌入批大小为 $B_{\text{emb}}$，则调用轮数为 $\lceil n_s/B_{\text{emb}}\rceil$，总 token 数与文档长度同阶。语义分块因此比固定分块多一次全文档编码，但这次编码可以与后续块编码合并为同一批请求。

语义分块的失效情形有三类。代词与省略句的嵌入与任何句子都低相似，导致过度切分；长句内部发生主题转换时无法切开；相邻句子共享词汇但主题不同时，相似度偏高，导致欠切分。

### 7 结构分块

结构分块读取文档自身的标记，把标记边界作为候选切分点。

Markdown 文档按 ATX 标题（`#` 到 `######`）构建标题栈，每个叶子节作为一个块；节超过 $L$ 时在段落边界继续切分，切分后的每块继承完整标题路径，例如 `部署指南 > 配置 > 超时设置`。标题路径写入元数据，检索时可按章节过滤，生成时可作为引用前缀。

代码围栏（三个反引号）内部不做切分。代码块超过 $L$ 时按空行或函数定义边界切分，并在每块开头重复语言标记与函数签名。表格按行切分时重复表头，否则后续块缺少列名，模型无法解释单元格。

PDF 需要版面分析：识别双栏顺序、页眉页脚、脚注与图表标题。直接按页切分会在跨页段落处断裂；按阅读顺序重排后再切分可缓解。页码、栏号与坐标写入元数据，用于引用与高亮。

结构分块的边界质量最高，但依赖解析器。解析失败的文档需要回退到递归分块，回退路径必须显式记录，否则同一批索引中混入两种边界规则，评估结果无法归因。

### 8 父子分块

父子分块建立两级结构：子块 $c^{\text{child}}$ 长度约 128 至 256 token，用于索引与相似度计算；父块 $c^{\text{parent}}$ 长度约 512 至 2048 token，用于生成。每个子块保存指向父块的标识。

检索时对子块打分，取前 $k$ 个子块，映射为去重后的父块集合 $\mathcal{P}$，把 $\mathcal{P}$ 放入上下文。设父块长度为 $L_p$，上下文预算为 $B$，则可用父块数受

$$
|\mathcal{P}|\le\left\lfloor\frac{B}{L_p}\right\rfloor
$$

约束。由于多个子块可能属于同一父块，$|\mathcal{P}|\le k$ 恒成立，去重减少重复上下文。

父子结构同时获得两种粒度：子块向量聚焦单一主题，匹配精度接近小块；父块提供完整段落，生成时不会缺失条件。设子块长度为 $L_c$，索引条目增加为 $N/L_c$，且需要维护映射表；父块文本只存一份，用标识引用。

实现上有两种展开方式。检索后立即展开父块，上下文只含父块；或先放子块，生成前再替换为父块。前者实现简单，后者便于在重排阶段保留子块粒度的分数。

### 9 Agentic 分块

Agentic 分块把边界决策交给模型。做法是把文档与切分指令一起送入模型，要求输出切分位置或直接输出块列表；也可以要求模型把文档改写为原子命题集合，每个命题作为一个块。

成本结构与其他方法不同：输入 token 等于文档长度，输出 token 等于边界标记或改写后的文本，每个文档至少一次模型调用；若文档超过模型上下文，还需先做粗切分再逐段处理。对 $10^5$ 篇文档的语料，该方法的总调用成本比固定分块高两个数量级以上。

确定性也是问题。即使温度设为 0，不同批次、不同模型版本仍可能给出不同边界，索引需要版本号，重建时必须整批重跑。适合的场景是高价值、低数量、结构异常的文档，例如合同、论文与手册；不适合海量网页。

### 10 块大小与重叠的权衡

块大小的选择取决于查询类型与证据长度。下表给出一组常用工作点及其性质，数值为经验范围，实际取值需在验证集上测量。

| 块大小（token） | 检索精度 | 上下文完整性 | 索引体积 | 典型用途 |
|---|---|---|---|---|
| 64–128 | 高 | 低 | 大 | 事实型问答、FAQ、实体属性 |
| 256 | 较高 | 中 | 中 | 通用默认值 |
| 512 | 中 | 较高 | 小 | 技术文档、需要段落条件的问题 |
| 1024–2048 | 低 | 高 | 最小 | 摘要、全局问题、父子分块的父块 |

重叠的选择由证据长度决定。取 $L=256$、$n_a=40$，按下表的公式计算完整率与冗余比例。

| 重叠 $O$ | 步长 $S$ | 完整率 $P_{\text{intact}}$ | 索引冗余 $O/S$ |
|---|---|---|---|
| 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 不再提高完整率，只增加冗余。工程上应先用验证集估计证据长度分布的上四分位数，再取 $O$ 略大于该值。

### 11 元数据设计

元数据决定检索之后能否引用、过滤与重排。常用字段如下。

| 字段 | 类型 | 用途 | 注意 |
|---|---|---|---|
| `doc_id` | 字符串 | 去重与增量更新 | 全局唯一，不用文件名 |
| `source` | 字符串 | 引用与权限 | 与访问控制表对应 |
| `title_path` | 字符串 | 章节过滤、引用前缀 | 用固定分隔符连接标题栈 |
| `page` | 整数 | 引用定位 | PDF 与扫描件必需 |
| `char_start` / `char_end` | 整数 | 高亮与偏移校验 | 相对于原始文档而非块 |
| `section_type` | 枚举 | 区分正文、表格、代码、脚注 | 影响生成提示 |
| `version` | 字符串 | 索引版本 | 与分块器版本一同记录 |
| `lang` | 字符串 | 分词与嵌入模型选择 | 混合语料必需 |

设计约束有三条。过滤字段应是低基数字段，高基数字段放入负载而不建索引，否则过滤选择性差且内存占用高。页码与字符偏移必须指向原始文档，块内相对偏移在重建后会失效。父子分块中，子块元数据应复制父块的 `doc_id`、`source` 与 `title_path`，否则展开父块后无法引用。

### 12 选择决策树

下图给出从文档特征到分块策略的决策顺序。

```mermaid
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。统计包含证据的块是否进入检索前 $k$。该指标同时受分块与嵌入模型影响，用于比较端到端检索效果。

指标三为答案正确率与引用准确率。前者用人工标注或模型判定，后者统计答案引用的块是否真的包含支撑句。

实验设计采用单变量对照：固定 $L$ 改变 $O$，固定 $O$ 改变 $L$，再比较固定、递归、语义、结构四种策略。每个配置重复三次取均值，报告置信区间。分块消融的样本量建议不少于 200 个问题，否则 5 个百分点的差异无法区分。

## 关键直觉

> [!tip]
> 分块是在检索分辨率与证据完整性之间选择工作点：块越短，块向量越接近单一主题，匹配越精确，但证据跨块的概率越高；块越长则相反。重叠不改变主题分辨率，它只把边界代价从证据丢失转换为索引冗余，因此补偿的是切分误差，不补偿语义混杂。

该表述与第 2、3 节的推导对应：完整率 $P_{\text{intact}}=\min(1,(L-n_a+1)/(L-O))$ 由 $L$ 与 $O$ 控制，块内主题混合导致的余弦衰减 $\cos\approx1/\sqrt{m_s}$ 由块内句子数 $m_s$ 控制。两个量相互独立，调参时必须分别测量。

## 例子与代码

以下代码实现固定长度、递归字符与语义三种分块，并统计块数、平均长度、最短与最长长度、重叠率、覆盖率与句界完整率。运行环境为 Python 3.10 及以上、NumPy 1.24 及以上，只依赖标准库与 NumPy。

分词采用近似规则：每个汉字、每个英文单词、每个数字串、每个标点各记为一个 token。该规则用于让代码不依赖具体分词器，统计口径在同一份文档内保持一致；真实系统应替换为与生成模型相同的分词器。

```python
# 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` 以哈希词袋替代，替换该函数即可接入生产模型。第四部分统计指标，重叠率按 $\lvert c_i\cap c_{i+1}\rvert/\lvert c_{i+1}\rvert$ 计算，句界完整率统计块末尾字符是否落在句末标点或换行处。

在示例文档上运行，输出如下。

```text
文档 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% 高于配置的 $32/160=20\%$，因为重叠率的分母是下一块长度，而下一块平均只有 111 token，$32/111\approx29\%$，且部分块的下一块更短，因此实测值略高于该估算。句界完整率为 100%，因为所有块都在分隔符处结束。

语义分块产生 7 个块，最长 166，未超过 $L_{\max}=180$，最短 60，达到 $L_{\min}=50$，句界完整率 100%，重叠率为 0。它没有使用重叠却在句界处全部对齐，说明重叠与句界对齐是两种独立的边界质量控制手段：前者处理不可避免的硬切，后者从源头避免硬切。

覆盖率三者为 100%，因为块是连续窗口且未丢弃短块。若实现中加入"丢弃小于 20 token 的块"，覆盖率会低于 100%，被丢弃区间内的证据永久不可检索，这是常见的隐性指标下降来源。

把上述统计接入 [[从零实现RAG指南]] 的索引流程时，应在写入向量库前断言覆盖率等于 1，并把块数、平均长度与句界完整率写入索引清单，便于重建后对比。

## 易错点

> [!warning]
> - 用字符数代替 token 数：中文、英文与代码的字符/token 比例不同，按字符设定的 512 在英文中约为 128 token，在中文中为 512 至 1024 token，上下文预算与块数统计都会偏差。
> - 只调块大小而不调重叠：$O=0$ 时证据完整率上限为 $(L-n_a+1)/L$，把 $L$ 从 256 提到 512 只把完整率从 0.848 提到 0.924，仍低于 $L=256$、$O=51$ 的 1.0。
> - 语义分块使用固定绝对阈值：不同文档的相邻句相似度分布尺度不同，固定阈值在长文档上过度切分、在短文档上几乎不切分；应按文档分位数或验证集校准。
> - 按长度硬切表格与代码：表头与数据行分离、代码语句被截断，检索命中后生成阶段无法解析，且引用坐标指向半个语法单元。
> - 父子分块只保存子块文本：检索命中后取不到父块，或父块需要重新解析原文，延迟与失败率都会上升；必须显式保存 child 到 parent 的映射与父块文本。
> - 用平均块长评价分块质量：平均长度相同但分布不同的两种策略，检索表现可能差异很大；应同时报告最短、最长、标准差与句界完整率。

## 关联笔记

- [[RAG原理与流程]]（前置）：给出文档到答案的完整链路，本篇展开其中"文档切分为块"这一步。
- [[Embedding与向量检索]]（前置）：块是嵌入与相似度计算的对象，嵌入模型的输入长度上限直接约束块大小。
- [[检索优化与重排Rerank]]（后续）：召回阶段的候选集由块集合构成，重排只能在已召回的块内调整顺序。
- [[RAG评估]]（后续）：recall@k 与 context precision 以块为单位定义，分块变化会使历史指标不可比。
- [[从零实现RAG指南]]（后续）：把本篇的分块器接入最小 RAG 管线，并用覆盖率断言保护索引质量。

## 达标检测

- [ ] 能写出固定长度分块的块数公式，并在 $N=1000$、$L=256$、$O=0$ 时算出 $m=4$。
- [ ] 能推导证据完整率 $\min(1,(L-n_a+1)/(L-O))$，并说明 $O\ge n_a-1$ 时完整率恒为 1 的原因。
- [ ] 能运行本篇代码，把语义分块的百分位阈值从 30 改为 10，说明块数与平均长度的变化方向并给出理由。
- [ ] 能解释递归分块在本篇示例中块数多于固定分块的原因，并指出重叠率高于配置值的原因。
- [ ] 能对一份 Markdown 文档写出保留标题路径、代码围栏与表格表头的结构分块规则。
- [ ] 能识别"用字符数代替 token 数"的错误，并给出中文、英文、代码三类文本的字符/token 比例差异。
- [ ] 能为 $10^6$ token 的语料估算 $L=256$、$O=51$ 时的块数与额外索引 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》中文笔记 —— 对应分块粒度与重叠比例的工程经验总结。
