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

This class is an implementation of the Structured Value Elimination algorithm on PRM<GUM_SCALAR>. More...

#include <agrum/PRM/SVED.h>

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

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

Public Member Functions
Constructors & destructor.
	SVED (const PRM< GUM_SCALAR > &prm, const PRMSystem< GUM_SCALAR > &model)
	Default Constructor. More...
	~SVED ()
	Destructor. More...
Getters & setters.
virtual std::string	name () const
	Returns the name of the current inference algorithm. 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 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 Attributes
Protected members.
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...

Query methods.
typedef PRMInference< GUM_SCALAR >::Chain	Chain
	Code alias. More...
virtual void	_evidenceAdded (const Chain &chain)
	See PRMInference::_evidenceAdded(). More...
virtual void	_evidenceRemoved (const Chain &chain)
	See PRMInference::_evidenceRemoved(). More...
virtual void	_marginal (const Chain &chain, Potential< GUM_SCALAR > &m)
	See PRMInference::_marginal(). More...
virtual void	_joint (const std::vector< Chain > &queries, Potential< GUM_SCALAR > &j)
	See PRMInference::_joint(). More...

Detailed Description

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

This class is an implementation of the Structured Value Elimination algorithm on PRM<GUM_SCALAR>.

Definition at line 60 of file SVED.h.

Member Typedef Documentation

ArraySetIterator

template<typename GUM_SCALAR>

typedef Set< MultiDimArray< GUM_SCALAR >* >::iterator_safe gum::prm::SVED< GUM_SCALAR >::ArraySetIterator

private

Code alias.

Definition at line 115 of file SVED.h.

BucketSet

template<typename GUM_SCALAR>

typedef Set< Potential< GUM_SCALAR >* > gum::prm::SVED< GUM_SCALAR >::BucketSet

private

Code alias.

Definition at line 108 of file SVED.h.

BucketSetIterator

template<typename GUM_SCALAR>

typedef Set< Potential< GUM_SCALAR >* >::iterator_safe gum::prm::SVED< GUM_SCALAR >::BucketSetIterator

private

Code alias.

Definition at line 111 of file SVED.h.

Chain

template<typename GUM_SCALAR>

typedef PRMInference< GUM_SCALAR >::Chain gum::prm::SVED< GUM_SCALAR >::Chain

protected

Code alias.

Definition at line 90 of file SVED.h.

EMap

template<typename GUM_SCALAR>

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

inherited

Code alias.

Definition at line 57 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 66 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 62 of file PRMInference.h.

Constructor & Destructor Documentation

SVED()

template<typename GUM_SCALAR >

INLINE gum::prm::SVED< GUM_SCALAR >::SVED	(	const PRM< GUM_SCALAR > &	prm,
		const PRMSystem< GUM_SCALAR > &	model
	)

Default Constructor.

Definition at line 494 of file SVED_tpl.h.

                                                                          :
        PRMInference< GUM_SCALAR >(prm, model),
        __class_elim_order(0), __bb(*this) {
      GUM_CONSTRUCTOR(SVED);
    }

~SVED()

template<typename GUM_SCALAR >

gum::prm::SVED< GUM_SCALAR >::~SVED

(

)

Destructor.

Definition at line 32 of file SVED_tpl.h.

                              {
      GUM_DESTRUCTOR(SVED);

      for (const auto& elt : __elim_orders)
        delete elt.second;

      if (__class_elim_order != nullptr) delete __class_elim_order;
    }

Member Function Documentation

__checkElimOrder()

template<typename GUM_SCALAR >

INLINE bool gum::prm::SVED< GUM_SCALAR >::__checkElimOrder ( const PRMInstance< GUM_SCALAR > *  first, const PRMInstance< GUM_SCALAR > *  second  )

private

Returns true if second can be eliminated before first.

Definition at line 524 of file SVED_tpl.h.

References gum::prm::SVED< GUM_SCALAR >::__class_elim_order, gum::prm::SVED< GUM_SCALAR >::__initElimOrder(), gum::prm::SVED< GUM_SCALAR >::__trim(), gum::SequenceImplementation< Key, Alloc, Gen >::pos(), and gum::prm::PRMInstance< GUM_SCALAR >::type().

Referenced by gum::prm::SVED< GUM_SCALAR >::__reduceElimList().

                                                {
      if (__class_elim_order == 0) { __initElimOrder(); }

      auto first_name = __trim(first->type().name());
      auto second_name = __trim(second->type().name());
      return (__class_elim_order->pos(first_name)
              <= __class_elim_order->pos(second_name));
    }

Here is the call graph for this function:

Here is the caller graph for this function:

__eliminateNodes()

template<typename GUM_SCALAR >

void gum::prm::SVED< GUM_SCALAR >::__eliminateNodes ( const PRMInstance< GUM_SCALAR > *  query, NodeId  id, BucketSet &  pool, BucketSet &  trash  )

private

Returns true if second can be eliminated before first.

Definition at line 43 of file SVED_tpl.h.

References gum::prm::eliminateNodes(), gum::StaticTriangulation::eliminationOrder(), gum::List< Val, Alloc >::empty(), gum::Set< Key, Alloc >::exists(), gum::List< Val, Alloc >::front(), gum::prm::PRMInstance< GUM_SCALAR >::get(), gum::prm::PRMInstance< GUM_SCALAR >::getInstances(), gum::prm::PRMInstance< GUM_SCALAR >::getRefAttr(), gum::Set< Key, Alloc >::insert(), gum::List< Val, Alloc >::insert(), gum::prm::InstanceBayesNet< GUM_SCALAR >::modalities(), gum::DAGmodel::moralGraph(), gum::List< Val, Alloc >::popFront(), and gum::prm::InstanceBayesNet< GUM_SCALAR >::variable().

                                                              {
      Set< const PRMInstance< GUM_SCALAR >* > ignore;
      ignore.insert(query);
      // Extracting required attributes and slotchains
      Set< NodeId >& attr_set = __getAttrSet(query);
      Set< NodeId >& sc_set = __getSCSet(query);
      // Downward elimination
      List< const PRMInstance< GUM_SCALAR >* > elim_list;

      for (const auto attr : attr_set) {
        try {
          for (auto iter = query->getRefAttr(attr).begin();
               iter != query->getRefAttr(attr).end();
               ++iter)
            if ((!ignore.exists(iter->first)) && (__bb.exists(iter->first)))
              __eliminateNodesDownward(
                 query, iter->first, pool, trash, elim_list, ignore);
        } catch (NotFound&) {
          // Ok
        }
      }

      // Eliminating all nodes in query instance, except query
      InstanceBayesNet< GUM_SCALAR > bn(*query);
      DefaultTriangulation           t(&(bn.moralGraph()), &(bn.modalities()));
      std::vector< const DiscreteVariable* > elim_order;

      if (this->hasEvidence(query)) __insertEvidence(query, pool);

      for (const auto attr : attr_set)
        pool.insert(
           &(const_cast< Potential< GUM_SCALAR >& >(query->get(attr).cpf())));

      for (size_t idx = 0; idx < t.eliminationOrder().size(); ++idx) {
        if (t.eliminationOrder()[idx] != node) {
          auto        var_id = t.eliminationOrder()[idx];
          const auto& var = bn.variable(var_id);
          elim_order.push_back(&var);
        }
      }

      eliminateNodes(elim_order, pool, trash);
      // Eliminating instance in elim_list
      List< const PRMInstance< GUM_SCALAR >* > tmp_list;
      __reduceElimList(query, elim_list, tmp_list, ignore, pool, trash);

      while (!elim_list.empty()) {
        if (__checkElimOrder(query, elim_list.front())) {
          if ((!ignore.exists(elim_list.front()))
              && (__bb.exists(elim_list.front())))
            __eliminateNodesDownward(
               query, elim_list.front(), pool, trash, elim_list, ignore);
        } else if (__bb.exists(elim_list.front())) {
          tmp_list.insert(elim_list.front());
        }

        elim_list.popFront();
      }

      // Upward elimination
      for (const auto chain : sc_set)
        for (const auto parent : query->getInstances(chain))
          if ((!ignore.exists(parent)) && (__bb.exists(*parent)))
            __eliminateNodesUpward(parent, pool, trash, tmp_list, ignore);
    }

Here is the call graph for this function:

__eliminateNodesDownward()

template<typename GUM_SCALAR >

void gum::prm::SVED< GUM_SCALAR >::__eliminateNodesDownward ( const PRMInstance< GUM_SCALAR > *  from, const PRMInstance< GUM_SCALAR > *  i, BucketSet &  pool, BucketSet &  trash, List< const PRMInstance< GUM_SCALAR > * > &  elim_list, Set< const PRMInstance< GUM_SCALAR > * > &  ignore  )

private

Returns true if second can be eliminated before first.

Definition at line 113 of file SVED_tpl.h.

References gum::prm::eliminateNodes(), gum::List< Val, Alloc >::empty(), gum::List< Val, Alloc >::front(), gum::prm::PRMInstance< GUM_SCALAR >::getInstances(), gum::prm::PRMInstance< GUM_SCALAR >::getRefAttr(), gum::Set< Key, Alloc >::insert(), gum::List< Val, Alloc >::popFront(), gum::prm::PRMInstance< GUM_SCALAR >::type(), and gum::prm::InstanceBayesNet< GUM_SCALAR >::variable().

Referenced by gum::prm::SVED< GUM_SCALAR >::__reduceElimList().

                                                         {
      ignore.insert(i);
      // Extracting required attributes and slotchains
      Set< NodeId >& attr_set = __getAttrSet(i);
      Set< NodeId >& sc_set = __getSCSet(i);
      // Calling elimination over child instance
      List< const PRMInstance< GUM_SCALAR >* > my_list;

      for (const auto attr : attr_set) {
        try {
          for (auto iter = i->getRefAttr(attr).begin();
               iter != i->getRefAttr(attr).end();
               ++iter)
            if ((!ignore.exists(iter->first)) && (__bb.exists(iter->first)))
              __eliminateNodesDownward(
                 i, iter->first, pool, trash, my_list, ignore);
        } catch (NotFound&) {
          // Ok
        }
      }

      // Eliminating all nodes in current instance
      if (this->hasEvidence(i)) {
        __eliminateNodesWithEvidence(i, pool, trash);
      } else {
        __insertLiftedNodes(i, pool, trash);

        for (const auto agg : i->type().aggregates())
          if (__bb.requisiteNodes(i).exists(agg->id()))
            pool.insert(__getAggPotential(i, agg));

        try {
          InstanceBayesNet< GUM_SCALAR >         bn(*i);
          std::vector< const DiscreteVariable* > elim_order;

          for (auto node : __getElimOrder(i->type())) {
            const auto& var = bn.variable(node);
            elim_order.push_back(&var);
          }

          eliminateNodes(elim_order, pool, trash);
        } catch (NotFound&) {
          // Raised if there is no inner nodes to eliminate
        }
      }

      // Calling elimination over child's parents
      while (!my_list.empty()) {
        if (__checkElimOrder(i, my_list.front())) {
          if ((!ignore.exists(my_list.front())) && (__bb.exists(my_list.front())))
            __eliminateNodesDownward(
               i, my_list.front(), pool, trash, my_list, ignore);
        } else if (__bb.exists(my_list.front())) {
          elim_list.insert(my_list.front());
        }

        my_list.popFront();
      }

      // Adding parents instance to elim_list
      for (const auto chain : sc_set)
        for (const auto parent : i->getInstances(chain))
          if ((!ignore.exists(parent)) && __bb.exists(parent) && (parent != from))
            elim_list.insert(parent);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

__eliminateNodesUpward()

template<typename GUM_SCALAR >

void gum::prm::SVED< GUM_SCALAR >::__eliminateNodesUpward ( const PRMInstance< GUM_SCALAR > *  i, BucketSet &  pool, BucketSet &  trash, List< const PRMInstance< GUM_SCALAR > * > &  elim_list, Set< const PRMInstance< GUM_SCALAR > * > &  ignore  )

private

Returns true if second can be eliminated before first.

Definition at line 186 of file SVED_tpl.h.

References gum::prm::eliminateNodes(), gum::prm::PRMInstance< GUM_SCALAR >::getInstances(), gum::prm::PRMInstance< GUM_SCALAR >::getRefAttr(), gum::Set< Key, Alloc >::insert(), gum::List< Val, Alloc >::insert(), gum::prm::PRMInstance< GUM_SCALAR >::type(), and gum::prm::InstanceBayesNet< GUM_SCALAR >::variable().

                                                         {
      ignore.insert(i);
      // Extracting required attributes and slotchains
      Set< NodeId >& attr_set = __getAttrSet(i);
      Set< NodeId >& sc_set = __getSCSet(i);

      // Downward elimination
      for (const auto attr : attr_set) {
        try {
          for (auto iter = i->getRefAttr(attr).begin();
               iter != i->getRefAttr(attr).end();
               ++iter)
            if ((!ignore.exists(iter->first)) && (__bb.exists(iter->first)))
              __eliminateNodesDownward(
                 i, iter->first, pool, trash, elim_list, ignore);
        } catch (NotFound&) {
          // Ok
        }
      }

      // Eliminating all nodes in i instance
      if (this->hasEvidence(i)) {
        __eliminateNodesWithEvidence(i, pool, trash);
      } else {
        __insertLiftedNodes(i, pool, trash);

        for (const auto agg : i->type().aggregates())
          if (__bb.requisiteNodes(i).exists(agg->id()))
            pool.insert(__getAggPotential(i, agg));

        try {
          InstanceBayesNet< GUM_SCALAR >         bn(*i);
          std::vector< const DiscreteVariable* > elim_order;

          for (auto node : __getElimOrder(i->type())) {
            const auto& var = bn.variable(node);
            elim_order.push_back(&var);
          }
          eliminateNodes(elim_order, pool, trash);
        } catch (NotFound&) {
          // Raised if there is no inner nodes to eliminate
        }
      }

      // Eliminating instance in elim_list
      List< const PRMInstance< GUM_SCALAR >* > tmp_list;

      while (!elim_list.empty()) {
        if (__checkElimOrder(i, elim_list.front())) {
          if ((!ignore.exists(elim_list.front()))
              && (__bb.exists(elim_list.front())))
            __eliminateNodesDownward(
               i, elim_list.front(), pool, trash, elim_list, ignore);
        } else if (__bb.exists(elim_list.front())) {
          ignore.insert(elim_list.front());
        }

        elim_list.popFront();
      }

      // Upward elimination
      for (const auto chain : sc_set)
        for (const auto parent : i->getInstances(chain))
          if ((!ignore.exists(parent)) && (__bb.exists(parent)))
            __eliminateNodesUpward(parent, pool, trash, tmp_list, ignore);
    }

Here is the call graph for this function:

__eliminateNodesWithEvidence()

template<typename GUM_SCALAR >

void gum::prm::SVED< GUM_SCALAR >::__eliminateNodesWithEvidence ( const PRMInstance< GUM_SCALAR > *  i, BucketSet &  pool, BucketSet &  trash  )

private

Returns true if second can be eliminated before first.

Definition at line 259 of file SVED_tpl.h.

References gum::prm::eliminateNode(), gum::StaticTriangulation::eliminationOrder(), gum::Set< Key, Alloc >::insert(), gum::prm::InstanceBayesNet< GUM_SCALAR >::modalities(), and gum::DAGmodel::moralGraph().

                                                                              {
      // Adding required evidences
      for (const auto& elt : this->evidence(i))
        if (__bb.requisiteNodes(i).exists(elt.first))
          pool.insert(const_cast< Potential< GUM_SCALAR >* >(elt.second));

      // Adding potentials and eliminating the remaining nodes
      for (const auto& a : *i)
        if (__bb.requisiteNodes(i).exists(a.first))
          pool.insert(&(const_cast< Potential< GUM_SCALAR >& >(a.second->cpf())));

      InstanceBayesNet< GUM_SCALAR > bn(*i);
      DefaultTriangulation           t(&(bn.moralGraph()), &(bn.modalities()));
      const std::vector< NodeId >&   full_elim_order = t.eliminationOrder();

      for (auto var = full_elim_order.begin(); var != full_elim_order.end(); ++var)
        eliminateNode(&(i->get(*var).type().variable()), pool, trash);
    }

Here is the call graph for this function:

__getAggPotential()

template<typename GUM_SCALAR >

INLINE Potential< GUM_SCALAR > * gum::prm::SVED< GUM_SCALAR >::__getAggPotential ( const PRMInstance< GUM_SCALAR > *  i, const PRMAggregate< GUM_SCALAR > *  agg  )

private

Returns true if second can be eliminated before first.

Definition at line 536 of file SVED_tpl.h.

References gum::prm::PRMInstance< GUM_SCALAR >::get(), and gum::prm::PRMClassElement< GUM_SCALAR >::safeName().

                                                                                  {
      return &(
         const_cast< Potential< GUM_SCALAR >& >(i->get(agg->safeName()).cpf()));
    }

Here is the call graph for this function:

__getAttrSet()

template<typename GUM_SCALAR >

INLINE Set< NodeId > & gum::prm::SVED< GUM_SCALAR >::__getAttrSet ( const PRMInstance< GUM_SCALAR > *  i )

private

Returns true if second can be eliminated before first.

Definition at line 556 of file SVED_tpl.h.

References gum::prm::SVED< GUM_SCALAR >::__bb, gum::prm::SVED< GUM_SCALAR >::__initReqSets(), and gum::prm::SVED< GUM_SCALAR >::__req_set.

                                                                              {
      try {
        return *(__req_set[&(__bb.requisiteNodes(i))].first);
      } catch (NotFound&) {
        __initReqSets(i);
        return *(__req_set[&(__bb.requisiteNodes(i))].first);
      }
    }

Here is the call graph for this function:

__getElimOrder()

template<typename GUM_SCALAR >

INLINE std::vector< NodeId > & gum::prm::SVED< GUM_SCALAR >::__getElimOrder ( const PRMClass< GUM_SCALAR > &  c )

private

Returns true if second can be eliminated before first.

Definition at line 512 of file SVED_tpl.h.

References gum::prm::SVED< GUM_SCALAR >::__elim_orders.

                                                                             {
      return *(__elim_orders[&c]);
    }

__getSCSet()

template<typename GUM_SCALAR >

INLINE Set< NodeId > & gum::prm::SVED< GUM_SCALAR >::__getSCSet ( const PRMInstance< GUM_SCALAR > *  i )

private

Returns true if second can be eliminated before first.

Definition at line 567 of file SVED_tpl.h.

References gum::prm::SVED< GUM_SCALAR >::__bb, gum::prm::SVED< GUM_SCALAR >::__initReqSets(), and gum::prm::SVED< GUM_SCALAR >::__req_set.

                                                                            {
      try {
        return *(__req_set[&(__bb.requisiteNodes(i))].second);
      } catch (NotFound&) {
        __initReqSets(i);
        return *(__req_set[&(__bb.requisiteNodes(i))].second);
      }
    }

Here is the call graph for this function:

__initElimOrder()

template<typename GUM_SCALAR >

void gum::prm::SVED< GUM_SCALAR >::__initElimOrder ( )

private

Returns true if second can be eliminated before first.

Definition at line 368 of file SVED_tpl.h.

References gum::Set< Key, Alloc >::contains(), gum::prm::ClassDependencyGraph< GUM_SCALAR >::dag(), gum::SequenceImplementation< Key, Alloc, std::is_scalar< Key >::value >::exists(), gum::prm::ClassDependencyGraph< GUM_SCALAR >::get(), gum::Set< Key, Alloc >::insert(), gum::SequenceImplementation< Key, Alloc, Gen >::insert(), and gum::SequenceImplementation< Key, Alloc, std::is_scalar< Key >::value >::insert().

Referenced by gum::prm::SVED< GUM_SCALAR >::__checkElimOrder().

                                             {
      ClassDependencyGraph< GUM_SCALAR >                        cdg(*(this->_prm));
      Sequence< const PRMClassElementContainer< GUM_SCALAR >* > class_elim_order;
      std::list< NodeId >                                       l;

      for (const auto node : cdg.dag().nodes()) {
        if (cdg.dag().parents(node).empty()) { l.push_back(node); }
      }

      Set< NodeId > visited_node;

      while (!l.empty()) {
        visited_node.insert(l.front());

        if (!class_elim_order.exists(cdg.get(l.front()).first)) {
          class_elim_order.insert(cdg.get(l.front()).first);
        }

        for (const auto child : cdg.dag().children(l.front())) {
          if (!visited_node.contains(child)) { l.push_back(child); }
        }

        l.pop_front();
      }

      __class_elim_order = new Sequence< std::string >();
      for (auto c : class_elim_order) {
        std::string name = c->name();
        auto        pos = name.find_first_of("<");
        if (pos != std::string::npos) { name = name.substr(0, pos); }
        try {
          __class_elim_order->insert(name);
        } catch (DuplicateElement&) {}
      }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

__initLiftedNodes()

template<typename GUM_SCALAR >

void gum::prm::SVED< GUM_SCALAR >::__initLiftedNodes ( const PRMInstance< GUM_SCALAR > *  i, BucketSet &  trash  )

private

Returns true if second can be eliminated before first.

Definition at line 299 of file SVED_tpl.h.

References gum::prm::PRMClassElementContainer< GUM_SCALAR >::containerDag(), gum::prm::eliminateNode(), gum::Set< Key, Alloc >::erase(), gum::Set< Key, Alloc >::exists(), gum::prm::PRMClass< GUM_SCALAR >::get(), gum::Set< Key, Alloc >::insert(), gum::prm::PRMClass< GUM_SCALAR >::isOutputNode(), gum::prm::ClassBayesNet< GUM_SCALAR >::modalities(), gum::DAGmodel::moralGraph(), gum::List< Val, Alloc >::pushBack(), gum::Set< Key, Alloc >::size(), gum::prm::PRMInstance< GUM_SCALAR >::type(), and gum::prm::PRMClassElement< GUM_SCALAR >::type().

                                                                 {
      PRMClass< GUM_SCALAR >& c = const_cast< PRMClass< GUM_SCALAR >& >(i->type());
      BucketSet*              lifted_pool = new BucketSet();
      __lifted_pools.insert(&(__bb.requisiteNodes(i)), lifted_pool);

      for (const auto node : __bb.requisiteNodes(i))
        if (PRMClassElement< GUM_SCALAR >::isAttribute(c.get(node)))
          lifted_pool->insert(
             const_cast< Potential< GUM_SCALAR >* >(&(c.get(node).cpf())));

      NodeSet inners, outers, ignore;

      for (const auto& elt : *i) {
        if (__bb.requisiteNodes(*i).exists(elt.first)) {
          if (PRMClassElement< GUM_SCALAR >::isAttribute(c.get(elt.first))) {
            if (c.isOutputNode(c.get(elt.first)))
              outers.insert(elt.first);
            else if (!outers.exists(elt.first))
              inners.insert(elt.first);
          } else if (PRMClassElement< GUM_SCALAR >::isAggregate(
                        c.get(elt.first))) {
            outers.insert(elt.first);

            // We need to put in the output_elim_order aggregator's parents
            // which are
            // innner nodes
            for (const auto par : c.containerDag().parents(elt.first))
              if (PRMClassElement< GUM_SCALAR >::isAttribute(i->type().get(par))
                  && i->type().isInnerNode(i->type().get(par))
                  && __bb.requisiteNodes(i).exists(par)) {
                inners.erase(par);
                outers.insert(par);
              }
          }
        } else {
          ignore.insert(elt.first);
        }
      }

      // Now we proceed with the elimination of inner attributes
      ClassBayesNet< GUM_SCALAR > bn(c);
      List< NodeSet >             partial_ordering;

      if (inners.size()) partial_ordering.pushBack(inners);

      if (outers.size()) partial_ordering.pushBack(outers);

      if (ignore.size()) partial_ordering.pushBack(ignore);

      GUM_ASSERT(inners.size() || outers.size());
      PartialOrderedTriangulation t(
         &(bn.moralGraph()), &(bn.modalities()), &partial_ordering);

      for (size_t idx = 0; idx < inners.size(); ++idx)
        eliminateNode(&(c.get(t.eliminationOrder()[idx]).type().variable()),
                      *lifted_pool,
                      trash);

      // If there is not only inner and input Attributes
      if (outers.size()) {
        __elim_orders.insert(
           &c,
           new std::vector< NodeId >(t.eliminationOrder().begin() + inners.size(),
                                     t.eliminationOrder().end()));
      }
    }

Here is the call graph for this function:

__initReqSets()

template<typename GUM_SCALAR >

void gum::prm::SVED< GUM_SCALAR >::__initReqSets ( const PRMInstance< GUM_SCALAR > *  i )

private

Returns true if second can be eliminated before first.

Definition at line 463 of file SVED_tpl.h.

References GUM_ERROR, gum::Set< Key, Alloc >::insert(), and gum::prm::PRMInstance< GUM_SCALAR >::type().

Referenced by gum::prm::SVED< GUM_SCALAR >::__getAttrSet(), and gum::prm::SVED< GUM_SCALAR >::__getSCSet().

                                                                             {
      Set< NodeId >* attr_set = new Set< NodeId >();
      Set< NodeId >* sc_set = new Set< NodeId >();

      for (const auto node : __bb.requisiteNodes(i)) {
        switch (i->type().get(node).elt_type()) {
          case PRMClassElement< GUM_SCALAR >::prm_aggregate:
          case PRMClassElement< GUM_SCALAR >::prm_attribute: {
            attr_set->insert(node);
            break;
          }

          case PRMClassElement< GUM_SCALAR >::prm_slotchain: {
            sc_set->insert(node);
            break;
          }

          default: {
            GUM_ERROR(FatalError,
                      "There should not be elements other"
                      " than PRMAttribute<GUM_SCALAR> and SlotChain.");
          }
        }
      }

      __req_set.insert(
         &(__bb.requisiteNodes(i)),
         std::pair< Set< NodeId >*, Set< NodeId >* >(attr_set, sc_set));
    }

Here is the call graph for this function:

Here is the caller graph for this function:

__insertEvidence()

template<typename GUM_SCALAR >

INLINE void gum::prm::SVED< GUM_SCALAR >::__insertEvidence ( const PRMInstance< GUM_SCALAR > *  i, BucketSet &  pool  )

private

Returns true if second can be eliminated before first.

Definition at line 504 of file SVED_tpl.h.

References gum::prm::PRMInference< GUM_SCALAR >::evidence(), and gum::Set< Key, Alloc >::insert().

                                                             {
      for (const auto& elt : this->evidence(i))
        pool.insert(const_cast< Potential< GUM_SCALAR >* >(elt.second));
    }

Here is the call graph for this function:

__insertLiftedNodes()

template<typename GUM_SCALAR >

void gum::prm::SVED< GUM_SCALAR >::__insertLiftedNodes ( const PRMInstance< GUM_SCALAR > *  i, BucketSet &  pool, BucketSet &  trash  )

private

Returns true if second can be eliminated before first.

Definition at line 280 of file SVED_tpl.h.

References gum::prm::PRMInstance< GUM_SCALAR >::bijection(), gum::prm::copyPotential(), and gum::Set< Key, Alloc >::insert().

                                                                              {
      BucketSet* lifted_pool = nullptr;

      try {
        lifted_pool = __lifted_pools[&(__bb.requisiteNodes(i))];
      } catch (NotFound&) {
        __initLiftedNodes(i, trash);
        lifted_pool = __lifted_pools[&(__bb.requisiteNodes(i))];
      }

      for (const auto lifted_pot : *lifted_pool) {
        Potential< GUM_SCALAR >* pot = copyPotential(i->bijection(), *lifted_pot);
        pool.insert(pot);
        trash.insert(pot);
      }
    }

Here is the call graph for this function:

__reduceElimList()

template<typename GUM_SCALAR >

INLINE void gum::prm::SVED< GUM_SCALAR >::__reduceElimList ( const PRMInstance< GUM_SCALAR > *  i, List< const PRMInstance< GUM_SCALAR > * > &  elim_list, List< const PRMInstance< GUM_SCALAR > * > &  reduced_list, Set< const PRMInstance< GUM_SCALAR > * > &  ignore, BucketSet &  pool, BucketSet &  trash  )

private

Returns true if second can be eliminated before first.

Definition at line 577 of file SVED_tpl.h.

References gum::prm::SVED< GUM_SCALAR >::__bb, gum::prm::SVED< GUM_SCALAR >::__checkElimOrder(), and gum::prm::SVED< GUM_SCALAR >::__eliminateNodesDownward().

                                                        {
      while (!elim_list.empty()) {
        if (__checkElimOrder(i, elim_list.front())) {
          if ((!ignore.exists(elim_list.front()))
              && (__bb.exists(elim_list.front()))) {
            __eliminateNodesDownward(
               i, elim_list.front(), pool, trash, elim_list, ignore);
          }
        } else if (__bb.exists(elim_list.front())) {
          reduced_list.insert(elim_list.front());
        }

        elim_list.popFront();
      }
    }

Here is the call graph for this function:

__trim()

template<typename GUM_SCALAR >

INLINE std::string gum::prm::SVED< GUM_SCALAR >::__trim ( const std::string &  s )

private

Returns true if second can be eliminated before first.

Definition at line 517 of file SVED_tpl.h.

Referenced by gum::prm::SVED< GUM_SCALAR >::__checkElimOrder().

                                                                  {
      auto pos = s.find_first_of("<");
      if (pos != std::string::npos) { return s.substr(0, pos); }
      return s;
    }

Here is the caller graph for this function:

_evidenceAdded()

template<typename GUM_SCALAR>

INLINE void gum::prm::SVED< GUM_SCALAR >::_evidenceAdded ( const Chain &  chain )

protectedvirtual

See PRMInference::_evidenceAdded().

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

Definition at line 543 of file SVED_tpl.h.

                                                      {
      // Do nothing
    }

_evidenceRemoved()

template<typename GUM_SCALAR>

INLINE void gum::prm::SVED< GUM_SCALAR >::_evidenceRemoved ( const Chain &  chain )

protectedvirtual

See PRMInference::_evidenceRemoved().

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

Definition at line 549 of file SVED_tpl.h.

                                                      {
      // Do nothing
    }

_joint()

template<typename GUM_SCALAR >

void gum::prm::SVED< GUM_SCALAR >::_joint ( const std::vector< Chain > &  queries, Potential< GUM_SCALAR > &  j  )

protectedvirtual

See PRMInference::_joint().

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

Definition at line 457 of file SVED_tpl.h.

References GUM_ERROR.

                                                                   {
      GUM_ERROR(FatalError, "Not implemented.");
    }

_marginal()

template<typename GUM_SCALAR >

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

protectedvirtual

See PRMInference::_marginal().

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

Definition at line 405 of file SVED_tpl.h.

References gum::prm::PRMClassElement< GUM_SCALAR >::id(), gum::Set< Key, Alloc >::insert(), gum::MultiDimDecorator< GUM_SCALAR >::nbrDim(), gum::Potential< GUM_SCALAR >::normalize(), and gum::MultiDimDecorator< GUM_SCALAR >::variablesSequence().

                                                                   {
      const PRMInstance< GUM_SCALAR >*  i = chain.first;
      const PRMAttribute< GUM_SCALAR >* elt = chain.second;
      SVED< GUM_SCALAR >::BucketSet     pool, trash;
      __bb.compute(i, elt->id());
      __eliminateNodes(i, elt->id(), pool, trash);

      std::vector< const Potential< GUM_SCALAR >* > result;
      for (auto pot : pool) {
        if (pot->contains(*(m.variablesSequence().atPos(0))))
          result.push_back(pot);
      }

      while (result.size() > 1) {
        const auto& p1 = *(result.back());
        result.pop_back();
        const auto& p2 = *(result.back());
        result.pop_back();
        auto mult = new Potential< GUM_SCALAR >(p1 * p2);
        result.push_back(mult);
        trash.insert(mult);
      }

      m = *(result.back());
      m.normalize();

      GUM_ASSERT(m.nbrDim() == (Size)1);

      // cleaning up the mess
      for (const auto pot : trash)
        delete pot;

      for (const auto& elt : __lifted_pools)
        delete elt.second;

      __lifted_pools.clear();

      for (const auto& elt : __req_set) {
        delete elt.second.first;
        delete elt.second.second;
      }

      __req_set.clear();

      for (const auto elt : __elim_orders)
        delete elt.second;

      __elim_orders.clear();
    }

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 106 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 33 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 153 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 174 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 163 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 184 of file PRMInference_tpl.h.

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

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 194 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 200 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 206 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 213 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:

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 260 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 231 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::SVED< GUM_SCALAR >::name ( ) const

virtual

Returns the name of the current inference algorithm.

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

Definition at line 600 of file SVED_tpl.h.

                                                    {
      return "SVED";
    }

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

Member Data Documentation

__bb

template<typename GUM_SCALAR>

StructuredBayesBall< GUM_SCALAR > gum::prm::SVED< GUM_SCALAR >::__bb

private

Definition at line 129 of file SVED.h.

Referenced by gum::prm::SVED< GUM_SCALAR >::__getAttrSet(), gum::prm::SVED< GUM_SCALAR >::__getSCSet(), and gum::prm::SVED< GUM_SCALAR >::__reduceElimList().

__class_elim_order

template<typename GUM_SCALAR>

Sequence< std::string >* gum::prm::SVED< GUM_SCALAR >::__class_elim_order

private

Definition at line 127 of file SVED.h.

Referenced by gum::prm::SVED< GUM_SCALAR >::__checkElimOrder().

__elim_orders

template<typename GUM_SCALAR>

HashTable< const PRMClass< GUM_SCALAR >*, std::vector< NodeId >* > gum::prm::SVED< GUM_SCALAR >::__elim_orders

private

Definition at line 118 of file SVED.h.

Referenced by gum::prm::SVED< GUM_SCALAR >::__getElimOrder().

__lifted_pools

template<typename GUM_SCALAR>

HashTable< const Set< NodeId >*, BucketSet* > gum::prm::SVED< GUM_SCALAR >::__lifted_pools

private

The Set<NodeId> returned by StructuredBayesBall<GUM_SCALAR> is unique for each family of instances with the same requisite set (thus the same lifted potentials).

Definition at line 125 of file SVED.h.

__req_set

template<typename GUM_SCALAR>

HashTable< const Set< NodeId >*, std::pair< Set< NodeId >*, Set< NodeId >* > > gum::prm::SVED< GUM_SCALAR >::__req_set

private

First pair -> requisite Attributes Second pair -> requisite SlotChains.

Definition at line 135 of file SVED.h.

Referenced by gum::prm::SVED< GUM_SCALAR >::__getAttrSet(), and gum::prm::SVED< GUM_SCALAR >::__getSCSet().

_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 210 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 213 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().

---

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

• agrum/PRM/inference/SVED.h
• agrum/PRM/inference/SVED_tpl.h