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

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

#include <CNLoopyPropagation.h>

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

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

Public Attributes
Signaler3< Size, double, double >	onProgress
	Progression, error and time. More...
Signaler1< std::string >	onStop
	Criteria messageApproximationScheme. More...

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

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

Protected Attributes
NodeProperty< bool >	_update_p
	Used to keep track of which node needs to update it's information coming from it's parents. More...
NodeProperty< bool >	_update_l
	Used to keep track of which node needs to update it's information coming from it's children. More...
NodeSet	active_nodes_set
	The current node-set to iterate through at this current step. More...
NodeSet	next_active_nodes_set
	The next node-set, i.e. More...
NodeProperty< NodeSet *>	_msg_l_sent
	Used to keep track of one's messages sent to it's parents. More...
ArcProperty< GUM_SCALAR >	_ArcsL_min
	"Lower" information \( \Lambda \) coming from one's children. More...
ArcProperty< GUM_SCALAR >	_ArcsP_min
	"Lower" information \( \pi \) coming from one's parent. More...
NodeProperty< GUM_SCALAR >	_NodesL_min
	"Lower" node information \( \Lambda \) obtained by combinaison of children messages. More...
NodeProperty< GUM_SCALAR >	_NodesP_min
	"Lower" node information \( \pi \) obtained by combinaison of parent's messages. More...
ArcProperty< GUM_SCALAR >	_ArcsL_max
	"Upper" information \( \Lambda \) coming from one's children. More...
ArcProperty< GUM_SCALAR >	_ArcsP_max
	"Upper" information \( \pi \) coming from one's parent. More...
NodeProperty< GUM_SCALAR >	_NodesL_max
	"Upper" node information \( \Lambda \) obtained by combinaison of children messages. More...
NodeProperty< GUM_SCALAR >	_NodesP_max
	"Upper" node information \( \pi \) obtained by combinaison of parent's messages. More...
bool	_InferenceUpToDate
	TRUE if inference has already been performed, FALSE otherwise. More...
const CredalNet< GUM_SCALAR > *	_credalNet
	A pointer to the Credal Net used. More...
margi	_oldMarginalMin
	Old lower marginals used to compute epsilon. More...
margi	_oldMarginalMax
	Old upper marginals used to compute epsilon. More...
margi	_marginalMin
	Lower marginals. More...
margi	_marginalMax
	Upper marginals. More...
credalSet	_marginalSets
	Credal sets vertices, if enabled. More...
expe	_expectationMin
	Lower expectations, if some variables modalities were inserted. More...
expe	_expectationMax
	Upper expectations, if some variables modalities were inserted. More...
dynExpe	_dynamicExpMin
	Lower dynamic expectations. More...
dynExpe	_dynamicExpMax
	Upper dynamic expectations. More...
dynExpe	_modal
	Variables modalities used to compute expectations. More...
margi	_evidence
	Holds observed variables states. More...
query	_query
	Holds the query nodes states. More...
cluster	_t0
	Clusters of nodes used with dynamic networks. More...
cluster	_t1
	Clusters of nodes used with dynamic networks. More...
bool	_storeVertices
	True if credal sets vertices are stored, False otherwise. More...
bool	_repetitiveInd
	True if using repetitive independence ( dynamic network only ), False otherwise. More...
bool	_storeBNOpt
	Iterations limit stopping rule used by some algorithms such as CNMonteCarloSampling. More...
VarMod2BNsMap< GUM_SCALAR >	_dbnOpt
	Object used to efficiently store optimal bayes net during inference, for some algorithms. More...
int	_timeSteps
	The number of time steps of this network (only usefull for dynamic networks). More...
double	_current_epsilon
	Current epsilon. More...
double	_last_epsilon
	Last epsilon value. More...
double	_current_rate
	Current rate. More...
Size	_current_step
	The current step. More...
Timer	_timer
	The timer. More...
ApproximationSchemeSTATE	_current_state
	The current state. More...
std::vector< double >	_history
	The scheme history, used only if verbosity == true. More...
double	_eps
	Threshold for convergence. More...
bool	_enabled_eps
	If true, the threshold convergence is enabled. More...
double	_min_rate_eps
	Threshold for the epsilon rate. More...
bool	_enabled_min_rate_eps
	If true, the minimal threshold for epsilon rate is enabled. More...
double	_max_time
	The timeout. More...
bool	_enabled_max_time
	If true, the timeout is enabled. More...
Size	_max_iter
	The maximum iterations. More...
bool	_enabled_max_iter
	If true, the maximum iterations stopping criterion is enabled. More...
Size	_burn_in
	Number of iterations before checking stopping criteria. More...
Size	_period_size
	Checking criteria frequency. More...
bool	_verbosity
	If true, verbosity is enabled. More...

Protected Member Functions
Protected initialization methods
void	_initialize ()
	Topological forward propagation to initialize old marginals & messages. More...
Protected algorithm methods
void	_makeInferenceNodeToNeighbours ()
	Starts the inference with this inference type. More...
void	_makeInferenceByOrderedArcs ()
	Starts the inference with this inference type. More...
void	_makeInferenceByRandomOrder ()
	Starts the inference with this inference type. More...
void	_updateMarginals ()
	Compute marginals from up-to-date messages. More...
void	_msgL (const NodeId X, const NodeId demanding_parent)
	Sends a message to one's parent, i.e. More...
void	_compute_ext (GUM_SCALAR &msg_l_min, GUM_SCALAR &msg_l_max, std::vector< GUM_SCALAR > &lx, GUM_SCALAR &num_min, GUM_SCALAR &num_max, GUM_SCALAR &den_min, GUM_SCALAR &den_max)
	Used by _msgL. More...
void	_compute_ext (std::vector< std::vector< GUM_SCALAR > > &combi_msg_p, const NodeId &id, GUM_SCALAR &msg_l_min, GUM_SCALAR &msg_l_max, std::vector< GUM_SCALAR > &lx, const Idx &pos)
	Used by _msgL. More...
void	_enum_combi (std::vector< std::vector< std::vector< GUM_SCALAR > > > &msgs_p, const NodeId &id, GUM_SCALAR &msg_l_min, GUM_SCALAR &msg_l_max, std::vector< GUM_SCALAR > &lx, const Idx &pos)
	Used by _msgL. More...
void	_msgP (const NodeId X, const NodeId demanding_child)
	Sends a message to one's child, i.e. More...
void	_enum_combi (std::vector< std::vector< std::vector< GUM_SCALAR > > > &msgs_p, const NodeId &id, GUM_SCALAR &msg_p_min, GUM_SCALAR &msg_p_max)
	Used by _msgP. More...
void	_compute_ext (std::vector< std::vector< GUM_SCALAR > > &combi_msg_p, const NodeId &id, GUM_SCALAR &msg_p_min, GUM_SCALAR &msg_p_max)
	Used by _msgP. More...
void	_refreshLMsPIs (bool refreshIndic=false)
	Get the last messages from one's parents and children. More...
GUM_SCALAR	_calculateEpsilon ()
	Compute epsilon. More...
Post-inference protected methods
void	_computeExpectations ()
	Since the network is binary, expectations can be computed from the final marginals which give us the credal set vertices. More...
void	_updateIndicatrices ()
	Only update indicatrices variables at the end of computations ( calls _msgP ). More...
Protected initialization methods
void	_repetitiveInit ()
	Initialize _t0 and _t1 clusters. More...
void	_initExpectations ()
	Initialize lower and upper expectations before inference, with the lower expectation being initialized on the highest modality and the upper expectation being initialized on the lowest modality. More...
void	_initMarginals ()
	Initialize lower and upper old marginals and marginals before inference, with the lower marginal being 1 and the upper 0. More...
void	_initMarginalSets ()
	Initialize credal set vertices with empty sets. More...
Protected algorithms methods
const GUM_SCALAR	_computeEpsilon ()
	Compute approximation scheme epsilon using the old marginals and the new ones. More...
void	_updateExpectations (const NodeId &id, const std::vector< GUM_SCALAR > &vertex)
	Given a node id and one of it's possible vertex obtained during inference, update this node lower and upper expectations. More...
void	_updateCredalSets (const NodeId &id, const std::vector< GUM_SCALAR > &vertex, const bool &elimRedund=false)
	Given a node id and one of it's possible vertex, update it's credal set. More...
Proptected post-inference methods
void	_dynamicExpectations ()
	Rearrange lower and upper expectations to suit dynamic networks. More...

Detailed Description

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

<agrum/CN/CNLoopyPropagation.h>

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

Template Parameters

GUM_SCALAR

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

Author

Matthieu HOURBRACQ and Pierre-Henri WUILLEMIN

Definition at line 58 of file CNLoopyPropagation.h.

Member Typedef Documentation

__infE

template<typename GUM_SCALAR >

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

private

To easily access InferenceEngine< GUM_SCALAR > methods.

Definition at line 368 of file CNLoopyPropagation.h.

cArcP

template<typename GUM_SCALAR >

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

Definition at line 61 of file CNLoopyPropagation.h.

msg

template<typename GUM_SCALAR >

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

Definition at line 60 of file CNLoopyPropagation.h.

Member Enumeration Documentation

ApproximationSchemeSTATE

enum gum::IApproximationSchemeConfiguration::ApproximationSchemeSTATE : char

stronginherited

The different state of an approximation scheme.

Enumerator
Undefined
Continue
Epsilon
Rate
Limit
TimeLimit
Stopped

Definition at line 65 of file IApproximationSchemeConfiguration.h.

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

InferenceType

template<typename GUM_SCALAR >

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

strong

Inference type to be used by the algorithm.

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

Definition at line 66 of file CNLoopyPropagation.h.

                               : char {
        nodeToNeighbours, 
        ordered, 
        randomOrder 
      };

Constructor & Destructor Documentation

CNLoopyPropagation()

template<typename GUM_SCALAR >

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

explicit

Constructor.

Parameters

cnet	The CredalNet to be used with this algorithm.

Definition at line 1508 of file CNLoopyPropagation_tpl.h.

References gum::credal::CNLoopyPropagation< GUM_SCALAR >::__bnet, gum::credal::CNLoopyPropagation< GUM_SCALAR >::__cn, gum::credal::CNLoopyPropagation< GUM_SCALAR >::__inferenceType, gum::credal::CNLoopyPropagation< GUM_SCALAR >::_InferenceUpToDate, gum::credal::CredalNet< GUM_SCALAR >::current_bn(), GUM_ERROR, gum::credal::CredalNet< GUM_SCALAR >::hasComputedCPTMinMax(), gum::credal::CredalNet< GUM_SCALAR >::isSeparatelySpecified(), and gum::credal::CNLoopyPropagation< GUM_SCALAR >::nodeToNeighbours.

                                            :
        InferenceEngine< GUM_SCALAR >::InferenceEngine(cnet) {
      if (!cnet.isSeparatelySpecified()) {
        GUM_ERROR(OperationNotAllowed,
                  "CNLoopyPropagation is only available "
                  "with separately specified nets");
      }

      // test for binary cn
      for (auto node : cnet.current_bn().nodes())
        if (cnet.current_bn().variable(node).domainSize() != 2) {
          GUM_ERROR(OperationNotAllowed,
                    "CNLoopyPropagation is only available "
                    "with binary credal networks");
        }

      // test if compute CPTMinMax has been called
      if (!cnet.hasComputedCPTMinMax()) {
        GUM_ERROR(OperationNotAllowed,
                  "CNLoopyPropagation only works when "
                  "\"computeCPTMinMax()\" has been called for "
                  "this credal net");
      }

      __cn = &cnet;
      __bnet = &cnet.current_bn();

      __inferenceType = InferenceType::nodeToNeighbours;
      _InferenceUpToDate = false;

      GUM_CONSTRUCTOR(CNLoopyPropagation);
    }

Here is the call graph for this function:

~CNLoopyPropagation()

template<typename GUM_SCALAR >

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

virtual

Destructor.

Definition at line 1543 of file CNLoopyPropagation_tpl.h.

References gum::credal::CNLoopyPropagation< GUM_SCALAR >::__bnet, gum::credal::CNLoopyPropagation< GUM_SCALAR >::_InferenceUpToDate, and gum::credal::CNLoopyPropagation< GUM_SCALAR >::_msg_l_sent.

                                                          {
      _InferenceUpToDate = false;

      if (_msg_l_sent.size() > 0) {
        for (auto node : __bnet->nodes()) {
          delete _msg_l_sent[node];
        }
      }

      //_msg_l_sent.clear();
      //_update_l.clear();
      //_update_p.clear();

      GUM_DESTRUCTOR(CNLoopyPropagation);
    }

Member Function Documentation

_calculateEpsilon()

template<typename GUM_SCALAR >

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

protected

Compute epsilon.

Returns

Epsilon.

Definition at line 1457 of file CNLoopyPropagation_tpl.h.

                                                                   {
      _refreshLMsPIs();
      _updateMarginals();

      return __infE::_computeEpsilon();
    }

_compute_ext() [1/3]

template<typename GUM_SCALAR >

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

protected

Used by _msgL.

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

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

Parameters

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

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

Definition at line 181 of file CNLoopyPropagation_tpl.h.

References _INF.

                                           {
      GUM_SCALAR num_min_tmp = 1.;
      GUM_SCALAR den_min_tmp = 1.;
      GUM_SCALAR num_max_tmp = 1.;
      GUM_SCALAR den_max_tmp = 1.;

      GUM_SCALAR res_min = 1.0, res_max = 0.0;

      auto lsize = lx.size();

      for (decltype(lsize) i = 0; i < lsize; i++) {
        bool non_defini_min = false;
        bool non_defini_max = false;

        if (lx[i] == _INF) {
          num_min_tmp = num_min;
          den_min_tmp = den_max;
          num_max_tmp = num_max;
          den_max_tmp = den_min;
        } else if (lx[i] == (GUM_SCALAR)1.) {
          num_min_tmp = GUM_SCALAR(1.);
          den_min_tmp = GUM_SCALAR(1.);
          num_max_tmp = GUM_SCALAR(1.);
          den_max_tmp = GUM_SCALAR(1.);
        } else if (lx[i] > (GUM_SCALAR)1.) {
          GUM_SCALAR li = GUM_SCALAR(1.) / (lx[i] - GUM_SCALAR(1.));
          num_min_tmp = num_min + li;
          den_min_tmp = den_max + li;
          num_max_tmp = num_max + li;
          den_max_tmp = den_min + li;
        } else if (lx[i] < (GUM_SCALAR)1.) {
          GUM_SCALAR li = GUM_SCALAR(1.) / (lx[i] - GUM_SCALAR(1.));
          num_min_tmp = num_max + li;
          den_min_tmp = den_min + li;
          num_max_tmp = num_min + li;
          den_max_tmp = den_max + li;
        }

        if (den_min_tmp == 0. && num_min_tmp == 0.) {
          non_defini_min = true;
        } else if (den_min_tmp == 0. && num_min_tmp != 0.) {
          res_min = _INF;
        } else if (den_min_tmp != _INF || num_min_tmp != _INF) {
          res_min = num_min_tmp / den_min_tmp;
        }

        if (den_max_tmp == 0. && num_max_tmp == 0.) {
          non_defini_max = true;
        } else if (den_max_tmp == 0. && num_max_tmp != 0.) {
          res_max = _INF;
        } else if (den_max_tmp != _INF || num_max_tmp != _INF) {
          res_max = num_max_tmp / den_max_tmp;
        }

        if (non_defini_max && non_defini_min) {
          std::cout << "undefined msg" << std::endl;
          continue;
        } else if (non_defini_min && !non_defini_max) {
          res_min = res_max;
        } else if (non_defini_max && !non_defini_min) {
          res_max = res_min;
        }

        if (res_min < 0.) { res_min = 0.; }

        if (res_max < 0.) { res_max = 0.; }

        if (msg_l_min == msg_l_max && msg_l_min == -2.) {
          msg_l_min = res_min;
          msg_l_max = res_max;
        }

        if (res_max > msg_l_max) { msg_l_max = res_max; }

        if (res_min < msg_l_min) { msg_l_min = res_min; }

      }   // end of : for each lx
    }

_compute_ext() [2/3]

template<typename GUM_SCALAR >

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

protected

Used by _msgL.

extremes pour une combinaison des parents, message vers parent

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

Parameters

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

Definition at line 271 of file CNLoopyPropagation_tpl.h.

                                                      {
      GUM_SCALAR num_min = 0.;
      GUM_SCALAR num_max = 0.;
      GUM_SCALAR den_min = 0.;
      GUM_SCALAR den_max = 0.;

      auto taille = combi_msg_p.size();

      std::vector< typename std::vector< GUM_SCALAR >::iterator > it(taille);

      for (decltype(taille) i = 0; i < taille; i++) {
        it[i] = combi_msg_p[i].begin();
      }

      Size pp = pos;

      Size combi_den = 0;
      Size combi_num = pp;

      // marginalisation
      while (it[taille - 1] != combi_msg_p[taille - 1].end()) {
        GUM_SCALAR prod = 1.;

        for (decltype(taille) k = 0; k < taille; k++) {
          prod *= *it[k];
        }

        den_min += (__cn->get_CPT_min()[id][combi_den] * prod);
        den_max += (__cn->get_CPT_max()[id][combi_den] * prod);

        num_min += (__cn->get_CPT_min()[id][combi_num] * prod);
        num_max += (__cn->get_CPT_max()[id][combi_num] * prod);

        combi_den++;
        combi_num++;

        if (combi_den % pp == 0) {
          combi_den += pp;
          combi_num += pp;
        }

        // incrementation
        ++it[0];

        for (decltype(taille) i = 0;
             (i < taille - 1) && (it[i] == combi_msg_p[i].end());
             ++i) {
          it[i] = combi_msg_p[i].begin();
          ++it[i + 1];
        }
      }   // end of : marginalisation

      _compute_ext(msg_l_min, msg_l_max, lx, num_min, num_max, den_min, den_max);
    }

_compute_ext() [3/3]

template<typename GUM_SCALAR >

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

protected

Used by _msgP.

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

Marginalisation.

Parameters

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

Definition at line 337 of file CNLoopyPropagation_tpl.h.

                                                            {
      GUM_SCALAR min = 0.;
      GUM_SCALAR max = 0.;

      auto taille = combi_msg_p.size();

      std::vector< typename std::vector< GUM_SCALAR >::iterator > it(taille);

      for (decltype(taille) i = 0; i < taille; i++) {
        it[i] = combi_msg_p[i].begin();
      }

      int  combi = 0;
      auto theEnd = combi_msg_p[taille - 1].end();

      while (it[taille - 1] != theEnd) {
        GUM_SCALAR prod = 1.;

        for (decltype(taille) k = 0; k < taille; k++) {
          prod *= *it[k];
        }

        min += (__cn->get_CPT_min()[id][combi] * prod);
        max += (__cn->get_CPT_max()[id][combi] * prod);

        combi++;

        // incrementation
        ++it[0];

        for (decltype(taille) i = 0;
             (i < taille - 1) && (it[i] == combi_msg_p[i].end());
             ++i) {
          it[i] = combi_msg_p[i].begin();
          ++it[i + 1];
        }
      }

      if (min < msg_p_min) { msg_p_min = min; }

      if (max > msg_p_max) { msg_p_max = max; }
    }

_computeEpsilon()

template<typename GUM_SCALAR >

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

inlineprotectedinherited

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

Highest delta on either lower or upper marginal is epsilon.

Also updates oldMarginals to current marginals.

Returns

Epsilon.

Definition at line 1016 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_marginalMax, gum::credal::InferenceEngine< GUM_SCALAR >::_marginalMin, gum::credal::InferenceEngine< GUM_SCALAR >::_oldMarginalMax, gum::credal::InferenceEngine< GUM_SCALAR >::_oldMarginalMin, and gum::HashTable< Key, Val, Alloc >::size().

                                                                           {
      GUM_SCALAR eps = 0;
#pragma omp parallel
      {
        GUM_SCALAR tEps = 0;
        GUM_SCALAR delta;

        int nsize = int(_marginalMin.size());

#pragma omp for

        for (int i = 0; i < nsize; i++) {
          auto dSize = _marginalMin[i].size();

          for (Size j = 0; j < dSize; j++) {
            // on min
            delta = _marginalMin[i][j] - _oldMarginalMin[i][j];
            delta = (delta < 0) ? (-delta) : delta;
            tEps = (tEps < delta) ? delta : tEps;

            // on max
            delta = _marginalMax[i][j] - _oldMarginalMax[i][j];
            delta = (delta < 0) ? (-delta) : delta;
            tEps = (tEps < delta) ? delta : tEps;

            _oldMarginalMin[i][j] = _marginalMin[i][j];
            _oldMarginalMax[i][j] = _marginalMax[i][j];
          }
        }   // end of : all variables

#pragma omp critical(epsilon_max)
        {
#pragma omp flush(eps)
          eps = (eps < tEps) ? tEps : eps;
        }
      }

      return eps;
    }

Here is the call graph for this function:

_computeExpectations()

template<typename GUM_SCALAR >

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

protected

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

Definition at line 1482 of file CNLoopyPropagation_tpl.h.

                                                                {
      if (__infE::_modal.empty()) { return; }

      std::vector< std::vector< GUM_SCALAR > > vertices(
         2, std::vector< GUM_SCALAR >(2));

      for (auto node : __bnet->nodes()) {
        vertices[0][0] = __infE::_marginalMin[node][0];
        vertices[0][1] = __infE::_marginalMax[node][1];

        vertices[1][0] = __infE::_marginalMax[node][0];
        vertices[1][1] = __infE::_marginalMin[node][1];

        for (auto vertex = 0, vend = 2; vertex != vend; vertex++) {
          __infE::_updateExpectations(node, vertices[vertex]);
          // test credal sets vertices elim
          // remove with L2U since variables are binary
          // but does the user know that ?
          __infE::_updateCredalSets(
             node,
             vertices[vertex]);   // no redundancy elimination with 2 vertices
        }
      }
    }

_dynamicExpectations()

template<typename GUM_SCALAR >

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

protectedinherited

Rearrange lower and upper expectations to suit dynamic networks.

Definition at line 721 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_credalNet, gum::credal::InferenceEngine< GUM_SCALAR >::_dynamicExpMax, gum::credal::InferenceEngine< GUM_SCALAR >::_dynamicExpMin, gum::credal::InferenceEngine< GUM_SCALAR >::_expectationMax, gum::credal::InferenceEngine< GUM_SCALAR >::_expectationMin, gum::credal::InferenceEngine< GUM_SCALAR >::_modal, and gum::HashTable< Key, Val, Alloc >::empty().

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

                                                             {
      // no modals, no expectations computed during inference
      if (_expectationMin.empty() || _modal.empty()) return;

      // already called by the algorithm or the user
      if (_dynamicExpMax.size() > 0 && _dynamicExpMin.size() > 0) return;

      // typedef typename std::map< int, GUM_SCALAR > innerMap;
      using innerMap = typename gum::HashTable< int, GUM_SCALAR >;

      // typedef typename std::map< std::string, innerMap > outerMap;
      using outerMap = typename gum::HashTable< std::string, innerMap >;

      // typedef typename std::map< std::string, std::vector< GUM_SCALAR > >
      // mod;

      // si non dynamique, sauver directement _expectationMin et Max (revient au
      // meme
      // mais plus rapide)
      outerMap expectationsMin, expectationsMax;

      for (const auto& elt : _expectationMin) {
        std::string var_name, time_step;

        var_name = _credalNet->current_bn().variable(elt.first).name();
        auto delim = var_name.find_first_of("_");
        time_step = var_name.substr(delim + 1, var_name.size());
        var_name = var_name.substr(0, delim);

        // to be sure (don't store not monitored variables' expectations)
        // although it
        // should be taken care of before this point
        if (!_modal.exists(var_name)) continue;

        expectationsMin.getWithDefault(var_name, innerMap())
           .getWithDefault(atoi(time_step.c_str()), 0) =
           elt.second;   // we iterate with min iterators
        expectationsMax.getWithDefault(var_name, innerMap())
           .getWithDefault(atoi(time_step.c_str()), 0) =
           _expectationMax[elt.first];
      }

      for (const auto& elt : expectationsMin) {
        typename std::vector< GUM_SCALAR > dynExp(elt.second.size());

        for (const auto& elt2 : elt.second)
          dynExp[elt2.first] = elt2.second;

        _dynamicExpMin.insert(elt.first, dynExp);
      }

      for (const auto& elt : expectationsMax) {
        typename std::vector< GUM_SCALAR > dynExp(elt.second.size());

        for (const auto& elt2 : elt.second) {
          dynExp[elt2.first] = elt2.second;
        }

        _dynamicExpMax.insert(elt.first, dynExp);
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_enum_combi() [1/2]

template<typename GUM_SCALAR >

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

protected

Used by _msgL.

comme precedemment mais pour message parent, vraisemblance prise en compte

Enumerate parent's messages.

Parameters

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

Definition at line 464 of file CNLoopyPropagation_tpl.h.

                                                                     {
      GUM_SCALAR msg_l_min = real_msg_l_min;
      GUM_SCALAR msg_l_max = real_msg_l_max;

      auto taille = msgs_p.size();

      // one parent node, the one receiving the message
      if (taille == 0) {
        GUM_SCALAR num_min = __cn->get_CPT_min()[id][1];
        GUM_SCALAR num_max = __cn->get_CPT_max()[id][1];
        GUM_SCALAR den_min = __cn->get_CPT_min()[id][0];
        GUM_SCALAR den_max = __cn->get_CPT_max()[id][0];

        _compute_ext(msg_l_min, msg_l_max, lx, num_min, num_max, den_min, den_max);

        real_msg_l_min = msg_l_min;
        real_msg_l_max = msg_l_max;
        return;
      }

      decltype(taille) msgPerm = 1;
#pragma omp parallel
      {
        GUM_SCALAR                               msg_lmin = msg_l_min;
        GUM_SCALAR                               msg_lmax = msg_l_max;
        std::vector< std::vector< GUM_SCALAR > > combi_msg_p(taille);

        decltype(taille) confs = 1;
#pragma omp for

        for (int i = 0; i < int(taille); i++) {
          confs *= msgs_p[i].size();
        }

#pragma omp atomic
        msgPerm *= confs;
#pragma omp barrier
#pragma omp flush(msgPerm)

// direct binary representation of config, no need for iterators
#pragma omp for

        for (long j = 0; j < long(msgPerm); j++) {
          // get jth msg :
          auto jvalue = j;

          for (decltype(taille) i = 0; i < taille; i++) {
            if (msgs_p[i].size() == 2) {
              combi_msg_p[i] = (jvalue & 1) ? msgs_p[i][1] : msgs_p[i][0];
              jvalue /= 2;
            } else {
              combi_msg_p[i] = msgs_p[i][0];
            }
          }

          _compute_ext(combi_msg_p, id, msg_lmin, msg_lmax, lx, pos);
        }

// there may be more threads here than in the for loop, therefor positive test
// is NECESSARY (init is -2)
#pragma omp critical(msglminmax)
        {
#pragma omp flush(msg_l_min)
#pragma omp flush(msg_l_max)

          if ((msg_l_min > msg_lmin || msg_l_min == -2) && msg_lmin > 0) {
            msg_l_min = msg_lmin;
          }

          if ((msg_l_max < msg_lmax || msg_l_max == -2) && msg_lmax > 0) {
            msg_l_max = msg_lmax;
          }
        }
      }

      real_msg_l_min = msg_l_min;
      real_msg_l_max = msg_l_max;
    }

_enum_combi() [2/2]

template<typename GUM_SCALAR >

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

protected

Used by _msgP.

enumere combinaisons messages parents, pour message vers enfant

Enumerate parent's messages.

Parameters

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

Definition at line 388 of file CNLoopyPropagation_tpl.h.

                                                                           {
      auto taille = msgs_p.size();

      // source node
      if (taille == 0) {
        msg_p_min = __cn->get_CPT_min()[id][0];
        msg_p_max = __cn->get_CPT_max()[id][0];
        return;
      }

      decltype(taille) msgPerm = 1;
#pragma omp parallel
      {
        GUM_SCALAR msg_pmin = msg_p_min;
        GUM_SCALAR msg_pmax = msg_p_max;

        std::vector< std::vector< GUM_SCALAR > > combi_msg_p(taille);

        decltype(taille) confs = 1;

#pragma omp for

        for (long i = 0; i < long(taille); i++) {
          confs *= msgs_p[i].size();
        }

#pragma omp atomic
        msgPerm *= confs;
#pragma omp barrier
#pragma omp \
   flush   // ( msgPerm ) let the compiler choose what to flush (due to mvsc)

#pragma omp for

        for (int j = 0; j < int(msgPerm); j++) {
          // get jth msg :
          auto jvalue = j;

          for (decltype(taille) i = 0; i < taille; i++) {
            if (msgs_p[i].size() == 2) {
              combi_msg_p[i] = (jvalue & 1) ? msgs_p[i][1] : msgs_p[i][0];
              jvalue /= 2;
            } else {
              combi_msg_p[i] = msgs_p[i][0];
            }
          }

          _compute_ext(combi_msg_p, id, msg_pmin, msg_pmax);
        }

// since min is _INF and max is 0 at init, there is no issue having more threads
// here
// than during for loop
#pragma omp critical(msgpminmax)
        {
#pragma omp flush   //( msg_p_min )
          //#pragma omp flush ( msg_p_max )  let the compiler choose what to
          // flush (due to mvsc)

          if (msg_p_min > msg_pmin) { msg_p_min = msg_pmin; }

          if (msg_p_max < msg_pmax) { msg_p_max = msg_pmax; }
        }
      }
      return;
    }

_initExpectations()

template<typename GUM_SCALAR >

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

protectedinherited

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

Definition at line 695 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_credalNet, gum::credal::InferenceEngine< GUM_SCALAR >::_expectationMax, gum::credal::InferenceEngine< GUM_SCALAR >::_expectationMin, gum::credal::InferenceEngine< GUM_SCALAR >::_modal, gum::HashTable< Key, Val, Alloc >::clear(), and gum::HashTable< Key, Val, Alloc >::insert().

Referenced by gum::credal::InferenceEngine< GUM_SCALAR >::eraseAllEvidence(), gum::credal::InferenceEngine< GUM_SCALAR >::insertModals(), and gum::credal::InferenceEngine< GUM_SCALAR >::insertModalsFile().

                                                          {
      _expectationMin.clear();
      _expectationMax.clear();

      if (_modal.empty()) return;

      for (auto node : _credalNet->current_bn().nodes()) {
        std::string var_name, time_step;

        var_name = _credalNet->current_bn().variable(node).name();
        auto delim = var_name.find_first_of("_");
        var_name = var_name.substr(0, delim);

        if (!_modal.exists(var_name)) continue;

        _expectationMin.insert(node, _modal[var_name].back());
        _expectationMax.insert(node, _modal[var_name].front());
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_initialize()

template<typename GUM_SCALAR >

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

protected

Topological forward propagation to initialize old marginals & messages.

Definition at line 605 of file CNLoopyPropagation_tpl.h.

References _INF, gum::ArcGraphPart::children(), GUM_ERROR, gum::Set< Key, Alloc >::insert(), gum::ArcGraphPart::parents(), and gum::Set< Key, Alloc >::size().

                                                       {
      const DAG& graphe = __bnet->dag();

      // use const iterators with cbegin when available
      for (auto node : __bnet->topologicalOrder()) {
        _update_p.set(node, false);
        _update_l.set(node, false);
        NodeSet* _parents = new NodeSet();
        _msg_l_sent.set(node, _parents);

        // accelerer init pour evidences
        if (__infE::_evidence.exists(node)) {
          if (__infE::_evidence[node][1] != 0.
              && __infE::_evidence[node][1] != 1.) {
            GUM_ERROR(OperationNotAllowed,
                      "CNLoopyPropagation can only handle HARD evidences");
          }

          active_nodes_set.insert(node);
          _update_l.set(node, true);
          _update_p.set(node, true);

          if (__infE::_evidence[node][1] == (GUM_SCALAR)1.) {
            _NodesL_min.set(node, _INF);
            _NodesP_min.set(node, (GUM_SCALAR)1.);
          } else if (__infE::_evidence[node][1] == (GUM_SCALAR)0.) {
            _NodesL_min.set(node, (GUM_SCALAR)0.);
            _NodesP_min.set(node, (GUM_SCALAR)0.);
          }

          std::vector< GUM_SCALAR > marg(2);
          marg[1] = _NodesP_min[node];
          marg[0] = 1 - marg[1];

          __infE::_oldMarginalMin.set(node, marg);
          __infE::_oldMarginalMax.set(node, marg);

          continue;
        }

        NodeSet _par = graphe.parents(node);
        NodeSet _enf = graphe.children(node);

        if (_par.size() == 0) {
          active_nodes_set.insert(node);
          _update_p.set(node, true);
          _update_l.set(node, true);
        }

        if (_enf.size() == 0) {
          active_nodes_set.insert(node);
          _update_p.set(node, true);
          _update_l.set(node, true);
        }

        const auto parents = &__bnet->cpt(node).variablesSequence();

        std::vector< std::vector< std::vector< GUM_SCALAR > > > msgs_p;
        std::vector< std::vector< GUM_SCALAR > >                msg_p;
        std::vector< GUM_SCALAR >                               distri(2);

        // +1 from start to avoid _counting itself
        // use const iterators when available with cbegin
        for (auto jt = ++parents->begin(), theEnd = parents->end(); jt != theEnd;
             ++jt) {
          // compute probability distribution to avoid doing it multiple times
          // (at
          // each combination of messages)
          distri[1] = _NodesP_min[__bnet->nodeId(**jt)];
          distri[0] = (GUM_SCALAR)1. - distri[1];
          msg_p.push_back(distri);

          if (_NodesP_max.exists(__bnet->nodeId(**jt))) {
            distri[1] = _NodesP_max[__bnet->nodeId(**jt)];
            distri[0] = (GUM_SCALAR)1. - distri[1];
            msg_p.push_back(distri);
          }

          msgs_p.push_back(msg_p);
          msg_p.clear();
        }

        GUM_SCALAR msg_p_min = 1.;
        GUM_SCALAR msg_p_max = 0.;

        if (__cn->currentNodeType(node)
            != CredalNet< GUM_SCALAR >::NodeType::Indic) {
          _enum_combi(msgs_p, node, msg_p_min, msg_p_max);
        }

        if (msg_p_min <= (GUM_SCALAR)0.) { msg_p_min = (GUM_SCALAR)0.; }

        if (msg_p_max <= (GUM_SCALAR)0.) { msg_p_max = (GUM_SCALAR)0.; }

        _NodesP_min.set(node, msg_p_min);
        std::vector< GUM_SCALAR > marg(2);
        marg[1] = msg_p_min;
        marg[0] = 1 - msg_p_min;

        __infE::_oldMarginalMin.set(node, marg);

        if (msg_p_min != msg_p_max) {
          marg[1] = msg_p_max;
          marg[0] = 1 - msg_p_max;
          _NodesP_max.insert(node, msg_p_max);
        }

        __infE::_oldMarginalMax.set(node, marg);

        _NodesL_min.set(node, (GUM_SCALAR)1.);
      }

      for (auto arc : __bnet->arcs()) {
        _ArcsP_min.set(arc, _NodesP_min[arc.tail()]);

        if (_NodesP_max.exists(arc.tail())) {
          _ArcsP_max.set(arc, _NodesP_max[arc.tail()]);
        }

        _ArcsL_min.set(arc, _NodesL_min[arc.tail()]);
      }
    }

Here is the call graph for this function:

_initMarginals()

template<typename GUM_SCALAR >

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

protectedinherited

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

Definition at line 663 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_credalNet, gum::credal::InferenceEngine< GUM_SCALAR >::_marginalMax, gum::credal::InferenceEngine< GUM_SCALAR >::_marginalMin, gum::credal::InferenceEngine< GUM_SCALAR >::_oldMarginalMax, gum::credal::InferenceEngine< GUM_SCALAR >::_oldMarginalMin, gum::HashTable< Key, Val, Alloc >::clear(), and gum::HashTable< Key, Val, Alloc >::insert().

Referenced by gum::credal::InferenceEngine< GUM_SCALAR >::eraseAllEvidence(), and gum::credal::InferenceEngine< GUM_SCALAR >::InferenceEngine().

                                                       {
      _marginalMin.clear();
      _marginalMax.clear();
      _oldMarginalMin.clear();
      _oldMarginalMax.clear();

      for (auto node : _credalNet->current_bn().nodes()) {
        auto dSize = _credalNet->current_bn().variable(node).domainSize();
        _marginalMin.insert(node, std::vector< GUM_SCALAR >(dSize, 1));
        _oldMarginalMin.insert(node, std::vector< GUM_SCALAR >(dSize, 1));

        _marginalMax.insert(node, std::vector< GUM_SCALAR >(dSize, 0));
        _oldMarginalMax.insert(node, std::vector< GUM_SCALAR >(dSize, 0));
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_initMarginalSets()

template<typename GUM_SCALAR >

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

protectedinherited

Initialize credal set vertices with empty sets.

Definition at line 680 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_credalNet, gum::credal::InferenceEngine< GUM_SCALAR >::_marginalSets, gum::credal::InferenceEngine< GUM_SCALAR >::_storeVertices, gum::HashTable< Key, Val, Alloc >::clear(), and gum::HashTable< Key, Val, Alloc >::insert().

Referenced by gum::credal::InferenceEngine< GUM_SCALAR >::eraseAllEvidence(), and gum::credal::InferenceEngine< GUM_SCALAR >::storeVertices().

                                                          {
      _marginalSets.clear();

      if (!_storeVertices) return;

      for (auto node : _credalNet->current_bn().nodes())
        _marginalSets.insert(node, std::vector< std::vector< GUM_SCALAR > >());
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_makeInferenceByOrderedArcs()

template<typename GUM_SCALAR >

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

protected

Starts the inference with this inference type.

Definition at line 824 of file CNLoopyPropagation_tpl.h.

References gum::credal::CredalNet< GUM_SCALAR >::currentNodeType().

                                                                       {
      Size nbrArcs = __bnet->dag().sizeArcs();

      std::vector< cArcP > seq;
      seq.reserve(nbrArcs);

      for (const auto& arc : __bnet->arcs()) {
        seq.push_back(&arc);
      }

      GUM_SCALAR eps;
      // validate TestSuite
      __infE::continueApproximationScheme(1.);

      do {
        for (const auto it : seq) {
          if (__cn->currentNodeType(it->tail())
                 == CredalNet< GUM_SCALAR >::NodeType::Indic
              || __cn->currentNodeType(it->head())
                    == CredalNet< GUM_SCALAR >::NodeType::Indic) {
            continue;
          }

          _msgP(it->tail(), it->head());
          _msgL(it->head(), it->tail());
        }

        eps = _calculateEpsilon();

        __infE::updateApproximationScheme();

      } while (__infE::continueApproximationScheme(eps));
    }

Here is the call graph for this function:

_makeInferenceByRandomOrder()

template<typename GUM_SCALAR >

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

protected

Starts the inference with this inference type.

Definition at line 778 of file CNLoopyPropagation_tpl.h.

References gum::credal::CredalNet< GUM_SCALAR >::currentNodeType(), and gum::credal::lp::swap().

                                                                       {
      Size nbrArcs = __bnet->dag().sizeArcs();

      std::vector< cArcP > seq;
      seq.reserve(nbrArcs);

      for (const auto& arc : __bnet->arcs()) {
        seq.push_back(&arc);
      }

      GUM_SCALAR eps;
      // validate TestSuite
      __infE::continueApproximationScheme(1.);

      do {
        for (Size j = 0, theEnd = nbrArcs / 2; j < theEnd; j++) {
          auto w1 = rand() % nbrArcs, w2 = rand() % nbrArcs;

          if (w1 == w2) { continue; }

          std::swap(seq[w1], seq[w2]);
        }

        for (const auto it : seq) {
          if (__cn->currentNodeType(it->tail())
                 == CredalNet< GUM_SCALAR >::NodeType::Indic
              || __cn->currentNodeType(it->head())
                    == CredalNet< GUM_SCALAR >::NodeType::Indic) {
            continue;
          }

          _msgP(it->tail(), it->head());
          _msgL(it->head(), it->tail());
        }

        eps = _calculateEpsilon();

        __infE::updateApproximationScheme();

      } while (__infE::continueApproximationScheme(eps));
    }

Here is the call graph for this function:

_makeInferenceNodeToNeighbours()

template<typename GUM_SCALAR >

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

protected

Starts the inference with this inference type.

Definition at line 733 of file CNLoopyPropagation_tpl.h.

References gum::ArcGraphPart::children(), and gum::ArcGraphPart::parents().

                                                                          {
      const DAG& graphe = __bnet->dag();

      GUM_SCALAR eps;
      // to validate TestSuite
      __infE::continueApproximationScheme(1.);

      do {
        for (auto node : active_nodes_set) {
          for (auto chil : graphe.children(node)) {
            if (__cn->currentNodeType(chil)
                == CredalNet< GUM_SCALAR >::NodeType::Indic) {
              continue;
            }

            _msgP(node, chil);
          }

          for (auto par : graphe.parents(node)) {
            if (__cn->currentNodeType(node)
                == CredalNet< GUM_SCALAR >::NodeType::Indic) {
              continue;
            }

            _msgL(node, par);
          }
        }

        eps = _calculateEpsilon();

        __infE::updateApproximationScheme();

        active_nodes_set.clear();
        active_nodes_set = next_active_nodes_set;
        next_active_nodes_set.clear();

      } while (__infE::continueApproximationScheme(eps)
               && active_nodes_set.size() > 0);

      __infE::stopApproximationScheme();   // just to be sure of the
      // approximationScheme has been notified of
      // the end of looop
    }

Here is the call graph for this function:

_msgL()

template<typename GUM_SCALAR >

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

protected

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

X is sending a message to a demanding_parent.

Parameters

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

Definition at line 859 of file CNLoopyPropagation_tpl.h.

References gum::Set< Key, Alloc >::empty(), gum::Set< Key, Alloc >::insert(), and gum::Set< Key, Alloc >::size().

                                                                               {
      NodeSet const& children = __bnet->children(Y);
      NodeSet const& _parents = __bnet->parents(Y);

      const auto parents = &__bnet->cpt(Y).variablesSequence();

      if (((children.size() + parents->size() - 1) == 1)
          && (!__infE::_evidence.exists(Y))) {
        return;
      }

      bool update_l = _update_l[Y];
      bool update_p = _update_p[Y];

      if (!update_p && !update_l) { return; }

      _msg_l_sent[Y]->insert(X);

      // for future refresh LM/PI
      if (_msg_l_sent[Y]->size() == _parents.size()) {
        _msg_l_sent[Y]->clear();
        _update_l[Y] = false;
      }

      // refresh LM_part
      if (update_l) {
        if (!children.empty() && !__infE::_evidence.exists(Y)) {
          GUM_SCALAR lmin = 1.;
          GUM_SCALAR lmax = 1.;

          for (auto chil : children) {
            lmin *= _ArcsL_min[Arc(Y, chil)];

            if (_ArcsL_max.exists(Arc(Y, chil))) {
              lmax *= _ArcsL_max[Arc(Y, chil)];
            } else {
              lmax *= _ArcsL_min[Arc(Y, chil)];
            }
          }

          lmin = lmax;

          if (lmax != lmax && lmin == lmin) { lmax = lmin; }

          if (lmax != lmax && lmin != lmin) {
            std::cout << "no likelihood defined [lmin, lmax] (incompatibles "
                         "evidence ?)"
                      << std::endl;
          }

          if (lmin < 0.) { lmin = 0.; }

          if (lmax < 0.) { lmax = 0.; }

          // no need to update nodeL if evidence since nodeL will never be used

          _NodesL_min[Y] = lmin;

          if (lmin != lmax) {
            _NodesL_max.set(Y, lmax);
          } else if (_NodesL_max.exists(Y)) {
            _NodesL_max.erase(Y);
          }

        }   // end of : node has children & no evidence

      }   // end of : if update_l

      GUM_SCALAR lmin = _NodesL_min[Y];
      GUM_SCALAR lmax;

      if (_NodesL_max.exists(Y)) {
        lmax = _NodesL_max[Y];
      } else {
        lmax = lmin;
      }

      if (lmin == lmax && lmin == 1.) {
        _ArcsL_min[Arc(X, Y)] = lmin;

        if (_ArcsL_max.exists(Arc(X, Y))) { _ArcsL_max.erase(Arc(X, Y)); }

        return;
      }

      // garder pour chaque noeud un table des parents maj, une fois tous maj,
      // stop
      // jusque notification msg L ou P

      if (update_p || update_l) {
        std::vector< std::vector< std::vector< GUM_SCALAR > > > msgs_p;
        std::vector< std::vector< GUM_SCALAR > >                msg_p;
        std::vector< GUM_SCALAR >                               distri(2);

        Idx pos;

        // +1 from start to avoid _counting itself
        // use const iterators with cbegin when available
        for (auto jt = ++parents->begin(), theEnd = parents->end(); jt != theEnd;
             ++jt) {
          if (__bnet->nodeId(**jt) == X) {
            // retirer la variable courante de la taille
            pos = parents->pos(*jt) - 1;
            continue;
          }

          // compute probability distribution to avoid doing it multiple times
          // (at
          // each combination of messages)
          distri[1] = _ArcsP_min[Arc(__bnet->nodeId(**jt), Y)];
          distri[0] = GUM_SCALAR(1.) - distri[1];
          msg_p.push_back(distri);

          if (_ArcsP_max.exists(Arc(__bnet->nodeId(**jt), Y))) {
            distri[1] = _ArcsP_max[Arc(__bnet->nodeId(**jt), Y)];
            distri[0] = GUM_SCALAR(1.) - distri[1];
            msg_p.push_back(distri);
          }

          msgs_p.push_back(msg_p);
          msg_p.clear();
        }

        GUM_SCALAR min = -2.;
        GUM_SCALAR max = -2.;

        std::vector< GUM_SCALAR > lx;
        lx.push_back(lmin);

        if (lmin != lmax) { lx.push_back(lmax); }

        _enum_combi(msgs_p, Y, min, max, lx, pos);

        if (min == -2. || max == -2.) {
          if (min != -2.) {
            max = min;
          } else if (max != -2.) {
            min = max;
          } else {
            std::cout << std::endl;
            std::cout << "!!!! pas de message L calculable !!!!" << std::endl;
            return;
          }
        }

        if (min < 0.) { min = 0.; }

        if (max < 0.) { max = 0.; }

        bool update = false;

        if (min != _ArcsL_min[Arc(X, Y)]) {
          _ArcsL_min[Arc(X, Y)] = min;
          update = true;
        }

        if (_ArcsL_max.exists(Arc(X, Y))) {
          if (max != _ArcsL_max[Arc(X, Y)]) {
            if (max != min) {
              _ArcsL_max[Arc(X, Y)] = max;
            } else {   // if ( max == min )
              _ArcsL_max.erase(Arc(X, Y));
            }

            update = true;
          }
        } else {
          if (max != min) {
            _ArcsL_max.insert(Arc(X, Y), max);
            update = true;
          }
        }

        if (update) {
          _update_l.set(X, true);
          next_active_nodes_set.insert(X);
        }

      }   // end of update_p || update_l
    }

Here is the call graph for this function:

_msgP()

template<typename GUM_SCALAR >

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

protected

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

X is sending a message to a demanding_child.

Parameters

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

Definition at line 1045 of file CNLoopyPropagation_tpl.h.

References _INF, gum::Set< Key, Alloc >::erase(), and gum::Set< Key, Alloc >::size().

                                                                               {
      NodeSet const& children = __bnet->children(X);

      const auto parents = &__bnet->cpt(X).variablesSequence();

      if (((children.size() + parents->size() - 1) == 1)
          && (!__infE::_evidence.exists(X))) {
        return;
      }

      // LM_part ---- from all children but one --- the lonely one will get the
      // message

      if (__infE::_evidence.exists(X)) {
        _ArcsP_min[Arc(X, demanding_child)] = __infE::_evidence[X][1];

        if (_ArcsP_max.exists(Arc(X, demanding_child))) {
          _ArcsP_max.erase(Arc(X, demanding_child));
        }

        return;
      }

      bool update_l = _update_l[X];
      bool update_p = _update_p[X];

      if (!update_p && !update_l) { return; }

      GUM_SCALAR lmin = 1.;
      GUM_SCALAR lmax = 1.;

      // use cbegin if available
      for (auto chil : children) {
        if (chil == demanding_child) { continue; }

        lmin *= _ArcsL_min[Arc(X, chil)];

        if (_ArcsL_max.exists(Arc(X, chil))) {
          lmax *= _ArcsL_max[Arc(X, chil)];
        } else {
          lmax *= _ArcsL_min[Arc(X, chil)];
        }
      }

      if (lmin != lmin && lmax == lmax) { lmin = lmax; }

      if (lmax != lmax && lmin == lmin) { lmax = lmin; }

      if (lmax != lmax && lmin != lmin) {
        std::cout << "pas de vraisemblance definie [lmin, lmax] (observations "
                     "incompatibles ?)"
                  << std::endl;
        return;
      }

      if (lmin < 0.) { lmin = 0.; }

      if (lmax < 0.) { lmax = 0.; }

      // refresh PI_part
      GUM_SCALAR min = _INF;
      GUM_SCALAR max = 0.;

      if (update_p) {
        std::vector< std::vector< std::vector< GUM_SCALAR > > > msgs_p;
        std::vector< std::vector< GUM_SCALAR > >                msg_p;
        std::vector< GUM_SCALAR >                               distri(2);

        // +1 from start to avoid _counting itself
        // use const_iterators if available
        for (auto jt = ++parents->begin(), theEnd = parents->end(); jt != theEnd;
             ++jt) {
          // compute probability distribution to avoid doing it multiple times
          // (at
          // each combination of messages)
          distri[1] = _ArcsP_min[Arc(__bnet->nodeId(**jt), X)];
          distri[0] = GUM_SCALAR(1.) - distri[1];
          msg_p.push_back(distri);

          if (_ArcsP_max.exists(Arc(__bnet->nodeId(**jt), X))) {
            distri[1] = _ArcsP_max[Arc(__bnet->nodeId(**jt), X)];
            distri[0] = GUM_SCALAR(1.) - distri[1];
            msg_p.push_back(distri);
          }

          msgs_p.push_back(msg_p);
          msg_p.clear();
        }

        _enum_combi(msgs_p, X, min, max);

        if (min < 0.) { min = 0.; }

        if (max < 0.) { max = 0.; }

        if (min == _INF || max == _INF) {
          std::cout << " ERREUR msg P min = max = INF " << std::endl;
          std::cout.flush();
          return;
        }

        _NodesP_min[X] = min;

        if (min != max) {
          _NodesP_max.set(X, max);
        } else if (_NodesP_max.exists(X)) {
          _NodesP_max.erase(X);
        }

        _update_p.set(X, false);

      }   // end of update_p
      else {
        min = _NodesP_min[X];

        if (_NodesP_max.exists(X)) {
          max = _NodesP_max[X];
        } else {
          max = min;
        }
      }

      if (update_p || update_l) {
        GUM_SCALAR msg_p_min;
        GUM_SCALAR msg_p_max;

        // cas limites sur min
        if (min == _INF && lmin == 0.) {
          std::cout << "MESSAGE P ERR (negatif) : pi = inf, l = 0" << std::endl;
        }

        if (lmin == _INF) {   // cas infini
          msg_p_min = GUM_SCALAR(1.);
        } else if (min == 0. || lmin == 0.) {
          msg_p_min = 0;
        } else {
          msg_p_min = GUM_SCALAR(1. / (1. + ((1. / min - 1.) * 1. / lmin)));
        }

        // cas limites sur max
        if (max == _INF && lmax == 0.) {
          std::cout << "MESSAGE P ERR (negatif) : pi = inf, l = 0" << std::endl;
        }

        if (lmax == _INF) {   // cas infini
          msg_p_max = GUM_SCALAR(1.);
        } else if (max == 0. || lmax == 0.) {
          msg_p_max = 0;
        } else {
          msg_p_max = GUM_SCALAR(1. / (1. + ((1. / max - 1.) * 1. / lmax)));
        }

        if (msg_p_min != msg_p_min && msg_p_max == msg_p_max) {
          msg_p_min = msg_p_max;
          std::cout << std::endl;
          std::cout << "msg_p_min is NaN" << std::endl;
        }

        if (msg_p_max != msg_p_max && msg_p_min == msg_p_min) {
          msg_p_max = msg_p_min;
          std::cout << std::endl;
          std::cout << "msg_p_max is NaN" << std::endl;
        }

        if (msg_p_max != msg_p_max && msg_p_min != msg_p_min) {
          std::cout << std::endl;
          std::cout << "pas de message P calculable (verifier observations)"
                    << std::endl;
          return;
        }

        if (msg_p_min < 0.) { msg_p_min = 0.; }

        if (msg_p_max < 0.) { msg_p_max = 0.; }

        bool update = false;

        if (msg_p_min != _ArcsP_min[Arc(X, demanding_child)]) {
          _ArcsP_min[Arc(X, demanding_child)] = msg_p_min;
          update = true;
        }

        if (_ArcsP_max.exists(Arc(X, demanding_child))) {
          if (msg_p_max != _ArcsP_max[Arc(X, demanding_child)]) {
            if (msg_p_max != msg_p_min) {
              _ArcsP_max[Arc(X, demanding_child)] = msg_p_max;
            } else {   // if ( msg_p_max == msg_p_min )
              _ArcsP_max.erase(Arc(X, demanding_child));
            }

            update = true;
          }
        } else {
          if (msg_p_max != msg_p_min) {
            _ArcsP_max.insert(Arc(X, demanding_child), msg_p_max);
            update = true;
          }
        }

        if (update) {
          _update_p.set(demanding_child, true);
          next_active_nodes_set.insert(demanding_child);
        }

      }   // end of : update_l || update_p
    }

Here is the call graph for this function:

_refreshLMsPIs()

template<typename GUM_SCALAR >

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

protected

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

Definition at line 1254 of file CNLoopyPropagation_tpl.h.

References _INF, gum::Set< Key, Alloc >::empty(), and gum::Set< Key, Alloc >::erase().

                                                                           {
      for (auto node : __bnet->nodes()) {
        if ((!refreshIndic)
            && __cn->currentNodeType(node)
                  == CredalNet< GUM_SCALAR >::NodeType::Indic) {
          continue;
        }

        NodeSet const& children = __bnet->children(node);

        auto parents = &__bnet->cpt(node).variablesSequence();

        if (_update_l[node]) {
          GUM_SCALAR lmin = 1.;
          GUM_SCALAR lmax = 1.;

          if (!children.empty() && !__infE::_evidence.exists(node)) {
            for (auto chil : children) {
              lmin *= _ArcsL_min[Arc(node, chil)];

              if (_ArcsL_max.exists(Arc(node, chil))) {
                lmax *= _ArcsL_max[Arc(node, chil)];
              } else {
                lmax *= _ArcsL_min[Arc(node, chil)];
              }
            }

            if (lmin != lmin && lmax == lmax) { lmin = lmax; }

            lmax = lmin;

            if (lmax != lmax && lmin != lmin) {
              std::cout
                 << "pas de vraisemblance definie [lmin, lmax] (observations "
                    "incompatibles ?)"
                 << std::endl;
              return;
            }

            if (lmin < 0.) { lmin = 0.; }

            if (lmax < 0.) { lmax = 0.; }

            _NodesL_min[node] = lmin;

            if (lmin != lmax) {
              _NodesL_max.set(node, lmax);
            } else if (_NodesL_max.exists(node)) {
              _NodesL_max.erase(node);
            }
          }

        }   // end of : update_l

        if (_update_p[node]) {
          if ((parents->size() - 1) > 0 && !__infE::_evidence.exists(node)) {
            std::vector< std::vector< std::vector< GUM_SCALAR > > > msgs_p;
            std::vector< std::vector< GUM_SCALAR > >                msg_p;
            std::vector< GUM_SCALAR >                               distri(2);

            // +1 from start to avoid _counting itself
            // cbegin
            for (auto jt = ++parents->begin(), theEnd = parents->end();
                 jt != theEnd;
                 ++jt) {
              // compute probability distribution to avoid doing it multiple
              // times
              // (at each combination of messages)
              distri[1] = _ArcsP_min[Arc(__bnet->nodeId(**jt), node)];
              distri[0] = GUM_SCALAR(1.) - distri[1];
              msg_p.push_back(distri);

              if (_ArcsP_max.exists(Arc(__bnet->nodeId(**jt), node))) {
                distri[1] = _ArcsP_max[Arc(__bnet->nodeId(**jt), node)];
                distri[0] = GUM_SCALAR(1.) - distri[1];
                msg_p.push_back(distri);
              }

              msgs_p.push_back(msg_p);
              msg_p.clear();
            }

            GUM_SCALAR min = _INF;
            GUM_SCALAR max = 0.;

            _enum_combi(msgs_p, node, min, max);

            if (min < 0.) { min = 0.; }

            if (max < 0.) { max = 0.; }

            _NodesP_min[node] = min;

            if (min != max) {
              _NodesP_max.set(node, max);
            } else if (_NodesP_max.exists(node)) {
              _NodesP_max.erase(node);
            }

            _update_p[node] = false;
          }
        }   // end of update_p

      }   // end of : for each node
    }

Here is the call graph for this function:

_repetitiveInit()

template<typename GUM_SCALAR >

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

protectedinherited

Initialize _t0 and _t1 clusters.

Definition at line 784 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_credalNet, gum::credal::InferenceEngine< GUM_SCALAR >::_t0, gum::credal::InferenceEngine< GUM_SCALAR >::_t1, gum::credal::InferenceEngine< GUM_SCALAR >::_timeSteps, gum::HashTable< Key, Val, Alloc >::clear(), GUM_ERROR, and gum::HashTable< Key, Val, Alloc >::insert().

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

                                                        {
      _timeSteps = 0;
      _t0.clear();
      _t1.clear();

      // t = 0 vars belongs to _t0 as keys
      for (auto node : _credalNet->current_bn().dag().nodes()) {
        std::string var_name = _credalNet->current_bn().variable(node).name();
        auto        delim = var_name.find_first_of("_");

        if (delim > var_name.size()) {
          GUM_ERROR(InvalidArgument,
                    "void InferenceEngine< GUM_SCALAR "
                    ">::_repetitiveInit() : the network does not "
                    "appear to be dynamic");
        }

        std::string time_step = var_name.substr(delim + 1, 1);

        if (time_step.compare("0") == 0) _t0.insert(node, std::vector< NodeId >());
      }

      // t = 1 vars belongs to either _t0 as member value or _t1 as keys
      for (const auto& node : _credalNet->current_bn().dag().nodes()) {
        std::string var_name = _credalNet->current_bn().variable(node).name();
        auto        delim = var_name.find_first_of("_");
        std::string time_step = var_name.substr(delim + 1, var_name.size());
        var_name = var_name.substr(0, delim);
        delim = time_step.find_first_of("_");
        time_step = time_step.substr(0, delim);

        if (time_step.compare("1") == 0) {
          bool found = false;

          for (const auto& elt : _t0) {
            std::string var_0_name =
               _credalNet->current_bn().variable(elt.first).name();
            delim = var_0_name.find_first_of("_");
            var_0_name = var_0_name.substr(0, delim);

            if (var_name.compare(var_0_name) == 0) {
              const Potential< GUM_SCALAR >* potential(
                 &_credalNet->current_bn().cpt(node));
              const Potential< GUM_SCALAR >* potential2(
                 &_credalNet->current_bn().cpt(elt.first));

              if (potential->domainSize() == potential2->domainSize())
                _t0[elt.first].push_back(node);
              else
                _t1.insert(node, std::vector< NodeId >());

              found = true;
              break;
            }
          }

          if (!found) { _t1.insert(node, std::vector< NodeId >()); }
        }
      }

      // t > 1 vars belongs to either _t0 or _t1 as member value
      // remember _timeSteps
      for (auto node : _credalNet->current_bn().dag().nodes()) {
        std::string var_name = _credalNet->current_bn().variable(node).name();
        auto        delim = var_name.find_first_of("_");
        std::string time_step = var_name.substr(delim + 1, var_name.size());
        var_name = var_name.substr(0, delim);
        delim = time_step.find_first_of("_");
        time_step = time_step.substr(0, delim);

        if (time_step.compare("0") != 0 && time_step.compare("1") != 0) {
          // keep max time_step
          if (atoi(time_step.c_str()) > _timeSteps)
            _timeSteps = atoi(time_step.c_str());

          std::string var_0_name;
          bool        found = false;

          for (const auto& elt : _t0) {
            std::string var_0_name =
               _credalNet->current_bn().variable(elt.first).name();
            delim = var_0_name.find_first_of("_");
            var_0_name = var_0_name.substr(0, delim);

            if (var_name.compare(var_0_name) == 0) {
              const Potential< GUM_SCALAR >* potential(
                 &_credalNet->current_bn().cpt(node));
              const Potential< GUM_SCALAR >* potential2(
                 &_credalNet->current_bn().cpt(elt.first));

              if (potential->domainSize() == potential2->domainSize()) {
                _t0[elt.first].push_back(node);
                found = true;
                break;
              }
            }
          }

          if (!found) {
            for (const auto& elt : _t1) {
              std::string var_0_name =
                 _credalNet->current_bn().variable(elt.first).name();
              auto delim = var_0_name.find_first_of("_");
              var_0_name = var_0_name.substr(0, delim);

              if (var_name.compare(var_0_name) == 0) {
                const Potential< GUM_SCALAR >* potential(
                   &_credalNet->current_bn().cpt(node));
                const Potential< GUM_SCALAR >* potential2(
                   &_credalNet->current_bn().cpt(elt.first));

                if (potential->domainSize() == potential2->domainSize()) {
                  _t1[elt.first].push_back(node);
                  break;
                }
              }
            }
          }
        }
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_updateCredalSets()

template<typename GUM_SCALAR >

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

inlineprotectedinherited

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

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

Parameters

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

Definition at line 928 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_marginalMax, gum::credal::InferenceEngine< GUM_SCALAR >::_marginalMin, gum::credal::InferenceEngine< GUM_SCALAR >::_marginalSets, gum::HashTable< Key, Val, Alloc >::cbegin(), gum::HashTable< Key, Val, Alloc >::cend(), gum::credal::LRSWrapper< GUM_SCALAR >::elimRedundVrep(), gum::credal::LRSWrapper< GUM_SCALAR >::fillV(), gum::credal::LRSWrapper< GUM_SCALAR >::getOutput(), and gum::credal::LRSWrapper< GUM_SCALAR >::setUpV().

Referenced by gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_verticesFusion().

                                                    {
      auto& nodeCredalSet = _marginalSets[id];
      auto  dsize = vertex.size();

      bool eq = true;

      for (auto it = nodeCredalSet.cbegin(), itEnd = nodeCredalSet.cend();
           it != itEnd;
           ++it) {
        eq = true;

        for (Size i = 0; i < dsize; i++) {
          if (std::fabs(vertex[i] - (*it)[i]) > 1e-6) {
            eq = false;
            break;
          }
        }

        if (eq) break;
      }

      if (!eq || nodeCredalSet.size() == 0) {
        nodeCredalSet.push_back(vertex);
        return;
      } else
        return;

      // because of next lambda return condition
      if (nodeCredalSet.size() == 1) return;

      // check that the point and all previously added ones are not inside the
      // actual
      // polytope
      auto itEnd = std::remove_if(
         nodeCredalSet.begin(),
         nodeCredalSet.end(),
         [&](const std::vector< GUM_SCALAR >& v) -> bool {
           for (auto jt = v.cbegin(),
                     jtEnd = v.cend(),
                     minIt = _marginalMin[id].cbegin(),
                     minItEnd = _marginalMin[id].cend(),
                     maxIt = _marginalMax[id].cbegin(),
                     maxItEnd = _marginalMax[id].cend();
                jt != jtEnd && minIt != minItEnd && maxIt != maxItEnd;
                ++jt, ++minIt, ++maxIt) {
             if ((std::fabs(*jt - *minIt) < 1e-6 || std::fabs(*jt - *maxIt) < 1e-6)
                 && std::fabs(*minIt - *maxIt) > 1e-6)
               return false;
           }
           return true;
         });

      nodeCredalSet.erase(itEnd, nodeCredalSet.end());

      // we need at least 2 points to make a convex combination
      if (!elimRedund || nodeCredalSet.size() <= 2) return;

      // there may be points not inside the polytope but on one of it's facet,
      // meaning it's still a convex combination of vertices of this facet. Here
      // we
      // need lrs.
      LRSWrapper< GUM_SCALAR > lrsWrapper;
      lrsWrapper.setUpV((unsigned int)dsize, (unsigned int)(nodeCredalSet.size()));

      for (const auto& vtx : nodeCredalSet)
        lrsWrapper.fillV(vtx);

      lrsWrapper.elimRedundVrep();

      _marginalSets[id] = lrsWrapper.getOutput();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

_updateExpectations()

template<typename GUM_SCALAR >

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

inlineprotectedinherited

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

Parameters

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

Definition at line 907 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_credalNet, gum::credal::InferenceEngine< GUM_SCALAR >::_expectationMax, gum::credal::InferenceEngine< GUM_SCALAR >::_expectationMin, and gum::credal::InferenceEngine< GUM_SCALAR >::_modal.

                                                                {
      std::string var_name = _credalNet->current_bn().variable(id).name();
      auto        delim = var_name.find_first_of("_");

      var_name = var_name.substr(0, delim);

      if (_modal.exists(var_name) /*_modal.find(var_name) != _modal.end()*/) {
        GUM_SCALAR exp = 0;
        auto       vsize = vertex.size();

        for (Size mod = 0; mod < vsize; mod++)
          exp += vertex[mod] * _modal[var_name][mod];

        if (exp > _expectationMax[id]) _expectationMax[id] = exp;

        if (exp < _expectationMin[id]) _expectationMin[id] = exp;
      }
    }

_updateIndicatrices()

template<typename GUM_SCALAR >

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

protected

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

Definition at line 1465 of file CNLoopyPropagation_tpl.h.

                                                               {
      for (auto node : __bnet->nodes()) {
        if (__cn->currentNodeType(node)
            != CredalNet< GUM_SCALAR >::NodeType::Indic) {
          continue;
        }

        for (auto pare : __bnet->parents(node)) {
          _msgP(pare, node);
        }
      }

      _refreshLMsPIs(true);
      _updateMarginals();
    }

_updateMarginals()

template<typename GUM_SCALAR >

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

protected

Compute marginals from up-to-date messages.

Definition at line 1361 of file CNLoopyPropagation_tpl.h.

References _INF.

                                                            {
      for (auto node : __bnet->nodes()) {
        GUM_SCALAR msg_p_min = 1.;
        GUM_SCALAR msg_p_max = 0.;

        if (__infE::_evidence.exists(node)) {
          if (__infE::_evidence[node][1] == 0.) {
            msg_p_min = (GUM_SCALAR)0.;
          } else if (__infE::_evidence[node][1] == 1.) {
            msg_p_min = 1.;
          }

          msg_p_max = msg_p_min;
        } else {
          GUM_SCALAR min = _NodesP_min[node];
          GUM_SCALAR max;

          if (_NodesP_max.exists(node)) {
            max = _NodesP_max[node];
          } else {
            max = min;
          }

          GUM_SCALAR lmin = _NodesL_min[node];
          GUM_SCALAR lmax;

          if (_NodesL_max.exists(node)) {
            lmax = _NodesL_max[node];
          } else {
            lmax = lmin;
          }

          if (min == _INF || max == _INF) {
            std::cout << " min ou max === _INF !!!!!!!!!!!!!!!!!!!!!!!!!! "
                      << std::endl;
            return;
          }

          if (min == _INF && lmin == 0.) {
            std::cout << "proba ERR (negatif) : pi = inf, l = 0" << std::endl;
            return;
          }

          if (lmin == _INF) {
            msg_p_min = GUM_SCALAR(1.);
          } else if (min == 0. || lmin == 0.) {
            msg_p_min = GUM_SCALAR(0.);
          } else {
            msg_p_min = GUM_SCALAR(1. / (1. + ((1. / min - 1.) * 1. / lmin)));
          }

          if (max == _INF && lmax == 0.) {
            std::cout << "proba ERR (negatif) : pi = inf, l = 0" << std::endl;
            return;
          }

          if (lmax == _INF) {
            msg_p_max = GUM_SCALAR(1.);
          } else if (max == 0. || lmax == 0.) {
            msg_p_max = GUM_SCALAR(0.);
          } else {
            msg_p_max = GUM_SCALAR(1. / (1. + ((1. / max - 1.) * 1. / lmax)));
          }
        }

        if (msg_p_min != msg_p_min && msg_p_max == msg_p_max) {
          msg_p_min = msg_p_max;
          std::cout << std::endl;
          std::cout << "msg_p_min is NaN" << std::endl;
        }

        if (msg_p_max != msg_p_max && msg_p_min == msg_p_min) {
          msg_p_max = msg_p_min;
          std::cout << std::endl;
          std::cout << "msg_p_max is NaN" << std::endl;
        }

        if (msg_p_max != msg_p_max && msg_p_min != msg_p_min) {
          std::cout << std::endl;
          std::cout << "Please check the observations (no proba can be computed)"
                    << std::endl;
          return;
        }

        if (msg_p_min < 0.) { msg_p_min = 0.; }

        if (msg_p_max < 0.) { msg_p_max = 0.; }

        __infE::_marginalMin[node][0] = 1 - msg_p_max;
        __infE::_marginalMax[node][0] = 1 - msg_p_min;
        __infE::_marginalMin[node][1] = msg_p_min;
        __infE::_marginalMax[node][1] = msg_p_max;
      }
    }

continueApproximationScheme()

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

inherited

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

Test the stopping criterion that are enabled.

Parameters

error

The new error value.

Returns

false if state become != ApproximationSchemeSTATE::Continue

Exceptions

OperationNotAllowed

Raised if state != ApproximationSchemeSTATE::Continue.

Definition at line 227 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_current_epsilon, gum::ApproximationScheme::_current_rate, gum::ApproximationScheme::_current_state, gum::ApproximationScheme::_current_step, gum::ApproximationScheme::_enabled_eps, gum::ApproximationScheme::_enabled_max_iter, gum::ApproximationScheme::_enabled_max_time, gum::ApproximationScheme::_enabled_min_rate_eps, gum::ApproximationScheme::_eps, gum::ApproximationScheme::_history, gum::ApproximationScheme::_last_epsilon, gum::ApproximationScheme::_max_iter, gum::ApproximationScheme::_max_time, gum::ApproximationScheme::_min_rate_eps, gum::ApproximationScheme::_stopScheme(), gum::ApproximationScheme::_timer, gum::IApproximationSchemeConfiguration::Continue, gum::IApproximationSchemeConfiguration::Epsilon, GUM_EMIT3, GUM_ERROR, gum::IApproximationSchemeConfiguration::Limit, gum::IApproximationSchemeConfiguration::messageApproximationScheme(), gum::IApproximationSchemeConfiguration::onProgress, gum::IApproximationSchemeConfiguration::Rate, gum::ApproximationScheme::startOfPeriod(), gum::ApproximationScheme::stateApproximationScheme(), gum::Timer::step(), gum::IApproximationSchemeConfiguration::TimeLimit, and gum::ApproximationScheme::verbosity().

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::_computeKL(), gum::SamplingInference< GUM_SCALAR >::_loopApproxInference(), gum::learning::DAG2BNLearner< ALLOC >::createBN(), gum::learning::GreedyHillClimbing::learnStructure(), gum::learning::LocalSearchWithTabuList::learnStructure(), and gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::makeInference().

                                                                           {
    // For coherence, we fix the time used in the method

    double timer_step = _timer.step();

    if (_enabled_max_time) {
      if (timer_step > _max_time) {
        _stopScheme(ApproximationSchemeSTATE::TimeLimit);
        return false;
      }
    }

    if (!startOfPeriod()) { return true; }

    if (_current_state != ApproximationSchemeSTATE::Continue) {
      GUM_ERROR(OperationNotAllowed,
                "state of the approximation scheme is not correct : "
                   + messageApproximationScheme());
    }

    if (verbosity()) { _history.push_back(error); }

    if (_enabled_max_iter) {
      if (_current_step > _max_iter) {
        _stopScheme(ApproximationSchemeSTATE::Limit);
        return false;
      }
    }

    _last_epsilon = _current_epsilon;
    _current_epsilon = error;   // eps rate isEnabled needs it so affectation was
    // moved from eps isEnabled below

    if (_enabled_eps) {
      if (_current_epsilon <= _eps) {
        _stopScheme(ApproximationSchemeSTATE::Epsilon);
        return false;
      }
    }

    if (_last_epsilon >= 0.) {
      if (_current_epsilon > .0) {
        // ! _current_epsilon can be 0. AND epsilon
        // isEnabled can be disabled !
        _current_rate =
           std::fabs((_current_epsilon - _last_epsilon) / _current_epsilon);
      }
      // limit with current eps ---> 0 is | 1 - ( last_eps / 0 ) | --->
      // infinity the else means a return false if we isEnabled the rate below,
      // as we would have returned false if epsilon isEnabled was enabled
      else {
        _current_rate = _min_rate_eps;
      }

      if (_enabled_min_rate_eps) {
        if (_current_rate <= _min_rate_eps) {
          _stopScheme(ApproximationSchemeSTATE::Rate);
          return false;
        }
      }
    }

    if (stateApproximationScheme() == ApproximationSchemeSTATE::Continue) {
      if (onProgress.hasListener()) {
        GUM_EMIT3(onProgress, _current_step, _current_epsilon, timer_step);
      }

      return true;
    } else {
      return false;
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

credalNet()

template<typename GUM_SCALAR >

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

inherited

Get this creadal network.

Returns

A constant reference to this CredalNet.

Definition at line 59 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_credalNet.

Referenced by gum::credal::InferenceEngine< GUM_SCALAR >::InferenceEngine().

                                                                            {
      return *_credalNet;
    }

Here is the caller graph for this function:

currentTime()

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

virtualinherited

Returns the current running time in second.

Returns

Returns the current running time in second.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 128 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_timer, and gum::Timer::step().

Referenced by gum::learning::genericBNLearner::currentTime().

{ return _timer.step(); }

Here is the call graph for this function:

Here is the caller graph for this function:

disableEpsilon()

INLINE void gum::ApproximationScheme::disableEpsilon ( )

virtualinherited

Disable stopping criterion on epsilon.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 54 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_enabled_eps.

Referenced by gum::learning::genericBNLearner::disableEpsilon().

{ _enabled_eps = false; }

Here is the caller graph for this function:

disableMaxIter()

INLINE void gum::ApproximationScheme::disableMaxIter ( )

virtualinherited

Disable stopping criterion on max iterations.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 105 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_enabled_max_iter.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::__mcInitApproximationScheme(), gum::learning::genericBNLearner::disableMaxIter(), and gum::learning::GreedyHillClimbing::GreedyHillClimbing().

{ _enabled_max_iter = false; }

Here is the caller graph for this function:

disableMaxTime()

INLINE void gum::ApproximationScheme::disableMaxTime ( )

virtualinherited

Disable stopping criterion on timeout.

Returns

Disable stopping criterion on timeout.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 131 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_enabled_max_time.

Referenced by gum::learning::genericBNLearner::disableMaxTime(), and gum::learning::GreedyHillClimbing::GreedyHillClimbing().

{ _enabled_max_time = false; }

Here is the caller graph for this function:

disableMinEpsilonRate()

INLINE void gum::ApproximationScheme::disableMinEpsilonRate ( )

virtualinherited

Disable stopping criterion on epsilon rate.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 79 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_enabled_min_rate_eps.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::__mcInitApproximationScheme(), gum::GibbsBNdistance< GUM_SCALAR >::_computeKL(), gum::learning::genericBNLearner::disableMinEpsilonRate(), and gum::learning::GreedyHillClimbing::GreedyHillClimbing().

                                                         {
    _enabled_min_rate_eps = false;
  }

Here is the caller graph for this function:

dynamicExpectations()

template<typename GUM_SCALAR >

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

inherited

Compute dynamic expectations.

See also

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

Definition at line 716 of file inferenceEngine_tpl.h.

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

                                                            {
      _dynamicExpectations();
    }

Here is the call graph for this function:

dynamicExpMax()

template<typename GUM_SCALAR >

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

inherited

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

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

Parameters

varName

The variable name prefix which upper expectation we want.

Returns

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

Definition at line 504 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_dynamicExpMax, and GUM_ERROR.

                                       {
      std::string errTxt = "const std::vector< GUM_SCALAR > & InferenceEngine< "
                           "GUM_SCALAR >::dynamicExpMax ( const std::string & "
                           "varName ) const : ";

      if (_dynamicExpMax.empty())
        GUM_ERROR(OperationNotAllowed,
                  errTxt + "_dynamicExpectations() needs to be called before");

      if (!_dynamicExpMax.exists(
             varName) /*_dynamicExpMin.find(varName) == _dynamicExpMin.end()*/)
        GUM_ERROR(NotFound, errTxt + "variable name not found : " << varName);

      return _dynamicExpMax[varName];
    }

dynamicExpMin()

template<typename GUM_SCALAR >

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

inherited

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

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

Parameters

varName

The variable name prefix which lower expectation we want.

Returns

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

Definition at line 486 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_dynamicExpMin, and GUM_ERROR.

                                       {
      std::string errTxt = "const std::vector< GUM_SCALAR > & InferenceEngine< "
                           "GUM_SCALAR >::dynamicExpMin ( const std::string & "
                           "varName ) const : ";

      if (_dynamicExpMin.empty())
        GUM_ERROR(OperationNotAllowed,
                  errTxt + "_dynamicExpectations() needs to be called before");

      if (!_dynamicExpMin.exists(
             varName) /*_dynamicExpMin.find(varName) == _dynamicExpMin.end()*/)
        GUM_ERROR(NotFound, errTxt + "variable name not found : " << varName);

      return _dynamicExpMin[varName];
    }

enableEpsilon()

INLINE void gum::ApproximationScheme::enableEpsilon ( )

virtualinherited

Enable stopping criterion on epsilon.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 57 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_enabled_eps.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::__mcInitApproximationScheme(), and gum::learning::genericBNLearner::enableEpsilon().

{ _enabled_eps = true; }

Here is the caller graph for this function:

enableMaxIter()

INLINE void gum::ApproximationScheme::enableMaxIter ( )

virtualinherited

Enable stopping criterion on max iterations.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 108 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_enabled_max_iter.

Referenced by gum::learning::genericBNLearner::enableMaxIter().

{ _enabled_max_iter = true; }

Here is the caller graph for this function:

enableMaxTime()

INLINE void gum::ApproximationScheme::enableMaxTime ( )

virtualinherited

Enable stopping criterion on timeout.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 134 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_enabled_max_time.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::CNMonteCarloSampling(), and gum::learning::genericBNLearner::enableMaxTime().

{ _enabled_max_time = true; }

Here is the caller graph for this function:

enableMinEpsilonRate()

INLINE void gum::ApproximationScheme::enableMinEpsilonRate ( )

virtualinherited

Enable stopping criterion on epsilon rate.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 84 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_enabled_min_rate_eps.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::_computeKL(), and gum::learning::genericBNLearner::enableMinEpsilonRate().

                                                        {
    _enabled_min_rate_eps = true;
  }

Here is the caller graph for this function:

epsilon()

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

virtualinherited

Returns the value of epsilon.

Returns

Returns the value of epsilon.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 51 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_eps.

Referenced by gum::ImportanceSampling< GUM_SCALAR >::_onContextualize(), and gum::learning::genericBNLearner::epsilon().

{ return _eps; }

Here is the caller graph for this function:

eraseAllEvidence()

template<typename GUM_SCALAR >

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

virtual

Erase all inference related data to perform another one.

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

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

Definition at line 576 of file CNLoopyPropagation_tpl.h.

                                                            {
      __infE::eraseAllEvidence();

      _ArcsL_min.clear();
      _ArcsL_max.clear();
      _ArcsP_min.clear();
      _ArcsP_max.clear();
      _NodesL_min.clear();
      _NodesL_max.clear();
      _NodesP_min.clear();
      _NodesP_max.clear();

      _InferenceUpToDate = false;

      if (_msg_l_sent.size() > 0) {
        for (auto node : __bnet->nodes()) {
          delete _msg_l_sent[node];
        }
      }

      _msg_l_sent.clear();
      _update_l.clear();
      _update_p.clear();

      active_nodes_set.clear();
      next_active_nodes_set.clear();
    }

expectationMax() [1/2]

template<typename GUM_SCALAR >

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

inherited

Get the upper expectation of a given node id.

Parameters

id	The node id which upper expectation we want.

Returns

A constant reference to this node upper expectation.

Definition at line 479 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_expectationMax.

                                                                          {
      try {
        return _expectationMax[id];
      } catch (NotFound& err) { throw(err); }
    }

expectationMax() [2/2]

template<typename GUM_SCALAR >

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

inherited

Get the upper expectation of a given variable name.

Parameters

varName

The variable name which upper expectation we want.

Returns

A constant reference to this variable upper expectation.

Definition at line 462 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_credalNet, and gum::credal::InferenceEngine< GUM_SCALAR >::_expectationMax.

                                       {
      try {
        return _expectationMax[_credalNet->current_bn().idFromName(varName)];
      } catch (NotFound& err) { throw(err); }
    }

expectationMin() [1/2]

template<typename GUM_SCALAR >

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

inherited

Get the lower expectation of a given node id.

Parameters

id	The node id which lower expectation we want.

Returns

A constant reference to this node lower expectation.

Definition at line 471 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_expectationMin.

                                                                          {
      try {
        return _expectationMin[id];
      } catch (NotFound& err) { throw(err); }
    }

expectationMin() [2/2]

template<typename GUM_SCALAR >

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

inherited

Get the lower expectation of a given variable name.

Parameters

varName

The variable name which lower expectation we want.

Returns

A constant reference to this variable lower expectation.

Definition at line 454 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_credalNet, and gum::credal::InferenceEngine< GUM_SCALAR >::_expectationMin.

                                       {
      try {
        return _expectationMin[_credalNet->current_bn().idFromName(varName)];
      } catch (NotFound& err) { throw(err); }
    }

getApproximationSchemeMsg()

template<typename GUM_SCALAR >

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

inlineinherited

Get approximation scheme state.

Returns

A constant string about approximation scheme state.

Definition at line 515 of file inferenceEngine.h.

References gum::IApproximationSchemeConfiguration::messageApproximationScheme().

                                                  {
        return this->messageApproximationScheme();
      }

Here is the call graph for this function:

getT0Cluster()

template<typename GUM_SCALAR >

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

inherited

Get the _t0 cluster.

Returns

A constant reference to the _t0 cluster.

Definition at line 1005 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_t0.

                                                         {
      return _t0;
    }

getT1Cluster()

template<typename GUM_SCALAR >

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

inherited

Get the _t1 cluster.

Returns

A constant reference to the _t1 cluster.

Definition at line 1011 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_t1.

                                                         {
      return _t1;
    }

getVarMod2BNsMap()

template<typename GUM_SCALAR >

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

inherited

Get optimum IBayesNet.

Returns

A pointer to the optimal net object.

Definition at line 141 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_dbnOpt.

                                                       {
      return &_dbnOpt;
    }

history()

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

virtualinherited

Returns the scheme history.

Returns

Returns the scheme history.

Exceptions

OperationNotAllowed

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

Implements gum::IApproximationSchemeConfiguration.

Definition at line 173 of file approximationScheme_inl.h.

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

Referenced by gum::learning::genericBNLearner::history().

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

    if (verbosity() == false) {
      GUM_ERROR(OperationNotAllowed, "No history when verbosity=false");
    }

    return _history;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

inferenceType() [1/2]

template<typename GUM_SCALAR >

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

(

InferenceType

inft

)

Set the inference type.

Parameters

inft	The choosen InferenceType.

Definition at line 1560 of file CNLoopyPropagation_tpl.h.

References gum::credal::CNLoopyPropagation< GUM_SCALAR >::__inferenceType.

                                                                           {
      __inferenceType = inft;
    }

inferenceType() [2/2]

template<typename GUM_SCALAR >

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

(

)

Get the inference type.

Returns

The inference type.

Definition at line 1566 of file CNLoopyPropagation_tpl.h.

References gum::credal::CNLoopyPropagation< GUM_SCALAR >::__inferenceType.

                                                       {
      return __inferenceType;
    }

initApproximationScheme()

INLINE void gum::ApproximationScheme::initApproximationScheme ( )

inherited

Initialise the scheme.

Definition at line 187 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_current_epsilon, gum::ApproximationScheme::_current_rate, gum::ApproximationScheme::_current_state, gum::ApproximationScheme::_current_step, gum::ApproximationScheme::_history, gum::ApproximationScheme::_timer, gum::IApproximationSchemeConfiguration::Continue, and gum::Timer::reset().

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::__mcInitApproximationScheme(), gum::GibbsBNdistance< GUM_SCALAR >::_computeKL(), gum::SamplingInference< GUM_SCALAR >::_loopApproxInference(), gum::SamplingInference< GUM_SCALAR >::_onStateChanged(), gum::learning::DAG2BNLearner< ALLOC >::createBN(), gum::learning::GreedyHillClimbing::learnStructure(), and gum::learning::LocalSearchWithTabuList::learnStructure().

                                                           {
    _current_state = ApproximationSchemeSTATE::Continue;
    _current_step = 0;
    _current_epsilon = _current_rate = -1.0;
    _history.clear();
    _timer.reset();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

insertEvidence() [1/2]

template<typename GUM_SCALAR >

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

inherited

Insert evidence from map.

Parameters

eviMap

The map variable name - likelihood.

Definition at line 229 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_credalNet, gum::credal::InferenceEngine< GUM_SCALAR >::_evidence, gum::HashTable< Key, Val, Alloc >::clear(), gum::HashTable< Key, Val, Alloc >::empty(), GUM_SHOWERROR, and gum::HashTable< Key, Val, Alloc >::insert().

                                                                   {
      if (!_evidence.empty()) _evidence.clear();

      for (auto it = eviMap.cbegin(), theEnd = eviMap.cend(); it != theEnd; ++it) {
        NodeId id;

        try {
          id = _credalNet->current_bn().idFromName(it->first);
        } catch (NotFound& err) {
          GUM_SHOWERROR(err);
          continue;
        }

        _evidence.insert(id, it->second);
      }
    }

Here is the call graph for this function:

insertEvidence() [2/2]

template<typename GUM_SCALAR >

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

inherited

Insert evidence from Property.

Parameters

evidence

The on nodes Property containing likelihoods.

Definition at line 251 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_credalNet, gum::credal::InferenceEngine< GUM_SCALAR >::_evidence, gum::HashTable< Key, Val, Alloc >::clear(), gum::HashTable< Key, Val, Alloc >::empty(), GUM_SHOWERROR, and gum::HashTable< Key, Val, Alloc >::insert().

                                                                {
      if (!_evidence.empty()) _evidence.clear();

      // use cbegin() to get const_iterator when available in aGrUM hashtables
      for (const auto& elt : evidence) {
        try {
          _credalNet->current_bn().variable(elt.first);
        } catch (NotFound& err) {
          GUM_SHOWERROR(err);
          continue;
        }

        _evidence.insert(elt.first, elt.second);
      }
    }

Here is the call graph for this function:

insertEvidenceFile()

template<typename GUM_SCALAR >

virtual void gum::credal::CNLoopyPropagation< GUM_SCALAR >::insertEvidenceFile ( const std::string &  path )

inlinevirtual

Insert evidence from file.

Parameters

path	The path to the evidence file.

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

Definition at line 382 of file CNLoopyPropagation.h.

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

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

Here is the call graph for this function:

insertModals()

template<typename GUM_SCALAR >

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

inherited

Insert variables modalities from map to compute expectations.

Parameters

modals

The map variable name - modalities.

Definition at line 193 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_credalNet, gum::credal::InferenceEngine< GUM_SCALAR >::_initExpectations(), gum::credal::InferenceEngine< GUM_SCALAR >::_modal, and GUM_SHOWERROR.

                                                                   {
      if (!_modal.empty()) _modal.clear();

      for (auto it = modals.cbegin(), theEnd = modals.cend(); it != theEnd; ++it) {
        NodeId id;

        try {
          id = _credalNet->current_bn().idFromName(it->first);
        } catch (NotFound& err) {
          GUM_SHOWERROR(err);
          continue;
        }

        // check that modals are net compatible
        auto dSize = _credalNet->current_bn().variable(id).domainSize();

        if (dSize != it->second.size()) continue;

        // GUM_ERROR(OperationNotAllowed, "void InferenceEngine< GUM_SCALAR
        // >::insertModals( const std::map< std::string, std::vector< GUM_SCALAR
        // > >
        // &modals) : modalities does not respect variable cardinality : " <<
        // _credalNet->current_bn().variable( id ).name() << " : " << dSize << "
        // != "
        // << it->second.size());

        _modal.insert(it->first, it->second);   //[ it->first ] = it->second;
      }

      //_modal = modals;

      _initExpectations();
    }

Here is the call graph for this function:

insertModalsFile()

template<typename GUM_SCALAR >

void gum::credal::InferenceEngine< GUM_SCALAR >::insertModalsFile ( const std::string &  path )

inherited

Insert variables modalities from file to compute expectations.

Parameters

path	The path to the modalities file.

Definition at line 146 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_initExpectations(), gum::credal::InferenceEngine< GUM_SCALAR >::_modal, and GUM_ERROR.

                                                                              {
      std::ifstream mod_stream(path.c_str(), std::ios::in);

      if (!mod_stream.good()) {
        GUM_ERROR(OperationNotAllowed,
                  "void InferenceEngine< GUM_SCALAR "
                  ">::insertModals(const std::string & path) : "
                  "could not open input file : "
                     << path);
      }

      if (!_modal.empty()) _modal.clear();

      std::string line, tmp;
      char *      cstr, *p;

      while (mod_stream.good()) {
        getline(mod_stream, line);

        if (line.size() == 0) continue;

        cstr = new char[line.size() + 1];
        strcpy(cstr, line.c_str());

        p = strtok(cstr, " ");
        tmp = p;

        std::vector< GUM_SCALAR > values;
        p = strtok(nullptr, " ");

        while (p != nullptr) {
          values.push_back(GUM_SCALAR(atof(p)));
          p = strtok(nullptr, " ");
        }   // end of : line

        _modal.insert(tmp, values);   //[tmp] = values;

        delete[] p;
        delete[] cstr;
      }   // end of : file

      mod_stream.close();

      _initExpectations();
    }

Here is the call graph for this function:

insertQuery()

template<typename GUM_SCALAR >

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

inherited

Insert query variables and states from Property.

Parameters

query

The on nodes Property containing queried variables states.

Definition at line 331 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_credalNet, gum::credal::InferenceEngine< GUM_SCALAR >::_query, gum::HashTable< Key, Val, Alloc >::clear(), gum::HashTable< Key, Val, Alloc >::empty(), GUM_SHOWERROR, and gum::HashTable< Key, Val, Alloc >::insert().

                                                       {
      if (!_query.empty()) _query.clear();

      for (const auto& elt : query) {
        try {
          _credalNet->current_bn().variable(elt.first);
        } catch (NotFound& err) {
          GUM_SHOWERROR(err);
          continue;
        }

        _query.insert(elt.first, elt.second);
      }
    }

Here is the call graph for this function:

insertQueryFile()

template<typename GUM_SCALAR >

void gum::credal::InferenceEngine< GUM_SCALAR >::insertQueryFile ( const std::string &  path )

inherited

Insert query variables states from file.

Parameters

path	The path to the query file.

Definition at line 348 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_credalNet, gum::credal::InferenceEngine< GUM_SCALAR >::_query, gum::HashTable< Key, Val, Alloc >::clear(), gum::HashTable< Key, Val, Alloc >::empty(), GUM_ERROR, GUM_SHOWERROR, and gum::HashTable< Key, Val, Alloc >::insert().

                                                                             {
      std::ifstream evi_stream(path.c_str(), std::ios::in);

      if (!evi_stream.good()) {
        GUM_ERROR(IOError,
                  "void InferenceEngine< GUM_SCALAR >::insertQuery(const "
                  "std::string & path) : could not open input file : "
                     << path);
      }

      if (!_query.empty()) _query.clear();

      std::string line, tmp;
      char *      cstr, *p;

      while (evi_stream.good() && std::strcmp(line.c_str(), "[QUERY]") != 0) {
        getline(evi_stream, line);
      }

      while (evi_stream.good()) {
        getline(evi_stream, line);

        if (std::strcmp(line.c_str(), "[EVIDENCE]") == 0) break;

        if (line.size() == 0) continue;

        cstr = new char[line.size() + 1];
        strcpy(cstr, line.c_str());

        p = strtok(cstr, " ");
        tmp = p;

        // if user input is wrong
        NodeId node = -1;

        try {
          node = _credalNet->current_bn().idFromName(tmp);
        } catch (NotFound& err) {
          GUM_SHOWERROR(err);
          continue;
        }

        auto dSize = _credalNet->current_bn().variable(node).domainSize();

        p = strtok(nullptr, " ");

        if (p == nullptr) {
          _query.insert(node, std::vector< bool >(dSize, true));
        } else {
          std::vector< bool > values(dSize, false);

          while (p != nullptr) {
            if ((Size)atoi(p) >= dSize)
              GUM_ERROR(OutOfBounds,
                        "void InferenceEngine< GUM_SCALAR "
                        ">::insertQuery(const std::string & path) : "
                        "query modality is higher or equal to "
                        "cardinality");

            values[atoi(p)] = true;
            p = strtok(nullptr, " ");
          }   // end of : line

          _query.insert(node, values);
        }

        delete[] p;
        delete[] cstr;
      }   // end of : file

      evi_stream.close();
    }

Here is the call graph for this function:

isEnabledEpsilon()

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

virtualinherited

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

Returns

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

Implements gum::IApproximationSchemeConfiguration.

Definition at line 61 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_enabled_eps.

Referenced by gum::learning::genericBNLearner::isEnabledEpsilon().

                                                          {
    return _enabled_eps;
  }

Here is the caller graph for this function:

isEnabledMaxIter()

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

virtualinherited

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

Returns

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

Implements gum::IApproximationSchemeConfiguration.

Definition at line 112 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_enabled_max_iter.

Referenced by gum::learning::genericBNLearner::isEnabledMaxIter().

                                                          {
    return _enabled_max_iter;
  }

Here is the caller graph for this function:

isEnabledMaxTime()

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

virtualinherited

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

Returns

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

Implements gum::IApproximationSchemeConfiguration.

Definition at line 138 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_enabled_max_time.

Referenced by gum::learning::genericBNLearner::isEnabledMaxTime().

                                                          {
    return _enabled_max_time;
  }

Here is the caller graph for this function:

isEnabledMinEpsilonRate()

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

virtualinherited

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

Returns

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

Implements gum::IApproximationSchemeConfiguration.

Definition at line 90 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_enabled_min_rate_eps.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::_computeKL(), and gum::learning::genericBNLearner::isEnabledMinEpsilonRate().

                                                                 {
    return _enabled_min_rate_eps;
  }

Here is the caller graph for this function:

makeInference()

template<typename GUM_SCALAR >

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

virtual

Starts the inference.

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

Definition at line 550 of file CNLoopyPropagation_tpl.h.

                                                         {
      if (_InferenceUpToDate) { return; }

      _initialize();

      __infE::initApproximationScheme();

      switch (__inferenceType) {
        case InferenceType::nodeToNeighbours:
          _makeInferenceNodeToNeighbours();
          break;

        case InferenceType::ordered: _makeInferenceByOrderedArcs(); break;

        case InferenceType::randomOrder: _makeInferenceByRandomOrder(); break;
      }

      //_updateMarginals();
      _updateIndicatrices();   // will call _updateMarginals()

      _computeExpectations();

      _InferenceUpToDate = true;
    }

marginalMax() [1/2]

template<typename GUM_SCALAR >

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

inherited

Get the upper marginals of a given node id.

Parameters

id	The node id which upper marginals we want.

Returns

A constant reference to this node upper marginals.

Definition at line 447 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_marginalMax.

                                                                       {
      try {
        return _marginalMax[id];
      } catch (NotFound& err) { throw(err); }
    }

marginalMax() [2/2]

template<typename GUM_SCALAR >

const std::vector< GUM_SCALAR > & gum::credal::InferenceEngine< GUM_SCALAR >::marginalMax ( const std::string &  varName ) const

inherited

Get the upper marginals of a given variable name.

Parameters

varName

The variable name which upper marginals we want.

Returns

A constant reference to this variable upper marginals.

Definition at line 430 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_credalNet, and gum::credal::InferenceEngine< GUM_SCALAR >::_marginalMax.

                                       {
      try {
        return _marginalMax[_credalNet->current_bn().idFromName(varName)];
      } catch (NotFound& err) { throw(err); }
    }

marginalMin() [1/2]

template<typename GUM_SCALAR >

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

inherited

Get the lower marginals of a given node id.

Parameters

id	The node id which lower marginals we want.

Returns

A constant reference to this node lower marginals.

Definition at line 439 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_marginalMin.

                                                                       {
      try {
        return _marginalMin[id];
      } catch (NotFound& err) { throw(err); }
    }

marginalMin() [2/2]

template<typename GUM_SCALAR >

const std::vector< GUM_SCALAR > & gum::credal::InferenceEngine< GUM_SCALAR >::marginalMin ( const std::string &  varName ) const

inherited

Get the lower marginals of a given variable name.

Parameters

varName

The variable name which lower marginals we want.

Returns

A constant reference to this variable lower marginals.

Definition at line 422 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_credalNet, and gum::credal::InferenceEngine< GUM_SCALAR >::_marginalMin.

                                       {
      try {
        return _marginalMin[_credalNet->current_bn().idFromName(varName)];
      } catch (NotFound& err) { throw(err); }
    }

maxIter()

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

virtualinherited

Returns the criterion on number of iterations.

Returns

Returns the criterion on number of iterations.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 102 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_max_iter.

Referenced by gum::learning::genericBNLearner::maxIter().

{ return _max_iter; }

Here is the caller graph for this function:

maxTime()

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

virtualinherited

Returns the timeout (in seconds).

Returns

Returns the timeout (in seconds).

Implements gum::IApproximationSchemeConfiguration.

Definition at line 125 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_max_time.

Referenced by gum::learning::genericBNLearner::maxTime().

{ return _max_time; }

Here is the caller graph for this function:

messageApproximationScheme()

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

inherited

Returns the approximation scheme message.

Returns

Returns the approximation scheme message.

Definition at line 40 of file IApproximationSchemeConfiguration_inl.h.

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

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

                                                                         {
    std::stringstream s;

    switch (stateApproximationScheme()) {
      case ApproximationSchemeSTATE::Continue: s << "in progress"; break;

      case ApproximationSchemeSTATE::Epsilon:
        s << "stopped with epsilon=" << epsilon();
        break;

      case ApproximationSchemeSTATE::Rate:
        s << "stopped with rate=" << minEpsilonRate();
        break;

      case ApproximationSchemeSTATE::Limit:
        s << "stopped with max iteration=" << maxIter();
        break;

      case ApproximationSchemeSTATE::TimeLimit:
        s << "stopped with timeout=" << maxTime();
        break;

      case ApproximationSchemeSTATE::Stopped: s << "stopped on request"; break;

      case ApproximationSchemeSTATE::Undefined: s << "undefined state"; break;
    };

    return s.str();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

minEpsilonRate()

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

virtualinherited

Returns the value of the minimal epsilon rate.

Returns

Returns the value of the minimal epsilon rate.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 74 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_min_rate_eps.

Referenced by gum::learning::genericBNLearner::minEpsilonRate().

                                                          {
    return _min_rate_eps;
  }

Here is the caller graph for this function:

nbrIterations()

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

virtualinherited

Returns the number of iterations.

Returns

Returns the number of iterations.

Exceptions

OperationNotAllowed

Raised if the scheme did not perform.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 163 of file approximationScheme_inl.h.

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

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::_computeKL(), and gum::learning::genericBNLearner::nbrIterations().

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

    return _current_step;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

periodSize()

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

virtualinherited

Returns the period size.

Returns

Returns the period size.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 149 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_period_size.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::makeInference(), and gum::learning::genericBNLearner::periodSize().

{ return _period_size; }

Here is the caller graph for this function:

remainingBurnIn()

INLINE Size gum::ApproximationScheme::remainingBurnIn ( )

inherited

Returns the remaining burn in.

Returns

Returns the remaining burn in.

Definition at line 210 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_burn_in, and gum::ApproximationScheme::_current_step.

                                                   {
    if (_burn_in > _current_step) {
      return _burn_in - _current_step;
    } else {
      return 0;
    }
  }

repetitiveInd()

template<typename GUM_SCALAR >

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

inherited

Get the current independence status.

Returns

True if repetitive, False otherwise.

Definition at line 120 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_repetitiveInd.

                                                            {
      return _repetitiveInd;
    }

saveExpectations()

template<typename GUM_SCALAR >

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

inherited

Saves expectations to file.

Parameters

path	The path to the file to be used.

Definition at line 554 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_dynamicExpMax, gum::credal::InferenceEngine< GUM_SCALAR >::_dynamicExpMin, and GUM_ERROR.

                                    {
      if (_dynamicExpMin.empty())   //_modal.empty())
        return;

      // else not here, to keep the const (natural with a saving process)
      // else if(_dynamicExpMin.empty() || _dynamicExpMax.empty())
      //_dynamicExpectations(); // works with or without a dynamic network

      std::ofstream m_stream(path.c_str(), std::ios::out | std::ios::trunc);

      if (!m_stream.good()) {
        GUM_ERROR(IOError,
                  "void InferenceEngine< GUM_SCALAR "
                  ">::saveExpectations(const std::string & path) : could "
                  "not open output file : "
                     << path);
      }

      for (const auto& elt : _dynamicExpMin) {
        m_stream << elt.first;   // it->first;

        // iterates over a vector
        for (const auto& elt2 : elt.second) {
          m_stream << " " << elt2;
        }

        m_stream << std::endl;
      }

      for (const auto& elt : _dynamicExpMax) {
        m_stream << elt.first;

        // iterates over a vector
        for (const auto& elt2 : elt.second) {
          m_stream << " " << elt2;
        }

        m_stream << std::endl;
      }

      m_stream.close();
    }

saveInference()

template<typename GUM_SCALAR >

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

(

const std::string &

path

)

Deprecated:

Use saveMarginals() from InferenceEngine instead.

This one is easier to read but harder for scripts to parse.

Parameters

path	The path to the file to save marginals.

Definition at line 29 of file CNLoopyPropagation_tpl.h.

References _INF, and GUM_ERROR.

                                                                              {
      std::string path_name = path.substr(0, path.size() - 4);
      path_name = path_name + ".res";

      std::ofstream res(path_name.c_str(), std::ios::out | std::ios::trunc);

      if (!res.good()) {
        GUM_ERROR(NotFound,
                  "CNLoopyPropagation<GUM_SCALAR>::saveInference(std::"
                  "string & path) : could not open file : "
                     + path_name);
      }

      std::string ext = path.substr(path.size() - 3, path.size());

      if (std::strcmp(ext.c_str(), "evi") == 0) {
        std::ifstream evi(path.c_str(), std::ios::in);
        std::string   ligne;

        if (!evi.good()) {
          GUM_ERROR(NotFound,
                    "CNLoopyPropagation<GUM_SCALAR>::saveInference(std::"
                    "string & path) : could not open file : "
                       + ext);
        }

        while (evi.good()) {
          getline(evi, ligne);
          res << ligne << "\n";
        }

        evi.close();
      }

      res << "[RESULTATS]"
          << "\n";

      for (auto node : __bnet->nodes()) {
        // calcul distri posteriori
        GUM_SCALAR msg_p_min = 1.0;
        GUM_SCALAR msg_p_max = 0.0;

        // cas evidence, calcul immediat
        if (__infE::_evidence.exists(node)) {
          if (__infE::_evidence[node][1] == 0.) {
            msg_p_min = 0.;
          } else if (__infE::_evidence[node][1] == 1.) {
            msg_p_min = 1.;
          }

          msg_p_max = msg_p_min;
        }
        // sinon depuis node P et node L
        else {
          GUM_SCALAR min = _NodesP_min[node];
          GUM_SCALAR max;

          if (_NodesP_max.exists(node)) {
            max = _NodesP_max[node];
          } else {
            max = min;
          }

          GUM_SCALAR lmin = _NodesL_min[node];
          GUM_SCALAR lmax;

          if (_NodesL_max.exists(node)) {
            lmax = _NodesL_max[node];
          } else {
            lmax = lmin;
          }

          // cas limites sur min
          if (min == _INF && lmin == 0.) {
            std::cout << "proba ERR (negatif) : pi = inf, l = 0" << std::endl;
          }

          if (lmin == _INF) {   // cas infini
            msg_p_min = GUM_SCALAR(1.);
          } else if (min == 0. || lmin == 0.) {
            msg_p_min = GUM_SCALAR(0.);
          } else {
            msg_p_min = GUM_SCALAR(1. / (1. + ((1. / min - 1.) * 1. / lmin)));
          }

          // cas limites sur max
          if (max == _INF && lmax == 0.) {
            std::cout << "proba ERR (negatif) : pi = inf, l = 0" << std::endl;
          }

          if (lmax == _INF) {   // cas infini
            msg_p_max = GUM_SCALAR(1.);
          } else if (max == 0. || lmax == 0.) {
            msg_p_max = GUM_SCALAR(0.);
          } else {
            msg_p_max = GUM_SCALAR(1. / (1. + ((1. / max - 1.) * 1. / lmax)));
          }
        }

        if (msg_p_min != msg_p_min && msg_p_max == msg_p_max) {
          msg_p_min = msg_p_max;
        }

        if (msg_p_max != msg_p_max && msg_p_min == msg_p_min) {
          msg_p_max = msg_p_min;
        }

        if (msg_p_max != msg_p_max && msg_p_min != msg_p_min) {
          std::cout << std::endl;
          std::cout << "pas de proba calculable (verifier observations)"
                    << std::endl;
        }

        res << "P(" << __bnet->variable(node).name() << " | e) = ";

        if (__infE::_evidence.exists(node)) {
          res << "(observe)" << std::endl;
        } else {
          res << std::endl;
        }

        res << "\t\t" << __bnet->variable(node).label(0) << "  [ "
            << (GUM_SCALAR)1. - msg_p_max;

        if (msg_p_min != msg_p_max) {
          res << ", " << (GUM_SCALAR)1. - msg_p_min << " ] | ";
        } else {
          res << " ] | ";
        }

        res << __bnet->variable(node).label(1) << "  [ " << msg_p_min;

        if (msg_p_min != msg_p_max) {
          res << ", " << msg_p_max << " ]" << std::endl;
        } else {
          res << " ]" << std::endl;
        }
      }   // end of : for each node

      res.close();
    }

saveMarginals()

template<typename GUM_SCALAR >

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

inherited

Saves marginals to file.

Parameters

path	The path to the file to be used.

Definition at line 528 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_credalNet, gum::credal::InferenceEngine< GUM_SCALAR >::_marginalMax, gum::credal::InferenceEngine< GUM_SCALAR >::_marginalMin, and GUM_ERROR.

                                    {
      std::ofstream m_stream(path.c_str(), std::ios::out | std::ios::trunc);

      if (!m_stream.good()) {
        GUM_ERROR(IOError,
                  "void InferenceEngine< GUM_SCALAR >::saveMarginals(const "
                  "std::string & path) const : could not open output file "
                  ": "
                     << path);
      }

      for (const auto& elt : _marginalMin) {
        Size esize = Size(elt.second.size());

        for (Size mod = 0; mod < esize; mod++) {
          m_stream << _credalNet->current_bn().variable(elt.first).name() << " "
                   << mod << " " << (elt.second)[mod] << " "
                   << _marginalMax[elt.first][mod] << std::endl;
        }
      }

      m_stream.close();
    }

saveVertices()

template<typename GUM_SCALAR >

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

inherited

Saves vertices to file.

Parameters

path	The path to the file to be used.

Definition at line 628 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_credalNet, gum::credal::InferenceEngine< GUM_SCALAR >::_marginalSets, and GUM_ERROR.

                                                                              {
      std::ofstream m_stream(path.c_str(), std::ios::out | std::ios::trunc);

      if (!m_stream.good()) {
        GUM_ERROR(IOError,
                  "void InferenceEngine< GUM_SCALAR >::saveVertices(const "
                  "std::string & path) : could not open outpul file : "
                     << path);
      }

      for (const auto& elt : _marginalSets) {
        m_stream << _credalNet->current_bn().variable(elt.first).name()
                 << std::endl;

        for (const auto& elt2 : elt.second) {
          m_stream << "[";
          bool first = true;

          for (const auto& elt3 : elt2) {
            if (!first) {
              m_stream << ",";
              first = false;
            }

            m_stream << elt3;
          }

          m_stream << "]\n";
        }
      }

      m_stream.close();
    }

setEpsilon()

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

virtualinherited

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

If the criterion was disabled it will be enabled.

Parameters

eps	The new epsilon value.

Exceptions

OutOfLowerBound

Raised if eps < 0.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 43 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_enabled_eps, gum::ApproximationScheme::_eps, and GUM_ERROR.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::__mcInitApproximationScheme(), gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::GibbsSampling< GUM_SCALAR >::GibbsSampling(), gum::learning::GreedyHillClimbing::GreedyHillClimbing(), gum::SamplingInference< GUM_SCALAR >::SamplingInference(), and gum::learning::genericBNLearner::setEpsilon().

                                                        {
    if (eps < 0.) { GUM_ERROR(OutOfLowerBound, "eps should be >=0"); }

    _eps = eps;
    _enabled_eps = true;
  }

Here is the caller graph for this function:

setMaxIter()

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

virtualinherited

Stopping criterion on number of iterations.

If the criterion was disabled it will be enabled.

Parameters

max	The maximum number of iterations.

Exceptions

OutOfLowerBound

Raised if max <= 1.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 95 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_enabled_max_iter, gum::ApproximationScheme::_max_iter, and GUM_ERROR.

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

                                                      {
    if (max < 1) { GUM_ERROR(OutOfLowerBound, "max should be >=1"); }
    _max_iter = max;
    _enabled_max_iter = true;
  }

Here is the caller graph for this function:

setMaxTime()

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

virtualinherited

Stopping criterion on timeout.

If the criterion was disabled it will be enabled.

Parameters

timeout

The timeout value in seconds.

Exceptions

OutOfLowerBound

Raised if timeout <= 0.0.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 118 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_enabled_max_time, gum::ApproximationScheme::_max_time, and GUM_ERROR.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::CNMonteCarloSampling(), gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::SamplingInference< GUM_SCALAR >::SamplingInference(), and gum::learning::genericBNLearner::setMaxTime().

                                                            {
    if (timeout <= 0.) { GUM_ERROR(OutOfLowerBound, "timeout should be >0."); }
    _max_time = timeout;
    _enabled_max_time = true;
  }

Here is the caller graph for this function:

setMinEpsilonRate()

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

virtualinherited

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

If the criterion was disabled it will be enabled

Parameters

rate	The minimal epsilon rate.

Exceptions

OutOfLowerBound

if rate<0

Implements gum::IApproximationSchemeConfiguration.

Definition at line 66 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_enabled_min_rate_eps, gum::ApproximationScheme::_min_rate_eps, and GUM_ERROR.

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

                                                                {
    if (rate < 0) { GUM_ERROR(OutOfLowerBound, "rate should be >=0"); }

    _min_rate_eps = rate;
    _enabled_min_rate_eps = true;
  }

Here is the caller graph for this function:

setPeriodSize()

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

virtualinherited

How many samples between two stopping is enable.

Parameters

p	The new period value.

Exceptions

OutOfLowerBound

Raised if p < 1.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 143 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_period_size, and GUM_ERROR.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::CNMonteCarloSampling(), gum::GibbsBNdistance< GUM_SCALAR >::GibbsBNdistance(), gum::SamplingInference< GUM_SCALAR >::SamplingInference(), and gum::learning::genericBNLearner::setPeriodSize().

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

    _period_size = p;
  }

Here is the caller graph for this function:

setRepetitiveInd()

template<typename GUM_SCALAR >

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

inherited

Parameters

repetitive

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

Definition at line 111 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_repetitiveInd, and gum::credal::InferenceEngine< GUM_SCALAR >::_repetitiveInit().

                                                                              {
      bool oldValue = _repetitiveInd;
      _repetitiveInd = repetitive;

      // do not compute clusters more than once
      if (_repetitiveInd && !oldValue) _repetitiveInit();
    }

Here is the call graph for this function:

setVerbosity()

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

virtualinherited

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

Parameters

v	If true, then verbosity is turned on.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 152 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_verbosity.

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

{ _verbosity = v; }

Here is the caller graph for this function:

startOfPeriod()

INLINE bool gum::ApproximationScheme::startOfPeriod ( )

inherited

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

Returns

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

Definition at line 197 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_burn_in, gum::ApproximationScheme::_current_step, and gum::ApproximationScheme::_period_size.

Referenced by gum::ApproximationScheme::continueApproximationScheme().

                                                 {
    if (_current_step < _burn_in) { return false; }

    if (_period_size == 1) { return true; }

    return ((_current_step - _burn_in) % _period_size == 0);
  }

Here is the caller graph for this function:

stateApproximationScheme()

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

virtualinherited

Returns the approximation scheme state.

Returns

Returns the approximation scheme state.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 158 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_current_state.

Referenced by gum::ApproximationScheme::continueApproximationScheme(), gum::ApproximationScheme::history(), gum::ApproximationScheme::nbrIterations(), and gum::learning::genericBNLearner::stateApproximationScheme().

                                                             {
    return _current_state;
  }

Here is the caller graph for this function:

stopApproximationScheme()

INLINE void gum::ApproximationScheme::stopApproximationScheme ( )

inherited

Stop the approximation scheme.

Definition at line 219 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_current_state, gum::ApproximationScheme::_stopScheme(), gum::IApproximationSchemeConfiguration::Continue, and gum::IApproximationSchemeConfiguration::Stopped.

Referenced by gum::learning::DAG2BNLearner< ALLOC >::createBN(), gum::learning::GreedyHillClimbing::learnStructure(), and gum::learning::LocalSearchWithTabuList::learnStructure().

                                                           {
    if (_current_state == ApproximationSchemeSTATE::Continue) {
      _stopScheme(ApproximationSchemeSTATE::Stopped);
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

storeBNOpt() [1/2]

template<typename GUM_SCALAR >

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

inherited

Parameters

value

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

Definition at line 99 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_storeBNOpt.

                                                                   {
      _storeBNOpt = value;
    }

storeBNOpt() [2/2]

template<typename GUM_SCALAR >

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

inherited

Returns

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

Definition at line 135 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_storeBNOpt.

                                                         {
      return _storeBNOpt;
    }

storeVertices() [1/2]

template<typename GUM_SCALAR >

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

inherited

Parameters

value

True if vertices are to be stored, false otherwise.

Definition at line 104 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_initMarginalSets(), and gum::credal::InferenceEngine< GUM_SCALAR >::_storeVertices.

                                                                      {
      _storeVertices = value;

      if (value) _initMarginalSets();
    }

Here is the call graph for this function:

storeVertices() [2/2]

template<typename GUM_SCALAR >

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

inherited

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

Returns

the number of iterations.int iterStop () const;

True if vertice are stored, False otherwise.

Definition at line 130 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_storeVertices.

                                                            {
      return _storeVertices;
    }

toString()

template<typename GUM_SCALAR >

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

inherited

Print all nodes marginals to standart output.

Definition at line 599 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_credalNet, gum::credal::InferenceEngine< GUM_SCALAR >::_marginalMax, gum::credal::InferenceEngine< GUM_SCALAR >::_marginalMin, gum::credal::InferenceEngine< GUM_SCALAR >::_query, gum::HashTable< Key, Val, Alloc >::empty(), and gum::HashTable< Key, Val, Alloc >::exists().

                                                            {
      std::stringstream output;
      output << std::endl;

      // use cbegin() when available
      for (const auto& elt : _marginalMin) {
        Size esize = Size(elt.second.size());

        for (Size mod = 0; mod < esize; mod++) {
          output << "P(" << _credalNet->current_bn().variable(elt.first).name()
                 << "=" << mod << "|e) = [ ";
          output << _marginalMin[elt.first][mod] << ", "
                 << _marginalMax[elt.first][mod] << " ]";

          if (!_query.empty())
            if (_query.exists(elt.first) && _query[elt.first][mod])
              output << " QUERY";

          output << std::endl;
        }

        output << std::endl;
      }

      return output.str();
    }

Here is the call graph for this function:

updateApproximationScheme()

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

inherited

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

Parameters

incr	The new increment steps.

Definition at line 206 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_current_step.

Referenced by gum::GibbsBNdistance< GUM_SCALAR >::_computeKL(), gum::SamplingInference< GUM_SCALAR >::_loopApproxInference(), gum::learning::DAG2BNLearner< ALLOC >::createBN(), gum::learning::GreedyHillClimbing::learnStructure(), gum::learning::LocalSearchWithTabuList::learnStructure(), and gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::makeInference().

                                                                              {
    _current_step += incr;
  }

Here is the caller graph for this function:

verbosity()

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

virtualinherited

Returns true if verbosity is enabled.

Returns

Returns true if verbosity is enabled.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 154 of file approximationScheme_inl.h.

References gum::ApproximationScheme::_verbosity.

Referenced by gum::ApproximationScheme::continueApproximationScheme(), gum::ApproximationScheme::history(), and gum::learning::genericBNLearner::verbosity().

{ return _verbosity; }

Here is the caller graph for this function:

vertices()

template<typename GUM_SCALAR >

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

inherited

Get the vertice of a given node id.

Parameters

id	The node id which vertice we want.

Returns

A constant reference to this node vertice.

Definition at line 523 of file inferenceEngine_tpl.h.

References gum::credal::InferenceEngine< GUM_SCALAR >::_marginalSets.

                                                                    {
      return _marginalSets[id];
    }

Member Data Documentation

__bnet

template<typename GUM_SCALAR >

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

private

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

Definition at line 377 of file CNLoopyPropagation.h.

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

__cn

template<typename GUM_SCALAR >

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

private

A pointer to the CredalNet to be used.

Definition at line 374 of file CNLoopyPropagation.h.

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

__inferenceType

template<typename GUM_SCALAR >

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

private

The choosen inference type.

nodeToNeighbours by Default.

Definition at line 371 of file CNLoopyPropagation.h.

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

_ArcsL_max

template<typename GUM_SCALAR >

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

protected

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

Definition at line 351 of file CNLoopyPropagation.h.

_ArcsL_min

template<typename GUM_SCALAR >

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

protected

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

Definition at line 339 of file CNLoopyPropagation.h.

_ArcsP_max

template<typename GUM_SCALAR >

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

protected

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

Definition at line 353 of file CNLoopyPropagation.h.

_ArcsP_min

template<typename GUM_SCALAR >

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

protected

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

Definition at line 341 of file CNLoopyPropagation.h.

_burn_in

Size gum::ApproximationScheme::_burn_in

protectedinherited

Number of iterations before checking stopping criteria.

Definition at line 414 of file approximationScheme.h.

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

_credalNet

template<typename GUM_SCALAR >

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

protectedinherited

A pointer to the Credal Net used.

Definition at line 74 of file inferenceEngine.h.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::__mcThreadDataCopy(), gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::__verticesSampling(), gum::credal::InferenceEngine< GUM_SCALAR >::_dynamicExpectations(), gum::credal::InferenceEngine< GUM_SCALAR >::_initExpectations(), gum::credal::InferenceEngine< GUM_SCALAR >::_initMarginals(), gum::credal::InferenceEngine< GUM_SCALAR >::_initMarginalSets(), gum::credal::InferenceEngine< GUM_SCALAR >::_repetitiveInit(), gum::credal::InferenceEngine< GUM_SCALAR >::_updateExpectations(), gum::credal::InferenceEngine< GUM_SCALAR >::credalNet(), gum::credal::InferenceEngine< GUM_SCALAR >::expectationMax(), gum::credal::InferenceEngine< GUM_SCALAR >::expectationMin(), gum::credal::InferenceEngine< GUM_SCALAR >::InferenceEngine(), gum::credal::InferenceEngine< GUM_SCALAR >::insertEvidence(), gum::credal::InferenceEngine< GUM_SCALAR >::insertEvidenceFile(), gum::credal::InferenceEngine< GUM_SCALAR >::insertModals(), gum::credal::InferenceEngine< GUM_SCALAR >::insertQuery(), gum::credal::InferenceEngine< GUM_SCALAR >::insertQueryFile(), gum::credal::InferenceEngine< GUM_SCALAR >::marginalMax(), gum::credal::InferenceEngine< GUM_SCALAR >::marginalMin(), gum::credal::InferenceEngine< GUM_SCALAR >::saveMarginals(), gum::credal::InferenceEngine< GUM_SCALAR >::saveVertices(), and gum::credal::InferenceEngine< GUM_SCALAR >::toString().

_current_epsilon

double gum::ApproximationScheme::_current_epsilon

protectedinherited

Current epsilon.

Definition at line 369 of file approximationScheme.h.

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

_current_rate

double gum::ApproximationScheme::_current_rate

protectedinherited

Current rate.

Definition at line 375 of file approximationScheme.h.

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

_current_state

ApproximationSchemeSTATE gum::ApproximationScheme::_current_state

protectedinherited

The current state.

Definition at line 384 of file approximationScheme.h.

Referenced by gum::ApproximationScheme::_stopScheme(), gum::ApproximationScheme::continueApproximationScheme(), gum::ApproximationScheme::initApproximationScheme(), gum::ApproximationScheme::stateApproximationScheme(), and gum::ApproximationScheme::stopApproximationScheme().

_current_step

Size gum::ApproximationScheme::_current_step

protectedinherited

The current step.

Definition at line 378 of file approximationScheme.h.

Referenced by gum::learning::Miic::_initiation(), gum::learning::Miic::_iteration(), gum::learning::Miic::_orientation_3off2(), gum::learning::Miic::_orientation_latents(), gum::learning::Miic::_orientation_miic(), gum::ApproximationScheme::continueApproximationScheme(), gum::ApproximationScheme::initApproximationScheme(), gum::learning::Miic::learnMixedStructure(), gum::ApproximationScheme::nbrIterations(), gum::ApproximationScheme::remainingBurnIn(), gum::ApproximationScheme::startOfPeriod(), and gum::ApproximationScheme::updateApproximationScheme().

_dbnOpt

template<typename GUM_SCALAR >

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

protectedinherited

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

Definition at line 147 of file inferenceEngine.h.

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

_dynamicExpMax

template<typename GUM_SCALAR >

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

protectedinherited

Upper dynamic expectations.

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

Definition at line 101 of file inferenceEngine.h.

Referenced by gum::credal::InferenceEngine< GUM_SCALAR >::_dynamicExpectations(), gum::credal::InferenceEngine< GUM_SCALAR >::dynamicExpMax(), gum::credal::InferenceEngine< GUM_SCALAR >::eraseAllEvidence(), and gum::credal::InferenceEngine< GUM_SCALAR >::saveExpectations().

_dynamicExpMin

template<typename GUM_SCALAR >

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

protectedinherited

Lower dynamic expectations.

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

Definition at line 98 of file inferenceEngine.h.

Referenced by gum::credal::InferenceEngine< GUM_SCALAR >::_dynamicExpectations(), gum::credal::InferenceEngine< GUM_SCALAR >::dynamicExpMin(), gum::credal::InferenceEngine< GUM_SCALAR >::eraseAllEvidence(), and gum::credal::InferenceEngine< GUM_SCALAR >::saveExpectations().

_enabled_eps

bool gum::ApproximationScheme::_enabled_eps

protectedinherited

If true, the threshold convergence is enabled.

Definition at line 393 of file approximationScheme.h.

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

_enabled_max_iter

bool gum::ApproximationScheme::_enabled_max_iter

protectedinherited

If true, the maximum iterations stopping criterion is enabled.

Definition at line 411 of file approximationScheme.h.

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

_enabled_max_time

bool gum::ApproximationScheme::_enabled_max_time

protectedinherited

If true, the timeout is enabled.

Definition at line 405 of file approximationScheme.h.

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

_enabled_min_rate_eps

bool gum::ApproximationScheme::_enabled_min_rate_eps

protectedinherited

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

Definition at line 399 of file approximationScheme.h.

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

_eps

double gum::ApproximationScheme::_eps

protectedinherited

Threshold for convergence.

Definition at line 390 of file approximationScheme.h.

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

_evidence

template<typename GUM_SCALAR >

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

protectedinherited

Holds observed variables states.

Definition at line 107 of file inferenceEngine.h.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::__insertEvidence(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_optFusion(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_updateThread(), gum::credal::InferenceEngine< GUM_SCALAR >::eraseAllEvidence(), gum::credal::InferenceEngine< GUM_SCALAR >::insertEvidence(), and gum::credal::InferenceEngine< GUM_SCALAR >::insertEvidenceFile().

_expectationMax

template<typename GUM_SCALAR >

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

protectedinherited

Upper expectations, if some variables modalities were inserted.

Definition at line 94 of file inferenceEngine.h.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::__mcThreadDataCopy(), gum::credal::InferenceEngine< GUM_SCALAR >::_dynamicExpectations(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_expFusion(), gum::credal::InferenceEngine< GUM_SCALAR >::_initExpectations(), gum::credal::InferenceEngine< GUM_SCALAR >::_updateExpectations(), and gum::credal::InferenceEngine< GUM_SCALAR >::expectationMax().

_expectationMin

template<typename GUM_SCALAR >

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

protectedinherited

Lower expectations, if some variables modalities were inserted.

Definition at line 91 of file inferenceEngine.h.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::__mcThreadDataCopy(), gum::credal::InferenceEngine< GUM_SCALAR >::_dynamicExpectations(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_expFusion(), gum::credal::InferenceEngine< GUM_SCALAR >::_initExpectations(), gum::credal::InferenceEngine< GUM_SCALAR >::_updateExpectations(), and gum::credal::InferenceEngine< GUM_SCALAR >::expectationMin().

_history

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

protectedinherited

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

Definition at line 387 of file approximationScheme.h.

Referenced by gum::ApproximationScheme::continueApproximationScheme(), gum::ApproximationScheme::history(), and gum::ApproximationScheme::initApproximationScheme().

_InferenceUpToDate

template<typename GUM_SCALAR >

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

protected

TRUE if inference has already been performed, FALSE otherwise.

Definition at line 364 of file CNLoopyPropagation.h.

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

_last_epsilon

double gum::ApproximationScheme::_last_epsilon

protectedinherited

Last epsilon value.

Definition at line 372 of file approximationScheme.h.

Referenced by gum::ApproximationScheme::continueApproximationScheme().

_marginalMax

template<typename GUM_SCALAR >

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

protectedinherited

Upper marginals.

Definition at line 84 of file inferenceEngine.h.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::__mcThreadDataCopy(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_computeEpsilon(), gum::credal::InferenceEngine< GUM_SCALAR >::_computeEpsilon(), gum::credal::InferenceEngine< GUM_SCALAR >::_initMarginals(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_initThreadsData(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_optFusion(), gum::credal::InferenceEngine< GUM_SCALAR >::_updateCredalSets(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_updateMarginals(), gum::credal::InferenceEngine< GUM_SCALAR >::marginalMax(), gum::credal::InferenceEngine< GUM_SCALAR >::saveMarginals(), and gum::credal::InferenceEngine< GUM_SCALAR >::toString().

_marginalMin

template<typename GUM_SCALAR >

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

protectedinherited

Lower marginals.

Definition at line 82 of file inferenceEngine.h.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::__mcThreadDataCopy(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_computeEpsilon(), gum::credal::InferenceEngine< GUM_SCALAR >::_computeEpsilon(), gum::credal::InferenceEngine< GUM_SCALAR >::_initMarginals(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_initThreadsData(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_optFusion(), gum::credal::InferenceEngine< GUM_SCALAR >::_updateCredalSets(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_updateMarginals(), gum::credal::InferenceEngine< GUM_SCALAR >::marginalMin(), gum::credal::InferenceEngine< GUM_SCALAR >::saveMarginals(), and gum::credal::InferenceEngine< GUM_SCALAR >::toString().

_marginalSets

template<typename GUM_SCALAR >

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

protectedinherited

Credal sets vertices, if enabled.

Definition at line 87 of file inferenceEngine.h.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::__mcThreadDataCopy(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_expFusion(), gum::credal::InferenceEngine< GUM_SCALAR >::_initMarginalSets(), gum::credal::InferenceEngine< GUM_SCALAR >::_updateCredalSets(), gum::credal::InferenceEngine< GUM_SCALAR >::saveVertices(), and gum::credal::InferenceEngine< GUM_SCALAR >::vertices().

_max_iter

Size gum::ApproximationScheme::_max_iter

protectedinherited

The maximum iterations.

Definition at line 408 of file approximationScheme.h.

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

_max_time

double gum::ApproximationScheme::_max_time

protectedinherited

The timeout.

Definition at line 402 of file approximationScheme.h.

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

_min_rate_eps

double gum::ApproximationScheme::_min_rate_eps

protectedinherited

Threshold for the epsilon rate.

Definition at line 396 of file approximationScheme.h.

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

_modal

template<typename GUM_SCALAR >

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

protectedinherited

Variables modalities used to compute expectations.

Definition at line 104 of file inferenceEngine.h.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::__mcThreadDataCopy(), gum::credal::InferenceEngine< GUM_SCALAR >::_dynamicExpectations(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_expFusion(), gum::credal::InferenceEngine< GUM_SCALAR >::_initExpectations(), gum::credal::InferenceEngine< GUM_SCALAR >::_updateExpectations(), gum::credal::InferenceEngine< GUM_SCALAR >::insertModals(), gum::credal::InferenceEngine< GUM_SCALAR >::insertModalsFile(), and gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::makeInference().

_msg_l_sent

template<typename GUM_SCALAR >

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

protected

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

Definition at line 336 of file CNLoopyPropagation.h.

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

_NodesL_max

template<typename GUM_SCALAR >

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

protected

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

Definition at line 356 of file CNLoopyPropagation.h.

_NodesL_min

template<typename GUM_SCALAR >

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

protected

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

Definition at line 344 of file CNLoopyPropagation.h.

_NodesP_max

template<typename GUM_SCALAR >

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

protected

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

Definition at line 360 of file CNLoopyPropagation.h.

_NodesP_min

template<typename GUM_SCALAR >

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

protected

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

Definition at line 348 of file CNLoopyPropagation.h.

_oldMarginalMax

template<typename GUM_SCALAR >

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

protectedinherited

Old upper marginals used to compute epsilon.

Definition at line 79 of file inferenceEngine.h.

Referenced by gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_computeEpsilon(), gum::credal::InferenceEngine< GUM_SCALAR >::_computeEpsilon(), gum::credal::InferenceEngine< GUM_SCALAR >::_initMarginals(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_initThreadsData(), and gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_updateOldMarginals().

_oldMarginalMin

template<typename GUM_SCALAR >

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

protectedinherited

Old lower marginals used to compute epsilon.

Definition at line 77 of file inferenceEngine.h.

Referenced by gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_computeEpsilon(), gum::credal::InferenceEngine< GUM_SCALAR >::_computeEpsilon(), gum::credal::InferenceEngine< GUM_SCALAR >::_initMarginals(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_initThreadsData(), and gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_updateOldMarginals().

_period_size

Size gum::ApproximationScheme::_period_size

protectedinherited

Checking criteria frequency.

Definition at line 417 of file approximationScheme.h.

Referenced by gum::ApproximationScheme::periodSize(), gum::ApproximationScheme::setPeriodSize(), and gum::ApproximationScheme::startOfPeriod().

_query

template<typename GUM_SCALAR >

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

protectedinherited

Holds the query nodes states.

Definition at line 109 of file inferenceEngine.h.

Referenced by gum::credal::InferenceEngine< GUM_SCALAR >::eraseAllEvidence(), gum::credal::InferenceEngine< GUM_SCALAR >::insertQuery(), gum::credal::InferenceEngine< GUM_SCALAR >::insertQueryFile(), and gum::credal::InferenceEngine< GUM_SCALAR >::toString().

_repetitiveInd

template<typename GUM_SCALAR >

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

protectedinherited

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

False by default.

Definition at line 133 of file inferenceEngine.h.

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

_storeBNOpt

template<typename GUM_SCALAR >

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

protectedinherited

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

The algorithms stops if no changes occured within 1000 iterations by default. int _iterStop; True is optimal bayes net are stored, for each variable and each modality, False otherwise. Not all algorithms offers this option. False by default.

Definition at line 143 of file inferenceEngine.h.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::__mcThreadDataCopy(), gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::__verticesSampling(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_updateThread(), gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::CNMonteCarloSampling(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::eraseAllEvidence(), gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::makeInference(), and gum::credal::InferenceEngine< GUM_SCALAR >::storeBNOpt().

_storeVertices

template<typename GUM_SCALAR >

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

protectedinherited

True if credal sets vertices are stored, False otherwise.

False by default.

Definition at line 129 of file inferenceEngine.h.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::__mcThreadDataCopy(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_expFusion(), gum::credal::InferenceEngine< GUM_SCALAR >::_initMarginalSets(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_updateThread(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::_verticesFusion(), gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::CNMonteCarloSampling(), gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::eraseAllEvidence(), gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::makeInference(), and gum::credal::InferenceEngine< GUM_SCALAR >::storeVertices().

_t0

template<typename GUM_SCALAR >

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

protectedinherited

Clusters of nodes used with dynamic networks.

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

Definition at line 117 of file inferenceEngine.h.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::__mcThreadDataCopy(), gum::credal::InferenceEngine< GUM_SCALAR >::_repetitiveInit(), and gum::credal::InferenceEngine< GUM_SCALAR >::getT0Cluster().

_t1

template<typename GUM_SCALAR >

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

protectedinherited

Clusters of nodes used with dynamic networks.

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

Definition at line 124 of file inferenceEngine.h.

Referenced by gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >::__mcThreadDataCopy(), gum::credal::InferenceEngine< GUM_SCALAR >::_repetitiveInit(), and gum::credal::InferenceEngine< GUM_SCALAR >::getT1Cluster().

_timer

Timer gum::ApproximationScheme::_timer

protectedinherited

The timer.

Definition at line 381 of file approximationScheme.h.

Referenced by gum::learning::Miic::_initiation(), gum::learning::Miic::_iteration(), gum::learning::Miic::_orientation_3off2(), gum::learning::Miic::_orientation_latents(), gum::learning::Miic::_orientation_miic(), gum::ApproximationScheme::_stopScheme(), gum::ApproximationScheme::continueApproximationScheme(), gum::ApproximationScheme::currentTime(), gum::ApproximationScheme::initApproximationScheme(), and gum::learning::Miic::learnMixedStructure().

_timeSteps

template<typename GUM_SCALAR >

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

protectedinherited

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

Deprecated:

Definition at line 154 of file inferenceEngine.h.

Referenced by gum::credal::InferenceEngine< GUM_SCALAR >::_repetitiveInit().

_update_l

template<typename GUM_SCALAR >

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

protected

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

Definition at line 326 of file CNLoopyPropagation.h.

_update_p

template<typename GUM_SCALAR >

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

protected

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

Definition at line 322 of file CNLoopyPropagation.h.

_verbosity

bool gum::ApproximationScheme::_verbosity

protectedinherited

If true, verbosity is enabled.

Definition at line 420 of file approximationScheme.h.

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

active_nodes_set

template<typename GUM_SCALAR >

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

protected

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

Definition at line 329 of file CNLoopyPropagation.h.

next_active_nodes_set

template<typename GUM_SCALAR >

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

protected

The next node-set, i.e.

the nodes that will send messages at the next step.

Definition at line 333 of file CNLoopyPropagation.h.

onProgress

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

inherited

Progression, error and time.

Definition at line 59 of file IApproximationSchemeConfiguration.h.

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

onStop

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

inherited

Criteria messageApproximationScheme.

Definition at line 62 of file IApproximationSchemeConfiguration.h.

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

---

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

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