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

Vytváření vnoření (Embeddings)

Lekce 11 z 18 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Kódování úryvků do vektorů
  2. Dávkové kódování
  3. Překonávání chyb sítě
  4. Uložení indexu na disk
  5. Ověření před pokračováním
  6. Klíčové poznatky

Kódování úryvků do vektorů

Tvé dokumenty jsou nyní rozděleny na čisté úryvky. Dalším krokem je jejich transformace na vnoření (embeddings) pomocí API mistral-embed a následné uložení těchto vektorů do vektorového úložiště, které bude fungovat jako tvůj vyhledávač. V tento okamžik přestává být tvůj korpus obyčejným textem a stává se dotazovatelnou geometrií. Několik inženýrských opatření – dávkování, opakované pokusy a perzistence – rozhoduje o tom, zda vznikne křehký prototyp, nebo spolehlivý index.

Pro malý korpus, řekněme méně než sto úryvků, stačí jediný přímý požadavek. Extrahuj text ze svých slovníků s úryvky, předej je API tak, jak jsou, a získej celou matici. Tvar (87, 1024) zobrazený na konci běhu je tvou první kontrolou sanity: tolik řádků, kolik máš úryvků, a 1024 sloupců, protože to je dimenze modelu mistral-embed. Pokud se počet řádků neshoduje, proklouzlo do dávky prázdné místo.

import numpy as np
from mistralai.client import Mistral

client = Mistral(api_key=api_key)

# Assume chunks is the list of our prepared chunks
chunk_texts = [c["text"] for c in chunks]

# Encode in a single call
response = client.embeddings.create(
    model="mistral-embed",
    inputs=chunk_texts,
)

embeddings = np.array([d.embedding for d in response.data])
print(f"Embeddings: {embeddings.shape}")
# Embeddings: (87, 1024) for example

Dávkové kódování

Při překročení několika desítek úryvků narazíš u jediného volání na limity API. Řešením je rozdělit seznam na dávky a výsledky spojit. Níže uvedená funkce zpracovává úseky po 25 kusech a zobrazuje průběh. Není to jen kosmetika: u korpusu o několika tisících úryvcích trvá kódování několik minut a budeš chtít vědět, kde se proces nachází, místo abys zíral na němý terminál. Pořadí zůstává zachováno, takže každý vektor zůstává zarovnán se svým odpovídajícím úryvkem v původním seznamu.

def encode_chunks(chunks, batch_size=25, model="mistral-embed"):
    """Encode a list of chunks in batches."""
    texts = [c["text"] for c in chunks]
    all_embeddings = []

    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]
        print(f"  Encoding batch {i // batch_size + 1}/{(len(texts) - 1) // batch_size + 1} "
              f"({len(batch)} chunks)...")

        response = client.embeddings.create(
            model=model,
            inputs=batch,
        )
        all_embeddings.extend([d.embedding for d in response.data])

    return np.array(all_embeddings)

# Encode all chunks
embeddings = encode_chunks(chunks, batch_size=25)
print(f"Total: {embeddings.shape[0]} vectors of {embeddings.shape[1]} dimensions")

Překonávání chyb sítě

V produkčním prostředí dříve či později některý požadavek na API selže: výpadek sítě, dosažení limitu rychlosti nebo dočasná nedostupnost. Bez ochrany se tvé indexování zastaví u dávky 180 ze 400 a jsi zase na začátku. Robustní verze obalí každou dávku smyčkou s opakovanými pokusy využívající exponenciální backoff – jedna sekunda, pak dvě, pak čtyři. Toto zvyšující se časování je klíčové: okamžité opakování po zamítnutí kvůli kvótě situaci jen zhorší. Po třech po sobě jdoucích selháních funkce vyvolá explicitní výjimku s názvem chybné dávky, místo aby vrátila zkrácenou matici, kde bys na mezeru přišel až během vyhledávání.

import time

def encode_chunks_robust(chunks, batch_size=25, max_retries=3):
    """Robust encoding with error handling."""
    texts = [c["text"] for c in chunks]
    all_embeddings = []

    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]

        for attempt in range(max_retries):
            try:
                response = client.embeddings.create(
                    model="mistral-embed",
                    inputs=batch,
                )
                all_embeddings.extend([d.embedding for d in response.data])
                break  # Success, exit retry loop

            except Exception as e:
                wait_time = 2 ** attempt  # Exponential backoff: 1s, 2s, 4s
                print(f"  Error in batch {i // batch_size + 1}, "
                      f"attempt {attempt + 1}/{max_retries}: {e}")
                if attempt < max_retries - 1:
                    print(f"  Waiting {wait_time}s before retry...")
                    time.sleep(wait_time)
                else:
                    raise RuntimeError(
                        f"Failed after {max_retries} attempts for batch {i // batch_size + 1}"
                    )

    return np.array(all_embeddings)

Uložení indexu na disk

Každé spuštění kódování stojí čas a peníze za volání API. Přepočítávání vektorů pokaždé, když se aplikace spustí, je čistý plýtvání, zejména když se samotný korpus nezměnil. Ukládání probíhá do dvou doplňkových souborů: vektory jdou do formátu NumPy, což je kompaktní binární formát, který se načítá okamžitě, zatímco metadata – text, zdroj, pozice – jdou do čitelného JSON, který můžeš otevřít a zkontrolovat podezřelý úryvek. Oba soubory jsou na sobě závislé a propojené pořadím řádků: nikdy jeden negeneruj bez druhého, jinak budou tvé výsledky vyhledávání ukazovat na špatné texty.

import json

def save_index(chunks, embeddings, filepath="rag_index"):
    """Save chunks and embeddings."""
    # Save embeddings (NumPy)
    np.save(f"{filepath}_embeddings.npy", embeddings)

    # Save metadata (JSON)
    metadata = []
    for c in chunks:
        metadata.append({
            "text": c["text"],
            "source": c.get("source", ""),
            "chunk_index": c.get("chunk_index", 0),
        })
    with open(f"{filepath}_metadata.json", "w", encoding="utf-8") as f:
        json.dump(metadata, f, ensure_ascii=False, indent=2)

    print(f"Index saved: {len(chunks)} chunks, {embeddings.shape}")


def load_index(filepath="rag_index"):
    """Load chunks and embeddings from disk."""
    embeddings = np.load(f"{filepath}_embeddings.npy")

    with open(f"{filepath}_metadata.json", "r", encoding="utf-8") as f:
        metadata = json.load(f)

    print(f"Index loaded: {len(metadata)} chunks, {embeddings.shape}")
    return metadata, embeddings

# Save
save_index(chunks, embeddings)

# Load (on next startup)
chunks_loaded, embeddings_loaded = load_index()

Ověření před pokračováním

Tichá korupce indexu se projeví pozdě, obvykle když uživatel nahlásí absurdní odpověď. Několik offline kontrol zabere třicet sekund a ušetří ti toto trapné odhalení. Ověřovací funkce nejprve zobrazí základní metriky – počet úryvků, dimenzi, průměrnou normu – a poté změří podobnost mezi sousedními úryvky: protože pocházejí ze stejného dokumentu, měly by vykazovat výrazně vyšší hodnoty než dva náhodné úseky. Poslední test je nejjednodušší a nejvýmluvnější: úryvek porovnaný sám se sebou musí dát přesně 1,0. Jakákoli jiná hodnota signalizuje problém se zarovnáním nebo chybu při numerické konverzi.

from sklearn.metrics.pairwise import cosine_similarity

def verify_embeddings(chunks, embeddings, n_tests=5):
    """Verify embedding quality with simple tests."""
    print("=== Verifying embeddings ===")
    print(f"Number of chunks: {len(chunks)}")
    print(f"Dimensions: {embeddings.shape[1]}")
    print(f"Average norm: {np.linalg.norm(embeddings, axis=1).mean():.4f}")

    # Test: chunks from the same document should be closer
    for i in range(min(n_tests, len(chunks) - 1)):
        sim = cosine_similarity([embeddings[i]], [embeddings[i + 1]])[0][0]
        print(f"  Similarity chunk {i} <-> {i+1}: {sim:.4f}")

    # Test: a chunk compared to itself = 1.0
    self_sim = cosine_similarity([embeddings[0]], [embeddings[0]])[0][0]
    print(f"  Self-similarity (must be 1.0): {self_sim:.6f}")

verify_embeddings(chunks, embeddings)

Seřazeno dohromady se celý pracovní postup zredukuje na čtyři užitečné řádky. Připravíš úryvky pomocí pipeline z předchozí lekce, zakóduješ je v robustním režimu, ověříš a uložíš. Toto je skript, který znovu spustíš pokaždé, když se korpus aktualizuje.

# 1. Prepare chunks (previous lesson)
chunks = prepare_documents(raw_docs)

# 2. Encode
embeddings = encode_chunks_robust(chunks, batch_size=25)

# 3. Verify
verify_embeddings(chunks, embeddings)

# 4. Save
save_index(chunks, embeddings)

print("Index ready for search!")

Klíčové poznatky

  • Používej dávkování pro kódování velkých korpusů (dávky po 25–50 úryvcích)
  • Přidej logiku opakovaných pokusů s exponenciálním backoffem pro robustnost
  • Ukládej vnoření na disk (NumPy), abys předešel přepočítávání
  • Uchovávej metadata (text, zdroj, pozice) v samostatném souboru JSON
  • Před nasazením do produkce ověř kvalitu vnoření