Zephyrnet-logotyp

Implementera andra SVM-smaker med Pythons Scikit-Learn

Datum:

Beskrivning

Den här guiden är den tredje och sista delen av tre guider om Support Vector Machines (SVM). I den här guiden kommer vi att fortsätta arbeta med användningsfallet för förfalskade sedlar, ha en snabb sammanfattning av den allmänna idén bakom SVM, förstå vad som är kärntricket och implementera olika typer av icke-linjära kärnor med Scikit-Learn.

I den kompletta serien av SVM-guider kommer du, förutom att lära dig om andra typer av SVM:er, också lära dig om enkla SVM, SVM fördefinierade parametrar, C och Gamma hyperparametrar och hur de kan ställas in med rutnätssökning och korsvalidering.

Om du vill läsa de tidigare guiderna kan du ta en titt på de två första guiderna eller se vilka ämnen som intresserar dig mest. Nedan är tabellen över ämnen som tas upp i varje guide:

  1. Implementering av SVM och Kernel SVM med Pythons Scikit-Learn
  • Användningsfall: glöm sedlar
  • Bakgrund till SVM
  • Enkel (linjär) SVM-modell
    • Om datamängden
    • Importera datamängden
    • Utforska datasättet
  • Implementering av SVM med Scikit-Learn
    • Dela upp data i tåg/testuppsättningar
    • Träna modellen
    • Förutsäga
    • Utvärdering av modellen
    • Tolka resultat
  1. Förstå SVM-hyperparametrar
  • Hyperparametern C
  • Gamma-hyperparametern

3. Implementera andra SVM-smaker med Pythons Scikit-Learn

  • SVMs allmänna idé (en sammanfattning)
  • Kärna (Trick) SVM
  • Implementering av icke-linjär kärna SVM med Scikit-Learn
  • Importerar bibliotek
    • Importera datamängden
    • Dela upp data i funktioner (X) och mål (y)
    • Dela upp data i tåg/testuppsättningar
    • Att träna algoritmen
  • Polynomkärna
    • Förutsäga
    • Utvärdera algoritmen
  • Gaussisk kärna
    • Förutsägelse och utvärdering
  • Sigmoidkärna
    • Förutsägelse och utvärdering
  • Jämförelse av icke-linjära kärnprestanda

Låt oss komma ihåg vad SVM handlar om innan vi ser några intressanta SVM-kärnvariationer.

SVMs allmänna idé

I fallet med linjärt separerbara data i två dimensioner (som visas i Fig. 1) skulle den typiska maskininlärningsalgoritmen vara att försöka hitta en gräns som delar upp data på ett sådant sätt att felklassificeringsfelet minimeras. Om du tittar noga på figur 1, lägg märke till att det kan finnas flera gränser (oändliga) som delar upp datapunkterna korrekt. De två streckade linjerna såväl som den heldragna linjen är alla giltiga klassificeringar av data.

Flera beslutsgränser

Fig 1: Flera beslutsgränser

När SVM väljer beslutsgräns, väljer den en gräns som maximerar avståndet mellan sig själv och de närmaste datapunkterna i klasserna. Vi vet redan att de närmaste datapunkterna är stödvektorerna och att avståndet kan parametriseras med båda C och gamma hyperparametrar.

Vid beräkning av beslutsgränsen väljer algoritmen hur många punkter som ska beaktas och hur långt marginalen kan gå – detta konfigurerar ett problem med marginalmaximering. För att lösa det marginalmaximeringsproblemet använder SVM stödvektorerna (som ses i fig. 2) och försöker ta reda på vad som är optimala värden som håller marginalavståndet större, samtidigt som de klassificerar fler punkter korrekt enligt funktionen som används för att separera uppgifterna.

Beslutsgräns med stödvektorer

Fig 2: Beslutsgräns med stödvektorer

Det är därför SVM skiljer sig från andra klassificeringsalgoritmer, när det inte bara hittar en beslutsgräns, utan det slutar med att hitta den optimala beslutsgränsen.

Det finns komplex matematik som härrör från statistik och beräkningsmetoder bakom att hitta stödvektorerna, beräkna marginalen mellan beslutsgränsen och stödvektorerna och maximera den marginalen. Den här gången går vi inte in på detaljerna om hur matematiken utspelar sig.

Det är alltid viktigt att dyka djupare och se till att maskininlärningsalgoritmer inte är någon form av mystisk besvärjelse, även om att inte veta varje matematisk detalj vid denna tidpunkt inte gjorde och kommer inte att hindra dig från att kunna exekvera algoritmen och få resultat.

Råd: nu när vi har gjort en sammanfattning av den algoritmiska processen är det tydligt att avståndet mellan datapunkter kommer att påverka den beslutsgräns SVM väljer, på grund av det, skala data är vanligtvis nödvändigt när du använder en SVM-klassificerare. Prova att använda Scikit-learns standardskaleringsmetod för att förbereda data och sedan köra koderna igen för att se om det finns en skillnad i resultat.

Kärna (Trick) SVM

I föregående avsnitt har vi kommit ihåg och organiserat den allmänna idén med SVM – att se hur den kan användas för att hitta den optimala beslutsgränsen för linjärt separerbar data. Men i fallet med icke-linjärt separerbara data, såsom den som visas i fig. 3, vet vi redan att en rät linje inte kan användas som en beslutsgräns.

Icke-linjärt separerbara data

Fig 3: Icke-linjärt separerbara data

Snarare kan vi använda den modifierade versionen av SVM som vi diskuterade i början, kallad Kernel SVM.

I grund och botten, vad kärnan SVM kommer att göra är att projicera icke-linjärt separerbara data med lägre dimensioner till motsvarande form i högre dimensioner. Detta är ett knep, för när man projicerar icke-linjärt separerbar data i högre dimensioner, ändras dataformen på ett sådant sätt att den blir separerbar. Till exempel, när man tänker på tre dimensioner, kan datapunkterna från varje klass hamna i en annan dimension, vilket gör den separerbar. Ett sätt att öka datadimensionerna kan vara att exponentiera dem. Återigen, det är komplex matematik involverad i detta, men du behöver inte oroa dig för det för att använda SVM. Snarare kan vi använda Pythons Scikit-Learn-bibliotek för att implementera och använda de icke-linjära kärnorna på samma sätt som vi har använt de linjära.

Implementering av icke-linjär kärna SVM med Scikit-Learn

I det här avsnittet kommer vi att använda samma datauppsättning för att förutsäga om en sedel är verklig eller förfalskad enligt de fyra funktioner vi redan känner till.

Du kommer att se att resten av stegen är typiska maskininlärningssteg och behöver väldigt lite förklaring tills vi når den del där vi tränar våra icke-linjära kärn-SVM:er.

Importerar bibliotek

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

Importera datamängden

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)

Dela upp data i funktioner (X) och mål (y)

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

Dela upp data i tåg/testuppsättningar

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

Att träna algoritmen

För att träna kärnan SVM kommer vi att använda densamma SVC klass av Scikit-Learn's svm bibliotek. Skillnaden ligger i värdet för kärnparametern för SVC klass.

I fallet med den enkla SVM har vi använt "linjär" som värde för kärnparametern. Men som vi har nämnt tidigare, för kärna SVM, kan vi använda gaussiska, polynomiska, sigmoid eller beräkningsbara kärnor. Vi kommer att implementera polynomiska, gaussiska och sigmoid-kärnor och titta på dess slutliga mätvärden för att se vilken som verkar passa våra klasser med en högre måttenhet.

1. Polynomkärna

I algebra är ett polynom ett uttryck för formen:

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

Detta har variabler, som t.ex a och b, konstanter, i vårt exempel, 9 och koefficienter (konstanter åtföljda av variabler), som t.ex 2 och 4. De 3 anses vara graden av polynomet.

Det finns typer av data som bäst kan beskrivas när man använder en polynomfunktion, här är vad kärnan kommer att göra att mappa våra data till ett polynom som vi väljer graden till. Ju högre grad, desto mer kommer funktionen att försöka komma närmare data, så beslutsgränsen är mer flexibel (och mer benägen att överanpassa) – ju lägre grad, desto minst flexibel.

Kolla in vår praktiska, praktiska guide för att lära dig Git, med bästa praxis, branschaccepterade standarder och medföljande fuskblad. Sluta googla Git-kommandon och faktiskt lära Det!

Så för att genomföra polynom kärna, förutom att välja poly kärnan skickar vi också ett värde för degree parameter för SVC klass. Nedan är koden:

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

Förutsäga

Nu, när vi har tränat algoritmen, är nästa steg att göra förutsägelser på testdata.

Som vi har gjort tidigare kan vi köra följande skript för att göra det:

y_pred_poly = svclassifier.predict(X_test)

Utvärdera algoritmen

Som vanligt är det sista steget att göra utvärderingar på polynomkärnan. Eftersom vi har upprepat koden för klassificeringsrapporten och förvirringsmatrisen några gånger, låt oss omvandla den till en funktion som display_results efter att ha mottagit respektive y_test, y_pred och titel till Seaborns förvirringsmatris 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 anropa funktionen och titta på resultaten som erhålls med polynomkärnan:

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

Resultatet ser ut så här:

 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 upprepa samma steg för Gauss- och sigmoidkärnor.

2. Gausskärna

För att använda den gaussiska kärnan behöver vi bara ange 'rbf' som värde för kernel parameter för SVC-klassen:

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

När du utforskar den här kärnan ytterligare kan du också använda rutnätssökning för att kombinera den med olika C och gamma värden.

Förutsägelse och utvärdering

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)

Utdata från den Gaussiska kärnan SVM ser ut så här:

 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. Sigmoidkärna

Slutligen, låt oss använda en sigmoid-kärna för att implementera Kernel SVM. Ta en titt på följande manus:

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

För att använda sigmoid-kärnan måste du ange 'sigmoid' som värde för kernel parameter för SVC klass.

Förutsägelse och utvärdering

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)

Utdata från Kernel SVM med Sigmoid-kärna ser ut så här:

 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

Jämförelse av icke-linjära kärnprestanda

Om vi ​​kort jämför prestandan för de olika typerna av icke-linjära kärnor, kan det verka som att sigmoidkärnan har de lägsta måtten, alltså den sämsta prestandan.

Bland de gaussiska och polynomiska kärnorna kan vi se att den gaussiska kärnan uppnådde en perfekt 100 % förutsägelsegrad – vilket vanligtvis är misstänkt och kan indikera en överanpassning, medan polynomkärnan felklassificerade 68 instanser av klass 1.

Därför finns det ingen hård och snabb regel för vilken kärna som presterar bäst i varje scenario eller i vårt nuvarande scenario utan att ytterligare söka efter hyperparametrar, förstå varje funktionsform, utforska data och jämföra tåg- och testresultat för att se om algoritmen är generaliserande.

Det handlar om att testa alla kärnor och välja den med kombinationen av parametrar och dataförberedelser som ger de förväntade resultaten enligt ditt projekts sammanhang.

Going Further – Handhållet end-to-end-projekt

Din nyfikna natur gör att du vill gå längre? Vi rekommenderar att du kollar in vår Guidade projekt: “Hands-on husprisförutsägelse – maskininlärning i Python”.

I det här guidade projektet – du lär dig hur du bygger kraftfulla traditionella maskininlärningsmodeller såväl som modeller för djupinlärning, använder Ensemble Learning och utbildar meta-lärare för att förutsäga huspriser från en påse med Scikit-Learn och Keras-modeller.

Med hjälp av Keras, API:et för djupinlärning byggt ovanpå Tensorflow, kommer vi att experimentera med arkitekturer, bygga en ensemble av staplade modeller och träna en meta-lärare neurala nätverk (nivå-1-modell) för att ta reda på priset på ett hus.

Djup inlärning är fantastiskt – men innan du tar till det, rekommenderas det att du också försöker lösa problemet med enklare tekniker, som med ytlig inlärning algoritmer. Vår baslinjeprestanda kommer att baseras på en Slumpmässig skogsregression algoritm. Dessutom – vi kommer att utforska att skapa ensembler av modeller genom Scikit-Learn via tekniker som t.ex säckväv och rösta.

Detta är ett projekt från slut till slut, och som alla maskininlärningsprojekt börjar vi med – med Utforskande dataanalys, Följt av Förbehandling av data och slutligen Bygga grunt och Modeller för djupinlärning för att passa de data vi har utforskat och rensat tidigare.

Slutsats

I den här artikeln gjorde vi en snabb sammanfattning av SVM:er, studerade om kärntricket och implementerade olika smaker av icke-linjära SVM:er.

Jag föreslår att du implementerar varje kärna och fortsätter att gå vidare. Du kan utforska matematiken som används för att skapa var och en av de olika kärnorna, varför de skapades och skillnaderna när det gäller deras hyperparametrar. På det sättet kommer du att lära dig om teknikerna och vilken typ av kärna som är bäst att tillämpa beroende på sammanhanget och tillgänglig data.

Att ha en tydlig förståelse för hur varje kärna fungerar och när de ska användas kommer definitivt att hjälpa dig på din resa. Låt oss veta hur utvecklingen går och lycklig kodning!

plats_img

Senaste intelligens

plats_img