fmdpLearner.h

Go to the documentation of this file.

// =========================================================================
#ifndef GUM_FMDP_LEARNER_H
#define GUM_FMDP_LEARNER_H
// =========================================================================
#include <agrum/core/hashTable.h>
// =========================================================================
#include <agrum/FMDP/SDyna/Strategies/ILearningStrategy.h>
#include <agrum/FMDP/fmdp.h>
#include <agrum/FMDP/learning/datastructure/imddi.h>
#include <agrum/FMDP/learning/datastructure/iti.h>
#include <agrum/FMDP/learning/observation.h>
// =========================================================================
#include <agrum/variables/discreteVariable.h>
// =========================================================================

namespace gum {

  template < TESTNAME    VariableAttributeSelection,
             TESTNAME    RewardAttributeSelection,
             LEARNERNAME LearnerSelection >
  class FMDPLearner : public ILearningStrategy {
    typedef
       typename LearnerSelect< LearnerSelection,
                               IMDDI< VariableAttributeSelection, false >,
                               ITI< VariableAttributeSelection, false > >::type
          VariableLearnerType;

    typedef typename LearnerSelect< LearnerSelection,
                                    IMDDI< RewardAttributeSelection, true >,
                                    ITI< RewardAttributeSelection, true > >::type
       RewardLearnerType;

    typedef HashTable< const DiscreteVariable*, VariableLearnerType* >
       VarLearnerTable;

    public:
    // ==========================================================================
    // ==========================================================================

    // ###################################################################
    // ###################################################################
    FMDPLearner(double learningThreshold,
                bool   actionReward,
                double similarityThreshold = 0.05);

    // ###################################################################
    // ###################################################################
    ~FMDPLearner();


    // ###################################################################
    // ###################################################################
    public:
    // ==========================================================================
    // ==========================================================================
    void initialize(FMDP< double >* fmdp);

    // ==========================================================================
    // ==========================================================================
    MultiDimFunctionGraph< double >* __instantiateFunctionGraph() {
      return __instantiateFunctionGraph(Int2Type< LearnerSelection >());
    }

    MultiDimFunctionGraph< double >*
       __instantiateFunctionGraph(Int2Type< IMDDILEARNER >) {
      return MultiDimFunctionGraph< double, ExactTerminalNodePolicy >::
         getReducedAndOrderedInstance();
    }

    MultiDimFunctionGraph< double >*
       __instantiateFunctionGraph(Int2Type< ITILEARNER >) {
      return MultiDimFunctionGraph< double,
                                    ExactTerminalNodePolicy >::getTreeInstance();
    }


    // ==========================================================================
    // ==========================================================================
    VariableLearnerType*
       __instantiateVarLearner(MultiDimFunctionGraph< double >* target,
                               Set< const DiscreteVariable* >&  mainVariables,
                               const DiscreteVariable*          learnedVar) {
      return __instantiateVarLearner(
         target, mainVariables, learnedVar, Int2Type< LearnerSelection >());
    }

    VariableLearnerType*
       __instantiateVarLearner(MultiDimFunctionGraph< double >* target,
                               Set< const DiscreteVariable* >&  mainVariables,
                               const DiscreteVariable*          learnedVar,
                               Int2Type< IMDDILEARNER >) {
      return new VariableLearnerType(target,
                                     __learningThreshold,
                                     __similarityThreshold,
                                     mainVariables,
                                     learnedVar);
    }

    VariableLearnerType*
       __instantiateVarLearner(MultiDimFunctionGraph< double >* target,
                               Set< const DiscreteVariable* >&  mainVariables,
                               const DiscreteVariable*          learnedVar,
                               Int2Type< ITILEARNER >) {
      return new VariableLearnerType(
         target, __learningThreshold, mainVariables, learnedVar);
    }


    // ==========================================================================
    // ==========================================================================
    RewardLearnerType*
       __instantiateRewardLearner(MultiDimFunctionGraph< double >* target,
                                  Set< const DiscreteVariable* >&  mainVariables) {
      return __instantiateRewardLearner(
         target, mainVariables, Int2Type< LearnerSelection >());
    }

    RewardLearnerType*
       __instantiateRewardLearner(MultiDimFunctionGraph< double >* target,
                                  Set< const DiscreteVariable* >&  mainVariables,
                                  Int2Type< IMDDILEARNER >) {
      return new RewardLearnerType(
         target, __learningThreshold, __similarityThreshold, mainVariables);
    }

    RewardLearnerType*
       __instantiateRewardLearner(MultiDimFunctionGraph< double >* target,
                                  Set< const DiscreteVariable* >&  mainVariables,
                                  Int2Type< ITILEARNER >) {
      return new RewardLearnerType(target, __learningThreshold, mainVariables);
    }



    // ###################################################################
    // ###################################################################
    public:
    // ==========================================================================
    // ==========================================================================
    bool addObservation(Idx actionId, const Observation* obs);


    // ==========================================================================
    // ==========================================================================
    void updateFMDP();



    // ###################################################################
    // ###################################################################
    public:
    // ==========================================================================
    // ==========================================================================
    Size size();

    // ==========================================================================
    // ==========================================================================
    const IVisitableGraphLearner* varLearner(Idx                     actionId,
                                             const DiscreteVariable* var) const {
      return __actionLearners[actionId]->getWithDefault(var, nullptr);
    }

    virtual double rMax() const { return __rmax; }

    private:
    double __rmax;

    public:
    virtual double modaMax() const { return __modaMax; }

    private:
    double __modaMax;



    private:
    FMDP< double >* __fmdp;

    HashTable< Idx, VarLearnerTable* > __actionLearners;

    bool                                 __actionReward;
    HashTable< Idx, RewardLearnerType* > __actionRewardLearners;
    RewardLearnerType*                   __rewardLearner;

    const double __learningThreshold;
    const double __similarityThreshold;
  };


} /* namespace gum */

#include <agrum/FMDP/learning/fmdpLearner_tpl.h>

#endif   // GUM_FMDP_LEARNER_H