Dominando los Modelos de Clasificación: Una Guía Completa con Técnicas de Evaluación y Manejo de Conjuntos de Datos
Introducción
En el ámbito del aprendizaje automático, los modelos de clasificación juegan un papel fundamental en la predicción de resultados categóricos. Ya sea para distinguir entre correos electrónicos de spam y no spam, diagnosticar enfermedades o determinar la satisfacción del cliente, los algoritmos de clasificación proporcionan la base para la toma de decisiones informadas. En este artículo, profundizaremos en la construcción de modelos de clasificación robustos utilizando el poderoso ecosistema de Python, enfocándonos en el preprocesamiento de datos, el entrenamiento del modelo, la evaluación y el manejo de diversos conjuntos de datos. Te guiaremos a través de un cuaderno Jupyter integral que sirve como plantilla maestra para tareas de clasificación, equipado con métricas de evaluación y adaptabilidad a diferentes conjuntos de datos.
Tabla de Contenidos
- Comprendiendo el Conjunto de Datos
- Preprocesamiento de Datos
- Construcción y Evaluación de Modelos de Clasificación
- Conclusión
Comprendiendo el Conjunto de Datos
Antes de sumergirnos en la construcción del modelo, es crucial comprender el conjunto de datos en cuestión. Para esta guía, utilizaremos el conjunto de datos Satisfacción de Pasajeros de Aerolíneas de Kaggle. Este conjunto de datos abarca diversos factores que influyen en la satisfacción de los pasajeros, lo que lo hace ideal para tareas de clasificación.
Carga de Datos
Comenzaremos importando las bibliotecas necesarias y cargando el conjunto de datos en un DataFrame de pandas.
|
1 2 3 4 5 6 7 8 9 10 |
import pandas as pd import seaborn as sns # Load datasets data1 = pd.read_csv('Airline1.csv') data2 = pd.read_csv('Airline2.csv') # Concatenate datasets data = pd.concat([data1, data2]) print(data.shape) |
|
1 |
(129880, 25) |
Esto indica que tenemos 129,880 registros con 25 características cada uno.
Preprocesamiento de Datos
El preprocesamiento de datos es la piedra angular para un rendimiento efectivo del modelo. Implica limpiar los datos, manejar valores faltantes, codificar variables categóricas, seleccionar características relevantes y escalar los datos para asegurar la consistencia.
Manejo de Datos Faltantes
Datos Numéricos:Para las columnas numéricas, emplearemos la imputación por la media para llenar los valores faltantes.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
import numpy as np from sklearn.impute import SimpleImputer # Identify numerical columns numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0]) # Initialize imputer imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean') # Fit and transform imp_mean.fit(X.iloc[:, numerical_cols]) X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols]) |
Para las columnas categóricas, utilizaremos la estrategia de la categoría más frecuente para imputar los valores faltantes.
|
1 2 3 4 5 6 7 8 9 |
# Identify string/object columns string_cols = list(np.where((X.dtypes == np.object))[0]) # Initialize imputer imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent') # Fit and transform imp_freq.fit(X.iloc[:, string_cols]) X.iloc[:, string_cols] = imp_freq.transform(X.iloc[:, string_cols]) |
Codificación de Variables Categóricas
Los modelos de aprendizaje automático requieren entradas numéricas. Por lo tanto, las variables categóricas deben ser codificadas adecuadamente.
Codificación de Etiquetas:Para variables categóricas binarias o aquellas con un alto número de categorías, la codificación de etiquetas es eficiente.
|
1 2 3 4 5 6 7 8 9 |
from sklearn import preprocessing def LabelEncoderMethod(series): le = preprocessing.LabelEncoder() le.fit(series) return le.transform(series) # Encode target variable y = LabelEncoderMethod(y) |
Para variables categóricas con un número limitado de categorías, la codificación one-hot evita que el modelo interprete relaciones numéricas donde no existen.
|
1 2 3 4 5 6 |
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) |
Para optimizar las estrategias de codificación basadas en el número de categorías, implementamos un mecanismo de selección.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
def EncodingSelection(X, threshold=10): string_cols = list(np.where((X.dtypes == np.object))[0]) one_hot_encoding_indices = [] for col in string_cols: length = len(pd.unique(X[X.columns[col]])) if length == 2 or length > threshold: X[X.columns[col]] = LabelEncoderMethod(X[X.columns[col]]) else: one_hot_encoding_indices.append(col) X = OneHotEncoderMethod(one_hot_encoding_indices, X) return X X = EncodingSelection(X) print(X.shape) |
|
1 |
(129880, 26) |
Selección de Características
Seleccionar las características más relevantes mejora el rendimiento del modelo y reduce la complejidad computacional. Utilizaremos la prueba Chi-Cuadrado para la selección de características.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
from sklearn.feature_selection import SelectKBest, chi2 from sklearn import preprocessing # Initialize kbest = SelectKBest(score_func=chi2, k='all') MMS = preprocessing.MinMaxScaler() K_features = 10 # Apply transformations x_temp = MMS.fit_transform(X) x_temp = kbest.fit(x_temp, y) # Select top K features best_features = np.argsort(x_temp.scores_)[-K_features:] features_to_delete = np.argsort(x_temp.scores_)[:-K_features] X = np.delete(X, features_to_delete, axis=1) print(X.shape) |
|
1 |
(129880, 10) |
Escalado de Características
El escalado asegura que todas las características contribuyan de manera equitativa al rendimiento del modelo.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
from sklearn import preprocessing # Initialize scaler sc = preprocessing.StandardScaler(with_mean=False) sc.fit(X_train) # Transform features X_train = sc.transform(X_train) X_test = sc.transform(X_test) print(X_train.shape) print(X_test.shape) |
|
1 2 |
(103904, 10) (25976, 10) |
Construcción y Evaluación de Modelos de Clasificación
Con los datos preprocesados, ahora podemos construir y evaluar varios modelos de clasificación. Exploraremos múltiples algoritmos para comparar su rendimiento.
Clasificador K-Nearest Neighbors (KNN)
KNN es un algoritmo simple pero efectivo que clasifica puntos de datos basándose en la etiqueta mayoritaria de sus vecinos más cercanos.
|
1 2 3 4 5 6 7 8 9 10 11 |
from sklearn.neighbors import KNeighborsClassifier from sklearn.metrics import accuracy_score, classification_report # Initialize and train knnClassifier = KNeighborsClassifier(n_neighbors=10) knnClassifier.fit(X_train, y_train) # Predict and evaluate y_pred = knnClassifier.predict(X_test) print(accuracy_score(y_pred, y_test)) print(classification_report(y_pred, y_test, target_names=['No', 'Yes'])) |
|
1 2 3 4 5 6 7 8 9 |
0.932668617185094 precision recall f1-score support No 0.96 0.92 0.94 15395 Yes 0.90 0.94 0.92 10581 accuracy 0.93 25976 macro avg 0.93 0.93 0.93 25976 weighted avg 0.93 0.93 0.93 25976 |
El clasificador KNN alcanza una alta precisión del 93.27%, lo que indica un excelente rendimiento en la predicción de la satisfacción de los pasajeros.
Regresión Logística
La Regresión Logística modela la probabilidad de un resultado binario, lo que la hace ideal para tareas de clasificación.
|
1 2 3 4 5 6 7 8 9 10 |
from sklearn.linear_model import LogisticRegression # Initialize and train LRM = LogisticRegression() LRM.fit(X_train, y_train) # Predict and evaluate y_pred = LRM.predict(X_test) print(accuracy_score(y_pred, y_test)) print(classification_report(y_pred, y_test)) |
|
1 2 3 4 5 6 7 8 9 |
0.8557129658145981 precision recall f1-score support No 0.88 0.87 0.87 15068 Yes 0.82 0.84 0.83 10908 accuracy 0.86 25976 macro avg 0.85 0.85 0.85 25976 weighted avg 0.86 0.86 0.86 25976 |
La Regresión Logística arroja una precisión del 85.57%, ligeramente inferior a la de KNN pero aún respetable para comparaciones de referencia.
Gaussian Naive Bayes (GaussianNB)
GaussianNB es un clasificador probabilístico basado en el Teorema de Bayes, asumiendo la independencia de las características.
|
1 2 3 4 5 6 7 8 9 10 |
from sklearn.naive_bayes import GaussianNB # Initialize and train model_GNB = GaussianNB() model_GNB.fit(X_train, y_train) # Predict and evaluate y_pred = model_GNB.predict(X_test) print(accuracy_score(y_pred, y_test)) print(classification_report(y_pred, y_test)) |
|
1 2 3 4 5 6 7 8 9 |
0.828688019710502 precision recall f1-score support No 0.84 0.85 0.85 14662 Yes 0.81 0.80 0.80 11314 accuracy 0.83 25976 macro avg 0.83 0.82 0.83 25976 weighted avg 0.83 0.83 0.83 25976 |
GaussianNB logra una precisión del 82.87%, demostrando su efectividad a pesar de sus simples supuestos subyacentes.
Máquina de Soporte Vectorial (SVM)
SVM crea hiperplanos para separar las clases, optimizando el margen entre ellas.
|
1 2 3 4 5 6 7 8 9 10 |
from sklearn.svm import SVC # Initialize and train model_SVC = SVC() model_SVC.fit(X_train, y_train) # Predict and evaluate y_pred = model_SVC.predict(X_test) print(accuracy_score(y_pred, y_test)) print(classification_report(y_pred, y_test)) |
|
1 2 3 4 5 6 7 8 9 |
0.9325916230366492 precision recall f1-score support No 0.95 0.93 0.94 15033 Yes 0.91 0.93 0.92 10943 accuracy 0.93 25976 macro avg 0.93 0.93 0.93 25976 weighted avg 0.93 0.93 0.93 25976 |
SVM refleja el rendimiento de KNN con una precisión del 93.26%, destacando su robustez en tareas de clasificación.
Clasificador de Árbol de Decisión
Los Árboles de Decisión dividen los datos basándose en los valores de las características, formando un modelo en forma de árbol de decisiones.
|
1 2 3 4 5 6 7 8 9 10 |
from sklearn.tree import DecisionTreeClassifier # Initialize and train model_DTC = DecisionTreeClassifier(max_leaf_nodes=25, min_samples_split=4, random_state=42) model_DTC.fit(X_train, y_train) # Predict and evaluate y_pred = model_DTC.predict(X_test) print(accuracy_score(y_pred, y_test)) print(classification_report(y_pred, y_test)) |
|
1 2 3 4 5 6 7 8 9 |
0.9256621496766245 precision recall f1-score support No 0.95 0.92 0.94 15213 Yes 0.90 0.93 0.91 10763 accuracy 0.93 25976 macro avg 0.92 0.93 0.92 25976 weighted avg 0.93 0.93 0.93 25976 |
El Clasificador de Árbol de Decisión registra una precisión del 92.57%, demostrando su capacidad para capturar patrones complejos en los datos.
Clasificador de Bosques Aleatorios
Random Forest construye múltiples árboles de decisión y agrega sus predicciones para mejorar la precisión y la robustez.
|
1 2 3 4 5 6 7 8 9 10 |
from sklearn.ensemble import RandomForestClassifier # Initialize and train model_RFC = RandomForestClassifier(n_estimators=500, max_depth=5) model_RFC.fit(X_train, y_train) # Predict and evaluate y_pred = model_RFC.predict(X_test) print(accuracy_score(y_pred, y_test)) print(classification_report(y_pred, y_test)) |
|
1 2 3 4 5 6 7 8 9 |
0.9181937172774869 precision recall f1-score support No 0.93 0.93 0.93 14837 Yes 0.90 0.91 0.90 11139 accuracy 0.92 25976 macro avg 0.92 0.92 0.92 25976 weighted avg 0.92 0.92 0.92 25976 |
Random Forest logra una precisión del 91.82%, equilibrando de manera efectiva el sesgo y la varianza a través del aprendizaje en conjunto.
Clasificador AdaBoost
AdaBoost combina múltiples clasificadores débiles para formar un clasificador fuerte, enfocándose en instancias previamente mal clasificadas.
|
1 2 3 4 5 6 7 8 9 10 |
from sklearn.ensemble import AdaBoostClassifier # Initialize and train model_ABC = AdaBoostClassifier() model_ABC.fit(X_train, y_train) # Predict and evaluate y_pred = model_ABC.predict(X_test) print(accuracy_score(y_pred, y_test)) print(classification_report(y_pred, y_test)) |
|
1 2 3 4 5 6 7 8 9 |
0.9101863258392362 precision recall f1-score support No 0.93 0.92 0.92 14977 Yes 0.89 0.90 0.89 10999 accuracy 0.91 25976 macro avg 0.91 0.91 0.91 25976 weighted avg 0.91 0.91 0.91 25976 |
AdaBoost alcanza una precisión del 91.02%, demostrando su eficacia en la mejora del rendimiento del modelo a través de técnicas de boosting.
Clasificador XGBoost
XGBoost es un framework de boosting de gradiente altamente optimizado conocido por su rendimiento y velocidad.
|
1 2 3 4 5 6 7 8 9 10 |
import xgboost as xgb # Initialize and train model_xgb = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss') model_xgb.fit(X_train, y_train) # Predict and evaluate y_pred = model_xgb.predict(X_test) print(accuracy_score(y_pred, y_test)) print(classification_report(y_pred, y_test)) |
|
1 2 3 4 5 6 7 8 9 |
0.9410994764397905 precision recall f1-score support No 0.96 0.94 0.95 15122 Yes 0.92 0.94 0.93 10854 accuracy 0.94 25976 macro avg 0.94 0.94 0.94 25976 weighted avg 0.94 0.94 0.94 25976 |
XGBoost lidera el grupo con una impresionante precisión del 94.11%, subrayando su superioridad en el manejo de conjuntos de datos complejos con alta capacidad predictiva.
Conclusión
Construir modelos de clasificación efectivos depende de un meticuloso preprocesamiento de datos, una selección informada de características y la elección del algoritmo adecuado para la tarea. A través de nuestra plantilla maestra integral de Jupyter Notebook, hemos explorado varios algoritmos de clasificación, cada uno con sus fortalezas únicas. Desde K-Nearest Neighbors y Regresión Logística hasta técnicas de ensamblaje avanzadas como Random Forest y XGBoost, el conjunto de herramientas es vasto y adaptable a diversos conjuntos de datos.
Siguiendo esta guía, los científicos de datos y entusiastas pueden optimizar sus flujos de trabajo en aprendizaje automático, asegurando un rendimiento robusto del modelo y evaluaciones perspicaces. Recuerda, la piedra angular de cualquier modelo exitoso reside en comprender y preparar los datos antes de sumergirse en las complejidades algorítmicas.
Conclusiones Clave:- La Calidad de los Datos Importa: El manejo efectivo de datos faltantes y la codificación adecuada de variables categóricas son cruciales para la precisión del modelo.
- La Selección de Características Mejora el Rendimiento: Identificar y seleccionar las características más relevantes puede aumentar significativamente el rendimiento del modelo y reducir la carga computacional.
- Algoritmos Diversos Ofrecen Ventajas Únicas: Explorar múltiples algoritmos de clasificación permite una toma de decisiones informada basada en las fortalezas del modelo y las características del conjunto de datos.
- La Evaluación Continua es Esencial: Evaluar regularmente los modelos utilizando métricas como precisión, exactitud, recuperación y F1-score asegura la alineación con los objetivos del proyecto.
Aprovecha el poder de estas técnicas para construir modelos predictivos que no solo desempeñen de manera excepcional, sino que también proporcionen insights significativos sobre tus datos.
Recursos:
- Kaggle: Satisfacción de Pasajeros de Aerolíneas
- Documentación de Scikit-Learn
- Documentación de XGBoost
Para más tutoriales e insights sobre aprendizaje automático y ciencia de datos, suscríbete a nuestro boletín informativo y síguenos en LinkedIn.