04-manipulacion-datos.Rmd

# Transformación y agrupacion de datos 

En esta sección mostraremos herramientas de transformación y agrupación de 
datos (arreo de datos!). Trataremos los siguientes puntos:

* Transformación de datos.

* Estrategia separa-aplica-combina.

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 tablas 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.


Usaremos los datos de población municipal de INEGI que leímos en la sección anterior.

```{r, message=FALSE, warning=FALSE}
library(tidyverse)
```


```{r}
df_mxmunicipio <- read_csv("datos/df_municipios.csv")
df_edu <- read_csv("datos/df_edu.csv")
```

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)
```

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

Summarise sirve para crear nuevas tablas 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 (ventanas) {-}

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 tablas, por ejemplo:

```{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, eval=FALSE}
data(election_sub_2012)
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()
```

![](img/mapa_edo.png)

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, eval=FALSE}
library(patchwork)
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()
# con patchwork podemos hacer:
map_edo + hexbinmap_edo
```

![](img/mapa_edo_2.png)


![](img/manicule2.jpg) Genera un mapa a nivel estado 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()
```

![](img/Xolbio1.png){width=20%}