Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Maħżen tal-Vetturi ma' FAISS

Lezzjoni 12 / 18 Aġġornat 2 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. FAISS: Tiftix ta’ Vetturi b’Prestazzjoni Għolja
  2. Oħloq l-Ewwel Indiċi Tiegħek
  3. Għażla tat-Tip ta’ Indiċi t-Tajjeb
  4. Interrogazzjoni tal-Indiċi
  5. Bidla għas-Similarità tal-Kosinu
  6. Meta l-Corpus Isir Massiv
  7. Punti Ewlenin

FAISS: Tiftix ta’ Vetturi b’Prestazzjoni Għolja

Ikkalkulajt u ħżajt l-embeddings tiegħek, iżda matriċi NumPy mhix magna tat-tiftix: tqabbil mistoqsija ma’ 100,000 vettur bl-użu ta’ loop f’Python jieħu diversi sekondi għal kull mistoqsija. FAISS (Facebook AI Similarity Search) isolvi eżattament din il-problema. Din il-librerija open-source ta’ Meta hija ddisinjata għat-tiftix tas-similarità fuq settijiet kbar ta’ vetturi; hija mgħaġġla, effiċjenti fil-memorja, u taħdem tajjeb kemm jekk ikollok ftit mijiet ta’ vetturi kif ukoll miljuni. L-installazzjoni tieħu kmand wieħed biss. faiss-cpu huwa biżżejjed fil-biċċa l-kbira tal-każijiet; faiss-gpu huwa ġustifikat biss għal volumi fejn il-kompjazzjoni ssir il-kolli tal-flixkun.

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

import faiss
import numpy as np

Oħloq l-Ewwel Indiċi Tiegħek

L-aktar indiċi sempliċi huwa IndexFlatL2, li jwettaq tiftix eżawrjenti bl-użu tad-distanza L2 (Ewklidew). “Eżawrjenti” tfisser li attwalment iqabbel il-mistoqsija ma’ kull vettur maħżun: l-ebda approssimazzjoni, allura l-ebda riżultat mitluf. Inti tinizjalizzah bid-dimensjoni tal-vettur—1024 għal mistral-embed, valur li taqra direttament mill-forma tal-matriċi minflok ma tiktbu b’mod riġidu fil-kodiċi. Il-konverżjoni għal float32 mhix għażla: FAISS jiċħad il-float64 li NumPy jipproduċi b’mod default, u li tinsa dan id-dettall huwa l-ewwel żball li jiltaqa’ miegħu kull bidu.

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

Għażla tat-Tip ta’ Indiċi t-Tajjeb

FAISS ma joffrix indiċi wieħed biss iżda familja sħiħa minnhom, u l-għażla tinvolvi kompromess bejn il-preċiżjoni u l-veloċità. L-ewwel tnejn, IndexFlatL2 u IndexFlatIP, huma eżatti: huma jvarjaw biss fil-metrika użata, id-distanza Ewklidew għal wieħed, il-prodott dot (dot product) għall-ieħor. IndexIVFFlat ibiddel il-loġika billi jaqsam l-ispazju f’clusters u jfittex biss dawk l-aktar promettenti, li jħaffef b’mod sinifikanti t-tiftix bl-ispiża ta’ telfa ħafifa fir-riċall (recall)—u jeħtieġ taħriġ minn qabel fuq id-data tiegħek. Fl-aħħar nett, IndexHNSWFlat jibni graf tan-ġirien u juri ruħu mgħaġġel ħafna waqt il-mistoqsijiet, bil-parametru 32 li jistabbilixxi n-numru ta’ ġirien miżmuma għal kull nodu hawnhekk.

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

Interrogazzjoni tal-Indiċi

It-tiftix iseħħ f’tliet passi. L-ewwel, ikkodifika l-mistoqsija tal-utent bl-istess mudell bħall-corpus—mistoqsija kkodifikata minn mudell differenti tagħti distanzi bla sens. FAISS imbagħad jirritorna żewġ arrays paralleli: id-distanzi u l-indiċijiet tal-k l-aktar ġirien qrib. Dawn l-indiċijiet huma pożizzjonijiet fil-lista tal-chunks tiegħek: hawnhekk fejn tidħol id-dixxiplina mil-lezzjoni ta’ qabel, peress li l-allinjament bejn il-matriċi u l-metadata huwa dak li jippermettilek tirritorna għat-test u s-sors tiegħu. It-test if idx >= 0 ikopri l-każ fejn l-indiċi fih inqas minn k vetturi, f’liema każ FAISS jimla l-postijiet nieqsa b’-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]}...")

Bidla għas-Similarità tal-Kosinu

FAISS ma joffrix indiċi “kosinu” espliċitu, iżda l-alġebra tipprovdi ekwivalenti bla ħlas: għal vetturi b’norma 1, il-prodott dot huwa l-kosinu. Inti sempliċiment taqsam kull vettur bin-norma tiegħu, imbagħad tuża IndexFlatIP. Din il-bidla hija ‘l bogħod milli tkun teoretika: id-distanza L2 hija sensittiva għat-tul tal-vettur, allura chunk twil ħafna jista’ jispiċċa artifiċjalment ‘il bogħod minn mistoqsija qasira anke jekk is-suġġetti tagħhom jaqblu. Il-kosinu jkejjel biss l-orjentazzjoni, għalhekk it-tifsira, u dik ġeneralment hija dak li trid tqabbel.

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)

Bħall-embeddings, l-indiċi jippersisti fuq id-diska. faiss.write_index jipproduċi fajl binarju li faiss.read_index jerġa’ jtellgħu eżatt kif inhu, inklużi l-istrutturi interni—li huwa l-aktar importanti għall-indiċijiet imħarrġa, fejn ir-rikostruzzjoni inkella tkun teħtieġ li ssir mill-ġdid.

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

Meta l-Corpus Isir Massiv

Minn diversi mijiet ta’ eluf ta’ vetturi ‘l fuq, it-tiftix eżawrjenti jsir bil-mod wisq u l-indiċi IVF (Inverted File) isir meħtieġ. Iċ-ċiklu tal-ħajja tiegħu jinkludi pass li l-indiċijiet ċatti m’għandhomx: it-taħriġ, li janalizza d-distribuzzjoni tad-data tiegħek biex ipoġġi ċ-ċentroidi tal-partizzjoni nlist. Imbagħad jiġi ż-żieda tal-vetturi, u mbagħad l-aġġustament ta’ nprobe, il-kontroll li jiddeċiedi kemm-il partizzjoni se tiġi esplorata għal kull mistoqsija. Iż-żieda ta’ nprobe ittejjeb ir-riċall u tbaxxi l-veloċità tat-tiftix; dan huwa l-parametru li se taġġusta billi tkejjel, fuq sett rappreżentattiv ta’ mistoqsijiet, il-punt fejn ir-riżultati jieqfu jitjiebu.

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)

Punti Ewlenin

  • FAISS huwa l-istandard għat-tiftix mgħaġġel tal-vetturi
  • IndexFlatL2 għal corpora żgħar (inqas minn 100K vettur), tiftix eżatt
  • IndexIVFFlat għal corpora kbar, tiftix approssimattiv iżda mgħaġġel
  • Normalizza l-vetturi u uża IndexFlatIP għas-similarità tal-kosinu
  • Ħażen l-indiċi fuq id-diska b’faiss.write_index biex tevita li terġa’ tibnih