Ottimizzazione degli iperparametri

Modellazione con tidymodels in R

David Svancer

Data Scientist

Iperparametri

Parametri del modello fissati prima dell’addestramento che controllano la complessità

parsnip decision tree

cost_complexity
- Penalizza molti nodi terminali
tree_depth
- Percorso più lungo dalla radice al nodo terminale
min_n
- Minimo di punti nel nodo per poter dividere

Regioni rettangolari del modello ad albero decisionale

Valori di default degli iperparametri

La funzione decision_tree() imposta valori di default

cost_complexity = 0.01
tree_depth = 30
min_n = 20

Potrebbero non essere i migliori per tutti i dataset

Tuning degli iperparametri
- Uso della cross validation per trovare il set ottimale di valori

dt_model <- decision_tree() %>% 
  set_engine('rpart') %>% 
  set_mode('classification')

Etichettare gli iperparametri per il tuning

La funzione tune() del pacchetto tune

Per etichettare gli iperparametri da ottimizzare, impostali a tune() nella specifica parsnip
Crea un modello con parametri di tuning
- Fa capire alle altre funzioni che vanno ottimizzati

dt_tune_model <- decision_tree(cost_complexity = tune(),
                               tree_depth = tune(),
                               min_n = tune()) %>% 
  set_engine('rpart') %>% 
  set_mode('classification')


dt_tune_model

Decision Tree Model Specification (classification)

Main Arguments:
  cost_complexity = tune()
  tree_depth = tune()
  min_n = tune()

Computational engine: rpart

Creare un workflow di tuning

Gli oggetti workflow si aggiornano facilmente

leads_wkfl iniziale
- Feature engineering per lead scoring e modello ad albero con iperparametri di default
Passa leads_wkfl a update_model() e fornisci il nuovo albero con parametri da ottimizzare

leads_tune_wkfl <- leads_wkfl %>% 

  update_model(dt_tune_model)


leads_tune_wkfl

== Workflow ===============
Preprocessor: Recipe
Model: decision_tree()
-- Preprocessor -----------
3 Recipe Steps
* step_corr()
* step_normalize()
* step_dummy()
-- Model ------------------
Decision Tree Model Specification (classification)
Main Arguments: cost_complexity = tune()
                tree_depth = tune()
                min_n = tune()
Computational engine: rpart

Grid search

Metodo più comune per ottimizzare gli iperparametri

Genera una griglia di combinazioni uniche di valori
- Per ogni combinazione, usa la cross validation per stimare le prestazioni
Scegli la combinazione migliore

cost_complexity	tree_depth	min_n
0.001	20	35
0.001	20	15
0.001	35	35
0.001	35	15
0.2	20	35
...	...	...

Identificare gli iperparametri

La funzione parameters() del pacchetto dials

Prende un oggetto modello parsnip
Restituisce una tibble con gli iperparametri etichettati da tune(), se presenti
- Usata per generare griglie di tuning con dials

parameters(dt_tune_model)

Collection of 3 parameters for tuning

  identifier            type     object
cost_complexity  cost_complexity nparam[+]
tree_depth       tree_depth      nparam[+]
min_n            min_n           nparam[+]

Griglia casuale

Generare combinazioni casuali

Questo metodo spesso aumenta le chance di trovare valori ottimali

La funzione grid_random()

Primo argomento: risultato di parameters()
size imposta il numero di combinazioni casuali da generare
- Esegui set.seed() prima di grid_random() per la riproducibilità

set.seed(214)
grid_random(parameters(dt_tune_model),

            size = 5)

# A tibble: 5 x 3
  cost_complexity  tree_depth min_n
            <dbl>      <int>  <int>
1    0.0000000758        14     39
2    0.0243               5     34
3    0.00000443          11      8
4    0.000000600          3      5
5    0.00380              5     36

Salvare una griglia di tuning

Primo passo nel tuning degli iperparametri

Crea e salva una griglia di tuning
dt_grid contiene 5 combinazioni casuali di valori

set.seed(214)
dt_grid <- grid_random(parameters(dt_tune_model),
                       size = 5)


dt_grid

# A tibble: 5 x 3
  cost_complexity  tree_depth min_n
            <dbl>      <int>  <int>
1    0.0000000758        14     39
2    0.0243               5     34
3    0.00000443          11      8
4    0.000000600          3      5
5    0.00380              5     36

Tuning con cross validation

La funzione tune_grid() esegue il tuning degli iperparametri

Argomenti:

workflow o modello parsnip
Oggetto di cross validation, resamples
Griglia di tuning, grid
Funzione metrics opzionale

Restituisce una tibble di risultati

.metrics
- Colonna-lista con i risultati per ogni fold

dt_tuning <- leads_tune_wkfl %>%

             tune_grid(resamples = leads_folds,

                       grid = dt_grid,

                       metrics = leads_metrics)

dt_tuning

# Tuning results
# 10-fold cross-validation using stratification 
# A tibble: 10 x 4
   splits             id       .metrics         ..
   <list>            <chr>      <list>          ..
<split [896/100]>   Fold01   <tibble [15 x 7]>  ..
................    ......   ...............    ..
<split [897/99]>    Fold09   <tibble [15 x 7]>  ..
<split [897/99]>    Fold10   <tibble [15 x 7]>  ..

Esplorare i risultati del tuning

La funzione collect_metrics() fornisce risultati riassunti di default

Media delle metriche stimate su tutti i fold per combinazione

dt_tuning %>% 
  collect_metrics()

# A tibble: 15 x 9
   cost_complexity tree_depth min_n .metric .estimator  mean     n std_err .config
             <dbl>      <int> <int> <chr>   <chr>      <dbl> <int>   <dbl> <chr>  
 1    0.0000000758         14    39 roc_auc binary     0.827    10 0.0147  Model1 
 2    0.0000000758         14    39 sens    binary     0.728    10 0.0277  Model1 
 3    0.0000000758         14    39 spec    binary     0.865    10 0.0156  Model1 
 4    0.0243                5    34 roc_auc binary     0.823    10 0.0147  Model2 
 .    ......               ..    .. ....    ......     .....    .. .....   ......
14    0.00380               5    36 sens    binary     0.747    10 0.0209  Model5 
15    0.00380               5    36 spec    binary     0.858    10 0.0161  Model5

Al tuning!

Modellazione con tidymodels in R