Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Chunking: Doiciméid a Roinnt go Cliste

Ceacht 12 as 22 Nuashonraithe 29 Iúil 2026 Forbróir
Ar an leathanach seo
  1. Cuspóirí
  2. Cár gá doiciméid a scoilt?
  3. Straitéis 1: Chunking de mhéid seasta
  4. Straitéis 2: Chunking bunaithe ar dheighilteoirí
  5. Straitéis 3: Chunking de réir alt Markdown
  6. Straitéis 4: Chunking seimeantach
  7. Chunks a shaibhriú le comhthéacs
  8. Cén méid chunk ba chóir duit a roghnú?
  9. Príomhphointí

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–200An-chruinn, dea-ghráinneachtCailleann comhthéacs
300–500Dea-chomhréirCaighdeánach
500–1000Comhthéacs saibhirNíos lú cruinnis, costasach
1000+Comhthéacs uastaCaolaí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