Keras-tutorial: Deep learning in Python

Deze Keras-tutorial is een introductie tot deep learning in Python: leer je data voorbewerken, neurale netwerken modelleren, evalueren en optimaliseren.

Bijgewerkt 2 okt 2026 · 15 min lezen

Verken met AI

ChatGPT Claude Perplexity

Tegenwoordig ken je waarschijnlijk al machine learning, een tak binnen de informatica die de ontwikkeling bestudeert van algoritmen die kunnen leren. Vandaag focus je op deep learning, een deelgebied van machine learning met een reeks algoritmen die geïnspireerd zijn op de structuur en werking van het brein. Deze algoritmen worden meestal kunstmatige neurale netwerken (ANN) genoemd. Deep learning is een van de hotste velden in data science, met talloze casestudy's die verbluffende resultaten laten zien in robotica, beeldherkenning en kunstmatige intelligentie (AI).

Een van de krachtigste en gemakkelijkst te gebruiken Python-bibliotheken voor het ontwikkelen en evalueren van deep learning-modellen is Keras; het wikkelt de efficiënte numerieke rekenbibliotheken Theano en TensorFlow. Het voordeel is vooral dat je op een gemakkelijke en leuke manier met neurale netwerken kunt beginnen.

banner skill track deep learning in python

De Keras-tutorial voor beginners van vandaag introduceert je in de basis van deep learning met Python:

Je leert eerst wat kunstmatige neurale netwerken zijn
Vervolgens laat de tutorial je stap voor stap zien hoe je Python en zijn bibliotheken gebruikt om je data te begrijpen, verkennen en visualiseren,
Hoe je je data preprocesset: je leert hoe je je data opsplitst in train- en testsets en hoe je je data kunt standaardiseren,
Hoe je multilayer perceptrons bouwt voor classificatietaken,
Hoe je de data compileert en fit op deze modellen,
Hoe je je model gebruikt om doelwaarden te voorspellen, en
Hoe je de modellen valideert die je hebt gebouwd.
Tot slot zie je ook hoe je een model voor regressietaken opzet, en leer je hoe je het door jou gebouwde model kunt fine-tunen.

Wil je een cursus volgen over Keras en deep learning in Python? Overweeg dan DataCamp's Deep Learning in Python-cursus!

Mis ook onze Keras-cheat sheet niet, die de zes stappen laat zien die je moet doorlopen om neurale netwerken in Python te bouwen, inclusief codevoorbeelden!

Introductie van kunstmatige neurale netwerken

Voor je dieper in Keras duikt en hoe je het kunt gebruiken om met deep learning in Python te starten, is het handig dat je het een en ander weet over neurale netwerken. Zoals je in de vorige sectie kort las, vonden neurale netwerken hun inspiratie in de biologie, waar de term “neuronaal netwerk” ook voor neuronen wordt gebruikt. Het menselijk brein is dan een voorbeeld van zo'n neuraal netwerk, dat is samengesteld uit een aantal neuronen.

En zoals je weet, is het brein in staat vrij complexe berekeningen uit te voeren, en daar komt de inspiratie voor kunstmatige neurale netwerken vandaan. Het netwerk als geheel is een krachtig modelleringsinstrument.

Perceptrons

Het eenvoudigste neurale netwerk is de “perceptron”, die in zijn simpelste vorm uit één enkele neuron bestaat. Net als biologische neuronen, die dendrieten en axonen hebben, is de kunstmatige enkelvoudige neuron een eenvoudige boomstructuur met invoerknooppunten en één uitvoerknooppunt, dat verbonden is met elk invoerknooppunt. Hier is een visuele vergelijking van beide:

biologische neuron versus diagram kunstmatig neuraal netwerk

Zoals je op de afbeelding ziet, hebben kunstmatige neuronen zes componenten. Van links naar rechts zijn dit:

Invoerknooppunten. Elk invoerknooppunt heeft een numerieke waarde, die elk reëel getal kan zijn. Onthoud dat reële getallen het volledige spectrum vormen: ze kunnen positief of negatief zijn, gehele of decimale getallen.
Verbindingen. Op vergelijkbare wijze heeft elke verbinding die van het invoerknooppunt vertrekt een gewicht, en ook dat kan elk reëel getal zijn.
Vervolgens worden alle waarden van de invoerknooppunten en de gewichten van de verbindingen samengebracht: ze dienen als input voor een gewogen som: \(y = f(\sum_{i=1}^{D} w_i*x_i)\), of, anders geformuleerd, \(y = f(w_1*x_1 + w_2*x_2 + ... w_D*x_D)\).
Dit resultaat is de input voor een transfer- of activatiefunctie. In het eenvoudigste maar triviale geval is deze transferfunctie een identiteitsfunctie, \(f(x)=x\) of \(y=x\). In dit geval is \(x\) de gewogen som van de invoerknooppunten en de verbindingen. Maar net zoals een biologisch neuron pas “vuurt” wanneer een bepaalde drempel wordt overschreden, zal de kunstmatige neuron ook pas vuren wanneer de som van de inputs een drempel overschrijdt, bijvoorbeeld 0. Dat vind je niet terug in een identiteitsfunctie! De meest intuïtieve manier is een systeem als het volgende te bedenken:
\(f(x) = 0\) als \(x<0\)
\(f(x) = 0{,}5\) als \(x=0\)
\(f(x) = 1\) als \(x>0\)
Je kunt je voorstellen dat de output dan geen vloeiende lijn is: het is een discontinue functie. Omdat dit problemen kan veroorzaken in de wiskundige verwerking, wordt vaak een continue variant gebruikt: de sigmoidfunctie. Een voorbeeld van een sigmoid dat je misschien al kent, is de logistische functie. Met deze functie krijg je een veel vloeiender resultaat!
Het resultaat is het uitvoerknooppunt, dat hoort bij de functie (zoals de sigmoid) van de gewogen som van de invoerknooppunten. Merk op dat de sigmoid een wiskundige functie is die een S-vormige curve oplevert; later lees je hier meer over.
Tot slot kan de perceptron een extra parameter hebben, de bias, die je kunt zien als het gewicht dat hoort bij een extra invoerknooppunt dat permanent op 1 staat. De bias is cruciaal omdat je daarmee de activatiefunctie naar links of rechts kunt verschuiven, wat bepalend kan zijn voor het succes van je training.

Logische consequentie van dit model is dat perceptrons alleen met numerieke data werken. Dit betekent dat je nominale data moet omzetten naar een numeriek formaat.

Nu je weet dat perceptrons met drempels werken, is de stap naar classificatie niet groot: de perceptron kan bepalen dat elke output boven een bepaalde drempel aangeeft dat een instantie tot de ene klasse behoort, terwijl een output onder de drempel betekent dat de input tot de andere klasse behoort. De rechte lijn waar de output gelijk is aan de drempel vormt dan de grens tussen de twee klassen.

Multilayer perceptrons

Netwerken van perceptrons zijn multilayer perceptrons, en dat is wat deze tutorial in Python met behulp van Keras implementeert! Multilayer perceptrons staan ook bekend als “feedforwardneurale netwerken”. Zoals je wellicht al vermoedde, zijn dit complexere netwerken dan de perceptron, omdat ze uit meerdere neuronen bestaan die in lagen zijn georganiseerd. Het aantal lagen is meestal beperkt tot twee of drie, maar in theorie is er geen limiet!

De lagen werken sterk zoals de biologische neuronen waar je hierboven over las: de outputs van de ene laag dienen als inputs voor de volgende laag.

Tussen de lagen onderscheid je een invoerlaag, verborgen lagen en een uitvoerlaag. Multilayer perceptrons zijn vaak volledig verbonden. Dit betekent dat er een verbinding is van elke perceptron in een bepaalde laag naar elke perceptron in de volgende laag. Hoewel volledige verbondenheid geen vereiste is, is het doorgaans wel zo.

Merk op dat terwijl de perceptron alleen lineaire scheidingen tussen klassen kon representeren, de multilayer perceptron die beperking overwint en ook complexere beslissingsgrenzen kan weergeven.

Wijntypes voorspellen in Python met Keras

Voor deze tutorial gebruik je de wine quality-dataset die je kunt vinden in de wine quality-dataset van de UCI Machine Learning Repository. Idealiter pas je deep learning toe op grotere datasets, maar voor deze tutorial gebruik je een kleinere. Het doel is vooral om je op weg te helpen met de bibliotheek en je vertrouwd te maken met hoe neurale netwerken werken.

Misschien ken je deze dataset al, want het is een van de populairste datasets om te leren hoe je machinelearningproblemen aanpakt. In dit geval helpt hij je op weg met deep learning in Python met Keras.

Laten we beginnen!

De data begrijpen

Voordat je de data inlaadt, is het handig om te checken hoeveel je eigenlijk weet over wijn (in relatie tot de dataset, natuurlijk). De meesten weten dat er grofweg twee populaire soorten wijn zijn: rood en wit.

(Ik weet zeker dat er veel meer zijn, maar voor de eenvoud en door mijn beperkte wijnkennis laat ik het hierbij. Mijn excuses aan de echte kenners onder jullie :)).

Dat weten is één ding, maar als je deze data wilt analyseren, moet je net iets meer weten.

Bekijk eerst de map met de databescrijving om te zien welke variabelen zijn opgenomen. Dit is meestal de eerste stap om je data te begrijpen. Ga naar deze pagina voor de beschrijving of lees verder om je data iets beter te leren kennen.

De data bestaat uit twee datasets die betrekking hebben op rode en witte varianten van de Portugese “Vinho Verde”-wijn. Zoals in de beschrijving staat, vind je in deze dataset alleen fysisch-chemische en sensorische variabelen. Het beschrijvingsbestand somt de 12 opgenomen variabelen op, maar voor wie, net als ik, geen scheikundige is, volgt hier een korte uitleg per variabele:

Vaste zuren: zuren zijn belangrijke wijneigenschappen en dragen sterk bij aan de smaak. Meestal wordt de totale zuurgraad verdeeld in twee groepen: vluchtige zuren en niet-vluchtige of vaste zuren. Onder de vaste zuren die je in wijn vindt, zijn onder andere wijnsteenzuur, appelzuur, citroenzuur en barnsteenzuur. In de datasets is deze variabele uitgedrukt in g(\(tartaric acid\))/\(dm^3\).
Vluchtige zuren: de vluchtige zuurgraad is in feite het proces waarbij wijn in azijn verandert. In de VS zijn de wettelijke limieten voor vluchtige zuurgraad 1,2 g/L voor rode tafelwijn en 1,1 g/L voor witte tafelwijn. In deze datasets is de vluchtige zuurgraad uitgedrukt in g(\(acetic acid\))/\(dm^3\).
Citroenzuur is een van de vaste zuren die je in wijn aantreft. Het is uitgedrukt in g/\(dm^3\) in beide datasets.
Restsuiker verwijst doorgaans naar de suiker die overblijft nadat de gisting stopt of is gestopt. Het is uitgedrukt in g/\(dm^3\) in de red- en white-data.
Chloriden kunnen aanzienlijk bijdragen aan ziltigheid in wijn. Hier is het uitgedrukt in g(\(sodium chloride\))/\(dm^3\).
Vrij zwaveldioxide: het deel van het zwaveldioxide dat aan wijn wordt toegevoegd en dat daarin “verdwijnt”, wordt gebonden genoemd, terwijl het actieve deel vrij wordt genoemd. De wijnmaker probeert altijd een zo hoog mogelijk aandeel vrij zwavel ten opzichte van gebonden te bereiken. In de data is deze variabele uitgedrukt in mg/\(dm^3\).
Totaal zwaveldioxide is de som van het gebonden en vrije zwaveldioxide (SO2). Hier uitgedrukt in mg/\(dm^3\). Er zijn wettelijke limieten voor het zwavelgehalte in wijn: in de EU mag rode wijn 160 mg/L bevatten, terwijl witte en roséwijnen circa 210 mg/L mogen hebben. Zoete wijnen mogen 400 mg/L bevatten. In de VS is de limiet 350 mg/L en in Australië 250 mg/L.
Dichtheid wordt doorgaans gebruikt als maat voor de omzetting van suiker naar alcohol. Hier uitgedrukt in g/\(cm^3\).
pH of het potentiaal van waterstof is een numerieke schaal om de zuurgraad of basischheid van wijn aan te geven. Oplossingen met een pH lager dan 7 zijn zuur, met een pH hoger dan 7 basisch. Met pH 7 is zuiver water neutraal. De meeste wijnen hebben een pH tussen 2,9 en 3,9 en zijn dus zuur.
Sulfaten zijn voor wijn wat gluten voor voedsel zijn. Je kent sulfieten misschien van de hoofdpijn die ze kunnen veroorzaken. Ze zijn wereldwijd een regulier onderdeel van het wijnmaken en worden als noodzakelijk beschouwd. In dit geval zijn ze uitgedrukt in g(\(potassium sulphate\))/\(dm^3\).
Alcohol: wijn is een alcoholische drank en zoals je weet kan het alcoholpercentage per wijn verschillen. Het is niet verrassend dat deze variabele is opgenomen; in de datasets uitgedrukt in % vol.
Kwaliteit: wijnexperts beoordeelden de wijnkwaliteit tussen 0 (zeer slecht) en 10 (uitstekend). Het uiteindelijke cijfer is de mediaan van minimaal drie beoordelingen door dezelfde experts.

Dit is natuurlijk basisinformatie die je nodig kunt hebben om te starten. Ben je een echte wijnkenner, dan weet je dit en meer!

Tijd om je data op te halen!

De data inladen

Dit kan eenvoudig met de Python-datamanipulatiebibliotheek pandas. Je volgt de importconventie en importeert het pakket onder de alias pd.

Vervolgens gebruik je de functie read_csv() om de CSV-bestanden waarin de data is opgeslagen in te lezen. Gebruik daarnaast het argument sep om aan te geven dat de scheidingsteken in dit geval een puntkomma is en geen komma.

Probeer het uit in het DataCamp Light-blok hieronder:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgSW1wb3J0IHBhbmRhcyBcbmltcG9ydCBwYW5kYXMgYXMgcGRcblxuIyBSZWFkIGluIHdoaXRlIHdpbmUgZGF0YSBcbndoaXRlID0gX19fX19fX19fX18oXCJodHRwOi8vYXJjaGl2ZS5pY3MudWNpLmVkdS9tbC9tYWNoaW5lLWxlYXJuaW5nLWRhdGFiYXNlcy93aW5lLXF1YWxpdHkvd2luZXF1YWxpdHktd2hpdGUuY3N2XCIsIHNlcD0nOycpXG5cbiMgUmVhZCBpbiByZWQgd2luZSBkYXRhIFxucmVkID0gX19fX19fX19fX18oXCJodHRwOi8vYXJjaGl2ZS5pY3MudWNpLmVkdS9tbC9tYWNoaW5lLWxlYXJuaW5nLWRhdGFiYXNlcy93aW5lLXF1YWxpdHkvd2luZXF1YWxpdHktcmVkLmNzdlwiLCBzZXA9JzsnKSIsInNvbHV0aW9uIjoiIyBJbXBvcnQgcGFuZGFzIFxuaW1wb3J0IHBhbmRhcyBhcyBwZFxuXG4jIFJlYWQgaW4gd2hpdGUgd2luZSBkYXRhIFxud2hpdGUgPSBwZC5yZWFkX2NzdihcImh0dHA6Ly9hcmNoaXZlLmljcy51Y2kuZWR1L21sL21hY2hpbmUtbGVhcm5pbmctZGF0YWJhc2VzL3dpbmUtcXVhbGl0eS93aW5lcXVhbGl0eS13aGl0ZS5jc3ZcIiwgc2VwPSc7JylcblxuIyBSZWFkIGluIHJlZCB3aW5lIGRhdGEgXG5yZWQgPSBwZC5yZWFkX2NzdihcImh0dHA6Ly9hcmNoaXZlLmljcy51Y2kuZWR1L21sL21hY2hpbmUtbGVhcm5pbmctZGF0YWJhc2VzL3dpbmUtcXVhbGl0eS93aW5lcXVhbGl0eS1yZWQuY3N2XCIsIHNlcD0nOycpIiwic2N0IjoiRXgoKS50ZXN0X2ltcG9ydChcInBhbmRhc1wiKVxuRXgoKS50ZXN0X29iamVjdChcIndoaXRlXCIpXG5FeCgpLnRlc3Rfb2JqZWN0KFwicmVkXCIpXG5zdWNjZXNzX21zZz1cIlBlcmZlY3QhIFlvdSdyZSByZWFkeSB0byBnbyFcIiJ9

Top! Een fluitje van een cent, toch?

Dit heb je waarschijnlijk al vaak gedaan, maar het blijft een essentiële eerste stap. Nu ben je helemaal klaar om je data te verkennen, te manipuleren en te modelleren!

Data-exploratie

Met de data bij de hand is het makkelijk om meer over deze wijnen te leren! Een van de eerste dingen die je waarschijnlijk wilt doen, is snel naar beide DataFrames kijken:

Nu is het tijd om te controleren of je import geslaagd is: controleer of de data alle variabelen bevat die het beschrijvingsbestand van de UCI Machine Learning Repository beloofde. Kijk naast het aantal variabelen ook naar de kwaliteit van de import: kloppen de datatypes? Zijn alle rijen meegekomen? Zijn er null-waarden waarmee je rekening moet houden bij het opschonen?

Je wilt je data misschien met meer dan alleen info() bekijken:

Kort herhaald: head(), tail() en sample() zijn fantastisch omdat ze je snel en zonder gedoe je data laten inspecteren.

Vervolgens geeft describe() samenvattende statistieken die je helpen de datakwaliteit te beoordelen. Je ziet dat sommige variabelen een groot verschil hebben tussen hun min- en max-waarden. Dit pak je later aan, maar het is belangrijk je er nu bewust van te zijn.

Tot slot heb je met isnull() gecontroleerd of er null-waarden in red zitten. Deze functie is handig wanneer je na het lezen van de resultaten van info() nog twijfelt.

Tip: controleer ook of de wijndata null-waarden bevat. Dat kan met de IPython-shell van het DataCamp Light-blok hierboven.

Nu je al hebt gekeken of de import geslaagd en correct is, is het tijd om iets dieper te graven.

De data visualiseren

Een manier is te kijken naar de verdeling van enkele variabelen uit de dataset en scatterplots te maken om mogelijke correlaties te zien. Uiteraard kun je dit veel uitgebreider doen als je deze data voor je eigen project zou gebruiken.

Alcohol

Een variabele die meteen kan opvallen is alcohol. Het is waarschijnlijk een van de eerste dingen die je aandacht trekken wanneer je een wijndataset bekijkt. Je kunt de verdelingen met elke datavisualisatiebibliotheek tekenen, maar in dit geval gebruikt de tutorial matplotlib om ze snel te plotten:

Zoals je in de onderstaande afbeelding ziet, liggen de alcoholniveaus van rode en witte wijn grotendeels gelijk: rond 9% alcohol. Natuurlijk zijn er ook flink wat observaties met 10% of 11% alcohol.

verdeling alcohol voor een neuraal netwerkmodel

Je kunt dit dubbelchecken met de functie histogram() uit de numpy-package om het histogram van de white- en red-data te berekenen, zoals hier:

Als je geïnteresseerd bent in tutorials over matplotlib, bekijk dan zeker DataCamp's Matplotlib-tutorial voor beginners en de tutorial 3D-volumetrische data bekijken, die laat zien hoe je de event handler-API van Matplotlib gebruikt.

Sulfaten

Vervolgens ben ik benieuwd naar de relatie tussen sulfaten en de kwaliteit van de wijn. Zoals je hierboven las, kunnen sulfaten hoofdpijn veroorzaken, en ik vraag me af of dit de kwaliteit beïnvloedt. Bovendien hoor ik vaak dat vooral vrouwen geen wijn willen drinken juist vanwege hoofdpijn. Misschien beïnvloedt dit de beoordelingen van rode wijn?

Laten we kijken.

Zoals je in de onderstaande afbeelding ziet, lijkt rode wijn meer sulfaten te bevatten dan witte wijn, die minder sulfaten boven 1 g/\(dm^3\) heeft. Voor witte wijn lijken er slechts een paar uitzonderingen iets boven 1 g/\(dm^3\) te vallen, terwijl dat voor rode wijn duidelijk meer is. Dit zou misschien de algemene uitspraak kunnen verklaren dat rode wijn hoofdpijn veroorzaakt, maar hoe zit het met de kwaliteit?

Je ziet duidelijk dat er witte wijn is met relatief weinig sulfaten die een score 9 krijgt, maar verder is het op dit moment lastig om de data correct te interpreteren.

Houd er natuurlijk rekening mee dat het verschil in aantal observaties de grafieken en je interpretatie kan beïnvloeden.

deep learning python met keras

Zuurheid

Naast sulfaten is de zuurgraad een van de belangrijkste wijnkenmerken die nodig zijn om kwaliteitswijnen te maken. Grote wijnen balanceren vaak zuurgraad, tannine, alcohol en zoetheid. Uit wat extra onderzoek blijkt dat bij hoeveelheden van 0,2 tot 0,4 g/L vluchtige zuurgraad de kwaliteit niet beïnvloedt. Bij hogere niveaus kan vluchtige zuurgraad de wijn een scherpe, azijnachtige sensatie geven. Een extreem hoge vluchtige zuurgraad duidt op een ernstig gebrekkige wijn.

Laten we de data testen en een scatterplot maken van alcohol versus vluchtige zuurgraad. De datapunten moeten worden gekleurd volgens hun beoordeling of quality-label:

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

Let op: de kleuren in deze afbeelding zijn willekeurig gekozen met behulp van de NumPy-module random. Je kunt dit altijd wijzigen door een lijst door te geven aan de variabelen redcolors of whitecolors. Zorg er wel voor dat ze gelijk zijn (behalve 1, omdat de wittewijndata één unieke quality-waarde meer heeft dan de rodewijndata), anders kloppen je legendes niet!

Bekijk de volledige grafiek hier:

In de afbeelding hierboven zie je dat de niveaus waar je eerder over las vooral gelden voor witte wijn: de meeste wijnen met label 8 hebben een vluchtige zuurgraad van 0,5 of lager, maar of dit effect heeft op de kwaliteit is lastig te zeggen, omdat alle datapunten erg dicht op elkaar zitten aan één kant van de grafiek.

Dit is slechts een snelle data-exploratie. Als je deze stap in je eigen projecten verder zou willen uitwerken, bekijk dan DataCamp's posts over data-exploratie, zoals de tutorials Python Exploratory Data Analysis en Python Data Profiling, die je door de basis van EDA leiden.

De EDA afronden

Dat was misschien veel om te verwerken, dus een korte samenvatting van wat je tijdens je EDA hebt gezien en wat belangrijk kan zijn voor het vervolg van deze tutorial:

Sommige variabelen in je datasets hebben waarden die aanzienlijk ver uit elkaar liggen. Dit pak je aan in de volgende sectie van de tutorial.
Je hebt een ideaal scenario: er zijn geen null-waarden in de datasets.
De meeste wijnen in de dataset hebben rond de 9% alcohol.
Rode wijn lijkt meer sulfaten te bevatten dan witte wijn, die minder sulfaten boven 1 g/\(dm^3\) heeft.
Je zag dat de meeste wijnen een vluchtige zuurgraad van 0,5 of lager hadden. Op dit moment is er geen directe relatie met de kwaliteit van de wijn.

Tot nu toe heb je de witte en rode wijndata apart bekeken. De twee verschillen op sommige variabelen en lijken in andere gevallen juist erg op elkaar. Denk je dat er een manier is om op basis van variabelen in te delen in witte of rode wijn?

Er is maar één manier om daar achter te komen: preprocess de data en modelleer die zodat je kunt zien wat er gebeurt!

Data preprocessen

Nu je je data hebt verkend, is het tijd om op de inzichten te acteren! Laten we de data preprocessen zodat je je eigen neuraal netwerk kunt gaan bouwen!

Je zet ignore_index hier op True omdat je de indexlabels van white niet wilt behouden wanneer je de data aan red toevoegt: je wilt dat de labels doorgaan waar ze in red gebleven waren, en niet dubbele indexlabels krijgen door de twee datasets samen te voegen.

Intermezzo: correlatiematrix

Nu je de volledige dataset hebt, is het een goed idee om ook snel wat data-exploratie te doen. Je weet al het een en ander doordat je de twee datasets afzonderlijk hebt bekeken, en nu is het tijd om wat steviger inzichten te verzamelen.

Omdat grafieken soms lastig te interpreteren zijn, is het ook slim om een correlatiematrix te plotten. Daarmee zie je sneller welke variabelen met elkaar correleren:

Zoals je zou verwachten, zijn er variabelen die correleren, zoals density en residual sugar. Ook volatile acidity en type hangen nauwer samen dan je misschien had gedacht toen je de twee datasets los van elkaar bekeek, en het lag ook wel in de lijn der verwachting dat free sulfur dioxide en total sulfur dioxide zouden correleren.

correlation wine quality data

Heel interessant!

Train- en testsets

Met ongebalanceerde data bedoel je meestal een classificatieprobleem waarbij de klassen niet gelijk vertegenwoordigd zijn. De meeste classificatiedatasets hebben niet exact evenveel instanties per klasse, maar een klein verschil maakt vaak niet uit. Je moet er dus voor zorgen dat beide wijnklassen aanwezig zijn in het trainingsmodel. Bovendien moeten de aantallen van beide wijntypen min of meer gelijk zijn, zodat je in je voorspellingen niet de ene of de andere klasse voortrekt.

In dit geval lijkt er sprake van een onbalans, maar je gaat hier nu even mee verder. Daarna kun je het model evalueren en als het ondermaats presteert, kun je undersampling of oversampling toepassen om het verschil in observaties op te vangen.

Importeer nu de train_test_split uit sklearn.model_selection en wijs de data en de doellabels toe aan de variabelen X en y. Je zult zien dat je de array met doellabels moet afvlakken om de variabelen X en y als invoer voor de functie train_test_split() te kunnen gebruiken. Aan de slag: start in de DataCamp Light-blok hieronder!

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaW1wb3J0IHBhbmRhcyBhcyBwZFxuaW1wb3J0IG51bXB5IGFzIG5wXG5ucC5yYW5kb20uc2VlZCg3KVxud2hpdGUgPSBwZC5yZWFkX2NzdihcImh0dHA6Ly9hcmNoaXZlLmljcy51Y2kuZWR1L21sL21hY2hpbmUtbGVhcm5pbmctZGF0YWJhc2VzL3dpbmUtcXVhbGl0eS93aW5lcXVhbGl0eS13aGl0ZS5jc3ZcIiwgc2VwPSc7JylcbnJlZCA9IHBkLnJlYWRfY3N2KFwiaHR0cDovL2FyY2hpdmUuaWNzLnVjaS5lZHUvbWwvbWFjaGluZS1sZWFybmluZy1kYXRhYmFzZXMvd2luZS1xdWFsaXR5L3dpbmVxdWFsaXR5LXJlZC5jc3ZcIiwgc2VwPSc7JylcbnJlZFsndHlwZSddID0gMVxud2hpdGVbJ3R5cGUnXSA9IDBcbndpbmVzID0gcmVkLmFwcGVuZCh3aGl0ZSwgaWdub3JlX2luZGV4PVRydWUpIiwic2FtcGxlIjoiIyBJbXBvcnQgYHRyYWluX3Rlc3Rfc3BsaXRgIGZyb20gYHNrbGVhcm4ubW9kZWxfc2VsZWN0aW9uYFxuZnJvbSBza2xlYXJuLm1vZGVsX3NlbGVjdGlvbiBpbXBvcnQgdHJhaW5fdGVzdF9zcGxpdFxuXG4jIFNwZWNpZnkgdGhlIGRhdGEgXG5YPXdpbmVzLml4WzosMDoxMV1cblxuIyBTcGVjaWZ5IHRoZSB0YXJnZXQgbGFiZWxzIGFuZCBmbGF0dGVuIHRoZSBhcnJheSBcbnk9bnAucmF2ZWwod2luZXMudHlwZSlcblxuIyBTcGxpdCB0aGUgZGF0YSB1cCBpbiB0cmFpbiBhbmQgdGVzdCBzZXRzXG5YX3RyYWluLCBYX3Rlc3QsIHlfdHJhaW4sIHlfdGVzdCA9IHRyYWluX3Rlc3Rfc3BsaXQoWCwgeSwgdGVzdF9zaXplPTAuMzMsIHJhbmRvbV9zdGF0ZT00MikiLCJzb2x1dGlvbiI6IiMgSW1wb3J0IGB0cmFpbl90ZXN0X3NwbGl0YCBmcm9tIGBza2xlYXJuLm1vZGVsX3NlbGVjdGlvbmBcbmZyb20gc2tsZWFybi5tb2RlbF9zZWxlY3Rpb24gaW1wb3J0IHRyYWluX3Rlc3Rfc3BsaXRcblxuIyBTcGVjaWZ5IHRoZSBkYXRhIFxuWD13aW5lcy5peFs6LDA6MTldXG5cbiMgU3BlY2lmeSB0aGUgdGFyZ2V0IGxhYmVscyBhbmQgZmxhdHRlbiB0aGUgYXJyYXlcbnk9IG5wLnJhdmVsKHdpbmVzLnR5cGUpXG5cbiMgU3BsaXQgdGhlIGRhdGEgdXAgaW4gdHJhaW4gYW5kIHRlc3Qgc2V0c1xuWF90cmFpbiwgWF90ZXN0LCB5X3RyYWluLCB5X3Rlc3QgPSB0cmFpbl90ZXN0X3NwbGl0KFgsIHksIHRlc3Rfc2l6ZT0wLjMzLCByYW5kb21fc3RhdGU9NDIpIiwic2N0IjoiRXgoKS50ZXN0X2ltcG9ydChcInNrbGVhcm4ubW9kZWxfc2VsZWN0aW9uLnRyYWluX3Rlc3Rfc3BsaXRcIilcbkV4KCkudGVzdF9vYmplY3QoXCJYXCIpXG5FeCgpLnRlc3Rfb2JqZWN0KFwieVwiKVxuRXgoKS50ZXN0X29iamVjdChcIlhfdHJhaW5cIilcbkV4KCkudGVzdF9vYmplY3QoXCJYX3Rlc3RcIilcbkV4KCkudGVzdF9vYmplY3QoXCJ5X3RyYWluXCIpXG5FeCgpLnRlc3Rfb2JqZWN0KFwieV90ZXN0XCIpIn0=

Je bent al een heel eind op weg om je eerste neuraal netwerk te bouwen, maar er is nog één ding waar je aan moet denken! Weet je nog wat je ontdekte toen je de samenvattingen van de datasets white en red bekeek?

Inderdaad, sommige waarden lagen nogal ver uit elkaar. Het is zinvol om hier te standaardiseren.

Standaardiseer de data

Standaardiseren is een manier om met die ver uiteenlopende waarden om te gaan. Het scikit-learn-pakket biedt een snelle en goede manier om je data te standaardiseren: importeer de module StandardScaler uit sklearn.preprocessing en je bent klaar om je train- en testdata te schalen!

# Import `StandardScaler` from `sklearn.preprocessing`
from sklearn.preprocessing import StandardScaler

# Define the scaler 
scaler = StandardScaler().fit(X_train)

# Scale the train set
X_train = scaler.transform(X_train)

# Scale the test set
X_test = scaler.transform(X_test)

Nu je data is voorbewerkt, kun je door naar het echte werk: je eigen neuraal netwerk bouwen om wijnen te classificeren.

Modeldata

Voordat je gaat modelleren, ga je terug naar je oorspronkelijke vraag: kun je voorspellen of een wijn rood of wit is aan de hand van zijn chemische eigenschappen, zoals vluchtige zuurgraad of sulfaten?

Omdat je maar twee klassen hebt, namelijk wit en rood, ga je binaire classificatie doen. Zoals je je kunt voorstellen betekent “binair” 0 of 1, ja of nee. Omdat neurale netwerken alleen met numerieke data werken, heb je rood al gecodeerd als 1 en wit als 0.

Een type netwerk dat goed presteert op zo’n probleem is een multilayer perceptron. Zoals je aan het begin van deze tutorial hebt gelezen, is dit type neuraal netwerk vaak volledig verbonden. Dat betekent dat je een vrij simpele stapel fully connected lagen gaat bouwen om dit probleem op te lossen. Voor de activatiefunctie gebruik je hier het best een van de meest gangbare om vertrouwd te raken met Keras en neurale netwerken: de relu-activatie.

Hoe begin je nu met het bouwen van je multilayer perceptron? Een snelle manier is het Keras Sequential-model: dat is een lineaire stapel van lagen. Je maakt het model eenvoudig door een lijst met laaginstanties door te geven aan de constructor, die je opzet met model = Sequential().

Denk vervolgens terug aan de structuur van het multilayer perceptron zoals aan het begin van deze tutorial: je hebt een invoerlaag, enkele verborgen lagen en een uitvoerlaag. Bij het maken van je model is het daarom belangrijk dat je eerste laag de vorm van de input duidelijk maakt. Het model moet weten welke invoervorm het kan verwachten en daarom vind je in de documentatie en in voorbeelden van lagen steeds de argumenten input_shape, input_dim, input_length of batch_size.

In dit geval gebruik je een Dense-laag, een volledig verbonden laag. Dense-lagen implementeren de volgende operatie: output = activation(dot(input, kernel) + bias). Merk op dat je Dense-laag zonder activatiefunctie slechts uit twee lineaire operaties zou bestaan: een inproduct en een optelling.

In de eerste laag krijgt het argument activation de waarde relu. Je ziet ook dat de input_shape is gedefinieerd. Dit is de input van de operatie die je net zag: het model neemt als invoer arrays met vorm (12,), of (*, 12). Tot slot zie je dat de eerste laag 12 als eerste waarde heeft voor het argument units van Dense(); dit is de dimensionaliteit van de uitvoerruimte en dat zijn in feite 12 verborgen units. Dit betekent dat het model arrays met vorm (*, 12) zal uitgeven: dat is de dimensionaliteit van de uitvoerruimte. Geen zorgen als dit nog niet helemaal landt, later lees je er meer over!

De units vertegenwoordigen eigenlijk de kernel uit de formule hierboven of de gewichtenmatrix, opgebouwd uit alle gewichten die aan alle invoerknooppunten worden gegeven, aangemaakt door de laag. Merk op dat je in het onderstaande voorbeeld geen bias opneemt, omdat je het argument use_bias niet hebt meegegeven en op TRUE gezet, wat ook een mogelijkheid is.

De tussenlaag gebruikt ook de activatiefunctie relu. De uitvoer van deze laag zal arrays met vorm (*,8) zijn.

Je sluit het netwerk af met een Dense-laag van grootte 1. De laatste laag gebruikt ook een sigmoid-activatie zodat je uitvoer daadwerkelijk een kans is. Dat levert een score op tussen 0 en 1, die aangeeft hoe waarschijnlijk het is dat het sample de doelwaarde “1” heeft, ofwel hoe waarschijnlijk de wijn rood is.

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaW1wb3J0IG51bXB5IGFzIG5wXG5ucC5yYW5kb20uc2VlZCg3KSIsInNhbXBsZSI6IiMgSW1wb3J0IGBTZXF1ZW50aWFsYCBmcm9tIGBrZXJhcy5tb2RlbHNgXG5mcm9tIGtlcmFzLm1vZGVscyBpbXBvcnQgU2VxdWVudGlhbFxuXG4jIEltcG9ydCBgRGVuc2VgIGZyb20gYGtlcmFzLmxheWVyc2BcbmZyb20ga2VyYXMubGF5ZXJzIGltcG9ydCBEZW5zZVxuXG4jIEluaXRpYWxpemUgdGhlIGNvbnN0cnVjdG9yXG5tb2RlbCA9IFNlcXVlbnRpYWwoKVxuXG4jIEFkZCBhbiBpbnB1dCBsYXllciBcbm9kZWwuYWRkKERlbnNlKDEyLCBhY3RpdmF0aW9uPSdyZWx1JywgaW5wdXRfc2hhcGU9KDExLCkpKVxuXG4jIEFkZCBvbmUgaGlkZGVuIGxheWVyIFxubW9kZWwuYWRkKERlbnNlKDgsIGFjdGl2YXRpb249J3JlbHUnKSlcblxuIyBBZGQgYW4gb3V0cHV0IGxheWVyIFxubW9kZWwuYWRkKERlbnNlKDEsIGFjdGl2YXRpb249J3NpZ21vaWQnKSkifQ==

Al met al zie je dat er twee belangrijke architectuurkeuzes zijn voor je model: hoeveel lagen je gebruikt en hoeveel “verborgen units” je per laag kiest.

In dit geval koos je 12 verborgen units voor de eerste laag van je model: zoals hierboven beschreven is dat de dimensionaliteit van de uitvoerruimte. Met andere woorden, je stelt de mate van vrijheid in die je het netwerk geeft bij het leren van representaties. Als je meer verborgen units toestaat, kan je netwerk complexere representaties leren, maar het wordt ook een duurdere operatie die gevoelig kan zijn voor overfitting.

Onthoud dat overfitting optreedt wanneer het model te complex is: het beschrijft willekeurige ruis in plaats van de onderliggende relatie die het zou moeten beschrijven. Met andere woorden, de trainingsdata wordt té goed gemodelleerd!

Merk op dat je, als je niet veel trainingsdata hebt, beter een klein netwerk met weinig verborgen lagen gebruikt (meestal slechts één, zoals in het voorbeeld hierboven).

Als je informatie wilt over het model dat je zojuist hebt gemaakt, kun je onder andere het attribuut output_shape of de functie summary() gebruiken. Enkele van de meest basale staan hieronder.

Probeer ze uit om te zien wat je precies terugkrijgt en wat ze je vertellen over het model dat je net hebt gemaakt:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaW1wb3J0IG51bXB5IGFzIG5wXG5ucC5yYW5kb20uc2VlZCg3KVxuZnJvbSBrZXJhcy5tb2RlbHMgaW1wb3J0IFNlcXVlbnRpYWxcbmZyb20ga2VyYXMubGF5ZXJzIGltcG9ydCBEZW5zZVxubW9kZWwgPSBTZXF1ZW50aWFsKClcbm1vZGVsLmFkZChEZW5zZSgxMixhY3RpdmF0aW9uPSdyZWx1JywgaW5wdXRfc2hhcGU9KDExLCkpKVxubW9kZWwuYWRkKERlbnNlKDgsYWN0aXZhdGlvbj0ncmVsdScpKVxubW9kZWwuYWRkKERlbnNlKDEsYWN0aXZhdGlvbj0nc2lnbW9pZCcpKSIsInNhbXBsZSI6IiMgTW9kZWwgb3V0cHV0IHNoYXBlXG5tb2RlbC5fX19fX19fX19fX1xuXG4jIE1vZGVsIHN1bW1hcnlcbm9kZWwuX19fX19fX19fX19cblxuIyBNb2RlbCBjb25maWdcbm1vZGVsLmdldF9jb25maWcoKVxuXG4jIExpc3QgYWxsIHdlaWdodCB0ZW5zb3JzIFxubW9kZWwuZ2V0X3dlaWdodHMoKSIsInNvbHV0aW9uIjoiIyBNb2RlbCBvdXRwdXQgc2hhcGVcbm1vZGVsLm91dHB1dF9zaGFwZVxuXG4jIE1vZGVsIHN1bW1hcnlcbm1vZGVsLnN1bW1hcnkoKVxuXG4jIE1vZGVsIGNvbmZpZ1xubW9kZWwuZ2V0X2NvbmZpZygpXG5cbiMgTGlzdCBhbGwgd2VpZ2h0IHRlbnNvcnMgXG5tb2RlbC5nZXRfd2VpZ2h0cygpIiwic2N0IjoiRXgoKS50ZXN0X29iamVjdF9hY2Nlc3NlZChcIm1vZGVsXCIpXG5FeCgpLnRlc3Rfb2JqZWN0X2FjY2Vzc2VkKFwibW9kZWxcIilcbkV4KCkudGVzdF9mdW5jdGlvbihcIm1vZGVsLmdldF9jb25maWdcIilcbkV4KCkudGVzdF9mdW5jdGlvbihcIm1vZGVsLmdldF93ZWlnaHRzXCIpXG5zdWNjZXNzX21zZyhcIkF3ZXNvbWUgam9iIVwiKSJ9

Compilen en fitten

Tijd om je model te compilen en het op de data te fitten: gebruik opnieuw compile() en fit() om dit te doen.

model.compile(loss='binary_crossentropy',
              optimizer='adam',
              metrics=['accuracy'])
                   
model.fit(X_train, y_train,epochs=20, batch_size=1, verbose=1)

Bij het compilen configureer je het model met de optimizer adam en de verliesfunctie binary_crossentropy. Daarnaast kun je tijdens het trainen ook de nauwkeurigheid monitoren door ['accuracy'] door te geven aan het argument metrics.

De optimizer en de loss zijn twee verplichte argumenten als je het model wilt compilen. Enkele populaire optimalisatie-algoritmen zijn Stochastic Gradient Descent (SGD), ADAM en RMSprop. Afhankelijk van het algoritme dat je kiest, moet je bepaalde parameters tunen, zoals learning rate of momentum. De keuze van een verliesfunctie hangt af van de taak: bij een regressieprobleem gebruik je meestal de Mean Squared Error (MSE). Zoals je in dit voorbeeld ziet, gebruikte je binary_crossentropy voor het binaire classificatieprobleem om te bepalen of een wijn rood of wit is. Bij multi-class-classificatie gebruik je categorical_crossentropy.

Daarna kun je het model trainen gedurende 20 epochs of iteraties over alle samples in X_train en y_train, in batches van 1 sample. Je kunt ook het argument verbose opgeven. Door het op 1 te zetten, geef je aan dat je een voortgangsbalk wilt zien.

Met andere woorden, je traint het model voor een opgegeven aantal epochs of blootstellingen aan de trainingsset. Een epoch is één doorgang door de volledige trainingsset, gevolgd door het testen op de validatieset. De batchgrootte in de code hierboven bepaalt het aantal samples dat per keer door het netwerk gaat. Zo optimaliseer je ook de efficiëntie, omdat je voorkomt dat je te veel inputpatronen tegelijk in het geheugen laadt.

Waarden voorspellen

Aan de slag met je model! Je kunt er voorspellingen mee doen voor de labels van de testset. Gebruik gewoon predict() en geef de testset door om de labels voor de data te voorspellen. In dit geval wordt het resultaat opgeslagen in y_pred:

y_pred = model.predict(X_test)

Voordat je je model gaat evalueren, kun je alvast een snelle indruk krijgen van de nauwkeurigheid door te kijken hoe y_pred en y_test zich tot elkaar verhouden:

y_pred[:5]

array([[0],
       [1],
       [0],
       [0],
       [0]], dtype=int32)

y_test[:5]

array([0, 1, 0, 0, 0])

Je ziet dat deze waarden lijken te kloppen, maar wat stelt dit voor zonder harde cijfers?

Model evalueren

Nu je je model hebt gebouwd en gebruikt om voorspellingen te doen op data die je model nog niet had gezien, is het tijd om de prestaties te evalueren. Je kunt de voorspellingen visueel vergelijken met de echte testlabels (y_test), of allerlei metrics gebruiken om de prestaties te bepalen. In dit geval gebruik je evaluate() hiervoor. Geef de testdata en testlabels door en zet desgewenst het argument verbose op 1. Je ziet dan meer logs verschijnen.

score = model.evaluate(X_test, y_test,verbose=1)

print(score)

[0.025217213829228164, 0.99487179487179489]

De score is een lijst met de combinatie van verlies en nauwkeurigheid. In dit geval lijken beide erg goed, maar bedenk dat je data enigszins ongebalanceerd was: je had meer observaties van witte wijn dan van rode. De nauwkeurigheid kan simpelweg de klassenverdeling weerspiegelen doordat er vooral white wordt voorspeld, omdat die observaties overvloedig aanwezig zijn!

Voordat je de data anders gaat rangschikken en samenstellen, is het altijd een goed idee om andere evaluatiemetrics te proberen. Hiervoor kun je vertrouwen op scikit-learn (dat je importeert als sklearn, net als eerder bij het maken van de train- en testsets).

In dit geval test je een paar basisclassificatie-evaluatietechnieken, zoals:

De confusion matrix, een uitsplitsing van voorspellingen in een tabel met correcte voorspellingen en de soorten onjuiste voorspellingen. Idealiter zie je alleen getallen op de diagonaal; dat betekent dat al je voorspellingen correct waren!
Precision is een maat voor de exactheid van een classifier. Hoe hoger de precision, hoe nauwkeuriger de classifier.
Recall is een maat voor de volledigheid van een classifier. Hoe hoger de recall, hoe meer gevallen de classifier dekt.
De F1-score of F-score is een gewogen gemiddelde van precision en recall.
De Kappa of Cohen’s kappa is de classificatienauwkeurigheid genormaliseerd naar de onbalans van de klassen in de data.

# Import the modules from `sklearn.metrics`
from sklearn.metrics import confusion_matrix, precision_score, recall_score, f1_score, cohen_kappa_score

# Confusion matrix
confusion_matrix(y_test, y_pred)

array([[1585,    3],
       [   8,  549]])

# Precision 
precision_score(y_test, y_pred)

0.994565217391

# Recall
recall_score(y_test, y_pred)

0.98563734290843807

# F1 score
f1_score(y_test,y_pred)

0.99008115419296661

# Cohen's kappa
cohen_kappa_score(y_test, y_pred)

0.98662321692498967

Al deze scores zijn erg goed! Je hebt een behoorlijk accuraat model gemaakt, ondanks dat je aanzienlijk meer rijen van het type witte wijn had.

Goed gedaan!

Meer experimenten

Je hebt je eerste model succesvol gebouwd, maar je kunt hier nog verder mee gaan. Waarom probeer je de volgende dingen niet uit en kijk je wat het effect is? Zoals je hierboven las, draaien de twee belangrijkste architectuurkeuzes om de lagen en de verborgen knopen. Dat zijn mooie vertrekpunten:

Je gebruikte 1 verborgen laag. Probeer 2 of 3 verborgen lagen;
Gebruik lagen met meer of juist minder verborgen units;
Neem de kolom quality als doellabels en de rest van de data (inclusief de gecodeerde kolom type!) als je data. Je hebt nu een multi-class-classificatieprobleem!

Waarom zou je ook niet de activatiefunctie wijzigen? Probeer in plaats van relu eens de activatiefunctie tanh en kijk wat het resultaat is!

Wijnkwaliteit voorspellen

Je classificatiemodel presteerde perfect voor een eerste run!

Maar er is zoveel meer te doen dan alleen een stapje hoger gaan en complexere structuren proberen dan het multilayer perceptron. Waarom maak je geen neuraal netwerk om de wijnkwaliteit te voorspellen?

In dit geval gaat de tutorial ervan uit dat quality een continue variabele is: de taak is dan geen binaire classificatie, maar een ordinale regressietaak. Dat is een type regressie dat wordt gebruikt om een ordinale variabele te voorspellen: de waarde quality bestaat op een willekeurige schaal waarbij de relatieve ordening tussen de verschillende waarden van quality betekenisvol is. De schaal 0–10 voor “zeer slecht” tot “zeer goed” is zo’n voorbeeld.

Merk op dat je dit probleem ook als classificatie zou kunnen zien en de kwaliteitslabels als vaste klasselabels kunt beschouwen.

In elk geval betekent deze opzet dat je doellabels de kolom quality worden in je DataFrames red en white voor het tweede deel van deze tutorial. Dat vereist extra preprocessing.

Data voorbewerken

Omdat de variabele quality je doelklasse wordt, moet je de kwaliteitslabels nu isoleren van de rest van de dataset. Je plaatst wines.quality in een andere variabele y en je zet de wijnen-data, met uitzondering van de kolom quality, in een variabele x.

Vervolgens ben je klaar om de data in train- en testsets te splitsen, maar dat pad volg je hier niet (al zou het wel kunnen!). In dit tweede deel van de tutorial gebruik je k-fold-validatie, waarbij je de data in K partities splitst. Vaak kies je K = 4 of 5. Vervolgens instantieer je identieke modellen en train je elk model op een partitie, terwijl je ook evalueert op de overige partities. De validatiescore voor het model is dan het gemiddelde van de K behaalde validatiescores.

Je ziet later hoe je dit doet. Gebruik nu eerst StandardScaler om ervoor te zorgen dat je data in orde is voordat je de data aan het model fit, net als zojuist.

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaW1wb3J0IHBhbmRhcyBhcyBwZFxud2hpdGUgPSBwZC5yZWFkX2NzdihcImh0dHA6Ly9hcmNoaXZlLmljcy51Y2kuZWR1L21sL21hY2hpbmUtbGVhcm5pbmctZGF0YWJhc2VzL3dpbmUtcXVhbGl0eS93aW5lcXVhbGl0eS13aGl0ZS5jc3ZcIiwgc2VwPSc7JylcbnJlZCA9IHBkLnJlYWRfY3N2KFwiaHR0cDovL2FyY2hpdmUuaWNzLnVjaS5lZHUvbWwvbWFjaGluZS1sZWFybmluZy1kYXRhYmFzZXMvd2luZS1xdWFsaXR5L3dpbmVxdWFsaXR5LXJlZC5jc3ZcIiwgc2VwPSc7JylcbndpbmVzID0gcmVkLmFwcGVuZCh3aGl0ZSwgaWdub3JlX2luZGV4PVRydWUpIiwic2FtcGxlIjoiIyBJc29sYXRlIHRhcmdldCBsYWJlbHNcbnkgPSB3aW5lcy5fX19fX19fX1xuXG4jIElzb2xhdGUgZGF0YVxuWCA9IHdpbmVzLmRyb3AoJ3F1YWxpdHknLCBheGlzPV8pICIsInNvbHV0aW9uIjoiIyBJc29sYXRlIHRhcmdldCBsYWJlbHNcbnkgPSB3aW5lcy5xdWFsaXR5XG5cbiMgSXNvbGF0ZSBkYXRhXG5YID0gd2luZXMuZHJvcCgncXVhbGl0eScsIGF4aXM9MSkgIiwic2N0IjoiRXgoKS50ZXN0X29iamVjdChcInlcIilcbkV4KCkudGVzdF9vYmplY3QoXCJYXCIpIn0=

Vergeet niet dat je ook nu weer moet schalen, omdat je bij je data voor red, white (en dus ook wines) veel verschillen in sommige waarden had.

Probeer dit uit in het DataCamp Light-blok hieronder. Alle benodigde libraries zijn al voor je ingeladen!

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaW1wb3J0IHBhbmRhcyBhcyBwZFxud2hpdGUgPSBwZC5yZWFkX2NzdihcImh0dHA6Ly9hcmNoaXZlLmljcy51Y2kuZWR1L21sL21hY2hpbmUtbGVhcm5pbmctZGF0YWJhc2VzL3dpbmUtcXVhbGl0eS93aW5lcXVhbGl0eS13aGl0ZS5jc3ZcIiwgc2VwPSc7JylcbnJlZCA9IHBkLnJlYWRfY3N2KFwiaHR0cDovL2FyY2hpdmUuaWNzLnVjaS5lZHUvbWwvbWFjaGluZS1sZWFybmluZy1kYXRhYmFzZXMvd2luZS1xdWFsaXR5L3dpbmVxdWFsaXR5LXJlZC5jc3ZcIiwgc2VwPSc7JylcbndpbmVzID0gcmVkLmFwcGVuZCh3aGl0ZSwgaWdub3JlX2luZGV4PVRydWUpXG55ID0gd2luZXMucXVhbGl0eVxuWCA9IHdpbmVzLmRyb3AoJ3F1YWxpdHknLCBheGlzPTEpIFxuZnJvbSBza2xlYXJuLnByZXByb2Nlc3NpbmcgaW1wb3J0IFN0YW5kYXJkU2NhbGVyIiwic2FtcGxlIjoiIyBTY2FsZSB0aGUgZGF0YSB3aXRoIGBTdGFuZGFyZFNjYWxlcmBcblggPSBfX19fX19fX19fX19fX19fLmZpdF90cmFuc2Zvcm0oWCkiLCJzb2x1dGlvbiI6IiMgU2NhbGUgdGhlIGRhdGEgd2l0aCBgU3RhbmRhcmRTY2FsZXJgXG5YID0gU3RhbmRhcmRTY2FsZXIoKS5maXRfdHJhbnNmb3JtKFgpIiwic2N0IjoiRXgoKS50ZXN0X29iamVjdChcIlhcIikifQ==

Nu ben je weer op het punt waar je even geleden ook was. Je kunt opnieuw beginnen met het modelleren van het neurale netwerk!

Architectuur van het neurale netwerk modelleren

Nu je de data opnieuw hebt voorbewerkt, is het weer tijd om een neuraal netwerkmodel te bouwen, een multilayer perceptron. Ook al gebruik je het voor een regressietaak, de architectuur kan er vrijwel hetzelfde uitzien, met twee Dense-lagen.

Vergeet niet dat de eerste laag je invoerlaag is. Je moet de vorm van je invoerdata aan deze laag doorgeven. In dit geval zie je dat je input_dim gebruikt om de dimensies van de invoerdata door te geven aan de Dense-laag.

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiaW1wb3J0IHBhbmRhcyBhcyBwZFxuZnJvbSBza2xlYXJuLm1vZGVsX3NlbGVjdGlvbiBpbXBvcnQgdHJhaW5fdGVzdF9zcGxpdFxuZnJvbSBza2xlYXJuLnByZXByb2Nlc3NpbmcgaW1wb3J0IFN0YW5kYXJkU2NhbGVyXG53aGl0ZSA9IHBkLnJlYWRfY3N2KFwiaHR0cDovL2FyY2hpdmUuaWNzLnVjaS5lZHUvbWwvbWFjaGluZS1sZWFybmluZy1kYXRhYmFzZXMvd2luZS1xdWFsaXR5L3dpbmVxdWFsaXR5LXdoaXRlLmNzdlwiLCBzZXA9JzsnKVxucmVkID0gcGQucmVhZF9jc3YoXCJodHRwOi8vYXJjaGl2ZS5pY3MudWNpLmVkdS9tbC9tYWNoaW5lLWxlYXJuaW5nLWRhdGFiYXNlcy93aW5lLXF1YWxpdHkvd2luZXF1YWxpdHktcmVkLmNzdlwiLCBzZXA9JzsnKVxucmVkWyd0eXBlJ10gPSAxXG53aGl0ZVsndHlwZSddID0gMFxud2luZXMgPSByZWQuYXBwZW5kKHdoaXRlLCBpZ25vcmVfaW5kZXg9VHJ1ZSlcbnkgPSB3aW5lcy5xdWFsaXR5XG5YID0gd2luZXMuZHJvcCgncXVhbGl0eScsIGF4aXM9MSkgXG5YID0gU3RhbmRhcmRTY2FsZXIoKS5maXRfdHJhbnNmb3JtKFgpIiwic2FtcGxlIjoiIyBJbXBvcnQgYFNlcXVlbnRpYWxgIGZyb20gYGtlcmFzLm1vZGVsc2BcbmZyb20ga2VyYXMubW9kZWxzIGltcG9ydCBTZXF1ZW50aWFsXG5cbiMgSW1wb3J0IGBEZW5zZWAgZnJvbSBga2VyYXMubGF5ZXJzYFxuZnJvbSBrZXJhcy5sYXllcnMgaW1wb3J0IERlbnNlXG5cbiMgSW5pdGlhbGl6ZSB0aGUgbW9kZWxcbm1vZGVsID0gU2VxdWVudGlhbCgpXG5cbiMgQWRkIGlucHV0IGxheWVyIFxubW9kZWwuYWRkKERlbnNlKDY0LCBpbnB1dF9kaW09MTIsIGFjdGl2YXRpb249J3JlbHUnKSlcbiAgICBcbiMgQWRkIG91dHB1dCBsYXllciBcbm1vZGVsLmFkZChEZW5zZSgxKSkifQ==

Merk opnieuw op dat de eerste laag die je definieert de invoerlaag is. Deze laag moet de invoerdimensies van je data kennen. Je geeft de invoerdimensies door, die in dit geval 12 zijn (vergeet niet dat je ook de kolom Type meetelt die je in het eerste deel van de tutorial hebt aangemaakt!). Je gebruikt opnieuw de activatiefunctie relu, maar ook nu is er geen bias betrokken. Het aantal verborgen units is 64.

Je netwerk eindigt met een enkele unit Dense(1), en bevat geen activatie. Dit is een typische opzet voor scalaire regressie, waarbij je één continue waarde probeert te voorspellen.

Compileer het model, fit de data

Met je model in de hand kun je het weer compilen en de data erop fitten. Maar wacht. Heb je de K-fold-validatiepartities niet nodig waar je eerder over las? Klopt.

import numpy as np
from sklearn.model_selection import StratifiedKFold

seed = 7
np.random.seed(seed)

kfold = StratifiedKFold(n_splits=5, shuffle=True, random_state=seed)
for train, test in kfold.split(X, Y):
    model = Sequential()
    model.add(Dense(64, input_dim=12, activation='relu'))
    model.add(Dense(1))
    model.compile(optimizer='rmsprop', loss='mse', metrics=['mae'])
    model.fit(X[train], Y[train], epochs=10, verbose=1)

Gebruik de functie compile() om het model te compilen en vervolgens fit() om het model op de data te fitten. Voor het compilen zorg je er opnieuw voor dat je minstens de argumenten optimizer en loss definieert. In dit geval kun je rsmprop gebruiken, een van de populairste optimalisatie-algoritmen, en mse als verliesfunctie, wat heel gebruikelijk is voor regressieproblemen zoals dat van jou.

Het extra argument metrics dat je definieert is eigenlijk een functie die wordt gebruikt om de prestaties van je model te beoordelen. Voor regressieproblemen is het gebruikelijk om de Mean Absolute Error (MAE) als metric te nemen. Daar lees je in de volgende sectie meer over.

Geef de traindata en -labels door aan fit(), bepaal hoeveel epochs je wilt trainen, de batchgrootte en zet desgewenst het argument verbose op 1 om meer logs te krijgen, want dit kan even duren.

Model evalueren

Net als eerder moet je je model ook evalueren. Naast het toevoegen van y_pred = model.predict(X[test]) aan de rest van de code hierboven, is het ook een goed idee om enkele evaluatiemetrics uit sklearn te gebruiken, zoals je in het eerste deel van de tutorial ook hebt gedaan.

Hiervoor kun je gebruikmaken van de Mean Squared Error (MSE) en de Mean Absolute Error (MAE). De eerste, ook wel “mean squared deviation” (MSD) genoemd, meet het gemiddelde van de kwadraten van de fouten of afwijkingen. Met andere woorden, het kwantificeert het verschil tussen de schatter en wat geschat wordt. Zo leer je meer over de kwaliteit van je schatter: hij is altijd niet-negatief, en waarden dichter bij nul zijn beter.

De tweede maat, MAE, staat voor Mean Absolute Error: die kwantificeert hoe dicht voorspellingen bij de uiteindelijke uitkomsten liggen.

Voeg deze regels toe aan het vorige codeblok en let goed op de inspringing:

mse_value, mae_value = model.evaluate(X[test], Y[test], verbose=0)

print(mse_value)
0.522478731072
print(mae_value)
0.561965950103

Merk op dat je naast de MSE- en MAE-scores ook de R2-score of de regressiescorefunctie kunt gebruiken. Hier streef je naar een score van 1,0, wat het beste is. De score kan echter ook negatief zijn!

from sklearn.metrics import r2_score

r2_score(Y[test], y_pred)
0.3125092543

Op het eerste gezicht zijn dit behoorlijk beroerde cijfers, toch? Het goede nieuws is dat je nu kunt gaan experimenteren met het optimaliseren van de code zodat de resultaten wat beter worden.

Daar gaat de volgende en laatste sectie over!

Model finetunen

Je model finetunen is waarschijnlijk iets wat je vaak zult doen, omdat niet alle problemen zo rechttoe rechtaan zijn als dat uit het eerste deel van deze tutorial. Zoals je hierboven las, zijn er al twee cruciale keuzes die je waarschijnlijk wilt bijstellen: hoeveel lagen je gaat gebruiken en hoeveel “verborgen units” je per laag kiest.

In het begin is dat inderdaad best een zoektocht.

Lagen toevoegen

Wat gebeurt er als je nog een laag toevoegt aan je model? Wat als het er zo uitziet?

model = Sequential()
model.add(Dense(64, input_dim=12, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(1))

Verborgen units

Probeer ook het effect van meer verborgen units in de architectuur van je model en bestudeer het effect op de evaluatie, bijvoorbeeld zo:

model = Sequential()
model.add(Dense(128, input_dim=12, activation='relu'))
model.add(Dense(1))

Merk opnieuw op dat, omdat je niet enorm veel data hebt, overfitting sneller en sterker kan optreden. Daarom kies je beter een klein netwerk.

Nog wat experimenten: optimalisatieparameters

Naast het toevoegen van lagen en spelen met verborgen units, kun je ook proberen (een deel van) de parameters van het optimalisatie-algoritme dat je aan de functie compile() geeft aan te passen. Tot nu toe gaf je steeds een string door, zoals rmsprop, aan het argument optimizer.

Maar dat hoeft niet altijd zo te zijn!

Probeer bijvoorbeeld RMSprop te importeren uit keras.models en de learning rate lr aan te passen. Je kunt ook de standaardwaarden voor de andere parameters van RMSprop() wijzigen, maar dat is niet aan te raden. Meer informatie vind je hier.

from keras.optimizers import RMSprop
rmsprop = RMSprop(lr=0.0001)
model.compile(optimizer=rmsprop, loss='mse', metrics=['mae'])

Experimenteer ook met andere optimalisatie-algoritmen, zoals Stochastic Gradient Descent (SGD). Zie je effect?

from keras.optimizers import SGD, RMSprop
sgd=SGD(lr=0.1)
model.compile(optimizer=sgd, loss='mse', metrics=['mae'])

Ga verder!

Deze tutorial is slechts een begin van je deep learning-reis met Python en Keras. Er valt nog veel te ontdekken, dus waarom volg je niet DataCamp’s cursus Deep Learning in Python? Bekijk in de tussentijd ook zeker de Keras-documentatie, als je dat nog niet gedaan hebt. Je vindt er meer voorbeelden en informatie over alle functies, argumenten, extra lagen, enzovoort. Het wordt ongetwijfeld een onmisbare bron als je leert werken met neurale netwerken in Python! Als je liever een boek leest dat de fundamenten van deep learning (met Keras) uitlegt én hoe het in de praktijk wordt gebruikt, lees dan zeker François Chollet’s boek Deep Learning in Python.