SVM Hyperparameters begrijpen

Introductie

Deze handleiding is het tweede deel van drie handleidingen over Support Vector Machines (SVM's). In deze gids zullen we blijven werken aan de use case van vervalste bankbiljetten, begrijpen welke SVM-parameters al zijn ingesteld door Scikit-learn, wat C- en Gamma-hyperparameters zijn en hoe ze kunnen worden afgestemd met behulp van kruisvalidatie en rasterzoeken.

In de complete serie SVM-gidsen leert u naast SVM-hyperparameters ook over eenvoudige SVM, een concept dat de kernel trucen verken andere soorten SVM's.

Als u alle gidsen wilt lezen, de eerste gids wilt bekijken of wilt zien welke u het meest interesseert, vindt u hieronder de tabel met onderwerpen die in elke gids worden behandeld:

1. SVM en Kernel SVM implementeren met Scikit-Learn van Python

• Use case: vergeet bankbiljetten
• Achtergrond van SVM's
• Eenvoudig (lineair) SVM-model
  • Over de gegevensset
  • De gegevensset importeren
  • De dataset verkennen
• SVM implementeren met Scikit-Learn
  • Gegevens verdelen in trein-/testsets
  • Het model trainen
  • Voorspellingen doen
  • Het model evalueren
  • Resultaten interpreteren

2. SVM Hyperparameters begrijpen

• De C-hyperparameter
• De Gamma-hyperparameter

3. Andere SVM-smaken implementeren met Scikit-Learn van Python (binnenkort beschikbaar!)

• Het algemene idee van SVM's (een samenvatting)
• Kernel (truc) SVM
• Implementatie van niet-lineaire kernel SVM met Scikit-Learn
• Bibliotheken importeren
  • De dataset importeren
  • Gegevens verdelen in kenmerken (X) en doel (y)
  • Gegevens verdelen in trein-/testsets
  • Het algoritme trainen
• Polynoom kernel
  • Voorspellingen doen
  • Het algoritme evalueren
• Gauss-kernel
  • Voorspelling en evaluatie
• Sigmoïde kernel
  • Voorspelling en evaluatie
• Vergelijking van niet-lineaire kernelprestaties

Laten we leren hoe we kruisvalidatie kunnen implementeren en hyperparameterafstemming kunnen uitvoeren.

SVM-hyperparameters

Om alle modelparameters te zien die al zijn ingesteld door Scikit-learn en de standaardwaarden ervan, kunnen we de get_params() methode:

svc.get_params()

Deze methode geeft weer:

{'C': 1.0, 'break_ties': False, 'cache_size': 200, 'class_weight': None, 'coef0': 0.0, 'decision_function_shape': 'ovr', 'degree': 3, 'gamma': 'scale', 'kernel': 'linear', 'max_iter': -1, 'probability': False, 'random_state': None, 'shrinking': True, 'tol': 0.001, 'verbose': False}

Merk op dat er in totaal al 15 hyperparameters worden ingesteld, dit gebeurt omdat het SVM-algoritme veel variaties heeft. We hebben de lineaire kernel gebruikt om een ​​lineaire functie te verkrijgen, maar er zijn ook kernels die andere soorten functies beschrijven en die kernels zijn op verschillende manieren geparametriseerd.

Deze variaties maken het model flexibeler en geschikter voor het vinden van een scheiding tussen verschillende vormen van gegevens. Als we een lijn kunnen trekken om onze klassen te scheiden, dan a lineaire kern zal een goede optie zijn, als we een bocht nodig hebben, dan a veelterm kernel is misschien de beste keuze, als onze gegevens ronde vormen hebben, dan a Radiale basisfunctie or RBF kernel past beter bij de gegevens als er waarden boven en onder een drempel zijn, a sigmoïde kernel zou de klassen beter kunnen scheiden. Uit wat we in onze gegevens hebben onderzocht, lijkt het erop dat een RBF of een polynomiale kernel geschikter zou zijn dan een lineaire kernel.

Nu we een idee hebben dat er 4 soorten verschillende kernelfuncties zijn, kunnen we teruggaan naar de parameters. Wanneer het SVM-algoritme een scheiding tussen klassen probeert te vinden, hebben we al begrepen dat het een classificatie trekt marge tussen de steunvectoren en de scheidingslijn (of kromme).

Deze marge is in zekere zin als een buffer tussen de scheidingslijn en de punten. De margegrootte kan variëren, wanneer de marge is kleinere, is er minder ruimte voor punten die buiten de marge vallen, waardoor de scheiding tussen klassen duidelijker wordt, dus er worden meer steekproeven correct geclassificeerd, omgekeerd, wanneer de marge is groter, is de scheiding tussen klassen minder duidelijk en kunnen er meer voorbeelden zijn verkeerd geclassificeerd. Met andere woorden, een kleinere marge betekent meer correct geclassificeerde monsters, en ook een meer stijf classifier, terwijl een grotere marge, duidt op meer verkeerd geclassificeerde monsters, maar een meer flexibel classificeerder.

Wanneer die marges worden gekozen, is de parameter die ze bepaalt de C parameter.

De C-hyperparameter

De C parameter omgekeerd evenredig is met de margegrootte, dit betekent dat de groter de waarde van C kleinere de marge, en omgekeerd, de kleinere de waarde van C groter de marge. De C parameter kan samen met elke kernel worden gebruikt, het vertelt het algoritme hoeveel het moet voorkomen dat elk trainingsvoorbeeld verkeerd wordt geclassificeerd, daarom staat het ook bekend als regularisatie. Onze lineaire kernel SVM heeft een C van 1.0, wat een Groot waarde en geeft een kleinere marge.

We kunnen experimenteren met a kleinere waarde van 'C' en in de praktijk begrijpen wat er met a gebeurt grotere marge. Om dat te doen, zullen we een nieuwe classificatie maken, svc_cen wijzig alleen de waarde van C naar 0.0001. Laten we ook de herhalen fit en predict stappen:

svc_c = SVC(kernel='linear', C=0.0001)
svc_c.fit(X_train, y_train)
y_pred_c = svc_c.predict(X_test)

Nu kunnen we de resultaten voor de testgegevens bekijken:

print(classification_report(y_test, y_pred_c)) cm_c = confusion_matrix(y_test, y_pred_c)
sns.heatmap(cm_c, annot=True, fmt='d').set_title('Confusion matrix of linear SVM with C=0.0001')

Dit levert op:

 precision recall f1-score support 0 0.82 0.96 0.88 148 1 0.94 0.76 0.84 127 accuracy 0.87 275 macro avg 0.88 0.86 0.86 275
weighted avg 0.88 0.87 0.86 275

Door een kleinere te gebruiken C en het verkrijgen van een grotere marge, is de classificator flexibeler geworden en met meer classificatiefouten. In het classificatierapport kunnen we zien dat de f1-score, voorheen 0.99 voor beide klassen, is verlaagd naar 0.88 voor klasse 0 en naar 0.84 voor klasse 1. In de verwarringsmatrix ging het model van 2 naar 6 fout-positieven en van 2 naar 31 fout-negatieven.

We kunnen ook herhalen predict stap en bekijk de resultaten om te controleren of er nog steeds een overfit is bij het gebruik van treingegevens:

y_pred_ct = svc_c.predict(X_train) cm_ct = confusion_matrix(y_train, y_pred_ct)
sns.heatmap(cm_ct, annot=True, fmt='d').set_title('Confusion matrix of linear SVM with C=0.0001 and train data') print(classification_report(y_train, y_pred_ct))

Dit resulteert in:

 precision recall f1-score support 0 0.88 0.96 0.92 614 1 0.94 0.84 0.88 483 accuracy 0.90 1097 macro avg 0.91 0.90 0.90 1097
weighted avg 0.91 0.90 0.90 1097

Door de resultaten met een kleinere te bekijken C en treingegevens, kunnen we zien dat er een verbetering was in de overfit, maar zodra de meeste statistieken nog steeds hoger zijn voor treingegevens, lijkt het erop dat de overfit niet is opgelost. Dus, gewoon veranderen van de C parameter was niet genoeg om het model flexibeler te maken en de generalisatie ervan te verbeteren.

Tot nu toe hebben we de marges in SVM begrepen en hoe deze het algehele resultaat van het algoritme beïnvloeden, maar hoe zit het met de lijn (of curve) die de klassen scheidt? Deze lijn is de beslissingsgrens. We weten dus al dat de marges een impact hebben op de flexibiliteit van de beslissingsgrens ten opzichte van fouten, we kunnen nu kijken naar een andere parameter die ook van invloed is op de beslissingsgrens.

De Gamma-hyperparameter

Er kunnen oneindige beslissingsgrenzen worden gekozen, sommige van die grenzen scheiden de klassen en andere niet. Moeten bij het kiezen van een effectieve beslissingsgrens rekening worden gehouden met de eerste 10 dichtstbijzijnde punten van elke klasse? Of moeten er meer punten worden overwogen, ook de punten die ver weg zijn? In SVM wordt die bereikkeuze bepaald door een andere hyperparameter, gamma.

Like C, gamma is enigszins omgekeerd evenredig met de afstand. De hoger de waarde ervan, de dichtstbijzijnde zijn de punten die in aanmerking worden genomen voor de beslissingsgrens, en de laagste de gamma verder punten worden ook overwogen voor het kiezen van de beslissingsgrens.

Een ander effect van gamma is dat hoe hoger de waarde, hoe meer de reikwijdte van de beslissingsgrens dichter bij de punten eromheen komt, waardoor het grilliger wordt en vatbaarder voor overfit - en hoe lager de waarde, hoe vloeiender en regelmatiger de beslissingsgrens. oppervlak wordt ook minder vatbaar voor overfit. Dit geldt voor elk hypervlak, maar kan gemakkelijker worden waargenomen bij het scheiden van gegevens in hogere dimensies. In sommige documentatie, gamma kan ook worden aangeduid als sigma.

In het geval van ons model is de standaardwaarde van gamma was scale. Zoals te zien is in de Scikit-learn SVC-documentatie, betekent dit dat de waarde ervan is:

$$
gamma = (1/ tekst{n_features} * X.var())
$$

or

$$
gamma = (1/ text{number_of_features} * text{features_variantie})
$$

In ons geval moeten we de variantie van berekenen X_train, vermenigvuldig het met 4 en deel het resultaat door 1. We kunnen dit doen met de volgende code:

number_of_features = X_train.shape[1] features_variance = X_train.values.var()
gamma = 1/(number_of_features * features_variance)
print('gamma:', gamma)

Dit levert op:

gamma: 0.013924748072859962

Er is ook een andere manier om naar de waarde van te kijken gamma, door toegang te krijgen tot het object van de classificator gamma parameter met ._gamma:

svc._gamma 

We kunnen zien dat de gamma gebruikt in onze classifier was laag, dus er werd ook rekening gehouden met verder weg gelegen punten.

Er is geen regel voor het kiezen van waarden voor hyperparameters, zoals C en gamma - het zal afhangen van hoe lang en welke bronnen beschikbaar zijn voor het experimenteren met verschillende hyperparameterwaarden, welke transformaties in de gegevens kunnen worden aangebracht en welke resultaten worden verwacht . De gebruikelijke manier om naar de hyperparameterwaarden te zoeken, is door elk van de voorgestelde waarden te combineren via a grid zoeken samen met een procedure die die hyperparameterwaarden toepast en statistieken verkrijgt voor verschillende delen van de aangeroepen gegevens kruisvalidatie. In Scikit-learn is dit al geïmplementeerd als de GridSearchCV (CV van kruisvalidatie) methode.

Om een ​​rasterzoekopdracht met kruisvalidatie uit te voeren, moeten we het GridSearchCV, definieer een woordenboek met de waarden van hyperparameters waarmee wordt geëxperimenteerd, zoals het type van kernel, het assortiment voor CEn voor gamma, maak een instantie van de SVC, definieer de score of metric zal worden gebruikt voor evaluatie (hier zullen we ervoor kiezen om te optimaliseren voor zowel precisie als recall, dus we zullen gebruiken f1-score), het aantal onderverdelingen dat wordt gemaakt in de gegevens voor het uitvoeren van de zoekopdracht cv – de standaardwaarde is 5, maar het is een goede gewoonte om er minimaal 10 te gebruiken – hier gebruiken we 5 gegevensvouwen om het duidelijker te maken bij het vergelijken van resultaten.

De GridSearchCV een fit methode die onze treingegevens ontvangt en verder splitst in trein- en testsets voor de kruisvalidatie. We kunnen instellen return_train_score om de resultaten te vergelijken en te garanderen dat er geen overfit is.

Dit is de code voor de rasterzoekopdracht met kruisvalidatie:

from sklearn.model_selection import GridSearchCV parameters_dictionary = {'kernel':['linear', 'rbf'], 'C':[0.0001, 1, 10], 'gamma':[1, 10, 100]}
svc = SVC() grid_search = GridSearchCV(svc, parameters_dictionary, scoring = 'f1', return_train_score=True, cv = 5, verbose = 1) grid_search.fit(X_train, y_train)

Deze code geeft het volgende weer:

Fitting 5 folds for each of 18 candidates, totalling 90 fits
# and a clickable GridSeachCV object schema

Nadat we de hyperparameter-zoekopdracht hebben uitgevoerd, kunnen we de best_estimator_, best_params_ en best_score_ eigenschappen om het beste model, parameterwaarden en hoogste f1-score te verkrijgen:

best_model = grid_search.best_estimator_
best_parameters = grid_search.best_params_
best_f1 = grid_search.best_score_ print('The best model was:', best_model)
print('The best parameter values were:', best_parameters)
print('The best f1-score was:', best_f1)

Dit resulteert in:

The best model was: SVC(C=1, gamma=1)
The best parameter values were: {'C': 1, 'gamma': 1, 'kernel': 'rbf'}
The best f1-score was: 0.9979166666666666

Onze aanvankelijke gok bevestigend door naar de gegevens te kijken, heeft het beste model geen lineaire kernel, maar een niet-lineaire, RBF.

Te gebruiken zowel C en gamma hebben de waarde 1, en de f1-score is erg hoog, 0.99. Aangezien de waarde hoog is, laten we eens kijken of er sprake was van een overfit door te gluren naar de gemiddelde test- en treinscores die we hebben geretourneerd, in de cv_results_ voorwerp:

gs_mean_test_scores = grid_search.cv_results_['mean_test_score']
gs_mean_train_scores = grid_search.cv_results_['mean_train_score'] print("The mean test f1-scores were:", gs_mean_test_scores)
print("The mean train f1-scores were:", gs_mean_train_scores)

De gemiddelde scores waren:

The mean test f1-scores were: [0.78017291 0. 0.78017291 0. 0.78017291 0. 0.98865407 0.99791667 0.98865407 0.76553515 0.98865407 0.040291 0.98656 0.99791667 0.98656 0.79182565 0.98656 0.09443985] The mean train f1-scores were: [0.78443424 0. 0.78443424 0. 0.78443424 0. 0.98762683 1. 0.98762683 1. 0.98762683 1. 0.98942923 1. 0.98942923 1. 0.98942923 1. ]

Door naar de gemiddelde scores te kijken, kunnen we zien dat de hoogste, 0.99791667 twee keer voorkomt, en in beide gevallen was de score in treingegevens 1. Dit geeft aan dat de overfit aanhoudt. Vanaf hier zou het interessant zijn om terug te gaan naar de gegevensvoorbereiding en te begrijpen of het zinvol is om de gegevens te normaliseren, een ander type gegevenstransformatie uit te voeren en ook nieuwe functies te creëren met functie-engineering.

We hebben zojuist een techniek gezien om de hyperparameters van het model te vinden, en we hebben al iets gezegd over lineaire scheidbaarheid, ondersteuningsvectoren, beslissingsgrenzen, maximalisatie van marges en kerneltruc. SVM is een complex algoritme, meestal met veel wiskundige concepten en kleine tweakbare onderdelen die moeten worden aangepast om als geheel samen te komen.

Laten we combineren wat we tot nu toe hebben gezien, een samenvatting maken van hoe alle onderdelen van SVM werken, en dan kijken naar enkele van de andere kernelimplementaties samen met hun resultaten.

Conclusie

In dit artikel begrepen we de standaardparameters achter de SVM-implementatie van Scikit-Learn. We begrepen wat C- en Gamma-parameters zijn, en hoe het wijzigen van elk van hen van invloed kan zijn op het SVM-model.

We leerden ook over rasterzoeken om te zoeken naar de beste C- en Gamma-waarden, en om kruisvalidatie te gebruiken om onze resultaten beter te generaliseren en te garanderen dat er geen enkele vorm van gegevenslekkage is.

Het uitvoeren van een hyperparameterafstemming met rasterzoekopdracht en kruisvalidatie is een gebruikelijke praktijk in datawetenschap, dus ik raad u ten zeerste aan de technieken te implementeren, de code uit te voeren en de verbanden te zien tussen de hyperparameterwaarden en de veranderingen in SVM-voorspellingen.

• Door SEO aangedreven content en PR-distributie. Word vandaag nog versterkt.
• Platoblockchain. Web3 Metaverse Intelligentie. Kennis versterkt. Toegang hier.
• De toekomst slaan met Adryenn Ashley. Toegang hier.
• Bron: https://stackabuse.com/understanding-svm-hyperparameters/