CrossValidationMulticlassStorage.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * Written (W) 2012 Heiko Strathmann, Sergey Lisitsyn
 *
 */

#ifndef CROSSVALIDATIONMULTICLASSSTORAGE_H_
#define CROSSVALIDATIONMULTICLASSSTORAGE_H_

#include <shogun/evaluation/CrossValidationOutput.h>
#include <shogun/evaluation/BinaryClassEvaluation.h>
#include <shogun/labels/MulticlassLabels.h>
#include <shogun/lib/SGMatrix.h>
#include <shogun/lib/DynamicObjectArray.h>

namespace shogun
{

class CMachine;
class CLabels;
class CEvaluation;

class CCrossValidationMulticlassStorage: public CCrossValidationOutput
{
public:

    CCrossValidationMulticlassStorage(bool compute_ROC=true, bool compute_PRC=false, bool compute_conf_matrices=false);

    virtual ~CCrossValidationMulticlassStorage();

    SGMatrix<float64_t> get_fold_ROC(int32_t run, int32_t fold, int32_t c)
    {
        ASSERT(0<=run);
        ASSERT(run<m_num_runs);
        ASSERT(0<=fold);
        ASSERT(fold<m_num_folds);
        ASSERT(0<=c);
        ASSERT(c<m_num_classes);
        REQUIRE(m_compute_ROC, "ROC computation was not enabled\n");
        return m_fold_ROC_graphs[run*m_num_folds*m_num_classes+fold*m_num_classes+c];
    }
    
    SGMatrix<float64_t> get_fold_PRC(int32_t run, int32_t fold, int32_t c)
    {
        ASSERT(0<=run);
        ASSERT(run<m_num_runs);
        ASSERT(0<=fold);
        ASSERT(fold<m_num_folds);
        ASSERT(0<=c);
        ASSERT(c<m_num_classes);
        REQUIRE(m_compute_PRC, "PRC computation was not enabled\n");
        return m_fold_PRC_graphs[run*m_num_folds*m_num_classes+fold*m_num_classes+c];
    }

    void append_binary_evaluation(CBinaryClassEvaluation* evaluation)
    {
        m_binary_evaluations->push_back(evaluation);
    }

    CBinaryClassEvaluation* get_binary_evaluation(int32_t idx)
    {
        return (CBinaryClassEvaluation*)m_binary_evaluations->get_element_safe(idx);
    }

    float64_t get_fold_evaluation_result(int32_t run, int32_t fold, int32_t c, int32_t e)
    {
        ASSERT(0<=run);
        ASSERT(run<m_num_runs);
        ASSERT(0<=fold);
        ASSERT(fold<m_num_folds);
        ASSERT(0<=c);
        ASSERT(c<m_num_classes);
        ASSERT(0<=e);
        int32_t n_evals = m_binary_evaluations->get_num_elements();
        ASSERT(e<n_evals);
        return m_evaluations_results[run*m_num_folds*m_num_classes*n_evals+fold*m_num_classes*n_evals+c*n_evals+e];
    }

    float64_t get_fold_accuracy(int32_t run, int32_t fold)
    {
        ASSERT(0<=run);
        ASSERT(run<m_num_runs);
        ASSERT(0<=fold);
        ASSERT(fold<m_num_folds);
        return m_accuracies[run*m_num_folds+fold];
    }

    SGMatrix<int32_t> get_fold_conf_matrix(int32_t run, int32_t fold)
    {
        ASSERT(0<=run);
        ASSERT(run<m_num_runs);
        ASSERT(0<=fold);
        ASSERT(fold<m_num_folds);
        REQUIRE(m_compute_conf_matrices, "Confusion matrices computation was not enabled\n");
        return m_conf_matrices[run*m_num_folds+fold];
    }

    virtual void post_init();

    virtual void post_update_results();

    virtual void init_expose_labels(CLabels* labels);

    virtual void update_test_result(CLabels* results,
            const char* prefix="");

    virtual void update_test_true_result(CLabels* results,
            const char* prefix="");

    virtual const char* get_name() const { return "CrossValidationMulticlassStorage"; }

protected:

    bool m_initialized;

    CDynamicObjectArray* m_binary_evaluations;

    SGVector<float64_t> m_evaluations_results;

    SGVector<float64_t> m_accuracies;

    bool m_compute_ROC;

    SGMatrix<float64_t>* m_fold_ROC_graphs; 

    bool m_compute_PRC;

    SGMatrix<float64_t>* m_fold_PRC_graphs; 

    bool m_compute_conf_matrices;

    SGMatrix<int32_t>* m_conf_matrices;

    CMulticlassLabels* m_pred_labels;

    CMulticlassLabels* m_true_labels;

    int32_t m_num_classes;

};

}

#endif /* CROSSVALIDATIONMULTICLASSSTORAGE_H_ */