Reportería dinámica y Visualización con R

Cristian Benalcázar
 Tabla de contenido

1. Data products: Introducción y tipos.

2. Investigación reproducible con Markdown.
3. Aplicaciones web con shiny, shinydashboard y flexdashboard.
4. RStudio Server y Shiny Server.
5. Integración con bases de datos SQL.

Bibliografía recomendada: Developing Data Products in R, Brian Caffo

and Sean Kross
1. Data products
Introducción

Productos de datos son el resultado de un análisis de

datos.

• Tabla
• Gráfico
• Informe
• Presentación
• Sitios web de análisis interactivo
Ejemplo:
Un análisis de datos podría generar algoritmo que calcule un score para
un grupo de posibles clientes.

Producto de datos:
Tabla con resultado
Reporte que muestre este resultado y su forma de cálculo
Aplicación que incorpore ese algoritmo en un sitio web para que los
usuarios puedan introducir datos de nuevos clientes y obtengan su score.
Tipos

• Estáticos
Productos que no permiten modificar tipo de visualización
Informe
Presentación
Tabla

• Dinámicos
Productos que permiten modificar el tipo de visualización, además de
cambiar el tipo de gráfico, permiten añadir nuevas variables, nuevos
registros, realizar filtros, actualizar y consolidar los resultados, etc.
Aplicaciones de control, consulta, captura y visualización de
información.
¿Por qué hacerlo con R?
Potencial y ventajas de R se incorporan directamente a nuestros
productos de datos.

Facilidad, dentro de lo necesario para desarrollar productos de datos

se incluye HTML, Javascript, D3, Web Services, etc. etc.
Ejemplo:
Reporte Excel personalizado
Ejemplo:
Gráficos estáticos y dinámicos

Highcharter, rCharts, Plotly, etc.

http://rusersgroup.com/blog/highcharter/

Mapas

http://rusersgroup.com/blog/highcharter/

Highcharter, Leaflet, ggmap, etc.

Ejemplo:
Presentaciones

RPresenter

https://rpubs.com/RUsersGroup-Ecuador/visualizacion

Slidify

https://rusersgroup.github.io
Ejemplo:
Aplicaciones y páginas web

Shiny, Shinydashboard, Flexdashboard.

https://crbdlc.shinyapps.io/reactivos_rusersgroup/

Githubpages

http://rusersgroup.com/
2. Investigación reproducible con
Markdown.
Investigación reproducible

Estudio, análisis o investigación completamente replicable –captura de

datos, limpieza, procesamiento y resultados-.

Debe incluir descripción, objetivos, análisis, etc.

Ejemplos:
rpubs.com
¿Qué es Markdown?

Markdown es un lenguaje de marcado ligero que trata de conseguir la

máxima legibilidad y facilidad de publicación tanto en su forma de
entrada como de salida, inspirándose en muchas convenciones
existentes para marcar mensajes de correo electrónico usando texto
plano.

La clave del diseño de Markdown es la facilidad de su lectura que hace

que el lenguaje sea fácilmente interpretado, sin lucir como si hubiera
sido marcado con etiquetas o instrucciones de estilo, como RTF o
HTML, los cuales tienen etiquetas que hacen mas difícil su lectura e
interpretación.

Fundamental para la web semántica

Integración con R

Markdown ofrece integración con varios lenguajes de programación,

dentro de estos R, la manera más sencilla de escribir un informe
rápido, mezclando un poco de R, es usar rmarkdown, una variante de
Markdown desarrollada por la gente de Rstudio.

R Markdown es una variante de Markdown basada en pandoc que

tiene incrustados trozos de código R, que se utiliza con knitr para
facilitar la creación de informes basados en web reproducibles.

install.packages("rmarkdown")
library(rmarkdown)
Integración con R

• La sintaxis de Markdown tiene algunas mejoras;

• Permite generar documentos HTML, PDF y MS Word, así como
presentaciones Beamer, ioslides y Slidy.
• Permite incluir ecuaciones de LaTeX sin procesar dentro de la
reducción para la personalización avanzada de la salida de PDF.
• Incluyendo soporte ampliado para tablas, listas de definiciones y
bibliografías.
• Permite incluir ganchos para personalizar la salida HTML y PDF
(incluye CSS, encabezados y pies de página).
• Permite definir fácilmente nuevos formatos para los requisitos de
publicación personalizada.
• Permite crear documentos interactivos de R Markdown utilizando
Shiny.
Chunks –trozos de código-

La clave para integración con R son los trozos de código, que se

incluyen en cualquier parte del código rmarkdown, dentro del trozo se
puede incluir cualquier función o paquete de R.
---
title: "Untitled"
author: “crb"
date: "27 de agosto de 2018"
output:
ioslides_presentation: default
---

```{r setup, include=FALSE}

knitr::opts_chunk$set(echo = FALSE)
```

## R Markdown

This is an R Markdown presentation. Markdown is a simple formatting syntax for

authoring HTML, PDF, and MS Word documents. For more details on using R Markdown see
<http://rmarkdown.rstudio.com>.

## Slide with Bullets

- Bullet 1
- Bullet 2
- Bullet 3

## Slide with R Output

```{r cars, echo = TRUE}

summary(cars)
```

## Slide with Plot

```{r pressure}
plot(pressure)
```
Argumentos en chunks
https://www.rstudio.com/wp-content/uploads/2015/03/rmarkdown-spanish.pdf

https://rmarkdown.rstudio.com/

http://rusersgroup.com/blog/rmarkdown/
Herramientas para usar Markdown

• Stackedit.io
• dillinger.io

Comprensión y práctica
Taller 1

1. Desarrollar un informe en rmarkdown

2. Desarrollar una presentación en rpresenter o slidify con el mismo

contenido del informe

Publicarlos en rpubs.com
3. Aplicaciones web con shiny,
shinydashboard y flexdashboard.
¿Qué es Shiny?

Shiny es una paquete de R con el cual podemos crear aplicaciones

web interactivas (apps) que permiten a los usuarios interactuar con sus
datos sin tener que manipular el código.

No hace falta conocimiento de HTML o JavaScript, solo conocer R.

install.packages("shiny")
library(shiny)
Componentes de una aplicación shiny

La aplicación tiene 3 componentes:

UI : Interfaz de usuario, controla el diseño, entradas y salidas de la

aplicación.
SERVER : Funciones, cálculos, resultados, etc., contiene las
instrucciones necesarias para el funcionamiento de la aplicación.
GLOBAL : Data - puede omitirse y colocarse antes del resto de
componentes.

APP : Combina las anteriores

UI

Layout - Diseño

Las aplicaciones shiny tienen 2 layouts(tipos de diseño):

• Sidebar Layout
Sidebar
Mainpanel

• Grid Layout
Fluidrow
Fixedrow
Funcionamiento: Entradas y salidas

Entrada ui >> input

sliderInput(“bins”, “Number of bins:”, min = 1,

max = 50, value = 30)

input$bins

Procesamiento
server >> output

output$distPlot <- renderPlot({ x <- faithful[, 2] bins <-

seq(min(x), max(x), length.out = input$bins + 1) hist(x,
breaks = bins, col = 'darkgray', border = 'white') })

Visualización
ui >> input & output

plotOutput(“distPlot”)
Tipos de entradas
Tipos de salidas
https://www.rstudio.com/wp-content/uploads/2015/03/shiny-spanish.pdf
runExample("01_hello")

“01_hello”
“02_text”
“03_reactivity”
“04_mpg”
“05_sliders”
“06_tabsets”
“07_widgets”
“08_html”
“09_upload”
“10_download”
“11_timer”

Comprensión y práctica
Taller 2

1. Desarrollar un aplicación en shiny

Publicarla en shinyapps.io
3.1. Shinydashboard y
flexdashboard.
Shinydashboard

install.packages("shinydashboard")
## app.R
library(shinydashboard)

ui <- dashboardPage(
dashboardHeader(),
dashboardSidebar(),
dashboardBody()
)

server <- function(input, output) {

}

shinyApp(ui, server)
https://rstudio.github.io/shinydashboard/index.html
Flexdashboard

install.packages(“flexdashboard")

https://rmarkdown.rstudio.com/flexdashboard/index.html
4. Shinyserver y Rstudio server.
Shiny-server

Demostración

https://www.rstudio.com/products/shiny/shiny-server/
RStudio-server

Demostración

https://www.rstudio.com/products/rstudio/
5. Integración con SQL
 Integración con bases de datos SQL

R Permite integración con bases de datos relacionales Postgres, MySql, Oracle, etc.

En dependencia del tipo de base podemos utilizar un determinado paquete o función.

library("RJDBC")
drv <- JDBC(driverClass="oracle.jdbc.driver.OracleDriver",
classPath="/ojdbc6.jar",
identifier.quote="`")

conn <- dbConnect(drv=drv,

url="jdbc:oracle:thin:@//192.168.1.132:1521/ORAI",
user="user", password="pass")

dbGetQuery(conn, "select * from tabla_x")

library(“RPostgreSQL")
library("odbc") db <- dbConnect(PostgreSQL(),
library(“DBI") dbname = "base", host = "localhost",
db <- dbConnect(odbc(), port = 5432,
dbname = "base", host = "localhost", user = "postgres", password = "pass")
port = 5432,
user = "postgres", password = "pass") query <- "select * from tabla_x"
data <- dbGetQuery(db, query)
query <- "select * from tabla_x" dbDisconnect(db) data
data <- dbGetQuery(db, query)
dbDisconnect(db) data