DEoptim.control function

Control various aspects of the DEoptim implementation

Allow the user to set some characteristics of the Differential Evolution optimization algorithm implemented in DEoptim.

DEoptim.control(VTR = -Inf, strategy = 2, bs = FALSE, NP = 50,
   itermax = 200, CR = 0.5, F = 0.8, trace = TRUE,
   initialpop = NULL, storepopfrom = itermax + 1,
   storepopfreq = 1, p = 0.2, c = 0, reltol = sqrt(.Machine$double.eps),
   steptol = itermax)

Arguments

• VTR: the value to be reached. The optimization process will stop if either the maximum number of iterations itermax

  is reached or the best parameter vector bestmem has found a value fn(bestmem) <= VTR. Default to -Inf.

• strategy: defines the Differential Evolution strategy used in the optimization procedure:

  1: DE / rand / 1 / bin (classical strategy)

  2: DE / local-to-best / 1 / bin (default)

  3: DE / best / 1 / bin with jitter

  4: DE / rand / 1 / bin with per-vector-dither

  5: DE / rand / 1 / bin with per-generation-dither

  6: DE / current-to-p-best / 1

  any value not above: variation to DE / rand / 1 / bin: either-or-algorithm. Default strategy is currently 2. See Details.

• bs: if FALSE then every mutant will be tested against a member in the previous generation, and the best value will proceed into the next generation (this is standard trial vs. target selection). If TRUE then the old generation and NP

  mutants will be sorted by their associated objective function values, and the best NP vectors will proceed into the next generation (best of parent and child selection). Default is FALSE.

• NP: number of population members. Defaults to 50. For many problems it is best to set NP to be at least 10 times the length of the parameter vector.

• itermax: the maximum iteration (population generation) allowed. Default is 200.

• CR: crossover probability from interval [0,1]. Default to 0.5.

• F: step-size from interval [0,2]. Default to 0.8.

• trace: Printing of progress occurs? Default to TRUE. If numeric, progress will be printed every trace iterations.

• initialpop: an initial population used as a starting population in the optimization procedure. May be useful to speed up the convergence. Default to NULL. If given, each member of the initial population should be given as a row of a numeric matrix, so that initialpop is a matrix with NP rows and a number of columns equal to the length of the parameter vector to be optimized.

• storepopfrom: from which generation should the following intermediate populations be stored in memory. Default to itermax + 1, i.e., no intermediate population is stored.

• storepopfreq: the frequency with which populations are stored. Default to 1, i.e., every intermediate population is stored.

• p: when strategy = 6, the top (100 * p)% best solutions are used in the mutation. p must be defined in (0,1].

• c: when c > 0, crossover probability(CR) and step-size(F) are randomized at each mutation as an implementation of the JADE algorithm . c must be defined in [0,1].

• reltol: relative convergence tolerance. The algorithm stops if it is unable to reduce the value by a factor of reltol * (abs(val) + reltol) after steptol steps. Defaults to sqrt(.Machine$double.eps), typically about 1e-8.

• steptol: see reltol. Defaults to itermax.

Returns

The default value of control is the return value of DEoptim.control(), which is a list (and a member of the S3 class DEoptim.control) with the above elements.

Details

This defines the Differential Evolution strategy used in the optimization procedure, described below in the terms used by Price et al. (2006); see also Mullen et al. (2009) for details.

• strategy = 1: DE / rand / 1 / bin.

  This strategy is the classical approach for DE, and is described in DEoptim.

• strategy = 2: DE / local-to-best / 1 / bin.

  In place of the classical DE mutation the expression

$$v_{i,g} = old_{i,g} + (best_{g} - old_{i,g}) + x_{r0,g} + F \cdot (x_{r1,g} - x_{r2,g})v_i,g = old_i,g + (best_g - old_i,g) + x_r0,g + F * (x_r1,g - x_r2,g)$$

is used, where $old_i,g$ and $best_g$ are the $i$-th member and best member, respectively, of the previous population. This strategy is currently used by default.

• strategy = 3: DE / best / 1 / bin with jitter.

  In place of the classical DE mutation the expression

$$v_{i,g} = best_{g} + jitter + F \cdot (x_{r1,g} - x_{r2,g})v_i,g = best_g + jitter + F * (x_r1,g - x_r2,g)$$

is used, where $jitter$ is defined as 0.0001 * rand + F.

• strategy = 4: DE / rand / 1 / bin with per vector dither.

  In place of the classical DE mutation the expression

$$v_{i,g} = x_{r0,g} + dither \cdot (x_{r1,g} - x_{r2,g})v_i,g = x_r0,g + dither * (x_r1,g - x_r2,g)$$

is used, where $dither$ is calculated as $F + \code{rand} * (1 - F)$.

• strategy = 5: DE / rand / 1 / bin with per generation dither.

  The strategy described for 4 is used, but $dither$

  is only determined once per-generation.

• any value not above: variation to DE / rand / 1 / bin: either-or algorithm.

  In the case that rand < 0.5, the classical strategy strategy = 1 is used. Otherwise, the expression

$$v_{i,g} = x_{r0,g} + 0.5 \cdot (F + 1) \cdot (x_{r1,g} + x_{r2,g} - 2 \cdot x_{r0,g})v_i,g = x_r0,g + 0.5 * (F + 1) * (x_r1,g + x_r2,g - 2 * x_r0,g)$$

is used.

Note

Further details and examples of the package DEoptim can be found in Mullen et al. (2009) and Ardia et al. (2010).

Please cite the package in publications.

See Also

DEoptim and DEoptim-methods.

References

Price, K.V., Storn, R.M., Lampinen J.A. (2006) Differential Evolution - A Practical Approach to Global Optimization. Berlin Heidelberg: Springer-Verlag. ISBN 3540209506.

Mullen, K.M., Ardia, D., Gil, D.L, Windover, D., Cline, J. (2009) DEoptim: An Package for Global Optimization by Differential Evolution. URL https://www.ssrn.com/abstract=1526466

Ardia, D., Boudt, K., Carl, P., Mullen, K.M., Peterson, B.G. (2010) Differential Evolution (DEoptim) for Non-Convex Portfolio Optimization. URL https://www.ssrn.com/abstract=1584905

Author(s)

For RcppDE: Dirk Eddelbuettel.

For DEoptim: David Ardia, Katharine Mullen katharine.mullen@nist.gov , Brian Peterson and Joshua Ulrich.

Examples

## set the population size to 20
DEoptim.control(NP = 20)

## set the population size, the number of iterations and don't
## display the iterations during optimization
DEoptim.control(NP = 20, itermax = 100, trace = FALSE)