Estoy realizando mi trabajo de maestría y estoy realizando un código muy extenso. Incluso por la cantidad de bucles se demora mucho en mostrar resultados. En cierta ocasión escuche que si lograba escribir el código en programación en paralelo los tiempos se reducen y no tendría que escribir tantos bucles. Como puedo hacer esto en R? De antemano muchas gracias por la colaboración. Cordial saludo. -- Alex Johann Zambrano Carbonell http://experienceinstatistics.blogspot.com/ [[alternative HTML version deleted]]
Hola, Sí, si puedes paralelizar en R. Con esta referencia puedes empezar (incluye referencias adicionales): http://journal.r-project.org/2009-1/RJournal_2009-1_Knaus+et+al.pdf Pero antes de llegar a ese punto, puedes considerar la opción de sustituir tus bucles por funciones de la familia *apply: http://stackoverflow.com/questions/3505701/r-grouping-functions-sapply-vs-lapply-vs-apply-vs-tapply-vs-by-vs-aggrega En cualquier caso, puedes compartir aquí en la lista los bucles que consideres más pesados y podemos ver de qué forma se pueden optimizar. Saludos, Carlos Ortega www.qualityexcellence.es El 23 de abril de 2013 21:53, Alex J. Zambrano <alexjzc@gmail.com> escribió:> Estoy realizando mi trabajo de maestría y estoy realizando un código muy > extenso. Incluso por la cantidad de bucles se demora mucho en mostrar > resultados. > > En cierta ocasión escuche que si lograba escribir el código en programación > en paralelo los tiempos se reducen y no tendría que escribir tantos bucles. > > Como puedo hacer esto en R? > > De antemano muchas gracias por la colaboración. > > Cordial saludo. > > -- > Alex Johann Zambrano Carbonell > http://experienceinstatistics.blogspot.com/ > > [[alternative HTML version deleted]] > > > _______________________________________________ > R-help-es mailing list > R-help-es@r-project.org > https://stat.ethz.ch/mailman/listinfo/r-help-es > >-- Saludos, Carlos Ortega www.qualityexcellence.es [[alternative HTML version deleted]]
Hola: Alex, puedes probar a utilizar apply en lugar de bucles for. Si consultando la ayuda de esa función no ves la luz, puedes consultarnos a partir de un bucle for que tengas en concreto, para orientarte acerca de cómo aplicar el apply (y nunca mejor dicho lo de aplicar). Ánimo con tu trabajo de maestría!!. Por cierto, aprovecho para lanzar esta consulta: recientemente he leído que en las versiones recientes de R (no sé a partir de cuál) el rendimiento de apply y for se aproximan, con lo cual la tendencia es la de que cada vez "compense" menos el usar apply. ¿Es correcto ésto?. Un saludo!. Eva --- El mar, 23/4/13, Alex J. Zambrano <alexjzc@gmail.com> escribió: De: Alex J. Zambrano <alexjzc@gmail.com> Asunto: [R-es] Programación en paralelo Para: r-help-es@r-project.org Fecha: martes, 23 de abril, 2013 21:53 Estoy realizando mi trabajo de maestría y estoy realizando un código muy extenso. Incluso por la cantidad de bucles se demora mucho en mostrar resultados. En cierta ocasión escuche que si lograba escribir el código en programación en paralelo los tiempos se reducen y no tendría que escribir tantos bucles. Como puedo hacer esto en R? De antemano muchas gracias por la colaboración. Cordial saludo. -- Alex Johann Zambrano Carbonell http://experienceinstatistics.blogspot.com/ [[alternative HTML version deleted]] -----Adjunto en línea a continuación----- _______________________________________________ R-help-es mailing list R-help-es@r-project.org https://stat.ethz.ch/mailman/listinfo/r-help-es [[alternative HTML version deleted]]
Mi experiencia reciente es que no es cierto. Además con muchísima diferencia. Tenía un proceso con bucles que me tardaba 50 minutos. Lo vectoricé y me tardó menos de 3 minutos. Me quedé muy impresionado con la diferencia, la verdad. Un saludo. Isidro Hidalgo Arellano Observatorio Regional de Empleo Consejería de Empleo y Economía ihidalgo en jccm.es http://www.jccm.es> -----Mensaje original----- > De: r-help-es-bounces en r-project.org [mailto:r-help-es-bounces en r- > project.org] En nombre de Eva Prieto Castro > Enviado el: martes, 23 de abril de 2013 22:53 > Para: r-help-es en r-project.org; Alex J. Zambrano > Asunto: Re: [R-es] Programación en paralelo > > > Hola: > > Alex, puedes probar a utilizar apply en lugar de bucles for. Si > consultando la ayuda de esa función no ves la luz, puedes consultarnos > a partir de un bucle for que tengas en concreto, para orientarte acerca > de cómo aplicar el apply (y nunca mejor dicho lo de aplicar). > > Ánimo con tu trabajo de maestría!!. > > Por cierto, aprovecho para lanzar esta consulta: recientemente he leído > que en las versiones recientes de R (no sé a partir de cuál) el > rendimiento de apply y for se aproximan, con lo cual la tendencia es la > de que cada vez "compense" menos el usar apply. ¿Es correcto ésto?. > > Un saludo!. > > Eva > > --- El mar, 23/4/13, Alex J. Zambrano <alexjzc en gmail.com> escribió: > > De: Alex J. Zambrano <alexjzc en gmail.com> > Asunto: [R-es] Programación en paralelo > Para: r-help-es en r-project.org > Fecha: martes, 23 de abril, 2013 21:53 > > Estoy realizando mi trabajo de maestría y estoy realizando un código > muy extenso. Incluso por la cantidad de bucles se demora mucho en > mostrar resultados. > > En cierta ocasión escuche que si lograba escribir el código en > programación en paralelo los tiempos se reducen y no tendría que > escribir tantos bucles. > > Como puedo hacer esto en R? > > De antemano muchas gracias por la colaboración. > > Cordial saludo. > > -- > Alex Johann Zambrano Carbonell > http://experienceinstatistics.blogspot.com/ > > [[alternative HTML version deleted]] > > > -----Adjunto en línea a continuación----- > > _______________________________________________ > R-help-es mailing list > R-help-es en r-project.org > https://stat.ethz.ch/mailman/listinfo/r-help-es > > [[alternative HTML version deleted]]
Hola Eva, Sobre el detalle que comentas del rendimiento de "*apply" vs. bucles "for" recientemente vi este estudio que por cierto no detalla la versión de R utilizada: http://rsnippets.blogspot.com.es/2013/03/gnu-r-loop-speed-comparison.html Sobre la degradación de velocidad, he oído algo pero asociado a multiplicación de grandes matrices y que esta degradación se produjo desde la versión 2.12. Saludos, Carlos Ortega www.qualityexcellence.es El 23 de abril de 2013 22:53, Eva Prieto Castro <evapcastro@yahoo.es>escribió:> > Hola: > > Alex, puedes probar a utilizar apply en lugar de bucles for. Si > consultando la ayuda de esa función no ves la luz, puedes consultarnos a > partir de un bucle for que tengas en concreto, para orientarte acerca de > cómo aplicar el apply (y nunca mejor dicho lo de aplicar). > > Ánimo con tu trabajo de maestría!!. > > Por cierto, aprovecho para lanzar esta consulta: recientemente he leído > que en las versiones recientes de R (no sé a partir de cuál) el rendimiento > de apply y for se aproximan, con lo cual la tendencia es la de que cada vez > "compense" menos el usar apply. ¿Es correcto ésto?. > > Un saludo!. > > Eva > > --- El mar, 23/4/13, Alex J. Zambrano <alexjzc@gmail.com> escribió: > > De: Alex J. Zambrano <alexjzc@gmail.com> > Asunto: [R-es] Programación en paralelo > Para: r-help-es@r-project.org > Fecha: martes, 23 de abril, 2013 21:53 > > Estoy realizando mi trabajo de maestría y estoy realizando un código muy > extenso. Incluso por la cantidad de bucles se demora mucho en mostrar > resultados. > > En cierta ocasión escuche que si lograba escribir el código en programación > en paralelo los tiempos se reducen y no tendría que escribir tantos bucles. > > Como puedo hacer esto en R? > > De antemano muchas gracias por la colaboración. > > Cordial saludo. > > -- > Alex Johann Zambrano Carbonell > http://experienceinstatistics.blogspot.com/ > > [[alternative HTML version deleted]] > > > -----Adjunto en línea a continuación----- > > _______________________________________________ > R-help-es mailing list > R-help-es@r-project.org > https://stat.ethz.ch/mailman/listinfo/r-help-es > > [[alternative HTML version deleted]] > > > _______________________________________________ > R-help-es mailing list > R-help-es@r-project.org > https://stat.ethz.ch/mailman/listinfo/r-help-es > >-- Saludos, Carlos Ortega www.qualityexcellence.es [[alternative HTML version deleted]]
Hola Alex, El paquete "parallel" (que viene con R) tiene la funcion mclapply() que facilita la paralelizacion de una funcion f cualquiera. Otra posibilidad es utilizar el paquete "compiler" y la funcion cmpfun para compilar tu funcion f. Solo este paso (sin paralelizar) te ahorrara algo de tiempo. Ahora, si combinas mclapply con la funcion f compilada, ganas muchisimo mas. Los loops son en general menos eficientes que *apply, pero si creas los objetos "antes de" y luego vas llenandolos de informacion a traves de loops, el desempeño mejora considerablemente. La combinacion vectorizacion + compiler + parallels es ideal (ver comentario de Isidro). Saludos, Jorge.- 2013/4/24 Alex J. Zambrano <alexjzc@gmail.com>> Estoy realizando mi trabajo de maestría y estoy realizando un código muy > extenso. Incluso por la cantidad de bucles se demora mucho en mostrar > resultados. > > En cierta ocasión escuche que si lograba escribir el código en programación > en paralelo los tiempos se reducen y no tendría que escribir tantos bucles. > > Como puedo hacer esto en R? > > De antemano muchas gracias por la colaboración. > > Cordial saludo. > > -- > Alex Johann Zambrano Carbonell > http://experienceinstatistics.blogspot.com/ > > [[alternative HTML version deleted]] > > > _______________________________________________ > R-help-es mailing list > R-help-es@r-project.org > https://stat.ethz.ch/mailman/listinfo/r-help-es > >[[alternative HTML version deleted]]
Con respecto a este tema, pueden mencionar alguna bibliografía o web o hilo para profundizar? En la actualidad y en varios campos cada vez es más común encontrar bases de datos grandes. En particular no soy muy avanzado pero probando un código, usando for con if en el medio, que solamente recodifica datos de genotipados me llevaba como hora u hora y media. Estimo que usando apply o la sugerencia de Jorge Velez de combinar varias estrategias podría disminuir drásticamente el tiempo de procesado. Saludos y gracias. Fernando Macedo El 24 de abril de 2013 07:40, Jorge I Velez <jorgeivanvelez@gmail.com>escribió:> Hola Alex, > > El paquete "parallel" (que viene con R) tiene la funcion mclapply() que > facilita la paralelizacion de una funcion f cualquiera. > > Otra posibilidad es utilizar el paquete "compiler" y la funcion cmpfun para > compilar tu funcion f. Solo este paso (sin paralelizar) te ahorrara algo > de tiempo. Ahora, si combinas mclapply con la funcion f compilada, ganas > muchisimo mas. > > Los loops son en general menos eficientes que *apply, pero si creas los > objetos "antes de" y luego vas llenandolos de informacion a traves de > loops, el desempeño mejora considerablemente. > > La combinacion vectorizacion + compiler + parallels es ideal (ver > comentario de Isidro). > > Saludos, > Jorge.- > > > 2013/4/24 Alex J. Zambrano <alexjzc@gmail.com> > > > Estoy realizando mi trabajo de maestría y estoy realizando un código muy > > extenso. Incluso por la cantidad de bucles se demora mucho en mostrar > > resultados. > > > > En cierta ocasión escuche que si lograba escribir el código en > programación > > en paralelo los tiempos se reducen y no tendría que escribir tantos > bucles. > > > > Como puedo hacer esto en R? > > > > De antemano muchas gracias por la colaboración. > > > > Cordial saludo. > > > > -- > > Alex Johann Zambrano Carbonell > > http://experienceinstatistics.blogspot.com/ > > > > [[alternative HTML version deleted]] > > > > > > _______________________________________________ > > R-help-es mailing list > > R-help-es@r-project.org > > https://stat.ethz.ch/mailman/listinfo/r-help-es > > > > > > [[alternative HTML version deleted]] > > > _______________________________________________ > R-help-es mailing list > R-help-es@r-project.org > https://stat.ethz.ch/mailman/listinfo/r-help-es > >[[alternative HTML version deleted]]
Hola, Hay un libro de R dedicado a esto: http://www.amazon.com/Parallel-R-Q-Ethan-McCallum/dp/1449309925/ref=la_B008YIIKG6_1_1?ie=UTF8&qid=1366827125&sr=1-1 Saludos, Carlos Ortega www.qualityexcellence.es El 24 de abril de 2013 18:25, Fernando Macedo <fermace@gmail.com> escribió:> Con respecto a este tema, pueden mencionar alguna bibliografía o web o hilo > para profundizar? En la actualidad y en varios campos cada vez es más común > encontrar bases de datos grandes. > > En particular no soy muy avanzado pero probando un código, usando for con > if en el medio, que solamente recodifica datos de genotipados me llevaba > como hora u hora y media. Estimo que usando apply o la sugerencia de Jorge > Velez de combinar varias estrategias podría disminuir drásticamente el > tiempo de procesado. > > Saludos y gracias. > > Fernando Macedo > > > El 24 de abril de 2013 07:40, Jorge I Velez <jorgeivanvelez@gmail.com > >escribió: > > > Hola Alex, > > > > El paquete "parallel" (que viene con R) tiene la funcion mclapply() que > > facilita la paralelizacion de una funcion f cualquiera. > > > > Otra posibilidad es utilizar el paquete "compiler" y la funcion cmpfun > para > > compilar tu funcion f. Solo este paso (sin paralelizar) te ahorrara algo > > de tiempo. Ahora, si combinas mclapply con la funcion f compilada, ganas > > muchisimo mas. > > > > Los loops son en general menos eficientes que *apply, pero si creas los > > objetos "antes de" y luego vas llenandolos de informacion a traves de > > loops, el desempeño mejora considerablemente. > > > > La combinacion vectorizacion + compiler + parallels es ideal (ver > > comentario de Isidro). > > > > Saludos, > > Jorge.- > > > > > > 2013/4/24 Alex J. Zambrano <alexjzc@gmail.com> > > > > > Estoy realizando mi trabajo de maestría y estoy realizando un código > muy > > > extenso. Incluso por la cantidad de bucles se demora mucho en mostrar > > > resultados. > > > > > > En cierta ocasión escuche que si lograba escribir el código en > > programación > > > en paralelo los tiempos se reducen y no tendría que escribir tantos > > bucles. > > > > > > Como puedo hacer esto en R? > > > > > > De antemano muchas gracias por la colaboración. > > > > > > Cordial saludo. > > > > > > -- > > > Alex Johann Zambrano Carbonell > > > http://experienceinstatistics.blogspot.com/ > > > > > > [[alternative HTML version deleted]] > > > > > > > > > _______________________________________________ > > > R-help-es mailing list > > > R-help-es@r-project.org > > > https://stat.ethz.ch/mailman/listinfo/r-help-es > > > > > > > > > > [[alternative HTML version deleted]] > > > > > > _______________________________________________ > > R-help-es mailing list > > R-help-es@r-project.org > > https://stat.ethz.ch/mailman/listinfo/r-help-es > > > > > > [[alternative HTML version deleted]] > > > _______________________________________________ > R-help-es mailing list > R-help-es@r-project.org > https://stat.ethz.ch/mailman/listinfo/r-help-es > >-- Saludos, Carlos Ortega www.qualityexcellence.es [[alternative HTML version deleted]]
Estimado Fernando Macedo Casi de curioso vi lo siguiente: http://notjustmath.wordpress.com/2012/01/22/parallel-computing-with-r/ Javier Marcuzzi El 24 de abril de 2013 13:25, Fernando Macedo <fermace@gmail.com> escribió:> Con respecto a este tema, pueden mencionar alguna bibliografía o web o hilo > para profundizar? En la actualidad y en varios campos cada vez es más común > encontrar bases de datos grandes. > > En particular no soy muy avanzado pero probando un código, usando for con > if en el medio, que solamente recodifica datos de genotipados me llevaba > como hora u hora y media. Estimo que usando apply o la sugerencia de Jorge > Velez de combinar varias estrategias podría disminuir drásticamente el > tiempo de procesado. > > Saludos y gracias. > > Fernando Macedo > > > El 24 de abril de 2013 07:40, Jorge I Velez <jorgeivanvelez@gmail.com > >escribió: > > > Hola Alex, > > > > El paquete "parallel" (que viene con R) tiene la funcion mclapply() que > > facilita la paralelizacion de una funcion f cualquiera. > > > > Otra posibilidad es utilizar el paquete "compiler" y la funcion cmpfun > para > > compilar tu funcion f. Solo este paso (sin paralelizar) te ahorrara algo > > de tiempo. Ahora, si combinas mclapply con la funcion f compilada, ganas > > muchisimo mas. > > > > Los loops son en general menos eficientes que *apply, pero si creas los > > objetos "antes de" y luego vas llenandolos de informacion a traves de > > loops, el desempeño mejora considerablemente. > > > > La combinacion vectorizacion + compiler + parallels es ideal (ver > > comentario de Isidro). > > > > Saludos, > > Jorge.- > > > > > > 2013/4/24 Alex J. Zambrano <alexjzc@gmail.com> > > > > > Estoy realizando mi trabajo de maestría y estoy realizando un código > muy > > > extenso. Incluso por la cantidad de bucles se demora mucho en mostrar > > > resultados. > > > > > > En cierta ocasión escuche que si lograba escribir el código en > > programación > > > en paralelo los tiempos se reducen y no tendría que escribir tantos > > bucles. > > > > > > Como puedo hacer esto en R? > > > > > > De antemano muchas gracias por la colaboración. > > > > > > Cordial saludo. > > > > > > -- > > > Alex Johann Zambrano Carbonell > > > http://experienceinstatistics.blogspot.com/ > > > > > > [[alternative HTML version deleted]] > > > > > > > > > _______________________________________________ > > > R-help-es mailing list > > > R-help-es@r-project.org > > > https://stat.ethz.ch/mailman/listinfo/r-help-es > > > > > > > > > > [[alternative HTML version deleted]] > > > > > > _______________________________________________ > > R-help-es mailing list > > R-help-es@r-project.org > > https://stat.ethz.ch/mailman/listinfo/r-help-es > > > > > > [[alternative HTML version deleted]] > > > _______________________________________________ > R-help-es mailing list > R-help-es@r-project.org > https://stat.ethz.ch/mailman/listinfo/r-help-es > >[[alternative HTML version deleted]]
Hola, ¿qué tal? Sobre Por cierto, aprovecho para lanzar esta consulta: recientemente he leído que> en las versiones recientes de R (no sé a partir de cuál) el rendimiento de > apply y for se aproximan, con lo cual la tendencia es la de que cada vez > "compense" menos el usar apply. ¿Es correcto ésto?. >tengo una puntualización. Richard A. Becker, en su artículo "A Brief History of S", dice (refiriéndose a S alrededor del año 1980): "As users began to use S for larger problems, it became apparent that the implicit looping that S used (iterating over all elements of a vector), was unable to handle every problem. It was necessary to add explicit looping constructs to the language. We did so with a general for expression: for(index in values) expression where the index variable would take on the series of values in turn, each time executing the expression. Since one very common use of for loops was to iterate over the rows or columns of a matrix, the apply function was introduced. This function takes a matrix and the name of a function and applies that function in turn to each of the rows or columns of the matrix (or to general slices of an array) and does not require an explicit loop. We were able to implement apply so that the implicit looping was done with much greater efficiency than could be achieved by a loop in the S language." Y ha sido así hasta no hace tanto. Y es una idea que aún colea. Actualmente, sin embargo,> system.time( for(i in 1:10000) a <- runif(i))user system elapsed 2.461 0.028 2.491> system.time( sapply(1:10000, function(x) a <- runif(x)) )user system elapsed 2.976 0.020 3.000 Como puede comprobarse, no hay nada intrínsecamente ralentizador en el for. Eso sí, hay miles de maneras de dispararse en el pie con esos bucles. De hecho, yo apenas los uso. Y el principal motivo es que no veo natural tener que llevar la contabilidad de las iteraciones o encargarme de compilar el objeto de salida. Prefiero delegar esas tareas en funciones de más alto nivel. Un saludo, Carlos J. Gil Bellosta http://www.datanalytics.com [[alternative HTML version deleted]]
Hola Fernando, 2013/4/25 Fernando Macedo <fermace@gmail.com>> Con respecto a este tema, pueden mencionar alguna bibliografía o web o > hilo para profundizar? En la actualidad y en varios campos cada vez es más > común encontrar bases de datos grandes. > > En particular no soy muy avanzado pero probando un código, usando for con > if en el medio, que solamente recodifica datos de genotipados me llevaba > como hora u hora y media. >La estrategia que frecuentemente utilizo en casos como este es indexacion. Si "x" es tu base de datos de genotipos, podrias hacer algo como lo siguiente: x[x == "AA"] <- 2 x[x == "Aa"] <- 1 x[x == "aa"] <- 0 para cambiar "AA" por 2, "Aa" por 1 y "aa" por 0, donde 2, 1 y 0 corresponden al numero de copias del alelo "A" en cada genotipo presente en _toda_ tu base de datos. Veras que el tiempo de procesamiento se reducira drasticamente. Otra forma es utilizar la funcion recode de "car". Observa que en ambos casos no es necesario usar la combinacion if + for. Por cierto, si hay la condicion que debes chequear no es _extremadamente_ compleja, utilizar ifelse resulta, por lo general, mejor que if (ifelse es vectorizado). Saludos, Jorge.-> Estimo que usando apply o la sugerencia de Jorge Velez de combinar varias > estrategias podría disminuir drásticamente el tiempo de procesado. > > Saludos y gracias. > > Fernando Macedo > > > El 24 de abril de 2013 07:40, Jorge I Velez <jorgeivanvelez@gmail.com>escribió: > > Hola Alex, >> >> El paquete "parallel" (que viene con R) tiene la funcion mclapply() que >> facilita la paralelizacion de una funcion f cualquiera. >> >> Otra posibilidad es utilizar el paquete "compiler" y la funcion cmpfun >> para >> compilar tu funcion f. Solo este paso (sin paralelizar) te ahorrara algo >> de tiempo. Ahora, si combinas mclapply con la funcion f compilada, ganas >> muchisimo mas. >> >> Los loops son en general menos eficientes que *apply, pero si creas los >> objetos "antes de" y luego vas llenandolos de informacion a traves de >> loops, el desempeño mejora considerablemente. >> >> La combinacion vectorizacion + compiler + parallels es ideal (ver >> comentario de Isidro). >> >> Saludos, >> Jorge.- >> >> >> 2013/4/24 Alex J. Zambrano <alexjzc@gmail.com> >> >> > Estoy realizando mi trabajo de maestría y estoy realizando un código muy >> > extenso. Incluso por la cantidad de bucles se demora mucho en mostrar >> > resultados. >> > >> > En cierta ocasión escuche que si lograba escribir el código en >> programación >> > en paralelo los tiempos se reducen y no tendría que escribir tantos >> bucles. >> > >> > Como puedo hacer esto en R? >> > >> > De antemano muchas gracias por la colaboración. >> > >> > Cordial saludo. >> > >> > -- >> > Alex Johann Zambrano Carbonell >> > http://experienceinstatistics.blogspot.com/ >> > >> > [[alternative HTML version deleted]] >> > >> > >> > _______________________________________________ >> > R-help-es mailing list >> > R-help-es@r-project.org >> > https://stat.ethz.ch/mailman/listinfo/r-help-es >> > >> > >> >> [[alternative HTML version deleted]] >> >> >> _______________________________________________ >> R-help-es mailing list >> R-help-es@r-project.org >> https://stat.ethz.ch/mailman/listinfo/r-help-es >> >> > > >[[alternative HTML version deleted]]