FAISS: быстрый поиск векторного сходства

Как применить

FAISS идеально подходит для быстрого поиска сходства в крупных наборах векторов, содержащих миллионы или миллиарды векторов.

Он подходит в случаях, когда требуется ускорение вычислений на GPU.

Он обеспечивает чистый поиск векторного сходства без фильтрации по метаданным.

Он предназначен для задач, где критически важны высокая пропускная способность и низкая задержка.

Он также поддерживает автономную или пакетную обработку эмбеддингов.

Если вам нужна фильтрация по метаданным, используйте Chroma или Pinecone вместо него.

Если вам нужны полноценные функции базы данных, используйте Weaviate вместо него.

Annoy — более простая альтернатива с меньшим количеством функций.

Выберите правильный тип индекса: Flat для менее чем 10 тысяч векторов, IVF для диапазона 10 тысяч–1 миллион, а HNSW — для достижения высокого качества.

Для крупных наборов данных используйте GPU — это ускорит работу в 10–100 раз.

Следите за объёмом памяти и используйте PQ для крупных наборов данных.

Типы индексов имеют разные характеристики: Flat создаётся быстро, но медленно выполняет поиск при высоком потреблении памяти и точности 100%; IVF требует среднего времени создания, обеспечивает быстрый поиск, среднее потребление памяти и точность 95–99%; HNSW создаётся медленно, но обеспечивает самый быстрый поиск при высоком потреблении памяти и точности 99%; PQ требует среднего времени создания, обеспечивает быстрый поиск, низкое потребление памяти и точность 90–95%.

Установите FAISS с пакетом только для CPU или с поддержкой GPU.

# CPU only
pip install faiss-cpu

# GPU support
pip install faiss-gpu

Запустите пример базового использования, чтобы создать индекс, добавить векторы и найти ближайшие аналоги.

import faiss
import numpy as np

# Create sample data (1000 vectors, 128 dimensions)
d = 128
nb = 1000
vectors = np.random.random((nb, d)).astype('float32')

# Create index
index = faiss.IndexFlatL2(d)  # L2 distance
index.add(vectors)             # Add vectors

# Search
k = 5  # Find 5 nearest neighbors
query = np.random.random((1, d)).astype('float32')
distances, indices = index.search(query, k)

print(f"Nearest neighbors: {indices}")
print(f"Distances: {distances}")

Для точного поиска используйте плоский индекс с расстоянием L2 или скалярным произведением; это самый медленный, но самый точный вариант.

# L2 (Euclidean) distance
index = faiss.IndexFlatL2(d)

# Inner product (cosine similarity if normalized)
index = faiss.IndexFlatIP(d)

# Slowest, most accurate

Для быстрого приближённого поиска используйте инвертированный индекс IVF: создайте квантизатор, постройте индекс с кластерами, обучите его на данных, добавьте векторы и задайте количество кластеров для поиска.

# Create quantizer
quantizer = faiss.IndexFlatL2(d)

# IVF index with 100 clusters
nlist = 100
index = faiss.IndexIVFFlat(quantizer, d, nlist)

# Train on data
index.train(vectors)

# Add vectors
index.add(vectors)

# Search (nprobe = clusters to search)
index.nprobe = 10
distances, indices = index.search(query, k)

Для оптимального соотношения качества и скорости используйте индекс HNSW; он не требует обучения, поэтому можно сразу добавлять векторы и выполнять поиск.

# HNSW index
M = 32  # Number of connections per layer
index = faiss.IndexHNSWFlat(d, M)

# No training needed
index.add(vectors)

# Search
distances, indices = index.search(query, k)

Для экономии памяти используйте квантизацию произведения; это уменьшит объём памяти в 16–32 раза; процесс обучения и добавления векторов аналогичен другим индексам.

# PQ reduces memory by 16-32×
m = 8   # Number of subquantizers
nbits = 8
index = faiss.IndexPQ(d, m, nbits)

# Train and add
index.train(vectors)
index.add(vectors)

Сохраните обученный индекс в файл и загрузите его обратно для продолжения поиска.

# Save index
faiss.write_index(index, "large.index")

# Load index
index = faiss.read_index("large.index")

# Continue using
distances, indices = index.search(query, k)

Включите ускорение на GPU, перенеся индекс с CPU на один GPU или на все GPU — это ускорит работу в 10–100 раз по сравнению с CPU.

# Single GPU
res = faiss.StandardGpuResources()
index_cpu = faiss.IndexFlatL2(d)
index_gpu = faiss.index_cpu_to_gpu(res, 0, index_cpu)  # GPU 0

# Multi-GPU
index_gpu = faiss.index_cpu_to_all_gpus(index_cpu)

# 10-100× faster than CPU

Интегрируйте FAISS с LangChain для создания векторного хранилища из документов, сохранения его локально, загрузки обратно и выполнения поиска сходства.

from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings

# Create FAISS vector store
vectorstore = FAISS.from_documents(docs, OpenAIEmbeddings())

# Save
vectorstore.save_local("faiss_index")

# Load
vectorstore = FAISS.load_local(
    "faiss_index",
    OpenAIEmbeddings(),
    allow_dangerous_deserialization=True
)

# Search
results = vectorstore.similarity_search("query", k=5)

Интегрируйте FAISS с LlamaIndex, создав индекс FAISS и обернув его в FaissVectorStore.

from llama_index.vector_stores.faiss import FaissVectorStore
import faiss

# Create FAISS index
d = 1536
faiss_index = faiss.IndexFlatL2(d)

vector_store = FaissVectorStore(faiss_index=faiss_index)

Для косинусного сходства используйте IndexFlatIP с нормализованными векторами.

Сохраняйте обученные индексы, так как процесс обучения затратен.

Настройте параметры nprobe или ef_search, чтобы сбалансировать скорость и точность.

Выполняйте запросы пакетами для лучшего использования GPU.

FAISS распространяется по лицензии MIT.