Índice

· Introducción
∘ ¿Por qué no .get_dummies()?
· Importación de datos
∘ Dimensiones
∘ Número de variables categóricas
∘ Filtrar variables categóricas
∘ Número previsto de columnas adicionales
· One Hot Encoding (OHE)
∘ Número real de columnas adicionales

Introducción

Las máquinas AMAN los números NO les gustan tanto los datos de texto

Muchos datos vienen en forma de datos de texto. Los científicos de datos deben poder convertir estos datos a un tipo de datos numéricos para que nuestros algoritmos de aprendizaje automático no exploten

En nuestro primer tutorial de Machine Learning 101 , aprenderemos cómo One Hot Encode (OHE) variables categóricas en un conjunto de datos.

Tomaremos un conjunto de datos sobre ventas de viviendas y codificaremos todas las características categóricas de este marco de datos para crear variables ficticias que tomarán el valor de 0️⃣ o 1⃣ . Estas variables ficticias luego se agregarán nuevamente al marco de datos original.

A su vez, también tendremos que eliminar ️ las columnas de texto originales que se codificaron, ya que a nuestros algoritmos de aprendizaje automático no les gustarían ❌

¿Por qué no .get_dummies( )?

Un enfoque alternativo para codificar variables categóricas es usar el método .get_dummies() . ¿Por qué no usar este método en su lugar?

La respuesta es porque .get_dummies() es mucho menos eficiente que usar OHE para conjuntos de datos más grandes OHE es más eficiente ya que aprovecha algo llamado matriz dispersa en lugar de solo generar el marco de datos completo.

Importación de datos

Los datos para este tutorial se pueden encontrar en mi Github .

# Import libraries
import pandas as pd
import numpy as np
import warnings

# Ignore warnings
warnings.filterwarnings("ignore")
    
# Import data
data = pd.read_csv("Housing_Sales_Data.csv")

# Display subset of data frame
data.iloc[:,:10].head()

Al usar .shape , podemos encontrar las dimensiones de nuestro marco de datos de vivienda: 1379 filas y 80 columnas.

# Inspect df dimensions
data.shape

Usando el método .value_counts( ) , podemos contar el número de cada tipo de variable en nuestro marco de datos Encontraremos 43 columnas de tipo de datos objeto (variables de cadena). Estas son nuestras columnas categóricas.

# Count data types
data.dtypes.value_counts()

      
                

                    
                    
                
            

Ahora crearemos una variable, máscara , que nos permitirá filtrar las columnas no categóricas de nuestro marco de datos. mask tomará un valor booleano para cada característica dependiendo de si la característica es una variable categórica.

# Create mask variable
mask = data.dtypes == np.object

# Display mask
mask

      
                

                    
                    
                
            

# Select only categorical variables
categorical_cols = data.columns[mask]

Es una buena práctica ver cuántas variables adicionales espera que se creen, para ver si su número pronosticado se alinea con el número real de columnas creadas al final.

Para determinar cuántas columnas adicionales se crearían, usamos una función lambda . Para cada variable categórica, la función lambda devolverá la cantidad de clases únicas para esa característica.

# Determine number of extra columns
num_ohe_cols = (data[categorical_cols]
                .apply(lambda x: x.nunique())
                .sort_values(ascending=False))

# Display first 10 rows
num_ohe_cols.head(10)

      
                

                    
                    
                
            

No nos interesará codificar características con un solo valor, por lo que las eliminaremos del marco de datos ❌ En esta ocasión, no hay características con un solo valor, pero es un paso útil.

# No need to encode if there is only one value
small_num_ohe_cols = num_ohe_cols.loc[num_ohe_cols>1]

Como ejemplo, Neighborhood creará 25 variables ficticias, ya que tiene 25 clases únicas (ver arriba). ¡Antes de volver a agregar estas nuevas columnas al marco de datos original, eliminaremos la columna Vecindario original ya que ya no será necesaria (y no se puede usar debido a su tipo de datos)! Así, estamos sumando 25 variables… pero restando 1.

# Subtract 1 value from each feature
small_num_ohe_cols -= 1

# Sum of new features
small_num_ohe_cols.sum()

Una codificación activa (OHE)

Antes de importar OneHotEncoder , haremos una copia de nuestro marco de datos para calcular la diferencia en las columnas antes y después de la codificación.

# Copy of the data
data_ohe = data.copy()

# Import OneHotEncoder
from sklearn.preprocessing import OneHotEncoder

# Initialise
ohe = OneHotEncoder()

# The encoders
ohe = OneHotEncoder(drop="first")

Afortunadamente... no tiene un impacto significativo en la previsibilidad , que es lo que más preocupa al aprendizaje automático Por lo tanto, no lo usaremos aquí.

Ahora, vamos a crear un ciclo for Este ciclo:

1. Recorra cada característica categórica
2. One Hot Encode los datos para devolver una matriz dispersa
3. Eliminar la columna asociada del marco de datos original
4. Obtenga los nombres de todas las etiquetas de clase únicas de la columna
5. Cree nombres de columna para cada columna codificada por valor
6. Crear nuevo marco de datos
7. Agregar nuevo marco de datos codificado al marco de datos original

# (1) - Loop through categorical variables
for col in num_ohe_cols.index:
    
    # (2) - OHE data to get sparse matrix
    new_dat = ohe.fit_transform(data_ohe[[col]])
    
    # (3) - Remove this column from original df
    data_ohe = data_ohe.drop(col, axis=1)
    
     # (4) - Get unique value names
    cats = ohe.categories_
    
    # (5) - Create column names
    new_cols = ['_'.join([col,cat]) for cat in cats[0]]
    
    # (6) - Create new df
    new_df = pd.DataFrame(new_dat.toarray(),columns=new_cols)
    
    # (7) - Append df
    data_ohe = pd.concat([data_ohe, new_df], axis =1)

Este marco de datos luego se agrega al marco de datos original después de que Foundation se haya eliminado de él. Este proceso se repite para las 43 variables categóricas en el marco de datos original

Número real de columnas adicionales

Después de codificar cada variable categórica y agregar todas las variables ficticias al marco de datos original... ahora deseamos determinar cuántas columnas adicionales se crearon mediante la codificación. Recuerde, estamos esperando 215!

Usamos .shape[1] en ambos marcos de datos (el que tiene nuevas variables ficticias y el original). Esto devolverá el número de columnas en ambos marcos de datos. Luego solo restamos uno del otro.

# Column difference is as calculated above
data_ohe.shape[1] - data.shape[1]

¡Finalizado!

¡Con eso, este tutorial ha concluido! Espero que lo haya encontrado util. Hasta la próxima… Sopa de Guisantes ✌️