yap-6.3/packages/CLPBN/clpbn/bp/BnBpSolver.h

#ifndef HORUS_BNBPSOLVER_H
#define HORUS_BNBPSOLVER_H

#include <vector>
#include <set>

#include "Solver.h"
#include "BayesNet.h"
#include "Horus.h"
#include "Util.h"

using namespace std;

class BpNodeInfo;

static const string PI_SYMBOL = "pi" ;
static const string LD_SYMBOL = "ld" ;

enum LinkOrientation  {UP, DOWN};

class BpLink
{
  public:
    BpLink (BayesNode* s, BayesNode* d, LinkOrientation o)
    { 
      source_      = s;
      destin_      = d;
      orientation_ = o;
      if (orientation_ == LinkOrientation::DOWN) {
        v1_.resize (s->nrStates(), LogAware::tl (1.0 / s->nrStates()));
        v2_.resize (s->nrStates(), LogAware::tl (1.0 / s->nrStates()));
      } else {
        v1_.resize (d->nrStates(), LogAware::tl (1.0 / d->nrStates()));
        v2_.resize (d->nrStates(), LogAware::tl (1.0 / d->nrStates()));
      }
      currMsg_   = &v1_;
      nextMsg_   = &v2_;
      residual_  = 0;
      msgSended_ = false;
    }

    BayesNode* getSource (void) const { return source_; }

    BayesNode* getDestination (void) const { return destin_; }

    LinkOrientation getOrientation (void) const { return orientation_; }

    const Params& getMessage (void) const { return *currMsg_; }

    Params& getNextMessage (void) { return *nextMsg_;}

    bool messageWasSended (void) const { return msgSended_; }

    double getResidual (void) const { return residual_; }

    void clearResidual (void) { residual_ = 0;}

    void updateMessage (void)
    {
      swap (currMsg_, nextMsg_);
      msgSended_ = true;
    }
 
    void updateResidual (void)
    {
      residual_ = LogAware::getMaxNorm (v1_, v2_);
    }
   
    string toString (void) const
    {
      stringstream ss;
      if (orientation_ == LinkOrientation::DOWN) {
        ss << PI_SYMBOL;
      } else {
        ss << LD_SYMBOL;
      }
      ss << "(" << source_->label();
      ss << " --> " << destin_->label() << ")" ;
      return ss.str();
    }

    string toString (unsigned stateIndex) const
    {
      stringstream ss;
      ss << toString() << "[" ;
      if (orientation_ == LinkOrientation::DOWN) {
        ss << source_->states()[stateIndex] << "]" ;
      } else {
        ss << destin_->states()[stateIndex] << "]" ;
      }
      return ss.str();
    }
 
  private:
    BayesNode*       source_;
    BayesNode*       destin_;
    LinkOrientation  orientation_;
    Params           v1_;
    Params           v2_;
    Params*          currMsg_;
    Params*          nextMsg_;
    bool             msgSended_;
    double           residual_;
};

typedef vector<BpLink*> BpLinkSet;


class BpNodeInfo
{
  public:
    BpNodeInfo (BayesNode*);

    Params& getPiValues (void) { return piVals_; }

    Params& getLambdaValues (void) { return ldVals_; }

    const BpLinkSet& getIncomingParentLinks (void) { return inParentLinks_; }

    const BpLinkSet& getIncomingChildLinks (void) { return inChildLinks_; }

    const BpLinkSet& getOutcomingParentLinks (void) { return outParentLinks_; }

    const BpLinkSet& getOutcomingChildLinks (void) { return outChildLinks_; }
   
    void addIncomingParentLink  (BpLink* l)  { inParentLinks_.push_back (l); }

    void addIncomingChildLink   (BpLink* l)  { inChildLinks_.push_back (l); }

    void addOutcomingParentLink (BpLink* l)  { outParentLinks_.push_back (l); }

    void addOutcomingChildLink  (BpLink* l)  { outChildLinks_.push_back (l); }

    Params getBeliefs (void) const;

    bool receivedBottomInfluence (void) const;

   
  private:
    DISALLOW_COPY_AND_ASSIGN (BpNodeInfo);

    const BayesNode*  node_;
    Params            piVals_;
    Params            ldVals_;
    BpLinkSet         inParentLinks_;
    BpLinkSet         inChildLinks_;
    BpLinkSet         outParentLinks_;
    BpLinkSet         outChildLinks_;
};



class BnBpSolver : public Solver
{
  public:
    BnBpSolver (const BayesNet&);

   ~BnBpSolver (void);

    void runSolver (void);
    Params getPosterioriOf (VarId);
    Params getJointDistributionOf (const VarIds&);
  
  private:
    DISALLOW_COPY_AND_ASSIGN (BnBpSolver);

    void initializeSolver (void);

    void runLoopySolver (void);

    void maxResidualSchedule (void);

    bool converged (void) const;

    void updatePiValues (BayesNode*);

    void updateLambdaValues (BayesNode*);

    void calculateLambdaMessage (BpLink*);

    void calculatePiMessage (BpLink*);

    Params getJointByJunctionNode (const VarIds&);

    Params getJointByConditioning (const VarIds&) const;

    void printPiLambdaValues (const BayesNode*) const;

    void printAllMessageStatus (void) const;

    void calculateAndUpdateMessage (BpLink* link, bool calcResidual = true)
    {
      if (Constants::DEBUG >= 3) {
        cout << "calculating & updating " << link->toString() << endl;
      }
      if (link->getOrientation() == LinkOrientation::DOWN) {
        calculatePiMessage (link);
      } else if (link->getOrientation() == LinkOrientation::UP) {
        calculateLambdaMessage (link);
      }
      if (calcResidual) {
        link->updateResidual();
      }
      link->updateMessage();
    }

    void calculateMessage (BpLink* link, bool calcResidual = true)
    {
      if (Constants::DEBUG >= 3) {
        cout << "calculating " << link->toString() << endl;
      }
      if (link->getOrientation() == LinkOrientation::DOWN) {
        calculatePiMessage (link);
      } else if (link->getOrientation() == LinkOrientation::UP) {
        calculateLambdaMessage (link);
      }
      if (calcResidual) {
        link->updateResidual();
      }
    }

    void updateMessage (BpLink* link)
    {
      if (Constants::DEBUG >= 3) {
        cout << "updating " << link->toString() << endl;
      }
      link->updateMessage();
    }

    void updateValues (BpLink* link)
    {
      if (!link->getDestination()->hasEvidence()) {
        if (link->getOrientation() == LinkOrientation::DOWN) {
          updatePiValues (link->getDestination());
        } else if (link->getOrientation() == LinkOrientation::UP) {
          updateLambdaValues (link->getDestination());
        }
      }
    }

    BpNodeInfo* ninf (const BayesNode* node) const
    {
      assert (node);
      assert (node == bayesNet_->getBayesNode (node->varId()));
      assert (node->getIndex() < nodesI_.size());
      return nodesI_[node->getIndex()];
    }

    const BayesNet*      bayesNet_;
    vector<BpLink*>      links_;
    vector<BpNodeInfo*>  nodesI_;
    unsigned             nIters_;

    struct compare
    {
      inline bool operator() (const BpLink* e1, const BpLink* e2)
      {
        return e1->getResidual() > e2->getResidual();
      }
    };

    typedef multiset<BpLink*, compare> SortedOrder;
    SortedOrder sortedOrder_;

    typedef unordered_map<BpLink*, SortedOrder::iterator> BpLinkMap;
    BpLinkMap linkMap_;

};

#endif // HORUS_BNBPSOLVER_H