QGreedyPolicy.hpp

Go to the documentation of this file.

#ifndef AI_TOOLBOX_FACTORED_MDP_Q_GREEDY_POLICY_HEADER_FILE
#define AI_TOOLBOX_FACTORED_MDP_Q_GREEDY_POLICY_HEADER_FILE
 
#include <AIToolbox/PolicyInterface.hpp>
#include <AIToolbox/Factored/MDP/Types.hpp>
#include <AIToolbox/Factored/Utils/FilterMap.hpp>
 
#include <AIToolbox/Factored/Bandit/Algorithms/Utils/VariableElimination.hpp>
#include <AIToolbox/Factored/MDP/Algorithms/Utils/GraphUtils.hpp>
 
namespace AIToolbox::Factored::MDP {
    template <typename Maximizer = Bandit::VariableElimination>
    class QGreedyPolicy : public PolicyInterface<State, State, Action> {
        public:
            using Base = PolicyInterface<State, State, Action>;
 
            template <typename... Args>
            QGreedyPolicy(State s, Action a, const FilterMap<QFunctionRule> & q, Args && ...args);
 
            template <typename... Args>
            QGreedyPolicy(State s, Action a, const QFunction & q, Args && ...args);
 
            virtual Action sampleAction(const State & s) const override;
 
            virtual double getActionProbability(const State & s, const Action & a) const override;
 
            Maximizer & getMaximizer();
 
            const Maximizer & getMaximizer() const;
 
            const typename Maximizer::Graph & getGraph() const;
 
        private:
            const FilterMap<QFunctionRule> * qc_;
            const QFunction * qm_;
 
            mutable Maximizer max_;
            mutable typename Maximizer::Graph graph_;
    };
 
    template <typename Maximizer>
    template <typename... Args>
    QGreedyPolicy<Maximizer>::QGreedyPolicy(State s, Action a, const FilterMap<QFunctionRule> & q, Args && ...args) :
            Base(std::move(s), std::move(a)), qc_(&q), qm_(nullptr),
            max_(std::forward<Args>(args)...),
            graph_(MakeGraph<Maximizer>()(q, A))
    {}
 
    template <typename Maximizer>
    template <typename... Args>
    QGreedyPolicy<Maximizer>::QGreedyPolicy(State s, Action a, const QFunction & q, Args && ...args) :
            Base(std::move(s), std::move(a)), qc_(nullptr), qm_(&q),
            max_(std::forward<Args>(args)...),
            graph_(MakeGraph<Maximizer>()(q, A))
    {}
 
    template <typename Maximizer>
    Action QGreedyPolicy<Maximizer>::sampleAction(const State & s) const {
        if (qc_) {
            UpdateGraph<Maximizer>()(graph_, qc_->filter(s), S, A, s);
        } else {
            UpdateGraph<Maximizer>()(graph_, *qm_, S, A, s);
        }
        return std::get<0>(max_(A, graph_));
    }
 
    template <typename Maximizer>
    double QGreedyPolicy<Maximizer>::getActionProbability(const State & s, const Action & a) const {
        if (veccmp(a, sampleAction(s)) == 0) return 1.0;
        return 0.0;
    }
 
    template <typename Maximizer>
    Maximizer & QGreedyPolicy<Maximizer>::getMaximizer() {
        return max_;
    }
 
    template <typename Maximizer>
    const Maximizer & QGreedyPolicy<Maximizer>::getMaximizer() const {
        return max_;
    }
 
    template <typename Maximizer>
    const typename Maximizer::Graph & QGreedyPolicy<Maximizer>::getGraph() const {
        return graph_;
    }
}
 
#endif