Vector Store s FAISS
Na této stránce
FAISS: Vyhledávání vektorů s vysokým výkonem
Spočítal jsi a uložil své vektory (embeddings), ale matice NumPy není vyhledávač: porovnání dotazu se 100 000 vektory pomocí smyčky v Pythonu by trvalo několik sekund na každou otázku. FAISS (Facebook AI Similarity Search) řeší přesně tento problém. Tato open-source knihovna od Meta je navržena pro vyhledávání podobnosti ve velkých sadách vektorů; je rychlá, paměťově efektivní a funguje stejně dobře s několika stovkami vektorů jako s miliony. Instalace zabere jediný příkaz. faiss-cpu stačí ve velké většině případů; faiss-gpu je opodstatněné pouze u objemů, kde se výpočet stane úzkým hrdlem.
# pip install faiss-cpu
# or faiss-gpu for GPU acceleration
import faiss
import numpy as np
Vytvoření prvního indexu
Nejjednodušším indexem je IndexFlatL2, který provádí vyčerpávající vyhledávání pomocí vzdálenosti L2 (Eukleidovská). „Vyčerpávající“ znamená, že skutečně porovná dotaz s každým uloženým vektorem: žádná aproximace, takže žádné vynechané výsledky. Inicializuješ jej dimenzí vektoru – 1024 pro mistral-embed, hodnotu, kterou přečteš přímo z tvaru matice, místo abys ji natvrdo zakódoval. Převod na float32 není volitelný: FAISS odmítá float64, které NumPy ve výchozím nastavení produkuje, a zapomenutí tohoto detailu je první chybou, do které spadne každý začátečník.
# 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}")
Výběr správného typu indexu
FAISS nenabízí jediný index, ale celou jejich rodinu a výběr zahrnuje kompromis mezi přesností a rychlostí. První dva, IndexFlatL2 a IndexFlatIP, jsou exaktní: liší se pouze použitou metrikou, pro jeden je to Eukleidovská vzdálenost, pro druhý skalární součin. IndexIVFFlat mění logiku rozdělením prostoru do clusterů a vyhledáváním pouze v těch nejslibnějších, což výrazně zrychlí hledání za cenu mírné ztráty úplnosti (recall) – a vyžaduje předchozí trénink na tvých datech. Nakonec IndexHNSWFlat buduje graf sousedů a při dotazech se ukazuje jako velmi rychlý, přičemž parametr 32 zde nastavuje počet sousedů zachovaných na uzel.
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
Dotazování na index
Vyhledávání probíhá ve třech krocích. Nejprve zakóduješ otázku uživatele stejným modelem jako korpus – dotaz zakódovaný jiným modelem by poskytl nesmyslné vzdálenosti. FAISS poté vrátí dvě paralelní pole: vzdálenosti a indexy k nejbližších sousedů. Tyto indexy jsou pozicemi v tvém seznamu chunků: zde se vyplatí kázeň z předchozí lekce, protože právě zarovnání mezi maticí a metadaty ti umožňuje vystopovat zpět text a jeho zdroj. Test if idx >= 0 pokrývá případ, kdy index obsahuje méně než k vektorů, v takovém případě FAISS chybějící místa vyplní hodnotou -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]}...")
Přepnutí na kosinovou podobnost
FAISS nenabízí explicitní index „kosinus“, ale algebra poskytuje bezplatný ekvivalent: pro vektory s normou 1 je skalární součin kosinem. Jednoduše vydělíš každý vektor jeho normou a poté použiješ IndexFlatIP. Tato změna není jen teoretická: vzdálenost L2 je citlivá na délku vektoru, takže velmi dlouhý chunk může skončit uměle daleko od krátkého dotazu, i když se jejich témata shodují. Kosinus měří pouze orientaci, tedy význam, a to je obvykle to, co chceš porovnávat.
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)
Stejně jako u vektorů přetrvává index na disku. faiss.write_index vytvoří binární soubor, který faiss.read_index znovu načte tak, jak je, včetně vnitřních struktur – což je nejdůležitější u trénovaných indexů, kde by jinak bylo nutné rekonstrukci provádět znovu.
# 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")
Když se korpus stane obrovským
Od několika set tisíc vektorů se vyčerpávající vyhledávání stává příliš pomalým a index IVF (Inverted File) se stává nezbytným. Jeho životní cyklus zahrnuje krok, který ploché indexy nemají: trénink, který analyzuje rozložení tvých dat za účelem umístění centroidů nlist oddílů. Následuje přidání vektorů a poté ladění nprobe, což je ovládací prvek, který rozhoduje, kolik oddílů bude pro každý dotaz prozkoumáno. Zvýšení nprobe zlepšuje úplnost (recall) a zpomaluje vyhledávání; toto je parametr, který budeš upravovat měřením na reprezentativní sadě otázek, dokud nenajdeš bod, kdy se výsledky přestanou zlepšovat.
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)
Klíčové poznatky
- FAISS je standardem pro rychlé vyhledávání vektorů
IndexFlatL2pro malé korpusy (do 100 tisíc vektorů), exaktní vyhledáváníIndexIVFFlatpro velké korpusy, aproximované, ale rychlé vyhledávání- Normalizuj vektory a použij
IndexFlatIPpro kosinovou podobnost - Ulož index na disk pomocí
faiss.write_index, abys předešel jeho opětovnému vytváření