maxBFGS {maxLik}R Documentation

BFGS, conjugate gradient, SANN and Nelder-Mead Maximization

Description

These functions are wrappers for optim where the arguments are compatible with maxNR. Note that there is a maxNR-based BFGS implementation maxBFGSR.

Usage

maxBFGS(fn, grad = NULL, hess=NULL, start, fixed = NULL,
   print.level = 0, iterlim = 200, constraints = NULL,
   tol = 1e-08, reltol=tol,
   finalHessian=TRUE,
   parscale=rep(1, length=length(start)), ... )

maxCG(fn, grad = NULL, hess = NULL, start, fixed = NULL,
   print.level = 0, iterlim = 500, constraints = NULL,
   tol = 1e-08, reltol=tol,
   finalHessian=TRUE,
   parscale = rep(1, length = length(start)),
   alpha = 1, beta = 0.5, gamma = 2, ...)

maxSANN(fn, grad = NULL, hess = NULL, start, fixed = NULL,
   print.level = 0, iterlim = 10000, constraints = NULL,
   tol = 1e-08, reltol=tol,
   finalHessian=TRUE,
   cand = NULL, temp = 10, tmax = 10,
   parscale = rep(1, length = length(start)),
   random.seed = 123, ... )

maxNM(fn, grad = NULL, hess = NULL, start, fixed = NULL,
   print.level = 0, iterlim = 500, constraints = NULL,
   tol = 1e-08, reltol=tol,
   finalHessian=TRUE,
   parscale = rep(1, length = length(start)),
   alpha = 1, beta = 0.5, gamma = 2, ...)

Arguments

fn

function to be maximised. Must have the parameter vector as the first argument. In order to use numeric gradient and BHHH method, fn must return vector of observation-specific likelihood values. Those are summed by maxNR if necessary. If the parameters are out of range, fn should return NA. See details for constant parameters.

grad

gradient of the function. Must have the parameter vector as the first argument. If NULL, numeric gradient is used (only maxBFGS uses gradient). Gradient may return a matrix, where columns correspond to the parameters and rows to the observations (useful for maxBHHH). The columns are summed internally.

hess

Hessian of the function. Not used by any of these methods, for compatibility with maxNR.

start

initial values for the parameters.

fixed

parameters that should be fixed at their starting values: either a logical vector of the same length as argument start, a numeric (index) vector indicating the positions of the fixed parameters, or a vector of character strings indicating the names of the fixed parameters (parameter names are taken from argument start).

print.level

a larger number prints more working information.

iterlim

maximum number of iterations.

constraints

either NULL for unconstrained optimization or a list with two components. The components may be either eqA and eqB for equality-constrained optimization A %*% theta + B = 0; or ineqA and ineqB for inequality constraints A %*% theta + B >= 0. The equality-constrained problem is forwarded to sumt, the inequality-constrained case to constrOptim2.

tol, reltol

the relative convergence tolerance (see optim). tol is for compatibility with maxNR.

finalHessian

how (and if) to calculate the final Hessian. Either FALSE (not calculate), TRUE (use analytic/numeric Hessian) or "bhhh"/"BHHH" for information equality approach. The latter approach is only suitable for maximizing log-likelihood function. It requires the gradient/log-likelihood to be supplied by individual observations, see maxBHHH for details.

cand

a function used in the "SANN" algorithm to generate a new candidate point; if it is NULL, a default Gaussian Markov kernel is used (see argument gr of optim).

temp

controls the '"SANN"' method. It is the starting temperature for the cooling schedule. Defaults to '10'.

tmax

is the number of function evaluations at each temperature for the '"SANN"' method. Defaults to '10'. (see optim)

random.seed

an integer used to seed R's random number generator. This is to ensure replicability when the ‘Simulated Annealing’ method is used. Defaults to 123.

parscale

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. (see optim)

alpha, beta, gamma

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). (see optim)

...

further arguments for fn and grad.

Details

The ‘state’ (or ‘seed’) of R's random number generator is saved at the beginning of the maxSANN function and restored at the end of this function so that this function does not affect the generation of random numbers although the random seed is set to argument random.seed and the ‘SANN’ algorithm uses random numbers.

Value

Object of class "maxim":

maximum

value of fn at maximum.

estimate

best set of parameters found.

gradient

vector, gradient at parameter value estimate.

gradientObs

matrix of gradients at parameter value estimate evaluated at each observation (only if grad returns a matrix or grad is not specified and fn returns a vector).

hessian

value of Hessian at optimum.

code

integer. Success code, 0 is success (see optim).

message

character string giving any additional information returned by the optimizer, or NULL.

fixed

logical vector indicating which parameters are treated as constants.

iterations

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.

type

character string "BFGS maximisation".

constraints

A list, describing the constrained optimization (NULL if unconstrained). Includes the following components:

  • typetype of constrained optimization

  • outer.iterationsnumber of iterations in the constraints step

  • barrier.valuevalue of the barrier function

Author(s)

Ott Toomet otoomet@ut.ee, Arne Henningsen

See Also

optim, nlm, maxNR, maxBHHH, maxBFGSR.

Examples

# Maximum Likelihood estimation of the parameter of Poissonian distribution
n <- rpois(100, 3)
loglik <- function(l) n*log(l) - l - lfactorial(n)
# we use numeric gradient
summary(maxBFGS(loglik, start=1))
# you would probably prefer mean(n) instead of that ;-)
# Note also that maxLik is better suited for Maximum Likelihood
###
### Now an example of constrained optimization
###
f <- function(theta) {
  x <- theta[1]
  y <- theta[2]
  exp(-(x^2 + y^2))
  ## Note: you may want to use exp(- theta %*% theta) instead ;-)
}
## use constraints: x + y >= 1
A <- matrix(c(1, 1), 1, 2)
B <- -1
res <- maxNM(f, start=c(1,1), constraints=list(ineqA=A, ineqB=B),
print.level=1)
print(summary(res))

[Package maxLik version 1.1-0 Index]