Package {spareg}

Type:	Package
Title:	Sparse Projected Averaged Regression
Version:	1.2.0
Description:	A flexible framework combining variable screening and random projection techniques for fitting ensembles of predictive generalized linear models to high-dimensional data. Designed for extensibility, the package implements key techniques as S3 classes with user-friendly constructors, enabling easy integration and development of new procedures for high-dimensional applications.
License:	GPL-3
Imports:	Matrix, ROCR, Rdpack, ggplot2, rlang, glmnet, methods
RdMacros:	Rdpack
Encoding:	UTF-8
URL:	https://github.com/lauravana/spareg
BugReports:	https://github.com/lauravana/spareg/issues
Suggests:	testthat (≥ 3.0.0), foreach, doParallel, doRNG, robustbase, cellWise, VariableScreening, ggpubr, R.matlab
Config/testthat/edition:	3
Depends:	R (≥ 4.0.0)
Config/roxygen2/version:	8.1.0
NeedsCompilation:	no
Packaged:	2026-09-25 15:22:35 UTC; lauravanagur
Author:	Laura Vana-Gür [aut, cre], Roman Parzer [aut], Peter Filzmoser [aut]
Maintainer:	Laura Vana-Gür <laura.vana.guer@tuwien.ac.at>
Repository:	CRAN
Date/Publication:	2026-09-25 16:50:02 UTC

Coef Method for 'spar' Object

Description

Extracts coefficients from 'spar' object

Usage

## S3 method for class 'spar'
coef(
  object,
  nummod = NULL,
  nu = NULL,
  aggregate = c("mean", "median", "none"),
  ...
)

Arguments

Value

Returns an object of class 'coefspar', which is a list with elements

• intercept: The average intercept value or vector intercepts (one for each marginal model) if aggregate = "none".

• beta: Vector of length p of averaged coefficients or a p x max(nummods) matrix of coefficients if agregate = "none".

• nummod: Number of models based on which the coefficients are computed.

• nu: Threshold value based on which the coefficients are computed.

See Also

print.coefspar, summary.coefspar

Examples

example_data <- simulate_spareg_data(n = 100, p = 400, ntest = 100)
spar_res <- spar(example_data$x, example_data$y, xval = example_data$xtest,
  yval = example_data$ytest, nummods=c(5, 10))
coef(spar_res)
coef(spar_res, aggregate = "median")
coef(spar_res, aggregate = "none")
coef(spar_res, nummod = 5, nu = 0)

Coef Method for 'spar.cv' Object

Description

Extract coefficients from 'spar.cv' object. This function extracts coefficients only if precompute_mode = "precompute_all". In this case, coefficients are derived from the initial run on the full dataset using the optimal M and \nu combination identified via cross-validation (best or 1se rule). For other modes ("precompute_proj" or "full_cv"), coefficients cannot be directly extracted because screening or projections vary across folds. To obtain coefficients in these cases, refit the model on the full dataset using spar() with the selected M and \nu values.

Usage

## S3 method for class 'spar.cv'
coef(
  object,
  nummod = NULL,
  nu = NULL,
  opt_par = c("best", "1se"),
  aggregate = c("mean", "median", "none"),
  ...
)

Arguments

Value

List with elements

• intercept average intercept value or vector intercepts (one for each marginal model) if aggregate = "none".

• beta vector of length p of averaged coefficients or a p x max(nummods) matrix of coefficients if agregate = "none".

• nummod number of models based on which the coefficient is computed.

• nu threshold based on which the coefficients is computed.

See Also

predict.spar.cv, get_model.spar.cv

Examples

example_data <- simulate_spareg_data(n = 80, p = 200, ntest = 100)
spar_res <- spar.cv(example_data$x, example_data$y, nfolds = 3L,
  nummods = c(5, 10))
coef(spar_res)

Constructor Function for Building 'randomprojection' Object

Description

Creates an object class 'randomprojection' using arguments passed by user.

Usage

constructor_randomprojection(
  name = NULL,
  generate_fun,
  update_fun = update_rp_default,
  update_rpm_w_data = update_rpm_identity,
  control = list()
)

Arguments

Details

The update_rpm_w_data function is particularly relevant for cross-validation procedures where random projection matrices are precomputed (e.g., precompute_mode = "precompute_all" or precompute_mode = "precompute_rpm"). In such cases, the cross-validation procedure uses the precomputed matrices, but you may want to update data-dependent entries (e.g., diagonal elements) with the training data in each fold. For example, in rp_cw(data = TRUE), the diagonal elements of the projection matrices are updated to reflect screening coefficients computed on the training data for each fold, while the random elements remain unchanged.

Value

Returns a function that, when called, creates and returns an object of class randomprojection.

Examples

generate_cauchy <- function(object, x, y, m, included_vector, ...) {
  p <- length(included_vector)
  control_rcauchy <- c(object$control[names(object$control) %in% names(formals(rcauchy))],
    attributes(object)[names(attributes(object)) %in% names(formals(rcauchy))])
  control_rcauchy <-  control_rcauchy[!duplicated(names(control_rcauchy))]
  vals <- do.call(function(...)
    rcauchy(m * p, ...), control_rcauchy)
  RM <- matrix(vals, nrow = m, ncol = p)
  return(RM)
}
rp_cauchy <- constructor_randomprojection(
  generate_fun = generate_cauchy, name = "rp_cauchy")
example_data <- simulate_spareg_data(n = 100, p = 400, ntest = 100)
spar_res <- spar(example_data$x, example_data$y, xval = example_data$xtest,
  yval = example_data$ytest, rp = rp_cauchy(scale = 1/400))
spar_res

Constructor Function for Building screencoef Objects

Description

The created function will return a object of class screencoef which constitutes of a list. The attributes of the generating object will include by default type, which can take one of two values "prob" (indicating probabilistic screening should be employed), "fixed" (indicating that the top nscreen variables should be employed).

Usage

constructor_screencoef(
  name = NULL,
  generate_fun,
  update_fun = update_screen_default
)

Arguments

Details

Creates an object class screencoef using arguments passed by user.

Value

Returns a function that, when called, creates and returns an object of class 'screencoef'.

Examples

generate_scr_sirs <- function(y, x, object, ...) {
  ctrl <- object$control[names(object$control) %in%
                          names(formals(VariableScreening::screenIID))]
 res_screen <- do.call(function(...)
   VariableScreening::screenIID(x, y, ...), ctrl)
 res_screen$measurement
}
screen_sirs <- constructor_screencoef("screen_sirs",
  generate_fun = generate_scr_sirs)
example_data <- simulate_spareg_data(n = 100, p = 400, ntest = 100)
spar_example <- spar(example_data$x, example_data$y,
  screencoef = screen_sirs(control = list(method = "SIRS")),
  rp = rp_sparse())
spar_example

Constructor Function for Building sparmodel Object

Description

The created function will return a object of class sparmodel which constitutes of a list.

Usage

constructor_sparmodel(
  name = NULL,
  generate_fun,
  update_fun = update_sparmodel_default
)

Arguments

Details

Creates an object of class sparmodel using arguments passed by user.

Value

Returns a function that, when called, creates and returns an object of class sparmodel.

Examples

model_glmrob <- function(object, x, y, z, ...) {
  requireNamespace("robustbase")
  glmrob_res <- do.call(function(...)
    robustbase::glmrob(y ~ as.matrix(z), ...),
    object$control)
  intercept <- coef(glmrob_res)[1]
  gammas <- coef(glmrob_res)[-1]
  list(gammas = gammas, intercept = intercept)
}
spar_glmrob <- constructor_sparmodel(
  generate_fun = model_glmrob,name = "glmrob")
example_data <- simulate_spareg_data(n = 100, p = 400, ntest = 100)
spar_res <- spar(example_data$x, example_data$y, xval = example_data$xtest,
  yval = example_data$ytest,
  model = spar_glmrob())
spar_res

Sparse Embedding Matrix

Description

Sparse Embedding Matrix

Usage

generate_cw(object, x, y, m, included_vector, ...)

Arguments

Value

(possibly sparse) matrix with m rows and length(included_vector) columns.

Gaussian Random Projection Matrix

Description

Gaussian Random Projection Matrix

Usage

generate_gaussian(object, x = NULL, y = NULL, m, included_vector, ...)

Arguments

Value

Returns a matrix with m rows and length(included_vector) columns sampled from the normal distribution.

Generate screening coefficient based on correlation

Description

Generate screening coefficient based on correlation

Usage

generate_scrcoef_cor(object, x, y, ...)

Arguments

Value

vector of screening coefficients of length p

Screening coefficient based on glmnet coefficients

Description

Screening coefficient based on glmnet coefficients

Usage

generate_scrcoef_glmnet(object, x, y, ...)

Arguments

Value

vector of screening coefficients of length p

Generate screening coefficient based on marginal likelihood in univariate GLMs

Description

Generate screening coefficient based on marginal likelihood in univariate GLMs

Usage

generate_scrcoef_marglik(object, x, y, ...)

Arguments

Value

vector of screening coefficients of length p

Sparse Random Projection Matrix

Description

Sparse Random Projection Matrix

Usage

generate_sparse(object, x = NULL, y = NULL, m, included_vector, ...)

Arguments

Value

Returns a (possibly sparse) matrix with m rows and length(included_vector) columns.

Extractor for Model Coefficients from 'coefspar' Object

Description

Extractor for Model Coefficients from 'coefspar' Object

Usage

get_coef(x)

Arguments

Value

A numeric vector or matrix of coefficients.

See Also

coef.spar, coef.spar.cv, print.coefspar, summary.coefspar

Examples

example_data <- simulate_spareg_data(n = 100, p = 400, ntest = 100)
spar_res <- spar(example_data$x, example_data$y, xval = example_data$xtest,
  yval = example_data$ytest, nummods=c(5, 10))
coefs <- coef(spar_res)
get_coef(coefs)

Extractor for Model Intercept from 'coefspar' Object

Description

Extractor for Model Intercept from 'coefspar' Object

Usage

get_intercept(x)

Arguments

Value

Intercept (numeric or vector).

Examples

example_data <- simulate_spareg_data(n = 100, p = 400, ntest = 100)
spar_res <- spar(example_data$x, example_data$y, xval = example_data$xtest,
  yval = example_data$ytest, nummods=c(5, 10))
coefs <- coef(spar_res)
get_coef(coefs)

Extractor for (Cross-)Validation Measure from 'spar' or 'spar.cv' Object

Description

Extractor for (Cross-)Validation Measure from 'spar' or 'spar.cv' Object

Usage

get_measure(object)

Arguments

Value

data.frame containing the (cross-)validation measure for the considered threshold and number of model combinations. For 'spar' objects it contains information about the measure calculated on the validation set (or on the training sample if xval and yval are missing) and the number of active variables. For 'spar.cv' objects it contains information on the average measure obtained across folds together with the standard deviation across the folds and the average number of active variables. the nfolds of the training set.

See Also

spar, spar.cv, get_model

Examples

example_data <- simulate_spareg_data(n = 100, p = 400, ntest = 100)
spar_res <- spar(example_data$x, example_data$y, xval = example_data$xtest,
  yval = example_data$ytest, nummods=c(5, 10))
get_measure(spar_res)

get_model

Description

Retrieve the Best Model from a Fitted Object

Usage

get_model(object, ...)

Arguments

Details

This generic function retrieves the best model from a fitted object of class spar or spar.cv. The method dispatched depends on the class of the input object.

Value

The modified object with the best model selected.

Examples

# Example usage with a fitted object

example_data <- simulate_spareg_data(n = 100, p = 400, ntest = 100)
fitted_obj <- spar(example_data$x, example_data$y, family = gaussian(), nfolds = 3L)
best_model <- get_model(fitted_obj)

Get Best Model for spar Objects

Description

Extracts the best model from a fitted spar object based on validation results. The best model is determined by the minimum validation measure.

Usage

## S3 method for class 'spar'
get_model(object, ...)

Arguments

Value

An updated spar object containing:

• betas: Coefficients of the best model, with values below nu set to 0.

• intercepts: Intercepts for the selected number of models (nummod).

• val_res: Validation results filtered for the best nummod and nu.

Examples

example_data <- simulate_spareg_data(n = 100, p = 400, ntest = 100)
fitted_spar <- spar(example_data$x, example_data$y, family = gaussian())
best_spar <- get_model(fitted_spar)

Get Best Model for spar.cv Objects

Description

Extracts the best or 1SE model from a fitted spar.cv object. The selection is based on cross-validation results, and the model can be re-estimated if required.

Usage

## S3 method for class 'spar.cv'
get_model(
  object,
  opt_par = c("best", "1se"),
  x = NULL,
  y = NULL,
  xval = NULL,
  yval = NULL,
  ...
)

Arguments

Value

An updated spar or spar.cv object containing:

• betas: Coefficients of the selected model.

• intercepts: Intercepts for the selected model.

• val_res: Validation results filtered for the selected nummod and nu.

• Additional fields like xscale, yscale, xcenter, and ycenter if precompute_mode == "precompute_all".

Examples

example_data <- simulate_spareg_data(n = 50, p = 200, ntest = 50)
fitted_spar_cv <- spar.cv(example_data$x, example_data$y, family = gaussian(), nfolds = 3L)
best_spar_cv <- get_model(fitted_spar_cv, opt_par = "best")

Plot Method for 'spar' Object

Description

Creates diagnostic plots for a 'spar'] object, including:

• Validation measure vs. nus or nummods.

• Number of active variables vs. nus or nummods.

• Residuals vs. fitted values.

• Coefficient heatmap.

Usage

## S3 method for class 'spar'
plot(
  x,
  plot_type = c("val_measure", "val_numactive", "res_vs_fitted", "coefs"),
  plot_along = c("nu", "nummod"),
  nummod = NULL,
  nu = NULL,
  xfit = NULL,
  yfit = NULL,
  prange = NULL,
  coef_order = NULL,
  digits = 2L,
  ...
)

Arguments

Value

Returns a 'ggplot2::ggplot' object.

Examples

example_data <- simulate_spareg_data(n = 100, p = 400, ntest = 100)
spar_res <- spar(example_data$x, example_data$y, xval = example_data$xtest,
  yval = example_data$ytest, nummods=c(5, 10))
plot(spar_res)
plot(spar_res, plot_type = "val_measure", plot_along = "nummod", nu = 0)
plot(spar_res, plot_type = "val_measure", plot_along = "nu", nummod = 10)
plot(spar_res, plot_type = "val_numactive",  plot_along = "nummod", nu = 0)
plot(spar_res, plot_type = "val_numactive",  plot_along = "nu", nummod = 10)
plot(spar_res, plot_type = "res_vs_fitted",  xfit = example_data$xtest,
  yfit = example_data$ytest)
plot(spar_res, plot_type = "coefs", prange = c(1,400))

Plot Method for 'spar.cv' Object

Description

Plot cross-validation measure or number of active variables over different thresholds or number of models of 'spar.cv' object, produce a residuals vs fitted plot, or a plot of the estimated coefficients in each marginal model, sorted by their absolute value.

Usage

## S3 method for class 'spar.cv'
plot(
  x,
  plot_type = c("val_measure", "val_numactive", "res_vs_fitted", "coefs"),
  plot_along = c("nu", "nummod"),
  nummod = NULL,
  nu = NULL,
  xfit = NULL,
  yfit = NULL,
  opt_par = c("best", "1se"),
  prange = NULL,
  coef_order = NULL,
  digits = 2L,
  ...
)

Arguments

Value

'ggplot2::ggplot' object

Examples

example_data <- simulate_spareg_data(n = 80, p = 200, ntest = 100)
spar_res <- spar.cv(example_data$x, example_data$y, nfolds = 3L,
  screencoef = screen_cor(), rp = rp_gaussian(), nummods = c(5, 10))
plot(spar_res)
plot(spar_res, plot_type = "val_measure", plot_along = "nummod", nu = 0)
plot(spar_res, plot_type = "val_measure", plot_along = "nu", nummod = 10)
plot(spar_res, plot_type = "val_numactive",  plot_along = "nummod", nu = 0)
plot(spar_res, plot_type = "val_numactive",  plot_along = "nu", nummod = 10)

Predict Method for 'spar.cv' Object

Description

Predict responses for new predictors from 'spar' object

Usage

## S3 method for class 'spar'
predict(
  object,
  xnew = NULL,
  type = c("response", "link"),
  avg_type = c("link", "response"),
  nummod = NULL,
  nu = NULL,
  aggregate = c("mean", "median"),
  ...
)

Arguments

Value

Returns a vector of predictions.

Examples

example_data <- simulate_spareg_data(n = 100, p = 400, ntest = 100)
spar_res <- spar(example_data$x, example_data$y, xval = example_data$xtest,
  yval = example_data$ytest, nummods=c(5, 10))
pred <- predict(spar_res, xnew = example_data$xtest)

Predict Method for 'spar.cv' Object

Description

Predict responses for new predictors from 'spar.cv' object. Only allowed if precompute_mode = "precompute_all" is used when calling spar.cv. In this case the ensemble obtained on the whole data is used for the combination of threshold and number of models using the best or the 1se identified through cross-validation. Otherwise predictions cannot be generated without refitting on whole data with best or 1se parameters. To be able to generate predictions in case precompute_mode = "precompute_rpm" or precompute_mode = "full_cv", use spar() to refit with the desired (nu, M) combination.

Usage

## S3 method for class 'spar.cv'
predict(
  object,
  xnew = NULL,
  type = c("response", "link"),
  avg_type = c("link", "response"),
  opt_par = c("best", "1se"),
  nummod = NULL,
  nu = NULL,
  aggregate = c("mean", "median"),
  ...
)

Arguments

Value

Vector of predictions

See Also

coef.spar.cv, get_model.spar.cv

Examples

example_data <- simulate_spareg_data(n = 80, p = 200, ntest = 100)
spar_res <- spar.cv(example_data$x, example_data$y, nfolds = 3L,
  rp = rp_gaussian(), nummods = c(5, 10))
pred <- predict(spar_res, example_data$x)

Print Method for 'coefspar' Object

Description

Prints a summary of coefficients from a 'coefspar' object, including the selected M and \nu, and the number of active variables.

Usage

## S3 method for class 'coefspar'
print(x, digits = 4L, show = 6L, ...)

Arguments

Value

Invisibly returns the input object x.

Examples

example_data <- simulate_spareg_data(n = 100, p = 2000, ntest = 100)
spar_res <- spareg(example_data$x, example_data$y, xval = example_data$xtest,
  yval = example_data$ytest, nummods=c(5, 10))
coef(spar_res)
coef(spar_res, aggregate = "median")
coef(spar_res, aggregate = "none")
print(coef(spar_res), show = 10L, digits = 6L)

Print Method for a 'randomprojection' Object

Description

Prints a summary of a randomprojection object, including its name, and key attributes such as mslow and msup.

Usage

## S3 method for class 'randomprojection'
print(x, ...)

Arguments

Value

Invisibly returns the input object x.

Examples

rp <- rp_gaussian(mslow = 5, msup = 10)
print(rp)

Print Method for 'screencoef' Object

Description

Print method for a 'screencoef' object

Usage

## S3 method for class 'screencoef'
print(x, ...)

Arguments

Value

text summary

Print summary of 'spar' Object

Description

Prints a summary of a spar object, including the validation measure, optimal M and \nu, and the number of active predictors.

Usage

## S3 method for class 'spar'
print(x, digits = 4L, ...)

Arguments

Value

Invisibly returns the input object x.

Examples

example_data <- simulate_spareg_data(n = 100, p = 400, ntest = 100)
spar_res <- spar(example_data$x, example_data$y, xval = example_data$xtest,
  yval = example_data$ytest, nummods=c(5, 10))
print(spar_res)

Print Method for 'spar.cv' Object

Description

Print summary of 'spar.cv' object

Usage

## S3 method for class 'spar.cv'
print(x, digits = 4L, ...)

Arguments

Value

text summary

Examples

example_data <- simulate_spareg_data(n = 80, p = 200, ntest = 100)
spar_res <- spareg.cv(example_data$x, example_data$y, nfolds = 3L,
  screencoef = screen_cor(), rp = rp_gaussian(), nummods = c(5, 10))
print(spar_res)

Random Projection Object Class

Description

The 'randomprojection' class' represents a configuration for generating and managing random projection matrices in the SPAR (Sparse Projected Averaged Regression) framework. Objects of this class encapsulate:

• Functions for generating, updating, and modifying random projection matrices.

• Control parameters for the random projection process.

• Metadata (e.g., name, attributes) for customization.

Details

Objects of class 'randomprojection' are created using the constructor_randomprojection function. They are used in the spar and spar.cv functions to define how predictors are projected into a lower-dimensional space.

The class includes the following components:

• name: A character string describing the random projection method (e.g., "rp_gaussian", "rp_sparse").

• generate_fun: A function to generate the random projection matrix. This function must accept arguments like object, x, y, m, included_vector, and ....

• update_fun: A function to update the randomprojection object with data-specific information. This function must accept arguments like object, x, y, family, and ....

• update_rpm_w_data: A function to update an already-generated random projection matrix with data-dependent information. This function must accept arguments like rpm, object, included_vector, x, y, family, and ....

• control: A list of control parameters for the random projection process (e.g., mslow, msup, psi).

Attributes

The following attributes are commonly used in randomprojection objects:

• mslow: Integer. The minimum dimension for projection. Default: ⁠\eqn{\log(p)}⁠.

• msup: Integer. The maximum dimension for projection. Default: ⁠\eqn{n/2}⁠.

• data: Logical. If TRUE, the projection matrix is updated with data-dependent coefficients (e.g., for rp_cw).

Usage

'randomprojection' objects are typically created using predefined constructors like:

• rp_gaussian(): Gaussian random projection.

• rp_sparse(): Sparse random projection (Achlioptas, 2003).

• rp_cw(): Sparse Embedding (Clarkson-Woodruff) random projection.

Users can also define custom random projection methods by providing their own generate_fun, update_fun, and update_rpm_w_data functions to constructor_randomprojection.

References

Achlioptas D (2003). “Database-Friendly Random Projections: Johnson-Lindenstrauss with Binary Coins.” Journal of Computer and System Sciences, 66(4), 671-687. ISSN 0022-0000. doi:10.1016/S0022-0000(03)00025-4. Special Issue on PODS 2001.

Clarkson KL, Woodruff DP (2013). “Low Rank Approximation and Regression in Input Sparsity Time.” In Proceedings of the Forty-Fifth Annual ACM Symposium on Theory of Computing, STOC '13, 81–90. ISBN 9781450320290. doi:10.1145/2488608.2488620.

Parzer R, Filzmoser P, Vana-Gür L (2025). “Data-Driven Random Projection and Screening for High-Dimensional Generalized Linear Models.” Statistical Modelling. doi:10.1177/1471082X251392705..

See Also

constructor_randomprojection, rp_gaussian, rp_sparse, rp_cw, spar

Examples

rp_gauss <- rp_gaussian(mslow = 5, msup = 10)
example_data <- simulate_spareg_data(n = 200, p = 2000, ntest = 100)
spar_res <- spar(
  example_data$x,
  example_data$y,
  xval = example_data$xtest,
  yval = example_data$ytest,
  rp = rp_gauss
)

Sparse Embedding Matrix

Description

Creates an object class 'randomprojection' using arguments passed by user which in turn can be employed to generate a sparse embedding matrix as in (Clarkson and Woodruff 2013).

Usage

rp_cw(..., control = list())

Arguments

Details

The entries of the matrix are generated based on (Clarkson and Woodruff 2013). This matrix is constructed as \Phi=BD\in \mathbb{R}^{m\times p}, where B is a (p\times p) binary matrix, where for each column j an index is uniformly sampled from \{1,\ldots,m\} and the corresponding entry is set to one, and D is a (p\times p) diagonal matrix, with entries d_j \sim \text{Unif}(\{-1, 1\}). If specified as rp_cw(data = TRUE), the random elements on the diagonal are replaced by the ridge coefficients with a small penalty, as introduced in (Parzer et al. 2025).

Arguments related to the random projection procedure can be passed to the rp_cw() function through ..., and will be saved as attributes of the 'randomprojection' object. The following attributes are relevant for spar and spar.cv:

• mslow: integer giving the minimum dimension to which the predictors should be projected; defaults to \log(p).

• msup: integer giving the maximum dimension to which the predictors should be projected; defaults to n/2.

Value

object of class 'randomprojection' which is a list with elements name, generate_fun, update_fun, control

References

Clarkson KL, Woodruff DP (2013). “Low Rank Approximation and Regression in Input Sparsity Time.” In Proceedings of the Forty-Fifth Annual ACM Symposium on Theory of Computing, STOC '13, 81–90. ISBN 9781450320290. doi:10.1145/2488608.2488620.

Parzer R, Filzmoser P, Vana-Gür L (2025). “Data-Driven Random Projection and Screening for High-Dimensional Generalized Linear Models.” Statistical Modelling. doi:10.1177/1471082X251392705..

Examples

example_data <- simulate_spareg_data(n = 200, p = 2000, ntest = 100)
spar_res <- spar(example_data$x, example_data$y, xval = example_data$xtest,
  yval = example_data$ytest, nummods=c(5, 10, 15, 20, 25, 30),
  rp = rp_cw(data = TRUE))

Gaussian Random Projection Matrix

Description

Creates an object class 'randomprojection' using arguments passed by user which in turn can be employed to generate a random matrix with normally distributed entries (mean 0 and standard deviation 1 by default).

Usage

rp_gaussian(..., control = list())

Arguments

Details

Arguments related to the random projection procedure can be passed to the rp_gaussian() function through ..., and will be saved as attributes of the 'randomprojection' object. The following attributes are relevant for spar and spar.cv:

• mslow: integer giving the minimum dimension to which the predictors should be projected; defaults to \log(p).

• msup: integer giving the maximum dimension to which the predictors should be projected; defaults to n/2.

Value

Returns an object of class 'randomprojection' which is a list with elements name, generate_fun, update_fun, control

Examples

example_data <- simulate_spareg_data(n = 200, p = 2000, ntest = 100)
spar_res <- spar(example_data$x, example_data$y, xval = example_data$xtest,
  yval = example_data$ytest, nummods=c(5, 10, 15, 20, 25, 30),
  rp = rp_gaussian(control = list(sd = 1/sqrt(ncol(example_data$x)))))

Sparse Random Projection Matrix

Description

Creates an object class 'randomprojection' using arguments passed by user which in turn can be employed to generate a sparse embedding matrix as in (Achlioptas 2003).

Usage

rp_sparse(..., control = list())

Arguments

Details

The sparse matrix used in (Achlioptas 2003) with entries equal to \Psi_{ij} = \pm 1/\sqrt{\psi} with probability \psi/2 and zero otherwise for \psi\in (0,1]. Default is psi = 1.

Arguments related to the random projection procedure can be passed to the rp_gaussian() function through ..., and will be saved as attributes of the 'randomprojection' object. The following attributes are relevant for spar and spar.cv:

• mslow: integer giving the minimum dimension to which the predictors should be projected; defaults to \log(p).

• msup: integer giving the maximum dimension to which the predictors should be projected; defaults to n/2.

Value

object of class 'randomprojection' which is a list with elements name, generate_fun, update_fun, control

References

Achlioptas D (2003). “Database-Friendly Random Projections: Johnson-Lindenstrauss with Binary Coins.” Journal of Computer and System Sciences, 66(4), 671-687. ISSN 0022-0000. doi:10.1016/S0022-0000(03)00025-4. Special Issue on PODS 2001.

Examples

example_data <- simulate_spareg_data(n = 200, p = 2000, ntest = 100)
spar_res <- spar(example_data$x, example_data$y, xval = example_data$xtest,
  yval = example_data$ytest, nummods=c(5, 10, 15, 20, 25, 30),
  rp = rp_sparse(control = list(psi = 1/3)))

Screening Coefficient Based on Correlation

Description

Creates an object class 'screencoef' using arguments passed by user, where the screening coefficient should be computed based on the correlation coefficient of response and each predictor separately.

Usage

screen_cor(..., control = list())

Arguments

Details

Creates an object class 'screencoef' using arguments passed by user.

The function generate_fun relies on cor.

Arguments related to the screening procedure can be passed to the screen_cor() function through ..., and will be saved as attributes of the 'screencoef' object.

Value

object of class 'screencoef' which is a list with elements

• name (character, optional, used for printing)

• control (list of controls passed as an argument)

• generate_fun for generating the screening coefficient. This function should have arguments and y (vector of (standardized for Gaussian) responses), x (the matrix of standardized predictors) and a 'screencoef' object.

See Also

constructor_screencoef, screencoef

Examples

example_data <- simulate_spareg_data(n = 200, p = 2000, ntest = 100)
spar_res <- spar(example_data$x, example_data$y, xval = example_data$xtest,
  yval = example_data$ytest, nummods=c(5, 10, 15, 20, 25, 30),
  screencoef = screen_cor(control = list(method = "kendall")))

Screening Coefficient Based on glmnet Coefficients

Description

Creates an object class 'screencoef' using arguments passed by user, where the screening coefficient should be computed based on penalized coefficients.

Usage

screen_glmnet(..., control = list())

Arguments

Details

Creates an object class 'screencoef' using arguments passed by user.

The function generate_fun relies on glmnet.

Arguments related to the screening procedure can be passed to the screen_glmnet() function through ..., and will be saved as attributes of the 'screencoef' object.

Value

object of class 'screencoef' which is a list with elements

• name (character, optional, used for printing)

• control (list of controls passed as an argument)

• generate_fun for generating the screening coefficient. This function should have arguments and y (vector of (standardized for Gaussian) responses), x (the matrix of standardized predictors) and a 'screencoef' object.

See Also

constructor_screencoef, screencoef

Examples

example_data <- simulate_spareg_data(n = 200, p = 2000, ntest = 100)
spar_res <- spar(example_data$x, example_data$y, xval = example_data$xtest,
  yval = example_data$ytest, nummods=c(5, 10, 15, 20, 25, 30),
  screencoef = screen_glmnet(control = list(alpha = 0.1)))

Screening Coefficient Based on Marginal GLMs

Description

Creates an object class 'screencoef' using arguments passed by user, where the screening coefficient should be computed based on the marginal likelihood of the univariate GLM where the response is regressed on each predictor separately.

Usage

screen_marglik(..., control = list())

Arguments

Details

The function generate_fun relies on glm.

Arguments related to the screening procedure can be passed to the screen_marglik() function through ..., and will be saved as attributes of the 'screencoef' object. Note that if family is not provided in control, the family used in spar or spar.cv will be used.

Value

object of class 'screencoef' which is a list with elements:

• name (character, optional, used for printing)

• control (list of controls passed as an argument)

• generate_fun for generating the screening coefficient. This function should have arguments and y (vector of (standardized for Gaussian) responses), x (the matrix of standardized predictors) and a 'screencoef' object.

See Also

constructor_screencoef, screencoef

Examples

example_data <- simulate_spareg_data(n = 200, p = 2000, ntest = 100)
spar_res <- spar(example_data$x, example_data$y, xval = example_data$xtest,
  yval = example_data$ytest, nummods=c(5, 10, 15, 20, 25, 30),
  screencoef = screen_marglik(nscreen = 500))

Screening Coefficient Object Class

Description

The 'screencoef' class represents a configuration for computing and managing screening coefficients in the SPAR (Sparse Projected Averaged Regression) framework. Objects of this class encapsulate:

• Functions for generating and updating screening coefficients.

• Control parameters for the screening process.

• Metadata (e.g., name, attributes) for customization.

Screening coefficients are used to reduce the dimensionality of the predictor space by selecting the most relevant variables before applying random projections.

Details

Objects of class screencoef are created using the constructor_screencoef function. They are used in the spar and spar.cv functions to define how predictors are screened.

The class includes the following components:

• name: A character string describing the screening method (e.g., "screen_marglik", "screen_cor", "screen_glmnet").

• generate_fun: A function to compute the screening coefficients. This function must accept:

  • x: A matrix of standardized predictors.

  • y: A vector of standardized responses.

  • object: An object of class screencoef.

  • ...: Additional arguments passed from spar().

• update_fun: A function to update the screencoef object with data-specific information. This function must accept:

  • object: An object of class screencoef.

  • x: A matrix of standardized predictors.

  • y: A vector of standardized responses.

  • family: A stats::family object.

  • ...: Additional arguments passed from spar(). If not provided, the default update_screen_default is used, which leaves the object unchanged.

• control: A list of control parameters for the screening process (e.g., nscreen, split_data_prop).

Attributes

The following attributes are commonly used in screencoef objects:

• type: Character. The type of screening to employ:

  • "prob": Probabilistic screening (variables are selected probabilistically based on their screening coefficients).

  • "fixed": Fixed screening (the top nscreen variables are selected). Default: "prob".

• nscreen: Integer. The number of variables to retain after screening. Default: ⁠2n⁠ (twice the number of observations).

• split_data_prop: Numeric. The proportion of data to use for computing screening coefficients. The remaining data is used for fitting the marginal models. Default: 1 (use all data).

• reuse_in_rp: Logical. If TRUE, the screening coefficients are reused in the construction of the random projection. Default: FALSE.

• importance: Numeric vector. The screening coefficients computed from the data.

• inc_prob: Numeric vector. The inclusion probabilities for probabilistic screening (normalized screening coefficients).

Screening Methods

The following predefined screening methods are available:

• screen_marglik: Screening based on marginal likelihood in univariate GLMs. Uses stats::glm to fit a separate GLM for each predictor and extracts the coefficients.

• screen_cor: Screening based on correlation between predictors and the response. Uses stats::cor to compute correlation coefficients.

• screen_glmnet: Screening based on penalized regression coefficients from glmnet::glmnet. Uses Lasso or Ridge regression to compute coefficients.

Users can also define custom screening methods by providing their own generate_fun and update_fun functions to constructor_screencoef.

See Also

constructor_screencoef, screen_marglik, screen_cor, screen_glmnet, spar

Examples

screen_marglik_obj <- screen_marglik(nscreen = 500, type = "prob")
example_data <- simulate_spareg_data(n = 200, p = 2000, ntest = 100)
spar_res <- spar(
  example_data$x,
  example_data$y,
  xval = example_data$xtest,
  yval = example_data$ytest,
  screencoef = screen_marglik_obj
)

Simulate Sparse Regression Data

Description

Generates synthetic data for sparse linear regression problems. Returns training and test sets along with model parameters.

Usage

simulate_spareg_data(
  n,
  p,
  ntest,
  a = min(100, p/4),
  snr = 10,
  rho = 0.5,
  mu = 1,
  beta_vals = NULL,
  seed = NULL
)

Arguments

Value

A list with the following components:

x

Training design matrix ⁠(n x p)⁠.

y

Training response vector (length n).

xtest

Test design matrix (⁠ntest x p⁠).

ytest

Test response vector (length ntest).

mu

Intercept used in data generation.

beta

True coefficient vector (length p).

sigma2

Noise variance used in data generation. Equals \beta' \Sigma \beta/snr.

Examples

set.seed(123)
data <- simulate_spareg_data(n = 200, p = 2000, ntest = 100)
str(data)

Sparse Projected Averaged Regression (SPAR)

Description

Fits a Sparse Projected Averaged Regression (SPAR) model to high-dimensional data. SPAR builds an ensemble of generalized linear models (GLMs) where high-dimensional predictors are first screened (using a screening coefficient) and then projected using random projection matrices. This function evaluates the model over a grid of thresholds (nus) and a grid of the number of marginal models (nummods). It is also used internally by the cross-validated procedure spar.cv.

Usage

spar(
  x,
  y,
  family = gaussian("identity"),
  model = NULL,
  rp = NULL,
  screencoef = NULL,
  xval = NULL,
  yval = NULL,
  nnu = 20L,
  nus = NULL,
  nummods = 20L,
  measure = c("deviance", "mse", "mae", "class", "1-auc"),
  avg_type = c("link", "response"),
  parallel = FALSE,
  inds = NULL,
  RPMs = NULL,
  seed = NULL,
  ...
)

spareg(
  x,
  y,
  family = gaussian("identity"),
  model = NULL,
  rp = NULL,
  screencoef = NULL,
  xval = NULL,
  yval = NULL,
  nnu = 20L,
  nus = NULL,
  nummods = 20L,
  measure = c("deviance", "mse", "mae", "class", "1-auc"),
  avg_type = c("link", "response"),
  parallel = FALSE,
  inds = NULL,
  RPMs = NULL,
  seed = NULL,
  ...
)

Arguments

Details

If a parallel backend (e.g., doParallel) is registered and parallel = TRUE, the foreach package is used to parallelize the estimation of marginal models. If a parallel backend is registered and parallel = TRUE, the foreach function is used to estimate the marginal models in parallel.

Value

An object of class spar with the following components:

• betas: A ⁠p x max(nummods)⁠ sparse matrix of standardized coefficients for each marginal model.

• intercepts: Intercepts for each marginal model.

• scr_coef: A vector of length p with screening coefficients for standardized predictors.

• inds: A list of index vectors for variables retained after screening.

• RPMs: A list of projection matrices for each marginal model.

• val_res: A data.frame with validation results (measure and number of active variables) for each M and \nu.

• val_set: A logical flag indicating whether validation data were provided.

• family: The family object used for the GLM.

• nus: The vector of thresholds considered.

• nummods: The vector of numbers of marginal models considered.

• ycenter: The empirical mean of the initial response vector.

• yscale: The empirical standard deviation of the initial response vector.

• xcenter: A vector of empirical means for the initial predictors.

• xscale: A vector of empirical standard deviations for the initial predictors.

• avg_type: The averaging type used for validation.

• measure: The validation measure used.

• rp: The 'randomprojection' object.

• screencoef: The 'screencoef' object.

• x_rows_for_fitting_marginal_models: A vector of row indices from x used for fitting marginal models (if screening splits data).

References

Parzer R, Filzmoser P, Vana-Gür L (2025). “Sparse Data-Driven Random Projection in Regression for High-Dimensional Data.” Journal of Data Science, Statistics, and Visualisation, 5(5). doi:10.52933/jdssv.v5i5.138.

Parzer R, Filzmoser P, Vana-Gür L (2025). “Data-Driven Random Projection and Screening for High-Dimensional Generalized Linear Models.” Statistical Modelling. doi:10.1177/1471082X251392705.

Clarkson KL, Woodruff DP (2013). “Low Rank Approximation and Regression in Input Sparsity Time.” In Proceedings of the Forty-Fifth Annual ACM Symposium on Theory of Computing, STOC '13, 81–90. ISBN 9781450320290. doi:10.1145/2488608.2488620.

Achlioptas D (2003). “Database-Friendly Random Projections: Johnson-Lindenstrauss with Binary Coins.” Journal of Computer and System Sciences, 66(4), 671-687. ISSN 0022-0000. doi:10.1016/S0022-0000(03)00025-4. Special Issue on PODS 2001.

See Also

spar.cv, coef.spar, predict.spar, plot.spar, print.spar

Examples

example_data <- simulate_spareg_data(n = 200, p = 400, ntest = 100)
spar_res <- spar(example_data$x, example_data$y, xval = example_data$xtest,
  yval = example_data$ytest, nummods=c(5, 10, 15, 20, 25, 30))
coefs <- coef(spar_res)
pred <- predict(spar_res, xnew = example_data$x)
plot(spar_res)
plot(spar_res, plot_type = "val_measure", plot_along = "nummod", nu = 0)
plot(spar_res, plot_type = "val_measure", plot_along = "nu", nummod = 10)
plot(spar_res, plot_type = "val_numactive",  plot_along = "nummod", nu = 0)
plot(spar_res, plot_type = "val_numactive",  plot_along = "nu", nummod = 10)
plot(spar_res, plot_type = "res_vs_fitted",  xfit = example_data$xtest,
  yfit = example_data$ytest)
plot(spar_res, plot_type = "coefs", prange = c(1,400))

spar_res <- spareg(example_data$x, example_data$y, xval = example_data$xtest,
  yval = example_data$ytest, nummods=c(5, 10, 15, 20, 25, 30))

Sparse Projected Averaged Regression with Cross-Validation

Description

Apply Sparse Projected Averaged Regression to High-Dimensional Data, where the number of models and the threshold parameter is chosen using a cross-validation procedure.

Usage

spar.cv(
  x,
  y,
  family = gaussian("identity"),
  model = spar_glmnet(),
  rp = NULL,
  screencoef = NULL,
  nfolds = 10,
  nnu = 20,
  nus = NULL,
  nummods = c(20),
  measure = c("deviance", "mse", "mae", "class", "1-auc"),
  avg_type = c("link", "response"),
  parallel = FALSE,
  seed = NULL,
  precompute_mode = c("precompute_all", "precompute_rpm", "full_cv"),
  ...
)

spareg.cv(
  x,
  y,
  family = gaussian("identity"),
  model = spar_glmnet(),
  rp = NULL,
  screencoef = NULL,
  nfolds = 10,
  nnu = 20,
  nus = NULL,
  nummods = c(20),
  measure = c("deviance", "mse", "mae", "class", "1-auc"),
  avg_type = c("link", "response"),
  parallel = FALSE,
  seed = NULL,
  precompute_mode = c("precompute_all", "precompute_rpm", "full_cv"),
  ...
)

Arguments

Value

object of class 'spar.cv' with elements

• val_res a data.frame with CV results for each fold and for each element of nus and nummods

• fitted_objects list of fitted objects for the whole data (first element) and for each fold, each element is a list with elements

  • betas_std p x max(nummods) sparse matrix of class 'Matrix::dgCMatrix' containing the standardized coefficients from each marginal model computed with the SPAR algorithm on the training data.

  • intercepts in each marginal model, vector of length max(nummods) computed with the SPAR algorithm on the training data.

  • scr_coef p-vector of coefficients used for screening for standardized predictors

  • inds list of index-vectors corresponding to variables kept after screening in each marginal model of length max(nummods). If kept fixed, only the first element corresponding to the indicators computed on the whole data is populated.

  • RPMs list of projection matrices used in each marginal model of length max(nummods). If kept fixed, only the first element corresponding to the projection matrices generated once on the whole data is populated.

  • ycenter empirical mean of response vector in training data

  • yscale empirical standard deviation of response vector in training data .

  • xcenter p-vector of empirical means of predictor variables in training data

  • xscale p-vector of empirical standard deviations of predictor variables in training data

  • seed integer seed used at the beginning of the algorithm. In each fold the seed is modified as seed + fold_id.

• nus vector of \nu's considered for thresholding

• nummods vector of numbers of marginal models considered for validation

• family a character corresponding to family object used for the marginal generalized linear model e.g., "gaussian(identity)"

• measure character, type of validation measure used

• avg_type character, averaging type for computing the validation measure

• rp an object of class 'randomprojection'

• screencoef an object of class 'screeningcoef'

• model an object of class 'sparmodel'

• precompute_mode character, one of c("precompute_all", "precompute_rpm", "full_cv"), indicating whether the same random projection matrix and/or the same indices for screening across folds were used.

• seed integer seed used at the beginning of the algorithm.

See Also

spar, coef.spar.cv, predict.spar.cv, plot.spar.cv, print.spar.cv

Examples

example_data <- simulate_spareg_data(n = 80, p = 200, ntest = 100)
spar_res <- spar.cv(example_data$x, example_data$y, nfolds = 3L,
  rp = rp_gaussian(), nummods = c(5, 10))
spar_res


spar_res <- spareg.cv(example_data$x, example_data$y,
  nummods=c(5, 10, 15, 20, 25, 30))

GLM Marginal sparmodel

Description

Creates an object class sparmodel using arguments passed by user. The generating function computes the coefficients of the marginal models based on a GLM. Computation relies on stats::glm.

Usage

spar_glm(..., control = list())

Arguments

Details

Relies on glm.

Value

Returns an object of class sparmodel.

See Also

sparmodel, stats::glm

Examples

example_data <- simulate_spareg_data(n = 100, p = 400, ntest = 100)
spar_res <- spar(example_data$x, example_data$y,
  xval = example_data$xtest, yval = example_data$ytest,
  model = spar_glm())

Penalized GLM Marginal sparmodel

Description

Creates an object class sparmodel using arguments passed by user, where the generating function computes the coefficients of the marginal models based on a penalized GLM. Computation relies on glmnet::glmnet. By default, the models assume \alpha=0 and return the coefficients obtained with the penalty \lambda_\text{min}.

Usage

spar_glmnet(..., control = list())

Arguments

Details

Relies on glmnet.

Value

Returns an object of class sparmodel.

See Also

sparmodel, glmnet::glmnet

Examples

example_data <- simulate_spareg_data(n = 100, p = 400, ntest = 100)
spar_res <- spar(example_data$x, example_data$y,
  xval = example_data$xtest, yval = example_data$ytest,
  model = spar_glmnet(alpha = 0.1))

SPAR Model Object Class

Description

The sparmodel class represents a configuration for fitting marginal models in the SPAR (Sparse Projected Averaged Regression) framework. Objects of this class encapsulate:

• Functions for estimating marginal models (e.g., GLM, GLMNET, or custom models).

• Control parameters for the model fitting process.

• Metadata (e.g., name, attributes) for customization.

Marginal models are fitted to projected predictors (after screening and random projection) to compute coefficients and intercepts for each model in the ensemble.

Details

Objects of class sparmodel are created using the constructor_sparmodel function or predefined constructors like spar_glm and spar_glmnet. They are used in the spar and spar.cv functions to define how marginal models are fitted to the projected data.

The class includes the following components:

• name: A character string describing the model type (e.g., "glm", "glmnet", "glmrob").

• generate_fun: A function to estimate the marginal model coefficients and intercept. This function must accept:

  • object: An object of class sparmodel.

  • x: A matrix of standardized predictors (unused in most cases, as models are fitted on projected data).

  • y: A vector of standardized responses.

  • z: A matrix of projected predictors (the design matrix for the marginal model).

  • ...: Additional arguments passed from spar(). The function must return a list with two elements:

    • gammas: A vector of regression coefficients for the projected predictors.

    • intercept: The intercept of the model.

• update_fun: A function to update the sparmodel object with data-specific information before fitting. This function must accept:

  • object: An object of class sparmodel.

  • x: A matrix of standardized predictors.

  • y: A vector of standardized responses.

  • family: A stats::family object.

  • ...: Additional arguments passed from spar(). If not provided, the default update_sparmodel_default is used, which only updates the family if missing.

• control: A list of control parameters for the model fitting process (e.g., family, alpha for glmnet).

Model Types

The following predefined model types are available:

• spar_glm: Fits marginal models using stats::glm. Supports all standard GLM families. For Gaussian models with identity link, it uses a fast OLS solver.

• spar_glmnet: Fits marginal models using glmnet::glmnet. Supports penalized regression (Ridge, Lasso, or Elastic Net). Automatically converts family objects to strings for compatibility with glmnet.

• Custom Models: Users can define their own model types by providing custom generate_fun and update_fun functions to constructor_sparmodel. For example, spar_glmrob (not exported by default) uses robustbase::glmrob for robust regression.

See Also

constructor_sparmodel, spar_glm, spar_glmnet, spar

Examples

model_glmnet <- spar_glmnet(alpha = 0.5)

example_data <- simulate_spareg_data(n = 200, p = 2000, ntest = 100)
spar_res <- spar(
  example_data$x,
  example_data$y,
  xval = example_data$xtest,
  yval = example_data$ytest,
  model = model_glmnet
)

Summary Method for 'coefspar' Object

Description

Provides a detailed summary of a coefspar object, including coefficient statistics.

Usage

## S3 method for class 'coefspar'
summary(object, digits = 4L, ...)

Arguments

Value

Invisibly returns input object.

Examples

example_data <- simulate_spareg_data(n = 100, p = 2000, ntest = 100)
spar_res <- spareg(example_data$x, example_data$y, xval = example_data$xtest,
  yval = example_data$ytest, nummods=c(5, 10))
summary(coef(spar_res))
summary(coef(spar_res, aggregate = "none"))

Default Update Function for Random Projection Objects

Description

A default function to update a randomprojection object with the family information. This function is used internally by constructor_randomprojection if no custom update_fun is provided.

Usage

update_rp_default(object, x, y, family, ...)

Arguments

Value

The updated 'randomprojection' object with the family_string attribute set.

Default Function to Update Random Projection Matrices

Description

A default function that returns the input random projection matrix unchanged. This function is used internally by constructor_randomprojection if no custom update_rpm_w_data is provided.

Usage

update_rpm_identity(rpm, object, included_vector, x, y, family, ...)

Arguments

Value

The input rpm matrix, unchanged.

Update screening glmnet object

Description

Update screening glmnet object

Usage

update_screen_glmnet(object, x, y, family, ...)

Arguments

Value

vector of screening coefficients of length p