#include <agrum/FMDP/planning/FunctionGraph/imddi.h>

Inheritance diagram for gum::IMDDI< AttributeSelection, isScalar >:

Collaboration diagram for gum::IMDDI< AttributeSelection, isScalar >:

Public Member Functions
void	insertSetOfVars (MultiDimFunctionGraph< double > *ret) const override
Constructor & destructor.
	IMDDI (MultiDimFunctionGraph< double > target, double attributeSelectionThreshold, double pairSelectionThreshold, gum::VariableSet attributeListe, const DiscreteVariable learnedValue)
	Variable Learner constructor.
	IMDDI (MultiDimFunctionGraph< double > *target, double attributeSelectionThreshold, double pairSelectionThreshold, gum::VariableSet attributeListe)
	Reward Learner constructor.
	~IMDDI () override
	Default destructor.
Visit Methods
Size	size ()
NodeId	root () const override
bool	isTerminal (NodeId ni) const override
const DiscreteVariable *	nodeVar (NodeId ni) const override
NodeId	nodeSon (NodeId ni, Idx modality) const override
Idx	nodeNbObservation (NodeId ni) const override

Protected Attributes
MultiDimFunctionGraph< double > *	target_
	The final diagram we're building.
gum::VariableSet	setOfVars_
const DiscreteVariable *	value_
Sequence< ValueType >	valueAssumed_
bool	needUpdate_
Model handling datastructures
NodeGraphPart	model_
	The source of nodeId.
NodeId	root_
	The root of the ordered tree.
HashTable< NodeId, const DiscreteVariable * >	nodeVarMap_
	Gives for any node its associated variable.
HashTable< NodeId, NodeId * >	nodeSonsMap_
	A table giving for any node a table mapping to its son idx is the modality of associated variable.
HashTable< const DiscreteVariable , LinkedList< NodeId > >	var2Node_
	Associates to any variable the list of all nodes associated to this variable.
HashTable< NodeId, NodeDatabase< AttributeSelection, isScalar > * >	nodeId2Database_
	This hashtable binds every node to an associated NodeDatabase which handles every observation that concerns that node.
HashTable< NodeId, Set< const Observation * > * >	leafDatabase_
	This hashtable binds to every leaf an associated set of all hte observations compatible with it.

Private Types
using	ValueType

Private Member Functions
Constructor & destructor.
void	_clearValue_ ()
	Template function dispatcher.
New Observation insertion methods
void	_assumeValue_ (const Observation *obs)
	Get value assumed by studied variable for current observation.
Idx	_branchObs_ (const Observation obs, const DiscreteVariable var)
	Seek modality assumed in obs for given var.

Private Attributes
Sequence< const DiscreteVariable * >	_varOrder_
LeafAggregator	_lg_
HashTable< NodeId, AbstractLeaf * >	_leafMap_
Idx	_nbTotalObservation_
	The total number of observation added to this tree.
double	_attributeSelectionThreshold_
	The threshold above which we consider variables to be dependant.

Incrementals methods
void	addObservation (const Observation *) override
	Adds a new observation to the structure.
void	updateGraph () override
	Updates the tree after a new observation has been added.
void	updateNodeWithObservation_ (const Observation *newObs, NodeId currentNodeId) override
	Adds a new observation to the structure.
NodeId	insertLeafNode_ (NodeDatabase< AttributeSelection, isScalar > nDB, const DiscreteVariable boundVar, Set< const Observation * > *sonsMap) override
	Adds a new observation to the structure.
void	chgNodeBoundVar_ (NodeId chgedNodeId, const DiscreteVariable *desiredVar) override
	Adds a new observation to the structure.
void	removeNode_ (NodeId removedNodeId) override
	Adds a new observation to the structure.
void	_addLeaf_ (NodeId)
	Adds a new observation to the structure.
void	_removeLeaf_ (NodeId)
	Adds a new observation to the structure.

Updating private methods
void	updateFunctionGraph () override
	Computes the score of the given variables for the given node.
void	_updateScore_ (const DiscreteVariable *, NodeId, VariableSelector &vs)
	Computes the score of the given variables for the given node.
void	_downdateScore_ (const DiscreteVariable *, NodeId, VariableSelector &vs)
	Computes the score of the given variables for the given node.
void	_updateNodeSet_ (Set< NodeId > &, const DiscreteVariable *, VariableSelector &)
	For each node in the given set, this methods checks whether or not we should installed the given variable as a test. If so, the node is updated.
void	_rebuildFunctionGraph_ ()
	Computes the score of the given variables for the given node.
NodeId	_insertLeafInFunctionGraph_ (AbstractLeaf *, Int2Type< true >)
	Computes the score of the given variables for the given node.
NodeId	_insertLeafInFunctionGraph_ (AbstractLeaf *, Int2Type< false >)
	Computes the score of the given variables for the given node.

Graph Structure update methods
virtual void	updateVar (const DiscreteVariable *)
	If a new modality appears to exists for given variable, call this method to turn every associated node to this variable into leaf. Graph has then indeed to be revised.
void	updateNode_ (NodeId nody, gum::VariableSet &bestVars)
	From the given sets of node, selects randomly one and installs it on given node.
virtual void	convertNode2Leaf_ (NodeId)
	Turns the given node into a leaf if not already so.
virtual void	transpose_ (NodeId, const DiscreteVariable *)
	Installs given variable to the given node, ensuring that the variable is not present in its subtree.
virtual NodeId	insertNode_ (NodeDatabase< AttributeSelection, isScalar > nDB, const DiscreteVariable boundVar)
	inserts a new node in internal graph
virtual NodeId	insertInternalNode_ (NodeDatabase< AttributeSelection, isScalar > nDB, const DiscreteVariable boundVar, NodeId *sonsMap)
	inserts a new internal node in internal graph

Detailed Description

template<TESTNAME AttributeSelection, bool isScalar = false>
class gum::IMDDI< AttributeSelection, isScalar >

Definition at line 74 of file imddi.h.

Member Typedef Documentation

◆ ValueType

using gum::IncrementalGraphLearner< AttributeSelection, isScalar >::ValueType

privateinherited

Definition at line 84 of file incrementalGraphLearner.h.

Constructor & Destructor Documentation

◆ IMDDI() [1/2]

template<TESTNAME AttributeSelection, bool isScalar>

gum::IMDDI< AttributeSelection, isScalar >::IMDDI	(	MultiDimFunctionGraph< double > *	target,
		double	attributeSelectionThreshold,
		double	pairSelectionThreshold,
		gum::VariableSet	attributeListe,
		const DiscreteVariable *	learnedValue )

Variable Learner constructor.

Definition at line 75 of file imddi_tpl.h.

                                                                                     :
      IncrementalGraphLearner< AttributeSelection, isScalar >(target, attributeListe, learnedValue),
      _lg_(&(this->model_), pairSelectionThreshold), _nbTotalObservation_(0),
      _attributeSelectionThreshold_(attributeSelectionThreshold) {
    GUM_CONSTRUCTOR(IMDDI);
    _addLeaf_(this->root_);
  }

References IMDDI(), gum::IncrementalGraphLearner< AttributeSelection, false >::IncrementalGraphLearner(), _addLeaf_(), _attributeSelectionThreshold_, _lg_, _nbTotalObservation_, gum::IncrementalGraphLearner< AttributeSelection, false >::model_, and gum::IncrementalGraphLearner< AttributeSelection, false >::root_.

Referenced by IMDDI(), IMDDI(), and ~IMDDI().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IMDDI() [2/2]

template<TESTNAME AttributeSelection, bool isScalar>

gum::IMDDI< AttributeSelection, isScalar >::IMDDI	(	MultiDimFunctionGraph< double > *	target,
		double	attributeSelectionThreshold,
		double	pairSelectionThreshold,
		gum::VariableSet	attributeListe )

Reward Learner constructor.

Definition at line 91 of file imddi_tpl.h.

                                                                              :
      IncrementalGraphLearner< AttributeSelection, isScalar >(
          target,
          attributeListe,
          new LabelizedVariable("Reward", "", 2)),
      _lg_(&(this->model_), pairSelectionThreshold), _nbTotalObservation_(0),
      _attributeSelectionThreshold_(attributeSelectionThreshold) {
    GUM_CONSTRUCTOR(IMDDI);
    _addLeaf_(this->root_);
  }

References IMDDI(), gum::IncrementalGraphLearner< AttributeSelection, false >::IncrementalGraphLearner(), _addLeaf_(), _attributeSelectionThreshold_, _lg_, _nbTotalObservation_, gum::IncrementalGraphLearner< AttributeSelection, false >::model_, and gum::IncrementalGraphLearner< AttributeSelection, false >::root_.

Here is the call graph for this function:

◆ ~IMDDI()

template<TESTNAME AttributeSelection, bool isScalar>

gum::IMDDI< AttributeSelection, isScalar >::~IMDDI ( )

override

Default destructor.

Definition at line 109 of file imddi_tpl.h.

                                                {
    GUM_DESTRUCTOR(IMDDI);
    for (HashTableIteratorSafe< NodeId, AbstractLeaf* > leafIter = _leafMap_.beginSafe();
         leafIter != _leafMap_.endSafe();
         ++leafIter)
      delete leafIter.val();
  }

References IMDDI(), and _leafMap_.

Here is the call graph for this function:

Member Function Documentation

◆ _addLeaf_()

template<TESTNAME AttributeSelection, bool isScalar>

void gum::IMDDI< AttributeSelection, isScalar >::_addLeaf_ ( NodeId currentNodeId )

private

Adds a new observation to the structure.

Definition at line 298 of file imddi_tpl.h.

                                                                            {
    _leafMap_.insert(
        currentNodeId,
        new ConcreteLeaf< AttributeSelection, isScalar >(currentNodeId,
                                                         this->nodeId2Database_[currentNodeId],
                                                         &(this->valueAssumed_)));
    _lg_.addLeaf(_leafMap_[currentNodeId]);
  }

References _leafMap_, _lg_, gum::IncrementalGraphLearner< AttributeSelection, false >::nodeId2Database_, and gum::IncrementalGraphLearner< AttributeSelection, false >::valueAssumed_.

Referenced by IMDDI(), IMDDI(), chgNodeBoundVar_(), and insertLeafNode_().

Here is the caller graph for this function:

◆ _assumeValue_()

void gum::IncrementalGraphLearner< AttributeSelection, isScalar >::_assumeValue_ ( const Observation * obs )

privateinherited

Get value assumed by studied variable for current observation.

Definition at line 153 of file incrementalGraphLearner_tpl.h.

                              {
    _assumeValue_(obs, Int2Type< isScalar >());
  }

References leafDatabase_, and updateNodeWithObservation_().

Here is the call graph for this function:

◆ _branchObs_()

Idx gum::IncrementalGraphLearner< AttributeSelection, isScalar >::_branchObs_	(	const Observation *	obs,
		const DiscreteVariable *	var )

privateinherited

Seek modality assumed in obs for given var.

Definition at line 164 of file incrementalGraphLearner_tpl.h.

                                   {
    return _branchObs_(obs, var, Int2Type< isScalar >());
  }

Referenced by addObservation().

Here is the caller graph for this function:

◆ _clearValue_()

void gum::IncrementalGraphLearner< AttributeSelection, isScalar >::_clearValue_ ( )

privateinherited

Template function dispatcher.

Definition at line 117 of file incrementalGraphLearner_tpl.h.

                                                                             {
    _clearValue_(Int2Type< isScalar >());
  }

References IncrementalGraphLearner(), _clearValue_(), and leafDatabase_.

Referenced by _clearValue_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _downdateScore_()

template<TESTNAME AttributeSelection, bool isScalar>

void gum::IMDDI< AttributeSelection, isScalar >::_downdateScore_	(	const DiscreteVariable *	var,
		NodeId	nody,
		VariableSelector &	vs )

private

Computes the score of the given variables for the given node.

Definition at line 201 of file imddi_tpl.h.

                                                                                          {
    if (!this->nodeId2Database_[nody]->isTestRelevant(var)) return;
    double weight = (double)this->nodeId2Database_[nody]->nbObservation()
                  / (double)this->_nbTotalObservation_;
    vs.downdateScore(var,
                     weight * this->nodeId2Database_[nody]->testValue(var),
                     weight * this->nodeId2Database_[nody]->testOtherCriterion(var));
  }

References _nbTotalObservation_, gum::VariableSelector::downdateScore(), and gum::IncrementalGraphLearner< AttributeSelection, false >::nodeId2Database_.

Referenced by _updateNodeSet_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _insertLeafInFunctionGraph_() [1/2]

template<TESTNAME AttributeSelection, bool isScalar>

NodeId gum::IMDDI< AttributeSelection, isScalar >::_insertLeafInFunctionGraph_	(	AbstractLeaf *	leaf,
		Int2Type< false >	)

private

Computes the score of the given variables for the given node.

Definition at line 403 of file imddi_tpl.h.

                                                                                               {
    NodeId* sonsMap
        = static_cast< NodeId* >(SOA_ALLOCATE(sizeof(NodeId) * this->value_->domainSize()));
    for (Idx modality = 0; modality < this->value_->domainSize(); ++modality) {
      double newVal = 0.0;
      if (leaf->total()) newVal = (double)leaf->effectif(modality) / (double)leaf->total();
      sonsMap[modality] = this->target_->manager()->addTerminalNode(newVal);
    }
    return this->target_->manager()->addInternalNode(this->value_, sonsMap);
  }

References gum::AbstractLeaf::effectif(), SOA_ALLOCATE, gum::IncrementalGraphLearner< AttributeSelection, false >::target_, gum::AbstractLeaf::total(), and gum::IncrementalGraphLearner< AttributeSelection, false >::value_.

Here is the call graph for this function:

◆ _insertLeafInFunctionGraph_() [2/2]

template<TESTNAME AttributeSelection, bool isScalar>

NodeId gum::IMDDI< AttributeSelection, isScalar >::_insertLeafInFunctionGraph_	(	AbstractLeaf *	leaf,
		Int2Type< true >	)

private

Computes the score of the given variables for the given node.

Definition at line 389 of file imddi_tpl.h.

                                                                                              {
    double value = 0.0;
    for (Idx moda = 0; moda < leaf->nbModa(); moda++) {
      value += (double)leaf->effectif(moda) * this->valueAssumed_.atPos(moda);
    }
    if (leaf->total()) value /= (double)leaf->total();
    return this->target_->manager()->addTerminalNode(value);
  }

References gum::AbstractLeaf::effectif(), gum::AbstractLeaf::nbModa(), gum::IncrementalGraphLearner< AttributeSelection, false >::target_, gum::AbstractLeaf::total(), and gum::IncrementalGraphLearner< AttributeSelection, false >::valueAssumed_.

Referenced by _rebuildFunctionGraph_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _rebuildFunctionGraph_()

template<TESTNAME AttributeSelection, bool isScalar>

void gum::IMDDI< AttributeSelection, isScalar >::_rebuildFunctionGraph_ ( )

private

Computes the score of the given variables for the given node.

Definition at line 333 of file imddi_tpl.h.

                                                                     {
    // *******************************************************************************************************
    // Mise à jour de l'aggregateur de feuille
    _lg_.update();
 
    // *******************************************************************************************************
    // Reinitialisation du Graphe de Décision
    this->target_->clear();
    for (auto varIter = _varOrder_.beginSafe(); varIter != _varOrder_.endSafe(); ++varIter)
      this->target_->add(**varIter);
    this->target_->add(*this->value_);
 
    HashTable< NodeId, NodeId > toTarget;
 
    // *******************************************************************************************************
    // Insertion des feuilles
    HashTable< NodeId, AbstractLeaf* > treeNode2leaf = _lg_.leavesMap();
    HashTable< AbstractLeaf*, NodeId > leaf2DGNode;
    for (HashTableConstIteratorSafe< NodeId, AbstractLeaf* > treeNodeIter
         = treeNode2leaf.cbeginSafe();
         treeNodeIter != treeNode2leaf.cendSafe();
         ++treeNodeIter) {
      if (!leaf2DGNode.exists(treeNodeIter.val()))
        leaf2DGNode.insert(treeNodeIter.val(),
                           _insertLeafInFunctionGraph_(treeNodeIter.val(), Int2Type< isScalar >()));
 
      toTarget.insert(treeNodeIter.key(), leaf2DGNode[treeNodeIter.val()]);
    }
 
    // *******************************************************************************************************
    // Insertion des noeuds internes (avec vérification des possibilités de
    // fusion)
    for (SequenceIteratorSafe< const DiscreteVariable* > varIter = _varOrder_.rbeginSafe();
         varIter != _varOrder_.rendSafe();
         --varIter) {
      for (Link< NodeId >* curNodeIter = this->var2Node_[*varIter]->list(); curNodeIter;
           curNodeIter                 = curNodeIter->nextLink()) {
        NodeId* sonsMap
            = static_cast< NodeId* >(SOA_ALLOCATE(sizeof(NodeId) * (*varIter)->domainSize()));
        for (Idx modality = 0; modality < (*varIter)->domainSize(); ++modality)
          sonsMap[modality] = toTarget[this->nodeSonsMap_[curNodeIter->element()][modality]];
        toTarget.insert(curNodeIter->element(),
                        this->target_->manager()->addInternalNode(*varIter, sonsMap));
      }
    }
 
    // *******************************************************************************************************
    // Polish
    this->target_->manager()->setRootNode(toTarget[this->root_]);
    this->target_->manager()->clean();
  }

References _insertLeafInFunctionGraph_(), _lg_, _varOrder_, gum::HashTable< Key, Val >::cbeginSafe(), gum::HashTable< Key, Val >::cendSafe(), gum::HashTable< Key, Val >::exists(), gum::HashTable< Key, Val >::insert(), gum::IncrementalGraphLearner< AttributeSelection, false >::nodeSonsMap_, gum::IncrementalGraphLearner< AttributeSelection, false >::root_, SOA_ALLOCATE, gum::IncrementalGraphLearner< AttributeSelection, false >::target_, gum::IncrementalGraphLearner< AttributeSelection, false >::value_, and gum::IncrementalGraphLearner< AttributeSelection, false >::var2Node_.

Referenced by updateFunctionGraph().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _removeLeaf_()

template<TESTNAME AttributeSelection, bool isScalar>

void gum::IMDDI< AttributeSelection, isScalar >::_removeLeaf_ ( NodeId currentNodeId )

private

Adds a new observation to the structure.

Definition at line 311 of file imddi_tpl.h.

                                                                               {
    _lg_.removeLeaf(_leafMap_[currentNodeId]);
    delete _leafMap_[currentNodeId];
    _leafMap_.erase(currentNodeId);
  }

References _leafMap_, and _lg_.

Referenced by chgNodeBoundVar_(), and removeNode_().

Here is the caller graph for this function:

◆ _updateNodeSet_()

template<TESTNAME AttributeSelection, bool isScalar>

void gum::IMDDI< AttributeSelection, isScalar >::_updateNodeSet_	(	Set< NodeId > &	nodeSet,
		const DiscreteVariable *	selectedVar,
		VariableSelector &	vs )

private

For each node in the given set, this methods checks whether or not we should installed the given variable as a test. If so, the node is updated.

Definition at line 218 of file imddi_tpl.h.

                                                                                          {
    Set< NodeId > oldNodeSet(nodeSet);
    nodeSet.clear();
    for (SetIteratorSafe< NodeId > nodeIter = oldNodeSet.beginSafe();
         nodeIter != oldNodeSet.endSafe();
         ++nodeIter) {
      if (this->nodeId2Database_[*nodeIter]->isTestRelevant(selectedVar)
          && this->nodeId2Database_[*nodeIter]->testValue(selectedVar)
                 > _attributeSelectionThreshold_) {
        this->transpose_(*nodeIter, selectedVar);
 
        // Then we subtract the from the score given to each variables the
        // quantity given by this node
        for (vs.begin(); vs.hasNext(); vs.next()) {
          _downdateScore_(vs.current(), *nodeIter, vs);
        }
 
        // And finally we add all its child to the new set of nodes
        // and updates the remaining var's score
        for (Idx modality = 0; modality < this->nodeVarMap_[*nodeIter]->domainSize(); ++modality) {
          NodeId sonId = this->nodeSonsMap_[*nodeIter][modality];
          nodeSet << sonId;
 
          for (vs.begin(); vs.hasNext(); vs.next()) {
            _updateScore_(vs.current(), sonId, vs);
          }
        }
      } else {
        nodeSet << *nodeIter;
      }
    }
  }

References _attributeSelectionThreshold_, _downdateScore_(), _updateScore_(), gum::VariableSelector::begin(), gum::Set< Key >::beginSafe(), gum::Set< Key >::clear(), gum::VariableSelector::current(), gum::Set< Key >::endSafe(), gum::VariableSelector::hasNext(), gum::VariableSelector::next(), gum::IncrementalGraphLearner< AttributeSelection, false >::nodeId2Database_, gum::IncrementalGraphLearner< AttributeSelection, false >::nodeSonsMap_, gum::IncrementalGraphLearner< AttributeSelection, false >::nodeVarMap_, and gum::IncrementalGraphLearner< AttributeSelection, false >::transpose_().

Referenced by updateGraph().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _updateScore_()

template<TESTNAME AttributeSelection, bool isScalar>

void gum::IMDDI< AttributeSelection, isScalar >::_updateScore_	(	const DiscreteVariable *	var,
		NodeId	nody,
		VariableSelector &	vs )

private

Computes the score of the given variables for the given node.

Definition at line 189 of file imddi_tpl.h.

                                                                                        {
    if (!this->nodeId2Database_[nody]->isTestRelevant(var)) return;
    double weight = (double)this->nodeId2Database_[nody]->nbObservation()
                  / (double)this->_nbTotalObservation_;
    vs.updateScore(var,
                   weight * this->nodeId2Database_[nody]->testValue(var),
                   weight * this->nodeId2Database_[nody]->testOtherCriterion(var));
  }

References _nbTotalObservation_, gum::IncrementalGraphLearner< AttributeSelection, false >::nodeId2Database_, and gum::VariableSelector::updateScore().

Referenced by _updateNodeSet_(), and updateGraph().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addObservation()

template<TESTNAME AttributeSelection, bool isScalar>

void gum::IMDDI< AttributeSelection, isScalar >::addObservation ( const Observation * obs )

overridevirtual

Adds a new observation to the structure.

Reimplemented from gum::IncrementalGraphLearner< AttributeSelection, false >.

Definition at line 122 of file imddi_tpl.h.

                                                                                   {
    _nbTotalObservation_++;
    IncrementalGraphLearner< AttributeSelection, isScalar >::addObservation(obs);
  }

References _nbTotalObservation_, and gum::IncrementalGraphLearner< AttributeSelection, isScalar >::addObservation().

Here is the call graph for this function:

◆ chgNodeBoundVar_()

template<TESTNAME AttributeSelection, bool isScalar>

void gum::IMDDI< AttributeSelection, isScalar >::chgNodeBoundVar_	(	NodeId	chgedNodeId,
		const DiscreteVariable *	desiredVar )

overrideprotectedvirtual

Adds a new observation to the structure.

Reimplemented from gum::IncrementalGraphLearner< AttributeSelection, false >.

Definition at line 275 of file imddi_tpl.h.

                                                                                                   {
    if (this->nodeVarMap_[currentNodeId] == this->value_) _removeLeaf_(currentNodeId);
 
    IncrementalGraphLearner< AttributeSelection, isScalar >::chgNodeBoundVar_(currentNodeId,
                                                                              desiredVar);
 
    if (desiredVar == this->value_) _addLeaf_(currentNodeId);
  }

References _addLeaf_(), _removeLeaf_(), gum::IncrementalGraphLearner< AttributeSelection, isScalar >::chgNodeBoundVar_(), gum::IncrementalGraphLearner< AttributeSelection, false >::nodeVarMap_, and gum::IncrementalGraphLearner< AttributeSelection, false >::value_.

Here is the call graph for this function:

◆ convertNode2Leaf_()

void gum::IncrementalGraphLearner< AttributeSelection, isScalar >::convertNode2Leaf_ ( NodeId currentNodeId )

protectedvirtualinherited

Turns the given node into a leaf if not already so.

Definition at line 218 of file incrementalGraphLearner_tpl.h.

                            {
    if (nodeVarMap_[currentNodeId] != value_) {
      leafDatabase_.insert(currentNodeId, new Set< const Observation* >());
 
      // Resolving tensor sons issue
      for (Idx modality = 0; modality < nodeVarMap_[currentNodeId]->domainSize(); ++modality) {
        NodeId sonId = nodeSonsMap_[currentNodeId][modality];
        convertNode2Leaf_(sonId);
        (*leafDatabase_[currentNodeId]) = (*leafDatabase_[currentNodeId]) + *(leafDatabase_[sonId]);
        removeNode_(sonId);
      }
 
      SOA_DEALLOCATE(nodeSonsMap_[currentNodeId],
                     sizeof(NodeId) * nodeVarMap_[currentNodeId]->domainSize());
      nodeSonsMap_.erase(currentNodeId);
 
      chgNodeBoundVar_(currentNodeId, value_);
    }
  }

Referenced by transpose_(), and gum::IMDDI< AttributeSelection, isScalar >::updateGraph().

Here is the caller graph for this function:

◆ insertInternalNode_()

NodeId gum::IncrementalGraphLearner< AttributeSelection, isScalar >::insertInternalNode_	(	NodeDatabase< AttributeSelection, isScalar > *	nDB,
		const DiscreteVariable *	boundVar,
		NodeId *	sonsMap )

protectedvirtualinherited

inserts a new internal node in internal graph

Parameters

nDB	: the associated database
boundVar	: the associated variable
sonsMap	: a table giving node's sons node

Returns: the newly created node's id

Definition at line 246 of file incrementalGraphLearner_tpl.h.

                                                             {
    NodeId newNodeId = this->insertNode_(nDB, boundVar);
    nodeSonsMap_.insert(newNodeId, sonsMap);
    return newNodeId;
  }

References nodeVarMap_, and value_.

◆ insertLeafNode_()

template<TESTNAME AttributeSelection, bool isScalar>

NodeId gum::IMDDI< AttributeSelection, isScalar >::insertLeafNode_	(	NodeDatabase< AttributeSelection, isScalar > *	nDB,
		const DiscreteVariable *	boundVar,
		Set< const Observation * > *	sonsMap )

overrideprotectedvirtual

Adds a new observation to the structure.

Reimplemented from gum::IncrementalGraphLearner< AttributeSelection, false >.

Definition at line 257 of file imddi_tpl.h.

                                                            {
    NodeId currentNodeId
        = IncrementalGraphLearner< AttributeSelection, isScalar >::insertLeafNode_(nDB,
                                                                                   boundVar,
                                                                                   obsSet);
 
    _addLeaf_(currentNodeId);
 
    return currentNodeId;
  }

References _addLeaf_(), and gum::IncrementalGraphLearner< AttributeSelection, isScalar >::insertLeafNode_().

Here is the call graph for this function:

◆ insertNode_()

NodeId gum::IncrementalGraphLearner< AttributeSelection, isScalar >::insertNode_	(	NodeDatabase< AttributeSelection, isScalar > *	nDB,
		const DiscreteVariable *	boundVar )

protectedvirtualinherited

inserts a new node in internal graph

Parameters

nDB	: the associated database
boundVar	: the associated variable

Returns: the newly created node's id

Reimplemented in gum::ITI< AttributeSelection, isScalar >.

Definition at line 234 of file incrementalGraphLearner_tpl.h.

                                                              {
    NodeId newNodeId = model_.addNode();
    nodeVarMap_.insert(newNodeId, boundVar);
    nodeId2Database_.insert(newNodeId, nDB);
    var2Node_[boundVar]->addLink(newNodeId);
 
    needUpdate_ = true;
 
    return newNodeId;
  }

References chgNodeBoundVar_(), and value_.

Here is the call graph for this function:

◆ insertSetOfVars()

template<TESTNAME AttributeSelection, bool isScalar>

void gum::IMDDI< AttributeSelection, isScalar >::insertSetOfVars ( MultiDimFunctionGraph< double > * ret ) const

overridevirtual

Implements gum::IVisitableGraphLearner.

Definition at line 416 of file imddi_tpl.h.

                                                  {
    for (SequenceIteratorSafe< const DiscreteVariable* > varIter = _varOrder_.beginSafe();
         varIter != _varOrder_.endSafe();
         ++varIter)
      ret->add(**varIter);
  }

References _varOrder_, and gum::MultiDimFunctionGraph< GUM_ELEMENT, TerminalNodePolicy >::add().

Here is the call graph for this function:

◆ isTerminal()

bool gum::IncrementalGraphLearner< AttributeSelection, isScalar >::isTerminal ( NodeId ni ) const

overridevirtualinherited

Implements gum::IVisitableGraphLearner.

Definition at line 307 of file incrementalGraphLearner_tpl.h.

                                                                                          {
    return !this->nodeSonsMap_.exists(ni);
  }

◆ nodeNbObservation()

Idx gum::IncrementalGraphLearner< AttributeSelection, isScalar >::nodeNbObservation ( NodeId ni ) const

overridevirtualinherited

Implements gum::IVisitableGraphLearner.

Definition at line 313 of file incrementalGraphLearner_tpl.h.

                                                                                                {
    return this->nodeId2Database_[ni]->nbObservation();
  }

◆ nodeSon()

NodeId gum::IncrementalGraphLearner< AttributeSelection, isScalar >::nodeSon	(	NodeId	ni,
		Idx	modality ) const

overridevirtualinherited

Implements gum::IVisitableGraphLearner.

Definition at line 311 of file incrementalGraphLearner_tpl.h.

                                                                                                 {
    return this->nodeSonsMap_[ni][modality];
  }

◆ nodeVar()

const DiscreteVariable * gum::IncrementalGraphLearner< AttributeSelection, isScalar >::nodeVar ( NodeId ni ) const

overridevirtualinherited

Implements gum::IVisitableGraphLearner.

Definition at line 309 of file incrementalGraphLearner_tpl.h.

                                                                                      {
    return this->nodeVarMap_[ni];
  }

◆ removeNode_()

template<TESTNAME AttributeSelection, bool isScalar>

void gum::IMDDI< AttributeSelection, isScalar >::removeNode_ ( NodeId removedNodeId )

overrideprotectedvirtual

Adds a new observation to the structure.

Reimplemented from gum::IncrementalGraphLearner< AttributeSelection, false >.

Definition at line 289 of file imddi_tpl.h.

                                                                              {
    if (this->nodeVarMap_[currentNodeId] == this->value_) _removeLeaf_(currentNodeId);
    IncrementalGraphLearner< AttributeSelection, isScalar >::removeNode_(currentNodeId);
  }

References _removeLeaf_(), gum::IncrementalGraphLearner< AttributeSelection, false >::nodeVarMap_, gum::IncrementalGraphLearner< AttributeSelection, isScalar >::removeNode_(), and gum::IncrementalGraphLearner< AttributeSelection, false >::value_.

Here is the call graph for this function:

◆ root()

NodeId gum::IncrementalGraphLearner< AttributeSelection, isScalar >::root ( ) const

overridevirtualinherited

Implements gum::IVisitableGraphLearner.

Definition at line 305 of file incrementalGraphLearner_tpl.h.

                                                                             {
    return this->root_;
  }

◆ size()

Size gum::IncrementalGraphLearner< AttributeSelection, isScalar >::size ( )

inherited

Definition at line 303 of file incrementalGraphLearner_tpl.h.

                                                                     {
    return nodeVarMap_.size();
  }

References nodeSonsMap_, nodeVarMap_, and transpose_().

Here is the call graph for this function:

◆ transpose_()

void gum::IncrementalGraphLearner< AttributeSelection, isScalar >::transpose_	(	NodeId	currentNodeId,
		const DiscreteVariable *	desiredVar )

protectedvirtualinherited

Installs given variable to the given node, ensuring that the variable is not present in its subtree.

Definition at line 224 of file incrementalGraphLearner_tpl.h.

                                          {
    // **************************************************************************************
    // Si le noeud courant contient déjà la variable qu'on souhaite lui amener
    // Il n'y a rien à faire
    if (nodeVarMap_[currentNodeId] == desiredVar) { return; }
 
    // **************************************************************************************
    // Si le noeud courant est terminal,
    // Il faut artificiellement insérer un noeud liant à la variable
    if (nodeVarMap_[currentNodeId] == value_) {
      // We turned this leaf into an internal node.
      // This mean that we'll need to install children leaves for each value of
      // desiredVar
 
      // First We must prepare these new leaves NodeDatabases and Sets<const
      // Observation*>
      NodeDatabase< AttributeSelection, isScalar >** dbMap
          = static_cast< NodeDatabase< AttributeSelection, isScalar >** >(SOA_ALLOCATE(
              sizeof(NodeDatabase< AttributeSelection, isScalar >*) * desiredVar->domainSize()));
      Set< const Observation* >** obsetMap = static_cast< Set< const Observation* >** >(
          SOA_ALLOCATE(sizeof(Set< const Observation* >*) * desiredVar->domainSize()));
      for (Idx modality = 0; modality < desiredVar->domainSize(); ++modality) {
        dbMap[modality]    = new NodeDatabase< AttributeSelection, isScalar >(&setOfVars_, value_);
        obsetMap[modality] = new Set< const Observation* >();
      }
      for (SetIteratorSafe< const Observation* > obsIter
           = leafDatabase_[currentNodeId]->beginSafe();
           leafDatabase_[currentNodeId]->endSafe() != obsIter;
           ++obsIter) {
        dbMap[_branchObs_(*obsIter, desiredVar)]->addObservation(*obsIter);
        obsetMap[_branchObs_(*obsIter, desiredVar)]->insert(*obsIter);
      }
 
      // Then we can install each new leaves (and put in place the sonsMap)
      NodeId* sonsMap
          = static_cast< NodeId* >(SOA_ALLOCATE(sizeof(NodeId) * desiredVar->domainSize()));
      for (Idx modality = 0; modality < desiredVar->domainSize(); ++modality)
        sonsMap[modality] = insertLeafNode_(dbMap[modality], value_, obsetMap[modality]);
 
      // Some necessary clean up
      SOA_DEALLOCATE(dbMap,
                     sizeof(NodeDatabase< AttributeSelection, isScalar >*)
                         * desiredVar->domainSize());
      SOA_DEALLOCATE(obsetMap, sizeof(Set< const Observation* >*) * desiredVar->domainSize());
 
      // And finally we can turn the node into an internal node associated to
      // desiredVar
      chgNodeBoundVar_(currentNodeId, desiredVar);
      nodeSonsMap_.insert(currentNodeId, sonsMap);
 
      return;
    }
 
    // *************************************************************************************
    // Remains the general case where currentNodeId is an internal node.
 
    // First we ensure that children node use desiredVar as variable
    for (Idx modality = 0; modality < nodeVarMap_[currentNodeId]->domainSize(); ++modality)
      transpose_(nodeSonsMap_[currentNodeId][modality], desiredVar);
 
    //        Sequence<NodeDatabase<AttributeSelection, isScalar>*>
    //        sonsNodeDatabase =
    //        nodeId2Database_[currentNodeId]->splitOnVar(desiredVar);
    NodeId* sonsMap
        = static_cast< NodeId* >(SOA_ALLOCATE(sizeof(NodeId) * desiredVar->domainSize()));
 
    // Then we create the new mapping
    for (Idx desiredVarModality = 0; desiredVarModality < desiredVar->domainSize();
         ++desiredVarModality) {
      NodeId* grandSonsMap = static_cast< NodeId* >(
          SOA_ALLOCATE(sizeof(NodeId) * nodeVarMap_[currentNodeId]->domainSize()));
      NodeDatabase< AttributeSelection, isScalar >* sonDB
          = new NodeDatabase< AttributeSelection, isScalar >(&setOfVars_, value_);
      for (Idx currentVarModality = 0;
           currentVarModality < nodeVarMap_[currentNodeId]->domainSize();
           ++currentVarModality) {
        grandSonsMap[currentVarModality]
            = nodeSonsMap_[nodeSonsMap_[currentNodeId][currentVarModality]][desiredVarModality];
        sonDB->operator+=((*nodeId2Database_[grandSonsMap[currentVarModality]]));
      }
 
      sonsMap[desiredVarModality]
          = insertInternalNode_(sonDB, nodeVarMap_[currentNodeId], grandSonsMap);
    }
 
    // Finally we clean the old remaining nodes
    for (Idx currentVarModality = 0; currentVarModality < nodeVarMap_[currentNodeId]->domainSize();
         ++currentVarModality) {
      removeNode_(nodeSonsMap_[currentNodeId][currentVarModality]);
    }
 
    // We suppress the old sons map and remap to the new one
    SOA_DEALLOCATE(nodeSonsMap_[currentNodeId],
                   sizeof(NodeId) * nodeVarMap_[currentNodeId]->domainSize());
    nodeSonsMap_[currentNodeId] = sonsMap;
 
    chgNodeBoundVar_(currentNodeId, desiredVar);
  }

References convertNode2Leaf_(), leafDatabase_, nodeSonsMap_, nodeVarMap_, and removeNode_().

Referenced by gum::IMDDI< AttributeSelection, isScalar >::_updateNodeSet_(), and size().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ updateFunctionGraph()

template<TESTNAME AttributeSelection, bool isScalar>

void gum::IMDDI< AttributeSelection, isScalar >::updateFunctionGraph ( )

overridevirtual

Computes the score of the given variables for the given node.

Implements gum::IncrementalGraphLearner< AttributeSelection, false >.

Definition at line 322 of file imddi_tpl.h.

                                                                  {
    //      if(  _lg_.needsUpdate() || this->needUpdate_ ){
    _rebuildFunctionGraph_();
    this->needUpdate_ = false;
    //      }
  }

References _rebuildFunctionGraph_(), and gum::IncrementalGraphLearner< AttributeSelection, false >::needUpdate_.

Here is the call graph for this function:

◆ updateGraph()

template<TESTNAME AttributeSelection, bool isScalar>

void gum::IMDDI< AttributeSelection, isScalar >::updateGraph ( )

overridevirtual

Updates the tree after a new observation has been added.

Implements gum::IncrementalGraphLearner< AttributeSelection, false >.

Definition at line 140 of file imddi_tpl.h.

                                                          {
    _varOrder_.clear();
 
    // First xe initialize the node set which will give us the scores
    Set< NodeId > currentNodeSet;
    currentNodeSet.insert(this->root_);
 
    // Then we initialize the pool of variables to consider
    VariableSelector vs(this->setOfVars_);
    for (vs.begin(); vs.hasNext(); vs.next()) {
      _updateScore_(vs.current(), this->root_, vs);
    }
 
    // Then, until there's no node remaining
    while (!vs.isEmpty()) {
      // We select the best var
      const DiscreteVariable* selectedVar = vs.select();
      _varOrder_.insert(selectedVar);
 
      // Then we decide if we update each node according to this var
      _updateNodeSet_(currentNodeSet, selectedVar, vs);
    }
 
    // If there are remaining node that are not leaves after we establish the
    // var order
    // these nodes are turned into leaf.
    for (SetIteratorSafe< NodeId > nodeIter = currentNodeSet.beginSafe();
         nodeIter != currentNodeSet.endSafe();
         ++nodeIter)
      this->convertNode2Leaf_(*nodeIter);
 
 
    if (_lg_.needsUpdate()) _lg_.update();
  }

References _lg_, _updateNodeSet_(), _updateScore_(), _varOrder_, gum::VariableSelector::begin(), gum::Set< Key >::beginSafe(), gum::IncrementalGraphLearner< AttributeSelection, false >::convertNode2Leaf_(), gum::VariableSelector::current(), gum::Set< Key >::endSafe(), gum::VariableSelector::hasNext(), gum::Set< Key >::insert(), gum::VariableSelector::isEmpty(), gum::VariableSelector::next(), gum::IncrementalGraphLearner< AttributeSelection, false >::root_, gum::VariableSelector::select(), and gum::IncrementalGraphLearner< AttributeSelection, false >::setOfVars_.

Here is the call graph for this function:

◆ updateNode_()

void gum::IncrementalGraphLearner< AttributeSelection, isScalar >::updateNode_	(	NodeId	updatedNode,
		gum::VariableSet &	varsOfInterest )

protectedinherited

From the given sets of node, selects randomly one and installs it on given node.

Chechks of course if node's current variable is not in that set first.

Parameters

nody	: the node we update
bestVars	: the set of interessting vars to be installed here

Chechks of course if node's current variable is not in that set first.

Parameters

nody	: the node we update
bestVar	: the set of interessting vars to be installed here

Definition at line 213 of file incrementalGraphLearner_tpl.h.

                                      {
    // If this node has no interesting variable, we turn it into a leaf
    if (varsOfInterest.empty()) {
      convertNode2Leaf_(updatedNode);
      return;
    }
 
    // If this node has already one of the best variable intalled as test, we
    // move on
    if (nodeVarMap_.exists(updatedNode) && varsOfInterest.exists(nodeVarMap_[updatedNode])) {
      return;
    }
 
    // In any other case we have to install variable as best test
    Idx randy = randomValue(varsOfInterest.size()), basc = 0;
    SetConstIteratorSafe< const DiscreteVariable* > varIter;
    for (varIter = varsOfInterest.cbeginSafe(), basc = 0;
         varIter != varsOfInterest.cendSafe() && basc < randy;
         ++varIter, basc++)
      ;
 
    transpose_(updatedNode, *varIter);
  }

Referenced by gum::ITI< AttributeSelection, isScalar >::updateGraph().

Here is the caller graph for this function:

◆ updateNodeWithObservation_()

template<TESTNAME AttributeSelection, bool isScalar>

void gum::IMDDI< AttributeSelection, isScalar >::updateNodeWithObservation_	(	const Observation *	newObs,
		NodeId	currentNodeId )

overrideprotectedvirtual

Adds a new observation to the structure.

Reimplemented from gum::IncrementalGraphLearner< AttributeSelection, false >.

Definition at line 128 of file imddi_tpl.h.

                                                                                               {
    IncrementalGraphLearner< AttributeSelection, isScalar >::updateNodeWithObservation_(
        newObs,
        currentNodeId);
    if (this->nodeVarMap_[currentNodeId] == this->value_) _lg_.updateLeaf(_leafMap_[currentNodeId]);
  }

References _leafMap_, _lg_, gum::IncrementalGraphLearner< AttributeSelection, false >::nodeVarMap_, gum::IncrementalGraphLearner< AttributeSelection, isScalar >::updateNodeWithObservation_(), and gum::IncrementalGraphLearner< AttributeSelection, false >::value_.

Here is the call graph for this function:

◆ updateVar()

void gum::IncrementalGraphLearner< AttributeSelection, isScalar >::updateVar ( const DiscreteVariable * var )

virtualinherited

If a new modality appears to exists for given variable, call this method to turn every associated node to this variable into leaf. Graph has then indeed to be revised.

Definition at line 195 of file incrementalGraphLearner_tpl.h.

                                   {
    Link< NodeId >* nodIter = var2Node_[var]->list();
    Link< NodeId >* nni     = nullptr;
    while (nodIter) {
      nni = nodIter->nextLink();
      convertNode2Leaf_(nodIter->element());
      nodIter = nni;
    }
  }

Member Data Documentation

◆ _attributeSelectionThreshold_

template<TESTNAME AttributeSelection, bool isScalar = false>

double gum::IMDDI< AttributeSelection, isScalar >::_attributeSelectionThreshold_

private

The threshold above which we consider variables to be dependant.

Definition at line 187 of file imddi.h.

Referenced by IMDDI(), IMDDI(), and _updateNodeSet_().

◆ _leafMap_

template<TESTNAME AttributeSelection, bool isScalar = false>

HashTable< NodeId, AbstractLeaf* > gum::IMDDI< AttributeSelection, isScalar >::_leafMap_

private

Definition at line 181 of file imddi.h.

Referenced by ~IMDDI(), _addLeaf_(), _removeLeaf_(), and updateNodeWithObservation_().

◆ _lg_

template<TESTNAME AttributeSelection, bool isScalar = false>

LeafAggregator gum::IMDDI< AttributeSelection, isScalar >::_lg_

private

Definition at line 179 of file imddi.h.

Referenced by IMDDI(), IMDDI(), _addLeaf_(), _rebuildFunctionGraph_(), _removeLeaf_(), updateGraph(), and updateNodeWithObservation_().

◆ _nbTotalObservation_

template<TESTNAME AttributeSelection, bool isScalar = false>

Idx gum::IMDDI< AttributeSelection, isScalar >::_nbTotalObservation_

private

The total number of observation added to this tree.

Definition at line 184 of file imddi.h.

Referenced by IMDDI(), IMDDI(), _downdateScore_(), _updateScore_(), and addObservation().

◆ _varOrder_

template<TESTNAME AttributeSelection, bool isScalar = false>

Sequence< const DiscreteVariable* > gum::IMDDI< AttributeSelection, isScalar >::_varOrder_

private

Definition at line 177 of file imddi.h.

Referenced by _rebuildFunctionGraph_(), insertSetOfVars(), and updateGraph().

◆ leafDatabase_

HashTable< NodeId, Set< const Observation* >* > gum::IncrementalGraphLearner< AttributeSelection, isScalar >::leafDatabase_

protectedinherited

This hashtable binds to every leaf an associated set of all hte observations compatible with it.

Definition at line 364 of file incrementalGraphLearner.h.

Referenced by _assumeValue_(), _clearValue_(), and transpose_().

◆ model_

NodeGraphPart gum::IncrementalGraphLearner< AttributeSelection, isScalar >::model_

protectedinherited

The source of nodeId.

Definition at line 330 of file incrementalGraphLearner.h.

Referenced by gum::IMDDI< AttributeSelection, isScalar >::IMDDI(), and gum::IMDDI< AttributeSelection, isScalar >::IMDDI().

◆ needUpdate_

bool gum::IncrementalGraphLearner< AttributeSelection, isScalar >::needUpdate_

protectedinherited

Definition at line 377 of file incrementalGraphLearner.h.

Referenced by gum::IMDDI< AttributeSelection, isScalar >::updateFunctionGraph().

◆ nodeId2Database_

HashTable< NodeId, NodeDatabase< AttributeSelection, isScalar >* > gum::IncrementalGraphLearner< AttributeSelection, isScalar >::nodeId2Database_

protectedinherited

This hashtable binds every node to an associated NodeDatabase which handles every observation that concerns that node.

Definition at line 358 of file incrementalGraphLearner.h.

Referenced by gum::IMDDI< AttributeSelection, isScalar >::_addLeaf_(), gum::IMDDI< AttributeSelection, isScalar >::_downdateScore_(), gum::ITI< AttributeSelection, isScalar >::_insertTerminalNode_(), gum::ITI< AttributeSelection, isScalar >::_insertTerminalNode_(), gum::IMDDI< AttributeSelection, isScalar >::_updateNodeSet_(), gum::IMDDI< AttributeSelection, isScalar >::_updateScore_(), insertSetOfVars(), and gum::ITI< AttributeSelection, isScalar >::updateGraph().

◆ nodeSonsMap_

HashTable< NodeId, NodeId* > gum::IncrementalGraphLearner< AttributeSelection, isScalar >::nodeSonsMap_

protectedinherited

A table giving for any node a table mapping to its son idx is the modality of associated variable.

Definition at line 346 of file incrementalGraphLearner.h.

Referenced by ~IncrementalGraphLearner(), gum::ITI< AttributeSelection, isScalar >::_insertNodeInFunctionGraph_(), gum::IMDDI< AttributeSelection, isScalar >::_rebuildFunctionGraph_(), gum::IMDDI< AttributeSelection, isScalar >::_updateNodeSet_(), addObservation(), insertSetOfVars(), removeNode_(), size(), transpose_(), and gum::ITI< AttributeSelection, isScalar >::updateGraph().

◆ nodeVarMap_

HashTable< NodeId, const DiscreteVariable* > gum::IncrementalGraphLearner< AttributeSelection, isScalar >::nodeVarMap_

protectedinherited

Gives for any node its associated variable.

Definition at line 340 of file incrementalGraphLearner.h.

Referenced by ~IncrementalGraphLearner(), gum::ITI< AttributeSelection, isScalar >::_insertNodeInFunctionGraph_(), gum::IMDDI< AttributeSelection, isScalar >::_updateNodeSet_(), addObservation(), gum::IMDDI< AttributeSelection, isScalar >::chgNodeBoundVar_(), gum::ITI< AttributeSelection, isScalar >::chgNodeBoundVar_(), insertInternalNode_(), insertSetOfVars(), gum::IMDDI< AttributeSelection, isScalar >::removeNode_(), size(), transpose_(), gum::ITI< AttributeSelection, isScalar >::updateGraph(), and gum::IMDDI< AttributeSelection, isScalar >::updateNodeWithObservation_().

◆ root_

NodeId gum::IncrementalGraphLearner< AttributeSelection, isScalar >::root_

protectedinherited

The root of the ordered tree.

Definition at line 335 of file incrementalGraphLearner.h.

Referenced by gum::IMDDI< AttributeSelection, isScalar >::IMDDI(), gum::IMDDI< AttributeSelection, isScalar >::IMDDI(), gum::ITI< AttributeSelection, isScalar >::ITI(), gum::ITI< AttributeSelection, isScalar >::ITI(), gum::IMDDI< AttributeSelection, isScalar >::_rebuildFunctionGraph_(), gum::ITI< AttributeSelection, isScalar >::updateFunctionGraph(), gum::IMDDI< AttributeSelection, isScalar >::updateGraph(), and gum::ITI< AttributeSelection, isScalar >::updateGraph().

◆ setOfVars_

gum::VariableSet gum::IncrementalGraphLearner< AttributeSelection, isScalar >::setOfVars_

protectedinherited

Definition at line 372 of file incrementalGraphLearner.h.

Referenced by insertLeafNode_(), insertSetOfVars(), gum::ITI< AttributeSelection, isScalar >::insertSetOfVars_(), gum::IMDDI< AttributeSelection, isScalar >::updateGraph(), and gum::ITI< AttributeSelection, isScalar >::updateGraph().

◆ target_

MultiDimFunctionGraph< double >* gum::IncrementalGraphLearner< AttributeSelection, isScalar >::target_

protectedinherited

The final diagram we're building.

Definition at line 370 of file incrementalGraphLearner.h.

Referenced by gum::IMDDI< AttributeSelection, isScalar >::_insertLeafInFunctionGraph_(), gum::IMDDI< AttributeSelection, isScalar >::_insertLeafInFunctionGraph_(), gum::ITI< AttributeSelection, isScalar >::_insertNodeInFunctionGraph_(), gum::ITI< AttributeSelection, isScalar >::_insertTerminalNode_(), gum::ITI< AttributeSelection, isScalar >::_insertTerminalNode_(), gum::IMDDI< AttributeSelection, isScalar >::_rebuildFunctionGraph_(), and gum::ITI< AttributeSelection, isScalar >::updateFunctionGraph().

◆ value_

const DiscreteVariable* gum::IncrementalGraphLearner< AttributeSelection, isScalar >::value_

protectedinherited

Definition at line 374 of file incrementalGraphLearner.h.

◆ valueAssumed_

Sequence< ValueType > gum::IncrementalGraphLearner< AttributeSelection, isScalar >::valueAssumed_

protectedinherited

Definition at line 375 of file incrementalGraphLearner.h.

Referenced by gum::IMDDI< AttributeSelection, isScalar >::_addLeaf_(), and gum::IMDDI< AttributeSelection, isScalar >::_insertLeafInFunctionGraph_().

◆ var2Node_

HashTable< const DiscreteVariable*, LinkedList< NodeId >* > gum::IncrementalGraphLearner< AttributeSelection, isScalar >::var2Node_

protectedinherited

Associates to any variable the list of all nodes associated to this variable.

Definition at line 352 of file incrementalGraphLearner.h.

Referenced by ~IncrementalGraphLearner(), and gum::IMDDI< AttributeSelection, isScalar >::_rebuildFunctionGraph_().

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

agrum/FMDP/learning/datastructure/imddi.h
agrum/FMDP/learning/datastructure/imddi_tpl.h

Public Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Incrementals methods

Updating private methods

Graph Structure update methods

Detailed Description

Member Typedef Documentation

◆ ValueType

Constructor & Destructor Documentation

◆ IMDDI() [1/2]

◆ IMDDI() [2/2]

◆ ~IMDDI()

Member Function Documentation

◆ _addLeaf_()

◆ _assumeValue_()

◆ _branchObs_()

◆ _clearValue_()

◆ _downdateScore_()

◆ _insertLeafInFunctionGraph_() [1/2]

◆ _insertLeafInFunctionGraph_() [2/2]

◆ _rebuildFunctionGraph_()

◆ _removeLeaf_()

◆ _updateNodeSet_()

◆ _updateScore_()

◆ addObservation()

◆ chgNodeBoundVar_()

◆ convertNode2Leaf_()

◆ insertInternalNode_()

◆ insertLeafNode_()

◆ insertNode_()

◆ insertSetOfVars()

◆ isTerminal()

◆ nodeNbObservation()

◆ nodeSon()

◆ nodeVar()

◆ removeNode_()

◆ root()

◆ size()

◆ transpose_()

◆ updateFunctionGraph()

◆ updateGraph()

◆ updateNode_()

◆ updateNodeWithObservation_()

◆ updateVar()

Member Data Documentation

◆ _attributeSelectionThreshold_

◆ _leafMap_

◆ _lg_

◆ _nbTotalObservation_

◆ _varOrder_

◆ leafDatabase_

◆ model_

◆ needUpdate_

◆ nodeId2Database_

◆ nodeSonsMap_

◆ nodeVarMap_

◆ root_

◆ setOfVars_

◆ target_

◆ value_

◆ valueAssumed_

◆ var2Node_