Hoe het aantal schatters voor Gradient Boosting te kiezen?

In Data Science zijn er tegenwoordig veel algoritmen beschikbaar voor gebruik. Een handige techniek is daarom om ze te combineren in een enkel model om het beste uit elk model te halen, wat resulteert in een nauwkeuriger model.

Met behulp van Scikit-Learn vindt u het Random Forest-algoritme, dat is het soort bagging-ensemblemodel. Aan de andere kant vindt u ook Boosting-modellen, die de schatters in volgorde trainen, waarbij het resultaat van het ene model wordt doorgegeven aan het volgende, die zullen proberen de voorspellingen te verbeteren, totdat ze een optimaal resultaat bereiken.

Bij het maken van een schatter voor het vergroten van het verloop, vindt u deze hyperparameter n_estimator=100 met een standaardwaarde van 100 bomen die moeten worden gemaakt om tot een resultaat te komen. Vaak zetten we dit gewoon op de standaard of verhogen we het indien nodig, zelfs met behulp van Grid Search-technieken.

In dit bericht zullen we een eenvoudige manier vinden om naar een enkel nummer te gaan dat we kunnen gebruiken om ons model te trainen.

Gradient Boosting kan worden geladen vanuit Scikit-Learn met behulp van deze klasse from sklearn.ensemble import GradientBoostingRegressor. Het Gradient Boosting-algoritme kan worden gebruikt voor classificatie of voor regressiemodellen. Het is een op bomen gebaseerde schatter - wat betekent dat het is samengesteld uit vele beslissingsbomen.

Het resultaat van de Boom 1 fouten zal genereren. Die fouten worden gebruikt en de invoer voor de Boom 2. Nogmaals, de fouten van het laatste model worden gebruikt en de invoer van het volgende, totdat het de bereikt n_estimators waarde.

Aangezien elke schatter zal passen bij de fout van de vorige, is de verwachting dat de combinatie van de voorspellingen beter zal zijn dan die van de schatter alleen. Na elke iteratie maken we het model complexer, waardoor vertekening wordt verminderd maar de variantie aan de andere kant wordt vergroot. We moeten dus weten wanneer we moeten stoppen.

Laten we eens kijken hoe we dat nu kunnen doen.

De code voor deze oefening is eenvoudig. Het enige wat we moeten doen is een lus maken na elke iteratie en controleren bij welke we de minste fout hadden.

Laten we beginnen met het kiezen van een dataset. We zullen de gebruiken auto ongelukken dataset, afkomstig uit de seaborn-bibliotheek (dus een open data onder BDS-licentie).

# Gegevensset
df = sns.load_dataset('car_crashes')

Hier is een snelle blik op de gegevens. We zullen proberen een schatting te maken van de total bedrag met behulp van de andere kenmerken als voorspellers. Omdat het een uitvoer van reële getallen is, hebben we het over een regressiemodel.

Snel kijken naar de correlaties.

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

Ok, geen grote multicollineariteit. Dat kunnen we zien ins_premium en ins_losses correleert niet goed met de total , dus we zullen ze niet in het model beschouwen.

Als we de ontbrekende gegevens controleren, zijn er geen

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

Leuk, dus laten we de gegevens nu splitsen.

# X en y
X = df.drop(['ins_premium', 'ins_losses', 'abbrev', 'total'], axis=1)
y = df['totaal']# Treintest
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, willekeurige_status=22)

We kunnen een pijplijn maken om de gegevens te schalen en te modelleren (het is echt niet erg nodig om deze gegevens te schalen, omdat ze al in dezelfde schaal staan, op de tientallen basis). Vervolgens passen we de gegevens aan het model aan en voorspellen we de resultaten.

Ik gebruik 500 schatters met a learning_rate van 0.3.

De leersnelheid is de grootte van de stap die we nemen om tot de minimale fout te komen. Als we een te hoge waarde gebruiken, kunnen we het minimum overschrijden. Als we een getal gebruiken dat te klein is, komen we er misschien niet eens in de buurt. Dus een vuistregel die u kunt overwegen is: als u een groot aantal schatters heeft, kunt u lagere waarden van leersnelheid gebruiken. Als u slechts een paar schatters heeft, geeft u er de voorkeur aan hogere waarden van leersnelheid te gebruiken.

stappen = [('schaal', StandardScaler()),
('GBR', GradientBoostingRegressor(n_estimators=500, learning_rate=0.03)) ]# Instantie Pipeline en fit
pipe = Pipeline(stappen).fit(X_train, y_train)# Voorspellen
preds = pijp.predict(X_test)

Nu evalueren.

# RMSE van de voorspellingen
print(f'RMSE: { round(np.sqrt(mean_squared_error(y_test, preds)),1 )}')[UIT]: RMSE: 1.1# Gemiddelde van de echte Y-waarden
print(f'Data y mean: {round( y.mean(),1 )}')[OUT]: Gegevens y gemiddelde: 15.8

Mooi zo. Onze RMSE is ongeveer 6.9% van het gemiddelde. Dus we zitten er gemiddeld zo ver naast.

Laten we nu eens kijken naar een manier om ons model af te stemmen door het optimale aantal schatters te kiezen om te trainen dat ons het laagste foutenpercentage geeft.

Zoals ik al zei, we hoeven deze gegevens niet echt te schalen omdat ze al in dezelfde verhouding staan. Dus laten we het model passen.

#Model
gbr = GradientBoostingRegressor(n_estimators=500, leersnelheid=0.3).fit(X_train, y_train)

Nu is het de goede dingen. Er is een methode in Gradient Boosting waarmee we de voorspellingen van elke getrainde schatter kunnen herhalen, van 1 tot 500. We zullen dus een lus maken die door de 500 schatters in de gbr model, voorspelt resultaten met behulp van de methode staged_predict(), berekent de gemiddelde kwadratische fout en slaat het resultaat op in de lijst errors.

# Loop voor het beste nummer
errors = [ mean_squared_error(y_test, preds) voor preds in gbr.staged_predict(X_test)]# Optimaal aantal schatters
optimale_num_estimators = np.argmin(fouten) + 1

Vervolgens kunnen we het resultaat plotten.

#Verhaallijn
g=sns.lineplot(x=bereik(500), y=fouten)
g.set_title(f'Beste aantal schatters bij {best_n_estimators}', size=15);

We zien dat het laagste foutenpercentage is met 34 schatters. Laten we ons model dus opnieuw trainen met 34 schatters en vergelijken met het resultaat van het model dat met de pijplijn is getraind.

# Opnieuw trainen
gbr = GradientBoostingRegressor(n_estimators=34, leersnelheid=0.3).fit(X_train, y_train)# Voorspellingen
preds2 = gbr.predict(X_test)

Evalueren…

# RMSE van de voorspellingen
print(f'RMSE: { round(np.sqrt(mean_squared_error(y_test, preds2)),1 )}')
[UIT]: RMSE: 1.0# Gegevens Y bedoel
print(f'Data y mean: {round( y.mean(),1 )}')[OUT]: Gegevens y gemiddelde: 15.8

We zijn nu gedaald van 6.9% naar 6.3%. Ca. 9% beter. Laten we een paar voorspellingen bekijken.

Interessante resultaten. Sommige voorspellingen van het tweede model zijn beter dan het eerste.

We hebben geleerd hoe we het beste aantal schatters kunnen bepalen om aan te passen GradientBoostingRegressor van Scikit-Learn. Dit is een hyperparameter die het verschil kan maken in dit soort ensemblemodel, dat schatters in volgorde traint.

Soms, na een paar iteraties, kan het model beginnen te overfitten, waardoor de variantie te veel zal toenemen, wat invloed heeft op de voorspellingen.

We hebben gezien dat een eenvoudige lus ons kan helpen om in dit geval de optimale oplossing te vinden. Maar zeker, voor grote datasets kan het duur zijn om te berekenen, dus een idee zou zijn om een ​​lagere te proberen n_estimators en kijk of u snel genoeg de minimale fout kunt bereiken.

Hier is de volledige code in GitHub.

Als je deze inhoud leuk vond, volg dan mijn blog.

Vind me op LinkedIn.

Deze oefening was gebaseerd op het uitstekende tekstboek van Aurélien Géron, in de referentie.

Hoe kies je het aantal schatters voor Gradient Boosting opnieuw gepubliceerd vanuit de bron https://towardsdatascience.com/how-to-choose-the-number-of-estimators-for-gradient-boosting-8d06920ab891?source=rss—-7f60cf5620c9— 4 via https://towardsdatascience.com/feed

<!–

->