[R-es] Cannot allocate vector of size
Ruben Bermad
ruben_bm en hotmail.com
Mie Dic 23 11:58:15 CET 2015
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]]
Más información sobre la lista de distribución R-help-es