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

#pragma once

#include <cstdlib>
#include <vector>

#include "drwnBase.h"
#include "drwnFeatureMaps.h"

using namespace std;
using namespace Eigen;

// drwnFeatureTransform -----------------------------------------------------

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

 public:
    drwnFeatureTransform();
    drwnFeatureTransform(const drwnFeatureTransform& t);
    virtual ~drwnFeatureTransform() {
        // do nothing
    }

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

    // clone operation from (drwnStdObjIface)
    virtual drwnFeatureTransform *clone() const = 0;

    // i/o
    virtual void clear() { _nFeatures = 0; _bValid = false; }
    virtual bool save(drwnXMLNode& xml) const;
    virtual bool load(drwnXMLNode& xml);

    // training methods (implemented in derived classes)

    // evaluation (in-place and copy)
    virtual void transform(vector<double>& x) const;
    virtual void transform(const vector<double>& x, vector<double>& y) const = 0;
    virtual void transform(vector<vector<double> >& x) const;
    virtual void transform(const vector<vector<double> >& x,
        vector<vector<double> >& y) const;

    // evaluation with pre-processing (in-place and copy)
    virtual void transform(vector<double>& x, const drwnFeatureTransform& xform) const;
    virtual void transform(const vector<double>& x, vector<double>& y,
        const drwnFeatureTransform& xform) const;
    virtual void transform(vector<vector<double> >& x, const drwnFeatureTransform& xform) const;
    virtual void transform(const vector<vector<double> >& x,
        vector<vector<double> >& y, const drwnFeatureTransform& xform) const;
};

// drwnTFeatureMapTranform --------------------------------------------------

template<class FeatureMap>
class drwnTFeatureMapTransform : public drwnFeatureTransform {
 public:
    drwnTFeatureMapTransform() : drwnFeatureTransform() { /* do nothing */ }
    drwnTFeatureMapTransform(const drwnTFeatureMapTransform<FeatureMap> &t) :
       drwnFeatureTransform(t) { /* do nothing */ }
    ~drwnTFeatureMapTransform() { /* do nothing */ }

    // access
    const char *type() const { return "drwnTFeatureMapTransform"; }
    drwnTFeatureMapTransform<FeatureMap> *clone() const { 
        return new drwnTFeatureMapTransform<FeatureMap>(*this);
    }

    bool valid() const { return true; }

    // evaluation
    void transform(const vector<double>& x, vector<double>& y) const {
        const FeatureMap phi(x.size());
        y = phi(x);
    }
};

// drwnUnsupervisedTransform ------------------------------------------------

class drwnUnsupervisedTransform : public drwnFeatureTransform {
 public:
    drwnUnsupervisedTransform();
    drwnUnsupervisedTransform(const drwnUnsupervisedTransform& t);
    virtual ~drwnUnsupervisedTransform() {
        // do nothing
    }

    // clone operation from (drwnStdObjIface)
    virtual drwnUnsupervisedTransform *clone() const = 0;

    // training
    virtual double train(const vector<vector<double> >& features) = 0;
    virtual double train(const vector<vector<double> >& features,
        const vector<double>& weights);

    virtual double train(const vector<vector<double> >& features,
        const drwnFeatureTransform& xform);
    virtual double train(const vector<vector<double> >& features,
        const vector<double>& weights, const drwnFeatureTransform& xform);
};

// drwnSupervisedTransform --------------------------------------------------

class drwnSupervisedTransform : public drwnFeatureTransform {
 public:
    drwnSupervisedTransform();
    drwnSupervisedTransform(const drwnSupervisedTransform& t);
    virtual ~drwnSupervisedTransform() {
        // do nothing
    }

    // clone operation from (drwnStdObjIface)
    virtual drwnSupervisedTransform *clone() const = 0;

    // training
    virtual double train(const vector<vector<double> >& features,
        const vector<int>& labels) = 0;
    virtual double train(const vector<vector<double> >& features,
        const vector<int>& labels, const vector<double>& weights);

    virtual double train(const vector<vector<double> >& features,
        const vector<int>& labels, const drwnFeatureTransform& xform);
    virtual double train(const vector<vector<double> >& features,
        const vector<int>& labels, const vector<double>& weights,
        const drwnFeatureTransform& xform);
};

// drwnFeatureTransformFactory ----------------------------------------------

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

typedef drwnFactory<drwnFeatureTransform> drwnFeatureTransformFactory;