Buenas a todos. Desde hace un tiempo estoy tratando de aplicar las
funciones de la familia *pply en todo lo que puedo, pero todavía no es
algo que me surja tan rápidamente o naturalmente al momento de los loops
como usar for().
Conozco las ventajas de usar estas funciones y por eso mi intento de
hacerme de ellas.
Por ejemplo en este problema:
data=matrix(rnorm(100*20),20,100)
col=sample(1:100,100)
t1=Sys.time()
medias=replicate(1000,{
sel=sample(1:20,10)
pareja=sample(sel,100,replace = T)
ta=Sys.time()
*recep=NULL**
** for(i in 1:100){**
** n=col[i]**
** m=pareja[i]**
** c=data[m,n]**
** recep=c(recep,c)**
** }**
* tb=Sys.time()
media=mean(recep)
tt=tb-ta
c(media,tt)
})
t2=Sys.time()
diftime=(t2-t1)[[1]]
sum(medias[2,])/diftime
la parte que está en negrita (si usé bien los Sys.time()) me representa
(hice varias pruebas) aprox un 60% del tiempo total empleado.
Mi pregunta es, para este ejemplo ¿cómo plantearían una solución usando
funciones *pply?
Y luego ver cuanto aumenta en el rendimiento del uso del tiempo.
De paso, la salida que obtengo es una matriz de 2 por 1000, cuando sería
más interesante una matriz de 1000 por 2. Si se usa simplify = F como
argumento de replicate() resulta en una lista. ¿Existe algún argumento
que directamente obtenga una matriz de 1000 por 2? (Esto último pensando
en de repente 100000 o 1000000 de repeticiones y salidas más complejas).
Saludos!
--
Fernando Macedo
[[alternative HTML version deleted]]
Hola Fernando, No puedo ver las negritas, pero intuyo que lo que quieres es calcular la media por columnas? Si es asi, hay dos maneras: 1. Usa colMeans(x), donde "x" es tu matriz de datos 2. Usa apply(x, 2, mean) donde "x" es tu matriz de datos Existe una tercera pero menos conocida posibilidad que es usando el paquete matrixStats. Esta implementado en C en su mayoria y, de acuerdo con el autor, es mucho mas rapido que la familia *apply. En http://cran.r-project.org/web/packages/matrixStats/vignettes/matrixStats-methods.html puedes encontrar mas informacion. Saludos cordiales, Jorge.- 2015-03-19 11:01 GMT+11:00 Fernando Macedo <fermace en gmail.com>:> Buenas a todos. Desde hace un tiempo estoy tratando de aplicar las > funciones de la familia *pply en todo lo que puedo, pero todavía no es > algo que me surja tan rápidamente o naturalmente al momento de los loops > como usar for(). > Conozco las ventajas de usar estas funciones y por eso mi intento de > hacerme de ellas. > > Por ejemplo en este problema: > > data=matrix(rnorm(100*20),20,100) > col=sample(1:100,100) > > t1=Sys.time() > > medias=replicate(1000,{ > sel=sample(1:20,10) > pareja=sample(sel,100,replace = T) > ta=Sys.time() > *recep=NULL** > ** for(i in 1:100){** > ** n=col[i]** > ** m=pareja[i]** > ** c=data[m,n]** > ** recep=c(recep,c)** > ** }** > * tb=Sys.time() > media=mean(recep) > tt=tb-ta > c(media,tt) > }) > > t2=Sys.time() > > diftime=(t2-t1)[[1]] > > sum(medias[2,])/diftime > > > la parte que está en negrita (si usé bien los Sys.time()) me representa > (hice varias pruebas) aprox un 60% del tiempo total empleado. > > Mi pregunta es, para este ejemplo ¿cómo plantearían una solución usando > funciones *pply? > Y luego ver cuanto aumenta en el rendimiento del uso del tiempo. > > De paso, la salida que obtengo es una matriz de 2 por 1000, cuando sería > más interesante una matriz de 1000 por 2. Si se usa simplify = F como > argumento de replicate() resulta en una lista. ¿Existe algún argumento > que directamente obtenga una matriz de 1000 por 2? (Esto último pensando > en de repente 100000 o 1000000 de repeticiones y salidas más complejas). > > > Saludos! > > -- > Fernando Macedo > > > [[alternative HTML version deleted]] > > _______________________________________________ > 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 Jorge, muchas gracias por tu pronta respuesta, no me di cuenta que
el formateo podría causar problemas, envío de nuevo el código sin formatos.
La idea básica es para un set de números de columnas (desordenados) y un
set de numeros de fila el loop lo que hace es ir a la fila y columna
correspondiente de data, tomar el valor y luego hacer la media sobre esos.
data=matrix(rnorm(100*20),20,100)
col=sample(1:100,100)
t1=Sys.time()
medias=replicate(1000,{
sel=sample(1:20,10)
pareja=sample(sel,100,replace = T)
ta=Sys.time()
recep=NULL
for(i in 1:100){
n=col[i]
m=pareja[i]
c=data[m,n]
recep=c(recep,c)
}
tb=Sys.time()
media=mean(recep)
tt=tb-ta
c(media,tt)
},simplify=T)
t2=Sys.time()
diftime=(t2-t1)[[1]]
sum(medias[2,])/diftime
Fernando Macedo
El 18/03/15 a las 21:06, Jorge I Velez escribió:> Hola Fernando,
>
> No puedo ver las negritas, pero intuyo que lo que quieres es calcular
> la media por columnas? Si es asi, hay dos maneras:
>
> 1. Usa colMeans(x), donde "x" es tu matriz de datos
> 2. Usa apply(x, 2, mean) donde "x" es tu matriz de datos
>
> Existe una tercera pero menos conocida posibilidad que es usando el
> paquete matrixStats. Esta implementado en C en su mayoria y, de
> acuerdo con el autor, es mucho mas rapido que la familia *apply. En
>
http://cran.r-project.org/web/packages/matrixStats/vignettes/matrixStats-methods.html
> puedes encontrar mas informacion.
>
> Saludos cordiales,
> Jorge.-
>
>
>
> 2015-03-19 11:01 GMT+11:00 Fernando Macedo <fermace en gmail.com
> <mailto:fermace en gmail.com>>:
>
> Buenas a todos. Desde hace un tiempo estoy tratando de aplicar las
> funciones de la familia *pply en todo lo que puedo, pero todavía no es
> algo que me surja tan rápidamente o naturalmente al momento de los
> loops
> como usar for().
> Conozco las ventajas de usar estas funciones y por eso mi intento de
> hacerme de ellas.
>
> Por ejemplo en este problema:
>
> data=matrix(rnorm(100*20),20,100)
> col=sample(1:100,100)
>
> t1=Sys.time()
>
> medias=replicate(1000,{
> sel=sample(1:20,10)
> pareja=sample(sel,100,replace = T)
> ta=Sys.time()
> *recep=NULL**
> ** for(i in 1:100){**
> ** n=col[i]**
> ** m=pareja[i]**
> ** c=data[m,n]**
> ** recep=c(recep,c)**
> ** }**
> * tb=Sys.time()
> media=mean(recep)
> tt=tb-ta
> c(media,tt)
> })
>
> t2=Sys.time()
>
> diftime=(t2-t1)[[1]]
>
> sum(medias[2,])/diftime
>
>
> la parte que está en negrita (si usé bien los Sys.time()) me
> representa
> (hice varias pruebas) aprox un 60% del tiempo total empleado.
>
> Mi pregunta es, para este ejemplo ¿cómo plantearían una solución
> usando
> funciones *pply?
> Y luego ver cuanto aumenta en el rendimiento del uso del tiempo.
>
> De paso, la salida que obtengo es una matriz de 2 por 1000, cuando
> sería
> más interesante una matriz de 1000 por 2. Si se usa simplify = F como
> argumento de replicate() resulta en una lista. ¿Existe algún argumento
> que directamente obtenga una matriz de 1000 por 2? (Esto último
> pensando
> en de repente 100000 o 1000000 de repeticiones y salidas más
> complejas).
>
>
> Saludos!
>
> --
> Fernando Macedo
>
>
> [[alternative HTML version deleted]]
>
> _______________________________________________
> R-help-es mailing list
> R-help-es en r-project.org <mailto:R-help-es en r-project.org>
> https://stat.ethz.ch/mailman/listinfo/r-help-es
>
>
[[alternative HTML version deleted]]
Hola, ¿qué tal?
Puedes hacer
data <- matrix(rnorm(100 *20), 100, 20)
medias <- replicate(1000,{
sel <- sample(1:20,10)
tmp <- data[cbind(sel, sample(sel,100,replace = T))]
mean(tmp)
})
Mira el párrafo de ?"]" que comienza diciendo "A third form of
indexing..."
Un saludo,
Carlos J. Gil Bellosta
http://www.datanalytics.com
El día 19 de marzo de 2015, 1:01, Fernando Macedo <fermace en gmail.com>
escribió:> Buenas a todos. Desde hace un tiempo estoy tratando de aplicar las
> funciones de la familia *pply en todo lo que puedo, pero todavía no es
> algo que me surja tan rápidamente o naturalmente al momento de los loops
> como usar for().
> Conozco las ventajas de usar estas funciones y por eso mi intento de
> hacerme de ellas.
>
> Por ejemplo en este problema:
>
> data=matrix(rnorm(100*20),20,100)
> col=sample(1:100,100)
>
> t1=Sys.time()
>
> medias=replicate(1000,{
> sel=sample(1:20,10)
> pareja=sample(sel,100,replace = T)
> ta=Sys.time()
> *recep=NULL**
> ** for(i in 1:100){**
> ** n=col[i]**
> ** m=pareja[i]**
> ** c=data[m,n]**
> ** recep=c(recep,c)**
> ** }**
> * tb=Sys.time()
> media=mean(recep)
> tt=tb-ta
> c(media,tt)
> })
>
> t2=Sys.time()
>
> diftime=(t2-t1)[[1]]
>
> sum(medias[2,])/diftime
>
>
> la parte que está en negrita (si usé bien los Sys.time()) me representa
> (hice varias pruebas) aprox un 60% del tiempo total empleado.
>
> Mi pregunta es, para este ejemplo ¿cómo plantearían una solución usando
> funciones *pply?
> Y luego ver cuanto aumenta en el rendimiento del uso del tiempo.
>
> De paso, la salida que obtengo es una matriz de 2 por 1000, cuando sería
> más interesante una matriz de 1000 por 2. Si se usa simplify = F como
> argumento de replicate() resulta en una lista. ¿Existe algún argumento
> que directamente obtenga una matriz de 1000 por 2? (Esto último pensando
> en de repente 100000 o 1000000 de repeticiones y salidas más complejas).
>
>
> Saludos!
>
> --
> Fernando Macedo
>
>
> [[alternative HTML version deleted]]
>
> _______________________________________________
> R-help-es mailing list
> R-help-es en r-project.org
> https://stat.ethz.ch/mailman/listinfo/r-help-es