objective.hpp

Go to the documentation of this file.

#pragma once
 
#include <pineforge/hpo/error.hpp>
 
#include <cstddef>
#include <functional>
#include <memory>
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "pineforge/hpo/types.hpp"
 
namespace pineforge::hpo {
 
using MetricMap = std::unordered_map<std::string, double>;
 
enum class DivisionByZeroPolicy {
    Reject,   
    Ieee754,  
};
 
enum class NonFinitePolicy {
    Reject,  
    Allow,   
};
 
struct EvaluationPolicy {
    DivisionByZeroPolicy division_by_zero = DivisionByZeroPolicy::Reject;
    NonFinitePolicy non_finite_metric = NonFinitePolicy::Reject;
    NonFinitePolicy non_finite_result = NonFinitePolicy::Reject;
};
 
enum class EvaluationError {
    None,             
    MissingMetric,    
    NonFiniteMetric,  
    DivisionByZero,   
    NonFiniteResult,  
};
 
struct ExpressionEvaluation {
    bool valid = false;
    double value = 0.0;
    EvaluationError error = EvaluationError::None;
    std::string diagnostic;
};
 
class ExpressionError : public TypedHpoError<> {
public:
    ExpressionError(std::string message, std::size_t offset);
 
    std::size_t offset() const noexcept { return offset_; }
 
private:
    std::size_t offset_;
};
 
namespace detail {
struct ExpressionNode;
}  // namespace detail
 
class MetricExpression {
public:
    explicit MetricExpression(std::string source);
    ~MetricExpression();
 
    MetricExpression(MetricExpression&&) noexcept;
    MetricExpression& operator=(MetricExpression&&) noexcept;
    MetricExpression(const MetricExpression&) = delete;
    MetricExpression& operator=(const MetricExpression&) = delete;
 
    ExpressionEvaluation evaluate(const MetricMap& metrics,
                                  const EvaluationPolicy& policy = {}) const noexcept;
    const std::string& source() const noexcept { return source_; }
    const std::vector<std::string>& identifiers() const noexcept { return identifiers_; }
 
private:
    std::string source_;
    std::unique_ptr<detail::ExpressionNode> root_;
    std::vector<std::string> identifiers_;
};
 
enum class ConstraintRelation {
    LessEqual,     
    GreaterEqual,  
    Equal,         
};
 
struct Constraint {
    std::string name;
    double lhs = 0.0;
    ConstraintRelation relation = ConstraintRelation::LessEqual;
    double rhs = 0.0;
    double tolerance = 0.0;
 
    bool satisfied() const noexcept;
 
    double violation() const noexcept;
};
 
struct ObjectiveResult {
    std::vector<double> values;
    std::vector<Constraint> constraints;
    bool valid = true;
    std::string diagnostic;
 
    bool feasible() const noexcept;
 
    static ObjectiveResult invalid(std::string diagnostic);
};
 
template <typename Observation>
using ObjectiveFn = std::function<ObjectiveResult(const Observation&, const TrialContext&)>;
 
}  // namespace pineforge::hpo