So wählen Sie die Anzahl der Schätzer für Gradient Boosting aus

In Data Science stehen heutzutage viele Algorithmen zur Verfügung. Eine nützliche Technik besteht daher darin, sie in einem einzigen Modell zu kombinieren, um das Beste aus jedem herauszuholen, was zu einem genaueren Modell führt.

Mit Scikit-Learn finden Sie den Random-Forest-Algorithmus, das ist die absackende Art des Ensemble-Modells. Auf der anderen Seite finden Sie auch Boosting-Modelle, die die Schätzer der Reihe nach trainieren, wobei das Ergebnis eines Modells an das nächste weitergegeben wird, das versucht, die Vorhersagen zu verbessern, bis sie ein optimales Ergebnis erreichen.

Beim Erstellen eines Gradient Boosting-Schätzers finden Sie diesen Hyperparameter n_estimator=100 mit einem Standardwert von 100 zu erstellenden Bäumen, um zu einem Ergebnis zu kommen. Oft setzen wir dies einfach auf den Standardwert oder erhöhen es nach Bedarf, sogar mit Grid Search-Techniken.

In diesem Beitrag finden wir einen einfachen Weg, um zu einer einzelnen Zahl zu gelangen, mit der wir unser Modell trainieren können.

Gradient Boosting kann mit dieser Klasse von Scikit-Learn geladen werden from sklearn.ensemble import GradientBoostingRegressor. Der Gradient Boosting-Algorithmus kann entweder zur Klassifizierung oder für Regressionsmodelle verwendet werden. Es ist ein baumbasierter Schätzer – was bedeutet, dass er aus vielen Entscheidungsbäumen besteht.

Das Ergebnis der Baum 1 wird Fehler erzeugen. Diese Fehler werden verwendet und die Eingabe für die Baum 2. Wiederum werden die Fehler des letzten Modells verwendet und die Eingabe des nächsten, bis es das erreicht n_estimators Wert.

Da jeder Schätzer den Fehler des vorherigen anpasst, ist zu erwarten, dass die Kombination der Vorhersagen besser ist als die des Schätzers allein. Nach jeder Iteration machen wir das Modell komplexer, verringern die Verzerrung, erhöhen aber auf der anderen Seite die Varianz. Wir müssen also wissen, wann wir aufhören müssen.

Mal sehen, wie man das jetzt macht.

Der Code für diese Übung ist einfach. Alles, was wir tun müssen, ist nach jeder Iteration eine Schleife zu machen und zu prüfen, bei welcher wir den geringsten Fehler hatten.

Beginnen wir mit der Auswahl eines Datensatzes. Wir werden die verwenden Autounfälle Datensatz, nativ aus der Seaborn-Bibliothek (also eine Open Data unter BDS-Lizenz).

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

Hier ist ein kurzer Blick auf die Daten. Wir werden versuchen, die zu schätzen total Menge unter Verwendung der anderen Merkmale als Prädiktoren. Da es sich um eine reelle Zahlenausgabe handelt, sprechen wir von einem Regressionsmodell.

Schnell auf die Zusammenhänge schauen.

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

Ok, keine große Multikollinearität. Wir können das sehen ins_premium und ins_losses nicht sehr gut mit korrelieren total , daher werden wir sie im Modell nicht berücksichtigen.

Wenn wir die fehlenden Daten überprüfen, gibt es keine

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

Schön, also teilen wir die Daten jetzt auf.

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

Wir können eine Pipeline erstellen, um die Daten zu skalieren und zu modellieren (Es ist wirklich nicht sehr notwendig, diese Daten zu skalieren, da sie bereits auf der Zehnerbasis auf der gleichen Skala sind). Als nächstes passen wir die Daten an das Modell an und sagen die Ergebnisse voraus.

Ich verwende 500 Schätzer mit a learning_rate von 0.3.

Die Lernrate ist die Größe des Schrittes, den wir unternehmen, um zum minimalen Fehler zu gelangen. Wenn wir einen zu hohen Wert verwenden, überschreiten wir möglicherweise das Minimum. Wenn wir eine zu kleine Zahl verwenden, kommen wir möglicherweise nicht einmal in die Nähe. Eine Faustregel, die Sie berücksichtigen können, lautet also: Wenn Sie eine große Anzahl von Schätzern haben, können Sie niedrigere Werte für die Lernrate verwenden. Wenn Sie nur wenige Schätzer haben, verwenden Sie lieber höhere Werte für die Lernrate.

Schritte = [('scale', StandardScaler()),
('GBR', GradientBoostingRegressor(n_estimators=500, learning_rate=0.03))]# Instanz-Pipeline und fit
pipe = Pipeline(steps).fit(X_train, y_train)# Vorhersagen
preds = pipe.predict(X_test)

Jetzt auswerten.

# RMSE der Vorhersagen
print(f'RMSE: { round(np.sqrt(mean_squared_error(y_test, preds)),1 )}')[AUS]: RMSE: 1.1# Mittelwert der wahren Y-Werte
print(f'Daten y bedeuten: {round( y.mean(),1 )}')[OUT]: Daten y bedeuten: 15.8

Gut. Unser RMSE liegt bei etwa 6.9 % des Mittelwerts. Also sind wir im Durchschnitt um so viel daneben.

Lassen Sie uns nun prüfen, wie wir unser Modell optimieren können, indem wir die optimale Anzahl von zu trainierenden Schätzern auswählen, die uns die niedrigste Fehlerrate liefern.

Wie ich schon sagte, müssen wir diese Daten nicht wirklich skalieren, da sie bereits im gleichen Verhältnis stehen. Passen wir also das Modell an.

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

Jetzt ist es das gute Zeug. Es gibt eine Methode in Gradient Boosting, die es uns ermöglicht, die Vorhersagen jedes trainierten Schätzers von 1 bis 500 zu durchlaufen. Wir werden also eine Schleife erstellen, die die 500 Schätzer in durchläuft gbr Modell, sagt Ergebnisse unter Verwendung der Methode voraus staged_predict(), berechnet den mittleren quadratischen Fehler und speichert das Ergebnis in der Liste errors.

# Schleife für die beste Zahl
Fehler = [mean_squared_error(y_test, preds) für preds in gbr.staged_predict(X_test)]# Optimale Anzahl von Schätzern
optimale_num_estimators = np.argmin(errors) + 1

Als nächstes können wir das Ergebnis grafisch darstellen.

#Parzelle
g=sns.lineplot(x=Bereich(500), y=Fehler)
g.set_title(f'Beste Anzahl an Schätzern bei {best_n_estimators}', size=15);

Wir sehen, dass die niedrigste Fehlerquote bei 34 Schätzern liegt. Lassen Sie uns also unser Modell mit 34 Schätzern neu trainieren und mit dem Ergebnis des mit der Pipeline trainierten Modells vergleichen.

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

Auswerten…

# RMSE der Vorhersagen
print(f'RMSE: { round(np.sqrt(mean_squared_error(y_test, preds2)),1 )}')
[AUS]: RMSE: 1.0# Daten Y bedeuten
print(f'Daten y bedeuten: {round( y.mean(),1 )}')[OUT]: Daten y bedeuten: 15.8

Wir sind jetzt von 6.9 % auf 6.3 % Rabatt gesunken. Ca. 9% besser. Schauen wir uns ein paar Vorhersagen an.

Interessante Ergebnisse. Einige der Vorhersagen des zweiten Modells sind besser als die des ersten.

Wir haben gelernt, wie man die beste Anzahl von Schätzern bestimmt, um a zu optimieren GradientBoostingRegressor von Scikit-Learn. Dies ist ein Hyperparameter, der in dieser Art von Ensemblemodell, das Schätzer nacheinander trainiert, einen Unterschied machen kann.

Manchmal kann das Modell nach einigen Iterationen anfangen, sich zu überanpassen, wodurch die Varianz zu stark erhöht wird, was sich auf die Vorhersagen auswirkt.

Wir haben gesehen, dass uns eine einfache Schleife helfen kann, in diesem Fall die optimale Lösung zu finden. Aber natürlich kann die Berechnung bei großen Datensätzen teuer sein, daher wäre es eine Idee, einen niedrigeren Wert zu versuchen n_estimators zuerst und sehen Sie, ob Sie den minimalen Fehler bald genug erreichen können.

Hier ist die vollständigen Code in GitHub.

Wenn Ihnen dieser Inhalt gefallen hat, folgen Sie meinem Blog.

Finde mich auf LinkedIn.

Diese Übung basiert auf dem ausgezeichneten Lehrbuch von Aurélien Géron, in der Referenz.

So wählen Sie die Anzahl der Schätzer für Gradient Boosting neu veröffentlicht aus Quelle https://towardsdatascience.com/how-to-choose-the-number-of-estimators-for-gradient-boosting-8d06920ab891?source=rss—-7f60cf5620c9— 4 über https://towardsdatascience.com/feed

<!–

->