gum::JointTargetedMNInference< GUM_SCALAR > Class Template Reference

<agrum/MN/inference/jointTargetedMNInference.h> More...

#include <jointTargetedMNInference.h>

Inheritance diagram for gum::JointTargetedMNInference< GUM_SCALAR >:

Collaboration diagram for gum::JointTargetedMNInference< GUM_SCALAR >:

Public Member Functions
Potential< GUM_SCALAR >	evidenceJointImpact (const NodeSet &targets, const NodeSet &evs)
	Create a gum::Potential for P(joint targets|evs) (for all instanciation of targets and evs) More...
Potential< GUM_SCALAR >	evidenceJointImpact (const std::vector< std::string > &targets, const std::vector< std::string > &evs)
	Create a gum::Potential for P(joint targets|evs) (for all instanciation of targets and evs) More...
Potential< GUM_SCALAR >	evidenceImpact (NodeId target, const NodeSet &evs)
	Create a gum::Potential for P(target|evs) (for all instanciation of target and evs) More...
Potential< GUM_SCALAR >	evidenceImpact (const std::string &target, const std::vector< std::string > &evs)
	Create a gum::Potential for P(target|evs) (for all instanciation of target and evs) More...
Constructors / Destructors
	JointTargetedMNInference (const IMarkovNet< GUM_SCALAR > *mn)
	default constructor More...
virtual	~JointTargetedMNInference ()
	destructor More...
Probability computations
virtual const Potential< GUM_SCALAR > &	jointPosterior (const NodeSet &nodes) final
	Compute the joint posterior of a set of nodes. More...
virtual const Potential< GUM_SCALAR > &	posterior (NodeId node) final
	Computes and returns the posterior of a node. More...
virtual const Potential< GUM_SCALAR > &	posterior (const std::string &nodeName) final
	Computes and returns the posterior of a node. More...
Targets
virtual void	eraseAllTargets ()
	Clear all previously defined targets (marginal and joint targets) More...
virtual void	eraseAllJointTargets () final
	Clear all previously defined joint targets. More...
virtual void	eraseAllMarginalTargets () final
	Clear all the previously defined marginal targets. More...
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. More...
virtual void	eraseJointTarget (const NodeSet &joint_target) final
	removes an existing joint target More...
virtual bool	isJointTarget (const NodeSet &vars) const final
	return true if target is a joint target. More...
virtual const Set< NodeSet > &	jointTargets () const noexcept final
	returns the list of joint targets More...
virtual Size	nbrJointTargets () const noexcept final
	returns the number of joint targets More...
Information Theory related functions
GUM_SCALAR	I (NodeId X, NodeId Y)
	Mutual information between X and Y. More...
GUM_SCALAR	I (const std::string &X, const std::string &Y)
	Mutual information between X and Y. More...
GUM_SCALAR	VI (NodeId X, NodeId Y)
	Variation of information between X and Y. More...
GUM_SCALAR	VI (const std::string &X, const std::string &Y)
	Variation of information between X and Y. More...
GUM_SCALAR	jointMutualInformation (const NodeSet &targets)
	Mutual information between targets. More...
GUM_SCALAR	jointMutualInformation (const std::vector< std::string > &targets)
	Mutual information between targets. More...
Targets
virtual void	addAllTargets () final
	adds all nodes as targets More...
virtual void	addTarget (NodeId target) final
	Add a marginal target to the list of targets. More...
virtual void	addTarget (const std::string &nodeName) final
	Add a marginal target to the list of targets. More...
virtual void	eraseTarget (NodeId target) final
	removes an existing (marginal) target More...
virtual void	eraseTarget (const std::string &nodeName) final
	removes an existing (marginal) target More...
virtual bool	isTarget (NodeId node) const final
	return true if variable is a (marginal) target More...
virtual bool	isTarget (const std::string &nodeName) const final
	return true if variable is a (marginal) target More...
virtual const Size	nbrTargets () const noexcept final
	returns the number of marginal targets More...
virtual const NodeSet &	targets () const noexcept final
	returns the list of marginal targets More...
Information Theory related functions
virtual GUM_SCALAR	H (NodeId X) final
	Entropy Compute Shanon's entropy of a node given the observation. More...
virtual GUM_SCALAR	H (const std::string &nodeName) final
	Entropy Compute Shanon's entropy of a node given the observation. More...
Accessors / Modifiers
virtual void	setMN (const IMarkovNet< GUM_SCALAR > *mn)
	assigns a new MN to the inference engine More...
virtual const IMarkovNet< GUM_SCALAR > &	MN () const final
	Returns a constant reference over the IMarkovNet referenced by this class. More...
Accessors / Modifiers
virtual const GraphicalModel &	model () const final
	Returns a constant reference over the IBayesNet referenced by this class. More...
virtual const NodeProperty< Size > &	domainSizes () const final
	get the domain sizes of the random variables of the model More...
virtual bool	isInferenceReady () const noexcept final
	returns whether the inference object is in a ready state More...
virtual bool	isInferenceOutdatedStructure () const noexcept final
	returns whether the inference object is in a OutdatedStructure state More...
virtual bool	isInferenceOutdatedPotentials () const noexcept final
	returns whether the inference object is in a OutdatedPotential state More...
virtual bool	isInferenceDone () const noexcept final
	returns whether the inference object is in a InferenceDone state More...
virtual void	prepareInference () final
	prepare the internal inference structures for the next inference More...
virtual void	makeInference () final
	perform the heavy computations needed to compute the targets' posteriors More...
virtual void	clear ()
	clears all the data structures allocated for the last inference More...
virtual StateOfInference	state () const noexcept final
	returns the state of the inference engine More...
Evidence
virtual void	addEvidence (NodeId id, const Idx val) final
	adds a new hard evidence on node id More...
virtual void	addEvidence (const std::string &nodeName, const Idx val) final
	adds a new hard evidence on node named nodeName More...
virtual void	addEvidence (NodeId id, const std::string &label) final
	adds a new hard evidence on node id More...
virtual void	addEvidence (const std::string &nodeName, const std::string &label) final
	adds a new hard evidence on node named nodeName More...
virtual void	addEvidence (NodeId id, const std::vector< GUM_SCALAR > &vals) final
	adds a new evidence on node id (might be soft or hard) More...
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) More...
virtual void	addEvidence (const Potential< GUM_SCALAR > &pot) final
	adds a new evidence on node id (might be soft or hard) More...
virtual void	addEvidence (Potential< GUM_SCALAR > &&pot) final
	adds a new evidence on node id (might be soft or hard) More...
virtual void	addSetOfEvidence (const Set< const Potential< GUM_SCALAR > * > &potset) final
	adds a new set of evidence More...
virtual void	addListOfEvidence (const List< const Potential< GUM_SCALAR > * > &potlist) final
	adds a new list of evidence More...
virtual void	chgEvidence (NodeId id, const Idx val) final
	change the value of an already existing hard evidence More...
virtual void	chgEvidence (const std::string &nodeName, const Idx val) final
	change the value of an already existing hard evidence More...
virtual void	chgEvidence (NodeId id, const std::string &label) final
	change the value of an already existing hard evidence More...
virtual void	chgEvidence (const std::string &nodeName, const std::string &label) final
	change the value of an already existing hard evidence More...
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) More...
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) More...
virtual void	chgEvidence (const Potential< GUM_SCALAR > &pot) final
	change the value of an already existing evidence (might be soft or hard) More...
virtual void	eraseAllEvidence () final
	removes all the evidence entered into the network More...
virtual void	eraseEvidence (NodeId id) final
	removed the evidence, if any, corresponding to node id More...
virtual void	eraseEvidence (const std::string &nodeName) final
	removed the evidence, if any, corresponding to node of name nodeName More...
virtual bool	hasEvidence () const final
	indicates whether some node(s) have received evidence More...
virtual bool	hasEvidence (NodeId id) const final
	indicates whether node id has received an evidence More...
virtual bool	hasEvidence (const std::string &nodeName) const final
	indicates whether node id has received an evidence More...
virtual bool	hasHardEvidence (NodeId id) const final
	indicates whether node id has received a hard evidence More...
virtual bool	hasHardEvidence (const std::string &nodeName) const final
	indicates whether node id has received a hard evidence More...
virtual bool	hasSoftEvidence (NodeId id) const final
	indicates whether node id has received a soft evidence More...
virtual bool	hasSoftEvidence (const std::string &nodeName) const final
	indicates whether node id has received a soft evidence More...
virtual Size	nbrEvidence () const final
	returns the number of evidence entered into the Bayesian network More...
virtual Size	nbrHardEvidence () const final
	returns the number of hard evidence entered into the Bayesian network More...
virtual Size	nbrSoftEvidence () const final
	returns the number of soft evidence entered into the Bayesian network More...
const NodeProperty< const Potential< GUM_SCALAR > *> &	evidence () const
	returns the set of evidence More...
const NodeSet &	softEvidenceNodes () const
	returns the set of nodes with soft evidence More...
const NodeSet &	hardEvidenceNodes () const
	returns the set of nodes with hard evidence More...
const NodeProperty< Idx > &	hardEvidence () const
	indicate for each node with hard evidence which value it took More...

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

Protected Member Functions
virtual bool	isExactJointComputable_ (const NodeSet &vars)
	check if the vars form a possible computable joint (can be redefined by subclass) More...
virtual NodeSet	superForJointComputable_ (const NodeSet &vars)
virtual void	onModelChanged_ (const GraphicalModel *mn)
	fired after a new Markov net has been assigned to the engine More...
virtual void	onJointTargetAdded_ (const NodeSet &set)=0
	fired after a new joint target is inserted More...
virtual void	onJointTargetErased_ (const NodeSet &set)=0
	fired before a joint target is removed More...
virtual void	onAllTargetsErased_ ()=0
	fired before a all the marginal and joint targets are removed More...
virtual void	onAllJointTargetsErased_ ()=0
	fired before a all the joint targets are removed More...
virtual const Potential< GUM_SCALAR > &	jointPosterior_ (const NodeSet &set)=0
	asks derived classes for the joint posterior of a declared target set More...
virtual const Potential< GUM_SCALAR > &	jointPosterior_ (const NodeSet &wanted_target, const NodeSet &declared_target)=0
	asks derived classes for the joint posterior of a set of variables not declared as a joint target More...
virtual Potential< GUM_SCALAR > *	unnormalizedJointPosterior_ (const NodeSet &set)=0
	returns a fresh unnormalized joint posterior of a given set of variables More...
virtual Potential< GUM_SCALAR > *	unnormalizedJointPosterior_ (NodeId id)=0
	returns a fresh potential equal to P(argument,evidence) More...
virtual void	onMarginalTargetAdded_ (const NodeId id)=0
	fired after a new marginal target is inserted More...
virtual void	onMarginalTargetErased_ (const NodeId id)=0
	fired before a marginal target is removed More...
virtual void	onAllMarginalTargetsAdded_ ()=0
	fired after all the nodes of the MN are added as marginal targets More...
virtual void	onAllMarginalTargetsErased_ ()=0
	fired before a all marginal targets are removed More...
virtual const Potential< GUM_SCALAR > &	posterior_ (NodeId id)=0
	asks derived classes for the posterior of a given variable More...
void	setTargetedMode_ ()
bool	isTargetedMode_ () const
virtual void	onStateChanged_ ()=0
	fired when the stage is changed More...
virtual void	onEvidenceAdded_ (const NodeId id, bool isHardEvidence)=0
	fired after a new evidence is inserted More...
virtual void	onEvidenceErased_ (const NodeId id, bool isHardEvidence)=0
	fired before an evidence is removed More...
virtual void	onAllEvidenceErased_ (bool contains_hard_evidence)=0
	fired before all the evidence are erased More...
virtual void	onEvidenceChanged_ (const NodeId id, bool hasChangedSoftHard)=0
	fired after an evidence is changed, in particular when its status (soft/hard) changes More...
virtual void	updateOutdatedStructure_ ()=0
	prepares inference when the latter is in OutdatedStructure state More...
virtual void	updateOutdatedPotentials_ ()=0
	prepares inference when the latter is in OutdatedPotentials state More...
virtual void	makeInference_ ()=0
	called when the inference has to be performed effectively More...
void	setOutdatedStructureState_ ()
	put the inference into an outdated model structure state More...
void	setOutdatedPotentialsState_ ()
	puts the inference into an OutdatedPotentials state if it is not already in an OutdatedStructure state More...
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). More...
void	setModel_ (const GraphicalModel *model)
void	setModelDuringConstruction_ (const GraphicalModel *model)
	assigns a model during the inference engine construction More...
bool	hasNoModel_ () const

Detailed Description

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

<agrum/MN/inference/jointTargetedMNInference.h>

A generic class for the computation of (possibly incrementally) joint posteriors

The goal of this class is to take care of the joint targets used for computing joint posteriors. The JointTargetedMNInference class inherits from Inference that takes care of handling both evidence and the current state of the inference and from MarginalTargetedMNInference for the handling of marginal targets. Note that the JointTargetedMNInference is designed to be used in incremental inference engines.

Definition at line 56 of file jointTargetedMNInference.h.

Member Enumeration Documentation

StateOfInference

template<typename GUM_SCALAR >

enum 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.
• OutdatedPotentials: in this state, the structure of the model remains unchanged, only some potentials stored in it have changed. Therefore, the inference probably just needs to invalidate some already computed potentials 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 potentials we need.

Enumerator
OutdatedStructure
OutdatedPotentials
ReadyForInference
Done

Definition at line 106 of file graphicalModelInference.h.

    {
      OutdatedStructure,
      OutdatedPotentials,
      ReadyForInference,
      Done
    };

Constructor & Destructor Documentation

JointTargetedMNInference()

template<typename GUM_SCALAR >

gum::JointTargetedMNInference< GUM_SCALAR >::JointTargetedMNInference ( const IMarkovNet< GUM_SCALAR > *  mn )

explicit

default constructor

Warning

note that, by aGrUM's rule, the MN is not copied but only referenced by the inference algorithm.

Definition at line 35 of file jointTargetedMNInference_tpl.h.

                                         :
      MarginalTargetedMNInference< GUM_SCALAR >(mn) {
    // assign a MN if this has not been done before (due to virtual inheritance)
    if (this->hasNoModel_()) {
      MarkovNetInference< GUM_SCALAR >::_setMarkovNetDuringConstruction_(mn);
    }
    GUM_CONSTRUCTOR(JointTargetedMNInference);
  }

~JointTargetedMNInference()

template<typename GUM_SCALAR >

gum::JointTargetedMNInference< GUM_SCALAR >::~JointTargetedMNInference ( )

virtual

destructor

Definition at line 48 of file jointTargetedMNInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                    {
    GUM_DESTRUCTOR(JointTargetedMNInference);
  }

Here is the call graph for this function:

Member Function Documentation

addAllTargets()

template<typename GUM_SCALAR >

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

finalvirtualinherited

adds all nodes as targets

Definition at line 131 of file marginalTargetedMNInference_tpl.h.

                                                                {
    // check if the node belongs to the Markov network
    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->MN().graph()) {
      if (!_targets_.contains(target)) {
        _targets_.insert(target);
        onMarginalTargetAdded_(target);
        this->setState_(MarkovNetInference< GUM_SCALAR >::StateOfInference::OutdatedStructure);
      }
    }
  }

addEvidence() [1/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 228 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

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 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 234 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

addEvidence() [3/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 241 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

addEvidence() [4/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 248 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

addEvidence() [5/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 256 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

    Potential< GUM_SCALAR > pot;
    pot.add(_model_->variable(id));
    pot.fillWith(vals);
    addEvidence(std::move(pot));
  }

Here is the call graph for this function:

addEvidence() [6/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 280 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

addEvidence() [7/8]

template<typename GUM_SCALAR >

INLINE void gum::GraphicalModelInference< GUM_SCALAR >::addEvidence ( const Potential< GUM_SCALAR > &  pot )

finalvirtualinherited

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

Exceptions

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

Definition at line 325 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

addEvidence() [8/8]

template<typename GUM_SCALAR >

void gum::GraphicalModelInference< GUM_SCALAR >::addEvidence ( Potential< GUM_SCALAR > &&  pot )

finalvirtualinherited

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

Exceptions

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

Definition at line 287 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                       {
    // check if the potential 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
    // potential only contains 0 (in this case, this will automatically raise
    // an exception) )
    Idx  val;
    bool is_hard_evidence = _isHardEvidence_(pot, val);

    // insert the evidence
    _evidence_.insert(id,
                      new Potential< GUM_SCALAR >(std::forward< Potential< 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);
  }

Here is the call graph for this function:

addJointTarget()

template<typename GUM_SCALAR >

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

finalvirtual

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 114 of file jointTargetedMNInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                         {
    // check if the nodes in the target belong to the Markov network
    if (this->hasNoModel_())
      GUM_ERROR(NullElement,
                "No Markov net has been assigned to the "
                "inference algorithm");

    const auto& dag = this->MN().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.isProperSupersetOf(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->isProperSubsetOf(joint_target)) eraseJointTarget(*iter);
    }

    this->setTargetedMode_();   // does nothing if already in targeted mode
    _joint_targets_.insert(joint_target);
    onJointTargetAdded_(joint_target);
    this->setState_(MarkovNetInference< GUM_SCALAR >::StateOfInference::OutdatedStructure);
  }

Here is the call graph for this function:

addListOfEvidence()

template<typename GUM_SCALAR >

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

finalvirtualinherited

adds a new list of evidence

Exceptions

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

Definition at line 333 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

addSetOfEvidence()

template<typename GUM_SCALAR >

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

finalvirtualinherited

adds a new set of evidence

Exceptions

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

Definition at line 342 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

addTarget() [1/2]

template<typename GUM_SCALAR >

void gum::MarginalTargetedMNInference< 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 108 of file marginalTargetedMNInference_tpl.h.

                                                                         {
    // check if the node belongs to the Markov network
    if (this->hasNoModel_())
      GUM_ERROR(NullElement,
                "No Markov net has been assigned to the "
                "inference algorithm");

    if (!this->MN().graph().exists(target)) {
      GUM_ERROR(UndefinedElement, target << " is not a NodeId in the Markov network")
    }

    setTargetedMode_();   // does nothing if already in targeted mode
    // add the new target
    if (!_targets_.contains(target)) {
      _targets_.insert(target);
      onMarginalTargetAdded_(target);
      this->setState_(MarkovNetInference< GUM_SCALAR >::StateOfInference::OutdatedStructure);
    }
  }

addTarget() [2/2]

template<typename GUM_SCALAR >

void gum::MarginalTargetedMNInference< 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 152 of file marginalTargetedMNInference_tpl.h.

                                                                                     {
    // check if the node belongs to the Markov network
    if (this->hasNoModel_())
      GUM_ERROR(NullElement,
                "No Markov net has been assigned to the "
                "inference algorithm");

    addTarget(this->MN().idFromName(nodeName));
  }

chgEvidence() [1/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 402 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

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 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 408 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

chgEvidence() [3/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 415 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

chgEvidence() [4/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 422 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

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 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 431 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                             {
    // 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 potential corresponding to vals
    Potential< GUM_SCALAR > pot;
    pot.add(_model_->variable(id));
    pot.fillWith(vals);
    chgEvidence(pot);
  }

Here is the call graph for this function:

chgEvidence() [6/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 456 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

chgEvidence() [7/7]

template<typename GUM_SCALAR >

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

finalvirtualinherited

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

Exceptions

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

Definition at line 464 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                            {
    // check if the potential corresponds to an evidence
    if (pot.nbrDim() != 1) {
      GUM_ERROR(InvalidArgument, pot << " is not a mono-dimensional potential.")
    }
    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
    // potential 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 Potential< 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::OutdatedPotentials); }
    }

    onEvidenceChanged_(id, hasChangedSoftHard);
  }

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 139 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

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 159 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                              {
    return _domain_sizes_;
  }

Here is the call graph for this function:

eraseAllEvidence()

template<typename GUM_SCALAR >

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

finalvirtualinherited

removes all the evidence entered into the network

Definition at line 553 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

eraseAllJointTargets()

template<typename GUM_SCALAR >

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

finalvirtual

Clear all previously defined joint targets.

Definition at line 94 of file jointTargetedMNInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

eraseAllMarginalTargets()

template<typename GUM_SCALAR >

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

finalvirtual

Clear all the previously defined marginal targets.

Definition at line 87 of file jointTargetedMNInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

eraseAllTargets()

template<typename GUM_SCALAR >

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

virtual

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::MarginalTargetedMNInference< GUM_SCALAR >.

Definition at line 106 of file jointTargetedMNInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                      {
    eraseAllMarginalTargets();
    eraseAllJointTargets();
  }

Here is the call graph for this function:

eraseEvidence() [1/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 527 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

      delete (_evidence_[id]);
      _evidence_.erase(id);
    }
  }

Here is the call graph for this function:

eraseEvidence() [2/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 546 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

eraseJointTarget()

template<typename GUM_SCALAR >

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

finalvirtual

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 152 of file jointTargetedMNInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                           {
    // check if the nodes in the target belong to the Markov network
    if (this->hasNoModel_())
      GUM_ERROR(NullElement,
                "No Markov net has been assigned to the "
                "inference algorithm");

    const auto& dag = this->MN().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_(MarkovNetInference< GUM_SCALAR >::StateOfInference::OutdatedStructure);
    }
  }

Here is the call graph for this function:

eraseTarget() [1/2]

template<typename GUM_SCALAR >

void gum::MarginalTargetedMNInference< 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 165 of file marginalTargetedMNInference_tpl.h.

                                                                           {
    // check if the node belongs to the Markov network
    if (this->hasNoModel_())
      GUM_ERROR(NullElement,
                "No Markov net has been assigned to the "
                "inference algorithm");

    if (!this->MN().graph().exists(target)) {
      GUM_ERROR(UndefinedElement, target << " is not a NodeId in the Markov network")
    }


    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_(MarkovNetInference< GUM_SCALAR >::StateOfInference::OutdatedStructure);
    }
  }

eraseTarget() [2/2]

template<typename GUM_SCALAR >

void gum::MarginalTargetedMNInference< 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 189 of file marginalTargetedMNInference_tpl.h.

                                                                                       {
    // check if the node belongs to the Markov network
    if (this->hasNoModel_())
      GUM_ERROR(NullElement,
                "No Markov net has been assigned to the "
                "inference algorithm");

    eraseTarget(this->MN().idFromName(nodeName));
  }

evidence()

template<typename GUM_SCALAR >

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

inherited

returns the set of evidence

Definition at line 605 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                     {
    return _evidence_;
  }

Here is the call graph for this function:

evidenceImpact() [1/2]

template<typename GUM_SCALAR >

Potential< GUM_SCALAR > gum::MarginalTargetedMNInference< GUM_SCALAR >::evidenceImpact ( NodeId  target, const NodeSet &  evs  )

inherited

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

Warning

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

Parameters

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

Returns

a Potential

Definition at line 269 of file marginalTargetedMNInference_tpl.h.

                                                                                                {
    const auto& vtarget = this->MN().variable(target);

    if (evs.contains(target)) {
      GUM_ERROR(InvalidArgument,
                "Target <" << vtarget.name() << "> (" << target << ") can not be in evs (" << evs
                           << ").");
    }
    auto condset = this->MN().minimalCondSet(target, evs);

    Potential< GUM_SCALAR > res;
    this->eraseAllTargets();
    this->eraseAllEvidence();
    res.add(this->MN().variable(target));
    this->addTarget(target);
    for (const auto& n: condset) {
      res.add(this->MN().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->MN().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;
  }

evidenceImpact() [2/2]

template<typename GUM_SCALAR >

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

inherited

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

Warning

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

Parameters

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

Returns

a Potential

Definition at line 307 of file marginalTargetedMNInference_tpl.h.

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

evidenceJointImpact() [1/2]

template<typename GUM_SCALAR >

Potential< GUM_SCALAR > gum::JointTargetedMNInference< GUM_SCALAR >::evidenceJointImpact	(	const NodeSet &	targets,
		const NodeSet &	evs
	)

Create a gum::Potential 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 Potential

Parameters

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

Returns

a Potential

Definition at line 319 of file jointTargetedMNInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                     {
    if (!(evs * targets).empty()) {
      GUM_ERROR(InvalidArgument,
                "Targets (" << targets << ") can not intersect evs (" << evs << ").");
    }
    auto condset = this->MN().minimalCondSet(targets, evs);

    this->eraseAllTargets();
    this->eraseAllEvidence();

    Instantiation           iTarget;
    Potential< GUM_SCALAR > res;
    for (const auto& target: targets) {
      res.add(this->MN().variable(target));
      iTarget.add(this->MN().variable(target));
    }
    this->addJointTarget(targets);

    for (const auto& n: condset) {
      res.add(this->MN().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->MN().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;
  }

Here is the call graph for this function:

evidenceJointImpact() [2/2]

template<typename GUM_SCALAR >

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

Create a gum::Potential 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 Potential

Parameters

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

Returns

a Potential

Definition at line 360 of file jointTargetedMNInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

H() [1/2]

template<typename GUM_SCALAR >

INLINE GUM_SCALAR gum::MarginalTargetedMNInference< 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 254 of file marginalTargetedMNInference_tpl.h.

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

H() [2/2]

template<typename GUM_SCALAR >

INLINE GUM_SCALAR gum::MarginalTargetedMNInference< 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 262 of file marginalTargetedMNInference_tpl.h.

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

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 597 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                              {
    return _hard_evidence_;
  }

Here is the call 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 619 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                       {
    return _hard_evidence_nodes_;
  }

Here is the call 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 351 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                       {
    return !_evidence_.empty();
  }

Here is the call graph for this function:

hasEvidence() [2/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 358 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                {
    return _evidence_.exists(id);
  }

Here is the call graph for this function:

hasEvidence() [3/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 380 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

hasHardEvidence() [1/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 365 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                    {
    return _hard_evidence_nodes_.exists(id);
  }

Here is the call graph for this function:

hasHardEvidence() [2/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 388 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

hasNoModel_()

template<typename GUM_SCALAR >

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

inlineprotectedinherited

Definition at line 527 of file graphicalModelInference.h.

{ return _model_ == nullptr; };

hasSoftEvidence() [1/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 372 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                    {
    return _soft_evidence_nodes_.exists(id);
  }

Here is the call graph for this function:

hasSoftEvidence() [2/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 396 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

I() [1/2]

template<typename GUM_SCALAR >

GUM_SCALAR gum::JointTargetedMNInference< GUM_SCALAR >::I	(	NodeId	X,
		NodeId	Y
	)

Mutual information between X and Y.

See also

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

Warning

Due to limitation of joint, may not be able to compute this value

Exceptions

OperationNotAllowed

in these cases

Definition at line 263 of file jointTargetedMNInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                         {
    Potential< GUM_SCALAR > pX, pY, *pXY = nullptr;
    if (X == Y) { GUM_ERROR(OperationNotAllowed, "Mutual Information I(X,Y) with X==Y") }

    try {
      // here use unnormalized joint posterior rather than just posterior
      // to avoid saving the posterior in the cache of the inference engines
      // like LazyPropagation or Shafer-Shenoy.
      pXY = this->unnormalizedJointPosterior_({X, Y});
      pXY->normalize();
      pX = pXY->margSumOut({&(this->MN().variable(Y))});
      pY = pXY->margSumOut({&(this->MN().variable(X))});
    } catch (...) {
      if (pXY != nullptr) { delete pXY; }
      throw;
    }

    Instantiation i(*pXY);
    auto          res = (GUM_SCALAR)0;

    for (i.setFirst(); !i.end(); ++i) {
      GUM_SCALAR vXY = (*pXY)[i];
      GUM_SCALAR vX  = pX[i];
      GUM_SCALAR vY  = pY[i];

      if (vXY > (GUM_SCALAR)0) {
        if (vX == (GUM_SCALAR)0 || vY == (GUM_SCALAR)0) {
          GUM_ERROR(OperationNotAllowed,
                    "Mutual Information (X,Y) with P(X)=0 or P(Y)=0 "
                    "and P(X,Y)>0");
        }

        res += vXY * (std::log2(vXY) - std::log2(vX) - std::log2(vY));
      }
    }

    delete pXY;

    return res;
  }

Here is the call graph for this function:

I() [2/2]

template<typename GUM_SCALAR >

GUM_SCALAR gum::JointTargetedMNInference< GUM_SCALAR >::I	(	const std::string &	X,
		const std::string &	Y
	)

Mutual information between X and Y.

See also

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

Warning

Due to limitation of joint, may not be able to compute this value

Exceptions

OperationNotAllowed

in these cases

Definition at line 244 of file jointTargetedMNInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                               {
    return I(this->MN().idFromName(Xname), this->MN().idFromName(Yname));
  }

Here is the call graph for this function:

isExactJointComputable_()

template<typename GUM_SCALAR >

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

protectedvirtual

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

Reimplemented in gum::ShaferShenoyMNInference< GUM_SCALAR >.

Definition at line 426 of file jointTargetedMNInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                          {
    if (_joint_targets_.contains(vars)) return true;

    return false;
  }

Here is the call 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 84 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

isInferenceOutdatedPotentials()

template<typename GUM_SCALAR >

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

finalvirtualnoexceptinherited

returns whether the inference object is in a OutdatedPotential state

Definition at line 79 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call 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 73 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

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 68 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

isJointTarget()

template<typename GUM_SCALAR >

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

finalvirtual

return true if target is a joint target.

Definition at line 68 of file jointTargetedMNInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                             {
    if (this->hasNoModel_())
      GUM_ERROR(NullElement,
                "No Markov net has been assigned to the "
                "inference algorithm");

    const auto& gra = this->MN().graph();
    for (const auto var: vars) {
      if (!gra.exists(var)) {
        GUM_ERROR(UndefinedElement, var << " is not a NodeId in the Markov network")
      }
    }

    return _joint_targets_.contains(vars);
  }

Here is the call graph for this function:

isTarget() [1/2]

template<typename GUM_SCALAR >

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

finalvirtualinherited

return true if variable is a (marginal) target

Definition at line 73 of file marginalTargetedMNInference_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->MN().graph().exists(node)) {
      GUM_ERROR(UndefinedElement, node << " is not a NodeId in the Markov network")
    }

    return _targets_.contains(node);
  }

isTarget() [2/2]

template<typename GUM_SCALAR >

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

finalvirtualinherited

return true if variable is a (marginal) target

Definition at line 89 of file marginalTargetedMNInference_tpl.h.

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

isTargetedMode_()

template<typename GUM_SCALAR >

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

protectedinherited

Definition at line 316 of file marginalTargetedMNInference_tpl.h.

                                                                               {
    return _targeted_mode_;
  }

jointMutualInformation() [1/2]

template<typename GUM_SCALAR >

GUM_SCALAR gum::JointTargetedMNInference< GUM_SCALAR >::jointMutualInformation

(

const NodeSet &

targets

)

Mutual information between targets.

See also

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

Parameters

targets

the NodeSet of the targeted variables

Definition at line 370 of file jointTargetedMNInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                          {
    const auto& mn  = this->MN();
    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);
    }

    Set< const DiscreteVariable* > 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.margSumIn(sov).entropy();
    }

    for (Idx i = 0; i < caracteristic.nbrDim(); i++) {
      delete &caracteristic.variable(i);
    }

    return res;
  }

Here is the call graph for this function:

jointMutualInformation() [2/2]

template<typename GUM_SCALAR >

GUM_SCALAR gum::JointTargetedMNInference< GUM_SCALAR >::jointMutualInformation

(

const std::vector< std::string > &

targets

)

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 420 of file jointTargetedMNInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

jointPosterior()

template<typename GUM_SCALAR >

const Potential< GUM_SCALAR > & gum::JointTargetedMNInference< GUM_SCALAR >::jointPosterior ( const NodeSet &  nodes )

finalvirtual

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

for efficiency reasons, the potential is stored into the inference engine and is returned by reference. In order to ensure that the potential 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 199 of file jointTargetedMNInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                {
    // try to get the smallest set of targets that contains "nodes"
    bool    found_exact_target = false;
    NodeSet super_target;

    if (isExactJointComputable_(nodes)) {
      found_exact_target = true;
    } else {
      super_target = superForJointComputable_(nodes);
      if (super_target.empty()) {
        GUM_ERROR(UndefinedElement,
                  "No joint target containing " << nodes << " could be found among "
                                                << _joint_targets_);
      }
    }

    if (!this->isInferenceDone()) { this->makeInference(); }

    if (found_exact_target)
      return jointPosterior_(nodes);
    else
      return jointPosterior_(nodes, super_target);
  }

Here is the call graph for this function:

jointPosterior_() [1/2]

template<typename GUM_SCALAR >

virtual const Potential< GUM_SCALAR >& gum::JointTargetedMNInference< GUM_SCALAR >::jointPosterior_ ( const NodeSet &  set )

protectedpure virtual

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

Parameters

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

Implemented in gum::ShaferShenoyMNInference< GUM_SCALAR >.

jointPosterior_() [2/2]

template<typename GUM_SCALAR >

virtual const Potential< GUM_SCALAR >& gum::JointTargetedMNInference< GUM_SCALAR >::jointPosterior_ ( const NodeSet &  wanted_target, const NodeSet &  declared_target  )

protectedpure virtual

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

Implemented in gum::ShaferShenoyMNInference< GUM_SCALAR >.

jointTargets()

template<typename GUM_SCALAR >

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

finalvirtualnoexcept

returns the list of joint targets

returns the list of target sets

Definition at line 181 of file jointTargetedMNInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                   {
    return _joint_targets_;
  }

Here is the call graph for this function:

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 664 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                   {
    if (isInferenceDone()) { return; }

    if (!isInferenceReady()) { prepareInference(); }

    makeInference_();

    setState_(StateOfInference::Done);
  }

Here is the call graph for this function:

makeInference_()

template<typename GUM_SCALAR >

virtual void gum::GraphicalModelInference< GUM_SCALAR >::makeInference_ ( )

protectedpure virtualinherited

called when the inference has to be performed effectively

Once the inference is done, fillPosterior_ can be called.

Implemented in gum::LazyPropagation< GUM_SCALAR >, gum::SamplingInference< GUM_SCALAR >, gum::VariableElimination< GUM_SCALAR >, gum::ShaferShenoyInference< GUM_SCALAR >, gum::ShaferShenoyMNInference< GUM_SCALAR >, gum::ShaferShenoyLIMIDInference< GUM_SCALAR >, and gum::LoopyBeliefPropagation< GUM_SCALAR >.

MN()

template<typename GUM_SCALAR >

INLINE const IMarkovNet< GUM_SCALAR > & gum::MarkovNetInference< GUM_SCALAR >::MN ( ) const

finalvirtualinherited

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

Exceptions

UndefinedElement

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

Definition at line 57 of file MarkovNetInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

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 107 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call 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 576 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                       {
    return _evidence_.size();
  }

Here is the call graph for this function:

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 583 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                           {
    return _hard_evidence_nodes_.size();
  }

Here is the call graph for this function:

nbrJointTargets()

template<typename GUM_SCALAR >

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

finalvirtualnoexcept

returns the number of joint targets

returns the number of target sets

Definition at line 187 of file jointTargetedMNInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                     {
    return _joint_targets_.size();
  }

Here is the call graph for this function:

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 590 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                           {
    return _soft_evidence_nodes_.size();
  }

Here is the call graph for this function:

nbrTargets()

template<typename GUM_SCALAR >

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

finalvirtualnoexceptinherited

returns the number of marginal targets

Definition at line 208 of file marginalTargetedMNInference_tpl.h.

                                                                                         {
    return _targets_.size();
  }

onAllEvidenceErased_()

template<typename GUM_SCALAR >

virtual void gum::GraphicalModelInference< GUM_SCALAR >::onAllEvidenceErased_ ( bool  contains_hard_evidence )

protectedpure virtualinherited

fired before all the evidence are erased

Implemented in gum::SamplingInference< GUM_SCALAR >, gum::ShaferShenoyLIMIDInference< GUM_SCALAR >, gum::LazyPropagation< GUM_SCALAR >, gum::VariableElimination< GUM_SCALAR >, gum::ShaferShenoyInference< GUM_SCALAR >, gum::ShaferShenoyMNInference< GUM_SCALAR >, and gum::LoopyBeliefPropagation< GUM_SCALAR >.

onAllJointTargetsErased_()

template<typename GUM_SCALAR >

virtual void gum::JointTargetedMNInference< GUM_SCALAR >::onAllJointTargetsErased_ ( )

protectedpure virtual

fired before a all the joint targets are removed

Implemented in gum::ShaferShenoyMNInference< GUM_SCALAR >.

onAllMarginalTargetsAdded_()

template<typename GUM_SCALAR >

virtual void gum::MarginalTargetedMNInference< GUM_SCALAR >::onAllMarginalTargetsAdded_ ( )

protectedpure virtualinherited

fired after all the nodes of the MN are added as marginal targets

Implemented in gum::ShaferShenoyMNInference< GUM_SCALAR >.

onAllMarginalTargetsErased_()

template<typename GUM_SCALAR >

virtual void gum::MarginalTargetedMNInference< GUM_SCALAR >::onAllMarginalTargetsErased_ ( )

protectedpure virtualinherited

fired before a all marginal targets are removed

Implemented in gum::ShaferShenoyMNInference< GUM_SCALAR >.

onAllTargetsErased_()

template<typename GUM_SCALAR >

virtual void gum::JointTargetedMNInference< GUM_SCALAR >::onAllTargetsErased_ ( )

protectedpure virtual

fired before a all the marginal and joint targets are removed

Implemented in gum::ShaferShenoyMNInference< GUM_SCALAR >.

onEvidenceAdded_()

template<typename GUM_SCALAR >

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

protectedpure virtualinherited

fired after a new evidence is inserted

Implemented in gum::SamplingInference< GUM_SCALAR >, gum::ShaferShenoyLIMIDInference< GUM_SCALAR >, gum::LazyPropagation< GUM_SCALAR >, gum::VariableElimination< GUM_SCALAR >, gum::ShaferShenoyInference< GUM_SCALAR >, gum::ShaferShenoyMNInference< GUM_SCALAR >, and gum::LoopyBeliefPropagation< GUM_SCALAR >.

onEvidenceChanged_()

template<typename GUM_SCALAR >

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

protectedpure virtualinherited

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

Implemented in gum::SamplingInference< GUM_SCALAR >, gum::LazyPropagation< GUM_SCALAR >, gum::ShaferShenoyLIMIDInference< GUM_SCALAR >, gum::VariableElimination< GUM_SCALAR >, gum::ShaferShenoyInference< GUM_SCALAR >, gum::ShaferShenoyMNInference< GUM_SCALAR >, and gum::LoopyBeliefPropagation< GUM_SCALAR >.

onEvidenceErased_()

template<typename GUM_SCALAR >

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

protectedpure virtualinherited

fired before an evidence is removed

Implemented in gum::SamplingInference< GUM_SCALAR >, gum::ShaferShenoyLIMIDInference< GUM_SCALAR >, gum::LazyPropagation< GUM_SCALAR >, gum::VariableElimination< GUM_SCALAR >, gum::ShaferShenoyInference< GUM_SCALAR >, gum::ShaferShenoyMNInference< GUM_SCALAR >, and gum::LoopyBeliefPropagation< GUM_SCALAR >.

onJointTargetAdded_()

template<typename GUM_SCALAR >

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

protectedpure virtual

fired after a new joint target is inserted

Parameters

set	The set of target variable's ids.

Implemented in gum::ShaferShenoyMNInference< GUM_SCALAR >.

onJointTargetErased_()

template<typename GUM_SCALAR >

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

protectedpure virtual

fired before a joint target is removed

Parameters

set	The set of target variable's ids.

Implemented in gum::ShaferShenoyMNInference< GUM_SCALAR >.

onMarginalTargetAdded_()

template<typename GUM_SCALAR >

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

protectedpure virtualinherited

fired after a new marginal target is inserted

Parameters

id	The target variable's id.

Implemented in gum::ShaferShenoyMNInference< GUM_SCALAR >.

onMarginalTargetErased_()

template<typename GUM_SCALAR >

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

protectedpure virtualinherited

fired before a marginal target is removed

Parameters

id	The target variable's id.

Implemented in gum::ShaferShenoyMNInference< GUM_SCALAR >.

onModelChanged_()

template<typename GUM_SCALAR >

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

protectedvirtual

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

Reimplemented from gum::MarginalTargetedMNInference< GUM_SCALAR >.

Definition at line 55 of file jointTargetedMNInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                       {
    MarginalTargetedMNInference< GUM_SCALAR >::onModelChanged_(mn);
    onAllJointTargetsErased_();
    _joint_targets_.clear();
  }

Here is the call graph for this function:

onStateChanged_()

template<typename GUM_SCALAR >

virtual void gum::GraphicalModelInference< GUM_SCALAR >::onStateChanged_ ( )

protectedpure virtualinherited

fired when the stage is changed

Implemented in gum::SamplingInference< GUM_SCALAR >, gum::LazyPropagation< GUM_SCALAR >, gum::ShaferShenoyLIMIDInference< GUM_SCALAR >, gum::VariableElimination< GUM_SCALAR >, gum::ShaferShenoyInference< GUM_SCALAR >, gum::ShaferShenoyMNInference< GUM_SCALAR >, and gum::LoopyBeliefPropagation< GUM_SCALAR >.

posterior() [1/2]

template<typename GUM_SCALAR >

const Potential< GUM_SCALAR > & gum::JointTargetedMNInference< GUM_SCALAR >::posterior ( NodeId  node )

finalvirtual

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 potential is stored into the inference engine and is returned by reference. In order to ensure that the potential 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::MarginalTargetedMNInference< GUM_SCALAR >.

Definition at line 226 of file jointTargetedMNInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

posterior() [2/2]

template<typename GUM_SCALAR >

const Potential< GUM_SCALAR > & gum::JointTargetedMNInference< GUM_SCALAR >::posterior ( const std::string &  nodeName )

finalvirtual

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 potential is stored into the inference engine and is returned by reference. In order to ensure that the potential 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::MarginalTargetedMNInference< GUM_SCALAR >.

Definition at line 236 of file jointTargetedMNInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

posterior_()

template<typename GUM_SCALAR >

virtual const Potential< GUM_SCALAR >& gum::MarginalTargetedMNInference< GUM_SCALAR >::posterior_ ( NodeId  id )

protectedpure virtualinherited

asks derived classes for the posterior of a given variable

Parameters

id	The variable's id.

Implemented in gum::ShaferShenoyMNInference< GUM_SCALAR >.

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 645 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                      {
    if (isInferenceReady() || isInferenceDone()) { return; }

    if (_model_ == nullptr)
      GUM_ERROR(NullElement,
                "No model been assigned to the "
                "inference algorithm");

    if (_state_ == StateOfInference::OutdatedStructure)
      updateOutdatedStructure_();
    else
      updateOutdatedPotentials_();

    setState_(StateOfInference::ReadyForInference);
  }

Here is the call graph for this function:

setMN()

template<typename GUM_SCALAR >

void gum::MarkovNetInference< GUM_SCALAR >::setMN ( const IMarkovNet< GUM_SCALAR > *  mn )

virtualinherited

assigns a new MN to the inference engine

Assigns a new MN to the MarkovNetInference engine and sends messages to the descendants of MarkovNetInference to inform them that the MN 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 64 of file MarkovNetInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                 {
    this->setModel_(mn);
  }

Here is the call graph for this function:

setModel_()

template<typename GUM_SCALAR >

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

protectedinherited

Definition at line 118 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call 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 129 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

setOutdatedPotentialsState_()

template<typename GUM_SCALAR >

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

protectedinherited

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

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

Definition at line 638 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                 {
    setState_(StateOfInference::OutdatedPotentials);
  }

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 OutdatedPotentials 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 potentials 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 630 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                {
    setState_(StateOfInference::OutdatedStructure);
  }

Here is the call 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 98 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

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

Here is the call graph for this function:

setTargetedMode_()

template<typename GUM_SCALAR >

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

protectedinherited

Definition at line 320 of file marginalTargetedMNInference_tpl.h.

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

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 612 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                       {
    return _soft_evidence_nodes_;
  }

Here is the call 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 92 of file graphicalModelInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                 {
    return _state_;
  }

Here is the call graph for this function:

superForJointComputable_()

template<typename GUM_SCALAR >

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

protectedvirtual

Reimplemented in gum::ShaferShenoyMNInference< GUM_SCALAR >.

Definition at line 433 of file jointTargetedMNInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                              {
    for (const auto& target: _joint_targets_)
      if (vars.isProperSubsetOf(target)) return target;

    for (const auto& factor: this->MN().factors())
      if (vars.isProperSubsetOf(factor.first)) return factor.first;

    return NodeSet();
  }

Here is the call graph for this function:

targets()

template<typename GUM_SCALAR >

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

finalvirtualnoexceptinherited

returns the list of marginal targets

Definition at line 202 of file marginalTargetedMNInference_tpl.h.

                                                                                          {
    return _targets_;
  }

unnormalizedJointPosterior_() [1/2]

template<typename GUM_SCALAR >

virtual Potential< GUM_SCALAR >* gum::JointTargetedMNInference< GUM_SCALAR >::unnormalizedJointPosterior_ ( const NodeSet &  set )

protectedpure virtual

returns a fresh unnormalized joint posterior of a given set of variables

Parameters

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

Implemented in gum::ShaferShenoyMNInference< GUM_SCALAR >.

unnormalizedJointPosterior_() [2/2]

template<typename GUM_SCALAR >

virtual Potential< GUM_SCALAR >* gum::JointTargetedMNInference< GUM_SCALAR >::unnormalizedJointPosterior_ ( NodeId  id )

protectedpure virtual

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

Implemented in gum::ShaferShenoyMNInference< GUM_SCALAR >.

updateOutdatedPotentials_()

template<typename GUM_SCALAR >

virtual void gum::GraphicalModelInference< GUM_SCALAR >::updateOutdatedPotentials_ ( )

protectedpure virtualinherited

prepares inference when the latter is in OutdatedPotentials state

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

Implemented in gum::SamplingInference< GUM_SCALAR >, gum::LazyPropagation< GUM_SCALAR >, gum::VariableElimination< GUM_SCALAR >, gum::ShaferShenoyInference< GUM_SCALAR >, gum::ShaferShenoyMNInference< GUM_SCALAR >, gum::ShaferShenoyLIMIDInference< GUM_SCALAR >, and gum::LoopyBeliefPropagation< GUM_SCALAR >.

updateOutdatedStructure_()

template<typename GUM_SCALAR >

virtual void gum::GraphicalModelInference< GUM_SCALAR >::updateOutdatedStructure_ ( )

protectedpure virtualinherited

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

Implemented in gum::SamplingInference< GUM_SCALAR >, gum::LazyPropagation< GUM_SCALAR >, gum::VariableElimination< GUM_SCALAR >, gum::ShaferShenoyInference< GUM_SCALAR >, gum::ShaferShenoyMNInference< GUM_SCALAR >, gum::ShaferShenoyLIMIDInference< GUM_SCALAR >, and gum::LoopyBeliefPropagation< GUM_SCALAR >.

VI() [1/2]

template<typename GUM_SCALAR >

INLINE GUM_SCALAR gum::JointTargetedMNInference< GUM_SCALAR >::VI	(	NodeId	X,
		NodeId	Y
	)

Variation of information between X and Y.

See also

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

Warning

Due to limitation of joint, may not be able to compute this value

Exceptions

OperationNotAllowed

in these cases

See also

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

Warning

Due to limitation of , may not be able to compute this value

Exceptions

OperationNotAllowed

in these cases

Definition at line 312 of file jointTargetedMNInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                 {
    return this->H(X) + this->H(Y) - 2 * I(X, Y);
  }

Here is the call graph for this function:

VI() [2/2]

template<typename GUM_SCALAR >

GUM_SCALAR gum::JointTargetedMNInference< GUM_SCALAR >::VI	(	const std::string &	X,
		const std::string &	Y
	)

Variation of information between X and Y.

See also

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

Warning

Due to limitation of joint, may not be able to compute this value

Exceptions

OperationNotAllowed

in these cases

Definition at line 250 of file jointTargetedMNInference_tpl.h.

References gum::Set< Key, Alloc >::emplace().

                                                                                {
    return VI(this->MN().idFromName(Xname), this->MN().idFromName(Yname));
  }

Here is the call graph for this function:

Member Data Documentation

_joint_targets_

template<typename GUM_SCALAR >

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

private

the set of joint targets

Definition at line 308 of file jointTargetedMNInference.h.

---

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

• agrum/MN/inference/tools/jointTargetedMNInference.h
• agrum/MN/inference/tools/jointTargetedMNInference_tpl.h