›  Demo-PY4: Predictive Maintenance mit scikit-learn

Demo-PY4 zeigt, wie eine Ausfall-Prognose 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 Automobildatensatz, der in allen Demos des Predictive Maintenance-Zyklus verwendet wird: eine csv-Datei automotive_data.csv mit 136 Beobachtungen. Jede Beobachtung bzw. Zeile hat insgesamt 24 Spalten, von denen 22 Spalten Sensorwerte enthalten und die Merkmale der Datenanalyse darstellen. Zielvariable ist die Spalte "Ausfall". Die Fragestellung lautet: "Bei welcher Kombination von Merkmalen tritt ein Ausfall ein?".

info-icon Motivation

In den Demonstratoren des Predictive Maintenance-Zyklus Demo 2: Was ist Predictive Maintenance?, Demo 2: Datenanalyse mit RapidMiner, Demo 3: Predictive Maintenance mit R, Demo 5: Predictive Maintenance mit MATLAB wird die Durchführung der Datenanalyse und Vorhersage im Rahmen der Vorausschauenden Wartung unter Verwendung verschiedener Datenanalyse-Tools durchgeführt: RapidMiner, R, MATLAB. In dieser Demo des Predictive Maintenance-Zyklus 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 eine Open-Source-Bibliothek zum maschinellen Lernen für die Programmiersprache Python und bietet leistungsstarke Algorithmen, wie Klassifikations-, Regressions- und Clustering-Algorithmen, siehe die sklearn-Funktionen. In diesem Abschnitt wird die Bibliothek scikit-learn eine zentrale Rolle spielen, da sie die von uns benötigten binären Klassifikationsverfahren: Entscheidungsbäume zur Verfügung stellt, siehe sklearn.tree.

Warum graphviz?

Graphviz ist ein Open-Source-Programmpaket zur Visualisierung von Graphen, das in scikit-learn mittels der Funktion Funktion export_graphviz()für die Visualisierung von Entscheidungsbäumen verwendet wird. Die erzeugte Visualisierung des Entscheidungsbaums stellt pro Knoten zusätzliche Informationen wie: Anzahl der Beobachtungen, Anzahl der Merkmale, Entropie, Wert der Zielvariablen.

info-icon Übersicht

Demo-PY4 ist in 5 Abschnitte gegliedert. Zunächst wird der Automobil-Datensatz beschrieben und die Fragestellung, die wir mit unserer Datenanalyse beantworten wollen. Danach beschreiben wir kurz die Funktionsweise und Anwendung von Entscheidungsbäumen. Danach wird die Erstellung des Jupyter Notebooks und Vorbereitung benötigter Bibliotheken erläutert. In den folgenden Abschnitten beschreiben wir die Erstellung eines Entscheidungsbaum-Vorhersagemodells, dessen Visualisierung mit graphviz, und die Ermittlung von Performance-Kennzahlen, die die Güte des Modells beschreiben.

  1. Der Automobil-Datensatz

  2. Was ist ein Entscheidungsbaum?

  3. Jupyter Notebook erstellen

  4. Das Entscheidungsbaum-Vorhersagemodell

  5. Performance-Kennzahlen

Der Automobil-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.


Was ist ein Entscheidungsbaum?

Ein Entscheidungsbaum ist ein einfaches und intuitiv nutzbares binäres Klassifikationsmodell, mit dessen Hilfe man eine Fragestellung beantworten kann. In unserem Fall die Frage, ob bei einer bestimmten Kombination von Messungen ein Ausfall eintritt oder nicht. Ein Entscheidungsbaum besteht aus einer Wurzel, Kindknoten 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.

Die Details der Durchführung einer Vorhersage mit Hilfe eines Entscheidungsbaums sind in Demo2 - Datenanalyse beschrieben.

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.

Zunächst wird in 6 Codezellen ein Entscheidungsbaum-Vorhersagemodell erstellt, an dem wir die korrekte Abfolge der Schritte testen. Danach erstellen wir mit Hilfe der Jupyter Widget-Funktion interactive() eine interaktive Visualisierung des Entscheidungsbaums. Die interaktive Benutzeroberfläche hat im oberen Bereich Steuerelemente, über die die wichtigsten Konfigurationsparameter eingestellt werden. 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.

Interaktive Visualisierung des Entscheidungsbaums
Interaktive Visualisierung des Entscheidungsbaums

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.

Das Entscheidungsbaum-Vorhersagemodell

1. 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. 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 

2. Daten einlesen

In der zweiten 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.

 # 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]   


3. Merkmale und Zielvariable extrahieren

In der dritten 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]))  


4. Aufteilen der Daten in Trainingsdaten 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%.

Python-Code 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])    


5. 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.

 # Erstelle Modell   
 model = DecisionTreeClassifier (  
      criterion='entropy',   
      splitter='best',       
      min_samples_split= 0.3,   
      max_features=10,  
      max_depth=None
      )  
 # Erzeuge Entscheidungsbaum  
 model.fit(X_train, y_train)  

6. 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.

 # 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)  
 graph  


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 Demo2 - Datenanalyse - Kennzahlen detailliert beschrieben. Wir verwenden hier nur Accuracy, Precision und Recall.

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%.

Python-Code Ausgabe
  
 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.

Mit Beiträgen von:
 Prof. Dr. Eva Maria Kiss und
 M. Sc. Anke Welz
Tools, Software und weiterführende Links:
Python, Anaconda, Jupyter Notebook, scikit-learn, pandas, matplotlib, NumPy