bbp.h

Go to the documentation of this file.

/*  This file is part of libDAI - http://www.libdai.org/
 *
 *  Copyright (c) 2006-2011, The libDAI authors. All rights reserved.
 *
 *  Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.
 */




#ifndef ___defined_libdai_bbp_h
#define ___defined_libdai_bbp_h


#include <dai/dai_config.h>
#ifdef DAI_WITH_CBP


#include <vector>
#include <utility>

#include <dai/prob.h>
#include <dai/daialg.h>
#include <dai/factorgraph.h>
#include <dai/enum.h>
#include <dai/bp_dual.h>


namespace dai {



DAI_ENUM(BBPCostFunctionBase,CFN_GIBBS_B,CFN_GIBBS_B2,CFN_GIBBS_EXP,CFN_GIBBS_B_FACTOR,CFN_GIBBS_B2_FACTOR,CFN_GIBBS_EXP_FACTOR,CFN_VAR_ENT,CFN_FACTOR_ENT,CFN_BETHE_ENT);


class BBPCostFunction : public BBPCostFunctionBase {
    public:
        BBPCostFunction() : BBPCostFunctionBase() {}

        BBPCostFunction( const BBPCostFunctionBase &x ) : BBPCostFunctionBase(x) {}

        bool needGibbsState() const;

        Real evaluate( const InfAlg &ia, const std::vector<size_t> *stateP ) const;

        BBPCostFunction& operator=( const BBPCostFunctionBase &x ) {
            BBPCostFunctionBase::operator=( x );
            return *this;
        }
};



class BBP {
    private:

        BP_dual _bp_dual;
        const FactorGraph *_fg;
        const InfAlg *_ia;


        std::vector<Prob> _adj_psi_V;
        std::vector<Prob> _adj_psi_F;
        std::vector<std::vector<Prob> > _adj_n;
        std::vector<std::vector<Prob> > _adj_m;
        std::vector<Prob> _adj_b_V;
        std::vector<Prob> _adj_b_F;


        std::vector<Prob> _init_adj_psi_V;
        std::vector<Prob> _init_adj_psi_F;

        std::vector<std::vector<Prob> > _adj_n_unnorm;
        std::vector<std::vector<Prob> > _adj_m_unnorm;
        std::vector<std::vector<Prob> > _new_adj_n;
        std::vector<std::vector<Prob> > _new_adj_m;
        std::vector<Prob> _adj_b_V_unnorm;
        std::vector<Prob> _adj_b_F_unnorm;

        std::vector<std::vector<Prob > > _Tmsg;
        std::vector<std::vector<Prob > > _Umsg;
        std::vector<std::vector<std::vector<Prob > > > _Smsg;
        std::vector<std::vector<std::vector<Prob > > > _Rmsg;

        size_t _iters;


        typedef std::vector<size_t>  _ind_t;
        std::vector<std::vector<_ind_t> >  _indices;

        void RegenerateInds();
        const _ind_t& _index(size_t i, size_t _I) const { return _indices[i][_I]; }


        void RegenerateT();
        void RegenerateU();
        void RegenerateS();
        void RegenerateR();
        void RegenerateInputs();

        void RegeneratePsiAdjoints();

        void RegenerateParMessageAdjoints();

        void RegenerateSeqMessageAdjoints();
        void Regenerate();


        Prob & T(size_t i, size_t _I) { return _Tmsg[i][_I]; }
        const Prob & T(size_t i, size_t _I) const { return _Tmsg[i][_I]; }
        Prob & U(size_t I, size_t _i) { return _Umsg[I][_i]; }
        const Prob & U(size_t I, size_t _i) const { return _Umsg[I][_i]; }
        Prob & S(size_t i, size_t _I, size_t _j) { return _Smsg[i][_I][_j]; }
        const Prob & S(size_t i, size_t _I, size_t _j) const { return _Smsg[i][_I][_j]; }
        Prob & R(size_t I, size_t _i, size_t _J) { return _Rmsg[I][_i][_J]; }
        const Prob & R(size_t I, size_t _i, size_t _J) const { return _Rmsg[I][_i][_J]; }

        Prob& adj_n(size_t i, size_t _I) { return _adj_n[i][_I]; }
        const Prob& adj_n(size_t i, size_t _I) const { return _adj_n[i][_I]; }
        Prob& adj_m(size_t i, size_t _I) { return _adj_m[i][_I]; }
        const Prob& adj_m(size_t i, size_t _I) const { return _adj_m[i][_I]; }



        void calcNewN( size_t i, size_t _I );

        void calcNewM( size_t i, size_t _I );
        void calcUnnormMsgN( size_t i, size_t _I );
        void calcUnnormMsgM( size_t i, size_t _I );
        void upMsgN( size_t i, size_t _I );
        void upMsgM( size_t i, size_t _I );
        void doParUpdate();


        void incrSeqMsgM( size_t i, size_t _I, const Prob& p );
        //  DISABLED BECAUSE IT IS BUGGY:
        //  void updateSeqMsgM( size_t i, size_t _I );
        void setSeqMsgM( size_t i, size_t _I, const Prob &p );
        void sendSeqMsgN( size_t i, size_t _I, const Prob &f );
        void sendSeqMsgM( size_t i, size_t _I );


        Prob unnormAdjoint( const Prob &w, Real Z_w, const Prob &adj_w );

        Real getUnMsgMag();
        void getMsgMags( Real &s, Real &new_s );
        void getArgmaxMsgM( size_t &i, size_t &_I, Real &mag );
        Real getMaxMsgM();

        Real getTotalMsgM();
        Real getTotalNewMsgM();
        Real getTotalMsgN();

        std::vector<Prob> getZeroAdjF( const FactorGraph &fg );
        std::vector<Prob> getZeroAdjV( const FactorGraph &fg );

    public:


        BBP( const InfAlg *ia, const PropertySet &opts ) : _bp_dual(ia), _fg(&(ia->fg())), _ia(ia) {
            props.set(opts);
        }


        void init( const std::vector<Prob> &adj_b_V, const std::vector<Prob> &adj_b_F, const std::vector<Prob> &adj_psi_V, const std::vector<Prob> &adj_psi_F ) {
            _adj_b_V = adj_b_V;
            _adj_b_F = adj_b_F;
            _init_adj_psi_V = adj_psi_V;
            _init_adj_psi_F = adj_psi_F;
            Regenerate();
        }

        void init( const std::vector<Prob> &adj_b_V, const std::vector<Prob> &adj_b_F ) {
            init( adj_b_V, adj_b_F, getZeroAdjV(*_fg), getZeroAdjF(*_fg) );
        }

        void init_V( const std::vector<Prob> &adj_b_V ) {
            init( adj_b_V, getZeroAdjF(*_fg) );
        }

        void init_F( const std::vector<Prob> &adj_b_F ) {
            init( getZeroAdjV(*_fg), adj_b_F );
        }


        void initCostFnAdj( const BBPCostFunction &cfn, const std::vector<size_t> *stateP );


        void run();


        Prob& adj_psi_V(size_t i) { return _adj_psi_V[i]; }
        const Prob& adj_psi_V(size_t i) const { return _adj_psi_V[i]; }
        Prob& adj_psi_F(size_t I) { return _adj_psi_F[I]; }
        const Prob& adj_psi_F(size_t I) const { return _adj_psi_F[I]; }
        Prob& adj_b_V(size_t i) { return _adj_b_V[i]; }
        const Prob& adj_b_V(size_t i) const { return _adj_b_V[i]; }
        Prob& adj_b_F(size_t I) { return _adj_b_F[I]; }
        const Prob& adj_b_F(size_t I) const { return _adj_b_F[I]; }
        size_t Iterations() { return _iters; }

    public:
        /* PROPERTIES(props,BBP) {
           DAI_ENUM(UpdateType,SEQ_FIX,SEQ_MAX,SEQ_BP_REV,SEQ_BP_FWD,PAR);

           size_t verbose = 0;

           size_t maxiter;

           Real tol;

           Real damping;

           UpdateType updates;

           // DISABLED BECAUSE IT IS BUGGY:
           // bool clean_updates;
        }
        */
/* {{{ GENERATED CODE: DO NOT EDIT. Created by
    ./scripts/regenerate-properties include/dai/bbp.h src/bbp.cpp
*/
        struct Properties {

            DAI_ENUM(UpdateType,SEQ_FIX,SEQ_MAX,SEQ_BP_REV,SEQ_BP_FWD,PAR);
            size_t verbose;
            size_t maxiter;

            Real tol;
            Real damping;
            UpdateType updates;


            void set(const PropertySet &opts);
            PropertySet get() const;
            std::string toString() const;
        } props;
/* }}} END OF GENERATED CODE */
};



Real numericBBPTest( const InfAlg &bp, const std::vector<size_t> *state, const PropertySet &bbp_props, const BBPCostFunction &cfn, Real h );


} // end of namespace dai


#endif


#endif