decl/second-order-panoc.hpp

Go to the documentation of this file.

#pragma once
 
#include <panoc-alm/inner/decl/panoc-fwd.hpp>
#include <panoc-alm/inner/decl/panoc-stop-crit.hpp>
#include <panoc-alm/util/atomic_stop_signal.hpp>
#include <panoc-alm/util/lipschitz.hpp>
#include <panoc-alm/util/problem.hpp>
#include <panoc-alm/util/solverstatus.hpp>
 
#include <atomic>
#include <chrono>
#include <limits>
#include <string>
 
namespace pa {
 
struct SecondOrderPANOCParams {
    LipschitzEstimateParams Lipschitz;
    unsigned max_iter = 100;
    std::chrono::microseconds max_time = std::chrono::minutes(5);
    real_t τ_min = 1. / 256;
    real_t L_min = 1e-5;
    real_t L_max = 1e9;
    PANOCStopCrit stop_crit = PANOCStopCrit::ApproxKKT;
    unsigned max_no_progress = 10;
 
    unsigned print_interval = 0;
 
    real_t quadratic_upperbound_tolerance_factor =
        10 * std::numeric_limits<real_t>::epsilon();
 
    bool update_lipschitz_in_linesearch = true;
    bool alternative_linesearch_cond    = false;
};
 
class SecondOrderPANOCSolver {
  public:
    using Params = SecondOrderPANOCParams;
 
    struct Stats {
        SolverStatus status = SolverStatus::Unknown;
        real_t ε            = inf;
        std::chrono::microseconds elapsed_time;
        unsigned iterations          = 0;
        unsigned newton_failures     = 0;
        unsigned linesearch_failures = 0;
        unsigned τ_1_accepted        = 0;
        unsigned count_τ             = 0;
        real_t sum_τ                 = 0;
    };
 
    struct ProgressInfo {
        unsigned k;
        crvec x;
        crvec p;
        real_t norm_sq_p;
        crvec x_hat;
        real_t ψ;
        crvec grad_ψ;
        real_t ψ_hat;
        crvec grad_ψ_hat;
        real_t L;
        real_t γ;
        real_t ε;
        crvec Σ;
        crvec y;
        const Problem &problem;
        const Params &params;
    };
 
    SecondOrderPANOCSolver(Params params) : params(params) {}
 
    Stats operator()(const Problem &problem,        // in
                     crvec Σ,                       // in
                     real_t ε,                      // in
                     bool always_overwrite_results, // in
                     rvec x,                        // inout
                     rvec y,                        // inout
                     rvec err_z);                   // out
 
    SecondOrderPANOCSolver &
    set_progress_callback(std::function<void(const ProgressInfo &)> cb) {
        this->progress_cb = cb;
        return *this;
    }
 
    std::string get_name() const { return "SecondOrderPANOCSolver"; }
 
    void stop() { stop_signal.stop(); }
 
    const Params &get_params() const { return params; }
 
  private:
    Params params;
    AtomicStopSignal stop_signal;
    std::function<void(const ProgressInfo &)> progress_cb;
};
 
template <class InnerSolverStats>
struct InnerStatsAccumulator;
 
template <>
struct InnerStatsAccumulator<SecondOrderPANOCSolver::Stats> {
    std::chrono::microseconds elapsed_time;
    unsigned iterations          = 0;
    unsigned newton_failures     = 0;
    unsigned linesearch_failures = 0;
    unsigned τ_1_accepted        = 0;
    unsigned count_τ             = 0;
    real_t sum_τ                 = 0;
};
 
inline InnerStatsAccumulator<SecondOrderPANOCSolver::Stats> &
operator+=(InnerStatsAccumulator<SecondOrderPANOCSolver::Stats> &acc,
           const SecondOrderPANOCSolver::Stats &s) {
    acc.elapsed_time += s.elapsed_time;
    acc.iterations += s.iterations;
    acc.newton_failures += s.newton_failures;
    acc.linesearch_failures += s.linesearch_failures;
    acc.τ_1_accepted += s.τ_1_accepted;
    acc.count_τ += s.count_τ;
    acc.sum_τ += s.sum_τ;
    return acc;
}
 
} // namespace pa