gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine > Class Template Reference

Class template representing a CredalNet inference engine using one or more IBayesNet inference engines such as LazyPropagation. More...

#include <multipleInferenceEngine.h>

Inheritance diagram for gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >:

Collaboration diagram for gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >:

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

Public Member Functions
Constructors / Destructors
	MultipleInferenceEngine (const CredalNet< GUM_SCALAR > &credalNet)
	Constructor. More...
virtual	~MultipleInferenceEngine ()
	Destructor. More...
Post-inference methods
virtual void	eraseAllEvidence ()
	Erase all inference related data to perform another one. More...
Pure virtual methods
virtual void	makeInference ()=0
	To be redefined by each credal net algorithm. More...
Getters and setters
VarMod2BNsMap< GUM_SCALAR > *	getVarMod2BNsMap ()
	Get optimum IBayesNet. More...
const CredalNet< GUM_SCALAR > &	credalNet () const
	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...
virtual void	insertEvidenceFile (const std::string &path)
	Insert evidence from file. 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
Potential< GUM_SCALAR >	marginalMin (const NodeId id) const
	Get the lower marginals of a given node id. More...
Potential< GUM_SCALAR >	marginalMin (const std::string &varName) const
	Get the lower marginals of a given variable name. More...
Potential< GUM_SCALAR >	marginalMax (const NodeId id) const
	Get the upper marginals of a given node id. More...
Potential< 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	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
margis__	l_marginalMin_
	Threads lower marginals, one per thread. More...
margis__	l_marginalMax_
	Threads upper marginals, one per thread. More...
expes__	l_expectationMin_
	Threads lower expectations, one per thread. More...
expes__	l_expectationMax_
	Threads upper expectations, one per thread. More...
modals__	l_modal_
	Threads modalities. More...
credalSets__	l_marginalSets_
	Threads vertices. More...
margis__	l_evidence_
	Threads evidence. More...
clusters__	l_clusters_
	Threads clusters. More...
std::vector< bnet__ *>	workingSet_
	Threads IBayesNet. More...
std::vector< List< const Potential< GUM_SCALAR > *> *>	workingSetE_
	Threads evidence. More...
std::vector< BNInferenceEngine *>	l_inferenceEngine_
	Threads BNInferenceEngine. More...
std::vector< VarMod2BNsMap< GUM_SCALAR > *>	l_optimalNet_
	Threads optimal IBayesNet. 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
Fusion of threads optimal IBayesNet.
void	initThreadsData_ (const Size &num_threads, const bool storeVertices__, const bool storeBNOpt__)
	Initialize threads data. More...
Protected algorithms methods
bool	updateThread_ (const NodeId &id, const std::vector< GUM_SCALAR > &vertex, const bool &elimRedund=false)
	Update thread information (marginals, expectations, IBayesNet, vertices) for a given node id. More...
void	updateMarginals_ ()
	Fusion of threads marginals. More...
const GUM_SCALAR	computeEpsilon_ ()
	Compute epsilon and update old marginals. More...
void	updateOldMarginals_ ()
	Update old marginals (from current marginals). More...
Proptected post-inference methods
void	optFusion_ ()
	Fusion of threads optimal IBayesNet. More...
void	expFusion_ ()
	Fusion of threads expectations. More...
void	verticesFusion_ ()
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
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 BNInferenceEngine>
class gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >

Class template representing a CredalNet inference engine using one or more IBayesNet inference engines such as LazyPropagation.

Extends InferenceEngine< GUM_SCALAR >. Used for outer multi-threading such as CNMonteCarloSampling.

Template Parameters

GUM_SCALAR	A floating type ( float, double, long double ... ).
BNInferenceEngine	A IBayesNet inference engine such as LazyPropagation.

Author

Matthieu HOURBRACQ and Pierre-Henri WUILLEMIN()

Definition at line 54 of file multipleInferenceEngine.h.

Member Typedef Documentation

bnet__

template<typename GUM_SCALAR , class BNInferenceEngine >

typedef IBayesNet< GUM_SCALAR > gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::bnet__

private

Definition at line 64 of file multipleInferenceEngine.h.

cluster__

template<typename GUM_SCALAR , class BNInferenceEngine >

typedef NodeProperty< std::vector< NodeId > > gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::cluster__

private

Definition at line 59 of file multipleInferenceEngine.h.

clusters__

template<typename GUM_SCALAR , class BNInferenceEngine >

typedef std::vector< std::vector< cluster__ > > gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::clusters__

private

Definition at line 68 of file multipleInferenceEngine.h.

credalSet__

template<typename GUM_SCALAR , class BNInferenceEngine >

typedef NodeProperty< std::vector< std::vector< GUM_SCALAR > > > gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::credalSet__

private

Definition at line 60 of file multipleInferenceEngine.h.

credalSets__

template<typename GUM_SCALAR , class BNInferenceEngine >

typedef std::vector< credalSet__ > gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::credalSets__

private

Definition at line 67 of file multipleInferenceEngine.h.

expe__

template<typename GUM_SCALAR , class BNInferenceEngine >

typedef NodeProperty< GUM_SCALAR > gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::expe__

private

Definition at line 62 of file multipleInferenceEngine.h.

expes__

template<typename GUM_SCALAR , class BNInferenceEngine >

typedef std::vector< expe__ > gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::expes__

private

Definition at line 66 of file multipleInferenceEngine.h.

infE__

template<typename GUM_SCALAR , class BNInferenceEngine >

typedef InferenceEngine< GUM_SCALAR > gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::infE__

private

To easily access InferenceEngine< GUM_SCALAR > methods.

Definition at line 57 of file multipleInferenceEngine.h.

margi__

template<typename GUM_SCALAR , class BNInferenceEngine >

typedef NodeProperty< std::vector< GUM_SCALAR > > gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::margi__

private

Definition at line 61 of file multipleInferenceEngine.h.

margis__

template<typename GUM_SCALAR , class BNInferenceEngine >

typedef std::vector< margi__ > gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::margis__

private

Definition at line 65 of file multipleInferenceEngine.h.

modals__

template<typename GUM_SCALAR , class BNInferenceEngine >

typedef std::vector< HashTable< std::string, std::vector< GUM_SCALAR > > > gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::modals__

private

Definition at line 72 of file multipleInferenceEngine.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 64 of file IApproximationSchemeConfiguration.h.

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

Constructor & Destructor Documentation

MultipleInferenceEngine()

template<typename GUM_SCALAR , class BNInferenceEngine >

gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::MultipleInferenceEngine ( const CredalNet< GUM_SCALAR > &  credalNet )

explicit

Constructor.

Parameters

credalNet

The CredalNet to be used.

Definition at line 30 of file multipleInferenceEngine_tpl.h.

                                                                         :
        InferenceEngine< GUM_SCALAR >::InferenceEngine(credalNet) {
      GUM_CONSTRUCTOR(MultipleInferenceEngine);
    }

~MultipleInferenceEngine()

template<typename GUM_SCALAR , class BNInferenceEngine >

gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::~MultipleInferenceEngine ( )

virtual

Destructor.

Definition at line 37 of file multipleInferenceEngine_tpl.h.

                                                                           {
      GUM_DESTRUCTOR(MultipleInferenceEngine);
    }

Member Function Documentation

computeEpsilon_()

template<typename GUM_SCALAR , class BNInferenceEngine >

const GUM_SCALAR gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::computeEpsilon_ ( )

inlineprotected

Compute epsilon and update old marginals.

Returns

Epsilon.

Definition at line 303 of file multipleInferenceEngine_tpl.h.

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

        int  tId   = getThreadNumber();
        long nsize = long(workingSet_[tId]->size());

#pragma omp for

        for (long i = 0; i < nsize; i++) {
          Size dSize = Size(l_marginalMin_[tId][i].size());

          for (Size j = 0; j < dSize; j++) {
            // on min
            delta = this->marginalMin_[i][j] - this->oldMarginalMin_[i][j];
            delta = (delta < 0) ? (-delta) : delta;
            tEps  = (tEps < delta) ? delta : tEps;

            // on max
            delta = this->marginalMax_[i][j] - this->oldMarginalMax_[i][j];
            delta = (delta < 0) ? (-delta) : delta;
            tEps  = (tEps < delta) ? delta : tEps;

            this->oldMarginalMin_[i][j] = this->marginalMin_[i][j];
            this->oldMarginalMax_[i][j] = this->marginalMax_[i][j];
          }
        }   // end of : all variables

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

      }   // end of : parallel region
      return eps;
    }

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 226 of file approximationScheme_inl.h.

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

                                                                           {
    // 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:

credalNet()

template<typename GUM_SCALAR >

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

inherited

Get this creadal network.

Returns

A constant reference to this CredalNet.

Definition at line 59 of file inferenceEngine_tpl.h.

                                                      {
      return *credalNet_;
    }

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 127 of file approximationScheme_inl.h.

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

{ return timer_.step(); }

Here is the call graph for this function:

disableEpsilon()

INLINE void gum::ApproximationScheme::disableEpsilon ( )

virtualinherited

Disable stopping criterion on epsilon.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 53 of file approximationScheme_inl.h.

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

{ enabled_eps_ = false; }

Here is the call graph for this function:

disableMaxIter()

INLINE void gum::ApproximationScheme::disableMaxIter ( )

virtualinherited

Disable stopping criterion on max iterations.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 104 of file approximationScheme_inl.h.

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

{ enabled_max_iter_ = false; }

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

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

{ enabled_max_time_ = false; }

Here is the call graph for this function:

disableMinEpsilonRate()

INLINE void gum::ApproximationScheme::disableMinEpsilonRate ( )

virtualinherited

Disable stopping criterion on epsilon rate.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 78 of file approximationScheme_inl.h.

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

                                                         {
    enabled_min_rate_eps_ = false;
  }

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

                                                            {
      dynamicExpectations_();
    }

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 723 of file inferenceEngine_tpl.h.

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

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

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

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 506 of file inferenceEngine_tpl.h.

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

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

      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 488 of file inferenceEngine_tpl.h.

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

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

      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 56 of file approximationScheme_inl.h.

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

{ enabled_eps_ = true; }

Here is the call graph for this function:

enableMaxIter()

INLINE void gum::ApproximationScheme::enableMaxIter ( )

virtualinherited

Enable stopping criterion on max iterations.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 107 of file approximationScheme_inl.h.

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

{ enabled_max_iter_ = true; }

Here is the call graph for this function:

enableMaxTime()

INLINE void gum::ApproximationScheme::enableMaxTime ( )

virtualinherited

Enable stopping criterion on timeout.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 133 of file approximationScheme_inl.h.

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

{ enabled_max_time_ = true; }

Here is the call graph for this function:

enableMinEpsilonRate()

INLINE void gum::ApproximationScheme::enableMinEpsilonRate ( )

virtualinherited

Enable stopping criterion on epsilon rate.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 83 of file approximationScheme_inl.h.

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

                                                        {
    enabled_min_rate_eps_ = true;
  }

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

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

{ return eps_; }

Here is the call graph for this function:

eraseAllEvidence()

template<typename GUM_SCALAR , class BNInferenceEngine >

void gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::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 532 of file multipleInferenceEngine_tpl.h.

                                                                        {
      infE__::eraseAllEvidence();
      Size tsize = Size(workingSet_.size());

      // delete pointers
      for (Size bn = 0; bn < tsize; bn++) {
        if (infE__::storeVertices_) l_marginalSets_[bn].clear();

        if (workingSet_[bn] != nullptr) delete workingSet_[bn];

        if (infE__::storeBNOpt_)
          if (l_inferenceEngine_[bn] != nullptr) delete l_optimalNet_[bn];

        if (this->workingSetE_[bn] != nullptr) {
          for (const auto ev: *workingSetE_[bn])
            delete ev;

          delete workingSetE_[bn];
        }

        if (l_inferenceEngine_[bn] != nullptr) delete l_inferenceEngine_[bn];
      }

      // this is important, those will be resized with the correct number of
      // threads.

      workingSet_.clear();
      workingSetE_.clear();
      l_inferenceEngine_.clear();
      l_optimalNet_.clear();

      l_marginalMin_.clear();
      l_marginalMax_.clear();
      l_expectationMin_.clear();
      l_expectationMax_.clear();
      l_modal_.clear();
      l_marginalSets_.clear();
      l_evidence_.clear();
      l_clusters_.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 481 of file inferenceEngine_tpl.h.

                                                                          {
      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 464 of file inferenceEngine_tpl.h.

                                       {
      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 473 of file inferenceEngine_tpl.h.

                                                                          {
      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 456 of file inferenceEngine_tpl.h.

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

expFusion_()

template<typename GUM_SCALAR , class BNInferenceEngine >

void gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::expFusion_ ( )

protected

Fusion of threads expectations.

Definition at line 409 of file multipleInferenceEngine_tpl.h.

                                                                              {
      // don't create threads if there are no modalities to compute expectations
      if (this->modal_.empty()) return;

      // we can compute expectations from vertices of the final credal set
      if (infE__::storeVertices_) {
#pragma omp parallel
        {
          int threadId = getThreadNumber();

          if (!this->l_modal_[threadId].empty()) {
            Size nsize = Size(workingSet_[threadId]->size());

#pragma omp for

            for (long i = 0; i < long(nsize);
                 i++) {   // i needs to be signed (due to omp with visual c++
                          // 15)
              std::string var_name = workingSet_[threadId]->variable(i).name();
              auto        delim    = var_name.find_first_of("_");
              var_name             = var_name.substr(0, delim);

              if (!l_modal_[threadId].exists(var_name)) continue;

              for (const auto& vertex: infE__::marginalSets_[i]) {
                GUM_SCALAR exp   = 0;
                Size       vsize = Size(vertex.size());

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

                if (exp > infE__::expectationMax_[i])
                  infE__::expectationMax_[i] = exp;

                if (exp < infE__::expectationMin_[i])
                  infE__::expectationMin_[i] = exp;
              }
            }   // end of : each variable parallel for
          }     // end of : if this thread has modals
        }       // end of parallel region
        return;
      }

#pragma omp parallel
      {
        int threadId = getThreadNumber();

        if (!this->l_modal_[threadId].empty()) {
          Size nsize = Size(workingSet_[threadId]->size());
#pragma omp for
          for (long i = 0; i < long(nsize);
               i++) {   // long instead of Idx due to omp for visual C++15
            std::string var_name = workingSet_[threadId]->variable(i).name();
            auto        delim    = var_name.find_first_of("_");
            var_name             = var_name.substr(0, delim);

            if (!l_modal_[threadId].exists(var_name)) continue;

            Size tsize = Size(l_expectationMax_.size());

            for (Idx tId = 0; tId < tsize; tId++) {
              if (l_expectationMax_[tId][i] > this->expectationMax_[i])
                this->expectationMax_[i] = l_expectationMax_[tId][i];

              if (l_expectationMin_[tId][i] < this->expectationMin_[i])
                this->expectationMin_[i] = l_expectationMin_[tId][i];
            }   // end of : each thread
          }     // end of : each variable
        }       // end of : if modals not empty
      }         // end of : parallel region
    }

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 508 of file inferenceEngine.h.

                                                  {
        return this->messageApproximationScheme();
      }

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 1008 of file inferenceEngine_tpl.h.

                                                         {
      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 1014 of file inferenceEngine_tpl.h.

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

                                                       {
      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 172 of file approximationScheme_inl.h.

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

                                                                       {
    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:

initApproximationScheme()

INLINE void gum::ApproximationScheme::initApproximationScheme ( )

inherited

Initialise the scheme.

Definition at line 186 of file approximationScheme_inl.h.

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

                                                           {
    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:

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 697 of file inferenceEngine_tpl.h.

                                                          {
      expectationMin_.clear();
      expectationMax_.clear();

      if (modal_.empty()) return;

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

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

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

        expectationMin_.insert(node, modal_[var_name].back());
        expectationMax_.insert(node, modal_[var_name].front());
      }
    }

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 665 of file inferenceEngine_tpl.h.

                                                       {
      marginalMin_.clear();
      marginalMax_.clear();
      oldMarginalMin_.clear();
      oldMarginalMax_.clear();

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

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

initMarginalSets_()

template<typename GUM_SCALAR >

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

protectedinherited

Initialize credal set vertices with empty sets.

Definition at line 682 of file inferenceEngine_tpl.h.

                                                          {
      marginalSets_.clear();

      if (!storeVertices_) return;

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

initThreadsData_()

template<typename GUM_SCALAR , class BNInferenceEngine >

void gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::initThreadsData_ ( const Size &  num_threads, const bool  storeVertices__, const bool  storeBNOpt__  )

inlineprotected

Initialize threads data.

Parameters

num_threads	The number of threads.
storeVertices__	True if vertices should be stored, False otherwise.
storeBNOpt__	True if optimal IBayesNet should be stored, false otherwise.

Definition at line 43 of file multipleInferenceEngine_tpl.h.

                                    {
      workingSet_.clear();
      workingSet_.resize(num_threads, nullptr);
      workingSetE_.clear();
      workingSetE_.resize(num_threads, nullptr);

      l_marginalMin_.clear();
      l_marginalMin_.resize(num_threads);
      l_marginalMax_.clear();
      l_marginalMax_.resize(num_threads);
      l_expectationMin_.clear();
      l_expectationMin_.resize(num_threads);
      l_expectationMax_.clear();
      l_expectationMax_.resize(num_threads);

      l_clusters_.clear();
      l_clusters_.resize(num_threads);

      if (storeVertices__) {
        l_marginalSets_.clear();
        l_marginalSets_.resize(num_threads);
      }

      if (storeBNOpt__) {
        for (Size ptr = 0; ptr < this->l_optimalNet_.size(); ptr++)
          if (this->l_optimalNet_[ptr] != nullptr) delete l_optimalNet_[ptr];

        l_optimalNet_.clear();
        l_optimalNet_.resize(num_threads);
      }

      l_modal_.clear();
      l_modal_.resize(num_threads);

      infE__::oldMarginalMin_.clear();
      this->oldMarginalMin_ = this->marginalMin_;
      this->oldMarginalMax_.clear();
      this->oldMarginalMax_ = this->marginalMax_;
    }

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.

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

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.

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

insertEvidenceFile()

template<typename GUM_SCALAR >

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

virtualinherited

Insert evidence from file.

Parameters

path	The path to the evidence file.

Reimplemented in gum::credal::CNLoopyPropagation< GUM_SCALAR >, and gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >.

Definition at line 270 of file inferenceEngine_tpl.h.

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

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

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

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

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

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

        if (std::strcmp(line.c_str(), "[QUERY]") == 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;
        }

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

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

        evidence_.insert(node, values);

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

      evi_stream.close();
    }

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.

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

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.

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

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.

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

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.

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

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 60 of file approximationScheme_inl.h.

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

                                                          {
    return enabled_eps_;
  }

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

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

                                                          {
    return enabled_max_iter_;
  }

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

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

                                                          {
    return enabled_max_time_;
  }

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

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

                                                                 {
    return enabled_min_rate_eps_;
  }

Here is the call graph for this function:

makeInference()

template<typename GUM_SCALAR , class BNInferenceEngine >

virtual void gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::makeInference ( )

pure virtual

To be redefined by each credal net algorithm.

Starts the inference.

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

Implemented in gum::credal::CNMonteCarloSampling< GUM_SCALAR, BNInferenceEngine >.

marginalMax() [1/2]

template<typename GUM_SCALAR >

gum::Potential< 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 446 of file inferenceEngine_tpl.h.

                                                                       {
      try {
        Potential< GUM_SCALAR > res;
        res.add(credalNet_->current_bn().variable(id));
        res.fillWith(marginalMax_[id]);
        return res;
      } catch (NotFound& err) { throw(err); }
    }

marginalMax() [2/2]

template<typename GUM_SCALAR >

INLINE Potential< 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 428 of file inferenceEngine_tpl.h.

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

marginalMin() [1/2]

template<typename GUM_SCALAR >

gum::Potential< 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 435 of file inferenceEngine_tpl.h.

                                                                       {
      try {
        Potential< GUM_SCALAR > res;
        res.add(credalNet_->current_bn().variable(id));
        res.fillWith(marginalMin_[id]);
        return res;
      } catch (NotFound& err) { throw(err); }
    }

marginalMin() [2/2]

template<typename GUM_SCALAR >

INLINE Potential< 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.

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

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 101 of file approximationScheme_inl.h.

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

{ return max_iter_; }

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

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

{ return max_time_; }

Here is the call graph for this function:

messageApproximationScheme()

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

inherited

Returns the approximation scheme message.

Returns

Returns the approximation scheme message.

Definition at line 39 of file IApproximationSchemeConfiguration_inl.h.

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

                                                                         {
    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:

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 73 of file approximationScheme_inl.h.

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

                                                          {
    return min_rate_eps_;
  }

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

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

                                                       {
    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:

optFusion_()

template<typename GUM_SCALAR , class BNInferenceEngine >

void gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::optFusion_ ( )

protected

Fusion of threads optimal IBayesNet.

Definition at line 482 of file multipleInferenceEngine_tpl.h.

                                                                              {
      typedef std::vector< bool > dBN;

      Size nsize = Size(workingSet_[0]->size());

      // no parallel insert in hash-tables (OptBN)
      for (Idx i = 0; i < nsize; i++) {
        // we don't store anything for observed variables
        if (infE__::evidence_.exists(i)) continue;

        Size dSize = Size(l_marginalMin_[0][i].size());

        for (Size j = 0; j < dSize; j++) {
          // go through all threads
          std::vector< Size > keymin(3);
          keymin[0] = i;
          keymin[1] = j;
          keymin[2] = 0;
          std::vector< Size > keymax(keymin);
          keymax[2] = 1;

          Size tsize = Size(l_marginalMin_.size());

          for (Size tId = 0; tId < tsize; tId++) {
            if (l_marginalMin_[tId][i][j] == this->marginalMin_[i][j]) {
              const std::vector< dBN* >& tOpts
                 = l_optimalNet_[tId]->getBNOptsFromKey(keymin);
              Size osize = Size(tOpts.size());

              for (Size bn = 0; bn < osize; bn++) {
                infE__::dbnOpt_.insert(*tOpts[bn], keymin);
              }
            }

            if (l_marginalMax_[tId][i][j] == this->marginalMax_[i][j]) {
              const std::vector< dBN* >& tOpts
                 = l_optimalNet_[tId]->getBNOptsFromKey(keymax);
              Size osize = Size(tOpts.size());

              for (Size bn = 0; bn < osize; bn++) {
                infE__::dbnOpt_.insert(*tOpts[bn], keymax);
              }
            }
          }   // end of : all threads
        }     // end of : all modalities
      }       // end of : all variables
    }

periodSize()

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

virtualinherited

Returns the period size.

Returns

Returns the period size.

Implements gum::IApproximationSchemeConfiguration.

Definition at line 148 of file approximationScheme_inl.h.

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

{ return period_size_; }

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

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

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

Here is the call graph for this function:

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.

                                                            {
      return repetitiveInd_;
    }

repetitiveInit_()

template<typename GUM_SCALAR >

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

protectedinherited

Initialize t0_ and t1_ clusters.

Definition at line 786 of file inferenceEngine_tpl.h.

                                                        {
      timeSteps_ = 0;
      t0_.clear();
      t1_.clear();

      // t = 0 vars belongs to t0_ as keys
      for (auto node: credalNet_->current_bn().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;
                }
              }
            }
          }
        }
      }
    }

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 556 of file inferenceEngine_tpl.h.

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

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

      std::ofstream m_stream(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();
    }

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 530 of file inferenceEngine_tpl.h.

                                    {
      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 630 of file inferenceEngine_tpl.h.

                                                                              {
      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 42 of file approximationScheme_inl.h.

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

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

    eps_         = eps;
    enabled_eps_ = true;
  }

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

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

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

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

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

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

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

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

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

    min_rate_eps_         = rate;
    enabled_min_rate_eps_ = true;
  }

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

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

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

    period_size_ = p;
  }

Here is the call 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.

                                                                              {
      bool oldValue  = repetitiveInd_;
      repetitiveInd_ = repetitive;

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

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 151 of file approximationScheme_inl.h.

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

{ verbosity_ = v; }

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

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

                                                 {
    if (current_step_ < burn_in_) { return false; }

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

    return ((current_step_ - burn_in_) % period_size_ == 0);
  }

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

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

                                                             {
    return current_state_;
  }

Here is the call graph for this function:

stopApproximationScheme()

INLINE void gum::ApproximationScheme::stopApproximationScheme ( )

inherited

Stop the approximation scheme.

Definition at line 218 of file approximationScheme_inl.h.

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

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

Here is the call 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.

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

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

                                                                      {
      storeVertices_ = value;

      if (value) initMarginalSets_();
    }

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.

                                                            {
      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 601 of file inferenceEngine_tpl.h.

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

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

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

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

          output << std::endl;
        }

        output << std::endl;
      }

      return output.str();
    }

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 205 of file approximationScheme_inl.h.

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

                                                                              {
    current_step_ += incr;
  }

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

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

      bool eq = true;

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

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

        if (eq) break;
      }

      if (!eq || nodeCredalSet.size() == 0) {
        nodeCredalSet.push_back(vertex);
        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();
    }

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 909 of file inferenceEngine_tpl.h.

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

      var_name = var_name.substr(0, delim);

      if (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;
      }
    }

updateMarginals_()

template<typename GUM_SCALAR , class BNInferenceEngine >

void gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::updateMarginals_ ( )

inlineprotected

Fusion of threads marginals.

Definition at line 273 of file multipleInferenceEngine_tpl.h.

                                                                               {
#pragma omp parallel
      {
        int  threadId = getThreadNumber();
        long nsize    = long(workingSet_[threadId]->size());

#pragma omp for

        for (long i = 0; i < nsize; i++) {
          Size dSize = Size(l_marginalMin_[threadId][i].size());

          for (Size j = 0; j < dSize; j++) {
            Size tsize = Size(l_marginalMin_.size());

            // go through all threads
            for (Size tId = 0; tId < tsize; tId++) {
              if (l_marginalMin_[tId][i][j] < this->marginalMin_[i][j])
                this->marginalMin_[i][j] = l_marginalMin_[tId][i][j];

              if (l_marginalMax_[tId][i][j] > this->marginalMax_[i][j])
                this->marginalMax_[i][j] = l_marginalMax_[tId][i][j];
            }   // end of : all threads
          }     // end of : all modalities
        }       // end of : all variables
      }         // end of : parallel region
    }

updateOldMarginals_()

template<typename GUM_SCALAR , class BNInferenceEngine >

void gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::updateOldMarginals_ ( )

protected

Update old marginals (from current marginals).

Call this once to initialize old marginals (after burn-in for example) and then use computeEpsilon_ which does the same job but compute epsilon too.

Definition at line 346 of file multipleInferenceEngine_tpl.h.

                                                                           {
#pragma omp parallel
      {
        int  threadId = getThreadNumber();
        long nsize    = long(workingSet_[threadId]->size());

#pragma omp for

        for (long i = 0; i < nsize; i++) {
          Size dSize = Size(l_marginalMin_[threadId][i].size());

          for (Size j = 0; j < dSize; j++) {
            Size tsize = Size(l_marginalMin_.size());

            // go through all threads
            for (Size tId = 0; tId < tsize; tId++) {
              if (l_marginalMin_[tId][i][j] < this->oldMarginalMin_[i][j])
                this->oldMarginalMin_[i][j] = l_marginalMin_[tId][i][j];

              if (l_marginalMax_[tId][i][j] > this->oldMarginalMax_[i][j])
                this->oldMarginalMax_[i][j] = l_marginalMax_[tId][i][j];
            }   // end of : all threads
          }     // end of : all modalities
        }       // end of : all variables
      }         // end of : parallel region
    }

updateThread_()

template<typename GUM_SCALAR , class BNInferenceEngine >

bool gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::updateThread_ ( const NodeId &  id, const std::vector< GUM_SCALAR > &  vertex, const bool &  elimRedund = false  )

inlineprotected

Update thread information (marginals, expectations, IBayesNet, vertices) for a given node id.

Parameters

id	The id of the node to be updated.
vertex	The vertex.
elimRedund	true if redundancy elimination is to be performed, false otherwise and by default.

Returns

True if the IBayesNet is kept (for now), False otherwise.

Definition at line 88 of file multipleInferenceEngine_tpl.h.

                                                       {
      int tId = getThreadNumber();

      // save E(X) if we don't save vertices
      if (!infE__::storeVertices_ && !l_modal_[tId].empty()) {
        std::string var_name = workingSet_[tId]->variable(id).name();
        auto        delim    = var_name.find_first_of("_");
        var_name             = var_name.substr(0, delim);

        if (l_modal_[tId].exists(var_name)) {
          GUM_SCALAR exp   = 0;
          Size       vsize = Size(vertex.size());

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

          if (exp > l_expectationMax_[tId][id]) l_expectationMax_[tId][id] = exp;

          if (exp < l_expectationMin_[tId][id]) l_expectationMin_[tId][id] = exp;
        }
      }   // end of : if modal (map) not empty

      bool newOne = false;
      bool added  = false;
      bool result = false;
      // for burn in, we need to keep checking on local marginals and not global
      // ones
      // (faster inference)
      // we also don't want to store dbn for observed variables since there will
      // be a
      // huge number of them (probably all of them).
      Size vsize = Size(vertex.size());

      for (Size mod = 0; mod < vsize; mod++) {
        if (vertex[mod] < l_marginalMin_[tId][id][mod]) {
          l_marginalMin_[tId][id][mod] = vertex[mod];
          newOne                       = true;

          if (infE__::storeBNOpt_ && !infE__::evidence_.exists(id)) {
            std::vector< Size > key(3);
            key[0] = id;
            key[1] = mod;
            key[2] = 0;

            if (l_optimalNet_[tId]->insert(key, true)) result = true;
          }
        }

        if (vertex[mod] > l_marginalMax_[tId][id][mod]) {
          l_marginalMax_[tId][id][mod] = vertex[mod];
          newOne                       = true;

          if (infE__::storeBNOpt_ && !infE__::evidence_.exists(id)) {
            std::vector< Size > key(3);
            key[0] = id;
            key[1] = mod;
            key[2] = 1;

            if (l_optimalNet_[tId]->insert(key, true)) result = true;
          }
        } else if (vertex[mod] == l_marginalMin_[tId][id][mod]
                   || vertex[mod] == l_marginalMax_[tId][id][mod]) {
          newOne = true;

          if (infE__::storeBNOpt_ && vertex[mod] == l_marginalMin_[tId][id][mod]
              && !infE__::evidence_.exists(id)) {
            std::vector< Size > key(3);
            key[0] = id;
            key[1] = mod;
            key[2] = 0;

            if (l_optimalNet_[tId]->insert(key, false)) result = true;
          }

          if (infE__::storeBNOpt_ && vertex[mod] == l_marginalMax_[tId][id][mod]
              && !infE__::evidence_.exists(id)) {
            std::vector< Size > key(3);
            key[0] = id;
            key[1] = mod;
            key[2] = 1;

            if (l_optimalNet_[tId]->insert(key, false)) result = true;
          }
        }

        // store point to compute credal set vertices.
        // check for redundancy at each step or at the end ?
        if (infE__::storeVertices_ && !added && newOne) {
          updateThreadCredalSets__(id, vertex, elimRedund);
          added = true;
        }
      }

      // if all variables didn't get better marginals, we will delete
      if (infE__::storeBNOpt_ && result) return true;

      return false;
    }

updateThreadCredalSets__()

template<typename GUM_SCALAR , class BNInferenceEngine >

void gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::updateThreadCredalSets__ ( const NodeId &  id, const std::vector< GUM_SCALAR > &  vertex, const bool &  elimRedund  )

inlineprivate

Ask for redundancy elimination of a node credal set of a calling thread.

Called by updateThread_ if vertices are stored.

Parameters

id	A constant reference to the node id whose credal set is to be checked for redundancy.
vertex	The vertex to add to the credal set.
elimRedund	true if redundancy elimination is to be performed, false otherwise and by default.

Definition at line 192 of file multipleInferenceEngine_tpl.h.

                                                                             {
      int   tId           = getThreadNumber();
      auto& nodeCredalSet = l_marginalSets_[tId][id];
      Size  dsize         = Size(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;

      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    = l_marginalMin_[tId][id].cbegin(),
                     minItEnd = l_marginalMin_[tId][id].cend(),
                     maxIt    = l_marginalMax_[tId][id].cbegin(),
                     maxItEnd = l_marginalMax_[tId][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.
      Size setSize = Size(nodeCredalSet.size());

      LRSWrapper< GUM_SCALAR > lrsWrapper;
      lrsWrapper.setUpV(dsize, setSize);

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

      lrsWrapper.elimRedundVrep();

      l_marginalSets_[tId][id] = lrsWrapper.getOutput();
    }

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 153 of file approximationScheme_inl.h.

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

{ return verbosity_; }

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

                                                                    {
      return marginalSets_[id];
    }

verticesFusion_()

template<typename GUM_SCALAR , class BNInferenceEngine >

void gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::verticesFusion_ ( )

protected

Deprecated:

Fusion of threads vertices.

Definition at line 375 of file multipleInferenceEngine_tpl.h.

                                                                       {
      // don't create threads if there are no vertices saved
      if (!infE__::storeVertices_) return;

#pragma omp parallel
      {
        int  threadId = getThreadNumber();
        Size nsize    = Size(workingSet_[threadId]->size());

#pragma omp for

        for (long i = 0; i < long(nsize); i++) {
          Size tsize = Size(l_marginalMin_.size());

          // go through all threads
          for (long tId = 0; tId < long(tsize); tId++) {
            auto& nodeThreadCredalSet = l_marginalSets_[tId][i];

            // for each vertex, if we are at any opt marginal, add it to the set
            for (const auto& vtx: nodeThreadCredalSet) {
              // we run redundancy elimination at each step
              // because there could be 100000 threads and the set will be so
              // huge
              // ...
              // BUT not if vertices are of dimension 2 ! opt check and equality
              // should be enough
              infE__::updateCredalSets_(i, vtx, (vtx.size() > 2) ? true : false);
            }   // end of : nodeThreadCredalSet
          }     // end of : all threads
        }       // end of : all variables
      }         // end of : parallel region
    }

Member Data Documentation

burn_in_

Size gum::ApproximationScheme::burn_in_

protectedinherited

Number of iterations before checking stopping criteria.

Definition at line 413 of file approximationScheme.h.

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 69 of file inferenceEngine.h.

current_epsilon_

double gum::ApproximationScheme::current_epsilon_

protectedinherited

Current epsilon.

Definition at line 368 of file approximationScheme.h.

current_rate_

double gum::ApproximationScheme::current_rate_

protectedinherited

Current rate.

Definition at line 374 of file approximationScheme.h.

current_state_

ApproximationSchemeSTATE gum::ApproximationScheme::current_state_

protectedinherited

The current state.

Definition at line 383 of file approximationScheme.h.

current_step_

Size gum::ApproximationScheme::current_step_

protectedinherited

The current step.

Definition at line 377 of file approximationScheme.h.

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 142 of file inferenceEngine.h.

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 96 of file inferenceEngine.h.

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 93 of file inferenceEngine.h.

enabled_eps_

bool gum::ApproximationScheme::enabled_eps_

protectedinherited

If true, the threshold convergence is enabled.

Definition at line 392 of file approximationScheme.h.

enabled_max_iter_

bool gum::ApproximationScheme::enabled_max_iter_

protectedinherited

If true, the maximum iterations stopping criterion is enabled.

Definition at line 410 of file approximationScheme.h.

enabled_max_time_

bool gum::ApproximationScheme::enabled_max_time_

protectedinherited

If true, the timeout is enabled.

Definition at line 404 of file approximationScheme.h.

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 398 of file approximationScheme.h.

eps_

double gum::ApproximationScheme::eps_

protectedinherited

Threshold for convergence.

Definition at line 389 of file approximationScheme.h.

evidence_

template<typename GUM_SCALAR >

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

protectedinherited

Holds observed variables states.

Definition at line 102 of file inferenceEngine.h.

expectationMax_

template<typename GUM_SCALAR >

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

protectedinherited

Upper expectations, if some variables modalities were inserted.

Definition at line 89 of file inferenceEngine.h.

expectationMin_

template<typename GUM_SCALAR >

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

protectedinherited

Lower expectations, if some variables modalities were inserted.

Definition at line 86 of file inferenceEngine.h.

history_

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

protectedinherited

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

Definition at line 386 of file approximationScheme.h.

l_clusters_

template<typename GUM_SCALAR , class BNInferenceEngine >

clusters__ gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::l_clusters_

protected

Threads clusters.

Definition at line 107 of file multipleInferenceEngine.h.

l_evidence_

template<typename GUM_SCALAR , class BNInferenceEngine >

margis__ gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::l_evidence_

protected

Threads evidence.

Definition at line 105 of file multipleInferenceEngine.h.

l_expectationMax_

template<typename GUM_SCALAR , class BNInferenceEngine >

expes__ gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::l_expectationMax_

protected

Threads upper expectations, one per thread.

Definition at line 99 of file multipleInferenceEngine.h.

l_expectationMin_

template<typename GUM_SCALAR , class BNInferenceEngine >

expes__ gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::l_expectationMin_

protected

Threads lower expectations, one per thread.

Definition at line 97 of file multipleInferenceEngine.h.

l_inferenceEngine_

template<typename GUM_SCALAR , class BNInferenceEngine >

std::vector< BNInferenceEngine* > gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::l_inferenceEngine_

protected

Threads BNInferenceEngine.

Definition at line 115 of file multipleInferenceEngine.h.

l_marginalMax_

template<typename GUM_SCALAR , class BNInferenceEngine >

margis__ gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::l_marginalMax_

protected

Threads upper marginals, one per thread.

Definition at line 95 of file multipleInferenceEngine.h.

l_marginalMin_

template<typename GUM_SCALAR , class BNInferenceEngine >

margis__ gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::l_marginalMin_

protected

Threads lower marginals, one per thread.

Definition at line 93 of file multipleInferenceEngine.h.

l_marginalSets_

template<typename GUM_SCALAR , class BNInferenceEngine >

credalSets__ gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::l_marginalSets_

protected

Threads vertices.

Definition at line 103 of file multipleInferenceEngine.h.

l_modal_

template<typename GUM_SCALAR , class BNInferenceEngine >

modals__ gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::l_modal_

protected

Threads modalities.

Definition at line 101 of file multipleInferenceEngine.h.

l_optimalNet_

template<typename GUM_SCALAR , class BNInferenceEngine >

std::vector< VarMod2BNsMap< GUM_SCALAR >* > gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::l_optimalNet_

protected

Threads optimal IBayesNet.

Definition at line 117 of file multipleInferenceEngine.h.

last_epsilon_

double gum::ApproximationScheme::last_epsilon_

protectedinherited

Last epsilon value.

Definition at line 371 of file approximationScheme.h.

marginalMax_

template<typename GUM_SCALAR >

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

protectedinherited

Upper marginals.

Definition at line 79 of file inferenceEngine.h.

marginalMin_

template<typename GUM_SCALAR >

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

protectedinherited

Lower marginals.

Definition at line 77 of file inferenceEngine.h.

marginalSets_

template<typename GUM_SCALAR >

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

protectedinherited

Credal sets vertices, if enabled.

Definition at line 82 of file inferenceEngine.h.

max_iter_

Size gum::ApproximationScheme::max_iter_

protectedinherited

The maximum iterations.

Definition at line 407 of file approximationScheme.h.

max_time_

double gum::ApproximationScheme::max_time_

protectedinherited

The timeout.

Definition at line 401 of file approximationScheme.h.

min_rate_eps_

double gum::ApproximationScheme::min_rate_eps_

protectedinherited

Threshold for the epsilon rate.

Definition at line 395 of file approximationScheme.h.

modal_

template<typename GUM_SCALAR >

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

protectedinherited

Variables modalities used to compute expectations.

Definition at line 99 of file inferenceEngine.h.

oldMarginalMax_

template<typename GUM_SCALAR >

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

protectedinherited

Old upper marginals used to compute epsilon.

Definition at line 74 of file inferenceEngine.h.

oldMarginalMin_

template<typename GUM_SCALAR >

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

protectedinherited

Old lower marginals used to compute epsilon.

Definition at line 72 of file inferenceEngine.h.

onProgress

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

inherited

Progression, error and time.

Definition at line 58 of file IApproximationSchemeConfiguration.h.

onStop

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

inherited

Criteria messageApproximationScheme.

Definition at line 61 of file IApproximationSchemeConfiguration.h.

period_size_

Size gum::ApproximationScheme::period_size_

protectedinherited

Checking criteria frequency.

Definition at line 416 of file approximationScheme.h.

query_

template<typename GUM_SCALAR >

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

protectedinherited

Holds the query nodes states.

Definition at line 104 of file inferenceEngine.h.

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 128 of file inferenceEngine.h.

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 138 of file inferenceEngine.h.

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 124 of file inferenceEngine.h.

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 112 of file inferenceEngine.h.

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 119 of file inferenceEngine.h.

timer_

Timer gum::ApproximationScheme::timer_

protectedinherited

The timer.

Definition at line 380 of file approximationScheme.h.

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 149 of file inferenceEngine.h.

verbosity_

bool gum::ApproximationScheme::verbosity_

protectedinherited

If true, verbosity is enabled.

Definition at line 419 of file approximationScheme.h.

workingSet_

template<typename GUM_SCALAR , class BNInferenceEngine >

std::vector< bnet__* > gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::workingSet_

protected

Threads IBayesNet.

Definition at line 110 of file multipleInferenceEngine.h.

workingSetE_

template<typename GUM_SCALAR , class BNInferenceEngine >

std::vector< List< const Potential< GUM_SCALAR >* >* > gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::workingSetE_

protected

Threads evidence.

Definition at line 112 of file multipleInferenceEngine.h.

---

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

• agrum/CN/inference/multipleInferenceEngine.h
• agrum/CN/inference/multipleInferenceEngine_tpl.h