<agrum/PRM/structuredInference.h> More...

#include <structuredInference.h>

Inheritance diagram for gum::prm::StructuredInference< GUM_SCALAR >:

Collaboration diagram for gum::prm::StructuredInference< GUM_SCALAR >:

Classes
struct	RGData
	Private structure to represent data about a reduced graph. More...
struct	PData
	Private structure to represent data about a pattern. More...
struct	CData
	Private structure to represent data about a Class<GUM_SCALAR>. More...

Public Types
using	Chain = std::pair< const PRMInstance< GUM_SCALAR >, const PRMAttribute< GUM_SCALAR > >
	Code alias.
using	EMap = NodeProperty< const Tensor< GUM_SCALAR >* >
	Code alias.
using	EMapIterator = typename NodeProperty< const Tensor< GUM_SCALAR >* >::iterator_safe
	Code alias.
using	EMapConstIterator
	Code alias.

Public Member Functions
std::string	info () const
Constructor & destructor.
	StructuredInference (const PRM< GUM_SCALAR > &prm, const PRMSystem< GUM_SCALAR > &system, gspan::SearchStrategy< GUM_SCALAR > *strategy=0)
	Default constructor.
	StructuredInference (const StructuredInference &source)
	Copy constructor.
virtual	~StructuredInference ()
	Destructor.
StructuredInference &	operator= (const StructuredInference &source)
	Copy operator.
Getters and setters.
void	setPatternMining (bool b)
	Tells this algorithm to use pattern mining or not.
virtual std::string	name () const
	Tells this algorithm to use pattern mining or not.
GSpan< GUM_SCALAR > &	gspan ()
	Returns the instance of gspan used to search patterns.
const GSpan< GUM_SCALAR > &	gspan () const
	Returns the instance of gspan used to search patterns.
void	searchPatterns ()
	Search for patterns without doing any computations.
Query methods.
void	posterior (const Chain &chain, Tensor< GUM_SCALAR > &m)
	Compute the posterior of the formal attribute pointed by chain and stores it in m.
void	joint (const std::vector< Chain > &chains, Tensor< GUM_SCALAR > &j)
	Compute the joint probability of the formals attributes pointed by chains and stores it in m.
Evidence handling.
EMap &	evidence (const PRMInstance< GUM_SCALAR > &i)
	Returns EMap of evidences over i.
EMap &	evidence (const PRMInstance< GUM_SCALAR > *i)
	Returns EMap of evidences over i.
const EMap &	evidence (const PRMInstance< GUM_SCALAR > &i) const
	Returns EMap of evidences over i.
const EMap &	evidence (const PRMInstance< GUM_SCALAR > *i) const
	Returns EMap of evidences over i.
bool	hasEvidence (const PRMInstance< GUM_SCALAR > &i) const
	Returns true if i has evidence.
bool	hasEvidence (const PRMInstance< GUM_SCALAR > *i) const
	Returns EMap of evidences over i.
bool	hasEvidence (const Chain &chain) const
	Returns true if i has evidence on PRMAttribute<GUM_SCALAR> a.
bool	hasEvidence () const
	Returns true if i has evidence on PRMAttribute<GUM_SCALAR> a.
void	addEvidence (const Chain &chain, const Tensor< GUM_SCALAR > &p)
	Add an evidence to the given instance's elt.
void	removeEvidence (const Chain &chain)
	Remove evidence on the given instance's elt.
void	clearEvidence ()
	Remove all evidences.

Public Attributes
Timer	timer
Timer	plopTimer
double	triang_time
double	mining_time
double	pattern_time
double	inner_time
double	obs_time
double	full_time

Protected Member Functions
Protected members.
virtual void	evidenceAdded_ (const typename PRMInference< GUM_SCALAR >::Chain &chain)
	See PRMInference::evidenceAdded_().
virtual void	evidenceRemoved_ (const typename PRMInference< GUM_SCALAR >::Chain &chain)
	See PRMInference::evidenceRemoved_().
virtual void	posterior_ (const typename PRMInference< GUM_SCALAR >::Chain &chain, Tensor< GUM_SCALAR > &m)
	See PRMInference::posterior_().
virtual void	joint_ (const std::vector< typename PRMInference< GUM_SCALAR >::Chain > &queries, Tensor< GUM_SCALAR > &j)
	See PRMInference::joint_().

Private Member Functions
void	_buildReduceGraph_ (RGData &data)
	This calls reducePattern() over each pattern and then build the reduced graph which is used for inference. The reduce graph is a triangulated instance graph.
void	_addEdgesInReducedGraph_ (RGData &data)
	Add the nodes in the reduced graph.
void	_removeNode_ (typename StructuredInference::PData &data, NodeId id, Set< Tensor< GUM_SCALAR > * > &pool)
void	_reduceAloneInstances_ (RGData &data)
	Add the reduced tensors of instances not in any used patterns.
void	_reducePattern_ (const gspan::Pattern *p)
	Proceed with the elimination of all inner variables (observed or not) of all usable matches of Pattern p. Inner variables which are part of the query are not eliminated.
void	_buildPatternGraph_ (PData &data, Set< Tensor< GUM_SCALAR > * > &pool, const Sequence< PRMInstance< GUM_SCALAR > * > &match)
	Build the DAG corresponding to Pattern data.pattern, initialize pool with all the Tensors of all variables in data.pattern. The first match of data.pattern (aka data.match) is used.
void	_insertNodeInElimLists_ (typename StructuredInference::PData &data, const Sequence< PRMInstance< GUM_SCALAR > * > &match, PRMInstance< GUM_SCALAR > inst, PRMAttribute< GUM_SCALAR > attr, NodeId id, std::pair< Idx, std::string > &v)
bool	_allInstanceNoRefAttr_ (typename StructuredInference::PData &data, std::pair< Idx, std::string > attr)
void	_removeBarrenNodes_ (typename StructuredInference::PData &data, Set< Tensor< GUM_SCALAR > * > &pool)
Set< Tensor< GUM_SCALAR > * > *	_eliminateObservedNodes_ (typename StructuredInference::PData &data, const Set< Tensor< GUM_SCALAR > * > &pool, const Sequence< PRMInstance< GUM_SCALAR > * > &match, const std::vector< NodeId > &elim_order)
	Add in data.queries() any queried variable in one of data.pattern matches.
Set< Tensor< GUM_SCALAR > * > *	_eliminateObservedNodesInSource_ (typename StructuredInference::PData &data, const Set< Tensor< GUM_SCALAR > * > &pool, const Sequence< PRMInstance< GUM_SCALAR > * > &match, const std::vector< NodeId > &elim_order)
Set< Tensor< GUM_SCALAR > * > *	_translatePotSet_ (typename StructuredInference::PData &data, const Set< Tensor< GUM_SCALAR > * > &pool, const Sequence< PRMInstance< GUM_SCALAR > * > &match)
	Translate a given Tensor Set into one w.r.t. variables in match.
std::string	_str_ (const PRMInstance< GUM_SCALAR > i, const PRMAttribute< GUM_SCALAR > a) const
std::string	_str_ (const PRMInstance< GUM_SCALAR > *i, const PRMAttribute< GUM_SCALAR > &a) const
std::string	_str_ (const PRMInstance< GUM_SCALAR > *i, const PRMSlotChain< GUM_SCALAR > &a) const

Private Attributes
GSpan< GUM_SCALAR > *	_gspan_
	Pointer over th GSpan<GUM_SCALAR> instance used by this class.
HashTable< const Sequence< PRMInstance< GUM_SCALAR > * > , Set< Tensor< GUM_SCALAR > > * >	_elim_map_
	Mapping between a Pattern's match and its tensor pool after inner variables were eliminated.
HashTable< const PRMClass< GUM_SCALAR > , CData >	_cdata_map_
	Mapping between a Class<GUM_SCALAR> and data about instances reduced using only Class<GUM_SCALAR> level information.
Set< Tensor< GUM_SCALAR > * >	_trash_
	Keeping track of create tensors to delete them after inference.
HashTable< const PRMClass< GUM_SCALAR > , std::vector< NodeId > >	_outputs_
Set< const PRMInstance< GUM_SCALAR > * >	_reducedInstances_
	This keeps track of reduced instances.
PRMInference< GUM_SCALAR >::Chain	_query_
	The query.
PData *	_pdata_
	The pattern data of the pattern which one of its matches contains the query.
bool	_mining_
	Flag which tells to use pattern mining or not.
bool	_found_query_
	Flag with an explicit name.
std::pair< Idx, std::string >	_query_data_
std::string	_dot_
	Unreduce the match containing the query.

Private evidence handling methods and members.
HashTable< const PRMInstance< GUM_SCALAR > , EMap >	_evidences_
	Mapping of evidence over PRMInstance<GUM_SCALAR>'s nodes.
EMap &	_EMap_ (const PRMInstance< GUM_SCALAR > *i)
	Private getter over evidences, if necessary creates an EMap for i.
using	EvidenceIterator
	Code alias.
using	EvidenceConstIterator
	Code alias.

Protected members.
virtual void	evidenceAdded_ (const Chain &chain)=0
	This method is called whenever an evidence is added, but AFTER any processing made by PRMInference.
virtual void	evidenceRemoved_ (const Chain &chain)=0
	This method is called whenever an evidence is removed, but BEFORE any processing made by PRMInference.
virtual void	posterior_ (const Chain &chain, Tensor< GUM_SCALAR > &m)=0
	Generic method to compute the posterior of given element.
virtual void	joint_ (const std::vector< Chain > &queries, Tensor< GUM_SCALAR > &j)=0
	Generic method to compute the posterior of given element.
PRM< GUM_SCALAR > const *	prm_
	The PRM<GUM_SCALAR> on which inference is done.
PRMSystem< GUM_SCALAR > const *	sys_
	The Model on which inference is done.

Detailed Description

template<typename GUM_SCALAR>
class gum::prm::StructuredInference< GUM_SCALAR >

This PRM<GUM_SCALAR> inference algorithm exploits the GSpan<GUM_SCALAR> algorithm to discover new patters and exploit them in a structured way.

Definition at line 69 of file structuredInference.h.

Member Typedef Documentation

◆ Chain

template<typename GUM_SCALAR>

using gum::prm::PRMInference< GUM_SCALAR >::Chain = std::pair< const PRMInstance< GUM_SCALAR >*, const PRMAttribute< GUM_SCALAR >* >

inherited

Code alias.

Definition at line 71 of file PRMInference.h.

◆ EMap

template<typename GUM_SCALAR>

using gum::prm::PRMInference< GUM_SCALAR >::EMap = NodeProperty< const Tensor< GUM_SCALAR >* >

inherited

Code alias.

Definition at line 74 of file PRMInference.h.

◆ EMapConstIterator

template<typename GUM_SCALAR>

using gum::prm::PRMInference< GUM_SCALAR >::EMapConstIterator

inherited

Initial value:

typename NodeProperty< const Tensor< GUM_SCALAR >* >::const_iterator_safe

gum::NodeProperty

HashTable< NodeId, VAL > NodeProperty

Property on graph elements.

Definition graphElements.h:395

Code alias.

Definition at line 80 of file PRMInference.h.

◆ EMapIterator

template<typename GUM_SCALAR>

using gum::prm::PRMInference< GUM_SCALAR >::EMapIterator = typename NodeProperty< const Tensor< GUM_SCALAR >* >::iterator_safe

inherited

Code alias.

Definition at line 77 of file PRMInference.h.

◆ EvidenceConstIterator

template<typename GUM_SCALAR>

using gum::prm::PRMInference< GUM_SCALAR >::EvidenceConstIterator

privateinherited

Initial value:

typename HashTable< const PRMInstance< GUM_SCALAR >*, EMap* >::const_iterator_safe

gum::HashTable

The class for generic Hash Tables.

Definition hashTable.h:637

gum::prm::PRMInference::EMap

NodeProperty< const Tensor< GUM_SCALAR > * > EMap

Code alias.

Definition PRMInference.h:74

Code alias.

Definition at line 241 of file PRMInference.h.

◆ EvidenceIterator

template<typename GUM_SCALAR>

using gum::prm::PRMInference< GUM_SCALAR >::EvidenceIterator

privateinherited

Initial value:

typename HashTable< const PRMInstance< GUM_SCALAR >*, EMap* >::iterator_safe

Code alias.

Definition at line 238 of file PRMInference.h.

Constructor & Destructor Documentation

◆ StructuredInference() [1/2]

template<typename GUM_SCALAR>

gum::prm::StructuredInference< GUM_SCALAR >::StructuredInference	(	const PRM< GUM_SCALAR > &	prm,
		const PRMSystem< GUM_SCALAR > &	system,
		gspan::SearchStrategy< GUM_SCALAR > *	strategy = 0 )

Default constructor.

Definition at line 56 of file structuredInference_tpl.h.

                                                     :
        PRMInference< GUM_SCALAR >(prm, system), _gspan_(0), _pdata_(0), _mining_(false),
        _dot_(".") {
      GUM_CONSTRUCTOR(StructuredInference);
      _gspan_      = new GSpan< GUM_SCALAR >(prm, system, strategy);
      triang_time  = 0.0;
      mining_time  = 0.0;
      pattern_time = 0.0;
      inner_time   = 0.0;
      obs_time     = 0.0;
      full_time    = 0.0;
    }

References gum::prm::PRMInference< GUM_SCALAR >::PRMInference(), StructuredInference(), _dot_, _gspan_, _mining_, _pdata_, full_time, inner_time, mining_time, obs_time, pattern_time, and triang_time.

Referenced by StructuredInference(), StructuredInference(), ~StructuredInference(), and operator=().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ StructuredInference() [2/2]

template<typename GUM_SCALAR>

gum::prm::StructuredInference< GUM_SCALAR >::StructuredInference ( const StructuredInference< GUM_SCALAR > & source )

Copy constructor.

Definition at line 73 of file structuredInference_tpl.h.

                                                         :
        PRMInference< GUM_SCALAR >(source), _gspan_(0), _pdata_(0), _mining_(source._mining_),
        _found_query_(false), _dot_(".") {
      GUM_CONS_CPY(StructuredInference);
      _gspan_ = new GSpan< GUM_SCALAR >(*(this->prm_), *(this->sys_));
    }

References gum::prm::PRMInference< GUM_SCALAR >::PRMInference(), StructuredInference(), _dot_, _found_query_, _gspan_, _mining_, _pdata_, gum::prm::PRMInference< GUM_SCALAR >::prm_, and gum::prm::PRMInference< GUM_SCALAR >::sys_.

Here is the call graph for this function:

◆ ~StructuredInference()

template<typename GUM_SCALAR>

gum::prm::StructuredInference< GUM_SCALAR >::~StructuredInference ( )

virtual

Destructor.

Definition at line 82 of file structuredInference_tpl.h.

                                                            {
      GUM_DESTRUCTOR(StructuredInference);
      delete this->_gspan_;
 
      for (const auto& elt: _elim_map_)
        delete elt.second;
 
      for (const auto& elt: _cdata_map_)
        delete elt.second;
 
      for (const auto elt: _trash_)
        delete (elt);
 
      for (const auto& elt: _outputs_)
        delete elt.second;
 
      if (_pdata_) delete _pdata_;
    }

References StructuredInference(), _cdata_map_, _elim_map_, _gspan_, _outputs_, _pdata_, and _trash_.

Here is the call graph for this function:

Member Function Documentation

◆ _addEdgesInReducedGraph_()

template<typename GUM_SCALAR>

void gum::prm::StructuredInference< GUM_SCALAR >::_addEdgesInReducedGraph_ ( RGData & data )

private

Add the nodes in the reduced graph.

Add edges in the reduced graph.

Definition at line 709 of file structuredInference_tpl.h.

                                                                {
      // We first add edges between variables already in pool (i.e. those of the
      // reduced instances)
      NodeId id_1, id_2;
 
      for (const auto pot: data.pool) {
        const Sequence< const DiscreteVariable* >& vars = pot->variablesSequence();
 
        for (Size var_1 = 0; var_1 < vars.size(); ++var_1) {
          if (data.var2node.existsFirst(vars.atPos(var_1))) {
            id_1 = data.var2node.second(vars.atPos(var_1));
          } else {
            id_1 = data.reducedGraph.addNode();
            data.var2node.insert(vars.atPos(var_1), id_1);
            data.mods.insert(id_1, vars.atPos(var_1)->domainSize());
            data.outputs().insert(id_1);
          }
 
          for (Size var_2 = var_1 + 1; var_2 < vars.size(); ++var_2) {
            if (data.var2node.existsFirst(vars.atPos(var_2))) {
              id_2 = data.var2node.second(vars.atPos(var_2));
            } else {
              id_2 = data.reducedGraph.addNode();
              data.var2node.insert(vars.atPos(var_2), id_2);
              data.mods.insert(id_2, vars.atPos(var_2)->domainSize());
              data.outputs().insert(id_2);
            }
 
            try {
              data.reducedGraph.addEdge(id_1, id_2);
            } catch (DuplicateElement const&) {}
          }
        }
      }
 
      // Adding tensors obtained from reduced patterns
      for (const auto& elt: _elim_map_) {
        // We add edges between variables in the same reduced patterns
        for (const auto pot: *elt.second) {
          data.pool.insert(pot);
          const Sequence< const DiscreteVariable* >& vars = pot->variablesSequence();
 
          for (Size var_1 = 0; var_1 < vars.size(); ++var_1) {
            if (data.var2node.existsFirst(vars.atPos(var_1))) {
              id_1 = data.var2node.second(vars.atPos(var_1));
            } else {
              id_1 = data.reducedGraph.addNode();
              data.var2node.insert(vars.atPos(var_1), id_1);
              data.mods.insert(id_1, vars.atPos(var_1)->domainSize());
              data.outputs().insert(id_1);
            }
 
            for (Size var_2 = var_1 + 1; var_2 < vars.size(); ++var_2) {
              if (data.var2node.existsFirst(vars.atPos(var_2))) {
                id_2 = data.var2node.second(vars.atPos(var_2));
              } else {
                id_2 = data.reducedGraph.addNode();
                data.var2node.insert(vars.atPos(var_2), id_2);
                data.mods.insert(id_2, vars.atPos(var_2)->domainSize());
                data.outputs().insert(id_2);
              }
 
              try {
                data.reducedGraph.addEdge(id_1, id_2);
              } catch (DuplicateElement const&) {}
            }
          }
        }
      }
    }

References _elim_map_, gum::UndiGraph::addEdge(), gum::NodeGraphPart::addNode(), gum::SequenceImplementation< Key, Gen >::atPos(), gum::Set< Key >::insert(), gum::prm::StructuredInference< GUM_SCALAR >::RGData::mods, gum::prm::StructuredInference< GUM_SCALAR >::RGData::outputs(), gum::prm::StructuredInference< GUM_SCALAR >::RGData::pool, gum::prm::StructuredInference< GUM_SCALAR >::RGData::reducedGraph, gum::SequenceImplementation< Key, Gen >::size(), and gum::prm::StructuredInference< GUM_SCALAR >::RGData::var2node.

Referenced by _buildReduceGraph_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _allInstanceNoRefAttr_()

template<typename GUM_SCALAR>

bool gum::prm::StructuredInference< GUM_SCALAR >::_allInstanceNoRefAttr_	(	typename StructuredInference< GUM_SCALAR >::PData &	data,
		std::pair< Idx, std::string >	attr )

private

Definition at line 403 of file structuredInference_tpl.h.

                                                             {
      for (const auto mat: data.matches)
        if (mat->atPos(attr.first)->hasRefAttr(mat->atPos(attr.first)->get(attr.second).id()))
          return false;
 
      return true;
    }

References gum::prm::StructuredInference< GUM_SCALAR >::PData::matches.

Referenced by _buildPatternGraph_().

Here is the caller graph for this function:

◆ _buildPatternGraph_()

template<typename GUM_SCALAR>

void gum::prm::StructuredInference< GUM_SCALAR >::_buildPatternGraph_	(	PData &	data,
		Set< Tensor< GUM_SCALAR > * > &	pool,
		const Sequence< PRMInstance< GUM_SCALAR > * > &	match )

private

Build the DAG corresponding to Pattern data.pattern, initialize pool with all the Tensors of all variables in data.pattern. The first match of data.pattern (aka data.match) is used.

Definition at line 348 of file structuredInference_tpl.h.

                                                                  {
      std::pair< Idx, std::string > v;
      Tensor< GUM_SCALAR >*         pot = 0;
 
      for (const auto inst: match) {
        for (const auto& elt: *inst) {
          NodeId id = data.graph.addNode();
          v         = std::make_pair(match.pos(inst), elt.second->safeName());
          data.map.insert(id, v);
          data.node2attr.insert(id, _str_(inst, elt.second));
          data.mod.insert(id, elt.second->type()->domainSize());
          data.vars.insert(id, &(elt.second->type().variable()));
          pool.insert(const_cast< Tensor< GUM_SCALAR >* >(&(elt.second->cpf())));
          pot = &(const_cast< Tensor< GUM_SCALAR >& >(inst->get(v.second).cpf()));
 
          for (const auto var: pot->variablesSequence()) {
            try {
              if (id != data.vars.first(var)) data.graph.addEdge(id, data.vars.first(var));
            } catch (DuplicateElement const&) {
            } catch (NotFound const&) {}
          }
 
          _insertNodeInElimLists_(data, match, inst, elt.second, id, v);
 
          if (data.inners().exists(id)
              && (inst->type().containerDag().children(elt.second->id()).size() == 0)
              && _allInstanceNoRefAttr_(data, v))
            data.barren.insert(id);
        }
      }
 
      if (!_found_query_) {
        for (const auto mat: data.matches) {
          if (mat->exists(const_cast< PRMInstance< GUM_SCALAR >* >(_query_.first))) {
            Idx pos = mat->pos(const_cast< PRMInstance< GUM_SCALAR >* >(_query_.first));
            DiscreteVariable& var
                = match.atPos(pos)->get(_query_.second->safeName()).type().variable();
            NodeId id = data.vars.first(&var);
            data.barren.erase(id);
            data.inners().erase(id);
            data.obs().erase(id);
            data.outputs().erase(id);
            data.queries().insert(id);
            _found_query_ = true;
            _query_data_  = std::make_pair(pos, _query_.second->safeName());
            break;
          }
        }
      }
    }

Referenced by _reducePattern_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _buildReduceGraph_()

template<typename GUM_SCALAR>

void gum::prm::StructuredInference< GUM_SCALAR >::_buildReduceGraph_ ( RGData & data )

private

This calls reducePattern() over each pattern and then build the reduced graph which is used for inference. The reduce graph is a triangulated instance graph.

Definition at line 224 of file structuredInference_tpl.h.

                                                                {
      // Launch the pattern mining
      plopTimer.reset();
 
      if (_mining_) _gspan_->discoverPatterns();
 
      mining_time = plopTimer.step();
      // Reducing each used pattern
      plopTimer.reset();
      using Iter = std::vector< gspan::Pattern* >::const_iterator;
 
      for (Iter p = _gspan_->patterns().begin(); p != _gspan_->patterns().end(); ++p)
        if (_gspan_->matches(**p).size()) _reducePattern_(*p);
 
      pattern_time = plopTimer.step();
      // reducing instance not already reduced in a pattern
      _reduceAloneInstances_(data);
      // Adding edges using the pools
      _addEdgesInReducedGraph_(data);
      // Placing the query where it belongs
      NodeId id = data.var2node.second(&(_query_.second->type().variable()));
      data.outputs().erase(id);
      data.queries().insert(id);
      // Triangulating, then eliminating
      PartialOrderedTriangulation  t(&(data.reducedGraph), &(data.mods), &(data.partial_order));
      const std::vector< NodeId >& elim_order = t.eliminationOrder();
 
      for (size_t i = 0; i < data.outputs().size(); ++i)
        eliminateNode(data.var2node.first(elim_order[i]), data.pool, _trash_);
    }

References _addEdgesInReducedGraph_(), _gspan_, _mining_, _query_, _reduceAloneInstances_(), _reducePattern_(), _trash_, gum::prm::eliminateNode(), gum::StaticTriangulation::eliminationOrder(), gum::Set< Key >::erase(), gum::Set< Key >::insert(), mining_time, gum::prm::StructuredInference< GUM_SCALAR >::RGData::mods, gum::prm::StructuredInference< GUM_SCALAR >::RGData::outputs(), gum::prm::StructuredInference< GUM_SCALAR >::RGData::partial_order, pattern_time, plopTimer, gum::prm::StructuredInference< GUM_SCALAR >::RGData::pool, gum::prm::StructuredInference< GUM_SCALAR >::RGData::queries(), gum::prm::StructuredInference< GUM_SCALAR >::RGData::reducedGraph, and gum::prm::StructuredInference< GUM_SCALAR >::RGData::var2node.

Referenced by posterior_(), and searchPatterns().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _eliminateObservedNodes_()

template<typename GUM_SCALAR>

Set< Tensor< GUM_SCALAR > * > * gum::prm::StructuredInference< GUM_SCALAR >::_eliminateObservedNodes_	(	typename StructuredInference< GUM_SCALAR >::PData &	data,
		const Set< Tensor< GUM_SCALAR > * > &	pool,
		const Sequence< PRMInstance< GUM_SCALAR > * > &	match,
		const std::vector< NodeId > &	elim_order )

private

Add in data.queries() any queried variable in one of data.pattern matches.

Proceeds with the elimination of observed variables in math and then call translatePotSet().

Definition at line 487 of file structuredInference_tpl.h.

                                                                     {
      Set< Tensor< GUM_SCALAR >* >* my_pool = _translatePotSet_(data, pool, match);
      std::pair< Idx, std::string > target;
      size_t                        end = data.inners().size() + data.obs().size();
 
      for (size_t idx = data.inners().size(); idx < end; ++idx) {
        target = data.map[data.vars.first(data.vars.second(elim_order[idx]))];
        eliminateNode(&(match[target.first]->get(target.second).type().variable()),
                      *my_pool,
                      _trash_);
      }
 
      return my_pool;
    }

References _translatePotSet_(), _trash_, gum::prm::eliminateNode(), gum::prm::StructuredInference< GUM_SCALAR >::PData::inners(), gum::prm::StructuredInference< GUM_SCALAR >::PData::map, gum::prm::StructuredInference< GUM_SCALAR >::PData::obs(), gum::Set< Key >::size(), and gum::prm::StructuredInference< GUM_SCALAR >::PData::vars.

Referenced by _reducePattern_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _eliminateObservedNodesInSource_()

template<typename GUM_SCALAR>

Set< Tensor< GUM_SCALAR > * > * gum::prm::StructuredInference< GUM_SCALAR >::_eliminateObservedNodesInSource_	(	typename StructuredInference< GUM_SCALAR >::PData &	data,
		const Set< Tensor< GUM_SCALAR > * > &	pool,
		const Sequence< PRMInstance< GUM_SCALAR > * > &	match,
		const std::vector< NodeId > &	elim_order )

private

Definition at line 467 of file structuredInference_tpl.h.

                                                                         {
      Set< Tensor< GUM_SCALAR >* >* my_pool = new Set< Tensor< GUM_SCALAR >* >(pool);
      std::pair< Idx, std::string > target;
      size_t                        end = data.inners().size() + data.obs().size();
 
      for (size_t idx = data.inners().size(); idx < end; ++idx) {
        target = data.map[data.vars.first(data.vars.second(elim_order[idx]))];
        eliminateNode(&(match[target.first]->get(target.second).type().variable()),
                      *my_pool,
                      _trash_);
      }
 
      return my_pool;
    }

References _trash_, gum::prm::eliminateNode(), gum::prm::StructuredInference< GUM_SCALAR >::PData::inners(), gum::prm::StructuredInference< GUM_SCALAR >::PData::map, gum::prm::StructuredInference< GUM_SCALAR >::PData::obs(), gum::Set< Key >::size(), and gum::prm::StructuredInference< GUM_SCALAR >::PData::vars.

Referenced by _reducePattern_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _EMap_()

template<typename GUM_SCALAR>

PRMInference< GUM_SCALAR >::EMap & gum::prm::PRMInference< GUM_SCALAR >::_EMap_ ( const PRMInstance< GUM_SCALAR > * i )

privateinherited

Private getter over evidences, if necessary creates an EMap for i.

Definition at line 116 of file PRMInference_tpl.h.

                                                                             {
      if (_evidences_.exists(i)) {
        return *(_evidences_[i]);
      } else {
        _evidences_.insert(i, new PRMInference< GUM_SCALAR >::EMap());
        return *(_evidences_[i]);
      }
    }

References _evidences_.

Referenced by removeEvidence().

Here is the caller graph for this function:

◆ _insertNodeInElimLists_()

template<typename GUM_SCALAR>

void gum::prm::StructuredInference< GUM_SCALAR >::_insertNodeInElimLists_	(	typename StructuredInference< GUM_SCALAR >::PData &	data,
		const Sequence< PRMInstance< GUM_SCALAR > * > &	match,
		PRMInstance< GUM_SCALAR > *	inst,
		PRMAttribute< GUM_SCALAR > *	attr,
		NodeId	id,
		std::pair< Idx, std::string > &	v )

private

Definition at line 314 of file structuredInference_tpl.h.

                                                          {
      if ((*inst).hasRefAttr((*inst).get(v.second).id())) {
        std::vector< std::pair< PRMInstance< GUM_SCALAR >*, std::string > >& refs
            = inst->getRefAttr(inst->get(v.second).id());
 
        for (auto r = refs.begin(); r != refs.end(); ++r) {
          if (!match.exists(r->first)) {
            data.outputs().insert(id);
            break;
          }
        }
      }
 
      if (!(data.outputs().size() && (data.outputs().exists(id)))) {
        for (const auto m: data.matches) {
          if (this->hasEvidence(std::make_pair((*m)[v.first], &((*m)[v.first]->get(v.second))))) {
            GUM_ASSERT(inst->type().name() == (*m)[v.first]->type().name());
            GUM_ASSERT(inst->get(v.second).safeName() == (*m)[v.first]->get(v.second).safeName());
            data.obs().insert(id);
            break;
          }
        }
 
        if (!(data.obs().size() && (data.obs().exists(id)))) data.inners().insert(id);
      }
    }

References gum::Set< Key >::exists(), gum::prm::PRMInstance< GUM_SCALAR >::get(), gum::prm::PRMInstance< GUM_SCALAR >::getRefAttr(), gum::prm::PRMInference< GUM_SCALAR >::hasEvidence(), gum::prm::StructuredInference< GUM_SCALAR >::PData::inners(), gum::Set< Key >::insert(), gum::prm::StructuredInference< GUM_SCALAR >::PData::matches, gum::prm::StructuredInference< GUM_SCALAR >::PData::obs(), gum::prm::StructuredInference< GUM_SCALAR >::PData::outputs(), gum::Set< Key >::size(), and gum::prm::PRMInstance< GUM_SCALAR >::type().

Referenced by _buildPatternGraph_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _reduceAloneInstances_()

template<typename GUM_SCALAR>

void gum::prm::StructuredInference< GUM_SCALAR >::_reduceAloneInstances_ ( RGData & data )

private

Add the reduced tensors of instances not in any used patterns.

Definition at line 595 of file structuredInference_tpl.h.

                                                                   {
      StructuredInference< GUM_SCALAR >::CData* data = 0;
      Tensor< GUM_SCALAR >*                     pot  = nullptr;
      PRMInstance< GUM_SCALAR >*                inst = nullptr;
 
      for (const auto& elt: *this->sys_) {
        inst = elt.second;
 
        if (!_reducedInstances_.exists(inst)) {
          // Checking if its not an empty class
          if (inst->size()) {
            Set< Tensor< GUM_SCALAR >* > pool;
 
            try {
              data = _cdata_map_[&(inst->type())];
            } catch (NotFound const&) {
              data = new StructuredInference< GUM_SCALAR >::CData(inst->type());
              _cdata_map_.insert(&(inst->type()), data);
            }
 
            data->instances.insert(inst);
            // Filling up the partial ordering
            List< NodeSet > partial_order;
 
            if (data->inners().size()) partial_order.push_back(data->inners());
 
            if (data->aggregators().size())
              for (const auto agg: data->aggregators())
                partial_order[0].insert(agg);
 
            if (data->outputs().size()) partial_order.push_back(data->outputs());
 
            if (_query_.first == inst) {
              // First case, the instance contains the query
              partial_order[0].erase(_query_.second->id());
 
              if (partial_order[0].empty()) partial_order.erase(0);
 
              if (partial_order.size() > 1) {
                partial_order[1].erase(_query_.second->id());
 
                if (partial_order[1].empty()) partial_order.erase(1);
              }
 
              NodeSet query_set;
              query_set.insert(_query_.second->id());
              partial_order.insert(query_set);
 
              // Adding the tensors
              for (auto attr = inst->begin(); attr != inst->end(); ++attr)
                pool.insert(&(const_cast< Tensor< GUM_SCALAR >& >((*(attr.val())).cpf())));
 
              // Adding evidences if any
              if (this->hasEvidence(inst))
                for (const auto& elt: this->evidence(inst))
                  pool.insert(const_cast< Tensor< GUM_SCALAR >* >(elt.second));
 
              PartialOrderedTriangulation  t(&(data->moral_graph), &(data->mods), &(partial_order));
              const std::vector< NodeId >& v = t.eliminationOrder();
 
              if (partial_order.size() > 1)
                for (size_t idx = 0; idx < partial_order[0].size(); ++idx)
                  eliminateNode(&(inst->get(v[idx]).type().variable()), pool, _trash_);
            } else if (this->hasEvidence(inst)) {
              // Second case, the instance has evidences
              // Adding the tensors
              for (const auto& elt: *inst)
                pool.insert(&const_cast< Tensor< GUM_SCALAR >& >(elt.second->cpf()));
 
              // Adding evidences
              for (const auto& elt: this->evidence(inst))
                pool.insert(const_cast< Tensor< GUM_SCALAR >* >(elt.second));
 
              PartialOrderedTriangulation t(&(data->moral_graph), &(data->mods), &(partial_order));
 
              for (size_t idx = 0; idx < partial_order[0].size(); ++idx)
                eliminateNode(&(inst->get(t.eliminationOrder()[idx]).type().variable()),
                              pool,
                              _trash_);
            } else {
              // Last cast, the instance neither contains evidences nor
              // instances
              // We translate the class level tensors into the instance ones
              // and
              // proceed with elimination
              for (const auto srcPot: data->pool) {
                pot = copyTensor(inst->bijection(), *srcPot);
                pool.insert(pot);
                _trash_.insert(pot);
              }
 
              for (const auto agg: data->c.aggregates())
                pool.insert(&(const_cast< Tensor< GUM_SCALAR >& >(inst->get(agg->id()).cpf())));
 
              // We eliminate inner aggregators with their parents if necessary
              // (see
              // CData constructor)
              Size size = data->inners().size() + data->aggregators().size();
 
              for (size_t idx = data->inners().size(); idx < size; ++idx)
                eliminateNode(&(inst->get(data->elim_order()[idx]).type().variable()),
                              pool,
                              _trash_);
            }
 
            for (const auto pot: pool)
              rg_data.pool.insert(pot);
          }
        }
      }
    }

Referenced by _buildReduceGraph_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _reducePattern_()

template<typename GUM_SCALAR>

void gum::prm::StructuredInference< GUM_SCALAR >::_reducePattern_ ( const gspan::Pattern * p )

private

Proceed with the elimination of all inner variables (observed or not) of all usable matches of Pattern p. Inner variables which are part of the query are not eliminated.

Definition at line 257 of file structuredInference_tpl.h.

                                                                                 {
      Set< Tensor< GUM_SCALAR >* >                      pool;
      typename StructuredInference< GUM_SCALAR >::PData data(*p, _gspan_->matches(*p));
      _buildPatternGraph_(data, pool, **(data.matches.begin()));
      _removeBarrenNodes_(data, pool);
      PartialOrderedTriangulation  t(&(data.graph), &(data.mod), data.partial_order());
      const std::vector< NodeId >& elim_order = t.eliminationOrder();
 
      for (size_t i = 0; i < data.inners().size(); ++i)
        if (!data.barren.exists(elim_order[i]))
          eliminateNode(data.vars.second(elim_order[i]), pool, _trash_);
 
      typename GSpan< GUM_SCALAR >::MatchedInstances                 fake_patterns;
      typename GSpan< GUM_SCALAR >::MatchedInstances::const_iterator iter = data.matches.begin();
 
      for (const auto elt: **iter)
        _reducedInstances_.insert(elt);
 
      if (data.obs().size())
        _elim_map_.insert(*iter, _eliminateObservedNodesInSource_(data, pool, **iter, elim_order));
      else _elim_map_.insert(*iter, new Set< Tensor< GUM_SCALAR >* >(pool));
 
      ++iter;
 
      if (data.obs().size()) {
        for (; iter != data.matches.end(); ++iter) {
          try {
            _elim_map_.insert(*iter, _eliminateObservedNodes_(data, pool, **iter, elim_order));
          } catch (OperationNotAllowed const&) { fake_patterns.insert(*iter); }
        }
      } else {
        for (; iter != data.matches.end(); ++iter) {
          try {
            _elim_map_.insert(*iter, _translatePotSet_(data, pool, **iter));
          } catch (OperationNotAllowed const&) { fake_patterns.insert(*iter); }
        }
      }
 
      for (const auto pat: fake_patterns) {
        for (const auto elt: *pat)
          _reducedInstances_.erase(elt);
 
        data.matches.erase(pat);
      }
 
      obs_time += plopTimer.step();
 
      if (data.queries().size())
        for (const auto m: data.matches)
          if (!(m->exists(const_cast< PRMInstance< GUM_SCALAR >* >(_query_.first))))
            eliminateNode(
                &(m->atPos(_query_data_.first)->get(_query_data_.second).type().variable()),
                *(_elim_map_[m]),
                _trash_);
    }

Referenced by _buildReduceGraph_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _removeBarrenNodes_()

template<typename GUM_SCALAR>

void gum::prm::StructuredInference< GUM_SCALAR >::_removeBarrenNodes_	(	typename StructuredInference< GUM_SCALAR >::PData &	data,
		Set< Tensor< GUM_SCALAR > * > &	pool )

private

Definition at line 414 of file structuredInference_tpl.h.

                                                                 {
      Sequence< NodeId > candidates;
 
      for (const auto node: data.barren) {
        for (const auto pot: pool)
          if (pot->contains(*data.vars.second(node))) {
            pool.erase(pot);
            break;
          }
 
        for (const auto nei: data.graph.neighbours(node))
          if (data.inners().exists(nei)) {
            try {
              candidates.insert(nei);
            } catch (DuplicateElement const&) {}
          }
      }
 
      NodeId                node;
      Tensor< GUM_SCALAR >* my_pot = nullptr;
      short                 count  = 0;
 
      while (candidates.size()) {
        node = candidates.back();
        candidates.erase(node);
        count = 0;
 
        for (const auto pot: pool) {
          if (pot->contains(*data.vars.second(node))) {
            ++count;
            my_pot = pot;
          }
        }
 
        if (count == 1) {
          pool.erase(my_pot);
          data.barren.insert(node);
 
          for (const auto nei: data.graph.neighbours(node)) {
            if (data.inners().exists(nei)) {
              try {
                candidates.insert(nei);
              } catch (DuplicateElement const&) {}
            }
          }
        }
      }
    }

References gum::SequenceImplementation< Key, std::is_scalar< Key >::value >::back(), gum::prm::StructuredInference< GUM_SCALAR >::PData::barren, gum::SequenceImplementation< Key, std::is_scalar< Key >::value >::erase(), gum::Set< Key >::exists(), gum::prm::StructuredInference< GUM_SCALAR >::PData::graph, gum::prm::StructuredInference< GUM_SCALAR >::PData::inners(), gum::SequenceImplementation< Key, std::is_scalar< Key >::value >::insert(), gum::Set< Key >::insert(), gum::EdgeGraphPart::neighbours(), gum::SequenceImplementation< Key, std::is_scalar< Key >::value >::size(), and gum::prm::StructuredInference< GUM_SCALAR >::PData::vars.

Referenced by _reducePattern_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _removeNode_()

template<typename GUM_SCALAR>

INLINE void gum::prm::StructuredInference< GUM_SCALAR >::_removeNode_	(	typename StructuredInference< GUM_SCALAR >::PData &	data,
		NodeId	id,
		Set< Tensor< GUM_SCALAR > * > &	pool )

private

Definition at line 987 of file structuredInference_tpl.h.

                                                                 {
      data.graph.eraseNode(id);
      GUM_ASSERT(!data.graph.exists(id));
      data.mod.erase(id);
      GUM_ASSERT(!data.mod.exists(id));
      data.node2attr.eraseFirst(id);
      GUM_ASSERT(!data.node2attr.existsFirst(id));
      data.map.erase(id);
      GUM_ASSERT(!data.map.exists(id));
      data.vars.eraseFirst(id);
      GUM_ASSERT(!data.vars.existsFirst(id));
      data.inners().erase(id);
      GUM_ASSERT(!data.inners().exists(id));
      pool.erase(data.pots[id]);
      GUM_ASSERT(!pool.exists(data.pots[id]));
      data.pots.erase(id);
      GUM_ASSERT(!data.pots.exists(id));
    }

References gum::Set< Key >::erase(), gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::eraseFirst(), gum::UndiGraph::eraseNode(), gum::NodeGraphPart::exists(), gum::Set< Key >::exists(), gum::BijectionImplementation< T1, T2, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::existsFirst(), gum::prm::StructuredInference< GUM_SCALAR >::PData::graph, gum::prm::StructuredInference< GUM_SCALAR >::PData::inners(), gum::prm::StructuredInference< GUM_SCALAR >::PData::map, gum::prm::StructuredInference< GUM_SCALAR >::PData::mod, gum::prm::StructuredInference< GUM_SCALAR >::PData::node2attr, gum::prm::StructuredInference< GUM_SCALAR >::PData::pots, and gum::prm::StructuredInference< GUM_SCALAR >::PData::vars.

Here is the call graph for this function:

◆ _str_() [1/3]

template<typename GUM_SCALAR>

INLINE std::string gum::prm::StructuredInference< GUM_SCALAR >::_str_	(	const PRMInstance< GUM_SCALAR > *	i,
		const PRMAttribute< GUM_SCALAR > &	a ) const

private

Definition at line 949 of file structuredInference_tpl.h.

                                                                                            {
      return i->name() + _dot_ + a.safeName();
    }

References _dot_, gum::prm::PRMObject::name(), and gum::prm::PRMClassElement< GUM_SCALAR >::safeName().

Here is the call graph for this function:

◆ _str_() [2/3]

template<typename GUM_SCALAR>

INLINE std::string gum::prm::StructuredInference< GUM_SCALAR >::_str_	(	const PRMInstance< GUM_SCALAR > *	i,
		const PRMAttribute< GUM_SCALAR > *	a ) const

private

Definition at line 942 of file structuredInference_tpl.h.

                                                                                            {
      return i->name() + _dot_ + a->safeName();
    }

References _dot_, gum::prm::PRMObject::name(), and gum::prm::PRMClassElement< GUM_SCALAR >::safeName().

Referenced by _buildPatternGraph_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _str_() [3/3]

template<typename GUM_SCALAR>

INLINE std::string gum::prm::StructuredInference< GUM_SCALAR >::_str_	(	const PRMInstance< GUM_SCALAR > *	i,
		const PRMSlotChain< GUM_SCALAR > &	a ) const

private

Definition at line 956 of file structuredInference_tpl.h.

                                                                                            {
      return i->name() + _dot_ + a.lastElt().safeName();
    }

References _dot_, gum::prm::PRMSlotChain< GUM_SCALAR >::lastElt(), and gum::prm::PRMObject::name().

Here is the call graph for this function:

◆ _translatePotSet_()

template<typename GUM_SCALAR>

Set< Tensor< GUM_SCALAR > * > * gum::prm::StructuredInference< GUM_SCALAR >::_translatePotSet_	(	typename StructuredInference< GUM_SCALAR >::PData &	data,
		const Set< Tensor< GUM_SCALAR > * > &	pool,
		const Sequence< PRMInstance< GUM_SCALAR > * > &	match )

private

Translate a given Tensor Set into one w.r.t. variables in match.

Definition at line 507 of file structuredInference_tpl.h.

                                                                  {
#ifdef DEBUG
 
      for (const auto iter = data.matches.begin(); iter != data.matches.end(); ++iter) {
        GUM_ASSERT((**iter).size() == match.size());
 
        for (Size idx = 0; idx < match.size(); ++idx) {
          GUM_ASSERT((**iter).atPos(idx)->type() == match.atPos(idx)->type());
        }
      }
 
#endif
      Set< Tensor< GUM_SCALAR >* >* my_pool = new Set< Tensor< GUM_SCALAR >* >();
      std::pair< Idx, std::string > target;
      Bijection< const DiscreteVariable*, const DiscreteVariable* > bij;
      const Sequence< PRMInstance< GUM_SCALAR >* >& source = **(data.matches.begin());
 
      for (Size idx = 0; idx < match.size(); ++idx) {
        _reducedInstances_.insert(match[idx]);
        const auto& chains = source[idx]->type().slotChains();
 
        for (const auto sc: chains) {
#ifdef DEBUG
          GUM_ASSERT(!(sc->isMultiple()));
#endif
 
          try {
            bij.insert(&(source[idx]
                             ->getInstance(sc->id())
                             .get(sc->lastElt().safeName())
                             .type()
                             .variable()),
                       &(match[idx]
                             ->getInstance(sc->id())
                             .get(sc->lastElt().safeName())
                             .type()
                             .variable()));
          } catch (DuplicateElement const&) {
            try {
              if (bij.first(&(match[idx]
                                  ->getInstance(sc->id())
                                  .get(sc->lastElt().safeName())
                                  .type()
                                  .variable()))
                  != &(source[idx]
                           ->getInstance(sc->id())
                           .get(sc->lastElt().safeName())
                           .type()
                           .variable())) {
                delete my_pool;
                GUM_ERROR(OperationNotAllowed, "fake pattern")
              }
            } catch (NotFound const&) {
              delete my_pool;
              GUM_ERROR(OperationNotAllowed, "fake pattern")
            }
          }
        }
      }
 
      for (const auto p: pool) {
        for (const auto v: p->variablesSequence()) {
          try {
            target = data.map[data.vars.first(v)];
            bij.insert(v, &(match[target.first]->get(target.second).type().variable()));
          } catch (NotFound const&) {
            GUM_ASSERT(bij.existsFirst(v));
          } catch (DuplicateElement const&) {}
        }
 
        try {
          my_pool->insert(copyTensor(bij, *p));
        } catch (Exception const&) {
          for (const auto pot: *my_pool)
            delete pot;
 
          delete my_pool;
          GUM_ERROR(OperationNotAllowed, "fake pattern")
        }
      }
 
      return my_pool;
    }

References _reducedInstances_, gum::prm::copyTensor(), gum::BijectionImplementation< T1, T2, Gen >::existsFirst(), gum::BijectionImplementation< T1, T2, Gen >::first(), GUM_ERROR, gum::BijectionImplementation< T1, T2, Gen >::insert(), gum::Set< Key >::insert(), gum::prm::StructuredInference< GUM_SCALAR >::PData::map, gum::prm::StructuredInference< GUM_SCALAR >::PData::matches, and gum::prm::StructuredInference< GUM_SCALAR >::PData::vars.

Referenced by _eliminateObservedNodes_(), and _reducePattern_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addEvidence()

template<typename GUM_SCALAR>

void gum::prm::PRMInference< GUM_SCALAR >::addEvidence	(	const Chain &	chain,
		const Tensor< GUM_SCALAR > &	p )

inherited

Add an evidence to the given instance's elt.

Parameters

chain	The variable being observed.
p	The Tensor added (by copy) as evidence.

Exceptions

NotFound	Raised if elt does not belong to i.
OperationNotAllowed	Raised if p is inconsistent with elt.

Definition at line 126 of file PRMInference_tpl.h.

                                                                                {
      if (chain.first->exists(chain.second->id())) {
        if ((p.nbrDim() != 1) || (!p.contains(chain.second->type().variable())))
          GUM_ERROR(OperationNotAllowed, "illegal evidence for the given PRMAttribute.")
 
        Tensor< GUM_SCALAR >* e = new Tensor< GUM_SCALAR >();
        e->add(chain.second->type().variable());
        Instantiation i(*e);
 
        for (i.setFirst(); !i.end(); i.inc())
          e->set(i, p.get(i));
 
        PRMInference< GUM_SCALAR >::EMap& emap = _EMap_(chain.first);
 
        if (emap.exists(chain.second->id())) {
          delete emap[chain.second->id()];
          emap[chain.second->id()] = e;
        } else {
          emap.insert(chain.second->id(), e);
        }
 
        evidenceAdded_(chain);
      } else {
        GUM_ERROR(NotFound,
                  "the given PRMAttribute does not belong to this "
                  "Instance<GUM_SCALAR>.");
      }
    }

◆ clearEvidence()

template<typename GUM_SCALAR>

void gum::prm::PRMInference< GUM_SCALAR >::clearEvidence ( )

inherited

Remove all evidences.

Definition at line 56 of file PRMInference_tpl.h.

                                                   {
      for (const auto& elt: _evidences_) {
        for (const auto& elt2: *elt.second)
          delete elt2.second;
 
        delete elt.second;
      }
 
      _evidences_.clear();
    }

References _evidences_.

Referenced by operator=().

Here is the caller graph for this function:

◆ evidence() [1/4]

template<typename GUM_SCALAR>

INLINE PRMInference< GUM_SCALAR >::EMap & gum::prm::PRMInference< GUM_SCALAR >::evidence ( const PRMInstance< GUM_SCALAR > & i )

inherited

Returns EMap of evidences over i.

Exceptions

NotFound if i has no evidence.

Definition at line 171 of file PRMInference_tpl.h.

                                                                               {
      try {
        return *(_evidences_[&i]);
      } catch (NotFound const&) { GUM_ERROR(NotFound, "this instance has no evidence.") }
    }

References _evidences_, and GUM_ERROR.

Referenced by gum::prm::SVE< GUM_SCALAR >::_eliminateNodesWithEvidence_(), gum::prm::SVED< GUM_SCALAR >::_eliminateNodesWithEvidence_(), gum::prm::SVE< GUM_SCALAR >::_insertEvidence_(), gum::prm::SVED< GUM_SCALAR >::_insertEvidence_(), gum::prm::StructuredInference< GUM_SCALAR >::_reduceAloneInstances_(), gum::prm::GroundedInference< GUM_SCALAR >::evidenceAdded_(), hasEvidence(), posterior(), and gum::prm::StructuredInference< GUM_SCALAR >::posterior_().

Here is the caller graph for this function:

◆ evidence() [2/4]

template<typename GUM_SCALAR>

INLINE const PRMInference< GUM_SCALAR >::EMap & gum::prm::PRMInference< GUM_SCALAR >::evidence ( const PRMInstance< GUM_SCALAR > & i ) const

inherited

Returns EMap of evidences over i.

Exceptions

NotFound if i has no evidence.

Definition at line 179 of file PRMInference_tpl.h.

                                                                                     {
      try {
        return *(_evidences_[&i]);
      } catch (NotFound const&) { GUM_ERROR(NotFound, "this instance has no evidence.") }
    }

References _evidences_.

◆ evidence() [3/4]

template<typename GUM_SCALAR>

INLINE PRMInference< GUM_SCALAR >::EMap & gum::prm::PRMInference< GUM_SCALAR >::evidence ( const PRMInstance< GUM_SCALAR > * i )

inherited

Returns EMap of evidences over i.

Exceptions

NotFound if i has no evidence.

Definition at line 187 of file PRMInference_tpl.h.

                                                                               {
      try {
        return *(_evidences_[i]);
      } catch (NotFound const&) { GUM_ERROR(NotFound, "this instance has no evidence.") }
    }

◆ evidence() [4/4]

template<typename GUM_SCALAR>

INLINE const PRMInference< GUM_SCALAR >::EMap & gum::prm::PRMInference< GUM_SCALAR >::evidence ( const PRMInstance< GUM_SCALAR > * i ) const

inherited

Returns EMap of evidences over i.

Exceptions

NotFound if i has no evidence.

Definition at line 195 of file PRMInference_tpl.h.

                                                                                     {
      try {
        return *(_evidences_[i]);
      } catch (NotFound const&) { GUM_ERROR(NotFound, "this instance has no evidence.") }
    }

References _evidences_, and GUM_ERROR.

◆ evidenceAdded_() [1/2]

template<typename GUM_SCALAR>

virtual void gum::prm::PRMInference< GUM_SCALAR >::evidenceAdded_ ( const Chain & chain )

protectedpure virtualinherited

This method is called whenever an evidence is added, but AFTER any processing made by PRMInference.

Implemented in gum::prm::SVE< GUM_SCALAR >, and gum::prm::SVED< GUM_SCALAR >.

◆ evidenceAdded_() [2/2]

template<typename GUM_SCALAR>

void gum::prm::StructuredInference< GUM_SCALAR >::evidenceAdded_ ( const typename PRMInference< GUM_SCALAR >::Chain & chain )

protectedvirtual

See PRMInference::evidenceAdded_().

Definition at line 114 of file structuredInference_tpl.h.

115 {}

◆ evidenceRemoved_() [1/2]

template<typename GUM_SCALAR>

virtual void gum::prm::PRMInference< GUM_SCALAR >::evidenceRemoved_ ( const Chain & chain )

protectedpure virtualinherited

This method is called whenever an evidence is removed, but BEFORE any processing made by PRMInference.

Implemented in gum::prm::SVE< GUM_SCALAR >, and gum::prm::SVED< GUM_SCALAR >.

Referenced by removeEvidence().

Here is the caller graph for this function:

◆ evidenceRemoved_() [2/2]

template<typename GUM_SCALAR>

void gum::prm::StructuredInference< GUM_SCALAR >::evidenceRemoved_ ( const typename PRMInference< GUM_SCALAR >::Chain & chain )

protectedvirtual

See PRMInference::evidenceRemoved_().

Definition at line 118 of file structuredInference_tpl.h.

119 {}

◆ gspan() [1/2]

template<typename GUM_SCALAR>

INLINE GSpan< GUM_SCALAR > & gum::prm::StructuredInference< GUM_SCALAR >::gspan ( )

Returns the instance of gspan used to search patterns.

Definition at line 977 of file structuredInference_tpl.h.

                                                                         {
      return *_gspan_;
    }

References _gspan_.

◆ gspan() [2/2]

template<typename GUM_SCALAR>

INLINE const GSpan< GUM_SCALAR > & gum::prm::StructuredInference< GUM_SCALAR >::gspan ( ) const

Returns the instance of gspan used to search patterns.

Definition at line 982 of file structuredInference_tpl.h.

                                                                                     {
      return *_gspan_;
    }

References _gspan_.

◆ hasEvidence() [1/4]

template<typename GUM_SCALAR>

INLINE bool gum::prm::PRMInference< GUM_SCALAR >::hasEvidence ( ) const

inherited

Returns true if i has evidence on PRMAttribute<GUM_SCALAR> a.

Definition at line 217 of file PRMInference_tpl.h.

                                                              {
      return (_evidences_.size() != (Size)0);
    }

References _evidences_.

◆ hasEvidence() [2/4]

template<typename GUM_SCALAR>

INLINE bool gum::prm::PRMInference< GUM_SCALAR >::hasEvidence ( const Chain & chain ) const

inherited

Returns true if i has evidence on PRMAttribute<GUM_SCALAR> a.

Definition at line 212 of file PRMInference_tpl.h.

                                                                                {
      return (hasEvidence(chain.first)) ? evidence(chain.first).exists(chain.second->id()) : false;
    }

References evidence(), and hasEvidence().

Here is the call graph for this function:

◆ hasEvidence() [3/4]

template<typename GUM_SCALAR>

INLINE bool gum::prm::PRMInference< GUM_SCALAR >::hasEvidence ( const PRMInstance< GUM_SCALAR > & i ) const

inherited

Returns true if i has evidence.

Definition at line 202 of file PRMInference_tpl.h.

                                                                                                {
      return _evidences_.exists(&i);
    }

References _evidences_.

Referenced by gum::prm::SVE< GUM_SCALAR >::_eliminateNodes_(), gum::prm::SVED< GUM_SCALAR >::_eliminateNodes_(), gum::prm::SVED< GUM_SCALAR >::_eliminateNodesDownward_(), gum::prm::SVED< GUM_SCALAR >::_eliminateNodesUpward_(), gum::prm::StructuredInference< GUM_SCALAR >::_insertNodeInElimLists_(), gum::prm::StructuredInference< GUM_SCALAR >::_reduceAloneInstances_(), gum::prm::SVE< GUM_SCALAR >::_variableElimination_(), hasEvidence(), posterior(), and gum::prm::StructuredInference< GUM_SCALAR >::posterior_().

Here is the caller graph for this function:

◆ hasEvidence() [4/4]

template<typename GUM_SCALAR>

INLINE bool gum::prm::PRMInference< GUM_SCALAR >::hasEvidence ( const PRMInstance< GUM_SCALAR > * i ) const

inherited

Returns EMap of evidences over i.

Definition at line 207 of file PRMInference_tpl.h.

                                                                                                {
      return _evidences_.exists(i);
    }

References _evidences_.

◆ info()

template<typename GUM_SCALAR>

std::string gum::prm::StructuredInference< GUM_SCALAR >::info ( ) const

Definition at line 200 of file structuredInference_tpl.h.

                                                            {
      std::stringstream s;
      s << "Triangulation time: " << triang_time << std::endl;
      s << "Pattern mining time: " << mining_time << std::endl;
      s << "Pattern elimination time: " << pattern_time << std::endl;
      s << "Inner node elimination time: " << inner_time << std::endl;
      s << "Observed node elimination time: " << obs_time << std::endl;
      s << "Full inference time: " << full_time << std::endl;
      s << "#patterns: " << _gspan_->patterns().size() << std::endl;
      Size count = 0;
      using Iter = std::vector< gspan::Pattern* >::const_iterator;
 
      for (Iter p = _gspan_->patterns().begin(); p != _gspan_->patterns().end(); ++p) {
        if (_gspan_->matches(**p).size()) {
          s << "Pattern n°" << count++ << " match count: " << _gspan_->matches(**p).size()
            << std::endl;
          s << "Pattern n°" << count++ << " instance count: " << (**p).size() << std::endl;
        }
      }
 
      return s.str();
    }

References _gspan_, full_time, inner_time, mining_time, obs_time, pattern_time, and triang_time.

◆ joint()

template<typename GUM_SCALAR>

INLINE void gum::prm::PRMInference< GUM_SCALAR >::joint	(	const std::vector< Chain > &	chains,
		Tensor< GUM_SCALAR > &	j )

inherited

Compute the joint probability of the formals attributes pointed by chains and stores it in m.

Parameters

chains	A Set of strings of the form instance.attribute.
j	An empty CPF which will be filed by the joint probability over chains.

Exceptions

NotFound	Raised if some chain in chains does not point to a formal attribute.
OperationNotAllowed	Raise if m is not empty.

Definition at line 261 of file PRMInference_tpl.h.

                                                                            {
      if (j.nbrDim() > 0) { GUM_ERROR(OperationNotAllowed, "the given Tensor is not empty.") }
 
      for (auto chain = chains.begin(); chain != chains.end(); ++chain) {
        j.add(chain->second->type().variable());
      }
 
      joint_(chains, j);
    }

References GUM_ERROR, and joint_().

Here is the call graph for this function:

◆ joint_() [1/2]

template<typename GUM_SCALAR>

virtual void gum::prm::PRMInference< GUM_SCALAR >::joint_	(	const std::vector< Chain > &	queries,
		Tensor< GUM_SCALAR > &	j )

protectedpure virtualinherited

Generic method to compute the posterior of given element.

Parameters

queries	Set of pairs of PRMInstance<GUM_SCALAR> and PRMAttribute<GUM_SCALAR>.
j	CPF filled with the joint probability of queries. It is initialized properly.

Implemented in gum::prm::SVE< GUM_SCALAR >, and gum::prm::SVED< GUM_SCALAR >.

Referenced by joint().

Here is the caller graph for this function:

◆ joint_() [2/2]

template<typename GUM_SCALAR>

void gum::prm::StructuredInference< GUM_SCALAR >::joint_	(	const std::vector< typename PRMInference< GUM_SCALAR >::Chain > &	queries,
		Tensor< GUM_SCALAR > &	j )

protectedvirtual

See PRMInference::joint_().

Definition at line 193 of file structuredInference_tpl.h.

                                                                            {
      GUM_ERROR(FatalError, "not implemented")
    }

References GUM_ERROR.

◆ name()

template<typename GUM_SCALAR>

INLINE std::string gum::prm::StructuredInference< GUM_SCALAR >::name ( ) const

virtual

Tells this algorithm to use pattern mining or not.

Implements gum::prm::PRMInference< GUM_SCALAR >.

Definition at line 972 of file structuredInference_tpl.h.

                                                                   {
      return "StructuredInference";
    }

◆ operator=()

template<typename GUM_SCALAR>

StructuredInference< GUM_SCALAR > & gum::prm::StructuredInference< GUM_SCALAR >::operator= ( const StructuredInference< GUM_SCALAR > & source )

Copy operator.

Definition at line 102 of file structuredInference_tpl.h.

                                                         {
      this->prm_ = source.prm_;
      this->sys_ = source.sys_;
 
      if (this->_gspan_) delete this->_gspan_;
 
      this->_gspan_ = new GSpan< GUM_SCALAR >(*(this->prm_), *(this->sys_));
      return *this;
    }

References StructuredInference(), _gspan_, gum::prm::PRMInference< GUM_SCALAR >::prm_, and gum::prm::PRMInference< GUM_SCALAR >::sys_.

Here is the call graph for this function:

◆ posterior()

template<typename GUM_SCALAR>

INLINE void gum::prm::PRMInference< GUM_SCALAR >::posterior	(	const Chain &	chain,
		Tensor< GUM_SCALAR > &	m )

inherited

Compute the posterior of the formal attribute pointed by chain and stores it in m.

Parameters

chain	A string of the form instance.attribute.
m	An empty CPF which will be filed by the posterior of chain.

Exceptions

NotFound	Raised if chain is invalid.
TypeError	Raised if chain does not point to an PRMAttribute<GUM_SCALAR>.
OperationNotAllowed	Raise if m is not empty.

Definition at line 235 of file PRMInference_tpl.h.

                                                             {
      if (m.nbrDim() > 0) { GUM_ERROR(OperationNotAllowed, "the given Tensor is not empty.") }
 
      if (hasEvidence(chain)) {
        m.add(chain.second->type().variable());
        const Tensor< GUM_SCALAR >& e = *(evidence(chain.first)[chain.second->id()]);
        Instantiation               i(m), j(e);
 
        for (i.setFirst(), j.setFirst(); !i.end(); i.inc(), j.inc())
          m.set(i, e.get(j));
      } else {
        if (chain.second != &(chain.first->get(chain.second->safeName()))) {
          typename PRMInference< GUM_SCALAR >::Chain good_chain
              = std::make_pair(chain.first, &(chain.first->get(chain.second->safeName())));
          m.add(good_chain.second->type().variable());
          posterior_(good_chain, m);
        } else {
          m.add(chain.second->type().variable());
          posterior_(chain, m);
        }
      }
    }

References gum::prm::PRMInstance< GUM_SCALAR >::end(), evidence(), GUM_ERROR, hasEvidence(), gum::Instantiation::inc(), and gum::Instantiation::setFirst().

Here is the call graph for this function:

◆ posterior_() [1/2]

template<typename GUM_SCALAR>

virtual void gum::prm::PRMInference< GUM_SCALAR >::posterior_	(	const Chain &	chain,
		Tensor< GUM_SCALAR > &	m )

protectedpure virtualinherited

Generic method to compute the posterior of given element.

Parameters

chain
m	CPF filled with the posterior of elt. It is initialized properly.

Implemented in gum::prm::SVE< GUM_SCALAR >, and gum::prm::SVED< GUM_SCALAR >.

◆ posterior_() [2/2]

template<typename GUM_SCALAR>

void gum::prm::StructuredInference< GUM_SCALAR >::posterior_	(	const typename PRMInference< GUM_SCALAR >::Chain &	chain,
		Tensor< GUM_SCALAR > &	m )

protectedvirtual

See PRMInference::posterior_().

Definition at line 122 of file structuredInference_tpl.h.

                                                             {
      timer.reset();
      _found_query_ = false;
      _query_       = chain;
      typename StructuredInference< GUM_SCALAR >::RGData data;
 
      if (!this->hasEvidence() && (chain.second->cpf().nbrDim() == 1)) {
        Instantiation i(m);
 
        for (i.setFirst(); !i.end(); i.inc())
          m.set(i, chain.second->cpf().get(i));
 
        return;
      } else if (this->hasEvidence(chain)) {
        Instantiation               i(m);
        const Tensor< GUM_SCALAR >* e = this->evidence(_query_.first)[_query_.second->id()];
 
        for (i.setFirst(); !i.end(); i.inc())
          m.set(i, e->get(i));
 
        return;
      }
 
      _buildReduceGraph_(data);
      Set< const Tensor< GUM_SCALAR >* > pots;
 
      if (data.pool.size() > 1) {
        for (const auto pot: data.pool)
          if (pot->contains(_query_.second->type().variable())) pots.insert(pot);
 
        if (pots.size() == 1) {
          Tensor< GUM_SCALAR >* pot = const_cast< Tensor< GUM_SCALAR >* >(*(pots.begin()));
          GUM_ASSERT(pot->contains(_query_.second->type().variable()));
          GUM_ASSERT(pot->variablesSequence().size() == 1);
          Instantiation i(*pot), j(m);
 
          for (i.setFirst(), j.setFirst(); !i.end(); i.inc(), j.inc())
            m.set(j, pot->get(i));
        } else {
          MultiDimCombinationDefault< Tensor< GUM_SCALAR > > Comb(multTensor);
          Tensor< GUM_SCALAR >*                              tmp = Comb.execute(pots);
          Instantiation                                      i(m), j(*tmp);
 
          for (i.setFirst(), j.setFirst(); !i.end(); i.inc(), j.inc())
            m.set(i, tmp->get(j));
 
          delete tmp;
        }
      } else {
        Tensor< GUM_SCALAR >* pot = *(data.pool.begin());
        GUM_ASSERT(pot->contains(_query_.second->type().variable()));
        GUM_ASSERT(pot->variablesSequence().size() == 1);
        Instantiation i(*pot), j(m);
 
        for (i.setFirst(), j.setFirst(); !i.end(); i.inc(), j.inc())
          m.set(j, pot->get(i));
      }
 
      m.normalize();
 
      if (_pdata_) {
        delete _pdata_;
        _pdata_ = 0;
      }
 
      full_time = timer.step();
    }

References _buildReduceGraph_(), _found_query_, _pdata_, _query_, gum::Set< Key >::begin(), gum::Instantiation::end(), gum::prm::PRMInference< GUM_SCALAR >::evidence(), gum::MultiDimCombinationDefault< TABLE >::execute(), full_time, gum::prm::PRMInference< GUM_SCALAR >::hasEvidence(), gum::Instantiation::inc(), gum::Set< Key >::insert(), gum::prm::multTensor(), gum::prm::StructuredInference< GUM_SCALAR >::RGData::pool, gum::Instantiation::setFirst(), gum::Set< Key >::size(), and timer.

Here is the call graph for this function:

◆ removeEvidence()

template<typename GUM_SCALAR>

INLINE void gum::prm::PRMInference< GUM_SCALAR >::removeEvidence ( const Chain & chain )

inherited

Remove evidence on the given instance's elt.

Parameters

chain The variable being observed.

Exceptions

NotFound	Raised if the given names are not found.
TypeError	Raised if the elt is not an PRMAttribute<GUM_SCALAR>.

Definition at line 222 of file PRMInference_tpl.h.

                                                                             {
      try {
        if (_EMap_(chain.first).exists(chain.second->id())) {
          evidenceRemoved_(chain);
          delete _EMap_(chain.first)[chain.second->id()];
          _EMap_(chain.first).erase(chain.second->id());
        }
      } catch (NotFound const&) {
        // Ok, we are only removing
      }
    }

References _EMap_(), and evidenceRemoved_().

Here is the call graph for this function:

◆ searchPatterns()

template<typename GUM_SCALAR>

void gum::prm::StructuredInference< GUM_SCALAR >::searchPatterns ( )

Search for patterns without doing any computations.

Definition at line 927 of file structuredInference_tpl.h.

                                                           {
      const PRMInstance< GUM_SCALAR >* i = (this->sys_->begin()).val();
      _query_                            = std::make_pair(i, i->begin().val());
      _found_query_                      = false;
      typename StructuredInference< GUM_SCALAR >::RGData data;
      _buildReduceGraph_(data);
    }

References _buildReduceGraph_(), _found_query_, _query_, gum::prm::PRMInstance< GUM_SCALAR >::begin(), and gum::prm::PRMInference< GUM_SCALAR >::sys_.

Here is the call graph for this function:

◆ setPatternMining()

template<typename GUM_SCALAR>

INLINE void gum::prm::StructuredInference< GUM_SCALAR >::setPatternMining ( bool b )

Tells this algorithm to use pattern mining or not.

Definition at line 936 of file structuredInference_tpl.h.

                                                                          {
      _mining_ = b;
    }

References _mining_.

Member Data Documentation

◆ _cdata_map_

template<typename GUM_SCALAR>

HashTable< const PRMClass< GUM_SCALAR >*, CData* > gum::prm::StructuredInference< GUM_SCALAR >::_cdata_map_

private

Mapping between a Class<GUM_SCALAR> and data about instances reduced using only Class<GUM_SCALAR> level information.

Definition at line 275 of file structuredInference.h.

Referenced by ~StructuredInference(), and _reduceAloneInstances_().

◆ _dot_

template<typename GUM_SCALAR>

std::string gum::prm::StructuredInference< GUM_SCALAR >::_dot_

private

Unreduce the match containing the query.

Used to create strings

Definition at line 378 of file structuredInference.h.

Referenced by StructuredInference(), StructuredInference(), _str_(), _str_(), and _str_().

◆ _elim_map_

template<typename GUM_SCALAR>

HashTable< const Sequence< PRMInstance< GUM_SCALAR >* >*, Set< Tensor< GUM_SCALAR >* >* > gum::prm::StructuredInference< GUM_SCALAR >::_elim_map_

private

Mapping between a Pattern's match and its tensor pool after inner variables were eliminated.

Definition at line 269 of file structuredInference.h.

Referenced by ~StructuredInference(), _addEdgesInReducedGraph_(), and _reducePattern_().

◆ _evidences_

template<typename GUM_SCALAR>

HashTable< const PRMInstance< GUM_SCALAR >*, EMap* > gum::prm::PRMInference< GUM_SCALAR >::_evidences_

privateinherited

Mapping of evidence over PRMInstance<GUM_SCALAR>'s nodes.

Definition at line 245 of file PRMInference.h.

Referenced by PRMInference(), _EMap_(), clearEvidence(), evidence(), evidence(), evidence(), hasEvidence(), hasEvidence(), and hasEvidence().

◆ _found_query_

template<typename GUM_SCALAR>

bool gum::prm::StructuredInference< GUM_SCALAR >::_found_query_

private

Flag with an explicit name.

Definition at line 296 of file structuredInference.h.

Referenced by StructuredInference(), _buildPatternGraph_(), posterior_(), and searchPatterns().

◆ _gspan_

template<typename GUM_SCALAR>

GSpan< GUM_SCALAR >* gum::prm::StructuredInference< GUM_SCALAR >::_gspan_

private

Pointer over th GSpan<GUM_SCALAR> instance used by this class.

Definition at line 263 of file structuredInference.h.

Referenced by StructuredInference(), StructuredInference(), ~StructuredInference(), _buildReduceGraph_(), _reducePattern_(), gspan(), gspan(), info(), and operator=().

◆ _mining_

template<typename GUM_SCALAR>

bool gum::prm::StructuredInference< GUM_SCALAR >::_mining_

private

Flag which tells to use pattern mining or not.

Definition at line 293 of file structuredInference.h.

Referenced by StructuredInference(), StructuredInference(), _buildReduceGraph_(), and setPatternMining().

◆ _outputs_

template<typename GUM_SCALAR>

HashTable< const PRMClass< GUM_SCALAR >*, std::vector< NodeId >* > gum::prm::StructuredInference< GUM_SCALAR >::_outputs_

private

Definition at line 280 of file structuredInference.h.

Referenced by ~StructuredInference().

◆ _pdata_

template<typename GUM_SCALAR>

PData* gum::prm::StructuredInference< GUM_SCALAR >::_pdata_

private

The pattern data of the pattern which one of its matches contains the query.

Definition at line 290 of file structuredInference.h.

Referenced by StructuredInference(), StructuredInference(), ~StructuredInference(), and posterior_().

◆ _query_

template<typename GUM_SCALAR>

PRMInference<GUM_SCALAR>::Chain gum::prm::StructuredInference< GUM_SCALAR >::_query_

private

The query.

Definition at line 286 of file structuredInference.h.

Referenced by _buildPatternGraph_(), _buildReduceGraph_(), _reduceAloneInstances_(), _reducePattern_(), posterior_(), and searchPatterns().

◆ _query_data_

template<typename GUM_SCALAR>

std::pair< Idx, std::string > gum::prm::StructuredInference< GUM_SCALAR >::_query_data_

private

Definition at line 297 of file structuredInference.h.

Referenced by _buildPatternGraph_(), and _reducePattern_().

◆ _reducedInstances_

template<typename GUM_SCALAR>

Set< const PRMInstance< GUM_SCALAR >* > gum::prm::StructuredInference< GUM_SCALAR >::_reducedInstances_

private

This keeps track of reduced instances.

Definition at line 283 of file structuredInference.h.

Referenced by _reduceAloneInstances_(), _reducePattern_(), and _translatePotSet_().

◆ _trash_

template<typename GUM_SCALAR>

Set< Tensor< GUM_SCALAR >* > gum::prm::StructuredInference< GUM_SCALAR >::_trash_

private

Keeping track of create tensors to delete them after inference.

Definition at line 278 of file structuredInference.h.

Referenced by ~StructuredInference(), _buildReduceGraph_(), _eliminateObservedNodes_(), _eliminateObservedNodesInSource_(), _reduceAloneInstances_(), and _reducePattern_().

◆ full_time

template<typename GUM_SCALAR>

double gum::prm::StructuredInference< GUM_SCALAR >::full_time

Definition at line 395 of file structuredInference.h.

Referenced by StructuredInference(), info(), and posterior_().

◆ inner_time

template<typename GUM_SCALAR>

double gum::prm::StructuredInference< GUM_SCALAR >::inner_time

Definition at line 393 of file structuredInference.h.

Referenced by StructuredInference(), and info().

◆ mining_time

template<typename GUM_SCALAR>

double gum::prm::StructuredInference< GUM_SCALAR >::mining_time

Definition at line 391 of file structuredInference.h.

Referenced by StructuredInference(), _buildReduceGraph_(), and info().

◆ obs_time

template<typename GUM_SCALAR>

double gum::prm::StructuredInference< GUM_SCALAR >::obs_time

Definition at line 394 of file structuredInference.h.

Referenced by StructuredInference(), _reducePattern_(), and info().

◆ pattern_time

template<typename GUM_SCALAR>

double gum::prm::StructuredInference< GUM_SCALAR >::pattern_time

Definition at line 392 of file structuredInference.h.

Referenced by StructuredInference(), _buildReduceGraph_(), and info().

◆ plopTimer

template<typename GUM_SCALAR>

Timer gum::prm::StructuredInference< GUM_SCALAR >::plopTimer

Definition at line 389 of file structuredInference.h.

Referenced by _buildReduceGraph_(), and _reducePattern_().

◆ prm_

template<typename GUM_SCALAR>

PRM< GUM_SCALAR > const* gum::prm::PRMInference< GUM_SCALAR >::prm_

protectedinherited

The PRM<GUM_SCALAR> on which inference is done.

Definition at line 224 of file PRMInference.h.

Referenced by PRMInference(), PRMInference(), gum::prm::StructuredInference< GUM_SCALAR >::StructuredInference(), gum::prm::SVE< GUM_SCALAR >::_initElimOrder_(), gum::prm::SVED< GUM_SCALAR >::_initElimOrder_(), operator=(), and gum::prm::StructuredInference< GUM_SCALAR >::operator=().

◆ sys_

template<typename GUM_SCALAR>

PRMSystem< GUM_SCALAR > const* gum::prm::PRMInference< GUM_SCALAR >::sys_

protectedinherited

The Model on which inference is done.

Definition at line 227 of file PRMInference.h.

Referenced by PRMInference(), PRMInference(), gum::prm::StructuredInference< GUM_SCALAR >::StructuredInference(), gum::prm::StructuredInference< GUM_SCALAR >::_reduceAloneInstances_(), operator=(), gum::prm::StructuredInference< GUM_SCALAR >::operator=(), and gum::prm::StructuredInference< GUM_SCALAR >::searchPatterns().

◆ timer

template<typename GUM_SCALAR>

Timer gum::prm::StructuredInference< GUM_SCALAR >::timer

Definition at line 388 of file structuredInference.h.

Referenced by posterior_().

◆ triang_time

template<typename GUM_SCALAR>

double gum::prm::StructuredInference< GUM_SCALAR >::triang_time

Definition at line 390 of file structuredInference.h.

Referenced by StructuredInference(), and info().

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

agrum/PRM/inference/structuredInference.h
agrum/PRM/inference/structuredInference_tpl.h

Classes

Public Types

Public Member Functions

Public Attributes

Protected Member Functions

Private Member Functions

Private Attributes

Private evidence handling methods and members.

Protected members.

Detailed Description

Member Typedef Documentation

◆ Chain

◆ EMap

◆ EMapConstIterator

◆ EMapIterator

◆ EvidenceConstIterator

◆ EvidenceIterator

Constructor & Destructor Documentation

◆ StructuredInference() [1/2]

◆ StructuredInference() [2/2]

◆ ~StructuredInference()

Member Function Documentation

◆ _addEdgesInReducedGraph_()

◆ _allInstanceNoRefAttr_()

◆ _buildPatternGraph_()

◆ _buildReduceGraph_()

◆ _eliminateObservedNodes_()

◆ _eliminateObservedNodesInSource_()

◆ _EMap_()

◆ _insertNodeInElimLists_()

◆ _reduceAloneInstances_()

◆ _reducePattern_()

◆ _removeBarrenNodes_()

◆ _removeNode_()

◆ _str_() [1/3]

◆ _str_() [2/3]

◆ _str_() [3/3]

◆ _translatePotSet_()

◆ addEvidence()

◆ clearEvidence()

◆ evidence() [1/4]

◆ evidence() [2/4]

◆ evidence() [3/4]

◆ evidence() [4/4]

◆ evidenceAdded_() [1/2]

◆ evidenceAdded_() [2/2]

◆ evidenceRemoved_() [1/2]

◆ evidenceRemoved_() [2/2]

◆ gspan() [1/2]

◆ gspan() [2/2]

◆ hasEvidence() [1/4]

◆ hasEvidence() [2/4]

◆ hasEvidence() [3/4]

◆ hasEvidence() [4/4]

◆ info()

◆ joint()

◆ joint_() [1/2]

◆ joint_() [2/2]

◆ name()

◆ operator=()

◆ posterior()

◆ posterior_() [1/2]

◆ posterior_() [2/2]

◆ removeEvidence()

◆ searchPatterns()

◆ setPatternMining()

Member Data Documentation

◆ _cdata_map_

◆ _dot_

◆ _elim_map_

◆ _evidences_

◆ _found_query_

◆ _gspan_

◆ _mining_

◆ _outputs_

◆ _pdata_

◆ _query_

◆ _query_data_

◆ _reducedInstances_

◆ _trash_