Kärntricket: RBF-, polynom- och sigmoidkärnor
Ni kommer att tillämpa RBF- och polynomkärnor på en icke-linjärt separerbar datamängd och förstå att kärnor implicit projicerar data till högre dimensioner.
Kärntricket: RBF-, polynom- och sigmoidkärnor är en gratis lektion i Machine Learning Academy på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Machine Learning Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Machine Learning Academy innehåller totalt 4 lektioner.
Problemet: Icke-linjära data
Många klassificeringsproblem i verkligheten är inte linjärt separerbara — ingen rät linje (eller hyperplan) kan separera klasserna korrekt. Data som ligger i koncentriska ringar kan till exempel inte separeras av någon linjär gräns. Ett sätt är att manuellt skapa nya särdrag (t.ex. x², x×y) som gör klasserna linjärt separerbara i det utökade rummet. Kärntricket gör detta automatiskt och implicit, utan att någonsin beräkna koordinaterna i det högdimensionella rummet.
Feature-avbildningar: Lyft data till högre dimensioner
En feature-avbildning φ(x) omvandlar en indatavektor till en representation med högre dimension. Till exempel avbildar φ([x₁, x₂]) = [x₁², √2·x₁x₂, x₂²] tvådimensionella data till tre dimensioner. Efter denna avbildning kan klasser som överlappade i 2D bli linjärt separerbara i 3D. SVM hittar sedan ett hyperplan med maximal marginal i det transformerade rummet. Den motsvarande beslutsgränsen i det ursprungliga 2D-rummet är en kurva, vilket ger SVM förmåga till icke-linjär klassificering.
Kärntricket: Undvik explicita feature-avbildningar
Att beräkna φ(x) explicit är dyrt eller till och med omöjligt (vissa feature-avbildningar ger vektorer med oändligt många dimensioner). Den centrala insikten är att SVM:s duala formulering bara behöver skalärprodukter φ(xᵢ)·φ(xⱼ), inte de enskilda feature-vektorerna. En kärnfunktion K(xᵢ, xⱼ) beräknar denna skalärprodukt direkt från de ursprungliga indata, utan att någonsin konstruera φ(xᵢ). Detta är kärntricket: dyra skalärprodukter i högdimensionella rum beräknas billigt i indatarummet.
Polynomkärna
Polynomkärnan definieras som K(xᵢ, xⱼ) = (γ · xᵢ·xⱼ + r)^d, där d är polynomgraden, γ är en skalningsfaktor och r är parametern coef0. En polynomkärna av grad 2 skapar implicit alla parvisa interaktioner (x₁x₂) och kvadrerade termer (x₁²). Högre grader skapar mer komplexa gränser men medför risk för överanpassning. I scikit-learn använder Ni 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-kärnan: Det självklara arbetsverktyget
Radial Basis Function-kärnan (RBF-kärnan), även kallad den gaussiska kärnan, definieras som K(xᵢ, xⱼ) = exp(-γ · ||xᵢ - xⱼ||²). Den mäter likhet baserat på avstånd: närliggande punkter har ett kärnvärde nära 1 och avlägsna punkter ett värde nära 0. RBF-kärnan motsvarar en feature-avbildning med oändligt många dimensioner, vilket ger SVM obegränsad uttrycksförmåga. Den är standardkärnan i scikit-learns SVC och fungerar bra på de flesta dataset när C och γ ställs in 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-parametern i RBF-kärnan
Parametern gamma styr hur långt inflytandet från ett enskilt träningsexempel sträcker sig. Ett lågt gamma gör att varje punkts inflytande sträcker sig långt — beslutsgränsen blir jämn och modellen underanpassar (hög bias). Ett högt gamma gör att inflytandet avtar kraftigt — gränsen omsluter enskilda träningspunkter tätt (hög varians, överanpassning). Standardvärden i scikit-learn: gamma='scale' (använder 1/(n_features × X.var())) eller gamma='auto' (använder 1/n_features). Ställ alltid in C och gamma tillsammans.
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}')Sigmoidkärna
Sigmoidkärnan är K(xᵢ, xⱼ) = tanh(γ · xᵢ·xⱼ + r), vilket liknar aktiveringsfunktionen i ett neuronnät med två lager. Den är inte alltid en giltig (positivt semidefinit) kärna för alla parametervärden, vilket innebär att SVM-optimeringen kanske inte konvergerar till ett globalt minimum. Sigmoidkärnan är sällan det bästa valet i praktiken — RBF överträffar den nästan alltid — men den kan vara användbar när tolkbarheten hos analogin med neuronnät värderas högt.
Att välja kärna i praktiken
En praktisk vägledning för val av kärna: använd linjär när Ni har många särdrag (text, genomik) eller när data redan är högdimensionella — det är onödigt att lägga till fler dimensioner med kärnor; använd RBF som standard för tabulära data med låg till medelhög dimension — den är mest flexibel och ofta bäst; använd polynom när Ni har konkreta skäl att tro att polynomiska särdragsinteraktioner är viktiga; undvik sigmoid om Ni inte experimenterar. Jämför alltid kärnorna med korsvalidering på Ert specifika dataset.
Komplexitet och skalbarhet hos kärn-SVM
Den största svagheten hos kärn-SVM är skalbarheten. Träningen kräver att ett kvadratiskt programmeringsproblem löses, vilket skalas som O(n²) till O(n³) med avseende på antalet träningsexempel. För 100 000 exempel kan en RBF-SVM ta timmar eller få slut på minne. Lösningar: (1) använd LinearSVC för linjära kärnor, vilket skalar till miljontals exempel; (2) använd approximativa kärnmetoder som Nystroem eller RBFSampler, som skapar explicita feature-avbildningar med låg dimension; (3) byt till gradient boosting eller neuronnät för verkligt stora dataset.
Jämföra kärnor på samma dataset
Det korrekta sättet att välja kärna är att jämföra dem alla med korsvalidering på Ert dataset. Olika dataset föredrar olika kärnor. Ett linjärt separerbart problem får ingen fördel av RBF. Ett problem med komplex lokal struktur kan behöva RBF med högt gamma. Börja alltid med den linjära kärnan som baslinje och prova sedan RBF med en grid search över C och gamma. Om ingen av dem presterar märkbart bättre än den andra, väljer Ni linjär kärna för tolkbarhet och snabbhet.
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 sats och giltiga kärnor
Alla funktioner kan inte användas som kärnor. En giltig kärna måste uppfylla Mercers villkor: den måste vara symmetrisk (K(x,y) = K(y,x)) och ge en positivt semidefinit Gram-matris för varje uppsättning indata. Detta garanterar att kärnan motsvarar en giltig skalärprodukt i något feature-rum, vilket gör SVM-optimeringsproblemet konvext (ett globalt minimum). Egna kärnor för DNA-sekvenser, grafer eller text kan definieras och skickas till SVC(kernel='precomputed'), så länge de uppfyller Mercers sats.
Snabbtest
Testa Er förståelse av kärntricket från den här lektionen.
Sammanfattning av lektionen
I den här lektionen har Ni lärt Er: att kärnfunktioner implicit beräknar skalärprodukter i högdimensionella feature-rum, att RBF-kärnan är den mest mångsidiga standardkärnan och att gamma styr påverkningsradien och att kärn-SVM inte skalar till stora dataset, så överväg linjära kärnor eller approximativa metoder först. Härnäst utforskar vi hur C och gamma ställs in samtidigt med en grid search.
Lär dig Python med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 30
- Lektioner
- 120
Vanliga frågor
Är lektionen ”Kärntricket: RBF-, polynom- och sigmoidkärnor” gratis?
Ja – hela texten till ”Kärntricket: RBF-, polynom- och sigmoidkärnor” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Machine Learning Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Machine Learning Academy innehåller totalt 4 lektioner.
Vad lär jag mig i ”Kärntricket: RBF-, polynom- och sigmoidkärnor”?
Ni kommer att tillämpa RBF- och polynomkärnor på en icke-linjärt separerbar datamängd och förstå att kärnor implicit projicerar data till högre dimensioner. Ni övar på Machine Learning Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Machine Learning Academy?
Du behöver inga förkunskaper. Utbildningen i Machine Learning Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.
Hur lång tid tar lektionen ”Kärntricket: RBF-, polynom- och sigmoidkärnor”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Machine Learning Academy-lektionen?
Ja. Varje Machine Learning Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Klassificerare med maximal marginal: stödvektorer och hyperplan
- SVM med mjuk marginal och parametern C
- Kärntricket: RBF-, polynom- och sigmoidkärnor
- Justera C och gamma med en rutnätsökning