faiss 0.3.0 → 0.3.1

data/vendor/faiss/faiss/IndexIVFPQR.cpp

@@ -35,10 +35,12 @@ IndexIVFPQR::IndexIVFPQR(
           refine_pq(d, M_refine, nbits_per_idx_refine),
           k_factor(4) {
     by_residual = true;
+    refine_pq.cp.max_points_per_centroid = 1000;
 }
 
 IndexIVFPQR::IndexIVFPQR() : k_factor(1) {
     by_residual = true;
+    refine_pq.cp.max_points_per_centroid = 1000;
 }
 
 void IndexIVFPQR::reset() {
@@ -46,24 +48,39 @@ void IndexIVFPQR::reset() {
     refine_codes.clear();
 }
 
-void IndexIVFPQR::train_residual(idx_t n, const float* x) {
-    float* residual_2 = new float[n * d];
-    ScopeDeleter<float> del(residual_2);
-
-    train_residual_o(n, x, residual_2);
-
-    if (verbose)
+void IndexIVFPQR::train_encoder(idx_t n, const float* x, const idx_t* assign) {
+    IndexIVFPQ::train_encoder(n, x, assign);
+    if (verbose) {
         printf("training %zdx%zd 2nd level PQ quantizer on %" PRId64
                " %dD-vectors\n",
                refine_pq.M,
                refine_pq.ksub,
                n,
                d);
-
-    refine_pq.cp.max_points_per_centroid = 1000;
+    }
     refine_pq.cp.verbose = verbose;
 
-    refine_pq.train(n, residual_2);
+    // 2nd level residual
+    std::vector<float> residual_2(n * d);
+    std::vector<uint8_t> train_codes(pq.code_size * n);
+    pq.compute_codes(x, train_codes.data(), n);
+
+    for (idx_t i = 0; i < n; i++) {
+        const float* xx = x + i * d;
+        float* res = residual_2.data() + i * d;
+        pq.decode(train_codes.data() + i * pq.code_size, res);
+        for (int j = 0; j < d; j++) {
+            res[j] = xx[j] - res[j];
+        }
+    }
+
+    refine_pq.train(n, residual_2.data());
+}
+
+idx_t IndexIVFPQR::train_encoder_num_vectors() const {
+    return std::max(
+            pq.cp.max_points_per_centroid * pq.ksub,
+            refine_pq.cp.max_points_per_centroid * refine_pq.ksub);
 }
 
 void IndexIVFPQR::add_with_ids(idx_t n, const float* x, const idx_t* xids) {
@@ -74,18 +91,18 @@ void IndexIVFPQR::add_core(
         idx_t n,
         const float* x,
         const idx_t* xids,
-        const idx_t* precomputed_idx) {
-    float* residual_2 = new float[n * d];
-    ScopeDeleter<float> del(residual_2);
+        const idx_t* precomputed_idx,
+        void* /*inverted_list_context*/) {
+    std::unique_ptr<float[]> residual_2(new float[n * d]);
 
     idx_t n0 = ntotal;
 
-    add_core_o(n, x, xids, residual_2, precomputed_idx);
+    add_core_o(n, x, xids, residual_2.get(), precomputed_idx);
 
     refine_codes.resize(ntotal * refine_pq.code_size);
 
     refine_pq.compute_codes(
-            residual_2, &refine_codes[n0 * refine_pq.code_size], n);
+            residual_2.get(), &refine_codes[n0 * refine_pq.code_size], n);
 }
 #define TIC t0 = get_cycles()
 #define TOC get_cycles() - t0
@@ -104,11 +121,10 @@ void IndexIVFPQR::search_preassigned(
     uint64_t t0;
     TIC;
     size_t k_coarse = long(k * k_factor);
-    idx_t* coarse_labels = new idx_t[k_coarse * n];
-    ScopeDeleter<idx_t> del1(coarse_labels);
-    { // query with quantizer levels 1 and 2.
-        float* coarse_distances = new float[k_coarse * n];
-        ScopeDeleter<float> del(coarse_distances);
+    std::unique_ptr<idx_t[]> coarse_labels(new idx_t[k_coarse * n]);
+    {
+        // query with quantizer levels 1 and 2.
+        std::unique_ptr<float[]> coarse_distances(new float[k_coarse * n]);
 
         IndexIVFPQ::search_preassigned(
                 n,
@@ -116,8 +132,8 @@ void IndexIVFPQR::search_preassigned(
                 k_coarse,
                 idx,
                 L1_dis,
-                coarse_distances,
-                coarse_labels,
+                coarse_distances.get(),
+                coarse_labels.get(),
                 true,
                 params);
     }
@@ -131,13 +147,12 @@ void IndexIVFPQR::search_preassigned(
 #pragma omp parallel reduction(+ : n_refine)
     {
         // tmp buffers
-        float* residual_1 = new float[2 * d];
-        ScopeDeleter<float> del(residual_1);
-        float* residual_2 = residual_1 + d;
+        std::unique_ptr<float[]> residual_1(new float[2 * d]);
+        float* residual_2 = residual_1.get() + d;
 #pragma omp for
         for (idx_t i = 0; i < n; i++) {
             const float* xq = x + i * d;
-            const idx_t* shortlist = coarse_labels + k_coarse * i;
+            const idx_t* shortlist = coarse_labels.get() + k_coarse * i;
             float* heap_sim = distances + k * i;
             idx_t* heap_ids = labels + k * i;
             maxheap_heapify(k, heap_sim, heap_ids);
@@ -155,7 +170,7 @@ void IndexIVFPQR::search_preassigned(
                 assert(ofs >= 0 && ofs < invlists->list_size(list_no));
 
                 // 1st level residual
-                quantizer->compute_residual(xq, residual_1, list_no);
+                quantizer->compute_residual(xq, residual_1.get(), list_no);
 
                 // 2nd level residual
                 const uint8_t* l2code = invlists->get_single_code(list_no, ofs);
@@ -168,9 +183,10 @@ void IndexIVFPQR::search_preassigned(
                 idx_t id = invlists->get_single_id(list_no, ofs);
                 assert(0 <= id && id < ntotal);
                 refine_pq.decode(
-                        &refine_codes[id * refine_pq.code_size], residual_1);
+                        &refine_codes[id * refine_pq.code_size],
+                        residual_1.get());
 
-                float dis = fvec_L2sqr(residual_1, residual_2, d);
+                float dis = fvec_L2sqr(residual_1.get(), residual_2, d);
 
                 if (dis < heap_sim[0]) {
                     idx_t id_or_pair = store_pairs ? sl : id;

data/vendor/faiss/faiss/IndexIVFPQR.h

@@ -37,7 +37,9 @@ struct IndexIVFPQR : IndexIVFPQ {
     size_t remove_ids(const IDSelector& sel) override;
 
     /// trains the two product quantizers
-    void train_residual(idx_t n, const float* x) override;
+    void train_encoder(idx_t n, const float* x, const idx_t* assign) override;
+
+    idx_t train_encoder_num_vectors() const override;
 
     void add_with_ids(idx_t n, const float* x, const idx_t* xids) override;
 
@@ -46,7 +48,8 @@ struct IndexIVFPQR : IndexIVFPQ {
             idx_t n,
             const float* x,
             const idx_t* xids,
-            const idx_t* precomputed_idx) override;
+            const idx_t* precomputed_idx,
+            void* inverted_list_context = nullptr) override;
 
     void reconstruct_from_offset(int64_t list_no, int64_t offset, float* recons)
             const override;

data/vendor/faiss/faiss/IndexIVFSpectralHash.cpp

@@ -9,8 +9,8 @@
 
 #include <faiss/IndexIVFSpectralHash.h>
 
-#include <stdint.h>
 #include <algorithm>
+#include <cstdint>
 #include <memory>
 
 #include <faiss/IndexLSH.h>
@@ -31,22 +31,17 @@ IndexIVFSpectralHash::IndexIVFSpectralHash(
         float period)
         : IndexIVF(quantizer, d, nlist, (nbit + 7) / 8, METRIC_L2),
           nbit(nbit),
-          period(period),
-          threshold_type(Thresh_global) {
+          period(period) {
     RandomRotationMatrix* rr = new RandomRotationMatrix(d, nbit);
     rr->init(1234);
     vt = rr;
-    own_fields = true;
     is_trained = false;
+    by_residual = false;
 }
 
-IndexIVFSpectralHash::IndexIVFSpectralHash()
-        : IndexIVF(),
-          vt(nullptr),
-          own_fields(false),
-          nbit(0),
-          period(0),
-          threshold_type(Thresh_global) {}
+IndexIVFSpectralHash::IndexIVFSpectralHash() : IndexIVF() {
+    by_residual = false;
+}
 
 IndexIVFSpectralHash::~IndexIVFSpectralHash() {
     if (own_fields) {
@@ -67,10 +62,14 @@ float median(size_t n, float* x) {
 
 } // namespace
 
-void IndexIVFSpectralHash::train_residual(idx_t n, const float* x) {
+void IndexIVFSpectralHash::train_encoder(
+        idx_t n,
+        const float* x,
+        const idx_t* assign) {
     if (!vt->is_trained) {
         vt->train(n, x);
     }
+    FAISS_THROW_IF_NOT(!by_residual);
 
     if (threshold_type == Thresh_global) {
         // nothing to do
@@ -158,7 +157,7 @@ void binarize_with_freq(
     }
 }
 
-}; // namespace
+} // namespace
 
 void IndexIVFSpectralHash::encode_vectors(
         idx_t n,
@@ -167,6 +166,7 @@ void IndexIVFSpectralHash::encode_vectors(
         uint8_t* codes,
         bool include_listnos) const {
     FAISS_THROW_IF_NOT(is_trained);
+    FAISS_THROW_IF_NOT(!by_residual);
     float freq = 2.0 / period;
     size_t coarse_size = include_listnos ? coarse_code_size() : 0;
 
@@ -224,6 +224,7 @@ struct IVFScanner : InvertedListScanner {
               hc(qcode.data(), index->code_size) {
         this->store_pairs = store_pairs;
         this->code_size = index->code_size;
+        this->keep_max = is_similarity_metric(index->metric_type);
     }
 
     void set_query(const float* query) override {
@@ -288,26 +289,23 @@ struct IVFScanner : InvertedListScanner {
     }
 };
 
+struct BuildScanner {
+    using T = InvertedListScanner*;
+
+    template <class HammingComputer>
+    static T f(const IndexIVFSpectralHash* index, bool store_pairs) {
+        return new IVFScanner<HammingComputer>(index, store_pairs);
+    }
+};
+
 } // anonymous namespace
 
 InvertedListScanner* IndexIVFSpectralHash::get_InvertedListScanner(
         bool store_pairs,
         const IDSelector* sel) const {
     FAISS_THROW_IF_NOT(!sel);
-    switch (code_size) {
-#define HANDLE_CODE_SIZE(cs) \
-    case cs:                 \
-        return new IVFScanner<HammingComputer##cs>(this, store_pairs)
-        HANDLE_CODE_SIZE(4);
-        HANDLE_CODE_SIZE(8);
-        HANDLE_CODE_SIZE(16);
-        HANDLE_CODE_SIZE(20);
-        HANDLE_CODE_SIZE(32);
-        HANDLE_CODE_SIZE(64);
-#undef HANDLE_CODE_SIZE
-        default:
-            return new IVFScanner<HammingComputerDefault>(this, store_pairs);
-    }
+    BuildScanner bs;
+    return dispatch_HammingComputer(code_size, bs, this, store_pairs);
 }
 
 void IndexIVFSpectralHash::replace_vt(VectorTransform* vt_in, bool own) {

data/vendor/faiss/faiss/IndexIVFSpectralHash.h

@@ -30,14 +30,14 @@ struct IndexPreTransform;
  */
 struct IndexIVFSpectralHash : IndexIVF {
     /// transformation from d to nbit dim
-    VectorTransform* vt;
+    VectorTransform* vt = nullptr;
     /// own the vt
-    bool own_fields;
+    bool own_fields = true;
 
     /// nb of bits of the binary signature
-    int nbit;
+    int nbit = 0;
     /// interval size for 0s and 1s
-    float period;
+    float period = 0;
 
     enum ThresholdType {
         Thresh_global,        ///< global threshold at 0
@@ -45,7 +45,7 @@ struct IndexIVFSpectralHash : IndexIVF {
         Thresh_centroid_half, ///< central interval around centroid
         Thresh_median         ///< median of training set
     };
-    ThresholdType threshold_type;
+    ThresholdType threshold_type = Thresh_global;
 
     /// Trained threshold.
     /// size nlist * nbit or 0 if Thresh_global
@@ -60,7 +60,7 @@ struct IndexIVFSpectralHash : IndexIVF {
 
     IndexIVFSpectralHash();
 
-    void train_residual(idx_t n, const float* x) override;
+    void train_encoder(idx_t n, const float* x, const idx_t* assign) override;
 
     void encode_vectors(
             idx_t n,

data/vendor/faiss/faiss/IndexLSH.cpp

@@ -11,6 +11,7 @@
 #include <cstring>
 
 #include <algorithm>
+#include <memory>
 
 #include <faiss/impl/FaissAssert.h>
 #include <faiss/utils/hamming.h>
@@ -56,7 +57,7 @@ const float* IndexLSH::apply_preprocess(idx_t n, const float* x) const {
     }
 
     if (train_thresholds) {
-        if (xt == NULL) {
+        if (xt == nullptr) {
             xt = new float[nbits * n];
             memcpy(xt, x, sizeof(*x) * n * nbits);
         }
@@ -75,18 +76,17 @@ void IndexLSH::train(idx_t n, const float* x) {
         thresholds.resize(nbits);
         train_thresholds = false;
         const float* xt = apply_preprocess(n, x);
-        ScopeDeleter<float> del(xt == x ? nullptr : xt);
+        std::unique_ptr<const float[]> del(xt == x ? nullptr : xt);
         train_thresholds = true;
 
-        float* transposed_x = new float[n * nbits];
-        ScopeDeleter<float> del2(transposed_x);
+        std::unique_ptr<float[]> transposed_x(new float[n * nbits]);
 
         for (idx_t i = 0; i < n; i++)
             for (idx_t j = 0; j < nbits; j++)
                 transposed_x[j * n + i] = xt[i * nbits + j];
 
         for (idx_t i = 0; i < nbits; i++) {
-            float* xi = transposed_x + i * n;
+            float* xi = transposed_x.get() + i * n;
             // std::nth_element
             std::sort(xi, xi + n);
             if (n % 2 == 1)
@@ -110,19 +110,17 @@ void IndexLSH::search(
     FAISS_THROW_IF_NOT(k > 0);
     FAISS_THROW_IF_NOT(is_trained);
     const float* xt = apply_preprocess(n, x);
-    ScopeDeleter<float> del(xt == x ? nullptr : xt);
+    std::unique_ptr<const float[]> del(xt == x ? nullptr : xt);
 
-    uint8_t* qcodes = new uint8_t[n * code_size];
-    ScopeDeleter<uint8_t> del2(qcodes);
+    std::unique_ptr<uint8_t[]> qcodes(new uint8_t[n * code_size]);
 
-    fvecs2bitvecs(xt, qcodes, nbits, n);
+    fvecs2bitvecs(xt, qcodes.get(), nbits, n);
 
-    int* idistances = new int[n * k];
-    ScopeDeleter<int> del3(idistances);
+    std::unique_ptr<int[]> idistances(new int[n * k]);
 
-    int_maxheap_array_t res = {size_t(n), size_t(k), labels, idistances};
+    int_maxheap_array_t res = {size_t(n), size_t(k), labels, idistances.get()};
 
-    hammings_knn_hc(&res, qcodes, codes.data(), ntotal, code_size, true);
+    hammings_knn_hc(&res, qcodes.get(), codes.data(), ntotal, code_size, true);
 
     // convert distances to floats
     for (int i = 0; i < k * n; i++)
@@ -146,16 +144,16 @@ void IndexLSH::transfer_thresholds(LinearTransform* vt) {
 void IndexLSH::sa_encode(idx_t n, const float* x, uint8_t* bytes) const {
     FAISS_THROW_IF_NOT(is_trained);
     const float* xt = apply_preprocess(n, x);
-    ScopeDeleter<float> del(xt == x ? nullptr : xt);
+    std::unique_ptr<const float[]> del(xt == x ? nullptr : xt);
     fvecs2bitvecs(xt, bytes, nbits, n);
 }
 
 void IndexLSH::sa_decode(idx_t n, const uint8_t* bytes, float* x) const {
     float* xt = x;
-    ScopeDeleter<float> del;
+    std::unique_ptr<float[]> del;
     if (rotate_data || nbits != d) {
         xt = new float[n * nbits];
-        del.set(xt);
+        del.reset(xt);
     }
     bitvecs2fvecs(bytes, xt, nbits, n);
 

data/vendor/faiss/faiss/IndexNNDescent.cpp

@@ -158,8 +158,8 @@ void IndexNNDescent::search(
         {
             VisitedTable vt(ntotal);
 
-            DistanceComputer* dis = storage_distance_computer(storage);
-            ScopeDeleter1<DistanceComputer> del(dis);
+            std::unique_ptr<DistanceComputer> dis(
+                    storage_distance_computer(storage));
 
 #pragma omp for
             for (idx_t i = i0; i < i1; i++) {
@@ -197,8 +197,7 @@ void IndexNNDescent::add(idx_t n, const float* x) {
     storage->add(n, x);
     ntotal = storage->ntotal;
 
-    DistanceComputer* dis = storage_distance_computer(storage);
-    ScopeDeleter1<DistanceComputer> del(dis);
+    std::unique_ptr<DistanceComputer> dis(storage_distance_computer(storage));
     nndescent.build(*dis, ntotal, verbose);
 }
 

data/vendor/faiss/faiss/IndexNSG.cpp

@@ -29,32 +29,16 @@ using namespace nsg;
  * IndexNSG implementation
  **************************************************************/
 
-IndexNSG::IndexNSG(int d, int R, MetricType metric)
-        : Index(d, metric),
-          nsg(R),
-          own_fields(false),
-          storage(nullptr),
-          is_built(false),
-          GK(64),
-          build_type(0) {
-    nndescent_S = 10;
-    nndescent_R = 100;
+IndexNSG::IndexNSG(int d, int R, MetricType metric) : Index(d, metric), nsg(R) {
     nndescent_L = GK + 50;
-    nndescent_iter = 10;
 }
 
 IndexNSG::IndexNSG(Index* storage, int R)
         : Index(storage->d, storage->metric_type),
           nsg(R),
-          own_fields(false),
           storage(storage),
-          is_built(false),
-          GK(64),
           build_type(1) {
-    nndescent_S = 10;
-    nndescent_R = 100;
     nndescent_L = GK + 50;
-    nndescent_iter = 10;
 }
 
 IndexNSG::~IndexNSG() {
@@ -95,8 +79,8 @@ void IndexNSG::search(
         {
             VisitedTable vt(ntotal);
 
-            DistanceComputer* dis = storage_distance_computer(storage);
-            ScopeDeleter1<DistanceComputer> del(dis);
+            std::unique_ptr<DistanceComputer> dis(
+                    storage_distance_computer(storage));
 
 #pragma omp for
             for (idx_t i = i0; i < i1; i++) {
@@ -120,7 +104,7 @@ void IndexNSG::search(
     }
 }
 
-void IndexNSG::build(idx_t n, const float* x, idx_t* knn_graph, int GK) {
+void IndexNSG::build(idx_t n, const float* x, idx_t* knn_graph, int GK_2) {
     FAISS_THROW_IF_NOT_MSG(
             storage,
             "Please use IndexNSGFlat (or variants) instead of IndexNSG directly");
@@ -131,9 +115,9 @@ void IndexNSG::build(idx_t n, const float* x, idx_t* knn_graph, int GK) {
     ntotal = storage->ntotal;
 
     // check the knn graph
-    check_knn_graph(knn_graph, n, GK);
+    check_knn_graph(knn_graph, n, GK_2);
 
-    const nsg::Graph<idx_t> knng(knn_graph, n, GK);
+    const nsg::Graph<idx_t> knng(knn_graph, n, GK_2);
     nsg.build(storage, n, knng, verbose);
     is_built = true;
 }
@@ -302,10 +286,10 @@ IndexNSGFlat::IndexNSGFlat(int d, int R, MetricType metric)
  * IndexNSGPQ implementation
  **************************************************************/
 
-IndexNSGPQ::IndexNSGPQ() {}
+IndexNSGPQ::IndexNSGPQ() = default;
 
-IndexNSGPQ::IndexNSGPQ(int d, int pq_m, int M)
-        : IndexNSG(new IndexPQ(d, pq_m, 8), M) {
+IndexNSGPQ::IndexNSGPQ(int d, int pq_m, int M, int pq_nbits)
+        : IndexNSG(new IndexPQ(d, pq_m, pq_nbits), M) {
     own_fields = true;
     is_trained = false;
 }
@@ -325,10 +309,10 @@ IndexNSGSQ::IndexNSGSQ(
         int M,
         MetricType metric)
         : IndexNSG(new IndexScalarQuantizer(d, qtype, metric), M) {
-    is_trained = false;
+    is_trained = this->storage->is_trained;
     own_fields = true;
 }
 
-IndexNSGSQ::IndexNSGSQ() {}
+IndexNSGSQ::IndexNSGSQ() = default;
 
 } // namespace faiss

data/vendor/faiss/faiss/IndexNSG.h

@@ -28,25 +28,25 @@ struct IndexNSG : Index {
     NSG nsg;
 
     /// the sequential storage
-    bool own_fields;
-    Index* storage;
+    bool own_fields = false;
+    Index* storage = nullptr;
 
     /// the index is built or not
-    bool is_built;
+    bool is_built = false;
 
     /// K of KNN graph for building
-    int GK;
+    int GK = 64;
 
     /// indicate how to build a knn graph
     /// - 0: build NSG with brute force search
     /// - 1: build NSG with NNDescent
-    char build_type;
+    char build_type = 0;
 
     /// parameters for nndescent
-    int nndescent_S;
-    int nndescent_R;
-    int nndescent_L;
-    int nndescent_iter;
+    int nndescent_S = 10;
+    int nndescent_R = 100;
+    int nndescent_L; // set to GK + 50
+    int nndescent_iter = 10;
 
     explicit IndexNSG(int d = 0, int R = 32, MetricType metric = METRIC_L2);
     explicit IndexNSG(Index* storage, int R = 32);
@@ -90,7 +90,7 @@ struct IndexNSGFlat : IndexNSG {
  */
 struct IndexNSGPQ : IndexNSG {
     IndexNSGPQ();
-    IndexNSGPQ(int d, int pq_m, int M);
+    IndexNSGPQ(int d, int pq_m, int M, int pq_nbits = 8);
     void train(idx_t n, const float* x) override;
 };