Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Kötegelés és darabolás

4. lecke 18 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. A nagy mennyiségek kihívása
  2. Kötegelés: Csoportos feldolgozás
  3. Darabolás: Szöveg felosztása
  4. Átfedés
  5. Teljes folyamat: Darabolás + Kötegelés + Beágyazás
  6. Főbb megállapítások

A nagy mennyiségek kihívása

Amikor több ezer dokumentummal dolgozol, nem kódolhatsz le mindent egyetlen API-hívásban. Kezelned kell a kötegelést (csoportos feldolgozás) és a darabolást (szöveg felosztása). Ez a két technika elengedhetetlen a nagy léptékű szemantikus keresőrendszerek felépítéséhez.

A két fogalom hasonlónak hangzik, de ellentétes problémákat oldanak meg. A darabolás egyetlen, túl nagy dokumentummal foglalkozik, amelyet nem lehet hatékonyan egészben kódolni; a kötegelés pedig túl sok dokumentum kezelésére szolgál, amelyek nem férnek bele egyetlen kérésbe. Egy háromszáz oldalas műszaki kézikönyv az első kategóriába esik, egy húszezer jegyet tartalmazó export a másodikba, egy valós projekt pedig szinte mindig mindkettőt igényli.

Kötegelés: Csoportos feldolgozás

A mistral-embed API bemenetek listáját fogadja el, de gyakorlati korlátok léteznek (kérés mérete, tokenek száma). A megoldás az, hogy a korpuszt kötegekre osztod, és végigiterálsz rajtuk. Az alábbi függvény pontosan ezt teszi, haladást jelezve – ez kritikus részlet, amikor egy teljes korpusz kódolása több percig tart, és tudnod kell, hogy a folyamat halad-e vagy beragadt.

import numpy as np
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

def get_embeddings_by_chunks(data, chunk_size=25):
    """Nagy szöveglista kódolása kötegekben."""
    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

# Példa 1000 dokumentummal
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")

Az extend használata az append helyett biztosítja, hogy a vektorok sorrendje pontosan megegyezzen a bemeneti szövegek sorrendjével. Ez lehetővé teszi, hogy később egy egyszerű index alapján visszakeresd az eredeti dokumentumot.

A kötegméret optimalizálása

Az optimális kötegméret a szövegeid átlagos hosszától függ: ötven cikkcím és ötven teljes jelentés tokenekben mérve nem ugyanannyit nyom. Ahelyett, hogy véletlenszerűen választanál egy konstansot, becsüld meg ezt magából a korpuszból.

def optimal_batch_size(documents, max_tokens_per_batch=16000):
    """Az optimális kötegméret becslése."""
    # Durva becslés: 1 token ~ 4 karakter angolul
    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)  # Maximum 100-nál

# Igazítás a korpuszhoz
batch_size = optimal_batch_size(documents)
print(f"Recommended batch size: {batch_size}")

A 100-as felső korlát nem kozmetikai: efelett egyetlen sikertelen köteg is jelentős munkaveszteséget okoz, és a válasz által fogyasztott memória is jelentőssé válik.

Darabolás: Szöveg felosztása

A hosszú szövegeket kódolás előtt darabokra kell osztani. Több stratégia létezik, mindegyiknek megvannak az előnyei, és a választás közvetlenül befolyásolja a válaszok minőségét: egy olyan darab, amely egy mondat közepén kezdődik, elmosódott vektort eredményez, ami elmosódott keresési találatokhoz vezet.

Karakteralapú felosztás (Egyszerű)

A legközvetlenebb módszer minden N. karakternél vág, függetlenül a tartalomtól. Erénye a kiszámíthatóság és a sebesség, így prototípusokhoz vagy egyértelmű szerkezet nélküli szövegekhez elfogadható.

def chunk_by_chars(text, chunk_size=2048, overlap=200):
    """Szöveg felosztása átfedő darabokra."""
    chunks = []
    start = 0
    while start < len(text):
        end = start + chunk_size
        chunk = text[start:end]
        chunks.append(chunk)
        start = end - overlap  # Átfedés a kontextus miatt
    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")

Bekezdésalapú felosztás (Ajánlott)

A bekezdésalapú felosztás tiszteletben tartja a szerző által szánt jelentésegységet. Termékdokumentációban minden bekezdés általában egy konkrét pontot fed le; ha ezt egyben hagyod, olyan darabot kapsz, amely önmagában is képes megválaszolni egy kérdést. A függvény addig gyűjti a bekezdéseket, amíg el nem éri a maximális méretet, majd lezárja az aktuális darabot.

def chunk_by_paragraphs(text, max_chunk_size=2048):
    """Felosztás bekezdéshatárok tiszteletben tartásával."""
    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

Mondataalapú felosztás

Amikor a szövegben nincsenek használható bekezdések – például hívásátirat vagy napló –, a mondat válik a legkisebb rendelkezésre álló jelentésegységgé. A felosztás ekkor ugyanazt a gyűjtési logikát követi, a mondatvégi írásjelekre támaszkodva.

import re

def chunk_by_sentences(text, max_chunk_size=1500):
    """Felosztás mondatvégek tiszteletben tartásával."""
    # Felosztás mondatvégi írásjeleknél
    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

Átfedés

A darabok közötti átfedés megakadályozza, hogy egy gondolatot kettévágj. A darab méretének 10–20%-át kitevő átfedés hozzáadásával megőrzöd a kontextust a szomszédos részek között. Képzelj el egy eljárást, ahol a 4. lépés a 2040. karakternél ér véget, és a következményt azonnal ezután magyarázzák el: átfedés nélkül egyetlen darab sem tartalmazza az érvelés mindkét felét, és a keresés sosem fogja visszahozni a teljes választ.

Az alábbi értékek tartalomtípustól függően bevált kiindulópontként szolgálnak:

# Ajánlott paraméterek tartalomtípus szerint
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},
}

A beszélgetések esetén 500 karakterre csökken a méret, mert egy beszédfordulat rövid, és egy nagyobb darab több témát keverne össze; a kód esetén 2000-re nő, generózus átfedéssel, mert egy függvény elveszíti a jelentését, ha az aláírását elválasztják a törzsétől.

Teljes folyamat: Darabolás + Kötegelés + Beágyazás

Így kombinálhatod a darabolást és a kötegelést egy éles környezeti folyamatban. Amit nem szabad elhanyagolnod, az a chunk_metadata: enélkül árva vektorokat kapsz, amelyek nem tudják jelezni, melyik dokumentumból származnak, és sosem lesz képes hivatkozni a forrásaidra a végső válaszban.

def pipeline_embed(documents, chunk_size=1500, overlap=200, batch_size=50):
    """Teljes folyamat: darabolás, kötegelés, beágyazás."""
    # 1. Minden dokumentum darabolása
    all_chunks = []
    chunk_metadata = []  # Forrásdokumentum követése

    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. Kódolás kötegekben
    embeddings = get_embeddings_by_chunks(all_chunks, chunk_size=batch_size)

    # 3. Strukturált eredmények visszaadása
    return {
        "chunks": all_chunks,
        "embeddings": np.array(embeddings),
        "metadata": chunk_metadata,
    }

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

Futtasd ezt a folyamatot egy tucatnyi valódi dokumentumodon, és szemrevételezéssel ellenőrizd az all_chunks tartalmát, mielőtt nagy léptékben kódolnál bármit is. Egy rossz felosztás olvasás közben azonnal látszik, míg a mátrix alakján sosem mutatkozik meg.

Főbb megállapítások

  • A kötegelés lehetővé teszi több ezer dokumentum kódolását az API-korlátok túllépése nélkül
  • A darabolás felosztja a hosszú szövegeket a jobb szemantikus granularitás érdekében
  • A darabok közötti 10–20%-os átfedés megőrzi a kontextust
  • A bekezdés- vagy mondatalapú felosztás előnyösebb a karakteralapúval szemben
  • Minden darabhoz tartsd meg a metaadatokat (forrásdokumentum, pozíció)