Train je eerste model
Een volledig notebook: van vijf meetpunten naar een model dat zelf zijn gewicht en bias leert.
De opdracht, leerdoelen en voorkennis
- Je schrijft een complete trainingslus zonder machine-learningbibliotheek.
- Je controleert verlies, parameters en voorspellingen met tests en een grafiek.
Lees eerst: Een helling voor elk gewicht · Maak fouten meetbaar.
Je kunt een voorspelling berekenen en één gewicht verbeteren. Nu maak je de volledige lus: voorspellen, fouten meten, gradiënten berekenen en gewicht én bias aanpassen. Je tekent daarna de werkelijk berekende verlieswaarden en controleert ook een nieuwe voorspelling.
Dit model heeft één lineaire uitvoer zonder ReLU, zodat die ieder reëel getal mag zijn. De vijf meetpunten zijn bewust exact volgens een eenvoudige lijn gemaakt. Zo kun je de eerste update met de hand volgen voordat je honderden rondes uitvoert.
1. Begin met gegevens en een werkende voorspeller
Gebruik x = [0,0.25,0.5,0.75,1] en y = [1,1.5,2,2.5,3]. Iedere invoer heeft één doel. De regel is een gewicht w maal x plus bias b; de onbekende instellingen beginnen straks bij nul.
x = [0., .25, .5, .75, 1.]
y = [1., 1.5, 2., 2.5, 3.]
def voorspel(x, w, b):
return w * x + b
print(voorspel(0.5, 2, 1)) # 2.0
Maak ook verlies(w,b) als MSE over de vijf opgeslagen voorbeelden. Bij w = b = 0 zijn alle voorspellingen nul. De kwadratische fouten zijn 1,2.25,4,6.25,9: som 22.5 en gemiddelde 4.5.
def verlies(w, b):
totaal = 0
for i in range(len(x)):
p = voorspel(x[i], w, b)
fout = p - y[i]
totaal = totaal + fout ** 2
return totaal / len(x)
print(verlies(0, 0)) # 4.5
De notebookcellen delen variabelen: voer daarom eerst de gegevenscel uit en daarna de functies. Na een runtimeherstart begin je weer bij de eerste cel. Bewaar de voorbeelden intact tijdens training en controle.
012. Bereken beide gradiënten bij dezelfde instellingen
Je kent partiële afgeleiden uit de gradiëntenles. Voor één foutkwadraat geeft de kettingregel een factor twee maal de fout. De afgeleide van wx+b naar w is x; naar b is zij één.
e_i is voorspelling min doel bij voorbeeld i; N is vijf. Aan het begin zijn de fouten [−1,−1.5,−2,−2.5,−3]. Hun som is −10 en de som van fout maal x is −6.25: de gradiënten zijn dus −4 voor b en −2.5 voor w.
Met leersnelheid 0.2 worden de nieuwe instellingen w = 0−0.2×(−2.5)=0.5 en b = 0−0.2×(−4)=0.8. Hun MSE is 1.18375, al veel kleiner dan 4.5.
def gradienten(w, b):
sw, sb = 0, 0
for i in range(len(x)):
p = voorspel(x[i], w, b)
fout = p - y[i]
sw = sw + fout * x[i]
sb = sb + fout
return 2*sw/len(x), 2*sb/len(x)
dw, db = gradienten(0, 0)
w = 0 - 0.2 * dw
b = 0 - 0.2 * db
print(w, b) # 0.5 0.8
print(round(verlies(w, b), 6))
# 1.18375
Veelgemaakte fout: eerst w aanpassen en daarna pas de biasgradiënt opnieuw berekenen. Dan gebruik je twee verschillende punten in het verlieslandschap voor één gezamenlijke update. Bereken beide gradiënten vóór je een van de parameters wijzigt.
3. Herhaal en bewaar het echte verloop
Begin voor de volledige proef opnieuw met w = b = 0. Bewaar eerst het startverlies en voeg na iedere update het nieuwe verlies toe. Driehonderd updates leveren daarom 301 waarden, geen 300.
w, b = 0., 0.
leersnelheid = 0.2
geschiedenis = [verlies(w, b)]
for stap in range(300):
dw, db = gradienten(w, b)
w = w - leersnelheid * dw
b = b - leersnelheid * db
geschiedenis.append(verlies(w, b))
print(len(geschiedenis)) # 301
print(round(w, 4), round(b, 4))
# ongeveer 2.0 1.0
Gebruik je eigen berekeningen in de derde cel; de helpernaam gradienten is een mogelijkheid, geen verplicht functiecontract. Een eindparameter invullen zonder te leren zou geen trainingsverloop verklaren. Controleer daarom ook de beginwaarde, de eerste update en de tussenliggende verliezen.
4. Lees de grafiek en controleer een nieuwe voorspelling
Teken iedere opgeslagen verlieswaarde als één punt op een lijn. De horizontale positie is de trainingsstap en de verticale positie de MSE. Matplotlib laat zo zien wat de lus werkelijk heeft berekend.
import matplotlib.pyplot as plt
fig, ax = plt.subplots(figsize=(6, 3))
ax.plot(geschiedenis, color="#26765c")
ax.set_xlabel("Trainingsstap")
ax.set_ylabel("MSE")
ax.set_title("Zo leert jouw model")
fig.tight_layout()
subplots maakt een figuur en een assenstelsel; plot gebruikt bij één lijst automatisch posities 0 tot en met 300. De set-methoden benoemen de assen en titel; tight_layout geeft die ruimte. De notebook toont de figuur onder de cel.
Zoek de eerste snelle daling en vergelijk die met de tragere laatste stappen. Een steeds vlakker wordende curve kan betekenen dat de updates kleiner worden. Zij bewijst op zichzelf nog niet dat de voorspeller de juiste berekening maakt.
print(round(voorspel(1.5, w, b), 4))
# ongeveer 4.0
verbeterd = geschiedenis[-1] < 4.5
print(verbeterd)
# True
De nieuwe invoer 1.5 verwacht volgens de gemaakte lijn ongeveer 4. Dat controleert deze speelgoedproef, maar vormt geen onafhankelijke evaluatie op echte, ruisende gegevens. Gebruik daarvoor de afspraken uit de datatrack.
03Wat neem je mee?
- Voorspeller en verlies vormen samen een controleerbare trainingsopdracht.
- Beide gradiënten horen bij hetzelfde oude paar w,b.
- Echte verlieswaarden, de bijbehorende grafiek en een nieuwe voorspelling vullen elkaar aan.
Hierna combineer je meerdere neuronen tot lagen en laat je zulke tussenlagen samen leren.
Bronnen: Google ML Crash Course — gradient descent ↗ Matplotlib — pyplot ↗ · Gecontroleerd 2026-10-28.
1. Begin met voorbeelden
Gebruik de vijf gegeven x/y-paren. Elke invoer heeft precies één doel; laat deze voorbeelden tijdens training intact.
Bekijk voorbeeld
x = [0.0, 0.25, 0.5, 0.75, 1.0]
y = [1.0, 1.5, 2.0, 2.5, 3.0]
print('Voorbeelden:', list(zip(x, y)))2. Bouw je voorspeller
Maak voorspel(x,w,b) en verlies(w,b) als MSE over de opgeslagen voorbeelden. Nulinstellingen geven startverlies 4.5. Voer de gegevenscel eerst uit.
Bekijk voorbeeld
def voorspel(x, w, b):
return w * x + b
def verlies(w, b):
return sum((voorspel(xi, w, b) - yi) ** 2 for xi, yi in zip(x, y)) / len(x)
print('Startverlies:', verlies(0, 0))3. Laat het model leren
Begin met w = b = 0 en eta = 0.2. Bereken dw en db bij dezelfde oude instellingen vóór de update. Bewaar 301 echte verliezen: de start en 300 updates. Eerste update: w = 0.5, b = 0.8 en MSE = 1.18375.
Bekijk voorbeeld
w, b = 0.0, 0.0
leersnelheid = 0.2
geschiedenis = [verlies(w, b)]
for _ in range(300):
fouten = [voorspel(xi, w, b) - yi for xi, yi in zip(x, y)]
dw = 2 * sum(fout * xi for fout, xi in zip(fouten, x)) / len(x)
db = 2 * sum(fouten) / len(x)
w -= leersnelheid * dw
b -= leersnelheid * db
geschiedenis.append(verlies(w, b))
print('Gewicht:', round(w, 4), 'bias:', round(b, 4))4. Kijk wat er is geleerd
Teken de 301 werkelijke verliezen tegen hun stapnummer met asnamen en titel. Bekijk snelle begin- en tragere einddaling; controleer ook voorspel(1.5,w,b)≈4. Dit blijft een speelgoedproef.
Bekijk voorbeeld
import matplotlib.pyplot as plt fig, ax = plt.subplots(figsize=(6, 3)) ax.plot(geschiedenis, color='#26765c') ax.set(xlabel='Trainingsstap', ylabel='MSE', title='Zo leert jouw model') fig.tight_layout() # De grafiek verschijnt automatisch onder de cel.