A pack of learning algorithms that can easily be used. More...

#include <IBNLearner.h>

Inheritance diagram for gum::learning::IBNLearner:

Classes
class	Database
	a helper to easily read databases More...

Public Types
enum class	ScoreType { AIC , BD , BDeu , BIC , fNML , K2 , LOG2LIKELIHOOD , MDL }
	an enumeration enabling to select easily the score we wish to use More...
enum class	ParamEstimatorType { ML }
	an enumeration to select the type of parameter estimation we shall apply More...
enum class	BNLearnerPriorType { NO_prior , SMOOTHING , DIRICHLET_FROM_DATABASE , DIRICHLET_FROM_BAYESNET , BDEU }
	an enumeration to select the prior More...
enum class	AlgoType { K2 , GREEDY_HILL_CLIMBING , LOCAL_SEARCH_WITH_TABU_LIST , MIIC , PC , FCI , EXTENDED_GREEDY_HILL_CLIMBING , GREEDY_THICK_THINNING }
	an enumeration to select easily the learning algorithm to use More...
enum class	ApproximationSchemeSTATE : char { Undefined , Continue , Epsilon , Rate , Limit , TimeLimit , Stopped }
	The different state of an approximation scheme. More...

Public Member Functions
void	unsetTotalOrder ()
	removes the current total ordering constraint, if any
void	setForbiddenArcs (const ArcSet &set)
	removes a total
void	setMandatoryArcs (const ArcSet &set)
	assign a set of mandatory arcs
Constructors / Destructors
	IBNLearner (std::string_view filename, const std::vector< std::string > &missingSymbols, bool induceTypes=true)
	read the database file for the score / parameter estimation and var names
	IBNLearner (const DatabaseTable &db)
	read the database file for the score / parameter estimation and var names
template<GUM_Numeric GUM_SCALAR>
	IBNLearner (std::string_view filename, const gum::BayesNet< GUM_SCALAR > &src, const std::vector< std::string > &missing_symbols)
	read the database file for the score / parameter estimation and var names
	IBNLearner (const IBNLearner &)
	copy constructor
	IBNLearner (IBNLearner &&)
	move constructor
	~IBNLearner () override
	destructor
Operators
IBNLearner &	operator= (const IBNLearner &)
	copy operator
IBNLearner &	operator= (IBNLearner &&)
	move operator
Accessors / Modifiers
DAG	learnDAG ()
	learn a structure from a file (must have read the db before)
PDAG	learnPDAG ()
	learn a partial structure from a file (must have read the db before and must have selected miic)
PAG	learnPAG ()
	learn a PAG — only valid when useFCI() has been called
void	setInitialDAG (const DAG &)
	sets an initial DAG structure
DAG	initialDAG ()
	returns the initial DAG structure
const std::vector< std::string > &	names () const
	returns the names of the variables in the database
const std::vector< std::size_t > &	domainSizes () const
	returns the domain sizes of the variables in the database
Size	domainSize (NodeId var) const
	learn a structure from a file (must have read the db before)
Size	domainSize (std::string_view var) const
	learn a structure from a file (must have read the db before)
NodeId	idFromName (std::string_view var_name) const
	returns the node id corresponding to a variable name
const DatabaseTable &	database () const
	returns the database used by the BNLearner
void	setDatabaseWeight (const double new_weight)
	assign a weight to all the rows of the learning database so that the sum of their weights is equal to new_weight
void	setRecordWeight (const std::size_t i, const double weight)
	sets the weight of the ith record of the database
double	recordWeight (const std::size_t i) const
	returns the weight of the ith record
double	databaseWeight () const
	returns the weight of the whole database
const std::string &	nameFromId (NodeId id) const
	returns the variable name corresponding to a given node id
void	useDatabaseRanges (const std::vector< std::pair< std::size_t, std::size_t > > &new_ranges)
	use a new set of database rows' ranges to perform learning
void	clearDatabaseRanges ()
	reset the ranges to the one range corresponding to the whole database
const std::vector< std::pair< std::size_t, std::size_t > > &	databaseRanges () const
	returns the current database rows' ranges used for learning
std::pair< std::size_t, std::size_t >	useCrossValidationFold (const std::size_t learning_fold, const std::size_t k_fold)
	sets the ranges of rows to be used for cross-validation learning
std::pair< double, double >	chi2 (NodeId id1, NodeId id2, const std::vector< NodeId > &knowing={})
	Return the <statistic,pvalue> pair for chi2 test in the database.
std::pair< double, double >	chi2 (std::string_view name1, std::string_view name2, const std::vector< std::string > &knowing={})
	Return the <statistic,pvalue> pair for the BNLearner.
std::pair< double, double >	G2 (NodeId id1, NodeId id2, const std::vector< NodeId > &knowing={})
	Return the <statistic,pvalue> pair for for G2 test in the database.
std::pair< double, double >	G2 (std::string_view name1, std::string_view name2, const std::vector< std::string > &knowing={})
	Return the <statistic,pvalue> pair for for G2 test in the database.
double	logLikelihood (const std::vector< NodeId > &vars, const std::vector< NodeId > &knowing={})
	Return the loglikelihood of vars in the base, conditioned by knowing for the BNLearner.
double	logLikelihood (const std::vector< std::string > &vars, const std::vector< std::string > &knowing={})
	Return the loglikelihood of vars in the base, conditioned by knowing for the BNLearner.
double	mutualInformation (NodeId id1, NodeId id2, const std::vector< NodeId > &knowing={})
	Return the mutual information of id1 and id2 in the base, conditioned by knowing for the BNLearner.
double	mutualInformation (std::string_view var1, std::string_view var2, const std::vector< std::string > &knowing={})
	Return the mutual information of var1 and var2 in the base, conditioned by knowing for the BNLearner.
double	correctedMutualInformation (NodeId id1, NodeId id2, const std::vector< NodeId > &knowing={})
	Return the mutual information of id1 and id2 in the base, conditioned by knowing for the BNLearner.
double	correctedMutualInformation (std::string_view var1, std::string_view var2, const std::vector< std::string > &knowing={})
	Return the mutual information of var1 and var2 in the base, conditioned by knowing for the BNLearner.
double	score (NodeId vars, const std::vector< NodeId > &knowing={})
	Return the value of the score currently in use by the BNLearner of a variable given a set of other variables.
double	score (std::string_view vars, const std::vector< std::string > &knowing={})
	Return the value of the score currently in use by the BNLearner of a variable given a set of other variables The score used is the one currently selected in the BNLearner.
std::vector< double >	rawPseudoCount (const std::vector< NodeId > &vars)
	Return the pseudo-counts of NodeIds vars in the base in a raw array.
std::vector< double >	rawPseudoCount (const std::vector< std::string > &vars)
	Return the pseudoconts of vars in the base in a raw array.
Size	nbCols () const
Size	nbRows () const
void	useEM (const double epsilon, const double noise=default_EM_noise)
	use The EM algorithm to learn parameters
void	useEMWithRateCriterion (const double epsilon, const double noise=default_EM_noise)
	use The EM algorithm to learn parameters with the rate stopping criterion
void	useEMWithDiffCriterion (const double epsilon, const double noise=default_EM_noise)
	use The EM algorithm to learn parameters with the diff stopping criterion
void	forbidEM ()
	prevent using the EM algorithm for parameter learning
bool	isUsingEM () const
	indicates whether we use EM for parameter learning
EMApproximationScheme &	EM ()
	returns the EM parameter learning approximation scheme if EM is enabled
ApproximationSchemeSTATE	EMState () const
	returns the state of the last EM algorithm executed
std::string	EMStateMessage () const
	returns the state of the EM algorithm
bool	hasMissingValues () const
	returns true if the learner's database has missing values
Score selection
void	useScoreAIC ()
	indicate that we wish to use an AIC score
void	useScoreBD ()
	indicate that we wish to use a BD score
void	useScoreBDeu ()
	indicate that we wish to use a BDeu score
void	useScoreBIC ()
	indicate that we wish to use a BIC score
void	useScorefNML ()
	indicate that we wish to use a fNML score
void	useScoreK2 ()
	indicate that we wish to use a K2 score
void	useScoreLog2Likelihood ()
	indicate that we wish to use a Log2Likelihood score
void	useScoreMDL ()
	indicate that we wish to use a MDL score
a prior selection / parameterization
void	useNoPrior ()
	use no prior
void	useBDeuPrior (double weight=1.0)
	use the BDeu prior
void	useSmoothingPrior (double weight=1)
	use the prior smoothing
void	useDirichletPrior (std::string_view filename, double weight=1)
	use the Dirichlet prior from a database
std::string	checkScorePriorCompatibility () const
	checks whether the current score and prior are compatible
Learning algorithm selection
void	useGreedyHillClimbing ()
	indicate that we wish to use a greedy hill climbing algorithm
void	useExtendedGreedyHillClimbing ()
	indicate that we wish to use the extended greedy hill climbing algorithm
void	useLocalSearchWithTabuList (Size tabu_size=100, Size nb_decrease=2)
	indicate that we wish to use a local search with tabu list
void	useK2 (const Sequence< NodeId > &order)
	indicate that we wish to use K2
void	useK2 (const std::vector< NodeId > &order)
	indicate that we wish to use K2
void	useMIIC ()
	indicate that we wish to use MIIC
void	usePC ()
	indicate that we wish to use PC (Chi2 test by default)
void	useFCI ()
	indicate that we wish to use FCI (Chi2 test by default)
void	useGreedyThickThinning ()
	indicate that we wish to use greedy thick-thinning
void	setGreedyThickThinningReversals (bool allow)
	enable or disable arc reversals in the thin phase of greedy thick-thinning
bool	greedyThickThinningReversals () const
	returns whether arc reversals are allowed in the thin phase of greedy thick-thinning
bool	isConstraintBased () const
	indicate if the selected algorithm is constraint-based
bool	isScoreBased () const
	indicate if the selected algorithm is score-based
allow/forbid the graph operations used during learning
void	allowArcAdditions (bool allow=true)
	allow (true)/forbid (false) to add arcs during learning.
void	allowArcDeletions (bool allow=true)
	allow (true)/forbid (false) to delete arcs during learning.
void	allowArcReversals (bool allow=true)
	allow (true)/forbid (false) to reverse arcs during learning.
void	allowArcTriangleDeletions (bool allow=true)
	allow (true)/forbid (false) to delete arc triangles during learning.
MIIC parameterization and specific results
void	useNMLCorrection ()
	indicate that we wish to use the NML correction for and MIIC
void	useMDLCorrection ()
	indicate that we wish to use the MDL correction for MIIC
void	useNoCorrection ()
	indicate that we wish to use the NoCorr correction for MIIC
std::vector< Arc >	latentVariables () const
	get the list of arcs hiding latent variables
PC parameterization
void	useChi2Test ()
	indicate that we wish to use Chi2 independence test for PC
void	useG2Test ()
	indicate that we wish to use G2 independence test for PC
void	setPCAlpha (double alpha)
	set the significance threshold alpha for PC (default 0.05)
void	setPCStable (bool stable)
	set stable mode for PC — defer removals to end of each depth level (default true)
void	setPCMaxCondSetSize (Size max_k)
	set maximum conditioning set size for PC (default Size(-1) = unlimited)
void	setPCUnshieldedColliderSorted (bool sorted)
	set unshielded-collider ordering for PC: sorted=true uses descending p-value order (strongest evidence first); sorted=false uses natural traversal order (default false)
FCI parameterization
void	useFCIChi2Test ()
	indicate that we wish to use Chi2 independence test for FCI
void	useFCIG2Test ()
	indicate that we wish to use G2 independence test for FCI
void	setFCIAlpha (double alpha)
	set the significance threshold alpha for FCI (default 0.05)
void	setFCIMaxPathLength (Size max_len)
	set maximum discriminating-path length for FCI R4 (default Size(-1) = unlimited)
void	setFCIExhaustiveSepSet (bool exhaustive)
	enable exhaustive sepset mode for FCI skeleton learning (default false)
bool	fciExhaustiveSepSet () const
	return true when FCI uses exhaustive sepset mode
Accessors / Modifiers for adding constraints on learning
void	setMaxIndegree (Size max_indegree)
	sets the max indegree
void	setSliceOrder (const NodeProperty< NodeId > &slice_order)
	sets a partial order on the nodes
void	setSliceOrder (const std::vector< std::vector< std::string > > &slices)
	sets a partial order on the nodes
void	unsetSliceOrder ()
	removes the slice order constraint
void	setTotalOrder (const Sequence< NodeId > &order)
	sets a total order over some nodes
void	setTotalOrder (const std::vector< std::string > &order)
	sets the max indegree
assign a new forbidden arc
void	addForbiddenArc (const Arc &arc)
void	addForbiddenArc (NodeId tail, NodeId head)
void	addForbiddenArc (std::string_view tail, std::string_view head)
remove a forbidden arc
void	eraseForbiddenArc (const Arc &arc)
void	eraseForbiddenArc (NodeId tail, NodeId head)
void	eraseForbiddenArc (std::string_view tail, std::string_view head)
assign a new mandatory arc
void	addMandatoryArc (const Arc &arc)
void	addMandatoryArc (NodeId tail, NodeId head)
void	addMandatoryArc (std::string_view tail, std::string_view head)
remove a mandatory arc
void	eraseMandatoryArc (const Arc &arc)
void	eraseMandatoryArc (NodeId tail, NodeId head)
void	eraseMandatoryArc (std::string_view tail, std::string_view head)
add a node with no parent
void	addNoParentNode (NodeId node)
void	addNoParentNode (std::string_view node)
remove a node with no parent
void	eraseNoParentNode (NodeId node)
void	eraseNoParentNode (std::string_view node)
add a node with no children
void	addNoChildrenNode (NodeId node)
void	addNoChildrenNode (std::string_view node)
remove a node with no children
void	eraseNoChildrenNode (NodeId node)
void	eraseNoChildrenNode (std::string_view node)

void	setPossibleEdges (const EdgeSet &set)
	assign a set of possible edges
void	setPossibleSkeleton (const UndiGraph &skeleton)
	assign a set of possible edges
assign a new possible edge
Warning By default, any edge is possible. However, once at least one possible edge is defined, all the other edges not declared possible are considered as impossible.
void	addPossibleEdge (const Edge &edge)
void	addPossibleEdge (NodeId tail, NodeId head)
void	addPossibleEdge (std::string_view tail, std::string_view head)
remove a possible edge
void	erasePossibleEdge (const Edge &edge)
void	erasePossibleEdge (NodeId tail, NodeId head)
void	erasePossibleEdge (std::string_view tail, std::string_view head)
Multithreading
void	setNumberOfThreads (Size nb) override
	sets the number max of threads that can be used
redistribute signals AND implementation of interface
IApproximationSchemeConfiguration
void	setCurrentApproximationScheme (const ApproximationScheme *approximationScheme)
	{@ /// distribute signals
void	distributeProgress (const ApproximationScheme *approximationScheme, Size pourcent, double error, double time)
	{@ /// distribute signals
void	distributeStop (const ApproximationScheme *approximationScheme, std::string_view message)
	distribute signals

void	setEpsilon (double eps) override
	Given that we approximate f(t), stopping criterion on \|f(t+1)-f(t)\| If the criterion was disabled it will be enabled.
double	epsilon () const override
	Get the value of epsilon.
void	disableEpsilon () override
	Disable stopping criterion on epsilon.
void	enableEpsilon () override
	Enable stopping criterion on epsilon.
bool	isEnabledEpsilon () const override

void	setMinEpsilonRate (double rate) override
	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.
double	minEpsilonRate () const override
	Get 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

void	setMaxIter (Size max) override
	stopping criterion on number of iterationsIf the criterion was disabled it will be enabled
Size	maxIter () const override
void	disableMaxIter () override
	Disable stopping criterion on max iterations.
void	enableMaxIter () override
	Enable stopping criterion on max iterations.
bool	isEnabledMaxIter () const override

void	setMaxTime (double timeout) override
	stopping criterion on timeout If the criterion was disabled it will be enabled
double	maxTime () const override
	returns the timeout (in seconds)
double	currentTime () const override
	get the current running time in second (double)
void	disableMaxTime () override
	Disable stopping criterion on timeout.
void	enableMaxTime () override
	stopping criterion on timeout If the criterion was disabled it will be enabled
bool	isEnabledMaxTime () const override

void	setPeriodSize (Size p) override
	how many samples between 2 stopping isEnableds
Size	periodSize () const override
	how many samples between 2 stopping isEnableds

void	setVerbosity (bool v) override
	verbosity
bool	verbosity () const override
	verbosity

ApproximationSchemeSTATE	stateApproximationScheme () const override
	history
Size	nbrIterations () const override
const std::vector< double > &	history () const override
EM approximation scheme for parameter learning
void	EMsetEpsilon (double eps)
	sets the stopping criterion of EM as being the minimal difference between two consecutive log-likelihoods
double	EMEpsilon () const
	Get the value of EM's min diff epsilon.
void	EMdisableEpsilon ()
	Disable the min log-likelihood diff stopping criterion for EM.
void	EMenableEpsilon ()
	Enable the log-likelihood min diff stopping criterion in EM.
bool	EMisEnabledEpsilon () const
	return true if EM's stopping criterion is the log-likelihood min diff
void	EMsetMinEpsilonRate (double rate)
	sets the stopping criterion of EM as being the minimal log-likelihood's evolution rate
double	EMMinEpsilonRate () const
	Get the value of the minimal log-likelihood evolution rate of EM.
void	EMdisableMinEpsilonRate ()
	Disable the log-likelihood evolution rate stopping criterion.
void	EMenableMinEpsilonRate ()
	Enable the log-likelihood evolution rate stopping criterion.
bool	EMisEnabledMinEpsilonRate () const
void	EMsetMaxIter (Size max)
	add a max iteration stopping criterion
Size	EMMaxIter () const
	return the max number of iterations criterion
void	EMdisableMaxIter ()
	Disable stopping criterion on max iterations.
void	EMenableMaxIter ()
	Enable stopping criterion on max iterations.
bool	EMisEnabledMaxIter () const
void	EMsetMaxTime (double timeout)
	add a stopping criterion on timeout
double	EMMaxTime () const
	@brief returns EM's timeout (in milliseconds)
double	EMCurrentTime () const
	get the current running time in second (double)
void	EMdisableMaxTime ()
	Disable EM's timeout stopping criterion.
void	EMenableMaxTime ()
	sets the stopping criterion of EM as being the minimal difference between two consecutive log-likelihoods
bool	EMisEnabledMaxTime () const
void	EMsetPeriodSize (Size p)
	how many samples between 2 stoppings isEnabled
Size	EMPeriodSize () const
	sets the stopping criterion of EM as being the minimal difference between two consecutive log-likelihoods
void	EMsetVerbosity (bool v)
	sets or unsets EM's verbosity
bool	EMVerbosity () const
	returns the EM's verbosity status
ApproximationSchemeSTATE	EMStateApproximationScheme () const
	get the current state of EM
Size	EMnbrIterations () const
	returns the number of iterations performed by the last EM execution
const std::vector< double > &	EMHistory () const
	returns the history of the last EM execution
Getters and setters
std::string	messageApproximationScheme () const
	Returns the approximation scheme message.
Accessors/Modifiers
Size	getNumberOfThreads () const override
	returns the current max number of threads used by the class containing this ThreadNumberManager
bool	isGumNumberOfThreadsOverriden () const override
	indicates whether the class containing this ThreadNumberManager set its own number of threads

Public Attributes
Signaler< Size, double, double >	onProgress
	Progression, error and time.
Signaler< std::string_view >	onStop
	Criteria messageApproximationScheme.

Static Public Attributes
static constexpr double	default_EM_noise {0.1}
	the default noise amount added to CPTs during EM's initialization (see method useEM())

Protected Types
enum class	IndepTestType { Chi2 , G2 }
	independence test type for PC More...

Protected Member Functions
PAG	learnPAG_ ()
PDAG	learnPDAG_ ()
void	_setPriorWeight_ (double weight)
	sets the prior weight
virtual void	createPrior_ ()=0
	create the prior used for learning
void	createScore_ ()
	create the score used for learning
ParamEstimator *	createParamEstimator_ (const DBRowGeneratorParser &parser, bool take_into_account_score=true)
	create the parameter estimator used for learning
DAG	learnDag_ ()
	returns the DAG learnt
MixedGraph	prepareSimpleMiic_ ()
	prepares the initial graph for Simple Miic
MixedGraph	prepareMiic_ ()
	prepares the initial graph for miic
MixedGraph	preparePC_ ()
	prepares the initial graph and independence test for PC
MixedGraph	prepareFCI_ ()
	prepares the initial graph and independence test for FCI
PriorType	getPriorType_ () const
	returns the type (as a string) of a given prior
void	createCorrectedMutualInformation_ ()
	create the Corrected Mutual Information instance for Miic

Static Protected Member Functions
static DatabaseTable	readFile_ (std::string_view filename, const std::vector< std::string > &missing_symbols)
	reads a file and returns a databaseVectInRam
static void	isCSVFileName_ (std::string_view filename)
	checks whether the extension of a CSV filename is correct

Protected Attributes
bool	inducedTypes_ {false}
	the policy for typing variables
ScoreType	scoreType_ {ScoreType::BDeu}
	the score selected for learning
Score *	score_ {nullptr}
	the score used
ParamEstimatorType	paramEstimatorType_ {ParamEstimatorType::ML}
	the type of the parameter estimator
bool	useEM_ {false}
	a Boolean indicating whether we should use EM for parameter learning or not
double	noiseEM_ {0.1}
	the noise factor (in (0,1)) used by EM for perturbing the CPT during init
CorrectedMutualInformation *	mutualInfo_ {nullptr}
	the selected correction for miic
BNLearnerPriorType	priorType_ {BNLearnerPriorType::NO_prior}
	the a priorselected for the score and parameters
Prior *	prior_ {nullptr}
	the prior used
NoPrior *	noPrior_ {nullptr}
double	priorWeight_ {1.0f}
	the weight of the prior
StructuralConstraintSliceOrder	constraintSliceOrder_
	the constraint for 2TBNs
StructuralConstraintTotalOrder	constraintTotalOrder_
	the total order ing constraint
StructuralConstraintIndegree	constraintIndegree_
	the constraint for indegrees
StructuralConstraintTabuList	constraintTabuList_
	the constraint for tabu lists
StructuralConstraintForbiddenArcs	constraintForbiddenArcs_
	the constraint on forbidden arcs
StructuralConstraintPossibleEdges	constraintPossibleEdges_
	the constraint on possible Edges
StructuralConstraintMandatoryArcs	constraintMandatoryArcs_
	the constraint on mandatory arcs
StructuralConstraintNoParentNodes	constraintNoParentNodes_
	the constraint on no parent nodes
StructuralConstraintNoChildrenNodes	constraintNoChildrenNodes_
	the constraint on no children nodes
AlgoType	selectedAlgo_ {AlgoType::MIIC}
	the selected learning algorithm
bool	allowArcAdditions_ {true}
	whether we allow or not arc additions during learning
bool	allowArcDeletions_ {true}
	whether we allow or not arc deletions during learning
bool	allowArcReversals_ {true}
	whether we allow or not arc reversals during learning
bool	allowArcTriangleDeletions_ {true}
	whether we allow or not arc deletions during learning
K2	algoK2_
	the K2 algorithm
SimpleMiic	algoSimpleMiic_
	the MIIC algorithm
Miic	algoMiic_
	the Constraint MIIC algorithm
CorrectedMutualInformation::KModeTypes	kmodeMiic_
	the penalty used in MIIC
gum::learning::PC	algoPC_
	the PC algorithm
IndepTestType	indepTestTypePC_ {IndepTestType::Chi2}
IndependenceTest *	indepTestPC_ {nullptr}
	owned independence test object for PC (rebuilt before each learn call)
double	alphaPc_ {0.05}
	PC parameters.
bool	stablePc_ {true}
Size	maxCondSetSizePc_ {Size(-1)}
bool	sortedUCPc_ {false}
gum::learning::FCI	algoFCI_
	the FCI algorithm
IndepTestType	indepTestTypeFCI_ {IndepTestType::Chi2}
	independence test type for FCI (reuses IndepTestType defined above)
IndependenceTest *	indepTestFCI_ {nullptr}
	owned independence test object for FCI (rebuilt before each learn call)
double	alphaFci_ {0.05}
	FCI parameters.
Size	maxPathLengthFci_ {Size(-1)}
bool	exhaustiveSepSetFci_ {false}
DAG2BNLearner	dag2BN_
	the parametric EM
GreedyHillClimbing	greedyHillClimbing_
	the greedy hill climbing algorithm
GreedyHillClimbing	extendedGreedyHillClimbing_
	the extended greedy hill climbing
GreedyThickThinning	greedyThickThinning_
	the greedy thick-thinning algorithm
LocalSearchWithTabuList	localSearchWithTabuList_
	the local search with tabu list algorithm
Database	scoreDatabase_
	the database to be used by the scores and parameter estimators
std::vector< std::pair< std::size_t, std::size_t > >	ranges_
	the set of rows' ranges within the database in which learning is done
Database *	priorDatabase_ {nullptr}
	the database used by the Dirichlet a priori
std::string	priorDbname_
	the filename for the Dirichlet a priori, if any
DAG	initialDag_
	an initial DAG given to learners
std::string	filename_ {"-"}
	the filename database
Size	nbDecreasingChanges_ {2}
const ApproximationScheme *	currentAlgorithm_ {nullptr}

Private Attributes
Size	_nb_threads_ {0}
	the max number of threads used by the class

Detailed Description

A pack of learning algorithms that can easily be used.

The pack currently contains K2, GreedyHillClimbing and LocalSearchWithTabuList also miic

Definition at line 104 of file IBNLearner.h.

Member Enumeration Documentation

◆ AlgoType

enum class gum::learning::IBNLearner::AlgoType

strong

an enumeration to select easily the learning algorithm to use

Enumerator
K2
GREEDY_HILL_CLIMBING
LOCAL_SEARCH_WITH_TABU_LIST
MIIC
PC
FCI
EXTENDED_GREEDY_HILL_CLIMBING
GREEDY_THICK_THINNING

Definition at line 123 of file IBNLearner.h.

                        {
      K2,
      GREEDY_HILL_CLIMBING,
      LOCAL_SEARCH_WITH_TABU_LIST,
      MIIC,
      PC,
      FCI,
      EXTENDED_GREEDY_HILL_CLIMBING,
      GREEDY_THICK_THINNING
    };

◆ 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 87 of file IApproximationSchemeConfiguration.h.

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

◆ BNLearnerPriorType

enum class gum::learning::IBNLearner::BNLearnerPriorType

strong

an enumeration to select the prior

Enumerator
NO_prior
SMOOTHING
DIRICHLET_FROM_DATABASE
DIRICHLET_FROM_BAYESNET
BDEU

Definition at line 114 of file IBNLearner.h.

                                  {
      NO_prior,
      SMOOTHING,
      DIRICHLET_FROM_DATABASE,
      DIRICHLET_FROM_BAYESNET,
      BDEU
    };

◆ IndepTestType

enum class gum::learning::IBNLearner::IndepTestType

strongprotected

independence test type for PC

Enumerator
Chi2
G2

Definition at line 1209 of file IBNLearner.h.

1209{ Chi2, G2 };

◆ ParamEstimatorType

enum class gum::learning::IBNLearner::ParamEstimatorType

strong

an enumeration to select the type of parameter estimation we shall apply

Enumerator
ML

Definition at line 111 of file IBNLearner.h.

111{ ML };

◆ ScoreType

enum class gum::learning::IBNLearner::ScoreType

strong

an enumeration enabling to select easily the score we wish to use

Enumerator
AIC
BD
BDeu
BIC
fNML
K2
LOG2LIKELIHOOD
MDL

Definition at line 107 of file IBNLearner.h.

107{ AIC, BD, BDeu, BIC, fNML, K2, LOG2LIKELIHOOD, MDL };

Constructor & Destructor Documentation

◆ IBNLearner() [1/5]

gum::learning::IBNLearner::IBNLearner	(	std::string_view	filename,
		const std::vector< std::string > &	missingSymbols,
		bool	induceTypes = true )

read the database file for the score / parameter estimation and var names

Parameters

filename	the name of a CSV file containing the dataset
missing_symbols	the set of symbols in the CSV that should be interpreted as missing values
induceTypes	when some columns of the dataset have only numerical values, it is certainly be better to tag them as corresponding to integer, range or continuous variables. By setting induceTypes to true (default), this is precisely what the BNLearner will do. If inducedTypes is false, all the values in the dataset are interpreted as "labels", i.e., as categorical values.

Definition at line 200 of file IBNLearner.cpp.

                                                                        :
      inducedTypes_(induceTypes), scoreDatabase_(filename, missing_symbols, induceTypes),
      filename_(filename) {
    noPrior_ = new NoPrior(scoreDatabase_.databaseTable());
 
    GUM_CONSTRUCTOR(IBNLearner)
  }

References IBNLearner(), filename_, inducedTypes_, noPrior_, and scoreDatabase_.

Referenced by gum::learning::IBNLearner::Database::Database(), IBNLearner(), IBNLearner(), IBNLearner(), IBNLearner(), IBNLearner(), ~IBNLearner(), gum::learning::BNLearner< GUM_SCALAR >::EMsetPeriodSize(), operator=(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IBNLearner() [2/5]

gum::learning::IBNLearner::IBNLearner ( const DatabaseTable & db )

explicit

read the database file for the score / parameter estimation and var names

Parameters

filename	the name of a CSV file containing the dataset
missing_symbols	the set of symbols in the CSV that should be interpreted as missing values
induceTypes	when some columns of the dataset have only numerical values, it is certainly be better to tag them as corresponding to integer, range or continuous variables. By setting induceTypes to true (default), this is precisely what the BNLearner will do. If inducedTypes is false, all the values in the dataset are interpreted as "labels", i.e., as categorical values.

Definition at line 210 of file IBNLearner.cpp.

                                                : scoreDatabase_(db) {
    noPrior_ = new NoPrior(scoreDatabase_.databaseTable());
    GUM_CONSTRUCTOR(IBNLearner)
  }

References IBNLearner(), noPrior_, and scoreDatabase_.

Here is the call graph for this function:

◆ IBNLearner() [3/5]

template<GUM_Numeric GUM_SCALAR>

gum::learning::IBNLearner::IBNLearner	(	std::string_view	filename,
		const gum::BayesNet< GUM_SCALAR > &	src,
		const std::vector< std::string > &	missing_symbols )

read the database file for the score / parameter estimation and var names

Parameters

filename	The file to learn from.
src	indicate for some nodes (not necessarily all the nodes of the BN) which modalities they should have and in which order these modalities should be stored into the nodes. For instance, if modalities = { 1 -> {True, False, Big} }, then the node of id 1 in the BN will have 3 modalities, the first one being True, the second one being False, and the third bein Big. The modalities specified by the user will be considered as being exactly those of the variables of the BN (as a consequence, if we find other values in the database, an exception will be raised during learning).
missing_symbols	the set of symbols in the CSV that should be interpreted as missing values

Definition at line 101 of file IBNLearner_tpl.h.

                                                                         :
      scoreDatabase_(filename, bn, missing_symbols) {
    filename_     = filename;
    noPrior_      = new NoPrior(scoreDatabase_.databaseTable());
    inducedTypes_ = false;
    GUM_CONSTRUCTOR(IBNLearner);
  }

References IBNLearner(), filename_, inducedTypes_, noPrior_, and scoreDatabase_.

Here is the call graph for this function:

◆ IBNLearner() [4/5]

gum::learning::IBNLearner::IBNLearner ( const IBNLearner & from )

copy constructor

Definition at line 215 of file IBNLearner.cpp.

                                               :
      IApproximationSchemeConfiguration(from), ThreadNumberManager(from),
      inducedTypes_(from.inducedTypes_), scoreType_(from.scoreType_),
      paramEstimatorType_(from.paramEstimatorType_), useEM_(from.useEM_), noiseEM_(from.noiseEM_),
      priorType_(from.priorType_), priorWeight_(from.priorWeight_),
      constraintSliceOrder_(from.constraintSliceOrder_),
      constraintIndegree_(from.constraintIndegree_), constraintTabuList_(from.constraintTabuList_),
      constraintForbiddenArcs_(from.constraintForbiddenArcs_),
      constraintMandatoryArcs_(from.constraintMandatoryArcs_),
      constraintNoParentNodes_(from.constraintNoParentNodes_),
      constraintNoChildrenNodes_(from.constraintNoChildrenNodes_),
      selectedAlgo_(from.selectedAlgo_), algoK2_(from.algoK2_),
      algoSimpleMiic_(from.algoSimpleMiic_), algoMiic_(from.algoMiic_), kmodeMiic_(from.kmodeMiic_),
      dag2BN_(from.dag2BN_), greedyHillClimbing_(from.greedyHillClimbing_),
      localSearchWithTabuList_(from.localSearchWithTabuList_), scoreDatabase_(from.scoreDatabase_),
      ranges_(from.ranges_), priorDbname_(from.priorDbname_), initialDag_(from.initialDag_),
      filename_(from.filename_), nbDecreasingChanges_(from.nbDecreasingChanges_) {
    noPrior_ = new NoPrior(scoreDatabase_.databaseTable());
 
    GUM_CONS_CPY(IBNLearner)
  }

References gum::IApproximationSchemeConfiguration::IApproximationSchemeConfiguration(), IBNLearner(), gum::ThreadNumberManager::ThreadNumberManager(), algoK2_, algoMiic_, algoSimpleMiic_, constraintForbiddenArcs_, constraintIndegree_, constraintMandatoryArcs_, constraintNoChildrenNodes_, constraintNoParentNodes_, constraintSliceOrder_, constraintTabuList_, dag2BN_, filename_, greedyHillClimbing_, inducedTypes_, initialDag_, kmodeMiic_, localSearchWithTabuList_, nbDecreasingChanges_, noiseEM_, noPrior_, paramEstimatorType_, priorDbname_, priorType_, priorWeight_, ranges_, scoreDatabase_, scoreType_, selectedAlgo_, and useEM_.

Here is the call graph for this function:

◆ IBNLearner() [5/5]

gum::learning::IBNLearner::IBNLearner ( IBNLearner && from )

move constructor

Definition at line 237 of file IBNLearner.cpp.

                                          :
      ThreadNumberManager(std::move(from)), inducedTypes_(from.inducedTypes_),
      scoreType_(from.scoreType_), paramEstimatorType_(from.paramEstimatorType_),
      useEM_(from.useEM_), noiseEM_(from.noiseEM_), priorType_(from.priorType_),
      priorWeight_(from.priorWeight_), constraintSliceOrder_(std::move(from.constraintSliceOrder_)),
      constraintIndegree_(std::move(from.constraintIndegree_)),
      constraintTabuList_(std::move(from.constraintTabuList_)),
      constraintForbiddenArcs_(std::move(from.constraintForbiddenArcs_)),
      constraintMandatoryArcs_(std::move(from.constraintMandatoryArcs_)),
      constraintNoParentNodes_(std::move(from.constraintNoParentNodes_)),
      constraintNoChildrenNodes_(std::move(from.constraintNoChildrenNodes_)),
      selectedAlgo_(from.selectedAlgo_), algoK2_(std::move(from.algoK2_)),
      algoSimpleMiic_(std::move(from.algoSimpleMiic_)), algoMiic_(std::move(from.algoMiic_)),
      kmodeMiic_(from.kmodeMiic_), dag2BN_(std::move(from.dag2BN_)),
      greedyHillClimbing_(std::move(from.greedyHillClimbing_)),
      localSearchWithTabuList_(std::move(from.localSearchWithTabuList_)),
      scoreDatabase_(std::move(from.scoreDatabase_)), ranges_(std::move(from.ranges_)),
      priorDbname_(std::move(from.priorDbname_)), initialDag_(std::move(from.initialDag_)),
      filename_(std::move(from.filename_)),
      nbDecreasingChanges_(std::move(from.nbDecreasingChanges_)) {
    noPrior_ = new NoPrior(scoreDatabase_.databaseTable());
 
    GUM_CONS_MOV(IBNLearner)
  }

References IBNLearner(), gum::ThreadNumberManager::ThreadNumberManager(), algoK2_, algoMiic_, algoSimpleMiic_, constraintForbiddenArcs_, constraintIndegree_, constraintMandatoryArcs_, constraintNoChildrenNodes_, constraintNoParentNodes_, constraintSliceOrder_, constraintTabuList_, dag2BN_, filename_, greedyHillClimbing_, inducedTypes_, initialDag_, kmodeMiic_, localSearchWithTabuList_, nbDecreasingChanges_, noiseEM_, noPrior_, paramEstimatorType_, priorDbname_, priorType_, priorWeight_, ranges_, scoreDatabase_, scoreType_, selectedAlgo_, and useEM_.

Here is the call graph for this function:

◆ ~IBNLearner()

gum::learning::IBNLearner::~IBNLearner ( )

override

destructor

Definition at line 262 of file IBNLearner.cpp.

                          {
    if (score_) delete score_;
 
    if (prior_) delete prior_;
 
    if (noPrior_) delete noPrior_;
 
    if (priorDatabase_) delete priorDatabase_;
 
    if (mutualInfo_) delete mutualInfo_;
 
    if (indepTestPC_) delete indepTestPC_;
 
    if (indepTestFCI_) delete indepTestFCI_;
 
    GUM_DESTRUCTOR(IBNLearner)
  }

References IBNLearner(), indepTestFCI_, indepTestPC_, mutualInfo_, noPrior_, prior_, priorDatabase_, and score_.

Here is the call graph for this function:

Member Function Documentation

◆ _setPriorWeight_()

INLINE void gum::learning::IBNLearner::_setPriorWeight_ ( double weight )

protected

sets the prior weight

Definition at line 644 of file IBNLearner_inl.h.

                                                        {
    if (weight < 0) { GUM_ERROR(OutOfBounds, "the weight of the prior must be positive") }
 
    priorWeight_ = weight;
    checkScorePriorCompatibility();
  }

References checkScorePriorCompatibility(), GUM_ERROR, and priorWeight_.

Referenced by useBDeuPrior(), useDirichletPrior(), and useSmoothingPrior().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addForbiddenArc() [1/3]

INLINE void gum::learning::IBNLearner::addForbiddenArc ( const Arc & arc )

Definition at line 517 of file IBNLearner_inl.h.

517{ constraintForbiddenArcs_.addArc(arc); }

References constraintForbiddenArcs_.

Referenced by addForbiddenArc(), and addForbiddenArc().

Here is the caller graph for this function:

◆ addForbiddenArc() [2/3]

INLINE void gum::learning::IBNLearner::addForbiddenArc	(	NodeId	tail,
		NodeId	head )

Definition at line 525 of file IBNLearner_inl.h.

                                                                              {
    addForbiddenArc(Arc(tail, head));
  }

References addForbiddenArc().

Here is the call graph for this function:

◆ addForbiddenArc() [3/3]

INLINE void gum::learning::IBNLearner::addForbiddenArc	(	std::string_view	tail,
		std::string_view	head )

Definition at line 535 of file IBNLearner_inl.h.

                                                                                  {
    addForbiddenArc(Arc(idFromName(tail), idFromName(head)));
  }

References addForbiddenArc(), and idFromName().

Here is the call graph for this function:

◆ addMandatoryArc() [1/3]

INLINE void gum::learning::IBNLearner::addMandatoryArc ( const Arc & arc )

Definition at line 550 of file IBNLearner_inl.h.

550{ constraintMandatoryArcs_.addArc(arc); }

References constraintMandatoryArcs_.

Referenced by addMandatoryArc(), and addMandatoryArc().

Here is the caller graph for this function:

◆ addMandatoryArc() [2/3]

INLINE void gum::learning::IBNLearner::addMandatoryArc	(	NodeId	tail,
		NodeId	head )

Definition at line 598 of file IBNLearner_inl.h.

                                                                  {
    addMandatoryArc(Arc(tail, head));
  }

References addMandatoryArc().

Here is the call graph for this function:

◆ addMandatoryArc() [3/3]

INLINE void gum::learning::IBNLearner::addMandatoryArc	(	std::string_view	tail,
		std::string_view	head )

Definition at line 588 of file IBNLearner_inl.h.

                                                                                  {
    addMandatoryArc(Arc(idFromName(tail), idFromName(head)));
  }

References addMandatoryArc(), and idFromName().

Here is the call graph for this function:

◆ addNoChildrenNode() [1/2]

INLINE void gum::learning::IBNLearner::addNoChildrenNode ( NodeId node )

Definition at line 571 of file IBNLearner_inl.h.

                                                       {
    constraintNoChildrenNodes_.addNode(node);
  }

References constraintNoChildrenNodes_.

Referenced by addNoChildrenNode().

Here is the caller graph for this function:

◆ addNoChildrenNode() [2/2]

INLINE void gum::learning::IBNLearner::addNoChildrenNode ( std::string_view node )

Definition at line 575 of file IBNLearner_inl.h.

                                                               {
    addNoChildrenNode(idFromName(name));
  }

References addNoChildrenNode(), and idFromName().

Here is the call graph for this function:

◆ addNoParentNode() [1/2]

INLINE void gum::learning::IBNLearner::addNoParentNode ( NodeId node )

Definition at line 557 of file IBNLearner_inl.h.

557{ constraintNoParentNodes_.addNode(node); }

References constraintNoParentNodes_.

Referenced by addNoParentNode().

Here is the caller graph for this function:

◆ addNoParentNode() [2/2]

INLINE void gum::learning::IBNLearner::addNoParentNode ( std::string_view node )

Definition at line 559 of file IBNLearner_inl.h.

                                                             {
    addNoParentNode(idFromName(name));
  }

References addNoParentNode(), and idFromName().

Here is the call graph for this function:

◆ addPossibleEdge() [1/3]

INLINE void gum::learning::IBNLearner::addPossibleEdge ( const Edge & edge )

Definition at line 482 of file IBNLearner_inl.h.

                                                          {
    constraintPossibleEdges_.addEdge(edge);
  }

References constraintPossibleEdges_.

Referenced by addPossibleEdge(), and addPossibleEdge().

Here is the caller graph for this function:

◆ addPossibleEdge() [2/3]

INLINE void gum::learning::IBNLearner::addPossibleEdge	(	NodeId	tail,
		NodeId	head )

Definition at line 492 of file IBNLearner_inl.h.

                                                                              {
    addPossibleEdge(Edge(tail, head));
  }

References addPossibleEdge().

Here is the call graph for this function:

◆ addPossibleEdge() [3/3]

INLINE void gum::learning::IBNLearner::addPossibleEdge	(	std::string_view	tail,
		std::string_view	head )

Definition at line 502 of file IBNLearner_inl.h.

                                                                                  {
    addPossibleEdge(Edge(idFromName(tail), idFromName(head)));
  }

References addPossibleEdge(), and idFromName().

Here is the call graph for this function:

◆ allowArcAdditions()

INLINE void gum::learning::IBNLearner::allowArcAdditions ( bool allow = true )

allow (true)/forbid (false) to add arcs during learning.

This affects only Extended Greedy Hill Climbing and Local Search with Tabu List. Greedy Hill Climbing and K2 always allow arc additions.

Definition at line 454 of file IBNLearner_inl.h.

454{ allowArcAdditions_ = allow; }

gum::learning::IBNLearner::allowArcAdditions_

bool allowArcAdditions_

whether we allow or not arc additions during learning

Definition IBNLearner.h:1181

References allowArcAdditions_.

◆ allowArcDeletions()

INLINE void gum::learning::IBNLearner::allowArcDeletions ( bool allow = true )

allow (true)/forbid (false) to delete arcs during learning.

This affects only Extended Greedy Hill Climbing and Local Search with Tabu List. Greedy Hill Climbing always allows arc deletions while K2 always forbid them. If you wish a K2-like algorithm that enables arc deletions, use and extended greedy hill climbing combined with a TotalOrder constraint.

Definition at line 457 of file IBNLearner_inl.h.

457{ allowArcDeletions_ = allow; }

gum::learning::IBNLearner::allowArcDeletions_

bool allowArcDeletions_

whether we allow or not arc deletions during learning

Definition IBNLearner.h:1184

References allowArcDeletions_.

◆ allowArcReversals()

INLINE void gum::learning::IBNLearner::allowArcReversals ( bool allow = true )

allow (true)/forbid (false) to reverse arcs during learning.

This affects only Extended Greedy Hill Climbing and Local Search with Tabu List. Greedy Hill Climbing always allows arc reversals while K2 always forbid them (due to its total ordering constraint).

Definition at line 460 of file IBNLearner_inl.h.

460{ allowArcReversals_ = allow; }

gum::learning::IBNLearner::allowArcReversals_

bool allowArcReversals_

whether we allow or not arc reversals during learning

Definition IBNLearner.h:1187

References allowArcReversals_.

◆ allowArcTriangleDeletions()

INLINE void gum::learning::IBNLearner::allowArcTriangleDeletions ( bool allow = true )

allow (true)/forbid (false) to delete arc triangles during learning.

This affects only Extended Greedy Hill Climbing and Local Search with Tabu List. Greedy Hill Climbing and K2 always forbid arc triangle deletions.

Definition at line 463 of file IBNLearner_inl.h.

                                                              {
    allowArcTriangleDeletions_ = allow;
  }

References allowArcTriangleDeletions_.

◆ checkScorePriorCompatibility()

std::string gum::learning::IBNLearner::checkScorePriorCompatibility ( ) const

checks whether the current score and prior are compatible

Returns: a non empty string if the prior is somehow compatible with the score.

Definition at line 1270 of file IBNLearner.cpp.

                                                           {
    if (this->isConstraintBased()) return "";
 
    const auto prior = getPriorType_();
 
    switch (scoreType_) {
      using enum gum::learning::IBNLearner::ScoreType;
      case AIC : return ScoreAIC::isPriorCompatible(prior, priorWeight_);
 
      case BD : return ScoreBD::isPriorCompatible(prior, priorWeight_);
 
      case BDeu : return ScoreBDeu::isPriorCompatible(prior, priorWeight_);
 
      case BIC : return ScoreBIC::isPriorCompatible(prior, priorWeight_);
 
      case fNML : return ScorefNML::isPriorCompatible(prior, priorWeight_);
 
      case K2 : return ScoreK2::isPriorCompatible(prior, priorWeight_);
 
      case LOG2LIKELIHOOD : return ScoreLog2Likelihood::isPriorCompatible(prior, priorWeight_);
 
      case MDL : return ScoreMDL::isPriorCompatible(prior, priorWeight_);
 
      default : return "IBNLearner does not support yet this score";
    }
  }

References AIC, BD, BDeu, BIC, fNML, getPriorType_(), isConstraintBased(), gum::learning::ScoreAIC::isPriorCompatible(), gum::learning::ScoreBD::isPriorCompatible(), gum::learning::ScoreBDeu::isPriorCompatible(), gum::learning::ScoreBIC::isPriorCompatible(), gum::learning::ScorefNML::isPriorCompatible(), gum::learning::ScoreK2::isPriorCompatible(), gum::learning::ScoreLog2Likelihood::isPriorCompatible(), LOG2LIKELIHOOD, MDL, priorWeight_, and scoreType_.

Referenced by _setPriorWeight_(), useBDeuPrior(), useDirichletPrior(), useNoPrior(), useScoreAIC(), useScoreBD(), useScoreBDeu(), useScoreBIC(), useScorefNML(), useScoreK2(), useScoreLog2Likelihood(), useScoreMDL(), and useSmoothingPrior().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ chi2() [1/2]

std::pair< double, double > gum::learning::IBNLearner::chi2	(	NodeId	id1,
		NodeId	id2,
		const std::vector< NodeId > &	knowing = {} )

Return the <statistic,pvalue> pair for chi2 test in the database.

Parameters

id1	first variable
id2	second variable
knowing	list of observed variables

Returns: a std::pair<double,double>

Definition at line 1338 of file IBNLearner.cpp.

                                                                                             {
    createPrior_();
    gum::learning::IndepTestChi2 chi2score(scoreDatabase_.parser(), *prior_, databaseRanges());
 
    return chi2score.statistics(id1, id2, knowing);
  }

References createPrior_(), databaseRanges(), prior_, scoreDatabase_, and gum::learning::IndepTestChi2::statistics().

Referenced by chi2().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ chi2() [2/2]

std::pair< double, double > gum::learning::IBNLearner::chi2	(	std::string_view	name1,
		std::string_view	name2,
		const std::vector< std::string > &	knowing = {} )

Return the <statistic,pvalue> pair for the BNLearner.

Parameters

id1	first variable
id2	second variable
knowing	list of observed variables

Returns: a std::pair<double,double>

Definition at line 1345 of file IBNLearner.cpp.

                                                                                      {
    std::vector< NodeId > knowingIds;
    std::transform(knowing.begin(),
                   knowing.end(),
                   std::back_inserter(knowingIds),
                   [this](const std::string& c) { return this->idFromName(c); });
    return chi2(idFromName(name1), idFromName(name2), knowingIds);
  }

References chi2(), and idFromName().

Here is the call graph for this function:

◆ clearDatabaseRanges()

INLINE void gum::learning::IBNLearner::clearDatabaseRanges ( )

reset the ranges to the one range corresponding to the whole database

Definition at line 729 of file IBNLearner_inl.h.

729{ ranges_.clear(); }

References ranges_.

◆ correctedMutualInformation() [1/2]

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

Return the mutual information of id1 and id2 in the base, conditioned by knowing for the BNLearner.

Warning: This function returns the mutual information corrected using defined correction (useNML, useMDL) and prior

Parameters

id1	nodeId
id2	nodeId
knowing	an optional vector of conditioning NodeIds

Returns: a double

Definition at line 1403 of file IBNLearner.cpp.

                                                                                    {
    createPrior_();
    gum::learning::CorrectedMutualInformation cmi(scoreDatabase_.parser(),
                                                  *prior_,
                                                  databaseRanges());
 
    switch (kmodeMiic_) {
      using enum gum::learning::CorrectedMutualInformation::KModeTypes;
      case MDL : cmi.useMDL(); break;
 
      case NML : cmi.useNML(); break;
 
      case NoCorr : cmi.useNoCorr(); break;
 
      default :
        GUM_ERROR(NotImplementedYet,
                  "The BNLearner's corrected mutual information class does "
                      << "not implement yet this correction : " << int(kmodeMiic_))
    }
    if (knowing.size() == (Size)0) return cmi.score(id1, id2) / scoreDatabase_.weight();
    else return cmi.score(id1, id2, knowing) / scoreDatabase_.weight();
  }

References createPrior_(), databaseRanges(), GUM_ERROR, kmodeMiic_, MDL, prior_, gum::learning::CorrectedMutualInformation::score(), scoreDatabase_, gum::learning::CorrectedMutualInformation::useMDL(), gum::learning::CorrectedMutualInformation::useNML(), and gum::learning::CorrectedMutualInformation::useNoCorr().

Referenced by correctedMutualInformation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ correctedMutualInformation() [2/2]

double gum::learning::IBNLearner::correctedMutualInformation	(	std::string_view	var1,
		std::string_view	var2,
		const std::vector< std::string > &	knowing = {} )

Return the mutual information of var1 and var2 in the base, conditioned by knowing for the BNLearner.

Warning: This function returns the mutual information corrected using defined correction (useNML, useMDL) and prior; This function returns the bare mutual information (without prior or correction)

Parameters

var1	name of a row
var2	name of a row
knowing	an optional vector of conditioning rows

Returns: a double

Definition at line 1428 of file IBNLearner.cpp.

                                                                                       {
    std::vector< NodeId > knowingIds;
 
    auto mapper = [this](const std::string& c) { return this->idFromName(c); };
 
    std::transform(knowing.begin(), knowing.end(), std::back_inserter(knowingIds), mapper);
 
    return correctedMutualInformation(this->idFromName(var1), this->idFromName(var2), knowingIds);
  }

References correctedMutualInformation(), and idFromName().

Here is the call graph for this function:

◆ createCorrectedMutualInformation_()

void gum::learning::IBNLearner::createCorrectedMutualInformation_ ( )

protected

create the Corrected Mutual Information instance for Miic

Definition at line 966 of file IBNLearner.cpp.

                                                     {
    if (mutualInfo_ != nullptr) delete mutualInfo_;
 
    mutualInfo_ = new CorrectedMutualInformation(scoreDatabase_.parser(),
                                                 *noPrior_,
                                                 ranges_,
                                                 scoreDatabase_.nodeId2Columns());
    switch (kmodeMiic_) {
      using enum CorrectedMutualInformation::KModeTypes;
      case MDL : mutualInfo_->useMDL(); break;
      case NML : mutualInfo_->useNML(); break;
      case NoCorr : mutualInfo_->useNoCorr(); break;
      default :
        GUM_ERROR(NotImplementedYet,
                  "The BNLearner's corrected mutual information class does "
                      << "not implement yet this correction : " << int(kmodeMiic_))
    }
  }

References GUM_ERROR, kmodeMiic_, MDL, mutualInfo_, noPrior_, ranges_, and scoreDatabase_.

Referenced by prepareMiic_().

Here is the caller graph for this function:

◆ createParamEstimator_()

ParamEstimator * gum::learning::IBNLearner::createParamEstimator_	(	const DBRowGeneratorParser &	parser,
		bool	take_into_account_score = true )

protected

create the parameter estimator used for learning

Definition at line 544 of file IBNLearner.cpp.

                                                                                  {
    ParamEstimator* param_estimator = nullptr;
 
    // create the new estimator
    switch (paramEstimatorType_) {
      case ParamEstimatorType::ML :
        if (take_into_account_score && (score_ != nullptr)) {
          param_estimator = new ParamEstimatorML(parser,
                                                 *prior_,
                                                 score_->internalPrior(),
                                                 ranges_,
                                                 scoreDatabase_.nodeId2Columns());
        } else {
          param_estimator = new ParamEstimatorML(parser,
                                                 *prior_,
                                                 *noPrior_,
                                                 ranges_,
                                                 scoreDatabase_.nodeId2Columns());
        }
 
        break;
 
      default :
        GUM_ERROR(OperationNotAllowed,
                  "IBNLearner does not support " << "yet this parameter estimator")
    }
 
    // assign the number of threads
    param_estimator->setNumberOfThreads(
        this->isGumNumberOfThreadsOverriden() ? this->getNumberOfThreads() : 0);
 
    // assign the set of ranges
    param_estimator->setRanges(ranges_);
 
    return param_estimator;
  }

References gum::ThreadNumberManager::getNumberOfThreads(), GUM_ERROR, gum::ThreadNumberManager::isGumNumberOfThreadsOverriden(), ML, noPrior_, paramEstimatorType_, prior_, ranges_, score_, scoreDatabase_, gum::learning::ParamEstimator::setNumberOfThreads(), and gum::learning::ParamEstimator::setRanges().

Here is the call graph for this function:

◆ createPrior_()

virtual void gum::learning::IBNLearner::createPrior_ ( )

protectedpure virtual

create the prior used for learning

Implemented in gum::learning::BNLearner< GUM_SCALAR >.

Referenced by chi2(), correctedMutualInformation(), G2(), learnDAG(), logLikelihood(), rawPseudoCount(), and score().

Here is the caller graph for this function:

◆ createScore_()

void gum::learning::IBNLearner::createScore_ ( )

protected

create the score used for learning

Definition at line 471 of file IBNLearner.cpp.

                                {
    // first, save the old score, to be delete if everything is ok
    Score* old_score = score_;
 
    // create the new scoring function
    switch (scoreType_) {
      case ScoreType::AIC :
        score_ = new ScoreAIC(scoreDatabase_.parser(),
                              *prior_,
                              ranges_,
                              scoreDatabase_.nodeId2Columns());
        break;
 
      case ScoreType::BD :
        score_ = new ScoreBD(scoreDatabase_.parser(),
                             *prior_,
                             ranges_,
                             scoreDatabase_.nodeId2Columns());
        break;
 
      case ScoreType::BDeu :
        score_ = new ScoreBDeu(scoreDatabase_.parser(),
                               *prior_,
                               ranges_,
                               scoreDatabase_.nodeId2Columns());
        break;
 
      case ScoreType::BIC :
        score_ = new ScoreBIC(scoreDatabase_.parser(),
                              *prior_,
                              ranges_,
                              scoreDatabase_.nodeId2Columns());
        break;
 
      case ScoreType::fNML :
        score_ = new ScorefNML(scoreDatabase_.parser(),
                               *prior_,
                               ranges_,
                               scoreDatabase_.nodeId2Columns());
        break;
 
      case ScoreType::K2 :
        score_ = new ScoreK2(scoreDatabase_.parser(),
                             *prior_,
                             ranges_,
                             scoreDatabase_.nodeId2Columns());
        break;
 
      case ScoreType::LOG2LIKELIHOOD :
        score_ = new ScoreLog2Likelihood(scoreDatabase_.parser(),
                                         *prior_,
                                         ranges_,
                                         scoreDatabase_.nodeId2Columns());
        break;
 
      case ScoreType::MDL :
        score_ = new ScoreMDL(scoreDatabase_.parser(),
                              *prior_,
                              ranges_,
                              scoreDatabase_.nodeId2Columns());
        break;
 
      default : GUM_ERROR(OperationNotAllowed, "IBNLearner does not support yet this score")
    }
 
    // remove the old score, if any
    if (old_score != nullptr) delete old_score;
 
    // assign the number of threads
    score_->setNumberOfThreads(this->isGumNumberOfThreadsOverriden() ? this->getNumberOfThreads()
                                                                     : 0);
  }

References AIC, BD, BDeu, BIC, fNML, gum::ThreadNumberManager::getNumberOfThreads(), GUM_ERROR, gum::ThreadNumberManager::isGumNumberOfThreadsOverriden(), K2, LOG2LIKELIHOOD, MDL, prior_, ranges_, score_, scoreDatabase_, and scoreType_.

Referenced by learnDAG(), and score().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ currentTime()

INLINE double gum::learning::IBNLearner::currentTime ( ) const

overridevirtual

get the current running time in second (double)

Implements gum::IApproximationSchemeConfiguration.

Definition at line 890 of file IBNLearner_inl.h.

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

References currentAlgorithm_, and GUM_ERROR.

◆ database()

INLINE const DatabaseTable & gum::learning::IBNLearner::database ( ) const

returns the database used by the BNLearner

Definition at line 732 of file IBNLearner_inl.h.

                                                         {
    return scoreDatabase_.databaseTable();
  }

References scoreDatabase_.

Referenced by readFile_().

Here is the caller graph for this function:

◆ databaseRanges()

INLINE const std::vector< std::pair< std::size_t, std::size_t > > & gum::learning::IBNLearner::databaseRanges ( ) const

returns the current database rows' ranges used for learning

Returns: The method returns a vector of pairs [Xi,Yi) of indices of rows in the database. The learning is performed on these set of rows.

Warning: an empty set of ranges means the whole database.

Definition at line 724 of file IBNLearner_inl.h.

                                                {
    return ranges_;
  }

References ranges_.

Referenced by chi2(), correctedMutualInformation(), G2(), logLikelihood(), mutualInformation(), and rawPseudoCount().

Here is the caller graph for this function:

◆ databaseWeight()

INLINE double gum::learning::IBNLearner::databaseWeight ( ) const

returns the weight of the whole database

Definition at line 161 of file IBNLearner_inl.h.

161{ return scoreDatabase_.weight(); }

References scoreDatabase_.

◆ disableEpsilon()

INLINE void gum::learning::IBNLearner::disableEpsilon ( )

overridevirtual

Disable stopping criterion on epsilon.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 797 of file IBNLearner_inl.h.

                                         {
    algoK2_.approximationScheme().disableEpsilon();
    greedyHillClimbing_.disableEpsilon();
    localSearchWithTabuList_.disableEpsilon();
    dag2BN_.disableEpsilon();
  }

References algoK2_, dag2BN_, greedyHillClimbing_, and localSearchWithTabuList_.

◆ disableMaxIter()

INLINE void gum::learning::IBNLearner::disableMaxIter ( )

overridevirtual

Disable stopping criterion on max iterations.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 859 of file IBNLearner_inl.h.

                                         {
    algoK2_.approximationScheme().disableMaxIter();
    greedyHillClimbing_.disableMaxIter();
    localSearchWithTabuList_.disableMaxIter();
    dag2BN_.disableMaxIter();
  }

References algoK2_, dag2BN_, greedyHillClimbing_, and localSearchWithTabuList_.

◆ disableMaxTime()

INLINE void gum::learning::IBNLearner::disableMaxTime ( )

overridevirtual

Disable stopping criterion on timeout.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 895 of file IBNLearner_inl.h.

                                         {
    algoK2_.approximationScheme().disableMaxTime();
    greedyHillClimbing_.disableMaxTime();
    localSearchWithTabuList_.disableMaxTime();
    dag2BN_.disableMaxTime();
  }

References algoK2_, dag2BN_, greedyHillClimbing_, and localSearchWithTabuList_.

◆ disableMinEpsilonRate()

INLINE void gum::learning::IBNLearner::disableMinEpsilonRate ( )

overridevirtual

Disable stopping criterion on epsilon rate.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 828 of file IBNLearner_inl.h.

                                                {
    algoK2_.approximationScheme().disableMinEpsilonRate();
    greedyHillClimbing_.disableMinEpsilonRate();
    localSearchWithTabuList_.disableMinEpsilonRate();
    dag2BN_.disableMinEpsilonRate();
  }

References algoK2_, dag2BN_, greedyHillClimbing_, and localSearchWithTabuList_.

◆ distributeProgress()

INLINE void gum::learning::IBNLearner::distributeProgress	(	const ApproximationScheme *	approximationScheme,
		Size	pourcent,
		double	error,
		double	time )

{@ /// distribute signals

Definition at line 771 of file IBNLearner_inl.h.

                                                                              {
    setCurrentApproximationScheme(approximationScheme);
    if (onProgress.hasListener()) GUM_EMIT3(onProgress, pourcent, error, time);
  }

References GUM_EMIT3, gum::IApproximationSchemeConfiguration::onProgress, and setCurrentApproximationScheme().

Here is the call graph for this function:

◆ distributeStop()

INLINE void gum::learning::IBNLearner::distributeStop	(	const ApproximationScheme *	approximationScheme,
		std::string_view	message )

distribute signals

Definition at line 779 of file IBNLearner_inl.h.

                                                                           {
    setCurrentApproximationScheme(approximationScheme);
    if (onStop.hasListener()) GUM_EMIT1(onStop, message);
  }

References GUM_EMIT1, gum::IApproximationSchemeConfiguration::onStop, and setCurrentApproximationScheme().

Here is the call graph for this function:

◆ domainSize() [1/2]

INLINE Size gum::learning::IBNLearner::domainSize ( NodeId var ) const

learn a structure from a file (must have read the db before)

Definition at line 715 of file IBNLearner_inl.h.

715{ return scoreDatabase_.domainSizes()[var]; }

References scoreDatabase_.

◆ domainSize() [2/2]

INLINE Size gum::learning::IBNLearner::domainSize ( std::string_view var ) const

learn a structure from a file (must have read the db before)

Definition at line 718 of file IBNLearner_inl.h.

                                                             {
    return scoreDatabase_.domainSizes()[idFromName(var)];
  }

References idFromName(), and scoreDatabase_.

Here is the call graph for this function:

◆ domainSizes()

INLINE const std::vector< std::size_t > & gum::learning::IBNLearner::domainSizes ( ) const

returns the domain sizes of the variables in the database

Definition at line 710 of file IBNLearner_inl.h.

                                                                     {
    return scoreDatabase_.domainSizes();
  }

References scoreDatabase_.

◆ EM()

INLINE EMApproximationScheme & gum::learning::IBNLearner::EM ( )

returns the EM parameter learning approximation scheme if EM is enabled

returns the EM parameter learning approximation scheme

Returns: returns the EM parameter learning approximation scheme if EM is enabled, else if raises a NotFound exception. The scheme can then be subsequently used to fine-tune the EM algorithm, e.g., by setting its max time or max number of iterations.

Exceptions

NotFound is raised if EM() is called while the EM algorithm has not been enabled by useEM(), useEMWithDiffCriterion() or useEMWithRateCriterion().

Definition at line 436 of file IBNLearner_inl.h.

                                               {
    if (useEM_) return dag2BN_;
    else GUM_ERROR(NotFound, "EM is currently forbidden. Please enable it with useEM()")
  }

References dag2BN_, GUM_ERROR, and useEM_.

◆ EMCurrentTime()

INLINE double gum::learning::IBNLearner::EMCurrentTime ( ) const

get the current running time in second (double)

Definition at line 992 of file IBNLearner_inl.h.

992{ return dag2BN_.currentTime(); }

References dag2BN_.

◆ EMdisableEpsilon()

INLINE void gum::learning::IBNLearner::EMdisableEpsilon ( )

Disable the min log-likelihood diff stopping criterion for EM.

Definition at line 960 of file IBNLearner_inl.h.

960{ dag2BN_.disableEpsilon(); }

References dag2BN_.

◆ EMdisableMaxIter()

INLINE void gum::learning::IBNLearner::EMdisableMaxIter ( )

Disable stopping criterion on max iterations.

Definition at line 982 of file IBNLearner_inl.h.

982{ dag2BN_.disableMaxIter(); }

References dag2BN_.

◆ EMdisableMaxTime()

INLINE void gum::learning::IBNLearner::EMdisableMaxTime ( )

Disable EM's timeout stopping criterion.

Definition at line 994 of file IBNLearner_inl.h.

994{ dag2BN_.disableMaxTime(); }

References dag2BN_.

◆ EMdisableMinEpsilonRate()

INLINE void gum::learning::IBNLearner::EMdisableMinEpsilonRate ( )

Disable the log-likelihood evolution rate stopping criterion.

Definition at line 970 of file IBNLearner_inl.h.

970{ dag2BN_.disableMinEpsilonRate(); }

References dag2BN_.

◆ EMenableEpsilon()

INLINE void gum::learning::IBNLearner::EMenableEpsilon ( )

Enable the log-likelihood min diff stopping criterion in EM.

Warning: setting this stopping criterion disables the min rate criterion (if it was enabled)

Definition at line 962 of file IBNLearner_inl.h.

962{ dag2BN_.enableEpsilon(); }

References dag2BN_.

◆ EMenableMaxIter()

INLINE void gum::learning::IBNLearner::EMenableMaxIter ( )

Enable stopping criterion on max iterations.

Definition at line 984 of file IBNLearner_inl.h.

984{ dag2BN_.enableMaxIter(); }

References dag2BN_.

◆ EMenableMaxTime()

INLINE void gum::learning::IBNLearner::EMenableMaxTime ( )

sets the stopping criterion of EM as being the minimal difference between two consecutive log-likelihoods

Parameters

eps	the log-likelihood difference below which EM stops its iterations

Warning: setting this stopping criterion disables the min rate criterion (if it was enabled)

Exceptions

OutOfBounds if eps <= 0

Definition at line 996 of file IBNLearner_inl.h.

996{ dag2BN_.enableMaxTime(); }

References dag2BN_.

◆ EMenableMinEpsilonRate()

INLINE void gum::learning::IBNLearner::EMenableMinEpsilonRate ( )

Enable the log-likelihood evolution rate stopping criterion.

Warning: setting this stopping criterion disables the min diff criterion (if it was enabled)

Definition at line 972 of file IBNLearner_inl.h.

972{ dag2BN_.enableMinEpsilonRate(); }

References dag2BN_.

◆ EMEpsilon()

INLINE double gum::learning::IBNLearner::EMEpsilon ( ) const

Get the value of EM's min diff epsilon.

Get the value of EM's min diff epsilon

Warning: Note that this value is not taken into account unless the min diff criterion is enabled

Definition at line 958 of file IBNLearner_inl.h.

958{ return dag2BN_.epsilon(); }

References dag2BN_.

◆ EMHistory()

INLINE const std::vector< double > & gum::learning::IBNLearner::EMHistory ( ) const

returns the history of the last EM execution

Warning: to activate the history recording, EM's verbosity must be set to true

Definition at line 1015 of file IBNLearner_inl.h.

1015{ return dag2BN_.history(); }

References dag2BN_.

◆ EMisEnabledEpsilon()

INLINE bool gum::learning::IBNLearner::EMisEnabledEpsilon ( ) const

return true if EM's stopping criterion is the log-likelihood min diff

Definition at line 964 of file IBNLearner_inl.h.

964{ return dag2BN_.isEnabledEpsilon(); }

References dag2BN_.

◆ EMisEnabledMaxIter()

INLINE bool gum::learning::IBNLearner::EMisEnabledMaxIter ( ) const

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

Definition at line 986 of file IBNLearner_inl.h.

986{ return dag2BN_.isEnabledMaxIter(); }

References dag2BN_.

◆ EMisEnabledMaxTime()

INLINE bool gum::learning::IBNLearner::EMisEnabledMaxTime ( ) const

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

Definition at line 998 of file IBNLearner_inl.h.

998{ return dag2BN_.isEnabledMaxTime(); }

References dag2BN_.

◆ EMisEnabledMinEpsilonRate()

INLINE bool gum::learning::IBNLearner::EMisEnabledMinEpsilonRate ( ) const

Returns: true if EM's stopping criterion is the log-likelihood evolution rate

Definition at line 974 of file IBNLearner_inl.h.

                                                          {
    return dag2BN_.isEnabledMinEpsilonRate();
  }

References dag2BN_.

◆ EMMaxIter()

INLINE Size gum::learning::IBNLearner::EMMaxIter ( ) const

return the max number of iterations criterion

Warning: Note that this value is not taken into account unless the max iter criterion is enabled

Definition at line 980 of file IBNLearner_inl.h.

980{ return dag2BN_.maxIter(); }

References dag2BN_.

◆ EMMaxTime()

INLINE double gum::learning::IBNLearner::EMMaxTime ( ) const

@brief returns EM's timeout (in milliseconds)

Warning: Note that this value is not taken into account unless the max time criterion is enabled

Definition at line 990 of file IBNLearner_inl.h.

990{ return dag2BN_.maxTime(); }

References dag2BN_.

◆ EMMinEpsilonRate()

INLINE double gum::learning::IBNLearner::EMMinEpsilonRate ( ) const

Get the value of the minimal log-likelihood evolution rate of EM.

Warning: Note that this value is not taken into account unless the min rate criterion is enabled

Definition at line 968 of file IBNLearner_inl.h.

968{ return dag2BN_.minEpsilonRate(); }

References dag2BN_.

◆ EMnbrIterations()

INLINE Size gum::learning::IBNLearner::EMnbrIterations ( ) const

returns the number of iterations performed by the last EM execution

Definition at line 1013 of file IBNLearner_inl.h.

1013{ return dag2BN_.nbrIterations(); }

References dag2BN_.

◆ EMPeriodSize()

INLINE Size gum::learning::IBNLearner::EMPeriodSize ( ) const

sets the stopping criterion of EM as being the minimal difference between two consecutive log-likelihoods

Parameters

eps	the log-likelihood difference below which EM stops its iterations

Warning: setting this stopping criterion disables the min rate criterion (if it was enabled)

Exceptions

OutOfBounds if eps <= 0

Definition at line 1002 of file IBNLearner_inl.h.

1002{ return dag2BN_.periodSize(); }

References dag2BN_.

◆ EMsetEpsilon()

INLINE void gum::learning::IBNLearner::EMsetEpsilon ( double eps )

sets the stopping criterion of EM as being the minimal difference between two consecutive log-likelihoods

Parameters

eps	the log-likelihood difference below which EM stops its iterations

Warning: setting this stopping criterion disables the min rate criterion (if it was enabled)

Exceptions

OutOfBounds if eps <= 0

Definition at line 956 of file IBNLearner_inl.h.

956{ dag2BN_.setEpsilon(eps); }

References dag2BN_.

◆ EMsetMaxIter()

INLINE void gum::learning::IBNLearner::EMsetMaxIter ( Size max )

add a max iteration stopping criterion

Parameters

max	the max number of iterations that EM is allowed to perform

Exceptions

OutOfBounds if max<=1

Definition at line 978 of file IBNLearner_inl.h.

978{ dag2BN_.setMaxIter(max); }

References dag2BN_.

◆ EMsetMaxTime()

INLINE void gum::learning::IBNLearner::EMsetMaxTime ( double timeout )

add a stopping criterion on timeout

Parameters

timeout the timeout in milliseconds

Exceptions

OutOfBounds if timeout<=0.0

Definition at line 988 of file IBNLearner_inl.h.

988{ dag2BN_.setMaxTime(timeout); }

References dag2BN_.

◆ EMsetMinEpsilonRate()

INLINE void gum::learning::IBNLearner::EMsetMinEpsilonRate ( double rate )

sets the stopping criterion of EM as being the minimal log-likelihood's evolution rate

Parameters

rate	the log-likelihood evolution rate below which EM stops its iterations

Warning: setting this stopping criterion disables the min diff criterion (if it was enabled)

Exceptions

OutOfBounds if rate<=0

Definition at line 966 of file IBNLearner_inl.h.

966{ dag2BN_.setMinEpsilonRate(rate); }

References dag2BN_.

◆ EMsetPeriodSize()

INLINE void gum::learning::IBNLearner::EMsetPeriodSize ( Size p )

how many samples between 2 stoppings isEnabled

Exceptions

OutOfBounds if p<1

Definition at line 1000 of file IBNLearner_inl.h.

1000{ dag2BN_.setPeriodSize(p); }

References dag2BN_.

◆ EMsetVerbosity()

INLINE void gum::learning::IBNLearner::EMsetVerbosity ( bool v )

sets or unsets EM's verbosity

Definition at line 1004 of file IBNLearner_inl.h.

1004{ dag2BN_.setVerbosity(v); }

References dag2BN_.

◆ EMState()

INLINE IApproximationSchemeConfiguration::ApproximationSchemeSTATE gum::learning::IBNLearner::EMState ( ) const

returns the state of the last EM algorithm executed

Definition at line 442 of file IBNLearner_inl.h.

                                                                                             {
    if (useEM_) return dag2BN_.stateApproximationScheme();
    else return IApproximationSchemeConfiguration::ApproximationSchemeSTATE::Undefined;
  }

References dag2BN_, gum::IApproximationSchemeConfiguration::Undefined, and useEM_.

◆ EMStateApproximationScheme()

INLINE IApproximationSchemeConfiguration::ApproximationSchemeSTATE gum::learning::IBNLearner::EMStateApproximationScheme ( ) const

get the current state of EM

Definition at line 1009 of file IBNLearner_inl.h.

                                                      {
    return dag2BN_.stateApproximationScheme();
  }

References dag2BN_.

◆ EMStateMessage()

INLINE std::string gum::learning::IBNLearner::EMStateMessage ( ) const

returns the state of the EM algorithm

Definition at line 448 of file IBNLearner_inl.h.

                                                    {
    if (useEM_) return dag2BN_.messageApproximationScheme();
    else return "EM is currently forbidden. Please enable it with useEM()";
  }

References dag2BN_, and useEM_.

◆ EMVerbosity()

INLINE bool gum::learning::IBNLearner::EMVerbosity ( ) const

returns the EM's verbosity status

Definition at line 1006 of file IBNLearner_inl.h.

1006{ return dag2BN_.verbosity(); }

References dag2BN_.

◆ enableEpsilon()

INLINE void gum::learning::IBNLearner::enableEpsilon ( )

overridevirtual

Enable stopping criterion on epsilon.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 804 of file IBNLearner_inl.h.

                                        {
    algoK2_.approximationScheme().enableEpsilon();
    greedyHillClimbing_.enableEpsilon();
    localSearchWithTabuList_.enableEpsilon();
    dag2BN_.enableEpsilon();
  }

References algoK2_, dag2BN_, greedyHillClimbing_, and localSearchWithTabuList_.

◆ enableMaxIter()

INLINE void gum::learning::IBNLearner::enableMaxIter ( )

overridevirtual

Enable stopping criterion on max iterations.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 866 of file IBNLearner_inl.h.

                                        {
    algoK2_.approximationScheme().enableMaxIter();
    greedyHillClimbing_.enableMaxIter();
    localSearchWithTabuList_.enableMaxIter();
    dag2BN_.enableMaxIter();
  }

References algoK2_, dag2BN_, greedyHillClimbing_, and localSearchWithTabuList_.

◆ enableMaxTime()

INLINE void gum::learning::IBNLearner::enableMaxTime ( )

overridevirtual

stopping criterion on timeout If the criterion was disabled it will be enabled

Exceptions

OutOfBounds if timeout<=0.0 timeout is time in second (double).

Implements gum::IApproximationSchemeConfiguration.

Definition at line 902 of file IBNLearner_inl.h.

                                        {
    algoK2_.approximationScheme().enableMaxTime();
    greedyHillClimbing_.enableMaxTime();
    localSearchWithTabuList_.enableMaxTime();
    dag2BN_.enableMaxTime();
  }

References algoK2_, dag2BN_, greedyHillClimbing_, and localSearchWithTabuList_.

◆ enableMinEpsilonRate()

INLINE void gum::learning::IBNLearner::enableMinEpsilonRate ( )

overridevirtual

Enable stopping criterion on epsilon rate.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 835 of file IBNLearner_inl.h.

                                               {
    algoK2_.approximationScheme().enableMinEpsilonRate();
    greedyHillClimbing_.enableMinEpsilonRate();
    localSearchWithTabuList_.enableMinEpsilonRate();
    dag2BN_.enableMinEpsilonRate();
  }

References algoK2_, dag2BN_, greedyHillClimbing_, and localSearchWithTabuList_.

◆ epsilon()

INLINE double gum::learning::IBNLearner::epsilon ( ) const

overridevirtual

Get the value of epsilon.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 792 of file IBNLearner_inl.h.

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

References currentAlgorithm_, and GUM_ERROR.

Referenced by gum::learning::BNLearner< GUM_SCALAR >::useEM(), useEM(), gum::learning::BNLearner< GUM_SCALAR >::useEMWithDiffCriterion(), useEMWithDiffCriterion(), gum::learning::BNLearner< GUM_SCALAR >::useEMWithRateCriterion(), and useEMWithRateCriterion().

Here is the caller graph for this function:

◆ eraseForbiddenArc() [1/3]

INLINE void gum::learning::IBNLearner::eraseForbiddenArc ( const Arc & arc )

Definition at line 520 of file IBNLearner_inl.h.

                                                          {
    constraintForbiddenArcs_.eraseArc(arc);
  }

References constraintForbiddenArcs_.

Referenced by eraseForbiddenArc(), and eraseForbiddenArc().

Here is the caller graph for this function:

◆ eraseForbiddenArc() [2/3]

INLINE void gum::learning::IBNLearner::eraseForbiddenArc	(	NodeId	tail,
		NodeId	head )

Definition at line 530 of file IBNLearner_inl.h.

                                                                                {
    eraseForbiddenArc(Arc(tail, head));
  }

References eraseForbiddenArc().

Here is the call graph for this function:

◆ eraseForbiddenArc() [3/3]

INLINE void gum::learning::IBNLearner::eraseForbiddenArc	(	std::string_view	tail,
		std::string_view	head )

Definition at line 540 of file IBNLearner_inl.h.

                                                                                    {
    eraseForbiddenArc(Arc(idFromName(tail), idFromName(head)));
  }

References eraseForbiddenArc(), and idFromName().

Here is the call graph for this function:

◆ eraseMandatoryArc() [1/3]

INLINE void gum::learning::IBNLearner::eraseMandatoryArc ( const Arc & arc )

Definition at line 553 of file IBNLearner_inl.h.

                                                          {
    constraintMandatoryArcs_.eraseArc(arc);
  }

References constraintMandatoryArcs_.

Referenced by eraseMandatoryArc(), and eraseMandatoryArc().

Here is the caller graph for this function:

◆ eraseMandatoryArc() [2/3]

INLINE void gum::learning::IBNLearner::eraseMandatoryArc	(	NodeId	tail,
		NodeId	head )

Definition at line 603 of file IBNLearner_inl.h.

                                                                    {
    eraseMandatoryArc(Arc(tail, head));
  }

References eraseMandatoryArc().

Here is the call graph for this function:

◆ eraseMandatoryArc() [3/3]

INLINE void gum::learning::IBNLearner::eraseMandatoryArc	(	std::string_view	tail,
		std::string_view	head )

Definition at line 593 of file IBNLearner_inl.h.

                                                                                    {
    eraseMandatoryArc(Arc(idFromName(tail), idFromName(head)));
  }

References eraseMandatoryArc(), and idFromName().

Here is the call graph for this function:

◆ eraseNoChildrenNode() [1/2]

INLINE void gum::learning::IBNLearner::eraseNoChildrenNode ( NodeId node )

Definition at line 579 of file IBNLearner_inl.h.

                                                         {
    constraintNoChildrenNodes_.eraseNode(node);
  }

References constraintNoChildrenNodes_.

Referenced by eraseNoChildrenNode().

Here is the caller graph for this function:

◆ eraseNoChildrenNode() [2/2]

INLINE void gum::learning::IBNLearner::eraseNoChildrenNode ( std::string_view node )

Definition at line 583 of file IBNLearner_inl.h.

                                                                 {
    eraseNoChildrenNode(idFromName(name));
  }

References eraseNoChildrenNode(), and idFromName().

Here is the call graph for this function:

◆ eraseNoParentNode() [1/2]

INLINE void gum::learning::IBNLearner::eraseNoParentNode ( NodeId node )

Definition at line 563 of file IBNLearner_inl.h.

                                                       {
    constraintNoParentNodes_.eraseNode(node);
  }

References constraintNoParentNodes_.

Referenced by eraseNoParentNode().

Here is the caller graph for this function:

◆ eraseNoParentNode() [2/2]

INLINE void gum::learning::IBNLearner::eraseNoParentNode ( std::string_view node )

Definition at line 567 of file IBNLearner_inl.h.

                                                               {
    eraseNoParentNode(idFromName(name));
  }

References eraseNoParentNode(), and idFromName().

Here is the call graph for this function:

◆ erasePossibleEdge() [1/3]

INLINE void gum::learning::IBNLearner::erasePossibleEdge ( const Edge & edge )

Definition at line 487 of file IBNLearner_inl.h.

                                                            {
    constraintPossibleEdges_.eraseEdge(edge);
  }

References constraintPossibleEdges_.

Referenced by erasePossibleEdge(), and erasePossibleEdge().

Here is the caller graph for this function:

◆ erasePossibleEdge() [2/3]

INLINE void gum::learning::IBNLearner::erasePossibleEdge	(	NodeId	tail,
		NodeId	head )

Definition at line 497 of file IBNLearner_inl.h.

                                                                                {
    erasePossibleEdge(Edge(tail, head));
  }

References erasePossibleEdge().

Here is the call graph for this function:

◆ erasePossibleEdge() [3/3]

INLINE void gum::learning::IBNLearner::erasePossibleEdge	(	std::string_view	tail,
		std::string_view	head )

Definition at line 507 of file IBNLearner_inl.h.

                                                                                    {
    erasePossibleEdge(Edge(idFromName(tail), idFromName(head)));
  }

References erasePossibleEdge(), and idFromName().

Here is the call graph for this function:

◆ fciExhaustiveSepSet()

INLINE bool gum::learning::IBNLearner::fciExhaustiveSepSet ( ) const

return true when FCI uses exhaustive sepset mode

Exceptions

OperationNotAllowed when FCI is not the selected algorithm

Definition at line 271 of file IBNLearner_inl.h.

                                                    {
    if (selectedAlgo_ != AlgoType::FCI) {
      GUM_ERROR(OperationNotAllowed,
                "fciExhaustiveSepSet() is only valid when using the FCI algorithm")
    }
    return exhaustiveSepSetFci_;
  }

References exhaustiveSepSetFci_, FCI, GUM_ERROR, and selectedAlgo_.

◆ forbidEM()

INLINE void gum::learning::IBNLearner::forbidEM ( )

prevent using the EM algorithm for parameter learning

forbid to use EM

Definition at line 430 of file IBNLearner_inl.h.

430{ useEM_ = false; }

References useEM_.

◆ G2() [1/2]

std::pair< double, double > gum::learning::IBNLearner::G2	(	NodeId	id1,
		NodeId	id2,
		const std::vector< NodeId > &	knowing = {} )

Return the <statistic,pvalue> pair for for G2 test in the database.

Parameters

id1	first variable
id2	second variable
knowing	list of observed variables

Returns: a std::pair<double,double>

Definition at line 1357 of file IBNLearner.cpp.

                                                                                           {
    createPrior_();
    gum::learning::IndepTestG2 g2score(scoreDatabase_.parser(), *prior_, databaseRanges());
    return g2score.statistics(id1, id2, knowing);
  }

References createPrior_(), databaseRanges(), prior_, scoreDatabase_, and gum::learning::IndepTestG2::statistics().

Referenced by G2().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ G2() [2/2]

std::pair< double, double > gum::learning::IBNLearner::G2	(	std::string_view	name1,
		std::string_view	name2,
		const std::vector< std::string > &	knowing = {} )

Return the <statistic,pvalue> pair for for G2 test in the database.

Parameters

id1	first variable
id2	second variable
knowing	list of observed variables

Returns: a std::pair<double,double>

Definition at line 1363 of file IBNLearner.cpp.

                                                                                    {
    std::vector< NodeId > knowingIds;
    std::transform(knowing.begin(),
                   knowing.end(),
                   std::back_inserter(knowingIds),
                   [this](const std::string& c) { return this->idFromName(c); });
    return G2(idFromName(name1), idFromName(name2), knowingIds);
  }

References G2(), and idFromName().

Here is the call graph for this function:

◆ getNumberOfThreads()

Size gum::ThreadNumberManager::getNumberOfThreads ( ) const

nodiscardoverridevirtualinherited

returns the current max number of threads used by the class containing this ThreadNumberManager

Implements gum::IThreadNumberManager.

Referenced by gum::learning::IBNLearner::createParamEstimator_(), gum::learning::IBNLearner::createScore_(), gum::credal::InferenceEngine< GUM_SCALAR >::dispatchMarginalsToThreads_(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::expFusion_(), gum::ScheduledInference::scheduler(), and gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::verticesFusion_().

Here is the caller graph for this function:

◆ getPriorType_()

INLINE PriorType gum::learning::IBNLearner::getPriorType_ ( ) const

protected

returns the type (as a string) of a given prior

Definition at line 689 of file IBNLearner_inl.h.

                                                   {
    switch (priorType_) {
      using enum gum::learning::IBNLearner::BNLearnerPriorType;
      case NO_prior : return PriorType::NoPriorType;
      case SMOOTHING : return PriorType::SmoothingPriorType;
      case DIRICHLET_FROM_DATABASE :
      case DIRICHLET_FROM_BAYESNET : return PriorType::DirichletPriorType;
      case BDEU : return PriorType::BDeuPriorType;
      default :
        GUM_ERROR(OperationNotAllowed,
                  "IBNLearner getPriorType does "
                  "not support yet this prior")
    }
  }

References BDEU, gum::learning::BDeuPriorType, DIRICHLET_FROM_BAYESNET, DIRICHLET_FROM_DATABASE, gum::learning::DirichletPriorType, GUM_ERROR, NO_prior, gum::learning::NoPriorType, priorType_, SMOOTHING, and gum::learning::SmoothingPriorType.

Referenced by checkScorePriorCompatibility().

Here is the caller graph for this function:

◆ greedyThickThinningReversals()

INLINE bool gum::learning::IBNLearner::greedyThickThinningReversals ( ) const

returns whether arc reversals are allowed in the thin phase of greedy thick-thinning

Definition at line 382 of file IBNLearner_inl.h.

                                                             {
    return greedyThickThinning_.allowReversalsInThinPhase();
  }

References greedyThickThinning_.

◆ hasMissingValues()

INLINE bool gum::learning::IBNLearner::hasMissingValues ( ) const

returns true if the learner's database has missing values

Definition at line 467 of file IBNLearner_inl.h.

                                                 {
    return scoreDatabase_.databaseTable().hasMissingValues();
  }

References scoreDatabase_.

Referenced by rawPseudoCount().

Here is the caller graph for this function:

◆ history()

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

overridevirtual

Exceptions

OperationNotAllowed if scheme not performed or verbosity=false

Implements gum::IApproximationSchemeConfiguration.

Definition at line 949 of file IBNLearner_inl.h.

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

References currentAlgorithm_, and GUM_ERROR.

◆ idFromName()

INLINE NodeId gum::learning::IBNLearner::idFromName ( std::string_view var_name ) const

returns the node id corresponding to a variable name

Exceptions

MissingVariableInDatabase if a variable of the BN is not found in the database.

Definition at line 136 of file IBNLearner_inl.h.

                                                                    {
    return scoreDatabase_.idFromName(var_name);
  }

References scoreDatabase_.

Referenced by addForbiddenArc(), addMandatoryArc(), addNoChildrenNode(), addNoParentNode(), addPossibleEdge(), chi2(), correctedMutualInformation(), domainSize(), eraseForbiddenArc(), eraseMandatoryArc(), eraseNoChildrenNode(), eraseNoParentNode(), erasePossibleEdge(), G2(), logLikelihood(), mutualInformation(), rawPseudoCount(), score(), setSliceOrder(), and setTotalOrder().

Here is the caller graph for this function:

◆ initialDAG()

INLINE DAG gum::learning::IBNLearner::initialDAG ( )

returns the initial DAG structure

Definition at line 166 of file IBNLearner_inl.h.

166{ return initialDag_; }

References initialDag_.

◆ isConstraintBased()

INLINE bool gum::learning::IBNLearner::isConstraintBased ( ) const

indicate if the selected algorithm is constraint-based

Definition at line 750 of file IBNLearner_inl.h.

                                                  {
    switch (selectedAlgo_) {
      case AlgoType::K2 :
      case AlgoType::GREEDY_HILL_CLIMBING :
      case AlgoType::EXTENDED_GREEDY_HILL_CLIMBING :
      case AlgoType::LOCAL_SEARCH_WITH_TABU_LIST :
      case AlgoType::GREEDY_THICK_THINNING : return false;
      case AlgoType::MIIC :
      case AlgoType::PC :
      case AlgoType::FCI : return true;
      default : throw OperationNotAllowed("Unknown algorithm");
    }
  }

References EXTENDED_GREEDY_HILL_CLIMBING, FCI, GREEDY_HILL_CLIMBING, GREEDY_THICK_THINNING, K2, LOCAL_SEARCH_WITH_TABU_LIST, MIIC, PC, and selectedAlgo_.

Referenced by checkScorePriorCompatibility(), and isScoreBased().

Here is the caller graph for this function:

◆ isCSVFileName_()

void gum::learning::IBNLearner::isCSVFileName_ ( std::string_view filename )

staticprotected

checks whether the extension of a CSV filename is correct

Definition at line 429 of file IBNLearner.cpp.

                                                         {
    // get the extension of the file
 
    if (auto filename_size = Size(filename.size()); filename_size < 4) {
      GUM_ERROR(FormatNotFound,
                "IBNLearner could not determine the "
                "file type of the database")
    }
 
    std::string extension(filename.substr(filename.size() - 4));
    std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
 
    if (extension != ".csv") {
      GUM_ERROR(OperationNotAllowed, "IBNLearner does not support yet this type of database file")
    }
  }

References GUM_ERROR.

Referenced by gum::learning::IBNLearner::Database::Database(), gum::learning::IBNLearner::Database::Database(), and readFile_().

Here is the caller graph for this function:

◆ isEnabledEpsilon()

INLINE bool gum::learning::IBNLearner::isEnabledEpsilon ( ) const

overridevirtual

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

Implements gum::IApproximationSchemeConfiguration.

Definition at line 811 of file IBNLearner_inl.h.

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

References currentAlgorithm_, and GUM_ERROR.

◆ isEnabledMaxIter()

INLINE bool gum::learning::IBNLearner::isEnabledMaxIter ( ) const

overridevirtual

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

Implements gum::IApproximationSchemeConfiguration.

Definition at line 873 of file IBNLearner_inl.h.

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

References currentAlgorithm_, and GUM_ERROR.

◆ isEnabledMaxTime()

INLINE bool gum::learning::IBNLearner::isEnabledMaxTime ( ) const

overridevirtual

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

Implements gum::IApproximationSchemeConfiguration.

Definition at line 909 of file IBNLearner_inl.h.

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

References currentAlgorithm_, and GUM_ERROR.

◆ isEnabledMinEpsilonRate()

INLINE bool gum::learning::IBNLearner::isEnabledMinEpsilonRate ( ) const

overridevirtual

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

Implements gum::IApproximationSchemeConfiguration.

Definition at line 842 of file IBNLearner_inl.h.

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

References currentAlgorithm_, and GUM_ERROR.

◆ isGumNumberOfThreadsOverriden()

bool gum::ThreadNumberManager::isGumNumberOfThreadsOverriden ( ) const

nodiscardoverridevirtualinherited

indicates whether the class containing this ThreadNumberManager set its own number of threads

Implements gum::IThreadNumberManager.

Referenced by gum::learning::IBNLearner::createParamEstimator_(), and gum::learning::IBNLearner::createScore_().

Here is the caller graph for this function:

◆ isScoreBased()

INLINE bool gum::learning::IBNLearner::isScoreBased ( ) const

indicate if the selected algorithm is score-based

Definition at line 764 of file IBNLearner_inl.h.

764{ return !isConstraintBased(); }

References isConstraintBased().

Here is the call graph for this function:

◆ isUsingEM()

INLINE bool gum::learning::IBNLearner::isUsingEM ( ) const

indicates whether we use EM for parameter learning

Definition at line 433 of file IBNLearner_inl.h.

433{ return useEM_; }

References useEM_.

◆ latentVariables()

INLINE std::vector< Arc > gum::learning::IBNLearner::latentVariables ( ) const

get the list of arcs hiding latent variables

Exceptions

OperationNotAllowed when MIIC is not the selected algorithm

Definition at line 345 of file IBNLearner_inl.h.

                                                            {
    return algoMiic_.latentVariables();
  }

References algoMiic_.

◆ learnDAG()

DAG gum::learning::IBNLearner::learnDAG ( )

learn a structure from a file (must have read the db before)

Definition at line 956 of file IBNLearner.cpp.

                           {
    createPrior_();
    createScore_();
    auto dag = learnDag_();
    for (const auto i: dag) {
      dag.setName(i, scoreDatabase_.databaseTable().variableName(i));
    }
    return dag;
  }

References createPrior_(), createScore_(), learnDag_(), and scoreDatabase_.

Here is the call graph for this function:

◆ learnDag_()

DAG gum::learning::IBNLearner::learnDag_ ( )

protected

returns the DAG learnt

Definition at line 985 of file IBNLearner.cpp.

                            {
    // check that the database does not contain any missing value
    if (scoreDatabase_.databaseTable().hasMissingValues()
        || ((priorDatabase_ != nullptr)
            && (priorType_ == BNLearnerPriorType::DIRICHLET_FROM_DATABASE)
            && priorDatabase_->databaseTable().hasMissingValues())) {
      GUM_ERROR(MissingValueInDatabase,
                "For the moment, the BNLearner is unable to cope "
                "with missing values in databases")
    }
    // add the mandatory arcs to the initial dag and remove the forbidden ones
    // from the initial graph
    DAG init_graph = initialDag_;
 
    for (const auto& arc: constraintMandatoryArcs_.arcs()) {
      if (!init_graph.exists(arc.tail())) init_graph.addNodeWithId(arc.tail());
 
      if (!init_graph.exists(arc.head())) init_graph.addNodeWithId(arc.head());
 
      init_graph.addArc(arc.tail(), arc.head());
    }
 
    for (const auto& arc: constraintForbiddenArcs_.arcs())
      init_graph.eraseArc(arc);
 
 
    switch (selectedAlgo_) {
      // ========================================================================
      case AlgoType::PC : {
        BNLearnerListener listener(this, algoPC_);
        MixedGraph        mgraph = this->preparePC_();
        return algoPC_.learnDAG(mgraph);
      }
 
      // ========================================================================
      case AlgoType::FCI : {
        BNLearnerListener listener(this, algoFCI_);
        MixedGraph        mgraph = this->prepareFCI_();
        return algoFCI_.learnDAG(mgraph);
      }
 
      // ========================================================================
      case AlgoType::MIIC : {
        BNLearnerListener listener(this, algoMiic_);
        // create the mixedGraph and the corrected mutual information
        MixedGraph mgraph = this->prepareMiic_();
 
        algoMiic_.setMutualInformation(*mutualInfo_);
        return algoMiic_.learnDAG(mgraph);
      }
 
      // ========================================================================
      case AlgoType::GREEDY_HILL_CLIMBING : {
        BNLearnerListener listener(this, greedyHillClimbing_);
        StructuralConstraintSetStatic< StructuralConstraintMandatoryArcs,
                                       StructuralConstraintForbiddenArcs,
                                       StructuralConstraintPossibleEdges,
                                       StructuralConstraintSliceOrder,
                                       StructuralConstraintNoParentNodes,
                                       StructuralConstraintNoChildrenNodes,
                                       StructuralConstraintTotalOrder >
            invariable_constraints;
        static_cast< StructuralConstraintMandatoryArcs& >(invariable_constraints)
            = constraintMandatoryArcs_;
        static_cast< StructuralConstraintForbiddenArcs& >(invariable_constraints)
            = constraintForbiddenArcs_;
        static_cast< StructuralConstraintPossibleEdges& >(invariable_constraints)
            = constraintPossibleEdges_;
        static_cast< StructuralConstraintSliceOrder& >(invariable_constraints)
            = constraintSliceOrder_;
        static_cast< StructuralConstraintNoParentNodes& >(invariable_constraints)
            = constraintNoParentNodes_;
        static_cast< StructuralConstraintNoChildrenNodes& >(invariable_constraints)
            = constraintNoChildrenNodes_;
        static_cast< StructuralConstraintTotalOrder& >(invariable_constraints)
            = constraintTotalOrder_;
 
        StructuralConstraintSetStatic< StructuralConstraintIndegree, StructuralConstraintDAG >
            variable_constraints;
        static_cast< StructuralConstraintIndegree& >(variable_constraints) = constraintIndegree_;
 
        GraphChangesSelector4DiGraph selector(*score_,
                                              invariable_constraints,
                                              variable_constraints);
 
        // enforce that greedy hill climbing uses arc additions, deletions and reversals
        // and only these operations
        selector.useArcAdditions(true);
        selector.useArcDeletions(true);
        selector.useArcReversals(true);
        selector.useArcTriangleDeletions(false);
 
        return greedyHillClimbing_.learnStructure(selector, init_graph);
      }
 
      // ========================================================================
      case AlgoType::EXTENDED_GREEDY_HILL_CLIMBING : {
        BNLearnerListener listener(this, extendedGreedyHillClimbing_);
        StructuralConstraintSetStatic< StructuralConstraintMandatoryArcs,
                                       StructuralConstraintForbiddenArcs,
                                       StructuralConstraintPossibleEdges,
                                       StructuralConstraintNoParentNodes,
                                       StructuralConstraintNoChildrenNodes,
                                       StructuralConstraintSliceOrder,
                                       StructuralConstraintTotalOrder >
            invariable_constraints;
        static_cast< StructuralConstraintMandatoryArcs& >(invariable_constraints)
            = constraintMandatoryArcs_;
        static_cast< StructuralConstraintForbiddenArcs& >(invariable_constraints)
            = constraintForbiddenArcs_;
        static_cast< StructuralConstraintPossibleEdges& >(invariable_constraints)
            = constraintPossibleEdges_;
        static_cast< StructuralConstraintSliceOrder& >(invariable_constraints)
            = constraintSliceOrder_;
        static_cast< StructuralConstraintNoParentNodes& >(invariable_constraints)
            = constraintNoParentNodes_;
        static_cast< StructuralConstraintNoChildrenNodes& >(invariable_constraints)
            = constraintNoChildrenNodes_;
        static_cast< StructuralConstraintTotalOrder& >(invariable_constraints)
            = constraintTotalOrder_;
 
        StructuralConstraintSetStatic< StructuralConstraintIndegree, StructuralConstraintDAG >
            variable_constraints;
        static_cast< StructuralConstraintIndegree& >(variable_constraints) = constraintIndegree_;
 
        GraphChangesSelector4DiGraph selector(*score_,
                                              invariable_constraints,
                                              variable_constraints);
 
        selector.useArcAdditions(allowArcAdditions_);
        selector.useArcDeletions(allowArcDeletions_);
        selector.useArcReversals(allowArcReversals_);
        selector.useArcTriangleDeletions(allowArcTriangleDeletions_);
 
        return greedyHillClimbing_.learnStructure(selector, init_graph);
      }
 
      // ========================================================================
      case AlgoType::GREEDY_THICK_THINNING : {
        BNLearnerListener listener(this, greedyThickThinning_);
        StructuralConstraintSetStatic< StructuralConstraintMandatoryArcs,
                                       StructuralConstraintForbiddenArcs,
                                       StructuralConstraintPossibleEdges,
                                       StructuralConstraintSliceOrder,
                                       StructuralConstraintNoParentNodes,
                                       StructuralConstraintNoChildrenNodes,
                                       StructuralConstraintTotalOrder >
            invariable_constraints;
        static_cast< StructuralConstraintMandatoryArcs& >(invariable_constraints)
            = constraintMandatoryArcs_;
        static_cast< StructuralConstraintForbiddenArcs& >(invariable_constraints)
            = constraintForbiddenArcs_;
        static_cast< StructuralConstraintPossibleEdges& >(invariable_constraints)
            = constraintPossibleEdges_;
        static_cast< StructuralConstraintSliceOrder& >(invariable_constraints)
            = constraintSliceOrder_;
        static_cast< StructuralConstraintNoParentNodes& >(invariable_constraints)
            = constraintNoParentNodes_;
        static_cast< StructuralConstraintNoChildrenNodes& >(invariable_constraints)
            = constraintNoChildrenNodes_;
        static_cast< StructuralConstraintTotalOrder& >(invariable_constraints)
            = constraintTotalOrder_;
 
        StructuralConstraintSetStatic< StructuralConstraintIndegree, StructuralConstraintDAG >
            variable_constraints;
        static_cast< StructuralConstraintIndegree& >(variable_constraints) = constraintIndegree_;
 
        GraphChangesSelector4DiGraph selector(*score_,
                                              invariable_constraints,
                                              variable_constraints);
 
        return greedyThickThinning_.learnStructure(selector, init_graph);
      }
 
      // ========================================================================
      case AlgoType::LOCAL_SEARCH_WITH_TABU_LIST : {
        BNLearnerListener listener(this, localSearchWithTabuList_);
        StructuralConstraintSetStatic< StructuralConstraintMandatoryArcs,
                                       StructuralConstraintForbiddenArcs,
                                       StructuralConstraintPossibleEdges,
                                       StructuralConstraintSliceOrder,
                                       StructuralConstraintNoParentNodes,
                                       StructuralConstraintNoChildrenNodes,
                                       StructuralConstraintTotalOrder >
            invariable_constraints;
        static_cast< StructuralConstraintMandatoryArcs& >(invariable_constraints)
            = constraintMandatoryArcs_;
        static_cast< StructuralConstraintForbiddenArcs& >(invariable_constraints)
            = constraintForbiddenArcs_;
        static_cast< StructuralConstraintPossibleEdges& >(invariable_constraints)
            = constraintPossibleEdges_;
        static_cast< StructuralConstraintSliceOrder& >(invariable_constraints)
            = constraintSliceOrder_;
        static_cast< StructuralConstraintNoParentNodes& >(invariable_constraints)
            = constraintNoParentNodes_;
        static_cast< StructuralConstraintNoChildrenNodes& >(invariable_constraints)
            = constraintNoChildrenNodes_;
        static_cast< StructuralConstraintTotalOrder& >(invariable_constraints)
            = constraintTotalOrder_;
 
        StructuralConstraintSetStatic< StructuralConstraintTabuList,
                                       StructuralConstraintIndegree,
                                       StructuralConstraintDAG >
            variable_constraints;
        static_cast< StructuralConstraintTabuList& >(variable_constraints) = constraintTabuList_;
        static_cast< StructuralConstraintIndegree& >(variable_constraints) = constraintIndegree_;
 
        GraphChangesSelector4DiGraph selector(*score_,
                                              invariable_constraints,
                                              variable_constraints);
 
        selector.useArcAdditions(allowArcAdditions_);
        selector.useArcDeletions(allowArcDeletions_);
        selector.useArcReversals(allowArcReversals_);
        selector.useArcTriangleDeletions(allowArcTriangleDeletions_);
 
        return localSearchWithTabuList_.learnStructure(selector, init_graph);
      }
 
      // ========================================================================
      case AlgoType::K2 : {
        BNLearnerListener listener(this, algoK2_.approximationScheme());
        StructuralConstraintSetStatic< StructuralConstraintMandatoryArcs,
                                       StructuralConstraintForbiddenArcs,
                                       StructuralConstraintPossibleEdges,
                                       StructuralConstraintNoParentNodes,
                                       StructuralConstraintNoChildrenNodes,
                                       StructuralConstraintTotalOrder >
            invariable_constraints;
        static_cast< StructuralConstraintMandatoryArcs& >(invariable_constraints)
            = constraintMandatoryArcs_;
        static_cast< StructuralConstraintForbiddenArcs& >(invariable_constraints)
            = constraintForbiddenArcs_;
        static_cast< StructuralConstraintPossibleEdges& >(invariable_constraints)
            = constraintPossibleEdges_;
        static_cast< StructuralConstraintNoParentNodes& >(invariable_constraints)
            = constraintNoParentNodes_;
        static_cast< StructuralConstraintNoChildrenNodes& >(invariable_constraints)
            = constraintNoChildrenNodes_;
        static_cast< StructuralConstraintTotalOrder& >(invariable_constraints)
            = constraintTotalOrder_;
 
        // if some mandatory arcs are incompatible with the order, use a DAG
        // constraint instead of a DiGraph constraint to avoid cycles
        const ArcSet& mandatory_arcs
            = static_cast< StructuralConstraintMandatoryArcs& >(invariable_constraints).arcs();
        const Sequence< NodeId >& order            = algoK2_.order();
        bool                      order_compatible = true;
 
        for (const auto& arc: mandatory_arcs) {
          if (order.pos(arc.tail()) >= order.pos(arc.head())) {
            order_compatible = false;
            break;
          }
        }
 
        if (order_compatible) {
          StructuralConstraintSetStatic< StructuralConstraintIndegree, StructuralConstraintDiGraph >
              variable_constraints;
          static_cast< StructuralConstraintIndegree& >(variable_constraints) = constraintIndegree_;
 
          GraphChangesSelector4DiGraph selector(*score_,
                                                invariable_constraints,
                                                variable_constraints);
 
          return algoK2_.learnStructure(selector, init_graph);
        } else {
          StructuralConstraintSetStatic< StructuralConstraintIndegree, StructuralConstraintDAG >
              variable_constraints;
          static_cast< StructuralConstraintIndegree& >(variable_constraints) = constraintIndegree_;
 
          GraphChangesSelector4DiGraph selector(*score_,
                                                invariable_constraints,
                                                variable_constraints);
 
          return algoK2_.learnStructure(selector, init_graph);
        }
      }
    }
 
    GUM_ERROR(OperationNotAllowed,
              "the learnDAG method has not been implemented for this "
              "learning algorithm")
  }

Referenced by learnDAG().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ learnPAG()

PAG gum::learning::IBNLearner::learnPAG ( )

learn a PAG — only valid when useFCI() has been called

Exceptions

OperationNotAllowed when FCI is not the selected algorithm

Definition at line 948 of file IBNLearner.cpp.

                           {
    auto pag = learnPAG_();
    for (const auto i: pag) {
      pag.setName(i, scoreDatabase_.databaseTable().variableName(i));
    }
    return pag;
  }

References learnPAG_(), and scoreDatabase_.

Here is the call graph for this function:

◆ learnPAG_()

PAG gum::learning::IBNLearner::learnPAG_ ( )

protected

Definition at line 934 of file IBNLearner.cpp.

                            {
    if (selectedAlgo_ != AlgoType::FCI) {
      GUM_ERROR(OperationNotAllowed, "learnPAG() is only valid when using the FCI algorithm")
    }
    if (scoreDatabase_.databaseTable().hasMissingValues()) {
      GUM_ERROR(MissingValueInDatabase,
                "For the moment, the BNLearner is unable to learn "
                    << "structures with missing values in databases")
    }
    BNLearnerListener listener(this, algoFCI_);
    MixedGraph        mgraph = this->prepareFCI_();
    return algoFCI_.learnPAG(mgraph);
  }

References algoFCI_, FCI, GUM_ERROR, prepareFCI_(), scoreDatabase_, and selectedAlgo_.

Referenced by learnPAG().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ learnPDAG()

PDAG gum::learning::IBNLearner::learnPDAG ( )

learn a partial structure from a file (must have read the db before and must have selected miic)

Definition at line 926 of file IBNLearner.cpp.

                             {
    auto pdag = learnPDAG_();
    for (const auto i: pdag) {
      pdag.setName(i, scoreDatabase_.databaseTable().variableName(i));
    }
    return pdag;
  }

References learnPDAG_(), and scoreDatabase_.

Here is the call graph for this function:

◆ learnPDAG_()

PDAG gum::learning::IBNLearner::learnPDAG_ ( )

protected

Definition at line 893 of file IBNLearner.cpp.

                              {
    if (selectedAlgo_ != AlgoType::MIIC && selectedAlgo_ != AlgoType::PC
        && selectedAlgo_ != AlgoType::FCI) {
      GUM_ERROR(OperationNotAllowed,
                "Score-based algorithms do not build PDAG. Please use a constraint-based "
                "algorithm instead")
    }
    // check that the database does not contain any missing value
    if (scoreDatabase_.databaseTable().hasMissingValues()) {
      GUM_ERROR(MissingValueInDatabase,
                "For the moment, the BNLearner is unable to learn "
                    << "structures with missing values in databases")
    }
 
    if (selectedAlgo_ == AlgoType::PC) {
      BNLearnerListener listener(this, algoPC_);
      MixedGraph        mgraph = this->preparePC_();
      return algoPC_.learnPDAG(mgraph);
    }
 
    if (selectedAlgo_ == AlgoType::FCI) {
      BNLearnerListener listener(this, algoFCI_);
      MixedGraph        mgraph = this->prepareFCI_();
      return algoFCI_.learnPDAG(mgraph);
    }
 
    BNLearnerListener listener(this, algoMiic_);
    // create the mixedGraph_constraint_MandatoryArcs.arcs
    MixedGraph mgraph = this->prepareMiic_();
    algoMiic_.setMutualInformation(*mutualInfo_);
    return algoMiic_.learnPDAG(mgraph);
  }

References algoFCI_, algoMiic_, algoPC_, FCI, GUM_ERROR, MIIC, mutualInfo_, PC, prepareFCI_(), prepareMiic_(), preparePC_(), scoreDatabase_, and selectedAlgo_.

Referenced by learnPDAG().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ logLikelihood() [1/2]

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

Return the loglikelihood of vars in the base, conditioned by knowing for the BNLearner.

Parameters

vars	a vector of NodeIds
knowing	an optional vector of conditioning NodeIds

Returns: a double

Definition at line 1374 of file IBNLearner.cpp.

                                                                       {
    createPrior_();
    gum::learning::ScoreLog2Likelihood ll2score(scoreDatabase_.parser(), *prior_, databaseRanges());
 
    std::vector< NodeId > total(vars);
    total.insert(total.end(), knowing.begin(), knowing.end());
    double LLtotal = ll2score.score(IdCondSet(total, false, true));
    if (knowing.size() == (Size)0) {
      return LLtotal;
    } else {
      double LLknw = ll2score.score(IdCondSet(knowing, false, true));
      return LLtotal - LLknw;
    }
  }

References createPrior_(), databaseRanges(), prior_, gum::learning::ScoreLog2Likelihood::score(), and scoreDatabase_.

Referenced by logLikelihood().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ logLikelihood() [2/2]

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

Return the loglikelihood of vars in the base, conditioned by knowing for the BNLearner.

Parameters

vars	a vector of name of rows
knowing	an optional vector of conditioning rows

Returns: a double

Definition at line 1390 of file IBNLearner.cpp.

                                                                          {
    std::vector< NodeId > ids;
    std::vector< NodeId > knowingIds;
 
    auto mapper = [this](const std::string& c) { return this->idFromName(c); };
 
    std::transform(vars.begin(), vars.end(), std::back_inserter(ids), mapper);
    std::transform(knowing.begin(), knowing.end(), std::back_inserter(knowingIds), mapper);
 
    return logLikelihood(ids, knowingIds);
  }

References idFromName(), and logLikelihood().

Here is the call graph for this function:

◆ maxIter()

INLINE Size gum::learning::IBNLearner::maxIter ( ) const

overridevirtual

Returns: the criterion on number of iterations

Implements gum::IApproximationSchemeConfiguration.

Definition at line 854 of file IBNLearner_inl.h.

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

References currentAlgorithm_, and GUM_ERROR.

◆ maxTime()

INLINE double gum::learning::IBNLearner::maxTime ( ) const

overridevirtual

returns the timeout (in seconds)

Implements gum::IApproximationSchemeConfiguration.

Definition at line 885 of file IBNLearner_inl.h.

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

References currentAlgorithm_, and GUM_ERROR.

◆ messageApproximationScheme()

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

inherited

Returns the approximation scheme message.

Returns: Returns the approximation scheme message.

Definition at line 64 of file IApproximationSchemeConfiguration.cpp.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ minEpsilonRate()

INLINE double gum::learning::IBNLearner::minEpsilonRate ( ) const

overridevirtual

Get the value of the minimal epsilon rate.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 823 of file IBNLearner_inl.h.

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

References currentAlgorithm_, and GUM_ERROR.

◆ mutualInformation() [1/2]

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

Return the mutual information of id1 and id2 in the base, conditioned by knowing for the BNLearner.

Warning: This function returns the bare mutual information (without prior or correction)

Parameters

id1	nodeId
id2	nodeId
knowing	an optional vector of conditioning NodeIds

Returns: a double

Definition at line 1440 of file IBNLearner.cpp.

                                                                           {
    const auto prior = NoPrior(scoreDatabase_.databaseTable(), scoreDatabase_.nodeId2Columns());
    gum::learning::CorrectedMutualInformation cmi(scoreDatabase_.parser(), prior, databaseRanges());
    cmi.useNoCorr();
 
    if (knowing.size() == (Size)0) return cmi.score(id1, id2) / scoreDatabase_.weight();
    else return cmi.score(id1, id2, knowing) / scoreDatabase_.weight();
  }

References databaseRanges(), gum::learning::CorrectedMutualInformation::score(), scoreDatabase_, and gum::learning::CorrectedMutualInformation::useNoCorr().

Referenced by mutualInformation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mutualInformation() [2/2]

double gum::learning::IBNLearner::mutualInformation	(	std::string_view	var1,
		std::string_view	var2,
		const std::vector< std::string > &	knowing = {} )

Return the mutual information of var1 and var2 in the base, conditioned by knowing for the BNLearner.

Warning: This function returns the bare mutual information (without prior or correction)

Parameters

var1	name of a row
var2	name of a row
knowing	an optional vector of conditioning rows

Returns: a double

Definition at line 1451 of file IBNLearner.cpp.

                                                                              {
    std::vector< NodeId > knowingIds;
 
    auto mapper = [this](const std::string& c) { return this->idFromName(c); };
 
    std::transform(knowing.begin(), knowing.end(), std::back_inserter(knowingIds), mapper);
 
    return mutualInformation(this->idFromName(var1), this->idFromName(var2), knowingIds);
  }

References idFromName(), and mutualInformation().

Here is the call graph for this function:

◆ nameFromId()

INLINE const std::string & gum::learning::IBNLearner::nameFromId ( NodeId id ) const

returns the variable name corresponding to a given node id

Definition at line 141 of file IBNLearner_inl.h.

                                                                {
    return scoreDatabase_.nameFromId(id);
  }

References scoreDatabase_.

◆ names()

INLINE const std::vector< std::string > & gum::learning::IBNLearner::names ( ) const

returns the names of the variables in the database

Definition at line 705 of file IBNLearner_inl.h.

                                                               {
    return scoreDatabase_.names();
  }

References scoreDatabase_.

◆ nbCols()

INLINE Size gum::learning::IBNLearner::nbCols ( ) const

Returns: the number of cols in the database

Definition at line 736 of file IBNLearner_inl.h.

736{ return scoreDatabase_.domainSizes().size(); }

References scoreDatabase_.

◆ nbrIterations()

INLINE Size gum::learning::IBNLearner::nbrIterations ( ) const

overridevirtual

Exceptions

OperationNotAllowed if scheme not performed

Implements gum::IApproximationSchemeConfiguration.

Definition at line 944 of file IBNLearner_inl.h.

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

References currentAlgorithm_, and GUM_ERROR.

◆ nbRows()

INLINE Size gum::learning::IBNLearner::nbRows ( ) const

Returns: the number of rows in the database

Definition at line 738 of file IBNLearner_inl.h.

738{ return scoreDatabase_.databaseTable().size(); }

References scoreDatabase_.

◆ operator=() [1/2]

IBNLearner & gum::learning::IBNLearner::operator= ( const IBNLearner & from )

copy operator

Definition at line 280 of file IBNLearner.cpp.

                                                        {
    if (this != &from) {
      if (score_) {
        delete score_;
        score_ = nullptr;
      }
 
      if (prior_) {
        delete prior_;
        prior_ = nullptr;
      }
 
      if (priorDatabase_) {
        delete priorDatabase_;
        priorDatabase_ = nullptr;
      }
 
      if (mutualInfo_) {
        delete mutualInfo_;
        mutualInfo_ = nullptr;
      }
 
      ThreadNumberManager::operator=(from);
      scoreType_                 = from.scoreType_;
      paramEstimatorType_        = from.paramEstimatorType_;
      useEM_                     = from.useEM_;
      noiseEM_                   = from.noiseEM_;
      priorType_                 = from.priorType_;
      priorWeight_               = from.priorWeight_;
      constraintSliceOrder_      = from.constraintSliceOrder_;
      constraintIndegree_        = from.constraintIndegree_;
      constraintTabuList_        = from.constraintTabuList_;
      constraintForbiddenArcs_   = from.constraintForbiddenArcs_;
      constraintNoParentNodes_   = from.constraintNoParentNodes_;
      constraintNoChildrenNodes_ = from.constraintNoChildrenNodes_;
      constraintMandatoryArcs_   = from.constraintMandatoryArcs_;
      selectedAlgo_              = from.selectedAlgo_;
      algoK2_                    = from.algoK2_;
      algoSimpleMiic_            = from.algoSimpleMiic_;
      algoMiic_                  = from.algoMiic_;
      kmodeMiic_                 = from.kmodeMiic_;
      dag2BN_                    = from.dag2BN_;
      greedyHillClimbing_        = from.greedyHillClimbing_;
      localSearchWithTabuList_   = from.localSearchWithTabuList_;
      scoreDatabase_             = from.scoreDatabase_;
      ranges_                    = from.ranges_;
      priorDbname_               = from.priorDbname_;
      initialDag_                = from.initialDag_;
      filename_                  = from.filename_;
      nbDecreasingChanges_       = from.nbDecreasingChanges_;
      currentAlgorithm_          = nullptr;
    }
 
    return *this;
  }

References IBNLearner(), algoK2_, algoMiic_, algoSimpleMiic_, constraintForbiddenArcs_, constraintIndegree_, constraintMandatoryArcs_, constraintNoChildrenNodes_, constraintNoParentNodes_, constraintSliceOrder_, constraintTabuList_, currentAlgorithm_, dag2BN_, filename_, greedyHillClimbing_, initialDag_, kmodeMiic_, localSearchWithTabuList_, mutualInfo_, nbDecreasingChanges_, noiseEM_, gum::ThreadNumberManager::operator=(), paramEstimatorType_, prior_, priorDatabase_, priorDbname_, priorType_, priorWeight_, ranges_, score_, scoreDatabase_, scoreType_, selectedAlgo_, and useEM_.

Here is the call graph for this function:

◆ operator=() [2/2]

IBNLearner & gum::learning::IBNLearner::operator= ( IBNLearner && from )

move operator

Definition at line 336 of file IBNLearner.cpp.

                                                   {
    if (this != &from) {
      if (score_) {
        delete score_;
        score_ = nullptr;
      }
 
      if (prior_) {
        delete prior_;
        prior_ = nullptr;
      }
 
      if (priorDatabase_) {
        delete priorDatabase_;
        priorDatabase_ = nullptr;
      }
 
      if (mutualInfo_) {
        delete mutualInfo_;
        mutualInfo_ = nullptr;
      }
 
      ThreadNumberManager::operator=(std::move(from));
      scoreType_                 = from.scoreType_;
      paramEstimatorType_        = from.paramEstimatorType_;
      useEM_                     = from.useEM_;
      noiseEM_                   = from.noiseEM_;
      priorType_                 = from.priorType_;
      priorWeight_               = from.priorWeight_;
      constraintSliceOrder_      = std::move(from.constraintSliceOrder_);
      constraintIndegree_        = std::move(from.constraintIndegree_);
      constraintTabuList_        = std::move(from.constraintTabuList_);
      constraintForbiddenArcs_   = std::move(from.constraintForbiddenArcs_);
      constraintNoParentNodes_   = std::move(from.constraintNoParentNodes_);
      constraintNoChildrenNodes_ = std::move(from.constraintNoChildrenNodes_);
      constraintMandatoryArcs_   = std::move(from.constraintMandatoryArcs_);
      selectedAlgo_              = from.selectedAlgo_;
      algoK2_                    = from.algoK2_;
      algoSimpleMiic_            = std::move(from.algoSimpleMiic_);
      algoMiic_                  = std::move(from.algoMiic_);
      kmodeMiic_                 = from.kmodeMiic_;
      dag2BN_                    = std::move(from.dag2BN_);
      greedyHillClimbing_        = std::move(from.greedyHillClimbing_);
      localSearchWithTabuList_   = std::move(from.localSearchWithTabuList_);
      scoreDatabase_             = std::move(from.scoreDatabase_);
      ranges_                    = std::move(from.ranges_);
      priorDbname_               = std::move(from.priorDbname_);
      filename_                  = std::move(from.filename_);
      initialDag_                = std::move(from.initialDag_);
      nbDecreasingChanges_       = std::move(from.nbDecreasingChanges_);
      currentAlgorithm_          = nullptr;
    }
 
    return *this;
  }

References IBNLearner(), algoK2_, algoMiic_, algoSimpleMiic_, constraintForbiddenArcs_, constraintIndegree_, constraintMandatoryArcs_, constraintNoChildrenNodes_, constraintNoParentNodes_, constraintSliceOrder_, constraintTabuList_, currentAlgorithm_, dag2BN_, filename_, greedyHillClimbing_, initialDag_, kmodeMiic_, localSearchWithTabuList_, mutualInfo_, nbDecreasingChanges_, noiseEM_, gum::ThreadNumberManager::operator=(), paramEstimatorType_, prior_, priorDatabase_, priorDbname_, priorType_, priorWeight_, ranges_, score_, scoreDatabase_, scoreType_, selectedAlgo_, and useEM_.

Here is the call graph for this function:

◆ periodSize()

INLINE Size gum::learning::IBNLearner::periodSize ( ) const

overridevirtual

how many samples between 2 stopping isEnableds

Exceptions

OutOfBounds if p<1

Implements gum::IApproximationSchemeConfiguration.

Definition at line 921 of file IBNLearner_inl.h.

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

References currentAlgorithm_, and GUM_ERROR.

◆ prepareFCI_()

MixedGraph gum::learning::IBNLearner::prepareFCI_ ( )

protected

prepares the initial graph and independence test for FCI

Definition at line 803 of file IBNLearner.cpp.

                                     {
    MixedGraph mgraph;
    DiGraph    forbiddenGraph;
    DAG        mandatoryGraph;
 
    for (Size i = 0; i < scoreDatabase_.databaseTable().nbVariables(); ++i) {
      mgraph.addNodeWithId(i);
      forbiddenGraph.addNodeWithId(i);
      mandatoryGraph.addNodeWithId(i);
    }
 
    const EdgeSet& possible_edges = constraintPossibleEdges_.edges();
    if (possible_edges.empty()) {
      for (const NodeId i: mgraph.nodes()) {
        for (NodeId j = 0; j < i; ++j) {
          mgraph.addEdge(j, i);
        }
      }
    } else {
      for (const auto& edge: possible_edges) {
        mgraph.addEdge(edge.first(), edge.second());
      }
    }
 
    for (const auto& arc: constraintMandatoryArcs_.arcs()) {
      mandatoryGraph.addArc(arc.tail(), arc.head());
      forbiddenGraph.addArc(arc.head(), arc.tail());
    }
    for (const auto& arc: constraintForbiddenArcs_.arcs()) {
      forbiddenGraph.addArc(arc.tail(), arc.head());
    }
 
    const gum::NodeProperty< gum::Size > sliceOrder = constraintSliceOrder_.sliceOrder();
    gum::NodeProperty< gum::Size >       copyOrder  = gum::HashTable(sliceOrder);
    for (const auto& [n1, r1]: sliceOrder) {
      for (const auto& [n2, r2]: copyOrder) {
        if (r1 > r2) {
          forbiddenGraph.addArc(n1, n2);
        } else if (r2 > r1) {
          forbiddenGraph.addArc(n2, n1);
        }
      }
      copyOrder.erase(n1);
    }
 
    const auto& totalOrder = constraintTotalOrder_.totalOrder();
    for (auto iter1 = totalOrder.begin(); iter1 != totalOrder.end(); ++iter1) {
      for (auto iter2 = iter1 + 1; iter2 != totalOrder.end(); ++iter2) {
        forbiddenGraph.addArc(*iter2, *iter1);
      }
    }
 
    for (const auto node: constraintNoParentNodes_.nodes()) {
      for (const auto node2: mgraph.nodes()) {
        if (node != node2) { forbiddenGraph.addArc(node2, node); }
      }
    }
    for (const auto node: constraintNoChildrenNodes_.nodes()) {
      for (const auto node2: mgraph.nodes()) {
        if (node != node2) { forbiddenGraph.addArc(node, node2); }
      }
    }
 
    if (indepTestFCI_) {
      delete indepTestFCI_;
      indepTestFCI_ = nullptr;
    }
    if (indepTestTypeFCI_ == IndepTestType::Chi2) {
      indepTestFCI_ = new IndepTestChi2(scoreDatabase_.parser(),
                                        *noPrior_,
                                        ranges_,
                                        scoreDatabase_.nodeId2Columns());
    } else {
      indepTestFCI_ = new IndepTestG2(scoreDatabase_.parser(),
                                      *noPrior_,
                                      ranges_,
                                      scoreDatabase_.nodeId2Columns());
    }
 
    algoFCI_.setMaxIndegree(constraintIndegree_.maxIndegree());
    algoFCI_.setMandatoryGraph(mandatoryGraph);
    algoFCI_.setForbiddenGraph(forbiddenGraph);
    algoFCI_.setIndependenceTest(*indepTestFCI_);
    algoFCI_.setAlpha(alphaFci_);
    algoFCI_.setMaxPathLength(maxPathLengthFci_);
    algoFCI_.setExhaustiveSepSet(exhaustiveSepSetFci_);
 
    return mgraph;
  }

References gum::DAG::addArc(), gum::DiGraph::addArc(), gum::UndiGraph::addEdge(), gum::NodeGraphPart::addNodeWithId(), algoFCI_, alphaFci_, Chi2, constraintForbiddenArcs_, constraintIndegree_, constraintMandatoryArcs_, constraintNoChildrenNodes_, constraintNoParentNodes_, constraintPossibleEdges_, constraintSliceOrder_, constraintTotalOrder_, gum::Set< Key >::empty(), exhaustiveSepSetFci_, indepTestFCI_, indepTestTypeFCI_, maxPathLengthFci_, gum::NodeGraphPart::nodes(), noPrior_, ranges_, and scoreDatabase_.

Referenced by learnDag_(), learnPAG_(), and learnPDAG_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ prepareMiic_()

MixedGraph gum::learning::IBNLearner::prepareMiic_ ( )

protected

prepares the initial graph for miic

Definition at line 611 of file IBNLearner.cpp.

                                      {
    // Initialize the mixed graph to the fully connected graph
    MixedGraph mgraph;
    DiGraph    forbiddenGraph;
    DAG        mandatoryGraph;
 
    // GUM_CHECKPOINT
    for (Size i = 0; i < scoreDatabase_.databaseTable().nbVariables(); ++i) {
      mgraph.addNodeWithId(i);
      forbiddenGraph.addNodeWithId(i);
      mandatoryGraph.addNodeWithId(i);
    }
 
    const EdgeSet& possible_edges = constraintPossibleEdges_.edges();
 
    if (possible_edges.empty()) {
      for (const NodeId i: mgraph.nodes()) {
        for (NodeId j = 0; j < i; ++j) {
          // contiguous nodeIds !
          mgraph.addEdge(j, i);
        }
      }
    } else {
      for (const auto& edge: possible_edges) {
        mgraph.addEdge(edge.first(), edge.second());
      }
    }
    // GUM_CHECKPOINT
 
    // translating the mandatory arcs for constraintMiic
    HashTable< std::pair< NodeId, NodeId >, char > initial_marks;
    const ArcSet&                                  mandatory_arcs = constraintMandatoryArcs_.arcs();
 
    // GUM_CHECKPOINT
    for (const auto& arc: mandatory_arcs) {
      mandatoryGraph.addArc(arc.tail(), arc.head());
      // MIIC's marks mechanism (orientationMiic_) handles the reverse direction;
      // adding it to forbiddenGraph would cause DuplicateElement (unlike preparePC_).
    }
 
    // GUM_CHECKPOINT
    //  translating the forbidden arcs for constraintMiic
    const ArcSet& forbidden_arcs = constraintForbiddenArcs_.arcs();
    for (const auto& arc: forbidden_arcs) {
      forbiddenGraph.addArc(arc.tail(), arc.head());
    }
 
    // GUM_CHECKPOINT
    const gum::NodeProperty< gum::Size > sliceOrder = constraintSliceOrder_.sliceOrder();
    gum::NodeProperty< gum::Size >       copyOrder  = gum::HashTable(sliceOrder);
    for (const auto& [n1, r1]: sliceOrder) {
      for (const auto& [n2, r2]: copyOrder) {
        if (r1 > r2) {
          forbiddenGraph.addArc(n1, n2);
          // initial_marks.insert({n1, n2}, '-');
        } else if (r2 > r1) {
          forbiddenGraph.addArc(n2, n1);
          // initial_marks.insert({n2, n1}, '-');
        }
      }
      copyOrder.erase(n1);
    }
 
    // GUM_CHECKPOINT
    const auto& totalOrder = constraintTotalOrder_.totalOrder();
    for (auto iter1 = totalOrder.begin(); iter1 != totalOrder.end(); ++iter1) {
      const auto node1 = *iter1;
      for (auto iter2 = iter1 + 1; iter2 != totalOrder.end(); ++iter2) {
        forbiddenGraph.addArc(*iter2, node1);
      }
    }
 
    for (const auto node: constraintNoParentNodes_.nodes()) {
      for (const auto node2: mgraph.nodes()) {
        if (node != node2) { forbiddenGraph.addArc(node2, node); }
      }
    }
 
    for (const auto node: constraintNoChildrenNodes_.nodes()) {
      for (const auto node2: mgraph.nodes()) {
        if (node != node2) { forbiddenGraph.addArc(node, node2); }
      }
    }
 
    // GUM_CHECKPOINT
    algoMiic_.setMaxIndegree(constraintIndegree_.maxIndegree());
    algoMiic_.addConstraints(initial_marks);
    algoMiic_.setMandatoryGraph(mandatoryGraph);
    algoMiic_.setForbiddenGraph(forbiddenGraph);
 
    // GUM_CHECKPOINT
    // create the mutual entropy object
    // if ( _mutual_info_ == nullptr) { this->useNMLCorrection(); }
    createCorrectedMutualInformation_();
 
    // GUM_CHECKPOINT
    return mgraph;
  }

References gum::DAG::addArc(), gum::DiGraph::addArc(), gum::UndiGraph::addEdge(), gum::NodeGraphPart::addNodeWithId(), algoMiic_, constraintForbiddenArcs_, constraintIndegree_, constraintMandatoryArcs_, constraintNoChildrenNodes_, constraintNoParentNodes_, constraintPossibleEdges_, constraintSliceOrder_, constraintTotalOrder_, createCorrectedMutualInformation_(), gum::Set< Key >::empty(), gum::NodeGraphPart::nodes(), and scoreDatabase_.

Referenced by learnDag_(), and learnPDAG_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ preparePC_()

MixedGraph gum::learning::IBNLearner::preparePC_ ( )

protected

prepares the initial graph and independence test for PC

Definition at line 710 of file IBNLearner.cpp.

                                    {
    MixedGraph mgraph;
    DiGraph    forbiddenGraph;
    DAG        mandatoryGraph;
 
    for (Size i = 0; i < scoreDatabase_.databaseTable().nbVariables(); ++i) {
      mgraph.addNodeWithId(i);
      forbiddenGraph.addNodeWithId(i);
      mandatoryGraph.addNodeWithId(i);
    }
 
    const EdgeSet& possible_edges = constraintPossibleEdges_.edges();
    if (possible_edges.empty()) {
      for (const NodeId i: mgraph.nodes()) {
        for (NodeId j = 0; j < i; ++j) {
          mgraph.addEdge(j, i);
        }
      }
    } else {
      for (const auto& edge: possible_edges) {
        mgraph.addEdge(edge.first(), edge.second());
      }
    }
 
    for (const auto& arc: constraintMandatoryArcs_.arcs()) {
      mandatoryGraph.addArc(arc.tail(), arc.head());
      forbiddenGraph.addArc(arc.head(), arc.tail());
    }
    for (const auto& arc: constraintForbiddenArcs_.arcs()) {
      forbiddenGraph.addArc(arc.tail(), arc.head());
    }
 
    const gum::NodeProperty< gum::Size > sliceOrder = constraintSliceOrder_.sliceOrder();
    gum::NodeProperty< gum::Size >       copyOrder  = gum::HashTable(sliceOrder);
    for (const auto& [n1, r1]: sliceOrder) {
      for (const auto& [n2, r2]: copyOrder) {
        if (r1 > r2) {
          forbiddenGraph.addArc(n1, n2);
        } else if (r2 > r1) {
          forbiddenGraph.addArc(n2, n1);
        }
      }
      copyOrder.erase(n1);
    }
 
    const auto& totalOrder = constraintTotalOrder_.totalOrder();
    for (auto iter1 = totalOrder.begin(); iter1 != totalOrder.end(); ++iter1) {
      for (auto iter2 = iter1 + 1; iter2 != totalOrder.end(); ++iter2) {
        forbiddenGraph.addArc(*iter2, *iter1);
      }
    }
 
    for (const auto node: constraintNoParentNodes_.nodes()) {
      for (const auto node2: mgraph.nodes()) {
        if (node != node2) { forbiddenGraph.addArc(node2, node); }
      }
    }
    for (const auto node: constraintNoChildrenNodes_.nodes()) {
      for (const auto node2: mgraph.nodes()) {
        if (node != node2) { forbiddenGraph.addArc(node, node2); }
      }
    }
 
    // build the independence test (owned by IBNLearner)
    if (indepTestPC_) {
      delete indepTestPC_;
      indepTestPC_ = nullptr;
    }
    if (indepTestTypePC_ == IndepTestType::Chi2) {
      indepTestPC_ = new IndepTestChi2(scoreDatabase_.parser(),
                                       *noPrior_,
                                       ranges_,
                                       scoreDatabase_.nodeId2Columns());
    } else {
      indepTestPC_ = new IndepTestG2(scoreDatabase_.parser(),
                                     *noPrior_,
                                     ranges_,
                                     scoreDatabase_.nodeId2Columns());
    }
 
    algoPC_.setMaxIndegree(constraintIndegree_.maxIndegree());
    algoPC_.setMandatoryGraph(mandatoryGraph);
    algoPC_.setForbiddenGraph(forbiddenGraph);
    algoPC_.setIndependenceTest(*indepTestPC_);
    algoPC_.setAlpha(alphaPc_);
    algoPC_.setStable(stablePc_);
    algoPC_.setMaxCondSetSize(maxCondSetSizePc_);
    algoPC_.setUCPriority(sortedUCPc_ ? gum::learning::PC::UCPriority::Sorted
                                      : gum::learning::PC::UCPriority::Standard);
 
    return mgraph;
  }

References gum::DAG::addArc(), gum::DiGraph::addArc(), gum::UndiGraph::addEdge(), gum::NodeGraphPart::addNodeWithId(), algoPC_, alphaPc_, Chi2, constraintForbiddenArcs_, constraintIndegree_, constraintMandatoryArcs_, constraintNoChildrenNodes_, constraintNoParentNodes_, constraintPossibleEdges_, constraintSliceOrder_, constraintTotalOrder_, gum::Set< Key >::empty(), indepTestPC_, indepTestTypePC_, maxCondSetSizePc_, gum::NodeGraphPart::nodes(), noPrior_, ranges_, scoreDatabase_, gum::learning::CIBasedLearning::Sorted, sortedUCPc_, stablePc_, and gum::learning::CIBasedLearning::Standard.

Referenced by learnDag_(), and learnPDAG_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ prepareSimpleMiic_()

MixedGraph gum::learning::IBNLearner::prepareSimpleMiic_ ( )

protected

prepares the initial graph for Simple Miic

◆ rawPseudoCount() [1/2]

std::vector< double > gum::learning::IBNLearner::rawPseudoCount ( const std::vector< NodeId > & vars )

Return the pseudo-counts of NodeIds vars in the base in a raw array.

Parameters

vars	a vector of

Returns: a std::vector<double> containing the contingency table

Definition at line 1481 of file IBNLearner.cpp.

                                                                                {
    if (this->hasMissingValues()) {
      GUM_ERROR(MissingValueInDatabase,
                "BNLearner cannot compute pseudo-counts with missing values in the database")
    }
    if (vars.empty()) {
      GUM_ERROR(OutOfBounds, "BNLearner::rawPseudoCount called with an empty vector of variables")
    }
    Tensor< double > res;
 
    createPrior_();
    gum::learning::PseudoCount count(scoreDatabase_.parser(), *prior_, databaseRanges());
    return count.get(vars);
  }

References createPrior_(), databaseRanges(), gum::learning::PseudoCount::get(), GUM_ERROR, hasMissingValues(), prior_, and scoreDatabase_.

Referenced by rawPseudoCount().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ rawPseudoCount() [2/2]

std::vector< double > gum::learning::IBNLearner::rawPseudoCount ( const std::vector< std::string > & vars )

Return the pseudoconts of vars in the base in a raw array.

Parameters

vars	a vector of name

Returns: a std::vector<double> containing the contingency table

Definition at line 1496 of file IBNLearner.cpp.

                                                                                   {
    std::vector< NodeId > ids;
 
    auto mapper = [this](const std::string& c) { return this->idFromName(c); };
 
    std::transform(vars.begin(), vars.end(), std::back_inserter(ids), mapper);
    return rawPseudoCount(ids);
  }

References idFromName(), and rawPseudoCount().

Here is the call graph for this function:

◆ readFile_()

DatabaseTable gum::learning::IBNLearner::readFile_	(	std::string_view	filename,
		const std::vector< std::string > &	missing_symbols )

staticprotected

reads a file and returns a databaseVectInRam

Definition at line 446 of file IBNLearner.cpp.

                                                                                     {
    // get the extension of the file
    isCSVFileName_(filename);
 
    DBInitializerFromCSV initializer{std::string(filename)};
 
    const auto&       var_names = initializer.variableNames();
    const std::size_t nb_vars   = var_names.size();
 
    DBTranslatorSet                translator_set;
    DBTranslator4LabelizedVariable translator(missing_symbols);
    for (std::size_t i = 0; i < nb_vars; ++i) {
      translator_set.insertTranslator(translator, i);
    }
 
    DatabaseTable database(missing_symbols, translator_set);
    database.setVariableNames(initializer.variableNames());
    initializer.fillDatabase(database);
 
    database.reorder();
 
    return database;
  }

References database(), gum::learning::IDBInitializer::fillDatabase(), gum::learning::DBTranslatorSet::insertTranslator(), isCSVFileName_(), and gum::learning::IDBInitializer::variableNames().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ recordWeight()

INLINE double gum::learning::IBNLearner::recordWeight ( const std::size_t i ) const

returns the weight of the ith record

Exceptions

OutOfBounds if i is outside the set of indices of the records

Definition at line 156 of file IBNLearner_inl.h.

                                                                {
    return scoreDatabase_.weight(i);
  }

References scoreDatabase_.

◆ score() [1/2]

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

Return the value of the score currently in use by the BNLearner of a variable given a set of other variables.

Parameters

var	the NodeId of the LHS variable
knowing	an optional vector of conditioning variables, specified by their NodeIds

Returns: a double corresponding to the value of the score

Definition at line 1463 of file IBNLearner.cpp.

                                                                               {
    createPrior_();
    createScore_();
 
    return score_->score(var, knowing);
  }

References createPrior_(), createScore_(), and score_.

Referenced by score(), and useDatabaseRanges().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ score() [2/2]

double gum::learning::IBNLearner::score	(	std::string_view	vars,
		const std::vector< std::string > &	knowing = {} )

Return the value of the score currently in use by the BNLearner of a variable given a set of other variables The score used is the one currently selected in the BNLearner.

Parameters

var	the name of the variable
knowing	an optional vector of conditioning variables, specified by their names

Returns: a double corresponding to the value of the score

Definition at line 1470 of file IBNLearner.cpp.

                                                                                    {
    auto mapper = [this](const std::string& c) { return this->idFromName(c); };
 
    const NodeId          id = this->idFromName(var);
    std::vector< NodeId > knowingIds;
    knowingIds.reserve(knowing.size());
    std::transform(knowing.begin(), knowing.end(), std::back_inserter(knowingIds), mapper);
 
    return score(id, knowingIds);
  }

References idFromName(), and score().

Here is the call graph for this function:

◆ setCurrentApproximationScheme()

INLINE void gum::learning::IBNLearner::setCurrentApproximationScheme ( const ApproximationScheme * approximationScheme )

{@ /// distribute signals

Definition at line 767 of file IBNLearner_inl.h.

                                                                                              {
    currentAlgorithm_ = approximationScheme;
  }

References currentAlgorithm_.

Referenced by gum::learning::BNLearnerListener::BNLearnerListener(), distributeProgress(), and distributeStop().

Here is the caller graph for this function:

◆ setDatabaseWeight()

INLINE void gum::learning::IBNLearner::setDatabaseWeight ( const double new_weight )

assign a weight to all the rows of the learning database so that the sum of their weights is equal to new_weight

assign new weight to the rows of the learning database

Definition at line 146 of file IBNLearner_inl.h.

                                                                   {
    scoreDatabase_.setDatabaseWeight(new_weight);
  }

References scoreDatabase_.

◆ setEpsilon()

INLINE void gum::learning::IBNLearner::setEpsilon ( double eps )

overridevirtual

Given that we approximate f(t), stopping criterion on |f(t+1)-f(t)| If the criterion was disabled it will be enabled.

Exceptions

OutOfBounds if eps<0

Implements gum::IApproximationSchemeConfiguration.

Definition at line 785 of file IBNLearner_inl.h.

                                               {
    algoK2_.approximationScheme().setEpsilon(eps);
    greedyHillClimbing_.setEpsilon(eps);
    localSearchWithTabuList_.setEpsilon(eps);
    dag2BN_.setEpsilon(eps);
  }

References algoK2_, dag2BN_, greedyHillClimbing_, and localSearchWithTabuList_.

◆ setFCIAlpha()

INLINE void gum::learning::IBNLearner::setFCIAlpha ( double alpha )

set the significance threshold alpha for FCI (default 0.05)

Exceptions

OperationNotAllowed when FCI is not the selected algorithm

Definition at line 247 of file IBNLearner_inl.h.

                                                  {
    if (selectedAlgo_ != AlgoType::FCI) {
      GUM_ERROR(OperationNotAllowed, "setFCIAlpha() is only valid when using the FCI algorithm")
    }
    alphaFci_ = alpha;
  }

References alphaFci_, FCI, GUM_ERROR, and selectedAlgo_.

◆ setFCIExhaustiveSepSet()

INLINE void gum::learning::IBNLearner::setFCIExhaustiveSepSet ( bool exhaustive )

enable exhaustive sepset mode for FCI skeleton learning (default false)

Exceptions

OperationNotAllowed when FCI is not the selected algorithm

Definition at line 263 of file IBNLearner_inl.h.

                                                                {
    if (selectedAlgo_ != AlgoType::FCI) {
      GUM_ERROR(OperationNotAllowed,
                "setFCIExhaustiveSepSet() is only valid when using the FCI algorithm")
    }
    exhaustiveSepSetFci_ = exhaustive;
  }

References exhaustiveSepSetFci_, FCI, GUM_ERROR, and selectedAlgo_.

◆ setFCIMaxPathLength()

INLINE void gum::learning::IBNLearner::setFCIMaxPathLength ( Size max_len )

set maximum discriminating-path length for FCI R4 (default Size(-1) = unlimited)

Exceptions

OperationNotAllowed when FCI is not the selected algorithm

Definition at line 255 of file IBNLearner_inl.h.

                                                          {
    if (selectedAlgo_ != AlgoType::FCI) {
      GUM_ERROR(OperationNotAllowed,
                "setFCIMaxPathLength() is only valid when using the FCI algorithm")
    }
    maxPathLengthFci_ = max_len;
  }

References FCI, GUM_ERROR, maxPathLengthFci_, and selectedAlgo_.

◆ setForbiddenArcs()

INLINE void gum::learning::IBNLearner::setForbiddenArcs ( const ArcSet & set )

removes a total

assign a set of forbidden arcs

Definition at line 512 of file IBNLearner_inl.h.

                                                            {
    constraintForbiddenArcs_.setArcs(set);
  }

References constraintForbiddenArcs_.

◆ setGreedyThickThinningReversals()

INLINE void gum::learning::IBNLearner::setGreedyThickThinningReversals ( bool allow )

enable or disable arc reversals in the thin phase of greedy thick-thinning

Definition at line 377 of file IBNLearner_inl.h.

                                                                    {
    greedyThickThinning_.setAllowReversalsInThinPhase(allow);
  }

References greedyThickThinning_.

◆ setInitialDAG()

INLINE void gum::learning::IBNLearner::setInitialDAG ( const DAG & dag )

sets an initial DAG structure

Definition at line 164 of file IBNLearner_inl.h.

164{ initialDag_ = dag; }

References initialDag_.

◆ setMandatoryArcs()

INLINE void gum::learning::IBNLearner::setMandatoryArcs ( const ArcSet & set )

assign a set of mandatory arcs

Definition at line 545 of file IBNLearner_inl.h.

                                                            {
    constraintMandatoryArcs_.setArcs(set);
  }

References constraintMandatoryArcs_.

◆ setMaxIndegree()

INLINE void gum::learning::IBNLearner::setMaxIndegree ( Size max_indegree )

sets the max indegree

Definition at line 217 of file IBNLearner_inl.h.

                                                          {
    constraintIndegree_.setMaxIndegree(max_indegree);
  }

References constraintIndegree_.

◆ setMaxIter()

INLINE void gum::learning::IBNLearner::setMaxIter ( Size max )

overridevirtual

stopping criterion on number of iterationsIf the criterion was disabled it will be enabled

Parameters

max	The maximum number of iterations

Exceptions

OutOfBounds if max<=1

Implements gum::IApproximationSchemeConfiguration.

Definition at line 847 of file IBNLearner_inl.h.

                                             {
    algoK2_.approximationScheme().setMaxIter(max);
    greedyHillClimbing_.setMaxIter(max);
    localSearchWithTabuList_.setMaxIter(max);
    dag2BN_.setMaxIter(max);
  }

References algoK2_, dag2BN_, greedyHillClimbing_, and localSearchWithTabuList_.

◆ setMaxTime()

INLINE void gum::learning::IBNLearner::setMaxTime ( double timeout )

overridevirtual

stopping criterion on timeout If the criterion was disabled it will be enabled

Exceptions

OutOfBounds if timeout<=0.0 timeout is time in second (double).

Implements gum::IApproximationSchemeConfiguration.

Definition at line 878 of file IBNLearner_inl.h.

                                                   {
    algoK2_.approximationScheme().setMaxTime(timeout);
    greedyHillClimbing_.setMaxTime(timeout);
    localSearchWithTabuList_.setMaxTime(timeout);
    dag2BN_.setMaxTime(timeout);
  }

References algoK2_, dag2BN_, greedyHillClimbing_, and localSearchWithTabuList_.

◆ setMinEpsilonRate()

INLINE void gum::learning::IBNLearner::setMinEpsilonRate ( double rate )

overridevirtual

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.

Exceptions

OutOfBounds if rate<0

Implements gum::IApproximationSchemeConfiguration.

Definition at line 816 of file IBNLearner_inl.h.

                                                       {
    algoK2_.approximationScheme().setMinEpsilonRate(rate);
    greedyHillClimbing_.setMinEpsilonRate(rate);
    localSearchWithTabuList_.setMinEpsilonRate(rate);
    dag2BN_.setMinEpsilonRate(rate);
  }

References algoK2_, dag2BN_, greedyHillClimbing_, and localSearchWithTabuList_.

◆ setNumberOfThreads()

INLINE void gum::learning::IBNLearner::setNumberOfThreads ( Size nb )

overridevirtual

sets the number max of threads that can be used

Parameters

nb	the number max of threads to be used. If this number is set to 0, then it is defaulted to aGrUM's max number of threads

Implements gum::IThreadNumberManager.

Definition at line 741 of file IBNLearner_inl.h.

                                                    {
    ThreadNumberManager::setNumberOfThreads(nb);
    if (score_ != nullptr) score_->setNumberOfThreads(nb);
  }

References score_, and gum::ThreadNumberManager::setNumberOfThreads().

Here is the call graph for this function:

◆ setPCAlpha()

INLINE void gum::learning::IBNLearner::setPCAlpha ( double alpha )

set the significance threshold alpha for PC (default 0.05)

Exceptions

OperationNotAllowed when PC is not the selected algorithm

Definition at line 296 of file IBNLearner_inl.h.

                                                 {
    if (selectedAlgo_ != AlgoType::PC) {
      GUM_ERROR(OperationNotAllowed, "setPCAlpha() is only valid when using the PC algorithm")
    }
    alphaPc_ = alpha;
  }

References alphaPc_, GUM_ERROR, PC, and selectedAlgo_.

◆ setPCMaxCondSetSize()

INLINE void gum::learning::IBNLearner::setPCMaxCondSetSize ( Size max_k )

set maximum conditioning set size for PC (default Size(-1) = unlimited)

Exceptions

OperationNotAllowed when PC is not the selected algorithm

Definition at line 312 of file IBNLearner_inl.h.

                                                        {
    if (selectedAlgo_ != AlgoType::PC) {
      GUM_ERROR(OperationNotAllowed,
                "setPCMaxCondSetSize() is only valid when using the PC algorithm")
    }
    maxCondSetSizePc_ = max_k;
  }

References GUM_ERROR, maxCondSetSizePc_, PC, and selectedAlgo_.

◆ setPCStable()

INLINE void gum::learning::IBNLearner::setPCStable ( bool stable )

set stable mode for PC — defer removals to end of each depth level (default true)

Exceptions

OperationNotAllowed when PC is not the selected algorithm

Definition at line 304 of file IBNLearner_inl.h.

                                                 {
    if (selectedAlgo_ != AlgoType::PC) {
      GUM_ERROR(OperationNotAllowed, "setPCStable() is only valid when using the PC algorithm")
    }
    stablePc_ = stable;
  }

References GUM_ERROR, PC, selectedAlgo_, and stablePc_.

◆ setPCUnshieldedColliderSorted()

INLINE void gum::learning::IBNLearner::setPCUnshieldedColliderSorted ( bool sorted )

set unshielded-collider ordering for PC: sorted=true uses descending p-value order (strongest evidence first); sorted=false uses natural traversal order (default false)

Exceptions

OperationNotAllowed when PC is not the selected algorithm

Definition at line 321 of file IBNLearner_inl.h.

                                                                   {
    if (selectedAlgo_ != AlgoType::PC) {
      GUM_ERROR(OperationNotAllowed,
                "setPCUnshieldedColliderSorted() is only valid when using the PC algorithm")
    }
    sortedUCPc_ = sorted;
  }

References GUM_ERROR, PC, selectedAlgo_, and sortedUCPc_.

◆ setPeriodSize()

INLINE void gum::learning::IBNLearner::setPeriodSize ( Size p )

overridevirtual

how many samples between 2 stopping isEnableds

Exceptions

OutOfBounds if p<1

Implements gum::IApproximationSchemeConfiguration.

Definition at line 914 of file IBNLearner_inl.h.

                                              {
    algoK2_.approximationScheme().setPeriodSize(p);
    greedyHillClimbing_.setPeriodSize(p);
    localSearchWithTabuList_.setPeriodSize(p);
    dag2BN_.setPeriodSize(p);
  }

References algoK2_, dag2BN_, greedyHillClimbing_, and localSearchWithTabuList_.

◆ setPossibleEdges()

INLINE void gum::learning::IBNLearner::setPossibleEdges ( const EdgeSet & set )

assign a set of possible edges

Warning: Once at least one possible edge is defined, all other edges are not possible anymore

Definition at line 472 of file IBNLearner_inl.h.

                                                             {
    constraintPossibleEdges_.setEdges(set);
  }

References constraintPossibleEdges_.

Referenced by setPossibleSkeleton().

Here is the caller graph for this function:

◆ setPossibleSkeleton()

INLINE void gum::learning::IBNLearner::setPossibleSkeleton ( const UndiGraph & skeleton )

assign a set of possible edges

Warning: Once at least one possible edge is defined, all other edges are not possible anymore

Definition at line 477 of file IBNLearner_inl.h.

                                                                   {
    setPossibleEdges(g.edges());
  }

References gum::EdgeGraphPart::edges(), and setPossibleEdges().

Here is the call graph for this function:

◆ setRecordWeight()

INLINE void gum::learning::IBNLearner::setRecordWeight	(	const std::size_t	i,
		const double	weight )

sets the weight of the ith record of the database

assign new weight to the ith row of the learning database

Exceptions

OutOfBounds if i is outside the set of indices of the records or if the weight is negative

Definition at line 151 of file IBNLearner_inl.h.

                                                                                    {
    scoreDatabase_.setWeight(i, new_weight);
  }

References scoreDatabase_.

◆ setSliceOrder() [1/2]

INLINE void gum::learning::IBNLearner::setSliceOrder ( const NodeProperty< NodeId > & slice_order )

sets a partial order on the nodes

Parameters

slice_order a NodeProperty given the rank (priority) of nodes in the partial order

Definition at line 608 of file IBNLearner_inl.h.

                                                                                 {
    constraintSliceOrder_ = StructuralConstraintSliceOrder(slice_order);
  }

References constraintSliceOrder_.

Referenced by setSliceOrder(), and unsetSliceOrder().

Here is the caller graph for this function:

◆ setSliceOrder() [2/2]

INLINE void gum::learning::IBNLearner::setSliceOrder ( const std::vector< std::vector< std::string > > & slices )

sets a partial order on the nodes

Parameters

slices the list of list of variable names. If it is empty, this is equivalent to removing the constraint (useful if you had previously added a slice order constraint and you do not want to use it anymore)

Definition at line 612 of file IBNLearner_inl.h.

                                                                                         {
    NodeProperty< NodeId > slice_order;
    NodeId                 rank = 0;
    for (const auto& slice: slices) {
      for (const auto& name: slice) {
        slice_order.insert(idFromName(name), rank);
      }
      rank++;
    }
    setSliceOrder(slice_order);
  }

References idFromName(), gum::HashTable< Key, Val >::insert(), and setSliceOrder().

Here is the call graph for this function:

◆ setTotalOrder() [1/2]

INLINE void gum::learning::IBNLearner::setTotalOrder ( const Sequence< NodeId > & order )

sets a total order over some nodes

This defines a total ordering constraint on the nodes belonging to the sequence. If you plan to use K2, do not use this constraint, prefer using method useK2(order).

Note that all the nodes of the graph to be learned need not belong to order: if a node does not belong to it, then it just means that there is no constraint on this node in the total ordering.

Note also that you can both exploit a total ordering and slice ordering. For instance, we may wish that the topological ordering of the graph we learn satisfies that 1 < 3 < 4 < 5 and 2 < 3, 4 and 5, then use a total ordering 1 < 3 < 4 < 5 combined with a slice ordering {2} < {3,4,5}.

Parameters

order

Definition at line 627 of file IBNLearner_inl.h.

                                                                       {
    constraintTotalOrder_ = StructuralConstraintTotalOrder(order);
  }

References constraintTotalOrder_.

Referenced by setTotalOrder(), and unsetTotalOrder().

Here is the caller graph for this function:

◆ setTotalOrder() [2/2]

INLINE void gum::learning::IBNLearner::setTotalOrder ( const std::vector< std::string > & order )

sets the max indegree

Definition at line 632 of file IBNLearner_inl.h.

                                                                           {
    Sequence< NodeId > sequence;
    for (const auto& name: order) {
      sequence.insert(idFromName(name));
    }
    setTotalOrder(sequence);
  }

References idFromName(), gum::SequenceImplementation< Key, std::is_scalar< Key >::value >::insert(), and setTotalOrder().

Here is the call graph for this function:

◆ setVerbosity()

INLINE void gum::learning::IBNLearner::setVerbosity ( bool v )

overridevirtual

verbosity

Implements gum::IApproximationSchemeConfiguration.

Definition at line 926 of file IBNLearner_inl.h.

                                             {
    algoK2_.approximationScheme().setVerbosity(v);
    greedyHillClimbing_.setVerbosity(v);
    localSearchWithTabuList_.setVerbosity(v);
    dag2BN_.setVerbosity(v);
  }

References algoK2_, dag2BN_, greedyHillClimbing_, and localSearchWithTabuList_.

◆ stateApproximationScheme()

INLINE IApproximationSchemeConfiguration::ApproximationSchemeSTATE gum::learning::IBNLearner::stateApproximationScheme ( ) const

overridevirtual

history

Implements gum::IApproximationSchemeConfiguration.

Definition at line 939 of file IBNLearner_inl.h.

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

References currentAlgorithm_, and GUM_ERROR.

◆ unsetSliceOrder()

INLINE void gum::learning::IBNLearner::unsetSliceOrder ( )

removes the slice order constraint

The methd is useful if you had previously added a slice order constraint and you do not want to use it anymore

Definition at line 624 of file IBNLearner_inl.h.

624{ setSliceOrder(NodeProperty< NodeId >()); }

References setSliceOrder().

Here is the call graph for this function:

◆ unsetTotalOrder()

INLINE void gum::learning::IBNLearner::unsetTotalOrder ( )

removes the current total ordering constraint, if any

Definition at line 641 of file IBNLearner_inl.h.

641{ setTotalOrder(Sequence< NodeId >()); }

References setTotalOrder().

Here is the call graph for this function:

◆ useBDeuPrior()

INLINE void gum::learning::IBNLearner::useBDeuPrior ( double weight = 1.0 )

use the BDeu prior

The BDeu prior adds weight to all the cells of the counts tables. In other words, it adds weight rows in the database with equally probable values.

Definition at line 679 of file IBNLearner_inl.h.

                                                    {
    if (weight < 0) { GUM_ERROR(OutOfBounds, "the weight of the prior must be positive") }
 
    priorType_ = BNLearnerPriorType::BDEU;
    _setPriorWeight_(weight);
 
    checkScorePriorCompatibility();
  }

References _setPriorWeight_(), BDEU, checkScorePriorCompatibility(), GUM_ERROR, and priorType_.

Here is the call graph for this function:

◆ useChi2Test()

INLINE void gum::learning::IBNLearner::useChi2Test ( )

indicate that we wish to use Chi2 independence test for PC

Exceptions

OperationNotAllowed when PC is not the selected algorithm

Definition at line 280 of file IBNLearner_inl.h.

                                      {
    if (selectedAlgo_ != AlgoType::PC) {
      GUM_ERROR(OperationNotAllowed, "useChi2Test() is only valid when using the PC algorithm")
    }
    indepTestTypePC_ = IndepTestType::Chi2;
  }

References Chi2, GUM_ERROR, indepTestTypePC_, PC, and selectedAlgo_.

◆ useCrossValidationFold()

std::pair< std::size_t, std::size_t > gum::learning::IBNLearner::useCrossValidationFold	(	const std::size_t	learning_fold,
		const std::size_t	k_fold )

sets the ranges of rows to be used for cross-validation learning

When applied on (x,k), the method indicates to the subsequent learnings that they should be performed on the xth fold in a k-fold cross-validation context. For instance, if a database has 1000 rows, and if we perform a 10-fold cross-validation, then, the first learning fold (learning_fold=0) corresponds to rows interval [100,1000) and the test dataset corresponds to [0,100). The second learning fold (learning_fold=1) is [0,100) U [200,1000) and the corresponding test dataset is [100,200).

Parameters

learning_fold	a number indicating the set of rows used for learning. If N denotes the size of the database, and k_fold represents the number of folds in the cross validation, then the set of rows used for testing is [learning_fold * N / k_fold, (learning_fold+1) * N / k_fold) and the learning database is the complement in the database
k_fold	the value of "k" in k-fold cross validation

Returns: a pair [x,y) of rows' indices that corresponds to the indices of rows in the original database that constitute the test dataset

Exceptions

OutOfBounds is raised if k_fold is equal to 0 or learning_fold is greater than or eqal to k_fold, or if k_fold is greater than or equal to the size of the database.

Definition at line 1299 of file IBNLearner.cpp.

                                                                 {
    if (k_fold == 0) { GUM_ERROR(OutOfBounds, "K-fold cross validation with k=0 is forbidden") }
 
    if (learning_fold >= k_fold) {
      GUM_ERROR(OutOfBounds,
                "In " << k_fold << "-fold cross validation, the learning "
                      << "fold should be strictly lower than " << k_fold
                      << " but, here, it is equal to " << learning_fold)
    }
 
    const std::size_t db_size = scoreDatabase_.databaseTable().nbRows();
    if (k_fold >= db_size) {
      GUM_ERROR(OutOfBounds,
                "In " << k_fold << "-fold cross validation, the database's "
                      << "size should be strictly greater than " << k_fold
                      << " but, here, the database has only " << db_size << "rows")
    }
 
    // create the ranges of rows of the test database
    const std::size_t foldSize   = db_size / k_fold;
    const std::size_t unfold_deb = learning_fold * foldSize;
    const std::size_t unfold_end = unfold_deb + foldSize;
 
    ranges_.clear();
    if (learning_fold == std::size_t(0)) {
      ranges_.push_back(std::pair< std::size_t, std::size_t >(unfold_end, db_size));
    } else {
      ranges_.push_back(std::pair< std::size_t, std::size_t >(std::size_t(0), unfold_deb));
 
      if (learning_fold != k_fold - 1) {
        ranges_.push_back(std::pair< std::size_t, std::size_t >(unfold_end, db_size));
      }
    }
 
    return std::pair< std::size_t, std::size_t >(unfold_deb, unfold_end);
  }

References GUM_ERROR, ranges_, and scoreDatabase_.

◆ useDatabaseRanges()

void gum::learning::IBNLearner::useDatabaseRanges ( const std::vector< std::pair< std::size_t, std::size_t > > & new_ranges )

use a new set of database rows' ranges to perform learning

Parameters

ranges a set of pairs {(X1,Y1),...,(Xn,Yn)} of database's rows indices. The subsequent learnings are then performed only on the union of the rows [Xi,Yi), i in {1,...,n}. This is useful, e.g, when performing cross validation tasks, in which part of the database should be ignored. An empty set of ranges is equivalent to an interval [X,Y) ranging over the whole database.

Definition at line 1506 of file IBNLearner.cpp.

                                                                      {
    // use a score to detect whether the ranges are ok
    ScoreLog2Likelihood score(scoreDatabase_.parser(), *noPrior_);
    score.setRanges(new_ranges);
    ranges_ = score.ranges();
  }

References noPrior_, ranges_, score(), and scoreDatabase_.

Here is the call graph for this function:

◆ useDirichletPrior()

INLINE void gum::learning::IBNLearner::useDirichletPrior	(	std::string_view	filename,
		double	weight = 1 )

use the Dirichlet prior from a database

Definition at line 668 of file IBNLearner_inl.h.

                                                                                  {
    if (weight < 0) { GUM_ERROR(OutOfBounds, "the weight of the prior must be positive") }
 
    priorDbname_ = filename;
    priorType_   = BNLearnerPriorType::DIRICHLET_FROM_DATABASE;
    _setPriorWeight_(weight);
 
    checkScorePriorCompatibility();
  }

References _setPriorWeight_(), checkScorePriorCompatibility(), DIRICHLET_FROM_DATABASE, GUM_ERROR, priorDbname_, and priorType_.

Here is the call graph for this function:

◆ useEM()

INLINE void gum::learning::IBNLearner::useEM	(	const double	epsilon,
		const double	noise = default_EM_noise )

use The EM algorithm to learn parameters

Parameters

epsilon	sets the approximation stopping criterion: EM stops whenever the absolute value of the relative difference between two consecutive log-likelihoods drops below epsilon. Note that epsilon=0 is considered as a directive to not use EM. However, if you wish to forbid the use of EM, prefer executing Method forbidEM() rather than useEM(0) as it is more unequivocal.
noise	When EM starts, it initializes all the CPTs of the Bayes net. EM adds a noise to these CPTs by mixing their values with some random noise. The formula used is, up to some normalizing constant: new_cpt = (1-noise) * cpt + noise * random_cpt(). Of course, noise must belong to interval [0,1].

Warning: if epsilon=0, EM is not used

Exceptions

OutOfBounds is raised if epsilon is strictly negative or if noise does not belong to interval [0,1].

Definition at line 395 of file IBNLearner_inl.h.

                                                                        {
    if (epsilon < 0.0)
      GUM_ERROR(OutOfBounds, "EM's min log-likelihood evolution rate must be non-negative");
    if ((noise < 0.0) || (noise > 1.0))
      GUM_ERROR(OutOfBounds, "EM's noise must belong to interval [0,1]");
    if (epsilon > 0) {
      useEM_ = true;
      dag2BN_.setMinEpsilonRate(epsilon);
      dag2BN_.setNoise(noise);
      noiseEM_ = noise;
    } else {
      useEM_ = false;   // epsilon == 0
    }
  }

References dag2BN_, epsilon(), GUM_ERROR, noiseEM_, and useEM_.

Referenced by useEMWithRateCriterion().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ useEMWithDiffCriterion()

INLINE void gum::learning::IBNLearner::useEMWithDiffCriterion	(	const double	epsilon,
		const double	noise = default_EM_noise )

use The EM algorithm to learn parameters with the diff stopping criterion

use The EM algorithm to learn parameters with the diff stoppîng criterion

Parameters

epsilon	epsilon sets the approximation stopping criterion: EM stops whenever the difference between two consecutive log-likelihoods drops below epsilon. Note that, for using EM, epsilon should be strictly positive.
noise	When EM starts, it initializes all the CPTs of the Bayes net. EM adds a noise to these CPTs by mixing their values with some random noise. The formula used is, up to some normalizing constant: new_cpt = (1-noise) * cpt + noise * random_cpt(). Of course, noise must belong to interval [0,1].

Exceptions

OutOfBounds is raised if epsilon is not strictly positive or if noise does not belong to interval [0,1].

Definition at line 418 of file IBNLearner_inl.h.

                                                                                         {
    if (epsilon <= 0.0)
      GUM_ERROR(OutOfBounds, "EM's min log-likelihood differences must be positive");
    if ((noise < 0.0) || (noise > 1.0))
      GUM_ERROR(OutOfBounds, "EM's noise must belong to interval [0,1]");
    useEM_ = true;
    dag2BN_.setEpsilon(epsilon);
    dag2BN_.setNoise(noise);
    noiseEM_ = noise;
  }

References dag2BN_, epsilon(), GUM_ERROR, noiseEM_, and useEM_.

Here is the call graph for this function:

◆ useEMWithRateCriterion()

INLINE void gum::learning::IBNLearner::useEMWithRateCriterion	(	const double	epsilon,
		const double	noise = default_EM_noise )

use The EM algorithm to learn parameters with the rate stopping criterion

Parameters

epsilon	epsilon sets the approximation stopping criterion: EM stops whenever the absolute value of the relative difference between two consecutive log-likelihoods drops below epsilon. Note that, for using EM, epsilon should be strictly positive.
noise	When EM starts, it initializes all the CPTs of the Bayes net. EM adds a noise to these CPTs by mixing their values with some random noise. The formula used is, up to some normalizing constant: new_cpt = (1-noise) * cpt + noise * random_cpt(). Of course, noise must belong to interval [0,1].

Exceptions

OutOfBounds is raised if epsilon is not strictly positive or if noise does not belong to interval [0,1].

Definition at line 411 of file IBNLearner_inl.h.

                                                                                         {
    if (epsilon <= 0.0)
      GUM_ERROR(OutOfBounds, "EM's min log-likelihood evolution rate must be positive");
    useEM(epsilon, noise);
  }

References epsilon(), GUM_ERROR, and useEM().

Here is the call graph for this function:

◆ useExtendedGreedyHillClimbing()

INLINE void gum::learning::IBNLearner::useExtendedGreedyHillClimbing ( )

indicate that we wish to use the extended greedy hill climbing algorithm

The extended greedy hill climbing adds to the classical operations (arc addition, arc reversal, arc deletion) two additional operations: arc triangle deletion1 and arc triangle deletion2. The former modifies a structure X1->X2->X3 + X1->X3 into a v-structure centered on X1, i.e., X2->X1<-X3. Arc triangle deletion2 modifies structure X1->X2->X3 + X1->X3 into a v-structure centered on X2, i.e., X1->X2<-X3.

In addition, the extended greedy hill climbing allows the user to select which operations among arc additions, arc reversals, arc deletions, arc triangle deletions, are allowed.

Definition at line 367 of file IBNLearner_inl.h.

                                                        {
    selectedAlgo_ = AlgoType::EXTENDED_GREEDY_HILL_CLIMBING;
  }

References EXTENDED_GREEDY_HILL_CLIMBING, and selectedAlgo_.

◆ useFCI()

INLINE void gum::learning::IBNLearner::useFCI ( )

indicate that we wish to use FCI (Chi2 test by default)

Definition at line 228 of file IBNLearner_inl.h.

228{ selectedAlgo_ = AlgoType::FCI; }

References FCI, and selectedAlgo_.

◆ useFCIChi2Test()

INLINE void gum::learning::IBNLearner::useFCIChi2Test ( )

indicate that we wish to use Chi2 independence test for FCI

Exceptions

OperationNotAllowed when FCI is not the selected algorithm

Definition at line 231 of file IBNLearner_inl.h.

                                         {
    if (selectedAlgo_ != AlgoType::FCI) {
      GUM_ERROR(OperationNotAllowed, "useFCIChi2Test() is only valid when using the FCI algorithm")
    }
    indepTestTypeFCI_ = IndepTestType::Chi2;
  }

References Chi2, FCI, GUM_ERROR, indepTestTypeFCI_, and selectedAlgo_.

◆ useFCIG2Test()

INLINE void gum::learning::IBNLearner::useFCIG2Test ( )

indicate that we wish to use G2 independence test for FCI

Exceptions

OperationNotAllowed when FCI is not the selected algorithm

Definition at line 239 of file IBNLearner_inl.h.

                                       {
    if (selectedAlgo_ != AlgoType::FCI) {
      GUM_ERROR(OperationNotAllowed, "useFCIG2Test() is only valid when using the FCI algorithm")
    }
    indepTestTypeFCI_ = IndepTestType::G2;
  }

References FCI, G2, GUM_ERROR, indepTestTypeFCI_, and selectedAlgo_.

◆ useG2Test()

INLINE void gum::learning::IBNLearner::useG2Test ( )

indicate that we wish to use G2 independence test for PC

Exceptions

OperationNotAllowed when PC is not the selected algorithm

Definition at line 288 of file IBNLearner_inl.h.

                                    {
    if (selectedAlgo_ != AlgoType::PC) {
      GUM_ERROR(OperationNotAllowed, "useG2Test() is only valid when using the PC algorithm")
    }
    indepTestTypePC_ = IndepTestType::G2;
  }

References G2, GUM_ERROR, indepTestTypePC_, PC, and selectedAlgo_.

◆ useGreedyHillClimbing()

INLINE void gum::learning::IBNLearner::useGreedyHillClimbing ( )

indicate that we wish to use a greedy hill climbing algorithm

Definition at line 362 of file IBNLearner_inl.h.

                                                {
    selectedAlgo_ = AlgoType::GREEDY_HILL_CLIMBING;
  }

References GREEDY_HILL_CLIMBING, and selectedAlgo_.

◆ useGreedyThickThinning()

INLINE void gum::learning::IBNLearner::useGreedyThickThinning ( )

indicate that we wish to use greedy thick-thinning

Definition at line 372 of file IBNLearner_inl.h.

                                                 {
    selectedAlgo_ = AlgoType::GREEDY_THICK_THINNING;
  }

References GREEDY_THICK_THINNING, and selectedAlgo_.

◆ useK2() [1/2]

INLINE void gum::learning::IBNLearner::useK2 ( const Sequence< NodeId > & order )

indicate that we wish to use K2

Definition at line 350 of file IBNLearner_inl.h.

                                                               {
    selectedAlgo_ = AlgoType::K2;
    algoK2_.setOrder(order);
  }

References algoK2_, K2, and selectedAlgo_.

◆ useK2() [2/2]

INLINE void gum::learning::IBNLearner::useK2 ( const std::vector< NodeId > & order )

indicate that we wish to use K2

Definition at line 356 of file IBNLearner_inl.h.

                                                                {
    selectedAlgo_ = AlgoType::K2;
    algoK2_.setOrder(order);
  }

References algoK2_, K2, and selectedAlgo_.

◆ useLocalSearchWithTabuList()

INLINE void gum::learning::IBNLearner::useLocalSearchWithTabuList	(	Size	tabu_size = 100,
		Size	nb_decrease = 2 )

indicate that we wish to use a local search with tabu list

Parameters

tabu_size	indicate the size of the tabu list
nb_decrease	indicate the max number of changes decreasing the score consecutively that we allow to apply

Definition at line 387 of file IBNLearner_inl.h.

                                                                                     {
    selectedAlgo_        = AlgoType::LOCAL_SEARCH_WITH_TABU_LIST;
    nbDecreasingChanges_ = nb_decrease;
    constraintTabuList_.setTabuListSize(tabu_size);
    localSearchWithTabuList_.setMaxNbDecreasingChanges(nb_decrease);
  }

References constraintTabuList_, LOCAL_SEARCH_WITH_TABU_LIST, localSearchWithTabuList_, nbDecreasingChanges_, and selectedAlgo_.

◆ useMDLCorrection()

INLINE void gum::learning::IBNLearner::useMDLCorrection ( )

indicate that we wish to use the MDL correction for MIIC

Exceptions

OperationNotAllowed when MIIC is not the selected algorithm

Definition at line 335 of file IBNLearner_inl.h.

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

References kmodeMiic_, and gum::learning::CorrectedMutualInformation::MDL.

◆ useMIIC()

INLINE void gum::learning::IBNLearner::useMIIC ( )

indicate that we wish to use MIIC

Definition at line 222 of file IBNLearner_inl.h.

222{ selectedAlgo_ = AlgoType::MIIC; }

References MIIC, and selectedAlgo_.

◆ useNMLCorrection()

INLINE void gum::learning::IBNLearner::useNMLCorrection ( )

indicate that we wish to use the NML correction for and MIIC

indicate that we wish to use the NML correction for MIIC

Exceptions

OperationNotAllowed when MIIC is not the selected algorithm

Definition at line 330 of file IBNLearner_inl.h.

                                           {
    kmodeMiic_ = CorrectedMutualInformation::KModeTypes::NML;
  }

References kmodeMiic_, and gum::learning::CorrectedMutualInformation::NML.

◆ useNoCorrection()

INLINE void gum::learning::IBNLearner::useNoCorrection ( )

indicate that we wish to use the NoCorr correction for MIIC

Exceptions

OperationNotAllowed when MIIC is not the selected algorithm

Definition at line 340 of file IBNLearner_inl.h.

                                          {
    kmodeMiic_ = CorrectedMutualInformation::KModeTypes::NoCorr;
  }

References kmodeMiic_, and gum::learning::CorrectedMutualInformation::NoCorr.

◆ useNoPrior()

INLINE void gum::learning::IBNLearner::useNoPrior ( )

use no prior

Definition at line 652 of file IBNLearner_inl.h.

                                     {
    priorType_ = BNLearnerPriorType::NO_prior;
    checkScorePriorCompatibility();
  }

References checkScorePriorCompatibility(), NO_prior, and priorType_.

Here is the call graph for this function:

◆ usePC()

INLINE void gum::learning::IBNLearner::usePC ( )

indicate that we wish to use PC (Chi2 test by default)

Definition at line 225 of file IBNLearner_inl.h.

225{ selectedAlgo_ = AlgoType::PC; }

References PC, and selectedAlgo_.

◆ useScoreAIC()

INLINE void gum::learning::IBNLearner::useScoreAIC ( )

indicate that we wish to use an AIC score

Definition at line 169 of file IBNLearner_inl.h.

                                      {
    scoreType_ = ScoreType::AIC;
    checkScorePriorCompatibility();
  }

References AIC, checkScorePriorCompatibility(), and scoreType_.

Here is the call graph for this function:

◆ useScoreBD()

INLINE void gum::learning::IBNLearner::useScoreBD ( )

indicate that we wish to use a BD score

Definition at line 175 of file IBNLearner_inl.h.

                                     {
    scoreType_ = ScoreType::BD;
    checkScorePriorCompatibility();
  }

References BD, checkScorePriorCompatibility(), and scoreType_.

Here is the call graph for this function:

◆ useScoreBDeu()

INLINE void gum::learning::IBNLearner::useScoreBDeu ( )

indicate that we wish to use a BDeu score

Definition at line 181 of file IBNLearner_inl.h.

                                       {
    scoreType_ = ScoreType::BDeu;
    checkScorePriorCompatibility();
  }

References BDeu, checkScorePriorCompatibility(), and scoreType_.

Here is the call graph for this function:

◆ useScoreBIC()

INLINE void gum::learning::IBNLearner::useScoreBIC ( )

indicate that we wish to use a BIC score

Definition at line 187 of file IBNLearner_inl.h.

                                      {
    scoreType_ = ScoreType::BIC;
    checkScorePriorCompatibility();
  }

References BIC, checkScorePriorCompatibility(), and scoreType_.

Here is the call graph for this function:

◆ useScorefNML()

INLINE void gum::learning::IBNLearner::useScorefNML ( )

indicate that we wish to use a fNML score

Definition at line 193 of file IBNLearner_inl.h.

                                       {
    scoreType_ = ScoreType::fNML;
    checkScorePriorCompatibility();
  }

References checkScorePriorCompatibility(), fNML, and scoreType_.

Here is the call graph for this function:

◆ useScoreK2()

INLINE void gum::learning::IBNLearner::useScoreK2 ( )

indicate that we wish to use a K2 score

Definition at line 199 of file IBNLearner_inl.h.

                                     {
    scoreType_ = ScoreType::K2;
    checkScorePriorCompatibility();
  }

References checkScorePriorCompatibility(), K2, and scoreType_.

Here is the call graph for this function:

◆ useScoreLog2Likelihood()

INLINE void gum::learning::IBNLearner::useScoreLog2Likelihood ( )

indicate that we wish to use a Log2Likelihood score

Definition at line 205 of file IBNLearner_inl.h.

                                                 {
    scoreType_ = ScoreType::LOG2LIKELIHOOD;
    checkScorePriorCompatibility();
  }

References checkScorePriorCompatibility(), LOG2LIKELIHOOD, and scoreType_.

Here is the call graph for this function:

◆ useScoreMDL()

INLINE void gum::learning::IBNLearner::useScoreMDL ( )

indicate that we wish to use a MDL score

Definition at line 211 of file IBNLearner_inl.h.

                                      {
    scoreType_ = ScoreType::MDL;
    checkScorePriorCompatibility();
  }

References checkScorePriorCompatibility(), MDL, and scoreType_.

Here is the call graph for this function:

◆ useSmoothingPrior()

INLINE void gum::learning::IBNLearner::useSmoothingPrior ( double weight = 1 )

use the prior smoothing

Parameters

weight pass in argument a weight if you wish to assign a weight to the smoothing, else the current weight of the IBNLearner will be used.

Definition at line 658 of file IBNLearner_inl.h.

                                                         {
    if (weight < 0) { GUM_ERROR(OutOfBounds, "the weight of the prior must be positive") }
 
    priorType_ = BNLearnerPriorType::SMOOTHING;
    _setPriorWeight_(weight);
 
    checkScorePriorCompatibility();
  }

References _setPriorWeight_(), checkScorePriorCompatibility(), GUM_ERROR, priorType_, and SMOOTHING.

Here is the call graph for this function:

◆ verbosity()

INLINE bool gum::learning::IBNLearner::verbosity ( ) const

overridevirtual

verbosity

Implements gum::IApproximationSchemeConfiguration.

Definition at line 933 of file IBNLearner_inl.h.

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

References currentAlgorithm_, and GUM_ERROR.

Member Data Documentation

◆ _nb_threads_

Size gum::ThreadNumberManager::_nb_threads_ {0}

privateinherited

the max number of threads used by the class

Definition at line 126 of file threadNumberManager.h.

126{0};

◆ algoFCI_

gum::learning::FCI gum::learning::IBNLearner::algoFCI_

protected

the FCI algorithm

Definition at line 1222 of file IBNLearner.h.

Referenced by learnDag_(), learnPAG_(), learnPDAG_(), and prepareFCI_().

◆ algoK2_

K2 gum::learning::IBNLearner::algoK2_

protected

the K2 algorithm

Definition at line 1193 of file IBNLearner.h.

Referenced by IBNLearner(), IBNLearner(), disableEpsilon(), disableMaxIter(), disableMaxTime(), disableMinEpsilonRate(), enableEpsilon(), enableMaxIter(), enableMaxTime(), enableMinEpsilonRate(), learnDag_(), operator=(), operator=(), setEpsilon(), setMaxIter(), setMaxTime(), setMinEpsilonRate(), setPeriodSize(), setVerbosity(), useK2(), and useK2().

◆ algoMiic_

Miic gum::learning::IBNLearner::algoMiic_

protected

the Constraint MIIC algorithm

Definition at line 1199 of file IBNLearner.h.

Referenced by IBNLearner(), IBNLearner(), latentVariables(), learnDag_(), learnPDAG_(), operator=(), operator=(), and prepareMiic_().

◆ algoPC_

gum::learning::PC gum::learning::IBNLearner::algoPC_

protected

the PC algorithm

Definition at line 1206 of file IBNLearner.h.

Referenced by learnDag_(), learnPDAG_(), and preparePC_().

◆ algoSimpleMiic_

SimpleMiic gum::learning::IBNLearner::algoSimpleMiic_

protected

the MIIC algorithm

Definition at line 1196 of file IBNLearner.h.

Referenced by IBNLearner(), IBNLearner(), operator=(), and operator=().

◆ allowArcAdditions_

bool gum::learning::IBNLearner::allowArcAdditions_ {true}

protected

whether we allow or not arc additions during learning

Definition at line 1181 of file IBNLearner.h.

1181{true};

Referenced by allowArcAdditions(), and learnDag_().

◆ allowArcDeletions_

bool gum::learning::IBNLearner::allowArcDeletions_ {true}

protected

whether we allow or not arc deletions during learning

Definition at line 1184 of file IBNLearner.h.

1184{true};

Referenced by allowArcDeletions(), and learnDag_().

◆ allowArcReversals_

bool gum::learning::IBNLearner::allowArcReversals_ {true}

protected

whether we allow or not arc reversals during learning

Definition at line 1187 of file IBNLearner.h.

1187{true};

Referenced by allowArcReversals(), and learnDag_().

◆ allowArcTriangleDeletions_

bool gum::learning::IBNLearner::allowArcTriangleDeletions_ {true}

protected

whether we allow or not arc deletions during learning

Definition at line 1190 of file IBNLearner.h.

1190{true};

Referenced by allowArcTriangleDeletions(), and learnDag_().

◆ alphaFci_

double gum::learning::IBNLearner::alphaFci_ {0.05}

protected

FCI parameters.

Definition at line 1231 of file IBNLearner.h.

1231{0.05};

Referenced by prepareFCI_(), and setFCIAlpha().

◆ alphaPc_

double gum::learning::IBNLearner::alphaPc_ {0.05}

protected

PC parameters.

Definition at line 1216 of file IBNLearner.h.

1216{0.05};

Referenced by preparePC_(), and setPCAlpha().

◆ constraintForbiddenArcs_

StructuralConstraintForbiddenArcs gum::learning::IBNLearner::constraintForbiddenArcs_

protected

the constraint on forbidden arcs

Definition at line 1163 of file IBNLearner.h.

Referenced by IBNLearner(), IBNLearner(), addForbiddenArc(), eraseForbiddenArc(), learnDag_(), operator=(), operator=(), prepareFCI_(), prepareMiic_(), preparePC_(), and setForbiddenArcs().

◆ constraintIndegree_

StructuralConstraintIndegree gum::learning::IBNLearner::constraintIndegree_

protected

the constraint for indegrees

Definition at line 1157 of file IBNLearner.h.

Referenced by IBNLearner(), IBNLearner(), learnDag_(), operator=(), operator=(), prepareFCI_(), prepareMiic_(), preparePC_(), and setMaxIndegree().

◆ constraintMandatoryArcs_

StructuralConstraintMandatoryArcs gum::learning::IBNLearner::constraintMandatoryArcs_

protected

the constraint on mandatory arcs

Definition at line 1169 of file IBNLearner.h.

Referenced by IBNLearner(), IBNLearner(), addMandatoryArc(), eraseMandatoryArc(), learnDag_(), operator=(), operator=(), prepareFCI_(), prepareMiic_(), preparePC_(), and setMandatoryArcs().

◆ constraintNoChildrenNodes_

StructuralConstraintNoChildrenNodes gum::learning::IBNLearner::constraintNoChildrenNodes_

protected

the constraint on no children nodes

Definition at line 1175 of file IBNLearner.h.

Referenced by IBNLearner(), IBNLearner(), addNoChildrenNode(), eraseNoChildrenNode(), learnDag_(), operator=(), operator=(), prepareFCI_(), prepareMiic_(), and preparePC_().

◆ constraintNoParentNodes_

StructuralConstraintNoParentNodes gum::learning::IBNLearner::constraintNoParentNodes_

protected

the constraint on no parent nodes

Definition at line 1172 of file IBNLearner.h.

Referenced by IBNLearner(), IBNLearner(), addNoParentNode(), eraseNoParentNode(), learnDag_(), operator=(), operator=(), prepareFCI_(), prepareMiic_(), and preparePC_().

◆ constraintPossibleEdges_

StructuralConstraintPossibleEdges gum::learning::IBNLearner::constraintPossibleEdges_

protected

the constraint on possible Edges

Definition at line 1166 of file IBNLearner.h.

Referenced by addPossibleEdge(), erasePossibleEdge(), learnDag_(), prepareFCI_(), prepareMiic_(), preparePC_(), and setPossibleEdges().

◆ constraintSliceOrder_

StructuralConstraintSliceOrder gum::learning::IBNLearner::constraintSliceOrder_

protected

the constraint for 2TBNs

Definition at line 1151 of file IBNLearner.h.

Referenced by IBNLearner(), IBNLearner(), learnDag_(), operator=(), operator=(), prepareFCI_(), prepareMiic_(), preparePC_(), and setSliceOrder().

◆ constraintTabuList_

StructuralConstraintTabuList gum::learning::IBNLearner::constraintTabuList_

protected

the constraint for tabu lists

Definition at line 1160 of file IBNLearner.h.

Referenced by IBNLearner(), IBNLearner(), learnDag_(), operator=(), operator=(), and useLocalSearchWithTabuList().

◆ constraintTotalOrder_

StructuralConstraintTotalOrder gum::learning::IBNLearner::constraintTotalOrder_

protected

the total order ing constraint

Definition at line 1154 of file IBNLearner.h.

Referenced by learnDag_(), prepareFCI_(), prepareMiic_(), preparePC_(), and setTotalOrder().

◆ currentAlgorithm_

const ApproximationScheme* gum::learning::IBNLearner::currentAlgorithm_ {nullptr}

protected

Definition at line 1272 of file IBNLearner.h.

1272{nullptr};

Referenced by currentTime(), epsilon(), history(), isEnabledEpsilon(), isEnabledMaxIter(), isEnabledMaxTime(), isEnabledMinEpsilonRate(), maxIter(), maxTime(), minEpsilonRate(), nbrIterations(), operator=(), operator=(), periodSize(), setCurrentApproximationScheme(), stateApproximationScheme(), and verbosity().

◆ dag2BN_

DAG2BNLearner gum::learning::IBNLearner::dag2BN_

protected

the parametric EM

Definition at line 1236 of file IBNLearner.h.

Referenced by IBNLearner(), IBNLearner(), disableEpsilon(), disableMaxIter(), disableMaxTime(), disableMinEpsilonRate(), EM(), EMCurrentTime(), EMdisableEpsilon(), EMdisableMaxIter(), EMdisableMaxTime(), EMdisableMinEpsilonRate(), EMenableEpsilon(), EMenableMaxIter(), EMenableMaxTime(), EMenableMinEpsilonRate(), EMEpsilon(), EMHistory(), EMisEnabledEpsilon(), EMisEnabledMaxIter(), EMisEnabledMaxTime(), EMisEnabledMinEpsilonRate(), EMMaxIter(), EMMaxTime(), EMMinEpsilonRate(), EMnbrIterations(), EMPeriodSize(), EMsetEpsilon(), EMsetMaxIter(), EMsetMaxTime(), EMsetMinEpsilonRate(), EMsetPeriodSize(), EMsetVerbosity(), EMState(), EMStateApproximationScheme(), EMStateMessage(), EMVerbosity(), enableEpsilon(), enableMaxIter(), enableMaxTime(), enableMinEpsilonRate(), operator=(), operator=(), setEpsilon(), setMaxIter(), setMaxTime(), setMinEpsilonRate(), setPeriodSize(), setVerbosity(), useEM(), and useEMWithDiffCriterion().

◆ default_EM_noise

double gum::learning::IBNLearner::default_EM_noise {0.1}

staticconstexpr

the default noise amount added to CPTs during EM's initialization (see method useEM())

Definition at line 135 of file IBNLearner.h.

135{0.1};

Referenced by gum::learning::BNLearner< GUM_SCALAR >::useEM(), gum::learning::BNLearner< GUM_SCALAR >::useEMWithDiffCriterion(), and gum::learning::BNLearner< GUM_SCALAR >::useEMWithRateCriterion().

◆ exhaustiveSepSetFci_

bool gum::learning::IBNLearner::exhaustiveSepSetFci_ {false}

protected

Definition at line 1233 of file IBNLearner.h.

1233{false};

Referenced by fciExhaustiveSepSet(), prepareFCI_(), and setFCIExhaustiveSepSet().

◆ extendedGreedyHillClimbing_

GreedyHillClimbing gum::learning::IBNLearner::extendedGreedyHillClimbing_

protected

the extended greedy hill climbing

Definition at line 1242 of file IBNLearner.h.

Referenced by learnDag_().

◆ filename_

std::string gum::learning::IBNLearner::filename_ {"-"}

protected

the filename database

Definition at line 1266 of file IBNLearner.h.

1266{"-"};

Referenced by IBNLearner(), IBNLearner(), IBNLearner(), IBNLearner(), operator=(), and operator=().

◆ greedyHillClimbing_

GreedyHillClimbing gum::learning::IBNLearner::greedyHillClimbing_

protected

the greedy hill climbing algorithm

Definition at line 1239 of file IBNLearner.h.

Referenced by IBNLearner(), IBNLearner(), disableEpsilon(), disableMaxIter(), disableMaxTime(), disableMinEpsilonRate(), enableEpsilon(), enableMaxIter(), enableMaxTime(), enableMinEpsilonRate(), learnDag_(), operator=(), operator=(), setEpsilon(), setMaxIter(), setMaxTime(), setMinEpsilonRate(), setPeriodSize(), and setVerbosity().

◆ greedyThickThinning_

GreedyThickThinning gum::learning::IBNLearner::greedyThickThinning_

protected

the greedy thick-thinning algorithm

Definition at line 1245 of file IBNLearner.h.

Referenced by greedyThickThinningReversals(), learnDag_(), and setGreedyThickThinningReversals().

◆ indepTestFCI_

IndependenceTest* gum::learning::IBNLearner::indepTestFCI_ {nullptr}

protected

owned independence test object for FCI (rebuilt before each learn call)

Definition at line 1228 of file IBNLearner.h.

1228{nullptr};

Referenced by ~IBNLearner(), and prepareFCI_().

◆ indepTestPC_

IndependenceTest* gum::learning::IBNLearner::indepTestPC_ {nullptr}

protected

owned independence test object for PC (rebuilt before each learn call)

Definition at line 1213 of file IBNLearner.h.

1213{nullptr};

Referenced by ~IBNLearner(), and preparePC_().

◆ indepTestTypeFCI_

IndepTestType gum::learning::IBNLearner::indepTestTypeFCI_ {IndepTestType::Chi2}

protected

independence test type for FCI (reuses IndepTestType defined above)

Definition at line 1225 of file IBNLearner.h.

1225{IndepTestType::Chi2};

Referenced by prepareFCI_(), useFCIChi2Test(), and useFCIG2Test().

◆ indepTestTypePC_

IndepTestType gum::learning::IBNLearner::indepTestTypePC_ {IndepTestType::Chi2}

protected

Definition at line 1210 of file IBNLearner.h.

1210{IndepTestType::Chi2};

Referenced by preparePC_(), useChi2Test(), and useG2Test().

◆ inducedTypes_

bool gum::learning::IBNLearner::inducedTypes_ {false}

protected

the policy for typing variables

Definition at line 1119 of file IBNLearner.h.

1119{false};

Referenced by IBNLearner(), IBNLearner(), IBNLearner(), and IBNLearner().

◆ initialDag_

DAG gum::learning::IBNLearner::initialDag_

protected

an initial DAG given to learners

Definition at line 1263 of file IBNLearner.h.

Referenced by IBNLearner(), IBNLearner(), initialDAG(), learnDag_(), operator=(), operator=(), and setInitialDAG().

◆ kmodeMiic_

CorrectedMutualInformation::KModeTypes gum::learning::IBNLearner::kmodeMiic_

protected

Initial value:

{

CorrectedMutualInformation::KModeTypes::MDL}

the penalty used in MIIC

Definition at line 1202 of file IBNLearner.h.

1202 {

1203 CorrectedMutualInformation::KModeTypes::MDL};

Referenced by IBNLearner(), IBNLearner(), correctedMutualInformation(), createCorrectedMutualInformation_(), operator=(), operator=(), useMDLCorrection(), useNMLCorrection(), and useNoCorrection().

◆ localSearchWithTabuList_

LocalSearchWithTabuList gum::learning::IBNLearner::localSearchWithTabuList_

protected

the local search with tabu list algorithm

Definition at line 1248 of file IBNLearner.h.

Referenced by IBNLearner(), IBNLearner(), disableEpsilon(), disableMaxIter(), disableMaxTime(), disableMinEpsilonRate(), enableEpsilon(), enableMaxIter(), enableMaxTime(), enableMinEpsilonRate(), learnDag_(), operator=(), operator=(), setEpsilon(), setMaxIter(), setMaxTime(), setMinEpsilonRate(), setPeriodSize(), setVerbosity(), and useLocalSearchWithTabuList().

◆ maxCondSetSizePc_

Size gum::learning::IBNLearner::maxCondSetSizePc_ {Size(-1)}

protected

Definition at line 1218 of file IBNLearner.h.

1218{Size(-1)};

Referenced by preparePC_(), and setPCMaxCondSetSize().

◆ maxPathLengthFci_

Size gum::learning::IBNLearner::maxPathLengthFci_ {Size(-1)}

protected

Definition at line 1232 of file IBNLearner.h.

1232{Size(-1)};

Referenced by prepareFCI_(), and setFCIMaxPathLength().

◆ mutualInfo_

CorrectedMutualInformation* gum::learning::IBNLearner::mutualInfo_ {nullptr}

protected

the selected correction for miic

Definition at line 1137 of file IBNLearner.h.

1137{nullptr};

Referenced by ~IBNLearner(), createCorrectedMutualInformation_(), learnDag_(), learnPDAG_(), operator=(), and operator=().

◆ nbDecreasingChanges_

Size gum::learning::IBNLearner::nbDecreasingChanges_ {2}

protected

Definition at line 1269 of file IBNLearner.h.

1269{2};

Referenced by IBNLearner(), IBNLearner(), operator=(), operator=(), and useLocalSearchWithTabuList().

◆ noiseEM_

double gum::learning::IBNLearner::noiseEM_ {0.1}

protected

the noise factor (in (0,1)) used by EM for perturbing the CPT during init

Definition at line 1134 of file IBNLearner.h.

1134{0.1};

Referenced by IBNLearner(), IBNLearner(), operator=(), operator=(), useEM(), and useEMWithDiffCriterion().

◆ noPrior_

NoPrior* gum::learning::IBNLearner::noPrior_ {nullptr}

protected

Definition at line 1145 of file IBNLearner.h.

1145{nullptr};

Referenced by IBNLearner(), IBNLearner(), IBNLearner(), IBNLearner(), IBNLearner(), ~IBNLearner(), createCorrectedMutualInformation_(), createParamEstimator_(), prepareFCI_(), preparePC_(), and useDatabaseRanges().

◆ onProgress

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

inherited

Progression, error and time.

Definition at line 81 of file IApproximationSchemeConfiguration.h.

Referenced by gum::ApproximationScheme::continueApproximationScheme(), 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

Signaler< std::string_view > gum::IApproximationSchemeConfiguration::onStop

inherited

Criteria messageApproximationScheme.

Definition at line 84 of file IApproximationSchemeConfiguration.h.

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

◆ paramEstimatorType_

ParamEstimatorType gum::learning::IBNLearner::paramEstimatorType_ {ParamEstimatorType::ML}

protected

the type of the parameter estimator

Definition at line 1128 of file IBNLearner.h.

1128{ParamEstimatorType::ML};

Referenced by IBNLearner(), IBNLearner(), createParamEstimator_(), operator=(), and operator=().

◆ prior_

Prior* gum::learning::IBNLearner::prior_ {nullptr}

protected

the prior used

Definition at line 1143 of file IBNLearner.h.

1143{nullptr};

Referenced by ~IBNLearner(), chi2(), correctedMutualInformation(), createParamEstimator_(), createScore_(), G2(), logLikelihood(), operator=(), operator=(), and rawPseudoCount().

◆ priorDatabase_

Database* gum::learning::IBNLearner::priorDatabase_ {nullptr}

protected

the database used by the Dirichlet a priori

Definition at line 1257 of file IBNLearner.h.

1257{nullptr};

Referenced by ~IBNLearner(), learnDag_(), operator=(), and operator=().

◆ priorDbname_

std::string gum::learning::IBNLearner::priorDbname_

protected

the filename for the Dirichlet a priori, if any

Definition at line 1260 of file IBNLearner.h.

Referenced by IBNLearner(), IBNLearner(), operator=(), operator=(), and useDirichletPrior().

◆ priorType_

BNLearnerPriorType gum::learning::IBNLearner::priorType_ {BNLearnerPriorType::NO_prior}

protected

the a priorselected for the score and parameters

Definition at line 1140 of file IBNLearner.h.

1140{BNLearnerPriorType::NO_prior};

Referenced by IBNLearner(), IBNLearner(), getPriorType_(), learnDag_(), operator=(), operator=(), useBDeuPrior(), useDirichletPrior(), useNoPrior(), and useSmoothingPrior().

◆ priorWeight_

double gum::learning::IBNLearner::priorWeight_ {1.0f}

protected

the weight of the prior

Definition at line 1148 of file IBNLearner.h.

1148{1.0f};

Referenced by IBNLearner(), IBNLearner(), _setPriorWeight_(), checkScorePriorCompatibility(), operator=(), and operator=().

◆ ranges_

std::vector< std::pair< std::size_t, std::size_t > > gum::learning::IBNLearner::ranges_

protected

the set of rows' ranges within the database in which learning is done

Definition at line 1254 of file IBNLearner.h.

Referenced by IBNLearner(), IBNLearner(), clearDatabaseRanges(), createCorrectedMutualInformation_(), createParamEstimator_(), createScore_(), databaseRanges(), operator=(), operator=(), prepareFCI_(), preparePC_(), useCrossValidationFold(), and useDatabaseRanges().

◆ score_

Score* gum::learning::IBNLearner::score_ {nullptr}

protected

the score used

Definition at line 1125 of file IBNLearner.h.

1125{nullptr};

Referenced by ~IBNLearner(), createParamEstimator_(), createScore_(), learnDag_(), operator=(), operator=(), score(), and setNumberOfThreads().

◆ scoreDatabase_

Database gum::learning::IBNLearner::scoreDatabase_

protected

the database to be used by the scores and parameter estimators

Definition at line 1251 of file IBNLearner.h.

Referenced by IBNLearner(), IBNLearner(), IBNLearner(), IBNLearner(), IBNLearner(), chi2(), correctedMutualInformation(), createCorrectedMutualInformation_(), createParamEstimator_(), createScore_(), database(), databaseWeight(), domainSize(), domainSize(), domainSizes(), G2(), hasMissingValues(), idFromName(), learnDAG(), learnDag_(), learnPAG(), learnPAG_(), learnPDAG(), learnPDAG_(), logLikelihood(), mutualInformation(), nameFromId(), names(), nbCols(), nbRows(), operator=(), operator=(), prepareFCI_(), prepareMiic_(), preparePC_(), rawPseudoCount(), recordWeight(), setDatabaseWeight(), setRecordWeight(), useCrossValidationFold(), and useDatabaseRanges().

◆ scoreType_

ScoreType gum::learning::IBNLearner::scoreType_ {ScoreType::BDeu}

protected

the score selected for learning

Definition at line 1122 of file IBNLearner.h.

1122{ScoreType::BDeu};

Referenced by IBNLearner(), IBNLearner(), checkScorePriorCompatibility(), createScore_(), operator=(), operator=(), useScoreAIC(), useScoreBD(), useScoreBDeu(), useScoreBIC(), useScorefNML(), useScoreK2(), useScoreLog2Likelihood(), and useScoreMDL().

◆ selectedAlgo_

AlgoType gum::learning::IBNLearner::selectedAlgo_ {AlgoType::MIIC}

protected

the selected learning algorithm

Definition at line 1178 of file IBNLearner.h.

1178{AlgoType::MIIC};

Referenced by IBNLearner(), IBNLearner(), fciExhaustiveSepSet(), isConstraintBased(), learnDag_(), learnPAG_(), learnPDAG_(), operator=(), operator=(), setFCIAlpha(), setFCIExhaustiveSepSet(), setFCIMaxPathLength(), setPCAlpha(), setPCMaxCondSetSize(), setPCStable(), setPCUnshieldedColliderSorted(), useChi2Test(), useExtendedGreedyHillClimbing(), useFCI(), useFCIChi2Test(), useFCIG2Test(), useG2Test(), useGreedyHillClimbing(), useGreedyThickThinning(), useK2(), useK2(), useLocalSearchWithTabuList(), useMIIC(), and usePC().

◆ sortedUCPc_

bool gum::learning::IBNLearner::sortedUCPc_ {false}

protected

Definition at line 1219 of file IBNLearner.h.

1219{false};

Referenced by preparePC_(), and setPCUnshieldedColliderSorted().

◆ stablePc_

bool gum::learning::IBNLearner::stablePc_ {true}

protected

Definition at line 1217 of file IBNLearner.h.

1217{true};

Referenced by preparePC_(), and setPCStable().

◆ useEM_

bool gum::learning::IBNLearner::useEM_ {false}

protected

a Boolean indicating whether we should use EM for parameter learning or not

Definition at line 1131 of file IBNLearner.h.

1131{false};

Referenced by IBNLearner(), IBNLearner(), EM(), EMState(), EMStateMessage(), forbidEM(), isUsingEM(), operator=(), operator=(), useEM(), and useEMWithDiffCriterion().

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

agrum/BN/learning/BNLearnUtils/IBNLearner.h
agrum/BN/learning/BNLearnUtils/IBNLearner.cpp
agrum/BN/learning/BNLearnUtils/IBNLearner_inl.h
agrum/BN/learning/BNLearnUtils/IBNLearner_tpl.h

Classes

Public Types

Public Member Functions

Public Attributes

Static Public Attributes

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ AlgoType

◆ ApproximationSchemeSTATE

◆ BNLearnerPriorType

◆ IndepTestType

◆ ParamEstimatorType

◆ ScoreType

Constructor & Destructor Documentation

◆ IBNLearner() [1/5]

◆ IBNLearner() [2/5]

◆ IBNLearner() [3/5]

◆ IBNLearner() [4/5]

◆ IBNLearner() [5/5]

◆ ~IBNLearner()

Member Function Documentation

◆ _setPriorWeight_()

◆ addForbiddenArc() [1/3]

◆ addForbiddenArc() [2/3]

◆ addForbiddenArc() [3/3]

◆ addMandatoryArc() [1/3]

◆ addMandatoryArc() [2/3]

◆ addMandatoryArc() [3/3]

◆ addNoChildrenNode() [1/2]

◆ addNoChildrenNode() [2/2]

◆ addNoParentNode() [1/2]

◆ addNoParentNode() [2/2]

◆ addPossibleEdge() [1/3]

◆ addPossibleEdge() [2/3]

◆ addPossibleEdge() [3/3]

◆ allowArcAdditions()

◆ allowArcDeletions()

◆ allowArcReversals()

◆ allowArcTriangleDeletions()

◆ checkScorePriorCompatibility()

◆ chi2() [1/2]

◆ chi2() [2/2]

◆ clearDatabaseRanges()

◆ correctedMutualInformation() [1/2]

◆ correctedMutualInformation() [2/2]

◆ createCorrectedMutualInformation_()

◆ createParamEstimator_()

◆ createPrior_()

◆ createScore_()

◆ currentTime()

◆ database()

◆ databaseRanges()

◆ databaseWeight()

◆ disableEpsilon()

◆ disableMaxIter()

◆ disableMaxTime()

◆ disableMinEpsilonRate()

◆ distributeProgress()

◆ distributeStop()

◆ domainSize() [1/2]

◆ domainSize() [2/2]

◆ domainSizes()

◆ EM()

◆ EMCurrentTime()

◆ EMdisableEpsilon()

◆ EMdisableMaxIter()

◆ EMdisableMaxTime()

◆ EMdisableMinEpsilonRate()

◆ EMenableEpsilon()

◆ EMenableMaxIter()

◆ EMenableMaxTime()

◆ EMenableMinEpsilonRate()

◆ EMEpsilon()

◆ EMHistory()

◆ EMisEnabledEpsilon()