Antes de nada, me gustaría daros las gracias por toda vuestra ayuda.
He estado probando todo lo que me habéis dicho a la vez, y no hay manera, sigo
teniendo el problema con el espacio.
En cuanto al tamaño de la base de datos, es más grande de lo que puse, me
equivoqué y puse el tamaño de una base anterior con la que estuve trabajando, la
actual tiene 36866 filas x 6500 columnas.
He seguido todas vuestras recomendaciones (combinándolas) en diferentes
dispositivos y sistemas operativos, pero no hay manera. De hecho el último
intento fue haciendo los siguientes pasos en un sistema operativo Linux, con R
64 bits y en un servidor con 65Gb de RAM.
1) He convertido la base de datos en una matriz "sparse" cuyo tamaño
pasa de una matriz de 861.2Mb a una matriz de 10.2Mb
2) He eliminado todo lo que no es necesario de la función beta.pair dejándola
en:library (betapart) # para que cargue la función betapart.core()
beta.pair <- function(x, index.family="sorensen"){ # test for
a valid index index.family <- match.arg(index.family,
c('jaccard','sorensen')) # test for pre-existing
betapart objects if (! inherits(x, "betapart")){ x <-
betapart.core(x) } # run the analysis given the index
switch(index.family, sorensen = { beta.sim
<- x$min.not.shared pairwise <-
list(beta.sim=as.dist(beta.sim))}, jaccard =
{ beta.jtu <- (x$min.not.shared)
pairwise <- list(beta.jtu=as.dist(beta.jtu))}) return(pairwise)
}
3) He ejecutado la función.matriz_distancias <- beta.pair (sparse_matrix,
index.family="sorensen")
Y tras todos estos pasos me sigue dando el problema. Creo que ya solo me queda
probar con los paquetes de R para gestión de Big Data como ff o bigmemory.
¿Sabéis si las matrices que se guardan como bigmemory pueden manipularse con las
mismas funciones que el resto?En concreto quiero saber si voy a poder calcular
la matriz de distancias con beta.pair, y hacer un análisis cluster tipo UPGMA
sobre esa matriz (la función agnes () o hclust()).
Saludos, Rubén
> From: dirienzo.julio en gmail.com
> Date: Tue, 22 Dec 2015 17:31:03 -0300
> To: marcelino.delacruz en upm.es
> CC: r-help-es en r-project.org
> Subject: Re: [R-es] Cannot allocate vector of size
>
> Si las matrices tiene gran cantidad de ceros, es posible reducir
> sustancialmente la memoria utilizada cambiando las matrices convencionales
> por matrices sparse (library(Matrix))
>
> Dr. Julio Di Rienzo
> Estadística y Biometría
> FCA- U.N. Córdoba
> http://sites.google.com/site/juliodirienzo
>
>
> El 22 de diciembre de 2015, 15:41, Marcelino de la Cruz <
> marcelino.delacruz en upm.es> escribió:
>
> > Yo creo que el problema principal está en betapart.core(), que crea y
> > mantiene simultáneamente en memoria varios objetos de alrededor de 1
Gb que
> > luego combina en una lista... Probablemente es entre las líneas el
código
> > de betaper.core donde hay que ir eliminando objetos.
> >
> > Saludos,
> >
> > Marcelino
> >
> >
> > El 22/12/2015 a las 18:26, Carlos J. Gil Bellosta escribió:
> >
> >> Hola, ¿qué tal?
> >>
> >> Yo no entré a comentar lo que hacen ni beta.pair ni betapart.core,
que
> >> es la función a la que esta llama. Pero tanto la una como la otra
> >> hacen puras operaciones de álgebra lineal (sobre todo
betapart.core).
> >> Esas operaciones deberían ser muy livianas en términos de uso de
> >> memoria. El objeto resultante no deberia ocupar más de 1GB (una
matriz
> >> 11k x 11k).
> >>
> >> Así que si conviertes tus datos de entrada a matriz (en lugar de
DF),
> >> borras el DF y haces un gc() (para borrar el objeto grande
enseguida)
> >> y operas con con esa matriz, es fácil que no tengas problemas. ¡No
> >> deberías tenerlos!
> >>
> >> Un saludo,
> >>
> >> Carlos J. Gil Bellosta
> >> http:///www.datanalytics.com
> >>
> >>
> >>
> >>
> >>
> >>
> >> El día 22 de diciembre de 2015, 11:25, Francisco Rodriguez Sanchez
> >> <f.rodriguez.sanc en gmail.com> escribió:
> >>
> >>> Hola Rubén,
> >>>
> >>> Totalmente de acuerdo con los consejos de Carlos. Ten en
cuenta que
> >>> aunque R
> >>> disponga de varios (bastantes) GB de memoria, algunos de los
objetos que
> >>> va
> >>> creando durante el proceso pueden consumirla por completo. Es
decir, que
> >>> aunque tu ordenador tenga 64GB de RAM, es posible que no
queden 10 GB
> >>> libres
> >>> para almacenar un objeto (porque ya hay demasiados objetos
grandes en la
> >>> memoria).
> >>>
> >>> Sinceramente, más que intentar implementar los análisis en
python 'de
> >>> novo',
> >>> creo que lo mejor es optimizar el código de R para evitar
consumir toda
> >>> la
> >>> memoria. Por ejemplo, si miras el código de la función
beta.pair del
> >>> paquete
> >>> betapart (pegado más abajo), verás que crea 3 objetos
(beta.sim,
> >>> beta.sne, y
> >>> beta.sor) que probablemente son muy grandes. Y luego los
convierte a cada
> >>> uno en matriz de distancias (as.dist). En estas operaciones se
te va la
> >>> memoria, pues todos estos objetos están almacenados ahí.
> >>>
> >>> Por tanto, una solución fácil sería calcular cada una de estas
cosas de
> >>> una
> >>> en una, y acto seguido almacenarla en disco y reiniciar R (o
gestionar la
> >>> memoria, con gc, etc, mira
http://adv-r.had.co.nz/memory.html). Cuando
> >>> ya lo
> >>> tengas todo en disco puedes ir cargando objetos conforme los
vayas
> >>> necesitando. Si son demasiado grandes para leerlos, puedes
usar el
> >>> paquete
> >>> ff y similares. Un manual muy bueno para big data en R:
> >>> https://github.com/Robinlovelace/R-for-Big-Data.
> >>>
> >>> Así pues, desgranando y ejecutando una a unas las operaciones
que
> >>> ejecuta la
> >>> función beta.pair, creo que puedes solucionar tu problema. O
al menos eso
> >>> espero!
> >>>
> >>> Mucha suerte
> >>>
> >>> Paco
> >>>
> >>>
> >>>
> >>> beta.pair <- function(x,
index.family="sorensen"){
> >>>
> >>> # test for a valid index
> >>> index.family <- match.arg(index.family,
c('jaccard','sorensen'))
> >>>
> >>> # test for pre-existing betapart objects
> >>> if (! inherits(x, "betapart")){
> >>> x <- betapart.core(x)
> >>> }
> >>>
> >>> # run the analysis given the index
> >>> switch(index.family,
> >>> sorensen = {
> >>> beta.sim <- x$min.not.shared /
(x$min.not.shared + x$shared)
> >>> beta.sne <- ((x$max.not.shared -
x$min.not.shared) / ((2 *
> >>> x$shared) + x$sum.not.shared)) * (x$shared / (x$min.not.shared
+
> >>> x$shared))
> >>> beta.sor <- x$sum.not.shared / (2 * x$shared +
> >>> x$sum.not.shared)
> >>>
> >>> pairwise <- list(beta.sim=as.dist(beta.sim),
> >>> beta.sne=as.dist(beta.sne),beta.sor=as.dist(beta.sor))},
> >>> jaccard = {
> >>> beta.jtu <- (2*x$min.not.shared) /
((2*x$min.not.shared) +
> >>> x$shared)
> >>> beta.jne <- ((x$max.not.shared -
x$min.not.shared) /
> >>> (x$shared +
> >>> x$sum.not.shared)) * (x$shared / ((2*x$min.not.shared) +
x$shared))
> >>> beta.jac <- x$sum.not.shared / (x$shared +
x$sum.not.shared)
> >>>
> >>> pairwise <- list(beta.jtu=as.dist(beta.jtu),
> >>> beta.jne=as.dist(beta.jne),beta.jac=as.dist(beta.jac))})
> >>>
> >>> return(pairwise)
> >>>
> >>> }
> >>>
> >>> El 21/12/2015 a las 20:32, Carlos J. Gil Bellosta escribió:
> >>>
> >>>>
> >>>> Hola, ¿qué tal?
> >>>>
> >>>> Haz tres cosas:
> >>>>
> >>>> 1) Prueba con subconjuntos de tus datos más pequeños: 1k,
2k, etc. a ver
> >>>> si
> >>>> funciona.
> >>>> 2) Mientras tanto, vigila el uso de memoria de tu máquina.
En
> >>>> particular,
> >>>> los del proceso R.
> >>>> 3) Usa object.size para ver cuánto ocupan esos objetos que
vas creando.
> >>>>
> >>>> Con eso verás dónde están los límites. Puede que la
función beta.part no
> >>>> sea muy eficiente en términos de uso de la memoria. Los
objetos que
> >>>> estás
> >>>> creando deberían ocupar menos de 5GB.
> >>>>
> >>>> En un sistema operativo normal y moderno deberías poder
usar toda la RAM
> >>>> disponible. Usa (2) para ver cuánto come tu proceso de R.
> >>>>
> >>>> Un saludo,
> >>>>
> >>>> Carlos J. Gil Bellosta
> >>>> http://www.datanalytics.com
> >>>>
> >>>> El 21 de diciembre de 2015, 11:08, Ruben Bermad
<ruben_bm en hotmail.com>
> >>>> escribió:
> >>>>
> >>>> Hola a tod en s,
> >>>>> Soy nuevo en R-help-es, por lo que perdonadme si
debería haber mandado
> >>>>> este email a una sección en particular.
> >>>>> Quería consultaros un error que me aparece en R al
hacer una matriz de
> >>>>> disimilitud a partir de una tabla con 6000 columnas x
11000 filas. El
> >>>>> mensaje que da R es "cannot allocate vector of
size 10Gb", y me resulta
> >>>>> extraño ya que tengo 64 Gb de RAM disponible.
> >>>>> He estado leyendo en los foros y manuales de R que si
trabajo en una
> >>>>> máquina de 64 bits sea Windows o Linux R no debería de
tener un límite
> >>>>> para
> >>>>> ubicar un objeto, y que debería de usar toda la
memoria física y
> >>>>> virtual
> >>>>> disponible, pero creo que no está siendo así.
> >>>>> Por ello quisiera preguntaros si vosotros sabéis como
puedo ampliar la
> >>>>> memoria disponible (si este fuera de verdad el
problema) o cómo puedo
> >>>>> ubicar el vector en el disco y que no use la RAM.
> >>>>> En concreto estoy intentando usar la función
"beta.pair" del paquete
> >>>>> "betapart"
> >>>>>
(https://cran.r-project.org/web/packages/betapart/betapart.pdf)
> >>>>> sobre la matriz de 6000x11000. Es en este punto donde
R me da el
> >>>>> mensaje
> >>>>> de
> >>>>> error.
> >>>>> Después me gustaría ejecutar la función
"agnes" del paquete "cluster" o
> >>>>> la
> >>>>> función "hclust" del paquete
"stats" sobre dicha matriz de
> >>>>> disimilitud, y
> >>>>> supongo que tendré un problema similar.
> >>>>> El código exacto que he usado
es:library(betapart)data_base # Base de
> >>>>> datos de 6000 columnas x 11000 filasdistance <-
beta.pair (data_base,
> >>>>> index.family="sorensen") # Calculo de la
matriz de disimilitud
> >>>>> beta_similarity <- distance$beta.sim # Selecciono
el tipo de medida que
> >>>>> quiero
> >>>>> library(cluster)UPGMA<- agnes (beta_similarity ) #
Análisis UPGMA
> >>>>>
> >>>>> Soluciones que he intentado: Ante los problemas que he
tenido, he
> >>>>> intentado hacer la matriz de disimilitud en python. El
problema es que
> >>>>> no
> >>>>> hay una función optimizada para la medida de
disimilitud que quiero
> >>>>> estimar
> >>>>> (índice de simpson), y he tenido que escribir un
código para que haga
> >>>>> los
> >>>>> cálculos por pares, pero va a tardar más de 8 días (y
es un análisis
> >>>>> que
> >>>>> tengo que repetir muchas veces y no me parece muy
viable). Por ello
> >>>>> vuelvo
> >>>>> a R para intentar buscar una solución con el manejo de
esta gran base
> >>>>> de
> >>>>> datos.
> >>>>> Os agradecería cualquier tipo de ayuda.
> >>>>> Muchas gracias por adelantado,
> >>>>> Un cordial saludo, Rubén
> >>>>>
> >>>>>
> >>>>> [[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]]
> >>>>
> >>>> _______________________________________________
> >>>> R-help-es mailing list
> >>>> R-help-es en r-project.org
> >>>> https://stat.ethz.ch/mailman/listinfo/r-help-es
> >>>>
> >>>
> >>>
> >>> --
> >>> Dr Francisco Rodriguez-Sanchez
> >>> Integrative Ecology Group
> >>> Estacion Biologica de Doñana - CSIC
> >>> Avda. Americo Vespucio s/n
> >>> 41092 Sevilla (Spain)
> >>> http://bit.ly/frod_san
> >>>
> >>>
> >>> _______________________________________________
> >>> R-help-es mailing list
> >>> R-help-es en r-project.org
> >>> https://stat.ethz.ch/mailman/listinfo/r-help-es
> >>>
> >>
> >> _______________________________________________
> >> R-help-es mailing list
> >> R-help-es en r-project.org
> >> https://stat.ethz.ch/mailman/listinfo/r-help-es
> >>
> >>
> > _______________________________________________
> > 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]]
>
> _______________________________________________
> 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]]
Ummm, si tu idea es hacer un cluster jerárquico con esa cantidad de casos, me
parece que estás perdido. El,problema es que tenes que pasar por una matriz de
distancias.. y con el número de filas del cual partís, más matriz de distancias
es gigantesca. Aún cuando no tuvieras problemas de memoria, procesarla sería un
desfio en tiempo computacional. Para grandes volúmenes de datos tnes que pensar
en algoritmos de cluster como kmeans o cosas por el estilo. Si tu problema es
que queres usar una métrica distinta de la euclidiana, pensando, con un espacio
de dimensión 65000 dudo que haya mucha diferencia.
Enviado desde mi IPad
_____________________________
From: Ruben Bermad <ruben_bm en hotmail.com>
Sent: miércoles, diciembre 23, 2015 07:58
Subject: RE: [R-es] Cannot allocate vector of size
To: Julio Alejandro Di Rienzo <dirienzo.julio en gmail.com>, Marcelino de
la Cruz <marcelino.delacruz en upm.es>
Cc: r-help-es <r-help-es en r-project.org>
Antes de nada, me gustaría daros las gracias por toda vuestra ayuda.
He estado probando todo lo que me habéis dicho a la vez, y no hay
manera, sigo teniendo el problema con el espacio.
En cuanto al tamaño de la base de datos, es más grande de lo que
puse, me equivoqué y puse el tamaño de una base anterior con la que estuve
trabajando, la actual tiene 36866 filas x 6500 columnas.
He seguido todas vuestras recomendaciones (combinándolas) en
diferentes dispositivos y sistemas operativos, pero no hay manera. De hecho el
último intento fue haciendo los siguientes pasos en un sistema operativo Linux,
con R 64 bits y en un servidor con 65Gb de RAM.
1) He convertido la base de datos en una matriz "sparse"
cuyo tamaño pasa de una matriz de 861.2Mb a una matriz de 10.2Mb
2) He eliminado todo lo que no es necesario de la función beta.pair
dejándola en: library (betapart) # para que cargue la función
betapart.core()
beta.pair <- function(x, index.family="sorensen"){
# test for a valid index index.family
<- match.arg(index.family, c('jaccard','sorensen'))
# test for pre-existing betapart objects
if (! inherits(x, "betapart")){ x <-
betapart.core(x) }
# run the analysis given the index
switch(index.family, sorensen = {
beta.sim <- x$min.not.shared
pairwise <-
list(beta.sim=as.dist(beta.sim))},
jaccard = { beta.jtu <-
(x$min.not.shared)
pairwise <- list(beta.jtu=as.dist(beta.jtu) )})
return(pairwise) }
3) He ejecutado la función. matriz_distancias <-
beta.pair (sparse_matrix, index.family="sorensen")
Y tras todos estos pasos me sigue dando el problema. Creo que ya solo
me queda probar con los paquetes de R para gestión de Big Data como ff o
bigmemory.
¿Sabéis si las matrices que se guardan como bigmemory pueden
manipularse con las mismas funciones que el resto? En concreto quiero
saber si voy a poder calcular la matriz de distancias con beta.pair, y hacer un
análisis cluster tipo UPGMA sobre esa matriz (la función agnes () o hclust()).
Saludos, Rubén
> From: dirienzo.julio en gmail.com > Date: Tue, 22 Dec 2015 17:31:03 -0300
> To: marcelino.delacruz en upm.es
> CC: r-help-es en r-project.org
> Subject: Re: [R-es] Cannot allocate vector of size
>
> Si las matrices tiene gran cantidad de ceros, es posible reducir
> sustancialmente la memoria utilizada cambiando las matrices convencionales
> por matrices sparse (library(Matrix))
>
> Dr. Julio Di Rienzo
> Estadística y Biometría
> FCA- U.N. Córdoba
> http://sites.google.com/site/juliodirienzo
>
>
> El 22 de diciembre de 2015, 15:41, Marcelino de la Cruz <
> marcelino.delacruz en upm.es> escribió:
>
> > Yo creo que el problema principal está en betapart.core(), que crea y
> > mantiene simultáneamente en memoria varios objetos de alrededor de 1
Gb que
> > luego combina en una lista... Probablemente es entre las líneas el
código
> > de betaper.core donde hay que ir eliminando objetos.
> >
> > Saludos,
> >
> > Marcelino
> >
> >
> > El 22/12/2015 a las 18:26, Carlos J. Gil Bellosta escribió:
> >
> >> Hola, ¿qué tal?
> >>
> >> Yo no entré a comentar lo que hacen ni beta.pair ni betapart.core,
que
> >> es la función a la que esta llama. Pero tanto la una como la otra
> >> hacen puras operaciones de álgebra lineal (sobre todo
betapart.core).
> >> Esas operaciones deberían ser muy livianas en términos de uso de
> >> memoria. El objeto resultante no deberia ocupar más de 1GB (una
matriz
> >> 11k x 11k).
> >>
> >> Así que si conviertes tus datos de entrada a matriz (en lugar de
DF),
> >> borras el DF y haces un gc() (para borrar el objeto grande
enseguida)
> >> y operas con con esa matriz, es fácil que no tengas problemas. ¡No
> >> deberías tenerlos!
> >>
> >> Un saludo,
> >>
> >> Carlos J. Gil Bellosta
> >> http:///www.datanalytics.com
> >>
> >>
> >>
> >>
> >>
> >>
> >> El día 22 de diciembre de 2015, 11:25, Francisco Rodriguez Sanchez
> >> <f.rodriguez.sanc en gmail.com> escribió:
> >>
> >>> Hola Rubén,
> >>>
> >>> Totalmente de acuerdo con los consejos de Carlos. Ten en
cuenta que
> >>> aunque R
> >>> disponga de varios (bastantes) GB de memoria, algunos de los
objetos que
> >>> va
> >>> creando durante el proceso pueden consumirla por completo. Es
decir, que
> >>> aunque tu ordenador tenga 64GB de RAM, es posible que no
queden 10 GB
> >>> libres
> >>> para almacenar un objeto (porque ya hay demasiados objetos
grandes en la
> >>> memoria).
> >>>
> >>> Sinceramente, más que intentar implementar los análisis en
python 'de
> >>> novo',
> >>> creo que lo mejor es optimizar el código de R para evitar
consumir toda
> >>> la
> >>> memoria. Por ejemplo, si miras el código de la función
beta.pair del
> >>> paquete
> >>> betapart (pegado más abajo), verás que crea 3 objetos
(beta.sim,
> >>> beta.sne, y
> >>> beta.sor) que probablemente son muy grandes. Y luego los
convierte a cada
> >>> uno en matriz de distancias (as.dist). En estas operaciones se
te va la
> >>> memoria, pues todos estos objetos están almacenados ahí.
> >>>
> >>> Por tanto, una solución fácil sería calcular cada una de estas
cosas de
> >>> una
> >>> en una, y acto seguido almacenarla en disco y reiniciar R (o
gestionar la
> >>> memoria, con gc, etc, mira
http://adv-r.had.co.nz/memory.html). Cuando
> >>> ya lo
> >>> tengas todo en disco puedes ir cargando objetos conforme los
vayas
> >>> necesitando. Si son demasiado grandes para leerlos, puedes
usar el
> >>> paquete
> >>> ff y similares. Un manual muy bueno para big data en R:
> >>> https://github.com/Robinlovelace/R-for-Big-Data.
> >>>
> >>> Así pues, desgranando y ejecutando una a unas las operaciones
que
> >>> ejecuta la
> >>> función beta.pair, creo que puedes solucionar tu problema. O
al menos eso
> >>> espero!
> >>>
> >>> Mucha suerte
> >>>
> >>> Paco
> >>>
> >>>
> >>>
> >>> beta.pair <- function(x,
index.family="sorensen"){
> >>>
> >>> # test for a valid index
> >>> index.family <- match.arg(index.family,
c('jaccard','sorensen'))
> >>>
> >>> # test for pre-existing betapart objects
> >>> if (! inherits(x, "betapart")){
> >>> x <- betapart.core(x)
> >>> }
> >>>
> >>> # run the analysis given the index
> >>> switch(index.family,
> >>> sorensen = {
> >>> beta.sim <- x$min.not.shared / (x$min.not.shared +
x$shared)
> >>> beta.sne <- ((x$max.not.shared - x$min.not.shared) / ((2 *
> >>> x$shared) + x$sum.not.shared)) * (x$shared / (x$min.not.shared
+
> >>> x$shared))
> >>> beta.sor <- x$sum.not.shared / (2 * x$shared +
> >>> x$sum.not.shared)
> >>>
> >>> pairwise <- list(beta.sim=as.dist(beta.sim),
> >>> beta.sne=as.dist(beta.sne),beta.sor=as.dist(beta.sor))},
> >>> jaccard = {
> >>> beta.jtu <- (2*x$min.not.shared) / ((2*x$min.not.shared) +
> >>> x$shared)
> >>> beta.jne <- ((x$max.not.shared - x$min.not.shared) /
> >>> (x$shared +
> >>> x$sum.not.shared)) * (x$shared / ((2*x$min.not.shared) +
x$shared))
> >>> beta.jac <- x$sum.not.shared / (x$shared +
x$sum.not.shared)
> >>>
> >>> pairwise <- list(beta.jtu=as.dist(beta.jtu),
> >>> beta.jne=as.dist(beta.jne),beta.jac=as.dist(beta.jac))})
> >>>
> >>> return(pairwise)
> >>>
> >>> }
> >>>
> >>> El 21/12/2015 a las 20:32, Carlos J. Gil Bellosta escribió:
> >>>
> >>>>
> >>>> Hola, ¿qué tal?
> >>>>
> >>>> Haz tres cosas:
> >>>>
> >>>> 1) Prueba con subconjuntos de tus datos más pequeños: 1k,
2k, etc. a ver
> >>>> si
> >>>> funciona.
> >>>> 2) Mientras tanto, vigila el uso de memoria de tu máquina.
En
> >>>> particular,
> >>>> los del proceso R.
> >>>> 3) Usa object.size para ver cuánto ocupan esos objetos que
vas creando.
> >>>>
> >>>> Con eso verás dónde están los límites. Puede que la
función beta.part no
> >>>> sea muy eficiente en términos de uso de la memoria. Los
objetos que
> >>>> estás
> >>>> creando deberían ocupar menos de 5GB.
> >>>>
> >>>> En un sistema operativo normal y moderno deberías poder
usar toda la RAM
> >>>> disponible. Usa (2) para ver cuánto come tu proceso de R.
> >>>>
> >>>> Un saludo,
> >>>>
> >>>> Carlos J. Gil Bellosta
> >>>> http://www.datanalytics.com
> >>>>
> >>>> El 21 de diciembre de 2015, 11:08, Ruben Bermad
<ruben_bm en hotmail.com>
> >>>> escribió:
> >>>>
> >>>> Hola a tod en s,
> >>>>> Soy nuevo en R-help-es, por lo que perdonadme si
debería haber mandado
> >>>>> este email a una sección en particular.
> >>>>> Quería consultaros un error que me aparece en R al
hacer una matriz de
> >>>>> disimilitud a partir de una tabla con 6000 columnas x
11000 filas. El
> >>>>> mensaje que da R es "cannot allocate vector of
size 10Gb", y me resulta
> >>>>> extraño ya que tengo 64 Gb de RAM disponible.
> >>>>> He estado leyendo en los foros y manuales de R que si
trabajo en una
> >>>>> máquina de 64 bits sea Windows o Linux R no debería de
tener un límite
> >>>>> para
> >>>>> ubicar un objeto, y que debería de usar toda la
memoria física y
> >>>>> virtual
> >>>>> disponible, pero creo que no está siendo así.
> >>>>> Por ello quisiera preguntaros si vosotros sabéis como
puedo ampliar la
> >>>>> memoria disponible (si este fuera de verdad el
problema) o cómo puedo
> >>>>> ubicar el vector en el disco y que no use la RAM.
> >>>>> En concreto estoy intentando usar la función
"beta.pair" del paquete
> >>>>> "betapart"
> >>>>>
(https://cran.r-project.org/web/packages/betapart/betapart.pdf)
> >>>>> sobre la matriz de 6000x11000. Es en este punto donde
R me da el
> >>>>> mensaje
> >>>>> de
> >>>>> error.
> >>>>> Después me gustaría ejecutar la función
"agnes" del paquete "cluster" o
> >>>>> la
> >>>>> función "hclust" del paquete
"stats" sobre dicha matriz de
> >>>>> disimilitud, y
> >>>>> supongo que tendré un problema similar.
> >>>>> El código exacto que he usado
es:library(betapart)data_base # Base de
> >>>>> datos de 6000 columnas x 11000 filasdistance <-
beta.pair (data_base,
> >>>>> index.family="sorensen") # Calculo de la
matriz de disimilitud
> >>>>> beta_similarity <- distance$beta.sim # Selecciono
el tipo de medida que
> >>>>> quiero
> >>>>> library(cluster)UPGMA<- agnes (beta_similarity ) #
Análisis UPGMA
> >>>>>
> >>>>> Soluciones que he intentado: Ante los problemas que he
tenido, he
> >>>>> intentado hacer la matriz de disimilitud en python. El
problema es que
> >>>>> no
> >>>>> hay una función optimizada para la medida de
disimilitud que quiero
> >>>>> estimar
> >>>>> (índice de simpson), y he tenido que escribir un
código para que haga
> >>>>> los
> >>>>> cálculos por pares, pero va a tardar más de 8 días (y
es un análisis
> >>>>> que
> >>>>> tengo que repetir muchas veces y no me parece muy
viable). Por ello
> >>>>> vuelvo
> >>>>> a R para intentar buscar una solución con el manejo de
esta gran base
> >>>>> de
> >>>>> datos.
> >>>>> Os agradecería cualquier tipo de ayuda.
> >>>>> Muchas gracias por adelantado,
> >>>>> Un cordial saludo, Rubén
> >>>>>
> >>>>>
> >>>>> [[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]]
> >>>>
> >>>> _______________________________________________
> >>>> R-help-es mailing list
> >>>> R-help-es en r-project.org
> >>>> https://stat.ethz.ch/mailman/listinfo/r-help-es
> >>>>
> >>>
> >>>
> >>> --
> >>> Dr Francisco Rodriguez-Sanchez
> >>> Integrative Ecology Group
> >>> Estacion Biologica de Doñana - CSIC
> >>> Avda. Americo Vespucio s/n
> >>> 41092 Sevilla (Spain)
> >>> http://bit.ly/frod_san
> >>>
> >>>
> >>> _______________________________________________
> >>> R-help-es mailing list
> >>> R-help-es en r-project.org
> >>> https://stat.ethz.ch/mailman/listinfo/r-help-es
> >>>
> >>
> >> _______________________________________________
> >> R-help-es mailing list
> >> R-help-es en r-project.org
> >> https://stat.ethz.ch/mailman/listinfo/r-help-es
> >>
> >>
> > _______________________________________________
> > 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]]
>
> _______________________________________________
> 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]]
Prueba esto:
beta.pair <- function(x){
betapart.core(x)$min.not.shared
}
tmp <- beta.pair(x)
gc()
my.dist <- as.dist(tmp)
He quitado en beta.pair todo lo que está de más. ¡De hecho, la he
dejado en nada! Aun así, betapart.core hace cálculos que no necesitas
y puede que necesites una versión simplificada de ella. He visto que
el cuello de botella en términos de memoria está principalmente en el
as.dist. Por eso lo he sacado de la función. Igual funciona el
beta.pair y no el as.dist. Mira a ver.
He intercalado un gc() para tratar de vaciar la memoria después de la
llamada a beta.pair y betapart.core, por ver si ayuda. Ambas funciones
crean objetos (demasiados) muy grandes (demasiado también).
Cuando ejecutes eso, trata de tener la memoria vacía (salvo por tu
matriz de entrada). ¡Y que sea una matriz!
Un saludo,
Carlos J. Gil Bellosta
http://www.datanalytics.com
El día 23 de diciembre de 2015, 12:11, Julio Alejandro Di Rienzo
<dirienzo.julio en gmail.com> escribió:> Ummm, si tu idea es hacer un cluster jerárquico con esa cantidad de casos,
me parece que estás perdido. El,problema es que tenes que pasar por una matriz
de distancias.. y con el número de filas del cual partís, más matriz de
distancias es gigantesca. Aún cuando no tuvieras problemas de memoria,
procesarla sería un desfio en tiempo computacional. Para grandes volúmenes de
datos tnes que pensar en algoritmos de cluster como kmeans o cosas por el
estilo. Si tu problema es que queres usar una métrica distinta de la euclidiana,
pensando, con un espacio de dimensión 65000 dudo que haya mucha diferencia.
>
> Enviado desde mi IPad
>
> _____________________________
> From: Ruben Bermad <ruben_bm en hotmail.com>
> Sent: miércoles, diciembre 23, 2015 07:58
> Subject: RE: [R-es] Cannot allocate vector of size
> To: Julio Alejandro Di Rienzo <dirienzo.julio en gmail.com>,
Marcelino de la Cruz <marcelino.delacruz en upm.es>
> Cc: r-help-es <r-help-es en r-project.org>
>
>
> Antes de nada, me gustaría daros las gracias por toda vuestra
ayuda.
> He estado probando todo lo que me habéis dicho a la vez, y no hay
manera, sigo teniendo el problema con el espacio.
> En cuanto al tamaño de la base de datos, es más grande de lo
que puse, me equivoqué y puse el tamaño de una base anterior con la que estuve
trabajando, la actual tiene 36866 filas x 6500 columnas.
> He seguido todas vuestras recomendaciones (combinándolas) en
diferentes dispositivos y sistemas operativos, pero no hay manera. De hecho el
último intento fue haciendo los siguientes pasos en un sistema operativo Linux,
con R 64 bits y en un servidor con 65Gb de RAM.
> 1) He convertido la base de datos en una matriz
"sparse" cuyo tamaño pasa de una matriz de 861.2Mb a una matriz de
10.2Mb
> 2) He eliminado todo lo que no es necesario de la función
beta.pair dejándola en: library (betapart) # para que cargue
la función betapart.core()
> beta.pair <- function(x,
index.family="sorensen"){ # test
for a valid index index.family <- match.arg(index.family,
c('jaccard','sorensen'))
# test for pre-existing betapart objects if (! inherits(x,
"betapart")){ x <- betapart.core(x)
} # run the analysis given the index
switch(index.family, sorensen = {
beta.sim <- x$min.not.shared
pairwise <- list(beta.sim=as.dist(beta.sim))},
jaccard = { beta.jtu <- (x$min.not.shared)
pairwise <- list(beta.jtu=as.dist(beta.jtu) )})
return(pairwise) }
> 3) He ejecutado la función. matriz_distancias
<- beta.pair (sparse_matrix, index.family="sorensen")
> Y tras todos estos pasos me sigue dando el problema. Creo que ya
solo me queda probar con los paquetes de R para gestión de Big Data como ff o
bigmemory.
> ¿Sabéis si las matrices que se guardan como bigmemory pueden
manipularse con las mismas funciones que el resto? En concreto quiero
saber si voy a poder calcular la matriz de distancias con beta.pair, y hacer un
análisis cluster tipo UPGMA sobre esa matriz (la función agnes () o hclust()).
> Saludos, Rubén
>
> > From: dirienzo.julio en gmail.com
>> Date: Tue, 22 Dec 2015 17:31:03 -0300
>> To: marcelino.delacruz en upm.es
>> CC: r-help-es en r-project.org
>> Subject: Re: [R-es] Cannot allocate vector of size
>>
>> Si las matrices tiene gran cantidad de ceros, es posible reducir
>> sustancialmente la memoria utilizada cambiando las matrices
convencionales
>> por matrices sparse (library(Matrix))
>>
>> Dr. Julio Di Rienzo
>> Estadística y Biometría
>> FCA- U.N. Córdoba
>> http://sites.google.com/site/juliodirienzo
>>
>>
>> El 22 de diciembre de 2015, 15:41, Marcelino de la Cruz <
>> marcelino.delacruz en upm.es> escribió:
>>
>> > Yo creo que el problema principal está en betapart.core(), que
crea y
>> > mantiene simultáneamente en memoria varios objetos de alrededor de
1 Gb que
>> > luego combina en una lista... Probablemente es entre las líneas el
código
>> > de betaper.core donde hay que ir eliminando objetos.
>> >
>> > Saludos,
>> >
>> > Marcelino
>> >
>> >
>> > El 22/12/2015 a las 18:26, Carlos J. Gil Bellosta escribió:
>> >
>> >> Hola, ¿qué tal?
>> >>
>> >> Yo no entré a comentar lo que hacen ni beta.pair ni
betapart.core, que
>> >> es la función a la que esta llama. Pero tanto la una como la
otra
>> >> hacen puras operaciones de álgebra lineal (sobre todo
betapart.core).
>> >> Esas operaciones deberían ser muy livianas en términos de uso
de
>> >> memoria. El objeto resultante no deberia ocupar más de 1GB
(una matriz
>> >> 11k x 11k).
>> >>
>> >> Así que si conviertes tus datos de entrada a matriz (en lugar
de DF),
>> >> borras el DF y haces un gc() (para borrar el objeto grande
enseguida)
>> >> y operas con con esa matriz, es fácil que no tengas problemas.
¡No
>> >> deberías tenerlos!
>> >>
>> >> Un saludo,
>> >>
>> >> Carlos J. Gil Bellosta
>> >> http:///www.datanalytics.com
>> >>
>> >>
>> >>
>> >>
>> >>
>> >>
>> >> El día 22 de diciembre de 2015, 11:25, Francisco Rodriguez
Sanchez
>> >> <f.rodriguez.sanc en gmail.com> escribió:
>> >>
>> >>> Hola Rubén,
>> >>>
>> >>> Totalmente de acuerdo con los consejos de Carlos. Ten en
cuenta que
>> >>> aunque R
>> >>> disponga de varios (bastantes) GB de memoria, algunos de
los objetos que
>> >>> va
>> >>> creando durante el proceso pueden consumirla por completo.
Es decir, que
>> >>> aunque tu ordenador tenga 64GB de RAM, es posible que no
queden 10 GB
>> >>> libres
>> >>> para almacenar un objeto (porque ya hay demasiados objetos
grandes en la
>> >>> memoria).
>> >>>
>> >>> Sinceramente, más que intentar implementar los análisis en
python 'de
>> >>> novo',
>> >>> creo que lo mejor es optimizar el código de R para evitar
consumir toda
>> >>> la
>> >>> memoria. Por ejemplo, si miras el código de la función
beta.pair del
>> >>> paquete
>> >>> betapart (pegado más abajo), verás que crea 3 objetos
(beta.sim,
>> >>> beta.sne, y
>> >>> beta.sor) que probablemente son muy grandes. Y luego los
convierte a cada
>> >>> uno en matriz de distancias (as.dist). En estas
operaciones se te va la
>> >>> memoria, pues todos estos objetos están almacenados ahí.
>> >>>
>> >>> Por tanto, una solución fácil sería calcular cada una de
estas cosas de
>> >>> una
>> >>> en una, y acto seguido almacenarla en disco y reiniciar R
(o gestionar la
>> >>> memoria, con gc, etc, mira
http://adv-r.had.co.nz/memory.html). Cuando
>> >>> ya lo
>> >>> tengas todo en disco puedes ir cargando objetos conforme
los vayas
>> >>> necesitando. Si son demasiado grandes para leerlos, puedes
usar el
>> >>> paquete
>> >>> ff y similares. Un manual muy bueno para big data en R:
>> >>> https://github.com/Robinlovelace/R-for-Big-Data.
>> >>>
>> >>> Así pues, desgranando y ejecutando una a unas las
operaciones que
>> >>> ejecuta la
>> >>> función beta.pair, creo que puedes solucionar tu problema.
O al menos eso
>> >>> espero!
>> >>>
>> >>> Mucha suerte
>> >>>
>> >>> Paco
>> >>>
>> >>>
>> >>>
>> >>> beta.pair <- function(x,
index.family="sorensen"){
>> >>>
>> >>> # test for a valid index
>> >>> index.family <- match.arg(index.family,
c('jaccard','sorensen'))
>> >>>
>> >>> # test for pre-existing betapart objects
>> >>> if (! inherits(x, "betapart")){
>> >>> x <- betapart.core(x)
>> >>> }
>> >>>
>> >>> # run the analysis given the index
>> >>> switch(index.family,
>> >>> sorensen = {
>> >>> beta.sim <- x$min.not.shared / (x$min.not.shared +
x$shared)
>> >>> beta.sne <- ((x$max.not.shared - x$min.not.shared) /
((2 *
>> >>> x$shared) + x$sum.not.shared)) * (x$shared /
(x$min.not.shared +
>> >>> x$shared))
>> >>> beta.sor <- x$sum.not.shared / (2 * x$shared +
>> >>> x$sum.not.shared)
>> >>>
>> >>> pairwise <- list(beta.sim=as.dist(beta.sim),
>> >>> beta.sne=as.dist(beta.sne),beta.sor=as.dist(beta.sor))},
>> >>> jaccard = {
>> >>> beta.jtu <- (2*x$min.not.shared) /
((2*x$min.not.shared) +
>> >>> x$shared)
>> >>> beta.jne <- ((x$max.not.shared - x$min.not.shared) /
>> >>> (x$shared +
>> >>> x$sum.not.shared)) * (x$shared / ((2*x$min.not.shared) +
x$shared))
>> >>> beta.jac <- x$sum.not.shared / (x$shared +
x$sum.not.shared)
>> >>>
>> >>> pairwise <- list(beta.jtu=as.dist(beta.jtu),
>> >>> beta.jne=as.dist(beta.jne),beta.jac=as.dist(beta.jac))})
>> >>>
>> >>> return(pairwise)
>> >>>
>> >>> }
>> >>>
>> >>> El 21/12/2015 a las 20:32, Carlos J. Gil Bellosta
escribió:
>> >>>
>> >>>>
>> >>>> Hola, ¿qué tal?
>> >>>>
>> >>>> Haz tres cosas:
>> >>>>
>> >>>> 1) Prueba con subconjuntos de tus datos más pequeños:
1k, 2k, etc. a ver
>> >>>> si
>> >>>> funciona.
>> >>>> 2) Mientras tanto, vigila el uso de memoria de tu
máquina. En
>> >>>> particular,
>> >>>> los del proceso R.
>> >>>> 3) Usa object.size para ver cuánto ocupan esos objetos
que vas creando.
>> >>>>
>> >>>> Con eso verás dónde están los límites. Puede que la
función beta.part no
>> >>>> sea muy eficiente en términos de uso de la memoria.
Los objetos que
>> >>>> estás
>> >>>> creando deberían ocupar menos de 5GB.
>> >>>>
>> >>>> En un sistema operativo normal y moderno deberías
poder usar toda la RAM
>> >>>> disponible. Usa (2) para ver cuánto come tu proceso de
R.
>> >>>>
>> >>>> Un saludo,
>> >>>>
>> >>>> Carlos J. Gil Bellosta
>> >>>> http://www.datanalytics.com
>> >>>>
>> >>>> El 21 de diciembre de 2015, 11:08, Ruben Bermad
<ruben_bm en hotmail.com>
>> >>>> escribió:
>> >>>>
>> >>>> Hola a tod en s,
>> >>>>> Soy nuevo en R-help-es, por lo que perdonadme si
debería haber mandado
>> >>>>> este email a una sección en particular.
>> >>>>> Quería consultaros un error que me aparece en R al
hacer una matriz de
>> >>>>> disimilitud a partir de una tabla con 6000
columnas x 11000 filas. El
>> >>>>> mensaje que da R es "cannot allocate vector
of size 10Gb", y me resulta
>> >>>>> extraño ya que tengo 64 Gb de RAM disponible.
>> >>>>> He estado leyendo en los foros y manuales de R que
si trabajo en una
>> >>>>> máquina de 64 bits sea Windows o Linux R no
debería de tener un límite
>> >>>>> para
>> >>>>> ubicar un objeto, y que debería de usar toda la
memoria física y
>> >>>>> virtual
>> >>>>> disponible, pero creo que no está siendo así.
>> >>>>> Por ello quisiera preguntaros si vosotros sabéis
como puedo ampliar la
>> >>>>> memoria disponible (si este fuera de verdad el
problema) o cómo puedo
>> >>>>> ubicar el vector en el disco y que no use la RAM.
>> >>>>> En concreto estoy intentando usar la función
"beta.pair" del paquete
>> >>>>> "betapart"
>> >>>>>
(https://cran.r-project.org/web/packages/betapart/betapart.pdf)
>> >>>>> sobre la matriz de 6000x11000. Es en este punto
donde R me da el
>> >>>>> mensaje
>> >>>>> de
>> >>>>> error.
>> >>>>> Después me gustaría ejecutar la función
"agnes" del paquete "cluster" o
>> >>>>> la
>> >>>>> función "hclust" del paquete
"stats" sobre dicha matriz de
>> >>>>> disimilitud, y
>> >>>>> supongo que tendré un problema similar.
>> >>>>> El código exacto que he usado
es:library(betapart)data_base # Base de
>> >>>>> datos de 6000 columnas x 11000 filasdistance <-
beta.pair (data_base,
>> >>>>> index.family="sorensen") # Calculo de la
matriz de disimilitud
>> >>>>> beta_similarity <- distance$beta.sim #
Selecciono el tipo de medida que
>> >>>>> quiero
>> >>>>> library(cluster)UPGMA<- agnes (beta_similarity
) # Análisis UPGMA
>> >>>>>
>> >>>>> Soluciones que he intentado: Ante los problemas
que he tenido, he
>> >>>>> intentado hacer la matriz de disimilitud en
python. El problema es que
>> >>>>> no
>> >>>>> hay una función optimizada para la medida de
disimilitud que quiero
>> >>>>> estimar
>> >>>>> (índice de simpson), y he tenido que escribir un
código para que haga
>> >>>>> los
>> >>>>> cálculos por pares, pero va a tardar más de 8 días
(y es un análisis
>> >>>>> que
>> >>>>> tengo que repetir muchas veces y no me parece muy
viable). Por ello
>> >>>>> vuelvo
>> >>>>> a R para intentar buscar una solución con el
manejo de esta gran base
>> >>>>> de
>> >>>>> datos.
>> >>>>> Os agradecería cualquier tipo de ayuda.
>> >>>>> Muchas gracias por adelantado,
>> >>>>> Un cordial saludo, Rubén
>> >>>>>
>> >>>>>
>> >>>>> [[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]]
>> >>>>
>> >>>> _______________________________________________
>> >>>> R-help-es mailing list
>> >>>> R-help-es en r-project.org
>> >>>> https://stat.ethz.ch/mailman/listinfo/r-help-es
>> >>>>
>> >>>
>> >>>
>> >>> --
>> >>> Dr Francisco Rodriguez-Sanchez
>> >>> Integrative Ecology Group
>> >>> Estacion Biologica de Doñana - CSIC
>> >>> Avda. Americo Vespucio s/n
>> >>> 41092 Sevilla (Spain)
>> >>> http://bit.ly/frod_san
>> >>>
>> >>>
>> >>> _______________________________________________
>> >>> R-help-es mailing list
>> >>> R-help-es en r-project.org
>> >>> https://stat.ethz.ch/mailman/listinfo/r-help-es
>> >>>
>> >>
>> >> _______________________________________________
>> >> R-help-es mailing list
>> >> R-help-es en r-project.org
>> >> https://stat.ethz.ch/mailman/listinfo/r-help-es
>> >>
>> >>
>> > _______________________________________________
>> > 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]]
>>
>> _______________________________________________
>> 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]]
>
> _______________________________________________
> R-help-es mailing list
> R-help-es en r-project.org
> https://stat.ethz.ch/mailman/listinfo/r-help-es