Variables dummy (one-hot encoding) con R

Variables dummy con R

Los datos categóricos o nominales, como su nombre lo indica, son usados para nombrar o categorizar información. Este tipo de dato se caracteriza por no ser ordenado, incluso si se usan números para representarlos.

El nombre de las diferentes razas de perros es un dato categórico. Aunque puedes ordenar todos los nombres alfabéticamente, carece de sentido conceptual que “Akita” se encuentre antes que “Beagle” o que “Collie” se encuentre después de “Chihuahua”. Esto no nos informa ni nos ayuda a entender sobre las características de los perros que pertenecen a estas razas.

Las funciones de R base y stats, que se incluyen con toda instalación de este lenguaje, están diseñadas para trabajar con datos categóricos usando, principalmente, las características del tipo de dato factor, que es particular a R.

Si deseamos realizar una regresión linear con la función lm() de stats, no tendremos problemas para realizar correctamente sus operaciones.

Sin embargo, este no siempre es el caso con funciones incluidas en paquetes de terceros o que importan procedimientos desde otros lenguajes de programación.

En especial, múltiples métodos de Machine Learning y Deep Learning requieren matrices numéricas como datos de entrada, por lo que es necesario transformar variables de tipo categórico para implementarlos.

La manera más sencilla de transformar estos datos es crear variables dummy (falsas, en español), proceso también conocido como one-hot encoding.

En este artículo revisaremos cómo crear variables dummy en R, definiendo nuestra propia función y usando el paquete fastDummies. Pero primero, demos un vistazo a qué es una variable dummy.

Las variables dummy

Crear variables dummy implica transformar datos de un formato “alto”, en el que cada columna contiene la información de una variable, a datos con un formato “ancho”, en los que múltiples columnas contienen la información de las dos variables, codificada de manera binaria, esto es, con 0 y 1.

A lo largo de este artículo usaremos como ejemplo un data frame con datos de distintos perros en una veterinaria hipotética.

Nuestro objetivo será transformar la información de dos variables, raza, para la raza a la que pertenecen los perros, y vac, para tipo de vacuna que se les ha aplicado, a variables dummy.

Es decir, pasaremos de este data frame:

   id   peso alto   raza  vac
1   1 1988.4 24.5  akita alfa
2   2 2070.0 54.9 collie beta
3   3 2063.3 43.5 collie alfa
4   4 1759.0 51.4  akita beta
5   5 2123.1 20.8 beagle beta
6   6 1825.3 24.0 collie beta
7   7 2205.3 37.2  akita alfa
8   8 1822.6 13.9  akita beta
9   9 1608.1 23.5 collie alfa
10 10 1717.8 22.7  akita beta
11 11 2206.2 32.7 beagle beta
12 12 1950.3 30.1 beagle beta
13 13 2191.8 39.1  akita beta
14 14 2176.5 38.2 collie alfa
15 15 2060.8 41.8 collie alfa

A este data frame:

   id   peso alto raza_akita raza_collie raza_beagle vac_alfa vac_beta
1   1 1988.4 24.5          1           0           0        1        0
2   2 2070.0 54.9          0           1           0        0        1
3   3 2063.3 43.5          0           1           0        1        0
4   4 1759.0 51.4          1           0           0        0        1
5   5 2123.1 20.8          0           0           1        0        1
6   6 1825.3 24.0          0           1           0        0        1
7   7 2205.3 37.2          1           0           0        1        0
8   8 1822.6 13.9          1           0           0        0        1
9   9 1608.1 23.5          0           1           0        1        0
10 10 1717.8 22.7          1           0           0        0        1
11 11 2206.2 32.7          0           0           1        0        1
12 12 1950.3 30.1          0           0           1        0        1
13 13 2191.8 39.1          1           0           0        0        1
14 14 2176.5 38.2          0           1           0        1        0
15 15 2060.8 41.8          0           1           0        1        0

En este ejemplo, la manera de interpretar las variables dummy es observando las columnas con el prefijo “raza_” y “vac_”.

Para cada renglón, si una variable dummy con el prefijo “raza_” contiene un 1, esto indica que el perro en ese renglón pertenece a esa raza. Lo mismo hacemos con las columnas con el prefijo “vac_”.

De este modo, el primer perro en nuestro datos es un akita, pues tiene un 1 en la columna raza_akita y el tipo de vacuna que se le ha aplicado es beta, pues tiene un 1 en vac_beta.

Veamos como llegar a este resultado, paso por paso, definiendo nuestra propia función.

Definiendo una función para crear variables dummy

Usaremos los siguientes paquetes, que forman parte del tidyverse, una familia de paquetes diseñados para realizar operaciones comunes en R de manera más intuitiva y organizada:

  • dplyr. Manipulación y transformación de datos en data frames.
  • tidyr. Re-estructurar y limpiar la estructura de data frames.
  • map. Manipulación de listas y programación funcional.

La manera más fácil de agregar estos paquetes en nuestro espacio de trabajo de R es a través de cargar todo tidyverse con library.

library(tidyverse)

Si no tienes instalado este paquete, usamos la función install.packages.

install.packages("tidyverse")

Generamos los datos que usaremos en nuestro ejemplo con data.frame.

Poblaremos un data frame con datos de id, peso, alto, raza y vacuna aplicada a 15 perros de una veterinaria hipotética.

Las funciones rnorm y sample son usadas para generar datos aleatorios, mientras que set.seed es una función que nos permite reproducir sus resultados, de modo tal que obtengas los mismos valores que ves aquí. round simplemente redondea datos numéricos.

set.seed(1986)
perros <- 
  data.frame(
    id = 1:15,
    peso = round(rnorm(n = 15, mean = 2000, sd = 250), 1),
    alto  = round(rnorm(n = 15, mean = 30, sd = 10), 1), 
    raza = sample(x = c("akita", "beagle", "collie"), size = 15, 
                     replace = TRUE),
    vac = sample(x = c("alfa", "beta"), size = 15, replace = TRUE)
  )

Nuestro data frame es el siguiente.

perros
   id   peso alto   raza  vac
1   1 1988.4 24.5  akita alfa
2   2 2070.0 54.9 collie beta
3   3 2063.3 43.5 collie alfa
4   4 1759.0 51.4  akita beta
5   5 2123.1 20.8 beagle beta
6   6 1825.3 24.0 collie beta
7   7 2205.3 37.2  akita alfa
8   8 1822.6 13.9  akita beta
9   9 1608.1 23.5 collie alfa
10 10 1717.8 22.7  akita beta
11 11 2206.2 32.7 beagle beta
12 12 1950.3 30.1 beagle beta
13 13 2191.8 39.1  akita beta
14 14 2176.5 38.2 collie alfa
15 15 2060.8 41.8 collie alfa

Comenzamos usando la función mutate para modificar y crear columnas.

Agregamos el prefijo “raza” y “vac” a los datos de la columnas con esos nombres. Esto nos servirá más adelante organizar y distinguir nuestras variables dummy.

A lo largo de este ejemplo usaremos el pipe de dplyr, %>%, el cual indica que el resultado de una función es usado como los argumentos de la siguiente. Esto facilita programar y depurar operaciones que ocurren en secuencia, así que veras frecuentemente este operador.

perros %>% 
  mutate(raza = paste("raza", raza, sep = "_"))
   id   peso alto        raza  vac
1   1 1988.4 24.5  raza_akita alfa
2   2 2070.0 54.9 raza_collie beta
3   3 2063.3 43.5 raza_collie alfa
4   4 1759.0 51.4  raza_akita beta
5   5 2123.1 20.8 raza_beagle beta
6   6 1825.3 24.0 raza_collie beta
7   7 2205.3 37.2  raza_akita alfa
8   8 1822.6 13.9  raza_akita beta
9   9 1608.1 23.5 raza_collie alfa
10 10 1717.8 22.7  raza_akita beta
11 11 2206.2 32.7 raza_beagle beta
12 12 1950.3 30.1 raza_beagle beta
13 13 2191.8 39.1  raza_akita beta
14 14 2176.5 38.2 raza_collie alfa
15 15 2060.8 41.8 raza_collie alfa

Ahora creamos una columna llamada valor_raza, que llenamos con unos. De este modo indicaremos la presencia de esta variable al convertir la columna raza en varias dummy. Hacemos lo mismo con la columna vac.

perros %>% 
  mutate(raza = paste("raza", raza, sep = "_"),
         valor_raza = 1,
         vac = paste("vac", vac, sep = "_"),
         valor_vac = 1
         )
   id   peso alto        raza      vac valor_raza valor_vac
1   1 1988.4 24.5  raza_akita vac_alfa          1         1
2   2 2070.0 54.9 raza_collie vac_beta          1         1
3   3 2063.3 43.5 raza_collie vac_alfa          1         1
4   4 1759.0 51.4  raza_akita vac_beta          1         1
5   5 2123.1 20.8 raza_beagle vac_beta          1         1
6   6 1825.3 24.0 raza_collie vac_beta          1         1
7   7 2205.3 37.2  raza_akita vac_alfa          1         1
8   8 1822.6 13.9  raza_akita vac_beta          1         1
9   9 1608.1 23.5 raza_collie vac_alfa          1         1
10 10 1717.8 22.7  raza_akita vac_beta          1         1
11 11 2206.2 32.7 raza_beagle vac_beta          1         1
12 12 1950.3 30.1 raza_beagle vac_beta          1         1
13 13 2191.8 39.1  raza_akita vac_beta          1         1
14 14 2176.5 38.2 raza_collie vac_alfa          1         1
15 15 2060.8 41.8 raza_collie vac_alfa          1         1

Finalmente usamos la función spread para convertir las columnas raza y vac en múltiples columnas. Esta función hace una transposición, convirtiendo datos altos a datos anchos.

spread nos pide dos argumentos, ╔key y value. `key es el nombre de la columna que se usará para nombrar a las nuevas columnas, value es el valor que estas tendrán.

perros %>% 
  mutate(raza = paste("raza", raza, sep = "_"),
         valor_raza = 1,
         vac = paste("vac", vac, sep = "_"),
         valor_vac = 1
         ) %>% 
  spread(key = raza, value = valor_raza)
   id   peso alto      vac valor_vac raza_akita raza_beagle raza_collie
1   1 1988.4 24.5 vac_alfa         1          1          NA          NA
2   2 2070.0 54.9 vac_beta         1         NA          NA           1
3   3 2063.3 43.5 vac_alfa         1         NA          NA           1
4   4 1759.0 51.4 vac_beta         1          1          NA          NA
5   5 2123.1 20.8 vac_beta         1         NA           1          NA
6   6 1825.3 24.0 vac_beta         1         NA          NA           1
7   7 2205.3 37.2 vac_alfa         1          1          NA          NA
8   8 1822.6 13.9 vac_beta         1          1          NA          NA
9   9 1608.1 23.5 vac_alfa         1         NA          NA           1
10 10 1717.8 22.7 vac_beta         1          1          NA          NA
11 11 2206.2 32.7 vac_beta         1         NA           1          NA
12 12 1950.3 30.1 vac_beta         1         NA           1          NA
13 13 2191.8 39.1 vac_beta         1          1          NA          NA
14 14 2176.5 38.2 vac_alfa         1         NA          NA           1
15 15 2060.8 41.8 vac_alfa         1         NA          NA           1

Hacemos los mismo con vac.

perros %>% 
  mutate(raza = paste("raza", raza, sep = "_"),
         valor_raza = 1,
         vac = paste("vac", vac, sep = "_"),
         valor_vac = 1
         ) %>% 
  spread(key = raza, value = valor_raza) %>% 
  spread(key = vac, value = valor_vac)
   id   peso alto raza_akita raza_beagle raza_collie vac_alfa vac_beta
1   1 1988.4 24.5          1          NA          NA        1       NA
2   2 2070.0 54.9         NA          NA           1       NA        1
3   3 2063.3 43.5         NA          NA           1        1       NA
4   4 1759.0 51.4          1          NA          NA       NA        1
5   5 2123.1 20.8         NA           1          NA       NA        1
6   6 1825.3 24.0         NA          NA           1       NA        1
7   7 2205.3 37.2          1          NA          NA        1       NA
8   8 1822.6 13.9          1          NA          NA       NA        1
9   9 1608.1 23.5         NA          NA           1        1       NA
10 10 1717.8 22.7          1          NA          NA       NA        1
11 11 2206.2 32.7         NA           1          NA       NA        1
12 12 1950.3 30.1         NA           1          NA       NA        1
13 13 2191.8 39.1          1          NA          NA       NA        1
14 14 2176.5 38.2         NA          NA           1        1       NA
15 15 2060.8 41.8         NA          NA           1        1       NA

Nuestras variables están casi listas. Tenemos que cambiar los NA por 0. Debemos dar un argumento adicional a spread, fill = 0.

perros %>% 
  mutate(raza = paste("raza", raza, sep = "_"),
         valor_raza = 1,
         vac = paste("vac", vac, sep = "_"),
         valor_vac = 1
         ) %>% 
  spread(key = raza, value = valor_raza, fill = 0) %>% 
  spread(key = vac, value = valor_vac, fill = 0)
   id   peso alto raza_akita raza_beagle raza_collie vac_alfa vac_beta
1   1 1988.4 24.5          1           0           0        1        0
2   2 2070.0 54.9          0           0           1        0        1
3   3 2063.3 43.5          0           0           1        1        0
4   4 1759.0 51.4          1           0           0        0        1
5   5 2123.1 20.8          0           1           0        0        1
6   6 1825.3 24.0          0           0           1        0        1
7   7 2205.3 37.2          1           0           0        1        0
8   8 1822.6 13.9          1           0           0        0        1
9   9 1608.1 23.5          0           0           1        1        0
10 10 1717.8 22.7          1           0           0        0        1
11 11 2206.2 32.7          0           1           0        0        1
12 12 1950.3 30.1          0           1           0        0        1
13 13 2191.8 39.1          1           0           0        0        1
14 14 2176.5 38.2          0           0           1        1        0
15 15 2060.8 41.8          0           0           1        1        0

¡Listo! Tenemos variables dummy para raza y para vac.

Por supuesto podemos definir una función para realizar esta tarea fácilmente.

Como tidyverse tiene una forma no estándar de evaluar los nombres de variables, usaremos mutate_at en lugar de mutate y las funciones eval y as.symbol. Estas dos últimas funciones son usadas para interpretar cadenas de texto como nombres de objetos.

La función que vamos a definir recibirá como argumentos un data frame y el nombre de la columna que deseamos convertir a dummy, como cadena de texto.

Nombramos a nuestra función columna_dummy.

columna_dummy <- function(df, columna) {
  df %>% 
  mutate_at(columna, ~paste(columna, eval(as.symbol(columna)), sep = "_")) %>% 
    mutate(valor = 1) %>% 
    spread(key = columna, value = valor, fill = 0)
}

Probemos nuestra función con la columna raza.

columna_dummy(perros, "raza")
   id   peso alto  vac raza_akita raza_beagle raza_collie
1   1 1988.4 24.5 alfa          1           0           0
2   2 2070.0 54.9 beta          0           0           1
3   3 2063.3 43.5 alfa          0           0           1
4   4 1759.0 51.4 beta          1           0           0
5   5 2123.1 20.8 beta          0           1           0
6   6 1825.3 24.0 beta          0           0           1
7   7 2205.3 37.2 alfa          1           0           0
8   8 1822.6 13.9 beta          1           0           0
9   9 1608.1 23.5 alfa          0           0           1
10 10 1717.8 22.7 beta          1           0           0
11 11 2206.2 32.7 beta          0           1           0
12 12 1950.3 30.1 beta          0           1           0
13 13 2191.8 39.1 beta          1           0           0
14 14 2176.5 38.2 alfa          0           0           1
15 15 2060.8 41.8 alfa          0           0           1

Probamos ahora con la columna vac.

columna_dummy(perros, "vac")
   id   peso alto   raza vac_alfa vac_beta
1   1 1988.4 24.5  akita        1        0
2   2 2070.0 54.9 collie        0        1
3   3 2063.3 43.5 collie        1        0
4   4 1759.0 51.4  akita        0        1
5   5 2123.1 20.8 beagle        0        1
6   6 1825.3 24.0 collie        0        1
7   7 2205.3 37.2  akita        1        0
8   8 1822.6 13.9  akita        0        1
9   9 1608.1 23.5 collie        1        0
10 10 1717.8 22.7  akita        0        1
11 11 2206.2 32.7 beagle        0        1
12 12 1950.3 30.1 beagle        0        1
13 13 2191.8 39.1  akita        0        1
14 14 2176.5 38.2 collie        1        0
15 15 2060.8 41.8 collie        1        0

El resultado anterior está bien si queremos transformar en dummy una variable a la vez, pero es poco práctica para realizar múltiples transformaciones.

Podemos usar las funciones lapply de R base o map del paquete purrr del tidyverse para definir una nueva función que pueda convertir a dummy más de una variable a la vez.

Como estamos usando tidyverse, usaremos map, una función que nos permite aplicar una función a todos los elementos de una lista, o un objeto coercionable a una lista, como es el caso de los data frame.

Vamos a aplicar columna_dummy a los elementos de nuestro data frame perros llamados raza y vac.

map(c("raza", "vac"), columna_dummy, df = perros) 
[[1]]
   id   peso alto  vac raza_akita raza_beagle raza_collie
1   1 1988.4 24.5 alfa          1           0           0
2   2 2070.0 54.9 beta          0           0           1
3   3 2063.3 43.5 alfa          0           0           1
4   4 1759.0 51.4 beta          1           0           0
5   5 2123.1 20.8 beta          0           1           0
6   6 1825.3 24.0 beta          0           0           1
7   7 2205.3 37.2 alfa          1           0           0
8   8 1822.6 13.9 beta          1           0           0
9   9 1608.1 23.5 alfa          0           0           1
10 10 1717.8 22.7 beta          1           0           0
11 11 2206.2 32.7 beta          0           1           0
12 12 1950.3 30.1 beta          0           1           0
13 13 2191.8 39.1 beta          1           0           0
14 14 2176.5 38.2 alfa          0           0           1
15 15 2060.8 41.8 alfa          0           0           1

[[2]]
   id   peso alto   raza vac_alfa vac_beta
1   1 1988.4 24.5  akita        1        0
2   2 2070.0 54.9 collie        0        1
3   3 2063.3 43.5 collie        1        0
4   4 1759.0 51.4  akita        0        1
5   5 2123.1 20.8 beagle        0        1
6   6 1825.3 24.0 collie        0        1
7   7 2205.3 37.2  akita        1        0
8   8 1822.6 13.9  akita        0        1
9   9 1608.1 23.5 collie        1        0
10 10 1717.8 22.7  akita        0        1
11 11 2206.2 32.7 beagle        0        1
12 12 1950.3 30.1 beagle        0        1
13 13 2191.8 39.1  akita        0        1
14 14 2176.5 38.2 collie        1        0
15 15 2060.8 41.8 collie        1        0

¡Luce bien! Sin embargo, nuestro resultado es una lista con dos data frames, en lugar de un data frame.

¡Luce bien! Sin embargo, nuestro resultado es una lista con dos data frames, en lugar de un data frame.

Usamos reduce de purrr e inner_join de dplyr para unir estas dos data frames en una sola, tomando las columnas en comun como índice, un proceso similar lo que haríamos en SQL.

map(c("raza", "vac"), columna_dummy, df = perros) %>% 
  reduce(inner_join)
   id   peso alto  vac raza_akita raza_beagle raza_collie   raza vac_alfa
1   1 1988.4 24.5 alfa          1           0           0  akita        1
2   2 2070.0 54.9 beta          0           0           1 collie        0
3   3 2063.3 43.5 alfa          0           0           1 collie        1
4   4 1759.0 51.4 beta          1           0           0  akita        0
5   5 2123.1 20.8 beta          0           1           0 beagle        0
6   6 1825.3 24.0 beta          0           0           1 collie        0
7   7 2205.3 37.2 alfa          1           0           0  akita        1
8   8 1822.6 13.9 beta          1           0           0  akita        0
9   9 1608.1 23.5 alfa          0           0           1 collie        1
10 10 1717.8 22.7 beta          1           0           0  akita        0
11 11 2206.2 32.7 beta          0           1           0 beagle        0
12 12 1950.3 30.1 beta          0           1           0 beagle        0
13 13 2191.8 39.1 beta          1           0           0  akita        0
14 14 2176.5 38.2 alfa          0           0           1 collie        1
15 15 2060.8 41.8 alfa          0           0           1 collie        1
   vac_beta
1         0
2         1
3         0
4         1
5         1
6         1
7         0
8         1
9         0
10        1
11        1
12        1
13        1
14        0
15        0

Nos resta quitar del data frame resultante las columnas raza y vac originales.

Esto lo haremos al definir la función crear_variables, que tomará como argumentos un data frame y los nombres de las variables que deseamos convertir a dummy. De este modo, podremos usar select para quitar del data frame resultante las variables originales.

crear_dummies <- function(df, nombres) {
  map(c("raza", "vac"), columna_dummy, df = perros) %>% 
    reduce(inner_join) %>% 
    select(-c(nombres))
}

Probemos nuestra nueva función.

crear_dummies(perros, c("raza", "vac"))
   id   peso alto raza_akita raza_beagle raza_collie vac_alfa vac_beta
1   1 1988.4 24.5          1           0           0        1        0
2   2 2070.0 54.9          0           0           1        0        1
3   3 2063.3 43.5          0           0           1        1        0
4   4 1759.0 51.4          1           0           0        0        1
5   5 2123.1 20.8          0           1           0        0        1
6   6 1825.3 24.0          0           0           1        0        1
7   7 2205.3 37.2          1           0           0        1        0
8   8 1822.6 13.9          1           0           0        0        1
9   9 1608.1 23.5          0           0           1        1        0
10 10 1717.8 22.7          1           0           0        0        1
11 11 2206.2 32.7          0           1           0        0        1
12 12 1950.3 30.1          0           1           0        0        1
13 13 2191.8 39.1          1           0           0        0        1
14 14 2176.5 38.2          0           0           1        1        0
15 15 2060.8 41.8          0           0           1        1        0

¡Hemos terminado!

Por supuesto, si no quieres definir esta función para cada uno de tus proyectos en R, puedes crear un paquete local que la incluya o puedes usar un paquete ya existente que realice esta transformación. Uno de ellos es fastDummies.

Usando fastDummies

El paquete fastDummies esta diseñado específicamente para convertir variables categóricas en dummies.

Cargamos este paquete con library.

library(fastDummies)

Si no lo tenemos instalado, usamos install.packages.

install.packages("fastDummies")

Podemos crear variables dummy con la función dummy_cols. Damos como argumentos un data frame y el nombre de las columnas que queremos convertir a dummy. Si no damos nombres de columna, convertirá todas las que sean de tipo carácter o factor.

dummy_cols(perros,  select_columns = c("raza", "vac"))
   id   peso alto   raza  vac raza_akita raza_collie raza_beagle vac_alfa
1   1 1988.4 24.5  akita alfa          1           0           0        1
2   2 2070.0 54.9 collie beta          0           1           0        0
3   3 2063.3 43.5 collie alfa          0           1           0        1
4   4 1759.0 51.4  akita beta          1           0           0        0
5   5 2123.1 20.8 beagle beta          0           0           1        0
6   6 1825.3 24.0 collie beta          0           1           0        0
7   7 2205.3 37.2  akita alfa          1           0           0        1
8   8 1822.6 13.9  akita beta          1           0           0        0
9   9 1608.1 23.5 collie alfa          0           1           0        1
10 10 1717.8 22.7  akita beta          1           0           0        0
11 11 2206.2 32.7 beagle beta          0           0           1        0
12 12 1950.3 30.1 beagle beta          0           0           1        0
13 13 2191.8 39.1  akita beta          1           0           0        0
14 14 2176.5 38.2 collie alfa          0           1           0        1
15 15 2060.8 41.8 collie alfa          0           1           0        1
   vac_beta
1         0
2         1
3         0
4         1
5         1
6         1
7         0
8         1
9         0
10        1
11        1
12        1
13        1
14        0
15        0

Esta función nos devuelve un data frame que conserva las variables originales, así que tenemos que usar select para quitarlas, si así lo deseamos.

dummy_cols(perros,  select_columns = c("raza", "vac")) %>% 
  select(-c("raza", "vac"))
   id   peso alto raza_akita raza_collie raza_beagle vac_alfa vac_beta
1   1 1988.4 24.5          1           0           0        1        0
2   2 2070.0 54.9          0           1           0        0        1
3   3 2063.3 43.5          0           1           0        1        0
4   4 1759.0 51.4          1           0           0        0        1
5   5 2123.1 20.8          0           0           1        0        1
6   6 1825.3 24.0          0           1           0        0        1
7   7 2205.3 37.2          1           0           0        1        0
8   8 1822.6 13.9          1           0           0        0        1
9   9 1608.1 23.5          0           1           0        1        0
10 10 1717.8 22.7          1           0           0        0        1
11 11 2206.2 32.7          0           0           1        0        1
12 12 1950.3 30.1          0           0           1        0        1
13 13 2191.8 39.1          1           0           0        0        1
14 14 2176.5 38.2          0           1           0        1        0
15 15 2060.8 41.8          0           1           0        1        0

dummy_cols además acepta un par de argumentos más, que son útiles para evitar colinealidad en ciertos modelos estadísticos:

  • remove_first_dummy: Quita la primera categoría en las variables convertidas a dummy.
  • remove_most_frequent_dummy: Quita la categoría más numerosa en las variables convertidas a dummy.

Por último, dummy_rows es una función que nos sirve para generar renglones para los cuales no existen datos para todas las combinaciones de variables categóricas existentes.

Nosotros no tenemos datos para la combinación raza = “beagle” y vac = “alfa”, así que genera un renglón para esta combinación, asignando NA como valor para las demás variables.

dummy_rows(perros)
   id   peso alto   raza  vac
1   1 1988.4 24.5  akita alfa
2   2 2070.0 54.9 collie beta
3   3 2063.3 43.5 collie alfa
4   4 1759.0 51.4  akita beta
5   5 2123.1 20.8 beagle beta
6   6 1825.3 24.0 collie beta
7   7 2205.3 37.2  akita alfa
8   8 1822.6 13.9  akita beta
9   9 1608.1 23.5 collie alfa
10 10 1717.8 22.7  akita beta
11 11 2206.2 32.7 beagle beta
12 12 1950.3 30.1 beagle beta
13 13 2191.8 39.1  akita beta
14 14 2176.5 38.2 collie alfa
15 15 2060.8 41.8 collie alfa
16 NA     NA   NA beagle alfa

Conclusiones

En este artículo revisamos dos procedimientos para crear variables dummy en R, proceso al que también se le conoce como one-hot encoding. En mi experiencia manipulando datos, esta es una transformación a la cual no puedes escapar si quieres trabajar algoritmos de Machine Learning y Deep Learning.

En el mundo real, los datos nunca tienen el formato ideal para ser analizados, así que contar con las herramientas para poder manipularlos a formatos que cubran nuestras necesidades es sumamente importante y algo en lo que vale la pena invertir un poco de tiempo.


Consultas, dudas, comentarios y correcciones son bienvenidas:

El código y los datos usados en este documento se encuentran en Github:

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *