Vector Store avec FAISS
På denna sida
FAISS : recherche vectorielle haute performance
Tu as calculé et sauvegardé tes embeddings, mais une matrice NumPy n’est pas un moteur de recherche : comparer une requête à 100 000 vecteurs avec une boucle Python prendrait plusieurs secondes par question. FAISS (Facebook AI Similarity Search) résout exactement ce problème. Cette bibliothèque open source de Meta est conçue pour la recherche de similarité sur de grands ensembles de vecteurs ; elle est rapide, économe en mémoire et fonctionne aussi bien avec quelques centaines de vecteurs qu’avec des millions. L’installation tient en une commande. faiss-cpu suffit dans la grande majorité des cas ; faiss-gpu ne se justifie que pour des volumes où le calcul devient le goulot d’étranglement.
# pip install faiss-cpu
# or faiss-gpu for GPU acceleration
import faiss
import numpy as np
Crée ton premier index
L’index le plus simple est IndexFlatL2, qui effectue une recherche exhaustive avec la distance L2 (euclidienne). « Exhaustive » signifie qu’il compare réellement la requête à chaque vecteur stocké : pas d’approximation, donc aucun résultat manqué. Tu l’initialises avec la dimension des vecteurs — 1024 pour mistral-embed, une valeur que tu lis directement depuis la forme de la matrice plutôt que de la coder en dur. La conversion en float32 n’est pas optionnelle : FAISS rejette le float64 produit par défaut par NumPy, et oublier ce détail est la première erreur que rencontre tout débutant.
# 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}")
Choisir le bon type d’index
FAISS ne propose pas un seul index, mais toute une famille, et le choix implique un compromis entre précision et vitesse. Les deux premiers, IndexFlatL2 et IndexFlatIP, sont exacts : ils ne diffèrent que par la métrique utilisée, distance euclidienne pour l’un, produit scalaire pour l’autre. IndexIVFFlat change la logique en partitionnant l’espace en clusters et en recherchant uniquement les plus prometteurs, ce qui accélère considérablement la recherche au prix d’une légère perte de rappel — et nécessite un entraînement préalable sur tes données. Enfin, IndexHNSWFlat construit un graphe de voisins et s’avère très rapide lors des requêtes, le paramètre 32 fixant ici le nombre de voisins conservés par nœud.
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
Interroger l’index
La recherche se déroule en trois étapes. D’abord, encode la question de l’utilisateur avec le même modèle que le corpus — une requête encodée par un modèle différent donnerait des distances inexploitables. FAISS renvoie ensuite deux tableaux parallèles : les distances et les indices des k plus proches voisins. Ces indices correspondent à des positions dans ta liste de chunks : c’est là que la rigueur de la leçon précédente porte ses fruits, puisque l’alignement entre la matrice et les métadonnées est ce qui te permet de remonter au texte et à sa source. Le test if idx >= 0 couvre le cas où l’index contient moins de k vecteurs, auquel cas FAISS remplit les places manquantes avec -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]}...")
Passer à la similarité cosinus
FAISS ne propose pas d’index « cosinus » explicite, mais l’algèbre offre un équivalent gratuit : pour des vecteurs de norme 1, le produit scalaire est le cosinus. Il suffit de diviser chaque vecteur par sa norme, puis d’utiliser IndexFlatIP. Ce changement est loin d’être théorique : la distance L2 est sensible à la longueur des vecteurs, si bien qu’un chunk très long peut se retrouver artificiellement loin d’une requête courte même si leurs sujets correspondent. Le cosinus ne mesure que l’orientation, donc le sens, et c’est généralement ce que tu veux comparer.
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)
Comme pour les embeddings, l’index persiste sur disque. faiss.write_index produit un fichier binaire que faiss.read_index recharge tel quel, structures internes comprises — ce qui compte surtout pour les index entraînés, où la reconstruction devrait sinon être refaite.
# 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")
Quand le corpus devient massif
À partir de plusieurs centaines de milliers de vecteurs, la recherche exhaustive devient trop lente et l’index IVF (Inverted File) devient nécessaire. Son cycle de vie inclut une étape absente des index plats : l’entraînement, qui analyse la distribution de tes données pour placer les centroïdes des nlist partitions. Vient ensuite l’ajout des vecteurs, puis le réglage de nprobe, le curseur qui décide combien de partitions seront explorées par requête. Augmenter nprobe améliore le rappel et ralentit la recherche ; c’est le paramètre que tu ajusteras en mesurant, sur un jeu représentatif de questions, le point à partir duquel les résultats ne s’améliorent plus.
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)
Viktiga punkter
- FAISS est la référence pour la recherche vectorielle rapide
IndexFlatL2pour les petits corpus (moins de 100k vecteurs), recherche exacteIndexIVFFlatpour les grands corpus, recherche approchée mais rapide- Normalise les vecteurs et utilise
IndexFlatIPpour la similarité cosinus - Sauvegarde l’index sur disque avec
faiss.write_indexpour éviter de le reconstruire