BroadRouter

RAG 分块大小与重叠:对检索效果和成本的影响

BroadNet Inference 团队 · 阅读约 7 分钟 · 发布于 · 更新于

先从约 256 到 512 token 的分块、0 到 15% 的重叠开始,并用你自己的查询调整 top-k。分块越大,每次查询发给大模型的 token 越多。重叠会让你向量化和存储的 token 乘以“大小 ÷(大小 − 重叠)”,所以 50% 的重叠会让索引翻倍。公开测试发现,小分块或无重叠的分块召回率往往不差,甚至更好。

分块大小和重叠,是每条 RAG 流水线一开始就设定、之后却很少再回头看的两个数字。它们决定你要存多少个向量、要向量化多少 token、每个问题要发给大模型多少 token,以及能不能找到正确的段落。本文先介绍公开测试的发现,再一步步算清 token 账,让你在向量化之前就能看到每种设置的成本。

如果你还在考虑要不要用 RAG,先读长上下文还是 RAG。处理阿拉伯语文档的话,请把阿拉伯语 RAG 和阿拉伯语文本规范化与本文结合起来看。

分块大小和重叠会改变什么?

  • 分块大小是你向量化和检索的每一块包含多少 token。
  • 重叠是相邻分块共享多少 token,这样在边界处被切断的句子至少会在一个分块中完整出现。
  • Top-k 是每个问题检索多少个分块。

三者共同决定了四个量:

量 公式(长文档)
存储的分块数 语料 token 数 ÷(大小 − 重叠)
向量化的 token 数 语料 token 数 × 大小 ÷(大小 − 重叠)
每次查询的上下文 top-k × 大小
每次查询的大模型输入 top-k × 大小 + 系统提示词 + 问题

前两项在每次建索引时支付一次,每次重新分块时再付一次。最后一项则在每个问题上都要付,永远如此。

关于分块大小,公开测试怎么说?

有两个公开评测值得了解,因为它们测量的东西不同。

**Chroma(Smith 与 Troynikov,2024 年 7 月)**在 token 层面衡量检索效果:相关文本被检索到了多少(召回率),以及检索到的内容中有多少是相关的。它每次检索五个分块,使用 OpenAI 的 text-embedding-3-large。部分结果:

切分器 大小(token) 重叠 召回率 IoU
Recursive 800 400 85.4% 1.5%
Token 800 400 87.9% 1.4%
Recursive 400 200 88.1% 3.3%
Recursive 400 0 89.5% 3.6%
Recursive 200 0 88.1% 6.9%

IoU(交并比)衡量检索到的文本中有多少是相关的,所以它同时也反映了浪费的 token。800/400 这两行对应 OpenAI 文件搜索的默认设置;假设使用 token 切分器,Chroma 发现这个设置的召回率略低于平均水平,其他指标则是最低的。更小、无重叠的分块召回率持平甚至更高,携带的无关文本也少得多。

**NVIDIA(2025 年 6 月)**在五个数据集上衡量端到端的回答准确率,测试了 128 到 2,048 token、15% 重叠的 token 分块,以及按页和按章节的分块。按页分块的平均准确率最高(0.648),方差也最小。最佳的 token 大小取决于问题类型:事实型数据集偏好 256 到 512 token,分析型偏好 1,024 token 或整页。128 和 2,048 这两个极端通常表现更差。

两者在一点上是一致的:不存在通用的最佳大小,而大分块加大重叠,很少是正确的默认值。

重叠会让索引膨胀多少?

每个分块向前推进“大小 − 重叠”个 token,所以索引相当于存了“大小 ÷(大小 − 重叠)”份语料。以一个 2,000,000 token、由 10,000 token 文档组成的语料为例:

大小 重叠 分块数 向量化的 token 数 膨胀倍数
200 0 10,000 2,000,000 1.00×
400 0 5,000 2,000,000 1.00×
512 77 (15%) 4,600 2,338,800 1.17×
1,024 154 (15%) 2,400 2,338,800 1.17×
800 400 (50%) 4,800 3,840,000 1.92×
400 200 (50%) 9,800 3,920,000 1.96×

短文档的膨胀稍小一些,因为每篇文档的最后一个分块是不完整的。公式给出的是上限:15% 的重叠在向量化 token、向量存储和重建索引时间上大约多花 18%,50% 的重叠则大约多花 100%。

重叠在查询时也有成本。重叠 50% 时,为同一个问题检索到的两个相邻分块有一半文本是重复的。你要为这些重复的 token 付费,而且它们还会把其他相关段落挤出 top-k。

BroadNet 不提供 embedding 服务,所以这部分账单付给你的 embedding 服务商。可以用 Embedding 成本计算器估算。

分块大小对大模型账单有什么影响?

每个问题都会发送 top-k 个分块加上提示词。假设每月 100,000 个问题,系统提示词加问题共 600 个 token,每次回答都是 300 个 token:

大小 × top-k 每次查询的上下文 每次查询的输入 每月输入
200 × 10 2,000 2,600 2.6 亿
400 × 5 2,000 2,600 2.6 亿
512 × 5 2,560 3,160 3.16 亿
800 × 5 4,000 4,600 4.6 亿
1,024 × 5 5,120 5,720 5.72 亿
1,024 × 8 8,192 8,792 8.79 亿

每一行的输出都是每月 3,000 万 token,所以只有输入在变化。按每百万 token 的价格计算,每月输入成本就是最后一列的百万数乘以该价格。在每百万输入 token $0.10 的 Gemma 4 VL 26B 上,1,024 × 8 的设置每月输入成本为 879 × $0.10,而 400 × 5 为 260 × $0.10。前者是后者的 3.4 倍,而公开测试并没有显示这种设置的召回率更好。在 Qwen3.8 27B(输入 $0.175)或 GLM 5.3(输入 $0.78)上,比例相同,总额更大。

有两个杠杆比模型价格的影响更大:

  1. **增大分块时调低 k。**200 × 10 和 400 × 5 发送的上下文相同。测试不同大小时,让每次查询的上下文大致保持不变,这样你比较的是检索质量,而不是上下文预算。
  2. **缓存固定部分。**把系统提示词放在最前面并保持逐字节不变,这样在有缓存价格的模型上,它就能按缓存输入价格计费。检索到的分块每个问题都不同,很少能命中缓存。

上下文限制也要考虑。Gemma 4 VL 26B 每次请求接受 32,768 个 token,对上表任何一行都绰绰有余。如果你把 k × 大小推到几万 token,那你已经从 RAG 走向了长上下文,那种比较有它自己的算法。RAG 分块计算器可以按你自己的语料、分块大小、重叠和 top-k 套用这些公式。

怎么按 token 分块又不切断单词?

按 token 计数,但在结构处切分。LangChain 的 RecursiveCharacterTextSplitter 用它的 length_function 计算大小,默认是字符长度。这时 512 的“大小”就是 512 个字符,英文大约相当于 100 到 150 个 token,阿拉伯语又是另一个数字,见阿拉伯语的每词 token 数。而 embedding 的限制和大模型账单都按 token 计。

下面这个分块函数把完整的段落装进 token 预算,并把末尾的段落作为重叠带到下一块。在段落边界处切分,可以避免把单词或多字节的阿拉伯语字符切断,而直接按 token 窗口切分就可能出现这种情况。

import tiktoken

enc = tiktoken.get_encoding("o200k_base")    # an estimate: count with your embedder's tokenizer
count = lambda s: len(enc.encode(s))

def chunk(text, size=512, overlap=64):
    """Pack whole paragraphs up to `size` tokens; repeat trailing paragraphs up to `overlap` tokens."""
    chunks, cur, cur_len = [], [], 0
    for para in (p.strip() for p in text.split("\n\n")):
        if not para:
            continue
        n = count(para)
        if cur and cur_len + n > size:
            chunks.append("\n\n".join(cur))
            tail, t = [], 0
            for q in reversed(cur):                  # carry the end of this chunk forward
                if t + count(q) > overlap:
                    break
                tail.insert(0, q); t += count(q)
            cur, cur_len = tail, t
        cur.append(para); cur_len += n              # a paragraph over `size` stays whole
    if cur:
        chunks.append("\n\n".join(cur))
    return chunks

def plan(corpus_tokens, size, overlap, k, queries_per_month, prompt_tokens=600):
    index_tokens = corpus_tokens * size / (size - overlap)   # long-document limit
    per_query = k * size + prompt_tokens
    return {"chunks": round(index_tokens / size), "tokens_to_embed": round(index_tokens),
            "input_per_query": per_query, "input_per_month": per_query * queries_per_month}

print(plan(2_000_000, 512, 64, 5, 100_000))
# {'chunks': 4464, 'tokens_to_embed': 2285714, 'input_per_query': 3160, 'input_per_month': 316000000}

这里的重叠是“最多”:比重叠预算更长的段落不会被重复。单个超过 size 的段落会保持完整;如果你的文档有句子结构,先把这类段落按句子切开。在每个分块前加上文档标题和章节标题,这样检索到的分块依然能说明自己讲的是什么。这样每个分块会多几个 token,但往往比重叠更有用。

怎么为你的数据选定这些数字?

  1. **建立评测集。**50 到 200 个真实问题,每个问题配上能回答它的段落。评分方法见大模型评测指南。
  2. **固定上下文预算。**比较不同大小时,让 k × 大小保持在某个值附近,比如 2,000 个 token。
  3. **试三种大小和两种重叠。**例如 256、512 和 1,024 token,各自在 0 和 15% 重叠下测试。测量正确段落在 k 以内的召回率。
  4. **试试按结构切分。**如果你的文档有页码或编号章节,就拿按页或按章节的分块和各种 token 大小比一比。NVIDIA 发现按页分块最稳定。
  5. **在召回率与最佳值相差一两个百分点以内的设置中,选最便宜的那个,**然后用月度成本估算方法按你的查询量算出价格。

先在样本上完成这些,再对全部语料做向量化。以后再改分块方案,就意味着所有内容都要重新向量化。

BroadNet Inference 适合什么场景

BroadNet Inference 负责 RAG 的回答环节,而不是检索。它不提供 embedding 或向量存储,所以请搭配你选择的 embedding 服务商和向量数据库。在回答环节,Gemma 4 VL 26B 是低成本选项,可以用 $5 的初始额度运行。Qwen3.8 27B(262,144 token 上下文)和 GLM 5.3(1,048,576)适合更大的 top-k 或长文档,需要先充值。提示词和检索到的段落在请求结束后不会被保留。如果你的语料足够小且稳定,放得进上下文窗口,那么长上下文可能比分块更合适。

常见问题

RAG 的分块大小设多少合适?

从 256 到 512 token 左右开始测试。Chroma 的评测发现,200 到 400 token、无重叠的效果很好。NVIDIA 发现,256 到 512 token 适合事实型问题,而分析型问题用 1,024 token 或整页的分块效果更好。

分块重叠应该设多少?

比大多数默认值更少。NVIDIA 在一个数据集上试了 10%、15% 和 20%,发现 15% 最好。Chroma 发现无重叠的设置往往得分持平甚至更高。重叠每多一点,要向量化、存储和发送的 token 就多一点。

分块越大,成本越高吗?

在没有重叠的情况下,向量化的成本不会更高:语料的 token 数是一样的。但每次查询的成本更高,因为每个检索到的分块更长,top-k × 分块大小随之增长。增大分块时要调低 k。

分块大小是按 token 还是按字符计算的?

取决于切分器。LangChain 的 RecursiveCharacterTextSplitter 用它的 length_function 计算,默认是字符长度。而 embedding 的限制和大模型的账单都按 token 计,所以要传入一个 token 计数函数。

改了分块大小,需要重新向量化吗?

需要。新的边界产生新的分块,每个分块都需要新的向量。重新向量化相当于把整个索引的成本再付一遍,所以要先在样本上定好分块方案,再对全部语料做向量化。

以 Markdown 格式阅读问 ChatGPT问 Claude问 Perplexity