faiss 0.1.0 → 0.1.1

data/vendor/faiss/demos/demo_sift1M.cpp

@@ -0,0 +1,252 @@
+/**
+ * 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.
+ */
+
+
+
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <cassert>
+#include <cstring>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#include <sys/time.h>
+
+#include <faiss/AutoTune.h>
+#include <faiss/index_factory.h>
+
+/**
+ * To run this demo, please download the ANN_SIFT1M dataset from
+ *
+ *   http://corpus-texmex.irisa.fr/
+ *
+ * and unzip it to the sudirectory sift1M.
+ **/
+
+/*****************************************************
+ * I/O functions for fvecs and ivecs
+ *****************************************************/
+
+
+float * fvecs_read (const char *fname,
+                    size_t *d_out, size_t *n_out)
+{
+    FILE *f = fopen(fname, "r");
+    if(!f) {
+        fprintf(stderr, "could not open %s\n", fname);
+        perror("");
+        abort();
+    }
+    int d;
+    fread(&d, 1, sizeof(int), f);
+    assert((d > 0 && d < 1000000) || !"unreasonable dimension");
+    fseek(f, 0, SEEK_SET);
+    struct stat st;
+    fstat(fileno(f), &st);
+    size_t sz = st.st_size;
+    assert(sz % ((d + 1) * 4) == 0 || !"weird file size");
+    size_t n = sz / ((d + 1) * 4);
+
+    *d_out = d; *n_out = n;
+    float *x = new float[n * (d + 1)];
+    size_t nr = fread(x, sizeof(float), n * (d + 1), f);
+    assert(nr == n * (d + 1) || !"could not read whole file");
+
+    // shift array to remove row headers
+    for(size_t i = 0; i < n; i++)
+        memmove(x + i * d, x + 1 + i * (d + 1), d * sizeof(*x));
+
+    fclose(f);
+    return x;
+}
+
+// not very clean, but works as long as sizeof(int) == sizeof(float)
+int *ivecs_read(const char *fname, size_t *d_out, size_t *n_out)
+{
+    return (int*)fvecs_read(fname, d_out, n_out);
+}
+
+double elapsed ()
+{
+    struct timeval tv;
+    gettimeofday (&tv, nullptr);
+    return  tv.tv_sec + tv.tv_usec * 1e-6;
+}
+
+
+
+int main()
+{
+    double t0 = elapsed();
+
+    // this is typically the fastest one.
+    const char *index_key = "IVF4096,Flat";
+
+    // these ones have better memory usage
+    // const char *index_key = "Flat";
+    // const char *index_key = "PQ32";
+    // const char *index_key = "PCA80,Flat";
+    // const char *index_key = "IVF4096,PQ8+16";
+    // const char *index_key = "IVF4096,PQ32";
+    // const char *index_key = "IMI2x8,PQ32";
+    // const char *index_key = "IMI2x8,PQ8+16";
+    // const char *index_key = "OPQ16_64,IMI2x8,PQ8+16";
+
+    faiss::Index * index;
+
+    size_t d;
+
+    {
+        printf ("[%.3f s] Loading train set\n", elapsed() - t0);
+
+        size_t nt;
+        float *xt = fvecs_read("sift1M/sift_learn.fvecs", &d, &nt);
+
+        printf ("[%.3f s] Preparing index \"%s\" d=%ld\n",
+                elapsed() - t0, index_key, d);
+        index = faiss::index_factory(d, index_key);
+
+        printf ("[%.3f s] Training on %ld vectors\n", elapsed() - t0, nt);
+
+        index->train(nt, xt);
+        delete [] xt;
+    }
+
+
+    {
+        printf ("[%.3f s] Loading database\n", elapsed() - t0);
+
+        size_t nb, d2;
+        float *xb = fvecs_read("sift1M/sift_base.fvecs", &d2, &nb);
+        assert(d == d2 || !"dataset does not have same dimension as train set");
+
+        printf ("[%.3f s] Indexing database, size %ld*%ld\n",
+                elapsed() - t0, nb, d);
+
+        index->add(nb, xb);
+
+        delete [] xb;
+    }
+
+    size_t nq;
+    float *xq;
+
+    {
+        printf ("[%.3f s] Loading queries\n", elapsed() - t0);
+
+        size_t d2;
+        xq = fvecs_read("sift1M/sift_query.fvecs", &d2, &nq);
+        assert(d == d2 || !"query does not have same dimension as train set");
+
+    }
+
+    size_t k; // nb of results per query in the GT
+    faiss::Index::idx_t *gt;  // nq * k matrix of ground-truth nearest-neighbors
+
+    {
+        printf ("[%.3f s] Loading ground truth for %ld queries\n",
+                elapsed() - t0, nq);
+
+        // load ground-truth and convert int to long
+        size_t nq2;
+        int *gt_int = ivecs_read("sift1M/sift_groundtruth.ivecs", &k, &nq2);
+        assert(nq2 == nq || !"incorrect nb of ground truth entries");
+
+        gt = new faiss::Index::idx_t[k * nq];
+        for(int i = 0; i < k * nq; i++) {
+            gt[i] = gt_int[i];
+        }
+        delete [] gt_int;
+    }
+
+    // Result of the auto-tuning
+    std::string selected_params;
+
+    { // run auto-tuning
+
+        printf ("[%.3f s] Preparing auto-tune criterion 1-recall at 1 "
+                "criterion, with k=%ld nq=%ld\n", elapsed() - t0, k, nq);
+
+        faiss::OneRecallAtRCriterion crit(nq, 1);
+        crit.set_groundtruth (k, nullptr, gt);
+        crit.nnn = k; // by default, the criterion will request only 1 NN
+
+        printf ("[%.3f s] Preparing auto-tune parameters\n", elapsed() - t0);
+
+        faiss::ParameterSpace params;
+        params.initialize(index);
+
+        printf ("[%.3f s] Auto-tuning over %ld parameters (%ld combinations)\n",
+                elapsed() - t0, params.parameter_ranges.size(),
+                params.n_combinations());
+
+        faiss::OperatingPoints ops;
+        params.explore (index, nq, xq, crit, &ops);
+
+        printf ("[%.3f s] Found the following operating points: \n",
+                elapsed() - t0);
+
+        ops.display ();
+
+        // keep the first parameter that obtains > 0.5 1-recall@1
+        for (int i = 0; i < ops.optimal_pts.size(); i++) {
+            if (ops.optimal_pts[i].perf > 0.5) {
+                selected_params = ops.optimal_pts[i].key;
+                break;
+            }
+        }
+        assert (selected_params.size() >= 0 ||
+                !"could not find good enough op point");
+    }
+
+
+    { // Use the found configuration to perform a search
+
+        faiss::ParameterSpace params;
+
+        printf ("[%.3f s] Setting parameter configuration \"%s\" on index\n",
+                elapsed() - t0, selected_params.c_str());
+
+        params.set_index_parameters (index, selected_params.c_str());
+
+        printf ("[%.3f s] Perform a search on %ld queries\n",
+                elapsed() - t0, nq);
+
+        // output buffers
+        faiss::Index::idx_t *I = new  faiss::Index::idx_t[nq * k];
+        float *D = new float[nq * k];
+
+        index->search(nq, xq, k, D, I);
+
+        printf ("[%.3f s] Compute recalls\n", elapsed() - t0);
+
+        // evaluate result by hand.
+        int n_1 = 0, n_10 = 0, n_100 = 0;
+        for(int i = 0; i < nq; i++) {
+            int gt_nn = gt[i * k];
+            for(int j = 0; j < k; j++) {
+                if (I[i * k + j] == gt_nn) {
+                    if(j < 1) n_1++;
+                    if(j < 10) n_10++;
+                    if(j < 100) n_100++;
+                }
+            }
+        }
+        printf("R@1 = %.4f\n", n_1 / float(nq));
+        printf("R@10 = %.4f\n", n_10 / float(nq));
+        printf("R@100 = %.4f\n", n_100 / float(nq));
+
+    }
+
+    delete [] xq;
+    delete [] gt;
+    delete index;
+    return 0;
+}

data/vendor/faiss/gpu/GpuAutoTune.cpp

@@ -0,0 +1,95 @@
+/**
+ * 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.
+ */
+
+#include <faiss/gpu/GpuAutoTune.h>
+#include <typeinfo>
+
+#include <faiss/gpu/GpuIndex.h>
+#include <faiss/IndexReplicas.h>
+#include <faiss/IndexShards.h>
+#include <faiss/IndexPreTransform.h>
+#include <faiss/gpu/GpuIndexFlat.h>
+#include <faiss/gpu/GpuIndexIVFFlat.h>
+#include <faiss/gpu/GpuIndexIVFPQ.h>
+#include <faiss/gpu/GpuIndexIVFScalarQuantizer.h>
+#include <faiss/impl/FaissAssert.h>
+#include <faiss/gpu/utils/DeviceUtils.h>
+
+namespace faiss { namespace gpu {
+
+
+using namespace ::faiss;
+
+/**********************************************************
+ * Parameters to auto-tune on GpuIndex'es
+ **********************************************************/
+
+#define DC(classname) auto ix = dynamic_cast<const classname *>(index)
+
+
+void GpuParameterSpace::initialize (const Index * index)
+{
+    if (DC (IndexPreTransform)) {
+        index = ix->index;
+    }
+    if (DC (IndexReplicas)) {
+        if (ix->count() == 0) return;
+        index = ix->at(0);
+    }
+    if (DC (IndexShards)) {
+        if (ix->count() == 0) return;
+        index = ix->at(0);
+    }
+    if (DC (GpuIndexIVF)) {
+        ParameterRange & pr = add_range("nprobe");
+        for (int i = 0; i < 12; i++) {
+            size_t nprobe = 1 << i;
+            if (nprobe >= ix->getNumLists() ||
+                nprobe > getMaxKSelection()) break;
+            pr.values.push_back (nprobe);
+        }
+    }
+    // not sure we should call the parent initializer
+}
+
+
+
+#undef DC
+// non-const version
+#define DC(classname) auto *ix = dynamic_cast<classname *>(index)
+
+
+
+void GpuParameterSpace::set_index_parameter (
+        Index * index, const std::string & name, double val) const
+{
+    if (DC (IndexReplicas)) {
+        for (int i = 0; i < ix->count(); i++)
+            set_index_parameter (ix->at(i), name, val);
+        return;
+    }
+    if (name == "nprobe") {
+        if (DC (GpuIndexIVF)) {
+            ix->setNumProbes (int (val));
+            return;
+        }
+    }
+    if (name == "use_precomputed_table") {
+        if (DC (GpuIndexIVFPQ)) {
+            ix->setPrecomputedCodes(bool (val));
+            return;
+        }
+    }
+
+    // maybe normal index parameters apply?
+    ParameterSpace::set_index_parameter (index, name, val);
+}
+
+
+
+
+} } // namespace

data/vendor/faiss/gpu/GpuAutoTune.h

@@ -0,0 +1,27 @@
+/**
+ * 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
+
+#include <faiss/Index.h>
+#include <faiss/AutoTune.h>
+
+namespace faiss { namespace gpu {
+
+
+/// parameter space and setters for GPU indexes
+struct GpuParameterSpace: faiss::ParameterSpace {
+    /// initialize with reasonable parameters for the index
+    void initialize (const faiss::Index * index) override;
+
+    /// set a combination of parameters on an index
+    void set_index_parameter (
+          faiss::Index * index, const std::string & name,
+          double val) const override;
+};
+
+} } // namespace

data/vendor/faiss/gpu/GpuCloner.cpp

@@ -0,0 +1,403 @@
+/**
+ * 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.
+ */
+
+
+#include <faiss/gpu/GpuCloner.h>
+#include <typeinfo>
+
+#include <faiss/gpu/GpuIndex.h>
+#include <faiss/impl/FaissAssert.h>
+#include <faiss/index_io.h>
+#include <faiss/IndexFlat.h>
+#include <faiss/IndexIVF.h>
+#include <faiss/IndexIVFFlat.h>
+#include <faiss/IndexScalarQuantizer.h>
+#include <faiss/IndexIVFPQ.h>
+#include <faiss/IndexReplicas.h>
+#include <faiss/IndexPreTransform.h>
+#include <faiss/MetaIndexes.h>
+#include <faiss/gpu/GpuIndexFlat.h>
+#include <faiss/gpu/GpuIndexIVFFlat.h>
+#include <faiss/gpu/GpuIndexIVFPQ.h>
+#include <faiss/gpu/GpuIndexIVFScalarQuantizer.h>
+#include <faiss/gpu/utils/DeviceUtils.h>
+
+namespace faiss { namespace gpu {
+
+
+/**********************************************************
+ * Cloning to CPU
+ **********************************************************/
+
+void ToCPUCloner::merge_index(Index *dst, Index *src, bool successive_ids)
+{
+    if (auto ifl = dynamic_cast<IndexFlat *>(dst)) {
+        auto ifl2 = dynamic_cast<const IndexFlat *>(src);
+        FAISS_ASSERT(ifl2);
+        FAISS_ASSERT(successive_ids);
+        ifl->add(ifl2->ntotal, ifl2->xb.data());
+    } else if(auto ifl = dynamic_cast<IndexIVFFlat *>(dst)) {
+        auto ifl2 = dynamic_cast<IndexIVFFlat *>(src);
+        FAISS_ASSERT(ifl2);
+        ifl->merge_from(*ifl2, successive_ids ? ifl->ntotal : 0);
+    } else if(auto ifl = dynamic_cast<IndexIVFScalarQuantizer *>(dst)) {
+        auto ifl2 = dynamic_cast<IndexIVFScalarQuantizer *>(src);
+        FAISS_ASSERT(ifl2);
+        ifl->merge_from(*ifl2, successive_ids ? ifl->ntotal : 0);
+    } else if(auto ifl = dynamic_cast<IndexIVFPQ *>(dst)) {
+        auto ifl2 = dynamic_cast<IndexIVFPQ *>(src);
+        FAISS_ASSERT(ifl2);
+        ifl->merge_from(*ifl2, successive_ids ? ifl->ntotal : 0);
+    } else {
+        FAISS_ASSERT(!"merging not implemented for this type of class");
+    }
+}
+
+
+Index *ToCPUCloner::clone_Index(const Index *index)
+{
+    if(auto ifl = dynamic_cast<const GpuIndexFlat *>(index)) {
+        IndexFlat *res = new IndexFlat();
+        ifl->copyTo(res);
+        return res;
+    } else if(auto ifl = dynamic_cast<const GpuIndexIVFFlat *>(index)) {
+        IndexIVFFlat *res = new IndexIVFFlat();
+        ifl->copyTo(res);
+        return res;
+    } else if(auto ifl =
+              dynamic_cast<const GpuIndexIVFScalarQuantizer *>(index)) {
+        IndexIVFScalarQuantizer *res = new IndexIVFScalarQuantizer();
+        ifl->copyTo(res);
+        return res;
+    } else if(auto ipq = dynamic_cast<const GpuIndexIVFPQ *>(index)) {
+        IndexIVFPQ *res = new IndexIVFPQ();
+        ipq->copyTo(res);
+        return res;
+
+        // for IndexShards and IndexReplicas we assume that the
+        // objective is to make a single component out of them
+        // (inverse op of ToGpuClonerMultiple)
+
+    } else if(auto ish = dynamic_cast<const IndexShards *>(index)) {
+        int nshard = ish->count();
+        FAISS_ASSERT(nshard > 0);
+        Index *res = clone_Index(ish->at(0));
+        for(int i = 1; i < ish->count(); i++) {
+            Index *res_i = clone_Index(ish->at(i));
+            merge_index(res, res_i, ish->successive_ids);
+            delete res_i;
+        }
+        return res;
+    } else if(auto ipr = dynamic_cast<const IndexReplicas *>(index)) {
+        // just clone one of the replicas
+        FAISS_ASSERT(ipr->count() > 0);
+        return clone_Index(ipr->at(0));
+    } else {
+        return Cloner::clone_Index(index);
+    }
+}
+
+faiss::Index * index_gpu_to_cpu(const faiss::Index *gpu_index)
+{
+    ToCPUCloner cl;
+    return cl.clone_Index(gpu_index);
+}
+
+
+
+
+/**********************************************************
+ * Cloning to 1 GPU
+ **********************************************************/
+
+ToGpuCloner::ToGpuCloner(GpuResources *resources, int device,
+                         const GpuClonerOptions &options):
+    GpuClonerOptions(options), resources(resources), device(device)
+{}
+
+Index *ToGpuCloner::clone_Index(const Index *index)
+{
+    if(auto ifl = dynamic_cast<const IndexFlat *>(index)) {
+        GpuIndexFlatConfig config;
+        config.device = device;
+        config.useFloat16 = useFloat16;
+        config.storeTransposed = storeTransposed;
+
+        return new GpuIndexFlat(resources, ifl, config);
+    } else if(auto ifl = dynamic_cast<const faiss::IndexIVFFlat *>(index)) {
+        GpuIndexIVFFlatConfig config;
+        config.device = device;
+        config.indicesOptions = indicesOptions;
+        config.flatConfig.useFloat16 = useFloat16CoarseQuantizer;
+        config.flatConfig.storeTransposed = storeTransposed;
+
+        GpuIndexIVFFlat *res =
+            new GpuIndexIVFFlat(resources,
+                                ifl->d,
+                                ifl->nlist,
+                                ifl->metric_type,
+                                config);
+        if(reserveVecs > 0 && ifl->ntotal == 0) {
+            res->reserveMemory(reserveVecs);
+        }
+
+        res->copyFrom(ifl);
+        return res;
+    } else if(auto ifl =
+              dynamic_cast<const faiss::IndexIVFScalarQuantizer *>(index)) {
+        GpuIndexIVFScalarQuantizerConfig config;
+        config.device = device;
+        config.indicesOptions = indicesOptions;
+        config.flatConfig.useFloat16 = useFloat16CoarseQuantizer;
+        config.flatConfig.storeTransposed = storeTransposed;
+
+        GpuIndexIVFScalarQuantizer *res =
+            new GpuIndexIVFScalarQuantizer(resources,
+                                           ifl->d,
+                                           ifl->nlist,
+                                           ifl->sq.qtype,
+                                           ifl->metric_type,
+                                           ifl->by_residual,
+                                           config);
+        if(reserveVecs > 0 && ifl->ntotal == 0) {
+            res->reserveMemory(reserveVecs);
+        }
+
+        res->copyFrom(ifl);
+        return res;
+    } else if(auto ipq = dynamic_cast<const faiss::IndexIVFPQ *>(index)) {
+        if(verbose)
+            printf("  IndexIVFPQ size %ld -> GpuIndexIVFPQ "
+                   "indicesOptions=%d "
+                   "usePrecomputed=%d useFloat16=%d reserveVecs=%ld\n",
+                   ipq->ntotal, indicesOptions, usePrecomputed,
+                   useFloat16, reserveVecs);
+        GpuIndexIVFPQConfig config;
+        config.device = device;
+        config.indicesOptions = indicesOptions;
+        config.flatConfig.useFloat16 = useFloat16CoarseQuantizer;
+        config.flatConfig.storeTransposed = storeTransposed;
+        config.useFloat16LookupTables = useFloat16;
+        config.usePrecomputedTables = usePrecomputed;
+
+        GpuIndexIVFPQ *res = new GpuIndexIVFPQ(resources, ipq, config);
+
+        if(reserveVecs > 0 && ipq->ntotal == 0) {
+            res->reserveMemory(reserveVecs);
+        }
+
+        return res;
+    } else {
+        return Cloner::clone_Index(index);
+    }
+}
+
+
+faiss::Index * index_cpu_to_gpu(
+       GpuResources* resources, int device,
+       const faiss::Index *index,
+       const GpuClonerOptions *options)
+{
+    GpuClonerOptions defaults;
+    ToGpuCloner cl(resources, device, options ? *options : defaults);
+    return cl.clone_Index(index);
+}
+
+
+/**********************************************************
+ * Cloning to multiple GPUs
+ **********************************************************/
+
+ToGpuClonerMultiple::ToGpuClonerMultiple(
+                        std::vector<GpuResources *> & resources,
+                        std::vector<int>& devices,
+                        const GpuMultipleClonerOptions &options):
+    GpuMultipleClonerOptions(options)
+{
+    FAISS_ASSERT(resources.size() == devices.size());
+    for(int i = 0; i < resources.size(); i++) {
+        sub_cloners.push_back(ToGpuCloner(resources[i], devices[i], options));
+    }
+}
+
+
+ToGpuClonerMultiple::ToGpuClonerMultiple(
+                        const std::vector<ToGpuCloner> & sub_cloners,
+                        const GpuMultipleClonerOptions &options):
+    GpuMultipleClonerOptions(options),
+    sub_cloners(sub_cloners)
+{}
+
+
+void ToGpuClonerMultiple::copy_ivf_shard (
+                         const IndexIVF *index_ivf, IndexIVF *idx2,
+                         long n, long i)
+{
+    if (shard_type == 2) {
+        long i0 = i * index_ivf->ntotal / n;
+        long i1 = (i + 1) * index_ivf->ntotal / n;
+
+        if(verbose)
+            printf("IndexShards shard %ld indices %ld:%ld\n",
+                   i, i0, i1);
+        index_ivf->copy_subset_to(*idx2, 2, i0, i1);
+        FAISS_ASSERT(idx2->ntotal == i1 - i0);
+    } else if (shard_type == 1) {
+        if(verbose)
+            printf("IndexShards shard %ld select modulo %ld = %ld\n",
+                   i, n, i);
+        index_ivf->copy_subset_to(*idx2, 1, n, i);
+    } else {
+        FAISS_THROW_FMT ("shard_type %d not implemented", shard_type);
+    }
+
+}
+
+Index * ToGpuClonerMultiple::clone_Index_to_shards (const Index *index)
+{
+    long n = sub_cloners.size();
+
+    auto index_ivfpq =
+        dynamic_cast<const faiss::IndexIVFPQ *>(index);
+    auto index_ivfflat =
+        dynamic_cast<const faiss::IndexIVFFlat *>(index);
+    auto index_ivfsq =
+        dynamic_cast<const faiss::IndexIVFScalarQuantizer *>(index);
+    auto index_flat =
+        dynamic_cast<const faiss::IndexFlat *>(index);
+    FAISS_THROW_IF_NOT_MSG (
+        index_ivfpq || index_ivfflat || index_flat || index_ivfsq,
+        "IndexShards implemented only for "
+        "IndexIVFFlat, IndexIVFScalarQuantizer, "
+        "IndexFlat and IndexIVFPQ");
+
+    std::vector<faiss::Index*> shards(n);
+
+    for(long i = 0; i < n; i++) {
+        // make a shallow copy
+        if(reserveVecs)
+            sub_cloners[i].reserveVecs =
+                (reserveVecs + n - 1) / n;
+
+        if (index_ivfpq) {
+            faiss::IndexIVFPQ idx2(
+                       index_ivfpq->quantizer, index_ivfpq->d,
+                       index_ivfpq->nlist, index_ivfpq->code_size,
+                       index_ivfpq->pq.nbits);
+            idx2.metric_type = index_ivfpq->metric_type;
+            idx2.pq = index_ivfpq->pq;
+            idx2.nprobe = index_ivfpq->nprobe;
+            idx2.use_precomputed_table = 0;
+            idx2.is_trained = index->is_trained;
+            copy_ivf_shard (index_ivfpq, &idx2, n, i);
+            shards[i] = sub_cloners[i].clone_Index(&idx2);
+        } else if (index_ivfflat) {
+            faiss::IndexIVFFlat idx2(
+                       index_ivfflat->quantizer, index->d,
+                       index_ivfflat->nlist, index_ivfflat->metric_type);
+            idx2.nprobe = index_ivfflat->nprobe;
+            copy_ivf_shard (index_ivfflat, &idx2, n, i);
+            shards[i] = sub_cloners[i].clone_Index(&idx2);
+        } else if (index_ivfsq) {
+            faiss::IndexIVFScalarQuantizer idx2(
+                       index_ivfsq->quantizer, index->d, index_ivfsq->nlist,
+                       index_ivfsq->sq.qtype,
+                       index_ivfsq->metric_type,
+                       index_ivfsq->by_residual);
+            idx2.nprobe = index_ivfsq->nprobe;
+            copy_ivf_shard (index_ivfsq, &idx2, n, i);
+            shards[i] = sub_cloners[i].clone_Index(&idx2);
+        } else if (index_flat) {
+            faiss::IndexFlat idx2 (
+                                   index->d, index->metric_type);
+            shards[i] = sub_cloners[i].clone_Index(&idx2);
+            if (index->ntotal > 0) {
+                long i0 = index->ntotal * i / n;
+                long i1 = index->ntotal * (i + 1) / n;
+                shards[i]->add (i1 - i0,
+                                index_flat->xb.data() + i0 * index->d);
+            }
+        }
+    }
+
+    bool successive_ids = index_flat != nullptr;
+    faiss::IndexShards *res =
+        new faiss::IndexShards(index->d, true,
+                               successive_ids);
+
+    for (int i = 0; i < n; i++) {
+        res->add_shard(shards[i]);
+    }
+    res->own_fields = true;
+    FAISS_ASSERT(index->ntotal == res->ntotal);
+    return res;
+}
+
+Index *ToGpuClonerMultiple::clone_Index(const Index *index)
+{
+    long n = sub_cloners.size();
+    if (n == 1)
+        return sub_cloners[0].clone_Index(index);
+
+    if(dynamic_cast<const IndexFlat *>(index) ||
+       dynamic_cast<const faiss::IndexIVFFlat *>(index) ||
+       dynamic_cast<const faiss::IndexIVFScalarQuantizer *>(index) ||
+       dynamic_cast<const faiss::IndexIVFPQ *>(index)) {
+        if(!shard) {
+            IndexReplicas * res = new IndexReplicas();
+            for(auto & sub_cloner: sub_cloners) {
+                res->addIndex(sub_cloner.clone_Index(index));
+            }
+            res->own_fields = true;
+            return res;
+        } else {
+            return clone_Index_to_shards (index);
+        }
+    } else if(auto miq = dynamic_cast<const MultiIndexQuantizer *>(index)) {
+        if (verbose) {
+            printf("cloning MultiIndexQuantizer: "
+                   "will be valid only for search k=1\n");
+        }
+        const ProductQuantizer & pq = miq->pq;
+        IndexSplitVectors *splitv = new IndexSplitVectors(pq.d, true);
+        splitv->own_fields = true;
+
+        for (int m = 0; m < pq.M; m++) {
+            // which GPU(s) will be assigned to this sub-quantizer
+
+            long i0 = m * n / pq.M;
+            long i1 = pq.M <= n ? (m + 1) * n / pq.M : i0 + 1;
+            std::vector<ToGpuCloner> sub_cloners_2;
+            sub_cloners_2.insert(
+                                 sub_cloners_2.begin(), sub_cloners.begin() + i0,
+                                 sub_cloners.begin() + i1);
+            ToGpuClonerMultiple cm(sub_cloners_2, *this);
+            IndexFlatL2 idxc (pq.dsub);
+            idxc.add (pq.ksub, pq.centroids.data() + m * pq.d * pq.ksub);
+            Index *idx2 = cm.clone_Index(&idxc);
+            splitv->add_sub_index(idx2);
+        }
+        return splitv;
+    } else {
+        return Cloner::clone_Index(index);
+    }
+}
+
+
+
+faiss::Index * index_cpu_to_gpu_multiple(
+       std::vector<GpuResources*> & resources,
+       std::vector<int> &devices,
+       const faiss::Index *index,
+       const GpuMultipleClonerOptions *options)
+{
+    GpuMultipleClonerOptions defaults;
+    ToGpuClonerMultiple cl(resources, devices, options ? *options : defaults);
+    return cl.clone_Index(index);
+}
+
+} } // namespace