incrementalGraphLearner.h

Go to the documentation of this file.

// =========================================================================
#ifndef GUM_INCREMENTAL_GRAPH_LEARNER_H
#define GUM_INCREMENTAL_GRAPH_LEARNER_H
// =========================================================================
// =========================================================================
#include <agrum/multidim/implementations/multiDimFunctionGraph.h>
// =========================================================================
#include <agrum/FMDP/learning/core/templateStrategy.h>
#include <agrum/FMDP/learning/datastructure/IVisitableGraphLearner.h>
#include <agrum/FMDP/learning/datastructure/nodeDatabase.h>
// =========================================================================
#include <agrum/multidim/utils/FunctionGraphUtilities/link.h>
// =========================================================================

namespace gum {

  template < TESTNAME AttributeSelection, bool isScalar = false >
  class IncrementalGraphLearner : public IVisitableGraphLearner {
    typedef typename ValueSelect< isScalar, double, Idx >::type ValueType;

    public:
    // ###################################################################
    // ###################################################################

    // ==========================================================================
    // ==========================================================================
    IncrementalGraphLearner(MultiDimFunctionGraph< double >* target,
                            Set< const DiscreteVariable* >   attributesSet,
                            const DiscreteVariable*          learnVariable);

    // ==========================================================================
    // ==========================================================================
    virtual ~IncrementalGraphLearner();

    private:
    // ==========================================================================
    // ==========================================================================
    void __clearValue() { __clearValue(Int2Type< isScalar >()); }

    // ==========================================================================
    // ==========================================================================
    void __clearValue(Int2Type< true >) { delete _value; }

    // ==========================================================================
    // ==========================================================================
    void __clearValue(Int2Type< false >) {}



    // ###################################################################
    // ###################################################################
    public:
    // ==========================================================================
    // ==========================================================================
    virtual void addObservation(const Observation* obs);

    private:
    // ==========================================================================
    // ==========================================================================
    void __assumeValue(const Observation* obs) {
      __assumeValue(obs, Int2Type< isScalar >());
    }
    void __assumeValue(const Observation* obs, Int2Type< true >) {
      if (!_valueAssumed.exists(obs->reward())) _valueAssumed << obs->reward();
    }
    void __assumeValue(const Observation* obs, Int2Type< false >) {
      if (!_valueAssumed.exists(obs->modality(_value)))
        _valueAssumed << obs->modality(_value);
    }


    // ==========================================================================
    // ==========================================================================
    Idx __branchObs(const Observation* obs, const DiscreteVariable* var) {
      return __branchObs(obs, var, Int2Type< isScalar >());
    }
    Idx __branchObs(const Observation*      obs,
                    const DiscreteVariable* var,
                    Int2Type< true >) {
      return obs->rModality(var);
    }
    Idx __branchObs(const Observation*      obs,
                    const DiscreteVariable* var,
                    Int2Type< false >) {
      return obs->modality(var);
    }

    protected:
    // ==========================================================================
    // ==========================================================================
    virtual void _updateNodeWithObservation(const Observation* newObs,
                                            NodeId             currentNodeId) {
      _nodeId2Database[currentNodeId]->addObservation(newObs);
    }


    // ###################################################################
    // ###################################################################

    public:
    // ==========================================================================
    // ==========================================================================
    virtual void updateVar(const DiscreteVariable*);

    // ==========================================================================
    // ==========================================================================
    virtual void updateGraph() = 0;

    protected:
    // ==========================================================================
    // ==========================================================================
    void _updateNode(NodeId nody, Set< const DiscreteVariable* >& bestVars);

    // ==========================================================================
    // ==========================================================================
    virtual void _convertNode2Leaf(NodeId);

    // ==========================================================================
    // ==========================================================================
    virtual void _transpose(NodeId, const DiscreteVariable*);

    // ==========================================================================
    // ==========================================================================
    virtual NodeId _insertNode(NodeDatabase< AttributeSelection, isScalar >* nDB,
                               const DiscreteVariable* boundVar);

    // ==========================================================================
    // ==========================================================================
    virtual NodeId
       _insertInternalNode(NodeDatabase< AttributeSelection, isScalar >* nDB,
                           const DiscreteVariable*                       boundVar,
                           NodeId*                                       sonsMap);

    // ==========================================================================
    // ==========================================================================
    virtual NodeId
       _insertLeafNode(NodeDatabase< AttributeSelection, isScalar >* nDB,
                       const DiscreteVariable*                       boundVar,
                       Set< const Observation* >*                    obsSet);

    // ==========================================================================
    // ==========================================================================
    virtual void _chgNodeBoundVar(NodeId                  chgedNodeId,
                                  const DiscreteVariable* desiredVar);

    // ==========================================================================
    // ==========================================================================
    virtual void _removeNode(NodeId removedNodeId);



    // ###################################################################
    // ###################################################################
    public:
    // ==========================================================================
    // ==========================================================================
    virtual void updateFunctionGraph() = 0;



    public:
    // ==========================================================================
    // ==========================================================================
    Size size() { return _nodeVarMap.size(); }


    // ###################################################################
    // ###################################################################
    public:
    // ==========================================================================
    // ==========================================================================
    NodeId root() const { return this->_root; }

    // ==========================================================================
    // ==========================================================================
    bool isTerminal(NodeId ni) const { return !this->_nodeSonsMap.exists(ni); }

    // ==========================================================================
    // ==========================================================================
    const DiscreteVariable* nodeVar(NodeId ni) const {
      return this->_nodeVarMap[ni];
    }

    // ==========================================================================
    // ==========================================================================
    NodeId nodeSon(NodeId ni, Idx modality) const {
      return this->_nodeSonsMap[ni][modality];
    }

    // ==========================================================================
    // ==========================================================================
    Idx nodeNbObservation(NodeId ni) const {
      return this->_nodeId2Database[ni]->nbObservation();
    }

    // ==========================================================================
    // ==========================================================================
    virtual void insertSetOfVars(MultiDimFunctionGraph< double >* ret) const {
      for (SetIteratorSafe< const DiscreteVariable* > varIter =
              _setOfVars.beginSafe();
           varIter != _setOfVars.endSafe();
           ++varIter)
        ret->add(**varIter);
    }

    protected:

    // ###################################################################
    // ###################################################################

    // ==========================================================================
    // ==========================================================================
    NodeGraphPart _model;

    // ==========================================================================
    // ==========================================================================
    NodeId _root;

    // ==========================================================================
    // ==========================================================================
    HashTable< NodeId, const DiscreteVariable* > _nodeVarMap;

    // ==========================================================================
    // ==========================================================================
    HashTable< NodeId, NodeId* > _nodeSonsMap;

    // ==========================================================================
    // ==========================================================================
    HashTable< const DiscreteVariable*, LinkedList< NodeId >* > _var2Node;

    // ==========================================================================
    // ==========================================================================
    HashTable< NodeId, NodeDatabase< AttributeSelection, isScalar >* >
       _nodeId2Database;

    // ==========================================================================
    // ==========================================================================
    HashTable< NodeId, Set< const Observation* >* > _leafDatabase;



    MultiDimFunctionGraph< double >* _target;

    Set< const DiscreteVariable* > _setOfVars;

    const DiscreteVariable* _value;
    Sequence< ValueType >   _valueAssumed;

    bool _needUpdate;
  };


} /* namespace gum */

#include <agrum/FMDP/learning/datastructure/incrementalGraphLearner_tpl.h>

#endif   // GUM_INCREMENTAL_GRAPH_LEARNER_H