drwnBoostedClassifier.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:    drwnBoostedClassifier.h
** AUTHOR(S):   Stephen Gould <stephen.gould@anu.edu.au>
**
*****************************************************************************/

#pragma once

#include <cstdlib>
#include <vector>

#include "drwnBase.h"
#include "drwnClassifier.h"
#include "drwnDecisionTree.h"

using namespace std;

// drwnBoostingMethod --------------------------------------------------------

typedef enum _drwnBoostingMethod {
    DRWN_BOOST_DISCRETE, DRWN_BOOST_GENTLE, DRWN_BOOST_REAL
} drwnBoostingMethod;

// drwnBoostedClassifier -----------------------------------------------------

class drwnBoostedClassifier : public drwnClassifier {
 public:
    // default training parameters
    static drwnBoostingMethod METHOD;
    static int NUM_ROUNDS;   
    static int MAX_DEPTH;    
    static double SHRINKAGE; 

 protected:
    // actual training parameters
    drwnBoostingMethod _method;    
    int _numRounds;                
    int _maxDepth;                 
    double _shrinkage;             

    vector<drwnDecisionTree *> _weakLearners;
    vector<double> _alphas;

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

    // access functions
    virtual const char *type() const { return "drwnBoostedClassifier"; }
    virtual drwnBoostedClassifier *clone() const { return new drwnBoostedClassifier(*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);

    void pruneRounds(unsigned numRounds);

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

 protected:

};