Andere SVM-smaken implementeren met Scikit-Learn van Python

Introductie

Deze handleiding is het derde en laatste deel van drie handleidingen over Support Vector Machines (SVM's). In deze gids zullen we blijven werken met de use case van vervalste bankbiljetten, een korte samenvatting geven van het algemene idee achter SVM's, begrijpen wat de kerneltruc is en verschillende soorten niet-lineaire kernels implementeren met Scikit-Learn.

In de complete serie SVM-gidsen leert u niet alleen over andere soorten SVM's, maar ook over eenvoudige SVM, vooraf gedefinieerde SVM-parameters, C- en Gamma-hyperparameters en hoe deze kunnen worden afgestemd met zoeken naar rasters en kruisvalidatie.

Als u de vorige gidsen wilt lezen, kunt u de eerste twee gidsen bekijken of kijken welke onderwerpen u het meest interesseren. Hieronder vindt u 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

• Het algemene idee van SVM's (een samenvatting)
• Kernel (truc) SVM
• Niet-lineaire kernel-SVM implementeren met Scikit-Learn
• Bibliotheken importeren
  • De gegevensset 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 onthouden waar SVM om draait voordat we enkele interessante SVM-kernelvariaties zien.

Het algemene idee van SVM's

In het geval van lineair scheidbare gegevens in twee dimensies (zoals getoond in Fig. 1) zou de typische machine learning-algoritmebenadering zijn om te proberen een grens te vinden die de gegevens zodanig verdeelt dat de misclassificatiefout wordt geminimaliseerd. Als je goed naar figuur 1 kijkt, zie je dat er verschillende grenzen (oneindig) kunnen zijn die de gegevenspunten correct verdelen. De twee stippellijnen en de ononderbroken lijn zijn allemaal geldige classificaties van de gegevens.

Fig 1: Meerdere beslissingsgrenzen

Wanneer SVM kiest voor de beslissingsgrens, kiest het een grens die de afstand tussen zichzelf en de dichtstbijzijnde datapunten van de klassen maximaliseert. We weten al dat de dichtstbijzijnde datapunten de steunvectoren zijn en dat de afstand beide kan worden geparametriseerd C en gamma hyperparameters.

Bij het berekenen van die beslissingsgrens kiest het algoritme hoeveel punten er moeten worden overwogen en hoe ver de marge kan gaan - dit vormt een margemaximalisatieprobleem. Bij het oplossen van dat margemaximalisatieprobleem gebruikt SVM de ondersteuningsvectoren (zoals te zien in Fig. 2) en probeert te achterhalen wat optimale waarden zijn die de margeafstand groter houden, terwijl meer punten correct worden geclassificeerd volgens de functie die wordt gebruikt om de gegevens scheiden.

Fig 2: Beslissingsgrens met ondersteuningsvectoren

Dit is de reden waarom SVM verschilt van andere classificatie-algoritmen, aangezien het niet alleen een beslissingsgrens vindt, maar uiteindelijk de optimale beslissingsgrens vindt.

Er is complexe wiskunde afgeleid van statistiek en rekenmethoden betrokken bij het vinden van de ondersteuningsvectoren, het berekenen van de marge tussen de beslissingsgrens en de ondersteuningsvectoren, en het maximaliseren van die marge. Deze keer gaan we niet in op de details van hoe de wiskunde uitpakt.

Het is altijd belangrijk om dieper te duiken en ervoor te zorgen dat machine learning-algoritmen geen mysterieuze spreuk zijn, hoewel het feit dat je op dit moment niet elk wiskundig detail kende, je er niet van weerhield het algoritme uit te voeren en resultaten te verkrijgen.

Kernel (truc) SVM

In de vorige sectie hebben we het algemene idee van SVM onthouden en georganiseerd - we hebben gezien hoe het kan worden gebruikt om de optimale beslissingsgrens te vinden voor lineair scheidbare gegevens. In het geval van niet-lineair scheidbare gegevens, zoals die getoond in Fig. 3, weten we echter al dat een rechte lijn niet kan worden gebruikt als beslissingsgrens.

Fig 3: niet-lineair scheidbare gegevens

In plaats daarvan kunnen we de gewijzigde versie van SVM gebruiken die we in het begin hadden besproken, genaamd Kernel SVM.

In wezen zal de kernel-SVM de niet-lineair scheidbare gegevens van lagere dimensies projecteren naar de overeenkomstige vorm in hogere dimensies. Dit is een truc, want bij het projecteren van niet-lineair scheidbare gegevens in hogere dimensies verandert de vorm van de gegevens zodanig dat ze scheidbaar worden. Als we bijvoorbeeld denken aan 3 dimensies, kunnen de gegevenspunten van elke klasse uiteindelijk worden toegewezen aan een andere dimensie, waardoor deze scheidbaar wordt. Een manier om de gegevensdimensies te vergroten, is door deze te exponentiëren. Nogmaals, hier komt complexe wiskunde bij kijken, maar u hoeft zich daar geen zorgen over te maken om SVM te gebruiken. In plaats daarvan kunnen we de Scikit-Learn-bibliotheek van Python gebruiken om de niet-lineaire kernels op dezelfde manier te implementeren en te gebruiken als de lineaire.

Niet-lineaire kernel-SVM implementeren met Scikit-Learn

In deze sectie zullen we dezelfde dataset gebruiken om te voorspellen of een bankbiljet echt of vervalst is volgens de vier kenmerken die we al kennen.

U zult zien dat de rest van de stappen typische machine learning-stappen zijn en heel weinig uitleg nodig hebben totdat we het deel bereiken waar we onze niet-lineaire kernel-SVM's trainen.

Bibliotheken importeren

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
from sklearn.model_selection import train_test_split

De gegevensset importeren

data_link = "https://archive.ics.uci.edu/ml/machine-learning-databases/00267/data_banknote_authentication.txt"
col_names = ["variance", "skewness", "curtosis", "entropy", "class"] bankdata = pd.read_csv(data_link, names=col_names, sep=",", header=None)
bankdata.head()mes)

Gegevens verdelen in kenmerken (X) en doel (y)

X = bankdata.drop('class', axis=1)
y = bankdata['class']

Gegevens verdelen in trein-/testsets

SEED = 42 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20, random_state = SEED)

Het algoritme trainen

Om de kernel SVM te trainen, zullen we hetzelfde gebruiken SVC klasse van de Scikit-Learn's svm bibliotheek. Het verschil zit hem in de waarde voor de kernelparameter van het SVC klasse.

In het geval van de eenvoudige SVM hebben we "lineair" gebruikt als waarde voor de kernelparameter. Zoals we eerder hebben vermeld, kunnen we voor kernel-SVM echter Gaussiaanse, polynoom-, sigmoïde- of berekenbare kernels gebruiken. We zullen polynomiale, Gaussische en sigmoïde kernels implementeren en kijken naar de uiteindelijke statistieken om te zien welke lijkt te passen bij onze klassen met een hogere metriek.

1. Polynoomkernel

In de algebra is een polynoom een ​​uitdrukking van de vorm:

$$
2a*b^3 + 4a – 9
$$

Dit heeft variabelen, zoals a en b, constanten, in ons voorbeeld, 9 en coëfficiënten (constanten vergezeld van variabelen), zoals 2 en 4. De 3 wordt beschouwd als de graad van het polynoom.

Er zijn soorten gegevens die het best kunnen worden beschreven bij het gebruik van een polynoomfunctie. Hier zal de kernel onze gegevens toewijzen aan een polynoom waarvan we de graad zullen kiezen. Hoe hoger de graad, hoe meer de functie zal proberen dichter bij de gegevens te komen, dus de beslissingsgrens is flexibeler (en vatbaarder voor overfit) - hoe lager de graad, hoe minder flexibel.

Dus voor de uitvoering van de polynoom kernel, naast het kiezen van de poly kernel, geven we ook een waarde door voor de degree parameter van de SVC klas. Hieronder staat de code:

from sklearn.svm import SVC
svc_poly = SVC(kernel='poly', degree=8)
svc_poly.fit(X_train, y_train)

Voorspellingen doen

Nu we het algoritme hebben getraind, is de volgende stap het doen van voorspellingen op basis van de testgegevens.

Zoals we eerder hebben gedaan, kunnen we het volgende script uitvoeren om dit te doen:

y_pred_poly = svclassifier.predict(X_test)

Het algoritme evalueren

Zoals gewoonlijk is de laatste stap het maken van evaluaties op de polynoomkernel. Aangezien we de code voor het classificatierapport en de verwarringsmatrix een paar keer hebben herhaald, gaan we deze omzetten in een functie die display_results na ontvangst van de respectieven y_test, y_pred en titel van de verwarringsmatrix van Seaborn met cm_title:

def display_results(y_test, y_pred, cm_title): cm = confusion_matrix(y_test,y_pred) sns.heatmap(cm, annot=True, fmt='d').set_title(cm_title) print(classification_report(y_test,y_pred))

Nu kunnen we de functie aanroepen en kijken naar de resultaten verkregen met de polynoomkernel:

cm_title_poly = "Confusion matrix with polynomial kernel"
display_results(y_test, y_pred_poly, cm_title_poly)

De uitvoer ziet er zo uit:

 precision recall f1-score support 0 0.69 1.00 0.81 148 1 1.00 0.46 0.63 127 accuracy 0.75 275 macro avg 0.84 0.73 0.72 275
weighted avg 0.83 0.75 0.73 275

Nu kunnen we dezelfde stappen herhalen voor Gaussiaanse en sigmoïde kernels.

2. Gaussische kernel

Om de gaussische kernel te gebruiken, hoeven we alleen 'rbf' op te geven als waarde voor de kernel parameter van de SVC-klasse:

svc_gaussian = SVC(kernel='rbf', degree=8)
svc_gaussian.fit(X_train, y_train)

Bij het verder verkennen van deze kernel kun je ook rasterzoeken gebruiken om het met verschillende te combineren C en gamma waarden.

Voorspelling en evaluatie

y_pred_gaussian = svc_gaussian.predict(X_test)

cm_title_gaussian = "Confusion matrix with Gaussian kernel"
display_results(y_test, y_pred_gaussian, cm_title_gaussian)

De uitvoer van de Gaussiaanse kernel SVM ziet er als volgt uit:

 precision recall f1-score support 0 1.00 1.00 1.00 148 1 1.00 1.00 1.00 127 accuracy 1.00 275 macro avg 1.00 1.00 1.00 275
weighted avg 1.00 1.00 1.00 275

3. Sigmoïde kernel

Laten we tot slot een sigmoïde kernel gebruiken voor het implementeren van Kernel SVM. Kijk eens naar het volgende script:

svc_sigmoid = SVC(kernel='sigmoid')
svc_sigmoid.fit(X_train, y_train)

Om de sigmoid-kernel te gebruiken, moet u 'sigmoid' specificeren als waarde voor de kernel parameter van de SVC klasse.

Voorspelling en evaluatie

y_pred_sigmoid = svc_sigmoid.predict(X_test)

cm_title_sigmoid = "Confusion matrix with Sigmoid kernel"
display_results(y_test, y_pred_sigmoid, cm_title_sigmoid)

De uitvoer van de Kernel SVM met Sigmoid-kernel ziet er als volgt uit:

 precision recall f1-score support 0 0.67 0.71 0.69 148 1 0.64 0.59 0.61 127 accuracy 0.65 275 macro avg 0.65 0.65 0.65 275
weighted avg 0.65 0.65 0.65 275

Vergelijking van niet-lineaire kernelprestaties

Als we kort de prestaties van de verschillende soorten niet-lineaire kernels vergelijken, lijkt het erop dat de sigmoïde kernel de laagste statistieken heeft, dus de slechtste prestatie.

Van de Gauss- en polynoomkernels kunnen we zien dat de Gaussiaanse kernel een perfect voorspellingspercentage van 100% behaalde - wat meestal verdacht is en kan duiden op een overfit, terwijl de polynoomkernel 68 instanties van klasse 1 verkeerd classificeerde.

Daarom is er geen vaste regel over welke kernel het beste presteert in elk scenario of in ons huidige scenario zonder verder te zoeken naar hyperparameters, inzicht te krijgen in elke functievorm, de gegevens te onderzoeken en trein- en testresultaten te vergelijken om te zien of het algoritme is aan het generaliseren.

Het draait allemaal om het testen van alle kernels en het selecteren van degene met de combinatie van parameters en gegevensvoorbereiding die de verwachte resultaten opleveren in overeenstemming met de context van uw project.

Verder gaan - Hand-held end-to-end project

Je leergierige karakter maakt dat je verder wilt gaan? We raden aan om onze Begeleid project: "Hands-on huizenprijsvoorspelling - machinaal leren in Python".

In dit begeleide project leer je hoe je krachtige traditionele machine learning-modellen en deep learning-modellen bouwt, Ensemble Learning gebruikt en meta-leerlingen traint om huizenprijzen te voorspellen uit een zak met Scikit-Learn- en Keras-modellen.

Met Keras, de deep learning-API die bovenop Tensorflow is gebouwd, experimenteren we met architecturen, bouwen we een ensemble van gestapelde modellen en trainen we een meta-leerling neuraal netwerk (niveau-1-model) om de prijs van een huis te berekenen.

Diep leren is verbazingwekkend - maar voordat u er gebruik van maakt, is het raadzaam om ook te proberen het probleem op te lossen met eenvoudigere technieken, zoals met oppervlakkig leren algoritmen. Onze basisprestaties zullen gebaseerd zijn op een Willekeurige bosregressie algoritme. Daarnaast zullen we onderzoeken hoe we ensembles van modellen kunnen maken via Scikit-Learn via technieken zoals: zakken en stemming.

Dit is een end-to-end-project, en net als bij alle Machine Learning-projecten beginnen we met – met Verkennende gegevensanalyse, Gevolgd door Data Preprocessing en tot slot Ondiep bouwen en Diepe leermodellen om te passen bij de gegevens die we eerder hebben onderzocht en opgeschoond.

Conclusie

In dit artikel hebben we een korte samenvatting gemaakt van SVM's, de kerneltruc bestudeerd en verschillende smaken van niet-lineaire SVM's geïmplementeerd.

Ik stel voor dat je elke kernel implementeert en verder gaat. U kunt de wiskunde onderzoeken die is gebruikt om elk van de verschillende kernels te maken, waarom ze zijn gemaakt en de verschillen met betrekking tot hun hyperparameters. Op die manier leer je over de technieken en welk type kernel je best toepast afhankelijk van de context en de beschikbare data.

Een duidelijk begrip hebben van hoe elke kernel werkt en wanneer je ze moet gebruiken, zal je zeker helpen tijdens je reis. Laat ons weten hoe het met de voortgang gaat en veel plezier met coderen!

• 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/implementing-other-svm-flavors-with-pythons-scikit-learn/