AI is de verzamelterm voor alle programma’s die menselijke intelligentie nabootsen, op wat voor manier dan ook. Machine learning is een onderdeel van AI. Bij machine learning leert een model patronen uit data. Supervised machine learning, ook wel supervised learning genoemd, is het proces van een machine leren voorspellingen te doen op basis van eerdere data waarvan we het antwoord al kennen. Het model krijgt dus voorbeelden met het juiste label of antwoord.
Als we een spamfilter willen trainen, moeten we eerst een berg e-mails aan ons algoritme voeren met het label ‘spam’ of ‘geen spam’. Vervolgens leert ons algoritme patronen door al die e-mails door te kammen en kan het daarna bij nieuwe mails zonder label een geïnformeerde gok doen. Ook kan je superivsed learning gebruiken voor zoiets als het voorspellen van huizenprijzen. Je hebt dan een lijst met reeds verkochte huizen nodig en een aantal eigenschappen zoals grootte, hoe nieuw het huis is, energielabel etc, en natuurlijk de prijs. Dan leert het algoritme van deze data hoeveel iedere van deze eigenschappen ‘waard’ is, en gebruikt dat om de prijs voor een nieuw huis te voorspellen.
Unsupervised machine learning is een type machine learning waar wij patronen willen herkennen in data zonder dat we het antwoord al weten. Dit kunnen we dus niet gebruiken om huizenprijzen te voorspellen, maar wel om bijvoorbeeld klantengedrag te classificeren. Een bekend voorbeeld van unsupervised machine learning is het Netflix-algoritme dat je suggesties geeft op basis van wat mensen die dezelfde series leuk vinden ook kijken. Een ander voorbeeld is het ‘klanten kochten dit ook’-tabblad op websites zoals Amazon en Bol. Dit zijn vereenvoudigde voorbeelden; aanbevelingssystemen kunnen verschillende technieken gebruiken.
Deep learning is een onderdeel van machine learning waarbij we gebruikmaken van een ‘neural network’. Hier wordt gebruikgemaakt van een aantal lagen ‘neuronen’. Ieder neuron binnen deep learning is een kleine rekeneenheid die relatief eenvoudige rekensommen maakt. Ieder neuron gebruikt input van de vorige laag neuronen, maakt een berekening die vaak een antwoord tussen 0 en 1 geeft, en stuurt dit antwoord weer door. Dit zou je bijvoorbeeld kunnen gebruiken om te herkennen of er een kat te zien is in een foto. Geef je machine een berg foto’s waarvan een deel wel katten heeft en een deel geen katten, geef de labels van wel een kat of niet een kat mee en viola. Het algoritme stelt de parameters van het neurale netwerk zo in dat het goed wordt in het herkennen van katten in foto’s.
Large language models, ook wel LLM’s genoemd, zijn zelf weer een onderdeel van deep learning. Dit zijn je ChatGPT’s, je GROK’s en andere AI’s in deze lijn. Ze gebruiken net zoals bij deep learning neural networks, maar het grote verschil is de schaal. Waar een neural network dat je zelf met gemak kan bouwen misschien 100.000 parameters heeft, heeft een ChatGPT er inmiddels meer dan 200 miljard. De grote omvang van het neurale netwerk vereist ontzettend veel training en computerkracht, maar het resultaat is indrukwekkend. Er komen nog wat meer zaken bij kijken, zoals attention en tokenization, maar de kern van iedere LLM is een neuraal netwerk. LLM’s worden op verschillende manieren getraind; niet elke stap in hun training is supervised learning.
Stel je voor dat je zelf van deze technologie gebruik wil maken? Dan gaan de stappen als volgt:
We hebben een probleem waar we supervised learning op willen toepassen, bijvoorbeeld het voorspellen van huizenprijzen. Op basis van het doel kiezen we een algoritme dat het beste bij ons probleem past.
We verzamelen data over al verkochte huizen. Hoe recenter ze zijn verkocht en hoe meer huizen, hoe beter ons algoritme wordt.
We laten ons algoritme los op het leeuwendeel van de data die we al hebben.
We laten nu ons al getrainde algoritme los op de rest van de data om te zien of de voorspellingen kloppen bij de daadwerkelijke huizenprijzen. Als die testvoorspellingen goed zijn, zijn we tevreden en kunnen we nu ons model gebruiken. Als de voorspellingen slecht zijn, hebben we meer data nodig, betere data, een ander algoritme of een andere manier van trainen.
Wanneer je eenmaal een algoritme hebt uitgekozen, heb je training-data nodig om je AI op te trainen. In onze voorbeelden van een spamfilter, huizenprijzen en kattenherkenning hebben we toepasselijke training-data nodig. Dit zijn bijvoorbeeld e-mails waarvan wij van tevoren al weten of het wel of niet spam-e-mails zijn. Bij de huizenprijzen wordt de training-data iets gecompliceerder, en moeten we bij ieder huis een lijst van factoren meenemen en een prijs. Bij kattenherkenning hebben we foto’s nodig waar wel of niet katten in zitten. Hoe meer training-data we hebben, hoe beter — zolang de data ook geschikt en gevarieerd is.
Een van de belangrijkste stappen van het hele proces is het verzamelen van de juiste training-data. Het ‘Garbage in, garbage out’-principe verklaart wat er gebeurt als we het verzamelen van data foutief uitvoeren. We hebben voor een goed model erg gevarieerde data nodig. Wanneer wij een model trainen om katten te herkennen in foto’s, is het van cruciaal belang dat we niet alleen foto’s met katten en foto’s zonder katten hebben. We willen ook vele foto’s in onze training-data stoppen waar misschien een deel van een kat in te zien is, waar een poema of tijger of andere katachtige in zit, waar een aantal honden, marters en andere kleine zoogdieren in zitten, en zo voort. De twijfelgevallen zijn de gevallen waar we de meeste training-data voor willen hebben.
In het geval van spam-e-mails lijkt de training-data simpeler, maar ook daar komt veel bij kijken. Er zijn zo veel verschillende soorten spam-e-mails, en iedere soort moet herkend worden. Niet alleen de ‘gratis iPhone’-e-mails moeten gevangen worden, maar ook bijvoorbeeld de e-mails die zich voordoen als een factuur van een soortgelijke dienst die je toevallig hebt gebruikt. Net een nieuw dak laten vervangen bij dakvervanging.nl? Dan zou het fijn zijn als je model de nep-e-mail van dakvervaging.nl ook vangt. Zo zijn er nog veel meer venijnige spam-e-mails waar we voor behoed willen worden.
Bij de huizenprijzen is de training-data van onze voorbeelden het moeilijkst. Er zijn vele factoren die meespelen in de totale prijs van een huis. Bouwjaar, grootte van het perceel, grootte van het huis, de locatie, hoe goed het onderhouden is, hoeveel slaapkamers het huis heeft, heeft het een dakkapel, heeft het een bubbelbad, en nog veel meer factoren. Welke factoren kun je makkelijk meten? Wil je überhaupt alle factoren meenemen? Hoeveel waarde moeten we hechten aan veel natuurlijk licht in het huis? Hoe kwantificeren we ‘fijne buren’ in een monetaire waarde?
Het beslissen van wat voor data je wil gebruiken en dan vervolgens die data verzamelen, kan makkelijk het langste en het duurste proces zijn van het ontwikkelen van je AI. Het is hierbij echter niet noodzakelijk dat je een papiertje hebt waarop staat dat je goed wiskunde kan.
Een goede AI maken is een imposante taak. Je begint met een doel. Wat moet de AI doen? Op basis daarvan kiest men een algoritme dat het beste past bij je doel. Enkele voorbeelden zijn:
Wil je bijvoorbeeld een spamfilter maken voor een e-mailservice? Dan gebruik je logistische regressie. Dat is een algoritme dat kan classificeren tussen wel of niet spam.
Wil je een AI ontwikkelen die huizenprijzen kan inschatten? Dan maak je gebruik van een lineair regressie-algoritme dat verschillende factoren kan meenemen om een prijs te voorspellen. Bij de huizenprijzen hebben we data nodig van huizen met de uiteindelijke prijs. Het lineaire regressie-algoritme berekent dan hoe zwaar je alle factoren mee moet rekenen, zoals oppervlakte, aantal slaapkamers, grootte van de tuin, etc. Op basis van deze factoren en de uiteindelijke prijs kan het algoritme ‘leren’ hoeveel je iedere factor mee moet tellen om de prijs van een huis zo goed mogelijk te voorspellen.
Wil je een AI maken die katten kan herkennen binnen foto’s? Dan maak je gebruik van een convolutional neural network. Klinkt dat allemaal erg moeilijk? Gelukkig hoeven we niet precies te weten hoe iedere stap van ieder algoritme werkt om ze te kunnen gebruiken.
Een algoritme, datgene wat we nou geregeld AI noemen, is niets anders dan een stappenplan, vaak voor de computer. Dit houdt in dat wij tegen de computer vertellen hoe die om moet gaan met de input die wij meegeven, namelijk de training-data.
In het geval van de spam-e-mailherkenning slaan wij ieder woord dat wordt gebruikt in de Nederlandse taal (en vaak ook stukken van andere talen) op in een grote kolom. Die kolom, die we ook wel een vector noemen, heeft dan voor ieder woord een binaire 1 of 0 voor iedere e-mail. Ja als dit woord voorkomt in de e-mail, en nee als dat niet zo is.
Vervolgens krijgt ieder woord een bepaalde waarde om mee te beginnen, bijvoorbeeld een willekeurig getal voor ieder woord, of simpelweg 1 voor ieder woord. Als we alles een waarde van 1 toekennen, betekent dat dat we net zo veel waarde hechten aan het woord ‘gratis’ als aan het woord ‘en’, terwijl wij logischerwijs bij het woord ‘gratis’ sneller spam zouden verwachten dan bij het woord ‘en’.
Vervolgens laten wij het algoritme een simpele som maken over alle woorden in ons woordenboek, voor het gemak genomen als 20.000:
Z = g₁w₁ + g₂w₂ + … + g₂₀₀₀₀w₂₀₀₀₀ + b
Hier zien we een eindwaarde Z voor een e-mail, die bestaat uit het gewicht gᵢ voor een specifiek woord wᵢ dat in ons voorbeeld begint op 1 voor ieder woord. Dat gewicht vermenigvuldigen we met 1 als het woord voorkomt in de e-mail of 0 als het woord niet voorkomt. Dan tellen we nog een bias b bij de eindwaarde op. De bias kan de score verschuiven. Als er geen woorden bijdragen en de bias 0 is, is de kans op spam na de volgende stap 50%.
Nu berekenen we voor iedere e-mail de kans dat het spam is door een functie te gebruiken zoals:
P = 1 / (1 + e⁻ᶻ)
Met een functie als deze geldt: hoe hoger de Z-waarde, hoe groter de kans dat de e-mail spam is.
Aangezien we zijn begonnen met een waarde van 1 voor ieder woord, wordt er eigenlijk maar gegokt of een e-mail spam is of niet. Onze AI maakt ontzettend veel fouten. Wij weten echter wel welke e-mails spam zijn en welke niet, en geven dat ook mee in onze training-data. Iedere keer dat deze fouten worden gemaakt, kijkt het algoritme naar de waarden die bij ieder woord passen en gaat het kleine veranderingen maken. Het woord ‘gratis’ was gebruikt in een e-mail waar het algoritme besloot dat het geen spam was terwijl wij hebben meegegeven dat het wel een spam-e-mail was? Dan kan het gewicht voor het woord ‘gratis’ bijvoorbeeld worden verhoogd, zodat het zwaarder meeweegt als spam. In een andere e-mail wordt het woord ‘rapportage’ gebruikt waar de AI spam toekende terwijl het geen spam was? Dan kan ‘rapportage’ bijvoorbeeld een lager gewicht krijgen.
Een model wordt niet in één keer goed. Tijdens het trainen verwerkt het de training-data meerdere keren en past het zijn instellingen aan om betere voorspellingen te doen. Zo’n volledige ronde langs alle training-data heeft een speciale naam.
Iedere ronde waarbij je alle training-data een enkele keer door je algoritme haalt, noemt men een epoch. In tegenstelling tot wat men misschien zou verwachten, is het niet beter om je model zo lang mogelijk te laten trainen. Als je zelf een spam filter maakt zal je betere resultaten krijgen met 50 epochs dan met 10000 epochs. De reden daarvoor is overfitting.
Deze kleine mutaties van de waarden zijn niet per se positief. Soms verandert het model de verkeerde kant op en moet het in de volgende ronde weer bijgesteld worden. In tegenstelling tot wat men zou verwachten, wil je niet te veel epochs toepassen. Wanneer je te vaak je algoritme traint op je training-data, wordt het heel goed in het verwerken van die training-data. Dat kan tot gevolg hebben dat het slecht wordt in het herkennen van nieuwe data die niet in je training-data zat. Dat heet overfitting.
In het voorbeeld van kattenherkenning zou het kunnen dat na 100 epochs een oranje kat die een pootje mist niet wordt herkend als kat, omdat je training-data maar een paar katten met een missend pootje had en geen daarvan oranje was. Na 10 epochs had precies hetzelfde algoritme misschien wel de kat herkend, omdat het een algemeen katvormig object in de foto was met een acceptabele kleur.
In het trainen van een algoritme is het gebruikelijk om je training-data te splitsen in een train-, validatie- en testgedeelte, bijvoorbeeld in een 80%, 15%, 5%-verdeling. We trainen ons model dan op de 80% training-data. De validatie-data gebruiken we tijdens het ontwikkelen van het model om te kijken of keuzes, zoals het aantal epochs, goed werken. Na iedere epoch testen wij ons model op de validatie-data, om te zien hoe goed deze nieuwe versie van het model is met data die het model nog nooit heeft gezien. Het model verandert niet de parameters op basis van de validatie-data dus wordt deze data gezien als ‘nieuwe’ data. Nadat ons model is getraind doen we een laatste test op de 5% test-data om te zien of we tevreden zijn met het resultaat. Die test-data is dus niet gebruikt om het model te trainen. De reden waarom we die test-data nog gebruiken is omdat de resultaten op de validatie data vaak invloed hebben om ons model: We kiezen de parameters bij het epoch die het beste werkte op de validatie-data. Daarna testen we dus nog een keer op de test-data.
Het snappen hoe je algoritme werkt is natuurlijk voordelig in het ontwikkelen van een AI. Begrijpen waar je AI fouten kan maken, hoe goed je training-data is, waar er nog gaten in zijn, waar je AI niet goed in is, wordt allemaal makkelijker als je precies weet hoe de stappen in elkaar zitten. Maar een perfect begrip van alle wiskunde is niet noodzakelijk.
Als jij een toepasselijk algoritme kiest en dat goed kan coderen, kom je al een heel eind. Zelfs bij die stappen zijn er genoeg hulpmiddelen tegenwoordig. Het verzamelen van goede test-data, het uitvoeren van je algoritmen met een juiste hoeveelheid epochs en goed beredeneren waar je training-data/algoritme tekortschiet, zal snel leiden tot een goed resultaat. Het is niet voor iedereen nodig om alle algoritmen te kennen of zelfs nieuwe algoritmen te ontwikkelen.
Dus als jij twijfelt over het ontwikkelen van je eigen AI en vreest dat het te lastig is, wees dan niet bang. Veel van deze algoritmen zijn al ontwikkeld. Je moet slechts de stap zetten die altijd het moeilijkst is: de eerste stap.
