umappp 0.1.2

data/vendor/knncolle/Annoy/Annoy.hpp

@@ -0,0 +1,193 @@
+#ifndef KNNCOLLE_ANNOYBASE_HPP
+#define KNNCOLLE_ANNOYBASE_HPP
+
+#include <cstdint>
+
+#include "../utils/Base.hpp"
+
+#include "annoy/annoylib.h"
+#include "annoy/kissrandom.h"
+
+/**
+ * @file Annoy.hpp
+ *
+ * @brief Implements an approximate nearest neighbor search with Annoy.
+ */
+
+namespace knncolle {
+
+/**
+ * @brief Perform an approximate nearest neighbor search with Annoy.
+ *
+ * In the Approximate Nearest Neighbors Oh Yeah (Annoy) algorithm, a tree is constructed where a random hyperplane splits the points into two subsets at each internal node.
+ * Leaf nodes are defined when the number of points in a subset falls below a threshold (close to twice the number of dimensions for the settings used here).
+ * Multiple trees are constructed in this manner, each of which is different due to the random choice of hyperplanes.
+ * For a given query point, each tree is searched to identify the subset of all points in the same leaf node as the query point. 
+ * The union of these subsets across all trees is exhaustively searched to identify the actual nearest neighbors to the query.
+ *
+ * @see
+ * Bernhardsson E (2018).
+ * Annoy.
+ * https://github.com/spotify/annoy
+ *
+ * @tparam DISTANCE An **Annoy**-derived class to compute the distance between vectors.
+ * Note that this is not the same as the classes in `distances.hpp`.
+ * @tparam INDEX_t Integer type for the indices.
+ * @tparam DISTANCE_t Floating point type for the distances.
+ * @tparam INTERNAL_INDEX_t Integer type for the internal indices.
+ * @tparam INTERNAL_DATA_t Floating point type for the internal data store.
+ * This uses a `float` instead of a `double` to sacrifice some accuracy for performance.
+ */
+template<class DISTANCE, typename INDEX_t = int, typename DISTANCE_t = double, typename QUERY_t = DISTANCE_t, typename INTERNAL_INDEX_t = int32_t, typename INTERNAL_DATA_t = float>
+class Annoy : public Base<INDEX_t, DISTANCE_t, QUERY_t> {
+public:
+    INDEX_t nobs() const {
+        return annoy_index.get_n_items();
+    }
+    
+    INDEX_t ndim() const {
+        return num_dim;
+    }
+
+
+public:
+    /**
+     * Defaults for the constructor parameters.
+     */
+    struct Defaults {
+        /**
+         * See `ntrees` in the `Annoy()` constructor.
+         */
+        static constexpr int ntrees = 50;
+
+        /**
+         * See `search_mult` in the `Annoy()` constructor.
+         */
+        static constexpr double search_mult = -1;
+    };
+
+public:
+    /**
+     * @param ndim Number of dimensions.
+     * @param nobs Number of observations.
+     * @param vals Pointer to an array of length `ndim * nobs`, corresponding to a dimension-by-observation matrix in column-major format, 
+     * i.e., contiguous elements belong to the same observation.
+     * @param ntrees Number of trees to construct.
+     * Larger values improve accuracy at the cost of index size (i.e., memory usage), see [here](https://github.com/spotify/annoy#tradeoffs) for details.
+     * @param search_mult Factor that is multiplied by the number of neighbors `k` to determine the number of nodes to search in `find_nearest_neighbors()`.
+     * Larger values improve accuracy at the cost of runtime, see [here](https://github.com/spotify/annoy#tradeoffs) for details.
+     * If set to -1, it defaults to `ntrees`.
+     *
+     * @tparam INPUT Floating-point type of the input data.
+     */
+    template<typename INPUT>
+    Annoy(INDEX_t ndim, INDEX_t nobs, const INPUT* vals, int ntrees = Defaults::ntrees, double search_mult = Defaults::search_mult) : 
+        annoy_index(ndim), num_dim(ndim), search_k_mult(search_mult) 
+    {
+        if constexpr(std::is_same<INPUT, INTERNAL_DATA_t>::value) {
+            for (INDEX_t i=0; i < nobs; ++i, vals += ndim) {
+                annoy_index.add_item(i, vals);
+            }
+        } else {
+            std::vector<INTERNAL_DATA_t> incoming(ndim);
+            for (INDEX_t i=0; i < nobs; ++i, vals += ndim) {
+                std::copy(vals, vals + ndim, incoming.begin());
+                annoy_index.add_item(i, incoming.data());
+            }
+        }
+        annoy_index.build(ntrees);
+        return;
+    }
+
+    std::vector<std::pair<INDEX_t, DISTANCE_t> > find_nearest_neighbors(INDEX_t index, int k) const {
+        std::vector<INTERNAL_INDEX_t> indices;
+        std::vector<INTERNAL_DATA_t> distances;
+        annoy_index.get_nns_by_item(index, k + 1, get_search_k(k + 1), &indices, &distances); // +1, as it forgets to discard 'self'.
+
+        bool self_found = false;
+        const INTERNAL_INDEX_t self = index;
+        std::vector<std::pair<INDEX_t, DISTANCE_t> > output;
+        output.reserve(k);
+        for (size_t i = 0; i < indices.size(); ++i) {
+            if (!self_found && indices[i] == self) {
+                self_found=true;
+            } else {
+                output.emplace_back(indices[i], distances[i]);
+            }
+        }
+
+        // Just in case we're full of ties at duplicate points, such that 'c'
+        // is not in the set.  Note that, if self_found=false, we must have at
+        // least 'K+2' points for 'c' to not be detected as its own neighbor.
+        // Thus there is no need to worry whether we are popping off a non-'c'
+        // element at the end of the vector.
+        if (!self_found) {
+            output.pop_back();
+        }
+
+        return output;
+    }
+        
+    std::vector<std::pair<INDEX_t, DISTANCE_t> > find_nearest_neighbors(const QUERY_t* query, int k) const {
+        std::vector<INTERNAL_INDEX_t> indices;
+        indices.reserve(k);
+        std::vector<INTERNAL_DATA_t> distances;
+        distances.reserve(k);
+
+        if constexpr(std::is_same<INTERNAL_DATA_t, QUERY_t>::value) {
+            annoy_index.get_nns_by_vector(query, k, get_search_k(k), &indices, &distances);
+        } else {
+            std::vector<INTERNAL_DATA_t> tmp(query, query + num_dim);
+            annoy_index.get_nns_by_vector(tmp.data(), k, get_search_k(k), &indices, &distances);
+        }
+
+        std::vector<std::pair<INDEX_t, DISTANCE_t> > output;
+        output.reserve(k);
+        for (size_t i = 0; i < indices.size(); ++i) {
+            output.emplace_back(indices[i], distances[i]);
+        }
+        return output;
+    }
+
+    const QUERY_t* observation(INDEX_t index, QUERY_t* buffer) const {
+        if constexpr(std::is_same<QUERY_t, INTERNAL_DATA_t>::value) {
+            annoy_index.get_item(index, buffer);
+        } else {
+            std::vector<INTERNAL_DATA_t> tmp(num_dim);
+            annoy_index.get_item(index, tmp.data());
+            std::copy(tmp.begin(), tmp.end(), buffer);
+        }
+        return buffer;
+    }
+
+    using Base<INDEX_t, DISTANCE_t, QUERY_t>::observation;
+
+private:
+    ::Annoy::AnnoyIndex<INTERNAL_INDEX_t, INTERNAL_DATA_t, DISTANCE, ::Annoy::Kiss64Random, ::Annoy::AnnoyIndexSingleThreadedBuildPolicy> annoy_index;
+    INDEX_t num_dim;
+    double search_k_mult;
+
+    int get_search_k(int k) const {
+        if (search_k_mult < 0) {
+            return -1;
+        } else {
+            return search_k_mult * k + 0.5; // rounded up.
+        }
+    }
+};
+
+/**
+ * Perform an Annoy search with Euclidean distances.
+ */
+template<typename INDEX_t = int, typename DISTANCE_t = double, typename QUERY_t = DISTANCE_t, typename INTERNAL_INDEX_t = int32_t, typename INTERNAL_DATA_t = float>
+using AnnoyEuclidean = Annoy<::Annoy::Euclidean, INDEX_t, DISTANCE_t, QUERY_t, INTERNAL_INDEX_t, INTERNAL_DATA_t>;
+
+/**
+ * Perform an Annoy search with Manhattan distances.
+ */
+template<typename INDEX_t = int, typename DISTANCE_t = double, typename QUERY_t = DISTANCE_t, typename INTERNAL_INDEX_t = int32_t, typename INTERNAL_DATA_t = float>
+using AnnoyManhattan = Annoy<::Annoy::Manhattan, INDEX_t, DISTANCE_t, QUERY_t, INTERNAL_INDEX_t, INTERNAL_DATA_t>;
+
+}
+
+#endif

data/vendor/knncolle/BruteForce/BruteForce.hpp

@@ -0,0 +1,120 @@
+#ifndef KNNCOLLE_BRUTEFORCE_HPP
+#define KNNCOLLE_BRUTEFORCE_HPP
+
+#include "../utils/distances.hpp"
+#include "../utils/NeighborQueue.hpp"
+#include "../utils/Base.hpp"
+
+#include <vector>
+#include <type_traits>
+
+/**
+ * @file BruteForce.hpp
+ *
+ * @brief Implements a brute-force search for nearest neighbors.
+ */
+
+namespace knncolle {
+
+/**
+ * @brief Perform a brute-force nearest neighbor search.
+ *
+ * The brute-force search computes all pairwise distances between data and query points to identify nearest neighbors of the latter.
+ * It has quadratic complexity and is theoretically the worst-performing method;
+ * however, it has effectively no overhead from constructing or querying indexing structures, 
+ * potentially making it faster in cases where indexing provides little benefit (e.g., few data points, high dimensionality).
+ *
+ * @tparam DISTANCE Class to compute the distance between vectors, see `distance::Euclidean` for an example.
+ * @tparam INDEX_t Integer type for the indices.
+ * @tparam DISTANCE_t Floating point type for the distances.
+ * @tparam QUERY_t Floating point type for the query data.
+ * @tparam INTERNAL_t Floating point type for the internal calculations.
+ */
+template<class DISTANCE, typename INDEX_t = int, typename DISTANCE_t = double, typename QUERY_t = DISTANCE_t, typename INTERNAL_t = double>
+class BruteForce : public Base<INDEX_t, DISTANCE_t, QUERY_t> {
+private:
+    INDEX_t num_dim;
+    INDEX_t num_obs;
+
+public:
+    INDEX_t nobs() const { return num_obs; } 
+    
+    INDEX_t ndim() const { return num_dim; }
+
+private:
+    std::vector<INTERNAL_t> store;
+
+public:
+    /**
+     * @param ndim Number of dimensions.
+     * @param nobs Number of observations.
+     * @param vals Pointer to an array of length `ndim * nobs`, corresponding to a dimension-by-observation matrix in column-major format, 
+     * i.e., contiguous elements belong to the same observation.
+     *
+     * @tparam INPUT Floating-point type of the input data.
+     */
+    template<typename INPUT>
+    BruteForce(INDEX_t ndim, INDEX_t nobs, const INPUT* vals) : num_dim(ndim), num_obs(nobs), store(vals, vals + ndim * nobs) {}
+
+    std::vector<std::pair<INDEX_t, DISTANCE_t> > find_nearest_neighbors(INDEX_t index, int k) const {
+        NeighborQueue<INDEX_t, INTERNAL_t> nearest(k, index);
+        search_nn(store.data() + index * num_dim, nearest);
+
+        auto output = nearest.template report<DISTANCE_t>();
+        normalize(output);
+        return output;
+    }
+
+    std::vector<std::pair<INDEX_t, DISTANCE_t> > find_nearest_neighbors(const QUERY_t* query, int k) const {
+        NeighborQueue<INDEX_t, INTERNAL_t> nearest(k);
+        search_nn(query, nearest);
+        auto output = nearest.template report<DISTANCE_t>();
+        normalize(output);
+        return output;
+    }
+
+    const QUERY_t* observation(INDEX_t index, QUERY_t* buffer) const {
+        auto candidate = store.data() + num_dim * index;
+        if constexpr(std::is_same<QUERY_t, INTERNAL_t>::value) {
+            return candidate;
+        } else {
+            std::copy(candidate, candidate + num_dim, buffer);
+            return buffer;
+        }
+    }
+
+    using Base<INDEX_t, DISTANCE_t, QUERY_t>::observation;
+
+private:
+    template<class QUEUE>
+    void search_nn(const QUERY_t* query, QUEUE& nearest) const {
+        auto copy = store.data();
+        for (INDEX_t i = 0; i < num_obs; ++i, copy += num_dim) {
+            nearest.add(i, DISTANCE::template raw_distance<INTERNAL_t>(query, copy, num_dim));
+        }
+        return;
+    }
+
+    void normalize(std::vector<std::pair<INDEX_t, DISTANCE_t> >& results) const {
+        for (auto& d : results) {
+            d.second = DISTANCE::normalize(d.second);
+        }
+        return;
+    } 
+};
+
+/**
+ * Perform a brute-force search with Euclidean distances.
+ */
+template<typename INDEX_t = int, typename DISTANCE_t = double, typename QUERY_t = DISTANCE_t, typename INTERNAL_t = double>
+using BruteForceEuclidean = BruteForce<distances::Euclidean, INDEX_t, DISTANCE_t, QUERY_t, INTERNAL_t>;
+
+/**
+ * Perform a brute-force search with Manhattan distances.
+ */
+template<typename INDEX_t = int, typename DISTANCE_t = double, typename QUERY_t = DISTANCE_t, typename INTERNAL_t = double>
+using BruteForceManhattan = BruteForce<distances::Manhattan, INDEX_t, DISTANCE_t, QUERY_t, INTERNAL_t>;
+
+}
+
+#endif

data/vendor/knncolle/Hnsw/Hnsw.hpp

@@ -0,0 +1,225 @@
+#ifndef KNNCOLLE_HNSW_HPP
+#define KNNCOLLE_HNSW_HPP
+
+#include "../utils/Base.hpp"
+#include "../utils/NeighborQueue.hpp"
+
+#include "hnswlib/hnswalg.h"
+#include <cmath>
+
+/**
+ * @file Hnsw.hpp
+ *
+ * @brief Implements an approximate nearest neighbor search with HNSW.
+ */
+
+namespace knncolle {
+
+/**
+ * @brief Perform an approximate nearest neighbor search with HNSW.
+ *
+ * In the HNSW algorithm (Malkov and Yashunin, 2016), each point is a node in a "nagivable small world" graph.
+ * The nearest neighbor search proceeds by starting at a node and walking through the graph to obtain closer neighbors to a given query point.
+ * Nagivable small world graphs are used to maintain connectivity across the data set by creating links between distant points.
+ * This speeds up the search by ensuring that the algorithm does not need to take many small steps to move from one cluster to another.
+ * The HNSW algorithm extends this idea by using a hierarchy of such graphs containing links of different lengths, 
+ * which avoids wasting time on small steps in the early stages of the search where the current node position is far from the query.
+ *
+ * @see
+ * Malkov YA, Yashunin DA (2016).
+ * Efficient and robust approximate nearest neighbor search using Hierarchical Navigable Small World graphs.
+ * _arXiv_.
+ * https://arxiv.org/abs/1603.09320
+ *
+ *
+ * @tparam DISTANCE An **hnswlib**-derived class to compute the distance between vectors.
+ * Note that this is not the same as the classes in `distances.hpp`.
+ * @tparam INDEX_t Integer type for the indices.
+ * @tparam DISTANCE_t Floating point type for the distances.
+ */
+template<class SPACE, typename INDEX_t = int, typename DISTANCE_t = double, typename QUERY_t = DISTANCE_t>
+class Hnsw : public Base<INDEX_t, DISTANCE_t, QUERY_t> {
+    typedef float INTERNAL_DATA_t; // floats are effectively hard-coded into hnswlib, given that L2Space only uses floats.
+
+public:
+    INDEX_t nobs() const {
+        return num_obs;
+    }
+    
+    INDEX_t ndim() const {
+        return num_dim;
+    }
+
+public:
+    /**
+     * Defaults for the constructor parameters.
+     */
+    struct Defaults {
+        /**
+         * See `nlinks` in the `Hnsw()` constructor.
+         */
+        static constexpr int nlinks = 16;
+
+        /**
+         * See `ef_construction` in the `Hnsw()` constructor.
+         */
+        static constexpr int ef_construction = 200;
+
+        /**
+         * See `ef_search` in the `Hnsw()` constructor.
+         */
+        static constexpr int ef_search = 10;
+    };
+
+public:
+    /**
+     * @param ndim Number of dimensions.
+     * @param nobs Number of observations.
+     * @param vals Pointer to an array of length `ndim * nobs`, corresponding to a dimension-by-observation matrix in column-major format, 
+     * i.e., contiguous elements belong to the same observation.
+     * @param nlinks Number of bidirectional links for each node.
+     * This is equivalent to the `M` parameter in the underlying **hnswlib** library, see [here](https://github.com/nmslib/hnswlib/blob/master/ALGO_PARAMS.md#construction-parameters) for details.
+     * @param ef_construction Size of the dynamic list of nearest neighbors during index construction.
+     * This controls the trade-off between indexing time and accuracy and is equivalent to the `ef_construct` parameter in the underlying **hnswlib** library, 
+     * see [here](https://github.com/nmslib/hnswlib/blob/master/ALGO_PARAMS.md#construction-parameters) for details.
+     * @param ef_search Size of the dynamic list of nearest neighbors during searching.
+     * This controls the trade-off between search speed and accuracy and is equivalent to the `ef` parameter in the underlying **hnswlib** library, 
+     * see [here](https://github.com/nmslib/hnswlib/blob/master/ALGO_PARAMS.md#search-parameters) for details.
+     *
+     * @tparam INPUT Floating-point type of the input data.
+     */
+    template<typename INPUT>
+    Hnsw(INDEX_t ndim, INDEX_t nobs, const INPUT* vals, int nlinks = Defaults::nlinks, int ef_construction = Defaults::ef_construction, int ef_search = Defaults::ef_search) : 
+        space(ndim), hnsw_index(&space, nobs, nlinks, ef_construction), num_dim(ndim), num_obs(nobs)
+    {
+        if constexpr(std::is_same<INPUT, INTERNAL_DATA_t>::value) {
+            for (INDEX_t i=0; i < nobs; ++i, vals += ndim) {
+                hnsw_index.addPoint(vals, i);
+            }
+        } else {
+            std::vector<INTERNAL_DATA_t> copy(ndim);
+            for (INDEX_t i=0; i < nobs; ++i, vals += ndim) {
+                std::copy(vals, vals + ndim, copy.begin());
+                hnsw_index.addPoint(copy.data(), i);
+            }
+        }
+        hnsw_index.setEf(ef_search);
+        return;
+    }
+
+    std::vector<std::pair<INDEX_t, DISTANCE_t> > find_nearest_neighbors(INDEX_t index, int k) const {
+        auto V = hnsw_index.getDataByLabel<INTERNAL_DATA_t>(index);
+        auto Q = hnsw_index.searchKnn(V.data(), k+1);
+        auto output = harvest_queue<INDEX_t, DISTANCE_t>(Q, true, index);
+        normalize(output);
+        return output;
+    }
+        
+    std::vector<std::pair<INDEX_t, DISTANCE_t> > find_nearest_neighbors(const QUERY_t* query, int k) const {
+        if constexpr(std::is_same<QUERY_t, INTERNAL_DATA_t>::value) {
+            auto Q = hnsw_index.searchKnn(query, k);
+            auto output = harvest_queue<INDEX_t, DISTANCE_t>(Q);
+            normalize(output);
+            return output;
+        } else {
+            std::vector<INTERNAL_DATA_t> copy(query, query + num_dim);
+            auto Q = hnsw_index.searchKnn(copy.data(), k);
+            auto output = harvest_queue<INDEX_t, DISTANCE_t>(Q);
+            normalize(output);
+            return output;
+        }
+    }
+
+    const QUERY_t* observation(INDEX_t index, QUERY_t* buffer) const {
+        auto V = hnsw_index.getDataByLabel<INTERNAL_DATA_t>(index);
+        std::copy(V.begin(), V.begin() + num_dim, buffer);
+        return buffer;
+    }
+
+    std::vector<QUERY_t> observation(INDEX_t index) const {
+        if constexpr(std::is_same<QUERY_t, INTERNAL_DATA_t>::value) {
+            return hnsw_index.getDataByLabel<QUERY_t>(index);
+        } else {
+            auto V = hnsw_index.getDataByLabel<INTERNAL_DATA_t>(index);
+            return std::vector<QUERY_t>(V.begin(), V.end());
+        }
+    }
+
+private:
+    SPACE space;
+    hnswlib::HierarchicalNSW<INTERNAL_DATA_t> hnsw_index;
+    INDEX_t num_dim, num_obs;
+
+    static void normalize(std::vector<std::pair<INDEX_t, DISTANCE_t> >& results) {
+        for (auto& d : results) {
+            d.second = SPACE::normalize(d.second);
+        }
+        return;
+    }
+};
+
+namespace hnsw_distances {
+
+class Manhattan : public hnswlib::SpaceInterface<float> {
+    size_t data_size_;
+    size_t dim_;
+public:
+    Manhattan(size_t ndim) : data_size_(ndim * sizeof(float)), dim_(ndim) {}
+
+    ~Manhattan() {}
+
+    size_t get_data_size() {
+        return data_size_;
+    }
+
+    hnswlib::DISTFUNC<float> get_dist_func() {
+        return L1;
+    }
+
+    void * get_dist_func_param() {
+        return &dim_;
+    }
+
+    static float L1(const void *pVect1v, const void *pVect2v, const void *qty_ptr) {
+        //return *((float*)pVect2);
+        const float* pVect1=static_cast<const float*>(pVect1v);
+        const float* pVect2=static_cast<const float*>(pVect2v);
+        size_t qty = *((size_t *) qty_ptr);
+        float res = 0;
+        for (; qty > 0; --qty, ++pVect1, ++pVect2) {
+            res += std::fabs(*pVect1 - *pVect2);
+        }
+        return res;
+    }
+    
+    static float normalize(float raw) {
+        return raw;
+    }
+};
+
+class Euclidean : public hnswlib::L2Space {
+public:
+    Euclidean(size_t ndim) : hnswlib::L2Space(ndim) {}
+
+    static float normalize(float raw) {
+        return std::sqrt(raw);
+    }
+};
+
+}
+
+/**
+ * Perform an Hnsw search with Euclidean distances.
+ */
+template<typename INDEX_t = int, typename DISTANCE_t = double, typename QUERY_t = DISTANCE_t>
+using HnswEuclidean = Hnsw<hnsw_distances::Euclidean, INDEX_t, DISTANCE_t, QUERY_t>;
+
+/**
+ * Perform an Hnsw search with Manhattan distances.
+ */
+template<typename INDEX_t = int, typename DISTANCE_t = double, typename QUERY_t = DISTANCE_t>
+using HnswManhattan = Hnsw<hnsw_distances::Manhattan, INDEX_t, DISTANCE_t, QUERY_t>;
+
+}
+
+#endif