En esta sección, aprenderemos 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 Estados Unidos.

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. Para utilizarlo, descargue la carpeta Censo_App

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.

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

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.

helpers.R usa los paquetes maps y mapproj.

Este archivo lo puedes encontrar dentro de la carpeta Censo_App.

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

Argumento	Entrada
var	Un vector columna del conjunto de datos counties.rds
color	Cualquier cadena de caracteres entre las opciones de color en colors()
legend.title	Una cadena de caracteres para usar como título de la leyenda del gráfico
max	Un parámetro para controlar el rango de sombra (valor predeterminado 100)
min	Un parámetro para controlar el rango de sombra (valor predeterminado 0)

Podemos 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("Censo_App/helpers.R")
condados <- readRDS("Censo_App/data/counties.rds")
x11()
percent_map(condados$white, "darkblue", "% White")

Notemos 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.

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() relentizará la aplicación.

ui <- fluidPage(
  titlePanel("Censo_2010"),
  
  sidebarLayout(
    sidebarPanel(
      ... # igual que lo visto.
    ),
    
    mainPanel(plotOutput("mapa"))
  )
)

server <- function(input, output){
  output$mapa <- renderPlot({
    percent_map( # algunos argumentos )
  })
}

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

server <- function(input, output) {
  output$mapa <- renderPlot({
    data <- switch(input$var, 
                   "Porcentaje de blancos" = counties$white,
                   "Porcentaje de negros" = counties$black,
                   "Porcentaje de hispanos" = counties$hispanic,
                   "Porcentaje de asiaticos" = 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.

1. Crea un archivo App.R dentro de la aplicación Censo_App 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.

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.

Mostraremos 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:

• Descargue la carpeta llamada Acciones en el directorio de trabajo.

`Valoresutiliza el paquetequantmod`` de R.

Inicie la aplicación con:

library(quantmod)
runApp("Acciones",display.mode = "showcase")

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

• Escribir 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.
• Decidir si se ajustan o no los precios por la inflación.

Note que la casilla de verificación “Ajuste los precios por inflación” aún no funciona. Vamos a trabajarlo más adelante.

Por defecto, Acciones muestra las acciones para el símbolo de cotización “SPY”. 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 GOLD (Oro).

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

• Usa getSymbols para descargar los datos financieros de Yahoo finance.
• Usa chartSeries para mostrar los precios en un gráfico atractivo.

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

La aplicación Acciones tiene un pequeño fallo, cuando se da clic en “Escala logarítmica”, 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 ("black"),
              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.

Una expresión reactiva es una expresión de 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 de R rodeada de llaves.

Por ejemplo, una expresión reactiva que utiliza los widgets de Acciones 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("black"),
              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.

Analice cómo funcionará la sigueinte expresión reactiva en la aplicación Acciones.

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 ("black"),
    type = "line", log.scale = input$log, TA = NULL)
  })

}

Cuando se hace clic en “Escala logarítmica”, 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.

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. Analice la posible solució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) })
}

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.

Descrague la carpeta Mapa. Note que al cambiar de estado el mapa no reacciona. Solucione este problema.

-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.

Mostraremos 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).

• 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 (www, 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.

library(shiny)
runApp("App.R")

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

Si no tiene su propia página web para alojar los archivos, puede alojarlos de forma gratuita en www.github.com. GitHub ofrece muchas funciones para apoyar la colaboración, como rastreadores de problemas y una estrecha integración con el sistema de control de versiones git.

Los usuarios pueden iniciar la aplicación ejecutando:

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

Un ejemplo se encuentra aquí

GitHub ofrece un servicio alternativo para compartir archivos en gist.github.com, donde no se necesita tener una cuenta GitHub para usar este servicio.

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. Puede iniciar una aplicación ejecutando:

runGist("b7e15a5053259014a272df311f6409bb")

Un ejemplo se encuentra aquí.

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.

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

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

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.

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.

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.
• Herramientas de administrador.
• Soporte prioritario.

RStudio Connect es una plataforma de publicación para el trabajo en R en un entorno comercial, donde se comparte aplicaciones Shiny, informes en RMarkdown, dashboards, gráficas, notas en Jupyter, etc, 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.

\[ \hspace{3cm} \] ¡Ya sabes lo suficiente para crear tus propias aplicaciones Shiny!

\[ \hspace{3cm} \]