Премини към основното съдържание
Български— Изберете език
Меню

Разделяне на части: Интелигентно разбиване на документите

Урок 12 от 22 Обновен 29 юли 2026 г. Програмист
На тази страница
  1. Цели
  2. Защо да разделяме документите?
  3. Стратегия 1: Разбиване с фиксиран размер
  4. Стратегия 2: Разбиване базирано на разделители
  5. Стратегия 3: Разбиване на Markdown секции
  6. Стратегия 4: Семантично разбиване
  7. Обогатяване на частите с контекст
  8. Какъв размер на частта да изберете?
  9. Ключови изводи

Цели

  • Да разберете защо разделянето на части (chunking) е критично за качеството на RAG
  • Да овладеете различни стратегии за разбиване
  • Да изберете правилния размер на частта и припокриване

Защо да разделяме документите?

Моделите за вграждане (embedding) имат лимит на токени: 8191 за OpenAI. Този лимит е първата причина за разбиване на документите, но не е най-важната. Дори документ, значително под този таван, дава лоши резултати, когато се кодира като един блок, защото полученият вектор осреднява цялото съдържание и губи детайлите. Вземете например 40-страничен наръчник за човешки ресурси, обхващащ политики за отпуски, работа от разстояние, отчети за разходи и здравно осигуряване: неговото единично вграждане не прилича истински на нито една от тези четири теми, а търсенето на „колко дни отпуск“ ще го класира под много по-къс, но далеч по-целеви документ.

Разделянето на части решава този проблем, като разбива документа на свързани парчета, всяко от които улавя конкретна идея или параграф. Това е стъпката, при която RAG конвейерът печели или губи най-много качество – още преди да изберете модел за вграждане.

Стратегия 1: Разбиване с фиксиран размер

Най-простият метод брои думите и реже на редовни интервали. Той напълно игнорира структурата на текста, което го прави брутален, но се нуждае само от три реда код и служи като съществена базова линия: всяка по-усъвършенствана стратегия трябва да докаже, че работи по-добре от тази.

def chunker_fixed_size(
    text: str,
    size: int = 500,
    overlap: int = 100
) -> list[str]:
    """Splits text into fixed-size chunks with overlap."""
    words = text.split()
    chunks = []

    for i in range(0, len(words), size - overlap):
        chunk = " ".join(words[i:i + size])
        if chunk.strip():
            chunks.append(chunk)

    return chunks

long_text = "A very long document... " * 500
chunks = chunker_fixed_size(long_text, size=300, overlap=50)
print(f"{len(chunks)} chunks generated")

Параметърът overlap заслужава внимание. Без припокриване, разрезът рано или късно ще падне по средата на обяснение: изречението „срокът за уведомяване е три месеца“ попада в една част, а „с изключение на изпитателния срок“ – в следващата. Нито едното, нито другото отговаря правилно на въпроса, а второто дори подвежда. Чрез припокриване на частите с 10–20% от техния размер, гарантирате, че всяка идея съществува непокътната поне веднъж някъде в индекса. Това е добра отправна точка; коригирайте я по-късно въз основа на плътността на вашите документи.

Стратегия 2: Разбиване базирано на разделители

Вместо да режете дума по дума, можете да уважите естествените граници на текста. Идеята е да опитате първо най-силния разделител – двойният нов ред, който разделя два параграфа – след което да преминете надолу към прогресивно по-слаби разделители, стига полученият кусок да надвишава максималния размер. Така един блог пост ще бъде разделен параграф по параграф, и само един чудовищен параграф ще бъде фрагментиран по изречения.

import re

def chunker_separators(
    text: str,
    separators: list[str] = ["\n\n", "\n", ". ", " "],
    max_size: int = 1000
) -> list[str]:
    """Splits text while respecting natural separators."""
    chunks = []
    current_chunk = ""

    # Split by the strongest separator first
    segments = [text]
    for sep in separators:
        new_segments = []
        for segment in segments:
            parts = segment.split(sep)
            for part in parts:
                if len(part.split()) > max_size:
                    new_segments.append(part)
                else:
                    if (current_chunk and
                        len((current_chunk + sep + part).split()) > max_size):
                        chunks.append(current_chunk.strip())
                        current_chunk = part
                    else:
                        current_chunk = (
                            current_chunk + sep + part
                            if current_chunk else part
                        )
        segments = new_segments

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

    return chunks

Стратегия 3: Разбиване на Markdown секции

Когато вашият корпус се състои от структурирана документация, заглавията вече вършат работата вместо вас: авторът вече е разграничил единиците на смисъл. Разбиването на нивата на заглавията # и ## произвежда части, които съответстват точно на секциите, а функцията по-долу запазва заглавието заедно с текста, което ще използваме веднага след това за обогатяване.

def chunker_markdown(text: str, max_level: int = 2) -> list[dict]:
    """Splits a Markdown document by sections."""
    chunks = []
    current_section = {"title": "", "content": "", "level": 0}

    for line in text.split("\n"):
        # Detect headings
        match = re.match(r"^(#{1,6})\s+(.+)$", line)
        if match:
            level = len(match.group(1))
            title = match.group(2)

            if level <= max_level and current_section["content"].strip():
                chunks.append({
                    "title": current_section["title"],
                    "text": current_section["content"].strip(),
                    "level": current_section["level"]
                })

            if level <= max_level:
                current_section = {
                    "title": title,
                    "content": "",
                    "level": level
                }
            else:
                current_section["content"] += line + "\n"
        else:
            current_section["content"] += line + "\n"

    if current_section["content"].strip():
        chunks.append({
            "title": current_section["title"],
            "text": current_section["content"].strip(),
            "level": current_section["level"]
        })

    return chunks

Стратегия 4: Семантично разбиване

За текст без явна структура – обобщение на среща, транскрипция на разговор – нито размерът, нито разделителите знаят къде се сменя темата. Вгражданията (embeddings) знаят. Кодирате всяко изречение, сравнявате всяко изречение с предишното и режете там, където сходството рухва: точно там говорещият е преминал от бюджет към наемане на персонал. Имайте предвид, че text-embedding-3-small е достатъчен тук, тъй като не търсите абсолютна точност, а относителен разрив.

from openai import OpenAI
import numpy as np

client = OpenAI()

def chunker_semantic(
    text: str,
    similarity_threshold: float = 0.75,
    min_sentence_length: int = 20
) -> list[str]:
    """Groups sentences by semantic similarity."""
    # Split into sentences
    sentences = re.split(r"(?<=[.!?])\s+", text)
    sentences = [s for s in sentences if len(s) > min_sentence_length]

    if len(sentences) <= 1:
        return [text]

    # Embeddings for each sentence
    resp = client.embeddings.create(
        input=sentences,
        model="text-embedding-3-small"  # small is sufficient here
    )
    embs = np.array([d.embedding for d in sorted(resp.data, key=lambda x: x.index)])

    # Find break points
    chunks = []
    chunk_sentences = [sentences[0]]

    for i in range(1, len(sentences)):
        sim = float(np.dot(embs[i], embs[i - 1]))
        if sim < similarity_threshold:
            # Semantic break detected
            chunks.append(" ".join(chunk_sentences))
            chunk_sentences = [sentences[i]]
        else:
            chunk_sentences.append(sentences[i])

    if chunk_sentences:
        chunks.append(" ".join(chunk_sentences))

    return chunks

Обогатяване на частите с контекст

Изолирана част често губи информацията, която я прави разбираема. „Продължителността е три години“ не означава нищо, ако читателят – или моделът за вграждане – не знае, че това е от главата за гаранцията на производителя. Добавянето на префикс към всяка част със заглавието на документа и заглавието на секцията възстановява този контекст директно във самия вектор, и търсенето на „продължителност на гаранцията“ тогава ще открие пасажа.

def enrich_chunk(chunk: str, doc_title: str, section: str = "") -> str:
    """Adds context to the chunk for better embedding."""
    prefix = f"Document: {doc_title}"
    if section:
        prefix += f" | Section: {section}"
    return f"{prefix}\n\n{chunk}"

Какъв размер на частта да изберете?

Изборът включва компромис между точност и контекст: кратката част цели фино, но е ампутирана, докато дългата част разбира всичко, но разрежда сигнала.

Размер (токени)ПредимстваНедостатъци
100–200Много прецизни, добра грануларностГубят контекст
300–500Добър компромисСтандарт
500–1000Богат контекстПо-малко прецизни, скъпи
1000+Максимален контекстРазрежда информацията

Няма универсална стойност: идеалният размер зависи от вашите документи и заявки. Единственият надежден метод е да индексирате един и същи корпус с два или три размера, след което да измерите резултатите, използвайки метриките от урок 10 върху набор от реални въпроси. База знания за поддръжка, съставена от кратки отговори, толерира 200 токена; правен корпус ще изисква 800.

Ключови изводи

  • Разделянето на части е стъпката с най-голямо въздействие в RAG конвейера
  • Използвайте фиксиран размер като базова линия, разделители за уважаване на структурата
  • Семантичното разбиване автоматично открива промени в темата
  • Припокриването и контекстуалното обогатяване подобряват качеството
  • Тествайте различни размери и измервайте с метрики за търсене