gum::credal::CNLoopyPropagation< GUM_SCALAR > Class Template Reference

<agrum/CN/CNLoopyPropagation.h> More...

#include <CNLoopyPropagation.h>

Inheritance diagram for gum::credal::CNLoopyPropagation< GUM_SCALAR >:

Collaboration diagram for gum::credal::CNLoopyPropagation< GUM_SCALAR >:

Public Types
enum class	InferenceType : char { nodeToNeighbours , ordered , randomOrder }
	Inference type to be used by the algorithm. More...
using	msg = std::vector< Tensor< GUM_SCALAR >* >
using	cArcP = const class gum::Arc*
enum class	ApproximationSchemeSTATE : char {   Undefined , Continue , Epsilon , Rate ,   Limit , TimeLimit , Stopped }
	The different state of an approximation scheme. More...

Public Member Functions
virtual void	addEvidence (NodeId id, const Idx val) final
	adds a new hard evidence on node id
virtual void	addEvidence (std::string_view nodeName, const Idx val) final
	adds a new hard evidence on node named nodeName
virtual void	addEvidence (NodeId id, std::string_view label) final
	adds a new hard evidence on node id
virtual void	addEvidence (std::string_view nodeName, std::string_view label) final
	adds a new hard evidence on node named nodeName
virtual void	addEvidence (NodeId id, const std::vector< GUM_SCALAR > &vals) final
	adds a new evidence on node id (might be soft or hard)
virtual void	addEvidence (std::string_view nodeName, const std::vector< GUM_SCALAR > &vals) final
	adds a new evidence on node named nodeName (might be soft or hard)
virtual void	addEvidence (const Tensor< GUM_SCALAR > &pot) final
	adds a new evidence on node id (might be soft or hard)
Public algorithm methods
void	makeInference () override
	Starts the inference.
void	insertEvidenceFile (std::string_view path) override
	Starts the inference.
Getters and setters
void	inferenceType (InferenceType inft)
	Set the inference type.
InferenceType	inferenceType ()
	Get the inference type.
Post-inference methods
void	eraseAllEvidence () override
	Erase all inference related data to perform another one.
void	saveInference (std::string_view path)
Constructors / Destructors
	CNLoopyPropagation (const CredalNet< GUM_SCALAR > &credalNet)
	Constructor.
	~CNLoopyPropagation () override
	Destructor.
Getters and setters
VarMod2BNsMap< GUM_SCALAR > *	getVarMod2BNsMap ()
	Get optimum IBayesNet.
const CredalNet< GUM_SCALAR > &	credalNet () const
	Get this credal network.
const NodeProperty< std::vector< NodeId > > &	getT0Cluster () const
	Get the t0_ cluster.
const NodeProperty< std::vector< NodeId > > &	getT1Cluster () const
	Get the t1_ cluster.
void	setRepetitiveInd (const bool repetitive)
void	storeVertices (const bool value)
bool	storeVertices () const
	Get the number of iterations without changes used to stop some algorithms.
void	storeBNOpt (const bool value)
bool	storeBNOpt () const
bool	repetitiveInd () const
	Get the current independence status.
Pre-inference initialization methods
void	insertModalsFile (std::string_view path)
	Insert variables modalities from file to compute expectations.
void	insertModals (const std::map< std::string, std::vector< GUM_SCALAR > > &modals)
	Insert variables modalities from map to compute expectations.
void	insertEvidence (const std::map< std::string, std::vector< GUM_SCALAR > > &eviMap)
	Insert evidence from map.
void	insertEvidence (const NodeProperty< std::vector< GUM_SCALAR > > &evidence)
	Insert evidence from Property.
void	insertQueryFile (std::string_view path)
	Insert query variables states from file.
void	insertQuery (const NodeProperty< std::vector< bool > > &queryquery)
	Insert query variables and states from Property.
Post-inference methods
Tensor< GUM_SCALAR >	marginalMin (const NodeId id) const
	Get the lower marginals of a given node id.
Tensor< GUM_SCALAR >	marginalMin (std::string_view varName) const
	Get the lower marginals of a given variable name.
Tensor< GUM_SCALAR >	marginalMax (const NodeId id) const
	Get the upper marginals of a given node id.
Tensor< GUM_SCALAR >	marginalMax (std::string_view varName) const
	Get the upper marginals of a given variable name.
const GUM_SCALAR &	expectationMin (const NodeId id) const
	Get the lower expectation of a given node id.
const GUM_SCALAR &	expectationMin (std::string_view varName) const
	Get the lower expectation of a given variable name.
const GUM_SCALAR &	expectationMax (const NodeId id) const
	Get the upper expectation of a given node id.
const GUM_SCALAR &	expectationMax (std::string_view varName) const
	Get the upper expectation of a given variable name.
const std::vector< GUM_SCALAR > &	dynamicExpMin (std::string_view varName) const
	Get the lower dynamic expectation of a given variable prefix (without the time step included, i.e.
const std::vector< GUM_SCALAR > &	dynamicExpMax (std::string_view varName) const
	Get the upper dynamic expectation of a given variable prefix (without the time step included, i.e.
const std::vector< std::vector< GUM_SCALAR > > &	vertices (const NodeId id) const
	Get the vertice of a given node id.
void	saveMarginals (std::string_view path) const
	Saves marginals to file.
void	saveExpectations (std::string_view path) const
	Saves expectations to file.
void	saveVertices (std::string_view path) const
	Saves vertices to file.
void	dynamicExpectations ()
	Compute dynamic expectations.
std::string	toString () const
	Print all nodes marginals to standart output.
const std::string	getApproximationSchemeMsg ()
	Get approximation scheme state.
Getters and setters
void	setEpsilon (double eps) override
	Given that we approximate f(t), stopping criterion on |f(t+1)-f(t)|.
double	epsilon () const override
	Returns the value of epsilon.
void	disableEpsilon () override
	Disable stopping criterion on epsilon.
void	enableEpsilon () override
	Enable stopping criterion on epsilon.
bool	isEnabledEpsilon () const override
	Returns true if stopping criterion on epsilon is enabled, false otherwise.
void	setMinEpsilonRate (double rate) override
	Given that we approximate f(t), stopping criterion on d/dt(|f(t+1)-f(t)|).
double	minEpsilonRate () const override
	Returns the value of the minimal epsilon rate.
void	disableMinEpsilonRate () override
	Disable stopping criterion on epsilon rate.
void	enableMinEpsilonRate () override
	Enable stopping criterion on epsilon rate.
bool	isEnabledMinEpsilonRate () const override
	Returns true if stopping criterion on epsilon rate is enabled, false otherwise.
void	setMaxIter (Size max) override
	Stopping criterion on number of iterations.
Size	maxIter () const override
	Returns the criterion on number of iterations.
void	disableMaxIter () override
	Disable stopping criterion on max iterations.
void	enableMaxIter () override
	Enable stopping criterion on max iterations.
bool	isEnabledMaxIter () const override
	Returns true if stopping criterion on max iterations is enabled, false otherwise.
void	setMaxTime (double timeout) override
	Stopping criterion on timeout.
double	maxTime () const override
	Returns the timeout (in seconds).
double	currentTime () const override
	Returns the current running time in second.
void	disableMaxTime () override
	Disable stopping criterion on timeout.
void	enableMaxTime () override
	Enable stopping criterion on timeout.
bool	isEnabledMaxTime () const override
	Returns true if stopping criterion on timeout is enabled, false otherwise.
void	setPeriodSize (Size p) override
	How many samples between two stopping is enable.
Size	periodSize () const override
	Returns the period size.
void	setVerbosity (bool v) override
	Set the verbosity on (true) or off (false).
bool	verbosity () const override
	Returns true if verbosity is enabled.
ApproximationSchemeSTATE	stateApproximationScheme () const override
	Returns the approximation scheme state.
Size	nbrIterations () const override
	Returns the number of iterations.
const std::vector< double > &	history () const override
	Returns the scheme history.
void	initApproximationScheme ()
	Initialise the scheme.
bool	startOfPeriod () const
	Returns true if we are at the beginning of a period (compute error is mandatory).
void	updateApproximationScheme (unsigned int incr=1)
	Update the scheme w.r.t the new error and increment steps.
Size	remainingBurnIn () const
	Returns the remaining burn in.
void	stopApproximationScheme ()
	Stop the approximation scheme.
bool	continueApproximationScheme (double error)
	Update the scheme w.r.t the new error.
Getters and setters
std::string	messageApproximationScheme () const
	Returns the approximation scheme message.
Accessors/Modifiers
void	setNumberOfThreads (Size nb) override
	sets the number max of threads to be used by the class containing this ThreadNumberManager
Size	getNumberOfThreads () const override
	returns the current max number of threads used by the class containing this ThreadNumberManager
bool	isGumNumberOfThreadsOverriden () const override
	indicates whether the class containing this ThreadNumberManager set its own number of threads

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

Protected Member Functions
Protected initialization methods
void	initialize_ ()
	Topological forward propagation to initialize old marginals & messages.
Protected algorithm methods
void	makeInferenceNodeToNeighbours_ ()
	Starts the inference with this inference type.
void	makeInferenceByOrderedArcs_ ()
	Starts the inference with this inference type.
void	makeInferenceByRandomOrder_ ()
	Starts the inference with this inference type.
void	updateMarginals_ ()
	Compute marginals from up-to-date messages.
void	msgL_ (const NodeId X, const NodeId demanding_parent)
	Sends a message to one's parent, i.e.
void	compute_ext_ (GUM_SCALAR &msg_l_min, GUM_SCALAR &msg_l_max, std::vector< GUM_SCALAR > &lx, GUM_SCALAR &num_min, GUM_SCALAR &num_max, GUM_SCALAR &den_min, GUM_SCALAR &den_max)
	Used by msgL_.
void	compute_ext_ (std::vector< std::vector< GUM_SCALAR > > &combi_msg_p, const NodeId &id, GUM_SCALAR &msg_l_min, GUM_SCALAR &msg_l_max, std::vector< GUM_SCALAR > &lx, const Idx &pos)
	Used by msgL_.
void	enum_combi_ (std::vector< std::vector< std::vector< GUM_SCALAR > > > &msgs_p, const NodeId &id, GUM_SCALAR &msg_l_min, GUM_SCALAR &msg_l_max, std::vector< GUM_SCALAR > &lx, const Idx &pos)
	Used by msgL_.
void	msgP_ (const NodeId X, const NodeId demanding_child)
	Sends a message to one's child, i.e.
void	enum_combi_ (std::vector< std::vector< std::vector< GUM_SCALAR > > > &msgs_p, const NodeId &id, GUM_SCALAR &msg_p_min, GUM_SCALAR &msg_p_max)
	Used by msgP_.
void	compute_ext_ (std::vector< std::vector< GUM_SCALAR > > &combi_msg_p, const NodeId &id, GUM_SCALAR &msg_p_min, GUM_SCALAR &msg_p_max)
	Used by msgP_.
void	refreshLMsPIs_ (bool refreshIndic=false)
	Get the last messages from one's parents and children.
GUM_SCALAR	calculateEpsilon_ ()
	Compute epsilon.
Post-inference protected methods
void	computeExpectations_ ()
	Since the network is binary, expectations can be computed from the final marginals which give us the credal set vertices.
void	updateIndicatrices_ ()
	Only update indicatrices variables at the end of computations ( calls msgP_ ).
Protected initialization methods
void	repetitiveInit_ ()
	Initialize t0_ and t1_ clusters.
void	initExpectations_ ()
	Initialize lower and upper expectations before inference, with the lower expectation being initialized on the highest modality and the upper expectation being initialized on the lowest modality.
void	initMarginals_ ()
	Initialize lower and upper old marginals and marginals before inference, with the lower marginal being 1 and the upper 0.
void	dispatchMarginalsToThreads_ ()
	computes Vector threadRanges_, that assigns some part of marginalMin_ and marginalMax_ to the threads
void	initMarginalSets_ ()
	Initialize credal set vertices with empty sets.
Protected algorithms methods
virtual const GUM_SCALAR	computeEpsilon_ ()
	Compute approximation scheme epsilon using the old marginals and the new ones.
void	updateExpectations_ (const NodeId &id, const std::vector< GUM_SCALAR > &vertex)
	Given a node id and one of it's possible vertex obtained during inference, update this node lower and upper expectations.
void	updateCredalSets_ (const NodeId &id, const std::vector< GUM_SCALAR > &vertex, const bool &elimRedund=false)
	Given a node id and one of it's possible vertex, update it's credal set.
Proptected post-inference methods
void	dynamicExpectations_ ()
	Rearrange lower and upper expectations to suit dynamic networks.

Protected Attributes
NodeProperty< bool >	update_p_
	Used to keep track of which node needs to update it's information coming from it's parents.
NodeProperty< bool >	update_l_
	Used to keep track of which node needs to update it's information coming from it's children.
NodeSet	active_nodes_set_
	The current node-set to iterate through at this current step.
NodeSet	next_active_nodes_set_
	The next node-set, i.e.
NodeProperty< NodeSet * >	msg_l_sent_
	Used to keep track of one's messages sent to it's parents.
ArcProperty< GUM_SCALAR >	ArcsL_min_
	"Lower" information \( \Lambda \) coming from one's children.
ArcProperty< GUM_SCALAR >	ArcsP_min_
	"Lower" information \( \pi \) coming from one's parent.
NodeProperty< GUM_SCALAR >	NodesL_min_
	"Lower" node information \( \Lambda \) obtained by combinaison of children messages.
NodeProperty< GUM_SCALAR >	NodesP_min_
	"Lower" node information \( \pi \) obtained by combinaison of parent's messages.
ArcProperty< GUM_SCALAR >	ArcsL_max_
	"Upper" information \( \Lambda \) coming from one's children.
ArcProperty< GUM_SCALAR >	ArcsP_max_
	"Upper" information \( \pi \) coming from one's parent.
NodeProperty< GUM_SCALAR >	NodesL_max_
	"Upper" node information \( \Lambda \) obtained by combinaison of children messages.
NodeProperty< GUM_SCALAR >	NodesP_max_
	"Upper" node information \( \pi \) obtained by combinaison of parent's messages.
bool	inference_up_to_date_
	TRUE if inference has already been performed, FALSE otherwise.
const CredalNet< GUM_SCALAR > *	credalNet_
	A pointer to the Credal Net used.
margi	oldMarginalMin_
	Old lower marginals used to compute epsilon.
margi	oldMarginalMax_
	Old upper marginals used to compute epsilon.
margi	marginalMin_
	Lower marginals.
margi	marginalMax_
	Upper marginals.
credalSet	marginalSets_
	Credal sets vertices, if enabled.
expe	expectationMin_
	Lower expectations, if some variables modalities were inserted.
expe	expectationMax_
	Upper expectations, if some variables modalities were inserted.
dynExpe	dynamicExpMin_
	Lower dynamic expectations.
dynExpe	dynamicExpMax_
	Upper dynamic expectations.
dynExpe	modal_
	Variables modalities used to compute expectations.
margi	evidence_
	Holds observed variables states.
query	query_
	Holds the query nodes states.
cluster	t0_
	Clusters of nodes used with dynamic networks.
cluster	t1_
	Clusters of nodes used with dynamic networks.
bool	storeVertices_
	True if credal sets vertices are stored, False otherwise.
bool	repetitiveInd_
	True if using repetitive independence ( dynamic network only ), False otherwise.
bool	storeBNOpt_
	Iterations limit stopping rule used by some algorithms such as CNMonteCarloSampling.
VarMod2BNsMap< GUM_SCALAR >	dbnOpt_
	Object used to efficiently store optimal bayes net during inference, for some algorithms.
std::vector< std::pair< NodeId, Idx > >	threadRanges_
	the ranges of elements of marginalMin_ and marginalMax_ processed by each thread
int	timeSteps_
	The number of time steps of this network (only useful for dynamic networks).
Size	threadMinimalNbOps_ {Size(20)}
double	current_epsilon_
	Current epsilon.
double	last_epsilon_
	Last epsilon value.
double	current_rate_
	Current rate.
Size	current_step_
	The current step.
Timer	timer_
	The timer.
ApproximationSchemeSTATE	current_state_
	The current state.
std::vector< double >	history_
	The scheme history, used only if verbosity == true.
double	eps_
	Threshold for convergence.
bool	enabled_eps_
	If true, the threshold convergence is enabled.
double	min_rate_eps_
	Threshold for the epsilon rate.
bool	enabled_min_rate_eps_
	If true, the minimal threshold for epsilon rate is enabled.
double	max_time_
	The timeout.
bool	enabled_max_time_
	If true, the timeout is enabled.
Size	max_iter_
	The maximum iterations.
bool	enabled_max_iter_
	If true, the maximum iterations stopping criterion is enabled.
Size	burn_in_
	Number of iterations before checking stopping criteria.
Size	period_size_
	Checking criteria frequency.
bool	verbosity_
	If true, verbosity is enabled.

Private Types
using	_infE_ = InferenceEngine< GUM_SCALAR >
	To easily access InferenceEngine< GUM_SCALAR > methods.
using	credalSet = NodeProperty< std::vector< std::vector< GUM_SCALAR > > >
using	margi = NodeProperty< std::vector< GUM_SCALAR > >
using	expe = NodeProperty< GUM_SCALAR >
using	dynExpe = typename gum::HashTable< std::string, std::vector< GUM_SCALAR > >
using	query = NodeProperty< std::vector< bool > >
using	cluster = NodeProperty< std::vector< NodeId > >

Private Member Functions
void	stopScheme_ (ApproximationSchemeSTATE new_state)
	Stop the scheme given a new state.

Private Attributes
InferenceType	_inferenceType_
	The chosen inference type.
const CredalNet< GUM_SCALAR > *	_cn_
	A pointer to the CredalNet to be used.
const IBayesNet< GUM_SCALAR > *	_bnet_
	A pointer to it's IBayesNet used as a DAG.
Size	_nb_threads_ {0}
	the max number of threads used by the class

Detailed Description

template<GUM_Numeric GUM_SCALAR>
class gum::credal::CNLoopyPropagation< GUM_SCALAR >

<agrum/CN/CNLoopyPropagation.h>

Class implementing loopy-propagation with binary networks - L2U algorithm.

Template Parameters

GUM_SCALAR

A floating type ( float, double, long double ... ).

Author

Matthieu HOURBRACQ and Pierre-Henri WUILLEMIN(_at_LIP6)

Definition at line 75 of file CNLoopyPropagation.h.

Member Typedef Documentation

_infE_

template<GUM_Numeric GUM_SCALAR>

using gum::credal::CNLoopyPropagation< GUM_SCALAR >::_infE_ = InferenceEngine< GUM_SCALAR >

private

To easily access InferenceEngine< GUM_SCALAR > methods.

Definition at line 384 of file CNLoopyPropagation.h.

cArcP

template<GUM_Numeric GUM_SCALAR>

using gum::credal::CNLoopyPropagation< GUM_SCALAR >::cArcP = const class gum::Arc*

Definition at line 78 of file CNLoopyPropagation.h.

cluster

template<GUM_Numeric GUM_SCALAR>

using gum::credal::InferenceEngine< GUM_SCALAR >::cluster = NodeProperty< std::vector< NodeId > >

privateinherited

Definition at line 82 of file inferenceEngine.h.

credalSet

template<GUM_Numeric GUM_SCALAR>

using gum::credal::InferenceEngine< GUM_SCALAR >::credalSet = NodeProperty< std::vector< std::vector< GUM_SCALAR > > >

privateinherited

Definition at line 75 of file inferenceEngine.h.

dynExpe

template<GUM_Numeric GUM_SCALAR>

using gum::credal::InferenceEngine< GUM_SCALAR >::dynExpe = typename gum::HashTable< std::string, std::vector< GUM_SCALAR > >

privateinherited

Definition at line 79 of file inferenceEngine.h.

expe

template<GUM_Numeric GUM_SCALAR>

using gum::credal::InferenceEngine< GUM_SCALAR >::expe = NodeProperty< GUM_SCALAR >

privateinherited

Definition at line 77 of file inferenceEngine.h.

margi

template<GUM_Numeric GUM_SCALAR>

using gum::credal::InferenceEngine< GUM_SCALAR >::margi = NodeProperty< std::vector< GUM_SCALAR > >

privateinherited

Definition at line 76 of file inferenceEngine.h.

msg

template<GUM_Numeric GUM_SCALAR>

using gum::credal::CNLoopyPropagation< GUM_SCALAR >::msg = std::vector< Tensor< GUM_SCALAR >* >

Definition at line 77 of file CNLoopyPropagation.h.

query

template<GUM_Numeric GUM_SCALAR>

using gum::credal::InferenceEngine< GUM_SCALAR >::query = NodeProperty< std::vector< bool > >

privateinherited

Definition at line 81 of file inferenceEngine.h.

Member Enumeration Documentation

ApproximationSchemeSTATE

enum class gum::IApproximationSchemeConfiguration::ApproximationSchemeSTATE : char

stronginherited

The different state of an approximation scheme.

Enumerator
Undefined
Continue
Epsilon
Rate
Limit
TimeLimit
Stopped

Definition at line 87 of file IApproximationSchemeConfiguration.h.

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

InferenceType

template<GUM_Numeric GUM_SCALAR>

enum class gum::credal::CNLoopyPropagation::InferenceType : char

strong

Inference type to be used by the algorithm.

Enumerator
nodeToNeighbours	Uses a node-set so we don't iterate on nodes that can't send a new message. Should be the fastest inference type. A step is going through the node-set.
ordered	Chooses an arc ordering and sends messages accordingly at all steps. Avoid it since it can give slightly worse results than other inference types. A step is going through all arcs.
randomOrder	Chooses a random arc ordering and sends messages accordingly. A new order is set at each step. A step is going through all arcs.

Definition at line 83 of file CNLoopyPropagation.h.

                               : char {
        nodeToNeighbours, 
 
        ordered,          
 
        randomOrder       
      };

Constructor & Destructor Documentation

CNLoopyPropagation()

template<GUM_Numeric GUM_SCALAR>

gum::credal::CNLoopyPropagation< GUM_SCALAR >::CNLoopyPropagation ( const CredalNet< GUM_SCALAR > & credalNet )

explicit

Constructor.

Parameters

cnet	The CredalNet to be used with this algorithm.

Definition at line 1480 of file CNLoopyPropagation_tpl.h.

                                                                                               :
      InferenceEngine< GUM_SCALAR >::InferenceEngine(credalNet) {
    if (!credalNet.isSeparatelySpecified()) {
      GUM_ERROR(OperationNotAllowed,
                "CNLoopyPropagation is only available "
                "with separately specified nets");
    }
 
    // test for binary cn
    for (auto node: credalNet.current_bn().nodes())
      if (credalNet.current_bn().variable(node).domainSize() != 2) {
        GUM_ERROR(OperationNotAllowed,
                  "CNLoopyPropagation is only available "
                  "with binary credal networks")
      }
 
    // test if compute CPTMinMax has been called
    if (!credalNet.hasComputedBinaryCPTMinMax()) {
      GUM_ERROR(OperationNotAllowed,
                "CNLoopyPropagation only works when "
                "\"computeBinaryCPTMinMax()\" has been called for "
                "this credal net")
    }
 
    _cn_   = &credalNet;
    _bnet_ = &credalNet.current_bn();
 
    _inferenceType_       = InferenceType::nodeToNeighbours;
    inference_up_to_date_ = false;
 
    GUM_CONSTRUCTOR(CNLoopyPropagation)
  }

References CNLoopyPropagation(), gum::credal::InferenceEngine< GUM_SCALAR >::InferenceEngine(), _bnet_, _cn_, _inferenceType_, gum::credal::InferenceEngine< GUM_SCALAR >::credalNet(), gum::credal::CredalNet< GUM_SCALAR >::current_bn(), gum::credal::CredalNet< GUM_SCALAR >::hasComputedBinaryCPTMinMax(), inference_up_to_date_, gum::credal::CredalNet< GUM_SCALAR >::isSeparatelySpecified(), and nodeToNeighbours.

Referenced by CNLoopyPropagation(), and ~CNLoopyPropagation().

Here is the call graph for this function:

Here is the caller graph for this function:

~CNLoopyPropagation()

template<GUM_Numeric GUM_SCALAR>

gum::credal::CNLoopyPropagation< GUM_SCALAR >::~CNLoopyPropagation ( )

override

Destructor.

Definition at line 1514 of file CNLoopyPropagation_tpl.h.

                                                        {
    inference_up_to_date_ = false;
 
    for (auto& [node, pset]: msg_l_sent_) {
      delete pset;
    }
 
    GUM_DESTRUCTOR(CNLoopyPropagation)
  }

References CNLoopyPropagation(), inference_up_to_date_, and msg_l_sent_.

Here is the call graph for this function:

Member Function Documentation

addEvidence() [1/7]

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::addEvidence ( const Tensor< GUM_SCALAR > & pot )

finalvirtualinherited

adds a new evidence on node id (might be soft or hard)

Exceptions

UndefinedElement	if the tensor is defined over several nodes
UndefinedElement	if the node on which the tensor is defined does not belong to the Bayesian network
InvalidArgument	if the node of the tensor already has an evidence
FatalError	if pot=[0,0,...,0]

Definition at line 1197 of file inferenceEngine_tpl.h.

                                                                                   {
      const auto id = this->credalNet_->current_bn().idFromName(pot.variable(0).name());
      std::vector< GUM_SCALAR > vals(this->credalNet_->current_bn().variable(id).domainSize(), 0);
      Instantiation             I(pot);
      for (I.setFirst(); !I.end(); I.inc()) {
        vals[I.val(0)] = pot[I];
      }
      addEvidence(id, vals);
    }

References addEvidence(), credalNet_, gum::Instantiation::end(), gum::Instantiation::inc(), gum::Instantiation::setFirst(), and gum::Instantiation::val().

Here is the call graph for this function:

addEvidence() [2/7]

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::addEvidence ( NodeId id, const Idx val )

finalvirtualinherited

adds a new hard evidence on node id

Exceptions

UndefinedElement	if id does not belong to the Bayesian network
InvalidArgument	if val is not a value for id
InvalidArgument	if id already has an evidence

Definition at line 1164 of file inferenceEngine_tpl.h.

                                                                            {
      std::vector< GUM_SCALAR > vals(this->credalNet_->current_bn().variable(id).domainSize(), 0);
      vals[val] = 1;
      addEvidence(id, vals);
    }

References addEvidence(), and credalNet_.

Referenced by addEvidence(), addEvidence(), addEvidence(), addEvidence(), addEvidence(), addEvidence(), and makeInference().

Here is the call graph for this function:

Here is the caller graph for this function:

addEvidence() [3/7]

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::addEvidence ( NodeId id, const std::vector< GUM_SCALAR > & vals )

finalvirtualinherited

adds a new evidence on node id (might be soft or hard)

Exceptions

UndefinedElement	if id does not belong to the Bayesian network
InvalidArgument	if id already has an evidence
FatalError	if vals=[0,0,...,0]
InvalidArgument	if the size of vals is different from the domain size of node id

Definition at line 1154 of file inferenceEngine_tpl.h.

                                                                                         {
      evidence_.insert(id, vals);
      // forces the computation of the begin iterator to avoid subsequent data races
      // @TODO make HashTableConstIterator constructors thread safe
      evidence_.begin();
    }

References evidence_.

addEvidence() [4/7]

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::addEvidence ( NodeId id, std::string_view label )

finalvirtualinherited

adds a new hard evidence on node id

Exceptions

UndefinedElement	if id does not belong to the Bayesian network
InvalidArgument	if val is not a value for id
InvalidArgument	if id already has an evidence

Definition at line 1178 of file inferenceEngine_tpl.h.

                                                                                   {
      addEvidence(id, this->credalNet_->current_bn().variable(id)[label]);
    }

References addEvidence(), and credalNet_.

Here is the call graph for this function:

addEvidence() [5/7]

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::addEvidence ( std::string_view nodeName, const Idx val )

finalvirtualinherited

adds a new hard evidence on node named nodeName

Exceptions

UndefinedElement	if nodeName does not belong to the Bayesian network
InvalidArgument	if val is not a value for id
InvalidArgument	if nodeName already has an evidence

Definition at line 1172 of file inferenceEngine_tpl.h.

                                                                                          {
      addEvidence(this->credalNet_->current_bn().idFromName(nodeName), val);
    }

References addEvidence(), and credalNet_.

Here is the call graph for this function:

addEvidence() [6/7]

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::addEvidence ( std::string_view nodeName, const std::vector< GUM_SCALAR > & vals )

finalvirtualinherited

adds a new evidence on node named nodeName (might be soft or hard)

Exceptions

UndefinedElement	if id does not belong to the Bayesian network
InvalidArgument	if nodeName already has an evidence
FatalError	if vals=[0,0,...,0]
InvalidArgument	if the size of vals is different from the domain size of node nodeName

Definition at line 1191 of file inferenceEngine_tpl.h.

                                                                                         {
      addEvidence(this->credalNet_->current_bn().idFromName(nodeName), vals);
    }

References addEvidence(), and credalNet_.

Here is the call graph for this function:

addEvidence() [7/7]

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::addEvidence ( std::string_view nodeName, std::string_view label )

finalvirtualinherited

adds a new hard evidence on node named nodeName

Exceptions

UndefinedElement	if nodeName does not belong to the Bayesian network
InvalidArgument	if val is not a value for id
InvalidArgument	if nodeName already has an evidence

Definition at line 1184 of file inferenceEngine_tpl.h.

                                                                          {
      const NodeId id = this->credalNet_->current_bn().idFromName(nodeName);
      addEvidence(id, this->credalNet_->current_bn().variable(id)[label]);
    }

References addEvidence(), and credalNet_.

Here is the call graph for this function:

calculateEpsilon_()

template<GUM_Numeric GUM_SCALAR>

GUM_SCALAR gum::credal::CNLoopyPropagation< GUM_SCALAR >::calculateEpsilon_ ( )

protected

Compute epsilon.

Returns

Epsilon.

Definition at line 1434 of file CNLoopyPropagation_tpl.h.

                                                                 {
    refreshLMsPIs_();
    updateMarginals_();
 
    return _infE_::computeEpsilon_();
  }

References gum::credal::InferenceEngine< GUM_SCALAR >::computeEpsilon_(), refreshLMsPIs_(), and updateMarginals_().

Referenced by makeInferenceByOrderedArcs_(), makeInferenceByRandomOrder_(), and makeInferenceNodeToNeighbours_().

Here is the call graph for this function:

Here is the caller graph for this function:

compute_ext_() [1/3]

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CNLoopyPropagation< GUM_SCALAR >::compute_ext_ ( GUM_SCALAR & msg_l_min, GUM_SCALAR & msg_l_max, std::vector< GUM_SCALAR > & lx, GUM_SCALAR & num_min, GUM_SCALAR & num_max, GUM_SCALAR & den_min, GUM_SCALAR & den_max )

protected

Used by msgL_.

pour les fonctions suivantes, les GUM_SCALAR min/max doivent etre initialises (min a 1 et max a 0) pour comparer avec les resultats intermediaires

Compute the final message for the given parent's message and likelihood (children's messages), numerators & denominators.

Parameters

msg_l_min	The reference to the current lower value of the message to be sent.
msg_l_max	The reference to the current upper value of the message to be sent.
lx	The lower and upper likelihood.
num_min	The reference to the previously computed lower numerator.
num_max	The reference to the previously computed upper numerator.
den_min	The reference to the previously computed lower denominator.
den_max	The reference to the previously computed upper denominator.

une fois les cpts marginalises sur X et Ui, on calcul le min/max,

Definition at line 196 of file CNLoopyPropagation_tpl.h.

                                                                                          {
    GUM_SCALAR num_min_tmp = 1.;
    GUM_SCALAR den_min_tmp = 1.;
    GUM_SCALAR num_max_tmp = 1.;
    GUM_SCALAR den_max_tmp = 1.;
 
    GUM_SCALAR res_min = 1.0;
    GUM_SCALAR res_max = 0.0;
 
    auto lsize = lx.size();
 
    for (decltype(lsize) i = 0; i < lsize; i++) {
      bool non_defini_min = false;
      bool non_defini_max = false;
 
      if (lx[i] == INF_) {
        num_min_tmp = num_min;
        den_min_tmp = den_max;
        num_max_tmp = num_max;
        den_max_tmp = den_min;
      } else if (lx[i] == (GUM_SCALAR)1.) {
        num_min_tmp = GUM_SCALAR(1.);
        den_min_tmp = GUM_SCALAR(1.);
        num_max_tmp = GUM_SCALAR(1.);
        den_max_tmp = GUM_SCALAR(1.);
      } else if (lx[i] > (GUM_SCALAR)1.) {
        GUM_SCALAR li = GUM_SCALAR(1.) / (lx[i] - GUM_SCALAR(1.));
        num_min_tmp   = num_min + li;
        den_min_tmp   = den_max + li;
        num_max_tmp   = num_max + li;
        den_max_tmp   = den_min + li;
      } else if (lx[i] < (GUM_SCALAR)1.) {
        GUM_SCALAR li = GUM_SCALAR(1.) / (lx[i] - GUM_SCALAR(1.));
        num_min_tmp   = num_max + li;
        den_min_tmp   = den_min + li;
        num_max_tmp   = num_min + li;
        den_max_tmp   = den_max + li;
      }
 
      if (den_min_tmp == 0. && num_min_tmp == 0.) {
        non_defini_min = true;
      } else if (den_min_tmp == 0. && num_min_tmp != 0.) {
        res_min = INF_;
      } else if (den_min_tmp != INF_ || num_min_tmp != INF_) {
        res_min = num_min_tmp / den_min_tmp;
      }
 
      if (den_max_tmp == 0. && num_max_tmp == 0.) {
        non_defini_max = true;
      } else if (den_max_tmp == 0. && num_max_tmp != 0.) {
        res_max = INF_;
      } else if (den_max_tmp != INF_ || num_max_tmp != INF_) {
        res_max = num_max_tmp / den_max_tmp;
      }
 
      if (non_defini_max && non_defini_min) {
        std::cout << "undefined msg" << std::endl;
        continue;
      } else if (non_defini_min && !non_defini_max) {
        res_min = res_max;
      } else if (non_defini_max && !non_defini_min) {
        res_max = res_min;
      }
 
      if (res_min < 0.) { res_min = 0.; }
 
      if (res_max < 0.) { res_max = 0.; }
 
      if (msg_l_min == msg_l_max && msg_l_min == -2.) {
        msg_l_min = res_min;
        msg_l_max = res_max;
      }
 
      if (res_max > msg_l_max) { msg_l_max = res_max; }
 
      if (res_min < msg_l_min) { msg_l_min = res_min; }
 
    }   // end of : for each lx
  }

References INF_.

Referenced by compute_ext_(), enum_combi_(), and enum_combi_().

Here is the caller graph for this function:

compute_ext_() [2/3]

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CNLoopyPropagation< GUM_SCALAR >::compute_ext_ ( std::vector< std::vector< GUM_SCALAR > > & combi_msg_p, const NodeId & id, GUM_SCALAR & msg_l_min, GUM_SCALAR & msg_l_max, std::vector< GUM_SCALAR > & lx, const Idx & pos )

protected

Used by msgL_.

extremes pour une combinaison des parents, message vers parent

Compute the numerators & denominators for the given parent's message and likelihood (children's messages). Marginalisation.

Parameters

combi_msg_p	The parent's chosen message.
id	The constant id of the node sending the message.
msg_l_min	The reference to the current lower value of the message to be sent.
msg_l_max	The reference to the current upper value of the message to be sent.
lx	The lower and upper likelihood.
pos	The position of the parent node to receive the message in the CPT of the one sending the message ( first parent, second ... ).

Definition at line 286 of file CNLoopyPropagation_tpl.h.

                                                     {
    GUM_SCALAR num_min = 0.;
    GUM_SCALAR num_max = 0.;
    GUM_SCALAR den_min = 0.;
    GUM_SCALAR den_max = 0.;
 
    auto taille = combi_msg_p.size();
 
    std::vector< typename std::vector< GUM_SCALAR >::iterator > it(taille);
 
    for (decltype(taille) i = 0; i < taille; i++) {
      it[i] = combi_msg_p[i].begin();
    }
 
    Size pp = pos;
 
    Size combi_den = 0;
    Size combi_num = pp;
 
    // marginalisation
    while (it[taille - 1] != combi_msg_p[taille - 1].end()) {
      GUM_SCALAR prod = 1.;
 
      for (decltype(taille) k = 0; k < taille; k++) {
        prod *= *it[k];
      }
 
      den_min += (_cn_->get_binaryCPT_min()[id][combi_den] * prod);
      den_max += (_cn_->get_binaryCPT_max()[id][combi_den] * prod);
 
      num_min += (_cn_->get_binaryCPT_min()[id][combi_num] * prod);
      num_max += (_cn_->get_binaryCPT_max()[id][combi_num] * prod);
 
      combi_den++;
      combi_num++;
 
      if (pp != 0) {
        if (combi_den % pp == 0) {
          combi_den += pp;
          combi_num += pp;
        }
      }
 
      // incrementation
      ++it[0];
 
      for (decltype(taille) i = 0; (i < taille - 1) && (it[i] == combi_msg_p[i].end()); ++i) {
        it[i] = combi_msg_p[i].begin();
        ++it[i + 1];
      }
    }   // end of : marginalisation
 
    compute_ext_(msg_l_min, msg_l_max, lx, num_min, num_max, den_min, den_max);
  }

References _cn_, and compute_ext_().

Here is the call graph for this function:

compute_ext_() [3/3]

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CNLoopyPropagation< GUM_SCALAR >::compute_ext_ ( std::vector< std::vector< GUM_SCALAR > > & combi_msg_p, const NodeId & id, GUM_SCALAR & msg_p_min, GUM_SCALAR & msg_p_max )

protected

Used by msgP_.

extremes pour une combinaison des parents, message vers enfant marginalisation cpts

Marginalisation.

Parameters

combi_msg_p	The parent's chosen message.
id	The constant id of the node sending the message.
msg_p_min	The reference to the current lower value of the message to be sent.
msg_p_max	The reference to the current upper value of the message to be sent.

Definition at line 352 of file CNLoopyPropagation_tpl.h.

                                                           {
    GUM_SCALAR min = 0.;
    GUM_SCALAR max = 0.;
 
    auto taille = combi_msg_p.size();
 
    std::vector< typename std::vector< GUM_SCALAR >::iterator > it(taille);
 
    for (decltype(taille) i = 0; i < taille; i++) {
      it[i] = combi_msg_p[i].begin();
    }
 
    int  combi  = 0;
    auto theEnd = combi_msg_p[taille - 1].end();
 
    while (it[taille - 1] != theEnd) {
      GUM_SCALAR prod = 1.;
 
      for (decltype(taille) k = 0; k < taille; k++) {
        prod *= *it[k];
      }
 
      min += (_cn_->get_binaryCPT_min()[id][combi] * prod);
      max += (_cn_->get_binaryCPT_max()[id][combi] * prod);
 
      combi++;
 
      // incrementation
      ++it[0];
 
      for (decltype(taille) i = 0; (i < taille - 1) && (it[i] == combi_msg_p[i].end()); ++i) {
        it[i] = combi_msg_p[i].begin();
        ++it[i + 1];
      }
    }
 
    if (min < msg_p_min) { msg_p_min = min; }
 
    if (max > msg_p_max) { msg_p_max = max; }
  }

References _cn_.

computeEpsilon_()

template<GUM_Numeric GUM_SCALAR>

const GUM_SCALAR gum::credal::InferenceEngine< GUM_SCALAR >::computeEpsilon_ ( )

protectedvirtualinherited

Compute approximation scheme epsilon using the old marginals and the new ones.

Highest delta on either lower or upper marginal is epsilon.

Also updates oldMarginals to current marginals.

Returns

Epsilon.

Reimplemented in gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >, and gum::credal::MultipleInferenceEngine< GUM_SCALAR, LazyPropagation< GUM_SCALAR > >.

Definition at line 979 of file inferenceEngine_tpl.h.

                                                                    {
      // compute the number of threads and prepare for the result
      const Size                nb_threads = ThreadExecutor::nbRunningThreadsExecutors() == 0
                                               ? this->threadRanges_.size() - 1
                                               : 1;   // no nested multithreading
      std::vector< GUM_SCALAR > tEps(nb_threads, std::numeric_limits< GUM_SCALAR >::max());
 
      // create the function to be executed by the threads
      auto threadedEps = [this, &tEps](const std::size_t                              this_thread,
                                       const std::size_t                              nb_threads,
                                       const std::vector< std::pair< NodeId, Idx > >& ranges) {
        auto&      this_tEps = tEps[this_thread];
        GUM_SCALAR delta;
 
        // below, we will loop over indices i and j of marginalMin_ and
        // marginalMax_. Index i represents nodes and j allow to parse their
        // domain. To parse all the domains of all the nodes, we should theorically
        // use 2 loops. However, here, we will use one loop: we start with node i
        // and parse its domain with index j. When this is done, we move to the
        // next node, and so on. The underlying idea is that, by doing so, we
        // need not parse in this function the whole domain of a node: we can start
        // the loop at a given value of node i and complete the loop on another
        // value of another node. These values are computed in Vector threadRanges_
        // by Method dispatchMarginalsToThreads_(), which dispatches the loops
        // among threads
        auto       i                = ranges[this_thread].first;
        auto       j                = ranges[this_thread].second;
        auto       domain_size      = this->marginalMax_[i].size();
        const auto end_i            = ranges[this_thread + 1].first;
        auto       end_j            = ranges[this_thread + 1].second;
        const auto marginalMax_size = this->marginalMax_.size();
 
        while ((i < end_i) || (j < end_j)) {
          // on min
          delta     = marginalMin_[i][j] - oldMarginalMin_[i][j];
          delta     = (delta < 0) ? (-delta) : delta;
          this_tEps = (this_tEps < delta) ? delta : this_tEps;
 
          // on max
          delta     = marginalMax_[i][j] - oldMarginalMax_[i][j];
          delta     = (delta < 0) ? (-delta) : delta;
          this_tEps = (this_tEps < delta) ? delta : this_tEps;
 
          oldMarginalMin_[i][j] = marginalMin_[i][j];
          oldMarginalMax_[i][j] = marginalMax_[i][j];
 
          if (++j == domain_size) {
            j = 0;
            ++i;
            if (i < marginalMax_size) domain_size = this->marginalMax_[i].size();
          }
        }
      };
 
      // launch the threads
      ThreadExecutor::execute(
          nb_threads,
          threadedEps,
          (nb_threads == 1)
              ? std::vector< std::pair< NodeId, Idx > >{{0, 0}, {this->marginalMin_.size(), 0}}
              : this->threadRanges_);
 
      // aggregate all the results
      GUM_SCALAR eps = tEps[0];
      for (const auto nb: tEps)
        if (eps < nb) eps = nb;
 
      return eps;
    }

References gum::threadsSTL::ThreadExecutor::execute(), marginalMax_, marginalMin_, gum::threadsSTL::ThreadExecutor::nbRunningThreadsExecutors(), oldMarginalMax_, oldMarginalMin_, and threadRanges_.

Referenced by gum::credal::CNLoopyPropagation< GUM_SCALAR >::calculateEpsilon_().

Here is the call graph for this function:

Here is the caller graph for this function:

computeExpectations_()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CNLoopyPropagation< GUM_SCALAR >::computeExpectations_ ( )

protected

Since the network is binary, expectations can be computed from the final marginals which give us the credal set vertices.

Definition at line 1456 of file CNLoopyPropagation_tpl.h.

                                                              {
    if (_infE_::modal_.empty()) { return; }
 
    std::vector< std::vector< GUM_SCALAR > > vertices(2, std::vector< GUM_SCALAR >(2));
 
    for (auto node: _bnet_->nodes()) {
      vertices[0][0] = _infE_::marginalMin_[node][0];
      vertices[0][1] = _infE_::marginalMax_[node][1];
 
      vertices[1][0] = _infE_::marginalMax_[node][0];
      vertices[1][1] = _infE_::marginalMin_[node][1];
 
      for (auto vertex = 0, vend = 2; vertex != vend; vertex++) {
        _infE_::updateExpectations_(node, vertices[vertex]);
        // test credal sets vertices elim
        // remove with L2U since variables are binary
        // but does the user know that ?
        _infE_::updateCredalSets_(node,
                                  vertices[vertex]);   // no redundancy elimination with 2 vertices
      }
    }
  }

References _bnet_, gum::credal::InferenceEngine< GUM_SCALAR >::marginalMax_, gum::credal::InferenceEngine< GUM_SCALAR >::marginalMin_, gum::credal::InferenceEngine< GUM_SCALAR >::modal_, gum::credal::InferenceEngine< GUM_SCALAR >::updateCredalSets_(), gum::credal::InferenceEngine< GUM_SCALAR >::updateExpectations_(), and gum::credal::InferenceEngine< GUM_SCALAR >::vertices().

Referenced by makeInference().

Here is the call graph for this function:

Here is the caller graph for this function:

continueApproximationScheme()

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

inherited

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

Test the stopping criterion that are enabled.

Parameters

error

The new error value.

Returns

false if state become != ApproximationSchemeSTATE::Continue

Exceptions

OperationNotAllowed

Raised if state != ApproximationSchemeSTATE::Continue.

Definition at line 69 of file approximationScheme.cpp.

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

References gum::IApproximationSchemeConfiguration::Continue, current_epsilon_, current_rate_, current_state_, current_step_, enabled_eps_, enabled_max_iter_, enabled_max_time_, enabled_min_rate_eps_, eps_, gum::IApproximationSchemeConfiguration::Epsilon, GUM_EMIT3, GUM_ERROR, gum::__sig__::BasicSignaler< Args... >::hasListener(), history_, last_epsilon_, gum::IApproximationSchemeConfiguration::Limit, max_iter_, max_time_, gum::IApproximationSchemeConfiguration::messageApproximationScheme(), min_rate_eps_, gum::IApproximationSchemeConfiguration::onProgress, gum::IApproximationSchemeConfiguration::Rate, startOfPeriod(), stateApproximationScheme(), gum::Timer::step(), stopScheme_(), gum::IApproximationSchemeConfiguration::TimeLimit, timer_, and verbosity().

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

Here is the call graph for this function:

Here is the caller graph for this function:

credalNet()

template<GUM_Numeric GUM_SCALAR>

const CredalNet< GUM_SCALAR > & gum::credal::InferenceEngine< GUM_SCALAR >::credalNet ( ) const

inherited

Get this credal network.

Returns

A constant reference to this CredalNet.

Definition at line 82 of file inferenceEngine_tpl.h.

                                                                                  {
      return *credalNet_;
    }

References credalNet_.

Referenced by gum::credal::CNLoopyPropagation< GUM_SCALAR >::CNLoopyPropagation(), InferenceEngine(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::MultipleInferenceEngine(), and makeInference().

Here is the caller graph for this function:

currentTime()

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

overridevirtualinherited

Returns the current running time in second.

Returns

Returns the current running time in second.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 137 of file approximationScheme_inl.h.

{ return timer_.step(); }

References gum::Timer::step(), and timer_.

Referenced by gum::learning::IBNLearner::currentTime(), and gum::learning::IBNLearner::EMCurrentTime().

Here is the call graph for this function:

Here is the caller graph for this function:

disableEpsilon()

INLINE void gum::ApproximationScheme::disableEpsilon ( )

overridevirtualinherited

Disable stopping criterion on epsilon.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 75 of file approximationScheme_inl.h.

{ enabled_eps_ = false; }

References enabled_eps_.

Referenced by gum::learning::EMApproximationScheme::EMApproximationScheme(), gum::learning::LocalSearchWithTabuList::LocalSearchWithTabuList(), gum::learning::IBNLearner::disableEpsilon(), gum::learning::IBNLearner::EMdisableEpsilon(), and gum::learning::EMApproximationScheme::setMinEpsilonRate().

Here is the caller graph for this function:

disableMaxIter()

INLINE void gum::ApproximationScheme::disableMaxIter ( )

overridevirtualinherited

Disable stopping criterion on max iterations.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 116 of file approximationScheme_inl.h.

{ enabled_max_iter_ = false; }

References enabled_max_iter_.

Referenced by gum::learning::GreedyHillClimbing::GreedyHillClimbing(), gum::learning::GreedyThickThinning::GreedyThickThinning(), gum::learning::LocalSearchWithTabuList::LocalSearchWithTabuList(), gum::learning::IBNLearner::disableMaxIter(), and gum::learning::IBNLearner::EMdisableMaxIter().

Here is the caller graph for this function:

disableMaxTime()

INLINE void gum::ApproximationScheme::disableMaxTime ( )

overridevirtualinherited

Disable stopping criterion on timeout.

Returns

Disable stopping criterion on timeout.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 140 of file approximationScheme_inl.h.

{ enabled_max_time_ = false; }

References enabled_max_time_.

Referenced by gum::learning::GreedyHillClimbing::GreedyHillClimbing(), gum::learning::GreedyThickThinning::GreedyThickThinning(), gum::learning::LocalSearchWithTabuList::LocalSearchWithTabuList(), gum::learning::IBNLearner::disableMaxTime(), and gum::learning::IBNLearner::EMdisableMaxTime().

Here is the caller graph for this function:

disableMinEpsilonRate()

INLINE void gum::ApproximationScheme::disableMinEpsilonRate ( )

overridevirtualinherited

Disable stopping criterion on epsilon rate.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 96 of file approximationScheme_inl.h.

{ enabled_min_rate_eps_ = false; }

References enabled_min_rate_eps_.

Referenced by gum::learning::GreedyHillClimbing::GreedyHillClimbing(), gum::learning::GreedyThickThinning::GreedyThickThinning(), gum::learning::LocalSearchWithTabuList::LocalSearchWithTabuList(), gum::GibbsBNdistance< GUM_SCALAR >::computeKL_(), gum::MCBNDistance< GUM_SCALAR >::computeKL_(), gum::learning::IBNLearner::disableMinEpsilonRate(), gum::learning::IBNLearner::EMdisableMinEpsilonRate(), and gum::learning::EMApproximationScheme::setEpsilon().

Here is the caller graph for this function:

dispatchMarginalsToThreads_()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::dispatchMarginalsToThreads_ ( )

protectedinherited

computes Vector threadRanges_, that assigns some part of marginalMin_ and marginalMax_ to the threads

Definition at line 1094 of file inferenceEngine_tpl.h.

                                                                    {
      // we compute the number of elements in the 2 loops (over i,j in marginalMin_[i][j])
      Size       nb_elements      = 0;
      const auto marginalMin_size = this->marginalMin_.size();
      for (const auto& marg_i: this->marginalMin_)
        nb_elements += marg_i.second.size();
 
      // distribute evenly the elements among the threads
      auto nb_threads = ThreadNumberManager::getNumberOfThreads();
      if (nb_elements < nb_threads) nb_threads = nb_elements;
 
      // the result that we return is a vector of pairs (NodeId, Idx). For thread number i, the
      // pair at index i is the beginning of the range that the thread will have to process: this
      // is the part of the marginal distribution vector of node NodeId starting at index Idx.
      // The pair at index i+1 is the end of this range (not included)
      threadRanges_.clear();
      threadRanges_.reserve(nb_threads + 1);
 
      // try to balance the number of elements among the threads
      Idx nb_elts_par_thread = nb_elements / nb_threads;
      Idx rest_elts          = nb_elements - nb_elts_par_thread * nb_threads;
 
      NodeId current_node         = 0;
      Idx    current_domain_index = 0;
      Size   current_domain_size  = this->marginalMin_[0].size();
      threadRanges_.emplace_back(current_node, current_domain_index);
 
      for (Idx i = Idx(0); i < nb_threads; ++i) {
        // compute the end of the threads, assuming that the current node has a domain
        // sufficiently large
        current_domain_index += nb_elts_par_thread;
        if (rest_elts != Idx(0)) {
          ++current_domain_index;
          --rest_elts;
        }
 
        // if the current node is not sufficient to hold all the elements that
        // the current thread should process. So we should add elements of the
        // next nodes
        while (current_domain_index >= current_domain_size) {
          current_domain_index -= current_domain_size;
          ++current_node;
          current_domain_index = 0;
          if (current_node != marginalMin_size) {
            current_domain_size = this->marginalMin_[current_node].size();
          }
        }
 
        // now we can store the range if elements
        threadRanges_.emplace_back(current_node, current_domain_index);
 
        // compute the next begin_node
        if (current_domain_index == current_domain_size) {
          ++current_node;
          current_domain_index = 0;
        }
      }
    }

References gum::ThreadNumberManager::getNumberOfThreads(), and threadRanges_.

Referenced by initMarginals_().

Here is the call graph for this function:

Here is the caller graph for this function:

dynamicExpectations()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::dynamicExpectations ( )

inherited

Compute dynamic expectations.

See also

dynamicExpectations_ Only call this if an algorithm does not call it by itself.

Definition at line 702 of file inferenceEngine_tpl.h.

                                                            {
      dynamicExpectations_();
    }

References dynamicExpectations_().

Referenced by makeInference().

Here is the call graph for this function:

Here is the caller graph for this function:

dynamicExpectations_()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::dynamicExpectations_ ( )

protectedinherited

Rearrange lower and upper expectations to suit dynamic networks.

Definition at line 707 of file inferenceEngine_tpl.h.

                                                             {
      // no modals, no expectations computed during inference
      if (expectationMin_.empty() || modal_.empty()) return;
 
      // already called by the algorithm or the user
      if (dynamicExpMax_.size() > 0 && dynamicExpMin_.size() > 0) return;
 
      using innerMap = typename gum::HashTable< int, GUM_SCALAR >;
 
      using outerMap = typename gum::HashTable< std::string, innerMap >;
 
 
      // if non dynamic, directly save expectationMin_ et Max (same but faster)
      outerMap expectationsMin, expectationsMax;
 
      for (const auto& elt: expectationMin_) {
        std::string var_name, time_step;
 
        var_name   = credalNet_->current_bn().variable(elt.first).name();
        auto delim = var_name.find_first_of("_");
        time_step  = var_name.substr(delim + 1, var_name.size());
        var_name   = var_name.substr(0, delim);
 
        // to be sure (don't store not monitored variables' expectations)
        // although it
        // should be taken care of before this point
        if (!modal_.exists(var_name)) continue;
 
        expectationsMin.getWithDefault(var_name, innerMap())
            .getWithDefault(atoi(time_step.c_str()), 0)
            = elt.second;   // we iterate with min iterators
        expectationsMax.getWithDefault(var_name, innerMap())
            .getWithDefault(atoi(time_step.c_str()), 0) = expectationMax_[elt.first];
      }
 
      for (const auto& elt: expectationsMin) {
        typename std::vector< GUM_SCALAR > dynExp(elt.second.size());
 
        for (const auto& elt2: elt.second)
          dynExp[elt2.first] = elt2.second;
 
        dynamicExpMin_.insert(elt.first, dynExp);
      }
 
      for (const auto& elt: expectationsMax) {
        typename std::vector< GUM_SCALAR > dynExp(elt.second.size());
 
        for (const auto& elt2: elt.second) {
          dynExp[elt2.first] = elt2.second;
        }
 
        dynamicExpMax_.insert(elt.first, dynExp);
      }
    }

References credalNet_, dynamicExpMax_, dynamicExpMin_, expectationMax_, expectationMin_, and modal_.

Referenced by dynamicExpectations().

Here is the caller graph for this function:

dynamicExpMax()

template<GUM_Numeric GUM_SCALAR>

const std::vector< GUM_SCALAR > & gum::credal::InferenceEngine< GUM_SCALAR >::dynamicExpMax ( std::string_view varName ) const

inherited

Get the upper dynamic expectation of a given variable prefix (without the time step included, i.e.

call with "temp" to get "temp_0", ..., "temp_T").

Parameters

varName

The variable name prefix which upper expectation we want.

Returns

A constant reference to the variable upper expectation over all time steps.

Definition at line 496 of file inferenceEngine_tpl.h.

                                                                                 {
      std::string errTxt = "const std::vector< GUM_SCALAR > & InferenceEngine< "
                           "GUM_SCALAR >::dynamicExpMax ( const std::string & "
                           "varName ) const : ";
 
      if (dynamicExpMax_.empty())
        GUM_ERROR(OperationNotAllowed, errTxt + "_dynamicExpectations() needs to be called before")
 
      auto p = dynamicExpMax_.tryGet(varName);
      if (!p /*dynamicExpMin_.find(varName) == dynamicExpMin_.end()*/)
        GUM_ERROR(NotFound, errTxt + "variable name not found : " << varName)
 
      return *p;
    }

References InferenceEngine(), and dynamicExpMax().

Referenced by dynamicExpMax(), and makeInference().

Here is the call graph for this function:

Here is the caller graph for this function:

dynamicExpMin()

template<GUM_Numeric GUM_SCALAR>

const std::vector< GUM_SCALAR > & gum::credal::InferenceEngine< GUM_SCALAR >::dynamicExpMin ( std::string_view varName ) const

inherited

Get the lower dynamic expectation of a given variable prefix (without the time step included, i.e.

call with "temp" to get "temp_0", ..., "temp_T").

Parameters

varName

The variable name prefix which lower expectation we want.

Returns

A constant reference to the variable lower expectation over all time steps.

Definition at line 479 of file inferenceEngine_tpl.h.

                                                                                 {
      std::string errTxt = "const std::vector< GUM_SCALAR > & InferenceEngine< "
                           "GUM_SCALAR >::dynamicExpMin ( const std::string & "
                           "varName ) const : ";
 
      if (dynamicExpMin_.empty())
        GUM_ERROR(OperationNotAllowed, errTxt + "_dynamicExpectations() needs to be called before")
 
      auto p = dynamicExpMin_.tryGet(varName);
      if (!p /*dynamicExpMin_.find(varName) == dynamicExpMin_.end()*/)
        GUM_ERROR(NotFound, errTxt + "variable name not found : " << varName)
 
      return *p;
    }

Referenced by makeInference().

Here is the caller graph for this function:

enableEpsilon()

INLINE void gum::ApproximationScheme::enableEpsilon ( )

overridevirtualinherited

Enable stopping criterion on epsilon.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 78 of file approximationScheme_inl.h.

{ enabled_eps_ = true; }

References enabled_eps_.

Referenced by gum::learning::IBNLearner::EMenableEpsilon(), and gum::learning::IBNLearner::enableEpsilon().

Here is the caller graph for this function:

enableMaxIter()

INLINE void gum::ApproximationScheme::enableMaxIter ( )

overridevirtualinherited

Enable stopping criterion on max iterations.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 119 of file approximationScheme_inl.h.

{ enabled_max_iter_ = true; }

References enabled_max_iter_.

Referenced by gum::learning::IBNLearner::EMenableMaxIter(), and gum::learning::IBNLearner::enableMaxIter().

Here is the caller graph for this function:

enableMaxTime()

INLINE void gum::ApproximationScheme::enableMaxTime ( )

overridevirtualinherited

Enable stopping criterion on timeout.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 143 of file approximationScheme_inl.h.

{ enabled_max_time_ = true; }

References enabled_max_time_.

Referenced by gum::learning::IBNLearner::EMenableMaxTime(), and gum::learning::IBNLearner::enableMaxTime().

Here is the caller graph for this function:

enableMinEpsilonRate()

INLINE void gum::ApproximationScheme::enableMinEpsilonRate ( )

overridevirtualinherited

Enable stopping criterion on epsilon rate.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 99 of file approximationScheme_inl.h.

{ enabled_min_rate_eps_ = true; }

References enabled_min_rate_eps_.

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

Here is the caller graph for this function:

enum_combi_() [1/2]

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CNLoopyPropagation< GUM_SCALAR >::enum_combi_ ( std::vector< std::vector< std::vector< GUM_SCALAR > > > & msgs_p, const NodeId & id, GUM_SCALAR & msg_l_min, GUM_SCALAR & msg_l_max, std::vector< GUM_SCALAR > & lx, const Idx & pos )

protected

Used by msgL_.

comme precedemment mais pour message parent, vraisemblance prise en compte

Enumerate parent's messages.

Parameters

msgs_p	All the messages from the parents which will be enumerated.
id	The constant id of the node sending the message.
msg_l_min	The reference to the current lower value of the message to be sent.
msg_l_max	The reference to the current upper value of the message to be sent.
lx	The lower and upper likelihood.
pos	The position of the parent node to receive the message in the CPT of the one sending the message ( first parent, second ... ).

Definition at line 471 of file CNLoopyPropagation_tpl.h.

                                                                    {
    GUM_SCALAR msg_l_min = real_msg_l_min;
    GUM_SCALAR msg_l_max = real_msg_l_max;
 
    auto taille = msgs_p.size();
 
    // one parent node, the one receiving the message
    if (taille == 0) {
      GUM_SCALAR num_min = _cn_->get_binaryCPT_min()[id][1];
      GUM_SCALAR num_max = _cn_->get_binaryCPT_max()[id][1];
      GUM_SCALAR den_min = _cn_->get_binaryCPT_min()[id][0];
      GUM_SCALAR den_max = _cn_->get_binaryCPT_max()[id][0];
 
      compute_ext_(msg_l_min, msg_l_max, lx, num_min, num_max, den_min, den_max);
 
      real_msg_l_min = msg_l_min;
      real_msg_l_max = msg_l_max;
      return;
    }
 
    Size msgPerm = 1;
    for (Size i = 0; i < taille; i++) {
      msgPerm *= msgs_p[i].size();
    }
 
    // dispatch the messages among the threads and prepare the data
    // they will process
    Size nb_threads = ThreadExecutor::nbRunningThreadsExecutors() == 0
                        ? this->getNumberOfThreads()
                        : 1;   // no nested multithreading
    nb_threads      = std::min(msgPerm * taille / this->threadMinimalNbOps_, nb_threads);
    if (nb_threads < 1) nb_threads = 1;
 
    const auto ranges = gum::dispatchRangeToThreads(0, msgPerm, (unsigned int)(nb_threads));
    const auto real_nb_threads = ranges.size();
    std::vector< GUM_SCALAR > msg_lmin(real_nb_threads, msg_l_min);
    std::vector< GUM_SCALAR > msg_lmax(real_nb_threads, msg_l_max);
 
    // create the function to be executed by the threads
    auto threadedExec = [this, &msg_lmin, &msg_lmax, msgs_p, taille, ranges, id, &lx, pos](
                            const std::size_t this_thread,
                            const std::size_t nb_threads) {
      std::vector< std::vector< GUM_SCALAR > > combi_msg_p(taille);
 
      const auto& [first, second] = ranges[this_thread];
      for (Idx j = first; j < second; ++j) {
        // get jth msg :
        auto jvalue = j;
 
        for (Idx i = 0; i < taille; i++) {
          if (msgs_p[i].size() == 2) {
            combi_msg_p[i] = (jvalue & 1) ? msgs_p[i][1] : msgs_p[i][0];
            jvalue /= 2;
          } else {
            combi_msg_p[i] = msgs_p[i][0];
          }
        }
        compute_ext_(combi_msg_p, id, msg_lmin[this_thread], msg_lmax[this_thread], lx, pos);
      }
    };
 
    // launch the threads
    ThreadExecutor::execute(real_nb_threads, threadedExec);
 
    for (Idx j = 0; j < real_nb_threads; ++j) {
      if ((msg_l_min > msg_lmin[j] || msg_l_min == -2) && msg_lmin[j] > 0) {
        msg_l_min = msg_lmin[j];
      }
      if ((msg_l_max < msg_lmax[j] || msg_l_max == -2) && msg_lmax[j] > 0) {
        msg_l_max = msg_lmax[j];
      }
    }
 
    real_msg_l_min = msg_l_min;
    real_msg_l_max = msg_l_max;
  }

References _cn_, compute_ext_(), gum::dispatchRangeToThreads(), gum::threadsSTL::ThreadExecutor::execute(), gum::ThreadNumberManager::getNumberOfThreads(), gum::threadsSTL::ThreadExecutor::nbRunningThreadsExecutors(), and gum::credal::InferenceEngine< GUM_SCALAR >::threadMinimalNbOps_.

Referenced by initialize_(), msgL_(), msgP_(), and refreshLMsPIs_().

Here is the call graph for this function:

Here is the caller graph for this function:

enum_combi_() [2/2]

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CNLoopyPropagation< GUM_SCALAR >::enum_combi_ ( std::vector< std::vector< std::vector< GUM_SCALAR > > > & msgs_p, const NodeId & id, GUM_SCALAR & msg_p_min, GUM_SCALAR & msg_p_max )

protected

Used by msgP_.

enumerate combinations messages parents, pour message vers enfant

Enumerate parent's messages.

Parameters

msgs_p	All the messages from the parents which will be enumerated.
id	The constant id of the node sending the message.
msg_p_min	The reference to the current lower value of the message to be sent.
msg_p_max	The reference to the current upper value of the message to be sent.

Definition at line 401 of file CNLoopyPropagation_tpl.h.

                                                                          {
    auto taille = msgs_p.size();
 
    // source node
    if (taille == 0) {
      msg_p_min = _cn_->get_binaryCPT_min()[id][0];
      msg_p_max = _cn_->get_binaryCPT_max()[id][0];
      return;
    }
 
    Size msgPerm = 1;
    for (Size i = 0; i < taille; i++) {
      msgPerm *= msgs_p[i].size();
    }
 
    // dispatch the messages among the threads and prepare the data
    // they will process
    Size nb_threads = ThreadExecutor::nbRunningThreadsExecutors() == 0
                        ? this->getNumberOfThreads()
                        : 1;   // no nested multithreading
    nb_threads      = std::min(msgPerm * taille / this->threadMinimalNbOps_, nb_threads);
    if (nb_threads < 1) nb_threads = 1;
 
    const auto ranges = gum::dispatchRangeToThreads(0, msgPerm, (unsigned int)(nb_threads));
    const auto real_nb_threads = ranges.size();
    std::vector< GUM_SCALAR > msg_pmin(real_nb_threads, msg_p_min);
    std::vector< GUM_SCALAR > msg_pmax(real_nb_threads, msg_p_max);
 
    // create the function to be executed by the threads
    auto threadedExec
        = [this, &msg_pmin, &msg_pmax, msgs_p, taille, ranges, id](const std::size_t this_thread,
                                                                   const std::size_t nb_threads) {
            std::vector< std::vector< GUM_SCALAR > > combi_msg_p(taille);
 
            const auto& [first, second] = ranges[this_thread];
            for (Idx j = first; j < second; ++j) {
              // get jth msg :
              auto jvalue = j;
 
              for (Idx i = 0; i < taille; i++) {
                if (msgs_p[i].size() == 2) {
                  combi_msg_p[i] = (jvalue & 1) ? msgs_p[i][1] : msgs_p[i][0];
                  jvalue /= 2;
                } else {
                  combi_msg_p[i] = msgs_p[i][0];
                }
              }
 
              compute_ext_(combi_msg_p, id, msg_pmin[this_thread], msg_pmax[this_thread]);
            }
          };
 
    // launch the threads
    ThreadExecutor::execute(real_nb_threads, threadedExec);
 
    for (Idx j = 0; j < real_nb_threads; ++j) {
      if (msg_p_min > msg_pmin[j]) { msg_p_min = msg_pmin[j]; }
      if (msg_p_max < msg_pmax[j]) { msg_p_max = msg_pmax[j]; }
    }
  }

References _cn_, compute_ext_(), gum::dispatchRangeToThreads(), gum::threadsSTL::ThreadExecutor::execute(), gum::ThreadNumberManager::getNumberOfThreads(), gum::threadsSTL::ThreadExecutor::nbRunningThreadsExecutors(), and gum::credal::InferenceEngine< GUM_SCALAR >::threadMinimalNbOps_.

Here is the call graph for this function:

epsilon()

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

overridevirtualinherited

Returns the value of epsilon.

Returns

Returns the value of epsilon.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 72 of file approximationScheme_inl.h.

{ return eps_; }

References eps_.

Referenced by gum::learning::IBNLearner::EMEpsilon(), gum::learning::IBNLearner::epsilon(), gum::ImportanceSampling< GUM_SCALAR >::onContextualize_(), and gum::ImportanceSampling< GUM_SCALAR >::unsharpenBN_().

Here is the caller graph for this function:

eraseAllEvidence()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CNLoopyPropagation< GUM_SCALAR >::eraseAllEvidence ( )

overridevirtual

Erase all inference related data to perform another one.

You need to insert evidence again if needed but modalities are kept. You can insert new ones by using the appropriate method which will delete the old ones.

Reimplemented from gum::credal::InferenceEngine< GUM_SCALAR >.

Definition at line 579 of file CNLoopyPropagation_tpl.h.

                                                          {
    _infE_::eraseAllEvidence();
 
    ArcsL_min_.clear();
    ArcsL_max_.clear();
    ArcsP_min_.clear();
    ArcsP_max_.clear();
    NodesL_min_.clear();
    NodesL_max_.clear();
    NodesP_min_.clear();
    NodesP_max_.clear();
 
    inference_up_to_date_ = false;
 
    if (!msg_l_sent_.empty()) {
      for (auto node: _bnet_->nodes()) {
        delete msg_l_sent_[node];
      }
    }
 
    msg_l_sent_.clear();
    update_l_.clear();
    update_p_.clear();
 
    active_nodes_set_.clear();
    next_active_nodes_set_.clear();
  }

References _bnet_, active_nodes_set_, ArcsL_max_, ArcsL_min_, ArcsP_max_, ArcsP_min_, gum::credal::InferenceEngine< GUM_SCALAR >::eraseAllEvidence(), inference_up_to_date_, msg_l_sent_, next_active_nodes_set_, NodesL_max_, NodesL_min_, NodesP_max_, NodesP_min_, update_l_, and update_p_.

Here is the call graph for this function:

expectationMax() [1/2]

template<GUM_Numeric GUM_SCALAR>

const GUM_SCALAR & gum::credal::InferenceEngine< GUM_SCALAR >::expectationMax ( const NodeId id ) const

inherited

Get the upper expectation of a given node id.

Parameters

id	The node id which upper expectation we want.

Returns

A constant reference to this node upper expectation.

Definition at line 473 of file inferenceEngine_tpl.h.

                                                                                         {
      return expectationMax_[id];
    }

References expectationMax_.

Referenced by makeInference().

Here is the caller graph for this function:

expectationMax() [2/2]

template<GUM_Numeric GUM_SCALAR>

const GUM_SCALAR & gum::credal::InferenceEngine< GUM_SCALAR >::expectationMax ( std::string_view varName ) const

inherited

Get the upper expectation of a given variable name.

Parameters

varName

The variable name which upper expectation we want.

Returns

A constant reference to this variable upper expectation.

Definition at line 463 of file inferenceEngine_tpl.h.

                                                                                  {
      return expectationMax_[credalNet_->current_bn().idFromName(varName)];
    }

References credalNet_, and expectationMax_.

expectationMin() [1/2]

template<GUM_Numeric GUM_SCALAR>

const GUM_SCALAR & gum::credal::InferenceEngine< GUM_SCALAR >::expectationMin ( const NodeId id ) const

inherited

Get the lower expectation of a given node id.

Parameters

id	The node id which lower expectation we want.

Returns

A constant reference to this node lower expectation.

Definition at line 468 of file inferenceEngine_tpl.h.

                                                                                         {
      return expectationMin_[id];
    }

References expectationMin_.

Referenced by makeInference().

Here is the caller graph for this function:

expectationMin() [2/2]

template<GUM_Numeric GUM_SCALAR>

const GUM_SCALAR & gum::credal::InferenceEngine< GUM_SCALAR >::expectationMin ( std::string_view varName ) const

inherited

Get the lower expectation of a given variable name.

Parameters

varName

The variable name which lower expectation we want.

Returns

A constant reference to this variable lower expectation.

Definition at line 457 of file inferenceEngine_tpl.h.

                                                                                  {
      return expectationMin_[credalNet_->current_bn().idFromName(varName)];
    }

References credalNet_, and expectationMin_.

getApproximationSchemeMsg()

template<GUM_Numeric GUM_SCALAR>

const std::string gum::credal::InferenceEngine< GUM_SCALAR >::getApproximationSchemeMsg ( )

inherited

Get approximation scheme state.

Returns

A constant string about approximation scheme state.

Definition at line 1208 of file inferenceEngine_tpl.h.

                                                                             {
      return this->messageApproximationScheme();
    }

References gum::IApproximationSchemeConfiguration::messageApproximationScheme().

Referenced by makeInference().

Here is the call graph for this function:

Here is the caller graph for this function:

getNumberOfThreads()

Size gum::ThreadNumberManager::getNumberOfThreads ( ) const

nodiscardoverridevirtualinherited

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

Implements gum::IThreadNumberManager.

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

Here is the caller graph for this function:

getT0Cluster()

template<GUM_Numeric GUM_SCALAR>

const NodeProperty< std::vector< NodeId > > & gum::credal::InferenceEngine< GUM_SCALAR >::getT0Cluster ( ) const

inherited

Get the t0_ cluster.

Returns

A constant reference to the t0_ cluster.

Definition at line 968 of file inferenceEngine_tpl.h.

                                                          {
      return t0_;
    }

References t0_.

Referenced by makeInference().

Here is the caller graph for this function:

getT1Cluster()

template<GUM_Numeric GUM_SCALAR>

const NodeProperty< std::vector< NodeId > > & gum::credal::InferenceEngine< GUM_SCALAR >::getT1Cluster ( ) const

inherited

Get the t1_ cluster.

Returns

A constant reference to the t1_ cluster.

Definition at line 974 of file inferenceEngine_tpl.h.

                                                          {
      return t1_;
    }

References t1_.

Referenced by makeInference().

Here is the caller graph for this function:

getVarMod2BNsMap()

template<GUM_Numeric GUM_SCALAR>

VarMod2BNsMap< GUM_SCALAR > * gum::credal::InferenceEngine< GUM_SCALAR >::getVarMod2BNsMap ( )

inherited

Get optimum IBayesNet.

Returns

A pointer to the optimal net object.

Definition at line 164 of file inferenceEngine_tpl.h.

                                                                                 {
      return &dbnOpt_;
    }

References dbnOpt_.

Referenced by makeInference().

Here is the caller graph for this function:

history()

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

overridevirtualinherited

Returns the scheme history.

Returns

Returns the scheme history.

Exceptions

OperationNotAllowed

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

Implements gum::IApproximationSchemeConfiguration.

Definition at line 179 of file approximationScheme_inl.h.

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

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

Referenced by gum::learning::IBNLearner::EMHistory(), and gum::learning::IBNLearner::history().

Here is the call graph for this function:

Here is the caller graph for this function:

inferenceType() [1/2]

template<GUM_Numeric GUM_SCALAR>

CNLoopyPropagation< GUM_SCALAR >::InferenceType gum::credal::CNLoopyPropagation< GUM_SCALAR >::inferenceType

(

)

Get the inference type.

Returns

The inference type.

Definition at line 1531 of file CNLoopyPropagation_tpl.h.

                                                      {
    return _inferenceType_;
  }

References _inferenceType_.

inferenceType() [2/2]

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CNLoopyPropagation< GUM_SCALAR >::inferenceType

(

InferenceType

inft

)

Set the inference type.

Parameters

inft	The chosen InferenceType.

Definition at line 1525 of file CNLoopyPropagation_tpl.h.

                                                                         {
    _inferenceType_ = inft;
  }

References _inferenceType_.

initApproximationScheme()

INLINE void gum::ApproximationScheme::initApproximationScheme ( )

inherited

Initialise the scheme.

Definition at line 190 of file approximationScheme_inl.h.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

initExpectations_()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::initExpectations_ ( )

protectedinherited

Initialize lower and upper expectations before inference, with the lower expectation being initialized on the highest modality and the upper expectation being initialized on the lowest modality.

Definition at line 680 of file inferenceEngine_tpl.h.

                                                          {
      expectationMin_.clear();
      expectationMax_.clear();
 
      if (modal_.empty()) return;
 
      for (auto node: credalNet_->current_bn().nodes()) {
        std::string var_name, time_step;
 
        var_name   = credalNet_->current_bn().variable(node).name();
        auto delim = var_name.find_first_of("_");
        var_name   = var_name.substr(0, delim);
 
        auto p_modal = modal_.tryGet(var_name);
        if (!p_modal) continue;
 
        expectationMin_.insert(node, p_modal->back());
        expectationMax_.insert(node, p_modal->front());
      }
    }

References credalNet_, expectationMax_, expectationMin_, and modal_.

Referenced by eraseAllEvidence().

Here is the caller graph for this function:

initialize_()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CNLoopyPropagation< GUM_SCALAR >::initialize_ ( )

protected

Topological forward propagation to initialize old marginals & messages.

Definition at line 608 of file CNLoopyPropagation_tpl.h.

                                                     {
    const DAG& graphe = _bnet_->dag();
 
    // use const iterators with cbegin when available
    for (auto node: _bnet_->topologicalOrder()) {
      update_p_.set(node, false);
      update_l_.set(node, false);
      auto parents_ = new NodeSet();
      msg_l_sent_.set(node, parents_);
 
      // accelerer init pour evidences
      if (_infE_::evidence_.exists(node)) {
        if (_infE_::evidence_[node][1] != 0. && _infE_::evidence_[node][1] != 1.) {
          GUM_ERROR(OperationNotAllowed, "CNLoopyPropagation can only handle HARD evidences")
        }
 
        active_nodes_set_.insert(node);
        update_l_.set(node, true);
        update_p_.set(node, true);
 
        if (_infE_::evidence_[node][1] == (GUM_SCALAR)1.) {
          NodesL_min_.set(node, INF_);
          NodesP_min_.set(node, (GUM_SCALAR)1.);
        } else if (_infE_::evidence_[node][1] == (GUM_SCALAR)0.) {
          NodesL_min_.set(node, (GUM_SCALAR)0.);
          NodesP_min_.set(node, (GUM_SCALAR)0.);
        }
 
        std::vector< GUM_SCALAR > marg(2);
        marg[1] = NodesP_min_[node];
        marg[0] = 1 - marg[1];
 
        _infE_::oldMarginalMin_.set(node, marg);
        _infE_::oldMarginalMax_.set(node, marg);
 
        continue;
      }
 
      NodeSet par_ = graphe.parents(node);
      NodeSet enf_ = graphe.children(node);
 
      if (par_.empty()) {
        active_nodes_set_.insert(node);
        update_p_.set(node, true);
        update_l_.set(node, true);
      }
 
      if (enf_.empty()) {
        active_nodes_set_.insert(node);
        update_p_.set(node, true);
        update_l_.set(node, true);
      }

      const auto parents = &_bnet_->cpt(node).variablesSequence();
 
      std::vector< std::vector< std::vector< GUM_SCALAR > > > msgs_p;
      std::vector< std::vector< GUM_SCALAR > >                msg_p;
      std::vector< GUM_SCALAR >                               distri(2);
 
      // +1 from start to avoid counting_ itself
      // use const iterators when available with cbegin
      for (auto jt = ++parents->begin(), theEnd = parents->end(); jt != theEnd; ++jt) {
        // compute probability distribution to avoid doing it multiple times
        // (at
        // each combination of messages)
        distri[1] = NodesP_min_[_bnet_->nodeId(**jt)];
        distri[0] = (GUM_SCALAR)1. - distri[1];
        msg_p.push_back(distri);
 
        if (NodesP_max_.exists(_bnet_->nodeId(**jt))) {
          distri[1] = NodesP_max_[_bnet_->nodeId(**jt)];
          distri[0] = (GUM_SCALAR)1. - distri[1];
          msg_p.push_back(distri);
        }
 
        msgs_p.push_back(msg_p);
        msg_p.clear();
      }
 
      GUM_SCALAR msg_p_min = 1.;
      GUM_SCALAR msg_p_max = 0.;
 
      if (_cn_->currentNodeType(node) != CredalNet< GUM_SCALAR >::NodeType::Indic) {
        enum_combi_(msgs_p, node, msg_p_min, msg_p_max);
      }
 
      if (msg_p_min <= (GUM_SCALAR)0.) { msg_p_min = (GUM_SCALAR)0.; }
 
      if (msg_p_max <= (GUM_SCALAR)0.) { msg_p_max = (GUM_SCALAR)0.; }
 
      NodesP_min_.set(node, msg_p_min);
      std::vector< GUM_SCALAR > marg(2);
      marg[1] = msg_p_min;
      marg[0] = 1 - msg_p_min;
 
      _infE_::oldMarginalMin_.set(node, marg);
 
      if (msg_p_min != msg_p_max) {
        marg[1] = msg_p_max;
        marg[0] = 1 - msg_p_max;
        NodesP_max_.insert(node, msg_p_max);
      }
 
      _infE_::oldMarginalMax_.set(node, marg);
 
      NodesL_min_.set(node, (GUM_SCALAR)1.);
    }
 
    for (auto arc: _bnet_->arcs()) {
      ArcsP_min_.set(arc, NodesP_min_[arc.tail()]);
 
      if (NodesP_max_.exists(arc.tail())) { ArcsP_max_.set(arc, NodesP_max_[arc.tail()]); }
 
      ArcsL_min_.set(arc, NodesL_min_[arc.tail()]);
    }
  }

References _bnet_, _cn_, active_nodes_set_, ArcsL_min_, ArcsP_max_, ArcsP_min_, gum::ArcGraphPart::children(), gum::Set< Key >::empty(), enum_combi_(), gum::credal::InferenceEngine< GUM_SCALAR >::evidence_, GUM_ERROR, gum::credal::CredalNet< GUM_SCALAR >::Indic, INF_, msg_l_sent_, NodesL_min_, NodesP_max_, NodesP_min_, gum::credal::InferenceEngine< GUM_SCALAR >::oldMarginalMax_, gum::credal::InferenceEngine< GUM_SCALAR >::oldMarginalMin_, gum::ArcGraphPart::parents(), update_l_, and update_p_.

Referenced by makeInference().

Here is the call graph for this function:

Here is the caller graph for this function:

initMarginals_()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::initMarginals_ ( )

protectedinherited

Initialize lower and upper old marginals and marginals before inference, with the lower marginal being 1 and the upper 0.

Definition at line 644 of file inferenceEngine_tpl.h.

                                                       {
      marginalMin_.clear();
      marginalMax_.clear();
      oldMarginalMin_.clear();
      oldMarginalMax_.clear();
 
      for (auto node: credalNet_->current_bn().nodes()) {
        auto dSize = credalNet_->current_bn().variable(node).domainSize();
        marginalMin_.insert(node, std::vector< GUM_SCALAR >(dSize, 1));
        oldMarginalMin_.insert(node, std::vector< GUM_SCALAR >(dSize, 1));
 
        marginalMax_.insert(node, std::vector< GUM_SCALAR >(dSize, 0));
        oldMarginalMax_.insert(node, std::vector< GUM_SCALAR >(dSize, 0));
      }
 
      // now that we know the sizes of marginalMin_ and marginalMax_, we can
      // dispatch their processes to the threads
      dispatchMarginalsToThreads_();
    }

References credalNet_, dispatchMarginalsToThreads_(), marginalMax_, marginalMin_, oldMarginalMax_, and oldMarginalMin_.

Referenced by InferenceEngine(), and eraseAllEvidence().

Here is the call graph for this function:

Here is the caller graph for this function:

initMarginalSets_()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::initMarginalSets_ ( )

protectedinherited

Initialize credal set vertices with empty sets.

Definition at line 665 of file inferenceEngine_tpl.h.

                                                          {
      marginalSets_.clear();
 
      if (!storeVertices_) return;
 
      for (auto node: credalNet_->current_bn().nodes())
        marginalSets_.insert(node, std::vector< std::vector< GUM_SCALAR > >());
    }

References credalNet_, marginalSets_, and storeVertices_.

Referenced by eraseAllEvidence(), and storeVertices().

Here is the caller graph for this function:

insertEvidence() [1/2]

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::insertEvidence ( const NodeProperty< std::vector< GUM_SCALAR > > & evidence )

inherited

Insert evidence from Property.

Parameters

evidence

The on nodes Property containing likelihoods.

Definition at line 268 of file inferenceEngine_tpl.h.

                                                                 {
      if (!evidence_.empty()) evidence_.clear();
 
      // use cbegin() to get const_iterator when available in aGrUM hashtables
      for (const auto& elt: evidence) {
        if (!credalNet_->current_bn().exists(elt.first)) continue;
 
        evidence_.insert(elt.first, elt.second);
      }
 
      // forces the computation of the begin iterator to avoid subsequent data races
      // @TODO make HashTableConstIterator constructors thread safe
      evidence_.begin();
    }

References credalNet_, and evidence_.

insertEvidence() [2/2]

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::insertEvidence ( const std::map< std::string, std::vector< GUM_SCALAR > > & eviMap )

inherited

Insert evidence from map.

Parameters

eviMap

The map variable name - likelihood.

Definition at line 247 of file inferenceEngine_tpl.h.

                                                                    {
      if (!evidence_.empty()) evidence_.clear();
 
      for (auto it = eviMap.cbegin(), theEnd = eviMap.cend(); it != theEnd; ++it) {
        if (!credalNet_->current_bn().exists(it->first)) continue;
 
        NodeId id = credalNet_->current_bn().idFromName(it->first);
 
        evidence_.insert(id, it->second);
      }
 
      // forces the computation of the begin iterator to avoid subsequent data races
      // @TODO make HashTableConstIterator constructors thread safe
      evidence_.begin();
    }

References credalNet_, and evidence_.

Referenced by makeInference().

Here is the caller graph for this function:

insertEvidenceFile()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CNLoopyPropagation< GUM_SCALAR >::insertEvidenceFile ( std::string_view path )

overridevirtual

Starts the inference.

Reimplemented from gum::credal::InferenceEngine< GUM_SCALAR >.

Definition at line 1536 of file CNLoopyPropagation_tpl.h.

                                                                               {
    InferenceEngine< GUM_SCALAR >::insertEvidenceFile(path);
  }

References gum::credal::InferenceEngine< GUM_SCALAR >::insertEvidenceFile().

Here is the call graph for this function:

insertModals()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::insertModals ( const std::map< std::string, std::vector< GUM_SCALAR > > & modals )

inherited

Insert variables modalities from map to compute expectations.

Parameters

modals

The map variable name - modalities.

Definition at line 216 of file inferenceEngine_tpl.h.

                                                                    {
      if (!modal_.empty()) modal_.clear();
 
      for (auto it = modals.cbegin(), theEnd = modals.cend(); it != theEnd; ++it) {
        if (!credalNet_->current_bn().exists(it->first)) continue;
 
        NodeId id = credalNet_->current_bn().idFromName(it->first);
 
        // check that modals are net compatible
        auto dSize = credalNet_->current_bn().variable(id).domainSize();
 
        if (dSize != it->second.size()) continue;
 
        // GUM_ERROR(OperationNotAllowed, "void InferenceEngine< GUM_SCALAR
        // >::insertModals( const std::map< std::string, std::vector< GUM_SCALAR
        // > >
        // &modals) : modalities does not respect variable cardinality : " <<
        // credalNet_->current_bn().variable( id ).name() << " : " << dSize << "
        // != "
        // << it->second.size());
 
        modal_.insert(it->first, it->second);   //[ it->first ] = it->second;
      }
 
      //_modal = modals;
 
      initExpectations_();
    }

References credalNet_, and modal_.

Referenced by makeInference().

Here is the caller graph for this function:

insertModalsFile()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::insertModalsFile ( std::string_view path )

inherited

Insert variables modalities from file to compute expectations.

Parameters

path	The path to the modalities file.

Definition at line 169 of file inferenceEngine_tpl.h.

                                                                            {
      std::ifstream mod_stream(std::string(path), std::ios::in);
 
      if (!mod_stream.good()) {
        GUM_ERROR(OperationNotAllowed,
                  "void InferenceEngine< GUM_SCALAR "
                  ">::insertModals(const std::string & path) : "
                  "could not open input file : "
                      << path);
      }
 
      if (!modal_.empty()) modal_.clear();
 
      std::string line, tmp;
      char *      cstr, *p;
 
      while (mod_stream.good()) {
        getline(mod_stream, line);
 
        if (line.size() == 0) continue;
 
        cstr = new char[line.size() + 1];
        strcpy(cstr, line.c_str());
 
        p   = strtok(cstr, " ");
        tmp = p;
 
        std::vector< GUM_SCALAR > values;
        p = strtok(nullptr, " ");
 
        while (p != nullptr) {
          values.push_back(GUM_SCALAR(atof(p)));
          p = strtok(nullptr, " ");
        }   // end of : line
 
        modal_.insert(tmp, values);   //[tmp] = values;
 
        delete[] p;
        delete[] cstr;
      }   // end of : file
 
      mod_stream.close();
 
      initExpectations_();
    }

References GUM_ERROR, and modal_.

Referenced by makeInference().

Here is the caller graph for this function:

insertQuery()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::insertQuery ( const NodeProperty< std::vector< bool > > & query )

inherited

Insert query variables and states from Property.

Parameters

query

The on nodes Property containing queried variables states.

Definition at line 346 of file inferenceEngine_tpl.h.

                                                        {
      if (!query_.empty()) query_.clear();
 
      for (const auto& elt: query) {
        if (!credalNet_->current_bn().exists(elt.first)) continue;
 
        query_.insert(elt.first, elt.second);
      }
    }

References query_.

Referenced by makeInference().

Here is the caller graph for this function:

insertQueryFile()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::insertQueryFile ( std::string_view path )

inherited

Insert query variables states from file.

Parameters

path	The path to the query file.

Definition at line 358 of file inferenceEngine_tpl.h.

                                                                           {
      std::ifstream evi_stream(std::string(path), std::ios::in);
 
      if (!evi_stream.good()) {
        GUM_ERROR(IOError,
                  "void InferenceEngine< GUM_SCALAR >::insertQuery(const "
                  "std::string & path) : could not open input file : "
                      << path);
      }
 
      if (!query_.empty()) query_.clear();
 
      std::string line, tmp;
      char *      cstr, *p;
 
      while (evi_stream.good() && std::strcmp(line.c_str(), "[QUERY]") != 0) {
        getline(evi_stream, line);
      }
 
      while (evi_stream.good()) {
        getline(evi_stream, line);
 
        if (std::strcmp(line.c_str(), "[EVIDENCE]") == 0) break;
 
        if (line.size() == 0) continue;
 
        cstr = new char[line.size() + 1];
        strcpy(cstr, line.c_str());
 
        p   = strtok(cstr, " ");
        tmp = p;
 
        // if user input is wrong
        NodeId node = -1;
 
        if (!credalNet_->current_bn().exists(tmp)) continue;
        node = credalNet_->current_bn().idFromName(tmp);
 
        auto dSize = credalNet_->current_bn().variable(node).domainSize();
 
        p = strtok(nullptr, " ");
 
        if (p == nullptr) {
          query_.insert(node, std::vector< bool >(dSize, true));
        } else {
          std::vector< bool > values(dSize, false);
 
          while (p != nullptr) {
            if ((Size)atoi(p) >= dSize)
              GUM_ERROR(OutOfBounds,
                        "void InferenceEngine< GUM_SCALAR "
                        ">::insertQuery(const std::string & path) : "
                        "query modality is higher or equal to "
                        "cardinality");
 
            values[atoi(p)] = true;
            p               = strtok(nullptr, " ");
          }   // end of : line
 
          query_.insert(node, values);
        }
 
        delete[] p;
        delete[] cstr;
      }   // end of : file
 
      evi_stream.close();
    }

References GUM_ERROR.

Referenced by makeInference().

Here is the caller graph for this function:

isEnabledEpsilon()

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

overridevirtualinherited

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

Returns

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

Implements gum::IApproximationSchemeConfiguration.

Definition at line 82 of file approximationScheme_inl.h.

{ return enabled_eps_; }

References enabled_eps_.

Referenced by gum::learning::IBNLearner::EMisEnabledEpsilon(), and gum::learning::IBNLearner::isEnabledEpsilon().

Here is the caller graph for this function:

isEnabledMaxIter()

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

overridevirtualinherited

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

Returns

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

Implements gum::IApproximationSchemeConfiguration.

Definition at line 123 of file approximationScheme_inl.h.

{ return enabled_max_iter_; }

References enabled_max_iter_.

Referenced by gum::learning::IBNLearner::EMisEnabledMaxIter(), and gum::learning::IBNLearner::isEnabledMaxIter().

Here is the caller graph for this function:

isEnabledMaxTime()

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

overridevirtualinherited

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

Returns

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

Implements gum::IApproximationSchemeConfiguration.

Definition at line 147 of file approximationScheme_inl.h.

{ return enabled_max_time_; }

References enabled_max_time_.

Referenced by gum::learning::IBNLearner::EMisEnabledMaxTime(), and gum::learning::IBNLearner::isEnabledMaxTime().

Here is the caller graph for this function:

isEnabledMinEpsilonRate()

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

overridevirtualinherited

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

Returns

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

Implements gum::IApproximationSchemeConfiguration.

Definition at line 103 of file approximationScheme_inl.h.

{ return enabled_min_rate_eps_; }

References enabled_min_rate_eps_.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::computeKL_(), gum::MCBNDistance< GUM_SCALAR >::computeKL_(), gum::learning::IBNLearner::EMisEnabledMinEpsilonRate(), and gum::learning::IBNLearner::isEnabledMinEpsilonRate().

Here is the caller graph for this function:

isGumNumberOfThreadsOverriden()

bool gum::ThreadNumberManager::isGumNumberOfThreadsOverriden ( ) const

nodiscardoverridevirtualinherited

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

Implements gum::IThreadNumberManager.

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

Here is the caller graph for this function:

makeInference()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CNLoopyPropagation< GUM_SCALAR >::makeInference ( )

overridevirtual

Starts the inference.

Implements gum::credal::InferenceEngine< GUM_SCALAR >.

Definition at line 555 of file CNLoopyPropagation_tpl.h.

                                                       {
    if (inference_up_to_date_) { return; }
 
    initialize_();
 
    _infE_::initApproximationScheme();
 
    switch (_inferenceType_) {
      case InferenceType::nodeToNeighbours : makeInferenceNodeToNeighbours_(); break;
 
      case InferenceType::ordered : makeInferenceByOrderedArcs_(); break;
 
      case InferenceType::randomOrder : makeInferenceByRandomOrder_(); break;
    }
 
    //_updateMarginals();
    updateIndicatrices_();   // will call updateMarginals_()
 
    computeExpectations_();
 
    inference_up_to_date_ = true;
  }

References _inferenceType_, computeExpectations_(), inference_up_to_date_, gum::ApproximationScheme::initApproximationScheme(), initialize_(), makeInferenceByOrderedArcs_(), makeInferenceByRandomOrder_(), makeInferenceNodeToNeighbours_(), nodeToNeighbours, ordered, randomOrder, and updateIndicatrices_().

Here is the call graph for this function:

makeInferenceByOrderedArcs_()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CNLoopyPropagation< GUM_SCALAR >::makeInferenceByOrderedArcs_ ( )

protected

Starts the inference with this inference type.

Definition at line 813 of file CNLoopyPropagation_tpl.h.

                                                                     {
    Size nbrArcs = _bnet_->dag().sizeArcs();
 
    std::vector< cArcP > seq;
    seq.reserve(nbrArcs);
 
    for (const auto& arc: _bnet_->arcs()) {
      seq.push_back(&arc);
    }
 
    GUM_SCALAR eps;
    // validate TestSuite
    _infE_::continueApproximationScheme(1.);
 
    do {
      for (const auto it: seq) {
        if (_cn_->currentNodeType(it->tail()) == CredalNet< GUM_SCALAR >::NodeType::Indic
            || _cn_->currentNodeType(it->head()) == CredalNet< GUM_SCALAR >::NodeType::Indic) {
          continue;
        }
 
        msgP_(it->tail(), it->head());
        msgL_(it->head(), it->tail());
      }
 
      eps = calculateEpsilon_();
 
      _infE_::updateApproximationScheme();
 
    } while (_infE_::continueApproximationScheme(eps));
  }

References _bnet_, _cn_, calculateEpsilon_(), gum::ApproximationScheme::continueApproximationScheme(), gum::credal::CredalNet< GUM_SCALAR >::Indic, msgL_(), msgP_(), and gum::ApproximationScheme::updateApproximationScheme().

Referenced by makeInference().

Here is the call graph for this function:

Here is the caller graph for this function:

makeInferenceByRandomOrder_()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CNLoopyPropagation< GUM_SCALAR >::makeInferenceByRandomOrder_ ( )

protected

Starts the inference with this inference type.

Definition at line 768 of file CNLoopyPropagation_tpl.h.

                                                                     {
    Size nbrArcs = _bnet_->dag().sizeArcs();
 
    std::vector< cArcP > seq;
    seq.reserve(nbrArcs);
 
    for (const auto& arc: _bnet_->arcs()) {
      seq.push_back(&arc);
    }
 
    GUM_SCALAR eps;
    // validate TestSuite
    _infE_::continueApproximationScheme(1.);
 
    do {
      for (Size j = 0, theEnd = nbrArcs / 2; j < theEnd; j++) {
        auto w1 = randomValue(nbrArcs);
        auto w2 = randomValue(nbrArcs);
 
        if (w1 == w2) { continue; }
 
        std::swap(seq[w1], seq[w2]);
      }
 
      for (const auto it: seq) {
        if (_cn_->currentNodeType(it->tail()) == CredalNet< GUM_SCALAR >::NodeType::Indic
            || _cn_->currentNodeType(it->head()) == CredalNet< GUM_SCALAR >::NodeType::Indic) {
          continue;
        }
 
        msgP_(it->tail(), it->head());
        msgL_(it->head(), it->tail());
      }
 
      eps = calculateEpsilon_();
 
      _infE_::updateApproximationScheme();
 
    } while (_infE_::continueApproximationScheme(eps));
  }

References _bnet_, _cn_, calculateEpsilon_(), gum::ApproximationScheme::continueApproximationScheme(), gum::credal::CredalNet< GUM_SCALAR >::Indic, msgL_(), msgP_(), gum::randomValue(), and gum::ApproximationScheme::updateApproximationScheme().

Referenced by makeInference().

Here is the call graph for this function:

Here is the caller graph for this function:

makeInferenceNodeToNeighbours_()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CNLoopyPropagation< GUM_SCALAR >::makeInferenceNodeToNeighbours_ ( )

protected

Starts the inference with this inference type.

Definition at line 730 of file CNLoopyPropagation_tpl.h.

                                                                        {
    const DAG& graphe = _bnet_->dag();
 
    GUM_SCALAR eps;
    // to validate TestSuite
    _infE_::continueApproximationScheme(1.);
 
    do {
      for (auto node: active_nodes_set_) {
        for (auto chil: graphe.children(node)) {
          if (_cn_->currentNodeType(chil) == CredalNet< GUM_SCALAR >::NodeType::Indic) { continue; }
 
          msgP_(node, chil);
        }
 
        for (auto par: graphe.parents(node)) {
          if (_cn_->currentNodeType(node) == CredalNet< GUM_SCALAR >::NodeType::Indic) { continue; }
 
          msgL_(node, par);
        }
      }
 
      eps = calculateEpsilon_();
 
      _infE_::updateApproximationScheme();
 
      active_nodes_set_.clear();
      active_nodes_set_ = next_active_nodes_set_;
      next_active_nodes_set_.clear();
 
    } while (_infE_::continueApproximationScheme(eps) && active_nodes_set_.size() > 0);
 
    _infE_::stopApproximationScheme();   // just to be sure of the
    // approximationScheme has been notified of
    // the end of looop
  }

References _bnet_, _cn_, active_nodes_set_, calculateEpsilon_(), gum::ArcGraphPart::children(), gum::ApproximationScheme::continueApproximationScheme(), gum::credal::CredalNet< GUM_SCALAR >::Indic, msgL_(), msgP_(), next_active_nodes_set_, gum::ArcGraphPart::parents(), gum::ApproximationScheme::stopApproximationScheme(), and gum::ApproximationScheme::updateApproximationScheme().

Referenced by makeInference().

Here is the call graph for this function:

Here is the caller graph for this function:

marginalMax() [1/2]

template<GUM_Numeric GUM_SCALAR>

gum::Tensor< GUM_SCALAR > gum::credal::InferenceEngine< GUM_SCALAR >::marginalMax ( const NodeId id ) const

inherited

Get the upper marginals of a given node id.

Parameters

id	The node id which upper marginals we want.

Returns

A constant reference to this node upper marginals.

Definition at line 448 of file inferenceEngine_tpl.h.

                                                                                            {
      Tensor< GUM_SCALAR > res;
      res.add(credalNet_->current_bn().variable(id));
      res.fillWith(marginalMax_[id]);
      return res;
    }

Referenced by makeInference(), and marginalMax().

Here is the caller graph for this function:

marginalMax() [2/2]

template<GUM_Numeric GUM_SCALAR>

Tensor< GUM_SCALAR > gum::credal::InferenceEngine< GUM_SCALAR >::marginalMax ( std::string_view varName ) const

inherited

Get the upper marginals of a given variable name.

Parameters

varName

The variable name which upper marginals we want.

Returns

A constant reference to this variable upper marginals.

Definition at line 435 of file inferenceEngine_tpl.h.

                                                                               {
      return marginalMax(credalNet_->current_bn().idFromName(varName));
    }

References credalNet_, and marginalMax().

Here is the call graph for this function:

marginalMin() [1/2]

template<GUM_Numeric GUM_SCALAR>

gum::Tensor< GUM_SCALAR > gum::credal::InferenceEngine< GUM_SCALAR >::marginalMin ( const NodeId id ) const

inherited

Get the lower marginals of a given node id.

Parameters

id	The node id which lower marginals we want.

Returns

A constant reference to this node lower marginals.

Definition at line 440 of file inferenceEngine_tpl.h.

                                                                                            {
      Tensor< GUM_SCALAR > res;
      res.add(credalNet_->current_bn().variable(id));
      res.fillWith(marginalMin_[id]);
      return res;
    }

References credalNet_, and marginalMin_.

Referenced by makeInference(), and marginalMin().

Here is the caller graph for this function:

marginalMin() [2/2]

template<GUM_Numeric GUM_SCALAR>

Tensor< GUM_SCALAR > gum::credal::InferenceEngine< GUM_SCALAR >::marginalMin ( std::string_view varName ) const

inherited

Get the lower marginals of a given variable name.

Parameters

varName

The variable name which lower marginals we want.

Returns

A constant reference to this variable lower marginals.

Definition at line 429 of file inferenceEngine_tpl.h.

                                                                               {
      return marginalMin(credalNet_->current_bn().idFromName(varName));
    }

References credalNet_, and marginalMin().

Here is the call graph for this function:

maxIter()

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

overridevirtualinherited

Returns the criterion on number of iterations.

Returns

Returns the criterion on number of iterations.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 113 of file approximationScheme_inl.h.

{ return max_iter_; }

References max_iter_.

Referenced by gum::learning::IBNLearner::EMMaxIter(), and gum::learning::IBNLearner::maxIter().

Here is the caller graph for this function:

maxTime()

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

overridevirtualinherited

Returns the timeout (in seconds).

Returns

Returns the timeout (in seconds).

Implements gum::IApproximationSchemeConfiguration.

Definition at line 134 of file approximationScheme_inl.h.

{ return max_time_; }

References max_time_.

Referenced by gum::learning::IBNLearner::EMMaxTime(), and gum::learning::IBNLearner::maxTime().

Here is the caller graph for this function:

messageApproximationScheme()

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

inherited

Returns the approximation scheme message.

Returns

Returns the approximation scheme message.

Definition at line 64 of file IApproximationSchemeConfiguration.cpp.

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

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

minEpsilonRate()

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

overridevirtualinherited

Returns the value of the minimal epsilon rate.

Returns

Returns the value of the minimal epsilon rate.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 93 of file approximationScheme_inl.h.

{ return min_rate_eps_; }

References min_rate_eps_.

Referenced by gum::learning::IBNLearner::EMMinEpsilonRate(), and gum::learning::IBNLearner::minEpsilonRate().

Here is the caller graph for this function:

msgL_()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CNLoopyPropagation< GUM_SCALAR >::msgL_ ( const NodeId X, const NodeId demanding_parent )

protected

Sends a message to one's parent, i.e.

X is sending a message to a demanding_parent.

Parameters

X	The constant node id of the node sending the message.
demanding_parent	The constant node id of the node receiving the message.

Definition at line 846 of file CNLoopyPropagation_tpl.h.

                                                                             {
    NodeSet const& children = _bnet_->children(Y);
    NodeSet const& parents_ = _bnet_->parents(Y);
 
    const auto parents = &_bnet_->cpt(Y).variablesSequence();
 
    if (((children.size() + parents->size() - 1) == 1) && (!_infE_::evidence_.exists(Y))) {
      return;
    }
 
    bool update_l = update_l_[Y];
    bool update_p = update_p_[Y];
 
    if (!update_p && !update_l) { return; }
 
    msg_l_sent_[Y]->insert(X);
 
    // for future refresh LM/PI
    if (msg_l_sent_[Y]->size() == parents_.size()) {
      msg_l_sent_[Y]->clear();
      update_l_[Y] = false;
    }
 
    // refresh LM_part
    if (update_l) {
      if (!children.empty() && !_infE_::evidence_.exists(Y)) {
        GUM_SCALAR lmin = 1.;
        GUM_SCALAR lmax = 1.;
 
        for (const NodeId chil: children) {
          const Arc arc_YC{Y, chil};
          lmin *= ArcsL_min_[arc_YC];
 
          if (ArcsL_max_.exists(arc_YC)) {
            lmax *= ArcsL_max_[arc_YC];
          } else {
            lmax *= ArcsL_min_[arc_YC];
          }
        }
 
        lmin = lmax;
 
        if (lmax != lmax && lmin == lmin) { lmax = lmin; }
 
        if (lmax != lmax && lmin != lmin) {
          std::cout << "no likelihood defined [lmin, lmax] (incompatibles "
                       "evidence ?)"
                    << std::endl;
        }
 
        if (lmin < 0.) { lmin = 0.; }
 
        if (lmax < 0.) { lmax = 0.; }
 
        // no need to update nodeL if evidence since nodeL will never be used
 
        NodesL_min_[Y] = lmin;
 
        if (lmin != lmax) {
          NodesL_max_.set(Y, lmax);
        } else if (NodesL_max_.exists(Y)) {
          NodesL_max_.erase(Y);
        }
 
      }   // end of : node has children & no evidence
 
    }   // end of : if update_l
 
    GUM_SCALAR lmin = NodesL_min_[Y];
    GUM_SCALAR lmax;
 
    if (NodesL_max_.exists(Y)) {
      lmax = NodesL_max_[Y];
    } else {
      lmax = lmin;
    }

 
    const Arc arc_XY{X, Y};
    if (lmin == lmax && lmin == 1.) {
      ArcsL_min_[arc_XY] = lmin;
 
      if (ArcsL_max_.exists(arc_XY)) { ArcsL_max_.erase(arc_XY); }
 
      return;
    }
 
    // garder pour chaque noeud un table des parents maj, une fois tous maj,
    // stop
    // jusque notification msg L ou P
 
    if (update_p || update_l) {
      std::vector< std::vector< std::vector< GUM_SCALAR > > > msgs_p;
      std::vector< std::vector< GUM_SCALAR > >                msg_p;
      std::vector< GUM_SCALAR >                               distri(2);
 
      Idx pos;
 
      // +1 from start to avoid counting_ itself
      // use const iterators with cbegin when available
      for (auto jt = ++parents->begin(), theEnd = parents->end(); jt != theEnd; ++jt) {
        if (_bnet_->nodeId(**jt) == X) {
          // retirer la variable courante de la taille
          pos = parents->pos(*jt) - 1;
          continue;
        }
 
        // compute probability distribution to avoid doing it multiple times
        // (at each combination of messages)
        const Arc arc_PY{_bnet_->nodeId(**jt), Y};
        distri[1] = ArcsP_min_[arc_PY];
        distri[0] = GUM_SCALAR(1.) - distri[1];
        msg_p.push_back(distri);
 
        if (ArcsP_max_.exists(arc_PY)) {
          distri[1] = ArcsP_max_[arc_PY];
          distri[0] = GUM_SCALAR(1.) - distri[1];
          msg_p.push_back(distri);
        }
 
        msgs_p.push_back(msg_p);
        msg_p.clear();
      }
 
      GUM_SCALAR min = -2.;
      GUM_SCALAR max = -2.;
 
      std::vector< GUM_SCALAR > lx;
      lx.push_back(lmin);
 
      if (lmin != lmax) { lx.push_back(lmax); }
 
      enum_combi_(msgs_p, Y, min, max, lx, pos);
 
      if (min == -2. || max == -2.) {
        if (min != -2.) {
          max = min;
        } else if (max != -2.) {
          min = max;
        } else {
          std::cout << std::endl;
          std::cout << "!!!! pas de message L calculable !!!!" << std::endl;
          return;
        }
      }
 
      if (min < 0.) { min = 0.; }
 
      if (max < 0.) { max = 0.; }
 
      bool update = false;
 
      if (min != ArcsL_min_[arc_XY]) {
        ArcsL_min_[arc_XY] = min;
        update             = true;
      }
 
      if (ArcsL_max_.exists(arc_XY)) {
        if (max != ArcsL_max_[arc_XY]) {
          if (max != min) {
            ArcsL_max_[arc_XY] = max;
          } else {   // if ( max == min )
            ArcsL_max_.erase(arc_XY);
          }
 
          update = true;
        }
      } else {
        if (max != min) {
          ArcsL_max_.insert(arc_XY, max);
          update = true;
        }
      }
 
      if (update) {
        update_l_.set(X, true);
        next_active_nodes_set_.insert(X);
      }
 
    }   // end of update_p || update_l
  }

References _bnet_, ArcsL_max_, ArcsL_min_, ArcsP_max_, ArcsP_min_, gum::Set< Key >::empty(), enum_combi_(), gum::credal::InferenceEngine< GUM_SCALAR >::evidence_, gum::Set< Key >::insert(), msg_l_sent_, next_active_nodes_set_, NodesL_max_, NodesL_min_, gum::Set< Key >::size(), update_l_, and update_p_.

Referenced by makeInferenceByOrderedArcs_(), makeInferenceByRandomOrder_(), and makeInferenceNodeToNeighbours_().

Here is the call graph for this function:

Here is the caller graph for this function:

msgP_()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CNLoopyPropagation< GUM_SCALAR >::msgP_ ( const NodeId X, const NodeId demanding_child )

protected

Sends a message to one's child, i.e.

X is sending a message to a demanding_child.

Parameters

X	The constant node id of the node sending the message.
demanding_child	The constant node id of the node receiving the message.

Definition at line 1032 of file CNLoopyPropagation_tpl.h.

                                                                                           {
    NodeSet const& children = _bnet_->children(X);
 
    const auto parents = &_bnet_->cpt(X).variablesSequence();
 
    if (((children.size() + parents->size() - 1) == 1) && (!_infE_::evidence_.exists(X))) {
      return;
    }
 
    // LM_part ---- from all children but one --- the lonely one will get the
    // message
 
    const Arc arc_XDC{X, demanding_child};
    if (_infE_::evidence_.exists(X)) {
      ArcsP_min_[arc_XDC] = _infE_::evidence_[X][1];
 
      if (ArcsP_max_.exists(arc_XDC)) { ArcsP_max_.erase(arc_XDC); }
 
      return;
    }
 
    bool update_l = update_l_[X];
    bool update_p = update_p_[X];
 
    if (!update_p && !update_l) { return; }
 
    GUM_SCALAR lmin = 1.;
    GUM_SCALAR lmax = 1.;
 
    // use cbegin if available
    for (auto chil: children) {
      if (chil == demanding_child) { continue; }
 
      const Arc arc_XC{X, chil};
      lmin *= ArcsL_min_[arc_XC];
 
      if (ArcsL_max_.exists(arc_XC)) {
        lmax *= ArcsL_max_[arc_XC];
      } else {
        lmax *= ArcsL_min_[arc_XC];
      }
    }
 
    if (lmin != lmin && lmax == lmax) { lmin = lmax; }
 
    if (lmax != lmax && lmin == lmin) { lmax = lmin; }
 
    if (lmax != lmax && lmin != lmin) {
      std::cout << "pas de vraisemblance definie [lmin, lmax] (observations "
                   "incompatibles ?)"
                << std::endl;
      return;
    }
 
    if (lmin < 0.) { lmin = 0.; }
 
    if (lmax < 0.) { lmax = 0.; }
 
    // refresh PI_part
    GUM_SCALAR min = INF_;
    GUM_SCALAR max = 0.;
 
    if (update_p) {
      std::vector< std::vector< std::vector< GUM_SCALAR > > > msgs_p;
      std::vector< std::vector< GUM_SCALAR > >                msg_p;
      std::vector< GUM_SCALAR >                               distri(2);
 
      // +1 from start to avoid counting_ itself
      // use const_iterators if available
      for (auto jt = ++parents->begin(), theEnd = parents->end(); jt != theEnd; ++jt) {
        // compute probability distribution to avoid doing it multiple times
        // (at each combination of messages)
        const Arc arc_PX{_bnet_->nodeId(**jt), X};
        distri[1] = ArcsP_min_[arc_PX];
        distri[0] = GUM_SCALAR(1.) - distri[1];
        msg_p.push_back(distri);
 
        if (ArcsP_max_.exists(arc_PX)) {
          distri[1] = ArcsP_max_[arc_PX];
          distri[0] = GUM_SCALAR(1.) - distri[1];
          msg_p.push_back(distri);
        }
 
        msgs_p.push_back(msg_p);
        msg_p.clear();
      }
 
      enum_combi_(msgs_p, X, min, max);
 
      if (min < 0.) { min = 0.; }
 
      if (max < 0.) { max = 0.; }
 
      if (min == INF_ || max == INF_) {
        std::cout << " ERREUR msg P min = max = INF " << std::endl;
        std::cout.flush();
        return;
      }
 
      NodesP_min_[X] = min;
 
      if (min != max) {
        NodesP_max_.set(X, max);
      } else if (NodesP_max_.exists(X)) {
        NodesP_max_.erase(X);
      }
 
      update_p_.set(X, false);
 
    }   // end of update_p
    else {
      min = NodesP_min_[X];
 
      if (NodesP_max_.exists(X)) {
        max = NodesP_max_[X];
      } else {
        max = min;
      }
    }
 
    if (update_p || update_l) {
      GUM_SCALAR msg_p_min;
      GUM_SCALAR msg_p_max;
 
      // cas limites sur min
      if (min == INF_ && lmin == 0.) {
        std::cout << "MESSAGE P ERR (negatif) : pi = inf, l = 0" << std::endl;
      }
 
      if (lmin == INF_) {   // cas infini
        msg_p_min = GUM_SCALAR(1.);
      } else if (min == 0. || lmin == 0.) {
        msg_p_min = 0;
      } else {
        msg_p_min = GUM_SCALAR(1. / (1. + ((1. / min - 1.) * 1. / lmin)));
      }
 
      // cas limites sur max
      if (max == INF_ && lmax == 0.) {
        std::cout << "MESSAGE P ERR (negatif) : pi = inf, l = 0" << std::endl;
      }
 
      if (lmax == INF_) {   // cas infini
        msg_p_max = GUM_SCALAR(1.);
      } else if (max == 0. || lmax == 0.) {
        msg_p_max = 0;
      } else {
        msg_p_max = GUM_SCALAR(1. / (1. + ((1. / max - 1.) * 1. / lmax)));
      }
 
      if (msg_p_min != msg_p_min && msg_p_max == msg_p_max) {
        msg_p_min = msg_p_max;
        std::cout << std::endl;
        std::cout << "msg_p_min is NaN" << std::endl;
      }
 
      if (msg_p_max != msg_p_max && msg_p_min == msg_p_min) {
        msg_p_max = msg_p_min;
        std::cout << std::endl;
        std::cout << "msg_p_max is NaN" << std::endl;
      }
 
      if (msg_p_max != msg_p_max && msg_p_min != msg_p_min) {
        std::cout << std::endl;
        std::cout << "pas de message P calculable (verifier observations)" << std::endl;
        return;
      }
 
      if (msg_p_min < 0.) { msg_p_min = 0.; }
 
      if (msg_p_max < 0.) { msg_p_max = 0.; }
 
      bool update = false;
 
      if (msg_p_min != ArcsP_min_[arc_XDC]) {
        ArcsP_min_[arc_XDC] = msg_p_min;
        update              = true;
      }
 
      if (ArcsP_max_.exists(arc_XDC)) {
        if (msg_p_max != ArcsP_max_[arc_XDC]) {
          if (msg_p_max != msg_p_min) {
            ArcsP_max_[arc_XDC] = msg_p_max;
          } else {   // if ( msg_p_max == msg_p_min )
            ArcsP_max_.erase(arc_XDC);
          }
 
          update = true;
        }
      } else {
        if (msg_p_max != msg_p_min) {
          ArcsP_max_.insert(arc_XDC, msg_p_max);
          update = true;
        }
      }
 
      if (update) {
        update_p_.set(demanding_child, true);
        next_active_nodes_set_.insert(demanding_child);
      }
 
    }   // end of : update_l || update_p
  }

References _bnet_, ArcsL_max_, ArcsL_min_, ArcsP_max_, ArcsP_min_, enum_combi_(), gum::credal::InferenceEngine< GUM_SCALAR >::evidence_, INF_, next_active_nodes_set_, NodesP_max_, NodesP_min_, gum::Set< Key >::size(), update_l_, and update_p_.

Referenced by makeInferenceByOrderedArcs_(), makeInferenceByRandomOrder_(), makeInferenceNodeToNeighbours_(), and updateIndicatrices_().

Here is the call graph for this function:

Here is the caller graph for this function:

nbrIterations()

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

overridevirtualinherited

Returns the number of iterations.

Returns

Returns the number of iterations.

Exceptions

OperationNotAllowed

Raised if the scheme did not perform.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 170 of file approximationScheme_inl.h.

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

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

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::computeKL_(), gum::MCBNDistance< GUM_SCALAR >::computeKL_(), gum::learning::IBNLearner::EMnbrIterations(), and gum::learning::IBNLearner::nbrIterations().

Here is the call graph for this function:

Here is the caller graph for this function:

periodSize()

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

overridevirtualinherited

Returns the period size.

Returns

Returns the period size.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 156 of file approximationScheme_inl.h.

{ return period_size_; }

References period_size_.

Referenced by gum::learning::IBNLearner::EMPeriodSize(), and gum::learning::IBNLearner::periodSize().

Here is the caller graph for this function:

refreshLMsPIs_()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CNLoopyPropagation< GUM_SCALAR >::refreshLMsPIs_ ( bool refreshIndic = false )

protected

Get the last messages from one's parents and children.

Definition at line 1237 of file CNLoopyPropagation_tpl.h.

                                                                         {
    for (auto node: _bnet_->nodes()) {
      if ((!refreshIndic)
          && _cn_->currentNodeType(node) == CredalNet< GUM_SCALAR >::NodeType::Indic) {
        continue;
      }
 
      NodeSet const& children = _bnet_->children(node);
 
      auto parents = &_bnet_->cpt(node).variablesSequence();
 
      if (update_l_[node]) {
        GUM_SCALAR lmin = 1.;
        GUM_SCALAR lmax = 1.;
 
        if (!children.empty() && !_infE_::evidence_.exists(node)) {
          for (auto chil: children) {
            const Arc arc_NC{node, chil};
            lmin *= ArcsL_min_[arc_NC];
 
            if (ArcsL_max_.exists(arc_NC)) {
              lmax *= ArcsL_max_[arc_NC];
            } else {
              lmax *= ArcsL_min_[arc_NC];
            }
          }
 
          if (lmin != lmin && lmax == lmax) { lmin = lmax; }
 
          lmax = lmin;
 
          if (lmax != lmax && lmin != lmin) {
            std::cout << "pas de vraisemblance definie [lmin, lmax] (observations "
                         "incompatibles ?)"
                      << std::endl;
            return;
          }
 
          if (lmin < 0.) { lmin = 0.; }
 
          if (lmax < 0.) { lmax = 0.; }
 
          NodesL_min_[node] = lmin;
 
          if (lmin != lmax) {
            NodesL_max_.set(node, lmax);
          } else if (NodesL_max_.exists(node)) {
            NodesL_max_.erase(node);
          }
        }
 
      }   // end of : update_l
 
      if (update_p_[node]) {
        if ((parents->size() - 1) > 0 && !_infE_::evidence_.exists(node)) {
          std::vector< std::vector< std::vector< GUM_SCALAR > > > msgs_p;
          std::vector< std::vector< GUM_SCALAR > >                msg_p;
          std::vector< GUM_SCALAR >                               distri(2);
 
          // +1 from start to avoid counting_ itself
          // cbegin
          for (auto jt = ++parents->begin(), theEnd = parents->end(); jt != theEnd; ++jt) {
            // compute probability distribution to avoid doing it multiple
            // times (at each combination of messages)
            const Arc arc_PN{_bnet_->nodeId(**jt), node};
            distri[1] = ArcsP_min_[arc_PN];
            distri[0] = GUM_SCALAR(1.) - distri[1];
            msg_p.push_back(distri);
 
            if (ArcsP_max_.exists(arc_PN)) {
              distri[1] = ArcsP_max_[arc_PN];
              distri[0] = GUM_SCALAR(1.) - distri[1];
              msg_p.push_back(distri);
            }
 
            msgs_p.push_back(msg_p);
            msg_p.clear();
          }
 
          GUM_SCALAR min = INF_;
          GUM_SCALAR max = 0.;
 
          enum_combi_(msgs_p, node, min, max);
 
          if (min < 0.) { min = 0.; }
 
          if (max < 0.) { max = 0.; }
 
          NodesP_min_[node] = min;
 
          if (min != max) {
            NodesP_max_.set(node, max);
          } else if (NodesP_max_.exists(node)) {
            NodesP_max_.erase(node);
          }
 
          update_p_[node] = false;
        }
      }   // end of update_p
 
    }   // end of : for each node
  }

References _bnet_, _cn_, ArcsL_max_, ArcsL_min_, ArcsP_max_, ArcsP_min_, gum::Set< Key >::empty(), enum_combi_(), gum::credal::InferenceEngine< GUM_SCALAR >::evidence_, gum::credal::CredalNet< GUM_SCALAR >::Indic, INF_, NodesL_max_, NodesL_min_, NodesP_max_, NodesP_min_, update_l_, and update_p_.

Referenced by calculateEpsilon_(), and updateIndicatrices_().

Here is the call graph for this function:

Here is the caller graph for this function:

remainingBurnIn()

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

inherited

Returns the remaining burn in.

Returns

Returns the remaining burn in.

Definition at line 213 of file approximationScheme_inl.h.

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

References burn_in_, and current_step_.

repetitiveInd()

template<GUM_Numeric GUM_SCALAR>

bool gum::credal::InferenceEngine< GUM_SCALAR >::repetitiveInd ( ) const

inherited

Get the current independence status.

Returns

True if repetitive, False otherwise.

Definition at line 143 of file inferenceEngine_tpl.h.

                                                            {
      return repetitiveInd_;
    }

References repetitiveInd_.

Referenced by makeInference().

Here is the caller graph for this function:

repetitiveInit_()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::repetitiveInit_ ( )

protectedinherited

Initialize t0_ and t1_ clusters.

Definition at line 763 of file inferenceEngine_tpl.h.

                                                        {
      timeSteps_ = 0;
      t0_.clear();
      t1_.clear();
 
      // t = 0 vars belongs to t0_ as keys
      for (auto node: credalNet_->current_bn().internalDag().nodes()) {
        std::string var_name = credalNet_->current_bn().variable(node).name();
        auto        delim    = var_name.find_first_of("_");
 
        if (delim > var_name.size()) {
          GUM_ERROR(InvalidArgument,
                    "void InferenceEngine< GUM_SCALAR "
                    ">::repetitiveInit_() : the network does not "
                    "appear to be dynamic");
        }
 
        std::string time_step = var_name.substr(delim + 1, 1);
 
        if (time_step.compare("0") == 0) t0_.insert(node, std::vector< NodeId >());
      }
 
      // t = 1 vars belongs to either t0_ as member value or t1_ as keys
      for (const auto& node: credalNet_->current_bn().internalDag().nodes()) {
        std::string var_name  = credalNet_->current_bn().variable(node).name();
        auto        delim     = var_name.find_first_of("_");
        std::string time_step = var_name.substr(delim + 1, var_name.size());
        var_name              = var_name.substr(0, delim);
        delim                 = time_step.find_first_of("_");
        time_step             = time_step.substr(0, delim);
 
        if (time_step.compare("1") == 0) {
          bool found = false;
 
          for (const auto& elt: t0_) {
            std::string var_0_name = credalNet_->current_bn().variable(elt.first).name();
            delim                  = var_0_name.find_first_of("_");
            var_0_name             = var_0_name.substr(0, delim);
 
            if (var_name.compare(var_0_name) == 0) {
              const Tensor< GUM_SCALAR >* tensor(&credalNet_->current_bn().cpt(node));
              const Tensor< GUM_SCALAR >* tensor2(&credalNet_->current_bn().cpt(elt.first));
 
              if (tensor->domainSize() == tensor2->domainSize()) t0_[elt.first].push_back(node);
              else t1_.insert(node, std::vector< NodeId >());
 
              found = true;
              break;
            }
          }
 
          if (!found) { t1_.insert(node, std::vector< NodeId >()); }
        }
      }
 
      // t > 1 vars belongs to either t0_ or t1_ as member value
      // remember timeSteps_
      for (auto node: credalNet_->current_bn().internalDag().nodes()) {
        std::string var_name  = credalNet_->current_bn().variable(node).name();
        auto        delim     = var_name.find_first_of("_");
        std::string time_step = var_name.substr(delim + 1, var_name.size());
        var_name              = var_name.substr(0, delim);
        delim                 = time_step.find_first_of("_");
        time_step             = time_step.substr(0, delim);
 
        if (time_step.compare("0") != 0 && time_step.compare("1") != 0) {
          // keep max time_step
          if (atoi(time_step.c_str()) > timeSteps_) timeSteps_ = atoi(time_step.c_str());
 
          std::string var_0_name;
          bool        found = false;
 
          for (const auto& elt: t0_) {
            std::string var_0_name = credalNet_->current_bn().variable(elt.first).name();
            delim                  = var_0_name.find_first_of("_");
            var_0_name             = var_0_name.substr(0, delim);
 
            if (var_name.compare(var_0_name) == 0) {
              const Tensor< GUM_SCALAR >* tensor(&credalNet_->current_bn().cpt(node));
              const Tensor< GUM_SCALAR >* tensor2(&credalNet_->current_bn().cpt(elt.first));
 
              if (tensor->domainSize() == tensor2->domainSize()) {
                t0_[elt.first].push_back(node);
                found = true;
                break;
              }
            }
          }
 
          if (!found) {
            for (const auto& elt: t1_) {
              std::string var_0_name = credalNet_->current_bn().variable(elt.first).name();
              auto        delim      = var_0_name.find_first_of("_");
              var_0_name             = var_0_name.substr(0, delim);
 
              if (var_name.compare(var_0_name) == 0) {
                const Tensor< GUM_SCALAR >* tensor(&credalNet_->current_bn().cpt(node));
                const Tensor< GUM_SCALAR >* tensor2(&credalNet_->current_bn().cpt(elt.first));
 
                if (tensor->domainSize() == tensor2->domainSize()) {
                  t1_[elt.first].push_back(node);
                  break;
                }
              }
            }
          }
        }
      }
    }

References gum::HashTable< Key, Val >::clear(), credalNet_, GUM_ERROR, t0_, t1_, and timeSteps_.

Referenced by setRepetitiveInd().

Here is the call graph for this function:

Here is the caller graph for this function:

saveExpectations()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::saveExpectations ( std::string_view path ) const

inherited

Saves expectations to file.

Parameters

path	The path to the file to be used.

Definition at line 541 of file inferenceEngine_tpl.h.

                                                                                  {
      if (dynamicExpMin_.empty())   //_modal.empty())
        return;
 
      // else not here, to keep the const (natural with a saving process)
      // else if(dynamicExpMin_.empty() || dynamicExpMax_.empty())
      //_dynamicExpectations(); // works with or without a dynamic network
 
      std::ofstream m_stream(std::string(path), std::ios::out | std::ios::trunc);
 
      if (!m_stream.good()) {
        GUM_ERROR(IOError,
                  "void InferenceEngine< GUM_SCALAR "
                  ">::saveExpectations(const std::string & path) : could "
                  "not open output file : "
                      << path);
      }
 
      for (const auto& elt: dynamicExpMin_) {
        m_stream << elt.first;   // it->first;
 
        // iterates over a vector
        for (const auto& elt2: elt.second) {
          m_stream << " " << elt2;
        }
 
        m_stream << std::endl;
      }
 
      for (const auto& elt: dynamicExpMax_) {
        m_stream << elt.first;
 
        // iterates over a vector
        for (const auto& elt2: elt.second) {
          m_stream << " " << elt2;
        }
 
        m_stream << std::endl;
      }
 
      m_stream.close();
    }

Referenced by makeInference().

Here is the caller graph for this function:

saveInference()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CNLoopyPropagation< GUM_SCALAR >::saveInference

(

std::string_view

path

)

Deprecated

Use saveMarginals() from InferenceEngine instead. This one is easier to read but harder for scripts to parse.

Parameters

path	The path to the file to save marginals.

Definition at line 49 of file CNLoopyPropagation_tpl.h.

                                                                          {
    const std::string spath(path);
    std::string       path_name = spath.substr(0, spath.size() - 4);
    path_name                   = path_name + ".res";
 
    std::ofstream res(path_name.c_str(), std::ios::out | std::ios::trunc);
 
    if (!res.good()) {
      GUM_ERROR(NotFound,
                "CNLoopyPropagation<GUM_SCALAR>::saveInference(std::"
                "string & path) : could not open file : "
                    + path_name)
    }
 
 
    if (std::string ext = spath.substr(spath.size() - 3, spath.size());
        std::strcmp(ext.c_str(), "evi") == 0) {
      std::ifstream evi(spath.c_str(), std::ios::in);
      std::string   ligne;
 
      if (!evi.good()) {
        GUM_ERROR(NotFound,
                  "CNLoopyPropagation<GUM_SCALAR>::saveInference(std::"
                  "string & path) : could not open file : "
                      + ext)
      }
 
      while (evi.good()) {
        getline(evi, ligne);
        res << ligne << "\n";
      }
 
      evi.close();
    }
 
    res << "[RESULTATS]"
        << "\n";
 
    for (auto node: _bnet_->nodes()) {
      // calcul distri posteriori
      GUM_SCALAR msg_p_min = 1.0;
      GUM_SCALAR msg_p_max = 0.0;
 
      // cas evidence, calcul immediat
      if (_infE_::evidence_.exists(node)) {
        if (_infE_::evidence_[node][1] == 0.) {
          msg_p_min = 0.;
        } else if (_infE_::evidence_[node][1] == 1.) {
          msg_p_min = 1.;
        }
 
        msg_p_max = msg_p_min;
      }
      // sinon depuis node P et node L
      else {
        GUM_SCALAR min = NodesP_min_[node];
        GUM_SCALAR max;
 
        if (NodesP_max_.exists(node)) {
          max = NodesP_max_[node];
        } else {
          max = min;
        }
 
        GUM_SCALAR lmin = NodesL_min_[node];
        GUM_SCALAR lmax;
 
        if (NodesL_max_.exists(node)) {
          lmax = NodesL_max_[node];
        } else {
          lmax = lmin;
        }
 
        // cas limites sur min
        if (min == INF_ && lmin == 0.) {
          std::cout << "proba ERR (negatif) : pi = inf, l = 0" << std::endl;
        }
 
        if (lmin == INF_) {   // cas infini
          msg_p_min = GUM_SCALAR(1.);
        } else if (min == 0. || lmin == 0.) {
          msg_p_min = GUM_SCALAR(0.);
        } else {
          msg_p_min = GUM_SCALAR(1. / (1. + ((1. / min - 1.) * 1. / lmin)));
        }
 
        // cas limites sur max
        if (max == INF_ && lmax == 0.) {
          std::cout << "proba ERR (negatif) : pi = inf, l = 0" << std::endl;
        }
 
        if (lmax == INF_) {   // cas infini
          msg_p_max = GUM_SCALAR(1.);
        } else if (max == 0. || lmax == 0.) {
          msg_p_max = GUM_SCALAR(0.);
        } else {
          msg_p_max = GUM_SCALAR(1. / (1. + ((1. / max - 1.) * 1. / lmax)));
        }
      }
 
      if (msg_p_min != msg_p_min && msg_p_max == msg_p_max) { msg_p_min = msg_p_max; }
 
      if (msg_p_max != msg_p_max && msg_p_min == msg_p_min) { msg_p_max = msg_p_min; }
 
      if (msg_p_max != msg_p_max && msg_p_min != msg_p_min) {
        std::cout << std::endl;
        std::cout << "pas de proba calculable (verifier observations)" << std::endl;
      }
 
      res << "P(" << _bnet_->variable(node).name() << " | e) = ";
 
      if (_infE_::evidence_.exists(node)) {
        res << "(observe)" << std::endl;
      } else {
        res << std::endl;
      }
 
      res << "\t\t" << _bnet_->variable(node).label(0) << "  [ " << (GUM_SCALAR)1. - msg_p_max;
 
      if (msg_p_min != msg_p_max) {
        res << ", " << (GUM_SCALAR)1. - msg_p_min << " ] | ";
      } else {
        res << " ] | ";
      }
 
      res << _bnet_->variable(node).label(1) << "  [ " << msg_p_min;
 
      if (msg_p_min != msg_p_max) {
        res << ", " << msg_p_max << " ]" << std::endl;
      } else {
        res << " ]" << std::endl;
      }
    }   // end of : for each node
 
    res.close();
  }

References _bnet_, gum::credal::InferenceEngine< GUM_SCALAR >::evidence_, GUM_ERROR, INF_, NodesL_max_, NodesL_min_, NodesP_max_, and NodesP_min_.

saveMarginals()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::saveMarginals ( std::string_view path ) const

inherited

Saves marginals to file.

Parameters

path	The path to the file to be used.

Definition at line 518 of file inferenceEngine_tpl.h.

                                                                               {
      std::ofstream m_stream(std::string(path), std::ios::out | std::ios::trunc);
 
      if (!m_stream.good()) {
        GUM_ERROR(IOError,
                  "void InferenceEngine< GUM_SCALAR >::saveMarginals(const "
                  "std::string & path) const : could not open output file "
                  ": " << path);
      }
 
      for (const auto& elt: marginalMin_) {
        Size esize = Size(elt.second.size());
 
        for (Size mod = 0; mod < esize; mod++) {
          m_stream << credalNet_->current_bn().variable(elt.first).name() << " " << mod << " "
                   << (elt.second)[mod] << " " << marginalMax_[elt.first][mod] << std::endl;
        }
      }
 
      m_stream.close();
    }

Referenced by makeInference().

Here is the caller graph for this function:

saveVertices()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::saveVertices ( std::string_view path ) const

inherited

Saves vertices to file.

Parameters

path	The path to the file to be used.

Definition at line 613 of file inferenceEngine_tpl.h.

                                                                              {
      std::ofstream m_stream(std::string(path), std::ios::out | std::ios::trunc);
 
      if (!m_stream.good()) {
        GUM_ERROR(IOError,
                  "void InferenceEngine< GUM_SCALAR >::saveVertices(const "
                  "std::string & path) : could not open outpul file : "
                      << path);
      }
 
      for (const auto& elt: marginalSets_) {
        m_stream << credalNet_->current_bn().variable(elt.first).name() << std::endl;
 
        for (const auto& elt2: elt.second) {
          m_stream << "[";
          bool first = true;
 
          for (const auto& elt3: elt2) {
            if (!first) { m_stream << ","; }
            first = false;
            m_stream << elt3;
          }
 
          m_stream << "]\n";
        }
      }
 
      m_stream.close();
    }

References credalNet_, GUM_ERROR, and marginalSets_.

Referenced by makeInference().

Here is the caller graph for this function:

setEpsilon()

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

overridevirtualinherited

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

If the criterion was disabled it will be enabled.

Parameters

eps	The new epsilon value.

Exceptions

OutOfBounds

Raised if eps < 0.

Implements gum::IApproximationSchemeConfiguration.

Reimplemented in gum::learning::EMApproximationScheme.

Definition at line 64 of file approximationScheme_inl.h.

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

References enabled_eps_, eps_, and GUM_ERROR.

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

Here is the caller graph for this function:

setMaxIter()

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

overridevirtualinherited

Stopping criterion on number of iterations.

If the criterion was disabled it will be enabled.

Parameters

max	The maximum number of iterations.

Exceptions

OutOfBounds

Raised if max <= 1.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 106 of file approximationScheme_inl.h.

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

References enabled_max_iter_, GUM_ERROR, and max_iter_.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::MCBNDistance< GUM_SCALAR >::MCBNDistance(), gum::MCBNDistance< GUM_SCALAR >::MCBNDistance(), gum::SamplingInference< GUM_SCALAR >::SamplingInference(), gum::learning::IBNLearner::EMsetMaxIter(), and gum::learning::IBNLearner::setMaxIter().

Here is the caller graph for this function:

setMaxTime()

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

overridevirtualinherited

Stopping criterion on timeout.

If the criterion was disabled it will be enabled.

Parameters

timeout

The timeout value in seconds.

Exceptions

OutOfBounds

Raised if timeout <= 0.0.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 127 of file approximationScheme_inl.h.

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

References enabled_max_time_, GUM_ERROR, and max_time_.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::MCBNDistance< GUM_SCALAR >::MCBNDistance(), gum::MCBNDistance< GUM_SCALAR >::MCBNDistance(), gum::SamplingInference< GUM_SCALAR >::SamplingInference(), gum::learning::IBNLearner::EMsetMaxTime(), and gum::learning::IBNLearner::setMaxTime().

Here is the caller graph for this function:

setMinEpsilonRate()

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

overridevirtualinherited

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

If the criterion was disabled it will be enabled

Parameters

rate	The minimal epsilon rate.

Exceptions

OutOfBounds

if rate<0

Implements gum::IApproximationSchemeConfiguration.

Reimplemented in gum::learning::EMApproximationScheme.

Definition at line 85 of file approximationScheme_inl.h.

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

References enabled_min_rate_eps_, GUM_ERROR, and min_rate_eps_.

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

Here is the caller graph for this function:

setNumberOfThreads()

void gum::ThreadNumberManager::setNumberOfThreads ( Size nb )

overridevirtualinherited

sets the number max of threads to be used by the class containing this ThreadNumberManager

Parameters

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

Implements gum::IThreadNumberManager.

Referenced by gum::learning::IBNLearner::setNumberOfThreads(), and gum::ScheduledInference::setNumberOfThreads().

Here is the caller graph for this function:

setPeriodSize()

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

overridevirtualinherited

How many samples between two stopping is enable.

Parameters

p	The new period value.

Exceptions

OutOfBounds

Raised if p < 1.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 150 of file approximationScheme_inl.h.

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

References GUM_ERROR.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::MCBNDistance< GUM_SCALAR >::MCBNDistance(), gum::MCBNDistance< GUM_SCALAR >::MCBNDistance(), gum::SamplingInference< GUM_SCALAR >::SamplingInference(), gum::learning::IBNLearner::EMsetPeriodSize(), and gum::learning::IBNLearner::setPeriodSize().

Here is the caller graph for this function:

setRepetitiveInd()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::setRepetitiveInd ( const bool repetitive )

inherited

Parameters

repetitive

True if repetitive independence is to be used, false otherwise. Only useful with dynamic networks.

Definition at line 134 of file inferenceEngine_tpl.h.

                                                                              {
      bool oldValue  = repetitiveInd_;
      repetitiveInd_ = repetitive;
 
      // do not compute clusters more than once
      if (repetitiveInd_ && !oldValue) repetitiveInit_();
    }

References repetitiveInd_, and repetitiveInit_().

Referenced by makeInference().

Here is the call graph for this function:

Here is the caller graph for this function:

setVerbosity()

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

overridevirtualinherited

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

Parameters

v	If true, then verbosity is turned on.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 159 of file approximationScheme_inl.h.

{ verbosity_ = v; }

References verbosity_.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::MCBNDistance< GUM_SCALAR >::MCBNDistance(), gum::MCBNDistance< GUM_SCALAR >::MCBNDistance(), gum::SamplingInference< GUM_SCALAR >::SamplingInference(), gum::learning::IBNLearner::EMsetVerbosity(), and gum::learning::IBNLearner::setVerbosity().

Here is the caller graph for this function:

startOfPeriod()

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

inherited

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

Returns

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

Definition at line 200 of file approximationScheme_inl.h.

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

Referenced by continueApproximationScheme().

Here is the caller graph for this function:

stateApproximationScheme()

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

overridevirtualinherited

Returns the approximation scheme state.

Returns

Returns the approximation scheme state.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 165 of file approximationScheme_inl.h.

                                                             {
    return current_state_;
  }

Referenced by continueApproximationScheme(), gum::learning::IBNLearner::EMState(), gum::learning::IBNLearner::EMStateApproximationScheme(), history(), nbrIterations(), and gum::learning::IBNLearner::stateApproximationScheme().

Here is the caller graph for this function:

stopApproximationScheme()

INLINE void gum::ApproximationScheme::stopApproximationScheme ( )

inherited

Stop the approximation scheme.

Definition at line 222 of file approximationScheme_inl.h.

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

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

Here is the caller graph for this function:

stopScheme_()

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

privateinherited

Stop the scheme given a new state.

Parameters

new_state

The scheme new state.

Definition at line 231 of file approximationScheme_inl.h.

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

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

Referenced by continueApproximationScheme().

Here is the caller graph for this function:

storeBNOpt() [1/2]

template<GUM_Numeric GUM_SCALAR>

bool gum::credal::InferenceEngine< GUM_SCALAR >::storeBNOpt ( ) const

inherited

Returns

True if optimal bayes net are stored for each variable and each modality, False otherwise.

Definition at line 159 of file inferenceEngine_tpl.h.

                                                         {
      return storeBNOpt_;
    }

References storeBNOpt_.

storeBNOpt() [2/2]

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::storeBNOpt ( const bool value )

inherited

Parameters

value

True if optimal Bayesian networks are to be stored for each variable and each modality.

Definition at line 122 of file inferenceEngine_tpl.h.

                                                                   {
      storeBNOpt_ = value;
    }

References storeBNOpt_.

Referenced by makeInference().

Here is the caller graph for this function:

storeVertices() [1/2]

template<GUM_Numeric GUM_SCALAR>

bool gum::credal::InferenceEngine< GUM_SCALAR >::storeVertices ( ) const

inherited

Get the number of iterations without changes used to stop some algorithms.

Returns

the number of iterations. int iterStop () const;

True if vertice are stored, False otherwise.

Definition at line 154 of file inferenceEngine_tpl.h.

                                                            {
      return storeVertices_;
    }

References storeVertices_.

storeVertices() [2/2]

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::storeVertices ( const bool value )

inherited

Parameters

value

True if vertices are to be stored, false otherwise.

Definition at line 127 of file inferenceEngine_tpl.h.

                                                                      {
      storeVertices_ = value;
 
      if (value) initMarginalSets_();
    }

References initMarginalSets_(), and storeVertices_.

Referenced by makeInference().

Here is the call graph for this function:

Here is the caller graph for this function:

toString()

template<GUM_Numeric GUM_SCALAR>

std::string gum::credal::InferenceEngine< GUM_SCALAR >::toString ( ) const

inherited

Print all nodes marginals to standart output.

Definition at line 585 of file inferenceEngine_tpl.h.

                                                            {
      std::stringstream output;
      output << std::endl;
 
      // use cbegin() when available
      for (const auto& elt: marginalMin_) {
        Size esize = Size(elt.second.size());
 
        for (Size mod = 0; mod < esize; mod++) {
          output << "P(" << credalNet_->current_bn().variable(elt.first).name() << "=" << mod
                 << "|e) = [ ";
          output << marginalMin_[elt.first][mod] << ", " << marginalMax_[elt.first][mod] << " ]";
 
          if (!query_.empty()) {
            if (auto p_query = query_.tryGet(elt.first); p_query && (*p_query)[mod])
              output << " QUERY";
          }
 
          output << std::endl;
        }
 
        output << std::endl;
      }
 
      return output.str();
    }

Referenced by makeInference().

Here is the caller graph for this function:

updateApproximationScheme()

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

inherited

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

Parameters

incr	The new increment steps.

Definition at line 209 of file approximationScheme_inl.h.

                                                                              {
    current_step_ += incr;
  }

References current_step_.

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

Here is the caller graph for this function:

updateCredalSets_()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::updateCredalSets_ ( const NodeId & id, const std::vector< GUM_SCALAR > & vertex, const bool & elimRedund = false )

inlineprotectedinherited

Given a node id and one of it's possible vertex, update it's credal set.

To maximise efficiency, don't pass a vertex we know is inside the polytope (i.e. not at an extreme value for any modality)

Parameters

id	The id of the node to be updated
vertex	A (tensor) vertex of the node credal set
elimRedund	remove redundant vertex (inside a facet)

Definition at line 896 of file inferenceEngine_tpl.h.

                                                                                  {
      auto& nodeCredalSet = marginalSets_[id];
      auto  dsize         = vertex.size();
 
      bool eq = true;
 
      for (auto it = nodeCredalSet.cbegin(), itEnd = nodeCredalSet.cend(); it != itEnd; ++it) {
        eq = true;
 
        for (Size i = 0; i < dsize; i++) {
          if (std::fabs(vertex[i] - (*it)[i]) > 1e-6) {
            eq = false;
            break;
          }
        }
 
        if (eq) break;
      }
 
      if (!eq || nodeCredalSet.size() == 0) {
        nodeCredalSet.push_back(vertex);
      } else return;
 
      // because of next lambda return condition
      if (nodeCredalSet.size() == 1) return;
 
      // check that the point and all previously added ones are not inside the
      // actual
      // polytope
      auto itEnd = std::remove_if(
          nodeCredalSet.begin(),
          nodeCredalSet.end(),
          [&](const std::vector< GUM_SCALAR >& v) -> bool {
            for (auto jt       = v.cbegin(),
                      jtEnd    = v.cend(),
                      minIt    = marginalMin_[id].cbegin(),
                      minItEnd = marginalMin_[id].cend(),
                      maxIt    = marginalMax_[id].cbegin(),
                      maxItEnd = marginalMax_[id].cend();
                 jt != jtEnd && minIt != minItEnd && maxIt != maxItEnd;
                 ++jt, ++minIt, ++maxIt) {
              if ((std::fabs(*jt - *minIt) < 1e-6 || std::fabs(*jt - *maxIt) < 1e-6)
                  && std::fabs(*minIt - *maxIt) > 1e-6)
                return false;
            }
            return true;
          });
 
      nodeCredalSet.erase(itEnd, nodeCredalSet.end());
 
      // we need at least 2 points to make a convex combination
      if (!elimRedund || nodeCredalSet.size() <= 2) return;
 
      // there may be points not inside the polytope but on one of it's facet,
      // meaning it's still a convex combination of vertices of this facet. Here
      // we
      // need lrs.
      LRSWrapper< GUM_SCALAR > lrsWrapper;
      lrsWrapper.setUpV((unsigned int)dsize, (unsigned int)(nodeCredalSet.size()));
 
      for (const auto& vtx: nodeCredalSet)
        lrsWrapper.fillV(vtx);
 
      lrsWrapper.elimRedundVrep();
 
      marginalSets_[id] = lrsWrapper.getOutput();
    }

References marginalSets_.

Referenced by gum::credal::CNLoopyPropagation< GUM_SCALAR >::computeExpectations_(), and gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::verticesFusion_().

Here is the caller graph for this function:

updateExpectations_()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::InferenceEngine< GUM_SCALAR >::updateExpectations_ ( const NodeId & id, const std::vector< GUM_SCALAR > & vertex )

inlineprotectedinherited

Given a node id and one of it's possible vertex obtained during inference, update this node lower and upper expectations.

Parameters

id	The id of the node to be updated
vertex	A (tensor) vertex of the node credal set

Definition at line 874 of file inferenceEngine_tpl.h.

                                               {
      std::string var_name = credalNet_->current_bn().variable(id).name();
      auto        delim    = var_name.find_first_of("_");
 
      var_name = var_name.substr(0, delim);
 
      if (auto p_modal = modal_.tryGet(var_name)) {
        GUM_SCALAR exp   = 0;
        auto       vsize = vertex.size();
 
        for (Size mod = 0; mod < vsize; mod++)
          exp += vertex[mod] * (*p_modal)[mod];
 
        if (exp > expectationMax_[id]) expectationMax_[id] = exp;
 
        if (exp < expectationMin_[id]) expectationMin_[id] = exp;
      }
    }

References credalNet_, expectationMax_, expectationMin_, and modal_.

Referenced by gum::credal::CNLoopyPropagation< GUM_SCALAR >::computeExpectations_().

Here is the caller graph for this function:

updateIndicatrices_()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CNLoopyPropagation< GUM_SCALAR >::updateIndicatrices_ ( )

protected

Only update indicatrices variables at the end of computations ( calls msgP_ ).

Definition at line 1442 of file CNLoopyPropagation_tpl.h.

                                                             {
    for (auto node: _bnet_->nodes()) {
      if (_cn_->currentNodeType(node) != CredalNet< GUM_SCALAR >::NodeType::Indic) { continue; }
 
      for (auto pare: _bnet_->parents(node)) {
        msgP_(pare, node);
      }
    }
 
    refreshLMsPIs_(true);
    updateMarginals_();
  }

References _bnet_, _cn_, gum::credal::CredalNet< GUM_SCALAR >::Indic, msgP_(), refreshLMsPIs_(), and updateMarginals_().

Referenced by makeInference().

Here is the call graph for this function:

Here is the caller graph for this function:

updateMarginals_()

template<GUM_Numeric GUM_SCALAR>

void gum::credal::CNLoopyPropagation< GUM_SCALAR >::updateMarginals_ ( )

protected

Compute marginals from up-to-date messages.

Definition at line 1341 of file CNLoopyPropagation_tpl.h.

                                                          {
    for (auto node: _bnet_->nodes()) {
      GUM_SCALAR msg_p_min = 1.;
      GUM_SCALAR msg_p_max = 0.;
 
      if (_infE_::evidence_.exists(node)) {
        if (_infE_::evidence_[node][1] == 0.) {
          msg_p_min = (GUM_SCALAR)0.;
        } else if (_infE_::evidence_[node][1] == 1.) {
          msg_p_min = 1.;
        }
 
        msg_p_max = msg_p_min;
      } else {
        GUM_SCALAR min = NodesP_min_[node];
        GUM_SCALAR max;
 
        if (NodesP_max_.exists(node)) {
          max = NodesP_max_[node];
        } else {
          max = min;
        }
 
        GUM_SCALAR lmin = NodesL_min_[node];
        GUM_SCALAR lmax;
        if (NodesL_max_.exists(node)) {
          lmax = NodesL_max_[node];
        } else {
          lmax = lmin;
        }
 
        if (min == INF_ || max == INF_) {
          std::cout << " min ou max === INF_ !!!!!!!!!!!!!!!!!!!!!!!!!! " << std::endl;
          return;
        }
 
        if (min == INF_ && lmin == 0.) {
          std::cout << "proba ERR (negatif) : pi = inf, l = 0" << std::endl;
          return;
        }
 
        if (lmin == INF_) {
          msg_p_min = GUM_SCALAR(1.);
        } else if (min == 0. || lmin == 0.) {
          msg_p_min = GUM_SCALAR(0.);
        } else {
          msg_p_min = GUM_SCALAR(1. / (1. + ((1. / min - 1.) * 1. / lmin)));
        }
 
        if (max == INF_ && lmax == 0.) {
          std::cout << "proba ERR (negatif) : pi = inf, l = 0" << std::endl;
          return;
        }
 
        if (lmax == INF_) {
          msg_p_max = GUM_SCALAR(1.);
        } else if (max == 0. || lmax == 0.) {
          msg_p_max = GUM_SCALAR(0.);
        } else {
          msg_p_max = GUM_SCALAR(1. / (1. + ((1. / max - 1.) * 1. / lmax)));
        }
      }
 
      if (msg_p_min != msg_p_min && msg_p_max == msg_p_max) {
        msg_p_min = msg_p_max;
        std::cout << std::endl;
        std::cout << "msg_p_min is NaN" << std::endl;
      }
 
      if (msg_p_max != msg_p_max && msg_p_min == msg_p_min) {
        msg_p_max = msg_p_min;
        std::cout << std::endl;
        std::cout << "msg_p_max is NaN" << std::endl;
      }
 
      if (msg_p_max != msg_p_max && msg_p_min != msg_p_min) {
        std::cout << std::endl;
        std::cout << "Please check the observations (no proba can be computed)" << std::endl;
        return;
      }
 
      if (msg_p_min < 0.) { msg_p_min = 0.; }
 
      if (msg_p_max < 0.) { msg_p_max = 0.; }
 
      _infE_::marginalMin_[node][0] = 1 - msg_p_max;
      _infE_::marginalMax_[node][0] = 1 - msg_p_min;
      _infE_::marginalMin_[node][1] = msg_p_min;
      _infE_::marginalMax_[node][1] = msg_p_max;
    }
  }

References _bnet_, gum::credal::InferenceEngine< GUM_SCALAR >::evidence_, INF_, gum::credal::InferenceEngine< GUM_SCALAR >::marginalMax_, gum::credal::InferenceEngine< GUM_SCALAR >::marginalMin_, NodesL_max_, NodesL_min_, NodesP_max_, and NodesP_min_.

Referenced by calculateEpsilon_(), and updateIndicatrices_().

Here is the caller graph for this function:

verbosity()

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

overridevirtualinherited

Returns true if verbosity is enabled.

Returns

Returns true if verbosity is enabled.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 161 of file approximationScheme_inl.h.

{ return verbosity_; }

References verbosity_.

Referenced by ApproximationScheme(), gum::learning::EMApproximationScheme::EMApproximationScheme(), continueApproximationScheme(), gum::learning::IBNLearner::EMVerbosity(), and gum::learning::IBNLearner::verbosity().

Here is the caller graph for this function:

vertices()

template<GUM_Numeric GUM_SCALAR>

const std::vector< std::vector< GUM_SCALAR > > & gum::credal::InferenceEngine< GUM_SCALAR >::vertices ( const NodeId id ) const

inherited

Get the vertice of a given node id.

Parameters

id	The node id which vertice we want.

Returns

A constant reference to this node vertice.

Definition at line 513 of file inferenceEngine_tpl.h.

                                                                     {
      return marginalSets_[id];
    }

References marginalSets_.

Referenced by gum::credal::CNLoopyPropagation< GUM_SCALAR >::computeExpectations_(), and makeInference().

Here is the caller graph for this function:

Member Data Documentation

_bnet_

template<GUM_Numeric GUM_SCALAR>

const IBayesNet< GUM_SCALAR >* gum::credal::CNLoopyPropagation< GUM_SCALAR >::_bnet_

private

A pointer to it's IBayesNet used as a DAG.

Definition at line 393 of file CNLoopyPropagation.h.

Referenced by CNLoopyPropagation(), computeExpectations_(), eraseAllEvidence(), initialize_(), makeInferenceByOrderedArcs_(), makeInferenceByRandomOrder_(), makeInferenceNodeToNeighbours_(), msgL_(), msgP_(), refreshLMsPIs_(), saveInference(), updateIndicatrices_(), and updateMarginals_().

_cn_

template<GUM_Numeric GUM_SCALAR>

const CredalNet< GUM_SCALAR >* gum::credal::CNLoopyPropagation< GUM_SCALAR >::_cn_

private

A pointer to the CredalNet to be used.

Definition at line 390 of file CNLoopyPropagation.h.

Referenced by CNLoopyPropagation(), compute_ext_(), compute_ext_(), enum_combi_(), enum_combi_(), initialize_(), makeInferenceByOrderedArcs_(), makeInferenceByRandomOrder_(), makeInferenceNodeToNeighbours_(), refreshLMsPIs_(), and updateIndicatrices_().

_inferenceType_

template<GUM_Numeric GUM_SCALAR>

InferenceType gum::credal::CNLoopyPropagation< GUM_SCALAR >::_inferenceType_

private

The chosen inference type.

nodeToNeighbours by Default.

Definition at line 387 of file CNLoopyPropagation.h.

Referenced by CNLoopyPropagation(), inferenceType(), inferenceType(), and makeInference().

_nb_threads_

Size gum::ThreadNumberManager::_nb_threads_ {0}

privateinherited

the max number of threads used by the class

Definition at line 126 of file threadNumberManager.h.

active_nodes_set_

template<GUM_Numeric GUM_SCALAR>

NodeSet gum::credal::CNLoopyPropagation< GUM_SCALAR >::active_nodes_set_

protected

The current node-set to iterate through at this current step.

Definition at line 345 of file CNLoopyPropagation.h.

Referenced by eraseAllEvidence(), initialize_(), and makeInferenceNodeToNeighbours_().

ArcsL_max_

template<GUM_Numeric GUM_SCALAR>

ArcProperty< GUM_SCALAR > gum::credal::CNLoopyPropagation< GUM_SCALAR >::ArcsL_max_

protected

"Upper" information \( \Lambda \) coming from one's children.

Definition at line 367 of file CNLoopyPropagation.h.

Referenced by eraseAllEvidence(), msgL_(), msgP_(), and refreshLMsPIs_().

ArcsL_min_

template<GUM_Numeric GUM_SCALAR>

ArcProperty< GUM_SCALAR > gum::credal::CNLoopyPropagation< GUM_SCALAR >::ArcsL_min_

protected

"Lower" information \( \Lambda \) coming from one's children.

Definition at line 355 of file CNLoopyPropagation.h.

Referenced by eraseAllEvidence(), initialize_(), msgL_(), msgP_(), and refreshLMsPIs_().

ArcsP_max_

template<GUM_Numeric GUM_SCALAR>

ArcProperty< GUM_SCALAR > gum::credal::CNLoopyPropagation< GUM_SCALAR >::ArcsP_max_

protected

"Upper" information \( \pi \) coming from one's parent.

Definition at line 369 of file CNLoopyPropagation.h.

Referenced by eraseAllEvidence(), initialize_(), msgL_(), msgP_(), and refreshLMsPIs_().

ArcsP_min_

template<GUM_Numeric GUM_SCALAR>

ArcProperty< GUM_SCALAR > gum::credal::CNLoopyPropagation< GUM_SCALAR >::ArcsP_min_

protected

"Lower" information \( \pi \) coming from one's parent.

Definition at line 357 of file CNLoopyPropagation.h.

Referenced by eraseAllEvidence(), initialize_(), msgL_(), msgP_(), and refreshLMsPIs_().

burn_in_

Size gum::ApproximationScheme::burn_in_

protectedinherited

Number of iterations before checking stopping criteria.

Definition at line 423 of file approximationScheme.h.

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

credalNet_

template<GUM_Numeric GUM_SCALAR>

const CredalNet< GUM_SCALAR >* gum::credal::InferenceEngine< GUM_SCALAR >::credalNet_

protectedinherited

A pointer to the Credal Net used.

Definition at line 86 of file inferenceEngine.h.

Referenced by InferenceEngine(), addEvidence(), addEvidence(), addEvidence(), addEvidence(), addEvidence(), addEvidence(), credalNet(), dynamicExpectations_(), expectationMax(), expectationMin(), initExpectations_(), initMarginals_(), initMarginalSets_(), insertEvidence(), insertEvidence(), insertModals(), marginalMax(), marginalMin(), marginalMin(), repetitiveInit_(), saveVertices(), and updateExpectations_().

current_epsilon_

double gum::ApproximationScheme::current_epsilon_

protectedinherited

Current epsilon.

Definition at line 378 of file approximationScheme.h.

Referenced by continueApproximationScheme().

current_rate_

double gum::ApproximationScheme::current_rate_

protectedinherited

Current rate.

Definition at line 384 of file approximationScheme.h.

Referenced by continueApproximationScheme().

current_state_

ApproximationSchemeSTATE gum::ApproximationScheme::current_state_

protectedinherited

The current state.

Definition at line 393 of file approximationScheme.h.

Referenced by ApproximationScheme(), continueApproximationScheme(), and initApproximationScheme().

current_step_

Size gum::ApproximationScheme::current_step_

protectedinherited

The current step.

Definition at line 387 of file approximationScheme.h.

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

dbnOpt_

template<GUM_Numeric GUM_SCALAR>

VarMod2BNsMap< GUM_SCALAR > gum::credal::InferenceEngine< GUM_SCALAR >::dbnOpt_

protectedinherited

Object used to efficiently store optimal bayes net during inference, for some algorithms.

Definition at line 160 of file inferenceEngine.h.

Referenced by InferenceEngine(), getVarMod2BNsMap(), and gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::optFusion_().

dynamicExpMax_

template<GUM_Numeric GUM_SCALAR>

dynExpe gum::credal::InferenceEngine< GUM_SCALAR >::dynamicExpMax_

protectedinherited

Upper dynamic expectations.

If the network if not dynamic it's content is the same as expectationMax_.

Definition at line 113 of file inferenceEngine.h.

Referenced by dynamicExpectations_(), and eraseAllEvidence().

dynamicExpMin_

template<GUM_Numeric GUM_SCALAR>

dynExpe gum::credal::InferenceEngine< GUM_SCALAR >::dynamicExpMin_

protectedinherited

Lower dynamic expectations.

If the network is not dynamic it's content is the same as expectationMin_.

Definition at line 110 of file inferenceEngine.h.

Referenced by dynamicExpectations_(), and eraseAllEvidence().

enabled_eps_

bool gum::ApproximationScheme::enabled_eps_

protectedinherited

If true, the threshold convergence is enabled.

Definition at line 402 of file approximationScheme.h.

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

enabled_max_iter_

bool gum::ApproximationScheme::enabled_max_iter_

protectedinherited

If true, the maximum iterations stopping criterion is enabled.

Definition at line 420 of file approximationScheme.h.

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

enabled_max_time_

bool gum::ApproximationScheme::enabled_max_time_

protectedinherited

If true, the timeout is enabled.

Definition at line 414 of file approximationScheme.h.

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

enabled_min_rate_eps_

bool gum::ApproximationScheme::enabled_min_rate_eps_

protectedinherited

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

Definition at line 408 of file approximationScheme.h.

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

eps_

double gum::ApproximationScheme::eps_

protectedinherited

Threshold for convergence.

Definition at line 399 of file approximationScheme.h.

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

evidence_

template<GUM_Numeric GUM_SCALAR>

margi gum::credal::InferenceEngine< GUM_SCALAR >::evidence_

protectedinherited

Holds observed variables states.

Definition at line 119 of file inferenceEngine.h.

Referenced by addEvidence(), eraseAllEvidence(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::initialize_(), insertEvidence(), insertEvidence(), insertEvidenceFile(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::msgL_(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::msgP_(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::optFusion_(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::refreshLMsPIs_(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::saveInference(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::updateMarginals_(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, LazyPropagation< GUM_SCALAR > >::updateMarginals_(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::updateThread_(), and gum::credal::MultipleInferenceEngine< GUM_SCALAR, LazyPropagation< GUM_SCALAR > >::updateThread_().

expectationMax_

template<GUM_Numeric GUM_SCALAR>

expe gum::credal::InferenceEngine< GUM_SCALAR >::expectationMax_

protectedinherited

Upper expectations, if some variables modalities were inserted.

Definition at line 106 of file inferenceEngine.h.

Referenced by dynamicExpectations_(), expectationMax(), expectationMax(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::expFusion_(), initExpectations_(), and updateExpectations_().

expectationMin_

template<GUM_Numeric GUM_SCALAR>

expe gum::credal::InferenceEngine< GUM_SCALAR >::expectationMin_

protectedinherited

Lower expectations, if some variables modalities were inserted.

Definition at line 103 of file inferenceEngine.h.

Referenced by dynamicExpectations_(), expectationMin(), expectationMin(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::expFusion_(), initExpectations_(), and updateExpectations_().

history_

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

protectedinherited

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

Definition at line 396 of file approximationScheme.h.

Referenced by continueApproximationScheme().

inference_up_to_date_

template<GUM_Numeric GUM_SCALAR>

bool gum::credal::CNLoopyPropagation< GUM_SCALAR >::inference_up_to_date_

protected

TRUE if inference has already been performed, FALSE otherwise.

Definition at line 380 of file CNLoopyPropagation.h.

Referenced by CNLoopyPropagation(), ~CNLoopyPropagation(), eraseAllEvidence(), and makeInference().

last_epsilon_

double gum::ApproximationScheme::last_epsilon_

protectedinherited

Last epsilon value.

Definition at line 381 of file approximationScheme.h.

Referenced by continueApproximationScheme().

marginalMax_

template<GUM_Numeric GUM_SCALAR>

margi gum::credal::InferenceEngine< GUM_SCALAR >::marginalMax_

protectedinherited

Upper marginals.

Definition at line 96 of file inferenceEngine.h.

Referenced by computeEpsilon_(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::computeEpsilon_(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::computeExpectations_(), initMarginals_(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::initThreadsData_(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::optFusion_(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::updateMarginals_(), and gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::updateMarginals_().

marginalMin_

template<GUM_Numeric GUM_SCALAR>

margi gum::credal::InferenceEngine< GUM_SCALAR >::marginalMin_

protectedinherited

Lower marginals.

Definition at line 94 of file inferenceEngine.h.

Referenced by computeEpsilon_(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::computeEpsilon_(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::computeExpectations_(), initMarginals_(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::initThreadsData_(), marginalMin(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::optFusion_(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::updateMarginals_(), and gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::updateMarginals_().

marginalSets_

template<GUM_Numeric GUM_SCALAR>

credalSet gum::credal::InferenceEngine< GUM_SCALAR >::marginalSets_

protectedinherited

Credal sets vertices, if enabled.

Definition at line 99 of file inferenceEngine.h.

Referenced by gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::expFusion_(), initMarginalSets_(), saveVertices(), updateCredalSets_(), and vertices().

max_iter_

Size gum::ApproximationScheme::max_iter_

protectedinherited

The maximum iterations.

Definition at line 417 of file approximationScheme.h.

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

max_time_

double gum::ApproximationScheme::max_time_

protectedinherited

The timeout.

Definition at line 411 of file approximationScheme.h.

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

min_rate_eps_

double gum::ApproximationScheme::min_rate_eps_

protectedinherited

Threshold for the epsilon rate.

Definition at line 405 of file approximationScheme.h.

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

modal_

template<GUM_Numeric GUM_SCALAR>

dynExpe gum::credal::InferenceEngine< GUM_SCALAR >::modal_

protectedinherited

Variables modalities used to compute expectations.

Definition at line 116 of file inferenceEngine.h.

Referenced by gum::credal::CNLoopyPropagation< GUM_SCALAR >::computeExpectations_(), dynamicExpectations_(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::expFusion_(), initExpectations_(), insertModals(), insertModalsFile(), and updateExpectations_().

msg_l_sent_

template<GUM_Numeric GUM_SCALAR>

NodeProperty< NodeSet* > gum::credal::CNLoopyPropagation< GUM_SCALAR >::msg_l_sent_

protected

Used to keep track of one's messages sent to it's parents.

Definition at line 352 of file CNLoopyPropagation.h.

Referenced by ~CNLoopyPropagation(), eraseAllEvidence(), initialize_(), and msgL_().

next_active_nodes_set_

template<GUM_Numeric GUM_SCALAR>

NodeSet gum::credal::CNLoopyPropagation< GUM_SCALAR >::next_active_nodes_set_

protected

The next node-set, i.e.

the nodes that will send messages at the next step.

Definition at line 349 of file CNLoopyPropagation.h.

Referenced by eraseAllEvidence(), makeInferenceNodeToNeighbours_(), msgL_(), and msgP_().

NodesL_max_

template<GUM_Numeric GUM_SCALAR>

NodeProperty< GUM_SCALAR > gum::credal::CNLoopyPropagation< GUM_SCALAR >::NodesL_max_

protected

"Upper" node information \( \Lambda \) obtained by combinaison of children messages.

Definition at line 372 of file CNLoopyPropagation.h.

Referenced by eraseAllEvidence(), msgL_(), refreshLMsPIs_(), saveInference(), and updateMarginals_().

NodesL_min_

template<GUM_Numeric GUM_SCALAR>

NodeProperty< GUM_SCALAR > gum::credal::CNLoopyPropagation< GUM_SCALAR >::NodesL_min_

protected

"Lower" node information \( \Lambda \) obtained by combinaison of children messages.

Definition at line 360 of file CNLoopyPropagation.h.

Referenced by eraseAllEvidence(), initialize_(), msgL_(), refreshLMsPIs_(), saveInference(), and updateMarginals_().

NodesP_max_

template<GUM_Numeric GUM_SCALAR>

NodeProperty< GUM_SCALAR > gum::credal::CNLoopyPropagation< GUM_SCALAR >::NodesP_max_

protected

"Upper" node information \( \pi \) obtained by combinaison of parent's messages.

Definition at line 376 of file CNLoopyPropagation.h.

Referenced by eraseAllEvidence(), initialize_(), msgP_(), refreshLMsPIs_(), saveInference(), and updateMarginals_().

NodesP_min_

template<GUM_Numeric GUM_SCALAR>

NodeProperty< GUM_SCALAR > gum::credal::CNLoopyPropagation< GUM_SCALAR >::NodesP_min_

protected

"Lower" node information \( \pi \) obtained by combinaison of parent's messages.

Definition at line 364 of file CNLoopyPropagation.h.

Referenced by eraseAllEvidence(), initialize_(), msgP_(), refreshLMsPIs_(), saveInference(), and updateMarginals_().

oldMarginalMax_

template<GUM_Numeric GUM_SCALAR>

margi gum::credal::InferenceEngine< GUM_SCALAR >::oldMarginalMax_

protectedinherited

Old upper marginals used to compute epsilon.

Definition at line 91 of file inferenceEngine.h.

Referenced by computeEpsilon_(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::computeEpsilon_(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::initialize_(), initMarginals_(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::initThreadsData_(), and gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::updateOldMarginals_().

oldMarginalMin_

template<GUM_Numeric GUM_SCALAR>

margi gum::credal::InferenceEngine< GUM_SCALAR >::oldMarginalMin_

protectedinherited

Old lower marginals used to compute epsilon.

Definition at line 89 of file inferenceEngine.h.

Referenced by computeEpsilon_(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::computeEpsilon_(), gum::credal::CNLoopyPropagation< GUM_SCALAR >::initialize_(), initMarginals_(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::initThreadsData_(), and gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::updateOldMarginals_().

onProgress

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

inherited

Progression, error and time.

Definition at line 81 of file IApproximationSchemeConfiguration.h.

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

onStop

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

inherited

Criteria messageApproximationScheme.

Definition at line 84 of file IApproximationSchemeConfiguration.h.

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

period_size_

Size gum::ApproximationScheme::period_size_

protectedinherited

Checking criteria frequency.

Definition at line 426 of file approximationScheme.h.

Referenced by ApproximationScheme(), and periodSize().

query_

template<GUM_Numeric GUM_SCALAR>

query gum::credal::InferenceEngine< GUM_SCALAR >::query_

protectedinherited

Holds the query nodes states.

Definition at line 121 of file inferenceEngine.h.

Referenced by eraseAllEvidence(), and insertQuery().

repetitiveInd_

template<GUM_Numeric GUM_SCALAR>

bool gum::credal::InferenceEngine< GUM_SCALAR >::repetitiveInd_

protectedinherited

True if using repetitive independence ( dynamic network only ), False otherwise.

False by default.

Definition at line 145 of file inferenceEngine.h.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::CNMonteCarloSampling(), gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::_verticesSampling_(), gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::makeInference(), repetitiveInd(), and setRepetitiveInd().

storeBNOpt_

template<GUM_Numeric GUM_SCALAR>

bool gum::credal::InferenceEngine< GUM_SCALAR >::storeBNOpt_

protectedinherited

Iterations limit stopping rule used by some algorithms such as CNMonteCarloSampling.

The algorithms stops if no changes occured within 1000 iterations by default. int iterStop_;

True is optimal bayes net are stored, for each variable and each modality, False otherwise. Not all algorithms offers this option. False by default.

Definition at line 155 of file inferenceEngine.h.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::CNMonteCarloSampling(), gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::_mcThreadDataCopy_(), gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::_verticesSampling_(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::eraseAllEvidence(), gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::makeInference(), storeBNOpt(), storeBNOpt(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, LazyPropagation< GUM_SCALAR > >::updateMarginals_(), and gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::updateThread_().

storeVertices_

template<GUM_Numeric GUM_SCALAR>

bool gum::credal::InferenceEngine< GUM_SCALAR >::storeVertices_

protectedinherited

True if credal sets vertices are stored, False otherwise.

False by default.

Definition at line 141 of file inferenceEngine.h.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::CNMonteCarloSampling(), gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::_mcThreadDataCopy_(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::eraseAllEvidence(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::expFusion_(), initMarginalSets_(), gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::makeInference(), storeVertices(), storeVertices(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::updateThread_(), and gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::verticesFusion_().

t0_

template<GUM_Numeric GUM_SCALAR>

cluster gum::credal::InferenceEngine< GUM_SCALAR >::t0_

protectedinherited

Clusters of nodes used with dynamic networks.

Any node key in t0_ is present at \( t=0 \) and any node belonging to the node set of this key share the same CPT than the key. Used for sampling with repetitive independence.

Definition at line 129 of file inferenceEngine.h.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::_mcThreadDataCopy_(), getT0Cluster(), and repetitiveInit_().

t1_

template<GUM_Numeric GUM_SCALAR>

cluster gum::credal::InferenceEngine< GUM_SCALAR >::t1_

protectedinherited

Clusters of nodes used with dynamic networks.

Any node key in t1_ is present at \( t=1 \) and any node belonging to the node set of this key share the same CPT than the key. Used for sampling with repetitive independence.

Definition at line 136 of file inferenceEngine.h.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::_mcThreadDataCopy_(), getT1Cluster(), and repetitiveInit_().

threadMinimalNbOps_

template<GUM_Numeric GUM_SCALAR>

Size gum::credal::InferenceEngine< GUM_SCALAR >::threadMinimalNbOps_ {Size(20)}

protectedinherited

Definition at line 182 of file inferenceEngine.h.

Referenced by gum::credal::CNLoopyPropagation< GUM_SCALAR >::enum_combi_(), and gum::credal::CNLoopyPropagation< GUM_SCALAR >::enum_combi_().

threadRanges_

template<GUM_Numeric GUM_SCALAR>

std::vector< std::pair< NodeId, Idx > > gum::credal::InferenceEngine< GUM_SCALAR >::threadRanges_

protectedinherited

the ranges of elements of marginalMin_ and marginalMax_ processed by each thread

these ranges are stored into a vector of pairs (NodeId, Idx). For thread number i, the pair at index i is the beginning of the range that the thread will have to process: this is the part of the marginal distribution vector of node NodeId starting at index Idx. The pair at index i+1 is the end of this range (not included).

Warning

the size of threadRanges_ is the number of threads + 1.

Definition at line 172 of file inferenceEngine.h.

Referenced by computeEpsilon_(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::computeEpsilon_(), dispatchMarginalsToThreads_(), and gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::updateMarginals_().

timer_

Timer gum::ApproximationScheme::timer_

protectedinherited

The timer.

Definition at line 390 of file approximationScheme.h.

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

timeSteps_

template<GUM_Numeric GUM_SCALAR>

int gum::credal::InferenceEngine< GUM_SCALAR >::timeSteps_

protectedinherited

The number of time steps of this network (only useful for dynamic networks).

Deprecated

Definition at line 179 of file inferenceEngine.h.

Referenced by repetitiveInit_().

update_l_

template<GUM_Numeric GUM_SCALAR>

NodeProperty< bool > gum::credal::CNLoopyPropagation< GUM_SCALAR >::update_l_

protected

Used to keep track of which node needs to update it's information coming from it's children.

Definition at line 342 of file CNLoopyPropagation.h.

Referenced by eraseAllEvidence(), initialize_(), msgL_(), msgP_(), and refreshLMsPIs_().

update_p_

template<GUM_Numeric GUM_SCALAR>

NodeProperty< bool > gum::credal::CNLoopyPropagation< GUM_SCALAR >::update_p_

protected

Used to keep track of which node needs to update it's information coming from it's parents.

Definition at line 338 of file CNLoopyPropagation.h.

Referenced by eraseAllEvidence(), initialize_(), msgL_(), msgP_(), and refreshLMsPIs_().

verbosity_

bool gum::ApproximationScheme::verbosity_

protectedinherited

If true, verbosity is enabled.

Definition at line 429 of file approximationScheme.h.

Referenced by ApproximationScheme(), setVerbosity(), and verbosity().

---

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

• agrum/CN/inference/CNLoopyPropagation.h
• agrum/CN/inference/CNLoopyPropagation_tpl.h