Polynomiale regressie: van rechte lijnen naar krommen

Als je data een bocht maakt, is het niet logisch om een rechte lijn te gebruiken om nieuwe punten te schatten. Doe je dat wel, dan krijg je een model dat het patroon mist, hoge residuen heeft en slecht voorspelt. In de echte wereld gedraagt data zich zelden lineair, of je nu modelleert hoe de dosering van een medicijn het effect beïnvloedt, hoe temperatuur materiaalspanning beïnvloedt, of hoe activaprijzen in de tijd bewegen.

Polynomiale regressie lost dit op door lineaire regressie uit te breiden zodat je krommen in plaats van rechte lijnen kunt fitten. Voeg gewoon een paar termen met hogere graden toe - x², x³ - en je model kan de werkelijke vorm van je data volgen.

In dit artikel leg ik uit wat polynomiale regressie is, de wiskunde erachter, hoe je het in Python implementeert en hoe je de valkuil waar de meesten intrappen vermijdt: overfitting.

Als het concept machine learning nieuw voor je is, lees dan eerst onze Essentials of Linear Regression in Python-tutorial.

Wat is polynomiale regressie?

Polynomiale regressie is het algoritme waar je naar grijpt als een rechte lijn je data niet kan beschrijven.

Lineaire regressie modelleert de relatie tussen variabelen als een rechte lijn. Dat werkt als de relatie echt lineair is - maar de meeste data in de echte wereld is dat niet. Denk aan hoe de remafstand van een auto verandert met de snelheid, of hoe de groeisnelheid van een plant reageert op meststof. Deze relaties buigen af. Een rechte lijn past daar niet goed op, wat je ook probeert.

Polynomiale regressie breidt lineaire regressie uit door termen met hogere graden aan de vergelijking toe te voegen. In plaats van y = b0 + b1x te fitten, fit je iets als y = b0 + b1x + b2x² + b3x³. De graad van het polynoom - die n in "n-de graad" - bepaalt hoeveel bochten de curve kan maken.

Kort gezegd is dit het belangrijkste verschil tussen de twee:

• Lineaire regressie: Past een rechte lijn. Eén coëfficiënt per feature, één vrijheidsgraad in de curve.

• Polynomiale regressie: Past een kromme. Elke extra term (x², x³, ...) geeft het model meer flexibiliteit om de vorm van de data te volgen.

Lineaire versus polynomiale regressie

Onder de motorkap is polynomiale regressie nog steeds een lineair model. "Lineair" verwijst hier naar hoe het model met zijn coëfficiënten omgaat, niet naar de vorm van de curve die het oplevert. Je voegt nieuwe features toe (x², x³) en fit daarop een lineaire vergelijking.

Wanneer gebruik je het nu echt?

Kies voor polynomiale regressie als je residuplot van een lineair model een patroon laat zien - dat is een teken dat de relatie niet lineair is. Het past ook goed wanneer je domeinkennis wijst op een gebogen relatie, zoals in de fysica, biologie of economie.

Het nadeel is dat polynomen met een hogere graad instabiel kunnen worden. Een polynoom van graad 2 of 3 kan de meeste echte krommen aan, maar ga je hoger, dan fit je waarschijnlijk ruis in plaats van signaal.

Waarom polynomiale regressie gebruiken?

De meeste relaties tussen variabelen in de echte wereld zijn niet lineair.

Een rechte lijn kan in de buurt komen, maar "in de buurt" is niet goed genoeg als je iets gevoeligs wilt voorspellen. Wanneer de relatie in de data buigt, zal een lineair model die buiging consequent missen.

Polynomiale regressie doet het beter door de curve te laten meebuigen. In plaats van je data in een rechte lijn te wringen, fit je een kromme die de vorm van de relatie kan volgen.

Hier zijn een paar domeinen waar het echt verschil maakt:

• Biologie en geneeskunde: Dosis-responsrelaties zijn zelden lineair. Een lage dosis heeft misschien weinig effect, een gemiddelde dosis werkt goed en een hoge dosis veroorzaakt bijwerkingen. Die S-vormige curve vraagt om een polynomiaal model om haar vast te leggen
• Engineering: Spannings-rekrelaties in materialen, aerodynamische weerstand en thermische uitzetting volgen allemaal niet-lineaire patronen die polynomiale regressie goed modelleert
• Financiën: Rendementen, optiewaardering en vraagcurves vertonen vaak afnemende of versnellende effecten die je niet met een rechte lijn kunt vangen
• Machine-learningpijplijnen: Polynomiale features zijn een snelle manier om niet-lineariteit toe te voegen aan een lineair model zonder over te stappen op een complexer algoritme

De gemene deler in al deze gevallen is hetzelfde: de relatie tussen je input en output verandert bij verschillende waarden van x. Lineaire regressie gaat uit van een constante verandering. Polynomiale regressie niet.

Dat gezegd hebbende: polynomiale regressie is geen wondermiddel.

Het werkt het best wanneer je domeinkennis op een gebogen relatie wijst, of wanneer je residuplot duidelijk een patroon laat zien dat een rechte lijn niet kan oplossen. Gebruik het met een specifiek probleem voor ogen - niet alleen omdat de R² van je lineaire model niet hoog genoeg is.

De wiskunde achter polynomiale regressie begrijpen

De basiswiskunde achter polynomiale regressie kennen helpt je het beter te begrijpen.

Polynomiale termen

Bij lineaire regressie ziet je model er zo uit:

Formule voor lineaire regressie

Dat is één invoervariabele, één coëfficiënt, één rechte lijn. Polynomiale regressie breidt dit uit met termen van hogere graad:

Formule voor polynomiale regressie

Elke nieuwe term - x², x³, enzovoort - geeft het model één extra "bocht" om mee te werken. Een polynoom van graad 2 kan één kromme fitten. Een polynoom van graad 3 kan een kromme fitten die één keer van richting verandert. De graad n bepaalt hoe flexibel het model is.

Het onderliggende algoritme blijft hetzelfde. Je voegt alleen nieuwe features toe. x² wordt behandeld als een eigen invoervariabele, net als x. Het model fit nog steeds een lineaire vergelijking - maar dan op getransformeerde features.

Kleinste-kwadraten-schatting

Een polynomiaal regressiemodel fitten werkt hetzelfde als bij lineaire regressie - namelijk met kleinste-kwadraten-schatting.

Het idee is om de coëfficiënten te vinden die de som van gekwadrateerde residuen te minimaliseren:

SSR-formule

Elk gekwadrateerd verschil is een residu - het gat tussen wat het model voorspelt en wat is waargenomen. Door te kwadrateren voorkom je dat negatieve en positieve fouten elkaar opheffen en worden grote fouten zwaarder bestraft dan kleine.

In de praktijk regelt je library dit voor je. Maar weten dat kleinste kwadraten het doel is, helpt je begrijpen waarom uitschieters polynomiale modellen zo veel pijn doen - één groot residu wordt gekwadrateerd en trekt de coëfficiënten zijn kant op.

Coëfficiënten interpreteren

Bij lineaire regressie heeft b1 een simpele interpretatie: voor elke toename van één eenheid in x verandert y met b1.

Polynomiale regressie is wat complexer. Als je model b_1x + b_2x^2 bevat, hangt het effect van x op y af van de huidige waarde van x - je kunt b2 niet geïsoleerd lezen en daar een conclusie uit trekken. De helling van de curve verandert voortdurend, wat je ziet door de afgeleide naar x te nemen:

Afgeleide t.o.v. x

De helling zelf is een functie van x. Dat betekent dat de impact van één eenheid verandering in x op elk punt van de curve anders is.

Daarom moet je individuele coëfficiënten in een polynomiaal model niet proberen te interpreteren. Kijk in plaats daarvan naar de curve als geheel. Plot je voorspellingen tegenover je data.

Toepassingen van polynomiale regressie in data science

Polynomiale regressie duikt in veel vakgebieden op, omdat gebogen relaties overal voorkomen in echte data.

Financiën

Financiële data beweegt zelden in rechte lijnen.

Activaprijzen, omzetgroei en vraagcurves hebben de neiging te versnellen, te vertragen of van richting te veranderen afhankelijk van marktomstandigheden. Een lineair model gaat uit van een constante veranderingssnelheid, en dat klopt bijna nooit. Polynomiale regressie laat je deze verschuivingen modelleren - bijvoorbeeld hoe de vraag van consumenten eerst langzaam afneemt en daarna snel zodra de prijs een bepaalde grens overschrijdt.

Het is ook handig voor trendanalyse in de tijd. Als je een curve past op historische prijsdata of modelleert hoe een metric groeit tijdens verschillende fasen van een conjunctuurcyclus, schat een polynoom van graad 2 of 3 de vorm vaak veel beter dan een rechte lijn.

Engineering

Fysische processen zijn enkele van de beste voorbeelden van niet-lineaire relaties.

Spanning en rek in materialen, stromingsleer, thermische uitzetting en aerodynamische weerstand volgen allemaal krommen, geen lijnen. Veel van de basisvergelijkingen in de fysica zijn van nature polynomiaal. Polynomiale regressie geeft je een datagedreven manier om die krommen te fitten wanneer je metingen hebt maar geen nette, gesloten vorm van de vergelijking.

Een goed voorbeeld is luchtweerstand, die toeneemt met het kwadraat van de snelheid. Een lineair model zal de weerstand bij hoge snelheden onderschatten, en een polynoom van graad 2 zal de relatie correct fitten.

Machine learning

In machine learning wordt polynomiale regressie vaak gebruikt als feature-engineeringtechniek in plaats van als op zichzelf staand model.

Door polynomiale termen - x², x³, interactietermen - aan je featureset toe te voegen, geef je een lineair model de mogelijkheid om niet-lineaire patronen te fitten zonder over te stappen op een complexer algoritme. Dit is een veelgebruikte eerste stap wanneer je lineaire model underfit en je flexibiliteit wilt toevoegen voordat je iets als een beslisboom of neuraal netwerk inzet.

Het is ook nuttig als basismodel.

Voordat je een complexer model traint, laat polynomiale regressie je zien hoeveel variantie een eenvoudige kromme kan verklaren. Als een polynoom van graad 3 je al het grootste deel van de weg brengt, heb je misschien niets complexers nodig.

Hoe kies je de juiste graad voor polynomiale regressie

De graad van je polynoom kiezen is een van de belangrijkste beslissingen die je neemt. Zit je er in welke richting dan ook naast, dan eindig je met een minder accuraat model.

Gelukkig zijn een paar regels Python-code genoeg om het werk te doen.

Overfitting vs. underfitting

Underfitting treedt op als je graad te laag is. Een polynoom van graad 1 op gebogen data mist het patroon - hoge bias, slechte voorspellingen en een model dat slecht presteert op zowel trainings- als nieuwe data.

Overfitting is het tegenovergestelde probleem, en gevaarlijker omdat het er in eerste instantie goed uitziet. Een polynoom van hoge graad kan door elk datapunt in je trainingsset gaan met bijna nul fout. Maar het model onthoudt gewoon de ruis. Het valt uit elkaar op nieuwe data.

Je ziet dit door trainingsfout en testfout over graden te vergelijken:

import numpy as np
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split

np.random.seed(42)

# Generate sample data
x = np.linspace(-3, 3, 80).reshape(-1, 1)
y = 0.6 * x.ravel()**2 - x.ravel() + np.random.normal(0, 0.6, 80)

x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.25)

for deg in [1, 2, 12]:
    poly = PolynomialFeatures(deg)
    model = LinearRegression()
    model.fit(poly.fit_transform(x_train), y_train)

    train_err = mean_squared_error(y_train, model.predict(poly.transform(x_train)))
    test_err  = mean_squared_error(y_test,  model.predict(poly.transform(x_test)))

    print(f"Degree {deg:>2} | Train MSE: {train_err:.4f} | Test MSE: {test_err:.4f}")

MSE bij verschillende graden

Of, visueel weergegeven:

Data gefit met verschillende polynomiale graden

Graad 1 laat hoge fout zien op beide sets - dat is underfitting. Graad 2 is goed in balans. Graad 12 heeft lagere trainingsfout maar veel hogere testfout - dat is overfitting.

Cross-validatie

De juiste manier om de beste graad te vinden is cross-validatie - specifiek k-fold cross-validatie.

Het idee is om je data in k subsets te splitsen, dan te trainen op k-1 daarvan en te testen op de subset die je hebt achtergehouden, en te herhalen totdat elke subset één keer de testset is geweest. Gemiddeld vervolgens de fout over alle folds, doe dit voor elke kandidaatgraad en kies degene met de laagste gemiddelde testfout.

De implementatie is veel eenvoudiger dan de uitleg:

import numpy as np
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import cross_val_score
from sklearn.pipeline import make_pipeline
import matplotlib.pyplot as plt

np.random.seed(42)

# Generate sample data
x = np.linspace(-3, 3, 80).reshape(-1, 1)
y = 0.6 * x.ravel()**2 - x.ravel() + np.random.normal(0, 0.6, 80)

# Test degrees 1 through 10
degrees = range(1, 11)
mean_errors = []

for deg in degrees:
    model = make_pipeline(PolynomialFeatures(deg), LinearRegression())
    scores = cross_val_score(model, x, y, cv=5, scoring="neg_mean_squared_error")
    mean_errors.append(-scores.mean())
    print(f"Degree {deg:>2} | Mean error: {-scores.mean():.4f}")

best_degree = np.argmin(mean_errors) + 1

Vergelijking van graadfouten

Of, visueel weergegeven:

Vergelijking van cross-validatiefouten

De CV-fout daalt naarmate je nuttige polynomiale termen toevoegt, en stijgt weer zodra het model gaat overfitten.

Als twee graden vergelijkbare CV-fouten geven, kies dan de lagere. Een eenvoudiger model dat net zo goed presteert is altijd de betere keuze.

Belangrijke aandachtspunten en beperkingen

Er zijn een paar manieren waarop polynomiale regressie je op het verkeerde spoor kan zetten. Laten we die nu doornemen.

Gevoeligheid voor uitschieters

Uitschieters beïnvloeden polynomiale regressie sterker dan lineaire regressie.

Kleinste kwadraten kwadrateren elk residu voordat ze worden opgeteld. Eén datapunt ver van de trend levert onevenredig veel foutbijdrage, en het model buigt zijn curve om die fout te verminderen - zelfs als dat betekent dat de fit elders wordt vervormd.

Dit effect wordt erger naarmate de graad toeneemt. Een polynoom van hoge graad is flexibel genoeg om een uitschieter achterna te gaan, wat de curve wegtrekt van het gros van je data om één slecht punt te fitten.

Een manier om dit te omzeilen is je data op te schonen voordat je fit. Plot je data, identificeer uitschieters en bepaal of ze echt signaal of ruis vertegenwoordigen. Als het ruis is - meetfouten, invoerfouten, beschadigde records - verwijder ze. Als ze echt zijn, overweeg dan een robuustere fitalgoritme zoals RANSAC of Huber-regressie.

Overfitting

Elke keer dat je een polynomiale term toevoegt, geef je het model meer flexibiliteit. Op een gegeven moment stopt die flexibiliteit met helpen en begint het model de willekeurige ruis in je trainingsdata te fitten in plaats van het daadwerkelijke patroon. Het resultaat is een curve die goed scoort op trainingsdata maar instort op nieuwe data.

Het lastige is dat overfitting onzichtbaar is als je alleen naar trainingsfout kijkt. Een polynoom van graad 10 zal bijna altijd een lagere training-MSE hebben dan een polynoom van graad 2. Dat betekent niet dat het een beter model is.

Zo pak je dit aan:

• Begin laag: Probeer graad 2 of 3 voordat je hoger gaat. De meeste curves in de echte wereld hebben niet meer nodig
• Evalueer altijd op achtergehouden data: Alleen trainingsfout zegt niets over generalisatie.
• Cross-validatie: Gebruik dit om de graad te vinden waarbij de testfout niet meer verbetert.
• Kijk naar de curve: Doet je polynoom iets geks buiten het bereik van je trainingsdata, dan is dat een teken van overfitting.

Polynomiale regressie werkt het best wanneer je een goede reden hebt om een gebogen relatie te verwachten en je de graad laag kunt houden.

Alternatieven voor polynomiale regressie

Polynomiale regressie is niet altijd het juiste gereedschap - sommige van deze alternatieven passen misschien beter, zonder woordspeling bedoeld.

Splines

Splines lossen het probleem van globale instabiliteit op.

Als je een polynoom van graad 10 fit, worden alle coëfficiënten beïnvloed door elk datapunt. Een verandering in één regio van je data beïnvloedt de curve overal. Splines vermijden dit door je data op te splitsen in segmenten en op elk segment een apart polynoom van lage graad te fitten. De segmenten worden verbonden op punten die knopen heten, met voorwaarden die de totale curve bij de overgangen soepel houden.

Het resultaat is een curve die flexibel is waar het moet en stabiel elders.

In Python hebben scipy en scikit-learn beide degelijke spline-implementaties:

from scipy.interpolate import UnivariateSpline

spline = UnivariateSpline(x, y, k=3)
y_pred = spline(x_new)

Spline versus een polynoom van hoge graad

Kortom: kies voor splines wanneer je data zich in verschillende regio's anders gedraagt, of wanneer één enkele polynomiale kromme de vorm niet kan vangen zonder naar een hoge graad te gaan.

Support Vector Regression

Support Vector Regression (SVR) pakt het anders aan.

Het fit geen curve die de kwadratische fout over alle punten minimaliseert, maar probeert een functie te vinden die binnen een gedefinieerde foutmarge voor zoveel mogelijk punten blijft, terwijl punten binnen die marge worden genegeerd. Dit maakt het minder gevoelig voor uitschieters dan polynomiale regressie.

De link met polynomiale regressie komt via de kerneltruc. SVR met een polynomiale kernel kan niet-lineaire relaties fitten die lijken op polynomiale regressie - maar met betere generalisatie en meer controle over de fit via regularisatieparameters.

from sklearn.svm import SVR

model = SVR(kernel="poly", degree=3, C=1.0, epsilon=0.1)
model.fit(x_train, y_train)

SVR versus een polynoom van hoge graad

SVR is een goede keuze wanneer je data uitschieters bevat die je niet kunt verwijderen, wanneer je meer controle nodig hebt over de bias-variantieafweging, of wanneer polynomiale regressie blijft overfitten ondanks cross-validatie.

Conclusie

In dit artikel heb ik laten zien hoe het lineaire regressie uitbreidt om krommen te fitten, hoe kleinste-kwadraten-schatting de beste coëfficiënten vindt, en waarom het weinig zegt om die coëfficiënten afzonderlijk te interpreteren.

De graad die je kiest is belangrijker dan wat dan ook. Te laag leidt tot underfitting, te hoog tot overfitting. Cross-validatie geeft je een objectieve manier om het sweet spot te vinden. En als polynomiale regressie niet de juiste keuze is, zijn splines en SVR sterke alternatieven om te kennen.

De beste manier om hier gevoel voor te krijgen, is het op je eigen data te gebruiken. Kies een dataset waarvan je een niet-lineaire relatie vermoedt, fit eerst een lineair model, plot de residuen en bekijk wat polynomiale regressie anders doet. Lees onze gids Non-Linear Models and Insights Using R om deze pipeline in de praktijk te zien.