# Introduction

oem is a package for the estimation of various penalized regression models using the oem algorithm of (Xiong et al. 2016). The focus of oem is to provide high performance computation for big tall data. Many applications not only have a large number of variables, but a vast number of observations; oem is designed to perform well in these settings.

• Fast computation for big tall data
• Efficient computation for computation for multiple penalties simultaneously
• Efficient cross-validation

# Installation

The simplest way to install oem is via the CRAN repositories as the following:

To install the development version, first install the devtools package

and then installl oem via the install_github function

# Quick Start

Simulate data

Fit a penalized regression model using the oem function

fit1 <- oem(x = x, y = y, penalty = "lasso")

Plot the solution path

# Key Features

## Available functions

Function Name Functionality
oem() Main fitting function
oem.xtx() Fitting function for precomputed $$X'X,X'y$$
big.oem() Fitting function for big.matrix() objects
summary.oemfit() Summary for oem objects
predict.oemfit() Prediction for oem objects
plot.oemfit() Plotting for oem objects
logLik.oemfit() log Likelihood for oem objects
cv.oem() Cross-validation function
xval.oem() Fast cross-validation for linear models
summary.cv.oem() Summary for cv.oem objects
predict.cv.oem() Prediction for cv.oem objects
plot.cv.oem() Plotting for cv.oem objects
logLik.cv.oem() log Likelihood for cv.oem objects

## Available Penalties

Penalty Option Name Penalty Form
Lasso lasso $$\lambda \sum_{j = 1}^pd_j|\beta_j|$$
Elastic Net elastic.net $$\lambda \sum_{j = 1}^p\alpha d_j|\beta_j| + \frac{1}{2}(1 - \alpha)\lambda \sum_{j = 1}^pd_j\beta_j^2$$
MCP mcp $$\lambda \sum_{j = 1}^pd_j \int_0^{\beta_j}(1 - x/(\gamma\lambda d_j))_+\mathrm{d}x$$
SCAD scad $$\sum_{j = 1}^p p^{SCAD}_{\lambda d_j,\gamma}(\beta_j)$$
Group Lasso grp.lasso $$\lambda \sum_{k = 1}^Gd_k\sqrt{\sum_{j \in g_k}\beta_j^2}$$
Group MCP grp.mcp $$\lambda \sum_{k = 1}^Gp^{MCP}_{\lambda d_k,\gamma}(||\boldsymbol\beta_{g_k}||_2)$$
Group SCAD grp.scad $$\lambda \sum_{k = 1}^Gp^{SCAD}_{\lambda d_k,\gamma}(||\boldsymbol\beta_{g_k}||_2)$$
Sparse Group Lasso sparse.grp.lasso $$\lambda \alpha\sum_{j = 1}^pd_j|\beta_j| + \lambda (1-\alpha)\sum_{k = 1}^Gd_k\sqrt{\sum_{j \in g_k}\beta_j^2}$$

where $$||\boldsymbol\beta_{g_k}||_2 = \sqrt{\sum_{j \in g_k}\beta_j^2}$$, $p_{\lambda, \gamma}^{SCAD}(\beta) = \left\{ \begin{array}{ll} \lambda|\beta| & |\beta| \leq \lambda ; \\ -\frac{|\beta|^2 - 2\gamma\lambda|\beta| + \lambda^2}{2(\gamma - 1)} & \lambda < |\beta| \leq \gamma\lambda ; \\ \frac{(\gamma + 1)\lambda^2}{2} & |\beta| > \gamma\lambda, \\ \end{array} \right.$

and

$p_{\lambda, \gamma}^{MCP}(\beta) = \lambda \int_0^{\beta}(1 - x/(\gamma\lambda ))_+\mathrm{d}x = \\ \left\{ \begin{array}{ll} -\lambda (|\beta| - \frac{\beta^2} {2 \lambda\gamma}) & |\beta| \leq \gamma\lambda ; \\ \frac{ \lambda^2\gamma}{2} & |\beta| > \gamma\lambda. \\ \end{array} \right.$

Any penalty with .net at the end of its name has a ridge term of $$\frac{1}{2}(1 - \alpha)\lambda \sum_{j = 1}^pd_j\beta_j^2$$ added to it and the original penalty multiplied by $$\alpha$$. For example, grp.mcp.net is the penalty

$\lambda \sum_{k = 1}^G\alpha p^{MCP}_{\lambda d_k,\gamma}(||\boldsymbol\beta_{g_k}||_2) + \frac{1}{2}(1 - \alpha)\lambda \sum_{j = 1}^pd_j\beta_j^2.$

## Available Model Families

The following models are available currently.

Model Option Name Loss Form
Linear Regression gaussian $$\frac{1}{2n}\sum_{i=1}^n(y_i - x_i^T\beta) ^ 2$$
Logistic Regression binomial $$-\frac{1}{n}\sum_{i=1}^n\left[y_i x_i^T\beta - \log (1 + \exp\{ x_i^T\beta \} ) \right]$$

There are plans to include support for multiple responses, binomial models (not just logistic regression), Cox’s proportional hazards model, and more if requested.

# Fitting multiple penalties at once

The oem algorithm is well-suited to quickly estimate a solution path for multiple penalties simultaneously if the number of variables is not too large. The oem algorithm is only efficient for multiple penalties for linear models.

For the group lasso penalty, the groups argument must be used. groups should be a vector which indicates the group number for each variable.

fit2 <- oem(x = x, y = y, penalty = c("lasso", "mcp", "grp.lasso", "grp.mcp"),
groups = rep(1:20, each = 5))

Plot the solution paths for all models

## Timing Comparison

The following is a demonstration of oem’s efficiency for computing solutions for tuning parameter paths for multiple penalties at once.

### Linear Regression

The efficiency oem for fitting multiple penalties at once only applies to linear models. However, for linear models it is quite efficient, even for a high number of tuning parameters for many different penalties.

##    user  system elapsed
##    0.28    0.01    0.44
##    user  system elapsed
##    0.37    0.02    0.53
##    user  system elapsed
##    0.45    0.03    0.52

### Logistic Regression

It is still more efficient to fit multiple penalties at once instead of individually for logistic regression, but the benefit is not as dramatic as for linear models.

##    user  system elapsed
##    2.60    0.05    3.36
system.time(fit2b <- oem(x = x2, y = y2, penalty = c("grp.lasso", "lasso", "mcp", "scad", "elastic.net"),
family = "binomial",
groups = rep(1:20, each = 5), nlambda = 100L))
##    user  system elapsed
##   12.36    0.08   13.33

# Cross Validation

Here we use the nfolds argument to specify the number of folds for $$k$$-fold cross validation

##    user  system elapsed
##    1.71    0.11    1.98

Plot the cross validation mean squared error results for each model

## Extremely Fast Cross Validation for Linear Models

The function xval.oem offers accelerated cross validation for penalized linear models. In many cases is is orders of magnitude faster than cv.oem. It is only recommended for scenarios where the number of observations is larger than the number of variables. In addition to the computational gains in single-core usage, it also benefits from parallelizaton using OpenMP (instead of using foreach, as used by cv.oem). For large enough problems, it has on a similar order of computation time as just fitting one OEM model.

##    user  system elapsed
##    6.72    0.92    7.76
##    user  system elapsed
##    1.01    0.05    1.09
##    user  system elapsed
##    1.37    0.06    0.96
##    user  system elapsed
##    0.25    0.00    0.25

## Evaluation Metrics

A variety of evaluation metrics can be used for cross validation. The available metrics can be found in the table below

Model Metric type.measure=
Linear Regression Mean squared error mse or deviance
Mean absolute error mae
——————— ———————————- ————————
Logistic Regression Deviance deviance
Area under the ROC curve auc
Misclassification Rate class
Mean squared error of fitted mean mse
Mean absolute error of fitted mean mae

Consider a binary outcome setting with logistic regression.

### Misclassification Rate

In this case, misclassification rate is not the best indicator of performance. The classes here are imbalanced:

## [1] 0.062

### Area Under the ROC Curve

Area under the ROC curve is an alternative classification metric to misclassification rate. It is available by setting type.measure = "auc".

# Methods for Very Large Scale Problems

## OEM with Precomputed $$X^TX$$, $$X^TY$$ for Linear Models

With a very large dataset and computing cluster, the total size of a dataset may be very large, but if the number of variables is only moderately large (on the order of a few thousands) $$X^TX$$ and $$X^TY$$ may not be large and may already be available from other computations or can be computed trivially in parallel. The function oem.xtx computes penalized linear regression models using the OEM algorithm only using $$X^TX$$ and $$X^TY$$. Standardization can be achieved by providing a vector of scaling factors (usually the standard deviations of the columns of x). The function is used like the following:

##    user  system elapsed
##    0.19    0.05    0.25
##    user  system elapsed
##       0       0       0
## [1] 1.59317e-14
## [1] 1.276756e-14

# Other Features

## Parallelization via OpenMP

Computational time can be reduced a little via OpenMP parallelization of the key computational steps of the OEM algorithm. Simply use the ncores argument to access parallelization. There is no need for the foreach package.

##    user  system elapsed
##    4.52    0.13    5.15
##    user  system elapsed
##    5.94    0.11    5.10