Skapa inbäddningar
På denna sida
Koda chunkar till vektorer
Dina dokument är nu uppdelade i rena chunkar. Nästa steg är att omvandla dem till inbäddningar (embeddings) med hjälp av mistral-embed-API:t och sedan lagra dessa vektorer i en vektorbutik som fungerar som din sökmotor. Det är här din korpus slutar vara vanlig text och blir sökbar geometri. Några tekniska försiktighetsåtgärder – batchning, försök på nytt och beständighet – gör skillnaden mellan en skör prototyp och ett pålitligt index.
För en liten korpus, säg färre än hundra chunkar, räcker ett enda direktanrop. Extrahera texten från dina chunk-ordlistor, skicka dem oförändrade till API:t och hämta hela matrisen. Formen (87, 1024) som visas i slutet av körningen är din första sanity check: lika många rader som chunkar, och 1024 kolumner eftersom det är dimensionen för mistral-embed. Om antalet rader inte stämmer har en tom chunk smugit sig in i batchen.
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
Batch-kodning
Utöver några dussin chunkar når ett enda anrop API-gränserna. Lösningen är att dela upp listan i batchar och sammanfoga resultaten. Funktionen nedan bearbetar bitar om 25 och visar framsteg. Detta är inte bara kosmetika: för en korpus på flera tusen chunkar tar kodningen flera minuter, och du vill veta var processen befinner sig istället för att stirra på en tyst terminal. Ordningen bevaras, så varje vektor förblir linjerad med motsvarande chunk i din ursprungliga lista.
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")
Att överleva nätverksfel
I produktion kommer ett API-anrop förr eller senare att misslyckas: nätverksbortfall, hastighetsbegränsning nådd eller tillfälligt driftstopp. Utan skydd stannar din indexering vid batch 180 av 400, och du är tillbaka till ruta ett. Den robusta versionen omsluter varje batch i en loop för försök på nytt med exponentiell backoff – en sekund, sedan två, sedan fyra. Detta ökande mellanrum är viktigt: att försöka igen omedelbart efter ett avslag på grund av kvot gör bara saken värre. Efter tre misslyckanden i rad höjer funktionen ett explicit undantag som namnger den felaktiga batchen, istället för att returnera en trunkerad matris där du först skulle upptäcka gapet under sökningen.
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)
Spara indexet till disk
Varje kodningsomgång kostar tid och debiterade API-anrop. Att beräkna om vektorer varje gång ditt program startar är rent slöseri, särskilt eftersom korpusen i sig inte har ändrats. Sparandet sker i två kompletterande filer: vektorerna hamnar i NumPy, ett kompakt binärt format som laddas omedelbart, medan metadata – text, källa, position – hamnar i läsbar JSON som du kan öppna för att inspektera en misstänkt chunk. De två filerna är ömsesidigt beroende och länkade via radordning: generera aldrig om den ena utan den andra, annars kommer dina sökresultat att peka på fel texter.
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()
Verifiera innan du fortsätter
Ett tyst korrupt index visar sig sent, vanligtvis när en användare rapporterar ett absurt svar. Några offline-kontroller tar trettio sekunder och sparar dig från den upptäckten. Verifieringsfunktionen visar först grundläggande mätvärden – antal chunkar, dimension, genomsnittlig norm – och mäter sedan likheten mellan intilliggande chunkar: eftersom de kommer från samma dokument bör de visa betydligt högre värden än två slumpmässiga passager. Det sista testet är det enklaste och mest avslöjande: en chunk jämförd med sig själv måste ge exakt 1,0. Varje annat värde signalerar ett linjeringsproblem eller ett numeriskt konverteringsfel.
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)
Sammanslaget kokar arbetsflödet ner till fyra användbara rader. Du förbereder chunkar med pipelinen från föregående lektion, kodar i robust läge, verifierar och sparar. Detta är skriptet du kommer att köra om varje gång korpusen uppdateras.
# 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!")
Viktiga punkter
- Använd batchning för att koda stora korpusar (batchar om 25–50 chunkar)
- Lägg till logik för försök på nytt med exponentiell backoff för robusthet
- Spara inbäddningar till disk (NumPy) för att undvika omberäkning
- Håll metadata (text, källa, position) i en separat JSON-fil
- Verifiera kvaliteten på inbäddningarna innan du använder dem i produktion