Namespace: nagcpp

Namespace: opt

Function: handle_solve_dfls_rcomm

NAG CPP Interface
nagcpp::opt::handle_solve_dfls_rcomm (e04fg)

Note: this function uses optional parameters to define choices in the problem specification and in the details of the algorithm. If you wish to use default settings for all of the optional parameters, you need only read Sections 1 to 10 of this document. If, however, you wish to reset some or all of the settings please refer to Section 11 for a detailed description of the algorithm and to Section 12 for a detailed description of the specification of the optional parameters.

Keyword Search:

NAG Library Manual, Mark 27

Interfaces: FL CL CPP AD

NAG CPP Interface Introduction

E04 (Opt) Chapter Contents

e04fg: FL CL CPP AD

Namespace: nagcpp

Namespace: opt

Function: handle_solve_dfls_rcomm

▸▿ Contents

1 Purpose

2 Specification

3 Description

4 References

5 Arguments

6 Exceptions and Warnings

7 Accuracy

8 Parallelism and Performance

▸▿ 9 Further Comments

9.1 Description of the Printed Output

10 Example

▸▿ 11 Algorithmic Details

11.1 Derivative-free Trust Region Algorithm

11.2 Bounds on the Variables

11.3 Adaptation to Nonlinear Least Squares Problems

11.4 Growing the Interpolation Set

11.5 Dealing with Noisy Problems

▸▿ 12 Optional Parameters

12.1 Description of the Optional Parameters

1 Purpose

handle_solve_dfls_rcomm is a reverse communication Derivative-free Optimization (DFO) solver from the NAG optimization modelling suite (DFLS) for small to medium-scale nonlinear least squares problems with bound constraints.

2 Specification

#include "e04/nagcpp_e04fg.hpp"
#include "e04/nagcpp_class_CommE04RA.hpp"

template <typename COMM, typename X, typename RX, typename RINFO, typename STATS>

void function handle_solve_dfls_rcomm(COMM &comm, types::f77_integer &irevcm, types::f77_integer &neval, X &&x, RX &&rx, RINFO &&rinfo, STATS &&stats, OptionalE04FG opt)

template <typename COMM, typename X, typename RX, typename RINFO, typename STATS>

void function handle_solve_dfls_rcomm(COMM &comm, types::f77_integer &irevcm, types::f77_integer &neval, X &&x, RX &&rx, RINFO &&rinfo, STATS &&stats)

3 Description

handle_solve_dfls_rcomm uses reverse communication for function evaluations and monitoring steps. Every time the solver requires an evaluation of the objective function, it pauses its progress, exits and waits for the function to be called again with the objective value provided in the argument rx.

handle_solve_dfls_rcomm is aimed at minimizing a sum of squares objective function subject to bound constraints:

\begin{array}{l} \underset{x \in ℝ^{n}}{minimize} & \sum_{i = 1}^{m_{r}} {r_{i} (x)}^{2} \\ subject to & l_{x} \leq x \leq u_{x} . \end{array}

Here the

r_{i} (x)

are smooth nonlinear functions called residuals and

l_{x}

and

u_{x}

are

n

-dimensional vectors defining bounds on the variables. Typically, in a calibration or data fitting context, the residuals will be defined as the difference between the data points and a nonlinear model (see Section 2.2.3 in the E04 Chapter Introduction).

handle_solve_dfls_rcomm serves as a solver for compatible problems stored as a handle. The handle points to an internal data structure which defines the problem and serves as a means of communication for functions in the NAG optimization modelling suite. To define a compatible problem handle, you must call handle_init followed by handle_set_nlnls to initialize it and optionally call handle_set_simplebounds to define bounds on the variables. If handle_set_simplebounds is not called, all the variables will be considered free by the solver. It should be noted that handle_solve_dfls_rcomm always assumes that the Jacobian of the residuals is dense, therefore defining a sparse structure for the residuals in the call to handle_set_nlnls will have no effect. See Section 3.1 in the E04 Chapter Introduction for more details about the NAG optimization modelling suite.

The solver allows fixing variables with the definition of the bounds. However, the following constraint must be met in order to be able to call the solver:

for all non-fixed variable $x_{i}$ , the value of $u_{x} (i) - l_{x} (i)$ must be at least twice the starting trust region radius (see the consistency constraint of the optional parameter DFO Starting Trust Region).

The solver is based on a derivative-free trust region framework. This type of method is well suited for small to medium-scale problems (around 100 variables) for which the derivatives are unavailable or not easy to compute, and/or for which the function evaluations are expensive or noisy. For a detailed description of the algorithm see Section 11.

The algorithm behaviour and solver strategy can be modified by various optional parameters (see Section 12) which can be set by handle_opt_set and e04zpf (no CPP interface) at any time between the initialization of the handle by handle_init and a call to the solver. The optional parameters' names specific for this solver start either with the prefix DFO (Derivative-free Optimization) or DFLS (Derivative-free Least Squares). The default values for these optional parameters are chosen to work well in the general case, but it is recommended you tune them to your particular problem. In particular, if the objective function is known to be noisy, it is highly recommended to set the optional parameter DFO Noisy Problem to

YES

. Once the solver has finished, options may be modified for the next solve. The solver may be called repeatedly with various starting points and/or optional parameters.

The underlying algorithm implemented for handle_solve_dfls_rcomm is the same as the one used by e04fff (no CPP interface). handle_solve_dfls_rcomm serves as a reverse communication interface to the derivative-free solver for nonlinear least squares problems.

4 References

Cartis C, Fiala J, Marteau B and Roberts L (2018) Improving the Flexibility and Robustness of Model-Based Derivative-Free Optimization Solvers Technical Report University of Oxford

Cartis C and Roberts L (2017) A Derivative-Free Gauss-Newton Method

Conn A R, Scheinberg K and Vicente L N (2009) Introduction to Derivative-Free Optimization, vol. 8 of MPS-SIAM Series on Optimization MPS/SIAM, Philadelphia

Powell M J D (2009) The BOBYQA algorithm for bound constrained optimization without derivatives Report DAMTP 2009/NA06 University of Cambridge https://www.damtp.cam.ac.uk/user/na/NA_papers/NA2009_06.pdf

Zhang H, Conn A R and Scheinberg K (2010) A Derivative-Free Algorithm for Least-Squares Minimization SIAM J. Optim. 20(6) 3555–3576

5 Arguments

Note: this function uses reverse communication. Its use involves an initial entry, intermediate exits and re-entries, and a final exit, as indicated by the argument irevcm. Between intermediate exits and re-entries, all arguments other than those specified by the value of irevcm must remain unchanged.

1: $comm$ – CommE04RA Input/Output

Communication structure. An object of either the derived class CommE04RA or its base class NoneCopyableComm can be supplied. It is recommended that the derived class is used. If the base class is supplied it must first be initialized via a call to opt::handle_init (e04ra).

2: $irevcm$ – types::f77_integer Input/Output

On entry: does not need to be set on the first call of handle_solve_dfls_rcomm. On subsequent calls, irevcm must be set to a positive integer if all the required function evaluations have been correctly provided in rx. Otherwise, if a problem occurred during a monitoring step or while providing objective values, it is possible to set it to a negative value:

$irevcm = - 1$: If function evaluations were required, the solver will attempt a rescue procedure and request an alternative point. If no function were required (monitoring step), the solver will stop with $errorid = 20$ .
$irevcm \leq - 2$: The solver will cleanly exit and return the best available point as a well as the solve statistics.

On exit: indicates what action is to be performed before the next call to handle_solve_dfls_rcomm.

$irevcm = 0$: Final exit of the solver.
$irevcm = 1$: neval objective evaluations are required.
$irevcm = 2$: Monitoring step, no evaluation is required, x and rx contain the best evaluation of the objective yet.

3: $neval$ – types::f77_integer Output

On exit: indicates the number of objective evaluations required for the next call of handle_solve_dfls_rcomm in rx. The coordinates of the points to evaluate are provided in the first neval columns of x.

4: $x (nvar, maxeval)$ – double array Input/Output

On entry: the first column contains

x_{0}

, the initial estimates of the variables

x

On exit: if

irevcm = 0

2

, the first column contains the best computed estimate of the solution.

irevcm = 1

, the first neval columns contain the coordinates of the points to evaluate.

5: $rx (nres, maxeval)$ – double array Input/Output

On entry: does not need to be set on the first call to handle_solve_dfls_rcomm.

irevcm = 1

after the last call of handle_solve_dfls_rcomm, the first neval columns must contain the residuals of the requested points.

On exit: if

irevcm = 0

2

, the first column contains the residuals of the best computed point.

6: $rinfo (100)$ – double array Output

On exit: optimal objective value and various indicators at monitoring steps or at the end of the final iteration. The measures are given in the table below:

$0$	Objective function value $f (x)$ (sum of the squared residuals).
$1$	$ρ$ , the current lower bound of the trust region.
$2$	$Δ$ , the current size of the trust region.
$3$	The number of interpolation points used by the solver.
$4 - 99$	Reserved for future use.

7: $stats (100)$ – double array Output

On exit: solver statistics at monitoring steps or at the end of the final iteration as given in the table below:

$0$	Number of calls to the objective function.
$1$	Total time spent in the solver (including time spent evaluating the objective).
$2$	Total time spent evaluating the objective function.
$3$	Number of steps.
$4 - 99$	Reserved for future use.

8: $opt$ – OptionalE04FG Input/Output

Optional parameter container, derived from Optional.

5.1Additional Quantities

1: $maxeval$: The maximum number of function evaluations that can be requested at the same time.
2: $nvar$: $n$ , the number of variables in the problem.
3: $nres$: $m_{r}$ , the number of residuals in the problem.

6 Exceptions and Warnings

Errors or warnings detected by the function:

Note: in some cases handle_solve_dfls_rcomm may return useful information.

All errors and warnings have an associated numeric error code field, errorid, stored either as a member of the thrown exception object (see errorid), or as a member of opt.ifail, depending on how errors and warnings are being handled (see Error Handling for more details).

Raises: ErrorException

$errorid = 1$: comm::handle has not been initialized.

$errorid = 1$: comm::handle does not belong to the NAG optimization modelling suite,
has not been initialized properly or is corrupted.

$errorid = 1$: comm::handle has not been initialized properly or is corrupted.

$errorid = 2$: This solver does not support the model defined in the handle.

$errorid = 2$: The problem is already being solved.

$errorid = 4$: On entry, $maxeval = ⟨ value ⟩$ .
Constraint: $maxeval > 0$ .

$errorid = 4$: The information supplied does not match with that previously stored.
On entry, $nvar = ⟨ value ⟩$ must match that
given during initialization of the comm::handle, i.e., $⟨ value ⟩$ .

$errorid = 4$: The information supplied does not match with that previously stored.
On entry, $nres = ⟨ value ⟩$ must match that
given during the definition of the objective in the comm::handle,
i.e., $⟨ value ⟩$ .

$errorid = 4$: The information supplied does not match with that previously stored.
On entry, $maxeval = ⟨ value ⟩$ must match that
given during the first call of the function, i.e., $⟨ value ⟩$ .

$errorid = 5$: Inconsistent options ‘DFO Trust Region Tolerance’ $ρ_{end}$
and ‘DFO Starting Trust Region’ $ρ_{beg}$ .
Constraint: $ρ_{end} < ρ_{beg}$ .
Use function to set compatible option values.

$errorid = 5$: Inconsistent options ‘DFO Trust Region Tolerance’ $ρ_{end}$
and ‘DFO Trust Region Slow Tol’ $ρ_{tol}$ .
Constraint: $ρ_{end} < ρ_{tol}$ .
Use function to set compatible option values.

$errorid = 5$: Option ‘DFO Starting Trust Region’
$ρ_{beg} = ⟨ value ⟩$ ,
$l_{x} (i) = ⟨ value ⟩$ ,
$u_{x} (i) = ⟨ value ⟩$ and $i = ⟨ value ⟩$ .
Constraint: if $l_{x} (i) \neq u_{x} (i)$ in coordinate $i$ ,
then $u_{x} (i) - l_{x} (i) \geq 2 \times ρ_{beg}$ .
Use function to set compatible option values.

$errorid = 6$: There were $n_{r} = ⟨ value ⟩$ unequal bounds and
the option
‘DFO Number Interp Points’ $npt = ⟨ value ⟩$ .
Constraint: $n_{r} + 1 \leq npt \leq \frac{(n_{r} + 1) \times (n_{r} + 2)}{2}$ .
Use function to set compatible option values.

$errorid = 6$: The number of initial interpolation points is greater than the maximum.
Use ‘DFO Number Interp Points’ and ‘DFO Number Initial Points’
to control the number of interpolation points.

$errorid = 6$: Initial number of interpolation points $ninit = ⟨ value ⟩$ ,
total number of interpolation points $npts = ⟨ value ⟩$ ,
number of variables $nvar = ⟨ value ⟩$ .
Constraint: growing interpolation set is only supported for linear models
( $npts = nvar + 1$ ).
Use ‘DFO Number Interp Points’ and ‘DFO Number Initial Points’
to control the number of interpolation points.

$errorid = 8$: $nres = 0$ . There are no residuals, the objective function is empty.

$errorid = 8$: Maximization is not possible for a nonlinear least squares problem.

$errorid = 10601$: On entry, argument $⟨ value ⟩$ must be a vector of size $⟨ value ⟩$ array.
Supplied argument has $⟨ value ⟩$ dimensions.

$errorid = 10601$: On entry, argument $⟨ value ⟩$ must be a vector of size $⟨ value ⟩$ array.
Supplied argument was a vector of size $⟨ value ⟩$ .

$errorid = 10601$: On entry, argument $⟨ value ⟩$ must be a vector of size $⟨ value ⟩$ array.
The size for the supplied array could not be ascertained.

$errorid = 10601$: On entry, argument $⟨ value ⟩$ must be a $⟨ value ⟩$ x $⟨ value ⟩$ array.
Supplied argument has $⟨ value ⟩$ dimensions.

$errorid = 10601$: On entry, argument $⟨ value ⟩$ must be a $⟨ value ⟩$ x $⟨ value ⟩$ array.
Supplied argument was a $⟨ value ⟩$ x $⟨ value ⟩$ array.

$errorid = 10601$: On entry, argument $⟨ value ⟩$ must be a $⟨ value ⟩$ x $⟨ value ⟩$ array.
Not all of the sizes for the supplied array could be ascertained.

$errorid = 10602$: On entry, the raw data component of $⟨ value ⟩$ is null.

$errorid = 10603$: On entry, unable to ascertain a value for $⟨ value ⟩$ .

$errorid = 10604$: On entry, the data in $⟨ value ⟩$ is stored in $⟨ value ⟩$ Major Order.
The data was expected to be in $⟨ value ⟩$ Major Order.

$errorid = 10605$: On entry, the communication class $⟨ value ⟩$ has not been initialized correctly.

$errorid = 10703$: An exception was thrown during IO (writing).

$errorid = - 99$: An unexpected error has been triggered by this routine.

$errorid = - 399$: Your licence key may have expired or may not have been installed correctly.

$errorid = - 999$: Dynamic memory allocation failed.

Raises: WarningException

$errorid = 17$: Rescue failed: the trust region could not be reduced further after
some function evaluation could not be provided.
Check the specification of your objective and whether it needs rescaling.
Try a different initial x.

$errorid = 17$: Some initial interpolation points were not provided.
Rescue cannot be attempted at this stage.
Check the specification of your objective and whether it needs rescaling.
Try a different initial x.

$errorid = 18$: The predicted reduction in a trust region step was non-positive.
Check the specification of your objective and whether it needs rescaling.
Try a different initial x.

$errorid = 21$: Maximum number of function evaluations exceeded.

$errorid = 23$: The solver terminated after the maximum time allowed was exceeded.

$errorid = 24$: No progress, the solver was stopped after $⟨ value ⟩$
consecutive slow steps.
Use the option ‘DFO Maximum Slow Steps’ to modify the
maximum number of slow steps accepted.

$errorid = 50$: The problem was solved to an acceptable level after
$⟨ value ⟩$ consecutive slow iterations.
Use the option ‘DFO Maximum Slow Steps’ to modify the
maximum number of slow steps accepted.

Raises: CallbackEarlyTermination

$errorid = 20$: User requested termination during a monitoring step.

$errorid = 20$: User requested termination during an objective evaluation step.

7 Accuracy

In a non-noisy case, the solver can declare convergence on two conditions.

(i)The trust region radius is below the tolerance $ρ_{end}$ set by the optional parameter DFO Trust Region Tolerance. When this condition is met, the corresponding solution will generally be at a distance smaller than $10 \times ρ_{end}$ of a local minimum.
(ii)The sum of the square of the residuals is below the tolerance set by the optional parameter DFLS Small Residuals Tol. In a data fitting context, this condition means that the error between the observed data and the model is smaller than the requested tolerance.

If the objective is declared as noisy by the optional parameter DFO Noisy Problem, the solver declares convergence more conservatively. Instead of stopping with the first condition, the solver will trigger soft restarts (see Section 11 for more details) to ensure it did not get stuck in a flat region because of the noise. The solver then declares convergence when it is reasonably sure that it has reached a local minimum.

(i)The total number of restarts is greater than the limit set by optional parameter DFO Max Soft Restarts and the trust region radius is below the tolerance.
(ii)The number of consecutive restarts that did not manage to decrease the objective function is greater than the limit set by the optional parameter DFO Max Unsucc Soft Restarts.

In addition, this solver can stop if the convergence is deemed too slow on two conditions.

(i)The trust region lower bound is lower than the value set by the optional parameter DFO Trust Region Slow Tol and the number of consecutive slow steps is greater than the value set by DFO Maximum Slow Steps.
(ii)The trust region lower bound is greater than the value set by the optional parameter DFO Trust Region Slow Tol and the number of consecutive slow steps is greater than five times the value set by DFO Maximum Slow Steps.

The slow convergence detection can be deactivated by setting DFO Maximum Slow Steps to

0

8 Parallelism and Performance

Please see the description for the underlying computational routine in this section of the FL Interface documentation.

9 Further Comments

9.1 Description of the Printed Output

The solver can print information to give an overview of the problem and the progress of the computation. The output may be sent to two independent unit numbers which are set by optional parameters Print File and Monitoring File. Optional parameters Print Level, Print Options, Monitoring Level and Print Solution determine the exposed level of detail. This allows, for example, a detailed log file to be generated while the condensed information is displayed on the screen.

By default (

Print File = 6

Print Level = 2

), four sections are printed to the standard output: a header, a list of options, an iteration log and a summary.

Header

The header contains statistics about the problem. It should look like:

---------------------------------------------------
E04F(G|F)), Derivative-free solver for data fitting
            (nonlinear least squares problems)
---------------------------------------------------

Problem statistics
  Number of variables                 10
  Number of unconstrained variables   10
  Number of fixed variables            0
  Starting interpolation points       11
  Total interpolation points          11
  Number of residuals                 10

Optional parameters list

Print Options = YES

, a list of the optional parameters and their values is printed. The list shows all options of the solver, each displayed on one line. The line contains the option name, its current value and an indicator for how it was set. The options left at their defaults are noted by ‘d’ and the ones you set are noted by ‘U’. Note that the output format is compatible with the file format expected by e04zpf (no CPP interface). The output looks as follows:

Stats Time                    =                 Yes     * U
Dfo Trust Region Tolerance    =         1.00000E-07     * U
Dfo Max Objective Calls       =                 500     * d
Dfo Starting Trust Region     =         1.10000E-01     * U
Dfo Number Interp Points      =                   0     * d

Iteration log

Print Level \geq 2

, the solver will print a summary line for each step. An iteration is considered successful when it yields a decrease of the objective sufficiently close to the decrease predicted by the quadratic model. Each line shows the step number (step), the value of the objective function (obj), the lower bound on the radius of the trust region (rho), and the cumulative number of objective function evaluations (nf). The output looks as follows:

----------------------------------------
 step |    obj        rho    |    nf   |
----------------------------------------
    1 |  3.87E+01  1.00E-01  |    12   |
    2 |  3.39E+01  1.00E-01  |    13   |
    3 |  1.78E+01  1.00E-01  |    14   |
    4 |  3.95E-29  1.00E-01  |    15   |

Occasionally, the letter ‘s’ is printed at the end of the line indicating that the progress is considered slow by the slow convergence detection heuristic. After a certain number of consecutive slow steps, the solver is stopped. The limit on the number of slow iterations can be controlled by the optional parameter DFO Maximum Slow Steps and the tolerance on the trust region radius before the solver can be stopped is driven by DFO Trust Region Slow Tol.

Print Level \geq 3

, each line additionally shows the current value of the trust region radius (delta) as well as the step length (||d||) taken. It might look as follows:

------------------------------------------------------------
 step |    obj        rho      delta     ||d||   |    nf   |
------------------------------------------------------------
    1 |  4.02E+00  1.00E-01  4.00E-01  1.00E-01  |     4   |
    2 |  3.66E+00  1.00E-01  4.00E-01  4.00E-01  |     5   |
    3 |  3.48E+00  1.00E-01  4.00E-01  4.00E-01  |     6   |
    4 |  2.32E+00  1.00E-01  4.00E-01  1.00E-01  |     9   |

Summary

Once the solver finishes, a summary is produced:

Status: Converged, small residuals

Value of the objective                    3.95417E-29
Number of objective function evaluations           15
Number of steps                                     4

Note that only the iterations that decrease the objective function are printed in the iteration log, meaning that objective evaluations are likely to happen between the last printed iteration and the convergence. This leads to a small difference between the last line of the iteration log and the final summary in terms of the number of function evaluations.

Optionally, if

Stats Time = YES

, the timings are printed:

Timings
      Total time spent in the solver            0.056
      Time spent in the objective evaluation    0.012

Additionally, if

Print Solution = YES

, the solution is printed along with the bounds:

Computed Solution:
  idx   Lower bound        Value      Upper bound
    1       -inf       -1.00000E+00        inf
    2       -inf       -1.00000E+00        inf
    3       -inf       -1.00000E+00        inf
    4       -inf       -1.00000E+00        inf

10 Example

In this example, we minimize the two-dimension Rosenbrock function under some bound constraints. In this problem, the number of variables

n = 2

and the number of residuals

m_{r} = 2

\begin{matrix} r_{1} (x) & = & 1.0 - x_{1} \\ r_{2} (x) & = & 10.0 * (x_{2} - {x_{1}}^{2}) . \end{matrix}

The following bounds are defined on the variables

\begin{matrix} - 1.5989 & \leq & x_{1} & \leq & 2.0 \\ - 2.0 & \leq & x_{2} . \end{matrix}

The initial guess is

x_{0} = (- 1.2, 1.0) .

The expected solution is

x^{*} = (1.0, 1.0) .

Source File	Data	Results
ex_e04fg_boost.cpp	None	ex_e04fg_boost.r

11 Algorithmic Details

This section contains a short description of the algorithm used in handle_solve_dfls_rcomm which is based on the collaborative work between NAG and the University of Oxford (Cartis and Roberts (2017) and Cartis et al. (2018)). It uses a model-based derivative-free trust region framework adapted to exploit least squares problems structure.

11.1 Derivative-free Trust Region Algorithm

In this section, we are interested in generic problems of the form

\begin{matrix} \underset{x \in ℝ^{n}}{minimize} & f (x) \end{matrix}

where the derivatives of the objective function

f

are not easily available. A model-based DFO algorithm maintains a set of points

Y_{k}

centred on an iterate

x_{k}

to build quadratic interpolation models of the objective

f (x_{k} + s) \approx ϕ_{k} (s) = f (x_{k}) + g_{k}^{T} s + \frac{1}{2} s^{T} H_{k} s,

where

g_{k}

and

H_{k}

are built with the interpolation conditions

\forall y \in Y_{k}, ​ ϕ_{k} (y - x_{k}) = f (y) .

(1)

Note that if the number of interpolation points

npt

is smaller than

\frac{(n_{r} + 1) \times (n_{r} + 2)}{2}

, the model chosen is the one for which the Hessian

H_{k}

is the closest to

H_{k - 1}

in the Frobenius norm sense. This model is iteratively optimized over a trust region, updated and moved around the new computed points. More precisely, it can be described as:

DFO Algorithm
1. 1.Initialization
  Choose an initial interpolation set $Y_{0}$ , trust region radius $ρ_{beg}$ and build the first quadratic model $ϕ_{0}$ .
2. 2.Iteration k
  1. (i)Minimize the model in the trust region to obtain a step $s_{k}$ .
  2. (ii)If the step is too small, adjust the geometry of the interpolation set and the trust region size $ρ_{k}$ and restart the iteration.
  3. (iii)Evaluate the objective at the new point $x_{k} + s_{k}$ .
  4. (iv)Replace a far away point from $Y_{k}$ by $x_{k} + s_{k}$ to obtain $Y_{k + 1}$ .
  5. (v)If the decrease of the objective is sufficient (successful step), choose $x_{k + 1} = x_{k} + s_{k}$ , else choose $x_{k + 1} = x_{k}$ .
  6. (vi)Choose $ρ_{k + 1}$ and adjust the geometry of $Y_{k + 1}$ , if necessary.
  7. (vii)Build $ϕ_{k + 1}$ using the new interpolation set.
  8. (viii)Stop the algorithm if $ρ_{k + 1}$ is below the chosen tolerance $ρ_{end}$ .

In the following sections, we call an iteration ‘successful’ when the trial point

x_{k} + s_{k}

is accepted as the next iterate.

11.2 Bounds on the Variables

The bounds on the variables are handled during the model optimization step (step 2(i) of DFO Algorithm) with an active set method. If a bound is hit, it is fixed and step 2(i) is restarted.

11.3 Adaptation to Nonlinear Least Squares Problems

In the specific case where

f

is a sum of square

f (x) = \sum_{i = 1}^{m_{r}} {r_{i} (x)}^{2}

, a good approximation of the Hessian of the objective can be

\nabla^{2} f (x) \approx {J (x)}^{T} J (x),

where

J

is the

m_{r}

n

first derivative matrix of

f

. This approximation is the main idea behind the Gauss–Newton and Levenberg–Marquardt methods. Following the work of Zhang et al. (2010), it is possible to adapt it to the DFO framework. In handle_solve_dfls_rcomm, one linear model is built for each residual

r_{i}

r_{i} (x + s) \approx r_{i} (x) + {g^{(i)}}^{T} s .

Let

J = {(g^{(1)}, g^{(2)}, \dots)}^{T}

. To build the model of the objective

f

, we then choose

f (x + s) \approx ϕ (s) = f (x) + g_{f}^{T} s + \frac{1}{2} s^{T} H_{f} s,

where

g_{f}

is chosen as

g_{f} = J^{T} f (x),

and

H_{f}

H_{f} = J^{T} J + {\begin{cases} 0 & if & ‖ g_{f} ‖ \geq κ_{1} \\ κ_{3} ‖ f (x) ‖ I & if & ‖ g_{f} ‖ < κ_{1} and \frac{1}{2} f (x) < κ_{2} ‖ g_{f} ‖ . \end{cases}

The first expression amounts to making a Gauss–Newton approximation when we are far from a stationary point and the second to a Levenberg–Marquardt approximation when we are close to a stationary point with small residuals.

handle_solve_dfls_rcomm integrates this method of building models into the framework presented in the DFO Algorithm.

11.4 Growing the Interpolation Set

In the case where the function is very expensive, it might be desirable for the solver to make some progress before the

n_{r} + 1

evaluations necessary to build the first interpolation model are done. To get that behaviour, you can set the optional parameter DFO Number Initial Points, controlling the number of initial interpolation points, to a value that is lower than

n_{r} + 1

. The solver will then start its iteration earlier while adding random perturbations to the interpolation models to ensure that the full space is explored.

It is to be noted that this mode will typically not lead to a faster convergence to the solution and should only be used if early progress is desirable.

11.5 Dealing with Noisy Problems

If the problem solved is known to be noisy, declaring it as such to the solver with the optional parameter DFO Noisy Problem will modify the behaviour of the solver to take into account the uncertainty of the function evaluations. The two main features implemented to handle noisy objective functions are:

(i)slow update of the trust regions;
(ii)soft restarts of the algorithm can be performed instead of declaring convergence to ensure the solver did not get stuck in a flat region due to the noise.

A soft restart consists of a reset of the trust region's values to the starting ones and a few objective evaluations to improve the geometry of the interpolation set in the new trust region. It is possible to control the number of objective evaluations performed during a soft restart with the optional parameter DFO Number Soft Restarts Pts. After a set maximum number of restarts (DFO Max Soft Restarts) or maximum number of unsuccessful restarts (DFO Max Unsucc Soft Restarts), the solver will declare convergence in the usual way.

12 Optional Parameters

Several optional parameters in handle_solve_dfls_rcomm define choices in the problem specification or the algorithm logic. In order to reduce the number of formal arguments of handle_solve_dfls_rcomm these optional parameters have associated default values that are appropriate for most problems. Therefore, you need only specify those optional parameters whose values are to be different from their default values.

The remainder of this section can be skipped if you wish to use the default values for all optional parameters.

The optional parameters can be changed by calling handle_opt_set anytime between the initialization of the handle and the call to the solver. Modification of the optional parameters during intermediate monitoring stops is not allowed. Once the solver finishes, the optional parameters can be altered again for the next solve.

The option values may be retrieved by handle_opt_get.

The following is a list of the optional parameters available. A full description of each optional parameter is provided in Section 12.1.

12.1 Description of the Optional Parameters

For each option, we give a summary line, a description of the optional parameter and details of constraints.

The summary line contains:

the keywords, where the minimum abbreviation of each keyword is underlined;
a parameter value, where the letters $a$ , $i$ and $r$ denote options that take character, integer and real values respectively;
the default value, where the symbol $ε$ is a generic notation for machine precision (see precision).

All options accept the value

DEFAULT

to return single options to their default states.

Keywords and character values are case and white space insensitive.

Defaults

This special keyword may be used to reset all optional parameters to their default values. Any value given with this keyword will be ignored.

DFLS Small Residuals Tol

r

Default

= ε^{0.75}

This option defines the tolerance on the value of the residuals. Namely, the solver declares convergence if

f (x) = \sum_{i = 1}^{m_{r}} {r_{i} (x)}^{2} < DFLS Small Residuals Tol .

Constraint:

DFLS Small Residuals Tol > ε^{2}

DFO Initial Interp Points

a

Default

= Coordinate

Determines how the initial interpolation points are chosen. If

DFO Initial Interp Points = Coordinate

, the interpolation points are chosen along the coordinate directions around the initial point. If

DFO Initial Interp Points = Random

, the initial interpolation points are chosen along random orthogonal directions around the initial point. Set DFO Random Seed to a positive value to fix the random seed and get reproducible results.

Constraint:

DFO Initial Interp Points = Coordinate

Random

DFO Maximum Slow Steps

i

Default

= 20

DFO Maximum Slow Steps > 0

, this parameter defines the maximum number of consecutive slow iterations

n_{slow}

allowed. Set

DFO Maximum Slow Steps = 0

to deactivate the slow iteration detection. The algorithm can stop in two situations:

(i) $n_{slow} > DFO Maximum Slow Steps$ and $ρ < DFO Trust Region Slow Tol$ with $errorid = 50$ ,
(ii) $n_{slow} > 5 \times DFO Maximum Slow Steps$ with $errorid = 24$ .

Constraint:

DFO Maximum Slow Steps \geq 0

DFO Max Objective Calls

i

Default

= 500

A limit on the number of objective function evaluations the solver is allowed to compute. If the limit is reached, the solver stops with

errorid = 21

Constraint:

DFO Max Objective Calls \geq 1

DFO Max Soft Restarts

i

Default

= 5

The maximum total number of soft restarts that can be performed if the objective function is declared as noisy (

DFO Noisy Problem = YES

Constraint:

DFO Max Soft Restarts \geq 1

DFO Max Unsucc Soft Restarts

i

Default

= 3

The maximum number of consecutive unsuccessful soft restarts that can be performed if the objective function is declared as noisy (

DFO Noisy Problem = YES

Constraint:

DFO Max Unsucc Soft Restarts \geq 1

DFO Monitor Frequency

i

Default

= 0

DFO Monitor Frequency > 0

, the solver will stop at the end of every

i

th step for monitoring purposes. handle_solve_dfls_rcomm needs to be called again to continue the optimization.

Constraint:

DFO Monitor Frequency \geq 0

DFO Noise Level

r

Default

= 0.0

Indicates the noise level expected when evaluating the objective function. If

DFO Noisy Problem = YES

Constraint:

DFO Noise Level \geq 0.0

DFO Noisy Problem

a

Default

= NO

Indicates if the function evaluations provided to the solver are noisy. If

DFO Noisy Problem = YES

, some algorithmic features will be activated:

(i)The trust region update becomes slower to reflect the decreased confidence in the objective values.
(ii)Soft restarts of the algorithm can be performed to ensure the algorithm did not get stuck because of the noise (see DFO Max Soft Restarts, DFO Max Unsucc Soft Restarts and DFO Number Soft Restarts Pts to control the restart characteristics).
(iii)In addition, if $DFO Noise Level > 0.0$ , the solver will trigger a soft restart if all the function values are within the noise level.

DFO Number Initial Points

i

Default

= 0

The initial number of interpolation points in

Y_{0}

(1) used to build the linear models of the residuals. If

DFO Number Initial Points = 0

, the number of points is chosen to be equal to the total number of interpolation points set by DFO Number Interp Points.

If this parameter is chosen to be lower than the maximum set by DFO Number Interp Points, the solver will progressively increase the number of interpolation points until it reaches that value. In this release, it is only possible to grow the interpolation set if DFO Number Interp Points is set to the default value.

Constraint:

DFO Number Initial Points \geq 0

Consistency constraints, the solver stops with

errorid = 6

if not met:

$0 \leq DFO Number Initial Points \leq DFO Number Interp Points$ .
If $DFO Number Initial Points < DFO Number Interp Points$ , DFO Number Interp Points must be set to the default value.

DFO Number Interp Points

i

Default

= 0

The maximum number of interpolation points in

Y_{k}

(1) used to build the linear models of the residuals. If

DFO Number Interp Points = 0

, the number of points is chosen to be

n_{r} + 1

where

n_{r}

is the number of non-fixed variables.

Constraint:

DFO Number Interp Points \geq 0

Consistency constraint, the solver stops with

errorid = 6

if not met:

$n_{r} + 1 \leq DFO Number Interp Points \leq \frac{(n_{r} + 1) \times (n_{r} + 2)}{2}$ .

DFO Number Soft Restarts Pts

i

Default

= 3

The number of interpolation points that are replaced during a soft restart.

Constraint:

DFO Number Soft Restarts Pts \geq 1

DFO Print Frequency

i

Default

= 1

DFO Print Frequency > 0

, the solver prints the iteration log to the appropriate units at the end of every

i

th step.

Constraint:

DFO Print Frequency \geq 0

DFO Random Seed

i

Default

= - 1

The random seed used to generate the random points used to build the initial model or build the underdetermined models when the interpolation set has not fully grown (

DFO Number Initial Points < DFO Number Interp Points

). If

DFO Random Seed < 0

, the random seed will be based on values taken from the real-time clock, potentially resulting in the solver taking a different path each time it is run. Set it to a positive value to get fully reproducible runs.

Constraint:

DFO Print Frequency \geq - 1

DFO Starting Trust Region

r

Default

= 0.1

ρ_{beg}

, the initial trust region radius. This parameter should be set to about one tenth of the greatest expected overall change to a variable: the initial quadratic model will be constructed by taking steps from the initial

x

of length

ρ_{beg}

along each coordinate direction. The default value assumes that the variables have an order of magnitude

1

Constraint:

DFO Starting Trust Region > ε

Consistency constraints, the solver stops with

errorid = 5

if not met:

$DFO Starting Trust Region \leq DFO Trust Region Tolerance$ .
$DFO Starting Trust Region \leq \frac{1}{2} \min_{i} (u_{x} (i) - l_{x} (i))$ .

DFO Trust Region Slow Tol

r

Default

= ε^{0.25}

The minimal acceptable trust region radius for the solution to be declared as acceptable. The solver stops if:

$n_{slow} > DFO Maximum Slow Steps$ and $ρ_{k} < DFO Trust Region Slow Tol$ .

Constraint:

DFO Trust Region Slow Tol > ε

Consistency constraint, the solver stops with

errorid = 5

if not met:

$DFO Trust Region Slow Tol > DFO Trust Region Tolerance$ .

DFO Trust Region Tolerance

r

Default

= ε^{0.37}

ρ_{end}

, the requested trust region radius. The algorithm declares convergence when the trust region radius reaches this limit. It should indicate the absolute accuracy that is required in the final values of the variables.

Constraint:

DFO Trust Region Tolerance > ε

Consistency constraints, the solver stops with

errorid = 5

if not met:

$DFO Starting Trust Region > DFO Trust Region Tolerance$ .
$DFO Trust Region Slow Tol > DFO Trust Region Tolerance$ .

Infinite Bound Size

r

Default

= 10^{20}

This defines the ‘infinite’ bound

bigbnd

in the definition of the problem constraints. Any upper bound greater than or equal to

bigbnd

will be regarded as

+ \infty

(and similarly any lower bound less than or equal to

- bigbnd

will be regarded as

- \infty

). Note that a modification of this optional parameter does not influence constraints which have already been defined; only the constraints formulated after the change will be affected.

Constraint:

Infinite Bound Size \geq 1000

Monitoring File

i

Default

= - 1

i \geq 0

, the unit number for the secondary (monitoring) output. If

Monitoring File = - 1

, no secondary output is provided. The information output to this unit is controlled by Monitoring Level.

Constraint:

Monitoring File \geq - 1

Monitoring Level

i

Default

= 4

This parameter sets the amount of information detail that will be printed by the solver to the secondary output. The meaning of the levels is the same as with Print Level.

Constraint:

0 \leq Monitoring Level \leq 5

Print File

i

Default

= advisory message unit number

i \geq 0

, the unit number for the primary output of the solver. If

Print File = - 1

, the primary output is completely turned off independently of other settings. The default value is the advisory message unit number as defined by x04abf (no CPP interface) at the time of the optional parameters initialization, e.g., at the initialization of the handle. The information output to this unit is controlled by Print Level.

Constraint:

Print File \geq - 1

Print Level

i

Default

= 2

This parameter defines how detailed information should be printed by the solver to the primary and secondary output.

$i$	Output
$0$	No output from the solver.
$1$	The Header and Summary.
$2$ , $3$ , $4$ , $5$	Additionally, the Iteration log.

Constraint:

0 \leq Print Level \leq 5

Print Options

a

Default

= YES

Print Options = YES

, a listing of optional parameters will be printed to the primary output and is always printed to the secondary output.

Constraint:

Print Options = YES

NO

Print Solution

a

Default

= NO

Print Solution = YES

, the solution will be printed to the primary and secondary output.

Constraint:

Print Solution = YES

NO

Stats Time

a

Default

= NO

This parameter turns on timings of various parts of the algorithm to give a better overview of where most of the time is spent. This might be helpful for a choice of different solving approaches. It is possible to choose between CPU and wall clock time. Choice

YES

is equivalent to

WALL CLOCK

Constraint:

Stats Time = YES

NO

CPU

WALL CLOCK

Time Limit

r

Default

= 10^{6}

A limit to the number of seconds that the solver can use to solve one problem. If during the convergence check this limit is exceeded, the solver will terminate with

errorid = 23

Constraint:

Time Limit > 0

NAG Library Manual, Mark 27

Interfaces: FL CL CPP AD

NAG CPP Interface Introduction

E04 (Opt) Chapter Contents

e04fg: FL CL CPP AD

Namespace: nagcpp

Namespace: opt

Function: handle_solve_dfls_rcomm

NAG CPP Interfacenagcpp::opt::handle_solve_dfls_rcomm (e04fg)

▸▿ Contents

1 Purpose

2 Specification

3 Description

4 References

5 Arguments

5.1Additional Quantities

6 Exceptions and Warnings

7 Accuracy

8 Parallelism and Performance

9 Further Comments

9.1 Description of the Printed Output

10 Example

11 Algorithmic Details

11.1 Derivative-free Trust Region Algorithm

11.2 Bounds on the Variables

11.3 Adaptation to Nonlinear Least Squares Problems

11.4 Growing the Interpolation Set

11.5 Dealing with Noisy Problems

12 Optional Parameters

12.1 Description of the Optional Parameters

NAG CPP Interface
nagcpp::opt::handle_solve_dfls_rcomm (e04fg)