Vector Store su FAISS
Šiame puslapyje
FAISS: didelio našumo vektorių paieška
Apskaičiavai ir išsaugojai savo įterpimus (embeddings), tačiau „NumPy“ matrica nėra paieškos variklis: lyginant užklausą su 100 000 vektorių naudojant „Python“ ciklą, vienam klausimui atsakyti prireiktų kelių sekundžių. FAISS („Facebook AI Similarity Search“) būtent šią problemą ir sprendžia. Ši atviro kodo „Meta“ biblioteka sukurta panašumo paieškai didelėse vektorių aibėse; ji veikia greitai, efektyviai naudoja atmintį ir vienodai gerai tinka tiek keliems šimtams, tiek milijonams vektorių. Diegimas trunka vieną komandą. Daugeliu atvejų pakanka faiss-cpu; faiss-gpu yra pateisinamas tik tais atvejais, kai skaičiavimai tampa „butelio kakleliu“ dėl didelių duomenų apimčių.
# pip install faiss-cpu
# or faiss-gpu for GPU acceleration
import faiss
import numpy as np
Sukurk savo pirmąjį indeksą
Paprastiausias indeksas yra IndexFlatL2, kuris atlieka išsamią paiešką naudodamas L2 atstumą (Euklido). „Išsami“ reiškia, kad užklausa faktiškai lyginama su kiekvienu saugomu vektoriumi: jokių apytikslių skaičiavimų, todėl jokių praleistų rezultatų. Jį inicializuoji nurodydamas vektorių dimensiją – 1024 modeliui mistral-embed, reikšmę, kurią nuskaityti tiesiai iš matricos formos, o ne įrašyti rankiniu būdu. Konvertavimas į float32 nėra pasirenkamas: FAISS atmeta float64, kurį „NumPy“ generuoja pagal nutylėjimą, ir pamiršus šią detalę kyla pirmoji klaida, su kuria susiduria kiekvienas pradedantysis.
# 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}")
Tinkamo indekso tipo pasirinkimas
FAISS siūlo ne vieną indeksą, o jų šeimą, ir pasirinkimas reiškia kompromisą tarp tikslumo ir greičio. Pirmieji du, IndexFlatL2 ir IndexFlatIP, yra tikslūs: jie skiriasi tik naudojama metrika – vienas naudoja Euklido atstumą, kitas – skaliarinę sandaugą. IndexIVFFlat pakeičia logiką padalijant erdvę į klasterius ir ieškant tik perspektyviausiuose iš jų, kas žymiai pagreitina paiešką, tačiau šiek tiek sumažina išsamumą (recall) – be to, tam reikia išankstinio mokymo su tavo duomenimis. Galiausiai, IndexHNSWFlat sukuria kaimynų grafą ir pasirodo esąs labai greitas vykdant užklausas; čia parametras 32 nustato kiekvienam mazgui paliekamų kaimynų skaičių.
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
Užklausų teikimas indeksui
Paieška vyksta trimis žingsniais. Pirmiausia užkoduoji naudotojo klausimą naudodamas tą patį modelį, kuris buvo naudotas korpusui – kitu modeliu užkoduota užklausa duotų beprasmius atstumus. Tada FAISS grąžina du lygiagrečius masyvus: atstumus ir k artimiausių kaimynų indeksus. Šie indeksai yra pozicijos tavo fragmentų sąraše: būtent čia pravartu ankstesnėje pamokoje įgyta disciplina, nes būtent matricos ir metaduomenų suderinimas leidžia atsekti tekstą ir jo šaltinį. Sąlyga if idx >= 0 apima atvejį, kai indekse yra mažiau nei k vektorių; tokiu atveju FAISS trūkstamas vietas užpildo reikšme -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]}...")
Perėjimas prie kosinusinio panašumo
FAISS neturi aiškaus „kosinusinio“ indekso, tačiau algebra suteikia nemokamą ekvivalentą: vienetinio ilgio vektoriams skaliarinė sandauga yra kosinusas. Tereikia kiekvieną vektorių padalinti iš jo normos, o tada naudoti IndexFlatIP. Šis pakeitimas nėra tik teorinis: L2 atstumas jautrus vektoriaus ilgiui, todėl labai ilgas fragmentas gali dirbtinai atsidurti toli nuo trumpos užklausos, net jei jų temos sutampa. Kosinusas matuoja tik kryptį, taigi ir prasmę, o būtent tai paprastai ir norima lyginti.
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)
Kaip ir su įterpimais, indeksas išsaugomas diske. faiss.write_index sukuria dvejetainį failą, kurį faiss.read_index įkelia tokį, koks yra, įskaitant vidines struktūras – tai ypač svarbu mokytiems indeksams, kuriuos kitaip tektų kurti iš naujo.
# 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")
Kai korpusas tampa milžiniškas
Pradedant nuo kelių šimtų tūkstančių vektorių, išsami paieška tampa per lėta ir tampa būtinas IVF (atvirkštinio failo) indeksas. Jo gyvavimo cikle yra žingsnis, kurio neturi plokštieji indeksai: mokymas, kurio metu analizuojamas duomenų pasiskirstymas, kad būtų išdėstyti nlist skirsnių centroidai. Toliau pridedami vektoriai ir derinamas nprobe – parametras, nulemiantis, kiek skirsnių bus nagrinėjama vykdant kiekvieną užklausą. Didinant nprobe gerėja išsamumas, bet lėtėja paieška; tai yra parametras, kurį derinsi matuodamas reprezentatyvioje klausimų aibėje tašką, kuriame rezultatai nustoja gerėti.
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)
Svarbiausi punktai
- FAISS yra standartinis įrankis greitai vektorių paieškai
IndexFlatL2skirtas mažiems korpusams (iki 100 tūkst. vektorių), tiksli paieškaIndexIVFFlatskirtas dideliems korpusams, apytikslė, bet greita paieška- Normalizuok vektorius ir naudok
IndexFlatIPkosinusiniam panašumui - Išsaugok indeksą diske naudodamas
faiss.write_index, kad išvengtum jo kūrimo iš naujo