descent_method_base.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 "num_collect/base/index_type.h"
#include "num_collect/logging/log_tag_view.h"
#include "num_collect/opt/concepts/line_searcher.h"
#include "num_collect/opt/optimizer_base.h"
 
namespace num_collect::opt {
 
template <typename Derived, concepts::line_searcher LineSearcher>
class descent_method_base : public optimizer_base<Derived> {
public:
    using line_searcher_type = LineSearcher;
 
    using objective_function_type =
        typename line_searcher_type::objective_function_type;
 
    using variable_type = typename objective_function_type::variable_type;
 
    using value_type = typename objective_function_type::value_type;
 
    void init(const variable_type& init_variable) {
        line_searcher_.init(init_variable);
        iterations_ = 0;
    }
 
    [[nodiscard]] auto calc_direction() -> variable_type {
        return derived().calc_direction();
    }
 
    void iterate() {
        line_searcher_.search(calc_direction());
        ++iterations_;
    }
 
    [[nodiscard]] auto is_stop_criteria_satisfied() const -> bool {
        return gradient_norm() < tol_grad_norm_;
    }
 
    [[nodiscard]] auto line_searcher() -> line_searcher_type& {
        return line_searcher_;
    }
 
    [[nodiscard]] auto line_searcher() const -> const line_searcher_type& {
        return line_searcher_;
    }
 
    [[nodiscard]] auto opt_variable() const -> const variable_type& {
        return line_searcher().opt_variable();
    }
 
    [[nodiscard]] auto opt_value() const -> const value_type& {
        return line_searcher().opt_value();
    }
 
    [[nodiscard]] auto iterations() const noexcept -> index_type {
        return iterations_;
    }
 
    [[nodiscard]] auto evaluations() const noexcept -> index_type {
        return line_searcher().evaluations();
    }
 
    [[nodiscard]] auto gradient() const -> const variable_type& {
        return line_searcher().gradient();
    }
 
    [[nodiscard]] auto gradient_norm() const -> value_type {
        return gradient().norm();
    }
 
    auto tol_gradient_norm(const value_type& value) -> Derived& {
        tol_grad_norm_ = value;
        return derived();
    }
 
protected:
    // use derived() function
    using optimizer_base<Derived>::derived;
 
    explicit descent_method_base(logging::log_tag_view tag,
        const objective_function_type& obj_fun = objective_function_type())
        : optimizer_base<Derived>(tag), line_searcher_(obj_fun) {}
 
private:
    line_searcher_type line_searcher_;
 
    index_type iterations_{0};
 
    static inline const auto default_tol_grad_norm =
        static_cast<value_type>(1e-3);
 
    value_type tol_grad_norm_{default_tol_grad_norm};
};
 
}  // namespace num_collect::opt