Models are fitted through repeated evaluation of modified call extracted from
the global.model (in a similar fashion as with update). This
approach, while robust in that it can be applied to most model types is not
the most efficient and may be computationally-intensive.
Note that the number of combinations grows exponentially with number of
predictors (2<U+207F>, less when
interactions are present, see below).
The fitted model objects are not stored in the result. To get (a subset of)
models, use get.models on the object returned by dredge.
For a list of model types that can be used as a global.model see
list of supported models.
Modelling functions not storing call in their result should be evaluated
via the wrapper function created by updateable.
Information criterion
rank is found by a call to match.fun and may be specified as a
function or a symbol or a character string specifying
a function to be searched for from the environment of the call to dredge.
The function rank must accept model object as its first argument and
always return a scalar.
Interactions
By default, marginality constraints are respected, so “all possible
combinations” include only those containing interactions with their
respective main effects and all lower order terms.
However, if global.model makes an exception to this principle (e.g. due
to a nested design such as a / (b + d)), this will be reflected in the
subset models.
Subsetting
There are three ways to constrain the resulting set of models: setting limits to
the number of terms in a model with m.lim, binding
term(s) to all models with fixed, and more complex rules can be applied
using argument subset. To be included in the selection table, the model
formulation must satisfy all these conditions.
subset can take either a form of an expression or a matrix.
The latter should be a lower triangular matrix with logical values, where
columns and rows correspond to global.model terms. Value
subset["a", "b"] == FALSE will exclude any model containing both terms
a and b.
demo(dredge.subset) has examples of using the subset matrix in
conjunction with correlation matrices to exclude models containing collinear
predictors.
In the form of expression, the argument subset acts in a similar
fashion to that in the function subset for data.frames: model
terms can be referred to by name as variables in the expression, with the
difference being that are interpreted as logical values (i.e. equal to
TRUE if the term exists in the model).
There is also .(x) and .(+x) notation indicating, respectively,
any and all interactions including a term x. It is only useful
with marginality exceptions.
The expression can contain any of the global.model terms
(getAllTerms(global.model) lists them), as well as names of the
varying argument items. Names of global.model terms take
precedence when identical to names of varying, so to avoid ambiguity
varying variables in subset expression should be enclosed in
V() (e.g. subset = V(family) == "Gamma" assuming that
varying is something like list(family = c(..., "Gamma"))).
If item names in varying are missing, the items themselves are coerced to
names. Call and symbol elements are represented as character values (via
deparse), and everything except numeric, logical, character and
NULL values is replaced by item numbers (e.g. varying =
list(family = list(..., Gamma) should be referred to as
subset = V(family) == 2. This can quickly become confusing, therefore it
is recommended to use named lists. demo(dredge.varying) provides examples.
The subset expression can also contain variable
`*nvar*` (backtick-quoted), equal to
number of terms in the model (not the number of estimated parameters).
To make inclusion of a model term conditional on presence of another model term,
the function dc (“dependency chain”) can be used in
the subset expression. dc takes any number of term names as
arguments, and allows a term to be included only if all preceding ones
are also present (e.g. subset = dc(a, b, c) allows for models a,
a+b and a+b+c but not b, c, b+c or
a+c).
subset expression can have a form of an unevaluated call,
expression object, or a one sided formula. See ‘Examples’.
Compound model terms (such as interactions, ‘as-is’ expressions within
I() or smooths in gam) should be enclosed within curly brackets
(e.g. {s(x,k=2)}), or backticks (like non-syntactic
names, e.g.
`s(x, k = 2)`
).
Backticks-quoted names must match exactly (including whitespace) the term names
as given by getAllTerms.
subset expression syntax summary
a & bindicates that model terms a and b must be
present (see Logical Operators)
{log(x,2)} or `log(x, 2)`represent a complex
model term log(x, 2)
V(x)represents a varying variable x
.(x)indicates that at least one term containing the term
x must be present
.(+x)indicates that all the terms containing the term x
must be present
dc(a, b, c,...)‘dependency chain’: b is allowed only
if a is present, and c only if both a and b are
present, etc.
`*nvar*`number of terms.
To simply keep certain terms in all models, use of argument fixed is much
more efficient. The fixed formula is interpreted in the same manner
as model formula and so the terms need not to be quoted.
Missing values
Use of na.action = "na.omit" (R's default) or "na.exclude" in
global.model must be avoided, as it results with sub-models fitted to
different data sets, if there are missing values. Error is thrown if it is
detected.
It is a common mistake to give na.action as an argument in the call
to dredge (typically resulting in an error from the rank
function to which the argument is passed through ‘…’), while the correct way
is either to pass na.action in the call to the global model or to set
it as a global option.
Methods
There are subset and
plot methods, the latter creates a
graphical representation of model weights and variable relative importance.
Coefficients can be extracted with coef or coefTable.