Vektorska baza s FAISS
Na tej strani
FAISS: Iskanje vektorjev z visoko zmogljivostjo
Izračunal in shranil si svoje vgraditve (embeddings), a matrika NumPy ni iskalnik: primerjava poizvedbe s 100.000 vektorji z uporabo zanke v Pythonu bi trajala več sekund na vprašanje. FAISS (Facebook AI Similarity Search) rešuje prav ta problem. Ta odprtokodna knjižnica podjetja Meta je zasnovana za iskanje podobnosti v velikih nizih vektorjev; hitra je, pomnilniško učinkovita in deluje enako dobro pri nekaj sto vektorjih kot pri milijonih. Namestitev zahteva le en ukaz. faiss-cpu zadostuje v veliki večini primerov; faiss-gpu je upravičen le pri obsegih, kjer računanje postane ozko grlo.
# pip install faiss-cpu
# or faiss-gpu for GPU acceleration
import faiss
import numpy as np
Ustvari svoj prvi indeks
Najpreprostejši indeks je IndexFlatL2, ki izvaja izčrpno iskanje z uporabo razdalje L2 (evklidska). „Izčrpno” pomeni, da dejansko primerja poizvedbo z vsakim shranjenim vektorjem: brez približkov, torej brez izgubljenih rezultatov. Inicializiraš ga z dimenzijo vektorja—1024 za mistral-embed, vrednost, ki jo prebereš neposredno iz oblike matrike, namesto da bi jo trdo kodiral. Pretvorba v float32 ni izbirna: FAISS zavrne float64, ki ga NumPy privzeto proizvede, in pozaba na to podrobnost je prva napaka, s katero se sreča vsak začetnik.
# 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}")
Izbira prave vrste indeksa
FAISS ne ponuja enega samega indeksa, temveč družino le-teh, izbira pa vključuje kompromis med natančnostjo in hitrostjo. Prva dva, IndexFlatL2 in IndexFlatIP, sta točna: razlikujeta se le v uporabljeni metrik, pri enem je to evklidska razdalja, pri drugem skalarni produkt. IndexIVFFlat spremeni logiko s particioniranjem prostora v gruče in iskanjem le najbolj obetavnih, kar bistveno pospeši iskanje ob rahli izgubi priklica (recall)—in zahteva predhodno usposabljanje na tvojih podatkih. Nazadnje, IndexHNSWFlat gradi graf sosedov in se izkaže za zelo hitrega med poizvedbami, pri čemer parameter 32 določa število sosedov, ohranjenih na vozlišče.
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
Poizvedba v indeksu
Iskanje poteka v treh korakih. Najprej kodiraj uporabnikovo vprašanje z istim modelom kot korpus—poizvedba, kodirana z drugačnim modelom, bi dala nesmiselne razdalje. FAISS nato vrne dve vzporedni polji: razdalje in indekse k najbližjih sosedov. Ti indeksi so položaji v tvojem seznamu kosov (chunks): tu se obrestuje disciplina iz prejšnje lekcije, saj je poravnava med matriko in metapodatki tista, ki ti omogoča sledenje nazaj do besedila in njegovega vira. Preizkus if idx >= 0 pokriva primer, ko indeks vsebuje manj kot k vektorjev, v katerem primeru FAISS manjkajoča mesta zapolni z -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]}...")
Preklop na kosinusno podobnost
FAISS ne ponuja eksplicitnega indeksa „kosinus”, a algebra ponuja brezplačen ekvivalent: za vektorje z normo 1 je skalarni produkt enak kosinusu. Preprosto deliš vsak vektor z njegovo normo, nato pa uporabiš IndexFlatIP. Ta sprememba ni zgolj teoretična: razdalja L2 je občutljiva na dolžino vektorja, zato se lahko zelo dolg kos umetno znajde daleč od kratke poizvedbe, čeprav se njuni temi ujemata. Kosinus meri le usmerjenost, torej pomen, in to je običajno tisto, kar želiš primerjati.
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)
Kot pri vgraditvah tudi indeks ostane na disku. faiss.write_index ustvari binarno datoteko, ki jo faiss.read_index ponovno naloži takšno, kot je, vključno z notranjimi strukturami—kar je najpomembnejše pri usposobljenih indeksih, kjer bi bilo v nasprotnem primeru treba rekonstrukcijo opraviti 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")
Ko korpus postane ogromen
Pri več sto tisoč vektorjih postane izčrpno iskanje prepočasno in indeks IVF (Inverted File) postane nujen. Njegov življenjski cikel vključuje korak, ki ga ravni indeksi nimajo: usposabljanje, ki analizira porazdelitev tvojih podatkov, da postavi težišča particij nlist. Sledi dodajanje vektorjev, nato pa uglaševanje nprobe, ročice, ki odloča, koliko particij bo raziskanih na poizvedbo. Povečanje nprobe izboljša priklic in upočasni iskanje; to je parameter, ki ga boš prilagajal z merjenjem na reprezentativnem nizu vprašanj točke, pri kateri se rezultati prenehajo izboljševati.
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)
Ključne ugotovitve
- FAISS je standard za hitro iskanje vektorjev
IndexFlatL2za majhne korpuse (pod 100 tisoč vektorjev), točno iskanjeIndexIVFFlatza velike korpuse, približno, a hitro iskanje- Normaliziraj vektorje in uporabi
IndexFlatIPza kosinusno podobnost - Shrani indeks na disk z
faiss.write_index, da se izogneš ponovni gradnji