optimizer,
further restart_edge, etc;
check.nobs.vs.rankZ, or
check.rankX (currently not for nlmerControl);
optCtrl list
argument.
lmerControl(optimizer = "bobyqa",
restart_edge = TRUE,
boundary.tol = 1e-5,
calc.derivs=TRUE,
use.last.params=FALSE,
sparseX = FALSE,
## input checking options
check.nobs.vs.rankZ = "ignore",
check.nobs.vs.nlev = "stop",
check.nlev.gtreq.5 = "ignore",
check.nlev.gtr.1 = "stop",
check.nobs.vs.nRE="stop",
check.rankX = c("message+drop.cols", "silent.drop.cols", "warn+drop.cols",
"stop.deficient", "ignore"),
check.scaleX = c("warning","stop","silent.rescale",
"message+rescale","warn+rescale","ignore"),
check.formula.LHS = "stop",
## convergence checking options
check.conv.grad = .makeCC("warning", tol = 2e-3, relTol = NULL),
check.conv.singular = .makeCC(action = "ignore", tol = 1e-4),
check.conv.hess = .makeCC(action = "warning", tol = 1e-6),
## optimizer args
optCtrl = list())glmerControl(optimizer = c("bobyqa", "Nelder_Mead"),
restart_edge = FALSE,
boundary.tol = 1e-5,
calc.derivs=TRUE,
use.last.params=FALSE,
sparseX = FALSE,
tolPwrss=1e-7,
compDev=TRUE,
nAGQ0initStep=TRUE,
## input checking options
check.nobs.vs.rankZ = "ignore",
check.nobs.vs.nlev = "stop",
check.nlev.gtreq.5 = "ignore",
check.nlev.gtr.1 = "stop",
check.nobs.vs.nRE="stop",
check.rankX = c("message+drop.cols", "silent.drop.cols", "warn+drop.cols",
"stop.deficient", "ignore"),
check.scaleX = "warning",
check.formula.LHS = "stop",
check.response.not.const = "stop",
## convergence checking options
check.conv.grad = .makeCC("warning", tol = 1e-3, relTol = NULL),
check.conv.singular = .makeCC(action = "ignore", tol = 1e-4),
check.conv.hess = .makeCC(action = "warning", tol = 1e-6),
## optimizer args
optCtrl = list())
nlmerControl(optimizer = "Nelder_Mead", tolPwrss = 1e-10,
optCtrl = list())
.makeCC(action, tol, relTol, …)
lmer or glmer, possibly length 2 for glmer).
The built-in optimizers are Nelder_Mead and
bobyqa (from the minqa package). Any
minimizing function that allows box constraints can be used provided
that it
fn (function to be
optimized), par (starting parameter values), lower
and upper (parameter bounds)
and control (control parameters, passed
through from the control argument) andpar
(best-fit parameters), fval (best-fit function value),
conv (convergence code, equal to zero for
successful convergence) and (optionally) message
(informational message, or explanation of convergence failure). Special provisions are made for bobyqa,
Nelder_Mead, and optimizers wrapped in the
optimx package; to use the optimx optimizers (including
L-BFGS-B from base optim and
nlminb), pass the method argument to
optim in the optCtrl argument (you may also
need to load the optimx package manually using
library(optimx) or require(optimx)).
For glmer, if length(optimizer)==2, the first element
will be used for the preliminary (random effects parameters only)
optimization, while the second will be used for the final (random
effects plus fixed effect parameters) phase. See
modular for more information on these two phases.
If optimizer is NULL (at present for lmer only),
all of the model structures will be set up, but no optimization will
be done (e.g. parameters will all be returned as NA).
TRUE), rather than the value of the
parameters corresponding to the minimum deviance, be returned?
This is a "backward bug-compatibility" option; use TRUE
only when trying to match previous results.lmerControl.)nAGQ = 0. While the initial optimization usually
provides a good starting point for subsequent fitting
(thus increasing overall computational speed),
setting this option to FALSE can be useful in cases
where the initial phase results in bad fixed-effect estimates
(seen most often in binomial models with link="cloglog"
and offsets).action.action.action, with
the addition of "warningSmall" and "stopSmall", which run
the test only if the dimensions of Z are < 1e6.
nobs > rank(Z) will be tested for LMMs and GLMMs with
estimated scale parameters; nobs >= rank(Z) will be tested
for GLMMs with fixed scale parameter.
The rank test is done using the
method="qr" option of the rankMatrix
function.
action.
nobs<nlevels will be tested for LMMs and GLMMs with estimated
scale parameters; nobs<=nlevels will be tested for GLMMs with
fixed scale parameter.check.nobs.vs.nlev..makeCC, or a character string with only the action.check.conv.grad above.check.conv.grad
above.rankMatrix(X)
should be compared with ncol(X) and if columns from the design
matrix should possibly be dropped to ensure that it has full rank.
Sometimes needed to make the model identifiable. The options can be
abbreviated; the three "*.drop.cols" options all do drop
columns, "stop.deficient" gives an error when the rank is
smaller than the number of columns where "ignore" does no
rank computation, and will typically lead to less easily
understandable errors, later.simulate.merMod;
use at your own risk as it may allow the generation
of unstable merMod objectslist of additional arguments to be
passed to the nonlinear optimizer (see Nelder_Mead,
bobyqa). In particular, both
Nelder_Mead and bobyqa use maxfun to
specify the maximum number of function evaluations they
will try before giving up - in contrast to
optim and optimx-wrapped optimizers,
which use maxit.*Control functions return a list (inheriting from class
"merControl") containing
optimizer, restart_edge;
nlmerControl:)
"checkControl", a list of data-checking
specifications, e.g., check.nobs.vs.rankZ;
optCtrl
list, which may contain maxiter.
.makeCC returns a list containing the check specification
(action, tolerance, and optionally relative tolerance)."check." but not
including the convergence checks ("check.conv.*") or
rank-checking ("check.rank*") options)
may also be set globally via options.
In that case, (g)lmerControl will use them rather than the
default values, but will not override values that are passed as
explicit arguments. For example, options(lmerControl=list(check.nobs.vs.rankZ = "ignore"))
will suppress warnings that the number of observations is less than
the rank of the random effects model matrix Z.str(lmerControl())
str(glmerControl())
## Not run: ------------------------------------
# ## fit with default "bobyqa" algorithm ...
# fm0 <- lmer(Reaction ~ Days + ( 1 | Subject), sleepstudy)
# fm1 <- lmer(Reaction ~ Days + (Days | Subject), sleepstudy)
# ## or with "Nelder_Mead" (the previous default) ...
# fm1_bobyqa <- update(fm1, control = lmerControl(optimizer="Nelder_Mead"))
# ## or with the nlminb function used in older (<1.0) versions of lme4;
# ## this will usually replicate older results
# require(optimx)
# fm1_nlminb <- update(fm1,
# control = lmerControl(optimizer= "optimx",
# optCtrl = list(method="nlminb")))
# ## The other option here is method="L-BFGS-B".
# ## Or we can wrap base::optim():
# optimwrap <- function(fn,par,lower,upper,control=list(),
# ...) {
# if (is.null(control$method)) stop("must specify method in optCtrl")
# method <- control$method
# control$method <- NULL
# ## "Brent" requires finite upper values (lower bound will always
# ## be zero in this case)
# if (method=="Brent") upper <- pmin(1e4,upper)
# res <- optim(par=par, fn=fn, lower=lower,upper=upper,
# control=control,method=method,...)
# with(res, list(par = par,
# fval = value,
# feval= counts[1],
# conv = convergence,
# message = message))
# }
# fm0_brent <- update(fm0,
# control = lmerControl(optimizer = "optimwrap",
# optCtrl = list(method="Brent")))
# ## You can also use functions from the nloptr package.
# if (require(nloptr)) {
# defaultControl <- list(algorithm="NLOPT_LN_BOBYQA",
# xtol_abs=1e-6,ftol_abs=1e-6,maxeval=1e5)
# nloptwrap <- function(fn,par,lower,upper,control=list(),...) {
# for (n in names(defaultControl))
# if (is.null(control[[n]])) control[[n]] <- defaultControl[[n]]
# res <- nloptr(x0=par,eval_f=fn,lb=lower,ub=upper,opts=control,...)
# with(res, list(par = solution,
# fval = objective,
# feval= iterations,
# conv = if (status>0) 0 else status,
# message = message))
# }
# fm1_nloptr <- update(fm1, control=lmerControl(optimizer="nloptwrap"))
# fm1_nloptr_NM <- update(fm1, control=lmerControl(optimizer="nloptwrap",
# optCtrl=list(algorithm="NLOPT_LN_NELDERMEAD")))
# }
# ## other algorithm options include NLOPT_LN_COBYLA, NLOPT_LN_SBPLX
#
## ---------------------------------------------
Run the code above in your browser using DataLab