Neurale-netwerkmodellen (NN) bouwen in R

Introductie tot neurale netwerken

Neurale netwerken, of gesimuleerde neurale netwerken, zijn een subset van machine learning geïnspireerd op het menselijk brein. Ze bootsen na hoe biologische neuronen met elkaar communiceren om tot een beslissing te komen. 

Een neuraal netwerk bestaat uit een invoerlaag, een verborgen laag en een uitvoerlaag. De eerste laag ontvangt ruwe input, die wordt verwerkt door meerdere verborgen lagen, en de laatste laag produceert het resultaat. 

In het onderstaande voorbeeld hebben we het trainingsproces van neurale netwerken gesimuleerd om tabeldata te classificeren. We hebben parameters X1 en X2 die door 2 verborgen lagen met 4 en 2 neuronen gaan om een output te produceren. Met meerdere iteraties wordt het model beter in het classificeren van de doelen. 

Afbeelding gemaakt met TF Playground

Deep-learningalgoritmen, of diepe neurale netwerken, bestaan uit meerdere verborgen lagen en knooppunten. Het woord “diep” verwijst naar de diepte van neurale netwerken. Ze worden doorgaans gebruikt voor het oplossen van complexe problemen zoals beeldclassificatie, spraakherkenning en tekstgeneratie.

Leer meer over neurale netwerken in onze Deep Learning Tutorial. Je leert hoe activatiefuncties, verliesfuncties en backpropagation samenwerken om nauwkeurige resultaten te leveren. 

Typen neurale netwerken

Er worden meerdere typen neurale netwerken gebruikt voor geavanceerde machine-learningtoepassingen. Er is niet één modelarchitectuur die overal werkt. Het oudste type neuraal netwerk staat bekend als de Perceptron, ontwikkeld door Frank Rosenblatt in 1958. 

In deze sectie behandelen we de 5 meest populaire typen neurale netwerken die in de techindustrie worden gebruikt. 

Feedforward-neurale netwerken

Feedforward-neurale netwerken bestaan uit een invoerlaag, verborgen lagen en een uitvoerlaag. Ze heten feedforward omdat de datastroom in voorwaartse richting gaat en er geen backpropagation is. Ze worden vooral gebruikt bij classificatie, spraakherkenning, gezichtsherkenning en patroonherkenning.

Multi-Layer Perceptron

Multi-Layer Perceptrons (MLP's) lossen het tekort van het feedforward-neuraal netwerk op, namelijk dat het niet kan leren via backpropagation. Het is bidirectioneel en bestaat uit meerdere verborgen lagen en activatiefuncties. MLP's gebruiken forward propagation voor inputs en backpropagation voor het updaten van de gewichten. Het zijn basisnetwerken die de basis hebben gelegd voor computervisie, taaltechnologie en andere neurale netwerken. 

Let op: MLP's bestaan uit sigmoidneuronen, niet uit perceptrons, omdat problemen uit de echte wereld niet-lineair zijn.

Convolutionele neurale netwerken (CNN's)

Convolutionele neurale netwerken (CNN) worden doorgaans gebruikt in computervisie, beeldherkenning en patroonherkenning. Ze extraheren belangrijke kenmerken uit een afbeelding met behulp van meerdere convolutionele lagen. De convolutionele laag in een CNN gebruikt een aangepaste matrix (filter) om over afbeeldingen te convolueren en een featuremap te maken. 

Over het algemeen bestaan convolutionele neurale netwerken uit de invoerlaag, convolutionele laag, poolinglaag, volledig verbonden laag en uitvoerlaag. Lees onze tutorial Python Convolutional Neural Networks (CNN) met TensorFlow om meer te leren over hoe CNN's werken. 

Recurrente neurale netwerken (RNN's)

Recurrente neurale netwerken (RNN's) worden vaak gebruikt voor sequentiële data zoals tekst, reeksen afbeeldingen en tijdreeksen. Ze lijken op feedforward-netwerken, behalve dat ze via een terugkoppelingslus input krijgen uit vorige sequenties. RNN's worden gebruikt in NLP, verkoopvoorspellingen en weersvoorspellingen. 

RNN's hebben last van verdwijnende gradiënten; dat wordt opgelost door geavanceerde varianten van RNN's, zoals Long Short-Term Memory-netwerken (LSTM's) en Gated Recurrent Unit-netwerken (GRU's). Lees de Recurrent Neural Network Tutorial (RNN) om meer te leren over LSTM's en GRU's. 

Implementatie van neurale netwerken in R

We gaan neurale netwerken maken met de populaire R-packages neuralnet en Keras. 

In het eerste voorbeeld maken we met minimale inspanning een eenvoudig neuraal netwerk, en in het tweede voorbeeld pakken we een geavanceerder probleem aan met het Keras-package. 

Laten we de R-omgeving instellen door essentiële bibliotheken en afhankelijkheden te downloaden. 

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

Eenvoudige implementatie van een neuraal netwerk in R

In dit eerste voorbeeld gebruiken we de ingebouwde R-data iris en lossen we multiklassificatieproblemen op met een eenvoudig neuraal netwerk. 

We beginnen met het importeren van essentiële R-packages voor datamanipulatie en modeltraining. 

library(tidyverse)
library(neuralnet)Mogelijk gemaakt door

Data-analyse

Je kunt de data bekijken door `iris` te typen en dit in de R-console uit te voeren. Voordat we de data trainen, moeten we kolommen van het type character omzetten naar factors.

Let op: we gebruiken de DataCamp R-workspace om de voorbeelden uit te voeren. 

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

De functie `summary` wordt gebruikt voor statistische analyse en de verdeling van de data. 

summary(iris)Mogelijk gemaakt door

Zoals je ziet, hebben we gebalanceerde data. Alle drie de doelklassen hebben 50 samples. 

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 Mogelijk gemaakt door

Train-test-split

We zetten een seed voor reproduceerbaarheid en splitsen de data in train- en testsets voor modeltraining en -evaluatie. We gebruiken een 80:20-split. 

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,]Mogelijk gemaakt door

Een neuraal netwerk trainen

Het neuralnet-package is verouderd, maar nog steeds populair in de R-community. 

De functie `neuralnet` is eenvoudig. Je kunt er niet volledig vrij mee een aangepaste modelarchitectuur maken. 

In ons geval geven we, net als bij GLM, een machine-learningformule en data mee. De formule bestaat uit doelvariabelen en features. 

Daarna maken we twee verborgen lagen: de eerste met vier neuronen en de tweede met twee neuronen. 

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

Om onze modelarchitectuur te bekijken, gebruiken we de functie `plot`. Deze vereist een modelobject en het argument `rep`. 

plot(model,rep = "best")Mogelijk gemaakt door

Model-evaluatie

Voor de confusionmatrix:

1. We voorspellen categorieën met de testset. 
2. Maak een lijst met categorienamen.
3. Maak een predictiedataframe en vervang numerieke outputs door labels. 
4. Gebruik tabellen om ‘actual’ en ‘predicted’ waarden naast elkaar weer te geven. 

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)Mogelijk gemaakt door

We kregen bijna perfecte resultaten. Het lijkt erop dat ons model drie samples onjuist heeft geclassificeerd. We kunnen het resultaat verbeteren door meer neuronen aan elke laag toe te voegen. 

           prediction_label
            setosa versicolor virginica
  setosa          8          0        0
  versicolor      0         13        0
  virginica       0          3        6 Mogelijk gemaakt door

Om de nauwkeurigheid te controleren, moeten we eerst de werkelijke categorische waarden omzetten naar numerieke waarden en deze vergelijken met de voorspelde waarden. Als resultaat krijgen we een lijst met booleaanse waarden. 

We kunnen de functie `sum` gebruiken om het aantal `TRUE`-waarden te vinden en dit delen door het totale aantal samples om de nauwkeurigheid te krijgen. 

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

Het model heeft waarden voorspeld met 90% nauwkeurigheid. 

90Mogelijk gemaakt door

Let op: de broncode voor dit voorbeeld is beschikbaar in de R-workspace: Building Neural Network (NN) Models in R.

Convolutioneel neuraal netwerk in R met Keras

In dit voorbeeld gebruiken we Keras en TensorFlow om een convolutioneel neuraal netwerk te bouwen en te trainen voor een beeldclassificatietaak. Daarvoor gebruiken we de cifar10-afbeeldingsdataset met 60.000 32x32-kleurafbeeldingen, gelabeld in tien categorieën.

Afbeelding van CIFAR-10

Importeer essentiële R-packages. 

library(keras)
library(tensorflow)Mogelijk gemaakt door

De data voorbereiden

We importeren de ingebouwde Keras-dataset en splitsen deze in train- en testsets. 

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

Deel de train- en testfeatures door 255 om de data te normaliseren. 

x_train <- x_train / 255
x_test <-  x_test / 255Mogelijk gemaakt door

Het model bouwen

De Keras-API geeft ons de flexibiliteit om volledig aanpasbare, complexe neurale-netwerkarchitecturen te bouwen. 

In ons geval maken we meerdere convolutionele lagen, gevolgd door een max-poolinglaag, dropoutlaag, dense laag en uitvoerlaag. 

We gebruiken ‘Leaky ReLU’ als activatiefunctie voor alle lagen behalve de uitvoerlaag. Daar gebruiken we ‘softmax’. 

We moeten de inputvorm van de eerste 2D-convolutionele laag instellen op de afbeeldingsvorm (32,32,3) van de trainingsdataset. 

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')Mogelijk gemaakt door

Om de modelarchitectuur te bekijken, gebruiken we de functie `summary`. 

summary(model)Mogelijk gemaakt door

We hebben twee convolutionele lagen gevolgd door een max-poolinglaag, nog twee convolutionele lagen, een max-poolinglaag, een flatten-laag om de maximaal gefilterde output in vectoren om te zetten, en vervolgens twee dense lagen. 

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
________________________________________________________________________________Mogelijk gemaakt door

Het model compileren

1. We stellen de learning rate in met de functie voor exponentiële afname. Die verlaagt de learning rate na 1500 stappen met 0,98.
2. Geef het learning-rate-object door aan de Adamax-optimizer.
3. Onze verliesfunctie is sparse categorical cross-entropy.
4. Compileer het model met verlies- en optimizerfunctie en prestatiemetriek.

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"
)Mogelijk gemaakt door

Het model trainen

We fitten ons model en slaan de evaluatiemetriek op in `history`. 

• We trainen het model 10 epochs en zetten de batchgrootte op 32. 
• We voegen de testset toe voor validatie.
• Het argument `shuffle` husselt de trainingsdata aan het begin van elke epoch. 

history <- model %>% fit(
  x_train, y_train,
  batch_size = 32,
  epochs = 10,
  validation_data = list(x_test, y_test),
  shuffle = TRUE
)Mogelijk gemaakt door

Het model evalueren

Je kunt het model op de testset evalueren met de functie `evaluate`; die retourneert de uiteindelijke loss en accuracy. 

model %>% evaluate(x_test, y_test)Mogelijk gemaakt door

Het model opnieuw trainen op 50 epochs zal de nauwkeurigheid verbeteren. 

Loss 0.648191571235657 Accuracy 0.776799976825714Mogelijk gemaakt door

Om lijngrafieken voor loss en accuracy per epoch te plotten, gebruiken we de functie `plot`. 

plot(history)Mogelijk gemaakt door

Als we naar de grafiek kijken, zien we dat de lijn nog niet is afgevlakt. Dat betekent dat we met meer epochs de modelmetriek kunnen verbeteren. 

Wil je meer leren over de Keras-API en hoe je die kunt gebruiken om diepe neurale netwerken te bouwen? Bekijk dan de tutorial keras: Deep Learning in R. 

Toepassingen van neurale netwerken

We zien voorbeelden van neurale netwerken overal, van mobiele apps tot de industrie. Door de recente doorbraak van taal- en grote visuele modellen raken steeds meer bedrijven geïnteresseerd in het implementeren van diepe neurale netwerken om winst en klanttevredenheid te verhogen. 

In deze sectie bekijken we de top 10 toepassingen van neurale netwerken die de moderne wereld vormgeven. 

1. Tabelvoorspelling

Eenvoudige neurale netwerken zijn behoorlijk effectief op grote tabeldata. We kunnen ze gebruiken voor classificatie-, clustering- en regressieproblemen. 

2. Aandelenkoersvoorspelling

Veel bedrijven gebruiken LSTM, GRU en RNN voor financiële voorspellingen. Dat helpt hen betere beslissingen te nemen. 

3. Medische beeldvorming

Borstkankerdetectie, anomaliedetectie en beeldsegmentatie zijn enkele toepassingen van convolutionele neurale netwerken. Door voorgetrainde transformers zien we geavanceerd onderzoek naar ziektepreventie en vroege detectie van ernstige aandoeningen.  

4. E-commerce

Productaanbevelingen, gepersonaliseerde ervaringen en chatbots zijn enkele toepassingen van neurale netwerken in e-commerce. Deze modellen worden vooral gebruikt voor clustering, natural language processing en computervisie om de gebruikerservaring op het platform te verbeteren. 

5. Generatieve afbeeldingen

Door de populariteit van DALL·E 2 en Stable Diffusion is dit domein mainstream geworden. Bedrijven zoals Canva en Adobe hebben generatieve afbeeldingsmogelijkheden al geïmplementeerd om het aantal gebruikers te vergroten. Los van de hype worden generatieve afbeeldingen in elke industrie gebruikt om synthetische data te maken ter verbetering van de prestaties, stabiliteit en bias van modellen. 

6. Generatieve tekst

ChatGPT, GPT-3 en GPT-NEO zijn de diepe neurale-netwerkmodellen die dit domein domineren. Deze modellen worden gebruikt voor programmeerassistentie, chatbots, vertaling, vraag/antwoord en meer. Ze zijn overal, en bedrijven vinden het makkelijk om ze te integreren in hun bestaande systemen.

7. Klantenservice-chatbot

DialoGPT en BlenderBot zijn populaire conversational modellen die je chatexperience verbeteren. Ze zijn adaptief en kunnen worden fijn-afgesteld voor een specifiek doel. In de toekomst zien we geen lange wachttijden meer; deze chatbots zullen je problemen begrijpen en in realtime oplossingen bieden. 

8. Robotica

Reinforcement learning en computervisie-modellen spelen een grote rol in transformatie van industrieën. Denk aan volledig geautomatiseerd magazijnbeheer, fabrieken en winkelervaringen. 

9. Spraakherkenning

Spraakherkenning, tekst-naar-spraak en detectie van audio-activiteit zijn neurale-netwerkmodellen die worden ingezet voor spraakassistentie, automatische transcriptie en verbeterde communicatie-applicaties. 

10. Multimodaal

Text-to-Image (DALLE-2), Image-to-Text, Visual Question Answering en feature-extractie zijn enkele toepassingen in multimodale neurale netwerken. In de toekomst zie je text-to-video met audio. Je kunt dan een volledige film maken door het script aan te leveren.

Conclusie

De R-packages Keras en TensorFlow bieden een volledige reeks tools om complexe modelarchitecturen voor specifieke taken te bouwen. Je kunt de dataset laden, pre-processing uitvoeren, het model bouwen en optimaliseren, en het model evalueren met een paar regels code. Bovendien kun je met TensorFlow je experimenten monitoren, GPU's configureren en het model in productie brengen. 

In deze tutorial hebben we de basis van neurale netwerken, de typen modelarchitectuur en hun toepassingen doorgenomen. Bovendien hebben we geleerd hoe je een eenvoudig neuraal netwerk traint met `neuralnet` en een convolutioneel neuraal netwerk met `keras`. De tutorial behandelt het bouwen, compileren, trainen en evalueren van het model. 

Leer meer over de TensorFlow- en Keras-API in de cursus Introduction to TensorFlow in R. Je leert over TensorBoard en andere TensorFlow-API's, bouwt diepe neurale netwerken en verbetert de modelprestaties met regularisatie, dropout en hyperparameteroptimalisatie.