vtreat en un ejemplo pequeño

En este ejercicio, vas a usar vtreat para aplicar one-hot-encoding a una variable categórica en un ejemplo pequeño. vtreat crea un plan de tratamiento para transformar variables categóricas en variables indicadoras (codificadas como "lev") y para limpiar valores problemáticos de variables numéricas (codificadas como "clean").

Para diseñar un plan de tratamiento, usa la función designTreatmentsZ() (docs)

treatplan <- designTreatmentsZ(data, varlist)

data: el data frame de entrenamiento original
varlist: un vector con las variables de entrada a tratar (como cadenas).

designTreatmentsZ() devuelve una lista con un elemento scoreFrame: un data frame que incluye los nombres y tipos de las nuevas variables:

scoreFrame <- treatplan %>% 
            magrittr::use_series(scoreFrame) %>% 
            select(varName, origName, code)

varName: el nombre de la nueva variable tratada
origName: el nombre de la variable original de la que procede la variable tratada
code: el tipo de la nueva variable.
- "clean": una variable numérica sin NAs ni NaNs
- "lev": una variable indicadora para un nivel específico de la variable categórica original.

(magrittr::use_series() (docs) es un alias de $ que puedes usar en tuberías.)

Para estos ejercicios, queremos varName donde code sea "clean" o "lev":

newvarlist <- scoreFrame %>% 
             filter(code %in% c("clean", "lev") %>%
             magrittr::use_series(varName)

Para transformar el conjunto de datos a variables todas numéricas y con one-hot-encoding, usa prepare() (docs):

data.treat <- prepare(treatplan, data, varRestrictions = newvarlist)

treatplan: el plan de tratamiento
data: el data frame a tratar
varRestrictions: las variables deseadas en los datos tratados

El data frame dframe y el paquete magrittr ya están precargados.

Este ejercicio forma parte del curso

Aprendizaje supervisado en R: Regresión

Ver curso

Instrucciones del ejercicio

Imprime dframe. Supondremos que color y size son variables de entrada, y popularity es la salida que queremos predecir.
Crea un vector llamado vars con los nombres de las variables de entrada (como cadenas).
Carga el paquete vtreat.
Usa designTreatmentsZ() para crear un plan de tratamiento para las variables en vars. Asígñalo a la variable treatplan.
Obtén y examina el scoreFrame del plan de tratamiento para ver el mapeo de variables antiguas a nuevas.
- Solo necesitas las columnas varName, origName y code.
- ¿Cuáles son los nombres de las nuevas variables indicadoras? ¿Y de la variable continua?
Crea un vector newvars que contenga la variable varName donde code sea clean o lev. Imprímelo.
Usa prepare() para crear un nuevo data frame dframe.treat que sea una versión con one-hot-encoding de dframe (sin la columna de la salida).
- Imprímelo y compáralo con dframe.

ejercicio interactivo práctico

Prueba este ejercicio completando este código de ejemplo.

# Print dframe
dframe

# Create and print a vector of variable names
(vars <- ___)

# Load the package vtreat
___

# Create the treatment plan
treatplan <- ___(___, ___)

# Examine the scoreFrame
(scoreFrame <- treatplan %>%
    use_series(scoreFrame) %>%
    select(___, ___, ___))

# We only want the rows with codes "clean" or "lev"
(newvars <- scoreFrame %>%
    filter(code %in% ___) %>%
    use_series(varName))

# Create the treated training data
(dframe.treat <- ___(___, ___, varRestriction = newvars))

Editar y ejecutar código