Werkplaats / De werkplaats
In jouw eigen tempo
← Neurale netwerken
MODULE 01 · LES 02

Maak fouten meetbaar

Bouw een verliesfunctie en zet zelf de eerste stappen van gradient descent.

60 min3 checkpoints
DIT GA JE ONTDEKKEN
  • Je berekent de gemiddelde kwadratische fout van voorspellingen.
  • Je controleert een afgeleide numeriek en past één gradient-descentstap toe.

Je neuron geeft een score, maar welke gewichten maken die score bruikbaar? Daarvoor moet je zijn uitkomsten eerst met gewenste antwoorden kunnen vergelijken. Een verliesfunctie (loss function) vat fouten samen in een getal dat je probeert te verkleinen.

Lager verlies betekent beter volgens die gekozen maat. Of het model ook geschikt is voor nieuwe planten, onderzoek je met onafhankelijke gegevens. Hier houden we de voorbeelden klein zodat je de berekening én één verbeterstap zelf kunt controleren.

1. Maak verschillen positief zonder hun grootte te vergeten

Neem voorspellingen [1,3] en doelen [2,1]. De verschillen voorspelling min doel zijn −1 en 2. Kwadrateren geeft 1 en 4; middelen geeft 2.5.

De gemiddelde kwadratische fout (mean squared error, MSE) doet dit voor alle paren. Het kwadraat zorgt dat een fout met dubbele grootte viermaal meetelt. Positieve en negatieve fouten kunnen elkaar zo niet wegstrepen.

MSE=1N∑(pi−yi)2

N telt de voorbeelden, p is een voorspelling, y het bijbehorende doel en i hun positie. Koppel dus dezelfde indices voordat je middelt.

voorspellingen = [1, 3]
doelen = [2, 1]
totaal = 0
for i in range(len(doelen)):
    fout = voorspellingen[i] - doelen[i]
    totaal = totaal + fout ** 2
print(totaal / len(doelen))  # 2.5

Maak mse(voorspellingen,doelen) voor niet-lege, even lange lijsten van eindige getallen. Gebruik alle voorbeelden, ook wanneer er meer dan twee zijn. De maat heeft de gekwadrateerde eenheid van het doel; haar grootte moet je binnen de toepassing beoordelen.

01
CHECKPOINTMeet de fout

2. Gebruik de afgeleide als lokale richtingaanwijzer

Om de verbeterstap te begrijpen, bekijken we één gewicht en een vast verlieslandschap: L(w) = (w−3)². Het minimum ligt bij w = 3. Links daarvan daalt het verlies wanneer w groeit; rechts daarvan moet w juist kleiner worden.

Uit de afleidingsregels volgt L′(w) = 2(w−3). Bij w = 1 is de helling −4, bij w = 5 is zij 4. De afgeleide beschrijft de lokale verandering, niet een kant-en-klare nieuwe parameter.

L(w)=(w−3)2L′(w)=2(w−3)

Controleer de formule ook numeriek. Een centraal verschil vergelijkt het verlies een klein stukje rechts en links van hetzelfde punt. Deel dat verschil door de totale afstand 2h.

def L(w):
    return (w - 3) ** 2

w = 1
h = 0.001
numeriek = (L(w+h) - L(w-h)) / (2*h)
formule = 2 * (w - 3)
print(round(numeriek, 6), formule)
# -4.0 -4

h is de kleine verplaatsing; afronding kan een klein verschil met de formule geven. Een extreem kleine h is op een computer niet vanzelf beter. Maak helling(w) voor deze parabool en gebruik het voorbeeld om je eigen uitkomst te controleren.

02
CHECKPOINTVind de helling

3. Ga tegen de helling in

Gradient descent trekt een deel van de helling van het gewicht af. De leersnelheid (learning rate) eta bepaalt hoe groot dat deel is. Een negatieve helling wordt daardoor een positieve verplaatsing.

wnieuw=w−ηL′(w)

Bij w = 0 is de helling −6. Met eta = 0.1 wordt de nieuwe w gelijk aan 0−0.1×(−6)=0.6. Het verlies daalt van 9 naar (0.6−3)² = 5.76.

w = 0.0
eta = 0.1
nieuw = w - eta * 2 * (w - 3)
print(round(nieuw, 4))  # 0.6
print(round(L(w), 4), round(L(nieuw), 4))
# 9.0 5.76

Maak stap(w,leersnelheid) met de helling bij de oude w. Veelgemaakte fout: alleen het minteken van de helling volgen en haar grootte vergeten. Dan voer je een andere update uit.

EEN STAP RICHTING BEGRIPZoek het laagste punt

Volg de helling van L(w) = (w − 3)².

020406080verliesw-6-3036minimum
Gewicht -3.000Verlies 36.000Stappen 0

Het diagram begint bij w = −3, dus niet bij nul uit ons handvoorbeeld. Zet één stap met de standaardleersnelheid en controleer de nieuwe plaats en het verlies. Reset daarna, kies eta = 1.1 en verklaar de grotere fout; een punt kan buiten het getekende bereik komen.

4. Een grotere stap kan voorbij het minimum schieten

Vanaf nul geven eta = 0.1 en eta = 0.9 respectievelijk w = 0.6 en w = 5.4: tegenovergestelde kanten van het minimum, met hetzelfde verlies. Eta = 1.1 gaat nog verder en verhoogt het verlies tot 12.96.

for eta in [0.1, 0.9, 1.1]:
    nieuw = 0 - eta * 2 * (0 - 3)
    gewicht = round(nieuw, 4)
    fout = round(L(nieuw), 4)
    print(gewicht, fout)
# 0.6 5.76
# 5.4 5.76
# 6.6 12.96

Voor deze specifieke parabool naderen vaste stappen het minimum bij 0 < eta < 1. Bij eta = 1 blijft de afstand gelijk en wisselt de kant; grotere eta vergroot de afstand. Andere verliesfuncties hebben andere kromming en daardoor andere bruikbare stapgroottes.

03
CHECKPOINTZet een leerstap

Wat neem je mee?

  • MSE middelt alle gekwadrateerde fouten en voorkomt dat tekens elkaar wegstrepen.
  • De afgeleide geeft lokale richting en grootte; een centraal verschil helpt haar controleren.
  • Gradient descent gebruikt die helling met een passende leersnelheid.

Hierna leer je een gewicht én een bias samen en teken je het echte trainingsverloop.

Verder lezen & bronnen

Inhoud gecontroleerd op 2026-10-28.
DE VOLGENDE STAPTrain je eerste model
JOUW EXPERIMENT

Probeer het zelf

Python
main.py

Python start zodra jij code uitvoert.

UITVOER

Je uitvoer verschijnt hier.
Alles rekent in je eigen browser.

Jouw checkpoints0 / 3
01
Meet de fout

Bereken de MSE voor alle voorspellingen.

Een hint

Kwadrateer eerst, tel daarna op en deel door het aantal voorbeelden.

02
Vind de helling

Bereken de afgeleide van L(w) = (w - 3)².

Een hint

De afgeleide van u² is 2u; hier is u = w - 3.

03
Zet een leerstap

Verplaats w tegen de helling in met de opgegeven leersnelheid.

Een hint

Trek leersnelheid × helling(w) af van w.

Vastgelopen? Bekijk de voorbeeldoplossing
def mse(voorspellingen, doelen):
    totaal = 0
    for i in range(len(doelen)):
        fout = voorspellingen[i] - doelen[i]
        totaal = totaal + fout ** 2
    return totaal / len(doelen)


def helling(w):
    return 2 * (w - 3)


def stap(w, leersnelheid):
    return w - leersnelheid * helling(w)

Voer de code uit en verklaar voor jezelf waarom elke stap werkt.