Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Vector Store s FAISS-om

Lekcija 12 od 18 Ažurirano 2. studenoga 2026. Programer
Na ovoj stranici
  1. FAISS: Pretraživanje vektora visokih performansi
  2. Kreiraj svoj prvi indeks
  3. Odabir ispravne vrste indeksa
  4. Upitivanje indeksa
  5. Prelazak na kosinusnu sličnost
  6. Kada korpus postane ogroman
  7. Ključne točke

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
  • IndexFlatL2 za male korpuse (ispod 100K vektora), egzaktno pretraživanje
  • IndexIVFFlat za velike korpuse, aproksimativno ali brzo pretraživanje
  • Normaliziraj vektore i koristi IndexFlatIP za kosinusnu sličnost
  • Spremi indeks na disk s faiss.write_index kako bi izbjegao ponovnu izgradnju