learningEnvironment.h

 
#ifndef LEARNING_ENVIRONMENT_H
#define LEARNING_ENVIRONMENT_H
 
#include "data/dataHandler.h"
#include <cstdint>
#include <vector>
 
namespace Learn {
 
    enum class LearningMode
    {
        TRAINING,
        VALIDATION,
        TESTING
    };
 
    class LearningEnvironment
    {
      protected:
        const uint64_t nbActions;
 
        LearningEnvironment(const LearningEnvironment& other) = default;
 
        const bool isDiscreteEnvironment;
 
        const std::vector<uint64_t> initActions;
 
      public:
        LearningEnvironment() = delete;
 
        virtual ~LearningEnvironment() = default;
 
        LearningEnvironment(
            uint64_t nbAct, bool isDiscreteEnv = true,
            const std::vector<uint64_t>& initAct = std::vector<uint64_t>())
            : nbActions{nbAct}, isDiscreteEnvironment{isDiscreteEnv},
              initActions{initAct.empty() && !isDiscreteEnv
                              ? std::vector<uint64_t>(nbAct, 0)
                              : initAct} {};
 
        virtual LearningEnvironment* clone() const;
 
        virtual bool isCopyable() const;
 
        virtual bool isUsingUtility() const;
 
        uint64_t getNbActions() const
        {
            return this->nbActions;
        };
 
        const std::vector<uint64_t>& getInitActions() const
        {
            return initActions;
        };
 
        const bool isDiscrete() const
        {
            return isDiscreteEnvironment;
        }
 
        virtual void doAction(double actionID);
 
        virtual void doActions(std::vector<double> vectActionID);
 
        virtual void reset(size_t seed = 0,
                           LearningMode mode = LearningMode::TRAINING,
                           uint16_t iterationNumber = 0,
                           uint64_t generationNumber = 0) = 0;
 
        virtual std::vector<std::reference_wrapper<const Data::DataHandler>>
        getDataSources() = 0;
 
        virtual double getScore() const = 0;
 
        virtual double getUtility() const;
 
        virtual bool isTerminal() const = 0;
    };
}; // namespace Learn
 
#endif