Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Dávkové zpracování a rozdělování na části

Lekce 4 z 18 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Výzva velkých objemů dat
  2. Dávkové zpracování: Zpracování ve skupinách
  3. Rozdělování na části: Splitting textu
  4. Překryv (Overlap)
  5. Kompletní pipeline: Rozdělení + Dávkování + Vnoření
  6. Klíčové poznatky

Výzva velkých objemů dat

Když pracuješ s tisíci dokumentů, nemůžeš vše zakódovat v jediném volání API. Musíš zvládat dávkové zpracování (zpracování ve skupinách) a rozdělování na části (splitting textu). Tyto dvě techniky jsou nezbytné pro budování sémantických vyhledávacích systémů ve velkém měřítku.

Oba pojmy znějí podobně, ale řeší opačné problémy. Rozdělování na části (chunking) řeší jednotlivý dokument, který je příliš velký na to, aby byl efektivně zakódován jako celek; dávkové zpracování (batching) řeší příliš mnoho dokumentů, které se nevejdou do jednoho požadavku. Třísetstránkový technický manuál spadá do první kategorie, export dvaceti tisíc tiketů do druhé a reálný projekt téměř vždy zahrnuje obojí.

Dávkové zpracování: Zpracování ve skupinách

API mistral-embed přijímá seznam vstupů, ale existují praktická omezení (velikost požadavku, počet tokenů). Řešením je rozdělit tvůj korpus na dávky a iterovat jimi. Níže uvedená funkce dělá přesně tohle a zobrazuje průběh – což je kritický detail, když kódování celého korpusu trvá několik minut a potřebuješ vědět, zda proces postupuje, nebo zasekl.

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žití extend místo append zajišťuje, že pořadí vektorů přesně odpovídá pořadí vstupního textu. To ti umožňuje později získat původní dokument pomocí jednoduchého indexu.

Optimalizace velikosti dávky

Optimální velikost dávky závisí na průměrné délce tvých textů: padesát názvů článků a padesát celých reportů nemá stejnou váhu v tocenech. Místo náhodného výběru konstanty ji odhadni přímo 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}")

Omezení na 100 není jen kosmetické: nad touto hranicí způsobí jedna neúspěšná dávka významnou ztrátu práce a paměť spotřebovaná odpovědí se stane substantialní.

Rozdělování na části: Splitting textu

Dlouhé texty musí být před zakódováním rozděleny na části (chunks). Existuje několik strategií, každá má své výhody a volba přímo ovlivňuje kvalitu odpovědí: část, která začíná uprostřed věty, vytvoří rozmazaný vektor, což vede k nepřesným výsledkům vyhledávání.

Rozdělování podle znaků (Jednoduché)

Nejpřímější metoda řeže každých N znaků bez ohledu na obsah. Její předností je předvídatelnost a rychlost, což ji činí přijatelnou pro prototypy nebo pro texty bez jasné struktury.

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

Rozdělování podle odstavců (Doporučené)

Rozdělování podle odstavců respektuje jednotku významu zamýšlenou autorem. V produktové dokumentaci každý odstavec obvykle pokrývá konkrétní bod; jeho zachování v celku vytváří část, která dokáže samostatně odpovědět na otázku. Funkce akumuluje odstavce, dokud není překročena maximální velikost, a poté uzavře aktuální část.

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

Rozdělování podle vět

Když text postrádá použitelné odstavce – například přepis hovoru nebo běžící log – stává se věta nejmenší dostupnou jednotkou významu. Rozdělování pak následuje stejnou logiku akumulace a spoléhá na interpunkci označující konec věty.

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

Překryv (Overlap)

Překryv mezi částmi zabraňuje rozříznutí myšlenky napůl. Přidáním překryvu o velikosti 10 % až 20 % velikosti části zachováváš kontext mezi sousedními úseky. Představ si postup, kde krok 4 končí na znaku 2040 a důsledek je vysvětlen okamžitě poté: bez překryvu žádná část neobsahuje obě poloviny úvahy a vyhledávání nikdy nezíská úplnou odpověď.

Níže uvedené hodnoty slouží jako osvědčené výchozí body v závislosti na 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},
}

Konverzace klesají na 500 znaků, protože obrat řeči je krátký a větší část by smíchala více témat; kód stoupá na 2000 s velkorysým překryvem, protože funkce ztrácí smysl, pokud je její signatura oddělena od těla funkce.

Kompletní pipeline: Rozdělení + Dávkování + Vnoření

Zde je návod, jak kombinovat rozdělování na části a dávkové zpracování v produkčním pipeline. Prvek, který nesmíš opomenout, je chunk_metadata: bez něj získáš osiřelé vektory, které nedokážou určit, ze kterého dokumentu pocházejí, a nikdy nebudeš schopen citovat své zdroje v konečné odpovědi.

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ť toto pipeline na tuctu svých skutečných dokumentů a vizuálně zkontroluj all_chunks před tím, než začneš kódovat ve velkém měřítku. Špatné rozdělení je okamžitě vidět při čtení, zatímco v tvaru matice se nikdy neprojeví.

Klíčové poznatky

  • Dávkové zpracování ti umožňuje zakódovat tisíce dokumentů bez překročení limitů API
  • Rozdělování na části štěpí dlouhé texty pro lepší sémantickou granularitu
  • Překryv 10–20 % mezi částmi zachovává kontext
  • Rozdělování podle odstavců nebo vět je vhodnější než podle znaků
  • Pro každou část uchovávej metadata (zdrojový dokument, pozice)