Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Vektoritietokanta FAISSilla

Oppitunti 12 / 18 Päivitetty 2. marraskuuta 2026 Kehittäjä
Tällä sivulla
  1. FAISS: Suorituskykyinen vektorihaku
  2. Luo ensimmäinen indeksisi
  3. Oikean indeksityypin valinta
  4. Indeksin kysely
  5. Siirtyminen kosinussamankaltaisuuteen
  6. Kun korpus kasvaa valtavaksi
  7. Keskeiset asiat

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
  • IndexFlatL2 pieniin korpuihin (alle 100 000 vektoria), tarkka haku
  • IndexIVFFlat suuriin korpuihin, likimääräinen mutta nopea haku
  • Normalisoi vektorit ja käytä IndexFlatIP:tä kosinussamankaltaisuuteen
  • Tallenna indeksi levylle komennolla faiss.write_index välttääksesi uudelleenrakennuksen