credalNet.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 __CREDAL_NET__H__
#define __CREDAL_NET__H__

 
#include <iostream>
#include <vector>
 
#include <agrum/agrum.h>
 
// #include <sys/wait.h>
#include <algorithm>
#include <cstdlib>
#include <fcntl.h>
#include <fstream>
#include <set>
#include <sstream>
#include <string>
#include <utility>   
 
#include <agrum/base/core/exceptions.h>
#include <agrum/base/core/math/pow.h>   // custom pow functions with integers, faster implementation
#include <agrum/base/core/threads/threadExecutor.h>
#include <agrum/base/core/threads/threads.h>
#include <agrum/BN/io/BIF/BIFReader.h>
#include <agrum/BN/io/BIF/BIFWriter.h>
#include <agrum/CN/polytope/LrsWrapper.h>
 
#include <sys/stat.h>
 
// 64 bits for windows (long is 32 bits)
#ifdef _MSC_VER
typedef __int64          int64_t;
typedef unsigned __int64 uint64_t;
#else
#  include <stdint.h>
#endif
 
namespace gum {
  namespace credal {

    template < typename GUM_SCALAR >
    class CredalNet {
      public:
      enum class NodeType : char { Precise, Credal, Vacuous, Indic };


      CredalNet();

      CredalNet(const std::string& src_min_num, const std::string& src_max_den = "");

      CredalNet(const BayesNet< GUM_SCALAR >& src_min_num,
                const BayesNet< GUM_SCALAR >& src_max_den = BayesNet< GUM_SCALAR >());

      ~CredalNet();



      NodeId addVariable(const std::string& name, const Size& card);

      void addArc(const NodeId& tail, const NodeId& head);

      void setCPTs(const NodeId&                                                  id,
                   const std::vector< std::vector< std::vector< GUM_SCALAR > > >& cpt);

      void setCPT(const NodeId&                                   id,
                  Size&                                           entry,
                  const std::vector< std::vector< GUM_SCALAR > >& cpt);

      void setCPT(const NodeId&                                   id,
                  Instantiation                                   ins,
                  const std::vector< std::vector< GUM_SCALAR > >& cpt);

      void fillConstraints(const NodeId&                    id,
                           const std::vector< GUM_SCALAR >& lower,
                           const std::vector< GUM_SCALAR >& upper);

      void fillConstraint(const NodeId&                    id,
                          const Idx&                       entry,
                          const std::vector< GUM_SCALAR >& lower,
                          const std::vector< GUM_SCALAR >& upper);

      void fillConstraint(const NodeId&                    id,
                          Instantiation                    ins,
                          const std::vector< GUM_SCALAR >& lower,
                          const std::vector< GUM_SCALAR >& upper);

      Instantiation instantiation(const NodeId& id);

      Size domainSize(const NodeId& id);



      void bnToCredal(GUM_SCALAR beta, bool oneNet, bool keepZeroes);
      void bnToCredal(GUM_SCALAR beta, bool oneNet);
 

      void intervalToCredalWithFiles();

      void intervalToCredal();

      void lagrangeNormalization();

      void idmLearning(const Idx s = 0, const bool keepZeroes = false);

      void approximatedBinarization();

 
      // other utility member methods
      // PH void saveCNet ( const std::string &cn_path ) const;
      // PH void loadCNet ( const std::string &src_cn_path );

      void saveBNsMinMax(const std::string& min_path, const std::string& max_path) const;
 
      // PH void vacants ( int &result ) const;
      // PH void notVacants ( int &result ) const;
      // PH void averageVertices ( GUM_SCALAR &result ) const;

      std::string toString() const;
      // PH void toPNG ( const std::string &png_path ) const;

      void computeBinaryCPTMinMax();   // REDO THIS IN PRIVATE !!!


      const BayesNet< GUM_SCALAR >& src_bn() const;

      const BayesNet< GUM_SCALAR >& current_bn() const;

      const NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > >&
          credalNet_currentCpt() const;

      const NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > >&
          credalNet_srcCpt() const;

      NodeType currentNodeType(const NodeId& id) const;

      NodeType nodeType(const NodeId& id) const;

      const GUM_SCALAR& epsilonMin() const;

      const GUM_SCALAR& epsilonMax() const;

      const GUM_SCALAR& epsilonMean() const;

      bool isSeparatelySpecified() const;

      bool hasComputedBinaryCPTMinMax() const;

      const std::vector< std::vector< GUM_SCALAR > >& get_binaryCPT_min() const;

      const std::vector< std::vector< GUM_SCALAR > >& get_binaryCPT_max() const;
 
      // PH const std::vector< std::vector< NodeId > > & var_bits() const;

 
      protected:
 
      private:
      GUM_SCALAR _precisionC_;   // = 1e6;
      GUM_SCALAR _deltaC_;   // = 5;

      GUM_SCALAR _epsilonMin_;
      GUM_SCALAR _epsilonMax_;
      GUM_SCALAR _epsilonMoy_;

      GUM_SCALAR _epsRedund_;   //= 1e-6;

      GUM_SCALAR _epsF_;   // = 1e-6;
      GUM_SCALAR _denMax_;   // = 1e6; // beware LRS

      GUM_SCALAR _precision_;   // = 1e6; // beware LRS

      bool _separatelySpecified_;

      BayesNet< GUM_SCALAR > _src_bn_;

      BayesNet< GUM_SCALAR > _src_bn_min_;
      BayesNet< GUM_SCALAR > _src_bn_max_;

      BayesNet< GUM_SCALAR >* _current_bn_;   // = nullptr;

      NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > > _credalNet_src_cpt_;

      NodeProperty< std::vector< std::vector< std::vector< GUM_SCALAR > > > >*
          _credalNet_current_cpt_;   // =  nullptr;

      NodeProperty< std::vector< NodeId > > _var_bits_;

      NodeProperty< NodeType > _original_nodeType_;
      NodeProperty< NodeType >* _current_nodeType_;   // = nullptr;

      bool _hasComputedBinaryCPTMinMax_;
      typename std::vector< std::vector< GUM_SCALAR > > _binCptMin_;

      typename std::vector< std::vector< GUM_SCALAR > > _binCptMax_;

      void _sort_varType_();

      int _find_dNode_card_(
          const std::vector< std::vector< std::vector< GUM_SCALAR > > >& var_cpt) const;

      void _intervalToCredal_();

      void _initParams_();

      void _initCNNets_(const std::string& src_min_num, const std::string& src_max_den);

      void _initCNNets_(const BayesNet< GUM_SCALAR >& src_min_num,
                        const BayesNet< GUM_SCALAR >& src_max_den);

      void _bnCopy_(BayesNet< GUM_SCALAR >& bn_dest);
 
      // void  _H2Vcdd_ ( const std::vector< std::vector< GUM_SCALAR > > & h_rep,
      // std::vector< std::vector< GUM_SCALAR > > & v_rep ) const;
      void _H2Vlrs_(const std::vector< std::vector< GUM_SCALAR > >& h_rep,
                    std::vector< std::vector< GUM_SCALAR > >&       v_rep) const;
 
    };   // CredalNet
 
 
#ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
    extern template class CredalNet< double >;
#endif
 
  }   // namespace credal
}   // namespace gum
 
#include <agrum/CN/credalNet_tpl.h>
 
#endif   //  __CREDAL_NET__H__