Векторно хранилище с FAISS
На тази страница
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, за да избегнете повторното му изграждане