## Running cross_validate from cvms in parallel

The cvms package is useful for cross-validating a list of linear and logistic regression model formulas in R. To speed up the process, I’ve added the option to cross-validate the models in parallel. In this post, I will walk you through a simple example and introduce the combine_predictors() function, which generates model formulas by combining a list of fixed effects. We will be using the simple `participant.scores`

dataset from cvms.

First, we will install the newest versions of cvms and groupdata2 from GitHub. You will also need the doParallel package.

`# Install packages`

devtools::install_github("ludvigolsen/groupdata2")

devtools::install_github("ludvigolsen/cvms")

Then, we attach the packages and set the random seed to 1.

`# Attach packages`

library(cvms) # cross_validate, combine_predictors

library(groupdata2) # fold

library(doParallel) # registerDoParallel

`# Set seed for reproducibility`

# Note that R versions < 3.6.0 may give different results

set.seed(1)

Now, we will create the folds for cross-validation. This simply adds a factor in the dataset called .folds with folds identifiers (e.g. 1,1,1,2,2,3,3,…). We will also ensure that we have a similar ratio of the two diagnoses in the folds, and that all rows pertaining to a participant is put in the same fold.

`# Create folds in the dataset`

data <- fold(participant.scores, k = 4,

cat_col = "diagnosis",

id_col = "participant")

We will use the combine_predictors() function to generate our model formulas. We supply the list of fixed effects (we will use *age* and *score*) and it combines them with and without interactions. Note that when we have more than 6 fixed effects, it becomes very slow due to the number of the possible combinations. To deal with this, it has some options to limit the number of fixed effects per formula, along with the maximum size of included interactions. We will not use those here though.

`# Generate model formulas with combine_predictors()`

models <- combine_predictors(dependent = "diagnosis",

fixed_effects = c("age", "score"))

models

`### [1] "diagnosis ~ age" "diagnosis ~ score"`

### [3] "diagnosis ~ age * score" "diagnosis ~ age + score"

We want to test if running cross_validate() in parallel is faster than running it sequentially. This would be hard to tell with only 4 simple models, so we repeat the model formulas 100 times each.

`# Repeat formulas 100 times`

models_repeated <- rep(models, each = 100)

Now we can cross-validate with and without parallelization. We will start *without* it.

`# Cross-validate the model formulas without parallelization`

system.time({cv_1 <- cross_validate(data,

models = models_repeated,

family = "binomial")})

`### user system elapsed`

### 26.290 0.194 26.595

This took **26.595** seconds to run.

For the parallelization, we will use the doParallel package. There are other options out there though.

First, we register the number of CPU cores to use. I will use 4 cores.

`# Register CPU cores`

registerDoParallel(4)

Then, we simply set parallel to TRUE in cross_validate().

`# Cross-validate the model formulas with parallelization`

system.time({cv_2 <- cross_validate(data,

models = models_repeated,

family = "binomial",

parallel = TRUE)})

`### user system elapsed`

### 39.274 1.845 10.955

This time it took only **10.955** seconds!

As these formulas are very simple, and the dataset is very small, it’s difficult to estimate how much time the parallelization will save in the real world. If we were cross-validating a lot of larger models on a big dataset, it could be a meaningful option.

In this post, you have learned to run cross_validate() in parallel. This functionality can also be found in validate(), and I have also added it to the new baseline() function, which I will cover in a future post. It creates baseline evaluations, so we have something to compare our awesome models to. Pretty neat!

You have also learned to generate model formulas with combine_predictors().