inmost_optimizer.h

#ifndef INMOST_INMOST_OPTIMIZER_H
#define INMOST_INMOST_OPTIMIZER_H
 
#include "inmost.h"
 
#if defined(USE_OPTIMIZER)
 
#include <vector>
#include <algorithm>
#include <string>
#include <deque>
#include <unordered_map>
#include <functional>
 
namespace INMOST {
 
    enum class OptimizationParameterType {
        PARAMETER_TYPE_DEFAULT,
        PARAMETER_TYPE_EXPONENT
    };
 
    class OptimizationParameterPoint {
    private:
        std::string name;
        double      value;
 
        OptimizationParameterPoint(const std::string &name, double value, OptimizationParameterType type);
 
        static void swap(OptimizationParameterPoint &left, OptimizationParameterPoint &right);
 
    public:
        OptimizationParameterPoint(const OptimizationParameterPoint &other);
 
        OptimizationParameterPoint(OptimizationParameterPoint &&other) noexcept;
 
        OptimizationParameterPoint &operator=(const OptimizationParameterPoint &other);
 
        const std::string &GetName() const noexcept;
 
        double GetValue() const noexcept;
 
        ~OptimizationParameterPoint();
 
        static double convert(double value, OptimizationParameterType type);
 
        friend class OptimizationParameters;
    };
 
    typedef std::vector<OptimizationParameterPoint> OptimizationParameterPoints;
 
    typedef std::pair<double, double> OptimizationParameterRange;
 
    class OptimizationParameter {
    private:
        std::string               name;          
        std::vector<double>       values;        
        double                    default_value; 
        OptimizationParameterType type;          
 
        static void swap(OptimizationParameter &left, OptimizationParameter &right);
 
    public:
        OptimizationParameter(const std::string &name, const OptimizationParameterRange &range, double step,
                              double default_value, OptimizationParameterType type = OptimizationParameterType::PARAMETER_TYPE_DEFAULT);
 
        OptimizationParameter(const std::string &name, const std::vector<double> &values,
                              double default_value, OptimizationParameterType type = OptimizationParameterType::PARAMETER_TYPE_DEFAULT);
 
        OptimizationParameter(const OptimizationParameter &other);
 
        OptimizationParameter(OptimizationParameter &&other) noexcept;
 
        OptimizationParameter &operator=(const OptimizationParameter &other);
 
        const std::string &GetName() const noexcept;
 
        const std::vector<double> &GetValues() const noexcept;
 
        double GetMinimalValue() const noexcept;
 
        double GetMaximumValue() const noexcept;
 
        double GetMinStrictBound(double v, double modifier = 1.0) const noexcept;
 
        double GetMaxStrictBound(double v, double modifier = 1.0) const noexcept;
 
        double GetClosestTo(double to) const noexcept;
 
        std::size_t GetClosestIndexTo(double to) const noexcept;
 
        std::size_t GetValuesCount() const noexcept;
 
        double GetDefaultValue() const noexcept;
 
        OptimizationParameterType GetType() const noexcept;
 
        double ExtractValueFromPoint(const OptimizationParameterPoint &point) const noexcept;
    };
 
    typedef std::pair<OptimizationParameter, double> OptimizationParametersEntry;
 
    typedef std::vector<OptimizationParametersEntry> OptimizationParameterEntries;
 
    class SuggestionChangedParameter {
    private:
        std::size_t index;
        double      value;
 
        static void swap(SuggestionChangedParameter &left, SuggestionChangedParameter &right);
 
    public:
        SuggestionChangedParameter(std::size_t index, double value);
 
        SuggestionChangedParameter(const SuggestionChangedParameter &other);
 
        SuggestionChangedParameter(SuggestionChangedParameter &&other);
 
        SuggestionChangedParameter &operator=(const SuggestionChangedParameter &other);
 
        std::size_t GetIndex() const noexcept;
 
        double GetValue() const noexcept;
 
        ~SuggestionChangedParameter();
    };
 
    typedef std::vector<SuggestionChangedParameter> SuggestionChangedParameters;
 
    class OptimizationParametersSuggestion {
    private:
        SuggestionChangedParameters changed;
        OptimizationParameterPoints before;
        double                      metrics_before;
        OptimizationParameterPoints after;
    public:
        OptimizationParametersSuggestion(const SuggestionChangedParameters &changed,
                                         const OptimizationParameterPoints &before, double metrics_before,
                                         const OptimizationParameterPoints &after);
 
        const SuggestionChangedParameters &GetChangedParameters() const noexcept;
 
        const OptimizationParameterPoints &GetPointsBefore() const noexcept;
 
        double GetMetricsBefore() const noexcept;
 
        const OptimizationParameterPoints &GetPointsAfter() const noexcept;
    };
 
    class OptimizationParameters {
    private:
        OptimizationParameterEntries entries;            
        double                       metrics;            
 
        static void swap(OptimizationParameters &left, OptimizationParameters &right);
 
    public:
        OptimizationParameters(const OptimizationParameterEntries &entries, double metrics);
 
        OptimizationParameters(const OptimizationParameters &other);
 
        OptimizationParameters(OptimizationParameters &&other) noexcept;
 
        OptimizationParameters &operator=(const OptimizationParameters &other);
 
        const OptimizationParameterEntries &GetParameterEntries() const noexcept;
 
        const OptimizationParametersEntry &GetParameterEntry(std::size_t index) const;
 
        const OptimizationParameter &GetParameter(std::size_t index) const;
 
        std::size_t Size() const;
 
        const OptimizationParameterPoints GetPoints() const noexcept;
 
        double GetMetrics() const noexcept;
 
        const OptimizationParameterPoints GetPointsWithChangedParameter(const OptimizationParameter &parameter, double value) const noexcept;
 
        const OptimizationParameterPoints GetPointsWithChangedParameters(const SuggestionChangedParameters &changed) const noexcept;
 
        void Update(const SuggestionChangedParameters &changed, double metrics);
 
        void Update(std::size_t index, double value, double metrics);
    };
 
    class OptimizationParameterResult {
    private:
        SuggestionChangedParameters changed;             
        OptimizationParameterPoints before;              
        double                      metrics_before;      
        OptimizationParameterPoints after;               
        double                      metrics_after;       
        bool                        is_good;             
 
        static void swap(OptimizationParameterResult &left, OptimizationParameterResult &right);
 
    public:
        OptimizationParameterResult(const SuggestionChangedParameters &changed,
                                    const OptimizationParameterPoints &before, const OptimizationParameterPoints &after,
                                    double metrics_before, double metrics_after, bool is_good);
 
        OptimizationParameterResult(const OptimizationParameterResult &other);
 
        OptimizationParameterResult(OptimizationParameterResult &&other) noexcept;
 
        OptimizationParameterResult &operator=(const OptimizationParameterResult &other);
 
        const OptimizationParameterPoints &GetPointsBefore() const noexcept;
 
        const OptimizationParameterPoints &GetPointsAfter() const noexcept;
 
        double GetMetricsBefore() const noexcept;
 
        double GetMetricsAfter() const noexcept;
 
        bool IsGood() const noexcept;
 
        const SuggestionChangedParameters& GetChangedParameters() const noexcept;
    };
 
    class OptimizationParameterResultsBuffer {
    private:
        std::size_t                             capacity;                            
        std::deque<OptimizationParameterResult> buffer;  
 
        static void swap(OptimizationParameterResultsBuffer &left, OptimizationParameterResultsBuffer &right);
 
    public:
        OptimizationParameterResultsBuffer(std::size_t capacity);
 
        OptimizationParameterResultsBuffer(const OptimizationParameterResultsBuffer &other);
 
        OptimizationParameterResultsBuffer(OptimizationParameterResultsBuffer &&other) noexcept;
 
        OptimizationParameterResultsBuffer &operator=(const OptimizationParameterResultsBuffer &other);
 
        std::deque<OptimizationParameterResult>::const_reverse_iterator cbegin() const noexcept;
 
        const OptimizationParameterResult &at(std::size_t index) const;
 
        std::deque<OptimizationParameterResult>::const_reverse_iterator cend() const noexcept;
 
        void push(const OptimizationParameterResult &result);
 
        std::size_t size() const noexcept;
 
        bool IsEmpty() const noexcept;
 
        bool IsLastResultSuccessful() const noexcept;
 
        bool IsSuccessfulResultExist() const noexcept;
 
        const OptimizationParameterResult &GetLastSuccessfulResult() const;
 
        const std::vector<OptimizationParameterResult> GetLastUniqueEntries(std::size_t max) const;
    };
 
    typedef std::map<std::string, std::string> OptimizerProperties;
 
    enum class OptimizerVerbosityLevel {
        Level0,
        Level1,
        Level2,
        Level3
    };
 
    enum class OptimizerRestartStrategy {
        RESTART_STRATEGY_NO_RESTART,
        RESTART_STRATEGY_WITH_BEST
    };
 
    typedef std::pair<bool, double> OptimizationFunctionInvokeResult;
 
    class OptimizerInterface {
    private:
        int mpi_rank;
 
        std::string             name;
        OptimizerVerbosityLevel verbosity = OptimizerVerbosityLevel::Level0;
 
        OptimizerRestartStrategy restart_strategy = OptimizerRestartStrategy::RESTART_STRATEGY_NO_RESTART;
        std::size_t              max_fails        = std::numeric_limits<std::size_t>::max();
        std::size_t              fails_count      = 0;
 
        std::deque<OptimizationParametersSuggestion> suggestions;
 
        void RestartWithBestStrategy();
 
    protected:
        OptimizationParameterResultsBuffer results;
        OptimizationParameters             parameters;
        const OptimizerProperties          properties;
 
        virtual bool UpdateSpaceWithLatestResults();
 
        virtual SuggestionChangedParameters AlgorithmMakeSuggestion() const = 0;
 
    public:
        OptimizerInterface(const std::string &name, const OptimizationParameters &parameters, const OptimizerProperties &properties, std::size_t buffer_capacity) :
                name(name), parameters(parameters), properties(properties), results(buffer_capacity), mpi_rank(0) {
#ifdef USE_MPI
            MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
#endif
        };
 
        OptimizationParametersSuggestion Suggest();
 
        void SaveResult(const SuggestionChangedParameters &changed,
                        const OptimizationParameterPoints &before, double metrics_before,
                        const OptimizationParameterPoints &after, double metrics_after, bool is_good);
 
        void SaveResult(const SuggestionChangedParameters &changed, const OptimizationParameterPoints &after, double metrics_after, bool is_good);
 
        void SaveResult(const OptimizationParametersSuggestion &suggestion, double metrics, bool is_good);
 
        const OptimizationParameterResultsBuffer &GetResults() const noexcept;
 
        const OptimizationParameterPoints GetPoints() const noexcept;
 
        void SetVerbosityLevel(OptimizerVerbosityLevel level) noexcept;
 
        OptimizerVerbosityLevel GetVerbosityLevel() const noexcept;
 
        bool HasProperty(const std::string &name) const noexcept;
 
        const std::string &GetProperty(const std::string &name) const;
 
        const OptimizationParametersSuggestion &GetLastSuggestion() const;
 
        void SetRestartStrategy(OptimizerRestartStrategy strategy, std::size_t max_fails) noexcept;
 
        const std::string &GetName() const noexcept;
 
        virtual ~OptimizerInterface() {};
    };
 
    typedef std::unordered_map<std::string, OptimizerInterface *> SavedOptimizersMap;
 
    class Optimizers {
    private:
        static SavedOptimizersMap optimizers;
 
        Optimizers() = delete;
    public:
        static bool IsOptimizerAvailable(const std::string &type);
 
        static std::vector<std::string> GetAvailableOptimizers();
 
        static OptimizerInterface *GetOptimizer(const std::string &name, const std::string &type,
                                                const OptimizationParameters &parameters, const OptimizerProperties &properties, std::size_t buffer_capacity);
 
        static void SaveOptimizerOrReplace(const std::string &name, const std::string &type,
                                           const OptimizationParameters &parameters, const OptimizerProperties &properties, std::size_t buffer_capacity);
 
        static void SaveOptimizerOrReplace(const std::string &name, const std::string &type, const OptimizerProperties &properties, std::size_t buffer_capacity);
 
        static OptimizerInterface *GetSavedOptimizer(const std::string &name);
    };
 
    class OptimizersConfiguration {
    private:
        enum class OptimizerConfigurationReaderState {
            READ_GLOBAL_PARAMETER
        };
 
        static std::vector<OptimizationParameter> global_parameters;
 
        OptimizersConfiguration() = delete;
 
        static OptimizationParameter ParseOptimizationParameter(const std::string &line);
    public:
        static void FromFile(const std::string &path);
 
        static void FromStream(std::istream &stream);
 
        static OptimizationParameters GetGlobalOptimizationParameters();
    };
 
};
 
#endif
 
#endif //INMOST_INMOST_OPTIMIZER_H