R

Hace ya unos meses hablé de cómo había unos cuantos proyectos relacionados con R en el Google Summer of Code 2010. Recientemente se ha publicado un pequeño resumen de los logros alcanzados:

• De las quince propuestas originales, arrancaron cinco.
• De las cinco, cuatro llegaron a buen término.
• Lamentablemente, el —tal vez— más interesante de ellos, la implementación de un interfaz de R análogo a DBI para bases de datos no relacionales (NoSQL), acabó en nada.

Me consta que este blog lo lee mucha gente relacionada con la universidad. ¿Será que el año que viene tendremos alguna propuesta de España, Colombia, Argentina…?

[Nota: esta entrada está totalmente desactualizada y la mantengo en en blog por una mezcla de sentimentalismo y fidelidad a la “memoria histórica”; el interesado en cómo interconectar R y C (o C++) hoy hará bien en buscar en otra parte.]

Esta entrada que ahora hago es un pequeño tutorial que publiqué en mi primera página de internet a principios de siglo, cuando todavía usaba Windows regularmente. Es posible que gran parte de lo que en ella cuente esté ya mandado a recoger. No obstante, tampoco hace tanto, eché mano de lo que en ella había dejado escrito para ver cómo migrar a Windows algo que había hecho en Linux y… todavía funcionó.

Hace poco recibí noticia de la creación de un grupo de usuarios de R en Brisbane, que no deja de ser una ciudad chiquita en un país poblacionalmente chiquito. ¡Y es ya el cuarto en Australia!

Miro también el siguiente gráfico y me da algo de grima:

¡No hay ni un sólo cerca de Madrid (que es la ubicación que a mí y ahora más me compete)! Así que si alguno de mis lectores está interesado en el asunto, podemos ir urdiendo cómo hacer para colocarle un pinchico rojo a ese mapa justo en Sol.

La próxima reunión anual de usuarios de R tendrá lugar del 16 al 18 de agosto de 2011 en la Universidad de Warwick, Inglaterra.

Los conferenciantes invitados de este año van a ser Adrian Bowman, Lee Edlefsen, Ulrike Grömping, Wolfgang Huber, Brian Ripley, Jonathan Rougier, Simon Urbanek y Brandon Whitcher.

Los usuarios de R están invitados a preparar charlas y presentar pósters ilustrando el uso de R.

¿Cuándo tocará en España? (Ramón Díaz Uriarte, que forma parte del comité organizador, me ha confirmado en comunicación personal que tardará, que hay una larga lista de candidatos a alojarlas y que vamos a tener que  esperar todavía, me temo).

Últimamente me están llegando conjuntos de datos para analizar con muy pocos registros. He aquí un subconjunto de uno de ellos (de hoy y debidamente anonimizado):

nivel.proteina <- c( 11.56, 10.43, 11.00, 10.92, 10.08, 9.98, 10.35,
  9.55, 9.19, 7.00, 6.72, 6.43, 7.43, 7.26, 6.67,  7.49, 8.03, 8.17,
  6.79, 7.68, 7.01, 7.51, 6.90, 7.27, 7.56, 8.61, 8.16, 7.12 )
grupo <- c(0,0,0,0,0,0,0,0,0,
  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1)
datos <- data.frame( nivel.proteina, grupo )

Le he estado dando vueltas a la manera de representar gráficamente este tipo de conjunto de datos de la manera en que deben hacerse estas cosas: que con un mero golpe de vista pueda hacerse uno con ellos.

Si el otro día anuncié la próxima integración de RapidMiner con R, hoy quiero dar a conocer un vídeo en la que se ilustra:

Tiene buena pinta, la verdad.

El otro día dejé planteada una tarea para mis lectores (que han sido menos diligentes que yo, incluso). Trataba de una comparación entre varios métodos para acceder a diccionarios (o hashes) de datos desde R para tratar de identificar el más eficiente en términos de velocidad de acceso.

Acá van los resultados:

n <- 100000
dat <- data.frame( id = paste( "id", 1:n, sep = "_" ),
    valor = rnorm( n ), stringsAsFactors = F )

n.sample <- 20000
seleccion <- sample( dat$id, n.sample )

### Con vectores:
system.time( res <- sapply( seleccion,
    function( x ) dat$valor[ dat$id == seleccion ] ) )

#  user  system elapsed
# 84.79    5.24   90.14

### Con listas:
mi.lista <- sapply( dat$valor, I, simplify = F )
names( mi.lista ) <- dat$id
system.time( res <- sapply( seleccion, function( x ) mi.lista[[x]] ) )

#  user  system elapsed
# 19.15    0.00   19.20

### Con entornos:
mi.entorno.0 <- new.env()
invisible( sapply( 1:n, function(i)
  assign( dat$id[i], dat$valor[i], env = mi.entorno.0 ) ) )
system.time( res <- sapply( seleccion, function( x ) mi.entorno.0[[x]] ) )

#  user  system elapsed
# 67.89    0.03   68.06

### Con el paquete data.table:
require( data.table )
tmp.dat <- dat
tmp.dat$id <- factor( tmp.dat$id )
mi.data.table <- data.table( tmp.dat )
setkey( mi.data.table, id )
system.time( res <- sapply( seleccion,
  function( x ) mi.data.table[ J(x) ]$valor ) )

#   user  system elapsed
# 371.07   25.91  400.39

### Con hashes:
mi.entorno.1 <- new.env( hash = T )
invisible( sapply( 1:n, function(i)
  assign( dat$id[i], dat$valor[i], env = mi.entorno.1 ) ) )
system.time( res <- sapply( seleccion,
    function( x ) mi.entorno.1[[x]] ) )

#  user  system elapsed
#  0.14    0.00    0.14

Los números son tan concluyentes que me excusan de la necesidad de ofrecer explicaciones y distingos. Aunque para que mis lectores no tengan que ir subiendo y bajando por la entrada para realizar comparaciones, los resumo en un gráfico:

Como nunca conseguí ver el vídeo de la conferencia que di en las I Jornadas de Usuarios de R en noviembre del 2009 directamente desde los servidores de la Universidad de Murcia, lo he subido a DailyMotion. Los 60 minutos de la conferencia están partidos en tres partes que pueden verse consecutivamente aquí.

Nota: al final de cada parte aparece un enlace para continuar a la siguiente.

Un banco que gana mucho dinero quiso gastarse un nada desdeñable pellizco de sus ingresos contratando a unos consultores muy resabidos de un país extranjero donde, es fama, todos saben mucho. El resultado fue una documentación ininteligible y un larguísimo programa en VB sin apenas comentarios que se demoraba horas en realizar una simulación trivial.

El banco, cansado de quemar ciclos de CPU en vano, encargó a una consultora local la reimplementación del algoritmo en un afamado paquete estadístico. A falta de documentación, la reimplementación hubo de hacerse tratando de adivinar qué demonios hacía el código original. Prácticamente, fue un proceso de ingeniería inversa.

Tengo acceso a una máquina que, aunque anda un poco corta de memoria, cuenta con ocho CPUs. Tenía unas simulaciones bastante pesadas que correr y quise aprovechar su naturaleza perfectamente paralelizable. Y, de paso, hacer con R lo mismo por lo que he visto a un consultor de SAS cobrar a razón de 3.000 dólares diarios.

En el fondo, es una trivialidad. Supongamos que la función que implementa la simulación se llama foo. Habitualmente, haríamos