ContingencyTableEvaluation.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) 2011 Sergey Lisitsyn
 * Copyright (C) 2011 Berlin Institute of Technology and Max-Planck-Society
 */

#ifndef CONTINGENCYTABLEEVALUATION_H_
#define CONTINGENCYTABLEEVALUATION_H_

#include <shogun/lib/config.h>

#include <shogun/evaluation/BinaryClassEvaluation.h>
#include <shogun/labels/Labels.h>
#include <shogun/mathematics/Math.h>
#include <shogun/io/SGIO.h>

namespace shogun
{

class CLabels;

enum EContingencyTableMeasureType
{
    ACCURACY = 0,
    ERROR_RATE = 10,
    BAL = 20,
    WRACC = 30,
    F1 = 40,
    CROSS_CORRELATION = 50,
    RECALL = 60,
    PRECISION = 70,
    SPECIFICITY = 80,
    CUSTOM = 999
};

class CContingencyTableEvaluation: public CBinaryClassEvaluation
{

public:

    CContingencyTableEvaluation() :
        CBinaryClassEvaluation(), m_type(ACCURACY), m_computed(false) {};

    CContingencyTableEvaluation(EContingencyTableMeasureType type) :
        CBinaryClassEvaluation(), m_type(type), m_computed(false)  {};

    virtual ~CContingencyTableEvaluation() {};

    virtual float64_t evaluate(CLabels* predicted, CLabels* ground_truth);

    virtual EEvaluationDirection get_evaluation_direction() const;

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

    inline float64_t get_accuracy() const
    {
        if (!m_computed)
            SG_ERROR("Uninitialized, please call evaluate first")

        return (m_TP+m_TN)/m_N;
    };

    inline float64_t get_error_rate() const
    {
        if (!m_computed)
                SG_ERROR("Uninitialized, please call evaluate first")

        return (m_FP + m_FN)/m_N;
    };

    inline float64_t get_BAL() const
    {
        if (!m_computed)
                SG_ERROR("Uninitialized, please call evaluate first")

        return 0.5*(m_FN/(m_FN + m_TP) + m_FP/(m_FP + m_TN));
    };

    inline float64_t get_WRACC() const
    {
        if (!m_computed)
                SG_ERROR("Uninitialized, please call evaluate first")

        return m_TP/(m_FN + m_TP) - m_FP/(m_FP + m_TN);
    };

    inline float64_t get_F1() const
    {
        if (!m_computed)
                SG_ERROR("Uninitialized, please call evaluate first")

        return (2*m_TP)/(2*m_TP + m_FP + m_FN);
    };

    inline float64_t get_cross_correlation() const
    {
        if (!m_computed)
                SG_ERROR("Uninitialized, please call evaluate first")

        return (m_TP*m_TN-m_FP*m_FN)/CMath::sqrt((m_TP+m_FP)*(m_TP+m_FN)*(m_TN+m_FP)*(m_TN+m_FN));
    };

    inline float64_t get_recall() const
    {
        if (!m_computed)
                SG_ERROR("Uninitialized, please call evaluate first")

        return m_TP/(m_TP+m_FN);
    };

    inline float64_t get_precision() const
    {
        if (!m_computed)
                SG_ERROR("Uninitialized, please call evaluate first")

        return m_TP/(m_TP+m_FP);
    };

    inline float64_t get_specificity() const
    {
        if (!m_computed)
                SG_ERROR("Uninitialized, please call evaluate first")

        return m_TN/(m_TN+m_FP);
    };

    float64_t get_TP() const
    {
        return m_TP;
    }
    float64_t get_FP() const
    {
        return m_FP;
    }
    float64_t get_TN() const
    {
        return m_TN;
    }
    float64_t get_FN() const
    {
        return m_FN;
    }

    virtual float64_t get_custom_score()
    {
        SG_NOTIMPLEMENTED
        return 0.0;
    }

    virtual EEvaluationDirection get_custom_direction() const
    {
        SG_NOTIMPLEMENTED
        return ED_MAXIMIZE;
    }

protected:

    void compute_scores(CBinaryLabels* predicted, CBinaryLabels* ground_truth);

    EContingencyTableMeasureType m_type;

    bool m_computed;

    int32_t m_N;

    float64_t m_TP;

    float64_t m_FP;

    float64_t m_TN;

    float64_t m_FN;
};

class CAccuracyMeasure: public CContingencyTableEvaluation
{
public:
    /* constructor */
    CAccuracyMeasure() : CContingencyTableEvaluation(ACCURACY) {};
    /* virtual destructor */
    virtual ~CAccuracyMeasure() {};
    /* name */
    virtual const char* get_name() const { return "AccuracyMeasure"; };
};

class CErrorRateMeasure: public CContingencyTableEvaluation
{
public:
    /* constructor */
    CErrorRateMeasure() : CContingencyTableEvaluation(ERROR_RATE) {};
    /* virtual destructor */
    virtual ~CErrorRateMeasure() {};
    /* name */
    virtual const char* get_name() const { return "ErrorRateMeasure"; };
};

class CBALMeasure: public CContingencyTableEvaluation
{
public:
    /* constructor */
    CBALMeasure() : CContingencyTableEvaluation(BAL) {};
    /* virtual destructor */
    virtual ~CBALMeasure() {};
    /* name */
    virtual const char* get_name() const { return "BALMeasure"; };
};

class CWRACCMeasure: public CContingencyTableEvaluation
{
public:
    /* constructor */
    CWRACCMeasure() : CContingencyTableEvaluation(WRACC) {};
    /* virtual destructor */
    virtual ~CWRACCMeasure() {};
    /* name */
    virtual const char* get_name() const { return "WRACCMeasure"; };
};

class CF1Measure: public CContingencyTableEvaluation
{
public:
    /* constructor */
    CF1Measure() : CContingencyTableEvaluation(F1) {};
    /* virtual destructor */
    virtual ~CF1Measure() {};
    /* name */
    virtual const char* get_name() const { return "F1Measure"; };
};

class CCrossCorrelationMeasure: public CContingencyTableEvaluation
{
public:
    /* constructor */
    CCrossCorrelationMeasure() : CContingencyTableEvaluation(CROSS_CORRELATION) {};
    /* virtual destructor */
    virtual ~CCrossCorrelationMeasure() {};
    /* name */
    virtual const char* get_name() const { return "CrossCorrelationMeasure"; };
};

class CRecallMeasure: public CContingencyTableEvaluation
{
public:
    /* constructor */
    CRecallMeasure() : CContingencyTableEvaluation(RECALL) {};
    /* virtual destructor */
    virtual ~CRecallMeasure() {};
    /* name */
    virtual const char* get_name() const { return "RecallMeasure"; };
};

class CPrecisionMeasure: public CContingencyTableEvaluation
{
public:
    /* constructor */
    CPrecisionMeasure() : CContingencyTableEvaluation(PRECISION) {};
    /* virtual destructor */
    virtual ~CPrecisionMeasure() {};
    /* name */
    virtual const char* get_name() const { return "PrecisionMeasure"; };
};

class CSpecificityMeasure: public CContingencyTableEvaluation
{
public:
    /* constructor */
    CSpecificityMeasure() : CContingencyTableEvaluation(SPECIFICITY) {};
    /* virtual destructor */
    virtual ~CSpecificityMeasure() {};
    /* name */
    virtual const char* get_name() const { return "SpecificityMeasure"; };
};
}
#endif /* CONTINGENCYTABLEEVALUATION_H_ */