Machine Learning in R für Einsteiger

iris

# Read in `iris` data
iris <- read.csv(url("http://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"), 
                 header = FALSE) 

# Print first lines
head(iris)

# Add column names
names(iris) <- c("Sepal.Length", "Sepal.Width", "Petal.Length", "Petal.Width", "Species")

# Check the result
iris

Schritt zwei. Verstehe deine Daten

Nachdem du den Iris-Datensatz in RStudio geladen hast, verschaffe dir ein gründliches Verständnis deiner Daten. Nur anschauen oder darüber lesen reicht zum Start nicht aus!

Werde praktisch: Erkunde und visualisiere den Datensatz und eigne dir bei Bedarf zusätzliches Domänenwissen an.

Wahrscheinlich bringst du das nötige Fachwissen schon mit. Zur Erinnerung: Jede Blüte hat Kelch- und Blütenblätter. Die Kelchblätter umschließen die Blütenblätter und sind meist grün und laubartig, die Blütenblätter sind in der Regel farbig. Bei Irisblüten ist das etwas anders, wie das folgende Bild zeigt:

Erster Überblick über den Datensatz

Verschaffe dir zunächst mit Diagrammen wie Histogrammen oder Boxplots ein Bild. Besonders aufschlussreich sind hier jedoch Scatterplots: So erkennst du, wie stark eine Variable von einer anderen beeinflusst wird.

Mit anderen Worten: Du prüfst, ob zwischen zwei Variablen Korrelationen bestehen.

Scatterplots kannst du zum Beispiel mit dem ggvis-Paket erstellen.

Hinweis: Lade zuerst das Paket ggvis:

# Load in `ggvis`
library(ggvis)

# Iris scatter plot
iris %>% ggvis(~Sepal.Length, ~Sepal.Width, fill = ~Species) %>% layer_points()Bereitgestellt von

Du siehst eine starke Korrelation zwischen Kelchblatt-Länge und -Breite bei Setosa, während sie bei Virginica und Versicolor schwächer ausfällt: Die Punkte sind stärker gestreut und bilden – anders als bei Setosa – keinen dichten Cluster.

Der Scatterplot für Blütenblatt-Länge und -Breite zeigt ein ähnliches Bild:

iris %>% ggvis(~Petal.Length, ~Petal.Width, fill = ~Species) %>% layer_points()Bereitgestellt von

Hier deutet der Plot auf eine positive Korrelation zwischen Blütenblatt-Länge und -Breite für alle im Iris-Datensatz enthaltenen Arten hin. Um diese Hypothese abzusichern, kannst du weiter testen:

# Overall correlation `Petal.Length` and `Petal.Width`
cor(iris$Petal.Length, iris$Petal.Width)

# Return values of `iris` levels 
x=levels(iris$Species)

# Print Setosa correlation matrix
print(x[1])
cor(iris[iris$Species==x[1],1:4])

# Print Versicolor correlation matrix
print(x[2])
cor(iris[iris$Species==x[2],1:4])

# Print Virginica correlation matrix
print(x[3])
cor(iris[iris$Species==x[3],1:4])

Kombiniert man alle drei Arten, ist die Korrelation etwas stärker als getrennt betrachtet: Insgesamt liegt sie bei 0,96, für Versicolor bei 0,79. Setosa und Virginica weisen – gerundet – Korrelationen von 0,31 bzw. 0,32 zwischen Blütenblatt-Länge und -Breite auf.

Tipp: Interessiert dich ggvis, Visualisierung oder speziell Histogramme? Sieh dir unser Histogramm-Tutorial und/oder den ggvis-Kurs an.

Nach der visuellen Übersicht kannst du dir den Datensatz auch direkt ausgeben lassen, indem du Folgendes eingibst:

# Return all `iris` data
iris

# Return first 5 lines of `iris`
head(iris)

# Return structure of `iris`
str(iris)

Wie du an der Ausgabe siehst, ist das keine ideale Methode: Der Datensatz flutet die Konsole und erschwert den Überblick. Besser prüfst du ihn mit head(iris) oder str(iris).

Mit dem letzten Befehl siehst du klar den Datentyp num und die drei Ausprägungen des Attributs Species als Faktor. Das ist praktisch, denn viele ML-Klassifikatoren in R erwarten, dass das Zielmerkmal als Faktor kodiert ist.

Merke: Faktorvariablen repräsentieren kategoriale Merkmale in R und können nur eine begrenzte Zahl an Werten annehmen.

Ein schneller Blick auf Species zeigt eine 50-50-50-Verteilung. Willst du die prozentuale Verteilung sehen, lass dir eine Proportionstabelle ausgeben:

# Division of `Species`
table(iris$Species) 

# Percentual division of `Species`
round(prop.table(table(iris$Species)) * 100, digits = 1)

Hinweis: round rundet die Werte des ersten Arguments prop.table(table(iris$Species))*100 auf die angegebene Stellenzahl, hier eine Nachkommastelle. Passe das über digits an.

Tieferes Verständnis deiner Daten

Bleib nicht beim High-Level-Überblick! R bietet dir mit summary() eine kompakte Statistik: Minimum, 1. Quartil, Median, Mittelwert, 3. Quartil und Maximum für numerische Spalten; für die Klassenvariable die Faktorhäufigkeiten:

# Summary overview of `iris`
summary(....) 

# Refined summary overview
summary(....[c("Petal.Width", "Sepal.Width")])

Wie du siehst, wurde der Befehl um c() ergänzt: Die Spalten petal width und sepal width werden zusammengefasst, und es wird nur für diese beiden eine Zusammenfassung angefordert.

Schritt drei. Wie geht es weiter?

Nun, da du deine Daten gut verstehst, definierst du sinnvolle Use Cases. Was könnten dir die Daten beibringen, welche Erkenntnisse sind realistisch? Daraus leitest du ab, welche Algorithmen sich eignen, um die gewünschten Ergebnisse zu erzielen.

Tipp: Je besser du deine Daten kennst, desto leichter schätzt du passende Use Cases und wählst den geeigneten Algorithmus.

In diesem Tutorial nutzen wir Iris für eine Klassifikation, also ein Beispiel für Predictive Modeling. Das letzte Attribut Species ist die Zielvariable, die du vorhersagen willst.

Hinweis: Du kannst für eine Regression mit KNN auch eine der numerischen Spalten als Zielvariable wählen.

Schritt vier. Richte deine Arbeitsumgebung ein

Viele ML-Algorithmen sind in R nicht standardmäßig enthalten. Du wirst in der Regel passende Pakete installieren müssen, bevor du loslegst.

Tipp: Du weißt, welchen Algorithmus du verwenden willst, aber nicht, welches Paket? Eine recht vollständige Übersicht der ML-Pakete in R findest du hier.

Für KNN nutzen wir in diesem Tutorial das Paket class:

library(.....)

Falls du es noch nicht installiert hast, geht das schnell mit:

install.packages("<package name>")Bereitgestellt von

Merke – Nerd-Tipp: Ob ein Paket installiert ist, prüfst du so:

any(grepl("<name of your package>", installed.packages()))Bereitgestellt von

Schritt fünf. Bereite deine Daten vor

Nach der Exploration und dem Setup geht es an die Modellierung. Vorher solltest du die Daten vorbereiten. Zwei wichtige Schritte: falls nötig normalisieren und in Trainings- und Testdaten aufteilen.

Normalisierung

Als Teil der Vorbereitung kann es nötig sein, die Daten zu normalisieren, um sie konsistent zu machen. Für den Einstieg reicht: Normalisierung erleichtert KNN das Lernen. Es gibt zwei Arten:

• Beispiel-Normalisierung passt jede Instanz individuell an,
• Feature-Normalisierung skaliert jedes Merkmal einheitlich über alle Instanzen.

Wann normalisieren?

Kurz: Wenn du vermutest, dass die Skalen nicht vergleichbar sind.

Das siehst du leicht in der Ausgabe von summary(). Schau dir die Min- und Max-Werte aller numerischen Attribute an. Hat ein Attribut einen deutlich größeren Wertebereich, dominiert es die Distanzberechnung – dann normalisieren.

Beispiel: Hast du nur X und Y, X reicht von 1 bis 1000, Y von 1 bis 100, dann überwiegt X in der Distanzfunktion.

Durch Normalisierung bringst du alle Merkmale in einen vergleichbaren Bereich, sodass Variablen mit großem Range die Distanz nicht übermäßig beeinflussen.

Tipp: Sieh dir summary(iris) an und prüfe, ob eine Normalisierung nötig ist.

Beim Iris-Datensatz ist sie nicht nötig: Sepal.Length liegt zwischen 4,3 und 7,9, Sepal.Width zwischen 2 und 4,4, Petal.Length zwischen 1 und 6,9 und Petal.Width zwischen 0,1 und 2,5. Alles bewegt sich grob zwischen 0,1 und 7,9 – akzeptabel.

Trotzdem lohnt es sich, Normalisierung und ihre Wirkung zu verstehen – besonders, wenn du neu im ML bist. Eine Feature-Normalisierung kannst du z. B. mit einer eigenen Funktion normalize() umsetzen.

Danach nutzt du sie in einem weiteren Befehl: lapply() wendet normalize auf jede Spalte an und liefert eine Liste, die du mit as.data.frame() in ein Dataframe verwandelst:

YourNormalizedDataSet <- as.data.frame(lapply(YourDataSet, normalize))Bereitgestellt von

Probier das im DataCamp-Light-Block unten aus!

# Build your own `normalize()` function
ormalize <- function(x) {
um <- x - min(x)
denom <- max(x) - min()x
return (num/denom)
}

# Normalize the `iris` data
iris_norm <- .............(.....(iris[1:4], normalize))

# Summarize `iris_norm`
summary(.........)

Für Iris würdest du normalize auf die vier numerischen Attribute (Sepal.Length, Sepal.Width, Petal.Length, Petal.Width) anwenden und das Ergebnis in ein Dataframe schreiben.

Tipp: Vergleiche zur Veranschaulichung den Normalisierungs-Output mit der Zusammenfassung aus Schritt zwei.

Trainings- und Testdaten

Um die Modellleistung zu bewerten, teilst du den Datensatz in zwei Teile: Training und Test.

Mit dem ersten trainierst du das System, mit dem zweiten evaluierst du es. Üblich ist eine disjunkte Aufteilung, z. B. 2/3 Training und 1/3 Test.

Ein letzter Blick zeigt: Wenn du blind aufteilst, riskierst du, dass im Training nicht alle drei Arten vertreten sind, z. B. keine „Virginica“. Dann würde das Modell unbekannte Instanzen nur als „Setosa“ oder „Versicolor“ einstufen – ohne Kenntnis einer dritten Art.

Ergebnis: falsche Vorhersagen im Test.

Sorge also dafür, dass alle drei Klassen im Training vorkommen und in etwa gleich häufig sind, damit du keine Klasse bevorzugst.

Für die Aufteilung setzt du zuerst einen Seed – die Startzahl für R’s Zufallszahlengenerator. Vorteil: Mit demselben Seed erhältst du dieselbe Zufallsfolge und damit reproduzierbare Ergebnisse.

set.seed(1234)Bereitgestellt von

Dann mischst du den Datensatz und stellst sicher, dass Training und Test je Anteile aller Arten enthalten.

Mit sample() ziehst du eine Stichprobe in der Größe der Zeilenzahl (150). Du ziehst mit Zurücklegen aus einem Vektor mit zwei Elementen und weist jeder Zeile eine 1 oder 2 zu – mit den Wahrscheinlichkeiten 0,67 bzw. 0,33.

ind <- sample(2, nrow(iris), replace=TRUE, prob=c(0.67, 0.33))Bereitgestellt von

Hinweis: replace ist TRUE, d. h. nach jeder Ziehung wird der Ursprungsvektor wiederhergestellt. So kann für jede weitere Zeile erneut 1 oder 2 zugewiesen werden. Die Auswahlwahrscheinlichkeiten legst du über prob fest. Der Seed ist weiterhin auf 1234 gesetzt.

Merke: Da 2/3 Training und 1/3 Test vorgesehen sind, vergibst du 1 mit 0,67 und 2 mit 0,33 Wahrscheinlichkeit.

Mit der in ind gespeicherten Stichprobe definierst du dann Trainings- und Testdaten:

# Compose training set
iris.training <- ....[ind==1, 1:4]

# Inspect training set
head(................)

# Compose test set
iris.test <- ....[ind==2, 1:4]

# Inspect test set
head(...........)

Hinweis: Neben der 2/3–1/3-Aufteilung nimmst du nicht alle Attribute in die Feature-Matrix auf. Konkret nutzt du Sepal.Length, Sepal.Width, Petal.Length und Petal.Width. Species ist die Zielvariable. Sie wird nicht als Feature genutzt, aber natürlich für die Bewertung benötigt.

Speichere daher die Klassenlabels als Faktorvektoren und teile sie ebenfalls in Training und Test auf:

# Compose `iris` training labels
iris.trainLabels <- iris[ind==1,5]

# Inspect result
print(iris.trainLabels)

# Compose `iris` test labels
iris.testLabels <- iris[ind==2, 5]

# Inspect result
print(iris.testLabels)

Schritt sechs. Das eigentliche KNN-Modell

Classifier bauen

Nach der Vorbereitung sind alle Trainingsdaten bereit – gelernt wurde bisher noch nicht. Jetzt suchst du die k nächsten Nachbarn für deine Testinstanzen.

Am einfachsten gelingt das mit knn(), das standardmäßig die euklidische Distanz nutzt, um die k nächsten Nachbarn zu einem neuen, unbekannten Punkt zu finden. k legst du selbst fest.

Wie erwähnt, erfolgt die Klassifikation per Mehrheits- oder gewichteter Abstimmung. Bei Klassifikation „gewinnt“ der Datenpunkt mit dem höchsten Score, und die unbekannte Instanz erhält dessen Label. Bei Stimmengleichheit wird zufällig entschieden.

Hinweis: k ist oft ungerade, um Tie-Breaks zu vermeiden.

Für den Classifier ergänzt du knn() um die nötigen Argumente, z. B. so:

# Build the model
iris_pred <- ...(train = iris.training, test = iris.test, cl = iris.trainLabels, k=3)

# Inspect `iris_pred`
.........

In iris_pred speicherst du die Ausgabe von knn(), das Trainingsdaten, Testdaten, Trainingslabels und die gewünschte Zahl an Nachbarn entgegennimmt. Das Ergebnis ist ein Faktorvektor mit den vorhergesagten Klassen für jede Zeile der Testdaten.

Hinweis: Die Testlabels gibst du nicht mit – sie dienen zur Bewertung der Vorhersagen.

Beim Inspizieren von iris_pred siehst du die vorhergesagten Klassen für jede Testzeile.

Schritt sieben. Evaluation deines Modells

Ein zentraler Schritt ist die Bewertung der Modellleistung. Du analysierst also, wie korrekt die Vorhersagen sind.

Für eine erste Einschätzung vergleichst du iris_pred einfach mit den zuvor definierten Testlabels:

# Put `iris.testLabels` in a data frame
irisTestLabels <- data.frame(................)

# Merge `iris_pred` and `iris.testLabels` 
merge <- data.frame(........., ...............)

# Specify column names for `merge`
names(.....) <- c("Predicted Species", "Observed Species")

# Inspect `merge` 
merge

Das Modell trifft recht genaue Vorhersagen, bis auf eine Fehlklassifikation in Zeile 29: „Versicolor“ statt „Virginica“.

Das ist ein erster Hinweis auf die Leistung. Für eine tiefergehende Analyse kannst du das Paket gmodels nutzen:

install.packages("package name")Bereitgestellt von

Falls bereits installiert, einfach laden:

library(gmodels)Bereitgestellt von

Anschließend erstellst du eine Kreuztabelle (Contingency Table), um die Beziehung zwischen den echten Klassen (iris.testLabels) und den Modellvorhersagen (iris_pred) zu untersuchen:

CrossTable(x = iris.testLabels, y = iris_pred, prop.chisq=FALSE)Bereitgestellt von

Hinweis: Das Argument prop.chisq steuert, ob der Chi-Quadrat-Beitrag jeder Zelle ausgegeben wird. Die Summe dieser Beiträge ergibt die Chi-Quadrat-Statistik, mit der man prüft, ob die Differenz zwischen beobachteten und erwarteten Werten signifikant ist.

Aus der Tabelle liest du die Zahl richtiger und falscher Vorhersagen ab: Eine Testinstanz wurde als Versicolor vorhergesagt, war aber tatsächlich Virginica (erste Zeile der „Virginica“-Spalte bei iris.testLabels). In allen anderen Fällen lag das Modell richtig. Fazit: Die Leistung ist gut, eine Verbesserung ist nicht zwingend nötig!

Machine Learning in R mit caret

Du hast KNN als Beispiel für überwachtes Lernen in R kennengelernt. Wie du gesehen hast, kann ML in R komplex werden: viele Algorithmen, unterschiedliche Syntax, etliche Parameter. Paketnamen und jeweilige Syntax zu merken, kann mühsam sein.

Hier hilft caret („Classification and Regression Training“): ein einheitliches Interface zu einer Vielzahl von ML-Algorithmen – ähnlich wie scikit-learn in Python.

Im Folgenden gehst du die gleichen Schritte wie oben, nutzt diesmal aber caret für die Klassifikation. Vieles hast du bereits erledigt: Daten verstehen, explorieren, Workspace vorbereiten. Jetzt geht’s ans Preprocessing mit caret!

Wie zuvor kannst du die Wirkung der Normalisierung untersuchen – später im Tutorial folgt ein Beispiel.

Als Nächstes teilst du die Daten in Training und Test auf. Diesmal gehst du etwas anders vor: Du splittest anhand der Labels in iris$Species. Außerdem nutzt du ein 75/25-Verhältnis.

# Create index to split based on labels  
index <- createDataPartition(iris$Species, p=0.75, list=FALSE)

# Subset training set with index
iris.training <- iris[.......,]

# Subset test set with index
iris.test <- iris[-.........,]

Jetzt kannst du Modelle trainieren! caret umfasst sehr viele Algorithmen. Wenn du unsicher bist, welche verfügbar sind, liste sie mit names(getModelInfo()) auf. Wähle dann einen Algorithmus und trainiere mit train():

# Overview of algos supported by caret
names(getModelInfo())

# Train a model
model_knn <- train(iris.training[, 1:4], iris.training[, 5], method='knn')

Andere Modelle zu trainieren ist jetzt simpel: Ändere nur das Argument method, z. B. so:

model_cart <- train(iris.training[, 1:4], iris.training[, 5], method='rpart2')Bereitgestellt von

Nachdem das Modell trainiert ist, sagst du die Labels des Testsets vorher und bewertest die Leistung:

# Predict the labels of the test set
predictions<-predict(object=model_knn,iris.test[,1:4])

# Evaluate the predictions
table(predictions)

# Confusion matrix 
confusionMatrix(predictions,iris.test[,5])

Zudem kannst du – wie zuvor – testen, welchen Effekt Preprocessing wie Skalierung und Zentrierung hat. Führe dazu diesen Code aus:

# Train the model with preprocessing
model_knn <- train(iris.training[, 1:4], iris.training[, 5], method='knn', preProcess=c("center", "scale"))

# Predict values
predictions<-predict.train(object=model_knn,iris.test[,1:4], type="raw")

# Confusion matrix
confusionMatrix(predictions,iris.test[,5])

Weiter zu Big Data

Glückwunsch! Du hast das Tutorial erfolgreich abgeschlossen.

Im Fokus stand der grundlegende KNN-Algorithmus in R. Der verwendete Iris-Datensatz ist klein und überschaubar. Du hast gesehen, wie du jeden Schritt selbst durchführst, aber auch, wie dir eine einheitliche Schnittstelle wie caret die Arbeit erleichtert.

Und es geht noch viel mehr!

Wenn du mit den Grundlagen und weiteren ML-Algorithmen experimentiert hast, lohnt es sich, tiefer in R und Datenanalyse einzusteigen.