Installing R

To install R, you need to download the installer from CRAN, the Comprehensive R Archive Network. This is the official repository for R packages and R itself. The website itself may look a little dated, which is mostly due to it being, in fact, a little dated.

Here you find direct links to download R for Windows, macOS and Linux — but please note that for Linux, I provide alternative instructions below that do not make use of CRAN.

If you are on Windows or macOS, proceed to the appropriate option here. Please note that I have extensive experience on macOS and various Linux distributions, but I do not have any recent experience with Windows. If you find these instructions lacking, please refer to the video guides I linked below for additional resources.

Now, click on the tab for your operating system for the next steps.

• Windows
• macOS
• Linux (e.g. Ubuntu)

You will be presented with multiple links, but the relevant one is the base version of R, which includes the core components.

Click on it and you will be greeted with this page:

Here, click the highlighted link to download the installer.

Run the installer on your PC and follow the instructions. You may be asked to accept the usual licenses of course, and can accept nay other defaults.

Optional: RTools

While you are here, you might as well also install RTools.
You may not need this at first, but at some point in the future you may be asked to install an in-development R package from a different source than CRAN such as GitHub. In these cases it may be necessary to compile the package from source, requiring additional compilers and tools — this is what RTools provides.

Navigate back to the overview site where you found base R and look for the link to RTools.

Click on the link to RTools 4.4 (or whichever is the most recent version) and download the installer.

Run the installer and you should be good to go!

The download page for macOS is quite simple: For reasonably modern systems, you can just click the top link to download the latest version of R for macOS.

Click on the top link to download the latest version of R for macOS on recent Apple computers. For older systems (pre 2020’s Apple Silicon), you may need to use second link for Intel Macs.

Tip

If you are unsure which version is correct for you, you should find some system information in the About this Mac section of your computer via the Settings app. Any reference to an “Apple M1” (or M2, …) chip means you have a recent Apple Silicon Mac.

For even older systems you may need to scroll down further for “Binaries for legacy macOS/OS X systems”, but I do not have experience with installing R on legacy systems unfortunately.

In any case, you will have downloaded a .pkg file, which you can run by double-clicking it and following the instructions, accepting any defaults that may come up.

Rather than installing R from CRAN, I have made very good experience with a tool called rig and basically always use it on any platform I can.

You can install it on many Linux platforms, including Ubuntu, by following the instructions provided in its documentation. Due to the myriad of Linux distributions, I cannot provide a one-size-fits-all solution here, but the instructions on the rig page should be sufficient, assuming you know how to enter commands in a terminal.

After installing it, you can install R by running the following command in your terminal:

rig add release

Afterwards, running R in your terminal should start R.

That’s it!
Whichever path you chose, you should now have R installed on your system! Note that this is only the so-called “base R” distribution, which means that it contains the core parts of the language. However, there is an extensive package ecosystem that you can install on top of this, extending the functionality of R in many ways. We will install one collection of packages after the next section.

Installing RStudio

We move on to install RStudio, the IDE for R. We get it from the Posit website, where you will find a download link for RStudio Desktop. Posit is the public benefit company formally known as RStudio, so you might run into references to both “RStudio the company” and “RStudio the IDE” on the internet. These days it is the company Posit, publishing the open-source IDE RStudio.

You will find two large buttons, one for installing R — which you presumably already did! If not, please scroll up on this site.

The second link hopefully links to the download for RStudio on your system, but if not, you can find the appropriate link in the list below.

Scrolling further down, you find download links for Windows, macOS, various versions of Ubuntu, and less common Linux distributions. If the big link above does not match your platform, you will hopefully find the correct version here.

Click on the appropriate link for your system to download the installer, and run it just like you did the R installer before or however else you typically install software.

Checking the Installation

After installing R and RStudio, you can check if everything is working by opening RStudio. Depending on your platform you might either find a desktop shortcut showing the RStudio logo or you can find it in your applications menu.

When you open RStudio, you should see a window similar to the one below.

The left half constitutes the console view, where you can type and execute R code directly. We will now try installing the tidyverse, a collection of packages that are very useful for data analysis and visualization. The tidyverse package itself is a collection of multiple other packages, each in turn providing different functionality.

Type

install.packages("tidyverse")

and press Enter You should see some activity in the console, and after a while you should see a message that the package was installed successfully. The text may be red, but that does not necessarily imply there was an error!

Finally, type

library("tidyverse")

and press Enter again. If you do not see any error messages, you have successfully installed R and RStudio, and even set up the tidyverse already!

Video Guides

If you prefer a video guide, many are available on YouTube.
Here are a few examples:

The Data

We’re using the Bikeshare data as included with the ISLR2 package (originally from the UCI Machine Learning Repository), which I preprocessed and whittled down a little for simplicity’s sake. You can look at the preprocessing steps in the code below, but I’ll skip the dataset exploration as it’s not the focus of this post.

library(data.table)
if (!("ISLR2" %in% installed.packages())) {
  install.packages("ISLR2")
}

data("Bikeshare", package = "ISLR2")

bike <- data.table(Bikeshare)
bike[, hr := as.numeric(as.character(hr))]
bike[, workingday := factor(workingday, levels = c(0, 1), labels = c("No Workingday", "Workingday"))]
bike[, season := factor(season, levels = 1:4, labels = c("Winter", "Spring", "Summer", "Fall"))]
bike[, atemp := NULL]
bike[, day := NULL]
bike[, registered := NULL]
bike[, casual := NULL]

saveRDS(bike, "bike.rds")

Tuning with mlr3

I wrapped the rpf learner into an mlr3 learner for mlr3extralearners, which makes it very convenient to tune. If you’re unfamiliar with the mlr3 ecosystem, well guess who contributed to the now-published mlr3 book available for free online, which you can also buy from your friendly neighborhood dystopian online retailer in fancy tree corpse form.
No judgement.
Mostly.
It’s fine.

Anyway, here’s the code I used, which is fairly standard “wrap learner in AutoTuner and tune the thing with 3-fold cross-validation and a somewhat arbitrary tuning budget using MBO I guess because why not” (WLATT3FCVSATBUMBOIGBWN, as my grampa used to call it).

library(mlr3verse)
library(mlr3extralearners)
# install.packages("mlr3extralearners", repos = "https://mlr-org.r-universe.dev")

bike <- readRDS("bike.rds")
biketask <- as_task_regr(bike, target = "bikers")
splits <- partition(biketask)

tuned_rpf <- auto_tuner(
  learner = lrn("regr.rpf", ntrees = 200, max_interaction = 4, nthreads = 2),
  tuner = tnr("mbo"),
  resampling = rsmp("cv", folds = 3),
  terminator = trm("evals", n_evals = 100, k = 10),
  search_space = ps(
    max_interaction = p_int(2, 10),
    splits = p_int(10, 100),
    split_try = p_int(1, 20),
    t_try = p_dbl(0.1, 1)
  ),
  store_tuning_instance = TRUE, 
  store_benchmark_result = TRUE
)

tuned_rpf$train(biketask, row_ids = splits$train)

Ideally, we would evaluate the tuned rpf on the test dataset like this:

pred <- tuned_rpf$predict(biketask, row_ids = splits$test)
pred$score(msr("regr.rmsle"))

…but since I saved the learner with saveRDS() on a different machine and restored it here for use with this post, we only get the error message

Error:
! external pointer is not valid

This is related to rpf using Rcpp modules under the hood, with the takeaway being that at the time of writing I don’t know if there’s a way to serialize and deserialize rpf models for situations like this. This is quite unfortunate, but for the time being we’ll just have to assume that the tuning result is somewhat reasonable. I should have just tuned on the full datasets, but alas, I guess this will have to do now.

Anyways, we extract the tuning archive stored in $archive of the AutoTuner object and convert the MSE we initially tuned with to the RMSE just to get a more manageable range of scores.

library(data.table)
archive <- tuned_rpf$archive$data
archive[, regr.rmse := sqrt(regr.mse)]

The kaggle challenge for this dataset (or a version of it, anyway) evaluates using the RMSLE, which would probably be more appropriate, come to think of it. Putting that one on the “oh well, next time” pile.

Let’s take a look at our scores in relation to our hyperparameter configurations first — one at a time, ignoring any interdependencies.

library(ggplot2)
melt(archive, id.vars = "regr.rmse", 
     measure.vars = c("splits", "split_try", "t_try", "max_interaction")) |>
  ggplot(aes(x = value, y = regr.rmse)) +
  facet_wrap(vars(variable), scales = "free_x") +
  geom_point() +
  labs(
    title = "rpf / Bikeshare tuning archive",
    subtitle = "Scores on inner resampling folds",
    x = "Parameter Value", y = "RMSE"
  )

The main thing to note here is that “more splits more good”, while the picture for the other parameters isn’t as clear. Other parameters might interact, and overall it’s not obvious if a parameter is more important than another.

Would be nice if we could somehow functionally decompose the effects of these parameters up to arbitrary ord— oh wait that’s glex, yes, let’s do the glex thing.

Explaining the Tuning Results

Both glex and randomPlantedForest can be installed via r-universe if you can’t be bothered to type remotes::install_github("PlantedML/glex") and/or remotes::install_github("PlantedML/randomPlantedForest"), which I usually can’t:

install.packages(c("glex", "randomPlantedForest"), repos = "https://plantedml.r-universe.dev")

library(randomPlantedForest)
library(glex)

We then fit another rpf with heuristically picked parameters on the tuning archive, using the RMSE as target and tuning parameters as features. Why not tune rpf “properly” here, you ask? Because I can’t decide whether I want to make this post a recursion joke or not. Also time is finite and I couldn’t be bothered.

rpfit <- rpf(
  regr.rmse ~ splits + split_try + t_try + max_interaction, 
  data = archive, 
  ntrees = 100, 
  splits = 100, 
  split_try = 20, 
  t_try = 1, 
  max_interaction = 4,
  nthreads = 3
)

rpglex <- glex(rpfit, tuned_rpf$archive$data)

rpvi <- glex_vi(rpglex)

autoplot(rpvi)

autoplot(rpvi, by_degree = TRUE)

library(patchwork)
p1 <- autoplot(rpglex, "splits")
p2 <- autoplot(rpglex, "t_try") 
p3 <- autoplot(rpglex, "max_interaction")
p4 <- autoplot(rpglex, "split_try")

(p1 + p2) / (p3 + p4)

autoplot(rpglex, c("splits", "split_try")) + 
autoplot(rpglex, c("splits", "t_try"))

tuned_rpf$tuning_result[, c("splits", "split_try", "t_try", "max_interaction")]

   splits split_try     t_try max_interaction
    <int>     <int>     <num>           <int>
1:    100         6 0.9422986               6

c(rmse = sqrt(tuned_rpf$tuning_result$regr.mse))

    rmse 
35.79528 

Conclusion

The key takeaway for the Bikeshare tuning is that:

• splits wants to be large.
• t_try wants to be close to 1.
• Setting max_interaction to 5 or greater is only going to make you wait for the result longer.
• split_try is also a parameter that exists. Idunno maybe just wing it with that boi and be done with it.

Turns out it wasn’t particularly eye-opening to take a look at parameter interactions, but oh well. Better to have decomposed and not needed it than to never decompose at all. Or something.