Vector Store med FAISS
På denne side
FAISS: Højtydende vektorsøgning
Du har beregnet og gemt dine embeddings, men en NumPy-matrix er ikke en søgemaskine: At sammenligne en forespørgsel med 100.000 vektorer ved hjælp af en Python-løkke ville tage flere sekunder per spørgsmål. FAISS (Facebook AI Similarity Search) løser præcis dette problem. Dette open source-bibliotek fra Meta er designet til lighedssøgning på tværs af store vektorsæt; det er hurtigt, hukommelseseffektivt og fungerer lige godt med få hundrede vektorer som med millioner. Installationen kræver kun én kommando. faiss-cpu er tilstrækkeligt i langt de fleste tilfælde; faiss-gpu er kun berettiget ved volumener, hvor beregning bliver flaskehalsen.
# pip install faiss-cpu
# or faiss-gpu for GPU acceleration
import faiss
import numpy as np
Opret dit første indeks
Det enkleste indeks er IndexFlatL2, som udfører en udtømmende søgning ved hjælp af L2-afstand (Euklidisk). “Udtømmende” betyder, at det faktisk sammenligner forespørgslen med hver eneste lagret vektor: ingen tilnærmelser, så ingen missede resultater. Du initialiserer det med vektordimensionen – 1024 for mistral-embed, en værdi du læser direkte fra matrix-formen i stedet for at hardcode den. Konvertering til float32 er ikke valgfri: FAISS afviser den float64, som NumPy producerer som standard, og at glemme denne detalje er den første fejl, enhver begynder støder på.
# 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}")
Valg af den rigtige indeks-type
FAISS tilbyder ikke ét enkelt indeks, men en familie af dem, og valget indebærer en afvejning mellem nøjagtighed og hastighed. De to første, IndexFlatL2 og IndexFlatIP, er eksakte: de adskiller sig kun ved den metrik, der bruges, henholdsvis euklidisk afstand og prikprodukt. IndexIVFFlat ændrer logikken ved at opdele rummet i klynger og kun søge i de mest lovende, hvilket øger søgehastigheden markant på bekostning af et lille tab i recall – og kræver forudgående træning på dine data. Endelig bygger IndexHNSWFlat en nabograf og viser sig at være meget hurtig under forespørgsler, hvor parameteren 32 her sætter antallet af naboer, der beholdes per node.
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
Forespørgsel af indekset
Søgningen foregår i tre trin. Først encoder du brugerens spørgsmål med den samme model som korpusset – en forespørgsel encoderet af en anden model ville give meningsløse afstande. FAISS returnerer derefter to parallelle arrays: afstandene og indeksene for de k nærmeste naboer. Disse indeks er positioner i din liste over chunks: her betaler disciplinen fra den tidligere lektion sig, da sammenhængen mellem matrixen og metadataene er det, der gør det muligt at spore tilbage til teksten og dens kilde. Testen if idx >= 0 dækker tilfældet, hvor indekset indeholder færre end k vektorer, i hvilket tilfælde FAISS fylder de manglende pladser med -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]}...")
Skift til cosinus-lichenhed
FAISS tilbyder ikke et eksplicit “cosine”-indeks, men algebraen giver en gratis ækvivalent: for vektorer med norm 1 er prikproduktet cosinus. Du dividerer blot hver vektor med sin norm og bruger derefter IndexFlatIP. Denne ændring er langt fra teoretisk: L2-afstand er følsom over for vektorlængde, så et meget langt chunk kan ende kunstigt langt fra en kort forespørgsel, selvom deres emner matcher. Cosinus måler kun orientering, altså betydning, og det er generelt det, du ønsker at sammenligne.
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)
Ligesom med embeddings persisters indekset på disken. faiss.write_index producerer en binær fil, som faiss.read_index genindlæser nøjagtigt som den er, inklusive interne strukturer – hvilket er vigtigst for trænede indeks, hvor rekonstruktion ellers skulle udføres på ny.
# 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")
Når korpusset bliver massivt
Fra flere hundrede tusinde vektorer bliver udtømmende søgning for langsom, og IVF-indekset (Inverted File) bliver nødvendigt. Dets livscyklus inkluderer et trin, som flade indeks ikke har: træning, som analyserer din datafordeling for at placere nlist partitions-centroider. Derefter følger tilføjelsen af vektorerne og derefter justeringen af nprobe, knappen der afgør, hvor mange partitioner der vil blive undersøgt per forespørgsel. At øge nprobe forbedrer recall og sænker søgehastigheden; dette er den parameter, du vil justere ved at måle på et repræsentativt sæt af spørgsmål det punkt, hvor resultaterne holder op med at blive bedre.
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)
Vigtige pointer
- FAISS er standarden for hurtig vektorsøgning
IndexFlatL2til små korpusser (under 100K vektorer), eksakt søgningIndexIVFFlattil store korpusser, tilnærmet men hurtig søgning- Normaliser vektorer og brug
IndexFlatIPtil cosinus-lichenhed - Gem indekset på disken med
faiss.write_indexfor at undgå genopbygning