hyperparams.h

Go to the documentation of this file.

// Copyright (c) 2021, Aalto University, developed by Erik Schultheis
// All rights reserved.
//
// SPDX-License-Identifier: MIT
 
#ifndef DISMEC_HYPERPARAMS_H
#define DISMEC_HYPERPARAMS_H
 
#include <string>
#include <variant>
#include <unordered_map>
#include <type_traits>
#include <functional>
#include <stdexcept>
 
namespace dismec
{
    class HyperParameterBase {
    public:
        using hyper_param_t = std::variant<long, double>;
 
        HyperParameterBase() = default;
        virtual ~HyperParameterBase() = default;
        HyperParameterBase(const HyperParameterBase&) = default;
        HyperParameterBase(HyperParameterBase&&) = default;
        HyperParameterBase& operator=(HyperParameterBase&&) = default;
        HyperParameterBase& operator=(const HyperParameterBase&) = default;
 
        void set_hyper_parameter(const std::string& name, long value);
        void set_hyper_parameter(const std::string& name, double value);
 
        [[nodiscard]] hyper_param_t get_hyper_parameter(const std::string& name) const;
 
        std::vector<std::string> get_hyper_parameter_names() const;
 
    protected:
        template<class U, class S>
        void declare_hyper_parameter(std::string name, U S::* pointer)
        {
            static_assert(std::is_base_of_v<HyperParameterBase, S>, "HyperParameterBase is not base class of member pointer");
 
            if(dynamic_cast<S*>(this) == nullptr) {
                throw std::logic_error("Cannot cast this pointer to class `S`");
            }
 
            auto getter = [pointer](const HyperParameterBase* self) {
                return dynamic_cast<const S*>(self)->*pointer;
            };
            auto setter = [pointer](HyperParameterBase* self, const U& value) {
                dynamic_cast<S*>(self)->*pointer = value;
            };
 
            declare_hyper_parameter(std::move(name), HyperParamData<U>{setter, getter});
        }
        template<class U, class S>
        void declare_hyper_parameter(std::string name, U(S::*getter)() const, void(S::*setter)(U))
        {
            static_assert(std::is_base_of_v<HyperParameterBase, S>, "T is not base class of member pointer");
 
            if(dynamic_cast<S*>(this) == nullptr) {
                throw std::logic_error("Cannot cast this pointer to class `S`");
            }
 
            auto getter_ = [getter](const HyperParameterBase* self) -> std::decay_t<U> {
                return (dynamic_cast<const S*>(self)->*getter)();
            };
            auto setter_ = [setter](HyperParameterBase* self, const U& value) {
                (dynamic_cast<S*>(self)->*setter)(value);
            };
 
            declare_hyper_parameter(std::move(name), HyperParamData<U>{setter_, getter_});
        }
 
        template<class T, class S>
        void declare_sub_object(const std::string& name, T S::*object) {
            static_assert(std::is_base_of_v<HyperParameterBase, S>, "S is not base class of member pointer");
            static_assert(std::is_base_of_v<HyperParameterBase, T>, "T is not base class of member pointer");
 
            if(dynamic_cast<S*>(this) == nullptr) {
                throw std::logic_error("Cannot cast this pointer to class `S`");
            }
 
            // we need to get one instance of the sub-object, so we can iterate its hyper-parameters
            HyperParameterBase& sub_object = dynamic_cast<S*>(this)->*object;
 
            for(const auto& hp : sub_object.m_HyperParameters)
            {
                std::visit([&](const auto& hp_data)
                {
                    // get the type that is used in the inner object
                    using value_t = typename std::decay_t<decltype(hp_data)>::ValueType;
                    // make getter and setter functions that look up the actual inner objects in the
                    // submitted `self`, and then call the inner getters and setters
                    auto getter_ = [object, inner_get=hp_data.Getter](const HyperParameterBase* self) {
                        auto self_as_s = dynamic_cast<const S*>(self);
                        return inner_get(&(self_as_s->*object));
                    };
                    auto setter_ = [object, inner_set=hp_data.Setter](HyperParameterBase* self, const value_t& value) {
                        auto self_as_s = dynamic_cast<S*>(self);
                        inner_set(&(self_as_s->*object), value);
                    };
                    // register with . separated name
                    declare_hyper_parameter(name + "." + hp.first, HyperParamData<value_t>{setter_, getter_});
                    }, hp.second);
            }
         }
 
    private:
 
        template<class D>
        struct HyperParamData {
            std::function<void(HyperParameterBase*, D)> Setter;
            std::function<D(const HyperParameterBase*)> Getter;
            using ValueType = D;
        };
 
        template<class D>
        void declare_hyper_parameter(std::string name, HyperParamData<D> data) {
            auto result = m_HyperParameters.insert( std::make_pair(std::move(name), std::move(data)) );
            if(!result.second) {
                throw std::logic_error("Trying to re-register hyper-parameter " + result.first->first);
            }
        }
 
        using hyper_param_ptr_t = std::variant<HyperParamData<long>, HyperParamData<double>>;
        std::unordered_map<std::string, hyper_param_ptr_t> m_HyperParameters;
    };
 
 
    class HyperParameters {
    public:
        using hyper_param_t = HyperParameterBase::hyper_param_t;
 
        void set(const std::string& name, long value);
        void set(const std::string& name, double value);
 
        [[nodiscard]] hyper_param_t get(const std::string& name) const;
 
        void apply(HyperParameterBase& target) const;
 
    private:
        std::unordered_map<std::string, hyper_param_t> m_Values;
    };
}
 
#endif //DISMEC_HYPERPARAMS_H