structuredInference.h

Go to the documentation of this file.

#ifndef GUM_STRUCTURED_INFERENCE_H
#define GUM_STRUCTURED_INFERENCE_H

#include <string>

#include <agrum/core/timer.h>

#include <agrum/BN/inference/variableElimination.h>

#include <agrum/multidim/ICIModels/multiDimNoisyORCompound.h>
#include <agrum/multidim/ICIModels/multiDimNoisyORNet.h>
#include <agrum/multidim/implementations/multiDimSparse.h>
#include <agrum/multidim/potential.h>
#include <agrum/multidim/utils/operators/multiDimCombinationDefault.h>
#include <agrum/multidim/utils/operators/projections4MultiDim.h>

#include <agrum/graphs/algorithms/triangulations/partialOrderedTriangulation.h>

#include <agrum/PRM/PRM.h>
#include <agrum/PRM/inference/PRMInference.h>
#include <agrum/PRM/inference/gspan.h>

namespace gum {
  namespace prm {

    template < typename GUM_SCALAR >
    class StructuredInference : public PRMInference< GUM_SCALAR > {
      public:
      // ========================================================================
      // ========================================================================

      StructuredInference(const PRM< GUM_SCALAR >&             prm,
                          const PRMSystem< GUM_SCALAR >&       system,
                          gspan::SearchStrategy< GUM_SCALAR >* strategy = 0);

      StructuredInference(const StructuredInference& source);

      virtual ~StructuredInference();

      StructuredInference& operator=(const StructuredInference& source);

      // ========================================================================
      // ========================================================================

      void setPatternMining(bool b);

      virtual std::string name() const;

      GSpan< GUM_SCALAR >& gspan();

      const GSpan< GUM_SCALAR >& gspan() const;

      void searchPatterns();

      protected:
      // ========================================================================
      // ========================================================================

      virtual void
         _evidenceAdded(const typename PRMInference< GUM_SCALAR >::Chain& chain);

      virtual void
         _evidenceRemoved(const typename PRMInference< GUM_SCALAR >::Chain& chain);

      virtual void
         _marginal(const typename PRMInference< GUM_SCALAR >::Chain& chain,
                   Potential< GUM_SCALAR >&                          m);

      virtual void _joint(
         const std::vector< typename PRMInference< GUM_SCALAR >::Chain >& queries,
         Potential< GUM_SCALAR >&                                         j);

      private:
      struct RGData {
        UndiGraph reducedGraph;
        NodeProperty< Size > mods;
        Bijection< const DiscreteVariable*, NodeId > var2node;
        Set< Potential< GUM_SCALAR >* > pool;
        List< NodeSet > partial_order;
        RGData();
        ~RGData();
        inline NodeSet& outputs() { return partial_order[0]; }
        inline NodeSet& queries() { return partial_order[1]; }
      };

      struct PData {
        const gspan::Pattern& pattern;
        typename GSpan< GUM_SCALAR >::MatchedInstances& matches;
        UndiGraph graph;
        NodeProperty< Size > mod;
        Bijection< NodeId, std::string > node2attr;
        NodeProperty< std::pair< Idx, std::string > > map;
        Bijection< NodeId, const DiscreteVariable* > vars;
        NodeProperty< Potential< GUM_SCALAR >* > pots;
        Set< NodeId > barren;
        PData(const gspan::Pattern&                           p,
              typename GSpan< GUM_SCALAR >::MatchedInstances& m);
        PData(const PData& source);
        ~PData();
        inline NodeSet& inners() { return __partial_order[0]; }
        inline NodeSet& obs() { return __partial_order[1]; }
        inline NodeSet& outputs() { return __partial_order[2]; }
        inline NodeSet& queries() { return __partial_order[3]; }
        // We use the first match for computations
        // inline const Sequence<PRMInstance<GUM_SCALAR>*>& match() const {
        // return
        // **(matches.begin());}
        // Remove any empty set in partial_order
        const List< NodeSet >* partial_order();

        private:
        List< NodeSet > __partial_order;
        List< NodeSet >* __real_order;
      };

      struct CData {
        const PRMClass< GUM_SCALAR >& c;
        UndiGraph moral_graph;
        NodeProperty< Size > mods;
        List< NodeSet > partial_order;
        Set< const PRMInstance< GUM_SCALAR >* > instances;
        Set< Potential< GUM_SCALAR >* > pool;
        CData(const PRMClass< GUM_SCALAR >& c);
        ~CData();
        inline NodeSet& inners() { return __inners; }
        inline NodeSet& aggregators() { return __aggregators; }
        inline NodeSet& outputs() { return __outputs; }
        inline std::vector< NodeId >& elim_order() { return __elim_order; }

        private:
        std::vector< NodeId >           __elim_order;
        NodeSet                         __inners;
        NodeSet                         __aggregators;
        NodeSet                         __outputs;
        Set< Potential< GUM_SCALAR >* > __trash;
      };

      GSpan< GUM_SCALAR >* __gspan;

      HashTable< const Sequence< PRMInstance< GUM_SCALAR >* >*,
                 Set< Potential< GUM_SCALAR >* >* >
         __elim_map;

      HashTable< const PRMClass< GUM_SCALAR >*, CData* > __cdata_map;

      Set< Potential< GUM_SCALAR >* > __trash;

      HashTable< const PRMClass< GUM_SCALAR >*, std::vector< NodeId >* > __outputs;

      Set< const PRMInstance< GUM_SCALAR >* > __reducedInstances;

      typename PRMInference< GUM_SCALAR >::Chain __query;

      PData* __pdata;

      bool __mining;

      bool                          __found_query;
      std::pair< Idx, std::string > __query_data;

      void __buildReduceGraph(RGData& data);

      // MSVC void __addNodesInReducedGraph( RGData& data );

      void __addEdgesInReducedGraph(RGData& data);

      void __removeNode(typename StructuredInference::PData& data,
                        NodeId                               id,
                        Set< Potential< GUM_SCALAR >* >&     pool);

      void __reduceAloneInstances(RGData& data);

      void __reducePattern(const gspan::Pattern* p);

      void
         __buildPatternGraph(PData&                                        data,
                             Set< Potential< GUM_SCALAR >* >&              pool,
                             const Sequence< PRMInstance< GUM_SCALAR >* >& match);

      void __insertNodeInElimLists(
         typename StructuredInference::PData&          data,
         const Sequence< PRMInstance< GUM_SCALAR >* >& match,
         PRMInstance< GUM_SCALAR >*                    inst,
         PRMAttribute< GUM_SCALAR >*                   attr,
         NodeId                                        id,
         std::pair< Idx, std::string >&                v);

      bool __allInstanceNoRefAttr(typename StructuredInference::PData& data,
                                  std::pair< Idx, std::string >        attr);

      void __removeBarrenNodes(typename StructuredInference::PData& data,
                               Set< Potential< GUM_SCALAR >* >&     pool);

      // MVSC void __buildQuerySet( PData& data );

      Set< Potential< GUM_SCALAR >* >* __eliminateObservedNodes(
         typename StructuredInference::PData&          data,
         const Set< Potential< GUM_SCALAR >* >&        pool,
         const Sequence< PRMInstance< GUM_SCALAR >* >& match,
         const std::vector< NodeId >&                  elim_order);

      Set< Potential< GUM_SCALAR >* >* __eliminateObservedNodesInSource(
         typename StructuredInference::PData&          data,
         const Set< Potential< GUM_SCALAR >* >&        pool,
         const Sequence< PRMInstance< GUM_SCALAR >* >& match,
         const std::vector< NodeId >&                  elim_order);

      Set< Potential< GUM_SCALAR >* >*
         __translatePotSet(typename StructuredInference::PData&          data,
                           const Set< Potential< GUM_SCALAR >* >&        pool,
                           const Sequence< PRMInstance< GUM_SCALAR >* >& match);

      // MVSC void __unreduceMatchWithQuery();

      // MVSC std::vector<NodeId>* __getClassOutputs( const
      // PRMClass<GUM_SCALAR>* c );
      std::string __dot;
      std::string __str(const PRMInstance< GUM_SCALAR >*  i,
                        const PRMAttribute< GUM_SCALAR >* a) const;
      std::string __str(const PRMInstance< GUM_SCALAR >*  i,
                        const PRMAttribute< GUM_SCALAR >& a) const;
      std::string __str(const PRMInstance< GUM_SCALAR >*  i,
                        const PRMSlotChain< GUM_SCALAR >& a) const;

      public:
      // For bench/debug purpose.
      Timer       timer;
      Timer       plopTimer;
      double      triang_time;
      double      mining_time;
      double      pattern_time;
      double      inner_time;
      double      obs_time;
      double      full_time;
      std::string info() const;
    };


#ifndef GUM_NO_EXTERN_TEMPLATE_CLASS
    extern template class StructuredInference< double >;
#endif


  } /* namespace prm */
} /* namespace gum */

#include <agrum/PRM/inference/structuredInference_tpl.h>

#endif /* GUM_STRUCTURED_INFERENCE_H */