1. Introducción a Plotly

1.1 ¿Qué es Plotly?

Plotly es una biblioteca de visualización de datos para R que permite crear gráficos interactivos. A diferencia de los gráficos tradicionales que son imágenes estáticas, los gráficos de Plotly responden a las acciones del usuario.

1.2 Características principales

Los gráficos creados con Plotly tienen las siguientes características:

Interactividad con el mouse: Al pasar el cursor sobre cualquier elemento del gráfico, se muestra información detallada sobre ese punto específico. Por ejemplo, en un gráfico de barras, al pasar el mouse sobre una barra aparece el valor exacto que representa.

Zoom y desplazamiento: Los gráficos permiten acercar (zoom) y desplazar la vista para examinar secciones específicas de los datos. Esta funcionalidad es especialmente útil cuando se trabaja con conjuntos de datos grandes.

Herramientas integradas: Cada gráfico incluye una barra de herramientas en la esquina superior derecha que permite descargar el gráfico como imagen PNG, hacer zoom, restablecer la vista original, entre otras opciones.

Compatibilidad web: Los gráficos de Plotly funcionan perfectamente en navegadores web y en aplicaciones Shiny, lo que facilita su publicación y compartición en línea.

1.3 ¿Para qué sirve Plotly?

Plotly es útil en diversos contextos:

Presentaciones y reportes: Los gráficos interactivos hacen más dinámicas las presentaciones, permitiendo explorar los datos en tiempo real durante la exposición.
Dashboards empresariales: Permite crear tableros de control donde los usuarios pueden filtrar y explorar información sin necesidad de crear múltiples versiones del mismo gráfico.
Análisis exploratorio de datos: Facilita la identificación de patrones y valores atípicos mediante la exploración interactiva.
Publicación web: Los gráficos se pueden publicar en páginas web manteniendo toda su funcionalidad interactiva.

2. Instalación y Configuración

2.1 Requisitos previos

Antes de trabajar con Plotly, es necesario tener instalado:

R: El lenguaje de programación estadístico (versión 3.5 o superior recomendada).
RStudio: Un entorno de desarrollo integrado que facilita el trabajo con R. Aunque no es estrictamente necesario, RStudio simplifica considerablemente el proceso.

2.2 Instalación de Plotly

La instalación de Plotly se realiza mediante el gestor de paquetes de R. En la consola de R o RStudio, ejecutamos:

install.packages("plotly")

Este comando descarga e instala el paquete Plotly desde el repositorio oficial CRAN (Comprehensive R Archive Network).

2.3 Paquetes complementarios

Aunque Plotly puede funcionar de manera independiente, existen otros paquetes que facilitan el trabajo con datos y gráficos:

dplyr: Sirve para manipular y transformar datos de manera eficiente. Por ejemplo, permite filtrar filas, seleccionar columnas, agrupar datos y calcular resúmenes.

tidyr: Ayuda a organizar los datos en formatos adecuados para la visualización. Es especialmente útil para convertir datos entre formatos “ancho” y “largo”.

readxl: Permite importar datos directamente desde archivos de Excel (.xlsx y .xls) sin necesidad de convertirlos a otros formatos.

viridis: Proporciona paletas de colores diseñadas para ser perceptualmente uniformes y accesibles para personas con daltonismo.

Para instalar estos paquetes complementarios:

install.packages(c("dplyr", "tidyr", "readxl", "viridis"))

2.4 Cargar las librerías

Una vez instalados los paquetes, es necesario cargarlos en cada sesión de trabajo antes de usarlos:

library(plotly)
library(dplyr)
library(tidyr)

El comando library() activa el paquete en la sesión actual de R, haciendo disponibles todas sus funciones.

3. Diferencias con otros sistemas de gráficos

3.1 Plotly vs. Gráficos base de R

R incluye un sistema de gráficos básico que utiliza funciones como plot(), barplot(), hist(), entre otras. Estos gráficos tienen características diferentes a los de Plotly:

Interactividad: Los gráficos base de R son completamente estáticos. Una vez generados, se comportan como imágenes fijas. Plotly, en cambio, genera gráficos que responden a las acciones del usuario.

Facilidad de personalización: Aunque los gráficos base permiten un alto nivel de personalización, requieren múltiples líneas de código para lograr aspectos profesionales. Plotly incluye estilos atractivos por defecto.

Uso en aplicaciones web: Los gráficos base requieren conversión a formatos de imagen para ser mostrados en páginas web. Los gráficos de Plotly están diseñados nativamente para funcionar en navegadores.

Veamos una comparación práctica. Creamos primero unos datos simples:

ventas <- data.frame(
  mes = c("Ene", "Feb", "Mar", "Abr", "May"),
  cantidad = c(150, 230, 180, 290, 250)
)

Este código crea una tabla con dos columnas: mes y cantidad, representando las ventas de cinco meses.

Ahora creamos el mismo gráfico con ambos sistemas:

# Gráfico base de R
barplot(ventas$cantidad, names.arg = ventas$mes,
        main = "Ventas mensuales - Gráfico Base",
        col = "steelblue", ylab = "Cantidad")

El gráfico anterior es estático. No podemos interactuar con él.

# Gráfico con Plotly
plot_ly(ventas, x = ~mes, y = ~cantidad, type = "bar",
        marker = list(color = "steelblue")) %>%
  layout(title = "Ventas mensuales - Plotly",
         yaxis = list(title = "Cantidad"))

En este segundo gráfico, al pasar el mouse sobre las barras, aparece información detallada de cada mes.

3.2 Plotly vs. ggplot2

ggplot2 es otro paquete muy popular para crear gráficos en R. Se basa en una “gramática de gráficos” que permite construir visualizaciones complejas de manera sistemática.

Filosofía de diseño: ggplot2 utiliza una sintaxis basada en capas que se van añadiendo con el operador +. Plotly utiliza una sintaxis más directa basada en funciones específicas para cada tipo de gráfico.

Interactividad: Los gráficos de ggplot2 son estáticos por defecto. Sin embargo, existe una función especial en Plotly llamada ggplotly() que convierte gráficos de ggplot2 en interactivos.

Curva de aprendizaje: ggplot2 requiere comprender su gramática específica. Plotly tiene una sintaxis más intuitiva para principiantes.

Ejemplo de conversión de ggplot2 a Plotly:

library(ggplot2)

# Crear gráfico con ggplot2
grafico_gg <- ggplot(ventas, aes(x = mes, y = cantidad)) +
  geom_bar(stat = "identity", fill = "coral") +
  theme_minimal() +
  labs(title = "Gráfico ggplot2 convertido a Plotly")

# Convertir a interactivo
ggplotly(grafico_gg)

Esta funcionalidad es muy útil si ya se tienen gráficos creados con ggplot2 y se desea añadir interactividad sin reescribir el código.

4. Estructura básica de un gráfico en Plotly

4.1 La función principal: plot_ly()

La función plot_ly() es el punto de partida para crear cualquier gráfico en Plotly. Su estructura general es:

plot_ly(data = datos, x = ~variable_x, y = ~variable_y, type = "tipo")

Analicemos cada componente:

data: Es el conjunto de datos que queremos graficar. Debe ser un data frame (tabla de datos) donde cada columna representa una variable.

x: Especifica qué variable del conjunto de datos se mostrará en el eje horizontal (eje X). El símbolo ~ antes del nombre de la variable es obligatorio y le indica a Plotly que busque esa columna dentro del data frame.

y: Define la variable para el eje vertical (eje Y). También requiere el símbolo ~.

type: Indica el tipo de gráfico que queremos crear. Las opciones más comunes son: “bar” para barras, “scatter” para puntos o líneas, “box” para diagramas de caja, “pie” para gráficos circulares, entre otros.

4.2 El operador pipe (%>%)

Plotly utiliza frecuentemente el operador pipe %>%, que se lee como “y entonces”. Este operador toma el resultado de una operación y lo pasa como entrada a la siguiente.

Por ejemplo, estas dos formas son equivalentes:

# Sin pipe (difícil de leer)
layout(plot_ly(ventas, x = ~mes, y = ~cantidad, type = "bar"), 
       title = "Título")

# Con pipe (más claro)
plot_ly(ventas, x = ~mes, y = ~cantidad, type = "bar") %>%
  layout(title = "Título")

El pipe permite escribir el código de forma más natural, siguiendo el orden lógico: primero creamos el gráfico, luego lo personalizamos.

4.3 La función layout()

La función layout() se utiliza para personalizar aspectos del gráfico como títulos, etiquetas de ejes, leyendas y formato general. Se añade al gráfico usando el operador pipe.

plot_ly(ventas, x = ~mes, y = ~cantidad, type = "bar") %>%
  layout(
    title = "Ventas Mensuales del Primer Semestre",
    xaxis = list(title = "Mes"),
    yaxis = list(title = "Cantidad de Ventas")
  )

En este ejemplo: - title define el título principal del gráfico - xaxis = list(title = "Mes") establece la etiqueta del eje X - yaxis = list(title = "Cantidad de Ventas") establece la etiqueta del eje Y

5. Tipos básicos de gráficos

5.1 Gráfico de barras

Los gráficos de barras se utilizan para comparar cantidades entre diferentes categorías. Cada barra representa una categoría y su altura corresponde al valor de esa categoría.

¿Cuándo usar un gráfico de barras? - Para comparar ventas entre productos - Para mostrar cantidad de estudiantes por carrera - Para comparar presupuestos entre departamentos - En general, cuando tenemos categorías y queremos comparar sus valores

Creamos datos de ejemplo:

productos <- data.frame(
  producto = c("Laptop", "Mouse", "Teclado", "Monitor", "Webcam"),
  ventas = c(45, 120, 85, 60, 95)
)

Ahora creamos el gráfico de barras:

plot_ly(productos, x = ~producto, y = ~ventas, type = "bar",
        marker = list(color = "#667eea")) %>%
  layout(title = "Ventas por Producto",
         xaxis = list(title = "Producto"),
         yaxis = list(title = "Unidades Vendidas"))

En este código: - type = "bar" especifica que queremos un gráfico de barras - marker = list(color = "#667eea") define el color de las barras usando un código hexadecimal

Barras horizontales: Si queremos que las barras estén en posición horizontal, simplemente intercambiamos x e y, y añadimos orientation = "h":

plot_ly(productos, x = ~ventas, y = ~producto, type = "bar",
        orientation = "h",
        marker = list(color = ~ventas, colorscale = "Viridis")) %>%
  layout(title = "Ventas por Producto (Horizontal)",
         xaxis = list(title = "Unidades Vendidas"))

Aquí también usamos colorscale = "Viridis" que asigna colores diferentes a cada barra según su valor, creando un efecto de gradiente.

5.2 Gráfico de líneas

Los gráficos de líneas son ideales para mostrar tendencias a lo largo del tiempo o para representar datos continuos. Conectan puntos de datos con líneas, facilitando la identificación de patrones y cambios.

¿Cuándo usar un gráfico de líneas? - Para mostrar evolución de ventas mes a mes - Para representar cambios de temperatura a lo largo del año - Para visualizar tendencias de precios en el tiempo - Cuando el eje X representa una secuencia ordenada (tiempo, edad, distancia, etc.)

Creamos datos de temperatura:

temperatura <- data.frame(
  mes = c("Ene", "Feb", "Mar", "Abr", "May", "Jun"),
  temp = c(22, 24, 26, 28, 30, 32)
)

Creamos el gráfico de líneas:

plot_ly(temperatura, x = ~mes, y = ~temp, type = "scatter",
        mode = "lines+markers",
        line = list(color = "#f39c12", width = 3),
        marker = list(size = 10, color = "#e74c3c")) %>%
  layout(title = "Temperatura Mensual Promedio",
         xaxis = list(title = "Mes"),
         yaxis = list(title = "Temperatura (°C)"))

Analicemos los parámetros: - type = "scatter" indica que usamos el tipo scatter, que sirve tanto para puntos como para líneas - mode = "lines+markers" especifica que queremos tanto la línea como los puntos marcadores. Otras opciones son solo “lines” o solo “markers” - line = list(color = "#f39c12", width = 3) define el color y grosor de la línea - marker = list(size = 10, color = "#e74c3c") define el tamaño y color de los puntos

5.3 Gráfico de dispersión

Los gráficos de dispersión muestran la relación entre dos variables numéricas. Cada punto representa una observación, con su posición determinada por los valores de ambas variables.

¿Cuándo usar un gráfico de dispersión? - Para analizar la relación entre horas de estudio y calificaciones - Para examinar correlación entre precio y demanda - Para identificar patrones o agrupaciones en los datos - Cuando queremos ver si dos variables están relacionadas

Creamos datos de estudiantes:

estudiantes <- data.frame(
  horas_estudio = c(2, 4, 6, 8, 3, 5, 7, 9, 4, 6),
  calificacion = c(60, 70, 80, 90, 65, 75, 85, 95, 72, 82)
)

Creamos el gráfico de dispersión:

plot_ly(estudiantes, x = ~horas_estudio, y = ~calificacion,
        type = "scatter", mode = "markers",
        marker = list(size = 12, color = "#3498db",
                     line = list(color = "white", width = 2))) %>%
  layout(title = "Relación entre Horas de Estudio y Calificación",
         xaxis = list(title = "Horas de Estudio"),
         yaxis = list(title = "Calificación"))

En este caso: - mode = "markers" indica que solo queremos mostrar puntos, sin líneas que los conecten - marker = list(size = 12) define el tamaño de los puntos - line = list(color = "white", width = 2) dentro de marker añade un borde blanco alrededor de cada punto

5.4 Gráfico circular (pie chart)

Los gráficos circulares muestran la composición de un total, dividido en partes. Cada “rebanada” representa la proporción de una categoría respecto al total.

¿Cuándo usar un gráfico circular? - Para mostrar participación de mercado - Para representar distribución presupuestaria - Para visualizar composición de una población - Cuando queremos destacar proporciones de un todo

Advertencia: Los gráficos circulares son efectivos solo cuando hay pocas categorías (idealmente entre 3 y 6). Con muchas categorías, se vuelven difíciles de leer.

Creamos datos de participación de mercado:

mercado <- data.frame(
  empresa = c("Empresa A", "Empresa B", "Empresa C", "Empresa D"),
  porcentaje = c(35, 25, 20, 20)
)

Creamos el gráfico circular:

plot_ly(mercado, labels = ~empresa, values = ~porcentaje,
        type = "pie",
        marker = list(colors = c("#3498db", "#e74c3c", "#2ecc71", "#f39c12"))) %>%
  layout(title = "Participación de Mercado")

Diferencias con otros tipos de gráficos: - Usamos labels en lugar de x para especificar las categorías - Usamos values en lugar de y para los valores numéricos - type = "pie" define el tipo como circular - colors (plural) dentro de marker permite especificar un color para cada rebanada

Gráfico de dona: Es una variación del gráfico circular con un agujero en el centro. Se crea añadiendo el parámetro hole:

plot_ly(mercado, labels = ~empresa, values = ~porcentaje,
        type = "pie", hole = 0.4,
        marker = list(colors = c("#3498db", "#e74c3c", "#2ecc71", "#f39c12"))) %>%
  layout(title = "Participación de Mercado (Gráfico de Dona)")

El valor de hole va de 0 a 1, donde 0 es un círculo completo y valores cercanos a 1 crean un anillo muy delgado. Un valor de 0.4 es comúnmente utilizado.

5.5 Diagrama de caja (boxplot)

Los diagramas de caja muestran la distribución de datos numéricos a través de sus cuartiles. Son muy útiles para identificar valores atípicos y comparar distribuciones entre grupos.

¿Qué muestra un boxplot? - La mediana (línea central de la caja) - El primer y tercer cuartil (bordes inferior y superior de la caja) - Los valores mínimos y máximos (líneas o “bigotes”) - Valores atípicos (puntos fuera de los bigotes)

¿Cuándo usar un boxplot? - Para comparar distribuciones de calificaciones entre grupos - Para detectar valores atípicos en datos de ventas - Para analizar variabilidad de precios entre categorías - Cuando queremos resumir la distribución de datos numéricos

Creamos datos de calificaciones:

calificaciones <- data.frame(
  grupo = c(rep("A", 30), rep("B", 30), rep("C", 30)),
  nota = c(rnorm(30, 75, 10), rnorm(30, 80, 8), rnorm(30, 70, 12))
)

El código anterior genera datos simulados: 30 calificaciones para cada grupo (A, B, C) con diferentes promedios y variabilidades.

Creamos el boxplot:

plot_ly(calificaciones, x = ~grupo, y = ~nota, type = "box",
        color = ~grupo,
        colors = c("#3498db", "#e74c3c", "#2ecc71")) %>%
  layout(title = "Distribución de Calificaciones por Grupo",
         xaxis = list(title = "Grupo"),
         yaxis = list(title = "Calificación"))

En este código: - type = "box" especifica el diagrama de caja - color = ~grupo asigna un color diferente a cada grupo - colors define la paleta de colores a usar

5.6 Histograma

Los histogramas muestran la frecuencia de aparición de valores en rangos específicos. Dividen el rango de datos en intervalos (bins) y cuentan cuántas observaciones caen en cada intervalo.

¿Cuándo usar un histograma? - Para analizar la distribución de edades en una población - Para examinar la distribución de ingresos - Para identificar si los datos siguen una distribución normal - Cuando queremos ver cómo se distribuyen los valores de una variable

Creamos datos de edades:

set.seed(123)  # Para reproducibilidad
edades <- data.frame(edad = rnorm(200, 35, 10))

Este código genera 200 edades con distribución aproximadamente normal, centrada en 35 años.

Creamos el histograma:

plot_ly(edades, x = ~edad, type = "histogram",
        marker = list(color = "#9b59b6",
                     line = list(color = "white", width = 1))) %>%
  layout(title = "Distribución de Edades",
         xaxis = list(title = "Edad"),
         yaxis = list(title = "Frecuencia"))

Características del histograma: - Solo requiere especificar x, ya que y (la frecuencia) se calcula automáticamente - type = "histogram" define el tipo de gráfico - line dentro de marker añade bordes blancos entre las barras para mejorar la legibilidad

6. Personalización de gráficos

6.1 Trabajar con colores

Los colores son fundamentales para hacer gráficos atractivos y comunicar información efectivamente.

Colores fijos

Podemos asignar un color único a todos los elementos del gráfico:

plot_ly(productos, x = ~producto, y = ~ventas, type = "bar",
        marker = list(color = "#e74c3c")) %>%
  layout(title = "Gráfico con color rojo fijo")

Los colores se pueden especificar de varias formas: - Código hexadecimal: "#e74c3c" (recomendado para precisión) - Nombre en inglés: "red", "blue", "green" - RGB: "rgb(231, 76, 60)"

Colores según valores

Podemos hacer que el color varíe según el valor de una variable:

plot_ly(productos, x = ~producto, y = ~ventas, type = "bar",
        marker = list(color = ~ventas,
                     colorscale = "Viridis",
                     showscale = TRUE)) %>%
  layout(title = "Colores según el valor de ventas")

Aquí: - color = ~ventas indica que el color debe basarse en los valores de ventas - colorscale = "Viridis" especifica la paleta de colores - showscale = TRUE muestra una barra lateral indicando la escala de colores

Paletas de colores

Plotly ofrece varias paletas predefinidas:

Viridis: Diseñada para ser perceptualmente uniforme y accesible
Blues, Greens, Reds: Gradientes de un solo color
RdYlBu: Rojo-Amarillo-Azul, útil para datos divergentes
YlOrRd: Amarillo-Naranja-Rojo, buena para datos secuenciales

6.2 Títulos y etiquetas

Los títulos y etiquetas son esenciales para que el gráfico sea autoexplicativo.

plot_ly(productos, x = ~producto, y = ~ventas, type = "bar") %>%
  layout(
    title = list(
      text = "<b>Ventas por Producto - Trimestre 1</b>",
      font = list(size = 20, color = "#2c3e50")
    ),
    xaxis = list(
      title = "Categoría de Producto",
      titlefont = list(size = 16, color = "#34495e"),
      tickfont = list(size = 12)
    ),
    yaxis = list(
      title = "Unidades Vendidas",
      titlefont = list(size = 16, color = "#34495e")
    )
  )

Elementos que podemos personalizar: - text: El texto del título (podemos usar <b> para negrita) - font = list(size, color): Tamaño y color de la fuente - titlefont: Formato específico para los títulos de los ejes - tickfont: Formato para los números en los ejes

6.3 Mostrar valores en el gráfico

A veces es útil mostrar los valores exactos directamente en el gráfico:

plot_ly(productos, x = ~producto, y = ~ventas, type = "bar",
        text = ~ventas, textposition = "auto",
        marker = list(color = "#3498db")) %>%
  layout(title = "Ventas con valores mostrados")

Parámetros importantes: - text = ~ventas especifica qué valores mostrar - textposition = "auto" coloca automáticamente el texto en la mejor posición. Otras opciones son “inside”, “outside”, “top”

7. Trabajar con datos reales

7.1 Importar datos desde Excel

En la práctica, nuestros datos suelen estar en archivos de Excel. El paquete readxl facilita su importación:

library(readxl)

# Importar archivo Excel
mis_datos <- read_excel("ruta/del/archivo.xlsx")

# Ver las primeras filas
head(mis_datos)

# Ver estructura de los datos
str(mis_datos)

Consejos para importar datos: - Asegurarse de que la ruta del archivo sea correcta - Verificar que la primera fila contenga los nombres de las columnas - Revisar que los datos se hayan importado correctamente con head()

7.2 Preparar datos con dplyr

A menudo necesitamos transformar nuestros datos antes de graficarlos. El paquete dplyr ofrece funciones intuitivas para esto:

# Datos de ventas diarias
ventas_diarias <- data.frame(
  fecha = seq.Date(from = as.Date("2024-01-01"),
                   to = as.Date("2024-01-31"), by = "day"),
  ventas = sample(100:500, 31, replace = TRUE),
  region = sample(c("Norte", "Sur"), 31, replace = TRUE)
)

# Calcular total de ventas por región
ventas_por_region <- ventas_diarias %>%
  group_by(region) %>%
  summarise(total = sum(ventas))

# Graficar
plot_ly(ventas_por_region, x = ~region, y = ~total,
        type = "bar", marker = list(color = "#2ecc71")) %>%
  layout(title = "Total de Ventas por Región - Enero 2024")

Funciones útiles de dplyr: - filter(): Selecciona filas que cumplen una condición - select(): Selecciona columnas específicas - mutate(): Crea nuevas columnas o modifica existentes - group_by(): Agrupa datos por categorías - summarise(): Calcula resúmenes (suma, promedio, etc.)

8. Integración con Shiny

8.1 ¿Qué es Shiny?

Shiny es un paquete de R que permite crear aplicaciones web interactivas sin necesidad de conocimientos de programación web (HTML, CSS, JavaScript). Combinar Shiny con Plotly permite crear dashboards dinámicos donde los usuarios pueden interactuar con los datos mediante menús, botones y controles.

8.2 Componentes de una aplicación Shiny

Una aplicación Shiny consta de dos partes principales:

UI (User Interface): Define cómo se ve la aplicación. Aquí especificamos dónde van los menús, botones, gráficos y textos.

Server: Contiene la lógica de la aplicación. Aquí procesamos datos y generamos los gráficos según las selecciones del usuario.

8.3 Aplicación básica con Plotly

Veamos un ejemplo simple de una aplicación que permite seleccionar el tipo de gráfico:

library(shiny)
library(plotly)

# Interfaz de usuario
ui <- fluidPage(
  titlePanel("Dashboard de Ventas"),
  
  sidebarLayout(
    sidebarPanel(
      selectInput("tipo_grafico", 
                  "Selecciona el tipo de gráfico:",
                  choices = c("Barras" = "bar", 
                             "Líneas" = "scatter"))
    ),
    
    mainPanel(
      plotlyOutput("grafico")
    )
  )
)

# Servidor (lógica)
server <- function(input, output) {
  output$grafico <- renderPlotly({
    plot_ly(productos, x = ~producto, y = ~ventas,
            type = input$tipo_grafico) %>%
      layout(title = "Ventas por Producto")
  })
}

# Ejecutar la aplicación
shinyApp(ui, server)

Explicación del código:

En la UI: - fluidPage() crea una página que se adapta al tamaño de la pantalla - titlePanel() define el título de la aplicación - sidebarLayout() crea un diseño con barra lateral y panel principal - selectInput() crea un menú desplegable. El "tipo_grafico" es el nombre interno que usaremos en el servidor - plotlyOutput("grafico") reserva un espacio para mostrar el gráfico de Plotly

En el Server: - renderPlotly() es la función que genera gráficos de Plotly en Shiny - input$tipo_grafico accede al valor seleccionado por el usuario en el menú - El gráfico se regenera automáticamente cada vez que el usuario cambia la selección

8.4 Dashboard con shinydashboard

Para crear dashboards más profesionales, utilizamos el paquete shinydashboard:

install.packages("shinydashboard")

shinydashboard proporciona una estructura de dashboard tipo panel administrativo con menús laterales, cajas para organizar contenido y diferentes pestañas.

Estructura básica de un dashboard:

library(shinydashboard)

ui <- dashboardPage(
  dashboardHeader(title = "Mi Dashboard"),
  dashboardSidebar(
    sidebarMenu(
      menuItem("Ventas", tabName = "ventas", icon = icon("chart-bar")),
      menuItem("Productos", tabName = "productos", icon = icon("box"))
    )
  ),
  dashboardBody(
    # Aquí va el contenido
  )
)

Componentes principales: - dashboardPage(): Contenedor principal del dashboard - dashboardHeader(): Barra superior con el título - dashboardSidebar(): Menú lateral con las opciones de navegación - dashboardBody(): Área principal donde se muestran los gráficos y contenido

8.5 Dashboard completo de ejemplo

A continuación mostramos un dashboard funcional que integra todo lo aprendido:

library(shiny)
library(shinydashboard)
library(plotly)
library(dplyr)

# Datos de ejemplo
datos_ventas <- data.frame(
  mes = rep(month.name[1:12], 3),
  producto = rep(c("Laptop", "Mouse", "Teclado"), each = 12),
  ventas = sample(50:200, 36, replace = TRUE),
  region = sample(c("Norte", "Sur", "Este", "Oeste"), 36, replace = TRUE)
)

ui <- dashboardPage(
  skin = "purple",
  
  dashboardHeader(title = "Análisis de Ventas 2024"),
  
  dashboardSidebar(
    sidebarMenu(
      menuItem("Dashboard Principal", tabName = "dashboard", 
               icon = icon("dashboard")),
      
      # Controles de filtrado
      selectInput("producto_filtro", "Selecciona Producto:",
                  choices = c("Todos", unique(datos_ventas$producto)),
                  selected = "Todos"),
      
      selectInput("region_filtro", "Selecciona Región:",
                  choices = c("Todas", unique(datos_ventas$region)),
                  selected = "Todas")
    )
  ),
  
  dashboardBody(
    tabItems(
      tabItem(tabName = "dashboard",
              fluidRow(
                box(width = 12, title = "Ventas Mensuales", 
                    status = "primary", solidHeader = TRUE,
                    plotlyOutput("grafico_mensual", height = "300px"))
              ),
              fluidRow(
                box(width = 6, title = "Ventas por Producto", 
                    status = "info", solidHeader = TRUE,
                    plotlyOutput("grafico_productos", height = "300px")),
                box(width = 6, title = "Distribución por Región", 
                    status = "success", solidHeader = TRUE,
                    plotlyOutput("grafico_regiones", height = "300px"))
              )
      )
    )
  )
)

server <- function(input, output) {
  
  # Datos reactivos que cambian según los filtros
  datos_filtrados <- reactive({
    datos <- datos_ventas
    
    if (input$producto_filtro != "Todos") {
      datos <- datos %>% filter(producto == input$producto_filtro)
    }
    
    if (input$region_filtro != "Todas") {
      datos <- datos %>% filter(region == input$region_filtro)
    }
    
    return(datos)
  })
  
  # Gráfico de ventas mensuales
  output$grafico_mensual <- renderPlotly({
    datos_mes <- datos_filtrados() %>%
      group_by(mes) %>%
      summarise(total = sum(ventas))
    
    plot_ly(datos_mes, x = ~mes, y = ~total,
            type = "scatter", mode = "lines+markers",
            line = list(color = "#605ca8", width = 3)) %>%
      layout(title = "",
             xaxis = list(title = "Mes"),
             yaxis = list(title = "Ventas Totales"))
  })
  
  # Gráfico por producto
  output$grafico_productos <- renderPlotly({
    datos_prod <- datos_filtrados() %>%
      group_by(producto) %>%
      summarise(total = sum(ventas))
    
    plot_ly(datos_prod, x = ~producto, y = ~total,
            type = "bar", marker = list(color = "#00c0ef")) %>%
      layout(title = "",
             xaxis = list(title = ""),
             yaxis = list(title = "Ventas"))
  })
  
  # Gráfico por región
  output$grafico_regiones <- renderPlotly({
    datos_reg <- datos_filtrados() %>%
      group_by(region) %>%
      summarise(total = sum(ventas))
    
    plot_ly(datos_reg, labels = ~region, values = ~total,
            type = "pie") %>%
      layout(title = "")
  })
}

shinyApp(ui, server)

Conceptos clave en este dashboard:

Datos reactivos: La función reactive() crea datos que se actualizan automáticamente cuando el usuario cambia los filtros. Esto evita tener que reescribir el código de filtrado en cada gráfico.

Múltiples gráficos sincronizados: Los tres gráficos muestran diferentes vistas de los mismos datos filtrados, proporcionando un análisis completo.

Organización con cajas: Las funciones box() organizan los gráficos en contenedores con títulos y colores que facilitan la lectura.

9. Publicación en ShinyApps.io

9.1 ¿Por qué publicar en ShinyApps.io?

Una vez creada nuestra aplicación Shiny con gráficos de Plotly, queremos compartirla con otras personas. ShinyApps.io es un servicio de RStudio que permite publicar aplicaciones Shiny en internet de forma gratuita (con limitaciones) o mediante planes de pago.

Ventajas de ShinyApps.io: - No requiere configurar un servidor web - Cuenta gratuita disponible - Fácil integración con RStudio - Las aplicaciones están disponibles 24/7 - Se puede compartir simplemente enviando un enlace

Limitaciones del plan gratuito: - Máximo 5 aplicaciones - 25 horas activas de uso al mes - La aplicación se suspende después de cierto tiempo sin uso

9.2 Crear cuenta en ShinyApps.io

Pasos para crear una cuenta:

Visitar www.shinyapps.io
Hacer clic en “Sign Up” (Registrarse)
Crear una cuenta usando email o cuenta de Google/GitHub
Elegir un nombre de usuario (este aparecerá en la URL de tus aplicaciones)
Seleccionar el plan Free (gratuito) para comenzar

9.3 Configurar RStudio para publicar

Antes de publicar por primera vez, debemos conectar RStudio con nuestra cuenta de ShinyApps.io:

Paso 1: Instalar el paquete rsconnect:

install.packages("rsconnect")
library(rsconnect)

Paso 2: Obtener el token de autenticación:

Iniciar sesión en ShinyApps.io
Ir a Account → Tokens
Hacer clic en “Show” en el token
Copiar el código que aparece

Paso 3: Configurar las credenciales en R:

Pegar el código copiado en la consola de R. Se verá similar a esto:

rsconnect::setAccountInfo(
  name = "tu-nombre-usuario",
  token = "ABCD1234TOKEN5678",
  secret = "secret-key-here"
)

Este paso solo se realiza una vez. R guardará las credenciales para futuras publicaciones.

9.4 Preparar la aplicación para publicar

Antes de publicar, verificamos que la aplicación funcione correctamente:

Verificar estructura de archivos: - El archivo principal debe llamarse app.R - Todos los datos necesarios deben estar en la misma carpeta - Las rutas de archivos deben ser relativas, no absolutas

Ejemplo de estructura correcta:

mi_dashboard/
├── app.R
├── datos.xlsx
└── README.md

Verificar paquetes necesarios: Asegurarse de que todos los paquetes utilizados estén instalados:

library(shiny)
library(shinydashboard)
library(plotly)
library(dplyr)
library(readxl)

9.5 Publicar la aplicación

Existen dos formas de publicar:

Método 1: Usando el botón en RStudio

Abrir el archivo app.R en RStudio
Hacer clic en el botón azul “Publish” en la esquina superior derecha
Seleccionar “Publish Application”
Verificar que todos los archivos necesarios estén seleccionados
Asignar un nombre a la aplicación (sin espacios)
Hacer clic en “Publish”

Método 2: Usando código

# Establecer el directorio de trabajo en la carpeta de la app
setwd("ruta/a/mi_dashboard")

# Publicar la aplicación
rsconnect::deployApp(
  appName = "ventas-dashboard",
  appFiles = c("app.R", "datos.xlsx"),
  forceUpdate = TRUE
)

Parámetros importantes: - appName: Nombre de la aplicación (aparecerá en la URL) - appFiles: Lista de archivos a incluir - forceUpdate = TRUE: Actualiza la aplicación si ya existe

9.6 Acceder y compartir la aplicación

Una vez publicada, la aplicación estará disponible en una URL con el formato:

https://tu-usuario.shinyapps.io/nombre-aplicacion/

Por ejemplo: https://geraldine.shinyapps.io/ventas-dashboard/

Esta URL se puede compartir con cualquier persona que tenga acceso a internet.

9.7 Actualizar una aplicación existente

Para actualizar una aplicación ya publicada con cambios o correcciones:

Realizar los cambios en el archivo app.R local
Verificar que funcione correctamente en el computador
Volver a publicar usando el mismo nombre de aplicación
RStudio detectará que ya existe y la actualizará

10. Consejos y buenas prácticas

10.1 Elección del tipo de gráfico adecuado

La elección correcta del tipo de gráfico es fundamental para comunicar información efectivamente:

Usar gráficos de barras cuando: - Se comparan cantidades entre categorías - Las categorías son independientes entre sí - El orden de las categorías no es temporal

Usar gráficos de líneas cuando: - Se muestran datos a lo largo del tiempo - Se desea destacar tendencias o cambios - Los datos son continuos

Usar gráficos de dispersión cuando: - Se analiza la relación entre dos variables numéricas - Se buscan correlaciones o patrones - Se desea identificar valores atípicos

Usar gráficos circulares cuando: - Se muestran partes de un todo - Hay pocas categorías (3-6 máximo) - Las proporciones son significativamente diferentes

Usar boxplots cuando: - Se comparan distribuciones entre grupos - Se necesita identificar valores atípicos - Se quiere mostrar la variabilidad de los datos

10.2 Uso efectivo de colores

Los colores pueden mejorar o arruinar un gráfico:

Recomendaciones: - Usar paletas accesibles como Viridis, que funcionan bien para personas con daltonismo - Limitar la cantidad de colores diferentes (máximo 5-7 en un mismo gráfico) - Usar colores que contrasten bien con el fondo - Mantener consistencia de colores en múltiples gráficos del mismo dashboard

Evitar: - Colores muy brillantes o saturados que cansen la vista - Combinaciones de rojo-verde (difíciles para personas con daltonismo) - Usar muchos colores sin un propósito claro

10.3 Títulos y etiquetas claros

Un gráfico debe ser autoexplicativo:

Incluir siempre: - Título descriptivo que indique qué muestra el gráfico - Etiquetas en los ejes explicando qué variable representa cada uno - Unidades de medida cuando sean relevantes (pesos, porcentajes, unidades) - Fuente de los datos si es un reporte formal

Ejemplo de buen título: “Ventas Mensuales de Productos Electrónicos - Año 2024 (en miles de soles)”

Ejemplo de mal título: “Gráfico 1” o simplemente “Ventas”

10.4 Optimización de rendimiento

Cuando trabajamos con grandes volúmenes de datos, el rendimiento es importante:

Filtrar datos antes de graficar:

# Correcto: filtrar primero
datos_2024 <- datos_completos %>% filter(año == 2024)
plot_ly(datos_2024, ...)

# Incorrecto: graficar todos los datos
plot_ly(datos_completos, ...)

Limitar el número de puntos en gráficos de dispersión: Si tenemos 100,000 puntos, considerar mostrar una muestra o agregar los datos:

# Tomar una muestra aleatoria
datos_muestra <- datos_grandes %>% sample_n(1000)
plot_ly(datos_muestra, ...)

Usar datos agregados cuando sea posible: En lugar de graficar ventas diarias de 5 años, graficar ventas mensuales o anuales.

10.5 Accesibilidad

Hacer que los gráficos sean accesibles para todos:

Usar patrones además de colores: En gráficos donde el color es crítico, considerar añadir patrones o texturas.

Asegurar contraste adecuado: El texto debe ser legible sobre el fondo.

Proporcionar alternativas textuales: En aplicaciones Shiny, incluir tablas de datos además de gráficos.

10.6 Documentación del código

Comentar el código facilita el mantenimiento y la colaboración:

# Cargar datos de ventas del archivo Excel
ventas <- read_excel("ventas_2024.xlsx")

# Filtrar solo las ventas de la región Norte
ventas_norte <- ventas %>% filter(region == "Norte")

# Crear gráfico de barras con ventas mensuales
plot_ly(ventas_norte, x = ~mes, y = ~total, type = "bar") %>%
  layout(title = "Ventas Región Norte - 2024")

Cada sección importante del código debe tener un comentario explicativo.

11. Recursos adicionales

11.1 Documentación oficial

Plotly para R: https://plotly.com/r/ La documentación oficial contiene ejemplos detallados de todos los tipos de gráficos y opciones de personalización.

Shiny: https://shiny.posit.co/ Tutoriales y guías para crear aplicaciones Shiny.

dplyr: https://dplyr.tidyverse.org/ Documentación del paquete para manipulación de datos.

11.2 Galería de ejemplos

Plotly R Gallery: https://plotly.com/r/ Colección de gráficos de ejemplo con código completo que se puede copiar y adaptar.

Shiny Gallery: https://shiny.posit.co/r/gallery/ Galería de aplicaciones Shiny de ejemplo.

11.3 Comunidad y ayuda

Stack Overflow: Sitio de preguntas y respuestas donde la comunidad ayuda a resolver problemas de código. Buscar con las etiquetas “r”, “plotly”, “shiny”.

RStudio Community: https://community.rstudio.com/ Foro oficial de RStudio donde se pueden hacer preguntas.

12. Conclusiones

Plotly es una herramienta poderosa y versátil para crear visualizaciones de datos interactivas en R. A lo largo de esta guía hemos cubierto:

Los conceptos básicos de Plotly y sus ventajas sobre otros sistemas de gráficos
La instalación y configuración necesaria
Los principales tipos de gráficos y cuándo usar cada uno
Técnicas de personalización para crear gráficos profesionales
La integración con Shiny para crear dashboards interactivos
El proceso de publicación en ShinyApps.io para compartir nuestro trabajo

La clave para dominar Plotly es la práctica constante. Comenzar con gráficos simples, experimentar con diferentes opciones de personalización y gradualmente incorporar funcionalidades más avanzadas.

Los gráficos interactivos no son solo más atractivos visualmente, sino que permiten a los usuarios explorar los datos de manera más profunda, descubriendo patrones e insights que podrían pasar desapercibidos en gráficos estáticos.

Con las herramientas y conocimientos presentados en esta guía, estamos preparados para crear visualizaciones efectivas que comuniquen información de manera clara y permitan la exploración interactiva de datos.

Guía Completa de Plotly en R

Aprende a crear gráficos interactivos desde cero

Geraldine Geronimo

2025-12-21