Chunking: Doiciméid a Roinnt go Cliste
Ar an leathanach seo
Cuspóirí
- Tuiscint a fháil ar an fáth a bhfuil chunking ríthábhachtach do cháilíocht RAG
- Máistreacht a dhéanamh ar straitéisí éagsúla scoilte
- An méid chunk agus an t-forluí ceart a roghnú
Cár gá doiciméid a scoilt?
Tá teorainn token ag múnlaí leabaithe: 8,191 do OpenAI. Is é an teorainn seo an chéad chúis le doiciméid a scoilt, ach ní hé an ceann is tábhachtaí é. Fiú doiciméad atá i bhfad faoin uasteorainn, cruthaíonn sé torthaí bocht nuair a chuirtear ina bhloc amháin é toisc go ndéanann an veicteoir a thagann as meánú ar an ábhar go léir agus cailltear mionsonraí. Tóg lámhleabhar HR 40 leathanach a chlúdaíonn polasaithe saoire, obair i gcéin, tuarascálacha caiteachais, agus árachas sláinte: ní dhéanann a leabú aonair aithris cheart ar aon cheann de na ceithre ábhar seo, agus rangóidh cuardach ar “cé mhéad lá saoire” é faoi dhoiciméad i bhfad níos giorra ach i bhfad níos spriocdhírithe.
Réitíonn chunking an fhadhb seo tríd an doiciméad a bhriseadh ina phíosaí comhleanúnacha, gach ceann acu ag gabháil smaoineamh nó mír shonrach. Is é seo an chéim ina mbuaileann nó ina gcailleann píblíne RAG an cháilíocht is mó—fiú sula roghnaíonn tú múnla leabaithe.
Straitéis 1: Chunking de mhéid seasta
Is é an modh is simplí ná focail a chomhaireamh agus gearradh ag eatraimh rialta. Déanann sé neamhaird iomlán ar struchtúr an téacs, rud a fhágann go bhfuil sé garbh, ach tógann sé trí líne cód agus feidhmíonn sé mar bhunlíne riachtanach: caithfidh aon straitéis níos sofaisticiúla a chruthú go bhfeidhmíonn sí níos fearr ná seo.
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")
Tuilleann an paraiméadar overlap aird. Gan forluí, titfidh gearradh sa deireadh i lár míniú: críochnaíonn an abairt “is trí mhí an tréimhse fógra” i gceann amháin de na chunks, agus “seachas le linn na tréimhse trialach” sa chéad cheann eile. Ní fhreagraíonn ceachtar acu an cheist i gceart, agus tá an dara ceann míthreorach fiú. Trí chunks a fhorluí faoi 10–20% dá méid, ráthaíonn tú go bhfuil gach smaoineamh slán ar a laghad uair amháin in áit éigin san innéacs. Is pointe tosaigh maith é seo; coigeartaigh é ina dhiaidh sin bunaithe ar dhlús do dhoiciméad.
Straitéis 2: Chunking bunaithe ar dheighilteoirí
In ionad gearradh focal ar fhocal, is féidir leat teorainneacha nádúrtha an téacs a urramú. Is é an smaoineamh ná triail a bhaint as an deighilteoir is láidre ar dtús—an briseadh líne dúbailte a scarann dhá mhír—agus ansin dul síos go deighilteoirí níos laige de réir a chéile fad is a sháraíonn an píosa a thagann as an méid uasta. Scoilfear blagmhír mar sin mír ar mhír, agus ní dhéanfar ach mír ollmhór a bhriseadh ina habairtí.
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
Straitéis 3: Chunking de réir alt Markdown
Nuair a bhíonn do chorpas comhdhéanta de dhoiciméadú struchtúrtha, déanann ceanntáscs an obair duit cheana féin: tá na haonaid chialla teorannaithe ag an údar cheana. Cruthaíonn scoilt ag leibhéil ceanntásc # agus ## chunks a fhreagraíonn go díreach do ranna, agus coinníonn an fheidhm thíos an ceanntásc in éineacht leis an téacs, rud a úsáidfimid díreach ina dhiaidh sin le haghaidh saibhrithe.
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
Straitéis 4: Chunking seimeantach
I gcás téacs gan struchtúr soiléir—achoimre cruinnithe, tras-scríbhinn glaonna—ní fios ag méid ná ag deighilteoirí cá n-athraíonn an t-ábhar. Tá a fhios ag leabuithe. Cuirtear gach abairt in ionchód, déantar gach abairt a chur i gcomparáid leis an gceann roimhe, agus déantar gearradh nuair a thiteann an chosúlacht: sin díreach áit ar athraigh an cainteoir ó bhuiséad go hearcaíocht. Tabhair faoi deara go bhfuil text-embedding-3-small leordhóthanach anseo toisc nach bhfuil tú ag lorg cruinnis absalóidigh ach briseadh coibhneasta.
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
Chunks a shaibhriú le comhthéacs
Go minic, cailleann chunk aonair an fhaisnéis a rinne inléite é. Ní chiallaíonn “is trí bliana an fhad” aon rud mura bhfuil a fhios ag an léitheoir—nó ag an múnla leabaithe—gur ón gcaibidil baránta monaróra é. Trí theideal an doiciméid agus teideal na rannóige a chur roimh gach chunk, cuireann tú an comhthéacs seo ar ais go díreach isteach sa veicteoir féin, agus ansin aimsíonn cuardach ar “fad an bharánta” an pasáiste.
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}"
Cén méid chunk ba chóir duit a roghnú?
Baineann an rogha le comhréir idir cruinneas agus comhthéacs: díritheann chunk gairid go mín ach tá sé mutilaithe, cé go dtuigeann chunk fada gach rud ach caolaíonn sé an comhartha.
| Méid (tokens) | Buntáistí | Míbhuntáistí |
|---|---|---|
| 100–200 | An-chruinn, dea-ghráinneacht | Cailleann comhthéacs |
| 300–500 | Dea-chomhréir | Caighdeánach |
| 500–1000 | Comhthéacs saibhir | Níos lú cruinnis, costasach |
| 1000+ | Comhthéacs uasta | Caolaíonn faisnéis |
Níl aon luach uilíoch ann: braitheann an méid idéalach ar do dhoiciméid agus ar do cheisteanna. Níl ach modh amháin iontaofa: innéacsigh an corpas céanna le dhá nó trí mhéid, agus ansin déan tomhas ag baint úsáide as na méadrachtaí ó cheacht 10 ar shraith ceisteanna fíor. Glacann bonn eolais tacaíochta atá déanta d’fhreagraí gairide le 200 token; éileoidh corpas dlíthiúil 800.
Príomhphointí
- Is é chunking an chéim is tiontaí sa phíblíne RAG
- Úsáid méid seasta mar bhunlíne, deighilteoirí chun struchtúr a urramú
- Brathann chunking seimeantach athruithe ábhair go huathoibríoch
- Feabhsaíonn forluí agus saibhriú comhthéacsúil an cháilíocht
- Déan tástáil ar mhéideanna éagsúla agus déan tomhas le méadrachtaí cuardaigh