S30L01 – Clasificador de votación

html
Dominando Técnicas de Ensambles en Aprendizaje Automático: Una Inmersión Profunda en Clasificadores de Votación y Ensambles Manuales
En el panorama en constante evolución del aprendizaje automático, lograr un rendimiento óptimo del modelo a menudo requiere aprovechar múltiples algoritmos. Aquí es donde entran en juego las técnicas de ensambles. Los métodos de ensamble combinan las fortalezas de varios modelos para ofrecer predicciones más precisas y robustas de lo que cualquier modelo individual podría lograr por sí solo. En esta guía completa, exploraremos dos técnicas de ensamble fundamentales: Clasificadores de Votación y Ensambles Manuales. Repasaremos sus implementaciones utilizando la biblioteca scikit-learn de Python, complementadas con un ejemplo práctico utilizando un conjunto de datos meteorológicos de Kaggle.

Tabla de Contenidos

    Introducción a las Técnicas de Ensambles
    Comprendiendo los Clasificadores de Votación
        
            Votación Dura vs. Votación Suave
            Implementando un Clasificador de Votación en Python
        
    
    Explorando Métodos de Ensamble Manuales
        
            Implementación Paso a Paso de un Ensamble Manual
        
    
    Implementación Práctica: Predicción del Clima
        
            Preprocesamiento de Datos
            Construcción del Modelo
            Evaluación de Métodos de Ensamble
        
    
    Conclusión



Introducción a las Técnicas de Ensambles
Aprendizaje por Ensambles es un paradigma poderoso en el aprendizaje automático donde múltiples modelos, a menudo denominados "aprendices débiles", se combinan estratégicamente para formar un "aprendiz fuerte". La premisa fundamental es que, aunque los modelos individuales pueden tener distintos grados de precisión, su sabiduría colectiva puede llevar a un rendimiento mejorado, una reducción de la varianza y una mayor generalización.

¿Por Qué Usar Técnicas de Ensambles?

    Mejora de la Precisión: Combinar múltiples modelos a menudo resulta en un mejor rendimiento predictivo.
    Reducción del Sobreajuste: Los ensambles pueden mitigar el sobreajuste equilibrando los sesgos y las varianzas de los modelos individuales.
    Versatilidad: Aplicable en diversos dominios y compatible con diferentes tipos de modelos.



Comprendiendo los Clasificadores de Votación
Un Clasificador de Votación es uno de los métodos de ensamble más simples y efectivos. Combina las predicciones de múltiples modelos diferentes y emite la clase que recibe la mayoría de los votos.

Votación Dura vs. Votación Suave

    Votación Dura: La predicción final es la moda de las clases predichas por cada modelo. Esencialmente, cada modelo tiene un voto igual, y la clase con más votos gana.
    Votación Suave: En lugar de confiar únicamente en las clases predichas, la votación suave considera las probabilidades predichas de cada clase. La predicción final se basa en la suma de las probabilidades, y se elige la clase con la probabilidad agregada más alta.


Implementando un Clasificador de Votación en Python
Profundicemos en una implementación práctica utilizando la biblioteca scikit-learn de Python. Utilizaremos un conjunto de datos meteorológicos para predecir si lloverá mañana.

1. Importando las Bibliotecas Necesarias




		
		
			
			
Java
			
			import pandas as pd
import numpy as np
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder, LabelEncoder, StandardScaler
from sklearn.feature_selection import SelectKBest, chi2
from sklearn.metrics import accuracy_score, classification_report
			
				
					
				
					1
2
3
4
5
6
7
8
				
						import pandas as pd
import numpy as np
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder, LabelEncoder, StandardScaler
from sklearn.feature_selection import SelectKBest, chi2
from sklearn.metrics import accuracy_score, classification_report
					
				
			
		



2. Carga y Preprocesamiento de Datos




		
		
			
			
Java
			
			# Cargar el conjunto de datos
data = pd.read_csv('weatherAUS - tiny.csv')

# Mostrar las últimas filas
print(data.tail())
			
				
					
				
					1
2
3
4
5
				
						# Cargar el conjunto de datos
data = pd.read_csv('weatherAUS - tiny.csv')
 
# Mostrar las últimas filas
print(data.tail())
					
				
			
		



3. Manejo de Datos Faltantes




		
		
			
			
Java
			
			# Separar características y objetivo
X = data.iloc[:, :-1]
y = data.iloc[:, -1]

# Columnas numéricas
numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns
imputer_num = SimpleImputer(strategy='mean')
X[numerical_cols] = imputer_num.fit_transform(X[numerical_cols])

# Columnas categóricas
categorical_cols = X.select_dtypes(include=['object']).columns
imputer_cat = SimpleImputer(strategy='most_frequent')
X[categorical_cols] = imputer_cat.fit_transform(X[categorical_cols])
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						# Separar características y objetivo
X = data.iloc[:, :-1]
y = data.iloc[:, -1]
 
# Columnas numéricas
numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns
imputer_num = SimpleImputer(strategy='mean')
X[numerical_cols] = imputer_num.fit_transform(X[numerical_cols])
 
# Columnas categóricas
categorical_cols = X.select_dtypes(include=['object']).columns
imputer_cat = SimpleImputer(strategy='most_frequent')
X[categorical_cols] = imputer_cat.fit_transform(X[categorical_cols])
					
				
			
		



4. Codificación de Variables Categóricas




		
		
			
			
Java
			
			# Codificación One-Hot
encoder = OneHotEncoder(drop='first', sparse=False)
encoded_cols = encoder.fit_transform(X[categorical_cols])
encoded_col_names = encoder.get_feature_names_out(categorical_cols)
X_encoded = pd.DataFrame(encoded_cols, columns=encoded_col_names)

# Combinar con características numéricas
X = pd.concat([X[numerical_cols], X_encoded], axis=1)
			
				
					
				
					1
2
3
4
5
6
7
8
				
						# Codificación One-Hot
encoder = OneHotEncoder(drop='first', sparse=False)
encoded_cols = encoder.fit_transform(X[categorical_cols])
encoded_col_names = encoder.get_feature_names_out(categorical_cols)
X_encoded = pd.DataFrame(encoded_cols, columns=encoded_col_names)
 
# Combinar con características numéricas
X = pd.concat([X[numerical_cols], X_encoded], axis=1)
					
				
			
		



5. Selección de Características




		
		
			
			
Java
			
			# Escalado de Características
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Selección de las 5 mejores características
selector = SelectKBest(score_func=chi2, k=5)
X_new = selector.fit_transform(X_scaled, y)
selected_features = selector.get_support(indices=True)
feature_names = X.columns[selected_features]
print(f"Selected Features: {feature_names}")
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						# Escalado de Características
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
 
# Selección de las 5 mejores características
selector = SelectKBest(score_func=chi2, k=5)
X_new = selector.fit_transform(X_scaled, y)
selected_features = selector.get_support(indices=True)
feature_names = X.columns[selected_features]
print(f"Selected Features: {feature_names}")
					
				
			
		



6. División de Conjunto de Entrenamiento y Prueba




		
		
			
			
Java
			
			X_train, X_test, y_train, y_test = train_test_split(
    X_new, y, test_size=0.20, random_state=1
)
			
				
					
				
					1
2
3
				
						X_train, X_test, y_train, y_test = train_test_split(
    X_new, y, test_size=0.20, random_state=1
)
					
				
			
		



7. Construcción de Clasificadores Individuales




		
		
			
			
Java
			
			from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
import xgboost as xgb

# Inicializar modelos
knn = KNeighborsClassifier(n_neighbors=3)
lr = LogisticRegression(random_state=0, max_iter=200)
gnb = GaussianNB()
svc = SVC(probability=True)
dtc = DecisionTreeClassifier()
rfc = RandomForestClassifier(n_estimators=500, max_depth=5)
abc = AdaBoostClassifier()
xgb_model = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss')
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
				
						from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
import xgboost as xgb
 
# Inicializar modelos
knn = KNeighborsClassifier(n_neighbors=3)
lr = LogisticRegression(random_state=0, max_iter=200)
gnb = GaussianNB()
svc = SVC(probability=True)
dtc = DecisionTreeClassifier()
rfc = RandomForestClassifier(n_estimators=500, max_depth=5)
abc = AdaBoostClassifier()
xgb_model = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss')
					
				
			
		



8. Entrenamiento y Evaluación de Modelos Individuales




		
		
			
			
Java
			
			# Lista de modelos y sus nombres
models = [
    ('KNN', knn),
    ('Logistic Regression', lr),
    ('GaussianNB', gnb),
    ('SVC', svc),
    ('Decision Tree', dtc),
    ('Random Forest', rfc),
    ('AdaBoost', abc),
    ('XGBoost', xgb_model)
]

# Entrenamiento y evaluación
for name, model in models:
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    accuracy = accuracy_score(y_pred, y_test)
    print(f"{name} Accuracy: {accuracy:.4f}")
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						# Lista de modelos y sus nombres
models = [
    ('KNN', knn),
    ('Logistic Regression', lr),
    ('GaussianNB', gnb),
    ('SVC', svc),
    ('Decision Tree', dtc),
    ('Random Forest', rfc),
    ('AdaBoost', abc),
    ('XGBoost', xgb_model)
]
 
# Entrenamiento y evaluación
for name, model in models:
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    accuracy = accuracy_score(y_pred, y_test)
    print(f"{name} Accuracy: {accuracy:.4f}")
					
				
			
		


Salida de Muestra:




		
		
			
			
Java
			
			KNN Accuracy: 0.8455
Logistic Regression Accuracy: 0.8690
GaussianNB Accuracy: 0.8220
SVC Accuracy: 0.8700
Decision Tree Accuracy: 0.8345
Random Forest Accuracy: 0.8720
AdaBoost Accuracy: 0.8715
XGBoost Accuracy: 0.8650
			
				
					
				
					1
2
3
4
5
6
7
8
				
						KNN Accuracy: 0.8455
Logistic Regression Accuracy: 0.8690
GaussianNB Accuracy: 0.8220
SVC Accuracy: 0.8700
Decision Tree Accuracy: 0.8345
Random Forest Accuracy: 0.8720
AdaBoost Accuracy: 0.8715
XGBoost Accuracy: 0.8650
					
				
			
		



9. Implementando un Clasificador de Votación




		
		
			
			
Java
			
			from sklearn.ensemble import VotingClassifier

# Inicializar Clasificador de Votación con votación suave
voting_clf = VotingClassifier(
    estimators=[
        ('knn', knn),
        ('lr', lr),
        ('gnb', gnb),
        ('svc', svc),
        ('dtc', dtc),
        ('rfc', rfc),
        ('abc', abc),
        ('xgb', xgb_model)
    ],
    voting='soft'
)

# Entrenar el Clasificador de Votación
voting_clf.fit(X_train, y_train)

# Predecir y evaluar
y_pred_voting = voting_clf.predict(X_test)
voting_accuracy = accuracy_score(y_pred_voting, y_test)
print(f"Voting Classifier Accuracy: {voting_accuracy:.4f}")
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
				
						from sklearn.ensemble import VotingClassifier
 
# Inicializar Clasificador de Votación con votación suave
voting_clf = VotingClassifier(
    estimators=[
        ('knn', knn),
        ('lr', lr),
        ('gnb', gnb),
        ('svc', svc),
        ('dtc', dtc),
        ('rfc', rfc),
        ('abc', abc),
        ('xgb', xgb_model)
    ],
    voting='soft'
)
 
# Entrenar el Clasificador de Votación
voting_clf.fit(X_train, y_train)
 
# Predecir y evaluar
y_pred_voting = voting_clf.predict(X_test)
voting_accuracy = accuracy_score(y_pred_voting, y_test)
print(f"Voting Classifier Accuracy: {voting_accuracy:.4f}")
					
				
			
		


Salida de Muestra:




		
		
			
			
Java
			
			Voting Classifier Accuracy: 0.8650
			
				
					
				
					1
				
						Voting Classifier Accuracy: 0.8650
					
				
			
		




Explorando Métodos de Ensamble Manuales
Mientras que los Clasificadores de Votación ofrecen un enfoque directo para el aprendizaje en ensambles, los Métodos de Ensamble Manuales proporcionan mayor flexibilidad al permitir estrategias personalizadas para combinar las predicciones de los modelos. Esta sección guía a través de una implementación de ensamble manual promediando las probabilidades predichas de los clasificadores individuales.

Implementación Paso a Paso de un Ensamble Manual

1. Predicción de Probabilidades con Modelos Individuales




		
		
			
			
Java
			
			# Predecir probabilidades con KNN
p1 = knn.predict_proba(X_test)

# Predecir probabilidades con Logistic Regression
p2 = lr.predict_proba(X_test)
			
				
					
				
					1
2
3
4
5
				
						# Predecir probabilidades con KNN
p1 = knn.predict_proba(X_test)
 
# Predecir probabilidades con Logistic Regression
p2 = lr.predict_proba(X_test)
					
				
			
		



2. Promediando las Probabilidades




		
		
			
			
Java
			
			# Promediar las probabilidades predichas
p_avg = (p1 + p2) / 2
			
				
					
				
					1
2
				
						# Promediar las probabilidades predichas
p_avg = (p1 + p2) / 2
					
				
			
		



3. Predicción Final Basada en Probabilidades Promediadas




		
		
			
			
Java
			
			# Convertir probabilidades promedio a predicciones finales
y_pred_manual = np.argmax(p_avg, axis=1)

# Evaluar la precisión
manual_accuracy = accuracy_score(y_pred_manual, y_test)
print(f"Manual Ensemble Accuracy: {manual_accuracy:.4f}")
			
				
					
				
					1
2
3
4
5
6
				
						# Convertir probabilidades promedio a predicciones finales
y_pred_manual = np.argmax(p_avg, axis=1)
 
# Evaluar la precisión
manual_accuracy = accuracy_score(y_pred_manual, y_test)
print(f"Manual Ensemble Accuracy: {manual_accuracy:.4f}")
					
				
			
		


Salida de Muestra:




		
		
			
			
Java
			
			Manual Ensemble Accuracy: 0.8600
			
				
					
				
					1
				
						Manual Ensemble Accuracy: 0.8600
					
				
			
		




Implementación Práctica: Predicción del Clima
Para ilustrar la aplicación de las técnicas de ensambles, utilizaremos un conjunto de datos meteorológicos de Kaggle que predice si lloverá mañana basado en diversos factores meteorológicos.

Preprocesamiento de Datos
El preprocesamiento adecuado de los datos es crucial para construir modelos de aprendizaje automático efectivos. Esto implica manejar valores faltantes, codificar variables categóricas, seleccionar características relevantes y escalar los datos.

1. Manejo de Datos Faltantes

    Características Numéricas: Imputadas usando la estrategia de la media.
    Características Categóricas: Imputadas usando la estrategia de la moda.


2. Codificación de Variables Categóricas

    Codificación One-Hot: Aplicada a características categóricas con más de dos categorías únicas.
    Codificación de Etiquetas: Aplicada a características categóricas binarias.


3. Selección de Características
Usando SelectKBest con la estadística chi-cuadrado para seleccionar las 5 características principales que tienen la relación más fuerte con la variable objetivo.

4. Escalado de Características
Aplicado StandardScaler para normalizar el conjunto de características, asegurando que cada característica contribuya por igual al rendimiento del modelo.

Construcción del Modelo
Se construyeron y evaluaron varios clasificadores individuales, incluidos K-Nearest Neighbors, Regresión Logística, Gaussian Naive Bayes, Support Vector Machines, Árboles de Decisión, Random Forests, AdaBoost y XGBoost.

Evaluación de Métodos de Ensamble
Se implementaron tanto un Clasificador de Votación como un Ensamble Manual para evaluar su desempeño frente a los modelos individuales.


Conclusión
Las técnicas de ensambles, particularmente los Clasificadores de Votación y los Ensambles Manuales, son herramientas invaluables en el arsenal de un practicante de aprendizaje automático. Al combinar estratégicamente múltiples modelos, estos métodos mejoran el rendimiento predictivo, reducen el riesgo de sobreajuste y aprovechan las fortalezas de diversos algoritmos. Ya sea que apunte a una mayor precisión o a modelos más robustos, dominar los métodos de ensambles puede elevar significativamente sus proyectos de aprendizaje automático.

Puntos Clave:

    Clasificador de Votación: Ofrece una manera simple pero efectiva de combinar múltiples modelos utilizando votación mayoritaria o promediado de probabilidades.
    Ensamble Manual: Proporciona un control granular sobre cómo se combinan las predicciones, permitiendo estrategias personalizadas que pueden superar a los métodos de ensamble estandarizados.
    Preprocesamiento de Datos: Esencial para asegurar que sus modelos se entrenen con datos limpios y bien estructurados, impactando directamente la efectividad de las técnicas de ensamble.
    Evaluación del Modelo: Siempre compare los métodos de ensamble con los modelos individuales para validar su valor añadido.

Adopte el aprendizaje por ensambles para desbloquear todo el potencial de sus modelos de aprendizaje automático y generar predicciones más precisas y confiables en sus proyectos.


Palabras Clave: Técnicas de Ensambles, Clasificador de Votación, Ensamble Manual, Aprendizaje Automático, Python, scikit-learn, Precisión del Modelo, Preprocesamiento de Datos, Selección de Características, Predicción del Clima, K-Nearest Neighbors, Regresión Logística, Gaussian Naive Bayes, Support Vector Machines, Árboles de Decisión, Random Forests, AdaBoost, XGBoost