Премини към основното съдържание
Български— Изберете език
Меню

Векторно хранилище с FAISS

Урок 12 от 18 Обновен 2 ноември 2026 г. Програмист
На тази страница
  1. FAISS: Високопроизводително векторно търсене
  2. Създаване на първия Ви индекс
  3. Избор на правилния тип индекс
  4. Заявки към индекса
  5. Превключване към косинусно сходство
  6. Когато корпусът стане масивен
  7. Ключови изводи

FAISS: Високопроизводително векторно търсене

Изчислихте и запазихте своите вграждания (embeddings), но матрицата на NumPy не е търсачка: сравняването на заявка със 100 000 вектора чрез цикъл на Python би отнело няколко секунди на въпрос. FAISS (Facebook AI Similarity Search) решава точно този проблем. Тази библиотека с отворен код от Meta е проектирана за търсене на сходство в големи множества от вектори; тя е бърза, паметта ѝ се използва ефективно и работи еднакво добре както с няколкостотин, така и с милиони вектори. Инсталацията става с една команда. faiss-cpu е напълно достатъчен в огромното мнозинство случаи; faiss-gpu е оправдан само за обеми, при които изчисленията се превръщат в тясно място.

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

import faiss
import numpy as np

Създаване на първия Ви индекс

Най-простият индекс е IndexFlatL2, който извършва изчерпателно търсене, използвайки разстояние L2 (Евклидово). „Изчерпателно“ означава, че той действително сравнява заявката с всеки съхранен вектор: няма апроксимация, следователно няма пропуснати резултати. Инициализирате го с размерността на вектора – 1024 за mistral-embed, стойност, която четете директно от формата на матрицата, вместо да я задавате твърдо в кода. Преобразуването към float32 не е по желание: FAISS отхвърля float64, който NumPy генерира по подразбиране, и пропускането на тази детайлност е първата грешка, която всеки начинаещ допуска.

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

Избор на правилния тип индекс

FAISS не предлага един единствен индекс, а цяло семейство от такива, като изборът включва компромис между точност и скорост. Първите два, IndexFlatL2 и IndexFlatIP, са точни: те се различават само по използваната метрика – Евклидово разстояние за единия и скаларно произведение за другия. IndexIVFFlat променя логиката, като разделя пространството на клъстери и търси само в най-обещаващите от тях, което значително ускорява търсенето за сметка на лека загуба на пълнота (recall) – и изисква предварително обучение върху Вашите данни. Накрая, IndexHNSWFlat изгражда граф на съседите и се доказва като много бърз при заявки, като параметърът 32 тук задава броя на запазените съседи на възел.

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

Заявки към индекса

Търсенето протича в три стъпки. Първо, кодирайте въпроса на потребителя със същия модел, както и корпуса – заявка, кодирана от различен модел, би дала безсмислени разстояния. След това FAISS връща два паралелни масива: разстоянията и индексите на k най-близки съседи. Тези индекси са позиции във Вашия списък с чънкове: тук дисциплината от предишния урок дава резултат, тъй като подравняването между матрицата и метаданните е това, което Ви позволява да проследите текста обратно до неговия източник. Проверката if idx >= 0 покрива случая, когато индексът съдържа по-малко от k вектора, при което FAISS попълва липсващите места с -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]}...")

Превключване към косинусно сходство

FAISS не предлага изричен индекс за „косинус“, но алгебрата предоставя безплатен еквивалент: за вектори с норма 1, скаларното произведение е косинусът. Просто разделяте всеки вектор на неговата норма, след което използвате IndexFlatIP. Тази промяна е далеч от теоретична: разстоянието L2 е чувствително към дължината на вектора, така че много дълъг чънк може да се окаже изкуствено далеч от кратка заявка, дори темите им да съвпадат. Косинусът измерва само ориентацията, следователно смисъла, и това обикновено е това, което искате да сравнявате.

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)

Както при вгражданията, индексът се запазва на диска. faiss.write_index произвежда двоичен файл, който faiss.read_index зарежда както си е, включително вътрешните структури – което е от най-голямо значение за обучените индекси, където в противен случай реконструкцията би трябвало да се извърши отново.

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

Когато корпусът стане масивен

Започвайки от няколкостотин хиляди вектора, изчерпателното търсене става твърде бавно и индексът IVF (Inverted File) става необходим. Неговият жизнен цикъл включва стъпка, която плоските индекси нямат: обучение, което анализира разпределението на Вашите данни, за да постави центроидите на nlist партиции. След това идва добавянето на векторите и настройването на nprobe, регулаторът, който решава колко партиции ще бъдат изследвани на заявка. Увеличаването на nprobe подобрява пълнотата (recall) и забавя търсенето; това е параметърът, който ще коригирате, като измервате върху представителен набор от въпроси точката, в която резултатите спират да се подобряват.

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)

Ключови изводи

  • FAISS е стандартът за бързо векторно търсене
  • IndexFlatL2 за малки корпуси (под 100 000 вектора), точно търсене
  • IndexIVFFlat за големи корпуси, приблизително, но бързо търсене
  • Нормализирайте векторите и използвайте IndexFlatIP за косинусно сходство
  • Запазете индекса на диска с faiss.write_index, за да избегнете повторното му изграждане