train_single.hpp

Go to the documentation of this file.

#ifndef SINGLEPP_TRAIN_SINGLE_HPP
#define SINGLEPP_TRAIN_SINGLE_HPP
 
#include "defs.hpp"
 
#include "knncolle/knncolle.hpp"
#include "tatami/tatami.hpp"
 
#include "build_indices.hpp"
#include "subset_to_markers.hpp"
 
#include <vector>
#include <memory>
 
namespace singlepp {
 
template<typename Index_ = DefaultIndex, typename Float_ = DefaultFloat>
struct TrainSingleOptions {
    int top = -1;
 
    std::shared_ptr<knncolle::Builder<knncolle::SimpleMatrix<Index_, Index_, Float_>, Float_> > trainer;
 
    int num_threads = 1;
};
 
namespace internal {
 
template<typename Value_, typename Index_, typename Label_, typename Float_>
std::vector<PerLabelReference<Index_, Float_> > build_references(
    const tatami::Matrix<Value_, Index_>& ref,
    const Label_* labels,
    const std::vector<Index_>& subset,
    const TrainSingleOptions<Index_, Float_>& options) 
{
    if (options.trainer) {
        return build_indices(ref, labels, subset, *(options.trainer), options.num_threads);
    } else {
        typedef knncolle::VptreeBuilder<knncolle::EuclideanDistance, knncolle::SimpleMatrix<Index_, Index_, Float_>, Float_> DefaultBuilder;
        return build_indices(ref, labels, subset, DefaultBuilder(), options.num_threads);
    }
}
 
}
template<typename Index_, typename Float_>
class TrainedSingle {
public:
    TrainedSingle(
        Markers<Index_> markers,
        std::vector<Index_> subset,
        std::vector<internal::PerLabelReference<Index_, Float_> > references) :
        my_markers(std::move(markers)),
        my_subset(std::move(subset)),
        my_references(std::move(references)) 
    {}
private:
    Markers<Index_> my_markers;
    std::vector<Index_> my_subset;
    std::vector<internal::PerLabelReference<Index_, Float_> > my_references;
 
public:
    const Markers<Index_>& get_markers() const {
        return my_markers;
    }
 
    const std::vector<Index_>& get_subset() const {
        return my_subset;
    }
 
    size_t num_labels() const {
        return my_references.size();
    }
 
    size_t num_profiles() const {
        size_t n = 0;
        for (const auto& ref : my_references) {
            n += ref.ranked.size();
        }
        return n;
    }
 
    const auto& get_references() const {
        return my_references;
    }
};
 
template<typename Value_, typename Index_, typename Label_, typename Float_>
TrainedSingle<Index_, Float_> train_single(
    const tatami::Matrix<Value_, Index_>& ref,
    const Label_* labels,
    Markers<Index_> markers,
    const TrainSingleOptions<Index_, Float_>& options)
{
    auto subset = internal::subset_to_markers(markers, options.top);
    auto subref = internal::build_references(ref, labels, subset, options);
    return TrainedSingle<Index_, Float_>(std::move(markers), std::move(subset), std::move(subref));
}
 
template<typename Index_, typename Float_>
class TrainedSingleIntersect {
public:
    TrainedSingleIntersect(
        Markers<Index_> markers,
        std::vector<Index_> test_subset,
        std::vector<Index_> ref_subset,
        std::vector<internal::PerLabelReference<Index_, Float_> > references) :
        my_markers(std::move(markers)),
        my_test_subset(std::move(test_subset)),
        my_ref_subset(std::move(ref_subset)),
        my_references(std::move(references)) 
    {}
private:
    Markers<Index_> my_markers;
    std::vector<Index_> my_test_subset;
    std::vector<Index_> my_ref_subset;
    std::vector<internal::PerLabelReference<Index_, Float_> > my_references;
 
public:
    const Markers<Index_>& get_markers() const {
        return my_markers;
    }
 
    const std::vector<Index_>& get_test_subset() const {
        return my_test_subset;
    }
 
    const std::vector<Index_>& get_ref_subset() const {
        return my_ref_subset;
    }
 
    size_t num_labels() const {
        return my_references.size();
    }
 
    size_t num_profiles() const {
        size_t n = 0;
        for (const auto& ref : my_references) {
            n += ref.ranked.size();
        }
        return n;
    }
 
    const auto& get_references() const {
        return my_references;
    }
};
 
template<typename Index_, typename Value_, typename Label_, typename Float_>
TrainedSingleIntersect<Index_, Float_> train_single_intersect(
    const Intersection<Index_>& intersection,
    const tatami::Matrix<Value_, Index_>& ref, 
    const Label_* labels,
    Markers<Index_> markers,
    const TrainSingleOptions<Index_, Float_>& options)
{
    auto pairs = internal::subset_to_markers(intersection, markers, options.top);
    auto subref = internal::build_references(ref, labels, pairs.second, options);
    return TrainedSingleIntersect<Index_, Float_>(std::move(markers), std::move(pairs.first), std::move(pairs.second), std::move(subref));
}
 
template<typename Index_, typename Id_, typename Value_, typename Label_, typename Float_>
TrainedSingleIntersect<Index_, Float_> train_single_intersect(
    Index_ test_nrow,
    const Id_* test_id, 
    const tatami::Matrix<Value_, Index_>& ref, 
    const Id_* ref_id, 
    const Label_* labels,
    Markers<Index_> markers,
    const TrainSingleOptions<Index_, Float_>& options)
{
    auto intersection = intersect_genes(test_nrow, test_id, ref.nrow(), ref_id);
    return train_single_intersect(intersection, ref, labels, std::move(markers), options);
}
 
}
 
#endif