search_space.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <map>
#include <optional>
#include <string>
#include <string_view>
#include <variant>
#include <vector>
 
#include "pineforge/hpo/types.hpp"
 
namespace pineforge::hpo {
 
enum class DimensionKind {
    Integer,      
    Real,         
    Boolean,      
    Categorical,  
};
 
class IntegerDimension {
public:
    IntegerDimension(std::string name,
                     std::int64_t low,
                     std::int64_t high,
                     std::int64_t step = 1,
                     bool log = false);
 
    const std::string& name() const noexcept { return name_; }
    std::int64_t low() const noexcept { return low_; }
    std::int64_t high() const noexcept { return high_; }
    std::int64_t step() const noexcept { return step_; }
    bool log() const noexcept { return log_; }
    bool contains(const ParameterValue& value) const noexcept;
 
private:
    std::string name_;
    std::int64_t low_;
    std::int64_t high_;
    std::int64_t step_;
    bool log_;
};
 
class RealDimension {
public:
    RealDimension(std::string name,
                  double low,
                  double high,
                  std::optional<double> step = std::nullopt,
                  bool log = false);
 
    const std::string& name() const noexcept { return name_; }
    double low() const noexcept { return low_; }
    double high() const noexcept { return high_; }
    const std::optional<double>& step() const noexcept { return step_; }
    bool log() const noexcept { return log_; }
    bool contains(const ParameterValue& value) const noexcept;
 
private:
    std::string name_;
    double low_;
    double high_;
    std::optional<double> step_;
    bool log_;
};
 
class BooleanDimension {
public:
    explicit BooleanDimension(std::string name);
 
    const std::string& name() const noexcept { return name_; }
    bool contains(const ParameterValue& value) const noexcept;
 
private:
    std::string name_;
};
 
class CategoricalDimension {
public:
    CategoricalDimension(std::string name, std::vector<ParameterValue> choices);
 
    const std::string& name() const noexcept { return name_; }
    const std::vector<ParameterValue>& choices() const noexcept { return choices_; }
    bool contains(const ParameterValue& value) const noexcept;
 
private:
    std::string name_;
    std::vector<ParameterValue> choices_;
};
 
using Dimension =
    std::variant<IntegerDimension, RealDimension, BooleanDimension, CategoricalDimension>;
 
DimensionKind dimension_kind(const Dimension& dimension) noexcept;
std::string_view dimension_name(const Dimension& dimension) noexcept;
bool dimension_contains(const Dimension& dimension, const ParameterValue& value) noexcept;
 
struct ValidationIssue {
    std::string parameter;
    std::string message;
};
 
class SearchSpace {
public:
    SearchSpace() = default;
 
    explicit SearchSpace(std::vector<Dimension> dimensions);
 
    void add(Dimension dimension);
    const std::vector<Dimension>& dimensions() const noexcept { return dimensions_; }
    const Dimension* find(std::string_view name) const noexcept;
 
    std::vector<ValidationIssue> validate(const Candidate& candidate,
                                          bool reject_unknown = true) const;
    bool is_valid(const Candidate& candidate, bool reject_unknown = true) const;
 
    std::map<std::string, std::string> serialize_candidate(const Candidate& candidate,
                                                           bool reject_unknown = true) const;
 
    std::optional<std::uint64_t> finite_cardinality() const;
 
    Candidate candidate_at(std::uint64_t ordinal, std::uint64_t id = 0) const;
 
    std::uint64_t candidate_ordinal(const Candidate& candidate) const;
 
private:
    std::vector<Dimension> dimensions_;
};
 
}  // namespace pineforge::hpo