Posts

Ensemble Learning

Stellen Sie sich vor, Sie haben die Frage Ihres Lebens vor sich. Die korrekte Beantwortung dieser Frage wird Ihr Leben positiv beeinflussen, andernfalls negativ. Aber Sie haben Glück: Sie dürfen einen Experten, den Sie auswählen dürfen, um Rat fragen oder Sie dürfen eine annonyme Gruppe, sagen wir 1.000 Personen, um Rat fragen. Welchen Rat würden Sie sich einholen? Die einzelne Experten-Meinung oder die aggriegierte Antwort einer ganzen Gruppe von Menschen?
Oder wie wäre es mit einer Gruppe von Experten?

Ensemble Learning

Beim Einsatz eines maschinellen Lernalgorithmus auf ein bestimmtes Problem kann durchaus eine angemessene Präzision (Accuracy, eine Quote an Prädiktionsergebnissen, die als korrekt einzustufen sind) erzielt werden, doch oftmals reicht die Verlässlichkeit eines einzelnen Algorithmus nicht aus. Algorithmen können mit unterschiedlichen Parametern verwendet werden, die sich bei bestimmten Daten-Situationen verschieden auswirken. Bestimmte Algorithmen neigen zur Unteranpassung (Underfitting), andere zur Überanpassung (Overfitting).

Soll Machine Learning für den produktiven Einsatz mit bestmöglicher Zuverlässigkeit entwickelt und eingesetzt werden, kommt sinnvollerweise Ensemble Learning zum Einsatz. Beim Ensemble Learning wird ein Ensemble (Kollektiv von Prädiktoren) gebildet um ein Ensemble Average (Kollektivmittelwert) zu bilden. Sollte also beispielsweise einige Klassifizierer bei bestimmten Daten-Eingaben in ihren Ergebnissen ausreißen, steuern andere Klassifizierer dagegen. Ensemble Learning kommt somit in der Hoffnung zum Einsatz, dass eine Gruppe von Algorithmen ein besseres Ergebnis im Mittel erzeugen als es ein einzelner Algorithmus könnte.

Ich spreche nachfolgend bevorzugt von Klassifizierern, jedoch kommt Ensemble Learning auch bei der Regression zum Einsatz.

Voting Classifiers (bzw. Voting Regressors)

Eine häufige Form – und i.d.R. auch als erstes Beispiel eines Ensemble Learners – ist das Prinzip der Voting Classifiers. Das Prinzip der Voting Classifiers ist eine äußerst leicht nachvollziehbare Idee des Ensemble Learnings und daher vermutlich auch eine der bekanntesten Form der Kollektivmittelwert-Bildung. Gleich vorweg: Ja, es gibt auch Voting Regressors, jedoch ist dies ein Konzept, das nicht ganz ohne umfassendere Aggregation auf oberster Ebene auskommen wird, daher wäre für die Zwecke der akkurateren Regression eher das Stacking (siehe unten) sinnvoll.

Eine häufige Frage im Data Science ist, welcher Klassifizierer für bestimmte Zwecke die besseren sind: Entscheidungsbäume, Support-Vector-Machines, k-nächste-Nachbarn oder logistische Regressionen?

Warum nicht einfach alle nutzen? In der Tat wird genau das nicht selten praktiziert. Das Ziel dieser Form des Ensemble Learnings ist leicht zu erkennen: Die unterschiedlichen Schwächen aller Algorithmen sollen sich – so die Hoffnung – gegenseitig aufheben. Alle Algorithmen (dabei können auch mehrere gleiche Algorithmen mit jedoch jeweils unterschiedlichen Paramtern gemeint sein, z. B. mehrere knN-Klassifizierer mit unterschiedlichen k-Werten und Dimensionsgewichtungen) werden auf dasselbe Problem hin trainiert.

Stacking

Bei der Prädiktion werden entweder alle Klassifizierer gleich behandelt oder unterschiedlich gewichtet (wobei größere Unterschiede der Gewichtungen unüblich, und vermutlich auch nicht sinnvoll, sind). Entsprechend einer Ensemble-Regel werden die Ergebnisse aller Klassifizierer aggregiert, bei Klassifikation durch eine Mehrheitsentscheidung, bei Regression meistens durch Durchschnittsbildung oder (beim Stacking) durch einen weiteren Regressor.

Abgesehen davon, dass wir mit dem Ensemble-Klassifizierer bzw. Regressoren vermutlich bessere Ergebnisse haben werden, haben wir nun auch eine weitere Information hinzubekommen: Eine Entropie über die Wahrscheinlichkeit. Bestenfalls haben alle Klassifizierer die gleiche Vorhersage berechnet, schlechtestensfalls haben wir ein Unentschieden. So können wir Vorhersagen in ihrer Aussagekraft bewerten. Analog kann bei Regressionen die Varianz der Ergebnisse herangezogen werden, um das Ergebnis in seiner Aussagekraft zu bewerten.

Betrachtung im Kontext von: Eine Kette ist nur so stark, wie ihr schwächstes Glied

Oft heißt es, dass Ensemble Learning zwar bessere Ergebnisse hervorbringt, als der schwächste Klassifizier in der Gruppe, aber auch schlechtere als der beste Klassifizierer. Ist Ensemble Learning also nur ein Akt der Ratlosigkeit, welcher Klassifizierer eigentlich der bessere wäre?

Ja und nein. Ensemble Learning wird tatsächlich in der Praxis dazu verwendet, einzelne Schwächen abzufangen und auch Ausreißer-Verhalten auf bisher andersartiger Daten abzuschwächen. Es ist ferner jedoch so, dass Ensemble Learner mit vielen Klassifizieren sogar bessere Vorhersagen liefern kann, als der beste Klassifizierer im Programm.

Das liegt an dem Gesetz der großen Zahlen, dass anhand eines Beispiels verdeutlicht werden kann: Bei einem (ausbalanzierten) Münzwurf liegt die Wahrscheinlichkeit bei genau 50,00% dafür, Kopf oder Zahl zu erhalten. Werfe ich die Münze beispielsweise zehn Mal, erhalte ich aber vielleicht drei Mal Kopf und sieben mal Zahl. Werfe ich sie 100 Mal, erhalte ich vielleicht 61 Mal Kopf und 39 Mal Zahl. Selbst nur 20 Mal die Zahl zu erhalten, wäre bei nur 100 Würfen gar nicht weit weg von unwahrscheinlich. Würde ich die Münze jedoch 10.000 Male werfen, würde ich den 50% schon sehr annähern, bei 10 Millionen Würfen wird sich die Verteilung ganz sicher als Gleichverteilung mit 50,0x% für Kopf oder Zahl einpendeln.

Nun stellt man sich (etwas überspitzt, da analog zu den Wünzwürfen) nun einen Ensemble Learner mit einer Gruppe von 10.000 Klassifiziern vor. Und angenommen, jeder einzelne Klassifizierer ist enorm schwach, denn eine richtige Vorhersage trifft nur mit einer Präzision von 51% zu (also kaum mehr als Glücksspiel), dann würde jedoch die Mehrheit der 10.000 Klassifizierer (nämlich 51%) richtig liegen und die Mehrheitsentscheidung in den absolut überwiegenden Fällen die korrekte Vorhersage treffen.

Was hingehen in diesem Kontext zutrifft: Prädiktionen via Ensemble Learning sind zwangsläufig langsam. Durch Parallelisierung der Klassifikation kann natürlich viel Zeit eingespart werden, dann ist das Ensemble Learning jedoch mindestens immer noch so langsam, wie der langsamste Klassifizierer.

Bagging

Ein Argument gegen den Einsatz von gänzlich verschiedenen Algortihmen ist, dass ein solcher Ensemble Learner nur schwer zu verstehen und einzuschätzen ist (übrigens ein generelles Problem im maschinellen Lernen). Bereits ein einzelner Algorithmus (z. B. Support Vector Machine) kann nach jedem Training alleine auf Basis der jeweils ausgewählten Daten (zum Training und zum Testen) recht unterschiedlich in seiner Vorhersage ausfallen.

Bagging (kurze Form von Bootstrap Aggregation) ist ein Ensemble Learning Prinzip, bei dem grundsätzlich der gleiche Algorithmus parallel mit unterschiedlichen Aufteilungen der Daten trainiert (und natürlich getestet) wird. Die Aufteilung der Daten kann dabei komplett (der vollständige Datensatz wird verteilt und verwendet) oder auch nur über Stichproben erfolgen (dann gibt es mehrfach verwendete Datenpunkte, aber auch solche, die überhaupt nicht verwendet werden). Das Ziel ist dabei insbesondere, im Endergebnis Unter- und Überanpassung zu vermeiden. Gibt es viele Dichte-Cluster und Ausreißer in den Daten, wird nicht jeder Klassifizierer sich diesen angepasst haben können. Jede Instanz der Klassifizierer erhält weitgehend unterschiedliche Daten mit eigenen Ausreißern und Dichte-Clustern, dabei darf es durchaus Überschneidungen bei der Datenaufteilung geben.

Pasting

Pasting ist fast genau wie Bagging, nur mit dem kleinen aber feinen Unterschied, dass sich die Datenaufteilung nicht überschneiden darf. Wird ein Datenpunkt durch Zufallsauswahl einem Klassifizierer zugewiesen, wird er nicht mehr für einen anderen Klassifizierer verwendet. Über die Trainingsdaten des einen Klassifizierers verfügt demnach kein anderer Klassifizierer. Die Klassifizierer sind somit völlig unabhängig voneinander trainiert, was manchmal explizit gewollt sein kann. Pasting setzt natürlich voraus, dass genug Daten vorhanden sind. Diese Voraussetzung ist gleichermaßen auch eine Antwort auf viele Probleme: Wie können große Datenmengen schnell verarbeitet werden? Durch die Aufteilung ohne Überschneidung auf parallele Knoten.

Random Forest

Random Forests sollten an dieser Stelle im Text eigentlich nicht stehen, denn sie sind ein Beispiel des parallelen Ensembles bzw. des Voting Classifiers mit Entscheidungsbäumen (Decision Trees). Random Forests möchte ich an dieser Stelle dennoch ansprechen, denn sie sind eine äußerst gängige Anwendung des Baggings oder (seltener) auch des Pastings für Entscheidungsbaumverfahren. Die Datenmenge wird durch Zufall aufgeteilt und aus jeder Aufteilung heraus wird ein Entscheidungsbaum erstellt. Eine Mehrheitsentscheidung der Klassifikationen aller Bäume ist das Ensemble Learning des Random Forests.

Random Forest ist ein Verfahren der Klassifikation oder Regression, das bereits so üblich ist, dass es mittlerweile längst in (fast) allen Machine Learning Bibliotheken implemeniert ist und – dank dieser Implementierung – in der Anwendung nicht komplizierter, als ein einzelner Entscheidungsbaum.

Stacking

Stacking ist eine Erweiterung des Voting Classifiers oder Voting Regressors um eine höhere Ebene (Blending-Level), die die beste Aggregation der Einzel-Ergebnisse erlernt. An der Spitze steht beim Stacking (mindestens) ein weiterer Klassifikator oder Regressor

Stacking ist insbesondere dann sinnvoll, wenn die Ergebnisse der einzelnen Algorithmen sehr unterschiedlich ausfallen können, was bei der Regression – da stetige Werte statt wenige Klassen – nahezu immer der Fall ist. Stacking-Algorithmen können sogar mehrere Schichten umfassen, was ihr Training wesentlich schwieriger gestaltet.

Boosting (Sequential Ensemble Learning)

Bagging, Pasting und Stacking sind parallele Verfahren des Ensemble Learning (was nicht bedeutet, dass die parallel dargestellten Algorithmen in der Praxis nicht doch sequenziell abgearbeitet werden). Zwangsweise sequenziell durchgeführt wird hingegen das Boosting, bei dem wir schwache Klassifizierer bzw. Regressoren durch Iteration in ihrem Training verstärken wollen. Boosting kann somit als eine Alternative zum Deep Learning gesehen werden. Während beim Deep Learning ein starker Algorithmus durch ein mehrschichtiges künstliches neuronales Netz dafür entworfen und trainiert wird, um ein komplexes Problem zu lösen (beispielsweise Testerkennung [OCR]), können derartige Herausforderungen auch mit schwächeren Klassifikatoren unter Einsatz von Boosting realisiert werden.

Boosting bezieht sich allein auf das Training und ist aus einer Not heraus entstanden: Wie bekommen wir bessere Prädiktionen mit einem eigentlich schwachen Lernalgorithmus, der tendenziell Unteranpassung erzeugt? Boosting ist eine Antwort auf Herausforderungen der Klassifikation oder Regression, bei der ein Algorithmus iterativ, also in mehreren Durchläufen, durch Anpassung von Gewichten trainiert wird.

Eines der bekanntesten Boosting-Verfahren ist AdaBoost. Der erste Schritt ist ein normales Training. Beim darauffolgenden Testen zeigen sich Klassifikations-/Regressionsfehler. Die fehlerhaft vorhergesagten Datenpunkte werden dann für einen nächsten Durchlauf höher gewichtet. Diese Iteration läuft einige Male, bis die Fehlerquote sich nicht mehr verbessert.

Bei AdaBoost werden falsch vorhergesagte Datensätze im jeweils nächsten Durchlauf höher gewichtet. Bei einem alternativen Boosing-Verfahren, dem Gradient Boosting (auf Basis der Gradientenmethode), werden Gewichtungen explizit in Gegenrichtung des Prädiktionsfehlers angepasst.

Was beispielsweise beim Voting Classifier der Random Forest ist, bei dem mehrere Entscheidungsbäume parallel arbeiten, sind das Äquvivalent beim Boosting die Gradient Boosted Trees, bei denen jeder Baum nur einen Teil der Daten akkurat beschreiben kann, die sequentielle Verschachtelung der Bäume jedoch auch herausfordernde Klassifikationen meistert.

Um bei dem Beispiel der Entscheidungsbäume zu bleiben: Sowohl Random Forests als auch Gradient Boosted Trees arbeiten grundsätzlich mit flachen Bäumen (schwache Klassifikatoren). Gradient Boosted Trees können durch die iterative Verstärkung generell eine höhere Präzision der Prädiktion erreichen als Random Forests, wenn die Feature- und Parameter-Auswahl bereits zu Anfang sinnvoll ist. Random Forests sind hingegen wiederum robuster bei der Feature- und Parameter-Auswahl, verstärken sich jedoch nicht gegenseitig, sondern sind in ihrem Endergebnis so gut, wie die Mehrheit der Bäume.

Buchempfehlungen

Mehr zum Thema Machine Learning und Ensemble Learning gewünscht? Folgende zwei Buchempfehlungen bieten nicht nur Erklärungen, sondern demonstrieren Ensemble Learning auch mit Beispiel-Code mit Python Scikit-Learn.

Hands-On Machine Learning with Scikit-Learn and TensorFlow: Concepts, Tools, and Techniques for Building Intelligent Systems Machine Learning mit Python: Das Praxis-Handbuch für Data Science, Predictive Analytics und Deep Learning (mitp Professional)

Lineare Regression in Python mit Scitkit-Learn

Die lineare Regressionsanalyse ist ein häufiger Einstieg ins maschinelle Lernen um stetige Werte vorherzusagen (Prediction bzw. Prädiktion). Hinter der Regression steht oftmals die Methode der kleinsten Fehlerquadrate und die hat mehr als eine mathematische Methode zur Lösungsfindung (Gradientenverfahren und Normalengleichung). Alternativ kann auch die Maximum Likelihood-Methode zur Regression verwendet werden. Wir wollen uns in diesem Artikel nicht auf die Mathematik konzentrieren, sondern uns direkt an die Anwendung mit Python Scikit-Learn machen:

Haupt-Lernziele:

  • Einführung in Machine Learning mit Scikit-Learn
  • Lineare Regression mit Scikit-Learn

Neben-Lernziele:

  • Datenvorbereitung (Data Preparation) mit Pandas und Scikit-Learn
  • Datenvisualisierung mit der Matplotlib direkt und indirekt (über Pandas)

Was wir inhaltlich tun:

Der Versuch einer Vorhersage eines Fahrzeugpreises auf Basis einer quantitativ-messbaren Eigenschaft eines Fahrzeuges.


Die Daten als Download

Für dieses Beispiel verwende ich die Datei “Automobil_data.txt” von Kaggle.com. Die Daten lassen sich über folgenden Link downloaden, nur leider wird ein (kostenloser) Account benötigt:
https://www.kaggle.com/toramky/automobile-dataset/downloads/automobile-dataset.zip
Sollte der Download-Link unerwartet mal nicht mehr funktionieren, freue ich mich über einen Hinweis als Kommentar 🙂

Die Entwicklungsumgebung

Ich verwende hier die Python-Distribution Anaconda 3 und als Entwicklungs-Umgebung Spyder (in Anaconda enthalten). Genauso gut funktionieren jedoch auch Jupyter Notebook, Eclipse mit PyDev oder direkt die IPython QT-Console.


Zuerst einmal müssen wir die Daten in unsere Python-Session laden und werden einige Transformationen durchführen müssen. Wir starten zunächst mit dem Importieren von drei Bibliotheken NumPy und Pandas, deren Bedeutung ich nicht weiter erläutern werde, somit voraussetze.

import matplotlib.pyplot as plt  # Die Nr.1 der Bibliotheken zur Datenvisualisierung
import numpy as np               # Bibliothek "Nummerisches Python"
import pandas as pd              # Bibliothek "Panel Data"

Wir nutzen die Pandas-Bibliothek, um die “Automobile_data.txt” in ein pd.DataFrame zu laden.

dataSet = pd.read_csv("Automobile_data.txt",  # Hier liegt die Datei im selben Verzeichnis wie das Python-Skript!
                      delimiter = ',',
                      thousands = None,
                      decimal = '.')

Schauen wir uns dann die ersten fünf Zeilen in IPython via dataSet.head().

In : dataSet.head()
Out: 
   symboling normalized-losses         make fuel-type aspiration num-of-doors  \
0          3                 ?  alfa-romero       gas        std          two   
1          3                 ?  alfa-romero       gas        std          two   
2          1                 ?  alfa-romero       gas        std          two   
3          2               164         audi       gas        std         four   
4          2               164         audi       gas        std         four   

    body-style drive-wheels engine-location  wheel-base  ...    engine-size  \
0  convertible          rwd           front        88.6  ...            130   
1  convertible          rwd           front        88.6  ...            130   
2    hatchback          rwd           front        94.5  ...            152   
3        sedan          fwd           front        99.8  ...            109   
4        sedan          4wd           front        99.4  ...            136   

   fuel-system  bore  stroke compression-ratio horsepower  peak-rpm city-mpg  \
0         mpfi  3.47    2.68               9.0        111      5000       21   
1         mpfi  3.47    2.68               9.0        111      5000       21   
2         mpfi  2.68    3.47               9.0        154      5000       19   
3         mpfi  3.19     3.4              10.0        102      5500       24   
4         mpfi  3.19     3.4               8.0        115      5500       18   

  highway-mpg  price  
0          27  13495  
1          27  16500  
2          26  16500  
3          30  13950  
4          22  17450  

[5 rows x 26 columns]

Hinweis: Der Datensatz hat viele Spalten, so dass diese in der Darstellung mit einem Backslash \ umgebrochen werden.

Gleich noch eine weitere Ausgabe dataSet.info(), die uns etwas über die Beschaffenheit der importierten Daten verrät:

In : dataSet.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 205 entries, 0 to 204
Data columns (total 26 columns):
symboling            205 non-null int64
normalized-losses    205 non-null object
make                 205 non-null object
fuel-type            205 non-null object
aspiration           205 non-null object
num-of-doors         205 non-null object
body-style           205 non-null object
drive-wheels         205 non-null object
engine-location      205 non-null object
wheel-base           205 non-null float64
length               205 non-null float64
width                205 non-null float64
height               205 non-null float64
curb-weight          205 non-null int64
engine-type          205 non-null object
num-of-cylinders     205 non-null object
engine-size          205 non-null int64
fuel-system          205 non-null object
bore                 205 non-null object
stroke               205 non-null object
compression-ratio    205 non-null float64
horsepower           205 non-null object
peak-rpm             205 non-null object
city-mpg             205 non-null int64
highway-mpg          205 non-null int64
price                205 non-null object
dtypes: float64(5), int64(5), object(16)
memory usage: 41.7+ KB

Einige Spalten entsprechen hinsichtlich des Datentypes nicht der Erwartung. Für die Spalten ‘horsepower’ und ‘peak-rpm’ würde ich eine Ganzzahl (Integer) erwarten, für ‘price’ hingegen eine Fließkommazahl (Float), allerdings sind die drei Spalten als Object deklariert. Mit Trick 17 im Data Science, der Anzeige der Minimum- und Maximum-Werte einer zu untersuchenden Datenreihe, kommen wir dem Übeltäter schnell auf die Schliche:

dataSet['horsepower'].min()
Out: '100'

dataSet['horsepower'].max()
Out: '?'

Datenbereinigung

Für eine Regressionsanalyse benötigen wir nummerische Werte (intervall- oder ratioskaliert), diese möchten wir auch durch richtige Datentypen-Deklaration herstellen. Nun wird eine Konvertierung in den gewünschten Datentyp jedoch an den (mit ‘?’ aufgefüllten) Datenlücken scheitern.

Schauen wir uns doch einmal die Datenreihen an, in denen in der Spalte ‘peak-rpm’ Fragezeichen stehen:

dataSet[dataSet['peak-rpm'] == '?'][['engine-type', 'num-of-cylinders']]
Out: 
    engine-type num-of-cylinders
130         ohc             four
131         ohc             four

Zwei Datenreihen sind vorhanden, bei denen ‘peak-rpm’ mit einem ‘?’ aufgefüllt wurde. Nun könnten wir diese Datenreihen einfach rauslöschen. Oder mit sinnvollen (im Sinne von wahrscheinlichen) Werten auffüllen. Vermutlichen haben beide Einträge – beide sind OHC-Motoren mit 4 Zylindern – eine ähnliche Drehzahl-Angabe wie vergleichbare Motoren. Mit folgendem Quellcode, gruppieren wir die Spalten ‘engine-type’ und ‘num-of-cylinders’ und bilden für diese Klassen den arithmetischen Mittelwert (.mean()) für die ‘peak-rpm’.

dataSet_rpm = dataSet[dataSet['peak-rpm'] != '?'][['engine-type', 'num-of-cylinders','peak-rpm']]
dataSet_rpm['peak-rpm'] = dataSet_rpm['peak-rpm'].astype(float)
dataSet_rpm_grouped = dataSet_rpm.groupby(['engine-type', 'num-of-cylinders'])
dataSet_rpm_grouped['peak-rpm'].mean()

Und schauen wir uns das Ergebnis an:

dataSet_rpm_grouped['peak-rpm'].mean()
Out: 
engine-type  num-of-cylinders
dohc         four                5700.000000 -- 
             six                 5050.000000
dohcv        eight               5750.000000
l            four                4668.181818
             three               5100.000000
ohc          five                5081.818182
             four                5155.468750
             six                 4821.428571
ohcf         four                4775.000000
             six                 5900.000000
ohcv         eight               4625.000000
             six                 5212.500000
             twelve              5000.000000
rotor        two                 6000.000000
Name: peak-rpm, dtype: float64

Ein Vier-Zylinder-OHC-Motor hat demnach durchschnittlich einen Drehzahl-Peak von 5155 Umdrehungen pro Minute. Ohne nun (fahrlässigerweise) auf die Verteilung in dieser Klasse zu achten, nehmen wir einfach diesen Schätzwert, um die zwei fehlende Datenpunkte zu ersetzen.

Wir möchten jedoch die Original-Daten erhalten und legen ein neues DataSet (dataSet_c) an, in welches wir die Korrekturen vornehmen:

dataSet_c = dataSet.copy()   # das "c"-Anhängsel steht für "corrected"

Nun können wir die fehlenden Peak-RPM-Einträge mit unserem Schätzwert ersetzen:

dataSet_c.loc[dataSet_c['peak-rpm'] == '?', 'peak-rpm'] = 5155

Was bei einer Drehzahl-Angabe noch funktionieren mag, ist für anderen Spalten bereits etwas schwieriger: Die beiden Spalten ‘price’ und ‘horsepower’ sind ebenfalls vom Typ Object, da sie ‘?’ enthalten. Verzichten wir einfach auf die betroffenen Zeilen:

dataSet_c = dataSet_c[dataSet_c['price'] != '?']                    # entsprechende Zeilen herausfiltern
dataSet_c['price'] = dataSet_c['price'].astype(float)               # Typ-Konvertierung zu Float

dataSet_c = dataSet_c[dataSet_c.horsepower != '?']                  # entsprechende Zeilen herausfiltern
dataSet_c['horsepower'] = dataSet_c['horsepower'].astype(float)     # Typ-Konvertierung in Int

Datenvisualisierung mit Pandas

Wir wollen uns nicht lange vom eigentlichen Ziel ablenken, dennoch nutzen wir die Visualisierungsfähigkeiten der Pandas-Library (welche die Matplotlib inkludiert), um uns dann die Anzahlen an Einträgen nach Hersteller der Fahrzeuge (Spalte ‘make’) anzeigen zu lassen:

dataSet_grouped_make = dataSet_c.groupby('make')
dataSet_grouped_make['make'].count().plot(kind = 'bar', figsize = (10, 10))
plt.show()    # Besser jedes Plot abschließen! Auch wenn es in Pandas entstanden ist.

Oder die durchschnittliche PS-Zahl nach Hersteller:

(dataSet_c.groupby('make'))['horsepower'].mean().plot(kind = 'barh',
                                                      title = 'Mean Horsepower',
                                                      figsize = (10, 10))
plt.show()

Vorbereitung der Regressionsanalyse

Nun kommen wir endlich zur Regressionsanalyse, die wir mit Scikit-Learn umsetzen möchten. Die Regressionsanalyse können wir nur mit intervall- oder ratioskalierten Datenspalten betreiben, daher beschränken wir uns auf diese. Die “price”-Spalte nehmen wir jedoch heraus und setzen sie als unsere Zielgröße fest.

""" ----- Vorbereitung für die Regressionsanalyse ----- """
cols_ratio = ['horsepower', 'wheel-base', 'length', 'width', 'height', 'curb-weight', 'engine-size', 'compression-ratio', 'city-mpg', 'highway-mpg']
cols_target = ['price']

dataSet_ratio = dataSet_c.loc[:, cols_ratio]
dataSet_target = dataSet_c[cols_target]

Interessant ist zudem die Betrachtung vorab, wie die einzelnen nummerischen Attribute untereinander korrelieren. Dafür nehmen wir auch die ‘price’-Spalte wieder in die Betrachtung hinein und hinterlegen auch eine Farbskala mit dem Preis (höhere Preise, hellere Farben).

grr = pd.plotting.scatter_matrix(dataSet_c[cols_target + cols_ratio]
                                 ,c = dataSet_target
                                 ,figsize=(15, 15)
                                 ,marker = 'o'
                                 ,hist_kwds={'bins' : 20}
                                 ,s = 60
                                 ,alpha = 0.8)
plt.show()

Die lineare Korrelation ist hier sehr interessant, da wir auch nur eine lineare Regression beabsichtigen.

Wie man in dieser Scatter-Matrix recht gut erkennen kann, scheinen einige Größen-Paare nahezu perfekt zu korrelieren, andere nicht.

Korrelation…

  • …nahezu perfekt linear: highway-mpg vs city-mpg (mpg = Miles per Gallon)
  • … eher nicht gegeben: highway-mpg vs height
  • … nicht linear, dafür aber nicht-linear: highway-mpg vs price

Nun, wir wollen den Preis eines Fahrzeuges vorhersagen, wenn wir eine andere quantitative Größe gegeben haben. Auf den Preis bezogen, erscheint mir die Motorleistung (Horsepower) einigermaßen linear zu korrelieren. Versuchen wir hier die lineare Regression und setzen somit die Spalte ‘horsepower’ als X und ‘price’ als y fest.

X = dataSet_ratio[['horsepower']] # doppelte [], da eine Liste von Spalten zu übergeben ist
y = dataSet_c[cols_target]

Die gängige Konvention ist übrigens, X groß zu schreiben, weil hier auch mehrere x-Dimensionen enthalten sein dürfen (multivariate Regression). y hingegen, ist stets nur eine Zielgröße (eine Dimension).

Die lineare Regression ist ein überwachtes Verfahren des maschinellen Lernens, somit müssen wir unsere Prädiktionsergebnisse mit Test-Daten testen, die nicht für das Training verwendet werden dürfen. Scitkit-Learn (oder kurz: sklearn) bietet hierfür eine Funktion an, die uns das Aufteilen der Daten abnimmt:

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y,
                                                    test_size = 0.3,     # 70% der Daten für das Training
                                                    random_state = None) # bei Bedarf kann hier "dem Zufall auf die Sprünge geholfen" werden

Zu beachten ist dabei, dass die Daten vor dem Aufteilen in Trainings- und Testdaten gut zu durchmischen sind. Auch dies übernimmt die train_test_split-Funktion für uns, nur sollte man im Hinterkopf behalten, dass die Ergebnisse (auf Grund der Zufallsauswahl) nach jedem Durchlauf immer wieder etwas anders aussehen.

Lineare Regression mit Scikit-Learn

Nun kommen wir zur Durchführung der linearen Regression mit Scitkit-Learn, die sich in drei Zeilen trainieren lässt:

""" ----- Lineare Regressionsanalyse ------- """

from sklearn.linear_model import LinearRegression   # importieren der Klasse

lr = LinearRegression()                             # instanziieren der Klasse

lr.fit(X_train, y_train)                            # trainieren

Aber Vorsicht! Bevor wir eine Prädiktion durchführen, wollen wir festlegen, wie wir die Güte der Prädiktion bewerten wollen. Die gängigsten Messungen für eine lineare Regression sind der MSE und R².

MSE = \frac{\sum_{i=1}^n (y_i - \hat{y_i})^2}{n}

Ein großer MSE ist schlecht, ein kleiner gut.

R^2 = 1 - \frac{MSE}{Var(y)}= \frac{\frac{1}{n} \cdot \sum_{i=1}^n (y_i - \hat{y_i})^2}{\frac{1}{n} \cdot \sum_{i=1}^n (y_i - \hat{\mu_y})^2}

Ein kleines R² ist schlecht, ein großes R² gut. Ein R² = 1.0 wäre theoretisch perfekt (da der Fehler = 0.00 wäre), jedoch in der Praxis unmöglich, da dieser nur bei absolut perfekter Korrelation auftreten würde. Die Klasse LinearRegression hat eine R²-Messmethode implementiert (score(x, y)).

print('------ Lineare Regression -----')
print('Funktion via sklearn: y = %.3f * x + %.3f' % (lr.coef_[0], lr.intercept_))
print("Alpha: {}".format(lr.intercept_))
print("Beta: {}".format(lr.coef_[0]))
print("Training Set R² Score: {:.2f}".format(lr.score(X_train, y_train)))
print("Test Set R² Score: {:.2f}".format(lr.score(X_test, y_test)))
print("\n")

Die Ausgabe (ein Beispiel!):

------ Lineare Regression -----
Funktion via sklearn: y = 170.919 * x + -4254.701     # Die Funktion ist als y = 171 * x - 4254.7
Alpha: [-4254.70114803]                               # y-Achsenschnitt bei x = 0
Beta: [ 170.91919086]                                 # Steigung der Gerade
Training Set R² Score: 0.62                           
Test Set R² Score: 0.73

Nach jedem Durchlauf ändert sich mit der Datenaufteilung (train_test_split()) das Modell etwas und auch R² schwankt um eine gewisse Bandbreite. Berauschend sind die Ergebnisse dabei nicht, und wenn wir uns die Regressionsgerade einmal ansehen, wird auch klar, warum:

plt.figure(figsize=(10,10))
plt.scatter(X_train, y_train, color = 'blue')                 # Blaue Punkte sind Trainingsdaten
plt.scatter(X_test, y_test, color = 'green')                  # Grüne Punkte sind Testdaten
plt.plot(X_train, lr.predict(X_train), color = 'red')         # Hier ensteht die Gerade (x, y) = (x, lr.predict(x)
plt.xlabel(X_train.columns[0])
plt.ylabel(cols_target[0])
plt.show()

Bei kleineren Leistungsbereichen, etwa bis 100 PS, ist die Preis-Varianz noch annehmbar gering, doch bei höheren Leistungsbereichen ist die Spannweite deutlich größer. (Nachträgliche Anmerkung vom 06.05.2018: relativ betrachtet, bleibt der Fehler über alle Wertebereiche ungefähr gleich [relativer Fehler]. Die absoluten Fehlerwerte haben jedoch bei größeren x-Werten so eine Varianz der möglichen y-Werte, dass keine befriedigenden Prädiktionen zu erwarten sind.)

Egal wie wir eine Gerade in diese Punktwolke legen, wir werden keine befriedigende Fehlergröße erhalten.

Nehmen wir einmal eine andere Spalte für X, bei der wir vor allem eine nicht-lineare Korrelation erkannt haben: “highway-mpg”

X = dataSet_ratio[['highway-mpg']]
y = dataSet_c[cols_target]

Wenn wir dann das Training wiederholen:

------ Lineare Regression -----
Funktion via sklearn: y = -868.787 * x + 40575.036
Alpha: [ 40575.03556055]
Beta: [-868.7869183]
Training Set R² Score: 0.49
Test Set R² Score: 0.40

Die R²-Werte sind nicht gerade berauschend, und das erklärt sich auch leicht, wenn wir die Trainings- und Testdaten sowie die gelernte Funktionsgerade visualisieren:

Die Gerade lässt sich nicht wirklich gut durch diese Punktwolke legen, da letztere eher eine Kurve als eine Gerade bildet. Im Grunde könnte eine Gerade noch einigermaßen gut in den Bereich von 22 bis 43 mpg passen und vermutlich annehmbare Ergebnisse liefern. Die Wertebereiche darunter und darüber jedoch verzerren zu sehr und sorgen zudem dafür, dass die Gerade auch innerhalb des mittleren Bereiches zu weit nach oben verschoben ist (ggf. könnte hier eine Ridge-/Lasso-Regression helfen).

Richtig gute Vorhersagen über nicht-lineare Verhältnisse können jedoch nur mit einer nicht-linearen Regression erreicht werden.

Nicht-lineare Regression mit Scikit-Learn

Nicht-lineare Regressionsanalysen erlauben es uns, nicht-lineare korrelierende Werte-Paare als Funktion zu erlernen. Im folgenden Scatter-Plot sehen wir zum einen die gewohnte lineare Regressionsgerade (y = a * x + b) in rot, eine polinominale Regressionskurve dritten Grades (y = a * x³ + b * x² + c * x + d) in violet sowie einen Entscheidungsweg einer Entscheidungsbaum-Regression in gelb.

Nicht-lineare Regressionsanalysen passen sich dem Verlauf der Punktwolke sehr viel besser an und können somit in der Regel auch sehr gute Vorhersageergebnisse liefern. Ich ziehe hier nun jedoch einen Gedankenstrich, liefere aber den Quellcode für die lineare Regression als auch für die beiden nicht-linearen Regressionen mit:

Python Script Regression via Scikit-Learn

Weitere Anmerkungen

  • Bibliotheken wie Scitkit-Learn erlauben es, machinelle Lernverfahren schnell und unkompliziert anwenden zu können. Allerdings sollte man auch verstehen, wei diese Verfahren im Hintergrund mathematisch arbeiten. Diese Bibliotheken befreien uns also nicht gänzlich von der grauen Theorie.
  • Statt der “reinen” lineare Regression (LinearRegression()) können auch eine Ridge-Regression (Ridge()), Lasso-Regression (Lasso()) oder eine Kombination aus beiden als sogenannte ElasticNet-Regression (ElasticNet()). Bei diesen kann über Parametern gesteuert werden, wie stark Ausreißer in den Daten berücksichtigt werden sollen.
  • Vor einer Regression sollten die Werte skaliert werden, idealerweise durch Standardisierung der Werte (sklearn.preprocessing.StandardScaler()) oder durch Normierung (sklearn.preprocessing.Normalizer()).
  • Wir haben hier nur zwei-dimensional betrachtet. In der Praxis ist das jedoch selten ausreichend, auch der Fahrzeug-Preis ist weder von der Motor-Leistung, noch von dem Kraftstoffverbrauch alleine abhängig – Es nehmen viele Größen auf den Preis Einfluss, somit benötigen wir multivariate Regressionsanalysen.

Data Science Knowledge Stack – Was ein Data Scientist können muss

Was muss ein Data Scientist können? Diese Frage wurde bereits häufig gestellt und auch häufig beantwortet. In der Tat ist man sich mittlerweile recht einig darüber, welche Aufgaben ein Data Scientist für Aufgaben übernehmen kann und welche Fähigkeiten dafür notwendig sind. Ich möchte versuchen, diesen Konsens in eine Grafik zu bringen: Ein Schichten-Modell, ähnlich des OSI-Layer-Modells (welches übrigens auch jeder Data Scientist kennen sollte).
Ich gebe Einführungs-Seminare in Data Science für Kaufleute und Ingenieure und bei der Erläuterung, was wir in den Seminaren gemeinsam theoretisch und mit praxisnahen Übungen erarbeiten müssen, bin ich auf die Idee für dieses Schichten-Modell gekommen. Denn bei meinen Seminaren fängt es mit der Problemstellung bereits an, ich gebe nämlich Seminare für Data Science für Business Analytics mit Python. Also nicht beispielsweise für medizinische Analysen und auch nicht mit R oder Julia. Ich vermittle also nicht irgendein Data Science, sondern eine ganz bestimmte Richtung.

Ein Data Scientist muss bei jedem Data Science Vorhaben Probleme auf unterschiedlichsten Ebenen bewältigen, beispielsweise klappt der Datenzugriff nicht wie geplant oder die Daten haben eine andere Struktur als erwartet. Ein Data Scientist kann Stunden damit verbringen, seinen eigenen Quellcode zu debuggen oder sich in neue Data Science Pakete für seine ausgewählte Programmiersprache einzuarbeiten. Auch müssen die richtigen Algorithmen zur Datenauswertung ausgewählt, richtig parametrisiert und getestet werden, manchmal stellt sich dabei heraus, dass die ausgewählten Methoden nicht die optimalen waren. Letztendlich soll ein Mehrwert für den Fachbereich generiert werden und auch auf dieser Ebene wird ein Data Scientist vor besondere Herausforderungen gestellt.


english-flagRead this article in English:
“Data Science Knowledge Stack – Abstraction of the Data Scientist Skillset”


Data Science Knowledge Stack

Mit dem Data Science Knowledge Stack möchte ich einen strukturierten Einblick in die Aufgaben und Herausforderungen eines Data Scientists geben. Die Schichten des Stapels stellen zudem einen bidirektionalen Fluss dar, der von oben nach unten und von unten nach oben verläuft, denn Data Science als Disziplin ist ebenfalls bidirektional: Wir versuchen gestellte Fragen mit Daten zu beantworten oder wir schauen, welche Potenziale in den Daten liegen, um bisher nicht gestellte Fragen zu beantworten.

Der Data Science Knowledge Stack besteht aus sechs Schichten:

Database Technology Knowledge

Ein Data Scientist arbeitet im Schwerpunkt mit Daten und die liegen selten direkt in einer CSV-Datei strukturiert vor, sondern in der Regel in einer oder in mehreren Datenbanken, die ihren eigenen Regeln unterliegen. Insbesondere Geschäftsdaten, beispielsweise aus dem ERP- oder CRM-System, liegen in relationalen Datenbanken vor, oftmals von Microsoft, Oracle, SAP oder eine Open-Source-Alternative. Ein guter Data Scientist beherrscht nicht nur die Structured Query Language (SQL), sondern ist sich auch der Bedeutung relationaler Beziehungen bewusst, kennt also auch das Prinzip der Normalisierung.

Andere Arten von Datenbanken, sogenannte NoSQL-Datenbanken (Not only SQL)  beruhen auf Dateiformaten, einer Spalten- oder einer Graphenorientiertheit, wie beispielsweise MongoDB, Cassandra oder GraphDB. Einige dieser Datenbanken verwenden zum Datenzugriff eigene Programmiersprachen (z. B. JavaScript bei MongoDB oder die graphenorientierte Datenbank Neo4J hat eine eigene Sprache namens Cypher). Manche dieser Datenbanken bieten einen alternativen Zugriff über SQL (z. B. Hive für Hadoop).

Ein Data Scientist muss mit unterschiedlichen Datenbanksystemen zurechtkommen und mindestens SQL – den Quasi-Standard für Datenverarbeitung – sehr gut beherrschen.

Data Access & Transformation Knowledge

Liegen Daten in einer Datenbank vor, können Data Scientists einfache (und auch nicht so einfache) Analysen bereits direkt auf der Datenbank ausführen. Doch wie bekommen wir die Daten in unsere speziellen Analyse-Tools? Hierfür muss ein Data Scientist wissen, wie Daten aus der Datenbank exportiert werden können. Für einmalige Aktionen kann ein Export als CSV-Datei reichen, doch welche Trennzeichen und Textqualifier können verwendet werden? Eventuell ist der Export zu groß, so dass die Datei gesplittet werden muss.
Soll eine direkte und synchrone Datenanbindung zwischen dem Analyse-Tool und der Datenbank bestehen, kommen Schnittstellen wie REST, ODBC oder JDBC ins Spiel. Manchmal muss auch eine Socket-Verbindung hergestellt werden und das Prinzip einer Client-Server-Architektur sollte bekannt sein. Auch mit synchronen und asynchronen Verschlüsselungsverfahren sollte ein Data Scientist vertraut sein, denn nicht selten wird mit vertraulichen Daten gearbeitet und ein Mindeststandard an Sicherheit ist zumindest bei geschäftlichen Anwendungen stets einzuhalten.

Viele Daten liegen nicht strukturiert in einer Datenbank vor, sondern sind sogenannte unstrukturierte oder semi-strukturierte Daten aus Dokumenten oder aus Internetquellen. Auch hier haben wir es mit Schnittstellen zutun, ein häufiger Einstieg für Data Scientists stellt beispielsweise die Twitter-API dar. Manchmal wollen wir Daten in nahezu Echtzeit streamen, beispielsweise Maschinendaten. Dies kann recht anspruchsvoll sein, so das Data Streaming beinahe eine eigene Disziplin darstellt, mit der ein Data Scientist schnell in Berührung kommen kann.

Programming Language Knowledge

Programmiersprachen sind für Data Scientists Werkzeuge, um Daten zu verarbeiten und die Verarbeitung zu automatisieren. Data Scientists sind in der Regel keine richtigen Software-Entwickler, sie müssen sich nicht um Software-Sicherheit oder -Ergonomie kümmern. Ein gewisses Basiswissen über Software-Architekturen hilft jedoch oftmals, denn immerhin sollen manche Data Science Programme in eine IT-Landschaft integriert werden. Unverzichtbar ist hingegen das Verständnis für objektorientierte Programmierung und die gute Kenntnis der Syntax der ausgewählten Programmiersprachen, zumal nicht jede Programmiersprache für alle Vorhaben die sinnvollste ist.

Auf dem Level der Programmiersprache gibt es beim Arbeitsalltag eines Data Scientists bereits viele Fallstricke, die in der Programmiersprache selbst begründet sind, denn jede hat ihre eigenen Tücken und Details entscheiden darüber, ob eine Analyse richtig oder falsch abläuft: Beispielsweise ob Datenobjekte als Kopie oder als Referenz übergeben oder wie NULL-Werte behandelt werden.

Data Science Tool & Library Knowledge

Hat ein Data Scientist seine Daten erstmal in sein favorisiertes Tool geladen, beispielsweise in eines von IBM, SAS oder in eine Open-Source-Alternative wie Octave, fängt seine Kernarbeit gerade erst an. Diese Tools sind allerdings eher nicht selbsterklärend und auch deshalb gibt es ein vielfältiges Zertifizierungsangebot für diverse Data Science Tools. Viele (wenn nicht die meisten) Data Scientists arbeiten überwiegend direkt mit einer Programmiersprache, doch reicht diese alleine nicht aus, um effektiv statistische Datenanalysen oder Machine Learning zu betreiben: Wir verwenden Data Science Bibliotheken, also Pakete (Packages), die uns Datenstrukturen und Methoden als Vorgabe bereitstellen und die Programmiersprache somit erweitern, damit allerdings oftmals auch neue Tücken erzeugen. Eine solche Bibliothek, beispielsweise Scikit-Learn für Python, ist eine in der Programmiersprache umgesetzte Methodensammlung und somit ein Data Science Tool. Die Verwendung derartiger Bibliotheken will jedoch gelernt sein und erfordert für die zuverlässige Anwendung daher Einarbeitung und Praxiserfahrung.

Geht es um Big Data Analytics, also die Analyse von besonders großen Daten, betreten wir das Feld von Distributed Computing (Verteiltes Rechnen). Tools (bzw. Frameworks) wie Apache Hadoop, Apache Spark oder Apache Flink ermöglichen es, Daten zeitlich parallel auf mehren Servern zu verarbeiten und auszuwerten. Auch stellen diese Tools wiederum eigene Bibliotheken bereit, für Machine Learning z. B. Mahout, MLlib und FlinkML.

Data Science Method Knowledge

Ein Data Scientist ist nicht einfach nur ein Bediener von Tools, sondern er nutzt die Tools, um seine Analyse-Methoden auf Daten anzuwenden, die er für die festgelegten Ziele ausgewählt hat. Diese Analyse-Methoden sind beispielweise Auswertungen der beschreibenden Statistik, Schätzverfahren oder Hypothesen-Tests. Etwas mathematischer sind Verfahren des maschinellen Lernens zum Data Mining, beispielsweise Clusterung oder Dimensionsreduktion oder mehr in Richtung automatisierter Entscheidungsfindung durch Klassifikation oder Regression.

Maschinelle Lernverfahren funktionieren in der Regel nicht auf Anhieb, sie müssen unter Einsatz von Optimierungsverfahren, wie der Gradientenmethode, verbessert werden. Ein Data Scientist muss Unter- und Überanpassung erkennen können und er muss beweisen, dass die Vorhersageergebnisse für den geplanten Einsatz akkurat genug sind.

Spezielle Anwendungen bedingen spezielles Wissen, was beispielsweise für die Themengebiete der Bilderkennung (Visual Computing) oder der Verarbeitung von menschlicher Sprache (Natural Language Processiong) zutrifft. Spätestens an dieser Stelle öffnen wir die Tür zum Deep Learning.

Fachexpertise

Data Science ist kein Selbstzweck, sondern eine Disziplin, die Fragen aus anderen Fachgebieten mit Daten beantworten möchte. Aus diesem Grund ist Data Science so vielfältig. Betriebswirtschaftler brauchen Data Scientists, um Finanztransaktionen zu analysieren, beispielsweise um Betrugsszenarien zu erkennen oder um die Kundenbedürfnisse besser zu verstehen oder aber, um Lieferketten zu optimieren. Naturwissenschaftler wie Geologen, Biologen oder Experimental-Physiker nutzen ebenfalls Data Science, um ihre Beobachtungen mit dem Ziel der Erkenntnisgewinnung zu machen. Ingenieure möchten die Situation und Zusammenhänge von Maschinenanlagen oder Fahrzeugen besser verstehen und Mediziner interessieren sich für die bessere Diagnostik und Medikation bei ihren Patienten.

Damit ein Data Scientist einen bestimmten Fachbereich mit seinem Wissen über Daten, Tools und Analyse-Methoden ergebnisorientiert unterstützen kann, benötigt er selbst ein Mindestmaß an der entsprechenden Fachexpertise. Wer Analysen für Kaufleute, Ingenieure, Naturwissenschaftler, Mediziner, Juristen oder andere Interessenten machen möchte, muss eben jene Leute auch fachlich verstehen können.

Engere Data Science Definition

Während die Data Science Pioniere längst hochgradig spezialisierte Teams aufgebaut haben, suchen beispielsweise kleinere Unternehmen eher den Data Science Allrounder, der vom Zugriff auf die Datenbank bis hin zur Implementierung der analytischen Anwendung das volle Aufgabenspektrum unter Abstrichen beim Spezialwissen übernehmen kann. Unternehmen mit spezialisierten Daten-Experten unterscheiden jedoch längst in Data Scientists, Data Engineers und Business Analysts. Die Definition für Data Science und die Abgrenzung der Fähigkeiten, die ein Data Scientist haben sollte, schwankt daher zwischen der breiteren und einer engeren Abgrenzung.

Die engere Betrachtung sieht vor, dass ein Data Engineer die Datenbereitstellung übernimmt, der Data Scientist diese in seine Tools lädt und gemeinsam mit den Kollegen aus dem Fachbereich die Datenanalyse betreibt. Demnach bräuchte ein Data Scientist kein Wissen über Datenbanken oder APIs und auch die Fachexpertise wäre nicht notwendig…

In der beruflichen Praxis sieht Data Science meiner Erfahrung nach so nicht aus, das Aufgabenspektrum umfasst mehr als nur den Kernbereich. Dieser Irrtum entsteht in Data Science Kursen und auch in Seminaren – würde ich nicht oft genug auf das Gesamtbild hinweisen. In Kursen und Seminaren, die Data Science als Disziplin vermitteln wollen, wird sich selbstverständlich auf den Kernbereich fokussiert: Programmierung, Tools und Methoden aus der Mathematik & Statistik.

Entscheidungsbaum-Algorithmus ID3

Dieser Artikel ist Teil 2 von 4 der Artikelserie Maschinelles Lernen mit Entscheidungsbaumverfahren.

Entscheidungsbäume sind den Ingenieuren bestens bekannt, um Produkte hierarchisch zu zerlegen und um Verfahrensanweisungen zu erstellen. Die Data Scientists möchten ebenfalls Verfahrensanweisungen erstellen, jedoch automatisiert aus den Daten heraus. Auf diese Weise angewendet, sind Entscheidungsbäume eine Form des maschinellen Lernens: Die Maschine soll selbst einen Weg finden, um ein Objekt einer Klasse zuzuordnen.

Der ID3-Algorithmus

Den ID3-Algorithmus zu verstehen lohnt sich, denn er ist die Grundlage für viele weitere, auf ihn aufbauende Algorithmen. Er ist mit seiner iterativen und rekursiven Vorgehensweise auch recht leicht zu verstehen, er darf nur wiederum nicht in seiner Wirkung unterschätzt werden. Die Vorgehensweise kann in drei wesentlichen Schritten zerlegt werden, wobei der erste Schritt die eigentliche Wirkung (mit allen Vor- und Nachteilen) entfaltet:

  1. Schritt: Auswählen des Attributes mit dem höchsten Informationsgewinn
    Betrachte alle Attribute (Merkmale) des Datensatzes und bestimme, welches Attribut die Daten am besten klassifiziert.
  2. Schritt: Anlegen eines Knotenpunktes mit dem Attribut
    Sollten die Ergebnisse unter diesem Knoten eindeutig sein (1 unique value), speichere es in diesem Knotenpunkt und springe zurück.
  3. Schritt: Rekursive Fortführung dieses Prozesses
    Andernfalls zerlege die Daten jedem Attribut entsprechend in n Untermengens (subsets), und wiederhole diese Schritte für jede der Teilmengen.

Der Informationsgewinn (Information Gain) – und wie man ihn berechnet


Der Informationsgewinn eines Attributes (A) im Sinne des ID3-Algorithmus ist die Differenz aus der Entropie (E(S)) (siehe Teil 1 der Artikelserie: Entropie, ein Maß für die Unreinheit in Daten) des gesamten Datensatzes (S) und der Summe aus den gewichteten Entropien des Attributes für jeden einzelnen Wert (Value i), der im Attribut vorkommt:
IG(S, A) = E(S) - \sum_{i=1}^n \frac{\bigl|S_i\bigl|}{\bigl|S\bigl|} \cdot E(S_i)

Wie die Berechnung des Informationsgewinnes funktioniert, wird Teil 3 dieser Artikel-Reihe (erscheint in Kürze) zeigen.

Die Vorzüge des ID3-Algorithmus – und die Nachteile

Der Algorithmus ist die Grundlage für viele weitere Algorithmen. In seiner Einfachheit bringt er gewisse Vorteile – die ihn vermutlich zum verbreitesten Entscheidungsbaum-Algorithmus machen – mit sich, aber hat auch eine Reihe von Nachteilen, die bedacht werden sollten.

Vorteile Nachteile
  • leicht verständlich und somit schnell implementiert
  • stellt eine gute Basis für Random Forests dar
  • alle Attribute spielen eine Rolle, der Baum wird aber tendenziell klein, da der Informationsgewinn die Reihenfolge vorgibt
  • funktioniert (mit Anpassungen) auch für Mehrfachklassifikation
  • aus der Reihenfolge durch den Informationsgewinn entsteht nicht unbedingt der beste bzw. kleinste Baum unter allen Möglichkeiten. Es ist ein Greedy-Algorithmus und somit “kurzsichtig”
  • die Suche nach Entscheidungsregeln ist daher auch nicht vollständig/umfassend
  • da der Baum via ID3 solange weiterwachsen soll, bis die Daten so eindeutig wie möglich erklärt sind, wird Overfitting geradezu provoziert

Overfitting (Überanpassung) beachten und vermeiden

Aus Daten heraus generierte Entscheidungsbäume neigen zur Überanpassung. Das bedeutet, dass sich die Bäume den Trainingsdaten soweit anpassen können, dass sie auf diese perfekt passen, jedoch keine oder nur noch einen unzureichende generalisierende Beschreibung mehr haben. Neue Daten, die eine höhere Vielfältigkeit als die Trainingsdaten haben können, werden dann nicht mehr unter einer angemessenen Fehlerquote korrekt klassifiziert.

Vorsicht vor Key-Spalten!

Einige Attribute erzwingen eine Überanpassung regelrecht: Wenn beispielsweise ein Attribut wie „Kunden-ID“ (eindeutige Nummer pro Kunde) einbezogen wird, haben wir – bezogen auf das Klassifikationsergebnis – für jeden einzelnen Wert in dem Attribut eine Entropie von 0 zu erwarten, denn jeder ID beschreibt einen eindeutigen Fall (Kunde, Kundengruppe etc.). Daraus folgt, dass der Informationsgewinn für dieses Attribut maximal wird. Hier würde der Baum eine enorme Breite erhalten, die nicht hilfreich wäre, denn jeder Wert (IDs) bekäme einen einzelnen Ast im Baum, der zu einem eindeutigen Ergebnis führt. Auf neue Daten (neue Kundennummern) ist der Baum nicht anwendbar, denn er stellt keine generalisierende Beschreibung mehr dar, sondern ist nur noch ein Abbild der Trainingsdaten.

Prunning – Den Baum nachträglich kürzen

Besonders große Bäume sind keine guten Bäume und ein Zeichen für Überanpassung. Eine Möglichkeit zur Verkleinerung ist das erneute Durchrechnen der Informationsgewinne und das kürzen von Verzweigungen (Verallgemeinerung), sollte der Informationsgewinn zu gering sein. Oftmals wird hierfür nicht die Entropie oder der Gini-Koeffizient, sondern der Klassifikationsfehler als Maß für die Unreinheit verwendet.

Random Forests als Overfitting-Allheilmittel

Bei Random Forests (eine Form des Ensemble Learning) handelt es sich um eine Gemeinschaftsentscheidung der Klassenzugehörigkeit über mehrere Entscheidungsbäume. Diese Art des “demokratischen” Machine Learnings wird auch Ensemble Learning genannt. Werden mehrere Entscheidungsbäume unterschiedlicher Strukturierung zur gemeinsamen Klassifikation verwendet, wird die Wirkung des Overfittings einzelner Bäume in der Regel reduziert.

Überwachtes vs unüberwachtes maschinelles Lernen

Dies ist Artikel 1 von 4 aus der Artikelserie – Was ist eigentlich Machine Learning?

Der Unterschied zwischen überwachten und unüberwachtem Lernen ist für Einsteiger in das Gebiet des maschinellen Lernens recht verwirrend. Ich halte die Bezeichnung “überwacht” und “unüberwacht” auch gar nicht für besonders gut, denn eigentlich wird jeder Algorithmus (zumindest anfangs) vom Menschen überwacht. Es sollte besser in trainierte und untrainierte Verfahren unterschieden werden, die nämlich völlig unterschiedliche Zwecke bedienen sollen:

Während nämlich überwachte maschinelle Lernverfahren über eine Trainingsphase regelrecht auf ein (!) Problem abgerichtet werden und dann produktiv als Assistenzsystem (bis hin zum Automated Decision Making) funktionieren sollen, sind demgegenüber unüberwachte maschinelle Lernverfahren eine Methodik, um unübersichtlich viele Zeilen und Spalten von folglich sehr großen Datenbeständen für den Menschen leichter interpretierbar machen zu können (was nicht immer funktioniert).

Trainiere dir deinen Algorithmus mit überwachtem maschinellen Lernen

Wenn ein Modell anhand von mit dem Ergebnis (z. B. Klassifikationsgruppe) gekennzeichneter Trainingsdaten erlernt werden soll, handelt es sich um überwachtes Lernen. Die richtige Antwort muss während der Trainingsphase also vorliegen und der Algorithmus muss die Lücke zwischen dem Input (Eingabewerte) und dem Output (das vorgeschriebene Ergebnis) füllen.

Die Überwachung bezieht sich dabei nur auf die Trainingsdaten! Im produktiven Lauf wird grundsätzlich nicht überwacht (und das Lernen könnte sich auf neue Daten in eine ganz andere Richtung entwickeln, als dies mit den Trainingsdaten der Fall war). Die Trainingsdaten

Eine besondere Form des überwachten Lernens ist die des bestärkenden Lernens. Bestärkendes Lernen kommt stets dann zum Einsatz, wenn ein Endergebnis noch gar nicht bestimmbar ist, jedoch der Trend hin zum Erfolg oder Misserfolg erkennbar wird (beispielsweise im Spielverlauf – AlphaGo von Google Deepmind soll bestärkend trainiert worden sein). In der Trainingsphase werden beim bestärkenden Lernen die korrekten Ergebnisse also nicht zur Verfügung gestellt, jedoch wird jedes Ergebnis bewertet, ob dieses (wahrscheinlich) in die richtige oder falsche Richtung geht (Annäherungslernen).

Zu den überwachten Lernverfahren zählen alle Verfahren zur Regression oder Klassifikation, beispielsweise mit Algorithmen wir k-nearest-Neighbour, Random Forest, künstliche neuronale Netze, Support Vector Machines oder auch Verfahren der Dimensionsreduktion wie die lineare Diskriminanzanalyse.

Mit unüberwachtem Lernen verborgene Strukturen identifizieren

Beim unüberwachten Lernen haben wir es mit nicht mit gekennzeichneten Daten zu tun, die möglichen Antworten/Ergebnisse sind uns gänzlich unbekannt. Folglich können wir den Algorithmus nicht trainieren, indem wir ihm die Ergebnisse, auf die er kommen soll, im Rahmen einer Trainingsphase vorgeben (überwachtes Lernen), sondern wir nutzen Algorithmen, die die Struktur der Daten erkunden und für uns Menschen sinnvolle Informationen aus Ihnen bilden (oder auch nicht – denn häufig bleibt es beim Versuch, denn der Erfolg ist nicht garantiert!).Unüberwachte Verfahren des maschinellen Lernens dienen dem Data Mining, also der Erkennung von Inhalten in Daten anhand von sichtbar werdenden Strukturen. Die Verfahren müssen nicht unbedingt mit Datenvisualisierung arbeiten, oft ist das aber der Fall, denn erst die visuellen Strukturen ermöglichen unseren menschlichen Gehirnen die Daten in einen Kontext zu bringen. Mir sind zwei Kategorien des unüberwachten Lernens bekannt, zum einem das Clustering, welches im Grunde ein unüberwachtes Klassifikationsverfahren darstellt, und zum anderen die Dimensionsreduktion PCA (Hauptkomponentenanalyse). Es gibt allerdings noch andere Verfahren, die mir weniger vertraut sind, beispielsweise unüberwacht lernende künstliche neuronale Netze, die Rauschen lernen, um Daten von eben diesem Rauschen zu befreien.

Was ist eigentlich Machine Learning? Artikelserie

Machine Learning ist Technik und Mythos zugleich. Nachfolgend der Versuch einer verständlichen Erklärung, mit folgenden Artikeln:

Machine Learning ist nicht neu, aber innovativ!

Machine Learning oder maschinelles Lernen ist eine Bezeichnung, die dank industrieller Trends wie der Industrie 4.0, Smart Grid oder dem autonomen Fahrzeug zur neuen Blüte verhilft. Machine Learning ist nichts Neues und die Algorithmen sind teilweise mehrere Jahrzehnte alt. Dennoch ist Machine Learning ein Innovationsinstrument, denn während früher nur abstrakte Anwendungen, mit vornehmlich wissenschaftlichen Hintergrund, auf maschinellem Lernen setzten, finden entsprechende Algorithmen Einzug in alltägliche industrielle bzw. geschäftliche, medizinische und gesellschaftsorientierte Anwendungen. Machine Learning erhöht demnach sowohl unseren Lebensstandard als auch unsere Lebenserwartung!

Maschinelles Lernen vs künstliche Intelligenz

Künstliche Intelligenz (Artificial Intelligence) ist eine Bezeichnung, die in der Wissenschaft immer noch viel diskutiert wird. Wo beginnt künstliche Intelligenz, wann entsteht natürliche Intelligenz und was ist Intelligenz überhaupt? Wenn diese Wortkombination künstliche Intelligenz fällt, denken die meisten Zuhörer an Filme wie Terminator von James Cameron oder AI von Steven Spielberg. Diese Filme wecken Erwartungen (und Ängste), denen wir mir unseren selbstlernenden Systemen noch lange nicht gerecht werden können. Von künstlicher Intelligenz sollte als mit Bedacht gesprochen werden.

Maschinelles Lernen ist Teilgebiet der künstlichen Intelligenz und eine Sammlung von mathematischen Verfahren zur Mustererkennung, die entweder über generelle Prinzipien (das Finden von Gemeinsamkeiten oder relativen Abgrenzungen) funktioniert [unüberwachtes Lernen] oder durch das Bilden eines Algorithmus als Bindeglied zwischen Input und gewünschten Output aus Trainingsdaten heraus.

Machine Learning vs Deep Learning

Deep Learning ist eine spezielle Form des maschinellen Lernens, die vermutlich in den kommenden Jahren zum Standard werden wird. Gemeint sind damit künstliche neuronale Netze, manchmal auch verschachtelte “herkömmliche” Verfahren, die zum einen mehrere Ebenen bilden (verborgene Schichten eines neuronalen Netzes) zum anderen viel komplexere Zusammenhänge erlernen können, was den Begriff Deep Learning rechtfertigt.

Machine Learning vs Data Mining

Data Mining bezeichnet die Erkenntnisgewinnung aus bisher nicht oder nicht hinreichend erforschter Daten. Unüberwachte Verfahren des maschinellen Lernens, dazu gehören einige Verfahren aus dem Clustering und der Dimensionsreduktion, dienen explizit dem Zweck des Data Minings. Es sind Verfahren, die uns Menschen dabei helfen, vielfältige und große Datenmengen leichter interpretieren zu können. Machine Learning ermöglicht jedoch noch weit mehr als Data Mining.

Scikit-Learn Machine Learning Roadmap

Darstellung der vier Gebiete des Machine Learning: Die scikit-learn-Roadmap. Die Darstellung ist nicht vollständig, sondern umfasst nur die in scikit-learn implementierten Verfahren. Das Original-Bild ist interaktiv und zu finden auf scikit-learn.org

Unsupervised Learning in R: K-Means Clustering

Die Clusteranalyse ist ein gruppenbildendes Verfahren, mit dem Objekte Gruppen – sogenannten Clustern zuordnet werden. Die dem Cluster zugeordneten Objekte sollen möglichst homogen sein, wohingegen die Objekte, die unterschiedlichen Clustern zugeordnet werden möglichst heterogen sein sollen. Dieses Verfahren wird z.B. im Marketing bei der Zielgruppensegmentierung, um Angebote entsprechend anzupassen oder im User Experience Bereich zur Identifikation sog. Personas.

Es gibt in der Praxis eine Vielzahl von Cluster-Verfahren, eine der bekanntesten und gebräuchlichsten Verfahren ist das K-Means Clustering, ein sog. Partitionierendes Clusterverfahren. Das Ziel dabei ist es, den Datensatz in K Cluster zu unterteilen. Dabei werden zunächst K beliebige Punkte als Anfangszentren (sog. Zentroiden) ausgewählt und jedem dieser Punkte der Punkt zugeordnet, zu dessen Zentrum er die geringste Distanz hat. K-Means ist ein „harter“ Clusteralgorithmus, d.h. jede Beobachtung wird genau einem Cluster zugeordnet. Zur Berechnung existieren verschiedene Distanzmaße. Das gebräuchlichste Distanzmaß ist die quadrierte euklidische Distanz:

D^2 = \sum_{i=1}^{v}(x_i - y_i)^2

Nachdem jede Beobachtung einem Cluster zugeordnet wurde, wird das Clusterzentrum neu berechnet und die Punkte werden den neuen Clusterzentren erneut zugeordnet. Dieser Vorgang wird so lange durchgeführt bis die Clusterzentren stabil sind oder eine vorher bestimmte Anzahl an Iterationen durchlaufen sind.
Das komplette Vorgehen wird im Folgenden anhand eines künstlich erzeugten Testdatensatzes erläutert.

set.seed(123)
Alter <- c(24, 22, 28, 25, 41, 39, 35, 40, 62, 57, 60, 55)
Einkommen <- c(20000, 22000, 25000, 24000, 55000, 65000, 75000, 60000, 30000, 34000, 30000, 34000)
Daten <- as.data.frame(cbind(Alter, Einkommen))

Zunächst wird ein Testdatensatz mit den Variablen „Alter“ und „Einkommen“ erzeugt, der 12 Fälle enthält. Als Schritt des „Data preprocessing“ müssen zunächst beide Variablen standardisiert werden, da ansonsten die Variable „Alter“ die Clusterbildung zu stark beeinflusst.

DatenAlter <- scale(DatenAlter)
DatenEinkommen <- scale(DatenEinkommen)

Das Ganze geplottet:

plot(DatenAlter, DatenEinkommen, col = "blue", pch = 19,
     xlab = "Alter (scaled)",
     ylab = "Einkommen (scaled)",
     main = "Alter vs. Einkommen (scaled)")

Wie bereits eingangs erwähnt müssen Cluster innerhalb möglichst homogen und zu Objekten anderer Cluster möglichst heterogen sein. Ein Maß für die Homogenität die „Within Cluster Sums of Squares“ (WSS), ein Maß für die Heterogenität „Between Cluster Sums of Squares“ (BSS).

Diese sind beispielsweise für eine 3-Cluster-Lösung wie folgt:

KmeansObj <- kmeans(Daten, 3, nstart = 20)
KmeansObjwithinss # Within Cluster Sums of Squares (WSS) KmeansObjtotss # Between Cluster Sums of Suqares (BSS)

> KmeansObjwithinss # Within Cluster Sums of Squares (WSS) [1] 0.7056937 0.1281607 0.1792432 > KmeansObjtotss # Between Cluster Sums of Suqares (BSS)
[1] 22

Sollte man die Anzahl der Cluster nicht bereits kennen oder sind diese extern nicht vorgegeben, dann bietet es sich an, anhand des Verhältnisses von WSS und BSS die „optimale“ Clusteranzahl zu berechnen. Dafür wird zunächst ein leerer Vektor initialisiert, dessen Werte nachfolgend über die Schleife mit dem Verhältnis von WSS und WSS gefüllt werden. Dies lässt sich anschließend per „Screeplot“ visualisieren.

ratio <- vector()
for (k in 1:6) {
    KMeansObj <- kmeans(Daten, k, nstart = 20)
    ratio[k] <- KMeansObjtot.withinss / KMeansObjtotss
}
plot(ratio, type = "b",
     xlab = "Anzahl der Cluster",
     ylab = "Ratio WSS/BSS",
     main = "Screeplot für verschiedene Clusterlösungen",
col = "blue",  pch = 19)

Die „optimale“ Anzahl der Cluster zählt sich am Knick der Linie ablesen (auch Ellbow-Kriterium genannt). Alternativ kann man sich an dem Richtwert von 0.2 orientieren. Unterschreitet das Verhältnis von WSS und BSS diesen Wert, so hat man die beste Lösung gefunden. In diesem Beispiel ist sehr deutlich, dass eine 3-Cluster-Lösung am besten ist.

KmeansObj <- kmeans(Daten, centers = 3, nstart = 20)
plot(DatenAlter, DatenEinkommen, col = KmeansObjcluster, pch = 19, cex = 4,      xlab = "Alter (scaled)",      ylab = "Einkommen (scaled)",      main = "3-Cluster-Lösung") points(KmeansObjcenters, col = 1:3, pch = 3, cex = 5, lwd = 5)

Fazit: Mit K-Means Clustering lassen sich schnell und einfach Muster in Datensätzen erkennen, die, gerade wenn mehr als zwei Variablen geclustert werden, sonst verborgen blieben. K-Means ist allerdings anfällig gegenüber Ausreißern, da Ausreißer gerne als separate Cluster betrachtet werden. Ebenfalls problematisch sind Cluster, deren Struktur nicht kugelförmig ist. Dies ist vor der Durchführung der Clusteranalyse mittels explorativer Datenanalyse zu überprüfen.

Entropie – Und andere Maße für Unreinheit in Daten

Dieser Artikel ist Teil 1 von 4 der Artikelserie Maschinelles Lernen mit Entscheidungsbaumverfahren.

Hierarchische Klassifikationsmodelle, zu denen das Entscheidungsbaumverfahren (Decision Tree) zählt, zerlegen eine Datenmenge iterativ oder rekursiv mit dem Ziel, die Zielwerte (Klassen) im Rahmen des Lernens (Trainingsphase des überwachten Lernens) möglichst gut zu bereiningen, also eindeutige Klassenzuordnungen für bestimmte Eigenschaften in den Features zu erhalten. Die Zerlegung der Daten erfolgt über einen Informationsgewinn, der für die Klassifikation mit einem Maß der Unreinheit berechnet wird (im nächsten Artikel der Serie werden wir die Entropie berechnen!) Read more

Interview mit Prof. Dr. Kai Uwe Barthel über Data Science mit Deep Learning

Interview mit Prof. Dr. Barthel, Chief Visionary Officer der Pixolution GmbH in Berlin, über Funktion, Einsatz und Einstieg in künstliche neuronale Netze.

Prof. Kai Barthel ist Gründer und CVO der Pixolution GmbH, ein Unternehmen, das Deep Learning dazu einsetzt, Bilder über ihre Pixelinhalte automatisiert verstehen zu können. Darüber hinaus ist Prof. Barthel in der Forschung und Lehre für Medieninformatik und Visual Computing an der Hochschule für Technik und Wirtschaft in Berlin tätig.

Data Science Blog: Welcher Weg hat Sie zu einem führenden Experten für Deep Learning und zur Gründung der Pixolution GmbH geführt?

Im Prinzip bin ich über mein Interesse an elektronischen Musikinstrumenten auf den Weg zur Analyse von Bits und Bytes gekommen. Als Schüler war ich von den neuen Möglichkeiten der Klangerzeugung fasziniert. 1980, zwei Jahre vor meinem Abitur, baute ich einen eigenen Synthesizer, ohne wirklich zu verstehen, was ich dort eigentlich tat.

Daraufhin studierte ich Elektrotechnik mit Fokus auf Signalverarbeitung, blieb nach dem Diplom diesem Themenbereich treu und arbeitete als wissenschaftlicher Mitarbeiter an der TU Berlin, wo ich zum Thema Bildkompression promovierte.

In diesem Kontext bin ich auf MPEG-7 gestoßen und fand das Konzept sehr spannend.  MPEG-7 war im Gegensatz zu MPEG-1, 2 und 4 kein Kompressionsstandard für Video- oder Audiodaten, sondern die Idee bestand darin, Metadaten von Mediendateien zu erzeugen. Ich befasste mich mit der automatisierten Beschreibung von Bildern, ohne manuelle Verschlagwortung, allein auf Basis der Pixelwerte. Spätestens das war für mich der erste Schritt in Richtung maschinelles Lernen.

Unser erster Erfolg war das Programm ImageSorter, das wir im Jahr 2006 als Freeware veröffentlichten. Hiermit konnte man hunderte von Bildern visuell sortiert darstellen und somit gesuchte Bilder schneller finden. Wir bekamen rasch unerwartete Anfragen aus der Industrie, wie etwa von CEWE mit der Aufgabe, Bilder für Fotobücher automatisch zu sortieren. Aus diesem Bedarf heraus haben wir dann die Pixolution GmbH gegründet. Auch Mauritius Images, eine der ältesten Bildagenturen Deutschlands, hatte unseren Algorithmus eingesetzt, mit dem die Ergebnisse einer Bildsuche inhaltsbasiert sortiert präsentiert wurden und somit die Nutzer in die Lage versetzten, mehrere hundert Bilder gleichzeitig zu erfassen.

Data Science Blog: Im Gegensatz zu anderen Anbietern künstlicher Intelligenz, befassen Sie sich nicht nur mit der einfachen Klassifikation von Bildern, sondern Sie verwenden Deep Learning, um dem Computer ein generelles Verständnis von Bildern zu verleihen.

Deep Learning ist ein Mittel zum Zweck, womit sich viele Aufgaben lösen lassen. Heute analysieren wir Bilder automatisiert über künstliche neuronale Netze, da diese in den letzten Jahren enorm an Reife hinzugewonnen haben. Hiermit lassen sich neben der Klassifikation „was ist der Inhalt eines Bildes?“ eine Reihe weiterer Aufgaben lösen. Hierzu gehört neben der automatischen Verschlagwortung unbekannter Bilder, das Finden ähnlicher Bilder, die Detektion von Duplikaten im Datenbestand, aber auch die Beantwortung sehr spezifischer Fragestellungen, wie etwa nach der Qualität, der Stimmung oder dem Stil eines Bildes. Einige Beispiele sind auf unserer Webseite http://www.visual-computing.com  zu finden. Natürlich lässt sich Deep-Learning auch auf andere Datentypen anwenden. Das kennen wir alle von Sprachassistenten wie Siri oder Email-Spamfiltern etc.

Unser Hauptprodukt bei Pixolution ist ein Plugin für Solr, womit wir ein klassisches Dokumentensuchsystem in die Lage versetzen, auch Bilder (z.B. von Agentur- oder Produktdatenbanken) gleichzeitig nach konventionellen Metadaten und visuellen/inhaltlichen Kriterien durchsuchbar zu machen. Dafür müssen die Bilder von der Maschine „verstanden“ werden.

Data Science Blog: Was bedeutet Deep Learning denn eigentlich im Kontrast zu Machine Learning? Wo beginnt Deep Learning und – als obligatorische Frage – ist Deep Learning ein überzogenes Buzzword?

Machine Learning ist im Prinzip der Oberbegriff aller Verfahren, bei denen Computer zu einer bestimmten Fragestellung selber den Algorithmus zur Lösung generieren können. Heute wird der Begriff „Machine Learning“ sicherlich etwas verschwenderisch verwendet. Zum Teil werden oft schon einfachere Verfahren wie beispielsweise Decision Trees oder K-means-Clustering als Machine Learning „verkauft“. Das eigentliche Machine Learning verwendet unterschiedliche Arten künstlicher neuronaler Netze. Einfache Aufgaben lassen sich mit kleinen neuronalen Netzen mit zwei bis vier Schichten lösen, dies reicht beispielsweise für die Erkennung von handschriftlichen Ziffern.

Deep Learning verwendet neuronale Netze mit deutlich mehr Schichten (bis hin zu Hunderten). Erst mit diesen vielen Schichten, die insgesamt Tausende bis Millionen von Netzwerkgewichten (zu lernende Parameter) haben, werden Lösungen für wirklich komplexe Aufgaben möglich.

Deep Learning ist ein Unterbereich von Machine Learning. Für mich ist Deep Learning kein Buzzword, denn die Lösungsmöglichkeiten von komplexen Aufgaben sind tiefgreifend. Es hat sich in den letzten Jahren einiges getan, so dass wirklich hochkomplizierte Aufgaben lösbar geworden sind.

Data Science Blog: Deep Learning gilt allerdings auch als Blackbox. Für den Menschen nachvollziehbare Entscheidungen von der Maschine sind somit nicht mehr möglich. Wie nachteilig wirkt sich das auf den Einsatz aus?

Die einzelnen Bestandteile eines künstlichen neuronalen Netzes sind recht simpel. Aus diesen elementaren Teilen werden neue Lösungsmodelle zusammengesetzt. Die Summe dieser Bestandteile und deren Interaktion wird jedoch schnell sehr hoch, so dass die Netze tatsächlich nicht mehr detailliert nachvollziehbar sind. Es stimmt also, dass künstliche neuronale Netze ab einer gewissen Größe zur Blackbox werden. Und es gibt auch Beispiele, mit denen solche Netze in die Irre geführt werden können. Nichtsdestotrotz liefern diese Netze die besten Ergebnisse, so dass dieser Nachteil in Kauf genommen wird – denn was wären die Alternativen?  Gerade im Bereich der Analyse und der Visualisierung der Funktionsweise von neuronalen Netzen gibt es viele Forschungsansätze, die das Verständnis mittelfristig deutlich verbessern werden. In vielen Bereichen sind die Klassifikationsergebnisse, die mit ausreichend vielen Beispielen trainiert wurden, besser als menschliche Experten. Hinzu kommt, dass menschliche Experten oft auch nicht genau begründen können, warum Sie zu einer bestimmten Eischätzung kommen, letztlich gleichen sie eine konkrete Fragestellung mit ihren umfangreichen Erfahrungen ab, was eine recht ähnliche Herangehensweise ist.

Data Science Blog: Welche Anwendungsszenarien für künstliche neuronale Netze gibt es?

Eine häufig verwendete Definition dessen, was Deep Learning an Aufgaben bewältigen kann, lautet: Es sind die Aufgaben, die ein Mensch in einer Sekunde lösen kann, ohne darüber nachdenken zu müssen. Wir können ein Netz darauf trainieren und es auf eine Aufgabe sozusagen „abrichten“. Im Unternehmen können künstliche neuronale Netze z. B. auffällige Verhaltensweisen von Maschinen identifizieren. Für mich geht es im Wesentlichen darum, der Maschine beizubringen, Bilder zu verstehen.

Das Verständnis von akustischen Signalen und Bildern ist schon lange ein Ziel der Informatik, es wird jedoch erst seit kurzem in zufriedenstellendem Ausmaß erreicht. Mit künstlichen neuronalen Netzen können Bilder vom Computer analysiert und Aussagen über ihre Inhalte gemacht werden. In den ersten Terminator-Filmen mit Arnold Schwarzenegger war es noch Science Fiction, dass die Welt aus Kamerabildern heraus analysiert und verstanden wurde. Inzwischen ist dies möglich. Was sicherlich noch eine Weile dauern wird, sind die Lösungen von Aufgaben, die eine zeitliche Planung oder ein strategisches Vorgehen benötigen.

Data Science Blog: Für welche Anwendungen in der Industrie ist Deep Learning schon gegenwärtig nutzbar?

Als Beispiel sei hier die industrielle Bildverarbeitung genannt. Bis vor kurzem war dies eine Sequenz von fein abgestimmten Schritten, wobei mit genau vordefinierten Bedingungen, wie etwa dem Bildhintergrund und einer bestimmten Beleuchtung, gearbeitet wurde. Dann wurde von einem Bildverarbeitungsexperten eine Kaskade von speziellen Bildverarbeitungsalgorithmen aufgesetzt, die das spezifische Problem lösten. Dies Prinzip hat meist sehr gut funktioniert, aber diese Ansätze ließen sich nicht gut generalisieren und mussten für jedes neue Problem wieder neu angepasst werden.

Beim Deep Learning ist die Situation eine ganz andere. Hier geht es darum, genügend Beispiele an Bildern und den dazugehörigen Ergebnissen zu haben. Das System lernt dann alleine, wie aus den Bildern bzw. Pixeln mit welchen Operationen die gewünschten Ergebnisse vorhergesagt werden können.

Für jeden, dem das noch zu abstrakt ist: Auch sehr spezifische Aufgaben aus der Industrie können mit neuronalen Netzen bewältigt werden. In der Fertigung und Montage können z.B. Nachfüllbehälter für Schrauben mit Kameras ausgestattet werden. Die Algorithmen erkennen dann über die Kamerabilder nicht nur zuverlässig, ob sich noch genügend viele Schrauben im Behälter befinden, sondern z. B. auch, um welche Schrauben es sich genau handelt.

Letztendlich spielt Deep Learning gerade in vielen Industrieanwendungen eine Rolle, so auch in der Spracherkennung oder dem Konzept des autonomen Fahrens. Das Hauptproblem beim Deep Learning ist nicht so sehr die Frage nach dem optimalen Netzwerk, sondern es besteht eher darin, genügend gute Beispiele zu haben, anhand derer die Netzwerke dann trainiert werden können.

Data Science Blog: Welche Entwicklungen der vergangenen Jahre ermöglichten die enormen Erfolge in Sachen Deep Learning?

Deep Learning wird in der Regel nicht mit CPUs, der zentralen Recheneinheit eines Computers, durchgeführt, sondern über GPUs, also speziell für Grafikberechnung ausgelegte Prozessoren – übrigens auch dann, wenn keine Bilder sondern andere Daten analysiert werden sollen. GPUs sind spezialisiert auf die Berechnung von Fließkommazahlen und können Matrizenmultiplikationen parallelisieren und somit etliche Male schneller als die CPU durchführen. Die heutige Hardware ermöglicht die notwendige Rechenleistung für künstliche neuronale Netze bereitzustellen.

Zum anderen benötigen Deep Learning Algorithmen sehr große Mengen an Trainingsdaten. Um ein neuronales Netz auf Bilder zu trainieren, um beispielsweise Katzen von Hunden zu unterscheiden, braucht es tausende Bilder mit Katzen und Hunden aus unterschiedlichen Perspektiven, Farben und Formen. Wir profitieren davon, dass sich diverse Menschen die Mühe gemacht haben, Millionen von Beispielbildern exakt zu beschriften und der Wissenschaft für das Training zur Verfügung zu stellen.

Data Science Blog: Was hat sich denn seitens der Algorithmen getan? Es heißt, dass die Backpropagation als Lernmethodik der große Clou bei neuronalen Netzen sei?

Backpropagation ist ein Lernverfahren für neuronale Netze, mit dem sich Aufgaben lösen lassen, bei denen die, zu den Eingangsdaten gehörigen/gewünschten Ergebnisse bekannt sind (supervised learning). Nach jedem Durchlauf der Daten durch das Netzwerk (Forward-Pass) gibt es einen Fehler im Endergebnis. Das Backpropagation-Verfahren arbeitet auf Basis der Gradientenabstiegsmethode und passt sukzessive die Netzwerkgewichte so an, dass der Fehler kleiner wird.

Eigentlich ist das Backpropagation-Verfahren ist schon recht lange bekannt. Neben der Beschleunigung der Computer und der Verfügbarkeit geeigneter Trainingsdaten, gab es jedoch erst in den letzten Jahren die notwendigen algorithmischen Fortschritte, mit denen es möglich wurde, auch extrem großen Netzwerke erfolgreich zu trainieren. Hier sind die Convolutional Netzwerke zu nennen, die insbesondere das Verstehen von Bildern (aber auch andere hochkomplexe Problemstellungen) erst möglich machten. Convolutional Netzwerke verwenden nicht für jeden Pixel ein individuelles Gewicht. Vielmehr wird ein Satz von zu erlernenden Filtern mit verhältnismäßig wenig Parametern/Gewichten verwendet. Jede Filterung erzeugt ein neues Bild, Pooling-Verfahren reduzieren die Auflösung dieser neu erzeugten Bilder, indem nur besonders aktive Neuronen beibehalten werden. Durch diese beiden Maßnahmen lässt sich die Zahl der Netzwerkgewichte gegenüber vollvernetzten Netzwerken deutlich reduzieren und ein erfolgreiches Netzwerktraining auch mit begrenzten Mengen an Beispieldaten erzielen.

Data Science Blog: Wie kann man sich denn vorstellen, wie so ein künstliches neuronales Netz funktioniert?

Die Grundidee ist an die biologischen Arbeitsweise im Gehirn angelehnt. Schichten von Neuronen erkennen bestimmte Muster. Auf den ersten Schichten sind dies zunächst einfache Strukturen wie Ecken, Kanten oder Farbübergänge. Die Neuronen führen also eine Funktion/Filterung aus, die jeden Eingabewert mit einer bestimmten Gewichtung multipliziert und diese Teilergebnisse aufsummiert. Eine nicht-lineare Funktion erzeugt hieraus einen Aktivierungswert, den Output, der angibt, ob ein entsprechendes Muster vorliegt. Dieser Output ist dann wiederum der Input für die nächste Netzwerkschicht ist. In den nächsten Schichten werden die einfachen Strukturen dann zu komplizierteren Mustern zusammengesetzt. Viele Linien aus unterschiedlichen Teilmustern ergeben beispielsweise Gitter, zwei senkrechte Linien ein Kreuz, usw. Letztlich lernen die Netzwerke aus allen möglichen Konstellationen der Eingangsdaten diejenigen Kombinationen, die in realen Daten/Bildern auftreten. Auf den letzten Schichten werden dann komplexere Muster erkannt, etwa mehrere Kreise und Konturlinien, die in einer bestimmten Anordnung beispielsweise ein menschliches Gesicht darstellen. Soll das künstliche neuronale Netz dieses Muster erkennen können, rechnen wir über die Backpropagation die Gewichtungen aus, die anhand der Beispielbilder – manche zeigen ein menschliches Gesicht, andere nicht – den kleinstmöglichen Klassifizierungsfehler erzeugen. Es wird beim Trainieren eines neuronalen Netzes also eine Funktion ermittelt, die den Input (die Bilddaten) auf den entsprechend Output (die korrekte Kategorie des Bildes) abbildet.

Data Science Blog: Was würden Sie Data Scientists raten, die in Deep Learning einsteigen möchten? Wie bewältigt man den Einstieg?

Ich würde nicht direkt ins Deep Learning einsteigen, sondern sicher erstmal versuchen, mich mit allgemeinen Methoden des maschinellen Lernens vertraut zu machen. Hierzu gehören Techniken wie das Clustering oder lineare/logistische Regression. Ich denke, dass jeder, der in diesen Bereich einsteigen will, wirklich einmal selber ein einfachstes Netzwerk (z.B. XOR und darüber hinaus) per Hand programmiert haben sollte. Hierfür können Tools wie MATLAB oder Octave verwendet werden. Erst im Anschluss, wenn man grundlegenden Kenntnisse erlangt hat, können Frameworks wie z.B. TensorFlow verwendet werden, was den Vorteil hat, dass einem die Bestimmung der mathematischen Ableitungen der Netzwerkstrukturen abgenommen wird. Dann lassen sich auch bestehende Lösungen besser nachvollziehen bzw. anpassen, um das Rad für den produktiven Lauf nicht noch einmal neuerfinden zu müssen, sondern die gewünschten Implementierungen ohne Umwege direkt angehen zu können.

Der Blick für das Wesentliche: Die Merkmalsselektion

In vielen Wissensbasen werden Datensätze durch sehr große Merkmalsräume beschrieben. Während der Generierung einer Wissensbasis wird versucht jedes mögliche Merkmal zu erfassen, um einen Datensatz möglichst genau zu beschreiben. Dabei muss aber nicht jedes Merkmal einen nachhaltigen Wert für das Predictive Modelling darstellen. Ein Klassifikator arbeitet mit reduziertem Merkmalsraum nicht nur schneller, sondern in der Regel auch weitaus effizienter. Oftmals erweist sich ein automatischer Ansatz der Merkmalsselektion besser, als ein manueller, da durchaus Zusammenhänge existieren können, die wir selbst so nicht identifizieren können.

Die Theorie: Merkmalsselektion

Automatische Merkmalsselektionsverfahren unterscheiden 3 verschiedene Arten: Filter, Wrapper und Embedded Methods. Einen guten Überblick über Filter- und Wrapper-Verfahren bieten Kumari et al. in ihrer Arbeit “Filter versus wrapper feature subset selection in large dimensionality micro array: A review” (Download als PDF).

Der Filter-Ansatz bewertet die Merkmale unabhängig des Klassifikators. Dabei werden univariate und multivariate Methoden unterschieden. Univariate Methoden bewerten die Merkmale separat, während der multivariate Ansatz mehrere Merkmale kombiniert. Für jedes Merkmal bzw. jedes Merkmalspaar wird ein statistischer Wert berechnet, der die Eignung der Merkmale für die Klassifikation angibt. Mithilfe eines Schwellwertes werden dann geeignete Merkmale herausgefiltert. Der Filter-Ansatz bietet eine schnelle und, aufgrund der geringen Komplexität, leicht skalierbare Lösung für die Merkmalsselektion. Der Nachteil von Filter-Selektoren besteht in der Missachtung der Abhängigkeiten zwischen den Merkmalen. So werden redundante Merkmale ähnlich bewertet und verzerren später die Erfolgsrate des Klassifikators. Bekannte Beispiele für Filter-Selektoren sind unter anderem die Euklidische Distanz und der Chi-2-Test.

Der Wrapper-Ansatz verbindet die Merkmalsbewertung mit einem Klassifikator. Innerhalb des Merkmalsraumes werden verschiedene Teilmengen von Merkmalen generiert und mithilfe eines trainierten Klassifikators getestet. Um alle möglichen Teilmengen des Merkmalsraumes zu identifizieren, wird der Klassifikator mit einem Suchalgorithmus kombiniert. Da der Merkmalsraum mit Zunahme der Anzahl der Merkmale exponentiell steigt, werden heuristische Suchmethoden für die Suche nach optimalen Teilmengen genutzt. Im Gegensatz zu den Filtern können hier redundante Merkmale abgefangen werden. Die Nutzung eines Klassifikators zur Bewertung der Teilmengen ist zugleich Vor- und Nachteil. Da die generierte Teilmenge auf einen speziellen Klassifikator zugeschnitten wird, ist nicht gewährleistet, dass die Menge auch für andere Klassifikatoren optimal ist. Somit ist dieser Ansatz zumeist abhängig vom gewählten Klassifikator. Zudem benötigt der Wrapper-Ansatz eine viel höhere Rechenzeit. Wrapper-Selektoren werden beispielsweise durch Genetische Algorithmen und Sequentielle Forward/Backward-Selektoren vertreten.

Embedded-Ansätze stellen eine Sonderform der Wrapper-Methode da. Allerdings werden Merkmalssuche und Klassifikatoren-Training nicht getrennt. Die Suche der optimalen Teilmenge ist hier im Modelltraining eingebettet. Dadurch liefern Embedded-Ansätze die gleichen Vorteile wie die Wrapper-Methoden, während die Rechenzeit dabei erheblich gesenkt werden kann. Der reduzierte Merkmalsraum ist aber auch hier vom jeweiligen Klassifikator abhängig. Klassifikatoren, die den Embedded-Ansatz ermöglichen sind beispielsweise der Random-Forest oder die Support-Vector-Maschine.

Entwicklungsgrundlage

Analog zum letzten Tutorial wird hier Python(x,y) und die Datenbasis „Human Activity Recognition Using Smartphones“ genutzt. Die Datenbasis beruht auf erfassten Sensordaten eines Smartphones während speziellen menschlichen Aktivitäten: Laufen, Treppen hinaufsteigen, Treppen herabsteigen, Sitzen, Stehen und Liegen. Auf den Aufzeichnungen von Gyroskop und Accelerometer wurden mehrere Merkmale erhoben. Die Datenmenge, alle zugehörigen Daten und die Beschreibung der Daten sind frei verfügbar.

(https://archive.ics.uci.edu/ml/datasets/Human+Activity+Recognition+Using+Smartphones)

Alle Daten liegen im Textformat vor. Für ein effizienteres Arbeiten mit der Datenbasis wurden diese im Vorfeld in das csv-Dateiformat überführt.

Python-Bibliotheken

Alle für das Data Mining relevanten Bibliotheken sind in Python(x,y) bereits enthalten. Für die Umsetzung werden folgende Bibliotheken genutzt:

import numpy as np
import pandas as pd

from sklearn.cross_validation import StratifiedKFold
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_selection import f_classif, RFECV, SelectKBest
from sklearn.svm import SVC

Die Bibliotheken NumPy und Pandas unterstützen die Arbeit mit verschiedenen Datenstrukturen und scikit-learn umfasst alle Funktionen des maschinellen Lernens.

Daten vorbereiten

Vor der Anwendung der einzelnen Verfahren werden die Daten vorbereitet. Das Data Frame wird eingelesen, die Klassen in numerische Labels überführt und das Datenfeld in Merkmale (X) und Klassenspalte (y) separiert. Weiterhin wird die informationslose Spalte subject entfernt.

index = 0
selected_features = []

# reading database
data = pd.read_csv("data/measures.csv", sep = ';', decimal = ',')

# converting textual class labels to numeric classes like description
data = data.replace({'WALKING': 1, 'WALKING_UPSTAIRS': 2, 'WALKING_DOWNSTAIRS': 3,
              'SITTING': 4, 'STANDING': 5, 'LAYING': 6})

# drop subject column
data = data.drop('subject', 1)

# remove class column from data set
print "removing class column from training set.."
X = data.drop('activity', 1)
y = data['activity']

columns = X.columns.values.tolist()

1. Verfahren: RFECV

Der RFECV (Recursive Feature Elimination with Cross Validation) ist ein Vertreter des Wrapper-Ansatzes. In diesem Beispiel wird die Merkmalsselektion mit einem Support Vector Klassifikator kombiniert. Der RFECV berechnet ein Ranking über die einzelnen Merkmale. Dabei bestimmt der Selektor selbst die optimale Menge der Merkmale. Alle Merkmale mit Platz 1 im Ranking bilden den optimalen Merkmalsraum.

''' ########## METHOD 1: RFE with cross validation and SVC ########## '''
print "create classifier for feature selection.."
svc = SVC(kernel = 'linear')

# fit the feature selector
print "create the feature selector.."
rfecv = RFECV(estimator = svc, step = 1, cv = StratifiedKFold(y, 3), scoring = 'accuracy')
print "fit the selector for data set.."
rfecv.fit(X, y)

print "The estimated number of optimal features is: " + str(rfecv.n_features_)

# get the most importent features
feat_importence = zip(rfecv.ranking_, columns)

# prepare list of selected features for new DataFrame
for i in range(len(feat_importence)):
    if(feat_importence[i][0] == 1):#>= np.nanmean(rfecv.ranking_)):
        selected_features.append(feat_importence[i][1])
        print "added feature: " + str(feat_importence[i][1]) + ".."

2. Verfahren: Random Forest-Klassifikator

Der Random-Forest-Klassifikator gehört zu den Modellen, die einen Embedded-Ansatz ermöglichen. Während des Klassifikatoren-Trainings wird jedem Merkmal ein Wert zugeordnet. Je höher der Wert, desto bedeutsamer das Merkmal. Allerdings ist hier eine manuelle Filterung notwendig, da anders als beim RFECV kein internes Optimum ermittelt wird. Mithilfe eines geeigneten Schwellwertes können die zu wählenden Merkmale bestimmt werden. In diesem Beispiel werden alle Merkmale selektiert, die eine Wichtung größer dem Mittelwert erhalten.

''' ########## METHOD 2: Random Forrest Classifier Feat Importance ########## '''
print "create classifier for feature selection.."
rfc = RandomForestClassifier(n_estimators = 500, criterion = 'entropy', max_depth = 4)
rfc = rfc.fit(X, y)

# get the most importent features
feat_importence = zip(rfc.feature_importances_, columns)

# prepare list of selected features for new DataFrame
for i in range(len(feat_importence)):
    if(feat_importence[i][0] >= np.mean(rfc.feature_importances_)):
        selected_features.append(feat_importence[i][1])
        print "added feature: " + str(feat_importence[i][1]) + ".."

3. Verfahren: Select K Best

Das Select K Best-Verfahren gehört den Filter-Ansätzen an. Daher kommt hier anders als bei den anderen beiden Verfahren kein Klassifikator zum Einsatz. Auch in diesem Verfahren wird für jedes Merkmal ein Wert berechnet, der die Wichtigkeit des Merkmals beziffert. Für die Berechnung der Werte können verschiedene Methoden verwendet werden. In diesem Beispiel wird eine Varianzanalyse genutzt (Parameter f_classif). Auch hier wird mithilfe eines manuellen Schwellwertes der reduzierte Merkmalsraum bestimmt.

''' ########## METHOD 3: Select K Best Features ########## '''
print "create classifier for feature selection.."
skb = SelectKBest(f_classif)
skb = skb.fit(X, y)

# get the most importent features
feat_importence = zip(skb.scores_, columns)

# prepare list of selected features for new DataFrame
for i in range(len(feat_importence)):
    if(feat_importence[i][0] >= np.nanmean(skb.scores_)):
        selected_features.append(feat_importence[i][1])
        print "added feature: " + str(feat_importence[i][1]) + ".."

Ergebnisse

Für die Bewertung der einzelnen Selektionsverfahren werden die einzelnen Verfahren in den Data-Mining-Prozess (siehe vorheriges Tutorial: Einstieg in das maschinelle Lernen mit Python(x,y)) integriert. Die nachfolgende Tabelle veranschaulicht die Ergebnisse der Klassifikation der einzelnen Verfahren.

 

Selektionsverfahren

Anzahl der Merkmale

Erfolgsrate Klassifikation

Ohne

561

93,96%

RFECV

314

94,03%

Random Forest

118

90,43%

Select K Best

186

92,30%

 

Durch den RFECV konnte das Ergebnis der Klassifikation leicht verbessert werden. Die anderen Selektionsverfahren, die auch deutlich weniger Merkmale nutzen, verschlechtern das Ergebnis sogar. Dies liegt vor allem an der manuellen Regulierung des Schwellwertes.