Implementering av andre SVM-smaker med Pythons Scikit-Learn

Introduksjon

Denne veiledningen er den tredje og siste delen av tre veiledninger om støttevektormaskiner (SVM). I denne veiledningen vil vi fortsette å jobbe med brukssaken for falske sedler, ha en rask oppsummering av den generelle ideen bak SVM-er, forstå hva som er kjernetrikset og implementere forskjellige typer ikke-lineære kjerner med Scikit-Learn.

I den komplette serien med SVM-veiledninger vil du i tillegg til å lære om andre typer SVM-er også lære om enkle SVM, SVM forhåndsdefinerte parametere, C- og Gamma-hyperparametre og hvordan de kan justeres med grid-søk og kryssvalidering.

Hvis du ønsker å lese de tidligere veiledningene, kan du ta en titt på de to første veiledningene eller se hvilke emner som interesserer deg mest. Nedenfor er tabellen over emner som dekkes i hver veiledning:

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

• Bruksfall: glem sedler
• Bakgrunn for SVM-er
• Enkel (lineær) SVM-modell
  • Om datasettet
  • Importerer datasettet
  • Utforsker datasettet
• Implementering av SVM med Scikit-Learn
  • Dele inn data i tog-/testsett
  • Trening av modellen
  • Gjøre spådommer
  • Evaluering av modellen
  • Tolke resultater

2. Forstå SVM-hyperparametre

• C-hyperparameteren
• Gamma-hyperparameteren

3. Implementering av andre SVM-smaker med Pythons Scikit-Learn

• Den generelle ideen til SVM-er (en oppsummering)
• Kjerne (Trick) SVM
• Implementering av ikke-lineær kjerne SVM med Scikit-Learn
• Importerer biblioteker
  • Importerer datasettet
  • Dele inn data i funksjoner (X) og mål (y)
  • Dele data i tog-/testsett
  • Trening av algoritmen
• Polynom kjerne
  • Gjøre spådommer
  • Evaluering av algoritmen
• Gaussisk kjerne
  • Prediksjon og evaluering
• Sigmoid kjerne
  • Prediksjon og evaluering
• Sammenligning av ikke-lineære kjerneytelser

La oss huske hva SVM handler om før vi ser noen interessante SVM-kjernevariasjoner.

Den generelle ideen til SVM-er

Ved lineært separerbare data i to dimensjoner (som vist i fig. 1) vil den typiske maskinlæringsalgoritmen være å prøve å finne en grense som deler dataene på en slik måte at feilklassifiseringsfeilen minimeres. Hvis du ser nøye på figur 1, legg merke til at det kan være flere grenser (uendelige) som deler datapunktene riktig. De to stiplede linjene samt den heltrukne linjen er alle gyldige klassifiseringer av dataene.

Fig 1: Flere beslutningsgrenser

Når SVM velger beslutningsgrense, velger den en grense som maksimerer avstanden mellom seg selv og de nærmeste datapunktene til klassene. Vi vet allerede at de nærmeste datapunktene er støttevektorene og at avstanden kan parametriseres begge ved C og gamma hyperparametre.

Ved beregning av beslutningsgrensen velger algoritmen hvor mange punkter som skal vurderes og hvor langt marginen kan gå – dette konfigurerer et marginmaksimeringsproblem. For å løse dette marginmaksimeringsproblemet bruker SVM støttevektorene (som vist i fig. 2) og prøver å finne ut hva som er optimale verdier som holder marginavstanden større, samtidig som de klassifiserer flere punkter riktig i henhold til funksjonen som brukes til å skille dataene.

Fig 2: Beslutningsgrense med støttevektorer

Dette er grunnen til at SVM skiller seg fra andre klassifiseringsalgoritmer, når den ikke bare finner en beslutningsgrense, men den ender opp med å finne den optimale beslutningsgrensen.

Det er kompleks matematikk hentet fra statistikk og beregningsmetoder involvert bak å finne støttevektorene, beregne marginen mellom beslutningsgrensen og støttevektorene og maksimere den marginen. Denne gangen skal vi ikke gå inn på detaljene om hvordan matematikken utspiller seg.

Det er alltid viktig å dykke dypere og sørge for at maskinlæringsalgoritmer ikke er en slags mystisk trylleformel, selv om det å ikke kjenne alle matematiske detaljer på dette tidspunktet ikke gjorde og vil ikke stoppe deg fra å kunne utføre algoritmen og oppnå resultater.

Kjerne (Trick) SVM

I forrige avsnitt har vi husket og organisert den generelle ideen til SVM – for å se hvordan den kan brukes til å finne den optimale beslutningsgrensen for lineært separerbare data. Men i tilfellet med ikke-lineært separerbare data, slik som den som er vist i fig. 3, vet vi allerede at en rett linje ikke kan brukes som en beslutningsgrense.

Fig. 3: Ikke-lineært separerbare data

Vi kan heller bruke den modifiserte versjonen av SVM vi hadde diskutert i begynnelsen, kalt Kernel SVM.

I utgangspunktet, hva kjernen SVM vil gjøre er å projisere ikke-lineært separerbare data med lavere dimensjoner til dens tilsvarende form i høyere dimensjoner. Dette er et triks, for når man projiserer ikke-lineært separerbare data i høyere dimensjoner, endres dataformen på en slik måte at den blir separerbar. For eksempel, når du tenker på 3 dimensjoner, kan datapunktene fra hver klasse ende opp med å bli allokert i en annen dimensjon, noe som gjør den separerbar. En måte å øke datadimensjonene på kan være å eksponensere dem. Igjen, det er kompleks matematikk involvert i dette, men du trenger ikke å bekymre deg for det for å bruke SVM. Vi kan heller bruke Pythons Scikit-Learn-bibliotek til å implementere og bruke de ikke-lineære kjernene på samme måte som vi har brukt de lineære.

Implementering av ikke-lineær kjerne SVM med Scikit-Learn

I denne delen vil vi bruke det samme datasettet for å forutsi om en seddel er ekte eller forfalsket i henhold til de fire funksjonene vi allerede kjenner.

Du vil se at resten av trinnene er typiske maskinlæringstrinn og trenger svært lite forklaring før vi når delen der vi trener våre ikke-lineære kjerne-SVM-er.

Importerer 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

Importerer datasettet

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)

Dele inn data i funksjoner (X) og mål (y)

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

Dele inn data i tog-/testsett

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

Trening av algoritmen

For å trene opp kjernen SVM, vil vi bruke det samme SVC klasse av Scikit-Learn's svm bibliotek. Forskjellen ligger i verdien for kjerneparameteren til SVC klasse.

I tilfellet med den enkle SVM har vi brukt "lineær" som verdien for kjerneparameteren. Men som vi har nevnt tidligere, for kjerne-SVM, kan vi bruke gaussiske, polynomiske, sigmoid- eller beregnbare kjerner. Vi vil implementere polynomiske, gaussiske og sigmoidkjerner og se på de endelige beregningene for å se hvilken som ser ut til å passe til våre klasser med en høyere metrikk.

1. Polynom kjerne

I algebra er et polynom et uttrykk for formen:

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

Denne har variabler, som f.eks a og b, konstanter, i vårt eksempel, 9 og koeffisienter (konstanter ledsaget av variabler), som f.eks 2 og 4. De 3 anses å være graden av polynomet.

Det er typer data som best kan beskrives når du bruker en polynomfunksjon, her er det kjernen vil gjøre å kartlegge dataene våre til et polynom som vi velger graden til. Jo høyere grad, jo mer vil funksjonen prøve å komme nærmere dataene, så beslutningsgrensen er mer fleksibel (og mer utsatt for overfitting) - jo lavere grad, jo minst fleksibel.

Så for å implementere polynom kjerne, foruten å velge poly kjerne, vil vi også sende en verdi 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)

Gjøre spådommer

Nå, når vi har trent algoritmen, er neste trinn å lage spådommer på testdataene.

Som vi har gjort før, kan vi kjøre følgende skript for å gjøre det:

y_pred_poly = svclassifier.predict(X_test)

Evaluering av algoritmen

Som vanlig er det siste trinnet å gjøre evalueringer på polynomkjernen. Siden vi har gjentatt koden for klassifiseringsrapporten og forvirringsmatrisen noen ganger, la oss transformere den til en funksjon som display_results etter å ha mottatt de respektive y_test, y_pred og tittel på Seaborns forvirringsmatrise 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))

Nå kan vi kalle funksjonen og se på resultatene oppnådd med polynomkjernen:

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

Utgangen ser slik ut:

 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

Nå kan vi gjenta de samme trinnene for Gauss- og sigmoidkjerner.

2. Gaussisk kjerne

For å bruke den gaussiske kjernen trenger vi bare å spesifisere 'rbf' som verdi for kernel parameter for SVC-klassen:

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

Når du utforsker denne kjernen videre, kan du også bruke rutenettsøk for å kombinere den med forskjellige C og gamma verdier.

Prediksjon 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)

Utgangen til den Gaussiske kjernen SVM ser slik ut:

 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. Sigmoid kjerne

Til slutt, la oss bruke en sigmoid-kjerne for å implementere Kernel SVM. Ta en titt på følgende skript:

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

For å bruke sigmoid-kjernen, må du spesifisere 'sigmoid' som verdi for kernel parameter for SVC klasse.

Prediksjon 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)

Utdataene fra Kernel SVM med Sigmoid-kjernen ser slik ut:

 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 av ikke-lineære kjerneytelser

Hvis vi kort sammenligner ytelsen til de forskjellige typene ikke-lineære kjerner, kan det virke som at sigmoid-kjernen har de laveste metrikkene, så den dårligste ytelsen.

Blant de gaussiske og polynomiske kjernene kan vi se at den gaussiske kjernen oppnådde en perfekt 100 % prediksjonsrate – noe som vanligvis er mistenkelig og kan indikere en overtilpasning, mens polynomkjernen feilklassifiserte 68 forekomster av klasse 1.

Derfor er det ingen fast og rask regel for hvilken kjerne som yter best i hvert scenario eller i vårt nåværende scenario uten å søke ytterligere etter hyperparametre, forstå hver funksjonsform, utforske dataene og sammenligne tog- og testresultater for å se om algoritmen er generaliserende.

Det handler om å teste alle kjernene og velge den med kombinasjonen av parametere og dataforberedelse som gir de forventede resultatene i henhold til konteksten til prosjektet ditt.

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

Din nysgjerrige natur gjør at du ønsker å gå lenger? Vi anbefaler å sjekke ut vår Veiledet prosjekt: "Hands-on husprisprediksjon – maskinlæring i Python".

I dette guidede prosjektet – vil du lære hvordan du bygger kraftige tradisjonelle maskinlæringsmodeller så vel som dyplæringsmodeller, bruker Ensemble Learning og trener meta-elever til å forutsi boligpriser fra en pose med Scikit-Learn og Keras-modeller.

Ved å bruke Keras, deep learning API bygget på toppen av Tensorflow, vil vi eksperimentere med arkitekturer, bygge et ensemble av stablede modeller og trene en meta-lærer nevrale nettverk (nivå-1-modell) for å finne ut prisen på et hus.

Dyplæring er fantastisk – men før du tyr til det, anbefales det også å prøve å løse problemet med enklere teknikker, for eksempel med grunn læring algoritmer. Vår baseline ytelse vil være basert på en Tilfeldig skogregresjon algoritme. I tillegg – vi vil utforske å lage ensembler av modeller gjennom Scikit-Learn via teknikker som posing og stemmegivning.

Dette er et ende-til-ende-prosjekt, og som alle maskinlæringsprosjekter starter vi med – med Utforskende dataanalyse, Etterfulgt av Forbehandling av data og endelig Bygge grunt og Dyplæringsmodeller for å passe til dataene vi har utforsket og renset tidligere.

konklusjonen

I denne artikkelen har vi laget en rask oppsummering av SVM-er, studert om kjernetrikset og implementert forskjellige smaker av ikke-lineære SVM-er.

Jeg foreslår at du implementerer hver kjerne og fortsetter videre. Du kan utforske matematikken som ble brukt til å lage hver av de forskjellige kjernene, hvorfor de ble opprettet og forskjellene angående hyperparametrene deres. På den måten vil du lære om teknikkene og hvilken type kjerne som er best å bruke avhengig av konteksten og tilgjengelige data.

Å ha en klar forståelse av hvordan hver kjerne fungerer og når du skal bruke dem, vil definitivt hjelpe deg på reisen. Fortell oss hvordan fremgangen går og god koding!

• SEO-drevet innhold og PR-distribusjon. Bli forsterket i dag.
• Platoblokkkjede. Web3 Metaverse Intelligence. Kunnskap forsterket. Tilgang her.
• Minting the Future med Adryenn Ashley. Tilgang her.
• kilde: https://stackabuse.com/implementing-other-svm-flavors-with-pythons-scikit-learn/