¿Qué es Tidyverse?

Paquetes y funciones

Flujo de trabajo para el análisis de datos

🌈Tidyverse

Datos: palmerpenguins

• En esta sesión vamos a trabajar con observaciones sobre pingüinos en el archipielago Palmer (Antartida)
• El objetivo del dataset palmerpenguins es proveer muchos datos para hacer ejercicios de manipulación, exploración y análisis de datos.
• Los datos fueron recopilados por Allison Horst y publicados con licencia abierta para su uso.
• Contiene datos sobre especies, islas, largo y profundidad de la cresta, largo de las alas, etc. ?palmerpenguins.

Leyendo datos en R

Fuente: Elaboración propia.

Proyectos y directorios de trabajo

Cuando empiezas a programar para ti mismo:

• Crea un folder dedicado a tu proyecto.
• Inicia un nuevo proyecto de R: File>New Project >Existing Directory
• Se creará un archivo con extensión .RProj.

• El directorio de trabajo se fijará automáticamente.
• Automáticamente se recupera el historial de acciones y los objetos contenidos en el proyecto.
• Es más fácil de reproducir los resultados (path relativo vs. absoluta)

getwd()
setwd()

Estructura de directorios del proyecto

Cada proyecto tiene su propia magia pero yo recomiendo usar la siguiente estructura de directorios:

nombre_proyecto 

├── README.md 
├── codigo 
│ ├── 1_preparacion_datos.Rmd 
│ ├── 2_manipulacion_datos.Rmd 
│ ├── 3_analisis_datos.Rmd 
│ ├── 3_estadistica_descriptiva.Rmd 
│ ├── 4_visualizacion.Rmd 
│ └── lib_func.R 
├── datos 
│ ├── originales 
│ └── procesados 
├── figuras 
└── nombre_proyecto.Rproj

• Nunca guardes los datos manipulados sobre el archivo original.
• Siempre incluye un README.md para saber que es lo que hace este proyecto.

Creación de estructura de directorios de trabajo

Podemos generar la estructura de carpetas directamente desde R:

###########################################################
# Esta función genera una estructura de directorios y
# archivos .Rmd en blanco para comenzar nuestro proyecto. 
#
# El único argumento de entrada es el path. 
###########################################################

plantilla_proyecto <- function(path) {
  # Verificar si el directorio base existe
  if (!dir.exists(path)) {
    stop(paste("El directorio", path, "no existe."))
  }
  
  # Cambiar el directorio de trabajo
  setwd(path)
  
  # Nombre del proyecto
  nombre_proyecto <- "Proyecto_1"
  
  # Crear carpeta principal del proyecto si no existe
  if (!dir.exists(nombre_proyecto)) {
    dir.create(nombre_proyecto)
  }
  
  # Definir estructura de carpetas (sin acentos)
  nombre_subcarpetas <- file.path(nombre_proyecto, c(
    "datos", "codigo", "figuras",    # Carpetas principales
    "datos/original", "datos/procesados" # Subcarpetas
  ))
  
  # Crear todas las carpetas de manera eficiente
  lapply(nombre_subcarpetas, dir.create, recursive = TRUE)
  
  # Crear los archivos dentro de la carpeta "codigo"
  carpeta_codigo <- file.path(nombre_proyecto, "codigo")
  
  # Verificar si la carpeta "codigo" existe antes de crear los archivos
  if (!dir.exists(carpeta_codigo)) {
    stop("La carpeta 'codigo' no existe.")
  }
  
  # Definir nombres de los archivos (sin acentos)
  file_names <- c(
    "1_preparacion_datos",  # Preparación de datos
    "2_manipulacion_datos", # Combinación de datos
    "3_est_descriptiva",    # Descriptivos
    "3_analisis_datos",     # Análisis
    "4_visualizacion"       # Visualización
  )
  
  # Crear las rutas completas para los archivos dentro de "codigo"
  file_paths <- file.path(carpeta_codigo, paste0(file_names, ".Rmd"))
  
  # Crear los archivos
  file.create(file_paths)
  
  # Crear un archivo adicional para funciones auxiliares
  file.create(file.path(carpeta_codigo, "funciones.R"))
  
  message("Estructura del proyecto creada exitosamente.")
}

Función readr()

Para leer/exportar archivos de texto plano en R necesitamos:

• Ubicación de los datos (path).
• delimitador (separador de valores) de los datos p.ej.: ., .``; o |.

Leer archivos de otros formatos

Para importar otros tipos de archivos podemos usar los siguientes paquetes:

• readxl: Archivos en formato MS Excel (Usa Java)
• haven: SPSS, Stata y SAS.
• googlesheets4: Archivos de Google Sheets.
• rvtest: Archivos HTML.

Ejemplo: Importando datos a R

raw_tsv_data <- read_tsv("mi_archivo.tsv")

raw_csv_data <- read_csv("data/original/miarchivo.csv")

# Fuente: https://catalog.data.gov/dataset/electric-vehicle-population-data
electric_vehicles <- read_csv("https://data.wa.gov/api/views/f6w7-q2d2/rows.csv")

Uso de tibbles en 🌈 Tidyverse

• La mayoría de las funciones en Tidyverse producen resultados en objetos denominados tibbles.
• Los tibbles son en escencia similares a los dataframe pero no son lo mismo:
  • Hacen menos cosas:
    • Nunca convierten caracteres en factores.
    • Nunca cambian el nombre de las variables.
    • Nunca asignan nombres a las filas.

Ejemplo de uso de tibbles

• Ejemplos:

# install.packages("tidyverse")
# install.packages("datos")

library(tidyverse)
library(datos)

flores_df <- datos::flores
flores_tbl <- as_tibble(flores)

Uso del paquete dplyr

Uso de filter()

Selecciona filas en un dataframe

• Uso:

filter(nombre_objeto, condición)

• Anteriormente usamos la sintáxis de R base para hacer algo similar:

imdb[imdb$duration_minutes == 132, c(1:13)] # R Base
df <- filter(imdb, duration_minutes == 132) # dplyr

Uso de select()

Seleccionar o descartar columnas en un dataframe.

• Uso:

select(df, col1, col2)  # Selecciona columnas 1-2
select(df, -col3)  # Selecciona todas las columnas menos col3

• Uso de funciones de selección especiales:

select(df, contains("col"))  # Seleccionar columnas que contienen "col"

• Comparativa:

df[,c("nombre", "edad")]  # R Base
select(df, nombre, edad)  # Tidyverse

Uso de la función mutate()

Transforma valores o crea columnas nuevas.

• Uso:

mutate(df, colum_name = operación)

df$nueva_var <- var + 20  # R base
df <- mutate(df, nueva_var = var + 20) # Tidyverse

Uso de la función rename()

La usamos para renombrar columnas existentes.

• Uso:

rename(df, new_col_name = old_col_name)

• Ejemplo:

imdb$duration_minutes <- imdb$duracion_min # R Base
imdb <- rename(imdb, duracion_min = duration_minutes)  # dplyr

El operador pipe

• El símbolo %>% o |> (entonces o después) es un componente que encadena todas las operaciones de manipulación de datos.

• Ventajas:

  • Nuestro código tiene una grámatica más amigable.
  • No es necesario anidar las llamadas a las funciones.
  • Es más sencillo eliminar/agregar operaciones en nuestro flujo de trabajo sin detener el código.

Ejemplo: Uso del operador pipe

# Nombre del objeto que usamos como insumo
imdb_manipulado <- imdb %>% 
  # Filtramos las películas que duran 132 minutos
  filter(duration_minutes == 132) %>% 
  # Conservamos unicamente el nombre, año y ranking
  select(name, year, rank, duration_minutes) %>% 
  # Creamos una nueva variable (year >=2000)
  mutate(siglo21 = ifelse(year >= 2000, 1, 0)) %>% 
  # Renombramos la variable duration_minutes
  rename(duracion_min = duration_minutes)

• Notas:

  • df solo se menciona una vez al principio (seleccionar y guardar resultados de operaciones).
  • El código termina una vez que dejan de existir |> o %>%.

Tidy Data (Datos ordenados)

Fuente: Allison Horst

Definición de datos ordenados

Los conjuntos de datos ordenados son fáciles de manipular, modelar y visualizar, y tienen una estructura específica: cada variable es una columna, cada observación es una fila, y cada tipo de unidad de observación es una fila. (Wickham, 2014)

• Así, los datos ordenados son datos rectangulares:

Formato de datos

• Durante nuestra investigación vamos a encontrar que los datos suelen publicarse en dos formatos o estructuras:
  • Formato ancho (wide) y largo (long)

Datos en formato ancho (wide)

Los datos en formato ancho se caracterizan porque las variables se representan mediante columnas separadas para cada nivel de una variable categórica.

• Esta estructura es útil cuando se desean ver comparaciones entre diferentes categorías.

• Las columnas están “anchas” porque cada materia tiene su propia columna.

Datos en formato largo (long)

En la estructura de datos largos cada observación se representa en una fila separada y las variables se colocan en columnas comunes (p.ej. una para el nombre de la materiay otro para el valor de la calificación).

• Esta estructura es útil para realizar filtrados y agregaciones de datos sobre múltiples dimensiones. (Lenguaje de computadora)

Conversión entre formatos

El paquete tidyr contiene diversas funciones que pueden ser útiles para ordenar y transformar nuestros datos:

• pivot_longer(): Convierte datos en formato ancho a largo. Es útil cuando necesitamos simplificar nuestros datasets para ejercicios de visualización.

• pivot_wider(): Convierte datos en formato largo a ancho. Es útil cuando queremos hacer tablas o comparaciones entre categorías.

Uso de función pivot_longer()

• Sintáxis básica de uso:

pivot_longer(datos, cols,
             names_to = "nombre",
             values_to = "valores", 
             values_drop_na = TRUE)

• Donde:
  • cols: El nombre de las columnas a pivotear de ancho a largo.
  • names_to: El nombre de la nueva columna que guardará los nombres de las variables pivoteadas.
  • values_to: El nombre de la nueva columna que contendrá los valores de las variables.
  • values_drop_na: Descarta los NA.

Ejemplo de uso pivot_longer()

# Encuesta sobre religión y nivel de ingresos
data("relig_income")  #tidyr
relig_income

# Transformación de 
df_long <- relig_income %>% 
  pivot_longer(-religion, 
               names_to = "nivel_ingreso",
               values_to = "conteo")

# Aumentar el grado de complejidad con Billboard List
data("billboard")

df_long <- billboard %>% 
  pivot_longer(
    cols = starts_with("wk"), 
    names_to = "Semana",
    values_to = "Ranking",
    values_drop_na = TRUE
  )

Uso de función pivot_wider()

• Sintáxis básica de uso:

pivot_wider(datos, 
             names_from = "nombre",
             values_from = "valores", 
             values_fill = NA)

• Donde:
  • datos: El conjunto de datos a transformar.
  • names_from: Especifica que valores de las columnas deberán convertirse en los nombres de las columnas en el formato ancho.
  • values_from: La columna que contiene los valores a rellenar en el formato de columnas anchas.
  • values_fill: El valor que se asignará a las observaciones perdidas.

Ejemplo de uso pivot_wider()

# Transformar de datos en formato Long a Wide

data("fish_encounters")

fish_encounters <- fish_encounters %>% 
                      pivot_wider(names_from = station,
                                  values_from = seen)


# No se registra cuando no se vió al pez.
# Podemos intuir que esto es cuando existen NA's

## Completar valores faltantes con 0's

data("fish_encounters")

df_wider <- fish_encounters %>% 
                      pivot_wider(names_from = station,
                                  values_from = seen,
                                  values_fill = list(seen = 0))
View(fish_encounters)
# When missing use 0

Ve al Ejercicio #9

Uso de la función group_by()

• Es útil cuando queremos realizar operaciones en algunos grupos dentro de un conjunto de datos.

• Sintáxis básica:

library(dplyr)

df_agrupado <- df %>%  
                group_by(grupo1, grupo2, ...)

• Donde:
  • df es un conjunto de datos rectangular.
  • grupo1, grupo2,... las columnas a partir de las cuales se quieren agrupar los datos.

Uso de la función summarize()

• Esta función se utiliza para generar resumenes de datos.

• Permite calcular estadísticas descriptivas (promedios, sumas, max, min, etc.) sobre un conjunto de datos agrupado.

• Sintáxis básica de uso:

resumen <- df %>% 
            group_by(categoria) %>% 
            summarize(estadistica = funcion(df_columna))

• Donde:
  • df es un conjunto de datos agrupado con la función group_by().
  • estadistica: El nombre de la columna que contendrá el resumen de los datos.
  • funcion(): Cálculo que deseas aplicar (p.ej. mean(), sum(), max(), etc.)

Ejemplo de uso de funciones group_by() y summarize()

# Datos de ejemplo
datos <- tibble(
  categoria = c("A", "A", "B", "B", "C"),
  valor = c(10, 20, 30, 40, 50)
)

# Calcular resumen sin agrupar
resumen_general <- datos %>%
  summarize(promedio_valor = mean(valor))

# Calcular resumen agrupado
resumen_por_categoria <- datos %>%
  group_by(categoria) %>%
  summarize(
    promedio_valor = mean(valor),
    desvest_valor = sd(valor)
  )

Uniones de datos

• En la práctica las uniones (joins) de datos nos permiten combinar información entre varios conjuntos de datos.
• La única condición que deben cumplir los datos es que tengan al menos una columna en común.
• En R existen diversos tipos de uniones:
  • Unión a la izquierda (left join).
  • Unión a la derecha (right join).
  • Unión completa (full join).
  • Unión interna (inner join).

Unión a la izquierda (left join)

En una unión a la izquierda de dos tablas L y R, la tabla resultante (llamemosla LR) contendrá todos los registros de la tabla L, pero solo los registros de R cuyas claves (ID) estén incluidas en L.

Unión a la derecha (right join)

En una unión a la derecha la tabla final contendrá todas las filas de R, pero sólo aquellas de L que tengan una clave coincidente. Nótese, que es posible reformular una unión a la derecha de L con R como una a la izquierda de R con L.

Unión completa (full join)

En la unión completa, la tabla resultante contendrá todas las filas de L y todas las de R, con independencia de que no exista una clave coincidente.

Uniones de datos usando R {base}

• Para unir tablas de datos usando R {base} podemos usar la función merge().

  • Sintáxis de uso:

merge(
  x = df1
  y = df2,
  by = "var_id"
)

• Donde:
  • df1 y df2 son las tablas de datos que queremos unir.
  • var_id es la variable en común a partir de la que unimos los datos.

Ejemplo de uso función merge()

# Ejemplo datos ensayo clínico

demographics <- data.frame(
  id = c("P1", "P2", "P3"),
  age = c(40, 54, 47),
  country = c("GER", "JPN", "BRA"),
  stringsAsFactors = FALSE
)
adverse_events <- data.frame(
  id = c("P1", "P1", "P3", "P4"),
  term = c("Headache", "Neutropenia", "Constipation", "Tachycardia"),
  onset_date = c("2020-12-03", "2021-01-03", "2020-11-29", "2021-01-27"),
  stringsAsFactors = FALSE
)

Ejemplo de uso función merge()

# Ejemplo Unión por la izquierda all.y (derecha)

df_merge <- merge(
  x = demographics,
  y = adverse_events,
  by = "id",
  all.x = TRUE
)

df_merge

# Ejemplo Unión completa

df_merge <- merge(
  x = demographics,
  y = adverse_events,
  by = "id",
  all = TRUE
)

df_merge

Ejemplo de uniones usando dplyr

• En dplyr tenemos una función (verbo) para cada tipo de unión:
  • left_join().
  • right_join().
  • inner_join().
  • full_join().

# Ejemplo de uniones usando dplyr
library(dplyr)
left_join(demographics, adverse_events, by = "id")
inner_join(demographics, adverse_events, by = "id")
full_join(demographics, adverse_events, by = "id")

Ejemplo de unión con dplyr

• En caso de que el nombre de las variables ID de las dos tablas no coincida, tendrás que pasar un vector nombrado como argumento de by.

• Nombre y valor corresponden con la clave en la primera y segunda tabla, respectivamente.

right_join(demographics, adverse_events2, by = c("id" = "pat_id"))