General-purpose optimization based on Nelder--Mead, quasi-Newton and conjugate-gradient algorithms. It includes an option for box-constrained optimization and simulated annealing.
optim(par, fn, gr = NULL, …, method = c("Nelder-Mead", "BFGS", "CG", "L-BFGS-B", "SANN", "Brent"), lower = -Inf, upper = Inf, control = list(), hessian = FALSE)
optimHess(par, fn, gr = NULL, …, control = list())
Initial values for the parameters to be optimized over.
A function to be minimized (or maximized), with first argument the vector of parameters over which minimization is to take place. It should return a scalar result.
A function to return the gradient for the
"L-BFGS-B"methods. If it is
NULL, a finite-difference approximation will be used.
"SANN"method it specifies a function to generate a new candidate point. If it is
NULLa default Gaussian Markov kernel is used.
Further arguments to be passed to
The method to be used. See ‘Details’. Can be abbreviated.
- lower, upper
Bounds on the variables for the
"L-BFGS-B"method, or bounds in which to search for method
A list of control parameters. See ‘Details’.
Logical. Should a numerically differentiated Hessian matrix be returned?
Note that arguments after
… must be matched exactly.
optim performs minimization, but it will maximize
control$fnscale is negative.
optimHess is an
auxiliary function to compute the Hessian at a later stage if
hessian = TRUE was forgotten.
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.
"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.
"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 than the BFGS method, but as they do not store a
matrix they may be successful in much larger optimization problems.
"L-BFGS-B" is that of Byrd et. al. (1995) 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.
Nocedal and Wright (1999) is a comprehensive reference for the previous three methods.
"SANN" is by default 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. By default the next candidate point is
generated from a Gaussian Markov kernel with scale proportional to the
actual temperature. If a function to generate a new candidate point is
"SANN" can also be used to solve combinatorial
optimization problems. Temperatures are decreased according to the
logarithmic cooling schedule as given in Belisle (1992, p.890);
specifically, the temperature is set to
temp / log(((t-1) %/% tmax)*tmax + exp(1)), where
the current iteration step and
control, see below. 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.
"Brent" is for one-dimensional problems only, using
optimize(). It can be useful in cases where
optim() is used inside other functions where only
can be specified, such as in
mle from package stats4.
fn can return
Inf if the function
cannot be evaluated at the supplied value, but the initial value must
have a computable finite value of
(Except for method
"L-BFGS-B" where the values should always be
optim can be used recursively, and for a single parameter
as well as many. It also accepts a zero-length
par, and just
evaluates the function with that argument.
control argument is a list that can supply any of the
Non-negative integer. If positive, tracing information on the progress of the optimization is produced. Higher values may produce more tracing information: for method
"L-BFGS-B"there are six levels of tracing. (To understand exactly what these do see the source code: higher levels give more detail.)
An overall scaling to be applied to the value of
grduring optimization. If negative, turns the problem into a maximization problem. Optimization is performed on
A vector of scaling values for the parameters. Optimization is performed on
par/parscaleand these should be comparable in the sense that a unit change in any element produces about a unit change in the scaled value. Not used (nor needed) for
method = "Brent".
A vector of step sizes for the finite-difference approximation to the gradient, on
par/parscalescale. Defaults to
The maximum number of iterations. Defaults to
100for the derivative-based methods, and
maxitgives the total number of function evaluations: there is no other stopping criterion. Defaults to
The absolute convergence tolerance. Only useful for non-negative functions, as a tolerance for reaching zero.
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
Scaling parameters for the
alphais the reflection factor (default 1.0),
betathe contraction factor (0.5) and
gammathe expansion factor (2.0).
The frequency of reports for the
control$traceis positive. Defaults to every 10 iterations for
"L-BFGS-B", or every 100 temperatures for
for the conjugate-gradients method. Takes value
1for the Fletcher--Reeves update,
2for Polak--Ribiere and
is an integer giving the number of BFGS updates retained in the
"L-BFGS-B"method, It defaults to
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
helps control 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.
"SANN"method. It is the starting temperature for the cooling schedule. Defaults to
is the number of function evaluations at each temperature for the
"SANN"method. Defaults to
Any names given to
par will be copied to the vectors passed to
gr. Note that no other attributes of
are copied over.
The parameter vector passed to
fn has special semantics and may
be shared between calls: the function should not change or copy it.
optim, a list with components:
The best set of parameters found.
The value of
fn corresponding to
A two-element integer vector giving the number of calls
gr respectively. This excludes those calls needed
to compute the Hessian, if requested, and any calls to
compute a finite-difference approximation to the gradient.
An integer code.
0 indicates successful
completion (which is always the case for
"Brent"). Possible error codes are
indicates that the iteration limit
maxithad been reached.
indicates degeneracy of the Nelder--Mead simplex.
indicates a warning from the
"L-BFGS-B"method; see component
messagefor further details.
indicates an error from the
"L-BFGS-B"method; see component
messagefor further details.
A character string giving any additional information
returned by the optimizer, or
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.
For optimHess, the description of the hessian component applies.
optim will work with one-dimensional
pars, but the
default method does not work well (and will warn). Method
optimize and needs bounds to be available;
"BFGS" often works well enough if not.
Belisle, C. J. P. (1992) Convergence theorems for a class of simulated annealing algorithms on \(R^d\). 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.
Nocedal, J. and Wright, S. J. (1999) Numerical Optimization. Springer.