UCVE.hpp

Go to the documentation of this file.

#ifndef AI_TOOLBOX_FACTORED_BANDIT_UCVE_HEADER_FILE
#define AI_TOOLBOX_FACTORED_BANDIT_UCVE_HEADER_FILE
 
#include "AIToolbox/Factored/Bandit/Types.hpp"
#include <AIToolbox/Factored/Utils/GenericVariableElimination.hpp>
 
namespace AIToolbox::Factored::Bandit {
    class UCVE {
        public:
            // Estimated mean and inverse weighted counts
            using V = Eigen::Vector2d;
            // Tag - Vector pair
            struct Entry {
                V v;
                PartialAction tag;
                EIGEN_MAKE_ALIGNED_OPERATOR_NEW
            };
            using Factor = std::vector<Entry>;
 
            using Result = std::tuple<Action, V>;
            using GVE = GenericVariableElimination<Factor>;
 
            template <typename Iterable>
            Result operator()(const Action & A, const double logtA, const Iterable & inputRules) {
                GVE::Graph graph(A.size());
 
                for (const Entry & rule : inputRules) {
                    const auto & [v, a] = rule;
                    auto & factorNode = graph.getFactor(a.first)->getData();
                    const auto id = toIndexPartial(A, a);
 
                    const auto it = std::lower_bound(
                        std::begin(factorNode),
                        std::end(factorNode),
                        id,
                        [](const auto & rule, size_t rhs) {return rule.first < rhs;}
                    );
 
                    if (it != std::end(factorNode) && it->first == id)
                        it->second[0].v += v;
                    else
                        factorNode.emplace(it, id, Factor{{v, PartialAction()}});
                }
                // Start solving process.
                return (*this)(A, logtA, graph);
            }
 
            Result operator()(const Action & A, const double logtA, GVE::Graph & graph);
    };
}
 
#endif