Hogyan válasszuk ki a becslések számát a Gradient Boosting-hoz

A Data Science területén manapság számos algoritmus áll rendelkezésre. Az egyik hasznos technika ezért az, hogy ezeket egyetlen modellben kombináljuk, hogy mindegyikből a legjobbat hozzuk ki, ami pontosabb modellt eredményez.

A Scikit-Learn segítségével megtalálhatja a Random Forest algoritmust, vagyis a zsákoló jellegű együttes modellt. Másrészt találhatunk Boosting modelleket is, amelyek sorban képezik a becslőket, ahol az egyik modell eredményét átadják a következőnek, és megpróbálják javítani az előrejelzéseket, amíg el nem érik az optimális eredményt.

A Gradient Boosting becslés létrehozásakor ezt a hiperparamétert találja n_estimator=100 alapértelmezett értékkel 100 fát kell létrehozni az eredmény eléréséhez. Sokszor csak az alapértelmezettre állítjuk, vagy szükség szerint növeljük, akár Grid Search technikákkal is.

Ebben a bejegyzésben egy egyszerű módot találunk arra, hogyan juthatunk el egyetlen számhoz, amellyel modellünket betaníthatjuk.

A Gradient Boosting a Scikit-Learn programból tölthető be ezzel az osztályral from sklearn.ensemble import GradientBoostingRegressor. A Gradient Boosting algoritmus osztályozáshoz vagy regressziós modellekhez is használható. Ez egy fa alapú becslés – ami azt jelenti, hogy sok döntési fából áll.

A Fa 1 hibákat fog generálni. Ezeket a hibákat használják fel, és a bemenet a Fa 2. Ismét az előző modell hibáit és a következő bemenetét használjuk, amíg el nem éri a n_estimators értéket.

Mivel minden becslő illeszkedni fog az előző hibájához, a várakozások szerint az előrejelzések kombinációja jobb lesz, mint bármelyik becslő önmagában. Minden iteráció után bonyolultabbá tesszük a modellt, csökkentve a torzítást, de növelve a szórást, a másik oldalon. Tehát tudnunk kell, mikor kell abbahagyni.

Lássuk, hogyan kell ezt most megtenni.

A gyakorlat kódja egyszerű. Csak annyit kell tennünk, hogy minden iteráció után egy ciklust írunk le, és ellenőrizzük, hogy melyiknél volt a legkisebb hiba.

Kezdjük egy adatkészlet kiválasztásával. Használjuk a autóbalesetek adatkészlet, natív a seaborn könyvtárból (tehát nyílt adat BDS licenc alatt).

# Adatkészlet
df = sns.load_dataset('car_crashes')

Íme egy gyors pillantás az adatokra. Megpróbáljuk megbecsülni a total összeget használva a többi jellemzőt előrejelzőként. Mivel ez egy valós szám kimenet, regressziós modellről beszélünk.

Gyorsan megnézve az összefüggéseket.

# Összefüggések
df.corr().style.background_gradient(cmap='coolwarm')

Ok, nincs jelentős multikollinearitás. Ezt láthatjuk ins_premium és a ins_losses nem nagyon korrelálnak a total , ezért ezeket nem vesszük figyelembe a modellben.

Ha ellenőrizzük a hiányzó adatokat, akkor nincsenek

# Hiányzó
df.isnull().sum()
0

Szép, szóval most osszuk fel az adatokat.

# X és y
X = df.drop(['ins_premium', 'ins_losses', 'rövid', 'összesen'], axis=1)
y = df['összesen']# Vonat teszt
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=22)

Létrehozhatunk egy folyamatot az adatok méretezéséhez és modellezéséhez (igazából nem nagyon szükséges ezeket az adatokat skálázni, mert már ugyanabban a skálában vannak, tízes alapon). Ezután illesztjük az adatokat a modellhez, és előrejelezzük az eredményeket.

500 becslést használok a learning_rate A 0.3.

A tanulási sebesség annak a lépésnek a nagysága, amelyet a minimális hiba eléréséhez megteszünk. Ha túl magas értéket használunk, akkor túlléphetjük a minimumot. Ha túl kicsi számot használunk, akkor lehet, hogy a közelébe sem jutunk. Tehát egy ökölszabály, amelyet megfontolhat: ha nagy számú becslése van, akkor alacsonyabb tanulási arányt használhat. Ha csak néhány becslése van, inkább használja a tanulási arány magasabb értékeit.

lépések = [('scale', StandardScaler()),
('GBR', GradientBoostingRegressor(n_estimators=500, learning_rate=0.03)) ]# Példánycsővezeték és illeszkedés
pipe = Pipeline(lépések).fit(X_train, y_train)# Jósolni
preds = pipe.predict(X_test)

Most pedig értékelni.

# RMSE a jóslatok
print(f'RMSE: { round(np.sqrt(mean_squared_error(y_test, preds)),1 )}')[OUT]: RMSE: 1.1# A valódi Y értékek átlaga
print(f'Data y mean: {round( y.mean(),1 )}')[KI]: Az y adatok jelentése: 15.8

Jó. Az RMSE az átlag 6.9%-a. Szóval átlagosan ennyivel el vagyunk maradva.

Most nézzük meg a modellünk hangolásának módját úgy, hogy kiválasztjuk a betanítandó becslések optimális számát, amely a legalacsonyabb hibaarányt adja.

Mint mondtam, nem igazán kell méreteznünk ezeket az adatokat, mert máris ugyanilyen arányban vannak. Illesszük tehát a modellt.

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

Most ez a jó dolog. A Gradient Boostingben van egy módszer, amely lehetővé teszi, hogy minden egyes betanított becslő előrejelzését 1-től 500-ig iteráljuk. Tehát létrehozunk egy hurkot, amely végigmegy az 500 becslésen gbr modell, előrejelzi az eredményeket a módszer segítségével staged_predict(), kiszámítja az átlagos négyzetes hibát, és eltárolja az eredményt a listában errors.

# Loop a legjobb számért
errors = [ mean_squared_error(y_test, preds) for preds in gbr.staged_predict(X_test)]# A becslések optimális száma
optimális_becslők száma = np.argmin(errors) + 1

Ezután megrajzolhatjuk az eredményt.

#Cselekmény
g=sns.lineplot(x=tartomány(500), y=hibák)
g.set_title(f'A becslések legjobb száma {best_n_estimators}-nál', size=15);

Azt látjuk, hogy a legalacsonyabb hibaarány 34 becslésnél van. Tehát képezzük át a modellünket 34 becsléssel, és hasonlítsuk össze a csővezetékkel betanított modell eredményével.

# Átképzés
gbr = GradientBoostingRegressor(n_estimators=34, learning_rate=0.3).fit(X_train, y_train)# Előrejelzések
preds2 = gbr.predict(X_test)

Értékelő…

# RMSE a jóslatok
print(f'RMSE: { round(np.sqrt(mean_squared_error(y_test, preds2)),1 )}')
[OUT]: RMSE: 1.0# Az Y adat jelentése
print(f'Data y mean: {round( y.mean(),1 )}')[KI]: Az y adatok jelentése: 15.8

Most 6.9%-ról 6.3%-ra csökkentünk. kb. 9%-kal jobb. Nézzünk néhány jóslatot.

Érdekes eredmények. A második modell néhány előrejelzése jobb, mint az első.

Megtanultuk, hogyan határozzuk meg a becslések legjobb számát az a GradientBoostingRegressor a Scikit-Learn-től. Ez egy hiperparaméter, amely különbséget tud tenni az ilyen típusú ensemble modellben, amely sorban képezi a becsléseket.

Előfordul, hogy néhány iteráció után a modell túlillesztésnek indulhat, így túlságosan növeli a szórást, ami befolyásolja az előrejelzéseket.

Láttuk, hogy ebben az esetben egy egyszerű hurok segíthet megtalálni az optimális megoldást. De természetesen nagy adathalmazok esetén költséges lehet a számítás, ezért érdemes megpróbálni egy alacsonyabbat n_estimators először, és nézze meg, hogy elég hamar eléri-e a minimális hibát.

Itt van a teljes kódot a GitHubban.

Ha tetszett ez a tartalom, kövesd a blogomat.

Keressen meg LinkedIn.

Ez a gyakorlat Aurélien Géron kiváló tankönyve alapján készült, a hivatkozásban.

A https://towardsdatascience.com/how-to-choose-the-number-of-estimators-for-gradient-boosting-8d06920ab891?source=rss—-7f60cf5620c9-forrásból újra közzétett Gradient Boosting becslőinek számának kiválasztása 4 a https://towardsdatascience.com/feed oldalon

<!–

->