Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Chunking: Qsim ta' Dokumenti b'Mod Intelliġenti

Lezzjoni 12 / 22 Aġġornat 29 ta’ Lulju 2026 Zviluppatur
F'din il-paġna
  1. Għanijiet
  2. Għaliex taqsam id-dokumenti?
  3. Strateġija 1: Chunking b’daqs fiss
  4. Strateġija 2: Chunking ibbażat fuq separaturi
  5. Strateġija 3: Chunking ta’ sezzjonijiet Markdown
  6. Strateġija 4: Chunking semantiku
  7. Arrikkiment taċ-chunks bil-kuntest
  8. Liema daqs ta’ chunk għandek tagħżel?
  9. Punti Ewlenin

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–200Preċiż ħafna, granularità tajbaJitlif il-kuntest
300–500Kompromess tajjebStandard
500–1000Kuntest rikkInqas preċiż, għali
1000+Kuntest massimuJdilwi 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