Hvordan velge antall estimatorer for Gradient Boosting

I Data Science er det mange algoritmer tilgjengelige for bruk i disse dager. En nyttig teknikk er derfor å bruke kombinere dem i en enkelt modell for å få det beste ut av hver, noe som resulterer i en mer nøyaktig modell.

Ved å bruke Scikit-Learn, vil du finne Random Forest-algoritmen, som er ensemblemodellen for bagging. På den annen side vil du også finne Boosting-modeller, som trener estimatorene i rekkefølge, hvor resultatet av en modell overføres til den neste, som vil prøve å forbedre spådommene, til de når et optimalt resultat.

Når du oppretter en Gradient Boosting-estimator, finner du denne hyperparameteren n_estimator=100 med en standardverdi på 100 trær som skal opprettes for å komme til et resultat. Mange ganger har vi bare satt dette til standard eller kanskje øke etter behov, til og med ved å bruke Grid Search-teknikker.

I dette innlegget vil vi finne en enkel måte å komme til et enkelt nummer for å bruke for å trene modellen vår.

Gradient Boosting kan lastes fra Scikit-Learn ved å bruke denne klassen from sklearn.ensemble import GradientBoostingRegressor. Gradient Boosting-algoritmen kan brukes enten for klassifisering eller for regresjonsmodeller. Det er en trebasert estimator - noe som betyr at den er sammensatt av mange beslutningstrær.

Resultatet av Tree 1 vil generere feil. Disse feilene vil bli brukt og inndataene for Tree 2. Nok en gang vil feilene til den siste modellen brukes og inndataene til den neste, til den når n_estimators verdi.

Siden hver estimator vil passe til feilen til den forrige, er forventningen at kombinasjonen av spådommene vil være bedre enn noen av estimatorens alene. Etter hver iterasjon gjør vi modellen mer kompleks, reduserer skjevhet, men øker variansen, på baksiden. Så vi må vite når vi skal stoppe.

La oss se hvordan du gjør det nå.

Koden for denne øvelsen er enkel. Alt vi må gjøre er en løkke etter hver iterasjon og sjekke hvilken vi hadde den laveste feilen.

La oss begynne med å velge et datasett. Vi vil bruke bilkrasj datasett, opprinnelig fra seaborn-biblioteket (så en åpen data under BDS-lisens).

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

Her er en rask titt på dataene. Vi vil prøve å anslå total mengde ved å bruke de andre funksjonene som prediktorer. Siden det er en reell tallutgang, snakker vi om en regresjonsmodell.

Ser raskt på sammenhengene.

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

Ok, ingen stor multikollinearitet. Det kan vi se ins_premium og ins_losses ikke korrelerer veldig godt med total , så vi vil ikke vurdere dem i modellen.

Hvis vi sjekker de manglende dataene, er det ingen

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

Fint, så la oss dele dataene nå.

# 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 lage en pipeline for å skalere dataene og modellere dem (det er egentlig ikke så veldig nødvendig å skalere disse dataene, siden de allerede er i samme skala, på titallet). Deretter tilpasser vi dataene til modellen og forutsier resultatene.

Jeg bruker 500 estimatorer med en learning_rate av 0.3.

Læringsraten er størrelsen på trinnet vi tar for å komme til minimumsfeilen. Hvis vi bruker en verdi som er for høy, kan vi passere minimum. Hvis vi bruker et tall som er for lite, kommer vi kanskje ikke engang i nærheten av det. Så en tommelfingerregel du kan vurdere er: hvis du har et stort antall estimatorer, kan du bruke lavere verdier for læringshastighet. Hvis du bare har noen få estimatorer, foretrekker du å bruke høyere verdier for læringshastighet.

trinn = [('scale', StandardScaler()),
('GBR', GradientBoostingRegressor(n_estimators=500, learning_rate=0.03)) ]# Forekomst Pipeline og passform
pipe = Pipeline(steps).fit(X_train, y_train)# Forutsi
preds = pipe.predict(X_test)

Nå, vurderer.

# RMSE av spådommene
print(f'RMSE: { round(np.sqrt(mean_squared_error(y_test, preds)),1 )}')[UT]: RMSE: 1.1# Gjennomsnitt av de sanne Y-verdiene
print(f'Data y mean: {round( y.mean(),1 )}')[UT]: Data y gjennomsnitt: 15.8

Flink. Vår RMSE er omtrent 6.9 % av gjennomsnittet. Så vi er i gjennomsnitt så mye.

La oss nå sjekke en måte å justere modellen vår på ved å velge det optimale antallet estimatorer å trene som vil gi oss den laveste feilraten.

Som jeg sa, vi trenger egentlig ikke å skalere disse dataene fordi de allerede er i samme andel. Så la oss tilpasse modellen.

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

Nå er det de gode tingene. Det er en metode i Gradient Boosting som lar oss iterere over spådommene til hver estimator som er trent, fra 1 til 500. Så vi vil lage en løkke som går gjennom de 500 estimatorene i gbr modell, forutsier resultater ved hjelp av metoden staged_predict(), beregner gjennomsnittlig kvadratfeil og lagrer resultatet i listen errors.

# Loop for det beste tallet
feil = [ mean_squared_error(y_test, preds) for preds i gbr.staged_predict(X_test)]# Optimalt antall estimatorer
optimal_num_estimators = np.argmin(errors) + 1

Deretter kan vi plotte resultatet.

#Plott
g=sns.lineplot(x=område(500), y=feil)
g.set_title(f'Beste antall estimatorer ved {best_n_estimators}', størrelse=15);

Vi ser at den laveste feilraten er med 34 estimatorer. Så la oss omskolere modellen vår med 34 estimatorer og sammenligne med resultatet fra modellen trent med rørledningen.

# Omskolere
gbr = GradientBoostingRegressor(n_estimators=34, learning_rate=0.3).fit(X_train, y_train)# Spådommer
preds2 = gbr.predict(X_test)

Evaluerer …

# RMSE av spådommene
print(f'RMSE: { round(np.sqrt(mean_squared_error(y_test, preds2)),1 )}')
[UT]: RMSE: 1.0# Data Y betyr
print(f'Data y mean: {round( y.mean(),1 )}')[UT]: Data y gjennomsnitt: 15.8

Vi gikk ned fra 6.9 % til 6.3 % rabatt nå. Ca. 9% bedre. La oss se på noen spådommer.

Interessante resultater. Noen av spådommene til den andre modellen er bedre enn den første.

Vi lærte hvordan vi bestemmer det beste antallet estimatorer for å justere en GradientBoostingRegressor fra Scikit-Learn. Dette er en hyperparameter som kan utgjøre en forskjell i denne typen ensemblemodell, som trener estimatorer i rekkefølge.

Noen ganger, etter noen iterasjoner, kan modellen begynne å overfitte, og dermed vil den begynne å øke variansen for mye, noe som påvirker spådommene.

Vi så at en enkel sløyfe kan hjelpe oss til å finne den optimale løsningen i dette tilfellet. Men for store datasett kan det være dyrt å beregne, så en ide ville være å prøve en lavere n_estimators først og se om du kan nå minimumsfeilen snart nok.

Her er komplett kode i GitHub.

Hvis du likte dette innholdet, følg bloggen min.

Finn meg på Linkedin.

Denne øvelsen var basert på den utmerkede læreboken til Aurélien Géron, i referansen.

Hvordan velge antall estimatorer for Gradient Boosting Republished 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

<!–

->