1 Introducción
2 Ejemplos de uso
- 2.1 Hola mundo
- 2.2 Cargar librerías de R
- 2.3 Cargar e interactuar con datasets
- 2.4 Crear un DataFrame de Spark
- 2.5 Leer el DataFrame de Spark desde R
- 2.6 Crear un DataFrame de R
- 2.7 Leer el DataFrame de R desde Spark (Scala)
- 2.8 Consultar el DataFrame de R con SQL
- 2.9 Gráfico de pares
- 2.10 Mapa de calor
- 2.11 Visualización de gráficas
  - 2.11.1 Gráfica de barras
  - 2.11.2 Diagramas de velas
  - 2.11.3 Gráfica de líneas
  - 2.11.4 Diagrama de burbujas
  - 2.11.5 Mapas
3 Conclusiones
4 Descargar ejemplo

Introducción

SparkR es un paquete de R que proporciona un front end ligero para utilizar Apache Spark desde R. SparkR proporciona una implementación de marcos de datos distribuidos que soporta operaciones como selección, filtrado, agregación, etc. (similar a los marcos de datos de R, dplyr) pero en grandes conjuntos de datos. SparkR también permite el aprendizaje automático distribuido mediante MLlib.

https://spark.apache.org/docs/latest/sparkr.html

Los Notebooks de Onesait Platform incorporan el intérprete de SparkR por defecto, por lo que no es necesario instalar nada previamente, teniendo que incluir únicamente la cabecera de%spark.r.

A continuación se muestran algunos ejemplos de cómo utilizar SparkR para calcular y representar resultados.

Ejemplos de uso

Hola mundo

El primer ejemplo consiste en mostrar en la ventana de resultados unas cuantas variables de diferentes tipos. Para ello, en un párrafo, se escribirá el siguiente código:

%spark.r

foo <- TRUE
print(foo)
bare <- c(1, 2.5, 4)
print(bare)
double <- 15.0
print(double)

Al ejecutar el párrafo, se mostrará el resultado.

Cargar librerías de R

Es posible cargar elementos de R como librerías, lo que permite ampliar las funcionalidades del intérprete. Por ejemplo, es posible cargar la librería de tablas para mostrar los datos de forma tabulada:

%spark.r

library(data.table)
dt <- data.table(Cabecera = 1:3)
print(dt)
for (i in 1:5) {
  print(i*2)
}
print(1:50)

En este caso, al ejecutar el párrafo se visualizará lo siguiente:

Cargar e interactuar con datasets

Es posible cargar conjuntos de datos para interactuar con ellos. Se tomará por ejemplo el conjunto «iris», conjunto que viene integrado con R, y que contiene información sobre especies de flores iris.

Para visualizar la cabecera de los datos del dataset, se ejecutará el siguiente código:

%spark.r

colnames(iris)
iris$Petal.Length
iris$Sepal.Length

Tras ejecutar el párrafo anterior, se mostrará la información indicada del conjunto:

Crear un DataFrame de Spark

Como con otras librerías, es posible crear un DataFrame en el que llevar a cabo operaciones complejas. En el siguiente ejemplo se va a leer información desde un CSV, procesando los datos originales para seguidamente mostrarlos.

%spark

import org.apache.commons.io.IOUtils
import java.net.URL
import java.nio.charset.Charset

val bankText = sc.parallelize(
    IOUtils.toString(
        new URL("https://raw.githubusercontent.com/apache/zeppelin/master/testing/resources/bank.csv"),
        Charset.forName("utf8")).split("\n"))

case class Bank(age: Integer, job: String, marital: String, education: String, balance: Integer)

val bank = bankText.map(s => s.split(";")).filter(s => s(0) != "\"age\"").map(
    s => Bank(s(0).toInt, 
            s(1).replaceAll("\"", ""),
            s(2).replaceAll("\"", ""),
            s(3).replaceAll("\"", ""),
            s(5).replaceAll("\"", "").toInt
        )
).toDF()
bank.registerTempTable("bank")

En este caso se usa como intérprete %spark y no %spark.r.

Leer el DataFrame de Spark desde R

En este ejemplo se va a leer el DataFrame creado previamente. Para ello se generará este párrafo:

%spark.r

df <- sql("select count(*) from bank")
printSchema(df)
SparkR::head(df)

El resultado de ejecutar el párrafo será el siguiente:

Crear un DataFrame de R

También es posible crear un DataFrame de R. Esto se hará de la siguiente forma:

%spark.r 

localNames <- data.frame(name=c("John", "Smith", "Sarah"), budget=c(19, 53, 18))
names <- createDataFrame(localNames)
printSchema(names)
registerTempTable(names, "names")

El resultado de ejecutar este párrafo mostrará el esquema del DataFrame:

Leer el DataFrame de R desde Spark (Scala)

Es posible acceder y leer este DataFrame mediante Spark. Para ello se creará este párrafo:

%spark

sqlContext.sql("select * from names").head

Tras ejecutarlo, se mostrará lo siguiente:

Consultar el DataFrame de R con SQL

También es posible analizar el DataFrame utilizando SQL, lo que va a permitir visualizar los resultados:

%spark.sql

select * from names

El resultado se visualizará de esta forma:

Dependiendo del método de visualización escogido por última vez, se visualizará de una forma u otra: tabla, diagrama de barras, gráfico circular, etc. Esto se podrá seleccionar en la barra de tipo de representación:

Gráfico de pares

Para analizar la distribución de datos, se puede dibujar un gráfico de pares de manera sencilla. Así, tomando de partida los datos del conjunto de «iris»:

%spark.r

pairs(iris)

El resultado sería:

Es posible representar este gráfico con rangos de colores, modificando ligeramente el código. Así, para un rango de tres colores se especificaría de la siguiente forma:

%spark.r

plot(iris, col = heat.colors(3))

El resultado se vería tal que así:

Mapa de calor

Otro gráfico típico que se puede representar es el mapa de calor. Se puede generar mediante el siguiente código:

%spark.r

library(ggplot2)
pres_rating <- data.frame(
  rating = as.numeric(presidents),
  year = as.numeric(floor(time(presidents))),
  quarter = as.numeric(cycle(presidents))
)
p <- ggplot(pres_rating, aes(x=year, y=quarter, fill=rating))
p + geom_raster()

Visualización de gráficas

También existen diferentes formas de representar datos de forma gráfica. Una de ellas es usando el Google Charts API (googleVis).

https://cran.r-project.org/web/packages/googleVis/vignettes/googleVis_intro.html

Algunos ejemplos serían:

Gráfica de barras

Definiendo un DataFrame con los valores de coordenadas y abscisas, tal como se muestra en el siguiente código:

%spark.r

library(googleVis)
df=data.frame(country=c("US", "GB", "BR"), 
              val1=c(10,13,14), 
              val2=c(23,12,32))
Bar <- gvisBarChart(df)
print(Bar, tag = 'chart')

La gráfica resultante se verá como la siguiente:

Diagramas de velas

Este tipo de diagrama se puede generar con el siguiente código:

%spark.r

library(googleVis)

Candle <- gvisCandlestickChart(OpenClose, 
  options=list(legend='none'))

print(Candle, tag = 'chart')

El resultado de ejecutar el párrafo sería el siguiente:

Gráfica de líneas

De manera muy similar a la gráfica de barras, se puede generar una gráfica de líneas con el siguiente código:

%spark.r

library(googleVis)
df=data.frame(country=c("US", "GB", "BR"), 
  val1=c(10,13,14), 
  val2=c(23,12,32))

Line <- gvisLineChart(df)

print(Line, tag = 'chart')

Tras ejecutarlo, se verá así:

Diagrama de burbujas

También se puede visualizar la información en forma de diagrama de burbujas. Tomando el conjunto de datos de «fruits», se generaría el diagrama mediante el siguiente código:

%spark.r

library(googleVis)
bubble <- gvisBubbleChart(Fruits, idvar="Fruit", 
  xvar="Sales", yvar="Expenses",
  colorvar="Year", sizevar="Profit",
  options=list(
  hAxis='{minValue:75, maxValue:125}'))
print(bubble, tag = 'chart')

El resultado sería el siguiente gráfico:

Mapas

Por último, pero no por ello menos importante, es posible visualizar mapas proyectados. Para ello, habrá que definir el siguiente código:

%spark.r

library(googleVis)
geo = gvisGeoChart(Exports, locationvar = "Country", colorvar="Profit", options=list(Projection = "kavrayskiy-vii"))
print(geo, tag = 'chart')

En el ejemplo indicado, se mostrará entonces un plano con los países coloreados según el conjunto de datos «exports»:

Conclusiones

Como se puede ver, es posible interactuar con los datos de diversas formas haciendo uso de los Notebooks con SparkR. En el caso de representaciones más avanzadas, usando gráficos y diagramas, las diferentes APIs, como el de Google que se ha utilizado en este caso, resultan útiles y muy prácticas.

Este tutorial ha querido mostrar representaciones básicas como ejemplo, por lo que se recomienda leer la documentación tanto de SparkR como de las APIs que se quieran utilizar para poder configurar con más detalle las opciones disponibles.

Descargar ejemplo

A continuación se encuentra disponible para descargar el ejemplo utilizado en este tutorial:

Intérprete SparkR para Apache Zeppelin