inferenceEngine.h

Go to the documentation of this file.

#ifndef __INFERENCE_ENGINE__H__
#define __INFERENCE_ENGINE__H__


#include <map>

#include <agrum/CN/LrsWrapper.h>
#include <agrum/CN/varMod2BNsMap.h>
#include <agrum/core/approximations/approximationScheme.h>
#include <agrum/core/exceptions.h>
#include <agrum/core/math/pow.h>
#include <agrum/core/math/rational.h>

namespace gum {
  namespace credal {

    template < typename GUM_SCALAR >
    class InferenceEngine : public ApproximationScheme {
      private:
      //@beforeMerging swapping from typedef to using
      using credalSet = NodeProperty< std::vector< std::vector< GUM_SCALAR > > >;
      using margi = NodeProperty< std::vector< GUM_SCALAR > >;
      using expe = NodeProperty< GUM_SCALAR >;

      using dynExpe =
         typename gum::HashTable< std::string, std::vector< GUM_SCALAR > >;

      using query = NodeProperty< std::vector< bool > >;
      using cluster = NodeProperty< std::vector< NodeId > >;

      protected:
      const CredalNet< GUM_SCALAR >* _credalNet;

      margi _oldMarginalMin;
      margi _oldMarginalMax;

      margi _marginalMin;
      margi _marginalMax;

      credalSet _marginalSets;

      expe _expectationMin;
      expe _expectationMax;

      dynExpe _dynamicExpMin;
      dynExpe _dynamicExpMax;

      dynExpe _modal;

      margi _evidence;
      query _query;

      cluster _t0;
      cluster _t1;

      bool _storeVertices;
      bool _repetitiveInd;

      bool _storeBNOpt;
      VarMod2BNsMap< GUM_SCALAR > _dbnOpt;

      int _timeSteps;


      void _repetitiveInit();

      void _initExpectations();

      void _initMarginals();

      void _initMarginalSets();



      inline const GUM_SCALAR _computeEpsilon();

      inline void _updateExpectations(const NodeId&                    id,
                                      const std::vector< GUM_SCALAR >& vertex);

      inline void _updateCredalSets(const NodeId&                    id,
                                    const std::vector< GUM_SCALAR >& vertex,
                                    const bool& elimRedund = false);



      void _dynamicExpectations();

      public:

      // InferenceEngine ();
      explicit InferenceEngine(const CredalNet< GUM_SCALAR >& credalNet);
      virtual ~InferenceEngine();



      virtual void makeInference() = 0;


      VarMod2BNsMap< GUM_SCALAR >* getVarMod2BNsMap();

      const CredalNet< GUM_SCALAR >& credalNet();

      const NodeProperty< std::vector< NodeId > >& getT0Cluster() const;

      const NodeProperty< std::vector< NodeId > >& getT1Cluster() const;

      void setRepetitiveInd(const bool repetitive);

      void storeVertices(const bool value);
      void storeBNOpt(const bool value);

      bool repetitiveInd() const;

      bool storeVertices() const;
      bool storeBNOpt() const;


      void insertModalsFile(const std::string& path);

      void insertModals(
         const std::map< std::string, std::vector< GUM_SCALAR > >& modals);

      virtual void insertEvidenceFile(const std::string& path);

      void insertEvidence(
         const std::map< std::string, std::vector< GUM_SCALAR > >& eviMap);

      void
         insertEvidence(const NodeProperty< std::vector< GUM_SCALAR > >& evidence);

      void insertQueryFile(const std::string& path);

      void insertQuery(const NodeProperty< std::vector< bool > >& query);



      virtual void eraseAllEvidence();

      const std::vector< GUM_SCALAR >& marginalMin(const NodeId id) const;

      const std::vector< GUM_SCALAR >& marginalMax(const NodeId id) const;

      const std::vector< GUM_SCALAR >&
         marginalMin(const std::string& varName) const;

      const std::vector< GUM_SCALAR >&
         marginalMax(const std::string& varName) const;

      const GUM_SCALAR& expectationMin(const NodeId id) const;

      const GUM_SCALAR& expectationMax(const NodeId id) const;

      const GUM_SCALAR& expectationMin(const std::string& varName) const;

      const GUM_SCALAR& expectationMax(const std::string& varName) const;

      const std::vector< GUM_SCALAR >&
         dynamicExpMin(const std::string& varName) const;

      const std::vector< GUM_SCALAR >&
         dynamicExpMax(const std::string& varName) const;

      const std::vector< std::vector< GUM_SCALAR > >&
         vertices(const NodeId id) const;

      void saveMarginals(const std::string& path) const;

      void saveExpectations(const std::string& path) const;

      void saveVertices(const std::string& path) const;

      void dynamicExpectations();   // if someone forgets the protected call at
                                    // the end
                                    // of its own algorithm, the user can call it

      std::string toString() const;

      const std::string getApproximationSchemeMsg() {
        return this->messageApproximationScheme();
      }

    };


#ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
    extern template class InferenceEngine< double >;
#endif
  }   // namespace credal
}   // namespace gum

#include <agrum/CN/inferenceEngine_tpl.h>

#endif