Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Vector Store s FAISS

Lekce 12 z 18 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. FAISS: Vyhledávání vektorů s vysokým výkonem
  2. Vytvoření prvního indexu
  3. Výběr správného typu indexu
  4. Dotazování na index
  5. Přepnutí na kosinovou podobnost
  6. Když se korpus stane obrovským
  7. Klíčové poznatky

FAISS: Vyhledávání vektorů s vysokým výkonem

Spočítal jsi a uložil své vektory (embeddings), ale matice NumPy není vyhledávač: porovnání dotazu se 100 000 vektory pomocí smyčky v Pythonu by trvalo několik sekund na každou otázku. FAISS (Facebook AI Similarity Search) řeší přesně tento problém. Tato open-source knihovna od Meta je navržena pro vyhledávání podobnosti ve velkých sadách vektorů; je rychlá, paměťově efektivní a funguje stejně dobře s několika stovkami vektorů jako s miliony. Instalace zabere jediný příkaz. faiss-cpu stačí ve velké většině případů; faiss-gpu je opodstatněné pouze u objemů, kde se výpočet stane úzkým hrdlem.

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

import faiss
import numpy as np

Vytvoření prvního indexu

Nejjednodušším indexem je IndexFlatL2, který provádí vyčerpávající vyhledávání pomocí vzdálenosti L2 (Eukleidovská). „Vyčerpávající“ znamená, že skutečně porovná dotaz s každým uloženým vektorem: žádná aproximace, takže žádné vynechané výsledky. Inicializuješ jej dimenzí vektoru – 1024 pro mistral-embed, hodnotu, kterou přečteš přímo z tvaru matice, místo abys ji natvrdo zakódoval. Převod na float32 není volitelný: FAISS odmítá float64, které NumPy ve výchozím nastavení produkuje, a zapomenutí tohoto detailu je první chybou, do které spadne každý začátečník.

# 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ýběr správného typu indexu

FAISS nenabízí jediný index, ale celou jejich rodinu a výběr zahrnuje kompromis mezi přesností a rychlostí. První dva, IndexFlatL2 a IndexFlatIP, jsou exaktní: liší se pouze použitou metrikou, pro jeden je to Eukleidovská vzdálenost, pro druhý skalární součin. IndexIVFFlat mění logiku rozdělením prostoru do clusterů a vyhledáváním pouze v těch nejslibnějších, což výrazně zrychlí hledání za cenu mírné ztráty úplnosti (recall) – a vyžaduje předchozí trénink na tvých datech. Nakonec IndexHNSWFlat buduje graf sousedů a při dotazech se ukazuje jako velmi rychlý, přičemž parametr 32 zde nastavuje počet sousedů zachovaných na uzel.

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

Dotazování na index

Vyhledávání probíhá ve třech krocích. Nejprve zakóduješ otázku uživatele stejným modelem jako korpus – dotaz zakódovaný jiným modelem by poskytl nesmyslné vzdálenosti. FAISS poté vrátí dvě paralelní pole: vzdálenosti a indexy k nejbližších sousedů. Tyto indexy jsou pozicemi v tvém seznamu chunků: zde se vyplatí kázeň z předchozí lekce, protože právě zarovnání mezi maticí a metadaty ti umožňuje vystopovat zpět text a jeho zdroj. Test if idx >= 0 pokrývá případ, kdy index obsahuje méně než k vektorů, v takovém případě FAISS chybějící místa vyplní 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]}...")

Přepnutí na kosinovou podobnost

FAISS nenabízí explicitní index „kosinus“, ale algebra poskytuje bezplatný ekvivalent: pro vektory s normou 1 je skalární součin kosinem. Jednoduše vydělíš každý vektor jeho normou a poté použiješ IndexFlatIP. Tato změna není jen teoretická: vzdálenost L2 je citlivá na délku vektoru, takže velmi dlouhý chunk může skončit uměle daleko od krátkého dotazu, i když se jejich témata shodují. Kosinus měří pouze orientaci, tedy význam, a to je obvykle to, co chceš porovnávat.

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)

Stejně jako u vektorů přetrvává index na disku. faiss.write_index vytvoří binární soubor, který faiss.read_index znovu načte tak, jak je, včetně vnitřních struktur – což je nejdůležitější u trénovaných indexů, kde by jinak bylo nutné rekonstrukci provádět znovu.

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

Když se korpus stane obrovským

Od několika set tisíc vektorů se vyčerpávající vyhledávání stává příliš pomalým a index IVF (Inverted File) se stává nezbytným. Jeho životní cyklus zahrnuje krok, který ploché indexy nemají: trénink, který analyzuje rozložení tvých dat za účelem umístění centroidů nlist oddílů. Následuje přidání vektorů a poté ladění nprobe, což je ovládací prvek, který rozhoduje, kolik oddílů bude pro každý dotaz prozkoumáno. Zvýšení nprobe zlepšuje úplnost (recall) a zpomaluje vyhledávání; toto je parametr, který budeš upravovat měřením na reprezentativní sadě otázek, dokud nenajdeš bod, kdy se výsledky přestanou zlepšovat.

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)

Klíčové poznatky

  • FAISS je standardem pro rychlé vyhledávání vektorů
  • IndexFlatL2 pro malé korpusy (do 100 tisíc vektorů), exaktní vyhledávání
  • IndexIVFFlat pro velké korpusy, aproximované, ale rychlé vyhledávání
  • Normalizuj vektory a použij IndexFlatIP pro kosinovou podobnost
  • Ulož index na disk pomocí faiss.write_index, abys předešel jeho opětovnému vytváření