EpsilonPolicyInterface.hpp

Go to the documentation of this file.

#ifndef AI_TOOLBOX_EPSILON_POLICY_INTERFACE_HEADER_FILE
#define AI_TOOLBOX_EPSILON_POLICY_INTERFACE_HEADER_FILE
 
#include <AIToolbox/PolicyInterface.hpp>
#include <AIToolbox/Utils/Probability.hpp>
 
#include <stdexcept>
 
namespace AIToolbox {
    template <typename State, typename Sampling, typename Action>
    class EpsilonPolicyInterface : public virtual PolicyInterface<State, Sampling, Action> {
        public:
            using Base = PolicyInterface<State, Sampling, Action>;
            EpsilonPolicyInterface(const Base & p, double epsilon = 0.1);
 
            virtual Action sampleAction(const Sampling & s) const override;
 
            virtual double getActionProbability(const Sampling & s, const Action & a) const override;
 
            void setEpsilon(double e);
 
            double getEpsilon() const;
 
        protected:
            virtual Action sampleRandomAction() const = 0;
 
            virtual double getRandomActionProbability() const = 0;
 
            const Base & policy_;
            double epsilon_;
    };
 
    template <typename State, typename Sampling, typename Action>
    EpsilonPolicyInterface<State, Sampling, Action>::EpsilonPolicyInterface(const Base & p, const double e) :
            policy_(p)
    {
        setEpsilon(e);
    }
 
    template <typename State, typename Sampling, typename Action>
    Action EpsilonPolicyInterface<State, Sampling, Action>::sampleAction(const Sampling & s) const {
        if ( probabilityDistribution(this->rand_) <= epsilon_ )
            return sampleRandomAction();
 
        return policy_.sampleAction(s);
    }
 
    template <typename State, typename Sampling, typename Action>
    double EpsilonPolicyInterface<State, Sampling, Action>::getActionProbability(const Sampling & s, const Action & a) const {
        // Probability of taking old decision               Random action probability
        return (1.0 - epsilon_) * policy_.getActionProbability(s,a) + epsilon_ * getRandomActionProbability();
    }
 
    template <typename State, typename Sampling, typename Action>
    void EpsilonPolicyInterface<State, Sampling, Action>::setEpsilon(const double e) {
        if ( e < 0.0 || e > 1.0 ) throw std::invalid_argument("Epsilon must be >= 0 and <= 1");
        epsilon_ = e;
    }
 
    template <typename State, typename Sampling, typename Action>
    double EpsilonPolicyInterface<State, Sampling, Action>::getEpsilon() const {
        return epsilon_;
    }
 
    template <typename Action>
    class EpsilonPolicyInterface<void, void, Action> : public virtual PolicyInterface<void, void, Action> {
        public:
            using Base = PolicyInterface<void, void, Action>;
            EpsilonPolicyInterface(const Base & p, double epsilon = 0.1);
 
            virtual Action sampleAction() const override;
 
            virtual double getActionProbability(const Action & a) const override;
 
            void setEpsilon(double e);
 
            double getEpsilon() const;
 
        protected:
            virtual Action sampleRandomAction() const = 0;
 
            virtual double getRandomActionProbability() const = 0;
 
            const Base & policy_;
            double epsilon_;
    };
 
    template <typename Action>
    EpsilonPolicyInterface<void, void, Action>::EpsilonPolicyInterface(const Base & p, const double e) :
            policy_(p)
    {
        setEpsilon(e);
    }
 
    template <typename Action>
    Action EpsilonPolicyInterface<void, void, Action>::sampleAction() const {
        if ( probabilityDistribution(this->rand_) <= epsilon_ )
            return sampleRandomAction();
 
        return policy_.sampleAction();
    }
 
    template <typename Action>
    double EpsilonPolicyInterface<void, void, Action>::getActionProbability(const Action & a) const {
        // Probability of taking old decision               Random action probability
        return (1.0 - epsilon_) * policy_.getActionProbability(a) + epsilon_ * getRandomActionProbability();
    }
 
    template <typename Action>
    void EpsilonPolicyInterface<void, void, Action>::setEpsilon(const double e) {
        if ( e < 0.0 || e > 1.0 ) throw std::invalid_argument("Epsilon must be >= 0 and <= 1");
        epsilon_ = e;
    }
 
    template <typename Action>
    double EpsilonPolicyInterface<void, void, Action>::getEpsilon() const {
        return epsilon_;
    }
}
 
#endif