Selector.hh

// Copyright QED Software 2023.
 
#ifndef GRAIL_SELECTOR_H
#define GRAIL_SELECTOR_H
 
#include "Blueprint.hh"
#include "../GrailData/DebugInfo/UtilityReasonerSnapshot.h"
#include "../GrailData/UtilityModel/UtilitySelectorModel.h"
#include "../GrailEvaluators/Evaluator.hh"
 
#include <functional>
#include <limits>
#include <random>
#include <vector>
 
namespace grail
{
namespace utility
{
    static const std::string MAX = "Max";
    static const std::string ROULETTE = "Roulette";
 
    template <typename ContextType>
    struct Option
    {
        ContextType context{};
        std::shared_ptr<evaluator::Evaluator<ContextType>> evaluator{};
        std::string evaluatedObjectName{};
        std::string evaluatedObjectMetadata{};
        int rank{};
    };
 
    struct SelectionResult
    {
        SelectionResult(bool isDebugging = false)
        {
            if(isDebugging)
            {
                snapshot = std::make_unique<data::UtilityReasonerSnapshot>();
            }
        }
 
        data::UtilityEvaluatorSnapshot* FetchNextEvaluatorSnapshot(const std::string& evaluatedObjectName,
                                                             const std::string& evaluatedObjectMetadata,
                                                             int rank)
        {
            if(snapshot != nullptr)
            {
                snapshot->evaluatorSnapshots.emplace_back(evaluatedObjectName, evaluatedObjectMetadata, rank);
                return &snapshot->evaluatorSnapshots.back();
            }
            return nullptr;
        }
 
        bool IsValid() const
        {
            return optionIndex != std::numeric_limits<std::size_t>::max();
        }
 
        std::unique_ptr<data::UtilityReasonerSnapshot> snapshot{nullptr};
        std::size_t optionIndex = std::numeric_limits<std::size_t>::max();
    };
 
    namespace selector
    {
        template <typename ContextType>
        void SelectMaxUtility(const std::vector<Option<ContextType>>& options,
                              SelectionResult& result,
                              std::function<bool(const std::size_t&)> validator)
        {
            float bestWeight = std::numeric_limits<float>::min();
            int bestRank = std::numeric_limits<int>::min();
 
            for(std::size_t i = 0; i < options.size(); ++i)
            {
                if(!validator(i))
                {
                    continue;
                }
 
                auto& option = options[i];
 
                int rank = option.rank;
                float weight = option.evaluator->EvaluateContext(option.context,
                                                                 result.
                                                                 FetchNextEvaluatorSnapshot(option.
                                                                     evaluatedObjectName,
                                                                     option.evaluatedObjectMetadata,
                                                                     rank));
 
                if(rank > bestRank || (rank == bestRank && weight > bestWeight))
                {
                    bestRank = rank;
                    bestWeight = weight;
                    result.optionIndex = i;
                }
            }
        }
 
        template <typename ContextType>
        void GetBestOption(data::SelectionMethod selectionMethod,
                           const std::vector<Option<ContextType>>& options,
                           SelectionResult& result,
                           std::function<bool(const std::size_t&)> validator = [](const std::size_t&) -> bool
                           {
                               return true;
                           })
        {
            switch(selectionMethod)
            {
            case data::SelectionMethod::MAX:
                SelectMaxUtility<ContextType>(options, result, validator);
                break;
            default:
                break; //TODO: crash?
            //REVIEW: resolve todo above
            }
        }
    }
}
}
#endif  //GRAIL_SELECTOR_H