faiss 0.2.5 → 0.2.7

data/vendor/faiss/faiss/impl/PolysemousTraining.cpp

@@ -8,7 +8,6 @@
 // -*- c++ -*-
 
 #include <faiss/impl/PolysemousTraining.h>
-#include "faiss/impl/FaissAssert.h"
 
 #include <omp.h>
 #include <stdint.h>
@@ -36,19 +35,6 @@ namespace faiss {
  * Optimization code
  ****************************************************/
 
-SimulatedAnnealingParameters::SimulatedAnnealingParameters() {
-    // set some reasonable defaults for the optimization
-    init_temperature = 0.7;
-    temperature_decay = pow(0.9, 1 / 500.);
-    // reduce by a factor 0.9 every 500 it
-    n_iter = 500000;
-    n_redo = 2;
-    seed = 123;
-    verbose = 0;
-    only_bit_flips = false;
-    init_random = false;
-}
-
 // what would the cost update be if iw and jw were swapped?
 // default implementation just computes both and computes the difference
 double PermutationObjective::cost_update(const int* perm, int iw, int jw)
@@ -906,7 +892,7 @@ void PolysemousTraining::optimize_ranking(
         ScopeDeleter1<PermutationObjective> del(obj);
 
         if (verbose > 0) {
-            printf("   m=%d, nq=%zd, nb=%zd, intialize RankingScore "
+            printf("   m=%d, nq=%zd, nb=%zd, initialize RankingScore "
                    "in %.3f ms\n",
                    m,
                    nq,

data/vendor/faiss/faiss/impl/PolysemousTraining.h

@@ -17,18 +17,19 @@ namespace faiss {
 /// parameters used for the simulated annealing method
 struct SimulatedAnnealingParameters {
     // optimization parameters
-    double init_temperature;  // init probability of accepting a bad swap
-    double temperature_decay; // at each iteration the temp is multiplied by
-                              // this
-    int n_iter;               // nb of iterations
-    int n_redo;               // nb of runs of the simulation
-    int seed;                 // random seed
-    int verbose;
-    bool only_bit_flips; // restrict permutation changes to bit flips
-    bool init_random;    // initialize with a random permutation (not identity)
+    double init_temperature = 0.7; // init probability of accepting a bad swap
+    // at each iteration the temp is multiplied by this
+    double temperature_decay = 0.9997893011688015; // = 0.9^(1/500)
+    int n_iter = 500000;                           // nb of iterations
+    int n_redo = 2; // nb of runs of the simulation
+    int seed = 123; // random seed
+    int verbose = 0;
+    bool only_bit_flips = false; // restrict permutation changes to bit flips
+    bool init_random =
+            false; // initialize with a random permutation (not identity)
 
     // set reasonable defaults
-    SimulatedAnnealingParameters();
+    SimulatedAnnealingParameters() {}
 };
 
 /// abstract class for the loss function

data/vendor/faiss/faiss/impl/ProductAdditiveQuantizer.cpp

@@ -65,13 +65,6 @@ void ProductAdditiveQuantizer::init(
         M += q->M;
         nbits.insert(nbits.end(), q->nbits.begin(), q->nbits.end());
     }
-    verbose = false;
-    is_trained = false;
-    norm_max = norm_min = NAN;
-    code_size = 0;
-    tot_bits = 0;
-    total_codebook_size = 0;
-    only_8bit = false;
     set_derived_values();
 
     // ProductAdditiveQuantizer

data/vendor/faiss/faiss/impl/ProductQuantizer.cpp

@@ -421,15 +421,28 @@ void ProductQuantizer::compute_codes(const float* x, uint8_t* codes, size_t n)
 
 void ProductQuantizer::compute_distance_table(const float* x, float* dis_table)
         const {
-    size_t m;
-
-    for (m = 0; m < M; m++) {
-        fvec_L2sqr_ny(
-                dis_table + m * ksub,
-                x + m * dsub,
-                get_centroids(m, 0),
-                dsub,
-                ksub);
+    if (transposed_centroids.empty()) {
+        // use regular version
+        for (size_t m = 0; m < M; m++) {
+            fvec_L2sqr_ny(
+                    dis_table + m * ksub,
+                    x + m * dsub,
+                    get_centroids(m, 0),
+                    dsub,
+                    ksub);
+        }
+    } else {
+        // transposed centroids are available, use'em
+        for (size_t m = 0; m < M; m++) {
+            fvec_L2sqr_ny_transposed(
+                    dis_table + m * ksub,
+                    x + m * dsub,
+                    transposed_centroids.data() + m * ksub,
+                    centroids_sq_lengths.data() + m * ksub,
+                    dsub,
+                    M * ksub,
+                    ksub);
+        }
     }
 }
 
@@ -460,7 +473,7 @@ void ProductQuantizer::compute_distance_tables(
 #endif
             if (dsub < 16) {
 
-#pragma omp parallel for
+#pragma omp parallel for if (nx > 1)
         for (int64_t i = 0; i < nx; i++) {
             compute_distance_table(x + i * d, dis_tables + i * ksub * M);
         }
@@ -494,7 +507,7 @@ void ProductQuantizer::compute_inner_prod_tables(
 #endif
             if (dsub < 16) {
 
-#pragma omp parallel for
+#pragma omp parallel for if (nx > 1)
         for (int64_t i = 0; i < nx; i++) {
             compute_inner_prod_table(x + i * d, dis_tables + i * ksub * M);
         }
@@ -668,7 +681,7 @@ void pq_knn_search_with_tables(
     size_t k = res->k, nx = res->nh;
     size_t ksub = pq.ksub, M = pq.M;
 
-#pragma omp parallel for
+#pragma omp parallel for if (nx > 1)
     for (int64_t i = 0; i < nx; i++) {
         /* query preparation for asymmetric search: compute look-up tables */
         const float* dis_table = dis_tables + i * ksub * M;

data/vendor/faiss/faiss/impl/ProductQuantizer.h

@@ -23,8 +23,6 @@ namespace faiss {
 
 /** Product Quantizer. Implemented only for METRIC_L2 */
 struct ProductQuantizer : Quantizer {
-    using idx_t = Index::idx_t;
-
     size_t M;     ///< number of subquantizers
     size_t nbits; ///< number of bits per quantization index
 
@@ -38,8 +36,8 @@ struct ProductQuantizer : Quantizer {
         Train_default,
         Train_hot_start,     ///< the centroids are already initialized
         Train_shared,        ///< share dictionary accross PQ segments
-        Train_hypercube,     ///< intialize centroids with nbits-D hypercube
-        Train_hypercube_pca, ///< intialize centroids with nbits-D hypercube
+        Train_hypercube,     ///< initialize centroids with nbits-D hypercube
+        Train_hypercube_pca, ///< initialize centroids with nbits-D hypercube
     };
     train_type_t train_type;
 

data/vendor/faiss/faiss/impl/Quantizer.h

@@ -1,4 +1,9 @@
-// (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
 
 #pragma once
 
@@ -8,8 +13,6 @@ namespace faiss {
 
 /** Product Quantizer. Implemented only for METRIC_L2 */
 struct Quantizer {
-    using idx_t = Index::idx_t;
-
     size_t d;         ///< size of the input vectors
     size_t code_size; ///< bytes per indexed vector