Ottimizzazione degli iperparametri GridSearchCV e RandomizedSearchCV, spiegati

Ottimizzazione dei parametri con GridSearchCV e RandomizedSearchCV spiegazione dettagliata

 

Ogni modello di machine learning che si addestra ha un insieme di parametri o coefficienti del modello. L’obiettivo dell’algoritmo di machine learning, formulato come un problema di ottimizzazione, è apprendere i valori ottimali di questi parametri.

Inoltre, i modelli di machine learning hanno anche un insieme di iperparametri. Come ad esempio il valore di K, il numero di vicini, nell’algoritmo dei K-Vicini Più Vicini. O la dimensione del batch quando si addestra una rete neurale profonda, e altro ancora.

Questi iperparametri non vengono appresi dal modello. Ma vengono specificati dallo sviluppatore. Influenzano le prestazioni del modello e sono regolabili. Quindi come si trovano i migliori valori per questi iperparametri? Questo processo è chiamato ottimizzazione degli iperparametri o taratura degli iperparametri.

Le due tecniche di taratura degli iperparametri più comuni includono:

  • Ricerca tramite griglia
  • Ricerca casuale

In questa guida, impareremo come funzionano queste tecniche e la loro implementazione in scikit-learn.

 

Addestramento di un classificatore SVM di base

 

Iniziamo addestrando un semplice classificatore Support Vector Machine (SVM) sul dataset del vino. 

Prima, importa i moduli e le classi necessarie: 

from sklearn import datasetsfrom sklearn.model_selection import train_test_splitfrom sklearn.svm import SVCfrom sklearn.metrics import accuracy_score

 

Il dataset del vino fa parte dei dataset incorporati in scikit-learn. Quindi leggiamo le caratteristiche e le etichette di destinazione come mostrato:

# Carica il dataset del vinewine = datasets.load_wine()X = wine.datay = wine.target

 

Il dataset del vino è un dataset semplice con 13 caratteristiche numeriche e tre etichette di classe di output. È un buon candidato per familiarizzare con i problemi di classificazione multi-classe. Puoi eseguire wine.DESCR per ottenere una descrizione del dataset.

  

Successivamente, dividiamo il dataset in set di addestramento e test. Qui abbiamo utilizzato una test_size del 0,2. Quindi l’80% dei dati va nel dataset di addestramento e il 20% nel dataset di test.

# Dividi il dataset in set di addestramento e testX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=24)

 

Ora istanzia un classificatore support vector e addestra il modello sul dataset di addestramento. Quindi valuta le sue prestazioni sul set di test.

# Crea un classificatore SVM di basebaseline_svm = SVC()baseline_svm.fit(X_train, y_train)y_pred = baseline_svm.predict(X_test)

 

Essendo un semplice problema di classificazione multi-classe, possiamo guardare l’accuratezza del modello.

# Valuta il modello di baseaccuratezza = accuracy_score(y_test, y_pred)print(f"Accuratezza SVM di base: {accuratezza:.2f}")

 

Vediamo che il punteggio di accuratezza di questo modello con i valori predefiniti per gli iperparametri è di circa 0,78. 

Output >>>Accuratezza SVM di base: 0,78

 

Qui abbiamo utilizzato un random_state di 24. Con uno stato casuale diverso otterrai una suddivisione dei dati di addestramento e test diversa e successivamente un punteggio di accuratezza diverso.

Quindi abbiamo bisogno di un modo migliore rispetto a una singola divisione dati di addestramento-test per valutare le prestazioni del modello. Forse, addestra il modello su molte di tali divisioni e considera l’accuratezza media. Provando anche diverse combinazioni di iperparametri? Sì, ecco perché usiamo la validazione incrociata nella valutazione del modello e nella ricerca degli iperparametri. Impareremo di più nelle sezioni seguenti.

Successivamente identifichiamo gli iperparametri che possiamo tarare per questo classificatore support vector machine.

 

Parametri SVM da regolare

 

Nella regolazione dei parametri, l’obiettivo è trovare la miglior combinazione di valori dei parametri per il nostro classificatore SVM. I parametri comuni da regolare per il support vector classifier includono:

  • C: parametro di regolarizzazione, che controlla il compromesso tra massimizzare il margine e minimizzare l’errore di classificazione.
  • kernel: specifica il tipo di funzione kernel da utilizzare (ad esempio, ‘lineare’, ‘rbf’, ‘polinomiale’).
  • gamma: coefficiente del kernel per i kernel ‘rbf’ e ‘polinomiale’.

 

Comprensione del ruolo della cross-validazione

 

La cross-validazione aiuta a valutare quanto bene il modello generalizza per dati non visti in precedenza e riduce il rischio di sovradattamento a un singolo set di train-test. La cross-validazione a k-fold comunemente utilizzata prevede la suddivisione del dataset in k fold di dimensioni uguali. Il modello viene allenato k volte, con ciascun fold che funge da set di convalida una volta e i rimanenti fold come set di allenamento. Quindi, per ogni fold, otteniamo una precisione di convalida incrociata.

Quando eseguiamo la ricerca sulla griglia e casuale per trovare i migliori parametri, scegliamo i parametri in base al miglior punteggio medio di convalida incrociata.

 

Cos’è la ricerca sulla griglia?

 

La ricerca sulla griglia è una tecnica di regolazione dei parametri che effettua una ricerca esaustiva all’interno di uno spazio di parametri specificato per trovare la combinazione di parametri che produce la migliore performance del modello.

 

Come funziona la ricerca sulla griglia

 

Definiamo lo spazio di ricerca dei parametri come una griglia di parametri. La griglia dei parametri è un dizionario in cui specificate ciascun parametro da regolare con una lista di valori da esplorare.

La ricerca sulla griglia esplora quindi sistematicamente ogni possibile combinazione di parametri dalla griglia dei parametri. Si adatta e valuta il modello per ogni combinazione utilizzando la cross-validazione e seleziona la combinazione che produce la migliore performance.

Successivamente, implementiamo la ricerca sulla griglia in scikit-learn.

 

GridSearchCV in Scikit-Learn

 

Prima di tutto, importiamo la classe GridSearchCV dal modulo model_selection di scikit-learn:

from sklearn.model_selection import GridSearchCV

 

Definiamo la griglia dei parametri per il classificatore SVM:

# Definisci la griglia dei parametriparam_grid = {'C': [0.1, 1, 10], 'kernel': ['lineare', 'rbf', 'polinomiale'], 'gamma': [0.1, 1, 'scala', 'auto']}

 

La ricerca sulla griglia esplora quindi sistematicamente ogni possibile combinazione di parametri dalla griglia dei parametri. Per questo esempio, valuta le prestazioni del modello con:

  • C impostato su 0.1, 1 e 10,
  • kernel impostato su ‘lineare’, ‘rbf’ e ‘polinomiale’, e
  • gamma impostato su 0.1, 1, ‘scala’ e ‘auto’.

Ciò comporta un totale di 3 * 3 * 4 = 36 diverse combinazioni da valutare. La ricerca sulla griglia adatta e valuta il modello per ogni combinazione utilizzando la cross-validazione e seleziona la combinazione che produce la migliore performance.

Poi istanziamo GridSearchCV per regolare i parametri del baseline_svm:

# Crea l'oggetto GridSearchCVgrid_search = GridSearchCV(estimator=baseline_svm, param_grid=param_grid, cv=5)# Addestra il modello con la griglia dei parametrigrid_search.fit(X_train, y_train)

 

Nota che abbiamo utilizzato una cross-validazione a 5 fold.

Infine, valutiamo le prestazioni del miglior modello, con i parametri ottimali trovati dalla ricerca sulla griglia, sui dati di test:

# Ottieni i migliori iperparametri e il miglior modello
best_params = grid_search.best_params
best_model = grid_search.best_estimator_

# Valuta il miglior modello
y_pred_best = best_model.predict(X_test)
accuracy_best = accuracy_score(y_test, y_pred_best)
print(f"Migliore accuratezza SVM: {accuracy_best:.2f}")
print(f"Migliori iperparametri: {best_params}")

 

Come si può notare, il modello raggiunge una precisione del 0.94 per i seguenti iperparametri:

Output >>>Migliore accuratezza SVM: 0.94Migliori iperparametri: {'C': 0.1, 'gamma': 0.1, 'kernel': 'poly'}

 

Pro e Contro della Ricerca nella Griglia

 

L’utilizzo della ricerca nella griglia per l’ottimizzazione degli iperparametri presenta i seguenti vantaggi:

  • La ricerca nella griglia esplora tutte le combinazioni specificate, garantendo di non perdere i migliori iperparametri all’interno dello spazio di ricerca definito.
  • È una buona scelta per esplorare spazi di iperparametri più piccoli.

Tuttavia, ci sono anche degli svantaggi:

  • La ricerca nella griglia può richiedere molto tempo di calcolo, specialmente quando si lavora con un gran numero di iperparametri e i loro valori. Potrebbe non essere fattibile per modelli molto complessi o ricerche di iperparametri estese.

Ora impariamo riguardo alla ricerca casuale.

 

Cos’è la Ricerca Casuale?

 

La ricerca casuale è un’altra tecnica per l’ottimizzazione degli iperparametri che esplora combinazioni casuali di iperparametri all’interno di distribuzioni o intervalli specificati. È particolarmente utile quando si ha a che fare con uno spazio di ricerca di iperparametri ampio.

 

Come Funziona la Ricerca Casuale

 

Nella ricerca casuale, invece di specificare una griglia di valori, è possibile definire distribuzioni di probabilità o intervalli per ogni iperparametro. Ciò comporta uno spazio di ricerca degli iperparametri molto più ampio.

La ricerca casuale campiona quindi casualmente un numero fisso di combinazioni di iperparametri da queste distribuzioni. Ciò permette alla ricerca casuale di esplorare un insieme diversificato di combinazioni di iperparametri efficientemente.

 

RandomizedSearchCV in Scikit-Learn

 

Ora ottimizziamo i parametri del classificatore SVM di base usando la ricerca casuale.

Importiamo la classe RandomizedSearchCV e definiamo param_dist, uno spazio di ricerca di iperparametri molto più ampio:

import numpy as npfrom sklearn.model_selection import RandomizedSearchCV from scipy.stats import uniformparam_dist = {    'C': uniform(0.1, 10),  # Distribuzione uniforme tra 0.1 e 10    'kernel': ['linear', 'rbf', 'poly'],    'gamma': ['scale', 'auto'] + list(np.logspace(-3, 3, 50))}

 

Similmente alla ricerca nella griglia, istanziamo il modello di ricerca casuale per cercare i migliori iperparametri. Qui, impostiamo n_iter su 20; quindi saranno campionate 20 combinazioni casuali di iperparametri.

# Crea l'oggetto RandomizedSearchCVrandomized_search = RandomizedSearchCV(estimator=baseline_svm, param_distributions=param_dist, n_iter=20, cv=5)randomized_search.fit(X_train, y_train)

 

Valutiamo quindi le prestazioni del modello con i migliori iperparametri trovati tramite la ricerca casuale:

# Ottieni i migliori iperparametri e il miglior modellobest_params_rand = randomized_search.best_paramsbest_model_rand = randomized_search.best_estimator_# Valuta il miglior modelloy_pred_best_rand = best_model_rand.predict(X_test)accuracy_best_rand = accuracy_score(y_test, y_pred_best_rand)print(f"Migliore accuratezza SVM: {accuracy_best_rand:.2f}")print(f"Migliori iperparametri: {best_params_rand}")

 

La migliore accuratezza e gli iperparametri ottimali sono:

Output >>>Migliore accuratezza SVM: 0.94Migliori iperparametri: {'C': 9.66495227534876, 'gamma': 6.25055192527397, 'kernel': 'poly'}

I parametri trovati attraverso la ricerca randomizzata sono diversi da quelli trovati attraverso la ricerca a griglia. Il modello con questi iperparametri raggiunge anche un punteggio di precisione del 0,94.

Pro e Contro della Ricerca Randomizzata

Riassumiamo i vantaggi della ricerca randomizzata:

  • La ricerca randomizzata è efficiente quando si tratta di un gran numero di iperparametri o di un’ampia gamma di valori perché non richiede una ricerca esaustiva.
  • Può gestire diversi tipi di parametri, inclusi valori continui e discreti.

Ecco alcune limitazioni della ricerca randomizzata:

  • A causa della sua natura casuale, potrebbe non sempre trovare i migliori iperparametri. Ma spesso trova rapidamente quelli buoni.
  • A differenza della ricerca a griglia, non garantisce che tutte le possibili combinazioni saranno esplorate.

Conclusione

Abbiamo appreso come eseguire la messa a punto degli iperparametri con RandomizedSearchCV e GridSearchCV in scikit-learn. Abbiamo poi valutato le prestazioni del nostro modello con i migliori iperparametri.

In sintesi, la ricerca a griglia cerca in modo esaustivo tutte le possibili combinazioni nella griglia dei parametri. Mentre la ricerca randomizzata campiona casualmente combinazioni di iperparametri.

Entrambe queste tecniche ti aiutano a identificare gli iperparametri ottimali per il tuo modello di machine learning riducendo il rischio di overfitting a uno specifico train-test split.

[Bala Priya C](https://twitter.com/balawc27) è una sviluppatrice e scrittrice tecnica dall’India. Ama lavorare all’intersezione tra matematica, programmazione, data science e creazione di contenuti. Le sue aree di interesse e competenza includono DevOps, data science e elaborazione del linguaggio naturale. Ama leggere, scrivere, programmare e bere caffè! Attualmente sta lavorando per imparare e condividere la sua conoscenza con la comunità di sviluppatori redigendo tutorial, guide, articoli di opinione e altro ancora.