Introducción a las herramientas del tidyverse

1. Introducción

La ciencia de datos es un campo interdisciplinario que involucra métodos científicos, procesos y sistemas para extraer conocimiento a través del entendimiento de datos en sus distintas formas.

A través de este cuaderno aprenderás a usar el lenguage de programación R, y en específico, las herramientos del tidyverse, para atender distintas tareas de la ciencia de datos.

Así, la mayor parte del material del cuaderno está inspirado en la vasta documentación (libros, papers, repositorios, etc.) elaborada por Hadley Wickham, principal gestor del tidyverse, y por ende, en cada capítulo se incluye un hipervínculo al material original:

• R for Data Science
• Tidy Data.

En específico, el objetivo de este material es dar una visión general sobre las herramientas del tidyverse disponibles para un proyecto de ciencia de datos. A continuación podrás ver un flujo común en este tipo de proyectos:

Veámoslo por pasos:

• Primero, es necesario importar los datos. Esto lo haremos con las primeras herramientas del tidyverse: readr y readxl. Si la data fuese a ser tomada desde otras fuentes, como bases de datos es posible usar librerías como RODBC y DBI.

• Una vez cargada la data, tenemos que colocarla en formato tidy. Es decir, transformarla de tal manera que cada fila sea una observación y que cada columna sea una variable. El hecho de tener los datos en este formato es útil para luchar contra las preguntas que tengamos en mente, y no contra el hecho de tener que poner los datos en un formato adecuado para la ejecución de alguna función. Esta tarea la podemos lograr con librerías como tidyr y dplyr.

• Cuando los datos hayan sido colocados en formato tidy, el siguiente paso es transformarlos. Esta transformación incluye el filtrado de los datos, crear nuevas variales en función de variables existentes y calcular estadística descriptiva. A todo este proceso se le suele llamar data wrangling. Esto se logra con el uso de la misma librería dplyr, apoyada en purrr.

• Una vez que tenemos los datos procesados pasamos a las etapas de visualización y modelamiento, las cuales nos permitirán generar conocimiento.

  • La visualización es una actividad fundamental del ser humano. Una buena visualización te puede mostrar cosas que no esperabas o a su vez, despertar nuevas preguntas. Además nos ayudará a darnos cuenta si es que la pregunta que estamos haciendo es la correcta, o si necesitamos replantear algo. Finalmente, si bien las visualizaciones son útiles, no son escalables debido a que requieren que un humano las interprete. Esto se consigue a través de la librería ggplot2.

  • Los modelos entonces van un paso más allá, al permitirnos responder las preguntas que hayamos planteados. En específico, estos son herramientas matemáticas/computacionales que generalmente escalan bien. Esto se logra a través de la librería tidymodels.

• El último paso del proceso es la comunicación. No importa qué tan bien estén hechos nuestros modelos y visualizaciones si no nos es posible comunicar los resultados. Esto se logra a través de las librerías rmarkdown y knitr.

Cabe notar que, si bien con ayuda de todas estas librerías podemos hacer una gran variedad de cosas, cubrimos con ellas el 80% de tareas de ciencia de datos. En alguno casos nos tendremos que ayudar de herramientas adicionales como sparklyr (para trabajar con Apache Spark) o data.table (para trabajar rápidamente con conjuntos de datos más grandes).

2. Creación de proyectos y Pipes

2.1. Creación de proyectos

El día a día del análisis de datos, si bien requiere que usemos un lenguaje de programación como R, también requiere que usemos otro tipo de herramientas y que estemos presentes en otro tipo de escenarios. Es por ello, que luego de presentar un análisis posiblemente regresemos a R sin recordar lo que estábamos haciendo, dónde estábamos trabajando, e incluso, cuántos proyectos teníamos. Para superar estas barreras es importante realizar dos decisiones:

1. ¿Qué es real sobre nuestro análisis? Es decir, ¿qué es lo que consideramos como el último registro de lo que trabajamos?

• Cuando comenzamos a trabajar con R, es normal que consideremos nuestro ambiente de trabajo (los objetos que se encuentran en la ventana environment de RStudio) como ‘’real’‘, sin embargo, en el largo plazo, estaremos mejor si consideramos nuestros scripts como’‘reales’’. Es decir, nos valdremos únicamente de estos últimos para realizar nuestro trabajo, ya que ellos serán los únicos capaces de replicar exactamente el mismo espacio de trabajo cada vez que utilicemos R. Con el fin de educarnos a nosotros mismos, es conveniente desactivar las opciones para preservar nuestros espacios de trabajo entre sesiones, dentro de Tools -> Global Options en RStudio, como se muestra en la siguiente imagen. Hacer esto es importante para no depender de cálculos que sin darnos cuenta, guardamos únicamente en el ambiente de trabajo.

2. ¿Dónde ‘’vive’’ nuestro análisis?

• En R existe el concepto de directorio de trabajo, el cual es el directorio de nuestra máquina donde R busca los archivos que pedimos cargar, y guarda los archivos que pedimos guardar. Este se muestra sobre la consola como se presenta en la siguiente imagen. Dentro de la consola podemos preguntar por este espacio de trabajo a través de la instrucción getwd(). Adicionalmente, es posible (aunque no recomendable) establecer otra dirección como nuestro directorio de trabajo a través de la instrucción setwd('/direccion/de/mi/proyecto'). Cabe mencionar además como nota que en R los directorios se escriben con “/” y no con “\” (como se hace en Windows), además, en R existen directorios absolutos. Los directorios absolutos apuntan a un lugar específico en la máquina, sin importar nuestro directorio de trabajo (empiezan con “C:”, “\\server” o “/”, dependiendo de nuestro sistema operativo).

Para facilitarnos la vida, RStudio cuenta con proyectos. Este complemento de RStudio nos permite tener todos los archivos asociados con un análisis en el mismo lugar. Para crearlo, basta con navegar a File->New Project y seleccionar las opciones que se muestran en la siguiente imagen (o las que convengan):

Cuando utilizamos proyectos debemos ubicarlos sobre carpetas que podamos encontrar, de lo contrario todo nuestro esfuerzo habrá sido en vano. Finalmente, cuando estemos trabajando sobre nuestro proyecto, R buscará los archivos que le indiquemos sobre este directorio, y de igual manera, guardará todos los resultados en ese mismo directorio.

2.2. Pipes

Un elemento fundamental del tidyverse son los pipes. Estos son símbolos que nos permitirán anidar operaciones, evitando que el código se haga inentendible. Su único requisito de uso es tener instalada la librería magrittr (que se instala por defecto al instalar el tidyverse).

Veamos un ejemplo de uso. Para ello primero cargaremos la librería tidyverse, que nos será de ayuda en todo el ejercicio.

library(tidyverse)

Con la librería cargada, utilizaremos el dataset diamonds incluido en ggplot2.

diamonds <- ggplot2::diamonds

Sobre dicho dataset realizaremos un filtro y un slice (subconjunto) de datos, sin preocuparnos por ahora de los detalles. Para ello utilizaremos un primer método, creando un objeto por cada operación.

diamonds2 <- filter(diamonds, cut=="Ideal", color=="E")
diamonds3 <- slice(diamonds, 1:1000)
diamonds3

Al hacerlo hemos creado un objeto extra llamado diamonds2, del que quizás no necesitemos la información. Para evitarnos esta situación podemos crear un el objeto diamonds3 utilizando funciones anidadas.

diamonds3 <- slice(
  filter(
    diamonds, cut=="Ideal", color=="E"
  ),
  1:1000
)
diamonds3

Este código, a pesar de que evita que creemos el paso extra de diamonds2, puede volverse un poco ilegible. Para evitar esto utilizaremos el operador pipe, tipeado como %>%.

diamonds3 <- diamonds %>% 
  filter(cut=="Ideal", color=="E") %>% 
  slice(1:1000)
diamonds3

Como vemos, el resultado es el mismo. El operador pipe entonces lo que hace es ejecutar la función de la derecha, utilizando como primer argumento el objeto de la izquierda. El hacer operaciones de esta manera es intuitivo, nos permite una fácil lectura sobre el código y evita anidar funciones. Por detrás, la función pipe utiliza el primer método que revisamos.

Dado que el %>% (¡ahora seguro lo lees sin problema!) es una herramienta poderosa, hay que usarla con sabiduría. Por ejemplo, es recomendable no usar estos pipes si hay partes intermedias de las transformaciones que nos pueden ser de utilidad (generalmente sucede cuando existen más de 10 pasos), cuando tenemos múltiples inputs y outputs en cada paso, o cuando la secuencia de pasos no es lineal. En el resto de casos, explotemos esta herramienta sin miedo alguno.

Finalmente, si bien el operador %>% es súmamente útil, existen otros operadores útiles como %<>% y %$% (aunque no sean tan comúnmente usados). El símbolo %<>% es un pipe de asignación que sobreescribe la transformación de la derecha en el objeto de la izquierda; mientras que %$% llama a las variables del dataframe de la izquierda para ejecutar funciones de la derecha que solo reciban vectores.

3. Importar y exportar datos

Esta sección es sencilla pero esencial. En ella aprenderemos a cargar archivos rectangulares en R como tibbles o dataframes (para nuestros propósitos, se usarán ambos términos de manera intercambiable, pero siempre estaremos refiriéndonos a tibbles). Para ello utilizaremos la librería readr (precargada con el tidyverse). Para ello, carguemos el tidyverse.

library(tidyverse)

La mayoría de las funciones de readr buscan importar archivos planos como data frames. Algunas de ellas se detalla a continuación.

• read_csv permite leer archivos separados por comas (,).
• read_csv2 permite leer archivos separados por punto y coma (;).
• read_tsv permite leer archivos separados por tabuladores.
• read_delim permite leer archivos separados por cualquier delimitador que se le especifique.
• read_fwf permite leer archivos con columnas que tienen un ancho específico.
• read_table permite leer archivos con columnas que tienen un ancho específico o que están separadas por un espacio en blanco.

Todas estas funciones tienen una sintaxis similar, así q si conocemos una, las conocemos a todas. Veamos un ejemplo con un archivo csv leído desde una dirección web (GitHub de Daniel Morales).

heights <- read_csv("https://gist.githubusercontent.com/danielmoralesp/650bf482113d05e75f283607637ea11b/raw/71b4ebd2472767662ffbd23fa35ec7ad6f5f92a6/heights.csv")
heights %>% head()

Como se puede notar es bastante sencillo, el primer argumento siempre corresponde a la dirección del archivo (sea que este provenga de la web o de nuestra máquina). Además en este primer argumento también podemos colocar una cadena de texto adecuada.

read_csv("a,b,c
1,2,3
4,5,6")

En ambos casos, la función read_csv lee la primera fila del archivo como nombres de columnas (este comportamiento es modificable a través del argumento col_names).

read_csv("1,2,3\n4,5,6", col_names = FALSE)

Si queremos nombres específicos para las columnas lo haremos con el mismo argumento.

read_csv("1,2,3\n4,5,6", col_names = c("x", "y", "z"))

Además, por defecto se nos imprime en consola la especificación del tipo de columnas que ha inferido en base a los primeros registros del archivo (comportamiento modificable a través del argument show_col_types).

read_csv("https://gist.githubusercontent.com/danielmoralesp/650bf482113d05e75f283607637ea11b/raw/71b4ebd2472767662ffbd23fa35ec7ad6f5f92a6/heights.csv", show_col_types = F)

Si queremos por ejemplo, saltarnos un determinado número de líneas del archivo lo podemos hacer a través del argumento skip.

read_csv("Primer línea
  Segunda línea
  x,y,z
  1,2,3", skip = 2)

O si el archivo tiene comentarios precedidos por algún caracter, las podemos ignorar con el argumento comment.

read_csv("# Mi comentario
  x,y,z
  1,2,3", comment = "#")

Finalmente, si tenemos caracteres particulares para la lectura de datos perdidos, usaremos el argumento na.

read_csv("a,b,c
         1,2,.", na = ".")

Al conocer el funcionamiento de estos argumentos tenemos ya visión sobre el 80% de archivos que usaremos en la vida real. El restante corresponde a argumentos muy específicos de otras funciones, que pueden ser consultados con la función help.

Adicional al importar datos, debemos conocer cómo exportar datos. Esto lo podemos hacer a través de las funciones write_csv, write_tsv y en general, write_delim. Su funcionamiento es muy similar al de las anteriores funciones, salvo que necesita primero el objeto a guardar.

write_delim(heights, "heights.txt", delim = ",")

Es preciso mencionar que al guardar archivos debemos tener mucho cuidado con el delimitador que usemos, ya que esto podría dañar nuestros datos (e.g. cuando hay una columna de nombres con comas y colocamos como separador la coma). Para evitar este problema, lo más usual es usar la función write_rds. Esta guarda nuestro archivo en un formato binario propio de R conocido como RDS. Para cargar archivos de este tipo se utiliza la función read_rds.

write_rds(heights, "heights.rds")
heights <- read_rds("heights.rds")
heights %>% head()

Una alternativa a esta es el uso de la librería feather, la cual guarda un archivo binario que pueden leer varios lenguajes de programación.

library(feather)
write_feather(heights, "heights.feather")
heights <- read_feather("heights.feather")
heights %>% head()

Esta última opción suele ser más rápida que RDS pero no soporta un tipo de dato especial que son las columnas-lista (las cuales son útiles al estimar modelos y realizar procedimientos más complejos sobre nuestros datos).

Finalmente, si deseamos leer datos desde otros formatos existen las siguientes opciones:

• haven para leer archivos de SPSS, Stata y SAS.
• readxl para leer archivos excel.
• DBI junto a backends específicos de bases de datos (RMySQL, RSQLite, RPostgreSQL, etc), la cual permite correr consultas SQL contra una base de datos, y devuelve un data frame.
• jsonlite para archivos json.
• xml2 para archivos xml (revisa el tutorial de purrr).
• rio para otro tipo de datos (revisa su github).

4. Datos en formato tidy

4.1. Introducción

En esta sección aprenderemos a utilizar la librería tidyr (incluida en el tidyverse) para organizar nuestros conjuntos de datos (que vienen en todas las formas y colores) en una estructura tidy (organizada). Si bien esta tarea puede ser la más pesada, y la que toma más tiempo de dedicación, al final dará sus frutos, facilitando la visualización y el modelado de datos. Si quieres conocer acerca del background teórico de este formato, no olvides leer ‘Tidy Data’.

Para que un dataset sea tidy se deben cumplir 3 reglas:

1. Cada variable debe ser una columna.
2. Cada observación debe ser una fila.
3. Cada celda debe contener un valor.

Visualmente, estas reglas se ven como se muestra a continuación.

Las dos principales ventajas de tener los datos en este formato son:

1. Dado que existe uniformidad en la forma en la que los datos se encuentran almacenados, es más fácil trabajar con ellos al unirlos, cruzarlos, visualizarlos, modelarlos, etc.
2. Permite que la naturaleza vectorizada de R brille. Al aplicar distintas funciones podremos llamar más fácilmente a una variable para que sea analizada.

Además de estas ventajas, todas las herramientas del tidyverse están creadas para funcionar con datos en formato tidy.

4.2. Pivote de datos

En la vida real, y pese a que las ventajas de los datos tidy son obvias, por lo general los datos no son almacenados de esta manera, sino que busca facilitar algún uso en particular. Por ello, en algunos análisis, necesitaremos lograr que se cumplan los principios de data tidy, y el primer paso siempre es descubrir qué son variables, y qué son observaciones. Algunas veces esto es fácil y otras, es necesario preguntarle a quien generó los datos porque se pueden dar dos problemas:

• Una variable puede estar dividida en varias columnas.
• Una observación puede estar dividida en varias filas.

Si se sufre de este problema, las principales funciones que usaremos son pivot_longer y pivot_wider.

Pivote de columnas a filas (Pivot Longer)

Cuando los nombres de una columna no son variables, sino valores de una variable tendremos que usar este método. Veamos un ejemplo.

library(tidyverse)
billboard %>% head()

En este dataset los nombres de las columnas representan semanas y no variables. Para convertirlas en filas usaremos la siguiente instrucción, la cual depende principalmente de los argumentos cols (que indica las columnas que pivotaremos), names_to (que indica la variable a la que moveremos los nombres de columna) y values_to (que indica la variable a la que moveremos los valores de la columna).

billboard %>%
 pivot_longer(
   cols = starts_with("wk"),
   names_to = "week",
   values_to = "rank"
 )

Al haber ejecutado la instrucción anterior ya tenemos una variable por columna, y una observación en cada fila. Es decir, hemos creado un dataset más largo, porque tiene más filas (de allí el nombre pivot_longer). A continuación podremos ver un gráfico que nos recordará la ejecución de esta operación.

Pivote de filas a columnas (Pivot Wider)

Esta operación es la opuesta a pivot_longer porque hace los datos más anchos, es decir, incrementa el número de columnas. En este caso, los valores de una fila son variables y no valores de una variable. Veamos un ejemplo.

us_rent_income %>% head()

En este caso, en la columna variable se guardan en realidad dos variables. Para pasar los datos a columnas, usaremos la siguiente función. Esta depende de dos argumentos: names_from (el cual indica la columna con los nombres variable) y values_from (el cual indica la/las columnas con los valores de la variables).

us_rent_income %>%
  pivot_wider(names_from = variable, values_from = c(estimate, moe))

Para no olvidar este comportamiento, nos referiremos a la siguiente imagen.

4.3. Separación y unión

¿Qué sucede si nuestro problema con los datos es que en una variable se han almacenado en realidad dos columnas? En ese caso usaremos la función separate. ¿Y si hay una variable dividida en varias (como un identificador)? En ese caso usaremos la función unite.

Veamos en acción primero a la función separate. Supongamos que tenemos el siguiente dataset.

df <- tibble(x = c("x.y", "x.z", "y.z"))
df

Separemos la primera columna en dos columnas distintas. Para ello especificaremos la variable a separar (col), los nombres de las columnas nuevas (into) y el separador (sep).

df %>% separate(col = x, into = c("A", "B"), sep = "\\.")

¿Ven que es bastante sencillo? Refirámonos a la siguiente imagen cuando no lo recordemos.

Para realizar unión, refirámonos al siguiente ejemplo.

df <- expand_grid(x = c("a", "1"), y = c("b", "2"))
df

Unamos de este dataset las dos primeras columnas. Para ello usaremos la función unite, que depende de los argumentos col (que indica el nombre de la columna resultado) y ... que acepta todas las columnas a incluir en la unión (por defecto esta se hace con el símbolo _, si deseas cambiarlo, usa el argumento sep).

df %>% unite(col = "z", x, y, sep = "-")

Al igual que antes, para no olvidar el funcionamiento de esta función, veremos la siguiente imagen.

4.4. Valores perdidos

Por lo general, los valores perdidos pueden estar expresados de dos maneras: explícita (NA) o implícita (simplemente no aparecen).

Veamos un ejemplo:

stocks <- tibble(
  year   = c(2015, 2015, 2015, 2015, 2016, 2016, 2016),
  qtr    = c(   1,    2,    3,    4,    2,    3,    4),
  return = c(1.88, 0.59, 0.35,   NA, 0.92, 0.17, 2.66)
)
stocks

En este dataset existen dos datos perdidos, el último trimestre del 2015 (que tiene un NA) y el primer trimestre de 2016 (que no aparece en los datos). Así, si quisieramos convertir el dato implícito en explícito, usaremos la función complete, a la cual basta únicamente con especificarle las columnas con todas las posibles combinaciones de datos.

stocks %>% complete(year, qtr)

En este caso, ambos datos perdidos se representan con NA.

Si en cambio, ya tenemos los datos perdidos explícitos, pero queremos llenarlos como el último dato disponible (si los datos vienen de una tabla dinámica en excel por ejemplo), usaremos la función fill, como se muestra a continuación.

treatment <- tibble(person = c("Derrick Whitmore", NA, NA, "Katherine Burke"),
                    treatment = c(1,2,3,1), response = c(7,10,9,4))
treatment

treatment %>% 
  fill(person)

A este procedimiento se le suele llamar llevar la última observación hacia adelante.

4.5. Datos non-tidy

Los datos que no se encuentran en formato tidy no necesariamente será negligidos. En algunos casos es conveniente tener datos en otro formato dado que:

• Algunas representaciones alternativas pueden tener mejor desempeño o ventajas de espacio.
• Áreas especializadas del conocimiento pueden sus propias formas de guardar y procesar los datos.

Si quieres saber más al respecto, visita el post de Jeff Leek.

5. Datos relacionales

6. Transformación de datos

7. Análisis exploratorio de datos

8. Visualización de datos