Chunking: Inteligentné rozdelenie dokumentov
Na tejto strane
Ciele
- Pochopiť, prečo je chunking kľúčový pre kvalitu RAG
- Ovládať rôzne stratégie rozdelenia textu
- Zvoliť správnu veľkosť chunku a prekrytie
Prečo rozdeľovať dokumenty?
Modely na vytváranie vektorových reprezentácií (embedding models) majú limit počtu tokenov: pre OpenAI je to 8 191. Tento limit je prvým dôvodom na rozdelenie dokumentov, no nie tým najdôležitejším. Aj dokument, ktorý je výrazne pod týmto stropom, prináša slabé výsledky, ak je zakódovaný ako jeden celok, pretože výsledný vektor spriemeruje celý obsah a stratí detaily. Predstav si 40-stranovú príručku pre ľudské zdroje, ktorá pokrýva dovolenky, prácu na diaľku, vyúčtovanie výdavkov a zdravotné poistenie: jej jediné vektorové zakódovanie skutočne nezodpovedá žiadnej z týchto štyroch tém a vyhľadávanie „koľko dní dovolenky“ ju zaradí až za oveľa kratší, no oveľa cielenější dokument.
Chunking tento problém rieši rozbitím dokumentu na súvislé časti, z ktorých každá zachytáva konkrétnu myšlienku alebo odsek. Práve v tomto kroku pipeline RAG najviac získa alebo stratí na kvalite – ešte predtým, než si vyberieš model na vytváranie vektorov.
Stratégia 1: Chunking s pevnou veľkosťou
Najjednoduchšia metóda počíta slová a režie v pravidelných intervaloch. Úplne ignoruje štruktúru textu, čo je brutálne, no stačia na to tri riadky kódu a slúži ako nevyhnutný základ: každá sofistikovanejšia stratégia musí dokázať, že funguje lepšie než táto.
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 zaslúži pozornosť. Bez prekrytia sa rez nakoniec ocitne uprostred vysvetlenia: veta „výpovedná lehota sú tri mesiace“ skončí v jednom chunku a „okrem skúšobnej doby“ v ďalšom. Ani jeden neodpovie na otázku správne a druhý je dokonca zavádzajúci. Prekrytím chunkov o 10 – 20 % ich veľkosti zabezpečíš, že každá myšlienka existuje neporušená aspoň raz niekde v indexe. Je to dobrý východiskový bod; neskôr ho upravíš podľa hustoty tvojich dokumentov.
Stratégia 2: Chunking podľa oddeľovačov
Namiesto rezania slovo po slove môžeš rešpektovať prirodzené hranice textu. Myšlienkou je najprv vyskúšať najsilnejší oddeľovač – dvojitý riadok, ktorý oddeľuje dva odseky – a potom zostupovať k progressively slabším oddeľovačom, kým výsledný kus presahuje maximálnu veľkosť. Blogový príspevok sa tak rozdelí odsek po odseku a iba obludný odsek sa roztriešti na vety.
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
Stratégia 3: Chunking podľa sekcií Markdown
Keď tvoje korpus tvoria štruktúrované dokumentácie, nadpisy už urobili prácu za teba: autor už vymedzil jednotky významu. Rozdelenie na úrovniach nadpisov # a ## vytvorí chunky, ktoré presne zodpovedajú sekciám, a funkcia nižšie ponecháva nadpis spolu s textom, čo hneď využijeme na obohatenie.
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
Stratégia 4: Sémantický chunking
Pri texte bez explicitnej štruktúry – zhrnutie schôdzky, prepis hovoru – ani veľkosť, ani oddeľovače nevedia, kde sa mení téma. Vedia to vektory. Zakóduješ každú vetu, porovnáš každú vetu s predchádzajúcou a odrežeš tam, kde klesne podobnosť: presne tam hovorca prešiel z rozpočtu na nábor. Všimni si, že text-embedding-3-small tu stačí, keďže nehľadáš absolútnu presnosť, ale relatívny zlom.
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
Obohatenie chunkov o kontext
Izolovaný chunk často stráca informáciu, ktorá ho robila zrozumiteľným. „Trvanie sú tri roky“ neznamená nič, ak čitateľ – alebo model na vytváranie vektorov – nevie, že je to z kapitoly o záruke výrobcu. Pridaním názvu dokumentu a názvu sekcie pred každý chunk obnovíš tento kontext priamo vo vektore a vyhľadávanie „dĺžka záruky“ potom nájde daný úsek.
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}"
Akú veľkosť chunku zvoliť?
Voľba zahŕňa kompromis medzi presnosťou a kontextom: krátky chunk cieli presne, no je ochudobnený, zatiaľ čo dlhý chunk chápe všetko, no zrieďuje signál.
| Veľkosť (tokeny) | Výhody | Nevýhody |
|---|---|---|
| 100–200 | Veľmi presné, dobrá granularita | Stráca kontext |
| 300–500 | Dobrý kompromis | Štandard |
| 500–1000 | Bohatý kontext | Menej presné, drahšie |
| 1000+ | Maximálny kontext | Zrieďuje informácie |
Neexistuje univerzálna hodnota: ideálna veľkosť závisí od tvojich dokumentov a dopytov. Jediná spoľahlivá metóda je indexovať rovnaký korpus s dvoma alebo tromi veľkosťami a potom merať pomocou metrík z lekcie 10 na sade reálnych otázok. Znalostná databáza podpory zložená z krátkych odpovedí znáša 200 tokenov; právny korpus bude vyžadovať 800.
Kľúčové poznatky
- Chunking je najvplyvnejším krokom v pipeline RAG
- Použi pevnú veľkosť ako základ, oddeľovače na rešpektovanie štruktúry
- Sémantický chunking automaticky detekuje zmeny tém
- Prekrytie a kontextové obohatenie zlepšujú kvalitu
- Testuj rôzne veľkosti a meraj pomocou metrík vyhľadávania