sampling_optimizer.h

Go to the documentation of this file.

/*
 * Copyright 2021 MusicScience37 (Kenta Kabashima)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once
 
#include <cstddef>
#include <limits>
#include <vector>
 
#include "num_collect/base/exception.h"
#include "num_collect/base/index_type.h"
#include "num_collect/base/precondition.h"
#include "num_collect/logging/iterations/iteration_logger.h"
#include "num_collect/logging/log_tag_view.h"
#include "num_collect/logging/logging_macros.h"
#include "num_collect/opt/concepts/objective_function.h"
#include "num_collect/opt/concepts/single_variate_objective_function.h"
#include "num_collect/opt/optimizer_base.h"
#include "num_collect/util/safe_cast.h"
 
namespace num_collect::opt {
 
constexpr auto sampling_optimizer_tag =
    logging::log_tag_view("num_collect::opt::sampling_optimizer");
 
template <concepts::objective_function ObjectiveFunction>
class sampling_optimizer;
 
template <concepts::single_variate_objective_function ObjectiveFunction>
class sampling_optimizer<ObjectiveFunction>
    : public optimizer_base<sampling_optimizer<ObjectiveFunction>> {
public:
    using this_type = sampling_optimizer<ObjectiveFunction>;
 
    using objective_function_type = ObjectiveFunction;
 
    using variable_type = typename objective_function_type::variable_type;
 
    using value_type = typename objective_function_type::value_type;
 
    explicit sampling_optimizer(
        const objective_function_type& obj_fun = objective_function_type())
        : optimizer_base<sampling_optimizer<ObjectiveFunction>>(
              sampling_optimizer_tag),
          obj_fun_(obj_fun) {}
 
    void change_objective_function(const objective_function_type& obj_fun) {
        obj_fun_ = obj_fun;
    }
 
    void init(const variable_type& lower, const variable_type& upper) {
        lower_ = lower;
        upper_ = upper;
        iterations_ = 0;
        evaluations_ = 0;
 
        // Without this, solve() causes segmentation fault.
        iterate();
    }
 
    void iterate() {
        const auto num_samples_size_t =
            util::safe_cast<std::size_t>(num_samples_);
        samples_.resize(num_samples_size_t);
        values_.resize(num_samples_size_t);
 
        value_type min_val = std::numeric_limits<value_type>::max();
 
        for (std::size_t i = 0; i < num_samples_size_t; ++i) {
            const variable_type rate = static_cast<variable_type>(i) /
                static_cast<variable_type>(num_samples_ - 1);
            const variable_type variable = lower_ + (upper_ - lower_) * rate;
 
            obj_fun_.evaluate_on(variable);
            const value_type value = obj_fun_.value();
 
            samples_[i] = variable;
            values_[i] = value;
 
            if (value < min_val) {
                min_val = value;
                ind_opt_sample_ = i;
            }
 
            ++evaluations_;
        }
 
        if (ind_opt_sample_ > 0) {
            lower_ = samples_[ind_opt_sample_ - 1];
        }
        if (ind_opt_sample_ < num_samples_size_t - 1) {
            upper_ = samples_[ind_opt_sample_ + 1];
        }
 
        ++iterations_;
    }
 
    [[nodiscard]] auto is_stop_criteria_satisfied() const -> bool {
        return iterations_ >= max_iterations_;
    }
 
    void configure_iteration_logger(logging::iterations::iteration_logger<
        sampling_optimizer<ObjectiveFunction>>& iteration_logger) const {
        iteration_logger.template append<index_type>(
            "Iter.", &this_type::iterations);
        iteration_logger.template append<index_type>(
            "Eval.", &this_type::evaluations);
        iteration_logger.template append<value_type>(
            "Value", &this_type::opt_value);
    }
 
    [[nodiscard]] auto opt_variable() const -> const variable_type& {
        return samples_[ind_opt_sample_];
    }
 
    [[nodiscard]] auto opt_value() const -> const value_type& {
        return values_[ind_opt_sample_];
    }
 
    [[nodiscard]] auto upper() const -> const variable_type& { return upper_; }
 
    [[nodiscard]] auto lower() const -> const variable_type& { return lower_; }
 
    [[nodiscard]] auto iterations() const noexcept -> index_type {
        return iterations_;
    }
 
    [[nodiscard]] auto evaluations() const noexcept -> index_type {
        return evaluations_;
    }
 
    auto num_samples(index_type value) -> sampling_optimizer& {
        NUM_COLLECT_PRECONDITION(value >= 2, this->logger(),
            "Number of samples must be at least two.");
        num_samples_ = value;
        return *this;
    }
 
    auto max_iterations(index_type value) -> sampling_optimizer& {
        NUM_COLLECT_PRECONDITION(value > 0, this->logger(),
            "Maximum number of iterations must be a positive integer.");
        max_iterations_ = value;
        return *this;
    }
 
private:
    objective_function_type obj_fun_;
 
    variable_type lower_{static_cast<variable_type>(0)};
 
    variable_type upper_{static_cast<variable_type>(1)};
 
    std::vector<variable_type> samples_{};
 
    std::vector<value_type> values_{};
 
    std::size_t ind_opt_sample_{0};
 
    static constexpr index_type default_num_samples = 21;
 
    index_type num_samples_{default_num_samples};
 
    static constexpr index_type default_max_iterations = 3;
 
    index_type max_iterations_{default_max_iterations};
 
    index_type iterations_{0};
 
    index_type evaluations_{0};
};
 
}  // namespace num_collect::opt