variableElimination.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_VARIABLE_ELIMINATION_H
#define GUM_VARIABLE_ELIMINATION_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/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 > VENewmultiTensor(const Tensor< GUM_SCALAR >& t1,
                                                      const Tensor< GUM_SCALAR >& t2) {
    return t1 * t2;
  }
 
  // the function used to combine two tables
  template < typename GUM_SCALAR >
  INLINE static Tensor< GUM_SCALAR > VENewprojTensor(const Tensor< GUM_SCALAR >& t1,
                                                     const gum::VariableSet&     del_vars) {
    return t1.sumOut(del_vars);
  }

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

    explicit VariableElimination(const IBayesNet< GUM_SCALAR >* BN,
                                 RelevantTensorsFinderType
                                 = RelevantTensorsFinderType::DSEP_BAYESBALL_TENSORS,
                                 FindBarrenNodesType = FindBarrenNodesType::FIND_BARREN_NODES);

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

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

    ~VariableElimination();

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

    void setTriangulation(const Triangulation& new_triangulation);


    void setRelevantTensorsFinderType(RelevantTensorsFinderType type);


    void setFindBarrenNodesType(FindBarrenNodesType type);

    const JunctionTree* junctionTree(NodeId id);

 
 
    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 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 (VariableElimination< 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&){VENewprojTensor};

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

    Triangulation* _triangulation_;


    UndiGraph _graph_;

    JunctionTree* _JT_{nullptr};

    HashTable< NodeId, NodeId > _node_to_clique_;

    HashTable< NodeId, NodeSet > _clique_to_nodes_;

    NodeId _targets2clique_;


    Tensor< GUM_SCALAR >* _target_posterior_{nullptr};

    static constexpr double _schedule_threshold_{1000000.0};

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

    void _createNewJT_(const NodeSet& targets);

    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 _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_ _collectMessage_(Schedule& schedule, NodeId id, NodeId from);

    std::pair< _TensorSet_, _TensorSet_ > _collectMessage_(NodeId id, NodeId from);

    std::pair< _TensorSet_, _TensorSet_ > _NodeTensors_(NodeId node);

    _ScheduleMultiDimSet_ _NodeTensors_(Schedule& schedule, NodeId node);

    std::pair< _TensorSet_, _TensorSet_ >
        _produceMessage_(NodeId                                  from_id,
                         NodeId                                  to_id,
                         std::pair< _TensorSet_, _TensorSet_ >&& incoming_messages);

    _ScheduleMultiDimSet_ _produceMessage_(Schedule&               schedule,
                                           NodeId                  from_id,
                                           NodeId                  to_id,
                                           _ScheduleMultiDimSet_&& incoming_messages);

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

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


    Tensor< GUM_SCALAR >* _unnormalizedJointPosterior_(NodeId id);


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


    Tensor< GUM_SCALAR >* _unnormalizedJointPosterior_(const NodeSet& set,
                                                       const NodeSet& targets,
                                                       const NodeSet& hard_evidence_nodes);


    Tensor< GUM_SCALAR >* _unnormalizedJointPosterior_(Schedule&      schedule,
                                                       const NodeSet& set,
                                                       const NodeSet& targets,
                                                       const NodeSet& hard_evidence_nodes);
  };
 
 
#ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
  extern template class VariableElimination< double >;
#endif
 
 
} /* namespace gum */
 
#include <agrum/BN/inference/variableElimination_tpl.h>
 
 
#endif /* GUM_VARIABLE_ELIMINATION_ */