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

Vytváranie vektorových reprezentácií (Embeddings)

Lekcia 11 z 18 Aktualizované 2. novembra 2026 Vývojár
Na tejto strane
  1. Kódovanie častí do vektorov
  2. Dávkové kódovanie
  3. Prežitie chyieb siete
  4. Uloženie indexu na disk
  5. Overenie pred pokračovaním
  6. Kľúčové poznatky

Kódovanie častí do vektorov

Tvoje dokumenty sú teraz rozdelené na čisté časti. Ďalším krokom je ich transformácia na vektorové reprezentácie (embeddings) pomocou API mistral-embed a následné uloženie týchto vektorov do vektorovej databázy, ktorá bude fungovať ako tvoj vyhľadávací engine. V tomto momente sa tvoja kolekcia dokumentov prestáva byť obyčajným textom a stáva sa geometriou, na ktorú sa dá dopytovať. Niekoľko inžinierskych opatrení – dávkové spracovanie, opakovanie pri chybách a perzistencia – rozhoduje o tom, či vytvoríš krehký prototyp, alebo spoľahlivý index.

Pre malú kolekciu, povedzme menej ako sto častí, stačí jediný priamy volanie. Extrahuj text zo svojich slovníkov s časťami, pošli ich tak, ako sú, do API a získaj celú maticu. Tvar (87, 1024) zobrazený na konci vykonávania je tvoja prvá kontrola sanity: toľko riadkov, koľko máš častí, a 1024 stĺpcov, pretože to je dimenzia modelu mistral-embed. Ak sa počet riadkov nezhoduje, do dávky sa dostala prázdna časť.

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ódovanie

Pri viac ako niekoľkých desiatkach častí narazíš na limity API pri jedinom volaní. Riešením je rozdelenie zoznamu na dávky a spojenie výsledkov. Funkcia nižšie spracováva úseky po 25 kusoch a zobrazuje priebeh. Nie je to len kozmetika: pri kolekcii niekoľkých tisíc častí trvá kódovanie niekoľko minút a budeš chcieť vedieť, kde sa proces nachádza, namiesto toho, aby si hľadel na tichý terminál. Poradie sa zachováva, takže každý vektor zostáva zarovnaný so zodpovedajúcou časťou v tvojom pôvodnom zozname.

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

Prežitie chyieb siete

V produkčnom prostredí sa volanie API skôr či neder pokazí: výpadok siete, dosiahnutie limitu rýchlosti alebo dočasná nedostupnosť. Bez ochrany sa tvoje indexovanie zastaví pri dávke 180 z 400 a si späť na začiatku. Robustná verzia obalí každú dávku do slučky s opakovaním a využíva exponenciálne oneskorenie – jedna sekunda, potom dve, potom štyri. Toto zvyšujúce sa oneskorenie je dôležité: okamžité opakovanie po zamietnutí kvóty veci len zhorší. Po troch po sebe idúcich zlyhaniach funkcia vyhodí explicitnú výnimku s názvom chybovej dávky, namiesto toho, aby vrátila orezanú maticu, kde by si medzeru objavil až počas vyhľadávania.

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ženie indexu na disk

Každé spustenie kódovania stojí čas a účtované volania API. Prepočítavanie vektorov pri každom štarte aplikácie je čistá strata, najmä keď sa samotná kolekcia dokumentov nezmenila. Ukladanie prebieha do dvoch doplnkových súborov: vektory idú do formátu NumPy, čo je kompaktný binárny formát, ktorý sa načíta okamžite, zatiaľ čo metadáta – text, zdroj, pozícia – idú do čitateľného JSON, ktorý môžeš otvoriť a skontrolovať podozrivú časť. Tieto dva súbory sú na sebe závislé, prepojené poradím riadkov: nikdy regeneruj jeden bez druhého, inak budú tvoje výsledky vyhľadávania ukazovať na nesprávne 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()

Overenie pred pokračovaním

Ticho poškodený index sa prejaví neskoro, zvyčajne keď používateľ nahlási absurdnú odpoveď. Niekoľko offline kontrol zaberie tridsať sekúnd a ušetrí ti takéto objavovanie. Overovacia funkcia najprv zobrazí základné metriky – počet častí, dimenzie, priemernú normu – a potom zmeria podobnosť medzi susednými časťami: keďže pochádzajú z toho istého dokumentu, mali by vykazovať výrazne vyššie hodnoty než dva náhodné úseky. Posledný test je najjednoduchší a najodhaľujúcejší: časť porovnaná so sebou samou musí vrátiť presne 1,0. Akákoľvek iná hodnota signalizuje problém so zarovnaním alebo numerickou konverziou.

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)

Spojené dohromady sa celý pracovný postup zredukuje na štyri užitočné riadky. Pripravíš časti pomocou pipeline z predchádzajúcej lekcie, zakóduješ ich v robustnom režime, overíš a uložíš. Toto je skript, ktorý znova spustíš vždy, keď sa aktualizuje kolekcia dokumentov.

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

Kľúčové poznatky

  • Na kódovanie veľkých kolekcií používaj dávkové spracovanie (dávky po 25–50 častiach)
  • Pridaj logiku opakovania s exponenciálnym oneskorením pre robustnosť
  • Ukladaj vektorové reprezentácie na disk (NumPy), aby sa predišlo prepočítavaniu
  • Uchovávaj metadáta (text, zdroj, pozícia) v samostatnom súbore JSON
  • Pred nasadením do produkcie over kvalitu vektorových reprezentácií