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>
#include <cstddef>
 
namespace singlepp {
 
template<typename Index_ = DefaultIndex, typename Float_ = DefaultFloat, class Matrix_ = knncolle::Matrix<Index_, Float_> >
struct TrainSingleOptions {
    int top = -1;
 
    std::shared_ptr<knncolle::Builder<Index_, Float_, Float_, Matrix_> > trainer;
 
    int num_threads = 1;
};
 
namespace internal {
 
template<typename Value_, typename Index_, typename Label_, typename Float_, class Matrix_>
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_, Matrix_>& options) 
{
    auto builder = options.trainer;
    if (!builder) {
        builder.reset(new knncolle::VptreeBuilder<Index_, Float_, Float_, Matrix_>(std::make_shared<knncolle::EuclideanDistance<Float_, Float_> >()));
    }
    return build_indices(ref, labels, subset, *builder, options.num_threads);
}
 
}
template<typename Index_, typename Float_>
class TrainedSingle {
public:
    TrainedSingle(
        Index_ test_nrow,
        Markers<Index_> markers,
        std::vector<Index_> subset,
        std::vector<internal::PerLabelReference<Index_, Float_> > references) :
        my_test_nrow(test_nrow),
        my_markers(std::move(markers)),
        my_subset(std::move(subset)),
        my_references(std::move(references)) 
    {}
private:
    Index_ my_test_nrow;
    Markers<Index_> my_markers;
    std::vector<Index_> my_subset;
    std::vector<internal::PerLabelReference<Index_, Float_> > my_references;
 
public:
    Index_ get_test_nrow() const {
        return my_test_nrow;
    }
 
    const Markers<Index_>& get_markers() const {
        return my_markers;
    }
 
    const std::vector<Index_>& get_subset() const {
        return my_subset;
    }
 
    std::size_t num_labels() const {
        return my_references.size();
    }
 
    std::size_t num_profiles() const {
        std::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_, class Matrix_>
TrainedSingle<Index_, Float_> train_single(
    const tatami::Matrix<Value_, Index_>& ref,
    const Label_* labels,
    Markers<Index_> markers,
    const TrainSingleOptions<Index_, Float_, Matrix_>& options)
{
    auto subset = internal::subset_to_markers(markers, options.top);
    auto subref = internal::build_references(ref, labels, subset, options);
    Index_ test_nrow = ref.nrow(); // remember, test and ref are assumed to have the same features.
    return TrainedSingle<Index_, Float_>(test_nrow, std::move(markers), std::move(subset), std::move(subref));
}
 
template<typename Index_, typename Float_>
class TrainedSingleIntersect {
public:
    TrainedSingleIntersect(
        Index_ test_nrow,
        Markers<Index_> markers,
        std::vector<Index_> test_subset,
        std::vector<Index_> ref_subset,
        std::vector<internal::PerLabelReference<Index_, Float_> > references) :
        my_test_nrow(test_nrow),
        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:
    Index_ my_test_nrow;
    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:
    Index_ get_test_nrow() const {
        return my_test_nrow;
    }
 
    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;
    }
 
    std::size_t num_labels() const {
        return my_references.size();
    }
 
    std::size_t num_profiles() const {
        std::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(
    Index_ test_nrow,
    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_>(test_nrow, std::move(markers), std::move(pairs.first), std::move(pairs.second), std::move(subref));
}
 
// For back-compatibility only.
template<typename Index_, typename Value_, typename Label_, typename Float_, class Matrix_>
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_, Matrix_>& options)
{
    return train_single_intersect<Index_, Value_, Label_, Float_>(-1, intersection, ref, labels, std::move(markers), options);
}
template<typename Index_, typename Id_, typename Value_, typename Label_, typename Float_, class Matrix_>
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_, Matrix_>& options)
{
    auto intersection = intersect_genes(test_nrow, test_id, ref.nrow(), ref_id);
    return train_single_intersect(test_nrow, intersection, ref, labels, std::move(markers), options);
}
 
}
 
#endif