Vektoritietokanta FAISSilla
Tällä sivulla
FAISS: Suorituskykyinen vektorihaku
Olet laskenut ja tallentanut upotuksesi, mutta NumPy-matriisi ei ole hakukone: kyselyn vertaaminen 100 000 vektoriin Python-silmukalla veisi useita sekunteja per kysymys. FAISS (Facebook AI Similarity Search) ratkaisee juuri tämän ongelman. Tämä Metan avoimen lähdekoodin kirjasto on suunniteltu samankaltaisuushakuun suurista vektorijoukoista; se on nopea, muistitehokas ja toimii yhtä hyvin muutaman sadan vektorin kuin miljoonienkin kanssa. Asennus vaatii vain yhden komennon. faiss-cpu riittää valtaosassa tapauksia; faiss-gpu on perusteltu vain sellaisissa määrissä, joissa laskenta muodostuu pullonkaulaksi.
# pip install faiss-cpu
# or faiss-gpu for GPU acceleration
import faiss
import numpy as np
Luo ensimmäinen indeksisi
Yksinkertaisin indeksi on IndexFlatL2, joka suorittaa tyhjentävän haun käyttäen L2-etäisyyttä (Eukleideinen). “Tyhjentävä” tarkoittaa, että se vertaa kyselyä todellisuudessa jokaiseen tallennettuun vektoriin: ei approksimaatiota, joten ei myöskään puuttuvia tuloksia. Alustat sen vektorin ulottuvuudella – 1024 mallille mistral-embed, arvon, jonka luet suoraan matriisin muodosta kovakoodauksen sijaan. Muunnos muotoon float32 ei ole valinnainen: FAISS hylkää oletuksena tuottamansa float64:n, ja tämän yksityiskohdan unohtaminen on ensimmäinen virhe, jonka jokainen aloittelija kohtaa.
# 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}")
Oikean indeksityypin valinta
FAISS ei tarjoa yhtä ainoaa indeksiä, vaan koko perheen niitä, ja valintaan liittyy kompromissi tarkkuuden ja nopeuden välillä. Kaksi ensimmäistä, IndexFlatL2 ja IndexFlatIP, ovat tarkkoja: ne eroavat toisistaan vain käytetyssä metriikassa, toisessa Eukleideinen etäisyys ja toisessa pistetulo. IndexIVFFlat muuttaa logiikkaa jakamalla avaruuden klustereihin ja hakemalla vain lupaavimmista, mikä nopeuttaa hakua merkittävästi pienen tarkkuuden menetyksen hinnalla – ja vaatii ennakkokoulutusta datallasi. Lopuksi IndexHNSWFlat rakentaa naapurigrafin ja osoittautuu erittäin nopeaksi kyselyissä, jossa parametri 32 määrittää tässä solmua kohden säilytettävien naapureiden määrän.
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
Indeksin kysely
Haku tapahtuu kolmessa vaiheessa. Ensin koodaa käyttäjän kysymys samalla mallilla kuin korpus – eri mallilla koodattu kysely tuottaisi merkityksettömiä etäisyyksiä. FAISS palauttaa sitten kaksi rinnakkaista taulukkoa: etäisyydet ja k lähimmän naapurin indeksit. Nämä indeksit ovat positioita chunkkien listassasi: tässä edellisen tunnin kurinalaisuus palkitaan, sillä matriisin ja metadatan välinen kohdistus on se, mikä mahdollistaa tekstin ja sen lähteen jäljittämisen takaisin. Ehto if idx >= 0 kattaa tapauksen, jossa indeksissä on vähemmän kuin k vektoria, jolloin FAISS täyttää puuttuvat kohdat arvolla -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]}...")
Siirtyminen kosinussamankaltaisuuteen
FAISS ei tarjoa eksplisiittistä “kosini”-indeksiä, mutta algebra tarjoaa ilmaisen vastineen: vektoreille, joiden normi on 1, pistetulo on kosini. Jaat yksinkertaisesti jokaisen vektorin sen normilla ja käytät IndexFlatIP:tä. Tämä muutos on kaikkea muuta kuin teoreettinen: L2-etäisyys on herkkä vektorin pituudelle, joten hyvin pitkä chunk voi päätyä keinotekoisen kauaksi lyhyestä kyselystä, vaikka niiden aiheet täsmäisivät. Kosini mittaa vain suuntaa, siis merkitystä, ja sitä haluat yleensä verrata.
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)
Kuten upotustenkin kohdalla, indeksi persistoituu levylle. faiss.write_index tuottaa binääritiedoston, jonka faiss.read_index lataa sellaisenaan, sisäiset rakenteet mukaan lukien – mikä on tärkeintä koulutetuille indekseille, joissa uudelleenrakennus muuten pitäisi tehdä uudelleen.
# 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")
Kun korpus kasvaa valtavaksi
Useiden satojen tuhansien vektorien kohdalla tyhjentävä haku muuttuu liian hitaaksi ja IVF (Inverted File) -indeksi välttämättömäksi. Sen elinkaari sisältää vaiheen, jota tasaisilla indekseillä ei ole: koulutuksen, joka analysoi datajakaumaasi sijoittaakseen nlist osituksen keskipisteet. Seuraavaksi tulevat vektorien lisääminen ja sitten nprobe:n säätäminen, vipu, joka päättää kuinka monta ositusta kyselyä kohden tutkitaan. nprobe:n kasvattaminen parantaa recallia ja hidastaa hakua; tämä on parametri, jota säädät mittaamalla edustavalla kysymysjoukolla sen pisteen, jossa tulokset lakkaavat parantumasta.
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)
Keskeiset asiat
- FAISS on standardi nopeaan vektorihakuun
IndexFlatL2pieniin korpuihin (alle 100 000 vektoria), tarkka hakuIndexIVFFlatsuuriin korpuihin, likimääräinen mutta nopea haku- Normalisoi vektorit ja käytä
IndexFlatIP:tä kosinussamankaltaisuuteen - Tallenna indeksi levylle komennolla
faiss.write_indexvälttääksesi uudelleenrakennuksen