faiss README

The project's README from github.com/facebookresearch/faiss. As one markdown file: README.md.

Faiss

Faiss is a library for efficient similarity search and clustering of dense vectors. It contains algorithms that search in sets of vectors of any size, up to ones that possibly do not fit in RAM. It also contains supporting code for evaluation and parameter tuning. Faiss is written in C++ with complete wrappers for Python/numpy. Some of the most useful algorithms are implemented on the GPU. It is developed primarily at Meta's Fundamental AI Research group.

News

See CHANGELOG.md for detailed information about latest features.

Introduction

Faiss contains several methods for similarity search. It assumes that the instances are represented as vectors and are identified by an integer, and that the vectors can be compared with L2 (Euclidean) distances or dot products. Vectors that are similar to a query vector are those that have the lowest L2 distance or the highest dot product with the query vector. It also supports cosine similarity, since this is a dot product on normalized vectors.

Some of the methods, like those based on binary vectors and compact quantization codes, solely use a compressed representation of the vectors and do not require to keep the original vectors. This generally comes at the cost of a less precise search but these methods can scale to billions of vectors in main memory on a single server. Other methods, like HNSW and NSG add an indexing structure on top of the raw vectors to make searching more efficient.

The GPU implementation can accept input from either CPU or GPU memory. On a server with GPUs, the GPU indexes can be used a drop-in replacement for the CPU indexes (e.g., replace IndexFlatL2 with GpuIndexFlatL2) and copies to/from GPU memory are handled automatically. Results will be faster however if both input and output remain resident on the GPU. Both single and multi-GPU usage is supported.

Installing

Faiss comes with precompiled libraries for Anaconda in Python, see faiss-cpu, faiss-gpu and faiss-gpu-cuvs. The library is mostly implemented in C++, the only dependency is a BLAS implementation. Optional GPU support is provided via CUDA or AMD ROCm, and the Python interface is also optional. The backend GPU implementations of NVIDIA cuVS can also be enabled optionally. It compiles with cmake. See INSTALL.md for details.

How Faiss works

Faiss is built around an index type that stores a set of vectors, and provides a function to search in them with L2 and/or dot product vector comparison. Some index types are simple baselines, such as exact search. Most of the available indexing structures correspond to various trade-offs with respect to

The optional GPU implementation provides what is likely (as of March 2017) the fastest exact and approximate (compressed-domain) nearest neighbor search implementation for high-dimensional vectors, fastest Lloyd's k-means, and fastest small k-selection algorithm known. The implementation is detailed here.

Full documentation of Faiss

The following are entry points for documentation:

Authors

The main authors of Faiss are:

Reference

References to cite when you use Faiss in a research paper:

@article{douze2024faiss,
      title={The Faiss library},
      author={Matthijs Douze and Alexandr Guzhva and Chengqi Deng and Jeff Johnson and Gergely Szilvasy and Pierre-Emmanuel Mazaré and Maria Lomeli and Lucas Hosseini and Hervé Jégou},
      year={2024},
      eprint={2401.08281},
      archivePrefix={arXiv},
      primaryClass={cs.LG}
}

For the GPU version of Faiss, please cite:

@article{johnson2019billion,
  title={Billion-scale similarity search with {GPUs}},
  author={Johnson, Jeff and Douze, Matthijs and J{\'e}gou, Herv{\'e}},
  journal={IEEE Transactions on Big Data},
  volume={7},
  number={3},
  pages={535--547},
  year={2019},
  publisher={IEEE}
}

Join the Faiss community

For public discussion of Faiss or for questions, visit https://github.com/facebookresearch/faiss/discussions.

We monitor the issues page of the repository. You can report bugs, ask questions, etc.

Faiss is MIT-licensed, refer to the LICENSE file in the top level directory.

Copyright © Meta Platforms, Inc.

faiss (facebookresearch/faiss)

Searching Database…

41.2K ·GitHub
Faiss
What is this?Faiss is a library for efficient similarity search and clustering of dense vectors, developed primarily at Meta's Fundamental AI Research group. It can search collections of vectors of any size, even ones that do not fit in RAM.
Is this an app I run, or code I build into my own project?It is a C++ library you link into your own code, with complete wrappers for Python/NumPy. There is no server or UI, and even the Python interface is optional.
How do I add it to my project?Precompiled conda packages exist for Python: faiss-cpu, faiss-gpu and faiss-gpu-cuvs. For C++ integration, compile it yourself with cmake; INSTALL.md covers the details.
What do I need installed for it to work?Only a BLAS implementation is required. GPU support is optional via CUDA or AMD ROCm, an NVIDIA cuVS backend can be enabled, and the Python interface is optional too.
Is the search exact or approximate?Both. Simple indexes do exact search, while structures like HNSW and NSG or compressed vector codes trade some precision for speed and memory — compressed ones can hold billions of vectors in a single server's RAM.
What trade-offs do I pick between when choosing an index type?Each index balances search time, search quality, memory per vector, training time, adding time, and whether external data is needed for unsupervised training. Simple exact-search baselines sit at one extreme, compressed indexes at the other.
What makes the GPU implementation special?Per the README, as of March 2017 it was likely the fastest exact and approximate (compressed-domain) nearest-neighbor search for high-dimensional vectors, plus the fastest known Lloyd's k-means and small k-selection algorithms. It is fastest when inputs and outputs stay in GPU memory.
Besides search, what else can Faiss do?Clustering of dense vectors is a first-class feature, and the library ships supporting code for evaluation and parameter tuning. The GPU side includes a notably fast implementation of Lloyd's k-means.
What are similar projects?qdrant, annoy, pgvector, weaviate, turbovec, sentrysearch, lancedb, DeepGEMM
Which topics is it in?nearest-neighbor-search, similarity-search, numpy, vector-search, vector-database, embeddings, high-performance, search, quantization, nvidia, cuda, c++
Creator
facebookresearch
Size
282.9 MB
Stars
41.2K
Updated
CommitOct 15Releasev1.15.1Sep 16
Age
9y
Commits · 90 Days