Come scegliere il numero di stimatori per il Gradient Boosting

Nella scienza dei dati ci sono molti algoritmi disponibili per l'uso al giorno d'oggi. Una tecnica utile, quindi, consiste nell'usarli combinandoli in un unico modello per ottenere il meglio da ciascuno, ottenendo un modello più accurato.

Utilizzando Scikit-Learn, troverai l'algoritmo Random Forest, ovvero il tipo di modello di ensemble di bagging. D'altra parte, troverai anche modelli Boosting, che addestrano gli stimatori in sequenza, dove il risultato di un modello viene passato a quello successivo, che cercherà di migliorare le previsioni, fino a raggiungere un risultato ottimale.

Quando crei uno stimatore Gradient Boosting, troverai questo iperparametro n_estimator=100 con un valore predefinito di 100 alberi da creare per arrivare ad un risultato. Molte volte, lo impostiamo semplicemente sul valore predefinito o magari lo aumentiamo secondo necessità, anche utilizzando le tecniche di Grid Search.

In questo post troveremo un modo semplice per arrivare ad un singolo numero da utilizzare per addestrare il nostro modello.

Il potenziamento del gradiente può essere caricato da Scikit-Learn utilizzando questa classe from sklearn.ensemble import GradientBoostingRegressor. L'algoritmo Gradient Boosting può essere utilizzato sia per la classificazione che per i modelli di regressione. È uno stimatore basato su alberi, il che significa che è composto da molti alberi decisionali.

Il risultato di Albero 1 genererà errori. Tali errori verranno utilizzati e l'input per il file Albero 2. Ancora una volta verranno utilizzati gli errori dell'ultimo modello e gli input di quello successivo, fino ad arrivare al n_estimators valore.

Poiché ciascuno stimatore adatterà l’errore del precedente, l’aspettativa è che la combinazione delle previsioni sarà migliore di quella di qualunque stimatore preso singolarmente. Dopo ogni iterazione, rendiamo il modello più complesso, riducendo la distorsione ma aumentando la varianza, d'altro canto. Quindi dobbiamo sapere quando fermarci.

Vediamo come farlo ora.

Il codice per questo esercizio è semplice. Tutto quello che dobbiamo fare è un ciclo dopo ogni iterazione e verificare in quale abbiamo avuto l'errore più basso.

Iniziamo scegliendo un set di dati. Utilizzeremo il incidenti d'auto set di dati, nativo della libreria Seaborn (quindi un dato aperto con licenza BDS).

#Set di dati
df = sns.load_dataset('car_crashes')

Ecco una rapida occhiata ai dati. Cercheremo di stimare il total importo utilizzando le altre funzionalità come predittori. Poiché si tratta di un output di numeri reali, stiamo parlando di un modello di regressione.

Osservando rapidamente le correlazioni.

# Correlazioni
df.corr().style. background_gradient(cmap='coolwarm')

Ok, nessuna multicollinearità importante. Possiamo vederlo ins_premium ed ins_losses non correlano molto bene con il total , quindi non li considereremo nel modello.

Se controlliamo i dati mancanti, non ce ne sono

# Mancante
df.isnull().sum()
0

Bene, quindi dividiamo i dati ora.

# X e y
X = df.drop(['ins_premium', 'ins_losses', 'abbrev', 'total'], axis=1)
y = df['totale']# Prova del treno
X_treno, X_test, y_treno, y_test = treno_test_split(X, y, test_size=0.3, random_state=22)

Possiamo creare una pipeline per ridimensionare i dati e modellarli (in realtà non è molto necessario ridimensionare questi dati, poiché sono già nella stessa scala, su base delle decine). Successivamente, adattiamo i dati al modello e prevediamo i risultati.

Sto utilizzando 500 stimatori con a learning_rate di 0.3.

Il tasso di apprendimento è la dimensione del passo che facciamo per arrivare all’errore minimo. Se utilizziamo un valore troppo alto, potremmo superare il minimo. Se usiamo un numero troppo piccolo, potremmo non avvicinarci nemmeno ad esso. Quindi, una regola pratica che puoi considerare è: se hai un numero elevato di stimatori, puoi utilizzare valori più bassi del tasso di apprendimento. Se hai solo pochi stimatori, preferisci utilizzare valori più alti del tasso di apprendimento.

passi = [('scala', StandardScaler()),
('GBR', GradientBoostingRegressor(n_estimators=500, learning_rate=0.03))]# Pipeline di istanza e adattamento
pipe = Pipeline(passi).fit(X_treno, y_treno)#Prevedere
preds = pipe.predict(X_test)

Ora, valutando.

# RMSE dei pronostici
print(f'RMSE: { round(np.sqrt(mean_squared_error(y_test, preds)),1 )}')[USCITA]: RMSE: 1.1# Media dei valori Y reali
print(f'Dati y media: {round( y.mean(),1 )}')[OUT]: Media dei dati: 15.8

Bene. Il nostro RMSE è circa il 6.9% della media. Quindi siamo fuori di questo, in media.

Ora controlliamo un modo per ottimizzare il nostro modello scegliendo il numero ottimale di stimatori da addestrare che ci fornirà il tasso di errore più basso.

Come ho detto, non dobbiamo realmente ridimensionare questi dati perché sono già nella stessa proporzione. Quindi adattiamo il modello.

#Modello
gbr = GradientBoostingRegressor(n_estimators=500, learning_rate=0.3).fit(X_train, y_train)

Ora è la roba buona. Esiste un metodo nel Gradient Boosting che ci consente di ripetere le previsioni di ciascuno stimatore addestrato, da 1 a 500. Quindi, creeremo un ciclo che attraversa i 500 stimatori nel gbr modello, prevede i risultati utilizzando il metodo staged_predict(), calcola l'errore quadratico medio e memorizza il risultato nell'elenco errors.

# Ripete il ciclo per il numero migliore
errori = [mean_squared_error(y_test, preds) per preds in gbr.staged_predict(X_test)]# Numero ottimale di stimatori
num_estimatori_ottimali = np.argmin(errori) + 1

Successivamente, possiamo tracciare il risultato.

#Complotto
g=sns.lineplot(x=intervallo(500), y=errori)
g.set_title(f'Miglior numero di stimatori a {best_n_estimators}', size=15);

Vediamo che il tasso di errore più basso si ha con 34 stimatori. Quindi, riqualificamo il nostro modello con 34 stimatori e confrontiamolo con il risultato del modello addestrato con la pipeline.

#Riqualificazione
gbr = GradientBoostingRegressor(n_estimators=34, learning_rate=0.3).fit(X_train, y_train)# Predizioni
preds2 = gbr.predict(X_test)

Valutare…

# RMSE dei pronostici
print(f'RMSE: { round(np.sqrt(mean_squared_error(y_test, preds2)),1 )}')
[USCITA]: RMSE: 1.0# Dati Y media
print(f'Dati y media: {round( y.mean(),1 )}')[OUT]: Media dei dati: 15.8

Adesso siamo scesi dal 6.9% al 6.3%. ca. 9% migliore. Diamo un’occhiata ad alcune previsioni.

Risultati interessanti. Alcune delle previsioni del secondo modello sono migliori del primo.

Abbiamo imparato come determinare il miglior numero di stimatori per modificare a GradientBoostingRegressor da Scikit-Learn. Questo è un iperparametro che può fare la differenza in questo tipo di modello di insieme, che addestra gli stimatori in sequenza.

A volte, dopo alcune iterazioni, il modello può iniziare ad adattarsi eccessivamente, quindi inizierà ad aumentare troppo la varianza, influenzando le previsioni.

Abbiamo visto che un semplice loop può aiutarci a trovare la soluzione ottimale in questo caso. Ma, certamente, per set di dati di grandi dimensioni può essere costoso da calcolare, quindi un'idea potrebbe essere quella di provarne uno inferiore n_estimators all'inizio e vedi se riesci a raggiungere l'errore minimo abbastanza presto.

Ecco il codice completo in GitHub.

Se ti è piaciuto questo contenuto, segui il mio blog.

Trovami su LinkedIn.

Questo esercizio si basa sull'eccellente libro di testo di Aurélien Géron, nel riferimento.

Come scegliere il numero di stimatori per il Gradient Boosting Ripubblicato dalla fonte https://towardsdatascience.com/how-to-choose-the-number-of-estimators-for-gradient-boosting-8d06920ab891?source=rss—-7f60cf5620c9— 4 tramite https://towardsdatascience.com/feed

<!–

->