Chunking: Qsim ta' Dokumenti b'Mod Intelliġenti
F'din il-paġna
Għanijiet
- Tifhem għaliex il-chunking huwa kritiku għall-kwalità tar-RAG
- Tmexxi strateġiji differenti ta’ qsim
- Tagħżel id-daqs u s-sovrappożizzjoni (overlap) tajbin għaċ-chunks
Għaliex taqsam id-dokumenti?
Il-mudelli ta’ embedding għandhom limitu ta’ tokens: 8,191 għal OpenAI. Dan il-limitu huwa l-ewwel raġuni biex taqsam id-dokumenti, iżda mhix l-aktar waħda importanti. Anke dokument li huwa ferm taħt dan is-soqfa jipproduċi riżultati fqar meta jiġi kkodifikat bħala blokk wieħed, għax il-vettur li jirriżulta jagħmel medja tal-kontenut kollu u jitlif id-dettalji. Ħu manual tal-HR ta’ 40 paġna li jkopri politiki tal-leave, xogħol remot, rapporti ta’ spejjeż, u assigurazzjoni tas-saħħa: l-embedding wieħed tiegħu ma jixbahx verament lil xi waħda minn dawn l-erba’ temi, u tfittxija għal “kemm-il jum ta’ leave” se tikklassifikah taħt dokument ferm iqsar iżda ferm aktar immirat.
Il-chunking isolvi din il-problema billi jkisser id-dokument f’biċċiet koerenti, li kull wieħed jaqbad idea jew paragrafu speċifiku. Dan huwa l-pass fejn pipeline ta’ RAG jikseb jew jitlif l-aktar kwalità—saħansitra qabel ma tagħżel mudell ta’ embedding.
Strateġija 1: Chunking b’daqs fiss
L-aktar metodu sempliċi jgħodd il-kliem jaqta’ f’intervalli regolari. Jinjora kompletament l-istruttura tat-test, u għalhekk huwa brutali, iżda jieħu tliet linji ta’ kodiċi u jservi bħala linja bażi essenzjali: kwalunkwe strateġija aktar sofistikata trid tipprova li taħdem aħjar minn din.
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")
Il-parametru overlap jistħoqqilu attenzjoni. Mingħajr sovrappożizzjoni, qatgħa eventwalment taqa’ f’nofs spjegazzjoni: is-sentenza “il-perjodu ta’ avviż huwa ta’ tliet xhur” tispiċċa f’chunk wieħed, u “ħlief matul il-perjodu ta’ provi” fil-li jmiss. L-ebda waħda ma tweġib il-mistoqsija b’mod korrett, u t-tieni waħda saħansitra tqarraq. Billi tsovrappone ċ-chunks b’10–20% tad-daqs tagħhom, tiggarantixxi li kull idea teżisti intatta mill-inqas darba f’xi post fl-indiċi. Dan huwa punt tat-tluq tajjeb; aġustah aktar tard ibbażat fuq id-densità tad-dokumenti tiegħek.
Strateġija 2: Chunking ibbażat fuq separaturi
Minflok ma taqta’ kelma b’kelma, tista’ tirrispetta l-fruntieri naturali tat-test. L-idea hija li tipprova l-aktar separatur b’saħħtu l-ewwel—il-break doppju tal-linja li jifred żewġ paragrafi—imbagħad tinżel għal separaturi progressivament aktar dgħajfa sakemm il-biċċa li tirriżulta taqbeż id-daqs massimu. Artiklu ta’ blog hekk jinqasam paragrafu b’paragrafu, u biss paragrafu mostruż jiġi fframmentat f’sentenzi.
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
Strateġija 3: Chunking ta’ sezzjonijiet Markdown
Meta l-corpus tiegħek jikkonsisti f’dokumentazzjoni strutturata, l-intestaturi diġà jagħmlu x-xogħol għalik: l-awtur diġà ddelimita l-unitajiet ta’ tifsira. Il-qsim fil-livelli tal-intestatura # u ## jipproduċi chunks li jikkorrispondu eżattament mas-sezzjonijiet, u l-funzjoni hawn taħt iżżomm l-intestatura mal-ġenb tat-test, li nużaw immedjatament wara għall-arrikkiment.
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
Strateġija 4: Chunking semantiku
Għal test mingħajr struttura espliċita—sommarju ta’ laqgħa, transkrizzjoni ta’ sejħa—la d-daqs u lanqas is-separaturi jafu fejn jinbidel is-suġġett. L-embeddings jafu. Tikkodifika kull sentenza, tqabbel kull sentenza ma’ dik ta’ qabilha, u taqta’ fejn is-similarità tonqos b’mod drastiku: eżattament hemmhekk fejn il-kelliem ibdel mill-baġit għar-reklutaġġ. Innota li text-embedding-3-small huwa biżżejjed hawnhekk peress li mhux qed tfittex preċiżjoni assoluta iżda break relattiv.
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
Arrikkiment taċ-chunks bil-kuntest
Chunk iżolat spiss jitlif l-informazzjoni li kienet tagħmlu interpretabbli. “Id-durata hija ta’ tliet snin” ma tfisser xejn jekk il-qarrej—jew il-mudell ta’ embedding—ma jafx li din hija mill-kapitolu tal-garanzija tal-manifattur. Li tpoġġi prefiss għal kull chunk bit-titolu tad-dokument u t-titolu tas-sezzjoni jirrestawra dan il-kuntest direttament fil-vettur innifsu, u tfittxija għal “durata tal-garanzija” imbagħad issib il-passaġġ.
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}"
Liema daqs ta’ chunk għandek tagħżel?
L-għażla tinvolvi kompromess bejn il-preċiżjoni u l-kuntest: chunk qasir jimmira b’mod fin iżda huwa mnaqqas, filwaqt li chunk twil jifhem kollox iżda jdilwi s-sinjal.
| Daqs (tokens) | Vantaġġi | Żvantaġġi |
|---|---|---|
| 100–200 | Preċiż ħafna, granularità tajba | Jitlif il-kuntest |
| 300–500 | Kompromess tajjeb | Standard |
| 500–1000 | Kuntest rikk | Inqas preċiż, għali |
| 1000+ | Kuntest massimu | Jdilwi l-informazzjoni |
M’hemm l-ebda valur universali: id-daqs ideali jiddependi fuq id-dokumenti u l-mistoqsijiet tiegħek. L-uniku metodu affidabbli huwa li tindiċja l-istess corpus b’żewġ jew tliet daqsijiet, imbagħad tkejjel bl-użu tal-metriki mil-lezzjoni 10 fuq sett ta’ mistoqsijiet reali. Bażi ta’ għarfien ta’ appoġġ magħmula minn tweġibiet qosra ttollera 200 token; corpus legali jeħtieġ 800.
Punti Ewlenin
- Il-chunking huwa l-pass l-aktar influwenti fil-pipeline tar-RAG
- Uża d-daqs fiss bħala linja bażi, u s-separaturi biex tirrispetta l-istruttura
- Il-chunking semantiku jiskopri awtomatikament il-bidliet fis-suġġett
- Is-sovrappożizzjoni u l-arrikkiment kuntestwali jtejbu l-kwalità
- Ittestja daqsijiet differenti u kejjel bil-metriki tat-tiftix