🤖 Automatización de Procesos para el Flujo de Trabajo en Machine Learning¶

# ===========================================================================
# 2. IMPORTACIÓN DE LIBRERÍAS
# ===========================================================================
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import os
import warnings
warnings.filterwarnings('ignore')

# Framework principal de Machine Learning (scikit-learn)
from sklearn.model_selection import (
    train_test_split, cross_validate, GridSearchCV
)
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder, FunctionTransformer
from sklearn.ensemble import RandomForestClassifier
from sklearn.svm import SVC
from sklearn.metrics import (
    classification_report, confusion_matrix, accuracy_score,
    precision_score, recall_score, f1_score, roc_curve, auc
)

# Estilo visual de las gráficas
sns.set_theme(style="whitegrid")
plt.rcParams['figure.figsize'] = (10, 6)
plt.rcParams['font.size'] = 11

print("✅ Librerías cargadas exitosamente.")

# ===========================================================================
# 3. CARGA DE DATOS DESDE LA WEB
# ===========================================================================
URL_TITANIC = "https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv"
RUTA_LOCAL = "./titanic.csv"

if os.path.exists(RUTA_LOCAL):
    print("📁 Cargando dataset desde la ruta local...")
    df = pd.read_csv(RUTA_LOCAL)
else:
    print("📥 Descargando dataset desde URL pública...")
    try:
        df = pd.read_csv(URL_TITANIC)
        df.to_csv(RUTA_LOCAL, index=False)
        print("💾 Dataset guardado localmente como 'titanic.csv'.")
    except Exception as e:
        print(f"❌ Error al descargar de la web: {e}")
        print("Intentando cargar desde la carpeta de la semana anterior...")
        df = pd.read_csv("../MA Semana 5/titanic.csv")

# Estandarizar nombres de columnas a minúsculas
df.columns = df.columns.str.lower()

# Resumen de dimensiones y columnas
print(f"Dimensiones del dataset: {df.shape[0]} filas, {df.shape[1]} columnas")
print("\nPrimeras 5 filas:")
display(df.head())

# ===========================================================================
# 4. ANÁLISIS EXPLORATORIO DE DATOS (EDA)
# ===========================================================================
fig, axes = plt.subplots(2, 2, figsize=(16, 12))
fig.suptitle('Análisis Exploratorio de Datos (Supervivencia en el Titanic)', fontsize=16, fontweight='bold')

# 1. Distribución de supervivencia
sns.countplot(ax=axes[0, 0], x='survived', data=df, palette='Set2')
axes[0, 0].set_title('Distribución de Supervivencia (0 = No, 1 = Sí)')
axes[0, 0].set_xlabel('Supervivencia')
axes[0, 0].set_ylabel('Cantidad')

# 2. Supervivencia por género
sns.countplot(ax=axes[0, 1], x='sex', hue='survived', data=df, palette='Set1')
axes[0, 1].set_title('Supervivencia según el Género')
axes[0, 1].set_xlabel('Género')
axes[0, 1].set_ylabel('Cantidad')

# 3. Supervivencia por clase de boleto
sns.countplot(ax=axes[1, 0], x='pclass', hue='survived', data=df, palette='viridis')
axes[1, 0].set_title('Supervivencia por Clase de Boleto')
axes[1, 0].set_xlabel('Clase de Boleto')
axes[1, 0].set_ylabel('Cantidad')

# 4. Distribución de edad según supervivencia
sns.kdeplot(ax=axes[1, 1], x='age', hue='survived', data=df, fill=True, common_norm=False, palette='coolwarm')
axes[1, 1].set_title('Distribución de Edad por Supervivencia')
axes[1, 1].set_xlabel('Edad')
axes[1, 1].set_ylabel('Densidad')

plt.tight_layout()
plt.savefig('eda_supervivencia_titanic.png', dpi=150, bbox_inches='tight')
plt.show()
print("Gráfica guardada: eda_supervivencia_titanic.png")

# ===========================================================================
# 5. INGENIERÍA DE CARACTERÍSTICAS
# ===========================================================================

def procesar_caracteristicas(data):
    # Crear una copia para evitar SettingWithCopyWarning
    df_new = data.copy()

    # 1. Tamaño de la familia
    df_new['family_size'] = df_new['sibsp'] + df_new['parch'] + 1

    # 2. ¿Viaja solo?
    df_new['is_alone'] = (df_new['family_size'] == 1).astype(int)

    # 3. Extraer títulos del nombre
    df_new['title'] = df_new['name'].str.extract(r' ([A-Za-z]+)\.', expand=False)

    # Agrupar títulos poco comunes en categorias estándar
    titulos_raros = ['Lady', 'Countess','Capt', 'Col', 'Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona']
    df_new['title'] = df_new['title'].replace(titulos_raros, 'Rare')
    df_new['title'] = df_new['title'].replace('Mlle', 'Miss')
    df_new['title'] = df_new['title'].replace('Ms', 'Miss')
    df_new['title'] = df_new['title'].replace('Mme', 'Mrs')

    # Rellenar valores nulos de títulos
    df_new['title'] = df_new['title'].fillna('Mr')

    # Eliminar columnas que no usaremos en el modelado directo
    df_new = df_new.drop(['passengerid', 'name', 'ticket', 'cabin'], axis=1)

    return df_new

# Aplicar ingeniería de características al dataset completo
df_procesado = procesar_caracteristicas(df)

print("Columnas actuales del dataset procesado:")
print(list(df_procesado.columns))
print("\nPrimeras 5 filas con nuevas características:")
display(df_procesado.head())

# ===========================================================================
# 6. PIPELINES Y COLUMNTRANSFORMER
# ===========================================================================

# Separar características (X) y variable objetivo (y)
X = df_procesado.drop('survived', axis=1)
y = df_procesado['survived']

# Dividir en entrenamiento y prueba (80/20) con semilla aleatoria para replicabilidad
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# Definir las columnas numéricas y categóricas
num_cols = ['age', 'fare', 'sibsp', 'parch', 'family_size']
cat_cols = ['sex', 'embarked', 'title']
bin_cols = ['is_alone']

# 1. Pipeline numérico: Imputador Mediana + Scaler
num_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())
])

# 2. Pipeline categórico: Imputador Moda + One-Hot Encoding
cat_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('onehot', OneHotEncoder(handle_unknown='ignore', sparse_output=False))
])

# Combinar preprocesamiento
preprocessor = ColumnTransformer(transformers=[
    ('num', num_transformer, num_cols),
    ('cat', cat_transformer, cat_cols),
    ('bin', 'passthrough', bin_cols)
])

# 3. Pipelines completos de extremo a extremo
pipeline_rf = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', RandomForestClassifier(random_state=42, class_weight='balanced'))
])

pipeline_svm = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('classifier', SVC(probability=True, random_state=42, class_weight='balanced'))
])

print("✅ Pipelines de Random Forest y SVM creados exitosamente.")

# ===========================================================================
# 7. OPTIMIZACIÓN CON GRIDSEARCHCV
# ===========================================================================

# Cuadrículas de parámetros a probar
param_grid_rf = {
    'classifier__n_estimators': [50, 100, 200],
    'classifier__max_depth': [4, 6, 8, 10],
    'classifier__min_samples_split': [2, 5, 10]
}

param_grid_svm = {
    'classifier__C': [0.1, 1, 10],
    'classifier__gamma': ['scale', 'auto', 0.01, 0.1]
}

print("🔎 Iniciando búsqueda de hiperparámetros para Random Forest...")
grid_rf = GridSearchCV(pipeline_rf, param_grid_rf, cv=5, scoring='f1', n_jobs=-1)
grid_rf.fit(X_train, y_train)
best_rf_model = grid_rf.best_estimator_
print(f"🥇 Mejores parámetros RF: {grid_rf.best_params_}")
print(f"📈 Mejor F1-score RF: {grid_rf.best_score_:.4f}")

print("\n🔎 Iniciando búsqueda de hiperparámetros para SVM...")
grid_svm = GridSearchCV(pipeline_svm, param_grid_svm, cv=5, scoring='f1', n_jobs=-1)
grid_svm.fit(X_train, y_train)
best_svm_model = grid_svm.best_estimator_
print(f"🥇 Mejores parámetros SVM: {grid_svm.best_params_}")
print(f"📈 Mejor F1-score SVM: {grid_svm.best_score_:.4f}")

# ===========================================================================
# 8. EVALUACIÓN ROBUSTA CON VALIDACIÓN CRUZADA MULTIMÉTRICA
# ===========================================================================

metricas = {
    'accuracy': 'accuracy',
    'precision': 'precision',
    'recall': 'recall',
    'f1': 'f1'
}

# Validación cruzada para el modelo optimizado de Random Forest
cv_results_rf = cross_validate(
    best_rf_model, X_train, y_train, cv=5, scoring=metricas, return_train_score=True
)

# Validación cruzada para el modelo optimizado de SVM
cv_results_svm = cross_validate(
    best_svm_model, X_train, y_train, cv=5, scoring=metricas, return_train_score=True
)

# Mostrar resultados promedio
def mostrar_resumen_cv(resultados, nombre):
    print(f"=== Resultados de Validación Cruzada (Train vs Val) para {nombre} ===")
    print(f"{'Métrica':<15} | {'Entrenamiento (Promedio)':<25} | {'Validación (Promedio)':<20}")
    print("-" * 70)
    for m in metricas.keys():
        train_mean = resultados[f'train_{m}'].mean()
        val_mean = resultados[f'test_{m}'].mean()
        print(f"{m.capitalize():<15} | {train_mean:24.4f} | {val_mean:19.4f}")
    print("=" * 70 + "\n")

mostrar_resumen_cv(cv_results_rf, "Random Forest")
mostrar_resumen_cv(cv_results_svm, "SVM")

# ===========================================================================
# 9. EVALUACIÓN FINAL EN TEST SET Y MATRICES DE CONFUSIÓN
# ===========================================================================

# Predicciones
y_pred_rf = best_rf_model.predict(X_test)
y_pred_svm = best_svm_model.predict(X_test)

y_probs_rf = best_rf_model.predict_proba(X_test)[:, 1]
y_probs_svm = best_svm_model.predict_proba(X_test)[:, 1]

# Graficar matrices de confusión y curvas ROC
fig, axes = plt.subplots(2, 2, figsize=(16, 14))

# 1. Matriz de Confusión Random Forest
cm_rf = confusion_matrix(y_test, y_pred_rf)
sns.heatmap(cm_rf, annot=True, fmt='d', cmap='Blues', ax=axes[0, 0])
axes[0, 0].set_title('Matriz de Confusión - Random Forest')
axes[0, 0].set_xlabel('Predicción')
axes[0, 0].set_ylabel('Real')

# 2. Matriz de Confusión SVM
cm_svm = confusion_matrix(y_test, y_pred_svm)
sns.heatmap(cm_svm, annot=True, fmt='d', cmap='Oranges', ax=axes[0, 1])
axes[0, 1].set_title('Matriz de Confusión - SVM')
axes[0, 1].set_xlabel('Predicción')
axes[0, 1].set_ylabel('Real')

# 3. Curva ROC
fpr_rf, tpr_rf, _ = roc_curve(y_test, y_probs_rf)
fpr_svm, tpr_svm, _ = roc_curve(y_test, y_probs_svm)
auc_rf = auc(fpr_rf, tpr_rf)
auc_svm = auc(fpr_svm, tpr_svm)

axes[1, 0].plot(fpr_rf, tpr_rf, color='blue', lw=2, label=f'Random Forest (AUC = {auc_rf:.4f})')
axes[1, 0].plot(fpr_svm, tpr_svm, color='orange', lw=2, label=f'SVM (AUC = {auc_svm:.4f})')
axes[1, 0].plot([0, 1], [0, 1], color='navy', linestyle='--')
axes[1, 0].set_xlim([0.0, 1.0])
axes[1, 0].set_ylim([0.0, 1.05])
axes[1, 0].set_xlabel('Tasa de Falsos Positivos')
axes[1, 0].set_ylabel('Tasa de Verdaderos Positivos')
axes[1, 0].set_title('Curva ROC')
axes[1, 0].legend(loc="lower right")

# 4. Tabla comparativa de métricas en Test Set
metricas_test = {
    'Modelo': ['Random Forest', 'SVM'],
    'Accuracy': [accuracy_score(y_test, y_pred_rf), accuracy_score(y_test, y_pred_svm)],
    'Precision': [precision_score(y_test, y_pred_rf), precision_score(y_test, y_pred_svm)],
    'Recall': [recall_score(y_test, y_pred_rf), recall_score(y_test, y_pred_svm)],
    'F1-score': [f1_score(y_test, y_pred_rf), f1_score(y_test, y_pred_svm)]
}
df_metricas = pd.DataFrame(metricas_test)
# Mostrar tabla como heatmap de texto en la gráfica
axes[1, 1].axis('off')
axes[1, 1].set_title('Métricas Finales en Conjunto de Prueba', fontsize=14, fontweight='bold')
tabla = axes[1, 1].table(
    cellText=df_metricas.values,
    colLabels=df_metricas.columns,
    cellLoc='center',
    loc='center'
)
tabla.set_fontsize(12)
tabla.scale(1, 2)

plt.tight_layout()
plt.savefig('resultados_comparativos_modelos.png', dpi=150, bbox_inches='tight')
plt.show()
print("Gráfica guardada: resultados_comparativos_modelos.png")

# Imprimir reportes en texto
print("\n" + "=" * 60)
print("REPORTE DE CLASIFICACIÓN: RANDOM FOREST")
print("=" * 60)
print(classification_report(y_test, y_pred_rf))

print("\n" + "=" * 60)
print("REPORTE DE CLASIFICACIÓN: SVM")
print("=" * 60)
print(classification_report(y_test, y_pred_svm))