Hur man väljer antalet estimatorer för Gradient Boosting

Inom Data Science finns det många algoritmer tillgängliga för användning nu för tiden. En användbar teknik är därför att kombinera dem i en enda modell för att få ut det bästa av var och en, vilket resulterar i en mer exakt modell.

Genom att använda Scikit-Learn kommer du att hitta Random Forest-algoritmen, det vill säga en ensemblemodell för påsar. Å andra sidan hittar du även Boosting-modeller, som tränar estimatorerna i sekvens, där resultatet av en modell skickas till nästa, som kommer att försöka förbättra förutsägelserna, tills de når ett optimalt resultat.

När du skapar en Gradient Boosting-estimator hittar du denna hyperparameter n_estimator=100 med ett standardvärde på 100 träd som ska skapas för att nå ett resultat. Många gånger ställer vi bara in detta till standard eller kanske ökar efter behov, även med hjälp av Grid Search-tekniker.

I det här inlägget kommer vi att hitta ett enkelt sätt att komma till ett enda nummer att använda för att träna vår modell.

Gradient Boosting kan laddas från Scikit-Learn med den här klassen from sklearn.ensemble import GradientBoostingRegressor. Gradient Boosting-algoritmen kan användas antingen för klassificering eller för regressionsmodeller. Det är en trädbaserad skattare – vilket betyder att den är sammansatt av många beslutsträd.

Resultatet av Träd 1 kommer att generera fel. Dessa fel kommer att användas och indata för Träd 2. Återigen kommer felen från den sista modellen att användas och inmatningen av nästa, tills den når n_estimators värde.

Eftersom varje estimator kommer att passa felet i den föregående, är förväntningen att kombinationen av förutsägelserna kommer att vara bättre än någon av estimatorns ensam. Efter varje iteration gör vi modellen mer komplex, minskar bias men ökar variansen på baksidan. Så vi måste veta när vi ska sluta.

Låt oss se hur man gör det nu.

Koden för denna övning är enkel. Allt vi behöver göra är en loop efter varje iteration och kontrollera vid vilken vi hade det lägsta felet.

Låt oss börja med att välja en datauppsättning. Vi kommer att använda bilolyckor datauppsättning, infödd från seaborn-biblioteket (så en öppen data under BDS-licens).

# Datauppsättning
df = sns.load_dataset('car_crashes')

Här är en snabb titt på uppgifterna. Vi kommer att försöka uppskatta total med hjälp av de andra funktionerna som prediktorer. Eftersom det är ett reellt tal, talar vi om en regressionsmodell.

Tittar snabbt på sambanden.

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

Ok, ingen större multikollinearitet. Vi kan se det ins_premium och ins_losses korrelerar inte särskilt bra med total , så vi kommer inte att överväga dem i modellen.

Om vi ​​kontrollerar de saknade uppgifterna finns det inga

# Saknas
df.isnull (). summa ()
0

Bra, så låt oss dela upp data nu.

# X och y
X = df.drop(['ins_premium', 'ins_losses', 'abbrev', 'total'], axis=1)
y = df['totalt']# Tågprov
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=22)

Vi kan skapa en pipeline för att skala data och modellera den (det är verkligen inte särskilt nödvändigt att skala dessa data, eftersom de redan är i samma skala, på tiotalsbasen). Därefter anpassar vi data till modellen och förutsäger resultaten.

Jag använder 500 estimatorer med en learning_rate av 0.3.

Inlärningshastigheten är storleken på steget vi tar för att komma till minsta möjliga fel. Om vi ​​använder ett värde som är för högt kan vi passera minimivärdet. Om vi ​​använder ett tal som är för litet kanske vi inte ens kommer i närheten av det. Så en tumregel du kan överväga är: om du har ett stort antal estimatorer kan du använda lägre värden på inlärningshastigheten. Om du bara har ett fåtal estimatorer, föredrar du att använda högre värden för inlärningshastighet.

steg = [('scale', StandardScaler()),
('GBR', GradientBoostingRegressor(n_estimators=500, learning_rate=0.03)) ]# Instans Pipeline och passform
pipe = Pipeline(steg).fit(X_train, y_train)# Förutse
preds = pipe.predict(X_test)

Nu utvärderar.

# RMSE av förutsägelserna
print(f'RMSE: { round(np.sqrt(mean_squared_error(y_test, preds)),1 )}')[UT]: RMSE: 1.1# Medelvärde av de sanna Y-värdena
print(f'Data y mean: {round( y.mean(),1 )}')[UT]: Data y medelvärde: 15.8

Bra. Vår RMSE är cirka 6.9 % av medelvärdet. Så vi har så här mycket i genomsnitt.

Låt oss nu kolla ett sätt att ställa in vår modell genom att välja det optimala antalet estimatorer att träna som ger oss den lägsta felfrekvensen.

Som jag sa, vi behöver egentligen inte skala denna data eftersom den redan är i samma proportion. Så låt oss passa modellen.

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

Nu är det bra. Det finns en metod i Gradient Boosting som gör att vi kan iterera över förutsägelserna för varje utbildad estimator, från 1 till 500. Så vi kommer att skapa en loop som går igenom de 500 estimatorerna i gbr modell, förutsäger resultat med hjälp av metoden staged_predict(), beräknar medelkvadratfelet och lagrar resultatet i listan errors.

# Slinga för bästa nummer
errors = [ mean_squared_error(y_test, preds) för preds i gbr.staged_predict(X_test)]# Optimalt antal estimatorer
optimal_num_estimators = np.argmin(errors) + 1

Därefter kan vi plotta resultatet.

#Komplott
g=sns.lineplot(x=intervall(500), y=fel)
g.set_title(f'Bästa antal estimatorer vid {best_n_estimators}', storlek=15);

Vi ser att den lägsta felfrekvensen är med 34 estimatorer. Så låt oss träna om vår modell med 34 estimatorer och jämföra med resultatet från modellen som tränats med pipeline.

# Omskola
gbr = GradientBoostingRegressor(n_estimators=34, learning_rate=0.3).fit(X_train, y_train)# Förutsägelser
preds2 = gbr.predict(X_test)

Utvärderar...

# RMSE av förutsägelserna
print(f'RMSE: { round(np.sqrt(mean_squared_error(y_test, preds2)),1 )}')
[UT]: RMSE: 1.0# Data Y betyder
print(f'Data y mean: {round( y.mean(),1 )}')[UT]: Data y medelvärde: 15.8

Vi gick ner från 6.9 % till 6.3 % rabatt nu. Cirka. 9% bättre. Låt oss titta på några förutsägelser.

Intressanta resultat. Några av förutsägelserna i den andra modellen är bättre än den första.

Vi lärde oss hur man bestämmer det bästa antalet estimatorer för att justera en GradientBoostingRegressor från Scikit-Learn. Detta är en hyperparameter som kan göra skillnad i den här typen av ensemblemodell, som tränar estimatorer i sekvens.

Ibland, efter några iterationer, kan modellen börja överanpassas, så den kommer att börja öka variansen för mycket, vilket påverkar förutsägelserna.

Vi såg att en enkel slinga kan hjälpa oss att hitta den optimala lösningen i det här fallet. Men visst, för stora datamängder kan det vara dyrt att beräkna, så en idé vore att prova en lägre n_estimators först och se om du kan nå minimifelet snart nog.

Här är komplett kod i GitHub.

Om du gillade detta innehåll, följ min blogg.

Hitta mig på LinkedIn.

Denna övning baserades på den utmärkta läroboken av Aurélien Géron, i referensen.

Hur man väljer antalet estimatorer för Gradient Boosting Republiced ​​from Source https://towardsdatascience.com/how-to-choose-the-number-of-estimators-for-gradient-boosting-8d06920ab891?source=rss—-7f60cf5620c9— 4 via https://towardsdatascience.com/feed

<!–

->