faiss 0.1.3 → 0.2.0

data/vendor/faiss/faiss/gpu/impl/InterleavedCodes.h

@@ -0,0 +1,51 @@
+/**
+ * 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 <stdint.h>
+#include <vector>
+
+// Utilities for bit packing and unpacking CPU non-interleaved and GPU
+// interleaved by 32 encodings
+namespace faiss { namespace gpu {
+
+// Unpacks arbitrary bitwidth codes to a whole number of bytes per code
+// The layout of the input is (v0 d0)(v0 d1) ... (v0 dD)(v1 d0) ...
+// (bit packed)
+// The layout of the output is the same (byte packed to roundUp(bitsPerCode, 8)
+// / 8 bytes)
+std::vector<uint8_t> unpackNonInterleaved(std::vector<uint8_t> data,
+                                          int numVecs,
+                                          int dims,
+                                          int bitsPerCode);
+
+// Unpacks arbitrary bitwidth codes to a whole number of bytes per scalar code
+// The layout of the input is (v0 d0)(v1 d0) ... (v31 d0)(v0 d1) ...
+// (bit packed)
+// The layout of the input is (v0 d0)(v0 d1) ... (v0 dD)(v1 d0) ...
+// (byte packed)
+std::vector<uint8_t> unpackInterleaved(std::vector<uint8_t> data,
+                                       int numVecs,
+                                       int dims,
+                                       int bitsPerCode);
+
+// Packs data in the byte packed non-interleaved form to bit packed
+// non-interleaved form
+std::vector<uint8_t> packNonInterleaved(std::vector<uint8_t> data,
+                                        int numVecs,
+                                        int dims,
+                                        int bitsPerCode);
+
+// Packs data in the byte packed non-interleaved form to bit packed
+// interleaved form
+std::vector<uint8_t> packInterleaved(std::vector<uint8_t> data,
+                                     int numVecs,
+                                     int dims,
+                                     int bitsPerCode);
+
+} } // namespace

data/vendor/faiss/faiss/gpu/impl/RemapIndices.cpp

@@ -14,17 +14,17 @@ namespace faiss { namespace gpu {
 // Utility function to translate (list id, offset) to a user index on
 // the CPU. In a cpp in order to use OpenMP
 void ivfOffsetToUserIndex(
-  long* indices,
+  Index::idx_t* indices,
   int numLists,
   int queries,
   int k,
-  const std::vector<std::vector<long>>& listOffsetToUserIndex) {
+  const std::vector<std::vector<Index::idx_t>>& listOffsetToUserIndex) {
   FAISS_ASSERT(numLists == listOffsetToUserIndex.size());
 
 #pragma omp parallel for
   for (int q = 0; q < queries; ++q) {
     for (int r = 0; r < k; ++r) {
-      long offsetIndex = indices[q * k + r];
+      auto offsetIndex = indices[q * k + r];
 
       if (offsetIndex < 0) continue;
 

data/vendor/faiss/faiss/gpu/impl/RemapIndices.h

@@ -8,6 +8,7 @@
 
 #pragma once
 
+#include <faiss/Index.h>
 #include <vector>
 
 namespace faiss { namespace gpu {
@@ -15,10 +16,10 @@ namespace faiss { namespace gpu {
 /// Utility function to translate (list id, offset) to a user index on
 /// the CPU. In a cpp in order to use OpenMP.
 void ivfOffsetToUserIndex(
-  long* indices,
+  Index::idx_t* indices,
   int numLists,
   int queries,
   int k,
-  const std::vector<std::vector<long>>& listOffsetToUserIndex);
+  const std::vector<std::vector<Index::idx_t>>& listOffsetToUserIndex);
 
 } } // namespace

data/vendor/faiss/faiss/gpu/test/TestCodePacking.cpp

@@ -0,0 +1,274 @@
+/**
+ * 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/impl/InterleavedCodes.h>
+#include <faiss/gpu/utils/StaticUtils.h>
+#include <faiss/gpu/test/TestUtils.h>
+#include <cmath>
+#include <gtest/gtest.h>
+#include <random>
+#include <sstream>
+#include <vector>
+
+TEST(TestCodePacking, NonInterleavedCodes_UnpackPack) {
+  using namespace faiss::gpu;
+
+  // We are fine using non-fixed seeds here, the results should be fully
+  // deterministic
+  auto seed = std::random_device()();
+  std::mt19937 gen(seed);
+  std::uniform_int_distribution<uint8_t> dist;
+
+  std::cout << "seed " << seed << "\n";
+
+  for (auto bitsPerCode : {4, 5, 6, 8, 16, 32}) {
+    for (auto dims : {1, 7, 8, 31, 32}) {
+      for (auto numVecs : {1, 3, 4, 5, 6, 8, 31, 32, 33, 65}) {
+        std::cout << bitsPerCode << " " << dims << " " << numVecs << "\n";
+
+        int srcVecSize = utils::divUp(dims * bitsPerCode, 8);
+        std::vector<uint8_t> data(numVecs * srcVecSize);
+
+        for (auto& v : data) {
+          v = dist(gen);
+        }
+
+        // currently unimplemented
+        EXPECT_FALSE(bitsPerCode > 8 && bitsPerCode % 8 != 0);
+
+        // Due to bit packing, mask out bits that should be zero based on
+        // dimensions we shouldn't have present
+        int vectorSizeBits = dims * bitsPerCode;
+        int vectorSizeBytes = utils::divUp(vectorSizeBits, 8);
+        int remainder = vectorSizeBits % 8;
+
+        if (remainder > 0) {
+          uint8_t mask = 0xff >> (8 - remainder);
+
+          for (int i = 0; i < numVecs; ++i) {
+            int lastVecByte = (i + 1) * vectorSizeBytes - 1;
+            data[lastVecByte] &= mask;
+          }
+        }
+
+        auto up = unpackNonInterleaved(data, numVecs, dims, bitsPerCode);
+        auto p = packNonInterleaved(up, numVecs, dims, bitsPerCode);
+
+        EXPECT_EQ(data, p);
+      }
+    }
+  }
+}
+
+TEST(TestCodePacking, NonInterleavedCodes_PackUnpack) {
+  using namespace faiss::gpu;
+
+  // We are fine using non-fixed seeds here, the results should be fully
+  // deterministic
+  std::random_device rd;
+  std::mt19937 gen(rd());
+  std::uniform_int_distribution<uint8_t> dist;
+
+  for (auto bitsPerCode : {4, 5, 6, 8, 16, 32}) {
+    for (auto dims : {1, 7, 8, 31, 32}) {
+      for (auto numVecs : {1, 3, 4, 5, 6, 8, 31, 32, 33, 65}) {
+        std::cout << bitsPerCode << " " << dims << " " << numVecs << "\n";
+
+        std::vector<uint8_t> data(numVecs * dims * utils::divUp(bitsPerCode, 8));
+
+        // currently unimplemented
+        EXPECT_FALSE(bitsPerCode > 8 && bitsPerCode % 8 != 0);
+
+        // Mask out high bits we shouldn't have based on code size
+        uint8_t mask = bitsPerCode < 8 ? (0xff >> (8 - bitsPerCode)) : 0xff;
+
+        for (auto& v : data) {
+          v = dist(gen) & mask;
+        }
+
+        auto p = packNonInterleaved(data, numVecs, dims, bitsPerCode);
+        auto up = unpackNonInterleaved(p, numVecs, dims, bitsPerCode);
+
+        EXPECT_EQ(data, up);
+      }
+    }
+  }
+}
+
+TEST(TestCodePacking, InterleavedCodes_UnpackPack) {
+  using namespace faiss::gpu;
+
+  // We are fine using non-fixed seeds here, the results should be fully
+  // deterministic
+  std::random_device rd;
+  std::mt19937 gen(rd());
+  std::uniform_int_distribution<uint8_t> dist;
+
+  for (auto bitsPerCode : {4, 5, 6, 8, 16, 32}) {
+    for (auto dims : {1, 7, 8, 31, 32}) {
+      for (auto numVecs : {1, 3, 4, 5, 6, 8, 31, 32, 33, 65}) {
+        std::cout << bitsPerCode << " " << dims << " " << numVecs << "\n";
+
+        int blocks = utils::divUp(numVecs, 32);
+        int bytesPerDimBlock = 32 * bitsPerCode / 8;
+        int bytesPerBlock = bytesPerDimBlock * dims;
+        int size = blocks * bytesPerBlock;
+
+        std::vector<uint8_t> data(size);
+
+        if (bitsPerCode == 8 || bitsPerCode == 16 || bitsPerCode == 32) {
+          int bytesPerCode = bitsPerCode / 8;
+
+          for (int i = 0; i < blocks; ++i) {
+            for (int j = 0; j < dims; ++j) {
+              for (int k = 0; k < 32; ++k) {
+                for (int l = 0; l < bytesPerCode; ++l) {
+                  int vec = i * 32 + k;
+                  if (vec < numVecs) {
+                    data[i * bytesPerBlock +
+                         j * bytesPerDimBlock +
+                         k * bytesPerCode + l] = dist(gen);
+                  }
+                }
+              }
+            }
+          }
+        } else if (bitsPerCode < 8) {
+          for (int i = 0; i < blocks; ++i) {
+            for (int j = 0; j < dims; ++j) {
+              for (int k = 0; k < bytesPerDimBlock; ++k) {
+                int loVec = i * 32 + (k * 8) / bitsPerCode;
+                int hiVec = loVec + 1;
+                int hiVec2 = hiVec + 1;
+
+                uint8_t lo = loVec < numVecs ?
+                  dist(gen) & (0xff >> (8 - bitsPerCode)) : 0;
+                uint8_t hi = hiVec < numVecs ?
+                  dist(gen) & (0xff >> (8 - bitsPerCode)) : 0;
+                uint8_t hi2 = hiVec2 < numVecs ?
+                  dist(gen) & (0xff >> (8 - bitsPerCode)) : 0;
+
+                uint8_t v = 0;
+                if (bitsPerCode == 4) {
+                  v = lo | (hi << 4);
+                } else if (bitsPerCode == 5) {
+                  switch (k % 5) {
+                    case 0:
+                      // 5 msbs of lower as vOut lsbs
+                      // 3 lsbs of upper as vOut msbs
+                      v = (lo & 0x1f) | (hi << 5);
+                      break;
+                    case 1:
+                      // 2 msbs of lower as vOut lsbs
+                      // 5 lsbs of upper as vOut msbs
+                      // 1 lsbs of upper2 as vOut msb
+                      v = (lo >> 3) | (hi << 2) | (hi2 << 7);
+                      break;
+                    case 2:
+                      // 4 msbs of lower as vOut lsbs
+                      // 4 lsbs of upper as vOut msbs
+                      v = (lo >> 1) | (hi << 4);
+                      break;
+                    case 3:
+                      // 1 msbs of lower as vOut lsbs
+                      // 5 lsbs of upper as vOut msbs
+                      // 2 lsbs of upper2 as vOut msb
+                      v = (lo >> 4) | (hi << 1) | (hi2 << 6);
+                      break;
+                    case 4:
+                      // 3 msbs of lower as vOut lsbs
+                      // 5 lsbs of upper as vOut msbs
+                      v = (lo >> 2) | (hi << 3);
+                      break;
+                  }
+                } else if (bitsPerCode == 6) {
+                  switch (k % 3) {
+                    case 0:
+                      // 6 msbs of lower as vOut lsbs
+                      // 2 lsbs of upper as vOut msbs
+                      v = (lo & 0x3f) | (hi << 6);
+                      break;
+                    case 1:
+                      // 4 msbs of lower as vOut lsbs
+                      // 4 lsbs of upper as vOut msbs
+                      v = (lo >> 2) | (hi << 4);
+                      break;
+                    case 2:
+                      // 2 msbs of lower as vOut lsbs
+                      // 6 lsbs of upper as vOut msbs
+                      v = (lo >> 4) | (hi << 2);
+                      break;
+                  }
+                } else {
+                  // unimplemented
+                  EXPECT_TRUE(false);
+                }
+
+                data[i * bytesPerBlock + j * bytesPerDimBlock + k] = v;
+              }
+            }
+          }
+        } else {
+          // unimplemented
+          EXPECT_TRUE(false);
+        }
+
+        auto up = unpackInterleaved(data, numVecs, dims, bitsPerCode);
+        auto p = packInterleaved(up, numVecs, dims, bitsPerCode);
+
+        EXPECT_EQ(data, p);
+      }
+    }
+  }
+}
+
+TEST(TestCodePacking, InterleavedCodes_PackUnpack) {
+  using namespace faiss::gpu;
+
+  // We are fine using non-fixed seeds here, the results should be fully
+  // deterministic
+  std::random_device rd;
+  std::mt19937 gen(rd());
+  std::uniform_int_distribution<uint8_t> dist;
+
+  for (auto bitsPerCode : {4, 5, 6, 8, 16, 32}) {
+    for (auto dims : {1, 7, 8, 31, 32}) {
+      for (auto numVecs : {1, 3, 4, 5, 6, 8, 31, 32, 33, 65}) {
+        std::cout << bitsPerCode << " " << dims << " " << numVecs << "\n";
+
+        std::vector<uint8_t> data(numVecs * dims * utils::divUp(bitsPerCode, 8));
+
+        if (bitsPerCode == 8 || bitsPerCode == 16 || bitsPerCode == 32) {
+          for (auto& v : data) {
+            v = dist(gen);
+          }
+        } else if (bitsPerCode < 8) {
+          uint8_t mask = 0xff >> (8 - bitsPerCode);
+
+          for (auto& v : data) {
+            v = dist(gen) & mask;
+          }
+        } else {
+          // unimplemented
+          EXPECT_TRUE(false);
+        }
+
+        auto p = packInterleaved(data, numVecs, dims, bitsPerCode);
+        auto up = unpackInterleaved(p, numVecs, dims, bitsPerCode);
+
+        EXPECT_EQ(data, up);
+      }
+    }
+  }
+}
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+
+  return RUN_ALL_TESTS();
+}

data/vendor/faiss/faiss/gpu/test/TestGpuIndexIVFFlat.cpp

@@ -206,6 +206,8 @@ void copyToTest(bool useFloat16CoarseQuantizer) {
   EXPECT_EQ(cpuIndex.nlist, gpuIndex.getNumLists());
   EXPECT_EQ(cpuIndex.nprobe, gpuIndex.getNumProbes());
 
+  testIVFEquality(cpuIndex, gpuIndex);
+
   // Query both objects; results should be equivalent
   bool compFloat16 = useFloat16CoarseQuantizer;
   faiss::gpu::compareIndices(cpuIndex, gpuIndex,
@@ -255,6 +257,8 @@ void copyFromTest(bool useFloat16CoarseQuantizer) {
   EXPECT_EQ(cpuIndex.nlist, gpuIndex.getNumLists());
   EXPECT_EQ(cpuIndex.nprobe, gpuIndex.getNumProbes());
 
+  testIVFEquality(cpuIndex, gpuIndex);
+
   // Query both objects; results should be equivalent
   bool compFloat16 = useFloat16CoarseQuantizer;
   faiss::gpu::compareIndices(cpuIndex, gpuIndex,
@@ -466,9 +470,10 @@ TEST(TestGpuIndexIVFFlat, AddNaN) {
   std::vector<float> nans(numNans * opt.dim,
                           std::numeric_limits<float>::quiet_NaN());
 
-  // Make one vector valid, which should actually add
+  // Make one vector valid (not the first vector, in order to test offset
+  // issues), which should actually add
   for (int i = 0; i < opt.dim; ++i) {
-    nans[i] = 0.0f;
+    nans[opt.dim + i] = i;
   }
 
   std::vector<float> trainVecs = faiss::gpu::randVecs(opt.numTrain, opt.dim);

data/vendor/faiss/faiss/gpu/test/TestGpuIndexIVFPQ.cpp

@@ -426,6 +426,8 @@ TEST(TestGpuIndexIVFPQ, CopyTo) {
     EXPECT_EQ(cpuIndex.pq.nbits, gpuIndex.getBitsPerCode());
     EXPECT_EQ(gpuIndex.getBitsPerCode(), opt.bitsPerCode);
 
+    testIVFEquality(cpuIndex, gpuIndex);
+
     // Query both objects; results should be equivalent
     faiss::gpu::compareIndices(cpuIndex, gpuIndex,
                                opt.numQuery, opt.dim, opt.k, opt.toString(),
@@ -458,7 +460,7 @@ TEST(TestGpuIndexIVFPQ, CopyFrom) {
 
   // Use garbage values to see if we overwrite them
   faiss::gpu::GpuIndexIVFPQ
-    gpuIndex(&res, 1, 1, 1, 1, faiss::METRIC_L2, config);
+    gpuIndex(&res, 1, 1, 1, 8, faiss::METRIC_L2, config);
   gpuIndex.setNumProbes(1);
 
   gpuIndex.copyFrom(&cpuIndex);
@@ -476,6 +478,8 @@ TEST(TestGpuIndexIVFPQ, CopyFrom) {
   EXPECT_EQ(cpuIndex.pq.nbits, gpuIndex.getBitsPerCode());
   EXPECT_EQ(gpuIndex.getBitsPerCode(), opt.bitsPerCode);
 
+  testIVFEquality(cpuIndex, gpuIndex);
+
   // Query both objects; results should be equivalent
   faiss::gpu::compareIndices(cpuIndex, gpuIndex,
                              opt.numQuery, opt.dim, opt.k, opt.toString(),

data/vendor/faiss/faiss/gpu/test/TestGpuIndexIVFScalarQuantizer.cpp

@@ -0,0 +1,231 @@
+/**
+ * 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/IndexFlat.h>
+#include <faiss/IndexScalarQuantizer.h>
+#include <faiss/gpu/GpuIndexIVFScalarQuantizer.h>
+#include <faiss/gpu/StandardGpuResources.h>
+#include <faiss/gpu/utils/DeviceUtils.h>
+#include <faiss/gpu/test/TestUtils.h>
+#include <cmath>
+#include <gtest/gtest.h>
+#include <sstream>
+#include <vector>
+
+constexpr float kF32MaxRelErr = 0.03f;
+
+struct Options {
+  Options() {
+    numAdd = 2 * faiss::gpu::randVal(2000, 5000);
+    dim = faiss::gpu::randVal(64, 200);
+
+    numCentroids = std::sqrt((float) numAdd / 2);
+    numTrain = numCentroids * 40;
+    nprobe = faiss::gpu::randVal(std::min(10, numCentroids), numCentroids);
+    numQuery = faiss::gpu::randVal(32, 100);
+
+    // Due to the approximate nature of the query and of floating point
+    // differences between GPU and CPU, to stay within our error bounds, only
+    // use a small k
+    k = std::min(faiss::gpu::randVal(10, 30), numAdd / 40);
+    indicesOpt = faiss::gpu::randSelect({
+        faiss::gpu::INDICES_CPU,
+        faiss::gpu::INDICES_32_BIT,
+        faiss::gpu::INDICES_64_BIT});
+
+    device = faiss::gpu::randVal(0, faiss::gpu::getNumDevices() - 1);
+  }
+
+  std::string toString() const {
+    std::stringstream str;
+    str << "IVFFlat device " << device
+        << " numVecs " << numAdd
+        << " dim " << dim
+        << " numCentroids " << numCentroids
+        << " nprobe " << nprobe
+        << " numQuery " << numQuery
+        << " k " << k
+        << " indicesOpt " << indicesOpt;
+
+    return str.str();
+  }
+
+  int numAdd;
+  int dim;
+  int numCentroids;
+  int numTrain;
+  int nprobe;
+  int numQuery;
+  int k;
+  int device;
+  faiss::gpu::IndicesOptions indicesOpt;
+};
+
+void runCopyToTest(faiss::ScalarQuantizer::QuantizerType qtype) {
+  using namespace faiss;
+  using namespace faiss::gpu;
+
+  Options opt;
+  std::vector<float> trainVecs = randVecs(opt.numTrain, opt.dim);
+  std::vector<float> addVecs = randVecs(opt.numAdd, opt.dim);
+
+  StandardGpuResources res;
+  res.noTempMemory();
+
+  auto config = GpuIndexIVFScalarQuantizerConfig();
+  config.device = opt.device;
+
+  GpuIndexIVFScalarQuantizer gpuIndex(&res,
+                                      opt.dim,
+                                      opt.numCentroids,
+                                      qtype,
+                                      METRIC_L2,
+                                      true,
+                                      config);
+  gpuIndex.train(opt.numTrain, trainVecs.data());
+  gpuIndex.add(opt.numAdd, addVecs.data());
+  gpuIndex.setNumProbes(opt.nprobe);
+
+  // use garbage values to see if we overwrite then
+  IndexFlatL2 cpuQuantizer(1);
+  IndexIVFScalarQuantizer cpuIndex(&cpuQuantizer, 1, 1,
+                                   ScalarQuantizer::QuantizerType::QT_6bit,
+                                   METRIC_L2);
+  cpuIndex.nprobe = 1;
+
+  gpuIndex.copyTo(&cpuIndex);
+
+  EXPECT_EQ(cpuIndex.ntotal, gpuIndex.ntotal);
+  EXPECT_EQ(gpuIndex.ntotal, opt.numAdd);
+
+  EXPECT_EQ(cpuIndex.d, gpuIndex.d);
+  EXPECT_EQ(cpuIndex.quantizer->d, gpuIndex.quantizer->d);
+  EXPECT_EQ(cpuIndex.d, opt.dim);
+  EXPECT_EQ(cpuIndex.nlist, gpuIndex.getNumLists());
+  EXPECT_EQ(cpuIndex.nprobe, gpuIndex.getNumProbes());
+
+  testIVFEquality(cpuIndex, gpuIndex);
+
+  // Query both objects; results should be equivalent
+  compareIndices(cpuIndex, gpuIndex,
+                 opt.numQuery, opt.dim, opt.k, opt.toString(),
+                 kF32MaxRelErr,
+                 0.1f,
+                 0.015f);
+}
+
+TEST(TestGpuIndexIVFScalarQuantizer, CopyTo_fp16) {
+  runCopyToTest(faiss::ScalarQuantizer::QuantizerType::QT_fp16);
+}
+
+TEST(TestGpuIndexIVFScalarQuantizer, CopyTo_8bit) {
+  runCopyToTest(faiss::ScalarQuantizer::QuantizerType::QT_8bit);
+}
+
+TEST(TestGpuIndexIVFScalarQuantizer, CopyTo_8bit_uniform) {
+  runCopyToTest(faiss::ScalarQuantizer::QuantizerType::QT_8bit_uniform);
+}
+
+TEST(TestGpuIndexIVFScalarQuantizer, CopyTo_6bit) {
+  runCopyToTest(faiss::ScalarQuantizer::QuantizerType::QT_6bit);
+}
+
+TEST(TestGpuIndexIVFScalarQuantizer, CopyTo_4bit) {
+  runCopyToTest(faiss::ScalarQuantizer::QuantizerType::QT_4bit);
+}
+
+TEST(TestGpuIndexIVFScalarQuantizer, CopyTo_4bit_uniform) {
+  runCopyToTest(faiss::ScalarQuantizer::QuantizerType::QT_4bit_uniform);
+}
+
+void runCopyFromTest(faiss::ScalarQuantizer::QuantizerType qtype) {
+  using namespace faiss;
+  using namespace faiss::gpu;
+
+  Options opt;
+  std::vector<float> trainVecs = randVecs(opt.numTrain, opt.dim);
+  std::vector<float> addVecs = randVecs(opt.numAdd, opt.dim);
+
+  IndexFlatL2 cpuQuantizer(opt.dim);
+  IndexIVFScalarQuantizer cpuIndex(&cpuQuantizer, opt.dim, opt.numCentroids,
+                                   qtype,
+                                   METRIC_L2);
+
+  cpuIndex.nprobe = opt.nprobe;
+  cpuIndex.train(opt.numTrain, trainVecs.data());
+  cpuIndex.add(opt.numAdd, addVecs.data());
+
+  // use garbage values to see if we overwrite then
+  StandardGpuResources res;
+  res.noTempMemory();
+
+  auto config = GpuIndexIVFScalarQuantizerConfig();
+  config.device = opt.device;
+
+  GpuIndexIVFScalarQuantizer gpuIndex(
+    &res,
+    1,
+    1,
+    ScalarQuantizer::QuantizerType::QT_4bit,
+    METRIC_L2,
+    false,
+    config);
+  gpuIndex.setNumProbes(1);
+
+  gpuIndex.copyFrom(&cpuIndex);
+
+  EXPECT_EQ(cpuIndex.ntotal, gpuIndex.ntotal);
+  EXPECT_EQ(gpuIndex.ntotal, opt.numAdd);
+
+  EXPECT_EQ(cpuIndex.d, gpuIndex.d);
+  EXPECT_EQ(cpuIndex.d, opt.dim);
+  EXPECT_EQ(cpuIndex.nlist, gpuIndex.getNumLists());
+  EXPECT_EQ(cpuIndex.nprobe, gpuIndex.getNumProbes());
+
+  testIVFEquality(cpuIndex, gpuIndex);
+
+  // Query both objects; results should be equivalent
+  compareIndices(cpuIndex, gpuIndex,
+                 opt.numQuery, opt.dim, opt.k, opt.toString(),
+                 kF32MaxRelErr,
+                 0.1f,
+                 0.015f);
+}
+
+TEST(TestGpuIndexIVFScalarQuantizer, CopyFrom_fp16) {
+  runCopyFromTest(faiss::ScalarQuantizer::QuantizerType::QT_fp16);
+}
+
+TEST(TestGpuIndexIVFScalarQuantizer, CopyFrom_8bit) {
+  runCopyFromTest(faiss::ScalarQuantizer::QuantizerType::QT_8bit);
+}
+
+TEST(TestGpuIndexIVFScalarQuantizer, CopyFrom_8bit_uniform) {
+  runCopyFromTest(faiss::ScalarQuantizer::QuantizerType::QT_8bit_uniform);
+}
+
+TEST(TestGpuIndexIVFScalarQuantizer, CopyFrom_6bit) {
+  runCopyFromTest(faiss::ScalarQuantizer::QuantizerType::QT_6bit);
+}
+
+TEST(TestGpuIndexIVFScalarQuantizer, CopyFrom_4bit) {
+  runCopyFromTest(faiss::ScalarQuantizer::QuantizerType::QT_4bit);
+}
+
+TEST(TestGpuIndexIVFScalarQuantizer, CopyFrom_4bit_uniform) {
+  runCopyFromTest(faiss::ScalarQuantizer::QuantizerType::QT_4bit_uniform);
+}
+
+int main(int argc, char** argv) {
+  testing::InitGoogleTest(&argc, argv);
+
+  // just run with a fixed test seed
+  faiss::gpu::setTestSeed(100);
+
+  return RUN_ALL_TESTS();
+}