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

Batching u Chunking

Lezzjoni 4 / 18 Aġġornat 2 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. L-Isfida tal-Volumi Kbar
  2. Batching: Ipproċessar fi Gruppi
  3. Chunking: Qsim tat-Test
  4. Overlap (Sovrappożizzjoni)
  5. Pipeline Sħiħa: Chunk + Batch + Embed
  6. Punti Ewlenin

L-Isfida tal-Volumi Kbar

Meta taħdem ma’ eluf ta’ dokumenti, ma tistax tikkodifika kollox f’sejħa API waħda. Trid timmaniġġja l-batching (ipproċessar fi gruppi) u l-chunking (qsim tat-test). Dawn iż-żewġ tekniki huma essenzjali biex tibni sistemi ta’ tiftix semantiku fuq skala kbira.

Iż-żewġ kunċetti jidhru simili iżda jsolvu problemi opposti. Il-chunking jittratta dokument wieħed li huwa kbir wisq biex jiġi kkodifikat b’mod effettiv bħala sħiħ; il-batching jittratta wisq dokumenti biex joqogħdu f’talba waħda. Manwal tekniku ta’ tliet mitt paġna jaqa’ fl-ewwel kategorija, esportazzjoni ta’ għoxrin elf biljett fit-tieni, u proġett fid-dinja reali kważi dejjem jinvolvi t-tnejn.

Batching: Ipproċessar fi Gruppi

L-API mistral-embed taċċetta lista ta’ inputs, iżda hemm limiti prattiċi (daqs it-talba, għadd ta’ tokens). Is-soluzzjoni hija li taqsam il-corpus tiegħek f’batches u tgħaddi minnhom b’loop. Il-funzjoni hawn taħt tagħmel eżattament dan, turi l-progress—detall kritiku meta l-kodifika ta’ corpus sħiħ tieħu diversi minuti u għandek bżonn tkun taf jekk il-proċess qed jimxi jew jekk imblukkatx.

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")

L-użu ta’ extend minflok append jiżgura li l-ordni tal-vetturi taqbel eżattament mal-ordni tat-test tal-input. Dan jippermettilek tirrikupra d-dokument oriġinali minn indiċi sempliċi aktar tard.

Ottimizzazzjoni tad-Daqs tal-Batch

Id-daqs ottimali tal-batch jiddependi mit-tul medju tat-testi tiegħek: ħamsin titlu ta’ artiklu u ħamsin rapport sħiħ ma jiżnux l-istess f’termini ta’ tokens. Minflok ma tagħżel kostanti b’mod każwali, stma dan mill-corpus innifsu.

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}")

Il-limitu massimu (cap) ta’ 100 mhuwiex kożmetiku: lil hinn minn hekk, batch wieħed li jfalli jikkawża telf sinifikanti ta’ xogħol, u l-memorja kkunsmata mir-rispons issir sostanzjali.

Chunking: Qsim tat-Test

It-testi twal iridu jiġu maqsuma f’chunks qabel il-kodifika. Jeżistu diversi strateġiji, kull waħda bil-vantaġġi tagħha, u l-għażla taffettwa direttament il-kwalità tar-rispons: chunk li jibda f’nofs sentenza jipproduċi vettur imċajpar, li jwassal għal riżultati ta’ tiftix imċajpra.

Qsim Ibbażat fuq il-Karattri (Sempliċi)

L-aktar metodu dirett jaqta’ kull N karattru, irrispettivament mill-kontenut. Il-mertu tiegħu huwa l-prevedibbiltà u l-veloċità, u jagħmlu aċċettabbli għal prototip jew għal test mingħajr struttura ċara.

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")

Qsim Ibbażat fuq il-Paragrafi (Rakkomandat)

Il-qsim ibbażat fuq il-paragrafi jirrispetta l-unità ta’ tifsira maħsuba mill-awtur. Fid-dokumentazzjoni tal-prodott, kull paragrafu ġeneralment ikopri punt speċifiku; iż-żamma tiegħu intatt tipproduċi chunk li jista’ jwieġeb mistoqsija waħdu. Il-funzjoni takkumula l-paragrafi sakemm id-daqs massimu jinqabeż, imbagħad tagħlaq il-chunk attwali.

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

Qsim Ibbażat fuq is-Sentenzi

Meta t-test ma jkollux paragrafi utilizzabbli—traskrizzjoni ta’ sejħa, log li għaddej—is-sentenza ssir l-iżgħar unità disponibbli ta’ tifsira. Il-qsim imbagħad isegwi l-istess loġika ta’ akkumulazzjoni, jiddependi fuq il-punteġġjar ta’ tmiem is-sentenza.

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

Overlap (Sovrappożizzjoni)

L-overlap bejn il-chunks jipprevjeni li taqsam idea f’nofsaha. Billi żżid overlap ta’ 10% sa 20% tad-daqs tal-chunk, iżżomm il-kuntest bejn biċċiet adjaċenti. Imaġina proċedura fejn il-pass 4 jispiċċa fil-karattru 2040 u l-konsegwenza hija spjegata immedjatament wara: mingħajr overlap, l-ebda chunk ma fih iż-żewġ nofsijiet tar-raġunament, u t-tiftix qatt ma jirkupra t-tweġiba sħiħa.

Il-valuri hawn taħt iservu bħala punti tat-tluq ippruvati skont it-tip ta’ kontenut:

# 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},
}

Il-konversazzjonijiet jinżlu għal 500 karattru għax dawra ta’ kelma hija qasira, u chunk akbar iħallat diversi suġġetti; il-kodiċi jitla’ għal 2000 b’overlap ġeneruż għax funzjoni titlef it-tifsira jekk is-sinjalatura tagħha tiġi separata mill-korp tagħha.

Pipeline Sħiħa: Chunk + Batch + Embed

Hekk tikkombina l-chunking u l-batching f’pipeline tal-produzzjoni. L-element li m’għandekx tonqos huwa chunk_metadata: mingħajru, tikseb vetturi orfni li ma jistgħux jindikaw minn liema dokument ġejjin, u qatt ma tkun tista’ tiċċita s-sorsi tiegħek fir-rispons finali.

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}")

Iddi din il-pipeline fuq doġġina mid-dokumenti attwali tiegħek u spezzjona all_chunks b’għajnejk qabel ma tikkodifika xejn fuq skala kbira. Qsim ħażin jidher immedjatament meta taqra, filwaqt li qatt ma jidher fil-forma tal-matriċi.

Punti Ewlenin

  • Il-batching jippermettilek tikkodifika eluf ta’ dokumenti mingħajr ma taqbeż il-limiti tal-API
  • Il-chunking jaqsam testi twal għal granularità semantika aħjar
  • Overlap ta’ 10–20% bejn il-chunks iżomm il-kuntest
  • Il-qsim b’paragrafi jew sentenzi huwa preferibbli għall-qsim b’karattri
  • Żomm il-metadata (dokument sors, pożizzjoni) għal kull chunk