El otro día pasé por uno de esos sitios en los que exponen en las paredes obras de artistas medianos con el precio debajo. Me quedé mirando una muy… concéntrica porque me recordaba a lo que nos regala a menudo Antonio Chinchón. Pregunté de qué trataba la cosa y tuvieron la paciencia de explicármelo: al lado había una foto enorme y, se conoce, las cosas concéntricas eran una reordenación de los píxels de la primera. Una especie de tortilla de patata deconstruida a lo Adriá, pero con fotos.

Anoche me busqué a mí mismo en el Registro Mercantil. Sudé la gota gorda y cuando me encontré, es decir, recibí una notificación de que mis registros habían sido ubicados por el buscador, me apareció una aviso: si quería proceder a ver los resultados de la búsqueda tenía que abonar 1.78 euros (creo).

Así que si pierdo 20 minutos de mi vida en una seudopágina que me quiere cobrar casi dos euros por información que yo le he proporcionado, el PIB español crece en 1.78 euros.

Mis clases de/con R suelen consistir en un guión que es un programa en R con muchos comentarios y ejercicios. Con el tiempo, estos últimos tienden a crecer hasta el punto de que se convierte casi en un fichero de texto comentado con aspersión —en su acepción no-DRAE de efecto— de líneas de código.

Mejor, me he dicho recientemente, usar Rmarkdown.

Pero Rmarkdown sirve para lo que sirve: como fuente para compilar ficheros pensados para ser leídos por seres humanos. Contiene demasiada información irrelevante —formato, etc.— para un guión.

Acabo de ejecutar

set.seed(1234)

x <- runif(1e6)
x.shift <- 1e9 + x

sd(x)
sd(x.shift)

sqrt(sum((x - mean(x))^2) / (length(x - 1)))
sqrt(sum((x.shift - mean(x.shift))^2) / (length(x - 1)))

sd.sum.squares <- function(x){
  n <- length(x)
  suma <- sum(x)
  suma.cuadrados <- sum(x^2)
  sqrt((n * suma.cuadrados - suma^2) / (n * (n-1)))
}

sd.sum.squares(x)
sd.sum.squares(x.shift)

inspirado por esto y me pregunto: ¿tanto ha llovido en términos de precisión numérica desde 2008?

Sí, mi viejo ordenador había cumplido 6 años y comenzaba a quedarse corto. La puntilla fueron problemas de compatibilidad de la tarjeta gráfica con el nuevo Xubuntu (más precisamente, con los nuevos núcleos de Linux que trae). Así que lo que hace no tanto habría parecido ciencia ficción, es ahora realidad bajo mi mesa: 64GB de RAM para mí solo. Y eso que no me he querido gastar dinero; además que, como autónomo y siendo la nueva máquina herramienta de trabajo, viene a salirme como en la mitad que a un civil.

El código es

library(httr)
library(plyr)
 
base.url <- "http://www.infobolsa.es/1/wtdb/ChartIntraday"
 
res <- POST(base.url,
            body = list(mv = "M SAN",
                        date = "20160518",
                        compressionMult = 1,
                        isSession = 1))
 
dat <- content(res, as = "parsed",
                type = "application/json")
 
dat <- dat$answer$LST$TV$T09
dat <- ldply(dat, unlist)

Los mutatis mutandis, si alguien tiene la gentileza, en los comentarios.

Se me pregunta cómo llegué a los datos con los que armé esta entrada. Recuérdese que gráficos como los que aparecen aquí los pinta tu propio navegador con javascript. De alguna manera, el servidor manda datos a tu navegador y, por lo tanto, de alguna manera, esos datos obran en tu poder.Solo hay que saber capturarlos.

La manera (más bien, una de ellas):

• Abre la página con Chrome
• Abre Chrome DevTools (con control-mayúscula-c en algunas máquinas o a través de menús (Tools, etc.) siempre).
• Entra a la pestaña Network y selecciona XHR.
• Busca entre los distintos ficheros intercambiados: típicamente, los datos están en el fichero más voluminoso.

Hay variantes (p.e., el navegador puede estar haciendo una petición POST), pero como todos los lectores de este blog menos, que me conste, uno sois gente lista, seguro que dais con la manera.

Hace un tiempo se aprobó la ley de Transparencia (ver en el BOE). Son muy interesantes el preámbulo y las excepciones, a las que volveré después.

Hace unos días hubo un muy inoportuno debate sobre la conveniencia o no de hacer públicos los resultados de nosequé pruebas de nivel (honestamente, ni sé cuáles son ni me interesan) que realizan los estudiantes de primaria. Pocos nos recordaron que publicar esa información se atiene al espíritu de la ley anterior tal como recoge su preámbulo y que bajo ninguna de las excepciones que contempla podría justificarse su ocultamiento. Pocos nos recordaron, además, que esa información es pública y accesible en países tales como el RU.

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")

El otro día me enseñaron una rareza: una curva ROC no cóncava. Digamos que como

El gráfico que la acompaña aquí,

explica un par de cositas. El artículo enlazado discute cómo combinar clasificadores para construir otro cuya curva ROC sea la envolvente convexa del original.