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

#pragma once

#include <vector>
#include <set>
#include <map>

#include "drwnBase.h"
#include "drwnVarUniverse.h"
#include "drwnVarAssignment.h"
#include "drwnFactorGraph.h"
#include "drwnTableFactorOps.h"

// drwnInference class -----------------------------------------------------

class drwnInference {
 protected:
    const drwnFactorGraph& _graph; 

 public:
    drwnInference(const drwnFactorGraph& graph);
    drwnInference(const drwnInference& inf);
    virtual ~drwnInference();

    virtual void clear() { /* do nothing */ };
    virtual bool inference() = 0;
    virtual void marginal(drwnTableFactor& belief) const = 0;
    virtual drwnFactorGraph varMarginals() const;

    inline drwnTableFactor operator[](int varIndx) const {
        drwnTableFactor factor(_graph.getUniverse());
        factor.addVariable(varIndx);
        marginal(factor);
        return factor;
    }
    inline drwnTableFactor operator[](const char* varName) const {
        return (*this)[_graph.getUniverse()->findVariable(varName)];
    }
};

// drwnMessagePassingInference class ----------------------------------------

class drwnMessagePassingInference : public drwnInference
{
 public:
    static unsigned MAX_ITERATIONS; 

 protected:
    // forward and backward messages during each iteration
    vector<drwnTableFactor *> _forwardMessages;
    vector<drwnTableFactor *> _backwardMessages;
    vector<drwnTableFactor *> _oldForwardMessages;
    vector<drwnTableFactor *> _oldBackwardMessages;

    // computation tree: intermediate factors, and (atomic) factor operations
    vector<drwnTableFactor *> _intermediateFactors;
    vector<drwnFactorOperation *> _computations;

    // shared storage for intermediate factors
    vector<drwnTableFactorStorage *> _sharedStorage;

 public:
    drwnMessagePassingInference(const drwnFactorGraph& graph);
    //drwnMessagePassingInference(const drwnMessagePassingInference& inf);
    virtual ~drwnMessagePassingInference();

    void clear();
    bool inference();

 protected:
    virtual void initializeMessages();
    virtual void buildComputationGraph() = 0;
};

// drwnSumProductInference class --------------------------------------------

class drwnSumProdInference : public drwnMessagePassingInference {
 public:
    drwnSumProdInference(const drwnFactorGraph& graph);
    ~drwnSumProdInference();

    void marginal(drwnTableFactor& belief) const;

 protected:
    void buildComputationGraph();
};

// drwnAsyncSumProductInference class ---------------------------------------

class drwnAsyncSumProdInference : public drwnSumProdInference {
 public:
    drwnAsyncSumProdInference(const drwnFactorGraph& graph);
    ~drwnAsyncSumProdInference();

 protected:
    void buildComputationGraph();
};