Support Vector Machine o SVM è uno degli algoritmi di apprendimento supervisionato più popolari, utilizzato per problemi di classificazione e regressione. Tuttavia, viene utilizzato principalmente per problemi di classificazione nell'apprendimento automatico.
L'obiettivo dell'algoritmo SVM è creare la migliore linea o limite decisionale in grado di separare lo spazio n-dimensionale in classi in modo da poter facilmente inserire il nuovo punto dati nella categoria corretta in futuro. Questo limite decisionale migliore è chiamato iperpiano.
SVM sceglie i punti/vettori estremi che aiutano a creare l'iperpiano. Questi casi estremi sono chiamati vettori di supporto e quindi l'algoritmo è definito Support Vector Machine. Considera il diagramma seguente in cui esistono due diverse categorie classificate utilizzando un confine decisionale o iperpiano:
Esempio: SVM può essere compreso con l'esempio che abbiamo utilizzato nel classificatore KNN. Supponiamo di vedere uno strano gatto che ha anche alcune caratteristiche dei cani, quindi se vogliamo un modello in grado di identificare con precisione se si tratta di un gatto o di un cane, è possibile creare tale modello utilizzando l'algoritmo SVM. Per prima cosa addestreremo il nostro modello con tante immagini di cani e gatti in modo che possa conoscere le diverse caratteristiche di cani e gatti, quindi lo testeremo con questa strana creatura. Quindi, poiché il vettore di supporto crea un confine decisionale tra questi due dati (gatto e cane) e sceglie i casi estremi (vettori di supporto), vedrà il caso estremo di cane e gatto. In base ai vettori di supporto lo classificherà come gatto. Considera il diagramma seguente:
È possibile utilizzare l'algoritmo SVM Rilevamento volti, classificazione delle immagini, categorizzazione del testo, eccetera.
pendenza indefinita
Tipi di SVM
La SVM può essere di due tipi:
Iperpiano e vettori di supporto nell'algoritmo SVM:
Iperpiano: Possono esserci più linee/limiti decisionali per separare le classi nello spazio n-dimensionale, ma dobbiamo trovare il miglior confine decisionale che aiuti a classificare i punti dati. Questo limite migliore è noto come iperpiano di SVM.
Le dimensioni dell'iperpiano dipendono dalle caratteristiche presenti nel set di dati, il che significa che se ci sono 2 caratteristiche (come mostrato nell'immagine), l'iperpiano sarà una linea retta. E se ci sono 3 caratteristiche, l'iperpiano sarà un piano a 2 dimensioni.
Creiamo sempre un iperpiano che abbia un margine massimo, ovvero la distanza massima tra i punti dati.
Vettori di supporto:
I punti dati o vettori che sono i più vicini all'iperpiano e che influenzano la posizione dell'iperpiano sono definiti vettori di supporto. Poiché questi vettori supportano l'iperpiano, quindi chiamato vettore di supporto.
Come funziona SVM?
SVM lineare:
Il funzionamento dell'algoritmo SVM può essere compreso utilizzando un esempio. Supponiamo di avere un set di dati con due tag (verde e blu) e che abbia due caratteristiche x1 e x2. Vogliamo un classificatore in grado di classificare la coppia (x1, x2) di coordinate in verde o blu. Considera l'immagine qui sotto:
Quindi, poiché è uno spazio 2-d, quindi utilizzando semplicemente una linea retta, possiamo facilmente separare queste due classi. Ma possono esserci più linee che possono separare queste classi. Considera l'immagine qui sotto:
Pertanto, l’algoritmo SVM aiuta a trovare la linea o il limite decisionale migliore; questo confine o regione migliore è chiamato a iperpiano . L'algoritmo SVM trova il punto più vicino delle linee di entrambe le classi. Questi punti sono chiamati vettori di supporto. La distanza tra i vettori e l'iperpiano è chiamata as margine . E l’obiettivo di SVM è massimizzare questo margine. IL iperpiano con il margine massimo è chiamato iperpiano ottimale .
SVM non lineare:
Se i dati sono disposti linearmente, possiamo separarli utilizzando una linea retta, ma per i dati non lineari non possiamo tracciare un'unica linea retta. Considera l'immagine qui sotto:
Quindi, per separare questi punti dati, dobbiamo aggiungere un'altra dimensione. Per i dati lineari, abbiamo utilizzato due dimensioni xey, quindi per i dati non lineari aggiungeremo una terza dimensione z. Può essere calcolato come:
z=x<sup>2</sup> +y<sup>2</sup>
Aggiungendo la terza dimensione, lo spazio campione diventerà come nell'immagine seguente:
Quindi ora SVM dividerà i set di dati in classi nel modo seguente. Considera l'immagine qui sotto:
Dato che siamo nello spazio tridimensionale, sembra un piano parallelo all'asse x. Se lo convertiamo nello spazio 2d con z=1, allora diventerà come:
Quindi otteniamo una circonferenza di raggio 1 in caso di dati non lineari.
Implementazione Python della Support Vector Machine
identificatori validi Java
Ora implementeremo l'algoritmo SVM utilizzando Python. Qui utilizzeremo lo stesso set di dati dati utente , che abbiamo utilizzato nella regressione logistica e nella classificazione KNN.
Fino alla fase di pre-elaborazione dei dati, il codice rimarrà lo stesso. Di seguito è riportato il codice:
#Data Pre-processing Step # importing libraries import numpy as nm import matplotlib.pyplot as mtp import pandas as pd #importing datasets data_set= pd.read_csv('user_data.csv') #Extracting Independent and dependent Variable x= data_set.iloc[:, [2,3]].values y= data_set.iloc[:, 4].values # Splitting the dataset into training and test set. from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test= train_test_split(x, y, test_size= 0.25, random_state=0) #feature Scaling from sklearn.preprocessing import StandardScaler st_x= StandardScaler() x_train= st_x.fit_transform(x_train) x_test= st_x.transform(x_test)
Dopo aver eseguito il codice sopra, pre-elaboreremo i dati. Il codice fornirà il set di dati come:
L'output scalato per il set di test sarà:
Adattamento del classificatore SVM al set di addestramento:
Ora il set di addestramento verrà adattato al classificatore SVM. Per creare il classificatore SVM, importeremo SVC classe da Sklearn.svm biblioteca. Di seguito è riportato il codice:
from sklearn.svm import SVC # 'Support vector classifier' classifier = SVC(kernel='linear', random_state=0) classifier.fit(x_train, y_train)
Nel codice precedente, abbiamo utilizzato kernel='lineare' , poiché qui stiamo creando SVM per dati separabili linearmente. Tuttavia, possiamo modificarlo per dati non lineari. Quindi abbiamo adattato il classificatore al set di dati di addestramento (x_train, y_train)
Produzione:
Out[8]: SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0, decision_function_shape='ovr', degree=3, gamma='auto_deprecated', kernel='linear', max_iter=-1, probability=False, random_state=0, shrinking=True, tol=0.001, verbose=False)
Le prestazioni del modello possono essere modificate modificando il valore di C (fattore di regolarizzazione), gamma e kernel .
Ora prevederemo l'output per il set di test. Per questo creeremo un nuovo vettore y_pred. Di seguito è riportato il codice:
#Predicting the test set result y_pred= classifier.predict(x_test)
Dopo aver ottenuto il vettore y_pred, possiamo confrontare il risultato di y_pred E y_prova per verificare la differenza tra il valore effettivo e il valore previsto.
Produzione: Di seguito è riportato l'output per la previsione del set di test:
Ora vedremo le prestazioni del classificatore SVM e quante previsioni errate ci sono rispetto al classificatore di regressione logistica. Per creare la matrice di confusione, dobbiamo importare il file matrice_confusione funzione della libreria sklearn. Dopo aver importato la funzione, la chiameremo utilizzando una nuova variabile cm . La funzione accetta principalmente due parametri sì_vero (i valori effettivi) e y_pred (il valore target restituito dal classificatore). Di seguito è riportato il codice:
#Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred)
Produzione:
Come possiamo vedere nell'immagine di output sopra, ci sono 66+24= 90 previsioni corrette e 8+2= 10 previsioni corrette. Pertanto possiamo dire che il nostro modello SVM è migliorato rispetto al modello di regressione logistica.
Ora visualizzeremo il risultato del set di training, di seguito è riportato il codice:
from matplotlib.colors import ListedColormap x_set, y_set = x_train, y_train x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('red', 'green'))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('red', 'green'))(i), label = j) mtp.title('SVM classifier (Training set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show()
Produzione:
Eseguendo il codice sopra, otterremo l'output come:
definire informatico
Come possiamo vedere, l'output di cui sopra appare simile all'output della regressione logistica. Nell'output, abbiamo ottenuto la linea retta come iperpiano perché abbiamo utilizzato un kernel lineare nel classificatore . E abbiamo anche discusso sopra che per lo spazio 2d, l'iperpiano in SVM è una linea retta.
#Visulaizing the test set result from matplotlib.colors import ListedColormap x_set, y_set = x_test, y_test x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('red','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('red', 'green'))(i), label = j) mtp.title('SVM classifier (Test set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show()
Produzione:
Eseguendo il codice sopra, otterremo l'output come:
Come possiamo vedere nell'immagine di output sopra, il classificatore SVM ha diviso gli utenti in due regioni (acquistati o non acquistati). Gli utenti che hanno acquistato il SUV si trovano nella regione rossa con i punti scatter rossi. E gli utenti che non hanno acquistato il SUV si trovano nella regione verde con punti scatter verdi. L'iperpiano ha diviso le due classi in variabile Acquistata e non acquistata.