Solve weighted least squares (WLS) problem for a single lambda value

Solves the weighted least squares (WLS) problem for a single lambda value. Internal function that users should not call directly.

elnet.fit(
  x,
  y,
  weights,
  lambda,
  alpha = 1,
  intercept = TRUE,
  thresh = 1e-07,
  maxit = 1e+05,
  penalty.factor = rep(1, nvars),
  exclude = c(),
  lower.limits = -Inf,
  upper.limits = Inf,
  warm = NULL,
  from.glmnet.fit = FALSE,
  save.fit = FALSE
)

Arguments

x: Input matrix, of dimension nobs x nvars; each row is an observation vector. If it is a sparse matrix, it is assumed to be unstandardized. It should have attributes xm and xs, where xm(j) and xs(j) are the centering and scaling factors for variable j respsectively. If it is not a sparse matrix, it is assumed that any standardization needed has already been done.
y: Quantitative response variable.
weights: Observation weights. elnet.fit does NOT standardize these weights.
lambda: A single value for the lambda hyperparameter.
alpha: The elasticnet mixing parameter, with $0 \le \alpha \le 1$. The penalty is defined as $$(1-\alpha)/2||\beta||_2^2+\alpha||\beta||_1.$$ alpha=1 is the lasso penalty, and alpha=0 the ridge penalty.
intercept: Should intercept be fitted (default=TRUE) or set to zero (FALSE)?
thresh: Convergence threshold for coordinate descent. Each inner coordinate-descent loop continues until the maximum change in the objective after any coefficient update is less than thresh times the null deviance. Default value is 1e-7.
maxit: Maximum number of passes over the data; default is 10^5. (If a warm start object is provided, the number of passes the warm start object performed is included.)
penalty.factor: Separate penalty factors can be applied to each coefficient. This is a number that multiplies lambda to allow differential shrinkage. Can be 0 for some variables, which implies no shrinkage, and that variable is always included in the model. Default is 1 for all variables (and implicitly infinity for variables listed in exclude). Note: the penalty factors are internally rescaled to sum to nvars.
exclude: Indices of variables to be excluded from the model. Default is none. Equivalent to an infinite penalty factor.
lower.limits: Vector of lower limits for each coefficient; default -Inf. Each of these must be non-positive. Can be presented as a single value (which will then be replicated), else a vector of length nvars.
upper.limits: Vector of upper limits for each coefficient; default Inf. See lower.limits.
warm: Either a glmnetfit object or a list (with names beta and a0 containing coefficients and intercept respectively) which can be used as a warm start. Default is NULL, indicating no warm start. For internal use only.
from.glmnet.fit: Was elnet.fit() called from glmnet.fit()? Default is FALSE.This has implications for computation of the penalty factors.
save.fit: Return the warm start object? Default is FALSE.

Value

An object with class "glmnetfit" and "glmnet". The list returned has the same keys as that of a glmnet object, except that it might have an additional warm_fit key.

a0: Intercept value.
beta: A nvars x 1 matrix of coefficients, stored in sparse matrix format.
df: The number of nonzero coefficients.
dim: Dimension of coefficient matrix.
lambda: Lambda value used.
dev.ratio: The fraction of (null) deviance explained. The deviance calculations incorporate weights if present in the model. The deviance is defined to be 2*(loglike_sat - loglike), where loglike_sat is the log-likelihood for the saturated model (a model with a free parameter per observation). Hence dev.ratio=1-dev/nulldev.
nulldev: Null deviance (per observation). This is defined to be 2*(loglike_sat -loglike(Null)). The null model refers to the intercept model.
npasses: Total passes over the data.
jerr: Error flag, for warnings and errors (largely for internal debugging).
offset: Always FALSE, since offsets do not appear in the WLS problem. Included for compability with glmnet output.
call: The call that produced this object.
nobs: Number of observations.
warm_fit: If save.fit=TRUE, output of C++ routine, used for warm starts. For internal use only.

Details

WARNING: Users should not call elnet.fit directly. Higher-level functions in this package call elnet.fit as a subroutine. If a warm start object is provided, some of the other arguments in the function may be overriden.

elnet.fit is essentially a wrapper around a C++ subroutine which minimizes

$$1/2 \sum w_i (y_i - X_i^T \beta)^2 + \sum \lambda \gamma_j [(1-\alpha)/2 \beta^2+\alpha|\beta|],$$

over $\beta$, where $\gamma_j$ is the relative penalty factor on the jth variable. If intercept = TRUE, then the term in the first sum is $w_i (y_i - \beta_0 - X_i^T \beta)^2$, and we are minimizing over both $\beta_0$ and $\beta$.

None of the inputs are standardized except for penalty.factor, which is standardized so that they sum up to nvars.