Esta sección muestra cómo cargar datos, scripts y paquetes de R en aplicaciones Shiny. Se ilustra esto con una aplicación sofisticada que visualiza los datos del censo de los EE.UU.

counties.rds

counties.rds es un conjunto de datos de datos demográficos para cada condado de los Estados Unidos, recopilados en el paquete de R UScensus2010, el cual se puede descargar aquí. Una vez descargado,

• Cree una nueva carpeta data en el directorio de la aplicación census-app.
• Mueva el archivo counties.rds a la carpeta data.

El conjunto de datos counties.rds contiene

• El nombre de cada condado de los Estados Unidos.
• La población total del condado.
• El porcentaje de residentes en el condado que son blancos, negros, hispanos o asiáticos.

counties <- readRDS("census-app/data/counties.rds")
head(counties)

             name total.pop white black hispanic asian
1 alabama,autauga     54571  77.2  19.3      2.4   0.9
2 alabama,baldwin    182265  83.5  10.9      4.4   0.7
3 alabama,barbour     27457  46.8  47.8      5.1   0.4
4    alabama,bibb     22915  75.0  22.9      1.8   0.1
5  alabama,blount     57322  88.9   2.5      8.1   0.2
6 alabama,bullock     10914  21.9  71.0      7.1   0.2

helpers.R

helpers.R es un script de R que puede ayudar a hacer mapas coropléticos, que son mapas que usan colores para mostrar la variación regional de una variable. En nuestro caso, helpers.R creará percent_map, una función diseñada para mapear los datos en counties.rds. el script helpers.R se puede descargar aquí.

helpers.R usa los paquetes de R maps y mapproj.

Guarde el archivo helpers.R dentro de la carpeta census-app.

La función percent_map en helpers.R usa cinco argumentos:

Se puede usar percent_map desde la línea de comandos para graficar los datos de los condados como un mapa coroplético, de la siguiente forma:

library(maps)
library(mapproj)
source("census-app/helpers.R")
counties <- readRDS("census-app/data/counties.rds")
percent_map(counties$white, "darkgreen", "% White")

percent_map grafica los datos de los condados como un mapa coroplético, donde se gráfica el porcentaje de residentes blancos en los condados de color verde oscuro.

Note que para usar percent_map

• Se ejecuta helpers.R con la función source.
• Se carga counties.rds con la función readRDS.
• Se cargaron los paquetes de R necesarios usando library(maps) y library(mapproj).

Para las funciones source y readRDS Shiny toma las rutas de los archivos desde el directorio del archivo app.R. Luego, para el ejemplo las instrucciones en Shiny son:

• source("helpers.R").
• readRDS ("data/counties.rds").
• Los paquetes maps y mapproj se pueden cargar de la manera usual:
  • library(maps).
  • library(mapproj).

Shiny ejecuta todos los comandos si son colocados en el script app.R, y el lugar donde se colocan determina cuántas veces se ejecutan (o se vuelven a ejecutar).

• Shiny ejecutará todo el script la primera vez que se llama runApp.
• La función server se ejecuta una vez cada vez que un usuario visita la aplicación.
• Las expresiones R dentro de las funciones render* se ejecutan cada vez que un usuario cambia el valor de un widget.

De manera que,

• La carga de datos, scripts y paquetes se debe hacer al comienzo del archivo app.R por fuera de la función server.
• Los objetos específicos de usuario se deben definir dentro del server, pero por fuera de los render*.
• Dentro de la función render* se debe colocar el código requerido para volver a construir un objeto.
• Colocar código innecesario dentro de una función render ralentizará la aplicación.

La aplicación de visualización del censo tiene un objeto reactivo, que es un gráfico de nombre "map", que se define en el panel principal de la ui, así:

ui <- fluidPage(
  titlePanel("censusVis"),
  
  sidebarLayout(
    sidebarPanel(
      ... # this defined like before
    ),
    
    mainPanel(plotOutput("map"))
  )
)

En la función server el gráfico se construye con la función percent_map, así:

server <- function(input, output){
  output$map <- renderPlot({
    percent_map( # some arguments )
  })
}

La función percent_map tiene cinco argumentos:

• Los tres primeros argumentos: var, color y legend.title, dependen del valor del widget del cuadro de selección.
• Los dos argumentos restantes: max y min, deberían ser los valores máximo y mínimo del widget de barra deslizante.

La siguiente función server muestra una forma de elaborar los argumentos reactivos para percent_map.

server <- function(input, output) {
  output$map <- renderPlot({
    data <- switch(input$var, 
                   "Percent White" = counties$white,
                   "Percent Black" = counties$black,
                   "Percent Hispanic" = counties$hispanic,
                   "Percent Asian" = counties$asian)
    
    percent_map(var = data, color = ?, legend.title = ?, max = ?, min = ?)
  })
}

La función switch de R puede transformar la salida de un widget de cuadro de selección a lo que se desee. Observe que el código está incompleto, ya que no da valores de color, legend.title, max o min.

1. Abra el archivo app.R de la aplicación census-app4 y agregue los comandos source("helpers.R"), counties <- readRDS("data/counties.rds"), library(maps) y library(mapproj).

   Asegúrese de colocar los comandos en una ubicación eficiente.

2. Complete el código para crear una aplicación de visualización del censo que funcione.

Se debe decidir:

• Cómo crear los valores de los argumentos percent_map, y
• Dónde colocar el código que crea estos argumentos.

Recuerde, se desea que los valores de argumento cambien cada vez que un usuario cambie el widget asociado.

Una solución al ejercicio es census-app-final.

Se pueden crear aplicaciones Shiny más complejas cargando conjuntos de datos, scripts y paquetes de R. Tenga en cuenta:

• El directorio en el que aparece app.R se convertirá en el directorio de trabajo de la aplicación Shiny.
• Shiny ejecutará el código colocado al inicio de app.R, antes de la función server, solo una vez durante la ejecución de una aplicación.
• Shiny ejecutará el código colocado dentro de la función server varias veces, lo que puede ralentizar la aplicación.
• La función switch es útil para acompañar a los widgets de Shiny de opción múltiple. Use switch para cambiar los valores de un widget por expresiones R.

A medida que las aplicaciones se tornan más complejas, se pueden volver ineficientes y lentas. La siguiente sección mostrará cómo crear aplicaciones modulares y rápidas con expresiones reactivas.

Esta sección muestra cómo optimizar las aplicaciones Shiny con expresiones reactivas, que permiten controlar qué partes de la aplicación se actualizan y cuando, evitando cálculos innecesarios.

Para ilustrar:

• Cree una nueva carpeta llamada stockVis en el directorio de trabajo.

• Descargue los siguientes archivos y colóquelos dentro del directorio stockVis: app.R y helpers.R.

  StockVis utiliza el paquete quantmod de R

• Inicie la aplicación con:

  runApp("stockVis")

  cuyo resultado es stockVis.

stockVis busca los precios de acciones para un símbolo de cotización y muestra los resultados como un gráfico de líneas. La aplicación permite:

• Seleccionar una acción para ser examinada,
• Elegir un rango de fechas para revisar,
• Elegir si desea graficar en el eje \(y\) los precios de las acciones o el logaritmo de los precios de las acciones, y
• Decidir si se ajustan o no los precios por la inflación.

Note que la casilla de verificación “Adjust prices for inflation” aún no funciona. Una de las tareas en esta sección es corregir el funcionamiento de tal casilla de verificación.

Por defecto, stockVis muestra las acciones para el símbolo de cotización SPY (un índice del S&P 500 total).

Para buscar otra acción se debe ingresar un símbolo de cotización de Yahoo Finance, que se pueden consultar aquí.

Algunos símbolos comunes son GOOG (Google), AAPL (Apple) y GS (Goldman Sachs).

stockVis depende en gran medida de dos funciones del paquete quantmod:

1. Usa getSymbols para descargar los datos financieros desde sitios web tales como Yahoo finance y el Banco de la Reserva Federal de St. Louis.
2. Usa chartSeries para mostrar los precios en un gráfico atractivo.

stockVis también usa un script R de nombre helpers.R, que contiene una función que ajusta los precios de las acciones por la inflación.

Casillas de verificación y rangos de fechas

La aplicación stockVis utiliza algunos widgets nuevos.

• Un selector de rango de fechas, creado con dateRangeInput, y
• Un par de casillas de verificación hechas con checkboxInput.

Los widgets de casillas de verificación son muy simples, devuelven TRUE si están marcadas, y FALSE si no están marcadas.

Las casillas de verificación tienen nombre log y adjust en el objeto ui, lo que significa que se puede buscar como input$log e input$adjust en la función server.

La aplicación stockVis tiene un problema, cuando se da clic en “Plot y axis on the log scale”, el valor de input$log cambia y se reejecuta la expresión en renderPlot:

output$plot <- renderPlot({
  data <- getSymbols(input$symb, src = "yahoo",
                     from = input$dates[1],
                     to = input$dates[2],
                     auto.assign = FALSE)
  
  chartSeries(data, theme = chartTheme ("white"),
              type = "line", log.scale = input$log, TA = NULL)
  
})

Esto provoca que:

1. getSymbols extrae de nuevo los datos de Yahoo Finance, y
2. Se vuelva a hacer el gráfico con el eje correcto.

Note que para volver a dibujar el gráfico no es necesario extraer de nuevo los datos, luego esto ralentiza la aplicación y consume ancho de banda del servidor.

Una expresión reactiva es una expresión R que utiliza una entrada de widget y devuelve un valor. La expresión reactiva actualiza este valor cada vez que el widget original cambie.

Para crear una expresión reactiva, se usa la función reactive, la cual toma una expresión R rodeada de llaves.

Por ejemplo, una expresión reactiva que utiliza los widgets de stockVis para extraer los datos de Yahoo.

dataInput <- reactive({
  getSymbols(input$symb, src = "yahoo",
             from = input$dates[1],
             to = input$dates[2],
             auto.assign = FALSE)
})

Luego, para acceder a los datos de precios en renderPlot se usa dataInput().

output$plot <- renderPlot({
  chartSeries(dataInput(), theme = chartTheme("white"),
              type = "line", log.scale = input$log, TA = NULL)
})

• Una expresión reactiva guarda el resultado la primera vez que se ejecuta.
• La próxima vez que se llame a una expresión reactiva, ésta verificará si el valor guardado ha quedado desactualizado (es decir, si los widgets de los que depende han cambiado).
• Si el valor no está actualizado, la expresión reactiva lo volverá a calcular (y guardará el nuevo resultado).
• Si el valor está actualizado, la expresión reactiva devolverá el valor guardado sin realizar ningún cálculo.

Se puede usar este comportamiento para evitar que Shiny vuelva a ejecutar código innecesariamente.

Considere cómo funcionará una expresión reactiva en la aplicación stockVis a continuación.

server <- function(input, output){
  
  dataInput <- reactive({
    getSymbols(input$symb, src = "yahoo",
               from = input$dates[1],
               to = input$dates[2],
               auto.assign = FALSE)
  })
  
  output$plot <- renderPlot({
    
    chartSeries(dataInput(), theme = chartTheme ("white"),
                type = "line", log.scale = input $ log, TA = NULL)
  })

}
library(shiny)

El resultado es stockVis2.

Cuando se hace clic en “Plot y axis on the log scale”, input$log cambiará y renderPlot se volverá a ejecutar.

Ahora:

1. renderPlot llamará a dataInput()
2. dataInput verificará que los widgets dates y symb no hayan cambiado
3. dataInput devolverá el conjunto de datos guardados de precios de acciones sin volver a extraer los datos desde Yahoo.
4. renderPlot volverá a dibujar el gráfico con el eje correcto.

Suponga que el usuario cambia el símbolo de acciones en el widget symb. Esto hará que el gráfico dibujado por renderPlot esté desactualizado, pero renderPlot no usa directamente a input$symb.

Shiny reconstruye automáticamente un objeto si:

• Un valor input en la función render* de los objetos cambia, o
• Una expresión reactiva en la función render* de los objetos se desactualiza.

Se recomienda usar una expresión reactiva adentro de una función reactive o render*, debido a que solo estas funciones de R pueden manejar una salida reactiva.

Casilla de verificación “Adjust prices for inflation”

La función adjust en helpers.R utiliza los datos del índice de precios al consumidor para transformar los precios históricos en valores actuales.

Una solución, que no es la ideal se presenta a continuación.

server <- function(input, output){
  
  dataInput <- reactive({
    getSymbols(input$symb, src = "yahoo",
               from = input$dates[1],
               to = input$dates[2],
               auto.assign = FALSE)
  })
  
  output$plot <- renderPlot({
    data <- dataInput()
    if(input$adjust) data <- adjust(dataInput())
    
    chartSeries(data, theme = chartTheme("white"),
                type = "line ", log.scale = input$log, TA = NULL)
  })
}

El resultado es stockVis3.

Solucione el problema anterior agregando una nueva expresión reactiva a la aplicación. La expresión reactiva debe tomar el valor de dataInput y devolver una copia ajustada (o no ajustada) de los datos.

Asegúrese de entender qué cálculos se hacen o no en la aplicación, cuando se hace clic en “Plot y axis on the log scale”.

La solución al ejercicio es stockVis-final.

• Una expresión reactiva toma valores input o de otras expresiones reactivas, y devuelve un nuevo valor.
• Las expresiones reactivas guardan los resultados, y solo los vuelven a calcular si la entrada ha cambiado.
• Las expresiones reactivas se crean con reactive({ }).
• Para usar una expresión reactiva se usa su nombre seguido de paréntesis ().
• Solo use expresiones reactivas dentro de otras expresiones reactivas o funciones render*.

Ahora puede crear aplicaciones Shiny sofisticadas y optimizadas. La sección final de este curso muestra cómo compartir las aplicaciones con otros.

Esta sección muestra varias formas de compartir las aplicaciones Shiny, para lo cual se tienen dos opciones básicas:

• Compartir la aplicación Shiny como un script de R. Esta es la forma más sencilla de compartir una aplicación, pero solo funciona si los usuarios tienen R en su computadora (y saben cómo usarlo). Los usuarios pueden usar estos scripts para iniciar la aplicación desde una sesión R.

• Compartir la aplicación Shiny como una página web. Esta es definitivamente la forma más amigable de compartir una aplicación Shiny. Los usuarios pueden acceder a la aplicación a través de internet desde un navegador. La aplicación estará totalmente procesada, actualizada y lista para funcionar.

En este caso cualquier usuario, que tenga copia del archivo app.R y el material complementario utilizado por la aplicación (por ejemplo, carpetas www o archivos helpers.R), puede ejecutar la aplicación Shiny.

Para enviar los archivos a otro usuario, puede hacerlo por correo electrónico (tal vez en un archivo zip) o alojar los archivos en línea. El usuario puede colocar los archivos en una carpeta en el directorio de trabajo y puede iniciar la aplicación en R con los mismos comandos que se han usado en este curso.

library(shiny)
runApp("census-app")

Shiny tiene tres comandos integrados que facilitan el uso de archivos alojados en línea: runUrl, runGitHub y runGist.

runUrl

runUrl descarga y lanza una aplicación Shiny directamente desde un enlace web. Para usarlo:

• Guarde el directorio de la aplicación Shiny como un archivo zip.
• Aloje el archivo zip en su propio enlace en una página web. Cualquier usuario con acceso al enlace puede iniciar la aplicación desde R ejecutando:

library(Shiny)
runUrl("<the weblink>")

runGitHub

Si no tiene su propia página web para alojar los archivos, puede alojarlos de forma gratuita en www.github.com. GitHub es un sitio popular para desarrolladores R para el alojamiento de proyectos, ya que hace más que solo alojar archivos. GitHub ofrece muchas funciones para apoyar la colaboración, como rastreadores de problemas, wikis y una estrecha integración con el sistema de control de versiones git. Para usarlo, se debe registrar (es gratis) y elegir un nombre de usuario.

Para compartir una aplicación a través de GitHub, se debe crear un repositorio de proyecto, donde se debe almacenar el archivo app.R, junto con el material complementario que use la aplicación. Los usuarios pueden iniciar la aplicación ejecutando:

runGitHub("<your repository name>", "<your user name>")

runGist

Si se desea publicar archivos en línea en forma anónima, GitHub ofrece un servicio alternativo para compartir archivos en gist.github.com, donde no se necesita tener una cuenta GitHub para usar este servicio. Incluso si tiene una cuenta de GitHub, gist es una forma simple y rápida de compartir proyectos Shiny.

Para compartir una aplicación como un gist:

• Copie y pegue el archivo app.R en la página web de gist.
• Anote la URL que GitHub le da al gist.

Una vez hecho el gist, los usuarios pueden iniciar la aplicación con runGist("<gist number>") donde "<gist number>" es el número que aparece al final de la dirección web del Gist.

Un ejemplo de una aplicación alojada como un gist está aquí. Puede iniciar esta aplicación con:

runGist("eb3470beb1c0252bd0289cbc89bcf36f")

Todos los métodos anteriores comparten la misma limitación, la cual es que requieren que el usuario tenga tanto R como Shiny instalados en su computadora. Sin embargo, Shiny crea la oportunidad perfecta para compartir aplicaciones con personas que no tienen R (y no tienen intención de obtenerlo).

Una aplicación Shiny resulta ser una de las herramientas de comunicación más utilizadas en el mundo, esto es, una página web. Si se aloja la aplicación en una URL propia, los usuarios pueden visitarla (y no deben preocuparse por el código que la genera).

Si se está familiarizado con el alojamiento web o se tiene acceso a un departamento de TI, el propietario puede alojar sus aplicaciones Shiny por si mismo. En el caso contrario, si se prefiere una experiencia más fácil o se necesita asistencia, RStudio le ofrece tres formas de alojar su aplicación Shiny como una página web:

1. shinyapps.io
2. Shiny Server
3. RStudio Connect

Shinyapps.io

La forma más fácil de convertir una aplicación Shiny en una página web es usar shinyapps.io, el servicio de alojamiento para aplicaciones Shiny de RStudio, el cual lo deja cargar la aplicación directamente desde una sesión de R.

El propietario tiene el control total sobre la aplicación, incluyendo las herramientas de administración del servidor. Para mayor información visite shinyapps.io.

Shiny Server

Shiny Server es un programa complementario de Shiny (gratis, de código abierto y está disponible en GitHub) que crea un servidor web diseñado para alojar aplicaciones Shiny. Shiny server puede ser ejecutado en servidores Linux y puede alojar múltiples aplicaciones Shiny en varias páginas web, y puede implementar las aplicaciones desde detrás de un firewall.

Para ver instrucciones detalladas de cómo instalar y configurar un servidor Shiny, visite la Guía de Shiny server.

RStudio Connect

Si se usa Shiny en un entorno comercial, es posible que sean de interés las herramientas de servidor que vienen con la mayoría de los programas de servidor pagos, tales como:

• Autenticación por contraseña.
• Soporte SSL.
• Herramientas de administrador.
• Soporte prioritario.

En ese caso, RStudio Connect es una plataforma de publicación para el trabajo en R en un entorno comercial, donde se comparte aplicaciones Shiny, informes en R Markdown, dashboards, gráficas, notas en Jupyter y más en un lugar conveniente. Para mayor información visite RStudio Connect.

Las aplicaciones Shiny son fáciles de compartir, ya sea a través de scripts de R, o como una aplicación web completamente funcional con su propia URL. Cada método tiene sus propias ventajas.

• Cualquier persona puede lanzar una aplicación siempre y cuando tenga una copia de los archivos de la misma, e instalado tanto R como Shiny.
• runUrl, runGitHub y runGist permiten compartir y recuperar archivos Shiny desde enlaces web.
• shinyapps.io permite convertir una aplicación Shiny en una aplicación web en vivo con su propia URL.
• Se puede usar el programa de código abierto Shiny server para crear un servidor Linux que aloje aplicaciones Shiny.
• Si se requiere un control más estricto o se desea administrar grandes volúmenes de tráfico, se puede adquirir RStudio Connect de RStudio.

Hemos recorrido todo el proceso de desarrollo de Shiny, de forma que podemos crear una aplicación sofisticada y reactiva, implementarla y compartirla con otros.

El siguiente paso es practicar y luego explorar las características avanzadas de Shiny.

Para ello, el Centro de desarrollo de Shiny puede ayudarlo, ya que alberga una Galería de aplicaciones inspiradoras, junto con el código que las produce. También incluye una sección de artículos para educación continua, que examinan en profundidad algunos temas de Shiny de nivel intermedio a avanzado.