Bucles anidados - Bosque aleatorio, parámetros múltiples -- performance campo con r campo con machine-learning campo con data-mining camp codereview Relacionados El problema

Nested loops - Random Forest, multiple parameters


2
vote

problema

Español

Estoy escribiendo un código que la tarea es crecer los árboles forestales aleatorios basados ​​en múltiples parámetros. En resumen:

  1. En primer lugar, declaro un marco de datos en el que se guardarán los parámetros del modelo y algunas estadísticas.
  2. En segundo lugar, declaro parámetros de modelo y el iterador de bucle (se mostrará después de cada iteración de bucle).
  3. A continuación, tengo un buceo anidado con el modelo y la función de predicción.
  4. Además, los parámetros y algunas estadísticas de la matriz de confusión se guardan en elframe.
  5. Además, el número de iteraciones está impreso y contado.
  6. Por último, pero no menos importante, se llama al colector de basura.

El código se ve así:

  ## data frame in which model parameters and some stats will be saved  model_eff <- data.frame("ntrees" = numeric(0),                         "zeros" = numeric(0),                          "mvars"= numeric(0),                         "eff" = numeric(0),                         "0_0" = numeric(0),                         "0_1" = numeric(0),                         "1_0" = numeric(0),                         "1_1" = numeric(0),                         "predict_sum" = numeric(0),                         "triangle" = numeric(0))   ## parameteres  ntrees <- c(300, 500) zeros <- sum(train.target) * c(1, 2, 3, 4, 5) mvars <- c(30, 50, 70, 90, 110, 130)  ## loop counter  i = 1  ## loop with model, prediction etc.  for (j in 1:length(ntrees)){   for (k in 1:length(zeros)){     for (l in 1:length(mvars)){        ## i-th model        model <- randomForest(train,                             y = as.factor(train.target),                             ntree = ntrees[j],                             do.trace = T,                             sampsize = c('0' = zeros[k], '1' = sum(train.target)),                             mtry = mvars[l])        ## prediction - my function, apart from a regular prediction       ##              outputs additional info        predict.model(model, val, val.target)        ## inserting model parameters and stats to a data frame for further comparisons        model_eff <- rbind(model_eff,                          c("ntrees" = ntrees[j],                            "zeros" = zeros[k],                            "mvars"= mvars[l],                            "eff" = eff_measures$eff,                            "0_0" = eff_measures$c.m[1, 1],                            "0_1" = eff_measures$c.m[1, 2],                            "1_0" = eff_measures$c.m[2, 1],                            "1_1" = eff_measures$c.m[2, 2],                            "predict_sum" = sum(TARGET3),                            "triangle" = eff_measures$triangle))        ## printing the number of iteration        cat("iteration =", i)       i <- i+1        ## calling garbage collector to assure free space in RAM        gc()     }   } }   

Ya he dividido los conjuntos de datos de tren / validación y sus variables de destino, sabiendo que los bosques aleatorios se ocupan de dichos datos de manera eficiente. Sin embargo, también intenté usar el paquete "foreach" para las cálculos de paralelización, el tiempo creciente para un solo árbol fue de 10-15% más largo que el uso de todos los núcleos.

Me gustaría saber si puedo acortar el tiempo de ejecución de este código, especialmente si hay una manera de evitar múltiples bucles desde que escuché que no son la mejor manera de programar en R.

Original en ingles

I'm writing a code which task is to grow Random Forest trees based on multiple parameters. In short:

  1. Firstly, I declare a data frame in which model parameters and some stats will be saved.
  2. Secondly, I declare model parameters and the loop iterator (it will be showed after every loop iteration).
  3. Next, I have a nested loops with the model and prediction function.
  4. Furthermore, parameters and some stats from the confusion matrix are saved to the dataframe.
  5. Additionally, the number of iterations is printed and counted.
  6. Last but not least, garbage collector is called.

The code looks like this:

## data frame in which model parameters and some stats will be saved  model_eff <- data.frame("ntrees" = numeric(0),                         "zeros" = numeric(0),                          "mvars"= numeric(0),                         "eff" = numeric(0),                         "0_0" = numeric(0),                         "0_1" = numeric(0),                         "1_0" = numeric(0),                         "1_1" = numeric(0),                         "predict_sum" = numeric(0),                         "triangle" = numeric(0))   ## parameteres  ntrees <- c(300, 500) zeros <- sum(train.target) * c(1, 2, 3, 4, 5) mvars <- c(30, 50, 70, 90, 110, 130)  ## loop counter  i = 1  ## loop with model, prediction etc.  for (j in 1:length(ntrees)){   for (k in 1:length(zeros)){     for (l in 1:length(mvars)){        ## i-th model        model <- randomForest(train,                             y = as.factor(train.target),                             ntree = ntrees[j],                             do.trace = T,                             sampsize = c('0' = zeros[k], '1' = sum(train.target)),                             mtry = mvars[l])        ## prediction - my function, apart from a regular prediction       ##              outputs additional info        predict.model(model, val, val.target)        ## inserting model parameters and stats to a data frame for further comparisons        model_eff <- rbind(model_eff,                          c("ntrees" = ntrees[j],                            "zeros" = zeros[k],                            "mvars"= mvars[l],                            "eff" = eff_measures$eff,                            "0_0" = eff_measures$c.m[1, 1],                            "0_1" = eff_measures$c.m[1, 2],                            "1_0" = eff_measures$c.m[2, 1],                            "1_1" = eff_measures$c.m[2, 2],                            "predict_sum" = sum(TARGET3),                            "triangle" = eff_measures$triangle))        ## printing the number of iteration        cat("iteration =", i)       i <- i+1        ## calling garbage collector to assure free space in RAM        gc()     }   } } 

I have already split the train/validation data sets and their target variables, knowing that Random Forest deals with such data mor efficiently. I also tried to use the "foreach" package for parallelizing computations, however, the growing time for only one tree was 10-15% longer than without using all the cores.

I would like to know if I can shorten the time of execution of this code, especially if there is a way to avoid multiple loops since I heard that they are not the best way of programming in R.

           

Lista de respuestas

1
 
vote

Ejemplo reproducible

Desafortunadamente, el fragmento de código que dio no se presta a ser reproducible. Entonces, el consejo que se le da está restringido.

Los cachés son agradables

Hay ciertos momentos en los que debe estar almacenando en caché una suma si se sabe que el valor es constante a través de diferentes iteraciones. En este caso en particular, tenemos: lock5 y lock6 que debe estar en caché. Di:

  lock7  

Conocimiento (de tamaño) es poder!

Inmediatamente, uno de los problemas clave que enfrentará es el hecho de que usted es Rbind 60 elementos, ya que evita dar entradas numéricas estables en los datos. Frame

  lock8  

Declare lock9 Antes del 3x para los bucles. Luego guarde los resultados usando:

  GetTicks()0  

aleatorios paralelos a través de GetTicks()1

La única otra sugerencia que tengo para paralelar la compilación del bosque aleatorio a través de:

  GetTicks()2  
 

Reproducible Example

Unfortunately, the code snippet that you gave does not lend itself to being reproducible. So, the advice being given is constrained.

Caches are nice

There are certain times where you should be caching a summation if the value is known to be constant through different iterations. In this particular case, we have: sum(train.target) and sum(TARGET3) that should be cached. Say:

stt = sum(train.target) st3 = sum(TARGET3) 

Knowledge (of size) is Power!

Immediately, one of the key issue you will face is the fact that you are rbind 60 items since you avoid giving stable numerical entries in the data.frame

## parameteres  ntrees <- c(300, 500) zeros <- sum(train.target) * c(1, 2, 3, 4, 5) mvars <- c(30, 50, 70, 90, 110, 130)  nitr = length(ntrees)*length(zeros)*length(mvars)  model_eff <- data.frame("ntrees" = numeric(nitr),                         "zeros"  = numeric(nitr),                          "mvars"  = numeric(nitr),                         "eff"    = numeric(nitr),                         "0_0"    = numeric(nitr),                         "0_1"    = numeric(nitr),                         "1_0"    = numeric(nitr),                         "1_1"    = numeric(nitr),                         "predict_sum" = numeric(nitr),                         "triangle"    = numeric(nitr),                         stringsAsFactors = F) 

Declare count = 1 before the 3x for loops. Then save results using:

model_eff[count,] = c("ntrees" = ntrees[j],                       "zeros" = zeros[k],                       "mvars"= mvars[l],                       "eff" = eff_measures$eff,                       "0_0" = eff_measures$c.m[1, 1],                       "0_1" = eff_measures$c.m[1, 2],                       "1_0" = eff_measures$c.m[2, 1],                       "1_1" = eff_measures$c.m[2, 2],                       "predict_sum" = st3 ,                       "triangle" = eff_measures$triangle)) count = count + 1 

Parallel RandomForest via caret

The only other suggestion I have it to parallelize the build of the random forest via:

# caret modeling framework library(caret)  # Parallel backend library(doParallel)  # Register a cluster registerDoParallel(cores = 5)  rf_model = train(train.target~.,data=train,method="rf",                  prox=TRUE,allowParallel=TRUE) 
 
 

Relacionados problema

6  Algoritmo de apriori usando pandas  ( Apriori algorithm using pandas ) 
Quiero optimizar mi algoritmo apriori para la velocidad: from itertools import combinations import pandas as pd import numpy as np trans=pd.read_table('ou...

2  Función R para generar predicciones de las calificaciones  ( R function to generate predictions from ratings ) 
Estoy tratando de mejorar el tiempo de ejecución de un programa que escribí en R. En general, lo que estoy haciendo es alimentar una función un marco de datos...

2  Estructuración de la estructura html plana en un árbol  ( Structuring flat html structure into a tree ) 
Dada una página HTML con las etiquetas de encabezado, como hull [(Point (-3) 1),(Point (-4) 1),(Point (-1) 4),(Point 0 0),(Point 2 2),(Point (-1) 3),(Point (...

2  Pársero de archivos para extraer datos del archivo de texto  ( File parser to extract data from text file ) 
Estoy tratando de extraer los datos del archivo de entrada y almacenarlo para trazar. He probado este código para algunos archivos del mismo formato. No estoy...

2  CSMR para el mejor precio de texto  ( Csmr for large scale text prcessing ) 
Estoy trabajando en un proyecto para procesamiento de texto a gran escala, que es una primera implementación de la idea básica de CSMR. CSMR es un algoritmo q...

2  Analizando datos de tratamiento de pacientes usando Pandas  ( Analyzing patient treatment data using pandas ) 
Yo trabajo en la industria de la salud de la población y obtenga contratos de empresas comerciales para realizar investigaciones sobre sus productos. Este es ...

4  Analizar conjuntos muy grandes de datos de ingeniería de archivos de Excel  ( Analyze very large sets of engineering data from excel files ) 
Soy un ingeniero de energía eléctrica con algunas habilidades de programación. Mi jefe me pidió que hiciera un programa que pudiera analizar datos muy grandes...

2  C # Puerto de la minería de datos Algoritmo Mucho más lento que la implementación de referencia  ( C port of data mining algorithm much slower than reference implementation ) 
Estaba tratando de implementar el algoritmo especificado en este documento de investigación (Por favor, ignore las matemáticas, ya que es irrelevante para l...

3  Programa de minería de subgrógrafo frecuente  ( Frequent subgraph mining program ) 
Estoy tratando de hacer un programa que lee gráficos de un .txt1 archivo , los pone en un vector, y finalmente pone los gráficos cerrados frecuentes en ot...

6  Descenso de degradado para regresión lineal usando numeros / pandas  ( Gradient descent for linear regression using numpy pandas ) 
Actualmente lo sigo a lo largo de Andrew Ng's Curso de aprendizaje de la máquina En Coursera y quería implementar el algoritmo de descenso de degradado ...




© 2022 respuesta.top Reservados todos los derechos. Centro de preguntas y respuestas reservados todos los derechos