Léim go dtí an príomhábhar
Gaeilge— Roghnaigh teanga
Roghchlár

Stóras Veicteoirí le FAISS

Ceacht 12 as 18 Nuashonraithe 2 Samhain 2026 Forbróir
Ar an leathanach seo
  1. FAISS: Cuardach Veicteoirí Ardfheidhmíochta
  2. Do Chéad Innéacs a Chruthú
  3. An Cineál Innéacs Ceart a Roghnú
  4. An tInnéacs a Fhiosrú
  5. Athrú go Cosine Similarity
  6. Nuair a Éiríonn an Corpus An-Mhór
  7. Príomhphointí

FAISS: Cuardach Veicteoirí Ardfheidhmíochta

Tá do chuid leabaithe ríofa agus sábháilte agat, ach ní innill chuardaigh iad maitrísí NumPy: thógfadh sé roinnt soicind in aghaidh na ceiste comparáid a dhéanamh idir ceist agus 100,000 veicteoir ag baint úsáide as lúb Python. Réitíonn FAISS (Facebook AI Similarity Search) an fhadhb seo go díreach. Is leabharlann foinse oscailte ó Meta é seo atá deartha do chuardach cosúlachta ar fud tacair mhóra veicteoirí; tá sé tapa, éifeachtach ó thaobh cuimhne de, agus oibríonn sé chomh maith le cúpla céad veicteoir agus a oibríonn sé le milliúin. Ní gá ach ordú amháin chun é a shuiteáil. Is leor faiss-cpu sa chuid is mó de chásanna; ní bhíonn faiss-gpu údaraithe ach do thoillte ina mbíonn an ríomhaireacht ina bhac.

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

import faiss
import numpy as np

Do Chéad Innéacs a Chruthú

Is é IndexFlatL2 an t-innéacs is simplí, a dhéanann cuardach íomlán ag baint úsáide as fad L2 (Eoiclídeach). Ciallaíonn “íomlán” go ndéanann sé comparáid idir an cheist agus gach veicteoir atá stóráilte i ndáiríre: gan aon neasú, mar sin gan aon torthaí a chailleadh. Tionscnaimh tú é le toise an veicteora—1024 do mistral-embed, luach a léann tú go díreach ó chruth na maitríse seachas é a chódú go crua. Níl tiontú go float32 roghnach: diúltaíonn FAISS an float64 a tháirgeann NumPy go réamhshocraithe, agus is é an mionsonra seo a dhéanamh dearmad de an chéad earráid a thagann ar gach túsaitheoir.

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

An Cineál Innéacs Ceart a Roghnú

Ní thairgeann FAISS innéacs amháin ach teaghlach acu, agus baineann an rogha le comhréir idir cruinneas agus luas. Is cruinn iad an dá cheann is túisce, IndexFlatL2 agus IndexFlatIP: níl difríocht eatarthu ach sa mhéadracht a úsáidtear, fad Eoiclídeach don cheann amháin, toradh poncúil don cheann eile. Athraíonn IndexIVFFlat an loighic trí spás a dheighilt ina chnuasaigh agus ag cuardach ach na cinn is geallta, rud a luathaíonn an cuardach go mór ar chostas caillteanas beag ar aisghabháil—agus éilíonn sé oiliúint roimh ré ar do chuid sonraí. Ar deireadh, tógann IndexHNSWFlat graf comharsana agus cruthaíonn sé an-tapa le linn ceisteanna, leis an bparaiméadar 32 ag socrú líon na gcomharsan a choinnítear in aghaidh an nóid anseo.

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

An tInnéacs a Fhiosrú

Tarlaíonn an cuardach i dtrí chéim. Ar dtús, ionchódaigh ceist an úsáideora leis an mhúnla céanna leis an gcorpas—thabharfadh ceist a ionchódaítear le múnla difriúil faid gan bhrí. Ansin, filleann FAISS dhá eagair chomhthreomhara: na faid agus innéacsanna na k gcomharsan is gaire. Is suíomhanna i do liosta smután iad na hinnéacsanna seo: seo áit a mbíonn luach sa saothair ón gcacht roimhe seo, ós rud é gurb é an ailíniú idir an mhaitrís agus na meiteashonraí a ligeann duit teacht ar ais ar an téacs agus ar a fhoinse. Clúdaíonn an tástáil if idx >= 0 an cás ina bhfuil níos lú ná k veicteoir san innéacs, agus sa chás sin, líonann FAISS na spotaí atá ar iarraidh le -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]}...")

Athrú go Cosine Similarity

Ní thairgeann FAISS innéacs “cosine” sainráite, ach soláthraíonn ailgéabar comhionannas saor in aisce: do veicteoirí le norm 1, is é an toradh poncúil ná an cosine. Roinneann tú gach veicteoir lena norm, agus ansin úsáideann tú IndexFlatIP. Níl an t-athrú seo teoiriciúil ar aon nós: tá fad L2 íogair do fhad an veicteora, mar sin is féidir le smután an-fhada teacht chun bheith go saorga i bhfad ó cheist ghairid fiú má mheaitseálann a n-ábhair. Ní thomhaiseann Cosine ach treoshuíomh, agus mar sin brí, agus sin é go hiondúil an rud atá uait a chur i gcomparáid.

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)

Mar a tharlaíonn le leabaithe, fanann an t-innéacs ar an diosca. Cruthaíonn faiss.write_index comhad dénártha a athlódálann faiss.read_index mar atá sé, lena n-áirítear struchtúir inmheánacha—rud atá tábhachtach go háirithe d’innéacsanna oilte, áit a mbeadh gá arís an t-atógáil a dhéanamh murach sin.

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

Nuair a Éiríonn an Corpus An-Mhór

Ag tosú ag cúpla céad míle veicteoir, éiríonn an cuardach íomlán ró-mhall agus éiríonn an t-innéacs IVF (Inverted File) riachtanach. Áirítear lena shaolré céim nach bhfuil ag innéacsanna cothroma: oiliúint, a dhéanann anailís ar dháileadh do chuid sonraí chun lárphointí deighilte nlist a chur. Ansin tagann cur leis na veicteoirí, agus ansin tiúniú ar nprobe, an cnaipe a shocraíonn cé mhéad deighilt a fhiosrófar in aghaidh na ceiste. Feabhsaíonn méadú ar nprobe an aisghabháil agus moillaíonn sé an cuardach; is é seo an paraiméadar a choigeartóidh tú trí thomhas a dhéanamh, ar thacar ionadaíoch ceisteanna, ar an bpointe ina stopann na torthaí ag feabhsú.

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)

Príomhphointí

  • Is é FAISS an caighdeán do chuardach veicteoirí tapa
  • IndexFlatL2 do chorpuis bheaga (faoi 100k veicteoir), cuardach cruinn
  • IndexIVFFlat do chorpuis mhóra, cuardach neasúil ach tapa
  • Normalaigh veicteoirí agus úsáid IndexFlatIP do chosine similarity
  • Sábháil an t-innéacs ar an diosca le faiss.write_index chun aththógáil a sheachaint