建议收藏】RAG文本分块技术最全解析:21种主流方法一网打尽!

RAG——RAG 索引(分块策略) 本文介绍了RAG系统中的关键分块技术及其策略选择。分块技术通过将文档拆分为适当大小的片段,直接影响检索和生成质量。文章详细分析了6种分块策略:固定大小分块(基准方法)、重叠分块(保留上下文)、递归分块(按语义单元分割)、文档特定分块(针对格式)、语义分块(NLP技术)和混合分块(综合优势)。每种策略各有适用场景和局限性,需根据文档特点和查询需求选择。最后指出LangChain提供了对应实现方法,便于开发者集成使用。合理选择分块策略对提升RAG系统性能至关重要。 阅读详情

检索增强生成(Retrieval-Augmented Generation, RAG)是当前AI工程师在实际应用中面临的重要技术挑战之一。从理论角度来看,RAG的工作原理相对直观:从自定义数据源中检索相关上下文,然后基于这些上下文让大语言模型生成对应的回答。在实际部署过程中,开发者往往需要处理大量格式混乱的异构数据,并经历反复的系统调优过程,包括分块策略的优化、嵌入模型的选择、检索器的配置、排序器的微调以及提示工程等多个环节。即便如此,系统仍可能出现信息检索不足或生成虚假信息的问题。

在这里插入图片描述

RAG系统包含多个相互关联的组件,其中文本分块策略是决定整个系统性能的关键因素。不同的数据类型、文件格式、内容结构、文档长度和应用场景都需要采用相应的分块策略。分块策略的选择不当会直接影响检索质量和生成效果。本文将系统介绍21种文本分块策略,从基础方法到高级技术,并详细分析每种策略的适用场景,以帮助开发者构建更加可靠的RAG系统。

1. 基础分块(换行符分割)

基础分块是最基础的文本分割方法,按照换行符对文本进行简单分割。

在这里插入图片描述

基础分块示例**适用场景:**该方法适用于结构相对规整且以换行符均匀分隔的文本数据,包括笔记文档、项目列表、FAQ文档、聊天记录或转录文本等,特别是当每行文本都包含完整语义单元的情况。**技术要点:**需要注意文本行长度的平衡。过长的文本行可能超出大语言模型的token限制,而过短的文本行则可能导致上下文信息不足,影响模型的理解和生成质量。代码实现:

def naive_chunking(text):  
    """按换行符进行基础分块"""  
    chunks = text.split('\n')  
    # 过滤空行  
    chunks = [chunk.strip() for chunk in chunks if chunk.strip()]  
    return chunks  

# 使用示例  
text = """这是第一行内容  
这是第二行内容  
这是第三行内容"""  

chunks = naive_chunking(text)  
print(f"分块结果: {chunks}")

2. 固定大小分块

固定大小分块方法按照预设的词数或字符数将文本分割为等长片段,不考虑语义边界。

图片

固定大小分块示例**适用场景:**该方法主要用于处理结构化程度较低的原始文本数据,如扫描文档的OCR输出、质量较差的语音转录文本,或缺乏标点符号、标题等结构标记的大型文本文件。代码实现:

def fixed_size_chunking(text, chunk_size=100, overlap=0):  
    """按固定大小进行文本分块  
    Args:  
        text: 输入文本  
        chunk_size: 每个分块的字符数  
        overlap: 重叠字符数  
    """
    chunks = []  
    start = 0
    text_length = len(text)  

    while start < text_length:  
        end = start + chunk_size  
        chunk = text[start:end]  
        chunks.append(chunk)  
        start = end - overlap  
    return chunks  

# 使用示例  
text = "这是一段很长的文本内容,需要按照固定大小进行分块处理。" * 10
chunks = fixed_size_chunking(text, chunk_size=50, overlap=10)  
print(f"分块数量: {len(chunks)}")  
print(f"第一个分块: {chunks[0]}")

3. 滑动窗口分块

滑动窗口分块在固定大小分块的基础上引入了重叠机制,相邻分块之间保持一定的内容重叠,以维持跨分块的上下文连续性。

图片

滑动窗口分块示例(与固定窗口分块比较)**适用场景:**该方法特别适用于语义信息跨越较长文本段落的内容,如学术论文、叙述性报告、自由格式写作等。与固定窗口分块类似,它也能处理缺乏明确结构标记的文本,但需要在token使用效率和上下文完整性之间进行权衡。代码实现:

def sliding_window_chunking(text, window_size=200, step_size=150):  
    """滑动窗口分块  
    Args:  
        text: 输入文本  
        window_size: 窗口大小(字符数)  
        step_size: 步长(字符数),小于window_size时产生重叠  
    """
    chunks = []  
    start = 0
    text_length = len(text)  

    while start < text_length:  
        end = min(start + window_size, text_length)  
        chunk = text[start:end]  
        chunks.append(chunk)  
        # 如果已经到达文本末尾,停止  
        if end == text_length:  
            break
        start += step_size  
    return chunks  
# 使用示例  
text = "人工智能技术的发展日新月异。深度学习模型在各个领域都取得了突破性进展。" * 5
chunks = sliding_window_chunking(text, window_size=100, step_size=80)  
print(f"分块数量: {len(chunks)}")  
for i, chunk in enumerate(chunks[:3]):  
    print(f"分块 {i+1}: {chunk}")

在这里插入图片描述

4. 基于句子的分块

基于句子的分块方法以句子为基本单位进行文本分割,通常以句号、问号或感叹号作为分割标记。

图片

基于句子的分块示例**适用场景:**该方法适用于结构良好、语言规范的文本内容,其中每个句子都包含相对完整的语义信息,如技术博客、文档总结或产品说明等。此外,句子级分块还可以作为预处理步骤,为后续更复杂的分块策略提供基础数据单元。代码实现:

上下滑动查看更多源码
import re  

defsentence_based_chunking(text, sentences_per_chunk=3):
    """基于句子的分块  

    Args:  
        text: 输入文本  
        sentences_per_chunk: 每个分块包含的句子数  
    """
    # 使用正则表达式分割句子  
    sentences = re.split(r'[.!?。!?]+', text)  
    sentences = [s.strip() for s in sentences if s.strip()]  

    chunks = []  
    for i in range(0, len(sentences), sentences_per_chunk):  
        chunk_sentences = sentences[i:i + sentences_per_chunk]  
        chunk = '。'.join(chunk_sentences)  
        if chunk:  # 确保分块不为空  
            chunks.append(chunk + '。')  

    return chunks  

# 使用示例  
text = """机器学习是人工智能的一个重要分支。它通过算法让计算机从数据中学习模式。  
深度学习是机器学习的子集。它使用神经网络来模拟人脑的工作方式。  
目前深度学习在图像识别和自然语言处理领域取得了巨大成功。"""

chunks = sentence_based_chunking(text, sentences_per_chunk=2)  
for i, chunk in enumerate(chunks):  
    print(f"分块 {i+1}: {chunk}")

5. 基于段落的分块

基于段落的分块方法以段落为单位进行文本分割,通常通过识别双换行符来确定段落边界,确保每个分块包含完整的主题或思想单元。

图片

基于段落的分块示例**适用场景:**当句子级分块提供的上下文信息不足时,段落级分块能够提供更丰富的语义环境。该方法特别适用于已经按照段落结构良好组织的文档,如学术文章、博客文章或技术报告等。代码实现:

def paragraph_based_chunking(text, max_paragraphs_per_chunk=2):  
    """基于段落的分块  
    Args:  
        text: 输入文本  
        max_paragraphs_per_chunk: 每个分块最大段落数  
    """
    # 按双换行符分割段落  
    paragraphs = text.split('\n\n')  
    paragraphs = [p.strip() for p in paragraphs if p.strip()]  
    chunks = []  
    for i in range(0, len(paragraphs), max_paragraphs_per_chunk):  
        chunk_paragraphs = paragraphs[i:i + max_paragraphs_per_chunk]  
        chunk = '\n\n'.join(chunk_paragraphs)  
        chunks.append(chunk)  
    return chunks  
# 使用示例  
text = """人工智能的发展经历了多个阶段。从最初的符号主义到现在的深度学习,每个阶段都有其独特的特点和贡献。  
机器学习作为人工智能的核心技术,为各行各业带来了革命性的变化。它不仅改变了我们处理数据的方式,也为未来的技术发展奠定了基础。  
深度学习的出现标志着人工智能进入了新的时代。通过模拟人脑神经网络的工作原理,深度学习在图像识别、语音处理等领域取得了突破性进展。"""
chunks = paragraph_based_chunking(text, max_paragraphs_per_chunk=1)  
for i, chunk in enumerate(chunks):  
    print(f"分块 {i+1}:\n{chunk}\n{'-'*50}")

6. 基于页面的分块

基于页面的分块方法将每个物理页面视为一个独立的文本分块。

图片

基于页面的分块示例**适用场景:**该方法主要用于处理具有分页结构的文档,如PDF扫描件、演示文稿或图书等。在需要保持页面布局信息或在检索过程中需要引用页码的应用场景中特别有用。**代码实现:

**

上下滑动查看更多源码
import PyPDF2  
from io import BytesIO  

defpage_based_chunking_pdf(pdf_path):
    """基于页面的PDF分块  

    Args:  
        pdf_path: PDF文件路径  
    """
    chunks = []  

    try:  
        with open(pdf_path, 'rb') as file:  
            pdf_reader = PyPDF2.PdfReader(file)  

            for page_num, page in enumerate(pdf_reader.pages):  
                text = page.extract_text()  
                if text.strip():  # 确保页面有内容  
                    chunk = {  
                        'page_number': page_num + 1,  
                        'content': text.strip()  
                    }  
                    chunks.append(chunk)  

    except Exception as e:  
        print(f"PDF处理错误: {e}")  

    return chunks  

# 简化版本:模拟页面分块  
defsimulate_page_chunking(text, chars_per_page=500):
    """模拟基于页面的分块  

    Args:  
        text: 输入文本  
        chars_per_page: 每页字符数  
    """
    chunks = []  
    page_num = 1

    for i in range(0, len(text), chars_per_page):  
        page_content = text[i:i + chars_per_page]  
        chunk = {  
            'page_number': page_num,  
            'content': page_content  
        }  
        chunks.append(chunk)  
        page_num += 1

    return chunks  

# 使用示例  
text = "这是一个长文档的内容。" * 100
chunks = simulate_page_chunking(text, chars_per_page=200)  
print(f"总页数: {len(chunks)}")  
print(f"第一页内容: {chunks[0]['content'][:50]}...")

7. 结构化分块

结构化分块方法基于文档的已知结构特征进行分割,如日志条目、数据库模式字段、HTML标签或Markdown元素等。

图片

结构化分块示例**适用场景:**该方法适用于具有明确结构标记的数据格式,包括系统日志、JSON记录、CSV文件或HTML文档等结构化或半结构化数据。**代码实现:

**

上下滑动查看更多源码
import json  
import re  
from bs4 import BeautifulSoup  

defjson_structured_chunking(json_data):
    """JSON数据结构化分块"""
    chunks = []  

    if isinstance(json_data, list):  
        for i, item in enumerate(json_data):  
            chunk = {  
                'type': 'json_item',  
                'index': i,  
                'content': json.dumps(item, ensure_ascii=False, indent=2)  
            }  
            chunks.append(chunk)  
    elif isinstance(json_data, dict):  
        for key, value in json_data.items():  
            chunk = {  
                'type': 'json_field',  
                'key': key,  
                'content': json.dumps({key: value}, ensure_ascii=False, indent=2)  
            }  
            chunks.append(chunk)  

    return chunks  

defhtml_structured_chunking(html_content):
    """HTML内容结构化分块"""
    soup = BeautifulSoup(html_content, 'html.parser')  
    chunks = []  

    # 按段落分块  
    for i, p in enumerate(soup.find_all('p')):  
        if p.get_text().strip():  
            chunk = {  
                'type': 'paragraph',  
                'index': i,  
                'content': p.get_text().strip()  
            }  
            chunks.append(chunk)  

    # 按标题分块  
    for level in range(1, 7):  # h1-h6  
        for i, h in enumerate(soup.find_all(f'h{level}')):  
            chunk = {  
                'type': f'heading_{level}',  
                'index': i,  
                'content': h.get_text().strip()  
            }  
            chunks.append(chunk)  

    return chunks  

# 使用示例  
json_data = [  
    {"name": "张三", "age": 25, "department": "技术部"},  
    {"name": "李四", "age": 30, "department": "产品部"}  
]  

chunks = json_structured_chunking(json_data)  
for chunk in chunks:  
    print(f"类型: {chunk['type']}, 内容: {chunk['content'][:50]}...")

8. 基于文档结构的分块

基于文档结构的分块方法利用文档的自然层次结构进行分割,如标题、副标题和章节等组织元素。

图片

基于文档结构的分块示例适用场景:该方法适用于具有清晰层次结构的文档,如技术文章、操作手册、教科书或研究论文等。同时,它也可以作为更高级分块策略(如层次分块)的预处理步骤。

9. 基于关键词的分块

基于关键词的分块方法通过预定义的关键词来识别分割点,将关键词的出现位置作为逻辑分段标记。

图片

基于关键词的分块示例(关键词是’Note’)**适用场景:**当文档缺乏明确的标题层次结构,但包含能够标识主题转换的特定关键词或短语时,该方法能够有效地进行主题分割。

10. 基于实体的分块

基于实体的分块方法使用命名实体识别(Named Entity Recognition, NER)技术来检测文本中的特定实体(如人名、地名、产品名等),然后围绕这些实体组织相关文本内容。

图片

基于实体的分块示例(关键词是’Note’)**适用场景:**该方法适用于实体信息具有重要意义的文档类型,如新闻报道、法律合同、案例研究或影视剧本等,能够确保与特定实体相关的信息被完整保留在同一分块中。

11. 基于Token的分块

基于Token的分块方法使用分词器(tokenizer)按照token数量进行文本分割。**适用场景:**该方法主要用于处理缺乏标题或段落结构的非结构化文档,以及需要严格控制输入长度的低token限制大语言模型场景。为了避免在句子中间进行分割而破坏语义完整性,通常建议将该技术与句子级分块相结合。**代码实现:

**

上下滑动查看更多源码
from transformers import AutoTokenizer  
import tiktoken  

deftoken_based_chunking_transformers(text, model_name="bert-base-chinese", max_tokens=512):
    """使用Transformers分词器进行基于Token的分块"""
    tokenizer = AutoTokenizer.from_pretrained(model_name)  

    # 对整个文本进行分词  
    tokens = tokenizer.tokenize(text)  
    chunks = []  

    for i in range(0, len(tokens), max_tokens):  
        chunk_tokens = tokens[i:i + max_tokens]  
        # 将tokens转换回文本  
        chunk_text = tokenizer.convert_tokens_to_string(chunk_tokens)  
        chunks.append(chunk_text)  

    return chunks  

deftoken_based_chunking_tiktoken(text, model="gpt-3.5-turbo", max_tokens=1000):
    """使用tiktoken进行基于Token的分块(适用于OpenAI模型)"""
    try:  
        encoding = tiktoken.encoding_for_model(model)  
    except KeyError:  
        encoding = tiktoken.get_encoding("cl100k_base")  

    # 编码文本  
    tokens = encoding.encode(text)  
    chunks = []  

    for i in range(0, len(tokens), max_tokens):  
        chunk_tokens = tokens[i:i + max_tokens]  
        # 解码回文本  
        chunk_text = encoding.decode(chunk_tokens)  
        chunks.append(chunk_text)  

    return chunks  

# 简化版本:字符近似token分块  
defsimple_token_chunking(text, max_tokens=1000, chars_per_token=4):
    """简化的基于Token的分块(字符数近似)"""
    max_chars = max_tokens * chars_per_token  
    chunks = []  

    for i in range(0, len(text), max_chars):  
        chunk = text[i:i + max_chars]  
        chunks.append(chunk)  

    return chunks  

# 使用示例  
text = "人工智能技术的发展正在改变我们的生活方式。" * 50
chunks = simple_token_chunking(text, max_tokens=100, chars_per_token=2)  
print(f"分块数量: {len(chunks)}")  
print(f"第一个分块长度: {len(chunks[0])} 字符")

12. 基于主题的分块

基于主题的分块方法通过主题建模或聚类技术来识别主题边界。该过程首先将文本分割为较小的单元(如句子或段落),然后使用机器学习方法将语义相关的片段聚合为单一分块。

图片

通过聚类进行基于主题的分块示例**适用场景:**该方法适用于涵盖多个主题的文档,能够确保每个分块专注于单一主题,特别是在主题转换较为渐进且缺乏明确标题或关键词标记的文本中表现良好。

13. 表格感知分块

表格感知分块方法专门处理文档中的表格结构,将表格内容转换为JSON或Markdown格式进行单独处理。分块粒度可以是行级别、列级别或整表级别。

图片

表格感知分块示例**适用场景:**该方法专门用于包含表格数据的文档,能够保持表格结构的完整性和数据关系的准确性。

14. 内容感知分块

内容感知分块方法根据不同的内容类型采用相应的分割规则,为段落、表格、列表等不同内容形式制定专门的处理策略。**适用场景:**该方法适用于包含多种内容格式的混合文档,能够根据内容类型的特点进行针对性处理,确保表格数据的完整性、段落语义的连贯性等。

15. 上下文分块

上下文分块方法利用大语言模型对知识库进行分析,并在文本嵌入之前为每个分块生成简短而相关的上下文描述。

图片

上下文分块示例**适用场景:**该方法适用于知识库规模在大语言模型token限制范围内的场景,特别是对于复杂文档(如财务报告和法律合同等)能够显著提升检索准确性。

16. 语义分块

语义分块方法通过计算文本片段的嵌入向量相似性来识别语义相关的内容,并将其组织为主题一致的分块。**适用场景:**当传统的段落分块或固定窗口分块无法满足需求时,语义分块能够提供更精确的主题聚合效果,特别适用于主题复杂多样的长文档。**代码实现:

**

上下滑动查看更多源码
from sentence_transformers import SentenceTransformer  
import numpy as np  
from sklearn.metrics.pairwise import cosine_similarity  

defsemantic_chunking(text, similarity_threshold=0.7, min_chunk_size=50):
    """基于语义相似性的分块  

    Args:  
        text: 输入文本  
        similarity_threshold: 相似性阈值  
        min_chunk_size: 最小分块大小  
    """
    # 初始化句子编码器  
    model = SentenceTransformer('all-MiniLM-L6-v2')  

    # 按句子分割  
    sentences = text.split('。')  
    sentences = [s.strip() + '。'for s in sentences if s.strip()]  

    if len(sentences) < 2:  
        return [text]  

    # 计算句子嵌入  
    embeddings = model.encode(sentences)  

    chunks = []  
    current_chunk = [sentences[0]]  

    for i in range(1, len(sentences)):  
        # 计算当前句子与当前分块的相似性  
        current_embedding = embeddings[i:i+1]  
        chunk_embeddings = embeddings[len(chunks) * len(current_chunk):len(chunks) * len(current_chunk) + len(current_chunk)]  

        # 计算平均相似性  
        similarities = cosine_similarity(current_embedding, chunk_embeddings)  
        avg_similarity = np.mean(similarities)  

        if avg_similarity >= similarity_threshold:  
            current_chunk.append(sentences[i])  
        else:  
            # 如果分块足够大,保存当前分块  
            chunk_text = ''.join(current_chunk)  
            if len(chunk_text) >= min_chunk_size:  
                chunks.append(chunk_text)  
            current_chunk = [sentences[i]]  

    # 添加最后一个分块  
    if current_chunk:  
        chunk_text = ''.join(current_chunk)  
        if len(chunk_text) >= min_chunk_size:  
            chunks.append(chunk_text)  
        elif chunks:  # 如果最后一个分块太小,合并到前一个分块  
            chunks[-1] += chunk_text  
        else:  
            chunks.append(chunk_text)  

    return chunks  

# 简化版本:基于关键词相似性的语义分块  
defsimple_semantic_chunking(text, keywords_per_chunk=3):
    """简化的语义分块(基于关键词)"""
    sentences = text.split('。')  
    sentences = [s.strip() for s in sentences if s.strip()]  

    chunks = []  
    current_chunk = []  
    current_keywords = set()  

    for sentence in sentences:  
        # 简单提取关键词(这里用长度>2的词)  
        words = [word for word in sentence if len(word) > 2]  
        sentence_keywords = set(words[:keywords_per_chunk])  

        # 计算关键词重叠  
        overlap = len(current_keywords.intersection(sentence_keywords))  

        if overlap > 0or len(current_chunk) == 0:  
            current_chunk.append(sentence + '。')  
            current_keywords.update(sentence_keywords)  
        else:  
            chunks.append(''.join(current_chunk))  
            current_chunk = [sentence + '。']  
            current_keywords = sentence_keywords  

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

    return chunks  

# 使用示例  
text = """人工智能技术发展迅速。机器学习是AI的核心技术。深度学习推动了AI革命。  
自然语言处理技术不断进步。聊天机器人越来越智能。语言模型能力显著提升。  
计算机视觉应用广泛。图像识别准确率不断提高。自动驾驶技术日趋成熟。"""

chunks = simple_semantic_chunking(text)  
for i, chunk in enumerate(chunks):  
    print(f"语义分块 {i+1}: {chunk}")

17. 递归分块

递归分块方法采用分层处理策略,首先使用大粒度分隔符(如段落)进行初步分割,然后对超出预设长度限制的分块使用更细粒度的分隔符(如句子或词汇)进行递归细分,直到所有分块都满足长度要求。**适用场景:**该方法适用于句子长度变化较大或难以预测的文本内容,如访谈记录、演讲稿或自由格式写作等。**代码实现:

**

上下滑动查看更多源码
import re  

defrecursive_chunking(text, max_chunk_size=500, separators=None):
    """递归分块方法  

    Args:  
        text: 输入文本  
        max_chunk_size: 最大分块大小  
        separators: 分隔符列表,按优先级排序  
    """
    if separators isNone:  
        separators = ['\n\n', '\n', '。', '!', '?', ',', ' ']  

    defsplit_text(text, max_size, sep_index=0):
        """递归分割文本"""
        if len(text) <= max_size or sep_index >= len(separators):  
            return [text] if text.strip() else []  

        separator = separators[sep_index]  
        chunks = []  

        # 按当前分隔符分割  
        parts = text.split(separator)  

        current_chunk = ""
        for part in parts:  
            # 如果添加这部分不会超过大小限制  
            if len(current_chunk + separator + part) <= max_size:  
                if current_chunk:  
                    current_chunk += separator + part  
                else:  
                    current_chunk = part  
            else:  
                # 保存当前分块  
                if current_chunk:  
                    if len(current_chunk) > max_size:  
                        # 如果当前分块仍然太大,递归处理  
                        chunks.extend(split_text(current_chunk, max_size, sep_index + 1))  
                    else:  
                        chunks.append(current_chunk)  

                # 开始新分块  
                if len(part) > max_size:  
                    # 如果这部分太大,递归处理  
                    chunks.extend(split_text(part, max_size, sep_index + 1))  
                    current_chunk = ""
                else:  
                    current_chunk = part  

        # 添加最后一个分块  
        if current_chunk:  
            if len(current_chunk) > max_size:  
                chunks.extend(split_text(current_chunk, max_size, sep_index + 1))  
            else:  
                chunks.append(current_chunk)  

        return chunks  

    return split_text(text, max_chunk_size)  

# 使用示例  
text = """这是第一段内容,包含了关于人工智能技术发展的详细介绍。  

这是第二段内容,讨论了机器学习在各个领域的应用。这段内容比较长,可能需要进一步分割。  

这是第三段的短内容。  

这是第四段非常长的内容,包含了大量的技术细节和实现方案,需要详细说明深度学习、自然语言处理、计算机视觉等多个技术领域的最新进展。"""

chunks = recursive_chunking(text, max_chunk_size=100)  
for i, chunk in enumerate(chunks):  
    print(f"递归分块 {i+1} (长度: {len(chunk)}): {chunk[:50]}...")

18. 嵌入分块

嵌入分块方法改变了传统的"先分块后嵌入"流程,而是首先对所有句子进行嵌入向量计算,然后按照向量相似性进行顺序聚合,只有当相似性低于预设阈值时才进行分割。**适用场景:**该方法适用于缺乏明确结构标记(如句子边界、标题、章节标记等)的文档,当传统的滑动窗口分块等方法效果不佳时,该方法能够提供更好的语义连贯性。

19. 智能代理分块

智能代理分块方法将分块决策完全委托给大语言模型,利用其语言理解能力来判断最优的分块边界。**适用场景:**该方法适用于内容复杂或结构不规整的文档,需要类似人类的判断能力来确定合理的分块边界。需要注意的是,该方法可能产生较高的计算成本和资源消耗。

20. 层次分块

层次分块方法在多个粒度级别上进行文本分割,如章节、子章节和段落等,使用户能够在不同的详细程度上进行信息检索。

图片

**适用场景:**该方法适用于具有清晰层次结构的文档,如技术文章、操作手册、教科书或研究论文等。它能够支持用户在保持上下文连贯性的同时,灵活地获取概览信息和详细内容。

21. 模态感知分块

模态感知分块方法针对不同类型的内容(文本、图像、表格等)采用专门的处理策略,确保每种模态的信息都得到适当的处理和保存。

图片

模态感知分块示例**适用场景:**该方法适用于多模态文档,能够根据不同内容类型的特点进行针对性处理,确保信息的完整性和准确性。

混合分块策略

混合分块策略结合多种分块方法、启发式规则、嵌入技术和大语言模型等技术手段,以获得更加稳定和可靠的分块效果。**适用场景:**当单一分块方法无法完全满足数据特点和应用需求时,混合策略通过综合运用多种技术来实现更好的整体性能。代码实现:

上下滑动查看更多源码
import re  
from typing import List, Dict, Any  

classHybridChunker:
    """混合分块器,结合多种分块策略"""

    def__init__(self, max_chunk_size=1000, overlap_size=100):
        self.max_chunk_size = max_chunk_size  
        self.overlap_size = overlap_size  

    defdetect_content_type(self, text: str) -> str:
        """检测内容类型"""
        # 检测是否包含代码  
        if re.search(r'```|def |class |import ', text):  
            return'code'

        # 检测是否包含表格标记  
        if'|'in text and text.count('|') > 5:  
            return'table'

        # 检测是否包含列表  
        if re.search(r'^\s*[-*+]\s', text, re.MULTILINE):  
            return'list'

        # 检测是否包含标题结构  
        if re.search(r'^#+\s', text, re.MULTILINE):  
            return'structured'

        return'plain_text'

    defchunk_by_content_type(self, text: str, content_type: str) -> List[str]:
        """根据内容类型选择分块策略"""

        if content_type == 'code':  
            return self._chunk_code(text)  
        elif content_type == 'table':  
            return self._chunk_table(text)  
        elif content_type == 'list':  
            return self._chunk_list(text)  
        elif content_type == 'structured':  
            return self._chunk_structured(text)  
        else:  
            return self._chunk_plain_text(text)  

    def_chunk_code(self, text: str) -> List[str]:
        """代码分块策略"""
        # 按代码块分割  
        code_blocks = re.split(r'```[\s\S]*?```', text)  
        chunks = []  
        for block in code_blocks:  
            if len(block) > self.max_chunk_size:  
                # 按函数或类分割  
                parts = re.split(r'\n(?=def |class )', block)  
                chunks.extend(parts)  
            else:  
                chunks.append(block)  
        return [chunk.strip() for chunk in chunks if chunk.strip()]  

    def_chunk_table(self, text: str) -> List[str]:
        """表格分块策略"""
        lines = text.split('\n')  
        chunks = []  
        current_chunk = []  

        for line in lines:  
            if'|'in line:  
                current_chunk.append(line)  
            else:  
                if current_chunk:  
                    chunks.append('\n'.join(current_chunk))  
                    current_chunk = []  
                if line.strip():  
                    chunks.append(line)  

        if current_chunk:  
            chunks.append('\n'.join(current_chunk))  

        return chunks  

    def_chunk_list(self, text: str) -> List[str]:
        """列表分块策略"""
        # 按列表项分组  
        items = re.split(r'\n(?=\s*[-*+]\s)', text)  
        chunks = []  
        current_chunk = ""

        for item in items:  
            if len(current_chunk + item) > self.max_chunk_size:  
                if current_chunk:  
                    chunks.append(current_chunk.strip())  
                current_chunk = item  
            else:  
                current_chunk += '\n' + item if current_chunk else item  

        if current_chunk:  
            chunks.append(current_chunk.strip())  

        return chunks  

    def_chunk_structured(self, text: str) -> List[str]:
        """结构化文档分块策略"""
        # 按标题分割  
        sections = re.split(r'\n(?=#+\s)', text)  
        chunks = []  

        for section in sections:  
            if len(section) > self.max_chunk_size:  
                # 进一步按段落分割  
                paragraphs = section.split('\n\n')  
                current_chunk = ""

                for para in paragraphs:  
                    if len(current_chunk + para) > self.max_chunk_size:  
                        if current_chunk:  
                            chunks.append(current_chunk.strip())  
                        current_chunk = para  
                    else:  
                        current_chunk += '\n\n' + para if current_chunk else para  

                if current_chunk:  
                    chunks.append(current_chunk.strip())  
            else:  
                chunks.append(section.strip())  

        return [chunk for chunk in chunks if chunk]  

    def_chunk_plain_text(self, text: str) -> List[str]:
        """纯文本分块策略"""
        # 结合段落和句子分块  
        paragraphs = text.split('\n\n')  
        chunks = []  
        current_chunk = ""

        for para in paragraphs:  
            if len(current_chunk + para) > self.max_chunk_size:  
                if current_chunk:  
                    chunks.append(current_chunk.strip())  

                # 如果单个段落过长,按句子分割  
                if len(para) > self.max_chunk_size:  
                    sentences = re.split(r'[.!?。!?]+', para)  
                    temp_chunk = ""
                    for sent in sentences:  
                        if len(temp_chunk + sent) > self.max_chunk_size:  
                            if temp_chunk:  
                                chunks.append(temp_chunk.strip() + '。')  
                            temp_chunk = sent  
                        else:  
                            temp_chunk += sent + '。'if temp_chunk else sent  

                    if temp_chunk:  
                        current_chunk = temp_chunk  
                    else:  
                        current_chunk = ""
                else:  
                    current_chunk = para  
            else:  
                current_chunk += '\n\n' + para if current_chunk else para  

        if current_chunk:  
            chunks.append(current_chunk.strip())  

        return chunks  

    defchunk(self, text: str) -> List[Dict[str, Any]]:
        """主分块方法"""
        content_type = self.detect_content_type(text)  
        chunks = self.chunk_by_content_type(text, content_type)  

        # 为每个分块添加元数据  
        result = []  
        for i, chunk in enumerate(chunks):  
            result.append({  
                'id': i,  
                'content': chunk,  
                'content_type': content_type,  
                'length': len(chunk)  
            })  

        return result  

# 使用示例  
text = """# 人工智能技术概述  

人工智能技术包括多个领域:  

- 机器学习  
- 深度学习    
- 自然语言处理  
- 计算机视觉  

## 代码示例  

def train_model(data):  
    model = create_model()  
    model.fit(data)  
    return model  


这是一个简单的模型训练函数。"""

chunker = HybridChunker(max_chunk_size=200)  
chunks = chunker.chunk(text)  

for chunk in chunks:  
    print(f"分块 {chunk['id']} ({chunk['content_type']}, {chunk['length']} 字符):")  
    print(f"{chunk['content'][:100]}...")  
    print("-" * 50)

总结

本文介绍了多种文本分块方法,包括固定大小分块、滑动窗口分块、基于句子和段落的分块等。每种方法都有其适用场景和实现方式,用户可以根据具体需求选择合适的分块策略。此外,还介绍了混合分块策略,结合多种方法以获得更好的效果。通过这些方法,用户可以有效地处理长文本数据,提高信息检索和处理的效率。希望本文能为文本处理和信息检索领域的研究和应用提供有价值的参考。

普通人如何抓住AI大模型的风口?

领取方式在文末

为什么要学习大模型?

目前AI大模型的技术岗位与能力培养随着人工智能技术的迅速发展和应用 , 大模型作为其中的重要组成部分 , 正逐渐成为推动人工智能发展的重要引擎 。大模型以其强大的数据处理和模式识别能力, 广泛应用于自然语言处理 、计算机视觉 、 智能推荐等领域 ,为各行各业带来了革命性的改变和机遇 。

目前,开源人工智能大模型已应用于医疗、政务、法律、汽车、娱乐、金融、互联网、教育、制造业、企业服务等多个场景,其中,应用于金融、企业服务、制造业和法律领域的大模型在本次调研中占比超过 30%。
在这里插入图片描述

随着AI大模型技术的迅速发展,相关岗位的需求也日益增加。大模型产业链催生了一批高薪新职业:
在这里插入图片描述

人工智能大潮已来,不加入就可能被淘汰。如果你是技术人,尤其是互联网从业者,现在就开始学习AI大模型技术,真的是给你的人生一个重要建议!

最后

只要你真心想学习AI大模型技术,这份精心整理的学习资料我愿意无偿分享给你,但是想学技术去乱搞的人别来找我!

在当前这个人工智能高速发展的时代,AI大模型正在深刻改变各行各业。我国对高水平AI人才的需求也日益增长,真正懂技术、能落地的人才依旧紧缺。我也希望通过这份资料,能够帮助更多有志于AI领域的朋友入门并深入学习。

真诚无偿分享!!!
vx扫描下方二维码即可
加上后会一个个给大家发

在这里插入图片描述

大模型全套学习资料展示

自我们与MoPaaS魔泊云合作以来,我们不断打磨课程体系与技术内容,在细节上精益求精,同时在技术层面也新增了许多前沿且实用的内容,力求为大家带来更系统、更实战、更落地的大模型学习体验。

图片

希望这份系统、实用的大模型学习路径,能够帮助你从零入门,进阶到实战,真正掌握AI时代的核心技能!

01 教学内容

图片

  • 从零到精通完整闭环:【基础理论 →RAG开发 → Agent设计 → 模型微调与私有化部署调→热门技术】5大模块,内容比传统教材更贴近企业实战!

  • 大量真实项目案例: 带你亲自上手搞数据清洗、模型调优这些硬核操作,把课本知识变成真本事‌!

02适学人群

应届毕业生‌: 无工作经验但想要系统学习AI大模型技术,期待通过实战项目掌握核心技术。

零基础转型‌: 非技术背景但关注AI应用场景,计划通过低代码工具实现“AI+行业”跨界‌。

业务赋能突破瓶颈: 传统开发者(Java/前端等)学习Transformer架构与LangChain框架,向AI全栈工程师转型‌。

image.png

vx扫描下方二维码即可
在这里插入图片描述

本教程比较珍贵,仅限大家自行学习,不要传播!更严禁商用!

03 入门到进阶学习路线图

大模型学习路线图,整体分为5个大的阶段:
图片

04 视频和书籍PDF合集

图片

从0到掌握主流大模型技术视频教程(涵盖模型训练、微调、RAG、LangChain、Agent开发等实战方向)

图片

新手必备的大模型学习PDF书单来了!全是硬核知识,帮你少走弯路(不吹牛,真有用)
图片

05 行业报告+白皮书合集

收集70+报告与白皮书,了解行业最新动态!
图片

06 90+份面试题/经验

AI大模型岗位面试经验总结(谁学技术不是为了赚$呢,找个好的岗位很重要)图片
在这里插入图片描述

07 deepseek部署包+技巧大全

在这里插入图片描述

由于篇幅有限

只展示部分资料

并且还在持续更新中…

真诚无偿分享!!!
vx扫描下方二维码即可
加上后会一个个给大家发

在这里插入图片描述

AI数据技术02:RAG数据检索 ​ 在人工智能的动态环境中,检索增强生成(RAG)已成为游戏规则的改变者,彻底改变了我们生成文本和与文本交互的方式。RAG 使用大型语言模型(LLM) 等工具将信息检索的强大功能与自然语言生成无缝结合,为内容创建提供了一种变革性的方法。 ​ 阅读详情

相关推荐

openclaw + ollama本地模型 + 飞书平台 windows平台部署教程

本教程将指导您在 Windows 10/11 环境下,通过 Ollama 运行本地模型,并结合 OpenClaw 接入飞书,搭建一个完全本地化的 AI 助手。

专注于技术研发行业技术主要有AI人工智能视觉识别、物联网技术、电商平台、app原生技术、微信小程序、鸿蒙语言开发、办公企业oa、ERP等,致力于做东半球最优秀的程序员 2178

RAG的5种文本分块策略#Text Splitting

你是否曾经尝试将一段很长的文本输入ChatGPT,却被告知文本太长了?或者你是否试图让你的应用程序具有更好的长期记忆,但效果还不够好?提高大语言模型性能的一个有效的策略是将大型数据分割成较小的部分。这个过程被称为分割或分块(Text Splitting)。在这个教程中,介绍了文本分割的5种方法。我阅读后做了些精简,分享给大家,原文可以文末查看原链接。Text Splitting文本分割的方法方法...

shadowcz007的博客 1万+

BCIC IV 2a数据集实战:从MATLAB导入到EEG信号分析全流程

本文提供了BCIC IV 2a数据集从MATLAB导入到EEG信号分析的完整实战流程。详细解析了数据集结构,区分了EEG与EOG信号,并演示了信号可视化、基础预处理(滤波、分段、基线校正)等关键步骤,帮助脑机接口研究者快速上手处理这一经典运动想象数据集。

weixin_29047919的博客 473

小白也能懂|RAG中的5种分块方式及其适用场景总结

RAG通过结合检索与生成技术,依赖其高效检索算法、多模态融合能力及系统级优化,解决了基础大模型在企业内部应用的局限性,例如通过RAG技术对接企业内部知识库,支持知识动态更新与实时交互,显著降低了大模型的幻觉风险,无需微调训练模型,低成本适配企业垂直领域的应用场景,在数据安全与可控性方面,可加入权限控制逻辑,确保敏感信息仅在授权范围内使用,同时通过引用标注实现可追溯性。

2401_85375186的博客 1393

STM32L433使用DSP库配置过程

STM32L433中有FPU,在使用中为了使用其中的部分函数,需要对其进行配置。     配置成功后做些总结,留待后续复习备忘,同时也希望有朋友像我一样使用DSP库配置时少走弯路,留作交流。

在在在的博客 4553

(2024,DDPM,DDIM,流匹配,SDE,ODE)扩散:基础教程

本文的目标是尽可能简单地教授扩散。第一节介绍扩散的基本原理。第二节和第三节展示如何构建随机和确定性扩散采样器。第四部分介绍了密切相关的流匹配,可看作是扩散的推广。​第五节,强调实践中最重要的一些设计选择,包括采样器、噪声时间表和参数化方法。

qq_44681809的博客 1万+

高级检索增强生成技术(RAG)全面指南:原理、分块、编码、索引、微调、Agent、展望

如果我们使用多个源来生成答案,要么是由于初始查询的复杂性(我们必须执行多个子查询,然后将检索到的上下文合并到一个答案中),要么是因为我们在各种文档中找到了单个查询的相关上下文,问题是我们是否能够准确地回溯我们的来源。显然,尽管OpenAI是LLM提供商的市场领导者,但仍有许多替代方案,例如Anthropic的Claude、最近流行的较小但功能强大的模型,例如Mixtral形式的Mistral、Microsoft的Phi-2以及许多开源选项,例如Llama2、OpenLLaMA、Falcon。

人工智能讲师分享前沿技术 9837

把 SAP Query 用到极致:ABAP Query 的核心概念、配置流程、权限与运输治理全解析

摘要:SAP Query 是一款面向业务用户的自助报表工具,可解决标准报表无法满足业务需求的问题。其核心由四大组件构成:Queries(报表定义)、InfoSets(数据视图)、User Groups(权限分组)和Translation(多语言支持)。通过SQ03、SQ02、SQ01事务码分步创建用户组、数据视图和查询,业务用户无需ABAP知识即可生成Basic List(明细)、Statistics(统计)和Ranked List(排名)三种报表形式。典型案例展示了如何为采购部门设计包含明细追溯和Top1

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 182

构建高效RAG系统:21种文本分块策略全解析,程序员必备收藏指南

本文详解RAG系统中的21种文本分块策略,从基础方法(换行符分割、固定大小分块)到高级技术(语义分块、智能代理分块),分析各策略适用场景与实现方式。强调分块策略对RAG系统性能的关键影响,为开发者构建可靠RAG系统提供全面指导。

2301_77193447的博客 883

python中使用squarify包可视化treemap图:为treemap图添加标题并自定义标题的字体大小、自定义设置treemap中标签字体的大小、添加数值数值标签、自定义设置边框的色彩

python中使用squarify包可视化treemap图:treemap将分层数据显示为一组嵌套矩形自定义设置每一个数据格的颜色、添加数值数值标签、自定义设置边框的色彩、自定义设置边框线条的粗细、为treemap图添加标题并自定义标题的字体大小、自定义设置treemap中标签字体的大小

data+scenario+science+insight 1066

打造AI智能体员工,我用扣子复刻了华与华、奥美和金枪大叔

这事说穿了,就是你用多个AI智能体,分别扮演专业角色,构成一支能力互补、各司其职的“数字团队”。每个智能体,都有明确的角色设定、任务边界和接口形式。它不再是一个泛泛的ChatGPT,而是你手下的“品牌顾问”、“策略专家”、“文案大神”、“短视频导演”、“运营总监”。简单来说,你不再是雇一个人,而是养一群机器人打工——24小时不摸鱼,不请假,不离职。如果你是个人创业者、内容创作者、培训机构、中小企业主,其实都可以尝试构建属于你自己的“AI虚拟员工矩阵”。

互联网架构师笔记 1499

大模型RAG必学:7种分块策略全解析,从入门到实战,建议收藏!

AI中的分块是指将大型文档分割成称为“chunk”的较小片段。这些片段可以是段落、句子、词组或受token限制的片段,这使得模型能更轻松地仅搜索和检索所需内容。这种分块技术对于优化检索增强生成(RAG)的性能至关重要。如何开始?可以从512 tokens 搭配 10-15%的重叠率开始。如何优化?调试参数,多使用递归分块和句子分块,语义分块还是不够优秀。如何测评?上号 chunking_evaluation有和方法论?

AI大模型的博客 1216

(数字图像处理MATLAB+Python)第五章图像增强-第一节:图像增强概述和基于灰度级变换的图像增强

图像增强(Image Enhancement):指不考虑图像降质原因,利用各种数学方法和变换手段,增强图像中人们感兴趣部分或提高有用的图像特征的清晰度。从图像质量来看,图像增强提高了图像的可懂度,改善了图像的视觉效果例如在现实场景中,针对那些对比度较差、视觉效果不好的图像,我们就可以利用图像增强改善视觉质量图像增强可分为如下几种基于灰度级变换的图像增强基于直方图修正的图像增强基于照度反射模型的图像增强基于模糊技术的图像增强基于伪彩色处理的图像增强其他图像增强方法分段线性灰度级变换。

快乐江湖的博客 3335

收藏级|RAG技术成败关键!21种分块策略详解(小白/程序员必学)

对于RAG技术而言,分块(Chunking)从来不是“无关紧要的技术细节”,而是直接决定RAG系统成败的核心变量——选对分块策略,能大幅减少模型“不知道”和幻觉生成的问题,降低后续调试成本;选错策略,再怎么优化嵌入、检索、Prompt都是徒劳。🚀 对于小白:优先从“朴素分块、句子分块、固定窗口分块”入手,练手熟悉后,再尝试滑动窗口、混合分块,逐步提升;🚀 对于程序员:可根据项目数据类型、业务需求,灵活组合2-3种分块方法,搭建混合分块系统,兼顾效率和精度。

xxue345678的博客 1225

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

【必收藏】RAG分块技术全解析:5种企业级大模型应用落地方法

本文详细介绍了RAG架构中关键的文档分块技术,包括固定大小分块、语义分块、递归分块、基于文档结构分块和基于LLM分块五种方法。分析了每种技术的原理、优缺点及适用场景。语义分块在多数情况下效果最佳,但最终选择需根据内容性质、嵌入模型能力和计算资源等因素综合考量。正确选择分块技术对提高RAG系统检索准确性和生成回答质量至关重要。

优快云_224022的博客 1926

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

RAG系统灵魂技术:文本分块全解析,程序员必学+收藏指南

文本分块是RAG系统的核心技术,通过将长文档切分为语义上有意义的单元,降低检索噪声,减少AI幻觉,缓解上下文丢失问题。文章介绍了五种主流分块策略(固定大小、语义、滑动窗口、反向、Agentic分块),并探讨了如何根据内容结构、查询类型等因素选择合适策略。良好的分块设计能显著提升RAG系统的检索准确性和响应质量,是企业级应用的关键环节。

2401_85325726的博客 977

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

RAG系统构建必看:8种文本分块策略全解析,收藏备用!

本文系统介绍了RAG系统中的8种文本分块策略,包括基础固定分块、递归分块、文档结构分块、语义分块等,分析各自优缺点及适用场景。文章指出分块策略选择需权衡计算成本、检索速度与回答质量,建议根据数据类型混合使用多种策略。后文转向AI就业趋势分析,强调大模型技术带来的新兴岗位机会,并提供包含学习路线、视频教程、实战项目等在内的大模型全套学习资源包,帮助读者掌握大模型技术抓住AI时代机遇。

ytt0523_com的博客 1040

大模型RAG系统分块技术详解:从原理到实战(小白也能学会,建议收藏)

RAG技术通过检索与生成结合解决大模型在企业应用中的局限,分块策略是核心环节。文章分析RAG分块面临的准确性、召回率和复杂文档解析三大问题,详细介绍五种分块策略的原理、优缺点及适用场景,提供选择建议。针对知识关联缺失、多模态理解不足等挑战,提出混合检索、查询扩展等前沿解决方案,为构建高效可靠的RAG系统提供技术指导。

2401_85325726的博客 978

【必学收藏】8种大模型RAG系统文本分块策略,小白也能轻松掌握!

文章详细介绍了8种RAG系统中的高级文本分块策略,包括滑动窗口、自适应、基于实体、混合、任务感知、HTML/XML标签、代码AST拆分和正则表达式分块。这些策略针对不同场景和需求,如保留跨边界上下文、处理结构化文档、构建知识库等。文章强调好的分块策略需综合考虑内容类型、任务类型和文档结构,选择或组合合适方法,以提升RAG系统效果。掌握这些策略并结合具体场景实验,能显著提升系统性能。

2401_85375186的博客 1104

RAG 分块策略全景对比:五大主流方案深度解析与选型指南

分块是 RAG 系统中最基础也最容易被低估的环节。它不像模型调优、提示工程那样“性感”,但分块策略的优劣,直接决定了向量检索的精度上限——再好的嵌入模型、再先进的重排序算法,都无法从根本上弥补分块不当带来的信息丢失或噪音引入。固定大小分块适合快速验证递归分块在保持语义完整性上更有优势语义分块精度最高但成本也最高结构化分块对特定类型文档效果最好延迟分块是计算资源充足时的高级玩法没有哪种方法是银弹,实际项目需要根据文档类型、查询特点、资源限制来组合使用。先设计好分块策略,再谈模型选型和优化。

✨ 欢迎来到【Seal ^_^ 的优快云博客】!✨ 451

收藏级干货!RAG五大分块策略全解析:从原理到落地,搞定大模型检索效率瓶颈

分块策略优点缺点适用场景固定大小分块实现简单,资源高效语义断裂,信息冗余快速处理非结构化文本语义分块语义完整,检索精准计算复杂,依赖阈值高精度问答、复杂文档递归分块灵活适应长文档,保留结构块大小不均,逻辑断裂风险长篇技术文档、企业报告基于结构的分块逻辑清晰,检索高效依赖格式标准化,预处理复杂结构化文档(论文、白皮书)基于LLM的分块高度智能,适应非结构化文本计算成本高,决策过程不可控非结构化内容、跨领域整合4、RAG分块策略选择建议。

weixin_59191169的博客 1101

【必学收藏】一文掌握RAG分块新范式:Max-Min语义分块技术深度解析

Max-Min语义分块颠覆传统"先分块再Embedding"流程,采用"先Embedding再分块"的动态语义驱动方法,通过计算句子间相似度实现智能分块,有效平衡检索精度与上下文完整性。该方法轻量化且资源复用高效,但存在长距离上下文依赖问题。未来RAG分块将向多策略融合方向发展,开发者需根据数据特点选择适配策略以提升系统性能。

2401_85373691的博客 1194

【收藏必备】大模型RAG应用核心:一文搞懂文本分块技术与最佳实践

本文详细介绍了RAG应用中的文本分块技术,强调其对检索相关性、效率、生成质量及系统灵活性的关键影响。文章分析了文本分块的重要性,包括精准匹配用户需求、降低计算成本、为LLM提供精准上下文以及突破上下文窗口限制等。同时,系统介绍了多种分块策略(如TokenTextSplitter、SentenceSplitter、固定长度分块等),并分析了各自的适用场景和优缺点,为开发者提供了实用的技术指导和最佳实践参考。 ---

Android_XG的博客 951

【必收藏】文本分块:RAG系统的核心技术,小白也能掌握的大模型优化指南

本文详细介绍了文本分块技术在RAG系统中的关键作用,包括其定义、必要性及多种分块策略(固定尺寸、语义分块、智能体驱动等)。文章强调文本分块直接影响检索准确性和系统性能,需遵循语义连贯性、上下文完整性和计算效率三大原则。不存在适用于所有场景的"万能方法",最佳分块策略应根据内容类型、查询复杂度和模型能力灵活选择,并通过持续迭代优化系统表现。

2401_85375186的博客 1028

RAG 中的分块技术深度解析:检索精度的第一道分水岭

分块(Chunking)是指将长文档或大量文本数据切分成更小的、语义相对独立的文本片段(Chunk)的过程。在 RAG 系统中,这些文本块是后续向量化、索引建立和检索的基本单位。可以将分块理解为一个“拼图制作”过程:原始文档是一幅完整的图像,分块就是将其切割成若干小块。每一块都是一个独立的检索单元,用户查询时,系统拼的不是整幅图,而是找与查询最匹配的几个小块,再组合起来呈现给 LLM。分块是 RAG 系统中最基础也最容易被低估的环节。它不像模型调优、提示工程那样“性感”,但。

✨ 欢迎来到【Seal ^_^ 的优快云博客】!✨ 417

【必学收藏】提升大模型RAG系统性能:9种文本分块策略全解析

文本分块是将大型文档分解为可管理处理单元的结构化过程。该过程的目标是将文档重新组织为多个部分,使RAG系统能够根据输入查询高效检索最相关的内容片段。RAG系统的工作机制是在推理阶段对查询进行嵌入编码,然后从向量数据库中检索前k个最相关的文本块。这些文本块作为上下文信息提供给生成模型,以产生准确且相关的响应。文本块的粒度可以从句子级别扩展到段落或章节级别,具体取决于应用场景和所采用的分割规则。这些规则构成了我们所说的分块策略。目前存在多种分块策略,每种策略都有其特定的优势和限制条件。

python12345_的博客 935
上一篇: 【大模型必备】向量数据库入门指南:从踩坑到精通,一篇讲透(建议收藏)
下一篇: 【建议收藏】AI产品经理学习路径全解析:顺序错了,努力全白费!
不秃头de程序猿
博客等级 码龄5年 4091粉丝 1479原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值