umappp 0.1.2

data/vendor/umappp/combine_neighbor_sets.hpp

@@ -0,0 +1,95 @@
+#ifndef UMAPPP_COMBINE_NEIGHBOR_SETS_HPP
+#define UMAPPP_COMBINE_NEIGHBOR_SETS_HPP
+
+#include <vector>
+#include <limits>
+#include <cmath>
+#include <algorithm>
+#include <numeric>
+
+#include "NeighborList.hpp"
+
+namespace umappp {
+
+template<typename Float>
+void combine_neighbor_sets(NeighborList<Float>& x, Float mix_ratio = 1) {
+    std::vector<size_t> last(x.size());
+    std::vector<size_t> original(x.size());
+
+    for (size_t i = 0; i < x.size(); ++i) {
+        auto& current = x[i];
+        std::sort(current.begin(), current.end()); // sorting by ID, see below.
+        original[i] = x[i].size();
+    }
+
+    for (size_t first = 0; first < x.size(); ++first) {
+        auto& current = x[first];
+        const int desired = first;
+
+        // Looping through the neighbors and searching for self in each
+        // neighbor's neighbors. As each inner vector in 'x' is sorted,
+        // this should only require a single pass through the entire set of
+        // neighbors as we do not need to search previously searched hits.
+        for (auto& y : current) {
+            auto& target = x[y.first];
+            auto& curlast = last[y.first];
+            const auto& limits = original[y.first];
+            while (curlast < limits && target[curlast].first < desired) {
+                ++curlast;
+            }
+
+            if (curlast < limits && target[curlast].first == desired) {
+                if (desired < y.first) { // don't average it twice.
+                    Float product = y.second * target[curlast].second;
+                    Float prob_final;
+
+                    if (mix_ratio == 1) {
+                        prob_final = y.second + target[curlast].second - product;
+                    } else if (mix_ratio == 0) {
+                        prob_final = product;
+                    } else {
+                        prob_final = mix_ratio * (y.second + target[curlast].second - product) + (1 - mix_ratio) * product;
+                    }
+
+                    y.second = prob_final;
+                    target[curlast].second = prob_final;
+                }
+            } else {
+                if (mix_ratio == 1) {
+                    target.emplace_back(desired, y.second);
+                } else if (mix_ratio == 0) {
+                    y.second = 0; // mark for deletion.
+                } else {
+                    y.second *= mix_ratio;
+                    target.emplace_back(desired, y.second);
+                }
+            }
+        }
+    }
+
+    // Removing zero probabilities.
+    if (mix_ratio == 0) {
+        for (auto& current : x) {
+            typename std::remove_reference<decltype(current)>::type replacement;
+            replacement.reserve(current.size());
+            for (const auto& y : current) {
+                if (y.second) {
+                    replacement.push_back(y);
+                }
+            }
+            std::swap(current, replacement);
+        }
+    }
+
+    // Sorting everything by index to be more cache-friendly. Also,
+    // irlba::ParallelSparseMatrix needs increasing inserts.
+    for (auto& current : x) {
+        std::sort(current.begin(), current.end());
+    }
+
+    return;
+}
+
+}
+
+#endif

data/vendor/umappp/find_ab.hpp

@@ -0,0 +1,157 @@
+#ifndef UMAPPP_FIND_AB_HPP
+#define UMAPPP_FIND_AB_HPP
+
+#include <cmath>
+#include <vector>
+#include <iostream>
+
+namespace umappp {
+
+/*
+ * Derivatives were obtained using the following code in R:
+ *
+ * > delta <- expression((1/(1+ a * x^(2*b)) - y)^2)
+ * > D(delta, "a")
+ * > D(delta, "b")
+ * > D(D(delta, "a"), "a")
+ * > D(D(delta, "b"), "a")
+ * > D(D(delta, "b"), "b")
+ *
+ * To test, evaluate with:
+ *
+ * > a <- 1.55461
+ * > b <- 0.743147
+ * > s <- 1
+ * > m <- 0.05
+ * > x <- seq(0, 3 * s, length.out=301)[-1]
+ * > y <- pmin(1, exp(-(x - m)/s))
+ * > sum(eval(delta))
+ */
+ 
+template<typename Float>
+std::pair<Float, Float> find_ab(Float spread, Float min_dist, Float grid = 300, Float limit = 0.5, int iter = 50, Float tol = 1e-6) {
+    Float x_half = std::log(limit) * -spread + min_dist;
+    Float d_half = limit / -spread;
+
+    // Compute the x and y coordinates of the expected distance curve.
+    std::vector<Float> grid_x(grid), grid_y(grid), log_x(grid);
+    const Float delta = spread * 3 / grid;
+    for (int g = 0; g < grid; ++g) {
+        grid_x[g] = (g + 1) * delta; // +1 to avoid meaningless least squares result at x = 0, where both curves have y = 1 (and also the derivative w.r.t. b is not defined).
+        log_x[g] = std::log(grid_x[g]);
+        grid_y[g] = (grid_x[g] <= min_dist ? 1 : std::exp(- (grid_x[g] - min_dist) / spread));
+    }
+
+    // Starting estimates.
+    Float b = - d_half * x_half / (1 / limit - 1) / (2 * limit * limit);
+    Float a = (1 / limit - 1) / std::pow(x_half, 2 * b);
+
+    std::vector<Float> observed_y(grid), xpow(grid);
+    auto compute_ss = [&](Float A, Float B) -> Float {
+        for (int g = 0; g < grid; ++g) {
+            xpow[g] = std::pow(grid_x[g], 2 * B);
+            observed_y[g] = 1 / (1 + A * xpow[g]);
+        }
+
+        Float ss = 0;
+        for (int g = 0; g < grid; ++g) {
+            ss += (grid_y[g] - observed_y[g]) * (grid_y[g] - observed_y[g]);
+        }
+
+        return ss;
+    };
+    Float ss = compute_ss(a, b);
+
+    for (int it = 0; it < iter; ++it) {
+        // Computing the first and second derivatives of the sum of squared differences.
+        Float da = 0, db = 0, daa = 0, dab = 0, dbb = 0;
+        for (int g = 0; g < grid; ++g) {
+            const Float& x = grid_x[g];
+            const Float& gy = grid_y[g];
+            const Float& oy = observed_y[g];
+
+            const Float& x2b = xpow[g];
+            const Float logx2 = log_x[g] * 2;
+            const Float delta = oy - gy;
+
+            // -(2 * (x^(2 * b)/(1 + a * x^(2 * b))^2 * (1/(1 + a * x^(2 * b)) - y)))
+            da += -2 * x2b * oy * oy * delta;
+
+            // -(2 * (a * (x^(2 * b) * (log(x) * 2))/(1 + a * x^(2 * b))^2 * (1/(1 + a * x^(2 * b)) - y)))
+            db += -2 * a * x2b * logx2 * oy * oy * delta;
+
+            // 2 * (
+            //     x^(2 * b)/(1 + a * x^(2 * b))^2 * (x^(2 * b)/(1 + a * x^(2 * b))^2) 
+            //     + x^(2 * b) * (2 * (x^(2 * b) * (1 + a * x^(2 * b))))/((1 + a * x^(2 * b))^2)^2 * (1/(1 + a * x^(2 * b)) - y)
+            // ) 
+            daa += 2 * (
+                x2b * oy * oy * x2b * oy * oy
+                + x2b * 2 * x2b * oy * oy * oy * delta
+            );
+
+            //-(2 * 
+            //    (
+            //        (
+            //            (x^(2 * b) * (log(x) * 2))/(1 + a * x^(2 * b))^2 
+            //            - a * (x^(2 * b) * (log(x) * 2)) * (2 * (x^(2 * b) * (1 + a * x^(2 * b))))/((1 + a * x^(2 * b))^2)^2
+            //        ) 
+            //        * (1/(1 + a * x^(2 * b)) - y) 
+            //        - a * (x^(2 * b) * (log(x) * 2))/(1 + a * x^(2 * b))^2 * (x^(2 * b)/(1 + a * x^(2 * b))^2)
+            //    )
+            //)
+            dab += -2 * (
+                (
+                    x2b * logx2 * oy * oy
+                    - a * x2b * logx2 * 2 * x2b * oy * oy * oy
+                ) * delta
+                - a * x2b * logx2 * oy * oy * x2b * oy * oy
+            );
+
+            // -(2 * 
+            //     (
+            //         (
+            //             a * (x^(2 * b) * (log(x) * 2) * (log(x) * 2))/(1 + a * x^(2 * b))^2 
+            //             - a * (x^(2 * b) * (log(x) * 2)) * (2 * (a * (x^(2 * b) * (log(x) * 2)) * (1 + a * x^(2 * b))))/((1 + a * x^(2 * b))^2)^2
+            //         ) 
+            //         * (1/(1 + a * x^(2 * b)) - y) 
+            //         - a * (x^(2 * b) * (log(x) * 2))/(1 + a * x^(2 * b))^2 * (a * (x^(2 * b) * (log(x) * 2))/(1 + a * x^(2 * b))^2)
+            //     )
+            // ) 
+            dbb += -2 * (
+                (
+                    (a * x2b * logx2 * logx2 * oy * oy)
+                    - (a * x2b * logx2 * 2 * a * x2b * logx2 * oy * oy * oy)
+                ) * delta 
+                - a * x2b * logx2 * oy * oy * a * x2b * logx2 * oy * oy
+            );
+        }
+
+        // Applying the Newton iterations with damping.
+        Float determinant = daa * dbb - dab * dab;
+        const Float delta_a = (da * dbb - dab * db) / determinant;
+        const Float delta_b = (- da * dab + daa * db) / determinant; 
+
+        Float ss_next = 0;
+        Float factor = 1;
+        for (int inner = 0; inner < 10; ++inner, factor /= 2) {
+            ss_next = compute_ss(a - factor * delta_a, b - factor * delta_b);
+            if (ss_next < ss) {
+                break;
+            }
+        }
+
+        if (ss && 1 - ss_next/ss > tol) {
+            a -= factor * delta_a;
+            b -= factor * delta_b;
+            ss = ss_next;
+        } else {
+            break;
+        }
+    }
+
+    return std::make_pair(a, b);
+}
+
+}
+
+#endif

data/vendor/umappp/neighbor_similarities.hpp

@@ -0,0 +1,136 @@
+#ifndef UMAPPP_NEIGHBOR_SIMILARITIES_HPP
+#define UMAPPP_NEIGHBOR_SIMILARITIES_HPP
+
+#include <vector>
+#include <limits>
+#include <cmath>
+#include <algorithm>
+#include <numeric>
+
+#include "NeighborList.hpp"
+
+namespace umappp {
+
+template<typename Float>
+void neighbor_similarities(
+    NeighborList<Float>& x, 
+    Float local_connectivity = 1.0, 
+    Float bandwidth = 1.0,
+    int max_iter = 64, 
+    Float tol = 1e-5, 
+    Float min_k_dist_scale = 1e-3
+) {
+    Float grand_mean_dist = -1;
+    constexpr Float max_val = std::numeric_limits<Float>::max();
+
+    #pragma omp parallel
+    {
+        std::vector<Float> non_zero_distances;
+        
+        #pragma omp for
+        for (size_t i = 0; i < x.size(); ++i) {
+            auto& all_neighbors = x[i];
+            const int n_neighbors = all_neighbors.size();
+
+            non_zero_distances.clear();
+            for (const auto& f : all_neighbors) {
+                if (f.second) {
+                    non_zero_distances.push_back(f.second);
+                }
+            }
+
+            if (non_zero_distances.size() <= local_connectivity) {
+                // When this happens, 'rho' is just theoretically set to the
+                // maximum distance. In such cases, the weights are always just
+                // set to 1 in the remaining code, because no distance can be
+                // greater than 'rho'. If that's the case, we might as well
+                // save some time and compute it here.
+                for (int k = 0; k < n_neighbors; ++k) {
+                    all_neighbors[k].second = 1;
+                }
+                continue;
+            }
+
+            // Find rho, the distance to the nearest (non-identical) neighbor,
+            // possibly with interpolation.
+            int index = std::floor(local_connectivity);
+            const Float interpolation = local_connectivity - index;
+            const Float lower = (index > 0 ? non_zero_distances[index - 1] : 0); // 'index' is 1-based, so -1.
+            const Float upper = non_zero_distances[index];
+            const Float rho = lower + interpolation * (upper - lower);
+
+            // Iterating to find a good sigma, just like how t-SNE does so for beta.
+            Float sigma = 1.0;
+            Float lo = 0.0;
+            Float hi = max_val;
+            Float sigma_best = sigma;
+            Float adiff_min = max_val;
+            const Float target = std::log2(all_neighbors.size() + 1); // include self. Dunno why, but uwot does it.
+
+            bool converged = false;
+            for (int iter = 0; iter < max_iter; ++iter) {
+                // If distance = 0, then max(distance - rho, 0) = 0 as rho >=
+                // 0. In which case, exp(-dist / sigma) is just 1 for each
+                // distance of zero, allowing us to just add these directly.
+                Float val = n_neighbors - non_zero_distances.size();
+                
+                for (auto d : non_zero_distances) {
+                    if (d > rho) {
+                        val += std::exp(-(d - rho)/ sigma);
+                    } else {
+                        val += 1;
+                    }
+                }
+
+                Float adiff = std::abs(val - target);
+                if (adiff < tol) {
+                    converged = true;
+                    break;
+                }
+
+                // store best sigma in case binary search fails (usually in the presence
+                // of multiple degenerate distances)
+                if (adiff < adiff_min) {
+                    adiff_min = adiff;
+                    sigma_best = sigma;
+                }
+
+                if (val > target) {
+                    hi = sigma;
+                    sigma = (lo + hi) / 2;
+                } else {
+                    lo = sigma;
+                    if (hi == max_val) {
+                        sigma *= 2;
+                    } else {
+                        sigma = (lo + hi) / 2;
+                    }
+                }
+            }
+
+            if (!converged) {
+                sigma = sigma_best;
+            }
+
+            // Quickly summing over the non-zero distances, then dividing
+            // by the total number of neighbors to obtain the mean.
+            Float mean_dist = std::accumulate(non_zero_distances.begin(), non_zero_distances.end(), 0.0)/n_neighbors;
+            sigma = std::max(min_k_dist_scale * mean_dist, sigma);
+
+            for (int k = 0; k < n_neighbors; ++k) {
+                Float& dist = all_neighbors[k].second;
+                if (dist > rho) {
+                    dist = std::exp(-(dist - rho) / (sigma * bandwidth));
+                } else {
+                    dist = 1;
+                }
+            }
+        }
+    }
+
+    return;
+}
+
+}
+
+#endif

data/vendor/umappp/optimize_layout.hpp

@@ -0,0 +1,285 @@
+#ifndef UMAPPP_OPTIMIZE_LAYOUT_HPP
+#define UMAPPP_OPTIMIZE_LAYOUT_HPP
+
+#include <vector>
+#include <limits>
+#include <algorithm>
+#include <cmath>
+
+#include "NeighborList.hpp"
+#include "aarand/aarand.hpp"
+
+namespace umappp {
+
+template<typename Float>
+struct EpochData {
+    EpochData(size_t nobs) : head(nobs) {}
+
+    int total_epochs;
+    int current_epoch = 0;
+
+    std::vector<size_t> head;
+    std::vector<int> tail;
+    std::vector<Float> epochs_per_sample;
+
+    std::vector<Float> epoch_of_next_sample;
+    std::vector<Float> epoch_of_next_negative_sample;
+    Float negative_sample_rate;
+};
+
+template<typename Float>
+EpochData<Float> similarities_to_epochs(const NeighborList<Float>& p, int num_epochs, Float negative_sample_rate) {
+    Float maxed = 0;
+    size_t count = 0;
+    for (const auto& x : p) {
+        count += x.size();
+        for (const auto& y : x) {
+            maxed = std::max(maxed, y.second);
+        }
+    }
+
+    EpochData<Float> output(p.size());
+    output.total_epochs = num_epochs;
+    output.tail.reserve(count);
+    output.epochs_per_sample.reserve(count);
+    const Float limit = maxed / num_epochs;
+
+    size_t last = 0;
+    for (size_t i = 0; i < p.size(); ++i) {
+        const auto& x = p[i];
+        for (const auto& y : x) {
+            if (y.second >= limit) {
+                output.tail.push_back(y.first);
+                output.epochs_per_sample.push_back(maxed / y.second);
+                ++last;
+            }
+        }
+        output.head[i] = last;
+    }
+
+    // Filling in some epoch-related running statistics.
+    output.epoch_of_next_sample = output.epochs_per_sample;
+    output.epoch_of_next_negative_sample = output.epochs_per_sample;
+    for (auto& e : output.epoch_of_next_negative_sample) {
+        e /= negative_sample_rate;
+    }
+    output.negative_sample_rate = negative_sample_rate;
+
+    return output;       
+}
+
+template<typename Float>
+Float quick_squared_distance(const Float* left, const Float* right, int ndim) {
+    Float dist2 = 0;
+    for (int d = 0; d < ndim; ++d, ++left, ++right) {
+        dist2 += (*left - *right) * (*left - *right);
+    }
+    constexpr Float dist_eps = std::numeric_limits<Float>::epsilon();
+    return std::max(dist_eps, dist2);
+}
+
+template<typename Float>
+Float clamp(Float input) {
+    constexpr Float min_gradient = -4;
+    constexpr Float max_gradient = 4;
+    return std::min(std::max(input, min_gradient), max_gradient);
+}
+
+template<bool batch, typename Float, class Setup, class Rng> 
+void optimize_sample(
+    size_t i,
+    int ndim,
+    Float* embedding,
+    Float* buffer,
+    Setup& setup,
+    Float a,
+    Float b,
+    Float gamma,
+    Float alpha,
+    Rng& rng,
+    Float epoch
+) {
+    const auto& head = setup.head;
+    const auto& tail = setup.tail;
+    const auto& epochs_per_sample = setup.epochs_per_sample;
+    auto& epoch_of_next_sample = setup.epoch_of_next_sample;
+    auto& epoch_of_next_negative_sample = setup.epoch_of_next_negative_sample;
+   
+    const size_t num_obs = head.size(); 
+    const Float negative_sample_rate = setup.negative_sample_rate;
+
+    size_t start = (i == 0 ? 0 : setup.head[i-1]), end = setup.head[i];
+    Float* left = embedding + i * ndim;
+
+    for (size_t j = start; j < end; ++j) {
+        if (epoch_of_next_sample[j] > epoch) {
+            continue;
+        }
+
+        Float* right = embedding + tail[j] * ndim;
+        Float dist2 = quick_squared_distance(left, right, ndim);
+        const Float pd2b = std::pow(dist2, b);
+        const Float grad_coef = (-2 * a * b * pd2b) / (dist2 * (a * pd2b + 1.0));
+        {
+            Float* lcopy = left;
+            Float* rcopy = right;
+
+            for (int d = 0; d < ndim; ++d, ++lcopy, ++rcopy) {
+                Float gradient = alpha * clamp(grad_coef * (*lcopy - *rcopy));
+                if constexpr(!batch) {
+                    *lcopy += gradient;
+                    *rcopy -= gradient;
+                } else {
+                    // Doubling as we'll assume symmetry from the same
+                    // force applied by the right node. This allows us to
+                    // avoid worrying about accounting for modifications to
+                    // the right node.
+                    buffer[d] += 2 * gradient;
+                }
+            }
+        }
+
+        // Here, we divide by epochs_per_negative_sample, defined as epochs_per_sample[j] / negative_sample_rate.
+        const size_t num_neg_samples = (epoch - epoch_of_next_negative_sample[j]) * negative_sample_rate / epochs_per_sample[j];
+
+        for (size_t p = 0; p < num_neg_samples; ++p) {
+            size_t sampled = aarand::discrete_uniform(rng, num_obs); 
+            if (sampled == i) {
+                continue;
+            }
+
+            Float* right = embedding + sampled * ndim;
+            Float dist2 = quick_squared_distance(left, right, ndim);
+            const Float grad_coef = 2 * gamma * b / ((0.001 + dist2) * (a * std::pow(dist2, b) + 1.0));
+            {
+                Float* lcopy = left;
+                const Float* rcopy = right;
+                for (int d = 0; d < ndim; ++d, ++lcopy, ++rcopy) {
+                    Float gradient = alpha * clamp(grad_coef * (*lcopy - *rcopy));
+                    if constexpr(!batch) {
+                        *lcopy += gradient;
+                    } else {
+                        buffer[d] += gradient;
+                    }
+                }
+            }
+        }
+
+        epoch_of_next_sample[j] += epochs_per_sample[j];
+
+        // The update to epoch_of_next_negative_sample involves adding
+        // num_neg_samples * epochs_per_negative_sample, which eventually boils
+        // down to setting epoch_of_next_negative_sample to 'n'.
+        epoch_of_next_negative_sample[j] = epoch;
+    }
+}
+
+template<typename Float, class Setup, class Rng>
+void optimize_layout(
+    int ndim,
+    Float* embedding, 
+    Setup& setup,
+    Float a, 
+    Float b, 
+    Float gamma,
+    Float initial_alpha,
+    Rng& rng,
+    int epoch_limit
+) {
+    auto& n = setup.current_epoch;
+    auto num_epochs = setup.total_epochs;
+    auto limit_epochs = num_epochs;
+    if (epoch_limit> 0) {
+        limit_epochs = std::min(epoch_limit, num_epochs);
+    }
+
+    for (; n < limit_epochs; ++n) {
+        const Float epoch = n;
+        const Float alpha = initial_alpha * (1.0 - epoch / num_epochs);
+        for (size_t i = 0; i < setup.head.size(); ++i) {
+            optimize_sample<false>(i, ndim, embedding, static_cast<Float*>(NULL), setup, a, b, gamma, alpha, rng, epoch);
+        }
+    }
+
+    return;
+}
+
+template<typename Float, class Setup, class SeedFunction, class EngineFunction>
+inline void optimize_layout_batched(
+    int ndim,
+    Float* embedding, 
+    Setup& setup,
+    Float a, 
+    Float b, 
+    Float gamma,
+    Float initial_alpha,
+    SeedFunction seeder,
+    EngineFunction creator,
+    int epoch_limit,
+    int nthreads
+) {
+    auto& n = setup.current_epoch;
+    auto num_epochs = setup.total_epochs;
+    auto limit_epochs = num_epochs;
+    if (epoch_limit > 0) {
+        limit_epochs = std::min(epoch_limit, num_epochs);
+    }
+
+    const size_t num_obs = setup.head.size(); 
+    std::vector<decltype(seeder())> seeds(num_obs);
+    std::vector<Float> replace_buffer(num_obs * ndim);
+    Float* replacement = replace_buffer.data();
+    bool using_replacement = false;
+
+    for (; n < limit_epochs; ++n) {
+        const Float epoch = n;
+        const Float alpha = initial_alpha * (1.0 - epoch / num_epochs);
+
+        // Fill the seeds.
+        for (auto& s : seeds) {
+            s = seeder();
+        }
+
+        // Input and output alternate between epochs, to avoid the need for a
+        // copy operation on the entire embedding at the end of each epoch.
+        Float* reference = (using_replacement ? replacement : embedding); 
+        Float* output = (using_replacement ? embedding : replacement);
+        using_replacement = !using_replacement;
+
+#ifndef UMAPPP_CUSTOM_PARALLEL
+        #pragma omp parallel num_threads(nthreads)
+        {
+            std::vector<Float> buffer(ndim);
+            #pragma omp for
+            for (size_t i = 0; i < setup.head.size(); ++i) {
+#else
+        UMAPPP_CUSTOM_PARALLEL(setup.head.size(), [&](size_t first, size_t last) -> void {
+            std::vector<Float> buffer(ndim);
+            for (size_t i = first; i < last; ++i) {
+#endif
+
+                size_t shift = i * ndim;
+                std::copy(reference + shift, reference + shift + ndim, buffer.data());
+                auto rng = creator(seeds[i]);
+                optimize_sample<true>(i, ndim, reference, buffer.data(), setup, a, b, gamma, alpha, rng, epoch);
+                std::copy(buffer.begin(), buffer.end(), output + shift);
+
+#ifndef UMAPPP_CUSTOM_PARALLEL
+            }
+        }
+#else
+            }
+        }, nthreads);
+#endif
+    }
+
+    if (using_replacement) {
+        std::copy(replace_buffer.begin(), replace_buffer.end(), embedding);
+    }
+
+    return;
+}
+
+}
+
+#endif