gum::ShaferShenoyMRFInference< GUM_SCALAR > Class Template Reference

<agrum/MRF/inference/ShaferShenoyMRFInference.h> More...

#include <ShaferShenoyMRFInference.h>

Inheritance diagram for gum::ShaferShenoyMRFInference< GUM_SCALAR >:

Collaboration diagram for gum::ShaferShenoyMRFInference< GUM_SCALAR >:

Public Types
enum class	StateOfInference { OutdatedStructure , OutdatedTensors , ReadyForInference , Done }
	current state of the inference More...

Public Member Functions
Tensor< GUM_SCALAR >	evidenceJointImpact (const NodeSet &targets, const NodeSet &evs)
	Create a gum::Tensor for P(joint targets|evs) (for all instanciation of targets and evs).
Tensor< GUM_SCALAR >	evidenceJointImpact (const std::vector< std::string > &targets, const std::vector< std::string > &evs)
	Create a gum::Tensor for P(joint targets|evs) (for all instanciation of targets and evs).
Tensor< GUM_SCALAR >	evidenceImpact (NodeId target, const NodeSet &evs)
	Create a gum::Tensor for P(target|evs) (for all instanciation of target and evs).
Tensor< GUM_SCALAR >	evidenceImpact (const std::string &target, const std::vector< std::string > &evs)
	Create a gum::Tensor for P(target|evs) (for all instanciation of target and evs).
Constructors / Destructors
	ShaferShenoyMRFInference (const IMarkovRandomField< GUM_SCALAR > *MN, bool use_binary_join_tree=true)
	default constructor
	~ShaferShenoyMRFInference ()
	destructor
Accessors / Modifiers
void	setTriangulation (const Triangulation &new_triangulation)
	use a new triangulation algorithm
const JoinTree *	joinTree ()
	returns the current join tree used
const JunctionTree *	junctionTree ()
	returns the current junction tree
GUM_SCALAR	evidenceProbability () final
	returns the probability of evidence
Probability computations
virtual const Tensor< GUM_SCALAR > &	jointPosterior (const NodeSet &nodes) final
	Compute the joint posterior of a set of nodes.
virtual const Tensor< GUM_SCALAR > &	posterior (NodeId node) final
	Computes and returns the posterior of a node.
virtual const Tensor< GUM_SCALAR > &	posterior (const std::string &nodeName) final
	Computes and returns the posterior of a node.
Targets
virtual void	eraseAllTargets () final
	Clear all previously defined targets (marginal and joint targets).
virtual void	eraseAllJointTargets () final
	Clear all previously defined joint targets.
virtual void	eraseAllMarginalTargets () final
	Clear all the previously defined marginal targets.
virtual void	addJointTarget (const NodeSet &joint_target) final
	Add a set of nodes as a new joint target. As a collateral effect, every node is added as a marginal target.
virtual void	eraseJointTarget (const NodeSet &joint_target) final
	removes an existing joint target
virtual bool	isJointTarget (const NodeSet &vars) const final
	return true if target is a joint target.
virtual const Set< NodeSet > &	jointTargets () const noexcept final
	returns the list of joint targets
virtual Size	nbrJointTargets () const noexcept final
	returns the number of joint targets
Information Theory related functions
GUM_SCALAR	jointMutualInformation (const NodeSet &targets)
	Mutual information between targets.
GUM_SCALAR	jointMutualInformation (const std::vector< std::string > &targets)
	Mutual information between targets.
Targets
virtual void	addAllTargets () final
	adds all nodes as targets
virtual void	addTarget (NodeId target) final
	Add a marginal target to the list of targets.
virtual void	addTarget (const std::string &nodeName) final
	Add a marginal target to the list of targets.
virtual void	eraseTarget (NodeId target) final
	removes an existing (marginal) target
virtual void	eraseTarget (const std::string &nodeName) final
	removes an existing (marginal) target
virtual bool	isTarget (NodeId node) const final
	return true if variable is a (marginal) target
virtual bool	isTarget (const std::string &nodeName) const final
	return true if variable is a (marginal) target
virtual Size	nbrTargets () const noexcept final
	returns the number of marginal targets
virtual const NodeSet &	targets () const noexcept final
	returns the list of marginal targets
Information Theory related functions
virtual GUM_SCALAR	H (NodeId X) final
	Entropy Compute Shanon's entropy of a node given the observation.
virtual GUM_SCALAR	H (const std::string &nodeName) final
	Entropy Compute Shanon's entropy of a node given the observation.
Accessors / Modifiers
virtual void	setMRF (const IMarkovRandomField< GUM_SCALAR > *mrf)
	assigns a new MRF to the inference engine
virtual const IMarkovRandomField< GUM_SCALAR > &	MRF () const final
	Returns a constant reference over the IMarkovRandomField referenced by this class.
Accessors / Modifiers
virtual const GraphicalModel &	model () const final
	Returns a constant reference over the IBayesNet referenced by this class.
virtual const NodeProperty< Size > &	domainSizes () const final
	get the domain sizes of the random variables of the model
virtual bool	isInferenceReady () const noexcept final
	returns whether the inference object is in a ready state
virtual bool	isInferenceOutdatedStructure () const noexcept final
	returns whether the inference object is in a OutdatedStructure state
virtual bool	isInferenceOutdatedTensors () const noexcept final
	returns whether the inference object is in a OutdatedTensor state
virtual bool	isInferenceDone () const noexcept final
	returns whether the inference object is in a InferenceDone state
virtual void	prepareInference () final
	prepare the internal inference structures for the next inference
virtual void	makeInference () final
	perform the heavy computations needed to compute the targets' posteriors
virtual void	clear ()
	clears all the data structures allocated for the last inference
virtual StateOfInference	state () const noexcept final
	returns the state of the inference engine
Evidence
virtual void	addEvidence (NodeId id, const Idx val) final
	adds a new hard evidence on node id
virtual void	addEvidence (const std::string &nodeName, const Idx val) final
	adds a new hard evidence on node named nodeName
virtual void	addEvidence (NodeId id, const std::string &label) final
	adds a new hard evidence on node id
virtual void	addEvidence (const std::string &nodeName, const std::string &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 (const std::string &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)
virtual void	addEvidence (Tensor< GUM_SCALAR > &&pot) final
	adds a new evidence on node id (might be soft or hard)
virtual void	addSetOfEvidence (const Set< const Tensor< GUM_SCALAR > * > &potset) final
	adds a new set of evidence
virtual void	addListOfEvidence (const List< const Tensor< GUM_SCALAR > * > &potlist) final
	adds a new list of evidence
virtual void	chgEvidence (NodeId id, const Idx val) final
	change the value of an already existing hard evidence
virtual void	chgEvidence (const std::string &nodeName, const Idx val) final
	change the value of an already existing hard evidence
virtual void	chgEvidence (NodeId id, const std::string &label) final
	change the value of an already existing hard evidence
virtual void	chgEvidence (const std::string &nodeName, const std::string &label) final
	change the value of an already existing hard evidence
virtual void	chgEvidence (NodeId id, const std::vector< GUM_SCALAR > &vals) final
	change the value of an already existing evidence (might be soft or hard)
virtual void	chgEvidence (const std::string &nodeName, const std::vector< GUM_SCALAR > &vals) final
	change the value of an already existing evidence (might be soft or hard)
virtual void	chgEvidence (const Tensor< GUM_SCALAR > &pot) final
	change the value of an already existing evidence (might be soft or hard)
virtual void	eraseAllEvidence () final
	removes all the evidence entered into the network
virtual void	eraseEvidence (NodeId id) final
	removed the evidence, if any, corresponding to node id
virtual void	eraseEvidence (const std::string &nodeName) final
	removed the evidence, if any, corresponding to node of name nodeName
virtual bool	hasEvidence () const final
	indicates whether some node(s) have received evidence
virtual bool	hasEvidence (NodeId id) const final
	indicates whether node id has received an evidence
virtual bool	hasEvidence (const std::string &nodeName) const final
	indicates whether node id has received an evidence
virtual bool	hasHardEvidence (NodeId id) const final
	indicates whether node id has received a hard evidence
virtual bool	hasHardEvidence (const std::string &nodeName) const final
	indicates whether node id has received a hard evidence
virtual bool	hasSoftEvidence (NodeId id) const final
	indicates whether node id has received a soft evidence
virtual bool	hasSoftEvidence (const std::string &nodeName) const final
	indicates whether node id has received a soft evidence
virtual Size	nbrEvidence () const final
	returns the number of evidence entered into the Bayesian network
virtual Size	nbrHardEvidence () const final
	returns the number of hard evidence entered into the Bayesian network
virtual Size	nbrSoftEvidence () const final
	returns the number of soft evidence entered into the Bayesian network
const NodeProperty< const Tensor< GUM_SCALAR > * > &	evidence () const
	returns the set of evidence
const NodeSet &	softEvidenceNodes () const
	returns the set of nodes with soft evidence
const NodeSet &	hardEvidenceNodes () const
	returns the set of nodes with hard evidence
const NodeProperty< Idx > &	hardEvidence () const
	indicate for each node with hard evidence which value it took
Constructors / Destructors
virtual ScheduledInference *	clone () const
	virtual copy constructor
Accessors/Modifiers
Scheduler &	scheduler () const
	returns the current scheduler
void	setNumberOfThreads (Size nb) final
	sets the number max of threads that can be used
void	setMaxMemory (double megabytes)
	sets an upper bound on the memory consumption admissible
virtual double	maxMemory () const
	returns the Max memory (in megabytes) available for executing schedules
Accessors/Modifiers
virtual Size	getNumberOfThreads () const
	returns the current max number of threads used by the class containing this ThreadNumberManager
bool	isGumNumberOfThreadsOverriden () const
	indicates whether the class containing this ThreadNumberManager set its own number of threads

Protected Member Functions
virtual bool	isExactJointComputable_ (const NodeSet &vars) final
	check if the vars form a possible computable joint (can be redefined by subclass)
virtual NodeSet	superForJointComputable_ (const NodeSet &vars) final
void	onEvidenceAdded_ (const NodeId id, bool isHardEvidence) final
	fired after a new evidence is inserted
void	onEvidenceErased_ (const NodeId id, bool isHardEvidence) final
	fired before an evidence is removed
void	onAllEvidenceErased_ (bool has_hard_evidence) final
	fired before all the evidence are erased
void	onEvidenceChanged_ (const NodeId id, bool hasChangedSoftHard) final
	fired after an evidence is changed, in particular when its status (soft/hard) changes
void	onMarginalTargetAdded_ (const NodeId id) final
	fired after a new single target is inserted
void	onMarginalTargetErased_ (const NodeId id) final
	fired before a single target is removed
void	onModelChanged_ (const GraphicalModel *mn) final
	fired after a new Markov net has been assigned to the inference engine
virtual void	onMRFChanged_ (const IMarkovRandomField< GUM_SCALAR > *mn) final
	fired after a new Markov net has been assigned to the inference engine
void	onJointTargetAdded_ (const NodeSet &set) final
	fired after a new joint target is inserted
void	onJointTargetErased_ (const NodeSet &set) final
	fired before a joint target is removed
void	onAllMarginalTargetsAdded_ () final
	fired after all the nodes of the MRF are added as single targets
void	onAllMarginalTargetsErased_ () final
	fired before all the single targets are removed
void	onAllJointTargetsErased_ () final
	fired before all the joint targets are removed
void	onAllTargetsErased_ () final
	fired before all single and joint targets are removed
void	onStateChanged_ () final
	fired when the state of the inference engine is changed
void	updateOutdatedStructure_ () final
	prepares inference when the latter is in OutdatedStructure state
void	updateOutdatedTensors_ () final
	prepares inference when the latter is in OutdatedTensors state
void	makeInference_ () final
	called when the inference has to be performed effectively
const Tensor< GUM_SCALAR > &	posterior_ (NodeId id) final
	returns the posterior of a given variable
const Tensor< GUM_SCALAR > &	jointPosterior_ (const NodeSet &set) final
	returns the posterior of a declared target set
const Tensor< GUM_SCALAR > &	jointPosterior_ (const NodeSet &wanted_target, const NodeSet &declared_target) final
	asks derived classes for the joint posterior of a set of variables not declared as a joint target
Tensor< GUM_SCALAR > *	unnormalizedJointPosterior_ (NodeId id) final
	returns a fresh tensor equal to P(argument,evidence)
Tensor< GUM_SCALAR > *	unnormalizedJointPosterior_ (const NodeSet &set) final
	returns a fresh tensor equal to P(argument,evidence)
void	setTargetedMode_ ()
bool	isTargetedMode_ () const
void	setOutdatedStructureState_ ()
	put the inference into an outdated model structure state
void	setOutdatedTensorsState_ ()
	puts the inference into an OutdatedTensors state if it is not already in an OutdatedStructure state
virtual void	setState_ (const StateOfInference state) final
	set the state of the inference engine and call the notification onStateChanged_ when necessary (i.e. when the state has effectively changed).
void	setModel_ (const GraphicalModel *model)
void	setModelDuringConstruction_ (const GraphicalModel *model)
	assigns a model during the inference engine construction
bool	hasNoModel_ () const

Private Types
enum	EvidenceChangeType { EVIDENCE_ADDED , EVIDENCE_ERASED , EVIDENCE_MODIFIED }
	the possible types of evidence changes More...
using	_TensorSet_ = Set< const Tensor< GUM_SCALAR >* >
using	_ScheduleMultiDimSet_ = Set< const IScheduleMultiDim* >
using	_TensorSetIterator_ = SetIteratorSafe< const Tensor< GUM_SCALAR >* >

Private Member Functions
bool	_isNewJTNeeded_ () const
	check whether a new join tree is really needed for the next inference
void	_createNewJT_ ()
	create a new junction tree as well as its related data structures
void	_initializeJTCliques_ (Schedule &schedule)
	put all the CPTs into the cliques when creating the JT using a schedule
void	_initializeJTCliques_ ()
	put all the CPTs into the cliques when creating the JT without using a schedule
void	_setProjectionFunction_ (Tensor< GUM_SCALAR >(*proj)(const Tensor< GUM_SCALAR > &, const gum::VariableSet &))
	sets the operator for performing the projections
void	_setCombinationFunction_ (Tensor< GUM_SCALAR >(*comb)(const Tensor< GUM_SCALAR > &, const Tensor< GUM_SCALAR > &))
	sets the operator for performing the combinations
void	_diffuseMessageInvalidations_ (NodeId from_id, NodeId to_id, NodeSet &invalidated_cliques)
	invalidate all the messages sent from a given clique
void	_invalidateAllMessages_ ()
	invalidate all messages, posteriors and created tensors
void	_computeJoinTreeRoots_ ()
	compute a root for each connected component of JT
const IScheduleMultiDim *	_marginalizeOut_ (Schedule &schedule, _ScheduleMultiDimSet_ pot_list, gum::VariableSet &del_vars, gum::VariableSet &kept_vars)
	removes variables del_vars from a list of tensors and returns the resulting list using schedules
const IScheduleMultiDim *	_marginalizeOut_ (_ScheduleMultiDimSet_ &pot_list, gum::VariableSet &del_vars, gum::VariableSet &kept_vars)
	removes variables del_vars from a list of tensors and returns the resulting list directly without schedules
void	_produceMessage_ (Schedule &schedule, NodeId from_id, NodeId to_id)
	creates the message sent by clique from_id to clique to_id using schedules
void	_produceMessage_ (NodeId from_id, NodeId to_id)
	creates the message sent by clique from_id to clique to_id without schedules
void	_collectMessage_ (Schedule &schedule, NodeId id, NodeId from)
	perform the collect phase using schedules
void	_collectMessage_ (NodeId id, NodeId from)
	actually perform the collect phase directly without schedules
Tensor< GUM_SCALAR > *	_unnormalizedJointPosterior_ (Schedule &schedule, NodeId id)
	computes the unnormalized posterior of a node using schedules
Tensor< GUM_SCALAR > *	_unnormalizedJointPosterior_ (NodeId id)
	computes the unnormalized posterior of a node without using schedules
Tensor< GUM_SCALAR > *	_unnormalizedJointPosterior_ (Schedule &schedule, const NodeSet &set)
	returns a fresh tensor equal to P(argument,evidence) using schedules
Tensor< GUM_SCALAR > *	_unnormalizedJointPosterior_ (const NodeSet &set)
	returns a fresh tensor equal to P(argument,evidence) without using schedules
	ShaferShenoyMRFInference (const ShaferShenoyMRFInference< GUM_SCALAR > &)=delete
	avoid copy constructors
ShaferShenoyMRFInference< GUM_SCALAR > &	operator= (const ShaferShenoyMRFInference< GUM_SCALAR > &)=delete
	avoid copy operators
void	_setAllMarginalTargets_ ()
	sets all the nodes of the Markov net as targets

Private Attributes
Tensor< GUM_SCALAR >(*	_projection_op_ )(const Tensor< GUM_SCALAR > &, const gum::VariableSet &)
	the operator for performing the projections
Tensor< GUM_SCALAR >(*	_combination_op_ )(const Tensor< GUM_SCALAR > &, const Tensor< GUM_SCALAR > &)
	the operator for performing the combinations
Triangulation *	_triangulation_
	the triangulation class creating the junction tree used for inference
bool	_use_binary_join_tree_ {true}
	indicates whether we should transform junction trees into binary join trees
UndiGraph	_graph_
	the undigraph extracted from the MRF and used to construct the join tree
JoinTree *	_JT_ {nullptr}
	the join (or junction) tree used to answer the last inference query
JunctionTree *	_junctionTree_ {nullptr}
	the junction tree to answer the last inference query
bool	_is_new_jt_needed_ {true}
	indicates whether a new join tree is needed for the next inference
NodeSet	_roots_
	a clique node used as a root in each connected component of JT
NodeProperty< NodeId >	_node_to_clique_
	for each node of graph (~ in the Markov net), associate an ID in the JT
HashTable< const Tensor< GUM_SCALAR > *, NodeId >	_factor_to_clique_
	assign to each factor in the MRF the clique that will contain it
NodeProperty< _TensorSet_ >	_node_to_factors_
	assign to each node the set of factors containing it
HashTable< NodeSet, NodeId >	_joint_target_to_clique_
	for each set target, assign a clique in the JT that contains it
NodeProperty< _ScheduleMultiDimSet_ >	_clique_tensors_
	the list of all tensors stored in the cliques
NodeProperty< const IScheduleMultiDim * >	_clique_ss_tensor_
	the tensors stored into the cliques by Shafer-Shenoy
ArcProperty< const IScheduleMultiDim * >	_separator_tensors_
	the list of all tensors stored in the separators after inferences
ArcProperty< const IScheduleMultiDim * >	_arc_to_created_tensors_
	the set of tensors created for the last inference messages
NodeProperty< const Tensor< GUM_SCALAR > * >	_target_posteriors_
	the set of single posteriors computed during the last inference
HashTable< NodeSet, const Tensor< GUM_SCALAR > * >	_joint_target_posteriors_
	the set of set target posteriors computed during the last inference
HashTable< const Tensor< GUM_SCALAR > *, GUM_SCALAR >	_constants_
	the constants resulting from the projections of CPTs defined over only hard evidence nodes @TODO remove this constant and insert the notion of a constant into tensors/multidim arrays
ArcProperty< bool >	_messages_computed_
	indicates whether a message (from one clique to another) has been computed
NodeProperty< const IScheduleMultiDim * >	_node_to_soft_evidence_
	the soft evidence stored in the cliques per their assigned node in the MRF
HashTable< const Tensor< GUM_SCALAR > *, const IScheduleMultiDim * >	_hard_ev_projected_factors_
	the factors that were projected due to hard evidence nodes
NodeSet	_hard_ev_nodes_
	the hard evidence nodes which were projected in factors
NodeProperty< EvidenceChangeType >	_evidence_changes_
	indicates which nodes of the MRF have evidence that changed since the last inference
bool	_use_schedules_ {false}
	indicates whether we should use schedules for inference
Set< NodeSet >	_joint_targets_
	the set of joint targets
bool	_targeted_mode_
	whether the actual targets are default
NodeSet	_targets_
	the set of marginal targets
SchedulerParallel	_scheduler_parallel_
SchedulerSequential	_scheduler_sequential_
Size	_nb_threads_ {0}
	the max number of threads used by the class

Static Private Attributes
static constexpr double	_schedule_threshold_ {1000000.0}
	minimal number of operations to perform in the JT to use schedules
static constexpr GUM_SCALAR	_one_minus_epsilon_ {GUM_SCALAR(1.0 - 1e-6)}
	for comparisons with 1 - epsilon

Detailed Description

template<typename GUM_SCALAR>
class gum::ShaferShenoyMRFInference< GUM_SCALAR >

<agrum/MRF/inference/ShaferShenoyMRFInference.h>

Implementation of Shafer-Shenoy's propagation algorithm for inference in Markov random fields

Definition at line 86 of file ShaferShenoyMRFInference.h.

Member Typedef Documentation

_ScheduleMultiDimSet_

template<typename GUM_SCALAR>

using gum::ShaferShenoyMRFInference< GUM_SCALAR >::_ScheduleMultiDimSet_ = Set< const IScheduleMultiDim* >

private

Definition at line 239 of file ShaferShenoyMRFInference.h.

_TensorSet_

template<typename GUM_SCALAR>

using gum::ShaferShenoyMRFInference< GUM_SCALAR >::_TensorSet_ = Set< const Tensor< GUM_SCALAR >* >

private

Definition at line 238 of file ShaferShenoyMRFInference.h.

_TensorSetIterator_

template<typename GUM_SCALAR>

using gum::ShaferShenoyMRFInference< GUM_SCALAR >::_TensorSetIterator_ = SetIteratorSafe< const Tensor< GUM_SCALAR >* >

private

Definition at line 240 of file ShaferShenoyMRFInference.h.

Member Enumeration Documentation

EvidenceChangeType

template<typename GUM_SCALAR>

enum gum::ShaferShenoyMRFInference::EvidenceChangeType

private

the possible types of evidence changes

Enumerator
EVIDENCE_ADDED
EVIDENCE_ERASED
EVIDENCE_MODIFIED

Definition at line 373 of file ShaferShenoyMRFInference.h.

{ EVIDENCE_ADDED, EVIDENCE_ERASED, EVIDENCE_MODIFIED };

StateOfInference

template<typename GUM_SCALAR>

enum class gum::GraphicalModelInference::StateOfInference

stronginherited

current state of the inference

graphicalModelInference can be in one of 4 different states:

• OutdatedStructure: in this state, the inference is fully unprepared to be applied because some events changed the "logical" structure of the model: for instance a node received a hard evidence, which implies that its outgoing arcs can be removed from the model, hence involving a structural change in the model.
• OutdatedTensors: in this state, the structure of the model remains unchanged, only some tensors stored in it have changed. Therefore, the inference probably just needs to invalidate some already computed tensors to be ready. Only a light amount of preparation is needed to be able to perform inference.
• Ready4Inference: in this state, all the data structures are ready for inference. There just remains to perform the inference computations.
• Done: the heavy computations of inference have been done. There might still remain a few light computations to perform to get the posterior tensors we need.

Enumerator
OutdatedStructure
OutdatedTensors
ReadyForInference
Done

Definition at line 127 of file graphicalModelInference.h.

{ OutdatedStructure, OutdatedTensors, ReadyForInference, Done };

Constructor & Destructor Documentation

ShaferShenoyMRFInference() [1/2]

template<typename GUM_SCALAR>

gum::ShaferShenoyMRFInference< GUM_SCALAR >::ShaferShenoyMRFInference ( const IMarkovRandomField< GUM_SCALAR > * MN, bool use_binary_join_tree = true )

explicit

default constructor

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

Here is the caller graph for this function:

~ShaferShenoyMRFInference()

template<typename GUM_SCALAR>

gum::ShaferShenoyMRFInference< GUM_SCALAR >::~ShaferShenoyMRFInference

(

)

destructor

ShaferShenoyMRFInference() [2/2]

template<typename GUM_SCALAR>

gum::ShaferShenoyMRFInference< GUM_SCALAR >::ShaferShenoyMRFInference ( const ShaferShenoyMRFInference< GUM_SCALAR > & )

privatedelete

avoid copy constructors

References ShaferShenoyMRFInference().

Here is the call graph for this function:

Member Function Documentation

_collectMessage_() [1/2]

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::_collectMessage_ ( NodeId id, NodeId from )

private

actually perform the collect phase directly without schedules

_collectMessage_() [2/2]

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::_collectMessage_ ( Schedule & schedule, NodeId id, NodeId from )

private

perform the collect phase using schedules

_computeJoinTreeRoots_()

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::_computeJoinTreeRoots_ ( )

private

compute a root for each connected component of JT

_createNewJT_()

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::_createNewJT_ ( )

private

create a new junction tree as well as its related data structures

_diffuseMessageInvalidations_()

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::_diffuseMessageInvalidations_ ( NodeId from_id, NodeId to_id, NodeSet & invalidated_cliques )

private

invalidate all the messages sent from a given clique

_initializeJTCliques_() [1/2]

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::_initializeJTCliques_ ( )

private

put all the CPTs into the cliques when creating the JT without using a schedule

_initializeJTCliques_() [2/2]

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::_initializeJTCliques_ ( Schedule & schedule )

private

put all the CPTs into the cliques when creating the JT using a schedule

_invalidateAllMessages_()

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::_invalidateAllMessages_ ( )

private

invalidate all messages, posteriors and created tensors

_isNewJTNeeded_()

template<typename GUM_SCALAR>

bool gum::ShaferShenoyMRFInference< GUM_SCALAR >::_isNewJTNeeded_ ( ) const

private

check whether a new join tree is really needed for the next inference

_marginalizeOut_() [1/2]

template<typename GUM_SCALAR>

const IScheduleMultiDim * gum::ShaferShenoyMRFInference< GUM_SCALAR >::_marginalizeOut_ ( _ScheduleMultiDimSet_ & pot_list, gum::VariableSet & del_vars, gum::VariableSet & kept_vars )

private

removes variables del_vars from a list of tensors and returns the resulting list directly without schedules

_marginalizeOut_() [2/2]

template<typename GUM_SCALAR>

const IScheduleMultiDim * gum::ShaferShenoyMRFInference< GUM_SCALAR >::_marginalizeOut_ ( Schedule & schedule, _ScheduleMultiDimSet_ pot_list, gum::VariableSet & del_vars, gum::VariableSet & kept_vars )

private

removes variables del_vars from a list of tensors and returns the resulting list using schedules

_produceMessage_() [1/2]

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::_produceMessage_ ( NodeId from_id, NodeId to_id )

private

creates the message sent by clique from_id to clique to_id without schedules

_produceMessage_() [2/2]

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::_produceMessage_ ( Schedule & schedule, NodeId from_id, NodeId to_id )

private

creates the message sent by clique from_id to clique to_id using schedules

_setAllMarginalTargets_()

template<typename GUM_SCALAR>

void gum::MarginalTargetedMRFInference< GUM_SCALAR >::_setAllMarginalTargets_ ( )

privateinherited

sets all the nodes of the Markov net as targets

Definition at line 222 of file marginalTargetedMRFInference_tpl.h.

                                                                           {
    _targets_.clear();
    if (!this->hasNoModel_()) {
      _targets_ = this->MRF().graph().asNodeSet();
      onAllMarginalTargetsAdded_();
    }
  }

References _targets_, gum::GraphicalModelInference< GUM_SCALAR >::hasNoModel_(), gum::MRFInference< GUM_SCALAR >::MRF(), and onAllMarginalTargetsAdded_().

Referenced by onModelChanged_().

Here is the call graph for this function:

Here is the caller graph for this function:

_setCombinationFunction_()

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::_setCombinationFunction_ ( Tensor< GUM_SCALAR >(* comb )(const Tensor< GUM_SCALAR > &, const Tensor< GUM_SCALAR > &) )

private

sets the operator for performing the combinations

_setProjectionFunction_()

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::_setProjectionFunction_ ( Tensor< GUM_SCALAR >(* proj )(const Tensor< GUM_SCALAR > &, const gum::VariableSet &) )

private

sets the operator for performing the projections

_unnormalizedJointPosterior_() [1/4]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > * gum::ShaferShenoyMRFInference< GUM_SCALAR >::_unnormalizedJointPosterior_ ( const NodeSet & set )

private

returns a fresh tensor equal to P(argument,evidence) without using schedules

_unnormalizedJointPosterior_() [2/4]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > * gum::ShaferShenoyMRFInference< GUM_SCALAR >::_unnormalizedJointPosterior_ ( NodeId id )

private

computes the unnormalized posterior of a node without using schedules

_unnormalizedJointPosterior_() [3/4]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > * gum::ShaferShenoyMRFInference< GUM_SCALAR >::_unnormalizedJointPosterior_ ( Schedule & schedule, const NodeSet & set )

private

returns a fresh tensor equal to P(argument,evidence) using schedules

_unnormalizedJointPosterior_() [4/4]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > * gum::ShaferShenoyMRFInference< GUM_SCALAR >::_unnormalizedJointPosterior_ ( Schedule & schedule, NodeId id )

private

computes the unnormalized posterior of a node using schedules

addAllTargets()

template<typename GUM_SCALAR>

void gum::MarginalTargetedMRFInference< GUM_SCALAR >::addAllTargets ( )

finalvirtualinherited

adds all nodes as targets

Definition at line 143 of file marginalTargetedMRFInference_tpl.h.

                                                                 {
    // check if the node belongs to the Markov random field
    if (this->hasNoModel_())
      GUM_ERROR(NullElement,
                "No Markov net has been assigned to the "
                "inference algorithm");
 
 
    setTargetedMode_();   // does nothing if already in targeted mode
    for (const auto target: this->MRF().graph()) {
      if (!_targets_.contains(target)) {
        _targets_.insert(target);
        onMarginalTargetAdded_(target);
        this->setState_(MRFInference< GUM_SCALAR >::StateOfInference::OutdatedStructure);
      }
    }
  }

References _targets_, GUM_ERROR, gum::GraphicalModelInference< GUM_SCALAR >::hasNoModel_(), gum::MRFInference< GUM_SCALAR >::MRF(), onMarginalTargetAdded_(), gum::GraphicalModelInference< GUM_SCALAR >::OutdatedStructure, gum::GraphicalModelInference< GUM_SCALAR >::setState_(), and setTargetedMode_().

Here is the call graph for this function:

addEvidence() [1/8]

template<typename GUM_SCALAR>

INLINE void gum::GraphicalModelInference< GUM_SCALAR >::addEvidence ( const std::string & 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 235 of file graphicalModelInference_tpl.h.

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

References addEvidence(), and model().

Here is the call graph for this function:

addEvidence() [2/8]

template<typename GUM_SCALAR>

INLINE void gum::GraphicalModelInference< GUM_SCALAR >::addEvidence ( const std::string & nodeName, const std::string & 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 249 of file graphicalModelInference_tpl.h.

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

References addEvidence(), and model().

Here is the call graph for this function:

addEvidence() [3/8]

template<typename GUM_SCALAR>

void gum::GraphicalModelInference< GUM_SCALAR >::addEvidence ( const std::string & 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 281 of file graphicalModelInference_tpl.h.

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

References addEvidence(), and model().

Here is the call graph for this function:

addEvidence() [4/8]

template<typename GUM_SCALAR>

INLINE void gum::GraphicalModelInference< 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 323 of file graphicalModelInference_tpl.h.

                                                                                                {
    Tensor< GUM_SCALAR > new_pot(pot);
    addEvidence(std::move(new_pot));
  }

References addEvidence().

Here is the call graph for this function:

addEvidence() [5/8]

template<typename GUM_SCALAR>

INLINE void gum::GraphicalModelInference< 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 229 of file graphicalModelInference_tpl.h.

                                                                                         {
    addEvidence(_createHardEvidence_(id, val));
  }

References _createHardEvidence_(), and addEvidence().

Referenced by addEvidence(), addEvidence(), addEvidence(), addEvidence(), addEvidence(), addEvidence(), addEvidence(), addListOfEvidence(), addSetOfEvidence(), gum::MarginalTargetedInference< GUM_SCALAR >::evidenceImpact(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::evidenceImpact(), gum::JointTargetedInference< GUM_SCALAR >::evidenceJointImpact(), gum::JointTargetedMRFInference< GUM_SCALAR >::evidenceJointImpact(), and gum::LoopySamplingInference< GUM_SCALAR, APPROX >::makeInference_().

Here is the call graph for this function:

Here is the caller graph for this function:

addEvidence() [6/8]

template<typename GUM_SCALAR>

INLINE void gum::GraphicalModelInference< GUM_SCALAR >::addEvidence ( NodeId id, const std::string & 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 242 of file graphicalModelInference_tpl.h.

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

References addEvidence(), and model().

Here is the call graph for this function:

addEvidence() [7/8]

template<typename GUM_SCALAR>

void gum::GraphicalModelInference< 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 257 of file graphicalModelInference_tpl.h.

                                                                                               {
    // checks that the evidence is meaningful
    if (_model_ == nullptr)
      GUM_ERROR(NullElement,
                "No Bayes net has been assigned to the "
                "inference algorithm");
 
    if (!_model_->exists(id)) { GUM_ERROR(UndefinedElement, id << " is not a NodeId in the model") }
 
    if (_model_->variable(id).domainSize() != vals.size()) {
      GUM_ERROR(InvalidArgument,
                "node " << _model_->variable(id)
                        << " and its evidence vector have different sizes.");
    }
 
    Tensor< GUM_SCALAR > pot;
    pot.add(_model_->variable(id));
    pot.fillWith(vals);
    addEvidence(std::move(pot));
  }

References _model_, addEvidence(), and GUM_ERROR.

Here is the call graph for this function:

addEvidence() [8/8]

template<typename GUM_SCALAR>

void gum::GraphicalModelInference< GUM_SCALAR >::addEvidence ( 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 288 of file graphicalModelInference_tpl.h.

                                                                                    {
    // check if the tensor corresponds to an evidence
    if (pot.nbrDim() != 1) { GUM_ERROR(InvalidArgument, pot << " is not mono-dimensional.") }
    if (_model_ == nullptr)
      GUM_ERROR(NullElement,
                "No Bayes net has been assigned to the "
                "inference algorithm");
 
    NodeId id = _model_->nodeId(pot.variable(0));
 
    if (hasEvidence(id)) {
      GUM_ERROR(InvalidArgument,
                " node " << id << " already has an evidence. Please use chgEvidence().");
    }
 
    // check whether we have a hard evidence (and also check whether the
    // tensor only contains 0 (in this case, this will automatically raise
    // an exception) )
    Idx  val              = 0;
    bool is_hard_evidence = _isHardEvidence_(pot, val);
 
    // insert the evidence
    _evidence_.insert(id, new Tensor< GUM_SCALAR >(std::forward< Tensor< GUM_SCALAR > >(pot)));
    if (is_hard_evidence) {   // pot is deterministic
      _hard_evidence_.insert(id, val);
      _hard_evidence_nodes_.insert(id);
    } else {
      _soft_evidence_nodes_.insert(id);
    }
    setState_(StateOfInference::OutdatedStructure);
    onEvidenceAdded_(id, is_hard_evidence);
  }

References _evidence_, _hard_evidence_, _hard_evidence_nodes_, _isHardEvidence_(), _model_, _soft_evidence_nodes_, GUM_ERROR, hasEvidence(), onEvidenceAdded_(), OutdatedStructure, and setState_().

Here is the call graph for this function:

addJointTarget()

template<typename GUM_SCALAR>

void gum::JointTargetedMRFInference< GUM_SCALAR >::addJointTarget ( const NodeSet & joint_target )

finalvirtualinherited

Add a set of nodes as a new joint target. As a collateral effect, every node is added as a marginal target.

Exceptions

UndefinedElement

if some node(s) do not belong to the Markov net

Definition at line 126 of file jointTargetedMRFInference_tpl.h.

                                                                                          {
    // check if the nodes in the target belong to the Markov random field
    if (this->hasNoModel_())
      GUM_ERROR(NullElement,
                "No Markov net has been assigned to the "
                "inference algorithm");
 
    const auto& dag = this->MRF().graph();
    for (const auto node: joint_target) {
      if (!dag.exists(node)) {
        GUM_ERROR(UndefinedElement,
                  "at least one one in " << joint_target << " does not belong to the mn");
      }
    }
 
    if (isExactJointComputable_(joint_target)) return;
    if (!superForJointComputable_(joint_target).empty()) return;
 
    // check if joint_target is a subset of an already existing target
    for (const auto& target: _joint_targets_) {
      if (target.isStrictSupersetOf(joint_target)) return;
    }
 
    // check if joint_target is not a superset of an already existing target
    // in this case, we need to remove old existing target
    for (auto iter = _joint_targets_.beginSafe(); iter != _joint_targets_.endSafe(); ++iter) {
      if (iter->isStrictSubsetOf(joint_target)) eraseJointTarget(*iter);
    }
 
    this->setTargetedMode_();   // does nothing if already in targeted mode
    _joint_targets_.insert(joint_target);
    onJointTargetAdded_(joint_target);
    this->setState_(MRFInference< GUM_SCALAR >::StateOfInference::OutdatedStructure);
  }

References _joint_targets_, eraseJointTarget(), GUM_ERROR, gum::GraphicalModelInference< GUM_SCALAR >::hasNoModel_(), isExactJointComputable_(), gum::MRFInference< GUM_SCALAR >::MRF(), onJointTargetAdded_(), gum::GraphicalModelInference< GUM_SCALAR >::OutdatedStructure, gum::GraphicalModelInference< GUM_SCALAR >::setState_(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::setTargetedMode_(), and superForJointComputable_().

Referenced by evidenceJointImpact(), and jointMutualInformation().

Here is the call graph for this function:

Here is the caller graph for this function:

addListOfEvidence()

template<typename GUM_SCALAR>

INLINE void gum::GraphicalModelInference< GUM_SCALAR >::addListOfEvidence ( const List< const Tensor< GUM_SCALAR > * > & potlist )

finalvirtualinherited

adds a new list of evidence

Exceptions

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

Definition at line 330 of file graphicalModelInference_tpl.h.

                                                          {
    for (const auto pot: potlist)
      addEvidence(*pot);
  }

References addEvidence().

Here is the call graph for this function:

addSetOfEvidence()

template<typename GUM_SCALAR>

INLINE void gum::GraphicalModelInference< GUM_SCALAR >::addSetOfEvidence ( const Set< const Tensor< GUM_SCALAR > * > & potset )

finalvirtualinherited

adds a new set of evidence

Exceptions

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

Definition at line 338 of file graphicalModelInference_tpl.h.

                                                        {
    for (const auto pot: potset)
      addEvidence(*pot);
  }

References addEvidence().

Here is the call graph for this function:

addTarget() [1/2]

template<typename GUM_SCALAR>

void gum::MarginalTargetedMRFInference< GUM_SCALAR >::addTarget ( const std::string & nodeName )

finalvirtualinherited

Add a marginal target to the list of targets.

Exceptions

UndefinedElement

if target is not a NodeId in the Markov net

Definition at line 163 of file marginalTargetedMRFInference_tpl.h.

                                                                                      {
    // check if the node belongs to the Markov random field
    if (this->hasNoModel_())
      GUM_ERROR(NullElement,
                "No Markov net has been assigned to the "
                "inference algorithm");
 
    addTarget(this->MRF().idFromName(nodeName));
  }

References addTarget(), GUM_ERROR, gum::GraphicalModelInference< GUM_SCALAR >::hasNoModel_(), and gum::MRFInference< GUM_SCALAR >::MRF().

Here is the call graph for this function:

addTarget() [2/2]

template<typename GUM_SCALAR>

void gum::MarginalTargetedMRFInference< GUM_SCALAR >::addTarget ( NodeId target )

finalvirtualinherited

Add a marginal target to the list of targets.

Exceptions

UndefinedElement

if target is not a NodeId in the Markov net

Definition at line 121 of file marginalTargetedMRFInference_tpl.h.

                                                                          {
    // check if the node belongs to the Markov random field
    if (this->hasNoModel_())
      GUM_ERROR(NullElement,
                "No Markov net has been assigned to the "
                "inference algorithm");
 
    if (!this->MRF().graph().exists(target)) {
      GUM_ERROR(UndefinedElement, target << " is not a NodeId in the Markov random field")
    }
 
    setTargetedMode_();   // does nothing if already in targeted mode
    // add the new target
    if (!_targets_.contains(target)) {
      _targets_.insert(target);
      onMarginalTargetAdded_(target);
      this->setState_(MRFInference< GUM_SCALAR >::StateOfInference::OutdatedStructure);
    }
  }

References _targets_, GUM_ERROR, gum::GraphicalModelInference< GUM_SCALAR >::hasNoModel_(), gum::MRFInference< GUM_SCALAR >::MRF(), onMarginalTargetAdded_(), gum::GraphicalModelInference< GUM_SCALAR >::OutdatedStructure, gum::GraphicalModelInference< GUM_SCALAR >::setState_(), and setTargetedMode_().

Referenced by addTarget(), and evidenceImpact().

Here is the call graph for this function:

Here is the caller graph for this function:

chgEvidence() [1/7]

template<typename GUM_SCALAR>

INLINE void gum::GraphicalModelInference< GUM_SCALAR >::chgEvidence ( const std::string & nodeName, const Idx val )

finalvirtualinherited

change the value of an already existing hard evidence

Exceptions

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

Definition at line 397 of file graphicalModelInference_tpl.h.

                                                                                         {
    chgEvidence(this->model().idFromName(nodeName), val);
  }

References chgEvidence(), and model().

Here is the call graph for this function:

chgEvidence() [2/7]

template<typename GUM_SCALAR>

INLINE void gum::GraphicalModelInference< GUM_SCALAR >::chgEvidence ( const std::string & nodeName, const std::string & label )

finalvirtualinherited

change the value of an already existing hard evidence

Exceptions

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

Definition at line 411 of file graphicalModelInference_tpl.h.

                                                                                         {
    NodeId id = this->model().idFromName(nodeName);
    chgEvidence(id, this->model().variable(id)[label]);
  }

References chgEvidence(), and model().

Here is the call graph for this function:

chgEvidence() [3/7]

template<typename GUM_SCALAR>

INLINE void gum::GraphicalModelInference< GUM_SCALAR >::chgEvidence ( const std::string & nodeName, const std::vector< GUM_SCALAR > & vals )

finalvirtualinherited

change the value of an already existing evidence (might be soft or hard)

Exceptions

UndefinedElement	if nodeName does not belong to the Bayesian network
InvalidArgument	if the node does not already have 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 445 of file graphicalModelInference_tpl.h.

                                                                                              {
    chgEvidence(this->model().idFromName(nodeName), vals);
  }

References chgEvidence(), and model().

Here is the call graph for this function:

chgEvidence() [4/7]

template<typename GUM_SCALAR>

void gum::GraphicalModelInference< GUM_SCALAR >::chgEvidence ( const Tensor< GUM_SCALAR > & pot )

finalvirtualinherited

change the value of an already existing evidence (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 does not already have an evidence
FatalError	if pot=[0,0,...,0]

Definition at line 452 of file graphicalModelInference_tpl.h.

                                                                                         {
    // check if the tensor corresponds to an evidence
    if (pot.nbrDim() != 1) {
      GUM_ERROR(InvalidArgument, pot << " is not a mono-dimensional tensor.")
    }
    if (_model_ == nullptr)
      GUM_ERROR(NullElement,
                "No Bayes net has been assigned to the "
                "inference algorithm");
 
    NodeId id = _model_->nodeId(pot.variable(0));
 
    if (!hasEvidence(id)) {
      GUM_ERROR(InvalidArgument, id << " has no evidence. Please use addEvidence().")
    }
 
    // check whether we have a hard evidence (and also check whether the
    // tensor only contains 0 (in this case, this will automatically raise
    // an exception) )
    Idx  val;
    bool is_hard_evidence = _isHardEvidence_(pot, val);
 
    // modify the evidence already stored
    const Tensor< GUM_SCALAR >* localPot = _evidence_[id];
    Instantiation               I(pot);
    for (I.setFirst(); !I.end(); I.inc()) {
      localPot->set(I, pot[I]);
    }
 
    // the inference state will be different
    // whether evidence change from Hard to Soft or not.
    bool hasChangedSoftHard = false;
 
    if (is_hard_evidence) {
      if (!hasHardEvidence(id)) {
        hasChangedSoftHard = true;
        _hard_evidence_.insert(id, val);
        _hard_evidence_nodes_.insert(id);
        _soft_evidence_nodes_.erase(id);
      } else {
        _hard_evidence_[id] = val;
      }
    } else {
      if (hasHardEvidence(id)) {   // evidence was hard
        _hard_evidence_.erase(id);
        _hard_evidence_nodes_.erase(id);
        _soft_evidence_nodes_.insert(id);
        hasChangedSoftHard = true;
      }
    }
 
    if (hasChangedSoftHard) {
      setState_(StateOfInference::OutdatedStructure);
    } else {
      if (!isInferenceOutdatedStructure()) { setState_(StateOfInference::OutdatedTensors); }
    }
 
    onEvidenceChanged_(id, hasChangedSoftHard);
  }

References _evidence_, _hard_evidence_, _hard_evidence_nodes_, _isHardEvidence_(), _model_, _soft_evidence_nodes_, gum::Instantiation::end(), GUM_ERROR, hasEvidence(), hasHardEvidence(), gum::Instantiation::inc(), isInferenceOutdatedStructure(), onEvidenceChanged_(), OutdatedStructure, OutdatedTensors, gum::Instantiation::setFirst(), and setState_().

Here is the call graph for this function:

chgEvidence() [5/7]

template<typename GUM_SCALAR>

INLINE void gum::GraphicalModelInference< GUM_SCALAR >::chgEvidence ( NodeId id, const Idx val )

finalvirtualinherited

change the value of an already existing hard evidence

Exceptions

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

Definition at line 391 of file graphicalModelInference_tpl.h.

                                                                                         {
    chgEvidence(_createHardEvidence_(id, val));
  }

References _createHardEvidence_(), and chgEvidence().

Referenced by chgEvidence(), chgEvidence(), chgEvidence(), chgEvidence(), chgEvidence(), chgEvidence(), gum::MarginalTargetedInference< GUM_SCALAR >::evidenceImpact(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::evidenceImpact(), gum::JointTargetedInference< GUM_SCALAR >::evidenceJointImpact(), and gum::JointTargetedMRFInference< GUM_SCALAR >::evidenceJointImpact().

Here is the call graph for this function:

Here is the caller graph for this function:

chgEvidence() [6/7]

template<typename GUM_SCALAR>

INLINE void gum::GraphicalModelInference< GUM_SCALAR >::chgEvidence ( NodeId id, const std::string & label )

finalvirtualinherited

change the value of an already existing hard evidence

Exceptions

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

Definition at line 404 of file graphicalModelInference_tpl.h.

                                                                                         {
    chgEvidence(id, this->model().variable(id)[label]);
  }

References chgEvidence(), and model().

Here is the call graph for this function:

chgEvidence() [7/7]

template<typename GUM_SCALAR>

INLINE void gum::GraphicalModelInference< GUM_SCALAR >::chgEvidence ( NodeId id, const std::vector< GUM_SCALAR > & vals )

finalvirtualinherited

change the value of an already existing evidence (might be soft or hard)

Exceptions

UndefinedElement	if id does not belong to the Bayesian network
InvalidArgument	if the node does not already have 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 420 of file graphicalModelInference_tpl.h.

                                                                                              {
    // check whether this corresponds to an evidence
    if (_model_ == nullptr)
      GUM_ERROR(NullElement,
                "No Bayes net has been assigned to the "
                "inference algorithm");
 
    if (!_model_->exists(id)) { GUM_ERROR(UndefinedElement, id << " is not a NodeId in the model") }
 
    if (_model_->variable(id).domainSize() != vals.size()) {
      GUM_ERROR(InvalidArgument,
                "node " << _model_->variable(id) << " and its evidence have different sizes.");
    }
 
    // create the tensor corresponding to vals
    Tensor< GUM_SCALAR > pot;
    pot.add(_model_->variable(id));
    pot.fillWith(vals);
    chgEvidence(pot);
  }

References _model_, chgEvidence(), and GUM_ERROR.

Here is the call graph for this function:

clear()

template<typename GUM_SCALAR>

INLINE void gum::GraphicalModelInference< GUM_SCALAR >::clear ( )

virtualinherited

clears all the data structures allocated for the last inference

Reimplemented in gum::ShaferShenoyLIMIDInference< GUM_SCALAR >.

Definition at line 155 of file graphicalModelInference_tpl.h.

                                                           {
    eraseAllEvidence();
    setState_(StateOfInference::OutdatedStructure);
  }

References eraseAllEvidence(), OutdatedStructure, and setState_().

Referenced by setModel_().

Here is the call graph for this function:

Here is the caller graph for this function:

clone()

ScheduledInference * gum::ScheduledInference::clone ( ) const

virtualinherited

virtual copy constructor

Definition at line 104 of file scheduledInference.cpp.

{ return new ScheduledInference(*this); }

References ScheduledInference().

Here is the call graph for this function:

domainSizes()

template<typename GUM_SCALAR>

INLINE const NodeProperty< Size > & gum::GraphicalModelInference< GUM_SCALAR >::domainSizes ( ) const

finalvirtualinherited

get the domain sizes of the random variables of the model

Definition at line 173 of file graphicalModelInference_tpl.h.

                                                                                              {
    return _domain_sizes_;
  }

References _domain_sizes_.

eraseAllEvidence()

template<typename GUM_SCALAR>

INLINE void gum::GraphicalModelInference< GUM_SCALAR >::eraseAllEvidence ( )

finalvirtualinherited

removes all the evidence entered into the network

Definition at line 540 of file graphicalModelInference_tpl.h.

                                                                      {
    bool has_hard_evidence = !_hard_evidence_.empty();
    this->onAllEvidenceErased_(has_hard_evidence);
 
    for (const auto& pair: _evidence_) {
      if (pair.second != nullptr) { delete (pair.second); }
    }
 
    _evidence_.clear();
    _hard_evidence_.clear();
    _hard_evidence_nodes_.clear();
    _soft_evidence_nodes_.clear();
 
    if (has_hard_evidence) {
      setState_(StateOfInference::OutdatedStructure);
    } else {
      if (!isInferenceOutdatedStructure()) { setState_(StateOfInference::OutdatedTensors); }
    }
  }

References _evidence_, _hard_evidence_, _hard_evidence_nodes_, _soft_evidence_nodes_, isInferenceOutdatedStructure(), onAllEvidenceErased_(), OutdatedStructure, OutdatedTensors, and setState_().

Referenced by clear(), gum::MarginalTargetedInference< GUM_SCALAR >::evidenceImpact(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::evidenceImpact(), gum::JointTargetedInference< GUM_SCALAR >::evidenceJointImpact(), gum::JointTargetedMRFInference< GUM_SCALAR >::evidenceJointImpact(), gum::JointTargetedInference< GUM_SCALAR >::jointMutualInformation(), and gum::JointTargetedMRFInference< GUM_SCALAR >::jointMutualInformation().

Here is the call graph for this function:

Here is the caller graph for this function:

eraseAllJointTargets()

template<typename GUM_SCALAR>

INLINE void gum::JointTargetedMRFInference< GUM_SCALAR >::eraseAllJointTargets ( )

finalvirtualinherited

Clear all previously defined joint targets.

Definition at line 108 of file jointTargetedMRFInference_tpl.h.

                                                                            {
    if (_joint_targets_.size() > 0) {
      // we already are in target mode. So no this->setTargetedMode_();  is needed
      onAllJointTargetsErased_();
      _joint_targets_.clear();
      this->setState_(MRFInference< GUM_SCALAR >::StateOfInference::OutdatedStructure);
    }
  }

References _joint_targets_, onAllJointTargetsErased_(), gum::GraphicalModelInference< GUM_SCALAR >::OutdatedStructure, and gum::GraphicalModelInference< GUM_SCALAR >::setState_().

Referenced by eraseAllTargets().

Here is the call graph for this function:

Here is the caller graph for this function:

eraseAllMarginalTargets()

template<typename GUM_SCALAR>

INLINE void gum::JointTargetedMRFInference< GUM_SCALAR >::eraseAllMarginalTargets ( )

finalvirtualinherited

Clear all the previously defined marginal targets.

Definition at line 102 of file jointTargetedMRFInference_tpl.h.

                                                                               {
    MarginalTargetedMRFInference< GUM_SCALAR >::eraseAllTargets();
  }

References gum::MarginalTargetedMRFInference< GUM_SCALAR >::eraseAllTargets().

Referenced by eraseAllTargets().

Here is the call graph for this function:

Here is the caller graph for this function:

eraseAllTargets()

template<typename GUM_SCALAR>

INLINE void gum::JointTargetedMRFInference< GUM_SCALAR >::eraseAllTargets ( )

finalvirtualinherited

Clear all previously defined targets (marginal and joint targets).

Clear all previously defined targets. As a result, no posterior can be computed (since we can only compute the posteriors of the marginal or joint targets that have been added by the user).

Reimplemented from gum::MarginalTargetedMRFInference< GUM_SCALAR >.

Definition at line 119 of file jointTargetedMRFInference_tpl.h.

                                                                       {
    eraseAllMarginalTargets();
    eraseAllJointTargets();
  }

References eraseAllJointTargets(), and eraseAllMarginalTargets().

Referenced by evidenceJointImpact(), and jointMutualInformation().

Here is the call graph for this function:

Here is the caller graph for this function:

eraseEvidence() [1/2]

template<typename GUM_SCALAR>

INLINE void gum::GraphicalModelInference< GUM_SCALAR >::eraseEvidence ( const std::string & nodeName )

finalvirtualinherited

removed the evidence, if any, corresponding to node of name nodeName

Definition at line 534 of file graphicalModelInference_tpl.h.

                                                                                            {
    eraseEvidence(this->model().idFromName(nodeName));
  }

References eraseEvidence(), and model().

Here is the call graph for this function:

eraseEvidence() [2/2]

template<typename GUM_SCALAR>

INLINE void gum::GraphicalModelInference< GUM_SCALAR >::eraseEvidence ( NodeId id )

finalvirtualinherited

removed the evidence, if any, corresponding to node id

Definition at line 514 of file graphicalModelInference_tpl.h.

                                                                            {
    if (hasEvidence(id)) {
      if (hasHardEvidence(id)) {
        onEvidenceErased_(id, true);
        _hard_evidence_.erase(id);
        _hard_evidence_nodes_.erase(id);
        setState_(StateOfInference::OutdatedStructure);
      } else {
        onEvidenceErased_(id, false);
        _soft_evidence_nodes_.erase(id);
        if (!isInferenceOutdatedStructure()) { setState_(StateOfInference::OutdatedTensors); }
      }
 
      delete (_evidence_[id]);
      _evidence_.erase(id);
    }
  }

References _evidence_, _hard_evidence_, _hard_evidence_nodes_, _soft_evidence_nodes_, hasEvidence(), hasHardEvidence(), isInferenceOutdatedStructure(), onEvidenceErased_(), OutdatedStructure, OutdatedTensors, and setState_().

Referenced by eraseEvidence().

Here is the call graph for this function:

Here is the caller graph for this function:

eraseJointTarget()

template<typename GUM_SCALAR>

void gum::JointTargetedMRFInference< GUM_SCALAR >::eraseJointTarget ( const NodeSet & joint_target )

finalvirtualinherited

removes an existing joint target

Warning

If the joint target does not already exist, the method does nothing. In particular, it does not raise any exception.

Definition at line 163 of file jointTargetedMRFInference_tpl.h.

                                                                                            {
    // check if the nodes in the target belong to the Markov random field
    if (this->hasNoModel_())
      GUM_ERROR(NullElement,
                "No Markov net has been assigned to the "
                "inference algorithm");
 
    const auto& dag = this->MRF().graph();
    for (const auto node: joint_target) {
      if (!dag.exists(node)) {
        GUM_ERROR(UndefinedElement,
                  "at least one one in " << joint_target << " does not belong to the mn");
      }
    }
 
    // check that the joint_target set does not contain the new target
    if (_joint_targets_.contains(joint_target)) {
      // note that we have to be in target mode when we are here
      // so, no this->setTargetedMode_();  is necessary
      onJointTargetErased_(joint_target);
      _joint_targets_.erase(joint_target);
      this->setState_(MRFInference< GUM_SCALAR >::StateOfInference::OutdatedStructure);
    }
  }

References _joint_targets_, GUM_ERROR, gum::GraphicalModelInference< GUM_SCALAR >::hasNoModel_(), gum::MRFInference< GUM_SCALAR >::MRF(), onJointTargetErased_(), gum::GraphicalModelInference< GUM_SCALAR >::OutdatedStructure, and gum::GraphicalModelInference< GUM_SCALAR >::setState_().

Referenced by addJointTarget().

Here is the call graph for this function:

Here is the caller graph for this function:

eraseTarget() [1/2]

template<typename GUM_SCALAR>

void gum::MarginalTargetedMRFInference< GUM_SCALAR >::eraseTarget ( const std::string & nodeName )

finalvirtualinherited

removes an existing (marginal) target

Warning

If the target does not already exist, the method does nothing. In particular, it does not raise any exception.

Definition at line 198 of file marginalTargetedMRFInference_tpl.h.

                                                                                        {
    // check if the node belongs to the Markov random field
    if (this->hasNoModel_())
      GUM_ERROR(NullElement,
                "No Markov net has been assigned to the "
                "inference algorithm");
 
    eraseTarget(this->MRF().idFromName(nodeName));
  }

References eraseTarget(), GUM_ERROR, gum::GraphicalModelInference< GUM_SCALAR >::hasNoModel_(), and gum::MRFInference< GUM_SCALAR >::MRF().

Here is the call graph for this function:

eraseTarget() [2/2]

template<typename GUM_SCALAR>

void gum::MarginalTargetedMRFInference< GUM_SCALAR >::eraseTarget ( NodeId target )

finalvirtualinherited

removes an existing (marginal) target

Warning

If the target does not already exist, the method does nothing. In particular, it does not raise any exception.

Definition at line 175 of file marginalTargetedMRFInference_tpl.h.

                                                                            {
    // check if the node belongs to the Markov random field
    if (this->hasNoModel_())
      GUM_ERROR(NullElement,
                "No Markov net has been assigned to the "
                "inference algorithm");
 
    if (!this->MRF().graph().exists(target)) {
      GUM_ERROR(UndefinedElement, target << " is not a NodeId in the Markov random field")
    }
 
 
    if (_targets_.contains(target)) {
      _targeted_mode_ = true;   // we do not use setTargetedMode_ because we do not
                                // want to clear the targets
      onMarginalTargetErased_(target);
      _targets_.erase(target);
      this->setState_(MRFInference< GUM_SCALAR >::StateOfInference::OutdatedStructure);
    }
  }

References _targeted_mode_, _targets_, GUM_ERROR, gum::GraphicalModelInference< GUM_SCALAR >::hasNoModel_(), gum::MRFInference< GUM_SCALAR >::MRF(), onMarginalTargetErased_(), gum::GraphicalModelInference< GUM_SCALAR >::OutdatedStructure, and gum::GraphicalModelInference< GUM_SCALAR >::setState_().

Referenced by eraseTarget().

Here is the call graph for this function:

Here is the caller graph for this function:

evidence()

template<typename GUM_SCALAR>

INLINE const NodeProperty< const Tensor< GUM_SCALAR > * > & gum::GraphicalModelInference< GUM_SCALAR >::evidence ( ) const

inherited

returns the set of evidence

Definition at line 587 of file graphicalModelInference_tpl.h.

                                                                     {
    return _evidence_;
  }

References _evidence_.

Referenced by gum::ImportanceSampling< GUM_SCALAR >::onContextualize_(), gum::MarginalTargetedInference< GUM_SCALAR >::posterior(), and gum::MarginalTargetedMRFInference< GUM_SCALAR >::posterior().

Here is the caller graph for this function:

evidenceImpact() [1/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::MarginalTargetedMRFInference< GUM_SCALAR >::evidenceImpact ( const std::string & target, const std::vector< std::string > & evs )

inherited

Create a gum::Tensor for P(target|evs) (for all instanciation of target and evs).

Warning

If some evs are d-separated, they are not included in the Tensor

Parameters

target	the nodeId of the target variable
evs	the nodeId of the observed variable

Returns

a Tensor

Definition at line 312 of file marginalTargetedMRFInference_tpl.h.

                                         {
    const auto& mn = this->MRF();
    return evidenceImpact(mn.idFromName(target), mn.nodeset(evs));
  }

References evidenceImpact(), and gum::MRFInference< GUM_SCALAR >::MRF().

Here is the call graph for this function:

evidenceImpact() [2/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::MarginalTargetedMRFInference< GUM_SCALAR >::evidenceImpact ( NodeId target, const NodeSet & evs )

inherited

Create a gum::Tensor for P(target|evs) (for all instanciation of target and evs).

Warning

If some evs are d-separated, they are not included in the Tensor

Parameters

mn	the MarkovRandomField
target	the nodeId of the targetted variable
evs	the vector of nodeId of the observed variables

Returns

a Tensor

Definition at line 274 of file marginalTargetedMRFInference_tpl.h.

                                                                                     {
    const auto& vtarget = this->MRF().variable(target);
 
    if (evs.contains(target)) {
      GUM_ERROR(InvalidArgument,
                "Target <" << vtarget.name() << "> (" << target << ") can not be in evs (" << evs
                           << ").");
    }
    auto condset = this->MRF().minimalCondSet(target, evs);
 
    Tensor< GUM_SCALAR > res;
    this->eraseAllTargets();
    this->eraseAllEvidence();
    res.add(this->MRF().variable(target));
    this->addTarget(target);
    for (const auto& n: condset) {
      res.add(this->MRF().variable(n));
      this->addEvidence(n, 0);
    }
 
    Instantiation inst(res);
    for (inst.setFirst(); !inst.end(); inst.incNotVar(vtarget)) {
      // inferring
      for (const auto& n: condset)
        this->chgEvidence(n, inst.val(this->MRF().variable(n)));
      this->makeInference();
      // populate res
      for (inst.setFirstVar(vtarget); !inst.end(); inst.incVar(vtarget)) {
        res.set(inst, this->posterior(target)[inst]);
      }
      inst.setFirstVar(vtarget);   // remove inst.end() flag
    }
 
    return res;
  }

References gum::GraphicalModelInference< GUM_SCALAR >::addEvidence(), addTarget(), gum::GraphicalModelInference< GUM_SCALAR >::chgEvidence(), gum::Set< Key >::contains(), gum::Instantiation::end(), gum::GraphicalModelInference< GUM_SCALAR >::eraseAllEvidence(), eraseAllTargets(), GUM_ERROR, gum::Instantiation::incNotVar(), gum::Instantiation::incVar(), gum::GraphicalModelInference< GUM_SCALAR >::makeInference(), gum::MRFInference< GUM_SCALAR >::MRF(), posterior(), gum::Instantiation::setFirst(), gum::Instantiation::setFirstVar(), and gum::Instantiation::val().

Referenced by evidenceImpact().

Here is the call graph for this function:

Here is the caller graph for this function:

evidenceJointImpact() [1/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::JointTargetedMRFInference< GUM_SCALAR >::evidenceJointImpact ( const NodeSet & targets, const NodeSet & evs )

inherited

Create a gum::Tensor for P(joint targets|evs) (for all instanciation of targets and evs).

Warning

If some evs are d-separated, they are not included in the Tensor

Parameters

targets	the NodeSet of the targeted variables
evs	the NodeSet of observed variables

Returns

a Tensor

Definition at line 254 of file jointTargetedMRFInference_tpl.h.

                                                                                       {
    if (!(evs * targets).empty()) {
      GUM_ERROR(InvalidArgument,
                "Targets (" << targets << ") can not intersect evs (" << evs << ").");
    }
    auto condset = this->MRF().minimalCondSet(targets, evs);
 
    this->eraseAllTargets();
    this->eraseAllEvidence();
 
    Instantiation        iTarget;
    Tensor< GUM_SCALAR > res;
    for (const auto& target: targets) {
      res.add(this->MRF().variable(target));
      iTarget.add(this->MRF().variable(target));
    }
    this->addJointTarget(targets);
 
    for (const auto& n: condset) {
      res.add(this->MRF().variable(n));
      this->addEvidence(n, 0);
    }
 
    Instantiation inst(res);
    for (inst.setFirstOut(iTarget); !inst.end(); inst.incOut(iTarget)) {
      // inferring
      for (const auto& n: condset)
        this->chgEvidence(n, inst.val(this->MRF().variable(n)));
      this->makeInference();
      // populate res
      for (inst.setFirstIn(iTarget); !inst.end(); inst.incIn(iTarget)) {
        res.set(inst, this->jointPosterior(targets)[inst]);
      }
      inst.setFirstIn(iTarget);   // remove inst.end() flag
    }
 
    return res;
  }

References gum::Instantiation::add(), gum::GraphicalModelInference< GUM_SCALAR >::addEvidence(), addJointTarget(), gum::GraphicalModelInference< GUM_SCALAR >::chgEvidence(), gum::Instantiation::end(), gum::GraphicalModelInference< GUM_SCALAR >::eraseAllEvidence(), eraseAllTargets(), GUM_ERROR, gum::Instantiation::incIn(), gum::Instantiation::incOut(), jointPosterior(), gum::GraphicalModelInference< GUM_SCALAR >::makeInference(), gum::MRFInference< GUM_SCALAR >::MRF(), gum::Instantiation::setFirstIn(), gum::Instantiation::setFirstOut(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::targets(), and gum::Instantiation::val().

Referenced by evidenceJointImpact().

Here is the call graph for this function:

Here is the caller graph for this function:

evidenceJointImpact() [2/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > gum::JointTargetedMRFInference< GUM_SCALAR >::evidenceJointImpact ( const std::vector< std::string > & targets, const std::vector< std::string > & evs )

inherited

Create a gum::Tensor for P(joint targets|evs) (for all instanciation of targets and evs).

Warning

If some evs are d-separated, they are not included in the Tensor

Parameters

targets	the vector of std::string of the targeted variables
evs	the vector of std::string of observed variables

Returns

a Tensor

Definition at line 295 of file jointTargetedMRFInference_tpl.h.

                                         {
    const auto& mn = this->MRF();
    return evidenceJointImpact(mn.nodeset(targets), mn.nodeset(evs));
  }

References evidenceJointImpact(), gum::MRFInference< GUM_SCALAR >::MRF(), and gum::MarginalTargetedMRFInference< GUM_SCALAR >::targets().

Here is the call graph for this function:

evidenceProbability()

template<typename GUM_SCALAR>

GUM_SCALAR gum::ShaferShenoyMRFInference< GUM_SCALAR >::evidenceProbability ( )

finalvirtual

returns the probability of evidence

Implements gum::EvidenceMRFInference< GUM_SCALAR >.

getNumberOfThreads()

virtual Size gum::ThreadNumberManager::getNumberOfThreads ( ) const

virtualinherited

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 >::displatchMarginalsToThreads_(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::expFusion_(), gum::ScheduledInference::scheduler(), and gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::verticesFusion_().

Here is the caller graph for this function:

H() [1/2]

template<typename GUM_SCALAR>

INLINE GUM_SCALAR gum::MarginalTargetedMRFInference< GUM_SCALAR >::H ( const std::string & nodeName )

finalvirtualinherited

Entropy Compute Shanon's entropy of a node given the observation.

See also

http://en.wikipedia.org/wiki/Information_entropy

Definition at line 268 of file marginalTargetedMRFInference_tpl.h.

                                                                                           {
    return H(this->MRF().idFromName(nodeName));
  }

References H(), and gum::MRFInference< GUM_SCALAR >::MRF().

Here is the call graph for this function:

H() [2/2]

template<typename GUM_SCALAR>

INLINE GUM_SCALAR gum::MarginalTargetedMRFInference< GUM_SCALAR >::H ( NodeId X )

finalvirtualinherited

Entropy Compute Shanon's entropy of a node given the observation.

See also

http://en.wikipedia.org/wiki/Information_entropy

Definition at line 260 of file marginalTargetedMRFInference_tpl.h.

                                                                          {
    return posterior(X).entropy();
  }

References posterior().

Referenced by H().

Here is the call graph for this function:

Here is the caller graph for this function:

hardEvidence()

template<typename GUM_SCALAR>

INLINE const NodeProperty< Idx > & gum::GraphicalModelInference< GUM_SCALAR >::hardEvidence ( ) const

inherited

indicate for each node with hard evidence which value it took

Definition at line 580 of file graphicalModelInference_tpl.h.

                                                                                              {
    return _hard_evidence_;
  }

References _hard_evidence_.

Referenced by gum::GibbsSampling< GUM_SCALAR >::GibbsSampling(), gum::SamplingInference< GUM_SCALAR >::contextualize(), gum::ImportanceSampling< GUM_SCALAR >::draw_(), and gum::WeightedSampling< GUM_SCALAR >::draw_().

Here is the caller graph for this function:

hardEvidenceNodes()

template<typename GUM_SCALAR>

INLINE const NodeSet & gum::GraphicalModelInference< GUM_SCALAR >::hardEvidenceNodes ( ) const

inherited

returns the set of nodes with hard evidence

the set of nodes that received hard evidence

Definition at line 599 of file graphicalModelInference_tpl.h.

                                                                                       {
    return _hard_evidence_nodes_;
  }

References _hard_evidence_nodes_.

Referenced by gum::SamplingInference< GUM_SCALAR >::contextualize(), gum::ImportanceSampling< GUM_SCALAR >::draw_(), gum::MonteCarloSampling< GUM_SCALAR >::draw_(), gum::WeightedSampling< GUM_SCALAR >::draw_(), gum::ImportanceSampling< GUM_SCALAR >::onContextualize_(), gum::MarginalTargetedInference< GUM_SCALAR >::posterior(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::posterior(), gum::SamplingInference< GUM_SCALAR >::setEstimatorFromBN_(), and gum::SamplingInference< GUM_SCALAR >::setEstimatorFromLBP_().

Here is the caller graph for this function:

hasEvidence() [1/3]

template<typename GUM_SCALAR>

INLINE bool gum::GraphicalModelInference< GUM_SCALAR >::hasEvidence ( ) const

finalvirtualinherited

indicates whether some node(s) have received evidence

Definition at line 346 of file graphicalModelInference_tpl.h.

                                                                       {
    return !_evidence_.empty();
  }

References _evidence_.

Referenced by addEvidence(), chgEvidence(), eraseEvidence(), and hasEvidence().

Here is the caller graph for this function:

hasEvidence() [2/3]

template<typename GUM_SCALAR>

INLINE bool gum::GraphicalModelInference< GUM_SCALAR >::hasEvidence ( const std::string & nodeName ) const

finalvirtualinherited

indicates whether node id has received an evidence

Definition at line 371 of file graphicalModelInference_tpl.h.

                                                                                        {
    return hasEvidence(this->model().idFromName(nodeName));
  }

References hasEvidence(), and model().

Here is the call graph for this function:

hasEvidence() [3/3]

template<typename GUM_SCALAR>

INLINE bool gum::GraphicalModelInference< GUM_SCALAR >::hasEvidence ( NodeId id ) const

finalvirtualinherited

indicates whether node id has received an evidence

Definition at line 352 of file graphicalModelInference_tpl.h.

                                                                                {
    return _evidence_.exists(id);
  }

References _evidence_.

hasHardEvidence() [1/2]

template<typename GUM_SCALAR>

INLINE bool gum::GraphicalModelInference< GUM_SCALAR >::hasHardEvidence ( const std::string & nodeName ) const

finalvirtualinherited

indicates whether node id has received a hard evidence

Definition at line 378 of file graphicalModelInference_tpl.h.

                                                                                            {
    return hasHardEvidence(this->model().idFromName(nodeName));
  }

References hasHardEvidence(), and model().

Here is the call graph for this function:

hasHardEvidence() [2/2]

template<typename GUM_SCALAR>

INLINE bool gum::GraphicalModelInference< GUM_SCALAR >::hasHardEvidence ( NodeId id ) const

finalvirtualinherited

indicates whether node id has received a hard evidence

Definition at line 358 of file graphicalModelInference_tpl.h.

                                                                                    {
    return _hard_evidence_nodes_.exists(id);
  }

References _hard_evidence_nodes_.

Referenced by chgEvidence(), gum::ImportanceSampling< GUM_SCALAR >::draw_(), eraseEvidence(), hasHardEvidence(), and gum::JointTargetedMRFInference< GUM_SCALAR >::jointPosterior().

Here is the caller graph for this function:

hasNoModel_()

template<typename GUM_SCALAR>

bool gum::GraphicalModelInference< GUM_SCALAR >::hasNoModel_ ( ) const

inlineprotectedinherited

Definition at line 542 of file graphicalModelInference.h.

{ return _model_ == nullptr; };

References _model_.

Referenced by gum::EvidenceInference< GUM_SCALAR >::EvidenceInference(), gum::EvidenceMRFInference< GUM_SCALAR >::EvidenceMRFInference(), gum::JointTargetedInference< GUM_SCALAR >::JointTargetedInference(), gum::JointTargetedMRFInference< GUM_SCALAR >::JointTargetedMRFInference(), gum::MarginalTargetedInference< GUM_SCALAR >::MarginalTargetedInference(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::MarginalTargetedMRFInference(), _computeDomainSizes_(), gum::MarginalTargetedInference< GUM_SCALAR >::_setAllMarginalTargets_(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::_setAllMarginalTargets_(), gum::MarginalTargetedInference< GUM_SCALAR >::addAllTargets(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::addAllTargets(), gum::JointTargetedInference< GUM_SCALAR >::addJointTarget(), gum::JointTargetedMRFInference< GUM_SCALAR >::addJointTarget(), gum::MarginalTargetedInference< GUM_SCALAR >::addTarget(), gum::MarginalTargetedInference< GUM_SCALAR >::addTarget(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::addTarget(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::addTarget(), gum::JointTargetedInference< GUM_SCALAR >::eraseJointTarget(), gum::JointTargetedMRFInference< GUM_SCALAR >::eraseJointTarget(), gum::MarginalTargetedInference< GUM_SCALAR >::eraseTarget(), gum::MarginalTargetedInference< GUM_SCALAR >::eraseTarget(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::eraseTarget(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::eraseTarget(), gum::JointTargetedInference< GUM_SCALAR >::isJointTarget(), gum::JointTargetedMRFInference< GUM_SCALAR >::isJointTarget(), gum::MarginalTargetedInference< GUM_SCALAR >::isTarget(), and gum::MarginalTargetedMRFInference< GUM_SCALAR >::isTarget().

Here is the caller graph for this function:

hasSoftEvidence() [1/2]

template<typename GUM_SCALAR>

INLINE bool gum::GraphicalModelInference< GUM_SCALAR >::hasSoftEvidence ( const std::string & nodeName ) const

finalvirtualinherited

indicates whether node id has received a soft evidence

Definition at line 385 of file graphicalModelInference_tpl.h.

                                                                                            {
    return hasSoftEvidence(this->model().idFromName(nodeName));
  }

References hasSoftEvidence(), and model().

Here is the call graph for this function:

hasSoftEvidence() [2/2]

template<typename GUM_SCALAR>

INLINE bool gum::GraphicalModelInference< GUM_SCALAR >::hasSoftEvidence ( NodeId id ) const

finalvirtualinherited

indicates whether node id has received a soft evidence

Definition at line 364 of file graphicalModelInference_tpl.h.

                                                                                    {
    return _soft_evidence_nodes_.exists(id);
  }

References _soft_evidence_nodes_.

Referenced by hasSoftEvidence().

Here is the caller graph for this function:

isExactJointComputable_()

template<typename GUM_SCALAR>

virtual bool gum::ShaferShenoyMRFInference< GUM_SCALAR >::isExactJointComputable_ ( const NodeSet & vars )

finalprotectedvirtual

check if the vars form a possible computable joint (can be redefined by subclass)

Reimplemented from gum::JointTargetedMRFInference< GUM_SCALAR >.

References isExactJointComputable_().

Referenced by isExactJointComputable_().

Here is the call graph for this function:

Here is the caller graph for this function:

isGumNumberOfThreadsOverriden()

bool gum::ThreadNumberManager::isGumNumberOfThreadsOverriden ( ) const

virtualinherited

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

Implements gum::IThreadNumberManager.

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

Here is the caller graph for this function:

isInferenceDone()

template<typename GUM_SCALAR>

INLINE bool gum::GraphicalModelInference< GUM_SCALAR >::isInferenceDone ( ) const

finalvirtualnoexceptinherited

returns whether the inference object is in a InferenceDone state

The inference object is in a done state when the posteriors can be retrieved without performing a new inference, i.e., all the heavy computations have already been performed. Typically, in a junction tree algorithm, this corresponds to a situation in which all the messages needed in the JT have been computed and sent.

Definition at line 104 of file graphicalModelInference_tpl.h.

                                                                                    {
    return (_state_ == StateOfInference::Done);
  }

References _state_, and Done.

Referenced by gum::JointTargetedInference< GUM_SCALAR >::jointPosterior(), gum::JointTargetedMRFInference< GUM_SCALAR >::jointPosterior(), makeInference(), gum::MarginalTargetedInference< GUM_SCALAR >::posterior(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::posterior(), and prepareInference().

Here is the caller graph for this function:

isInferenceOutdatedStructure()

template<typename GUM_SCALAR>

INLINE bool gum::GraphicalModelInference< GUM_SCALAR >::isInferenceOutdatedStructure ( ) const

finalvirtualnoexceptinherited

returns whether the inference object is in a OutdatedStructure state

Definition at line 92 of file graphicalModelInference_tpl.h.

                                                                                                 {
    return (_state_ == StateOfInference::OutdatedStructure);
  }

References _state_, and OutdatedStructure.

Referenced by chgEvidence(), eraseAllEvidence(), and eraseEvidence().

Here is the caller graph for this function:

isInferenceOutdatedTensors()

template<typename GUM_SCALAR>

INLINE bool gum::GraphicalModelInference< GUM_SCALAR >::isInferenceOutdatedTensors ( ) const

finalvirtualnoexceptinherited

returns whether the inference object is in a OutdatedTensor state

Definition at line 98 of file graphicalModelInference_tpl.h.

                                                                                               {
    return (_state_ == StateOfInference::OutdatedTensors);
  }

References _state_, and OutdatedTensors.

isInferenceReady()

template<typename GUM_SCALAR>

INLINE bool gum::GraphicalModelInference< GUM_SCALAR >::isInferenceReady ( ) const

finalvirtualnoexceptinherited

returns whether the inference object is in a ready state

Definition at line 86 of file graphicalModelInference_tpl.h.

                                                                                     {
    return (_state_ == StateOfInference::ReadyForInference);
  }

References _state_, and ReadyForInference.

Referenced by makeInference(), gum::SamplingInference< GUM_SCALAR >::onStateChanged_(), and prepareInference().

Here is the caller graph for this function:

isJointTarget()

template<typename GUM_SCALAR>

INLINE bool gum::JointTargetedMRFInference< GUM_SCALAR >::isJointTarget ( const NodeSet & vars ) const

finalvirtualinherited

return true if target is a joint target.

Definition at line 84 of file jointTargetedMRFInference_tpl.h.

                                                                                              {
    if (this->hasNoModel_())
      GUM_ERROR(NullElement,
                "No Markov net has been assigned to the "
                "inference algorithm");
 
    const auto& gra = this->MRF().graph();
    for (const auto var: vars) {
      if (!gra.exists(var)) {
        GUM_ERROR(UndefinedElement, var << " is not a NodeId in the Markov random field")
      }
    }
 
    return _joint_targets_.contains(vars);
  }

References _joint_targets_, GUM_ERROR, gum::GraphicalModelInference< GUM_SCALAR >::hasNoModel_(), and gum::MRFInference< GUM_SCALAR >::MRF().

Here is the call graph for this function:

isTarget() [1/2]

template<typename GUM_SCALAR>

INLINE bool gum::MarginalTargetedMRFInference< GUM_SCALAR >::isTarget ( const std::string & nodeName ) const

finalvirtualinherited

return true if variable is a (marginal) target

Definition at line 104 of file marginalTargetedMRFInference_tpl.h.

                                                                                          {
    return isTarget(this->MRF().idFromName(nodeName));
  }

References isTarget(), and gum::MRFInference< GUM_SCALAR >::MRF().

Here is the call graph for this function:

isTarget() [2/2]

template<typename GUM_SCALAR>

INLINE bool gum::MarginalTargetedMRFInference< GUM_SCALAR >::isTarget ( NodeId node ) const

finalvirtualinherited

return true if variable is a (marginal) target

Definition at line 88 of file marginalTargetedMRFInference_tpl.h.

                                                                                    {
    // check that the variable belongs to the mn
    if (this->hasNoModel_())
      GUM_ERROR(NullElement,
                "No Markov net has been assigned to the "
                "inference algorithm");
    if (!this->MRF().graph().exists(node)) {
      GUM_ERROR(UndefinedElement, node << " is not a NodeId in the Markov random field")
    }
 
    return _targets_.contains(node);
  }

References _targets_, GUM_ERROR, gum::GraphicalModelInference< GUM_SCALAR >::hasNoModel_(), and gum::MRFInference< GUM_SCALAR >::MRF().

Referenced by isTarget(), gum::JointTargetedMRFInference< GUM_SCALAR >::posterior(), and posterior().

Here is the call graph for this function:

Here is the caller graph for this function:

isTargetedMode_()

template<typename GUM_SCALAR>

INLINE bool gum::MarginalTargetedMRFInference< GUM_SCALAR >::isTargetedMode_ ( ) const

protectedinherited

Definition at line 320 of file marginalTargetedMRFInference_tpl.h.

                                                                                {
    return _targeted_mode_;
  }

References _targeted_mode_.

jointMutualInformation() [1/2]

template<typename GUM_SCALAR>

GUM_SCALAR gum::JointTargetedMRFInference< GUM_SCALAR >::jointMutualInformation ( const NodeSet & targets )

inherited

Mutual information between targets.

See also

https://en.wikipedia.org/wiki/Interaction_information

Parameters

targets

the NodeSet of the targeted variables

Definition at line 304 of file jointTargetedMRFInference_tpl.h.

                                                                                            {
    const auto& mn  = this->MRF();
    const Size  siz = targets.size();
    if (siz <= 1) {
      GUM_ERROR(InvalidArgument,
                "jointMutualInformation needs at least 2 variables (targets=" << targets << ")");
    }
 
    this->eraseAllTargets();
    this->eraseAllEvidence();
    this->addJointTarget(targets);
    this->makeInference();
    const auto po = this->jointPosterior(targets);
 
    gum::Instantiation caracteristic;
    gum::Instantiation variables;
    for (const auto nod: targets) {
      const auto& var = mn.variable(nod);
      auto        pv  = new gum::RangeVariable(var.name(), "", 0, 1);
      caracteristic.add(*pv);
      variables.add(var);
    }
 
    gum::VariableSet sov;
 
    const GUM_SCALAR start = (siz % 2 == 0) ? GUM_SCALAR(-1.0) : GUM_SCALAR(1.0);
    GUM_SCALAR       sign;
    GUM_SCALAR       res = GUM_SCALAR(0.0);
 
    caracteristic.setFirst();
    for (caracteristic.inc(); !caracteristic.end(); caracteristic.inc()) {
      sov.clear();
      sign = start;
      for (Idx i = 0; i < caracteristic.nbrDim(); i++) {
        if (caracteristic.val(i) == 1) {
          sign = -sign;
          sov.insert(&variables.variable(i));
        }
      }
      res += sign * po.sumIn(sov).entropy();
    }
 
    for (Idx i = 0; i < caracteristic.nbrDim(); i++) {
      delete &caracteristic.variable(i);
    }
 
    return res;
  }

References gum::Instantiation::add(), addJointTarget(), gum::Set< Key >::clear(), gum::Instantiation::end(), gum::GraphicalModelInference< GUM_SCALAR >::eraseAllEvidence(), eraseAllTargets(), GUM_ERROR, gum::Instantiation::inc(), gum::Set< Key >::insert(), jointPosterior(), gum::GraphicalModelInference< GUM_SCALAR >::makeInference(), gum::MRFInference< GUM_SCALAR >::MRF(), gum::Instantiation::nbrDim(), gum::Instantiation::setFirst(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::targets(), gum::Instantiation::val(), and gum::Instantiation::variable().

Referenced by jointMutualInformation().

Here is the call graph for this function:

Here is the caller graph for this function:

jointMutualInformation() [2/2]

template<typename GUM_SCALAR>

GUM_SCALAR gum::JointTargetedMRFInference< GUM_SCALAR >::jointMutualInformation ( const std::vector< std::string > & targets )

inherited

Mutual information between targets.

See also

https://en.wikipedia.org/wiki/Interaction_information

Parameters

targets

the vector of std::string of the targeted variables

Definition at line 354 of file jointTargetedMRFInference_tpl.h.

                                             {
    return jointMutualInformation(this->MRF().nodeset(targets));
  }

References jointMutualInformation(), gum::MRFInference< GUM_SCALAR >::MRF(), and gum::MarginalTargetedMRFInference< GUM_SCALAR >::targets().

Here is the call graph for this function:

jointPosterior()

template<typename GUM_SCALAR>

const Tensor< GUM_SCALAR > & gum::JointTargetedMRFInference< GUM_SCALAR >::jointPosterior ( const NodeSet & nodes )

finalvirtualinherited

Compute the joint posterior of a set of nodes.

Returns

a const ref to the posterior joint probability of the set of nodes.

Parameters

nodes

the set of nodes whose posterior joint probability is wanted

Warning

the node with hard evidence are removed from nodes.

For efficiency reasons, the tensor is stored into the inference engine and is returned by reference. In order to ensure that the tensor may still exist even if the Inference object is destroyed, the user has to copy it explicitly.

prepareInference and makeInference may be applied if needed.

Exceptions

UndefinedElement

if nodes is not in the targets

Definition at line 208 of file jointTargetedMRFInference_tpl.h.

                                                                                  {
    NodeSet real_nodes;
    for (const auto& node: nodes) {
      if (!this->hasHardEvidence(node)) { real_nodes.insert(node); }
    }
    // try to get the smallest set of targets that contains "nodes"
    bool    found_exact_target = false;
    NodeSet super_target;
 
    if (isExactJointComputable_(real_nodes)) {
      found_exact_target = true;
    } else {
      super_target = superForJointComputable_(real_nodes);
      if (super_target.empty()) {
        GUM_ERROR(UndefinedElement,
                  "No joint target containing " << real_nodes << " could be found among "
                                                << _joint_targets_);
      }
    }
 
    if (!this->isInferenceDone()) { this->makeInference(); }
 
    if (found_exact_target) return jointPosterior_(real_nodes);
    else { return jointPosterior_(real_nodes, super_target); }
  }

References _joint_targets_, gum::Set< Key >::empty(), GUM_ERROR, gum::GraphicalModelInference< GUM_SCALAR >::hasHardEvidence(), gum::Set< Key >::insert(), isExactJointComputable_(), gum::GraphicalModelInference< GUM_SCALAR >::isInferenceDone(), jointPosterior_(), gum::GraphicalModelInference< GUM_SCALAR >::makeInference(), and superForJointComputable_().

Referenced by evidenceJointImpact(), jointMutualInformation(), and posterior().

Here is the call graph for this function:

Here is the caller graph for this function:

jointPosterior_() [1/2]

template<typename GUM_SCALAR>

const Tensor< GUM_SCALAR > & gum::ShaferShenoyMRFInference< GUM_SCALAR >::jointPosterior_ ( const NodeSet & set )

finalprotectedvirtual

returns the posterior of a declared target set

Parameters

set	The set of ids of the variables whose joint posterior is looked for.

Implements gum::JointTargetedMRFInference< GUM_SCALAR >.

References jointPosterior_().

Referenced by jointPosterior_(), and jointPosterior_().

Here is the call graph for this function:

Here is the caller graph for this function:

jointPosterior_() [2/2]

template<typename GUM_SCALAR>

const Tensor< GUM_SCALAR > & gum::ShaferShenoyMRFInference< GUM_SCALAR >::jointPosterior_ ( const NodeSet & wanted_target, const NodeSet & declared_target )

finalprotectedvirtual

asks derived classes for the joint posterior of a set of variables not declared as a joint target

Parameters

wanted_target	The set of ids of the variables whose joint posterior is looked for.
declared_target	the joint target declared by the user that contains set

Implements gum::JointTargetedMRFInference< GUM_SCALAR >.

References jointPosterior_().

Here is the call graph for this function:

joinTree()

template<typename GUM_SCALAR>

const JoinTree * gum::ShaferShenoyMRFInference< GUM_SCALAR >::joinTree

(

)

returns the current join tree used

ShaferShenoy does not use a junction tree but a binary join tree because this may enable faster inferences. So do not be surprised to see that some cliques are contained into others in this tree.

jointTargets()

template<typename GUM_SCALAR>

INLINE const Set< NodeSet > & gum::JointTargetedMRFInference< GUM_SCALAR >::jointTargets ( ) const

finalvirtualnoexceptinherited

returns the list of joint targets

returns the list of target sets

Definition at line 191 of file jointTargetedMRFInference_tpl.h.

                                                                                    {
    return _joint_targets_;
  }

References _joint_targets_.

junctionTree()

template<typename GUM_SCALAR>

const JunctionTree * gum::ShaferShenoyMRFInference< GUM_SCALAR >::junctionTree

(

)

returns the current junction tree

ShaferShenoy does not use a junction tree but a binary join tree because this may enable faster inferences. This method return the junction tree, before optimizations

makeInference()

template<typename GUM_SCALAR>

INLINE void gum::GraphicalModelInference< GUM_SCALAR >::makeInference ( )

finalvirtualinherited

perform the heavy computations needed to compute the targets' posteriors

In a Junction tree propagation scheme, for instance, the heavy computations are those of the messages sent in the JT. This is precisely what makeInference should compute. Later, the computations of the posteriors can be done "lightly" by multiplying and projecting those messages.

Definition at line 638 of file graphicalModelInference_tpl.h.

                                                                   {
    if (isInferenceDone()) { return; }
 
    if (!isInferenceReady()) { prepareInference(); }
 
    makeInference_();
 
    setState_(StateOfInference::Done);
  }

References Done, isInferenceDone(), isInferenceReady(), makeInference_(), prepareInference(), and setState_().

Referenced by gum::MarginalTargetedInference< GUM_SCALAR >::evidenceImpact(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::evidenceImpact(), gum::JointTargetedInference< GUM_SCALAR >::evidenceJointImpact(), gum::JointTargetedMRFInference< GUM_SCALAR >::evidenceJointImpact(), gum::JointTargetedInference< GUM_SCALAR >::jointMutualInformation(), gum::JointTargetedMRFInference< GUM_SCALAR >::jointMutualInformation(), gum::JointTargetedInference< GUM_SCALAR >::jointPosterior(), gum::JointTargetedMRFInference< GUM_SCALAR >::jointPosterior(), gum::LoopySamplingInference< GUM_SCALAR, APPROX >::makeInference_(), gum::MarginalTargetedInference< GUM_SCALAR >::posterior(), and gum::MarginalTargetedMRFInference< GUM_SCALAR >::posterior().

Here is the call graph for this function:

Here is the caller graph for this function:

makeInference_()

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::makeInference_ ( )

finalprotectedvirtual

called when the inference has to be performed effectively

Once the inference is done, fillPosterior_ can be called.

Implements gum::GraphicalModelInference< GUM_SCALAR >.

References makeInference_().

Referenced by makeInference_().

Here is the call graph for this function:

Here is the caller graph for this function:

maxMemory()

INLINE double gum::ScheduledInference::maxMemory ( ) const

virtualinherited

returns the Max memory (in megabytes) available for executing schedules

Returns

the Max memory (in megabytes) available for executing schedules. 0 means an unlimited amount of memory

Definition at line 68 of file scheduledInference_inl.h.

{ return _scheduler_parallel_.maxMemory(); }

References _scheduler_parallel_.

model()

template<typename GUM_SCALAR>

INLINE const GraphicalModel & gum::GraphicalModelInference< GUM_SCALAR >::model ( ) const

finalvirtualinherited

Returns a constant reference over the IBayesNet referenced by this class.

Exceptions

UndefinedElement

is raised if no Bayes net has been assigned to the inference.

Definition at line 126 of file graphicalModelInference_tpl.h.

                                                                                  {
    if (_model_ == nullptr)
      GUM_ERROR(UndefinedElement,
                "No Bayes net has been assigned to "
                "the inference algorithm.");
    return *_model_;
  }

References _model_, and GUM_ERROR.

Referenced by GraphicalModelInference(), addEvidence(), addEvidence(), addEvidence(), addEvidence(), gum::BayesNetInference< GUM_SCALAR >::BN(), chgEvidence(), chgEvidence(), chgEvidence(), chgEvidence(), eraseEvidence(), hasEvidence(), hasHardEvidence(), hasSoftEvidence(), gum::MRFInference< GUM_SCALAR >::MRF(), onModelChanged_(), gum::ShaferShenoyLIMIDInference< GUM_SCALAR >::onModelChanged_(), setModel_(), and setModelDuringConstruction_().

Here is the caller graph for this function:

MRF()

template<typename GUM_SCALAR>

INLINE const IMarkovRandomField< GUM_SCALAR > & gum::MRFInference< GUM_SCALAR >::MRF ( ) const

finalvirtualinherited

Returns a constant reference over the IMarkovRandomField referenced by this class.

Exceptions

UndefinedElement

is raised if no Markov net has been assigned to the inference.

Definition at line 75 of file MRFInference_tpl.h.

                                                                                       {
    return static_cast< const IMarkovRandomField< GUM_SCALAR >& >(this->model());
  }

References gum::GraphicalModelInference< GUM_SCALAR >::model().

Referenced by gum::MarginalTargetedMRFInference< GUM_SCALAR >::_setAllMarginalTargets_(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::addAllTargets(), gum::JointTargetedMRFInference< GUM_SCALAR >::addJointTarget(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::addTarget(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::addTarget(), gum::JointTargetedMRFInference< GUM_SCALAR >::eraseJointTarget(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::eraseTarget(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::eraseTarget(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::evidenceImpact(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::evidenceImpact(), gum::JointTargetedMRFInference< GUM_SCALAR >::evidenceJointImpact(), gum::JointTargetedMRFInference< GUM_SCALAR >::evidenceJointImpact(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::H(), gum::JointTargetedMRFInference< GUM_SCALAR >::isJointTarget(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::isTarget(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::isTarget(), gum::JointTargetedMRFInference< GUM_SCALAR >::jointMutualInformation(), gum::JointTargetedMRFInference< GUM_SCALAR >::jointMutualInformation(), gum::JointTargetedMRFInference< GUM_SCALAR >::posterior(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::posterior(), and gum::JointTargetedMRFInference< GUM_SCALAR >::superForJointComputable_().

Here is the call graph for this function:

Here is the caller graph for this function:

nbrEvidence()

template<typename GUM_SCALAR>

INLINE Size gum::GraphicalModelInference< GUM_SCALAR >::nbrEvidence ( ) const

finalvirtualinherited

returns the number of evidence entered into the Bayesian network

Definition at line 562 of file graphicalModelInference_tpl.h.

                                                                       {
    return _evidence_.size();
  }

References _evidence_.

nbrHardEvidence()

template<typename GUM_SCALAR>

INLINE Size gum::GraphicalModelInference< GUM_SCALAR >::nbrHardEvidence ( ) const

finalvirtualinherited

returns the number of hard evidence entered into the Bayesian network

Definition at line 568 of file graphicalModelInference_tpl.h.

                                                                           {
    return _hard_evidence_nodes_.size();
  }

References _hard_evidence_nodes_.

nbrJointTargets()

template<typename GUM_SCALAR>

INLINE Size gum::JointTargetedMRFInference< GUM_SCALAR >::nbrJointTargets ( ) const

finalvirtualnoexceptinherited

returns the number of joint targets

returns the number of target sets

Definition at line 197 of file jointTargetedMRFInference_tpl.h.

                                                                                      {
    return _joint_targets_.size();
  }

References _joint_targets_.

nbrSoftEvidence()

template<typename GUM_SCALAR>

INLINE Size gum::GraphicalModelInference< GUM_SCALAR >::nbrSoftEvidence ( ) const

finalvirtualinherited

returns the number of soft evidence entered into the Bayesian network

Definition at line 574 of file graphicalModelInference_tpl.h.

                                                                           {
    return _soft_evidence_nodes_.size();
  }

References _soft_evidence_nodes_.

nbrTargets()

template<typename GUM_SCALAR>

INLINE Size gum::MarginalTargetedMRFInference< GUM_SCALAR >::nbrTargets ( ) const

finalvirtualnoexceptinherited

returns the number of marginal targets

Definition at line 216 of file marginalTargetedMRFInference_tpl.h.

                                                                                    {
    return _targets_.size();
  }

References _targets_.

onAllEvidenceErased_()

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::onAllEvidenceErased_ ( bool has_hard_evidence )

finalprotectedvirtual

fired before all the evidence are erased

Implements gum::GraphicalModelInference< GUM_SCALAR >.

References onAllEvidenceErased_().

Referenced by onAllEvidenceErased_().

Here is the call graph for this function:

Here is the caller graph for this function:

onAllJointTargetsErased_()

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::onAllJointTargetsErased_ ( )

finalprotectedvirtual

fired before all the joint targets are removed

Implements gum::JointTargetedMRFInference< GUM_SCALAR >.

References onAllJointTargetsErased_().

Referenced by onAllJointTargetsErased_().

Here is the call graph for this function:

Here is the caller graph for this function:

onAllMarginalTargetsAdded_()

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::onAllMarginalTargetsAdded_ ( )

finalprotectedvirtual

fired after all the nodes of the MRF are added as single targets

Implements gum::MarginalTargetedMRFInference< GUM_SCALAR >.

References onAllMarginalTargetsAdded_().

Referenced by onAllMarginalTargetsAdded_().

Here is the call graph for this function:

Here is the caller graph for this function:

onAllMarginalTargetsErased_()

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::onAllMarginalTargetsErased_ ( )

finalprotectedvirtual

fired before all the single targets are removed

Implements gum::MarginalTargetedMRFInference< GUM_SCALAR >.

References onAllMarginalTargetsErased_().

Referenced by onAllMarginalTargetsErased_().

Here is the call graph for this function:

Here is the caller graph for this function:

onAllTargetsErased_()

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::onAllTargetsErased_ ( )

finalprotectedvirtual

fired before all single and joint targets are removed

Implements gum::JointTargetedMRFInference< GUM_SCALAR >.

References onAllTargetsErased_().

Referenced by onAllTargetsErased_().

Here is the call graph for this function:

Here is the caller graph for this function:

onEvidenceAdded_()

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::onEvidenceAdded_ ( const NodeId id, bool isHardEvidence )

finalprotectedvirtual

fired after a new evidence is inserted

Implements gum::GraphicalModelInference< GUM_SCALAR >.

References onEvidenceAdded_().

Referenced by onEvidenceAdded_().

Here is the call graph for this function:

Here is the caller graph for this function:

onEvidenceChanged_()

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::onEvidenceChanged_ ( const NodeId id, bool hasChangedSoftHard )

finalprotectedvirtual

fired after an evidence is changed, in particular when its status (soft/hard) changes

Parameters

nodeId	the node of the changed evidence
hasChangedSoftHard	true if the evidence has changed from Soft to Hard or from Hard to Soft

Implements gum::GraphicalModelInference< GUM_SCALAR >.

References onEvidenceChanged_().

Referenced by onEvidenceChanged_().

Here is the call graph for this function:

Here is the caller graph for this function:

onEvidenceErased_()

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::onEvidenceErased_ ( const NodeId id, bool isHardEvidence )

finalprotectedvirtual

fired before an evidence is removed

Implements gum::GraphicalModelInference< GUM_SCALAR >.

References onEvidenceErased_().

Referenced by onEvidenceErased_().

Here is the call graph for this function:

Here is the caller graph for this function:

onJointTargetAdded_()

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::onJointTargetAdded_ ( const NodeSet & set )

finalprotectedvirtual

fired after a new joint target is inserted

Parameters

set	The set of target variable's ids.

Implements gum::JointTargetedMRFInference< GUM_SCALAR >.

References onJointTargetAdded_().

Referenced by onJointTargetAdded_().

Here is the call graph for this function:

Here is the caller graph for this function:

onJointTargetErased_()

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::onJointTargetErased_ ( const NodeSet & set )

finalprotectedvirtual

fired before a joint target is removed

Parameters

set	The set of target variable's ids.

Implements gum::JointTargetedMRFInference< GUM_SCALAR >.

References onJointTargetErased_().

Referenced by onJointTargetErased_().

Here is the call graph for this function:

Here is the caller graph for this function:

onMarginalTargetAdded_()

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::onMarginalTargetAdded_ ( const NodeId id )

finalprotectedvirtual

fired after a new single target is inserted

Parameters

id	The target variable's id.

Implements gum::MarginalTargetedMRFInference< GUM_SCALAR >.

References onMarginalTargetAdded_().

Referenced by onMarginalTargetAdded_().

Here is the call graph for this function:

Here is the caller graph for this function:

onMarginalTargetErased_()

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::onMarginalTargetErased_ ( const NodeId id )

finalprotectedvirtual

fired before a single target is removed

Parameters

id	The target variable's id.

Implements gum::MarginalTargetedMRFInference< GUM_SCALAR >.

References onMarginalTargetErased_().

Referenced by onMarginalTargetErased_().

Here is the call graph for this function:

Here is the caller graph for this function:

onModelChanged_()

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::onModelChanged_ ( const GraphicalModel * mn )

finalprotectedvirtual

fired after a new Markov net has been assigned to the inference engine

Reimplemented from gum::JointTargetedMRFInference< GUM_SCALAR >.

References onModelChanged_().

Referenced by onModelChanged_().

Here is the call graph for this function:

Here is the caller graph for this function:

onMRFChanged_()

template<typename GUM_SCALAR>

virtual void gum::ShaferShenoyMRFInference< GUM_SCALAR >::onMRFChanged_ ( const IMarkovRandomField< GUM_SCALAR > * mn )

finalprotectedvirtual

fired after a new Markov net has been assigned to the inference engine

References onMRFChanged_().

Referenced by onMRFChanged_().

Here is the call graph for this function:

Here is the caller graph for this function:

onStateChanged_()

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::onStateChanged_ ( )

inlinefinalprotectedvirtual

fired when the state of the inference engine is changed

Implements gum::GraphicalModelInference< GUM_SCALAR >.

Definition at line 192 of file ShaferShenoyMRFInference.h.

{};

References onStateChanged_().

Referenced by onStateChanged_().

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

template<typename GUM_SCALAR>

ShaferShenoyMRFInference< GUM_SCALAR > & gum::ShaferShenoyMRFInference< GUM_SCALAR >::operator= ( const ShaferShenoyMRFInference< GUM_SCALAR > & )

privatedelete

avoid copy operators

References ShaferShenoyMRFInference().

Here is the call graph for this function:

posterior() [1/2]

template<typename GUM_SCALAR>

const Tensor< GUM_SCALAR > & gum::JointTargetedMRFInference< GUM_SCALAR >::posterior ( const std::string & nodeName )

finalvirtualinherited

Computes and returns the posterior of a node.

Returns

a const ref to the posterior probability of the node.

Parameters

node	the node for which we need a posterior probability

Warning

for efficiency reasons, the tensor is stored into the inference engine and is returned by reference. In order to ensure that the tensor may still exist even if the Inference object is destroyed, the user has to copy it explicitly.

prepareInference and makeInference may be applied if needed by the posterior method.

Exceptions

UndefinedElement

if node is not in the set of targets

Reimplemented from gum::MarginalTargetedMRFInference< GUM_SCALAR >.

Definition at line 244 of file jointTargetedMRFInference_tpl.h.

                                                                                  {
    return posterior(this->MRF().idFromName(nodeName));
  }

References gum::MRFInference< GUM_SCALAR >::MRF(), and posterior().

Here is the call graph for this function:

posterior() [2/2]

template<typename GUM_SCALAR>

const Tensor< GUM_SCALAR > & gum::JointTargetedMRFInference< GUM_SCALAR >::posterior ( NodeId node )

finalvirtualinherited

Computes and returns the posterior of a node.

Returns

a const ref to the posterior probability of the node.

Parameters

node	the node for which we need a posterior probability

Warning

for efficiency reasons, the tensor is stored into the inference engine and is returned by reference. In order to ensure that the tensor may still exist even if the Inference object is destroyed, the user has to copy it explicitly.

prepareInference and makeInference may be applied if needed by the posterior method.

Exceptions

UndefinedElement

if node is not in the set of targets

Reimplemented from gum::MarginalTargetedMRFInference< GUM_SCALAR >.

Definition at line 236 of file jointTargetedMRFInference_tpl.h.

                                                                                            {
    if (this->isTarget(node)) return MarginalTargetedMRFInference< GUM_SCALAR >::posterior(node);
    else return jointPosterior(NodeSet{node});
  }

References gum::MarginalTargetedMRFInference< GUM_SCALAR >::isTarget(), jointPosterior(), and gum::MarginalTargetedMRFInference< GUM_SCALAR >::posterior().

Referenced by posterior().

Here is the call graph for this function:

Here is the caller graph for this function:

posterior_()

template<typename GUM_SCALAR>

const Tensor< GUM_SCALAR > & gum::ShaferShenoyMRFInference< GUM_SCALAR >::posterior_ ( NodeId id )

finalprotectedvirtual

returns the posterior of a given variable

Parameters

id	The variable's id.

Implements gum::MarginalTargetedMRFInference< GUM_SCALAR >.

References posterior_().

Referenced by posterior_().

Here is the call graph for this function:

Here is the caller graph for this function:

prepareInference()

template<typename GUM_SCALAR>

INLINE void gum::GraphicalModelInference< GUM_SCALAR >::prepareInference ( )

finalvirtualinherited

prepare the internal inference structures for the next inference

Definition at line 622 of file graphicalModelInference_tpl.h.

                                                                      {
    if (isInferenceReady() || isInferenceDone()) { return; }
 
    if (_model_ == nullptr)
      GUM_ERROR(NullElement,
                "No model been assigned to the "
                "inference algorithm");
 
    if (_state_ == StateOfInference::OutdatedStructure) updateOutdatedStructure_();
    else updateOutdatedTensors_();
 
    setState_(StateOfInference::ReadyForInference);
  }

References _model_, _state_, GUM_ERROR, isInferenceDone(), isInferenceReady(), OutdatedStructure, ReadyForInference, setState_(), updateOutdatedStructure_(), and updateOutdatedTensors_().

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

Here is the call graph for this function:

Here is the caller graph for this function:

scheduler()

INLINE Scheduler & gum::ScheduledInference::scheduler ( ) const

inherited

returns the current scheduler

Definition at line 48 of file scheduledInference_inl.h.

                                                        {
    if (ThreadNumberManager::getNumberOfThreads() != 1)
      return const_cast< SchedulerParallel& >(_scheduler_parallel_);
    else return const_cast< SchedulerSequential& >(_scheduler_sequential_);
  }

References _scheduler_parallel_, _scheduler_sequential_, and gum::ThreadNumberManager::getNumberOfThreads().

Here is the call graph for this function:

setMaxMemory()

INLINE void gum::ScheduledInference::setMaxMemory ( double megabytes )

inherited

sets an upper bound on the memory consumption admissible

Parameters

megabytes

the number of megabytes that can be used for the execution of the schedule. If this number is equal to 0, then no memory limit is applied.

Definition at line 61 of file scheduledInference_inl.h.

                                                               {
    if (megabytes < 0.0) megabytes = 0.0;
    _scheduler_parallel_.setMaxMemory(megabytes);
    _scheduler_sequential_.setMaxMemory(megabytes);
  }

References _scheduler_parallel_, and _scheduler_sequential_.

Referenced by ScheduledInference().

Here is the caller graph for this function:

setModel_()

template<typename GUM_SCALAR>

void gum::GraphicalModelInference< GUM_SCALAR >::setModel_ ( const GraphicalModel * model )

protectedinherited

Definition at line 136 of file graphicalModelInference_tpl.h.

                                                                                   {
    clear();
    _model_ = model;
    _computeDomainSizes_();
    onModelChanged_(model);
    setState_(StateOfInference::OutdatedStructure);
  }

References _computeDomainSizes_(), _model_, clear(), model(), onModelChanged_(), OutdatedStructure, and setState_().

Referenced by gum::BayesNetInference< GUM_SCALAR >::setBN(), and gum::MRFInference< GUM_SCALAR >::setMRF().

Here is the call graph for this function:

Here is the caller graph for this function:

setModelDuringConstruction_()

template<typename GUM_SCALAR>

void gum::GraphicalModelInference< GUM_SCALAR >::setModelDuringConstruction_ ( const GraphicalModel * model )

protectedinherited

assigns a model during the inference engine construction

Definition at line 146 of file graphicalModelInference_tpl.h.

                                   {
    _model_ = model;
    _computeDomainSizes_();
    setState_(StateOfInference::OutdatedStructure);
  }

References _computeDomainSizes_(), _model_, model(), OutdatedStructure, and setState_().

Referenced by gum::BayesNetInference< GUM_SCALAR >::_setBayesNetDuringConstruction_(), and gum::MRFInference< GUM_SCALAR >::_setMRFDuringConstruction_().

Here is the call graph for this function:

Here is the caller graph for this function:

setMRF()

template<typename GUM_SCALAR>

void gum::MRFInference< GUM_SCALAR >::setMRF ( const IMarkovRandomField< GUM_SCALAR > * mrf )

virtualinherited

assigns a new MRF to the inference engine

Assigns a new MRF to the MRFInference engine and sends messages to the descendants of MRFInference to inform them that the MRF has changed.

Warning

By default, all the nodes of the Markov net are targets.

note that, by aGrUM's rule, the mn is not copied into the inference engine but only referenced.

Definition at line 81 of file MRFInference_tpl.h.

                                                                                     {
    this->setModel_(mrf);
  }

References gum::GraphicalModelInference< GUM_SCALAR >::setModel_().

Here is the call graph for this function:

setNumberOfThreads()

INLINE void gum::ScheduledInference::setNumberOfThreads ( Size nb )

finalvirtualinherited

sets the number max of threads that can be used

Parameters

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

Reimplemented from gum::ThreadNumberManager.

Definition at line 55 of file scheduledInference_inl.h.

                                                            {
    ThreadNumberManager::setNumberOfThreads(nb);
    _scheduler_parallel_.setNumberOfThreads(nb);
  }

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

Here is the call graph for this function:

setOutdatedStructureState_()

template<typename GUM_SCALAR>

INLINE void gum::GraphicalModelInference< GUM_SCALAR >::setOutdatedStructureState_ ( )

protectedinherited

put the inference into an outdated model structure state

OutdatedStructure: in this state, the inference is fully unprepared to be applied because some events changed the "logical" structure of the model: for instance a node received a hard evidence, which implies that its outgoing arcs can be removed from the model, hence involving a structural change in the model. As a consequence, the (incremental) inference (probably) needs a significant amount of preparation to be ready for the next inference. In a Lazy propagation, for instance, this step amounts to compute a new join tree, hence a new structure in which inference will be applied. Note that classes that inherit from graphicalModelInference may be smarter than graphicalModelInference and may, in some situations, find out that their data structures are still ok for inference and, therefore, only resort to perform the actions related to the OutdatedTensors state. As an example, consider a LazyPropagation inference in Bayes Net A->B->C->D->E in which C has received hard evidence e_C and E is the only target. In this case, A and B are not needed for inference, the only tensors that matter are P(D|e_C) and P(E|D). So the smallest join tree needed for inference contains only one clique DE. Now, adding new evidence e_A on A has no impact on E given hard evidence e_C. In this case, LazyPropagation can be smart and not update its join tree.

Definition at line 609 of file graphicalModelInference_tpl.h.

                                                                                {
    setState_(StateOfInference::OutdatedStructure);
  }

References OutdatedStructure, and setState_().

Referenced by makeInference_().

Here is the call graph for this function:

Here is the caller graph for this function:

setOutdatedTensorsState_()

template<typename GUM_SCALAR>

INLINE void gum::GraphicalModelInference< GUM_SCALAR >::setOutdatedTensorsState_ ( )

protectedinherited

puts the inference into an OutdatedTensors state if it is not already in an OutdatedStructure state

OutdatedTensors: in this state, the structure of the model remains unchanged, only some tensors stored in it have changed. Therefore, the inference probably just needs to invalidate some already computed tensors to be ready. Only a light amount of preparation is needed to be able to perform inference.

Definition at line 616 of file graphicalModelInference_tpl.h.

                                                                              {
    setState_(StateOfInference::OutdatedTensors);
  }

References OutdatedTensors, and setState_().

Referenced by makeInference_().

Here is the call graph for this function:

Here is the caller graph for this function:

setState_()

template<typename GUM_SCALAR>

INLINE void gum::GraphicalModelInference< GUM_SCALAR >::setState_ ( const StateOfInference state )

finalprotectedvirtualinherited

set the state of the inference engine and call the notification onStateChanged_ when necessary (i.e. when the state has effectively changed).

Definition at line 117 of file graphicalModelInference_tpl.h.

                                                                                           {
    if (_state_ != state) {
      _state_ = state;
      onStateChanged_();
    }
  }

References _state_, onStateChanged_(), and state().

Referenced by gum::MarginalTargetedInference< GUM_SCALAR >::addAllTargets(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::addAllTargets(), addEvidence(), gum::JointTargetedInference< GUM_SCALAR >::addJointTarget(), gum::JointTargetedMRFInference< GUM_SCALAR >::addJointTarget(), gum::MarginalTargetedInference< GUM_SCALAR >::addTarget(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::addTarget(), chgEvidence(), clear(), eraseAllEvidence(), gum::JointTargetedInference< GUM_SCALAR >::eraseAllJointTargets(), gum::JointTargetedMRFInference< GUM_SCALAR >::eraseAllJointTargets(), gum::MarginalTargetedInference< GUM_SCALAR >::eraseAllTargets(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::eraseAllTargets(), eraseEvidence(), gum::JointTargetedInference< GUM_SCALAR >::eraseJointTarget(), gum::JointTargetedMRFInference< GUM_SCALAR >::eraseJointTarget(), gum::MarginalTargetedInference< GUM_SCALAR >::eraseTarget(), gum::MarginalTargetedMRFInference< GUM_SCALAR >::eraseTarget(), makeInference(), prepareInference(), setModel_(), setModelDuringConstruction_(), setOutdatedStructureState_(), and setOutdatedTensorsState_().

Here is the call graph for this function:

Here is the caller graph for this function:

setTargetedMode_()

template<typename GUM_SCALAR>

INLINE void gum::MarginalTargetedMRFInference< GUM_SCALAR >::setTargetedMode_ ( )

protectedinherited

Definition at line 325 of file marginalTargetedMRFInference_tpl.h.

                                                                           {
    if (!_targeted_mode_) {
      _targets_.clear();
      _targeted_mode_ = true;
    }
  }

References _targeted_mode_, and _targets_.

Referenced by addAllTargets(), gum::JointTargetedMRFInference< GUM_SCALAR >::addJointTarget(), addTarget(), and eraseAllTargets().

Here is the caller graph for this function:

setTriangulation()

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::setTriangulation

(

const Triangulation &

new_triangulation

)

use a new triangulation algorithm

softEvidenceNodes()

template<typename GUM_SCALAR>

INLINE const NodeSet & gum::GraphicalModelInference< GUM_SCALAR >::softEvidenceNodes ( ) const

inherited

returns the set of nodes with soft evidence

the set of nodes that received soft evidence

Definition at line 593 of file graphicalModelInference_tpl.h.

                                                                                       {
    return _soft_evidence_nodes_;
  }

References _soft_evidence_nodes_.

Referenced by gum::SamplingInference< GUM_SCALAR >::contextualize().

Here is the caller graph for this function:

state()

template<typename GUM_SCALAR>

INLINE GraphicalModelInference< GUM_SCALAR >::StateOfInference gum::GraphicalModelInference< GUM_SCALAR >::state ( ) const

finalvirtualnoexceptinherited

returns the state of the inference engine

Definition at line 111 of file graphicalModelInference_tpl.h.

                                                                  {
    return _state_;
  }

References _state_.

Referenced by setState_().

Here is the caller graph for this function:

superForJointComputable_()

template<typename GUM_SCALAR>

virtual NodeSet gum::ShaferShenoyMRFInference< GUM_SCALAR >::superForJointComputable_ ( const NodeSet & vars )

finalprotectedvirtual

Reimplemented from gum::JointTargetedMRFInference< GUM_SCALAR >.

References superForJointComputable_().

Referenced by superForJointComputable_().

Here is the call graph for this function:

Here is the caller graph for this function:

targets()

template<typename GUM_SCALAR>

INLINE const NodeSet & gum::MarginalTargetedMRFInference< GUM_SCALAR >::targets ( ) const

finalvirtualnoexceptinherited

returns the list of marginal targets

Definition at line 210 of file marginalTargetedMRFInference_tpl.h.

                                                                                           {
    return _targets_;
  }

References _targets_.

Referenced by gum::JointTargetedMRFInference< GUM_SCALAR >::evidenceJointImpact(), gum::JointTargetedMRFInference< GUM_SCALAR >::evidenceJointImpact(), gum::JointTargetedMRFInference< GUM_SCALAR >::jointMutualInformation(), and gum::JointTargetedMRFInference< GUM_SCALAR >::jointMutualInformation().

Here is the caller graph for this function:

unnormalizedJointPosterior_() [1/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > * gum::ShaferShenoyMRFInference< GUM_SCALAR >::unnormalizedJointPosterior_ ( const NodeSet & set )

finalprotectedvirtual

returns a fresh tensor equal to P(argument,evidence)

Implements gum::JointTargetedMRFInference< GUM_SCALAR >.

unnormalizedJointPosterior_() [2/2]

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR > * gum::ShaferShenoyMRFInference< GUM_SCALAR >::unnormalizedJointPosterior_ ( NodeId id )

finalprotectedvirtual

returns a fresh tensor equal to P(argument,evidence)

Implements gum::JointTargetedMRFInference< GUM_SCALAR >.

References unnormalizedJointPosterior_().

Referenced by unnormalizedJointPosterior_().

Here is the call graph for this function:

Here is the caller graph for this function:

updateOutdatedStructure_()

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::updateOutdatedStructure_ ( )

finalprotectedvirtual

prepares inference when the latter is in OutdatedStructure state

Note that the values of evidence are not necessarily known and can be changed between updateOutdatedStructure_ and makeMRFInference_.

Implements gum::GraphicalModelInference< GUM_SCALAR >.

updateOutdatedTensors_()

template<typename GUM_SCALAR>

void gum::ShaferShenoyMRFInference< GUM_SCALAR >::updateOutdatedTensors_ ( )

finalprotectedvirtual

prepares inference when the latter is in OutdatedTensors state

Note that the values of evidence are not necessarily known and can be changed between updateOutdatedStructure_ and makeMRFInference_.

Implements gum::GraphicalModelInference< GUM_SCALAR >.

References updateOutdatedTensors_().

Referenced by updateOutdatedTensors_().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

_arc_to_created_tensors_

template<typename GUM_SCALAR>

ArcProperty< const IScheduleMultiDim* > gum::ShaferShenoyMRFInference< GUM_SCALAR >::_arc_to_created_tensors_

private

the set of tensors created for the last inference messages

This structure contains some pointer only for the arcs on which a tensor has been created. Arcs for which no tensor was created do not belong to this structure.

Warning

Note that the factors that were projected due to hard evidence do not belong to this structure, they are kept in node_to_hard_ev_projected_factors.

Definition at line 331 of file ShaferShenoyMRFInference.h.

_clique_ss_tensor_

template<typename GUM_SCALAR>

NodeProperty< const IScheduleMultiDim* > gum::ShaferShenoyMRFInference< GUM_SCALAR >::_clique_ss_tensor_

private

the tensors stored into the cliques by Shafer-Shenoy

For a given clique, there is an entry in clique_ss_tensor even if the clique received no tensor. In this case, the tensor stored is equal to nullptr, else it is equal to the combination of all the corresponding list of tensors in clique_ss_tensor.

Definition at line 316 of file ShaferShenoyMRFInference.h.

_clique_tensors_

template<typename GUM_SCALAR>

NodeProperty< _ScheduleMultiDimSet_ > gum::ShaferShenoyMRFInference< GUM_SCALAR >::_clique_tensors_

private

the list of all tensors stored in the cliques

This structure contains a list for each clique in the join tree. If a clique did not received any tensor, then its list is empty but the entry for the clique does exist. Note that clique tensors contain also soft evidence and the factors that were projected to remove their variables that received hard evidence. The product of all these tensors is precisely the tensor stored into clique_ss_tensor

Definition at line 309 of file ShaferShenoyMRFInference.h.

_combination_op_

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR >(* gum::ShaferShenoyMRFInference< GUM_SCALAR >::_combination_op_) (const Tensor< GUM_SCALAR > &, const Tensor< GUM_SCALAR > &)

inlineprivate

the operator for performing the combinations

Definition at line 234 of file ShaferShenoyMRFInference.h.

                                                                         {SSNewMNmultiTensor};

_constants_

template<typename GUM_SCALAR>

HashTable< const Tensor< GUM_SCALAR >*, GUM_SCALAR > gum::ShaferShenoyMRFInference< GUM_SCALAR >::_constants_

private

the constants resulting from the projections of CPTs defined over only hard evidence nodes @TODO remove this constant and insert the notion of a constant into tensors/multidim arrays

Definition at line 345 of file ShaferShenoyMRFInference.h.

_evidence_changes_

template<typename GUM_SCALAR>

NodeProperty< EvidenceChangeType > gum::ShaferShenoyMRFInference< GUM_SCALAR >::_evidence_changes_

private

indicates which nodes of the MRF have evidence that changed since the last inference

Definition at line 377 of file ShaferShenoyMRFInference.h.

_factor_to_clique_

template<typename GUM_SCALAR>

HashTable< const Tensor< GUM_SCALAR >*, NodeId > gum::ShaferShenoyMRFInference< GUM_SCALAR >::_factor_to_clique_

private

assign to each factor in the MRF the clique that will contain it

Definition at line 291 of file ShaferShenoyMRFInference.h.

_graph_

template<typename GUM_SCALAR>

UndiGraph gum::ShaferShenoyMRFInference< GUM_SCALAR >::_graph_

private

the undigraph extracted from the MRF and used to construct the join tree

If all nodes are targets, this graph corresponds to the graph of the MRF. Otherwise, it may be a subgraph of this moral graph.

Definition at line 260 of file ShaferShenoyMRFInference.h.

_hard_ev_nodes_

template<typename GUM_SCALAR>

NodeSet gum::ShaferShenoyMRFInference< GUM_SCALAR >::_hard_ev_nodes_

private

the hard evidence nodes which were projected in factors

Definition at line 370 of file ShaferShenoyMRFInference.h.

_hard_ev_projected_factors_

template<typename GUM_SCALAR>

HashTable< const Tensor< GUM_SCALAR >*, const IScheduleMultiDim* > gum::ShaferShenoyMRFInference< GUM_SCALAR >::_hard_ev_projected_factors_

private

the factors that were projected due to hard evidence nodes

For each node whose factor is defined over some nodes that contain some hard evidence, assigns a new projected factor that does not contain these nodes anymore.

Warning

These tensors are owned by the inference class.

Definition at line 367 of file ShaferShenoyMRFInference.h.

_is_new_jt_needed_

template<typename GUM_SCALAR>

bool gum::ShaferShenoyMRFInference< GUM_SCALAR >::_is_new_jt_needed_ {true}

private

indicates whether a new join tree is needed for the next inference

when modifying the set of hard evidence, we can determine that the current JT is no more appropriate for inference. This variable enables us to keep track of this.

Definition at line 272 of file ShaferShenoyMRFInference.h.

{true};

_joint_target_posteriors_

template<typename GUM_SCALAR>

HashTable< NodeSet, const Tensor< GUM_SCALAR >* > gum::ShaferShenoyMRFInference< GUM_SCALAR >::_joint_target_posteriors_

private

the set of set target posteriors computed during the last inference

the posteriors are owned by ShaferShenoyMRFInference.

Definition at line 339 of file ShaferShenoyMRFInference.h.

_joint_target_to_clique_

template<typename GUM_SCALAR>

HashTable< NodeSet, NodeId > gum::ShaferShenoyMRFInference< GUM_SCALAR >::_joint_target_to_clique_

private

for each set target, assign a clique in the JT that contains it

Definition at line 299 of file ShaferShenoyMRFInference.h.

_joint_targets_

template<typename GUM_SCALAR>

Set< NodeSet > gum::JointTargetedMRFInference< GUM_SCALAR >::_joint_targets_

privateinherited

the set of joint targets

Definition at line 295 of file jointTargetedMRFInference.h.

Referenced by addJointTarget(), eraseAllJointTargets(), eraseJointTarget(), isExactJointComputable_(), isJointTarget(), jointPosterior(), jointTargets(), nbrJointTargets(), onModelChanged_(), and superForJointComputable_().

_JT_

template<typename GUM_SCALAR>

JoinTree* gum::ShaferShenoyMRFInference< GUM_SCALAR >::_JT_ {nullptr}

private

the join (or junction) tree used to answer the last inference query

Definition at line 263 of file ShaferShenoyMRFInference.h.

{nullptr};

_junctionTree_

template<typename GUM_SCALAR>

JunctionTree* gum::ShaferShenoyMRFInference< GUM_SCALAR >::_junctionTree_ {nullptr}

private

the junction tree to answer the last inference query

Definition at line 266 of file ShaferShenoyMRFInference.h.

{nullptr};

_messages_computed_

template<typename GUM_SCALAR>

ArcProperty< bool > gum::ShaferShenoyMRFInference< GUM_SCALAR >::_messages_computed_

private

indicates whether a message (from one clique to another) has been computed

Here, all the messages, computed or not, are put into the property, only the Boolean makes the difference between messages computed and those that were not computed

Definition at line 351 of file ShaferShenoyMRFInference.h.

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

{0};

_node_to_clique_

template<typename GUM_SCALAR>

NodeProperty< NodeId > gum::ShaferShenoyMRFInference< GUM_SCALAR >::_node_to_clique_

private

for each node of graph (~ in the Markov net), associate an ID in the JT

This mapping is useful notably to determine where the soft evidence are entered into the JT.

Warning

: nodes that received hard evidence do not belong to this data structure (as they do not belong to the JT)

Definition at line 288 of file ShaferShenoyMRFInference.h.

_node_to_factors_

template<typename GUM_SCALAR>

NodeProperty< _TensorSet_ > gum::ShaferShenoyMRFInference< GUM_SCALAR >::_node_to_factors_

private

assign to each node the set of factors containing it

Nodes that are assigned no factor (do they exist?) are assigned an empty factor set

Definition at line 296 of file ShaferShenoyMRFInference.h.

_node_to_soft_evidence_

template<typename GUM_SCALAR>

NodeProperty< const IScheduleMultiDim* > gum::ShaferShenoyMRFInference< GUM_SCALAR >::_node_to_soft_evidence_

private

the soft evidence stored in the cliques per their assigned node in the MRF

This variable is useful for method updateOutdatedTensors_: it enables to know which soft evidence should be removed/added into the cliques of the join tree.

Warning

These tensors are not owned by ShaferShenoyMRFInference, they are only referenced by it. Only the cliques that contain evidence are filled in this structure.

Definition at line 360 of file ShaferShenoyMRFInference.h.

_one_minus_epsilon_

template<typename GUM_SCALAR>

GUM_SCALAR gum::ShaferShenoyMRFInference< GUM_SCALAR >::_one_minus_epsilon_ {GUM_SCALAR(1.0 - 1e-6)}

staticconstexprprivate

for comparisons with 1 - epsilon

Definition at line 386 of file ShaferShenoyMRFInference.h.

{GUM_SCALAR(1.0 - 1e-6)};

_projection_op_

template<typename GUM_SCALAR>

Tensor< GUM_SCALAR >(* gum::ShaferShenoyMRFInference< GUM_SCALAR >::_projection_op_) (const Tensor< GUM_SCALAR > &, const gum::VariableSet &)

inlineprivate

the operator for performing the projections

Definition at line 234 of file ShaferShenoyMRFInference.h.

                                                                  {SSNewMNprojTensor};

_roots_

template<typename GUM_SCALAR>

NodeSet gum::ShaferShenoyMRFInference< GUM_SCALAR >::_roots_

private

a clique node used as a root in each connected component of JT

For usual probabilistic inference, roots is useless. This is useful when computing the probability of evidence. In this case, we need to compute this probability in every connected component and multiply them to get the overall probability of evidence.

Warning

roots should be computed only when evidenceProbability is called.

Definition at line 281 of file ShaferShenoyMRFInference.h.

_schedule_threshold_

template<typename GUM_SCALAR>

double gum::ShaferShenoyMRFInference< GUM_SCALAR >::_schedule_threshold_ {1000000.0}

staticconstexprprivate

minimal number of operations to perform in the JT to use schedules

Definition at line 383 of file ShaferShenoyMRFInference.h.

{1000000.0};

_scheduler_parallel_

SchedulerParallel gum::ScheduledInference::_scheduler_parallel_

privateinherited

Definition at line 137 of file scheduledInference.h.

Referenced by ScheduledInference(), ScheduledInference(), ScheduledInference(), maxMemory(), operator=(), operator=(), scheduler(), setMaxMemory(), and setNumberOfThreads().

_scheduler_sequential_

SchedulerSequential gum::ScheduledInference::_scheduler_sequential_

privateinherited

Definition at line 140 of file scheduledInference.h.

Referenced by ScheduledInference(), ScheduledInference(), ScheduledInference(), operator=(), operator=(), scheduler(), and setMaxMemory().

_separator_tensors_

template<typename GUM_SCALAR>

ArcProperty< const IScheduleMultiDim* > gum::ShaferShenoyMRFInference< GUM_SCALAR >::_separator_tensors_

private

the list of all tensors stored in the separators after inferences

This structure contains all the arcs of the join tree (edges in both directions) whether the arc received any tensor or not. If they did not receive any tensor, then they contain a nullptr pointer.

Definition at line 322 of file ShaferShenoyMRFInference.h.

_target_posteriors_

template<typename GUM_SCALAR>

NodeProperty< const Tensor< GUM_SCALAR >* > gum::ShaferShenoyMRFInference< GUM_SCALAR >::_target_posteriors_

private

the set of single posteriors computed during the last inference

the posteriors are owned by ShaferShenoyMRFInference.

Definition at line 335 of file ShaferShenoyMRFInference.h.

_targeted_mode_

template<typename GUM_SCALAR>

bool gum::MarginalTargetedMRFInference< GUM_SCALAR >::_targeted_mode_

privateinherited

whether the actual targets are default

Definition at line 259 of file marginalTargetedMRFInference.h.

Referenced by MarginalTargetedMRFInference(), eraseTarget(), isTargetedMode_(), onModelChanged_(), and setTargetedMode_().

_targets_

template<typename GUM_SCALAR>

NodeSet gum::MarginalTargetedMRFInference< GUM_SCALAR >::_targets_

privateinherited

the set of marginal targets

Definition at line 262 of file marginalTargetedMRFInference.h.

Referenced by MarginalTargetedMRFInference(), _setAllMarginalTargets_(), addAllTargets(), addTarget(), eraseAllTargets(), eraseTarget(), isTarget(), nbrTargets(), setTargetedMode_(), and targets().

_triangulation_

template<typename GUM_SCALAR>

Triangulation* gum::ShaferShenoyMRFInference< GUM_SCALAR >::_triangulation_

private

the triangulation class creating the junction tree used for inference

Definition at line 251 of file ShaferShenoyMRFInference.h.

_use_binary_join_tree_

template<typename GUM_SCALAR>

bool gum::ShaferShenoyMRFInference< GUM_SCALAR >::_use_binary_join_tree_ {true}

private

indicates whether we should transform junction trees into binary join trees

Definition at line 255 of file ShaferShenoyMRFInference.h.

{true};

_use_schedules_

template<typename GUM_SCALAR>

bool gum::ShaferShenoyMRFInference< GUM_SCALAR >::_use_schedules_ {false}

private

indicates whether we should use schedules for inference

Definition at line 380 of file ShaferShenoyMRFInference.h.

{false};

---

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

• agrum/MRF/inference/ShaferShenoyMRFInference.h