Bagaimana memilih jumlah estimator untuk Gradient Boosting

Dalam Ilmu Data, ada banyak algoritma yang tersedia untuk digunakan saat ini. Oleh karena itu, salah satu teknik yang berguna adalah menggabungkannya dalam satu model untuk mendapatkan yang terbaik dari masing-masing, menghasilkan model yang lebih akurat.

Menggunakan Scikit-Learn, Anda akan menemukan algoritma Random Forest, yaitu model ansambel yang mengantongi. Di sisi lain, Anda juga akan menemukan model Boosting, yang melatih estimator secara berurutan, di mana hasil dari satu model diteruskan ke model berikutnya, yang akan mencoba memperbaiki prediksi, hingga mencapai hasil yang optimal.

Saat membuat estimator Gradient Boosting, Anda akan menemukan hyperparameter ini n_estimator=100 dengan nilai default 100 pohon yang akan dibuat untuk mendapatkan hasil. Sering kali, kami hanya mengatur ini ke default atau mungkin meningkatkan sesuai kebutuhan, bahkan menggunakan teknik Grid Search.

Dalam postingan ini, kita akan menemukan cara sederhana untuk mendapatkan satu nomor yang akan digunakan untuk melatih model kita.

Peningkatan Gradien dapat dimuat dari Scikit-Learn menggunakan kelas ini from sklearn.ensemble import GradientBoostingRegressor. Algoritma Gradient Boosting dapat digunakan untuk klasifikasi atau model Regresi. Ini adalah estimator berbasis Pohon - artinya terdiri dari banyak pohon keputusan.

Hasil dari Pohon 1 akan menghasilkan kesalahan. Kesalahan tersebut akan digunakan dan masukan untuk Pohon 2. Sekali lagi, kesalahan dari model terakhir akan digunakan dan masukan dari model berikutnya, hingga mencapai n_estimators nilai.

Karena setiap estimator akan cocok dengan kesalahan yang sebelumnya, harapannya adalah bahwa kombinasi prediksi akan lebih baik daripada kombinasi prediksi mana pun. Setelah setiap iterasi, kami membuat model lebih kompleks, mengurangi bias tetapi meningkatkan varians, di sisi lain. Jadi kita harus tahu kapan harus berhenti.

Mari kita lihat bagaimana melakukannya sekarang.

Kode untuk latihan ini sederhana. Yang harus kita lakukan hanyalah membuat loop setelah setiap iterasi dan memeriksa di mana kita memiliki kesalahan terendah.

Mari kita mulai dengan memilih kumpulan data. Kami akan menggunakan kecelakaan mobil dataset, asli dari perpustakaan seaborn (jadi data terbuka di bawah lisensi BDS).

# Himpunan data
df = sns.load_dataset('car_crashes')

Berikut sekilas datanya. Kami akan mencoba untuk memperkirakan total jumlah menggunakan fitur lain sebagai prediktor. Karena ini adalah keluaran bilangan real, kita berbicara tentang model regresi.

Cepat melihat korelasi.

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

Oke, tidak ada multikolinearitas besar. Kita bisa melihat itu ins_premium dan ins_losses tidak berkorelasi sangat baik dengan total , jadi kami tidak akan mempertimbangkannya dalam model.

Jika kami memeriksa data yang hilang, tidak ada

# Hilang
df.isnull().jumlah()
0

Bagus, jadi mari kita pisahkan datanya sekarang.

# X dan y
X = df.drop(['ins_premium', 'ins_losses', 'singkatan', 'total'], axis=1)
y = df['total']# Tes kereta
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=22)

Kita dapat membuat pipeline untuk menskalakan data dan memodelkannya (sebenarnya tidak terlalu penting untuk menskalakan data ini, karena mereka sudah dalam skala yang sama, pada basis puluhan). Selanjutnya, kami menyesuaikan data dengan model dan memprediksi hasilnya.

Saya menggunakan 500 estimator dengan a learning_rate dari 0.3.

Tingkat pembelajaran adalah ukuran langkah yang kami ambil untuk mendapatkan kesalahan minimum. Jika kita menggunakan nilai yang terlalu tinggi, kita mungkin melewati batas minimum. Jika kita menggunakan angka yang terlalu kecil, kita bahkan mungkin tidak bisa mendekatinya. Jadi, aturan praktis yang dapat Anda pertimbangkan adalah: jika Anda memiliki banyak estimator, Anda dapat menggunakan nilai kecepatan pembelajaran yang lebih rendah. Jika Anda hanya memiliki sedikit estimator, lebih baik gunakan nilai kecepatan pembelajaran yang lebih tinggi.

langkah = [('skala', StandardScaler()),
('GBR', GradientBoostingRegressor(n_estimators=500, learning_rate=0.03)) ]# Instance Pipeline dan fit
pipa = Pipa(langkah).fit(X_train, y_train)# Meramalkan
preds = pipa.prediksi(X_test)

Sekarang, mengevaluasi.

# RMSE dari prediksi
print(f'RMSE: { round(np.sqrt(mean_squared_error(y_test, preds)),1 )}')[KELUAR]: RMSE: 1.1# Rata-rata nilai Y sebenarnya
print(f'Data y mean: {round( y.mean(),1 )}')[OUT]: Data y rata-rata: 15.8

Bagus. RMSE kami adalah sekitar 6.9% dari rata-rata. Jadi kita melenceng sebanyak ini, rata-rata.

Sekarang mari kita periksa cara menyetel model kita dengan memilih jumlah estimator optimal untuk dilatih yang akan memberi kita tingkat kesalahan terendah.

Seperti yang saya katakan, kita tidak perlu menskalakan data ini karena sudah dalam proporsi yang sama. Jadi mari kita sesuaikan modelnya.

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

Sekarang ini adalah hal yang baik. Ada metode dalam Gradient Boosting yang memungkinkan kita mengulang prediksi setiap estimator yang dilatih, dari 1 hingga 500. Jadi, kita akan membuat loop yang melewati 500 estimator di gbr model, memprediksi hasil menggunakan metode staged_predict(), menghitung kesalahan kuadrat rata-rata dan menyimpan hasilnya dalam daftar errors.

# Ulangi untuk nomor terbaik
kesalahan = [mean_squared_error(y_test, preds) untuk preds di gbr.staged_predict(X_test)]# Jumlah estimator yang optimal
optimal_num_estimators = np.argmin(kesalahan) + 1

Selanjutnya, kita dapat memplot hasilnya.

#Merencanakan
g=sns.lineplot(x=rentang(500), y=kesalahan)
g.set_title(f'Jumlah estimator terbaik di {best_n_estimators}', size=15);

Kami melihat bahwa tingkat kesalahan terendah adalah dengan 34 estimator. Jadi, mari latih ulang model kita dengan 34 estimator dan bandingkan dengan hasil dari model yang dilatih dengan pipeline.

# Latih kembali
gbr = GradientBoostingRegressor(n_estimators=34, learning_rate=0.3).fit(X_train, y_train)# Prediksi
preds2 = gbr.prediksi(X_test)

Mengevaluasi…

# RMSE dari prediksi
print(f'RMSE: { round(np.sqrt(mean_squared_error(y_test, preds2)),1 )}')
[KELUAR]: RMSE: 1.0# Data Y berarti
print(f'Data y mean: {round( y.mean(),1 )}')[OUT]: Data y rata-rata: 15.8

Kami turun dari 6.9% menjadi 6.3% sekarang. Kira-kira 9% lebih baik. Mari kita lihat beberapa prediksi.

Hasil yang menarik. Beberapa prediksi model kedua lebih baik dari yang pertama.

Kami belajar bagaimana menentukan jumlah estimator terbaik untuk men-tweak a GradientBoostingRegressor dari Scikit-Pelajari. Ini adalah hyperparameter yang dapat membuat perbedaan dalam model ansambel semacam ini, yang melatih estimator secara berurutan.

Kadang-kadang, setelah beberapa iterasi, model bisa mulai overfit, sehingga akan mulai meningkatkan varians terlalu banyak, yang berdampak pada prediksi.

Kami melihat bahwa loop sederhana dapat membantu kami menemukan solusi optimal dalam kasus ini. Tapi, tentu saja, untuk kumpulan data besar, perhitungannya bisa mahal, jadi idenya akan mencoba yang lebih rendah n_estimators pada awalnya dan lihat apakah Anda dapat segera mencapai kesalahan minimum.

Ini dia kode lengkap di GitHub.

Jika Anda menyukai konten ini, ikuti blog saya.

Temukan saya di LinkedIn.

Latihan ini didasarkan pada buku teks yang sangat bagus oleh Aurélien Géron, sebagai referensi.

Bagaimana memilih jumlah estimator untuk Gradient Boosting Diterbitkan ulang dari Sumber https://towardsdatascience.com/how-to-choose-the-number-of-estimators-for-gradient-boosting-8d06920ab891? 7 melalui https://towardsdatascience.com/feed

<!–

->