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

#pragma once

#include "drwnNNGraph.h"

using namespace std;
using namespace Eigen;

// drwnNNGraphLearner --------------------------------------------------------

class drwnNNGraphLearner {
 public:
    static double ALPHA_ZERO;
    static unsigned METRIC_ITERATIONS;
    static unsigned SEARCH_ITERATIONS;

 protected:
    const drwnNNGraph& _graph;
    double _lambda;
    vector<double> _labelWeights;

    drwnNNGraph _posGraph;
    drwnNNGraph _negGraph;

    unsigned _dim;              
    MatrixXd _X;                

 public:
    drwnNNGraphLearner(const drwnNNGraph& graph, double lambda);
    virtual ~drwnNNGraphLearner();

    virtual void setTransform(const MatrixXd& Lt) = 0;
    virtual MatrixXd getTransform() const = 0;
    virtual double learn(unsigned maxCycles);

    const drwnNNGraph& getSrcGraph() const { return _graph; }
    const drwnNNGraph& getPosGraph() const { return _posGraph; }
    const drwnNNGraph& getNegGraph() const { return _negGraph; }

    void clearLabelWeights() { _labelWeights.clear(); }
    void setLabelWeights(const vector<double>& w) {
        DRWN_LOG_VERBOSE("...setting label weights to " << toString(w));
        _labelWeights = w;
    };
    const vector<double>& getLabelWeights() const { return _labelWeights; }

 protected:
    virtual double computeObjective() const;
    virtual double computeLossFunction() const;
    virtual MatrixXd computeSubGradient() = 0;
    virtual void subGradientStep(const MatrixXd& G, double alpha) = 0;

    virtual void startMetricCycle();
    virtual void endMetricCycle();

    void updateGraphFeatures();
    void nearestNeighbourUpdate(unsigned nCycle, unsigned maxIterations);

    MatrixXd initializeTransform() const;
};

// drwnNNGraphMLearner -------------------------------------------------------

typedef set<pair<drwnNNGraphNodeIndex, drwnNNGraphNodeIndex> > drwnNNGraphLearnViolatedConstraints;

class drwnNNGraphMLearner : public drwnNNGraphLearner {
 protected:
    MatrixXd _M;

    MatrixXd _G;
    drwnNNGraphNodeAnnotation<drwnNNGraphLearnViolatedConstraints> _updateCache;

 public:
    drwnNNGraphMLearner(const drwnNNGraph& graph, double lambda);
    ~drwnNNGraphMLearner();

    void setTransform(const MatrixXd& Lt);
    MatrixXd getTransform() const;

 protected:
    MatrixXd computeSubGradient();
    void subGradientStep(const MatrixXd& G, double alpha);

    void startMetricCycle();
};

// drwnNNGraphLLearner -------------------------------------------------------

class drwnNNGraphLLearner : public drwnNNGraphLearner {
 protected:
    MatrixXd _Lt;

    MatrixXd _G;
    drwnNNGraphNodeAnnotation<drwnNNGraphLearnViolatedConstraints> _updateCache;

 public:
    drwnNNGraphLLearner(const drwnNNGraph& graph, double lambda);
    ~drwnNNGraphLLearner();

    void setTransform(const MatrixXd& Lt);
    MatrixXd getTransform() const;

 protected:
    MatrixXd computeSubGradient();
    void subGradientStep(const MatrixXd& G, double alpha);

    void startMetricCycle();
};

// drwnNNGraphSparseLearner --------------------------------------------------

class drwnNNGraphSparseLearner : public drwnNNGraphLearner {
 public:
    drwnNNGraphSparseLearner(const drwnNNGraph& graph, double lambda);
    ~drwnNNGraphSparseLearner();

 protected:
    virtual double computeLossFunction() const;
};

// drwnNNGraphLFastLearner ---------------------------------------------------

typedef drwnTriplet<bool, drwnNNGraphNodeIndex, drwnNNGraphNodeIndex>
    drwnNNGraphLearnSparseViolatedConstraint;

class drwnNNGraphLSparseLearner : public drwnNNGraphSparseLearner {
 protected:
    MatrixXd _Lt;

    MatrixXd _G;
    drwnNNGraphNodeAnnotation<drwnNNGraphLearnSparseViolatedConstraint> _updateCache;

 public:
    drwnNNGraphLSparseLearner(const drwnNNGraph& graph, double lambda);
    ~drwnNNGraphLSparseLearner();

    void setTransform(const MatrixXd& Lt);
    MatrixXd getTransform() const;

 protected:
    MatrixXd computeSubGradient();
    void subGradientStep(const MatrixXd& G, double alpha);

    void startMetricCycle();
};