-

Hoe doen computers slimme dingen? Flexibele modellen en neurale netwerken

Machine learning en artificial intelligence zijn termen die bedrijven graag gebruiken. Maar wat houdt het precies in, en hoe kun je data science succesvol inzetten? Professor Maurits Kaptein schept orde in de technologische verwarring.

In een poging om de zin van de onzin te scheiden op het gebied van Machine Learning, Data Science en AI – de naam doet er eigenlijk niet zoveel toe – een serie van zes artikelen over “hoe computers slimme dingen doen”. Het eerste artikel laat zien hoe computers, door middel van een goed idee, een (wiskundige) formalisatie, en daarna optimalisatie, een leuke film voor vanavond kunnen aanraden. Het tweede artikel in de serie laat de basis zien van supervised leren: hoe kunnen we door middel van een simpel wiskundig model de prijzen van huizen voorspellen? Echter, dat leek nog niet op de momenteel erg populaire neurale netwerken: dat gat probeer ik in dit artikel te dichten.

Stap 3: Flexibele modellen en neurale netwerken

In het vorige artikel zagen we hoe een computer kan leren om de prijs van een huis te voorspellen doormiddel van een simpele, rechte lijn. In dit geval was de voorspelde output y (de prijs van het huis) een functie van de input x (de grootte van het huis): y = a + b*x. Het ‘leren’ van de computer bestond simpelweg uit het zoeken naar de waarden van de parameters a en b waardoor de voorspelde prijs zo dicht mogelijk bij de geobserveerde prijs in de data kwam.

Echter, we hoeven ons natuurlijk niet te beperken tot rechte lijnen. Door de functie uit te breiden met extra parameters kunnen we relaties tussen input en output maken die steeds flexibeler zijn. De functie y = a + b*x + c*x2 maakt het mogelijk om ook gebogen lijnen toe te voegen. In het voorbeeldje van huizenprijzen is dat waarschijnlijk nuttig: de grootte van een huis zal voor kleine huizen waarschijnlijk meer effect hebben op de prijs dan voor grote huizen.

We hoeven ons ook niet te beperken tot functies van een enkele input: als we meerdere inputs hebben zoals de grootte van een huis x en de afstand van een huis tot het stadscentrum z, dan kunnen we de prijs ook proberen te voorspellen door nog meer parameters op te nemen, en zowel x en z mee te nemen in de functie: y = a + b*x + c*x2 + d*z.

In de praktijk leiden modellen met steeds meer parameters – dit zijn modellen die een flexibelere relatie tussen input(s) en output kunnen leren – tot steeds betere voorspellingen. Hoe flexibeler het model, des te beter kan een computer de voorspelde output matchen aan de daadwerkelijke output. De structuur van het probleem blijft echter steeds hetzelfde. De output y is een functie van alle input(s) x: y = f(x). De parameters van de functie bepalen hoe goed de voorspelde waarden overeenkomen met de waarden in onze data, en leren is niet meer dan het kiezen van de beste parameters (de optimalisatie stap).

Het verschil tussen decision trees, neurale netwerken, en deep learning is simpelweg een andere keuze van f(x). De simpele lijnen zoals hierboven beschreven zijn zogenaamde regressie modellen. Bij decision trees is f(x) een beslisboom: als de grootte van een huis groter is dan 100m2 dan kost het huis 250.000 euro, als de grootte kleiner is dan 100m2 dan kost het huis 150.000 euro. De parameters in dit geval zijn de zogenoemde splitsings-waarde — de 100m2 – en de twee voorspelde bedragen (250.000 en 150.000). Door meer splitsingen op te nemen kunnen ook decision trees zeer flexibel zijn.

Neurale netwerken zijn gebaseerd op een andere keuze voor f(x). Deze keuze is geïnspireerd op het idee dat we de inputs, de output, en de parameters visueel als volgt kunnen weergeven:

Maar, als dit kan, dan is er maar weinig wat ons ervan weerhoudt om f(x) veel flexibeler te maken door nog veel meer parameters toe te voegen:

Dit achter elkaar plakken van meerdere regressie modellen – in de praktijk vaak met nog wat additionele wiskundige bewerkingen – levert simpelweg een nieuwe, zeer flexibele functie op. Doordat de visuele weergave hierboven enigszins lijkt op een visuele voorstelling van de neuronen in onze eigen hersenen heeft dit model de naam neuraal netwerk gekregen.

Deep learning is niet meer dan een neuraal netwerk met meerdere lagen:

Voor de geïnteresseerde lezer, hier een overzicht van de verschillende typen netwerken, en dus van de verschillende keuzes voor f(x), die op dit moment veel gebruikt worden.

Bij regressiemodellen moeten we zelf het model flexibeler maken door parameters toe te voegen. Willen we een kromme lijn? Dan moeten we zelf x2 toevoegen aan f(x). Bij neurale netwerken is dit anders: doordat het netwerk heel veel parameters heeft kan een netwerk de kromme lijn leren zonder dat we deze zelf expliciet toevoegen. Mits er genoeg data beschikbaar is kan een neuraal netwerk – in de praktijk een functie met duizenden of soms miljoenen parameters – zeer complexe relaties tussen input en output leren zonder dat wij zelf aan hoeven geven hoe die relatie eruitziet. We hoeven dus ook niet meer zelf te kiezen welke variabelen belangrijk zijn (is het de grootte van een huis? De afstand tot het centrum van de stad? Het aantal badkamers?). We nemen ze simpelweg allemaal mee als input en het netwerk leert zelf welke delen van de input belangrijk zijn.

Het feit dat flexibele deep learning netwerken (mits we genoeg data hebben en een computer die snel genoeg is om goede parameter-waarde te vinden) zonder menselijke inmenging relaties tussen input en output kunnen leren heeft voor een revolutie in machine learning gezorgd. Vroeger, toen we bijvoorbeeld probeerden regressie modellen te gebruiken om een computer te leren geschreven tekst te herkennen, moest er nogal wat gebeuren. Iemand moest bedenken hoe we de geschreven tekst (uiteindelijk een plaatje en dus uiteindelijk een heleboel pixels met hun kleurcode) gingen relateren aan de output (een letter van het alfabet).

Dat was vrij lastig. Nu, als we genoeg input plaatjes hebben met de correcte output, en een computer die snel is, kunnen we simpelweg de computer laten uitvogelen wat een goede relatie tussen input en output is. Het is verassend hoeveel we met een simpel idee – een functie van input naar output en het kiezen van de parameters om de voorspelde output zo dicht mogelijk bij de werkelijke output te krijgen – kunnen doen als we het maar ver genoeg doortrekken. Als we maar genoeg voorbeelden hebben, en functies met genoeg parameters, dan kunnen we vrijwel alle relaties tussen input en output leren!

Te veel flexibiliteit?

Flexibele modellen zijn fantastisch en de moderne methoden waarop computers miljoenen parameters kunnen vinden zijn zeer indrukwekkend. Echter, meer flexibiliteit is niet altijd beter. Hoewel een flexibel model vaak beter werkt op de beschikbare data dan een niet flexibel model, is het niet zo dat een flexibel model het ook altijd beter doet op nieuwe data.

De intuïtie hiervoor is vrij simpel: als we de relatie van en output leren op basis van voorbeelden dan leren we aan de ene kant “signaal”: er is een daadwerkelijke relatie tussen de grootte van een huis en de prijs, en die relatie kan een computer leren. Aan de andere kant zit er in onze data waarschijnlijk ook “ruis”: er zijn verschillen in de prijzen tussen de huizen in onze specifieke data die niet verklaard worden door de grootte maar door andere factoren die we niet op hebben genomen in onze functie. Naarmate we steeds flexibelere modellen gebruiken is de kans steeds groter dat we niet alleen signaal leren, maar ook ruis. En, als we het model daarna gebruiken voor andere huizen, huizen die niet in onze dataset zaten, dan zijn onze voorspellingen slecht omdat we ten dele ruis voorspellen. Dit fenomeen wordt “overfitting” genoemd en verklaard waarom modellen soms heel goed werken op de beschikbare data, maar niet op nieuwe input.

Conceptueel zijn hier een aantal oplossingen voor. De eerste is simpel: kies een minder flexibel model. Dit kan door minder parameters op te nemen (minder lagen in het neurale netwerk bijvoorbeeld), of door de range van de parameter waarden te beperken (een techniek die “regularisatie” heet). Een andere oplossing is het simpelweg splitsen van de beschikbare data in een training-set die we gebruiken om de parameter-waarden te vinden en een test-set die we gebruiken om het model te evalueren. Als een model het goed doet in de training set, maar niet in de test set, dan overfit het model en moeten we op zoek naar een minder flexibel model. Een variant op dit laatste idee is de zogenaamde cross-validatie waarbij een dataset herhaaldelijk wordt opgesplitst in training en test sets.

Wrap up supervised leren

Ik hoop dat dit artikel, samen met het vorige, enigszins de magie van supervised leren – het leren tussen relaties van input en output – doorbreekt. Het “goede idee” is niet lastig en is al decennia bekend. Het wat er veranderd is, is de hoeveelheid beschikbare data en de beschikbare rekenkracht om parameters te kiezen. Hierdoor kunnen we nu ook zeer flexibele functies, zoals neurale netwerken, leren.

Deel dit bericht

Plaats een reactie

Uw e-mailadres wordt niet op de site getoond