Chunking: protingas dokumentų skaidymas
Šiame puslapyje
Tikslai
- Suprasti, kodėl chunking (skaidymas) yra kritiškai svarbus RAG kokybei
- Įvaldyti skirtingas skaidymo strategijas
- Pasirinkti tinkamą fragmento dydį ir persidengimą
Kodėl reikia skaidyti dokumentus?
Įterpimo (embedding) modeliai turi tokenų limitą: „OpenAI“ atveju jis siekia 8 191. Tai pirmoji priežastis skaidyti dokumentus, tačiau ne pati svarbiausia. Net ir gerokai mažesnis nei riba dokumentas duoda prastus rezultatus, jei koduojamas kaip vienas blokas, nes gautas vektorius suvidurkina visą turinį ir praranda detales. Įsivaizduok 40 puslapių HR vadovą, apimantį atostogų politiką, nuotolinį darbą, išlaidų ataskaitas ir sveikatos draudimą: jo vienas įterpimas iš tikrųjų neatitinka nė vienos iš šių keturių temų, o paieška „kiek dienų trunka atostogos“ jį įvertins žemiau nei daug trumpesnį, bet kur kas tikslesnį dokumentą.
Chunking išsprendžia šią problemą suskaidydamas dokumentą į logiškas dalis, kurių kiekviena fiksuoja konkrečią idėją ar pastraipą. Būtent šiame žingsnyje RAG sistema įgauna arba praranda daugiausia kokybės – dar prieš pasirenkant įterpimo modelį.
1 strategija: fiksuoto dydžio skaidymas
Paprastiausias metodas suskaičiuoja žodžius ir pjauna reguliariais intervalais. Jis visiškai ignoruoja teksto struktūrą, todėl yra grubus, tačiau tam užtenka trijų kodo eilučių ir jis tarnauja kaip esminė bazinė linija: bet kuri sudėtingesnė strategija turi įrodyti, kad veikia geriau už šią.
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")
Parametras overlap nusipelno dėmesio. Be persidengimo pjūvis anksčiau ar vėliau atsidurs paaiškinimo viduryje: sakinys „įspėjimo terminas yra trys mėnesiai“ atsiduria viename fragmente, o „išskyrus bandomąjį laikotarpį“ – kitame. Nei vienas, nei kitas neteisingai neatsako į klausimą, o antrasis netgi klaidina. Persidengiant fragmentams 10–20 % jų dydžio, garantuoji, kad kiekviena idėja bent kartą egzistuoja nepažeista indekse. Tai geras starto taškas; vėliau jį koreguok pagal dokumento tankumą.
2 strategija: skirtukais pagrįstas skaidymas
Užuot pjaustęs žodį po žodžio, gali gerbti natūralias teksto ribas. Idėja tokia: pirmiausia bandyti stipriausią skirtuką – dvigubą eilutės pertrauką, skiriančią dvi pastraipas, – tada leistis žemyn iki silpnesnių skirtukų tol, kol gautas gabalas viršija maksimalų dydį. Taip tinklaraščio įrašas bus skaidomas pastraipomis, o milžiniška pastraipa bus suskaidyta tik sakiniais.
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 strategija: „Markdown“ skyrių skaidymas
Kai tavo korpusą sudaro struktūruota dokumentacija, antraštės jau atlieka darbą už tave: autorius jau apibrėžė prasminius vienetus. Skaidymas ties # ir ## antraščių lygmenimis sukuria fragmentus, kurie tiksliai atitinka skyrius, o toliau pateikta funkcija palieka antraštę greta teksto, ką netrukus panaudosime praturtinimui.
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 strategija: semantinis skaidymas
Tekstui be aiškios struktūros – posėdžio santraukai, skambučio stenogramai – nei dydis, nei skirtukai nežino, kur keičiasi tema. Tai žino įterpimai. Užkoduoji kiekvieną sakinį, palygini jį su ankstesniu ir pjauni ten, kur panašumas staiga krenta: būtent ten kalbėtojas perėjo nuo biudžeto prie samdymo. Atkreipk dėmesį, kad čia pakanka text-embedding-3-small, nes ieškai ne absoliutaus tikslumo, o santykinės pertraukos.
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
Fragmentų praturtinimas kontekstu
Atskiras fragmentas dažnai praranda informaciją, kuri darė jį suprantamą. „Trukmė yra treji metai“ nieko nereiškia, jei skaitytojas – ar įterpimo modelis – nežino, kad tai iš gamintojo garantijos skyriaus. Pridėjus prie kiekvieno fragmento dokumento pavadinimą ir skyriaus antraštę, šis kontekstas atkuriamas tiesiai į patį vektorių, ir paieška „garantijos trukmė“ tada ras tą vietą.
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}"
Kokį fragmento dydį pasirinkti?
Pasirinkimas yra kompromisas tarp tikslumo ir konteksto: trumpas fragmentas taikliai pataiko, bet yra apkarpytas, o ilgas fragmentas supranta viską, bet praskiedžia signalą.
| Dydis (tokenai) | Privalumai | Trūkumai |
|---|---|---|
| 100–200 | Labai tikslus, gera granuliacija | Prarandamas kontekstas |
| 300–500 | Geras kompromisas | Standartas |
| 500–1000 | Turtingas kontekstas | Mažiau tikslus, brangiau |
| 1000+ | Maksimalus kontekstas | Informacija praskiedžiama |
Nėra universalios vertės: idealus dydis priklauso nuo tavo dokumentų ir užklausų. Vienintelis patikimas būdas – indeksuoti tą patį korpusą su dviem ar trim skirtingais dydžiais, tada įvertinti naudojant 10 pamokos metrikas realių klausimų aibėje. Pagalbos žinių bazė, sudaryta iš trumpų atsakymų, toleruoja 200 tokenų; teisiniam korpusui prireiks 800.
Svarbiausi punktai
- Chunking yra pats svarbiausias žingsnis RAG sistemoje
- Naudok fiksuotą dydį kaip bazę, o skirtukus – struktūrai išlaikyti
- Semantinis skaidymas automatiškai aptinka temos pokyčius
- Persidengimas ir konteksto praturtinimas gerina kokybę
- Testuok skirtingus dydžius ir vertink paieškos metrikomis