Kötegelés és darabolás
Ezen az oldalon
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ó)