Comprensione degli iperparametri SVM

Introduzione

Questa guida è la seconda parte di tre guide sulle Support Vector Machines (SVM). In questa guida, continueremo a lavorare sul caso d'uso delle banconote contraffatte, comprenderemo quali parametri SVM sono già stati impostati da Scikit-learn, quali sono gli iperparametri C e Gamma e come regolarli utilizzando la convalida incrociata e la ricerca sulla griglia.

Nella serie completa di guide SVM, oltre agli iperparametri SVM, imparerai anche il semplice SVM, un concetto chiamato trucco del kerneled esplorare altri tipi di SVM.

Se desideri leggere tutte le guide, dai un'occhiata alla prima guida, oppure vedi quali 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 (Prossimamente!)

• L'idea generale delle SVM (un riepilogo)
• Kernel (trucco) SVM
• Implementazione del kernel SVM non lineare con Scikit-Learn
• Importazione di librerie
  • Importazione del set di dati
  • Suddivisione 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

Impariamo come implementare la convalida incrociata ed eseguire un'ottimizzazione degli iperparametri.

Iperparametri SVM

Per vedere tutti i parametri del modello che sono già stati impostati da Scikit-learn e i suoi valori predefiniti, possiamo usare il file get_params() Metodo:

svc.get_params()

Questo metodo visualizza:

{'C': 1.0, 'break_ties': False, 'cache_size': 200, 'class_weight': None, 'coef0': 0.0, 'decision_function_shape': 'ovr', 'degree': 3, 'gamma': 'scale', 'kernel': 'linear', 'max_iter': -1, 'probability': False, 'random_state': None, 'shrinking': True, 'tol': 0.001, 'verbose': False}

Si noti che sono già stati impostati un totale di 15 iperparametri, questo accade perché l'algoritmo SVM ha molte varianti. Abbiamo usato il kernel lineare per ottenere una funzione lineare, ma ci sono anche kernel che descrivono altri tipi di funzioni e quei kernel sono parametrizzati in modi diversi.

Queste variazioni rendono il modello più flessibile e adatto a trovare una separazione tra diverse forme di dati. Se possiamo tracciare una linea per separare le nostre classi, allora a nucleo lineare sarà una buona opzione, se abbiamo bisogno di una curva, allora a polinomio kernel potrebbe essere la scelta migliore, se i nostri dati hanno forme circolari, allora a Funzione a base radiale or RBF kernel si adatterà meglio ai dati, se ci sono valori al di sopra e al di sotto di una soglia, a sigma kernel potrebbe separare meglio le classi. Da quanto abbiamo esplorato nei nostri dati, sembra che un kernel RBF o polinomiale sarebbe più adatto di un kernel lineare.

Ora che abbiamo un'idea che ci sono 4 tipi di diverse funzioni del kernel, possiamo tornare ai parametri. Quando l'algoritmo SVM cerca di trovare una separazione tra le classi, abbiamo già capito che disegna una classificazione margine tra i vettori di supporto e la linea di separazione (o curva).

Questo margine è, in un certo senso, come un cuscinetto tra la linea di separazione ei punti. La dimensione del margine può variare, quando il margine è inferiore , c'è meno spazio per i punti che cadono al di fuori del margine, rendendo più chiara la separazione tra le classi, quindi vengono classificato correttamente, al contrario, quando il margine è superiore, se assunto singolarmente., la separazione tra le classi è meno netta e possono esserlo più campioni erroneamente classificato. In altre parole, un margine più piccolo significa campioni classificati più correttamente, e anche un di più rigido classificatore, mentre un margine più ampio denota più campioni classificati erroneamente, ma un altro flessibile classificatore.

Quando si scelgono quei margini, il parametro che li determina è il C parametro.

L'iperparametro C

Il C parametro è inversamente proporzionale alla dimensione del margine, questo significa che il superiore, se assunto singolarmente. il valore di C, le inferiore il margine e, viceversa, il inferiore il valore di C, le superiore, se assunto singolarmente. il margine. IL C parametro può essere utilizzato insieme a qualsiasi kernel, indica all'algoritmo quanto evitare di classificare erroneamente ogni campione di addestramento, per questo motivo è anche noto come regolarizzazione. Il nostro kernel lineare SVM ha utilizzato a C di 1.0, che è a grandi valore e dà a margine minore.

Possiamo sperimentare con a inferiore valore di 'C' e capire in pratica cosa succede con a margine maggiore. Per fare ciò, creeremo un nuovo classificatore, svc_ce modificare solo il valore di C a 0.0001. Ripetiamo anche il fit ed predict passaggi:

svc_c = SVC(kernel='linear', C=0.0001)
svc_c.fit(X_train, y_train)
y_pred_c = svc_c.predict(X_test)

Ora possiamo guardare i risultati per i dati del test:

print(classification_report(y_test, y_pred_c)) cm_c = confusion_matrix(y_test, y_pred_c)
sns.heatmap(cm_c, annot=True, fmt='d').set_title('Confusion matrix of linear SVM with C=0.0001')

Questo produce:

 precision recall f1-score support 0 0.82 0.96 0.88 148 1 0.94 0.76 0.84 127 accuracy 0.87 275 macro avg 0.88 0.86 0.86 275
weighted avg 0.88 0.87 0.86 275

Usando un più piccolo C e ottenendo un margine maggiore, il classificatore è diventato più flessibile e con più errori di classificazione. Nel rapporto di classificazione, possiamo vedere che il f1-score, precedentemente 0.99 per entrambe le classi, è sceso a 0.88 per la classe 0 ea 0.84 per la classe 1. Nella matrice di confusione, il modello è passato da 2 a 6 falsi positivi e da 2 a 31 falsi negativi.

Possiamo anche ripetere il predict passo e guardare i risultati per verificare se c'è ancora un overfit quando si utilizzano i dati del treno:

y_pred_ct = svc_c.predict(X_train) cm_ct = confusion_matrix(y_train, y_pred_ct)
sns.heatmap(cm_ct, annot=True, fmt='d').set_title('Confusion matrix of linear SVM with C=0.0001 and train data') print(classification_report(y_train, y_pred_ct))

Questo risulta in:

 precision recall f1-score support 0 0.88 0.96 0.92 614 1 0.94 0.84 0.88 483 accuracy 0.90 1097 macro avg 0.91 0.90 0.90 1097
weighted avg 0.91 0.90 0.90 1097

Guardando i risultati con un file più piccolo C e i dati del treno, possiamo vedere che c'è stato un miglioramento nell'overfit, ma una volta che la maggior parte delle metriche è ancora più alta per i dati del treno, sembra che l'overfit non sia stato risolto. Quindi, basta cambiare il file C parametro non era sufficiente per rendere il modello più flessibile e migliorarne la generalizzazione.

Fino a questo punto, abbiamo capito i margini in SVM e come incidono sul risultato complessivo dell'algoritmo, ma per quanto riguarda la linea (o curva) che separa le classi? Questa linea è la confine di decisione. Quindi, sappiamo già che i margini hanno un impatto sulla flessibilità del confine decisionale nei confronti degli errori, ora possiamo dare un'occhiata a un altro parametro che influisce anche sul confine decisionale.

L'iperparametro Gamma

È possibile scegliere limiti decisionali infiniti, alcuni di questi limiti separeranno le classi e altri no. Quando si sceglie un confine di decisione effettivo, dovrebbero essere considerati i primi 10 punti più vicini di ciascuna classe? O dovrebbero essere considerati più punti, compresi i punti che sono lontani? In SVM, quella scelta di intervallo è definita da un altro iperparametro, gamma.

Come C, gamma è in qualche modo inversamente proporzionale alla sua distanza. IL superiore il suo valore, il più vicina sono i punti considerati per il confine di decisione, e il minore , il gamma, le più lontano i punti sono considerati anche per la scelta del confine decisionale.

Un altro impatto della gamma è che maggiore è il suo valore, più l'ambito del confine decisionale si avvicina ai punti attorno ad esso, rendendolo più frastagliato e incline all'overfit - e più basso è il suo valore, più uniforme e regolare è il confine decisionale la superficie diventa, inoltre, meno incline al sovradimensionamento. Questo è vero per qualsiasi iperpiano, ma può essere osservato più facilmente quando si separano i dati in dimensioni superiori. In alcune documentazioni, gamma può anche essere indicato come sigma.

Nel caso del nostro modello, il valore predefinito di gamma Prima scale. Come si può vedere nel Documentazione SVC di Scikit-learn, significa che il suo valore è:

$$
gamma = (1/ testo{n_caratteristiche} * X.var())
$$

or

$$
gamma = (1/ testo{numero_di_caratteristiche} * testo{caratteristiche_varianza})
$$

Nel nostro caso, dobbiamo calcolare la varianza di X_train, moltiplicalo per 4 e dividi il risultato per 1. Possiamo farlo con il seguente codice:

number_of_features = X_train.shape[1] features_variance = X_train.values.var()
gamma = 1/(number_of_features * features_variance)
print('gamma:', gamma)

Questo produce:

gamma: 0.013924748072859962

C'è anche un altro modo per guardare al valore di gamma, accedendo all'oggetto del classificatore gamma parametro con ._gamma:

svc._gamma 

Possiamo vedere che il gamma utilizzato nel nostro classificatore era basso, quindi considerava anche i punti più lontani.

Non esiste una regola su come scegliere i valori per gli iperparametri, come C e gamma: dipenderà da quanto tempo e quali risorse sono disponibili per sperimentare diversi valori di iperparametri, quali trasformazioni possono essere apportate ai dati e quali risultati sono attesi . Il modo usuale per cercare i valori dell'iperparametro è combinare ciascuno dei valori proposti attraverso a ricerca sulla griglia insieme a una procedura che applica quei valori di iperparametro e ottiene metriche per diverse parti dei dati chiamati convalida incrociata. In Scikit-learn, questo è già implementato come file GridSearchCV (CV dalla convalida incrociata).

Per eseguire una ricerca in griglia con convalida incrociata, dobbiamo importare il file GridSearchCV, definire un dizionario con i valori degli iperparametri che verranno sperimentati, ad esempio il tipo di kernel, l'intervallo per C, E per gamma, creare un'istanza di SVC, definire il score o la metrica verrà utilizzata per la valutazione (qui sceglieremo di ottimizzare sia per la precisione che per il richiamo, quindi utilizzeremo f1-score), il numero di divisioni che verranno effettuate nei dati per l'esecuzione della ricerca cv – il valore predefinito è 5, ma è buona norma usarne almeno 10 – qui useremo 5 ripiegamenti dati per renderlo più chiaro quando si confrontano i risultati.

Il GridSearchCV ha una fit metodo che riceve i nostri dati del treno e li suddivide ulteriormente in set di treni e test per la convalida incrociata. Possiamo impostare return_train_score a true per confrontare i risultati e garantire che non ci sia overfit.

Questo è il codice per la ricerca in griglia con validazione incrociata:

from sklearn.model_selection import GridSearchCV parameters_dictionary = {'kernel':['linear', 'rbf'], 'C':[0.0001, 1, 10], 'gamma':[1, 10, 100]}
svc = SVC() grid_search = GridSearchCV(svc, parameters_dictionary, scoring = 'f1', return_train_score=True, cv = 5, verbose = 1) grid_search.fit(X_train, y_train)

Questo codice restituisce:

Fitting 5 folds for each of 18 candidates, totalling 90 fits
# and a clickable GridSeachCV object schema

Dopo aver eseguito la ricerca dell'iperparametro, possiamo utilizzare il file best_estimator_, best_params_ ed best_score_ proprietà per ottenere il modello migliore, i valori dei parametri e il punteggio f1 più alto:

best_model = grid_search.best_estimator_
best_parameters = grid_search.best_params_
best_f1 = grid_search.best_score_ print('The best model was:', best_model)
print('The best parameter values were:', best_parameters)
print('The best f1-score was:', best_f1)

Questo risulta in:

The best model was: SVC(C=1, gamma=1)
The best parameter values were: {'C': 1, 'gamma': 1, 'kernel': 'rbf'}
The best f1-score was: 0.9979166666666666

Confermando la nostra ipotesi iniziale osservando i dati, il modello migliore non ha un kernel lineare, ma uno non lineare, RBF.

Entrambi C ed gamma hanno il valore di 1, e il f1-score è molto alto, 0.99. Dato che il valore è alto, vediamo se c'è stato un overfit sbirciando i punteggi medi del test e del treno che abbiamo restituito, all'interno del cv_results_ oggetto:

gs_mean_test_scores = grid_search.cv_results_['mean_test_score']
gs_mean_train_scores = grid_search.cv_results_['mean_train_score'] print("The mean test f1-scores were:", gs_mean_test_scores)
print("The mean train f1-scores were:", gs_mean_train_scores)

I punteggi medi sono stati:

The mean test f1-scores were: [0.78017291 0. 0.78017291 0. 0.78017291 0. 0.98865407 0.99791667 0.98865407 0.76553515 0.98865407 0.040291 0.98656 0.99791667 0.98656 0.79182565 0.98656 0.09443985] The mean train f1-scores were: [0.78443424 0. 0.78443424 0. 0.78443424 0. 0.98762683 1. 0.98762683 1. 0.98762683 1. 0.98942923 1. 0.98942923 1. 0.98942923 1. ]

Osservando i punteggi medi, possiamo vedere che quello più alto, 0.99791667, appare due volte e in entrambi i casi il punteggio nei dati del treno era 1. Ciò indica che l'overfit persiste. Da qui, sarebbe interessante tornare alla preparazione dei dati e capire se ha senso normalizzare i dati, effettuare qualche altro tipo di trasformazione dei dati e anche creare nuove funzionalità con l'ingegneria delle funzionalità.

Abbiamo appena visto una tecnica per trovare gli iperparametri del modello e abbiamo già accennato a qualcosa sulla separabilità lineare, i vettori di supporto, il limite decisionale, la massimizzazione dei margini e il trucco del kernel. SVM è un algoritmo complesso, di solito con molti concetti matematici coinvolti e piccole parti modificabili che devono essere adattate per riunirsi nel loro insieme.

Combiniamo ciò che abbiamo visto finora, facciamo un riepilogo di come funzionano tutte le parti di SVM e poi diamo un'occhiata ad alcune delle altre implementazioni del kernel insieme ai loro risultati.

Conclusione

In questo articolo abbiamo compreso i parametri predefiniti alla base dell'implementazione SVM di Scikit-Learn. Abbiamo capito quali sono i parametri C e Gamma e in che modo la modifica di ciascuno di essi può influire sul modello SVM.

Abbiamo anche imparato a utilizzare la ricerca della griglia per cercare i migliori valori C e Gamma e utilizzare la convalida incrociata per generalizzare meglio i nostri risultati e garantire che non vi sia alcuna forma di perdita di dati.

L'esecuzione di un'ottimizzazione dell'iperparametro con la ricerca della griglia e la convalida incrociata è una pratica comune nella scienza dei dati, quindi ti consiglio vivamente di implementare le tecniche, eseguire il codice e vedere i collegamenti tra i valori dell'iperparametro e le modifiche nelle previsioni SVM.

• 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/understanding-svm-hyperparameters/