drwnCompositeClassifier.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-2017, Stephen Gould
** All rights reserved.
**
******************************************************************************
** FILENAME:    drwnCompositeClassifier.h
** AUTHOR(S):   Stephen Gould <stephen.gould@anu.edu.au>
**
*****************************************************************************/

#pragma once

#include <cstdlib>
#include <vector>

#include "drwnBase.h"
#include "drwnClassifier.h"
#include "drwnMultiClassLogistic.h"
#include "drwnFeatureWhitener.h"

using namespace std;

// drwnCompositeClassifierMethod ---------------------------------------------

typedef enum _drwnCompositeClassifierMethod {
    DRWN_ONE_VS_ALL = 0, 
    DRWN_ONE_VS_ONE      
} drwnCompositeClassifierMethod;

// drwnCompositeClassifier ---------------------------------------------------

class drwnCompositeClassifier : public drwnClassifier {
 public:
    // default meta-parameters
    static string BASE_CLASSIFIER; 
    static drwnCompositeClassifierMethod METHOD; 

 protected:
    // actual meta-parameters
    string _baseClassifier;        
    drwnCompositeClassifierMethod _method; 

    vector<drwnClassifier *> _binaryClassifiers;
    drwnFeatureWhitener _featureWhitener;
    drwnTMultiClassLogistic<drwnBiasJointFeatureMap> _calibrationWeights;

 public:
    drwnCompositeClassifier();
    drwnCompositeClassifier(unsigned n, unsigned k = 2);
    drwnCompositeClassifier(const drwnCompositeClassifier &c);
    ~drwnCompositeClassifier();

    // access functions
    virtual const char *type() const { return "drwnCompositeClassifier"; }
    virtual drwnCompositeClassifier *clone() const { return new drwnCompositeClassifier(*this); }

    // initialization
    virtual void initialize(unsigned n, unsigned k = 2);

    // i/o
    virtual bool save(drwnXMLNode& node) const;
    virtual bool load(drwnXMLNode& node);

    // training
    using drwnClassifier::train;
    virtual double train(const drwnClassifierDataset& dataset);

    // evaluation (log-probability)
    using drwnClassifier::getClassScores;
    virtual void getClassScores(const vector<double>& features,
        vector<double>& outputScores) const;

 protected:

};