Implementering af andre SVM-varianter med Pythons Scikit-Learn

Introduktion

Denne guide er den tredje og sidste del af tre guider om Support Vector Machines (SVM'er). I denne vejledning vil vi blive ved med at arbejde med brugen af ​​falske pengesedler, have en hurtig opsummering af den generelle idé bag SVM'er, forstå, hvad kernetricket er, og implementere forskellige typer ikke-lineære kerner med Scikit-Learn.

I den komplette serie af SVM-vejledninger vil du udover at lære om andre typer SVM'er også lære om simple SVM, SVM foruddefinerede parametre, C- og Gamma-hyperparametre og hvordan de kan tunes med gittersøgning og krydsvalidering.

Hvis du ønsker at læse de tidligere guides, kan du tage et kig på de to første guider eller se, hvilke emner der interesserer dig mest. Nedenfor er tabellen over emner, der er dækket i hver guide:

1. Implementering af SVM og Kernel SVM med Pythons Scikit-Learn

• Use case: glem pengesedler
• Baggrund for SVM'er
• Simpel (lineær) SVM-model
  • Om datasættet
  • Import af datasættet
  • Udforskning af datasættet
• Implementering af SVM med Scikit-Learn
  • Opdeling af data i tog-/testsæt
  • Træning af modellen
  • At forudsige
  • Evaluering af modellen
  • Fortolkning af resultater

2. Forståelse af SVM-hyperparametre

• C-hyperparameteren
• Gamma-hyperparameteren

3. Implementering af andre SVM-varianter med Pythons Scikit-Learn

• Den generelle idé om SVM'er (et resumé)
• Kernel (Trick) SVM
• Implementering af ikke-lineær kerne SVM med Scikit-Learn
• Import af biblioteker
  • Import af datasættet
  • Opdeling af data i funktioner (X) og mål (y)
  • Opdeling af data i tog-/testsæt
  • Træning af algoritmen
• Polynomisk kerne
  • At forudsige
  • Evaluering af algoritmen
• Gaussisk kerne
  • Forudsigelse og evaluering
• Sigmoid kerne
  • Forudsigelse og evaluering
• Sammenligning af ikke-lineære kerneydelser

Lad os huske, hvad SVM handler om, før vi ser nogle interessante SVM-kernevariationer.

SVM'ers generelle idé

I tilfælde af lineært adskillelige data i to dimensioner (som vist i fig. 1) vil den typiske maskinlæringsalgoritme-tilgang være at forsøge at finde en grænse, der deler dataene på en sådan måde, at fejlklassificeringsfejlen minimeres. Hvis du ser nærmere på figur 1, skal du bemærke, at der kan være flere grænser (uendelige), der deler datapunkterne korrekt. De to stiplede linjer samt den fuldt optrukne linje er alle gyldige klassifikationer af dataene.

Fig. 1: Flere beslutningsgrænser

Når SVM vælger beslutningsgrænse, vælger den en grænse, der maksimerer afstanden mellem sig selv og de nærmeste datapunkter i klasserne. Vi ved allerede, at de nærmeste datapunkter er støttevektorerne, og at afstanden kan parametriseres begge ved C , gamma hyperparametre.

Ved beregning af denne beslutningsgrænse vælger algoritmen, hvor mange punkter der skal tages i betragtning, og hvor langt marginen kan gå – dette konfigurerer et marginmaksimeringsproblem. Ved at løse dette marginmaksimeringsproblem bruger SVM støttevektorerne (som det ses i fig. 2) og forsøger at finde ud af, hvad der er optimale værdier, der holder marginafstanden større, samtidig med at flere punkter klassificeres korrekt i henhold til den funktion, der bruges til at adskille dataene.

Fig. 2: Beslutningsgrænse med støttevektorer

Dette er grunden til, at SVM adskiller sig fra andre klassifikationsalgoritmer, når den ikke blot finder en beslutningsgrænse, men den ender med at finde den optimale beslutningsgrænse.

Der er kompleks matematik afledt af statistik og beregningsmetoder involveret bag at finde støttevektorerne, beregne marginen mellem beslutningsgrænsen og støttevektorerne og maksimere denne margin. Denne gang vil vi ikke gå i detaljer med, hvordan matematikken udspiller sig.

Det er altid vigtigt at dykke dybere og sikre sig, at maskinlæringsalgoritmer ikke er en slags mystisk besværgelse, selvom det ikke at kende alle matematiske detaljer på dette tidspunkt ikke og vil forhindre dig i at kunne udføre algoritmen og opnå resultater.

Kernel (Trick) SVM

I det foregående afsnit har vi husket og organiseret den generelle idé om SVM – for at se, hvordan den kan bruges til at finde den optimale beslutningsgrænse for lineært adskillelige data. Men i tilfælde af ikke-lineært separerbare data, såsom den vist i fig. 3, ved vi allerede, at en ret linje ikke kan bruges som en beslutningsgrænse.

Fig. 3: Ikke-lineært separerbare data

I stedet kan vi bruge den modificerede version af SVM, vi havde diskuteret i begyndelsen, kaldet Kernel SVM.

Grundlæggende, hvad kernel SVM vil gøre, er at projicere de ikke-lineært adskillelige data af lavere dimensioner til dens tilsvarende form i højere dimensioner. Dette er et trick, for når man projicerer ikke-lineært separerbare data i højere dimensioner, ændres dataformen på en sådan måde, at den bliver adskillelig. For eksempel, når man tænker på 3 dimensioner, kan datapunkterne fra hver klasse ende med at blive allokeret i en anden dimension, hvilket gør den adskillelig. En måde at øge datadimensionerne på kan være ved at eksponentisere dem. Igen er der kompleks matematik involveret i dette, men du behøver ikke bekymre dig om det for at bruge SVM. I stedet kan vi bruge Pythons Scikit-Learn-bibliotek til at implementere og bruge de ikke-lineære kerner på samme måde, som vi har brugt de lineære.

Implementering af ikke-lineær kerne SVM med Scikit-Learn

I dette afsnit vil vi bruge det samme datasæt til at forudsige, om en pengeseddel er ægte eller forfalsket i henhold til de fire funktioner, vi allerede kender.

Du vil se, at resten af ​​trinene er typiske maskinlæringstrin og kræver meget lidt forklaring, indtil vi når den del, hvor vi træner vores ikke-lineære kernel SVM'er.

Import af biblioteker

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

Import af datasættet

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)

Opdeling af data i funktioner (X) og mål (y)

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

Opdeling af data i tog-/testsæt

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

Træning af algoritmen

For at træne kernel SVM, vil vi bruge det samme SVC klasse af Scikit-Learn's svm bibliotek. Forskellen ligger i værdien for kerneparameteren for SVC klasse.

I tilfældet med den simple SVM har vi brugt "lineær" som værdien for kerneparameteren. Men som vi har nævnt tidligere, til kerne SVM, kan vi bruge gaussiske, polynomiske, sigmoide eller beregnelige kerner. Vi vil implementere polynomielle, gaussiske og sigmoidkerner og se på dens endelige metrikker for at se, hvilken der synes at passe til vores klasser med en højere metrik.

1. Polynomisk kerne

I algebra er et polynomium et udtryk for formen:

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

Dette har variabler, som f.eks a , b, konstanter, i vores eksempel, 9 og koefficienter (konstanter ledsaget af variabler), som f.eks 2 , 4. Det 3 anses for at være graden af ​​polynomiet.

Der er typer af data, der bedst kan beskrives, når du bruger en polynomiel funktion, her, hvad kernen vil gøre, er at kortlægge vores data til et polynomium, som vi vil vælge graden til. Jo højere grad, jo mere vil funktionen forsøge at komme tættere på dataene, så beslutningsgrænsen er mere fleksibel (og mere tilbøjelig til overfit) - jo lavere grad, jo mindst fleksibel.

Så for at implementere polynomisk kerne, udover at vælge poly kerne, vil vi også videregive en værdi for degree parameter for SVC klasse. Nedenfor er koden:

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

At forudsige

Nu, når vi har trænet algoritmen, er næste skridt at lave forudsigelser på testdataene.

Som vi har gjort før, kan vi udføre følgende script for at gøre det:

y_pred_poly = svclassifier.predict(X_test)

Evaluering af algoritmen

Som sædvanlig er det sidste trin at lave evalueringer på polynomiekernen. Da vi har gentaget koden for klassifikationsrapporten og forvirringsmatricen et par gange, lad os omdanne den til en funktion, der display_results efter at have modtaget de respektive y_test, y_pred og titel til Seaborns forvirringsmatrix med 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 kan vi kalde funktionen og se på resultaterne opnået med polynomiumkernen:

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

Output ser således ud:

 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 kan vi gentage de samme trin for gaussiske og sigmoide kerner.

2. Gaussisk kerne

For at bruge den gaussiske kerne behøver vi kun at angive 'rbf' som værdi for kernel parameter for SVC-klassen:

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

Når du udforsker denne kerne yderligere, kan du også bruge gittersøgning til at kombinere den med forskellige C , gamma værdier.

Forudsigelse og evaluering

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)

Outputtet af den Gaussiske kerne SVM ser sådan ud:

 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. Sigmoidkerne

Lad os endelig bruge en sigmoid-kerne til at implementere Kernel SVM. Tag et kig på følgende script:

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

For at bruge sigmoid-kernen skal du angive 'sigmoid' som værdi for kernel parameter for SVC klasse.

Forudsigelse og evaluering

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)

Outputtet af Kernel SVM med Sigmoid-kernen ser sådan ud:

 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

Sammenligning af ikke-lineære kerneydelser

Hvis vi kort sammenligner ydeevnen af ​​de forskellige typer ikke-lineære kerner, kan det se ud til, at sigmoid-kernen har de laveste metrics, så den dårligste ydeevne.

Blandt de Gaussiske og polynomielle kerner kan vi se, at den Gaussiske kerne opnåede en perfekt forudsigelsesrate på 100 % - hvilket normalt er mistænkeligt og kan indikere en overpasning, mens polynomiumkernen fejlklassificerede 68 forekomster af klasse 1.

Derfor er der ingen fast og hurtig regel for, hvilken kerne der fungerer bedst i hvert scenarie eller i vores nuværende scenarie uden yderligere at søge efter hyperparametre, forstå hver funktionsform, udforske dataene og sammenligne tog- og testresultater for at se, om algoritmen er generaliserende.

Det handler om at teste alle kernerne og vælge den med kombinationen af ​​parametre og dataforberedelse, der giver de forventede resultater i forhold til dit projekts kontekst.

Going Further – Håndholdt ende-til-ende-projekt

Din nysgerrige natur giver dig lyst til at gå længere? Vi anbefaler at tjekke vores Vejledt projekt: “Hands-on husprisforudsigelse – maskinlæring i Python”.

I dette guidede projekt – vil du lære, hvordan du bygger kraftfulde traditionelle maskinlæringsmodeller såvel som deep learning-modeller, bruger Ensemble Learning og træner meta-elever til at forudsige huspriser ud fra en pose Scikit-Learn og Keras-modeller.

Ved at bruge Keras, deep learning API bygget oven på Tensorflow, eksperimenterer vi med arkitekturer, bygger et ensemble af stablede modeller og træner en meta-lærer neuralt netværk (niveau-1 model) for at finde ud af prisen på et hus.

Dyb læring er fantastisk – men før man griber til det, anbefales det også at forsøge at løse problemet med enklere teknikker, som f.eks. overfladisk læring algoritmer. Vores baseline præstation vil være baseret på en Tilfældig skovregression algoritme. Derudover – vi vil udforske at skabe ensembler af modeller gennem Scikit-Learn via teknikker som f.eks sække , afstemning.

Dette er et ende-til-ende-projekt, og ligesom alle Machine Learning-projekter starter vi med – med Udforskende dataanalyse, efterfulgt af Dataforarbejdning og endelig Bygning lavvandet , Deep Learning-modeller for at passe til de data, vi tidligere har udforsket og renset.

Konklusion

I denne artikel lavede vi en hurtig opsummering af SVM'er, studerede om kernetricket og implementerede forskellige varianter af ikke-lineære SVM'er.

Jeg foreslår, at du implementerer hver kerne og fortsætter videre. Du kan udforske den matematik, der blev brugt til at skabe hver af de forskellige kerner, hvorfor de blev oprettet og forskellene med hensyn til deres hyperparametre. På den måde vil du lære om teknikkerne og hvilken type kerne der er bedst at anvende afhængigt af konteksten og de tilgængelige data.

At have en klar forståelse af, hvordan hver kerne fungerer, og hvornår du skal bruge dem, vil helt sikkert hjælpe dig på din rejse. Fortæl os, hvordan fremskridtene går, og glad kodning!

• SEO Powered Content & PR Distribution. Bliv forstærket i dag.
• Platoblokkæde. Web3 Metaverse Intelligence. Viden forstærket. Adgang her.
• Udmøntning af fremtiden med Adryenn Ashley. Adgang her.
• Kilde: https://stackabuse.com/implementing-other-svm-flavors-with-pythons-scikit-learn/