Regularisatie in machine learning: L1, L2 en Elastic Net uitgelegd

Dus, je hebt een model getraind dat bijna elk trainingsvoorbeeld perfect doet, maar faalt op nieuwe data? Dat overkomt ons allemaal.

Dat is op hoofdlijnen de definitie van overfitting. Je model heeft niet het echte patroon geleerd, maar het trainingsdata uit het hoofd geleerd. In een productieomgeving met nieuwe en onbekende data zou het model voorspellingen doen die je niet vertrouwt. Hoe verder echte data afwijkt van de trainingssamples, hoe erger dit wordt.

Regularisatie lost dit op door een strafterm toe te voegen aan de verliesfunctie. Die straf ontmoedigt complexe modellen. Met andere woorden: het is het mechanisme dat voorkomt dat je model elk datapunt past en het dwingt in plaats daarvan te generaliseren.

In dit artikel neem ik je mee door de intuïtie achter regularisatie, de meest gangbare methoden — L1, L2 en Elastic Net — en hoe je de juiste kiest voor jouw use case.

Als je wilt begrijpen waarom en hoe machine learning-modellen falen in productie, lees dan onze Bias-variance trade-off-blogpost.

Wat is regularisatie in machine learning

Regularisatie is een techniek die een strafterm toevoegt aan de verliesfunctie van je model om complexiteit te ontmoedigen.

Zonder deze strafterm is een model flexibel genoeg om de trainingsdata zo nauw te passen als het wil. Dat omvat ook de ruis en uitschieters. Regularisatie voegt een prijskaartje toe aan die flexibiliteit. Hoe complexer het model wil zijn, hoe hoger de straf wordt.

De verliesfunctie van je model meet normaal gesproken het verschil tussen voorspelde en werkelijke waarden. Regularisatie voegt een extra term toe aan die vergelijking, een die groeit naarmate de coëfficiënten van het model groeien. Het model moet nu twee concurrerende doelen balanceren: de trainingsdata passen én de coëfficiënten klein houden.

Die balans is wat de flexibiliteit van het model bepaalt.

Een zeer flexibel model kan zich in elke vorm wringen om trainingsdata te passen. Regularisatie strijkt dat terug naar een eenvoudigere vorm — een die waarschijnlijker standhoudt op data die het model nog niet eerder heeft gezien.

Waarom regularisatie nodig is

Elk model dat je traint, zit ergens tussen twee onbruikbare modellen in: eentje die te simpel is en eentje die te complex is.

Een model dat te simpel is, snapt de echte patronen in je data niet. Het mist het signaal. Dat is underfitting — het model presteert slecht op trainingsdata en op nieuwe data.

Een model dat te complex is, doet het tegenovergestelde. Het past elk detail in je trainingsdata, inclusief de ruis. Dat is overfitting — het model presteert geweldig op trainingsdata, maar faalt op nieuwe data omdat het de verkeerde dingen heeft gememoriseerd.

Neem polynomiale regressie als concreet voorbeeld. Een polynoom van graad 3 door data met een lichte kromming betekent dat je waarschijnlijk het juiste patroon past. Maar een polynoom van graad 15 door dezelfde data leidt tot overfitting — de kromme gaat door elk datapunt, maar doet willekeurige voorspellingen ertussenin.

De grafiek hieronder laat zien hoe dat er in de praktijk uitziet.

Net goed versus te complex model

Dit is de bias-variance trade-off.

Eenvoudige modellen hebben hoge bias — ze maken sterke aannames die echte patronen missen. Complexe modellen hebben hoge variantie — ze zijn te gevoelig voor de specifieke trainingssamples die ze zagen, en kleine veranderingen in de data leveren heel andere modellen op.

Regularisatie helpt je het beste van beide te krijgen. Het elimineert complexiteit niet, maar straft die af. Daardoor heeft je model een betere kans om het echte signaal te leren.

Hoe regularisatie werkt

Elk model leert door een verliesfunctie te minimaliseren — een maatstaf voor hoe verkeerd de voorspellingen zijn. Zonder regularisatie is de enige taak van het model om die fout te minimaliseren. Het zal er alles aan doen, inclusief het laten groeien van grote coëfficiënten die de trainingsdata passen maar niet generaliseren.

Regularisatie verandert het doel. In plaats van alleen de fout te minimaliseren, minimaliseert het model nu dit:

Hoe regularisatie werkt

De strafterm is een functie van de coëfficiënten van het model. Grote coëfficiënten verhogen de straf. Om de totale kosten laag te houden, wordt het model gedwongen zijn coëfficiënten klein te houden — wat neerkomt op eenvoudigere, beter generaliseerbare oplossingen.

De λ (lambda) bepaalt hoeveel de straf meetelt. Een hogere λ zet meer druk op het model om simpel te blijven. Een lagere λ laat het model meer focussen op het passen van de data. Je ziet hieronder in de sectie De regularisatiesterkte kiezen hoe je dit afstemt.

Types regularisatie in machine learning

Er zijn verschillende manieren om modelcomplexiteit te bestraffen. Elk zet op een andere manier druk op de coëfficiënten, wat betekent dat ze voor verschillende situaties geschikt zijn.

L2-regularisatie (Ridge-regressie)

L2-regularisatie straft de kwadraatwaarde van elke coëfficiënt. Hoe groter een coëfficiënt, hoe groter zijn bijdrage aan de straf — en hoe harder het model werkt om hem te verkleinen.

L2-regularisatie

Het sleutelwoord hier is krimpen. L2 duwt alle coëfficiënten richting nul, maar bereikt nul nooit helemaal. Elke feature blijft in het model, alleen met een kleiner gewicht. Dat maakt Ridge een goede default wanneer je gelooft dat de meeste features relevant zijn en je een stabiel, goed-gedragen model wilt.

L1-regularisatie (Lasso-regressie)

L1-regularisatie straft de absolute waarde van elke coëfficiënt in plaats van het kwadraat.

L1-regularisatie

Dat kleine verschil heeft een groot gevolg. L1 kan coëfficiënten helemaal tot precies nul duwen, wat betekent dat het features uit het model verwijdert. Je kunt dit zien als automatische featureselectie. Met andere woorden: Lasso-regularisatie kan je model vereenvoudigen door features te verwijderen.

L1 vs. L2-regularisatie

Het kernverschil komt neer op schaarste. L1 levert schaarse modellen op — alleen een subset van de features komt door. L2 levert dichte modellen op — alle features blijven, met kleinere gewichten.

Dat beïnvloedt ook de uitlegbaarheid. Een Lasso-model met 5 actieve features is makkelijker uit te leggen dan een Ridge-model met 50 features die allemaal een beetje bijdragen. Maar Ridge is doorgaans stabieler wanneer features onderling gecorreleerd zijn, omdat het het gewicht over hen verdeelt in plaats van willekeurig één te kiezen.

Hier is een kort overzicht van de verschillen:

L1 versus L2-regularisatie

Als je wilt zien hoe deze zich verhouden in Python, dan helpt onze Lasso- en Ridge-regressie in Python-tutorial je op weg.

Elastic Net-regularisatie

Elastic Net combineert L1 en L2 in één strafterm.

Elastic Net-regularisatie

Het idee is om het beste van beide te krijgen: featureselectie van L1 en stabiliteit van L2. Dit is handig wanneer je gecorreleerde features hebt en toch wilt dat sommige worden verwijderd. Lasso alleen neigt ertoe één feature uit een gecorreleerde groep te kiezen en de rest te negeren. Elastic Net houdt er eerder een paar, terwijl het irrelevante nog steeds verwijdert.

Regularisatie in verschillende modellen

Regularisatie komt terug in veel machine learning-modellen, maar in verschillende vormen. Ik laat je zien welke dat zijn.

Lineaire regressie is waar de meesten regularisatie voor het eerst zien. Als je L2-regularisatie toevoegt aan lineaire regressie, krijg je Ridge-regularisatie. Evenzo krijg je met L1 Lasso-regressie. De wiskunde is hetzelfde als hierboven beschreven — een strafterm toegevoegd aan de kleinste-kwadraten-verliesfunctie.

Logistische regressie werkt hetzelfde. De verliesfunctie verandert — het is kruis-entropie in plaats van kwadratische fout — maar de strafterm is identiek. De meeste machine learning-bibliotheken passen standaard L2-regularisatie toe op logistische regressie, wat de reden is dat je een parameter C ziet in scikit-learn. Het is het omgekeerde van λ, dus een kleinere C betekent sterkere regularisatie.

Neurale netwerken gebruiken een paar verschillende benaderingen:

• Gewichtsverval: L2-regularisatie toegepast op de gewichten van het netwerk — het werkt hetzelfde, alleen op veel grotere schaal
• Dropout: tijdens het trainen worden willekeurig een deel van de neuronen per pass uitgeschakeld, wat voorkomt dat het netwerk te zwaar leunt op één specifiek pad door de lagen.

Beide verminderen overfitting, maar via verschillende middelen.

Boomgebaseerde modellen gebruiken helemaal geen verliesstraffen. In plaats daarvan beheersen ze complexiteit via snoeien — beperken hoe diep een boom mag groeien, of takken verwijderen die de voorspellingen niet genoeg verbeteren om hun bestaan te rechtvaardigen. Hyperparameters zoals max_depth en min_samples_split in scikit-learn zijn regularisatieparameters, ook al heten ze niet zo.

Regularisatie en de bias-variance trade-off

Regularisatie draait om compromissen.

Als je een strafterm toevoegt, beperk je wat het model kan doen. Het kan de trainingsdata niet langer zo nauw passen als het wil. Die beperking introduceert bias — het model maakt opzettelijk licht verkeerde aannames, omdat je hebt opgedragen om simpel te blijven.

Maar diezelfde beperking verlaagt de variantie. Een model dat niet elk datapunt kan passen, is minder gevoelig voor de specifieke samples waarop het is getraind. Als je het op een iets andere dataset traint, krijg je een vergelijkbaar resultaat. Die stabiliteit is precies wat je wilt, zodat je model niet faalt in productie.

Zonder regularisatie krijg je een zeer flexibel model met lage bias (maakt weinig aannames en past de trainingsdata goed) en hoge variantie (kleine veranderingen in de trainingsdata leveren heel andere modellen op, wat betekent dat het niet te vertrouwen is op nieuwe data).

Regularisatie draait om het verschuiven van de balans. Iets meer bias in ruil voor veel minder variantie leidt meestal tot betere prestaties op data die het model nog niet heeft gezien. Dat is het compromis, en het is bijna altijd de moeite waard.

De regularisatiesterkte kiezen

Als machine learning-practicus moet je de regularisatiesterkte instellen nadat je het type regularisatie hebt gekozen.

Die sterkte wordt bepaald door een hyperparameter — meestal lambda (λ) in wiskundige notatie, of alpha in scikit-learn. Het is de vermenigvuldigingsfactor vóór de strafterm. Als je die verandert, verander je hoe hard het model richting eenvoud wordt geduwd.

Als je er in beide richtingen naast zit, krijg je een probleem in productie:

• Te laag: de straf is te zwak om effect te hebben. Het model overfit, net alsof je geen regularisatie had.
• Te hoog: de straf is de dominante factor. Het model is zo beperkt dat het echte patronen in de data niet kan begrijpen. Dat is underfitting.

De juiste waarde ligt ergens tussenin, en er is geen universeel antwoord. Het hangt af van je data, je model en hoeveel ruis je hebt.

De standaardmanier om die te vinden is cross-validatie. Je splitst je trainingsdata in folds, traint het model op elke combinatie van folds en meet de validatieprestatie over een reeks alpha-waarden. De waarde die de beste gemiddelde validatiescore geeft, is degene die je gebruikt.

In scikit-learn kunnen RidgeCV en LassoCV dit automatisch doen — ze voeren cross-validatie uit over een raster van alpha-waarden en selecteren de beste voor je.

from sklearn.linear_model import RidgeCV

model = RidgeCV(alphas=[0.01, 0.1, 1.0, 10.0], cv=5)
model.fit(X_train, y_train)

print(model.alpha_)

De geprinte alpha laat je de beste waarde zien die met cross-validatie is gevonden. Begin met een brede reeks waarden en verfijn zodra je weet waar het optimale gebied ligt.

Conclusie

Regularisatie is hoe je voorkomt dat een model té slim is voor zijn eigen bestwil.

Het bestraft complexiteit, waardoor het model wordt gedwongen om oplossingen te vinden die generaliseren in plaats van alleen trainingsdata te memoriseren. L2 houdt al je features, maar verkleint hun invloed. L1 verwijdert irrelevante features. Elastic Net combineert beide. En bij lineaire modellen, logistische regressie, neurale netwerken en ensemblemodellen duikt hetzelfde idee op in verschillende vormen, en het heet niet altijd “regularisatie”.

Het belangrijkst is de techniek die je kiest en de sterkte die je instelt. Dus wat je moet doen, is experimenteren. Probeer verschillende benaderingen met verschillende parameterwaarden. Kies niet één optie en ga door.

Je data vertelt je wat werkt.

Als je meer regularisatietechnieken in actie wilt zien, schrijf je dan in voor onze Machine Learning Scientist in Python-track. Die bevat 85 uur aan materiaal waarmee je job-ready wordt.