Entraînement par bootstrap aléatoire et génération de forêt

Question

J'ai d'énormes données d'entraînement pour la forêt aléatoire (dim: 47600811 * 9). Je veux prendre plusieurs (disons 1000) échantillon bootstrap de dimension 10000 * 9 (en prenant 9000 classes de classes négatives et 1000 classes de données positives dans chaque exécution) et générer itérativement des arbres pour chacun d'entre eux, puis combiner tous ces arbres en 1 forêt. Une idée approximative du code requis est donnée ci-dessous. Quelqu'un peut-il me guider comment puis-je générer un échantillon aléatoire avec remplacement de mes données de train réelles et générer de manière optimale des arbres pour eux de manière itérative? Ce sera une aide précieuse. Merci

library(doSNOW) 
library(randomForest) 
cl <- makeCluster(8) 
registerDoSNOW(cl) 

for (i=1:1000){ 
B <- 1000 
U <- 9000 
dataB <- trainData[sample(which(trainData$class == "B"), B,replace=TRUE),] 
dataU <- trainData[sample(which(trainData$class == "U"), U,replace=TRUE),] 
subset <- rbind(dataB, dataU) 

Je ne suis pas sûr que ce soit la meilleure façon de produire un sous-ensemble encore et encore (1000 fois) de trainData réelle.

rf <- foreach(ntree=rep(125, 8), .packages='randomForest') %dopar% { 
    randomForest(subset[,-1], subset$class, ntree=ntree) 
} 
} 
crf <- do.call('combine', rf) 
print(crf) 
stopCluster(cl) 

Answer 1

Bien que votre exemple parallélise l'intérieur plutôt que la boucle extérieure, il peut fonctionner raisonnablement bien tant que la boucle foreach interne prend plus de quelques secondes à exécuter, ce qui est presque certainement le cas. Cependant, votre programme a un bug: il jette les premiers 999 résultats foreach et ne traite que le dernier résultat. Pour résoudre ce problème, vous pouvez préallouer une liste de longueur 1000 * 8 et affecter les résultats de foreach à chaque itération de la boucle for externe. Par exemple:

library(doSNOW) 
library(randomForest) 
trainData <- data.frame(a=rnorm(20), b=rnorm(20), 
         class=c(rep("U", 10), rep("B", 10))) 
n <- 1000   # outer loop count 
chunksize <- 125 # value of ntree used in inner loop 
nw <- 8   # number of cluster workers 
cl <- makeCluster(nw) 
registerDoSNOW(cl) 
rf <- vector('list', n * nw) 
for (i in 1:n) { 
    B <- 1000 
    U <- 9000 
    dataB <- trainData[sample(which(trainData$class == "B"), B,replace=TRUE),] 
    dataU <- trainData[sample(which(trainData$class == "U"), U,replace=TRUE),] 
    subset <- rbind(dataB, dataU) 
    ix <- seq((i-1) * nw + 1, i * nw) 
    rf[ix] <- foreach(ntree=rep(chunksize, nw), 
        .packages='randomForest') %dopar% { 
    randomForest(subset[,-1], subset$class, ntree=ntree) 
    } 
} 
cat(sprintf("# models: %d; expected # models: %d\n", length(rf), n * nw)) 
cat(sprintf("expected total # trees: %d\n", n * nw * chunksize)) 
crf <- do.call('combine', rf) 
print(crf) 

Cela devrait résoudre le problème que vous mentionnez dans le commentaire que vous me dirigé vers.

Answer 2

Quelque chose comme ça fonctionnerait

# Replicate expression 1000 times, store output of each replication in a list 
# Find indices of class B and sample 9000 times with replacement 
# Do the same 1000 times for class U. Combine the two vectors of indices 

i = replicate(1000, {c(sample(which(trainData$class == "B"), 9000, replace = T), sample(which(trainData$class == "U"), 1000, replace = T))}) 

nourrir ensuite i dans une version parallèle de lapply

mclapply(i, function(i, ntree) randomForest(trainData[i,-1], trainData[i,]$class, ntree=ntree)