This page describes the options available for generating the model matrix.

This is the simpler option, and the one that is most compatible with other R modelling functions. The `model.frame`

function takes a formula and data frame and returns a *model frame*: a data frame with special information attached that lets R make sense of the terms in the formula. For example, if a formula includes an interaction term, the model frame will specify which columns in the data relate to the interaction, and how they should be treated. Similarly, if the formula includes expressions like `exp(x)`

or `I(x^2)`

on the RHS, `model.frame`

will evaluate these expressions and include them in the output.

The major disadvantage of using `model.frame`

is that it generates a terms object, which encodes how variables and interactions are organised. One of the attributes of this object is a matrix with one row per variable, and one column per main effect and interaction. At minimum, this is (approximately) a \(p \times p\) square matrix where \(p\) is the number of main effects in the model. For wide datasets with \(p > 10000\), this matrix can approach or exceed a gigabyte in size. Even if there is enough memory to store such an object, generating the model matrix can take a significant amount of time.

Another issue with the standard R approach is the treatment of factors. Normally, `model.matrix`

will turn an \(N\)-level factor into an indicator matrix with \(N-1\) columns, with one column being dropped. This is necessary for unregularised models as fit with `lm`

and `glm`

, since the full set of \(N\) columns is linearly dependent. With the usual treatment contrasts, the interpretation is that the dropped column represents a baseline level, while the coefficients for the other columns represent the difference in the response relative to the baseline.

This may not be appropriate for a regularised model as fit with glmnet. The regularisation procedure shrinks the coefficients towards zero, which forces the estimated differences from the baseline to be smaller. But this only makes sense if the baseline level was chosen beforehand, or is otherwise meaningful as a default; otherwise it is effectively making the levels more similar to an arbitrarily chosen level.

To deal with the problems above, glmnetUtils by default will avoid using `model.frame`

, instead building up the model matrix term-by-term. This avoids the memory cost of creating a `terms`

object, and can be noticeably faster than the standard approach. It will also include one column in the model matrix for *all* levels in a factor; that is, no baseline level is assumed. In this situation, the coefficients represent differences from the overall mean response, and shrinking them to zero *is* meaningful (usually).

This works in an additive fashion, ie the formula `~ a + b:c + d*e`

is treated as consisting of three terms, `a`

, `b:c`

and `d*e`

each of which is processed independently of the others. A dot in the formula includes all main effect terms, ie `~ . + a:b + f(x)`

expands to `~ a + b + x + a:b + f(x)`

(assuming a, b and x are the only columns in the data). Note that a formula like `~ (a + b) + (c + d)`

will be treated as two terms, `a + b`

and `c + d`

.

The code can handle fairly complex formulas, but it is not as sophisticated as base `model.frame`

and `model.matrix`

. In particular, terms that are to be *omitted* from the model must be at the end of the formula: `~ . - c`

works, but not `~ -c + .`

.

There are two ways in which glmnetUtils can generate a model matrix out of a formula and data frame. The first is to use the standard R machinery comprising model.frameand model.matrix; and the second is to build the matrix one variable at a time. These options are discussed and contrasted below.