02-manipulacion.Rmd

# Manipulación y agrupación de datos

En esta sección continuamos con la introducción a R para análisis de datos, 
en particular mostraremos herramientas de manipulación y transformación de 
datos. Trataremos los siguientes puntos:

* Transformación de datos.

* Estrategia separa-aplica-combina.

* Reestructura de datos y el principio de los datos limpios.

Es sabido que limpieza y preparación de datos ocupan gran parte del tiempo del 
análisis de datos ([Dasu y Johnson, 2003](http://onlinelibrary.wiley.com/book/10.1002/0471448354) 
y [NYT's ‘Janitor Work’ Is Key Hurdle to Insights](https://www.nytimes.com/2014/08/18/technology/for-big-data-scientists-hurdle-to-insights-is-janitor-work.html?mcubz=0)),
es por ello que vale la pena dedicar un tiempo a aprender técnicas que faciliten 
estas tareas, y entender que estructura en los datos es más conveniente para 
trabajar.

## Transformación de datos

Es sorprendente que una gran variedad de necesidades de transformación de datos
se pueden resolver con pocas funciones, en esta sección veremos 5 *verbos* que 
fueron diseñados para la tarea de transformación de datos y que comparten una 
filosofía en cuanto a su estructura. Estudiaremos las siguientes funciones:

* **filter**: obten un subconjunto de las filas de acuerdo a un criterio.
* **select**: selecciona columnas de acuerdo al nombre
* **arrange**: reordena las filas
* **mutate**: agrega nuevas variables
* **summarise**: reduce variables a valores (crear nuevas bases de datos con 
resúmenes de variables de la base original)

Estas funciones trabajan de manera similar, el primer argumento que reciben 
es un `data.frame`, los argumentos que siguen indican que operación se va a 
efectuar y el resultado es un nuevo `data.frame`.

Adicionalmente, se pueden usar con `group_by()` que veremos más adelante y que 
cambia el dominio de cada función, pasando de operar en el conjunto de datos
completos a operar en grupos.

### Datos {-}

Usaremos datos de población municipal incluidos en el paquete `mxmaps` y 
datos de educación, situación conyugal y hogar incluídos en el `estcomp`,
para tener acceso a ellos cargamos los paquetes correspondientes.

```{r}
library(tidyverse, warn.conflicts = FALSE, quietly = TRUE)
library(mxmaps)
library(estcomp)
```

Una alternatica a instalar `mxmaps` es leer únicamente los datos, se descargan 
del repositorio de GitHub y se cargan con la función `load()`.

```{r descargar_df_mun, eval=FALSE}
download.file("https://github.com/diegovalle/mxmaps/blob/master/data/df_mxmunicipio.RData?raw=true", "df_mxmunicipio.RData")
load("df_mxmunicipio.RData")
```

Observemos la estructura de los datos:

```{r}
df_mxmunicipio <- as_tibble(df_mxmunicipio)
glimpse(df_mxmunicipio)
glimpse(df_edu)
```

### Filtrar {-}

Creamos una tabla de datos de juguete para mostrar el funcionamiento de cada
instrucción:

```{r}
df_ej <- tibble(sexo = c("mujer", "hombre", "mujer", "mujer", "hombre"), 
  estatura = c(1.65, 1.80, 1.70, 1.60, 1.67))
df_ej
```

El primer argumento de `filter()` es el nombre del `data frame`, los 
subsecuentes son las expresiones que indican que filas filtrar.

```{r}
filter(df_ej, sexo == "mujer")
filter(df_ej, estatura > 1.65 & estatura < 1.75)
```

Algunos operadores importantes para filtrar son:  

```{r, eval = FALSE}
x > 1
x >= 1
x < 1
x <= 1
x != 1
x == 1
x %in% c("a", "b")
```


![](img/manicule2.jpg) Crea un subconjunto de los datos `df_mxmunicipio` que 
contenga únicamente los municipios de la CDMX (`state_abbr` es `CDMX`)

* Los municipios de Nuevo León con más de 200,000 habitantes.

* Los municipios donde más de la mitad la población se autoidentifica como
afromexicana o parte afromexicana.

```{r, echo=FALSE, eval=FALSE}
filter(df_mxmunicipio, state_abbr == "CDMX")

filter(df_mxmunicipio, state_abbr == "NL", pop > 200000)

filter(df_mxmunicipio, pop / 2 < sum(afromexican, part_afromexican))
```

#### Observación `==` y operadores booleanos {-}

Debemos tener cuidado al usar `==`, ¿qué devuelven las siguientes expresiones?

```{r, eval = FALSE}
sqrt(2) ^ 2 == 2
1/49 * 49 == 1
```

Los resultados de arriba se deben a que las computadoras 
usan aritmética de precisión finita:

```{r}
print(1/49 * 49, digits = 22)
```

Para estos casos es útil usar la función `near()`

```{r}
near(sqrt(2) ^ 2,  2)
near(1 / 49 * 49, 1)
```

Los **operadores booleanos** también son convenientes para filtrar:

```{r, eval = FALSE}
# Conjuntos
a | b # a o b
a & b # a y b 
a & !b # a y no-b
xor(a, b)
```

El siguiente esquema nos ayuda a entender que hace cada operación, `x` está 
representada por el círculo del lado izquierdo y `y` por el círculo del lado
derecho, la parte sombreada muestra las regiones que selecciona el operador:

```{r, out.width = "400px",echo = FALSE, fig.cap= "Operaciones booleanas, imagen del libro [r4ds](https://r4ds.had.co.nz/)."}
knitr::include_graphics("img/transform-logical.png")
```


#### Observación: faltantes `NA` {-}

Un caso común es cuando se desea eliminar o localizar los registros con
faltantes en una o más columnas de las tablas de datos, en R los datos faltantes
se expresan como `NA`, para seleccionar los registros con faltante en la 
variable `schoolyrs` de los datos `df_edu` resulta natural escribir:

```{r}
filter(df_edu, schoolyrs == NA)
```

Y para eliminarlos

```{r}
filter(df_edu, schoolyrs != NA)
```

en ambos casos nos devuelve una tabla vacía! 

El problema resulta de usar los operadores `==` y `!=`, pensemos ¿qué regresan 
las siguientes expresiones?

```{r, eval = FALSE}
5 + NA
NA / 2
sum(c(5, 4, NA))
mean(c(5, 4,  NA))
NA < 3
NA == 3
NA == NA
```

Las expresiones anteriores regresan `NA`, el hecho que la media de un vector 
que incluye `NA`s o su suma regrese `NA`s se debe a que por defecto en R se 
propagan los valores faltantes, esto es, si deconozco el valor de una de las 
componentes de un vector, también desconozco la suma del mismo; sin embargo, 
muchas funciones tienen un argumento _na.rm_ para eliminarlos,

```{r}
sum(c(5, 4, NA), na.rm = TRUE)
mean(c(5, 4, NA), na.rm = TRUE)
```

Aún queda pendiente como filtrarlos en una tabla, para esto veamos que el 
manejo de datos faltantes en R utiliza una lógica ternaria (como SQL):

```{r}
NA == NA
```

La expresión anterior puede resultar confusa, una manera de pensar en esto es
considerar los NA como *no sé*, por ejemplo si no se la edad de Juan y no se la 
edad de Esteban, la respuesta a ¿Juan tiene la misma edad que Esteban? es 
*no sé* (NA).

```{r}
edad_Juan <- NA
edad_Esteban <- NA
edad_Juan == edad_Esteban
edad_Jose <- 32
# Juan es menor que José?
edad_Juan < edad_Jose
```

Por tanto para determinar si un valor es faltante usamos la instrucción 
`is.na()`.

```{r}
is.na(NA)
```

Y finalmente podemos filtrar,

```{r, eval=FALSE}
filter(df_edu, is.na(schoolyrs))
```

### Seleccionar {-}

Elegir columnas de un conjunto de datos.

```{r}
df_ej
select(df_ej, sexo)
select(df_ej, -sexo)
```

```{r, eval = FALSE}
select(df_ej, starts_with("s"))
select(df_ej, contains("x"))
```

![](img/manicule2.jpg) Ve la ayuda de select (`?select`) y escribe tres
maneras de seleccionar las variables del estado en los datos `df_mxmunicipio`.

```{r, eval=FALSE, echo=FALSE}
select(df_mxmunicipio, contains("state"))
select(df_mxmunicipio, starts_with("state"))
select(df_mxmunicipio, 1, 4:6)
```


### Ordenar {-}

Ordenar de acuerdo al valor de una o más variables:

```{r}
arrange(df_ej, sexo)
arrange(df_ej, desc(estatura))
```

![](img/manicule2.jpg) Ordena los municipios por población, de mayor a
menor.

```{r, eval = FALSE, echo = FALSE}
arrange(select(df_mxmunicipio, municipio_name, pop), desc(pop))
```


* ¿Cuáles son los municipios con mayor disparidad de sexo (a total)?

```{r, eval = FALSE, echo = FALSE}
arrange(select(df_mxmunicipio, state_abbr, municipio_name, pop_male, pop_female), -abs(pop_male - pop_female))
```

* ¿Cuáles son los municipios con mayor disparidad de sexo (proporcional)?, 
elimina los municipios con menos de 5000 habitantes y repite.

```{r, eval = FALSE, echo = FALSE}
arrange(select(df_mxmunicipio, state_abbr, municipio_name, pop_male, pop_female, pop), -abs((pop_male - pop_female) / pop))
arrange(filter(df_mxmunicipio, pop > 5000), -abs((pop_male - pop_female) / pop))
```

### Mutar {-}

Mutar consiste en crear nuevas variables aplicando una función a columnas 
existentes:

```{r}
mutate(df_ej, estatura_cm = estatura * 100) 
mutate(df_ej, estatura_cm = estatura * 100, estatura_in = estatura_cm * 0.3937) 
```

![](img/manicule2.jpg) Calcula el porcentaje de población indígena de cada
municipio y almacenalo en una nueva variable.

```{r, eval = FALSE, echo = FALSE}
mutate(df_mxmunicipio, indigenous_prop = indigenous / pop)
```

* Crea una nueva variable que muestre el cociente entre la población femenina y
masculina.

```{r, eval = FALSE, echo = FALSE}
mutate(df_mxmunicipio, female_male_quotient = pop_female / pop_male, 
    female_male_pct = 100 * female_male_quotient)
```

Hay muchas funciones que podemos usar para crear nuevas variables con `mutate()`, éstas deben cumplir ser funciones vectorizadas, es decir, reciben un vector de valores y devuelven un vector de la misma dimensión, por ejemplo
multiplicar columnas o por un escalar.

![](img/manicule2.jpg) ¿Cuáles de las siguientes funciones son adecuadas para
`mutate()`? Notar que hay escenarios en los que nos puede interesar usar funciones no vectorizadas con `mutate()` pero vale la pena entender que es lo
que regresan.  
    * mean, pmin, max, `*`, `^`, quantile


```{r, eval = FALSE}
df_ej_2 <- add_column(df_ej, peso_actual = c(60, 80, 70, 50, 65), 
    peso_anterior = c(66, 78, 73, 54, 61))

mutate(df_ej_2, peso_medio = mean(c(peso_actual, peso_anterior)))
mutate(df_ej_2, peso_menor = pmin(peso_actual, peso_anterior))
mutate(df_ej_2, peso_mayor = max(peso_actual, peso_anterior))
mutate(df_ej_2, estatura_sq = estatura ^ 2, bmi = peso_actual / estatura_sq)
```


### Summarise y resúmenes por grupo  {-}

Summarise sirve para crear nuevas bases de datos con resúmenes o agregaciones de los datos originales.

```{r}
summarise(df_ej, promedio = mean(estatura))
```

![](img/manicule2.jpg) Calcula la población total, indígena y afromexicana a 
total.

```{r}
summarise(df_mxmunicipio, indigeonous = sum(indigenous), 
    afromexican = sum(afromexican))
```

La mayor utlidad de `summarise` es cuando la combinamos con una variable de 
agrupación y esta combinación es la estrategia separa-aplica combina.

#### Separa-aplica-combina (_split-apply-combine_) {-}

Muchos problemas de análisis de datos involucran la aplicación de la estrategia
separa-aplica-combina [@plyr], esta consiste en romper un problema en pedazos
(de acuerdo a una variable de interés), operar sobre cada subconjunto de manera
independiente (ej. calcular la media de cada grupo, ordenar observaciones por 
grupo, estandarizar por grupo) y después unir los pedazos nuevamente. El 
siguiente diagrama ejemplifiaca el paradigma de divide-aplica-combina:

* **Separa** la base de datos original.  
* **Aplica** funciones a cada subconjunto.  
* **Combina** los resultados en una nueva base de datos.

```{r, out.width = "500px",echo = FALSE, fig.cap= "Imagen de [Software Carpentry](https://swcarpentry.github.io/r-novice-gapminder/fig/12-plyr-fig1.png) con licencia [CC-BY 4.0](https://swcarpentry.github.io/r-novice-gapminder/LICENSE.html)."}
knitr::include_graphics("img/split-apply-combine.png")
```

Ahora, cuando pensamos como implementar la estrategia divide-aplica-combina es 
natural pensar en iteraciones, por ejemplo utilizar un ciclo `for` para recorrer cada grupo de interés y aplicar las funciones resumen, sin embargo la aplicación
de ciclos `for` desemboca en código difícil de entender por lo que preferimos 
trabajar con funciones creadas para estas tareas, usaremos el paquete 
`dplyr` que además de ser más claro suele ser más veloz.

Podemos hacer resúmenes por grupo, primero creamos una base de datos agrupada:

```{r}
by_sexo <- group_by(df_ej, sexo)
by_sexo
```

y después operamos sobre cada grupo, creando un resumen a nivel grupo y uniendo
los subconjuntos en una base nueva:

```{r, eval = FALSE, echo = FALSE}
summarise(by_sexo, promedio = mean(estatura))
```

![](img/manicule2.jpg) Calcula la población total por estado.

```{r, eval = FALSE, echo = FALSE}
by_state <- group_by(df_mxmunicipio, state_abbr)
summarise(by_state, pop = sum(pop), indigenous = sum(indigenous), 
    afromexican = sum(afromexican))
```

* Calcula la población indígena y afromexicana por estado.

```{r, eval = FALSE, echo = FALSE}
by_state <- group_by(df_mxmunicipio, state_abbr)
summarise(by_state, pop = sum(pop), indigenous = sum(indigenous), 
    afromexican = sum(afromexican))
```

* ¿Qué otros resúmenes puedes hacer para explorar los datos?


Algunas funciones útiles con _summarise_ son min(x), median(x), max(x), 
quantile(x, p), n(), sum(x), sum(x > 1), mean(x > 1), sd(x).

Por ejemplo, para cada área metropolitana: cuántos municipios engloba (`n()`), 
la población total (`sum()`) y al estado al que pertenece (`first()`).

```{r}
by_metro_area <- group_by(df_mxmunicipio, metro_area)
no_miss <- filter(by_metro_area, !is.na(metro_area))
pop_metro_area <- summarise(no_miss, state = first(state_abbr), 
    n_municipios = n(), pop_total = sum(pop))
head(pop_metro_area)
```


#### Operador pipeline {-}

En R, cuando uno hace varias operaciones es difícil leer y entender el 
código: 

```{r}
library(estcomp)

summarise(group_by(filter(election_2012, !is.na(section_type)), region,
    section_type), n = n(), pri_pvem = sum(pri_pvem), 
    prd_pt_mc = sum(prd_pt_mc), pan = sum(pan))
```

La dificultad radica en que usualmente los parámetros se asignan después del 
nombre de la función usando (). 

Una alternativa es ir almacenando las salidas en tablas de datos intermedias
pero esto resulta poco práctico porque: 1) almacenamos en el mismo objeto 
sobreescribiendo ó 2) terminamos con muchos objetos con nombres poco
significativos.

El operador *Forward Pipe* (`%>%`) cambia el orden en que se asignan los 
parámetros, de manera que un parámetro que precede a la función es enviado
("piped")  a la función:

* `x %>% f(y)` se vuelve `f(x, y)`,   
* `x %>% f(y) %>% g(z)` se vuelve `g(f(x, y), z)`. 

Es así que podemos reescribir el código para poder leer las 
operaciones que vamos aplicando de izquierda a derecha y de arriba hacia abajo.

Veamos como cambia el código del ejemplo:

```{r}
election_2012 %>% 
    filter(!is.na(section_type)) %>% 
    group_by(region, section_type) %>% 
    summarise(
        n = n(), 
        pri_pvem = sum(pri_pvem), 
        prd_pt_mc = sum(prd_pt_mc), 
        pan = sum(pan)
        ) 
```

podemos leer %>% como "_después_".

**Tip:** Un atajo para producir el operador pipeline `%>%` es 
shift + ctrl/cmd + M 

![](img/manicule2.jpg) Siguiendo con los datos `election_2012`, ¿Qué estados
tienen la mayor participación (esto es del total de votantes en la lista nominal
que porcentaje asistió a votar)? Tip: debes eliminar las casillas especiales  pues la lista nominal (`ln`) no está definida.

```{r, echo=FALSE, eval=FALSE}
election_2012 %>% 
    filter(polling_type != "S") %>% 
    group_by(state_abbr) %>% 
    summarise(
        n = n(), 
        total = sum(total), 
        nominal_list = sum(nominal_list)
        ) %>% 
    mutate(part = 100 * total / nominal_list) %>% 
    arrange(desc(part))
```

### Variables por grupo {-}

En ocasiones es conveniente crear variables por grupo, por ejemplo estandarizar
dentro de cada grupo z = (x - mean(x)) / sd(x). Para esto usamos `group_by()`
y `mutate()`.

Veamos un ejemplo:

```{r}
z_prd_pt_mc_state <- election_2012 %>%
    filter(total > 50, !is.na(section_type)) %>% 
    mutate(prd_pt_mc_pct = prd_pt_mc / total) %>% 
    group_by(state_abbr) %>% 
    mutate(
        n = n(),
        sd_prd_pt_mc = sd(prd_pt_mc_pct),
        mean_prd_pt_mc = mean(prd_pt_mc_pct),
        z_prd_pt_mc = (prd_pt_mc_pct - mean_prd_pt_mc) / sd_prd_pt_mc 
    )
```

### Verbos de dos tablas {-}

Muchas veces debemos reunir información que está almacenada a lo largo de 
muchas tablas, por ejemplo, si nos interesa conocer como se relaciona el año de 
escolaridad promedio (`schoolyrs` en el `df_edu`) con el porcentaje de
población indígena (`indigenous` en `df_mxmunicipios`), debemos poder *pegar*
las dos tablas.

Hay varias maneras de unir dos bases de datos y debemos pensar en el 
obejtivo:

```{r}
x <- tibble(name = c("John", "Paul", "George", "Ringo", "Stuart", "Pete"),
  instrument = c("guitar", "bass", "guitar", "drums", "bass",
     "drums"))

y <- tibble(name = c("John", "Paul", "George", "Ringo", "Brian"),
  band = c("TRUE", "TRUE", "TRUE",  "TRUE", "FALSE"))
x
y

inner_join(x, y)
left_join(x, y)
semi_join(x, y)
anti_join(x, y)
```

Resumamos lo que observamos arriba:

<div class="mi-tabla">
Tipo | Acción
-----|-------
inner|Incluye únicamente las filas que aparecen tanto en x como en y
left |Incluye todas las filas en x y las filas de y que coincidan
semi |Incluye las filas de x que coincidan con y
anti |Incluye las filas de x que no coinciden con y
</div>


![](img/manicule2.jpg) Ahora tu turno, ¿cómo se relacionan los años de
escolaridad con el porcentaje de población indígena. Utiliza los datos 
`df_mxmunicipio` y `df_edu` para explorar la relación. ¿cuál es el `join`
adecuado? ¿de qué tamaño serán los datos finales?
 
```{r}
glimpse(df_edu)
glimpse(df_mxmunicipio)
```

Si queremos un mapa del ganador de las elecciones por estado debemos unir los 
datos de elecciones con datos geográficos, estos estan incluídos en `mxmaps`, 
son `mxstate.map`.

```{r, fig.width=4.5, fig.height=4}
election_2012_state <- election_2012 %>%
    group_by(state_code) %>%
    summarise(
        pri_pvem = 100 * sum(pri_pvem) / sum(total),
        pan = 100 * sum(pan) / sum(total),
        prd_pt_mc = 100 * sum(prd_pt_mc) / sum(total)
    ) %>%
    mutate(winner = case_when(
        pri_pvem > pan & pri_pvem > prd_pt_mc ~ "pri_pvem",
        pan > pri_pvem & pan > prd_pt_mc ~ "pan",
        TRUE ~ "prd_pt_mc"), 
        winner_pct = pmax(pri_pvem, pan, prd_pt_mc))


election_map <- mxstate.map %>% 
    left_join(election_2012_state, by = c("region" = "state_code")) 

ggplot(election_map, aes(long, lat, group = group)) +
    geom_polygon(aes(fill = winner)) +
    coord_map()
```

Podemos especificar el color de cada categoría y la intensidad puede variar de
acuerdo al porcentaje de votos que se llevó el partido/alianza ganador.

```{r, fig.width=8}
library(gridExtra)
map_edo <- ggplot(election_map, aes(long, lat, group = group)) +
    geom_polygon(aes(fill = winner, alpha = winner_pct), color = "#666666", 
        size = .05, show.legend = FALSE) +
    coord_map() +
    scale_fill_manual(values = c("prd_pt_mc" = "#FFCC00", "pan" = "#3399FF", 
        "pri_pvem" = "#00CD66")) + 
    theme_void()

election_hexbinmap <- mxhexbin.map %>% 
    left_join(election_2012_state, by = c("region" = "state_code")) 
state_labels_map <- mxhexbin.map %>% 
    group_by(state_abbr) %>% 
    summarise(long = mean(long), lat = mean(lat), group = first(group))

hexbinmap_edo <- ggplot(election_hexbinmap, aes(long, lat, 
  group = group)) +
    geom_polygon(aes(fill = winner, alpha = winner_pct), color = "#666666", 
        size = .05, show.legend = FALSE) +
    coord_map() +
    scale_fill_manual(values = c("prd_pt_mc" = "#FFCC00", "pan" = "#3399FF", 
        "pri_pvem" = "#00CD66")) +
    geom_text(data = state_labels_map, aes(long, lat, label = state_abbr)) +
    theme_void()

grid.arrange(map_edo, hexbinmap_edo, nrow = 1)
```

![](img/manicule2.jpg) Genera un mapa a nivel municipo que muestre el porcentaje
de la población casada a total (mayores de 12 años).

```{r, echo = FALSE, eval=FALSE}
library(viridis)
library(scales)

df_marital %>% 
    filter(age_group == "Total", sex == "Total") %>% 
    right_join(mxmunicipio.map) %>% 
    ggplot(aes(long, lat, group = group)) +
    geom_polygon(aes(fill = separated), color = "#666666", size = .02) +
    coord_map() +
    scale_fill_viridis("percentage") +
    theme_void()
```


## Datos limpios

Una vez que importamos datos a R es conveniente limpiarlos, esto implica 
almacenarlos de una manera consisistente que nos permita enfocarnos en responder 
preguntas de los datos en lugar de estar luchando con los datos. 

Datos limpios son datos que facilitan las tareas del análisis de datos: 

*  **Visualización**: Resúmenes de datos usando gráficas, análisis exploratorio, 
o presentación de resultados. 

* **Manipulación**: Manipulación de variables como agregar, filtrar, reordenar,
transformar. 

* **Modelación**: Ajustar modelos es sencillo si los datos están en la forma 
correcta.


```{block2, type="caja"}
Los **principios de los datos limpios** [@tidy] 
proveen una manera estándar de organizar la información:

1. Cada columna es una variable.
2. Cada renglón es una observación .
3. Cada celda es un único valor.
```

Vale la pena notar que los principios de los datos limpios se pueden ver como 
teoría de algebra relacional para estadísticos, estós principios junto con 
*cada tipo de unidad observacional forma una tabla* equivalen a 
[la tercera forma normal de Codd](https://en.wikipedia.org/wiki/Third_normal_form) 
con enfoque en una sola tabla de datos en lugar de muchas conectadas en bases de 
datos relacionales. 

Veamos un ejemplo:

La mayor parte de las bases de datos en estadística tienen forma rectangular, 
¿cuántas variables tiene la siguiente tabla?

<div class="mi-tabla">
|   |tratamientoA|tratamientoB
----|------------|---------
Juan Aguirre|-   |2
Ana Bernal  |16  |11
José López  |3   |1
</div>

La tabla anterior también se puede estructurar de la siguiente manera:

<div class="mi-tabla">
 ||Juan Aguirre| Ana Bernal|José López
--|------------|-----------|----------
tratamientoA|- |    16     |   3
tratamientoB|2 |    11     |   1
</div>

Si vemos los principios (cada variable forma una columna, cada observación 
forma un renglón, cada tipo de unidad observacional forma una tabla), ¿las 
tablas anteriores cumplen los principios?

Para responder la pregunta identifiquemos primero cuáles son las variables y 
cuáles las observaciones de esta pequeña base. Las variables son: 
persona/nombre, tratamiento y resultado. Entonces, siguiendo los principios de
_datos limpios_ obtenemos la siguiente estructura: 

<div class="mi-tabla">
nombre      |tratamiento|resultado
------------|-----|---------
Juan Aguirre|a    |-
Ana Bernal  |a    |16
José López  |a    |3
Juan Aguirre|b    |2
Ana Bernal  |b    |11
José López  |b    |1
</div>

### Limpieza bases de datos {-}

Los principios de los datos limpios parecen obvios pero la mayor parte de los 
datos no los cumplen debido a:

1. La mayor parte de la gente no está familiarizada con los principios y es 
difícil derivarlos por uno mismo.  
2. Los datos suelen estar organizados para facilitar otros aspectos que no son 
análisis, por ejemplo, la captura.  

Algunos de los problemas más comunes en las bases de datos que no están 
_limpias_ son:

* Los encabezados de las columnas son valores y no nombres de variables. 
* Más de una variable por columna. 
* Las variables están organizadas tanto en filas como en columnas. 
* Más de un tipo de observación en una tabla.
* Una misma unidad observacional está almacenada en múltiples tablas. 

La mayor parte de estos problemas se pueden arreglar con pocas herramientas, 
a continuación veremos como _limpiar_ datos usando 2 funciones del paquete 
`tidyr`:

* `pivot_longer()`: recibe múltiples columnas y las convierte en pares de
valores y nombres de tal manera que alarga los datos.  
* `pivot_wider()`: el opuesto a `pivot_longer()` recibe columnas que separa 
haciendo los datos más anchos.

Repasaremos los problemas más comunes que se encuentran en conjuntos de datos
sucios y mostraremos como se puede manipular la tabla de datos (usando las 
funciones de pivoteo) con el fin de estructurarla para que cumpla los
principios de datos limpios.

**Nota:** Quizá has visto código de `tidyr` usando las funciones `gather()` y 
`spread()`, estas son versiones anteriores a las funciones de pivoteo, sin 
embargo, se les seguirá dando mantenimiento puesto que son muy populares, [aquí](https://tereom.github.io/tutoriales/datos_limpios.html) puedes encontrar 
una versión de las notas usando que utilizan `gather()` y `spread()`.

### Los encabezados de las columanas son valores {-}

Usaremos ejemplos para entender los conceptos más facilmente. Comenzaremos
con una tabla de datos que contiene las mediciones de partículas suspendidas
PM2.5 de la red automática de monitoreo atmosférico 
([RAMA](http://www.aire.cdmx.gob.mx)) para los primeros meses del 2019.


```{r}
library(tidyverse)
library(estcomp)
pm25_2019
```

¿Cuáles son las variables en estos datos?

Esta base de datos tiene 4 variables: fecha, hora, estación y medición 
(en microgramos por metro cúbico $\mu g/m^3$). 

```{r, eval = FALSE, echo = FALSE}
pm25_2019_tidy <- gather(pm25_2019, key = station, value = measurement, -date, 
  -hour)
head(pm25_2019_tidy)
tail(pm25_2019_tidy)
```

Al alargar los datos desaparecerán las columnas que se agrupan y darán 
lugar a dos nuevas columnas: la correspondiente a estación y la 
correspondiente a medición. Entonces,  usamos la función `pivot_longer()` que 
recibe los argumentos:

* data: `data.frame` que vamos a pivotear, alargar.  
* cols: columnas que vamos a pivotear (apilar), la 
notación para seleccionarlas es `tidyselect`, la misma que usamos con `select()`
en `dplyr`.
* names_to: nombre (`string`: en comillas "") de la nueva columna que almacenará
los nombres de las columnas en los datos.  
* values_to: nombre (`string`: en comillas "") de la nueva columna que 
almacenará los valores en los datos.

```{r}
pm25_2019_tidy <- pivot_longer(pm25_2019, cols = AJM:XAL, names_to = "station", 
  values_to = "measurement")
pm25_2019_tidy
```

Observemos que en la tabla original teníamos bajo la columna *AJM*, en el renglón
correspondiente a *2019-01-01* hora *1* un valor de 19, y podemos ver que este 
valor en la tabla larga se almacena bajo la columna *measurement* y corresponde 
a la estación *AJM*.

La nueva estructura de la base de datos nos permite, por ejemplo, hacer 
fácilmente una gráfica donde podemos comparar las diferencias en las 
frecuencias. 

```{r}
pm25_2019_tidy %>% 
    mutate(
        missing = is.na(measurement), 
        station = reorder(station, missing, sum)
        ) %>% 
    ggplot(aes(x = date, y = hour, fill = is.na(measurement))) +
    geom_raster(alpha = 0.8) +
    facet_wrap(~ station) +
    scale_fill_manual("faltante", 
        values = c("TRUE" = "salmon", "FALSE" = "gray"))
```

Otro ejemplo, veamos los datos `df_edu`, ¿cuántas variables tenemos?

```{r}
df_edu
```

Notemos que el nivel de escolaridad esta guardado en 6 columnas (preschool,
elementary, ..., other), este tipo de almacenamiento *no es limpio* aunque 
puede ser útil al momento de ingresar la información o para presentarla.

Para tener datos *limpios* apilamos los niveles de escolaridad de manera que 
sea una sola columna (nuevamente alargamos los datos):

```{r, include = FALSE}
df_edu_tidy <- gather(data = df_edu, grade, percent, preschool:other, 
  na.rm = TRUE)
glimpse(df_edu_tidy)
```

```{r}
df_edu_tidy <- pivot_longer(data = df_edu, cols = preschool:other, 
  names_to = "grade", values_to = "percent", values_drop_na = TRUE)
glimpse(df_edu_tidy)
```

El parámetro `values_drop_na = TRUE` se utiliza para eliminar los
renglones con valores faltantes en la columna de porcentaje, esto es, eliminamos
aquellas observaciones que tenían `NA` en la columnas de nivel de escolaridad de
la tabla ancha. En este caso optamos por que los faltantes sean implícitos, la
conveniencia de tenerlos implícitos/explícitos dependerá de la aplicación.

Con los datos limpios es facil hacer manipulaciones y grfiacs, ¿cómo habrían 
hecho la siguiente gráfica antes de la limpieza?

```{r}
df_edu_cdmx <- df_edu_tidy %>% 
    filter(state_abbr == "CDMX", sex != "Total", grade != "other") %>% 
    mutate(municipio_name = reorder(municipio_name, percent, last))

ggplot(df_edu_cdmx, aes(x = grade, 
    y = percent, group = sex, color = sex)) +
    geom_path() + 
    facet_wrap(~municipio_name) +
    theme(axis.text.x = element_text(angle = 60, hjust = 1)) +
    scale_x_discrete(limits = c("preschool", "elementary", 
        "secondary", "highschool", "higher_edu"))
```


### Una columna asociada a más de una variable {-}

Utilizaremos un subconjunto de los datos de la prueba ENLACE a nivel primaria,
la prueba [ENLACE](http://www.enlace.sep.gob.mx/ba/) evaluaba a todos los 
alumnos de tercero a sexto de primaria y a los alumnos de secundaria del país en 
3 áreas: *español*, *matemáticas* y *formación cívica y ética*.

```{r}
data("enlacep_2013")
enlacep_sub_2013 <- enlacep_2013 %>% 
    select(CVE_ENT:PUNT_FCE_6) %>% 
    sample_n(1000)
glimpse(enlacep_sub_2013)
```

![](img/manicule2.jpg) ¿Cuántas variables tiene este subconjunto de los datos?

* De manera similar a los ejemplos anteriores, 
utiliza la función `pivot_longer` para apilar las columnas correspondientes a 
área-grado.

```{r, echo=FALSE, eval=FALSE}
enlacep_long <- gather(enlacep_sub_2013, AREA_GRADO, PUNTAJE, 
    contains("PUNT"), na.rm = TRUE)
enlacep_long
```

```{r, echo=FALSE}
enlacep_long <- pivot_longer(enlacep_sub_2013, cols = contains("PUNT"), 
  names_to = c("AREA_GRADO"), values_to = "PUNTAJE")
```

* Piensa en como podemos separar la "variable" área-grado en dos columnas. 

Ahora separaremos las variables área y grado de la columna  `AREA_GRADO`, 
para ello debemos pasar a la función `separate()`, esta recibe como parámetros:  

- el nombre de la base de datos,  

- el nombre de la variable que deseamos separar en más de una,  

- la posición de donde deseamos "cortar" (hay más opciones para especificar 
como separar, ver `?separate`). El default es separar valores en todos los 
lugares que encuentre un caracter que no es alfanumérico (espacio, guión,...).

```{r}
enlacep_tidy <- separate(data = enlacep_long, col = AREA_GRADO, 
    into = c("AREA", "GRADO"), sep = 9)
enlacep_tidy

# creamos un mejor código de área
enlacep_tidy <- enlacep_tidy %>% 
    mutate(
        AREA = substr(AREA, 6, 8),
        GRADO = as.numeric(GRADO)
        ) 
glimpse(enlacep_tidy)
```

Conforme nos habituemos a las funciones podemos sacar provecho de sus 
argumentos adicionales:

* `names_prefix`: recibe una expresión regular para eliminar el texto que 
coincida del inicio de una variable.

```{r}
pivot_longer(enlacep_sub_2013, cols = contains("PUNT"), 
  names_to = c("AREA_GRADO"), values_to = "PUNTAJE", 
  names_prefix = "PUNT_") %>% 
  glimpse()
```

* `names_sep`: nos permite hacer el pivoteo y separar en una misma operación, 
en este caso `names_to` consiste en un vector con más de una entrada y 
`names_sep` indica como separar el nombre de las columnas.

```{r}
pivot_longer(enlacep_sub_2013, cols = contains("PUNT"), 
  names_to = c("AREA", "GRADO"), values_to = "PUNTAJE", names_prefix = "PUNT_", 
  names_sep = "_") %>% 
  glimpse()
```

* `names_pattern`: similar a `names_sep` pero recibe una expresión regular.

```{r, eval=FALSE}
pivot_longer(enlacep_sub_2013, cols = contains("PUNT"), 
  names_to = c("AREA", "GRADO"), names_pattern = "PUNT_?(.*)_(.*)", 
  values_to = "PUNTAJE")
```

* `names_ptypes, values_ptypes`: permiten especificar el tipo de las nuevas
columnas.

```{r}
pivot_longer(enlacep_sub_2013, cols = contains("PUNT"), 
  names_to = c("AREA", "GRADO"), values_to = "PUNTAJE", names_prefix = "PUNT_", 
  names_sep = "_", names_ptypes = list(GRADO = integer())) %>% 
  glimpse()
```


### Variables almacenadas en filas y columnas {-}

El problema más difícil es cuando las variables están tanto en filas como en 
columnas, veamos una base de datos de fertilidad. ¿Cuáles son las 
variables en estos datos?

```{r}
data("df_fertility")
df_fertility
```

Estos datos tienen variables en columnas individuales (state, size_localidad), 
en múltiples columnas (grupo de edad, age_15_19,..) y en filas (Valor y 
Error estándar). 

Comencemos por apilar las columnas.

```{r, include=FALSE}
fertility_long <- gather(df_fertility, age_bracket, value, age_15_19:global, 
    na.rm = TRUE)
fertility_long
```

```{r}
fertility_long <- pivot_longer(df_fertility, cols = age_15_19:global, 
  names_to = "age_bracket", values_to = "value", names_prefix = "age_")
fertility_long
```

Podemos crear algunas variables adicionales.

```{r}
fertility_vars <- fertility_long %>% 
    mutate(
        state_code = str_sub(state, 1, 2), 
        state_name = str_sub(state, 4)
        ) %>%
    select(-state)
fertility_vars
```

Finalmente, la columna *est* no es una variable, sino que almacena el nombre 
de 2 variables: *Valor* y *Error Estándar* la operación que debemos aplicar 
(`pivot_wider()`) es el inverso de apilar (`pivot_longer`), sus argumentos son:

* data: `data.frame` que vamos a pivotear.  
* names_from: nombre o nombres de las columnas (sin comillas) de los cuáles 
obtendremos los nombres de las nuevas columnas.
* values_from: nombre o nombres de las columnas (sin comillas) de los cuáles 
obtendremos los valores que llenarán las nuevas columnas.


```{r, include=FALSE}
fertility_tidy <- spread(data = fertility_vars, key = est, value = value)
```

```{r}
fertility_tidy <- pivot_wider(fertility_vars, names_from = est, 
  values_from = value)
```

Y podemos mejorar los nombres de las columnas, una opción rápida es usar el paquete janitor.

```{r}
fertility_tidy %>% 
    janitor::clean_names() %>% 
    glimpse()
```

o podemos hacerlo manualmente

```{r}
names(fertility_tidy)[5:6] <- c("est", "std_error")
```

Ahora es inmediato no solo hacer gráficas sino también ajustar un modelo.

```{r}
# ajustamos un modelo lineal donde la variable respuesta es temperatura 
# máxima, y la variable explicativa es el mes
fertility_sub <- filter(fertility_tidy, age_bracket != "global")
fertility_lm <- lm(est ~ age_bracket, data = fertility_sub)
summary(fertility_lm)
```

Vale la pena notar que aunque los datos limpios facilitan las 
tareas de análisis, distintas funciones o tareas requieren los datos en 
distintos formas y saber pivotear las tablas es muy útil.

![](img/manicule2.jpg) Grafica el valor estimado de fertilidad del grupo de
edad 20-24 contra 25-29. ¿Qué transformación debes hacer? Tip: elimina la 
columna que corresponde al error estándar antes de ensanchar los
datos.

```{r, include=FALSE}
fertility_age <- pivot_wider(fertility_tidy, names_from = age_bracket, 
  values_from = c(est, std_error))

ggplot(fertility_age, aes(est_20_24, est_25_29, color = size_localidad)) +
  geom_abline(alpha = 0.5) +
  geom_point()
```

### Una misma unidad observacional está almacenada en múltiples tablas {-}

También es común que los valores sobre una misma unidad observacional estén 
separados en muchas tablas o archivos, es común que estas tablas esten divididas 
de acuerdo a una variable, de tal manera que cada archivo representa a una 
persona, año o ubicación. Para juntar los archivos hacemos lo siguiente:

1. Enlistamos las rutas de los archivos. 
2. Leemos cada archivo y agregamos una columna con el nombre del archivo. 
3. Combinamos las tablas en un solo data frame.  

Veamos un ejemplo, descargamos la carpeta con los datos de varios contaminantes
de RAMA,

```{r, eval=FALSE}
usethis::use_zip("https://github.com/tereom/estcomp/raw/master/data-raw/19RAMA.zip", 
    "data")
```

ésta contiene 9 archivos de excel que almacenan información de monitoreo de 
contaminantes. Cada archivo contiene información de un contaminante y el nombre
del archivo indica el contaminante. 

Los pasos en R (usando el paquete `purrr`), primero creamos un vector con los
nombres de los archivos en un directorio, eligiendo aquellos que contengan las
letras ".csv".

```{r, echo=FALSE, eval=FALSE}
library(here)
dir_rama <- here("data", "19RAMA")
paths <- dir(dir_rama, pattern = "\\.xls$", full.names = TRUE) 
paths
```

```{r}
paths <- dir("data/19RAMA", pattern = "\\.xls$", full.names = TRUE)
```

Después le asignamos el nombre del archivo al nombre de cada elemento del vector.
Este paso se realiza para preservar los nombres de los archivos ya que estos
los asignaremos a una variable mas adelante.

```{r}
paths <- set_names(paths, basename(paths))
```

La función `map_df` itera sobre cada dirección, lee el archivo excel de dicha 
dirección y los combina en un data frame.

```{r, error=TRUE}
library(readxl)
rama <- map_df(paths, read_excel, .id = "FILENAME")

# eliminamos la basura del id
rama <- rama %>%
  mutate(PARAMETRO = str_remove(FILENAME, "2019") %>% str_remove(".xls")) %>%
  select(PARAMETRO, FECHA:AJU)
# y apilamos para tener una columna por estación
rama_tidy <- rama %>%
    gather(estacion, valor, ACO:AJU) %>% 
    mutate(valor = ifelse(-99, NA, valor))
rama_tidy
    
```

### Otras consideraciones {-}

En las buenas prácticas es importante tomar en cuenta los siguientes puntos:

* Incluir un encabezado con el nombre de las variables.

* Los nombres de las variables deben ser entendibles (e.g. AgeAtDiagnosis es 
mejor que AgeDx).

* En general los datos se deben guardar en un archivo por tabla.

* Escribir un script con las modificaciones que se hicieron a los _datos crudos_ 
(reproducibilidad).

* Otros aspectos importantes en la _limpieza_ de datos son: selección del tipo 
de variables (por ejemplo fechas), datos faltantes, _typos_ y detección de 
valores atípicos.


### Recursos adicionales {-}

* [Data Transformation Cheat Sheet](https://github.com/rstudio/cheatsheets/raw/master/data-transformation.pdf) 
de RStudio.

* [Data Wrangling Cheat Sheet](https://www.rstudio.com/wp-content/uploads/2015/02/data-wrangling-cheatsheet.pdf)
de RStudio.

* Limpiar nombres de columnas, eliminar filas vacías y más, paquete 
[janitor](https://github.com/sfirke/janitor).

* Lectura de datos tabulares con distintas estructuras, paquete 
[tidycells](https://buff.ly/2z9CcBN).