Machine Learning

Übersetzt aus dem Englischen mit ChatGPT.

Datum: August 2024
Lesedauer: 15 Minuten

Dies dient als eine Sammlung von Notizen, Beispielen und Tutorials zum maschinellen Lernen. Während ich das Material durchgehe, werde ich meinen Lernprozess hier dokumentieren. Es ist als hilfreiche Ressource für andere gedacht, die ebenfalls maschinelles Lernen lernen. Der Inhalt befindet sich noch in den frühen Entwicklungsphasen und wird in Zukunft weiter ausgebaut.

Beispiel

Besuche mein Google Colab Beispiel (opens in a new tab), um einige der überwachten Lernmodelle in Aktion zu sehen.

Definitionen

Eingabetypen

• Qualitativ: Endliche Anzahl von Kategorien oder Gruppen
  • Nominaldaten: Keine inhärente Reihenfolge
    Z.B. Länder

    Land	One-Hot Encoding
    Schweiz	[1, 0, 0]
    USA	[0, 1, 0]
    Italien	[0, 0, 1]

  • Ordinale Daten: Besitzen eine Reihenfolge
    Z.B. Altersgruppen
    Baby ist näher am Kind als am Erwachsenen
• Quantitativ: Numerische Werte
  • Kontinuierlich: Kann auf einem Kontinuum oder einer Skala gemessen werden
    Z.B. Temperatur
  • Diskret: Ergebnis einer Zählung
    Z.B. Anzahl der Köpfe in einer Reihe von Münzwürfen

Ausgabetypen

• Klassifikation
  • Mehrklassig - z.B. Baseball/Basketball/Fussball
  • Binär - z.B. Spam/nicht Spam
• Regression
  • Kontinuierliche Werte - z.B. Aktienkurs

Verlustfunktionen

Eine Verlustfunktion ist eine mathematische Funktion, die den Unterschied zwischen der vorhergesagten Ausgabe und der tatsächlichen Ausgabe eines Modells misst. Sie wird verwendet, um den Fehler zwischen den erwarteten und den tatsächlichen Ergebnissen zu quantifizieren.
Hier sind drei häufig verwendete Verlustfunktionen.

Mittlerer Absoluter Fehler (MAE)

Je weiter die Vorhersage abweicht, desto grösser der Verlust:

L1 = Σ|y_real - y_predicted|

Mittlerer Quadratfehler (MSE)

Misst den durchschnittlichen quadratischen Unterschied zwischen den vorhergesagten und den tatsächlichen Werten.
Minimale Strafe für kleine Fehler, viel höherer Verlust für grössere Fehler:

L2 = Σ|y_real - y_predicted|²

Kreuzentropie-Verlust

Diese Verlustfunktion wird bei Klassifikationsproblemen verwendet, bei denen die Zielvariable kategorisch ist. Sie misst den Unterschied zwischen den vorhergesagten Wahrscheinlichkeiten und den tatsächlichen Wahrscheinlichkeiten jeder Klasse. Die Formel lautet:

L3 = - Σ(y_true * log(y_predicted) + (1 - y_true) * log(1 - y_predicted))

Modell

Grundkonzept (Entscheidungsbaum)

Ein realer Immobilienmakler könnte sagen, dass er Häuser intuitiv schätzt. Bei genauerer Betrachtung erkennt man jedoch, dass er Preismuster erkennt und diese verwendet, um neue Häuser zu schätzen.
Maschinelles Lernen funktioniert genauso.

Der Entscheidungsbaum ist eines der vielen Modelle.
Er ist möglicherweise nicht so genau in der Vorhersage wie andere Modelle, aber leicht verständlich und der Baustein für einige der besten Modelle in der Datenwissenschaft.

Dieses Beispiel gruppiert Häuser in zwei Gruppen (mit Preisvorhersagen).

    -----------------------> $1.100.000
  /
 / 3 oder mehr
* Schlafzimmer
 \ weniger als 3
  \
    -----------------------> $750.000

Trainingsdaten werden dann verwendet, um das Modell zu trainieren, indem es so angepasst wird, dass die Aufteilungen und Endpreise so optimal wie möglich sind.
Danach kann es verwendet werden, um die Preise neuer Daten vorherzusagen.

Die Ergebnisse des oben gezeigten Baums wären eher vage.
Durch die Verwendung tieferer Bäume (mit mehr Aufteilungen) können mehr Faktoren erfasst werden.

								  ----> $1.300.000
								/
                               / ja
      ----------------------- * grösser als 11.500 Quadratfuss Grundstücksgrösse
    /                          \ nein
   /                            \
  /                               ----> $750.000
 / 3 oder mehr
* Schlafzimmer
 \ weniger als 3
  \                               ----> $850.000
   \                            /
    \						   / ja
	  ----------------------- * grösser als 8.500 Quadratfuss Grundstücksgrösse
						       \ nein
							    \
								  ----> $400.000

Der Punkt am unteren Ende, an dem die Vorhersage getroffen wird, wird als Blatt bezeichnet.

Pandas

Pandas ist das Hauptwerkzeug für Data Scientists, um Daten zu erkunden und zu manipulieren. Pandas wird oft mit pd abgekürzt.

import pandas as pd

Die Bibliothek bietet leistungsstarke Methoden für fast alles, was mit Daten gemacht werden muss.
Der wichtigste Teil ist das DataFrame.

Ausgebe Datenzusammenfassung

data_src = '../input/some-data.csv'
data = pd.read_csv(data_src)
data.describe()

Eine solche Tabelle kann wie folgt interpretiert werden:

Ausgabe der ersten 5 Zeilen

data.head()

Prediction Target

Mit der Punktnotation kannst du das Vorhersageziel auswählen (die Spalte, die du vorhersagen möchtest).
Dies wird nach Konvention als y bezeichnet.

y = data.Price

Auswahl von Features

Man könnte alle Spalten, ausser dem Target, als Features verwenden. Aber manchmal ist es besser, mit weniger Features zu arbeiten.
Diese können mit einer Feature Liste ausgewählt werden.

features = ['Rooms', 'Bathroom', 'Landsize', 'Lattitude', 'Longtitude']
X = data[features]

Modell erstellen (Decision Tree)

scikit-learn ist eine beliebte Bibliothek zum Modellieren von Daten (die typischerweise in DataFrames gespeichert sind).
Folge den untenstehenden Schritten, um ein Modell zu erstellen.

1. Definiere den Modelltyp und seine Parameter
2. Trainiere das Modell, indem du Muster aus den Daten erfasst
3. Vorhersage der Ergebnisse

from sklearn.tree import DecisionTreeRegressor
 
# 1
model = DecisionTreeRegressor(random_state=1) # random_state for consistent outcome across calls
 
# 2
model.fit(X, y)
 
# 3
prediction = model.predict(X)

Modell Validieren

Der vierte Schritt besteht darin, das Modell zu bewerten, indem die Vorhersagegenauigkeit überprüft wird.
Der Mittlere Absolute Fehler (MAE) ist eine von vielen Metriken, um die Qualität eines Modells zu bestimmen.
Die Formel ist einfach: Fehler = tatsächlich − vorhergesagt

Diese Metrik zeigt also, wie weit die Vorhersagen im Durchschnitt abweichen.

# 4
mean_absolute_error(y, prediction)

Data Splitting

Ein Modell sollte nicht mit allen Daten trainiert werden, da man so nicht weiss, wie es mit unbekannten Daten abschneidet. Es könnte auf den Trainingsdaten hervorragend abschneiden, weil es diese immer wieder gesehen hat, aber falsche Annahmen bei neuen Informationen treffen.
Um zu bewerten, wie gut das Modell verallgemeinern kann, wird es normalerweise in 3 Datensätze unterteilt:

• Training: Das Modell wird verbessert, indem der Fehler berechnet und daraus gelernt wird
• Validierung: Dient als Realitätscheck, um zu sehen, ob das Modell mit unbekannten Daten umgehen kann. Der Fehler wird nicht wieder ins Modell zurückgeführt.
• Test: Letzter Check, wie das endgültig gewählte Modell basierend auf dem Fehler abschneidet

So kann die Datenaufteilung in zwei Teile erfolgen:

from sklearn.model_selection import train_test_split
 
 
train_X, val_X, train_y, val_y = train_test_split(X, y, random_state = 0)
 
model = DecisionTreeRegressor()
 
# fit using training data
model.fit(train_X, train_y)
 
# predict validation data
val_predictions = model.predict(val_X)
print(mean_absolute_error(val_y, val_predictions))

Underfitting and Overfitting

Es gibt zwei Probleme, die die Genauigkeit der zukünftigen Vorhersagen eines Modells verringern können.

• Overfitting: Zu genau auf den Trainingssatz abgestimmt, indem Muster erfasst werden, die in der Zukunft nicht wieder auftreten.
• Underfitting: Relevante Muster werden nicht erfasst.

Der optimale Punkt in einem Entscheidungsbaum kann durch das Testen mit unterschiedlichen Tiefen gefunden werden:

from sklearn.metrics import mean_absolute_error
from sklearn.tree import DecisionTreeRegressor
 
def get_mae(max_leaf_nodes, train_X, val_X, train_y, val_y):
    model = DecisionTreeRegressor(max_leaf_nodes=max_leaf_nodes, random_state=0)
    model.fit(train_X, train_y)
    preds_val = model.predict(val_X)
    mae = mean_absolute_error(val_y, preds_val)
    return(mae)
 
for max_leaf_nodes in [10, 100, 1000]:
    my_mae = get_mae(max_leaf_nodes, train_X, val_X, train_y, val_y)
    print("Max leaf nodes: %d  \t\t Mean Absolute Error:  %d" %(max_leaf_nodes, my_mae))

Random Forest

Entscheidungsbäume schneiden oft nicht so gut ab aufgrund von Unteranpassung oder Überanpassung. Andere Modelle haben dasselbe Problem, aber viele davon beinhalten Konzepte, die die Leistung verbessern können. Ein Beispiel dafür ist der Random Forest.

Ein Random Forest-Modell verwendet viele Bäume und mittelt deren Vorhersagen, um eine viel genauere Vorhersage zu treffen, als es ein einzelner Baum könnte.

from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_absolute_error
 
model = RandomForestRegressor(random_state=1)
model.fit(train_X, train_y)
melb_preds = model.predict(val_X)
print(mean_absolute_error(val_y, melb_preds))

Wahl des Modells

Mit einer Funktion kannst du verschiedene Modelle ausprobieren.

from sklearn.metrics import mean_absolute_error
 
def score_model(model, X_t=X_train, X_v=X_valid, y_t=y_train, y_v=y_valid):
    model.fit(X_t, y_t)
    preds = model.predict(X_v)
    return mean_absolute_error(y_v, preds)
 
for i in range(0, len(models)):
    mae = score_model(models[i])
    print("Model %d MAE: %d" % (i+1, mae))

Fehlende Werte

Es gibt mehrere Ansätze, um mit fehlenden Werten umzugehen.

Beispiele

Vergiss nicht, sowohl den Trainings- als auch den Validierungsdatensatz/DataFrame immer anzupassen.

Löschen

# get names of cols with missing values
cols_with_missing = [col for col in X_train.columns
                     if X_train[col].isnull().any()]
 
# drop cols those
reduced_X_train = X_train.drop(cols_with_missing, axis=1)
reduced_X_valid = X_valid.drop(cols_with_missing, axis=1)
 
print("Drop MAE:")
print(score_dataset(reduced_X_train, reduced_X_valid, y_train, y_valid))

Imputation

from sklearn.impute import SimpleImputer
 
# imputation
my_imputer = SimpleImputer()
imputed_X_train = pd.DataFrame(my_imputer.fit_transform(X_train))
imputed_X_valid = pd.DataFrame(my_imputer.transform(X_valid))
 
# readd col names (imputation removed them)
imputed_X_train.columns = X_train.columns
imputed_X_valid.columns = X_valid.columns
 
print("Imputation MAE:")
print(score_dataset(imputed_X_train, imputed_X_valid, y_train, y_valid))

Imputation mit Erweiterung

# make copy to avoid changing original data (when imputing)
X_train_plus = X_train.copy()
X_valid_plus = X_valid.copy()
 
# make new cols indicating what will be imputed
for col in cols_with_missing:
    X_train_plus[col + '_was_missing'] = X_train_plus[col].isnull()
    X_valid_plus[col + '_was_missing'] = X_valid_plus[col].isnull()
 
# imputation
my_imputer = SimpleImputer()
imputed_X_train_plus = pd.DataFrame(my_imputer.fit_transform(X_train_plus))
imputed_X_valid_plus = pd.DataFrame(my_imputer.transform(X_valid_plus))
 
# readd col names (imputation removed them)
imputed_X_train_plus.columns = X_train_plus.columns
imputed_X_valid_plus.columns = X_valid_plus.columns
 
print("Extensive Imputation MAE:")
print(score_dataset(imputed_X_train_plus, imputed_X_valid_plus, y_train, y_valid))

Kategorische Variablen

Kategorische Variablen sind Enums wie "Schlecht, OK, Gut oder Sehr Gut".
Es gibt drei Ansätze, um mit ihnen umzugehen.

Löschen

Das Entfernen der Spalten aus dem Datensatz ist vielleicht einfacher, funktioniert jedoch nicht gut, wenn die Spalten nützliche Informationen enthalten.

drop_X_train = X_train.select_dtypes(exclude=['object'])
drop_X_valid = X_valid.select_dtypes(exclude=['object'])
 
print("Drop MAE:")
print(score_dataset(drop_X_train, drop_X_valid, y_train, y_valid))

Ordinal Encoding

Diese Kodierung ersetzt jeden eindeutigen Wert durch eine andere Ganzzahl, was ein nützlicher Ansatz für ordinale Variablen ist:
Schlecht (0) < OK (1) < Gut (2) < Sehr Gut (3)

from sklearn.preprocessing import OrdinalEncoder
 
# copy to avoid changing original data
label_X_train = X_train.copy()
label_X_valid = X_valid.copy()
 
# apply ordinal encoder to each col with categorical data
ordinal_encoder = OrdinalEncoder()
label_X_train[object_cols] = ordinal_encoder.fit_transform(X_train[object_cols])
label_X_valid[object_cols] = ordinal_encoder.transform(X_valid[object_cols])
 
print("Ordinal MAE:")
print(score_dataset(label_X_train, label_X_valid, y_train, y_valid))

One-Hot Encoding

One-Hot-Kodierung erstellt neue Spalten, um jeden einzigartigen Wert in den Originaldaten darzustellen. Diese Kodierung erzielt in der Regel die besten Ergebnisse.

Vorher:

Nachher:

from sklearn.preprocessing import OneHotEncoder
 
# apply one-hot encoder to each col with categorical data
OH_encoder = OneHotEncoder(handle_unknown='ignore', sparse=False)
OH_cols_train = pd.DataFrame(OH_encoder.fit_transform(X_train[object_cols]))
OH_cols_valid = pd.DataFrame(OH_encoder.transform(X_valid[object_cols]))
 
# readd index (one-hot encoding removed it)
OH_cols_train.index = X_train.index
OH_cols_valid.index = X_valid.index
 
# remove categorical cols (will replace with one-hot encoding)
num_X_train = X_train.drop(object_cols, axis=1)
num_X_valid = X_valid.drop(object_cols, axis=1)
 
# add one-hot encoded cols to numerical features
OH_X_train = pd.concat([num_X_train, OH_cols_train], axis=1)
OH_X_valid = pd.concat([num_X_valid, OH_cols_valid], axis=1)
 
# ensure all col have string type
OH_X_train.columns = OH_X_train.columns.astype(str)
OH_X_valid.columns = OH_X_valid.columns.astype(str)
 
print("One-Hote Encoding MAE:")
print(score_dataset(OH_X_train, OH_X_valid, y_train, y_valid))

Pipelines

Pipelines sind eine Möglichkeit, mehrere Datenumwandlungs- und Modellschritte miteinander zu verknüpfen.
Die Daten fliessen durch die Pipeline und die Schritte werden in der Reihenfolge angewendet.

Preprocessing

ColumnTransformer ist eine Klasse, die verwendet wird, um Vorverarbeitungsschritte zu bündeln.
Das folgende Beispiel imputiert fehlende Werte in numerischen Daten und wendet One-Hot-Kodierung auf kategoriale Daten an.

from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder
 
# preprocessing for numerical data
numerical_transformer = SimpleImputer(strategy='constant')
 
# preprocessing for categorical data
categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('onehot', OneHotEncoder(handle_unknown='ignore'))
])
 
# bundle preprocessing for numerical and categorical data
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numerical_transformer, numerical_cols),
        ('cat', categorical_transformer, categorical_cols)
    ])

Modell

Natürlich benötigst du ein Modell zum Trainieren.

from sklearn.ensemble import RandomForestRegressor
model = RandomForestRegressor(n_estimators=100, random_state=0)

Erstelle und bewerte die Pipeline

Dann wird die Pipeline-Klasse verwendet, um eine Pipeline zu definieren. Mit dieser Pipeline können die Vorverarbeitung und das Training in einer einzigen Codezeile durchgeführt werden, was sie sehr lesbar und einfach zu verwenden macht.

from sklearn.metrics import mean_absolute_error
 
# bundle preprocessing and modeling code in a pipeline
my_pipeline = Pipeline(steps=[('preprocessor', preprocessor),
                              ('model', model)
                             ])
 
# preprocessing of training data, fit model
my_pipeline.fit(X_train, y_train)
 
# preprocessing of validation data, get predictions
preds = my_pipeline.predict(X_valid)
 
# evaluate the model
score = mean_absolute_error(y_valid, preds)
print('MAE:', score)

Cross-Validation

Kreuzvalidierung ist eine Technik, bei der der Modellierungsprozess auf verschiedenen Teilmengen der Daten wiederholt wird.
Die Daten werden in mehrere Teilmengen unterteilt, die als "Folds" bezeichnet werden. Zum Beispiel 4 Folds, die jeweils 25% der Gesamtdaten enthalten.
Jeder Fold wird dann einmal als Validierung und die anderen 3 Mal als Trainingssatz verwendet.

Vorteil: Genaue Messung der Modellqualität
Nachteil: Dauert lange

Verwende es für kleine Datensätze, die nur ein paar Minuten oder weniger benötigen. Wenn du bereits genügend Daten hast, gibt es keinen Bedarf, einen Teil davon erneut zu verwenden.

from sklearn.ensemble import RandomForestRegressor
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.model_selection import cross_val_score
 
my_pipeline = Pipeline(steps=[('preprocessor', SimpleImputer()),
                              ('model', RandomForestRegressor(n_estimators=50,
                                                              random_state=0))
                             ])
 
# -1 since sklearn calculates negative MAE
scores = -1 * cross_val_score(my_pipeline, X, y,
                              cv=5,
                              scoring='neg_mean_absolute_error')
 
print("MAE:\n", scores)

XGBoost

Gradient Boosting ist ein sehr erfolgreicher Algorithmus. Diese Methode durchläuft Zyklen und fügt iterativ Modelle zu einem Ensemble hinzu.
Der Zyklus sieht folgendermassen aus:

1. Ein Ensemble von Modellen generiert Vorhersagen für den Datensatz.
2. Die Verlustfunktion wird basierend auf diesen Vorhersagen berechnet.
3. Ein neues Modell wird basierend auf der Verlustfunktion trainiert.
4. Dieses neue Modell wird zum Ensemble hinzugefügt.
5. Der Prozess wird wiederholt.

from xgboost import XGBRegressor
from sklearn.metrics import mean_absolute_error
 
model = XGBRegressor()
model.fit(X_train, y_train)
 
predictions = model.predict(X_valid)
print("MAE: " + str(mean_absolute_error(predictions, y_valid)))

Parameter

n_estimators

Definiert die Anzahl der Zyklen (achte auf under-/overfitting).

model = XGBRegressor(n_estimators=500)

(Üblicherweise Werte von 100 bis 1000.)

early_stopping_rounds

Ermöglicht es dem Modell, den idealen Wert für n_estimators zu finden, indem es frühzeitig stoppt, wenn die Scores nicht mehr besser werden.

model.fit(X_train, y_train,
             early_stopping_rounds=10,
             eval_set=[(X_valid, y_valid)],
             verbose=False)

Dies kann mit einem höheren n_estimators-Wert kombiniert werden, um die optimale Anzahl an Zyklen zu finden.

learning_rate

Die Vorhersagen jedes Modells werden nicht einfach summiert, sondern mit einer kleinen Zahl multipliziert, die als Lernrate bezeichnet wird.
Daher hat jeder Baum einen kleineren Einfluss auf die Vorhersagen, was helfen kann, Überanpassung (Overfitting) zu verhindern.

Kleine Lernraten erzeugen genauere Modelle, aber haben längere Trainingszeiten aufgrund der höheren Anzahl an Iterationen.

model = XGBRegressor(n_estimators=500, learning_rate=0.05) # default = 0.1

n_jobs

Dieser Parameter hat keinen Einfluss auf das resultierende Modell, kann jedoch verwendet werden, um den Trainingsprozess zu beschleunigen.
Bei grossen Daten kann die Laufzeit durch die Verwendung von Parallelverarbeitung verringert werden. Bei kleinen Datensätzen hat dies keinen Einfluss.

model = XGBRegressor(n_estimators=500, learning_rate=0.05, n_jobs=4)

Datenleckage

Es kann passieren, dass das Modell auf den Trainings- und sogar Validierungsdaten gut abschneidet, aber in der Produktion schlecht.
Dies könnte durch Datenleckage verursacht werden. Dies passiert, wenn der Trainingssatz Informationen über das Ziel enthält, die bei der Verwendung des Modells auf realen Daten nicht verfügbar sind.

Modelltypen

Überwachte Lernmodelle können in zwei Haupttypen unterteilt werden:

• Klassifikation: Kategoriale Ausgaben - Mehrklassen- oder Binärklassifikation
• Regression: Kontinuierliche Ausgaben - Werte

Klassifikation

k-Nearest Neighbors (kNN)

Annahme: Objekte, die nahe beieinander liegen, sind ähnlich.

Kategorisiert einen Datenpunkt basierend auf den nächsten Nachbarn - unter Verwendung von Distanzfunktionen wie euklidische Distanz, City-Block-Distanz und mehr.

By Paolo Bonfini - Own work, CC BY-SA 4.0, https://commons.wikimedia.org/w/index.php?curid=150465667 (opens in a new tab)

Naive Bayes

Annahme: Ein Merkmal einer Klasse ist unabhängig von anderen Merkmalen.

Klassifiziert basierend auf der höchsten Wahrscheinlichkeit, zu einer Klasse zu gehören, indem die Wahrscheinlichkeiten aller Merkmale berechnet werden.

By Sharpr for svg version. original work by kakau in a png - Own work, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=44059691 (opens in a new tab)

Weitere

• Discriminant Analysis

Regression

Linear Regression

Annahme: Der Zielwert ist eine lineare Kombination der Merkmale.

Verwendet eine lineare Funktion zur Vorhersage.

By Krishnavedala - Own work, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=15462765 (opens in a new tab)

Weitere

• Nonlinear Regression
• Generalized Linear Model
• Gaussian Process Regression (GPR)

Klassifikation oder Regression

Support Vector Machine

Annahme: 2 Klassen können durch einen Trenner separiert werden.

Das Dataset wird durch eine Hyperfläche geteilt, die die Klassen linear trennen soll und den grössten Abstand zwischen ihnen hat.

By User:ZackWeinberg, based on PNG version by User:Cyc - This file was derived from: Svm separating hyperplanes.png, CC BY-SA 3.0, https://commons.wikimedia.org/w/index.php?curid=22877598 (opens in a new tab)

Neuronales Netzwerk

Annahme: Eine Struktur, die vom menschlichen Gehirn inspiriert ist, kann die Eingaben mit den gewünschten Vorhersagen in Beziehung setzen.

Ein Netzwerk aus miteinander verbundenen und geschichteten Knoten/Neuronen wird durch iterative Modifikation der Verbindungsstärken trainiert.

By Mikael Häggström, M.D. Author info- Reusing images- Conflicts of interest:NoneMikael Häggström, M.D. - Own workReference: Ferrie, C., & Kaiser, S. (2019) Neural Networks for Babies, Sourcebooks ISBN: 1492671207., CC0, https://commons.wikimedia.org/w/index.php?curid=137892223 (opens in a new tab)

Weitere

• Decision Tree
• Ensemble Trees
• Generalized Additive Model (GAM)