learningAgent.h

 
#ifndef LEARNING_AGENT_H
#define LEARNING_AGENT_H
 
#include <map>
#include <queue>
 
#include "archive.h"
#include "environment.h"
#include "instructions/set.h"
#include "log/laLogger.h"
#include "mutator/mutationParameters.h"
#include "tpg/tpgExecutionEngine.h"
#include "tpg/tpgGraph.h"
 
#include "learn/classificationLearningEnvironment.h"
#include "learn/evaluationResult.h"
#include "learn/job.h"
#include "learn/learningEnvironment.h"
#include "learn/learningParameters.h"
 
#include "selector/selectorFactory.h"
namespace Learn {
 
    class LearningAgent
    {
      protected:
        LearningEnvironment& learningEnvironment;
 
        Environment env;
 
        Archive archive;
 
        LearningParameters params;
 
        std::shared_ptr<TPG::TPGGraph> tpg;
 
        std::shared_ptr<Selector::Selector> selector;
 
        Mutator::RNG rng;
 
        uint64_t maxNbThreads = 1;
 
        std::vector<std::reference_wrapper<Log::LALogger>> loggers;
 
      public:
        LearningAgent(LearningEnvironment& le, const Instructions::Set& iSet,
                      const LearningParameters& p,
                      const TPG::TPGFactory& factory = TPG::TPGFactory())
            : learningEnvironment{le},
              env(iSet, p, le.getDataSources(),
                  (le.isDiscrete()) ? 0 : le.getNbActions()),
              archive(p.archiveSize, p.archivingProbability), params{p},
              tpg(factory.createTPGGraph(env)),
              selector{Selector::selectorFactory(tpg, le, p)} {};
 
        virtual ~LearningAgent() = default;
 
        std::shared_ptr<TPG::TPGGraph> getTPGGraph();
 
        std::shared_ptr<Selector::Selector> getSelector();
 
        const Archive& getArchive() const;
 
        const Environment& getEnvironment() const;
 
        Mutator::RNG& getRNG();
 
        void addLogger(Log::LALogger& logger);
 
        virtual std::shared_ptr<EvaluationResult> evaluateJob(
            TPG::TPGExecutionEngine& tee, const Job& job,
            uint64_t generationNumber, LearningMode mode,
            LearningEnvironment& le) const;
 
        bool isRootEvalSkipped(
            const TPG::TPGVertex& root,
            std::shared_ptr<Learn::EvaluationResult>& previousResult) const;
 
        virtual std::multimap<std::shared_ptr<EvaluationResult>,
                              const TPG::TPGVertex*>
        evaluateAllRoots(uint64_t generationNumber, LearningMode mode);
 
        virtual std::shared_ptr<EvaluationResult> evaluateOneRoot(
            uint64_t generationNumber, LearningMode mode,
            const TPG::TPGVertex* root);
 
        virtual void trainOneGeneration(uint64_t generationNumber,
                                        bool doPopulate = true);
 
        virtual uint64_t train(volatile bool& altTraining,
                               bool printProgressBar);
 
        virtual std::shared_ptr<Learn::Job> makeJob(
            const TPG::TPGVertex* vertex, Learn::LearningMode mode, int idx = 0,
            TPG::TPGGraph* tpgGraph = nullptr);
 
        virtual std::queue<std::shared_ptr<Learn::Job>> makeJobs(
            Learn::LearningMode mode, TPG::TPGGraph* tpgGraph = nullptr);
 
        virtual void init(uint64_t seed = 0);
    };
}; // namespace Learn
 
#endif