Kerneltricket: RBF-, polynomielle og sigmoidkerneler
Anvend RBF- og polynomielle kerneler på et datasæt, der ikke kan separeres lineært, og forstå, at kerneler implicit projicerer data til højere dimensioner.
Kerneltricket: RBF-, polynomielle og sigmoidkerneler er en gratis Machine Learning Academy-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Machine Learning Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Machine Learning Academy-kurset indeholder 4 lektioner i alt.
Problemet: Ikke-lineære data
Mange klassifikationsproblemer fra den virkelige verden kan ikke separeres lineært — ingen lige linje (eller hyperplan) kan adskille klasserne korrekt. Data arrangeret i koncentriske ringe kan for eksempel ikke adskilles af nogen lineær grænse. En tilgang er manuelt at oprette nye features (f.eks. x², x×y), som gør klasserne lineært separable i det udvidede rum. Kernel-tricket gør dette automatisk og implicit uden nogensinde at beregne koordinaterne i det højdimensionelle rum.
Feature-maps: Løft af data til højere dimensioner
En feature-map φ(x) transformerer en inputvektor til en repræsentation med flere dimensioner. For eksempel afbilder φ([x₁, x₂]) = [x₁², √2·x₁x₂, x₂²] 2D-data til 3D. Efter denne afbildning kan klasser, der overlappede i 2D, blive lineært separable i 3D. SVM'en finder derefter et hyperplan med maksimal margin i det transformerede rum. Den tilsvarende beslutningsgrænse i det oprindelige 2D-rum er en kurve, hvilket giver SVM'en evnen til ikke-lineær klassifikation.
Kernel-tricket: Undgå eksplicitte feature-maps
Det er dyrt eller endda umuligt at beregne φ(x) eksplicit (nogle feature-maps producerer vektorer med uendelig mange dimensioner). Den centrale indsigt er, at SVM'ens duale formulering kun behøver prikprodukter φ(xᵢ)·φ(xⱼ), ikke de individuelle feature-vektorer. En kernelfunktion K(xᵢ, xⱼ) beregner dette prikprodukt direkte ud fra de oprindelige input uden nogensinde at konstruere φ(xᵢ). Det er kernel-tricket: dyre prikprodukter i højdimensionelle rum beregnes billigt i inputrummet.
Polynomiel kernel
Den polynomielle kernel er defineret som K(xᵢ, xⱼ) = (γ · xᵢ·xⱼ + r)^d, hvor d er polynomiets grad, γ er en skaleringsfaktor, og r er parameteren coef0. En polynomiel kernel af grad 2 opretter implicit alle parvise interaktioner (x₁x₂) og kvadrerede led (x₁²). Højere grader skaber mere komplekse grænser, men medfører risiko for overtilpasning. I scikit-learn skal du bruge SVC(kernel='poly', degree=3).
from sklearn.svm import SVC
from sklearn.datasets import make_moons
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
X, y = make_moons(n_samples=300, noise=0.15, random_state=42)
for degree in [2, 3, 5]:
model = make_pipeline(StandardScaler(), SVC(kernel='poly', degree=degree, C=5))
score = cross_val_score(model, X, y, cv=5).mean()
print(f'Polynomial degree={degree}: CV accuracy={score:.4f}')RBF-kernel: Den standardmæssige arbejdshest
Den radiale basisfunktionskernel (RBF-kernel), også kaldet den gaussiske kernel, er defineret som K(xᵢ, xⱼ) = exp(-γ · ||xᵢ - xⱼ||²). Den måler lighed ud fra afstand: nærliggende punkter har en kernelværdi tæt på 1, mens fjerne punkter har en værdi tæt på 0. RBF-kernen svarer til en feature-map med uendeligt mange dimensioner, hvilket giver SVM'en ubegrænset udtrykskraft. Den er standardkernen i scikit-learns SVC og fungerer godt på de fleste datasæt, når C og γ indstilles korrekt.
from sklearn.svm import SVC
from sklearn.datasets import make_moons
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
X, y = make_moons(n_samples=300, noise=0.15, random_state=42)
model = make_pipeline(StandardScaler(), SVC(kernel='rbf', C=1.0, gamma='scale'))
scores = cross_val_score(model, X, y, cv=5)
print('RBF SVM CV accuracy:', round(scores.mean(), 4))Gamma-parameteren i RBF-kernen
Parameteren gamma styrer, hvor langt indflydelsen fra et enkelt træningseksempel rækker. En lille gamma får hvert punkts indflydelse til at række langt — beslutningsgrænsen bliver glat, og modellen underpasser (høj bias). En stor gamma får indflydelsen til at aftage brat — grænsen lægger sig tæt omkring de enkelte træningspunkter (høj varians, overtilpasning). Standardværdier i scikit-learn: gamma='scale' (bruger 1/(n_features × X.var())) eller gamma='auto' (bruger 1/n_features). Du skal altid indstille C og gamma sammen.
from sklearn.svm import SVC
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
X, y = load_breast_cancer(return_X_y=True)
for gamma in [0.0001, 0.001, 0.01, 0.1, 1]:
model = make_pipeline(StandardScaler(), SVC(kernel='rbf', C=10, gamma=gamma))
score = cross_val_score(model, X, y, cv=5).mean()
print(f'gamma={gamma}: CV accuracy={score:.4f}')Sigmoid-kernel
Den sigmoidale kernel er K(xᵢ, xⱼ) = tanh(γ · xᵢ·xⱼ + r), som minder om aktiveringsfunktionen i et neuralt netværk med to lag. Den er ikke altid en gyldig (positiv semidefinit) kernel for alle parameterværdier, hvilket betyder, at SVM-optimeringen muligvis ikke konvergerer til et globalt minimum. Den sigmoidale kernel er sjældent det bedste valg i praksis — RBF overgår den næsten altid — men den kan være nyttig, når fortolkningen gennem analogien til neurale netværk er vigtig.
Valg af kernel i praksis
En praktisk vejledning til valg af kernel: Brug lineær, når du har mange features (tekst, genomik), eller når dataene allerede har mange dimensioner — det er unødvendigt at tilføje flere dimensioner via kernels. Brug RBF som standard til tabeldata med få til mellemange dimensioner — den er mest fleksibel og ofte bedst. Brug polynomiel, når du har en konkret grund til at tro, at polynomielle feature-interaktioner er vigtige. Undgå sigmoid, medmindre du eksperimenterer. Sammenlign altid kernels med krydsvalidering på dit specifikke datasæt.
Kompleksitet og skalerbarhed for kernel-SVM
Den største svaghed ved kernel-SVM'er er skalerbarheden. Træning kræver løsning af et kvadratisk programmeringsproblem, der skalerer som O(n²) til O(n³) i antallet af træningseksempler. For 100.000 eksempler kan en RBF-SVM tage flere timer eller løbe tør for hukommelse. Løsninger: (1) Brug LinearSVC til lineære kernels, da den skalerer til millioner af eksempler. (2) Brug approksimative kernelmetoder som Nystroem eller RBFSampler, der opretter eksplicitte feature-maps med få dimensioner. (3) Skift til gradient boosting eller neurale netværk ved virkelig store datasæt.
Sammenligning af kernels på det samme datasæt
Den korrekte måde at vælge en kernel på er at sammenligne dem alle med krydsvalidering på dit datasæt. Forskellige datasæt favoriserer forskellige kernels. Et lineært separabelt problem får ingen fordel af RBF. Et problem med kompleks lokal struktur kan have brug for RBF med høj gamma. Start altid med den lineære kernel som baseline, og prøv derefter RBF med en gittersøgning over C og gamma. Hvis ingen af dem klarer sig væsentligt bedre end den anden, skal du vælge lineær af hensyn til fortolkning og hastighed.
from sklearn.svm import SVC
from sklearn.datasets import load_digits
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
X, y = load_digits(return_X_y=True)
for kernel in ['linear', 'poly', 'rbf']:
model = make_pipeline(StandardScaler(), SVC(kernel=kernel, C=10))
score = cross_val_score(model, X, y, cv=3).mean()
print(f'Kernel={kernel:8s}: CV accuracy={score:.4f}')Mercers sætning og gyldige kernels
Ikke enhver funktion kan bruges som kernel. En gyldig kernel skal opfylde Mercers betingelse: Den skal være symmetrisk (K(x,y) = K(y,x)) og producere en positiv semidefinit Gram-matrix for ethvert sæt input. Det garanterer, at kernen svarer til et gyldigt prikprodukt i et feature-rum, så SVM-optimeringsproblemet bliver konvekst (ét globalt minimum). Brugerdefinerede kernels til DNA-sekvenser, grafer eller tekst kan defineres og sendes til SVC(kernel='precomputed'), så længe de opfylder Mercers sætning.
Hurtigt tjek
Test din forståelse af kernel-tricket fra denne lektion.
Opsummering af lektionen
I denne lektion lærte du: kernelfunktioner beregner implicit prikprodukter i højdimensionelle feature-rum, RBF-kernen er den mest alsidige standardkernel, hvor gamma styrer indflydelsesradius, og kernel-SVM'er skalerer ikke til store datasæt, så overvej lineære kernels eller approksimative metoder først. Næste gang udforsker vi samtidig indstilling af C og gamma med en gittersøgning.
Lær Python med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 30
- Lektioner
- 120
Ofte stillede spørgsmål
Er lektionen “Kerneltricket: RBF-, polynomielle og sigmoidkerneler” gratis?
Ja — hele teksten til “Kerneltricket: RBF-, polynomielle og sigmoidkerneler” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Machine Learning Academy-kurset, skal du opgradere til CoddyKit PRO. Machine Learning Academy-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Kerneltricket: RBF-, polynomielle og sigmoidkerneler”?
Anvend RBF- og polynomielle kerneler på et datasæt, der ikke kan separeres lineært, og forstå, at kerneler implicit projicerer data til højere dimensioner. Du øver dig i Machine Learning Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Machine Learning Academy?
Der kræves ingen tidligere erfaring. Machine Learning Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.
Hvor lang tid tager lektionen “Kerneltricket: RBF-, polynomielle og sigmoidkerneler”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Machine Learning Academy-lektion?
Ja. Alle Machine Learning Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Klassifikator med maksimal margin: Supportvektorer og hyperplan
- SVM med soft margin og parameteren C
- Kerneltricket: RBF-, polynomielle og sigmoidkerneler
- Justering af C og gamma med en netsøgning