Status.hpp

Go to the documentation of this file.

#ifndef UMAPPP_STATUS_HPP
#define UMAPPP_STATUS_HPP
 
#include "Options.hpp"
#include "optimize_layout.hpp"
 
#include <random>
#include <cstdint>
 
namespace umappp {
 
template<typename Index_, typename Float_>
class Status {
public:
    Status(internal::EpochData<Index_, Float_> epochs, Options options, int num_dim, Float_* embedding) : 
        my_epochs(std::move(epochs)),
        my_options(std::move(options)),
        my_engine(my_options.seed),
        my_num_dim(num_dim),
        my_embedding(embedding) 
    {}
private:
    internal::EpochData<Index_, Float_> my_epochs;
    Options my_options;
    std::mt19937_64 my_engine;
    int my_num_dim;
    Float_* my_embedding;
 
public:
    // Only used for testing, specifically in comparison to uwot:::data2set.
    const auto& get_epoch_data() const {
        return my_epochs;
    }
public:
    int num_dimensions() const {
        return my_num_dim;
    }
 
    const Float_* embedding() const {
        return my_embedding;
    }
 
    void set_embedding(Float_* ptr, bool copy = true) {
        if (copy) {
            size_t n = static_cast<size_t>(num_dimensions()) * num_observations(); // cast to avoid overflow.
            std::copy_n(my_embedding, n, ptr);
        }
        my_embedding = ptr;
    }
 
    int epoch() const {
        return my_epochs.current_epoch;
    }
 
    int num_epochs() const {
        return my_epochs.total_epochs;
    }
 
    size_t num_observations() const {
        return my_epochs.head.size();
    }
 
public:
    void run(int epoch_limit = 0) {
        if (epoch_limit == 0) {
            epoch_limit = my_epochs.total_epochs;
        }
 
        if (my_options.num_threads == 1 || !my_options.parallel_optimization) {
            internal::optimize_layout<Index_, Float_>(
                my_num_dim,
                my_embedding,
                my_epochs,
                my_options.a,
                my_options.b,
                my_options.repulsion_strength,
                my_options.learning_rate,
                my_engine,
                epoch_limit
            );
        } else {
            internal::optimize_layout_parallel<Index_, Float_>(
                my_num_dim,
                my_embedding,
                my_epochs,
                my_options.a,
                my_options.b,
                my_options.repulsion_strength,
                my_options.learning_rate,
                my_engine,
                epoch_limit,
                my_options.num_threads
            );
        }
        return;
    }
};
 
}
 
#endif