24 de noviembre de 2015

Shiny: resultados interactivos o programación reactiva

¿Qué es Shiny?

Shiny es una herramienta para crear fácilmente aplicaciones web interactivas (apps) que permiten a los usuarios interactuar con sus datos sin tener que manipular el código.

Shiny se basa la programación Reactiva que vincula los valores de entrada con los de salida. Además dispone de widgets pre-construidos haciendo posible la construcción de aplicaciones bonitas e interactivas con el mínimo esfuerzo.

Desarrollado por RStudio en 2012, http://shiny.rstudio.com/

Motivación

  • R ofrece excelentes características para manipular, analizar y representar datos.
  • R se utiliza esencialmente como aplicación de escritorio (local).
  • ¿Cómo compartir los desarrollos realizados en R de una manera rápida y flexible?
  • ¡Llevar R al navegador!
  • Permitir una interacción dinámica
  • Facilitar el uso de nuestros paquetes
  • Ofrecer nuestros paquetes online

Características

  • Programación Reactiva
  • HTML5/CSS3 y Javascript+ Node.js y R
  • Basado en tecnología websocket: WebSockets
  • Disponible en CRAN: paquete shiny

Ejemplo de shiny apps

Estructura de una aplicación Shiny

Cada app es una carpeta que contiene los siguienetes 2 archivos (opcionalmente contiene archivos extra):

  1. server.R: Instrucciones que constituyen los componentes de R de tu app. En otras palabras, contiene las instrucciones que el equipo necesita para construir su aplicación.

  2. ui.R: Una descripción de la interfaz (UI) de tu app, la página web que muestra tu app (secuencia de comandos de la interfaz de usuario). En otras palabras, contiene una secuencia de comandos que controla el diseño y aspecto de la aplicación.

Hagamos un ejemplo

Lo primero que se necesita es instalar el paquete:

install.packages("shiny")

Para obtener un ejemplo sencillo de Shiny podemos "correr" el ejemplo "Hola Shiny" que realiza un histograma y permite a los usuarios cambiar el número de intervalos en el gráfico.

library(shiny)
runExample("01_hello")

En este ejemplo: ui.R

shinyUI(fluidPage(
  # Application title
  titlePanel("Hello Shiny!"),
  # Sidebar with a slider input for the number of bins
  sidebarLayout(
    sidebarPanel(
      sliderInput("bins",
                  "Number of bins:",
                  min = 1,
                  max = 50,
                  value = 30)
    ),
    # Show a plot of the generated distribution
    mainPanel(
      plotOutput("distPlot")
    )
  )
))

En este ejemplo: server.R

# Define server logic required to draw a histogram
shinyServer(function(input, output) {  
  # Expression that generates a histogram. The expression is
  # wrapped in a call to renderPlot to indicate that:
  #  1) It is "reactive" and therefore should re-execute automatically
  #     when inputs change
  #  2) Its output type is a plot
  output$distPlot <- renderPlot({
    x    <- faithful[, 2]  # Old Faithful Geyser data
    bins <- seq(min(x), max(x), length.out = input$bins + 1)
    # draw the histogram with the specified number of bins
    hist(x, breaks = bins, col = 'darkgray', border = 'white')
  })
})

server.R

Instrucciones que constituyen los componentes R de tu app.

  1. Provee server.R con el mínimo de código necesario, shinyServer(function(input, output){}).
  2. Define los componentes en R para tu app entre las llaves { } después de function(input, output).
  3. Guarda cada componente R destinados para tu interfaz (UI) como output$.
  4. Crea cada componente de salida con una función render\(^*\).
  5. Dale a cada función render\(^*\) el código R que el servidor necesita para construir el componente. El servidor notará valores reactivos que aparecen en el código y reconstruirá el componente cada vez que estos valores cambian.
  6. Has referencia a valores en "widgets" con input$.

Ejecución: server.R

  1. Código puesto fuera de shinyServer solo corre una vez cuando inicias tu app. Úsalo para instrucciones generales. Crea una sola copia en memoria.

  2. Código puesto dentro de shinyServer corre una vez por cada usuario que visita tu app. Úsalo para instrucciones que necesitas dar por cada usuario del app. Crea una copia por cada usuario.

  3. código puesto dentro de una función render*, reactive, o observe se correrá muchas veces. Úsalo solo para código que el servidor necesita para reconstruir un componente UI.

# 1. Corre una vez: carga paquetes, scripts, datos
shinyServer(function(input, output) {  

# 2. Corre una vez por usuario
  output$distPlot <- renderPlot({

# 3. Código  para reconstruir la UI    
   x    <- faithful[, 2] 
   bins <- seq(min(x), max(x),length.out =input$bins+1)
   hist(x, breaks = bins, col ='darkgray',border='white')
  })
})

Ejecutar la aplicación (en R)

Para ejecutar la aplicación puede realizarse desde R compilando en la consola las dos líneas siguientes:

library(shiny)
runApp("sidor")

Nota: Recordar que para ejecutar la aplicación, se utiliza la función runApp con el nombre del directorio donde se encuentran los archivos anteriores.

Puedes descargarte los ficheros server.R y ui.R en la carpeta sidor

Ejecutar la aplicación (en RStudio)

También se puede correr la aplicación desde cualquiera de los dos archivos en el editor de texto RStudio, mediante el botón que se marca debajo (RStudio reconoce automáticamente que se trata de un código de una aplicación)

RStudio

RStudio mantiene un servidor que es gratuito, fácil de utilizar, seguro y escalable.

Para construir una app Shiny es conveniente segruir las siguientes tres reglas básicas en la que los valores de entrada (inputs) se conviertan resultados (outputs).

  1. Guardar los objetos para mostrar en el objeto output$
  2. Construir los objetos que se deseen mostrar con la función render*()
  3. Acceder a los valores de entrada en el objeto input$

Al fichero Server debe especificar como convertir los valores de entrada (objeto input$ para que se conviertan en resultados (objeto output$).

Programación reactiva y Widgets

  1. Reactividad: Cuando una entrada (input) cambia, el servidor reconstruye cada salida (output) que depende de ella (también si la dependencia es indirecta).

Puedes controlar este comportamiento a través de la cadena de dependencias.

  1. Widget: es una pequeña aplicación o programa que tiene por objetivo facilitar el acceso a funciones usadas frecuentemente y proveer de información visual.

Programación reactiva

a <- 3
b <- a + 2
a <- 7

b == ?

  • Imperativa: \(b = 5\)
  • Reactiva: \(b = 9\)

La programación Reactiva enfatiza el uso de:

  • Valores que cambian en el tiempo

  • Expresiones que registran esos cambios

Añadir widgets de control

¿Qué es un widget?

Un elemento web que los usuarios pueden interactuar con él enviando mensajes a la aplicación Shiny.

Los widgets de shiny recogen un valor de tu usuario. Cuando un usuario cambia el widget, el valor cambiará también.

Shiny dispone de un conjunto de widgets pre-construidos, cada uno creado con una función de R.

El primer argumento de cada función de widget es el del widget.

Puedes acceder a su valor actual en server.R con input$

Widgets básicos en Shiny

Widget Función Argumentos comunes
Botón de acción actionButton inputId, label
casilla checkboxInput inputId, label, value
grupo de casillas checkboxGroupInput inputId, label, choices, selected
selección de fechas dateInput inputId, label, value, min, max, format
selección rango fechas dateRangeInput inputId, label, start, end, min, max, format
subir archivo fileInput inputId, label, multiple
campo numerico numericInput inputId, label, value, min, max, step
botón de selección radioButtons inputId, label, choices, selected
casilla de selección selectInput inputId, label, choices, selected, multiple
deslizador sliderInput inputId, label, min, max, value, step
botón de envío submitButton text
campo de texto textInput inputId, label, value

Widgets básicos en Shiny

Funcionamiento de un Widgets

Funcionamiento de un Widgets

Se puede acceder al valor de el objeto input$

Html Widgets

  • Widgets en HTML funcionan igual que los plots deR, excepto que producen visualizaciones web interactivas.

  • Una o dos líneas de código R es todo lo que se necesita para producir un gráfico en 3D o una mapa "Leaflet".

  • Estos widgets se pueden usar en la consola R, así como incrustadas en informes Markdown R y aplicaciones web shiny.

Html Widgets

Shiny Output

Output Inserta
dataTableOutput una tabla interactiva
tableOutput una tabla
imageOutput imagen
plotOutput un plot
htmlOutput raw HTML
textOutput texto
verbatimtextOutput texto

Funcion *Output()

Para visualizar una salida, añadirla en el fluidPage() con la funcon \(*\)Output()

Restricciones y Extensiones

Shiny implementa los principales INPUTs en HTML (Text, RadioButtons, Sliders, SelectButtons, etc.).

Pero a veces nuestros paquetes reciben o muestran datos que no son fácilmente representables con dichos elementos.

  • La definición de elementos de entrada/salida es extensible por medio de HTML, CSS, Javascript y R.

  • Big Data: Shiny y SparkR

Creando nuestra propia app: paquete TP.idm

TP.idm: Estimation of Transition Probabilities for the Illness-Death Model

En el siguiente enlace se puede descargar la app shiny para el paquete TP.idm: eio.usc.es/pub/moviedo/descargas

Corre tu app

Presenta tu app como una página web accesible en linea.

  • runApp corre archivos locales
  • runGitHub corre archivos alojados en
  • runGist corre archivos guardados como gist ()
  • runURL descargará y lanzar una app directamente de un enlace web.

Corre tu app con runURL o runGitHub:

  • Guarde el directorio de su app como un archivo zip
  • runURL Suba ese archivo zip en su propio enlace en una página web. Cualquier persona con acceso al enlace puede lanzar la aplicación desde el interior de R ejecutando:
library(shiny)
runGitHub("shiny_example", "rstudio")
runUrl("https://github.com/rstudio/shiny_example/archive/master.zip")
runUrl("http://eio.usc.es/pub/moviedo/descargas/sidor.zip")
runUrl("http://eio.usc.es/pub/moviedo/descargas/TPidm.zip")

Comparte tu app

Presenta tu app como una página web accesible en linea.

  • ShinyApps.io Aloja tus apps en el servidor de RStudio. Opciones gratis (máximo 5 apps) y de pago, consulta en

  • Shiny Server Construye tu propio servidor linux para alojar apps. Gratis y de código abierto

Algunos ejemplos

Documentos interactivos

Convierte tu informe R markdown\(^*\) en un documento interactivo Shiny en 3 pasos

  1. Añade runtime: shiny a encabezado YAML

  2. En los trozos de código, añade funciones de Shiny input para incrustar widgets. Añade funciones Shiny render para salidas reactivas

  3. Render with rmarkdown::run or click Run Document in RStudio

Ver ejemplo de R markdown sidor01.Rmd se convierte en intercativo en el fichero sidor02.Rmd

\(^*\) Para más información sobre documentos dinámicos en R utilizando R Markdown véase Rmd tutorial.