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

#include <genericBNLearner.h>

Inheritance diagram for gum::learning::genericBNLearner:

Collaboration diagram for gum::learning::genericBNLearner:

Public Attributes
Signaler3< Size, double, double >	onProgress
	Progression, error and time. More...

Signaler1< std::string >	onStop
	Criteria messageApproximationScheme. More...

Public Member Functions
void	__setAprioriWeight (double weight)
	sets the apriori weight More...

void	setMandatoryArcs (const ArcSet &set)
	assign a set of forbidden arcs More...

Constructors / Destructors
	genericBNLearner (const std::string &filename, const std::vector< std::string > &missing_symbols)
	default constructor More...

	genericBNLearner (const DatabaseTable<> &db)
	default constructor More...

template<typename GUM_SCALAR >
	genericBNLearner (const std::string &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 More...

	genericBNLearner (const genericBNLearner &)
	copy constructor More...

	genericBNLearner (genericBNLearner &&)
	move constructor More...

virtual	~genericBNLearner ()
	destructor More...

Operators
genericBNLearner &	operator= (const genericBNLearner &)
	copy operator More...

genericBNLearner &	operator= (genericBNLearner &&)
	move operator More...

Accessors / Modifiers
DAG	learnDAG ()
	learn a structure from a file (must have read the db before) More...

MixedGraph	learnMixedStructure ()
	learn a partial structure from a file (must have read the db before and must have selected miic or 3off2) More...

void	setInitialDAG (const DAG &)
	sets an initial DAG structure More...

const std::vector< std::string > &	names () const
	returns the names of the variables in the database More...

const std::vector< std::size_t > &	domainSizes () const
	returns the domain sizes of the variables in the database More...

NodeId	idFromName (const std::string &var_name) const
	returns the node id corresponding to a variable name More...

const DatabaseTable &	database () const
	returns the database used by the BNLearner More...

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 More...

void	setRecordWeight (const std::size_t i, const double weight)
	sets the weight of the ith record of the database More...

double	recordWeight (const std::size_t i) const
	returns the weight of the ith record More...

double	databaseWeight () const
	returns the weight of the whole database More...

const std::string &	nameFromId (NodeId id) const
	returns the variable name corresponding to a given node id More...

template<template< typename > class XALLOC>
void	useDatabaseRanges (const std::vector< std::pair< std::size_t, std::size_t >, XALLOC< std::pair< std::size_t, std::size_t > > > &new_ranges)
	use a new set of database rows' ranges to perform learning More...

void	clearDatabaseRanges ()
	reset the ranges to the one range corresponding to the whole database More...

const std::vector< std::pair< std::size_t, std::size_t > > &	databaseRanges () const
	returns the current database rows' ranges used for learning More...

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 More...

std::pair< double, double >	chi2 (const NodeId id1, const NodeId id2, const std::vector< NodeId > &knowing={})
	Return the <statistic,pvalue> pair for chi2 test in the database. More...

std::pair< double, double >	chi2 (const std::string &name1, const std::string &name2, const std::vector< std::string > &knowing={})
	Return the <statistic,pvalue> pair for the BNLearner. More...

std::pair< double, double >	G2 (const NodeId id1, const NodeId id2, const std::vector< NodeId > &knowing={})
	Return the <statistic,pvalue> pair for for G2 test in the database. More...

std::pair< double, double >	G2 (const std::string &name1, const std::string &name2, const std::vector< std::string > &knowing={})
	Return the <statistic,pvalue> pair for for G2 test in the database. More...

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. More...

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. More...

Size	nbCols () const

Size	nbRows () const

void	useEM (const double epsilon)
	use The EM algorithm to learn paramters More...

bool	hasMissingValues () const
	returns true if the learner's database has missing values More...

Score selection
void	useScoreAIC ()
	indicate that we wish to use an AIC score More...

void	useScoreBD ()
	indicate that we wish to use a BD score More...

void	useScoreBDeu ()
	indicate that we wish to use a BDeu score More...

void	useScoreBIC ()
	indicate that we wish to use a BIC score More...

void	useScoreK2 ()
	indicate that we wish to use a K2 score More...

void	useScoreLog2Likelihood ()
	indicate that we wish to use a Log2Likelihood score More...

A priori selection / parameterization
void	useNoApriori ()
	use no apriori More...

void	useAprioriBDeu (double weight=1)
	use the BDeu apriori More...

void	useAprioriSmoothing (double weight=1)
	use the apriori smoothing More...

void	useAprioriDirichlet (const std::string &filename, double weight=1)
	use the Dirichlet apriori More...

std::string	checkScoreAprioriCompatibility ()
	checks whether the current score and apriori are compatible More...

Learning algorithm selection
void	useGreedyHillClimbing ()
	indicate that we wish to use a greedy hill climbing algorithm More...

void	useLocalSearchWithTabuList (Size tabu_size=100, Size nb_decrease=2)
	indicate that we wish to use a local search with tabu list More...

void	useK2 (const Sequence< NodeId > &order)
	indicate that we wish to use K2 More...

void	useK2 (const std::vector< NodeId > &order)
	indicate that we wish to use K2 More...

void	use3off2 ()
	indicate that we wish to use 3off2 More...

void	useMIIC ()
	indicate that we wish to use MIIC More...

3off2/MIIC parameterization and specific results
void	useNML ()
	indicate that we wish to use the NML correction for 3off2 More...

void	useMDL ()
	indicate that we wish to use the MDL correction for 3off2 More...

void	useNoCorr ()
	indicate that we wish to use the NoCorr correction for 3off2 More...

const std::vector< Arc >	latentVariables () const
	get the list of arcs hiding latent variables More...

Accessors / Modifiers for adding constraints on learning
void	setMaxIndegree (Size max_indegree)
	sets the max indegree More...

void	setSliceOrder (const NodeProperty< NodeId > &slice_order)
	sets a partial order on the nodes More...

void	setSliceOrder (const std::vector< std::vector< std::string > > &slices)
	sets a partial order on the nodes More...

void	setForbiddenArcs (const ArcSet &set)
	assign a set of forbidden arcs More...

assign a new forbidden arc
void	addForbiddenArc (const Arc &arc)

void	addForbiddenArc (const NodeId tail, const NodeId head)

void	addForbiddenArc (const std::string &tail, const std::string &head)

void	addMandatoryArc (const Arc &arc)

void	addMandatoryArc (const NodeId tail, const NodeId head)

void	addMandatoryArc (const std::string &tail, const std::string &head)

remove a forbidden arc
void	eraseForbiddenArc (const Arc &arc)

void	eraseForbiddenArc (const NodeId tail, const NodeId head)

void	eraseForbiddenArc (const std::string &tail, const std::string &head)

void	eraseMandatoryArc (const Arc &arc)

void	eraseMandatoryArc (const NodeId tail, const NodeId head)

void	eraseMandatoryArc (const std::string &tail, const std::string &head)


void	setPossibleEdges (const EdgeSet &set)
	assign a set of forbidden edges More...

void	setPossibleSkeleton (const UndiGraph &skeleton)
	assign a set of forbidden edges More...

assign a new possible edge
Warning Once at least one possible edge is defined, all other edges are not possible anymore
void	addPossibleEdge (const Edge &edge)

void	addPossibleEdge (const NodeId tail, const NodeId head)

void	addPossibleEdge (const std::string &tail, const std::string &head)

remove a possible edge
void	erasePossibleEdge (const Edge &edge)

void	erasePossibleEdge (const NodeId tail, const NodeId head)

void	erasePossibleEdge (const std::string &tail, const std::string &head)

redistribute signals AND implemenation of interface
IApproximationSchemeConfiguration
INLINE void	setCurrentApproximationScheme (const ApproximationScheme *approximationScheme)
	{@ /// distribute signals More...

INLINE void	distributeProgress (const ApproximationScheme *approximationScheme, Size pourcent, double error, double time)
	{@ /// distribute signals More...

INLINE void	distributeStop (const ApproximationScheme *approximationScheme, std::string message)
	distribute signals More...


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

double	epsilon () const
	Get the value of epsilon. More...

void	disableEpsilon ()
	Disable stopping criterion on epsilon. More...

void	enableEpsilon ()
	Enable stopping criterion on epsilon. More...

bool	isEnabledEpsilon () const


void	setMinEpsilonRate (double rate)
	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. More...

double	minEpsilonRate () const
	Get the value of the minimal epsilon rate. More...

void	disableMinEpsilonRate ()
	Disable stopping criterion on epsilon rate. More...

void	enableMinEpsilonRate ()
	Enable stopping criterion on epsilon rate. More...

bool	isEnabledMinEpsilonRate () const


void	setMaxIter (Size max)
	stopping criterion on number of iterationsIf the criterion was disabled it will be enabled More...

Size	maxIter () const

void	disableMaxIter ()
	Disable stopping criterion on max iterations. More...

void	enableMaxIter ()
	Enable stopping criterion on max iterations. More...

bool	isEnabledMaxIter () const


void	setMaxTime (double timeout)
	stopping criterion on timeout If the criterion was disabled it will be enabled More...

double	maxTime () const
	returns the timeout (in seconds) More...

double	currentTime () const
	get the current running time in second (double) More...

void	disableMaxTime ()
	Disable stopping criterion on timeout. More...

void	enableMaxTime ()
	stopping criterion on timeout If the criterion was disabled it will be enabled More...

bool	isEnabledMaxTime () const


void	setPeriodSize (Size p)
	how many samples between 2 stopping isEnableds More...

Size	periodSize () const
	how many samples between 2 stopping isEnableds More...


void	setVerbosity (bool v)
	verbosity More...

bool	verbosity () const
	verbosity More...


ApproximationSchemeSTATE	stateApproximationScheme () const
	history More...

Size	nbrIterations () const

const std::vector< double > &	history () const

Getters and setters
std::string	messageApproximationScheme () const
	Returns the approximation scheme message. More...

Public Types
enum	ScoreType { ScoreType::AIC, ScoreType::BD, ScoreType::BDeu, ScoreType::BIC, ScoreType::K2, ScoreType::LOG2LIKELIHOOD }
	an enumeration enabling to select easily the score we wish to use More...

enum	ParamEstimatorType { ParamEstimatorType::ML }
	an enumeration to select the type of parameter estimation we shall apply More...

enum	AprioriType { AprioriType::NO_APRIORI, AprioriType::SMOOTHING, AprioriType::DIRICHLET_FROM_DATABASE, AprioriType::BDEU }
	an enumeration to select the apriori More...

enum	AlgoType { AlgoType::K2, AlgoType::GREEDY_HILL_CLIMBING, AlgoType::LOCAL_SEARCH_WITH_TABU_LIST, AlgoType::MIIC_THREE_OFF_TWO }
	an enumeration to select easily the learning algorithm to use More...

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

Protected Attributes
ScoreType	__score_type {ScoreType::BDeu}
	the score selected for learning More...

Score *	__score {nullptr}
	the score used More...

ParamEstimatorType	__param_estimator_type {ParamEstimatorType::ML}
	the type of the parameter estimator More...

double	__EMepsilon {0.0}
	epsilon for EM. if espilon=0.0 : no EM More...

CorrectedMutualInformation *	__mutual_info {nullptr}
	the selected correction for 3off2 and miic More...

AprioriType	__apriori_type {AprioriType::NO_APRIORI}
	the a priori selected for the score and parameters More...

Apriori *	__apriori {nullptr}
	the apriori used More...

AprioriNoApriori *	__no_apriori {nullptr}

double	__apriori_weight {1.0f}
	the weight of the apriori More...

StructuralConstraintSliceOrder	__constraint_SliceOrder
	the constraint for 2TBNs More...

StructuralConstraintIndegree	__constraint_Indegree
	the constraint for indegrees More...

StructuralConstraintTabuList	__constraint_TabuList
	the constraint for tabu lists More...

StructuralConstraintForbiddenArcs	__constraint_ForbiddenArcs
	the constraint on forbidden arcs More...

StructuralConstraintPossibleEdges	__constraint_PossibleEdges
	the constraint on possible Edges More...

StructuralConstraintMandatoryArcs	__constraint_MandatoryArcs
	the constraint on forbidden arcs More...

AlgoType	__selected_algo {AlgoType::GREEDY_HILL_CLIMBING}
	the selected learning algorithm More...

K2	__K2
	the K2 algorithm More...

Miic	__miic_3off2
	the 3off2 algorithm More...

CorrectedMutualInformation ::KModeTypes	__3off2_kmode
	the penalty used in 3off2 More...

DAG2BNLearner	__Dag2BN
	the parametric EM More...

GreedyHillClimbing	__greedy_hill_climbing
	the greedy hill climbing algorithm More...

LocalSearchWithTabuList	__local_search_with_tabu_list
	the local search with tabu list algorithm More...

Database	__score_database
	the database to be used by the scores and parameter estimators More...

std::vector< std::pair< std::size_t, std::size_t > >	__ranges
	the set of rows' ranges within the database in which learning is done More...

Database *	__apriori_database {nullptr}
	the database used by the Dirichlet a priori More...

std::string	__apriori_dbname
	the filename for the Dirichlet a priori, if any More...

DAG	__initial_dag
	an initial DAG given to learners More...

const ApproximationScheme *	__current_algorithm {nullptr}

Protected Member Functions
void	__createApriori ()
	create the apriori used for learning More...

void	__createScore ()
	create the score used for learning More...

ParamEstimator *	__createParamEstimator (DBRowGeneratorParser<> &parser, bool take_into_account_score=true)
	create the parameter estimator used for learning More...

DAG	__learnDAG ()
	returns the DAG learnt More...

MixedGraph	__prepare_miic_3off2 ()
	prepares the initial graph for 3off2 or miic More...

const std::string &	__getAprioriType () const
	returns the type (as a string) of a given apriori More...

void	__createCorrectedMutualInformation ()
	create the Corrected Mutual Information instance for Miic/3off2 More...

Static Protected Member Functions
static DatabaseTable	__readFile (const std::string &filename, const std::vector< std::string > &missing_symbols)
	reads a file and returns a databaseVectInRam More...

static void	__checkFileName (const std::string &filename)
	checks whether the extension of a CSV filename is correct More...

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

Detailed Description

A pack of learning algorithms that can easily be used.

The pack currently contains K2, GreedyHillClimbing and LocalSearchWithTabuList also 3off2/miic

Definition at line 107 of file genericBNLearner.h.

Member Enumeration Documentation

◆ AlgoType

enum gum::learning::genericBNLearner::AlgoType

strong

an enumeration to select easily the learning algorithm to use

Enumerator
K2
GREEDY_HILL_CLIMBING
LOCAL_SEARCH_WITH_TABU_LIST
MIIC_THREE_OFF_TWO

Definition at line 126 of file genericBNLearner.h.

                           {
         K2,
         GREEDY_HILL_CLIMBING,
         LOCAL_SEARCH_WITH_TABU_LIST,
         MIIC_THREE_OFF_TWO
       };

◆ ApproximationSchemeSTATE

enum gum::IApproximationSchemeConfiguration::ApproximationSchemeSTATE : char

stronginherited

The different state of an approximation scheme.

Enumerator
Undefined
Continue
Epsilon
Rate
Limit
TimeLimit
Stopped

Definition at line 65 of file IApproximationSchemeConfiguration.h.

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

◆ AprioriType

enum gum::learning::genericBNLearner::AprioriType

strong

an enumeration to select the apriori

Enumerator
NO_APRIORI
SMOOTHING
DIRICHLET_FROM_DATABASE
BDEU

Definition at line 118 of file genericBNLearner.h.

                              {
         NO_APRIORI,
         SMOOTHING,
         DIRICHLET_FROM_DATABASE,
         BDEU
       };

◆ ParamEstimatorType

enum gum::learning::genericBNLearner::ParamEstimatorType

strong

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

Enumerator
ML

Definition at line 115 of file genericBNLearner.h.

115 { ML };

◆ ScoreType

enum gum::learning::genericBNLearner::ScoreType

strong

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

Enumerator
AIC
BD
BDeu
BIC
K2
LOG2LIKELIHOOD

Definition at line 111 of file genericBNLearner.h.

111 { AIC, BD, BDeu, BIC, K2, LOG2LIKELIHOOD };

Constructor & Destructor Documentation

◆ genericBNLearner() [1/5]

gum::learning::genericBNLearner::genericBNLearner	(	const std::string &	filename,
		const std::vector< std::string > &	missing_symbols
	)

default constructor

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

Definition at line 191 of file genericBNLearner.cpp.

References __no_apriori, __score_database, and gum::learning::genericBNLearner::Database::databaseTable().

                                                       :
         __score_database(filename, missing_symbols) {
       __no_apriori = new AprioriNoApriori<>(__score_database.databaseTable());
 
       // for debugging purposes
       GUM_CONSTRUCTOR(genericBNLearner);
     }

Here is the call graph for this function:

◆ genericBNLearner() [2/5]

gum::learning::genericBNLearner::genericBNLearner ( const DatabaseTable<> & db )

default constructor

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

Definition at line 202 of file genericBNLearner.cpp.

References __no_apriori, __score_database, and gum::learning::genericBNLearner::Database::databaseTable().

                                                                 :
         __score_database(db) {
       __no_apriori = new AprioriNoApriori<>(__score_database.databaseTable());
 
       // for debugging purposes
       GUM_CONSTRUCTOR(genericBNLearner);
     }

Here is the call graph for this function:

◆ genericBNLearner() [3/5]

template<typename GUM_SCALAR >

gum::learning::genericBNLearner::genericBNLearner	(	const std::string &	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.
modalities	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.
parse_database	if true, the modalities specified by the user will be considered as a superset of the modalities of the variables. A parsing of the database will allow to determine which ones are really necessary and will keep them in the order specified by the user (NodeProperty modalities). If parse_database is set to false (the default), then 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).

Definition at line 89 of file genericBNLearner_tpl.h.

References __no_apriori, __score_database, and gum::learning::genericBNLearner::Database::databaseTable().

                                                        :
         __score_database(filename, bn, missing_symbols) {
       __no_apriori = new AprioriNoApriori<>(__score_database.databaseTable());
       GUM_CONSTRUCTOR(genericBNLearner);
     }

Here is the call graph for this function:

◆ genericBNLearner() [4/5]

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

copy constructor

Definition at line 211 of file genericBNLearner.cpp.

References __no_apriori, __score_database, and gum::learning::genericBNLearner::Database::databaseTable().

                                                                    :
         __score_type(from.__score_type),
         __param_estimator_type(from.__param_estimator_type),
         __EMepsilon(from.__EMepsilon), __apriori_type(from.__apriori_type),
         __apriori_weight(from.__apriori_weight),
         __constraint_SliceOrder(from.__constraint_SliceOrder),
         __constraint_Indegree(from.__constraint_Indegree),
         __constraint_TabuList(from.__constraint_TabuList),
         __constraint_ForbiddenArcs(from.__constraint_ForbiddenArcs),
         __constraint_MandatoryArcs(from.__constraint_MandatoryArcs),
         __selected_algo(from.__selected_algo), __K2(from.__K2),
         __miic_3off2(from.__miic_3off2), __3off2_kmode(from.__3off2_kmode),
         __greedy_hill_climbing(from.__greedy_hill_climbing),
         __local_search_with_tabu_list(from.__local_search_with_tabu_list),
         __score_database(from.__score_database), __ranges(from.__ranges),
         __apriori_dbname(from.__apriori_dbname),
         __initial_dag(from.__initial_dag) {
       __no_apriori = new AprioriNoApriori<>(__score_database.databaseTable());
 
       // for debugging purposes
       GUM_CONS_CPY(genericBNLearner);
     }

Here is the call graph for this function:

◆ genericBNLearner() [5/5]

gum::learning::genericBNLearner::genericBNLearner ( genericBNLearner && from )

move constructor

Definition at line 234 of file genericBNLearner.cpp.

References __no_apriori, __score_database, and gum::learning::genericBNLearner::Database::databaseTable().

                                                               :
         __score_type(from.__score_type),
         __param_estimator_type(from.__param_estimator_type),
         __EMepsilon(from.__EMepsilon), __apriori_type(from.__apriori_type),
         __apriori_weight(from.__apriori_weight),
         __constraint_SliceOrder(std::move(from.__constraint_SliceOrder)),
         __constraint_Indegree(std::move(from.__constraint_Indegree)),
         __constraint_TabuList(std::move(from.__constraint_TabuList)),
         __constraint_ForbiddenArcs(std::move(from.__constraint_ForbiddenArcs)),
         __constraint_MandatoryArcs(std::move(from.__constraint_MandatoryArcs)),
         __selected_algo(from.__selected_algo), __K2(std::move(from.__K2)),
         __miic_3off2(std::move(from.__miic_3off2)),
         __3off2_kmode(from.__3off2_kmode),
         __greedy_hill_climbing(std::move(from.__greedy_hill_climbing)),
         __local_search_with_tabu_list(
            std::move(from.__local_search_with_tabu_list)),
         __score_database(std::move(from.__score_database)),
         __ranges(std::move(from.__ranges)),
         __apriori_dbname(std::move(from.__apriori_dbname)),
         __initial_dag(std::move(from.__initial_dag)) {
       __no_apriori = new AprioriNoApriori<>(__score_database.databaseTable());
 
       // for debugging purposes
       GUM_CONS_MOV(genericBNLearner);
     }

Here is the call graph for this function:

◆ ~genericBNLearner()

gum::learning::genericBNLearner::~genericBNLearner ( )

virtual

destructor

Definition at line 260 of file genericBNLearner.cpp.

References __apriori, __apriori_database, __mutual_info, __no_apriori, and __score.

                                         {
       if (__score) delete __score;
 
       if (__apriori) delete __apriori;
 
       if (__no_apriori) delete __no_apriori;
 
       if (__apriori_database) delete __apriori_database;
 
       if (__mutual_info) delete __mutual_info;
 
       GUM_DESTRUCTOR(genericBNLearner);
     }

Member Function Documentation

◆ __checkFileName()

void gum::learning::genericBNLearner::__checkFileName ( const std::string & filename )

staticprotected

checks whether the extension of a CSV filename is correct

Definition at line 411 of file genericBNLearner.cpp.

References GUM_ERROR.

Referenced by __readFile(), and gum::learning::genericBNLearner::Database::Database().

                                                                     {
       // get the extension of the file
       Size filename_size = Size(filename.size());
 
       if (filename_size < 4) {
         GUM_ERROR(FormatNotFound,
                   "genericBNLearner 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,
            "genericBNLearner does not support yet this type of database file");
       }
     }

Here is the caller graph for this function:

◆ __createApriori()

void gum::learning::genericBNLearner::__createApriori ( )

protected

create the apriori used for learning

Definition at line 460 of file genericBNLearner.cpp.

References __apriori, __apriori_database, __apriori_dbname, __apriori_type, __apriori_weight, __score_database, BDEU, gum::learning::genericBNLearner::Database::databaseTable(), DIRICHLET_FROM_DATABASE, GUM_ERROR, gum::learning::genericBNLearner::Database::missingSymbols(), NO_APRIORI, gum::learning::genericBNLearner::Database::nodeId2Columns(), gum::learning::genericBNLearner::Database::parser(), gum::learning::Apriori< ALLOC >::setWeight(), and SMOOTHING.

Referenced by chi2(), G2(), learnDAG(), and logLikelihood().

                                            {
       // first, save the old apriori, to be delete if everything is ok
       Apriori<>* old_apriori = __apriori;
 
       // create the new apriori
       switch (__apriori_type) {
         case AprioriType::NO_APRIORI:
           __apriori = new AprioriNoApriori<>(__score_database.databaseTable(),
                                              __score_database.nodeId2Columns());
           break;
 
         case AprioriType::SMOOTHING:
           __apriori = new AprioriSmoothing<>(__score_database.databaseTable(),
                                              __score_database.nodeId2Columns());
           break;
 
         case AprioriType::DIRICHLET_FROM_DATABASE:
           if (__apriori_database != nullptr) {
             delete __apriori_database;
             __apriori_database = nullptr;
           }
 
           __apriori_database = new Database(__apriori_dbname,
                                             __score_database,
                                             __score_database.missingSymbols());
 
           __apriori = new AprioriDirichletFromDatabase<>(
              __score_database.databaseTable(),
              __apriori_database->parser(),
              __apriori_database->nodeId2Columns());
           break;
 
         case AprioriType::BDEU:
           __apriori = new AprioriBDeu<>(__score_database.databaseTable(),
                                         __score_database.nodeId2Columns());
           break;
 
         default:
           GUM_ERROR(OperationNotAllowed,
                     "The BNLearner does not support yet this apriori");
       }
 
       // do not forget to assign a weight to the apriori
       __apriori->setWeight(__apriori_weight);
 
       // remove the old apriori, if any
       if (old_apriori != nullptr) delete old_apriori;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ __createCorrectedMutualInformation()

void gum::learning::genericBNLearner::__createCorrectedMutualInformation ( )

protected

create the Corrected Mutual Information instance for Miic/3off2

Definition at line 661 of file genericBNLearner.cpp.

References __3off2_kmode, __mutual_info, __no_apriori, __ranges, __score_database, GUM_ERROR, gum::learning::genericBNLearner::Database::nodeId2Columns(), gum::learning::genericBNLearner::Database::parser(), gum::learning::CorrectedMutualInformation< ALLOC >::useMDL(), gum::learning::CorrectedMutualInformation< ALLOC >::useNML(), and gum::learning::CorrectedMutualInformation< ALLOC >::useNoCorr().

Referenced by __prepare_miic_3off2().

                                                               {
       if (__mutual_info != nullptr) delete __mutual_info;
 
       __mutual_info =
          new CorrectedMutualInformation<>(__score_database.parser(),
                                           *__no_apriori,
                                           __ranges,
                                           __score_database.nodeId2Columns());
       switch (__3off2_kmode) {
         case CorrectedMutualInformation<>::KModeTypes::MDL:
           __mutual_info->useMDL();
           break;
 
         case CorrectedMutualInformation<>::KModeTypes::NML:
           __mutual_info->useNML();
           break;
 
         case CorrectedMutualInformation<>::KModeTypes::NoCorr:
           __mutual_info->useNoCorr();
           break;
 
         default:
           GUM_ERROR(NotImplementedYet,
                     "The BNLearner's corrected mutual information class does "
                        << "not support yet penalty mode " << int(__3off2_kmode));
       }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ __createParamEstimator()

ParamEstimator * gum::learning::genericBNLearner::__createParamEstimator	(	DBRowGeneratorParser<> &	parser,
		bool	take_into_account_score = `true`
	)

protected

create the parameter estimator used for learning

Definition at line 567 of file genericBNLearner.cpp.

References __apriori, __no_apriori, __param_estimator_type, __ranges, __score, __score_database, GUM_ERROR, gum::learning::Score< ALLOC >::internalApriori(), ML, gum::learning::genericBNLearner::Database::nodeId2Columns(), and gum::learning::ParamEstimator< ALLOC >::setRanges().

                                                                               {
       ParamEstimator<>* param_estimator = nullptr;
 
       // create the new estimator
       switch (__param_estimator_type) {
         case ParamEstimatorType::ML:
           if (take_into_account_score && (__score != nullptr)) {
             param_estimator =
                new ParamEstimatorML<>(parser,
                                       *__apriori,
                                       __score->internalApriori(),
                                       __ranges,
                                       __score_database.nodeId2Columns());
           } else {
             param_estimator =
                new ParamEstimatorML<>(parser,
                                       *__apriori,
                                       *__no_apriori,
                                       __ranges,
                                       __score_database.nodeId2Columns());
           }
 
           break;
 
         default:
           GUM_ERROR(OperationNotAllowed,
                     "genericBNLearner does not support "
                        << "yet this parameter estimator");
       }
 
       // assign the set of ranges
       param_estimator->setRanges(__ranges);
 
       return param_estimator;
     }

Here is the call graph for this function:

◆ __createScore()

void gum::learning::genericBNLearner::__createScore ( )

protected

create the score used for learning

Definition at line 509 of file genericBNLearner.cpp.

References __apriori, __ranges, __score, __score_database, __score_type, AIC, BD, BDeu, BIC, GUM_ERROR, K2, LOG2LIKELIHOOD, gum::learning::genericBNLearner::Database::nodeId2Columns(), and gum::learning::genericBNLearner::Database::parser().

Referenced by learnDAG().

                                          {
       // first, save the old score, to be delete if everything is ok
       Score<>* old_score = __score;
 
       // create the new scoring function
       switch (__score_type) {
         case ScoreType::AIC:
           __score = new ScoreAIC<>(__score_database.parser(),
                                    *__apriori,
                                    __ranges,
                                    __score_database.nodeId2Columns());
           break;
 
         case ScoreType::BD:
           __score = new ScoreBD<>(__score_database.parser(),
                                   *__apriori,
                                   __ranges,
                                   __score_database.nodeId2Columns());
           break;
 
         case ScoreType::BDeu:
           __score = new ScoreBDeu<>(__score_database.parser(),
                                     *__apriori,
                                     __ranges,
                                     __score_database.nodeId2Columns());
           break;
 
         case ScoreType::BIC:
           __score = new ScoreBIC<>(__score_database.parser(),
                                    *__apriori,
                                    __ranges,
                                    __score_database.nodeId2Columns());
           break;
 
         case ScoreType::K2:
           __score = new ScoreK2<>(__score_database.parser(),
                                   *__apriori,
                                   __ranges,
                                   __score_database.nodeId2Columns());
           break;
 
         case ScoreType::LOG2LIKELIHOOD:
           __score = new ScoreLog2Likelihood<>(__score_database.parser(),
                                               *__apriori,
                                               __ranges,
                                               __score_database.nodeId2Columns());
           break;
 
         default:
           GUM_ERROR(OperationNotAllowed,
                     "genericBNLearner does not support yet this score");
       }
 
       // remove the old score, if any
       if (old_score != nullptr) delete old_score;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ __getAprioriType()

INLINE const std::string & gum::learning::genericBNLearner::__getAprioriType ( ) const

protected

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

Definition at line 507 of file genericBNLearner_inl.h.

References __apriori_type, BDEU, DIRICHLET_FROM_DATABASE, GUM_ERROR, NO_APRIORI, and SMOOTHING.

Referenced by checkScoreAprioriCompatibility().

                                                                      {
       switch (__apriori_type) {
         case AprioriType::NO_APRIORI: return AprioriNoApriori<>::type::type;
 
         case AprioriType::SMOOTHING: return AprioriSmoothing<>::type::type;
 
         case AprioriType::DIRICHLET_FROM_DATABASE:
           return AprioriDirichletFromDatabase<>::type::type;
 
         case AprioriType::BDEU: return AprioriBDeu<>::type::type;
 
         default:
           GUM_ERROR(OperationNotAllowed,
                     "genericBNLearner getAprioriType does "
                     "not support yet this apriori");
       }
     }

Here is the caller graph for this function:

◆ __learnDAG()

DAG gum::learning::genericBNLearner::__learnDAG ( )

protected

returns the DAG learnt

Definition at line 689 of file genericBNLearner.cpp.

References __apriori_database, __apriori_type, __constraint_ForbiddenArcs, __constraint_Indegree, __constraint_MandatoryArcs, __constraint_PossibleEdges, __constraint_SliceOrder, __constraint_TabuList, __greedy_hill_climbing, __initial_dag, __K2, __local_search_with_tabu_list, __miic_3off2, __mutual_info, __prepare_miic_3off2(), __score, __score_database, __selected_algo, gum::DAG::addArc(), gum::NodeGraphPart::addNodeWithId(), gum::learning::K2::approximationScheme(), gum::learning::StructuralConstraintForbiddenArcs::arcs(), gum::learning::StructuralConstraintMandatoryArcs::arcs(), gum::learning::genericBNLearner::Database::databaseTable(), DIRICHLET_FROM_DATABASE, gum::ArcGraphPart::eraseArc(), gum::NodeGraphPart::exists(), GREEDY_HILL_CLIMBING, GUM_ERROR, gum::learning::IDatabaseTable< T_DATA, ALLOC >::hasMissingValues(), K2, gum::learning::K2::learnStructure(), gum::learning::GreedyHillClimbing::learnStructure(), gum::learning::LocalSearchWithTabuList::learnStructure(), gum::learning::Miic::learnStructure(), LOCAL_SEARCH_WITH_TABU_LIST, MIIC_THREE_OFF_TWO, gum::learning::K2::order(), and gum::SequenceImplementation< Key, Alloc, Gen >::pos().

Referenced by learnDAG().

                                      {
       // check that the database does not contain any missing value
       if (__score_database.databaseTable().hasMissingValues()
           || ((__apriori_database != nullptr)
               && (__apriori_type == AprioriType::DIRICHLET_FROM_DATABASE)
               && __apriori_database->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 = __initial_dag;
 
       const ArcSet& mandatory_arcs = __constraint_MandatoryArcs.arcs();
 
       for (const auto& arc : mandatory_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());
       }
 
       const ArcSet& forbidden_arcs = __constraint_ForbiddenArcs.arcs();
 
       for (const auto& arc : forbidden_arcs) {
         init_graph.eraseArc(arc);
       }
 
       switch (__selected_algo) {
         // ========================================================================
         case AlgoType::MIIC_THREE_OFF_TWO: {
           BNLearnerListener listener(this, __miic_3off2);
           // create the mixedGraph and the corrected mutual information
           MixedGraph mgraph = this->__prepare_miic_3off2();
 
           return __miic_3off2.learnStructure(*__mutual_info, mgraph);
         }
 
         // ========================================================================
         case AlgoType::GREEDY_HILL_CLIMBING: {
           BNLearnerListener listener(this, __greedy_hill_climbing);
           StructuralConstraintSetStatic< StructuralConstraintMandatoryArcs,
                                          StructuralConstraintForbiddenArcs,
                                          StructuralConstraintPossibleEdges,
                                          StructuralConstraintSliceOrder >
              gen_constraint;
           static_cast< StructuralConstraintMandatoryArcs& >(gen_constraint) =
              __constraint_MandatoryArcs;
           static_cast< StructuralConstraintForbiddenArcs& >(gen_constraint) =
              __constraint_ForbiddenArcs;
           static_cast< StructuralConstraintPossibleEdges& >(gen_constraint) =
              __constraint_PossibleEdges;
           static_cast< StructuralConstraintSliceOrder& >(gen_constraint) =
              __constraint_SliceOrder;
 
           GraphChangesGenerator4DiGraph< decltype(gen_constraint) > op_set(
              gen_constraint);
 
           StructuralConstraintSetStatic< StructuralConstraintIndegree,
                                          StructuralConstraintDAG >
              sel_constraint;
           static_cast< StructuralConstraintIndegree& >(sel_constraint) =
              __constraint_Indegree;
 
           GraphChangesSelector4DiGraph< decltype(sel_constraint),
                                         decltype(op_set) >
              selector(*__score, sel_constraint, op_set);
 
           return __greedy_hill_climbing.learnStructure(selector, init_graph);
         }
 
         // ========================================================================
         case AlgoType::LOCAL_SEARCH_WITH_TABU_LIST: {
           BNLearnerListener listener(this, __local_search_with_tabu_list);
           StructuralConstraintSetStatic< StructuralConstraintMandatoryArcs,
                                          StructuralConstraintForbiddenArcs,
                                          StructuralConstraintPossibleEdges,
                                          StructuralConstraintSliceOrder >
              gen_constraint;
           static_cast< StructuralConstraintMandatoryArcs& >(gen_constraint) =
              __constraint_MandatoryArcs;
           static_cast< StructuralConstraintForbiddenArcs& >(gen_constraint) =
              __constraint_ForbiddenArcs;
           static_cast< StructuralConstraintPossibleEdges& >(gen_constraint) =
              __constraint_PossibleEdges;
           static_cast< StructuralConstraintSliceOrder& >(gen_constraint) =
              __constraint_SliceOrder;
 
           GraphChangesGenerator4DiGraph< decltype(gen_constraint) > op_set(
              gen_constraint);
 
           StructuralConstraintSetStatic< StructuralConstraintTabuList,
                                          StructuralConstraintIndegree,
                                          StructuralConstraintDAG >
              sel_constraint;
           static_cast< StructuralConstraintTabuList& >(sel_constraint) =
              __constraint_TabuList;
           static_cast< StructuralConstraintIndegree& >(sel_constraint) =
              __constraint_Indegree;
 
           GraphChangesSelector4DiGraph< decltype(sel_constraint),
                                         decltype(op_set) >
              selector(*__score, sel_constraint, op_set);
 
           return __local_search_with_tabu_list.learnStructure(selector,
                                                               init_graph);
         }
 
         // ========================================================================
         case AlgoType::K2: {
           BNLearnerListener listener(this, __K2.approximationScheme());
           StructuralConstraintSetStatic< StructuralConstraintMandatoryArcs,
                                          StructuralConstraintForbiddenArcs,
                                          StructuralConstraintPossibleEdges >
              gen_constraint;
           static_cast< StructuralConstraintMandatoryArcs& >(gen_constraint) =
              __constraint_MandatoryArcs;
           static_cast< StructuralConstraintForbiddenArcs& >(gen_constraint) =
              __constraint_ForbiddenArcs;
           static_cast< StructuralConstraintPossibleEdges& >(gen_constraint) =
              __constraint_PossibleEdges;
 
           GraphChangesGenerator4K2< decltype(gen_constraint) > op_set(
              gen_constraint);
 
           // 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& >(gen_constraint)
                 .arcs();
           const Sequence< NodeId >& order = __K2.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 >
                sel_constraint;
             static_cast< StructuralConstraintIndegree& >(sel_constraint) =
                __constraint_Indegree;
 
             GraphChangesSelector4DiGraph< decltype(sel_constraint),
                                           decltype(op_set) >
                selector(*__score, sel_constraint, op_set);
 
             return __K2.learnStructure(selector, init_graph);
           } else {
             StructuralConstraintSetStatic< StructuralConstraintIndegree,
                                            StructuralConstraintDAG >
                sel_constraint;
             static_cast< StructuralConstraintIndegree& >(sel_constraint) =
                __constraint_Indegree;
 
             GraphChangesSelector4DiGraph< decltype(sel_constraint),
                                           decltype(op_set) >
                selector(*__score, sel_constraint, op_set);
 
             return __K2.learnStructure(selector, init_graph);
           }
         }
 
         // ========================================================================
         default:
           GUM_ERROR(OperationNotAllowed,
                     "the learnDAG method has not been implemented for this "
                     "learning algorithm");
       }
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ __prepare_miic_3off2()

MixedGraph gum::learning::genericBNLearner::__prepare_miic_3off2 ( )

protected

prepares the initial graph for 3off2 or miic

Definition at line 605 of file genericBNLearner.cpp.

References __constraint_ForbiddenArcs, __constraint_MandatoryArcs, __createCorrectedMutualInformation(), __miic_3off2, __score_database, gum::learning::Miic::addConstraints(), gum::UndiGraph::addEdge(), gum::NodeGraphPart::addNodeWithId(), gum::learning::StructuralConstraintMandatoryArcs::arcs(), gum::learning::StructuralConstraintForbiddenArcs::arcs(), gum::learning::genericBNLearner::Database::databaseTable(), gum::HashTable< Key, Val, Alloc >::insert(), and gum::learning::IDatabaseTable< T_DATA, ALLOC >::nbVariables().

Referenced by __learnDAG(), and learnMixedStructure().

                                                       {
       // Initialize the mixed graph to the fully connected graph
       MixedGraph mgraph;
       for (Size i = 0; i < __score_database.databaseTable().nbVariables(); ++i) {
         mgraph.addNodeWithId(i);
         for (Size j = 0; j < i; ++j) {
           mgraph.addEdge(j, i);
         }
       }
 
       // translating the constraints for 3off2 or miic
       HashTable< std::pair< NodeId, NodeId >, char > initial_marks;
       const ArcSet& mandatory_arcs = __constraint_MandatoryArcs.arcs();
       for (const auto& arc : mandatory_arcs) {
         initial_marks.insert({arc.tail(), arc.head()}, '>');
       }
 
       const ArcSet& forbidden_arcs = __constraint_ForbiddenArcs.arcs();
       for (const auto& arc : forbidden_arcs) {
         initial_marks.insert({arc.tail(), arc.head()}, '-');
       }
       __miic_3off2.addConstraints(initial_marks);
 
       // create the mutual entropy object
       // if (__mutual_info == nullptr) { this->useNML(); }
       __createCorrectedMutualInformation();
 
       return mgraph;
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ __readFile()

DatabaseTable gum::learning::genericBNLearner::__readFile	(	const std::string &	filename,
		const std::vector< std::string > &	missing_symbols
	)

staticprotected

reads a file and returns a databaseVectInRam

Definition at line 433 of file genericBNLearner.cpp.

References __checkFileName(), database(), gum::learning::IDBInitializer< ALLOC >::fillDatabase(), gum::learning::DBTranslatorSet< ALLOC >::insertTranslator(), gum::learning::DatabaseTable< ALLOC >::reorder(), gum::learning::DatabaseTable< ALLOC >::setVariableNames(), and gum::learning::IDBInitializer< ALLOC >::variableNames().

                                                       {
       // get the extension of the file
       __checkFileName(filename);
 
       DBInitializerFromCSV<> initializer(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;
     }

Here is the call graph for this function:

◆ __setAprioriWeight()

INLINE void gum::learning::genericBNLearner::__setAprioriWeight ( double weight )

sets the apriori weight

Definition at line 451 of file genericBNLearner_inl.h.

References __apriori_weight, checkScoreAprioriCompatibility(), GUM_ERROR, and gum::learning::genericBNLearner::Database::weight().

Referenced by useAprioriBDeu(), useAprioriDirichlet(), and useAprioriSmoothing().

                                                                   {
       if (weight < 0) {
         GUM_ERROR(OutOfBounds, "the weight of the apriori must be positive");
       }
 
       __apriori_weight = weight;
       checkScoreAprioriCompatibility();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addForbiddenArc() [1/3]

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

Definition at line 359 of file genericBNLearner_inl.h.

References __constraint_ForbiddenArcs, and gum::learning::StructuralConstraintForbiddenArcs::addArc().

Referenced by addForbiddenArc().

                                                                 {
       __constraint_ForbiddenArcs.addArc(arc);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addForbiddenArc() [2/3]

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

Definition at line 369 of file genericBNLearner_inl.h.

References addForbiddenArc().

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

Here is the call graph for this function:

◆ addForbiddenArc() [3/3]

INLINE void gum::learning::genericBNLearner::addForbiddenArc	(	const std::string &	tail,
		const std::string &	head
	)

Definition at line 381 of file genericBNLearner_inl.h.

References addForbiddenArc(), and gum::learning::genericBNLearner::Database::idFromName().

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

Here is the call graph for this function:

◆ addMandatoryArc() [1/3]

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

Definition at line 398 of file genericBNLearner_inl.h.

References __constraint_MandatoryArcs, and gum::learning::StructuralConstraintMandatoryArcs::addArc().

Referenced by addMandatoryArc().

                                                                 {
       __constraint_MandatoryArcs.addArc(arc);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addMandatoryArc() [2/3]

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

Definition at line 420 of file genericBNLearner_inl.h.

References addMandatoryArc().

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

Here is the call graph for this function:

◆ addMandatoryArc() [3/3]

INLINE void gum::learning::genericBNLearner::addMandatoryArc	(	const std::string &	tail,
		const std::string &	head
	)

Definition at line 408 of file genericBNLearner_inl.h.

References addMandatoryArc(), and gum::learning::genericBNLearner::Database::idFromName().

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

Here is the call graph for this function:

◆ addPossibleEdge() [1/3]

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

Definition at line 320 of file genericBNLearner_inl.h.

References __constraint_PossibleEdges, and gum::learning::StructuralConstraintPossibleEdges::addEdge().

Referenced by addPossibleEdge().

                                                                   {
       __constraint_PossibleEdges.addEdge(edge);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addPossibleEdge() [2/3]

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

Definition at line 330 of file genericBNLearner_inl.h.

References addPossibleEdge().

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

Here is the call graph for this function:

◆ addPossibleEdge() [3/3]

INLINE void gum::learning::genericBNLearner::addPossibleEdge	(	const std::string &	tail,
		const std::string &	head
	)

Definition at line 342 of file genericBNLearner_inl.h.

References addPossibleEdge(), and gum::learning::genericBNLearner::Database::idFromName().

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

Here is the call graph for this function:

◆ checkScoreAprioriCompatibility()

std::string gum::learning::genericBNLearner::checkScoreAprioriCompatibility ( )

checks whether the current score and apriori are compatible

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

Definition at line 866 of file genericBNLearner.cpp.

References __apriori_weight, __getAprioriType(), __score_type, AIC, BD, BDeu, BIC, gum::learning::ScoreAIC< ALLOC >::isAprioriCompatible(), gum::learning::ScoreBIC< ALLOC >::isAprioriCompatible(), gum::learning::ScoreLog2Likelihood< ALLOC >::isAprioriCompatible(), gum::learning::ScoreBDeu< ALLOC >::isAprioriCompatible(), gum::learning::ScoreK2< ALLOC >::isAprioriCompatible(), gum::learning::ScoreBD< ALLOC >::isAprioriCompatible(), K2, and LOG2LIKELIHOOD.

Referenced by __setAprioriWeight(), useAprioriBDeu(), useAprioriDirichlet(), useAprioriSmoothing(), useNoApriori(), useScoreAIC(), useScoreBD(), useScoreBDeu(), useScoreBIC(), useScoreK2(), and useScoreLog2Likelihood().

                                                                {
       const std::string& apriori = __getAprioriType();
 
       switch (__score_type) {
         case ScoreType::AIC:
           return ScoreAIC<>::isAprioriCompatible(apriori, __apriori_weight);
 
         case ScoreType::BD:
           return ScoreBD<>::isAprioriCompatible(apriori, __apriori_weight);
 
         case ScoreType::BDeu:
           return ScoreBDeu<>::isAprioriCompatible(apriori, __apriori_weight);
 
         case ScoreType::BIC:
           return ScoreBIC<>::isAprioriCompatible(apriori, __apriori_weight);
 
         case ScoreType::K2:
           return ScoreK2<>::isAprioriCompatible(apriori, __apriori_weight);
 
         case ScoreType::LOG2LIKELIHOOD:
           return ScoreLog2Likelihood<>::isAprioriCompatible(apriori,
                                                             __apriori_weight);
 
         default: return "genericBNLearner does not support yet this score";
       }
     }

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::genericBNLearner::chi2	(	const NodeId	id1,
		const 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 941 of file genericBNLearner.cpp.

References __apriori, __createApriori(), __score_database, databaseRanges(), gum::learning::genericBNLearner::Database::parser(), and gum::learning::IndepTestChi2< ALLOC >::statistics().

Referenced by chi2().

                                                                                {
       __createApriori();
       gum::learning::IndepTestChi2<> chi2score(
          __score_database.parser(), *__apriori, databaseRanges());
 
       return chi2score.statistics(id1, id2, knowing);
     }

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::genericBNLearner::chi2	(	const std::string &	name1,
		const std::string &	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 951 of file genericBNLearner.cpp.

References chi2(), and idFromName().

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

Here is the call graph for this function:

◆ clearDatabaseRanges()

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

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

Definition at line 543 of file genericBNLearner_inl.h.

References __ranges.

543 { __ranges.clear(); }

gum::learning::genericBNLearner::__ranges

std::vector< std::pair< std::size_t, std::size_t > > __ranges

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

Definition: genericBNLearner.h:800

◆ currentTime()

double gum::learning::genericBNLearner::currentTime ( ) const

inlinevirtual

get the current running time in second (double)

Implements gum::IApproximationSchemeConfiguration.

Definition at line 1035 of file genericBNLearner.h.

References __current_algorithm, gum::ApproximationScheme::currentTime(), and GUM_ERROR.

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

Here is the call graph for this function:

◆ database()

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

returns the database used by the BNLearner

Definition at line 546 of file genericBNLearner_inl.h.

References __score_database, and gum::learning::genericBNLearner::Database::databaseTable().

Referenced by __readFile(), and gum::learning::readFile().

                                                                    {
       return __score_database.databaseTable();
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ databaseRanges()

INLINE const std::vector< std::pair< std::size_t, std::size_t > > & gum::learning::genericBNLearner::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 538 of file genericBNLearner_inl.h.

References __ranges.

Referenced by chi2(), G2(), and logLikelihood().

                                                         {
       return __ranges;
     }

Here is the caller graph for this function:

◆ databaseWeight()

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

returns the weight of the whole database

Definition at line 173 of file genericBNLearner_inl.h.

References __score_database, and gum::learning::genericBNLearner::Database::weight().

                                                          {
       return __score_database.weight();
     }

Here is the call graph for this function:

◆ disableEpsilon()

void gum::learning::genericBNLearner::disableEpsilon ( )

inlinevirtual

Disable stopping criterion on epsilon.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 900 of file genericBNLearner.h.

References gum::learning::K2::approximationScheme(), and gum::ApproximationScheme::disableEpsilon().

                             {
         __K2.approximationScheme().disableEpsilon();
         __greedy_hill_climbing.disableEpsilon();
         __local_search_with_tabu_list.disableEpsilon();
         __Dag2BN.disableEpsilon();
       };

Here is the call graph for this function:

◆ disableMaxIter()

void gum::learning::genericBNLearner::disableMaxIter ( )

inlinevirtual

Disable stopping criterion on max iterations.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 990 of file genericBNLearner.h.

References gum::learning::K2::approximationScheme(), and gum::ApproximationScheme::disableMaxIter().

                             {
         __K2.approximationScheme().disableMaxIter();
         __greedy_hill_climbing.disableMaxIter();
         __local_search_with_tabu_list.disableMaxIter();
         __Dag2BN.disableMaxIter();
       };

Here is the call graph for this function:

◆ disableMaxTime()

void gum::learning::genericBNLearner::disableMaxTime ( )

inlinevirtual

Disable stopping criterion on timeout.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 1043 of file genericBNLearner.h.

References gum::learning::K2::approximationScheme(), and gum::ApproximationScheme::disableMaxTime().

                             {
         __K2.approximationScheme().disableMaxTime();
         __greedy_hill_climbing.disableMaxTime();
         __local_search_with_tabu_list.disableMaxTime();
         __Dag2BN.disableMaxTime();
       };

Here is the call graph for this function:

◆ disableMinEpsilonRate()

void gum::learning::genericBNLearner::disableMinEpsilonRate ( )

inlinevirtual

Disable stopping criterion on epsilon rate.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 946 of file genericBNLearner.h.

References gum::learning::K2::approximationScheme(), and gum::ApproximationScheme::disableMinEpsilonRate().

                                    {
         __K2.approximationScheme().disableMinEpsilonRate();
         __greedy_hill_climbing.disableMinEpsilonRate();
         __local_search_with_tabu_list.disableMinEpsilonRate();
         __Dag2BN.disableMinEpsilonRate();
       };

Here is the call graph for this function:

◆ distributeProgress()

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

inline

{@ /// distribute signals

Definition at line 862 of file genericBNLearner.h.

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

Referenced by gum::learning::BNLearnerListener::whenProgress().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ distributeStop()

INLINE void gum::learning::genericBNLearner::distributeStop	(	const ApproximationScheme *	approximationScheme,
		std::string	message
	)

inline

distribute signals

Definition at line 872 of file genericBNLearner.h.

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

Referenced by gum::learning::BNLearnerListener::whenStop().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ domainSizes()

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

returns the domain sizes of the variables in the database

Definition at line 532 of file genericBNLearner_inl.h.

References __score_database, and gum::learning::genericBNLearner::Database::domainSizes().

                                                      {
       return __score_database.domainSizes();
     }

Here is the call graph for this function:

◆ enableEpsilon()

void gum::learning::genericBNLearner::enableEpsilon ( )

inlinevirtual

Enable stopping criterion on epsilon.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 908 of file genericBNLearner.h.

References gum::learning::K2::approximationScheme(), and gum::ApproximationScheme::enableEpsilon().

                            {
         __K2.approximationScheme().enableEpsilon();
         __greedy_hill_climbing.enableEpsilon();
         __local_search_with_tabu_list.enableEpsilon();
         __Dag2BN.enableEpsilon();
       };

Here is the call graph for this function:

◆ enableMaxIter()

void gum::learning::genericBNLearner::enableMaxIter ( )

inlinevirtual

Enable stopping criterion on max iterations.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 997 of file genericBNLearner.h.

References gum::learning::K2::approximationScheme(), and gum::ApproximationScheme::enableMaxIter().

                            {
         __K2.approximationScheme().enableMaxIter();
         __greedy_hill_climbing.enableMaxIter();
         __local_search_with_tabu_list.enableMaxIter();
         __Dag2BN.enableMaxIter();
       };

Here is the call graph for this function:

◆ enableMaxTime()

void gum::learning::genericBNLearner::enableMaxTime ( )

inlinevirtual

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

Exceptions

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

Implements gum::IApproximationSchemeConfiguration.

Definition at line 1049 of file genericBNLearner.h.

References gum::learning::K2::approximationScheme(), and gum::ApproximationScheme::enableMaxTime().

                            {
         __K2.approximationScheme().enableMaxTime();
         __greedy_hill_climbing.enableMaxTime();
         __local_search_with_tabu_list.enableMaxTime();
         __Dag2BN.enableMaxTime();
       };

Here is the call graph for this function:

◆ enableMinEpsilonRate()

void gum::learning::genericBNLearner::enableMinEpsilonRate ( )

inlinevirtual

Enable stopping criterion on epsilon rate.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 953 of file genericBNLearner.h.

References gum::learning::K2::approximationScheme(), and gum::ApproximationScheme::enableMinEpsilonRate().

                                   {
         __K2.approximationScheme().enableMinEpsilonRate();
         __greedy_hill_climbing.enableMinEpsilonRate();
         __local_search_with_tabu_list.enableMinEpsilonRate();
         __Dag2BN.enableMinEpsilonRate();
       };

Here is the call graph for this function:

◆ epsilon()

double gum::learning::genericBNLearner::epsilon ( ) const

inlinevirtual

Get the value of epsilon.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 892 of file genericBNLearner.h.

References __current_algorithm, gum::ApproximationScheme::epsilon(), and GUM_ERROR.

Referenced by useEM().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eraseForbiddenArc() [1/3]

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

Definition at line 364 of file genericBNLearner_inl.h.

References __constraint_ForbiddenArcs, and gum::learning::StructuralConstraintForbiddenArcs::eraseArc().

Referenced by eraseForbiddenArc().

                                                                   {
       __constraint_ForbiddenArcs.eraseArc(arc);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eraseForbiddenArc() [2/3]

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

Definition at line 375 of file genericBNLearner_inl.h.

References eraseForbiddenArc().

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

Here is the call graph for this function:

◆ eraseForbiddenArc() [3/3]

INLINE void gum::learning::genericBNLearner::eraseForbiddenArc	(	const std::string &	tail,
		const std::string &	head
	)

Definition at line 387 of file genericBNLearner_inl.h.

References eraseForbiddenArc(), and gum::learning::genericBNLearner::Database::idFromName().

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

Here is the call graph for this function:

◆ eraseMandatoryArc() [1/3]

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

Definition at line 403 of file genericBNLearner_inl.h.

References __constraint_MandatoryArcs, and gum::learning::StructuralConstraintMandatoryArcs::eraseArc().

Referenced by eraseMandatoryArc().

                                                                   {
       __constraint_MandatoryArcs.eraseArc(arc);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ eraseMandatoryArc() [2/3]

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

Definition at line 426 of file genericBNLearner_inl.h.

References eraseMandatoryArc().

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

Here is the call graph for this function:

◆ eraseMandatoryArc() [3/3]

INLINE void gum::learning::genericBNLearner::eraseMandatoryArc	(	const std::string &	tail,
		const std::string &	head
	)

Definition at line 414 of file genericBNLearner_inl.h.

References eraseMandatoryArc(), and gum::learning::genericBNLearner::Database::idFromName().

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

Here is the call graph for this function:

◆ erasePossibleEdge() [1/3]

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

Definition at line 325 of file genericBNLearner_inl.h.

References __constraint_PossibleEdges, and gum::learning::StructuralConstraintPossibleEdges::eraseEdge().

Referenced by erasePossibleEdge().

                                                                     {
       __constraint_PossibleEdges.eraseEdge(edge);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ erasePossibleEdge() [2/3]

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

Definition at line 336 of file genericBNLearner_inl.h.

References erasePossibleEdge().

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

Here is the call graph for this function:

◆ erasePossibleEdge() [3/3]

INLINE void gum::learning::genericBNLearner::erasePossibleEdge	(	const std::string &	tail,
		const std::string &	head
	)

Definition at line 348 of file genericBNLearner_inl.h.

References erasePossibleEdge(), and gum::learning::genericBNLearner::Database::idFromName().

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

Here is the call graph for this function:

◆ G2() [1/2]

std::pair< double, double > gum::learning::genericBNLearner::G2	(	const NodeId	id1,
		const 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 963 of file genericBNLearner.cpp.

References __apriori, __createApriori(), __score_database, databaseRanges(), gum::learning::genericBNLearner::Database::parser(), and gum::learning::IndepTestG2< ALLOC >::statistics().

Referenced by G2().

                                                                                {
       __createApriori();
       gum::learning::IndepTestG2<> g2score(
          __score_database.parser(), *__apriori, databaseRanges());
       return g2score.statistics(id1, id2, knowing);
     }

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::genericBNLearner::G2	(	const std::string &	name1,
		const std::string &	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 972 of file genericBNLearner.cpp.

References G2(), and idFromName().

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

Here is the call graph for this function:

◆ hasMissingValues()

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

returns true if the learner's database has missing values

Definition at line 306 of file genericBNLearner_inl.h.

References __score_database, gum::learning::genericBNLearner::Database::databaseTable(), and gum::learning::IDatabaseTable< T_DATA, ALLOC >::hasMissingValues().

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

Here is the call graph for this function:

◆ history()

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

inlinevirtual

Exceptions

OperationNotAllowed if scheme not performed or verbosity=false

Implements gum::IApproximationSchemeConfiguration.

Definition at line 1119 of file genericBNLearner.h.

References __current_algorithm, GUM_ERROR, and gum::ApproximationScheme::history().

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

Here is the call graph for this function:

◆ idFromName()

INLINE NodeId gum::learning::genericBNLearner::idFromName ( const std::string & 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 147 of file genericBNLearner_inl.h.

References __score_database, and gum::learning::genericBNLearner::Database::idFromName().

Referenced by chi2(), G2(), and logLikelihood().

                                                                               {
       return __score_database.idFromName(var_name);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isEnabledEpsilon()

bool gum::learning::genericBNLearner::isEnabledEpsilon ( ) const

inlinevirtual

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

Implements gum::IApproximationSchemeConfiguration.

Definition at line 917 of file genericBNLearner.h.

References __current_algorithm, GUM_ERROR, and gum::ApproximationScheme::isEnabledEpsilon().

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

Here is the call graph for this function:

◆ isEnabledMaxIter()

bool gum::learning::genericBNLearner::isEnabledMaxIter ( ) const

inlinevirtual

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

Implements gum::IApproximationSchemeConfiguration.

Definition at line 1005 of file genericBNLearner.h.

References __current_algorithm, GUM_ERROR, and gum::ApproximationScheme::isEnabledMaxIter().

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

Here is the call graph for this function:

◆ isEnabledMaxTime()

bool gum::learning::genericBNLearner::isEnabledMaxTime ( ) const

inlinevirtual

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

Implements gum::IApproximationSchemeConfiguration.

Definition at line 1057 of file genericBNLearner.h.

References __current_algorithm, GUM_ERROR, and gum::ApproximationScheme::isEnabledMaxTime().

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

Here is the call graph for this function:

◆ isEnabledMinEpsilonRate()

bool gum::learning::genericBNLearner::isEnabledMinEpsilonRate ( ) const

inlinevirtual

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

Implements gum::IApproximationSchemeConfiguration.

Definition at line 961 of file genericBNLearner.h.

References __current_algorithm, GUM_ERROR, and gum::ApproximationScheme::isEnabledMinEpsilonRate().

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

Here is the call graph for this function:

◆ latentVariables()

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

get the list of arcs hiding latent variables

Exceptions

OperationNotAllowed when 3off2 is not the selected algorithm

Definition at line 266 of file genericBNLearner_inl.h.

References __miic_3off2, __selected_algo, GUM_ERROR, gum::learning::Miic::latentVariables(), and MIIC_THREE_OFF_TWO.

                                                                           {
       if (__selected_algo != AlgoType::MIIC_THREE_OFF_TWO) {
         GUM_ERROR(OperationNotAllowed,
                   "You must use the 3off2 algorithm before selecting "
                      << "the latentVariables method");
       }
       return __miic_3off2.latentVariables();
     }

Here is the call graph for this function:

◆ learnDAG()

DAG gum::learning::genericBNLearner::learnDAG ( )

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

Definition at line 653 of file genericBNLearner.cpp.

References __createApriori(), __createScore(), and __learnDAG().

                                    {
       // create the score and the apriori
       __createApriori();
       __createScore();
 
       return __learnDAG();
     }

Here is the call graph for this function:

◆ learnMixedStructure()

MixedGraph gum::learning::genericBNLearner::learnMixedStructure ( )

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

Definition at line 635 of file genericBNLearner.cpp.

References __miic_3off2, __mutual_info, __prepare_miic_3off2(), __score_database, __selected_algo, gum::learning::genericBNLearner::Database::databaseTable(), GUM_ERROR, gum::learning::IDatabaseTable< T_DATA, ALLOC >::hasMissingValues(), gum::learning::Miic::learnMixedStructure(), and MIIC_THREE_OFF_TWO.

                                                      {
       if (__selected_algo != AlgoType::MIIC_THREE_OFF_TWO) {
         GUM_ERROR(OperationNotAllowed, "Must be using the miic/3off2 algorithm");
       }
       // check that the database does not contain any missing value
       if (__score_database.databaseTable().hasMissingValues()) {
         GUM_ERROR(MissingValueInDatabase,
                   "For the moment, the BNLearner is unable to learn "
                      << "structures with missing values in databases");
       }
       BNLearnerListener listener(this, __miic_3off2);
 
       // create the mixedGraph_constraint_MandatoryArcs.arcs();
       MixedGraph mgraph = this->__prepare_miic_3off2();
 
       return __miic_3off2.learnMixedStructure(*__mutual_info, mgraph);
     }

Here is the call graph for this function:

◆ logLikelihood() [1/2]

double gum::learning::genericBNLearner::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 std::pair<double,double>

Definition at line 984 of file genericBNLearner.cpp.

References __apriori, __createApriori(), __score_database, databaseRanges(), gum::learning::genericBNLearner::Database::parser(), and gum::learning::ScoreLog2Likelihood< ALLOC >::score().

Referenced by logLikelihood().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ logLikelihood() [2/2]

double gum::learning::genericBNLearner::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 std::pair<double,double>

Definition at line 1002 of file genericBNLearner.cpp.

References idFromName(), and logLikelihood().

                                                                               {
       std::vector< NodeId > ids;
       std::vector< NodeId > knowingIds;
 
       auto mapper = [this](const std::string& c) -> NodeId {
         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);
     }

Here is the call graph for this function:

◆ maxIter()

Size gum::learning::genericBNLearner::maxIter ( ) const

inlinevirtual

Returns: the criterion on number of iterations

Implements gum::IApproximationSchemeConfiguration.

Definition at line 982 of file genericBNLearner.h.

References __current_algorithm, GUM_ERROR, and gum::ApproximationScheme::maxIter().

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

Here is the call graph for this function:

◆ maxTime()

double gum::learning::genericBNLearner::maxTime ( ) const

inlinevirtual

returns the timeout (in seconds)

Implements gum::IApproximationSchemeConfiguration.

Definition at line 1027 of file genericBNLearner.h.

References __current_algorithm, GUM_ERROR, and gum::ApproximationScheme::maxTime().

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

Here is the call graph for this function:

◆ messageApproximationScheme()

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

inherited

Returns the approximation scheme message.

Returns: Returns the approximation scheme message.

Definition at line 40 of file IApproximationSchemeConfiguration_inl.h.

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ minEpsilonRate()

double gum::learning::genericBNLearner::minEpsilonRate ( ) const

inlinevirtual

Get the value of the minimal epsilon rate.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 938 of file genericBNLearner.h.

References __current_algorithm, GUM_ERROR, and gum::ApproximationScheme::minEpsilonRate().

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

Here is the call graph for this function:

◆ nameFromId()

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

returns the variable name corresponding to a given node id

Definition at line 152 of file genericBNLearner_inl.h.

References __score_database, and gum::learning::genericBNLearner::Database::nameFromId().

                                                                         {
       return __score_database.nameFromId(id);
     }

Here is the call graph for this function:

◆ names()

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

returns the names of the variables in the database

Definition at line 526 of file genericBNLearner_inl.h.

References __score_database, and gum::learning::genericBNLearner::Database::names().

                                                                        {
       return __score_database.names();
     }

Here is the call graph for this function:

◆ nbCols()

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

Returns: the number of cols in the database

Definition at line 550 of file genericBNLearner_inl.h.

References __score_database, and gum::learning::genericBNLearner::Database::domainSizes().

                                                {
       return __score_database.domainSizes().size();
     }

Here is the call graph for this function:

◆ nbrIterations()

Size gum::learning::genericBNLearner::nbrIterations ( ) const

inlinevirtual

Exceptions

OperationNotAllowed if scheme not performed

Implements gum::IApproximationSchemeConfiguration.

Definition at line 1111 of file genericBNLearner.h.

References __current_algorithm, GUM_ERROR, and gum::ApproximationScheme::nbrIterations().

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

Here is the call graph for this function:

◆ nbRows()

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

Returns: the number of rows in the database

Definition at line 554 of file genericBNLearner_inl.h.

References __score_database, gum::learning::genericBNLearner::Database::databaseTable(), and gum::learning::IDatabaseTable< T_DATA, ALLOC >::size().

                                                {
       return __score_database.databaseTable().size();
     }

Here is the call graph for this function:

◆ operator=() [1/2]

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

copy operator

Definition at line 274 of file genericBNLearner.cpp.

References __3off2_kmode, __apriori, __apriori_database, __apriori_dbname, __apriori_type, __apriori_weight, __constraint_ForbiddenArcs, __constraint_Indegree, __constraint_MandatoryArcs, __constraint_SliceOrder, __constraint_TabuList, __current_algorithm, __EMepsilon, __greedy_hill_climbing, __initial_dag, __K2, __local_search_with_tabu_list, __miic_3off2, __mutual_info, __param_estimator_type, __ranges, __score, __score_database, __score_type, and __selected_algo.

                                                                               {
       if (this != &from) {
         if (__score) {
           delete __score;
           __score = nullptr;
         }
 
         if (__apriori) {
           delete __apriori;
           __apriori = nullptr;
         }
 
         if (__apriori_database) {
           delete __apriori_database;
           __apriori_database = nullptr;
         }
 
         if (__mutual_info) {
           delete __mutual_info;
           __mutual_info = nullptr;
         }
 
         __score_type = from.__score_type;
         __param_estimator_type = from.__param_estimator_type;
         __EMepsilon = from.__EMepsilon;
         __apriori_type = from.__apriori_type;
         __apriori_weight = from.__apriori_weight;
         __constraint_SliceOrder = from.__constraint_SliceOrder;
         __constraint_Indegree = from.__constraint_Indegree;
         __constraint_TabuList = from.__constraint_TabuList;
         __constraint_ForbiddenArcs = from.__constraint_ForbiddenArcs;
         __constraint_MandatoryArcs = from.__constraint_MandatoryArcs;
         __selected_algo = from.__selected_algo;
         __K2 = from.__K2;
         __miic_3off2 = from.__miic_3off2;
         __3off2_kmode = from.__3off2_kmode;
         __greedy_hill_climbing = from.__greedy_hill_climbing;
         __local_search_with_tabu_list = from.__local_search_with_tabu_list;
         __score_database = from.__score_database;
         __ranges = from.__ranges;
         __apriori_dbname = from.__apriori_dbname;
         __initial_dag = from.__initial_dag;
         __current_algorithm = nullptr;
       }
 
       return *this;
     }

◆ operator=() [2/2]

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

move operator

Definition at line 322 of file genericBNLearner.cpp.

References __3off2_kmode, __apriori, __apriori_database, __apriori_dbname, __apriori_type, __apriori_weight, __constraint_ForbiddenArcs, __constraint_Indegree, __constraint_MandatoryArcs, __constraint_SliceOrder, __constraint_TabuList, __current_algorithm, __EMepsilon, __greedy_hill_climbing, __initial_dag, __K2, __local_search_with_tabu_list, __miic_3off2, __mutual_info, __param_estimator_type, __ranges, __score, __score_database, __score_type, and __selected_algo.

                                                                          {
       if (this != &from) {
         if (__score) {
           delete __score;
           __score = nullptr;
         }
 
         if (__apriori) {
           delete __apriori;
           __apriori = nullptr;
         }
 
         if (__apriori_database) {
           delete __apriori_database;
           __apriori_database = nullptr;
         }
 
         if (__mutual_info) {
           delete __mutual_info;
           __mutual_info = nullptr;
         }
 
         __score_type = from.__score_type;
         __param_estimator_type = from.__param_estimator_type;
         __EMepsilon = from.__EMepsilon;
         __apriori_type = from.__apriori_type;
         __apriori_weight = from.__apriori_weight;
         __constraint_SliceOrder = std::move(from.__constraint_SliceOrder);
         __constraint_Indegree = std::move(from.__constraint_Indegree);
         __constraint_TabuList = std::move(from.__constraint_TabuList);
         __constraint_ForbiddenArcs = std::move(from.__constraint_ForbiddenArcs);
         __constraint_MandatoryArcs = std::move(from.__constraint_MandatoryArcs);
         __selected_algo = from.__selected_algo;
         __K2 = from.__K2;
         __miic_3off2 = std::move(from.__miic_3off2);
         __3off2_kmode = from.__3off2_kmode;
         __greedy_hill_climbing = std::move(from.__greedy_hill_climbing);
         __local_search_with_tabu_list =
            std::move(from.__local_search_with_tabu_list);
         __score_database = std::move(from.__score_database);
         __ranges = std::move(from.__ranges);
         __apriori_dbname = std::move(from.__apriori_dbname);
         __initial_dag = std::move(from.__initial_dag);
         __current_algorithm = nullptr;
       }
 
       return *this;
     }

◆ periodSize()

Size gum::learning::genericBNLearner::periodSize ( ) const

inlinevirtual

how many samples between 2 stopping isEnableds

Exceptions

OutOfLowerBound if p<1

Implements gum::IApproximationSchemeConfiguration.

Definition at line 1075 of file genericBNLearner.h.

References __current_algorithm, GUM_ERROR, and gum::ApproximationScheme::periodSize().

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

Here is the call graph for this function:

◆ recordWeight()

INLINE double gum::learning::genericBNLearner::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 168 of file genericBNLearner_inl.h.

References __score_database, and gum::learning::genericBNLearner::Database::weight().

                                                                         {
       return __score_database.weight(i);
     }

Here is the call graph for this function:

◆ setCurrentApproximationScheme()

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

inline

{@ /// distribute signals

Definition at line 856 of file genericBNLearner.h.

References __current_algorithm.

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

                                                          {
         __current_algorithm = approximationScheme;
       }

Here is the caller graph for this function:

◆ setDatabaseWeight()

INLINE void gum::learning::genericBNLearner::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 157 of file genericBNLearner_inl.h.

References __score_database, and gum::learning::genericBNLearner::Database::setDatabaseWeight().

                                                                            {
       __score_database.setDatabaseWeight(new_weight);
     }

Here is the call graph for this function:

◆ setEpsilon()

void gum::learning::genericBNLearner::setEpsilon ( double eps )

inlinevirtual

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

Exceptions

OutOfLowerBound if eps<0

Implements gum::IApproximationSchemeConfiguration.

Definition at line 884 of file genericBNLearner.h.

References gum::learning::K2::approximationScheme(), and gum::ApproximationScheme::setEpsilon().

                                   {
         __K2.approximationScheme().setEpsilon(eps);
         __greedy_hill_climbing.setEpsilon(eps);
         __local_search_with_tabu_list.setEpsilon(eps);
         __Dag2BN.setEpsilon(eps);
       };

Here is the call graph for this function:

◆ setForbiddenArcs()

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

assign a set of forbidden arcs

Definition at line 354 of file genericBNLearner_inl.h.

References __constraint_ForbiddenArcs, and gum::learning::StructuralConstraintForbiddenArcs::setArcs().

                                                                     {
       __constraint_ForbiddenArcs.setArcs(set);
     }

Here is the call graph for this function:

◆ setInitialDAG()

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

sets an initial DAG structure

Definition at line 178 of file genericBNLearner_inl.h.

References __initial_dag.

                                                               {
       __initial_dag = dag;
     }

◆ setMandatoryArcs()

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

assign a set of forbidden arcs

Definition at line 393 of file genericBNLearner_inl.h.

References __constraint_MandatoryArcs, and gum::learning::StructuralConstraintMandatoryArcs::setArcs().

                                                                     {
       __constraint_MandatoryArcs.setArcs(set);
     }

Here is the call graph for this function:

◆ setMaxIndegree()

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

sets the max indegree

Definition at line 219 of file genericBNLearner_inl.h.

References __constraint_Indegree, and gum::learning::StructuralConstraintIndegree::setMaxIndegree().

                                                                   {
       __constraint_Indegree.setMaxIndegree(max_indegree);
     }

Here is the call graph for this function:

◆ setMaxIter()

void gum::learning::genericBNLearner::setMaxIter ( Size max )

inlinevirtual

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

Parameters

max	The maximum number of iterations

Exceptions

OutOfLowerBound if max<=1

Implements gum::IApproximationSchemeConfiguration.

Definition at line 974 of file genericBNLearner.h.

References gum::learning::K2::approximationScheme(), and gum::ApproximationScheme::setMaxIter().

                                 {
         __K2.approximationScheme().setMaxIter(max);
         __greedy_hill_climbing.setMaxIter(max);
         __local_search_with_tabu_list.setMaxIter(max);
         __Dag2BN.setMaxIter(max);
       };

Here is the call graph for this function:

◆ setMaxTime()

void gum::learning::genericBNLearner::setMaxTime ( double timeout )

inlinevirtual

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

Exceptions

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

Implements gum::IApproximationSchemeConfiguration.

Definition at line 1019 of file genericBNLearner.h.

References gum::learning::K2::approximationScheme(), and gum::ApproximationScheme::setMaxTime().

                                       {
         __K2.approximationScheme().setMaxTime(timeout);
         __greedy_hill_climbing.setMaxTime(timeout);
         __local_search_with_tabu_list.setMaxTime(timeout);
         __Dag2BN.setMaxTime(timeout);
       }

Here is the call graph for this function:

◆ setMinEpsilonRate()

void gum::learning::genericBNLearner::setMinEpsilonRate ( double rate )

inlinevirtual

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

OutOfLowerBound if rate<0

Implements gum::IApproximationSchemeConfiguration.

Definition at line 930 of file genericBNLearner.h.

References gum::learning::K2::approximationScheme(), and gum::ApproximationScheme::setMinEpsilonRate().

                                           {
         __K2.approximationScheme().setMinEpsilonRate(rate);
         __greedy_hill_climbing.setMinEpsilonRate(rate);
         __local_search_with_tabu_list.setMinEpsilonRate(rate);
         __Dag2BN.setMinEpsilonRate(rate);
       };

Here is the call graph for this function:

◆ setPeriodSize()

void gum::learning::genericBNLearner::setPeriodSize ( Size p )

inlinevirtual

how many samples between 2 stopping isEnableds

Exceptions

OutOfLowerBound if p<1

Implements gum::IApproximationSchemeConfiguration.

Definition at line 1068 of file genericBNLearner.h.

References gum::learning::K2::approximationScheme(), and gum::ApproximationScheme::setPeriodSize().

                                  {
         __K2.approximationScheme().setPeriodSize(p);
         __greedy_hill_climbing.setPeriodSize(p);
         __local_search_with_tabu_list.setPeriodSize(p);
         __Dag2BN.setPeriodSize(p);
       };

Here is the call graph for this function:

◆ setPossibleEdges()

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

assign a set of forbidden edges

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

Definition at line 311 of file genericBNLearner_inl.h.

References __constraint_PossibleEdges, and gum::learning::StructuralConstraintPossibleEdges::setEdges().

Referenced by setPossibleSkeleton().

                                                                      {
       __constraint_PossibleEdges.setEdges(set);
     }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setPossibleSkeleton()

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

assign a set of forbidden edges

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

Definition at line 315 of file genericBNLearner_inl.h.

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

                                                                            {
       setPossibleEdges(g.edges());
     }

Here is the call graph for this function:

◆ setRecordWeight()

INLINE void gum::learning::genericBNLearner::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 162 of file genericBNLearner_inl.h.

References __score_database, and gum::learning::genericBNLearner::Database::setWeight().

                                                                                 {
       __score_database.setWeight(i, new_weight);
     }

Here is the call graph for this function:

◆ setSliceOrder() [1/2]

INLINE void gum::learning::genericBNLearner::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 433 of file genericBNLearner_inl.h.

References __constraint_SliceOrder.

Referenced by setSliceOrder().

                                                                                 {
       __constraint_SliceOrder = StructuralConstraintSliceOrder(slice_order);
     }

Here is the caller graph for this function:

◆ setSliceOrder() [2/2]

INLINE void gum::learning::genericBNLearner::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

Definition at line 437 of file genericBNLearner_inl.h.

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

                                                           {
       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);
     }

Here is the call graph for this function:

◆ setVerbosity()

void gum::learning::genericBNLearner::setVerbosity ( bool v )

inlinevirtual

verbosity

Implements gum::IApproximationSchemeConfiguration.

Definition at line 1085 of file genericBNLearner.h.

References gum::learning::K2::approximationScheme(), and gum::ApproximationScheme::setVerbosity().

                                 {
         __K2.approximationScheme().setVerbosity(v);
         __greedy_hill_climbing.setVerbosity(v);
         __local_search_with_tabu_list.setVerbosity(v);
         __Dag2BN.setVerbosity(v);
       };

Here is the call graph for this function:

◆ stateApproximationScheme()

ApproximationSchemeSTATE gum::learning::genericBNLearner::stateApproximationScheme ( ) const

inlinevirtual

history

Implements gum::IApproximationSchemeConfiguration.

Definition at line 1103 of file genericBNLearner.h.

References __current_algorithm, GUM_ERROR, and gum::ApproximationScheme::stateApproximationScheme().

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

Here is the call graph for this function:

◆ use3off2()

INLINE void gum::learning::genericBNLearner::use3off2 ( )

indicate that we wish to use 3off2

Definition at line 224 of file genericBNLearner_inl.h.

References __miic_3off2, __selected_algo, MIIC_THREE_OFF_TWO, and gum::learning::Miic::set3off2Behaviour().

                                            {
       __selected_algo = AlgoType::MIIC_THREE_OFF_TWO;
       __miic_3off2.set3off2Behaviour();
     }

Here is the call graph for this function:

◆ useAprioriBDeu()

INLINE void gum::learning::genericBNLearner::useAprioriBDeu ( double weight = 1 )

use the BDeu apriori

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

Definition at line 494 of file genericBNLearner_inl.h.

References __apriori_type, __setAprioriWeight(), BDEU, checkScoreAprioriCompatibility(), and GUM_ERROR.

                                                               {
       if (weight < 0) {
         GUM_ERROR(OutOfBounds, "the weight of the apriori must be positive");
       }
 
       __apriori_type = AprioriType::BDEU;
       __setAprioriWeight(weight);
 
       checkScoreAprioriCompatibility();
     }

Here is the call graph for this function:

◆ useAprioriDirichlet()

INLINE void gum::learning::genericBNLearner::useAprioriDirichlet	(	const std::string &	filename,
		double	weight = `1`
	)

use the Dirichlet apriori

Definition at line 479 of file genericBNLearner_inl.h.

References __apriori_dbname, __apriori_type, __setAprioriWeight(), checkScoreAprioriCompatibility(), DIRICHLET_FROM_DATABASE, and GUM_ERROR.

                                                                                  {
       if (weight < 0) {
         GUM_ERROR(OutOfBounds, "the weight of the apriori must be positive");
       }
 
       __apriori_dbname = filename;
       __apriori_type = AprioriType::DIRICHLET_FROM_DATABASE;
       __setAprioriWeight(weight);
 
       checkScoreAprioriCompatibility();
     }

Here is the call graph for this function:

◆ useAprioriSmoothing()

INLINE void gum::learning::genericBNLearner::useAprioriSmoothing ( double weight = 1 )

use the apriori smoothing

Parameters

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

Definition at line 467 of file genericBNLearner_inl.h.

References __apriori_type, __setAprioriWeight(), checkScoreAprioriCompatibility(), GUM_ERROR, and SMOOTHING.

                                                                    {
       if (weight < 0) {
         GUM_ERROR(OutOfBounds, "the weight of the apriori must be positive");
       }
 
       __apriori_type = AprioriType::SMOOTHING;
       __setAprioriWeight(weight);
 
       checkScoreAprioriCompatibility();
     }

Here is the call graph for this function:

◆ useCrossValidationFold()

std::pair< std::size_t, std::size_t > gum::learning::genericBNLearner::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 896 of file genericBNLearner.cpp.

References __ranges, __score_database, gum::learning::genericBNLearner::Database::databaseTable(), GUM_ERROR, and gum::learning::IDatabaseTable< T_DATA, ALLOC >::nbRows().

                                                                         {
       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 = __score_database.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);
     }

Here is the call graph for this function:

◆ useDatabaseRanges()

template<template< typename > class XALLOC>

void gum::learning::genericBNLearner::useDatabaseRanges ( const std::vector< std::pair< std::size_t, std::size_t >, XALLOC< 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 101 of file genericBNLearner_tpl.h.

References __no_apriori, __ranges, __score_database, gum::learning::genericBNLearner::Database::parser(), and gum::learning::Score< ALLOC >::setRanges().

                       {
       // use a score to detect whether the ranges are ok
       ScoreLog2Likelihood<> score(__score_database.parser(), *__no_apriori);
       score.setRanges(new_ranges);
       __ranges = score.ranges();
     }

Here is the call graph for this function:

◆ useEM()

INLINE void gum::learning::genericBNLearner::useEM ( const double epsilon )

use The EM algorithm to learn paramters

if epsilon=0, EM is not used

Definition at line 301 of file genericBNLearner_inl.h.

References __EMepsilon, and epsilon().

                                                             {
       __EMepsilon = epsilon;
     }

Here is the call graph for this function:

◆ useGreedyHillClimbing()

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

indicate that we wish to use a greedy hill climbing algorithm

Definition at line 288 of file genericBNLearner_inl.h.

References __selected_algo, and GREEDY_HILL_CLIMBING.

                                                         {
       __selected_algo = AlgoType::GREEDY_HILL_CLIMBING;
     }

◆ useK2() [1/2]

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

indicate that we wish to use K2

Definition at line 276 of file genericBNLearner_inl.h.

References __K2, __selected_algo, K2, and gum::learning::K2::setOrder().

                                                                        {
       __selected_algo = AlgoType::K2;
       __K2.setOrder(order);
     }

Here is the call graph for this function:

◆ useK2() [2/2]

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

indicate that we wish to use K2

Definition at line 282 of file genericBNLearner_inl.h.

References __K2, __selected_algo, K2, and gum::learning::K2::setOrder().

                                                                         {
       __selected_algo = AlgoType::K2;
       __K2.setOrder(order);
     }

Here is the call graph for this function:

◆ useLocalSearchWithTabuList()

INLINE void gum::learning::genericBNLearner::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 293 of file genericBNLearner_inl.h.

References __constraint_TabuList, __local_search_with_tabu_list, __selected_algo, LOCAL_SEARCH_WITH_TABU_LIST, gum::learning::LocalSearchWithTabuList::setMaxNbDecreasingChanges(), and gum::learning::StructuralConstraintTabuList::setTabuListSize().

                                                                                {
       __selected_algo = AlgoType::LOCAL_SEARCH_WITH_TABU_LIST;
       __constraint_TabuList.setTabuListSize(tabu_size);
       __local_search_with_tabu_list.setMaxNbDecreasingChanges(nb_decrease);
     }

Here is the call graph for this function:

◆ useMDL()

INLINE void gum::learning::genericBNLearner::useMDL ( )

indicate that we wish to use the MDL correction for 3off2

Exceptions

OperationNotAllowed when 3off2 is not the selected algorithm

Definition at line 246 of file genericBNLearner_inl.h.

References __3off2_kmode, __selected_algo, GUM_ERROR, and MIIC_THREE_OFF_TWO.

                                          {
       if (__selected_algo != AlgoType::MIIC_THREE_OFF_TWO) {
         GUM_ERROR(OperationNotAllowed,
                   "You must use the 3off2 algorithm before selecting "
                      << "the MDL score");
       }
       __3off2_kmode = CorrectedMutualInformation<>::KModeTypes::MDL;
     }

◆ useMIIC()

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

indicate that we wish to use MIIC

Definition at line 230 of file genericBNLearner_inl.h.

References __miic_3off2, __selected_algo, MIIC_THREE_OFF_TWO, and gum::learning::Miic::setMiicBehaviour().

                                           {
       __selected_algo = AlgoType::MIIC_THREE_OFF_TWO;
       __miic_3off2.setMiicBehaviour();
     }

Here is the call graph for this function:

◆ useNML()

INLINE void gum::learning::genericBNLearner::useNML ( )

indicate that we wish to use the NML correction for 3off2

Exceptions

OperationNotAllowed when 3off2 is not the selected algorithm

Definition at line 236 of file genericBNLearner_inl.h.

References __3off2_kmode, __selected_algo, GUM_ERROR, and MIIC_THREE_OFF_TWO.

                                          {
       if (__selected_algo != AlgoType::MIIC_THREE_OFF_TWO) {
         GUM_ERROR(OperationNotAllowed,
                   "You must use the 3off2 algorithm before selecting "
                      << "the NML score");
       }
       __3off2_kmode = CorrectedMutualInformation<>::KModeTypes::NML;
     }

◆ useNoApriori()

INLINE void gum::learning::genericBNLearner::useNoApriori ( )

use no apriori

Definition at line 461 of file genericBNLearner_inl.h.

References __apriori_type, checkScoreAprioriCompatibility(), and NO_APRIORI.

                                                {
       __apriori_type = AprioriType::NO_APRIORI;
       checkScoreAprioriCompatibility();
     }

Here is the call graph for this function:

◆ useNoCorr()

INLINE void gum::learning::genericBNLearner::useNoCorr ( )

indicate that we wish to use the NoCorr correction for 3off2

Exceptions

OperationNotAllowed when 3off2 is not the selected algorithm

Definition at line 256 of file genericBNLearner_inl.h.

References __3off2_kmode, __selected_algo, GUM_ERROR, and MIIC_THREE_OFF_TWO.

                                             {
       if (__selected_algo != AlgoType::MIIC_THREE_OFF_TWO) {
         GUM_ERROR(OperationNotAllowed,
                   "You must use the 3off2 algorithm before selecting "
                      << "the NoCorr score");
       }
       __3off2_kmode = CorrectedMutualInformation<>::KModeTypes::NoCorr;
     }

◆ useScoreAIC()

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

indicate that we wish to use an AIC score

Definition at line 183 of file genericBNLearner_inl.h.

References __score_type, AIC, and checkScoreAprioriCompatibility().

                                               {
       __score_type = ScoreType::AIC;
       checkScoreAprioriCompatibility();
     }

Here is the call graph for this function:

◆ useScoreBD()

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

indicate that we wish to use a BD score

Definition at line 189 of file genericBNLearner_inl.h.

References __score_type, BD, and checkScoreAprioriCompatibility().

                                              {
       __score_type = ScoreType::BD;
       checkScoreAprioriCompatibility();
     }

Here is the call graph for this function:

◆ useScoreBDeu()

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

indicate that we wish to use a BDeu score

Definition at line 195 of file genericBNLearner_inl.h.

References __score_type, BDeu, and checkScoreAprioriCompatibility().

                                                {
       __score_type = ScoreType::BDeu;
       checkScoreAprioriCompatibility();
     }

Here is the call graph for this function:

◆ useScoreBIC()

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

indicate that we wish to use a BIC score

Definition at line 201 of file genericBNLearner_inl.h.

References __score_type, BIC, and checkScoreAprioriCompatibility().

                                               {
       __score_type = ScoreType::BIC;
       checkScoreAprioriCompatibility();
     }

Here is the call graph for this function:

◆ useScoreK2()

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

indicate that we wish to use a K2 score

Definition at line 207 of file genericBNLearner_inl.h.

References __score_type, checkScoreAprioriCompatibility(), and K2.

                                              {
       __score_type = ScoreType::K2;
       checkScoreAprioriCompatibility();
     }

Here is the call graph for this function:

◆ useScoreLog2Likelihood()

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

indicate that we wish to use a Log2Likelihood score

Definition at line 213 of file genericBNLearner_inl.h.

References __score_type, checkScoreAprioriCompatibility(), and LOG2LIKELIHOOD.

                                                          {
       __score_type = ScoreType::LOG2LIKELIHOOD;
       checkScoreAprioriCompatibility();
     }

Here is the call graph for this function:

◆ verbosity()

bool gum::learning::genericBNLearner::verbosity ( ) const

inlinevirtual

verbosity

Implements gum::IApproximationSchemeConfiguration.

Definition at line 1092 of file genericBNLearner.h.

References __current_algorithm, GUM_ERROR, and gum::ApproximationScheme::verbosity().

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

Here is the call graph for this function:

Member Data Documentation

◆ __3off2_kmode

CorrectedMutualInformation ::KModeTypes gum::learning::genericBNLearner::__3off2_kmode

protected

Initial value:

{

CorrectedMutualInformation<>::KModeTypes::MDL}

the penalty used in 3off2

Definition at line 784 of file genericBNLearner.h.

Referenced by __createCorrectedMutualInformation(), operator=(), useMDL(), useNML(), and useNoCorr().

◆ __apriori

Apriori* gum::learning::genericBNLearner::__apriori {nullptr}

protected

the apriori used

Definition at line 749 of file genericBNLearner.h.

Referenced by __createApriori(), __createParamEstimator(), __createScore(), chi2(), G2(), logLikelihood(), operator=(), and ~genericBNLearner().

◆ __apriori_database

Database* gum::learning::genericBNLearner::__apriori_database {nullptr}

protected

the database used by the Dirichlet a priori

Definition at line 803 of file genericBNLearner.h.

Referenced by __createApriori(), __learnDAG(), operator=(), and ~genericBNLearner().

◆ __apriori_dbname

std::string gum::learning::genericBNLearner::__apriori_dbname

protected

the filename for the Dirichlet a priori, if any

Definition at line 806 of file genericBNLearner.h.

Referenced by __createApriori(), operator=(), and useAprioriDirichlet().

◆ __apriori_type

AprioriType gum::learning::genericBNLearner::__apriori_type {AprioriType::NO_APRIORI}

protected

the a priori selected for the score and parameters

Definition at line 746 of file genericBNLearner.h.

Referenced by __createApriori(), __getAprioriType(), __learnDAG(), operator=(), useAprioriBDeu(), useAprioriDirichlet(), useAprioriSmoothing(), and useNoApriori().

◆ __apriori_weight

double gum::learning::genericBNLearner::__apriori_weight {1.0f}

protected

the weight of the apriori

Definition at line 754 of file genericBNLearner.h.

Referenced by __createApriori(), __setAprioriWeight(), checkScoreAprioriCompatibility(), and operator=().

◆ __constraint_ForbiddenArcs

StructuralConstraintForbiddenArcs gum::learning::genericBNLearner::__constraint_ForbiddenArcs

protected

the constraint on forbidden arcs

Definition at line 766 of file genericBNLearner.h.

Referenced by __learnDAG(), __prepare_miic_3off2(), addForbiddenArc(), eraseForbiddenArc(), operator=(), and setForbiddenArcs().

◆ __constraint_Indegree

StructuralConstraintIndegree gum::learning::genericBNLearner::__constraint_Indegree

protected

the constraint for indegrees

Definition at line 760 of file genericBNLearner.h.

Referenced by __learnDAG(), operator=(), and setMaxIndegree().

◆ __constraint_MandatoryArcs

StructuralConstraintMandatoryArcs gum::learning::genericBNLearner::__constraint_MandatoryArcs

protected

the constraint on forbidden arcs

Definition at line 772 of file genericBNLearner.h.

Referenced by __learnDAG(), __prepare_miic_3off2(), addMandatoryArc(), eraseMandatoryArc(), operator=(), and setMandatoryArcs().

◆ __constraint_PossibleEdges

StructuralConstraintPossibleEdges gum::learning::genericBNLearner::__constraint_PossibleEdges

protected

the constraint on possible Edges

Definition at line 769 of file genericBNLearner.h.

Referenced by __learnDAG(), addPossibleEdge(), erasePossibleEdge(), and setPossibleEdges().

◆ __constraint_SliceOrder

StructuralConstraintSliceOrder gum::learning::genericBNLearner::__constraint_SliceOrder

protected

the constraint for 2TBNs

Definition at line 757 of file genericBNLearner.h.

Referenced by __learnDAG(), operator=(), and setSliceOrder().

◆ __constraint_TabuList

StructuralConstraintTabuList gum::learning::genericBNLearner::__constraint_TabuList

protected

the constraint for tabu lists

Definition at line 763 of file genericBNLearner.h.

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

◆ __current_algorithm

const ApproximationScheme* gum::learning::genericBNLearner::__current_algorithm {nullptr}

protected

Definition at line 812 of file genericBNLearner.h.

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

◆ __Dag2BN

DAG2BNLearner gum::learning::genericBNLearner::__Dag2BN

protected

the parametric EM

Definition at line 788 of file genericBNLearner.h.

◆ __EMepsilon

double gum::learning::genericBNLearner::__EMepsilon {0.0}

protected

epsilon for EM. if espilon=0.0 : no EM

Definition at line 740 of file genericBNLearner.h.

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

◆ __greedy_hill_climbing

GreedyHillClimbing gum::learning::genericBNLearner::__greedy_hill_climbing

protected

the greedy hill climbing algorithm

Definition at line 791 of file genericBNLearner.h.

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

◆ __initial_dag

DAG gum::learning::genericBNLearner::__initial_dag

protected

an initial DAG given to learners

Definition at line 809 of file genericBNLearner.h.

Referenced by __learnDAG(), operator=(), and setInitialDAG().

◆ __K2

K2 gum::learning::genericBNLearner::__K2

protected

the K2 algorithm

Definition at line 778 of file genericBNLearner.h.

Referenced by __learnDAG(), operator=(), and useK2().

◆ __local_search_with_tabu_list

LocalSearchWithTabuList gum::learning::genericBNLearner::__local_search_with_tabu_list

protected

the local search with tabu list algorithm

Definition at line 794 of file genericBNLearner.h.

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

◆ __miic_3off2

Miic gum::learning::genericBNLearner::__miic_3off2

protected

the 3off2 algorithm

Definition at line 781 of file genericBNLearner.h.

Referenced by __learnDAG(), __prepare_miic_3off2(), latentVariables(), learnMixedStructure(), operator=(), use3off2(), and useMIIC().

◆ __mutual_info

CorrectedMutualInformation* gum::learning::genericBNLearner::__mutual_info {nullptr}

protected

the selected correction for 3off2 and miic

Definition at line 743 of file genericBNLearner.h.

Referenced by __createCorrectedMutualInformation(), __learnDAG(), learnMixedStructure(), operator=(), and ~genericBNLearner().

◆ __no_apriori

AprioriNoApriori* gum::learning::genericBNLearner::__no_apriori {nullptr}

protected

Definition at line 751 of file genericBNLearner.h.

Referenced by __createCorrectedMutualInformation(), __createParamEstimator(), genericBNLearner(), useDatabaseRanges(), and ~genericBNLearner().

◆ __param_estimator_type

ParamEstimatorType gum::learning::genericBNLearner::__param_estimator_type {ParamEstimatorType::ML}

protected

the type of the parameter estimator

Definition at line 737 of file genericBNLearner.h.

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

◆ __ranges

std::vector< std::pair< std::size_t, std::size_t > > gum::learning::genericBNLearner::__ranges

protected

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

Definition at line 800 of file genericBNLearner.h.

Referenced by __createCorrectedMutualInformation(), __createParamEstimator(), __createScore(), clearDatabaseRanges(), databaseRanges(), operator=(), useCrossValidationFold(), and useDatabaseRanges().

◆ __score

Score* gum::learning::genericBNLearner::__score {nullptr}

protected

the score used

Definition at line 734 of file genericBNLearner.h.

Referenced by __createParamEstimator(), __createScore(), __learnDAG(), operator=(), and ~genericBNLearner().

◆ __score_database

Database gum::learning::genericBNLearner::__score_database

protected

the database to be used by the scores and parameter estimators

Definition at line 797 of file genericBNLearner.h.

Referenced by __createApriori(), __createCorrectedMutualInformation(), __createParamEstimator(), __createScore(), __learnDAG(), __prepare_miic_3off2(), chi2(), database(), databaseWeight(), domainSizes(), G2(), genericBNLearner(), hasMissingValues(), idFromName(), learnMixedStructure(), logLikelihood(), nameFromId(), names(), nbCols(), nbRows(), operator=(), recordWeight(), setDatabaseWeight(), setRecordWeight(), useCrossValidationFold(), and useDatabaseRanges().

◆ __score_type

ScoreType gum::learning::genericBNLearner::__score_type {ScoreType::BDeu}

protected

the score selected for learning

Definition at line 731 of file genericBNLearner.h.

Referenced by __createScore(), checkScoreAprioriCompatibility(), operator=(), useScoreAIC(), useScoreBD(), useScoreBDeu(), useScoreBIC(), useScoreK2(), and useScoreLog2Likelihood().

◆ __selected_algo

AlgoType gum::learning::genericBNLearner::__selected_algo {AlgoType::GREEDY_HILL_CLIMBING}

protected

the selected learning algorithm

Definition at line 775 of file genericBNLearner.h.

Referenced by __learnDAG(), latentVariables(), learnMixedStructure(), operator=(), use3off2(), useGreedyHillClimbing(), useK2(), useLocalSearchWithTabuList(), useMDL(), useMIIC(), useNML(), and useNoCorr().

◆ onProgress

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

inherited

Progression, error and time.

Definition at line 59 of file IApproximationSchemeConfiguration.h.

Referenced by gum::learning::Miic::_initiation(), gum::learning::Miic::_iteration(), gum::learning::Miic::_orientation_3off2(), gum::learning::Miic::_orientation_latents(), gum::learning::Miic::_orientation_miic(), gum::ApproximationScheme::continueApproximationScheme(), and distributeProgress().

◆ onStop

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

inherited

Criteria messageApproximationScheme.

Definition at line 62 of file IApproximationSchemeConfiguration.h.

Referenced by gum::ApproximationScheme::_stopScheme(), and distributeStop().

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

agrum/learning/BNLearnUtils/genericBNLearner.h
agrum/learning/BNLearnUtils/genericBNLearner.cpp
agrum/learning/BNLearnUtils/genericBNLearner_inl.h
agrum/learning/BNLearnUtils/genericBNLearner_tpl.h

Public Attributes

Public Member Functions

Public Types

Protected Attributes

Protected Member Functions

Static Protected Member Functions

Classes

Detailed Description

Member Enumeration Documentation

◆ AlgoType

◆ ApproximationSchemeSTATE

◆ AprioriType

◆ ParamEstimatorType

◆ ScoreType

Constructor & Destructor Documentation

◆ genericBNLearner() [1/5]

◆ genericBNLearner() [2/5]

◆ genericBNLearner() [3/5]

◆ genericBNLearner() [4/5]

◆ genericBNLearner() [5/5]

◆ ~genericBNLearner()

Member Function Documentation

◆ __checkFileName()

◆ __createApriori()

◆ __createCorrectedMutualInformation()

◆ __createParamEstimator()

◆ __createScore()

◆ __getAprioriType()

◆ __learnDAG()

◆ __prepare_miic_3off2()

◆ __readFile()

◆ __setAprioriWeight()

◆ addForbiddenArc() [1/3]

◆ addForbiddenArc() [2/3]

◆ addForbiddenArc() [3/3]

◆ addMandatoryArc() [1/3]

◆ addMandatoryArc() [2/3]

◆ addMandatoryArc() [3/3]

◆ addPossibleEdge() [1/3]

◆ addPossibleEdge() [2/3]

◆ addPossibleEdge() [3/3]

◆ checkScoreAprioriCompatibility()

◆ chi2() [1/2]

◆ chi2() [2/2]

◆ clearDatabaseRanges()

◆ currentTime()

◆ database()

◆ databaseRanges()

◆ databaseWeight()

◆ disableEpsilon()

◆ disableMaxIter()

◆ disableMaxTime()

◆ disableMinEpsilonRate()

◆ distributeProgress()

◆ distributeStop()

◆ domainSizes()

◆ enableEpsilon()

◆ enableMaxIter()

◆ enableMaxTime()

◆ enableMinEpsilonRate()

◆ epsilon()

◆ eraseForbiddenArc() [1/3]

◆ eraseForbiddenArc() [2/3]

◆ eraseForbiddenArc() [3/3]

◆ eraseMandatoryArc() [1/3]

◆ eraseMandatoryArc() [2/3]

◆ eraseMandatoryArc() [3/3]

◆ erasePossibleEdge() [1/3]

◆ erasePossibleEdge() [2/3]

◆ erasePossibleEdge() [3/3]

◆ G2() [1/2]

◆ G2() [2/2]

◆ hasMissingValues()

◆ history()

◆ idFromName()

◆ isEnabledEpsilon()

◆ isEnabledMaxIter()

◆ isEnabledMaxTime()

◆ isEnabledMinEpsilonRate()

◆ latentVariables()