R: Control various aspects of the DEoptim implementation

DEoptim.control {RcppDE} | R Documentation

## Control various aspects of the DEoptim implementation

### Description

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

### Usage

    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`.

### 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 * (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 * (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 * (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 * (F + 1) * (x_r1,g + x_r2,g - 2 * x_r0,g)

  is used.

### Value

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.

### Note

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

Please cite the package in publications.

### Author(s)

For RcppDE: Dirk Eddelbuettel.

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

### 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 R Package for Global Optimization by Differential Evolution. URL http://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 http://ssrn.com/abstract=1584905

### See Also

`DEoptim` and `DEoptim-methods`.

### 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)

[Package RcppDE version 0.1.6 Index]