Sklearn lineaire regressie: een complete gids met voorbeelden

Lineaire regressie is een fundamentele techniek in statistiek en machine learning waarmee je de relatie tussen variabelen kunt modelleren. Simpel gezegd stelt het ons in staat om een uitkomst te voorspellen op basis van één of meer beïnvloedende factoren. Het wordt veel toegepast bij vastgoedprijzen, verkoopprognoses, risicoanalyse en in veel andere domeinen.

In deze tutorial verkennen we lineaire regressie in scikit-learn: hoe het werkt, waarom het nuttig is en hoe je het implementeert met scikit-learn. Aan het einde kun je een lineair regressiemodel bouwen en evalueren om datagedreven voorspellingen te doen.

Spreidingsdiagram van huizenprijs versus aantal kamers

Lineaire regressie en machine learning

Naast de directe toepasbaarheid voor het bepalen van huizenprijzen speelt lineaire regressie een belangrijke rol in machine learning.

• Het is een basismodel om geavanceerdere technieken te begrijpen, zoals logistische regressie, neurale netwerken en support-vector-machines.
• Het is snel te trainen, ideaal voor snel prototypen.
• Het dient ook als baseline ter vergelijking. Als geavanceerdere modellen het niet significant beter doen, is de extra complexiteit mogelijk niet gerechtvaardigd.
• In tegenstelling tot sommige technieken (zoals deep learning) is het eenvoudig te interpreteren.
• Het kan helpen bij featureselectie door de nuttigste voorspellers te identificeren.

Ondanks de eenvoud blijft lineaire regressie onmisbaar in machine learning vanwege de efficiëntie, uitlegbaarheid en veelzijdigheid.

Lineaire regressie en de scikit-learn-bibliotheek

Met de scikit-learn-bibliotheek is lineaire regressie eenvoudig te implementeren. Deze bibliotheek heeft veel voordelen.

• Er is een consistente interface. De code om verschillende ML-algoritmen te implementeren is vergelijkbaar.
• De code is eenvoudig; complexe wiskunde en implementatiedetails worden afgeschermd. Om bijvoorbeeld een model op trainingsdata te fitten, volstaat de regel model.fit(X_train, y_train).
• Je hebt eenvoudig toegang tot modelcoëfficiënten.
• Er zijn ingebouwde metrics om modelprestaties te evalueren.
• Het is makkelijk om lineaire regressie (of een ander ML-algoritme) te integreren met preprocessing-stappen, zoals schalen en featureselectie, via Pipeline.

Ben je nieuw met scikit-learn? Bekijk dan onze cursus Machine Learning met scikit-learn voor een praktische introductie tot de Python-bibliotheek. 

Lineaire regressie begrijpen

Zoals we hebben gezien, wordt bij eenvoudige lineaire regressie de data gemodelleerd met een "best-fit-lijn". De formule voor deze lijn is: 

waarbij m de helling van de lijn is en b het intercept.

"Meervoudige lineaire regressie" generaliseert de casus van één voorspeller naar meerdere voorspellers (aantal kamers, nabijheid van de oceaan, mediaaninkomen in de buurt). De formule wordt veralgemeend tot: 

waarbij elke x_i een onafhankelijke variabele is en de bijbehorende b_i de coëfficiënt ervan. In drie dimensies wordt de lijn een vlak. In hogere dimensies wordt dat vlak een "hypervlak".

Hoe interpreteren we de coëfficiënten en het intercept? Het intercept is de voorspelde waarde van y wanneer alle onafhankelijke variabelen 0 zijn, of anders gezegd: de basiswaarde van de afhankelijke variabele wanneer de voorspellers niet bijdragen. Elke coëfficiënt b_i vertegenwoordigt de verandering in de afhankelijke variabele y bij een verandering van één eenheid in x_i, terwijl alle andere onafhankelijke variabelen constant worden gehouden.

De omgeving instellen

Scikit-learn installeren is eenvoudig. Gebruik gewoon het commando pip install scikit-learn. Als je een specifieke versie wilt installeren, bijvoorbeeld 1.2.2, voeg dan de versie toe aan het commando: pip install scikit-learn==1.2.2. Gebruik je Anaconda, dan zou scikit-learn al geïnstalleerd moeten zijn. Moet je het om wat voor reden dan ook toch installeren met de Anaconda-distributie, gebruik dan conda install scikit-learn.

Verschillende bibliotheken zijn nodig of aanbevolen bij het gebruik van scikit-learn. De numpy-bibliotheek is nodig om features en labels op te slaan. De pandas-bibliotheek wordt aanbevolen voor het laden, voorbewerken en verkennen van datasets. 

Als je scikit-learn gebruikt, werk je waarschijnlijk al met pandas voor je dataprep. Om je resultaten te plotten, gebruik je vaak matplotlib of seaborn of beide. Al deze bibliotheken kun je installeren met pip install, vergelijkbaar met het voorbeeld hierboven. Je kunt zelfs meerdere bibliotheken met één commando installeren:

pip install scikit-learn numpy pandas matplotlib seaborn.

Lineaire regressie implementeren in sklearn

Voordat we de dataset laden, importeren we de usual suspects.

# Import libraries.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

De dataset laden

Laten we de bekende California housing-dataset gebruiken.

# Read in California housing dataset.
from sklearn.datasets import fetch_california_housing


housing = fetch_california_housing()

De data voorbereiden

Laten we de data splitsen in trainings- en testsets. We importeren de methode train_test_split() uit sklearn.model_selection, roepen die aan met een percentage voor de testset en een random_state. We gebruiken ook eenvoudige lineaire regressie met de feature die overeenkomt met het gemiddelde aantal kamers.

# Import train_test_split.
from sklearn.model_selection import train_test_split


# Create features X and target y.
X = pd.DataFrame(housing.data, columns=housing.feature_names)[["AveRooms"]]
y = housing.target  # Median house value in $100,000s


# Split the dataset into training (80%) and testing (20%) sets.
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Nu we de data in test- en trainingsets hebben gesplitst, gaan we de features standaardiseren. Dit zorgt ervoor dat alle variabelen op dezelfde schaal staan, wat de modelprestaties en numerieke stabiliteit kan verbeteren.

# Import StandardScaler.
from sklearn.preprocessing import StandardScaler

# Instantiate StandardScaler.
scaler = StandardScaler()

# Fit and transform training data.
X_train_scaled = scaler.fit_transform(X_train)

# Also transform test data.
X_test_scaled = scaler.transform(X_test)

In deze code is StandardScaler een tool voor datavoorbewerking die het gemiddelde verwijdert en features schaalt naar variantie 1. Dit voorkomt dat bepaalde features het model domineren door schaalverschillen.

De scaler wordt op de trainingsdata gefit met fit_transform(). De testdata wordt vervolgens apart getransformeerd met transform() zodat deze met dezelfde factoren wordt geschaald als de trainingsdata, om datalekken te voorkomen.

Het lineaire regressiemodel trainen

Om een lineair regressiemodel te maken, importeer je LinearRegression() uit sklearn.linear_model. Roep het aan en ken het toe aan een variabele.

# Import LinearRegression.
from sklearn.linear_model import LinearRegression


# Instantiate linear regression model.
model = LinearRegression()

Het model fitten met trainingsdata is eenvoudig.

# Fit the model to the training data.
model.fit(X_train_scaled, y_train)

Voorspellingen doen

Nu we ons model hebben getraind, doen we voorspellingen op de testset.

# Make predictions on the testing data.
y_pred = model.predict(X_test_scaled)

Modelprestaties evalueren

Nu we voorspellingen op de testset hebben gedaan, willen we weten hoe goed ze overeenkomen met de werkelijkheid. Er zijn verschillende metrics om de prestaties van een regressie-algoritme te evalueren. Enkele van de meest gebruikte zijn de determinatiecoëfficiënt (R²), mean squared error (MSE) en root mean squared error (RMSE).

De determinatiecoëfficiënt, aangeduid als R², meet hoe goed een regressiemodel de variabiliteit van de doelvariabele verklaart. Met andere woorden: het kwantificeert hoeveel van de variatie in de doelvariabele wordt verklaard door de voorspellers, ook wel de goodness of fit genoemd.

Om dit beter te begrijpen, kijken we naar de formule:

waarbij yactual de werkelijke waarden van de doelvariabele zijn, ypredicted de voorspelde waarden van het model en ȳ het gemiddelde van de werkelijke waarden. Deze formule helpt ons te begrijpen hoeveel variantie in de doelvariabele door het model wordt verklaard. De noemer vertegenwoordigt de totale variantie in de data, terwijl de teller de onverklaarde variantie na toepassing van het regressiemodel weergeeft. De verhouding geeft dus het percentage verklaarde variantie door het model.

Hoe interpreteren we R²?

• R² = 1: het model verklaart perfect alle variantie in de doelvariabele. 
• R² = 0: het model verklaart geen variantie; voorspellingen zijn niet beter dan simpelweg het gemiddelde gebruiken. 
• R² < 0: het model presteert slechter dan het gemiddelde, wat op een slechte fit duidt.

Een paar belangrijke aandachtspunten.

• Een hogere R² is niet altijd beter. Een hoge R² kan op overfitting duiden, vooral bij complexe modellen. 
• Meer features toevoegen kan R² kunstmatig verhogen; een hogere waarde is dus niet per se beter.
• Gebruik bij meervoudige regressie de aangepaste R² (adjusted R²), die rekening houdt met het aantal voorspellers en misleidende verbeteringen door onnodige variabelen voorkomt.

Modelprestaties evalueren met de determinatiecoëfficiënt is eenvoudig met scikit-learn.

# Import metrics.
from sklearn.metrics import mean_squared_error, r2_score


# Calculate and print R^2 score.
r2 = r2_score(y_test, y_pred)
print(f"R-squared: {r2:.4f}")

R-squared: 0.0138

Andere veelgebruikte metrics zijn de mean squared error (MSE) en de root mean squared error (RMSE). Deze metrics meten hoe ver de voorspellingen van een model afwijken van de werkelijke waarden.

MSE berekent het gemiddelde van de gekwadrateerde verschillen tussen werkelijke en voorspelde waarden: 

voor het totale aantal observaties n. Omdat de fouten voor het middelen worden gekwadrateerd, worden grotere fouten zwaarder bestraft dan kleinere, waardoor MSE gevoelig is voor uitschieters. Een lagere MSE duidt op een betere model-fit.

Om dit te ondervangen wordt RMSE gebruikt, simpelweg de wortel uit MSE. Omdat RMSE in dezelfde eenheden is als de doelvariabele, biedt het een beter interpreteerbare maat voor de gemiddelde afwijking van voorspellingen.

MSE en RMSE berekenen is eenvoudig met scikit-learn.

# Calculate and print MSE.
mse = mean_squared_error(y_test, y_pred)
print(f"Mean squared error: {mse:.4f}")


# Calculate and print RMSE.
rmse = mse ** 0.5
print(f"Root mean squared error: {rmse:.4f}")

Mean squared error: 1.2923
Root mean squared error: 1.1368

Werken met meervoudige lineaire regressie in scikit-learn

Laten we het model opnieuw draaien met alle beschikbare features, niet alleen het gemiddelde aantal kamers. Verwacht je betere of slechtere resultaten?

# Uses all features.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score


# Load data set.
housing = fetch_california_housing()


# Split into X, y.
X = pd.DataFrame(housing.data, columns=housing.feature_names)
y = housing.target  # Median house value in $100,000s
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)


# Scale the data.
scaler = StandardScaler()


X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)


# Create model and fit it to the training data.
model = LinearRegression()
model.fit(X_train_scaled, y_train)


# Make predictions.
y_pred = model.predict(X_test_scaled)


# Calculate and print errors.
r2 = r2_score(y_test, y_pred)
print(f"R-squared: {r2:.4f}")


mse = mean_squared_error(y_test, y_pred)
print(f"Mean squared error: {mse:.4f}")


rmse = mse ** 0.5
print(f"Root mean squared error: {rmse:.4f}")

R-squared: 0.5758
Mean squared error: 0.5559
Root mean squared error: 0.7456

We zien dat de resultaten flink beter zijn dan met slechts één feature. Dit roept echter de vraag op of we wel alle features nodig hebben. Zijn sommige features relevanter dan andere? Het kiezen van de meest relevante features uit de dataset staat bekend als featureselectie.

Featureselectie is om meerdere redenen belangrijk.

• Vermindert overfitting. Minder features betekent minder complexiteit en dus minder risico op overfitting.
• Verbetert nauwkeurigheid. Het verwijderen van irrelevante of redundante features helpt het model zich te richten op betekenisvolle patronen.
• Verhoogt uitlegbaarheid. Maakt modellen makkelijker te begrijpen door de belangrijkste factoren uit te lichten.
• Versnelt training. Minder features verlagen de rekentijd en het geheugengebruik.

Wanneer meerdere features sterk gecorreleerd zijn, zijn ze redundant: ze geven het model in wezen dezelfde informatie. Deze situatie heet multicollineariteit. Hoewel multicollineariteit niet altijd de nauwkeurigheid van voorspellende modellen aantast, bemoeilijkt het featureselectie en interpretatie, vooral bij lineaire regressie en verwante modellen.

Variance Inflation Factor (VIF) is een maatstaf om multicollineariteit tussen voorspellers te detecteren. Voor elke voorspeller wordt VIF als volgt berekend: 

waarbij R_i² de R²-waarde is die wordt verkregen wanneer voorspeller X_i wordt geregressed op alle andere voorspellers in het model. Een hogere VIF betekent dat de voorspeller sterk gecorreleerd is met andere variabelen.

• VIF = 1: geen multicollineariteit (ideaal).
• VIF < 5: lage tot matige multicollineariteit (meestal acceptabel).
• VIF > 5: hoge multicollineariteit (overweeg gecorreleerde variabelen te verwijderen of te combineren).
• VIF > 10: ernstige multicollineariteit (sterke aanwijzing voor redundanties).

# Import libraries.
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.datasets import fetch_california_housing
from statsmodels.stats.outliers_influence import variance_inflation_factor


# Load the dataset.
housing = fetch_california_housing()
X = pd.DataFrame(housing.data, columns=housing.feature_names)


# Compute the correlation matrix.
corr_matrix = X.corr()


# Identify pairs of features with high collinearity (correlation > 0.8 or < -0.8).
high_corr_features = [(col1, col2, corr_matrix.loc[col1, col2])
                     for col1 in corr_matrix.columns
                     for col2 in corr_matrix.columns
                     if col1 != col2 and abs(corr_matrix.loc[col1, col2]) > 0.8]


# Convert to a DataFrame for better visualization.
collinearity_df = pd.DataFrame(high_corr_features, columns=["Feature 1", "Feature 2", "Correlation"])
print("\nHighly Correlated Features:\n", collinearity_df)


# Compute Variance Inflation Factor (VIF) for each feature.
vif_data = pd.DataFrame()
vif_data["Feature"] = X.columns
vif_data["VIF"] = [variance_inflation_factor(X.values, i) for i in range(X.shape[1])]


# Print VIF values.
print("\nVariance Inflation Factor (VIF) for each feature:\n", vif_data)

   Highly Correlated Features:
       Feature 1  Feature 2  Correlation
   0   AveRooms  AveBedrms     0.847621
   1  AveBedrms   AveRooms     0.847621
   2   Latitude  Longitude    -0.924664
   3  Longitude   Latitude    -0.924664
  
   Variance Inflation Factor (VIF) for each feature:
          Feature         VIF
   0      MedInc   11.511140
   1    HouseAge    7.195917
   2    AveRooms   45.993601
   3   AveBedrms   43.590314
   4  Population    2.935745
   5    AveOccup    1.095243
   6    Latitude  559.874071
   7   Longitude  633.711654

Laten we AveBedrms uit het model verwijderen.

# Import libraries.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score


# Load California housing dataset.
housing = fetch_california_housing()


# Create DataFrame and remove "AveBedrms" feature.
X = pd.DataFrame(housing.data, columns=housing.feature_names).drop(columns=["AveBedrms"])
y = housing.target  # Median house value in $100,000s


# Split data into training and testing sets.
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)


# Scale the data (Standardization).
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)


# Create a linear regression model and train it.
model = LinearRegression()
model.fit(X_train_scaled, y_train)


# Make predictions on the test set.
y_pred = model.predict(X_test_scaled)


# Calculate performance metrics.
r2 = r2_score(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
# Print evaluation metrics
print(f"R-squared: {r2:.4f}")
print(f"Mean squared error: {mse:.4f}")
print(f"Root mean squared error: {rmse:.4f}")

R-squared: 0.5823
Mean squared error: 0.5473
Root mean squared error: 0.7398

De resultaten zijn (marginaal) verbeterd.

Inzichten uit het model halen

Een regressiemodel bouwen is slechts de eerste stap; de uitkomsten begrijpen is net zo belangrijk. Door de coëfficiënten van het model te analyseren, kun je bepalen welke features de grootste impact hebben op de voorspellingen.

Regressiecoëfficiënten begrijpen

Zodra een lineair regressiemodel is getraind, kun je de coëfficiënten benaderen met model.coef_. Het intercept is beschikbaar via model.intercept_.

Zodra een lineair regressiemodel is getraind met LinearRegression(), kun je de coëfficiënten benaderen met model.coef_ en het intercept met model.intercept_.

print("Intercept:", model.intercept_)


coeff_df = pd.DataFrame({"Feature": X.columns, "Coefficient": model.coef_})
print("\nFeature Coefficients:\n", coeff_df)

   Intercept: 2.0719469373788777  

   Feature Coefficients:

         Feature  Coefficient

   0     MedInc     0.725747

   1   HouseAge     0.121519

   2   Latitude    -0.943105

   3  Longitude    -0.900735

Modelresultaten samenvatten

Omdat Scikit-Learn geen ingebouwde summary()-methode biedt zoals Statsmodels, kunnen we handmatig het belang van elke feature extraheren en visualiseren met regressiecoëfficiënten. Features met grotere absolute coëfficiënten hebben een sterkere impact op de doelvariabele. Bekijk de volgende code.

# Sort dataframe by coefficients.
coef_df_sorted = coef_df.sort_values(by="Coefficient", ascending=False)


# Create plot.
plt.figure(figsize=(8,6))
plt.barh(coef_df["Feature"], coef_df_sorted["Coefficient"], color="blue")
plt.xlabel("Coefficient Value")
plt.ylabel("Feature")
plt.title("Feature Importance (Linear Regression Coefficients)")
plt.show()

Grafiek van featurebelang op basis van coëfficiëntwaarden

Laten we nu de residuen en de regressie-fit visualiseren.

# Compute residuals.
residuals = y_test - y_pred


# Create plots.
plt.figure(figsize=(12,5))


# Plot 1: Residuals Distribution.
plt.subplot(1,2,1)
sns.histplot(residuals, bins=30, kde=True, color="blue")
plt.axvline(x=0, color='red', linestyle='--')
plt.title("Residuals Distribution")
plt.xlabel("Residuals (y_actual - y_predicted)")
plt.ylabel("Frequency")


# Plot 2: Regression Fit (Actual vs Predicted).
plt.subplot(1,2,2)
sns.scatterplot(x=y_test, y=y_pred, alpha=0.5)
plt.plot([min(y_test), max(y_test)], [min(y_test), max(y_test)], color='red', linestyle='--')  # Perfect fit line
plt.title("Regression Fit: Actual vs Predicted")
plt.xlabel("Actual Prices (in $100,000s)")
plt.ylabel("Predicted Prices (in $100,000s)")


# Show plots.
plt.tight_layout()
plt.show()

Plots om residuen en regressie-fit te visualiseren

De distributie van de residuen (linkerplot) zou rond nul gecentreerd moeten zijn, wat aangeeft dat fouten willekeurig verdeeld zijn. Als de residuen een normale verdeling volgen, past het model goed; als er scheefheid of een trend is, kan dat op systematische fouten wijzen. De regressie-fit (rechterplot) vergelijkt werkelijke versus voorspelde waarden, waarbij de rode stippellijn een perfecte fit weergeeft. Volgen de punten de lijn nauw, dan zijn de voorspellingen accuraat; verschijnt er een patroon (bijv. een kromme), dan is de relatie mogelijk niet echt lineair. 

Deze visualisaties helpen bij het diagnosticeren van overfitting of underfitting, onthullen patronen in residuen die op ontbrekende relaties wijzen en geven een duidelijk beeld van de effectiviteit van het model.

Praktische toepassingen

Lineaire regressie wordt in veel sectoren gebruikt voor voorspellingen en besluitvorming. In vastgoed schat het huizenprijzen op basis van factoren zoals grootte en locatie. 

Sales en marketing gebruiken het voor vraagvoorspelling en budgetoptimalisatie, terwijl de zorg het toepast voor risicobeoordeling van ziekten. In finance helpt het bij de voorspelling van aandelenkoersen en kredietbeoordeling, en in de maakindustrie bij kwaliteitscontrole en het voorspellen van uitval. 

Wanneer gebruik je lineaire regressie

• Features en de doelvariabele hebben een lineaire relatie.
• Uitlegbaarheid en eenvoud wegen zwaarder dan complexe modellering.
• Data vereist minimale feature engineering.

Wanneer niet gebruiken

• De relatie tussen doel en features is complex en niet-lineair.
• Data is sterk gecorreleerd.
• De data bevat uitschieters die je niet kunt verwijderen. In dat geval moet je mogelijk datatransformaties toepassen of strategieën gebruiken om hun impact te beperken.

Conclusie

Lineaire regressie is een van de meest fundamentele en wijdverbreide technieken in machine learning en statistische modellering. Ondanks de eenvoud is het een krachtig hulpmiddel om relaties tussen variabelen te begrijpen en voorspellingen te doen in diverse praktische toepassingen.

Dit zijn de belangrijkste punten uit de tutorial:

• Veelzijdige toepassingen. Lineaire regressie biedt waardevolle inzichten in meerdere sectoren en probleemdomeinen.
• Uitlegbaar. In tegenstelling tot complexe blackbox-modellen biedt lineaire regressie duidelijke interpretaties op basis van coëfficiënten, waardoor het eenvoudig te duiden en uit te leggen is.
• Featureselectie. Door features zorgvuldig te kiezen en multicollineariteit aan te pakken, blijven modellen accuraat, stabiel en betrouwbaar. 

Voor meer informatie over stringinterpolatie in Python kun je de resources van DataCamp bekijken.

• Eenvoudige lineaire regressie: alles wat je moet weten - Tutorial
• Lineaire regressie in R - Tutorial
• Lineaire regressie in Excel: een complete gids voor beginners - Tutorial
• Introductie tot regressie in R - Cursus
• Supervised learning met scikit-learn - Cursus
• Scikit-learn cheatsheet: Python machine learning - Cheatsheet
• Logistische regressie in Python begrijpen - Tutorial