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	marginal (const Chain &chain, Potential< GUM_SCALAR > &m)
	Compute the marginal 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	_marginal (const typename PRMInference< GUM_SCALAR >::Chain &chain, Potential< GUM_SCALAR > &m)
	See PRMInference::_marginal(). 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	_marginal (const Chain &chain, Potential< GUM_SCALAR > &m)=0
	Generic method to compute the marginal of given element. More...
virtual void	_joint (const std::vector< Chain > &queries, Potential< GUM_SCALAR > &j)=0
	Generic method to compute the marginal 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 64 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 57 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 60 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 69 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 65 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 36 of file structuredInference_tpl.h.

References gum::prm::StructuredInference< GUM_SCALAR >::__gspan, gum::prm::StructuredInference< GUM_SCALAR >::full_time, gum::prm::StructuredInference< GUM_SCALAR >::inner_time, gum::prm::StructuredInference< GUM_SCALAR >::mining_time, gum::prm::StructuredInference< GUM_SCALAR >::obs_time, gum::prm::StructuredInference< GUM_SCALAR >::pattern_time, and gum::prm::StructuredInference< GUM_SCALAR >::triang_time.

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

References gum::prm::StructuredInference< GUM_SCALAR >::__gspan, gum::prm::PRMInference< GUM_SCALAR >::_prm, and gum::prm::PRMInference< GUM_SCALAR >::_sys.

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

~StructuredInference()

template<typename GUM_SCALAR >

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

virtual

Destructor.

Definition at line 63 of file structuredInference_tpl.h.

References gum::prm::StructuredInference< GUM_SCALAR >::__cdata_map, gum::prm::StructuredInference< GUM_SCALAR >::__elim_map, gum::prm::StructuredInference< GUM_SCALAR >::__gspan, gum::prm::StructuredInference< GUM_SCALAR >::__outputs, gum::prm::StructuredInference< GUM_SCALAR >::__pdata, gum::prm::StructuredInference< GUM_SCALAR >::__trash, and gum::prm::StructuredInference< GUM_SCALAR >::operator=().

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

References gum::prm::StructuredInference< GUM_SCALAR >::__elim_map, gum::UndiGraph::addEdge(), gum::NodeGraphPart::addNode(), gum::SequenceImplementation< Key, Alloc, std::is_scalar< Key >::value >::atPos(), gum::Set< Key, Alloc >::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, Alloc, std::is_scalar< Key >::value >::size(), and gum::prm::StructuredInference< GUM_SCALAR >::RGData::var2node.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__buildReduceGraph().

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

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

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

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__buildPatternGraph().

                                                            {
      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 caller 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 349 of file structuredInference_tpl.h.

References gum::prm::StructuredInference< GUM_SCALAR >::__allInstanceNoRefAttr(), gum::prm::StructuredInference< GUM_SCALAR >::__found_query, gum::prm::StructuredInference< GUM_SCALAR >::__insertNodeInElimLists(), gum::prm::StructuredInference< GUM_SCALAR >::__query, gum::prm::StructuredInference< GUM_SCALAR >::__query_data, gum::prm::StructuredInference< GUM_SCALAR >::__str(), gum::UndiGraph::addEdge(), gum::NodeGraphPart::addNode(), gum::prm::StructuredInference< GUM_SCALAR >::PData::barren, gum::Set< Key, Alloc >::erase(), gum::Set< Key, Alloc >::exists(), gum::prm::StructuredInference< GUM_SCALAR >::PData::graph, gum::prm::StructuredInference< GUM_SCALAR >::PData::inners(), gum::Set< Key, Alloc >::insert(), gum::BijectionImplementation< T1, T2, Alloc, Gen >::insert(), gum::prm::StructuredInference< GUM_SCALAR >::PData::map, gum::prm::StructuredInference< GUM_SCALAR >::PData::matches, gum::prm::StructuredInference< GUM_SCALAR >::PData::mod, gum::prm::StructuredInference< GUM_SCALAR >::PData::node2attr, gum::prm::StructuredInference< GUM_SCALAR >::PData::obs(), gum::prm::StructuredInference< GUM_SCALAR >::PData::outputs(), gum::prm::StructuredInference< GUM_SCALAR >::PData::queries(), gum::MultiDimDecorator< GUM_SCALAR >::variablesSequence(), and gum::prm::StructuredInference< GUM_SCALAR >::PData::vars.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__reducePattern().

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

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

References gum::prm::StructuredInference< GUM_SCALAR >::__addEdgesInReducedGraph(), gum::prm::StructuredInference< GUM_SCALAR >::__gspan, gum::prm::StructuredInference< GUM_SCALAR >::__mining, gum::prm::StructuredInference< GUM_SCALAR >::__query, gum::prm::StructuredInference< GUM_SCALAR >::__reduceAloneInstances(), gum::prm::StructuredInference< GUM_SCALAR >::__reducePattern(), gum::prm::StructuredInference< GUM_SCALAR >::__trash, gum::prm::eliminateNode(), gum::StaticTriangulation::eliminationOrder(), gum::Set< Key, Alloc >::erase(), gum::Set< Key, Alloc >::insert(), gum::prm::StructuredInference< GUM_SCALAR >::mining_time, gum::prm::StructuredInference< GUM_SCALAR >::RGData::mods, gum::prm::StructuredInference< GUM_SCALAR >::RGData::outputs(), gum::prm::StructuredInference< GUM_SCALAR >::RGData::partial_order, gum::prm::StructuredInference< GUM_SCALAR >::pattern_time, gum::prm::StructuredInference< GUM_SCALAR >::plopTimer, gum::prm::StructuredInference< GUM_SCALAR >::RGData::pool, gum::prm::StructuredInference< GUM_SCALAR >::RGData::queries(), gum::prm::StructuredInference< GUM_SCALAR >::RGData::reducedGraph, gum::Timer::reset(), gum::Set< Key, Alloc >::size(), gum::Timer::step(), and gum::prm::StructuredInference< GUM_SCALAR >::RGData::var2node.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::_marginal(), and gum::prm::StructuredInference< GUM_SCALAR >::searchPatterns().

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

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

References gum::prm::StructuredInference< GUM_SCALAR >::__translatePotSet(), gum::prm::StructuredInference< GUM_SCALAR >::__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, Alloc >::size(), and gum::prm::StructuredInference< GUM_SCALAR >::PData::vars.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__reducePattern().

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

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

References gum::prm::StructuredInference< GUM_SCALAR >::__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, Alloc >::size(), and gum::prm::StructuredInference< GUM_SCALAR >::PData::vars.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__reducePattern().

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

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

References gum::Set< Key, Alloc >::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, Alloc >::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, Alloc >::size(), and gum::prm::PRMInstance< GUM_SCALAR >::type().

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__buildPatternGraph().

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

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 potentials of instances not in any used patterns.

Definition at line 613 of file structuredInference_tpl.h.

References gum::prm::StructuredInference< GUM_SCALAR >::__cdata_map, gum::prm::StructuredInference< GUM_SCALAR >::__query, gum::prm::StructuredInference< GUM_SCALAR >::__reducedInstances, gum::prm::StructuredInference< GUM_SCALAR >::__trash, gum::prm::PRMInference< GUM_SCALAR >::_sys, gum::prm::StructuredInference< GUM_SCALAR >::CData::aggregators(), gum::prm::PRMInstance< GUM_SCALAR >::begin(), gum::prm::PRMInstance< GUM_SCALAR >::bijection(), gum::prm::StructuredInference< GUM_SCALAR >::CData::c, gum::prm::copyPotential(), gum::prm::StructuredInference< GUM_SCALAR >::CData::elim_order(), gum::prm::eliminateNode(), gum::StaticTriangulation::eliminationOrder(), gum::prm::PRMInstance< GUM_SCALAR >::end(), gum::List< Val, Alloc >::erase(), gum::prm::PRMInference< GUM_SCALAR >::evidence(), gum::prm::PRMInstance< GUM_SCALAR >::get(), gum::prm::PRMInference< GUM_SCALAR >::hasEvidence(), gum::prm::StructuredInference< GUM_SCALAR >::CData::inners(), gum::Set< Key, Alloc >::insert(), gum::List< Val, Alloc >::insert(), gum::prm::StructuredInference< GUM_SCALAR >::CData::instances, gum::prm::StructuredInference< GUM_SCALAR >::CData::mods, gum::prm::StructuredInference< GUM_SCALAR >::CData::moral_graph, gum::prm::StructuredInference< GUM_SCALAR >::CData::outputs(), gum::prm::StructuredInference< GUM_SCALAR >::RGData::pool, gum::prm::StructuredInference< GUM_SCALAR >::CData::pool, gum::List< Val, Alloc >::push_back(), gum::prm::PRMInstance< GUM_SCALAR >::size(), gum::Set< Key, Alloc >::size(), gum::List< Val, Alloc >::size(), and gum::prm::PRMInstance< GUM_SCALAR >::type().

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__buildReduceGraph().

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

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

References gum::prm::StructuredInference< GUM_SCALAR >::__buildPatternGraph(), gum::prm::StructuredInference< GUM_SCALAR >::__elim_map, gum::prm::StructuredInference< GUM_SCALAR >::__eliminateObservedNodes(), gum::prm::StructuredInference< GUM_SCALAR >::__eliminateObservedNodesInSource(), gum::prm::StructuredInference< GUM_SCALAR >::__gspan, gum::prm::StructuredInference< GUM_SCALAR >::__query, gum::prm::StructuredInference< GUM_SCALAR >::__query_data, gum::prm::StructuredInference< GUM_SCALAR >::__reducedInstances, gum::prm::StructuredInference< GUM_SCALAR >::__removeBarrenNodes(), gum::prm::StructuredInference< GUM_SCALAR >::__translatePotSet(), gum::prm::StructuredInference< GUM_SCALAR >::__trash, gum::prm::eliminateNode(), gum::StaticTriangulation::eliminationOrder(), gum::Set< Key, Alloc >::insert(), gum::prm::StructuredInference< GUM_SCALAR >::obs_time, gum::prm::StructuredInference< GUM_SCALAR >::plopTimer, and gum::Timer::step().

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__buildReduceGraph().

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

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< Potential< GUM_SCALAR > * > &  pool  )

private

Definition at line 422 of file structuredInference_tpl.h.

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

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__reducePattern().

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

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< Potential< GUM_SCALAR > * > &  pool  )

private

Definition at line 1026 of file structuredInference_tpl.h.

References gum::Set< Key, Alloc >::erase(), gum::BijectionImplementation< T1, T2, Alloc, Gen >::eraseFirst(), gum::UndiGraph::eraseNode(), gum::NodeGraphPart::exists(), gum::Set< Key, Alloc >::exists(), gum::BijectionImplementation< T1, T2, Alloc, Gen >::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 >::CData::pool, gum::prm::StructuredInference< GUM_SCALAR >::PData::pots, and gum::prm::StructuredInference< GUM_SCALAR >::PData::vars.

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

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

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__buildPatternGraph().

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

Here is the call graph for this function:

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

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

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

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

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

References gum::prm::StructuredInference< GUM_SCALAR >::__reducedInstances, gum::prm::copyPotential(), gum::BijectionImplementation< T1, T2, Alloc, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::existsFirst(), gum::BijectionImplementation< T1, T2, Alloc, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::first(), GUM_ERROR, gum::BijectionImplementation< T1, T2, Alloc, std::is_scalar< T1 >::value &&std::is_scalar< T2 >::value >::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 gum::prm::StructuredInference< GUM_SCALAR >::__eliminateObservedNodes(), and gum::prm::StructuredInference< GUM_SCALAR >::__reducePattern().

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

Here is the caller graph for this function:

_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 95 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 99 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 >.

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

References GUM_ERROR.

                                                                           {
      GUM_ERROR(FatalError, "not implemented");
    }

_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 marginal 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 >.

_marginal() [1/2]

template<typename GUM_SCALAR >

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

protectedvirtual

See PRMInference::_marginal().

Definition at line 103 of file structuredInference_tpl.h.

References gum::prm::StructuredInference< GUM_SCALAR >::__buildReduceGraph(), gum::prm::StructuredInference< GUM_SCALAR >::__found_query, gum::prm::StructuredInference< GUM_SCALAR >::__pdata, gum::prm::StructuredInference< GUM_SCALAR >::__query, gum::Set< Key, Alloc >::begin(), gum::MultiDimCombinationDefault< GUM_SCALAR, TABLE >::combine(), gum::MultiDimDecorator< GUM_SCALAR >::contains(), gum::Instantiation::end(), gum::prm::PRMInference< GUM_SCALAR >::evidence(), gum::prm::StructuredInference< GUM_SCALAR >::full_time, gum::MultiDimDecorator< GUM_SCALAR >::get(), gum::prm::PRMInference< GUM_SCALAR >::hasEvidence(), gum::Instantiation::inc(), gum::Set< Key, Alloc >::insert(), gum::prm::multPotential(), gum::Potential< GUM_SCALAR >::normalize(), gum::prm::StructuredInference< GUM_SCALAR >::RGData::pool, gum::Timer::reset(), gum::MultiDimDecorator< GUM_SCALAR >::set(), gum::Instantiation::setFirst(), gum::Set< Key, Alloc >::size(), gum::Timer::step(), gum::prm::StructuredInference< GUM_SCALAR >::timer, and gum::MultiDimDecorator< GUM_SCALAR >::variablesSequence().

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

_marginal() [2/2]

template<typename GUM_SCALAR>

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

protectedpure virtualinherited

Generic method to compute the marginal of given element.

Parameters

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

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

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

Referenced by gum::prm::o3prmr::O3prmrInterpreter::observe().

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

Here is the caller graph for this function:

clearEvidence()

template<typename GUM_SCALAR >

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

inherited

Remove all evidences.

Definition at line 36 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 156 of file PRMInference_tpl.h.

Referenced by gum::prm::SVED< GUM_SCALAR >::__insertEvidence(), gum::prm::SVE< GUM_SCALAR >::__insertEvidence(), gum::prm::StructuredInference< GUM_SCALAR >::__reduceAloneInstances(), and gum::prm::StructuredInference< GUM_SCALAR >::_marginal().

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

Here is the caller graph for this function:

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 177 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 166 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 187 of file PRMInference_tpl.h.

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

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

References gum::prm::StructuredInference< GUM_SCALAR >::__gspan.

                                                                         {
      return *__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 1021 of file structuredInference_tpl.h.

References gum::prm::StructuredInference< GUM_SCALAR >::__gspan.

                                                                {
      return *__gspan;
    }

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

Referenced by gum::prm::o3prmr::O3prmrInterpreter::observe(), and gum::prm::o3prmr::O3prmrInterpreter::unobserve().

                                                 {
      return __evidences.exists(&i);
    }

Here is the caller graph for this function:

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 203 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 209 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 216 of file PRMInference_tpl.h.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__insertNodeInElimLists(), gum::prm::StructuredInference< GUM_SCALAR >::__reduceAloneInstances(), and gum::prm::StructuredInference< GUM_SCALAR >::_marginal().

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

Here is the caller graph for this function:

info()

template<typename GUM_SCALAR >

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

(

)

const

Definition at line 183 of file structuredInference_tpl.h.

References gum::prm::StructuredInference< GUM_SCALAR >::__gspan, gum::prm::StructuredInference< GUM_SCALAR >::full_time, gum::prm::StructuredInference< GUM_SCALAR >::inner_time, gum::prm::StructuredInference< GUM_SCALAR >::mining_time, gum::prm::StructuredInference< GUM_SCALAR >::obs_time, gum::prm::StructuredInference< GUM_SCALAR >::pattern_time, and gum::prm::StructuredInference< GUM_SCALAR >::triang_time.

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

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

marginal()

template<typename GUM_SCALAR>

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

inherited

Compute the marginal 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 marginal of chain.

Exceptions

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

Definition at line 234 of file PRMInference_tpl.h.

Referenced by gum::prm::o3prmr::O3prmrInterpreter::query().

                                                            {
      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());
          _marginal(good_chain, m);
        } else {
          m.add(chain.second->type().variable());
          _marginal(chain, m);
        }
      }
    }

Here is the caller graph for this function:

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

References gum::prm::StructuredInference< GUM_SCALAR >::__gspan, gum::prm::PRMInference< GUM_SCALAR >::_prm, and gum::prm::PRMInference< GUM_SCALAR >::_sys.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::~StructuredInference().

                                                                                                  {
      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 caller 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.
WrongType	Raised if the elt is not an PRMAttribute<GUM_SCALAR>.

Definition at line 221 of file PRMInference_tpl.h.

Referenced by gum::prm::o3prmr::O3prmrInterpreter::unobserve().

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

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

References gum::prm::StructuredInference< GUM_SCALAR >::__buildReduceGraph(), gum::prm::StructuredInference< GUM_SCALAR >::__found_query, gum::prm::StructuredInference< GUM_SCALAR >::__query, gum::prm::PRMInference< GUM_SCALAR >::_sys, and gum::prm::PRMInstance< GUM_SCALAR >::begin().

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

References gum::prm::StructuredInference< GUM_SCALAR >::__mining.

                                                                          {
      __mining = b;
    }

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

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__reduceAloneInstances(), and gum::prm::StructuredInference< GUM_SCALAR >::~StructuredInference().

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

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__str().

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

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__addEdgesInReducedGraph(), gum::prm::StructuredInference< GUM_SCALAR >::__reducePattern(), and gum::prm::StructuredInference< GUM_SCALAR >::~StructuredInference().

__found_query

template<typename GUM_SCALAR>

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

private

Flag with an explicit name.

Definition at line 284 of file structuredInference.h.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__buildPatternGraph(), gum::prm::StructuredInference< GUM_SCALAR >::_marginal(), and gum::prm::StructuredInference< GUM_SCALAR >::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 250 of file structuredInference.h.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__buildReduceGraph(), gum::prm::StructuredInference< GUM_SCALAR >::__reducePattern(), gum::prm::StructuredInference< GUM_SCALAR >::gspan(), gum::prm::StructuredInference< GUM_SCALAR >::info(), gum::prm::StructuredInference< GUM_SCALAR >::operator=(), gum::prm::StructuredInference< GUM_SCALAR >::StructuredInference(), and gum::prm::StructuredInference< GUM_SCALAR >::~StructuredInference().

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

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__buildReduceGraph(), and gum::prm::StructuredInference< GUM_SCALAR >::setPatternMining().

__outputs

template<typename GUM_SCALAR>

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

private

Definition at line 268 of file structuredInference.h.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::CData::outputs(), and gum::prm::StructuredInference< GUM_SCALAR >::~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 278 of file structuredInference.h.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::_marginal(), and gum::prm::StructuredInference< GUM_SCALAR >::~StructuredInference().

__query

template<typename GUM_SCALAR>

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

private

The query.

Definition at line 274 of file structuredInference.h.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__buildPatternGraph(), gum::prm::StructuredInference< GUM_SCALAR >::__buildReduceGraph(), gum::prm::StructuredInference< GUM_SCALAR >::__reduceAloneInstances(), gum::prm::StructuredInference< GUM_SCALAR >::__reducePattern(), gum::prm::StructuredInference< GUM_SCALAR >::_marginal(), and gum::prm::StructuredInference< GUM_SCALAR >::searchPatterns().

__query_data

template<typename GUM_SCALAR>

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

private

Definition at line 285 of file structuredInference.h.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__buildPatternGraph(), and gum::prm::StructuredInference< GUM_SCALAR >::__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 271 of file structuredInference.h.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__reduceAloneInstances(), gum::prm::StructuredInference< GUM_SCALAR >::__reducePattern(), and gum::prm::StructuredInference< GUM_SCALAR >::__translatePotSet().

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

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__buildReduceGraph(), gum::prm::StructuredInference< GUM_SCALAR >::__eliminateObservedNodes(), gum::prm::StructuredInference< GUM_SCALAR >::__eliminateObservedNodesInSource(), gum::prm::StructuredInference< GUM_SCALAR >::__reduceAloneInstances(), gum::prm::StructuredInference< GUM_SCALAR >::__reducePattern(), and gum::prm::StructuredInference< GUM_SCALAR >::~StructuredInference().

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

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

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

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

full_time

template<typename GUM_SCALAR>

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

Definition at line 385 of file structuredInference.h.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::_marginal(), gum::prm::StructuredInference< GUM_SCALAR >::info(), and gum::prm::StructuredInference< GUM_SCALAR >::StructuredInference().

inner_time

template<typename GUM_SCALAR>

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

Definition at line 383 of file structuredInference.h.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::info(), and gum::prm::StructuredInference< GUM_SCALAR >::StructuredInference().

mining_time

template<typename GUM_SCALAR>

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

Definition at line 381 of file structuredInference.h.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__buildReduceGraph(), gum::prm::StructuredInference< GUM_SCALAR >::info(), and gum::prm::StructuredInference< GUM_SCALAR >::StructuredInference().

obs_time

template<typename GUM_SCALAR>

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

Definition at line 384 of file structuredInference.h.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__reducePattern(), gum::prm::StructuredInference< GUM_SCALAR >::info(), and gum::prm::StructuredInference< GUM_SCALAR >::StructuredInference().

pattern_time

template<typename GUM_SCALAR>

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

Definition at line 382 of file structuredInference.h.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__buildReduceGraph(), gum::prm::StructuredInference< GUM_SCALAR >::info(), and gum::prm::StructuredInference< GUM_SCALAR >::StructuredInference().

plopTimer

template<typename GUM_SCALAR>

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

Definition at line 379 of file structuredInference.h.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::__buildReduceGraph(), and gum::prm::StructuredInference< GUM_SCALAR >::__reducePattern().

timer

template<typename GUM_SCALAR>

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

Definition at line 378 of file structuredInference.h.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::_marginal().

triang_time

template<typename GUM_SCALAR>

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

Definition at line 380 of file structuredInference.h.

Referenced by gum::prm::StructuredInference< GUM_SCALAR >::info(), and gum::prm::StructuredInference< GUM_SCALAR >::StructuredInference().

---

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

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