The hardware and bandwidth for this mirror is donated by METANET, the Webhosting and Full Service-Cloud Provider.
If you wish to report a bug, or if you are interested in having us mirror your free-software or open-source project, please feel free to contact us at mirror[@]metanet.ch.

An introduction to PCLassoReg

1 Introduction

PCLassoReg is a package that implements protein complex-based group regression models (PCLasso and PCLasso2) for risk protein complex identification.

1.1 PCLasso

PCLasso is a prognostic model that identifies risk protein complexes associated with survival. It has three inputs: a gene/protein expression matrix, survival data, and protein complexes. PCLasso is based on the Cox PH model and estimates the Cox regression coefficients by maximizing partial likelihood with regularization penalty. Considering that genes usually function by forming protein complexes, PCLasso regards genes belonging to the same protein complex as a group, and constructs a l1/l2 penalty based on the sum (i.e., l1 norm) of the l2 norms of the regression coefficients of the group members to perform the selection of features at the group level. It deals with the overlapping problem of protein complexes by constructing a latent group Lasso-Cox model. Through the final sparse solution, we can predict the patient’s risk score based on a small set of protein complexes and identify risk protein complexes that are frequently selected to construct prognostic models. The penalty parameters “grSCAD” and “grMCP” can also be used to identify survival-associated risk protein complexes. Their penalty for large coefficients is smaller than “grLasso”, so they tend to choose less risk protein complexes.

PCLasso solves the following problem: \[\begin{equation} \begin{aligned} & \hat\beta = \mathop{\arg\min}_{\beta\in{R}^p}\left[-\frac{2}{n}\sum_{r=1}^{m}\left(x_{j(r)}^ {T}\mathbf{\beta}-\log\bigg(\sum_{j\in{R}_r}e^{x_{i}^{T}\beta}\bigg)\right)+ \lambda\sum_{k=1}^{K}\sqrt{|G_k|}\left\|\gamma_k\right\|\right]\\ & \mathrm{s.t.}\ \ \beta=\sum_{k=1}^{K}\gamma_k \end{aligned} \end{equation} \] where the first term represents the log partial likelihood function, and the second term is a group Lasso (“grLasso”) penalty.

1.2 PCLasso2

PCLasso2 is a classification model that identifies risk protein complexes associated with classes. It has three inputs: a gene/protein expression matrix, a vector of binary response variables, and a number of known protein complexes. PCLasso2 is based on the logistic regression model and estimates the logistic regression coefficients by maximizing likelihood function with regularization penalty. PCLasso2 regards proteins belonging to the same protein complex as a group and constructs a group Lasso penalty (l1/l2 penalty) based on the sum (i.e. l1 norm) of the l2 norms of the regression coefficients of the group members to perform the selection of features at the group level. With the group Lasso penalty, PCLasso2 trains the logistic regression model and obtains a sparse solution at the protein complex level, that is, the proteins belonging to a protein complex are either wholly included or wholly excluded from the model. PCLasso2 outputs a prediction model and a small set of protein complexes included in the model, which are referred to as risk protein complexes. The PCSCAD and PCMCP are performed by setting the penalty parameter as “grSCAD” and “grMCP”, respectively.

PCLasso2 solves the following problem: \[\begin{equation} \begin{aligned} & \mathop{\arg\min}_{\beta_0,\beta}\left\{-\frac{1}{n}\sum_{i=1}^{n} \left[y_i\left(\beta_0+x_i^{T}\beta\right)-\log\bigg(1+e^{\beta_0+ x_{i}^{T}\beta}\bigg)\right]+ \lambda\sum_{k=1}^{K}\sqrt{|G_k|}\left\|\gamma_k\right\|\right\}\\ & \mathrm{s.t.}\ \ \beta=\sum_{k=1}^{K}\gamma_k \end{aligned} \end{equation} \] where the first term represents the log-likelihood function, and the second term is a group Lasso (“grLasso”) penalty.

2 Installation

Like many other R packages, the simplest way to obtain RLassoCox is to install it directly from CRAN. Type the following command in R console:

install.packages("PCLassoReg")

To install the latest development version from GitHub:

devtools::install_github("weiliu123/PCLassoReg")

3 PCLassoReg

In this section, we will go over the main functions, see the basic operations and have a look at the outputs. Users may have a better idea after this section what functions are available, which one to choose, or at least where to seek help.

First, we load the PCLassoReg package:

library("PCLassoReg")

3.1 PCLasso

The PCLasso model accepts a gene/protein expression matrix, survival data, and protein complexes for training the prognostic model. We load a set of data created beforehand for illustration. Users can either load their own data or use those saved in the workspace.

# load data
data(survivalData)
data(PCGroups)

x <- survivalData$Exp
y <- survivalData$survData

The commands load a list survivalData that contains a gene expression matrix Exp and survival information survData of patients in Exp, and a data frame PCGroups containing the protein complexes downloaded from [CORUM] (https://mips.helmholtz-muenchen.de/corum/).

survData is an n x 2 matrix, with a column “time” of failure/censoring times, and “status” a 0/1 indicator, with 1 meaning the time is a failure time, and zero a censoring time.

head(survivalData$survData)
#>        time status
#> S1 22.92000      1
#> S2 99.12000      0
#> S3 64.90000      0
#> S4 68.88000      1
#> S5 23.40000      1
#> S6 57.13333      0

Use getPCGroups function to get human protein complexes from PCGroups. Note that the parameter Type should be consistent the gene names in Exp.

# get human protein complexes
PC.Human <- getPCGroups(Groups = PCGroups, Organism = "Human",
                        Type = "EntrezID")

In order to train and test the predictive performance of the PCLasso model, we divide the data set into a training set and a test set.

set.seed(20150122)
idx.train <- sample(nrow(x), round(nrow(x)*2/3))
x.train <- x[idx.train,]
y.train <- y[idx.train,]
x.test <- x[-idx.train,]
y.test <- y[-idx.train,]

We usually use cv.PCLasso instead of PCLasso to train the model, because cv.PCLasso helps us choose the best \(\lambda\) through k-fold cross validation.

Train the PCLasso model based on the training set data:

# fit cv.PCLasso model
cv.fit1 <- cv.PCLasso(x = x.train, y = y.train, group = PC.Human, nfolds = 5)

cv.fit1 contains a list object that includes a cv.grpsurv object cv.fit and a list of detected protein complexes complexes.dt. complexes.dt contains the proteins that exist in the expression matrix x.train and are used for model training.

We can visualize the norm of the protein complexes by executing the plot function:

# plot the norm of each group
plot(cv.fit1, norm = TRUE)

Each curve in the figure corresponds to a group (protein complex). It shows the path of the norm of each protein complex and \(L_1\)-norm when \(\lambda\) varies.

Visualize the coefficients:

# plot the individual coefficients
plot(cv.fit1, norm = FALSE)

Each curve in the figure corresponds to a variable (gene/protein). It shows the path of the coefficient of each gene/protein and \(L_1\)-norm when \(\lambda\) varies.

The optimal \(\lambda\) value and a cross validated error plot can be obtained to help evaluate our model.

# plot the cross-validation error (deviance)
plot(cv.fit1, type = "cve")

In this plot, the vertical line shows where the cross-validation error curve hits its minimum. The optimal \(\lambda\) can be obtained:

cv.fit1$cv.fit$lambda.min
#> [1] 0.06767398

We can check the selected protein complexes (risk protein complexes) in our model.

# Selected protein complexes at lambda.min
sel.groups <- predict(object = cv.fit1, type="groups",
                      lambda = cv.fit1$cv.fit$lambda.min)
# For values of lambda not in the sequence of fitted models, linear
# interpolation is used.
sel.groups <- predict(object = cv.fit1, type="groups",
                      lambda = c(0.1, 0.05))

Check the number of risk protein complexes:

# The number of risk protein complexes at lambda.min
sel.ngroups <- predict(object = cv.fit1, type="ngroups",
                       lambda = cv.fit1$cv.fit$lambda.min)
# For values of lambda not in the sequence of fitted models, linear
# interpolation is used.
sel.ngroups <- predict(object = cv.fit1, type="ngroups",
                      lambda = c(0.1, 0.05))

Check the norms of the protein complexes:

# The coefficients of protein complexes at lambda.min
groups.norm <- predict(object = cv.fit1, type="coefficients",
                       lambda = cv.fit1$cv.fit$lambda.min)
# For values of lambda not in the sequence of fitted models, linear
# interpolation is used.
groups.norm <- predict(object = cv.fit1, type="coefficients",
                       lambda = c(0.1, 0.05))

Check the selected covariates (risk individual genes/proteins) in our model:

# Selected genes/proteins at lambda.min
sel.vars <- predict(object = cv.fit1, type="vars",
                    lambda=cv.fit1$cv.fit$lambda.min)
# For values of lambda not in the sequence of fitted models, linear
# interpolation is used.
sel.vars <- predict(object = cv.fit1, type="vars",
                    lambda=c(0.1, 0.05))

Check the number of risk individual genes/proteins:

# The number of risk genes/proteins at lambda.min
sel.nvars <- predict(object = cv.fit1, type="nvars",
                     lambda=cv.fit1$cv.fit$lambda.min)
# For values of lambda not in the sequence of fitted models, linear
# interpolation is used.
sel.vars <- predict(object = cv.fit1, type="nvars",
                    lambda=c(0.1, 0.05))

Due to the overlap of protein complexes, there may be duplicates in the above risk genes/proteins. Use the following command to remove duplication:

# Selected genes/proteins at lambda.min
sel.vars <- predict(object = cv.fit1, type="vars.unique",
                    lambda=cv.fit1$cv.fit$lambda.min)
# For values of lambda not in the sequence of fitted models, linear
# interpolation is used.
sel.vars <- predict(object = cv.fit1, type="vars.unique",
                    lambda=c(0.1, 0.05))
# The number of risk genes/proteins at lambda.min
sel.nvars <- predict(object = cv.fit1, type="nvars.unique",
                     lambda=cv.fit1$cv.fit$lambda.min)
# For values of lambda not in the sequence of fitted models, linear
# interpolation is used.
sel.vars <- predict(object = cv.fit1, type="nvars.unique",
                    lambda=c(0.1, 0.05))

The fitted PCLasso model can by used to predict survival risk of new patients:

# predict risk scores of samples in x.test
s <- predict(object = cv.fit1, x = x.test, type="link",
             lambda=cv.fit1$cv.fit$lambda.min)
# For values of lambda not in the sequence of fitted models, linear
# interpolation is used.
s <- predict(object = cv.fit1, x = x.test, type="link",
             lambda=c(0.1, 0.05))

3.2 PCLasso2

The PCLasso2 model accepts a gene/protein expression matrix, a response vector, and protein complexes for training the classification model. We load a set of data created beforehand for illustration. Users can either load their own data or use those saved in the workspace.

# load data
data(classData)
data(PCGroups)

x <- classData$Exp
y <- classData$Label

The commands load a list classData that contains a protein expression matrix Exp and class labels Label of patients in Exp, and a data frame PCGroups containing the protein complexes downloaded from [CORUM] (https://mips.helmholtz-muenchen.de/corum/).

Use getPCGroups function to get human protein complexes from PCGroups. Note that the parameter Type should be consistent the gene names in Exp.

# get human protein complexes
PC.Human <- getPCGroups(Groups = PCGroups, Organism = "Human",
                        Type = "GeneSymbol")

In order to train and test the predictive performance of the PCLasso2 model, we divide the data set into a training set and a test set.

set.seed(20150122)
idx.train <- sample(nrow(x), round(nrow(x)*2/3))
x.train <- x[idx.train,]
y.train <- y[idx.train]
x.test <- x[-idx.train,]
y.test <- y[-idx.train]

We usually use cv.PCLasso2 instead of PCLasso2 to train the model, because cv.PCLasso2 helps us choose the best \(\lambda\) through k-fold cross validation.

Train the PCLasso2 model based on the training set data:

cv.fit2 <- cv.PCLasso2(x = x.train, y = y.train, group = PC.Human,
                       penalty = "grLasso", family = "binomial", nfolds = 10)

cv.fit2 contains a list object that includes a cv.grpreg object cv.fit and a list of detected protein complexes complexes.dt. complexes.dt contains the proteins that exist in the expression matrix x.train and are used for model training.

We can visualize the norm of the protein complexes by executing the plot function:

# plot the norm of each group
plot(cv.fit2, norm = TRUE)

Each curve in the figure corresponds to a group (protein complex). It shows the path of the norm of each protein complex and \(L_1\)-norm when \(\lambda\) varies.

Visualize the coefficients:

# plot the individual coefficients
plot(cv.fit2, norm = FALSE)

Each curve in the figure corresponds to a variable (gene/protein). It shows the path of the coefficient of each gene/protein and \(L_1\)-norm when \(\lambda\) varies.

The optimal \(\lambda\) value and a cross validated error plot can be obtained to help evaluate our model.

# plot the cross-validation error (deviance)
plot(cv.fit2, type = "cve")

In this plot, the vertical line shows where the cross-validation error curve hits its minimum. The optimal \(\lambda\) can be obtained:

cv.fit2$cv.fit$lambda.min
#> [1] 0.01601148

We can check the selected protein complexes (risk protein complexes) in our model.

# Selected protein complexes at lambda.min
sel.groups <- predict(object = cv.fit2, type="groups",
                      lambda = cv.fit2$cv.fit$lambda.min)
# For values of lambda not in the sequence of fitted models, linear
# interpolation is used.
sel.groups <- predict(object = cv.fit2, type="groups",
                      lambda = c(0.1, 0.05))

Check the number of risk protein complexes:

# The number of risk protein complexes at lambda.min
sel.ngroups <- predict(object = cv.fit2, type="ngroups",
                       lambda = cv.fit2$cv.fit$lambda.min)
# For values of lambda not in the sequence of fitted models, linear
# interpolation is used.
sel.ngroups <- predict(object = cv.fit2, type="ngroups",
                      lambda = c(0.1, 0.05))

Check the norms of the protein complexes:

# The coefficients of protein complexes at lambda.min
groups.norm <- predict(object = cv.fit2, type="coefficients",
                       lambda = cv.fit2$cv.fit$lambda.min)
# For values of lambda not in the sequence of fitted models, linear
# interpolation is used.
groups.norm <- predict(object = cv.fit2, type="coefficients",
                       lambda = c(0.1, 0.05))

Check the selected covariates (risk individual genes/proteins) in our model:

# Selected genes/proteins at lambda.min
sel.vars <- predict(object = cv.fit2, type="vars",
                    lambda=cv.fit2$cv.fit$lambda.min)
# For values of lambda not in the sequence of fitted models, linear
# interpolation is used.
sel.vars <- predict(object = cv.fit2, type="vars",
                    lambda=c(0.1, 0.05))

Check the number of risk individual genes/proteins:

# The number of risk genes/proteins at lambda.min
sel.nvars <- predict(object = cv.fit2, type="nvars",
                     lambda=cv.fit2$cv.fit$lambda.min)
# For values of lambda not in the sequence of fitted models, linear
# interpolation is used.
sel.vars <- predict(object = cv.fit2, type="nvars",
                    lambda=c(0.1, 0.05))

Due to the overlap of protein complexes, there may be duplicates in the above risk genes/proteins. Use the following command to remove duplication:

# Selected genes/proteins at lambda.min
sel.vars <- predict(object = cv.fit2, type="vars.unique",
                    lambda=cv.fit2$cv.fit$lambda.min)
# For values of lambda not in the sequence of fitted models, linear
# interpolation is used.
sel.vars <- predict(object = cv.fit2, type="vars.unique",
                    lambda=c(0.1, 0.05))
# The number of risk genes/proteins at lambda.min
sel.nvars <- predict(object = cv.fit2, type="nvars.unique",
                     lambda=cv.fit2$cv.fit$lambda.min)
# For values of lambda not in the sequence of fitted models, linear
# interpolation is used.
sel.vars <- predict(object = cv.fit2, type="nvars.unique",
                    lambda=c(0.1, 0.05))

The fitted PCLasso2 model can by used to predict the probability that the sample is a tumor sample:

# predict probabilities of samples in x.test
s <- predict(object = cv.fit2, x = x.test, type="response",
             lambda=cv.fit2$cv.fit$lambda.min)
# For values of lambda not in the sequence of fitted models, linear
# interpolation is used.
s <- predict(object = cv.fit2, x = x.test, type="response",
             lambda=c(0.1, 0.05))

Predict the class labels of new samples:

# predict class labels of samples in x.test
s <- predict(object = cv.fit2, x = x.test, type="class",
             lambda=cv.fit2$cv.fit$lambda.min)
# For values of lambda not in the sequence of fitted models, linear
# interpolation is used.
s <- predict(object = cv.fit2, x = x.test, type="class",
             lambda=c(0.1, 0.05))

3.3 Other penalties

In addition to “grLasso”, two other penalty functions “grSCAD” and “grMCP” can be used to train PCLasso and PCLasso2 models. Their penalty for large coefficients is smaller than “grLasso”, so they tend to choose less risk protein complexes. Note that the two penalty functions have a new parameter gamma.

Train the PCLasso model:

# load data
data(survivalData)
data(PCGroups)

x = survivalData$Exp
y = survivalData$survData

PC.Human <- getPCGroups(Groups = PCGroups, Organism = "Human",
                        Type = "EntrezID")

# fit PCSCAD model
fit.PCSCAD <- PCLasso(x, y, group = PC.Human, penalty = "grSCAD", gamma = 6)

# fit PCMCP model
fit.PCMCP <- PCLasso(x, y, group = PC.Human, penalty = "grMCP", gamma = 5)

Train the PCLasso2 model:

# load data
data(classData)
data(PCGroups)

x = classData$Exp
y = classData$Label

PC.Human <- getPCGroups(Groups = PCGroups, Organism = "Human",
                        Type = "GeneSymbol")

# fit PCSCAD model
fit.PCSCAD2 <- PCLasso2(x, y, group = PC.Human, penalty = "grSCAD",
                       family = "binomial", gamma = 10)

# fit PCMCP model
fit.PCMCP2 <- PCLasso2(x, y, group = PC.Human, penalty = "grMCP",
                      family = "binomial", gamma = 9)

Other functions are similar to PCLasso and PCLasso2 models.

4 Reference

PCLasso2: a protein complex-based, group Lasso-logistic model for risk protein complex discovery. To be published.
PCLasso: a protein complex-based, group lasso-Cox model for accurate prognosis and risk protein complex discovery. Brief Bioinform, 2021.
Park, H., Niida, A., Miyano, S. and Imoto, S. (2015) Sparse overlapping group lasso for integrative multi-omics analysis. Journal of computational biology: a journal of computational molecular cell biology, 22, 73-84.

These binaries (installable software) and packages are in development.
They may not be fully stable and should be used with caution. We make no claims about them.