tidymodels-tree4

statlearning

trees

tidymodels

speed

string

Published

November 8, 2023

Aufgabe

Berechnen Sie folgendes einfache Modell:

Entscheidungsbaum

Modellformel: body_mass_g ~ . (Datensatz palmerpenguins::penguins)

Hier geht es darum, die Geschwindigkeit (und den Ressourcenverbrauch) beim Fitten zu verringern. Benutzen Sie dazu folgende Methoden

Auslassen gering performanter Tuningparameterwerte
Verwenden Sie ein Anova-Grid-Search!
Parallelisieren Sie auf mehrere Kerne (wenn möglich).

Hinweise:

Tunen Sie alle Parameter (die der Engine anbietet).
Verwenden Sie Defaults, wo nicht anders angegeben.
Beachten Sie die üblichen Hinweise.

Lösung

Setup

library(tidymodels)
data("penguins", package = "palmerpenguins")
library(tictoc)  # Zeitmessung
library(finetune)  # tune_race_anova
library(doParallel)  # mehrere CPUs nutzen 
set.seed(42)

Entfernen wir Fälle ohne y-Wert:

d <-
  penguins %>% 
  drop_na(body_mass_g)

Daten teilen

set.seed(42)
d_split <- initial_split(d)
d_train <- training(d_split)
d_test <- testing(d_split)

Modell(e)

mod_tree <-
  decision_tree(mode = "regression",
                cost_complexity = tune(),
                tree_depth = tune(),
                min_n = tune())

Rezept(e)

rec_plain <- 
  recipe(body_mass_g ~ ., data = d_train)

Resampling

set.seed(42)
rsmpl <- vfold_cv(d_train)

Workflows

wf_tree <-
  workflow() %>%  
  add_recipe(rec_plain) %>% 
  add_model(mod_tree)

Tuning-Grid

Tuninggrid:

tune_grid <- grid_regular(extract_parameter_set_dials(mod_tree), levels = 5)

Hinweis: Andere Arten von Tuning-Grids sind sinnvoller, hier ist nur zum Vergleich mit anderen Aufgaben diese Form des Tuning-Grids gewählt.

Die Zeilen im Tuninggrid zeigen uns, für wie viele Modellparameter ein Modell berechnet wird. Natürlich üblicherweise jedes Modell mit Resampling. Da kommt in Summe ein mitunter sehr große Menge an Modellberechnungen zusammen.

Ohne Speed-up

tic()
fit_tree <-
  tune_grid(object = wf_tree,
            grid = tune_grid,
            metrics = metric_set(rmse),
            resamples = rsmpl)
toc()

111.597 sec elapsed

Die angegebene Rechenzeit bezieht sich auf einen 4-Kerne-MacBook Pro (2020).

Mit Speeed-up 1

tic()
fit_tree2 <-
  tune_race_anova(object = wf_tree,
            grid = tune_grid,
            metrics = metric_set(rmse),
            control = control_race(verbose = FALSE,
                                   pkgs = c("tidymodels"),
                                   save_pred = TRUE),
            resamples = rsmpl)
toc()

140.425 sec elapsed

Mit Speeed-up 2

doParallel::registerDoParallel()

tic()
fit_tree2 <-
  tune_race_anova(
    object = wf_tree,
    grid = tune_grid,
    metrics = metric_set(rmse),
    control = control_race(verbose = FALSE,
                           pkgs = c("tidymodels"),
                           save_pred = TRUE),
            resamples = rsmpl)
toc()

129.935 sec elapsed

Mit Speeed-up 3

doParallel::registerDoParallel()

tic()
fit_tree2 <-
  tune_grid(object = wf_tree,
            grid = tune_grid,
            metrics = metric_set(rmse),
            control = control_grid(verbose = FALSE,
                                   save_pred = TRUE),
            resamples = rsmpl)
toc()

92.329 sec elapsed

Fazit

Mit Speed-up ist schneller also ohne. Hier haben wir einen Entscheidungsbaum berechnet, der ist nicht so sehr parallelisierbar. Bei einem “Wald-Modell”, wie Random Forests, sollte der Vorteil der Parallisierung viel deutlich sein.

Categories:

statlearning
trees
tidymodels
speed
string

--- exname: tidymodels-tree4 expoints: 1 extype: string exsolution: NA categories: - statlearning - trees - tidymodels - speed - string date: '2023-11-08' slug: tidymodels-tree4 title: tidymodels-tree4 --- # Aufgabe Berechnen Sie folgendes einfache Modell: 1. Entscheidungsbaum Modellformel: `body_mass_g ~ .` (Datensatz `palmerpenguins::penguins`) Hier geht es darum, die Geschwindigkeit (und den Ressourcenverbrauch) beim Fitten zu verringern. Benutzen Sie dazu folgende Methoden - Auslassen gering performanter Tuningparameterwerte - Verwenden Sie ein Anova-Grid-Search! - Parallelisieren Sie auf mehrere Kerne (wenn möglich). Hinweise: - Tunen Sie alle Parameter (die der Engine anbietet). - Verwenden Sie Defaults, wo nicht anders angegeben. - Beachten Sie die [üblichen Hinweise](https://datenwerk.netlify.app/hinweise). # Lösung ## Setup ```{r} library(tidymodels) data("penguins", package = "palmerpenguins") library(tictoc) # Zeitmessung library(finetune) # tune_race_anova library(doParallel) # mehrere CPUs nutzen set.seed(42) ``` Entfernen wir Fälle ohne y-Wert: ```{r} d <- penguins %>% drop_na(body_mass_g) ``` ## Daten teilen ```{r} set.seed(42) d_split <- initial_split(d) d_train <- training(d_split) d_test <- testing(d_split) ``` ## Modell(e) ```{r} mod_tree <- decision_tree(mode = "regression", cost_complexity = tune(), tree_depth = tune(), min_n = tune()) ``` ## Rezept(e) ```{r} rec_plain <- recipe(body_mass_g ~ ., data = d_train) ``` ## Resampling ```{r} set.seed(42) rsmpl <- vfold_cv(d_train) ``` ## Workflows ```{r} wf_tree <- workflow() %>% add_recipe(rec_plain) %>% add_model(mod_tree) ``` ## Tuning-Grid Tuninggrid: ```{r} tune_grid <- grid_regular(extract_parameter_set_dials(mod_tree), levels = 5) ``` *Hinweis*: Andere Arten von Tuning-Grids sind sinnvoller, hier ist nur zum Vergleich mit anderen Aufgaben diese Form des Tuning-Grids gewählt. Die Zeilen im Tuninggrid zeigen uns, für wie viele Modellparameter ein Modell berechnet wird. Natürlich üblicherweise jedes Modell mit Resampling. Da kommt in Summe ein mitunter sehr große Menge an Modellberechnungen zusammen. ## Ohne Speed-up ```{r} tic() fit_tree <- tune_grid(object = wf_tree, grid = tune_grid, metrics = metric_set(rmse), resamples = rsmpl) toc() ``` Die angegebene Rechenzeit bezieht sich auf einen 4-Kerne-MacBook Pro (2020). ## Mit Speeed-up 1 ```{r speed1} tic() fit_tree2 <- tune_race_anova(object = wf_tree, grid = tune_grid, metrics = metric_set(rmse), control = control_race(verbose = FALSE, pkgs = c("tidymodels"), save_pred = TRUE), resamples = rsmpl) toc() ``` ## Mit Speeed-up 2 ```{r speed2} doParallel::registerDoParallel() tic() fit_tree2 <- tune_race_anova( object = wf_tree, grid = tune_grid, metrics = metric_set(rmse), control = control_race(verbose = FALSE, pkgs = c("tidymodels"), save_pred = TRUE), resamples = rsmpl) toc() ``` ## Mit Speeed-up 3 ```{r speed3} doParallel::registerDoParallel() tic() fit_tree2 <- tune_grid(object = wf_tree, grid = tune_grid, metrics = metric_set(rmse), control = control_grid(verbose = FALSE, save_pred = TRUE), resamples = rsmpl) toc() ``` ## Fazit Mit Speed-up ist schneller also ohne. Hier haben wir einen Entscheidungsbaum berechnet, der ist nicht so sehr parallelisierbar. Bei einem "Wald-Modell", wie Random Forests, sollte der Vorteil der Parallisierung viel deutlich sein. --- Categories: - statlearning - trees - tidymodels - speed - string