SVM med soft margin og parameteren C
Observer, hvordan en større C reducerer marginens bredde og straffer fejlklassifikationer, mens en lille C tillader flere overtrædelser og giver en bredere, mere robust margin.
SVM med soft margin og parameteren C er en gratis Machine Learning Academy-lektion på CoddyKit. Dette er lektion 2 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 med hårde marginer
SVM'en med hård margin kræver, at hvert træningseksempel klassificeres korrekt med en margin på mindst 1, så der ikke er plads til fejl. I praksis er virkelige datasæt næsten aldrig perfekt lineært separable. Støj, forkert mærkede eksempler og ægte overlap mellem klasser betyder, at en hård margin enten er umulig at opfylde eller resulterer i en grænse, der forvrides så meget for at undgå enhver overtrædelse, at den overtilpasser træningsdataene. Vi har brug for en principiel måde at tillade nogle fejl på, samtidig med at marginen maksimeres.
Slack-variabler: Tilladelse af overtrædelser
SVM'en med blød margin introducerer slack-variabler ξᵢ ≥ 0 (xi, udtales 'ksi'), én for hvert træningseksempel, som måler, hvor meget et punkt overtræder marginen. Hvis ξᵢ = 0, er punktet klassificeret korrekt uden for marginen. Hvis 0 < ξᵢ < 1, ligger punktet inden for marginen, men er klassificeret korrekt. Hvis ξᵢ > 1, er punktet fejlklassificeret. Den nye målfunktion minimerer ||w||²/2 + C × Σξᵢ og afvejer marginens bredde mod den samlede overtrædelse.
C-parameteren: Straf for overtrædelser
C er regulariseringsstraffen: den styrer, hvor hårdt SVM'en straffer hver marginovertrædelse. En stor C giver en hård straf og tvinger modellen til at fejlklassificere så få punkter som muligt på bekostning af en smallere margin – det giver lav bias og høj varians (risiko for overtilpasning). En lille C accepterer flere overtrædelser til gengæld for en bredere og glattere margin – det giver højere bias og lavere varians (større robusthed over for støj). Du skal bruge krydsvalidering for at finde den rigtige C.
Visualisering af effekten af C
Med en meget lille C (f.eks. 0,001) producerer SVM'en en bred margin med mange fejlklassificerede træningspunkter – grænsen er glat og generaliserer godt, men underfitter, hvis dataene er tydeligt separable. Med en meget stor C (f.eks. 1000) bøjer grænsen sig for at klassificere næsten hvert træningspunkt korrekt, hvilket giver en smal margin, der kan overfitte. Den optimale C ligger mellem disse yderpunkter. Denne afvejning svarer til bias-varians-afvejningen i alle regulariserede modeller.
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
import numpy as np
X, y = load_breast_cancer(return_X_y=True)
for C in [0.001, 0.01, 0.1, 1, 10, 100]:
model = make_pipeline(StandardScaler(), SVC(kernel='linear', C=C))
score = cross_val_score(model, X, y, cv=5).mean()
print(f'C={C:6}: CV accuracy={score:.4f}')Antal støttevektorer kontra C
Når C falder (mere regularisering, bredere margin), overtræder flere træningseksempler marginen og bliver støttevektorer. Når C stiger (mindre regularisering, smallere margin), ligger færre eksempler på eller inden for marginen, så der er brug for færre støttevektorer. Du kan se dette ved at undersøge svm.n_support_. En model med mange støttevektorer er afhængig af flere træningseksempler for at definere sin grænse – den er typisk mere robust, men også mere kompleks.
from sklearn.svm import SVC
from sklearn.datasets import load_breast_cancer
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
import numpy as np
X, y = load_breast_cancer(return_X_y=True)
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
for C in [0.01, 0.1, 1, 10, 100]:
svm = SVC(kernel='linear', C=C).fit(X_scaled, y)
print(f'C={C:5}: support vectors = {svm.n_support_}, total = {sum(svm.n_support_)}')Hinge-tab: SVM'ens tabsfunktion
SVM'en med blød margin minimerer hinge-tabet: max(0, 1 - y × (w·x + b)) for hvert træningseksempel plus L2-regulariseringstermen ||w||²/(2C). Hinge-tabet er nul, når et punkt er korrekt klassificeret uden for marginen (punktet 'har intet tab'). Når et punkt bevæger sig mod eller over grænsen, vokser tabet lineært. Det gør SVM'er mindre følsomme over for afvigere end tab baseret på kvadrerede fejl, som ville straffe meget forkerte forudsigelser kvadratisk.
import numpy as np
# Hinge loss for a single example: y in {-1, +1}, score = decision function value
def hinge_loss(y, score):
return max(0, 1 - y * score)
# Correctly classified, far beyond margin
print('Correct, margin=2:', hinge_loss(1, 3)) # 0
# Inside margin, still correct
print('Inside margin:', hinge_loss(1, 0.5)) # 0.5
# Misclassified
print('Misclassified:', hinge_loss(1, -1)) # 2LinearSVC til store datasæt
scikit-learn leverer LinearSVC som et hurtigere alternativ til SVC(kernel='linear') til store datasæt. Den bruger LIBLINEAR-optimeringsalgoritmen (primalt eller dualt koordinatfald) i stedet for LIBSVM's kvadratiske programmeringsløser. For datasæt med titusindvis af eksempler kan LinearSVC være 10-100 gange hurtigere og samtidig give næsten identiske resultater. Den understøtter ikke predict_proba() direkte, men du kan anvende Platt-skalering via CalibratedClassifierCV.
from sklearn.svm import LinearSVC
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)
model = make_pipeline(StandardScaler(), LinearSVC(C=1.0, max_iter=5000))
scores = cross_val_score(model, X, y, cv=5)
print('LinearSVC CV:', scores.mean().round(4), '+/-', scores.std().round(4))Valg af C: Strategi for gittersøgning
Den optimale C-værdi spænder over mange størrelsesordener, så søg altid på en logaritmisk skala: [0.0001, 0.001, 0.01, 0.1, 1, 10, 100, 1000]. Lineær afstand mellem værdier overser det vigtige område med små værdier. Brug GridSearchCV med 5-dobbelt CV til at evaluere hver C. Specifikt for SVM er søgningen endimensional (eller todimensional med gamma for RBF-kernen), så den er beregningsmæssigt overkommelig selv med et fint gitter.
from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.datasets import load_breast_cancer
import numpy as np
X, y = load_breast_cancer(return_X_y=True)
model = make_pipeline(StandardScaler(), SVC(kernel='linear'))
param_grid = {'svc__C': np.logspace(-3, 3, 7)}
grid = GridSearchCV(model, param_grid, cv=5)
grid.fit(X, y)
print('Best C:', grid.best_params_['svc__C'])
print('Best CV score:', round(grid.best_score_, 4))Blød margin med ikke-lineære kerner
Begrebet blød margin gælder også for ikke-lineære kerner (RBF, polynomielle kerner). Når du bruger en RBF-kerne, styrer C stadig tolerancen for marginovertrædelser, men grænsen kan nu være en krum overflade i det oprindelige inputrum. En lille C med en RBF-kerne skaber en meget glat, næsten cirkulær grænse. En stor C med en lille gamma skaber en ekstremt kompleks grænse, der følger hver træningsklynge tæt. Begge yderpunkter overfitter på hver sin måde.
Opsummering og intuition for blød margin
Tænk på SVM'en med blød margin som en afvejning, du kan justere. Skru op for C: modellen bliver aggressiv, straffer enhver overtrædelse og gør marginen smallere for at tilpasse sig træningsdataene. Skru ned for C: modellen bliver mere eftergivende, accepterer overtrædelser, gør marginen bredere og prioriterer generalisering. Den rigtige C er den, der skaber den balance, dit specifikke datasæt har brug for. Dette gælder ikke kun SVM'er – regularisering findes også i ridge-regression (alpha), logistisk regression (C) og neurale netværk (weight decay), hvor der altid afvejes bias mod varians.
Sammenligning af SVM og logistisk regression
Både logistisk regression og SVM'en med blød margin finder lineære beslutningsgrænser, men de optimerer forskellige tabsfunktioner. Logistisk regression minimerer log-tab, som straffer alle fejlklassifikationer kontinuerligt. SVM'en minimerer hinge-tab, som er nul for korrekt klassificerede punkter uden for marginen og lineært for overtrædelser. I praksis gælder følgende: SVM'er klarer sig ofte bedre end logistisk regression på datasæt med få dimensioner og tydelige marginer, mens logistisk regression foretrækkes, når der er brug for velkalibrerede sandsynlighedsestimater, eller når datasættet er stort (millioner af eksempler), hvor den er hurtigere at træne.
from sklearn.svm import SVC
from sklearn.linear_model import LogisticRegression
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 name, model in [('SVM', SVC(kernel='linear', C=1.0)), ('LogReg', LogisticRegression(max_iter=1000))]:
pipe = make_pipeline(StandardScaler(), model)
score = cross_val_score(pipe, X, y, cv=5).mean()
print(f'{name}: CV accuracy={score:.4f}')Hurtigt tjek
Test din forståelse af SVM'en med blød margin og C-parameteren fra denne lektion.
Opsummering af lektionen
I denne lektion lærte du: soft-margin-SVM'en tillader kontrollerede marginoverskridelser via slack-variabler, C er regulariseringsstraffen, der afvejer marginens bredde mod træningsfejl, og du skal altid søge efter C på en logaritmisk skala ved hjælp af krydsvalidering. Næste gang udforsker vi kernel-tricket, som udvider SVM'er til ikke-lineære grænser.
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 “SVM med soft margin og parameteren C” gratis?
Ja — hele teksten til “SVM med soft margin og parameteren C” 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 “SVM med soft margin og parameteren C”?
Observer, hvordan en større C reducerer marginens bredde og straffer fejlklassifikationer, mens en lille C tillader flere overtrædelser og giver en bredere, mere robust margin. 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 2 af 4.
Hvor lang tid tager lektionen “SVM med soft margin og parameteren C”?
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