drwnClassificationResults.h

/******************************************************************************
** DARWIN: A FRAMEWORK FOR MACHINE LEARNING RESEARCH AND DEVELOPMENT
** Distributed under the terms of the BSD license (see the LICENSE file)
** Copyright (c) 2007-2015, Stephen Gould
** All rights reserved.
**
******************************************************************************
** FILENAME:    drwnClassificationResults.h
** AUTHOR(S):   Stephen Gould <stephen.gould@anu.edu.au>
**
*****************************************************************************/

#pragma once

#include <cstdlib>
#include <vector>
#include <map>

#include "drwnBase.h"
#include "drwnDataset.h"
#include "drwnClassifier.h"

using namespace std;

// drwnClassificationResults ------------------------------------------------

class drwnClassificationResults {
 public:
    static bool INCLUDE_MISSES; 

 protected:
    map<double, pair<int, int> > _scoredResults;
    int _numPositiveSamples;  
    int _numNegativeSamples;  
    double _posWeight;        

 public:
    drwnClassificationResults();
    drwnClassificationResults(const drwnClassificationResults& c);
    virtual ~drwnClassificationResults();

    inline int numPositives() const { return _numPositiveSamples; }
    inline int numNegatives() const { return _numNegativeSamples; }
    inline int numSamples() const { return _numPositiveSamples + _numNegativeSamples; }
    inline int numThresholds() const { return (int)_scoredResults.size(); }
    inline int numMisses() const;

    inline double getPosWeight() const { return _posWeight; }
    inline void setPosWeight(double w) { DRWN_ASSERT(w > 0.0); _posWeight = w; }

    inline void normalize();

    // i/o
    void clear();
    bool write(const char *filename) const;
    bool read(const char *filename);

    // modify the statistics
    void accumulate(const drwnClassificationResults& c);
    void accumulate(const drwnClassifierDataset& dataset,
        drwnClassifier const *classifier, int positiveClassId = 1);
    void accumulatePositives(double score, int count = 1);
    void accumulatePositives(const vector<double>& scores);
    void accumulateNegatives(double score, int count = 1);
    void accumulateNegatives(const vector<double> &scores);

    void accumulateMisses(int count = 1);

    // reduce the number of points in the curve aggregating nearby scores
    // TODO: void quantize(double minThreshold = 0.0, double maxThreshold = 1.0, int numBins = 100);
};

// drwnPRCurve --------------------------------------------------------------

class drwnPRCurve : public drwnClassificationResults {
 public:
    drwnPRCurve();
    drwnPRCurve(const drwnClassificationResults& c);
    virtual ~drwnPRCurve();

    vector<pair<double, double> > getCurve() const;
    void writeCurve(const char *filename) const;
    double averagePrecision(unsigned numPoints = 11) const;
};

// drwnClassificationResults inline functions -------------------------------

inline void drwnClassificationResults::normalize()
{
    if ((_numPositiveSamples > 0) && (_numNegativeSamples > 0)) {
        _posWeight = (double)_numNegativeSamples / (double)_numPositiveSamples;
    } else {
        _posWeight = 1.0;
    }
}

inline int drwnClassificationResults::numMisses() const {
    int count = _numPositiveSamples;
    for (map<double, pair<int, int> >::const_iterator it = _scoredResults.begin();
         it != _scoredResults.end(); it++) {
        count -= it->second.first;
    }
    return count;
}