Beágyazások létrehozása
Ezen az oldalon
Chunkok vektorrá alakítása
A dokumentumaidat most már tiszta chunkokra bontottad. A következő lépés ezek beágyazásokká (embeddings) alakítása a mistral-embed API segítségével, majd ezeknek a vektoroknak az elhelyezése egy vektortárban, amely keresőmotorként fog működni. Ebben a pillanatban a korpuszod megszűnik egyszerű szöveg lenni, és lekérdezhető geometriává válik. Néhány mérnöki óvintézkedés – kötegelés, újrapróbálkozások és tartósság – teszi a különbséget a törékeny prototípus és a megbízható index között.
Kisebb korpusz esetén, mondjuk száznál kevesebb chunkkal, egyetlen közvetlen hívás is elegendő. Kinyered a szöveget a chunk szótáraidból, változatlanul továbbítod az API-nak, és lekérdezed a teljes mátrixot. A végrehajtás végén megjelenő (87, 1024) alak az első sanity check-ed: annyi sor, ahány chunk, és 1024 oszlop, mert ez a mistral-embed dimenziója. Ha a sorok száma nem egyezik, akkor egy üres chunk csúszott be a kötegbe.
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
Köteges kódolás
Néhány tucat chunkon túl egyetlen hívás eléri az API korlátait. A megoldás a lista kötegekre bontása és az eredmények összefűzése. Az alábbi függvény 25-ös szeleteket dolgoz fel, és megjeleníti az előrehaladást. Ez nem csak kozmetika: több ezer chunkból álló korpusz esetén a kódolás több percig is eltarthat, és tudni szeretnéd, hol tart a folyamat, ahelyett, hogy egy néma terminált bámulnál. A sorrend megmarad, így minden vektor továbbra is igazodik a megfelelő chunkhoz az eredeti listádban.
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")
Hálózati hibák túlélése
Éles környezetben előbb-utóbb meghiúsul egy API-hívás: hálózati kimaradás, sebességkorlát túllépése vagy ideiglenes leállás. Védelem nélkül az indexelésed a 400-ból a 180. kötegnél megáll, és kezdheted elölről. A robusztus verzió minden köteget egy újrapróbálkozó ciklusba csomagol exponenciális háttéridővel – először egy másodperc, majd kettő, majd négy. Ez a növekvő időköz fontos: ha a kvóta elutasítása után azonnal próbálkozol újra, csak rontasz a helyzeten. Három egymást követő hiba után a függvény egy explicit kivételt dob, megnevezve a hibás köteget, ahelyett, hogy egy csonka mátrixot adna vissza, ahol a hiányosságot csak keresés közben vennéd észre.
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)
Az index mentése lemezre
Minden kódolási futtatás időbe és számlázott API-hívásokba kerül. A vektorok újraszámolása minden alkalmazásindításkor tiszta pazarlás, különösen, mivel maga a korpusz nem változott. A mentés két kiegészítő fájlban történik: a vektorok a NumPy tömör bináris formátumába kerülnek, amely azonnal betöltődik, míg a metaadatok – szöveg, forrás, pozíció – egy olvasható JSON fájlba, amelyet megnyithatsz egy gyanús chunk ellenőrzéséhez. A két fájl egymástól függ, a sorsrend köti őket össze: soha ne generáld újra az egyiket a másik nélkül, különben a keresési eredményeid rossz szövegekre mutatnak.
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()
Ellenőrzés a folytatás előtt
Egy csendben megsérült index későn derül ki, általában akkor, amikor egy felhasználó abszurd választ jelent. Néhány offline ellenőrzés harminc másodpercet vesz igénybe, és megóv ettől a felfedezéstől. Az ellenőrző függvény először alapvető metrikákat jelenít meg – chunkok száma, dimenzió, átlagos norma –, majd méri a szomszédos chunkok közötti hasonlóságot: mivel ugyanabból a dokumentumból származnak, jelentősen magasabb értékeket kell mutatniuk, mint két véletlenszerű szakasznak. Az utolsó teszt a legegyszerűbb és a legárulkodóbb: egy chunk önmagával való összehasonlításának pontosan 1,0-nak kell lennie. Bármilyen más érték igazítási problémára vagy numerikus konverziós hibára utal.
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)
Összefűzve a munkafolyamat négy hasznos sorra redukálódik. Előkészíted a chunkokat az előző lecke pipeline-jával, robusztus módban kódolod, ellenőrzöd, majd elmented. Ez az a szkript, amelyet minden alkalommal újra lefuttatsz, amikor a korpusz frissül.
# 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!")
Főbb megállapítások
- Használj kötegelést nagy korpuszok kódolásához (25–50 chunkos kötegek)
- Adj hozzá újrapróbálkozó logikát exponenciális háttéridővel a robusztusság érdekében
- Mentsd el a beágyazásokat lemezre (NumPy), hogy elkerüld az újraszámolást
- Tartsd a metaadatokat (szöveg, forrás, pozíció) egy külön JSON fájlban
- Ellenőrizd a beágyazások minőségét, mielőtt éles környezetben használnád őket