分块策略：如何把一桌文档大餐优雅分盘上桌？

可视化演示

展示滑动窗口固定分块、语义分块嵌入相似度切分及四种策略性能对比，揭示分块粒度与检索质量的权衡关系。

1. 为什么需要分块

你雇的帮厨从菜市场回来，把一整头牛放在案板上，问：“老板，直接下锅吗？”你当然会摇头。客人点的是“青椒牛柳”，不是“整牛火锅”。于是帮厨把牛按部位拆解：牛里脊切条、牛腩切块、牛骨熬汤，每一份恰好服务一道菜。

RAG 系统的“厨房”也遵循同样的逻辑。知识库接收文档时，如果整篇存进去，检索时每一轮都要把整篇文档与用户问题做比对。这不仅慢，而且返回的“答案食材”里掺杂了大量无关部位——客人想要牛柳，你端上来一头牛。所以，系统先把文档切成语义相对独立的片段，这些片段被称为块（chunk），每个块才是后续检索的最小单元。

块的大小直接影响两道工序：一是检索（query 与块的匹配），二是生成（把检索到的块喂给大模型）。块太小，一个完整观点被切成碎片，检索到的内容只有“半个证据”；块太大，噪音淹没重点。工程上通常用一个简单公式估算分块数量：

回到厨房场景：分块就像备菜的分寸拿捏。切得太粗，客人找不到想要的部位；切得太细，一炒就碎。理解了这个道理，我们才能继续看不同“刀法”——不同的分块策略，如何各显神通。

2. 语义分块原理：看纹理下刀

经验丰富的帮厨绝不闭着眼睛乱切。他拿刀前先观察纹理：牛肉的纹路顺着纤维走，南瓜的质地从皮到瓤渐变。纹理相近的地方一切到底，纹理突然断裂的地方才落刀——这样切出来的每块食材，都自带完整“身份”。

语义分块（Semantic Chunking）就是这种“看纹理下刀”的工程实现。它先把文档按句子拆开，再让每个句子通过一个嵌入模型变成一组数字，这组数字就是句子的“纹理坐标”，也叫向量。随后计算相邻两个句子向量的相似度：相似度高，说明两句话还在聊同一个话题；相似度突然跌到低谷，说明话题切换了——这里就是切分点。

实际操作时，相似度通常用余弦相似度计算：

语义分块的产出是“话题完整”的块：边界和自然语义对齐，检索时容易精准命中。缺点是每个句子都要做一次向量计算，成本比“尺子切法”高得多。帮厨看纹理下刀虽然慢，但端出来的每道菜都完整——这就是语义分块的独特价值。

3. 固定窗口法：尺子切菜

如果今天你请的帮厨是位临时工，他不想观察纹理，也不想算相似度。他直接拿出一把尺子，在长条案板上每隔10厘米“咔”一刀。整根胡萝卜、整条茄子全切成等长的小段，快速利落。

固定窗口分块（Fixed-size Chunking）就是这把“尺子”。它设定一个固定长度 K（比如 512 个 token 或 200 个字符），从文档开头每 K 个长度切一刀，不考虑句子、段落或语义。优点是极简单：不需要任何模型，速度最快，代码只有几行。对日志、结构化表格、代码仓库这类天然等长的文本，它完全够用。

但它有显而易见的短板：可能把一句话拦腰斩断，把一段完整的论证拆成两半。此时可用窗口遍历公式估算块数：

尺子切菜确实省事，但代价是切坏纹理：一句话可能被切成两半，就像把三文鱼腹部的花纹拦腰切断。所以它只适合“标准化食材”，遇到讲究语义的文档就要换更聪明的刀法。

4. 滑动窗口法：切蛋糕的重叠刀法

过生日切蛋糕时，你会让每一刀都和上一刀稍微重叠一点吗？其实不用。但如果你不是一次性切完，而是“边切边分给客人”，重叠刀法就有用了：每一刀都从上一刀边缘往后挪一段，让每一块蛋糕都带上一点上一块的花边——这样无论奶油花纹在哪里，每块都能分到完整的一层。

滑动窗口分块（Sliding Window Chunking）借鉴了这种重叠智慧。它仍使用固定窗口大小 K，但每次滑动距离 S 小于 K。于是相邻两个块之间有一段重复内容，称为重叠区。这段重叠让跨块上下文得以保留：上一块的结尾结论，会在下一块的开头再次出现，检索时无论命中哪一块，上下文都相对完整。

重叠的程度用重叠率 r 表示，步长与重叠率的关系是：

滑动窗口是“上下文连续性”与“存储效率”的折中。重叠太多，知识库膨胀、检索返回重复；重叠太少，连续性问题依旧。就像切蛋糕：刀刀重叠才能保住花纹，但每刀都切在同一个地方，那就永远切不出蛋糕了。

5. 递归分块法：冰箱分层收纳

整理冰箱时，最高效的思路是分层收纳：冷藏区放蔬菜、冷冻区放肉类；每个区里再用保鲜盒把牛肉、猪肉分开；如果牛肉还要细分，就再贴上标签“牛里脊”“牛腩”。这种“先分大类、再分小类”的结构化方法，就是递归分块（Recursive Chunking）的灵魂。

递归分块先按照文档的原生结构——章节、小节、段落、句子——构建一棵“文本树”。树的根是整篇文档，向下逐层展开到段落甚至句子。切分时“自顶向下”：先把文档按章切开，再把每章按节切开，直到达到目标粒度。每一层都提供不同粒度的块：上层适合概括型检索，下层适合精确型定位。

如果每层固定分成 b 个孩子，树的深度为 d，那么最终叶子块的数量是：

冰箱分层让你从“找肉”变成“先开冷冻区、再拿左边盒子”，检索也可以“先走上层再下钻”：用上层块判断方向，再顺着树往下找具体内容，效率和精确兼得。

6. Agentic 分块：看单下刀的主厨

前几种刀法都遵循固定的规则，有经验的主厨却会“看单下刀”：客人点了寿喜锅，三文鱼切厚片；客人点了刺身，三文鱼切薄片；客人对鱼过敏，他直接换菜。Agentic 分块就是把这种“临场判断力”交给 AI 的技术。

Agentic 分块的核心是让大语言模型（LLM）充当帮厨。它先阅读文档的标题、章节名、段落大意和当前任务描述（比如“做一个政策条款问答系统”），然后自主决定：这篇文章要不要分层？哪些地方按语义切？哪一段值得整块保留？它甚至可以混合多种策略——前半篇用递归分块，中间某段用语义分块。

从数学视角看，LLM 是在候选策略集合中做选择，目标是最大化最终的检索质量：

看单下刀的主厨让每道菜都恰到好处，但主厨很贵、也慢。Agentic 分块同样如此：它能实现最灵活的分块方案，但每次决策都要调用 LLM，适合对检索质量要求高、知识库规模可控的场景。

7. 粒度权衡调参：厚薄之间找平衡

涮火锅的羊肉片要薄，红烧肉的块要厚，回锅肉要切得厚薄适中。没人会说“肉切得越薄越好”或“越厚越好”，一切要看菜式。分块粒度（chunk size）也是同一个道理：没有绝对最优，只有任务匹配。

粒度影响最核心的两个指标是召回率（Recalled relevant chunks / total relevant chunks）和准确率（Relevant retrieved chunks / total retrieved chunks）。细粒度块小、主题单一，检索时容易精确命中目标内容，所以召回率高；但块太短，上下文信息不足，生成阶段可能答得“没头没尾”。

粗粒度块上下文丰富，大模型能充分理解语境，但块内噪声多，可能把不相关的内容一起带给大模型，拉低准确率。两者常被合成一个综合指标 F1：

厚薄合适才好吃。分块大小没有标准答案，但有调参法则：先跑基线、再看指标、再微调。你的任务是决定这盘“菜”要什么口感，而不是执着于最流行的那把刀。

8. 实践评估应用：用指标检验刀法

再好的刀法都要拿到真实宴席上验证。客人觉得好吃，菜才算成立；分块策略同样要在真实检索任务中接受检验。评估标准不是“切得整齐”，而是“检索质量好不好”。

实践一般分三步。第一步，选择基线：先跑固定窗口与滑动窗口，得到最基本的召回与准确率。第二步，对比升级：换成语义分块或递归分块，看是否带来显著提升。第三步，任务适配：政策评估类项目需要去查“某一具体条款”，就用细粒度语义分块；医学研究要跨段落阅读完整证据链，就用滑动窗口+重叠；商业情报要同时回答宏观和微观问题，就上 Agentic 混合策略。

评估时可把多个指标加权成一个综合分：

一场宴席检验刀法，一次评估检验策略。分块不是为了切得好看，而是为了让大模型“厨师”最终端出的答案让用户满意。掌握了这套评估方法，你就能在真实项目中从容地选择、比较、迭代你的分块策略。

AI 应用场景

Python 演示

# -*- coding: utf-8 -*-"""演示三种常见分块策略：固定窗口、滑动窗口、语义分块。使用词袋重合度近似语义相似度，避免依赖外部库。"""import re  def split_sentences(text):    """按中英文句号、感叹号、问号拆分句子。"""    parts = re.split(r'[。！？!?]', text)    return [p.strip() for p in parts if p.strip()]  def tokenize(text):    """简易分词：保留中文字符和英文单词。"""    return re.findall(r'[\u4e00-\u9fa5]|[a-zA-Z]+', text.lower())  def jaccard_sim(sent_a, sent_b):    """用 Jaccard 相似度近似句子语义相似度。"""    set_a, set_b = set(tokenize(sent_a)), set(tokenize(sent_b))    if not set_a or not set_b:        return 0.0    return len(set_a & set_b) / len(set_a | set_b)  class FixedWindowChunker:    """固定窗口分块：每 chunk 固定字符长度。"""     def __init__(self, chunk_size=100):        self.chunk_size = chunk_size     def chunk(self, text):        return [text[i:i + self.chunk_size]                for i in range(0, len(text), self.chunk_size)]  class SlidingWindowChunker:    """滑动窗口分块：固定长度 + 前向重叠。"""     def __init__(self, chunk_size=100, overlap_ratio=0.2):        self.chunk_size = chunk_size        self.step = max(1, int(chunk_size * (1 - overlap_ratio)))     def chunk(self, text):        chunks = []        start = 0        while start < len(text):            chunks.append(text[start:start + self.chunk_size])            start += self.step        return chunks  class SemanticChunker:    """语义分块：句子嵌入相似度低处切分。"""     def __init__(self, threshold=0.25):        self.threshold = threshold     def chunk(self, text):        sents = split_sentences(text)        if len(sents) <= 1:            return [text]        merged = [sents[0]]        for i in range(1, len(sents)):            sim = jaccard_sim(sents[i - 1], sents[i])            if sim < self.threshold:                merged.append('\n--- 语义分块 ---\n')            merged.append(sents[i])        chunks = []        cur_chunk = []        for part in merged:            if part == '\n--- 语义分块 ---\n':                if cur_chunk:                    chunks.append('。'.join(cur_chunk))                    cur_chunk = []            else:                cur_chunk.append(part)        if cur_chunk:            chunks.append('。'.join(cur_chunk))        return chunks  def main():    text = (        '语义分块与滑动窗口是RAG系统的关键策略。'        '它们决定知识库如何被检索。'        '语义分块依赖句子向量之间的相似度。'        '相似度突然下降的地方就是切分点。'        '滑动窗口则关注上下文连续性。'        '每一刀都与上一刀有部分重叠。'        '固定窗口实现最简单。'        '但可能会切断重要的语义信息。'    )    print('原始文档长度:', len(text))    print('\n=== 固定窗口(60字) ===')    for i, c in enumerate(FixedWindowChunker(60).chunk(text)):        print(f'[{i}] {c}')    print('\n=== 滑动窗口(60字, 20%重叠) ===')    for i, c in enumerate(SlidingWindowChunker(60, 0.2).chunk(text)):        print(f'[{i}] {c}')    print('\n=== 语义分块(阈值0.25) ===')    for i, c in enumerate(SemanticChunker(0.25).chunk(text)):        print(f'[{i}] {c}')  if __name__ == '__main__':    main()

1. self.step = max(1, int(chunk_size * (1 - overlap_ratio)))用重叠率算步长，重叠越多，步长越小，切出的相邻块共享内容越多。
2. chunks.append(text[start:start + self.chunk_size])每次都从 start 处切一个固定长度的窗口，模拟“蛋糕刀法”。
3. sim = jaccard_sim(sents[i - 1], sents[i])用 Jaccard 相似度近似句子语义距离，不需要外部向量模型。
4. if sim < self.threshold:相似度低于阈值，说明话题断裂，插入分块标记。
5. for i, c in enumerate(FixedWindowChunker(60).chunk(text)):逐个打印每个块的编号和内容，方便肉眼对比三种策略的差异。

常见误区

面试题