lazyPropagation.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005 by Christophe GONZALES et Pierre-Henri WUILLEMIN   *
 *   {prenom.nom}_at_lip6.fr                                               *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifndef GUM_LAZY_PROPAGATION_H
#define GUM_LAZY_PROPAGATION_H

#include <utility>

#include <agrum/core/math/math.h>
#include <agrum/BN/algorithms/barrenNodesFinder.h>
#include <agrum/BN/inference/tools/evidenceInference.h>
#include <agrum/BN/inference/tools/jointTargetedInference.h>
#include <agrum/BN/inference/tools/relevantPotentialsFinderType.h>
#include <agrum/agrum.h>
#include <agrum/graphs/algorithms/triangulations/defaultTriangulation.h>

namespace gum {


  // the function used to combine two tables
  template < typename GUM_SCALAR >
  INLINE static Potential< GUM_SCALAR >*
     LPNewmultiPotential(const Potential< GUM_SCALAR >& t1,
                         const Potential< GUM_SCALAR >& t2) {
    return new Potential< GUM_SCALAR >(t1 * t2);
  }

  // the function used to combine two tables
  template < typename GUM_SCALAR >
  INLINE static Potential< GUM_SCALAR >*
     LPNewprojPotential(const Potential< GUM_SCALAR >&        t1,
                        const Set< const DiscreteVariable* >& del_vars) {
    return new Potential< GUM_SCALAR >(t1.margSumOut(del_vars));
  }


  template < typename GUM_SCALAR >
  class LazyPropagation
      : public JointTargetedInference< GUM_SCALAR >
      , public EvidenceInference< GUM_SCALAR > {
    public:
    // ############################################################################
    // ############################################################################

    explicit LazyPropagation(
       const IBayesNet< GUM_SCALAR >* BN,
       RelevantPotentialsFinderType =
          RelevantPotentialsFinderType::DSEP_BAYESBALL_POTENTIALS,
       FindBarrenNodesType = FindBarrenNodesType::FIND_BARREN_NODES,
       bool use_binary_join_tree = true);

    LazyPropagation(const LazyPropagation< GUM_SCALAR >&) = delete;

    LazyPropagation< GUM_SCALAR >&
       operator=(const LazyPropagation< GUM_SCALAR >&) = delete;

    ~LazyPropagation() final;



    // ############################################################################
    // ############################################################################

    void setTriangulation(const Triangulation& new_triangulation);


    void setRelevantPotentialsFinderType(RelevantPotentialsFinderType type);


    void setFindBarrenNodesType(FindBarrenNodesType type);



    const JoinTree* joinTree();


    const JunctionTree* junctionTree();
    GUM_SCALAR evidenceProbability() final;



    protected:
    void _onEvidenceAdded(const NodeId id, bool isHardEvidence) final;

    void _onEvidenceErased(const NodeId id, bool isHardEvidence) final;

    void _onAllEvidenceErased(bool has_hard_evidence) final;

    void _onEvidenceChanged(const NodeId id, bool hasChangedSoftHard) final;


    void _onMarginalTargetAdded(const NodeId id) final;


    void _onMarginalTargetErased(const NodeId id) final;

    virtual void _onBayesNetChanged(const IBayesNet< GUM_SCALAR >* bn) final;


    void _onJointTargetAdded(const NodeSet& set) final;


    void _onJointTargetErased(const NodeSet& set) final;

    void _onAllMarginalTargetsAdded() final;

    void _onAllMarginalTargetsErased() final;

    void _onAllJointTargetsErased() final;

    void _onAllTargetsErased() final;

    void _onStateChanged() final{};


    void _updateOutdatedBNStructure() final;


    void _updateOutdatedBNPotentials() final;


    void _makeInference() final;



    const Potential< GUM_SCALAR >& _posterior(NodeId id) final;


    const Potential< GUM_SCALAR >& _jointPosterior(const NodeSet& set) final;

    const Potential< GUM_SCALAR >&
       _jointPosterior(const NodeSet& wanted_target,
                       const NodeSet& declared_target) final;

    Potential< GUM_SCALAR >* _unnormalizedJointPosterior(NodeId id) final;

    Potential< GUM_SCALAR >* _unnormalizedJointPosterior(const NodeSet& set) final;


    private:
    typedef Set< const Potential< GUM_SCALAR >* > __PotentialSet;
    typedef SetIteratorSafe< const Potential< GUM_SCALAR >* >
       __PotentialSetIterator;


    RelevantPotentialsFinderType __find_relevant_potential_type;

    void (LazyPropagation< GUM_SCALAR >::*__findRelevantPotentials)(
       Set< const Potential< GUM_SCALAR >* >& pot_list,
       Set< const DiscreteVariable* >&        kept_vars);

    FindBarrenNodesType __barren_nodes_type;

    Potential< GUM_SCALAR >* (*__projection_op)(
       const Potential< GUM_SCALAR >&,
       const Set< const DiscreteVariable* >&){LPNewprojPotential};

    Potential< GUM_SCALAR >* (*__combination_op)(const Potential< GUM_SCALAR >&,
                                                 const Potential< GUM_SCALAR >&){
       LPNewmultiPotential};

    Triangulation* __triangulation;

    bool __use_binary_join_tree{true};


    UndiGraph __graph;

    JoinTree* __JT{nullptr};

    JunctionTree* __junctionTree{nullptr};


    bool __is_new_jt_needed{true};


    NodeSet __roots;

    HashTable< NodeId, NodeId > __node_to_clique;

    HashTable< NodeSet, NodeId > __joint_target_to_clique;


    NodeProperty< __PotentialSet > __clique_potentials;


    ArcProperty< __PotentialSet > __separator_potentials;


    ArcProperty< __PotentialSet > __created_potentials;


    NodeProperty< const Potential< GUM_SCALAR >* > __target_posteriors;


    HashTable< NodeSet, const Potential< GUM_SCALAR >* > __joint_target_posteriors;

    NodeProperty< GUM_SCALAR > __constants;


    ArcProperty< bool > __messages_computed;


    NodeProperty< const Potential< GUM_SCALAR >* > __node_to_soft_evidence;


    NodeProperty< const Potential< GUM_SCALAR >* > __hard_ev_projected_CPTs;

    NodeSet __hard_ev_nodes;

    enum EvidenceChangeType { EVIDENCE_ADDED, EVIDENCE_ERASED, EVIDENCE_MODIFIED };

    NodeProperty< EvidenceChangeType > __evidence_changes;

    const GUM_SCALAR __1_minus_epsilon{GUM_SCALAR(1.0 - 1e-6)};


    bool __isNewJTNeeded() const;

    void __createNewJT();
    void __setProjectionFunction(Potential< GUM_SCALAR >* (*proj)(
       const Potential< GUM_SCALAR >&, const Set< const DiscreteVariable* >&));

    void __setCombinationFunction(Potential< GUM_SCALAR >* (*comb)(
       const Potential< GUM_SCALAR >&, const Potential< GUM_SCALAR >&));

    void __diffuseMessageInvalidations(NodeId   from_id,
                                       NodeId   to_id,
                                       NodeSet& invalidated_cliques);

    void __invalidateAllMessages();

    void __computeJoinTreeRoots();

    void __findRelevantPotentialsWithdSeparation(
       __PotentialSet& pot_list, Set< const DiscreteVariable* >& kept_vars);

    void __findRelevantPotentialsWithdSeparation2(
       __PotentialSet& pot_list, Set< const DiscreteVariable* >& kept_vars);

    void __findRelevantPotentialsWithdSeparation3(
       __PotentialSet& pot_list, Set< const DiscreteVariable* >& kept_vars);

    void __findRelevantPotentialsGetAll(__PotentialSet&                 pot_list,
                                        Set< const DiscreteVariable* >& kept_vars);

    void __findRelevantPotentialsXX(__PotentialSet&                 pot_list,
                                    Set< const DiscreteVariable* >& kept_vars);

    // remove barren variables and return the newly created projected potentials
    __PotentialSet
       __removeBarrenVariables(__PotentialSet&                 pot_list,
                               Set< const DiscreteVariable* >& del_vars);

    __PotentialSet __marginalizeOut(__PotentialSet                  pot_list,
                                    Set< const DiscreteVariable* >& del_vars,
                                    Set< const DiscreteVariable* >& kept_vars);

    void __produceMessage(NodeId from_id, NodeId to_id);

    void __collectMessage(NodeId id, NodeId from);
  };


#ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
  extern template class LazyPropagation< double >;
#endif


} /* namespace gum */

#include <agrum/BN/inference/lazyPropagation_tpl.h>

#endif /* GUM_LAZY_PROPAGATION_H */