Implementazione di altri sapori SVM con Scikit-Learn di Python

Introduzione

Questa guida è la terza e ultima parte di tre guide sulle Support Vector Machine (SVM). In questa guida, continueremo a lavorare con il caso d'uso delle banconote contraffatte, faremo un breve riepilogo dell'idea generale alla base degli SVM, capiremo qual è il trucco del kernel e implementeremo diversi tipi di kernel non lineari con Scikit-Learn.

Nella serie completa di guide SVM, oltre a conoscere altri tipi di SVM, imparerai anche semplici SVM, parametri predefiniti SVM, iperparametri C e Gamma e come possono essere sintonizzati con la ricerca della griglia e la convalida incrociata.

Se desideri leggere le guide precedenti, puoi dare un'occhiata alle prime due guide o vedere quali argomenti ti interessano di più. Di seguito la tabella degli argomenti trattati in ciascuna guida:

1. Implementazione di SVM e Kernel SVM con Scikit-Learn di Python

• Caso d'uso: dimentica le banconote
• Sfondo di SVM
• Modello SVM semplice (lineare).
  • Informazioni sul set di dati
  • Importazione del set di dati
  • Esplorazione del set di dati
• Implementazione di SVM con Scikit-Learn
  • Divisione dei dati in set di treni/test
  • Formazione del modello
  • Fare previsioni
  • Valutazione del modello
  • Interpretazione dei risultati

2. Comprensione degli iperparametri SVM

• L'iperparametro C
• L'iperparametro Gamma

3. Implementazione di altre versioni SVM con Scikit-Learn di Python

• L'idea generale delle SVM (un riepilogo)
• Kernel (trucco) SVM
• Implementazione di SVM del kernel non lineare con Scikit-Learn
• Importazione di librerie
  • Importazione del set di dati
  • Divisione dei dati in feature (X) e target (y)
  • Divisione dei dati in set di treni/test
  • Allenare l'algoritmo
• Nucleo polinomiale
  • Fare previsioni
  • Valutazione dell'algoritmo
• kernel gaussiano
  • Previsione e valutazione
• Kernel sigmoideo
  • Previsione e valutazione
• Confronto delle prestazioni del kernel non lineare

Ricordiamo cos'è SVM prima di vedere alcune interessanti variazioni del kernel SVM.

L'idea generale delle SVM

Nel caso di dati linearmente separabili in due dimensioni (come mostrato in Fig. 1) l'approccio tipico dell'algoritmo di apprendimento automatico sarebbe quello di cercare di trovare un confine che divida i dati in modo tale da minimizzare l'errore di classificazione errata. Se osservi attentamente la figura 1, nota che possono esserci diversi confini (infiniti) che dividono correttamente i punti dati. Le due linee tratteggiate e la linea continua sono tutte classificazioni valide dei dati.

Fig 1: Confini decisionali multipli

Quando SVM sceglie il file confine di decisione, sceglie un confine che massimizza la distanza tra se stesso e i punti dati più vicini delle classi. Sappiamo già che i punti dati più vicini sono i vettori di supporto e che la distanza può essere parametrizzata sia da C ed gamma iperparametri.

Nel calcolare quel limite decisionale, l'algoritmo sceglie quanti punti considerare e fino a che punto può spingersi il margine: questo configura un problema di massimizzazione del margine. Per risolvere il problema di massimizzazione del margine, SVM utilizza i vettori di supporto (come mostrato in Fig. 2) e cerca di capire quali sono i valori ottimali che mantengono maggiore la distanza del margine, classificando correttamente più punti in base alla funzione utilizzata per separare i dati.

Fig 2: Limite decisionale con vettori di supporto

Questo è il motivo per cui SVM differisce da altri algoritmi di classificazione, una volta che non trova semplicemente un confine decisionale, ma finisce per trovare il confine decisionale ottimale.

C'è una complessa matematica derivata dalla statistica e dai metodi computazionali coinvolti dietro la ricerca dei vettori di supporto, il calcolo del margine tra il confine decisionale ei vettori di supporto e la massimizzazione di tale margine. Questa volta non entreremo nei dettagli di come si svolge la matematica.

È sempre importante approfondire e assicurarsi che gli algoritmi di apprendimento automatico non siano una sorta di incantesimo misterioso, anche se non conoscere ogni dettaglio matematico in questo momento non ha impedito e non ti impedirà di eseguire l'algoritmo e ottenere risultati.

Kernel (trucco) SVM

Nella sezione precedente, abbiamo ricordato e organizzato l'idea generale di SVM, vedendo come può essere utilizzato per trovare il limite decisionale ottimale per dati linearmente separabili. Tuttavia, nel caso di dati non linearmente separabili, come quello mostrato in Fig. 3, sappiamo già che una linea retta non può essere utilizzata come confine decisionale.

Fig 3: Dati non linearmente separabili

Piuttosto, possiamo usare la versione modificata di SVM di cui avevamo discusso all'inizio, chiamata Kernel SVM.

Fondamentalmente, ciò che farà il kernel SVM è proiettare i dati non linearmente separabili di dimensioni inferiori nella loro forma corrispondente in dimensioni superiori. Questo è un trucco, perché quando si proiettano dati non linearmente separabili in dimensioni superiori, la forma dei dati cambia in modo tale da diventare separabile. Ad esempio, quando si pensa a 3 dimensioni, i punti dati di ciascuna classe potrebbero finire per essere allocati in una dimensione diversa, rendendola separabile. Un modo per aumentare le dimensioni dei dati può essere esponenziale. Ancora una volta, c'è una matematica complessa coinvolta in questo, ma non devi preoccuparti di questo per usare SVM. Piuttosto, possiamo usare la libreria Scikit-Learn di Python per implementare e usare i kernel non lineari nello stesso modo in cui abbiamo usato quelli lineari.

Implementazione di SVM del kernel non lineare con Scikit-Learn

In questa sezione, utilizzeremo lo stesso set di dati per prevedere se una banconota è reale o contraffatta in base alle quattro caratteristiche che già conosciamo.

Vedrai che il resto dei passaggi sono tipici passaggi di apprendimento automatico e richiedono pochissime spiegazioni fino a quando non raggiungiamo la parte in cui addestriamo i nostri SVM del kernel non lineare.

Importazione di librerie

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

Importazione del set di dati

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)

Divisione dei dati in feature (X) e target (y)

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

Divisione dei dati in set di treni/test

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

Allenare l'algoritmo

Per addestrare il kernel SVM, useremo lo stesso SVC classe degli Scikit-Learn svm biblioteca. La differenza sta nel valore del parametro del kernel di SVC classe.

Nel caso del semplice SVM abbiamo usato "lineare" come valore per il parametro del kernel. Tuttavia, come accennato in precedenza, per il kernel SVM, possiamo usare kernel gaussiani, polinomiali, sigmoidali o computabili. Implementeremo kernel polinomiali, gaussiani e sigmoidali e esamineremo le sue metriche finali per vedere quale sembra adattarsi alle nostre classi con una metrica più alta.

1. Nucleo polinomiale

In algebra, un polinomio è un'espressione della forma:

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

Questo ha variabili, come a ed b, costanti, nel nostro esempio, 9 e coefficienti (costanti accompagnate da variabili), come ad esempio 2 ed 4. 3 è considerato il grado del polinomio.

Esistono tipi di dati che possono essere meglio descritti quando si utilizza una funzione polinomiale, qui, ciò che il kernel farà è mappare i nostri dati su un polinomio di cui sceglieremo il grado. Più alto è il grado, più la funzione cercherà di avvicinarsi ai dati, quindi il limite decisionale è più flessibile (e più incline all'overfit): più basso è il grado, meno flessibile.

Quindi, per implementare il nucleo polinomiale, oltre a scegliere il poly kernel, passeremo anche un valore per il degree parametro del SVC classe. Di seguito il codice:

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

Fare previsioni

Ora, una volta addestrato l'algoritmo, il passo successivo è fare previsioni sui dati del test.

Come abbiamo fatto prima, possiamo eseguire il seguente script per farlo:

y_pred_poly = svclassifier.predict(X_test)

Valutazione dell'algoritmo

Come al solito, il passo finale è fare valutazioni sul kernel polinomiale. Visto che abbiamo ripetuto più volte il codice per il rapporto di classificazione e la matrice di confusione, trasformiamolo in una funzione che display_results dopo aver ricevuto i rispettivi y_test, y_pred e titolo alla matrice di confusione del Seaborn con 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))

Ora possiamo chiamare la funzione e guardare i risultati ottenuti con il kernel polinomiale:

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

L'output è simile a questo:

 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

Ora possiamo ripetere gli stessi passaggi per i kernel gaussiani e sigmoidali.

2. Kernel gaussiano

Per usare il kernel gaussiano, dobbiamo solo specificare 'rbf' come valore per il kernel parametro della classe SVC:

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

Quando esplori ulteriormente questo kernel, puoi anche utilizzare la ricerca della griglia per combinarlo con diversi C ed gamma valori.

Previsione e valutazione

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)

L'output del kernel gaussiano SVM è simile al seguente:

 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. Kernel sigmoideo

Infine, usiamo un kernel sigmoid per implementare Kernel SVM. Dai un'occhiata al seguente script:

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

Per usare il kernel sigmoid, devi specificare 'sigmoid' come valore per il file kernel parametro del SVC classe.

Previsione e valutazione

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)

L'output del kernel SVM con il kernel Sigmoid è simile al seguente:

 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

Confronto delle prestazioni del kernel non lineare

Se confrontiamo brevemente le prestazioni dei diversi tipi di kernel non lineari, potrebbe sembrare che il kernel sigmoid abbia le metriche più basse, quindi le prestazioni peggiori.

Tra i kernel gaussiano e polinomiale, possiamo vedere che il kernel gaussiano ha raggiunto un tasso di previsione perfetto del 100%, che di solito è sospetto e può indicare un overfit, mentre il kernel polinomiale ha classificato erroneamente 68 istanze di classe 1.

Pertanto, non esiste una regola rigida e veloce su quale kernel si comporta meglio in ogni scenario o nel nostro scenario attuale senza ulteriori ricerche di iperparametri, comprensione della forma di ogni funzione, esplorazione dei dati e confronto dei risultati di train e test per vedere se l'algoritmo sta generalizzando.

Si tratta di testare tutti i kernel e selezionare quello con la combinazione di parametri e preparazione dei dati che dia i risultati attesi in base al contesto del progetto.

Andare oltre - Progetto end-to-end portatile

La tua natura curiosa ti fa venire voglia di andare oltre? Ti consigliamo di dare un'occhiata al nostro Progetto guidato: "Previsione pratica dei prezzi delle abitazioni - Apprendimento automatico in Python".

In questo progetto guidato imparerai come creare potenti modelli di machine learning tradizionali e modelli di deep learning, utilizzare Ensemble Learning e formare meta-discenti per prevedere i prezzi delle case da un sacco di modelli Scikit-Learn e Keras.

Utilizzando Keras, l'API di deep learning basata su Tensorflow, sperimenteremo architetture, costruiremo un insieme di modelli impilati e addestreremo un meta-studente rete neurale (modello di livello 1) per determinare il prezzo di una casa.

Il deep learning è sorprendente, ma prima di ricorrere ad esso, si consiglia anche di tentare di risolvere il problema con tecniche più semplici, come con apprendimento superficiale algoritmi. La nostra performance di base sarà basata su a Regressione casuale della foresta algoritmo. Inoltre, esploreremo la creazione di insiemi di modelli attraverso Scikit-Learn tramite tecniche come insaccamento ed voto.

Questo è un progetto end-to-end e, come tutti i progetti di Machine Learning, inizieremo con – con Analisi dei dati esplorativi, Seguita da Pre-elaborazione dei dati e infine Edificio poco profondo ed Modelli di apprendimento profondo per adattarsi ai dati che abbiamo esplorato e ripulito in precedenza.

Conclusione

In questo articolo abbiamo fatto un breve riepilogo sugli SVM, studiato il trucco del kernel e implementato diversi tipi di SVM non lineari.

Ti suggerisco di implementare ogni kernel e andare oltre. Puoi esplorare la matematica utilizzata per creare ciascuno dei diversi kernel, perché sono stati creati e le differenze relative ai loro iperparametri. In questo modo imparerai le tecniche e quale tipo di kernel è meglio applicare a seconda del contesto e dei dati disponibili.

Avere una chiara comprensione di come funziona ogni kernel e quando usarli ti aiuterà sicuramente nel tuo viaggio. Facci sapere come stanno andando i progressi e buona programmazione!

• Distribuzione di contenuti basati su SEO e PR. Ricevi amplificazione oggi.
• Platoblockchain. Web3 Metaverse Intelligence. Conoscenza amplificata. Accedi qui.
• Coniare il futuro con Adryenn Ashley. Accedi qui.
• Fonte: https://stackabuse.com/implementing-other-svm-flavors-with-pythons-scikit-learn/