Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Úložisko vektorov s FAISS

Lekcia 12 z 18 Aktualizované 2. novembra 2026 Vývojár
Na tejto strane
  1. FAISS: Vyhľadávanie vektorov s vysokým výkonom
  2. Vytvorenie tvojho prvého indexu
  3. Výber správneho typu indexu
  4. Dopytovanie indexu
  5. Prechod na kosínusovú podobnosť
  6. Keď sa korpus stane obrovským
  7. Kľúčové poznatky

FAISS: Vyhľadávanie vektorov s vysokým výkonom

Vypočítal si a uložil svoje vektory (embeddings), ale matica NumPy nie je vyhľadávač: porovnanie dopytu so 100 000 vektormi pomocou slučky v Pythone by trvalo niekoľko sekúnd na každú otázku. FAISS (Facebook AI Similarity Search) rieši presne tento problém. Táto knižnica s otvoreným zdrojovým kódom od Meta je navrhnutá pre vyhľadávanie podobnosti vo veľkých množinách vektorov; je rýchla, pamäťovo efektívna a funguje rovnako dobre s niekoľkými stovkami vektorov ako s miliónmi. Inštalácia zaberie jediný príkaz. faiss-cpu vo väčšine prípadov úplne stačí; faiss-gpu je opodstatnené len pri objemoch, kde sa výpočet stane úzkym hrdlom.

# pip install faiss-cpu
# or faiss-gpu for GPU acceleration

import faiss
import numpy as np

Vytvorenie tvojho prvého indexu

Najjednoduchší index je IndexFlatL2, ktorý vykonáva vyčerpávajúce vyhľadávanie pomocou vzdialenosti L2 (Euklidovskej). „Vyčerpávajúce“ znamená, že skutočne porovná dopyt s každým uloženým vektorom: žiadna aproximácia, takže žiadne vynechané výsledky. Inicializuješ ho rozmerom vektora – 1024 pre mistral-embed, hodnotu, ktorú si priamo prečítaš z tvaru matice, namiesto toho, aby si ju natvrdo zakódoval. Konverzia na float32 nie je voliteľná: FAISS odmieta float64, ktoré NumPy štandardne produkuje, a zabudnutie na tento detail je prvou chybou, ktorej každý začiatočník čelí.

# 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}")

Výber správneho typu indexu

FAISS nenúka jeden jediný index, ale celú ich rodinu a výber zahŕňa kompromis medzi presnosťou a rýchlosťou. Prvé dva, IndexFlatL2 a IndexFlatIP, sú presné: líšia sa len použitou metrikou, pre jeden je to Euklidovská vzdialenosť, pre druhý skalárny súčin. IndexIVFFlat mení logiku rozdelením priestoru do zhlukov a vyhľadávaním len v tých najsľubnejších, čo výrazne urýchli vyhľadávanie za cenu miernej straty úplnosti (recall) – a vyžaduje si predchádzajúci tréning na tvojich dátach. Nakoniec, IndexHNSWFlat zostaví graf susedov a pri dopytoch sa ukáže ako veľmi rýchly, pričom parameter 32 tu nastavuje počet susedov zachovaných na každý uzol.

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

Dopytovanie indexu

Vyhľadávanie prebieha v troch krokoch. Najprv zakóduješ otázku používateľa rovnakým modelom ako korpus – dopyt zakódovaný iným modelom by poskytol nezmyselné vzdialenosti. FAISS následne vráti dve paralelné polia: vzdialenosti a indexy k najbližších susedov. Tieto indexy sú pozíciami v tvojom zozname chunkov: tu sa zúročí disciplína z predchádzajúcej lekcie, keďže práve zarovnanie medzi maticou a metadátami ti umožňuje vystopovať späť k textu a jeho zdroju. Test if idx >= 0 pokrýva prípad, keď index obsahuje menej ako k vektorov, v ktorom prípade FAISS doplní chýbajúce miesta hodnotou -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]}...")

Prechod na kosínusovú podobnosť

FAISS nenúka explicitný index „kosínus“, ale algebra poskytuje bezplatný ekvivalent: pre vektory s normou 1 je skalárny súčin kosínusom. Jednoducho vydelíš každý vektor jeho normou a potom použiješ IndexFlatIP. Táto zmena zďaleka nie je teoretická: vzdialenosť L2 je citlivá na dĺžku vektora, takže veľmi dlhý chunk môže skončiť umelo ďaleko od krátkeho dopytu, aj keď sa ich témy zhodujú. Kosínus meria len orientáciu, teda význam, a to je zvyčajne to, čo chceš porovnávať.

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)

Rovnako ako pri vektoroch, aj index pretrváva na disku. faiss.write_index vytvorí binárny súbor, ktorý faiss.read_index znova načíta tak, ako je, vrátane vnútorných štruktúr – čo je najdôležitejšie pri trénovaných indexoch, kde by inak bolo potrebné obnovovanie vykonať znova.

# 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")

Keď sa korpus stane obrovským

Od niekoľkých stotisíc vektorov sa vyčerpávajúce vyhľadávanie stáva príliš pomalým a index IVF (Inverted File) sa stáva nevyhnutným. Jeho životný cyklus zahŕňa krok, ktorý ploché indexy nemajú: trénovanie, ktoré analyzuje distribúciu tvojich dát na umiestnenie centroidov nlist partition. Ďalej nasleduje pridanie vektorov a potom ladenie nprobe, gombíka, ktorý rozhoduje, koľko partition sa preskúma pri každom dopyte. Zvýšenie nprobe zlepšuje úplnosť (recall) a spomaľuje vyhľadávanie; toto je parameter, ktorý budeš upravovať meraním na reprezentatívnej množine otázok bodu, v ktorom sa výsledky prestanú zlepšovať.

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)

Kľúčové poznatky

  • FAISS je štandardom pre rýchle vyhľadávanie vektorov
  • IndexFlatL2 pre malé korpusy (do 100 000 vektorov), presné vyhľadávanie
  • IndexIVFFlat pre veľké korpusy, aproximované, ale rýchle vyhľadávanie
  • Normalizuj vektory a použij IndexFlatIP pre kosínusovú podobnosť
  • Ulož index na disk pomocou faiss.write_index, aby si sa vyhol opätovnému budovaniu