Using Faiss for Efficient Vector Similarity Search: Installation, Index Construction, and Performance Optimization

Faiss, a Facebook AI library, simplifies similarity search by allowing you to build indexes over vector collections and retrieve nearest neighbors efficiently. It supports parameter tuning to balance speed and recall, making it essential to understand its underlying principles for business‑specific adjustments.

Preparing Data – The article downloads multiple semantic similarity datasets, merges sentence pairs, removes duplicates, and encodes each sentence into a dense 768‑dimensional embedding using the sentence-transformers library.

import requests
from io import StringIO
import pandas as pd
from sentence_transformers import SentenceTransformer

res = requests.get('https://raw.githubusercontent.com/brmson/dataset-sts/master/data/sts/sick2014/SICK_train.txt')
data = pd.read_csv(StringIO(res.text), sep='\t')
# ... additional dataset loading and merging ...
model = SentenceTransformer('bert-base-nli-mean-tokens')
sentence_embeddings = model.encode(sentences)

Installing Faiss – On Linux with CUDA, install the GPU‑accelerated version via conda install -c pytorch faiss-gpu ; on other OSes use the CPU version.

IndexFlatL2 – A simple, exact L2 distance index that requires no training. After creating the index with the same dimensionality as the embeddings, vectors are added and queried:

import faiss
d = sentence_embeddings.shape[1]
index = faiss.IndexFlatL2(d)
index.add(sentence_embeddings)

k = 4
xq = model.encode(["Someone sprints with a football"])
D, I = index.search(xq, k)

The search returns the IDs of the most similar sentences, demonstrating high semantic relevance.

Speed Considerations – IndexFlatL2 performs exhaustive distance calculations, which becomes costly for large datasets (e.g., 1.45 k vectors require 14.5 k distance computations per query).

Partitioned Index (IndexIVFFlat) – By dividing the vector space into nlist Voronoi cells, Faiss first identifies the cell containing the query vector and then performs a local exhaustive search, drastically reducing query time after training:

nlist = 50
quantizer = faiss.IndexFlatL2(d)
index = faiss.IndexIVFFlat(quantizer, d, nlist)
index.train(sentence_embeddings)
index.add(sentence_embeddings)

index.nprobe = 10  # number of cells to probe
D, I = index.search(xq, k)

Increasing nprobe improves recall at the cost of additional latency.

Product Quantization (IndexIVFPQ) – For massive datasets, Faiss can compress vectors using product quantization, reducing storage and accelerating distance calculations. The process involves splitting vectors into sub‑vectors, clustering each sub‑space, and representing sub‑vectors by centroid IDs.

m = 8  # sub‑vector count
bits = 8
quantizer = faiss.IndexFlatL2(d)
index = faiss.IndexIVFPQ(quantizer, d, nlist, m, bits)
index.train(sentence_embeddings)
index.add(sentence_embeddings)
index.nprobe = 10
D, I = index.search(xq, k)

Although PQ introduces a slight accuracy loss, it yields significant speed gains as the dataset scales.

Conclusion – The article provides a comprehensive overview of building efficient Faiss indexes, explains how to choose parameters for different business scenarios, and demonstrates that Faiss offers a simple yet powerful solution for high‑performance vector similarity search.