Vector Store FAISS-szal
Ezen az oldalon
FAISS: Nagy teljesítményű vektoros keresés
Kiszámoltad és elmentetted a beágyazásaidat (embeddings), de egy NumPy mátrix még nem keresőmotor: ha Python ciklussal hasonlítasz össze egy lekérdezést 100 000 vektorral, az kérdésenként több másodpercig is eltarthat. A FAISS (Facebook AI Similarity Search) pontosan ezt a problémát oldja meg. Ez a Meta nyílt forráskódú könyvtára nagy vektorkészletek hasonlósági keresésére készült: gyors, memóriahatékony, és ugyanolyan jól működik néhány száz, mint több millió vektor esetén. A telepítése egyetlen parancs. A legtöbb esetben a faiss-cpu elegendő; a faiss-gpu csak olyan volumen mellett indokolt, ahol a számítás válik szűk keresztmetszetté.
# pip install faiss-cpu
# or faiss-gpu for GPU acceleration
import faiss
import numpy as np
Hozd létre az első indexedet
A legegyszerűbb index az IndexFlatL2, amely kimerítő keresést végez L2 távolság (Euklideszi) alapján. A „kimerítő“ azt jelenti, hogy a lekérdezést ténylegesen összehasonlítja minden tárolt vektorral: nincs közelítés, így nincs elvétett találat sem. Az inicializáláshoz meg kell adnod a vektor dimenzióját – a mistral-embed esetén ez 1024, egy értéket, amit közvetlenül a mátrix alakjából olvasol ki, ahelyett, hogy beégetnéd a kódba. A float32 típusra való konvertálás nem opcionális: a FAISS elutasítja a NumPy által alapértelmezetten előállított float64-ot, és ennek elfelejtése az első hiba, amibe minden kezdő belefut.
# 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}")
A megfelelő indextípus kiválasztása
A FAISS nem egyetlen indexet kínál, hanem ezek egy családját, és a választás a pontosság és a sebesség közötti kompromisszumot jelenti. Az első kettő, az IndexFlatL2 és az IndexFlatIP, pontos: csak a használt metrikában térnek el, az egyik az Euklideszi távolságot, a másik a skaláris szorzatot használja. Az IndexIVFFlat megváltoztatja a logikát: a teret klaszterekbe particionálja, és csak a legígéretesebbeket keresi át, ami jelentősen felgyorsítja a keresést a visszaidézés (recall) enyhe csökkenése árán – ehhez azonban előzetes tanítás szükséges az adataidon. Végül az IndexHNSWFlat egy szomszédgráfot épít fel, és lekérdezéskor nagyon gyorsnak bizonyul; itt a 32-es paraméter határozza meg a csomópontonként megtartott szomszédok számát.
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
Az index lekérdezése
A keresés három lépésből áll. Először kódold le a felhasználó kérdését ugyanazzal a modellel, mint a korpuszt – egy másik modellel kódolt lekérdezés értelmetlen távolságokat eredményezne. A FAISS ezután két párhuzamos tömböt ad vissza: a távolságokat és a k legközelebbi szomszéd indexeit. Ezek az indexek a chunk-listádban lévő pozíciók: itt térül meg az előző leckében tanult fegyelem, hiszen a mátrix és a metaadatok közötti igazodás teszi lehetővé, hogy visszavezesd az eredményt a szöveghez és annak forrásához. Az if idx >= 0 teszt arra az esetre vonatkozik, amikor az index kevesebb mint k vektort tartalmaz; ilyenkor a FAISS a hiányzó helyeket -1-gyel tölti ki.
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]}...")
Váltás koszinusz-hasonlóságra
A FAISS nem kínál kifejezett „koszinusz“ indexet, de az algebra ingyenes ekvivalenst biztosít: az 1 normájú vektorok esetén a skaláris szorzat megegyezik a koszinusszal. Egyszerűen elosztod minden vektort a normájával, majd az IndexFlatIP-t használod. Ez a változtatás korántsem elméleti: az L2 távolság érzékeny a vektor hosszára, így egy nagyon hosszú chunk mesterségesen távol kerülhet egy rövid lekérdezéstől akkor is, ha a témájuk megegyezik. A koszinusz csak az irányt, azaz a jelentést méri, és általában ezt szeretnéd összehasonlítani.
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)
Akárcsak a beágyazások esetében, az index is lemezre persistálható. A faiss.write_index egy bináris fájlt hoz létre, amelyet a faiss.read_index változatlanul, a belső struktúrákkal együtt tölt be – ez különösen fontos a tanított indexeknél, ahol egyébként újra el kellene végezni a rekonstrukciót.
# 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")
Amikor a korpusz masszívvá válik
Néhány százezer vektortól kezdve a kimerítő keresés túl lassúvá válik, és az IVF (Inverted File) index használata válik szükségessé. Ennek életciklusa tartalmaz egy lépést, ami a lapos indexeknél nincs jelen: a tanítást, amely elemzi az adataid eloszlását, hogy elhelyezze az nlist számú partíció centroidjait. Ezt követi a vektorok hozzáadása, majd az nprobe hangolása; ez az a „gomb“, amely eldönti, hány partíciót vizsgál meg a rendszer lekérdezésenként. Az nprobe növelése javítja a visszaidézést és lassítja a keresést; ez az a paraméter, amit úgy állítasz be, hogy egy reprezentatív kérdéshalmazon méred: megtalálod azt a pontot, ahol az eredmények már nem javulnak tovább.
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)
Főbb megállapítások
- A FAISS a gyors vektoros keresés szabványa
IndexFlatL2kis korpuszokhoz (100K vektor alatt), pontos keresésIndexIVFFlatnagy korpuszokhoz, közelítő, de gyors keresés- Normalizáld a vektorokat és használd az
IndexFlatIP-t koszinusz-hasonlósághoz - Mentsd el az indexet lemezre a
faiss.write_indexsegítségével, hogy elkerüld az újbóli felépítést