Eduardo M. G. Vila

Box-constrained optimization problems are ubiquitous in many areas of science and engineering. Our package includes methods tailored to this class of optimization problems. Due to Julia's `Iterator` interface, Progradio's solvers can be paused, resumed, or terminated early. Since the first release, we have included a stricter line-search procedure, and support for simplex constraints (Σ x_j = 1). Progradio's unique features make it attractive to be used as a sub-routine for dynamic optimization.

We implement methods for box-constrained optimization problems: `min_x f(x) s.t. l <= x <= u`. This class of problems is relevant in its own right, but frequently appears as a sub-routine of nonlinearly constrained optimization methods, such as penalty or barrier algorithms.

Progradio makes use of Julia's `Iterator` interface, allowing greater control at each iteration (pausing, resuming, user-defined termination criteria). This feature (which most solvers lack) truly allows the solvers to be used as sub-routines to other algorithms. The traditional `solve()` interface is also available.

Since `v0.1`, we have implemented a stricter line-search algorithm. In addition to the existing Armijo method, this Wolfe-like procedure uses left and right-derivative information for the step-size selection. A more accurate line-search results in a higher rate of convergence, at the expense of the added derivative evaluations.

Additionally, we have added support for problems with simplex constraints (Σ x_j = 1). This is achieved with a transformation of variables at each iteration. The added constraint is effectively handled by a modified line-search, while ensuring feasibility at every iteration.

Progradio's early-termination and feasibility capabilities are attractive for infinite-dimensional optimization, such as solving optimal control problems.

We give examples of how dynamic optimization packages in our JuDO-dev organization call Progradio's solvers as sub-routines.

32-123

What's new with Progradio.jl - Projected Gradient Optimization

Dynamic optimization problems include optimal control, state estimation, and system identification. Our newly developed integrated residual methods generalize the state-of-the-art direct collocation method. `Interesso.jl` implements a selection of Lagrange polynomial and Gauss quadrature node distributions. The iterative `Progradio.jl` optimizer allows for efficient mesh refinement. We include an example of optimizing the trajectory of a space-shuttle landing.

Optimal control, state estimation, and system identification are examples of dynamic optimization problems (DOPs). In general, these need to be discretized in time into finite-dimensional problems, suitable for optimization solvers.

Transcribing DOPs into (nonlinear) optimization problems can be done in various ways. The state-of-the-art are direct collocation methods, where the differential equations are enforced at each of the discretized time nodes and the number of collocation points do not exceed the degrees of freedom. Integrated residual methods (IRMs) are a generalization of collocation, where errors in the differential equation violations are penalized instead. This generalization robustifies the method against certain DOPs for which the collocation method fails.

We parameterize the continuous trajectories using Lagrange polynomials in the barycentric form. This representation allows for fast and numerically stable interpolations. The user can choose the degree of polynomials, as well as the node distribution (e.g. Chebyshev, Legendre) to be used.

A central part of IRMs is the integration of the dynamic constraints violation. The numerical integration is done using Gauss quadrature methods. The user can choose the degree of quadrature, as well as the distribution (e.g. Gauss-Legendre, Clenshaw-Curtis) to be used.

The transcribed optimization problem is solved with `Progradio.jl`, our projected gradient solver. Because the package implements Julia's `Iterator` interface, the optimization can be arbitrarily terminated by Interesso. This is a key feature which allows efficient mesh refinement.

The Julia language and community have been crucial in allowing programming abstractions. Parameterizing types with `AbstractFloat` optimizes the code to a user-specified floating point precision, and `AbstractDifferentiation.jl` allows us to easily support many AD engines, dependence-free.

We demonstrate our code with an example optimal control problem: optimizing the trajectory of a space-shuttle landing.

Eduardo M. G. Vila

Talks:

What's new with Progradio.jl - Projected Gradient Optimization

Interesso - Integrated Residual Solver for Dynamic Optimization

Platinum sponsors

Gold sponsors

Silver sponsors

Bronze sponsors

Academic partners

Local partners

Fiscal Sponsor