Wordt vandaag nog een Data Scientist!

Hallo wereld!

Wanneer is iemand een Data Scientist?

Wanneer hij een dataset heeft geopend? Wanneer hij een machine learning model heeft gebouwd? Wanneer hij een dag als Data Scientist heeft gewerkt? Een jaar? Twintig jaar?

Allemaal fout.

Iemand is een Data Scientist nadat hij/zij mijn geweldige tutorial voor Data Analyse met Jupyter Notebook heeft gevolgd!

In deze tutorial ga ik jullie wat simpele maar belangrijke trucjes leren om je data te analyseren.

Data analyse is de eerste stap voor alle data aspiranten. Of je nu Data Scientist wil worden, Data Analyst of Machine Learning Engineer, het begint allemaal met het openen van en analyseren van je databestandje.

Bekijk het gauw hier op mijn Github!

3 Lessen uit 3 Kaggle projecten

Gegroet Dataridders,

In dit artikel zal ik de 3 lessen delen die ik geleerd heb bij het uitvoeren van de 3 actieve Getting Started wedstrijden/projecten op Kaggle. In volgorde van uitvoeren:

  1. Titanic: Machine Learning from Disaster

  2. Digit Recognizer

  3. House Prices: Advanced Regression Techniques

Let’s get started!

 

Les 1: Als je er een kan, dan kan je ze allemaal.

Mijn machine learning cursus eindproject heeft mij wekenlang zoet gehouden. Maar, mijn eerste Kaggle project was al klaar binnen een aantal uurtjes. De volgende twee projecten waren ook klaar binnen een dagje of twee.

Daarmee heb ik dan op Kaggle een project gedaan met classificatie, een met image recognition en een met regressie voor een dataset met 80 variabelen. Het proces was vrij vergelijkbaar voor alle drie. Verrassend vergelijkbaar.

Waren er uitdagingen? Ja. Was het moeilijk? Niet echt. Tuurlijk, er waren obstakels, maar het was slechts een kwestie van trial, error en Google search en de oplossingen waren redelijk snel gevonden.

Natuurlijk wil ik niet beweren dat alle machine learning technieken makkelijk zijn. Maar volgens mij zit de moeilijkheid niet zozeer in het maken van een model, maar in het maken van een optimaal model.

 

Les 2: Goede scores halen hoeft niet veel tijd te kosten.

Zoals ik al zei had ik er niet lang over gedaan om mijn projecten op Kaggle af te ronden. Waarom? Ik probeerde geen topscores te behalen. Het was slechts mijn doel om EEN score te halen. En dus trainde ik gewoon mijn modellen met zo weinig mogelijk data cleaning en feature engineering.

Het resultaat?

Verrassend goed! Oke, ik heb geen topscores behaald. Bij mijn eerste wedstrijd haalde ik de top 80 procent en de overige twee zat ik net onder de top 50 procent.

Dat klinkt vrij niet al te indrukwekkend, maar de modelprestaties van die modellen lagen allemaal vrij dicht bij de topscores. Mijn Titanic model haalde 75 procent accuraatheid, terwijl de hoogste realistische score zo’n 80 procent zou bedragen volgens de discussie pagina’s. Mijn image recognition model haalde 98 procent.

Een minimale inzet model doet dus niet veel onder voor een top tier model. Dit komt omdat de algoritmes het meeste werk al voor je doen. Lekker makkelijk!

 

Les 3: Kaggle succes kan misleidend zijn.

Bij elke van de 3 leaderboards zijn er mensen die een accuraatheid van 100 procent of een foutpercentage van (bijna) 0 procent gehaald hebben. Echter, dit zijn geen realistische scores voor een voorspellend model.

Hoe kan dit dan?

Vals spelen. Deze mensen hebben hun model simpelweg getraind op de gehele dataset en het vervolgens ook nog eens drastisch overfit. Vergelijk het met het uit je hoofd leren van de antwoorden voor een meerkeuzevraag proefwerk zonder de theorie te leren. Maar gelukkig is dit niet mogelijk bij de normale Kaggle wedstrijden waarbij de test data niet simpelweg van het internet af te halen is.

Ik ontdekte echter nog een vreemd fenomeen bij het opsturen van mijn antwoorden voor de House Prices wedstrijd. Ik had 3 verschillende lineaire regressie modellen getraind op de trainingsdata. Deze modellen presteerden ongeveer allemaal even goed op de testset die ik van de trainingsdata had achtergehouden. Er was echter een groot verschil met hoe twee van deze modellen scoorden op het leaderboard.

Mijn eerste submissie leverde mij een plek in de buurt van de bodem op met een Root-Mean-Squared-Error (RMSE) van 0.45. Mijn tweede submissie, een model dat vrijwel hetzelfde score op de testfractie van de trainingsdata,  plaatste mij in de buurt van de top 60 procent met een RMSE van 0.15! Een drastische verbetering!

Misschien dat ik iets gemist heb maar volgens mij is de enige verklaring voor dit verschil toeval. Met meer data was dit volgens mij dan ook nooit het geval geweest.

 

Samenvatting

Als je er een kan kan je ze allemaal, goede scores vergen weinig inzet en Kaggle scores zijn soms misleidend. Dat zijn de lessen die ik geleerd heb.

Misschien dat ik er met meer ervaringsdata achter kom dat mijn conclusiepatronen moeten worden bijgesteld, maar voor nu is dit mijn model van de Kaggle en Machine Learning wereld.

Dat is alles voor nu.

 

Tot de volgende keer!

Vervulling en frustratie

Gegroet Dataridder,

De meest vervullende dingen in het leven zijn vaak ook het meest frustrerend. Afgelopen week heb ik mijn eerste echte Applied Machine Learning Project afgerond, en daarmee mijn certificaat voor de Machine Learning Accelerator cursus behaald.

Het was niet makkelijk.

En ik zou liegen als ik zou zeggen dat het alleen maar plezierig en totaal niet onaangenaam was. Sterker nog, er waren meerdere periodes waar dit totaal niet het geval was, en waarin ik mezelf moest dwingen om door te gaan. Maar, uiteindelijk was het ook heel leerzaam en waren er ook veel periodes van plezier en vervulling.

In dit artikel zal ik mijn ervaringen met mijn eerste machine learning project bespreken in de hoop je voor te bereiden voor je eigen eerste project, mocht je daar nog niet aan begonnen zijn. Zowel, dan herken je je misschien in mijn ervaringen en weet je dat je niet de enige bent.

Voor de cursus mocht ik na het afronden van de leermodules mijn eigen eindproject formuleren. De eerste uitdaging was het kiezen van een onderwerp. Het is makkelijk genoeg om classificatie, regressie of clustering taken te bedenken, maar om taken te bedenken die ook nuttig en haalbaar zijn voor een eerste project en aansluiten bij mijn persoonlijke interesses, dat was echt bijzonder lastig. Ik was er dan ook vele uren aan kwijt, verspreid over vele, vele dagen.

De tweede uitdaging was het vinden van een goede dataset bij dat gekozen onderwerp. Het was echt verrassend lastig om een dataset te vinden die zowel geschikt is voor machine learning als goed gedocumenteerd is. Ik heb zo’n beetje het hele internet afgezocht en data voorbij zien komen in alle vormen en maten, van csv tot json en noem het maar.

Uiteindelijk heb ik gekozen voor het maken van een voorspellend model voor het succes van telemarketing voor een termijndeposito. De dataset kwam van The UCI Machine Learning Repository, was al eerder gebruikt door onderzoekers voor het zelfde doeleinde en goed gedocumenteerd. Een project dat zowel haalbaar leek als interessant, ook al sloot het niet helemaal aan bij mijn eerste ideeën en was het niet erg revolutionair.

Maar, na uren lang zoeken naar de perfecte dataset was het toch echt tijd om eens te gaan beginnen. Beter om een minder dan perfect project te doen, en dan nog een, en dan nog een, en op deze manier dan ook daadwerkelijk iets te leren, dan om voor altijd vast te blijven hangen in het keuzeproces.

Na de eerste stappen kwam ik uit bij de volgende uitdaging: het bedenken van goede ideeën voor feature engineering, het selecteren en vervormen van de gegevens voor het verbeteren van de prestatie van het model. Mijn domeinkennis bij mijn gekozen onderwerp was vrij beperkt, maar ook de dataset zelf liet vrij weinig ruimte over voor creativiteit aangezien hij al door een proces van filteren en feature engineering onderworpen was.

Na veel onderzoek kwam ik slechts met een handvol ideeën en deze bleken de prestatie van het model niet significant te verbeteren. Dit was erg frustrerend maar van wat ik gelezen en geleerd had tijdens de cursus ook niet ongebruikelijk. In ieder geval had ik wel veel geleerd en geoefend met de technieken die ik geleerd had in de cursus.

De vierde uitdaging was het wachten op het trainen van het model.

Ja, serieus.

Stel je het volgende scenario voor:

Je hebt eindelijk je feature engineering gedaan, je hyperparameters gekozen en je start het algoritme. Geweldig, nu kun je een paar uur wachten op de uitslag voordat je weer verder kunt. Na een paar uur wachten kom je terug om je resultaat te bewonderen. Maar, je bent ergens iets vergeten en/of de resultaten zijn teleurstellend en je kunt het hele proces weer opnieuw kunt beginnen.

Zucht…

Het kostte me een significant aantal iteraties om mijn aanpak en functies voldoende te verfijnen om dit proces wat vlotter te laten verlopen.

De laatste uitdaging was het documenteren van het proces zelf. Het eindresultaat moest namelijk een mooi lineair verslag zijn dat de lezer laat zien hoe je aan je resultaat gekomen bent. Vrij lastig om te doen voor een totaal niet-lineair proces waarbij je constant stappen terug zet en extra onderzoek doet om je resultaten te verbeteren. Uiteindelijk heb ik er maar het beste van gemaakt en mijn persoonlijke aantekeningen zo goed mogelijk omgezet in documentatie voor de lezer.

En dat was dus mijn project. Een proces van vele frustratie en vervulling als gevolg van het overwinnen van die frustratie. Hopelijk heb ik je met het delen van mijn uitdagingen een beetje voorbereid op je eigen toekomstige machine learning projecten, en/of je wat beter laten voelen over de projecten die je al gedaan hebt.

Dat was alles voor nu,

 

Tot de volgende keer.

 

Python Power!

Hallo wereld,

Zoals ik al had aangekondigd in mijn vorige bericht ben ik de laatste dagen vooral bezig geweest met de Machine Learning Accelerator van EliteDataScience. En inmiddels heb ik al aardig wat geleerd over het gebruik van Python voor Data Science.

En ik ben onder de indruk.

Eerder had ik bijvoorbeeld al geleerd om data te analyseren met Excel. Niets bijzonders, gewoon de basics. Ik had een Youtube kanaal gevonden dat uitstekende tutorials had voor het gebruik van deze software. En ik was onder de indruk van wat je er allemaal mee kon doen en hoe gemakkelijk het allemaal was.

Maar de kracht van Excel komt niet eens in de buurt van de kracht van Python.

Niet wanneer het gaat om Data Science. En het is niet alleen dat Python je in staat stelt om machine learning toe te passen, hoewel dat er zeker een hoop mee te maken heeft. Het is ook niet dat je met Python (eventueel in combinatie met relationele databases en SQL), veel meer data kunt verwerken. Nee, de ECHTE kracht van Python, en programmeren over het algemeen, is dat er bijna geen grenzen zijn aan de mogelijkheden.

Python kan dankzij de Pandas, Matplotlib en Seaborn libraries in principe alles wat Excel ook kan, maar beter.

Wil je een staafdiagram voor inzicht in je gegevens maken? Laad de libraries, laad de data, schrijf twee regels code en voilà, staafdiagram voor een categorische variabele naar keuze. Liever categorieën vergelijken op basis van een bepaalde andere variabele? Ook zo gedaan. Het is echt belachelijk makkelijk. Wil je alle rijen die (niet) aan een bepaalde voorwaarde voldoen eruit filteren?

Kinderspel!

Dankzij libraries en de compacte, elegante syntax van Python kun je heel snel hele complexe en nuttige dingen doen met je data. Dingen die met Excel een stuk langer zouden duren. Maar, de echte kracht zit verschuild in hoe gemakkelijk het is om op die mogelijkheden verder te bouwen. Je hebt een pakket vol met nuttige analyses aan je vingertippen, ja. Net zo gemakkelijk echter kun je zelf een nieuw pakket samen stellen om nog betere en/of snellere analyses uit te voeren, en deze te automatiseren. Schrijf gewoon een nieuwe methode, en wie weet, kan je daar gewoon een nieuwe library van maken ook, zodat iedereen hem kan gebruiken!

Dat is de kracht van Python voor Data Science. En Excel, hoewel een geweldige tool voor de simpelere doeleinden, kan daar gewoon niet aan meten, lijkt mij. Maar ja, wat weet ik ervan?

Dat is alles voor nu,

Tot de volgende keer!

Run Forest Run!

Hallo wereld,

Vandaag kan ik met trots aankondigen dat mijn Random Forest applicatie af is! Ik moet toegeven, ik begon te twijfelen of deze dag ooit nog zou komen. Maar, de aanhouder wint.

Het was echter niet de bedoeling om alleen een Random Forest te maken. De bedoeling was om hem te vergelijken met die van de scikit-learn library. In het bijzonder de applicatie van de EliteDataScience tutorial. Om dat te kunnen doen moest ik nog wat extra aanpassingen maken. Ten eerste moest de data verdeeld worden in een training- en testset. Vervolgens moest alle data gestandaardiseerd worden. Daarnaast moesten er ook nog wat statistische gegevens berekend worden om de prestatie van het algoritme te peilen.

Dit heb ik dan (onder andere) gedaan voor een random forest met 50 bomen met maximale diepte van 20 en een sample grootte van 100. Dat wil zeggen, er zijn 50 beslissingsbomen gemaakt met maximaal 20 lagen van vertakkingen, die gegroeid zijn op basis van 100 willekeurig geselecteerde gegevensrijen uit de trainingset. Daarnaast werden dan ook nog voor elk van die bomen slechts willekeurig 3 kwart van de kolommen geselecteerd. Dit zorgt voor extra variatie tussen de bomen. Deze bomen doen dan elk hun voorspelling en de voorspelling met de meeste stemmen wint.

Het resultaat is een model dat met succes de data van de rode wijn laadt en modelleert, met een r2-score van 0.31 (vs 0.47) en een mean-squared-error van 0.5 (vs 0.33). Ter herhaling, de r2 score geeft aan hoe goed de fit van het model is. De mean-squared-error geeft aan hoe nauwkeurig het model is. Oftewel, mijn model is een slechtere fit en minder nauwkeurig. Dit was echter te verwachten, aangezien mijn model niet automatisch getuned wordt en ik de hyperparameters willekeurig gekozen heb.

Daarnaast heb ik ook de nauwkeurigheid van het model laten uitrekenen, welke 0.67 was. Niet al te slecht dus, het raadt het 2 van de 3 keer goed. Voor het sk-learn model is dit echter niet direct uit te rekenen aangezien deze in tegenstelling tot mijn model geen categorische maar numerieke voorspellingen maakt. Hierdoor zijn alle voorspellingen automatisch niet exact juist, en moet ik dus de afgeronde waardes gebruiken. Als ik dat doe, krijg ik verrassend genoeg een nauwkeurigheid van slechts 0.69. Slechts 2 procent nauwkeuriger dan mijn eigen model!

Hoe dan ook is mijn missie geslaagd. Ik heb mijn eigen Random Forest algoritme gemaakt, en het vergeleken met het model van de EliteDataScience tutorial. Hiermee heb ik niet alleen veel geleerd over de werking van het Random Forest algoritme, ik heb ook mijn vaardigheid met Python enorm verbeterd!

De code kun je hier vinden. Ook heb ik de winesnobloader aangepast om de nauwkeurigheid uit te rekenen. In de toekomst zal ik misschien wat dieper ingaan op de werking en/of wat tutorials geven voor het maken van deze en mijn andere applicaties. Op het moment heb ik echter een probleem met mijn geluidsopname-kwaliteit, dus hoe ik dat ga doen weet ik nog niet. Maar, dat is alles voor nu.

Tot de volgende keer!

 

Worstelen met bomen

Hallo wereld,

Mijn missie om een random forest te maken met Python bleek een stuk lastiger dan ik aanvankelijk had gedacht. Maar, ik heb het nog niet op gegeven. En, hoewel ik er de afgelopen maand een beetje teveel omheen heb gedraaid ben ik er nog steeds mee bezig geweest. En vooral de afgelopen week heb ik weer wat vooruitgang gemaakt.

Na het maken van mijn eerste versie voor een beslissingsboom algoritme had ik namelijk een video met een link naar de voorbeeldcode gevonden op Youtube. In dit voorbeeld wordt ook een beslissingsboom met Python gemaakt, maar de programmeur pakt het toch allemaal net wat beter aan dan ik zelf deed. Het belangrijkste verschil is dat hij gebruikt maakte van recursie, dus ik besloot opnieuw te beginnen en ook een beslissingsboom met recursie te maken. Ik had hierbij het voornemen om alleen de informatie in de video te gebruiken en de voorbeeldcode te negeren.

En, dit was me redelijk goed gelukt, maar toen ik de beslissingsboom net zoals in mijn vorige applicatie probeerde te tekenen raakte ik in de problemen. De bomen werden succesvol gemaakt, wat ik kon zien door het resultaat in tekst te printen, maar om hem (recursief) te tekenen, dat wilde me maar niet lukken. Ondanks mijn vele pogingen.

Als je zelf ervaring hebt met het werken met grote lappen code dan weet je misschien wel hoe moeilijk het kan zijn om een groot project weer op te pakken nadat je er een tijd niet aan gewerkt hebt. Je bent vergeten wat alles ook alweer precies doet, en wat je precies nog allemaal moest doen. Als je dan niet de tijd neemt om je code weer grondig te bestuderen alsof je hem voor het eerst ziet dan kan je veel tijd verspillen. Niets wil werken, je snapt niet waarom, en je staart met frustratie en wanhoop naar je grote lap met code en vraagt je af of je niet beter opnieuw kan beginnen.

Uiteindelijk heb ik dan toch maar de moeite genomen om mijn code weer opnieuw te bestuderen. Regel voor regel. Functie voor functie. En bij al deze functies erbij gezet wat ze ook alweer precies deden. Hierdoor had ik eindelijk weer een goed begrip van hoe alles precies ook alweer werkte en was de code niet zo intimiderend meer.

En toen heb ik toch ook maar de voorbeeldcode erbij gepakt en kwam ik erachter dat daarbij niet eens de moeite werd gedaan om de boom te tekenen. In plaats daarvan werd de boom wel heel netjes met recursie geprint en gebruikt voor het maken van voorspellingen. Deze methodes heb ik dan maar aangepast en aan mijn programma toegevoegd.

Het resultaat is een efficiënte, overzichtelijke en werkende applicatie voor het maken van classificatie (maar geen regressie) bomen. Mocht je vergeten zijn wat dat betekent, het houdt in dat de boom in staat is om data in categorieën te plaatsen, maar nog niet in staat is om (exacte) numerieke voorspellingen te doen.

Aanvankelijk dacht ik regressie nodig zou hebben voor de wijndata, maar nadat ik de moeite had genomen om de data te onderzoeken kwam ik erachter dat er maar vijf verschillende cijfers voor de wijnkwaliteit waren in de gehele dataset: 3 tot en met 8. Dus, het enige wat nu nog te doen staat is het implementeren van deze beslissingsboom in een random forest algoritme. En de resultaten te vergelijken met die van de Random Forest Wijnproever zoals die op EliteDataScience geïmplementeerd was. Zou moeten lukken.

Hoe dan ook ben ik al ver gekomen tijdens het werken aan deze beslissingsboom. Mijn aanvankelijke doel voor dit project was het leren begrijpen en maken van random forests. Tot mijn eigen verbazing las ik zelf in mijn eerste bericht bij dit project terug dat ik nog niet eens van plan was om een Data Scientist te worden op dit punt. Maar, uiteindelijk verschoof het hoofddoel van dit project naar het leren programmeren met Python voor Data Science.

En, ik heb een hele hoop over Python geleerd tijdens het maken van deze beslissingsboom. Het zelf kunnen maken van een random forest is echter niet meer mijn belangrijkste leerdoel, het is slechts een project voor het oefenen met Python. Uiteindelijk is het belangrijker dat ik leer te werken met de libraries van Python voor het analyseren van data en het trainen van machine learning algoritmes. En daar zal ik dan ook na dit project mee verder gaan.

Maar, dat is alles voor nu.

Tot de volgende keer!

Project update: De eerste boompjes

Hallo wereld

Het is weer hoog tijd voor een project update. Mijn missie om een Random Forest te maken in Python gaat nog steeds door. Na uren van het vergroten van mijn kennis over beslissingsbomen, oefenen met Python en prutsen met Python is het me eindelijk gelukt om een werkende applicatie te maken! Er is nog een hele hoop werk te doen, maar de eerste boompjes hebben hun blaadjes gespreid.

Zoals ik al eerder had gezegd, mijn ervaring met Python was beperkt toen ik aan dit project begon. De helft van de uitdaging in dit project zat hem dan ook in het leren om te programmeren met Python. Echter, ik was ook geen complete beginner. Ik had al ervaring met Java en mezelf eerder al genoeg aangeleerd over Python om mijn eerste applicatie te maken: Conway’s Game of Life.

Deze manier van leren programmeren met het maken van een specifieke applicatie in gedachten is in mijn ogen HEEL BELANGRIJK. Want, als je niet weet WAT je wil programmeren en simpelweg het doel stelt om een programmeertaal te leren dan zul je nooit slagen. Je kunt een programmeertaal immers NOOIT helemaal leren! Zelfs een doel als “de basis principes van Python leren” is in mijn ogen nog steeds te vaag en je zult je daarbij eerst eens goed af moeten vragen:

  • Wat zijn die basis principes?
  • Waarom wil ik ze leren?
  • Wat kan ik ermee maken?

Aldus had ik opnieuw het doel om meer over Python te leren met een specifieke applicatie in gedachten. Om dit doel te behalen moest ik wel eerst mijn kennis van de basis syntax een beetje herhalen en aanvullen. Om dat te doen had ik onder andere deze video gekeken, waarin Python in 40 minuten wordt uitgelegd, op advies van EliteDataScience. Wees gewaarschuwd echter, hoewel het meeste wat in deze video wordt uitgelegd best nuttig is, is de kwaliteit niet overal even goed. Aan het eind van de video kwam ik namelijk in de problemen met niet werkende code vanwege een typefout. Nou, dat was mijn eigen schuld natuurlijk, maar toen ik daar op stackoverflow een vraag over stelde kwam ik erachter dat een significant aantal ervaren Python programmeurs de manier waarop hij een aantal dingen deed vrij slecht vonden. In het bijzonder ging het om zijn onhandige manier van het benoemen van variabelen, en zijn manier van het declareren van classes en het implementeren van inheritance. Als geheel is de video echter nog steeds nuttig als spoedcursus, maar wees dus gewaarschuwd dat het niet allemaal even geweldig is.

Daarna ging ik verder met het volgende advies op EliteDataScience. Ze verwezen naar een leuke puzzelpagina waarbij je puzzels kunt oplossen met Python. Hoewel dit in het begin heel leuk was werkte om de een of andere reden een van mijn oplossingen niet helemaal en kon ik de volgende pagina (derde geloof ik?) niet vinden. Ik kwam wel op een of andere forum pagina die mij informeerde dat ik de oplossing juist had, maar de url voor de volgende pagina werkte echter niet voor mij. Dus opnieuw, wees gewaarschuwd.

Maar ja, genoeg daarover. Terug naar het hoofd onderwerp, het project. Waar begin ik? Nou, ik ga er even van uit dat jullie al up-to-date zijn met hoe beslissingsbomen werken. Is dit niet het geval, lees dan misschien beter eerst even mijn eerdere bericht over de werking van beslissingsbomen. De code is te vinden op Github, maar ik denk dat het het handigst is om uit te leggen hoe het allemaal werkt in een video.

Hieronder staat ook nog een selectie van een aantal van de vele bronnen die ik gebruikt heb gedurende dit project tot dusver. Dat is alles voor nu.

 

Tot de volgende keer!

Bronnen:

Door de bomen het bos zien

Hallo wereld,

Wat zijn random forests? Hoe werken ze? Waar worden ze voor gebruikt? Nou, laat ik om dat uit te leggen eerst een stap terug doen en wat uit leggen over machine learning en decision trees. Random forests zijn namelijk machine learning algoritmes die zijn opgebouwd uit decision trees.

Machine learning is het subgebied binnen kunstmatige intelligentie dat zich bezig houdt met het bedenken en trainen van algoritmes die leren van gegevens. Het zijn programma’s met een aantal variabele parameters die zich aan passen aan een dataset om een zo effectief mogelijk eindprogramma te realiseren. Het is te vergelijken met de manier waarop wij leren. Op basis van de gebeurtenissen in ons verleden passen wij ons gedrag aan voor de gebeurtenissen in de toekomst.

Soms krijgen wij hier begeleiding bij, van ouders en leraren, die ons vertellen wat we wel of niet moeten of kunnen doen. Op andere momenten zoeken we het zelf uit, met vallen en opstaan. Zo is het ook met machine learning. Je hebt daarbij supervised (onder toezicht) en unsupervised (zonder toezicht) leren.

Decision trees (beslissingsbomen) vallen onder de supervised categorie. Wat houdt dit in? Nou, je moet het algoritme in principe les geven. Je geeft het een gelabelde dataset, dat wil zeggen een dataset met de gewenste antwoorden bijgevoegd. Bijvoorbeeld een verzameling van plaatjes van honden en katten met de labels hond of kat. Op basis daarvan kan het algoritme leren wat het verschil is tussen honden en katten en nieuwe plaatjes zelf leren categoriseren. Decision trees worden gebruikt voor classificatie en regressie. Bij classificatie wordt de data gecategoriseerd, net zoals bij het voorbeeld met honden en katten. Bij regressie wordt er een continue waarde aan toegedeeld. Bijvoorbeeld een algoritme dat de leeftijd van een mens of dier op basis van een foto bepaalt.

Decision trees leren data te categoriseren aan de hand van een model met knooppunten en vertakkingen. Bij elk knooppunt wordt een datapunt getest op een bepaalde variabele en op basis daarvan wordt bepaald naar welk volgende knooppunt het gaat voor de volgende test. Uiteindelijk komt het dan uit bij een eindknooppunt, een blad (leaf). Hierbij wordt het datapunt dan gelabeld binnen een een bepaalde klasse (of een continue waarde in het geval van regressie). Een voorbeeld?

Hierbij zijn de vierkanten dan dus de knooppunten, de lijntjes de takken en de rondjes de bladeren. Hoe bepaalt het algoritme wat de criteria zijn waar op getest wordt in de knooppunten? Brute kracht in principe. Bij elk knooppunt wordt voor elke variabele voor een groot aantal waarden getest tot wat voor split het zou zorgen in de dataset. Uiteindelijk wordt dan gewoon de split gekozen die de data het beste opsplitst. Dit proces wordt herhaald tot de gekozen eindcriteria bereikt worden (bijvoorbeeld de maximale lengte voor de boom).

Decision trees hebben echter de vervelende gewoonte om data te ‘overfitten’. Ze vormen zichzelf op een manier die heel nauwkeurig de trainingset kan modeleren, maar doen dit zo overdreven dat ze het slecht doen voor nieuwe gegevens. Ze leren de antwoorden in plaats van de patronen. Om dit te voorkomen kun je de decision trees ‘snoeien’. Dit houdt in dat je hem kleiner maakt zodat hij niet te gefocust raakt op de details. Maar er zijn ook andere oplossingen, en een daarvan is het random forest algoritme.

Een random forest is precies dat wat de naam al suggereert: een verzameling van random bomen, beslissingsbomen. Er wordt een verzameling van decision trees gegenereerd met random variaties in de trainingset en input variabelen. Deze decision trees krijgen dan elk een stem. In het geval van classificatie wordt het uiteindelijke antwoord bepaald door de meerderheid van die stemmen. In het geval van regressie wordt het gemiddelde genomen. Op deze manier wordt voorkomen dat het model overfit raakt, iets wat vooral een risico is voor trainingsets met veel variabelen en weinig datapunten. Random forests daarentegen kunnen daar over het algemeen uitstekend mee omgaan.

Dit en het feit dat ze over het algemeen vrij simpel te trainen zijn maakt ze erg populair. Ze doen het vooral goed voor classificatie maar zijn ook geschikt voor regressie. Ze worden gebruikt bij allerlei toepassingen op allerlei gebieden. Ze worden gebruikt door banken om kandidaten voor een lening te beoordelen. Ze worden gebruikt op de beurs om trends te voorspellen. Ze worden gebruikt in computer visie, bijvoorbeeld voor X-box connect. En nog veel meer.

En dat is het. Simpel nietwaar? Natuurlijk komt er wat meer bij kijken als je zo’n decision tree of random forest zelf wilt implementeren en trainen. Maar daarover later meer. Ik wil er namelijk eerst voor zorgen dat je het grote plaatje duidelijk hebt. Door de bomen het bos zien aldus. Bovendien heb ik de details zelf ook nog niet allemaal op een rijtje. Een boom tegelijk planten en zo. Maar, dat is alles voor nu.

Tot de volgende keer!

Project update: Random Forest Wijnproever

Hallo wereld,

Inmiddels ben ik begonnen aan de Random Forest Wijnproever. Ik heb de tutorial succesvol afgerond en een werkend model met behulp van de sklearn library gegenereerd.

Laat ik beginnen met uitleggen wat ik gedaan heb in deze tutorial. Alle code werd in deze tutorial gewoon aangereikt en het was in principe een kwestie van de uitleg lezen en de code gewoon overtypen. Desalniettemin is het toch een leerzame oefening zolang je de uitleg ook echt bestudeert en je best doet om de stappen te begrijpen. Het is echter best ingewikkelde theorie en als ik de Data Science Primer niet eerst bestudeerd had dan had ik er waarschijnlijk niet veel van gevolgd. Snap je dus niet waar ik het over heb, dan is het misschien een idee om daar eerst eens naar te kijken en/of naar de voorkennis die wordt aanbevolen in de tutorial. Mijn versie van de code kun je hier vinden. In tegenstelling tot in de voorbeeldcode heb ik twee afzonderlijke scripts gemaakt, een voor het genereren van het model (winesnob.py) en een voor het laden ervan nadat het is opgeslagen (winesnobloader.py). Hieronder zal ik uitleggen hoe het model gemaakt wordt.

Stap  3 en 4

Na het importeren van alle relevante libraries begint het met het laden van de dataset van een online locatie. Daarna wordt de dataset willekeurig gesplitst in een training set en een test set. Zoals de namen al suggereren, de trainingset is de subset van de data die gebruikt wordt om het model te trainen, en de testset de subset die gebruikt wordt om het model te testen. Het is belangrijk dat deze data gescheiden blijft, want anders leert het model geen patronen te ontdekken, maar gewoon de vaste antwoorden op de gegeven dataset. Het is te vergelijken met studenten laten studeren voor een proefwerk met het antwoordmodel. We willen niet dat het model leert alleen te presteren op de gegeven dataset maar op alle data. Om te kunnen testen hoe goed onze student de theorie heeft begrepen is het van belang dat we hem met vragen presenteren die hij/zij nog niet gezien heeft. Zo ook voor ons model.

Stap 5

Vervolgens is het de zaak om de data voor te bereiden. De data is namelijk nog niet geschikt voor het algoritme. Het moet nog gestandaardiseerd worden. Wat houdt dit in? Nou, dit is een concept binnen de statistiek. De korte versie is echter dat de data voor alle eigenschappen rond 0 wordt gecentreerd door het gemiddelde van die eigenschappen er af te halen. Daarnaast wordt het ook gedeeld door iets wat de standaarddeviatie heet, en dit zorgt ervoor dat de spreiding van de gegevens voor alle eigenschappen ongeveer hetzelfde is. Het resultaat van deze bewerkingen is dat alle eigenschappen even sterk meegenomen worden in het algoritme.

Stap 6, 7 en 8

Vervolgens is het tijd om het model te genereren en het vervolgens te trainen. Maar voordat we het model loslaten op de gehele trainingset is het eerst de zaak om de hyperparameters te bepalen. Dit zijn de parameters die bepalen HOE het model leert, niet WAT het leert. Om deze te kunnen bepalen wordt gebruikt gemaakt van een techniek die cross-validatie heet. Hierbij worden meerdere subsets van de trainingset gemaakt waarop modellen met verschillende hyperparameters worden losgelaten. Bij elk van die subsets wordt een kleine portie van de totale trainingset weggelaten bij het trainen van dit model en gebruikt voor het testen van dit model. Op deze manier blijft de echte testset dus onaangetast. Vervolgens worden de hyperparameters van het model met de beste prestatie uitgekozen. Deze hyperparameters worden dan gebruikt voor het model dat wordt losgelaten op de gehele trainingset. Deze laatste stap geeft slechts een kleine verbetering in prestatie ten opzichte van het model dat al losgelaten was op een iets kleinere portie van de trainingset, maar alle beetjes helpen.

Stap 9

Nu het model getraind is kan het getest worden op de testset. Hiervoor wordt het model gebruikt om de afhankelijke variabele te berekenen uit de onafhankelijke variabelen in de testset. Dit resultaat wordt dan vergeleken met de daadwerkelijke afhankelijke variabele die al gegeven was. De nauwkeurigheid van het model wordt dan weergegeven door de r2-score en mean-squared-error (mse) uit te rekenen.  De mean-squared-error spreekt voor zich, die wil je gewoon zo klein mogelijk hebben. De r2-score, ook wel determinatiecoëfficiënt (coefficient of determination) geeft aan hoe goed de “fit” is van het model. Bij een r2 van 1 is die “perfect”, maar van wat ik begrepen heb wil je tegelijkertijd ook voorkomen dat je model “overfit” is. Voor mijn model was de r2-score 0.46 en de mse 0.35, wat ongeveer overeen kwam met de waardes uit de tutorial. Wat dat precies betekent wordt niet echt uitgelegd, en heb ik ook nog niet uit kunnen vinden.

Stap 10

Nu hoeven we het model alleen nog op te slaan zodat we het met het andere script kunnen laden.

En klaar is Kees! Snap je het allemaal? Geloof het of niet, dat was het makkelijke gedeelte. Nu komt de echte uitdaging nog: mijn eigen Random Forest Algoritme schrijven. Ik ben hier namelijk al aan begonnen en ik zie nu al dat het een flinke uitdaging gaat worden. Al is het alleen maar het uitvogelen van Python. Ook zou het wel interessant zijn om de code aan te passen zodat het scores kan geven voor individuele gevallen. In hoeverre dit alles gaat lukken durf ik niet te zeggen, maar ik zal mijn best gaan doen. Dat is alles voor nu.

Tot de volgende keer!

 

Projectaankondiging: Random Forest Wijnproever

Hallo wereld,

Een tijd geleden gaf ik al aan dat ik een nieuw idee had voor een project.  Ik had het idee om een simulatie te programmeren, data te genereren en een programma te schrijven om die data te analyseren. Echter, dit idee gaat voorlopig niet door. Waarom niet? Nou het was me nog niet echt duidelijk hoe deze programma’s er precies uit zouden komen te zien. En hoe meer ik hierover nadacht, hoe meer ik me realiseerde dat ik me eigenlijk eerst ergens anders op wilde focussen. Namelijk, het bestuderen, toepassen en zelf programmeren van machine learning algoritmes. Aldus koos ik voor het volgende project.

Ik ga een tutorial volgen voor het schrijven van een machine learning applicatie in Python die wijnkwaliteit leert beoordelen. Een tutorial op EliteDataScience, een website die mensen de leermiddelen aanreikt om een data wetenschapper te worden. Nu vindt ik dat reuze interessant, maar het is op het moment niet mijn bedoeling om een data wetenschapper te worden, maar een programmeur van datasystemen. En met deze tutorial leer ik onder andere hoe ik de data science libraries van Python kan gebruiken om data te analyseren. En ik heb al wat geleerd op deze site over wat er allemaal komt kijken bij het uitvoeren van een goede data analyse, maar ik wil een stapje verder gaan. Ik wil ZELF het algoritme programmeren dat de data analyseert, in plaats van alleen de kant en klare versie in de gebruikte Python library te leren toepassen. En dat is dan ook het echte project: mijn eigen algoritme programmeren.

Misschien dat je je afvraagt wat het nut hier van is. Immers, waarom zou ik iets programmeren waar al een library voor is? Nou, het antwoord daarop is natuurlijk dat ik wil leren hoe het het algoritme werkt. Ik wil het zo goed leren begrijpen dat ik het zelf kan programmeren.

Bovendien zal ik hiermee ook mijn programmeervaardigheden over het algemeen verbeteren. En ja, ik ga dat doen met Python. Een taal waar ik tot nu toe slechts een klein beetje ervaring mee heb opgedaan met het maken van Conway’s Game of Life. Dat is het eerste en enige programma dat ik tot nu toe met Python heb gemaakt. Dus ook dat zal leerzaam zijn.

Eerst volg ik de tutorial en voer ik de data analyse uit met de methode uit de library. In de tutorial leer je om een programma te schrijven dat leert om een cijfer voor de wijnkwaliteit te berekenen op basis van een lijst van eigenschappen. Het leert om dit te doen op basis van een set trainingsdata. Het doet dit met een random forest algoritme uit de Scikit-Learn library. Daarna schrijf ik mijn eigen random forest algoritme, voer de analyse daarmee opnieuw uit, en vergelijk de resultaten. Het random forest algoritme is een regressie algoritme: het leert om een variabele te berekenen op basis van een aantal inputvariabelen. En zegt dit je niet niets, bekijk dan eventueel ook mijn post over datamining waarin ik onder andere kort uitleg wat regressie is. En wat het random forest algoritme betreft, daarover en ook over regressie zal ik meer uitleggen in de loop dit project. Wil je nu al meer weten hierover, kijk dan misschien eens naar H5 van de Data Science Primer op EliteDataScience. Daar wordt het heel duidelijk uitgelegd. Dat is alles voor nu.

Tot de volgende keer!