Dávkové spracovanie a rozdelenie na časti
Na tejto strane
Výzva veľkých objemov
Keď pracuješ s tisícami dokumentov, nemôžeš všetko zakódovať v jednom volaní API. Musíš zvládnuť dávkové spracovanie (spracovanie v skupinách) a rozdelenie na časti (splitting textu). Tieto dve techniky sú nevyhnutné pre budovanie systémov sémantického vyhľadávania vo veľkom meradle.
Tieto dva koncepty znejú podobne, ale riešia opačné problémy. Rozdelenie na časti (chunking) rieši jeden dokument, ktorý je príliš veľký na to, aby bol efektívne zakódovaný ako celok; dávkové spracovanie (batching) rieši príliš veľa dokumentov na to, aby sa zmestili do jednej požiadavky. Technická príručka s tristo stranami patrí do prvej kategórie, export dvadsiatich tisíc lístkov do druhej a reálny projekt takmer vždy zahŕňa obe.
Dávkové spracovanie: Spracovanie v skupinách
API mistral-embed akceptuje zoznam vstupov, ale existujú praktické obmedzenia (veľkosť požiadavky, počet tokenov). Riešením je rozdeliť tvoj korpus na dávky a prechádzať ich v cykle. Funkcia nižšie robí presne toto a zobrazuje priebeh – čo je kritický detail, keď zakódovanie celého korpusu trvá niekoľko minút a potrebuješ vedieť, či proces postupuje, alebo zasekol.
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")
Použitie extend namiesto append zabezpečuje, že poradie vektorov presne zodpovedá poradiu vstupného textu. To ti umožňuje neskôr získať pôvodný dokument pomocou jednoduchého indexu.
Optimalizácia veľkosti dávky
Optimálna veľkosť dávky závisí od priemernej dĺžky tvojich textov: päťdesiat názvov článkov a päťdesiat celých správ nemá rovnakú váhu v tokenoch. Namiesto náhodného výberu konštanty ju odhadni priamo z korpusu.
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}")
Obmedzenie na 100 nie je len kozmetické: nad touto hranou spôsobí jedna neúspešná dávka významnú stratu práce a pamäť spotrebovaná odpoveďou sa stane substantialnou.
Rozdelenie na časti: Splitting textu
Dlhé texty sa musia pred zakódovaním rozdeliť na časti (chunks). Existuje niekoľko stratégií, každá so svojimi výhodami, a výber priamo ovplyvňuje kvalitu odpovede: časť, ktorá začína v polovici vety, vytvorí rozmazaný vektor, čo vedie k rozmazaným výsledkom vyhľadávania.
Rozdelenie podľa znakov (Jednoduché)
Najpriamejšia metóda odreže každých N znakov bez ohľadu na obsah. Jej výhodou je predvídateľnosť a rýchlosť, čo ju robí prijateľnou pre prototyp alebo pre text bez jasnej štruktúry.
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")
Rozdelenie podľa odsekov (Odporúčané)
Rozdelenie podľa odsekov rešpektuje jednotku významu zamýšľanú autorom. V produktovej dokumentácii každý odsek zvyčajne pokrýva konkrétny bod; jeho zachovanie v celku vytvára časť, ktorá dokáže samostatne odpovedať na otázku. Funkcia akumuluje odseky, kým nie je prekročená maximálna veľkosť, a potom uzavrie aktuálnu časť.
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
Rozdelenie podľa viet
Keď text neobsahuje použiteľné odseky – prepis hovoru, bežiaci log – veta sa stáva najmenšou dostupnou jednotkou významu. Rozdelenie potom nasleduje rovnakú logiku akumulácie a spolieha sa na interpunkciu na konci vety.
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
Prekrytie
Prekrytie medzi časťami zabraňuje prerezaniu myšlienky napoly. Pridaním prekrytia (overlap) vo výške 10 % až 20 % veľkosti časti zachovávaš kontext medzi susednými kusmi. Predstav si postup, kde krok 4 končí na znaku 2040 a dôsledok je vysvetlený okamžite po ňom: bez prekrytia žiadna časť neobsahuje obe polovice úvahy a vyhľadávanie nikdy nezíska úplnú odpoveď.
Hodnoty nižšie slúžia ako overené východiskové body v závislosti od typu obsahu:
# 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},
}
Konverzácie klesajú na 500 znakov, pretože obrat reči je krátky a väčšia časť by zmiešala viacero tém; kód stúpa na 2000 so štedrým prekrytím, pretože funkcia stráca význam, ak je jej signatúra oddelená od tela funkcie.
Kompletný pipeline: Rozdelenie + Dávkovanie + Vektorizácia
Tu je spôsob, ako kombinovať rozdelenie na časti a dávkové spracovanie v produkčnom pipeline. Prvok, ktorý nesmieš zanedbať, je chunk_metadata: bez neho získavaš osamelé vektory, ktoré nedokážu indikovať, z ktorého dokumentu pochádzajú, a nikdy nebudeš môcť citovať svoje zdroje v konečnej odpovedi.
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}")
Spusť tento pipeline na tucte svojich skutočných dokumentov a vizuálne skontroluj all_chunks predtým, než začneš kódovať vo veľkom meradle. Zlé rozdelenie je okamžite viditeľné pri čítaní, zatiaľ čo v tvare matice sa nikdy neprejaví.
Kľúčové poznatky
- Dávkové spracovanie ti umožňuje zakódovať tisíce dokumentov bez prekročenia limitov API
- Rozdelenie na časti splituje dlhé texty pre lepšiu sémantickú granularitu
- Prekrytie 10 – 20 % medzi časťami zachováva kontext
- Rozdelenie podľa odsekov alebo viet je vhodnejšie ako rozdelenie podľa znakov
- Pre každú časť si uchovávaj metadáta (zdrojový dokument, pozícia)