Chunking: dokumentide intelligentne tükeldamine
Sellel lehel
Eesmärgid
- Mõista, miks on chunking RAG-i kvaliteedi jaoks kriitiline
- Omandada erinevad tükeldamisstrateegiad
- Valida õige tüki suurus ja kattuvus
Miks dokumente tükeldada?
Manustamismudelitel (embedding models) on tokenite piirang: OpenAI puhul 8191. See piirang on esimene põhjus dokumente tükeldada, kuid mitte kõige olulisem. Isegi lagi alt jääv dokument annab halvaid tulemusi, kui see kodeeritakse ühe plokkina, sest saadud vektor keskmistab kogu sisu ja kaotab detailid. Võta näiteks 40-leheküljeline personalijuhend, mis käsitleb puhkepoliitikat, kaugtööd, kuluaruandeid ja tervisekindlustust: selle üksik manustus ei sarnane tegelikult ühegi neist neljast teemast ja otsing fraasile “mitu puhkepäeva” järjestab selle palju madalamale kui palju lühema, kuid palju sihitumalt koostatud dokumendi.
Chunking lahendab selle probleemi, jagades dokumendi sidusateks tükkideks, millest igaüks haarab konkreetse idee või lõigu. See on samm, kus RAG-i torustik võidab või kaotab kõige rohkem kvaliteeti – isegi enne, kui valid manustamismudeli.
Strateegia 1: Fikseeritud suurusega chunking
Lihtsaim meetod loeb sõnu ja lõikab regulaarsete intervallide tagant. See eirab täielikult teksti struktuuri, muutes selle jõhkraks, kuid see mahub kolme koodireale ja toimib hädavajaliku baasjoonena: iga keerukam strateegia peab tõestama, et toimib sellest paremini.
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")
Parameeter overlap väärib tähelepanu. Ilma kattuvuseta maandub lõige varem või hiljem keset selgitust: lause “ettemääratlemise tähtaeg on kolm kuud” jääb ühte tükki ja “välja arvatud katseaeg” järgmisse. Kumbki ei vasta küsimusele õigesti ja teine on lausa eksitav. Kattes tükke 10–20% nende suurusest, garanteerid, et iga idee eksisteerib tervikuna vähemalt korra kusagil indeksis. See on hea lähtepunkt; kohanda seda hiljem vastavalt oma dokumentide tihedusele.
Strateegia 2: Eraldajatel põhinev chunking
Sõna-sõnalt lõikamise asemel võid austada teksti loomulikke piire. Idee on proovida kõige tugevamat eraldajat esmalt – topelt reavahetus, mis eraldab kahte lõiku – ja liikuda seejärel alla järjest nõrgemate eraldajateni, kuni saadud tükk ületab maksimaalset suurust. Blogipostitus jaguneb seega lõikude kaupa ja ainult koletislik lõik fragmenteeritakse lauseteks.
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
Strateegia 3: Markdowni sektsioonide chunking
Kui sinu korpuseks on struktureeritud dokumentatsioon, teevad pealkirjad töö juba sinu eest ära: autor on juba tähendusüksused piiritlenud. Tükeldamine tasemetel # ja ## toodab tükke, mis vastavad täpselt sektsioonidele, ja allolev funktsioon hoiab pealkirja teksti kõrval, mida kasutame kohe pärast seda rikastamiseks.
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
Strateegia 4: Semantiline chunking
Teksti puhul, millel puudub selge struktuur – koosoleku kokkuvõte, kõne transkript –, ei tea ei suurus ega eraldajad, kus teema muutub. Manustused teavad. Kodeeri iga lause, võrdle iga lauset eelmisega ja lõika seal, kus sarnasus kokku variseb: just seal lülitus kõneleja eelarvelt värbamisele. Pane tähele, et siin piisab mudelist text-embedding-3-small, kuna sa ei otsi absoluutset täpsust, vaid suhtelist murdepunkti.
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
Tükkide rikastamine kontekstiga
Iseseisev tükk kaotab sageli info, mis tegi selle tõlgendatavaks. „Kestus on kolm aastat“ ei tähenda midagi, kui lugeja – või manustamismudel – ei tea, et see pärineb tootja garantii peatükist. Iga tüki ette dokumendi ja sektsiooni pealkirja lisamine taastab selle konteksti otse vektori sees ja otsing „garantii kestus“ leiab siis selle lõigu üles.
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}"
Millise tüki suuruse peaksid valima?
Valik hõlmab kompromissi täpsuse ja konteksti vahel: lühike tükk sihib peenelt, kuid on amputeeritud, samas kui pikk tükk mõistab kõike, kuid lahjendab signaali.
| Suurus (tokeneid) | Eelised | Puudused |
|---|---|---|
| 100–200 | Väga täpne, hea granulaarsus | Kaotab konteksti |
| 300–500 | Hea kompromiss | Standardne |
| 500–1000 | Rikas kontekst | Vähem täpne, kallis |
| 1000+ | Maksimaalne kontekst | Lahjendab informatsiooni |
Universaalset väärtust pole: ideaalne suurus sõltub sinu dokumentidest ja päringutest. Ainuke usaldusväärne meetod on indekseerida sama korpus kahe või kolme suurusega ja seejärel mõõta tulemusi 10. tunnis käsitletud meetrikate abil reaalsete küsimuste komplekti peal. Lühikestest vastustest koosnev tugiteadmiste baas talub 200 tokenit; juriidiline korpus nõuab 800.
Peamised punktid
- Chunking on RAG-i torustiku mõjukaim samm
- Kasuta fikseeritud suurust baasjoonena ja eraldajaid struktuuri austamiseks
- Semantiline chunking tuvastab automaatselt teemamuutused
- Kattuvus ja kontekstiga rikastamine parandavad kvaliteeti
- Testi erinevaid suurusi ja mõõda tulemusi otsingumetriikatega