Package 'Coxmos'

Description

Computes the conditional survival probability P(T > y|Z = z)

Usage

Beran(
  time,
  status,
  covariate,
  delta,
  x,
  y,
  kernel = "gaussian",
  bw,
  lower.tail = FALSE
)

Arguments

Details

Possible options for argument window are "gaussian", "epanechnikov", "tricube", "boxcar", "triangular", "quartic" or "cosine".

Author(s)

Luis Meira-Machado and Marta Sestelo

References

R. Beran. Nonparametric regression with randomly censored survival data. Technical report, University of California, Berkeley, 1981.

Description

This function computes the time-dependent ROC curve for right censored survival data using the cumulative sensitivity and dynamic specificity definitions. The ROC curves can be either empirical (non-smoothed) or smoothed with/wtihout boundary correction. It also calculates the time-dependent area under the ROC curve (AUC). Edited by Pedro Salguero to remove the PLOT argument.

Usage

cenROC(Y, M, censor, t, U = NULL, h = NULL, bw = "NR", method = "tra",
    ktype = "normal", ktype1 = "normal", B = 0, alpha = 0.05, plot = FALSE)

Arguments

Details

The empirical (non-smoothed) ROC estimate and the smoothed ROC estimate with/without boundary correction can be obtained using this function. The smoothed ROC curve estimators require selecting two bandwidth parametrs: one for Beran’s weight calculation and one for smoothing the ROC curve. For the latter, three data-driven methods: the normal reference "NR", the plug-in "PI" and the cross-validation "CV" were implemented. To select the bandwidth parameter needed for Beran’s weight calculation, by default, the plug-in method of Sheather and Jones (1991) is used but it is also possible introduce a numeric value. See Beyene and El Ghouch (2020) for details.

Value

Returns the following items:

ROC The vector of estimated ROC values. These will be numeric numbers between zero

and one.

U The vector of grid points used.

AUC A data frame of dimension $1 \times 4$. The columns are: AUC, standard error of AUC, the lower

and upper limits of bootstrap CI.

bw The computed value of bandwidth. For the empirical method this is always NA.

Dt The vector of estimated event status.

M The vector of Marker values.

Author(s)

Kassu Mehari Beyene, Catholic University of Louvain. <[email protected]>

Anouar El Ghouch, Catholic University of Louvain. <[email protected]>

References

Beyene, K. M. and El Ghouch A. (2020). Smoothed time-dependent ROC curves for right-censored survival data. submitted.

Sheather, S. J. and Jones, M. C. (1991). A Reliable data-based bandwidth selection method for kernel density estimation. Journal of the Royal Statistical Society. Series B (Methodological) 53(3): 683–690.

Description

The cox function conducts a Cox proportional hazards regression analysis, a type of survival analysis. It is designed to handle right-censored data and is built upon the coxph function from the survival package. The function returns an object of class "Coxmos" with the attribute model labeled as "cox".

Usage

cox(
  X,
  Y,
  x.center = TRUE,
  x.scale = FALSE,
  remove_near_zero_variance = TRUE,
  remove_zero_variance = FALSE,
  toKeep.zv = NULL,
  remove_non_significant = FALSE,
  alpha = 0.05,
  MIN_EPV = 5,
  FORCE = FALSE,
  returnData = TRUE,
  verbose = FALSE
)

Arguments

Details

The Cox proportional hazards regression model is a linear model that describes the relationship between the hazard rate and one or more predictor variables. The function provided here offers several preprocessing steps to ensure the quality and robustness of the model.

The function allows for the centering and scaling of predictor variables, which can be essential for the stability and interpretability of the model. It also provides options to remove variables with near-zero or zero variance, which can be problematic in regression analyses. Such variables offer little to no information and can lead to overfitting.

Another notable feature is the ability to remove non-significant predictors from the final model through a backward selection process. This ensures that only variables that contribute significantly to the model are retained.

The function also checks for the minimum number of events per variable (EPV) to ensure the robustness of the model. If the specified EPV is not met, the function can either halt the computation or proceed based on user preference.

It's important to note that while this function is tailored for standard Cox regression, it might not be suitable for high-dimensional data. In such cases, users are advised to consider alternative methods like coxEN() or PLS-based Cox methods.

Value

Instance of class "Coxmos" and model "cox". The class contains the following elements:

X: List of normalized X data information.

• (data): normalized X matrix

• (x.mean): mean values for X matrix

• (x.sd): standard deviation for X matrix

Y: List of normalized Y data information.

• (data): normalized Y matrix

• (y.mean): mean values for Y matrix

• (y.sd): standard deviation for Y matrix

survival_model: List of survival model information

• fit: coxph object.

• AIC: AIC of cox model.

• BIC: BIC of cox model.

• lp: linear predictors for train data.

• coef: Coefficients for cox model.

• YChapeau: Y Chapeau residuals.

• Yresidus: Y residuals.

call: call function

X_input: X input matrix

Y_input: Y input matrix

nsv: Variables removed by remove_non_significant if any.

nzv: Variables removed by remove_near_zero_variance or remove_zero_variance.

nz_coeffvar: Variables removed by coefficient variation near zero.

removed_variables_correlation: Variables removed by being high correlated with other variables.

class: Model class.

time: time consumed for running the cox analysis.

Author(s)

Pedro Salguero Garcia. Maintainer: [email protected]

References

Cox D (1972). “Regression models and life tables (with discussion.” Royal Statistical Society. https://doi.org/10.1111/j.2517-6161.1972.tb00899.x. Concato J, Peduzzi P, Holford TR, Feinstein AR (1995). “Importance of events per independent variable in proportional hazards analysis I. Background, goals, and general strategy.” Journal of Clinical Epidemiology. doi:10.1016/0895-4356(95)00510-2, https://pubmed.ncbi.nlm.nih.gov/8543963/. Therneau TM (2024). A Package for Survival Analysis in R. R package version 3.5-8, https://CRAN.R-project.org/package=survival.

Examples

data("X_proteomic")
data("Y_proteomic")
X <- X_proteomic[,1:10]
Y <- Y_proteomic
cox(X, Y, x.center = TRUE, x.scale = TRUE)

Description

The cox.prediction function facilitates Cox predictions based on a given Coxmos model, specifically tailored for raw data input. It seamlessly integrates the generation of a score matrix, especially when a PLS Survival analysis has been executed, and subsequently conducts the Cox prediction. The function offers flexibility in prediction types and methods, catering to diverse analytical requirements.

Usage

cox.prediction(model, new_data, time = NULL, type = "lp", method = "cox")

Arguments

Details

The function initiates by determining the prediction method specified by the user. If the "cox" method is chosen, the function computes the score matrix using the predict.Coxmos function. This score matrix serves as a foundation for subsequent predictions. It's imperative to note that for prediction types "expected" and "survival", a specific time point must be provided to ensure accurate predictions. The function then leverages the predict function from the Cox model to compute the desired prediction metric.

Alternatively, if the "W.star" method is selected, the function computes the prediction values based on the W* matrix and the Cox model's coefficients. This involves normalization of the input data, ensuring it aligns with the training data's distribution. The normalization process considers mean and standard deviation values from the model, ensuring consistency in predictions. The resultant prediction values are then computed as a linear combination of the normalized data and the derived coefficients.

It's worth noting that the function is meticulously designed to handle potential inconsistencies or missing components in the model, ensuring robustness in predictions and minimizing potential errors during execution.

Value

Return the "lp", "risk", "expected" or "survival" metric for test data using the specific Coxmos model.

Author(s)

Pedro Salguero Garcia. Maintainer: [email protected]

Examples

data("X_proteomic")
data("Y_proteomic")
set.seed(123)
index_train <- caret::createDataPartition(Y_proteomic$event, p = .5, list = FALSE, times = 1)
X_train <- X_proteomic[index_train,1:50]
Y_train <- Y_proteomic[index_train,]

X_test <- X_proteomic[-index_train,1:50]
Y_test <- Y_proteomic[-index_train,]

model_icox <- splsicox(X_train, Y_train, n.comp = 2)
cox.prediction(model = model_icox, new_data = X_test, type = "lp")

Description

This function performs a cox elastic net model (based on glmnet R package). The function returns a Coxmos model with the attribute model as "coxEN".

Usage

coxEN(
  X,
  Y,
  EN.alpha = 0.5,
  max.variables = NULL,
  x.center = TRUE,
  x.scale = FALSE,
  remove_near_zero_variance = TRUE,
  remove_zero_variance = FALSE,
  toKeep.zv = NULL,
  remove_non_significant = FALSE,
  alpha = 0.05,
  MIN_EPV = 5,
  returnData = TRUE,
  verbose = FALSE
)

Arguments

Details

The coxEN function is designed to handle survival data using the elastic net regularization. The function is particularly useful when dealing with high-dimensional datasets where the number of predictors exceeds the number of observations. The elastic net regularization combines the strengths of both lasso and ridge regression. The EN.alpha parameter controls the balance between lasso and ridge penalties. It's important to note that when using the ridge penalty (EN.alpha = 0), the EVP and max.variables parameters will not be considered.

Value

Instance of class "Coxmos" and model "coxEN". The class contains the following elements: X: List of normalized X data information.

• (data): normalized X matrix

• (x.mean): mean values for X matrix

• (x.sd): standard deviation for X matrix

Y: List of normalized Y data information.

• (data): normalized X matrix

• (y.mean): mean values for Y matrix

• (y.sd): standard deviation for Y matrix'

survival_model: List of survival model information.

• fit: coxph object.

• AIC: AIC of cox model.

• BIC: BIC of cox model.

• lp: linear predictors for train data.

• coef: Coefficients for cox model.

• YChapeau: Y Chapeau residuals.

• Yresidus: Y residuals.

opt.lambda: Optimal lambda computed by the model with maximum % Var from glmnet function.

EN.alpha: EN.alpha selected

n.var: Number of variables selected

call: call function

X_input: X input matrix

Y_input: Y input matrix

convergence_issue: If any convergence issue has been found.

alpha: alpha value selected

selected_variables_cox: Variables selected to enter the cox model.

nsv: Variables removed by cox alpha cutoff.

removed_variables_correlation: Variables removed by being high correlated with other variables.

nzv: Variables removed by remove_near_zero_variance or remove_zero_variance.

nz_coeffvar: Variables removed by coefficient variation near zero.

class: Model class.

time: time consumed for running the cox analysis.

Author(s)

Pedro Salguero Garcia. Maintainer: [email protected]

References

Simon N, Friedman JH, Friedman JH, Hastie T, Tibshirani R (2011). “Regularization Paths for Cox's Proportional Hazards Model via Coordinate Descent.” Journal of Statistical Software. doi:10.18637/jss.v039.i05, https://pubmed.ncbi.nlm.nih.gov/27065756/.

Examples

data("X_proteomic")
data("Y_proteomic")
X <- X_proteomic[,1:50]
Y <- Y_proteomic
coxEN(X, Y, EN.alpha = 0.75, x.center = TRUE, x.scale = TRUE, remove_non_significant = TRUE)

Description

The coxSW function conducts a stepwise Cox regression analysis on survival data, leveraging the capabilities of the My.stepwise R package. The primary objective of this function is to identify the most significant predictors for survival data by iteratively adding or removing predictors based on their statistical significance in the model. The resulting model is of class "Coxmos" with an attribute model labeled as "coxSW".

Usage

coxSW(
  X,
  Y,
  max.variables = 20,
  BACKWARDS = TRUE,
  alpha_ENT = 0.1,
  alpha_OUT = 0.15,
  toKeep.sw = NULL,
  initialModel = NULL,
  x.center = TRUE,
  x.scale = FALSE,
  remove_near_zero_variance = TRUE,
  remove_zero_variance = FALSE,
  toKeep.zv = NULL,
  remove_non_significant = FALSE,
  alpha = 0.05,
  MIN_EPV = 5,
  returnData = TRUE,
  verbose = FALSE
)

Arguments

Details

The coxSW function employs a stepwise regression technique tailored for survival data. This method is particularly beneficial when dealing with a plethora of predictors, and there's a necessity to distill the model to its most impactful variables. The stepwise procedure can be configured to operate in forward, backward, or a hybrid mode, contingent on the parameters specified by the user.

During the iterative process, variables are evaluated for inclusion or exclusion based on predefined significance levels (alpha_ENT for entry and alpha_OUT for removal). This ensures that the model retains only those predictors that meet the significance criteria, thereby enhancing the model's interpretability and predictive power.

Additionally, the function offers several preprocessing options, such as centering and scaling of the predictor matrix, removal of variables with near-zero or zero variance, and the ability to enforce the inclusion of specific variables in the model. These preprocessing steps are crucial for ensuring the robustness and stability of the resulting Cox regression model.

It's worth noting that the function is equipped to handle both numeric and binary categorical predictors. However, it's imperative that categorical variables are appropriately transformed into binary format before analysis. The outcome or response variable should comprise two columns: "time" representing the survival time and "event" indicating the occurrence of the event of interest.

Value

Instance of class "Coxmos" and model "coxSW". The class contains the following elements:

X: List of normalized X data information.

• (data): normalized X matrix

• (x.mean): mean values for X matrix

• (x.sd): standard deviation for X matrix

Y: List of normalized Y data information.

• (data): normalized Y matrix

• (y.mean): mean values for Y matrix

• (y.sd): standard deviation for Y matrix

survival_model: List of survival model information

• fit: coxph object.

• AIC: AIC of cox model.

• BIC: BIC of cox model.

• lp: linear predictors for train data.

• coef: Coefficients for cox model.

• YChapeau: Y Chapeau residuals.

• Yresidus: Y residuals.

call: call function

X_input: X input matrix

Y_input: Y input matrix

nsv: Variables removed by remove_non_significant if any.

nzv: Variables removed by remove_near_zero_variance or remove_zero_variance.

nz_coeffvar: Variables removed by coefficient variation near zero.

removed_variables_correlation: Variables removed by being high correlated with other variables.

class: Model class.

time: time consumed for running the cox analysis.

Author(s)

Pedro Salguero Garcia. Maintainer: [email protected]

References

Efroymson MA (1960). “Multiple Regression Analysis.” Mathematical Methods for Digital Computers. Company ISC (2017). “My.stepwise: Stepwise Variable Selection Procedures for Regression Analysis.” https://cran.r-project.org/package=My.stepwise.

Examples

data("X_proteomic")
data("Y_proteomic")
X <- X_proteomic[,1:10]
Y <- Y_proteomic
coxSW(X, Y, x.center = TRUE, x.scale = TRUE)

Description

This function computes the data-driven bandwidth for smoothing the ROC (or distribution) function using the CV method of Beyene and El Ghouch (2020). This is an extension of the classical (unweighted) cross-validation bandwith selection method to the case of weighted data.

Usage

CV(X, wt, ktype = "normal")

Arguments

Details

Bowman et al (1998) proposed the cross-validation bandwidth selection method for unweighted kernal smoothed distribution function. This method is implemented in the R package kerdiest. We adapted this for the case of weighted data by incorporating the weight variable into the cross-validation function of Bowman's method. See Beyene and El Ghouch (2020) for details.

Value

Returns the computed value for the bandwith parameter.

Author(s)

Kassu Mehari Beyene, Catholic University of Louvain. <[email protected]>

Anouar El Ghouch, Catholic University of Louvain. <[email protected]>

References

Beyene, K. M. and El Ghouch A. (2020). Smoothed time-dependent ROC curves for right-censored survival data. submitted.

Bowman A., Hall P. and Trvan T.(1998). Bandwidth selection for the smoothing of distribution functions. Biometrika 85:799-808.

Quintela-del-Rio, A. and Estevez-Perez, G. (2015). kerdiest: Nonparametric kernel estimation of the distribution function, bandwidth selection and estimation of related functions. R package version 1.2.

Description

This function performs cross-validated CoxEN (coxEN). The function returns the optimal number of EN penalty value based on cross-validation. The performance could be based on multiple metrics as Area Under the Curve (AUC), Brier Score or C-Index. Furthermore, the user could establish more than one metric simultaneously.

Usage

cv.coxEN(
  X,
  Y,
  EN.alpha.list = seq(0, 1, 0.1),
  max.variables = NULL,
  n_run = 3,
  k_folds = 10,
  x.center = TRUE,
  x.scale = FALSE,
  remove_near_zero_variance = TRUE,
  remove_zero_variance = TRUE,
  toKeep.zv = NULL,
  remove_variance_at_fold_level = FALSE,
  remove_non_significant_models = FALSE,
  remove_non_significant = FALSE,
  alpha = 0.05,
  w_AIC = 0,
  w_c.index = 0,
  w_AUC = 1,
  w_BRIER = 0,
  times = NULL,
  max_time_points = 15,
  MIN_AUC_INCREASE = 0.01,
  MIN_AUC = 0.8,
  MIN_COMP_TO_CHECK = 3,
  pred.attr = "mean",
  pred.method = "cenROC",
  fast_mode = FALSE,
  MIN_EPV = 5,
  return_models = FALSE,
  returnData = FALSE,
  PARALLEL = FALSE,
  verbose = FALSE,
  seed = 123
)

Arguments

Details

The ⁠coxEN Cross-Validation⁠ function provides a robust mechanism to optimize the hyperparameters of the cox elastic net model through cross-validation. By systematically evaluating a range of elastic net mixing parameters (EN.alpha.list), this function identifies the optimal balance between lasso and ridge penalties for survival analysis.

The cross-validation process is structured across multiple runs (n_run) and folds (k_folds), ensuring a comprehensive assessment of model performance. Users can prioritize specific evaluation metrics, such as AUC, Brier Score, or C-Index, by assigning weights (w_AIC, w_c.index, w_AUC, w_BRIER). The function also offers flexibility in the AUC evaluation method (pred.method) and the attribute for metric evaluation (pred.attr).

One of the distinguishing features of this function is its adaptive evaluation process. The function can terminate the cross-validation early if the improvement in AUC does not exceed the MIN_AUC_INCREASE threshold or if a predefined AUC (MIN_AUC) is achieved. This adaptive approach ensures computational efficiency without compromising the quality of the results.

Data preprocessing options are integrated into the function, emphasizing the significance of data quality. Options to remove near-zero and zero variance variables, either globally or at the fold level, are available. The function also supports multicore processing (PARALLEL option) to expedite the cross-validation process.

Upon execution, the function returns a detailed output, encompassing information about the best model, performance metrics at various granularities (fold, run, component), and if desired, all cross-validated models.

Value

Instance of class "Coxmos" and model "cv.coxEN". The class contains the following elements: best_model_info: A data.frame with the information for the best model. df_results_folds: A data.frame with fold-level information. df_results_runs: A data.frame with run-level information. df_results_comps: A data.frame with component-level information (for cv.coxEN, EN.alpha information).

lst_models: If return_models = TRUE, return a the list of all cross-validated models. pred.method: AUC evaluation algorithm method for evaluate the model performance.

opt.EN.alpha: Optimal EN.alpha value selected by the best_model. opt.nvar: Optimal number of variables selected by the best_model.

plot_AIC: AIC plot by each hyper-parameter. plot_c_index: C-Index plot by each hyper-parameter. plot_BRIER: Brier Score plot by each hyper-parameter. plot_AUC: AUC plot by each hyper-parameter.

class: Cross-Validated model class.

lst_train_indexes: List (of lists) of indexes for the observations used in each run/fold for train the models. lst_test_indexes: List (of lists) of indexes for the observations used in each run/fold for test the models.

time: time consumed for running the cross-validated function.

Author(s)

Pedro Salguero Garcia. Maintainer: [email protected]

Examples

data("X_proteomic")
data("Y_proteomic")
X_proteomic <- X_proteomic[1:30,1:40]
Y_proteomic <- Y_proteomic[1:30,]
set.seed(123)
index_train <- caret::createDataPartition(Y_proteomic$event, p = .5, list = FALSE, times = 1)
X_train <- X_proteomic[index_train,]
Y_train <- Y_proteomic[index_train,]
cv.coxEN_model <- cv.coxEN(X_train, Y_train, EN.alpha.list = c(0.1,0.5),
x.center = TRUE, x.scale = TRUE)

Description

This function performs cross-validated sparse partial least squares single-block for sPLS-DACOX-Dynamic. It returns the optimal number of components and the optimal sparsity penalty value based on cross-validation. Performance can be evaluated using multiple metrics, such as Area Under the Curve (AUC), Brier Score, or C-Index. Users can also specify more than one metric simultaneously.

Usage

cv.isb.splsdacox(
  X,
  Y,
  max.ncomp = 8,
  vector = NULL,
  MIN_NVAR = 10,
  MAX_NVAR = NULL,
  n.cut_points = 5,
  MIN_AUC_INCREASE = 0.01,
  EVAL_METHOD = "AUC",
  n_run = 3,
  k_folds = 10,
  x.center = TRUE,
  x.scale = FALSE,
  remove_near_zero_variance = TRUE,
  remove_zero_variance = TRUE,
  toKeep.zv = NULL,
  remove_variance_at_fold_level = FALSE,
  remove_non_significant_models = FALSE,
  remove_non_significant = FALSE,
  alpha = 0.05,
  w_AIC = 0,
  w_c.index = 0,
  w_AUC = 1,
  w_BRIER = 0,
  times = NULL,
  max_time_points = 15,
  MIN_AUC = 0.8,
  MIN_COMP_TO_CHECK = 3,
  pred.attr = "mean",
  pred.method = "cenROC",
  fast_mode = FALSE,
  max.iter = 200,
  MIN_EPV = 5,
  return_models = FALSE,
  returnData = FALSE,
  PARALLEL = FALSE,
  verbose = FALSE,
  seed = 123
)

Arguments

Details

The cv.isb.splsdacox_dynamic function performs cross-validation for the single-block sparse partial least squares deviance residual Cox analysis (sPLS-DACOX). Cross-validation evaluates different hyperparameter combinations, including the number of components (max.ncomp) and the number of variables selected (vector). The function systematically evaluates models across multiple runs and folds to determine the best configuration. It allows flexibility in metrics, preprocessing steps (centering, scaling, variance filtering), and stopping criteria.

For each run, the dataset is divided into training and test sets for the specified number of folds (k_folds). Various metrics, such as AIC, C-Index, Brier Score, and AUC, are computed to assess model performance. The function identifies the optimal hyperparameters that yield the best performance based on the selected evaluation metrics.

Additionally, it offers options to control the evaluation algorithm method (pred.method), whether to return all models, and parallel processing (PARALLEL). The function also allows the user to control the verbosity of output messages and set the minimum threshold for Events Per Variable (MIN_EPV).

Value

An instance of class "Coxmos" and model "cv.SB.sPLS-DACOX-Dynamic", containing:

• best_model_info: Data frame with the best model's information.

• df_results_folds: Data frame with fold-level results.

• df_results_runs: Data frame with run-level results.

• df_results_comps: Data frame with component-level results.

• list_cv_spls_models: List of cross-validated models for each block.

• opt.comp: Optimal number of components.

• opt.nvar: Optimal number of variables selected.

• class: Model class.

• time: Time taken to run the cross-validation.

Author(s)

Pedro Salguero Garcia. Maintainer: [email protected]

Examples

data("X_multiomic")
data("Y_multiomic")
set.seed(123)
index_train <- caret::createDataPartition(Y_multiomic$event, p = .25, list = FALSE, times = 1)
X_train <- X_multiomic
X_train$mirna <- X_train$mirna[index_train,1:20]
X_train$proteomic <- X_train$proteomic[index_train,1:20]
Y_train <- Y_multiomic[index_train,]
vector <- list()
vector$mirna <- c(10)
vector$proteomic <- c(10)
cv.isb.splsdacox_model <- cv.isb.splsdacox(X_train, Y_train, max.ncomp = 1, vector = vector,
n_run = 1, k_folds = 3, x.center = TRUE, x.scale = TRUE)

Description

This function performs cross-validated sparse partial least squares single-block for sPLS-DRCOX-Dynamic. It returns the optimal number of components and the optimal sparsity penalty value based on cross-validation. Performance can be evaluated using multiple metrics, such as Area Under the Curve (AUC), Brier Score, or C-Index. Users can also specify more than one metric simultaneously.

Usage

cv.isb.splsdrcox(
  X,
  Y,
  max.ncomp = 8,
  vector = NULL,
  MIN_NVAR = 10,
  MAX_NVAR = NULL,
  n.cut_points = 5,
  MIN_AUC_INCREASE = 0.01,
  EVAL_METHOD = "AUC",
  n_run = 3,
  k_folds = 10,
  x.center = TRUE,
  x.scale = FALSE,
  remove_near_zero_variance = TRUE,
  remove_zero_variance = TRUE,
  toKeep.zv = NULL,
  remove_variance_at_fold_level = FALSE,
  remove_non_significant_models = FALSE,
  remove_non_significant = FALSE,
  alpha = 0.05,
  w_AIC = 0,
  w_c.index = 0,
  w_AUC = 1,
  w_BRIER = 0,
  times = NULL,
  max_time_points = 15,
  MIN_AUC = 0.8,
  MIN_COMP_TO_CHECK = 3,
  pred.attr = "mean",
  pred.method = "cenROC",
  fast_mode = FALSE,
  max.iter = 200,
  MIN_EPV = 5,
  return_models = FALSE,
  returnData = FALSE,
  PARALLEL = FALSE,
  verbose = FALSE,
  seed = 123
)

Arguments

Details

The cv.isb.splsdrcox_dynamic function performs cross-validation for the single-block sparse partial least squares deviance residual Cox analysis (sPLS-DRCOX). Cross-validation evaluates different hyperparameter combinations, including the number of components (max.ncomp) and the number of variables selected (vector). The function systematically evaluates models across multiple runs and folds to determine the best configuration. It allows flexibility in metrics, preprocessing steps (centering, scaling, variance filtering), and stopping criteria.

For each run, the dataset is divided into training and test sets for the specified number of folds (k_folds). Various metrics, such as AIC, C-Index, Brier Score, and AUC, are computed to assess model performance. The function identifies the optimal hyperparameters that yield the best performance based on the selected evaluation metrics.

Additionally, it offers options to control the evaluation algorithm method (pred.method), whether to return all models, and parallel processing (PARALLEL). The function also allows the user to control the verbosity of output messages and set the minimum threshold for Events Per Variable (MIN_EPV).

Value

An instance of class "Coxmos" and model "cv.SB.sPLS-DRCOX-Dynamic", containing:

• best_model_info: Data frame with the best model's information.

• df_results_folds: Data frame with fold-level results.

• df_results_runs: Data frame with run-level results.

• df_results_comps: Data frame with component-level results.

• list_cv_spls_models: List of cross-validated models for each block.

• opt.comp: Optimal number of components.

• opt.nvar: Optimal number of variables selected.

• class: Model class.

• time: Time taken to run the cross-validation.

Author(s)

Pedro Salguero Garcia. Maintainer: [email protected]

Examples

data("X_multiomic")
data("Y_multiomic")
set.seed(123)
index_train <- caret::createDataPartition(Y_multiomic$event, p = .25, list = FALSE, times = 1)
X_train <- X_multiomic
X_train$mirna <- X_train$mirna[index_train,1:20]
X_train$proteomic <- X_train$proteomic[index_train,1:20]
Y_train <- Y_multiomic[index_train,]
vector <- list()
vector$mirna <- c(10,20)
vector$proteomic <- c(10,20)
cv.isb.splsdrcox_model <- cv.isb.splsdrcox(X_train, Y_train, max.ncomp = 1, vector = vector,
n_run = 1, k_folds = 3, x.center = TRUE, x.scale = TRUE)

Description

This function performs cross-validated sparse partial least squares single-block for sPLS-DRCOX-Dynamic. It returns the optimal number of components and the optimal sparsity penalty value based on cross-validation. Performance can be evaluated using multiple metrics, such as Area Under the Curve (AUC), Brier Score, or C-Index. Users can also specify more than one metric simultaneously.

Usage

cv.isb.splsdrcox_penalty(
  X,
  Y,
  max.ncomp = 8,
  penalty.list = seq(0, 0.9, 0.1),
  n_run = 3,
  k_folds = 10,
  x.center = TRUE,
  x.scale = FALSE,
  remove_near_zero_variance = TRUE,
  remove_zero_variance = TRUE,
  toKeep.zv = NULL,
  remove_variance_at_fold_level = FALSE,
  remove_non_significant_models = FALSE,
  remove_non_significant = FALSE,
  alpha = 0.05,
  w_AIC = 0,
  w_c.index = 0,
  w_AUC = 1,
  w_BRIER = 0,
  times = NULL,
  max_time_points = 15,
  MIN_AUC_INCREASE = 0.01,
  MIN_AUC = 0.8,
  MIN_COMP_TO_CHECK = 3,
  pred.attr = "mean",
  pred.method = "cenROC",
  fast_mode = FALSE,
  max.iter = 200,
  MIN_EPV = 5,
  return_models = FALSE,
  returnData = FALSE,
  PARALLEL = FALSE,
  verbose = FALSE,
  seed = 123
)

Arguments

Details

The cv.isb.splsdrcox_penalty function performs cross-validation for the single-block sparse partial least squares deviance residual Cox analysis (sPLS-DRCOX). Cross-validation evaluates different hyperparameter combinations, including the number of components (max.ncomp) and the number of variables selected (vector). The function systematically evaluates models across multiple runs and folds to determine the best configuration. It allows flexibility in metrics, preprocessing steps (centering, scaling, variance filtering), and stopping criteria.

For each run, the dataset is divided into training and test sets for the specified number of folds (k_folds). Various metrics, such as AIC, C-Index, Brier Score, and AUC, are computed to assess model performance. The function identifies the optimal hyperparameters that yield the best performance based on the selected evaluation metrics.

Additionally, it offers options to control the evaluation algorithm method (pred.method), whether to return all models, and parallel processing (PARALLEL). The function also allows the user to control the verbosity of output messages and set the minimum threshold for Events Per Variable (MIN_EPV).

Value

An instance of class "Coxmos" and model "cv.SB.sPLS-DRCOX-Dynamic", containing:

• best_model_info: Data frame with the best model's information.

• df_results_folds: Data frame with fold-level results.

• df_results_runs: Data frame with run-level results.

• df_results_comps: Data frame with component-level results.

• list_cv_spls_models: List of cross-validated models for each block.

• opt.comp: Optimal number of components.

• opt.nvar: Optimal number of variables selected.

• class: Model class.

• time: Time taken to run the cross-validation.

Author(s)

Pedro Salguero Garcia. Maintainer: [email protected]

Examples

data("X_multiomic")
data("Y_multiomic")
set.seed(123)
index_train <- caret::createDataPartition(Y_multiomic$event, p = .25, list = FALSE, times = 1)
X_train <- X_multiomic
X_train$mirna <- X_train$mirna[index_train,1:50]
X_train$proteomic <- X_train$proteomic[index_train,1:50]
Y_train <- Y_multiomic[index_train,]
cv.isb.splsdrcox_model <- cv.isb.splsdrcox_penalty(X_train, Y_train, max.ncomp = 1,
n_run = 1, k_folds = 3, penalty.list = c(0, 0.5), x.center = TRUE, x.scale = TRUE)

Description

This function performs cross-validated sparse partial least squares single-block for sPLS-ICOX-Dynamic. It returns the optimal number of components and the optimal sparsity penalty value based on cross-validation. Performance can be evaluated using multiple metrics, such as Area Under the Curve (AUC), Brier Score, or C-Index. Users can also specify more than one metric simultaneously.

Usage

cv.isb.splsicox(
  X,
  Y,
  max.ncomp = 8,
  penalty.list = seq(0, 0.9, 0.1),
  n_run = 3,
  k_folds = 10,
  x.center = TRUE,
  x.scale = FALSE,
  remove_near_zero_variance = TRUE,
  remove_zero_variance = TRUE,
  toKeep.zv = NULL,
  remove_variance_at_fold_level = FALSE,
  remove_non_significant_models = FALSE,
  remove_non_significant = FALSE,
  alpha = 0.05,
  w_AIC = 0,
  w_c.index = 0,
  w_AUC = 1,
  w_BRIER = 0,
  times = NULL,
  max_time_points = 15,
  MIN_AUC_INCREASE = 0.01,
  MIN_AUC = 0.8,
  MIN_COMP_TO_CHECK = 3,
  pred.attr = "mean",
  pred.method = "cenROC",
  fast_mode = FALSE,
  MIN_EPV = 5,
  return_models = FALSE,
  returnData = FALSE,
  PARALLEL = FALSE,
  verbose = FALSE,
  seed = 123
)

Arguments

Details

The cv.isb.splsicox function performs cross-validation for the single-block sparse partial least squares deviance residual Cox analysis (sPLS-ICOX). Cross-validation evaluates different hyperparameter combinations, including the number of components (max.ncomp) and the number of variables selected (vector). The function systematically evaluates models across multiple runs and folds to determine the best configuration. It allows flexibility in metrics, preprocessing steps (centering, scaling, variance filtering), and stopping criteria.

For each run, the dataset is divided into training and test sets for the specified number of folds (k_folds). Various metrics, such as AIC, C-Index, Brier Score, and AUC, are computed to assess model performance. The function identifies the optimal hyperparameters that yield the best performance based on the selected evaluation metrics.

Additionally, it offers options to control the evaluation algorithm method (pred.method), whether to return all models, and parallel processing (PARALLEL). The function also allows the user to control the verbosity of output messages and set the minimum threshold for Events Per Variable (MIN_EPV).

Value

An instance of class "Coxmos" and model "cv.SB.sPLS-ICOX-Dynamic", containing:

• best_model_info: Data frame with the best model's information.

• df_results_folds: Data frame with fold-level results.

• df_results_runs: Data frame with run-level results.

• df_results_comps: Data frame with component-level results.

• list_cv_spls_models: List of cross-validated models for each block.

• opt.comp: Optimal number of components.

• opt.nvar: Optimal number of variables selected.

• class: Model class.

• time: Time taken to run the cross-validation.

Author(s)

Pedro Salguero Garcia. Maintainer: [email protected]

Examples

data("X_multiomic")
data("Y_multiomic")
set.seed(123)
index_train <- caret::createDataPartition(Y_multiomic$event, p = .3, list = FALSE, times = 1)
X_train <- X_multiomic
X_train$mirna <- X_train$mirna[index_train,1:30]
X_train$proteomic <- X_train$proteomic[index_train,1:30]
Y_train <- Y_multiomic[index_train,]
cv.isb.splsicox_model <- cv.isb.splsicox(X_train, Y_train, max.ncomp = 1, penalty.list = c(0, 0.5),
n_run = 1, k_folds = 2, x.center = TRUE, x.scale = TRUE)

Description

The cv.mb.splsdacox function performs cross-validation for the MB.sPLS-DACOX model, a specialized model tailored for survival analysis with high-dimensional data. This function systematically evaluates the performance of the model across different hyperparameters and configurations to determine the optimal settings for the given data.

Usage

cv.mb.splsdacox(
  X,
  Y,
  max.ncomp = 8,
  vector = NULL,
  design = NULL,
  MIN_NVAR = 10,
  MAX_NVAR = NULL,
  n.cut_points = 5,
  EVAL_METHOD = "AUC",
  n_run = 3,
  k_folds = 10,
  x.center = TRUE,
  x.scale = FALSE,
  remove_near_zero_variance = TRUE,
  remove_zero_variance = TRUE,
  toKeep.zv = NULL,
  remove_variance_at_fold_level = FALSE,
  remove_non_significant_models = FALSE,
  remove_non_significant = FALSE,
  alpha = 0.05,
  w_AIC = 0,
  w_c.index = 0,
  w_AUC = 1,
  w_BRIER = 0,
  times = NULL,
  max_time_points = 15,
  MIN_AUC_INCREASE = 0.01,
  MIN_AUC = 0.8,
  MIN_COMP_TO_CHECK = 3,
  pred.attr = "mean",
  pred.method = "cenROC",
  max.iter = 200,
  fast_mode = FALSE,
  MIN_EPV = 5,
  return_models = FALSE,
  returnData = FALSE,
  PARALLEL = FALSE,
  verbose = FALSE,
  seed = 123
)

Arguments

Details

The function operates by partitioning the data into multiple subsets (folds) and iteratively holding out one subset for validation while training on the remaining subsets. The cross-validation process is repeated for a specified number of runs, ensuring a robust assessment of the model's performance. The function offers flexibility in terms of the number of PLS components, the range of variables considered, and the evaluation metrics used.

The function provides an option to center and scale the explanatory variables, which can be crucial for ensuring consistent performance, especially when the variables are measured on different scales. Additionally, the function incorporates features to handle near-zero and zero variance variables, which can be problematic in high-dimensional datasets.

For model evaluation, users can choose between various metrics, including AUC, c-index, and Brier Score. The function also allows for the specification of weights for these metrics, enabling users to prioritize certain metrics over others based on the research context.

The function's design also emphasizes computational efficiency. It offers a parallel processing option to expedite the cross-validation process, especially beneficial for large datasets. However, users should be cautious about potential high RAM consumption when using this option.

Value

Instance of class "Coxmos" and model "cv.MB.sPLS-DACOX". best_model_info: A data.frame with the information for the best model. df_results_folds: A data.frame with fold-level information. df_results_runs: A data.frame with run-level information. df_results_comps: A data.frame with component-level information (for cv.coxEN, EN.alpha information).

lst_models: If return_models = TRUE, return a the list of all cross-validated models. pred.method: AUC evaluation algorithm method for evaluate the model performance.

opt.comp: Optimal component selected by the best_model. opt.nvar: Optimal number of variables selected by the best_model. design: Design matrix used for computing the MultiBlocks models.

plot_AIC: AIC plot by each hyper-parameter. plot_c_index: C-Index plot by each hyper-parameter. plot_BRIER: Brier Score plot by each hyper-parameter. plot_AUC: AUC plot by each hyper-parameter.

class: Cross-Validated model class.

lst_train_indexes: List (of lists) of indexes for the observations used in each run/fold for train the models. lst_test_indexes: List (of lists) of indexes for the observations used in each run/fold for test the models.

time: time consumed for running the cross-validated function.

Author(s)

Pedro Salguero Garcia. Maintainer: [email protected]

Examples

data("X_multiomic")
data("Y_multiomic")
set.seed(123)
index_train <- caret::createDataPartition(Y_multiomic$event, p = .5, list = FALSE, times = 1)
X_train <- X_multiomic
X_train$mirna <- X_train$mirna[index_train,1:50]
X_train$proteomic <- X_train$proteomic[index_train,1:50]
Y_train <- Y_multiomic[index_train,]
cv.mb.splsdacox_model <- cv.mb.splsdacox(X_train, Y_train, max.ncomp = 2, vector = NULL,
n_run = 1, k_folds = 2, x.center = TRUE, x.scale = TRUE)

Description

The cv.mb.splsdrcox function performs cross-validation for the MB.sPLS-DRCOX model, a specialized model for survival analysis with high-dimensional data. This function systematically evaluates the performance of the model across different hyperparameters and configurations to determine the optimal settings for the given data.

Usage

cv.mb.splsdrcox(
  X,
  Y,
  max.ncomp = 8,
  vector = NULL,
  design = NULL,
  MIN_NVAR = 10,
  MAX_NVAR = NULL,
  n.cut_points = 5,
  EVAL_METHOD = "AUC",
  n_run = 3,
  k_folds = 10,
  x.center = TRUE,
  x.scale = FALSE,
  remove_near_zero_variance = TRUE,
  remove_zero_variance = TRUE,
  toKeep.zv = NULL,
  remove_variance_at_fold_level = FALSE,
  remove_non_significant_models = FALSE,
  remove_non_significant = FALSE,
  alpha = 0.05,
  w_AIC = 0,
  w_c.index = 0,
  w_AUC = 1,
  w_BRIER = 0,
  times = NULL,
  max_time_points = 15,
  MIN_AUC_INCREASE = 0.01,
  MIN_AUC = 0.8,
  MIN_COMP_TO_CHECK = 3,
  pred.attr = "mean",
  pred.method = "cenROC",
  max.iter = 200,
  fast_mode = FALSE,
  MIN_EPV = 5,
  return_models = FALSE,
  returnData = FALSE,
  PARALLEL = FALSE,
  verbose = FALSE,
  seed = 123
)

Arguments

Details

The function operates by partitioning the data into multiple subsets (folds) and iteratively holding out one subset for validation while training on the remaining subsets. The cross-validation process is repeated for a specified number of runs, ensuring a robust assessment of the model's performance. The function offers flexibility in terms of the number of PLS components, the range of variables considered, and the evaluation metrics used.

The function provides an option to center and scale the explanatory variables, which can be crucial for ensuring consistent performance, especially when the variables are measured on different scales. Additionally, the function incorporates features to handle near-zero and zero variance variables, which can be problematic in high-dimensional datasets.

For model evaluation, users can choose between various metrics, including AUC, c-index, and Brier Score. The function also allows for the specification of weights for these metrics, enabling users to prioritize certain metrics over others based on the research context.

The function's design also emphasizes computational efficiency. It offers a parallel processing option to expedite the cross-validation process, especially beneficial for large datasets. However, users should be cautious about potential high RAM consumption when using this option.

Value

Instance of class "Coxmos" and model "cv.MB.sPLS-DRCOX". best_model_info: A data.frame with the information for the best model. df_results_folds: A data.frame with fold-level information. df_results_runs: A data.frame with run-level information. df_results_comps: A data.frame with component-level information (for cv.coxEN, EN.alpha information).

lst_models: If return_models = TRUE, return a the list of all cross-validated models. pred.method: AUC evaluation algorithm method for evaluate the model performance.

opt.comp: Optimal component selected by the best_model. opt.nvar: Optimal number of variables selected by the best_model. design: Design matrix used for computing the MultiBlocks models.

plot_AIC: AIC plot by each hyper-parameter. plot_c_index: C-Index plot by each hyper-parameter. plot_BRIER: Brier Score plot by each hyper-parameter. plot_AUC: AUC plot by each hyper-parameter.

class: Cross-Validated model class.

lst_train_indexes: List (of lists) of indexes for the observations used in each run/fold for train the models. lst_test_indexes: List (of lists) of indexes for the observations used in each run/fold for test the models.

time: time consumed for running the cross-validated function.

Author(s)

Pedro Salguero Garcia. Maintainer: [email protected]

Examples

data("X_multiomic")
data("Y_multiomic")
set.seed(123)
index_train <- caret::createDataPartition(Y_multiomic$event, p = .5, list = FALSE, times = 1)
X_train <- X_multiomic
X_train$mirna <- X_train$mirna[index_train,1:50]
X_train$proteomic <- X_train$proteomic[index_train,1:50]
Y_train <- Y_multiomic[index_train,]
cv.mb.splsdrcox_model <- cv.mb.splsdrcox(X_train, Y_train, max.ncomp = 2, vector = NULL,
n_run = 1, k_folds = 2, x.center = TRUE, x.scale = TRUE)

Description

This function performs cross-validated sparse partial least squares single block for splsdacox. The function returns the optimal number of components and the optimal sparsity penalty value based on cross-validation. The performance could be based on multiple metrics as Area Under the Curve (AUC), Brier Score or C-Index. Furthermore, the user could establish more than one metric simultaneously.

Usage

cv.sb.splsdacox(
  X,
  Y,
  max.ncomp = 8,
  vector = NULL,
  MIN_NVAR = 10,
  MAX_NVAR = NULL,
  n.cut_points = 5,
  MIN_AUC_INCREASE = 0.01,
  EVAL_METHOD = "AUC",
  n_run = 3,
  k_folds = 10,
  x.center = TRUE,
  x.scale = FALSE,
  remove_near_zero_variance = TRUE,
  remove_zero_variance = TRUE,
  toKeep.zv = NULL,
  remove_variance_at_fold_level = FALSE,
  remove_non_significant_models = FALSE,
  remove_non_significant = FALSE,
  alpha = 0.05,
  w_AIC = 0,
  w_c.index = 0,
  w_AUC = 1,
  w_BRIER = 0,
  times = NULL,
  max_time_points = 15,
  MIN_AUC = 0.8,
  MIN_COMP_TO_CHECK = 3,
  pred.attr = "mean",
  pred.method = "cenROC",
  fast_mode = FALSE,
  max.iter = 200,
  MIN_EPV = 5,
  return_models = FALSE,
  returnData = FALSE,
  PARALLEL = FALSE,
  verbose = FALSE,
  seed = 123
)

Arguments

Details

The cv.sb.splsdacox_dynamic function performs cross-validation for the single-block sparse partial least squares deviance residual Cox analysis. Cross-validation is a robust method to evaluate the performance of a statistical model by partitioning the original sample into a training set to train the model, and a test set to evaluate it. This helps in selecting the optimal hyperparameters for the model, such as the number of latent components (max.ncomp) and the penalty for variable selection (penalty.list).

The function systematically evaluates different combinations of hyperparameters by performing multiple runs and folds. For each combination, the dataset is divided into training and test sets based on the specified number of folds (k_folds). The model is then trained on the training set and evaluated on the test set. This process is repeated for the specified number of runs (n_run), ensuring a comprehensive evaluation of the model's performance across different partitions of the data.

Various evaluation metrics, such as AIC, C-Index, Brier Score, and AUC, are computed for each combination of hyperparameters. These metrics provide insights into the model's accuracy, discriminative ability, and calibration. The function then identifies the optimal hyperparameters that yield the best performance based on the specified evaluation metrics.

The function also offers flexibility in data preprocessing, such as centering and scaling of the explanatory variables, removal of near-zero variance variables, and more. Additionally, users can specify the AUC evaluation algorithm method (pred.method) and control the verbosity of the output (verbose).

The output provides a comprehensive overview of the cross-validation results, including detailed information at the fold, run, and component levels. Visualization tools, such as plots for AIC, C-Index, Brier Score, and AUC, are also provided to aid in understanding the model's performance across different hyperparameters.

In summary, the cv.sb.splsdacox_dynamic function offers a robust approach for hyperparameter tuning and model evaluation for the single-block sparse partial least squares deviance residual Cox analysis. It ensures that the final model is both accurate and generalizable to new data.

Value

Instance of class "Coxmos" and model "cv.SB.sPLS-DACOX-Dynamic". best_model_info: A data.frame with the information for the best model. df_results_folds: A data.frame with fold-level information. df_results_runs: A data.frame with run-level information. df_results_comps: A data.frame with component-level information (for cv.coxEN, EN.alpha information).

lst_models: If return_models = TRUE, return a the list of all cross-validated models. pred.method: AUC evaluation algorithm method for evaluate the model performance.

opt.comp: Optimal component selected by the best_model. opt.nvar: Optimal penalty/penalty selected by the best_model. opt.nvar: Optimal number of variables selected by the best_model.

plot_AIC: AIC plot by each hyper-parameter. plot_c_index: C-Index plot by each hyper-parameter. plot_BRIER: Brier Score plot by each hyper-parameter. plot_AUC: AUC plot by each hyper-parameter.

class: Cross-Validated model class.

lst_train_indexes: List (of lists) of indexes for the observations used in each run/fold for train the models. lst_test_indexes: List (of lists) of indexes for the observations used in each run/fold for test the models.

time: time consumed for running the cross-validated function.

Author(s)

Pedro Salguero Garcia. Maintainer: [email protected]

Examples

data("X_multiomic")
data("Y_multiomic")
set.seed(123)
index_train <- caret::createDataPartition(Y_multiomic$event, p = .25, list = FALSE, times = 1)
X_train <- X_multiomic
X_train$mirna <- X_train$mirna[index_train,1:20]
X_train$proteomic <- X_train$proteomic[index_train,1:20]
Y_train <- Y_multiomic[index_train,]
vector <- list()
vector$mirna <- c(10, 20)
vector$proteomic <- c(10, 20)
cv.sb.splsdacox_dynamic_model <- cv.sb.splsdacox(X_train, Y_train, max.ncomp = 1,
vector = vector, n_run = 1, k_folds = 3, x.center = TRUE, x.scale = TRUE)

Description

This function performs cross-validated sparse partial least squares single block for splsdrcox. The function returns the optimal number of components and the optimal sparsity penalty value based on cross-validation. The performance could be based on multiple metrics as Area Under the Curve (AUC), Brier Score or C-Index. Furthermore, the user could establish more than one metric simultaneously.

Usage

cv.sb.splsdrcox(
  X,
  Y,
  max.ncomp = 8,
  vector = NULL,
  MIN_NVAR = 10,
  MAX_NVAR = NULL,
  n.cut_points = 5,
  MIN_AUC_INCREASE = 0.01,
  EVAL_METHOD = "AUC",
  n_run = 3,
  k_folds = 10,
  x.center = TRUE,
  x.scale = FALSE,
  remove_near_zero_variance = TRUE,
  remove_zero_variance = TRUE,
  toKeep.zv = NULL,
  remove_variance_at_fold_level = FALSE,
  remove_non_significant_models = FALSE,
  remove_non_significant = FALSE,
  alpha = 0.05,
  w_AIC = 0,
  w_c.index = 0,
  w_AUC = 1,
  w_BRIER = 0,
  times = NULL,
  max_time_points = 15,
  MIN_AUC = 0.8,
  MIN_COMP_TO_CHECK = 3,
  pred.attr = "mean",
  pred.method = "cenROC",
  fast_mode = FALSE,
  max.iter = 200,
  MIN_EPV = 5,
  return_models = FALSE,
  returnData = FALSE,
  PARALLEL = FALSE,
  verbose = FALSE,
  seed = 123
)

Arguments

Details

The cv.sb.splsdrcox function performs cross-validation for the single-block sparse partial least squares deviance residual Cox analysis. Cross-validation is a robust method to evaluate the performance of a statistical model by partitioning the original sample into a training set to train the model, and a test set to evaluate it. This helps in selecting the optimal hyperparameters for the model, such as the number of latent components (max.ncomp) and the penalty for variable selection (penalty.list).

The function systematically evaluates different combinations of hyperparameters by performing multiple runs and folds. For each combination, the dataset is divided into training and test sets based on the specified number of folds (k_folds). The model is then trained on the training set and evaluated on the test set. This process is repeated for the specified number of runs (n_run), ensuring a comprehensive evaluation of the model's performance across different partitions of the data.

Various evaluation metrics, such as AIC, C-Index, Brier Score, and AUC, are computed for each combination of hyperparameters. These metrics provide insights into the model's accuracy, discriminative ability, and calibration. The function then identifies the optimal hyperparameters that yield the best performance based on the specified evaluation metrics.

The function also offers flexibility in data preprocessing, such as centering and scaling of the explanatory variables, removal of near-zero variance variables, and more. Additionally, users can specify the AUC evaluation algorithm method (pred.method) and control the verbosity of the output (verbose).

The output provides a comprehensive overview of the cross-validation results, including detailed information at the fold, run, and component levels. Visualization tools, such as plots for AIC, C-Index, Brier Score, and AUC, are also provided to aid in understanding the model's performance across different hyperparameters.

In summary, the cv.sb.splsdrcox function offers a robust approach for hyperparameter tuning and model evaluation for the single-block sparse partial least squares deviance residual Cox analysis. It ensures that the final model is both accurate and generalizable to new data.

Value

Instance of class "Coxmos" and model "cv.SB.sPLS-DRCOX-Dynamic". best_model_info: A data.frame with the information for the best model. df_results_folds: A data.frame with fold-level information. df_results_runs: A data.frame with run-level information. df_results_comps: A data.frame with component-level information (for cv.coxEN, EN.alpha information).

lst_models: If return_models = TRUE, return a the list of all cross-validated models. pred.method: AUC evaluation algorithm method for evaluate the model performance.

opt.comp: Optimal component selected by the best_model. opt.nvar: Optimal penalty/penalty selected by the best_model. opt.nvar: Optimal number of variables selected by the best_model.

plot_AIC: AIC plot by each hyper-parameter. plot_c_index: C-Index plot by each hyper-parameter. plot_BRIER: Brier Score plot by each hyper-parameter. plot_AUC: AUC plot by each hyper-parameter.

class: Cross-Validated model class.

lst_train_indexes: List (of lists) of indexes for the observations used in each run/fold for train the models. lst_test_indexes: List (of lists) of indexes for the observations used in each run/fold for test the models.

time: time consumed for running the cross-validated function.

Author(s)

Pedro Salguero Garcia. Maintainer: [email protected]

Examples

data("X_multiomic")
data("Y_multiomic")
set.seed(123)
index_train <- caret::createDataPartition(Y_multiomic$event, p = .25, list = FALSE, times = 1)
X_train <- X_multiomic
X_train$mirna <- X_train$mirna[index_train,1:30]
X_train$proteomic <- X_train$proteomic[index_train,1:30]
Y_train <- Y_multiomic[index_train,]
vector <- list()
vector$mirna <- c(10, 15)
vector$proteomic <- c(10, 15)
cv.sb.splsdrcox_model <- cv.sb.splsdrcox(X_train, Y_train, max.ncomp = 2, vector = vector,
n_run = 1, k_folds = 3, x.center = TRUE, x.scale = TRUE)

Description

This function performs cross-validated sparse partial least squares single block for splsdrcox. The function returns the optimal number of components and the optimal sparsity penalty value based on cross-validation. The performance could be based on multiple metrics as Area Under the Curve (AUC), Brier Score or C-Index. Furthermore, the user could establish more than one metric simultaneously.

Usage

cv.sb.splsdrcox_penalty(
  X,
  Y,
  max.ncomp = 8,
  penalty.list = seq(0.1, 0.9, 0.2),
  n_run = 3,
  k_folds = 10,
  x.center = TRUE,
  x.scale = FALSE,
  remove_near_zero_variance = TRUE,
  remove_zero_variance = TRUE,
  toKeep.zv = NULL,
  remove_variance_at_fold_level = FALSE,
  remove_non_significant_models = FALSE,
  remove_non_significant = FALSE,
  alpha = 0.05,
  w_AIC = 0,
  w_c.index = 0,
  w_AUC = 1,
  w_BRIER = 0,
  times = NULL,
  max_time_points = 15,
  MIN_AUC_INCREASE = 0.01,
  MIN_AUC = 0.8,
  MIN_COMP_TO_CHECK = 3,
  pred.attr = "mean",
  pred.method = "cenROC",
  fast_mode = FALSE,
  MIN_EPV = 5,
  return_models = FALSE,
  returnData = FALSE,
  PARALLEL = FALSE,
  verbose = FALSE,
  seed = 123
)

Arguments

Details

The cv.sb.splsdrcox function performs cross-validation for the single-block sparse partial least squares deviance residual Cox analysis. Cross-validation is a robust method to evaluate the performance of a statistical model by partitioning the original sample into a training set to train the model, and a test set to evaluate it. This helps in selecting the optimal hyperparameters for the model, such as the number of latent components (max.ncomp) and the penalty for variable selection (penalty.list).

The function systematically evaluates different combinations of hyperparameters by performing multiple runs and folds. For each combination, the dataset is divided into training and test sets based on the specified number of folds (k_folds). The model is then trained on the training set and evaluated on the test set. This process is repeated for the specified number of runs (n_run), ensuring a comprehensive evaluation of the model's performance across different partitions of the data.

Various evaluation metrics, such as AIC, C-Index, Brier Score, and AUC, are computed for each combination of hyperparameters. These metrics provide insights into the model's accuracy, discriminative ability, and calibration. The function then identifies the optimal hyperparameters that yield the best performance based on the specified evaluation metrics.

The function also offers flexibility in data preprocessing, such as centering and scaling of the explanatory variables, removal of near-zero variance variables, and more. Additionally, users can specify the AUC evaluation algorithm method (pred.method) and control the verbosity of the output (verbose).

The output provides a comprehensive overview of the cross-validation results, including detailed information at the fold, run, and component levels. Visualization tools, such as plots for AIC, C-Index, Brier Score, and AUC, are also provided to aid in understanding the model's performance across different hyperparameters.

In summary, the cv.sb.splsdrcox function offers a robust approach for hyperparameter tuning and model evaluation for the single-block sparse partial least squares deviance residual Cox analysis. It ensures that the final model is both accurate and generalizable to new data.

Value

Instance of class "Coxmos" and model "cv.SB.sPLS-DRCOX". best_model_info: A data.frame with the information for the best model. df_results_folds: A data.frame with fold-level information. df_results_runs: A data.frame with run-level information. df_results_comps: A data.frame with component-level information (for cv.coxEN, EN.alpha information).

lst_models: If return_models = TRUE, return a the list of all cross-validated models. pred.method: AUC evaluation algorithm method for evaluate the model performance.

opt.comp: Optimal component selected by the best_model. opt.penalty: Optimal penalty/penalty selected by the best_model. opt.nvar: Optimal number of variables selected by the best_model.

plot_AIC: AIC plot by each hyper-parameter. plot_c_index: C-Index plot by each hyper-parameter. plot_BRIER: Brier Score plot by each hyper-parameter. plot_AUC: AUC plot by each hyper-parameter.

class: Cross-Validated model class.

lst_train_indexes: List (of lists) of indexes for the observations used in each run/fold for train the models. lst_test_indexes: List (of lists) of indexes for the observations used in each run/fold for test the models.

time: time consumed for running the cross-validated function.

Author(s)

Pedro Salguero Garcia. Maintainer: [email protected]

Examples

data("X_multiomic")
data("Y_multiomic")
set.seed(123)
index_train <- caret::createDataPartition(Y_multiomic$event, p = .25, list = FALSE, times = 1)
X_train <- X_multiomic
X_train$mirna <- X_train$mirna[index_train,1:30]
X_train$proteomic <- X_train$proteomic[index_train,1:30]
Y_train <- Y_multiomic[index_train,]
cv.sb.splsdrcox_model <- cv.sb.splsdrcox_penalty(X_train, Y_train, max.ncomp = 2,
penalty.list = c(0.5), n_run = 1, k_folds = 3, x.center = TRUE, x.scale = TRUE)

Description

This function performs cross-validated sparse partial least squares single block for splsicox. The function returns the optimal number of components and the optimal sparsity penalty value based on cross-validation. The performance could be based on multiple metrics as Area Under the Curve (AUC), Brier Score or C-Index. Furthermore, the user could establish more than one metric simultaneously.

Usage

cv.sb.splsicox(
  X,
  Y,
  max.ncomp = 8,
  penalty.list = seq(0.1, 0.9, 0.2),
  n_run = 3,
  k_folds = 10,
  x.center = TRUE,
  x.scale = FALSE,
  remove_near_zero_variance = TRUE,
  remove_zero_variance = TRUE,
  toKeep.zv = NULL,
  remove_variance_at_fold_level = FALSE,
  remove_non_significant_models = FALSE,
  remove_non_significant = FALSE,
  alpha = 0.05,
  w_AIC = 0,
  w_c.index = 0,
  w_AUC = 1,
  w_BRIER = 0,
  times = NULL,
  max_time_points = 15,
  MIN_AUC_INCREASE = 0.01,
  MIN_AUC = 0.8,
  MIN_COMP_TO_CHECK = 3,
  pred.attr = "mean",
  pred.method = "cenROC",
  fast_mode = FALSE,
  MIN_EPV = 5,
  return_models = FALSE,
  returnData = FALSE,
  PARALLEL = FALSE,
  verbose = FALSE,
  seed = 123
)

Arguments

Details

The cv.sb.splsicox function performs cross-validation for the single-block sparse partial least squares individual Cox analysis. While the function can handle datasets with multiple blocks, it processes each block individually, ensuring a detailed examination of each block's contribution to the survival outcome. This is distinct from multiblock methods where all blocks are analyzed simultaneously.

In the context of this function, "single-block" means that each block of data is analyzed separately, one at a time. This approach is beneficial when different blocks represent distinct types or sources of data, allowing for a granular understanding of each block's significance without the interference of other blocks.

The cross-validation process involves partitioning the dataset into multiple subsets (folds) and then iteratively training the model on a subset of the data while validating it on the remaining data. This helps in determining the optimal hyperparameters for the model, such as the number of latent components and the penalty for variable selection.

The function offers flexibility in specifying various hyperparameters and options for data preprocessing. The output provides a comprehensive overview of the cross-validation results, including metrics like AIC, C-Index, Brier Score, and AUC for each hyper-parameter combination. Visualization tools are also provided to aid in understanding the model's performance across different hyperparameters.

In summary, the cv.sb.splsicox function offers a robust approach for determining the optimal parameters for the single-block sparse partial least squares individual Cox analysis, ensuring optimal feature selection, dimensionality reduction, and predictive modeling for each individual block in the dataset.

Value

Instance of class "Coxmos" and model "cv.SB.sPLS-ICOX". best_model_info: A data.frame with the information for the best model. df_results_folds: A data.frame with fold-level information. df_results_runs: A data.frame with run-level information. df_results_comps: A data.frame with component-level information (for cv.coxEN, EN.alpha information).

lst_models: If return_models = TRUE, return a the list of all cross-validated models. pred.method: AUC evaluation algorithm method for evaluate the model performance.

opt.comp: Optimal component selected by the best_model. opt.penalty: Optimal penalty value selected by the best_model.

plot_AIC: AIC plot by each hyper-parameter. plot_c_index: C-Index plot by each hyper-parameter. plot_BRIER: Brier Score plot by each hyper-parameter. plot_AUC: AUC plot by each hyper-parameter.

class: Cross-Validated model class.

lst_train_indexes: List (of lists) of indexes for the observations used in each run/fold for train the models. lst_test_indexes: List (of lists) of indexes for the observations used in each run/fold for test the models.

time: time consumed for running the cross-validated function.

Author(s)

Pedro Salguero Garcia. Maintainer: [email protected]

Examples

data("X_multiomic")
data("Y_multiomic")
set.seed(123)
index_train <- caret::createDataPartition(Y_multiomic$event, p = .5, list = FALSE, times = 1)
X_train <- X_multiomic
X_train$mirna <- X_train$mirna[index_train,1:50]
X_train$proteomic <- X_train$proteomic[index_train,1:50]
Y_train <- Y_multiomic[index_train,]
cv.sb.splsicox_model <- cv.sb.splsicox(X_train, Y_train, max.ncomp = 2, penalty.list = c(0.5),
n_run = 1, k_folds = 2, x.center = TRUE, x.scale = TRUE)

Description

The cv.splsdacox_dynamic function performs cross-validation for the sPLS-DA-COX-Dynamic model. This model is designed to handle survival data, where the response variables are time-to-event and event/censoring indicators. The function offers a comprehensive set of parameters to fine-tune the cross-validation process, including options for data preprocessing, model evaluation, and parallel processing.

Usage

cv.splsdacox(
  X,
  Y,
  max.ncomp = 8,
  vector = NULL,
  MIN_NVAR = 10,
  MAX_NVAR = NULL,
  n.cut_points = 5,
  MIN_AUC_INCREASE = 0.01,
  n_run = 3,
  k_folds = 10,
  x.center = TRUE,
  x.scale = FALSE,
  remove_near_zero_variance = TRUE,
  remove_zero_variance = TRUE,
  toKeep.zv = NULL,
  remove_variance_at_fold_level = FALSE,
  remove_non_significant_models = FALSE,
  remove_non_significant = FALSE,
  alpha = 0.05,
  EVAL_METHOD = "AUC",
  w_AIC = 0,
  w_c.index = 0,
  w_AUC = 1,
  w_BRIER = 0,
  times = NULL,
  max_time_points = 15,
  MIN_AUC = 0.8,
  MIN_COMP_TO_CHECK = 3,
  pred.attr = "mean",
  pred.method = "cenROC",
  fast_mode = FALSE,
  max.iter = 200,
  MIN_EPV = 5,
  return_models = FALSE,
  returnData = FALSE,
  PARALLEL = FALSE,
  verbose = FALSE,
  seed = 123
)

Arguments

Details

The function begins by ensuring that the required libraries for evaluation metrics are installed. It then checks the validity of the input parameters, such as ensuring that the response variables have the appropriate column names ("time" and "event") and that the evaluation weights sum to 1.

Data preprocessing steps include the potential removal of variables with zero or near-zero variance, and the transformation of explanatory variables to ensure they are centered or scaled as specified. The function also provides an option to remove variables based on their coefficient of variation.

The core of the function revolves around the cross-validation process. Data is split into training and test sets for each run and fold. For each combination of run, fold, and specified number of PLS components, a sPLS-DA-COX-Dynamic model is trained. The performance of these models is then evaluated using a combination of metrics, including the Akaike Information Criterion (AIC), C-index, Brier Score, and Area Under the Curve (AUC). The function provides flexibility in choosing the evaluation metric and its method.

Value

Instance of class "Coxmos" and model "cv.sPLS-DACOX-Dynamic". best_model_info: A data.frame with the information for the best model. df_results_folds: A data.frame with fold-level information. df_results_runs: A data.frame with run-level information. df_results_comps: A data.frame with component-level information (for cv.coxEN, EN.alpha information).

lst_models: If return_models = TRUE, return a the list of all cross-validated models. pred.method: AUC evaluation algorithm method for evaluate the model performance.

opt.comp: Optimal component selected by the best_model. opt.nvar: Optimal number of variables selected by the best_model.

plot_AIC: AIC plot by each hyper-parameter. plot_c_index: C-Index plot by each hyper-parameter. plot_BRIER: Brier Score plot by each hyper-parameter. plot_AUC: AUC plot by each hyper-parameter.

class: Cross-Validated model class.

lst_train_indexes: List (of lists) of indexes for the observations used in each run/fold for train the models. lst_test_indexes: List (of lists) of indexes for the observations used in each run/fold for test the models.

time: time consumed for running the cross-validated function.

Author(s)

Pedro Salguero Garcia. Maintainer: [email protected]

Examples

data("X_proteomic")
data("Y_proteomic")
set.seed(123)
index_train <- caret::createDataPartition(Y_proteomic$event, p = .5, list = FALSE, times = 1)
X_train <- X_proteomic[index_train,1:50]
Y_train <- Y_proteomic[index_train,]
cv.splsdacox_dynamic_model <- cv.splsdacox(X_train, Y_train, max.ncomp = 2, vector = NULL,
n_run = 1, k_folds = 2, x.center = TRUE, x.scale = TRUE)

Description

The function cv.splsdrcox_dynamic conducts a cross-validation for the sPLS-DRCOX model, which is a specialized model tailored for survival analysis. The function aims to optimize the model's performance by determining the best number of PLS components and variables through cross-validation.

Usage

cv.splsdrcox(
  X,
  Y,
  max.ncomp = 8,
  vector = NULL,
  MIN_NVAR = 10,
  MAX_NVAR = NULL,
  n.cut_points = 5,
  MIN_AUC_INCREASE = 0.01,
  EVAL_METHOD = "AUC",
  n_run = 3,
  k_folds = 10,
  x.center = TRUE,
  x.scale = FALSE,
  remove_near_zero_variance = TRUE,
  remove_zero_variance = TRUE,
  toKeep.zv = NULL,
  remove_variance_at_fold_level = FALSE,
  remove_non_significant_models = FALSE,
  remove_non_significant = FALSE,
  alpha = 0.05,
  w_AIC = 0,
  w_c.index = 0,
  w_AUC = 1,
  w_BRIER = 0,
  times = NULL,
  max_time_points = 15,
  MIN_AUC = 0.8,
  MIN_COMP_TO_CHECK = 3,
  pred.attr = "mean",
  pred.method = "cenROC",
  fast_mode = FALSE,
  max.iter = 200,
  MIN_EPV = 5,
  return_models = FALSE,
  returnData = FALSE,
  PARALLEL = FALSE,
  verbose = FALSE,
  seed = 123
)

Arguments

Details

The cv.splsdrcox_dynamic function is designed to perform cross-validation for the sPLS-DRCOX model, a specialized model for survival analysis. The function's primary objective is to identify the optimal number of PLS components and variables that yield the best model performance.

The function accepts both numeric matrices and data frames for explanatory (X) and response (Y) variables. It is essential to ensure that qualitative variables in X are transformed into binary format. The response variable Y should have two columns: "time" and "event". The event column should contain binary values, where 0/1 or FALSE/TRUE represent censored and event observations, respectively.

The cross-validation process is controlled by several parameters, including the maximum number of PLS components (max.ncomp), the number of runs (n_run), and the number of folds (k_folds). The function also provides options for data preprocessing, such as centering and scaling of the X matrix, and removal of variables with near-zero or zero variance.

Significance testing is incorporated into the model evaluation process. Users can specify the alpha threshold (alpha) for determining significance. Non-significant models or variables can be optionally removed from the evaluation based on user-defined criteria.

The function also offers flexibility in model evaluation metrics. Users can choose between different metrics such as AUC, AIC, C-Index, and Brier Score. The importance of each metric in the evaluation can be controlled using weights (w_AIC, w_c.index, w_AUC, w_BRIER).

For computational efficiency, the function provides an option to run the cross-validation in parallel (PARALLEL). Additionally, verbose logging can be enabled to display extra messages during the execution.

Value

Instance of class "Coxmos" and model "cv.sPLS-DRCOX-Dynamic". best_model_info: A data.frame with the information for the best model. df_results_folds: A data.frame with fold-level information. df_results_runs: A data.frame with run-level information. df_results_comps: A data.frame with component-level information (for cv.coxEN, EN.alpha information).

lst_models: If return_models = TRUE, return a the list of all cross-validated models. pred.method: AUC evaluation algorithm method for evaluate the model performance.

opt.comp: Optimal component selected by the best_model. opt.nvar: Optimal number of variables selected by the best_model.

plot_AIC: AIC plot by each hyper-parameter. plot_c_index: C-Index plot by each hyper-parameter. plot_BRIER: Brier Score plot by each hyper-parameter. plot_AUC: AUC plot by each hyper-parameter.

class: Cross-Validated model class.

lst_train_indexes: List (of lists) of indexes for the observations used in each run/fold for train the models. lst_test_indexes: List (of lists) of indexes for the observations used in each run/fold for test the models.

time: time consumed for running the cross-validated function.

Author(s)

Pedro Salguero Garcia. Maintainer: [email protected]

Examples

data("X_proteomic")
data("Y_proteomic")
set.seed(123)
index_train <- caret::createDataPartition(Y_proteomic$event, p = .5, list = FALSE, times = 1)
X_train <- X_proteomic[index_train,1:20]
Y_train <- Y_proteomic[index_train,]
cv.splsdrcox_dynamic_model <- cv.splsdrcox(X = X_train, Y = Y_train, max.ncomp = 1,
vector = NULL, n_run = 1, k_folds = 2, x.center = TRUE, x.scale = TRUE)

Description

This function performs cross-validated sparse partial least squares DRCox (sPLS-DRCOX). The function returns the optimal number of components and the optimal sparsity penalty value based on cross-validation. The performance could be based on multiple metrics as Area Under the Curve (AUC), Brier Score or C-Index. Furthermore, the user could establish more than one metric simultaneously.

This function performs cross-validated sparse partial least squares DRCox (sPLS-DRCOX). The function returns the optimal number of components and the optimal sparsity penalty value based on cross-validation. The performance could be based on multiple metrics as Area Under the Curve (AUC), Brier Score or C-Index. Furthermore, the user could establish more than one metric simultaneously.

Usage

cv.splsdrcox_penalty(
  X,
  Y,
  max.ncomp = 8,
  penalty.list = seq(0.1, 0.9, 0.2),
  n_run = 3,
  k_folds = 10,
  x.center = TRUE,
  x.scale = FALSE,
  remove_near_zero_variance = TRUE,
  remove_zero_variance = TRUE,
  toKeep.zv = NULL,
  remove_variance_at_fold_level = FALSE,
  remove_non_significant_models = FALSE,
  remove_non_significant = FALSE,
  alpha = 0.05,
  w_AIC = 0,
  w_c.index = 0,
  w_AUC = 1,
  w_BRIER = 0,
  times = NULL,
  max_time_points = 15,
  MIN_AUC_INCREASE = 0.01,
  MIN_AUC = 0.8,
  MIN_COMP_TO_CHECK = 3,
  pred.attr = "mean",
  pred.method = "cenROC",
  fast_mode = FALSE,
  MIN_EPV = 5,
  return_models = FALSE,
  returnData = FALSE,
  PARALLEL = FALSE,
  verbose = FALSE,
  seed = 123
)

cv.splsdrcox_penalty(
  X,
  Y,
  max.ncomp = 8,
  penalty.list = seq(0.1, 0.9, 0.2),
  n_run = 3,
  k_folds = 10,
  x.center = TRUE,
  x.scale = FALSE,
  remove_near_zero_variance = TRUE,
  remove_zero_variance = TRUE,
  toKeep.zv = NULL,
  remove_variance_at_fold_level = FALSE,
  remove_non_significant_models = FALSE,
  remove_non_significant = FALSE,
  alpha = 0.05,
  w_AIC = 0,
  w_c.index = 0,
  w_AUC = 1,
  w_BRIER = 0,
  times = NULL,
  max_time_points = 15,
  MIN_AUC_INCREASE = 0.01,
  MIN_AUC = 0.8,
  MIN_COMP_TO_CHECK = 3,
  pred.attr = "mean",
  pred.method = "cenROC",
  fast_mode = FALSE,
  MIN_EPV = 5,
  return_models = FALSE,
  returnData = FALSE,
  PARALLEL = FALSE,
  verbose = FALSE,
  seed = 123
)

Arguments

Details

The ⁠sPLS-DRCOX Cross-Validation⁠ function offers a robust approach to fine-tune the hyperparameters of the sPLS-DRCOX model, ensuring optimal performance in survival analysis tasks. By systematically evaluating different combinations of hyperparameters, this function identifies the best model configuration that minimizes prediction error.

Cross-validation is a crucial step in survival analysis, especially when dealing with high-dimensional datasets. It provides an unbiased assessment of the model's generalization capability, safeguarding against overfitting. This function employs a k-fold cross-validation strategy, partitioning the data into multiple subsets (folds) and iteratively using each fold as a test set while the remaining folds serve as training data.

One of the primary strengths of this function is its flexibility. Users can specify a range of values for the number of PLS components and the penalty parameter penalty. The function then evaluates all possible combinations, returning the optimal configuration that yields the best predictive performance.

Additionally, the function offers advanced features like parallel processing for faster computation, and the ability to return all models from the cross-validation process. This is particularly useful for in-depth analysis and comparisons.

The output provides comprehensive insights, including performance metrics for each fold, run, and hyperparameter combination. Visualization plots like AIC, C-Index, Brier Score, and AUC plots further aid in understanding the model's performance across different configurations.

The ⁠sPLS-DRCOX Cross-Validation⁠ function offers a robust approach to fine-tune the hyperparameters of the sPLS-DRCOX model, ensuring optimal performance in survival analysis tasks. By systematically evaluating different combinations of hyperparameters, this function identifies the best model configuration that minimizes prediction error.

Cross-validation is a crucial step in survival analysis, especially when dealing with high-dimensional datasets. It provides an unbiased assessment of the model's generalization capability, safeguarding against overfitting. This function employs a k-fold cross-validation strategy, partitioning the data into multiple subsets (folds) and iteratively using each fold as a test set while the remaining folds serve as training data.

One of the primary strengths of this function is its flexibility. Users can specify a range of values for the number of PLS components and the penalty parameter penalty. The function then evaluates all possible combinations, returning the optimal configuration that yields the best predictive performance.

Additionally, the function offers advanced features like parallel processing for faster computation, and the ability to return all models from the cross-validation process. This is particularly useful for in-depth analysis and comparisons.

The output provides comprehensive insights, including performance metrics for each fold, run, and hyperparameter combination. Visualization plots like AIC, C-Index, Brier Score, and AUC plots further aid in understanding the model's performance across different configurations.

Value

Instance of class "Coxmos" and model "cv.sPLS-DRCOX". best_model_info: A data.frame with the information for the best model. df_results_folds: A data.frame with fold-level information. df_results_runs: A data.frame with run-level information. df_results_comps: A data.frame with component-level information (for cv.coxEN, EN.alpha information).

lst_models: If return_models = TRUE, return a the list of all cross-validated models. pred.method: AUC evaluation algorithm method for evaluate the model performance.

opt.comp: Optimal component selected by the best_model. opt.penalty: Optimal penalty/penalty selected by the best_model. opt.nvar: Optimal number of variables selected by the best_model.

plot_AIC: AIC plot by each hyper-parameter. plot_c_index: C-Index plot by each hyper-parameter. plot_BRIER: Brier Score plot by each hyper-parameter. plot_AUC: AUC plot by each hyper-parameter.

class: Cross-Validated model class.

lst_train_indexes: List (of lists) of indexes for the observations used in each run/fold for train the models. lst_test_indexes: List (of lists) of indexes for the observations used in each run/fold for test the models.

time: time consumed for running the cross-validated function.

Instance of class "Coxmos" and model "cv.sPLS-DRCOX". best_model_info: A data.frame with the information for the best model. df_results_folds: A data.frame with fold-level information. df_results_runs: A data.frame with run-level information. df_results_comps: A data.frame with component-level information (for cv.coxEN, EN.alpha information).

lst_models: If return_models = TRUE, return a the list of all cross-validated models. pred.method: AUC evaluation algorithm method for evaluate the model performance.

opt.comp: Optimal component selected by the best_model. opt.penalty: Optimal penalty/penalty selected by the best_model. opt.nvar: Optimal number of variables selected by the best_model.

plot_AIC: AIC plot by each hyper-parameter. plot_c_index: C-Index plot by each hyper-parameter. plot_BRIER: Brier Score plot by each hyper-parameter. plot_AUC: AUC plot by each hyper-parameter.

class: Cross-Validated model class.

lst_train_indexes: List (of lists) of indexes for the observations used in each run/fold for train the models. lst_test_indexes: List (of lists) of indexes for the observations used in each run/fold for test the models.

time: time consumed for running the cross-validated function.

Author(s)

Pedro Salguero Garcia. Maintainer: [email protected]

Examples

data("X_proteomic")
data("Y_proteomic")
set.seed(123)
index_train <- caret::createDataPartition(Y_proteomic$event, p = .5, list = FALSE, times = 1)
X_train <- X_proteomic[index_train,1:50]
Y_train <- Y_proteomic[index_train,]
cv.splsdrcox_model <- cv.splsdrcox_penalty(X_train, Y_train, max.ncomp = 2, penalty.list = c(0.1),
n_run = 1, k_folds = 2, x.center = TRUE, x.scale = TRUE)
data("X_proteomic")
data("Y_proteomic")
set.seed(123)
index_train <- caret::createDataPartition(Y_proteomic$event, p = .5, list = FALSE, times = 1)
X_train <- X_proteomic[index_train,1:50]
Y_train <- Y_proteomic[index_train,]
cv.splsdrcox_model <- cv.splsdrcox_penalty(X_train, Y_train, max.ncomp = 2, penalty.list = c(0.1),
n_run = 1, k_folds = 2, x.center = TRUE, x.scale = TRUE)

Description

This function performs cross-validated sparse partial least squares Cox (sPLS-ICOX). The function returns the optimal number of components and the optimal sparsity penalty value based on cross-validation. The performance could be based on multiple metrics as Area Under the Curve (AUC), Brier Score or C-Index. Furthermore, the user could establish more than one metric simultaneously.

Usage

cv.splsicox(
  X,
  Y,
  max.ncomp = 8,
  penalty.list = seq(0, 0.9, 0.1),
  n_run = 3,
  k_folds = 10,
  x.center = TRUE,
  x.scale = FALSE,
  remove_near_zero_variance = TRUE,
  remove_zero_variance = TRUE,
  toKeep.zv = NULL,
  remove_variance_at_fold_level = FALSE,
  remove_non_significant_models = FALSE,
  remove_non_significant = FALSE,
  alpha = 0.05,
  w_AIC = 0,
  w_c.index = 0,
  w_AUC = 1,
  w_BRIER = 0,
  times = NULL,
  max_time_points = 15,
  MIN_AUC_INCREASE = 0.05,
  MIN_AUC = 0.8,
  MIN_COMP_TO_CHECK = 3,
  pred.attr = "mean",
  pred.method = "cenROC",
  fast_mode = FALSE,
  MIN_EPV = 5,
  return_models = FALSE,
  returnData = FALSE,
  PARALLEL = FALSE,
  verbose = FALSE,
  seed = 123
)

Arguments

Details

The ⁠sPLS-ICOX Cross-Validation⁠ function offers a systematic approach to determine the optimal hyperparameters for the sparse partial least squares Cox (sPLS-ICOX) model through cross-validation. This function aims to identify the best combination of the number of PLS components (max.ncomp) and the sparsity penalty (penalty.list) by evaluating model performance across multiple metrics such as Area Under the Curve (AUC), Brier Score, and C-Index.

Cross-validation is executed through a series of runs (n_run) and folds (k_folds), ensuring a robust assessment of model performance. The function provides flexibility in defining the evaluation criteria, allowing users to set weights for different metrics (w_AIC, w_c.index, w_AUC, w_BRIER) and to specify the desired evaluation method (pred.method).

An essential feature of this function is its ability to halt the evaluation process based on predefined conditions. If the improvement in AUC across successive models does not surpass the MIN_AUC_INCREASE threshold or if the desired AUC (MIN_AUC) is achieved, the evaluation can be terminated early, optimizing computational efficiency.

The function also incorporates various data preprocessing options, emphasizing the importance of data quality in model performance. For instance, near-zero and zero variance variables can be removed either globally or at the fold level. Additionally, the function can handle multicore processing (PARALLEL option) to expedite the cross-validation process.

Upon completion, the function returns a comprehensive output, including detailed information about the best model, performance metrics at various levels (fold, run, component), and optionally, all cross-validated models.

Value

Instance of class "Coxmos" and model "cv.sPLS-ICOX". best_model_info: A data.frame with the information for the best model. df_results_folds: A data.frame with fold-level information. df_results_runs: A data.frame with run-level information. df_results_comps: A data.frame with component-level information (for cv.coxEN, EN.alpha information).

lst_models: If return_models = TRUE, return a the list of all cross-validated models. pred.method: AUC evaluation algorithm method for evaluate the model performance.

opt.comp: Optimal component selected by the best_model. opt.penalty: Optimal penalty value selected by the best_model.

plot_AIC: AIC plot by each hyper-parameter. plot_c_index: C-Index plot by each hyper-parameter. plot_BRIER: Brier Score plot by each hyper-parameter. plot_AUC: AUC plot by each hyper-parameter.

class: Cross-Validated model class.

lst_train_indexes: List (of lists) of indexes for the observations used in each run/fold for train the models. lst_test_indexes: List (of lists) of indexes for the observations used in each run/fold for test the models.

time: time consumed for running the cross-validated function.

Author(s)

Pedro Salguero Garcia. Maintainer: [email protected]

Examples

data("X_proteomic")
data("Y_proteomic")
set.seed(123)
index_train <- caret::createDataPartition(Y_proteomic$event, p = .5, list = FALSE, times = 1)
X_train <- X_proteomic[index_train,1:50]
Y_train <- Y_proteomic[index_train,]
cv.splsicox_model <- cv.splsicox(X_train, Y_train, max.ncomp = 2, penalty.list = c(0.1),
n_run = 1, k_folds = 2, x.center = TRUE, x.scale = TRUE)

Description

Filters out variables from a dataset that exhibit a coefficient of variation below a specified threshold, ensuring the retention of variables with meaningful variability.

Usage

deleteNearZeroCoefficientOfVariation(X, LIMIT = 0.1)

Arguments

Details

The deleteNearZeroCoefficientOfVariation function is a pivotal tool in data preprocessing, especially when dealing with high-dimensional datasets. The coefficient of variation (CoV) is a normalized measure of data dispersion, calculated as the ratio of the standard deviation to the mean. In many scientific investigations, variables with a low CoV might be considered as offering limited discriminative information, potentially leading to noise in subsequent statistical analyses. By setting a threshold through the LIMIT parameter, this function provides a systematic approach to identify and exclude variables that do not meet the desired variability criteria. The underlying rationale is that variables with a CoV below the set threshold might not contribute significantly to the variability of the dataset and could be redundant or even detrimental for certain analyses. The function returns a modified dataset, a list of deleted variables, and the computed coefficients of variation for each variable. This comprehensive output ensures that researchers are well-informed about the preprocessing steps and can make subsequent analytical decisions with confidence.

Value

Return a list of two objects: X: The new data.frame X filtered. variablesDeleted: The variables that have been removed by the filter. coeff_variation: The coefficient variables per each variable tested.

Author(s)

Pedro Salguero Garcia. Maintainer: [email protected]

Examples

data("X_proteomic")
X <- X_proteomic
filter <- deleteNearZeroCoefficientOfVariation(X, LIMIT = 0.1)

Description

Filters out variables from a dataset that exhibit a coefficient of variation below a specified threshold, ensuring the retention of variables with meaningful variability.

Usage

deleteNearZeroCoefficientOfVariation.mb(X, LIMIT = 0.1)

Arguments

Details

The deleteNearZeroCoefficientOfVariation function is a pivotal tool in data preprocessing, especially when dealing with high-dimensional datasets. The coefficient of variation (CoV) is a normalized measure of data dispersion, calculated as the ratio of the standard deviation to the mean. In many scientific investigations, variables with a low CoV might be considered as offering limited discriminative information, potentially leading to noise in subsequent statistical analyses. By setting a threshold through the LIMIT parameter, this function provides a systematic approach to identify and exclude variables that do not meet the desired variability criteria. The underlying rationale is that variables with a CoV below the set threshold might not contribute significantly to the variability of the dataset and could be redundant or even detrimental for certain analyses. The function returns a modified dataset, a list of deleted variables, and the computed coefficients of variation for each variable. This comprehensive output ensures that researchers are well-informed about the preprocessing steps and can make subsequent analytical decisions with confidence.

Value

A list of three objects. X: A list with as many blocks as X input, but with the variables filtered. variablesDeleted: A list with as many blocks as X input, with the name of the variables that have been removed. coeff_variation: A list with as many blocks as X input, with the coefficient of variation per variable.

Author(s)

Pedro Salguero Garcia. Maintainer: [email protected]

Examples

data("X_multiomic")
X <- X_multiomic
filter <- deleteNearZeroCoefficientOfVariation.mb(X, LIMIT = 0.1)

Description

Provides a robust mechanism to filter out variables from a dataset that exhibit zero or near-zero variance, thereby enhancing the quality and interpretability of subsequent statistical analyses.

Usage

deleteZeroOrNearZeroVariance(
  X,
  remove_near_zero_variance = FALSE,
  remove_zero_variance = TRUE,
  toKeep.zv = NULL,
  freqCut = 95/5
)

Arguments

Details

The deleteZeroOrNearZeroVariance function is an indispensable tool in the preprocessing phase of statistical modeling. In many datasets, especially high-dimensional ones, certain variables might exhibit zero or near-zero variance. Such variables can be problematic as they offer limited information variance and can potentially distort the results of statistical models, leading to issues like overfitting. By leveraging the caret::nearZeroVar() function, this tool offers a rigorous method to identify and exclude these variables. Users are afforded flexibility in their choices, with options to remove only zero variance variables, near-zero variance variables, or both. The function also provides the capability to set a frequency cutoff, freqCut, which determines the threshold for near-zero variance based on the ratio of the most frequent value to the second most frequent value. For scenarios where certain variables are deemed essential and should not be removed regardless of their variance, the toKeep.zv parameter allows users to specify a list of such variables.

Value

Return a list of two objects: X: The new data.frame X filtered. variablesDeleted: The variables that have been removed by the filter.

Author(s)

Pedro Salguero Garcia. Maintainer: [email protected]