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 56 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 59 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 68 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 64 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 62 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 744 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:

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

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 415 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 352 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 209 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:

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

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 502 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 480 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:

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.

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

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

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 1024 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 1030 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 197 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 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.

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

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

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

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 264 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 176 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 1019 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 83 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 234 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 103 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 >.

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 619 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 245 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 427 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:

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

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

searchPatterns()

template<typename GUM_SCALAR >

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

(

)

Search for patterns without doing any computations.

Definition at line 974 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 983 of file structuredInference_tpl.h.

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

                                                                          {
      mining__ = b;
    }

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 988 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 995 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 1002 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 524 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:

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

full_time

template<typename GUM_SCALAR >

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

Definition at line 384 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 249 of file structuredInference.h.

inner_time

template<typename GUM_SCALAR >

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

Definition at line 382 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 280 of file structuredInference.h.

mining_time

template<typename GUM_SCALAR >

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

Definition at line 380 of file structuredInference.h.

obs_time

template<typename GUM_SCALAR >

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

Definition at line 383 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 267 of file structuredInference.h.

pattern_time

template<typename GUM_SCALAR >

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

Definition at line 381 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 277 of file structuredInference.h.

plopTimer

template<typename GUM_SCALAR >

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

Definition at line 378 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 213 of file PRMInference.h.

query__

template<typename GUM_SCALAR >

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

private

The query.

Definition at line 273 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 284 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 270 of file structuredInference.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 216 of file PRMInference.h.

timer

template<typename GUM_SCALAR >

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

Definition at line 377 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 265 of file structuredInference.h.

triang_time

template<typename GUM_SCALAR >

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

Definition at line 379 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