Chunking: Dokumentumaid intelligens felosztása
Ezen az oldalon
Célok
- Értsd meg, miért kritikus a chunking a RAG minősége szempontjából
- Sajátítsd el a különböző felosztási stratégiákat
- Válaszd ki a megfelelő chunk-méretet és átfedést
Miért osszuk fel a dokumentumokat?
A beágyazási (embedding) modelleknek van tokenkorlátjuk: az OpenAI esetében ez 8191. Ez a korlát az első ok a dokumentumok felosztására, de nem a legfontosabb. Még egy olyan dokumentum is gyenge eredményt produkál, amely jól a határérték alatt van, ha egyetlen blokkként kódoljuk be, mert a kapott vektor az összes tartalmat átlagolja, és elveszíti a részleteket. Vegyünk egy 40 oldalas HR-kézikönyvet, amely a szabadságolási szabályzatot, a távmunkát, a költségtérítéseket és az egészségbiztosítást tárgyalja: egyetlen beágyazása nem hasonlít igazán e négy téma egyikére sem, és a „hány szabadságnap jár“ keresés során ez a dokumentum hátrébb sorolódik, mint egy sokkal rövidebb, de célzottabb anyag.
A chunking ezt a problémát úgy oldja meg, hogy a dokumentumot koherens darabokra töri, amelyek mindegyike egy konkrét gondolatot vagy bekezdést ragad meg. Ez az a lépés, ahol egy RAG-folyamat a legtöbb minőséget nyeri vagy veszíti el – még mielőtt kiválasztanád a beágyazási modellt.
1. stratégia: Fix méretű chunking
A legegyszerűbb módszer megszámolja a szavakat, és rendszeres időközönként vág. Teljesen figyelmen kívül hagyja a szöveg szerkezetét, így brutális megoldás, de mindössze három sor kódot igényel, és alapvető alapvonalnak (baseline) szolgál: minden kifinomultabb stratégiának be kell bizonyítania, hogy jobban teljesít ennél.
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")
Az overlap paraméter külön figyelmet érdemel. Átfedés nélkül a vágás előbb-utóbb egy magyarázat közepébe esik: a „a felmondási idő három hónap“ mondat az egyik chunkba kerül, míg a „kivéve a próbaidő alatt“ a következőbe. Egyik sem válaszolja meg helyesen a kérdést, sőt, a második félrevezető lehet. A chunkok 10–20%-os átfedésével garantálod, hogy minden gondolat legalább egyszer sértetlenül szerepeljen az indexben. Ez jó kiindulópont; később a dokumentumaid sűrűsége alapján finomíthatsz rajta.
2. stratégia: Elválasztójeleken alapuló chunking
A szó szerinti vágás helyett tiszteletben tarthatod a szöveg természetes határait. Az ötlet az, hogy először a legerősebb elválasztót próbáld meg – a két bekezdést elválasztó dupla sortörést –, majd haladj lefelé a progressively gyengébb elválasztók felé mindaddig, amíg a kapott darab meghaladja a maximális méretet. Egy blogbejegyzést így bekezdésenként osztasz fel, és csak egy szörnyeteg méretű bekezdést törsz fel mondatokra.
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égia: Markdown szakaszok szerinti chunking
Ha a korpuszod strukturált dokumentációból áll, a címsorok már elvégzik helyetted a munkát: a szerző már lehatárolta a jelentésegységeket. A # és ## szintű címsoroknál történő felosztás olyan chunkokat eredményez, amelyek pontosan megfelelnek a szakaszoknak, és az alábbi függvény a címsort is megtartja a szöveg mellett, amit rögtön ezután felhasználhatsz a dúsításhoz.
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égia: Szemantikai chunking
Olyan szövegeknél, amelyeknek nincs explicit szerkezetük – például egy értekezlet összefoglalója vagy egy hívás átirata –, sem a méret, sem az elválasztójelek nem tudják, hol változik a téma. A beágyazások viszont igen. Kódold be minden mondatot, hasonlítsd össze az egyes mondatokat az előzővel, és ott vágj, ahol a hasonlóság összeomlik: pontosan ott váltott a beszélő a költségvetésről a toborzásra. Ne feledd, hogy itt a text-embedding-3-small is elegendő, mivel nem abszolút pontosságot keresel, hanem egy relatív töréspontot.
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
Chunkok dúsítása kontextussal
Egy elszigetelt chunk gyakran elveszíti azt az információt, amely értelmezhetővé tette. A „az időtartam három év“ semmit sem jelent, ha az olvasó – vagy a beágyazási modell – nem tudja, hogy ez a gyártói garancia fejezetből származik. Ha minden chunk elé odailleszted a dokumentum címét és a szakasz címét, ezzel közvetlenül a vektorba építed vissza ezt a kontextust, és a „garancia időtartama“ keresés ezután megtalálja a megfelelő részt.
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}"
Mekkora chunk-méretet válassz?
A választás a pontosság és a kontextus közötti kompromisszumot jelenti: egy rövid chunk finoman céloz, de csonka, míg egy hosszú chunk mindent ért, de hígítja a jelet.
| Méret (token) | Előnyök | Hátrányok |
|---|---|---|
| 100–200 | Nagyon pontos, jó szemcsézettség | Elveszíti a kontextust |
| 300–500 | Jó kompromisszum | Szabványos |
| 500–1000 | Gazdag kontextus | Kevésbé pontos, drága |
| 1000+ | Maximális kontextus | Hígítja az információt |
Nincs univerzális érték: az ideális méret a dokumentumaidtól és a lekérdezéseidtől függ. Az egyetlen megbízható módszer, ha ugyanazt a korpuszt két vagy három különböző mérettel indexeled, majd a 10. leckében tárgyalt metrikák segítségével méred az eredményt valós kérdések halmazán. Egy rövid válaszokból álló támogatási tudásbázis elviseli a 200 tokent; egy jogi korpuszhoz 800 szükséges.
Főbb megállapítások
- A chunking a legjelentősebb hatású lépés a RAG-folyamatban
- Használd a fix méretet alapvonalnak, az elválasztójeleket a szerkezet tiszteletben tartására
- A szemantikai chunking automatikusan érzékeli a témaváltásokat
- Az átfedés és a kontextuális dúsítás javítja a minőséget
- Tesztelj különböző méreteket, és mérd az eredményt keresési metrikákkal