Demo-PY4: Predictive Maintenance mit scikit-learn
Demo-PY4 zeigt, wie eine Ausfall-Klassifikation im Rahmen eines Predictive Maintenance-Szenarios mit Hilfe des Entscheidungsbaum-Verfahrens der Python-Bibliothek scikit-learn für Maschinelles Lernen durchgeführt wird. Wir verwenden denselben Automotive-Datensatz, der in allen Demos des Predictive Maintenance-Zyklus verwendet wird: eine csv-Datei automotive_data.csv mit 23 Merkmalen (Kühlmitteltemperatur, Drosselklappenstellung, ...) und einer Zielvariablen: Ausfall. Die Fragestellung lautet: "Bei welcher Kombination von Merkmalen tritt ein Ausfall ein?".
Motivation
Bei der Durchführung der Datenanalyse im Rahmen der
Predictive Maintenance
sind Entscheidungsbäume ein wichtiges Modell, das zur Vorhersage von Ausfällen eingesetzt werden kann.
Die Voraussetzung für den Einsatz eines Entscheidungsbaums als Klassifikationsmodell ist das Vorliegen von
Vergangenheitsdaten, bei denen bekannt ist, bei welcher Merkmalskombination ein Ausfall eingetreten ist (oder nicht).
In dieser Demo verwenden wir die Funktionen der Python-Bibliothek scikit-learn,
sowie graphviz für die Visualisierung des Entscheidungsbaums,
und setzen als Entwicklungs- und Laufzeitumgebung Jupyter Notebook ein.
Warum scikit-learn?
scikit-learn ist zusammen mit Pandas, Keras und Tensorflow eine der wichtigen Python-Bibliotheken für Maschinelles Lernen und bietet Unterstützung für die üblichen Schritte des Überwachten und Unüberwachten Lernens: Datenvorbereitung, Trainingsphase und Modellevaluation, ebenso leistungsstarke Algorithmen für Klassifikations-, Regressions- und Clustering-Probleme, siehe die Dokumentation der sklearn-Funktionen.
Warum graphviz?
Graphviz ist ein Open-Source-Programmpaket zur Visualisierung von Graphen, das in scikit-learn mittels der Funktion export_graphviz() für die Visualisierung von Entscheidungsbäumen verwendet wird. Die mit graphviz erzeugten Entscheidungsbäume können in verschiedenen Bildformaten gespeichert werden, insbesondere auch im SVG-Format, und haben damit eine bessere Qualität als die Default-Visualisierung mit der sklearn-Funktion plot_tree().
Übersicht
Demo-PY4 ist in 8 Abschnitte gegliedert. Zunächst wird der Automobil-Datensatz beschrieben und die Fragestellung formuliert, die mit der Datenanalyse beantwortet werden soll. Danach wird die Funktionsweise von Entscheidungsbäumen kurz vorgestellt, sowie die Erstellung des Jupyter Notebooks und Vorbereitung benötigter Bibliotheken. In den folgenden Abschnitten erfolgt die Erstellung eines Entscheidungsbaum-Vorhersagemodells, danach die Visualisierung mit graphviz, zuletzt die Ermittlung von Performance-Kennzahlen.
1 Der Automotive-Datensatz
Der Automobildatensatz ist eine csv-Datei und besteht aus insgesamt 136 Beobachtungen von 7 Motoren. Als Trennzeichen für die Spalten wird das Semikolon verwendet.
Jede Beobachtung enthält den Vorhersagewert Ausfall, mit angenommenen Werten ja/nein, die Messungsnummer, und Sensorwerte zu insgesamt 22 Merkmalen. Für den 7. Motor liegen nur 16 Messungen vor. Die erhobenen Merkmalswerte stammen aus Temperatur- und Druckmessungen sowie Mengenangaben zum Kraftstoff und zu Abgasdämpfen, die an verschiedenen Stellen im Motor erfasst wurden. Weiterhin enthält der Datensatz acht Merkmale zu den Lambdasonden, die an jeweils einem Zylinder im Motor Messwerte liefern und in 2 Bänke unterteilt sind (d.h. das Merkmal Lambdasonde32 gibt den Sensorwert vom dritten Zylinder innerhalb der zweiten Bank an). Bis auf die Katalysatortemperatur (Merkmalsname: KatalysatortempKategorie, Werte: normal/hoch) liegen für alle Merkmale numerische Messungen vor.
2 Die Fragestellung
Uns interessiert, welche Merkmalskombinationen, d.h. welches Zusammenspiel der Sensorwerte, zu einem Ausfall des Motors führen. Die Frage, die der Entscheidungsbaum beantworten soll, lautet also: Welche Kombination von Merkmalen wird zu einem Ausfall führen? Werden alle Merkmale einen Einfluss auf den Ausfall haben und falls nein, mit welchem Gewicht werden welche Merkmale einen Ausfall bewirken?
3 Ablauf der Datenanalyse
Die Datenanalyse für die Predictive Maintenance läuft in fünf Schritten ab, wobei einige der Teilschritte je nach Daten und ausgewähltem Modell auch entfallen können. Z.B. ist bei einem Entscheidungsbaum-Modell keine Normalisierung der Daten erforderlich.
- Schritt 1. Datenvorbereitung: Der Datensatz wird in Trainings- und Testdaten zerlegt, die Zielvariable wird festgelegt und die Daten
werden bereinigt, d.h. je nach Datenlage normalisiert und transformiert, bei fehlenden Werte interpoliert und durch Algorithmen werden
Ausreißer erkannt und behandelt.
- Schritt 2. Modell definieren: Gemäß den Daten wird ein passendes Modell gewählt, dies kann ein Entscheidungsbaum-Modell für
Klassifikation oder Regression sein, oder eine Nächste Nachbarn-Klassifikation, dies hängt von der Fragestellung ab.
- Schritt 3. Modell trainieren: Mit den Trainingsdaten wird das Modell erstellt, d.h. die Parameter des Modells geschätzt, z.B. die Verzweigungen und Blätter eines Entscheidungsbaums, oder die Parameter als Kleinste-Quadrate-Schätzer in einem Regressionsmodell.
- Schritt 4. Modell validieren: Das Modell wird auf die Testdaten angewendet um eine Vorhersage zu erhalten, der Vergleich
der Vorhersagen mit den bekannten Werten der Zielvariablen liefert die
Performance-Kennzahlen, die den Testfehler beschreiben, und angeben wie gut ein
Modell ist.
- Schritt 5. Modell verwenden: Durch Anwendung des Modells auf neue Beobachtungen, bei denen die Werte der Zielvariablen unbekannt sind, Vorhersagen getätigt.
4 Was ist ein Entscheidungsbaum?
Ein Entscheidungsbaum ist ein Klassifikationsmodell, mit dessen Hilfe eine Ja-Nein Fragestellung beantwortet werden kann. In einem Predictive Maintenance-Szenario soll z.B. vorhergesagt werden, ob bei einer bestimmten Kombination von Messungen ein Ausfall eintritt oder nicht. Diese "Vorhersage" ist strenggenommen eine Klassifikation, also eine Funktion / Zuordnung, die die Merkmale einer Beobachtung auf die korrekten Zustände ("Ausfall" oder "Kein Ausfall") abbildet. Das Modell entsteht, indem die Datentabelle, die bei der Datenerhebung erfasst wurde, um eine Spalte ergänzt wird, die Zielvariable genannt wird und die die Bewertung des Zustands enthält. Für die Vergangenheitsdaten ist die Bewertung bekannt, für neue Daten wird die Bewertung durch das Modell vorhergesagt.
Ein Entscheidungsbaum besteht aus einer Wurzel, Knoten und Blättern, wobei jeder Knoten eine Entscheidungsregel und jedes Blatt eine Antwort auf die Fragestellung darstellt. Um eine Klassifikation eines einzelnen Datenobjektes abzulesen, geht man vom Wurzelknoten entlang des Baumes abwärts. Bei jedem Knoten wird ein Merkmal abgefragt und eine Entscheidung über die Auswahl des folgenden Knoten getroffen. Dies wird so lange fortgesetzt, bis man ein Blatt erreicht. Das Blatt entspricht der Klassifikation.
Mini-Beispiel
Zur Veranschaulichung betrachten wir einen Datensatz mit Sensor-Messwerten mit nur zwei Merkmalen: Temperatur und Druck und einer Zielvariablen: Ausfall.
Der Entscheidungsbaum für das Mini-Beispiel gibt eine Antwort auf die Frage,
bei welcher Kombination von Werten für die Merkmale temp und druck das Gerät ausfallen wird.
Datensatz mit Zielvariable
Die Zeilen 1 bis 4 enthalten die Vergangenheitsdaten mit bekannter Bewertung der Zielvariablen. Zeile 5 enthält eine neue Beobachtung, für die auf Basis des Entscheidungsbaums der Ausfall vorhergesagt wird.
Entscheidungsbaum
Wenn die Temperatur hoch und der Druck hoch ist, wird ein Ausfall vorhergesagt. Wenn die Temperatur normal ist, wird kein Ausfall eintreten.
Wie entsteht der Entscheidungsbaum?
Die genaue Form des Entscheidungsbaums entsteht durch den Trainingsprozess des überwachten Lernens.
Die Input-Daten werden in Trainingsdaten und Testdaten unterteilt.
Auf Basis der Trainingsdaten wird mittels eines passenden Algorithmus (CART, C4.5 oder ID3) der Entscheidungsbaum erstellt,
dessen Güte mit Hilfe von Performance-Kennzahlen
(z.B. Vertrauenswahrscheinlichkeit, Genauigkeit, Trefferquote) ermittelt wird.
Der Trainingsprozess wird solange wiederholt, bis das Modell eine gewünschte Performance erreicht.
Danach kann es für die Vorhersage auf neuen Datensätzen verwendet werden.
5 Jupyter Notebook erstellen
Für die Datenverwaltung, die Erstellung des Entscheidungsbaum-Vorhersagemodells und die Vorhersage selber wird ein Jupyter Notebook verwendet. Über Programme öffnen wir die Jupyter Notebook-Anwendung und erzeugen mit Hilfe des Menüpunkts "New" ein neues Python3-Notizbuch mit dem Namen elab2go-Demo-PY4.
Die Details der Verwendung von Jupyter Notebooks sind im Abschnitt Jupyter Notebooks verwenden beschrieben. Weitere Voraussetzungen wie Grundlagen der Programmiersprache Python und der Einstieg in die Python-Bibliothek Pandas werden in Demo-PY1: Python-Tutorial und in Demo-PY2: Datenverwaltung mit Pandas genauer beschrieben.
Importieren der benötigten Programmbibliotheken
In der ersten Codezelle des Jupyter Notebooks importieren wir die benötigten Programmbibliotheken: Numpy, Pandas, sowie aus sklearn das Paket metrics und die Funktionen DecisionTreeClassifier, export_graphviz. Numpy wird für die Speicherung der Daten in Arrays benötigt, Pandas für die Datenaufbereitung mit DataFrames. Das sklearn-Packet metrics enthält Funktionen, mit denen man die Güte eines Vorhersagemodells bewerten kann.
In Python kann man mit Hilfe der import-Anweisung entweder eine komplette Programmbibliothek importieren, oder nur einzelne Funktionen der Programmbibliothek (from-import-Anweisung). Beim Import werden für die jeweiligen Bibliotheken oder Funktionen Alias-Namen vergeben: für Numpy vergeben wird den Alias np, für Pandas vergeben wir den Alias pd.
import numpy as np
import pandas as pd
import graphviz as gv
from sklearn import metrics
from sklearn.tree import DecisionTreeClassifier, export_graphviz
6 Das Entscheidungsbaum-Vorhersagemodell
Als Nächstes wird in 5 Codezellen ein Entscheidungsbaum-Vorhersagemodell erstellt, an dem wir die korrekte Abfolge der Schritte (1. Daten einlesen, 2. Merkmale und Zielvariable extrahieren, 3. Aufteilen der Daten in Trainings- und Testdaten, 4. Vorhersagemodell erstellen, 5. Vorhersagemodell visualisieren) testen.
6-1 Datenvorbereitung: Daten einlesen
In der ersten Codezelle werden Daten, die in der csv-Datei automotive_data.csv gespeichert sind, mit Hilfe der Funktion read_csv() der Pandas-Bibliothek eingelesen, siehe auch Demo-PY2: Datenverwaltung mit Pandas.
Python-Code:Ausgabe:# Lese CSV-Datei ein
file = 'automotive_data.csv'
COLS = np.arange(0,22,1).tolist()
df = pd.read_csv(file, header=0, sep = ";", index_col=0, usecols=COLS)
# Zeige einen Auszug der Daten zur Kontrolle an
print('PANDAS DATAFRAME:');
df.iloc[0:5,0:7]
- Zeile 1: Der Trainigsdatensatz befindet sich in demselben Ordner wie unser Skript, daher muss der Name der Datei keine Pfadangaben enthalten.
- Zeile 3: Erzeuge eine Liste mit Spaltennummern. Mit Hilfe der numpy-Funktion arange werden die Werte [0,1,2,...21] erzeugt: das sind diejenigen Spalten der csv-Datei, die in ein Pandas DataFrame importiert und als Merkmalsspalten verwendet werden sollen.
- Zeile 4: Lese CSV-Datei in ein Pandas DataFrame ein. Die Funktion read_csv() erhält als ersten Parameter den Namen der
einzulesenden Datei. Die weiteren Parameter sind Optionen, die den Import steuern.
header=0 bedeutet, dass die erste Zeile der CSV-Datei Spaltenüberschriften enthält.
index_col=0 bedeutet, dass die erste Spalte die Pandas-Indexspalte sein wird, die die Zeilenüberschriften enthält.
sep = ";" bedeutet, dass ein Semikolon als Trennzeichen (engl. separator) verwendet wird. - Zeile 5-7: Gebe einen Teil der Daten zur Kontrolle aus.
6-2 Datenvorbereitung: Merkmale und Zielvariable extrahieren
In der zweiten Codezelle werden die Merkmalswerte zunächst mit iloc in ein neues DataFrame extrahiert und dann mit der Pandas-Methode to_numpy() in ein NumPy-Array x konvertiert. Anschließend wird die Spalte "Ausfall" als Zielvariable in ein Array y extrahiert.
Python-Code:Ausgabe:# Extrahiere Merkmale in ein NumPy-Array x
merkmale = df.iloc[:,1:];
x = merkmale.to_numpy()
print("Merkmale x:\n" + str(x))
# Extrahiere Zielvariable in ein Numpy-Array y
y = df[['Ausfall']]
y = y.values
# Gebe drei Werte zur Kontrolle aus
print("Zielvariable y:\n" + str(y[1:4]))
6-3 Datenvorbereitung: Aufteilen der Daten in Trainings- und Testdaten
In der vierten Codezelle werden die in den Arrays x und y gespeicherten Daten in einen Trainings- und einen Testdatensatz aufgeteilt.
Der Trainingsdatensatz wird verwendet, um das Vorhersagemodell zu erstellen und der Testdatensatz wird verwendet, um das Modell zu validieren.
Die Methode train_test_split() erhält die Arrays x und y als Eingabeparameter und gibt vier Arrays zurück:
X_train: Trainingsdaten (nur Merkmale), X_test: Testdaten (nur Merkmale)
y_train: Trainingsdaten (Zielvariable), y_test: Testdaten (Zielvariable)
Der Parameter test_size steuert die Größe des Test-Datensatzes, hier: 30%.
Ausgabe:from sklearn.model_selection import train_test_split
# 70% Trainingsdaten und 30% Testdaten
X_train, X_test, y_train, y_test =
train_test_split(x, y, test_size=0.3, random_state=1)
print("X_train (Erste drei Zeilen):");
print(X_train[0:3])
print("y_train (Erste drei Zeilen):");
print(y_train[0:3])
6-4 Vorhersagemodell erstellen
Das Vorhersagemodell für die Trainingsdaten (X_train, y_train) wird mit Hilfe der Methode fit() des scikit-learn DecisionTreeClassifier erstellt. Der DecisionTreeClassifier verwendet eine optimierte Version des CART-Algorithmus. Beim Erstellen des Modells als Instanz der Klasse DecisionTreeClassifier werden verschiedene Konfigurationsparameter festgelegt, die steuern, wie genau der Entscheidungsbaum aufgebaut wird, die wichtigsten sind: criterion, splitter, max_depth, min_samples_split, min_samples_leaf, max_features.
Python-Code:# Erstelle Modell
model = DecisionTreeClassifier (
criterion='entropy',
splitter='best',
max_depth=5,
min_samples_split=0.3,
max_features=10
)
# Erzeuge Entscheidungsbaum
model.fit(X_train, y_train)
- criterion: legt fest, welche Funktion verwendet wird, um die Güte einer Aufteilung (engl. Split) an einem Knoten zu messen. Als Kriterium kann entweder "gini" oder "entropy" verwendet. Wir wählen das Kriterium "entropy".
- splitter: beschreibt mit welcher Strategie der nächste Knoten aufgeteilt wird.
-- splitter = 'random' bedeutet, dass ein zufälliges Merkmal ausgewählt wird um den Knoten aufzuteilen.
-- splitter = 'best' bedeutet, dass das relevanteste Merkmal ausgewählt wird, um den Knoten aufzuteilen. - max_depth: bestimmt die maximale Tiefe des Entscheidungsbaums. Der Default-Wert für max_depth ist "None", d.h. der Baum kann beliebig tief werden, dies kann jedoch zu Überanpassung des Modells an die Trainingsdaten führen. Wir setzen hier max_depth = 5.
- min_samples_split: bestimmt die minimal erforderliche Anzahl der Beobachtungen für die Aufteilung eines Knotens. Kann als absolute Zahl (kleinster Wert: 1, größter Wert: Anzahl der Beobachtungen) oder in Prozent (kleinster Wert: 0.1, größter Wert: 1.0) angegeben werden. Wir setzen min_samples_split = 0.3, d.h. ein Knoten wird nur aufgeteilt, wenn er mehr als 30% der Datensätze enthält.
- min_samples_leaf: bestimmt die kleinste Anzahl der Beobachtungen, die ein Blatt enthalten muss. Ein zu kleiner Wert (d.h. 1) kann zu einem Baum führen, in dem jedes Blatt nur genau eine Beobachtung enthält.
- max_features: gibt die Anzahl der Merkmale an, die bei der Suche nach der besten Aufteilung berücksichtigt werden.
Der kleinste Wert für max_features ist 1, der größte Wert ist die Anzahl der Merkmale (in unserem Fall, 22).
Informelle Interpretation: Angenommen, der Trainingsdatensatz besteht aus 100 Beobachtungen / Zeilen und wir setzen max_feature=10. Dann werden bei jedem Split (d.h. Aufteilung der Daten an einem Knoten 10 Merkmale zufällig ausgewählt und aus diesen 10 wird das beste Merkmal für den Split bestimmt. Ein zu großer Wert für max_features führt zu einer Überanpassung des Modells an die Trainingsdaten. Wir setzen max_features = 10.
6-5 Vorhersagemodell visualisieren
Die Visualisierung des Entscheidungsbaums wird mit Hilfe der Bibliothek Graphviz und der scikit learn-Funktion export_graphviz() erstellt. Graphviz ist ein Open-Source-Programmpaket zur Visualisierung von Graphen. Graphviz entnimmt alle zur Erzeugung der Grafik benötigten Anweisungen einer Textdatei, die eine Beschreibung der Knoten und Kanten des Graphen enthält, und zwar in der DOT-Beschreibungssprache für die visuelle Darstellung von Graphen.
Zunächst wird in Zeile 2-5 mit Hilfe der Funktion export_graphviz() der Entscheidungsbaum in das graphviz-DOT-Format exportiert. Daraus wird dann in Zeile 7 ein Graph erzeugt und in Zeile 8 in der Jupyter Notebook Ausgabe angezeigt. Wichtig: Um Graphviz zu verwenden, reicht es nicht, das entsprechende Python-Paket zu installieren, sondern Graphviz muss als eigene Anwendung auf Ihrem Rechner installiert und über die PATH-Variable bekannt sein.
Python-Code:# Visualisierung des Entscheidungsbaums
# Erzeuge dot-Quellcode
dot=export_graphviz(model, out_file=None,filled=True,
feature_names=df.columns[1:24],
class_names=['ja','nein']);
# Erzeuge Graphviz-Graphen aus dot-Quellcode
graph = gv.Source(dot, format='svg')
graph
Falls es bei der Visualisierung mit Graphviz zu einer Fehlermeldung kommt, kann der Entscheidungsbaum auch mit Hilfe der sklearn.Funktion plot_tree() visualisiert werden. Die Funktion erhält als ersten Parameter den zuvor trainierten Entscheidungsbaum (hier: "model") und als zweiten Parameter eine Option, die angibt ob die Baumknoten farblich ausgefüllt (Filled=True) oder Schwarz-Weiß angezeigt werden (Filled=False).
Python-Code:Ausgabe:import matplotlib.pyplot as plt
from sklearn import tree
fig, ax = plt.subplots(figsize=(10, 10))
tree.plot_tree(model, filled=True)
plt.show()
7 Performance-Kennzahlen
Um ein Entscheidungsbaum-Vorhersagemodell zu validieren, verwendet man Kennzahlen, die angeben, wie gut der Wert der Zielvariablen mit dem entsprechenden Modell vorhergesagt wird. Die wichtigsten Kennzahlen werden in Datenanalyse - Kennzahlen detailliert beschrieben. Wir verwenden hier nur Accuracy, Precision und Recall.
- Vertrauenswahrscheinlichkeit (engl. Accuracy):
Die Wahrscheinlichkeit, dass für eine Beobachtung eine richtige Vorhersage getroffen wird. Accuracy = Quotient zwischen der Anzahl der richtigen Zuordnungen und der Anzahl aller Beobachtungen. - Genauigkeit (engl. Precision):
Die Wahrscheinlichkeit, dass die Vorhersage eines Ausfalls auch richtig ist. Precision = Quotient zwischen den richtig positiv-Klassifikationen und der Anzahl der Vorhersagen mit "Ausfall=ja". - Trefferquote (engl. Recall):
Die Wahrscheinlichkeit, dass für eine Beobachtung "ausgefallen" auch ein Ausfall vorhergesagt wird. Recall = Quotient zwischen den richtig positiv-Klassifikationen und der Gesamtzahl der Beobachtungen mit Ausfall="ja".
In einem Predictive Maintenance-Szenario entstehen dem Unternehmen einerseits Kosten, falls ein Ausfall nicht als solcher erkannt wird, es entstehen aber auch Kosten, falls fälschlicherweise ein Ausfall vorhergesagt und die Produktion unterbrochen wird. D.h. die Kennzahlen Precision und Recall sind beide wichtig.
Im folgenden ermitteln wir Performance-Kennzahlen Accuracy, Precision und Recall und bewerten damit die Güte des Vorhersagemodells. Zunächst wird eine Vorhersage auf Basis des Entscheidungsbaums und der Testdaten erstellt. Die Methode predict() erhält als Parameter die Testdatensätze (30% der Daten, die nicht für die Erstellung des Modells verwendet wurden) und gibt einen Vektor y_pred mit Vorhersagen zurück: "ja" bedeutet Ausfall, "nein" bedeutet kein Ausfall.
Python-Code:Ausgabe:y_pred = model.predict(X_test)
y_pred
Nachdem das Vorhersage-Array y_pred ermittelt wurde, können die oben beschriebenen Metriken mit
Hilfe der Funktionen accuracy_score, precision_score und recall_score berechnet werden.
Mit den eingestellten Konfigurationsparametern (criterion='entropy', splitter='best', min_samples_split=0.3, max_features=10)
erreichen wir eine Vertrauenswahrscheinlichkeit von 75%, eine Genauigkeit von 83% und eine Trefferquote von 68%.
from sklearn.metrics import accuracy_score, precision_score, recall_score
print('PERFORMANCE-KENNZAHLEN:')
# Vertrauenswahrscheinlichkeit
print("Accuracy: %.2f%%" %
(100 * accuracy_score(y_test, y_pred)))
# Genauigkeit
print("Precision: %.2f%%" %
(100 * precision_score(y_test, y_pred, pos_label='ja', average='binary')))
# Trefferquote
print("Recall: %.2f%%" %
(100 * recall_score(y_test, y_pred, pos_label='ja', average='binary')))
Eine Genauigkeit von 83% ist im Falle unseres Mini-Automobildatensatzes mit nur 136 Beobachtungen als "gut" zu bewerten. Es bedeutet, dass in weniger als 20% der Fälle ein Ausfall vorhergesagt wird, obwohl eigentlich keiner vorliegt.
Der bisherige Code ist in einem Jupyter Notebook zusammengefasst, das bei Google Colab eingesehen und heruntergeladen werden kann (Anmeldung mit einem Google-Account ist erforderlich).
8 Interaktive Visualisierung
Nachdem die grundlegenden Funktionen der Klassifikation mit Entscheidungsbäumen getestet wurden, erstellen wir als Nächstes mit Hilfe der Jupyter Widget-Funktion interactive_output() eine interaktive Visualisierung des Entscheidungsbaums, mit dem Ziel, die Wirkung der unterschiedlichen Parameter auf die Performance des Modells zu testen.
Für die Benutzeroberfläche wurden verschiedene Design-Varianten ausprobiert: Training und Prognose auf einer Seite, Verwendung unterschiedlicher Tabs für die drei Schritte des Überwachten Lernens etc. Allen Varianten ist gemeinsam, dass die Benutzeroberfläche im oberen Bereich Steuerelemente hat, über die die wichtigsten Konfigurationsparameter eingestellt werden, und im unteren Bereich die tabellarische oder grafische Ausgabe angezeigt wird. Bei jeder Änderung eines Konfigurationsparameters wird sofort ein neues Vorhersagemodell erstellt und visualisiert. Gleichzeitig werden die Performance-Kennzahlen für den Validierungsdatensatz automatisch berechnet und angezeigt.
Die finale Benutzeroberfläche besteht aus drei Tabs, die den Schritten Datenvorbereitung, Modellerstellung und Vorhersage bzw. Klassifikation entsprechen. Im ersten Tab "Datensatz" können die Merkmale des Datensatzes ausgewählt werden. Im zweiten Tab "Entscheidungsbaum" können die Parameter min_samples_split, min_samples_leaf und max_depth des Entscheidungsbaums eingestellt werden, dabei wird interaktiv der daraus resultierende Entscheidungsbaum und die daraus errechneten Performance-Kennzahlen angezeigt.
Autoren, Tools und Quellen
Autoren
Prof. Dr. Eva Maria Kiss
Tools:
Python,
Anaconda,
Jupyter Notebook
Scikit-learn,
Pandas,
Matplotlib,
NumPy
Quellen und weiterführende Links
- [1] Erste Schritte mit Jupyter Notebook: elab2go/demo-py1/jupyter-notebooks.php
- [2] Jupyter Notebook Widgets verwenden: elab2go/demo-py1/jupyter-notebook-widgets
- [3] Jupyter Widgets Webseite: https://ipywidgets.readthedocs.io/
- [4] Offizielle Python Dokumentation bei python.org: https://docs.python.org/3/tutorial/ - sehr umfangreich, Nachschlagewerk, hier findet man Dokumentationen für spezifische Python-Versionen
- [5] Python Tutorial bei Google Developers: https://developers.google.com/edu/python/introduction - umfangreich, für Fortgeschrittene, verweist auf die offizielle Dokumentation