selectionMetrics.h

 
 
#ifndef SELECTION_METRICS_H
#define SELECTION_METRICS_H
 
#include "learn/learningEnvironment.h"
#include "tpg/tpgGraph.h"
 
namespace Selector {
    class SelectionMetrics
    {
      protected:
        double score = 0;
 
        double utility = 0;
 
      public:
        SelectionMetrics() = default;
 
        virtual ~SelectionMetrics() = default;
 
        SelectionMetrics(double score, double utility = 0)
            : score{score}, utility{utility} {};
 
        virtual double getScore() const;
 
        virtual double getUtility() const;
 
        virtual void initMetrics(
            const TPG::TPGVertex* agent,
            const Learn::LearningEnvironment& learningEnvironment) {
            /* Empty because sub-class does not need to inherrit from it.*/
        };
 
        virtual void extractMetricsStep(
            const TPG::TPGVertex* agent, std::vector<double> actionValues,
            const Learn::LearningEnvironment& learningEnvironment) {
            /* Empty because sub-class does not need to inherrit from it.*/
        };
 
        virtual void extractMetricsEpisode(
            const TPG::TPGVertex* agent, size_t nbStepsExecuted,
            const Learn::LearningEnvironment& learningEnvironment);
 
        virtual void weightedSum(std::shared_ptr<SelectionMetrics> other,
                                 size_t nbEvaluation, size_t nbEvaluationOther);
 
        friend bool operator<(const SelectionMetrics& lhs,
                              const SelectionMetrics& rhs)
        {
            return lhs.getScore() < rhs.getScore();
        }
 
        template <class T>
        static T weightedSum(T value, T valueOther, size_t nbEvaluation,
                             size_t nbEvaluationOther)
        {
            value = value * (T)nbEvaluation + valueOther * (T)nbEvaluationOther;
            value /= (T)(nbEvaluation + nbEvaluationOther);
            return value;
        }
    };
 
    bool operator<(std::shared_ptr<SelectionMetrics> a,
                   std::shared_ptr<SelectionMetrics> b);
 
}; // namespace Selector
 
#endif // SELECTION_METRICS_H