Vytváření vnoření (Embeddings)
Na této stránce
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í