5.3 Ejercicios Prácticos para el Capítulo 5

Estos ejercicios te ayudarán a practicar el manejo de datos desequilibrados con pesado de clases y SMOTE, utilizando métodos de validación cruzada apropiados. Cada ejercicio incluye una solución con código para orientación.

Ejercicio 1: Evaluar un Modelo con Pesado de Clases

Entrena un modelo de Regresión Logística en un conjunto de datos desequilibrado utilizando el pesado de clases para mejorar la sensibilidad del modelo hacia la clase minoritaria. Usa Validación Cruzada con Estratificación para garantizar una representación equilibrada de clases en cada partición.

Crea un conjunto de datos desequilibrado y divídelo en conjuntos de entrenamiento y prueba.
Aplica el pesado de clases a un modelo de Regresión Logística.
Evalúa el modelo utilizando validación cruzada con estratificación.

from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.metrics import classification_report

# Generate an imbalanced dataset
X, y = make_classification(n_samples=1000, n_features=20, n_classes=2, weights=[0.9, 0.1], random_state=42)

# Initialize Logistic Regression with class weighting
model = LogisticRegression(class_weight='balanced', random_state=42)

# Initialize Stratified K-Folds with 5 splits
strat_kfold = StratifiedKFold(n_splits=5)

# Solution: Evaluate model using Stratified K-Folds cross-validation
scores = cross_val_score(model, X, y, cv=strat_kfold, scoring='f1')
print("Stratified K-Folds F1 Scores:", scores)
print("Mean F1 Score:", scores.mean())

# Final model evaluation
model.fit(X, y)
y_pred = model.predict(X)
print("\\nClassification Report with Class Weighting:")
print(classification_report(y, y_pred))

En esta solución:

Se calcula el puntaje F1 del modelo utilizando Validación Cruzada con Estratificación para proporcionar una visión equilibrada del desempeño en cada clase.
El pesado de clases (class_weight='balanced') ayuda al modelo a considerar la clase minoritaria de manera más efectiva.

Ejercicio 2: Equilibrar Clases con SMOTE

Usa SMOTE para crear un conjunto de datos equilibrado para un Random Forest Classifier. Compara el desempeño en el conjunto de datos desequilibrado original y el conjunto re-muestreado con SMOTE.

Entrena un Random Forest Classifier en el conjunto de datos desequilibrado original.
Aplica SMOTE para equilibrar el conjunto de datos y vuelve a entrenar el modelo.
Compara los puntajes F1 de ambos modelos para observar el impacto de SMOTE.

from imblearn.over_sampling import SMOTE
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

# Generate an imbalanced dataset
X, y = make_classification(n_samples=1000, n_features=20, n_classes=2, weights=[0.9, 0.1], random_state=42)

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Solution: Train model on original imbalanced data
model = RandomForestClassifier(random_state=42)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print("Classification Report on Original Data:")
print(classification_report(y_test, y_pred))

# Apply SMOTE to create balanced data
smote = SMOTE(random_state=42)
X_resampled, y_resampled = smote.fit_resample(X_train, y_train)

# Train model on SMOTE-resampled data
model.fit(X_resampled, y_resampled)
y_pred_resampled = model.predict(X_test)
print("\\nClassification Report with SMOTE:")
print(classification_report(y_test, y_pred_resampled))

En esta solución:

SMOTE crea muestras sintéticas para equilibrar las clases, mejorando el desempeño en la clase minoritaria.
El informe de clasificación compara el puntaje F1 del modelo y otras métricas antes y después de usar SMOTE, mostrando la efectividad del equilibrio.

Ejercicio 3: Combinar SMOTE con Validación Cruzada Estratificada

Usa SMOTE con Validación Cruzada con Estratificación para evaluar el desempeño del modelo en múltiples particiones, equilibrando las clases en cada partición para una evaluación más robusta.

Aplica SMOTE dentro de cada partición de la validación cruzada.
Entrena un modelo de Random Forest en cada partición y reporta los puntajes F1.

from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.pipeline import Pipeline
from imblearn.pipeline import make_pipeline  # to use SMOTE in cross-validation
from sklearn.ensemble import RandomForestClassifier

# Generate an imbalanced dataset
X, y = make_classification(n_samples=1000, n_features=20, n_classes=2, weights=[0.9, 0.1], random_state=42)

# Initialize SMOTE and Random Forest in a pipeline
pipeline = make_pipeline(SMOTE(random_state=42), RandomForestClassifier(random_state=42))

# Initialize Stratified K-Folds Cross-Validation with 5 splits
strat_kfold = StratifiedKFold(n_splits=5)

# Solution: Cross-validation with SMOTE in each fold
scores = cross_val_score(pipeline, X, y, cv=strat_kfold, scoring='f1')
print("Stratified K-Folds with SMOTE F1 Scores:", scores)
print("Mean F1 Score:", scores.mean())

En esta solución:

SMOTE se aplica dentro de cada partición utilizando un pipeline, asegurando que las clases estén equilibradas en cada iteración de la validación cruzada.
Los puntajes F1 a lo largo de las particiones proporcionan una medida integral del desempeño del modelo en la clase minoritaria.

Ejercicio 4: Comparar Pesado de Clases vs. SMOTE en un Conjunto de Datos Desequilibrado

Entrena dos modelos de Regresión Logística en un conjunto de datos desequilibrado: uno con pesado de clases y otro con SMOTE. Compara el desempeño de cada enfoque utilizando el puntaje F1.

Entrena un modelo de Regresión Logística con class_weight='balanced'.
Entrena otro modelo utilizando SMOTE para equilibrar el conjunto de datos.
Compara los puntajes F1 de ambos modelos en un conjunto de prueba.

from imblearn.over_sampling import SMOTE
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split

# Generate an imbalanced dataset
X, y = make_classification(n_samples=1000, n_features=20, n_classes=2, weights=[0.9, 0.1], random_state=42)

# Split data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Solution 1: Logistic Regression with class weighting
model_weighted = LogisticRegression(class_weight='balanced', random_state=42)
model_weighted.fit(X_train, y_train)
y_pred_weighted = model_weighted.predict(X_test)
print("Classification Report with Class Weighting:")
print(classification_report(y_test, y_pred_weighted))

# Solution 2: Logistic Regression with SMOTE
smote = SMOTE(random_state=42)
X_resampled, y_resampled = smote.fit_resample(X_train, y_train)
model_smote = LogisticRegression(random_state=42)
model_smote.fit(X_resampled, y_resampled)
y_pred_smote = model_smote.predict(X_test)
print("\\nClassification Report with SMOTE:")
print(classification_report(y_test, y_pred_smote))

En esta solución:

Tanto el pesado de clases como SMOTE se aplican para abordar datos desequilibrados, lo que permite una comparación directa.
Los informes de clasificación muestran los puntajes F1 de ambos métodos, ayudando a determinar qué técnica funciona mejor para este conjunto de datos.

Estos ejercicios ofrecen experiencia práctica en el manejo de datos desequilibrados, incluyendo el uso de pesado de clases, SMOTE y estrategias de validación cruzada. Al dominar estas técnicas, mejorarás tu capacidad para evaluar y optimizar el desempeño de modelos en conjuntos de datos reales desequilibrados.