Vektoripood FAISS-iga
Sellel lehel
FAISS: Suurjõudlusega vektorotsing
Oled arvutanud ja salvestanud oma manused (embeddings), kuid NumPy maatriks ei ole otsingumootor: päringu võrdlemine 100 000 vektoriga Pythoni tsükli abil võtaks mitu sekundit küsimuse kohta. FAISS (Facebook AI Similarity Search) lahendab täpselt selle probleemi. See Meta avatud lähtekoodiga teek on loodud sarnasusotsinguks suurtes vektorikomplektides; see on kiire, mälusäästlik ja töötab sama hästi nii mõnesaja kui ka miljoni vektoriga. Paigaldamine võtab aega ühe käsu. Enamiku juhtudest piisab faiss-cpu versioonist; faiss-gpu on õigustatud ainult selliste mahtude korral, kus arvutus muutub pudelikaelaks.
# pip install faiss-cpu
# or faiss-gpu for GPU acceleration
import faiss
import numpy as np
Loo oma esimene indeks
Lihtsaim indeks on IndexFlatL2, mis teostab ammendava otsingu kasutades L2 kaugust (Eukleidiline). „Ammendav“ tähendab, et see võrdleb päringut tegelikult iga salvestatud vektoriga: ligikaudset arvutust ei toimu, seega tulemusi ei jäeta vahele. Initsialiseerid selle vektori mõõtmetega – 1024 mudeli mistral-embed puhul, väärtuse, mille loed otse maatriksi kujust, mitte ei kodeeri seda käsitsi. Teisendamine vormingusse float32 ei ole valikuline: FAISS lükkab tagasi float64, mida NumPy vaikimisi toodab, ja selle detaili unustamine on esimene viga, millega iga algaja kokku puutub.
# 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}")
Õige indeksitüübi valimine
FAISS ei paku mitte ühte indeksit, vaid tervet perekonda ning valik hõlmab kompromissi täpsuse ja kiiruse vahel. Esimesed kaks, IndexFlatL2 ja IndexFlatIP, on täpsed: need erinevad vaid kasutatava meetrika poolest, ühel juhul Eukleidiline kaugus, teisel skalaarkorrutis. IndexIVFFlat muudab loogikat, jagades ruumi klastritesse ja otsides ainult kõige paljutõotavamaid, mis kiirendab otsingut oluliselt, kuid toob kaasa väikese täpsuskao – ja nõuab eelnevat treenimist sinu andmetel. Lõpuks, IndexHNSWFlat ehitab naabrusgraafiku ja osutub päringute ajal väga kiireks, kusjuures parameeter 32 määrab siin iga sõlme kohta säilitatavate naabrite arvu.
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
Indeksi pärimine
Otsing toimub kolmes etapis. Esiteks kodeeri kasutaja küsimus sama mudeliga nagu korpuse puhul – erineva mudeliga kodeeritud päring annaks mõttetuid kaugusi. FAISS tagastab seejärel kaks paralleelset massiivi: kaugused ja k lähima naabri indeksid. Need indeksid on positsioonid sinu tükkide (chunks) loendis: just siin tasub ära eelmise tunni distsipliin, kuna maatriksi ja metaandmete joondamine võimaldab sul tagasi liikuda teksti ja selle allika juurde. Tingimus if idx >= 0 katab juhu, kui indeks sisaldab vähem kui k vektorit, millisel juhul täidab FAISS puuduvad kohad väärtusega -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]}...")
Üleminek koosinus-sarnasusele
FAISS ei paku otsest „koosinus“ indeksit, kuid algebra pakub tasuta ekvivalenti: normiga 1 vektorite puhul on skalaarkorrutis koosinus. Sa lihtsalt jagad iga vektori selle normiga ja kasutad seejärel IndexFlatIP. See muutus pole kaugeltki teoreetiline: L2 kaugus on tundlik vektori pikkuse suhtes, nii et väga pikk tükk võib lõppeda kunstlikult kaugel lühikesest päringust, isegi kui nende teemad kattuvad. Koosinus mõõdab ainult orientatsiooni ehk tähendust ja just seda soovid enamasti võrrelda.
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)
Nagu manuste puhulgi, püsib indeks kettal. faiss.write_index loob binaarse faili, mille faiss.read_index laeb muutumatul kujul uuesti, kaasa arvatud sisemised struktuurid – mis on kõige olulisem treenitud indeksite puhul, kus rekonstrueerimine tuleks muidu uuesti ette võtta.
# 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")
Kui korpus muutub tohutuks
Alates mõnest sajast tuhandest vektorist muutub ammendav otsing liiga aeglaseks ja vajalikuks saab IVF (Inverted File) indeks. Selle elutsükkel hõlmab sammu, mida tasastel indeksitel pole: treenimine, mis analüüsib sinu andmete jaotust, et paigutada nlist partitsiooni tsentroidid. Seejärel lisatakse vektorid ja häälestatakse nprobe, nupp, mis otsustab, mitut partitsiooni iga päringu kohta uuritakse. nprobe suurendamine parandab täielikkust (recall) ja aeglustab otsingut; see on parameeter, mida kohandad, mõõtes esinduslikul küsimuste hulgal punkti, kus tulemused enam ei parane.
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)
Peamised punktid
- FAISS on kiire vektorotsingu standard
IndexFlatL2väikeste korpuste jaoks (alla 100k vektori), täpne otsingIndexIVFFlatsuurte korpuste jaoks, ligikaudne kuid kiire otsing- Normaliseeri vektorid ja kasuta koosinus-sarnasuse jaoks
IndexFlatIP - Salvesta indeks kettale käsuga
faiss.write_index, et vältida uuesti loomist