Auteur: sedaniel

  • Home   /  
  • Artikelen geplaatst doorsedaniel
    • ( Pagina4 )

Door de bomen het bos zien

Hallo wereld!

Wat zijn random forests?

Hoe werken ze?

Waar worden ze voor gebruikt?

Nou, laat ik 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

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 van die gelabelde data kan het algoritme dan leren wat het verschil is tussen honden en katten en nieuwe plaatjes zelf leren categoriseren.

De twee hoofdtaken binnen supervised learning zijn 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

Decision trees zijn machine learning algoritmes die 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.

 

Random Forest

Een random forest is precies dat wat de naam al suggereert: een verzameling van (random) 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!

FOCUS

Wat is het doel van deze blog? Wat wil ik bereiken voor mijn lezers en voor mezelf? Dat zijn de vragen die ik de afgelopen dagen geprobeerd heb te beantwoorden.

In mijn laatste mededeling merkte ik dat de antwoorden op deze vragen nog niet helemaal duidelijk waren, voor mij noch voor jullie. En dat was een probleem, want als je niet weet waar je naar toe wilt dan kom je niet vooruit. Ik wist niet precies wat ik wilde leren, waarom ik het wilde leren, en hoe ik jullie kon helpen met wat ik aan het leren was. De wereld van data is zo groot, en mijn brein is zo klein. Hoe graag ik ook mezelf en jullie alles zou willen leren over data, dat lukt niet. Maar wat ik wel kan doen is alles leren wat essentieel is om een carrière in Data Science te beginnen, en onderweg delen wat ik leer zodat jullie dit ook kunnen. Wat ik wel kan doen is andere mensen aanmoedigen om daarbij te helpen door hun eigen kennis en vaardigheden te delen en in te zetten. En dat is dan ook wat ik ga doen.

Het plan voor de komende 6 maanden is als volgt. Ik ga alles leren wat essentieel is voor het krijgen van een baan als Junior Data Scientist. Om te bepalen wat dat is heb ik het advies op EliteDataScience opgevolgd en een toekomstig CV opgesteld voor mezelf.

Bijna alle vaardigheden op dit CV komen frequent in een of andere vorm voor in de functie-eisen voor Junior Data Scientist. De tools, talen en details verschillen, maar het komt in principe neer op :

  1. Kennis van (toegepaste) wiskunde, en vooral statistiek
  2. Ervaring met Python en/of R of vergelijkbare taal
  3. Ervaring met data analyse en data visualisatie en bijbehorende tools
  4. Ervaring met het trainen van machine learning algoritmes

Daarnaast wordt ook waarde gehecht aan ervaring met Git of een andere tool voor version control, ervaring met andere programmeertalen en een goede beheersing van zowel de Nederlandse als de Engelse taal. Zoals ik al zei verschillen de details, maar de vaardigheden die op mijn toekomstige CV staan zijn:

  • Toegepaste Statistiek
  • Machine Learning
  • Python
  • Java
  • SQL
  • R
  • Excel
  • Git
  • Calculus
  • Lineaire Algebra

Een aantal van deze vaardigheden beheers ik al tot op bepaalde hoogte, een aantal ervan heb ik in mijn opleidingen al voorbij zien komen, en met een aantal ervan heb ik nog vrijwel geen ervaring. Maar aan het einde van de komende 6 maanden is het mijn doel dat ik al deze vaardigheden redelijk tot uitstekend beheers. En dat jullie toegang hebben tot een hele hoop berichten waarin ik uitleg wat ik heb geleerd en de projecten die ik heb uitgevoerd presenteer en uitleg. En natuurlijk ook tot de informatie die alle andere Dataridders hier willen delen.

Lijkt dat je interessant en waardevol? Mooi, dan zie ik jou graag terug bij Dataridder! Ik heb overigens ook de Over Dataridder pagina aangepast aan deze nieuwe doelstelling. De pagina op EliteDataScience waarop onder andere het advies wordt gegeven om een toekomstig CV voor jezelf samen te stellen kun je hier vinden. 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!

 

Project brainstorm fall-out 2.0

Update: Dit is een aangepaste versie van een eerder bericht.

Hallo wereld,

Pfoe, ik heb echt heel veel nagedacht de afgelopen twee weken. Ik had het in mijn eerdere projectaankondiging al over mijn beslissing om toch iets anders te doen dan ik eerst in gedachten had. Het eerdere idee was een Simulatie Data Applicatie. Dit project had twee onderdelen, aan de ene kant een simulatie die data genereerde, en aan de andere kant het analyseren van die data.

Het eerste probleem was bedenken wat ik zou gaan simuleren. Eerst was mijn idee om een marktwerking simulatie te maken, met consumenten en producenten die op basis van individuele gedragingen een marktproces zouden genereren. Best een leuk idee, maar ook best complex en een beetje of topic. Dus ik besloot daarna om in plaats daarvan een oude simulatie op te graven: PredPrey, een simpele simulatie die ik had gemaakt van de interactie tussen roofdieren en prooien. Maar toen moest ik nog bedenken wat ik dan ging analyseren, en hoe, en waarom, en toen liep het helemaal uit de hand.

Eigenlijk kwam het allemaal terug op de vraag: wat wil ik leren? In het begin had ik hierop geantwoord: data analyse en opslag systemen programmeren. Echter, hoe meer ik nadacht en onderzoek deed, hoe meer ik me realiseerde dat dit antwoord niet compleet was, en tegelijkertijd ook best vaag en breed. Dingen waar ik me tot nu toe namelijk mee bezig hield, of van plan was mee bezig te houden, waren:

  • Applicaties met user interface te schrijven die gebruikers in staat stellen om data te analyseren. Grafieken maken, machine learning algoritmes erop los laten etc.
  • Databases programmeren, voor het opslaan, organiseren en aanpassen van data.
  • Simulatie applicaties schrijven die leervolle data genereren.
  • Zelf goede data analyse uit voeren met behulp van bestaande applicaties.
  • Zelf machine learning algoritmes schrijven die data analyseren.

En dat is eigenlijk allemaal veel te veel voor een persoon om met enige diepgang te bestuderen. En zonder diepgang zijn de praktische toepassingen beperkt. Aldus dacht ik. En ik wilde mij daarom gaan specialiseren, zodat ik meer diepgang kon opbouwen en meer waarde toevoegen. En in de vorige versie van dit bericht kondigde ik dan ook aan dat ik mij ging specialiseren in het begrijpen en programmeren van machine learning algoritmes voor data analyse. Dit leek mij het meest interessant en waardevol.

Maar, inmiddels weet ik het eerlijk gezegd allemaal niet zo zeker meer. Al deze dingen zijn interessant en waardevol. Het is waar dat ik meer expertise kan opbouwen als ik mij focus, en uiteindelijk zal ik dat dan ook willen doen. Maar ik weet eerlijk gezegd nog niet waar ik mij in wil specialiseren. Ik denk dat het nog te vroeg is om te zeggen.

Dus, hoewel ik mij in mijn volgende project daadwerkelijk ga focussen op het begrijpen en toepassen van het random forest algoritme, zal ik in de toekomst waarschijnlijk gewoon een beetje blijven experimenteren. Ik zal blijven posten over meerdere van die dingen die ik heb genoemd die met data en data systemen te maken hebben, en wie weet ook nog wat andere dingen binnen dit onderwerp. Ik kan er wel meer bedenken namelijk. bijvoorbeeld:

  • Applicaties die automatisch data verzamelen van het internet, of andere bronnen.
  • Persoonlijke (mobiele) applicaties die handige data analyse taken kunnen uitvoeren. (Denk aan spraakherkenning, muzieksuggesties, maar ook medische diagnoses en beroepsadvies.)

Misschien dat dit jullie ook helpt om te bepalen wat jullie het meest interessant vinden. Of wat leert over wat jullie al weten dat jullie het meest interessant vinden. Weten jullie zelf nog meer interessante onderwerpen, laat het weten. Maar 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!

Heldenmissie1: Schild wapen

Update: Deadline uitgesteld tot 1 maart 2019

 

Hallo wereld,

Het is tijd voor de eerste Heldenmissie! Dataridder is op zoek naar een schild wapen, blazoen of, in modernere termen, een logo. Want, zoals ik al aangaf in mijn bericht van vorige week, elke ridder moet herkenbaar zijn voor zijn bondgenoten.

De missie

Wat: Ontwerp een logo voor Dataridder.

Hoe: Hoe je maar wilt, zolang het uiteindelijk maar een digitaal afbeeldingsbestand is en het er professioneel en aantrekkelijk uitziet. Het formaat waar ik aan denk is 128×128 pixels, maar wil jij een ander formaat gebruiken, ga je gang. Maak het echter ook niet al te ingewikkeld en gedetailleerd, want uiteindelijk zal het vooral als kleine versie verschijnen. Hoewel een gedetailleerde versie wel mooi zou staan op een shirt… Wat je ook maakt, email je logo naar sedaniel@dataridder.nl.

Waarvoor: 1000 Ridderpunten en de Eretitel: Schildknaap! Grapje. De Eretitel: Logo Held! Weet ik veel. 100 Ridderpunten voor wie een betere Eretitel naar mij toe stuurt! Anders wordt het gewoon Logo Held. Of Wapen Waus. Oké, ik houdt op.

Wanneer: Voor het begin van het nieuwe jaar, ofwel 1 januari 2019.

Dan al?! Ja dan al. Als er tegen die tijd nog geen logo’s zijn binnengekomen dan zal ik mijn eigen logo namelijk waarschijnlijk invoeren. Nu ben ik zelf best handig met een potlood, ik ben geen kunstenaar en zeker geen digitale artiest. Ik denk daarom dan ook dat er zeker wel iemand van jullie is die het beter zou kunnen ontwerpen dan ik. Desalniettemin heb ik wel al mijn eigen concept gemaakt. Hieronder staan daar twee simpele 64×64 pixel schetsen van.

Ja, ik weet het, afgrijselijk. Maar het gaat om het concept. Als je er goed naar kijkt dan valt je misschien op dat het gebaseerd is op het symbool van de aanknop van je apparaten (de samenvoeging van een 0 en een 1, ofwel binaire code) wat past bij het data gedeelte van Dataridder. Tegelijkertijd is het ook een zwaard en een schild, wat past bij het ridder gedeelte van Dataridder. Ik vind het wel wat hebben.

Als je dit concept leuk vindt zou je het verder kunnen uitwerken tot een logo waar je je ogen niet bij dicht hoeft te knijpen. Maar vindt je dit idee maar niks en heb je zelf een veel beter idee, ook geweldig!

Dat is alles voor nu,

Tot de volgende keer!

 

Datamining

Hallo wereld. Dit keer ga ik jullie wat vertellen over datamining. Datamining (gegevensdelving, datadelving) is het gericht zoeken naar patronen en verbanden in verzamelingen van gegevens met als doel tot waardevolle kennis te komen. Het wordt toegepast in legio aan gebieden, zoals de wetenschap, de detailhandel, de financiële sector, de politie en de journalistiek. Denk bijvoorbeeld aan het analyseren van het aankoopgedrag van klanten om bedrijfsstrategieën te verbeteren, of het vinden van onregelmatigheden in online activiteit voor het opspeuren van criminelen.

De technologische ontwikkelingen van de laatste tijd hebben het verzamelen en opslaan van data steeds makkelijker gemaakt. Niet alleen dat, de wetenschappelijke en economische ontwikkelingen hebben ervoor gezorgd dat er veel meer data relevant voor ons geworden is. Echter, als mens zijn we niet opeens beter geworden in het verwerken van al die gegevens. Hierdoor hoopt het aantal gegevens zich op, gegevens die mogelijk tot waardevolle informatie zouden kunnen leiden als we ze zouden kunnen analyseren. Dit is waarom datamining steeds interessanter wordt als technologie. Het stelt ons in staat het onttrekken van informatie, dat wil zeggen nuttige inzichten en voorspellingen, uit die steeds harder groeiende hoop van gegevens te automatiseren.

Hierbij is het echter belangrijk dat dit allemaal op een verstandige en wetenschappelijke manier gebeurt. Het is heel gemakkelijk om verbanden te vinden met een programma die in werkelijkheid niets zeggen of iets heel anders betekenen dan op het eerste gezicht lijkt. Wist je bijvoorbeeld dat er meer mensen verdrinken op dagen dat er meer ijsjes verkocht worden? We moeten echt ophouden met al die ijsjes, niet waar?! Oh, of is het misschien dat er op warmere dagen meer mensen naar het strand komen en het risico lopen te verdrinken, en dat er ook meer ijsjes verkocht worden omdat er meer mensen op het strand zijn?

Datamining is onderdeel van een groter proces bekend als KDD: knowledge discovery in databases (kennisvergaring uit databases), waar meer bij komt kijken dan alleen het analyseren van de data. Maar met datamining wordt gerefereerd naar de analyse stap zelf en hierbij zijn een aantal verschillende analyse taken te onderscheiden:

  • Het groeperen van data. (Clustering)
  • Het vinden van verbanden tussen data. (Dependency modeling)
  • Het vinden van onregelmatigheden in data. (Anomaly detection)
  • Classificatie. (Classification)
  • Regressie. (Regression)
  • Samenvatten. (Summarization)
Het groeperen van data. (Clustering)

Hierbij gaat het om het groeperen van objecten op een dusdanige manier dat de objecten binnen een groep meer met elkaar in gemeen hebben dan met objecten binnen een andere groep. Hierbij gaat het om het vormen van nieuwe groepen in plaats van het indelen in bestaande categorieën. Dit kan worden toegepast op allerlei gebieden en leiden tot interessante nieuwe inzichten. Bijvoorbeeld een nieuwe groep consumenten met bepaalde gemeenschappelijke kenmerken die voorheen onopgemerkt bleven, door deze techniek toe te passen op klantonderzoeksgegevens.

Het vinden van verbanden tussen data. (Dependency modeling)

Het schijnt dat er een verband is tussen het aantal ooievaars dat wordt aangetroffen in een land en het aantal baby’s dat geboren wordt. Wist je dat? Helaas, het is weer niet echt een veelzeggend verband, en heeft meer te maken met het feit dat grotere landen zowel meer ooievaars als geboortes hebben. Toch, met datamining kunnen allerlei verbanden worden ontdekt tussen gegevens en soms zeggen die verbanden wel nuttige dingen. Bijvoorbeeld dat het gebruik van een bepaald medicijn vaak voorkomt in combinatie met hartproblemen. Handig om te weten. Of bijvoorbeeld om te voorspellen wat voor weer het morgen wordt.

Het vinden van onregelmatigheden in data. (Anomaly detection)

Je hebt een oneindige hoeveelheid aan gegevens en je bent op zoek naar de uitschieters, de objecten die buiten de boot vallen. Bijvoorbeeld om criminelen op te sporen, of een defect product. Succes om dat met het blote oog te doen. Daar heb je datamining voor nodig. Het is in principe niets anders dan het vinden van waarden die buiten bepaalde grenzen vallen, maar dus ook het bepalen van de grenzen waarbinnen het merendeel van de andere gegevens liggen.

Classificatie. (Classification)

Is dit een foto van een hond of een kat? Is dit bericht spam of geen spam? Is deze persoon zwanger, of niet zwanger? Zal deze persoon zijn lening wel of niet gaan aflossen? Dit zijn voorbeelden van vragen die je met (statistische) classificatie kan beantwoorden. En hoe doet een systeem dat? Nou, door op basis van een training set van objecten met bekende classificatie te leren onbekende objecten te classificeren. Als dat te ingewikkeld klinkt, het komt er in principe op neer om een systeem bijvoorbeeld een aantal plaatjes van honden en katten te laten zien totdat het in staat is om zelf te raden (met een bepaalde nauwkeurigheid) of een plaatje van een hond of een kat is. Dit is dan ook een van de hoofdtoepassingen van machine learning.

Regressie. (Regression)

Welke functie beschrijft deze datapunten het beste? Regressie is het proces waarmee verbanden tussen gegevens worden ingeschat. Het gaat er dan om uit te vinden hoe veranderingen in een bepaalde onafhankelijke variabele een bepaalde afhankelijke variabele beïnvloedt. Hierbij worden de andere onafhankelijke variabelen constant gehouden. Bijvoorbeeld: als je een hele hoop gegevens hebt over de verkoop van ijsjes N op een bepaalde dag onder bepaalde omstandigheden, hoe hangt dan de verkoop van ijsjes af van de temperatuur T? We zijn dan op zoek naar een functie N(T) die dit verband beschrijft zodat we voor elke T kunnen voorspellen hoeveel ijsjes er verkocht zullen worden.

Samenvatten. (Summarization)

Hierbij gebeurt er letterlijk wat er staat. Er wordt wat samengevat. Heb je bijvoorbeeld een groot document (of een grote hoeveelheid grote documenten) dan kun je met een programma een samenvatting genereren die bijvoorbeeld bepaalde veelvoorkomende zinnen verzameld. Of als je een grote verzameling tekst hebt van bijvoorbeeld een klantenonderzoek, dan kun je uitzoeken wat het meest gebruikte woord of de meest voorkomende zin is. Hierbij komt natuurlijk het een en ander kijken om dit goed te kunnen doen en met meer diepgang dan alleen het uitvinden van de meest gebruikte combinatie van letters. Ook hier komt machine learning bij kijken.

En dat is het! Nou niet per se. Dit zijn slechts de taken die genoemd werden op Wikipedia, en er zijn er waarschijnlijk nog wel meer te bedenken. Ja ik geef het toe, ik heb deze informatie voor een groot deel (maar niet exclusief) van Wikipedia afgehaald. Ik hoop echter dat je mijn uitleg beter begrijpt dan het lange en technische verhaal dat daar te vinden is. De bronnen die ik gebruikt heb staan onderaan dit bericht. Dat is alles voor nu.

Tot de volgende keer!

Bronnen

https://nl.wikipedia.org/wiki/Datamining

https://en.wikipedia.org/wiki/Data_mining

https://en.wikipedia.org/wiki/Cluster_analysis

https://nl.wikipedia.org/wiki/Rofecoxib

https://en.wikipedia.org/wiki/Regression_analysis

https://en.wikipedia.org/wiki/Statistical_classification

Data Mining Practical Machine Learning Tools and Techniques – I. Witten, E. Frank (Geweldig boek!)

StudentApp klaar voor nu

Hallo wereld!

Ik heb nog een aantal laatste aanpassingen gemaakt aan het studenten datasysteem. Dit zullen waarschijnlijk de laatste aanpassingen zijn die ik voorlopig zal maken. In plaats daarvan ga ik verder met nieuwe projecten, waarvan ik al wat gezegd had in mijn mededeling van vorige week.

Ten eerste heb ik de code een beetje gereorganiseerd. In JavaFX maakt men gebruik van wat men noemt Scenes om de windows te vullen met alle interface componenten. Tot nu toe had ik al deze Scenes in een method gepropt. Het resultaat? Een lange onoverzichtelijke rij van code met allerlei interface componenten die allemaal naamconflicten oproepen die constant moeten worden opgelost. Nu heb ik elke Scene laten genereren in een aparte method per stuk. Het resultaat? Een lange onoverzichtelijke rij van methods die in ieder geval geen naamconflicten meer veroorzaken. Na al het scrollen en programmeren en tijdens het schrijven van dit bericht kwam ik er echter weer achter dat je die lange onoverzichtelijke rijen code in Netbeans ook kon inklappen door op het minteken ernaast te klikken. Zucht…

Bovendien bleek het ook handig te zijn om Scenes te laten genereren in de functionaliteit van andere Scenes, door die methodes op deze plekken in te voeren. Bijvoorbeeld om de naam van de ingelogde student aan te passen tijdens het inloggen zelf. Waarschijnlijk kan het nog steeds allemaal veel beter, maar JavaFX was nog steeds onwennig voor mij en dit is de beste oplossing die ik voor nu kon vinden.

Ook heb ik de mogelijkheid om de save folder te wijzigen toegevoegd. Zoals ik al zei is dat veel professioneler. Niet alleen kun je hem nu wijzigen, het is nu ook niet meer zo dat hij automatisch wordt gemaakt in je C directory. In plaats daarvan wordt automatisch de folder geselecteerd waarin je de jar-file hebt opgeslagen voor opslag. Wees echter gewaarschuwd, als je hem in je IDE runt dan wordt automatisch de build folder geselecteerd, en die is niet geschikt voor permanente opslag. Zorg er dan in dit geval dus voor dat je de folder dan ook wijzigt met de handige functionaliteit die ik heb toegevoegd! Wil je niet dat de informatie direct in je geselecteerde folder wordt opgeslagen maar een nieuwe folder aanmaken? Dat kan ook. Type gewoon de naam van de folder die je wilt maken achter het bestandspad en de folder wordt automatisch aangemaakt.

Daarnaast heb ik ook een simpele zoekfunctie toegevoegd. Niets bijzonders, maar wat heb je aan een database waarin je niet kan zoeken? In mijn database staan dan misschien maar slechts een paar elementen, maar in een echte toepassing zouden er al snel honderden tot duizenden rijen in staan. De droom dat deze database een echte toepassing zou worden heb ik voorlopig echter even uitgesteld. Voor nu is het dan ook alleen maar mogelijk om op ID-nummer te zoeken. Meer als proof-of-concept dan als handige functionaliteit dus.

Tot slot heb ik ook een simpele cirkeldiagram scene toegevoegd die de verdeling van de studenten over de verschillende studiejaren toont. Om deze functioneel te maken heb ik dan de beschikbare jaarkeuzes beperkt tot 1 tot en met 5. Deze scene is mijn poging om een beetje data analyse aan het data opslag systeem toe te voegen. Want data analyse is natuurlijk veel leuker dan data opslag!

En dat is het! De code is te vinden op https://github.com/SamsonCodes/StudentenData/tree/evenmorechanges. Het is tijd voor een nieuw project. Wat voor project? Nou, dat vertel ik jullie volgende week natuurlijk.

Tot de volgende keer!

 

Java Tutorial: Data laden

Update: Dankzij Thom, een oud-medestudent en vriend van mij, is deze tutorial nu verbeterd. Thom, je bent een held!

Gegroet Dataridders,

Welkom bij de tweede Java data tutorial. Dit keer zal ik jullie leren hoe je data die je hebt opgeslagen in een bestand als tekst kunt laden. Opnieuw geldt hierbij: Dit is hoe ik het altijd gedaan heb en niet per se de enige noch de beste methode. Voor deze tutorial gelden dezelfde benodigdheden als bij de vorige:

  • Java SDK geïnstalleerd op je systeem
  • Een Java IDE, bijvoorbeeld Netbeans of Eclipse
  • Basiskennis van programmeren met Java

Om te beginnen zullen we weer eerst onze methode definiëren. We willen een functie die als input een bestandslocatie filePath voor een tekstbestand neemt en dan als output ons de tekst in dat bestand geeft in een ArrayList van String gegevens. En net zoals de vorige keer mag de functie weer static zijn, aangezien er geen object nodig is om hem te gebruiken. Dit ziet er dan als volgt uit:

public static ArrayList<String> loadData(String filePath)
{
ArrayList<String> loadedData = new ArrayList();
return loadedData;
}

Op dit moment wordt er nog niets geladen en is de ArrayList die wordt gereturned door onze methode nog leeg. Laten we daar verandering in brengen. Om onze data te laden zullen we gebruik maken van een FileReader. Moet ik echt uitleggen wat deze class doet?

Hij leest bestanden.

Maar een FileReader is niet erg efficiënt voor onze toepassing. Daarom hebben we nog een class nodig: BufferedReader. Een BufferedReader neemt als input een ander Reader object, en het resultaat is een Reader met byte-buffering, welke efficiënter is.

Echter, voor onze toepassing maakt die extra efficiëntie niet veel uit. We zijn meer geïnteresseerd in de readLine() methode van de BufferedReader, maar daarover later meer. Dat ziet er dan als volgt uit:

FileReader fileReader = new FileReader(filePath);
BufferedReader bufferedReader = new BufferedReader(fileReader);

Wat in Google’s naam is byte-buffering?! Eerlijk gezegd heb ik geen idee. Sterker nog, voordat ik deze tutorial maakte wist ik niet eens wat een BufferedReader was, waarom ik het moest gebruiken en waarom het een FileReader als input nam. Maar ik wist wat Google was en ik wist wat copy-paste was en dus ik wist hoe ik data moest laden.

Ik wilde voor deze tutorial echter toch wel iets meer kunnen uit leggen over het onderliggende proces dan dat, en dus heb ik maar wat onderzoek gedaan. Wil je meer weten over byte-buffering dan heb je twee opties: Wacht totdat ik besluit een tutorial of blog post te doen over byte-buffering, of doe wat ik doe als ik iets niet weet: Google het!

Genoeg intermezzo, verder met programmeren!

Net zoals bij de constructor van de PrintWriter moeten er weer wat Exceptions opgevangen worden bij de initialisatie van de FileReader. We zullen de code dus weer met try en catch omringen.

try
{
fileReader = new FileReader(filePath);
BufferedReader bufferedReader = new BufferedReader(fileReader);
}
catch (FileNotFoundException ex)
{
Logger.getLogger(DataLoadingTutorial.class.getName()).log(Level.SEVERE, null, ex);
}

Nu kunnen we de BufferedReader gebruiken om ons bestand te lezen. We doen dat met de eerder genoemde readLine() functie van BufferedReader en een while loop. De readline() functie stelt ons in staat hele regels tegelijk te lezen in ons programma, iets wat met FileReader niet kan. Zolang ons bestand nieuwe regels met tekst bevat zal readLine() ons deze geven. We willen voor onze while loop dan de output van readLine() toe blijven voegen aan onze ArrayList totdat readLine() ons een lege regel geeft. Dit ziet er dan als volgt uit:

String line;
while ((line = bufferedReader.readLine()) != null)
{
loadedData.add(line);
}

Ook readLine genereert echter weer wat vervelende Exceptions die moeten afgehandeld worden, IOExceptions dit keer. We zullen dus een catch-clausule moeten toevoegen:

catch (FileNotFoundException ex)
{
Logger.getLogger(DataLoadingTutorial.class.getName()).log(Level.SEVERE, null, ex);
}
catch (IOException ex)
{
Logger.getLogger(DataLoadingTutorial.class.getName()).log(Level.SEVERE, null, ex);
}

De Logger code is overigens weer automatisch gegenereerd en wordt gebruikt om de foutmeldingen in het log scherm te weergeven maar is niet essentieel, en kan weggelaten of bijvoorbeeld vervangen worden door een “System.out.println()” met tekst naar keuze.

In principe werkt deze code zo dan ook, maar dankzij Thom weten we nu hoe het beter kan. Ten eerste was ik vergeten om de reader te sluiten nadat de File gelezen was. De meest elegante methode om dit te doen met Java is door de constructor te verplaatsen naar de try opening zoals hieronder:

try (BufferedReader bufferedReader = new BufferedReader(new FileReader(filePath)))
{
String line;
while ((line = bufferedReader.readLine()) != null)
{
loadedData.add(line);
}
}

Dit zorgt ervoor dat de reader gesloten wordt, zelfs als er een Exception plaatsvindt. Hetzelfde principe geldt overigens voor de PrintWriter van de savefunctie.

try (PrintWriter writer = new PrintWriter(filePath, StandardCharsets.UTF_8.name()))

Daarnaast is een FileNotFoundException een subclass van een IOException en kunnen we de catch voor de FileNotFoundException dus weglaten, en alles met de IOException opvangen.

catch (IOException ex)
{
Logger.getLogger(DataLoadingTutorial.class.getName()).log(Level.SEVERE, null, ex);
}

Tot slot is er blijkbaar nog een alternatieve, makkelijkere manier om gegevens te laden met Java 8, door gebruik te maken van Streams met de Files class.

// Alternative: Java 8 way with Streams
try
{
System.out.println(“”);
System.out.println(“Inhoud:”);
Files.lines(Paths.get(PATH + “test.txt”)).forEach(System.out::println);
}
catch (IOException ex)
{
Logger.getLogger(DataLoadingTutorial.class.getName()).log(Level.SEVERE, null, ex);
}

Ja, ik weet het, waarom niet gewoon deze tutorial daarmee beginnen?! Maar ik zei al, ik ging jullie laten zien hoe IK het deed, en ik kende deze manier nog niet. Bovendien kan ik jullie er op het moment ook weinig over deze alternatieve methode uitleggen, en denk ik dat het proces dat ik heb uitgestippeld in mijn methode nog steeds heel leerzaam is. In de toekomst zal ik deze manier echter misschien ook gaan gebruiken.

En klaar is kees!

Zolang je nu maar de juiste bestandslocatie opgeeft zal deze code alle regels uit je tekstbestand in een ArrayList zetten. De volledige code, inclusief extra code voor het testen is te vinden op https://github.com/SamsonCodes/DataLoadingTutorial. Trouwens, mocht je het nog niet weten, de Java files binnen een Netbeans project zijn te vinden in de src folder. In dit geval is er slechts een Java file, en die is te vinden in de dataloadingtutorial folder (in Netbeans: package) binnen deze src folder.

Dat is alles voor nu,

 

Tot de volgende keer!

Dataridders, Eretitels en de Heldentabel

Gegroet Dataridders,

Willen jullie ook dat Dataridder.nl een site wordt waar iedereen terecht kan om te leren een expert te worden in data?

Ik wel namelijk, en tot nu toe heb ik dat dan ook in mijn eentje proberen te doen. Maar ik realiseer me dat dit best wat tijd en moeite gaat kosten. Nu ben ik bereid om die tijd en moeite te investeren, maar ik vroeg me af of jullie het niet leuk zouden vinden om OOK een bijdrage te leveren aan deze missie. Want samen kunnen we veel meer bereiken dan ik alleen ooit zou kunnen.

En dus kwam ik op het idee voor een nieuw systeem dat jullie in staat te stelt een bijdrage te leveren en daarvoor te bedanken.

Wat voor systeem?

Van nu af aan zal ik regelmatig, waarschijnlijk elke vrijdag, missies posten die jullie kunnen uitvoeren om Dataridder.nl te verbeteren en titels en privileges te verdienen.

Wat voor titels? Nou, ten eerste is er de titel “Dataridder”. Een Dataridder is iemand die zijn expertise heeft aangetoond met het virtuele zwaard (programmeren) om de ruwe, meedogenloze wereld van data te temmen en orde en wijsheid in deze wereld te brengen (data opslag en analyse).

Ten tweede is er de titel “Ridder van de Heldentabel”. Een Ridder van de Heldentabel (niet te verwarren met de veel minder coole en onhandige “Ronde Tabel” van Koning Arthur) is iemand die een of meerdere waardevolle bijdragen heeft geleverd aan de missie van Dataridder.nl. Dat wil zeggen iemand die zijn unieke talenten heeft ingezet om deze site te transformeren tot een plek waar iedereen kan leren om een expert te worden in data. In het geval dat die unieke talenten zijn met het virtuele zwaard is zo’n persoon dan dus een “Dataridder van de Heldentabel’. Maar die talenten hoeven niet per se met het virtuele zwaard te zijn, en dat brengt mij op de laatste soort titels, “Eretitels”.

Eretitels zijn titels die men kan verdienen door het uitvoeren van speciale “Heldenmissies”, of door het op eigen initiatief uitvoeren van bijzonder heldhaftige daden die Dataridder.nl een betere leerplek maken. Het zijn toevoegingen aan de eerste twee soorten titels, die de belangrijkste bijdrage van deze persoon aan Dataridder.nl omschrijven. Dit kan een tutorial zijn over het gebruiken van TensorFlow voor data analyse, maar ook het helpen promoten of het verbeteren van het uiterlijk van de site. Hoe zou zo’n titel er dan uit kunnen zien? Nou bijvoorbeeld: AndroidAapje1 (gebruikersnaam), Dataridder van de Heldentabel (riddertitel), Maker van den Dataridder App (eretitel).

Wat voor privileges? Nou ten eerste zal je als Ridder of Dataridder van de Heldentabel een plaats verdienen op de toekomstige eervolle vermeldingspagina op deze site: de Heldentabel. Ten tweede zul je als Dataridder en of Ridder van de Heldentabel in de toekomst kunnen rekenen op speciale aanbiedingen, exclusieve inhoud en wie weet wat nog meer? Reken er echter op dat ik je dankbaar zal zijn en dat ik mijn best ga doen om dit te laten merken.

Maar alleen de mogelijkheid voor het verdienen van titels is nog niet echt ideaal als systeem. Wanneer is iemand een Dataridder? Hoeveel bijdrages moet iemand leveren om geridderd te worden, of moet het juist een enkele bijzonder grote bijdrage zijn? Daarom is er nog een element nodig, een puntensysteem. In dit puntensysteem zullen er twee typen punten te verdienen zijn, Datapunten en Ridderpunten. Datapunten representeren de expertise die iemand heeft getoond als virtuele zwaardvechter in de data wereld. Ridderpunten representeren de bijdrage die iemand heeft geleverd aan de Dataridder missie. Met voldoende Datapunten (1000) kun je de titel van Dataridder verdienen en met voldoende Ridderpunten (1000) kun je een plaats verdienen aan de Gegevenstabel.

Op dit moment is het zover ik weet nog niet echt mogelijk om een account aan te maken op deze website, WordPress heeft nog steeds een aantal mysteries voor mij en ook dit mysterie zal ik dus nog even moeten uitvogelen. Maar dat is geen reden waarom jullie niet nu al zouden kunnen beginnen met het verdienen van punten en titels. Dus reken er maar op dat die missies er aan komen. En de eerste missie komt volgende week! Om alvast een hint te geven: vinden jullie ook niet dat Dataridder er op het moment nog een beetje standaard uit ziet? Een tweede hint: De winnaar van deze missie zou weleens kunnen bepalen hoe de eerste producten van Dataridder er uit zouden komen te zien. Een derde hint: Elke ridder moet herkenbaar zijn voor zijn bondgenoten.

Weet jij wat deze missie gaat worden? Stuur mij dan een email met het antwoord op sedaniel@dataridder.nl, en de eerste persoon die het raadt verdient de eerste 100 Ridderpunten! Zo makkelijk ga je ze echt nooit meer verdienen…

Dataridders, de plicht roept.