语义分块与延迟分块详解

一句话总结

两种分块策略都为了解决同一个核心问题:把长文档切成适合 AI 处理的小块,同时最大程度保留语义完整性。区别在于——语义分块”先切后编码”,延迟分块”先编码后切”。


一、核心概念

1. 语义分块(Semantic Chunking)

  • 核心逻辑:按”意思”切,不按”字数”切。计算相邻句子的语义相似度,当相似度突然大幅下降(话题转折点)时在此切块。
  • 切分信号:相邻句子相似度低。例如”苹果种植”后面紧跟”苹果手机评测”,相似度骤降 → 判定切开。
  • 优点:每个块内部话题高度统一,语义完整。
  • 缺点:计算相似度需调用 AI 模型,速度慢、消耗资源;阈值难调,容易切得过碎或漏切。

2. 延迟分块(Late Chunking)

  • 核心逻辑:先把整篇文档一次性输入给嵌入模型,生成每个句子的上下文感知向量,之后再在向量空间里动态切分。
  • 切分依据:不是标点或字数,而是看向量在高维空间的分布是否”跳跃”。即使字面连续,向量指向不同方向(含义不同)就在此处切开。
  • 优点:每个句子的向量融入了全文背景,语义判断更准确,能处理指代消解(如”它”指什么)。
  • 缺点:计算成本高;“先编码后切分”在操作上更复杂。

二、代码流程对比

1. 语义分块:先切后编码(流水线式)

流程:按句子切分 → 计算相邻句相似度 → 决定切割点 → 最后统一编码

def semantic_chunking(document):
    # 1. 先按标点切分成句子列表
    sentences = split_sentences(document)  # ["句1", "句2", "句3"...]
 
    chunks = []
    current_chunk = [sentences[0]]
 
    # 2. 遍历相邻句子,计算相似度
    for i in range(1, len(sentences)):
        # 调用轻量级embedding模型获取向量
        vec_prev = embed_model.encode(sentences[i-1])
        vec_curr = embed_model.encode(sentences[i])
        sim = cosine_similarity(vec_prev, vec_curr)  # 相似度分数
 
        # 3. 如果相似度低于阈值(如0.5),在此处切分
        if sim < threshold:
            chunks.append(merge_sentences(current_chunk))  # 保存前一块
            current_chunk = [sentences[i]]  # 开启新块
        else:
            current_chunk.append(sentences[i])
 
    chunks.append(merge_sentences(current_chunk))
 
    # 4. 最后对所有块进行编码(用于后续检索)
    chunk_vectors = embed_model.encode(chunks)
    return chunks, chunk_vectors

关键特征:

  • 编码次数多:每对相邻句子都要调用模型(句子级),计算量大。
  • 切割决策早:在原始文本层面就决定了边界。
  • 块内语义连贯,但块与块之间可能丢失长距离依赖(如”它”指代前文)。

2. 延迟分块:先编码后切(整体感知式)

流程:整篇输入 → 生成每个句子的上下文向量 → 在向量空间检测”跳变” → 按向量分布切分

def late_chunking(document):
    # 1. 先将文档按句子切分(只是标记位置,不切块)
    sentences = split_sentences(document)  # ["句1", "句2"...]
 
    # 2. 关键一步:将整篇文档一次性输入模型
    # 模型会为每个token生成向量,再池化为句子向量
    # 核心:每个句子的向量都融合了全文信息(含上下文)
    sentence_vectors = embed_model.encode_with_context(sentences, document)
    # 返回 shape: [句子数, 向量维度]
 
    # 3. 在向量层面检测"断层"
    chunks = []
    chunk_start = 0
 
    for i in range(1, len(sentence_vectors)):
        # 计算相邻句子向量的余弦相似度(此时向量已含全局信息)
        sim = cosine_similarity(sentence_vectors[i-1], sentence_vectors[i])
 
        # 或者更高级:检测向量的"分布跳跃"(如聚类突变点)
        if sim < threshold or is_change_point(sentence_vectors, i):
            # 根据向量位置,回溯原文切分
            chunk_text = merge_sentences(sentences[chunk_start:i])
            chunks.append(chunk_text)
            chunk_start = i
 
    chunks.append(merge_sentences(sentences[chunk_start:]))
 
    # 注意:此时切分完成,但每个块的向量已经在第2步生成好了
    # 直接取平均或拼接作为块向量即可
    chunk_vectors = aggregate_vectors(sentence_vectors, chunks)
    return chunks, chunk_vectors

关键特征:

  • 只调用一次模型,但要求模型支持上下文感知(如 ColBERT 或 LongFormer)。
  • 切割依赖向量分布,可能用到变化点检测算法(如 ruptures 库),不仅是简单阈值。
  • 每个句子的向量都是”全局视角”,能解决指代问题,切分更准确。

三、核心差异总结

维度语义分块延迟分块
模型调用时机先调多次(句子对)后调一次(整篇)
切分依据原始文本相似度向量空间分布
句子向量是否含上下文❌ 不含(独立编码)✅ 含(整篇输入)
代码复杂度低(阈值逻辑)高(需变化点检测)
内存占用低(逐句处理)高(需缓存全篇向量)
应用场景实时性要求高、文档结构清晰追求检索精度(如 RAG),避免前期切错丢信息

四、动态阈值选择(语义分块的进阶优化)

为什么需要动态阈值?

固定阈值(如 0.5)在不同文档中表现极不稳定——科技论文的句子相似度普遍偏高,而小说对话则忽高忽低。

方法一:百分位数法(最实用)

import numpy as np
 
# 计算所有相邻句子的相似度
similarities = [cosine_sim(sentences[i], sentences[i+1]) for i in range(len(sentences)-1)]
 
# 动态选阈值:取相似度分布的"下四分位数"或"均值-1个标准差"
threshold = np.percentile(similarities, 25)  # 取25%分位点
# 或
threshold = np.mean(similarities) - np.std(similarities)

逻辑:把相似度明显低于平均水平的位置作为切点,而非固定死值。

方法二:拐点检测(Elbow Method)

# 将相似度按从低到高排序,找"骤降"的拐点
sorted_sims = np.sort(similarities)
# 计算相邻差值,差值最大的位置即为"自然分界点"
gaps = np.diff(sorted_sims)
cut_index = np.argmax(gaps)  # 最大间隙处
threshold = sorted_sims[cut_index]

逻辑:相似度分布中天然存在一个”沟”,沟两边分别是”同一话题”和”不同话题”。

方法三:高斯混合模型(GMM)

from sklearn.mixture import GaussianMixture
 
# 假设相似度来自两个高斯分布:同类(高相似)和异类(低相似)
gmm = GaussianMixture(n_components=2)
gmm.fit(np.array(similarities).reshape(-1, 1))
# 取两个分布的交点作为阈值
threshold = (gmm.means_[0] + gmm.means_[1]) / 2  # 近似

逻辑:让算法自己学出”高”和”低”的分界线,最科学但计算稍重。

三种方法的取舍

  • 百分位数法:代码简单、效果稳定,优先推荐。
  • 拐点检测:只适合”一刀切”的场景,多切分点需改造。
  • GMM:最科学,但计算稍重,且默认需要指定组件数。

五、ruptures 检测断层原理(延迟分块的核心)

ruptures 是专门做时间序列突变点检测的库。用在延迟分块上就是:把相邻句子向量的相似度(或距离)看作一条时间序列,找序列中发生”跳跃”的位置。

三步原理

第一步:定义信号

# 每个句子向量作为一维点,信号就是向量序列
signal = sentence_vectors  # shape: [n_sentences, embedding_dim]
# 或者用相邻距离作为信号
signal = [cosine_dist(vec[i], vec[i+1]) for i in range(n_sentences-1)]

第二步:选择代价函数(Cost Function)

  • 衡量”这段子序列内部是否够一致”。
  • 常用 CostL2(均方误差):计算子序列的方差,方差越小越一致。
  • 断层点就是让”分段后总代价最小”的位置。

第三步:搜索最优切点(动态规划)

import ruptures as rpt
 
# 1. 定义模型(选择L2代价,penalty控制切分数量)
algo = rpt.Pelt(model="l2").fit(signal)
 
# 2. 检测断点(penalty值越大,切分越少)
change_points = algo.predict(penalty=10)  # 返回断点索引

直观理解

想象一条平缓的曲线(同一话题),突然出现大幅波动(换话题)。ruptures 会:

  1. 尝试在每个位置切一刀,计算”切后两段的内部方差之和”;
  2. 切后总方差比不切时降低得最多的位置,就是断层;
  3. penalty 参数相当于”惩罚项”——如果降低的幅度不够大,就不切,防止过切。

固定阈值 vs ruptures 动态检测

维度固定阈值ruptures 动态检测
依据单个数值比较整体序列分布
能否处理渐变话题❌ 易误切✅ 会判断是缓变还是突变
参数调优调 threshold调 penalty(更直观:越大块越少)
适用场景简单文档长文档、多主题混杂

实战建议

  • 用语义分块:优先用百分位数法动态选阈值。
  • 用延迟分块:直接用 ruptures 的 Pelt 算法,penalty 可设为 2 * std(signal) * log(n)(理论最优近似)。

六、两个易踩的坑

坑 1:拐点检测和 GMM 需要预设分块数量?

传统方法确实需要,但可以改进为免调参:

拐点检测改进版——3-sigma 找所有显著间隙

sorted_sims = np.sort(similarities)
gaps = np.diff(sorted_sims)
 
# 用"3-sigma原则"找异常大的间隙
mean_gap = np.mean(gaps)
std_gap = np.std(gaps)
significant_gaps = np.where(gaps > mean_gap + 2 * std_gap)[0]
 
# 每个显著间隙对应的相似度值,就是候选阈值
thresholds = sorted_sims[significant_gaps]

GMM 改进版——用 BIC 自动选组件数

from sklearn.mixture import GaussianMixture
import numpy as np
 
best_bic = np.inf
best_n = 1
for n in range(1, 5):  # 尝试1-4个高斯分布
    gmm = GaussianMixture(n_components=n, random_state=0)
    gmm.fit(np.array(similarities).reshape(-1, 1))
    bic = gmm.bic(X)
    if bic < best_bic:
        best_bic = bic
        best_n = n
 
# 用最优的n重新拟合
gmm = GaussianMixture(n_components=best_n)
gmm.fit(X)
# 此时各个组件的交点即为阈值

BIC 会自动平衡”拟合度”和”复杂度”,避免过拟合。

坑 2:n 个句子怎么切出 n-1 个位置?(索引映射)

最容易搞混的地方。 假设有 5 个句子:

句子索引:  0     1     2     3     4
         | 句A | 句B | 句C | 句D | 句E |
相邻对:     0-1   1-2   2-3   3-4
相似度索引:  0     1     2     3     ← 只有4个值

切分逻辑:

  • similarities[0] 对应句子 0 和句子 1 之间的位置。
  • 如果 similarities[0] 被判定为断层,切分点就在句子 0 之后、句子 1 之前。
  • 实际切割:chunk_1 = sentences[0:1], chunk_2 = sentences[1:]。

代码映射示例:

sentences = ["句A", "句B", "句C", "句D", "句E"]
similarities = [0.9, 0.3, 0.8, 0.4]  # 只有4个
 
# 假设检测出断层在 similarities[1] 和 similarities[3]
cut_indices = [1, 3]  # 这些是相似度数组的索引
 
# 映射到句子的切割位置
chunks = []
start = 0
for cut in cut_indices:
    # cut=1 表示在句子1和2之间切(因为 similarities[1] 对应句子1-2之间)
    chunks.append(sentences[start:cut+1])  # 注意 +1
    start = cut + 1
chunks.append(sentences[start:])
 
# 结果:
# cut=1 → 第一块: sentences[0:2] = ["句A", "句B"]
# cut=3 → 第二块: sentences[2:4] = ["句C", "句D"]
# 最后: 第三块: sentences[4:] = ["句E"]

ruptures 的索引含义:返回的断点索引是句子位置,不是相似度位置。如果返回 [3, 7],切分就是:

  • 第一块:sentences[0:3]
  • 第二块:sentences[3:7]
  • 第三块:sentences[7:]

七、免调参完整方案

def auto_chunking(sentences, sentence_vectors):
    # 1. 计算相邻相似度
    sims = [cosine_sim(sentence_vectors[i], sentence_vectors[i+1])
            for i in range(len(sentences)-1)]
 
    # 2. 用"均值-标准差"动态阈值(无需预设数量)
    threshold = np.mean(sims) - 0.5 * np.std(sims)
 
    # 3. 找出所有低于阈值的位置
    cut_positions = [i+1 for i, s in enumerate(sims) if s < threshold]
 
    # 4. 切分
    chunks = []
    start = 0
    for pos in cut_positions:
        if pos > start:
            chunks.append(sentences[start:pos])
            start = pos
    if start < len(sentences):
        chunks.append(sentences[start:])
 
    return chunks

该方案特点:✅ 无需预设块数 | ✅ 无需调参(0.5 是经验值,可微调)| ✅ 自动适应不同文档的相似度分布


八、选型建议

场景推荐方案
语义分块快速落地langchain 的 SemanticChunker,几句话即可实现
延迟分块jina-embeddings-v3 或 ColBERT,配合 ruptures 库检测断层
简单文档固定阈值即可
长文档、多主题混杂ruptures 动态检测

相关笔记