Vector Store s FAISS-om
Na ovoj stranici
FAISS: Pretraživanje vektora visokih performansi
Izračunao si i spremio svoje embedinge, ali NumPy matrica nije tražilica: usporedba upita sa 100.000 vektora pomoću Python petlje trajala bi nekoliko sekundi po pitanju. FAISS (Facebook AI Similarity Search) rješava točno taj problem. Ova open-source biblioteka tvrtke Meta dizajnirana je za pretraživanje sličnosti u velikim skupovima vektora; brza je, memorijski učinkovita i jednako dobro radi s nekoliko stotina kao i s milijunima vektora. Instalacija zahtijeva samo jednu naredbu. faiss-cpu je u velikoj većini slučajeva dovoljan; faiss-gpu opravdan je samo za volumene gdje računanje postaje usko grlo.
# pip install faiss-cpu
# or faiss-gpu for GPU acceleration
import faiss
import numpy as np
Kreiraj svoj prvi indeks
Najjednostavniji indeks je IndexFlatL2, koji provodi iscrpno pretraživanje koristeći L2 udaljenost (Euklidska). „Iscrpno“ znači da stvarno uspoređuje upit sa svakim spremljenim vektorom: nema aproksimacije, dakle nema propuštenih rezultata. Inicijaliziraš ga s dimenzijom vektora—1024 za mistral-embed, vrijednost koju očitaš izravno iz oblika matrice umjesto da je hard-kodiraš. Konverzija u float32 nije opcionalna: FAISS odbija float64 koji NumPy proizvodi prema zadanim postavkama, a zaboravljanje ove sitnice prva je greška koju svaki početnik napravi.
# 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}")
Odabir ispravne vrste indeksa
FAISS ne nudi jedan indeks, već obitelj indeksa, a izbor uključuje kompromis između točnosti i brzine. Prva dva, IndexFlatL2 i IndexFlatIP, su egzaktna: razlikuju se samo u metrikama koje koriste, jedna koristi Euklidsku udaljenost, druga umnožak skalarnih produkata. IndexIVFFlat mijenja logiku particioniranjem prostora u klastere i pretraživanjem samo najobećavajućih, što značajno ubrzava pretraživanje uz cijenu blagog gubitka u povratu rezultata (recall)—i zahtijeva prethodno treniranje na tvojim podacima. Konačno, IndexHNSWFlat gradi graf susjeda i pokazuje se vrlo brzim tijekom upita, pri čemu parametar 32 ovdje postavlja broj susjeda zadržanih po čvoru.
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
Upitivanje indeksa
Pretraživanje se odvija u tri koraka. Prvo, kodiraj korisnikovo pitanje s istim modelom kao i korpus—upit kodiran drugim modelom dao bi besmislene udaljenosti. FAISS zatim vraća dva paralelna polja: udaljenosti i indekse k najbližih susjeda. Ti indeksi su pozicije u tvom popisu chunkova: ovdje se isplaćuje disciplina iz prethodne lekcije, jer je poravnanje između matrice i metapodataka ono što ti omogućuje praćenje natrag do teksta i njegovog izvora. Test if idx >= 0 pokriva slučaj gdje indeks sadrži manje od k vektora, u kojem slučaju FAISS popunjava nedostajuća mjesta s -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]}...")
Prelazak na kosinusnu sličnost
FAISS ne nudi eksplicitni „kosinusni“ indeks, ali algebra nudi besplatan ekvivalent: za vektore s normom 1, umnožak skalarnih produkata jest kosinus. Jednostavno podijeliš svaki vektor s njegovom normom, a zatim koristiš IndexFlatIP. Ova promjena daleko je od teoretske: L2 udaljenost osjetljiva je na duljinu vektora, pa vrlo dugi chunk može završiti umjetno daleko od kratkog upita čak i ako se teme podudaraju. Kosinus mjeri samo orijentaciju, dakle značenje, a to je općenito ono što želiš uspoređivati.
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)
Kao i kod embedinga, indeks se.persistira na disk. faiss.write_index proizvodi binarnu datoteku koju faiss.read_index ponovno učitava kakva jest, uključujući interne strukture—što je najvažnije za trenirane indekse, gdje bi rekonstrukcija inače morala biti ponovljena.
# 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")
Kada korpus postane ogroman
Počevši od nekoliko stotina tisuća vektora, iscrpno pretraživanje postaje presporo i indeks IVF (Inverted File) postaje nužan. Njegov životni ciklus uključuje korak koji ravni indeksi nemaju: treniranje, koje analizira distribuciju tvojih podataka kako bi postavilo centre nlist particija. Slijedi dodavanje vektora, a zatim podešavanje nprobe, regulatora koji odlučuje koliko će se particija istražiti po upitu. Povećanje nprobe poboljšava povrat rezultata (recall) i usporava pretraživanje; to je parametar koji ćeš prilagoditi mjerenjem, na reprezentativnom skupu pitanja, točke u kojoj rezultati prestaju napredovati.
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 točke
- FAISS je standard za brzo pretraživanje vektora
IndexFlatL2za male korpuse (ispod 100K vektora), egzaktno pretraživanjeIndexIVFFlatza velike korpuse, aproksimativno ali brzo pretraživanje- Normaliziraj vektore i koristi
IndexFlatIPza kosinusnu sličnost - Spremi indeks na disk s
faiss.write_indexkako bi izbjegao ponovnu izgradnju