Machine Learning Academy · Les

De vergelijking van een rechte: richtingscoëfficiënt, snijpunt en voorspellingen

U haalt de formule y=mx+b op, tekent een regressielijn op echte gegevens en begrijpt hoe het model invoer aan uitvoer koppelt.

Les 1 van 413 stappen

De vergelijking van een rechte: richtingscoëfficiënt, snijpunt en voorspellingen is een gratis Machine Learning Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Machine Learning Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Machine Learning Academy bevat in totaal 4 lessen.

Lineaire relaties in gegevens

Veel relaties uit de echte wereld zijn ongeveer lineair: naarmate het vloeroppervlak toeneemt, stijgt de huizenprijs evenredig; als de reclame-uitgaven stijgen, stijgt de verkoop. Lineaire regressie modelleert deze relaties door de rechte lijn te vinden die het beste bij de gegevens past.

Voordat je het algoritme behandelt, moet je het wiskundige object dat het probeert te vinden goed begrijpen: de vergelijking van een lijn. Elk lineair regressiemodel is uiteindelijk een lijn (in 2D) of een hypervlak (in hogere dimensies), en de twee parameters die dit bepalen — helling en snijpunt — hebben een betekenisvolle interpretatie voor het probleem dat je oplost.

De vergelijking y = mx + b

De vergelijking van een lijn in 2D is y = mx + b, waarbij:

  • y — de afhankelijke variabele (wat we willen voorspellen, bijvoorbeeld de huizenprijs)
  • x — de onafhankelijke variabele of feature (bijvoorbeeld het vloeroppervlak)
  • m — de helling: hoeveel y verandert bij elke toename van x met één eenheid
  • b — het snijpunt: de waarde van y wanneer x nul is

In de notatie van machine learning wordt dit vaak geschreven als ŷ = w₁x + w₀ of ŷ = θ₁x + θ₀, waarbij w of θ de gewichten (parameters) zijn die het model leert.

import numpy as np
import matplotlib.pyplot as plt

# Define a line: y = 2x + 5
m = 2.0   # slope
b = 5.0   # intercept

x = np.linspace(0, 10, 100)
y = m * x + b  # vectorised — computes all 100 points at once

plt.plot(x, y, color='blue', linewidth=2)
plt.xlabel('x (square footage / 100)')
plt.ylabel('y (price in $1000s)')
plt.title('Line: y = 2x + 5')
plt.grid(True, alpha=0.3)
plt.show()

De helling interpreteren

De helling m geeft de veranderingssnelheid aan: bij elke toename van x met één eenheid verandert y met m eenheden. Het teken is belangrijk: een positieve helling betekent dat x en y samen bewegen (positieve correlatie), terwijl een negatieve helling betekent dat ze in tegengestelde richtingen bewegen.

In een huizenprijsmodel waarin x het vloeroppervlak is en y de prijs in dollars, betekent een helling van 150 dat elke extra vierkante voet 150 dollar toevoegt aan de voorspelde prijs. Deze interpreteerbaarheid is een van de grootste sterke punten van lineaire regressie: je kunt precies uitleggen wat de voorspelling bepaalt.

import numpy as np

# Example: house price model
# y = 150 * sqft + 50000

def predict_price(sqft, slope=150, intercept=50000):
    return slope * sqft + intercept

print('Price for 1000 sqft:', predict_price(1000))  # $200,000
print('Price for 1500 sqft:', predict_price(1500))  # $275,000
print('Price for 2000 sqft:', predict_price(2000))  # $350,000

# Each 500 sqft increase adds:
delta = predict_price(1500) - predict_price(1000)
print(f'Adding 500 sqft increases price by: ${delta:,}')

Het snijpunt interpreteren

Het snijpunt b is de waarde van y wanneer x gelijk is aan nul. Het verankert de lijn op een specifieke y-waarde op de verticale as. Bij het interpreteren van het snijpunt is voorzichtigheid nodig: soms heeft het een fysieke betekenis en soms niet.

In het voorbeeld van de huizenprijs zou een snijpunt van 50.000 dollar betekenen dat een huis met nul vierkante voet 50.000 dollar kost, wat fysiek betekenisloos is. Je kunt het snijpunt het beste zien als een kalibratieconstante die de hele lijn omhoog of omlaag verschuift zodat die bij de gegevens past, in plaats van als een grootheid met in elke context een directe betekenis in de echte wereld.

import numpy as np
import matplotlib.pyplot as plt

x = np.array([500, 800, 1000, 1200, 1500, 2000])
y = np.array([125000, 170000, 200000, 230000, 275000, 350000])

# The intercept shifts the line vertically
for intercept in [0, 50000, 100000]:
    y_line = 150 * np.linspace(0, 2000, 100) + intercept
    plt.plot(np.linspace(0, 2000, 100), y_line,
             label=f'b = {intercept:,}')

plt.scatter(x, y, color='black', zorder=5, label='Data')
plt.xlabel('Square Footage')
plt.ylabel('Price ($)')
plt.legend()
plt.show()

Gegevens en een regressielijn tekenen

Voordat je een model aanpast, moet je je gegevens altijd plotten om te controleren of er daadwerkelijk een lineair verband bestaat. Als het spreidingsdiagram een gebogen of niet-lineair patroon laat zien, is een lineair model de verkeerde keuze. Het visualiseren van de aangepaste lijn boven op het spreidingsdiagram is de eerste validatiestap na het trainen.

De regplot() van Seaborn berekent en plot de regressielijn met een betrouwbaarheidsinterval in één aanroep, waardoor dit tijdens verkennende data-analyse een snelle plausibiliteitscontrole is.

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

# Simulate house price data
np.random.seed(42)
sqft = np.random.uniform(500, 3000, 100)
price = 150 * sqft + 50000 + np.random.normal(0, 20000, 100)

# Quick regression plot with seaborn
plt.figure(figsize=(8, 5))
sns.regplot(x=sqft, y=price, scatter_kws={'alpha': 0.5},
            line_kws={'color': 'red', 'linewidth': 2})
plt.xlabel('Square Footage')
plt.ylabel('Price ($)')
plt.title('House Price vs Square Footage')
plt.show()

Voorspellingen doen met een lijn

Zodra je een lijn hebt (helling m en intercept b), is een voorspelling voor een nieuwe invoer x gewoon rekenwerk: vul x in de vergelijking in en bereken y. Dit heet inferentie of voorspellen.

Het belangrijkste inzicht is dat het model de werkelijke uitvoer voor een nieuwe invoer niet kent — het schat deze op basis van de patronen die het uit de trainingsgegevens heeft geleerd. De kwaliteit van deze voorspellingen hangt volledig af van hoe goed de trainingsgegevens de nieuwe invoer vertegenwoordigen en hoe lineair het werkelijke verband is.

import numpy as np

# Learned parameters (from training, simplified here)
slope = 150.0
intercept = 52000.0

def predict(x_new, m, b):
    return m * x_new + b

# Single prediction
new_house_sqft = 1800
predicted_price = predict(new_house_sqft, slope, intercept)
print(f'Predicted price for {new_house_sqft} sqft: ${predicted_price:,.0f}')

# Batch prediction (multiple houses)
houses = np.array([1000, 1200, 1500, 2000, 2500])
prices = predict(houses, slope, intercept)
for sqft, price in zip(houses, prices):
    print(f'{sqft} sqft -> ${price:,.0f}')

Residuen: het verschil tussen voorspelling en werkelijkheid

Geen enkele echte gegevensverzameling valt perfect op een lijn. Het residu voor elk gegevenspunt is het verschil tussen de werkelijke waarde en de door het model voorspelde waarde: residual = y_actual - y_predicted. Een positief residu betekent dat het model te laag heeft voorspeld; een negatief residu betekent dat het te hoog heeft voorspeld.

Residuen zijn het ruwe materiaal voor het evalueren en verbeteren van een lineair model. Als residuen een systematisch patroon vertonen (bijvoorbeeld altijd positief zijn voor grote x-waarden), wijst dat erop dat het werkelijke verband niet-lineair is en dat een complexer model nodig is.

import numpy as np

y_actual = np.array([200000, 250000, 310000, 180000, 420000])

# Model predictions
m, b = 150.0, 52000.0
x = np.array([1000, 1300, 1700, 850, 2400])
y_pred = m * x + b

residuals = y_actual - y_pred

for i, (actual, pred, res) in enumerate(zip(y_actual, y_pred, residuals)):
    print(f'House {i+1}: Actual=${actual:,}  Predicted=${pred:,.0f}  Residual=${res:,.0f}')

print(f'\nMean residual: ${residuals.mean():,.0f}')
print(f'Std of residuals: ${residuals.std():,.0f}')

Negatieve helling: inverse verbanden

Een negatieve helling modelleert een inverse relatie: als x toeneemt, neemt y af. Hoe ouder een auto bijvoorbeeld is, hoe lager de doorverkoopwaarde. Of hoe meer concurrenten een bedrijf heeft, hoe kleiner het marktaandeel.

Lineaire regressie verwerkt negatieve hellingen vanzelf — het algoritme vindt de helling (positief, negatief of nul) die het beste bij de trainingsgegevens past. Een helling van precies nul betekent dat x geen informatie over y bevat en dat de beste voorspelling voor elke invoer simpelweg het gemiddelde van y is.

import numpy as np
import matplotlib.pyplot as plt

# Car age vs resale value (inverse relationship)
np.random.seed(0)
age = np.random.uniform(1, 15, 50)
value = -1500 * age + 25000 + np.random.normal(0, 2000, 50)
value = np.clip(value, 1000, 30000)  # clip to realistic range

plt.scatter(age, value, alpha=0.6)
plt.plot([1, 15], [-1500*1+25000, -1500*15+25000],
         color='red', linewidth=2, label='y = -1500x + 25000')
plt.xlabel('Car Age (years)')
plt.ylabel('Resale Value ($)')
plt.title('Inverse Relationship: Age vs Resale Value')
plt.legend()
plt.show()

Van lijn naar hypervlak

In werkelijkheid hebben we bijna altijd meerdere invoerkenmerken, niet slechts één. Wanneer je de lijnvergelijking uitbreidt naar meerdere kenmerken, wordt het model een hypervlak in een ruimte met veel dimensies:

ŷ = w₁x₁ + w₂x₂ + ... + wₙxₙ + b

Elke wᵢ is een afzonderlijke coëfficiënt (gewicht) voor het bijbehorende kenmerk xᵢ. De voorspelling is nog steeds gewoon een lineaire combinatie van invoerwaarden plus een bias. Deze uitbreiding — van een lijn naar een hypervlak — is het enige wat verandert wanneer je van enkelvoudige naar meervoudige lineaire regressie gaat.

import numpy as np

# Multiple linear regression prediction
# y = w1*sqft + w2*bedrooms + w3*age + b

def predict_multi(features, weights, bias):
    # features shape: (n_features,) or (n_samples, n_features)
    return np.dot(features, weights) + bias

weights = np.array([150.0, 5000.0, -200.0])  # sqft, bedrooms, age
bias = 30000.0

# One house: 1500 sqft, 3 bedrooms, 10 years old
house = np.array([1500, 3, 10])
price = predict_multi(house, weights, bias)
print(f'Predicted price: ${price:,.0f}')
# = 150*1500 + 5000*3 + (-200)*10 + 30000 = $282,000

Correlatie versus causaliteit in lineaire modellen

Lineaire regressie vindt statistische correlaties, geen causale verbanden. Een grote helling tussen de verkoop van ijs en het aantal verdrinkingsgevallen betekent niet dat ijs verdrinking veroorzaakt — beide worden veroorzaakt door warm weer. De helling van een model vertelt je iets over het verband in de trainingsgegevens, niet over het onderliggende causale mechanisme.

Dit onderscheid is uiterst belangrijk wanneer je ML-modellen inzet voor besluitvorming. Een model dat wanbetalingen op leningen voorspelt, kan ontdekken dat postcode een sterke voorspeller is — maar het gebruik van postcode als beslisfactor kan rassendiscriminatie vastleggen in plaats van echt kredietrisico. Onderzoek altijd waarom een kenmerk zoveel voorspellende kracht heeft.

Instellen voor scikit-learn

Nu je begrijpt wat een lijn is en wat de parameters ervan betekenen, ben je klaar om scikit-learn te gebruiken om automatisch de optimale helling en intercept uit gegevens te leren. Het algoritme minimaliseert de totale voorspellingsfout over alle trainingsvoorbeelden en vindt de best passende lijn zonder dat je m en b handmatig hoeft af te stellen.

In de volgende les leer je precies hoe deze optimalisatie werkt — wat 'beste passing' wiskundig betekent en hoe de kostenfunctie Mean Squared Error het aanpassen van een lijn omzet in een probleem waarbij een wiskundige uitdrukking moet worden geminimaliseerd.

from sklearn.linear_model import LinearRegression
import numpy as np

# scikit-learn finds the optimal slope and intercept automatically
np.random.seed(42)
sqft = np.random.uniform(500, 3000, 100).reshape(-1, 1)
price = 150 * sqft.ravel() + 50000 + np.random.normal(0, 20000, 100)

model = LinearRegression()
model.fit(sqft, price)

print(f'Learned slope (coef_):     {model.coef_[0]:.1f}')
print(f'Learned intercept (b):     {model.intercept_:.1f}')
print(f'Prediction for 1500 sqft: ${model.predict([[1500]])[0]:,.0f}')

Korte controle

Test je begrip van de concepten uit deze les over machinelearning met Python.

Samenvatting van de les

In deze les heb je geleerd: de vergelijking y=mx+b definieert een lijn met helling m (veranderingssnelheid) en intercept b (y-waarde bij x=0), residuen meten het verschil tussen werkelijke en voorspelde waarden en meervoudige lineaire regressie breidt de lijn uit naar een hypervlak met één gewicht per kenmerk. Hierna verkennen we kostenfuncties en kleinste kwadraten — het wiskundige raamwerk dat definieert wat 'beste passing' betekent en hoe het algoritme de optimale parameters vindt.

Gratis beginnen

Leer Python met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen
30
Lessen
120

Veelgestelde vragen

Is de les “De vergelijking van een rechte: richtingscoëfficiënt, snijpunt en voorspellingen” gratis?

Ja — de volledige tekst van “De vergelijking van een rechte: richtingscoëfficiënt, snijpunt en voorspellingen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Machine Learning Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Machine Learning Academy bevat in totaal 4 lessen.

Wat leer ik in “De vergelijking van een rechte: richtingscoëfficiënt, snijpunt en voorspellingen”?

U haalt de formule y=mx+b op, tekent een regressielijn op echte gegevens en begrijpt hoe het model invoer aan uitvoer koppelt. Je oefent met Machine Learning Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Machine Learning Academy te beginnen?

Ervaring vooraf is niet nodig. Machine Learning Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “De vergelijking van een rechte: richtingscoëfficiënt, snijpunt en voorspellingen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Machine Learning Academy?

Ja. Elke les over Machine Learning Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

  1. De vergelijking van een rechte: richtingscoëfficiënt, snijpunt en voorspellingen
  2. Kostenfuncties en kleinste kwadraten
  3. Lineaire regressie trainen met scikit-learn
  4. Meervoudige lineaire regressie en het belang van features
← Terug naar Machine Learning Academy