Visualización de datos en R con ggplot2

El objetivo del módulo

Antes de graficar necesitamos dos cosas: R funcionando y los paquetes del curso instalados. En este módulo dejamos todo listo y, de paso, aclaramos una confusión clásica de quien recién parte: la diferencia entre instalar y cargar un paquete.

Instalar vs. cargar: la confusión número uno

Esto confunde a casi todo el mundo al empezar, así que vamos con calma usando una analogía:

• Instalar un paquete es como comprar un libro y ponerlo en tu estante. Lo haces una sola vez. El libro se queda en tu computador para siempre (hasta que lo actualices o borres).
• Cargar un paquete es como bajar el libro del estante y abrirlo sobre la mesa. Lo haces cada vez que abres R y vas a usar ese paquete.

Si instalas pero no cargas, R te dirá “no encuentro esa función”. Si intentas cargar algo que no instalaste, R te dirá “no existe ese paquete”. Son dos pasos distintos.

Paso 1 — Instalar los paquetes del curso

Vamos a usar cuatro paquetes principales. Los instalamos todos de una vez. Abre R (o Positron) y ejecuta:

# Instalar (esto se hace UNA sola vez en tu computador)
pak::pak(c("jsonlite", "lubridate", "dplyr", "ggplot2"))

¿Qué hace cada uno?

• jsonlite — lee archivos JSON (el formato en que vienen los datos de Pépito) y los convierte en tablas de R.
• lubridate — trabaja con fechas y horas sin volverse loco. Lo necesitamos porque las fechas de Pépito vienen como texto.
• dplyr — manipula tablas: filtrar filas, crear columnas, agrupar, resumir. Es la navaja suiza de los datos en R.
• ggplot2 — la estrella del curso: hace los gráficos.

pak::pak("tidyverse")

pak::pak(c("tidyverse", "jsonlite"))

Paso 2 — Cargar los paquetes

Cada vez que empieces una sesión de R para trabajar en el curso, carga los paquetes al inicio de tu script con library():

# Cargar (esto va al principio de tu script, CADA sesión)
library(jsonlite)
library(lubridate)
library(dplyr)
library(ggplot2)

Paso 3 — Comprobar que todo funciona

Hagamos una prueba mínima para confirmar que los paquetes se cargaron bien. Este código dibuja un gráfico de ejemplo con datos que ya vienen dentro de R:

library(ggplot2)

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

Si te aparece una ventana (o un panel) con una nube de puntos, ¡felicitaciones! ggplot2 está funcionando. No importa qué significa el gráfico todavía; solo queríamos confirmar que el motor enciende.

Un par de tips antes de seguir

Ejercicio

# 1. Instalar (una sola vez)
pak::pak(c("jsonlite", "lubridate", "dplyr", "ggplot2"))

# 2. Al inicio de pepito.R, cargar los paquetes
library(jsonlite)
library(lubridate)
library(dplyr)
library(ggplot2)

# 3. Gráfico de prueba
ggplot(mtcars, aes(x = wt, y = mpg)) +
  geom_point()

El objetivo del módulo

Tenemos los datos, pero la columna de fecha (created_at) es texto, y con texto no se puede calcular ni graficar bien. En este módulo la convertimos en una fecha-hora de verdad y, a partir de ella, creamos columnas nuevas que vamos a usar en casi todos los gráficos: la hora del día, la fecha y el día de la semana.

Este es el módulo más “técnico” de la parte de datos, pero también el más importante. Tómalo con calma.

El problema: una fecha que es texto

Recordemos cómo se ve created_at:

"Sun Nov 13 10:47:15 +0000 2011"

Para un humano es claro: domingo 13 de noviembre de 2011, a las 10:47:15, en hora UTC. Pero para R es una palabra larga sin significado. Si intentas restar dos de estas “palabras” para ver cuánto tiempo pasó, R se queja. Necesitamos traducir ese texto al idioma de fechas de R.

Convertir texto en fecha con parse_date_time()

La herramienta es parse_date_time(), del paquete lubridate. Le decimos en qué orden vienen las piezas de la fecha y él hace la conversión:

library(lubridate)

pepito_df$datetime <- parse_date_time(
  pepito_df$created_at,
  orders = "a b d H:M:S z Y",
  tz     = "UTC",
  locale = "C"
)

Vamos por partes, porque cada argumento importa:

• pepito_df$created_at — la columna de texto que queremos convertir.
• orders = "a b d H:M:S z Y" — el “molde” que describe el orden de las piezas en el texto. Cada letra es un pedazo:
  • a = nombre del día abreviado (Sun)
  • b = nombre del mes abreviado (Nov)
  • d = día del mes (13)
  • H:M:S = hora:minuto:segundo (10:47:15)
  • z = la zona horaria (+0000)
  • Y = año con 4 dígitos (2011)
• tz = "UTC" — le decimos que estas horas están en UTC (la hora de referencia mundial), porque así las guarda Twitter.
• locale = "C" — ¡clave! Le decimos que los nombres del día y del mes están en inglés (Sun, Nov). Sin esto, si tu computador está en español, R buscaría "Dom" y "Nov" en español y fallaría.

El resultado es una columna nueva, datetime, que R sí entiende como fecha-hora.

El detalle de la zona horaria: pasar a hora de Francia

Los datos están en UTC, pero Pépito vive en Francia. Si queremos saber “¿a qué hora sale Pépito?”, nos interesa la hora local francesa, no la UTC. En verano Francia va 2 horas adelante de UTC; en invierno, 1 hora. with_tz() hace esa conversión automáticamente, respetando incluso el horario de verano:

pepito_df$datetime_fr <- with_tz(pepito_df$datetime, tzone = "Europe/Paris")

Creamos una columna nueva, datetime_fr, que es el mismo instante pero expresado en hora de París.

Crear columnas útiles: fecha, hora y día de la semana

Ahora que tenemos una fecha-hora real (datetime_fr), podemos extraer pedazos de ella. Cada uno será una columna nueva que usaremos para graficar:

# Solo la fecha (sin la hora): 2011-11-13
pepito_df$date <- as_date(pepito_df$datetime_fr)

# Solo la hora del día como número 0–23
pepito_df$hour <- hour(pepito_df$datetime_fr)

# El día de la semana, con etiqueta y empezando en lunes
pepito_df$weekday <- wday(pepito_df$datetime_fr, label = TRUE, week_start = 1)

Qué hace cada función de lubridate:

• as_date() — se queda solo con el día (sirve para gráficos por fecha).
• hour() — extrae la hora como número entero de 0 a 23 (sirve para “¿a qué hora sale?”).
• wday(..., label = TRUE, week_start = 1) — el día de la semana. label = TRUE lo devuelve como nombre (lun, mar…) en vez de número; week_start = 1 hace que la semana empiece en lunes (en R, por defecto, empieza en domingo).

Revisar el resultado

Como siempre después de transformar: mira lo que quedó.

library(dplyr)
glimpse(pepito_df)

Ahora deberías ver las columnas nuevas con los tipos correctos:

$ datetime    <dttm> 2011-11-13 10:47:15, ...
$ datetime_fr <dttm> 2011-11-13 11:47:15, ...   (¡una hora más: invierno en Francia!)
$ date        <date> 2011-11-13, ...
$ hour        <int> 11, ...
$ weekday     <ord> dom, dom, dom, ...

<dttm> significa fecha-hora; <date> fecha; <int> número entero; <ord> factor ordenado (los días de la semana tienen orden). Si ves estos tipos, lo lograste: los datos ya están listos para graficar.

Versión con mutate() (más ordenada)

Ir creando columnas con pepito_df$x <- ... funciona perfecto. Pero a medida que avances verás esta forma encadenada con mutate() de dplyr, que hace lo mismo en un solo bloque:

pepito_df <- pepito_df |>
  mutate(
    datetime    = parse_date_time(created_at, "a b d H:M:S z Y", tz = "UTC", locale = "C"),
    datetime_fr = with_tz(datetime, "Europe/Paris"),
    date        = as_date(datetime_fr),
    hour        = hour(datetime_fr),
    weekday     = wday(datetime_fr, label = TRUE, week_start = 1)
  )

Las dos formas dan el mismo resultado. Usa la que te resulte más clara; mutate() se vuelve más cómoda cuando creas muchas columnas.

Errores comunes con fechas

Ejercicio

library(lubridate)
library(dplyr)

pepito_df$datetime    <- parse_date_time(pepito_df$created_at,
                                         orders = "a b d H:M:S z Y",
                                         tz = "UTC", locale = "C")
pepito_df$datetime_fr <- with_tz(pepito_df$datetime, tzone = "Europe/Paris")
pepito_df$date        <- as_date(pepito_df$datetime_fr)
pepito_df$hour        <- hour(pepito_df$datetime_fr)
pepito_df$weekday     <- wday(pepito_df$datetime_fr, label = TRUE, week_start = 1)

glimpse(pepito_df)
pepito_df |> count(weekday)

El objetivo del módulo

Ya conoces la gramática. Ahora vamos a usarla para responder una pregunta real: ¿a qué hora del día está más activo Pépito? En el camino aprenderás a controlar las barras: agrupar por color, separarlas o apilarlas, y ajustar el eje X.

De categorías a números: la hora del día

En el módulo 5 graficamos way, que tiene solo dos valores (in/out). Ahora usaremos la columna hour, que va de 0 a 23. Empecemos simple, contando los eventos por hora:

library(ggplot2)

ggplot(pepito_df, aes(x = hour)) +
  geom_bar()

Obtienes 24 barras, una por hora. Ya se nota la rutina del gato: pocas barras de madrugada (Pépito duerme) y barras altas durante el día.

Separar por sentido con fill

La pregunta se pone más interesante si distinguimos entradas de salidas. Para eso mapeamos way al color de relleno (fill), como aprendimos:

ggplot(pepito_df, aes(x = hour, fill = way)) +
  geom_bar()

Esto apila las barras: dentro de cada hora, una parte es in y otra out, una encima de la otra. Está bien, pero comparar alturas apiladas es difícil. Mejor pongámoslas lado a lado.

position: apilar, separar o normalizar

El argumento position de geom_bar() controla qué pasa cuando hay varios grupos por barra. Hay tres opciones que conviene conocer:

# Lado a lado (lo que queremos): dos barritas por hora
ggplot(pepito_df, aes(x = hour, fill = way)) +
  geom_bar(position = "dodge")

• position = "stack" (el de por defecto) — apila los grupos uno sobre otro. Bueno para ver el total.
• position = "dodge" — los pone lado a lado. Bueno para comparar grupos entre sí. Es el que usaremos.
• position = "fill" — apila pero estira todas las barras a la misma altura (100%), para ver proporciones. Bueno para “¿qué porcentaje de eventos a esta hora son salidas?”.

El gráfico completo

Juntemos todo y pulámoslo. Este es el gráfico de actividad por hora, completo:

ggplot(pepito_df, aes(x = hour, fill = way)) +
  geom_bar(position = "dodge") +
  scale_x_continuous(breaks = 0:23) +
  labs(
    title = "Actividad de Pépito por hora del día",
    x = "Hora del día",
    y = "Número de eventos",
    fill = "Sentido"
  ) +
  theme_minimal()

La capa nueva es scale_x_continuous(breaks = 0:23). Sirve para controlar las marcas del eje X:

• scale_x_continuous se usa cuando el eje X es numérico (como hour).
• breaks = 0:23 le dice “pon una marca en cada número del 0 al 23”. (0:23 es la forma corta de R para “todos los enteros de 0 a 23”.)

Sin esta línea, ggplot2 pone marcas cada 5 horas (0, 5, 10…) y cuesta leer la hora exacta. Con ella, ves las 24 horas etiquetadas.

Errores comunes con barras

conteo <- pepito_df |> count(hour)
ggplot(conteo, aes(x = hour, y = n)) +
  geom_col()

Ejercicio

library(ggplot2)

# 1. Dodge (lado a lado)
ggplot(pepito_df, aes(x = hour, fill = way)) +
  geom_bar(position = "dodge") +
  scale_x_continuous(breaks = 0:23) +
  labs(title = "Actividad de Pépito por hora del día",
       x = "Hora del día", y = "Número de eventos", fill = "Sentido") +
  theme_minimal()

# 2. Fill (proporción 0–100%)
ggplot(pepito_df, aes(x = hour, fill = way)) +
  geom_bar(position = "fill") +
  scale_x_continuous(breaks = 0:23) +
  labs(title = "Proporción de entradas y salidas por hora",
       x = "Hora del día", y = "Proporción", fill = "Sentido") +
  theme_minimal()

# 4. Día de la semana (eje categórico)
ggplot(pepito_df, aes(x = weekday)) +
  geom_bar(fill = "steelblue") +
  labs(title = "Actividad por día de la semana",
       x = "Día", y = "Número de eventos") +
  theme_minimal()

El objetivo del módulo

Hasta ahora contamos eventos. Pero la pregunta más rica del dataset es otra: ¿cuánto tiempo pasa Pépito fuera de casa? Para responderla necesitamos algo nuevo: emparejar cada salida con la entrada siguiente y medir la diferencia. Eso nos dará las “sesiones de paseo”, y con ellas haremos histogramas y densidades: los gráficos para ver cómo se distribuye una variable numérica.

Este módulo mezcla un poco más de preparación de datos con gráficos nuevos. Vale la pena: el resultado es la base del gran final.

El problema: cada fila es un evento, no una salida completa

Nuestros datos tienen una fila por evento (salió, o entró). Pero una “salida al mundo” son en realidad dos eventos: un out y, más tarde, el in que lo cierra. Para medir la duración necesitamos mirar cada fila y la siguiente.

La función que mira “la fila siguiente” es lead() de dplyr. Veámosla primero con las transiciones:

library(dplyr)

pepito_df |>
  mutate(next_way = lead(way)) |>
  count(way, next_way)

lead(way) crea una columna con el valor de way de la fila siguiente. Así podemos contar qué pasa después de cada evento: ¿una salida suele ir seguida de una entrada? El conteo te muestra las combinaciones (out → in, out → out, etc.).

pepito_df <- pepito_df |> arrange(datetime_fr)

Construir las sesiones de paseo

Ahora sí, armamos la tabla de sesiones. La lógica es: para cada fila que sea una salida (out) cuyo evento siguiente sea una entrada (in), calculamos cuánto tiempo pasó entre ambos.

library(dplyr)

# 1. Ordenar cronológicamente (imprescindible)
pepito_df <- pepito_df |> arrange(datetime_fr)

# 2. Construir las sesiones
sessions <- pepito_df |>
  mutate(
    next_way  = lead(way),            # el sentido del evento siguiente
    next_time = lead(datetime_fr)     # la hora del evento siguiente
  ) |>
  filter(way == "out", next_way == "in") |>   # solo: salió y luego entró
  mutate(
    duracion_min   = as.numeric(difftime(next_time, datetime_fr, units = "mins")),
    duracion_horas = duracion_min / 60,
    salida  = datetime_fr,
    entrada = next_time
  ) |>
  select(salida, entrada, duracion_min, duracion_horas)

Léelo como una receta encadenada con |>:

1. mutate(next_way = ..., next_time = ...) — agregamos dos columnas: el sentido y la hora del evento siguiente.
2. filter(way == "out", next_way == "in") — nos quedamos solo con las filas que son una salida seguida de una entrada. Una coma dentro de filter() significa “y” (ambas condiciones). Fíjate en el == doble: en R, == compara, mientras que = asigna. Para filtrar siempre va ==.
3. mutate(duracion_min = ...) — calculamos la duración. difftime(fin, inicio, units = "mins") da la diferencia de tiempo en minutos; as.numeric() la convierte en un número normal con el que podemos graficar. También guardamos salida y entrada con nombres claros.
4. select(...) — nos quedamos solo con las cuatro columnas que nos interesan.

El resultado, sessions, es una tabla donde cada fila es una salida completa de Pépito, con cuánto duró.

Limpiar sesiones imposibles

Los datos reales tienen ruido. A veces un evento se pierde (el sensor falla) y queda una “sesión” de duración negativa o de varios días. Las descartamos:

sessions <- sessions |>
  filter(
    duracion_min > 0,      # nada de duraciones negativas o cero
    duracion_horas < 24    # descarta paseos "de más de un día" (evento perdido)
  )

Por fin: el histograma “¿cuánto tiempo pasa fuera?”

Un histograma divide una variable numérica en tramos y cuenta cuántos datos caen en cada uno. Es el gráfico para ver la forma de una distribución: ¿la mayoría de los paseos son cortos? ¿hay algunos larguísimos?

library(ggplot2)

ggplot(sessions, aes(x = duracion_min)) +
  geom_histogram(binwidth = 15) +   # tramos de 15 minutos
  labs(
    title = "¿Cuánto tiempo pasa Pépito fuera?",
    x = "Minutos fuera",
    y = "Número de salidas"
  ) +
  theme_minimal()

• aes(x = duracion_min) — la variable que queremos distribuir. Solo X; el Y (el conteo) lo calcula el histograma.
• geom_histogram(binwidth = 15) — agrupa en tramos de 15 minutos. El ancho del tramo lo eliges tú con binwidth.

Vas a ver una distribución con una cola larga: muchísimos paseos cortos y unos pocos muy largos. Eso aplasta el gráfico hacia la izquierda.

Domando la cola larga con escala logarítmica

Cuando hay pocos valores enormes y muchos pequeños, una escala logarítmica en el eje X reparte mejor el espacio y deja ver la forma real:

ggplot(sessions, aes(x = duracion_min)) +
  geom_histogram(bins = 40) +
  scale_x_log10() +
  labs(
    title = "Duración de las salidas (escala log)",
    x = "Minutos fuera (log)",
    y = "Salidas"
  ) +
  theme_minimal()

La capa nueva es scale_x_log10(): comprime el eje X de forma logarítmica. Ahora la distribución se ve como una “campana” mucho más legible, y se nota la duración típica de un paseo.

Densidad: entradas vs. salidas a lo largo del día

Una curva de densidad es como un histograma “suavizado”: en vez de barras, una curva continua que muestra dónde se concentran los datos. Sirve muy bien para comparar dos grupos. Volvamos a pepito_df para comparar a qué horas sale y a qué horas entra:

ggplot(pepito_df, aes(x = hour, fill = way)) +
  geom_density(alpha = 0.5) +
  scale_x_continuous(breaks = seq(0, 24, 2)) +
  labs(
    title = "Distribución horaria: entradas vs salidas",
    x = "Hora del día",
    y = "Densidad",
    fill = "Sentido"
  ) +
  theme_minimal()

Dos detalles nuevos:

• geom_density(alpha = 0.5) — dibuja una curva por cada valor de way. alpha = 0.5 la hace medio transparente, para que se vean las dos curvas aunque se solapen. alpha va de 0 (invisible) a 1 (opaco) y va fuera de aes(), porque es un valor fijo.
• scale_x_continuous(breaks = seq(0, 24, 2)) — marcas cada 2 horas. seq(0, 24, 2) genera la secuencia 0, 2, 4, …, 24.

Las dos curvas revelan el patrón: las salidas se concentran en ciertas horas y las entradas en otras, un poco más tarde.

Un vistazo numérico con summary()

Antes de seguir, conviene mirar los números crudos. summary() da un resumen rápido de cada columna:

summary(sessions)

Te muestra el mínimo, máximo, promedio y la mediana de duracion_min. Mira la mediana: suele ser mucho menor que el promedio, justo porque la cola larga estira el promedio hacia arriba. Por eso, para “el tiempo típico fuera”, la mediana es más honesta que el promedio — algo que usaremos en el mapa de calor final.

Ejercicio

library(dplyr)
library(ggplot2)

# 1–3. Construir y limpiar sesiones
pepito_df <- pepito_df |> arrange(datetime_fr)

sessions <- pepito_df |>
  mutate(next_way = lead(way), next_time = lead(datetime_fr)) |>
  filter(way == "out", next_way == "in") |>
  mutate(
    duracion_min   = as.numeric(difftime(next_time, datetime_fr, units = "mins")),
    duracion_horas = duracion_min / 60,
    salida  = datetime_fr,
    entrada = next_time
  ) |>
  select(salida, entrada, duracion_min, duracion_horas) |>
  filter(duracion_min > 0, duracion_horas < 24)

# 4. Histograma normal
ggplot(sessions, aes(x = duracion_min)) +
  geom_histogram(binwidth = 15) +
  labs(title = "¿Cuánto tiempo pasa Pépito fuera?",
       x = "Minutos fuera", y = "Número de salidas") +
  theme_minimal()

# 5. Con escala logarítmica
ggplot(sessions, aes(x = duracion_min)) +
  geom_histogram(bins = 40) +
  scale_x_log10() +
  labs(title = "Duración de las salidas (escala log)",
       x = "Minutos fuera (log)", y = "Salidas") +
  theme_minimal()

# 6. Resumen
summary(sessions)

El objetivo del módulo

Con casi 14 años de datos, la pregunta natural es: ¿cambió la rutina de Pépito con el tiempo? ¿Sale más o menos que antes? ¿Influye la estación del año? En este módulo aprendemos dos herramientas: geom_smooth() (líneas de tendencia) y cómo dibujar varias líneas a la vez usando el color para distinguir grupos.

La tendencia general con geom_smooth()

Si dibujáramos un punto por cada salida (miles de puntos), veríamos una nube imposible de leer. geom_smooth() resuelve esto: traza una curva suave que sigue la tendencia general entre tanto punto.

library(ggplot2)

ggplot(sessions, aes(x = salida, y = duracion_min)) +
  geom_smooth() +
  scale_y_log10() +
  labs(
    title = "Tendencia del tiempo fuera (2011–2024)",
    x = "Fecha",
    y = "Minutos fuera (log)"
  ) +
  theme_minimal()

• aes(x = salida, y = duracion_min) — la fecha de salida contra la duración.
• geom_smooth() — calcula y dibuja la curva de tendencia, con una banda gris alrededor que indica la incertidumbre (cuán segura es la curva en cada punto).
• scale_y_log10() — otra vez, por la cola larga de las duraciones.

La curva te dice, de un vistazo, si la duración típica de los paseos sube, baja o se mantiene a lo largo de los años.

Preparar las estaciones del año

Ahora la pregunta estacional. Necesitamos clasificar cada salida según la estación. Como Pépito vive en el hemisferio norte, los meses de verano son junio–agosto. Para crear la columna usamos case_when(), que es como un “si esto, entonces aquello”:

library(dplyr)
library(lubridate)

sessions <- sessions |>
  mutate(
    anio = year(salida),
    estacion = case_when(
      month(salida) %in% c(12, 1, 2) ~ "Invierno",
      month(salida) %in% 3:5         ~ "Primavera",
      month(salida) %in% 6:8         ~ "Verano",
      TRUE                           ~ "Otoño"
    )
  )

Entendamos case_when():

• Cada línea tiene la forma condición ~ valor. Se lee: “si se cumple la condición, asigna este valor”.
• month(salida) %in% c(12, 1, 2) — “si el mes es diciembre, enero o febrero”. El operador %in% pregunta “¿está dentro de esta lista?”.
• 3:5 es la forma corta de c(3, 4, 5) (marzo a mayo).
• TRUE ~ "Otoño" — la última línea es el “para todo lo demás”. Como TRUE siempre se cumple, atrapa cualquier caso que no haya calzado antes (los meses 9, 10, 11).

Resumir por año y estación

Queremos un valor por cada combinación de año y estación: la mediana de minutos fuera. Aquí entra el dúo group_by() + summarise(), una de las parejas más usadas de dplyr:

resumen <- sessions |>
  group_by(anio, estacion) |>
  summarise(mediana = median(duracion_min), .groups = "drop")

• group_by(anio, estacion) — divide la tabla en grupos, uno por cada combinación de año y estación.
• summarise(mediana = median(duracion_min)) — para cada grupo, calcula la mediana y la guarda en una columna nueva, mediana. Usamos la mediana (y no el promedio) por lo que vimos en el módulo 8: resiste mejor las salidas extremas.
• .groups = "drop" — desagrupa la tabla al terminar. Si lo omites, dplyr te deja la tabla agrupada y te muestra un mensaje algo confuso. Ponerlo es una buena costumbre.

Varias líneas en un gráfico con color

Ahora dibujamos una línea por estación, todas en el mismo gráfico, distinguidas por color:

library(ggplot2)

resumen |>
  ggplot(aes(x = anio, y = mediana, color = estacion)) +
  geom_line(linewidth = 1) +
  geom_point() +
  labs(
    title = "Mediana de minutos fuera por estación y año",
    x = "Año",
    y = "Minutos fuera (mediana)",
    color = "Estación"
  ) +
  theme_minimal()

La clave está en color = estacion dentro de aes(): le decimos a ggplot2 “dibuja una línea distinta para cada estación y dales colores diferentes”. ggplot2 separa los datos por estación, dibuja una línea para cada una y agrega la leyenda automáticamente.

• geom_line(linewidth = 1) — las líneas, un poco más gruesas (linewidth controla el grosor).
• geom_point() — puntos sobre cada año, para marcar los valores reales.

Toques opcionales: etiquetar cada curva al final

Una leyenda obliga al lector a “ir y volver” entre las líneas y el recuadro de colores. Una alternativa más elegante es escribir el nombre de cada estación al final de su línea y quitar la leyenda. Lo hacemos en tres pasos.

Paso 1 — quedarnos con el último punto de cada estación. Para colocar la etiqueta al final, necesitamos saber dónde termina cada línea (su último año):

ultimos <- resumen |>
  group_by(estacion) |>
  filter(anio == max(anio)) |>
  ungroup()

group_by(estacion) agrupa por estación y filter(anio == max(anio)) deja, dentro de cada grupo, solo la fila del año más reciente. El resultado, ultimos, tiene una fila por estación: justo donde irá cada etiqueta.

Paso 2 — dibujar las etiquetas y quitar la leyenda:

resumen |>
  ggplot(aes(x = anio, y = mediana, color = estacion)) +
  geom_line(linewidth = 1) +
  geom_point() +
  geom_text(
    data = ultimos,
    aes(label = estacion),
    hjust = 0, nudge_x = 0.2,
    fontface = "bold", show.legend = FALSE
  ) +
  scale_x_continuous(expand = expansion(mult = c(0.02, 0.15))) +
  labs(title = "Mediana de minutos fuera por estación y año",
       x = "Año", y = "Minutos fuera (mediana)") +
  theme_minimal() +
  theme(legend.position = "none")

Lo nuevo, línea por línea:

• geom_text(data = ultimos, ...) — dibuja texto usando otra tabla (ultimos), no la del ggplot(). Esto es muy útil: cada capa puede tener sus propios datos. Como ultimos también tiene color = estacion, cada etiqueta sale del color de su línea.
• hjust = 0, nudge_x = 0.2 — alinea el texto a la izquierda y lo empuja un poco a la derecha, para que quede después del último punto y no encima.
• scale_x_continuous(expand = expansion(mult = c(0.02, 0.15))) — agranda el margen derecho del eje (un 15%) para que quepan las etiquetas. Sin esto, los nombres se cortan en el borde.
• theme(legend.position = "none") — quita la leyenda: ya no hace falta, porque cada línea está rotulada.

Un detalle con estos datos: en el último año las cuatro estaciones terminan muy cerca (todas con valores bajos, porque 2024 está incompleto), así que con geom_text los nombres se encimarían y se cortarían. La solución es ggrepel, que separa las etiquetas automáticamente.

Paso 3 — separar las etiquetas con ggrepel:

# pak::pak("ggrepel")   # instalar una vez
library(ggrepel)

resumen |>
  ggplot(aes(x = anio, y = mediana, color = estacion)) +
  geom_line(linewidth = 1) +
  geom_point() +
  geom_text_repel(
    data = ultimos, aes(label = estacion),
    hjust = 0, nudge_x = 0.8, direction = "y",
    box.padding = 0.5, min.segment.length = 0,
    segment.color = "grey70", segment.size = 0.3,
    max.overlaps = Inf, fontface = "bold", show.legend = FALSE
  ) +
  scale_x_continuous(expand = expansion(mult = c(0.02, 0.28))) +
  coord_cartesian(clip = "off") +
  labs(title = "Mediana de minutos fuera por estación y año",
       x = "Año", y = "Minutos fuera (mediana)") +
  theme_minimal() +
  theme(legend.position = "none",
        plot.margin = margin(6, 20, 6, 6))

Detalle por detalle, lo que hace que no se encimen:

• nudge_x = 0.8 + direction = "y" — empuja los nombres bien a la derecha y los separa solo en vertical.
• box.padding = 0.5 — exige más espacio alrededor de cada texto, así Otoño e Invierno (que en 2024 quedan casi a la misma altura) se apartan.
• min.segment.length = 0 + segment.color = "grey70" — dibuja una línea-guía gris desde cada nombre hasta su punto, para que se entienda cuál es cuál aunque queden cerca.
• coord_cartesian(clip = "off") + más expand y plot.margin — permiten que las etiquetas se dibujen en el margen derecho sin cortarse.

scale_color_manual(values = c(
  Invierno  = "#4F9DDE",   # azul frío
  Primavera = "#3FAE5A",   # verde
  Verano    = "#E4572E",   # naranja cálido
  Otoño     = "#E0A106"    # ámbar
))

Ejercicio

library(dplyr)
library(lubridate)
library(ggplot2)

# 1. Tendencia general
ggplot(sessions, aes(x = salida, y = duracion_min)) +
  geom_smooth() +
  scale_y_log10() +
  labs(title = "Tendencia del tiempo fuera (2011–2024)",
       x = "Fecha", y = "Minutos fuera (log)") +
  theme_minimal()

# 2–4. Estaciones
resumen <- sessions |>
  mutate(
    anio = year(salida),
    estacion = case_when(
      month(salida) %in% c(12, 1, 2) ~ "Invierno",
      month(salida) %in% 3:5         ~ "Primavera",
      month(salida) %in% 6:8         ~ "Verano",
      TRUE                           ~ "Otoño"
    )
  ) |>
  group_by(anio, estacion) |>
  summarise(mediana = median(duracion_min), .groups = "drop")

resumen |>
  ggplot(aes(x = anio, y = mediana, color = estacion)) +
  geom_line(linewidth = 1) +
  geom_point() +
  labs(title = "Mediana de minutos fuera por estación y año",
       x = "Año", y = "Minutos fuera (mediana)", color = "Estación") +
  theme_minimal()

# 5. Tendencia lineal
ggplot(sessions, aes(x = salida, y = duracion_min)) +
  geom_smooth(method = "lm") +
  scale_y_log10() +
  theme_minimal()