keras: Deep Learning in R

Zoals je inmiddels weet, is machine learning een deelgebied binnen Computerwetenschappen (CS). Deep learning is vervolgens een deelgebied van machine learning: een verzameling algoritmes geïnspireerd op de structuur en werking van de hersenen, meestal aangeduid als Artificial Neural Networks (ANN). Deep learning is op dit moment een van de hotste trends binnen machine learning, en er zijn veel problemen waarin deep learning uitblinkt, zoals robotica, beeldherkenning en Artificial Intelligence (AI).

De tutorial van vandaag geeft je een korte introductie tot deep learning in R met Keras via het keras-pakket:

# Load in the keras package
library(keras)

# Install TensorFlow
install_tensorflow()

Data laden

Nu het installatieproces helder is en je werkruimte klaarstaat, kun je data gaan inladen! Op dit punt heb je drie grote opties voor je data: je kunt een van de ingebouwde datasets gebruiken die met het keras-pakket meekomen, je kunt je eigen dataset laden uit bijvoorbeeld CSV-bestanden, of je kunt wat dummydata maken.

In welke situatie je ook zit, je zult zien dat je snel met het pakket aan de slag kunt. In deze sectie lopen we kort de drie opties door en leggen we uit hoe je de data die je nodig hebt kunt laden (of maken) om te beginnen!

# Read in MNIST data
mnist <- dataset_mnist()

# Read in CIFAR10 data
cifar10 <- dataset_cifar10()

# Read in IMDB data
imdb <- dataset_imdb()

Data verkennen

Voor deze tutorial werk je verder met de bekende iris-dataset die je met de functie read.csv() hebt ingelezen.

Voor wie de benodigde biologiekennis mist om met deze data te werken, hier wat achtergrond: alle bloemen hebben een kelkblad (sepal) en kroonblad (petal). Het kelkblad omsluit de kroonbladeren en is typisch groen en bladachtig, terwijl de kroonbladeren meestal gekleurde bladeren zijn. Bij irissen is dit net wat anders, zoals je in de volgende afbeelding ziet:

Je hebt in de vorige sectie misschien al gezien dat het iris-data frame na het importeren geen kolomnamen had. Voor de rest van de tutorial is dat niet heel belangrijk: ook al geeft read.csv() je data terug in een data.frame, de data die je aan de fit()-functie moet doorgeven, moet een matrix of array zijn.

Een paar dingen om te onthouden over de twee genoemde datastructuren: - Matrices en arrays hebben geen kolomnamen; - Matrices zijn tweedimensionale objecten met één datatype; - Arrays zijn meerdimensionale objecten met één datatype;

Tip: bekijk deze video als je de datastructuren in R wilt opfrissen!

Een data frame is daarentegen een speciaal soort benoemde lijst waarin alle elementen dezelfde lengte hebben. Het is een meerdimensionaal object dat meerdere datatypes kan bevatten. Dat zag je al toen je in de vorige sectie de structuur van het iris-data frame bekeek. Gezien dit, en omdat je straks naar een twee- of meerdimensionaal object met één datatype toe moet werken, kun je je alvast voorbereiden op wat voorbewerking voordat je je neurale netwerk gaat bouwen!

Voor nu kunnen kolomnamen handig zijn voor de verkenning, en ze maken het begrijpen van de data zeker makkelijker. Laten we dus wat kolomnamen toevoegen met de names()-functie. Vervolgens kun je de variabele iris meteen gebruiken in je data-exploratie! Plot bijvoorbeeld hoe de petal length en petal width met elkaar correleren met de plot()-functie.

Let op dat je de unclass()-functie gebruikt om de namen van de soorten, dus “setosa, versicolor” en “virginica”, om te zetten naar de numerieke waarden 1, 2 en 3.

Bekijk nu de output van de plotfunctie eens goed:

De grafiek geeft voor de verschillende soorten irissen een positieve correlatie aan tussen Petal.Length en Petal.Width. Dit wil je waarschijnlijk ook testen met de cor()-functie, die je de totale correlatie geeft tussen alle attributen die in de dataset zijn opgenomen:

Daarnaast kun je het corrplot-pakket in combinatie met de cor()-functie gebruiken om de correlaties tussen de attributen van je data te plotten; In dit geval bereken je de totale correlatie voor alle attributen van het iris-data frame. Je slaat het resultaat op in variabele M en geeft die door aan de corrplot()-functie.

Vergeet niet een method-argument te specificeren om aan te geven hoe je de data wilt plotten!

Je kunt verder experimenteren met de visualisatiemethode in de DataCamp Light-chunk hieronder:

Gebruik de R-console om je data verder te verkennen.

Als je grafieken voor deze data wilt maken met het ggvis-pakket, de interactieve grammar of graphics, bekijk dan DataCamp’s tutorial Machine Learning in R For Beginners of volg DataCamp’s ggvis-cursus.

Data voorbewerken

Voordat je je model kunt bouwen, moet je er ook voor zorgen dat je data opgeschoond is, genormaliseerd (indien van toepassing) en verdeeld in trainings- en testsets. Omdat de dataset uit de UCI Machine Learning Repository komt, kun je verwachten dat deze al enigszins schoon is, maar laten we de kwaliteit van je data toch even dubbelchecken.

Op het eerste gezicht zag je bij head() niet echt iets bijzonders, toch? Gebruik summary() en str() om kort te herhalen wat je leerde toen je controleerde of je import gelukt was:

Nu je zeker weet dat de data schoon genoeg is, kun je controleren of normalisatie nodig is voor de data waarmee je in deze tutorial werkt.

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

Het model construeren

Om een model te bouwen, initialiseer je eerst een sequentieel model met behulp van de functie keras_model_sequential(). Daarna kun je gaan modelleren.

Het is echter een goed idee om eerst nog even terug te gaan naar je oorspronkelijke vraag bij deze dataset: kun je de soort van een bepaalde irisbloem voorspellen? Werken met numerieke data is eenvoudiger, en je hebt de data voorbewerkt en de doelvariabele one-hot gecodeerd: een bloem is ofwel versicolor, setosa of virginica, en dat wordt weergegeven met binaire 1- en 0-waarden.

Een type netwerk dat goed presteert op zo’n probleem is een multi-layer perceptron. Dit type neuraal netwerk is vaak volledig verbonden. Dat betekent dat je een relatief eenvoudige stapel fully connected-lagen gaat bouwen om dit probleem op te lossen. Wat betreft de activatiefuncties, gebruik je hier het best een van de meest gangbare om vertrouwd te raken met Keras en neurale netwerken: de relu-activatie. Deze rectifier-activatie gebruik je in een verborgen laag, wat doorgaans een goede praktijk is.

Daarnaast zie je dat de softmax-activatie wordt gebruikt in de outputlaag. Dat doe je omdat je zeker wilt zijn dat de outputwaarden tussen 0 en 1 liggen en als voorspelde kansen gebruikt kunnen worden:

Let op hoe de outputlaag 3 outputwaarden maakt, één voor elke iris-klasse (versicolor, virginica of setosa). De eerste laag, met 8 verborgen nodes, heeft daarentegen een input_shape van 4. Dat komt omdat je trainingsdata iris.training 4 kolommen heeft.

Je kunt je model verder inspecteren met de volgende functies:

• Met de summary()-functie kun je een samenvattende weergave van je model printen;
• get_config() geeft een lijst terug met de configuratie van het model;
• get_layer() geeft de configuratie van de laag terug.
• De eigenschap layers kun je gebruiken om een vlakke lijst van de lagen van het model op te halen;
• Om de input-tensors te lijsten, gebruik je de eigenschap inputs; en
• Tot slot kun je met de eigenschap outputs de output-tensors ophalen.

Het model compileren en fitten

Nu je de architectuur van je model hebt opgezet, is het tijd om het model te compileren en te fitten op de data. Om je model te compileren, configureer je het met de adam-optimizer en de loss-functie categorical_crossentropy. Daarnaast monitor je de nauwkeurigheid tijdens het trainen door 'accuracy' door te geven aan het metrics-argument.

De optimizer en de loss zijn twee vereiste argumenten als je het model wilt compileren.

Enkele van de meest populaire optimalisatie-algoritmes zijn Stochastic Gradient Descent (SGD), ADAM en RMSprop. Afhankelijk van welk algoritme je kiest, moet je bepaalde parameters afstemmen, zoals learning rate of momentum. De keuze voor een loss-functie hangt af van je taak: voor een regressieprobleem gebruik je bijvoorbeeld meestal de Mean Squared Error (MSE).

Zoals je in dit voorbeeld ziet, gebruik je de loss-functie categorical_crossentropy voor het multiclass-classificatieprobleem om te bepalen of een iris versicolor, virginica of setosa is. Als je echter een binaire classificatie had, dan had je binary_crossentropy moeten gebruiken.

Vervolgens kun je het model fitten op je data; In dit geval train je het model 200 epochs of iteraties over alle samples in iris.training en iris.trainLabels, in batches van 5 samples.

Tip: als je wilt, kun je ook het verbose-argument in de fit()-functie opgeven. Door dit argument op 1 te zetten, geef je aan dat je de voortgangsbalk wilt zien.

Wat je hierboven doet, is het model trainen voor een bepaald aantal epochs of exposities aan de trainingsdataset. Een epoch is één keer door de volledige trainingsset, gevolgd door testen op de validatieset. De batchgrootte die je hierboven specificeert, bepaalt het aantal samples dat door het netwerk gaat. Ook optimaliseer je hiermee de efficiëntie, omdat je ervoor zorgt dat je niet te veel inputpatronen tegelijk in het geheugen laadt.

De trainingsgeschiedenis van het model visualiseren

Het is ook goed om te weten dat je de fitting kunt visualiseren als je de code uit de DataCamp Light-chunk hierboven aan een variabele toekent. Je kunt de variabele vervolgens doorgeven aan de plot()-functie, zoals je in deze code-chunk ziet!

Bestudeer de plot in meer detail.

Op het eerste gezicht is het niet verrassend dat dit er wat rommelig uitziet. Je weet misschien niet precies waar je naar kijkt, toch?

Een goed ding om te weten: loss en acc geven respectievelijk het verlies en de nauwkeurigheid van het model voor de trainingsdata aan, terwijl val_loss en val_acc dezelfde metrics zijn voor de test- of validatiedata.

Maar zelfs als je dit weet, zijn deze twee grafieken niet eenvoudig te interpreteren. Laten we dit opsplitsen in delen die je makkelijker begrijpt! Je splitst de twee plots en maakt er twee losse van: één voor het modelverlies en één voor de modelnauwkeurigheid. Gelukkig kun je eenvoudig gebruikmaken van de $-operator om de data te benaderen en stap voor stap te plotten.

Bekijk de DataCamp Light-box hieronder om te zien hoe je dit doet:

In deze eerste plot heb je het verlies van het model op de trainings- en testdata geplot. Tijd om hetzelfde te doen, maar dan voor de nauwkeurigheid van het model:

Een paar dingen om hier in gedachten te houden:

• Als de nauwkeurigheid op je trainingsdata blijft verbeteren terwijl die op je validatiedata slechter wordt, overfit je waarschijnlijk: je model begint de data te onthouden in plaats van ervan te leren.
• Als de trend voor nauwkeurigheid op beide datasets in de laatste paar epochs nog stijgt, kun je duidelijk zien dat het model de trainingsdata nog niet te veel heeft geleerd.

Labels van nieuwe data voorspellen

Nu je model is gemaakt, gecompileerd en gefit op de data, is het tijd om je model daadwerkelijk te gebruiken om de labels voor je testset iris.test te voorspellen. Zoals je verwachtte, kun je hiervoor de predict()-functie gebruiken. Daarna kun je de confusion matrix printen om de voorspellingen en de echte labels van de iris.test-data te bekijken met behulp van de table()-functie.

Wat vind je van de resultaten? Maakt het model dat je hebt gemaakt op het eerste gezicht de juiste voorspellingen?

Je model evalueren

Hoewel je al een idee hebt van de prestaties door naar de voorspelde labels voor iris.test te kijken, is het toch belangrijk om de tijd te nemen om je model te evalueren. Gebruik hiervoor de evaluate()-functie: geef de testdata iris.test en de testlabels iris.testLabels door en definieer de batchgrootte. Sla het resultaat op in een variabele score, zoals in het codevoorbeeld hieronder:

Door score te printen, krijg je de loss-waarde en de metric-waarde (in dit geval 'accuracy') terug.

Je model fijnstemmen

Je model fijnstemmen is waarschijnlijk iets wat je vaak zult doen, zeker in het begin, omdat niet alle classificatie- en regressieproblemen zo rechttoe rechtaan zijn als het probleem in het eerste deel van deze tutorial. Zoals je hierboven las, zijn er al twee belangrijke beslissingen die je waarschijnlijk wilt aanpassen: hoeveel lagen je gaat gebruiken en hoeveel “hidden units” je per laag kiest.

In het begin is dat best een zoektocht.

Naast spelen met het aantal epochs of de batchgrootte, zijn er andere manieren om je model te tweaken in de hoop dat het beter presteert: door lagen toe te voegen, door het aantal verborgen units te vergroten en door je eigen optimalisatieparameters aan de compile()-functie door te geven. In deze sectie bespreken we deze drie opties.

Je model opslaan, laden of exporteren

Er is nog één ding dat overblijft in je reis met het keras-pakket: je model opslaan of exporteren zodat je het op een later moment weer kunt laden.

• Allereerst kun je eenvoudig gebruikmaken van de functies save_model_hdf5() en load_model_hdf5() om je model in je werkruimte op te slaan en te laden:

save_model_hdf5(model, "my_model.h5")
model <- load_model_hdf5("my_model.h5")

• Daarnaast kun je ook de modelgewichten opslaan en laden met de functies save_model_weights_hdf5() en load_model_weights_hdf5() :

save_model_weights_hdf5("my_model_weights.h5")
model %>% load_model_weights_hdf5("my_model_weights.h5")

• Tot slot is het goed om te weten dat je de modelconfiguratie ook kunt exporteren naar JSON of YAML. De functies model_to_json() en model_to_yaml() helpen je hierbij. Om de configuraties terug in je werkruimte te laden, gebruik je gewoon de functies model_from_json() en model_from yaml():

json_string <- model_to_json(model)
model <- model_from_json(json_string)

yaml_string <- model_to_yaml(model)
model <- model_from_yaml(yaml_string)