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.test_nrow() != test.nrow()) {
        throw std::runtime_error("number of rows in 'test' is not the same as that used to build 'trained'");
    }
    annotate_cells_single(
        test, 
        trained,
        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(const std::size_t num_cells, const std::size_t num_labels) :
        best(sanisizer::cast<I<decltype(best.size())> >(num_cells)),
        delta(sanisizer::cast<I<decltype(delta.size())> >(num_cells))
    {
        scores.reserve(num_labels);
        for (I<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;
};
 
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.num_labels());
 
    ClassifySingleBuffers<Label_, Float_> buffers;
    buffers.best = output.best.data();
    buffers.delta = output.delta.data();
    buffers.scores.reserve(output.scores.size());
    for (auto& s : output.scores) {
        buffers.scores.emplace_back(s.data());
    }
 
    classify_single(test, trained, buffers, options);
    return output;
}
 
}
 
#endif