optim                  package:base                  R Documentation

_G_e_n_e_r_a_l-_p_u_r_p_o_s_e _O_p_t_i_m_i_z_a_t_i_o_n

_D_e_s_c_r_i_p_t_i_o_n:

     General-purpose optimization based on Nelder-Mead, quasi-Newton
     and conjugate-gradient algorithms. It includes an option for
     box-constrained optimization.

_U_s_a_g_e:

     optim(par, fn, gr = NULL,
           method = c("Nelder-Mead", "BFGS", "CG", "L-BFGS-B", "SANN"),
           lower = -Inf, upper = +Inf,
           control = list(), hessian = FALSE), ...)

_A_r_g_u_m_e_n_t_s:

     par: Initial values for the parameters to be optimized over.

      fn: A function to be minimized, with first argument the vector of
          parameters over which minimization is to take place. It
          should return a scalar result.

      gr: A function to return the gradient. Not needed for the
          `"Nelder-Mead"' and `"SANN"' method. If it is `NULL' and it
          is needed, a finite-difference approximation will be used. It
          is guaranteed that `gr' will be called immediately after a
          call to `fn' at the same parameter values.

  method: The method to be used. See Details.

lower, upper: Bounds on the variables for the `"L-BFGS-B"' method.

 control: A list of control parameters. See Details.

 hessian: Logical. Should a numerically differentiated Hessian matrix
          be returned?

     ...: Further arguments to be passed to `fn' and `gr'.

_D_e_t_a_i_l_s:

     By default this function performs minimization, but it will
     maximize if `control$fnscale' is negative.

     The default method is an implementation of that of Nelder and Mead
     (1965), that uses only function values and is robust but
     relatively slow. It will work reasonably well for
     non-differentiable functions.

     Method `"BFGS"' is a quasi-Newton method (also known as a variable
     metric algorithm), specifically that published simultaneously in
     1970 by Broyden, Fletcher, Goldfarb and Shanno. This uses function
     values and gradients to build up a picture of the surface to be
     optimized.

     Method `"CG"' is a conjugate gradients method based on that by
     Fletcher and Reeves (1964) (but with the option of Polak-Ribiere
     or Beale-Sorenson updates).  Conjugate gradient methods will
     generally be more fragile that the BFGS method, but as they do not
     store a matrix they may be successful in much larger optimization
     problems.

     Method `"L-BFGS-B"' is that of Byrd et. al. (1994) which allows
     box constraints, that is each variable can be given a lower and/or
     upper bound. The initial value must satisfy the constraints. This
     uses a limited-memory modification of the BFGS quasi-Newton
     method. If non-trivial bounds are supplied, this method will be
     selected, with a warning.

     Method `"SANN"' is a variant of simulated annealing given in
     Belisle (1992). Simulated-annealing belongs to the class of
     stochastic global optimization methods. It uses only function
     values but is relatively slow. It will also work for
     non-differentiable functions. This implementation uses the
     Metropolis function for the acceptance probability. The next
     candidate point is generated from a Gaussian Markov kernel with
     scale proportional to the actual temperature. Temperatures are
     decreased according to the logarithmic cooling schedule as given
     in Belisle (1992, p. 890). Note that the `"SANN"' method depends
     critically on the settings of the control parameters.  It is not a
     general-purpose method but can be very useful in getting to a good
     value on a very rough surface.

     Function `fn' can return `NA' or `Inf' if the function cannot be
     evaluated at the supplied value, but the initial value must have a
     computable finite value of `fn'. (Except for method `"L-BFGS-B"'
     where the values should always be finite.)

     `optim' can be used recursively, and for a single parameter as
     well as many.

     The `control' argument is a list that can supply any of the
     following components:

     `_t_r_a_c_e' Logical. If true, tracing information on the
            progress of the optimization is produced.

     `_f_n_s_c_a_l_e' An overall scaling to be applied to the
            value of `fn' and `gr' during optimization. If negative,
            turns the problem into a maximization problem. Optimization
            is performed on `fn(par)/fnscale'.

     `_p_a_r_s_c_a_l_e' A vector of scaling values for the
            parameters. Optimization is performed on `par/parscale' and
            these should be comparable in the sense that a unit change
            in any element produces about a unit change in the scaled
            value.

     `_n_d_e_p_s' A vector of step sizes for the finite-difference
            approximation to the gradient, on `par/parscale' scale.
            Defaults to `1e-3'.

     `_m_a_x_i_t' The maximum number of iterations. Defaults to
            `100' for the derivative-based methods, and `500' for
            `"Nelder-Mead"'. For `"SANN"' `maxit' gives the total
            number of function evaluations. There is no other stopping
            criteria. Defaults to `10000'.

     `_a_b_s_t_o_l' The absolute convergence tolerance. Only
            useful for non-negative functions, as a tolerance for
            reaching zero.

     `_r_e_l_t_o_l' Relative convergence tolerance.  The
            algorithm stops if it is unable to reduce the value by a
            factor of `reltol * (abs(val) + reltol)' at a step. 
            Defaults to `sqrt(.Machine$double.eps)', typically about
            `1e-8'.

     `_a_l_p_h_a', `_b_e_t_a', `_g_a_m_m_a' Scaling
            parameters for the `"Nelder-Mead"' method. `alpha' is the
            reflection factor (default 1.0), `beta' the contraction
            factor (0.5) and `gamma' the expansion factor (2.0).

     `_R_E_P_O_R_T' The frequency of reports for the `"BFGS"'
            method in `control$trace' is positive. Defaults to every 10
            iterations.

     `_t_y_p_e' for the conjugate-gradients method. Takes value `1'
            for the Fletcher-Reeves update, `2' for Polak-Ribiere and
            `3' for Beale-Sorenson.

     `_l_m_m' is an integer giving the number of BFGS updates
            retained in the `"L-BFGS-B"' method, It defaults to `5'.

     `_f_a_c_t_r' controls the convergence of the `"L-BFGS-B"'
            method. Convergence occurs when the reduction in the
            objective is within this factor of the machine tolerance.
            Default is `1e7', that is a tolerance of about `1e-8'.

     `_p_g_t_o_l' helps controls the convergence of the
            `"L-BFGS-B"' method. It is a tolerance on the projected
            gradient in the current search direction. This defaults to
            zero, when the check is suppressed.

     `_t_e_m_p' controls the `"SANN"' method. It is the starting
            temperature for the cooling schedule. Defaults to `10'.

     `_t_m_a_x' is the number of function evaluations at each
            temperature for the `"SANN"' method. Defaults to `10'.

_V_a_l_u_e:

     A list with components: 

     par: The best set of parameters found.

   value: The value of `fn' corresponding to `par'.

  counts: A two-element integer vector giving the number of calls to
          `fn' and `gr' respectively. This excludes those calls needed
          to compute the Hessian, if requested, and any calls to `fn'
          to compute a finite-difference approximation to the gradient.

convergence: An integer code. `0' indicates successful convergence.
          Error codes are

          `_1' indicates that the iteration limit `maxit' had been
                 reached.

          `_1_0' indicates degeneracy of the Nelder-Mead simplex.

          `_5_1' indicates a warning from the `"L-BFGS-B"' method;
                 see component `message' for further details.

          `_5_2' indicates an error from the `"L-BFGS-B"' method; see
                 component `message' for further details.

 message: A character string giving any additional information returned
          by the optimizer, or `NULL'.

 hessian: Only if argument `hessian' is true. A symmetric matrix giving
          an estimate of the Hessian at the solution found. Note that
          this is the Hessian of the unconstrained problem even if the
          box constraints are active.

_N_o_t_e:

     The code for methods `"Nelder-Mead"', `"BFGS"' and `"CG"' was
     based originally on Pascal code in Nash (1990) that was translated
     by `p2c' and then hand-optimized.  Dr Nash has agreed that the
     code can be made freely available.

     The code for method `"L-BFGS-B"' is based on Fortran code by Zhu,
     Byrd, Lu-Chen and Nocedal obtained from Netlib (file
     `opt/lbfgs_bcm.shar': another version is in `toms/778').

     The code for method `"SANN"' was contributed by A. Trapletti.

_R_e_f_e_r_e_n_c_e_s:

     Belisle, C. J. P. (1992) Convergence theorems for a class of
     simulated annealing algorithms on Rd. J Applied Probability, 29,
     885-895.

     Byrd, R. H., Lu, P., Nocedal, J. and Zhu, C.  (1995) A limited
     memory algorithm for bound constrained optimization. SIAM J.
     Scientific Computing, 16, 1190-1208.

     Fletcher, R. and Reeves, C. M. (1964) Function minimization by
     conjugate gradients. Computer Journal 7, 148-154.

     Nash, J. C. (1990) Compact Numerical Methods for Computers. Linear
     Algebra and Function Minimisation. Adam Hilger.

     Nelder, J. A. and Mead, R. (1965) A simplex algorithm for function
     minimization. Computer Journal 7, 308-313.

_S_e_e _A_l_s_o:

     `nlm', `optimize'

_E_x_a_m_p_l_e_s:

     fr <- function(x) {   ## Rosenbrock Banana function
         x1 <- x[1]
         x2 <- x[2]
         100 * (x2 - x1 * x1)^2 + (1 - x1)^2
     }
     grr <- function(x) { ## Gradient of `fr'
         x1 <- x[1]
         x2 <- x[2]
         c(-400 * x1 * (x2 - x1 * x1) - 2 * (1 - x1),
            200 *      (x2 - x1 * x1))
     }
     optim(c(-1.2,1), fr)
     optim(c(-1.2,1), fr, grr, method = "BFGS")
     optim(c(-1.2,1), fr, NULL, method = "BFGS", hessian = TRUE)
     optim(c(-1.2,1), fr, grr, method = "CG")
     optim(c(-1.2,1), fr, grr, method = "CG", control=list(type=2))
     optim(c(-1.2,1), fr, grr, method = "L-BFGS-B")

     flb <- function(x)
         { p <- length(x); sum(c(1, rep(4, p-1)) * (x - c(1, x[-p])^2)^2) }
     ## 25-dimensional box constrained
     optim(rep(3, 25), flb, NULL, "L-BFGS-B",
           lower=rep(2, 25), upper=rep(4, 25)) # par[24] is *not* at boundary

     ## "wild" function , global minimum at about -15.81515
     fw <- function (x)
         10*sin(0.3*x)*sin(1.3*x^2) + 0.00001*x^4 + 0.2*x+80
     plot(fw, -50, 50, n=1000, main = "optim() minimising `wild function'")

     res <- optim(50, fw, method="SANN",
                  control=list(maxit=20000, temp=20, parscale=20))
     res
     ## Now improve locally
     (r2 <- optim(res$par, fw, method="BFGS"))
     points(r2$par, r2$val, pch = 8, col = "red", cex = 2)

