gum::prm::StructuredInference< GUM_SCALAR > Class Template Reference

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

#include <structuredInference.h>

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

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

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

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

Public Types
typedef std::pair< const PRMInstance< GUM_SCALAR > *, const PRMAttribute< GUM_SCALAR > *>	Chain
	Code alias. More...
typedef NodeProperty< const Potential< GUM_SCALAR > *>	EMap
	Code alias. More...
typedef NodeProperty< const Potential< GUM_SCALAR > *>::iterator_safe	EMapIterator
	Code alias. More...
typedef NodeProperty< const Potential< GUM_SCALAR > *>::const_iterator_safe	EMapConstIterator
	Code alias. More...

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

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

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

Detailed Description

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

<agrum/PRM/structuredInference.h>

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 63 of file structuredInference.h.

Member Typedef Documentation

Chain

template<typename GUM_SCALAR>

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

inherited

Code alias.

Definition at line 55 of file PRMInference.h.

EMap

template<typename GUM_SCALAR>

typedef NodeProperty< const Potential< GUM_SCALAR >* > gum::prm::PRMInference< GUM_SCALAR >::EMap

inherited

Code alias.

Definition at line 58 of file PRMInference.h.

EMapConstIterator

template<typename GUM_SCALAR>

typedef NodeProperty< const Potential< GUM_SCALAR >* >::const_iterator_safe gum::prm::PRMInference< GUM_SCALAR >::EMapConstIterator

inherited

Code alias.

Definition at line 65 of file PRMInference.h.

EMapIterator

template<typename GUM_SCALAR>

typedef NodeProperty< const Potential< GUM_SCALAR >* >::iterator_safe gum::prm::PRMInference< GUM_SCALAR >::EMapIterator

inherited

Code alias.

Definition at line 61 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 35 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;
    }

StructuredInference() [2/2]

template<typename GUM_SCALAR >

gum::prm::StructuredInference< GUM_SCALAR >::StructuredInference

(

const StructuredInference< GUM_SCALAR > &

source

)

Copy constructor.

Definition at line 52 of file structuredInference_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

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

Here is the call graph for this function:

~StructuredInference()

template<typename GUM_SCALAR >

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

virtual

Destructor.

Definition at line 61 of file structuredInference_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

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

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 690 of file structuredInference_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                               {
      // 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&) {}
          }
        }
      }

      // Adding potentials 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&) {}
            }
          }
        }
      }
    }

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

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

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

      return true;
    }

Here is the call graph for this function:

_buildPatternGraph_()

template<typename GUM_SCALAR >

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

private

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

Definition at line 328 of file structuredInference_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                 {
      std::pair< Idx, std::string > v;
      Potential< 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< Potential< GUM_SCALAR >* >(&(elt.second->cpf())));
          pot = &(const_cast< Potential< 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&) {
            } catch (NotFound&) {}
          }

          _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;
          }
        }
      }
    }

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

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                               {
      // Launch the pattern mining
      plopTimer.reset();

      if (_mining_) _gspan_->discoverPatterns();

      mining_time = plopTimer.step();
      // Reducing each used pattern
      plopTimer.reset();
      typedef std::vector< gspan::Pattern* >::const_iterator Iter;

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

Here is the call graph for this function:

_eliminateObservedNodes_()

template<typename GUM_SCALAR >

Set< Potential< GUM_SCALAR > *> * gum::prm::StructuredInference< GUM_SCALAR >::_eliminateObservedNodes_ ( typename StructuredInference< GUM_SCALAR >::PData &  data, const Set< Potential< 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 467 of file structuredInference_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                    {
      Set< Potential< 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;
    }

Here is the call graph for this function:

_eliminateObservedNodesInSource_()

template<typename GUM_SCALAR >

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

private

Definition at line 447 of file structuredInference_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                       {
      Set< Potential< GUM_SCALAR >* >* my_pool = new Set< Potential< 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;
    }

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

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

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

Here is the call graph for this function:

_reduceAloneInstances_()

template<typename GUM_SCALAR >

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

private

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

Definition at line 576 of file structuredInference_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                  {
      StructuredInference< GUM_SCALAR >::CData* data = 0;
      Potential< 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< Potential< GUM_SCALAR >* > pool;

            try {
              data = _cdata_map_[&(inst->type())];
            } catch (NotFound&) {
              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 potentials
              for (auto attr = inst->begin(); attr != inst->end(); ++attr)
                pool.insert(&(const_cast< Potential< GUM_SCALAR >& >((*(attr.val())).cpf())));

              // Adding evidences if any
              if (this->hasEvidence(inst))
                for (const auto& elt: this->evidence(inst))
                  pool.insert(const_cast< Potential< 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 potentials
              for (const auto elt: *inst)
                pool.insert(&const_cast< Potential< GUM_SCALAR >& >(elt.second->cpf()));

              // Adding evidences
              for (const auto& elt: this->evidence(inst))
                pool.insert(const_cast< Potential< 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 potentials into the instance ones
              // and
              // proceed with elimination
              for (const auto srcPot: data->pool) {
                pot = copyPotential(inst->bijection(), *srcPot);
                pool.insert(pot);
                _trash_.insert(pot);
              }

              for (const auto agg: data->c.aggregates())
                pool.insert(&(const_cast< Potential< 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);
          }
        }
      }
    }

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

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                                 {
      Set< Potential< 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< Potential< 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&) { fake_patterns.insert(*iter); }
        }
      } else {
        for (; iter != data.matches.end(); ++iter) {
          try {
            _elim_map_.insert(*iter, _translatePotSet_(data, pool, **iter));
          } catch (OperationNotAllowed&) { 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_);
    }

Here is the call graph for this function:

_removeBarrenNodes_()

template<typename GUM_SCALAR >

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

private

Definition at line 394 of file structuredInference_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

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

      NodeId                   node;
      Potential< 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&) {}
            }
          }
        }
      }
    }

Here is the call 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< Potential< GUM_SCALAR > * > &  pool  )

private

Definition at line 973 of file structuredInference_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

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

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 928 of file structuredInference_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                                           {
      return i->name() + _dot_ + a->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 935 of file structuredInference_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

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

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

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

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

Here is the call graph for this function:

_translatePotSet_()

template<typename GUM_SCALAR >

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

private

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

Definition at line 487 of file structuredInference_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                 {
#ifdef DEBUG

      for (GSpan< GUM_SCALAR >::MatchedInstances::const_iterator 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< Potential< GUM_SCALAR >* >* my_pool = new Set< Potential< 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&) {
            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&) {
              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&) { GUM_ASSERT(bij.existsFirst(v)); } catch (DuplicateElement&) {
          }
        }

        try {
          my_pool->insert(copyPotential(bij, *p));
        } catch (Exception&) {
          for (const auto pot: *my_pool)
            delete pot;

          delete my_pool;
          GUM_ERROR(OperationNotAllowed, "fake pattern")
        }
      }

      return my_pool;
    }

Here is the call graph for this function:

addEvidence()

template<typename GUM_SCALAR>

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

inherited

Add an evidence to the given instance's elt.

Parameters

chain	The variable being observed.
p	The Potential 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 105 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.")

        Potential< GUM_SCALAR >* e = new Potential< 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 35 of file PRMInference_tpl.h.

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

        delete elt.second;
      }

      _evidences_.clear();
    }

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

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

evidence() [2/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 167 of file PRMInference_tpl.h.

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

evidence() [3/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 159 of file PRMInference_tpl.h.

                                                                                    {
      try {
        return *(_evidences_[&i]);
      } catch (NotFound&) { 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 175 of file PRMInference_tpl.h.

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

evidenceAdded_() [1/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 93 of file structuredInference_tpl.h.

                                                              {}

evidenceAdded_() [2/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 >.

evidenceRemoved_() [1/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 97 of file structuredInference_tpl.h.

                                                              {}

evidenceRemoved_() [2/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 >.

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 963 of file structuredInference_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                         {
      return *_gspan_;
    }

Here is the call graph for this function:

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 968 of file structuredInference_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                                     {
      return *_gspan_;
    }

Here is the call graph for this function:

hasEvidence() [1/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 182 of file PRMInference_tpl.h.

                                                                                                {
      return _evidences_.exists(&i);
    }

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

                                                                                                {
      return _evidences_.exists(i);
    }

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

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

hasEvidence() [4/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 197 of file PRMInference_tpl.h.

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

info()

template<typename GUM_SCALAR >

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

(

)

const

Definition at line 179 of file structuredInference_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                            {
      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;
      typedef std::vector< gspan::Pattern* >::const_iterator Iter;

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

Here is the call graph for this function:

joint()

template<typename GUM_SCALAR>

INLINE void gum::prm::PRMInference< GUM_SCALAR >::joint ( const std::vector< Chain > &  chains, Potential< 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 241 of file PRMInference_tpl.h.

                                                                           {
      if (j.nbrDim() > 0) { GUM_ERROR(OperationNotAllowed, "the given Potential is not empty.") }

      for (auto chain = chains.begin(); chain != chains.end(); ++chain) {
        j.add(chain->second->type().variable());
      }

      joint_(chains, j);
    }

joint_() [1/2]

template<typename GUM_SCALAR >

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

protectedvirtual

See PRMInference::joint_().

Definition at line 172 of file structuredInference_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                           {
      GUM_ERROR(FatalError, "not implemented")
    }

Here is the call graph for this function:

joint_() [2/2]

template<typename GUM_SCALAR>

virtual void gum::prm::PRMInference< GUM_SCALAR >::joint_ ( const std::vector< Chain > &  queries, Potential< 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 >.

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 958 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 81 of file structuredInference_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

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

Here is the call graph for this function:

posterior()

template<typename GUM_SCALAR>

INLINE void gum::prm::PRMInference< GUM_SCALAR >::posterior ( const Chain &  chain, Potential< 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 215 of file PRMInference_tpl.h.

                                                            {
      if (m.nbrDim() > 0) { GUM_ERROR(OperationNotAllowed, "the given Potential is not empty.") }

      if (hasEvidence(chain)) {
        m.add(chain.second->type().variable());
        const Potential< 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);
        }
      }
    }

posterior_() [1/2]

template<typename GUM_SCALAR >

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

protectedvirtual

See PRMInference::posterior_().

Definition at line 101 of file structuredInference_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                            {
      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 Potential< 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 Potential< 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) {
          Potential< GUM_SCALAR >* pot = const_cast< Potential< 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< GUM_SCALAR, Potential > Comb(multPotential);
          Potential< GUM_SCALAR >*                            tmp = Comb.combine(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 {
        Potential< 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();
    }

Here is the call graph for this function:

posterior_() [2/2]

template<typename GUM_SCALAR>

virtual void gum::prm::PRMInference< GUM_SCALAR >::posterior_ ( const Chain &  chain, Potential< 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 >.

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 202 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&) {
        // Ok, we are only removing
      }
    }

searchPatterns()

template<typename GUM_SCALAR >

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

(

)

Search for patterns without doing any computations.

Definition at line 913 of file structuredInference_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

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

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 922 of file structuredInference_tpl.h.

References gum::prm::ParamScopeData< GUM_SCALAR >::ParamScopeData().

                                                                          {
      _mining_ = b;
    }

Here is the call graph for this function:

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 256 of file structuredInference.h.

_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 359 of file structuredInference.h.

_elim_map_

template<typename GUM_SCALAR >

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

private

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

Definition at line 250 of file structuredInference.h.

_found_query_

template<typename GUM_SCALAR >

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

private

Flag with an explicit name.

Definition at line 277 of file structuredInference.h.

_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 244 of file structuredInference.h.

_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 274 of file structuredInference.h.

_outputs_

template<typename GUM_SCALAR >

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

private

Definition at line 261 of file structuredInference.h.

_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 271 of file structuredInference.h.

_query_

template<typename GUM_SCALAR >

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

private

The query.

Definition at line 267 of file structuredInference.h.

_query_data_

template<typename GUM_SCALAR >

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

private

Definition at line 278 of file structuredInference.h.

_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 264 of file structuredInference.h.

_trash_

template<typename GUM_SCALAR >

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

private

Keeping track of create potentials to delete them after inference.

Definition at line 259 of file structuredInference.h.

full_time

template<typename GUM_SCALAR >

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

Definition at line 376 of file structuredInference.h.

inner_time

template<typename GUM_SCALAR >

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

Definition at line 374 of file structuredInference.h.

mining_time

template<typename GUM_SCALAR >

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

Definition at line 372 of file structuredInference.h.

obs_time

template<typename GUM_SCALAR >

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

Definition at line 375 of file structuredInference.h.

pattern_time

template<typename GUM_SCALAR >

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

Definition at line 373 of file structuredInference.h.

plopTimer

template<typename GUM_SCALAR >

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

Definition at line 370 of file structuredInference.h.

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 207 of file PRMInference.h.

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 210 of file PRMInference.h.

timer

template<typename GUM_SCALAR >

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

Definition at line 369 of file structuredInference.h.

triang_time

template<typename GUM_SCALAR >

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

Definition at line 371 of file structuredInference.h.

---

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

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