Altro.jl

Implementation of the Augmented Lagrangian TRajectory Optimizer (ALTRO) solver, a very fast solver for constrained trajectory optimization problems. ALTRO uses iterative LQR (iLQR) with an augmented Lagrangian framework and can solve problems with nonlinear inequality and equality path constraints and nonlinear dynamics. The key features of the ALTRO solver are:

• General nonlinear cost functions, including minimum time problems
• General nonlinear state and input constraints
• Infeasible state initialization
• Square-root methods for improved numerical conditioning
• Active-set projection method for solution polishing

Altro.jl solves trajectory optimization problems set up using TrajectoryOptimization.jl.

For details on the solver, see the original conference paper or related tutorial.

Simple Example

See examples/quickstart.jl for a simple example of solving the canonical cartpole problem with Altro.jl.

Solver Statistics

ALTRO logs intermediate values during the course of the solve. These values are all stored in the SolverStats type, accessible via solver.stats or Altro.stats(solver). This currently stores the following information:

Field	Description
iterations	Total number of iterations
iterations_outer	Number of outer loop (Augmented Lagrangian) iterations
iterations_pn	Number of projected newton iterations
iteration	Vector of iteration number
iteration_outer	Vector of outer loop iteration number
cost	Vector of costs
dJ	Change in cost
c_max	Maximum constrained violation
gradient	Approximation of dual optimality residual (2-norm of gradient of the Lagrangian)
penalty_max	Maximum penalty parameter

The other fields are used interally by the solver and not important to the end user.

The vector fields of the SolverStats type can be converted to a dictionary via Dict(stats::SolverStats), which can then be cast into a tabular format such as DataFrame from DataFrames.jl.

Solver Options

Like any nonlinear programming solver, ALTRO comes with a host of solver options. While the default values yield good/acceptable performance on many problem, extra performance can always be gained by tuning these parameters. In practice, there are only a few parameters that need to be tuned. See the AL-iLQR Tutorial for more details.

The ALTRO solver is actually a composition of several different solvers with their own options. Early versions of Altro.jl required the user to manipulate a rather confusing heirarchy of solver options. Newer version of Altro.jl provide a single options struct that dramatically simplifies setting and working with the solver parameters.

Setting Solver Options

Solver options can be specified when the solver is instantiated or afterwards using the set_options! command. If we have a previously constructed Problem, this looks like

solver = ALTROSolver(prob, verbose=1, constraint_tolerance=1e-3, square_root=true)

Alternatively, solver options can be set using the set_options! command after the solver has been instantiated:

set_options!(solver, reset_duals=true, penalty_initial=100, penalty_scaling=50)

Querying Solver Options

The options struct for the ALTROSolver can be directly accessed via solver.opts or Altro.options(solver). Options can be directly set or retrieved from this mutable struct.

List of Options

For convenience, we provide a list of options in the ALTRO solver, along with a brief description:

Option	Description	Importance	Default
constraint_tolerance	All constraint violations must be below this value.	High	1e-6
cost_tolerance	The difference in costs between subsequent iterations must be below this value.	High	1e-4
cost_tolerance_intermediate	Cost tolerance for intermediate iLQR solves. Can speed up convergence by increase to 10-100x the cost_tolerance.	Med	1e-4
gradient_tolerance	Tolerance for 2-norm of primal optimality residual.	Low	1
gradient_tolerance_intermediate	Primal optimality residual tolerance for intermediate solve.	Low	10
iterations_inner	Max iLQR iterations per iLQR solve.	Med	300
dJ_counter_limit	Max number of times iLQR can fail to make progress before exiting.	Low	10
square_root	Enable the square root backward pass for improved numerical conditioning (WIP).	Med	false
line_search_lower_bound	Lower bound for Armijo line search.	Low	1e-8
line_search_upper_bound	Upper bound for Armijo line search.	Low	10.0
iterations_linesearch	Max number of backtracking steps in iLQR line search	Low	20
max_cost_value	Maximum cost value. Will terminate solve if cost exeeds this limit.	Low	1e8
max_state_value	Maximum value of any state. Will terminate solve if any state exeeds this limit.	Low	1e8
max_control_value	Maximum value of any control. Will terminate solve if any control exeeds this limit.	Low	1e8
static_bp	Enable the static backward pass. Only advisable for state + control dimensions < 20. Turn off if compile time is exessive.	Low	true
save_S	Save the intermediate cost-to-go expansions in the iLQR backward pass.	Low	false
bp_reg	Enable iLQR backward pass regularization (WIP).	Med	false
bp_reg_initial	Initial backward pass regularization.	Low	0.0
bp_reg_increase_factor	Multiplicative factor by which the regularization is increased.	Low	1.6
bp_reg_max	Maximum regularization.	Low	1e8
bp_reg_min	Minimum regularization.	Low	1e-8
bp_reg_fp	Amount of regularization added when foward pass fails	Low	10.0
penalty_initial	Initial penalty term on all constraints. Set low if the unconstrained solution is a good approximate solution to the constrained problem, and high if the initial guess provided is a good esimate. If NaN uses values in each constraint param, which defaults to 1.0.	Very High	NaN
penalty_scaling	Multiplicative factor by which the penalty is increased each outer loop iteration. High values can speed up convergence but quickly lead to poor numerical conditioning on difficult problems. Start with small values and then increase.If NaN defaults to 10 in the per-constraint parameter.	Very High	NaN
iterations_outer	Max number of outer loop (Augmented Lagrangian) iterations.	Med	30
verbose_pn	Turn on printing in the projected newton solver.	Low	false
n_steps	Maximum number of projected newton steps.	Low	2
projected_newton_tolerance	Constraint tolerance at which the solver will exit the Augmented Lagrangian solve and start the projected newton solve. Typically sqrt(constraint_tolerance)	High	1e-3
active_set_tolerance_pn	Tolerance for the active constraints during the projected newton solve. Includes some barely satisfied constraints into the active set. Can fix singularity issues during projected newton solve.	Med	1e-3
multiplier_projected	Enable updating the dual variables during the projected newton solve. Also provides a calculation of the optimality residual in the stats output.	Low	true
ρ_chol	Regularization on the projected newton Cholesky solve.	Med	1e-2
ρ_primal	Regularization on the primal variables during the projected newton solve. Required if cost Hessian is positive-semi-definite.	Low	1e-8
ρ_dual	Regularization on the dual variables during the multiplier projection step.	Low	1e-8
r_threshold	Improvement ratio threshold for projected newton solve. If the ratio of constraint violations between subsequent steps is less than this value, it will update the cost and constraint expansions	Low	1.1
projected_newton	Enable projected newton solve. If enabled, projected_newton_solve is used as the constraint_tolerance for the AL-iLQR solve. Projected newton solve is still a WIP and not very robust.	High	true
iterations	Max number of total iterations (iLQR + projected newton).	Med	1000
verbose	Controls output during solve. 0 is zero output, 1 outputs AL iterations, and 2 outputs both AL and iLQR iterations	Low	0