Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Dávkové spracovanie a rozdelenie na časti

Lekcia 4 z 18 Aktualizované 2. novembra 2026 Vývojár
Na tejto strane
  1. Výzva veľkých objemov
  2. Dávkové spracovanie: Spracovanie v skupinách
  3. Rozdelenie na časti: Splitting textu
  4. Prekrytie
  5. Kompletný pipeline: Rozdelenie + Dávkovanie + Vektorizácia
  6. Kľúčové poznatky

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)