Movatterモバイル変換

Elastic net model paths for some generalized linear models

Description

This package fits lasso and elastic-net model paths for regression, logisticand multinomial regression using coordinate descent. The algorithm isextremely fast, and exploits sparsity in the input x matrix where it exists.A variety of predictions can be made from the fitted models.

Details

Very simple to use. Acceptsx,y data for regression models, andproduces the regularization path over a grid of values for the tuningparameterlambda. Only 5 functions:glmnet
predict.glmnet
plot.glmnet
print.glmnet
coef.glmnet

Author(s)

Jerome Friedman, Trevor Hastie and Rob Tibshirani
Maintainer:Trevor Hastiehastie@stanford.edu

References

Friedman, J., Hastie, T. and Tibshirani, R. (2008)Regularization Paths for Generalized Linear Models via CoordinateDescent (2010), Journal of Statistical Software, Vol. 33(1), 1-22,doi:10.18637/jss.v033.i01.
Simon, N., Friedman, J., Hastie, T. and Tibshirani, R. (2011)Regularization Paths for Cox's ProportionalHazards Model via Coordinate Descent, Journal of Statistical Software, Vol.39(5), 1-13,doi:10.18637/jss.v039.i05.
Tibshirani,Robert, Bien, J., Friedman, J., Hastie, T.,Simon, N.,Taylor, J. andTibshirani, Ryan. (2012)Strong Rules for Discarding Predictors inLasso-type Problems, JRSSB, Vol. 74(2), 245-266,https://arxiv.org/abs/1011.2234.
Hastie, T., Tibshirani, Robert and Tibshirani, Ryan (2020)Best Subset,Forward Stepwise or Lasso? Analysis and Recommendations Based on Extensive Comparisons,Statist. Sc. Vol. 35(4), 579-592,https://arxiv.org/abs/1707.08692.
Glmnet webpage with four vignettes:https://glmnet.stanford.edu.

See Also

Useful links:

• https://glmnet.stanford.edu

Examples

x = matrix(rnorm(100 * 20), 100, 20)y = rnorm(100)g2 = sample(1:2, 100, replace = TRUE)g4 = sample(1:4, 100, replace = TRUE)fit1 = glmnet(x, y)predict(fit1, newx = x[1:5, ], s = c(0.01, 0.005))predict(fit1, type = "coef")plot(fit1, xvar = "lambda")fit2 = glmnet(x, g2, family = "binomial")predict(fit2, type = "response", newx = x[2:5, ])predict(fit2, type = "nonzero")fit3 = glmnet(x, g4, family = "multinomial")predict(fit3, newx = x[1:3, ], type = "response", s = 0.01)

Synthetic dataset with binary response

Description

Randomly generated data for binomial regression example.

Usage

data(BinomialExample)

Format

List containing the following elements:

x

100 by 30 matrix of numeric values.

y

Numeric vector of length 100 containing 44 zeros and 56 ones.

compute C index for a Cox model

Description

Computes Harrel's C index for predictions from a"coxnet" object.

Usage

Cindex(pred, y, weights = rep(1, nrow(y)))

Arguments

Details

Computes the concordance index, taking into account censoring.

Author(s)

Trevor Hastiehastie@stanford.edu

References

Harrel Jr, F. E. and Lee, K. L. and Mark, D. B. (1996)Tutorial in biostatistics: multivariable prognostic models: issues indeveloping models, evaluating assumptions and adequacy, and measuring andreducing error, Statistics in Medicine, 15, pages 361–387.

See Also

cv.glmnet

Examples

set.seed(10101)N = 1000p = 30nzc = p/3x = matrix(rnorm(N * p), N, p)beta = rnorm(nzc)fx = x[, seq(nzc)] %*% beta/3hx = exp(fx)ty = rexp(N, hx)tcens = rbinom(n = N, prob = 0.3, size = 1)  # censoring indicatory = cbind(time = ty, status = 1 - tcens)  # y=Surv(ty,1-tcens) with library(survival)fit = glmnet(x, y, family = "cox")pred = predict(fit, newx = x)apply(pred, 2, Cindex, y=y)cv.glmnet(x, y, family = "cox", type.measure = "C")

Synthetic dataset with right-censored survival response

Description

Randomly generated data for Cox regression example.

Usage

data(CoxExample)

Format

List containing the following elements:

x

1,000 by 30 matrix of numeric values.

y

1,000 by 2 matrix with column names "time" and "status". Thefirst column consists of positive numbers representing time to event,while the second column represents the status indicator(0=right-censored, 1=observed).

Synthetic dataset with multiple Gaussian responses

Description

Randomly generated data for multi-response Gaussian regression example.

Usage

data(MultiGaussianExample)

Format

List containing the following elements:

x

100 by 20 matrix of numeric values.

y

100 by 4 matrix of numeric values, each column representingone response vector.

Synthetic dataset with multinomial response

Description

Randomly generated data for multinomial regression example.

Usage

data(MultinomialExample)

Format

List containing the following elements:

x

500 by 30 matrix of numeric values.

y

Numeric vector of length 500 containing 142 ones, 174 twosand 184 threes.

Synthetic dataset with count response

Description

Randomly generated data for Poisson regression example.

Usage

data(PoissonExample)

Format

List containing the following elements:

x

500 by 20 matrix of numeric values.

y

Numeric vector of length 500 consisting of non-negativeintegers.

Synthetic dataset with Gaussian response

Description

Randomly generated data for Gaussian regression example.

Usage

data(QuickStartExample)

Format

List containing the following elements:

x

100 by 20 matrix of numeric values.

y

Numeric vector of length 100.

Synthetic dataset with sparse design matrix

Description

Randomly generated data for Gaussian regression example with thedesign matrix x being in sparse matrix format.

Usage

data(SparseExample)

Format

List containing the following elements:

x

100 by 20 matrix of numeric values. x is in sparse matrixformat, having class "dgCMatrix".

y

Numeric vector of length 100.

assess performance of a 'glmnet' object using test data.

Description

Given a test set, produce summary performance measures for the glmnetmodel(s)

Usage

assess.glmnet(  object,  newx = NULL,  newy,  weights = NULL,  family = c("gaussian", "binomial", "poisson", "multinomial", "cox", "mgaussian"),  ...)confusion.glmnet(  object,  newx = NULL,  newy,  family = c("binomial", "multinomial"),  ...)roc.glmnet(object, newx = NULL, newy, ...)

Arguments

Details

assess.glmnet produces all the different performance measuresprovided bycv.glmnet for each of the families. A single vector, or amatrix of predictions can be provided, or fitted model objects or CVobjects. In the case when the predictions are still to be made, the... arguments allow, for example, 'offsets' and other predictionparameters such as values for 'gamma' for 'relaxed' fits.roc.glmnetproduces for a single vector a two column matrix with columns TPR and FPR(true positive rate and false positive rate). This object can be plotted toproduce an ROC curve. If more than one predictions are called for, then alist of such matrices is produced.confusion.glmnet produces aconfusion matrix tabulating the classification results. Again, a singletable or a list, with a print method.

Value

assess.glmnet produces a list of vectors of measures.roc.glmnet a list of 'roc' two-column matrices, andconfusion.glmnet a list of tables. If a single prediction isprovided, or predictions are made from a CV object, the latter two drop thelist status and produce a single matrix or table.

Author(s)

Trevor Hastie and Rob Tibshirani
Maintainer: Trevor Hastiehastie@stanford.edu

See Also

cv.glmnet,glmnet.measures andvignette("relax",package="glmnet")

Examples

data(QuickStartExample)x <- QuickStartExample$x; y <- QuickStartExample$yset.seed(11)train = sample(seq(length(y)),70,replace=FALSE)fit1 = glmnet(x[train,], y[train])assess.glmnet(fit1, newx = x[-train,], newy = y[-train])preds = predict(fit1, newx = x[-train, ], s = c(1, 0.25))assess.glmnet(preds, newy = y[-train], family = "gaussian")fit1c = cv.glmnet(x, y, keep = TRUE)fit1a = assess.glmnet(fit1c$fit.preval, newy=y,family="gaussian")plot(fit1c$lambda, log="x",fit1a$mae,xlab="Log Lambda",ylab="Mean Absolute Error")abline(v=fit1c$lambda.min, lty=2, col="red")data(BinomialExample)x <- BinomialExample$x; y <- BinomialExample$yfit2 = glmnet(x[train,], y[train], family = "binomial")assess.glmnet(fit2,newx = x[-train,], newy=y[-train], s=0.1)plot(roc.glmnet(fit2, newx = x[-train,], newy=y[-train])[[10]])fit2c = cv.glmnet(x, y, family = "binomial", keep=TRUE)idmin = match(fit2c$lambda.min, fit2c$lambda)plot(roc.glmnet(fit2c$fit.preval, newy = y)[[idmin]])data(MultinomialExample)x <- MultinomialExample$x; y <- MultinomialExample$yset.seed(103)train = sample(seq(length(y)),100,replace=FALSE)fit3 = glmnet(x[train,], y[train], family = "multinomial")confusion.glmnet(fit3, newx = x[-train, ], newy = y[-train], s = 0.01)fit3c = cv.glmnet(x, y, family = "multinomial", type.measure="class", keep=TRUE)idmin = match(fit3c$lambda.min, fit3c$lambda)confusion.glmnet(fit3c$fit.preval, newy = y, family="multinomial")[[idmin]]

Simulated data for the glmnet vignette

Description

Simple simulated data, used to demonstrate the features of glmnet

Format

Data objects used to demonstrate features in the glmnet vignette

Details

These datasets are artificial, and are used to test out some of thefeatures of glmnet.

Examples

data(QuickStartExample)x <- QuickStartExample$x; y <- QuickStartExample$yglmnet(x, y)

fit a glm with all the options inglmnet

Description

Fit a generalized linear model as inglmnet but unpenalized. Thisallows all the features ofglmnet such as sparse x, bounds oncoefficients, offsets, and so on.

Usage

bigGlm(x, ..., path = FALSE)

Arguments

Details

This is essentially the same as fitting a "glmnet" model with a single valuelambda=0, but it avoids some edge cases. CAVEAT: If the user tries aproblem with N smaller than or close to p for some models, it is likely tofail (and maybe not gracefully!) If so, use thepath=TRUE argument.

Value

It returns an object of class "bigGlm" that inherits from class"glmnet". That means it can be predicted from, coefficients extracted viacoef. It has its own print method.

Author(s)

Trevor Hastie
Maintainer: Trevor Hastiehastie@stanford.edu

See Also

print,predict, andcoef methods.

Examples

# Gaussianx = matrix(rnorm(100 * 20), 100, 20)y = rnorm(100)fit1 = bigGlm(x, y)print(fit1)fit2=bigGlm(x,y>0,family="binomial")print(fit2)fit2p=bigGlm(x,y>0,family="binomial",path=TRUE)print(fit2p)

Extract coefficients from a glmnet object

Description

Similar to other predict methods, this functions predicts fitted values,logits, coefficients and more from a fitted"glmnet" object.

Usage

## S3 method for class 'glmnet'coef(object, s = NULL, exact = FALSE, ...)## S3 method for class 'glmnet'predict(  object,  newx,  s = NULL,  type = c("link", "response", "coefficients", "nonzero", "class"),  exact = FALSE,  newoffset,  ...)## S3 method for class 'relaxed'predict(  object,  newx,  s = NULL,  gamma = 1,  type = c("link", "response", "coefficients", "nonzero", "class"),  exact = FALSE,  newoffset,  ...)

Arguments

Details

The shape of the objects returned are different for"multinomial"objects. This function actually callsNextMethod(), and theappropriate predict method is invoked for each of the three model types.coef(...) is equivalent topredict(type="coefficients",...)

Value

The object returned depends on type.

Author(s)

Jerome Friedman, Trevor Hastie and Rob Tibshirani
Maintainer:Trevor Hastiehastie@stanford.edu

References

Friedman, J., Hastie, T. and Tibshirani, R. (2008)Regularization Paths for Generalized Linear Models via CoordinateDescent (2010), Journal of Statistical Software, Vol. 33(1), 1-22,doi:10.18637/jss.v033.i01.
Simon, N., Friedman, J., Hastie, T. and Tibshirani, R. (2011)Regularization Paths for Cox's ProportionalHazards Model via Coordinate Descent, Journal of Statistical Software, Vol.39(5), 1-13,doi:10.18637/jss.v039.i05.
Glmnet webpage with four vignettes,https://glmnet.stanford.edu.

See Also

glmnet, andprint, andcoef methods, andcv.glmnet.

Examples

x=matrix(rnorm(100*20),100,20)y=rnorm(100)g2=sample(1:2,100,replace=TRUE)g4=sample(1:4,100,replace=TRUE)fit1=glmnet(x,y)predict(fit1,newx=x[1:5,],s=c(0.01,0.005))predict(fit1,type="coef")fit2=glmnet(x,g2,family="binomial")predict(fit2,type="response",newx=x[2:5,])predict(fit2,type="nonzero")fit3=glmnet(x,g4,family="multinomial")predict(fit3,newx=x[1:3,],type="response",s=0.01)

Fit a Cox regression model with elastic net regularization for a singlevalue of lambda

Description

Fit a Cox regression model via penalized maximum likelihood for a singlevalue of lambda. Can deal with (start, stop] data and strata, as well assparse design matrices.

Usage

cox.fit(  x,  y,  weights,  lambda,  alpha = 1,  offset = rep(0, nobs),  thresh = 1e-10,  maxit = 1e+05,  penalty.factor = rep(1, nvars),  exclude = c(),  lower.limits = -Inf,  upper.limits = Inf,  warm = NULL,  from.cox.path = FALSE,  save.fit = FALSE,  trace.it = 0)

Arguments

Details

WARNING: Users should not callcox.fit directly. Higher-levelfunctions in this package callcox.fit as a subroutine. If awarm start object is provided, some of the other arguments in the functionmay be overriden.

cox.fit solves the elastic net problem for a single, user-specifiedvalue of lambda.cox.fit works for Cox regression models, including(start, stop] data and strata. It solves the problem using iterativelyreweighted least squares (IRLS). For each IRLS iteration,cox.fitmakes a quadratic (Newton) approximation of the log-likelihood, then callselnet.fit to minimize the resulting approximation.

In terms of standardization:cox.fit does not standardizexandweights.penalty.factor is standardized so that they sumup tonvars.

Value

An object with class "coxnet", "glmnetfit" and "glmnet". The listreturned contains more keys than that of a "glmnet" object.

Fit a Cox regression model with elastic net regularization for a path oflambda values

Description

Fit a Cox regression model via penalized maximum likelihood for a path oflambda values. Can deal with (start, stop] data and strata, as well assparse design matrices.

Usage

cox.path(  x,  y,  weights = NULL,  offset = NULL,  alpha = 1,  nlambda = 100,  lambda.min.ratio = ifelse(nobs < nvars, 0.01, 1e-04),  lambda = NULL,  standardize = TRUE,  thresh = 1e-10,  exclude = NULL,  penalty.factor = rep(1, nvars),  lower.limits = -Inf,  upper.limits = Inf,  maxit = 1e+05,  trace.it = 0,  ...)

Arguments

Details

Sometimes the sequence is truncated beforenlambda values of lambdahave been used. This happens whencox.path detects that thedecrease in deviance is marginal (i.e. we are near a saturated fit).

Value

An object of class "coxnet" and "glmnet".

Examples

set.seed(2)nobs <- 100; nvars <- 15xvec <- rnorm(nobs * nvars)xvec[sample.int(nobs * nvars, size = 0.4 * nobs * nvars)] <- 0x <- matrix(xvec, nrow = nobs)beta <- rnorm(nvars / 3)fx <- x[, seq(nvars / 3)] %*% beta / 3ty <- rexp(nobs, exp(fx))tcens <- rbinom(n = nobs, prob = 0.3, size = 1)jsurv <- survival::Surv(ty, tcens)fit1 <- glmnet:::cox.path(x, jsurv)# works with sparse x matrixx_sparse <- Matrix::Matrix(x, sparse = TRUE)fit2 <- glmnet:::cox.path(x_sparse, jsurv)# example with (start, stop] dataset.seed(2)start_time <- runif(100, min = 0, max = 5)stop_time <- start_time + runif(100, min = 0.1, max = 3)status <- rbinom(n = nobs, prob = 0.3, size = 1)jsurv_ss <- survival::Surv(start_time, stop_time, status)fit3 <- glmnet:::cox.path(x, jsurv_ss)# example with stratajsurv_ss2 <- stratifySurv(jsurv_ss, rep(1:2, each = 50))fit4 <- glmnet:::cox.path(x, jsurv_ss2)

Elastic net objective function value for Cox regression model

Description

Returns the elastic net objective function value for Cox regression model.

Usage

cox_obj_function(y, pred, weights, lambda, alpha, coefficients, vp)

Arguments

Compute gradient for Cox model

Description

Compute the gradient of the log partial likelihood at a particular fit for Coxmodel.

Usage

coxgrad(eta, y, w, std.weights = TRUE, diag.hessian = FALSE)

Arguments

Details

Compute a gradient vector at the fitted vector for the log partial likelihood.This is like a residual vector, and useful for manual screening ofpredictors forglmnet in applications wherep is very large(as in GWAS). Uses the Breslow approach to ties.

This function is essentially a wrapper: it checks whether the responseprovided is right-censored or (start, stop] survival data, and calls theappropriate internal routine.

Value

A single gradient vector the same length aseta. Ifdiag.hessian=TRUE, the diagonal of the Hessian isincluded as an attribute "diag_hessian".

See Also

coxnet.deviance

Examples

set.seed(1)eta <- rnorm(10)time <- runif(10, min = 1, max = 10)d <- ifelse(rnorm(10) > 0, 1, 0)y <- survival::Surv(time, d)coxgrad(eta, y)# return diagonal of Hessian as wellcoxgrad(eta, y, diag.hessian = TRUE)# example with (start, stop] datay2 <- survival::Surv(time, time + runif(10), d)coxgrad(eta, y2)# example with stratay2 <- stratifySurv(y, rep(1:2, length.out = 10))coxgrad(eta, y2)

Compute deviance for Cox model

Description

Compute the deviance (-2 log partial likelihood) for Cox model.

Usage

coxnet.deviance(  pred = NULL,  y,  x = NULL,  offset = NULL,  weights = NULL,  std.weights = TRUE,  beta = NULL)

Arguments

Details

Computes the deviance for a single set of predictions, or for a matrixof predictions. The user can either supply the predictionsdirectly through thepred option, or by supplying thex matrixandbeta coefficients. Uses the Breslow approach to ties.

The function first checks ifpred is passed: if so, it is used asthe predictions. Ifpred is not passed butx andbetaare passed, then these values are used to compute the predictions. Ifneitherx norbeta are passed, then the predictions are alltaken to be 0.

coxnet.deviance() is a wrapper: it calls the appropriate internalroutine based on whether the response is right-censored data or(start, stop] survival data.

Value

A vector of deviances, one for each column of predictions.

See Also

coxgrad

Examples

set.seed(1)eta <- rnorm(10)time <- runif(10, min = 1, max = 10)d <- ifelse(rnorm(10) > 0, 1, 0)y <- survival::Surv(time, d)coxnet.deviance(pred = eta, y = y)# if pred not provided, it is set to zero vectorcoxnet.deviance(y = y)# example with x and betax <- matrix(rnorm(10 * 3), nrow = 10)beta <- matrix(1:3, ncol = 1)coxnet.deviance(y = y, x = x, beta = beta)# example with (start, stop] datay2 <- survival::Surv(time, time + runif(10), d)coxnet.deviance(pred = eta, y = y2)# example with stratay2 <- stratifySurv(y, rep(1:2, length.out = 10))coxnet.deviance(pred = eta, y = y2)

Cross-validation for glmnet

Description

Does k-fold cross-validation for glmnet, produces a plot, and returns avalue forlambda (andgamma ifrelax=TRUE)

Usage

cv.glmnet(  x,  y,  weights = NULL,  offset = NULL,  lambda = NULL,  type.measure = c("default", "mse", "deviance", "class", "auc", "mae", "C"),  nfolds = 10,  foldid = NULL,  alignment = c("lambda", "fraction"),  grouped = TRUE,  keep = FALSE,  parallel = FALSE,  gamma = c(0, 0.25, 0.5, 0.75, 1),  relax = FALSE,  trace.it = 0,  ...)

Arguments

Details

The function runsglmnetnfolds+1 times; the first to get thelambda sequence, and then the remainder to compute the fit with eachof the folds omitted. The error is accumulated, and the average error andstandard deviation over the folds is computed. Note thatcv.glmnetdoes NOT search for values foralpha. A specific value should besupplied, elsealpha=1 is assumed by default. If users would like tocross-validatealpha as well, they should callcv.glmnet witha pre-computed vectorfoldid, and then use this same fold vector inseparate calls tocv.glmnet with different values ofalpha.Note also that the results ofcv.glmnet are random, since the foldsare selected at random. Users can reduce this randomness by runningcv.glmnet many times, and averaging the error curves.

Ifrelax=TRUE then the values ofgamma are used to mix thefits. If\eta is the fit for lasso/elastic net, and\eta_R isthe relaxed fit (with unpenalized coefficients), then a relaxed fit mixed by\gamma is

\eta(\gamma)=(1-\gamma)\eta_R+\gamma\eta.

There ispractically no extra cost for having a lot of values forgamma.However, 5 seems sufficient for most purposes. CV then selects bothgamma andlambda.

Value

an object of class"cv.glmnet" is returned, which is a listwith the ingredients of the cross-validation fit. If the object was createdwithrelax=TRUE then this class has a prefix class of"cv.relaxed".

Author(s)

Jerome Friedman, Trevor Hastie and Rob Tibshirani
Noah Simonhelped develop the 'coxnet' function.
Jeffrey Wong and B. Narasimhanhelped with the parallel option
Maintainer: Trevor Hastiehastie@stanford.edu

References

Friedman, J., Hastie, T. and Tibshirani, R. (2008)Regularization Paths for Generalized Linear Models via CoordinateDescent (2010), Journal of Statistical Software, Vol. 33(1), 1-22,doi:10.18637/jss.v033.i01.
Simon, N., Friedman, J., Hastie, T. and Tibshirani, R. (2011)Regularization Paths for Cox's ProportionalHazards Model via Coordinate Descent, Journal of Statistical Software, Vol.39(5), 1-13,doi:10.18637/jss.v039.i05.

See Also

glmnet andplot,predict, andcoefmethods for"cv.glmnet" and"cv.relaxed" objects.

Examples

set.seed(1010)n = 1000p = 100nzc = trunc(p/10)x = matrix(rnorm(n * p), n, p)beta = rnorm(nzc)fx = x[, seq(nzc)] %*% betaeps = rnorm(n) * 5y = drop(fx + eps)px = exp(fx)px = px/(1 + px)ly = rbinom(n = length(px), prob = px, size = 1)set.seed(1011)cvob1 = cv.glmnet(x, y)plot(cvob1)coef(cvob1)predict(cvob1, newx = x[1:5, ], s = "lambda.min")title("Gaussian Family", line = 2.5)set.seed(1011)cvob1a = cv.glmnet(x, y, type.measure = "mae")plot(cvob1a)title("Gaussian Family", line = 2.5)set.seed(1011)par(mfrow = c(2, 2), mar = c(4.5, 4.5, 4, 1))cvob2 = cv.glmnet(x, ly, family = "binomial")plot(cvob2)title("Binomial Family", line = 2.5)frame()set.seed(1011)cvob3 = cv.glmnet(x, ly, family = "binomial", type.measure = "class")plot(cvob3)title("Binomial Family", line = 2.5)## Not run: cvob1r = cv.glmnet(x, y, relax = TRUE)plot(cvob1r)predict(cvob1r, newx = x[, 1:5])set.seed(1011)cvob3a = cv.glmnet(x, ly, family = "binomial", type.measure = "auc")plot(cvob3a)title("Binomial Family", line = 2.5)set.seed(1011)mu = exp(fx/10)y = rpois(n, mu)cvob4 = cv.glmnet(x, y, family = "poisson")plot(cvob4)title("Poisson Family", line = 2.5)# Multinomialn = 500p = 30nzc = trunc(p/10)x = matrix(rnorm(n * p), n, p)beta3 = matrix(rnorm(30), 10, 3)beta3 = rbind(beta3, matrix(0, p - 10, 3))f3 = x %*% beta3p3 = exp(f3)p3 = p3/apply(p3, 1, sum)g3 = glmnet:::rmult(p3)set.seed(10101)cvfit = cv.glmnet(x, g3, family = "multinomial")plot(cvfit)title("Multinomial Family", line = 2.5)# Coxbeta = rnorm(nzc)fx = x[, seq(nzc)] %*% beta/3hx = exp(fx)ty = rexp(n, hx)tcens = rbinom(n = n, prob = 0.3, size = 1)  # censoring indicatory = cbind(time = ty, status = 1 - tcens)  # y=Surv(ty,1-tcens) with library(survival)foldid = sample(rep(seq(10), length = n))fit1_cv = cv.glmnet(x, y, family = "cox", foldid = foldid)plot(fit1_cv)title("Cox Family", line = 2.5)# Parallelrequire(doMC)registerDoMC(cores = 4)x = matrix(rnorm(1e+05 * 100), 1e+05, 100)y = rnorm(1e+05)system.time(cv.glmnet(x, y))system.time(cv.glmnet(x, y, parallel = TRUE))## End(Not run)

Elastic net deviance value

Description

Returns the elastic net deviance value.

Usage

dev_function(y, mu, weights, family)

Arguments

Extract the deviance from a glmnet object

Description

Compute the deviance sequence from the glmnet object

Usage

## S3 method for class 'glmnet'deviance(object, ...)

Arguments

Details

A glmnet object has componentsdev.ratio andnulldev. Theformer is the fraction of (null) deviance explained. The deviancecalculations incorporate weights if present in the model. The deviance isdefined to be 2*(loglike_sat - loglike), where loglike_sat is thelog-likelihood for the saturated model (a model with a free parameter perobservation). Null deviance is defined to be 2*(loglike_sat-loglike(Null)); The NULL model refers to the intercept model, except forthe Cox, where it is the 0 model. Hence dev.ratio=1-deviance/nulldev, andthisdeviance method returns (1-dev.ratio)*nulldev.

Value

(1-dev.ratio)*nulldev

Author(s)

Jerome Friedman, Trevor Hastie and Rob Tibshirani
Maintainer:Trevor Hastiehastie@stanford.edu

References

Friedman, J., Hastie, T. and Tibshirani, R. (2008)Regularization Paths for Generalized Linear Models via CoordinateDescent

See Also

glmnet,predict,print, andcoefmethods.

Examples

x = matrix(rnorm(100 * 20), 100, 20)y = rnorm(100)fit1 = glmnet(x, y)deviance(fit1)

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

Description

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

Usage

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

Details

WARNING: Users should not callelnet.fit directly. Higher-level functionsin this package callelnet.fit as a subroutine. If a warm start objectis provided, some of the other arguments in the function may be overriden.

elnet.fit is essentially a wrapper around a C++ subroutine whichminimizes

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 thejth variable. Ifintercept = TRUE, then the term in the first sum isw_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 forpenalty.factor, whichis standardized so that they sum up tonvars.

Value

An object with class "glmnetfit" and "glmnet". The list returned hasthe same keys as that of aglmnet object, except that it might have anadditionalwarm_fit key.

Helper function for Cox deviance and gradient

Description

Helps to find ties in death times of data.

Usage

fid(x, index)

Arguments

Value

A list with two arguments.

Examples

# Example with no tiesglmnet:::fid(c(1, 4, 5, 6), 1:5)# Example with tiesglmnet:::fid(c(1, 1, 1, 2, 3, 3, 4, 4, 4), 1:9)

Get lambda max for Cox regression model

Description

Return the lambda max value for Cox regression model, used for computinginitial lambda values. For internal use only.

Usage

get_cox_lambda_max(  x,  y,  alpha,  weights = rep(1, nrow(x)),  offset = rep(0, nrow(x)),  exclude = c(),  vp = rep(1, ncol(x)))

Arguments

Details

This function is called bycox.path for the value of lambda max.

Whenx is not sparse, it is expected to already by centered and scaled.Whenx is sparse, the function will get its attributesxm andxs for its centering and scaling factors. The value oflambda_max changes depending on whetherx is centered andscaled or not, so we needxm andxs to get the correct value.

Helper function to get etas (linear predictions)

Description

Given x, coefficients and intercept, return linear predictions. Wrapper thatworks with both regular and sparse x. Only works for single set of coefficientsand intercept.

Usage

get_eta(x, beta, a0)

Arguments

Get null deviance, starting mu and lambda max

Description

Return the null deviance, starting mu and lambda max values forinitialization. For internal use only.

Usage

get_start(  x,  y,  weights,  family,  intercept,  is.offset,  offset,  exclude,  vp,  alpha)

Arguments

Details

This function is called byglmnet.path for null deviance, starting muand lambda max values. It is also called byglmnet.fit when usedwithout warmstart, but they only use the null deviance and starting mu values.

Whenx is not sparse, it is expected to already by centered and scaled.Whenx is sparse, the function will get its attributesxm andxs for its centering and scaling factors.

Note that whetherx is centered & scaled or not, the values ofmuandnulldev don't change. However, the value oflambda_max doeschange, and we needxm andxs to get the correct value.

fit a GLM with lasso or elasticnet regularization

Description

Fit a generalized linear model via penalized maximum likelihood. Theregularization path is computed for the lasso or elasticnet penalty at agrid of values for the regularization parameter lambda. Can deal with allshapes of data, including very large sparse data matrices. Fits linear,logistic and multinomial, poisson, and Cox regression models.

Usage

glmnet(  x,  y,  family = c("gaussian", "binomial", "poisson", "multinomial", "cox", "mgaussian"),  weights = NULL,  offset = NULL,  alpha = 1,  nlambda = 100,  lambda.min.ratio = ifelse(nobs < nvars, 0.01, 1e-04),  lambda = NULL,  standardize = TRUE,  intercept = TRUE,  thresh = 1e-07,  dfmax = nvars + 1,  pmax = min(dfmax * 2 + 20, nvars),  exclude = NULL,  penalty.factor = rep(1, nvars),  lower.limits = -Inf,  upper.limits = Inf,  maxit = 1e+05,  type.gaussian = ifelse(nvars < 500, "covariance", "naive"),  type.logistic = c("Newton", "modified.Newton"),  standardize.response = FALSE,  type.multinomial = c("ungrouped", "grouped"),  relax = FALSE,  trace.it = 0,  ...)relax.glmnet(fit, x, ..., maxp = n - 3, path = FALSE, check.args = TRUE)

Arguments

Details

The sequence of models implied bylambda is fit by coordinatedescent. Forfamily="gaussian" this is the lasso sequence ifalpha=1, else it is the elasticnet sequence.

The objective function for"gaussian" is

1/2 RSS/nobs +\lambda*penalty,

and for the other models it is

-loglik/nobs +\lambda*penalty.

Note also that for"gaussian",glmnetstandardizes y to have unit variance (using 1/n rather than 1/(n-1) formula)before computing its lambda sequence (and then unstandardizes the resultingcoefficients); if you wish to reproduce/compare results with other software,best to supply a standardized y. The coefficients for any predictorvariables with zero variance are set to zero for all values of lambda.

Details onfamily option

From version 4.0 onwards, glmnet supports both the original built-in families,as well asany family object as used bystats:glm().This opens the door to a wide variety of additional models. For examplefamily=binomial(link=cloglog) orfamily=negative.binomial(theta=1.5) (from the MASS library).Note that the code runs faster for the built-in families.

The built in families are specifed via a character string. For all families,the object produced is a lasso or elasticnet regularization path for fitting thegeneralized linear regression paths, by maximizing the appropriate penalizedlog-likelihood (partial likelihood for the "cox" model). Sometimes thesequence is truncated beforenlambda values oflambda havebeen used, because of instabilities in the inverse link functions near asaturated fit.glmnet(...,family="binomial") fits a traditionallogistic regression model for the log-odds.glmnet(...,family="multinomial") fits a symmetric multinomial model,where each class is represented by a linear model (on the log-scale). Thepenalties take care of redundancies. A two-class"multinomial" modelwill produce the same fit as the corresponding"binomial" model,except the pair of coefficient matrices will be equal in magnitude andopposite in sign, and half the"binomial" values.Two useful additional families are thefamily="mgaussian" family andthetype.multinomial="grouped" option for multinomial fitting. Theformer allows a multi-response gaussian model to be fit, using a "group-lasso" penalty on the coefficients for each variable. Tying the responsestogether like this is called "multi-task" learning in some domains. Thegrouped multinomial allows the same penalty for thefamily="multinomial" model, which is also multi-responsed. For bothof these the penalty on the coefficient vector for variable j is

(1-\alpha)/2||\beta_j||_2^2+\alpha||\beta_j||_2.

Whenalpha=1this is a group-lasso penalty, and otherwise it mixes with quadratic justlike elasticnet. A small detail in the Cox model: if death times are tiedwith censored times, we assume the censored times occurred justbefore the death times in computing the Breslow approximation; ifusers prefer the usual convention ofafter, they can add a smallnumber to all censoring times to achieve this effect.

Details on response forfamily="cox"

For Cox models, the response should preferably be aSurv object,created by theSurv() function insurvival package. Forright-censored data, this object should have type "right", and for(start, stop] data, it should have type "counting". To fit stratified Coxmodels, strata should be added to the response via thestratifySurv()function before passing the response toglmnet(). (For backwardcompatibility, right-censored data can also be passed as atwo-column matrix with columns named 'time' and 'status'. Thelatter is a binary variable, with '1' indicating death, and '0' indicatingright censored.)

Details onrelax option

Ifrelax=TRUEa duplicate sequence of models is produced, where each active set in theelastic-net path is refit without regularization. The result of this is amatching"glmnet" object which is stored on the original object in acomponent named"relaxed", and is part of the glmnet output.Generally users will not callrelax.glmnet directly, unless theoriginal 'glmnet' object took a long time to fit. But if they do, they mustsupply the fit, and all the original arguments used to create that fit. Theycan limit the length of the relaxed path via 'maxp'.

Value

An object with S3 class"glmnet","*", where"*" is"elnet","lognet","multnet","fishnet"(poisson),"coxnet" or"mrelnet" for the various types ofmodels. If the model was created withrelax=TRUE then this class hasa prefix class of"relaxed".

Author(s)

Jerome Friedman, Trevor Hastie, Balasubramanian Narasimhan, NoahSimon, Kenneth Tay and Rob Tibshirani
Maintainer: Trevor Hastiehastie@stanford.edu

References

Friedman, J., Hastie, T. and Tibshirani, R. (2008)Regularization Paths for Generalized Linear Models via CoordinateDescent (2010), Journal of Statistical Software, Vol. 33(1), 1-22,doi:10.18637/jss.v033.i01.
Simon, N., Friedman, J., Hastie, T. and Tibshirani, R. (2011)Regularization Paths for Cox's ProportionalHazards Model via Coordinate Descent, Journal of Statistical Software, Vol.39(5), 1-13,doi:10.18637/jss.v039.i05.
Tibshirani,Robert, Bien, J., Friedman, J., Hastie, T.,Simon, N.,Taylor, J. andTibshirani, Ryan. (2012)Strong Rules for Discarding Predictors inLasso-type Problems, JRSSB, Vol. 74(2), 245-266,https://arxiv.org/abs/1011.2234.
Hastie, T., Tibshirani, Robert and Tibshirani, Ryan (2020)Best Subset,Forward Stepwise or Lasso? Analysis and Recommendations Based on Extensive Comparisons,Statist. Sc. Vol. 35(4), 579-592,https://arxiv.org/abs/1707.08692.
Glmnet webpage with four vignettes:https://glmnet.stanford.edu.

See Also

print,predict,coef andplot methods,and thecv.glmnet function.

Examples

# Gaussianx = matrix(rnorm(100 * 20), 100, 20)y = rnorm(100)fit1 = glmnet(x, y)print(fit1)coef(fit1, s = 0.01)  # extract coefficients at a single value of lambdapredict(fit1, newx = x[1:10, ], s = c(0.01, 0.005))  # make predictions# Relaxedfit1r = glmnet(x, y, relax = TRUE)  # can be used with any model# multivariate gaussiany = matrix(rnorm(100 * 3), 100, 3)fit1m = glmnet(x, y, family = "mgaussian")plot(fit1m, type.coef = "2norm")# binomialg2 = sample(c(0,1), 100, replace = TRUE)fit2 = glmnet(x, g2, family = "binomial")fit2n = glmnet(x, g2, family = binomial(link=cloglog))fit2r = glmnet(x,g2, family = "binomial", relax=TRUE)fit2rp = glmnet(x,g2, family = "binomial", relax=TRUE, path=TRUE)# multinomialg4 = sample(1:4, 100, replace = TRUE)fit3 = glmnet(x, g4, family = "multinomial")fit3a = glmnet(x, g4, family = "multinomial", type.multinomial = "grouped")# poissonN = 500p = 20nzc = 5x = matrix(rnorm(N * p), N, p)beta = rnorm(nzc)f = x[, seq(nzc)] %*% betamu = exp(f)y = rpois(N, mu)fit = glmnet(x, y, family = "poisson")plot(fit)pfit = predict(fit, x, s = 0.001, type = "response")plot(pfit, y)# Coxset.seed(10101)N = 1000p = 30nzc = p/3x = matrix(rnorm(N * p), N, p)beta = rnorm(nzc)fx = x[, seq(nzc)] %*% beta/3hx = exp(fx)ty = rexp(N, hx)tcens = rbinom(n = N, prob = 0.3, size = 1)  # censoring indicatory = cbind(time = ty, status = 1 - tcens)  # y=Surv(ty,1-tcens) with library(survival)fit = glmnet(x, y, family = "cox")plot(fit)# Cox example with (start, stop] dataset.seed(2)nobs <- 100; nvars <- 15xvec <- rnorm(nobs * nvars)xvec[sample.int(nobs * nvars, size = 0.4 * nobs * nvars)] <- 0x <- matrix(xvec, nrow = nobs)start_time <- runif(100, min = 0, max = 5)stop_time <- start_time + runif(100, min = 0.1, max = 3)status <- rbinom(n = nobs, prob = 0.3, size = 1)jsurv_ss <- survival::Surv(start_time, stop_time, status)fit <- glmnet(x, jsurv_ss, family = "cox")# Cox example with stratajsurv_ss2 <- stratifySurv(jsurv_ss, rep(1:2, each = 50))fit <- glmnet(x, jsurv_ss2, family = "cox")# Sparsen = 10000p = 200nzc = trunc(p/10)x = matrix(rnorm(n * p), n, p)iz = sample(1:(n * p), size = n * p * 0.85, replace = FALSE)x[iz] = 0sx = Matrix(x, sparse = TRUE)inherits(sx, "sparseMatrix")  #confirm that it is sparsebeta = rnorm(nzc)fx = x[, seq(nzc)] %*% betaeps = rnorm(n)y = fx + epspx = exp(fx)px = px/(1 + px)ly = rbinom(n = length(px), prob = px, size = 1)system.time(fit1 <- glmnet(sx, y))system.time(fit2n <- glmnet(x, y))

Internal glmnet functions

Description

These are not intended for use by users.lambda.interp does linearinterpolation of the lambdas to obtain a prediction at a new point s.glmnet_softmax does the classification for multinomial models.nonzeroCoef determines in an efficient manner which variables arenonzero in each fit.jerr prints out error messages from the C++ routines.plotCoef is called by theplot method forglmnetobjects.check_dots is used incoef andpredict withargumentexact=TRUE, to make sure user supplies original data used tofit the"glmnet" object.

Author(s)

Trevor Hastie

internal glmnet parameters

Description

View and/or change the factory default parameters in glmnet

Usage

glmnet.control(  fdev = 1e-05,  devmax = 0.999,  eps = 1e-06,  big = 9.9e+35,  mnlam = 5,  pmin = 1e-09,  exmx = 250,  prec = 1e-10,  mxit = 100,  itrace = 0,  epsnr = 1e-06,  mxitnr = 25,  factory = FALSE)

Arguments

Details

If called with no arguments,glmnet.control() returns a list with thecurrent settings of these parameters. Any arguments included in the callsets those parameters to the new values, and then silently returns. Thevalues set are persistent for the duration of the R session.

Value

A list with named elements as in the argument list

Author(s)

Jerome Friedman, Kenneth Tay, Trevor Hastie
Maintainer: Trevor Hastiehastie@stanford.edu

See Also

glmnet

Examples

glmnet.control(fdev = 0)  #continue along path even though not much changesglmnet.control()  # view current settingsglmnet.control(factory = TRUE)  # reset all the parameters to their default

Fit a GLM with elastic net regularization for a single value of lambda

Description

Fit a generalized linear model via penalized maximum likelihood for a singlevalue of lambda. Can deal with any GLM family.

Usage

glmnet.fit(  x,  y,  weights,  lambda,  alpha = 1,  offset = rep(0, nobs),  family = gaussian(),  intercept = TRUE,  thresh = 1e-10,  maxit = 1e+05,  penalty.factor = rep(1, nvars),  exclude = c(),  lower.limits = -Inf,  upper.limits = Inf,  warm = NULL,  from.glmnet.path = FALSE,  save.fit = FALSE,  trace.it = 0)

Arguments

Details

WARNING: Users should not callglmnet.fit directly. Higher-level functionsin this package callglmnet.fit as a subroutine. If a warm start objectis provided, some of the other arguments in the function may be overriden.

glmnet.fit solves the elastic net problem for a single, user-specifiedvalue of lambda.glmnet.fit works for any GLM family. It solves theproblem using iteratively reweighted least squares (IRLS). For each IRLSiteration,glmnet.fit makes a quadratic (Newton) approximation of thelog-likelihood, then callselnet.fit to minimize the resultingapproximation.

In terms of standardization:glmnet.fit does not standardizexandweights.penalty.factor is standardized so that they sum uptonvars.

Value

An object with class "glmnetfit" and "glmnet". The listreturned contains more keys than that of a "glmnet" object.

Display the names of the measures used in CV for different "glmnet" families

Description

Produces a list of names of measures

Usage

glmnet.measures(  family = c("all", "gaussian", "binomial", "poisson", "multinomial", "cox", "mgaussian",    "GLM"))

Arguments

Details

Try it and see. A very simple function to provide information

Author(s)

Trevor Hastie
Maintainer: Trevor Hastiehastie@stanford.edu

See Also

cv.glmnet andassess.glmnet.

Fit a GLM with elastic net regularization for a path of lambda values

Description

Fit a generalized linear model via penalized maximum likelihood for a path oflambda values. Can deal with any GLM family.

Usage

glmnet.path(  x,  y,  weights = NULL,  lambda = NULL,  nlambda = 100,  lambda.min.ratio = ifelse(nobs < nvars, 0.01, 1e-04),  alpha = 1,  offset = NULL,  family = gaussian(),  standardize = TRUE,  intercept = TRUE,  thresh = 1e-10,  maxit = 1e+05,  penalty.factor = rep(1, nvars),  exclude = integer(0),  lower.limits = -Inf,  upper.limits = Inf,  trace.it = 0)

Arguments

Details

glmnet.path solves the elastic net problem for a path of lambda values.It generalizesglmnet::glmnet in that it works for any GLM family.

Sometimes the sequence is truncated beforenlambda values of lambdahave been used. This happens whenglmnet.path detects that the decreasein deviance is marginal (i.e. we are near a saturated fit).

Value

An object with class "glmnetfit" and "glmnet".

Examples

set.seed(1)x <- matrix(rnorm(100 * 20), nrow = 100)y <- ifelse(rnorm(100) > 0, 1, 0)# binomial with probit linkfit1 <- glmnet:::glmnet.path(x, y, family = binomial(link = "probit"))

convert a data frame to a data matrix with one-hot encoding

Description

Converts a data frame to a data matrix suitable for input toglmnet.Factors are converted to dummy matrices via "one-hot" encoding. Options dealwith missing values and sparsity.

Usage

makeX(train, test = NULL, na.impute = FALSE, sparse = FALSE, ...)

Arguments

Details

The main function is to convert factors to dummy matrices via "one-hot"encoding. Having the 'train' and 'test' data present is useful if somefactor levels are missing in either. Since a factor with k levels leads to asubmatrix with 1/k entries zero, with large k thesparse=TRUE optioncan be helpful; a large matrix will be returned, but stored in sparse matrixformat. Finally, the function can deal with missing data. The currentversion has the option to replace missing observations with the mean fromthe training data. For dummy submatrices, these are the mean proportions ateach level.

Value

If only 'train' was provided, the function returns a matrix 'x'. Ifmissing values were imputed, this matrix has an attribute containing itscolumn means (before imputation). If 'test' was provided as well, a listwith two components is returned: 'x' and 'xtest'.

Author(s)

Trevor Hastie
Maintainer: Trevor Hastiehastie@stanford.edu

See Also

glmnet

Examples

set.seed(101)### Single data frameX = matrix(rnorm(20), 10, 2)X3 = sample(letters[1:3], 10, replace = TRUE)X4 = sample(LETTERS[1:3], 10, replace = TRUE)df = data.frame(X, X3, X4)makeX(df)makeX(df, sparse = TRUE)### Single data freame with missing valuesXn = XXn[3, 1] = NAXn[5, 2] = NAX3n = X3X3n[6] = NAX4n = X4X4n[9] = NAdfn = data.frame(Xn, X3n, X4n)makeX(dfn)makeX(dfn, sparse = TRUE)makeX(dfn, na.impute = TRUE)makeX(dfn, na.impute = TRUE, sparse = TRUE)### Test data as wellX = matrix(rnorm(10), 5, 2)X3 = sample(letters[1:3], 5, replace = TRUE)X4 = sample(LETTERS[1:3], 5, replace = TRUE)dft = data.frame(X, X3, X4)makeX(df, dft)makeX(df, dft, sparse = TRUE)### Missing data in test as wellXn = XXn[3, 1] = NAXn[5, 2] = NAX3n = X3X3n[1] = NAX4n = X4X4n[2] = NAdftn = data.frame(Xn, X3n, X4n)makeX(dfn, dftn)makeX(dfn, dftn, sparse = TRUE)makeX(dfn, dftn, na.impute = TRUE)makeX(dfn, dftn, sparse = TRUE, na.impute = TRUE)

Helper function to fit coxph model for survfit.coxnet

Description

This function constructs the coxph call needed to run the "hack" ofcoxph with 0 iterations. It's a separate function as we have to deal withfunction options like strata, offset and observation weights.

Usage

mycoxph(object, s, ...)

Arguments

Helper function to amend ... for new data in survfit.coxnet

Description

This function amends the function arguments passed to survfit.coxnetvia ... if new data was passed to survfit.coxnet. It's a separatefunction as we have to deal with function options like newstrataand newoffset.

Usage

mycoxpred(object, s, ...)

Arguments

Replace the missing entries in a matrix columnwise with the entries in asupplied vector

Description

Missing entries in any given column of the matrix are replaced by the columnmeans or the values in a supplied vector.

Usage

na.replace(x, m = rowSums(x, na.rm = TRUE))

Arguments

Details

This is a simple imputation scheme. This function is called bymakeXif thena.impute=TRUE option is used, but of course can be used onits own. If 'x' is sparse, the result is sparse, and the replacements aredone so as to maintain sparsity.

Value

A version of 'x' is returned with the missing values replaced.

Author(s)

Trevor Hastie
Maintainer: Trevor Hastiehastie@stanford.edu

See Also

makeX andglmnet

Examples

set.seed(101)### Single data frameX = matrix(rnorm(20), 10, 2)X[3, 1] = NAX[5, 2] = NAX3 = sample(letters[1:3], 10, replace = TRUE)X3[6] = NAX4 = sample(LETTERS[1:3], 10, replace = TRUE)X4[9] = NAdfn = data.frame(X, X3, X4)x = makeX(dfn)m = rowSums(x, na.rm = TRUE)na.replace(x, m)x = makeX(dfn, sparse = TRUE)na.replace(x, m)

Elastic net objective function value

Description

Returns the elastic net objective function value.

Usage

obj_function(y, mu, weights, family, lambda, alpha, coefficients, vp)

Arguments

Elastic net penalty value

Description

Returns the elastic net penalty value without thelambda factor.

Usage

pen_function(coefficients, alpha = 1, vp = 1)

Arguments

Details

The penalty is defined as

(1-\alpha)/2 \sum vp_j \beta_j^2 + \alpha \sum vp_j |\beta|.

Note the omission of the multiplicativelambda factor.

plot the cross-validation curve produced by cv.glmnet

Description

Plots the cross-validation curve, and upper and lower standard deviationcurves, as a function of thelambda values used. If the object hasclass"cv.relaxed" a different plot is produced, showing bothlambda andgamma

Usage

## S3 method for class 'cv.glmnet'plot(x, sign.lambda = -1, ...)## S3 method for class 'cv.relaxed'plot(x, se.bands = TRUE, sign.lambda = -1, ...)

Arguments

Details

A plot is produced, and nothing is returned.

Author(s)

Jerome Friedman, Trevor Hastie and Rob Tibshirani
Maintainer:Trevor Hastiehastie@stanford.edu

References

Friedman, J., Hastie, T. and Tibshirani, R. (2008)Regularization Paths for Generalized Linear Models via CoordinateDescent

See Also

glmnet andcv.glmnet.

Examples

set.seed(1010)n = 1000p = 100nzc = trunc(p/10)x = matrix(rnorm(n * p), n, p)beta = rnorm(nzc)fx = (x[, seq(nzc)] %*% beta)eps = rnorm(n) * 5y = drop(fx + eps)px = exp(fx)px = px/(1 + px)ly = rbinom(n = length(px), prob = px, size = 1)cvob1 = cv.glmnet(x, y)plot(cvob1)title("Gaussian Family", line = 2.5)cvob1r = cv.glmnet(x, y, relax = TRUE)plot(cvob1r)frame()set.seed(1011)par(mfrow = c(2, 2), mar = c(4.5, 4.5, 4, 1))cvob2 = cv.glmnet(x, ly, family = "binomial")plot(cvob2)title("Binomial Family", line = 2.5)## set.seed(1011)## cvob3 = cv.glmnet(x, ly, family = "binomial", type = "class")## plot(cvob3)## title("Binomial Family", line = 2.5)

plot coefficients from a "glmnet" object

Description

Produces a coefficient profile plot of the coefficient paths for a fitted"glmnet" object.

Usage

## S3 method for class 'glmnet'plot(  x,  xvar = c("lambda", "norm", "dev"),  label = FALSE,  sign.lambda = -1,  ...)## S3 method for class 'mrelnet'plot(  x,  xvar = c("lambda", "norm", "dev"),  label = FALSE,  sign.lambda = -1,  type.coef = c("coef", "2norm"),  ...)## S3 method for class 'multnet'plot(  x,  xvar = c("lambda", "norm", "dev"),  label = FALSE,  sign.lambda = -1,  type.coef = c("coef", "2norm"),  ...)## S3 method for class 'relaxed'plot(  x,  xvar = c("lambda", "dev"),  label = FALSE,  sign.lambda = -1,  gamma = 1,  ...)

Arguments

Details

A coefficient profile plot is produced. Ifx is a multinomial model,a coefficient plot is produced for each class.

Author(s)

Jerome Friedman, Trevor Hastie and Rob Tibshirani
Maintainer:Trevor Hastiehastie@stanford.edu

References

Friedman, J., Hastie, T. and Tibshirani, R. (2008)Regularization Paths for Generalized Linear Models via CoordinateDescent

See Also

glmnet, andprint,predict andcoefmethods.

Examples

x=matrix(rnorm(100*20),100,20)y=rnorm(100)g2=sample(1:2,100,replace=TRUE)g4=sample(1:4,100,replace=TRUE)fit1=glmnet(x,y)plot(fit1)plot(fit1,xvar="lambda",label=TRUE)fit3=glmnet(x,g4,family="multinomial")plot(fit3,pch=19)

make predictions from a "cv.glmnet" object.

Description

This function makes predictions from a cross-validated glmnet model, usingthe stored"glmnet.fit" object, and the optimal value chosen forlambda (andgamma for a 'relaxed' fit.

Usage

## S3 method for class 'cv.glmnet'predict(object, newx, s = c("lambda.1se", "lambda.min"), ...)## S3 method for class 'cv.relaxed'predict(  object,  newx,  s = c("lambda.1se", "lambda.min"),  gamma = c("gamma.1se", "gamma.min"),  ...)

Arguments

Details

This function makes it easier to use the results of cross-validation to makea prediction.

Value

The object returned depends on the ... argument which is passedon to thepredict method forglmnet objects.

Author(s)

Jerome Friedman, Trevor Hastie and Rob Tibshirani
Maintainer:Trevor Hastiehastie@stanford.edu

References

Friedman, J., Hastie, T. and Tibshirani, R. (2008)Regularization Paths for Generalized Linear Models via CoordinateDescent (2010), Journal of Statistical Software, Vol. 33(1), 1-22,doi:10.18637/jss.v033.i01.
Simon, N., Friedman, J., Hastie, T. and Tibshirani, R. (2011)Regularization Paths for Cox's ProportionalHazards Model via Coordinate Descent, Journal of Statistical Software, Vol.39(5), 1-13,doi:10.18637/jss.v039.i05.
Hastie, T., Tibshirani, Robert and Tibshirani, Ryan (2020)Best Subset,Forward Stepwise or Lasso? Analysis and Recommendations Based on Extensive Comparisons,Statist. Sc. Vol. 35(4), 579-592,https://arxiv.org/abs/1707.08692.
Glmnet webpage with four vignettes,https://glmnet.stanford.edu.

See Also

glmnet, andprint, andcoef methods, andcv.glmnet.

Examples

x = matrix(rnorm(100 * 20), 100, 20)y = rnorm(100)cv.fit = cv.glmnet(x, y)predict(cv.fit, newx = x[1:5, ])coef(cv.fit)coef(cv.fit, s = "lambda.min")predict(cv.fit, newx = x[1:5, ], s = c(0.001, 0.002))cv.fitr = cv.glmnet(x, y, relax = TRUE)predict(cv.fit, newx = x[1:5, ])coef(cv.fit)coef(cv.fit, s = "lambda.min", gamma = "gamma.min")predict(cv.fit, newx = x[1:5, ], s = c(0.001, 0.002), gamma = "gamma.min")

Get predictions from aglmnetfit fit object

Description

Gives fitted values, linear predictors, coefficients and number of non-zerocoefficients from a fittedglmnetfit object.

Usage

## S3 method for class 'glmnetfit'predict(  object,  newx,  s = NULL,  type = c("link", "response", "coefficients", "nonzero"),  exact = FALSE,  newoffset,  ...)

Arguments

Value

The object returned depends on type.

print a cross-validated glmnet object

Description

Print a summary of the results of cross-validation for a glmnet model.

Usage

## S3 method for class 'cv.glmnet'print(x, digits = max(3, getOption("digits") - 3), ...)

Arguments

Details

A summary of the cross-validated fit is produced, slightly different for a'cv.relaxed' object than for a 'cv.glmnet' object. Note that a 'cv.relaxed'object inherits from class 'cv.glmnet', so by directly invokingprint.cv.glmnet(object) will print the summary as ifrelax=TRUE had not been used.

Author(s)

Jerome Friedman, Trevor Hastie and Rob Tibshirani
Maintainer:Trevor Hastiehastie@stanford.edu

References

Friedman, J., Hastie, T. and Tibshirani, R. (2008)Regularization Paths for Generalized Linear Models via CoordinateDescent
https://arxiv.org/abs/1707.08692
Hastie, T.,Tibshirani, Robert, Tibshirani, Ryan (2019)Extended Comparisons ofBest Subset Selection, Forward Stepwise Selection, and the Lasso

See Also

glmnet,predict andcoef methods.

Examples

x = matrix(rnorm(100 * 20), 100, 20)y = rnorm(100)fit1 = cv.glmnet(x, y)print(fit1)fit1r = cv.glmnet(x, y, relax = TRUE)print(fit1r)## print.cv.glmnet(fit1r)  ## CHECK WITH TREVOR

print a glmnet object

Description

Print a summary of the glmnet path at each step along the path.

Usage

## S3 method for class 'glmnet'print(x, digits = max(3, getOption("digits") - 3), ...)

Arguments

Details

The call that produced the objectx is printed, followed by athree-column matrix with columnsDf,⁠%Dev⁠ andLambda.TheDf column is the number of nonzero coefficients (Df is areasonable name only for lasso fits).⁠%Dev⁠ is the percent devianceexplained (relative to the null deviance). In the case of a 'relaxed' fit,an additional column is inserted,⁠%Dev R⁠ which gives the percentdeviance explained by the relaxed model. For a "bigGlm" model, a simplersummary is printed.

Value

The matrix above is silently returned

References

Friedman, J., Hastie, T. and Tibshirani, R. (2008). Regularization Paths for Generalized Linear Models via Coordinate Descent

See Also

glmnet,predict andcoef methods.

Examples

x = matrix(rnorm(100 * 20), 100, 20)y = rnorm(100)fit1 = glmnet(x, y)print(fit1)

Make response for coxnet

Description

Internal function to make the response y passed to glmnet suitablefor coxnet (i.e. glmnet with family = "cox"). Sanity checks are performedhere too.

Usage

response.coxnet(y)

Arguments

Details

If y is a class "Surv" object, this function returns y with no changes. Ify is a two-column matrix with columns named 'time' and 'status', it isconverted into a "Surv" object.

Value

A class "Surv" object.

Generate multinomial samples from a probability matrix

Description

Generate multinomial samples

Usage

rmult(p)

Arguments

Details

Simple function that calls thermultinom function. It generates a class labelfor each row of its input matrix of class probabilities.

Value

a vector of class memberships

Author(s)

Trevor Hastie
Maintainer: Trevor Hastiehastie@stanford.edu

Add strata to a Surv object

Description

Helper function to add strata as an attribute to a Surv object. Theoutput of this function can be used as the response inglmnet()for fitting stratified Cox models.

Usage

stratifySurv(y, strata = rep(1, length(y)))

Arguments

Details

When fitting a stratified Cox model withglmnet(), strata shouldbe added to aSurv response with this helper function. Note thatit is not sufficient to add strata as an attribute to theSurvresponse manually: if the result does not have classstratifySurv,subsetting of the response will not work properly.

Value

An object of classstratifySurv (in addition to all theclassesy belonged to).

Examples

y <- survival::Surv(1:10, rep(0:1, length.out = 10))strata <- rep(1:3, length.out = 10)y2 <- stratifySurv(y, strata)  # returns stratifySurv object

Compute a survival curve from a coxnet object

Description

Computes the predicted survivor function for a Cox proportional hazardsmodel with elastic net penalty.

Usage

## S3 method for class 'coxnet'survfit(formula, s = NULL, ...)

Arguments

Details

To be consistent with other functions inglmnet, ifsis not specified, survival curves are returned for the entire lambdasequence. This is not recommended usage: it is best to callsurvfit.coxnet with a single value of the penalty parameterfor thes option.

Value

Ifs is a single value, an object of class "survfitcox"and "survfit" containing one or more survival curves. Otherwise, a listof such objects, one element for each value ins.Methods defined for survfit objects are print, summary and plot.

Examples

set.seed(2)nobs <- 100; nvars <- 15xvec <- rnorm(nobs * nvars)xvec[sample.int(nobs * nvars, size = 0.4 * nobs * nvars)] <- 0x <- matrix(xvec, nrow = nobs)beta <- rnorm(nvars / 3)fx <- x[, seq(nvars / 3)] %*% beta / 3ty <- rexp(nobs, exp(fx))tcens <- rbinom(n = nobs, prob = 0.3, size = 1)y <- survival::Surv(ty, tcens)fit1 <- glmnet(x, y, family = "cox")# survfit object for Cox model where lambda = 0.1sf1 <- survival::survfit(fit1, s = 0.1, x = x, y = y)plot(sf1)# example with new datasf2 <- survival::survfit(fit1, s = 0.1, x = x, y = y, newx = x[1:3, ])plot(sf2)# example with stratay2 <- stratifySurv(y, rep(1:2, length.out = nobs))fit2 <- glmnet(x, y2, family = "cox")sf3 <- survival::survfit(fit2, s = 0.1, x = x, y = y2)sf4 <- survival::survfit(fit2, s = 0.1, x = x, y = y2,               newx = x[1:3, ], newstrata = c(1, 1, 1))

Compute a survival curve from a cv.glmnet object

Description

Computes the predicted survivor function for a Cox proportional hazardsmodel with elastic net penalty from a cross-validated glmnet model.

Usage

## S3 method for class 'cv.glmnet'survfit(formula, s = c("lambda.1se", "lambda.min"), ...)

Arguments

Details

This function makes it easier to use the results of cross-validationto compute a survival curve.

Value

Ifs is a single value, an object of class "survfitcox"and "survfit" containing one or more survival curves. Otherwise, a listof such objects, one element for each value ins.Methods defined for survfit objects are print, summary and plot.

Examples

set.seed(2)nobs <- 100; nvars <- 15xvec <- rnorm(nobs * nvars)x <- matrix(xvec, nrow = nobs)beta <- rnorm(nvars / 3)fx <- x[, seq(nvars / 3)] %*% beta / 3ty <- rexp(nobs, exp(fx))tcens <- rbinom(n = nobs, prob = 0.3, size = 1)y <- survival::Surv(ty, tcens)cvfit <- cv.glmnet(x, y, family = "cox")# default: s = "lambda.1se"survival::survfit(cvfit, x = x, y = y)# s = "lambda.min"survival::survfit(cvfit, s = "lambda.min", x = x, y = y)

Check if glmnet should call cox.path

Description

Helper function to check if glmnet() should call cox.path().

Usage

use.cox.path(x, y)

Arguments

Details

Forfamily="cox", we only call the original coxnet() function if(i) x is not sparse, (ii) y is right-censored data, and (iii) we arenot fitting a stratified Cox model. This function also throws an errorif y has a "strata" attribute but is not of type "stratifySurv".

Value

TRUE if cox.path() should be called, FALSE otherwise.

Helper function to compute weighted mean and standard deviation

Description

Helper function to compute weighted mean and standard deviation.Deals gracefully whether x is sparse matrix or not.

Usage

weighted_mean_sd(x, weights = rep(1, nrow(x)))

Arguments

Value

A list with components.