classify_integrated.hpp

Go to the documentation of this file.

#ifndef SINGLEPP_CLASSIFY_INTEGRATED_HPP
#define SINGLEPP_CLASSIFY_INTEGRATED_HPP
 
#include "defs.hpp"
 
#include "tatami/tatami.hpp"
 
#include "annotate_cells_integrated.hpp"
#include "train_integrated.hpp"
 
#include <vector>
#include <unordered_map>
#include <unordered_set>
 
namespace singlepp {
 
template<typename Float_ = DefaultFloat>
struct ClassifyIntegratedOptions {
    Float_ quantile = 0.8;
 
    Float_ fine_tune_threshold = 0.05;
 
    bool fine_tune = true;
 
    int num_threads = 1;
};
 
template<typename RefLabel_ = DefaultRefLabel, typename Float_ = DefaultFloat>
struct ClassifyIntegratedBuffers {
    RefLabel_* best;
 
    std::vector<Float_*> scores;
 
    Float_* delta;
};
 
template<typename Value_, typename Index_, typename Label_, typename RefLabel_, typename Float_>
void classify_integrated(
    const tatami::Matrix<Value_, Index_>& test,
    const std::vector<const Label_*>& assigned,
    const TrainedIntegrated<Index_>& trained,
    ClassifyIntegratedBuffers<RefLabel_, Float_>& buffers,
    const ClassifyIntegratedOptions<Float_>& options)
{
    if (trained.test_nrow != static_cast<Index_>(-1) && trained.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_integrated(
        test,
        trained,
        assigned,
        options.quantile,
        options.fine_tune,
        options.fine_tune_threshold,
        buffers.best,
        buffers.scores,
        buffers.delta,
        options.num_threads
    );
}
 
template<typename RefLabel_ = DefaultRefLabel, typename Float_ = DefaultFloat>
struct ClassifyIntegratedResults {
    ClassifyIntegratedResults(size_t ncells, size_t nrefs) : best(ncells), delta(ncells) {
        scores.reserve(nrefs);
        for (size_t r = 0; r < nrefs; ++r) {
            scores.emplace_back(ncells);
        }
    }
    std::vector<RefLabel_> best;
 
    std::vector<std::vector<Float_> > scores;
 
    std::vector<Float_> delta;
};
 
template<typename RefLabel_ = DefaultRefLabel, typename Value_, typename Index_, typename Label_, typename Float_>
ClassifyIntegratedResults<RefLabel_, Float_> classify_integrated(
    const tatami::Matrix<Value_, Index_>& test,
    const std::vector<const Label_*>& assigned,
    const TrainedIntegrated<Index_>& trained,
    const ClassifyIntegratedOptions<Float_>& options)
{
    ClassifyIntegratedResults<RefLabel_, Float_> results(test.ncol(), trained.num_references());
    ClassifyIntegratedBuffers<RefLabel_, Float_> buffers;
    buffers.best = results.best.data();
    buffers.delta = results.delta.data();
    buffers.scores.reserve(results.scores.size());
    for (auto& s : results.scores) {
        buffers.scores.emplace_back(s.data());
    }
    classify_integrated(test, assigned, trained, buffers, options);
    return results;
}
 
}
 
#endif