IBNLearner.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_LEARNING_GENERIC_BN_LEARNER_H
#define GUM_LEARNING_GENERIC_BN_LEARNER_H
 
#include <memory>
#include <sstream>
 
#include <agrum/agrum.h>
 
#include <agrum/base/database/DBInitializerFromCSV.h>
#include <agrum/base/database/DBRowGenerator4CompleteRows.h>
#include <agrum/base/database/DBRowGeneratorEM.h>
#include <agrum/BN/algorithms/essentialGraph.h>
#include <agrum/BN/learning/constraints/structuralConstraintDAG.h>
#include <agrum/BN/learning/constraints/structuralConstraintForbiddenArcs.h>
#include <agrum/BN/learning/constraints/structuralConstraintIndegree.h>
#include <agrum/BN/learning/constraints/structuralConstraintMandatoryArcs.h>
#include <agrum/BN/learning/constraints/structuralConstraintNoChildrenNodes.h>
#include <agrum/BN/learning/constraints/structuralConstraintNoParentNodes.h>
#include <agrum/BN/learning/constraints/structuralConstraintPossibleEdges.h>
#include <agrum/BN/learning/constraints/structuralConstraintSliceOrder.h>
#include <agrum/BN/learning/constraints/structuralConstraintTabuList.h>
#include <agrum/BN/learning/K2.h>
#include <agrum/BN/learning/localSearchWithTabuList.h>
#include <agrum/BN/learning/paramUtils/DAG2BNLearner.h>
#include <agrum/BN/learning/paramUtils/paramEstimatorML.h>
#include <agrum/BN/learning/priors/DirichletPriorFromDatabase.h>
#include <agrum/BN/learning/SimpleMiic.h>
#include <agrum/BN/learning/structureUtils/graphChangesGenerator4DiGraph.h>
#include <agrum/BN/learning/structureUtils/graphChangesGenerator4K2.h>
#include <agrum/BN/learning/structureUtils/graphChangesSelector4DiGraph.h>
 
#include <agrum/BN/learning/scores_and_tests/scoreAIC.h>
#include <agrum/BN/learning/scores_and_tests/scoreBD.h>
#include <agrum/BN/learning/scores_and_tests/scoreBDeu.h>
#include <agrum/BN/learning/scores_and_tests/scoreK2.h>
 
namespace gum::learning {
  class BNLearnerListener;

  class IBNLearner: public IApproximationSchemeConfiguration, public ThreadNumberManager {
    public:
    enum class ScoreType { AIC, BD, BDeu, BIC, K2, LOG2LIKELIHOOD };

    enum class ParamEstimatorType { ML };

    enum class BNLearnerPriorType {
      NO_prior,
      SMOOTHING,
      DIRICHLET_FROM_DATABASE,
      DIRICHLET_FROM_BAYESNET,
      BDEU
    };

    enum class AlgoType { K2, GREEDY_HILL_CLIMBING, LOCAL_SEARCH_WITH_TABU_LIST, MIIC };

    static constexpr double default_EM_noise{0.1};

    class Database {
      public:
      // ########################################################################
      // ########################################################################


      explicit Database(const std::string&                file,
                        const std::vector< std::string >& missing_symbols,
                        const bool                        induceTypes = false);


      explicit Database(const DatabaseTable& db);


      Database(const std::string&                filename,
               const Database&                   score_database,
               const std::vector< std::string >& missing_symbols);


      template < typename GUM_SCALAR >
      Database(const std::string&                 filename,
               const gum::BayesNet< GUM_SCALAR >& bn,
               const std::vector< std::string >&  missing_symbols);

      Database(const Database& from);

      Database(Database&& from);

      ~Database();

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

      Database& operator=(const Database& from);

      Database& operator=(Database&& from);

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

      DBRowGeneratorParser& parser();

      const std::vector< std::size_t >& domainSizes() const;

      const std::vector< std::string >& names() const;

      NodeId idFromName(const std::string& var_name) const;

      const std::string& nameFromId(NodeId id) const;

      const DatabaseTable& databaseTable() const;

      void setDatabaseWeight(const double new_weight);

      const Bijection< NodeId, std::size_t >& nodeId2Columns() const;

      const std::vector< std::string >& missingSymbols() const;

      std::size_t nbRows() const;

      std::size_t size() const;


      void setWeight(const std::size_t i, const double weight);


      double weight(const std::size_t i) const;

      double weight() const;

 
      protected:
      DatabaseTable _database_;

      DBRowGeneratorParser* _parser_{nullptr};

      std::vector< std::size_t > _domain_sizes_;

      Bijection< NodeId, std::size_t > _nodeId2cols_;

      Size _max_threads_number_{gum::getNumberOfThreads()};

      Size _min_nb_rows_per_thread_{100};
 
      private:
      // returns the set of variables as a BN. This is convenient for
      // the constructors of prior Databases
      template < typename GUM_SCALAR >
      BayesNet< GUM_SCALAR > _BNVars_() const;
    };
 
    // ##########################################################################
    // ##########################################################################

    IBNLearner(const std::string&                filename,
               const std::vector< std::string >& missingSymbols,
               bool                              induceTypes = true);
 
    explicit IBNLearner(const DatabaseTable& db);

    template < typename GUM_SCALAR >
    IBNLearner(const std::string&                 filename,
               const gum::BayesNet< GUM_SCALAR >& src,
               const std::vector< std::string >&  missing_symbols);

    IBNLearner(const IBNLearner&);

    IBNLearner(IBNLearner&&);

    virtual ~IBNLearner();

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

    IBNLearner& operator=(const IBNLearner&);

    IBNLearner& operator=(IBNLearner&&);

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

    DAG learnDAG();

    PDAG learnPDAG();

    void setInitialDAG(const DAG&);

    DAG initialDAG();

    const std::vector< std::string >& names() const;

    const std::vector< std::size_t >& domainSizes() const;
    Size                              domainSize(NodeId var) const;
    Size                              domainSize(const std::string& var) const;


    NodeId idFromName(const std::string& var_name) const;

    const DatabaseTable& database() const;

    void setDatabaseWeight(const double new_weight);


    void setRecordWeight(const std::size_t i, const double weight);


    double recordWeight(const std::size_t i) const;

    double databaseWeight() const;

    const std::string& nameFromId(NodeId id) const;


    void useDatabaseRanges(const std::vector< std::pair< std::size_t, std::size_t > >& new_ranges);

    void clearDatabaseRanges();


    const std::vector< std::pair< std::size_t, std::size_t > >& databaseRanges() const;


    std::pair< std::size_t, std::size_t > useCrossValidationFold(const std::size_t learning_fold,
                                                                 const std::size_t k_fold);
 

    std::pair< double, double >
        chi2(NodeId id1, NodeId id2, const std::vector< NodeId >& knowing = {});
    std::pair< double, double > chi2(const std::string&                name1,
                                     const std::string&                name2,
                                     const std::vector< std::string >& knowing = {});

    std::pair< double, double >
        G2(NodeId id1, NodeId id2, const std::vector< NodeId >& knowing = {});
    std::pair< double, double > G2(const std::string&                name1,
                                   const std::string&                name2,
                                   const std::vector< std::string >& knowing = {});

    double logLikelihood(const std::vector< NodeId >& vars,
                         const std::vector< NodeId >& knowing = {});

    double logLikelihood(const std::vector< std::string >& vars,
                         const std::vector< std::string >& knowing = {});

    double mutualInformation(NodeId id1, NodeId id2, const std::vector< NodeId >& knowing = {});

    double mutualInformation(const std::string&                var1,
                             const std::string&                var2,
                             const std::vector< std::string >& knowing = {});
 

    double correctedMutualInformation(NodeId                       id1,
                                      NodeId                       id2,
                                      const std::vector< NodeId >& knowing = {});

    double correctedMutualInformation(const std::string&                var1,
                                      const std::string&                var2,
                                      const std::vector< std::string >& knowing = {});

    double score(NodeId vars, const std::vector< NodeId >& knowing = {});

    double score(const std::string& vars, const std::vector< std::string >& knowing = {});

    std::vector< double > rawPseudoCount(const std::vector< NodeId >& vars);

    std::vector< double > rawPseudoCount(const std::vector< std::string >& vars);
    Size nbCols() const;

    Size nbRows() const;

    void useEM(const double epsilon, const double noise = default_EM_noise);

    void useEMWithRateCriterion(const double epsilon, const double noise = default_EM_noise);

    void useEMWithDiffCriterion(const double epsilon, const double noise = default_EM_noise);

    void forbidEM();

    bool isUsingEM() const;

    EMApproximationScheme& EM();

    ApproximationSchemeSTATE EMState() const;

    std::string EMStateMessage() const;

    bool hasMissingValues() const;

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

    void useScoreAIC();

    void useScoreBD();

    void useScoreBDeu();

    void useScoreBIC();

    void useScoreK2();

    void useScoreLog2Likelihood();

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

    void useNoPrior();


    void useBDeuPrior(double weight = 1.0);


    void useSmoothingPrior(double weight = 1);

    void useDirichletPrior(const std::string& filename, double weight = 1);


    std::string checkScorePriorCompatibility() const;
 
    // ##########################################################################
    // ##########################################################################

    void useGreedyHillClimbing();


    void useLocalSearchWithTabuList(Size tabu_size = 100, Size nb_decrease = 2);

    void useK2(const Sequence< NodeId >& order);

    void useK2(const std::vector< NodeId >& order);

    void useMIIC();

    bool isConstraintBased() const {
      switch (selectedAlgo_) {
        case AlgoType::K2 :
        case AlgoType::GREEDY_HILL_CLIMBING :
        case AlgoType::LOCAL_SEARCH_WITH_TABU_LIST : return false;
        case AlgoType::MIIC : return true;
        default : throw OperationNotAllowed("Unknown algorithm");
      }
    }

    bool isScoreBased() const { return !isConstraintBased(); }

 
    // ##########################################################################
    // ##########################################################################
    void useNMLCorrection();
    void useMDLCorrection();
    void useNoCorrection();

    std::vector< Arc > latentVariables() const;

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

    void setMaxIndegree(Size max_indegree);

    void setSliceOrder(const NodeProperty< NodeId >& slice_order);

    void setSliceOrder(const std::vector< std::vector< std::string > >& slices);

    void setForbiddenArcs(const ArcSet& set);

    void addForbiddenArc(const Arc& arc);
    void addForbiddenArc(NodeId tail, NodeId head);
    void addForbiddenArc(const std::string& tail, const std::string& head);

    void eraseForbiddenArc(const Arc& arc);
    void eraseForbiddenArc(NodeId tail, NodeId head);
    void eraseForbiddenArc(const std::string& tail, const std::string& head);

    void setMandatoryArcs(const ArcSet& set);

    void addMandatoryArc(const Arc& arc);
    void addMandatoryArc(NodeId tail, NodeId head);
    void addMandatoryArc(const std::string& tail, const std::string& head);

    void eraseMandatoryArc(const Arc& arc);
    void eraseMandatoryArc(NodeId tail, NodeId head);
    void eraseMandatoryArc(const std::string& tail, const std::string& head);

    void addNoParentNode(NodeId node);
    void addNoParentNode(const std::string& node);

    void eraseNoParentNode(NodeId node);
    void eraseNoParentNode(const std::string& node);

    void addNoChildrenNode(NodeId node);
    void addNoChildrenNode(const std::string& node);

    void eraseNoChildrenNode(NodeId node);
    void eraseNoChildrenNode(const std::string& node);

    void setPossibleEdges(const EdgeSet& set);
    void setPossibleSkeleton(const UndiGraph& skeleton);

    //  are considered as impossible.
    void addPossibleEdge(const Edge& edge);
    void addPossibleEdge(NodeId tail, NodeId head);
    void addPossibleEdge(const std::string& tail, const std::string& head);

    void erasePossibleEdge(const Edge& edge);
    void erasePossibleEdge(NodeId tail, NodeId head);
    void erasePossibleEdge(const std::string& tail, const std::string& head);

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


    void setNumberOfThreads(Size nb) override;

 
    protected:
    void _setPriorWeight_(double weight);

    bool inducedTypes_{false};

    ScoreType scoreType_{ScoreType::BDeu};

    Score* score_{nullptr};

    ParamEstimatorType paramEstimatorType_{ParamEstimatorType::ML};

    bool useEM_{false};

    double noiseEM_{0.1};

    CorrectedMutualInformation* mutualInfo_{nullptr};

    BNLearnerPriorType priorType_{BNLearnerPriorType::NO_prior};

    Prior* prior_{nullptr};
 
    NoPrior* noPrior_{nullptr};

    double priorWeight_{1.0f};

    StructuralConstraintSliceOrder constraintSliceOrder_;

    StructuralConstraintIndegree constraintIndegree_;

    StructuralConstraintTabuList constraintTabuList_;

    StructuralConstraintForbiddenArcs constraintForbiddenArcs_;

    StructuralConstraintPossibleEdges constraintPossibleEdges_;

    StructuralConstraintMandatoryArcs constraintMandatoryArcs_;

    StructuralConstraintNoParentNodes constraintNoParentNodes_;

    StructuralConstraintNoChildrenNodes constraintNoChildrenNodes_;
 

    AlgoType selectedAlgo_{AlgoType::MIIC};

    K2 algoK2_;

    SimpleMiic algoSimpleMiic_;

    Miic algoMiic_;

    typename CorrectedMutualInformation::KModeTypes kmodeMiic_{
        CorrectedMutualInformation::KModeTypes::MDL};

    DAG2BNLearner dag2BN_;

    GreedyHillClimbing greedyHillClimbing_;

    LocalSearchWithTabuList localSearchWithTabuList_;

    Database scoreDatabase_;

    std::vector< std::pair< std::size_t, std::size_t > > ranges_;

    Database* priorDatabase_{nullptr};

    std::string priorDbname_;

    DAG initialDag_;

    std::string filename_{"-"};
 
    // size of the tabu list
    Size nbDecreasingChanges_{2};
 
    // the current algorithm as an approximationScheme
    const ApproximationScheme* currentAlgorithm_{nullptr};

    static DatabaseTable readFile_(const std::string&                filename,
                                   const std::vector< std::string >& missing_symbols);

    static void isCSVFileName_(const std::string& filename);

    virtual void createPrior_() = 0;

    void createScore_();

    ParamEstimator* createParamEstimator_(const DBRowGeneratorParser& parser,
                                          bool take_into_account_score = true);

    DAG learnDag_();

    MixedGraph prepareSimpleMiic_();

    MixedGraph prepareMiic_();

    PriorType getPriorType_() const;

    void createCorrectedMutualInformation_();
 
    public:
    // ##########################################################################
    // ##########################################################################
    // in order to not pollute the proper code of IBNLearner, we
    // directly
    // implement those
    // very simples methods here.
    INLINE void setCurrentApproximationScheme(const ApproximationScheme* approximationScheme) {
      currentAlgorithm_ = approximationScheme;
    }
 
    INLINE void distributeProgress(const ApproximationScheme* approximationScheme,
                                   Size                       pourcent,
                                   double                     error,
                                   double                     time) {
      setCurrentApproximationScheme(approximationScheme);
 
      if (onProgress.hasListener()) GUM_EMIT3(onProgress, pourcent, error, time);
    };

    INLINE void distributeStop(const ApproximationScheme* approximationScheme,
                               const std::string&         message) {
      setCurrentApproximationScheme(approximationScheme);
 
      if (onStop.hasListener()) GUM_EMIT1(onStop, message);
    };


    void setEpsilon(double eps) override {
      algoK2_.approximationScheme().setEpsilon(eps);
      greedyHillClimbing_.setEpsilon(eps);
      localSearchWithTabuList_.setEpsilon(eps);
    };

    double epsilon() const override {
      if (currentAlgorithm_ != nullptr) return currentAlgorithm_->epsilon();
      else GUM_ERROR(FatalError, "No chosen algorithm for learning")
    }

    void disableEpsilon() override {
      algoK2_.approximationScheme().disableEpsilon();
      greedyHillClimbing_.disableEpsilon();
      localSearchWithTabuList_.disableEpsilon();
    };

    void enableEpsilon() override {
      algoK2_.approximationScheme().enableEpsilon();
      greedyHillClimbing_.enableEpsilon();
      localSearchWithTabuList_.enableEpsilon();
    };

    bool isEnabledEpsilon() const override {
      if (currentAlgorithm_ != nullptr) return currentAlgorithm_->isEnabledEpsilon();
      else GUM_ERROR(FatalError, "No chosen algorithm for learning")
    }


    void setMinEpsilonRate(double rate) override {
      algoK2_.approximationScheme().setMinEpsilonRate(rate);
      greedyHillClimbing_.setMinEpsilonRate(rate);
      localSearchWithTabuList_.setMinEpsilonRate(rate);
    };

    double minEpsilonRate() const override {
      if (currentAlgorithm_ != nullptr) return currentAlgorithm_->minEpsilonRate();
      else GUM_ERROR(FatalError, "No chosen algorithm for learning")
    }

    void disableMinEpsilonRate() override {
      algoK2_.approximationScheme().disableMinEpsilonRate();
      greedyHillClimbing_.disableMinEpsilonRate();
      localSearchWithTabuList_.disableMinEpsilonRate();
    };

    void enableMinEpsilonRate() override {
      algoK2_.approximationScheme().enableMinEpsilonRate();
      greedyHillClimbing_.enableMinEpsilonRate();
      localSearchWithTabuList_.enableMinEpsilonRate();
    };

    bool isEnabledMinEpsilonRate() const override {
      if (currentAlgorithm_ != nullptr) return currentAlgorithm_->isEnabledMinEpsilonRate();
      else GUM_ERROR(FatalError, "No chosen algorithm for learning")
    }


    void setMaxIter(Size max) override {
      algoK2_.approximationScheme().setMaxIter(max);
      greedyHillClimbing_.setMaxIter(max);
      localSearchWithTabuList_.setMaxIter(max);
    };

    Size maxIter() const override {
      if (currentAlgorithm_ != nullptr) return currentAlgorithm_->maxIter();
      else GUM_ERROR(FatalError, "No chosen algorithm for learning")
    }

    void disableMaxIter() override {
      algoK2_.approximationScheme().disableMaxIter();
      greedyHillClimbing_.disableMaxIter();
      localSearchWithTabuList_.disableMaxIter();
    };

    void enableMaxIter() override {
      algoK2_.approximationScheme().enableMaxIter();
      greedyHillClimbing_.enableMaxIter();
      localSearchWithTabuList_.enableMaxIter();
    };

    bool isEnabledMaxIter() const override {
      if (currentAlgorithm_ != nullptr) return currentAlgorithm_->isEnabledMaxIter();
      else GUM_ERROR(FatalError, "No chosen algorithm for learning")
    }



    void setMaxTime(double timeout) override {
      algoK2_.approximationScheme().setMaxTime(timeout);
      greedyHillClimbing_.setMaxTime(timeout);
      localSearchWithTabuList_.setMaxTime(timeout);
    }

    double maxTime() const override {
      if (currentAlgorithm_ != nullptr) return currentAlgorithm_->maxTime();
      else GUM_ERROR(FatalError, "No chosen algorithm for learning")
    }

    double currentTime() const override {
      if (currentAlgorithm_ != nullptr) return currentAlgorithm_->currentTime();
      else GUM_ERROR(FatalError, "No chosen algorithm for learning")
    }

    void disableMaxTime() override {
      algoK2_.approximationScheme().disableMaxTime();
      greedyHillClimbing_.disableMaxTime();
      localSearchWithTabuList_.disableMaxTime();
    };
 
    void enableMaxTime() override {
      algoK2_.approximationScheme().enableMaxTime();
      greedyHillClimbing_.enableMaxTime();
      localSearchWithTabuList_.enableMaxTime();
    };

    bool isEnabledMaxTime() const override {
      if (currentAlgorithm_ != nullptr) return currentAlgorithm_->isEnabledMaxTime();
      else GUM_ERROR(FatalError, "No chosen algorithm for learning")
    }


    void setPeriodSize(Size p) override {
      algoK2_.approximationScheme().setPeriodSize(p);
      greedyHillClimbing_.setPeriodSize(p);
      localSearchWithTabuList_.setPeriodSize(p);
    };
 
    Size periodSize() const override {
      if (currentAlgorithm_ != nullptr) return currentAlgorithm_->periodSize();
      else GUM_ERROR(FatalError, "No chosen algorithm for learning")
    }


    void setVerbosity(bool v) override {
      algoK2_.approximationScheme().setVerbosity(v);
      greedyHillClimbing_.setVerbosity(v);
      localSearchWithTabuList_.setVerbosity(v);
    };
 
    bool verbosity() const override {
      if (currentAlgorithm_ != nullptr) return currentAlgorithm_->verbosity();
      else GUM_ERROR(FatalError, "No chosen algorithm for learning")
    }


 
    ApproximationSchemeSTATE stateApproximationScheme() const override {
      if (currentAlgorithm_ != nullptr) return currentAlgorithm_->stateApproximationScheme();
      else GUM_ERROR(FatalError, "No chosen algorithm for learning")
    }

    Size nbrIterations() const override {
      if (currentAlgorithm_ != nullptr) return currentAlgorithm_->nbrIterations();
      else GUM_ERROR(FatalError, "No chosen algorithm for learning")
    }

    const std::vector< double >& history() const override {
      if (currentAlgorithm_ != nullptr) return currentAlgorithm_->history();
      else GUM_ERROR(FatalError, "No chosen algorithm for learning")
    }

 


    void EMsetEpsilon(double eps) { dag2BN_.setEpsilon(eps); }


    double EMEpsilon() const { return dag2BN_.epsilon(); }

    void EMdisableEpsilon() { dag2BN_.disableEpsilon(); }

    void EMenableEpsilon() { dag2BN_.enableEpsilon(); }

    bool EMisEnabledEpsilon() const { return dag2BN_.isEnabledEpsilon(); }

    void EMsetMinEpsilonRate(double rate) { dag2BN_.setMinEpsilonRate(rate); }

    double EMMinEpsilonRate() const { return dag2BN_.minEpsilonRate(); }

    void EMdisableMinEpsilonRate() { dag2BN_.disableMinEpsilonRate(); }

    void EMenableMinEpsilonRate() { dag2BN_.enableMinEpsilonRate(); }

    bool EMisEnabledMinEpsilonRate() const { return dag2BN_.isEnabledMinEpsilonRate(); }

    void EMsetMaxIter(Size max) { dag2BN_.setMaxIter(max); }

    Size EMMaxIter() const { return dag2BN_.maxIter(); }

    void EMdisableMaxIter() { dag2BN_.disableMaxIter(); }

    void EMenableMaxIter() { dag2BN_.enableMaxIter(); }

    bool EMisEnabledMaxIter() const { return dag2BN_.isEnabledMaxIter(); }

    void EMsetMaxTime(double timeout) { dag2BN_.setMaxTime(timeout); }

    double EMMaxTime() const { return dag2BN_.maxTime(); }

    double EMCurrentTime() const { return dag2BN_.currentTime(); }

    void EMdisableMaxTime() { dag2BN_.disableMaxTime(); }
 
    void EMenableMaxTime() { dag2BN_.enableMaxTime(); };

    bool EMisEnabledMaxTime() const { return dag2BN_.isEnabledMaxTime(); }

    void EMsetPeriodSize(Size p) { dag2BN_.setPeriodSize(p); }
 
    Size EMPeriodSize() const { return dag2BN_.periodSize(); }

    void EMsetVerbosity(bool v) { dag2BN_.setVerbosity(v); }

    bool EMVerbosity() const { return dag2BN_.verbosity(); }

    ApproximationSchemeSTATE EMStateApproximationScheme() const {
      return dag2BN_.stateApproximationScheme();
    }

    Size EMnbrIterations() const { return dag2BN_.nbrIterations(); }

    const std::vector< double >& EMHistory() const { return dag2BN_.history(); }

  };
 
  /* namespace learning */
}   // namespace gum::learning

#ifndef GUM_NO_INLINE
#  include <agrum/BN/learning/BNLearnUtils/IBNLearner_inl.h>
#endif /* GUM_NO_INLINE */
 
#include <agrum/BN/learning/BNLearnUtils/IBNLearner_tpl.h>
 
#endif /* GUM_LEARNING_GENERIC_BN_LEARNER_H */