Tutorial Pandas: Codificación de variables categóricas a numéricas

¿Qué son las variables categóricas o de texto en Pandas?

En el contexto de Pandas, una biblioteca de análisis de datos para Python, las variables categóricas o de texto son aquellas que contienen valores discretos y no numéricos. Estas variables representan categorías y pueden tomar un número limitado de valores posibles. 

Las variables categóricas son comunes en conjuntos de datos y a menudo se utilizan para describir atributos cualitativos como colores, tipos de productos, géneros, entre otros.

Las variables categóricas pueden ser de dos tipos:

1. Nominales: No tienen un orden intrínseco. Por ejemplo, los colores de un coche ('rojo', 'azul', 'verde') o los tipos de productos ('electrónica', 'ropa', 'alimentos').
2. Ordinales: Tienen un orden intrínseco. Por ejemplo, las tallas de ropa ('pequeña', 'mediana', 'grande') o las calificaciones de un servicio ('malo', 'regular', 'bueno', 'excelente').

En Pandas, las columnas de un DataFrame que contienen variables categóricas pueden ser de tipo object (para texto) o de tipo Categorical. Es recomendable convertir las columnas que contienen datos categóricos al tipo Categorical para optimizar la memoria y mejorar el rendimiento en operaciones que involucren estas columnas.

Para ilustrar cómo identificar y trabajar con variables categóricas en Pandas, consideremos el siguiente ejemplo:

import pandas as pd

# Crear un DataFrame de ejemplo
data = {
    'Color': ['Rojo', 'Azul', 'Verde', 'Azul', 'Rojo'],
    'Tamaño': ['Pequeño', 'Mediano', 'Grande', 'Mediano', 'Pequeño'],
    'Precio': [100, 150, 200, 150, 100]
}

df = pd.DataFrame(data)

# Mostrar el tipo de datos de cada columna
print(df.dtypes)

El código anterior generará la siguiente salida, indicando que las columnas 'Color' y 'Tamaño' son de tipo object:

Color     object
Tamaño    object
Precio     int64
dtype: object

Para convertir estas columnas al tipo Categorical, se puede utilizar el método astype de Pandas:

df['Color'] = df['Color'].astype('category')
df['Tamaño'] = df['Tamaño'].astype('category')

# Verificar los tipos de datos después de la conversión
print(df.dtypes)

La salida ahora mostrará que las columnas 'Color' y 'Tamaño' son de tipo category:

Color     category
Tamaño    category
Precio       int64
dtype: object

El uso del tipo Categorical no solo mejora la eficiencia en términos de memoria, sino que también proporciona métodos específicos para trabajar con datos categóricos, como cat.codes para obtener los códigos numéricos correspondientes a cada categoría.

Además, Pandas ofrece funcionalidades avanzadas para manejar variables categóricas, como la creación de variables dummy (dummy variables) utilizando pd.get_dummies(), que es útil para la codificación de variables categóricas en modelos de machine learning:

# Crear variables dummy
df_dummies = pd.get_dummies(df, columns=['Color', 'Tamaño'])

print(df_dummies)

La salida será un DataFrame con columnas adicionales que representan las categorías de 'Color' y 'Tamaño' en formato binario:

   Precio  Color_Azul  Color_Rojo  Color_Verde  Tamaño_Grande  Tamaño_Mediano  Tamaño_Pequeño
0     100       False        True        False          False           False            True     
1     150        True       False        False          False            True           False   
2     200       False       False         True           True           False           False   
3     150        True       False        False          False            True           False   
4     100       False        True        False          False           False            True    

Además de la codificación automática, Pandas permite realizar una codificación ordinal manualmente, asignando valores numéricos específicos a cada categoría de acuerdo con un orden definido por el usuario. Esto es útil cuando se quiere tener control total sobre el orden de las categorías.

Por ejemplo, si tenemos una columna Producto con valores ['Monitor', 'Laptop', 'Tablet', 'Teléfono'], y queremos asignarles un orden específico, podemos hacerlo de la siguiente manera:

# Definir un DataFrame de ejemplo
data = {
    'Producto': ['Laptop', 'Tablet', 'Teléfono', 'Monitor', 'Laptop'],
    'Precio': [1000, 500, 700, 300, 1200]
}

df = pd.DataFrame(data)

# Definir el orden de los productos
orden_producto = {'Monitor': 0, 'Laptop': 1, 'Tablet': 2, 'Teléfono': 3}

# Aplicar la codificación ordinal
df['Producto_Ordinal'] = df['Producto'].map(orden_producto)
print(df)

La salida será:

   Producto  Precio  Producto_Ordinal
0   Laptop    1000                 1
1   Tablet     500                 2
2 Teléfono     700                 3
3  Monitor     300                 0
4   Laptop    1200                 1

Este proceso de conversión y manejo de variables categóricas es esencial para preparar los datos antes de aplicar técnicas de análisis o modelos predictivos, asegurando que las variables categóricas se representen de manera adecuada y eficiente.

¿Cómo se identifican u obtienen las columnas con variables categóricas o texto?

Para identificar u obtener columnas con variables categóricas o texto en un DataFrame de Pandas, se pueden seguir varios enfoques. Estos métodos permiten detectar columnas que contienen datos no numéricos, facilitando su posterior tratamiento y codificación.

Identificación por tipo de datos

Las columnas con variables categóricas o texto suelen ser de tipo object o category. Para identificar estas columnas, se puede inspeccionar el tipo de datos de cada columna utilizando el atributo dtypes del DataFrame.

import pandas as pd

# Crear un DataFrame de ejemplo
data = {
    'Color': ['Rojo', 'Azul', 'Verde', 'Azul', 'Rojo'],
    'Tamaño': ['Pequeño', 'Mediano', 'Grande', 'Mediano', 'Pequeño'],
    'Precio': [100, 150, 200, 150, 100]
}

df = pd.DataFrame(data)

# Mostrar el tipo de datos de cada columna
print(df.dtypes)

La salida será:

Color     object
Tamaño    object
Precio     int64
dtype: object

Para obtener únicamente las columnas de tipo object o category, se puede utilizar el método select_dtypes:

# Seleccionar columnas de tipo 'object' o 'category'
categorical_columns = df.select_dtypes(include=['object', 'category']).columns
print(categorical_columns)

La salida será:

Index(['Color', 'Tamaño'], dtype='object')

Uso de funciones lambda y apply

Otra forma de identificar columnas categóricas es utilizando funciones lambda con el método apply. Esto es útil si se desea aplicar una lógica personalizada para identificar columnas categóricas.

# Identificar columnas categóricas usando una función lambda
categorical_columns = df.apply(lambda col: col.dtype == 'object' or col.dtype.name == 'category').index
print(categorical_columns)

Identificación basada en valores únicos

Las variables categóricas suelen tener un número limitado de valores únicos. Se puede utilizar el método nunique para contar los valores únicos en cada columna y filtrar aquellas con un número limitado de categorías.

# Identificar columnas con menos de un umbral de valores únicos
threshold = 10
categorical_columns = [col for col in df.columns if df[col].nunique() < threshold and df[col].dtype == 'object']
print(categorical_columns)

Ejemplo completo

A continuación se muestra un ejemplo completo que combina varios métodos para identificar columnas categóricas:

import pandas as pd

# Crear un DataFrame de ejemplo
data = {
    'Color': ['Rojo', 'Azul', 'Verde', 'Azul', 'Rojo'],
    'Tamaño': ['Pequeño', 'Mediano', 'Grande', 'Mediano', 'Pequeño'],
    'Precio': [100, 150, 200, 150, 100],
    'Descuento': [5, 10, 15, 10, 5]
}

df = pd.DataFrame(data)

# Método 1: Usar select_dtypes
categorical_columns_method1 = df.select_dtypes(include=['object', 'category']).columns

# Método 2: Usar apply con lambda
categorical_columns_method2 = df.apply(lambda col: col.dtype == 'object' or col.dtype.name == 'category').index

# Método 3: Usar nunique para identificar columnas con pocos valores únicos
threshold = 10
categorical_columns_method3 = [col for col in df.columns if df[col].nunique() < threshold and df[col].dtype == 'object']

print("Método 1:", categorical_columns_method1)
print("Método 2:", categorical_columns_method2)
print("Método 3:", categorical_columns_method3)

La salida será:

Método 1: Index(['Color', 'Tamaño'], dtype='object')
Método 2: Index(['Color', 'Tamaño', 'Precio', 'Descuento'], dtype='object')
Método 3: ['Color', 'Tamaño']

Cada método tiene sus propias ventajas y puede ser útil en diferentes contextos. La elección del método dependerá de las características específicas del conjunto de datos y de los requisitos del análisis.

¿Por qué es importante el encoding o codificación de variables categóricas o texto a numéricas?

La codificación de variables categóricas o texto a numéricas es crucial en el análisis de datos y en la construcción de modelos de machine learning por varias razones fundamentales:

Compatibilidad con algoritmos de machine learning: La mayoría de los algoritmos de machine learning, especialmente los basados en métodos estadísticos y matemáticos, no pueden procesar directamente variables categóricas. Estos algoritmos requieren que todas las características de entrada sean numéricas. Por ejemplo, algoritmos como la regresión lineal, SVM, KNN y redes neuronales trabajan con datos numéricos.

Mejora del rendimiento del modelo: La codificación adecuada de variables categóricas puede mejorar significativamente el rendimiento de los modelos de machine learning. Representar las categorías de manera eficiente permite al modelo capturar mejor las relaciones y patrones en los datos. Por ejemplo, la codificación one-hot evita la introducción de relaciones ordinales no deseadas entre categorías.

Reducción de dimensionalidad: En algunos casos, la codificación de variables categóricas puede ayudar a reducir la dimensionalidad del conjunto de datos. Técnicas como la codificación ordinal o la codificación de frecuencia pueden ser útiles para representar las categorías de manera compacta sin aumentar excesivamente el número de características.

Eficiencia computacional: Trabajar con datos numéricos puede ser más eficiente desde el punto de vista computacional. Las operaciones matemáticas y las optimizaciones en los algoritmos de machine learning suelen ser más rápidas y eficientes cuando se realizan sobre datos numéricos en lugar de datos categóricos.

Manejo de valores faltantes: La codificación de variables categóricas puede facilitar el manejo de valores faltantes. Por ejemplo, al utilizar la codificación ordinal, se puede asignar un valor específico para representar los valores faltantes, lo que permite que los algoritmos de machine learning los manejen de manera más efectiva.

Ejemplo práctico de codificación con Pandas:

Supongamos que tenemos un DataFrame con variables categóricas y queremos prepararlo para su uso en un modelo de machine learning. Consideremos el siguiente ejemplo:

import pandas as pd

# Crear un DataFrame de ejemplo
data = {
    'Color': ['Rojo', 'Azul', 'Verde', 'Azul', 'Rojo'],
    'Tamaño': ['Pequeño', 'Mediano', 'Grande', 'Mediano', 'Pequeño'],
    'Precio': [100, 150, 200, 150, 100]
}

df = pd.DataFrame(data)

Para codificar las variables categóricas, podemos utilizar diferentes técnicas:

• Codificación one-hot:

# Usar pd.get_dummies para la codificación one-hot
df_one_hot = pd.get_dummies(df, columns=['Color', 'Tamaño'])
print(df_one_hot)

La salida será:

   Precio  Color_Azul  Color_Rojo  Color_Verde  Tamaño_Grande  Tamaño_Mediano  Tamaño_Pequeño
0     100       False        True        False          False           False        True         
1     150        True       False        False          False            True        False   
2     200       False       False         True           True           False        False   
3     150        True       False        False          False            True        False   
4     100       False        True        False          False           False        True   

• Codificación ordinal:

# Convertir a tipo 'category' y usar cat.codes para la codificación ordinal
df['Color'] = df['Color'].astype('category')
df['Tamaño'] = df['Tamaño'].astype('category')

df['Color_Ordinal'] = df['Color'].cat.codes
df['Tamaño_Ordinal'] = df['Tamaño'].cat.codes

print(df)

La salida será:

   Color   Tamaño  Precio  Color_Ordinal  Tamaño_Ordinal
0   Rojo  Pequeño     100              1               2
1   Azul  Mediano     150              0               1
2  Verde   Grande     200              2               0
3   Azul  Mediano     150              0               1
4   Rojo  Pequeño     100              1               2

• Codificación de frecuencia:

# Codificación de frecuencia
color_freq = df['Color'].value_counts() / len(df)
tamaño_freq = df['Tamaño'].value_counts() / len(df)

df['Color_Freq'] = df['Color'].map(color_freq)
df['Tamaño_Freq'] = df['Tamaño'].map(tamaño_freq)

print(df)

La salida será:

   Color   Tamaño  Precio  Color_Ordinal  Tamaño_Ordinal  Color_Freq  Tamaño_Freq
0   Rojo  Pequeño     100              1               2         0.4          0.4
1   Azul  Mediano     150              0               1         0.4          0.4
2  Verde   Grande     200              2               0         0.2          0.2
3   Azul  Mediano     150              0               1         0.4          0.4
4   Rojo  Pequeño     100              1               2         0.4          0.4

Cada técnica de codificación tiene sus propias ventajas y desventajas, y la elección de la técnica adecuada dependerá del contexto y del tipo de modelo de machine learning que se esté utilizando.

Formas de codificar variables categóricas o texto a numéricas con Pandas

Para transformar variables categóricas o de texto en datos numéricos, Pandas ofrece varias técnicas. Estas transformaciones son esenciales para la compatibilidad con algoritmos de machine learning y para mejorar la eficiencia en el análisis de datos. 

A continuación se describen las formas más comunes de codificación:

Codificación one-hot: Esta técnica crea una columna binaria para cada categoría única en la variable categórica. En la salida de Pandas, los valores se muestran como `True` o `False`, que equivalen a 1 y 0 respectivamente. Estos valores binarios indican la presencia (`True`/`1`) o ausencia (`False`/`0`) de una categoría específica y son completamente compatibles con los algoritmos de machine learning que esperan datos numéricos.

import pandas as pd

# Crear un DataFrame de ejemplo
data = {
    'Color': ['Rojo', 'Azul', 'Verde', 'Azul', 'Rojo'],
    'Tamaño': ['Pequeño', 'Mediano', 'Grande', 'Mediano', 'Pequeño']
}

df = pd.DataFrame(data)

# Aplicar codificación one-hot
df_one_hot = pd.get_dummies(df, columns=['Color', 'Tamaño'])
print(df_one_hot)

La salida será:

   Color_Azul  Color_Rojo  Color_Verde  Tamaño_Grande  Tamaño_Mediano  Tamaño_Pequeño
0       False        True        False          False           False        True   
1        True       False        False          False            True       False   
2       False       False         True           True           False       False   
3        True       False        False          False            True       False   
4       False        True        False          False           False        True  

Nota: En la salida de Jupyter Notebook, los valores `True` y `False` representan 1 y 0, respectivamente. Estos son valores binarios que indican la presencia o ausencia de una categoría específica.

Codificación ordinal: Asigna un valor entero único a cada categoría. Esta técnica es adecuada cuando las categorías tienen un orden intrínseco.

# Convertir a tipo 'category' y aplicar codificación ordinal
df['Color'] = df['Color'].astype('category')
df['Tamaño'] = df['Tamaño'].astype('category')

df['Color_Ordinal'] = df['Color'].cat.codes
df['Tamaño_Ordinal'] = df['Tamaño'].cat.codes

print(df)

La salida será:

   Color   Tamaño  Color_Ordinal  Tamaño_Ordinal
0   Rojo  Pequeño              1               2
1   Azul  Mediano              0               1
2  Verde   Grande              2               0
3   Azul  Mediano              0               1
4   Rojo  Pequeño              1               2

Codificación de frecuencia: Reemplaza cada categoría por la frecuencia de aparición de esa categoría en el conjunto de datos.

# Calcular la frecuencia de cada categoría
color_freq = df['Color'].value_counts() / len(df)
tamaño_freq = df['Tamaño'].value_counts() / len(df)

# Aplicar codificación de frecuencia
df['Color_Freq'] = df['Color'].map(color_freq)
df['Tamaño_Freq'] = df['Tamaño'].map(tamaño_freq)

print(df)

La salida será:

   Color   Tamaño  Color_Ordinal  Tamaño_Ordinal  Color_Freq  Tamaño_Freq
0   Rojo  Pequeño              1               2         0.4          0.4
1   Azul  Mediano              0               1         0.4          0.4
2  Verde   Grande              2               0         0.2          0.2
3   Azul  Mediano              0               1         0.4          0.4
4   Rojo  Pequeño              1               2         0.4          0.4

Codificación basada en el target: Utiliza el target (variable objetivo) para codificar las categorías. Esto puede incluir técnicas como la media del target por categoría.

# Crear un DataFrame con una variable objetivo
data = {
    'Color': ['Rojo', 'Azul', 'Verde', 'Azul', 'Rojo'],
    'Tamaño': ['Pequeño', 'Mediano', 'Grande', 'Mediano', 'Pequeño'],
    'Precio': [100, 150, 200, 150, 100]
}

df = pd.DataFrame(data)

# Calcular la media del target (Precio) por categoría
color_target_mean = df.groupby('Color')['Precio'].mean()
tamaño_target_mean = df.groupby('Tamaño')['Precio'].mean()

# Aplicar codificación basada en el target
df['Color_Target_Mean'] = df['Color'].map(color_target_mean)
df['Tamaño_Target_Mean'] = df['Tamaño'].map(tamaño_target_mean)

print(df)

La salida será:

   Color   Tamaño  Precio  Color_Target_Mean  Tamaño_Target_Mean
0   Rojo  Pequeño     100              100.0               100.0
1   Azul  Mediano     150              150.0               150.0
2  Verde   Grande     200              200.0               200.0
3   Azul  Mediano     150              150.0               150.0
4   Rojo  Pequeño     100              100.0               100.0

Codificación hashing: Utiliza una función hash para convertir categorías en enteros. Esta técnica es útil para grandes conjuntos de datos con muchas categorías únicas.

from sklearn.feature_extraction import FeatureHasher

# Crear un DataFrame de ejemplo
data = {
    'Color': ['Rojo', 'Azul', 'Verde', 'Azul', 'Rojo']
}

df = pd.DataFrame(data)

# Convertir cada valor en una lista de un solo elemento
df['Color'] = df['Color'].apply(lambda x: [x])

# Aplicar codificación hashing
hasher = FeatureHasher(input_type='string', n_features=3)
hashed_features = hasher.transform(df['Color'])

# Convertir las características hashed a un DataFrame
hashed_df = pd.DataFrame(hashed_features.toarray(), columns=['Color_Hash_1', 'Color_Hash_2', 'Color_Hash_3'])

print(hashed_df)

La salida será:

   Color_Hash_1  Color_Hash_2  Color_Hash_3
0           0.0           0.0           1.0
1           1.0           0.0           0.0
2           0.0           0.0           1.0
3           1.0           0.0           0.0
4           0.0           0.0           1.0

Cada técnica de codificación tiene sus propias ventajas y desventajas, y la elección de una u otra dependerá del contexto y del tipo de análisis o modelo de machine learning que se esté utilizando.