Sådan vælger du antallet af estimatorer til Gradient Boosting

I Data Science er der mange algoritmer tilgængelige til brug i disse dage. En nyttig teknik er derfor at bruge kombinere dem i en enkelt model for at få det bedste ud af hver, hvilket resulterer i en mere præcis model.

Ved at bruge Scikit-Learn finder du Random Forest-algoritmen, det er en ensemblemodel med sække. På den anden side finder du også Boosting-modeller, der træner estimatorerne i rækkefølge, hvor resultatet af den ene model overføres til den næste, som vil forsøge at forbedre forudsigelserne, indtil de når et optimalt resultat.

Når du opretter en Gradient Boosting-estimator, finder du denne hyperparameter n_estimator=100 med en standardværdi på 100 træer, der skal oprettes for at få et resultat. Mange gange har vi bare sat dette til standard eller måske øge efter behov, endda ved at bruge Grid Search-teknikker.

I dette indlæg finder vi en enkel måde at komme til et enkelt nummer, der skal bruges til at træne vores model.

Gradient Boosting kan indlæses fra Scikit-Learn ved hjælp af denne klasse from sklearn.ensemble import GradientBoostingRegressor. Gradient Boosting-algoritmen kan bruges enten til klassificering eller til regressionsmodeller. Det er en træbaseret estimator - hvilket betyder, at den er sammensat af mange beslutningstræer.

Resultatet af Træ 1 vil generere fejl. Disse fejl vil blive brugt og input til Træ 2. Endnu en gang vil fejlene fra den sidste model blive brugt og input fra den næste, indtil den når n_estimators værdi.

Da hver estimator passer til fejlen fra den foregående, er forventningen, at kombinationen af ​​forudsigelserne vil være bedre end nogen af ​​estimatorens alene. Efter hver iteration gør vi modellen mere kompleks, reducerer bias, men øger variansen på bagsiden. Så vi skal vide, hvornår vi skal stoppe.

Lad os se, hvordan man gør det nu.

Koden til denne øvelse er enkel. Det eneste, vi skal gøre, er en løkke efter hver iteration og kontrollere, ved hvilken vi havde den laveste fejl.

Lad os starte med at vælge et datasæt. Vi vil bruge bilulykker datasæt, hjemmehørende fra seaborn-biblioteket (så en åben data under BDS-licens).

# Datasæt
df = sns.load_dataset('car_crashes')

Her er et hurtigt kig på dataene. Vi vil forsøge at vurdere total mængde ved at bruge de andre funktioner som forudsigere. Da det er et reelt tal output, taler vi om en regressionsmodel.

Ser hurtigt på sammenhængene.

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

Ok, ingen større multikolinearitet. Det kan vi se ins_premium , ins_losses hænger ikke særlig godt sammen med total , så vi vil ikke overveje dem i modellen.

Hvis vi tjekker de manglende data, er der ingen

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

Dejligt, så lad os dele dataene op nu.

# X og y
X = df.drop(['ins_premium', 'ins_losses', 'abbrev', 'total'], axis=1)
y = df['total']# Togprøve
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=22)

Vi kan oprette en pipeline for at skalere dataene og modellere dem (det er virkelig ikke særlig nødvendigt at skalere disse data, da de allerede er i samme skala, på tierebasis). Dernæst tilpasser vi dataene til modellen og forudsiger resultaterne.

Jeg bruger 500 estimatorer med en learning_rate af 0.3.

Læringshastigheden er størrelsen af ​​det skridt, vi tager for at komme til minimumsfejlen. Hvis vi bruger en værdi, der er for høj, kan vi passere minimum. Hvis vi bruger et tal, der er for lille, kommer vi måske ikke engang tæt på det. Så en tommelfingerregel, du kan overveje, er: Hvis du har et stort antal estimatorer, kan du bruge lavere værdier for indlæringshastighed. Hvis du kun har nogle få estimatorer, foretrækker du at bruge højere værdier for indlæringshastighed.

steps = [('scale', StandardScaler()),
('GBR', GradientBoostingRegressor(n_estimators=500, learning_rate=0.03)) ]# Forekomst Pipeline og pasform
rør = Pipeline(trin).fit(X_train, y_train)# Forudsig
preds = pipe.predict(X_test)

Nu skal der evalueres.

# RMSE af forudsigelserne
print(f'RMSE: { round(np.sqrt(mean_squared_error(y_test, preds)),1 )}')[UD]: RMSE: 1.1# Gennemsnit af de sande Y-værdier
print(f'Data y betyder: {round( y.mean(),1 )}')[OUT]: Data y gennemsnit: 15.8

Godt. Vores RMSE er omkring 6.9% af gennemsnittet. Så vi er i gennemsnit så meget væk.

Lad os nu tjekke en måde at tune vores model på ved at vælge det optimale antal estimatorer at træne, som vil give os den laveste fejlrate.

Som jeg sagde, behøver vi ikke rigtig at skalere disse data, fordi de allerede er i samme forhold. Så lad os passe modellen.

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

Nu er det de gode ting. Der er en metode i Gradient Boosting, der giver os mulighed for at iterere over forudsigelserne for hver trænet estimator, fra 1 til 500. Så vi vil skabe en loop, der går gennem de 500 estimatorer i gbr model, forudsiger resultater ved hjælp af metoden staged_predict(), beregner den gennemsnitlige kvadratiske fejl og gemmer resultatet i listen errors.

# Loop for det bedste nummer
fejl = [ mean_squared_error(y_test, preds) for preds i gbr.staged_predict(X_test)]# Optimalt antal estimatorer
optimal_num_estimators = np.argmin(fejl) + 1

Dernæst kan vi plotte resultatet.

#Grund
g=sns.lineplot(x=område(500), y=fejl)
g.set_title(f'Bedste antal estimatorer ved {best_n_estimators}', størrelse=15);

Vi ser, at den laveste fejlrate er med 34 estimatorer. Så lad os genoptræne vores model med 34 estimatorer og sammenligne med resultatet fra modellen trænet med pipeline.

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

Evaluerer...

# RMSE af forudsigelserne
print(f'RMSE: { round(np.sqrt(mean_squared_error(y_test, preds2)),1 )}')
[UD]: RMSE: 1.0# Data Y betyder
print(f'Data y betyder: {round( y.mean(),1 )}')[OUT]: Data y gennemsnit: 15.8

Vi gik ned fra 6.9 % til 6.3 % nu. Ca. 9% bedre. Lad os se på et par forudsigelser.

Interessante resultater. Nogle af forudsigelserne i den anden model er bedre end den første.

Vi lærte, hvordan man bestemmer det bedste antal estimatorer til at justere en GradientBoostingRegressor fra Scikit-Learn. Dette er en hyperparameter, der kan gøre en forskel i denne form for ensemblemodel, der træner estimatorer i rækkefølge.

Nogle gange, efter et par iterationer, kan modellen begynde at overfitte, så den vil begynde at øge variansen for meget, hvilket påvirker forudsigelserne.

Vi så, at en simpel løkke kan hjælpe os med at finde den optimale løsning i dette tilfælde. Men for store datasæt kan det bestemt være dyrt at beregne, så en idé ville være at prøve en lavere n_estimators først og se, om du kan nå minimumsfejlen hurtigt nok.

Her er den komplet kode i GitHub.

Hvis du kunne lide dette indhold, så følg min blog.

Find mig på LinkedIn.

Denne øvelse var baseret på den fremragende lærebog af Aurélien Géron, i referencen.

Sådan vælger du antallet af estimatorer til Gradient Boosting Genudgivet fra kilde https://towardsdatascience.com/how-to-choose-the-number-of-estimators-for-gradient-boosting-8d06920ab891?source=rss—-7f60cf5620c9— 4 via https://towardsdatascience.com/feed

<!–

->