Source: Unite.AI
Meta’s Faiss maintainers released version 1.16.0 on November 10, 2026, packaging FAIR at Meta’s e-means clustering algorithm with CPU, GPU and distributed implementations. The researchers report beating Lloyd k-means’ loss after 25 epochs in 1.4 to 2.6 epochs, with 10–45× GPU wall-clock speedups against the compared implementations.
The software release follows the research preprint’s arXiv submission on November 6, 2026, rather than marking the algorithm’s first public disclosure. The work comes from researchers at FAIR at Meta and École Nationale des Ponts et Chaussées.
Version 1.16.0 adds reference e-means implementations, distributed and centroid-sharded training, Triton and CuTe assignment backends, reduced-precision assignment and benchmarks for reproducing the research results. It also includes DINO demonstrations that keep data resident or stream it from SSDs.
How E-Means Updates Centroids
K-means seeks centroids that minimize the mean squared distance between vectors and their nearest centroid, supporting retrieval, quantization and data curation. Lloyd’s algorithm assigns every point to its nearest centroid and rebuilds each cluster’s sum and count from the full dataset. e-means instead updates exponentially decayed sums and counts from mini-batches, so older assignments gradually lose influence; each centroid remains the ratio of its running vector sum to its running count. Using the entire dataset as one batch with a step of 1 reproduces one Lloyd iteration.
Two fitted scaling laws derive batch size and initial step size from dataset size, cluster count and epoch budget, removing the separate hyperparameter sweep required by earlier mini-batch approaches. A cosine schedule reduces the step to one-tenth of its starting value. The released class defaults to five training passes and accepts fractional passes.
The authors fitted the laws using 75,000 optimization runs on DEEP configurations. They report median held-out-dataset regret, meaning the excess error relative to the best grid setting, of 0.07% for the step law and 0.19% for the default batch law. The recipe also revives underused clusters by splitting a donor cluster, then finishes with each cluster’s exact mean over last-epoch assignments. A separate slow-moving-average finalization instead targets out-of-sample error.
Benchmarks Extend to Ten Billion Vectors
The full paper describes validation across embedding and synthetic datasets, with its principal GPU comparisons on H100 80GB GPUs and CPU experiments on a 64-core Xeon Platinum 8462Y+. Across 11 VIBE embedding tests, the authors report that e-means required 1.6 to 2.6 epochs to reach Lloyd’s 25-epoch error, with speedups of 8.0× to 22.8× against Flash-KMeans on one H100 and 9.0× to 15.0× against Faiss on 64 CPU cores, using 20 seeds per test.
At the largest scale, the authors report partitioning DINO10B, containing 10 billion 1,024-dimensional DINO patch embeddings, into approximately 16.7 million clusters in 2.5 epochs with exact assignment, reaching slightly lower test error than the 25-epoch Lloyd baseline. That run used 779 GPU-hours across 32 machines. A separate run using approximate nearest-centroid search through an inverted-file (IVF) index crossed the baseline after three epochs using 23.2 GPU-hours on one eight-GPU machine. The IVF approach searches selected centroid buckets rather than comparing every point with every centroid.
The paper reports that IVF assignment is 34× cheaper than exact assignment at the ten-billion-vector scale but brings no gain at 100 million vectors. That difference shows why the epoch count alone does not determine infrastructure requirements: the implementation and assignment method decide how much hardware a run needs.
Availability and Documented Limits
The official user guide provides NumpyEmeans for NumPy data and Emeans for PyTorch tensors. Faiss alone supports CPU execution; GPU execution uses CUDA-enabled PyTorch, with CuTe kernels available on H100 and H200 and Triton on other supported recent NVIDIA GPUs. Only nearest-centroid assignment uses reduced precision on GPU, while centroids, running sums and returned distances remain FP32. Replicated- and sharded-centroid classes support multi-GPU training; the paper notes that FP32 sums for 16 million centroids occupy 64 GiB, motivating sharding at that scale.
The scaling laws were tuned for relatively high-dimensional data and are not optimal for very low-dimensional or tiny datasets. The released defaults consequently choose the quality batch law at 16 dimensions or fewer and disable revival at two dimensions or fewer. The guide also cautions that returned training labels come from the last pass and are not necessarily assignments to the final centroids, and that the GPU path does not check inputs for NaN or infinite values.
For AI pipelines that cluster large embedding collections, the release makes the trade-off concrete: fewer training passes are available in a maintained library, while the largest reductions in GPU consumption depend on scale, hardware and whether approximate assignment fits the workload.
