Tutorial R: ggplot2 para visualización de datos

Gramática de gráficos y capas en ggplot2

La visualización de datos es una parte fundamental del análisis estadístico. En R, el paquete ggplot2 ha revolucionado la forma en que creamos gráficos, ofreciendo un enfoque sistemático y coherente basado en la gramática de gráficos.

¿Qué es la gramática de gráficos?

La gramática de gráficos es un marco conceptual desarrollado por Leland Wilkinson que proporciona un lenguaje estructurado para describir y construir visualizaciones. En lugar de pensar en gráficos como entidades predefinidas (como "gráfico de barras" o "gráfico de dispersión"), la gramática de gráficos nos permite descomponer cualquier visualización en componentes fundamentales.

ggplot2, creado por Hadley Wickham, implementa esta filosofía permitiéndonos construir gráficos capa por capa, donde cada capa añade un nuevo elemento visual o transformación a nuestra representación.

Principios fundamentales

La gramática de gráficos en ggplot2 se basa en la idea de que cualquier gráfico puede descomponerse en:

• Datos: La información que queremos visualizar
• Mapeos estéticos: Cómo se representan las variables (posición, color, forma, etc.)
• Geometrías: Las formas visuales que representan los datos
• Escalas: Cómo se transforman los valores de datos en propiedades visuales
• Facetas: División del gráfico en múltiples paneles
• Temas: Aspectos visuales no relacionados con los datos

Esta descomposición nos permite construir gráficos complejos de manera incremental y sistemática.

El sistema de capas

La característica más distintiva de ggplot2 es su sistema de capas. Cada elemento del gráfico se añade como una capa independiente, lo que permite una gran flexibilidad y control sobre la visualización final.

Veamos un ejemplo sencillo para entender este concepto:

# Cargar la librería
library(ggplot2)

# Crear un gráfico base (sin geometrías)
p <- ggplot(data = mtcars, mapping = aes(x = wt, y = mpg))

# Añadir una capa de puntos
p + geom_point()

En este ejemplo:

1. Primero creamos un objeto ggplot con nuestros datos y mapeos estéticos
2. Luego añadimos una capa geométrica (puntos) a ese objeto

La belleza de este enfoque es que podemos seguir añadiendo capas para enriquecer nuestro gráfico:

# Añadir múltiples capas
p + 
  geom_point() +
  geom_smooth(method = "lm") +
  labs(title = "Relación entre peso y consumo",
       x = "Peso (1000 lbs)",
       y = "Millas por galón")

Cada capa se superpone a las anteriores, creando una visualización más compleja y rica en información.

Independencia de las capas

Una característica poderosa del sistema de capas es que cada capa puede:

• Utilizar diferentes datos que el gráfico base
• Tener sus propios mapeos estéticos
• Aplicar sus propias transformaciones estadísticas

Por ejemplo:

# Usando diferentes datos y estéticas en capas
ggplot(mtcars, aes(x = wt, y = mpg)) +
  # Capa 1: Todos los puntos en gris
  geom_point(color = "grey70") +
  # Capa 2: Resaltar solo los coches con cilindrada alta
  geom_point(data = subset(mtcars, cyl >= 6),
             aes(color = factor(cyl)),
             size = 3)

En este ejemplo, la segunda capa de puntos utiliza un subconjunto de datos y mapeos estéticos diferentes a la primera capa.

Orden de las capas

El orden en que añadimos las capas es importante, ya que determina cómo se superponen visualmente. Las capas añadidas más tarde se dibujan encima de las anteriores.

# El orden importa
ggplot(mtcars, aes(x = wt, y = mpg)) +
  # La línea se dibuja primero (debajo)
  geom_smooth(method = "lm", se = FALSE) +
  # Los puntos se dibujan después (encima)
  geom_point()

Si invirtiéramos el orden de estas capas, la línea podría ocultar algunos puntos, alterando la interpretación visual.

Capas implícitas

Algunas funciones de ggplot2 añaden múltiples capas de forma implícita. Por ejemplo, geom_boxplot() añade automáticamente una capa para los valores atípicos:

# Boxplot con valores atípicos
ggplot(mtcars, aes(x = factor(cyl), y = mpg)) +
  geom_boxplot()

Ventajas del enfoque por capas

Este sistema de construcción por capas ofrece varias ventajas:

• Flexibilidad: Podemos construir visualizaciones personalizadas combinando capas básicas
• Iteración: Podemos desarrollar gráficos gradualmente, evaluando cada adición
• Reutilización: Podemos guardar objetos ggplot parciales y reutilizarlos
• Consistencia: Todos los gráficos siguen la misma lógica estructural

Flujo de trabajo típico

Un flujo de trabajo típico con ggplot2 sigue estos pasos:

1. Iniciar con un objeto ggplot que define los datos y mapeos estéticos principales
2. Añadir una o más capas geométricas para representar los datos
3. Personalizar escalas para ajustar cómo se representan los valores
4. Añadir etiquetas y títulos para mejorar la interpretabilidad
5. Aplicar temas para controlar la apariencia general

# Ejemplo de flujo de trabajo
ggplot(diamonds, aes(x = carat, y = price)) +
  # Capa geométrica
  geom_point(aes(color = cut), alpha = 0.5) +
  # Escala personalizada
  scale_color_brewer(palette = "Set1") +
  # Etiquetas
  labs(title = "Relación entre quilates y precio",
       subtitle = "Coloreado por calidad del corte",
       x = "Quilates",
       y = "Precio (USD)") +
  # Tema
  theme_minimal()

Este enfoque estructurado nos permite construir visualizaciones complejas de manera sistemática, manteniendo el control sobre cada aspecto del gráfico.

Componentes básicos: data, aes, geoms

Para crear visualizaciones efectivas con ggplot2, es fundamental entender los tres componentes básicos que forman la estructura de cualquier gráfico: los datos, los mapeos estéticos y las geometrías. Estos elementos constituyen los pilares sobre los que se construye cualquier visualización en este sistema.

Datos (data)

El primer componente de cualquier gráfico en ggplot2 es el conjunto de datos que queremos visualizar. ggplot2 está diseñado para trabajar principalmente con datos en formato data frame, la estructura tabular estándar en R.

# Ejemplo de un data frame simple
head(mtcars)

Cuando iniciamos un gráfico, siempre especificamos los datos como primer argumento:

library(ggplot2)

# Iniciando un gráfico con el data frame mtcars
ggplot(data = mtcars)

Este código por sí solo no produce ninguna visualización visible, ya que solo hemos especificado los datos, pero no cómo representarlos. Es importante que los datos estén en formato tidy (ordenado), donde:

• Cada variable forma una columna
• Cada observación forma una fila
• Cada tipo de unidad observacional forma una tabla

Mapeos estéticos (aes)

El segundo componente fundamental son los mapeos estéticos, que definen cómo se representan visualmente las variables de nuestros datos. Estos mapeos se especifican mediante la función aes() (abreviatura de "aesthetics").

Las estéticas más comunes incluyen:

• x: posición en el eje horizontal
• y: posición en el eje vertical
• color: color de los elementos
• fill: color de relleno
• size: tamaño de los elementos
• shape: forma de los puntos
• alpha: transparencia

# Definiendo mapeos estéticos básicos
ggplot(mtcars, aes(x = wt, y = mpg))

Este código define que la variable wt (peso) se mapeará al eje x, y la variable mpg (millas por galón) al eje y. Sin embargo, aún no veremos puntos o líneas porque no hemos especificado cómo representar estos datos visualmente.

Los mapeos estéticos pueden ser:

• Globales: definidos en la función ggplot() y aplicados a todas las capas
• Locales: definidos dentro de una geometría específica, afectando solo a esa capa

# Mapeo global vs. local
p1 <- ggplot(mtcars, aes(x = wt, y = mpg, color = factor(cyl))) +
  geom_point()  # Usa el mapeo de color global

p2 <- ggplot(mtcars, aes(x = wt, y = mpg)) +
  geom_point(aes(color = factor(cyl)))  # Mapeo de color local

También podemos establecer propiedades fijas (que no dependen de los datos) fuera de aes():

# Propiedad fija vs. mapeo estético
ggplot(mtcars, aes(x = wt, y = mpg)) +
  geom_point(color = "blue")  # Todos los puntos azules (propiedad fija)

ggplot(mtcars, aes(x = wt, y = mpg)) +
  geom_point(aes(color = factor(cyl)))  # Color varía según cilindros (mapeo)

Geometrías (geoms)

El tercer componente esencial son las geometrías, que determinan qué tipo de objetos visuales se utilizarán para representar los datos. Cada función geom_*() crea una capa con una forma específica de visualización.

Algunas geometrías comunes incluyen:

• geom_point(): crea gráficos de dispersión
• geom_line(): crea líneas conectando puntos
• geom_bar(): crea gráficos de barras
• geom_histogram(): crea histogramas
• geom_boxplot(): crea diagramas de caja

# Ejemplos de geometrías básicas
# Gráfico de dispersión
ggplot(mtcars, aes(x = wt, y = mpg)) +
  geom_point()

# Gráfico de líneas
ggplot(economics, aes(x = date, y = unemploy)) +
  geom_line()

# Histograma
ggplot(diamonds, aes(x = price)) +
  geom_histogram(bins = 30)

Cada geometría tiene sus propios parámetros específicos que controlan su apariencia y comportamiento:

# Parámetros específicos de geometrías
ggplot(mtcars, aes(x = wt, y = mpg)) +
  geom_point(size = 3, alpha = 0.7, shape = 21, fill = "lightblue")

Combinando los tres componentes

La magia de ggplot2 ocurre cuando combinamos estos tres componentes. Veamos algunos ejemplos prácticos:

Ejemplo 1: Gráfico de dispersión básico

# Gráfico de dispersión con los tres componentes básicos
ggplot(data = mtcars,                  # Datos
       mapping = aes(x = wt, y = mpg)) + # Mapeos estéticos
  geom_point()                         # Geometría

Ejemplo 2: Añadiendo una dimensión adicional con color

# Añadiendo color como dimensión adicional
ggplot(mtcars, aes(x = wt, y = mpg, color = factor(cyl))) +
  geom_point(size = 3)

Ejemplo 3: Combinando múltiples geometrías

# Combinando puntos y línea de tendencia
ggplot(mtcars, aes(x = wt, y = mpg)) +
  geom_point() +
  geom_smooth(method = "lm")

Ejemplo 4: Geometrías con diferentes mapeos estéticos

# Diferentes mapeos para diferentes geometrías
ggplot(mtcars, aes(x = wt, y = mpg)) +
  geom_point(aes(color = factor(cyl))) +
  geom_smooth(method = "lm", color = "black", linetype = "dashed")

Requisitos de datos para diferentes geometrías

Cada geometría tiene requisitos específicos sobre qué mapeos estéticos necesita:

• geom_point(): requiere mapeos x e y
• geom_bar(): por defecto solo requiere x (cuenta frecuencias)
• geom_histogram(): solo requiere x
• geom_boxplot(): requiere x (categórica) e y (numérica)

# Requisitos de datos para diferentes geometrías
# Barras (solo x)
ggplot(diamonds, aes(x = cut)) +
  geom_bar()

# Boxplot (x categórica, y numérica)
ggplot(diamonds, aes(x = cut, y = price)) +
  geom_boxplot()

Transformaciones estadísticas implícitas

Algunas geometrías aplican transformaciones estadísticas automáticamente a los datos:

# geom_bar() cuenta frecuencias por defecto
ggplot(diamonds, aes(x = cut)) +
  geom_bar()

# Equivalente a:
ggplot(diamonds, aes(x = cut, y = after_stat(count))) +
  geom_bar(stat = "count")

Para usar valores ya calculados en lugar de contar:

# Usando valores ya calculados
resumen <- data.frame(
  categoria = c("A", "B", "C"),
  valor = c(10, 25, 15)
)

ggplot(resumen, aes(x = categoria, y = valor)) +
  geom_bar(stat = "identity")

Consejos prácticos

• Orden lógico: Siempre piensa en tus visualizaciones siguiendo el orden datos → mapeos → geometrías
• Reutilización: Puedes guardar partes de tu gráfico en variables para reutilizarlas
• Iteración: Construye tus gráficos incrementalmente, añadiendo una capa a la vez

# Construcción incremental
p <- ggplot(mtcars, aes(x = wt, y = mpg))
p  # Base vacía

p <- p + geom_point()
p  # Añadimos puntos

p <- p + geom_smooth(method = "lm")
p  # Añadimos línea de tendencia

Dominar estos tres componentes básicos te proporcionará una base sólida para crear prácticamente cualquier tipo de visualización con ggplot2, desde las más simples hasta las más complejas y personalizadas.

Visualización de datasets con qplot() rápido

Mientras que la construcción de gráficos por capas con ggplot() ofrece un control detallado sobre cada aspecto de nuestras visualizaciones, en ocasiones necesitamos crear gráficos rápidos para explorar datos de forma ágil. Para estos casos, ggplot2 nos proporciona la función qplot() (abreviatura de "quick plot"), que permite generar visualizaciones con una sintaxis más concisa.

qplot() funciona como un atajo conveniente que simplifica la creación de gráficos comunes, manteniendo la potencia de ggplot2 pero con una interfaz más sencilla, similar a la función base plot() de R.

Sintaxis básica de qplot()

La función qplot() utiliza una sintaxis más compacta que ggplot():

library(ggplot2)

# Sintaxis básica
qplot(x, y, data, geom, ...)

Donde:

• x, y: Variables a graficar
• data: Conjunto de datos (opcional si x e y ya son vectores)
• geom: Tipo de geometría a utilizar ("point", "line", "boxplot", etc.)
• ...: Argumentos adicionales para personalizar el gráfico

Gráficos de dispersión rápidos

Para crear un gráfico de dispersión básico:

# Gráfico de dispersión simple
qplot(wt, mpg, data = mtcars)

Este código produce el mismo resultado que:

ggplot(mtcars, aes(x = wt, y = mpg)) +
  geom_point()

Podemos añadir color fácilmente:

# Añadiendo color por factor
qplot(wt, mpg, data = mtcars, color = factor(cyl))

Especificando geometrías

Aunque qplot() intenta adivinar la geometría apropiada basándose en los datos proporcionados, podemos especificarla explícitamente:

# Especificando geometría de puntos
qplot(wt, mpg, data = mtcars, geom = "point")

# Combinando geometrías
qplot(wt, mpg, data = mtcars, geom = c("point", "smooth"))

El segundo ejemplo combina puntos con una línea de tendencia, equivalente a:

ggplot(mtcars, aes(x = wt, y = mpg)) +
  geom_point() +
  geom_smooth()

Histogramas y densidades

Para crear histogramas rápidamente:

# Histograma simple
qplot(mpg, data = mtcars, geom = "histogram", bins = 10)

También podemos crear gráficos de densidad:

# Gráfico de densidad
qplot(mpg, data = mtcars, geom = "density")

Y combinar ambos en un mismo gráfico:

# Histograma con curva de densidad superpuesta
qplot(mpg, data = mtcars, geom = "histogram", bins = 10) +
  geom_density(aes(y = after_stat(count) * 0.25))

Gráficos de caja (boxplots)

Para crear boxplots rápidamente:

# Boxplot simple
qplot(factor(cyl), mpg, data = mtcars, geom = "boxplot")

Podemos añadir puntos para ver la distribución de los datos:

# Boxplot con puntos
qplot(factor(cyl), mpg, data = mtcars, geom = c("boxplot", "jitter"))

Gráficos de series temporales

Para datos temporales:

# Gráfico de líneas para series temporales
qplot(date, unemploy, data = economics, geom = "line")

Personalización básica

Aunque qplot() está diseñado para ser simple, permite cierto nivel de personalización:

# Personalizando un gráfico de dispersión
qplot(wt, mpg, data = mtcars,
      color = factor(cyl),      # Color por cilindros
      size = hp,                # Tamaño por caballos de fuerza
      alpha = I(0.7),           # Transparencia
      main = "Relación peso-consumo",  # Título
      xlab = "Peso (1000 lbs)",        # Etiqueta eje X
      ylab = "Millas por galón")       # Etiqueta eje Y

El uso de I() para alpha es necesario para indicar que queremos un valor fijo y no un mapeo estético.

Facetas rápidas

También podemos crear facetas (pequeños múltiplos) fácilmente:

# Creando facetas por número de cilindros
qplot(wt, mpg, data = mtcars, facets = ~ cyl)

# Facetas en dos variables
qplot(wt, mpg, data = mtcars, facets = am ~ cyl)

Cuándo usar qplot() vs. ggplot()

qplot() es ideal para:

• Exploración inicial de datos
• Visualizaciones rápidas durante el análisis
• Gráficos simples que no requieren mucha personalización
• Usuarios familiarizados con la función plot() de R base

ggplot() es preferible para:

• Gráficos finales para publicaciones o presentaciones
• Visualizaciones que requieren control preciso sobre cada elemento
• Gráficos complejos con múltiples capas
• Cuando necesitas reutilizar componentes del gráfico

Ejemplo práctico: exploración rápida de un dataset

Veamos cómo qplot() facilita la exploración visual rápida del conjunto de datos diamonds:

# Cargar el dataset
data(diamonds)

# Distribución de precios
qplot(price, data = diamonds, geom = "histogram", bins = 30)

# Relación precio-quilates
qplot(carat, price, data = diamonds, alpha = I(0.2))

# Precio por calidad de corte
qplot(cut, price, data = diamonds, geom = "boxplot")

# Relación precio-quilates por claridad
qplot(carat, price, data = diamonds, 
      color = clarity, facets = ~ cut)

Con estas pocas líneas, obtenemos una visión general rápida de las principales características del dataset.

Limitaciones de qplot()

Aunque qplot() es conveniente, tiene algunas limitaciones:

• Menor flexibilidad para personalizar aspectos específicos
• Algunas funcionalidades avanzadas de ggplot2 no son accesibles
• La sintaxis puede volverse confusa para gráficos más complejos

# Esto es más claro con ggplot():
qplot(wt, mpg, data = mtcars, geom = c("point", "smooth"), 
      method = "lm", formula = y ~ x, se = FALSE)

# Equivalente más legible con ggplot():
ggplot(mtcars, aes(x = wt, y = mpg)) +
  geom_point() +
  geom_smooth(method = "lm", formula = y ~ x, se = FALSE)

Transición de qplot() a ggplot()

A medida que te familiarices con ggplot2, es recomendable migrar gradualmente de qplot() a ggplot(). Puedes comenzar con qplot() para exploración rápida y luego refinar tus visualizaciones con ggplot().

# Flujo de trabajo recomendado:
# 1. Exploración rápida con qplot()
qplot(wt, mpg, data = mtcars, color = factor(cyl))

# 2. Refinamiento con ggplot() para el gráfico final
ggplot(mtcars, aes(x = wt, y = mpg, color = factor(cyl))) +
  geom_point(size = 2) +
  labs(title = "Relación entre peso y consumo",
       x = "Peso (1000 lbs)",
       y = "Millas por galón",
       color = "Cilindros") +
  theme_minimal()

En resumen, qplot() ofrece una forma ágil y sencilla de crear visualizaciones con ggplot2, ideal para la fase exploratoria del análisis de datos. Aunque no proporciona la flexibilidad completa de ggplot(), su sintaxis concisa lo convierte en una herramienta valiosa para generar gráficos informativos rápidamente.