S19L04 – Clases de Codificación de Etiquetas

html
Dominando la Codificación de Etiquetas en Aprendizaje Automático: Una Guía Completa

Tabla de Contenidos

    Introducción a la Codificación de Etiquetas
    Entendiendo el Conjunto de Datos
    Manejo de Datos Faltantes
        
            Datos Numéricos
            Datos Categóricos
        
    
    Codificación de Variables Categóricas
        
            Codificación One-Hot
            Codificación de Etiquetas
            Seleccionando la Técnica de Codificación Adecuada
        
    
    Selección de Características
    Construcción y Evaluación de un Modelo KNN
        
            División del Conjunto de Entrenamiento y Prueba
            Escalado de Características
            Entrenamiento y Evaluación del Modelo
        
    
    Visualización de Regiones de Decisión
    Conclusión




Introducción a la Codificación de Etiquetas

En el aprendizaje automático, la Codificación de Etiquetas es una técnica utilizada para convertir datos categóricos en formato numérico. Dado que muchos algoritmos no pueden trabajar directamente con datos categóricos, codificar estas categorías en números se vuelve una necesidad. La codificación de etiquetas asigna un entero único a cada categoría, facilitando la capacidad del modelo para interpretar y procesar los datos de manera eficiente.

Conceptos Clave:

    Datos Categóricos: Variables que representan categorías, como "Sí/No," "Rojo/Azul/Verde," etc.
    Codificación Numérica: El proceso de convertir datos categóricos en valores numéricos.




Entendiendo el Conjunto de Datos

Para esta guía, utilizaremos el conjunto de datos Weather AUS proveniente de Kaggle. Este conjunto de datos abarca varios atributos relacionados con el clima en diferentes ubicaciones y fechas de Australia.

Descripción del Conjunto de Datos:

    URL: Conjunto de Datos Weather AUS
    Características: Fecha, Ubicación, métricas de temperatura, Precipitación, detalles de viento, Humedad, Presión, cobertura de nubes y más.
    Variable Objetivo: RainTomorrow que indica si lloverá al día siguiente.




Manejo de Datos Faltantes

Los conjuntos de datos del mundo real a menudo contienen valores faltantes, lo que puede obstaculizar el rendimiento de los modelos de aprendizaje automático. Manejar adecuadamente estos valores faltantes es crucial para construir modelos robustos.

Datos Numéricos

Estrategia: Imputar valores faltantes utilizando la media de la columna.

Implementación:





		
		
			
			
Java
			
			import numpy as np
from sklearn.impute import SimpleImputer

# Initialize the imputer with mean strategy
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')

# Identify numerical columns
numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0])

# Fit and transform the data
imp_mean.fit(X.iloc[:, numerical_cols])
X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols])
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						import numpy as np
from sklearn.impute import SimpleImputer
 
# Initialize the imputer with mean strategy
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
 
# Identify numerical columns
numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0])
 
# Fit and transform the data
imp_mean.fit(X.iloc[:, numerical_cols])
X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols])
					
				
			
		



Datos Categóricos

Estrategia: Imputar valores faltantes utilizando la categoría más frecuente.

Implementación:





		
		
			
			
Java
			
			# Identify string columns
string_cols = list(np.where((X.dtypes == object))[0])

# Initialize the imputer with the most frequent strategy
imp_mean = SimpleImputer(missing_values=np.nan, strategy='most_frequent')

# Fit and transform the data
imp_mean.fit(X.iloc[:, string_cols])
X.iloc[:, string_cols] = imp_mean.transform(X.iloc[:, string_cols])
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						# Identify string columns
string_cols = list(np.where((X.dtypes == object))[0])
 
# Initialize the imputer with the most frequent strategy
imp_mean = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
 
# Fit and transform the data
imp_mean.fit(X.iloc[:, string_cols])
X.iloc[:, string_cols] = imp_mean.transform(X.iloc[:, string_cols])
					
				
			
		





Codificación de Variables Categóricas

Después de manejar los datos faltantes, el siguiente paso es codificar las variables categóricas para prepararlas para los algoritmos de aprendizaje automático.

Codificación One-Hot

La codificación One-Hot transforma variables categóricas en un formato que puede ser proporcionado a los algoritmos de ML para mejorar la predicción.

Implementación:





		
		
			
			
Java
			
			from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder

def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer(
        [('encoder', OneHotEncoder(), indices)], 
        remainder='passthrough'
    )
    return columnTransformer.fit_transform(data)
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
 
def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer(
        [('encoder', OneHotEncoder(), indices)], 
        remainder='passthrough'
    )
    return columnTransformer.fit_transform(data)
					
				
			
		



Codificación de Etiquetas

La codificación de etiquetas convierte cada valor de una columna categórica en un entero único. Es particularmente útil para variables categóricas binarias.

Implementación:





		
		
			
			
Java
			
			from sklearn import preprocessing

def LabelEncoderMethod(series):
    le = preprocessing.LabelEncoder()
    le.fit(series)
    return le.transform(series)
			
				
					
				
					1
2
3
4
5
6
				
						from sklearn import preprocessing
 
def LabelEncoderMethod(series):
    le = preprocessing.LabelEncoder()
    le.fit(series)
    return le.transform(series)
					
				
			
		



Seleccionando la Técnica de Codificación Adecuada

Elegir entre la codificación One-Hot y la codificación de etiquetas depende de la naturaleza de los datos categóricos.

Directrices:

    Categorías Binarias: La codificación de etiquetas es suficiente.
    Múltiples Categorías: La codificación One-Hot es preferible para evitar introducir relaciones ordinales.


Implementación:





		
		
			
			
Java
			
			def EncodingSelection(X, threshold=10):
    # Select string columns
    string_cols = list(np.where((X.dtypes == object))[0])
    one_hot_encoding_indices = []
    
    # Decide encoding method based on unique values
    for col in string_cols:
        unique_length = len(pd.unique(X[X.columns[col]]))
        if unique_length == 2 or unique_length &gt; threshold:
            X[X.columns[col]] = LabelEncoderMethod(X[X.columns[col]])
        else:
            one_hot_encoding_indices.append(col)
            
    # Apply One-Hot Encoding
    X = OneHotEncoderMethod(one_hot_encoding_indices, X)
    return X

X = EncodingSelection(X)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						def EncodingSelection(X, threshold=10):
    # Select string columns
    string_cols = list(np.where((X.dtypes == object))[0])
    one_hot_encoding_indices = []
    
    # Decide encoding method based on unique values
    for col in string_cols:
        unique_length = len(pd.unique(X[X.columns[col]]))
        if unique_length == 2 or unique_length &gt; threshold:
            X[X.columns[col]] = LabelEncoderMethod(X[X.columns[col]])
        else:
            one_hot_encoding_indices.append(col)
            
    # Apply One-Hot Encoding
    X = OneHotEncoderMethod(one_hot_encoding_indices, X)
    return X
 
X = EncodingSelection(X)
					
				
			
		





Selección de Características

Seleccionar las características más relevantes mejora el rendimiento del modelo y reduce la complejidad computacional.

Técnica: SelectKBest con Chi-Cuadrado (chi2) como función de puntuación.

Implementación:





		
		
			
			
Java
			
			from sklearn.feature_selection import SelectKBest, chi2
from sklearn import preprocessing

# Initialize SelectKBest
kbest = SelectKBest(score_func=chi2, k=10)

# Initialize Min-Max Scaler
MMS = preprocessing.MinMaxScaler()

# Scale features
x_temp = MMS.fit_transform(X)

# Fit SelectKBest
x_temp = kbest.fit(x_temp, y)

# Identify best features
best_features = np.argsort(x_temp.scores_)[-K_features:]
features_to_delete = best_features = np.argsort(x_temp.scores_)[:-K_features]

# Reduce dataset
X = np.delete(X, features_to_delete, axis=1)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
				
						from sklearn.feature_selection import SelectKBest, chi2
from sklearn import preprocessing
 
# Initialize SelectKBest
kbest = SelectKBest(score_func=chi2, k=10)
 
# Initialize Min-Max Scaler
MMS = preprocessing.MinMaxScaler()
 
# Scale features
x_temp = MMS.fit_transform(X)
 
# Fit SelectKBest
x_temp = kbest.fit(x_temp, y)
 
# Identify best features
best_features = np.argsort(x_temp.scores_)[-K_features:]
features_to_delete = best_features = np.argsort(x_temp.scores_)[:-K_features]
 
# Reduce dataset
X = np.delete(X, features_to_delete, axis=1)
					
				
			
		





Construcción y Evaluación de un Modelo KNN

Con el conjunto de datos preprocesado y las características seleccionadas, procedemos a construir y evaluar un clasificador K-Nearest Neighbors (KNN).

División del Conjunto de Entrenamiento y Prueba

Dividir el conjunto de datos asegura que el modelo se evalúe con datos no vistos, proporcionando una medida de su capacidad de generalización.

Implementación:





		
		
			
			
Java
			
			from sklearn.model_selection import train_test_split

# Split the data
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=1
)

print(X_train.shape)  # Output: (113754, 12)
			
				
					
				
					1
2
3
4
5
6
7
8
				
						from sklearn.model_selection import train_test_split
 
# Split the data
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=1
)
 
print(X_train.shape)  # Output: (113754, 12)
					
				
			
		



Escalado de Características

El escalado de características estandariza el rango de las características, lo cual es esencial para algoritmos como KNN que son sensibles a la escala de los datos.

Implementación:





		
		
			
			
Java
			
			from sklearn import preprocessing

# Initialize StandardScaler
sc = preprocessing.StandardScaler(with_mean=False)

# Fit and transform the training data
sc.fit(X_train)
X_train = sc.transform(X_train)

# Transform the test data
X_test = sc.transform(X_test)

print(X_train.shape)  # Output: (113754, 12)
print(X_test.shape)   # Output: (28439, 12)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						from sklearn import preprocessing
 
# Initialize StandardScaler
sc = preprocessing.StandardScaler(with_mean=False)
 
# Fit and transform the training data
sc.fit(X_train)
X_train = sc.transform(X_train)
 
# Transform the test data
X_test = sc.transform(X_test)
 
print(X_train.shape)  # Output: (113754, 12)
print(X_test.shape)   # Output: (28439, 12)
					
				
			
		



Entrenamiento y Evaluación del Modelo

Implementación:





		
		
			
			
Java
			
			from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# Initialize KNN classifier
knnClassifier = KNeighborsClassifier(n_neighbors=3)

# Train the model
knnClassifier.fit(X_train, y_train)

# Predict on test data
y_pred = knnClassifier.predict(X_test)

# Evaluate accuracy
accuracy = accuracy_score(y_pred, y_test)
print(f"Accuracy: {accuracy}")
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
 
# Initialize KNN classifier
knnClassifier = KNeighborsClassifier(n_neighbors=3)
 
# Train the model
knnClassifier.fit(X_train, y_train)
 
# Predict on test data
y_pred = knnClassifier.predict(X_test)
 
# Evaluate accuracy
accuracy = accuracy_score(y_pred, y_test)
print(f"Accuracy: {accuracy}")
					
				
			
		



Salida:




		
		
			
			
Java
			
			Accuracy: 0.8258
			
				
					
				
					1
				
						Accuracy: 0.8258
					
				
			
		



Una precisión de aproximadamente 82.58% indica que el modelo funciona razonablemente bien para predecir si lloverá al día siguiente basado en las características proporcionadas.



Visualización de Regiones de Decisión

Visualizar las regiones de decisión puede proporcionar ideas sobre cómo el modelo KNN está realizando predicciones. Aunque es más ilustrativo con menos características, aquí hay un fragmento de código de ejemplo para la visualización.

Implementación:





		
		
			
			
Java
			
			# Install mlxtend if not already installed
# pip install mlxtend

from mlxtend.plotting import plot_decision_regions
import matplotlib.pyplot as plt

# Plotting decision regions (Example with first two features)
plot_decision_regions(X_train[:, :2], y_train, clf=knnClassifier, legend=2)

# Adding axis labels
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('KNN Decision Regions')
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						# Install mlxtend if not already installed
# pip install mlxtend
 
from mlxtend.plotting import plot_decision_regions
import matplotlib.pyplot as plt
 
# Plotting decision regions (Example with first two features)
plot_decision_regions(X_train[:, :2], y_train, clf=knnClassifier, legend=2)
 
# Adding axis labels
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('KNN Decision Regions')
plt.show()
					
				
			
		



Nota: La visualización es más efectiva con dos características. Para conjuntos de datos con más características, considera técnicas de reducción de dimensionalidad como PCA antes de la visualización.



Conclusión

La Codificación de Etiquetas es una técnica fundamental en el arsenal de preprocesamiento de datos, permitiendo que los modelos de aprendizaje automático interpreten eficazmente los datos categóricos. Al manejar sistemáticamente los datos faltantes, seleccionar características relevantes y codificar adecuadamente las variables categóricas, se establece una base sólida para construir modelos predictivos robustos. Incorporar estas prácticas en tu flujo de trabajo no solo mejora el rendimiento del modelo, sino que también asegura la escalabilidad y eficiencia en tus proyectos de aprendizaje automático.

Puntos Clave:

    Codificación de Etiquetas transforma datos categóricos en formato numérico, esencial para los algoritmos de ML.
    Manejo de Datos Faltantes de manera adecuada puede prevenir resultados sesgados del modelo.
    Técnicas de Codificación deben elegirse en función de la naturaleza y el número de categorías.
    Selección de Características mejora el rendimiento del modelo eliminando características irrelevantes o redundantes.
    Modelo KNN su efectividad es influenciada por el preprocesamiento adecuado y el escalado de características.


Embárcate en tu viaje de aprendizaje automático dominando estas técnicas de preprocesamiento y desbloquea el potencial para construir modelos que sean tanto precisos como confiables.



Mejora Tu Aprendizaje:

    Explora más técnicas de preprocesamiento en nuestra Guía Avanzada de Preprocesamiento de Datos.
    Profundiza en los algoritmos de aprendizaje automático con nuestro Tutorial Integral de Modelos de ML.


¡Feliz Codificación!