Miic.h

Go to the documentation of this file.

#ifndef GUM_LEARNING_3_OFF_2_H
#define GUM_LEARNING_3_OFF_2_H

#include <string>
#include <vector>

#include <agrum/BN/BayesNet.h>
#include <agrum/config.h>
#include <agrum/core/approximations/IApproximationSchemeConfiguration.h>
#include <agrum/core/approximations/approximationScheme.h>
#include <agrum/core/heap.h>
#include <agrum/graphs/DAG.h>
#include <agrum/graphs/mixedGraph.h>
#include <agrum/learning/scores_and_tests/correctedMutualInformation.h>

namespace gum {

  namespace learning {

    class GreaterPairOn2nd {
      public:
      bool operator()(
         const std::pair<
            std::tuple< NodeId, NodeId, NodeId, std::vector< NodeId > >*,
            double >& e1,
         const std::pair<
            std::tuple< NodeId, NodeId, NodeId, std::vector< NodeId > >*,
            double >& e2) const;
    };

    class GreaterAbsPairOn2nd {
      public:
      bool operator()(
         const std::pair< std::tuple< NodeId, NodeId, NodeId >*, double >& e1,
         const std::pair< std::tuple< NodeId, NodeId, NodeId >*, double >& e2)
         const;
    };

    class GreaterTupleOnLast {
      public:
      bool operator()(
         const std::
            tuple< std::tuple< NodeId, NodeId, NodeId >*, double, double, double >&
               e1,
         const std::
            tuple< std::tuple< NodeId, NodeId, NodeId >*, double, double, double >&
               e2) const;
    };
    class Miic : public ApproximationScheme {
      public:
      // ##########################################################################
      // ##########################################################################

      Miic();

      Miic(int maxLog);

      Miic(const Miic& from);

      Miic(Miic&& from);

      ~Miic();


      Miic& operator=(const Miic& from);

      Miic& operator=(Miic&& from);

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



      MixedGraph learnMixedStructure(CorrectedMutualInformation<>& I,
                                     MixedGraph                    graph);


      DAG learnStructure(CorrectedMutualInformation<>& I, MixedGraph graph);


      template < typename GUM_SCALAR = double,
                 typename GRAPH_CHANGES_SELECTOR,
                 typename PARAM_ESTIMATOR >
      BayesNet< GUM_SCALAR > learnBN(GRAPH_CHANGES_SELECTOR& selector,
                                     PARAM_ESTIMATOR&        estimator,
                                     DAG                     initial_dag = DAG());

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

      void setMiicBehaviour();
      void set3off2Behaviour();

      void addConstraints(
         HashTable< std::pair< NodeId, NodeId >, char > constraints);

      protected:
      // ##########################################################################
      // ##########################################################################


      void _initiation(
         CorrectedMutualInformation<>&                                    I,
         MixedGraph&                                                      graph,
         HashTable< std::pair< NodeId, NodeId >, std::vector< NodeId > >& sep_set,
         Heap< std::pair<
                  std::tuple< NodeId, NodeId, NodeId, std::vector< NodeId > >*,
                  double >,
               GreaterPairOn2nd >&                                        _rank);


      void _iteration(
         CorrectedMutualInformation<>&                                    I,
         MixedGraph&                                                      graph,
         HashTable< std::pair< NodeId, NodeId >, std::vector< NodeId > >& sep_set,
         Heap< std::pair<
                  std::tuple< NodeId, NodeId, NodeId, std::vector< NodeId > >*,
                  double >,
               GreaterPairOn2nd >&                                        _rank);


      void _orientation_3off2(CorrectedMutualInformation<>&             I,
                              MixedGraph&                               graph,
                              const HashTable< std::pair< NodeId, NodeId >,
                                               std::vector< NodeId > >& sep_set);


      void _orientation_latents(CorrectedMutualInformation<>&             I,
                                MixedGraph&                               graph,
                                const HashTable< std::pair< NodeId, NodeId >,
                                                 std::vector< NodeId > >& sep_set);


      void _orientation_miic(CorrectedMutualInformation<>&             I,
                             MixedGraph&                               graph,
                             const HashTable< std::pair< NodeId, NodeId >,
                                              std::vector< NodeId > >& sep_set);


      void _findBestContributor(
         NodeId                        x,
         NodeId                        y,
         const std::vector< NodeId >&  ui,
         const MixedGraph&             graph,
         CorrectedMutualInformation<>& I,
         Heap< std::pair<
                  std::tuple< NodeId, NodeId, NodeId, std::vector< NodeId > >*,
                  double >,
               GreaterPairOn2nd >&     _rank);

      /*@param graph graph in which to find the triples
       *@param I mutual information object to compute the scores
       *@param sep_set hashtable storing the separation sets for pairs of variables
       */
      std::vector< std::pair< std::tuple< NodeId, NodeId, NodeId >*, double > >
         _getUnshieldedTriples(const MixedGraph&                         graph,
                               CorrectedMutualInformation<>&             I,
                               const HashTable< std::pair< NodeId, NodeId >,
                                                std::vector< NodeId > >& sep_set);

      /*@param graph graph in which to find the triples
       *@param I mutual information object to compute the scores
       *@param sep_set hashtable storing the separation sets for pairs of variables
       * @param marks hashtable containing the orientation marks for edges
       */
      std::vector< std::tuple< std::tuple< NodeId, NodeId, NodeId >*,
                               double,
                               double,
                               double > >
         _getUnshieldedTriplesMIIC(
            const MixedGraph&             graph,
            CorrectedMutualInformation<>& I,
            const HashTable< std::pair< NodeId, NodeId >, std::vector< NodeId > >&
                                                            sep_set,
            HashTable< std::pair< NodeId, NodeId >, char >& marks);

      /*@param graph graph in which to find the triples
       *@param proba_triples probabilities for the different triples to update
       */
      std::vector< std::tuple< std::tuple< NodeId, NodeId, NodeId >*,
                               double,
                               double,
                               double > >
         _updateProbaTriples(
            const MixedGraph&                   graph,
            std::vector< std::tuple< std::tuple< NodeId, NodeId, NodeId >*,
                                     double,
                                     double,
                                     double > > proba_triples);

      /*@param dag graph in which to which to propagate arcs
       *@param node node on which neighbours to propagate th orientation
       *@todo : avoid exception driven programmation in circle detection
       */
      void _propagatesHead(MixedGraph& graph, NodeId node);


      private:
      int __maxLog = 100;
      const std::vector< NodeId > __empty_set;
      std::vector< Arc > __latent_couples;

      Size __N;
      bool __usemiic{false};

      ArcProperty< double > __arc_probas;

      HashTable< std::pair< NodeId, NodeId >, char > __initial_marks;

      /*@param graph MixedGraph in which to search the path
       *@param n1 tail of the path
       *@param n2 head of the path
       */
      const bool __existsDirectedPath(const MixedGraph& graph,
                                      const NodeId      n1,
                                      const NodeId      n2) const;
    };

  } /* namespace learning */

} /* namespace gum */

//#include <agrum/learning/threeOffTwo_tpl.h>

#endif /* GUM_LEARNING_3_OFF_2_H */