Dominando los Modelos de Clasificación: Una Plantilla Integral en Python para Ciencia de Datos
Tabla de Contenidos
- Introducción a los Modelos de Clasificación
- Configurando tu Entorno
- Importación y Exploración de Datos
- Manejo de Datos Faltantes
- Codificación de Variables Categóricas
- Selección de Características
- División de Entrenamiento y Prueba
- Escalado de Características
- Construcción y Evaluación de Modelos
- Conclusión
1. Introducción a los Modelos de Clasificación
Los modelos de clasificación son una piedra angular del aprendizaje automático supervisado, permitiendo la predicción de etiquetas discretas basadas en características de entrada. Estos modelos son instrumentales en diversas aplicaciones, desde la detección de spam en correos electrónicos hasta el diagnóstico médico. Dominar estos modelos implica comprender el preprocesamiento de datos, la ingeniería de características, la selección de modelos y las métricas de evaluación.
2. Configurando tu Entorno
Antes de sumergirse en la construcción de modelos, asegúrate de que tu entorno de Python esté equipado con las bibliotecas necesarias. Aquí te mostramos cómo puedes configurar tu entorno:
|
1 2 |
# Install necessary libraries !pip install pandas seaborn scikit-learn xgboost |
Importa las bibliotecas esenciales:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
import pandas as pd import seaborn as sns import numpy as np from sklearn.model_selection import train_test_split from sklearn.preprocessing import StandardScaler, LabelEncoder, OneHotEncoder from sklearn.impute import SimpleImputer from sklearn.compose import ColumnTransformer from sklearn.feature_selection import SelectKBest, chi2 from sklearn.metrics import accuracy_score 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 |
3. Importación y Exploración de Datos
Para este tutorial, utilizaremos el Conjunto de Datos Weather Australia de Kaggle. Este conjunto de datos completo proporciona diversas características relacionadas con el clima que son ideales para construir modelos de clasificación.
|
1 2 3 |
# Import data data = pd.read_csv('weatherAUS.csv') # Ensure the CSV file is in your working directory print(data.tail()) |
Salida de Muestra:
|
1 2 3 4 5 6 |
Date Location MinTemp MaxTemp Rainfall Evaporation Sunshine WindGustDir WindGustSpeed WindDir9am ... Humidity3pm Pressure9am Pressure3pm Cloud9am Cloud3pm Temp9am Temp3pm RainToday RISK_MM RainTomorrow 142188 2017-06-20 Uluru 3.5 21.8 0.0 NaN E 31.0 ESE ... 27.0 1024.7 1021.2 NaN NaN 9.4 20.9 No 0.0 No 142189 2017-06-21 Uluru 2.8 23.4 0.0 NaN E 31.0 SE ... 24.0 1024.6 1020.3 NaN NaN 10.1 22.4 No 0.0 No 142190 2017-06-22 Uluru 3.6 25.3 0.0 NaN NNW 22.0 SE ... 21.0 1023.5 1019.1 NaN NaN 10.9 24.5 No 0.0 No 142191 2017-06-23 Uluru 5.4 26.9 0.0 NaN N 37.0 SE ... 24.0 1021.0 1016.8 NaN NaN 12.5 26.1 No 0.0 No 142192 2017-06-24 Uluru 7.8 27.0 0.0 NaN SE 28.0 SSE ... 24.0 1019.4 1016.5 3.0 2.0 15.1 26.0 No 0.0 No |
4. Manejo de Datos Faltantes
La integridad de los datos es crucial para construir modelos confiables. Abordemos los valores faltantes tanto en características numéricas como categóricas.
Manejo de Datos Numéricos Faltantes
Usa el SimpleImputer de Scikit-learn para llenar los valores numéricos faltantes con la media de cada columna.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
from sklearn.impute import SimpleImputer # Separate features and target X = data.iloc[:, :-1] # All columns except the last one y = data.iloc[:, -1] # Target column # Identify numeric columns numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns # Impute missing numeric values with mean imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean') X[numerical_cols] = imp_mean.fit_transform(X[numerical_cols]) |
Manejo de Datos Categóricos Faltantes
Para variables categóricas, imputa los valores faltantes con el valor más frecuente (modo).
|
1 2 3 4 5 6 |
# Identify categorical columns categorical_cols = X.select_dtypes(include=['object']).columns # Impute missing categorical values with the most frequent value imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent') X[categorical_cols] = imp_freq.fit_transform(X[categorical_cols]) |
5. Codificación de Variables Categóricas
Los modelos de aprendizaje automático requieren entradas numéricas. Por lo tanto, las variables categóricas necesitan ser codificadas. Usaremos la Codificación de Etiquetas (Label Encoding) para categorías binarias y la Codificación One-Hot (One-Hot Encoding) para categorías de múltiples clases.
Codificación de Etiquetas (Label Encoding)
|
1 2 3 4 |
from sklearn.preprocessing import LabelEncoder le = LabelEncoder() y = le.fit_transform(y) # Encoding the target variable |
Codificación One-Hot (One-Hot Encoding)
Implementa un método para manejar la codificación basado en el número de categorías únicas.
|
1 2 3 4 5 6 7 8 9 |
from sklearn.compose import ColumnTransformer from sklearn.preprocessing import OneHotEncoder def one_hot_encode(columns, data): ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), columns)], remainder='passthrough') return ct.fit_transform(data) # Example usage: # X = one_hot_encode(['WindGustDir', 'WindDir9am'], X) |
Alternativamente, automatiza el proceso de codificación basado en umbrales de categorías únicas.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
def encoding_selection(X, threshold=10): # Identify string columns string_cols = X.select_dtypes(include=['object']).columns one_hot_encoding_cols = [] for col in string_cols: unique_count = X[col].nunique() if unique_count == 2 or unique_count > threshold: X[col] = le.fit_transform(X[col]) else: one_hot_encoding_cols.append(col) if one_hot_encoding_cols: X = one_hot_encode(one_hot_encoding_cols, X) return X X = encoding_selection(X) |
6. Selección de Características
Reducir el número de características puede mejorar el rendimiento del modelo y reducir el costo computacional. Usaremos SelectKBest con la prueba Chi-Cuadrado para seleccionar las mejores características.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
from sklearn.feature_selection import SelectKBest, chi2 from sklearn.preprocessing import MinMaxScaler # Scale features scaler = MinMaxScaler() X_scaled = scaler.fit_transform(X) # Select top K features k = 10 # You can adjust this based on your requirement selector = SelectKBest(score_func=chi2, k=k) X_selected = selector.fit_transform(X_scaled, y) # Get selected feature indices selected_indices = selector.get_support(indices=True) selected_features = X.columns[selected_indices] print("Selected Features:", selected_features) |
7. División de Entrenamiento y Prueba
Dividir el conjunto de datos en conjuntos de entrenamiento y prueba es esencial para evaluar el rendimiento del modelo en datos no vistos.
|
1 2 3 4 5 |
from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(X_selected, y, test_size=0.20, random_state=1) print("Training set shape:", X_train.shape) print("Test set shape:", X_test.shape) |
Salida:
|
1 2 |
Training set shape: (113754, 10) Test set shape: (28439, 10) |
8. Escalado de Características
Estandarizar las características asegura que cada característica contribuya por igual a los cálculos de distancia en algoritmos como KNN y SVM.
|
1 2 3 4 5 6 7 |
from sklearn.preprocessing import StandardScaler scaler = StandardScaler() X_train = scaler.fit_transform(X_train) X_test = scaler.transform(X_test) print("Scaled Training set shape:", X_train.shape) print("Scaled Test set shape:", X_test.shape) |
Salida:
|
1 2 |
Scaled Training set shape: (113754, 10) Scaled Test set shape: (28439, 10) |
9. Construcción y Evaluación de Modelos
Con los datos preprocesados, ahora podemos construir y evaluar varios modelos de clasificación. Evaluaremos los modelos basándonos en sus puntuaciones de exactitud.
K-Nearest Neighbors (KNN)
|
1 2 3 4 5 6 7 |
from sklearn.neighbors import KNeighborsClassifier from sklearn.metrics import accuracy_score knn = KNeighborsClassifier(n_neighbors=3) knn.fit(X_train, y_train) y_pred = knn.predict(X_test) print("KNN Accuracy:", accuracy_score(y_test, y_pred)) |
Salida:
|
1 |
KNN Accuracy: 1.0 |
Regresión Logística
|
1 2 3 4 5 6 |
from sklearn.linear_model import LogisticRegression log_reg = LogisticRegression(random_state=0, max_iter=200) log_reg.fit(X_train, y_train) y_pred = log_reg.predict(X_test) print("Logistic Regression Accuracy:", accuracy_score(y_test, y_pred)) |
Salida:
|
1 |
Logistic Regression Accuracy: 0.99996 |
Gaussian Naive Bayes
|
1 2 3 4 5 6 |
from sklearn.naive_bayes import GaussianNB gnb = GaussianNB() gnb.fit(X_train, y_train) y_pred = gnb.predict(X_test) print("GaussianNB Accuracy:", accuracy_score(y_test, y_pred)) |
Salida:
|
1 |
GaussianNB Accuracy: 0.97437 |
Support Vector Machine (SVM)
|
1 2 3 4 5 6 |
from sklearn.svm import SVC svm = SVC() svm.fit(X_train, y_train) y_pred = svm.predict(X_test) print("SVM Accuracy:", accuracy_score(y_test, y_pred)) |
Salida:
|
1 |
SVM Accuracy: 0.99996 |
Clasificador de Árbol de Decisión
|
1 2 3 4 5 6 |
from sklearn.tree import DecisionTreeClassifier dtc = DecisionTreeClassifier() dtc.fit(X_train, y_train) y_pred = dtc.predict(X_test) print("Decision Tree Accuracy:", accuracy_score(y_test, y_pred)) |
Salida:
|
1 |
Decision Tree Accuracy: 1.0 |
Clasificador de Bosque Aleatorio (Random Forest)
|
1 2 3 4 5 6 |
from sklearn.ensemble import RandomForestClassifier rfc = RandomForestClassifier(n_estimators=500, max_depth=5) rfc.fit(X_train, y_train) y_pred = rfc.predict(X_test) print("Random Forest Accuracy:", accuracy_score(y_test, y_pred)) |
Salida:
|
1 |
Random Forest Accuracy: 1.0 |
AdaBoost Classifier
|
1 2 3 4 5 6 |
from sklearn.ensemble import AdaBoostClassifier abc = AdaBoostClassifier() abc.fit(X_train, y_train) y_pred = abc.predict(X_test) print("AdaBoost Accuracy:", accuracy_score(y_test, y_pred)) |
Salida:
|
1 |
AdaBoost Accuracy: 1.0 |
Clasificador XGBoost
|
1 2 3 4 5 6 |
import xgboost as xgb xgb_model = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss') xgb_model.fit(X_train, y_train) y_pred = xgb_model.predict(X_test) print("XGBoost Accuracy:", accuracy_score(y_test, y_pred)) |
Salida:
|
1 |
XGBoost Accuracy: 1.0 |
Nota: La advertencia respecto a la métrica de evaluación en XGBoost puede suprimirse estableciendo explícitamente el parámetro eval_metric, como se muestra arriba.
10. Conclusión
Construir modelos de clasificación no tiene por qué ser una tarea desalentadora. Con un enfoque estructurado en el preprocesamiento de datos, la codificación, la selección de características y la evaluación de modelos, puedes desarrollar eficientemente modelos robustos adaptados a tus necesidades específicas. La plantilla maestra ilustrada en este artículo sirve como una guía integral, agilizando el flujo de trabajo desde la ingestión de datos hasta la evaluación del modelo. Ya seas un principiante o un científico de datos experimentado, aprovechar tales plantillas puede mejorar la productividad y el rendimiento del modelo.
Conclusiones Clave:
- Preprocesamiento de Datos: Limpia y prepara tus datos meticulosamente para asegurar la exactitud del modelo.
- Técnicas de Codificación: Codifica adecuadamente las variables categóricas para adaptarlas a diferentes algoritmos.
- Selección de Características: Utiliza métodos de selección de características para mejorar la eficiencia y el rendimiento del modelo.
- Diversidad de Modelos: Experimenta con varios modelos para identificar el mejor ejecutante para tu conjunto de datos.
- Métricas de Evaluación: Ve más allá de la exactitud; considera otras métricas como precisión, recall y F1-score para una evaluación holística.
¡Adopta estas prácticas y potencia tus proyectos de ciencia de datos con claridad y precisión!