Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Vector Store FAISS-szal

12. lecke 18 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. FAISS: Nagy teljesítményű vektoros keresés
  2. Hozd létre az első indexedet
  3. A megfelelő indextípus kiválasztása
  4. Az index lekérdezése
  5. Váltás koszinusz-hasonlóságra
  6. Amikor a korpusz masszívvá válik
  7. Főbb megállapítások

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
  • IndexFlatL2 kis korpuszokhoz (100K vektor alatt), pontos keresés
  • IndexIVFFlat nagy 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_index segítségével, hogy elkerüld az újbóli felépítést