Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Vektoripood FAISS-iga

Õppetund 12 / 18 Värskendatud 2. november 2026 Arendajatele
Sellel lehel
  1. FAISS: Suurjõudlusega vektorotsing
  2. Loo oma esimene indeks
  3. Õige indeksitüübi valimine
  4. Indeksi pärimine
  5. Üleminek koosinus-sarnasusele
  6. Kui korpus muutub tohutuks
  7. Peamised punktid

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
  • IndexFlatL2 väikeste korpuste jaoks (alla 100k vektori), täpne otsing
  • IndexIVFFlat suurte 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