Úložisko vektorov s FAISS
Na tejto strane
FAISS: Vyhľadávanie vektorov s vysokým výkonom
Vypočítal si a uložil svoje vektory (embeddings), ale matica NumPy nie je vyhľadávač: porovnanie dopytu so 100 000 vektormi pomocou slučky v Pythone by trvalo niekoľko sekúnd na každú otázku. FAISS (Facebook AI Similarity Search) rieši presne tento problém. Táto knižnica s otvoreným zdrojovým kódom od Meta je navrhnutá pre vyhľadávanie podobnosti vo veľkých množinách vektorov; je rýchla, pamäťovo efektívna a funguje rovnako dobre s niekoľkými stovkami vektorov ako s miliónmi. Inštalácia zaberie jediný príkaz. faiss-cpu vo väčšine prípadov úplne stačí; faiss-gpu je opodstatnené len pri objemoch, kde sa výpočet stane úzkym hrdlom.
# pip install faiss-cpu
# or faiss-gpu for GPU acceleration
import faiss
import numpy as np
Vytvorenie tvojho prvého indexu
Najjednoduchší index je IndexFlatL2, ktorý vykonáva vyčerpávajúce vyhľadávanie pomocou vzdialenosti L2 (Euklidovskej). „Vyčerpávajúce“ znamená, že skutočne porovná dopyt s každým uloženým vektorom: žiadna aproximácia, takže žiadne vynechané výsledky. Inicializuješ ho rozmerom vektora – 1024 pre mistral-embed, hodnotu, ktorú si priamo prečítaš z tvaru matice, namiesto toho, aby si ju natvrdo zakódoval. Konverzia na float32 nie je voliteľná: FAISS odmieta float64, ktoré NumPy štandardne produkuje, a zabudnutie na tento detail je prvou chybou, ktorej každý začiatočník čelí.
# 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ýber správneho typu indexu
FAISS nenúka jeden jediný index, ale celú ich rodinu a výber zahŕňa kompromis medzi presnosťou a rýchlosťou. Prvé dva, IndexFlatL2 a IndexFlatIP, sú presné: líšia sa len použitou metrikou, pre jeden je to Euklidovská vzdialenosť, pre druhý skalárny súčin. IndexIVFFlat mení logiku rozdelením priestoru do zhlukov a vyhľadávaním len v tých najsľubnejších, čo výrazne urýchli vyhľadávanie za cenu miernej straty úplnosti (recall) – a vyžaduje si predchádzajúci tréning na tvojich dátach. Nakoniec, IndexHNSWFlat zostaví graf susedov a pri dopytoch sa ukáže ako veľmi rýchly, pričom parameter 32 tu nastavuje počet susedov zachovaných na každý uzol.
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
Dopytovanie indexu
Vyhľadávanie prebieha v troch krokoch. Najprv zakóduješ otázku používateľa rovnakým modelom ako korpus – dopyt zakódovaný iným modelom by poskytol nezmyselné vzdialenosti. FAISS následne vráti dve paralelné polia: vzdialenosti a indexy k najbližších susedov. Tieto indexy sú pozíciami v tvojom zozname chunkov: tu sa zúročí disciplína z predchádzajúcej lekcie, keďže práve zarovnanie medzi maticou a metadátami ti umožňuje vystopovať späť k textu a jeho zdroju. Test if idx >= 0 pokrýva prípad, keď index obsahuje menej ako k vektorov, v ktorom prípade FAISS doplní chýbajúce miesta 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]}...")
Prechod na kosínusovú podobnosť
FAISS nenúka explicitný index „kosínus“, ale algebra poskytuje bezplatný ekvivalent: pre vektory s normou 1 je skalárny súčin kosínusom. Jednoducho vydelíš každý vektor jeho normou a potom použiješ IndexFlatIP. Táto zmena zďaleka nie je teoretická: vzdialenosť L2 je citlivá na dĺžku vektora, takže veľmi dlhý chunk môže skončiť umelo ďaleko od krátkeho dopytu, aj keď sa ich témy zhodujú. Kosínus meria len orientáciu, teda význam, a to je zvyčajne to, čo chceš porovnávať.
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)
Rovnako ako pri vektoroch, aj index pretrváva na disku. faiss.write_index vytvorí binárny súbor, ktorý faiss.read_index znova načíta tak, ako je, vrátane vnútorných štruktúr – čo je najdôležitejšie pri trénovaných indexoch, kde by inak bolo potrebné obnovovanie vykonať znova.
# 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")
Keď sa korpus stane obrovským
Od niekoľkých stotisíc vektorov sa vyčerpávajúce vyhľadávanie stáva príliš pomalým a index IVF (Inverted File) sa stáva nevyhnutným. Jeho životný cyklus zahŕňa krok, ktorý ploché indexy nemajú: trénovanie, ktoré analyzuje distribúciu tvojich dát na umiestnenie centroidov nlist partition. Ďalej nasleduje pridanie vektorov a potom ladenie nprobe, gombíka, ktorý rozhoduje, koľko partition sa preskúma pri každom dopyte. Zvýšenie nprobe zlepšuje úplnosť (recall) a spomaľuje vyhľadávanie; toto je parameter, ktorý budeš upravovať meraním na reprezentatívnej množine otázok bodu, v ktorom sa výsledky prestanú zlepšovať.
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)
Kľúčové poznatky
- FAISS je štandardom pre rýchle vyhľadávanie vektorov
IndexFlatL2pre malé korpusy (do 100 000 vektorov), presné vyhľadávanieIndexIVFFlatpre veľké korpusy, aproximované, ale rýchle vyhľadávanie- Normalizuj vektory a použij
IndexFlatIPpre kosínusovú podobnosť - Ulož index na disk pomocou
faiss.write_index, aby si sa vyhol opätovnému budovaniu