语义分块与延迟分块详解
一句话总结
两种分块策略都为了解决同一个核心问题:把长文档切成适合 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 会:
- 尝试在每个位置切一刀,计算”切后两段的内部方差之和”;
- 切后总方差比不切时降低得最多的位置,就是断层;
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 动态检测 |