model-many.Rmd

# Muchos modelos

## Introducción

En este capítulo vas a aprender tres ideas poderosas que te van a ayudar a trabajar fácilmente con un gran número de modelos:

1.  Usar muchos modelos simples para entender mejor conjuntos de datos complejos.

1.  Usar columnas-lista (_list-columns_) para almacenar estructuras de datos arbitrarias en un _data frame_.
    Ésto, por ejemplo, te permitirá tener una columna que contenga modelos lineales.
   
1.  Usar el paquete __broom__, de David Robinson, para transformar modelos en datos ordenados.
    Ésta es una técnica poderosa para trabajar con un gran número de modelos
    porque una vez que tienes datos ordenados, puedes aplicar todas las técnicas que 
    has aprendido anteriormente en el libro.

Empezaremos entrando de lleno en un ejemplo motivador usando datos sobre la esperanza de vida alrededor del mundo. Es un conjunto de datos pequeño pero que ilustra cuán importante puede ser modelar para mejorar tus visualizaciones. Utilizaremos un número grande de modelos simples para extraer algunas de las señales más fuertes y que podamos ver las sutiles que permanecen. También veremos cómo las medidas de resumen de los modelos nos pueden ayudar a encontrar datos atípicos y tendencias inusuales.

Las siguientes secciones ahondarán en más detalles acerca de las técnicas:

1. En [columnas-lista], aprenderás más acerca de la estructura de datos columna-lista,
   y por qué es válido poner listas en _data frames_.
   
1. En [creando columnas-lista], aprenderás las tres maneras principales en las que 
   crearás columnas-lista.
   
1. En [simplificando columnas-lista] aprenderás cómo convertir columnas-lista de vuelta
   a vectores atómicos regulares (o conjuntos de vectores atómicos) para que puedas trabajar
   con ellos más fácilmente.
   
1. En [haciendo datos ordenados con broom], aprenderás sobre el conjunto de herramientas completo
   provisto por __broom__ (del inglés _escoba_), y verás cómo puede ser aplicado a otros tipos de 
   estructuras de datos.

Este capítulo es aspiracional en cierta medida: si este libro es tu primera introducción a R, este capítulo es probable que sea una lucha para ti. Requiere que tengas profundamente internalizadas ideas acerca de modelamiento, estructuras de datos, e iteración. Así que no te preocupes si no lo entiendes --- solo aparta este capítulo por un par de meses, y vuelve cuando quieras ejercitar tu cerebro.

### Prerrequisitos

Trabajar con muchos modelos requiere muchos de los paquetes del __tidyverse__ (para exploración de datos, doma y programación) y __modelr__ para facilitar el modelamiento.

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

## gapminder

Para motivar el poder de muchos modelos simples, vamos a mirar los datos de "gapminder". Estos datos fueron popularizados por Hans Rosling, un doctor y estadístico sueco. Si nunca has escuchado de él, para de leer este capítulo ahora mismo y ve a mirar uno de sus videos! Él es un presentador de datos fantástico e ilustra cómo puedes usar datos para presentar una historia convincente. Un buen lugar para empezar es este video corto filmado en conjunto con la BBC: <https://www.youtube.com/watch?v=jbkSRLYSojo>.

Los datos de gapminder resumen la progresión de países a través del tiempo, mirando estadísticos como esperanza de vida y PIB. Los datos son de fácil acceso en R, gracias a Jenny Bryan que creó el paquete __gapminder__. Utilizaremos la versión en español contenida en el paquete __datos__ (TODO: ver cómo poner esto):

```{r}
library(datos)
paises
```

En este caso de estudio, nos enfocaremos en solo tres variables para responder la pregunta "¿Cómo la esperanza de vida (`esperanza_de_vida`) cambia a través del tiempo (`anio`) para cada país (`pais`)?". Un buen lugar para empezar es con un gráfico:

```{r}
paises %>%
  ggplot(aes(anio, esperanza_de_vida, group = pais)) +
  geom_line(alpha = 1 / 3)
```

Es un conjunto de datos pequeño: solo tiene ~1,700 observaciones y 3 variables. Pero aún así es difícil ver qué está pasando! En general, parece que la esperanza de vida ha estado mejorando en forma constante. Sin embargo, si miras de cerca, puedes notar algunos países que no siguen este patrón. ¿Cómo podemos hacer que esos países se vean más fácilmente?

Una forma es usar el mismo enfoque que en el último capítulo: hay una señal fuerte (en general crecimiento lineal) que hace difícil ver tendencias más sutiles. Separaremos estos factores estimando un modelo con una tendencia lineal. El modelo captura el crecimiento estable en el tiempo, y los residuos mostrarán lo que queda fuera.

Ya sabes cómo hacer eso si tenemos un solo país:

```{r, out.width = "33%", fig.asp = 1, fig.width = 3, fig.align='default'}
nz <- filter(paises, pais == "Nueva Zelandia")
nz %>%
  ggplot(aes(anio, esperanza_de_vida)) +
  geom_line() +
  ggtitle("Datos completos = ")

nz_mod <- lm(esperanza_de_vida ~ anio, data = nz)
nz %>%
  add_predictions(nz_mod) %>%
  ggplot(aes(anio, pred)) +
  geom_line() +
  ggtitle("Tendencia lineal + ")

nz %>%
  add_residuals(nz_mod) %>%
  ggplot(aes(anio, resid)) +
  geom_hline(yintercept = 0, colour = "white", size = 3) +
  geom_line() +
  ggtitle("Patrón restante")
```

¿Cómo podemos ajustar fácilmente ese modelo para cada país?

### Datos anidados

Te puedes imaginar copiando y pegando ese código múltiples veces; pero ya has aprendido una mejor forma! Extrae el código en común con una función y repítelo usando una función map (TODO: no me queda claro que tenga sentido poner que el nombre de esta función venga del inglés, y no sé si ponerla en cursiva) de __purrr__. Este problema se estructura un poco diferente respecto a lo que has visto antes. En lugar de repetir una acción por cada variable, queremos repetirla para cada país, un subconjunto de filas. Para hacer eso, necesitamos una nueva estructura de datos: el __*data frame* anidado__ (_nested data frame_). Para crear un _data frame_ anidado empezamos con un _data frame_ agrupado, y lo "anidamos":

```{r}
por_pais <- paises %>%
  group_by(pais, continente) %>%
  nest()

por_pais
```

(Estoy haciendo un poco de trampa agrupando por `continente` y `pais` al mismo tiempo. Dado el `pais`, `continente` es fijo, así que no agrega ningún grupo más, pero es una forma fácil de llevarnos una variable adicional para el camino.)

Ésto crea un _data frame_ que tiene una fila por grupo (por país), y una columna bastante inusual: `data`. `data` es una lista de _data frames_ (o _tibbles_, para ser precisos). Esto parece una idea un poco loca: tenemos un _data frame_ con una columna que es una lista de otros _data frames_! Explicaré brevemente por qué pienso que es una buena idea.

La columna `data` es un poco difícil de examinar porque es una lista moderadamente complicada, y todavía estamos trabajando para tener buenas herramientas para explorar estos objetos. Desafortunadamente usar `str()` no es recomendable porque usualmente producirá un _output_ (salida de código) muy extenso. Pero si extraes un solo elemento de la columna `data` verás que contiene todos los datos para ese país (en este caso, Afganistán).

```{r}
por_pais$data[[1]]
```

Nota la diferencia entre un _data frame_ agrupado estándar y un _data frame_ anidado: en un _data frame_ agrupado, cada fila es una observación; en un _data frame_ anidado, cada fila es un grupo. Otra forma de pensar en un conjunto de datos anidado es que ahora tenemos una meta-observación: una fila que representa todo el transcurso de tiempo para un país, en lugar de solo un punto en el tiempo.

### Columnas-lista

Ahora que tenemos nuestro _data frame_ anidado, estamos en una buena posición para ajustar algunos modelos. Tenemos una función para ajustar modelos:

```{r}
modelo_pais <- function(df) {
  lm(esperanza_de_vida ~ anio, data = df)
}
```

Y queremos aplicarlo a cada _data frame_. Los _data frames_ están en una lista, así que podemos usar `purrr::map()` para aplicar `modelo_pais` a cada elemento:

```{r}
modelos <- map(por_pais$data, modelo_pais)
```

Sin embargo, en lugar de dejar la lista de modelos como un objeto suelto, creo que es mejor almacenarlo como una columna en el _data frame_ `por_pais`. Almacenar objetos relacionados en columnas es una parte clave del valor de los _data frames_, y por eso pienso que las columnas-lista son tan buena idea. En el transcurso de nuetro trabajo con estos países, vamos a tener muchas listas donde tenemos un elemento por país. ¿Por qué no almacenarlos todos juntos en un _data frame_?

En otras palabras, en lugar de crear un nuevo objeto en el entorno global, vamos a crear una nueva variable en el _data frame_ `por_pais`. Ese es un trabajo para `dplyr::mutate()`:

```{r}
por_pais <- por_pais %>%
  mutate(modelo = map(data, modelo_pais))
por_pais
```

Esto tiene una gran ventaja: como todos los objetos relacionados están almacenados juntos, no necesitas manualmente mantenerlos sincronizados cuando filtras o reordenas. La semántica del _data frame_ se ocupa de esto por ti:

```{r}
por_pais %>%
  filter(continente == "Europa")
por_pais %>%
  arrange(continente, pais)
```

Si tu lista de _data frames_ y lista de modelos fueran objetos separados, tienes (TODO: acá usaría "tendrías" pero no es lo que usa el original) que acordarte de que cuando reordenas o seleccionas un subconjunto de un vector, necesitas reordenar o seleccionar el subconjunto de todos los demás para mantenerlos sincronizados. Si te olvidas, tu código va a seguir funcionando, pero va a devolver la respuesta equivocada!

### Desanidando

Previamente calculamos los residuos de un único modelo con un conjunto de datos también único. Ahora tenemos 142 _data frames_ y 142 modelos. Para calcular los residuos, necesitamos llamar a la función `add_residuals()` (del inglés _adicionar residuos_) con cada par modelo-datos:

```{r}
por_pais <- por_pais %>%
  mutate(
    residuos = map2(data, modelo, add_residuals)
  )
por_pais
```

¿Pero cómo puedes graficar una lista de _data frames_? En lugar de luchar para contestar esa pregunta, transformemos la lista de _data frames_ de vuelta en un _data frame_ regular. Previamente usamos `nest()` (del inglés _anidar_) para transformar un _data frame_ regular en uno anidado, y ahora desanidamos con `unnest()`:

```{r}
residuos <- unnest(por_pais, residuos)
residuos
```

Nota que cada columna regular está repetida una vez por cada fila en la columna anidada. 

Ahora tenemos un _data frame_ regular, podemos graficar los residuos:

```{r}
residuos %>%
  ggplot(aes(anio, resid)) +
  geom_line(aes(group = pais), alpha = 1 / 3) +
  geom_smooth(se = FALSE)
```

Separar facetas por continente es particularmente revelador:
 
```{r}
residuos %>%
  ggplot(aes(anio, resid, group = pais)) +
  geom_line(alpha = 1 / 3) +
  facet_wrap(~ continente)
```

Parece que hemos perdido algunos patrones suaves. También hay algo interesante pasando en África: vemos algunos residuos muy grandes lo que sugiere que nuestro modelo no está ajustando muy bien. Exploraremos más eso en la próxima sección, atacando el problema desde un ángulo un poco diferente.

### Calidad del modelo

En lugar de examinar los residuos del modelo, podríamos examinar algunas medidas generales de la calidad del modelo. Aprendiste cómo calcular algunas medidas específicas en el capítulo anterior. Aquí mostraremos un enfoque diferente usando el paquete __broom__. El paquete __broom__ provee un conjunto de funciones generales para transformar modelos en datos ordenados. Aquí utilizaremos `broom::glance()` (del inglés _vistazo_) para extraer algunas métricas de la calidad del modelo. Si lo aplicamos a un modelo, obtenemos un _data frame_ con una única fila:

```{r}
broom::glance(nz_mod)
```

Podemos usar `mutate()` y `unnest()` para crear un _data frame_ con una fila por cada país:

```{r}
por_pais %>%
  mutate(glance = map(modelo, broom::glance)) %>%
  unnest(glance)
```

Este no es exactamente el _output_ que queremos, porque aún incluye todas las columnas que son una lista. Éste es el comportamiento por defecto cuando `unnest()` trabaja sobre _data frames_ con una única fila. Para suprimir esas columnas usamos `.drop = TRUE` (`drop`  — del inglés _descartar_):

```{r}
glance <- por_pais %>%
  mutate(glance = map(modelo, broom::glance)) %>%
  unnest(glance, .drop = TRUE)
glance
```

(Presta atención a las variables que no se imprimieron: hay mucha información útil allí.)

Con este _data frame_, podemos empezar a buscar modelos que no se ajustan bien:

```{r}
glance %>%
  arrange(r.squared)
```

Los peores modelos parecen estar todos en África. Vamos a chequear ésto con un gráfico. Tenemos un número relativamente chico de observaciones y una variable discreta, así que `geom_jitter()` (TODO: en inglés jitter es temblar o algo similar, pero no sé si estaría bien poner acá eso porque no es exactamente eso...) es efectiva:

```{r}
glance %>%
  ggplot(aes(continente, r.squared)) +
  geom_jitter(width = 0.5)
```

Podríamos quitar los países con un $R^2$ particularmente malo y graficar los datos:

```{r}
mal_ajuste <- filter(glance, r.squared < 0.25)

paises %>%
  semi_join(mal_ajuste, by = "pais") %>%
  ggplot(aes(anio, esperanza_de_vida, colour = pais)) +
  geom_line()
```

Vemos dos efectos principales aquí: las tragedias de la epidemia de VIH/SIDA y el genocidio de Ruanda.

### Ejercicios

1.  Una tendencia lineal parece ser demasiado simple para la tendencia general.
    ¿Puedes hacerlo mejor con un polinomio cuadrático? ¿Cómo puedes interpretar
    el coeficiente del término cuadrático? (Pista: puedes querer transformar
    `year` para que tenga media cero.)

1.  Explora otros métodos para visualizar la distribución del $R^2$ por
    continente. Puedes querer probar el paquete __ggbeeswarm__, que provee 
    métodos similares para evitar superposiciones como jitter, pero usa métodos
    determinísticos.

1.  Para crear el último gráfico (mostrando los datos para los países con los
    peores ajustes del modelo), precisamos dos pasos: creamos un _data frame_ con
    una fila por país y después hicimos un _semi-join_ (del inglés _semi juntar_) (TODO: deberíamos aclarar algo?) al conjunto de datos original.
    Es posible evitar este _join_ si usamos `unnest()` en lugar de 
    `unnest(.drop = TRUE)`. ¿Cómo?

## Columnas-lista

Ahora que has visto un flujo de trabajo básico para manejar muchos modelos, vamos a sumergirnos en algunos detalles. En esta sección, exploraremos en más detalle la estructura de datos columna-lista. Solo recientemente es que he comenzado a apreciar realmente la idea de la columna-lista. Esta estructura está implícita en la definición de _data frame_: un _data frame_ es una lista nombrada de vectores de igual largo. Una lista es un vector, así que siempre ha sido legítimo usar una lista como una columna de un _data frame_. Sin embargo, R base no hace las cosas fáciles para crear columnas-lista, y `data.frame()` trata a la lista como una lista de columnas:

```{r}
data.frame(x = list(1:3, 3:5))
```

Puedes prevenir que `data.frame()` haga esto con `I()`, pero el resultado no se imprime particularmente bien:

```{r}
data.frame(
  x = I(list(1:3, 3:5)),
  y = c("1, 2", "3, 4, 5")
)
```

_Tibble_ mitiga este problema siendo más perezoso (TODO: lazier) (`tibble()` no modifica sus _inputs_) y proporcionando un mejor método de impresión:

```{r}
tibble(
  x = list(1:3, 3:5),
  y = c("1, 2", "3, 4, 5")
)
```

Es incluso más fácil con `tribble()` ya que automáticamente puede interpretar que necesitas una lista:

```{r}
tribble(
  ~ x, ~ y,
  1:3, "1, 2",
  3:5, "3, 4, 5"
)
```

Columnas-lista son usualmente más útiles como estructuras de datos intermedias. Es difícil trabajar con ellas directamente, porque la mayoría de las funciones de R trabajan con vectores atómicos o _data frames_, pero la ventaja de mantener ítems relacionados juntos en un _data frame_ hace que valga la pena un poco de molestia.

Generalmente hay tres partes de un _pipeline_ (del inglés _tubería_) efectivo de columnas-lista:

1.  Creas la columna-lista usando uno entre `nest()`, `summarise()` + `list()`,
    o `mutate()` + una función map, como se describió en [Creando columnas-lista].

1.  Creas otra columna-lista intermedia transformando columnas lista 
    existentes con `map()`, `map2()` o `pmap()`. Por ejemplo, 
    en el caso de estudio de arriba, creamos una columna-lista de modelos transformando
    una columna-lista de _data frames_.
    
1.  Simplificas la columna-lista de vuelta en un _data frame_ o vector atómico,
    como se describió en [Simplificando columnas-lista].

## Creando columnas-lista

Típicamente, no crearás columnas-lista con `tibble()`. En cambio, las crearás a partir de columnas regulares, usando uno de tres métodos: 

1.  Con `tidyr::nest()` para convertir un _data frame_ agrupado en uno anidado
    donde tengas columnas-lista de _data frames_.
    
1.  Con `mutate()` y funciones vectorizadas que retornan una lista.

1.  Con `summarise()` y funciones de resumen que retornan múltiples resultados.

Alternativamente, podrías crearlas a partir de una lista nombrada, usando `tibble::enframe()`.

Generalmente, cuando creas columnas-lista, debes asegurarte de que sean homogéneas: cada elemento debe contener el mismo tipo de cosa. No hay chequeos para asegurarte de que sea así, pero si usas __purrr__ y recuerdas lo que aprendiste sobre funciones de tipo estable (TODO: type-stable functions), encontrarás que eso pasa naturalmente.

### Con anidación

`nest()` crea un _data frame_ anidado, que es un _data frame_ con una columna-lista de _data frames_. En un _data frame_ anidado cada fila es una meta-observación: las otras columnas son variables que definen la observación (como país y continente arriba), y la columna-lista de _data frames_ tiene las observaciones individuales que construyen la meta-observación.

Hay dos formas de usar `nest()`. Hasta ahora has visto cómo usarlo con un _data frame_ agrupado. Cuando se aplica a un _data frame_ agrupado, `nest()` mantiene las columnas que agrupan tal cual, y envuelve todo lo demás en la columna-lista:

```{r}
paises %>%
  group_by(pais, continente) %>%
  nest()
```

También lo puedes usar en un _data frame_ no agrupado, especificando cuáles columnas quieres anidar:

```{r}
paises %>%
  nest(anio:pib_per_capita)
```

### A partir de funciones vectorizadas

Algunas funciones útiles toman un vector atómico y retornan una lista. Por ejemplo, en [strings] (TODO: chequear cómo se llama el capítulo en español) aprendiste `stringr::str_split()` que toma un vector de caracteres y retorna una lista de vectores de caracteres. Si lo usas dentro de mutate (TODO: no sé si ponerlo en cursiva o dejarlo como el original), obtendrás una columna-lista:

```{r}
df <- tribble(
  ~ x1,
  "a,b,c",
  "d,e,f,g"
)

df %>%
  mutate(x2 = stringr::str_split(x1, ","))
```

`unnest()` sabe cómo manejar estas listas de vectores:

```{r}
df %>%
  mutate(x2 = stringr::str_split(x1, ",")) %>%
  unnest()
```

(Si usas mucho este patrón, asegúrate de chequear `tidyr::separate_rows()` (del inglés _separar filas_) que es un _wrapper_ (TODO: cuando esté el capítulo de Joshua poner explicación) alrededor de este patrón común).

Otro ejemplo de este patrón es usar `map()`, `map2()`, `pmap()` de __purrr__. Por ejemplo, podríamos tomar el ejemplo final de [Invoking different functions] (TODO: chequear nombre en español) y reescribirlo usando `mutate()`:

```{r}
sim <- tribble(
  ~ f, ~ params,
  "runif", list(min = -1, max = 1),
  "rnorm", list(sd = 5),
  "rpois", list(lambda = 10)
)

sim %>%
  mutate(sims = invoke_map(f, params, n = 10))
```

Nota que técnicamente `sim` no es homogénea porque contiene vectores con tipo de datos dobles así como enteros (TODO: both double and integer vectors). Sin embargo, es probable que ésto no cause muchos problemas porque ambos vectores son numéricos.

### A partir de medidas de resumen con más de un valor

Una restricción de `summarise()` es que solo funciona con funciones de resumen que retornan un único valor. Eso significa que no puedes usarlo con funciones como `quantile()` que retorna un vector de largo arbitrario:

```{r, error = TRUE}
mtautos %>%
  group_by(cilindros) %>%
  summarise(q = quantile(millas))
```

Sin embargo, puedes envolver el resultado en una lista! Esto obedece el contrato de `summarise()`, porque cada resumen ahora es una lista (un vector) de largo 1.

```{r}
mtautos %>%
  group_by(cilindros) %>%
  summarise(q = list(quantile(millas)))
```

Para producir resultados útiles con unnest, también necesitarás capturar las probabilidades:

```{r}
probs <- c(0.01, 0.25, 0.5, 0.75, 0.99)
mtautos %>%
  group_by(cilindros) %>%
  summarise(p = list(probs), q = list(quantile(millas, probs))) %>%
  unnest()
```

### A partir de una lista nombrada

_Data frames_ con columnas-lista proveen una solución a un problema común: ¿qué haces si quieres iterar sobre el contenido de una lista y también sobre sus elementos? En lugar de tratar de juntar todo en un único objeto, usualmente es más fácil hacer un _data frame_: una columna puede contener los elementos y otra columna la lista. Una forma fácil de crear un _data frame_ como éste desde una lista es `tibble::enframe()`.  

```{r}
x <- list(
  a = 1:5,
  b = 3:4,
  c = 5:6
)

df <- enframe(x)
df
```

La ventaja de esta estructura es que se generaliza de una forma relativamente sencilla - los nombres son útiles si tienes como metadata vectores de caracteres, pero no ayudan para otros tipos de datos o para múltiples vectores.

Ahora, si quieres iterar sobre los nombres y valores en paralelo, puedes usar `map2()`:

```{r}
df %>%
  mutate(
    smry = map2_chr(name, value, ~ stringr::str_c(.x, ": ", .y[1]))
  )
```

### Ejercicios

1.  Lista todas las funciones en las que puedas pensar que tomen como _input_ un vector atómico y 
    retornen una lista.
    
1.  Piensa en funciones de resumen útiles que, como `quantile()`, retornen
    múltiples valores.
    
1.  ¿Qué es lo que falta en el siguiente _data frame_? ¿Cómo `quantile()` retorna
    eso que falta? ¿Por qué eso no es tan útil aquí?

```{r}
mtautos %>%
  group_by(cilindros) %>%
  summarise(q = list(quantile(millas))) %>%
  unnest()
```

1.  ¿Qué hace este código? ¿Por qué podría ser útil?

```{r, eval = FALSE}
mtautos %>%
  group_by(cilindros) %>%
  summarise_each(funs(list))
```

## Simplificando columnas-lista

Para aplicar las técnicas de manipulación de datos y visualización que has aprendido en este libro, necesitarás simplificar la columna-lista de vuelta a una columna regular (un vector atómico), o conjunto de columnas. La técnica que usarás para volver a una estructura más sencilla depende de si quieres un único valor por elemento, o múltiples valores.

1.  Si quieres un único valor, usa `mutate()` con `map_lgl()`, 
    `map_int()`, `map_dbl()`, y `map_chr()` para crear un vector atómico.
    
1.  Si quieres varios valores, usa `unnest()` para convertir columnas-lista de vuelta a
    columnas regulares, repitiendo las filas tantas veces como sea necesario.

Estas técnicas están descritas con más detalle abajo.

### Lista a vector

Si puedes reducir tu columna lista a un vector atómico entonces será una columna regular. Por ejemplo, siempre puedes resumir un objeto con su tipo y largo, por lo que este código funcionará sin importar cuál tipo de columna-lista tengas:

```{r}
df <- tribble(
  ~ x,
  letters[1:5],
  1:3,
  runif(5)
)

df %>% mutate(
  tipo = map_chr(x, typeof),
  largo = map_int(x, length)
)
```

Ésta es la misma información básica que obtienes del método por defecto de imprimir _tbl_ (TODO: esto se traduce?), pero ahora lo puedes usar para filtrar. Es una técnica útil si tienes listas heterogéneas, y quieres remover las partes que no te sirven.

No te olvides de los atajos de `map_*()` - puedes usar `map_chr(x, "manzana")` para extraer la cadena de caracteres almacenada en `manzana` para cada elemento de `x`. Ésto es útil para separar listas anidadas en columnas regulares. Usa el argumento `.null` para proveer un valor para usar si el elemento es un valor perdido (_missing_) (TODO: traducimos missing?) (en lugar de retornar `NULL`):

```{r}
df <- tribble(
  ~ x,
  list(a = 1, b = 2),
  list(a = 2, c = 4)
)
df %>% mutate(
  a = map_dbl(x, "a"),
  b = map_dbl(x, "b", .null = NA_real_)
)
```

### Desanidando

`unnest()` trabaja repitiendo la columna regular una vez para cada elemento de la columna-lista. Por ejemplo, en el siguiente ejemplo sencillo repetimos la primera fila 4 veces (porque el primer elemento de `y` tiene largo cuatro), y la segunda fila una vez:

```{r}
tibble(x = 1:2, y = list(1:4, 1)) %>% unnest(y)
```

Esto significa que no puedes simultáneamente desanidar dos columnas que contengan un número diferente de elementos:

```{r, error = TRUE}
# Funciona, porque y y z tienen el mismo número de elementos en
# cada fila
df1 <- tribble(
  ~ x, ~ y, ~ z,
  1, c("a", "b"), 1:2,
  2, "c", 3
)
df1
df1 %>% unnest(y, z)

# No funciona porque y y z tienen un número diferente de elementos
df2 <- tribble(
  ~ x, ~ y, ~ z,
  1, "a", 1:2,
  2, c("b", "c"), 3
)
df2
df2 %>% unnest(y, z)
```

El mismo principio aplica al desanidar columnas-lista de _data frames_. Puedes desanidar múltiples columnas-lista siempre que todos los _data frames_ de cada fila tengan la misma cantidad de filas.

### Ejercicios

1.  ¿Por qué podría ser útil la función `lengths()` para crear columnas de 
    vectores atómicos a partir de columnas-lista?
    
1.  Lista los tipos de vectores más comúnes que se encuentran en un _data frame_. ¿Qué hace que las 
    listas sean diferentes?

## Haciendo datos ordenados con broom

El paquete __broom__ provee tres herramientas generales para transformar modelos en en _data frames_ ordenados:

1.  `broom::glance(modelo)` retorna una fila para cada modelo. Cada columna tiene una 
    medida de resumen del modelo: o bien una medida de la calidad del modelo, o complejidad, o 
    una combinación de ambos.
   
1.  `broom::tidy(modelo)` retorna una fila por cada coeficiente en el modelo. Cada 
    columna brinda información acerca de la estimación o su variabilidad.
    
1.  `broom::augment(modelo, datos)` retorna una fila por cada fila en `datos`, agregando
    valores adicionales como residuos, y estadísticos de influencia.