classify_single.hpp

Go to the documentation of this file.

#ifndef SINGLEPP_CLASSIFY_SINGLE_HPP
#define SINGLEPP_CLASSIFY_SINGLE_HPP
 
#include "defs.hpp"
 
#include "tatami/tatami.hpp"
 
#include "annotate_cells_single.hpp"
#include "train_single.hpp"
 
#include <vector> 
#include <cstddef>
#include <stdexcept>
 
namespace singlepp {
 
template<typename Float_ = DefaultFloat>
struct ClassifySingleOptions {
    Float_ quantile = 0.8;
 
    Float_ fine_tune_threshold = 0.05;
 
    bool fine_tune = true;
 
    int num_threads = 1;
};
 
template<typename Label_ = DefaultLabel, typename Float_ = DefaultFloat>
struct ClassifySingleBuffers {
    Label_* best;
 
    std::vector<Float_*> scores;
 
    Float_* delta;
};
 
template<typename Value_, typename Index_, typename Float_, typename Label_>
void classify_single(
    const tatami::Matrix<Value_, Index_>& test, 
    const TrainedSingle<Index_, Float_>& trained,
    const ClassifySingleBuffers<Label_, Float_>& buffers,
    const ClassifySingleOptions<Float_>& options) 
{
    if (trained.get_test_nrow() != test.nrow()) {
        throw std::runtime_error("number of rows in 'test' is not the same as that used to build 'trained'");
    }
    internal::annotate_cells_single(
        test, 
        trained.get_subset(),
        trained.get_references(), 
        trained.get_markers(), 
        options.quantile, 
        options.fine_tune, 
        options.fine_tune_threshold, 
        buffers.best, 
        buffers.scores, 
        buffers.delta,
        options.num_threads
    );
}
 
template<typename Value_, typename Index_, typename Float_, typename Label_>
void classify_single_intersect(
    const tatami::Matrix<Value_, Index_>& test, 
    const TrainedSingleIntersect<Index_, Float_>& trained,
    const ClassifySingleBuffers<Label_, Float_>& buffers,
    const ClassifySingleOptions<Float_>& options) 
{
    if (trained.get_test_nrow() != static_cast<Index_>(-1) && trained.get_test_nrow() != test.nrow()) {
        throw std::runtime_error("number of rows in 'test' is not the same as that used to build 'trained'");
    }
    internal::annotate_cells_single(
        test, 
        trained.get_test_subset(),
        trained.get_references(), 
        trained.get_markers(), 
        options.quantile, 
        options.fine_tune, 
        options.fine_tune_threshold, 
        buffers.best, 
        buffers.scores, 
        buffers.delta,
        options.num_threads
    );
}
 
template<typename Label_ = DefaultLabel, typename Float_ = DefaultFloat>
struct ClassifySingleResults {
    ClassifySingleResults(std::size_t num_cells, std::size_t num_labels) : best(num_cells), delta(num_cells) {
        scores.reserve(num_labels);
        for (decltype(num_labels) l = 0; l < num_labels; ++l) {
            scores.emplace_back(num_cells);
        }
    }
    std::vector<Label_> best;
 
    std::vector<std::vector<Float_> > scores;
 
    std::vector<Float_> delta;
};
 
namespace internal {
 
template<typename Label_, typename Float_>
ClassifySingleBuffers<Label_, Float_> results_to_buffers(ClassifySingleResults<Label_, Float_>& results) {
    ClassifySingleBuffers<Label_, Float_> output;
    output.best = results.best.data();
    output.delta = results.delta.data();
    output.scores.reserve(results.scores.size());
    for (auto& s : results.scores) {
        output.scores.emplace_back(s.data());
    }
    return output;
}
 
}
template<typename Label_ = DefaultLabel, typename Value_, typename Index_, typename Float_>
ClassifySingleResults<Label_, Float_> classify_single(
    const tatami::Matrix<Value_, Index_>& test,
    const TrainedSingle<Index_, Float_>& trained,
    const ClassifySingleOptions<Float_>& options) 
{
    ClassifySingleResults<Label_, Float_> output(test.ncol(), trained.get_references().size());
    auto buffers = internal::results_to_buffers(output);
    classify_single(test, trained, buffers, options);
    return output;
}
 
template<typename Label_ = DefaultLabel, typename Value_, typename Index_, typename Float_>
ClassifySingleResults<Label_, Float_> classify_single_intersect(
    const tatami::Matrix<Value_, Index_>& test,
    const TrainedSingleIntersect<Index_, Float_>& trained,
    const ClassifySingleOptions<Float_>& options) 
{
    ClassifySingleResults<Label_, Float_> output(test.ncol(), trained.get_references().size());
    auto buffers = internal::results_to_buffers(output);
    classify_single_intersect(test, trained, buffers, options);
    return output;
}
 
}
 
#endif