lazyPropagation.h

Go to the documentation of this file.

/****************************************************************************
 *   This file is part of the aGrUM/pyAgrum library.                        *
 *                                                                          *
 *   Copyright (c) 2005-2025 by                                             *
 *       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 *
 *       - Christophe GONZALES(_at_AMU)                                     *
 *                                                                          *
 *   The aGrUM/pyAgrum library is free software; you can redistribute it    *
 *   and/or modify it under the terms of either :                           *
 *                                                                          *
 *    - the GNU Lesser General Public License as published by               *
 *      the Free Software Foundation, either version 3 of the License,      *
 *      or (at your option) any later version,                              *
 *    - the MIT license (MIT),                                              *
 *    - or both in dual license, as here.                                   *
 *                                                                          *
 *   (see https://agrum.gitlab.io/articles/dual-licenses-lgplv3mit.html)    *
 *                                                                          *
 *   This aGrUM/pyAgrum library is distributed in the hope that it will be  *
 *   useful, but WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,          *
 *   INCLUDING BUT NOT LIMITED TO THE WARRANTIES MERCHANTABILITY or FITNESS *
 *   FOR A PARTICULAR PURPOSE  AND NONINFRINGEMENT. IN NO EVENT SHALL THE   *
 *   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *
 *   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,        *
 *   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR  *
 *   OTHER DEALINGS IN THE SOFTWARE.                                        *
 *                                                                          *
 *   See LICENCES for more details.                                         *
 *                                                                          *
 *   SPDX-FileCopyrightText: Copyright 2005-2025                            *
 *       - Pierre-Henri WUILLEMIN(_at_LIP6)                                 *
 *       - Christophe GONZALES(_at_AMU)                                     *
 *   SPDX-License-Identifier: LGPL-3.0-or-later OR MIT                      *
 *                                                                          *
 *   Contact  : info_at_agrum_dot_org                                       *
 *   homepage : http://agrum.gitlab.io                                      *
 *   gitlab   : https://gitlab.com/agrumery/agrum                           *
 *                                                                          *
 ****************************************************************************/
 

#ifndef GUM_LAZY_PROPAGATION_H
#define GUM_LAZY_PROPAGATION_H
 
#include <utility>
 
#include <agrum/agrum.h>
 
#include <agrum/base/graphicalModels/inference/scheduler/scheduledInference.h>
#include <agrum/base/graphs/algorithms/triangulations/defaultTriangulation.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/relevantTensorsFinderType.h>
 
namespace gum {
 
 
  // the function used to combine two tables
  template < typename GUM_SCALAR >
  INLINE static Tensor< GUM_SCALAR > LPNewmultiTensor(const Tensor< GUM_SCALAR >& t1,
                                                      const Tensor< GUM_SCALAR >& t2) {
    return t1 * t2;
  }
 
  // the function used to combine two tables with summations
  template < typename GUM_SCALAR >
  INLINE static Tensor< GUM_SCALAR > LPNewprojTensor(const Tensor< GUM_SCALAR >& t1,
                                                     const gum::VariableSet&     del_vars) {
    return t1.sumOut(del_vars);
  }
 
  // the function used to combine two tables with max
  template < typename GUM_SCALAR >
  INLINE static Tensor< GUM_SCALAR > LPMaxprojTensor(const Tensor< GUM_SCALAR >& t1,
                                                     const gum::VariableSet&     del_vars) {
    return t1.maxOut(del_vars);
  }

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

    explicit LazyPropagation(const IBayesNet< GUM_SCALAR >* BN,
                             RelevantTensorsFinderType
                             = RelevantTensorsFinderType::DSEP_BAYESBALL_TENSORS,
                             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();

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

    void setTriangulation(const Triangulation& new_triangulation);


    void setRelevantTensorsFinderType(RelevantTensorsFinderType type);


    void setFindBarrenNodesType(FindBarrenNodesType type);


    const JoinTree* joinTree();


    const JunctionTree* junctionTree();

    GUM_SCALAR evidenceProbability() final;


    Instantiation mpe();

    std::pair< Instantiation, GUM_SCALAR > mpeLog2Posterior();

 
 
    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;

    void onModelChanged_(const GraphicalModel* 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 updateOutdatedStructure_() final;


    void updateOutdatedTensors_() final;


    void makeInference_() final;
 


    const Tensor< GUM_SCALAR >& posterior_(NodeId id) final;


    const Tensor< GUM_SCALAR >& jointPosterior_(const NodeSet& set) final;

    const Tensor< GUM_SCALAR >& jointPosterior_(const NodeSet& wanted_target,
                                                const NodeSet& declared_target) final;

    Tensor< GUM_SCALAR >* unnormalizedJointPosterior_(NodeId id) final;

    Tensor< GUM_SCALAR >* unnormalizedJointPosterior_(const NodeSet& set) final;
 
 
    private:
    using _TensorSet_           = Set< const Tensor< GUM_SCALAR >* >;
    using _ScheduleMultiDimSet_ = Set< const IScheduleMultiDim* >;
 

    RelevantTensorsFinderType _find_relevant_tensor_type_{
        RelevantTensorsFinderType::DSEP_BAYESBALL_TENSORS};

    void (LazyPropagation< GUM_SCALAR >::*_findRelevantTensors_)(
        Set< const IScheduleMultiDim* >& pot_list,
        gum::VariableSet&                kept_vars);

    FindBarrenNodesType _barren_nodes_type_{FindBarrenNodesType::FIND_BARREN_NODES};

    Tensor< GUM_SCALAR > (*_projection_op_)(const Tensor< GUM_SCALAR >&,
                                            const gum::VariableSet&){LPNewprojTensor};

    Tensor< GUM_SCALAR > (*_combination_op_)(const Tensor< GUM_SCALAR >&,
                                             const Tensor< GUM_SCALAR >&){LPNewmultiTensor};

    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< _ScheduleMultiDimSet_ > _clique_tensors_;


    ArcProperty< _ScheduleMultiDimSet_ > _separator_tensors_;


    ArcProperty< _ScheduleMultiDimSet_ > _arc_to_created_tensors_;


    NodeProperty< const Tensor< GUM_SCALAR >* > _target_posteriors_;


    HashTable< NodeSet, const Tensor< GUM_SCALAR >* > _joint_target_posteriors_;

    NodeProperty< GUM_SCALAR > _constants_;


    ArcProperty< bool > _messages_computed_;


    NodeProperty< const IScheduleMultiDim* > _node_to_soft_evidence_;


    NodeProperty< const IScheduleMultiDim* > _node_to_hard_ev_projected_CPTs_;

    NodeSet _hard_ev_nodes_;

    enum EvidenceChangeType { EVIDENCE_ADDED, EVIDENCE_ERASED, EVIDENCE_MODIFIED };

    NodeProperty< EvidenceChangeType > _evidence_changes_;

    bool _use_schedules_{false};

    static constexpr double _schedule_threshold_{1000000.0};

    static constexpr GUM_SCALAR _one_minus_epsilon_{GUM_SCALAR(1.0 - 1e-6)};
 

    bool _isNewJTNeeded_() const;

    void _createNewJT_();

    void _initializeJTCliques_(Schedule& schedule);

    void _initializeJTCliques_();

    void _setProjectionFunction_(Tensor< GUM_SCALAR > (*proj)(const Tensor< GUM_SCALAR >&,
                                                              const gum::VariableSet&));

    void _setCombinationFunction_(Tensor< GUM_SCALAR > (*comb)(const Tensor< GUM_SCALAR >&,
                                                               const Tensor< GUM_SCALAR >&));

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

    void _invalidateAllMessages_();

    void _computeJoinTreeRoots_();

    void _findRelevantTensorsWithdSeparation_(_ScheduleMultiDimSet_& pot_list,
                                              gum::VariableSet&      kept_vars);

    void _findRelevantTensorsWithdSeparation2_(_ScheduleMultiDimSet_& pot_list,
                                               gum::VariableSet&      kept_vars);

    void _findRelevantTensorsWithdSeparation3_(_ScheduleMultiDimSet_& pot_list,
                                               gum::VariableSet&      kept_vars);

    void _findRelevantTensorsGetAll_(_ScheduleMultiDimSet_& pot_list, gum::VariableSet& kept_vars);

    void _findRelevantTensorsXX_(_ScheduleMultiDimSet_& pot_list, gum::VariableSet& kept_vars);

    _ScheduleMultiDimSet_ _removeBarrenVariables_(Schedule&              schedule,
                                                  _ScheduleMultiDimSet_& pot_list,
                                                  gum::VariableSet&      del_vars);

    _TensorSet_ _removeBarrenVariables_(_TensorSet_& pot_list, gum::VariableSet& del_vars);

    _ScheduleMultiDimSet_ _marginalizeOut_(Schedule&             schedule,
                                           _ScheduleMultiDimSet_ pot_list,
                                           gum::VariableSet&     del_vars,
                                           gum::VariableSet&     kept_vars);

    _ScheduleMultiDimSet_ _marginalizeOut_(_ScheduleMultiDimSet_& pot_list,
                                           gum::VariableSet&      del_vars,
                                           gum::VariableSet&      kept_vars);

    void _produceMessage_(Schedule& schedule, NodeId from_id, NodeId to_id);

    void _produceMessage_(NodeId from_id, NodeId to_id);

    void _collectMessage_(Schedule& schedule, NodeId id, NodeId from);

    void _collectMessage_(NodeId id, NodeId from);

    Tensor< GUM_SCALAR >* _unnormalizedJointPosterior_(Schedule& schedule, NodeId id);

    Tensor< GUM_SCALAR >* _unnormalizedJointPosterior_(NodeId id);

    Tensor< GUM_SCALAR >* _unnormalizedJointPosterior_(Schedule& schedule, const NodeSet& set);

    Tensor< GUM_SCALAR >* _unnormalizedJointPosterior_(const NodeSet& set);
  };
 
 
#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 */