Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Veikalu krātuve ar FAISS

Nodarbība 12 no 18 Atjaunota 2026. gada 2. novembris Programmētājs
Šajā lapā
  1. FAISS: Augstas veiktspējas vektoru meklēšana
  2. Izveido savu pirmo indeksu
  3. Pareizā indeksa tipa izvēle
  4. Vaicājumu veikšana indeksam
  5. Pāreja uz kosinusa līdzību
  6. Kad korpuss kļūst milzīgs
  7. Galvenās atziņas

FAISS: Augstas veiktspējas vektoru meklēšana

Tu esi aprēķinājis un saglabājis savus ieguljumus (embeddings), taču NumPy matrica nav meklētājprogramma: jautājuma salīdzināšana ar 100 000 vektoriem, izmantojot Python ciklu, aizņemtu vairākas sekundes uz katru jautājumu. FAISS (Facebook AI Similarity Search) atrisina tieši šo problēmu. Šī Meta atvērtā koda bibliotēka ir izstrādāta līdzības meklēšanai lielos vektoru kopumos; tā ir ātra, atmiņu taupoša un darbojas tikpat labi ar dažiem simtiem vektoru kā ar miljoniem. Instalācija prasa tikai vienu komandu. Vairumā gadījumu pietiek ar faiss-cpu; faiss-gpu ir attaisnojams tikai tādos apjomos, kuros aprēķini kļūst par „pudeles kaklu”.

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

import faiss
import numpy as np

Izveido savu pirmo indeksu

Vienkāršākais indekss ir IndexFlatL2, kas veic pilnīgu meklēšanu, izmantojot L2 attālumu (Eiklīda). „Pilnīga” nozīmē, ka tas faktiski salīdzina vaicājumu ar katru saglabāto vektoru: nav tuvinājumu, līdz ar to nav arī izlaistu rezultātu. Tu to inicializē ar vektora dimensiju — 1024 priekš mistral-embed, vērtību, ko nolasi tieši no matricas formas, nevis ieraksti cietkodēti. Konvertēšana uz float32 nav izvēles iespēja: FAISS noraida float64, ko NumPy ģenerē pēc noklusējuma, un šīs detaļas aizmirstšana ir pirmā kļūda, ar ko saskaras ikviens iesācējs.

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

Pareizā indeksa tipa izvēle

FAISS nepiedāvā vienu indeksu, bet gan to saimi, un izvēle ir kompromiss starp precizitāti un ātrumu. Pirmie divi, IndexFlatL2 un IndexFlatIP, ir precīzi: tie atšķiras tikai ar izmantoto metrisko lielumu — vienam tas ir Eiklīda attālums, otram — skalārais reizinājums. IndexIVFFlat maina loģiku, sadalot telpu kopās (clusters) un meklējot tikai daudzsološākajās, kas ievērojami paātrina meklēšanu par cenu nelielam atgūšanas precizitātes zudumam — un prasa iepriekšēju apmācību uz taviem datiem. Visbeidzot, IndexHNSWFlat veido kaimiņu grafu un izrādās ļoti ātrs vaicājumu laikā, kur parametrs 32 šeit nosaka katrā mezglā saglabājamo kaimiņu skaitu.

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

Vaicājumu veikšana indeksam

Meklēšana notiek trīs soļos. Pirmkārt, kodē lietotāja jautājumu ar to pašu modeli, ko izmantoji korpusam — jautājums, kas kodēts ar citu modeli, dotu bezjēdzīgus attālumus. FAISS tad atgriež divas paralēlas masīva rindas: attālumus un k tuvāko kaimiņu indeksus. Šie indeksi ir pozīcijas tavā fragmentu (chunks) sarakstā: tieši šeit noder iepriekšējās nodarbības disciplīna, jo tieši sakritība starp matricu un metadatiem ļauj tev atgriezties pie teksta un tā avota. Tests if idx >= 0 sedz gadījumu, kad indekss satur mazāk nekā k vektorus; tādā gadījumā FAISS trūkstošās vietas aizpilda ar -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āreja uz kosinusa līdzību

FAISS nepiedāvā eksplicītu „kosinusa” indeksu, taču algebra piedāvā bezmaksas ekvivalentu: vektoriem ar normu 1 skalārais reizinājums ir kosinuss. Tu vienkārši sadali katru vektoru ar tā normu un tad izmanto IndexFlatIP. Šīs izmaiņas nav tikai teorētiskas: L2 attālums ir jutīgs pret vektora garumu, tāpēc ļoti garš fragments var mākslīgi nonākt tālu no īsa vaicājuma, pat ja to tēmas sakrīt. Kosinuss mēra tikai virzienu, līdz ar to — nozīmi, un parasti tieši to tu vēlies salīdzināt.

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)

Tāpat kā ar iegulumiem, arī indekss tiek saglabāts diskā. faiss.write_index ģenerē bināru failu, ko faiss.read_index ielādē tādu pašu, ieskaitot iekšējās struktūras — kas ir vis svarīgāk apmācītiem indeksiem, kur citādi būtu jāveic atkārtota rekonstrukcija.

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

Kad korpuss kļūst milzīgs

Sākot no vairākiem simtiem tūkstošu vektoru, pilnīga meklēšana kļūst pārāk lēna, un kļūst nepieciešams IVF (apgrieztā faila) indekss. Tā dzīves cikls ietver soli, kas nav raksturīgs plakanajiem indeksiem: apmācību, kas analizē tava datu sadalījumu, lai novietotu nlist nodalījumu centrus. Tam seko vektoru pievienošana un pēc tam nprobe regulēšana — slēdzis, kas nosaka, cik daudz nodalījumu tiks pētīti katrā vaicājumā. nprobe palielināšana uzlabo atgūšanas precizitāti un palēnina meklēšanu; šis ir parametrs, ko tu pielāgosi, mērot reprezentatīvā jautājumu kopā punktu, kurā rezultāti vairs neuzlabojas.

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)

Galvenās atziņas

  • FAISS ir standarts ātrai vektoru meklēšanai
  • IndexFlatL2 maziem korpusiem (līdz 100 tūkstošiem vektoru), precīza meklēšana
  • IndexIVFFlat lieliem korpusiem, aptuvena, bet ātra meklēšana
  • Normalizē vektorus un izmanto IndexFlatIP kosinusa līdzībai
  • Saglabā indeksu diskā ar faiss.write_index, lai izvairītos no atkārtotas veidošanas