Merge remote-tracking branch 'origin/develop'

Author: searchivarius

python_vect_bindings/nmslib_vector.cc

@@ -260,15 +260,18 @@ class IndexWrapper {
  }
 
  PyObject* KnnQuery(int k, const Object* query) {
+ IntVector ids;
+Py_BEGIN_ALLOW_THREADS
+ KNNQueue<T>* res;
  KNNQuery<T> knn(*space_, query, k);
  index_->Search(&knn, -1);
- KNNQueue<T>* res = knn.Result()->Clone();
- IntVector ids;
+ res = knn.Result()->Clone();
  while (!res->Empty()) {
  ids.insert(ids.begin(), res->TopObject()->id());
  res->Pop();
  }
  delete res;
+Py_END_ALLOW_THREADS
  PyObject* z = PyList_New(ids.size());
  if (!z) {
  return NULL;
@@ -386,7 +389,9 @@ template <typename T>
 void _createIndex(PyObject* ptr, const AnyParams& index_params) {
  IndexWrapper<T>* index = reinterpret_cast<IndexWrapper<T>*>(
  PyLong_AsVoidPtr(ptr));
+Py_BEGIN_ALLOW_THREADS
  index->CreateIndex(index_params);
+Py_END_ALLOW_THREADS
 }
 
 PyObject* createIndex(PyObject* self, PyObject* args) {

similarity_search/include/distcomp.h

@@ -64,14 +64,30 @@ template <class T> T AngularDistance(const T *p1, const T *p2, size_t qty);
 template <class T> T CosineSimilarity(const T *p1, const T *p2, size_t qty);
 // Scalar product divided by vector Euclidean norms
 template <class T> T NormScalarProduct(const T *p1, const T *p2, size_t qty);
+// Sclar product divided by query vector Euclidean norm
+// Query is the second argument (by convention we use only left queries, where a data point is the left argument)
+// We don't have a SIMD version for QueryNormScalarProduct function yet.
+template <class T> T QueryNormScalarProduct(const T *p1, const T *p2, size_t qty);
 template <class T> T NormScalarProductSIMD(const T *p1, const T *p2, size_t qty);
 
 // Scalar product that is not normalized 
 template <class T> T ScalarProduct(const T *p1, const T *p2, size_t qty);
 template <class T> T ScalarProductSIMD(const T *p1, const T *p2, size_t qty);
 
-// Fast scalar product between sparse vectors (using SIMD)
-float ScalarProductFast(const char* pData1, size_t len1, const char* pData2, size_t len2);
+// Fast normalized-scalar product between sparse vectors (using SIMD)
+float NormSparseScalarProductFast(const char* pData1, size_t len1, const char* pData2, size_t len2);
+/*
+ * Fast query-side normalized-scalar product between sparse vectors (using SIMD).
+ * By our standard convention of using left queries, the query is the right argument.
+ */
+float QueryNormSparseScalarProductFast(const char* pData, size_t lenData, const char* pQuery, size_t lenQuery);
+// Fast scalar product between sparse vectors without normalization (using SIMD)
+float SparseScalarProductFast(const char* pData1, size_t len1, const char* pData2, size_t len2);
+
+/*
+ * Sometimes due to rounding errors, we get values > 1 or < -1.
+ * This throws off other functions that use scalar product, e.g., acos
+ */
 
 /*
  * Itakura-Saito distance

similarity_search/include/factory/init_spaces.h

@@ -113,10 +113,13 @@ inline void initSpaces() {
  REGISTER_SPACE_CREATOR(double, SPACE_SPARSE_COSINE_SIMILARITY, CreateSparseCosineSimilarity)
  REGISTER_SPACE_CREATOR(float, SPACE_SPARSE_ANGULAR_DISTANCE, CreateSparseAngularDistance)
  REGISTER_SPACE_CREATOR(double, SPACE_SPARSE_ANGULAR_DISTANCE, CreateSparseAngularDistance)
+ REGISTER_SPACE_CREATOR(float, SPACE_SPARSE_NEGATIVE_SCALAR, CreateSparseNegativeScalarProduct)
+ REGISTER_SPACE_CREATOR(double, SPACE_SPARSE_QUERY_NORM_NEGATIVE_SCALAR, CreateSparseQueryNormNegativeScalarProduct)
 
  REGISTER_SPACE_CREATOR(float, SPACE_SPARSE_COSINE_SIMILARITY_FAST, CreateSparseCosineSimilarityFast)
  REGISTER_SPACE_CREATOR(float, SPACE_SPARSE_ANGULAR_DISTANCE_FAST, CreateSparseAngularDistanceFast)
-
+ REGISTER_SPACE_CREATOR(float, SPACE_SPARSE_NEGATIVE_SCALAR_FAST, CreateSparseNegativeScalarProductFast)
+ REGISTER_SPACE_CREATOR(float, SPACE_SPARSE_QUERY_NORM_NEGATIVE_SCALAR_FAST, CreateSparseQueryNormNegativeScalarProductFast)
 
  REGISTER_SPACE_CREATOR(float, "savch", CreateSavch)
 

similarity_search/include/factory/space/space_sparse_scalar.h

@@ -26,6 +26,8 @@ namespace similarity {
  * Creating functions.
  */
 
+/* Regular sparse spaces */
+
 template <typename dist_t>
 Space<dist_t>* CreateSparseCosineSimilarity(const AnyParams& /* ignoring params */) {
  // Cosine Similarity
@@ -39,12 +41,36 @@ Space<dist_t>* CreateSparseAngularDistance(const AnyParams& /* ignoring params *
  return new SpaceSparseAngularDistance<dist_t>();
 }
 
+template <typename dist_t>
+Space<dist_t>* CreateSparseNegativeScalarProduct(const AnyParams& /* ignoring params */) {
+ // Cosine Similarity
+ return new SpaceSparseNegativeScalarProduct<dist_t>();
+}
+
+template <typename dist_t>
+Space<dist_t>* CreateSparseQueryNormNegativeScalarProduct(const AnyParams& /* ignoring params */) {
+ // Cosine Similarity
+ return new SpaceSparseQueryNormNegativeScalarProduct<dist_t>();
+}
+
+/* Fast sparse spaces */
+
 Space<float>* CreateSparseCosineSimilarityFast(const AnyParams& /* ignoring params */) {
  // Cosine Similarity
  return new SpaceSparseCosineSimilarityFast();
 }
 
 
+Space<float>* CreateSparseNegativeScalarProductFast(const AnyParams& /* ignoring params */) {
+ // Cosine Similarity
+ return new SpaceSparseNegativeScalarProductFast();
+}
+
+Space<float>* CreateSparseQueryNormNegativeScalarProductFast(const AnyParams& /* ignoring params */) {
+ // Cosine Similarity
+ return new SpaceSparseQueryNormNegativeScalarProductFast();
+}
+
 Space<float>* CreateSparseAngularDistanceFast(const AnyParams& /* ignoring params */) {
  // Cosine Similarity
  return new SpaceSparseAngularDistanceFast();

similarity_search/include/gold_standard.h

@@ -234,7 +234,7 @@ class GoldStandardManager {
  // if maxKeepEntryCoeff is non-zero, it defines how many GS entries (relative to the result set size) we memorize
  void Compute(size_t threadQty, float maxKeepEntryCoeff) {
  threadQty = std::max(size_t(1), threadQty);
- LOG(LIB_INFO) << "Computing gold standard data using " << threadQty << " threads, keeping " << maxKeepEntryCoeff<< " times result set size entries";;
+ LOG(LIB_INFO) << "Computing gold standard data using " << threadQty << " threads, keeping " << maxKeepEntryCoeff<< "x entries compared to the result set size";;
  for (size_t i = 0; i < config_.GetRange().size(); ++i) {
  vvGoldStandardRange_[i].clear();
  const dist_t radius = config_.GetRange()[i];

similarity_search/include/logging.h

@@ -69,7 +69,6 @@ class RuntimeErrorWrapper {
 #define LOG(severity) \
  Logger(severity, __FILE__, __LINE__, __FUNCTION__).stream()
 
-
 #define CHECK(condition) \
  if (!(condition)) {\
  LOG(LIB_ERROR) << "Check failed: " << #condition; \

similarity_search/include/simdutils.h

@@ -50,6 +50,17 @@
 #define MM_EXTRACT_DOUBLE(v,i) _mm_cvtsd_f64(_mm_shuffle_pd(v, v, _MM_SHUFFLE2(0, i)))
 #define MM_EXTRACT_FLOAT(v,i) _mm_cvtss_f32(_mm_shuffle_ps(v, v, _MM_SHUFFLE(0, 0, 0, i)))
 
+/*
+ * However, if we need to extract many numbers to sum the up, it is more efficient no
+ * not to use the above MM_EXTRACT_FLOAT (https://github.com/searchivarius/BlogCode/tree/master/2016/bench_sums)
+ * 
+ */
+inline float mm128_sum(__m128 reg) {
+ float PORTABLE_ALIGN16 TmpRes[4];
+ _mm_store_ps(TmpRes, reg);
+ return TmpRes[0] + TmpRes[1] + TmpRes[2] + TmpRes[3];
+};
+
 #endif
 
 #ifdef _MSC_VER

similarity_search/include/space/space_sparse_scalar.h

@@ -30,8 +30,10 @@
 #include "space_sparse_vector.h"
 #include "distcomp.h"
 
-#define SPACE_SPARSE_COSINE_SIMILARITY "cosinesimil_sparse"
-#define SPACE_SPARSE_ANGULAR_DISTANCE "angulardist_sparse"
+#define SPACE_SPARSE_COSINE_SIMILARITY "cosinesimil_sparse"
+#define SPACE_SPARSE_ANGULAR_DISTANCE "angulardist_sparse"
+#define SPACE_SPARSE_NEGATIVE_SCALAR "negdotprod_sparse"
+#define SPACE_SPARSE_QUERY_NORM_NEGATIVE_SCALAR "querynorm_negdotprod_sparse"
 
 namespace similarity {
 
@@ -54,7 +56,7 @@ class SpaceSparseAngularDistance : public SpaceSparseVectorSimpleStorage<dist_t>
  struct SpaceAngularDist {
  dist_t operator()(const dist_t* x, const dist_t* y, size_t length) const {
  dist_t val = AngularDistance(x, y, length);
- // TODO: @leo shouldn't happen any more, but let's keep this check here for a while
+ // This shouldn't normally happen, but let's keep this check
  if (std::isnan(val)) throw runtime_error("SpaceAngularDist Bug: NAN dist!!!!");
  return val;
  }
@@ -82,7 +84,7 @@ class SpaceSparseCosineSimilarity : public SpaceSparseVectorSimpleStorage<dist_t
  struct SpaceCosineSimilarityDist {
  dist_t operator()(const dist_t* x, const dist_t* y, size_t length) const {
  dist_t val = CosineSimilarity(x, y, length);
- // TODO: @leo shouldn't happen any more, but let's keep this check here for a while
+ // This shouldn't normally happen, but let's keep this check
  if (std::isnan(val)) throw runtime_error("SpaceCosineSimilarityDist Bug: NAN dist!!!!");
  return val;
  }
@@ -91,6 +93,59 @@ class SpaceSparseCosineSimilarity : public SpaceSparseVectorSimpleStorage<dist_t
  DISABLE_COPY_AND_ASSIGN(SpaceSparseCosineSimilarity);
 };
 
+template <typename dist_t>
+class SpaceSparseNegativeScalarProduct : public SpaceSparseVectorSimpleStorage<dist_t> {
+public:
+ explicit SpaceSparseNegativeScalarProduct() {}
+ virtual ~SpaceSparseNegativeScalarProduct() {}
+
+ virtual std::string StrDesc() const {
+ return "NegativeScalarProduct";
+ }
+
+protected:
+ virtual dist_t HiddenDistance(const Object* obj1, const Object* obj2) const {
+ return SpaceSparseVectorSimpleStorage<dist_t>::
+ ComputeDistanceHelper(obj1, obj2, distObjNegativeScalarProduct_);
+ }
+private:
+ struct SpaceNegativeScalarDist {
+ dist_t operator()(const dist_t* x, const dist_t* y, size_t length) const {
+ return -ScalarProductSIMD(x, y, length);
+ }
+ };
+ SpaceNegativeScalarDist distObjNegativeScalarProduct_;
+ DISABLE_COPY_AND_ASSIGN(SpaceSparseNegativeScalarProduct);
+};
+
+template <typename dist_t>
+class SpaceSparseQueryNormNegativeScalarProduct : public SpaceSparseVectorSimpleStorage<dist_t> {
+public:
+ explicit SpaceSparseQueryNormNegativeScalarProduct() {}
+ virtual ~SpaceSparseQueryNormNegativeScalarProduct() {}
+
+ virtual std::string StrDesc() const {
+ return "QueryNormNegativeScalarProduct";
+ }
+
+protected:
+ virtual dist_t HiddenDistance(const Object* obj1, const Object* obj2) const {
+ return SpaceSparseVectorSimpleStorage<dist_t>::
+ ComputeDistanceHelper(obj1, obj2, distObjQueryNormNegativeScalarProduct_);
+ }
+private:
+ struct SpaceNegativeQueryNormScalarDist {
+ dist_t operator()(const dist_t* x, const dist_t* y, size_t length) const {
+ // This shouldn't normally happen, but let's keep this check
+ dist_t val = QueryNormScalarProduct(x, y, length);
+ if (std::isnan(val)) throw runtime_error("SpaceNegativeQueryNormScalarDist Bug: NAN dist!!!!");
+ return -val;
+ }
+ };
+ SpaceNegativeQueryNormScalarDist distObjQueryNormNegativeScalarProduct_;
+ DISABLE_COPY_AND_ASSIGN(SpaceSparseQueryNormNegativeScalarProduct);
+};
+
 
 } // namespace similarity
 

similarity_search/include/space/space_sparse_scalar_fast.h

@@ -34,6 +34,10 @@
 #define SPACE_SPARSE_COSINE_SIMILARITY_FAST "cosinesimil_sparse_fast"
 #define SPACE_SPARSE_ANGULAR_DISTANCE_FAST "angulardist_sparse_fast"
 
+#define SPACE_SPARSE_NEGATIVE_SCALAR_FAST "negdotprod_sparse_fast"
+#define SPACE_SPARSE_QUERY_NORM_NEGATIVE_SCALAR_FAST "querynorm_negdotprod_sparse_fast"
+
+
 namespace similarity {
 
 class SpaceSparseCosineSimilarityFast : public SpaceSparseVectorInter<float> {
@@ -58,6 +62,28 @@ class SpaceSparseAngularDistanceFast : public SpaceSparseVectorInter<float> {
  DISABLE_COPY_AND_ASSIGN(SpaceSparseAngularDistanceFast);
 };
 
+class SpaceSparseNegativeScalarProductFast : public SpaceSparseVectorInter<float> {
+public:
+ explicit SpaceSparseNegativeScalarProductFast(){}
+ virtual std::string StrDesc() const {
+ return "NegativeScalarProduct (fast)";
+ }
+protected:
+ virtual float HiddenDistance(const Object* obj1, const Object* obj2) const;
+ DISABLE_COPY_AND_ASSIGN(SpaceSparseNegativeScalarProductFast);
+};
+
+class SpaceSparseQueryNormNegativeScalarProductFast : public SpaceSparseVectorInter<float> {
+public:
+ explicit SpaceSparseQueryNormNegativeScalarProductFast(){}
+ virtual std::string StrDesc() const {
+ return "QueryNormNegativeScalarProduct (fast)";
+ }
+protected:
+ virtual float HiddenDistance(const Object* obj1, const Object* obj2) const;
+ DISABLE_COPY_AND_ASSIGN(SpaceSparseQueryNormNegativeScalarProductFast);
+};
+
 
 } // namespace similarity
 

similarity_search/include/space/space_sparse_vector.h

@@ -107,7 +107,6 @@ class SpaceSparseVector : public Space<dist_t> {
  // Sparse vectors have no fixed dimensionality
  virtual size_t GetElemQty(const Object* object) const {return 0;}
 
- virtual dist_t ScalarProduct(const Object* obj1, const Object* obj2) const = 0;
 protected:
  void ReadSparseVec(std::string line, size_t line_num, IdType& label, vector<ElemType>& v) const;
  virtual void CreateVectFromObj(const Object* obj, vector<ElemType>& v) const = 0;
@@ -135,15 +134,10 @@ class SpaceSparseVectorSimpleStorage : public SpaceSparseVector<dist_t> {
  }
  }
 
- Object* CreateObjFromVect(IdType id, LabelType label, const vector<ElemType>& InpVect) const {
+ virtual Object* CreateObjFromVect(IdType id, LabelType label, const vector<ElemType>& InpVect) const override {
  return new Object(id, label, InpVect.size() * sizeof(ElemType), &InpVect[0]);
  };
 
- virtual dist_t ScalarProduct(const Object* obj1, const Object* obj2) const {
- SpaceNormScalarProduct distObjNormSP;
- return SpaceSparseVectorSimpleStorage<dist_t>::
- ComputeDistanceHelper(obj1, obj2, distObjNormSP);
- }
 protected:
  DISABLE_COPY_AND_ASSIGN(SpaceSparseVectorSimpleStorage);
 
@@ -156,13 +150,6 @@ class SpaceSparseVectorSimpleStorage : public SpaceSparseVector<dist_t> {
  for (size_t i = 0; i < qty; ++i) v[i] = beg[i];
  }
 
- struct SpaceNormScalarProduct {
- dist_t operator()(const dist_t* x, const dist_t* y, size_t length) const {
- return NormScalarProduct(x, y, length);
- }
- };
-
- 
  virtual dist_t HiddenDistance(const Object* obj1, const Object* obj2) const = 0;
 
  /*