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

#pragma once

#include <cstdlib>
#include <vector>

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

using namespace std;

// drwnClassifier -----------------------------------------------------------

class drwnClassifier : public drwnStdObjIface, public drwnProperties {
 protected:
    int _nFeatures;     
    int _nClasses;      
    bool _bValid;       

 public:
    drwnClassifier();
    drwnClassifier(unsigned n, unsigned k = 2);
    drwnClassifier(const drwnClassifier &c);
    virtual ~drwnClassifier() { /* do nothing */ }

    // access functions
    int numFeatures() const { return _nFeatures; }
    int numClasses() const { return _nClasses; }
    virtual bool valid() const { return _bValid; }

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

    // i/o
    virtual drwnClassifier *clone() const = 0;
    virtual bool save(drwnXMLNode& xml) const;
    virtual bool load(drwnXMLNode& xml);

    // training
    virtual double train(const drwnClassifierDataset& dataset) = 0;
    virtual double train(const vector<vector<double> >& features,
        const vector<int>& targets);
    virtual double train(const vector<vector<double> >& features,
        const vector<int>& targets, const vector<double>& weights);
    virtual double train(const char *filename);

    // evaluation (log-probability unnormalized)
    virtual void getClassScores(const vector<double>& features,
        vector<double>& outputScores) const = 0;
    virtual void getClassScores(const vector<vector<double> >& features,
        vector<vector<double> >& outputScores) const;

    // evaluation (normalized marginals)
    virtual void getClassMarginals(const vector<double>& features,
        vector<double>& outputMarginals) const;
    virtual void getClassMarginals(const vector<vector<double> >& features,
        vector<vector<double> >& outputMarginals) const;

    // evaluation (classification)
    virtual int getClassification(const vector<double>& features) const;
    virtual void getClassifications(const vector<vector<double> >& features,
        vector<int>& outputLabels) const;
};

// drwnClassifierFactory ----------------------------------------------------

template <>
struct drwnFactoryTraits<drwnClassifier> {
    static void staticRegistration();
};

typedef drwnFactory<drwnClassifier> drwnClassifierFactory;