initialize.hpp

Go to the documentation of this file.

#ifndef QDTSNE_INITIALIZE_HPP
#define QDTSNE_INITIALIZE_HPP
 
#include <cstddef>
 
#include "knncolle/knncolle.hpp"
 
#include "Status.hpp"
#include "Options.hpp"
#include "gaussian.hpp"
#include "symmetrize.hpp"
 
namespace qdtsne {
 
namespace internal {
 
template<std::size_t num_dim_, typename Index_, typename Float_>
Status<num_dim_, Index_, Float_> initialize(NeighborList<Index_, Float_> nn, const Float_ perp, const Options& options) {
    compute_gaussian_perplexity(nn, perp, options.num_threads);
    symmetrize_matrix(nn);
    return Status<num_dim_, Index_, Float_>(std::move(nn), options);
}
 
}
template<std::size_t num_dim_, typename Index_, typename Float_>
Status<num_dim_, Index_, Float_> initialize(NeighborList<Index_, Float_> neighbors, const Options& options) {
    Float_ perp = options.perplexity;
    if (neighbors.size()) {
        if (options.precomputed_perplexity_policy == PrecomputedPerplexityPolicy::ASIS) {
            ;
        } else {
            if (options.precomputed_perplexity_policy == PrecomputedPerplexityPolicy::INFER) {
                perp = static_cast<Float_>(neighbors.front().size())/3;
            } else {
                if (!sanisizer::is_equal(neighbors.front().size(), perplexity_to_k(options.perplexity))) {
                    throw std::runtime_error("unexpected number of neighbors for the specified perplexity");
                }
            }
        }
    }
    return internal::initialize<num_dim_>(std::move(neighbors), perp, options);
}
 
template<std::size_t num_dim_, typename Index_, typename Input_, typename Float_>
Status<num_dim_, Index_, Float_> initialize(const knncolle::Prebuilt<Index_, Input_, Float_>& prebuilt, const Options& options) { 
    const Index_ K = perplexity_to_k<Index_>(options.perplexity); 
    auto neighbors = knncolle::find_nearest_neighbors(prebuilt, K, options.num_threads);
    return internal::initialize<num_dim_>(std::move(neighbors), static_cast<Float_>(options.perplexity), options);
}
 
template<std::size_t num_dim_, typename Index_, typename Float_, class Matrix_>
Status<num_dim_, Index_, Float_> initialize(
    const std::size_t data_dim,
    const Index_ num_obs,
    const Float_* const data,
    const knncolle::Builder<Index_, Float_, Float_, Matrix_>& builder,
    const Options& options) 
{
    auto index = builder.build_unique(knncolle::SimpleMatrix<Index_, Float_>(data_dim, num_obs, data));
    return initialize<num_dim_>(*index, options);
}
 
}
 
#endif