Vector Store met FAISS
Op deze pagina
FAISS: Zoeken in vectoren met hoge prestaties
U heeft uw embeddings berekend en opgeslagen, maar een NumPy-matrix is geen zoekmachine: het vergelijken van een query met 100.000 vectoren via een Python-lus zou enkele seconden per vraag duren. FAISS (Facebook AI Similarity Search) lost precies dit probleem op. Deze open-sourcebibliotheek van Meta is ontworpen voor similariteitszoekopdrachten in grote vectorsets; hij is snel, geheugenefficiënt en werkt even goed met een paar honderd vectoren als met miljoenen. Installatie vereist slechts één commando. faiss-cpu is in de overgrote meerderheid van de gevallen voldoende; faiss-gpu is alleen gerechtvaardigd voor volumes waarbij de berekening de bottleneck wordt.
# pip install faiss-cpu
# or faiss-gpu for GPU acceleration
import faiss
import numpy as np
Uw eerste index maken
De eenvoudigste index is IndexFlatL2, die een exhaustieve zoekopdracht uitvoert met behulp van L2-afstand (Euclidisch). “Exhaustief” betekent dat de query daadwerkelijk met elke opgeslagen vector wordt vergeleken: geen benadering, dus geen gemiste resultaten. U initialiseert deze met de vectordimensie—1024 voor mistral-embed, een waarde die u direct uit de matrixvorm leest in plaats van hard-coding. Converteren naar float32 is niet optioneel: FAISS wijst de float64 af die NumPy standaard produceert, en het vergeten van dit detail is de eerste fout die elke beginner maakt.
# Assume our embeddings are a NumPy matrix
# embeddings.shape = (n_chunks, 1024)
# Create the index
dimension = embeddings.shape[1] # 1024 for mistral-embed
index = faiss.IndexFlatL2(dimension)
# Add the vectors
index.add(embeddings.astype(np.float32)) # FAISS requires float32
print(f"Index created: {index.ntotal} vectors of dimension {dimension}")
Het juiste indextype kiezen
FAISS biedt niet één enkele index, maar een familie ervan, en de keuze impliceert een afweging tussen nauwkeurigheid en snelheid. De eerste twee, IndexFlatL2 en IndexFlatIP, zijn exact: ze verschillen alleen in de gebruikte metriek, Euclidische afstand voor de ene, dot product voor de andere. IndexIVFFlat verandert de logica door de ruimte in clusters te partitioneren en alleen de meest veelbelovende te doorzoeken, wat de zoekopdracht aanzienlijk versnelt ten koste van een licht verlies in recall—en vereist voorafgaande training op uw data. Ten slotte bouwt IndexHNSWFlat een burengraaf op en blijkt zeer snel tijdens queries, waarbij de parameter 32 hier het aantal behouden buren per node instelt.
dimension = 1024
# 1. IndexFlatL2: Exact search, L2 distance
# Most accurate, but slowest for large volumes
index_flat_l2 = faiss.IndexFlatL2(dimension)
# 2. IndexFlatIP: Exact search, dot product (inner product)
# Use with normalized vectors for cosine similarity
index_flat_ip = faiss.IndexFlatIP(dimension)
# 3. IndexIVFFlat: Approximate search with partitioning
# Faster for large volumes, slight loss of accuracy
nlist = 100 # Number of partitions (clusters)
quantizer = faiss.IndexFlatL2(dimension)
index_ivf = faiss.IndexIVFFlat(quantizer, dimension, nlist)
# Requires training before use:
# index_ivf.train(embeddings)
# index_ivf.add(embeddings)
# 4. IndexHNSWFlat: Neighbor graph (very fast search)
index_hnsw = faiss.IndexHNSWFlat(dimension, 32) # 32 = number of neighbors
De index bevragen
Zoeken gebeurt in drie stappen. Encodeer eerst de vraag van de gebruiker met hetzelfde model als het corpus—een query die door een ander model is gecodeerd, zou betekenisloze afstanden opleveren. FAISS retourneert vervolgens twee parallelle arrays: de afstanden en de indices van de k dichtstbijzijnde buren. Deze indices zijn posities in uw lijst van chunks: hier betaalt de discipline van de vorige les zich terug, aangezien de uitlijning tussen de matrix en de metadata u in staat stelt terug te gaan naar de tekst en de bron. De test if idx >= 0 dekt het geval waarin de index minder dan k vectoren bevat, in welk geval FAISS de ontbrekende plekken invult met -1.
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
def search_index(query, index, chunks, k=5):
"""Search for chunks closest to a query."""
# 1. Encode the query
response = client.embeddings.create(
model="mistral-embed",
inputs=[query],
)
query_vector = np.array([response.data[0].embedding], dtype=np.float32)
# 2. Search in FAISS
distances, indices = index.search(query_vector, k)
# 3. Format results
results = []
for i, (dist, idx) in enumerate(zip(distances[0], indices[0])):
if idx >= 0: # FAISS returns -1 if not enough results
results.append({
"rank": i + 1,
"distance": float(dist),
"text": chunks[idx]["text"],
"source": chunks[idx].get("source", ""),
})
return results
# Example search
results = search_index("How does RAG work?", index, chunks)
for r in results:
print(f" #{r['rank']} (dist: {r['distance']:.4f}) [{r['source']}]")
print(f" {r['text'][:100]}...")
Overschakelen op Cosine Similarity
FAISS biedt geen expliciete “cosine”-index, maar de algebra biedt een gratis equivalent: voor vectoren met norm 1 is het dot product de cosine. U deelt eenvoudig elke vector door zijn norm en gebruikt vervolgens IndexFlatIP. Deze verandering is verre van theoretisch: L2-afstand is gevoelig voor vectorlengte, dus een zeer lange chunk kan kunstmatig ver van een korte query komen te staan, zelfs als hun onderwerpen overeenkomen. Cosine meet alleen de oriëntatie, dus de betekenis, en dat is over het algemeen wat u wilt vergelijken.
def create_cosine_index(embeddings):
"""Create a FAISS index with cosine similarity."""
# Normalize vectors (L2 norm = 1)
norms = np.linalg.norm(embeddings, axis=1, keepdims=True)
normalized = (embeddings / norms).astype(np.float32)
# Use IndexFlatIP (dot product = cosine for normalized vectors)
dimension = normalized.shape[1]
index = faiss.IndexFlatIP(dimension)
index.add(normalized)
return index
cosine_index = create_cosine_index(embeddings)
Net als bij embeddings blijft de index behouden op schijf. faiss.write_index produceert een binair bestand dat faiss.read_index exact zo opnieuw laadt, inclusief interne structuren—wat vooral belangrijk is voor getrainde indexen, waarbij reconstructie anders opnieuw zou moeten worden uitgevoerd.
# Save
faiss.write_index(index, "rag_faiss.index")
print("FAISS index saved")
# Load
index_loaded = faiss.read_index("rag_faiss.index")
print(f"Index loaded: {index_loaded.ntotal} vectors")
Wanneer het corpus massaal wordt
Vanaf enkele honderdduizenden vectoren wordt exhaustief zoeken te traag en wordt de IVF (Inverted File)-index noodzakelijk. De levenscyclus hiervan omvat een stap die vlakke indexen niet hebben: training, die uw dataverdeling analyseert om de nlist partition-centroïden te plaatsen. Daarna volgt het toevoegen van de vectoren, gevolgd door het afstellen van nprobe, de knop die bepaalt hoeveel partities per query worden onderzocht. Het verhogen van nprobe verbetert de recall en vertraagt het zoeken; dit is de parameter die u aanpast door op een representatieve set vragen te meten op welk punt de resultaten niet meer verbeteren.
def create_ivf_index(embeddings, nlist=100, nprobe=10):
"""Create an IVF index for large volumes."""
dimension = embeddings.shape[1]
data = embeddings.astype(np.float32)
# Create the quantizer and IVF index
quantizer = faiss.IndexFlatL2(dimension)
index = faiss.IndexIVFFlat(quantizer, dimension, nlist)
# Train the index (required for IVF)
print("Training index...")
index.train(data)
# Add the vectors
index.add(data)
# Number of partitions to explore during search
index.nprobe = nprobe # Higher = more accurate, slower
print(f"IVF index created: {index.ntotal} vectors, {nlist} partitions")
return index
# For 100K+ vectors
# large_index = create_ivf_index(embeddings, nlist=256, nprobe=20)
Belangrijkste punten
- FAISS is de standaard voor snel vectorzoeken
IndexFlatL2voor kleine corpora (onder 100K vectoren), exact zoekenIndexIVFFlatvoor grote corpora, benaderend maar snel zoeken- Normaliseer vectoren en gebruik
IndexFlatIPvoor cosine similariteit - Sla de index op schijf op met
faiss.write_indexom herbouw te voorkomen