Direkt zum Inhalt

Neuronale Netzmodelle (NN) in R erstellen

In diesem Tutorial lernst du, wie du ein neuronales Netzwerkmodell in R erstellst.
Aktualisierte 16. Jan. 2025  · 16 Min. Lesezeit

Aufbau von Neuronalen Netzwerken NN-Modellen in R

Einführung in Neuronale Netze

Neuronale Netze oder simulierte neuronale Netze sind ein Teilbereich des maschinellen Lernens, der sich am menschlichen Gehirn orientiert. Sie ahmen nach, wie biologische Neuronen miteinander kommunizieren, um eine Entscheidung zu treffen. 

Ein neuronales Netzwerk besteht aus einer Eingabeschicht, einer verborgenen Schicht und einer Ausgabeschicht. Die erste Schicht empfängt rohe Eingaben, die von mehreren versteckten Schichten verarbeitet werden, und die letzte Schicht liefert das Ergebnis. 

Im folgenden Beispiel haben wir den Trainingsprozess von neuronalen Netzen zur Klassifizierung von Tabellendaten simuliert. Wir haben die Parameter X1 und X2, die durch 2 versteckte Schichten mit 4 und 2 Neuronen geleitet werden, um die Ausgabe zu erzeugen. Mit mehreren Iterationen wird das Modell immer besser darin, die Ziele zu klassifizieren. 

Trainingsprozess von neuronalen Netzen zur Klassifizierung von Tabellendaten

Bild erstellt mit TF Playground

Deep-Learning-Algorithmen oder tiefe neuronale Netze bestehen aus mehreren versteckten Schichten und Knotenpunkten. Mit "tief" ist die Tiefe der neuronalen Netze gemeint. Sie werden in der Regel für die Lösung komplexer Probleme wie Bildklassifizierung, Spracherkennung und Texterstellung eingesetzt.

Erfahre mehr über neuronale Netze in unserem Deep Learning Tutorial. Du wirst lernen, wie Aktivierungsfunktion, Verlustfunktion und Backpropagation funktionieren, um genaue Ergebnisse zu erzielen. 

Arten von neuronalen Netzen

Für fortgeschrittene Anwendungen des maschinellen Lernens werden verschiedene Arten von neuronalen Netzen verwendet. Wir haben nicht die eine Modellarchitektur, die für alle funktioniert. Der älteste Typ eines neuronalen Netzes ist das sogenannte Perceptron, das 1958 von Frank Rosenblatt entwickelt wurde. 

In diesem Abschnitt stellen wir dir die 5 beliebtesten Arten von neuronalen Netzen vor, die in der Tech-Branche verwendet werden. 

Neuronale Netze mit Vorwärtskopplung

Neuronale Netze mit Vorwärtskopplung bestehen aus einer Eingabeschicht, versteckten Schichten und einer Ausgabeschicht. Sie wird Feedforward genannt, weil die Daten in Vorwärtsrichtung fließen und es keine Backpropagation gibt. Sie wird hauptsächlich zur Klassifizierung, Spracherkennung, Gesichtserkennung und Mustererkennung eingesetzt.

Mehrschichtiges Perzeptron

Mehrschichtige Perceptrons (MLPs) lösen den Nachteil des Feedforward-Netzes, dass es nicht durch Backpropagation lernen kann. Sie ist bidirektional und besteht aus mehreren versteckten Schichten und Aktivierungsfunktionen. MLPs verwenden Forward Propagation für die Eingaben und Backpropagation für die Aktualisierung der Gewichte. Sie sind grundlegende neuronale Netze, die den Grundstein für Computer Vision, Sprachtechnologie und andere neuronale Netze gelegt haben. 

Hinweis: MLPs bestehen aus sigmoiden Neuronen und nicht aus Perceptrons, weil reale Probleme nicht zeilenförmig sind.

Faltungsneuronale Netze (CNNs)

Neuronale Faltungsnetzwerke (Convolution Neural Networks, CNN) werden in der Regel in der Computer Vision, der Bilderkennung und der Mustererkennung eingesetzt. Sie wird verwendet, um mithilfe mehrerer Faltungsschichten wichtige Merkmale aus dem Bild zu extrahieren. Die Faltungsschicht im CNN verwendet eine eigene Matrix (Filter), um Bilder zu falten und eine Karte zu erstellen. 

Neuronale Faltungsnetze bestehen in der Regel aus einer Eingabeschicht, einer Faltungsschicht, einer Pooling-Schicht, einer vollständig verbundenen Schicht und einer Ausgabeschicht. Lies unser Python Convolutional Neural Networks (CNN) with TensorFlow Tutorial, um mehr darüber zu erfahren, wie CNN funktioniert. 

Rekurrente Neuronale Netze (RNNs)

Rekurrente neuronale Netze (RNNs) werden häufig für sequentielle Daten wie Texte, Bildfolgen und Zeitreihen verwendet. Sie sind ähnlich wie Feed-Forward-Netze, nur dass sie über eine Rückkopplungsschleife Eingaben von vorherigen Sequenzen erhalten. RNNs werden in den Bereichen NLP, Umsatzprognosen und Wettervorhersage eingesetzt. 

Bei RNNs gibt es Probleme mit verschwindenden Gradienten, die von fortgeschrittenen Versionen von RNNs namens Short-Term Memory Networks (LSTMs) und Gated Recurrent Unit Networks (GRUs) gelöst werden. Lies das Tutorial über rekurrente neuronale Netze (RNN), um mehr über LSTMs und GRUs zu erfahren. 

Implementierung von neuronalen Netzen in R

Wir werden lernen, neuronale Netzwerke mit den beliebten R-Paketen neuralnet und Keras zu erstellen. 

Im ersten Beispiel werden wir ein einfaches neuronales Netzwerk mit minimalem Aufwand erstellen, und im zweiten Beispiel werden wir ein fortgeschritteneres Problem mit dem Keras-Paket angehen. 

Richten wir die R-Umgebung ein, indem wir die wichtigsten Bibliotheken und Abhängigkeiten herunterladen. 

install.packages(c('neuralnet','keras','tensorflow'),dependencies = T)

Einfache Implementierung eines neuronalen Netzwerks in R

In diesem ersten Beispiel verwenden wir die in R integrierten Iris-Daten und lösen das Problem der Mehrfachklassifizierung mit einem einfachen neuronalen Netz. 

Wir beginnen mit dem Import wichtiger R-Pakete für die Datenbearbeitung und das Modelltraining. 

library(tidyverse)
library(neuralnet)

Datenanalyse

Du kannst auf die Daten zugreifen, indem du `iris` eingibst und es in der R-Konsole ausführst. Bevor wir die Daten trainieren, müssen wir die Zeichenspaltentypen in Faktoren umwandeln.

Hinweis: Wir verwenden den DataCamp R-Arbeitsbereich, um die Beispiele auszuführen. 

iris <- iris %>% mutate_if(is.character, as.factor)

Die Funktion "Zusammenfassung" wird für statistische Analysen und die Datenverteilung verwendet. 

summary(iris)

Wie wir sehen können, haben wir ausgeglichene Daten. Alle drei Zielklassen haben 50 Proben. 

Sepal.Length    Sepal.Width     Petal.Length    Petal.Width  
Min.   :4.300   Min.   :2.000   Min.   :1.000   Min.   :0.100 
1st Qu.:5.100   1st Qu.:2.800   1st Qu.:1.600   1st Qu.:0.300 
Median :5.800   Median :3.000   Median :4.350   Median :1.300 
Mean   :5.843   Mean   :3.057   Mean   :3.758   Mean   :1.199 
3rd Qu.:6.400   3rd Qu.:3.300   3rd Qu.:5.100   3rd Qu.:1.800 
Max.   :7.900   Max.   :4.400   Max.   :6.900   Max.   :2.500 
      Species 
setosa    :50 
versicolor:50 
virginica :50 

Split trainieren und testen

Wir setzen Seeds für die Reproduzierbarkeit und teilen die Daten in Trainings- und Testdatensätze für die Modellschulung und -bewertung. Wir werden es im Verhältnis 80:20 aufteilen. 

set.seed(245)
data_rows <- floor(0.80 * nrow(iris))
train_indices <- sample(c(1:nrow(iris)), data_rows)
train_data <- iris[train_indices,]
test_data <- iris[-train_indices,]

Neuronales Netzwerk trainieren

Das Paket neuralnet ist zwar veraltet, aber in der R-Gemeinde immer noch beliebt. 

Die Funktion "Neuralnet" ist einfach. Es gibt uns nicht die Freiheit, eine vollständig anpassbare Modellarchitektur zu erstellen. 

In unserem Fall stellen wir ihm eine Machine-Learning-Formel und Daten zur Verfügung, genau wie GLM. Die Formel besteht aus Zielvariablen und Merkmalen. 

Danach erstellen wir zwei versteckte Schichten, die erste Schicht mit vier Neuronen und die zweite mit zwei Neuronen. 

model = neuralnet(
    Species~Sepal.Length+Sepal.Width+Petal.Length+Petal.Width,
data=train_data,
hidden=c(4,2),
linear.output = FALSE
)

Um unsere Modellarchitektur zu betrachten, verwenden wir die Funktion "Plot". Er benötigt ein Model-Objekt und das Argument `rep`. 

plot(model,rep = "best")

NN-Modell

Modellbewertung

Für die Konfusionsmatrix:

  1. Wir werden die Kategorien anhand eines Testdatensatzes vorhersagen. 
  2. Erstelle eine Liste mit Kategorienamen.
  3. Erstelle einen DataFrame für die Vorhersage und ersetze numerische Ausgaben durch Beschriftungen. 
  4. Verwende Tabellen, um "tatsächliche" und "praktizierte" Werte nebeneinander darzustellen. 
pred <- predict(model, test_data)
labels <- c("setosa", "versicolor", "virginca")
prediction_label <- data.frame(max.col(pred)) %>%     
mutate(pred=labels[max.col.pred.]) %>%
select(2) %>%
unlist()

table(test_data$Species, prediction_label)

Wir haben fast perfekte Ergebnisse erzielt. Es scheint, dass unser Modell drei Proben falsch vorhergesagt hat. Wir können das Ergebnis verbessern, indem wir mehr Neuronen in jeder Schicht hinzufügen. 

           prediction_label
            setosa versicolor virginica
  setosa          8          0        0
  versicolor      0         13        0
  virginica       0          3        6 

Um die Genauigkeit zu überprüfen, müssen wir zunächst die tatsächlichen kategorialen Werte in numerische Werte umwandeln und sie mit den vorhergesagten Werten vergleichen. Als Ergebnis erhalten wir eine Liste mit booleschen Werten. 

Wir können die Funktion "Summe" verwenden, um die Anzahl der "WAHR"-Werte zu ermitteln und sie durch die Gesamtzahl der Stichproben zu teilen, um die Genauigkeit zu erhalten. 

check = as.numeric(test_data$Species) == max.col(pred)
accuracy = (sum(check)/nrow(test_data))*100
print(accuracy)

Das Modell hat die Werte mit einer Genauigkeit von 90 % vorhergesagt. 

90

Hinweis: Der Quellcode für dieses Beispiel ist im R-Arbeitsbereich verfügbar: Neuronale Netzwerkmodelle (NN) in R erstellen.

Convolutional Neural Network in R mit Keras

In diesem Beispiel werden wir Keras und TensorFlow verwenden, um ein Convolutional Neural Network Modell für die Bildklassifizierung zu erstellen und zu trainieren. Dazu verwenden wir den cifar10-Bilddatensatz, der aus 60.000 32x32-Farbbildern besteht, die in zehn Kategorien beschriftet sind.

CIFAR-10-Datensatz

Bild von CIFAR-10

Importiere wichtige R-Pakete. 

library(keras)
library(tensorflow)

Aufbereitung der Daten

Wir importieren den integrierten Keras-Datensatz und teilen ihn in Trainings- und Testdatensätze auf. 

c(c(x_train, y_train), c(x_test, y_test)) %<-% dataset_cifar10()

Teile die Trainings- und Testmerkmale durch 255, um die Daten zu normalisieren. 

x_train <- x_train / 255
x_test <-  x_test / 255

Das Modell bauen

Die Keras-API bietet uns die Flexibilität, eine vollständig anpassbare komplexe neuronale Netzwerkarchitektur aufzubauen. 

In unserem Fall werden wir mehrere Faltungsschichten erstellen, gefolgt von der Max-Pooling-Schicht, der Dropout-Schicht, der Dense-Schicht und der Output-Schicht. 

Wir verwenden "Leaky ReLU" als Aktivierungsfunktion für alle Schichten außer der Ausgabeschicht. Dafür verwenden wir "Softmax". 

Wir müssen die Eingangsform der ersten 2D-Faltungsschicht auf die Form des Bildes (32,32,3) aus dem Trainingsdatensatz einstellen. 

model <- keras_model_sequential()%>%
  # Start with a hidden 2D convolutional layer
  layer_conv_2d(
    filter = 16, kernel_size = c(3,3), padding = "same",
    input_shape = c(32, 32, 3), activation = 'leaky_relu'
  ) %>%

  # 2nd hidden layer
  layer_conv_2d(filter = 32, kernel_size = c(3,3), activation = 'leaky_relu') %>%
 

  # Use max pooling
  layer_max_pooling_2d(pool_size = c(2,2)) %>%
  layer_dropout(0.25) %>%

  # 3rd and 4th hidden 2D convolutional layers
  layer_conv_2d(filter = 32, kernel_size = c(3,3), padding = "same", activation = 'leaky_relu') %>%

  layer_conv_2d(filter = 64, kernel_size = c(3,3), activation = 'leaky_relu') %>%

  # Use max pooling
  layer_max_pooling_2d(pool_size = c(2,2)) %>%
  layer_dropout(0.25) %>%
 
  # Flatten max filtered output into feature vector
  # and feed into dense layer
  layer_flatten() %>%
  layer_dense(256, activation = 'leaky_relu') %>%
  layer_dropout(0.5) %>%

  # Outputs from dense layer
  layer_dense(10, activation = 'softmax')

Um die Modellarchitektur zu sehen, verwenden wir die Funktion "Zusammenfassung". 

summary(model)

Wir haben zwei Faltungsschichten, gefolgt von einer Max-Pooling-Schicht, zwei weiteren Faltungsschichten, einer Max-Pooling-Schicht, einer abgeflachten Schicht, um den gefilterten Output in Vektoren zu maximieren, und dann zwei dichte Schichten. 

Model: "sequential"
________________________________________________________________________________
Layer (type)                        Output Shape                    Param #    
================================================================================
conv2d_3 (Conv2D)                   (None, 32, 32, 16)              448        
________________________________________________________________________________
conv2d_2 (Conv2D)                   (None, 30, 30, 32)              4640       
________________________________________________________________________________
max_pooling2d_1 (MaxPooling2D)      (None, 15, 15, 32)              0          
________________________________________________________________________________
dropout_2 (Dropout)                 (None, 15, 15, 32)              0          
________________________________________________________________________________
conv2d_1 (Conv2D)                   (None, 15, 15, 32)              9248       
________________________________________________________________________________
conv2d (Conv2D)                     (None, 13, 13, 64)              18496      
________________________________________________________________________________
max_pooling2d (MaxPooling2D)        (None, 6, 6, 64)                0          
________________________________________________________________________________
dropout_1 (Dropout)                 (None, 6, 6, 64)                0          
________________________________________________________________________________
flatten (Flatten)                   (None, 2304)                    0          
________________________________________________________________________________
dense_1 (Dense)                     (None, 256)                     590080     
________________________________________________________________________________
dropout (Dropout)                   (None, 256)                     0          
________________________________________________________________________________
dense (Dense)                       (None, 10)                      2570       
================================================================================
Total params: 625,482
Trainable params: 625,482
Non-trainable params: 0
________________________________________________________________________________

Kompilieren des Modells

  1. Wir werden die Lernrate mithilfe der exponentiellen Abklingfunktion des Zeitplans festlegen. Sie reduziert die Lernrate nach 1500 Schritten um 0,98.
  2. Gib das Objekt mit der Lernrate in den Adamax-Optimierer ein.
  3. Unsere Verlustfunktion ist die spärliche kategoriale Kreuzentropie.
  4. Kompiliere das Modell mit Hilfe der Verlust- und Optimierungsfunktion und der Leistungsmetrik.
learning_rate <- learning_rate_schedule_exponential_decay(
  initial_learning_rate = 5e-3,
  decay_rate = 0.96,
  decay_steps = 1500,
  staircase = TRUE
)
opt <- optimizer_adamax(learning_rate = learning_rate)

loss <- loss_sparse_categorical_crossentropy(from_logits = TRUE)


model %>% compile(
  loss = loss,
  optimizer = opt,
  metrics = "accuracy"
)

Das Modell trainieren

Wir passen unser Modell an und speichern die Bewertungsmetrik in der "Historie". 

  • Wir werden ein Modell für 10 Epochen trainieren und die Stapelgröße auf 32 setzen. 
  • Hinzufügen eines Testdatensatzes zur Validierung.
  • Mit dem Argument "shuffle" werden die Trainingsdaten zu Beginn jeder Epoche neu gemischt. 
history <- model %>% fit(
  x_train, y_train,
  batch_size = 32,
  epochs = 10,
  validation_data = list(x_test, y_test),
  shuffle = TRUE
)

Bewertung des Modells

Mit der Funktion `evaluate` kannst du das Modell auf einem Testdatensatz auswerten und erhältst den endgültigen Verlust und die Genauigkeit zurück. 

model %>% evaluate(x_test, y_test)

Ein erneutes Training des Modells mit 50 Epochen verbessert die Modellgenauigkeit. 

Loss 0.648191571235657 Accuracy 0.776799976825714

Um den Verlust und die Genauigkeit für jede Epoche grafisch darzustellen, verwenden wir die Funktion "Plot". 

plot(history)

Wenn wir uns die Grafik ansehen, können wir feststellen, dass die Linie noch nicht abgeflacht ist. Das bedeutet, dass wir mit mehr Epochen die Modellmetriken verbessern können. 

CNN-Modell Verlust- und Genauigkeitsdiagramm

Wenn du mehr über die Keras-API erfahren möchtest und wie du damit tiefe neuronale Netze aufbauen kannst, schau dir keras an: Deep Learning in R tutorial. 

Anwendungen von neuronalen Netzen

Beispiele für neuronale Netze aus dem echten Leben gibt es überall, von mobilen Anwendungen bis hin zur Technik. Aufgrund des jüngsten Booms von Sprach- und großen visuellen Modellen interessieren sich immer mehr Unternehmen für die Implementierung von tiefen neuronalen Netzen, um ihre Gewinne und die Kundenzufriedenheit zu steigern. 

In diesem Abschnitt lernen wir die 10 wichtigsten Anwendungen neuronaler Netze kennen, die die moderne Welt prägen. 

1. Tabellarische Vorhersage

Einfache neuronale Netze sind bei großen Tabellendaten recht effektiv. Wir können sie für Klassifizierungs-, Clustering- und Regressionsprobleme verwenden. 

2. Aktienkursprognose

Viele Unternehmen nutzen LSTM, GRU und RNN für Finanzprognosen. So können sie bessere Entscheidungen treffen. 

3. Medizinische Bildgebung

Die Erkennung von Brustkrebs, die Erkennung von Anomalien und die Segmentierung von Bildern sind einige der Anwendungen von neuronalen Faltungsnetzwerken. Dank der vorgebildeten Transformatoren haben wir Fortschritte bei der Krankheitsvorbeugung und der Früherkennung von tödlichen Krankheiten gemacht.  

4. E-Commerce

Produktempfehlungen, personalisierte Erlebnisse und Chatbots sind einige der Anwendungen von neuronalen Netzen im E-Commerce. Diese Modelle werden hauptsächlich für Clustering, natürliche Sprachverarbeitung und Computer Vision verwendet, um das Kundenerlebnis auf der Plattform zu verbessern. 

5. Generatives Bild

Dank der Popularität von DALL-E 2 und der Stable Diffusion ist dieser Bereich zum Mainstream geworden. Unternehmen wie Canva und Adobe haben bereits generative Bildfunktionen eingeführt, um die Zahl der Nutzer zu erhöhen. Abseits des Mainstream-Hypes werden generative Bilder in jeder Branche eingesetzt, um synthetische Daten zu erstellen und so die Leistung, Stabilität und Verzerrungen des Modells zu verbessern. 

6. Generativer Text

ChatGPT, GPT-3 und GPT-NEO sind die Modelle der tiefen neuronalen Netze, die den Raum dominieren. Diese Modelle werden für Programmierhilfe, Chatbots, Übersetzung, Frage/Antwort und mehr verwendet. Sie ist allgegenwärtig, und die Unternehmen finden es einfach, sie in ihre aktuellen Systeme zu integrieren.

7. Kundenservice Chat Bot

DailoGPT und Blenderbot sind beliebte Konversationsmodelle, die dein Chatbot-Erlebnis verbessern. Sie sind anpassungsfähig und können für einen bestimmten Zweck feinabgestimmt werden. In Zukunft wird es keine langen Wartezeiten mehr geben; diese Chatbots werden in der Lage sein, deine Probleme zu verstehen und in Echtzeit Lösungen anzubieten. 

8. Robotik

Reinforcement Learning und Computer Vision Neural Network Modelle spielen eine wichtige Rolle bei der Übertragung von Industrien. Zum Beispiel eine vollautomatische Lagerverwaltung, Fabriken und ein Einkaufserlebnis. 

9. Spracherkennung

Neuronale Netzmodelle für Spracherkennung, Text-to-Speech und Audioaktivitätserkennung werden für Sprachassistenz, automatische Transkription und verbesserte Kommunikationsanwendungen eingesetzt. 

10. Multimodal

Text zu Bild (DALLE-2), Bildtext, visuelle Fragebeantwortung und Merkmalsextraktion sind einige der Anwendungen, die in multimodalen neuronalen Netzen verwendet werden. In Zukunft wirst du Text-to-Video mit Audio sehen. Du kannst einen kompletten Film erstellen, indem du das Drehbuch zur Verfügung stellst.

Fazit

Keras und das TensorFlow R-Paket bieten uns eine ganze Reihe von Werkzeugen, um komplexe Modellarchitekturen für bestimmte Aufgaben zu erstellen. Du kannst den Datensatz laden, die Vorverarbeitung durchführen, das Modell erstellen und optimieren und das Modell mit wenigen Zeilen Code auswerten. Außerdem kannst du mit Tensorflow deine Experimente überwachen, GPUs konfigurieren und das Modell in der Produktion einsetzen. 

In diesem Tutorium haben wir die Grundlagen von neuronalen Netzen, die Art der Modellarchitektur und die Anwendung kennengelernt. Außerdem haben wir gelernt, wie man mit `neuralnet` ein einfaches neuronales Netz und mit `keras` ein faltbares neuronales Netz trainiert. Das Tutorial behandelt die Modellerstellung, die Kompilierung, das Training und die Auswertung. 

Erfahre mehr über Tensorflow und Keras API, indem du den Kurs Einführung in TensorFlow in R belegst. Du lernst Tensorboard und andere TensorFlow-APIs kennen, baust tiefe neuronale Netze auf und verbesserst die Modellleistung mit Regularisierung, Dropout und Hyperparameter-Optimierung.  

Themen

R Kurse

Zertifizierung verfügbar

Kurs

Einführung in R

4 hr
2.8M
Beherrsche die Grundlagen der Datenanalyse in R, einschließlich Vektoren, Listen und Datenrahmen, und übe R mit echten Datensätzen.
Siehe DetailsRight Arrow
Kurs starten
Mehr anzeigenRight Arrow