optPenalty.kCV: Select optimal penalty parameter by K-fold cross-validation
In rags2ridges: Ridge Estimation of Precision Matrices from High-Dimensional Data

optPenalty.kCV

R Documentation

Select optimal penalty parameter by `K`-fold cross-validation

Description

Function that selects the optimal penalty parameter for the ridgeP call by usage of K-fold cross-validation. Its output includes (a.o.) the precision matrix under the optimal value of the penalty parameter.

Usage

optPenalty.kCV(
  Y,
  lambdaMin,
  lambdaMax,
  step,
  fold = nrow(Y),
  cor = FALSE,
  target = default.target(covML(Y)),
  type = "Alt",
  output = "light",
  graph = TRUE,
  verbose = TRUE
)

Arguments

`Y`	Data `matrix`. Variables assumed to be represented by columns.
`lambdaMin`	A `numeric` giving the minimum value for the penalty parameter.
`lambdaMax`	A `numeric` giving the maximum value for the penalty parameter.
`step`	An `integer` determining the number of steps in moving through the grid [`lambdaMin`, `lambdaMax`].
`fold`	A `numeric` or `integer` specifying the number of folds to apply in the cross-validation.
`cor`	A `logical` indicating if the evaluation of the LOOCV score should be performed on the correlation scale.
`target`	A target `matrix` (in precision terms) for Type I ridge estimators.
`type`	A `character` indicating the type of ridge estimator to be used. Must be one of: "Alt", "ArchI", "ArchII".
`output`	A `character` indicating if the output is either heavy or light. Must be one of: "all", "light".
`graph`	A `logical` indicating if the grid search for the optimal penalty parameter should be visualized.
`verbose`	A `logical` indicating if information on progress should be printed on screen.

Details

The function calculates a cross-validated negative log-likelihood score (using a regularized ridge estimator for the precision matrix) for each value of the penalty parameter contained in the search grid by way of K-fold cross-validation. The value of the penalty parameter that achieves the lowest cross-validated negative log-likelihood score is deemed optimal. The penalty parameter must be positive such that lambdaMin must be a positive scalar. The maximum allowable value of lambdaMax depends on the type of ridge estimator employed. For details on the type of ridge estimator one may use (one of: "Alt", "ArchI", "ArchII") see ridgeP. The ouput consists of an object of class list (see below). When output = "light" (default) only the optLambda and optPrec elements of the list are given.

Value

An object of class list:

`optLambda`	A `numeric` giving the optimal value of the penalty parameter.
`optPrec`	A `matrix` representing the precision matrix of the chosen type (see `ridgeP`) under the optimal value of the penalty parameter.
`lambdas`	A `numeric` vector representing all values of the penalty parameter for which cross-validation was performed; Only given when `output = "all"`.
`LLs`	A `numeric` vector representing the mean of cross-validated negative log-likelihoods for each value of the penalty parameter given in `lambdas`; Only given when `output = "all"`.

Note

When cor = TRUE correlation matrices are used in the computation of the (cross-validated) negative log-likelihood score, i.e., the K-fold sample covariance matrix is a matrix on the correlation scale. When performing evaluation on the correlation scale the data are assumed to be standardized. If cor = TRUE and one wishes to used the default target specification one may consider using target = default.target(covML(Y, cor = TRUE)). This gives a default target under the assumption of standardized data.

Under the default setting of the fold-argument, fold = nrow(Y), one performes leave-one-out cross-validation.

Author(s)

Carel F.W. Peeters <carel.peeters@wur.nl>, Wessel N. van Wieringen

Examples


## Obtain some (high-dimensional) data
p = 25
n = 10
set.seed(333)
X = matrix(rnorm(n*p), nrow = n, ncol = p)
colnames(X)[1:25] = letters[1:25]

## Obtain regularized precision under optimal penalty using K = n
OPT  <- optPenalty.kCV(X, lambdaMin = .5, lambdaMax = 30, step = 100); OPT
OPT$optLambda	# Optimal penalty
OPT$optPrec	  # Regularized precision under optimal penalty

## Another example with standardized data
X <- scale(X, center = TRUE, scale = TRUE)
OPT  <- optPenalty.kCV(X, lambdaMin = .5, lambdaMax = 30, step = 100, cor = TRUE,
                       target = default.target(covML(X, cor = TRUE))); OPT
OPT$optLambda	# Optimal penalty
OPT$optPrec	  # Regularized precision under optimal penalty

## Another example using K = 5
OPT  <- optPenalty.kCV(X, lambdaMin = .5, lambdaMax = 30, step = 100, fold = 5); OPT
OPT$optLambda	# Optimal penalty
OPT$optPrec	  # Regularized precision under optimal penalty

rags2ridges documentation built on Oct. 14, 2023, 5:06 p.m.