Wat is Reinforcement Learning? Uitleg met voorbeeld in Python

Reinforcement learning klinkt voor veel mensen als iets ingewikkelds of theoretisch. Toch is het onderliggende idee verrassend simpel. Het lijkt sterk op hoe mensen (en dieren) leren: door iets te proberen, feedback te krijgen, en daarmee het gedrag aan te passen.

In deze blog nemen we je stap voor stap mee in wat reinforcement learning is, hoe het verschilt van andere vormen van machine learning, en bouwen we een klein voorbeeld in programmeertaal Python dat het principe concreet maakt.

Wat is reinforcement learning en wanneer gebruik je het?

Bij veel machine-learning-toepassingen werk je met historische data en vaste antwoorden. Maar niet elk probleem werkt zo.

Denk aan situaties waarin:

• er geen vaste juiste keuze is, zoals het dagelijks verdelen van marketingbudget over kanalen;
• beslissingen doorwerken op de lange termijn, bijvoorbeeld bij voorraadbeheer;
• je pas later ziet of een keuze goed was, zoals bij betalingsherinneringen.

In dit soort gevallen schiet klassiek machine learning vaak tekort. Reinforcement learning biedt hier een alternatief.

Reinforcement learning draait om leren door te doen. Een model neemt beslissingen, krijgt feedback in de vorm van beloning of straf, en past zijn gedrag stap voor stap aan op basis van ervaring, in plaats van alleen historische data.

De vier kernbegrippen

Hoewel reinforcement learning in de praktijk complex kan worden, bestaat het concept altijd uit 4 vaste onderdelen.

1. Er is een agent: het beslissende onderdeel: datgene wat elke keer opnieuw een keuze moet maken. In een marketingvoorbeeld is de agent bijvoorbeeld het model dat elke dag bepaalt welke marketingcampagne live gaat.
2. Er is een omgeving: de wereld waarin de agent zich bevindt. In een marketingvoorbeeld is de omgeving bijvoorbeeld het advertentieplatform, de doelgroep die reageert op de campagne en externe factoren zoals seizoen of concurrentie.
3. De agent kan acties uitvoeren. Zoals een bepaalde marketingcampagne live laten gaan.
4. En na elke actie krijgt de agent een beloning (of juist niet). Wat bijvoorbeeld het effect in aantal verkopen is vanuit de marketingcampagne.

Het doel van de agent is niet om één keer een hoge beloning te krijgen, maar om over tijd zo goed mogelijk te presteren. Dat maakt reinforcement learning fundamenteel anders dan veel andere machine learning technieken.

Reinforcement learning in de praktijk

Reinforcement learning kom je vooral tegen in situaties waarin beslissingen herhaaldelijk worden genomen, het effect niet direct zichtbaar is en vaste regels tekortschieten. Het systeem leert niet van eenmalige analyses, maar van ervaring in de praktijk.

Typische toepassingen zijn bijvoorbeeld:

• Voorraad & logistiek: bepalen wanneer en hoeveel bepaalde artikelen worden bijbesteld, rekening houdend met servicegraad en kosten.
• Planning & capaciteit: beslissen over inzet van mensen of middelen onder wisselende omstandigheden.
• Marketing & sales: kiezen welke campagne, aanbieding of bericht wordt ingezet op basis van gerealiseerde leads of omzet.
• Pricing: prijzen dynamisch aanpassen op basis van vraag en concurrentie.

In al deze gevallen is er geen vast juiste keuze. Wat telt, is het leren van feedback en het gedrag gaandeweg verbeteren. Reinforcement learning wordt daarom vaak klein en gecontroleerd ingezet, met duidelijke grenzen. Zo groeit het uit van een experiment naar een praktisch hulpmiddel voor betere beslissingen over tijd.

De verschillen tussen reinforcement-, supervised-, en unsupervised machine learning

Het grote verschil zit niet zozeer in de techniek, maar in het leerproces.

• Bij supervised learning leert een model van voorbeelden uit het verleden.
• Bij unsupervised learning leert een model structuur herkennen in data.
• Bij reinforcement learning leert een model (agent) door interactie in de praktijk.

Dat betekent ook dat de agent soms "domme" dingen moet doen om te ontdekken wat werkt. Dat is geen fout, maar een noodzakelijk onderdeel van het leerproces. Net zoals een bedrijf soms bewust een minder zekere marketingcampagne test, moet een agent af en toe een ogenschijnlijk "domme" keuze maken om te ontdekken of er betere opties bestaan.

Een bekende spanning hierbij is die tussen uitproberen wat nog onbekend is en vasthouden aan wat zich al bewezen heeft:

• Moet je iets nieuws proberen?
• Of moet je blijven doen wat tot nu toe het beste lijkt te werken?

Elke reinforcement learning-oplossing balanceert tussen deze twee.

Reinforcement learning voorbeeld met programmeertaal Python

Stel je een marketingagent voor die elke dag moet beslissen welke campagne live gaat. De agent kan steeds kiezen tussen twee opties:

1. Een bewezen campagne die meestal een paar leads oplevert, maar zelden uitschieters kent.
2. Een nieuwe, creatieve campagne die soms veel leads oplevert, maar vaak ook niets doet.

Welke keuze op de lange termijn het beste is, weet de agent vooraf niet. Het enige wat de agent kan doen, is keuzes maken, het resultaat observeren en daarvan leren. Campagnes die vaker belonen worden geleidelijk aantrekkelijker, campagnes die weinig opleveren worden minder aantrekkelijk.

In de volgende stappen vertalen we dit idee naar een concreet voorbeeld in programmeertaal Python. Daarbij gebruiken we package PyTorch.

Stap 1: maken van een omgeving voor de agent

We beginnen met het definiëren van een omgeving. Dit is het deel van het probleem dat de agent niet kan controleren, maar waar het wel feedback van krijgt. In dit voorbeeld stelt de omgeving het resultaat van een marketingcampagne voor.

Voor leesbaarheid noemen we de omgeving hier daily_leads. Onderstaande functie daily_leads() krijgt als input de gekozen actie (welke campagne is ingezet) en geeft als output een beloning: het aantal leads dat die dag is gegenereerd.

import random

def daily_leads(action):
    if action == 0:  # veilige actie
        return random.choice([1, 1, 1, 1, 0])
    else:            # risicovolle actie
        return random.choice([5, 0, 0, 0, 0])

• Actie 0 staat voor een bewezen campagne die meestal één lead oplevert, maar soms niets.
• Actie 1 staat voor een nieuwe campagne die af en toe veel leads oplevert, maar vaak geen.

Door gebruik te maken van random.choice() simuleren we onzekerheid: dezelfde actie kan op verschillende dagen een andere uitkomst hebben. Precies dat maakt dit een geschikt voorbeeld voor reinforcement learning.

Stap 2: wat de agent onthoudt

De agent begint zonder kennis. Hij houdt slechts één ding bij: een voorkeur voor de nieuwe campagne.

Die voorkeur modelleren we in dit voorbeeld met één getal (p). Hoe hoger getal p, hoe groter de kans dat de agent voor de nieuwe campagne kiest. Let op: dit is sterk versimpeld voorbeeld, de praktijk is bijna altijd complexer.

import torch

# Eén parameter die kan leren.
p = torch.tensor(0.0, requires_grad=True)
learning_rate = 0.05

Dit is bewust extreem simpel gehouden: alleen één parameter die kan leren.

Stap 3: een keuze maken (verkennen versus benutten)

Elke dag kiest de agent welke campagne hij inzet. Die keuze is probabilistisch: soms kiest hij voor zekerheid, soms probeert hij iets nieuws.

prob_new_campaign = torch.sigmoid(p)

• Als prob_new_campaign hoog is, kiest de agent vaker voor de nieuwe campagne.
• Als prob_new_campaign laag is, blijft de agent bij de bewezen campagne.

Zo blijft de agent automatisch ruimte houden om te verkennen, zelfs als één optie beter lijkt.

Stap 4: leren van de beloning

Na het inzetten van een campagne ziet de agent hoeveel leads dat opleverde. Die beloning gebruikt hij om zijn voorkeur aan te passen.

if random.random() < prob_new_campaign.item():
    action = 1
    log_prob = torch.log(prob_new_campaign)
else:
    action = 0
    log_prob = torch.log(1 - prob_new_campaign)

reward = daily_leads(action)

loss = -log_prob * reward
loss.backward()

with torch.no_grad():
    p -= learning_rate * p.grad
    p.grad.zero_()

Wat gebeurt hier conceptueel?

• Keuzes voor campagnes die veel leads opleveren, worden waarschijnlijker.
• Keuzes die weinig opleveren, worden minder aantrekkelijk.
• Dit gebeurt automatisch, zonder dat het met expliciete regels is vastgelegd.

De agent leert dus door herhaling welk gedrag gemiddeld het beste werkt.

Wat gebeurt hier technisch?

• De agent kiest een campagne op basis van een kans (prob_new_campaign). We onthouden daarbij de log-kans (log_prob) van de gemaakte keuze. Die log-kans gebruiken we om te bepalen hoe sterk de voorkeur voor die keuze moet worden aangepast.
• Na het uitvoeren van de actie zien we de beloning (reward), bijvoorbeeld het aantal leads. Die beloning bepaalt of de gemaakte keuze moet worden aangemoedigd of juist afgeremd.
• De loss combineert beide: keuzes die veel beloning opleveren, worden waarschijnlijker; keuzes die weinig opleveren, minder.
• Met backward() berekenen we hoe de parameter p aangepast moet worden, en met een eenvoudige update-stap passen we die parameter daadwerkelijk aan.

Stap 5: alles samen, leren over meerdere dagen

Zetten we alle eerdere code in een loop, dan ontstaat een agent met een leerproces over tijd.

def daily_leads(campaign):
    if campaign == 0:  # bewezen campagne
        return random.choice([1, 1, 1, 1, 0])
    else:              # nieuwe campagne
        return random.choice([5, 0, 0, 0, 0])

# Eén parameter die kan leren.
p = torch.tensor(0.0, requires_grad=True)
learning_rate = 0.05

# Loop voor simulatie van 2000 dagen
for day in range(2000):
    # Kans om vandaag de nieuwe campagne te draaien
    prob_new = torch.sigmoid(p)

    # Kies (sample) op basis van die kans
    if random.random() < prob_new.item():
        campaign = 1
        log_prob = torch.log(prob_new)
    else:
        campaign = 0
        log_prob = torch.log(1 - prob_new)

    # Beloning: aantal leads vandaag
    reward = daily_leads(campaign)

    # Verhoog de kans op keuzes die beloning geven
    loss = -log_prob * reward

    loss.backward()
    with torch.no_grad():
        p -= learning_rate * p.grad
        p.grad.zero_()

    # Toon tussentijds resultaat
    if (day + 1) % 200 == 0:
        print(f"dag {day+1:4d} | P(nieuwe campagne)={prob_new.item():.3f}")

print("\nEindkans om nieuwe campagne te kiezen:", torch.sigmoid(p).item())

Na voldoende iteraties zie je dat de kans verschuift richting de campagne die gemiddeld de meeste waarde oplevert.

Output:
dag 200 | P(nieuwe campagne)=0.4695
dag 400 | P(nieuwe campagne)=0.5979
dag 600 | P(nieuwe campagne)=0.7483
dag 800 | P(nieuwe campagne)=0.8193
dag 1000 | P(nieuwe campagne)=0.8875
dag 1200 | P(nieuwe campagne)=0.9235
dag 1400 | P(nieuwe campagne)=0.9301
dag 1600 | P(nieuwe campagne)=0.9219
dag 1800 | P(nieuwe campagne)=0.9415
dag 2000 | P(nieuwe campagne)=0.9528

Eindkans om de nieuwe campagne te kiezen: 0.9528

Dit laat zien dat het model leert op basis van gemiddelde opbrengst, niet op basis van incidentele pieken. De uitkomst kan per run verschillen, omdat er willekeurigheid in de beloningen zit.

Toelichting op dit voorbeeld

Dit voorbeeld is bewust relatief simpel. In echte reinforcement learning-toepassingen heb je vaak:

• Meerdere states (toestanden)
• (Variabele) lange termijn beloningen
• Complexere modelleringen met bijvoorbeeld neurale netwerken
• Uitgebreide simulaties of implementatie in echte systemen

Maar het kernidee (een agent die leert in een omgeving op basis van acties en beloningen) blijft hetzelfde.

Tot slot

Reinforcement learning is een methode om een computer te laten leren door te doen. Bij reinforcement learning leert een agent die acties onderneemt in een omgeving op basis van beloningen. In de praktijk kun je het vooral gebruiken wanneer beslissingen zich blijven herhalen, vaste regels niet goed werken en je bereid bent het systeem gecontroleerd te laten leren van feedback in de praktijk. Met een programmeertaal zoals Python kun je relatief eenvoudig aan de slag met machine learning en reinforcement learning.

Machine learning specialist worden?

Wil jij snel op stoom zijn met machine learning? Volg dan onze Data Science opleiding. In vier dagen nemen we je mee in de basis van Python en statistiek. Er is geen voorkennis vereist. Je leert zelfstandig machine learning modellen ontwikkelen en toepassen. Voor wie al ervaring heeft met programmeren in Python is het ook mogelijk om alleen de laatste twee dagen mee te doen; dit is onze machine learning training.

Download één van onze opleidingsbrochures voor meer informatie