Kerneltruc uitgelegd: hoe SVM’s niet-lineaire patronen leren

Lineaire modellen zijn eenvoudig en intuïtief, maar ze falen zodra je data niet lineair scheidbaar is.

En de meeste real-world data is dat niet. Hoe je de gewichten ook afstelt, een rechte beslissingsgrens past niet goed - de klassen overlappen of vormen patronen die geen enkele lijn zonder fouten kan splitsen. Als je weet dat het model te simpel is voor de taak, maar niet meteen naar een neuraal netwerk wilt grijpen, is er een mooi midden.

Support Vector Machines bieden één “truc”. Je projecteert je data in een hoger-dimensionale ruimte, en wat onscheidbaar leek, wordt vaak wel scheidbaar. De kerneltruc is een computationele snelkoppeling die kernelgebaseerde modellen zoals SVM’s laat werken alsof de data getransformeerd is, zonder die transformatie ooit expliciet uit te voeren.

In dit artikel leer je precies hoe de kerneltruc binnen SVM’s werkt, welke kernelfuncties je moet kennen, en wanneer kernelmethoden de moeite waard zijn.

Maar wat is SVM precies? Lees onze blogpost over Support Vector Machines met Scikit-learn om alles te leren over het algoritme en hoe je het toepast.

Wat is de kerneltruc?

De kerneltruc is een methode om inproducten te berekenen in een hoger-dimensionale feature-ruimte zonder de data daar expliciet naartoe te mappen.

Je transformeert je datapunten dus niet echt om er daarna mee te rekenen. Je berekent wat het resultaat van die berekening zou zijn, met een kernelfunctie die direct op de originele inputs werkt.

Onthoud dat de kerneltruc alleen geldt voor modellen die steunen op inproducten tussen datapunten. Het is geen algemene ML-techniek. Als een model intern geen inproducten gebruikt, is de kerneltruc niet van toepassing. De meeste modellen gebruiken het niet.

SVM’s, gaussian processes en kernel-PCA zijn een paar goede voorbeelden waar deze kerneltruc wel werkt. Laat niemand je wijsmaken dat dit iets is “wat de meeste ML-modellen gebruiken”.

Waarom de kerneltruc bestaat

Lineaire modellen kunnen alleen lineaire beslissingsgrenzen leren. Dat is hun harde beperking, en het maakt ze ook begrijpelijk en interpreteerbaar.

Maar de meeste datasets uit de praktijk zijn niet lineair scheidbaar. Er bestaat geen rechte lijn (of hypervlak) die de klassen netjes splitst. Met de kerneltruc kan dezelfde data wel scheidbaar worden als je haar projecteert in een hoger-dimensionale ruimte.

De voor de hand liggende aanpak is om de data expliciet te transformeren door nieuwe features te maken, elk punt naar de hoger-dimensionale ruimte te mappen, en je model daar te trainen. Dat werkt, maar de kosten schalen mee. Als je naar een ruimte met duizenden dimensies mappt, wordt het opslaan en rekenen op die getransformeerde vectoren duur.

Met de kerneltruc bereken je in plaats daarvan niet voor elk datapunt de volledige transformatie φ(x), maar bereken je K(x, x′) - een kernelfunctie die je direct hetzelfde inproductresultaat geeft.

De kerneltruc in Support Vector Machines

Een SVM vindt de beslissingsgrens die de marge tussen twee klassen maximaliseert.

Om die grens te vinden, lost de SVM een optimalisatieprobleem op. En in de duale vorm hangt de optimalisatie alleen af van inproducten tussen datapunten, niet van de datapunten zelf. De duale doelstelling ziet er zo uit:

Duale doelfunctie

Waar α_i de geleerde gewichten zijn, y_i de klasse-labels, en ⟨x_i, x_j⟩ het inproduct tussen twee datapunten. SVM heeft alleen de paarsgewijze overeenkomsten tussen de datapunten nodig.

Als de SVM alleen inproducten nodig heeft, hoef je die niet uit de oorspronkelijke ruimte aan te leveren. Je vervangt ⟨x_i, x_j⟩ door een kernelfunctie K(x_i, x_j):

Formule met kernelfunctie

De SVM draait verder precies hetzelfde. Hij denkt alleen dat hij in een rijkere feature-ruimte werkt.

En dat is waar de kerneltruc om draait.

Hoe de kerneltruc werkt (conceptueel)

De standaardaanpak is om een mapping φ(x) te definiëren die elk datapunt transformeert naar een hoger-dimensionale ruimte, en daar vervolgens inproducten te berekenen:

De mapping

Maar φ(x) expliciet berekenen kan duur zijn, en in sommige gevallen heeft de gemapte ruimte duizenden of zelfs oneindig veel dimensies.

De kerneltruc slaat die stap over.

In plaats van φ(x) te berekenen en dan het inproduct te nemen, bereken je direct K(x, x′) - een kernelfunctie die voldoet aan:

Berekening met kernelfunctie

Het resultaat is identiek, maar de kosten zijn lager.

Zie K(x, x′) als een similariteitsfunctie. Hij neemt twee datapunten in de oorspronkelijke ruimte en geeft een getal terug dat aangeeft hoe vergelijkbaar ze zijn - maar dan op een manier die overeenkomt met vergelijken in een veel rijkere ruimte. Het model gedraagt zich alsof de data getransformeerd is. Dat is alleen nooit gebeurd.

Veelvoorkomende kernelfuncties

Niet alle kernelfuncties werken hetzelfde. Elke functie definieert een andere notie van similariteit tussen datapunten, wat betekent dat elke functie een ander soort beslissingsgrens oplevert. Ik laat je er een paar zien.

Lineaire kernel

Lineaire kernel

De lineaire kernel is gewoon een standaard inproduct. Het model blijft in de oorspronkelijke feature-ruimte en leert een lineaire grens, wat het equivalent maakt aan een standaard lineaire SVM.

Gebruik deze kernel wanneer je data al lineair scheidbaar is. Het is de snelste optie en het makkelijkst te interpreteren.

Polynomiale kernel

Polynomiale kernel

Waar c een constante is en d de graad van het polynoom.

De polynomiale kernel vangt interacties tussen features. Een graad-2 kernel beschouwt bijvoorbeeld alle paarsgewijze featurecombinaties. Zo kan het model gebogen grenzen leren zonder dat jij die interactietermen handmatig hoeft te maken.

Hogere graden betekenen expressievere grenzen, maar ook meer risico op overfitting.

RBF (Gaussiaanse) kernel

RBF-kernel

De RBF (Radial Basis Function) kernel is in de praktijk de meest gebruikte kernel. Hij meet similariteit op basis van afstand. Twee punten die dicht bij elkaar liggen, krijgen een hoge score; twee punten die ver uit elkaar liggen, krijgen een score dicht bij nul.

Interessant is dat hij data impliciet mappt naar een oneindig-dimensionale ruimte. Dit geeft genoeg flexibiliteit om complexe, niet-lineaire grenzen te begrijpen die andere kernels niet aankunnen.

Sigmoïde kernel

Sigmoïde kernel

De sigmoïde kernel wordt minder vaak gebruikt dan RBF- of polynomiale kernels, en voldoet niet altijd aan de wiskundige voorwaarden voor een geldige kernelfunctie, afhankelijk van de parameterkeuze.

Hij duikt af en toe op in oudere literatuur, maar in de praktijk is RBF bijna altijd een beter startpunt.

Kerneltruc buiten SVM

SVM is het meest voorkomende algoritme voor de kerneltruc, maar niet het enige.

Een paar andere modellen gebruiken hetzelfde idee:

• Kernel ridge regression past ridge-regressie toe in een hoger-dimensionale ruimte met een kernelfunctie in plaats van expliciete features
• Gaussian processes gebruiken kernelfuncties om covariantie tussen datapunten te definiëren. De kernel encodeert aannames over de gladheid en vorm van de functie die je probeert te leren
• Kernel-PCA breidt standaard PCA uit naar niet-lineaire structuren door hoofdcomponenten te vinden in een getransformeerde feature-ruimte

Bij al deze modellen heeft het model alleen inproducten nodig, dus kun je een kernelfunctie invoegen en niet-lineair gedrag krijgen zonder de rest van de wiskunde te veranderen.

Maar SVM blijft het duidelijkste voorbeeld, en de beste plek om je intuïtie op te bouwen.

Kerneltruc vs. feature engineering

Beide aanpakken lossen het probleem op dat je features niet expressief genoeg zijn. Maar ze doen dat op een andere manier.

Met feature engineering maak je expliciet nieuwe features uit de bestaande. Je bepaalt welke combinaties ertoe doen, berekent ze, voegt ze toe aan je dataset en traint op de uitgebreide featureset. Je ziet precies wat er in het model is gegaan.

De kerneltruc werkt impliciet in een hoger-dimensionale ruimte zonder dat je die extra features ooit definieert of opslaat. De transformatie wordt beschreven door de kernelfunctie.

De afweging komt neer op interpreteerbaarheid versus flexibiliteit.

Feature engineering houdt dingen transparant, want je weet wat elke feature voorstelt. De kerneltruc geeft je meer expressieve mogelijkheden, maar de impliciete feature-ruimte is vaak lastig te inspecteren of uit te leggen.

Als interpreteerbaarheid belangrijk is voor je use case, is feature engineering de veiligere keuze. Als je complexe patronen moet begrijpen en niet elke beslissing van het model hoeft te verklaren, brengt de kerneltruc je sneller waar je wilt zijn.

Voordelen van de kerneltruc

Het meest voor de hand liggende voordeel is dat het lineaire modellen niet-lineaire grenzen laat leren. Zonder dit kan een SVM alleen klassen scheiden met een recht hypervlak. Met de truc kan hetzelfde model gebogen, complexe beslissingsgrenzen aan.

Het vermijdt ook de kosten van expliciete hoog-dimensionale berekeningen. Je krijgt de expressieve kracht van een rijkere feature-ruimte zonder die extra dimensies op te slaan of te berekenen. Voor problemen waarbij de impliciete feature-ruimte duizenden of oneindig veel dimensies heeft, is dit wat de aanpak überhaupt mogelijk maakt.

Kernelmethoden werken ook vaak goed op datasets van middelgrote omvang. Als je geen miljoenen voorbeelden hebt maar je data niet lineair scheidbaar is, is een SVM met een goede kernel vaak een solide, betrouwbare keuze.

Beperkingen van de kerneltruc

Het grootste probleem is schaal. Het trainen van een kernel-SVM vereist het berekenen van K(x_i, x_j) voor elk paar datapunten. Dat is een O(n²)-operatie - en het wordt nog erger als je geheugen meerekent. Op grote datasets kan dit een harde bottleneck worden.

De kernelkeuze is ook niet triviaal. RBF is een goede standaard, maar niet altijd de juiste. De verkeerde kernel - of de verkeerde hyperparameters voor een kernel - kiezen kan resulteren in slechtere prestaties dan waarmee je begon.

Interpretatie is een ander punt. Met feature engineering weet je wat elke feature betekent. Met de kerneltruc is de impliciete feature-ruimte niet duidelijk. Het model werkt, maar uitleggen waarom het een specifieke beslissing nam, is lastig.

En in veel domeinen heeft deep learning simpelweg de overhand. Neurale netwerken kunnen grote datasets aan, leren hun eigen featurerepresentaties en presteren vaak beter dan kernelmethoden zonder handmatig een kernel te hoeven kiezen. Voor beeldclassificatie, NLP of elke taak met enorme hoeveelheden data zijn kernelmethoden zelden nog de eerste keuze.

Wanneer kernelmethoden gebruiken

Kernelmethoden zijn in 2026 niet verouderd, maar wel specialistischer geworden dan vroeger.

Je kiest voor een kernelmethode zoals een SVM met een RBF-kernel wanneer:

• Je data een niet-lineaire structuur heeft die een lineair model niet begrijpt
• Je dataset is klein tot middelgroot - denk aan duizenden samples, niet miljoenen
• Je hoeft individuele voorspellingen niet uit te leggen, dus lagere interpreteerbaarheid is een acceptabele trade-off

Ze passen goed bij gestructureerde, tabelvormige data wanneer je beperkte data hebt en een model nodig hebt dat goed generaliseert zonder veel tuning. In die gevallen kan een kernel-SVM nog steeds beter presteren dan complexere modellen.

Maar als je dataset groot is, of je voorspelbaarheid wilt kunnen uitleggen, zijn kernelmethoden niet de beste oplossing.

Voorbeeld: SVM met en zonder kernel

De beste manier om te zien wat de kerneltruc doet, is een lineaire SVM zien falen, en hem dan repareren met een kernel.

In het onderstaande voorbeeld heb je een eenvoudige dataset met twee concentrische cirkels, waarbij één klasse een binnenring vormt en de andere een buitenring. Er is geen rechte lijn die ze kan scheiden. Een lineaire SVM zal elke keer falen

Met een RBF-kernel tekent dezelfde SVM een cirkelvormige grens die de klassen scheidt. Het enige dat is veranderd, is de kernelfunctie.

Hier is het volledige voorbeeld:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.svm import SVC
from sklearn.datasets import make_circles

# Generate concentric circles dataset
np.random.seed(42)
X, y = make_circles(n_samples=300, noise=0.1, factor=0.4)

# Train both SVMs
svm_linear = SVC(kernel="linear", C=1)
svm_rbf = SVC(kernel="rbf", C=1, gamma="scale")
svm_linear.fit(X, y)
svm_rbf.fit(X, y)

print(f"Linear SVM accuracy: {svm_linear.score(X, y):.0%}")
print(f"RBF SVM accuracy:    {svm_rbf.score(X, y):.0%}")

Nauwkeurigheid lineaire versus RBF-SVM

De lineaire SVM trekt een rechte grens door het midden van de data. Hij splitst het vlak in twee helften, wat totaal niet past bij de werkelijke structuur van het probleem. De RBF-kernel daarentegen levert een cirkelvormige grens die de vorm van de data volgt.

Lineaire versus RBF-SVM gevisualiseerd

Kortom, het model leerde geen complexere structuur - het werkte gewoon in een ruimte waar de structuur eenvoudiger te vinden was.

Veelvoorkomende misvattingen over de kerneltruc

Er zijn een paar misvattingen over de kerneltruc die vaak genoeg opduiken, dus laat me ze hier adresseren.

"De kerneltruc werkt voor alle modellen." Dat is niet zo. De kerneltruc geldt alleen voor modellen die in hun optimalisatie steunen op inproducten tussen datapunten. De meeste modellen - decision trees, random forests, neurale netwerken, lineaire regressie - gebruiken inproducten niet op die manier, dus de kerneltruc is daar niet van toepassing.

"Het transformeert de data letterlijk." Niet expliciet. Je oorspronkelijke datapunten blijven precies zoals ze zijn. De kernelfunctie berekent wat het inproduct zou zijn in een hoger-dimensionale ruimte, maar er vindt in de praktijk geen transformatie plaats. De data wordt nooit uitgebreid of anders opgeslagen.

"Het verbetert altijd de prestaties." Dat hangt ervan af. Bij niet-lineaire problemen met kleine tot middelgrote datasets kan een goede kernel het verschil maken. Bij grote datasets weegt de rekenkost vaak zwaarder dan het voordeel. En als je data al lineair scheidbaar is, voegt een kernel alleen maar complexiteit toe.

Waarom de kerneltruc nog steeds ertoe doet

De kerneltruc is momenteel niet het meest besproken idee in ML. Deep learning voert op de meeste benchmarks de boventoon, en kernelmethoden zie je zelden.

Maar het blijft een fundamenteel concept dat de moeite waard is om te begrijpen.

SVM’s en de kerneltruc waren centraal binnen klassieke ML omdat ze goed werken op gestructureerde, tabelvormige data met beperkte samples, en de onderliggende wiskunde schoon en goed begrepen is. Als je wilt begrijpen hoe similariteitsgebaseerd leren werkt, of waarom inproducten ertoe doen in optimalisatie, is de kerneltruc een van de duidelijkste voorbeelden om te bestuderen.

Het heeft ook nog steeds echte toepassingen. Kleine datasets, gespecialiseerde domeinen zoals bio-informatica of tekstclassificatie met handgemaakte features, en problemen waarbij je een model nodig hebt dat goed generaliseert zonder veel data - dat zijn gebieden waar kernelmethoden nog relevant zijn.

De kernel is verdrongen in domeinen waar schaal en rauwe datavolume het meest tellen. In de juiste context is het nog steeds een goed gereedschap.

Conclusie

De kerneltruc lost een specifiek probleem op: hoe je niet-lineair gedrag krijgt uit een model dat alleen met inproducten kan werken. Het antwoord is om die inproducten te vervangen door een kernelfunctie die in een rijkere feature-ruimte hetzelfde resultaat berekent - zonder daar daadwerkelijk naartoe te gaan.

Het is het nuttigst om te begrijpen in de context van SVM’s, waar de duale formulering de substitutie netjes en expliciet maakt. Als je dat eenmaal snapt, gaat de bredere familie van kernelmethoden veel meer logisch aanvoelen.

Deep learning krijgt tegenwoordig de meeste aandacht, en voor grootschalige problemen is dat terecht. Maar de kerneltruc vertegenwoordigt een andere manier van denken - gebaseerd op geometrie en similariteit. Het is de moeite waard om te begrijpen, maar tenzij je in een gespecialiseerd veld werkt, zal je het in de praktijk zelden gebruiken.

Maar waarom heeft deep learning precies de overhand gekregen? Schrijf je in voor onze Deep Learning in Python track om te zien hoe neurale netwerken je in staat stellen complexe modellen op schaal te bouwen.