gum::LeafAggregator Class Reference

<agrum/FMDP/learning/FunctionGraph/leafAggregator.h> More...

#include <leafAggregator.h>

Collaboration diagram for gum::LeafAggregator:

Public Member Functions
void	update ()
bool	needsUpdate ()
HashTable< NodeId, AbstractLeaf *>	leavesMap ()
std::string	toString ()
Constructor & destructor.
	LeafAggregator (NodeGraphPart *idSource, double similarityThreshold)
	Default constructor. More...
	~LeafAggregator ()
	Default destructor. More...
Leaf Handling methods
void	addLeaf (AbstractLeaf *)
bool	updateLeaf (AbstractLeaf *)
void	removeLeaf (AbstractLeaf *)
void	begin ()
bool	hasNext ()
double	next ()

Detailed Description

<agrum/FMDP/learning/FunctionGraph/leafAggregator.h>

Gather together leaves with similar distributions

Definition at line 57 of file leafAggregator.h.

Constructor & Destructor Documentation

LeafAggregator()

gum::LeafAggregator::LeafAggregator	(	NodeGraphPart *	idSource,
		double	similarityThreshold
	)

Default constructor.

Definition at line 40 of file leafAggregator.cpp.

References __initialContext, and __needsUpdate.

                                                                     :
      __leavesCpt(idSource),
      __similarityThreshold(similarityThreshold) {
    GUM_CONSTRUCTOR(LeafAggregator);
    __initialContext = new FusionContext< true >(nullptr);
    __needsUpdate = false;
  }

~LeafAggregator()

gum::LeafAggregator::~LeafAggregator

(

)

Default destructor.

Definition at line 52 of file leafAggregator.cpp.

References __initialContext, __leaf2Pair, __removeContext(), and gum::LeafPair::otherLeaf().

                                  {
    __removeContext(0);

    delete __initialContext;

    for (HashTableIteratorSafe< AbstractLeaf*, Set< LeafPair* >* > leafIter =
            __leaf2Pair.beginSafe();
         leafIter != __leaf2Pair.endSafe();
         ++leafIter) {
      for (SetIteratorSafe< LeafPair* > pairIter = leafIter.val()->beginSafe();
           pairIter != leafIter.val()->endSafe();
           ++pairIter) {
        LeafPair* curPair = *pairIter;
        __leaf2Pair[curPair->otherLeaf(leafIter.key())]->erase(*pairIter);
        leafIter.val()->erase(curPair);
        delete curPair;
      }
      delete leafIter.val();
    }


    GUM_DESTRUCTOR(LeafAggregator);
  }

Here is the call graph for this function:

Member Function Documentation

__addInitialPair()

void gum::LeafAggregator::__addInitialPair ( LeafPair *  p )

private

Definition at line 359 of file leafAggregator.cpp.

References __initialContext, __removeContext(), and gum::FusionContext< isInitial >::addPair().

Referenced by addLeaf(), and needsUpdate().

                                                   {
    bool res = __initialContext->addPair(p);
    if (res) __removeContext(0);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

__removeContext()

void gum::LeafAggregator::__removeContext ( Idx  startingPos )

private

Definition at line 344 of file leafAggregator.cpp.

References __fusionSeq, __leavesCpt, __needsUpdate, and gum::NodeGraphPart::eraseNode().

Referenced by __addInitialPair(), __removeInitialPair(), __updateInitialPair(), addLeaf(), needsUpdate(), removeLeaf(), updateLeaf(), and ~LeafAggregator().

                                                      {
    for (Idx i = __fusionSeq.size() - 1; !__fusionSeq.empty() && i >= startingPos;
         --i) {
      __leavesCpt->eraseNode(__fusionSeq.atPos(i)->leaf()->id());
      delete __fusionSeq.atPos(i);
      __fusionSeq.erase(__fusionSeq.atPos(i));
    }

    __needsUpdate = true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

__removeInitialPair()

void gum::LeafAggregator::__removeInitialPair ( LeafPair *  p )

private

Definition at line 376 of file leafAggregator.cpp.

References __initialContext, __removeContext(), and gum::FusionContext< isInitial >::removePair().

Referenced by needsUpdate(), and removeLeaf().

                                                      {
    bool res = __initialContext->removePair(p);
    if (res) __removeContext(0);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

__updateInitialPair()

void gum::LeafAggregator::__updateInitialPair ( LeafPair *  p )

private

Definition at line 368 of file leafAggregator.cpp.

References __initialContext, __removeContext(), and gum::FusionContext< isInitial >::updatePair().

Referenced by needsUpdate(), and updateLeaf().

                                                      {
    bool res = __initialContext->updatePair(p);
    if (res) __removeContext(0);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

addLeaf()

void gum::LeafAggregator::addLeaf

(

AbstractLeaf *

l

)

Definition at line 83 of file leafAggregator.cpp.

References __addInitialPair(), __fusionSeq, __leaf2Pair, __needsUpdate, __removeContext(), gum::Set< Key, Alloc >::beginSafe(), gum::Set< Key, Alloc >::endSafe(), gum::Set< Key, Alloc >::insert(), and gum::LeafPair::updateLikelyhood().

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

                                              {
    Set< LeafPair* >* leafPairSet = new Set< LeafPair* >();
    Set< LeafPair* >  bag;

    // ****************************************************************************************
    // Création et ajout des pairs de base (Feuille de base + nouvelle Feuille)
    for (HashTableConstIteratorSafe< AbstractLeaf*, Set< LeafPair* >* > leafIter =
            __leaf2Pair.cbeginSafe();
         leafIter != __leaf2Pair.cendSafe();
         ++leafIter) {
      // Création de la pair et ajout dans les listes de pair des feuilles de
      // base
      LeafPair* p = new LeafPair(l, leafIter.key());
      p->updateLikelyhood();
      leafPairSet->insert(p);
      (leafIter.val())->insert(p);

      // Ajout de la nouvelle pair au tas initial
      __addInitialPair(p);

      bag.insert(p);
    }

    // ****************************************************************************************
    // Enregistrement de la nouvelle Feuille en tant que feuille de base
    __leaf2Pair.insert(l, leafPairSet);

    // ****************************************************************************************
    // Ajout de la feuille aux FusionContext

    for (SequenceIteratorSafe< FusionContext< false >* > fusIter =
            __fusionSeq.beginSafe();
         fusIter != __fusionSeq.endSafe();
         ++fusIter) {
      // Ajout de la nouvelle pair composée de la feuille de FusIter et de la
      // nouvelle feuille aux FusionContext suivant
      for (SetIteratorSafe< LeafPair* > pairIter = bag.beginSafe();
           pairIter != bag.endSafe();
           ++pairIter) {
        if ((*fusIter)->leaf()->contains((*pairIter)->secondLeaf()->id())) {
          bag >> *pairIter;
          continue;
        }

        if ((*fusIter)->addPair(*pairIter)) __removeContext(fusIter.pos() + 1);
      }

      if ((*fusIter)->associateLeaf(l)) __removeContext(fusIter.pos() + 1);

      bag << (*fusIter)->leafAssociatedPair(l);
    }

    __needsUpdate = true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

begin()

void gum::LeafAggregator::begin

(

)

hasNext()

bool gum::LeafAggregator::hasNext

(

)

leavesMap()

HashTable< NodeId, AbstractLeaf *> gum::LeafAggregator::leavesMap

(

)

Definition at line 285 of file leafAggregator.cpp.

References __fusionSeq, __leaf2Pair, gum::HashTable< Key, Val, Alloc >::beginSafe(), gum::HashTable< Key, Val, Alloc >::endSafe(), gum::HashTable< Key, Val, Alloc >::exists(), and gum::HashTable< Key, Val, Alloc >::insert().

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

                                                               {
    HashTable< NodeId, AbstractLeaf* > retMap;
    for (SequenceIteratorSafe< FusionContext< false >* > fusIter =
            __fusionSeq.rbeginSafe();
         fusIter != __fusionSeq.rendSafe();
         --fusIter) {
      bool alreadyIn = false;
      for (HashTableIteratorSafe< NodeId, AbstractLeaf* > mapIter =
              retMap.beginSafe();
           mapIter != retMap.endSafe();
           ++mapIter)
        if (mapIter.val()->contains((*fusIter)->leaf()->id())) {
          alreadyIn = true;
          break;
        }
      if (!alreadyIn) retMap.insert((*fusIter)->leaf()->id(), (*fusIter)->leaf());
    }

    for (HashTableIteratorSafe< AbstractLeaf*, Set< LeafPair* >* > leafIter =
            __leaf2Pair.beginSafe();
         leafIter != __leaf2Pair.endSafe();
         ++leafIter) {
      for (HashTableIteratorSafe< NodeId, AbstractLeaf* > mapIter =
              retMap.beginSafe();
           mapIter != retMap.endSafe();
           ++mapIter)
        if (mapIter.val()->contains(leafIter.key()->id())) {
          retMap.insert(leafIter.key()->id(), mapIter.val());
          break;
        }
      if (!retMap.exists(leafIter.key()->id()))
        retMap.insert(leafIter.key()->id(), leafIter.key());
    }

    return retMap;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

needsUpdate()

bool gum::LeafAggregator::needsUpdate ( )

inline

Definition at line 122 of file leafAggregator.h.

References __addInitialPair(), __needsUpdate, __removeContext(), __removeInitialPair(), __updateInitialPair(), leavesMap(), and toString().

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

{ return __needsUpdate; }

Here is the call graph for this function:

Here is the caller graph for this function:

next()

double gum::LeafAggregator::next

(

)

removeLeaf()

void gum::LeafAggregator::removeLeaf

(

AbstractLeaf *

l

)

Definition at line 192 of file leafAggregator.cpp.

References __fusionSeq, __leaf2Pair, __needsUpdate, __removeContext(), __removeInitialPair(), gum::Set< Key, Alloc >::beginSafe(), and gum::Set< Key, Alloc >::endSafe().

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

                                                 {
    // ***********************************************************************************
    // First we update every base pair linked to that leaf
    Set< LeafPair* > bag(*(__leaf2Pair[l]));
    for (SetIteratorSafe< LeafPair* > pairIter = bag.beginSafe();
         pairIter != bag.endSafe();
         ++pairIter) {
      __removeInitialPair(*pairIter);
      (*__leaf2Pair[(*pairIter)->otherLeaf(l)]) >> *pairIter;
    }

    // **********************************************************************************
    // The we have top update FusionContext pairs associated to that leaf
    Set< LeafPair* > toBeDeleted;
    for (SequenceIteratorSafe< FusionContext< false >* > fusIter =
            __fusionSeq.beginSafe();
         fusIter != __fusionSeq.endSafe();
         ++fusIter) {
      for (SetIteratorSafe< LeafPair* > pairIter = bag.beginSafe();
           pairIter != bag.endSafe();
           ++pairIter) {
        if ((*fusIter)->leaf()->contains((*pairIter)->secondLeaf()->id())
            || (*fusIter)->leaf()->contains((*pairIter)->firstLeaf()->id())) {
          bag >> *pairIter;
          continue;
        }

        if ((*fusIter)->removePair(*pairIter)) {
          __removeContext(fusIter.pos() + 1);
        }
      }

      bag << (*fusIter)->leafAssociatedPair(l);
      toBeDeleted << (*fusIter)->leafAssociatedPair(l);

      if ((*fusIter)->deassociateLeaf(l)) { __removeContext(fusIter.pos() + 1); }
    }

    for (SetIteratorSafe< LeafPair* > pairIter = toBeDeleted.beginSafe();
         pairIter != toBeDeleted.endSafe();
         ++pairIter)
      delete *pairIter;

    for (SetIteratorSafe< LeafPair* > pairIter = __leaf2Pair[l]->beginSafe();
         pairIter != __leaf2Pair[l]->endSafe();
         ++pairIter)
      delete *pairIter;
    delete __leaf2Pair[l];
    __leaf2Pair.erase(l);

    __needsUpdate = true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

toString()

std::string gum::LeafAggregator::toString

(

)

Definition at line 323 of file leafAggregator.cpp.

References __fusionSeq, __initialContext, and gum::FusionContext< isInitial >::toString().

Referenced by needsUpdate().

                                     {
    std::stringstream ss;
    ss << "################\nTas Initial : " << std::endl
       << __initialContext->toString() << std::endl;

    for (auto fusIter = __fusionSeq.beginSafe(); fusIter != __fusionSeq.endSafe();
         ++fusIter) {
      ss << "################\nTas " << fusIter.pos() << " : " << std::endl
         << (*fusIter)->toString();
    }

    return ss.str();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

update()

void gum::LeafAggregator::update

(

)

Definition at line 249 of file leafAggregator.cpp.

References __fusionSeq, __initialContext, __leavesCpt, __needsUpdate, __similarityThreshold, gum::NodeGraphPart::addNode(), gum::FusionContext< isInitial >::addPair(), gum::FusionContext< isInitial >::associateLeaf(), gum::FusionContext< isInitial >::beginPairs(), gum::AbstractLeaf::contains(), gum::FusionContext< isInitial >::containsAssociatedLeaf(), gum::LeafPair::convert2Leaf(), gum::FusionContext< isInitial >::endPairs(), gum::LeafPair::likelyhood(), and gum::FusionContext< isInitial >::top().

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

                              {
    LeafPair*     nextPair = __initialContext->top();
    pair_iterator pb = __initialContext->beginPairs();
    pair_iterator pe = __initialContext->endPairs();
    if (!__fusionSeq.empty()) {
      nextPair = __fusionSeq.back()->top();
      pb = __fusionSeq.back()->beginPairs();
      pe = __fusionSeq.back()->endPairs();
    }


    while (nextPair && nextPair->likelyhood() < __similarityThreshold) {
      AbstractLeaf* newLeaf = nextPair->convert2Leaf(__leavesCpt->addNode());
      FusionContext< false >* newContext = new FusionContext< false >(newLeaf);

      for (pair_iterator pairIter = pb; pairIter != pe; ++pairIter) {
        if (!newLeaf->contains(pairIter.key()->firstLeaf()->id())
            && !newLeaf->contains(pairIter.key()->secondLeaf()->id()))
          newContext->addPair(pairIter.key());
        if (!newLeaf->contains(pairIter.key()->firstLeaf()->id())
            && !newContext->containsAssociatedLeaf(pairIter.key()->firstLeaf()))
          newContext->associateLeaf(pairIter.key()->firstLeaf());
        if (!newLeaf->contains(pairIter.key()->secondLeaf()->id())
            && !newContext->containsAssociatedLeaf(pairIter.key()->secondLeaf()))
          newContext->associateLeaf(pairIter.key()->secondLeaf());
      }

      __fusionSeq.insert(newContext);
      nextPair = __fusionSeq.back()->top();
      pb = __fusionSeq.back()->beginPairs();
      pe = __fusionSeq.back()->endPairs();
    }
    __needsUpdate = false;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

updateLeaf()

bool gum::LeafAggregator::updateLeaf

(

AbstractLeaf *

l

)

Definition at line 142 of file leafAggregator.cpp.

References __fusionSeq, __leaf2Pair, __needsUpdate, __removeContext(), __updateInitialPair(), gum::Set< Key, Alloc >::beginSafe(), gum::Set< Key, Alloc >::clear(), gum::Set< Key, Alloc >::endSafe(), and gum::AbstractLeaf::id().

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

                                                 {
    // ***********************************************************************************
    // First we update every base pair linked to that leaf
    Set< LeafPair* > bag(*(__leaf2Pair[l]));
    for (SetIteratorSafe< LeafPair* > pairIter = bag.beginSafe();
         pairIter != bag.endSafe();
         ++pairIter) {
      (*pairIter)->updateLikelyhood();
      __updateInitialPair(*pairIter);
    }

    // **********************************************************************************
    // The we have top update FusionContext pairs associated to that leaf
    AbstractLeaf* curLeaf = l;
    for (SequenceIteratorSafe< FusionContext< false >* > fusIter =
            __fusionSeq.beginSafe();
         fusIter != __fusionSeq.endSafe();
         ++fusIter) {
      if ((*fusIter)->leaf()->contains(curLeaf->id())) {
        bag.clear();
        if ((*fusIter)->updateAllAssociatedLeaves())
          __removeContext(fusIter.pos() + 1);
        bag = (*fusIter)->associatedPairs();
        curLeaf = (*fusIter)->leaf();
        continue;
      }

      for (SetIteratorSafe< LeafPair* > pairIter = bag.beginSafe();
           pairIter != bag.endSafe();
           ++pairIter) {
        if ((*fusIter)->leaf()->contains((*pairIter)->secondLeaf()->id())
            || (*fusIter)->leaf()->contains((*pairIter)->firstLeaf()->id())) {
          bag >> *pairIter;
          continue;
        }

        if ((*fusIter)->updatePair(*pairIter)) __removeContext(fusIter.pos() + 1);
      }
      if ((*fusIter)->updateAssociatedLeaf(curLeaf))
        __removeContext(fusIter.pos() + 1);
      bag << (*fusIter)->leafAssociatedPair(curLeaf);
    }

    return __needsUpdate;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

__fusionSeq

Sequence< FusionContext< false >* > gum::LeafAggregator::__fusionSeq

private

Definition at line 134 of file leafAggregator.h.

Referenced by __removeContext(), addLeaf(), leavesMap(), removeLeaf(), toString(), update(), and updateLeaf().

__initialContext

FusionContext< true >* gum::LeafAggregator::__initialContext

private

Definition at line 136 of file leafAggregator.h.

Referenced by __addInitialPair(), __removeInitialPair(), __updateInitialPair(), LeafAggregator(), toString(), update(), and ~LeafAggregator().

__leaf2Pair

HashTable< AbstractLeaf*, Set< LeafPair* >* > gum::LeafAggregator::__leaf2Pair

private

Definition at line 138 of file leafAggregator.h.

Referenced by addLeaf(), leavesMap(), removeLeaf(), updateLeaf(), and ~LeafAggregator().

__leavesCpt

NodeGraphPart* gum::LeafAggregator::__leavesCpt

private

Definition at line 140 of file leafAggregator.h.

Referenced by __removeContext(), and update().

__needsUpdate

bool gum::LeafAggregator::__needsUpdate

private

Definition at line 143 of file leafAggregator.h.

Referenced by __removeContext(), addLeaf(), LeafAggregator(), needsUpdate(), removeLeaf(), update(), and updateLeaf().

__similarityThreshold

double gum::LeafAggregator::__similarityThreshold

private

Definition at line 142 of file leafAggregator.h.

Referenced by update().

---

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

• agrum/FMDP/learning/datastructure/leaves/leafAggregator.h
• agrum/FMDP/learning/datastructure/leaves/leafAggregator.cpp