keras: Deep Learning in R

Wie du inzwischen weißt, ist Machine Learning ein Teilbereich der Informatik (CS). Deep Learning ist wiederum ein Teilbereich des Machine Learning: eine Menge von Algorithmen, die von Struktur und Funktion des Gehirns inspiriert sind und meist als Künstliche Neuronale Netze (ANN) bezeichnet werden. Deep Learning ist derzeit einer der heißesten Trends im Machine Learning und glänzt bei vielen Aufgaben – etwa in Robotik, Bilderkennung und Künstlicher Intelligenz (KI).

Dieses Tutorial gibt dir eine kurze Einführung in Deep Learning in R mit Keras über das keras-Paket:

# Load in the keras package
library(keras)

# Install TensorFlow
install_tensorflow()

Daten laden

Jetzt, wo die Installation sitzt und dein Workspace bereit ist, kannst du Daten laden! Du hast grundsätzlich drei Optionen: Du nutzt eingebaute Datensätze aus dem keras-Paket, lädst eigene Daten z. B. aus CSV-Dateien, oder erstellst Dummy-Daten.

Ganz egal, welche Option du wählst – du kommst schnell ins Arbeiten. Dieser Abschnitt zeigt kurz alle drei Varianten und wie du die benötigten Daten lädst (oder erzeugst)!

# Read in MNIST data
mnist <- dataset_mnist()

# Read in CIFAR10 data
cifar10 <- dataset_cifar10()

# Read in IMDB data
imdb <- dataset_imdb()

Datenexploration

Für dieses Tutorial arbeitest du weiter mit dem berühmten iris-Datensatz, den du mit read.csv() importiert hast.

Für alle ohne botanischen Hintergrund hier etwas Kontext: Jede Blüte hat Kelchblatt (sepal) und Kronblatt (petal). Das Kelchblatt umschließt die Kronblätter, ist meist grün und blattähnlich; die Kronblätter sind meist farbig. Bei der Iris sieht das etwas anders aus – siehe Abbildung:

Dir ist vielleicht aufgefallen, dass der Data Frame iris nach dem Import keine Spaltennamen hatte. Für den Rest des Tutorials ist das nicht kritisch: Zwar liefert read.csv() einen data.frame zurück, aber die Daten, die du an fit() übergibst, müssen Matrix oder Array sein.

Ein paar Dinge zu den genannten Strukturen: – Matrizen und Arrays haben keine Spaltennamen; – Matrizen sind zweidimensionale Objekte eines einzigen Datentyps; – Arrays sind mehrdimensionale Objekte eines einzigen Datentyps.

Tipp: Schau dir dieses Video zur Auffrischung der Datenstrukturen in R an!

Ein Data Frame ist dagegen eine besondere Form einer benannten Liste, deren Elemente alle die gleiche Länge haben. Er ist mehrdimensional und kann mehrere Datentypen enthalten. Das hast du bereits in der Struktur des iris-Data-Frames gesehen. Da du auf ein zwei- oder mehrdimensionales Objekt mit einem Datentyp hinarbeiten musst, wirst du vor dem Netzbau etwas vorverarbeiten!

Für die Erkundung sind Spaltennamen jedoch hilfreich – sie erleichtern das Verständnis. Lass uns also mit names() Spaltennamen vergeben. Danach kannst du iris direkt nutzen. Plotte zum Beispiel mit plot(), wie Petal Length und Petal Width korrelieren.

Mit unclass() wandelst du die Artnamen „setosa, versicolor, virginica“ in die numerischen 1, 2 und 3 um.

Sieh dir das Plot-Ergebnis genauer an:

Die Grafik zeigt eine positive Korrelation zwischen Petal.Length und Petal.Width für die drei Iris-Arten. Das kannst du mit cor() auch quantitativ prüfen – diese Funktion liefert die Gesamt-Korrelation zwischen den Attributen des Datensatzes:

Mit dem Paket corrplot kannst du zusammen mit cor() die Korrelationen deiner Attribute visualisieren. Hier berechnest du die Korrelationen für alle Attribute des iris-Data-Frames, speicherst sie in M und übergibst M an corrplot().

Vergiss nicht, über den Parameter method festzulegen, wie geplottet werden soll!

Experimentiere mit der Darstellungsart im folgenden DataCamp-Light-Block:

Nutze die R-Konsole, um deine Daten weiter zu erkunden.

Wenn du mit ggvis (interaktive „Grammar of Graphics“) plotten willst, sieh dir DataCamps Tutorial Machine Learning in R für Einsteiger oder den ggvis-Kurs an.

Datenvorverarbeitung

Bevor du dein Modell baust, sollten die Daten bereinigt, ggf. normalisiert und in Trainings- und Testdaten geteilt sein. Da der Datensatz aus dem UCI-Repository kommt, ist er voraussichtlich recht sauber – dennoch: Prüfe die Qualität.

Auf den ersten Blick war bei head() nichts Auffälliges zu sehen. Nutze summary() und str(), um kurz zusammenzufassen, was du beim Import gelernt hast:

Jetzt kannst du prüfen, ob eine Normalisierung nötig ist.

x_train <- imdb$train$x
y_train <- imdb$train$y
x_test <- imdb$test$x
y_test <- imdb$test$y

Das Modell konstruieren

Starte mit einem sequenziellen Modell via keras_model_sequential(). Dann geht’s ans Modellieren.

Noch einmal zur Zielsetzung: Kannst du die Art einer Iris-Blüte vorhersagen? Numerische Daten sind einfacher zu verarbeiten, und du hast die Zielvariable bereits One-Hot-encodiert: Eine Blüte ist entweder versicolor, setosa oder virginica – und das spiegelt sich in binären 1/0-Werten wider.

Ein Netz, das für solche Probleme gut funktioniert, ist ein Multi-Layer Perceptron. Diese Netze sind oft „fully connected“, also voll verbunden. Du baust also einen einfachen Stapel aus Dense-Schichten. Als Aktivierungsfunktion eignet sich zum Einstieg die verbreitete relu für die versteckte Schicht – bewährte Praxis.

In der Ausgabeschicht nutzt du softmax, damit die Ausgaben im Bereich 0 bis 1 liegen und als vorhergesagte Wahrscheinlichkeiten interpretierbar sind:

Die Ausgabeschicht erzeugt 3 Werte – je eine Wahrscheinlichkeit für versicolor, virginica und setosa. Die erste Schicht mit 8 Neuronen hat input_shape=4, da iris.training 4 Spalten hat.

Folgende Funktionen helfen bei der Inspektion des Modells:

• summary() gibt eine Zusammenfassung aus,
• get_config() liefert die Modellkonfiguration als Liste,
• get_layer() gibt die Layer-Konfiguration zurück,
• über das Attribut layers erhältst du eine flache Liste der Schichten,
• inputs listet die Eingabetensoren,
• outputs listet die Ausgabetensoren.

Modell kompilieren und fitten

Jetzt kompilierst du das Modell und passt es an die Daten an. Zum Kompilieren konfigurierst du den adam-Optimizer und die Verlustfunktion categorical_crossentropy. Zusätzlich überwachst du die Genauigkeit, indem du 'accuracy' an metrics übergibst.

Optimizer und Loss sind Pflichtargumente beim Kompilieren.

Zu den populären Optimierern zählen Stochastic Gradient Descent (SGD), ADAM und RMSprop. Je nach Algorithmus musst du Parameter wie Lernrate oder Momentum tunen. Die Wahl der Verlustfunktion hängt von der Aufgabe ab: Für Regression etwa häufig Mean Squared Error (MSE).

Hier nutzt du categorical_crossentropy für das Multiklassenproblem (versicolor, virginica oder setosa). Bei binärer Klassifikation würdest du binary_crossentropy verwenden.

Anschließend passt du das Modell an: Hier trainierst du 200 Epochen über alle Samples in iris.training und iris.trainLabels, in Batches von 5 Samples.

Tipp: Mit verbose=1 in fit() bekommst du Fortschrittsbalken-Logging.

Du trainierst also für eine festgelegte Zahl an Epochen (jeder Durchlauf über den gesamten Trainingssatz, mit anschließender Validierung). batch_size legt fest, wie viele Samples pro Schritt durch das Netz laufen – effizienter, da nicht zu viele Muster gleichzeitig im Speicher liegen.

Training-Historie visualisieren

Du kannst die Anpassung auch visualisieren, wenn du das Ergebnis von fit() in einer Variablen speicherst und an plot() übergibst – so wie hier:

Sieh dir die Plots im Detail an.

Auf den ersten Blick wirkt das unübersichtlich – verständlich.

Wichtig: loss und acc zeigen Verlust und Genauigkeit auf den Trainingsdaten; val_loss und val_acc dieselben Metriken für Validierungs-/Testdaten.

Trotzdem sind die Graphen nicht leicht zu interpretieren. Zerlegen wir sie: Erstelle zwei separate Plots – einen für den Modellverlust und einen für die Genauigkeit. Mit dem $-Operator greifst du auf die Daten zu und plottest Schritt für Schritt.

So geht’s im folgenden DataCamp-Light-Block:

Hier hast du den Verlust für Training und Test geplottet. Jetzt auch die Genauigkeit:

Denk an Folgendes:

• Verbessert sich die Trainingsgenauigkeit weiter, während die Validierungsgenauigkeit schlechter wird, überfittest du vermutlich: Das Modell merkt sich die Daten statt zu generalisieren.
• Steigt die Genauigkeit in beiden Datensätzen in den letzten Epochen noch an, hat das Modell den Trainingssatz noch nicht „ausgelernt“.

Labels für neue Daten vorhersagen

Dein Modell ist erstellt, kompiliert und gefittet – Zeit für Vorhersagen auf dem Testset iris.test. Wie erwartet nutzt du predict(). Danach gibst du mit table() eine Konfusionsmatrix aus, um Vorhersagen und echte Labels zu vergleichen.

Wie wirken die Ergebnisse auf dich? Trifft das Modell auf Anhieb die richtigen Vorhersagen?

Modell evaluieren

Auch wenn die Konfusionsmatrix schon einen Eindruck vermittelt, solltest du dein Modell systematisch evaluieren. Nutze evaluate(): Übergebe iris.test, iris.testLabels und eine Batchgröße. Speichere das Ergebnis in score – so wie hier:

Beim Print von score bekommst du Verlust und Metrik (hier „accuracy“) zurück.

Modell feintunen

Feintuning wirst du häufig brauchen – gerade am Anfang, da viele Klassifikations- und Regressionsprobleme komplexer sind als unser Beispiel. Zwei zentrale Stellschrauben sind: Anzahl der Schichten und Zahl der „hidden units“ pro Schicht.

Am Anfang ist das eine kleine Reise.

Neben Epochen- und Batchgröße kannst du dein Modell auch so tweaken: Schichten hinzufügen, die Zahl versteckter Neuronen erhöhen und Optimierungsparameter in compile() anpassen. Hier sind drei Optionen.