Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Vector Store med FAISS

Lektion 12 af 18 Opdateret 2. november 2026 Udvikler
På denne side
  1. FAISS: Højtydende vektorsøgning
  2. Opret dit første indeks
  3. Valg af den rigtige indeks-type
  4. Forespørgsel af indekset
  5. Skift til cosinus-lichenhed
  6. Når korpusset bliver massivt
  7. Vigtige pointer

FAISS: Højtydende vektorsøgning

Du har beregnet og gemt dine embeddings, men en NumPy-matrix er ikke en søgemaskine: At sammenligne en forespørgsel med 100.000 vektorer ved hjælp af en Python-løkke ville tage flere sekunder per spørgsmål. FAISS (Facebook AI Similarity Search) løser præcis dette problem. Dette open source-bibliotek fra Meta er designet til lighedssøgning på tværs af store vektorsæt; det er hurtigt, hukommelseseffektivt og fungerer lige godt med få hundrede vektorer som med millioner. Installationen kræver kun én kommando. faiss-cpu er tilstrækkeligt i langt de fleste tilfælde; faiss-gpu er kun berettiget ved volumener, hvor beregning bliver flaskehalsen.

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

import faiss
import numpy as np

Opret dit første indeks

Det enkleste indeks er IndexFlatL2, som udfører en udtømmende søgning ved hjælp af L2-afstand (Euklidisk). “Udtømmende” betyder, at det faktisk sammenligner forespørgslen med hver eneste lagret vektor: ingen tilnærmelser, så ingen missede resultater. Du initialiserer det med vektordimensionen – 1024 for mistral-embed, en værdi du læser direkte fra matrix-formen i stedet for at hardcode den. Konvertering til float32 er ikke valgfri: FAISS afviser den float64, som NumPy producerer som standard, og at glemme denne detalje er den første fejl, enhver begynder støder på.

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

Valg af den rigtige indeks-type

FAISS tilbyder ikke ét enkelt indeks, men en familie af dem, og valget indebærer en afvejning mellem nøjagtighed og hastighed. De to første, IndexFlatL2 og IndexFlatIP, er eksakte: de adskiller sig kun ved den metrik, der bruges, henholdsvis euklidisk afstand og prikprodukt. IndexIVFFlat ændrer logikken ved at opdele rummet i klynger og kun søge i de mest lovende, hvilket øger søgehastigheden markant på bekostning af et lille tab i recall – og kræver forudgående træning på dine data. Endelig bygger IndexHNSWFlat en nabograf og viser sig at være meget hurtig under forespørgsler, hvor parameteren 32 her sætter antallet af naboer, der beholdes per node.

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

Forespørgsel af indekset

Søgningen foregår i tre trin. Først encoder du brugerens spørgsmål med den samme model som korpusset – en forespørgsel encoderet af en anden model ville give meningsløse afstande. FAISS returnerer derefter to parallelle arrays: afstandene og indeksene for de k nærmeste naboer. Disse indeks er positioner i din liste over chunks: her betaler disciplinen fra den tidligere lektion sig, da sammenhængen mellem matrixen og metadataene er det, der gør det muligt at spore tilbage til teksten og dens kilde. Testen if idx >= 0 dækker tilfældet, hvor indekset indeholder færre end k vektorer, i hvilket tilfælde FAISS fylder de manglende pladser med -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]}...")

Skift til cosinus-lichenhed

FAISS tilbyder ikke et eksplicit “cosine”-indeks, men algebraen giver en gratis ækvivalent: for vektorer med norm 1 er prikproduktet cosinus. Du dividerer blot hver vektor med sin norm og bruger derefter IndexFlatIP. Denne ændring er langt fra teoretisk: L2-afstand er følsom over for vektorlængde, så et meget langt chunk kan ende kunstigt langt fra en kort forespørgsel, selvom deres emner matcher. Cosinus måler kun orientering, altså betydning, og det er generelt det, du ønsker at sammenligne.

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)

Ligesom med embeddings persisters indekset på disken. faiss.write_index producerer en binær fil, som faiss.read_index genindlæser nøjagtigt som den er, inklusive interne strukturer – hvilket er vigtigst for trænede indeks, hvor rekonstruktion ellers skulle udføres på ny.

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

Når korpusset bliver massivt

Fra flere hundrede tusinde vektorer bliver udtømmende søgning for langsom, og IVF-indekset (Inverted File) bliver nødvendigt. Dets livscyklus inkluderer et trin, som flade indeks ikke har: træning, som analyserer din datafordeling for at placere nlist partitions-centroider. Derefter følger tilføjelsen af vektorerne og derefter justeringen af nprobe, knappen der afgør, hvor mange partitioner der vil blive undersøgt per forespørgsel. At øge nprobe forbedrer recall og sænker søgehastigheden; dette er den parameter, du vil justere ved at måle på et repræsentativt sæt af spørgsmål det punkt, hvor resultaterne holder op med at blive bedre.

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)

Vigtige pointer

  • FAISS er standarden for hurtig vektorsøgning
  • IndexFlatL2 til små korpusser (under 100K vektorer), eksakt søgning
  • IndexIVFFlat til store korpusser, tilnærmet men hurtig søgning
  • Normaliser vektorer og brug IndexFlatIP til cosinus-lichenhed
  • Gem indekset på disken med faiss.write_index for at undgå genopbygning