• Entscheidungsbäume?
• Ensembles?
• Gradient Boosting?
• Neural Networks / Deep Learning?

• Datenraum wird schrittweise aufgeteilt
• Jede Aufteilung: Entscheidung mit einer Variablen

• Ensemble Methode
• Verknüpft einzelne ‘schwache’ Modelle zu ‘starkem’ Ensemble
• Gewichtete Summe der Komponenten-Modelle
• Komponenten werden sequentiell trainiert
• Können parallel ausgewertet werden
• Sehr häufig: Entscheidungsbäume als Komponenten-Modelle

Performance von 13 Modellen auf 165 Klassifikationsproblemen

Bild übernommen von: Olson et al. (2018), Data-driven Advice for Applying Machine Learning to Bioinformatics Problems, https://arxiv.org/pdf/1708.05070.pdf

• Ungefähre Nachbildung eines biologischen Gehirns
• Netzwerk aus Neuronen
• Neuronen:
  • Gewichtete Summe aller Eingaben bestimmen
  • Nichtlineare Funktion anwenden (Aktivierungsfunktion)

siehe: https://deepmind.com/blog/article/alphago-zero-starting-scratch

Bild: Donarreiskoffer, Wikimedia, 2004, https://commons.wikimedia.org/wiki/File:Go_board.jpg

siehe: https://deepmind.com/blog/article/AlphaFold-Using-AI-for-scientific-discovery

Bild: B1357M, Wikimedia, 2014, https://commons.wikimedia.org/wiki/File:FADD_based_on_pdb_file_2GF5.gif

• Genauigkeit des Modells
• Sensitivität bzgl. Hyperparameter
• Interpretierbarkeit / Erklärbarkeit
• Bedarf an Zeit / Rechenressourcen
• Parallelisierbarkeit
• Eignung für Aufgabenstellungen / Daten
• Deployment / Implementationen
• Ease-of-use

Take-Home-Message: Vergleiche meist fallabhängig.

• Gesamtmodell in beiden Fällen schwer zu interpretieren
• GB
  • Bei Entscheidungsbäumen können zumindest die ersten Bäume interpretiert werden
• NN
  • u.a.: ‘Attention’ Mechanismen

Auszug aus: Nguyen et al., 2019, Machine Learning and Deep Learning frameworks and libraries for large-scale data mining: a survey

## Spalte "car_name" entfernen
data$car_name <- NULL
## Zeilen mit fehlenden Werten entfernen
data <- data[!is.na(data$horsepower),]
## Seed für Zufallszahlengenerator
set.seed(0)
## Aufteilen in Trainings- und Validierungsdaten
## und umwandeln in Datentyp 'matrix'
indices <- sample(1:nrow(data), 0.7 * nrow(data))
train_data <- as.matrix(data[indices,-1])
train_label <- data[indices,1]
val_data <- as.matrix(data[-indices,-1])
val_label <- data[-indices,1]

• “Übliche” Wahl für derartige Daten wäre GB
• Ausprobieren!

• xgboost: Extreme Gradient Boosting
• Moderne Implementation von Gradient Boosting
• Auch in R verfügbar:

install.packages("xgboost")

library(xgboost)
## Zufallszahlengenerator, Seed
set.seed(1234)
## Trainieren des xgbooost Modells
xgb_model <- xgboost(data=train_data,label=train_label,
                     nrounds = 10,
                     nthread = 1, verbose = 0)

p1 <- xgb.plot.tree(model = xgb_model, trees = 0)
p2 <- xgb.plot.tree(model = xgb_model, trees = 1)

• tensorflow: NN Implementation (von Google)
• keras: ease-of-use Schnittstelle für tensorflow
• Beispiel erfordert Installation von keras in R bzw. python, siehe: https://keras.rstudio.com/reference/install_keras.html

## Skalierung der Eingabedaten zu Intervall [0,1]
scalef <- function(x) (x-min(x)) / (max(x)-min(x)) 

## Keras / tensorflow laden
library(keras)

## Seed für tensorflow setzen (Reproduzierbarkeit)
tensorflow::set_random_seed(1234) 

## Modell initialisieren
model <- keras_model_sequential() 

## Füge dem Modell Schichten hinzu
model %>% 
    layer_dense(units = 20, input_shape = ncol(train_data)) %>% 
    layer_dense(units = 1)

## Kompilieren
model %>% compile(loss = 'mse',
     optimizer = "adam")

## Trainieren
histo <- model %>% fit(x=apply(train_data,2,scalef), 
     y=train_label, 
     verbose=0,
     epochs = 100)

plotly::ggplotly(plot(histo))

## GB RMSE:
sqrt(mean((predict(xgb_model,val_data) - val_label)^2))

## [1] 2.851855

## NN RMSE:
scores = model %>% evaluate(apply(val_data,2,scalef), val_label, verbose = 0)
print(sqrt(scores))

##     loss 
## 4.856659

• Problem:
  • tensorflow wählt zufällig initiale Gewichte
  • Daten sind zufällig aufgeteilt
  • Vielleicht Ergebnis ‘nur Zufall’?
• Lösung:
  • Wiederholungen des Experiments

siehe: experimentReplication.R

load("rmses.RData")
library(plotly)
plot_ly(x = rmse_gb, type = "box", name="GB") %>%
  add_trace(x = rmse_nn, name="NN") %>% 
  layout(xaxis = list(title = "rmse"), yaxis=list(autorange="reversed")) 

• Problem:
  • Parameter beeinflussen die Modelle, z. B.:
  • GB: Anzahl Bäume, Lernrate
  • NN: Anzahl Neuronen, Lernrate
• Lösung:
  • Parameter Tuning

siehe: tuneNN.R, tuneXgboost.R

• nrounds:
  • Anzahl Bäume
  • Default: nicht vorhanden
• max_depth:
  • Tiefe der Bäume
  • Default: 6
• eta:
  • Lernrate
  • Default: 0.3
• colsample_bytree:
  • Anteil auswählbarer Splitfeature
  • Default: 1 (100%)

• units:
  • Anzahl Neuronen in Schicht
  • Default: nicht vorhanden
• batch_size:
  • Anzahl Beobachtungen je Gewichtsupdate
  • Default: 32
• lr:
  • Lernrate (ADAM)
  • Default: 0.001
• activation:
  • Aktivierungsfunktion
  • Default: “linear”

load("resultFilexgboost.RData")
source("plotting.R")
plot_parallel(whichopt(resultpp2),yrange = c(1,5))

load("resultFileNN.RData")
plot_parallel(whichopt(resultpp2),
              yrange = c(1,5))

plot_ly(x = rmse_gb, type = "box", name="GB") %>% 
  add_trace(x = rmse_nn, name="NN") %>% 
  add_trace(x = rmse_gb_tuned, name="GB*") %>% 
  add_trace(x = rmse_nn_tuned, name="NN*") %>% 
  layout(xaxis = list(title = "rmse"), yaxis=list(autorange="reversed"))

• Kommt auf die Anwendung an
• Empfehlung: nehmen was man versteht
• Empirischer Vergleich, Tuning sinnvoll
• Ausserdem: Kombination möglich, z. B.:
  • GB mit einfachen NNs als Komponentenmodelle
  • Oder Feature Extraction mit convolutional NNs, danach GB
  • Oder Kombination aus GB und NN über stacking