Notebooks
Gerade im Bereich Machine Learning führen wir oft interaktiv eine Reihe von Codeschnipseln aus, um z.B. einen Datensatz besser zu verstehen oder schnell eine andere Lernstrategie auszuprobieren. Sogenannte Notebooks erlauben uns genau das zusammen mit der Möglichkeit, so ein Notebook auch leicht teilen zu können und damit andere an unseren Ergebnissen partizipieren zu lassen.
In einem Notebook kannst du Texte und Grafiken mit Codeschnipseln mischen. Das Besondere dabei ist, dass diese Codeschnipsel wirklich ausführbar sind. Dabei wird der Code nicht notwendigerweise auf dem Rechner ausgeführt, auf dem das Ergebnis im Browser angezeigt wird. In unserem Beispiel hier wird der Code auf einem Rechner von Google ausgeführt, auf dem auch sämtliche Software installiert ist. Die Ausgabe erfolgt aber in dem Browser auf deinem Rechner, auf dem außer dem Browser nichts weiter installiert sein muss.
Im einfachsten Fall kannst du dir so ein Notebook einfach nur ansehen, ohne es überhaupt auszuführen. Das geht, weil so ein Notebook auch jedes Ergebnis, inklusive Bildern, eines Codeschnipsels speichert.
Mehr Informationen zu Notebooks findest du unter http://jupyter.org/.
Unser Beispiel: Irisblüten
Als Beispiel nehmen wir den Irisdatensatz, der dir im Buch immer wieder begegnen wird (siehe auch den Kasten auf der nächsten Seite). Es geht darum, anhand von vier Eigenschaften der Irisblüten (Features) drei unterschiedliche Irisarten voneinander zu unterscheiden. Features sind die zu einem Datensatz gehörigen Eingaben, Labels sind die zugehörigen Ausgaben. Diese Ausgaben sind in unserem Fall die Zahlen 0 bis 2 für die unterschiedlichen Irisarten. Man unterscheidet die Arten »Iris setosa« (0), »Iris virginica« (1) und »Iris versicolor« (2). Unser Beispiel ist dabei ein Klassifikationsproblem. Anhand der Features wollen wir das zugehörige Label erschließen. Da wir dazu das System mit Datensätzen trainieren, haben wir es mit Supervised Learning zu tun.
Dieser Irisdatensatz wird sehr gut verstanden und für viele Beispiele verwendet. Daher gibt es diverse Ressourcen dafür, und er ist sogar direkt in Scikit-Learn als Beispieldatensatz verfügbar, ohne dass du ihn dir von irgendwo besorgen müsstest. Wie erwähnt, ist Scikit-Learn eine zentrale Python-Bibliothek für Machine Learning, die wir über das ganze Buch hinweg einsetzen werden.
Ursprung des Irisdatensatzes
Der Irisdatensatz wurde von dem Botaniker Edgar Anderson (https://en.wikipedia.org/wiki/Edgar_Anderson) zusammengestellt. Bekanntheit erlangte er über die Verwendung durch den Statistiker Ronald Fisher (https://en.wikipedia.org/wiki/Ronald_Fisher). Dieser nutzte den Datensatz in einem Artikel eines Magazin zur Eugenik als Beispiel für statistische Methoden der Klassifikation. Wir distanzieren uns von Fishers Ansichten (https://en.wikipedia.org/wiki/Ronald_Fisher#Views_on_race) über Existenz und unterschiedliche mentale Fähigkeiten von menschlichen Rassen und generell von der Thematik der Eugenik.
Im ersten Schritt unseres Notebooks nutzen wir nun den Beispieldatensatz direkt aus Scikit-Learn und haben dann die kompletten Daten in der Variablen iris. Es ist bei Scikit-Learn üblich, die Features mit einem großen X und die Labels mit einem kleinen y zu bezeichnen. Der Unterschied in der Groß-/Kleinschreibung soll andeuten, dass y nur ein einfacher Vektor mit der Art der Iris ist, also 0, 1 oder 2. X hat hingegen zwei Dimensionen, da es für jeden Datensatz vier Features gibt:
from sklearn import datasets
iris = datasets.load_iris()
X = iris.data
y = iris.target
Für jede der drei Arten gibt es jeweils 50 Beispiele. In jedem Beispiel ist zusammen mit der Irisart die Länge und Breite sowohl des Kelchblatts (Sepalum) als auch des Kronblatts (Petalum) erfasst. Das Kronblatt sind die bunten Blätter, die wir typischerweise als Blüte wahrnehmen. Das Kelchblatt ist meist grün wie der Stängel der Pflanze und schützt die Blüte im Knospenzustand. Bei einer blühenden Iris geht das Kelchblatt im Gegensatz zum Kronblatt ziemlich unter. Mehr dazu gibt es auf Wikipedia unter https://de.wikipedia.org/wiki/Portal:Statistik/Datensaetze#Iris.
Für uns ergibt das vier Features:
sepal_length: Länge des Kelchblatts
sepal_width: Breite des Kelchblatts
petal_length: Länge des Kronblatts
petal_width: Breite des Kronblatts
Diese können wir aus der 150-x-4-Matrix der Features extrahieren und haben dann jeweils einen Vektor mit 150 Einträgen:
X_sepal_length = X[:, 0]
X_sepal_width = X[:, 1]
X_petal_length = X[:, 2]
X_petal_width = X[:, 3]
Die eventuell etwas überraschende Syntax, um einen Vektor aus der Matrix zu bekommen [:, 0], bietet uns NumPy (https://docs.scipy.org/doc/numpy/user/basics.indexing.html), das von Scikit-Learn für Datenstrukturen genutzt wird. Die Syntax besagt, dass wir von der ersten Dimension alle Einträge wünschen und von der zweiten Dimension nur das nullte, erste, zweite und dritte Feature. NumPy ist eine zweite, grundlegendere Python-Bibliothek, die performante Datenstrukturen zur Verfügung stellt. Sie wird uns am Rande immer wieder begegnen und dann auch detaillierter vorgestellt werden. Wie bei vielen Programmiersprachen üblich, fängt auch bei Python die Zählung bei null und nicht bei eins an.
Wir bringen dem Computer bei, Irisblüten zu unterscheiden
Hier möchten wir nun dem Computer beibringen, die unterschiedlichen Arten der Irisblüten anhand ihrer Features zu unterscheiden. Das ist erstaunlich einfach, da wir mit Scikit-Learn eine Software nutzen, die genau für so etwas gedacht ist. Wir brauchen zuerst einen sogenannten Estimator, also eine Strategie, wie der Computer lernen soll.
Hier nutzen wir wieder das Supervised Learning, das heißt, wir trainieren unseren Estimator mit einer Reihe von Datensätzen, von denen wir die Klassifikation in eine der drei Arten kennen. Danach hoffen wir, dass unser Estimator auch Irisblüten, die wir bisher noch nicht gesehen haben, richtig klassifiziert, also anhand der Größe der Blütenblätter sagen kann, was für eine Art Iris wir vor uns haben. Dies nennt man Generalisierung.
Das mit der Hoffnung ist so eine Sache, und daher nutzen wir nicht alle unsere Datensätze zum Training, sondern halten einige zurück, um danach zu testen, wie gut das Training eigentlich funktioniert hat. Auch dabei unterstützt uns Scikit-Learn mit seinem model_selection-Paket. Damit können wir unsere Daten vom Zufall gesteuert in Trainings- und Testdaten aufteilen. Ein typisches Verhältnis sind 60% für das Training und 40% für den Test:
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test =
train_test_split(X, y, test_size=0.4)
Nun haben wir 90 Datensätze in X_train bzw. y_train und 60 in X_test bzw. y_test:
X_train.shape, y_train.shape, X_test.shape, y_test.shape
> ((90, 4), (90,), (60, 4), (60,))
Hier führen wir auch eine Konvention ein. Vom Code erzeugte Ausgaben schreiben wir direkt hinter den Code und fangen