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

Baisceáil agus Miondealú

Ceacht 4 as 18 Nuashonraithe 2 Samhain 2026 Forbróir
Ar an leathanach seo
  1. An Dúshlán a bhaineann le Toirteanna Móra
  2. Baisceáil: Próiseáil i nGrúpaí
  3. Miondealú: Téacs a Roinnt
  4. Forluí
  5. Píblíne Iomlán: Miondealú + Baisceáil + Ionchódú
  6. Príomhphointí

An Dúshlán a bhaineann le Toirteanna Móra

Nuair a bhíonn tú ag obair le mílte doiciméad, ní féidir leat gach rud a ionchódú in aon ghlaoch API amháin. Caithfidh tú baisceáil (próiseáil i ngrúpaí) agus miondealú (roinnt téacs) a bhainistiú. Tá an dá theicníc seo riachtanach chun córais chuardaigh shéimeantaigh a thógáil ar scála mór.

Tá an dá choincheap cosúil le chéile ar an gcéad amharc, ach réitíonn siad fadhbanna contrártha. Déileálann miondealú le doiciméad aonair atá ró-mhór le bheith ionchódaithe go héifeachtach ina iomláine; déileálann baisceáil le ró-mhór doiciméad le fitáil in aon iarratas amháin. Tagann lámhleabhar teicniúil trí chéad leathanach faoin gcéad chatagóir, easpórtáil fiche míle ticéad faoin dara ceann, agus beidh beagnach gach tionscadal sa saol mór i gceist leis an dá rud.

Baisceáil: Próiseáil i nGrúpaí

Glacann API mistral-embed le liosta ionchuir, ach tá teorainneacha praiticiúla ann (méid an iarratais, líon na dtócan). Is é an réiteach ná do chorpas a roinnt ina bhaisceanna agus dul tríd i lúb. Déanann an fheidhm thíos go díreach é sin, ag taispeáint dul chun cinn—mionsonraí ríthábhachtach nuair a thógann sé nóiméad iomlán chun corpas iomlán a ionchódú agus nuair is gá duit a fháil amach an bhfuil an próiseas ag dul ar aghaidh nó an bhfuil sé greamaithe.

import numpy as np
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

def get_embeddings_by_chunks(data, chunk_size=25):
    """Encode a large list of texts in batches."""
    chunks = [data[x:x + chunk_size] for x in range(0, len(data), chunk_size)]
    embeddings = []

    for i, chunk in enumerate(chunks):
        print(f"Batch {i+1}/{len(chunks)} ({len(chunk)} texts)...")
        response = client.embeddings.create(
            model="mistral-embed",
            inputs=chunk,
        )
        embeddings.extend([d.embedding for d in response.data])

    return embeddings

# Example with 1000 documents
documents = [f"Document number {i} with varied content." for i in range(1000)]
all_embeddings = get_embeddings_by_chunks(documents, chunk_size=50)

print(f"Total: {len(all_embeddings)} embeddings of {len(all_embeddings[0])} dimensions")

Cinntíonn úsáid extend in ionad append go bhfuil ord na veicteoirí comhoiriúnach go beacht le hord an téacs ionchuir. Ligeann sé seo duit an bun-doiciméad a aisghabháil ó innéacs simplí níos déanaí.

Méid na Baisce a Optamú

Braitheann an méid baisce is fearr ar fhad meánach do chuid téacsanna: níl an meáchan céanna i dtócan ag caoga teideal alt agus caoga tuarascáil iomlána. In ionad tairiseach a roghnú go randamach, déan meastachán air ón gcorpas féin.

def optimal_batch_size(documents, max_tokens_per_batch=16000):
    """Estimate the optimal batch size."""
    # Rough estimate: 1 token ~ 4 characters in English
    avg_chars = sum(len(d) for d in documents) / len(documents)
    avg_tokens = avg_chars / 4

    batch_size = max(1, int(max_tokens_per_batch / avg_tokens))
    return min(batch_size, 100)  # Cap at 100

# Adjust based on your corpus
batch_size = optimal_batch_size(documents)
print(f"Recommended batch size: {batch_size}")

Níl an teorainn ag 100 cosmaideach: thairis sin, is cúis le caillteanas suntasach oibre baisc amháin a theipeann, agus éiríonn an chuimhne a úsáidtear don fhreagra suntasach.

Miondealú: Téacs a Roinnt

Caithfear téacsanna fada a roinnt ina mion-chodanna sula ndéantar iad a ionchódú. Tá roinnt straitéisí ann, gach ceann acu lena bhuntáistí féin, agus bíonn tionchar díreach ag an rogha ar cháilíocht na freagartha: cruthaíonn mion-chuid a thosaíonn i lár abairte veicteoir doiléir, rud a fhágann go mbíonn torthaí cuardaigh doiléir.

Roinnt Bunaithe ar Charachtair (Simplí)

Is é an modh is díreacha ná gach N carachtar a ghearradh, beag beann ar an ábhar. Is é a thuilleamh ná intuarthacht agus luas, rud a fhágann go bhfuil sé inghlactha do phrótaitíopa nó do théacs gan struchtúr soiléir.

def chunk_by_chars(text, chunk_size=2048, overlap=200):
    """Split text into chunks with overlap."""
    chunks = []
    start = 0
    while start < len(text):
        end = start + chunk_size
        chunk = text[start:end]
        chunks.append(chunk)
        start = end - overlap  # Overlap for context
    return chunks

long_text = "A very long document..." * 500
chunks = chunk_by_chars(long_text, chunk_size=2048, overlap=200)
print(f"{len(chunks)} chunks created")

Roinnt Bunaithe ar Mhíreanna (Molta)

Urramaíonn roinnt bunaithe ar mhíreanna an t-aonad brí atá beartaithe ag an údar. I ndoiciméadú táirge, déileálann gach mír go hiondúil le pointe sonrach; má choinnítear slán é, faightear mion-chuid ar féidir léi freagra a thabhairt ar cheist léi féin. Carnann an fheidhm míreanna go dtí go sáraítear an méid uasta, agus ansin dúnann sí an mion-chuid reatha.

def chunk_by_paragraphs(text, max_chunk_size=2048):
    """Split while respecting paragraph boundaries."""
    paragraphs = text.split("\n\n")
    chunks = []
    current_chunk = ""

    for para in paragraphs:
        if len(current_chunk) + len(para) + 2 > max_chunk_size:
            if current_chunk:
                chunks.append(current_chunk.strip())
            current_chunk = para
        else:
            current_chunk += "\n\n" + para if current_chunk else para

    if current_chunk:
        chunks.append(current_chunk.strip())

    return chunks

Roinnt Bunaithe ar Abairtí

Nuair nach bhfuil míreanna inúsáidte sa téacs—tráchtáil glao, loga reatha—is í an abairt an t-aonad brí is lú atá ar fáil. Leanann an roinnt ansin an loighic charntha céanna, ag brath ar chomharthaí poncaíochta deireadh na habairte.

import re

def chunk_by_sentences(text, max_chunk_size=1500):
    """Split while respecting sentence boundaries."""
    # Split on end-of-sentence punctuation
    sentence_pattern = r'(?<=[.!?])\s+'
    sentences = re.split(sentence_pattern, text)
    chunks = []
    current_chunk = ""

    for sentence in sentences:
        if len(current_chunk) + len(sentence) + 1 > max_chunk_size:
            if current_chunk:
                chunks.append(current_chunk.strip())
            current_chunk = sentence
        else:
            current_chunk += " " + sentence if current_chunk else sentence

    if current_chunk:
        chunks.append(current_chunk.strip())

    return chunks

Forluí

Cuireann forluí idir mion-chodanna cosc ar smaoineamh a ghearradh ina dhá leath. Trí fhorluí 10% go 20% de mhéid na mion-chuide a chur leis, coinníonn tú comhthéacs idir píosaí cóngaracha. Samhlaigh nós imeachta ina bhfuil deireadh le céim 4 ag carachtar 2040 agus mínítear an toradh díreach ina dhiaidh sin: gan fhorluí, ní bhíonn an dá leath den réasúnaíocht in aon mhion-chuid amháin, agus ní aisghabhfaidh an cuardach an freagra iomlán riamh.

Seo thíos na luachanna a fhónann mar phointí tosaigh chruthaithe ag brath ar chineál an ábhair:

# Recommended parameters by content type
PARAMS = {
    "articles":     {"chunk_size": 1500, "overlap": 200},
    "documentation": {"chunk_size": 1000, "overlap": 150},
    "conversations": {"chunk_size": 500,  "overlap": 50},
    "code":          {"chunk_size": 2000, "overlap": 300},
}

Titann comhráite go 500 carachtar toisc go bhfuil cas cainte gairid, agus chumascfadh mion-chuid níos mó iltopaicí; éiríonn cód go 2000 le forluí flaithiúil toisc go gcailleann feidhm brí má scarann a síniú óna corp.

Píblíne Iomlán: Miondealú + Baisceáil + Ionchódú

Seo conas miondealú agus baisceáil a chomhcheangal i bpíblíne táirgeachta. Is é an eilimint nach mór duit a neamhaird ná chunk_metadata: gan é, faigheann tú veicteoirí dílleachta nach féidir leo a léiriú cén doiciméad as a dtagann siad, agus ní bheidh tú in ann do fhoinsí a lua sa fhreagra deiridh riamh.

def pipeline_embed(documents, chunk_size=1500, overlap=200, batch_size=50):
    """Complete pipeline: chunk, batch, embed."""
    # 1. Chunk all documents
    all_chunks = []
    chunk_metadata = []  # Track source document

    for doc_idx, doc in enumerate(documents):
        chunks = chunk_by_paragraphs(doc, max_chunk_size=chunk_size)
        for chunk_idx, chunk in enumerate(chunks):
            all_chunks.append(chunk)
            chunk_metadata.append({
                "doc_index": doc_idx,
                "chunk_index": chunk_idx,
            })

    print(f"{len(documents)} documents -> {len(all_chunks)} chunks")

    # 2. Encode in batches
    embeddings = get_embeddings_by_chunks(all_chunks, chunk_size=batch_size)

    # 3. Return structured results
    return {
        "chunks": all_chunks,
        "embeddings": np.array(embeddings),
        "metadata": chunk_metadata,
    }

# Usage
result = pipeline_embed(documents)
print(f"Embeddings: {result['embeddings'].shape}")

Rith an phíblíne seo ar dhosaen de do chuid doiciméad féin agus scrúdaigh all_chunks leis an tsúil sula ndéanann tú aon rud a ionchódú ar scála mór. Tá miondealú mícheart le feiceáil láithreach nuair a léann tú é, cé nach dtaispeánann sé riamh i gcruth na maitríse.

Príomhphointí

  • Ligeann baisceáil duit na mílte doiciméad a ionchódú gan sárú ar theorainneacha API
  • Roinneann miondealú téacsanna fada le haghaidh gráinníocht shéimeantach níos fearr
  • Coinníonn forluí 10–20% idir mion-chodanna an comhthéacs
  • Is fearr roinnt bunaithe ar mhíreanna nó ar abairtí ná roinnt bunaithe ar charachtair
  • Coinnigh meiteashonraí (bundoiciméad, suíomh) do gach mion-chuid