Implementering af SVM og Kernel SVM med Pythons Scikit-Learn

Introduktion

Denne vejledning er den første del af tre vejledninger om Support Vector Machines (SVM'er). I denne serie vil vi arbejde på en forfalskning af pengesedler, lære om de simple SVM, derefter om SVM-hyperparametre og til sidst lære et koncept kaldet kerne trick og udforske andre typer SVM'er.

Hvis du ønsker at læse alle guiderne eller se, hvilke der interesserer dig mest, er nedenstående tabel 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 (kommer snart!)

• C-hyperparameteren
• Gamma-hyperparameteren

3. Implementering af andre SVM-varianter med Pythons Scikit-Learn (kommer snart!)

• 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

Use Case: Forfalskede pengesedler

Nogle gange finder folk en måde at forfalske pengesedler på. Hvis der er en person, der kigger på disse noter og bekræfter deres gyldighed, kan det være svært at blive snydt af dem.

Men hvad sker der, når der ikke er en person til at se på hver seddel? Er der en måde at automatisk vide, om pengesedler er falske eller ægte?

Der er mange måder at besvare disse spørgsmål på. Et svar er at fotografere hver modtaget seddel, sammenligne dens billede med en forfalsket seddel og derefter klassificere den som ægte eller forfalsket. Når det kan være kedeligt eller kritisk at vente på notens validering, ville det også være interessant at foretage den sammenligning hurtigt.

Da billeder bliver brugt, kan de komprimeres, reduceres til gråtoner og få deres mål ekstraheret eller kvantificeret. På denne måde ville sammenligningen være mellem billedmålinger i stedet for hvert billedes pixel.

Indtil videre har vi fundet en måde at behandle og sammenligne pengesedler på, men hvordan vil de blive klassificeret som ægte eller falske? Vi kan bruge maskinlæring til at lave den klassificering. Der er en klassifikationsalgoritme kaldet Support Vector Machine, hovedsageligt kendt under sin forkortede form: svm.

Baggrund for SVM'er

SVM'er blev oprindeligt introduceret i 1968 af Vladmir Vapnik og Alexey Chervonenkis. På det tidspunkt var deres algoritme begrænset til klassificeringen af ​​data, der kunne adskilles ved hjælp af kun en lige linje, eller data, der var lineært adskillelige. Vi kan se, hvordan den adskillelse ville se ud:

I ovenstående billede har vi en linje i midten, hvor nogle punkter er til venstre, og andre er til højre for den linje. Bemærk, at begge grupper af punkter er perfekt adskilt, der er ingen punkter imellem eller endda tæt på linjen. Der synes at være en margen mellem lignende punkter og den linje, der deler dem, kaldes den margin adskillelsesmargin. Funktionen af ​​adskillelsesmarginen er at gøre mellemrummet mellem de ens punkter og linjen, der deler dem, større. SVM gør det ved at bruge nogle punkter og beregner dets vinkelrette vektorer for at understøtte beslutningen om linjens margin. Det er de støtte vektorer som er en del af navnet på algoritmen. Vi vil forstå mere om dem senere. Og den lige linje, som vi ser i midten, findes ved metoder, der maksimere det mellemrum mellem linjen og punkterne, eller som maksimerer adskillelsesmargenen. Disse metoder stammer fra området Optimeringsteori.

I det eksempel, vi lige har set, kan begge grupper af punkter let adskilles, da hvert enkelt punkt er tæt sammen med dets lignende punkter, og de to grupper er langt fra hinanden.

Men hvad sker der, hvis der ikke er en måde at adskille dataene ved hjælp af en lige linje? Hvis der er rodede punkter, der ikke er placeret, eller hvis en kurve er nødvendig?

For at løse dette problem blev SVM senere forfinet i 1990'erne til også at kunne klassificere data, der havde punkter, der var langt fra dets centrale tendens, såsom outliers, eller mere komplekse problemer, der havde mere end to dimensioner og ikke var lineært adskillelige .

Det mærkelige er, at kun i de senere år er SVM'er blevet bredt udbredt, primært på grund af deres evne til nogle gange at opnå mere end 90 % af korrekte svar eller nøjagtighed, for vanskelige problemer.

SVM'er implementeres på en unik måde sammenlignet med andre maskinlæringsalgoritmer, når de først er baseret på statistiske forklaringer af, hvad læring er, eller på Statistisk læringsteori.

I denne artikel vil vi se, hvad Support Vector Machines algoritmer er, den korte teori bag en støttevektormaskine og deres implementering i Pythons Scikit-Learn-bibliotek. Vi vil derefter bevæge os mod et andet SVM-koncept, kendt som Kernel SVM eller Kernel trick, og vil også implementere det ved hjælp af Scikit-Learn.

Simpel (lineær) SVM-model

Om datasættet

Efter eksemplet givet i introduktionen vil vi bruge et datasæt, der har målinger af ægte og forfalskede pengesedlerbilleder.

Når vi ser på to sedler, scanner vores øjne dem normalt fra venstre mod højre og tjekker, hvor der kan være ligheder eller uligheder. Vi ser efter en sort prik, der kommer før en grøn prik, eller et skinnende mærke, der er over en illustration. Det betyder, at der er en rækkefølge, som vi ser på noterne. Hvis vi vidste, at der var grønne og sorte prikker, men ikke hvis den grønne prik kom før den sorte, eller hvis den sorte kom før den grønne, ville det være sværere at skelne mellem toner.

Der er en lignende metode, som vi lige har beskrevet, og som kan anvendes på seddelbillederne. Generelt består denne metode i at oversætte billedets pixels til et signal og derefter tage hensyn til rækkefølgen, hvori hvert andet signal sker i billedet ved at transformere det til små bølger, eller bølger. Efter at have opnået wavelets, er der en måde at kende den rækkefølge, hvori nogle signaler sker før et andet, eller tid, men ikke præcis hvilket signal. For at vide det skal billedets frekvenser indhentes. De opnås ved en metode, der udfører nedbrydningen af ​​hvert signal, kaldet Fourier metode.

Når først tidsdimensionen er opnået gennem wavelets, og frekvensdimensionen gennem Fourier-metoden, foretages en overlejring af tid og frekvens for at se, hvornår begge har en match, dette er sammenfald analyse. Konvolutionen opnår en pasform, der matcher wavelets med billedets frekvenser og finder ud af, hvilke frekvenser der er mere fremtrædende.

Denne metode, der involverer at finde wavelets, deres frekvenser og derefter tilpasse dem begge, kaldes Wavelet transformation. Wavelet-transformationen har koefficienter, og disse koefficienter blev brugt til at opnå de målinger, vi har i datasættet.

Import af datasættet

Det pengeseddeldatasæt, som vi skal bruge i dette afsnit, er det samme, som blev brugt i klassifikationsafsnittet i beslutningstræ tutorial.

Lad os importere dataene til en panda dataframe struktur, og tag et kig på de første fem rækker med head() fremgangsmåde.

Bemærk, at dataene er gemt i en txt (tekst) filformat, adskilt af kommaer, og det er uden overskrift. Vi kan rekonstruere den som en tabel ved at læse den som en csv, med angivelse af separator som et komma, og tilføjelse af kolonnenavne med names argument.

Lad os følge disse tre trin på én gang, og så se på de første fem rækker af data:

import pandas as pd 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()

Dette resulterer i:

	variance skewness curtosis entropy class
0 3.62160 8.6661 -2.8073 -0.44699 0
1 4.54590 8.1674 -2.4586 -1.46210 0
2 3.86600 -2.6383 1.9242 0.10645 0
3 3.45660 9.5228 -4.0112 -3.59440 0
4 0.32924 -4.4552 4.5718 -0.98880 0

Vi kan se, at der er fem kolonner i vores datasæt, nemlig variance, skewness, curtosis, entropyog class. I de fem rækker er de første fire kolonner fyldt med tal som 3.62160, 8.6661, -2.8073 eller kontinuerlig værdier, og det sidste class kolonne har sine første fem rækker fyldt med 0'er eller en diskret værdi.

Da vores mål er at forudsige, om en bankvalutaseddel er autentisk eller ej, kan vi gøre det baseret på sedlens fire attributter:

• variance af Wavelet Transformeret billede. Generelt er variansen en kontinuerlig værdi, der måler, hvor meget datapunkterne er tæt på eller langt fra dataens gennemsnitsværdi. Hvis pointene er tættere på dataens gennemsnitsværdi, er fordelingen tættere på en normalfordeling, hvilket normalt betyder, at dens værdier er mere velfordelte og noget nemmere at forudsige. I den aktuelle billedsammenhæng er dette variansen af ​​de koefficienter, der er resultatet af wavelet-transformationen. Jo mindre varians, jo tættere var koefficienterne på at oversætte det faktiske billede.

• skewness af Wavelet Transformeret billede. Skævheden er en kontinuerlig værdi, der angiver asymmetrien af ​​en fordeling. Hvis der er flere værdier til venstre for middelværdien, er fordelingen negativt skæv, hvis der er flere værdier til højre for middelværdien, er fordelingen positivt skævt, og hvis middelværdien, tilstanden og medianen er ens, er fordelingen symmetrisk. Jo mere symmetrisk en fordeling er, jo tættere er den på en normalfordeling, og dens værdier er også bedre fordelt. I den foreliggende sammenhæng er dette skævheden af ​​de koefficienter, der er resultatet af wavelet-transformationen. Jo mere symmetrisk, jo tættere er koefficienterne vivariance, skewness, curtosis, entropyre til at oversætte det faktiske billede.

• curtosis (eller kurtosis) af Wavelet Transformeret billede. Kurtosen er en kontinuerlig værdi, der ligesom skævhed også beskriver formen på en fordeling. Afhængigt af kurtosiskoefficienten (k) kan en fordeling – sammenlignet med normalfordelingen være mere eller mindre flad – eller have mere eller mindre data i ekstremiteter eller hale. Når fordelingen er mere spredt og fladere, kaldes den platykurtisk; når den er mindre spredt og mere koncentreret i midten, mesokurtic; og når fordelingen er næsten helt koncentreret i midten, kaldes den leptokurtisk. Dette er det samme tilfælde som tidligere tilfælde af varians og skævhed, jo mere mesokurtisk fordelingen er, jo tættere var koefficienterne på at oversætte det faktiske billede.

• entropy af billede. Entropien er også en kontinuerlig værdi, den måler normalt tilfældigheden eller uorden i et system. I sammenhæng med et billede måler entropi forskellen mellem en pixel og dens nabopixel. For vores kontekst, jo mere entropi koefficienterne har, jo mere tab var der ved transformation af billedet - og jo mindre entropi, jo mindre informationstabet.

Den femte variabel var class variabel, som sandsynligvis har 0 og 1 værdier, der siger, om sedlen var ægte eller forfalsket.

Vi kan kontrollere, om den femte kolonne indeholder nuller og ettaller med Pandas' unique() metode:

bankdata['class'].unique()

Ovenstående metode returnerer:

array([0, 1]) 

Ovenstående metode returnerer et array med 0 og 1 værdier. Det betyder, at de eneste værdier i vores klasserækker er nuller og ettaller. Den er klar til at blive brugt som mål i vores superviserede læring.

• class af billede. Dette er en heltalsværdi, den er 0, når billedet er forfalsket, og 1, når billedet er ægte.

Da vi har en spalte med annoteringer af ægte og glem billeder, betyder det, at vores type læring er overvåget.

Vi kan også se, hvor mange poster eller billeder vi har, ved at se på antallet af rækker i dataene via shape ejendom:

bankdata.shape

Dette udsender:

(1372, 5)

Ovenstående linje betyder, at der er 1,372 rækker af transformerede pengesedlerbilleder og 5 kolonner. Det er de data, vi vil analysere.

Vi har importeret vores datasæt og foretaget et par kontroller. Nu kan vi udforske vores data for at forstå dem bedre.

Udforskning af datasættet

Vi har lige set, at der kun er nuller og ettaller i klassekolonnen, men vi kan også vide, i hvilket forhold de er – med andre ord – om der er flere nuller end etaller, flere enere end nuller, eller om antallet af nuller er det samme som antallet af enere, hvilket betyder, at de er det afbalanceret.

For at kende andelen kan vi tælle hver af nul- og en-værdierne i dataene med value_counts() metode:

bankdata['class'].value_counts()

Dette udsender:

0 762
1 610
Name: class, dtype: int64

I resultatet ovenfor kan vi se, at der er 762 nuller og 610 enere, eller 152 flere nuller end enere. Det betyder, at vi har en lille smule mere smedet de rigtige billeder, og hvis denne uoverensstemmelse var større, for eksempel 5500 nuller og 610 enere, kunne det påvirke vores resultater negativt. Når vi først prøver at bruge disse eksempler i vores model – jo flere eksempler der er, betyder det normalt, at jo mere information skal modellen vælge mellem forfalskede eller rigtige sedler – hvis der er få eksempler på rigtige sedler, er modellen tilbøjelig til at blive tager fejl, når de forsøger at genkende dem.

Vi ved allerede, at der er 152 flere forfalskede sedler, men kan vi være sikre på, at det er eksempler nok til, at modellen kan lære? At vide, hvor mange eksempler der er nødvendige for at lære, er et meget svært spørgsmål at besvare, i stedet kan vi forsøge at forstå, i procenter, hvor stor forskellen mellem klasser er.

Det første skridt er at bruge pandaer value_counts() metode igen, men lad os nu se procentdelen ved at inkludere argumentet normalize=True:

bankdata['class'].value_counts(normalize=True)

normalize=True beregner procentdelen af ​​dataene for hver klasse. Indtil videre er procentdelen af ​​forfalskede (0) og rigtige data (1):

0 0.555394
1 0.444606
Name: class, dtype: float64

Det betyder, at cirka (~) 56% af vores datasæt er forfalsket, og 44% af det er ægte. Dette giver os et forhold på 56%-44%, hvilket er det samme som en forskel på 12%. Dette anses statistisk som en lille forskel, fordi det er lige lidt over 10 %, så dataene anses for at være balancerede. Hvis der i stedet for en 56:44-proportion var en 80:20- eller 70:30-proportion, ville vores data blive betragtet som ubalancerede, og vi ville være nødt til at foretage en ubalancebehandling, men det er heldigvis ikke tilfældet.

Vi kan også se denne forskel visuelt ved at tage et kig på klassens eller målets fordeling med et Pandas-præget histogram ved at bruge:

bankdata['class'].plot.hist();

Dette plotter et histogram ved hjælp af datarammestrukturen direkte i kombination med matplotlib bibliotek, der er bag kulisserne.

Ved at se på histogrammet kan vi være sikre på, at vores målværdier er enten 0 eller 1, og at dataene er afbalancerede.

Dette var en analyse af kolonnen, som vi forsøgte at forudsige, men hvad med at analysere de andre kolonner af vores data?

Vi kan se på de statistiske målinger med describe() dataramme metode. Vi kan også bruge .T af transponering – for at invertere kolonner og rækker, hvilket gør det mere direkte at sammenligne på tværs af værdier:

bankdata.describe().T

Dette resulterer i:

 count mean std min 25% 50% 75% max
variance 1372.0 0.433735 2.842763 -7.0421 -1.773000 0.49618 2.821475 6.8248
skewness 1372.0 1.922353 5.869047 -13.7731 -1.708200 2.31965 6.814625 12.9516
curtosis 1372.0 1.397627 4.310030 -5.2861 -1.574975 0.61663 3.179250 17.9274
entropy 1372.0 -1.191657 2.101013 -8.5482 -2.413450 -0.58665 0.394810 2.4495
class 1372.0 0.444606 0.497103 0.0000 0.000000 0.00000 1.000000 1.0000

Bemærk at skævhed og curtose kolonner har middelværdier, der er langt fra standardafvigelsesværdierne, dette indikerer, at de værdier, der er længere fra dataens centrale tendens, eller har en større variabilitet.

Vi kan også tage et kig på hver features distribution visuelt ved at plotte hver features histogram inde i en for loop. Udover at se på fordelingen, ville det være interessant at se på, hvordan punkterne i hver klasse er adskilt med hensyn til hver funktion. For at gøre det kan vi plotte et scatterplot, der laver en kombination af funktioner mellem dem, og tildele forskellige farver til hvert punkt i forhold til dets klasse.

Lad os starte med hver funktions fordeling og plotte histogrammet for hver datakolonne undtagen class kolonne. Det class kolonne vil ikke blive taget i betragtning af dens placering i bankdata-kolonner-arrayet. Alle kolonner vil blive valgt undtagen den sidste med columns[:-1]:

import matplotlib.pyplot as plt for col in bankdata.columns[:-1]: plt.title(col) bankdata[col].plot.hist() plt.show();

Efter at have kørt ovenstående kode, kan vi se, at begge dele skewness , entropy datafordelinger er negativt skæve og curtosis er positivt skæv. Alle fordelinger er symmetriske, og variance er den eneste fordeling, der er tæt på normalen.

Vi kan nu gå videre til anden del og plotte spredningsplottet for hver variabel. For at gøre dette kan vi også vælge alle kolonner undtagen klassen med columns[:-1], brug Seaborn's scatterplot() og to for sløjfer for at opnå variationerne i parring for hver af funktionerne. Vi kan også udelukke parringen af ​​en funktion med sig selv ved at teste, om den første funktion er lig med den anden med en if statement.

import seaborn as sns for feature_1 in bankdata.columns[:-1]: for feature_2 in bankdata.columns[:-1]: if feature_1 != feature_2: print(feature_1, feature_2) sns.scatterplot(x=feature_1, y=feature_2, data=bankdata, hue='class') plt.show();

Bemærk, at alle grafer har både reelle og forfalskede datapunkter, der ikke er tydeligt adskilt fra hinanden, hvilket betyder, at der er en form for superposition af klasser. Da en SVM-model bruger en linje til at adskille mellem klasser, kunne nogen af ​​disse grupper i graferne adskilles med kun én linje? Det virker usandsynligt. Sådan ser de fleste rigtige data ud. Det tætteste vi kan komme på en adskillelse er i kombinationen af skewness , variance eller entropy , variance grunde. Dette skyldes sandsynligvis variance data med en fordelingsform, der er tættere på normalen.

Men at se på alle disse grafer i rækkefølge kan være lidt svært. Vi har alternativet at se alle distributions- og scatterplot-graferne sammen ved at bruge Seaborns pairplot().

Begge tidligere for sløjfer, vi havde lavet, kan erstattes af kun denne linje:

sns.pairplot(bankdata, hue='class');

Når man ser på parplot, ser det ud til, at curtosis , variance ville være den nemmeste kombination af funktioner, så de forskellige klasser kunne adskilles af en linje, eller lineært adskillelige.

Hvis de fleste data er langt fra at være lineært adskillelige, kan vi forsøge at forbehandle dem, ved at reducere dens dimensioner, og også normalisere dens værdier for at forsøge at gøre fordelingen tættere på en normal.

Lad os i dette tilfælde bruge dataene, som de er, uden yderligere forbehandling, og senere kan vi gå et trin tilbage, tilføje dataforbehandlingen og sammenligne resultaterne.

Implementering af SVM med Scikit-Learn

Før vi går mere ind i teorien om, hvordan SVM fungerer, kan vi bygge vores første basismodel med dataene og Scikit-Learns Support Vector Classifier or SVC klasse.

Vores model vil modtage wavelet-koefficienterne og forsøge at klassificere dem baseret på klassen. Det første trin i denne proces er at adskille koefficienterne eller funktioner fra klassen eller mål. Efter det trin er det andet trin at opdele dataene yderligere i et sæt, der skal bruges til modellens læring eller togsæt og en anden, der vil blive brugt til modellens evaluering eller test sæt.

Opdeling af data i tog-/testsæt

I den forrige session forstod og udforskede vi dataene. Nu kan vi opdele vores data i to arrays - en for de fire funktioner og en anden for den femte eller målfunktion. Da vi ønsker at forudsige klassen afhængigt af wavelets-koefficienterne, er vores y vil være class kolonne og vores X vil variance, skewness, curtosisog entropy kolonner.

For at adskille målet og funktionerne kan vi kun tilskrive class kolonne til y, senere dropper den fra datarammen for at tilskrive de resterende kolonner X med .drop() metode:

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

Når dataene er opdelt i attributter og etiketter, kan vi yderligere opdele dem i tog- og testsæt. Dette kunne gøres i hånden, men det model_selection biblioteket i Scikit-Learn indeholder train_test_split() metode, der giver os mulighed for tilfældigt at opdele data i tog- og testsæt.

For at bruge det, kan vi importere biblioteket, ring til train_test_split() metode, gå ind X , y data og definere en test_size at passere som et argument. I dette tilfælde vil vi definere det som 0.20– det betyder, at 20 % af dataene vil blive brugt til test, og de øvrige 80 % til træning.

Denne metode tager tilfældigt prøver, der respekterer den procentdel, vi har defineret, men respekterer Xy-parrene, for at prøvetagningen ikke ville blande forholdet fuldstændigt.

Da prøveudtagningsprocessen i sagens natur er tilfældig, vil vi altid have forskellige resultater, når vi kører metoden. For at kunne få de samme resultater, eller reproducerbare resultater, kan vi definere en konstant kaldet SEED med værdien 42.

Du kan udføre følgende script for at gøre det:

from sklearn.model_selection import train_test_split SEED = 42 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20, random_state = SEED)

Bemærk at train_test_split() metoden returnerer allerede X_train, X_test, y_train, y_test sæt i denne rækkefølge. Vi kan udskrive antallet af prøver adskilt til tog og test ved at få det første (0) element i shape ejendom returneret tuple:

xtrain_samples = X_train.shape[0]
xtest_samples = X_test.shape[0] print(f'There are {xtrain_samples} samples for training and {xtest_samples} samples for testing.')

Dette viser, at der er 1097 prøver til træning og 275 til test.

Træning af modellen

Vi har opdelt dataene i tog- og testsæt. Nu er det tid til at oprette og træne en SVM-model på togdataene. For at gøre det kan vi importere Scikit-Learn's svm bibliotek sammen med Support Vector Classifier klasse, eller SVC klasse.

Efter at have importeret klassen, kan vi oprette en forekomst af den – da vi opretter en simpel SVM-model, forsøger vi at adskille vores data lineært, så vi kan tegne en linje for at dividere vores data – hvilket er det samme som at bruge en lineær funktion – ved at definere kernel='linear' som argument for klassificeringen:

from sklearn.svm import SVC
svc = SVC(kernel='linear')

På denne måde vil klassifikatoren forsøge at finde en lineær funktion, der adskiller vores data. Efter at have oprettet modellen, lad os træne den, eller passer det, med togdataene, ved hjælp af fit() metode og give den X_train funktioner og y_train mål som argumenter.

Vi kan udføre følgende kode for at træne modellen:

svc.fit(X_train, y_train)

Bare sådan er modellen trænet. Indtil videre har vi forstået dataene, opdelt dem, lavet en simpel SVM-model og tilpasset modellen til togdataene.

Det næste trin er at forstå, hvor godt det passer til at beskrive vores data. Med andre ord at svare på, om en lineær SVM var et passende valg.

At forudsige

En måde at svare på, om modellen formåede at beskrive dataene, er at beregne og se på en eller anden klassifikation målinger.

I betragtning af at læringen er superviseret, kan vi lave forudsigelser med X_test og sammenligne disse forudsigelsesresultater – som vi kunne kalde y_pred – med den faktiske y_test eller grundsandhed.

For at forudsige nogle af dataene, modellens predict() metode kan anvendes. Denne metode modtager testfunktionerne, X_test, som et argument og returnerer en forudsigelse, enten 0 eller 1, for hver af dem X_tests rækker.

Efter at have forudsagt X_test data gemmes resultaterne i en y_pred variabel. Så hver af klasserne forudsagt med den simple lineære SVM-model er nu i y_pred variabel.

Dette er forudsigelseskoden:

y_pred = svc.predict(X_test)

I betragtning af at vi har forudsigelserne, kan vi nu sammenligne dem med de faktiske resultater.

Evaluering af modellen

Der er flere måder at sammenligne forudsigelser med faktiske resultater, og de måler forskellige aspekter af en klassifikation. Nogle af de mest brugte klassifikationsmetrikker er:

1. Forvirringsmatrix: når vi skal vide, hvor mange prøver vi fik rigtigt eller forkert for hver klasse. De værdier, der var korrekte og korrekt forudsagte, kaldes sande positive, dem, der blev forudsagt som positive, men ikke var positive, kaldes falske positive. Den samme nomenklatur af sande negativer , falske negativer bruges til negative værdier;

2. Precision: når vores mål er at forstå, hvilke korrekte forudsigelsesværdier, der blev betragtet som korrekte af vores klassifikator. Præcision vil dividere de sande positive værdier med de prøver, der blev forudsagt som positive;

$$
præcision = frac{tekst{true positives}}{text{true positives} + text{false positives}}
$$

3. Recall: almindeligvis beregnet sammen med præcision for at forstå, hvor mange af de sande positive, der blev identificeret af vores klassifikator. Tilbagekaldelsen beregnes ved at dividere de sande positive med alt, der skulle have været forudsagt som positivt.

$$
recall = frac{tekst{sande positives}}{tekst{sande positives} + tekst{falske negativer}}
$$

4. f1 score: er den balancerede eller harmonisk middel af præcision og genkaldelse. Den laveste værdi er 0 og den højeste er 1. Hvornår f1-score er lig med 1, betyder det, at alle klasser var korrekt forudsagt – dette er en meget svær score at opnå med rigtige data (undtagelser findes næsten altid).

$$
tekst{f1-score} = 2* frac{tekst{præcision} * tekst{recall}}{tekst{præcision} + tekst{recall}}
$$

Vi har allerede været bekendt med forvirringsmatrix, præcision, tilbagekaldelse og F1-scoremål. For at beregne dem kan vi importere Scikit-Learn's metrics bibliotek. Dette bibliotek indeholder classification_report , confusion_matrix metoder, returnerer klassifikationsrapportmetoden præcision, tilbagekaldelse og f1-score. Begge classification_report , confusion_matrix kan nemt bruges til at finde ud af værdierne for alle disse vigtige målinger.

Til beregning af metrikkerne importerer vi metoderne, kalder dem og videregiver de forudsagte klassifikationer som argumenter, y_test, og klassificeringsetiketterne, eller y_true.

For en bedre visualisering af forvirringsmatricen kan vi plotte den i en Seaborn's heatmap sammen med mængdeanmærkninger, og for klassificeringsrapporten er det bedst at udskrive resultatet, så dets resultater formateres. Dette er følgende kode:

from sklearn.metrics import classification_report, confusion_matrix cm = confusion_matrix(y_test,y_pred)
sns.heatmap(cm, annot=True, fmt='d').set_title('Confusion matrix of linear SVM') print(classification_report(y_test,y_pred))

Dette viser:

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

I klassificeringsrapporten ved vi, at der er en præcision på 0.99, tilbagekaldelse på 0.99 og en f1-score på 0.99 for de forfalskede sedler eller klasse 0. Disse målinger blev opnået ved hjælp af 148 prøver som vist i støttekolonnen. I mellemtiden, for klasse 1 eller rigtige noter, var resultatet én enhed under, en præcision på 0.98, 0.98 for tilbagekaldelse og samme f1-score. Denne gang blev der brugt 127 billedmålinger til at opnå disse resultater.

Hvis vi ser på forvirringsmatricen, kan vi også se, at fra 148 klasse 0 prøver var 146 korrekt klassificeret, og der var 2 falsk positive, mens der for 127 klasse 1 prøver var 2 falsk negative og 125 sande positive.

Vi kan læse klassifikationsrapporten og forvirringsmatricen, men hvad betyder de?

Fortolkning af resultater

For at finde ud af betydningen, lad os se på alle metrikerne kombineret.

Næsten alle prøverne for klasse 1 var korrekt klassificeret, der var 2 fejl for vores model ved identifikation af faktiske pengesedler. Dette er det samme som 0.98, eller 98 %, tilbagekaldelse. Noget lignende kan siges om klasse 0, kun 2 prøver blev klassificeret forkert, mens 148 er sande negative, hvilket giver en præcision på 99%.

Udover disse resultater markerer alle andre 0.99, hvilket er næsten 1, en meget høj metrisk. Det meste af tiden, når en så høj metrik sker med virkelige data, kan dette være et tegn på en model, der er overjusteret til dataene, eller overmonteret.

Når der er en overtilpasning, kan modellen fungere godt, når den forudsiger de data, der allerede er kendt, men den mister evnen til at generalisere til nye data, hvilket er vigtigt i scenarier i den virkelige verden.

En hurtig test for at finde ud af, om der sker en overfit, er også med togdata. Hvis modellen i nogen grad har husket togdataene, vil metrikken være meget tæt på 1 eller 100%. Husk, at togdataene er større end testdataene – af denne grund – prøv at se på det proportionalt, flere prøver, flere chancer for at lave fejl, medmindre der har været overfit.

For at forudsige med togdata, kan vi gentage, hvad vi har gjort for testdata, men nu med X_train:

y_pred_train = svc.predict(X_train) cm_train = confusion_matrix(y_train,y_pred_train)
sns.heatmap(cm_train, annot=True, fmt='d').set_title('Confusion matrix of linear SVM with train data') print(classification_report(y_train,y_pred_train))

Dette udsender:

 precision recall f1-score support 0 0.99 0.99 0.99 614 1 0.98 0.99 0.99 483 accuracy 0.99 1097 macro avg 0.99 0.99 0.99 1097
weighted avg 0.99 0.99 0.99 1097

Det er let at se, at der ser ud til at være overfit, når først tog-metrikken er 99%, når man har 4 gange mere data. Hvad kan man gøre i dette scenarie?

For at vende overfittet tilbage kan vi tilføje flere togobservationer, bruge en træningsmetode med forskellige dele af datasættet, som f.eks. krydsvalidering, og også ændre de standardparametre, der allerede eksisterer før træning, når du opretter vores model, eller hyperparametre. Det meste af tiden sætter Scikit-learn nogle parametre som standard, og dette kan ske stille, hvis der ikke er meget tid dedikeret til at læse dokumentationen.

Du kan tjekke anden del af denne vejledning (kommer snart!) for at se, hvordan man implementerer krydsvalidering og udfører en hyperparameterjustering.

Konklusion

I denne artikel studerede vi den simple lineære kerne SVM. Vi fik intuitionen bag SVM-algoritmen, brugte et rigtigt datasæt, udforskede dataene og så, hvordan disse data kan bruges sammen med SVM ved at implementere det med Pythons Scikit-Learn-bibliotek.

For at blive ved med at øve dig kan du prøve andre datasæt fra den virkelige verden, som er tilgængelige steder som f.eks Kaggle, UCI, Big Query offentlige datasæt, universiteter og offentlige websteder.

Jeg vil også foreslå, at du udforsker den faktiske matematik bag SVM-modellen. Selvom du ikke nødvendigvis har brug for det for at bruge SVM-algoritmen, er det stadig meget praktisk at vide, hvad der faktisk foregår bag kulisserne, mens din algoritme finder beslutningsgrænser.

• 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-svm-and-kernel-svm-with-pythons-scikit-learn/