deglib 0.2.4__tar.gz → 0.2.5__tar.gz

{deglib-0.2.4/src/deglib.egg-info → deglib-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deglib
-Version: 0.2.4
+Version: 0.2.5
 Summary: Python bindings for the Dynamic Exploration Graph library by Nico Hezel
 Author: Nico Hezel
 Author-email: Bruno Schilling <bruno.schilling@htw-berlin.de>

{deglib-0.2.4 → deglib-0.2.5}/lib/deglib/include/deglib/distance/fp32_ip.h

@@ -143,17 +143,20 @@ class InnerProductFloat_AVX512 {
             }
 
             if constexpr (HasDualSimd) {
-                const size_t nc16 = dim / 16;
-                offset = nc16 * 16;
+                const size_t nc32 = dim / 32;
+                offset = nc32 * 32;
 
-                for (size_t c = 0; c < nc16; ++c) {
-                    size_t idx = c * 16;
-                    __m512 q_vec = _mm512_loadu_ps(&query[idx]);
+                for (size_t c = 0; c < nc32; ++c) {
+                    size_t idx = c * 32;
+                    __m512 q_vec_lo = _mm512_loadu_ps(&query[idx]);
+                    __m512 q_vec_hi = _mm512_loadu_ps(&query[idx + 16]);
 
                     for (size_t j = 0; j < BATCH_SIZE; ++j) {
                         const float* db_ = static_cast<const float*>(db[j]);
-                        __m512 db_vec = _mm512_loadu_ps(&db_[idx]);
-                        s[j] = _mm512_fmadd_ps(q_vec, db_vec, s[j]);
+                        __m512 db_vec_lo = _mm512_loadu_ps(&db_[idx]);
+                        __m512 db_vec_hi = _mm512_loadu_ps(&db_[idx + 16]);
+                        s[j] = _mm512_fmadd_ps(q_vec_lo, db_vec_lo, s[j]);
+                        s[j] = _mm512_fmadd_ps(q_vec_hi, db_vec_hi, s[j]);
                     }
                 }
             }
@@ -265,17 +268,20 @@ class InnerProductFloat_AVX2 {
             }
 
             if constexpr (HasDualSimd) {
-                const size_t nc8 = dim / 8;
-                offset = nc8 * 8;
+                const size_t nc16 = dim / 16;
+                offset = nc16 * 16;
 
-                for (size_t c = 0; c < nc8; ++c) {
-                    size_t idx = c * 8;
-                    __m256 q_vec = _mm256_loadu_ps(&query[idx]);
+                for (size_t c = 0; c < nc16; ++c) {
+                    size_t idx = c * 16;
+                    __m256 q_vec_lo = _mm256_loadu_ps(&query[idx]);
+                    __m256 q_vec_hi = _mm256_loadu_ps(&query[idx + 8]);
 
                     for (size_t j = 0; j < BATCH_SIZE; ++j) {
                         const float* db_ = static_cast<const float*>(db[j]);
-                        __m256 db_vec = _mm256_loadu_ps(&db_[idx]);
-                        s[j] = _mm256_fmadd_ps(q_vec, db_vec, s[j]);
+                        __m256 db_vec_lo = _mm256_loadu_ps(&db_[idx]);
+                        __m256 db_vec_hi = _mm256_loadu_ps(&db_[idx + 8]);
+                        s[j] = _mm256_fmadd_ps(q_vec_lo, db_vec_lo, s[j]);
+                        s[j] = _mm256_fmadd_ps(q_vec_hi, db_vec_hi, s[j]);
                     }
                 }
             }

{deglib-0.2.4 → deglib-0.2.5}/lib/deglib/include/deglib/distance/fp32_l2.h

@@ -142,17 +142,20 @@ class L2Float_AVX512 {
             }
 
             if constexpr (HasDualSimd) {
-                const size_t nc16 = dim / 16;
-                offset = nc16 * 16;
+                const size_t nc32 = dim / 32;
+                offset = nc32 * 32;
 
-                for (size_t c = 0; c < nc16; ++c) {
-                    size_t idx = c * 16;
-                    __m512 q_vec = _mm512_loadu_ps(&query[idx]);
+                for (size_t c = 0; c < nc32; ++c) {
+                    size_t idx = c * 32;
+                    __m512 q_vec_lo = _mm512_loadu_ps(&query[idx]);
+                    __m512 q_vec_hi = _mm512_loadu_ps(&query[idx + 16]);
 
                     for (size_t j = 0; j < BATCH_SIZE; ++j) {
                         const float* db_ = static_cast<const float*>(db[j]);
-                        __m512 diff = _mm512_sub_ps(q_vec, _mm512_loadu_ps(&db_[idx]));
-                        s[j] = _mm512_fmadd_ps(diff, diff, s[j]);
+                        __m512 diff_lo = _mm512_sub_ps(q_vec_lo, _mm512_loadu_ps(&db_[idx]));
+                        __m512 diff_hi = _mm512_sub_ps(q_vec_hi, _mm512_loadu_ps(&db_[idx + 16]));
+                        s[j] = _mm512_fmadd_ps(diff_lo, diff_lo, s[j]);
+                        s[j] = _mm512_fmadd_ps(diff_hi, diff_hi, s[j]);
                     }
                 }
             }
@@ -264,17 +267,20 @@ class L2Float_AVX2 {
             }
 
             if constexpr (HasDualSimd) {
-                const size_t nc8 = dim / 8;
-                offset = nc8 * 8;
+                const size_t nc16 = dim / 16;
+                offset = nc16 * 16;
 
-                for (size_t c = 0; c < nc8; ++c) {
-                    size_t idx = c * 8;
-                    __m256 q_vec = _mm256_loadu_ps(&query[idx]);
+                for (size_t c = 0; c < nc16; ++c) {
+                    size_t idx = c * 16;
+                    __m256 q_vec_lo = _mm256_loadu_ps(&query[idx]);
+                    __m256 q_vec_hi = _mm256_loadu_ps(&query[idx + 8]);
 
                     for (size_t j = 0; j < BATCH_SIZE; ++j) {
                         const float* db_ = static_cast<const float*>(db[j]);
-                        __m256 diff = _mm256_sub_ps(q_vec, _mm256_loadu_ps(&db_[idx]));
-                        s[j] = _mm256_fmadd_ps(diff, diff, s[j]);
+                        __m256 diff_lo = _mm256_sub_ps(q_vec_lo, _mm256_loadu_ps(&db_[idx]));
+                        __m256 diff_hi = _mm256_sub_ps(q_vec_hi, _mm256_loadu_ps(&db_[idx + 8]));
+                        s[j] = _mm256_fmadd_ps(diff_lo, diff_lo, s[j]);
+                        s[j] = _mm256_fmadd_ps(diff_hi, diff_hi, s[j]);
                     }
                 }
             }

{deglib-0.2.4 → deglib-0.2.5}/lib/deglib/include/deglib/distance/int8_l2.h

@@ -169,19 +169,24 @@ class L2Int8_AVX512 {
             }
 
             if constexpr (HasDualSimd) {
-                const size_t nc32 = dim / 32;
-                offset = nc32 * 32;
+                const size_t nc64 = dim / 64;
+                offset = nc64 * 64;
 
-                for (size_t c = 0; c < nc32; ++c) {
-                    size_t idx = c * 32;
-                    __m256i q_raw = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(&query[idx]));
-                    __m512i q_vec = _mm512_cvtepi8_epi16(q_raw);
+                for (size_t c = 0; c < nc64; ++c) {
+                    size_t idx = c * 64;
+                    __m256i q_raw_lo = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(&query[idx]));
+                    __m256i q_raw_hi = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(&query[idx + 32]));
+                    __m512i q_vec_lo = _mm512_cvtepi8_epi16(q_raw_lo);
+                    __m512i q_vec_hi = _mm512_cvtepi8_epi16(q_raw_hi);
 
                     for (size_t j = 0; j < BATCH_SIZE; ++j) {
                         const int8_t* db_ = static_cast<const int8_t*>(db[j]);
-                        __m256i r_raw = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(&db_[idx]));
-                        __m512i diff = _mm512_sub_epi16(q_vec, _mm512_cvtepi8_epi16(r_raw));
-                        s[j] = _mm512_add_epi32(s[j], _mm512_madd_epi16(diff, diff));
+                        __m256i r_raw_lo = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(&db_[idx]));
+                        __m256i r_raw_hi = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(&db_[idx + 32]));
+                        __m512i diff_lo = _mm512_sub_epi16(q_vec_lo, _mm512_cvtepi8_epi16(r_raw_lo));
+                        __m512i diff_hi = _mm512_sub_epi16(q_vec_hi, _mm512_cvtepi8_epi16(r_raw_hi));
+                        s[j] = _mm512_add_epi32(s[j], _mm512_madd_epi16(diff_lo, diff_lo));
+                        s[j] = _mm512_add_epi32(s[j], _mm512_madd_epi16(diff_hi, diff_hi));
                     }
                 }
             }
@@ -290,19 +295,24 @@ class L2Int8_AVX2 {
             }
 
             if constexpr (HasDualSimd) {
-                const size_t nc16 = dim / 16;
-                offset = nc16 * 16;
+                const size_t nc32 = dim / 32;
+                offset = nc32 * 32;
 
-                for (size_t c = 0; c < nc16; ++c) {
-                    size_t idx = c * 16;
-                    __m128i q_raw = _mm_loadu_si128(reinterpret_cast<const __m128i*>(&query[idx]));
-                    __m256i q_vec = _mm256_cvtepi8_epi16(q_raw);
+                for (size_t c = 0; c < nc32; ++c) {
+                    size_t idx = c * 32;
+                    __m128i q_raw_lo = _mm_loadu_si128(reinterpret_cast<const __m128i*>(&query[idx]));
+                    __m128i q_raw_hi = _mm_loadu_si128(reinterpret_cast<const __m128i*>(&query[idx + 16]));
+                    __m256i q_vec_lo = _mm256_cvtepi8_epi16(q_raw_lo);
+                    __m256i q_vec_hi = _mm256_cvtepi8_epi16(q_raw_hi);
 
                     for (size_t j = 0; j < BATCH_SIZE; ++j) {
                         const int8_t* db_ = static_cast<const int8_t*>(db[j]);
-                        __m128i r_raw = _mm_loadu_si128(reinterpret_cast<const __m128i*>(&db_[idx]));
-                        __m256i diff = _mm256_sub_epi16(q_vec, _mm256_cvtepi8_epi16(r_raw));
-                        s[j] = _mm256_add_epi32(s[j], _mm256_madd_epi16(diff, diff));
+                        __m128i r_raw_lo = _mm_loadu_si128(reinterpret_cast<const __m128i*>(&db_[idx]));
+                        __m128i r_raw_hi = _mm_loadu_si128(reinterpret_cast<const __m128i*>(&db_[idx + 16]));
+                        __m256i diff_lo = _mm256_sub_epi16(q_vec_lo, _mm256_cvtepi8_epi16(r_raw_lo));
+                        __m256i diff_hi = _mm256_sub_epi16(q_vec_hi, _mm256_cvtepi8_epi16(r_raw_hi));
+                        s[j] = _mm256_add_epi32(s[j], _mm256_madd_epi16(diff_lo, diff_lo));
+                        s[j] = _mm256_add_epi32(s[j], _mm256_madd_epi16(diff_hi, diff_hi));
                     }
                 }
             }

{deglib-0.2.4 → deglib-0.2.5}/lib/deglib/include/deglib/distance/uint8_l2.h

@@ -173,19 +173,24 @@ class L2Uint8_AVX512 {
             }
 
             if constexpr (HasDualSimd) {
-                const size_t nc32 = dim / 32;
-                offset = nc32 * 32;
+                const size_t nc64 = dim / 64;
+                offset = nc64 * 64;
 
-                for (size_t c = 0; c < nc32; ++c) {
-                    size_t idx = c * 32;
-                    __m256i q_raw = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(&query[idx]));
-                    __m512i q_vec = _mm512_cvtepu8_epi16(q_raw);
+                for (size_t c = 0; c < nc64; ++c) {
+                    size_t idx = c * 64;
+                    __m256i q_raw_lo = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(&query[idx]));
+                    __m256i q_raw_hi = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(&query[idx + 32]));
+                    __m512i q_vec_lo = _mm512_cvtepu8_epi16(q_raw_lo);
+                    __m512i q_vec_hi = _mm512_cvtepu8_epi16(q_raw_hi);
 
                     for (size_t j = 0; j < BATCH_SIZE; ++j) {
                         const unsigned char* db_ = static_cast<const unsigned char*>(db[j]);
-                        __m256i r_raw = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(&db_[idx]));
-                        __m512i diff = _mm512_sub_epi16(q_vec, _mm512_cvtepu8_epi16(r_raw));
-                        s[j] = _mm512_add_epi32(s[j], _mm512_madd_epi16(diff, diff));
+                        __m256i r_raw_lo = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(&db_[idx]));
+                        __m256i r_raw_hi = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(&db_[idx + 32]));
+                        __m512i diff_lo = _mm512_sub_epi16(q_vec_lo, _mm512_cvtepu8_epi16(r_raw_lo));
+                        __m512i diff_hi = _mm512_sub_epi16(q_vec_hi, _mm512_cvtepu8_epi16(r_raw_hi));
+                        s[j] = _mm512_add_epi32(s[j], _mm512_madd_epi16(diff_lo, diff_lo));
+                        s[j] = _mm512_add_epi32(s[j], _mm512_madd_epi16(diff_hi, diff_hi));
                     }
                 }
             }
@@ -294,19 +299,24 @@ class L2Uint8_AVX2 {
             }
 
             if constexpr (HasDualSimd) {
-                const size_t nc16 = dim / 16;
-                offset = nc16 * 16;
+                const size_t nc32 = dim / 32;
+                offset = nc32 * 32;
 
-                for (size_t c = 0; c < nc16; ++c) {
-                    size_t idx = c * 16;
-                    __m128i q_raw = _mm_loadu_si128(reinterpret_cast<const __m128i*>(&query[idx]));
-                    __m256i q_vec = _mm256_cvtepu8_epi16(q_raw);
+                for (size_t c = 0; c < nc32; ++c) {
+                    size_t idx = c * 32;
+                    __m128i q_raw_lo = _mm_loadu_si128(reinterpret_cast<const __m128i*>(&query[idx]));
+                    __m128i q_raw_hi = _mm_loadu_si128(reinterpret_cast<const __m128i*>(&query[idx + 16]));
+                    __m256i q_vec_lo = _mm256_cvtepu8_epi16(q_raw_lo);
+                    __m256i q_vec_hi = _mm256_cvtepu8_epi16(q_raw_hi);
 
                     for (size_t j = 0; j < BATCH_SIZE; ++j) {
                         const unsigned char* db_ = static_cast<const unsigned char*>(db[j]);
-                        __m128i r_raw = _mm_loadu_si128(reinterpret_cast<const __m128i*>(&db_[idx]));
-                        __m256i diff = _mm256_sub_epi16(q_vec, _mm256_cvtepu8_epi16(r_raw));
-                        s[j] = _mm256_add_epi32(s[j], _mm256_madd_epi16(diff, diff));
+                        __m128i r_raw_lo = _mm_loadu_si128(reinterpret_cast<const __m128i*>(&db_[idx]));
+                        __m128i r_raw_hi = _mm_loadu_si128(reinterpret_cast<const __m128i*>(&db_[idx + 16]));
+                        __m256i diff_lo = _mm256_sub_epi16(q_vec_lo, _mm256_cvtepu8_epi16(r_raw_lo));
+                        __m256i diff_hi = _mm256_sub_epi16(q_vec_hi, _mm256_cvtepu8_epi16(r_raw_hi));
+                        s[j] = _mm256_add_epi32(s[j], _mm256_madd_epi16(diff_lo, diff_lo));
+                        s[j] = _mm256_add_epi32(s[j], _mm256_madd_epi16(diff_hi, diff_hi));
                     }
                 }
             }

{deglib-0.2.4 → deglib-0.2.5}/src/deglib/__init__.py

@@ -20,7 +20,7 @@ from .graph import (
 )
 from .distances import FloatSpace, Metric
 
-__version__ = "0.2.4"
+__version__ = "0.2.5"
 
 __all__ = [
     "DynamicExplorationGraph",

{deglib-0.2.4 → deglib-0.2.5/src/deglib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deglib
-Version: 0.2.4
+Version: 0.2.5
 Summary: Python bindings for the Dynamic Exploration Graph library by Nico Hezel
 Author: Nico Hezel
 Author-email: Bruno Schilling <bruno.schilling@htw-berlin.de>

{deglib-0.2.4 → deglib-0.2.5}/tests/test_builder.py

@@ -221,3 +221,31 @@ class TestGraphs:
         assert status.deleted > 0
         assert len(status.total_added_ids) == self.data.shape[0]
         assert len(status.total_deleted_ids) > 0
+
+    @pytest.mark.parametrize("dim", [48, 80, 100, 784])
+    @pytest.mark.parametrize("metric", [Metric.FP32_L2, Metric.FP32_InnerProduct])
+    def test_build_unaligned_dimensions(self, dim, metric):
+        samples = 60
+        edges_per_vertex = 16
+        np.random.seed(42)
+        data = np.random.random((samples, dim)).astype(np.float32)
+        if metric == Metric.FP32_InnerProduct:
+            data = data / np.linalg.norm(data, axis=1, keepdims=True)
+
+        graph = deglib.create_empty(samples, FloatSpace.create(dim, metric), edges_per_vertex)
+        builder = deglib.GraphBuilder(
+            graph,
+            extend_k=32,
+            extend_eps=0.1,
+            optimization_target=deglib.builder.OptimizationTarget.LowLID if metric == Metric.FP32_L2 else deglib.builder.OptimizationTarget.HighLID,
+        )
+        builder.add_entry(range(samples), data)
+        status = builder.build()
+        assert status.added == samples
+        assert graph.size() == samples
+
+        # Verify search works and returns valid neighbors
+        res = graph.search(data[0], k=10, eps=0.1)
+        indices, dists = res
+        assert len(indices) == 10
+        assert not np.isnan(dists).any()