Practica Machine Learning con Scikit-Learn - Soluciones

# Copie el código aca

import pandas as pd
import matplotlib.pyplot as plt
import sklearn

print(f"Pandas version: {pd.__version__}")
print(f"Sklearn version: {sklearn.__version__}")

# Copie el código aca

url = "https://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-red.csv"
wine_df = pd.read_csv(url, sep=";")
wine_df.info()

wine_df.head()

wine_df.describe()

# Copie el código aca

# Verificar valores nulos
print("Valores nulos por columna:")
print(wine_df.isna().sum())
print(f"\nTotal de valores nulos: {wine_df.isna().sum().sum()}")

# Verificar y eliminar duplicados
print(f"Filas antes de eliminar duplicados: {len(wine_df)}")
print(f"Filas duplicadas: {wine_df.duplicated().sum()}")

wine_df = wine_df.drop_duplicates()
print(f"Filas después de eliminar duplicados: {len(wine_df)}")

# Copie el código aca

# Crear variable objetivo binaria
wine_df["good_quality"] = (wine_df["quality"] >= 7).astype(int)

# Eliminar la columna quality original
wine_df = wine_df.drop(columns=["quality"])

# Verificar distribución de clases
print("Distribución de clases:")
print(wine_df["good_quality"].value_counts())
print(f"\nProporción de clase positiva: {wine_df['good_quality'].mean():.2%}")

# Copie el código aca

X = wine_df.drop(columns=["good_quality"])
y = wine_df["good_quality"]

print(f"Forma de X: {X.shape}")
print(f"Forma de y: {y.shape}")
print(f"\nColumnas de X: {list(X.columns)}")

# Copie el código aca

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42
)

print(f"Datos de entrenamiento: {X_train.shape[0]} filas")
print(f"Datos de test: {X_test.shape[0]} filas")
print(f"\nProporción clase positiva en entrenamiento: {y_train.mean():.2%}")
print(f"Proporción clase positiva en test: {y_test.mean():.2%}")

# Copie el código aca

from sklearn import set_config
from sklearn.ensemble import RandomForestClassifier
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

pipeline_rf = Pipeline([
    ("scaler", StandardScaler()),
    ("modelo", RandomForestClassifier(random_state=42)),
])

# Visualizar el pipeline
set_config(display="diagram")
pipeline_rf

# Copie el código aca

from sklearn.model_selection import StratifiedKFold, cross_validate

skfold = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)

cv_results = cross_validate(pipeline_rf, X_train, y_train, cv=skfold, scoring="f1")

print(f"F1-Score por fold: {cv_results['test_score']}")
print(f"F1-Score Promedio: {cv_results['test_score'].mean():.4f}")
print(f"F1-Score STD: {cv_results['test_score'].std():.4f}")

# Copie el código aca

from sklearn.ensemble import GradientBoostingClassifier
from sklearn.linear_model import LogisticRegression

# Copie el código aca

Random_Forest = Pipeline([
    ("scaler", StandardScaler()),
    ("modelo", RandomForestClassifier(random_state=42)),
])
Random_Forest

# Copie el código aca

Gradient_Boosting = Pipeline([
    ("scaler", StandardScaler()),
    ("modelo", GradientBoostingClassifier(random_state=42)),
])
Gradient_Boosting

# Copie el código aca

Logistic_Regression = Pipeline([
    ("scaler", StandardScaler()),
    ("modelo", LogisticRegression(random_state=42, max_iter=1000)),
])
Logistic_Regression

# Copie el código aca

# Definir los pipelines para cada modelo
modelos = {
    "Random Forest": Random_Forest,
    "Gradient Boosting": Gradient_Boosting,
    "Logistic Regression": Logistic_Regression,
}

# Evaluar cada modelo con cross-validation
resultados = {}
cv_scores = {}  # Almacenar todos los scores de cada fold para boxplots

for nombre, pipeline in modelos.items():
    cv_result = cross_validate(pipeline, X_train, y_train, cv=skfold, scoring="f1")
    media = cv_result["test_score"].mean()
    std = cv_result["test_score"].std()
    resultados[nombre] = {"media": media, "std": std}
    cv_scores[nombre] = cv_result["test_score"]  # Guardar los scores de todos los folds
    print(f"{nombre:25s} -> F1-Score: {media:.4f} ± {std:.4f}")

# Copie el código aca

# Crear boxplots de los resultados de cross-validation

# Preparar los datos para el boxplot
datos_boxplot = [cv_scores[nombre] for nombre in cv_scores.keys()]
nombres_modelos = list(cv_scores.keys())

# Crear la figura
plt.boxplot(datos_boxplot, tick_labels=nombres_modelos)
plt.title("Comparación de Modelos - F1-Score (Cross-Validation)")
plt.ylabel("F1-Score")
plt.xlabel("Modelo");

param_distributions = {
    "modelo__n_estimators": [50, 100, 200, 300, 500],
    "modelo__max_depth": [3, 5, 10, 15, 20, None],
    "modelo__min_samples_split": [2, 5, 10],
    "modelo__min_samples_leaf": [1, 2, 4],
    "modelo__max_features": ["sqrt", "log2", None],
}

# Copie el código aca

from sklearn.model_selection import RandomizedSearchCV

# Definir el espacio de hiperparámetros
# Nota: se usa "modelo__" como prefijo porque el modelo está dentro del pipeline
param_distributions = {
    "modelo__n_estimators": [50, 100, 200, 300, 500],
    "modelo__max_depth": [3, 5, 10, 15, 20, None],
    "modelo__min_samples_split": [2, 5, 10],
    "modelo__min_samples_leaf": [1, 2, 4],
    "modelo__max_features": ["sqrt", "log2", None],
}

# Crear el RandomizedSearchCV
random_search = RandomizedSearchCV(
    pipeline_rf,
    param_distributions=param_distributions,
    n_iter=50,
    cv=skfold,
    scoring="f1",
    random_state=42,
    n_jobs=-1,  # Usar todos los cores disponibles
)

# Ejecutar la búsqueda
random_search.fit(X_train, y_train)

# Copie el código aca

# Mejores hiperparámetros
print("Mejores hiperparámetros encontrados:")
for param, valor in random_search.best_params_.items():
    print(f"  {param}: {valor}")

print(f"\nMejor F1-Score CV: {random_search.best_score_:.4f}")
print(
    f"STD del mejor resultado: "
    f"{random_search.cv_results_['std_test_score'][random_search.best_index_]:.4f}"
)

# Top 5 resultados de la búsqueda
cv_results_df = pd.DataFrame(random_search.cv_results_)
top_5 = cv_results_df.nsmallest(5, "rank_test_score")[
    ["params", "mean_test_score", "std_test_score", "rank_test_score"]
]
top_5

# Copie el código aca

from sklearn.metrics import (
    accuracy_score,
    classification_report,
    f1_score,
    precision_score,
    recall_score,
)

# Configurar el pipeline con los mejores hiperparámetros
mejor_pipeline = pipeline_rf.set_params(**random_search.best_params_)

# Entrenar con todos los datos de entrenamiento
mejor_pipeline.fit(X_train, y_train)

# Predecir con datos de test
y_pred = mejor_pipeline.predict(X_test)

# Calcular métricas
print("Métricas en datos de Test:")
print(f"  Accuracy:  {accuracy_score(y_test, y_pred):.4f}")
print(f"  Precision: {precision_score(y_test, y_pred):.4f}")
print(f"  Recall:    {recall_score(y_test, y_pred):.4f}")
print(f"  F1-Score:  {f1_score(y_test, y_pred):.4f}")

# Copie el código aca

# Reporte de clasificación completo
print("\nReporte de Clasificación:")
print(classification_report(y_test, y_pred, target_names=["Malo", "Bueno"]))

# Copie el código aca

import matplotlib.pyplot as plt
from sklearn.metrics import ConfusionMatrixDisplay

fig, ax = plt.subplots(figsize=(6, 5))
ConfusionMatrixDisplay.from_predictions(
    y_test, y_pred, display_labels=["Malo", "Bueno"], ax=ax, cmap="Blues"
)
ax.set_title("Matriz de Confusión - Datos de Test")
plt.tight_layout()
plt.show()

# Copie el código aca

from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import MinMaxScaler

# Definir las columnas para cada transformación
cols_standard = [
    "fixed acidity",
    "volatile acidity",
    "citric acid",
    "residual sugar",
    "chlorides",
    "free sulfur dioxide",
    "total sulfur dioxide",
]

cols_minmax = ["density", "pH", "sulphates", "alcohol"]

# Crear el ColumnTransformer
preprocessor = ColumnTransformer(
    transformers=[
        ("standard", StandardScaler(), cols_standard),
        ("minmax", MinMaxScaler(), cols_minmax),
    ]
)

# Pipeline completo: preprocesamiento + modelo
pipeline_gb = Pipeline([
    ("preprocessor", preprocessor),
    ("modelo", GradientBoostingClassifier(random_state=42)),
])

# Visualizar el pipeline
set_config(display="diagram")
pipeline_gb

# Copie el código aca

# Evaluar con cross-validation
cv_results_gb = cross_validate(pipeline_gb, X_train, y_train, cv=skfold, scoring="f1")

print(f"F1-Score Promedio: {cv_results_gb['test_score'].mean():.4f}")
print(f"F1-Score STD: {cv_results_gb['test_score'].std():.4f}")

# Copie el código aca

# boxplot cv_results_gb
plt.figure(figsize=(10, 6))
plt.boxplot(cv_results_gb["test_score"])
plt.title("F1-Score de los 10 folds")
plt.xlabel("F1-Score")
plt.show()

param_distributions_gb = {
    "modelo__n_estimators": [50, 100, 200, 300],
    "modelo__max_depth": [3, 5, 7, 10],
    "modelo__learning_rate": [0.01, 0.05, 0.1, 0.2],
    "modelo__min_samples_split": [2, 5, 10],
    "modelo__min_samples_leaf": [1, 2, 4],
    "modelo__subsample": [0.8, 0.9, 1.0],
}

# Copie el código aca

param_distributions_gb = {
    "modelo__n_estimators": [50, 100, 200, 300],
    "modelo__max_depth": [3, 5, 7, 10],
    "modelo__learning_rate": [0.01, 0.05, 0.1, 0.2],
    "modelo__min_samples_split": [2, 5, 10],
    "modelo__min_samples_leaf": [1, 2, 4],
    "modelo__subsample": [0.8, 0.9, 1.0],
}

random_search_gb = RandomizedSearchCV(
    pipeline_gb,
    param_distributions=param_distributions_gb,
    n_iter=50,
    cv=skfold,
    scoring="f1",
    random_state=42,
    n_jobs=-1,
)

random_search_gb.fit(X_train, y_train)

print("Mejores hiperparámetros encontrados:")
for param, valor in random_search_gb.best_params_.items():
    print(f"  {param}: {valor}")

print(f"\nMejor F1-Score CV: {random_search_gb.best_score_:.4f}")
print(
    f"STD del mejor resultado: "
    f"{random_search_gb.cv_results_['std_test_score'][random_search_gb.best_index_]:.4f}"
)

# Copie el código aca

# Configurar el pipeline con los mejores hiperparámetros
mejor_pipeline_gb = pipeline_gb.set_params(**random_search_gb.best_params_)

# Entrenar con datos de entrenamiento
mejor_pipeline_gb.fit(X_train, y_train)

# Predecir con datos de test
y_pred_gb = mejor_pipeline_gb.predict(X_test)

# Métricas
print("Métricas en datos de Test (Gradient Boosting optimizado):")
print(f"  Accuracy:  {accuracy_score(y_test, y_pred_gb):.4f}")
print(f"  Precision: {precision_score(y_test, y_pred_gb):.4f}")
print(f"  Recall:    {recall_score(y_test, y_pred_gb):.4f}")
print(f"  F1-Score:  {f1_score(y_test, y_pred_gb):.4f}")

print("\nReporte de Clasificación:")
print(classification_report(y_test, y_pred_gb, target_names=["Malo", "Bueno"]))

# Matriz de confusión
fig, ax = plt.subplots(figsize=(6, 5))
ConfusionMatrixDisplay.from_predictions(
    y_test, y_pred_gb, display_labels=["Malo", "Bueno"], ax=ax, cmap="Blues"
)
ax.set_title("Matriz de Confusión - Gradient Boosting Optimizado")
plt.tight_layout()
plt.show()

# Copie el código aca

from joblib import dump

# Entrenar con todos los datos
modelo_final = pipeline_gb.set_params(**random_search_gb.best_params_)
modelo_final.fit(X, y)

# Verificación: accuracy sobre todos los datos
y_pred_all = modelo_final.predict(X)
print(f"F1-Score (todos los datos): {f1_score(y, y_pred_all):.4f}")

# Guardar el pipeline completo
dump(modelo_final, "pipeline_wine_quality.joblib")
print("\nModelo guardado exitosamente en 'pipeline_wine_quality.joblib'")

nuevos_datos = pd.DataFrame({
    "fixed acidity": [7.4, 11.2],
    "volatile acidity": [0.70, 0.28],
    "citric acid": [0.00, 0.56],
    "residual sugar": [1.9, 1.9],
    "chlorides": [0.076, 0.075],
    "free sulfur dioxide": [11.0, 17.0],
    "total sulfur dioxide": [34.0, 60.0],
    "density": [0.9978, 0.9980],
    "pH": [3.51, 3.16],
    "sulphates": [0.56, 0.58],
    "alcohol": [9.4, 9.8],
})

# Copie el código aca

from joblib import load

# Cargar el modelo
modelo_cargado = load("pipeline_wine_quality.joblib")

# Datos de ejemplo
nuevos_datos = pd.DataFrame({
    "fixed acidity": [7.4, 11.2],
    "volatile acidity": [0.70, 0.28],
    "citric acid": [0.00, 0.56],
    "residual sugar": [1.9, 1.9],
    "chlorides": [0.076, 0.075],
    "free sulfur dioxide": [11.0, 17.0],
    "total sulfur dioxide": [34.0, 60.0],
    "density": [0.9978, 0.9980],
    "pH": [3.51, 3.16],
    "sulphates": [0.56, 0.58],
    "alcohol": [9.4, 9.8],
})

# Hacer predicciones
predicciones = modelo_cargado.predict(nuevos_datos)
etiquetas = ["Malo" if p == 0 else "Bueno" for p in predicciones]

print("Predicciones para nuevos datos:")
for i, (pred, etiqueta) in enumerate(zip(predicciones, etiquetas)):
    print(f"  Vino {i + 1}: {pred} ({etiqueta})")

# Copie el código aca

# Obtener la importancia de las características
importances = modelo_final.named_steps["modelo"].feature_importances_
feature_names = cols_standard + cols_minmax

# Crear DataFrame y ordenar
importance_df = pd.DataFrame({
    "feature": feature_names,
    "importance": importances,
}).sort_values("importance", ascending=True)

# Visualizar
fig, ax = plt.subplots(figsize=(8, 6))
ax.barh(importance_df["feature"], importance_df["importance"], color="steelblue")
ax.set_xlabel("Importancia")
ax.set_title("Importancia de las Características - Gradient Boosting")
plt.tight_layout()
plt.show()