Spark

Trabajar con Spark usando Scala implica renunciar a ese paraíso que son las funciones melt y (d)cast de reshape2.

¿O no?

import org.apache.spark.sql.types.StructField;
import org.apache.spark.sql.types.StructType;
import org.apache.spark.sql.types.StringType;
import org.apache.spark.sql.types.DoubleType;
import org.apache.spark.sql.Row;

/** Create some data **/

val nrows = 20
val origDF = sc.parallelize(1.to(nrows).map(x => (x, math.pow(x,2), math.pow(x,3)))).toDF("id", "cuadrado", "cubo")

/** Melt **/

val ids  = Map("id" -> 0)
val cols = Map("cuadrado" -> 1, "cubo" -> 2)

def melt(x:Row, ids:Map[String, Int] , cols:Map[String, Int]) = {
        var tmp = ids.mapValues(y => x(y))
        for((k,v) <- cols) yield tmp + ("var" -> k, "value" -> x(v))
}

val df = origDF.flatMap(x => melt(x, ids, cols))

val newStructure = StructType( ids.values.map(x => origDF.schema(x)).toList ::: List(StructField("var", StringType), StructField("value", DoubleType)) )
val meltDF = sqlContext.applySchema(df.map(x => Row.fromSeq(x.values.toList)), newStructure)

/** cast **/

val castDF = meltDF.groupBy("id").pivot("var").sum("value")

En el Meetup de hoy me he enterado de que mis colegas de ASPgems están organizando un curso de Spark. Y no por colegas sino por competentes, lo divulgo por aquí.

La información al respecto, aquí.

Advertencia: El curso no es gratuito y ASPgems me ha invitado a dos cervezas a la salida del Meetup de hoy. Pero, tranquilos, mi precio no es ese.

He instalado Spark 1.4 recientemente y he comenzado a cacharrear. Antes de nada, quiero cargar datos.

Advierto que ha cambiado sustancialmente la API de SparkR. Entre otras novedades, desapareció (o más bien, se escondió) la función textFile, que permitía leer ficheros línea a línea. Ahora está pero no se exporta. La verás solo si haces SparkR:::textFile. ¿Signo de deprecación?

Se pueden crear un DataFrame (tablas distribuidas de Spark) a partir de un data.frame de R:

El anuncio de la liberación de la versión 1.4 de Spark se ha materializado. Está aquí.

¿Qué trae de novedad la versión 1.4? La integración con SparkR —antes había que instalarlo con algo de dolor independientemente— y, aparentemente, data.frames distribuidos y, cuentan, una sintaxis similar a la de dplyr —honestamente, hubiera preferido otra— para manipularlos.

Iré desgranando por aquí novedades. Y estoy pensando organizar una install & tutorial party un día de estos en Madrid. ¿Alguien se animaría?

Esta de hoy es una entrada muy friqui que se sirve de la casi excusa de que los creadores de Apache Spark han ganado la competición Gray Sort de 2014 para recomendar a sus lectores a estar alerta a las novedades que llegan.

Todavía colea el siglo XX y todavía pagan dinero por cosas que algún día consideraremos tan entrañables como el ZX Spectrum de 48kB tales como:

Uno de mis últimos pet projects tiene que ver con el análisis de las componentes conexas de unos grafos muy grandes. Como aquí pero con datos de un tamaño muchos órdenes de magnitud mayores. Usando Spark, claro. Y ya que lo cito, aprovecho la ocasión para regalar un consejo a mis lectores más jóvenes: no esperéis a los cuarenta para aprender Scala y Spark.

Voy a limitarme a copiar el código para referencia mía y de otros. Creo que se autoexplica:

Me he puesto en modo estoy serio con Spark. Lo instalé en mi ya manida máquina virtual (voy a subir una nueva versión de ella pronto), pero hoy la voy a instalar en mi portátil. Y con la idea de, en los próximos días, montar un clúster en condiciones.

Los pasos son los siguientes:

1. Ir a la página de descargas y seleccionar una versión ya precompilada. Hay varias porque Spark se enlaza con librerías relacionadas con Hadoop (aunque uno puede utilizar Spark perfectamente sin él) y hay varias versiones mutuamente incompatibles de Hadoop. Como no tengo ninguna instalada en el portátil, cualquiera me vale.
2. Descomprimir, mover el directorio a /opt y, opcionalmente, cambiar propietarios y grupos (a root).
3. Crear un enlace blando para vagos: sudo ln -s /opt/spark-1.0.1-bin-hadoop1/ /opt/spark
4. Arrancarlo (usando la interfaz para Python): /opt/spark/bin/pyspark

En la consola, ahora, se puede ejecutar:

Hay quienes preguntan cómo cargar con R un csv de 8GB en un portátil de 4GB de RAM. La verdad, he leído respuestas la mar de extravagantes a este tipo de cuestiones: p.e., recomendar SQLite.

Yo recomendaría Scalable Strategies for Computing with Massive Data. Entre otras cosas, porque para eso lo escribieron sus autores: para que se lea. Y porque está cargado de razón y buenos consejos.

Una cosa con la que tropezará enseguida quien lo hojee es:

Hoy he escrito

last.date <- max(Filter(function(x) format(x, "%m") == "03",
	all.filled.data$Date))

y he echado mucho de menos Scala.

Más sobre Scala:

• Si yo fuera rey, todos los niños aprenderían Scala.
• Al tipo que inventó Scala le gustan tanto o más los oneliners que a mí.
• Todavía me llevo mal con el compilador.
• La gente viene a Suiza y aprende el alemán malhablado de aquí; yo, ya véis, Scala. Soy así de sociable.
• Detrás de Scala vendrá Spark.