Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Sadalīšana fragmentos: jūsu dokumentu inteliģenta sadalīšana

Nodarbība 12 no 22 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Mērķi
  2. Kāpēc sadalīt dokumentus?
  3. 1. stratēģija: fiksēta izmēra fragmenti
  4. 2. stratēģija: sadalīšana pēc atdalītājiemem
  5. 3. stratēģija: Markdown sadaļu sadalīšana
  6. 4. stratēģija: semantiskā sadalīšana
  7. Fragmentu bagātināšana ar kontekstu
  8. Kādu fragmenta izmēru izvēlēties?
  9. Galvenās atziņas

Mērķi

  • Saprast, kāpēc sadalīšana fragmentos ir kritiska RAG kvalitātei
  • Apgūt dažādas sadalīšanas stratēģijas
  • Izvēlēties pareizo fragmenta izmēru un pārklājumu

Kāpēc sadalīt dokumentus?

Iegulšanas (embedding) modeļiem ir tokenu limits: OpenAI gadījumā tas ir 8191. Šis limits ir pirmais iemesls dokumentu sadalīšanai, taču tas nav pats svarīgākais. Pat dokuments, kas ir ievērojami zem šī griesta, sniedz sliktus rezultātus, ja to kodē kā vienu bloku, jo iegūtais vektors vidēji aptver visu saturu un zaudē detaļas. Paņem piemēram 40 lappušu HR rokasgrāmatu, kas aptver atvaļinājumu politiku, attālinātu darbu, izdevumu atskaites un veselības apdrošināšanu: tās vienīgais iegulums (embedding) patiesībā neatbilst nevienai no šīm četrām tēmām, un meklēšanas vaicājums „cik daudz atvaļinājuma dienu” to ierindos zemāk nekā daudz īsāku, bet daudz mērķtiecīgāku dokumentu.

Sadalīšana fragmentos atrisina šo problēmu, sadalot dokumentu loģiskās daļās, kur katra aptver konkrētu ideju vai rindkopu. Tas ir solis, kurā RAG cauruļvads iegūst vai zaudē visvairāk kvalitātes — pat pirms tu izvēlies iegulšanas modeli.

1. stratēģija: fiksēta izmēra fragmenti

Vienkāršākā metode saskaita vārdus un griež regulāros intervālos. Tā pilnībā ignorē teksta struktūru, padarot to brutālu, taču tai pietiek ar trim koda rindiņām, un tā kalpo kā būtisks bāzes līmenis: jebkurai sarežģītākai stratēģijai ir jāpierāda, ka tā darbojas labāk par šo.

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")

Parametrs overlap (pārklājums) ir pelnījis uzmanību. Bez pārklājuma griezums agrāk vai vēlāk trāpīs paskaidrojuma vidū: teikums „brīdinājuma termiņš ir trīs mēneši” nonāk vienā fragmentā, bet „izņemot pārbaudes laiku” — nākamajā. Neviens no tiem neatbild uz jautājumu pareizi, un otrais pat ir maldinošs. Pārklājot fragmentus par 10–20% no to izmēra, tu garantē, ka katra ideja vismaz vienreiz eksistē neskarta kaut kur indeksā. Tas ir labs sākumpunkts; vēlāk to vari pielāgot, ņemot vērā dokumenta blīvumu.

2. stratēģija: sadalīšana pēc atdalītājiemem

Tā vietā, lai grieztu vārdu pa vārdam, tu vari ievērot teksta dabiskās robežas. Ideja ir vispirms izmēģināt spēcīgāko atdalītāju — dubulto rindas pārtraukumu, kas atdala divas rindkopas — un pēc tam virzīties uz leju pie progressively vājākiem atdalītājiem, kamēr iegūtais gabals pārsniedz maksimālo izmēru. Tādējādi emuāra ieraksts tiks sadalīts rindkopās, un tikai milzīga rindkopa tiks sadalīta teikumos.

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. stratēģija: Markdown sadaļu sadalīšana

Ja tava korpusa pamatā ir strukturēta dokumentācija, virsraksti jau ir paveikuši darbu tavā vietā: autors jau ir norobežojis nozīmes vienības. Sadalīšana pie # un ## virsrakstu līmeņiem rada fragmentus, kas precīzi atbilst sadaļām, un tālāk minētā funkcija saglabā virsrakstu kopā ar tekstu, ko tūlīt pēc tam izmantosim bagātināšanai.

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. stratēģija: semantiskā sadalīšana

Tekstam bez skaidras struktūras — sanāksmes kopsavilkums, zvana transkripts — nedz izmērs, nedz atdalītāji nezina, kur tēma mainās. To zina iegulšanas (embeddings). Tu kodē katru teikumu, salīdzini katru teikumu ar iepriekšējo un veic griezienu tur, kur līdzība sabrūk: tieši tur runātājs pārgāja no budžeta uz personāla atlasi. Ņem vērā, ka šeit pietiek ar text-embedding-3-small, jo tu nemeklē absolūtu precizitāti, bet gan relatīvu pārtraukumu.

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

Fragmentu bagātināšana ar kontekstu

Atsevišķs fragments bieži zaudē informāciju, kas padarīja to interpretējamu. „Ilgs trīs gadus” neko nenozīmē, ja lasītājs — vai iegulšanas modelis — nezina, ka tas ir no ražotāja garantijas nodaļas. Katra fragmenta priekšā pievienojot dokumenta nosaukumu un sadaļas nosaukumu, tu atjauno šo kontekstu tieši pašā vektorā, un meklēšana pēc „garantijas ilgums” tad atradīs šo fragmentu.

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}"

Kādu fragmenta izmēru izvēlēties?

Izvēle ir kompromiss starp precizitāti un kontekstu: īss fragments mērķē smalki, bet ir amputēts, savukārt garš fragments saprot visu, bet atšķaida signālu.

Izmērs (tokeni)PriekšrocībasTrūkumi
100–200Ļoti precīzs, laba granularitāteZaudē kontekstu
300–500Labs kompromissStandarta
500–1000Bagāts kontekstsMazāk precīzs, dārgs
1000+Maksimāls kontekstsAtšķaida informāciju

Nav universālas vērtības: ideālais izmērs ir atkarīgs no taviem dokumentiem un vaicājumiem. Vienīgā uzticamā metode ir indeksēt to pašu korpusu ar diviem vai trim izmēriem un pēc tam veikt mērījumus, izmantojot 10. nodarbības metrikas reālu jautājumu kopai. Atbalsta zināšanu bāze, kas sastāv no īsām atbildēm, pieļauj 200 tokenus; juridisks korpuss prasīs 800.

Galvenās atziņas

  • Sadalīšana fragmentos ir visietekmīgākais solis RAG cauruļvadā
  • Izmanto fiksētu izmēru kā bāzes līmeni, atdalītājus — lai ievērotu struktūru
  • Semantiskā sadalīšana automātiski nosaka tēmu maiņu
  • Pārklājums un kontekstuāla bagātināšana uzlabo kvalitāti
  • Testē dažādus izmērus un veic mērījumus ar meklēšanas metrikām