Opret indlejrede vektorer
På denne side
Kodér chunks til vektorer
Dine dokumenter er nu opdelt i rene chunks. Næste skridt er at omdanne dem til indlejrede vektorer (embeddings) ved hjælp af mistral-embed-API’et og derefter gemme disse vektorer i et vektorlager, der fungerer som din søgemaskine. Det er her, dit korpus holder op med at være almindelig tekst og bliver til querybar geometri. Nogle få tekniske forholdsregler – batching, genforsøg og persistens – afgør forskellen mellem en skrøbelig prototype og et pålideligt indeks.
Til et lille korpus, f.eks. under hundrede chunks, er et enkelt direkte kald tilstrækkeligt. Uddrag teksten fra dine chunk-ordbøger, send dem uændret til API’et, og hent hele matricen. Formen (87, 1024), der vises ved afslutningen af kørslen, er din første sundhedstjek: lige så mange rækker som chunks og 1024 kolonner, fordi det er dimensionen for mistral-embed. Hvis antallet af rækker ikke stemmer overens, er en tom chunk sneget sig ind 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
Ud over et par dusin chunks rammer et enkelt kald API-grænserne. Løsningen er at opdele listen i batches og sammenkæde resultaterne. Funktionen nedenfor behandler udsnit på 25 og viser fremskridt. Det er ikke kun kosmetik: På et korpus på flere tusinde chunks tager kodningen flere minutter, og du vil gerne vide, hvor processen befinder sig, i stedet for at stirre på en tavs terminal. Rækkefølgen bevares, så hver vektor forbliver justeret med sin tilsvarende chunk i din oprindelige liste.
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")
Overlev netværksfejl
I produktion vil et API-kald før eller siden fejle: netværksudfald, ramt rate-limit eller midlertidigt udfald. Uden beskyttelse stopper dit indeksering ved batch 180 ud af 400, og du er tilbage ved start. Den robuste version pakker hver batch ind i en genforsøgsløkke med eksponentiel backoff – ét sekund, derefter to, derefter fire. Denne stigende afstand er vigtig: At forsøge igen umiddelbart efter en afvisning på grund af kvote gør kun tingene værre. Efter tre på hinanden følgende fejl kaster funktionen en eksplicit undtagelse, der navngiver den fejlbehæftede batch, i stedet for at returnere en trunkeret matrix, hvor du først ville opdage hullet under søgningen.
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)
Gem indekset på disken
Hver kodningskørsel koster tid og fakturerede API-kald. At genberegne vektorer hver gang dit program starter, er ren spild, især da selve korpussen ikke er ændret. Lagringen sker i to komplementære filer: vektorer gemmes i NumPy, et kompakt binært format, der indlæses øjeblikkeligt, mens metadata – tekst, kilde, position – gemmes i læsbar JSON, som du kan åbne for at inspicere en mistænkelig chunk. De to filer er indbyrdes afhængige og forbundet via linjerækkefølge: Generér aldrig den ene uden den anden, ellers vil dine søgeresultater pege på de forkerte tekster.
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()
Verificér før du fortsætter
Et stille korrumperet indeks viser sig sent, typisk når en bruger rapporterer et absurd svar. Nogle få offline-tjek tager tredive sekunder og sparer dig for den opdagelse. Verificeringsfunktionen viser først grundlæggende målinger – antal chunks, dimension, gennemsnitlig norm – og måler derefter ligheden mellem nabochunks: Da de stammer fra samme dokument, bør de vise væsentligt højere værdier end to tilfældige passager. Den sidste test er den enkleste og mest afslørende: En chunk sammenlignet med sig selv skal give præcis 1,0. Enhver anden værdi signalerer et justeringsproblem eller et numerisk konverteringsproblem.
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)
Sat sammen koges arbejdsgangen ned til fire nyttige linjer. Du forbereder chunks med pipeline’en fra den forrige lektion, koder i robust tilstand, verificerer og gemmer. Dette er det script, du vil genkøre hver gang korpussen opdateres.
# 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!")
Vigtige pointer
- Brug batching til at kode store korpusser (batches på 25–50 chunks)
- Tilføj logik for genforsøg med eksponentiel backoff for robusthed
- Gem indlejrede vektorer på disken (NumPy) for at undgå genberegning
- Opbevar metadata (tekst, kilde, position) i en separat JSON-fil
- Verificér kvaliteten af de indlejrede vektorer, før du bruger dem i produktion