pantr.hpp File Reference

#include <alpaqa/export.hpp>
#include <alpaqa/inner/inner-solve-options.hpp>
#include <alpaqa/inner/internal/lipschitz.hpp>
#include <alpaqa/inner/internal/panoc-helpers.hpp>
#include <alpaqa/inner/internal/panoc-stop-crit.hpp>
#include <alpaqa/inner/internal/solverstatus.hpp>
#include <alpaqa/problem/type-erased-problem.hpp>
#include <alpaqa/util/atomic-stop-signal.hpp>
#include <chrono>
#include <iostream>
#include <limits>
#include <string>
#include <type_traits>

Include dependency graph for pantr.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	PANTRParams< Conf >
	Tuning parameters for the PANTR algorithm. More...
struct	PANTRStats< Conf >
struct	PANTRProgressInfo< Conf >
class	PANTRSolver< DirectionT >
	PANTR solver for ALM. More...
struct	InnerStatsAccumulator< PANTRStats< Conf > >

Namespaces
namespace	alpaqa

Functions
template<Config Conf>
InnerStatsAccumulator< PANTRStats< Conf > > &	operator+= (InnerStatsAccumulator< PANTRStats< Conf > > &acc, const PANTRStats< Conf > &s)

---

Class Documentation

alpaqa::PANTRParams

struct alpaqa::PANTRParams

Collaboration diagram for PANTRParams< Conf >:

Class Members
LipschitzEstimateParams< config_t >	Lipschitz	Parameters related to the Lipschitz constant estimate and step size.
unsigned	max_iter = 100	Maximum number of inner PANTR iterations.
nanoseconds	max_time = std::chrono::minutes(5)	Maximum duration.
real_t	L_min = real_t(1e-5)	Minimum Lipschitz constant estimate.
real_t	L_max = real_t(1e20)	Maximum Lipschitz constant estimate.
PANOCStopCrit	stop_crit = PANOCStopCrit::ApproxKKT	What stopping criterion to use.
unsigned	max_no_progress = 10	Maximum number of iterations without any progress before giving up.
unsigned	print_interval = 0	When to print progress. If set to zero, nothing will be printed. If set to N != 0, progress is printed every N iterations.
int	print_precision = std::numeric_limits<real_t>::max_digits10 / 2	The precision of the floating point values printed by the solver.
real_t	quadratic_upperbound_tolerance_factor
real_t	TR_tolerance_factor = 10 * std::numeric_limits<real_t>::epsilon()
real_t	ratio_threshold_acceptable = real_t(0.2)	Minimal TR ratio to be accepted (successful).
real_t	ratio_threshold_good = real_t(0.8)	Minimal TR ratio to increase radius (very successful).
real_t	radius_factor_rejected = real_t(0.35)	TR radius decrease coefficient when unsuccessful.
real_t	radius_factor_acceptable = real_t(0.999)	TR radius decrease coefficient when successful.
real_t	radius_factor_good = real_t(2.5)	TR radius increase coefficient when very successful.
real_t	initial_radius = NaN<config_t>	Initial trust radius.
real_t	min_radius = 100 * std::numeric_limits<real_t>::epsilon()	Minimum trust radius.
bool	compute_ratio_using_new_stepsize = false	Check the quadratic upperbound and update γ before computing the reduction of the TR step.
bool	update_direction_on_prox_step = true
bool	recompute_last_prox_step_after_direction_reset = false
bool	disable_acceleration = false	Don't compute accelerated steps, fall back to forward-backward splitting. For testing purposes.
bool	ratio_approx_fbe_quadratic_model = true	Compute the trust-region ratio using an approximation of the quadratic model of the FBE, rather than the quadratic model of the subproblem. Specifically, when set to false, the quadratic model used is $$q(d)=\frac{1}{2}⟨{\mathcal{R}}_{\gamma }(\hat{x})d|d⟩+⟨R_{\gamma }(\hat{x})|d⟩.$$ When set to true, the quadratic model used is $$q_{\mathrm{approx}}(d)=(1-\alpha {)}^{-1}q(d),$$ where $\alpha =$ LipschitzEstimateParams::Lγ_factor. This is an approximation of the quadratic model of the FBE, $$q_{{\phi }_{\gamma }}(d)=\frac{1}{2}⟨{\mathcal{Q}}_{\gamma }(\hat{x}){\mathcal{R}}_{\gamma }(\hat{x})d|d⟩+⟨{\mathcal{Q}}_{\gamma }(\hat{x})R_{\gamma }(\hat{x})|d⟩,$$ with ${\mathcal{Q}}_{\gamma }(x)=\mathrm{Id}-\gamma {\mathrm{\nabla }}^2\psi (x)$.

alpaqa::PANTRStats

struct alpaqa::PANTRStats

Collaboration diagram for PANTRStats< Conf >:

Class Members
SolverStatus	status = SolverStatus::Busy
real_t	ε = inf<config_t>
nanoseconds	elapsed_time {}
nanoseconds	time_progress_callback {}
unsigned	iterations = 0
unsigned	accelerated_step_rejected = 0
unsigned	stepsize_backtracks = 0
unsigned	direction_failures = 0
unsigned	direction_update_rejected = 0
real_t	final_γ = 0
real_t	final_ψ = 0
real_t	final_h = 0
real_t	final_φγ = 0

alpaqa::PANTRProgressInfo

struct alpaqa::PANTRProgressInfo

Collaboration diagram for PANTRProgressInfo< Conf >:

Class Members
unsigned	k
SolverStatus	status
crvec	x
crvec	p
real_t	norm_sq_p
crvec	x̂
real_t	φγ
real_t	ψ
crvec	grad_ψ
real_t	ψ_hat
crvec	grad_ψ_hat
crvec	q
real_t	L
real_t	γ
real_t	Δ
real_t	ρ
real_t	ε
crvec	Σ
crvec	y
unsigned	outer_iter
const TypeErasedProblem< config_t > *	problem
const PANTRParams< config_t > *	params

alpaqa::InnerStatsAccumulator< PANTRStats< Conf > >

struct alpaqa::InnerStatsAccumulator< PANTRStats< Conf > >

Collaboration diagram for InnerStatsAccumulator< PANTRStats< Conf > >:

Class Members
nanoseconds	elapsed_time {}	Total elapsed time in the inner solver.
nanoseconds	time_progress_callback {}	Total time spent in the user-provided progress callback.
unsigned	iterations = 0	Total number of inner PANTR iterations.
unsigned	accelerated_step_rejected = 0	Total number of PANTR rejected accelerated steps.
unsigned	stepsize_backtracks = 0	Total number of FB step size reductions.
unsigned	direction_failures = 0	Total number of times that the accelerated direction was not finite.
unsigned	direction_update_rejected = 0	Total number of times that the direction update was rejected (e.g. it could have resulted in a non-positive definite Hessian estimate).
real_t	final_γ = 0	The final FB step size γ.
real_t	final_ψ = 0	Final value of the smooth cost $\psi (\hat{x})$.
real_t	final_h = 0	Final value of the nonsmooth cost $h(\hat{x})$.
real_t	final_φγ = 0	Final value of the forward-backward envelope, ${\phi }_{\gamma }(x)$ (note that this is in the point $x$, not $\hat{x}$).