您应该为您的 RAG 系统使用哪种分块技术？

1. 1. 固定大小分块（基于令牌或字符）

固定大小分块是最简单的方法，将文本分割成预定义长度的块（例如 512 个令牌），并可选地添加重叠（10-20%）以保持边界间的上下文连续性。

优点：实现简单、计算高效，适合快速原型开发。  

缺点：忽略语义结构，可能在句子或想法中间截断，导致上下文碎片化。  

何时使用：适用于统一的无结构数据，如日志、短笔记，或在实时应用中优先考虑速度而非精度。

代码示例（Python）：

from typing import List



import re





def word_splitter(source_text: str) -> List[str]:



    source_text = re.sub("\s+", " ", source_text)



    return re.split("\s", source_text)





def get_chunks_fixed_size_with_overlap(text: str, chunk_size: int, overlap_fraction: float = 0.2) -> List[str]:



    text_words = word_splitter(text)



    overlap_int = int(chunk_size * overlap_fraction)



    chunks = []



    for i in range(0, len(text_words), chunk_size):



        chunk_words = text_words[max(i - overlap_int, 0): i + chunk_size]



        chunk = " ".join(chunk_words)



        chunks.append(chunk)



    return chunks

2. 递归分块

这种方法使用分隔符的层次结构（例如，双换行符分段落，然后单换行符分句子），递归地分割文本，直到块符合所需大小。

优点：比固定大小更尊重文档结构，减少了不自然的断点。  

缺点：仍基于规则，可能无法捕捉深层语义；编码稍复杂。  

何时使用：适用于半结构化文本，如博客文章、新闻或研究论文，这些文本存在逻辑断点。

代码示例（Python）：

from typing import List





def recursive_chunking(text: str, max_chunk_size: int = 1000) -> List[str]:



    if len(text) <= max_chunk_size:



        return [text.strip()] if text.strip() else []



    separators = ["\n\n", "\n", ". ", " "]



    for separator in separators:



        if separator in text:



            parts = text.split(separator)



            chunks = []



            current_chunk = ""



            for part in parts:



                test_chunk = current_chunk + separator + part if current_chunk else part



                if len(test_chunk) <= max_chunk_size:



                    current_chunk = test_chunk



                else:



                    if current_chunk:



                        chunks.append(current_chunk.strip())



                    current_chunk = part



            if current_chunk:



                chunks.append(current_chunk.strip())



            final_chunks = []



            for chunk in chunks:



                if len(chunk) > max_chunk_size:



                    final_chunks.extend(recursive_chunking(chunk, max_chunk_size))



                else:



                    final_chunks.append(chunk)



            return [chunk for chunk in final_chunks if chunk]



    return [text[i:i + max_chunk_size] for i in range(0, len(text), max_chunk_size)]

3. 内容感知分块

内容感知分块基于自然内容单元（如句子、段落或章节）进行分割，使用分隔符或 NLP 工具。

优点：保持逻辑完整性，提升检索相关性。  

缺点：依赖一致的格式；对结构不良的数据无效。  

何时使用：适用于格式化文档，如报告、书籍或法律文本。

代码示例：使用 NLTK 库进行句子分割：

import nltk



nltk.download('punkt')





def sentence_chunking(text: str) -> List[str]:



    sentences = nltk.sent_tokenize(text)



    return sentences  # 如需进一步组合以达到所需大小

4. 语义分块

这种高级技术使用嵌入来分组语义相似的句子或段落，通常通过余弦相似度阈值实现。

优点：确保块在上下文中连贯，提升 RAG 准确性。  

缺点：嵌入计算导致高计算成本。  

何时使用：适用于密集的技术内容，如科学论文或代码库，其中含义优先于结构。

代码示例：使用 sentence-transformers：

from sentence_transformers import SentenceTransformer, util





model = SentenceTransformer('all-MiniLM-L6-v2')





def semantic_chunking(sentences: List[str], similarity_threshold: float = 0.7) -> List[str]:



    embeddings = model.encode(sentences)



    chunks = []



    current_chunk = [sentences[0]]



    for i in range(1, len(sentences)):



        sim = util.cos_sim(embeddings[i-1], embeddings[i])



        if sim > similarity_threshold:



            current_chunk.append(sentences[i])



        else:



            chunks.append(' '.join(current_chunk))



            current_chunk = [sentences[i]]



    chunks.append(' '.join(current_chunk))



    return chunks

5. 代理分块

利用 LLM 作为“代理”来智能确定块边界，基于提示进行操作。

优点：高度适应性且语义感知，无需固定规则。  

缺点：因 LLM 调用而昂贵且缓慢；可能不一致。  

何时使用：高价值场景，如自定义企业数据，精度至关重要。

代码示例：通过 OpenAI API 提示 LLM：

import openai





def Agentic_chunking(text: str, max_chunk_size: int) -> List[str]:



    response = openai.ChatCompletion.create(



        model="gpt-4",



        messages=[{"role": "user", "content": f"将此文本分割成不超过 {max_chunk_size} 个字符的连贯块：{text}"}]



    )



    chunks = response.choices[0].message.content.split('\n\n')  # 假设块由双换行符分隔



    return chunks

6. 滑动窗口分块

通过在文本上滑动窗口创建重叠块，确保连续上下文。

优点：捕捉边界间信息，减少信息丢失。  

缺点：因冗余而增加存储和检索开销。  

何时使用：叙事或序列数据，如故事、转录或时间序列日志。

代码示例：类似于固定大小，但步长可调：

def sliding_window_chunking(text: str, window_size: int, step: int) -> List[str]:



    words = text.split()



    chunks = []



    for i in range(0, len(words), step):



        chunk = ' '.join(words[i:i + window_size])



        if chunk:



            chunks.append(chunk)



    return chunks

7. 层次分块

构建多级结构（例如，文档 > 章节 > 段落 > 句子），用于分层检索。

优点：启用灵活的多分辨率搜索。  

缺点：设置和索引复杂。  

何时使用：大型层次文档，如手册、维基或学术论文。

代码示例：表示为树状结构（简化）：

# 使用 BeautifulSoup 等库解析 HTML 或自定义解析器处理层次



def hierarchical_chunking(document: dict) -> dict:



    # 假设文档已解析成章节



    hierarchy = {'sections': []}



    for section in document['sections']:



        chunks = {'title': section['title'], 'paragraphs': [p for p in section['content'].split('\n\n')]}



        hierarchy['sections'].append(chunks)



    return hierarchy

8. 延迟分块

一种新颖方法，首先在长上下文中生成嵌入，然后在嵌入后派生块，以保留完整上下文。

优点：更好地处理长依赖；对某些模型成本效益高。  

缺点：需要兼容的嵌入模型；不普遍适用。  

何时使用：与长上下文 LLM 一起使用，或处理相互连接的叙事，如小说或法律合同。

代码示例：使用专用 API（例如 Cohere）：

import cohere





co = cohere.Client('your-api-key')





def late_chunking(text: str) -> List[str]:



    # 嵌入长文本，然后基于嵌入簇进行分割



    response = co.embed(texts=[text], model='embed-english-v3.0')



    embeddings = response.embeddings[0]



    # 使用聚类（例如 KMeans）定义块



    # 简化：假设后处理分割



    return [text]  # 实际实现的占位符

选择分块技术的决策框架

选择合适的分块策略取决于几个因素：

• • 文档类型和结构：无结构数据使用固定大小或递归；结构化数据使用内容感知或层次。
• • 计算资源：预算有限时从简单方法如固定大小开始；高性能设置选择语义或代理。
• • 性能要求：复杂查询的准确性优先语义或延迟分块；速度优先递归。
• • 数据量：大规模语料库适合层次；重叠上下文适合滑动窗口。
• • 评估：使用指标如检索召回率、精度或端到端 RAG 基准（例如 RAGAS 框架）测试策略。迭代实验——A/B 测试不同块大小和重叠是关键。

总之，没有一种分块技术适用于所有场景——最佳选择取决于您的数据和用例。通过理解这些策略并应用决策框架，您可以优化 RAG 系统以实现卓越性能。