A precisão da máquina de aumento de gradiente diminui à medida que o número de iterações aumenta

Estou experimentando o algoritmo da máquina de aumento de gradiente através do caretpacote em R.

Usando um pequeno conjunto de dados de admissões de faculdade, executei o seguinte código:

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)

e descobri, para minha surpresa, que a precisão da validação cruzada do modelo diminuiu em vez de aumentar à medida que o número de iterações de aumento aumentou, atingindo uma precisão mínima de cerca de 0,59 em ~ 450.000 iterações.

Eu implementei o algoritmo GBM incorretamente?

EDIT: Seguindo a sugestão do Underminer, executei novamente o caretcódigo acima , mas foquei em executar de 100 a 5.000 iterações de aprimoramento:

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)

O gráfico resultante mostra que a precisão atinge o pico de aproximadamente 0,705 a ~ 1.800 iterações:

O curioso é que a precisão não alcançou ~ 0,70, mas declinou após 5.000 iterações.

Em geral, o erro de aumento pode aumentar com o número de iterações, especificamente quando os dados são barulhentos (por exemplo, casos com erros de etiqueta). Esse pode ser o seu problema, mas eu não poderia dizer sem saber mais sobre seus dados

Basicamente, o aumento pode 'focar' na previsão correta de casos que contêm informações erradas e, no processo, deteriora o desempenho médio em outros casos mais substanciais.

Esse link ( Boosting and Noise ) mostra uma descrição melhor do que eu posso fornecer sobre o problema.

Este artigo ( Ruído de classificação aleatória ) de Long e Servedio fornece mais detalhes técnicos do problema.

O que você exibiu é um exemplo clássico de sobreajuste. O pequeno aumento no erro vem do desempenho inferior na parte de validação do seu conjunto de dados com validação cruzada. Mais iterações quase sempre melhoram o erro no conjunto de treinamento, mas o oposto é verdadeiro para o conjunto de validação / teste.

Códigos para reproduzir um resultado semelhante, sem pesquisa na grade,

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

O pacote gbm tem uma função para estimar o número ideal de iterações (= número de árvores ou número de funções básicas),

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

Você não precisa do trem de interdição para isso.