Razčlenjevanje: Pametno razdeljevanje dokumentov
Na tej strani
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) | Prednosti | Slabosti |
|---|---|---|
| 100–200 | Zelo natančno, dobra zrnatost | Izguba konteksta |
| 300–500 | Dober kompromis | Standardno |
| 500–1000 | Bogat kontekst | Manj natančno, dražje |
| 1000+ | Največji kontekst | Razredč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