返回专栏
· 24 分钟阅读

文本切片 Chunking 策略:从文档分块到高质量 RAG 检索的核心技术


一、什么是 Chunking?

Chunking(文本切片)是指将较长的文档按照一定规则拆分为多个较小的文本单元,使其能够被独立处理、向量化、存储和检索。

在 RAG 系统中,Embedding 模型通常有输入长度限制,而用户查询往往只需要文档中的一小部分内容。因此,需要先将完整文档拆分为适合检索的片段。

例如,原始文档:

Transformer 是一种基于注意力机制的神经网络架构。

它由 Encoder 和 Decoder 等组件构成。
Self-Attention 用于建立不同 Token 之间的关系。
FFN 用于对每个位置的表示进行非线性变换。

Transformer 已广泛应用于自然语言处理和多模态模型。

切片后:

Chunk 1:
Transformer 是一种基于注意力机制的神经网络架构。

Chunk 2:
它由 Encoder 和 Decoder 等组件构成。
Self-Attention 用于建立不同 Token 之间的关系。

Chunk 3:
FFN 用于对每个位置的表示进行非线性变换。
Transformer 已广泛应用于自然语言处理和多模态模型。

每个 Chunk 都可以独立生成 Embedding,并保存到向量数据库中。

1.1 Chunking 在 RAG 中的位置

Chunking 位于文档解析之后、Embedding 之前,是知识入库的重要环节。

flowchart TD
    A["原始文档"] --> B["文档解析"]
    B --> C["结构化文本"]
    C --> D["Chunking 文本切片"]
    D --> E["Embedding 向量化"]
    E --> F["向量数据库"]
    F --> G["检索相关 Chunk"]
    G --> H["上下文构建"]
    H --> I["大模型生成答案"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#E5EAF8,stroke:#9AA8D2,color:#3F4F7A
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#E5F0E9,stroke:#83A995,color:#315D49
    style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F

Chunking 不只是文本长度控制,还涉及知识边界、语义完整性、上下文继承和检索粒度等问题。

二、为什么 Chunking 如此重要?

切片策略会直接影响 RAG 的检索质量。

同一份文档,使用不同的切片方式,可能得到完全不同的检索结果。

2.1 切片过大

假设一个 Chunk 包含 3000 个 Token。

优点:

  • 保留较多上下文。
  • 章节内容相对完整。
  • 不容易丢失跨句关系。

缺点:

  • Embedding 需要概括更多主题。
  • 无关内容可能稀释目标语义。
  • 检索命中后会带入大量无关文本。
  • 上下文窗口消耗较大。
  • 精确定位知识片段较困难。

例如,用户询问:

Redis 的默认端口是多少?

如果一个 Chunk 同时包含 Redis 的安装、配置、持久化、集群和性能优化内容,那么其向量可能无法充分突出默认端口这一局部信息。

2.2 切片过小

假设一个 Chunk 只有 30 个 Token。

优点:

  • 内容聚焦。
  • 检索粒度较细。
  • 无关内容较少。
  • 更容易定位具体知识。

缺点:

  • 可能丢失必要上下文。
  • 主语和指代关系容易断裂。
  • 表格和代码容易被拆散。
  • 单独的片段可能无法表达完整事实。
  • 检索需要更多 Chunk 才能还原完整信息。

例如:

Chunk 1:
Redis 是一种内存数据结构存储系统。

Chunk 2:
默认端口为 6379。

当用户询问默认端口时,Chunk 2 虽然包含答案,却没有明确说明这个端口属于 Redis。

如果只检索到 Chunk 2,模型可能无法准确判断它对应的对象。

2.3 Chunking 的核心权衡

切片策略需要在多个目标之间取得平衡。

目标 切片过大 切片过小
语义完整性 较容易保留 容易丢失
检索精度 可能被无关内容稀释 通常更聚焦
上下文完整性 较好 可能不足
检索定位 粒度较粗 粒度较细
Token 成本 单个结果较高 可能需要更多结果
索引规模 相对较小 相对较大

需要明确:不存在适用于所有知识库的最佳 Chunk Size。

最优切片粒度取决于文档结构、Embedding 模型、查询类型、检索策略和生成上下文预算。

三、Chunking 的核心参数

Chunking 通常涉及多个参数,不应只关注 Chunk Size。

3.1 Chunk Size

Chunk Size 表示单个切片的目标长度。

常见单位:

  • Character:字符数。
  • Word:单词数。
  • Token:模型 Token 数。
  • Sentence:句子数量。
  • Paragraph:段落数量。

在大模型应用中,通常更推荐使用 Token 作为长度单位。

原因:

  1. Embedding 模型通常具有 Token 输入限制。
  2. LLM 的上下文窗口以 Token 计算。
  3. 中英文字符数与 Token 数之间不存在固定换算比例。
  4. 代码、数字和特殊符号可能产生不同的 Token 数量。

常见实验区间:

场景 初始测试范围
FAQ 与短问答 100~300 Tokens
普通知识文档 300~600 Tokens
技术文档 400~800 Tokens
复杂章节内容 600~1200 Tokens
长篇分析与报告 800~1500 Tokens

这些只是实验起点,不是通用标准。最终应以目标 Embedding 模型的限制、实际检索效果和生成成本为准。

3.2 Chunk Overlap

Overlap 表示相邻 Chunk 之间重复保留的文本长度。

例如:

  • Chunk Size:500 Tokens。
  • Overlap:100 Tokens。

相邻切片将共享约 100 Tokens 的内容。

原始文本:
[A B C D E F G H I J]

Chunk 1:
[A B C D E]

Chunk 2:
[D E F G H]

Chunk 3:
[G H I J]

这里使用字符或片段示意重叠关系,实际系统通常按照 Token 数或文本边界计算。

Overlap 的主要作用:

  • 减少切片边界处的信息丢失。
  • 保留跨边界句子的上下文。
  • 提高边界附近知识的召回概率。
  • 缓解实体和关系被拆开的情况。

但 Overlap 也会产生副作用:

  • 重复存储内容。
  • 增加 Embedding 调用量。
  • 增加向量数据库容量。
  • 检索结果可能出现重复片段。
  • 上下文拼接时可能重复输入相同内容。

因此,Overlap 不是越大越好。

3.3 Overlap 比例

可以定义:

R_{overlap}=\frac{O}{S}

其中:

  • O:Overlap 长度。
  • S:Chunk Size。

例如:

S=500,\quad O=100

则:

R_{overlap}=20\%

对于连续、结构稳定的文本,可以从较低重叠比例开始测试;对于跨句依赖明显的内容,可以适当增加重叠。

但对于已经按照完整章节、表格或语义边界切分的内容,可能不需要较大的固定 Overlap。

3.4 Chunk 数量与存储开销

假设:

  • 文档总长度为 N Tokens。
  • Chunk Size 为 S。
  • Overlap 为 O。

对于固定长度、固定步长切片,步长为:

Stride=S-O

当 N>S 时,Chunk 数量近似为:

K=\left\lceil\frac{N-S}{S-O}\right\rceil+1

当 N\leq S 时:

K=1

例如:

N=10000,\quad S=500,\quad O=100

则:

K=\left\lceil\frac{10000-500}{400}\right\rceil+1=25

如果不使用 Overlap:

K=\left\lceil\frac{10000}{500}\right\rceil=20

可以看到,Overlap 会增加 Chunk 数量,进而增加向量存储和检索开销。

这里的公式适用于固定长度切片的估算。实际语义切片可能因段落长度和边界调整而产生不同数量。

四、常见 Chunking 策略

Chunking 有多种实现方式,不同策略适合不同类型的文档。

4.1 固定长度切片(Fixed-size Chunking)

固定长度切片是最简单的策略。

按照预设长度将文本连续拆分,每个 Chunk 尽量保持相同长度。

例如:

原始文本:
A B C D E F G H I J K L

Chunk Size = 4
Overlap = 0

Chunk 1:
A B C D

Chunk 2:
E F G H

Chunk 3:
I J K L

实现逻辑:

def fixed_chunk(text, chunk_size=500, overlap=0):
    if chunk_size <= 0:
        raise ValueError("chunk_size must be positive")

    if overlap < 0 or overlap >= chunk_size:
        raise ValueError("overlap must be >= 0 and < chunk_size")

    chunks = []
    stride = chunk_size - overlap

    for start in range(0, len(text), stride):
        chunk = text[start:start + chunk_size]

        if chunk:
            chunks.append(chunk)

        if start + chunk_size >= len(text):
            break

    return chunks

以上代码按照字符长度切片,用于说明算法逻辑。生产环境应使用目标模型对应的 Tokenizer 计算 Token 长度。

优点:

  • 实现简单。
  • 处理速度快。
  • 长度容易控制。
  • 适合批量处理。
  • 参数容易调节。

缺点:

  • 容易切断句子。
  • 可能拆分段落。
  • 可能破坏代码和表格。
  • 无法理解文档语义结构。

适用场景:

  • 纯文本。
  • 结构简单的日志。
  • 大规模文本预处理。
  • 对切片速度要求较高的场景。

4.2 递归字符切片(Recursive Character Chunking)

递归切片会优先尝试较大的文本边界,只有当前边界无法满足长度限制时,才继续使用更细粒度的分隔符。

常见分隔符优先级:

段落分隔符
    ↓
换行符
    ↓
句子分隔符
    ↓
空格
    ↓
字符

典型策略:

  1. 优先按照段落切分。
  2. 如果段落仍然过长,再按照句子切分。
  3. 如果句子仍然过长,再按照更细的文本边界切分。
  4. 最终确保切片长度符合限制。

示意:

flowchart TD
    A["输入长文本"] --> B["按段落分割"]
    B --> C{"片段是否超长"}
    C -->|"否"| D["保留当前片段"]
    C -->|"是"| E["按句子分割"]
    E --> F{"片段是否超长"}
    F -->|"否"| G["保留句子片段"]
    F -->|"是"| H["按空格或字符继续分割"]
    H --> I["检查长度限制"]
    I --> J["输出 Chunk"]
    D --> J
    G --> J

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#E5EAF8,stroke:#9AA8D2,color:#3F4F7A
    style I fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F

优点:

  • 尽量保留自然语言边界。
  • 比固定长度切片更符合文本结构。
  • 实现相对简单。
  • 可以兼容不同长度的段落。

缺点:

  • 依赖分隔符质量。
  • 对复杂文档结构理解有限。
  • 超长表格、代码块和特殊格式仍需要专门处理。
  • 不保证切片具有完整语义。

适用场景:

  • 普通知识文档。
  • 技术文章。
  • Markdown 文档。
  • 结构相对清晰的长文本。

4.3 句子切片(Sentence-based Chunking)

句子切片按照句子边界组织文本。

与固定长度切片不同,它尽量不从句子中间切断内容。

例如:

原始文本:

Redis 是一种内存数据结构存储系统。
它支持字符串、哈希、列表和集合等数据类型。
Redis 常用于缓存、消息队列和实时数据处理。

可以按照句子数量或 Token 预算组合:

Chunk 1:
Redis 是一种内存数据结构存储系统。
它支持字符串、哈希、列表和集合等数据类型。

Chunk 2:
Redis 常用于缓存、消息队列和实时数据处理。

优点:

  • 句子相对完整。
  • 适合问答型文本。
  • 不容易破坏局部语义。

缺点:

  • 句子长度差异较大。
  • 单个超长句子可能超过模型限制。
  • 句子之间可能存在较强的跨句依赖。
  • 依赖准确的句子边界识别。

中文需要特别注意:

  • 句号。
  • 问号。
  • 感叹号。
  • 分号。
  • 引号内部的标点。
  • 缩写和数字中的点号。

简单使用句号切分,可能破坏代码、英文缩写和复杂标点结构。

适用场景:

  • FAQ。
  • 短知识条目。
  • 以单句事实为主的语料。
  • 对边界完整性要求较高的文本。

4.4 段落切片(Paragraph-based Chunking)

段落切片按照原文段落边界组织内容。

一个段落通常围绕一个相对完整的主题展开,因此天然具有一定的语义完整性。

例如:

第一段:
Redis 是一种开源的内存数据结构存储系统,
支持多种数据结构。

第二段:
Redis 常用于缓存、消息队列和实时数据处理,
具有较高的读写性能。

可以将每个段落作为一个 Chunk,也可以在多个短段落之间进行组合。

优点:

  • 保留原文组织结构。
  • 减少句子之间的语义断裂。
  • 实现成本较低。
  • 适合文档型知识库。

缺点:

  • 段落长度可能差异较大。
  • 一个段落可能包含多个主题。
  • 某些文档的段落划分质量较差。

实际工程中,经常将段落切片与最大 Token 长度结合使用:

  • 短段落:合并相邻段落。
  • 合适长度段落:直接作为 Chunk。
  • 超长段落:继续递归切分。

4.5 语义切片(Semantic Chunking)

语义切片根据文本语义变化决定切片边界,而不是只依赖字符数、句子数或段落数。

核心思想:

如果相邻文本表达的是同一个主题,则倾向于放在同一个 Chunk 中;如果主题发生明显变化,则考虑在边界处切分。

典型处理过程:

flowchart TD
    A["输入文档"] --> B["句子切分"]
    B --> C["生成句子 Embedding"]
    C --> D["计算相邻句子相似度"]
    D --> E["识别语义变化点"]
    E --> F["结合长度约束"]
    F --> G["生成语义 Chunk"]
    G --> H["检查完整性"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#E5EAF8,stroke:#9AA8D2,color:#3F4F7A
    style D fill:#E5EAF8,stroke:#9AA8D2,color:#3F4F7A
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D

一种常见实现方式:

第一步:句子切分

将文档转换为句子序列:

S=\{s_1,s_2,\ldots,s_n\}

第二步:生成句子向量

使用 Embedding 模型得到:

E=\{e_1,e_2,\ldots,e_n\}

其中:

e_i=Embedding(s_i)

第三步:计算相邻句子相似度

使用余弦相似度:

Sim(e_i,e_{i+1})= \frac{e_i\cdot e_{i+1}} {\|e_i\|\|e_{i+1}\|}

第四步:识别语义边界

如果相邻句子的语义相似度明显降低,则可能意味着主题发生变化。

例如:

句子 1:Redis 是一种内存数据结构存储系统。
句子 2:Redis 支持字符串、列表和哈希等数据结构。
句子 3:Redis 常用于缓存场景。
句子 4:Transformer 使用 Self-Attention 建模上下文关系。

句子 1~3 主题一致,句子 4 转向另一个主题,可以考虑在句子 3 和句子 4 之间切分。

优点:

  • 更符合主题边界。
  • 可以减少跨主题混合。
  • 对内容结构不规则的文本有帮助。

缺点:

  • 需要额外生成句子 Embedding。
  • 计算成本更高。
  • 相似度阈值需要调节。
  • 相邻句子相似度不一定能够准确表示主题边界。
  • 可能将具有因果关系的内容错误拆开。

需要注意:语义相似度只是切片边界的一个信号,不是完整的语义理解。定义、例子、反例和结论之间可能存在较低的局部相似度,却仍属于同一个知识单元。

因此,语义切片通常还需要结合章节结构、段落边界和最大长度约束。

4.6 结构化切片(Structure-aware Chunking)

结构化切片根据文档本身的结构进行切分。

例如:

  • Markdown:按照标题层级切分。
  • HTML:按照 DOM 结构切分。
  • PDF:按照版面和章节切分。
  • Word:按照标题、段落和表格切分。
  • 代码:按照函数、类和模块切分。
  • 技术手册:按照章节、步骤和参数说明切分。

例如 Markdown:

# Redis

## 一、基本概念

Redis 是一种开源的内存数据结构存储系统。

## 二、数据类型

### 2.1 String

String 是 Redis 最基本的数据类型。

### 2.2 Hash

Hash 用于存储字段和值的映射关系。

可以生成:

Chunk 1:
Redis
一、基本概念
Redis 是一种开源的内存数据结构存储系统。

Chunk 2:
Redis
二、数据类型
2.1 String
String 是 Redis 最基本的数据类型。

Chunk 3:
Redis
二、数据类型
2.2 Hash
Hash 用于存储字段和值的映射关系。

这里的 Chunk 不仅保留正文,还继承了所属章节路径。

例如:

{
  "chunk_id": "chunk_001",
  "text": "String 是 Redis 最基本的数据类型。",
  "metadata": {
    "document_title": "Redis",
    "section_path": [
      "Redis",
      "二、数据类型",
      "2.1 String"
    ]
  }
}

优点:

  • 保留文档层级。
  • 便于检索时恢复上下文。
  • 适合技术文档和知识手册。
  • 能够更好地处理表格、代码和列表。

缺点:

  • 需要可靠的文档解析结果。
  • 不同文档格式需要不同解析逻辑。
  • 文档结构异常时可能影响切片质量。

对于企业知识库和技术知识库,结构化切片通常是非常值得优先考虑的策略。

五、进阶切片策略

除了基础切片方式,还有一些针对复杂检索场景设计的高级策略。

5.1 Parent-Child Chunking

Parent-Child Chunking 是一种父子切片策略。

它将文档组织为不同粒度的知识单元:

  • Parent Chunk:较大的父级文本块,保留完整上下文。
  • Child Chunk:较小的子级文本块,负责精确检索。

例如:

Parent Chunk:
Redis 数据类型

    Child 1:
    String 是 Redis 最基本的数据类型。

    Child 2:
    Hash 用于存储字段和值的映射关系。

    Child 3:
    List 是一个有序的字符串列表。

检索时优先匹配 Child Chunk,生成答案时可以返回对应 Parent Chunk。

flowchart TD
    A["完整文档"] --> B["Parent Chunk"]
    B --> C["Child Chunk 1"]
    B --> D["Child Chunk 2"]
    B --> E["Child Chunk 3"]
    C --> F["Embedding"]
    D --> F
    E --> F
    F --> G["向量检索"]
    G --> H["命中 Child"]
    H --> I["定位 Parent"]
    I --> J["返回完整上下文"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#E5EAF8,stroke:#9AA8D2,color:#3F4F7A
    style D fill:#E5EAF8,stroke:#9AA8D2,color:#3F4F7A
    style E fill:#E5EAF8,stroke:#9AA8D2,color:#3F4F7A
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F

这种方式解决了一个核心矛盾:

检索需要较小的粒度,生成需要足够的上下文。

优点:

  • 提高局部检索精度。
  • 保留父级上下文。
  • 减少小片段缺少主语的问题。
  • 支持多层级知识组织。

缺点:

  • 需要维护父子关系。
  • 检索后需要额外查询 Parent。
  • 返回父级内容可能增加 Token 消耗。
  • 父级过大仍可能带入无关内容。

实际系统还可以采用多层结构:

Document
    ↓
Section
    ↓
Parent Chunk
    ↓
Child Chunk

检索命中最小粒度的知识单元,再根据任务决定返回哪一层上下文。

5.2 Small-to-Big Retrieval

Small-to-Big Retrieval 与 Parent-Child 思想相近,但更强调检索粒度和上下文扩展策略。

基本过程:

  1. 使用较小的 Chunk 进行检索。
  2. 获取命中的片段位置。
  3. 根据片段位置扩展相邻文本。
  4. 组合成较大的上下文。
  5. 将扩展后的上下文提供给模型。

例如:

原始文档:

Chunk 1:Redis 的基本概念。
Chunk 2:Redis 的数据类型。
Chunk 3:Redis 的持久化机制。
Chunk 4:Redis 的高可用机制。

检索命中 Chunk 3 后,可以根据业务需要同时获取 Chunk 2 和 Chunk 4。

这种方式不要求预先建立严格的父子树,也可以根据文档顺序、章节路径和相邻位置进行动态扩展。

注意:扩展范围需要受 Token 预算约束,不能无条件返回整章内容。

5.3 Agentic Chunking

Agentic Chunking 使用大语言模型辅助判断文本切片边界。

与传统规则切片不同,它尝试理解:

  • 当前段落讨论什么。
  • 哪些句子属于同一主题。
  • 哪些内容应该保持在一起。
  • 哪些信息具有独立检索价值。

例如,输入:

Redis 是一种内存数据结构存储系统。
它支持 String、Hash、List 等数据类型。
Redis 常用于缓存场景。
Redis 也支持 RDB 和 AOF 持久化。

模型可能将其组织为:

Chunk 1:Redis 的定义与数据类型。
Chunk 2:Redis 的典型应用场景。
Chunk 3:Redis 的持久化机制。

优点:

  • 能利用语言模型理解复杂语义。
  • 对结构不规则的文档具有灵活性。
  • 可以结合领域规则定义知识边界。

缺点:

  • 模型调用成本较高。
  • 切片结果可能存在不稳定性。
  • 容易受到 Prompt 设计影响。
  • 需要额外的质量评估。
  • 大规模处理时吞吐量可能受限。

Agentic Chunking 并不意味着每个 Chunk 都必须由 Agent 决定。生产系统可以只对复杂、低质量或结构异常的文档启用模型辅助切片。

5.4 Late Chunking

Late Chunking 是一种与传统切片顺序不同的技术思路。

传统流程:

完整文本
    ↓
先切片
    ↓
每个 Chunk 独立 Embedding

Late Chunking 的核心思路是:

先对较长上下文进行模型编码,再根据 Token 级隐藏表示构建各个 Chunk 的向量。

概念流程:

flowchart TD
    A["完整长文本"] --> B["Tokenizer"]
    B --> C["长上下文编码"]
    C --> D["Token 级隐藏表示"]
    D --> E["根据 Chunk 边界分组"]
    E --> F["对组内 Token 表示池化"]
    F --> G["生成 Chunk Embedding"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#E5EAF8,stroke:#9AA8D2,color:#3F4F7A
    style D fill:#E5EAF8,stroke:#9AA8D2,color:#3F4F7A
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F

设模型对完整文本产生 Token 级隐藏表示:

H=[h_1,h_2,\ldots,h_n]

某个 Chunk 对应 Token 范围:

C_i=[a_i,b_i]

可以通过池化生成 Chunk 向量:

e_i=Pool(h_{a_i},\ldots,h_{b_i})

常见的池化方式包括 Mean Pooling 等,具体方式取决于 Embedding 模型的实现要求。

与传统独立切片相比,Late Chunking 可以让 Chunk 的向量表示利用更广泛的上下文信息,从而缓解某些片段缺少主语和上下文的问题。

但需要注意:

  • 模型必须支持足够长的上下文编码。
  • Token 级隐藏状态必须能够被正确获取。
  • 池化方式需要与模型训练方式兼容。
  • 不能简单将任意生成模型的隐藏状态当作高质量 Embedding。
  • 长文本编码可能带来较高计算成本。
  • 它不能自动解决错误的切片边界。

Late Chunking 改变的是 Chunk 向量的生成方式,并不意味着可以完全取消切片。

六、特殊内容的切片策略

普通文本可以使用段落或语义切片,但技术文档中还存在大量特殊内容。

如果不进行针对性处理,很容易破坏原始语义。

6.1 表格切片

表格通常具有行列关系,不能简单按照字符长度切开。

例如:

产品 价格 库存
A 100 20
B 200 15
C 300 10

如果只切出:

A 100 20
B 200 15

就可能丢失列名。

更合理的方式是保留表头:

表格:产品库存信息

产品 | 价格 | 库存
A | 100 | 20
B | 200 | 15

对于超长表格,可以按照行分组,但每个 Chunk 应包含必要的表头和单位。

建议保留:

  • 表格标题。
  • 多级表头。
  • 单位。
  • 行列信息。
  • 页码。
  • 表格所属章节。

6.2 代码切片

代码具有明确的语法结构。

不推荐简单按照固定字符数拆分代码。

例如:

class UserService:

    def get_user(self, user_id):
        return self.repository.find_by_id(user_id)

    def create_user(self, user):
        return self.repository.save(user)

更合理的切片单位:

  • Module。
  • Class。
  • Function。
  • Method。
  • Code Block。

切片时需要保留:

  • 文件路径。
  • 类名。
  • 函数名。
  • 编程语言。
  • 依赖关系。
  • 必要的导入语句。
  • 所属模块。

例如:

{
  "chunk_id": "code_001",
  "language": "python",
  "file_path": "services/user_service.py",
  "symbol_type": "method",
  "class_name": "UserService",
  "symbol_name": "get_user",
  "text": "def get_user(self, user_id):\n    return self.repository.find_by_id(user_id)"
}

对于大型函数,可以按照语法树(AST)进行更细粒度拆分,但应保留必要的函数签名和上下文。

6.3 数学公式切片

数学公式不能随意拆分。

例如:

Attention(Q,K,V)= softmax\left(\frac{QK^T}{\sqrt{d_k}}\right)V

如果公式被拆成多个片段,可能失去变量定义和计算关系。

建议:

  • 将公式与解释文本放在同一个 Chunk。
  • 保留公式编号。
  • 保留变量定义。
  • 保留公式前后的条件说明。
  • 对长公式保留原始 LaTeX。

6.4 列表与操作步骤切片

操作手册中经常出现连续步骤:

1. 创建数据库。
2. 创建用户。
3. 分配访问权限。
4. 配置连接参数。
5. 测试连接。

不应随意将步骤拆散。

如果一个操作流程整体具有依赖关系,可以将其作为一个知识单元。

如果流程过长,可以按照阶段拆分,并在每个 Chunk 中保留流程标题和阶段信息。

6.5 FAQ 切片

FAQ 的天然知识单元通常是一个问题及其完整答案。

例如:

问题:Redis 默认端口是多少?

答案:Redis 默认端口为 6379。

建议将问题和答案作为同一个 Chunk。

如果只对答案生成 Embedding,可能导致检索时缺少问题语义。