gum::learning::SimpleMiic Class Reference

The miic learning algorithm. More...

#include <SimpleMiic.h>

Inheritance diagram for gum::learning::SimpleMiic:

Collaboration diagram for gum::learning::SimpleMiic:

Public Types
enum class	ApproximationSchemeSTATE : char {   Undefined , Continue , Epsilon , Rate ,   Limit , TimeLimit , Stopped }
	The different state of an approximation scheme. More...

Public Member Functions
SimpleMiic &	operator= (const SimpleMiic &from)
	copy operator
SimpleMiic &	operator= (SimpleMiic &&from)
	move operator
Constructors / Destructors
	SimpleMiic ()
	default constructor
	SimpleMiic (int maxLog)
	default constructor with maxLog
	SimpleMiic (const SimpleMiic &from)
	copy constructor
	SimpleMiic (SimpleMiic &&from)
	move constructor
	~SimpleMiic () override
	destructor
Accessors / Modifiers
MixedGraph	learnPDAG (CorrectedMutualInformation &mutualInformation, MixedGraph graph)
	learns the structure of an Essential Graph
MixedGraph	learnMixedStructure (CorrectedMutualInformation &mutualInformation, MixedGraph graph)
	learns the structure of an Essential Graph
DAG	learnStructure (CorrectedMutualInformation &I, MixedGraph graph)
	learns the structure of a Bayesian network, i.e. a DAG, by first learning an Essential graph and then directing the remaining edges.
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())
	learns the structure and the parameters of a BN
const std::vector< Arc >	latentVariables () const
	get the list of arcs hiding latent variables
void	addConstraints (HashTable< std::pair< NodeId, NodeId >, char > constraints)
	Set a ensemble of constraints for the orientation phase.
Getters and setters
void	setEpsilon (double eps) override
	Given that we approximate f(t), stopping criterion on |f(t+1)-f(t)|.
double	epsilon () const override
	Returns the value of epsilon.
void	disableEpsilon () override
	Disable stopping criterion on epsilon.
void	enableEpsilon () override
	Enable stopping criterion on epsilon.
bool	isEnabledEpsilon () const override
	Returns true if stopping criterion on epsilon is enabled, false otherwise.
void	setMinEpsilonRate (double rate) override
	Given that we approximate f(t), stopping criterion on d/dt(|f(t+1)-f(t)|).
double	minEpsilonRate () const override
	Returns the value of the minimal epsilon rate.
void	disableMinEpsilonRate () override
	Disable stopping criterion on epsilon rate.
void	enableMinEpsilonRate () override
	Enable stopping criterion on epsilon rate.
bool	isEnabledMinEpsilonRate () const override
	Returns true if stopping criterion on epsilon rate is enabled, false otherwise.
void	setMaxIter (Size max) override
	Stopping criterion on number of iterations.
Size	maxIter () const override
	Returns the criterion on number of iterations.
void	disableMaxIter () override
	Disable stopping criterion on max iterations.
void	enableMaxIter () override
	Enable stopping criterion on max iterations.
bool	isEnabledMaxIter () const override
	Returns true if stopping criterion on max iterations is enabled, false otherwise.
void	setMaxTime (double timeout) override
	Stopping criterion on timeout.
double	maxTime () const override
	Returns the timeout (in seconds).
double	currentTime () const override
	Returns the current running time in second.
void	disableMaxTime () override
	Disable stopping criterion on timeout.
void	enableMaxTime () override
	Enable stopping criterion on timeout.
bool	isEnabledMaxTime () const override
	Returns true if stopping criterion on timeout is enabled, false otherwise.
void	setPeriodSize (Size p) override
	How many samples between two stopping is enable.
Size	periodSize () const override
	Returns the period size.
void	setVerbosity (bool v) override
	Set the verbosity on (true) or off (false).
bool	verbosity () const override
	Returns true if verbosity is enabled.
ApproximationSchemeSTATE	stateApproximationScheme () const override
	Returns the approximation scheme state.
Size	nbrIterations () const override
	Returns the number of iterations.
const std::vector< double > &	history () const override
	Returns the scheme history.
void	initApproximationScheme ()
	Initialise the scheme.
bool	startOfPeriod () const
	Returns true if we are at the beginning of a period (compute error is mandatory).
void	updateApproximationScheme (unsigned int incr=1)
	Update the scheme w.r.t the new error and increment steps.
Size	remainingBurnIn () const
	Returns the remaining burn in.
void	stopApproximationScheme ()
	Stop the approximation scheme.
bool	continueApproximationScheme (double error)
	Update the scheme w.r.t the new error.
Getters and setters
std::string	messageApproximationScheme () const
	Returns the approximation scheme message.

Public Attributes
Signaler3< Size, double, double >	onProgress
	Progression, error and time.
Signaler1< const std::string & >	onStop
	Criteria messageApproximationScheme.

Protected Member Functions
void	orientationLatents_ (CorrectedMutualInformation &mutualInformation, MixedGraph &graph, const HashTable< std::pair< NodeId, NodeId >, std::vector< NodeId > > &sepSet)
	variant trying to propagate both orientations in a bidirected arc
void	findBestContributor_ (NodeId x, NodeId y, const std::vector< NodeId > &ui, const MixedGraph &graph, CorrectedMutualInformation &mutualInformation, Heap< CondRanking, GreaterPairOn2nd > &rank)
	finds the best contributor node for a pair given a conditioning set
std::vector< Ranking >	unshieldedTriples_ (const MixedGraph &graph, CorrectedMutualInformation &mutualInformation, const HashTable< std::pair< NodeId, NodeId >, std::vector< NodeId > > &sepSet)
	gets the list of unshielded triples in the graph in decreasing value of |I'(x, y, z|{ui})|
std::vector< ProbabilisticRanking >	unshieldedTriplesMiic_ (const MixedGraph &graph, CorrectedMutualInformation &mutualInformation, const HashTable< std::pair< NodeId, NodeId >, std::vector< NodeId > > &sepSet, HashTable< std::pair< NodeId, NodeId >, char > &marks)
	gets the list of unshielded triples in the graph in decreasing value of |I'(x, y, z|{ui})|, prepares the orientation matrix for MIIC
std::vector< ProbabilisticRanking >	updateProbaTriples_ (const MixedGraph &graph, std::vector< ProbabilisticRanking > probaTriples)
	Gets the orientation probabilities like MIIC for the orientation phase.
bool	propagatesRemainingOrientableEdges_ (MixedGraph &graph, NodeId xj)
	Propagates the orientation from a node to its neighbours.
void	propagatesOrientationInChainOfRemainingEdges_ (MixedGraph &graph)
	heuristic for remaining edges when everything else has been tried
bool	isForbidenArc_ (NodeId x, NodeId y) const
bool	isOrientable_ (const MixedGraph &graph, NodeId xi, NodeId xj) const
Main phases
void	initiation_ (CorrectedMutualInformation &mutualInformation, MixedGraph &graph, HashTable< std::pair< NodeId, NodeId >, std::vector< NodeId > > &sepSet, Heap< CondRanking, GreaterPairOn2nd > &rank)
	Initiation phase.
void	iteration_ (CorrectedMutualInformation &mutualInformation, MixedGraph &graph, HashTable< std::pair< NodeId, NodeId >, std::vector< NodeId > > &sepSet, Heap< CondRanking, GreaterPairOn2nd > &rank)
	Iteration phase.
void	orientationMiic_ (CorrectedMutualInformation &mutualInformation, MixedGraph &graph, const HashTable< std::pair< NodeId, NodeId >, std::vector< NodeId > > &sepSet)
	Orientation phase from the MIIC algorithm, returns a mixed graph that may contain circles.

Protected Attributes
double	current_epsilon_
	Current epsilon.
double	last_epsilon_
	Last epsilon value.
double	current_rate_
	Current rate.
Size	current_step_
	The current step.
Timer	timer_
	The timer.
ApproximationSchemeSTATE	current_state_
	The current state.
std::vector< double >	history_
	The scheme history, used only if verbosity == true.
double	eps_
	Threshold for convergence.
bool	enabled_eps_
	If true, the threshold convergence is enabled.
double	min_rate_eps_
	Threshold for the epsilon rate.
bool	enabled_min_rate_eps_
	If true, the minimal threshold for epsilon rate is enabled.
double	max_time_
	The timeout.
bool	enabled_max_time_
	If true, the timeout is enabled.
Size	max_iter_
	The maximum iterations.
bool	enabled_max_iter_
	If true, the maximum iterations stopping criterion is enabled.
Size	burn_in_
	Number of iterations before checking stopping criteria.
Size	period_size_
	Checking criteria frequency.
bool	verbosity_
	If true, verbosity is enabled.

Private Member Functions
void	_orientingVstructureMiic_ (MixedGraph &graph, HashTable< std::pair< NodeId, NodeId >, char > &marks, NodeId x, NodeId y, NodeId z, double p1, double p2)
void	_propagatingOrientationMiic_ (MixedGraph &graph, HashTable< std::pair< NodeId, NodeId >, char > &marks, NodeId x, NodeId y, NodeId z, double p1, double p2)
bool	_isNotLatentCouple_ (NodeId x, NodeId y)
void	stopScheme_ (ApproximationSchemeSTATE new_state)
	Stop the scheme given a new state.

Static Private Member Functions
static bool	_existsNonTrivialDirectedPath_ (const MixedGraph &graph, NodeId n1, NodeId n2)
	checks for directed paths in a graph, considering double arcs like edges, not considering arc as a directed path.
static bool	_existsDirectedPath_ (const MixedGraph &graph, NodeId n1, NodeId n2)
	checks for directed paths in a graph, consider double arcs like edges

Private Attributes
int	_maxLog_ = 100
	Fixes the maximum log that we accept in exponential computations.
const std::vector< NodeId >	_emptySet_
	an empty conditioning set
std::vector< Arc >	_latentCouples_
	an empty vector of arcs
Size	_size_
	size of the database
ArcProperty< double >	_arcProbas_
	Storing the propabilities for each arc set in the graph.
HashTable< std::pair< NodeId, NodeId >, char >	_initialMarks_
	Initial marks for the orientation phase, used to convey constraints.

Detailed Description

The miic learning algorithm.

The miic class implements the miic algorithm based on https://doi.org/10.1371/journal.pcbi.1005662. It starts by eliminating edges that correspond to independent variables to build the skeleton of the graph, and then directs the remaining edges to get an essential graph. Latent variables can be detected using bi-directed arcs.

Definition at line 83 of file SimpleMiic.h.

Member Enumeration Documentation

ApproximationSchemeSTATE

enum class gum::IApproximationSchemeConfiguration::ApproximationSchemeSTATE : char

stronginherited

The different state of an approximation scheme.

Enumerator
Undefined
Continue
Epsilon
Rate
Limit
TimeLimit
Stopped

Definition at line 86 of file IApproximationSchemeConfiguration.h.

                                        : char {
      Undefined,
      Continue,
      Epsilon,
      Rate,
      Limit,
      TimeLimit,
      Stopped
    };

Constructor & Destructor Documentation

SimpleMiic() [1/4]

gum::learning::SimpleMiic::SimpleMiic

(

)

default constructor

Definition at line 63 of file SimpleMiic.cpp.

: _maxLog_(100), _size_(0) { GUM_CONSTRUCTOR(SimpleMiic); }

References SimpleMiic(), _maxLog_, and _size_.

Referenced by SimpleMiic(), SimpleMiic(), SimpleMiic(), SimpleMiic(), ~SimpleMiic(), operator=(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

SimpleMiic() [2/4]

gum::learning::SimpleMiic::SimpleMiic ( int maxLog )

explicit

default constructor with maxLog

Definition at line 66 of file SimpleMiic.cpp.

                                     : _maxLog_(maxLog), _size_(0) {
      GUM_CONSTRUCTOR(SimpleMiic);
    }

References SimpleMiic(), _maxLog_, and _size_.

Here is the call graph for this function:

SimpleMiic() [3/4]

gum::learning::SimpleMiic::SimpleMiic

(

const SimpleMiic &

from

)

copy constructor

Definition at line 71 of file SimpleMiic.cpp.

                                                 :
        ApproximationScheme(from), _size_(from._size_) {
      GUM_CONS_CPY(SimpleMiic);
    }

References gum::ApproximationScheme::ApproximationScheme(), SimpleMiic(), and _size_.

Here is the call graph for this function:

SimpleMiic() [4/4]

gum::learning::SimpleMiic::SimpleMiic

(

SimpleMiic &&

from

)

move constructor

Definition at line 77 of file SimpleMiic.cpp.

                                            :
        ApproximationScheme(std::move(from)), _size_(from._size_) {
      GUM_CONS_MOV(SimpleMiic);
    }

References gum::ApproximationScheme::ApproximationScheme(), SimpleMiic(), and _size_.

Here is the call graph for this function:

~SimpleMiic()

gum::learning::SimpleMiic::~SimpleMiic ( )

override

destructor

Definition at line 83 of file SimpleMiic.cpp.

{ GUM_DESTRUCTOR(SimpleMiic); }

References SimpleMiic().

Here is the call graph for this function:

Member Function Documentation

_existsDirectedPath_()

bool gum::learning::SimpleMiic::_existsDirectedPath_ ( const MixedGraph & graph, NodeId n1, NodeId n2 )

staticprivate

checks for directed paths in a graph, consider double arcs like edges

Parameters

graph	MixedGraph in which to search the path
n1	tail of the path
n2	head of the path

Definition at line 852 of file SimpleMiic.cpp.

                                                                {
      // not recursive version => use a FIFO for simulating the recursion
      List< NodeId > nodeFIFO;
      // mark[node] = successor if visited, else mark[node] does not exist
      Set< NodeId > mark;
 
      mark.insert(n2);
      nodeFIFO.pushBack(n2);
 
      NodeId current;
 
      while (!nodeFIFO.empty()) {
        current = nodeFIFO.front();
        nodeFIFO.popFront();
 
        // check the parents
        for (const auto new_one: graph.parents(current)) {
          if (graph.existsArc(current,
                              new_one))   // if there is a double arc, pass
            continue;
 
          if (new_one == n1) { return true; }
 
          if (mark.exists(new_one))   // if this node is already marked, do not
            continue;                 // check it again
 
          mark.insert(new_one);
          nodeFIFO.pushBack(new_one);
        }
      }
 
      return false;
    }

References gum::List< Val >::empty(), gum::Set< Key >::exists(), gum::ArcGraphPart::existsArc(), gum::List< Val >::front(), gum::Set< Key >::insert(), gum::ArcGraphPart::parents(), gum::List< Val >::popFront(), and gum::List< Val >::pushBack().

Referenced by _existsNonTrivialDirectedPath_(), _propagatingOrientationMiic_(), isOrientable_(), and orientationMiic_().

Here is the call graph for this function:

Here is the caller graph for this function:

_existsNonTrivialDirectedPath_()

bool gum::learning::SimpleMiic::_existsNonTrivialDirectedPath_ ( const MixedGraph & graph, NodeId n1, NodeId n2 )

staticprivate

checks for directed paths in a graph, considering double arcs like edges, not considering arc as a directed path.

Parameters

graph	MixedGraph in which to search the path
n1	tail of the path
n2	head of the path
countArc	bool to know if we

Definition at line 838 of file SimpleMiic.cpp.

                                                                          {
      for (const auto parent: graph.parents(n2)) {
        if (graph.existsArc(parent,
                            n2))   // if there is a double arc, pass
          continue;
        if (parent == n1)          // trivial directed path => not recognized
          continue;
        if (_existsDirectedPath_(graph, n1, parent)) return true;
      }
      return false;
    }

References _existsDirectedPath_(), gum::ArcGraphPart::existsArc(), and gum::ArcGraphPart::parents().

Referenced by _orientingVstructureMiic_().

Here is the call graph for this function:

Here is the caller graph for this function:

_isNotLatentCouple_()

bool gum::learning::SimpleMiic::_isNotLatentCouple_ ( NodeId x, NodeId y )

private

Definition at line 1057 of file SimpleMiic.cpp.

                                                                       {
      const auto& lbeg = _latentCouples_.begin();
      const auto& lend = _latentCouples_.end();
 
      return (std::find(lbeg, lend, Arc(x, y)) == lend)
          && (std::find(lbeg, lend, Arc(y, x)) == lend);
    }

References _latentCouples_.

Referenced by _orientingVstructureMiic_(), and orientationLatents_().

Here is the caller graph for this function:

_orientingVstructureMiic_()

void gum::learning::SimpleMiic::_orientingVstructureMiic_ ( MixedGraph & graph, HashTable< std::pair< NodeId, NodeId >, char > & marks, NodeId x, NodeId y, NodeId z, double p1, double p2 )

private

Definition at line 889 of file SimpleMiic.cpp.

                                                                                                  {
      // v-structure discovery
      if (marks[{x, z}] == 'o' && marks[{y, z}] == 'o') {   // If x-z-y
        if (!_existsNonTrivialDirectedPath_(graph, z, x)) {
          graph.eraseEdge(Edge(x, z));
          graph.addArc(x, z);
          // GUM_TRACE("1.a Removing edge (" << x << "," << z << ")")
          // GUM_TRACE("1.a Adding arc (" << x << "," << z << ")")
          marks[{x, z}] = '>';
          if (graph.existsArc(z, x) && _isNotLatentCouple_(z, x)) {
            GUM_TRACE("Adding latent couple (" << z << "," << x << ")")
            _latentCouples_.emplace_back(z, x);
          }
          if (!_arcProbas_.exists(Arc(x, z))) _arcProbas_.insert(Arc(x, z), p1);
        } else {
          graph.eraseEdge(Edge(x, z));
          // GUM_TRACE("1.b Adding arc (" << x << "," << z << ")")
          if (!_existsNonTrivialDirectedPath_(graph, x, z)) {
            graph.addArc(z, x);
            // GUM_TRACE("1.b Removing edge (" << x << "," << z << ")")
            marks[{z, x}] = '>';
          }
        }
 
        if (!_existsNonTrivialDirectedPath_(graph, z, y)) {
          graph.eraseEdge(Edge(y, z));
          graph.addArc(y, z);
          // GUM_TRACE("1.c Removing edge (" << y << "," << z << ")")
          // GUM_TRACE("1.c Adding arc (" << y << "," << z << ")")
          marks[{y, z}] = '>';
          if (graph.existsArc(z, y) && _isNotLatentCouple_(z, y)) {
            GUM_TRACE("Adding latent couple (" << z << "," << y << ")")
            _latentCouples_.emplace_back(z, y);
          }
          if (!_arcProbas_.exists(Arc(y, z))) _arcProbas_.insert(Arc(y, z), p2);
        } else {
          graph.eraseEdge(Edge(y, z));
          // GUM_TRACE("1.d Removing edge (" << y << "," << z << ")")
          if (!_existsNonTrivialDirectedPath_(graph, y, z)) {
            graph.addArc(z, y);
            // GUM_TRACE("1.d Adding arc (" << z << "," << y << ")")
            marks[{z, y}] = '>';
          }
        }
      } else if (marks[{x, z}] == '>' && marks[{y, z}] == 'o') {   // If x->z-y
        if (!_existsNonTrivialDirectedPath_(graph, z, y)) {
          graph.eraseEdge(Edge(y, z));
          graph.addArc(y, z);
          // GUM_TRACE("2.a Removing edge (" << y << "," << z << ")")
          // GUM_TRACE("2.a Adding arc (" << y << "," << z << ")")
          marks[{y, z}] = '>';
          if (graph.existsArc(z, y) && _isNotLatentCouple_(z, y)) {
            GUM_TRACE("Adding latent couple (" << z << "," << y << ")")
            _latentCouples_.emplace_back(z, y);
          }
          if (!_arcProbas_.exists(Arc(y, z))) _arcProbas_.insert(Arc(y, z), p2);
        } else {
          graph.eraseEdge(Edge(y, z));
          // GUM_TRACE("2.b Removing edge (" << y << "," << z << ")")
          if (!_existsNonTrivialDirectedPath_(graph, y, z)) {
            graph.addArc(z, y);
            // GUM_TRACE("2.b Adding arc (" << y << "," << z << ")")
            marks[{z, y}] = '>';
          }
        }
      } else if (marks[{y, z}] == '>' && marks[{x, z}] == 'o') {
        if (!_existsNonTrivialDirectedPath_(graph, z, x)) {
          graph.eraseEdge(Edge(x, z));
          graph.addArc(x, z);
          // GUM_TRACE("3.a Removing edge (" << x << "," << z << ")")
          // GUM_TRACE("3.a Adding arc (" << x << "," << z << ")")
          marks[{x, z}] = '>';
          if (graph.existsArc(z, x) && _isNotLatentCouple_(z, x)) {
            GUM_TRACE("Adding latent couple (" << z << "," << x << ")")
            _latentCouples_.emplace_back(z, x);
          }
          if (!_arcProbas_.exists(Arc(x, z))) _arcProbas_.insert(Arc(x, z), p1);
        } else {
          graph.eraseEdge(Edge(x, z));
          // GUM_TRACE("3.b Removing edge (" << x << "," << z << ")")
          if (!_existsNonTrivialDirectedPath_(graph, x, z)) {
            graph.addArc(z, x);
            // GUM_TRACE("3.b Adding arc (" << x << "," << z << ")")
            marks[{z, x}] = '>';
          }
        }
      }
    }

References _arcProbas_, _existsNonTrivialDirectedPath_(), _isNotLatentCouple_(), _latentCouples_, gum::DiGraph::addArc(), gum::EdgeGraphPart::eraseEdge(), and gum::ArcGraphPart::existsArc().

Referenced by orientationMiic_().

Here is the call graph for this function:

Here is the caller graph for this function:

_propagatingOrientationMiic_()

void gum::learning::SimpleMiic::_propagatingOrientationMiic_ ( MixedGraph & graph, HashTable< std::pair< NodeId, NodeId >, char > & marks, NodeId x, NodeId y, NodeId z, double p1, double p2 )

private

Definition at line 984 of file SimpleMiic.cpp.

                                                            {
      // orientation propagation
      if (marks[{x, z}] == '>' && marks[{y, z}] == 'o' && marks[{z, y}] != '-') {
        graph.eraseEdge(Edge(z, y));
        // std::cout << "4. Removing edge (" << z << "," << y << ")" <<
        // std::endl;
        if (!_existsDirectedPath_(graph, y, z) && graph.parents(y).empty()) {
          graph.addArc(z, y);
          // GUM_TRACE("4.a Adding arc (" << z << "," << y << ")")
          marks[{z, y}] = '>';
          marks[{y, z}] = '-';
          if (!_arcProbas_.exists(Arc(z, y))) _arcProbas_.insert(Arc(z, y), p2);
        } else if (!_existsDirectedPath_(graph, z, y) && graph.parents(z).empty()) {
          graph.addArc(y, z);
          GUM_TRACE("4.b Adding arc (" << y << "," << z << ")")
          marks[{z, y}] = '-';
          marks[{y, z}] = '>';
          _latentCouples_.emplace_back(y, z);
          if (!_arcProbas_.exists(Arc(y, z))) _arcProbas_.insert(Arc(y, z), p2);
        } else if (!_existsDirectedPath_(graph, y, z)) {
          graph.addArc(z, y);
          // GUM_TRACE("4.c Adding arc (" << z << "," << y << ")")
          marks[{z, y}] = '>';
          marks[{y, z}] = '-';
          if (!_arcProbas_.exists(Arc(z, y))) _arcProbas_.insert(Arc(z, y), p2);
        } else if (!_existsDirectedPath_(graph, z, y)) {
          graph.addArc(y, z);
          GUM_TRACE("4.d Adding arc (" << y << "," << z << ")")
          _latentCouples_.emplace_back(y, z);
          marks[{z, y}] = '-';
          marks[{y, z}] = '>';
          if (!_arcProbas_.exists(Arc(y, z))) _arcProbas_.insert(Arc(y, z), p2);
        }
      } else if (marks[{y, z}] == '>' && marks[{x, z}] == 'o' && marks[{z, x}] != '-') {
        graph.eraseEdge(Edge(z, x));
        // GUM_TRACE("5. Removing edge (" << z << "," << x << ")")
        if (!_existsDirectedPath_(graph, x, z) && graph.parents(x).empty()) {
          graph.addArc(z, x);
          // GUM_TRACE("5.a Adding arc (" << z << "," << x << ")")
          marks[{z, x}] = '>';
          marks[{x, z}] = '-';
          if (!_arcProbas_.exists(Arc(z, x))) _arcProbas_.insert(Arc(z, x), p1);
        } else if (!_existsDirectedPath_(graph, z, x) && graph.parents(z).empty()) {
          graph.addArc(x, z);
          GUM_TRACE("5.b Adding arc (" << x << "," << z << ")")
          marks[{z, x}] = '-';
          marks[{x, z}] = '>';
          _latentCouples_.emplace_back(x, z);
          if (!_arcProbas_.exists(Arc(x, z))) _arcProbas_.insert(Arc(x, z), p1);
        } else if (!_existsDirectedPath_(graph, x, z)) {
          graph.addArc(z, x);
          // GUM_TRACE("5.c Adding arc (" << z << "," << x << ")")
          marks[{z, x}] = '>';
          marks[{x, z}] = '-';
          if (!_arcProbas_.exists(Arc(z, x))) _arcProbas_.insert(Arc(z, x), p1);
        } else if (!_existsDirectedPath_(graph, z, x)) {
          graph.addArc(x, z);
          GUM_TRACE("5.d Adding arc (" << x << "," << z << ")")
          marks[{z, x}] = '-';
          marks[{x, z}] = '>';
          _latentCouples_.emplace_back(x, z);
          if (!_arcProbas_.exists(Arc(x, z))) _arcProbas_.insert(Arc(x, z), p1);
        }
      }
    }

References _arcProbas_, _existsDirectedPath_(), _latentCouples_, gum::DiGraph::addArc(), gum::Set< Key >::empty(), gum::EdgeGraphPart::eraseEdge(), and gum::ArcGraphPart::parents().

Referenced by orientationMiic_().

Here is the call graph for this function:

Here is the caller graph for this function:

addConstraints()

void gum::learning::SimpleMiic::addConstraints

(

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

constraints

)

Set a ensemble of constraints for the orientation phase.

Definition at line 834 of file SimpleMiic.cpp.

                                                                                            {
      this->_initialMarks_ = constraints;
    }

References _initialMarks_.

continueApproximationScheme()

INLINE bool gum::ApproximationScheme::continueApproximationScheme ( double error )

inherited

Update the scheme w.r.t the new error.

Test the stopping criterion that are enabled.

Parameters

error

The new error value.

Returns

false if state become != ApproximationSchemeSTATE::Continue

Exceptions

OperationNotAllowed

Raised if state != ApproximationSchemeSTATE::Continue.

Definition at line 229 of file approximationScheme_inl.h.

                                                                           {
    // For coherence, we fix the time used in the method
 
    double timer_step = timer_.step();
 
    if (enabled_max_time_) {
      if (timer_step > max_time_) {
        stopScheme_(ApproximationSchemeSTATE::TimeLimit);
        return false;
      }
    }
 
    if (!startOfPeriod()) { return true; }
 
    if (current_state_ != ApproximationSchemeSTATE::Continue) {
      GUM_ERROR(
          OperationNotAllowed,
          "state of the approximation scheme is not correct : " << messageApproximationScheme());
    }
 
    if (verbosity()) { history_.push_back(error); }
 
    if (enabled_max_iter_) {
      if (current_step_ > max_iter_) {
        stopScheme_(ApproximationSchemeSTATE::Limit);
        return false;
      }
    }
 
    last_epsilon_    = current_epsilon_;
    current_epsilon_ = error;   // eps rate isEnabled needs it so affectation was
    // moved from eps isEnabled below
 
    if (enabled_eps_) {
      if (current_epsilon_ <= eps_) {
        stopScheme_(ApproximationSchemeSTATE::Epsilon);
        return false;
      }
    }
 
    if (last_epsilon_ >= 0.) {
      if (current_epsilon_ > .0) {
        // ! current_epsilon_ can be 0. AND epsilon
        // isEnabled can be disabled !
        current_rate_ = std::fabs((current_epsilon_ - last_epsilon_) / current_epsilon_);
      }
      // limit with current eps ---> 0 is | 1 - ( last_eps / 0 ) | --->
      // infinity the else means a return false if we isEnabled the rate below,
      // as we would have returned false if epsilon isEnabled was enabled
      else {
        current_rate_ = min_rate_eps_;
      }
 
      if (enabled_min_rate_eps_) {
        if (current_rate_ <= min_rate_eps_) {
          stopScheme_(ApproximationSchemeSTATE::Rate);
          return false;
        }
      }
    }
 
    if (stateApproximationScheme() == ApproximationSchemeSTATE::Continue) {
      if (onProgress.hasListener()) {
        GUM_EMIT3(onProgress, current_step_, current_epsilon_, timer_step);
      }
 
      return true;
    } else {
      return false;
    }
  }

References enabled_max_time_, and timer_.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::computeKL_(), gum::learning::GreedyHillClimbing::learnStructure(), gum::learning::LocalSearchWithTabuList::learnStructure(), gum::SamplingInference< GUM_SCALAR >::loopApproxInference_(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::makeInferenceByOrderedArcs_(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::makeInferenceByRandomOrder_(), and gum::credal::CNLoopyPropagation< GUM_SCALAR >::makeInferenceNodeToNeighbours_().

Here is the caller graph for this function:

currentTime()

INLINE double gum::ApproximationScheme::currentTime ( ) const

overridevirtualinherited

Returns the current running time in second.

Returns

Returns the current running time in second.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 136 of file approximationScheme_inl.h.

{ return timer_.step(); }

References timer_.

disableEpsilon()

INLINE void gum::ApproximationScheme::disableEpsilon ( )

overridevirtualinherited

Disable stopping criterion on epsilon.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 74 of file approximationScheme_inl.h.

{ enabled_eps_ = false; }

References enabled_eps_.

Referenced by gum::learning::EMApproximationScheme::EMApproximationScheme(), and gum::learning::EMApproximationScheme::setMinEpsilonRate().

Here is the caller graph for this function:

disableMaxIter()

INLINE void gum::ApproximationScheme::disableMaxIter ( )

overridevirtualinherited

Disable stopping criterion on max iterations.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 115 of file approximationScheme_inl.h.

{ enabled_max_iter_ = false; }

References enabled_max_iter_.

Referenced by gum::learning::GreedyHillClimbing::GreedyHillClimbing().

Here is the caller graph for this function:

disableMaxTime()

INLINE void gum::ApproximationScheme::disableMaxTime ( )

overridevirtualinherited

Disable stopping criterion on timeout.

Returns

Disable stopping criterion on timeout.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 139 of file approximationScheme_inl.h.

{ enabled_max_time_ = false; }

References enabled_max_time_.

Referenced by gum::learning::GreedyHillClimbing::GreedyHillClimbing().

Here is the caller graph for this function:

disableMinEpsilonRate()

INLINE void gum::ApproximationScheme::disableMinEpsilonRate ( )

overridevirtualinherited

Disable stopping criterion on epsilon rate.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 95 of file approximationScheme_inl.h.

{ enabled_min_rate_eps_ = false; }

References enabled_min_rate_eps_.

Referenced by gum::learning::GreedyHillClimbing::GreedyHillClimbing(), gum::GibbsBNdistance< GUM_SCALAR >::computeKL_(), and gum::learning::EMApproximationScheme::setEpsilon().

Here is the caller graph for this function:

enableEpsilon()

INLINE void gum::ApproximationScheme::enableEpsilon ( )

overridevirtualinherited

Enable stopping criterion on epsilon.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 77 of file approximationScheme_inl.h.

{ enabled_eps_ = true; }

References enabled_eps_.

enableMaxIter()

INLINE void gum::ApproximationScheme::enableMaxIter ( )

overridevirtualinherited

Enable stopping criterion on max iterations.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 118 of file approximationScheme_inl.h.

{ enabled_max_iter_ = true; }

References enabled_max_iter_.

enableMaxTime()

INLINE void gum::ApproximationScheme::enableMaxTime ( )

overridevirtualinherited

Enable stopping criterion on timeout.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 142 of file approximationScheme_inl.h.

{ enabled_max_time_ = true; }

References enabled_max_time_.

enableMinEpsilonRate()

INLINE void gum::ApproximationScheme::enableMinEpsilonRate ( )

overridevirtualinherited

Enable stopping criterion on epsilon rate.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 98 of file approximationScheme_inl.h.

{ enabled_min_rate_eps_ = true; }

References enabled_min_rate_eps_.

Referenced by gum::learning::EMApproximationScheme::EMApproximationScheme(), and gum::GibbsBNdistance< GUM_SCALAR >::computeKL_().

Here is the caller graph for this function:

epsilon()

INLINE double gum::ApproximationScheme::epsilon ( ) const

overridevirtualinherited

Returns the value of epsilon.

Returns

Returns the value of epsilon.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 71 of file approximationScheme_inl.h.

{ return eps_; }

References eps_.

Referenced by gum::ImportanceSampling< GUM_SCALAR >::onContextualize_(), and gum::ImportanceSampling< GUM_SCALAR >::unsharpenBN_().

Here is the caller graph for this function:

findBestContributor_()

void gum::learning::SimpleMiic::findBestContributor_ ( NodeId x, NodeId y, const std::vector< NodeId > & ui, const MixedGraph & graph, CorrectedMutualInformation & mutualInformation, Heap< CondRanking, GreaterPairOn2nd > & rank )

protected

finds the best contributor node for a pair given a conditioning set

Parameters

x	first node
y	second node
ui	conditioning set
mutualInformation	A mutual information instance that will do the computations and has loaded the database.
graph	containing the assessed nodes
rank	the heap of ranks of the algorithm

Definition at line 418 of file SimpleMiic.cpp.

                                                                                       {
      double maxP = -1.0;
      NodeId maxZ = 0;
 
      // compute N
      // __N = I.N();
      const double Ixy_ui = mutualInformation.score(x, y, ui);
 
      for (const NodeId z: graph) {
        // if z!=x and z!=y and z not in ui
        if (z != x && z != y && std::find(ui.begin(), ui.end(), z) == ui.end()) {
          double Pnv;
          double Pb;
 
          // Computing Pnv
          const double Ixyz_ui    = mutualInformation.score(x, y, z, ui);
          double       calc_expo1 = -Ixyz_ui * M_LN2;
          // if exponential are too high or to low, crop them at _maxLog_
          if (calc_expo1 > _maxLog_) {
            Pnv = 0.0;
          } else if (calc_expo1 < -_maxLog_) {
            Pnv = 1.0;
          } else {
            Pnv = 1 / (1 + std::exp(calc_expo1));
          }
 
          // Computing Pb
          const double Ixz_ui = mutualInformation.score(x, z, ui);
          const double Iyz_ui = mutualInformation.score(y, z, ui);
 
          calc_expo1        = -(Ixz_ui - Ixy_ui) * M_LN2;
          double calc_expo2 = -(Iyz_ui - Ixy_ui) * M_LN2;
 
          // if exponential are too high or to low, crop them at  _maxLog_
          if (calc_expo1 > _maxLog_ || calc_expo2 > _maxLog_) {
            Pb = 0.0;
          } else if (calc_expo1 < -_maxLog_ && calc_expo2 < -_maxLog_) {
            Pb = 1.0;
          } else {
            double expo1, expo2;
            if (calc_expo1 < -_maxLog_) {
              expo1 = 0.0;
            } else {
              expo1 = std::exp(calc_expo1);
            }
            if (calc_expo2 < -_maxLog_) {
              expo2 = 0.0;
            } else {
              expo2 = std::exp(calc_expo2);
            }
            Pb = 1 / (1 + expo1 + expo2);
          }
 
          // Getting max(min(Pnv, pb))
          const double min_pnv_pb = std::min(Pnv, Pb);
          if (min_pnv_pb > maxP) {
            maxP = min_pnv_pb;
            maxZ = z;
          }
        }   // if z not in (x, y)
      }   // for z in graph.nodes
      // storing best z in rank_
      CondRanking final;
      auto        tup = new CondThreePoints{x, y, maxZ, ui};
      final.first     = tup;
      final.second    = maxP;
      rank.insert(final);
    }

References _maxLog_, gum::Heap< Val, Cmp >::insert(), M_LN2, and gum::learning::CorrectedMutualInformation::score().

Referenced by initiation_(), and iteration_().

Here is the call graph for this function:

Here is the caller graph for this function:

history()

INLINE const std::vector< double > & gum::ApproximationScheme::history ( ) const

overridevirtualinherited

Returns the scheme history.

Returns

Returns the scheme history.

Exceptions

OperationNotAllowed

Raised if the scheme did not performed or if verbosity is set to false.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 178 of file approximationScheme_inl.h.

                                                                       {
    if (stateApproximationScheme() == ApproximationSchemeSTATE::Undefined) {
      GUM_ERROR(OperationNotAllowed, "state of the approximation scheme is udefined")
    }
 
    if (!verbosity()) GUM_ERROR(OperationNotAllowed, "No history when verbosity=false")
 
    return history_;
  }

References GUM_ERROR, stateApproximationScheme(), and gum::IApproximationSchemeConfiguration::Undefined.

Here is the call graph for this function:

initApproximationScheme()

INLINE void gum::ApproximationScheme::initApproximationScheme ( )

inherited

Initialise the scheme.

Definition at line 189 of file approximationScheme_inl.h.

                                                           {
    current_state_   = ApproximationSchemeSTATE::Continue;
    current_step_    = 0;
    current_epsilon_ = current_rate_ = -1.0;
    history_.clear();
    timer_.reset();
  }

References ApproximationScheme(), gum::IApproximationSchemeConfiguration::Continue, current_epsilon_, current_rate_, current_state_, current_step_, and initApproximationScheme().

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::computeKL_(), initApproximationScheme(), gum::learning::GreedyHillClimbing::learnStructure(), gum::learning::LocalSearchWithTabuList::learnStructure(), gum::SamplingInference< GUM_SCALAR >::loopApproxInference_(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::makeInference(), and gum::SamplingInference< GUM_SCALAR >::onStateChanged_().

Here is the call graph for this function:

Here is the caller graph for this function:

initiation_()

void gum::learning::SimpleMiic::initiation_ ( CorrectedMutualInformation & mutualInformation, MixedGraph & graph, HashTable< std::pair< NodeId, NodeId >, std::vector< NodeId > > & sepSet, Heap< CondRanking, GreaterPairOn2nd > & rank )

protected

Initiation phase.

We go over all edges and test if the variables are marginally independent. If they are, the edge is deleted. If not, the best contributor is found.

Parameters

mutualInformation	A mutual information instance that will do the computations and has loaded the database.
graph	the MixedGraph we start from for the learning
sepSet	the separation set for independent couples, here set to {}
rank	the heap of ranks of the algorithm

Definition at line 128 of file SimpleMiic.cpp.

                                                                               {
      NodeId  x, y;
      EdgeSet edges      = graph.edges();
      Size    steps_init = edges.size();
 
      for (const Edge& edge: edges) {
        x          = edge.first();
        y          = edge.second();
        double Ixy = mutualInformation.score(x, y);
 
        if (Ixy <= 0) {   //< K
          graph.eraseEdge(edge);
          sepSet.insert(std::make_pair(x, y), _emptySet_);
        } else {
          findBestContributor_(x, y, _emptySet_, graph, mutualInformation, rank);
        }
 
        ++current_step_;
        if (onProgress.hasListener()) {
          GUM_EMIT3(onProgress, (current_step_ * 33) / steps_init, 0., timer_.step());
        }
      }
    }

References _emptySet_, gum::ApproximationScheme::current_step_, gum::EdgeGraphPart::edges(), gum::EdgeGraphPart::eraseEdge(), findBestContributor_(), GUM_EMIT3, gum::IApproximationSchemeConfiguration::onProgress, gum::learning::CorrectedMutualInformation::score(), gum::Set< Key >::size(), and gum::ApproximationScheme::timer_.

Referenced by learnMixedStructure().

Here is the call graph for this function:

Here is the caller graph for this function:

isEnabledEpsilon()

INLINE bool gum::ApproximationScheme::isEnabledEpsilon ( ) const

overridevirtualinherited

Returns true if stopping criterion on epsilon is enabled, false otherwise.

Returns

Returns true if stopping criterion on epsilon is enabled, false otherwise.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 81 of file approximationScheme_inl.h.

{ return enabled_eps_; }

References enabled_eps_.

isEnabledMaxIter()

INLINE bool gum::ApproximationScheme::isEnabledMaxIter ( ) const

overridevirtualinherited

Returns true if stopping criterion on max iterations is enabled, false otherwise.

Returns

Returns true if stopping criterion on max iterations is enabled, false otherwise.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 122 of file approximationScheme_inl.h.

{ return enabled_max_iter_; }

References enabled_max_iter_.

isEnabledMaxTime()

INLINE bool gum::ApproximationScheme::isEnabledMaxTime ( ) const

overridevirtualinherited

Returns true if stopping criterion on timeout is enabled, false otherwise.

Returns

Returns true if stopping criterion on timeout is enabled, false otherwise.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 146 of file approximationScheme_inl.h.

{ return enabled_max_time_; }

References enabled_max_time_.

isEnabledMinEpsilonRate()

INLINE bool gum::ApproximationScheme::isEnabledMinEpsilonRate ( ) const

overridevirtualinherited

Returns true if stopping criterion on epsilon rate is enabled, false otherwise.

Returns

Returns true if stopping criterion on epsilon rate is enabled, false otherwise.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 102 of file approximationScheme_inl.h.

{ return enabled_min_rate_eps_; }

References enabled_min_rate_eps_.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::computeKL_().

Here is the caller graph for this function:

isForbidenArc_()

bool gum::learning::SimpleMiic::isForbidenArc_ ( NodeId x, NodeId y ) const

protected

Definition at line 1065 of file SimpleMiic.cpp.

                                                            {
      return (_initialMarks_.exists({x, y}) && _initialMarks_[{x, y}] == '-');
    }

References _initialMarks_.

Referenced by learnPDAG(), and learnStructure().

Here is the caller graph for this function:

isOrientable_()

bool gum::learning::SimpleMiic::isOrientable_ ( const MixedGraph & graph, NodeId xi, NodeId xj ) const

protected

Definition at line 713 of file SimpleMiic.cpp.

                                                                                      {
      // no cycle
      if (_existsDirectedPath_(graph, xj, xi)) {
        // GUM_TRACE("cycle(" << xi << "-" << xj << ")")
        return false;
      }
 
      // R1
      if (!(graph.parents(xi) - graph.boundary(xj)).empty()) {
        // GUM_TRACE("R1(" << xi << "-" << xj << ")")
        return true;
      }
 
      // R2
      if (_existsDirectedPath_(graph, xi, xj)) {
        // GUM_TRACE("R2(" << xi << "-" << xj << ")")
        return true;
      }
 
      // R3
      int nbr = 0;
      for (const auto p: graph.parents(xj)) {
        if (!graph.mixedOrientedPath(xi, p).empty()) {
          nbr += 1;
          if (nbr == 2) {
            // GUM_TRACE("R3(" << xi << "-" << xj << ")")
            return true;
          }
        }
      }
      return false;
    }

References _existsDirectedPath_(), gum::MixedGraph::boundary(), gum::MixedGraph::mixedOrientedPath(), and gum::ArcGraphPart::parents().

Referenced by propagatesRemainingOrientableEdges_().

Here is the call graph for this function:

Here is the caller graph for this function:

iteration_()

void gum::learning::SimpleMiic::iteration_ ( CorrectedMutualInformation & mutualInformation, MixedGraph & graph, HashTable< std::pair< NodeId, NodeId >, std::vector< NodeId > > & sepSet, Heap< CondRanking, GreaterPairOn2nd > & rank )

protected

Iteration phase.

As long as we find important nodes for edges, we go over them to see if we can assess the conditional independence of the variables.

Parameters

mutualInformation	A mutual information instance that will do the computations and has loaded the database.
graph	the MixedGraph returned from the previous phase
sepSet	the separation set for independent couples, built during the iterations of the phase
rank	the heap of ranks of the algorithm

Definition at line 162 of file SimpleMiic.cpp.

                                                                               {
      // if no triples to further examine pass
      CondRanking best;
 
      Size steps_init = current_step_;
      Size steps_iter = rank.size();
 
      try {
        while (rank.top().second > 0.5) {
          best = rank.pop();
 
          const NodeId          x  = std::get< 0 >(*(best.first));
          const NodeId          y  = std::get< 1 >(*(best.first));
          const NodeId          z  = std::get< 2 >(*(best.first));
          std::vector< NodeId > ui = std::move(std::get< 3 >(*(best.first)));
 
          ui.push_back(z);
          const double i_xy_ui = mutualInformation.score(x, y, ui);
          if (i_xy_ui < 0) {
            graph.eraseEdge(Edge(x, y));
            sepSet.insert(std::make_pair(x, y), std::move(ui));
          } else {
            findBestContributor_(x, y, ui, graph, mutualInformation, rank);
          }
 
          delete best.first;
 
          ++current_step_;
          if (onProgress.hasListener()) {
            GUM_EMIT3(onProgress,
                      (current_step_ * 66) / (steps_init + steps_iter),
                      0.,
                      timer_.step());
          }
        }
      } catch (...) {}   // here, rank is empty
      current_step_ = steps_init + steps_iter;
      if (onProgress.hasListener()) { GUM_EMIT3(onProgress, 66, 0., timer_.step()); }
      current_step_ = steps_init + steps_iter;
    }

References gum::ApproximationScheme::current_step_, gum::EdgeGraphPart::eraseEdge(), findBestContributor_(), GUM_EMIT3, gum::IApproximationSchemeConfiguration::onProgress, gum::Heap< Val, Cmp >::pop(), gum::learning::CorrectedMutualInformation::score(), gum::Heap< Val, Cmp >::size(), gum::ApproximationScheme::timer_, and gum::Heap< Val, Cmp >::top().

Referenced by learnMixedStructure().

Here is the call graph for this function:

Here is the caller graph for this function:

latentVariables()

const std::vector< Arc > gum::learning::SimpleMiic::latentVariables

(

)

const

get the list of arcs hiding latent variables

Definition at line 820 of file SimpleMiic.cpp.

                                                             {
      GUM_CHECKPOINT
      return _latentCouples_;
    }

References _latentCouples_.

learnBN()

template<typename GUM_SCALAR, typename GRAPH_CHANGES_SELECTOR, typename PARAM_ESTIMATOR>

BayesNet< GUM_SCALAR > gum::learning::SimpleMiic::learnBN	(	GRAPH_CHANGES_SELECTOR &	selector,
		PARAM_ESTIMATOR &	estimator,
		DAG	initial_dag = DAG() )

learns the structure and the parameters of a BN

Parameters

selector	A selector class that computes the best changes that can be applied and that enables the user to get them very easily. Typically, the selector is a GraphChangesSelector4DiGraph<SCORE, STRUCT_CONSTRAINT, GRAPH_CHANGES_GENERATOR>.
estimator	A estimator.
names	The variables names.
modal	the domain sizes of the random variables observed in the database
translator	The cell translator to use.
initial_dag	the DAG we start from for our learning

Definition at line 827 of file SimpleMiic.cpp.

                                                                                    {
      return DAG2BNLearner::createBN< GUM_SCALAR >(estimator,
                                                   learnStructure(selector, initial_dag));
    }

References gum::learning::DAG2BNLearner::createBN(), and learnStructure().

Here is the call graph for this function:

learnMixedStructure()

MixedGraph gum::learning::SimpleMiic::learnMixedStructure	(	CorrectedMutualInformation &	mutualInformation,
		MixedGraph	graph )

learns the structure of an Essential Graph

learns the structure of a MixedGraph

Parameters

mutualInformation	A mutual information instance that will do the computations and has loaded the database.
graph	the MixedGraph we start from for the learning

Definition at line 98 of file SimpleMiic.cpp.

                                                                                  {
      timer_.reset();
      current_step_ = 0;
 
      // clear the vector of latent arcs to be sure
      _latentCouples_.clear();

      Heap< CondRanking, GreaterPairOn2nd > rank;

      HashTable< std::pair< NodeId, NodeId >, std::vector< NodeId > > sep_set;
 
      initiation_(mutualInformation, graph, sep_set, rank);
 
      iteration_(mutualInformation, graph, sep_set, rank);
 
      orientationMiic_(mutualInformation, graph, sep_set);
 
      return graph;
    }

References _latentCouples_, gum::ApproximationScheme::current_step_, initiation_(), iteration_(), orientationMiic_(), and gum::ApproximationScheme::timer_.

Referenced by learnPDAG(), and learnStructure().

Here is the call graph for this function:

Here is the caller graph for this function:

learnPDAG()

MixedGraph gum::learning::SimpleMiic::learnPDAG	(	CorrectedMutualInformation &	mutualInformation,
		MixedGraph	graph )

learns the structure of an Essential Graph

learns the structure of a PDAG from à MixedGraph. It returns a MixedGraph with the constraints of a PDAG, to avoid changing the dependencies in the other methods of the MIIC class.

Parameters

mutualInformation	A mutual information instance that will do the computations and has loaded the database.
graph	the MixedGraph we start from for the learning

Definition at line 614 of file SimpleMiic.cpp.

                                                                                           {
      MixedGraph essentialGraph = learnMixedStructure(I, initialGraph);
 
      // orientate remaining edges
      const Sequence< NodeId > order = essentialGraph.topologicalOrder();
 
      // first, forbidden arcs force arc in the other direction
      for (NodeId x: order) {
        const auto nei_x = essentialGraph.neighbours(x);
        for (NodeId y: nei_x)
          if (isForbidenArc_(x, y)) {
            essentialGraph.eraseEdge(Edge(x, y));
            if (isForbidenArc_(y, x)) {
              // GUM_TRACE("Neither arc allowed for edge (" << x << "," << y << ")")
            } else {
              // GUM_TRACE("Forced orientation : " << y << "->" << x)
              essentialGraph.addArc(y, x);
            }
          } else if (isForbidenArc_(y, x)) {
            essentialGraph.eraseEdge(Edge(x, y));
            // GUM_TRACE("Forced orientation : " << x << "->" << y)
            essentialGraph.addArc(x, y);
          }
      }
 
      // then propagates existing orientations thanks to Meek rules
      bool newOrientation = true;
      while (newOrientation) {
        newOrientation = false;
        for (NodeId x: order) {
          if (!essentialGraph.parents(x).empty()) {
            newOrientation |= propagatesRemainingOrientableEdges_(essentialGraph, x);
          }
        }
      }
      return essentialGraph;
    }

References gum::DiGraph::addArc(), gum::Set< Key >::empty(), gum::EdgeGraphPart::eraseEdge(), isForbidenArc_(), learnMixedStructure(), gum::EdgeGraphPart::neighbours(), gum::ArcGraphPart::parents(), propagatesRemainingOrientableEdges_(), and gum::DiGraph::topologicalOrder().

Here is the call graph for this function:

learnStructure()

DAG gum::learning::SimpleMiic::learnStructure	(	CorrectedMutualInformation &	I,
		MixedGraph	graph )

learns the structure of a Bayesian network, i.e. a DAG, by first learning an Essential graph and then directing the remaining edges.

learns the structure of an Bayesian network, ie a DAG, from an Essential graph.

Parameters

I	A mutual information instance that will do the computations and has loaded the database
graph	the MixedGraph we start from for the learning

Definition at line 654 of file SimpleMiic.cpp.

                                                                                         {
      MixedGraph essentialGraph = learnMixedStructure(I, initialGraph);
      // orientate remaining edges
 
      const Sequence< NodeId > order = essentialGraph.topologicalOrder();
 
      // first, forbidden arcs force arc in the other direction
      for (NodeId x: order) {
        const auto nei_x = essentialGraph.neighbours(x);
        for (NodeId y: nei_x)
          if (isForbidenArc_(x, y)) {
            essentialGraph.eraseEdge(Edge(x, y));
            if (isForbidenArc_(y, x)) {
              // GUM_TRACE("Neither arc allowed for edge (" << x << "," << y << ")")
            } else {
              // GUM_TRACE("Forced orientation : " << y << "->" << x)
              essentialGraph.addArc(y, x);
            }
          } else if (isForbidenArc_(y, x)) {
            essentialGraph.eraseEdge(Edge(x, y));
            // GUM_TRACE("Forced orientation : " << x << "->" << y)
            essentialGraph.addArc(x, y);
          }
      }
      // GUM_TRACE(essentialGraph.toDot());
 
      // first, propagate existing orientations
      bool newOrientation = true;
      while (newOrientation) {
        newOrientation = false;
        for (NodeId x: order) {
          if (!essentialGraph.parents(x).empty()) {
            newOrientation |= propagatesRemainingOrientableEdges_(essentialGraph, x);
          }
        }
      }
      // GUM_TRACE(essentialGraph.toDot());
      propagatesOrientationInChainOfRemainingEdges_(essentialGraph);
      // GUM_TRACE(essentialGraph.toDot());
 
      // then decide the orientation for double arcs
      for (NodeId x: order)
        for (NodeId y: essentialGraph.parents(x))
          if (essentialGraph.parents(y).contains(x)) {
            // GUM_TRACE(" + Resolving double arcs (poorly)")
            essentialGraph.eraseArc(Arc(y, x));
          }
 
      DAG dag;
      for (auto node: essentialGraph) {
        dag.addNodeWithId(node);
      }
      for (const Arc& arc: essentialGraph.arcs()) {
        dag.addArc(arc.tail(), arc.head());
      }
 
      return dag;
    }

References gum::DAG::addArc(), gum::DiGraph::addArc(), gum::NodeGraphPart::addNodeWithId(), gum::ArcGraphPart::arcs(), gum::Set< Key >::contains(), gum::Set< Key >::empty(), gum::ArcGraphPart::eraseArc(), gum::EdgeGraphPart::eraseEdge(), isForbidenArc_(), learnMixedStructure(), gum::EdgeGraphPart::neighbours(), gum::ArcGraphPart::parents(), propagatesOrientationInChainOfRemainingEdges_(), propagatesRemainingOrientableEdges_(), and gum::DiGraph::topologicalOrder().

Referenced by learnBN().

Here is the call graph for this function:

Here is the caller graph for this function:

maxIter()

INLINE Size gum::ApproximationScheme::maxIter ( ) const

overridevirtualinherited

Returns the criterion on number of iterations.

Returns

Returns the criterion on number of iterations.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 112 of file approximationScheme_inl.h.

{ return max_iter_; }

References max_iter_.

maxTime()

INLINE double gum::ApproximationScheme::maxTime ( ) const

overridevirtualinherited

Returns the timeout (in seconds).

Returns

Returns the timeout (in seconds).

Implements gum::IApproximationSchemeConfiguration.

Definition at line 133 of file approximationScheme_inl.h.

{ return max_time_; }

References max_time_.

messageApproximationScheme()

INLINE std::string gum::IApproximationSchemeConfiguration::messageApproximationScheme ( ) const

inherited

Returns the approximation scheme message.

Returns

Returns the approximation scheme message.

Definition at line 59 of file IApproximationSchemeConfiguration_inl.h.

                                                                                {
    std::stringstream s;
 
    switch (stateApproximationScheme()) {
      case ApproximationSchemeSTATE::Continue : s << "in progress"; break;
 
      case ApproximationSchemeSTATE::Epsilon : s << "stopped with epsilon=" << epsilon(); break;
 
      case ApproximationSchemeSTATE::Rate : s << "stopped with rate=" << minEpsilonRate(); break;
 
      case ApproximationSchemeSTATE::Limit : s << "stopped with max iteration=" << maxIter(); break;
 
      case ApproximationSchemeSTATE::TimeLimit : s << "stopped with timeout=" << maxTime(); break;
 
      case ApproximationSchemeSTATE::Stopped : s << "stopped on request"; break;
 
      case ApproximationSchemeSTATE::Undefined : s << "undefined state"; break;
    };
 
    return s.str();
  }

References Continue, Epsilon, epsilon(), Limit, maxIter(), maxTime(), minEpsilonRate(), Rate, stateApproximationScheme(), Stopped, TimeLimit, and Undefined.

Referenced by gum::credal::InferenceEngine< GUM_SCALAR >::getApproximationSchemeMsg(), and gum::credal::MultipleInferenceEngine< GUM_SCALAR, LazyPropagation< GUM_SCALAR > >::stateApproximationScheme().

Here is the call graph for this function:

Here is the caller graph for this function:

minEpsilonRate()

INLINE double gum::ApproximationScheme::minEpsilonRate ( ) const

overridevirtualinherited

Returns the value of the minimal epsilon rate.

Returns

Returns the value of the minimal epsilon rate.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 92 of file approximationScheme_inl.h.

{ return min_rate_eps_; }

References min_rate_eps_.

nbrIterations()

INLINE Size gum::ApproximationScheme::nbrIterations ( ) const

overridevirtualinherited

Returns the number of iterations.

Returns

Returns the number of iterations.

Exceptions

OperationNotAllowed

Raised if the scheme did not perform.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 169 of file approximationScheme_inl.h.

                                                       {
    if (stateApproximationScheme() == ApproximationSchemeSTATE::Undefined) {
      GUM_ERROR(OperationNotAllowed, "state of the approximation scheme is undefined")
    }
 
    return current_step_;
  }

References current_step_, GUM_ERROR, stateApproximationScheme(), and gum::IApproximationSchemeConfiguration::Undefined.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::computeKL_().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=() [1/2]

SimpleMiic & gum::learning::SimpleMiic::operator=

(

const SimpleMiic &

from

)

copy operator

Definition at line 86 of file SimpleMiic.cpp.

                                                          {
      ApproximationScheme::operator=(from);
      return *this;
    }

References SimpleMiic().

Here is the call graph for this function:

operator=() [2/2]

SimpleMiic & gum::learning::SimpleMiic::operator=

(

SimpleMiic &&

from

)

move operator

Definition at line 92 of file SimpleMiic.cpp.

                                                     {
      ApproximationScheme::operator=(std::move(from));
      return *this;
    }

References SimpleMiic().

Here is the call graph for this function:

orientationLatents_()

void gum::learning::SimpleMiic::orientationLatents_ ( CorrectedMutualInformation & mutualInformation, MixedGraph & graph, const HashTable< std::pair< NodeId, NodeId >, std::vector< NodeId > > & sepSet )

protected

variant trying to propagate both orientations in a bidirected arc

Definition at line 214 of file SimpleMiic.cpp.

                                                                                   {
      std::vector< Ranking > triples      = unshieldedTriples_(graph, mutualInformation, sepSet);
      Size                   steps_orient = triples.size();
      Size                   past_steps   = current_step_;
 
      NodeId i = 0;
      // list of elements that we shouldnt read again, ie elements that are
      // eligible to
      // rule 0 after the first time they are tested, and elements on which rule 1
      // has been applied
      while (i < triples.size()) {
        // if i not in do_not_reread
        Ranking triple = triples[i];
        NodeId  x, y, z;
        x = std::get< 0 >(*triple.first);
        y = std::get< 1 >(*triple.first);
        z = std::get< 2 >(*triple.first);
 
        std::vector< NodeId >       ui;
        std::pair< NodeId, NodeId > key     = {x, y};
        std::pair< NodeId, NodeId > rev_key = {y, x};
        if (sepSet.exists(key)) {
          ui = sepSet[key];
        } else if (sepSet.exists(rev_key)) {
          ui = sepSet[rev_key];
        }
        double Ixyz_ui = triple.second;
        // try Rule 0
        if (Ixyz_ui < 0) {
          // if ( z not in Sep[x,y])
          if (std::find(ui.begin(), ui.end(), z) == ui.end()) {
            // if what we want to add already exists : pass
            if ((graph.existsArc(x, z) || graph.existsArc(z, x))
                && (graph.existsArc(y, z) || graph.existsArc(z, y))) {
              ++i;
            } else {
              i = 0;
              graph.eraseEdge(Edge(x, z));
              graph.eraseEdge(Edge(y, z));
              // checking for cycles
              if (graph.existsArc(z, x)) {
                graph.eraseArc(Arc(z, x));
                try {
                  std::vector< NodeId > path = graph.directedPath(z, x);
                  // if we find a cycle, we force the competing edge
                  _latentCouples_.emplace_back(z, x);
                } catch (const gum::NotFound&) { graph.addArc(x, z); }
                graph.addArc(z, x);
              } else {
                try {
                  std::vector< NodeId > path = graph.directedPath(z, x);
                  // if we find a cycle, we force the competing edge
                  graph.addArc(z, x);
                  _latentCouples_.emplace_back(z, x);
                } catch (const gum::NotFound&) { graph.addArc(x, z); }
              }
              if (graph.existsArc(z, y)) {
                graph.eraseArc(Arc(z, y));
                try {
                  std::vector< NodeId > path = graph.directedPath(z, y);
                  // if we find a cycle, we force the competing edge
                  _latentCouples_.emplace_back(z, y);
                } catch (const gum::NotFound&) { graph.addArc(y, z); }
                graph.addArc(z, y);
              } else {
                try {
                  std::vector< NodeId > path = graph.directedPath(z, y);
                  // if we find a cycle, we force the competing edge
                  graph.addArc(z, y);
                  _latentCouples_.emplace_back(z, y);
 
                } catch (const gum::NotFound&) { graph.addArc(y, z); }
              }
              if (graph.existsArc(z, x) && _isNotLatentCouple_(z, x)) {
                _latentCouples_.emplace_back(z, x);
              }
              if (graph.existsArc(z, y) && _isNotLatentCouple_(z, y)) {
                _latentCouples_.emplace_back(z, y);
              }
            }
          } else {
            ++i;
          }
        } else {   // try Rule 1
          bool reset{false};
          if (graph.existsArc(x, z) && !graph.existsArc(z, y) && !graph.existsArc(y, z)) {
            reset = true;
            graph.eraseEdge(Edge(z, y));
            try {
              std::vector< NodeId > path = graph.directedPath(y, z);
              // if we find a cycle, we force the competing edge
              graph.addArc(y, z);
              _latentCouples_.emplace_back(y, z);
            } catch (const gum::NotFound&) { graph.addArc(z, y); }
          }
          if (graph.existsArc(y, z) && !graph.existsArc(z, x) && !graph.existsArc(x, z)) {
            reset = true;
            graph.eraseEdge(Edge(z, x));
            try {
              std::vector< NodeId > path = graph.directedPath(x, z);
              // if we find a cycle, we force the competing edge
              graph.addArc(x, z);
              _latentCouples_.emplace_back(x, z);
            } catch (const gum::NotFound&) { graph.addArc(z, x); }
          }
 
          if (reset) {
            i = 0;
          } else {
            ++i;
          }
        }   // if rule 0 or rule 1
        if (onProgress.hasListener()) {
          GUM_EMIT3(onProgress,
                    ((current_step_ + i) * 100) / (past_steps + steps_orient),
                    0.,
                    timer_.step());
        }
      }   // while
 
      // erasing the the double headed arcs
      for (const Arc& arc: _latentCouples_) {
        graph.eraseArc(Arc(arc.head(), arc.tail()));
      }
    }

References _isNotLatentCouple_(), _latentCouples_, gum::DiGraph::addArc(), gum::ApproximationScheme::current_step_, gum::ArcGraphPart::directedPath(), gum::ArcGraphPart::eraseArc(), gum::EdgeGraphPart::eraseEdge(), gum::ArcGraphPart::existsArc(), GUM_EMIT3, gum::IApproximationSchemeConfiguration::onProgress, gum::ApproximationScheme::timer_, and unshieldedTriples_().

Here is the call graph for this function:

orientationMiic_()

void gum::learning::SimpleMiic::orientationMiic_ ( CorrectedMutualInformation & mutualInformation, MixedGraph & graph, const HashTable< std::pair< NodeId, NodeId >, std::vector< NodeId > > & sepSet )

protected

Orientation phase from the MIIC algorithm, returns a mixed graph that may contain circles.

Orientation protocol of MIIC.

Parameters

mutualInformation	A mutual information instance that will do the computations and has loaded the database.
graph	the MixedGraph returned from the previous phase
sepSet	the separation set for independent couples, built during the previous phase

Definition at line 344 of file SimpleMiic.cpp.

                                                                                   {
      // structure to store the orientations marks -, o, or >,
      // Considers the head of the arc/edge first node -* second node
      HashTable< std::pair< NodeId, NodeId >, char > marks = _initialMarks_;
 
      // marks always correspond to the head of the arc/edge. - is for a forbidden
      // arc, > for a mandatory arc
      // we start by adding the mandatory arcs
      for (auto iter = marks.begin(); iter != marks.end(); ++iter) {
        if (graph.existsEdge(iter.key().first, iter.key().second) && iter.val() == '>') {
          graph.eraseEdge(Edge(iter.key().first, iter.key().second));
          graph.addArc(iter.key().first, iter.key().second);
        }
      }
 
      std::vector< ProbabilisticRanking > proba_triples
          = unshieldedTriplesMiic_(graph, mutualInformation, sepSet, marks);
 
      const Size steps_orient = proba_triples.size();
      Size       past_steps   = current_step_;
 
      ProbabilisticRanking best;
      if (steps_orient > 0) { best = proba_triples[0]; }
 
      while (!proba_triples.empty() && std::max(std::get< 2 >(best), std::get< 3 >(best)) > 0.5) {
        const NodeId x = std::get< 0 >(*std::get< 0 >(best));
        const NodeId y = std::get< 1 >(*std::get< 0 >(best));
        const NodeId z = std::get< 2 >(*std::get< 0 >(best));
 
        const double i3 = std::get< 1 >(best);
 
        const double p1 = std::get< 2 >(best);
        const double p2 = std::get< 3 >(best);
        if (i3 <= 0) {
          _orientingVstructureMiic_(graph, marks, x, y, z, p1, p2);
        } else {
          _propagatingOrientationMiic_(graph, marks, x, y, z, p1, p2);
        }
 
        delete std::get< 0 >(best);
        proba_triples.erase(proba_triples.begin());
        // actualisation of the list of triples
        proba_triples = updateProbaTriples_(graph, proba_triples);
 
        if (!proba_triples.empty()) best = proba_triples[0];
 
        ++current_step_;
        if (onProgress.hasListener()) {
          GUM_EMIT3(onProgress,
                    (current_step_ * 100) / (steps_orient + past_steps),
                    0.,
                    timer_.step());
        }
      }   // while
 
      // erasing the double headed arcs
      GUM_TRACE(_latentCouples_)
      for (auto iter = _latentCouples_.rbegin(); iter != _latentCouples_.rend(); ++iter) {
        graph.eraseArc(Arc(iter->head(), iter->tail()));
        if (_existsDirectedPath_(graph, iter->head(), iter->tail())) {
          // if we find a cycle, we force the competing edge
          graph.addArc(iter->head(), iter->tail());
          graph.eraseArc(Arc(iter->tail(), iter->head()));
          *iter = Arc(iter->head(), iter->tail());
        }
      }
 
      if (onProgress.hasListener()) { GUM_EMIT3(onProgress, 100, 0., timer_.step()); }
    }

References _existsDirectedPath_(), _initialMarks_, _latentCouples_, _orientingVstructureMiic_(), _propagatingOrientationMiic_(), gum::DiGraph::addArc(), gum::HashTable< Key, Val >::begin(), gum::ApproximationScheme::current_step_, gum::HashTable< Key, Val >::end(), gum::ArcGraphPart::eraseArc(), gum::EdgeGraphPart::eraseEdge(), gum::EdgeGraphPart::existsEdge(), GUM_EMIT3, gum::IApproximationSchemeConfiguration::onProgress, gum::ApproximationScheme::timer_, unshieldedTriplesMiic_(), and updateProbaTriples_().

Referenced by learnMixedStructure().

Here is the call graph for this function:

Here is the caller graph for this function:

periodSize()

INLINE Size gum::ApproximationScheme::periodSize ( ) const

overridevirtualinherited

Returns the period size.

Returns

Returns the period size.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 155 of file approximationScheme_inl.h.

{ return period_size_; }

References period_size_.

propagatesOrientationInChainOfRemainingEdges_()

void gum::learning::SimpleMiic::propagatesOrientationInChainOfRemainingEdges_ ( MixedGraph & graph )

protected

heuristic for remaining edges when everything else has been tried

Definition at line 746 of file SimpleMiic.cpp.

                                                                                             {
      // then decide the orientation for remaining edges
      while (!essentialGraph.edges().empty()) {
        const auto& edge               = *(essentialGraph.edges().begin());
        NodeId      root               = edge.first();
        Size        size_children_root = essentialGraph.children(root).size();
        NodeSet     visited;
        NodeSet     stack{root};
        // check the best root for the set of neighbours
        while (!stack.empty()) {
          NodeId next = *(stack.begin());
          stack.erase(next);
          if (visited.contains(next)) continue;
          if (essentialGraph.children(next).size() > size_children_root) {
            size_children_root = essentialGraph.children(next).size();
            root               = next;
          }
          for (const auto n: essentialGraph.neighbours(next))
            if (!stack.contains(n) && !visited.contains(n)) stack.insert(n);
          visited.insert(next);
        }
        // orientation now
        visited.clear();
        stack.clear();
        stack.insert(root);
        while (!stack.empty()) {
          NodeId next = *(stack.begin());
          stack.erase(next);
          if (visited.contains(next)) continue;
          const auto nei = essentialGraph.neighbours(next);
          for (const auto n: nei) {
            if (!stack.contains(n) && !visited.contains(n)) stack.insert(n);
            // GUM_TRACE(" + amap reasonably orientation for " << n << "->" << next);
            if (propagatesRemainingOrientableEdges_(essentialGraph, next)) continue;
            else essentialGraph.eraseEdge(Edge(n, next));
            essentialGraph.addArc(n, next);
          }
          visited.insert(next);
        }
      }
    }

References gum::DiGraph::addArc(), gum::Set< Key >::begin(), gum::ArcGraphPart::children(), gum::Set< Key >::clear(), gum::Set< Key >::contains(), gum::EdgeGraphPart::edges(), gum::Set< Key >::empty(), gum::Set< Key >::erase(), gum::EdgeGraphPart::eraseEdge(), gum::Set< Key >::insert(), gum::EdgeGraphPart::neighbours(), propagatesRemainingOrientableEdges_(), and gum::Set< Key >::size().

Referenced by learnStructure().

Here is the call graph for this function:

Here is the caller graph for this function:

propagatesRemainingOrientableEdges_()

bool gum::learning::SimpleMiic::propagatesRemainingOrientableEdges_ ( MixedGraph & graph, NodeId xj )

protected

Propagates the orientation from a node to its neighbours.

Definition at line 789 of file SimpleMiic.cpp.

                                                                                     {
      bool       res        = false;
      const auto neighbours = graph.neighbours(xj);
      for (auto& xi: neighbours) {
        bool i_j = isOrientable_(graph, xi, xj);
        bool j_i = isOrientable_(graph, xj, xi);
        if (i_j || j_i) {
          // GUM_TRACE(" + Removing edge (" << xi << "," << xj << ")")
          graph.eraseEdge(Edge(xi, xj));
          res = true;
        }
        if (i_j) {
          // GUM_TRACE(" + add arc (" << xi << "," << xj << ")")
          graph.addArc(xi, xj);
          propagatesRemainingOrientableEdges_(graph, xj);
        }
        if (j_i) {
          // GUM_TRACE(" + add arc (" << xi << "," << xj << ")")
          graph.addArc(xj, xi);
          propagatesRemainingOrientableEdges_(graph, xi);
        }
        if (i_j && j_i) {
          GUM_TRACE(" + add arc (" << xi << "," << xj << ")")
          _latentCouples_.emplace_back(xi, xj);
        }
      }
 
      return res;
    }

References _latentCouples_, gum::DiGraph::addArc(), gum::EdgeGraphPart::eraseEdge(), isOrientable_(), gum::EdgeGraphPart::neighbours(), and propagatesRemainingOrientableEdges_().

Referenced by learnPDAG(), learnStructure(), propagatesOrientationInChainOfRemainingEdges_(), and propagatesRemainingOrientableEdges_().

Here is the call graph for this function:

Here is the caller graph for this function:

remainingBurnIn()

INLINE Size gum::ApproximationScheme::remainingBurnIn ( ) const

inherited

Returns the remaining burn in.

Returns

Returns the remaining burn in.

Definition at line 212 of file approximationScheme_inl.h.

                                                         {
    if (burn_in_ > current_step_) {
      return burn_in_ - current_step_;
    } else {
      return 0;
    }
  }

References burn_in_, and current_step_.

setEpsilon()

INLINE void gum::ApproximationScheme::setEpsilon ( double eps )

overridevirtualinherited

Given that we approximate f(t), stopping criterion on |f(t+1)-f(t)|.

If the criterion was disabled it will be enabled.

Parameters

eps	The new epsilon value.

Exceptions

OutOfBounds

Raised if eps < 0.

Implements gum::IApproximationSchemeConfiguration.

Reimplemented in gum::learning::EMApproximationScheme.

Definition at line 63 of file approximationScheme_inl.h.

                                                        {
    if (eps < 0.) { GUM_ERROR(OutOfBounds, "eps should be >=0") }
 
    eps_         = eps;
    enabled_eps_ = true;
  }

References enabled_eps_, eps_, and GUM_ERROR.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::GibbsSampling< GUM_SCALAR >::GibbsSampling(), gum::learning::GreedyHillClimbing::GreedyHillClimbing(), gum::SamplingInference< GUM_SCALAR >::SamplingInference(), and gum::learning::EMApproximationScheme::setEpsilon().

Here is the caller graph for this function:

setMaxIter()

INLINE void gum::ApproximationScheme::setMaxIter ( Size max )

overridevirtualinherited

Stopping criterion on number of iterations.

If the criterion was disabled it will be enabled.

Parameters

max	The maximum number of iterations.

Exceptions

OutOfBounds

Raised if max <= 1.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 105 of file approximationScheme_inl.h.

                                                      {
    if (max < 1) { GUM_ERROR(OutOfBounds, "max should be >=1") }
    max_iter_         = max;
    enabled_max_iter_ = true;
  }

References enabled_max_iter_, GUM_ERROR, and max_iter_.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), and gum::SamplingInference< GUM_SCALAR >::SamplingInference().

Here is the caller graph for this function:

setMaxTime()

INLINE void gum::ApproximationScheme::setMaxTime ( double timeout )

overridevirtualinherited

Stopping criterion on timeout.

If the criterion was disabled it will be enabled.

Parameters

timeout

The timeout value in seconds.

Exceptions

OutOfBounds

Raised if timeout <= 0.0.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 126 of file approximationScheme_inl.h.

                                                            {
    if (timeout <= 0.) { GUM_ERROR(OutOfBounds, "timeout should be >0.") }
    max_time_         = timeout;
    enabled_max_time_ = true;
  }

References enabled_max_time_, GUM_ERROR, and max_time_.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), and gum::SamplingInference< GUM_SCALAR >::SamplingInference().

Here is the caller graph for this function:

setMinEpsilonRate()

INLINE void gum::ApproximationScheme::setMinEpsilonRate ( double rate )

overridevirtualinherited

Given that we approximate f(t), stopping criterion on d/dt(|f(t+1)-f(t)|).

If the criterion was disabled it will be enabled

Parameters

rate	The minimal epsilon rate.

Exceptions

OutOfBounds

if rate<0

Implements gum::IApproximationSchemeConfiguration.

Reimplemented in gum::learning::EMApproximationScheme.

Definition at line 84 of file approximationScheme_inl.h.

                                                                {
    if (rate < 0) { GUM_ERROR(OutOfBounds, "rate should be >=0") }
 
    min_rate_eps_         = rate;
    enabled_min_rate_eps_ = true;
  }

References enabled_min_rate_eps_, GUM_ERROR, and min_rate_eps_.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::GibbsSampling< GUM_SCALAR >::GibbsSampling(), gum::SamplingInference< GUM_SCALAR >::SamplingInference(), and gum::learning::EMApproximationScheme::setMinEpsilonRate().

Here is the caller graph for this function:

setPeriodSize()

INLINE void gum::ApproximationScheme::setPeriodSize ( Size p )

overridevirtualinherited

How many samples between two stopping is enable.

Parameters

p	The new period value.

Exceptions

OutOfBounds

Raised if p < 1.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 149 of file approximationScheme_inl.h.

                                                       {
    if (p < 1) { GUM_ERROR(OutOfBounds, "p should be >=1") }
 
    period_size_ = p;
  }

References GUM_ERROR, and period_size_.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), and gum::SamplingInference< GUM_SCALAR >::SamplingInference().

Here is the caller graph for this function:

setVerbosity()

INLINE void gum::ApproximationScheme::setVerbosity ( bool v )

overridevirtualinherited

Set the verbosity on (true) or off (false).

Parameters

v	If true, then verbosity is turned on.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 158 of file approximationScheme_inl.h.

{ verbosity_ = v; }

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), and gum::SamplingInference< GUM_SCALAR >::SamplingInference().

Here is the caller graph for this function:

startOfPeriod()

INLINE bool gum::ApproximationScheme::startOfPeriod ( ) const

inherited

Returns true if we are at the beginning of a period (compute error is mandatory).

Returns

Returns true if we are at the beginning of a period (compute error is mandatory).

Definition at line 199 of file approximationScheme_inl.h.

                                                       {
    if (current_step_ < burn_in_) { return false; }
 
    if (period_size_ == 1) { return true; }
 
    return ((current_step_ - burn_in_) % period_size_ == 0);
  }

References burn_in_, and current_step_.

stateApproximationScheme()

INLINE IApproximationSchemeConfiguration::ApproximationSchemeSTATE gum::ApproximationScheme::stateApproximationScheme ( ) const

overridevirtualinherited

Returns the approximation scheme state.

Returns

Returns the approximation scheme state.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 164 of file approximationScheme_inl.h.

                                                             {
    return current_state_;
  }

References current_state_.

Referenced by history(), and nbrIterations().

Here is the caller graph for this function:

stopApproximationScheme()

INLINE void gum::ApproximationScheme::stopApproximationScheme ( )

inherited

Stop the approximation scheme.

Definition at line 221 of file approximationScheme_inl.h.

                                                           {
    if (current_state_ == ApproximationSchemeSTATE::Continue) {
      stopScheme_(ApproximationSchemeSTATE::Stopped);
    }
  }

Referenced by gum::learning::GreedyHillClimbing::learnStructure(), gum::learning::LocalSearchWithTabuList::learnStructure(), and gum::credal::CNLoopyPropagation< GUM_SCALAR >::makeInferenceNodeToNeighbours_().

Here is the caller graph for this function:

stopScheme_()

INLINE void gum::ApproximationScheme::stopScheme_ ( ApproximationSchemeSTATE new_state )

privateinherited

Stop the scheme given a new state.

Parameters

new_state

The scheme new state.

Definition at line 301 of file approximationScheme_inl.h.

                                                                                 {
    if (new_state == ApproximationSchemeSTATE::Continue) { return; }
 
    if (new_state == ApproximationSchemeSTATE::Undefined) { return; }
 
    current_state_ = new_state;
    timer_.pause();
 
    if (onStop.hasListener()) { GUM_EMIT1(onStop, messageApproximationScheme()); }
  }

References gum::IApproximationSchemeConfiguration::Continue, current_state_, and gum::IApproximationSchemeConfiguration::Undefined.

Referenced by gum::credal::MultipleInferenceEngine< GUM_SCALAR, LazyPropagation< GUM_SCALAR > >::disableMaxIter(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, LazyPropagation< GUM_SCALAR > >::disableMaxTime(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, LazyPropagation< GUM_SCALAR > >::isEnabledMaxIter(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, LazyPropagation< GUM_SCALAR > >::maxTime(), and gum::credal::MultipleInferenceEngine< GUM_SCALAR, LazyPropagation< GUM_SCALAR > >::setPeriodSize().

Here is the caller graph for this function:

unshieldedTriples_()

std::vector< Ranking > gum::learning::SimpleMiic::unshieldedTriples_ ( const MixedGraph & graph, CorrectedMutualInformation & mutualInformation, const HashTable< std::pair< NodeId, NodeId >, std::vector< NodeId > > & sepSet )

protected

gets the list of unshielded triples in the graph in decreasing value of |I'(x, y, z|{ui})|

Definition at line 494 of file SimpleMiic.cpp.

                                                                                   {
      std::vector< Ranking > triples;
      for (NodeId z: graph) {
        for (NodeId x: graph.neighbours(z)) {
          for (NodeId y: graph.neighbours(z)) {
            if (y < x && !graph.existsEdge(x, y)) {
              std::vector< NodeId >       ui;
              std::pair< NodeId, NodeId > key     = {x, y};
              std::pair< NodeId, NodeId > rev_key = {y, x};
              if (sepSet.exists(key)) {
                ui = sepSet[key];
              } else if (sepSet.exists(rev_key)) {
                ui = sepSet[rev_key];
              }
              // remove z from ui if it's present
              const auto iter_z_place = std::find(ui.begin(), ui.end(), z);
              if (iter_z_place != ui.end()) { ui.erase(iter_z_place); }
 
              double  Ixyz_ui = mutualInformation.score(x, y, z, ui);
              Ranking triple;
              auto    tup   = new ThreePoints{x, y, z};
              triple.first  = tup;
              triple.second = Ixyz_ui;
              triples.push_back(triple);
            }
          }
        }
      }
      std::sort(triples.begin(), triples.end(), GreaterAbsPairOn2nd());
      return triples;
    }

References gum::EdgeGraphPart::existsEdge(), gum::EdgeGraphPart::neighbours(), and gum::learning::CorrectedMutualInformation::score().

Referenced by orientationLatents_().

Here is the call graph for this function:

Here is the caller graph for this function:

unshieldedTriplesMiic_()

std::vector< ProbabilisticRanking > gum::learning::SimpleMiic::unshieldedTriplesMiic_ ( const MixedGraph & graph, CorrectedMutualInformation & mutualInformation, const HashTable< std::pair< NodeId, NodeId >, std::vector< NodeId > > & sepSet, HashTable< std::pair< NodeId, NodeId >, char > & marks )

protected

gets the list of unshielded triples in the graph in decreasing value of |I'(x, y, z|{ui})|, prepares the orientation matrix for MIIC

Definition at line 531 of file SimpleMiic.cpp.

                                                                                    {
      std::vector< ProbabilisticRanking > triples;
      for (NodeId z: graph) {
        for (NodeId x: graph.neighbours(z)) {
          for (NodeId y: graph.neighbours(z)) {
            if (y < x && !graph.existsEdge(x, y)) {
              std::vector< NodeId >       ui;
              std::pair< NodeId, NodeId > key     = {x, y};
              std::pair< NodeId, NodeId > rev_key = {y, x};
              if (sepSet.exists(key)) {
                ui = sepSet[key];
              } else if (sepSet.exists(rev_key)) {
                ui = sepSet[rev_key];
              }
              // remove z from ui if it's present
              const auto iter_z_place = std::find(ui.begin(), ui.end(), z);
              if (iter_z_place != ui.end()) { ui.erase(iter_z_place); }
 
              const double         Ixyz_ui = mutualInformation.score(x, y, z, ui);
              auto                 tup     = new ThreePoints{x, y, z};
              ProbabilisticRanking triple{tup, Ixyz_ui, 0.5, 0.5};
              triples.push_back(triple);
              if (!marks.exists({x, z})) { marks.insert({x, z}, 'o'); }
              if (!marks.exists({z, x})) { marks.insert({z, x}, 'o'); }
              if (!marks.exists({y, z})) { marks.insert({y, z}, 'o'); }
              if (!marks.exists({z, y})) { marks.insert({z, y}, 'o'); }
            }
          }
        }
      }
      triples = updateProbaTriples_(graph, triples);
      std::sort(triples.begin(), triples.end(), GreaterTupleOnLast());
      return triples;
    }

References gum::EdgeGraphPart::existsEdge(), gum::EdgeGraphPart::neighbours(), gum::learning::CorrectedMutualInformation::score(), and updateProbaTriples_().

Referenced by orientationMiic_().

Here is the call graph for this function:

Here is the caller graph for this function:

updateApproximationScheme()

INLINE void gum::ApproximationScheme::updateApproximationScheme ( unsigned int incr = 1 )

inherited

Update the scheme w.r.t the new error and increment steps.

Parameters

incr	The new increment steps.

Definition at line 208 of file approximationScheme_inl.h.

                                                                              {
    current_step_ += incr;
  }

References current_step_.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::computeKL_(), gum::learning::GreedyHillClimbing::learnStructure(), gum::learning::LocalSearchWithTabuList::learnStructure(), gum::SamplingInference< GUM_SCALAR >::loopApproxInference_(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::makeInferenceByOrderedArcs_(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::makeInferenceByRandomOrder_(), and gum::credal::CNLoopyPropagation< GUM_SCALAR >::makeInferenceNodeToNeighbours_().

Here is the caller graph for this function:

updateProbaTriples_()

std::vector< ProbabilisticRanking > gum::learning::SimpleMiic::updateProbaTriples_ ( const MixedGraph & graph, std::vector< ProbabilisticRanking > probaTriples )

protected

Gets the orientation probabilities like MIIC for the orientation phase.

Definition at line 572 of file SimpleMiic.cpp.

                                                                                        {
      for (auto& triple: probaTriples) {
        NodeId x, y, z;
        x                 = std::get< 0 >(*std::get< 0 >(triple));
        y                 = std::get< 1 >(*std::get< 0 >(triple));
        z                 = std::get< 2 >(*std::get< 0 >(triple));
        const double Ixyz = std::get< 1 >(triple);
        double       Pxz  = std::get< 2 >(triple);
        double       Pyz  = std::get< 3 >(triple);
 
        if (Ixyz <= 0) {
          const double expo = std::exp(Ixyz);
          const double P0   = (1 + expo) / (1 + 3 * expo);
          // distinguish between the initialization and the update process
          if (Pxz == Pyz && Pyz == 0.5) {
            std::get< 2 >(triple) = P0;
            std::get< 3 >(triple) = P0;
          } else {
            if (graph.existsArc(x, z) && Pxz >= P0) {
              std::get< 3 >(triple) = Pxz * (1 / (1 + expo) - 0.5) + 0.5;
            } else if (graph.existsArc(y, z) && Pyz >= P0) {
              std::get< 2 >(triple) = Pyz * (1 / (1 + expo) - 0.5) + 0.5;
            }
          }
        } else {
          const double expo = std::exp(-Ixyz);
          if (graph.existsArc(x, z) && Pxz >= 0.5) {
            std::get< 3 >(triple) = Pxz * (1 / (1 + expo) - 0.5) + 0.5;
          } else if (graph.existsArc(y, z) && Pyz >= 0.5) {
            std::get< 2 >(triple) = Pyz * (1 / (1 + expo) - 0.5) + 0.5;
          }
        }
      }
      std::sort(probaTriples.begin(), probaTriples.end(), GreaterTupleOnLast());
      return probaTriples;
    }

References gum::ArcGraphPart::existsArc().

Referenced by orientationMiic_(), and unshieldedTriplesMiic_().

Here is the call graph for this function:

Here is the caller graph for this function:

verbosity()

INLINE bool gum::ApproximationScheme::verbosity ( ) const

overridevirtualinherited

Returns true if verbosity is enabled.

Returns

Returns true if verbosity is enabled.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 160 of file approximationScheme_inl.h.

{ return verbosity_; }

References verbosity_.

Referenced by ApproximationScheme(), and gum::learning::EMApproximationScheme::EMApproximationScheme().

Here is the caller graph for this function:

Member Data Documentation

_arcProbas_

ArcProperty< double > gum::learning::SimpleMiic::_arcProbas_

private

Storing the propabilities for each arc set in the graph.

Definition at line 299 of file SimpleMiic.h.

Referenced by _orientingVstructureMiic_(), and _propagatingOrientationMiic_().

_emptySet_

const std::vector< NodeId > gum::learning::SimpleMiic::_emptySet_

private

an empty conditioning set

Definition at line 291 of file SimpleMiic.h.

Referenced by initiation_().

_initialMarks_

HashTable< std::pair< NodeId, NodeId >, char > gum::learning::SimpleMiic::_initialMarks_

private

Initial marks for the orientation phase, used to convey constraints.

Definition at line 302 of file SimpleMiic.h.

Referenced by addConstraints(), isForbidenArc_(), and orientationMiic_().

_latentCouples_

std::vector< Arc > gum::learning::SimpleMiic::_latentCouples_

private

an empty vector of arcs

Definition at line 293 of file SimpleMiic.h.

Referenced by _isNotLatentCouple_(), _orientingVstructureMiic_(), _propagatingOrientationMiic_(), latentVariables(), learnMixedStructure(), orientationLatents_(), orientationMiic_(), and propagatesRemainingOrientableEdges_().

_maxLog_

int gum::learning::SimpleMiic::_maxLog_ = 100

private

Fixes the maximum log that we accept in exponential computations.

Definition at line 289 of file SimpleMiic.h.

Referenced by SimpleMiic(), SimpleMiic(), and findBestContributor_().

_size_

Size gum::learning::SimpleMiic::_size_

private

size of the database

Definition at line 296 of file SimpleMiic.h.

Referenced by SimpleMiic(), SimpleMiic(), SimpleMiic(), and SimpleMiic().

burn_in_

Size gum::ApproximationScheme::burn_in_

protectedinherited

Number of iterations before checking stopping criteria.

Definition at line 423 of file approximationScheme.h.

Referenced by ApproximationScheme(), gum::GibbsBNdistance< GUM_SCALAR >::burnIn(), gum::GibbsSampling< GUM_SCALAR >::burnIn(), remainingBurnIn(), gum::GibbsBNdistance< GUM_SCALAR >::setBurnIn(), gum::GibbsSampling< GUM_SCALAR >::setBurnIn(), and startOfPeriod().

current_epsilon_

double gum::ApproximationScheme::current_epsilon_

protectedinherited

Current epsilon.

Definition at line 378 of file approximationScheme.h.

Referenced by initApproximationScheme().

current_rate_

double gum::ApproximationScheme::current_rate_

protectedinherited

Current rate.

Definition at line 384 of file approximationScheme.h.

Referenced by initApproximationScheme().

current_state_

ApproximationSchemeSTATE gum::ApproximationScheme::current_state_

protectedinherited

The current state.

Definition at line 393 of file approximationScheme.h.

Referenced by ApproximationScheme(), initApproximationScheme(), stateApproximationScheme(), and stopScheme_().

current_step_

Size gum::ApproximationScheme::current_step_

protectedinherited

The current step.

Definition at line 387 of file approximationScheme.h.

Referenced by initApproximationScheme(), gum::learning::Miic::initiation_(), gum::learning::SimpleMiic::initiation_(), gum::learning::Miic::iteration_(), gum::learning::SimpleMiic::iteration_(), gum::learning::Miic::learnMixedStructure(), gum::learning::SimpleMiic::learnMixedStructure(), gum::learning::Miic::learnSkeleton(), nbrIterations(), gum::learning::SimpleMiic::orientationLatents_(), gum::learning::Miic::orientationMiic_(), gum::learning::SimpleMiic::orientationMiic_(), remainingBurnIn(), startOfPeriod(), and updateApproximationScheme().

enabled_eps_

bool gum::ApproximationScheme::enabled_eps_

protectedinherited

If true, the threshold convergence is enabled.

Definition at line 402 of file approximationScheme.h.

Referenced by ApproximationScheme(), disableEpsilon(), enableEpsilon(), isEnabledEpsilon(), and setEpsilon().

enabled_max_iter_

bool gum::ApproximationScheme::enabled_max_iter_

protectedinherited

If true, the maximum iterations stopping criterion is enabled.

Definition at line 420 of file approximationScheme.h.

Referenced by ApproximationScheme(), disableMaxIter(), enableMaxIter(), isEnabledMaxIter(), and setMaxIter().

enabled_max_time_

bool gum::ApproximationScheme::enabled_max_time_

protectedinherited

If true, the timeout is enabled.

Definition at line 414 of file approximationScheme.h.

Referenced by ApproximationScheme(), continueApproximationScheme(), disableMaxTime(), enableMaxTime(), isEnabledMaxTime(), and setMaxTime().

enabled_min_rate_eps_

bool gum::ApproximationScheme::enabled_min_rate_eps_

protectedinherited

If true, the minimal threshold for epsilon rate is enabled.

Definition at line 408 of file approximationScheme.h.

Referenced by ApproximationScheme(), disableMinEpsilonRate(), enableMinEpsilonRate(), isEnabledMinEpsilonRate(), and setMinEpsilonRate().

eps_

double gum::ApproximationScheme::eps_

protectedinherited

Threshold for convergence.

Definition at line 399 of file approximationScheme.h.

Referenced by ApproximationScheme(), epsilon(), and setEpsilon().

history_

std::vector< double > gum::ApproximationScheme::history_

protectedinherited

The scheme history, used only if verbosity == true.

Definition at line 396 of file approximationScheme.h.

last_epsilon_

double gum::ApproximationScheme::last_epsilon_

protectedinherited

Last epsilon value.

Definition at line 381 of file approximationScheme.h.

max_iter_

Size gum::ApproximationScheme::max_iter_

protectedinherited

The maximum iterations.

Definition at line 417 of file approximationScheme.h.

Referenced by ApproximationScheme(), maxIter(), and setMaxIter().

max_time_

double gum::ApproximationScheme::max_time_

protectedinherited

The timeout.

Definition at line 411 of file approximationScheme.h.

Referenced by ApproximationScheme(), maxTime(), and setMaxTime().

min_rate_eps_

double gum::ApproximationScheme::min_rate_eps_

protectedinherited

Threshold for the epsilon rate.

Definition at line 405 of file approximationScheme.h.

Referenced by ApproximationScheme(), minEpsilonRate(), and setMinEpsilonRate().

onProgress

Signaler3< Size, double, double > gum::IApproximationSchemeConfiguration::onProgress

inherited

Progression, error and time.

Definition at line 80 of file IApproximationSchemeConfiguration.h.

Referenced by gum::learning::IBNLearner::distributeProgress(), gum::learning::Miic::initiation_(), gum::learning::SimpleMiic::initiation_(), gum::learning::Miic::iteration_(), gum::learning::SimpleMiic::iteration_(), gum::learning::SimpleMiic::orientationLatents_(), gum::learning::Miic::orientationMiic_(), and gum::learning::SimpleMiic::orientationMiic_().

onStop

Signaler1< const std::string& > gum::IApproximationSchemeConfiguration::onStop

inherited

Criteria messageApproximationScheme.

Definition at line 83 of file IApproximationSchemeConfiguration.h.

Referenced by gum::learning::IBNLearner::distributeStop().

period_size_

Size gum::ApproximationScheme::period_size_

protectedinherited

Checking criteria frequency.

Definition at line 426 of file approximationScheme.h.

Referenced by ApproximationScheme(), periodSize(), and setPeriodSize().

timer_

Timer gum::ApproximationScheme::timer_

protectedinherited

The timer.

Definition at line 390 of file approximationScheme.h.

Referenced by continueApproximationScheme(), currentTime(), gum::learning::Miic::initiation_(), gum::learning::SimpleMiic::initiation_(), gum::learning::Miic::iteration_(), gum::learning::SimpleMiic::iteration_(), gum::learning::Miic::learnMixedStructure(), gum::learning::SimpleMiic::learnMixedStructure(), gum::learning::Miic::learnSkeleton(), gum::learning::SimpleMiic::orientationLatents_(), gum::learning::Miic::orientationMiic_(), and gum::learning::SimpleMiic::orientationMiic_().

verbosity_

bool gum::ApproximationScheme::verbosity_

protectedinherited

If true, verbosity is enabled.

Definition at line 429 of file approximationScheme.h.

Referenced by ApproximationScheme(), and verbosity().

---

The documentation for this class was generated from the following files:

• agrum/BN/learning/SimpleMiic.h
• agrum/BN/learning/SimpleMiic.cpp