Akurasi mesin peningkat gradien menurun karena jumlah iterasi meningkat

15

Saya bereksperimen dengan algoritma mesin peningkat gradien melalui caretpaket di R.

Menggunakan dataset penerimaan perguruan tinggi kecil, saya menjalankan kode berikut:

library(caret)

### Load admissions dataset. ###
mydata <- read.csv("http://www.ats.ucla.edu/stat/data/binary.csv")

### Create yes/no levels for admission. ### 
mydata$admit_factor[mydata$admit==0] <- "no"
mydata$admit_factor[mydata$admit==1] <- "yes"             

### Gradient boosting machine algorithm. ###
set.seed(123)
fitControl <- trainControl(method = 'cv', number = 5, summaryFunction=defaultSummary)
grid <- expand.grid(n.trees = seq(5000,1000000,5000), interaction.depth = 2, shrinkage = .001, n.minobsinnode = 20)
fit.gbm <- train(as.factor(admit_factor) ~ . - admit, data=mydata, method = 'gbm', trControl=fitControl, tuneGrid=grid, metric='Accuracy')
plot(fit.gbm)

dan ternyata saya terkejut bahwa akurasi validasi silang model menurun daripada meningkat ketika jumlah peningkatan iterasi meningkat, mencapai akurasi minimum sekitar 0,59 pada ~ 450,000 iterasi.

Apakah saya salah menerapkan algoritma GBM?

EDIT: Mengikuti saran Underminer, saya telah menjalankan kembali caretkode di atas tetapi fokus menjalankan 100 hingga 5.000 meningkatkan iterasi:

set.seed(123)
fitControl <- trainControl(method = 'cv', number = 5, summaryFunction=defaultSummary)
grid <- expand.grid(n.trees = seq(100,5000,100), interaction.depth = 2, shrinkage = .001, n.minobsinnode = 20)
fit.gbm <- train(as.factor(admit_factor) ~ . - admit, data=mydata, method = 'gbm', trControl=fitControl, tuneGrid=grid, metric='Accuracy')
plot(fit.gbm)

Plot yang dihasilkan menunjukkan bahwa akurasi sebenarnya memuncak di hampir 0,705 di ~ 1.800 iterasi:

Yang aneh adalah bahwa keakuratannya tidak mencapai ~ 70, tetapi malah menurun setelah 5.000 iterasi.

machine-learning caret boosting gbm hypothesis-testing t-test panel-data psychometrics intraclass-correlation generalized-linear-model categorical-data binomial model intercept causality cross-correlation distributions ranks p-value z-test sign-test time-series references terminology cross-correlation definition probability distributions beta-distribution inverse-gamma missing-data paired-comparisons paired-data clustered-standard-errors cluster-sample time-series arima logistic binary-data odds-ratio medicine hypothesis-testing wilcoxon-mann-whitney unsupervised-learning hierarchical-clustering neural-networks train clustering k-means regression ordinal-data change-scores machine-learning experiment-design roc precision-recall auc stata multilevel-analysis regression fitting nonlinear jmp r data-visualization gam gamm4 r lme4-nlme many-categories regression causality instrumental-variables endogeneity controlling-for-a-variable

— RobertF
sumber

14

Secara umum, meningkatkan kesalahan dapat meningkat dengan jumlah iterasi, khususnya ketika data berisik (mis. Kasus salah label). Ini bisa menjadi masalah Anda, tetapi saya tidak akan bisa mengatakannya tanpa mengetahui lebih banyak tentang data Anda

Pada dasarnya, meningkatkan dapat 'fokus' pada prediksi yang benar kasus-kasus yang mengandung informasi yang salah, dan dalam proses, menurunkan kinerja rata-rata pada kasus-kasus lain yang lebih substantif.

Tautan ini ( Meningkatkan dan Kebisingan ) menunjukkan deskripsi yang lebih baik daripada yang saya dapat berikan tentang masalah ini.

Makalah ini ( Kebisingan Klasifikasi Acak ) oleh Long dan Servedio memberikan rincian teknis lebih lanjut tentang masalah ini.

— Underminer
sumber

16

Apa yang telah Anda tampilkan adalah contoh klasik dari overfitting. Uptick in error kecil berasal dari kinerja yang lebih buruk pada bagian validasi dari kumpulan data yang divalidasi silang Anda. Lebih banyak iterasi hampir selalu meningkatkan kesalahan pada set pelatihan, tetapi sebaliknya berlaku untuk set validasi / tes.

— Ryan Zotti
sumber

Jadi gradien meningkatkan setelan berdasarkan pada # iterasi penguat? Menarik. Saya pikir akurasi akan lebih tinggi setelah mencapai iterasi # yang optimal.

— RobertF

4

Itu benar. Dalam meningkatkan gradien, setiap pohon berikutnya dibangun dari residu pohon sebelumnya, sehingga GBM akan terus mencoba memotong kesalahan yang tersisa pada set data pelatihan bahkan dengan biaya untuk dapat menggeneralisasi ke set validasi / tes. Itu sebabnya Anda melakukan validasi silang - karena algoritme pemasangan tidak secara

— bawaan

1

Gradient Boosting terinspirasi oleh AdaBoost. AdaBoost sangat jarang cocok dan ketika itu terjadi, itu hanya sedikit dan setelah banyak, banyak iterasi. Saya pikir penjelasan @Underminer lebih cenderung mewakili apa yang terjadi daripada komentar ini, terutama mengingat tidak ada referensi dalam komentar ini.

— Ricardo Cruz

2

@ RicardoCruz Saya pikir itu menarik bahwa Anda jarang melihat gradien meningkatkan pakaian. Selama empat tahun saya menggunakannya, saya telah melihat yang sebaliknya - terlalu banyak pohon menyebabkan overfitting. Saya pernah harus membuktikan sesuatu yang mirip dengan seorang kolega dan saya bisa mengurangi kesalahan pada pelatihan yang diatur menjadi hampir nol, tetapi kesalahan validasi naik secara signifikan lebih dari GBM yang tidak terlalu berpakaian. Saya masih berpikir meningkatkan gradien adalah algoritma yang bagus. Biasanya ini adalah algoritma pertama yang saya gunakan - Anda hanya perlu berhati-hati tentang terlalu banyak pohon, yang dapat Anda lacak melalui validasi silang

— Ryan Zotti

2

@RyanZotti saya berdiri dikoreksi kemudian. Saya telah membaca banyak makalah tentang AdaBoost dari Schapire et al karena saya menikmati dasar teorinya yang kuat dan indah. Para penulis berpendapat bahwa meningkatkan cenderung overfitting, tetapi sangat sulit. Saya tidak punya banyak pengalaman dalam menggunakannya, dan mereka tidak memiliki dasar teori yang kuat untuk memperdebatkan ini, dan, tentu saja, penulis adalah penulis, mereka secara alami bersemangat dengan penemuan mereka, jadi jika Anda memiliki pengalaman yang bertentangan , Saya berdiri dikoreksi.

— Ricardo Cruz

4

Kode untuk mereproduksi hasil yang serupa, tanpa pencarian kotak,

mod = gbm(admit ~ .,
      data = mydata[,-5],
      n.trees=100000,
      shrinkage=0.001,
      interaction.depth=2,
      n.minobsinnode=10,
      cv.folds=5,
      verbose=TRUE,
      n.cores=2)

best.iter <- gbm.perf(mod, method="OOB", plot.it=TRUE, oobag.curve=TRUE, overlay=TRUE)
print(best.iter)
[1] 1487
pred = as.integer(predict(mod, newdata=mydata[,-5], n.trees=best.iter) > 0)
y = mydata[,1]
sum(pred == y)/length(y)
[1] 0.7225

— horaceT
sumber

3

Paket gbm memiliki fungsi untuk memperkirakan iterasi # yang optimal (= # pohon, atau # fungsi basis),

gbm.perf(mod, method="OOB", plot.it=TRUE, oobag=TRUE, overlay=TRUE)

Anda tidak perlu kereta sisir untuk itu.

— horaceT
sumber

Saya tidak tahu apakah itu menyelesaikan masalah yang saya alami - tampaknya # iterasi optimal adalah 5.000 dalam kasus saya di mana akurasi berada pada titik tertinggi, mendekati 0,70 (titik data pertama dalam plot saya). Tapi sepertinya itu salah. Lebih banyak iterasi harus mengarah pada akurasi yang lebih tinggi, bukan lebih rendah, kan?

— RobertF

1

@ RobertTF Pertama, saya pikir Anda tidak perlu mengubah mengakui menjadi faktor. Ia bekerja dengan baik: mod = gbm (mengakui ~., Data = mydata [, - 5], n.trees = 100000, penyusutan = 0,001, interaksi.depth = 2, n.minobsinnode = 10, cv.folds = 5 , verbose = BENAR, n.cores = 2). Anda dapat melihat di mana gbm memilih iter optimal dengan: best.iter <- gbm.perf (mod, method = "OOB", plot.it = TRUE, oobag.curve = TRUE, overlay = TRUE). Yaitu, ketika perubahan penyimpangan berubah negatif (lihat plot yang dihasilkan dari ini).

— horaceT

1

@RobertF Satu hal lagi. Dengan menentukan n.trees = (satu juta) dalam panggilan gbm, Anda akan menjalankan semua nomor iterasi dari 1 hingga 1.000.000. Jadi Anda tidak perlu tanda sisipan untuk melakukan itu untuk Anda.

— horaceT

1

@RobertF Lebih banyak tindak lanjut. Saya hanya menjalankan 100 ribu pohon / iterasi. Akurasi yang saya dapatkan dengan memilih iterasi terbaik dengan gbm.perf adalah 0,7225, yang cukup dekat dengan Anda menjalankan iterasi jaringan penuh.

— horaceT