Przejdź do głównej treści
Polski— Wybierz język
Menu

Vector Store z FAISS

Lekcja 12 z 18 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. FAISS: Wysokowydajne wyszukiwanie wektorowe
  2. Stwórz swój pierwszy indeks
  3. Wybór odpowiedniego typu indeksu
  4. Odpytywanie indeksu
  5. Przejście na podobieństwo cosinusowe
  6. Gdy korpus staje się ogromny
  7. Kluczowe wnioski

FAISS: Wysokowydajne wyszukiwanie wektorowe

Obliczyłeś i zapisałeś swoje embeddingi, ale macierz NumPy nie jest silnikiem wyszukiwania: porównanie zapytania do 100 000 wektorów za pomocą pętli w Pythonie zajęłoby kilka sekund na każde pytanie. FAISS (Facebook AI Similarity Search) rozwiązuje dokładnie ten problem. Ta biblioteka open source od Meta została zaprojektowana do wyszukiwania podobieństw w dużych zbiorach wektorów; jest szybka, oszczędna pod względem pamięci i działa równie dobrze z kilkuset wektorami, jak i z milionami. Instalacja wymaga tylko jednego polecenia. W zdecydowanej większości przypadków wystarczy faiss-cpu; faiss-gpu jest uzasadnione tylko przy takich wolumenach, gdzie obliczenia stają się wąskim gardłem.

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

import faiss
import numpy as np

Stwórz swój pierwszy indeks

Najprostszym indeksem jest IndexFlatL2, który wykonuje wyszukiwanie wyczerpujące (exhaustive search) przy użyciu odległości L2 (euklidesowej). „Wyczerpujące“ oznacza, że faktycznie porównuje ono zapytanie z każdym zapisanym wektorem: brak aproksymacji, więc brak pominiętych wyników. Inicjalizujesz go wymiarem wektora – 1024 dla mistral-embed, wartość tę odczytujesz bezpośrednio z kształtu macierzy, zamiast wpisywać ją na sztywno. Konwersja do float32 nie jest opcjonalna: FAISS odrzuca float64, które NumPy domyślnie generuje, a zapomnienie o tym szczególe to pierwszy błąd, jaki popełnia każdy początkujący.

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

Wybór odpowiedniego typu indeksu

FAISS nie oferuje jednego indeksu, lecz całą ich rodzinę, a wybór wiąże się z kompromisem między dokładnością a szybkością. Dwa pierwsze, IndexFlatL2 i IndexFlatIP, są dokładne: różnią się tylko użytą metryką – odległością euklidesową w jednym przypadku i iloczynem skalarnym w drugim. IndexIVFFlat zmienia logikę, dzieląc przestrzeń na klastry i przeszukując tylko te najbardziej obiecujące, co znacznie przyspiesza wyszukiwanie kosztem niewielkiej utraty pełności wyników (recall) – wymaga jednak wcześniejszego wytrenowania na Twoich danych. Na koniec, IndexHNSWFlat buduje graf sąsiadów i okazuje się bardzo szybki podczas zapytań, przy czym parametr 32 ustawia tutaj liczbę sąsiadów przechowywanych w każdym węźle.

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

Odpytywanie indeksu

Wyszukiwanie odbywa się w trzech krokach. Po pierwsze, zakoduj pytanie użytkownika za pomocą tego samego modelu, co korpus – zapytanie zakodowane przez inny model dałoby bezsensowne odległości. FAISS zwraca następnie dwie równoległe tablice: odległości i indeksy k najbliższych sąsiadów. Te indeksy to pozycje na Twojej liście fragmentów (chunks): tutaj przydaje się dyscyplina z poprzedniej lekcji, ponieważ to zgodność między macierzą a metadanymi pozwala cofnąć się do tekstu i jego źródła. Test if idx >= 0 obsługuje przypadek, gdy indeks zawiera mniej niż k wektorów; wtedy FAISS wypełnia brakujące miejsca wartością -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]}...")

Przejście na podobieństwo cosinusowe

FAISS nie oferuje jawnego indeksu „cosinusowego“, ale algebra dostarcza darmowego odpowiednika: dla wektorów o normie 1 iloczyn skalarny jest cosinusem. Wystarczy podzielić każdy wektor przez jego normę, a następnie użyć IndexFlatIP. Ta zmiana nie jest tylko teoretyczna: odległość L2 jest wrażliwa na długość wektora, więc bardzo długi fragment może sztucznie znaleźć się daleko od krótkiego zapytania, nawet jeśli ich tematyka jest zgodna. Cosinus mierzy wyłącznie orientację, a więc znaczenie, i to zazwyczaj jest to, co chcesz porównywać.

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)

Podobnie jak w przypadku embeddingów, indeks utrwalasz na dysku. faiss.write_index tworzy plik binarny, który faiss.read_index wczytuje w niezmienionej formie, łącznie ze strukturami wewnętrznymi – co ma kluczowe znaczenie dla indeksów wytrenowanych, gdzie w przeciwnym razie należałoby powtórzyć proces rekonstrukcji.

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

Gdy korpus staje się ogromny

Począwszy od kilkuset tysięcy wektorów, wyszukiwanie wyczerpujące staje się zbyt wolne i konieczne staje się użycie indeksu IVF (Inverted File). Jego cykl życia obejmuje krok, którego nie mają indeksy płaskie: trenowanie, które analizuje rozkład Twoich danych, aby umieścić centra nlist partycji. Następnie następuje dodawanie wektorów, a potem dostrajanie parametru nprobe, który decyduje, ile partycji zostanie przeszukanych na każde zapytanie. Zwiększenie nprobe poprawia pełność wyników (recall) i spowalnia wyszukiwanie; jest to parametr, który dostosujesz, mierząc na reprezentatywnym zestawie pytań punkt, w którym wyniki przestają się poprawiać.

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)

Kluczowe wnioski

  • FAISS to standard szybkiego wyszukiwania wektorowego
  • IndexFlatL2 dla małych korpusów (poniżej 100 tys. wektorów), wyszukiwanie dokładne
  • IndexIVFFlat dla dużych korpusów, wyszukiwanie przybliżone, ale szybkie
  • Normalizuj wektory i używaj IndexFlatIP dla podobieństwa cosinusowego
  • Zapisz indeks na dysku za pomocą faiss.write_index, aby uniknąć jego ponownego budowania