RouletteSelector.hh

// Copyright QED Software 2023.
 
#ifndef GRAIL_ROULETTE_SELECTOR_H
#define GRAIL_ROULETTE_SELECTOR_H
 
#include "RouletteOptions.hh"
#include "../Selectors/SelectionOption.hh"
#include "../Selectors/SelectionResult.hh"
#include "../../GrailEvaluators/Consideration.hh"
#include "../ConfigHelpers/DefaultRandomNumberGenerator.h"
 
#include <algorithm>
#include <functional>
 
namespace grail
{
namespace utility
{
namespace roulette_selector
{
    template <typename ContextType>
    void GetBestOption(const std::vector<SelectionOption<ContextType>>& options,
                       SelectionResult& result,
                       RandomNumberGenerator& randomNumberGenerator,
                       RouletteOptions rouletteOptions,
                       std::function<bool(const std::size_t&)> validator)
    {
        std::vector<std::pair<int, float>> legalIndexWeightPairs(options.size());
        int bestRank = -1;
        for (int i = 0; i < options.size(); ++i)
        {
            if (!validator(i))
            {
                continue;
            }
 
            auto option = options[i];
            int rank = option.rank;
            evaluator::CacheConsiderationEvaluations(option.evaluator, option.context);
            float weight = option.evaluator->EvaluateContext(option.context,
                                                            result.FetchNextEvaluatorSnapshot(option.evaluatedObjectName, option.evaluatedObjectMetadata, rank));
            
            if (rank >= bestRank)
            {
                if (weight < 0.0f)
                {
                    continue;
                }
 
                if (rank > bestRank)
                {
                    legalIndexWeightPairs.clear();
                    bestRank = rank;
                }
 
                legalIndexWeightPairs.emplace_back(i, weight);
            }
        }
 
        const int numberOfTopBehaviors = rouletteOptions.GetNumberOfTopBehaviors();
        if (legalIndexWeightPairs.empty() || numberOfTopBehaviors == 0)
        {
            return;
        }
 
        std::sort(legalIndexWeightPairs.begin(), legalIndexWeightPairs.end(), [](auto first, auto second) { return first.second > second.second; });
        
        size_t topOptionsLimit;
        if(numberOfTopBehaviors > 0)
        {
            topOptionsLimit = std::min<size_t>(numberOfTopBehaviors, legalIndexWeightPairs.size());
        }
        else
        {
            topOptionsLimit = legalIndexWeightPairs.size();
        }
 
        const float bestOptionWeight = legalIndexWeightPairs.front().second;
        const float utilityThreshold = bestOptionWeight * rouletteOptions.GetRelativeUtilityThreshold();
        float totalWeightOfBestRankOptions = bestOptionWeight;
        for(int i = 1; i < topOptionsLimit; ++i)
        {
            const float optionUtility = legalIndexWeightPairs[i].second;
            if(optionUtility < utilityThreshold)
            {
                break;
            }
            
            totalWeightOfBestRankOptions += optionUtility;
        }
        
        float thresholdValue = randomNumberGenerator.GetRandomPercentage() * totalWeightOfBestRankOptions;
        for(const auto legalIndexWeightPair : legalIndexWeightPairs)
        {
            if (thresholdValue <= legalIndexWeightPair.second)
            {
                result.optionIndex = legalIndexWeightPair.first;
                return;
            }
 
            thresholdValue -= legalIndexWeightPair.second;
        }
    }
}
}
}
 
#endif  //GRAIL_ROULETTE_SELECTOR_H