parameter.hpp

Go to the documentation of this file.

 
#ifndef PLSSVM_PARAMETER_HPP_
#define PLSSVM_PARAMETER_HPP_
#pragma once
 
#include "plssvm/default_value.hpp"          // plssvm::default_value, plssvm::is_default_value_v
#include "plssvm/detail/type_traits.hpp"     // PLSSVM_REQUIRES, plssvm::detail::{remove_cvref_t, always_false_v}
#include "plssvm/detail/utility.hpp"         // plssvm::detail::unreachable
#include "plssvm/kernel_function_types.hpp"  // plssvm::kernel_function_type, plssvm::kernel_function_type_to_math_string
 
#include "fmt/core.h"                        // fmt::format
#include "fmt/ostream.h"                     // be able to output custom types with an operator<< overload using fmt
#include "igor/igor.hpp"                     // IGOR_MAKE_NAMED_ARGUMENT, igor::parser, igor::has_unnamed_arguments, igor::has_other_than
 
#include <iostream>                          // std::clog, std::endl, std::ostream
#include <string_view>                       // std::string_view
#include <type_traits>                       // std::is_same_v, std::is_convertible_v
#include <utility>                           // std::forward
 
namespace plssvm {
 
// create named arguments
IGOR_MAKE_NAMED_ARGUMENT(kernel_type);
IGOR_MAKE_NAMED_ARGUMENT(gamma);
IGOR_MAKE_NAMED_ARGUMENT(degree);
IGOR_MAKE_NAMED_ARGUMENT(coef0);
IGOR_MAKE_NAMED_ARGUMENT(cost);
IGOR_MAKE_NAMED_ARGUMENT(epsilon);
IGOR_MAKE_NAMED_ARGUMENT(max_iter);
IGOR_MAKE_NAMED_ARGUMENT(sycl_implementation_type);
IGOR_MAKE_NAMED_ARGUMENT(sycl_kernel_invocation_type);
 
namespace detail {
 
template <typename... Args>
constexpr bool has_only_named_args_v = !igor::has_unnamed_arguments<Args...>();
 
template <typename... Args>
constexpr bool has_only_parameter_named_args_v = !igor::has_other_than<Args...>(plssvm::kernel_type, plssvm::gamma, plssvm::degree, plssvm::coef0, plssvm::cost);
 
template <typename... Args>
constexpr bool has_only_sycl_parameter_named_args_v = !igor::has_other_than<Args...>(plssvm::kernel_type, plssvm::gamma, plssvm::degree, plssvm::coef0, plssvm::cost, plssvm::sycl_implementation_type, plssvm::sycl_kernel_invocation_type);
 
template <typename ExpectedType, typename IgorParser, typename NamedArgType>
ExpectedType get_value_from_named_parameter(const IgorParser &parser, const NamedArgType &named_arg) {
    using parsed_named_arg_type = detail::remove_cvref_t<decltype(parser(named_arg))>;
    // check whether a plssvm::default_value (e.g., plssvm::default_value<double>) or unwrapped normal value (e.g., double) has been provided
    if constexpr (is_default_value_v<parsed_named_arg_type>) {
        static_assert(std::is_convertible_v<typename parsed_named_arg_type::value_type, ExpectedType>, "Cannot convert the wrapped default value to the expected type!");
        // a plssvm::default_value has been provided (e.g., plssvm::default_value<double>)
        return static_cast<ExpectedType>(parser(named_arg).value());
    } else if constexpr (std::is_convertible_v<parsed_named_arg_type, ExpectedType>) {
        // an unwrapped value has been provided (e.g., double)
        return static_cast<ExpectedType>(parser(named_arg));
    } else {
        static_assert(detail::always_false_v<ExpectedType>, "The named parameter must be of type plssvm::default_value or a fundamental type!");
    }
    // may never be reached
    detail::unreachable();
}
 
template <typename T>
struct parameter {
    // only float and doubles are allowed
    static_assert(std::is_same_v<T, float> || std::is_same_v<T, double>, "The template type can only be 'float' or 'double'!");
 
    using real_type = T;
 
    constexpr parameter() noexcept = default;
    constexpr parameter(const kernel_function_type kernel_p, const int degree_p, const real_type gamma_p, const real_type coef0_p, const real_type cost_p) noexcept {
        // not in member initializer list since we want to override the default value
        kernel_type = kernel_p;
        degree = degree_p;
        gamma = gamma_p;
        coef0 = coef0_p;
        cost = cost_p;
    }
 
    template <typename... Args, PLSSVM_REQUIRES(has_only_named_args_v<Args...>)>
    constexpr explicit parameter(const parameter &params, Args &&...named_args) :
        parameter{ params } {
        this->set_named_arguments(std::forward<Args>(named_args)...);
    }
 
    template <typename... Args, PLSSVM_REQUIRES(has_only_named_args_v<Args...>)>
    constexpr explicit parameter(Args &&...named_args) noexcept {
        this->set_named_arguments(std::forward<Args>(named_args)...);
    }
 
    default_value<kernel_function_type> kernel_type{ default_init<kernel_function_type>{ kernel_function_type::linear } };
    default_value<int> degree{ default_init<int>{ 3 } };
    default_value<real_type> gamma{ default_init<real_type>{ 0.0 } };
    default_value<real_type> coef0{ default_init<real_type>{ 0.0 } };
    default_value<real_type> cost{ default_init<real_type>{ 1.0 } };
 
    template <typename U>
    [[nodiscard]] constexpr explicit operator parameter<U>() const {
        if constexpr (std::is_same_v<U, real_type>) {
            // no special conversions needed
            return parameter<real_type>{ *this };
        } else {
            // convert between parameter<float> <-> parameter<double>
            return parameter<U>{ kernel_type, degree, default_value<U>{ gamma }, default_value<U>{ coef0 }, default_value<U>{ cost } };
        }
    }
 
    [[nodiscard]] constexpr bool equivalent(const parameter &other) const noexcept {
        // equality check, but only the member variables that a necessary for the current kernel type are compared!
        // cannot be equal if both parameters have different kernel types
        if (kernel_type != other.kernel_type) {
            return false;
        }
        // check member variables based on kernel type
        switch (kernel_type.value()) {
            case kernel_function_type::linear:
                return cost == other.cost;
            case kernel_function_type::polynomial:
                return degree == other.degree && gamma == other.gamma && coef0 == other.coef0 && cost == other.cost;
            case kernel_function_type::rbf:
                return gamma == other.gamma && cost == other.cost;
        }
        return false;
    }
 
  private:
    template <typename... Args>
    void set_named_arguments(Args &&...named_args) {
        igor::parser parser{ std::forward<Args>(named_args)... };
 
        // compile time check: only named parameter are permitted
        static_assert(!parser.has_unnamed_arguments(), "Can only use named parameter!");
        // compile time check: each named parameter must only be passed once
        static_assert(!parser.has_duplicates(), "Can only use each named parameter once!");
        // compile time check: only some named parameters are allowed
        static_assert(!parser.has_other_than(plssvm::kernel_type, plssvm::gamma, plssvm::degree, plssvm::coef0, plssvm::cost, plssvm::sycl_implementation_type, plssvm::sycl_kernel_invocation_type),
                      "An illegal named parameter has been passed!");
 
        // shorthand function for emitting a warning if a provided parameter is not used by the current kernel function
        [[maybe_unused]] const auto print_warning = [](const std::string_view param_name, const kernel_function_type kernel) {
            std::clog << fmt::format("{} parameter provided, which is not used in the {} kernel ({})!", param_name, kernel, kernel_function_type_to_math_string(kernel)) << std::endl;
        };
 
        // compile time/runtime check: the values must have the correct types
        if constexpr (parser.has(plssvm::kernel_type)) {
            // get the value of the provided named parameter
            kernel_type = get_value_from_named_parameter<typename decltype(kernel_type)::value_type>(parser, plssvm::kernel_type);
        }
        if constexpr (parser.has(plssvm::gamma)) {
            // get the value of the provided named parameter
            gamma = get_value_from_named_parameter<typename decltype(gamma)::value_type>(parser, plssvm::gamma);
            // runtime check: the value may only be used with a specific kernel type
            if (kernel_type == kernel_function_type::linear) {
                print_warning("gamma", kernel_type);
            }
        }
        if constexpr (parser.has(plssvm::degree)) {
            // get the value of the provided named parameter
            degree = get_value_from_named_parameter<typename decltype(degree)::value_type>(parser, plssvm::degree);
            // runtime check: the value may only be used with a specific kernel type
            if (kernel_type == kernel_function_type::linear || kernel_type == kernel_function_type::rbf) {
                print_warning("degree", kernel_type);
            }
        }
        if constexpr (parser.has(plssvm::coef0)) {
            // get the value of the provided named parameter
            coef0 = get_value_from_named_parameter<typename decltype(coef0)::value_type>(parser, plssvm::coef0);
            // runtime check: the value may only be used with a specific kernel type
            if (kernel_type == kernel_function_type::linear || kernel_type == kernel_function_type::rbf) {
                print_warning("coef0", kernel_type);
            }
        }
        if constexpr (parser.has(plssvm::cost)) {
            // get the value of the provided named parameter
            cost = get_value_from_named_parameter<typename decltype(cost)::value_type>(parser, plssvm::cost);
        }
    }
};
 
extern template struct parameter<float>;
extern template struct parameter<double>;
 
template <typename T>
[[nodiscard]] constexpr bool operator==(const parameter<T> &lhs, const parameter<T> &rhs) noexcept {
    return lhs.kernel_type == rhs.kernel_type && lhs.degree == rhs.degree && lhs.gamma == rhs.gamma && lhs.coef0 == rhs.coef0 && lhs.cost == rhs.cost;
}
template <typename T>
[[nodiscard]] constexpr bool operator!=(const parameter<T> &lhs, const parameter<T> &rhs) noexcept {
    return !(lhs == rhs);
}
 
template <typename T>
[[nodiscard]] constexpr bool equivalent(const parameter<T> &lhs, const parameter<T> &rhs) noexcept {
    return lhs.equivalent(rhs);
}
 
template <typename T>
std::ostream &operator<<(std::ostream &out, const parameter<T> &params);
 
}  // namespace detail
 
using parameter = detail::parameter<double>;
 
[[nodiscard]] constexpr bool equivalent(const parameter &lhs, const parameter &rhs) noexcept {
    return detail::equivalent(lhs, rhs);
}
 
}  // namespace plssvm
 
#endif  // PLSSVM_PARAMETER_HPP_