train_single.hpp

Go to the documentation of this file.

#ifndef SINGLEPP_TRAIN_SINGLE_HPP
#define SINGLEPP_TRAIN_SINGLE_HPP
 
#include "defs.hpp"
 
#include "tatami/tatami.hpp"
 
#include "build_reference.hpp"
#include "subset_to_markers.hpp"
#include "utils.hpp"
 
#include <vector>
#include <memory>
#include <cstddef>
#include <cassert>
 
namespace singlepp {
 
struct TrainSingleOptions {
    int num_threads = 1;
};
 
template<typename Index_, typename Float_>
std::size_t get_num_labels_from_built(const BuiltReference<Index_, Float_>& built) {
    if (built.sparse.has_value()) {
        return built.sparse->size();
    } else {
        return built.dense->size();
    }
}
 
template<typename Index_, typename Float_>
std::size_t get_num_profiles_from_built(const BuiltReference<Index_, Float_>& built) {
    std::size_t n = 0;
    if (built.sparse.has_value()) {
        for (const auto& ref : *(built.sparse)) {
            n += get_num_samples(ref);
        }
    } else {
        for (const auto& ref : *(built->dense)) {
            n += get_num_samples(ref);
        }
    }
    return n;
}
template<typename Index_, typename Float_>
class TrainedSingle {
public:
    TrainedSingle(
        Index_ test_nrow,
        PairwiseMarkers<Index_> markers,
        std::vector<Index_> subset,
        BuiltReference<Index_, Float_> built
    ) : 
        my_test_nrow(test_nrow),
        my_markers(std::move(markers)),
        my_subset(std::move(subset)),
        my_built(std::move(built)) 
    {
        assert(is_sorted_unique(subset.size(), subset.data()));
 
        const auto nlabels = my_built.dense.has_value() ? my_built.dense->size() : my_built.sparse->size();
        if (!sanisizer::is_equal(my_markers.size(), nlabels)) {
            throw std::runtime_error("'markers' length should be equal to the number of unique labels");
        }
        for (const auto& mm : my_markers) {
            if (!sanisizer::is_equal(mm.size(), nlabels)) {
                throw std::runtime_error("length of each entry of 'markers' should be equal to the number of unique labels");
            }
        }
    }
private:
    Index_ my_test_nrow;
    PairwiseMarkers<Index_> my_markers;
    std::vector<Index_> my_subset;
    BuiltReference<Index_, Float_> my_built;
 
public:
    Index_ test_nrow() const {
        return my_test_nrow;
    }
 
    const PairwiseMarkers<Index_>& markers() const {
        return my_markers;
    }
 
    const std::vector<Index_>& subset() const {
        return my_subset;
    }
 
    std::size_t num_labels() const {
        return get_num_labels_from_built(my_built);
    }
 
    std::size_t num_profiles() const {
        return get_num_profiles_from_built(my_built);
    }
 
    const auto& built() const {
        return my_built;
    }
};
 
template<typename Float_ = double, typename Value_, typename Index_, typename Label_>
TrainedSingle<Index_, Float_> train_single(
    const tatami::Matrix<Value_, Index_>& ref,
    const Label_* labels,
    PairwiseMarkers<Index_> markers,
    const TrainSingleOptions& options
) {
    auto subset = subset_to_markers(ref.nrow(), markers);
    auto subref = build_reference<Float_>(ref, labels, subset, options.num_threads);
    const 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 Float_ = double, typename Index_, typename Value_, typename Label_>
TrainedSingle<Index_, Float_> train_single(
    Index_ test_nrow,
    const Intersection<Index_>& intersection,
    const tatami::Matrix<Value_, Index_>& ref, 
    const Label_* labels,
    PairwiseMarkers<Index_> markers,
    std::vector<Index_>* ref_subset,
    const TrainSingleOptions& options
) {
    auto pairs = subset_to_markers(test_nrow, intersection, ref.nrow(), markers);
    auto subref = build_reference<Float_>(ref, labels, pairs.second, options.num_threads);
    if (ref_subset) {
        *ref_subset = std::move(pairs.second);
    }
    return TrainedSingle<Index_, Float_>(test_nrow, std::move(markers), std::move(pairs.first), std::move(subref));
}
 
template<typename Float_ = double, typename Index_, typename Id_, typename Value_, typename Label_>
TrainedSingle<Index_, Float_> train_single(
    Index_ test_nrow,
    const Id_* test_id, 
    const tatami::Matrix<Value_, Index_>& ref, 
    const Id_* ref_id, 
    const Label_* labels,
    PairwiseMarkers<Index_> markers,
    std::vector<Index_>* ref_subset,
    const TrainSingleOptions& options
) {
    auto intersection = intersect_genes(test_nrow, test_id, ref.nrow(), ref_id);
    return train_single(test_nrow, intersection, ref, labels, std::move(markers), ref_subset, options);
}
 
}
 
#endif