Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Razčlenjevanje: Pametno razdeljevanje dokumentov

Lekcija 12 od 22 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Cilji
  2. Zakaj razdeljevati dokumente?
  3. Strategija 1: Razčlenjevanje s fiksno velikostjo
  4. Strategija 2: Razčlenjevanje na podlagi ločil
  5. Strategija 3: Razčlenjevanje po razdelkih Markdown
  6. Strategija 4: Semantično razčlenjevanje
  7. Obogatitev kosov s kontekstom
  8. Kako velikost kosa izbrati?
  9. Ključne ugotovitve

Cilji

  • Razumeš, zakaj je razčlenjevanje ključno za kakovost sistema RAG
  • Obvladaš različne strategije razdeljevanja besedila
  • Izbereš ustrezno velikost kosov in prekrivanje

Zakaj razdeljevati dokumente?

Modeli za vgradnje (embedding) imajo omejitev števila žetonov: 8.191 za OpenAI. Ta omejitev je prvi razlog za razdeljevanje dokumentov, vendar ni najpomembnejši. Tudi dokument, ki je precej pod to mejo, daje slabe rezultate, če ga kodiramo kot en sam blok, saj dobljeni vektor povpreči vso vsebino in izgubi podrobnosti. Vzemimo 40-stranski priročnik za kadre, ki pokriva politiko dopustov, delo na daljavo, poročila o stroških in zdravstveno zavarovanje: njegova enojna vgradnja ne odraža resnično nobene od teh štirih tem, iskanje po poizvedbi „koliko dni dopusta” pa ga bo uvrstilo nižje od much krajšega, a bistveno bolj ciljanega dokumenta.

Razčlenjevanje reši ta problem tako, da dokument razbije na koherentne dele, od katerih vsak zajema specifično idejo ali odstavek. To je korak, pri katerem cevovod RAG pridobi ali izgubi največ kakovosti – še preden izbereš model za vgradnje.

Strategija 1: Razčlenjevanje s fiksno velikostjo

Najpreprostejša metoda šteje besede in reže v rednih intervalih. Popolnoma ignorira strukturo besedila, kar je surovo, vendar zahteva le tri vrstice kode in služi kot bistvena izhodiščna točka: vsaka bolj sofisticirana strategija mora dokazati, da deluje bolje od te.

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

Parameter overlap si zasluži pozornost. Brez prekrivanja bo rez sčasoma pristal sredi razlage: stavek „odpovedni rok je tri mesece” konča v enem kosu, „razen med poskusno dobo” pa v naslednjem. Noben ne odgovori na vprašanje pravilno, drugi pa je celo zavajajoč. S prekrivanjem kosov za 10–20 % njihove velikosti zagotoviš, da vsaka ideja obstaja nedotaknjena vsaj enkrat nekje v indeksu. To je dobro izhodišče; kasneje ga prilagodi glede na gostoto tvojih dokumentov.

Strategija 2: Razčlenjevanje na podlagi ločil

Namesto rezanja besedo za besedo lahko spoštuješ naravne meje besedila. Ideja je, da najprej poskusiš najmočnejše ločilo – dvojni prelom vrstice, ki ločuje dva odstavka – nato pa se pomakneš navzdol k progressively šibkejšim ločilom, dokler nastali del presega največjo dovoljeno velikost. Objava na blogu se bo tako razdelila odstavek za odstavkom, le pošasten odstavek pa bo razdrobljen na stavke.

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

Strategija 3: Razčlenjevanje po razdelkih Markdown

Ko tvoja zbirka sestoji iz strukturirane dokumentacije, naslovi že opravijo delo namesto tebe: avtor je že določil enote pomena. Razdeljevanje na ravni naslovov # in ## proizvede kose, ki natančno ustrezajo razdelkom, spodnja funkcija pa ohrani naslov skupaj z besedilom, kar bomo takoj zatem uporabili za obogatitev.

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

Strategija 4: Semantično razčlenjevanje

Pri besedilih brez eksplicitne strukture – povzetek sestanka, prepis klica – niti velikost niti ločila ne vedo, kje se tema spremeni. To vedo vgradnje. Kodiraš vsak stavek, primerjaš vsak stavek s prejšnjim in režeš tam, kjer podobnost strmoglavi: točno tam je govorec prešel s proračuna na rekrutiranje. Upoštevaj, da je text-embedding-3-small tu zadosten, saj ne iščeš absolutne natančnosti, temveč relativni prelom.

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

Obogatitev kosov s kontekstom

Osamljen kos pogosto izgubi informacijo, ki ga je delala razumljivega. „Trajanje je tri leta” ne pomeni nič, če bralec – ali model za vgradnje – ne ve, da gre iz poglavja o garanciji proizvajalca. Dodajanje naslova dokumenta in naslova razdelka pred vsak kos obnovi ta kontekst neposredno v sam vektor, iskanje po poizvedbi „trajanje garancije” pa bo nato našlo ta odlomek.

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

Kako velikost kosa izbrati?

Izbira vključuje kompromis med natančnostjo in kontekstom: kratek kos cilja fino, a je okrnjen, medtem ko dolg kos razume vse, a razredči signal.

Velikost (žetoni)PrednostiSlabosti
100–200Zelo natančno, dobra zrnatostIzguba konteksta
300–500Dober kompromisStandardno
500–1000Bogat kontekstManj natančno, dražje
1000+Največji kontekstRazredči informacije

Univerzalne vrednosti ni: idealna velikost je odvisna od tvojih dokumentov in poizvedb. Edina zanesljiva metoda je indeksiranje iste zbirke z dvema ali tremi velikostmi, nato pa merjenje z uporabo metrik iz lekcije 10 na nizu realnih vprašanj. Zbirka znanja za podporo, sestavljena iz kratkih odgovorov, prenese 200 žetonov; pravna zbirka bo zahtevala 800.

Ključne ugotovitve

  • Razčlenjevanje je najvplivnejši korak v cevovodu RAG
  • Uporabi fiksno velikost kot izhodišče, ločila pa za spoštovanje strukture
  • Semantično razčlenjevanje samodejno zazna spremembe tem
  • Prekrivanje in kontekstna obogatitev izboljšata kakovost
  • Preizkusi različne velikosti in meri z metrikami iskanja