📊 Portafolio de Evidencias: Canalización de Proyectos de 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, learning_curve
)
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder, FunctionTransformer
from sklearn.feature_selection import SelectKBest, f_classif

# Clasificadores
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.svm import SVC

# Métricas
from sklearn.metrics import (
    classification_report, confusion_matrix, accuracy_score,
    precision_score, recall_score, f1_score, roc_curve, auc,
    ConfusionMatrixDisplay, RocCurveDisplay
)

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

print("✅ Librerías cargadas exitosamente.")
print(f"   pandas: {pd.__version__}")
print(f"   numpy: {np.__version__}")
import sklearn
print(f"   scikit-learn: {sklearn.__version__}")

# ===========================================================================
# 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: {e}")

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

print(f"\nDimensiones del dataset: {df.shape[0]} filas × {df.shape[1]} columnas")
print(f"\nColumnas: {list(df.columns)}")
print(f"\nPrimeras 5 filas:")
display(df.head())

# ===========================================================================
# 4.1 Información general del dataset
# ===========================================================================
print("=" * 60)
print("RESUMEN ESTADÍSTICO DEL DATASET")
print("=" * 60)
print(f"\nForma: {df.shape}")
print(f"\nValores faltantes por columna:")
missing = df.isnull().sum()
missing_pct = (missing / len(df) * 100).round(1)
missing_df = pd.DataFrame({'Faltantes': missing, 'Porcentaje (%)': missing_pct})
display(missing_df[missing_df['Faltantes'] > 0])

print(f"\nDistribución de la variable objetivo (survived):")
display(df['survived'].value_counts().to_frame('Conteo'))
print(f"\nTasa de supervivencia: {df['survived'].mean():.1%}")

# ===========================================================================
# 4.2 Visualizaciones exploratorias
# ===========================================================================
fig, axes = plt.subplots(2, 2, figsize=(14, 10))
fig.suptitle('Análisis Exploratorio del Dataset Titanic', fontsize=14, fontweight='bold')

# 4.2.1 Distribución de supervivencia
sns.countplot(data=df, x='survived', hue='survived', palette='Set2', ax=axes[0, 0], legend=False)
axes[0, 0].set_title('Distribución de Supervivencia')
axes[0, 0].set_xticklabels(['No Sobrevivió (0)', 'Sobrevivió (1)'])
axes[0, 0].set_ylabel('Frecuencia')

# 4.2.2 Supervivencia por clase
sns.countplot(data=df, x='pclass', hue='survived', palette='Set1', ax=axes[0, 1])
axes[0, 1].set_title('Supervivencia por Clase del Boleto')
axes[0, 1].set_xlabel('Clase')
axes[0, 1].legend(title='Survived', labels=['No', 'Sí'])

# 4.2.3 Distribución de edad por supervivencia
df[df['age'].notna()].boxplot(column='age', by='survived', ax=axes[1, 0])
axes[1, 0].set_title('Distribución de Edad por Supervivencia')
axes[1, 0].set_xlabel('Survived')
axes[1, 0].set_ylabel('Edad')
plt.sca(axes[1, 0])
plt.title('Distribución de Edad por Supervivencia')

# 4.2.4 Supervivencia por género
sns.countplot(data=df, x='sex', hue='survived', palette='coolwarm', ax=axes[1, 1])
axes[1, 1].set_title('Supervivencia por Género')
axes[1, 1].legend(title='Survived', labels=['No', 'Sí'])

plt.tight_layout()
plt.show()

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

# 5.1 Ingeniería de características
df['family_size'] = df['sibsp'] + df['parch'] + 1
df['is_alone'] = (df['family_size'] == 1).astype(int)

# 5.2 Selección de variables
FEATURES_NUM = ['age', 'fare', 'sibsp', 'parch', 'family_size', 'is_alone']
FEATURES_CAT = ['sex', 'embarked', 'pclass']
TARGET = 'survived'

# Convertir pclass a string para que sea tratada como categórica
df['pclass'] = df['pclass'].astype(str)

X = df[FEATURES_NUM + FEATURES_CAT]
y = df[TARGET]

# 5.3 División en entrenamiento y prueba (80/20, estratificada)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

print(f"Conjunto de entrenamiento: {X_train.shape[0]} muestras")
print(f"Conjunto de prueba:        {X_test.shape[0]} muestras")
print(f"\nVariables numéricas:  {FEATURES_NUM}")
print(f"Variables categóricas: {FEATURES_CAT}")
print(f"Variable objetivo:     {TARGET}")

# ===========================================================================
# 6. CONSTRUCCIÓN DEL PIPELINE DE CANALIZACIÓN
# ===========================================================================

# 6.1 Preprocesador unificado con ColumnTransformer
preprocessor = ColumnTransformer(
    transformers=[
        ('num', Pipeline([
            ('imputer', SimpleImputer(strategy='median')),
            ('scaler', StandardScaler())
        ]), FEATURES_NUM),
        ('cat', Pipeline([
            ('imputer', SimpleImputer(strategy='most_frequent')),
            ('onehot', OneHotEncoder(drop='first', sparse_output=False, handle_unknown='ignore'))
        ]), FEATURES_CAT)
    ]
)

# 6.2 Definición de los tres pipelines
pipelines = {
    'Random Forest': Pipeline([
        ('preprocessor', preprocessor),
        ('classifier', RandomForestClassifier(random_state=42))
    ]),
    'Gradient Boosting': Pipeline([
        ('preprocessor', preprocessor),
        ('classifier', GradientBoostingClassifier(random_state=42))
    ]),
    'SVM (SVC)': Pipeline([
        ('preprocessor', preprocessor),
        ('classifier', SVC(random_state=42, probability=True))
    ])
}

print("✅ Pipelines construidos exitosamente:")
for name in pipelines:
    print(f"   • {name}")

# Mostrar la estructura del pipeline de Random Forest como ejemplo
print("\n📐 Estructura del pipeline (Random Forest):")
print(pipelines['Random Forest'])

# ===========================================================================
# 7. VALIDACIÓN CRUZADA MULTIMÉTRICA (BASELINE)
# ===========================================================================
SCORING = ['accuracy', 'precision', 'recall', 'f1', 'roc_auc']
CV_FOLDS = 5

results_baseline = {}

print("=" * 70)
print("EVALUACIÓN BASELINE — Validación Cruzada (5-Fold Estratificada)")
print("=" * 70)

for name, pipeline in pipelines.items():
    cv_results = cross_validate(
        pipeline, X_train, y_train,
        cv=CV_FOLDS, scoring=SCORING,
        return_train_score=False, n_jobs=-1
    )

    results_baseline[name] = {
        metric: cv_results[f'test_{metric}'].mean()
        for metric in SCORING
    }

    print(f"\n🔹 {name}:")
    for metric in SCORING:
        mean_val = cv_results[f'test_{metric}'].mean()
        std_val = cv_results[f'test_{metric}'].std()
        print(f"   {metric:>12s}: {mean_val:.4f} ± {std_val:.4f}")

# Tabla comparativa
print("\n" + "=" * 70)
print("TABLA COMPARATIVA BASELINE")
print("=" * 70)
baseline_df = pd.DataFrame(results_baseline).T
baseline_df.columns = [m.upper() for m in SCORING]
display(baseline_df.round(4))

# ===========================================================================
# 8. OPTIMIZACIÓN DE HIPERPARÁMETROS CON GridSearchCV
# ===========================================================================

# 8.1 Definición de grids de búsqueda
param_grids = {
    'Random Forest': {
        'classifier__n_estimators': [50, 100, 200],
        'classifier__max_depth': [5, 10, 15, None],
        'classifier__min_samples_split': [2, 5],
        'classifier__min_samples_leaf': [1, 2]
    },
    'Gradient Boosting': {
        'classifier__n_estimators': [50, 100, 200],
        'classifier__learning_rate': [0.01, 0.1, 0.2],
        'classifier__max_depth': [3, 5, 7],
        'classifier__subsample': [0.8, 1.0]
    },
    'SVM (SVC)': {
        'classifier__C': [0.1, 1, 10],
        'classifier__kernel': ['rbf', 'linear'],
        'classifier__gamma': ['scale', 'auto']
    }
}

# 8.2 Ejecución de GridSearchCV para cada pipeline
best_models = {}
results_optimized = {}

print("=" * 70)
print("OPTIMIZACIÓN DE HIPERPARÁMETROS — GridSearchCV (5-Fold)")
print("=" * 70)

for name, pipeline in pipelines.items():
    print(f"\n🔍 Optimizando {name}...")

    grid_search = GridSearchCV(
        pipeline,
        param_grids[name],
        cv=CV_FOLDS,
        scoring='f1',           # Optimizamos por F1
        n_jobs=-1,
        verbose=0,
        refit=True
    )
    grid_search.fit(X_train, y_train)

    best_models[name] = grid_search.best_estimator_
    results_optimized[name] = {
        'best_score': grid_search.best_score_,
        'best_params': grid_search.best_params_
    }

    print(f"   ✅ Mejor F1 (CV): {grid_search.best_score_:.4f}")
    print(f"   📋 Mejores parámetros:")
    for param, value in grid_search.best_params_.items():
        param_short = param.replace('classifier__', '')
        print(f"      {param_short}: {value}")

print("\n" + "=" * 70)
print("RESUMEN DE OPTIMIZACIÓN")
print("=" * 70)
for name, result in results_optimized.items():
    baseline_f1 = results_baseline[name]['f1']
    optimized_f1 = result['best_score']
    improvement = optimized_f1 - baseline_f1
    arrow = "↑" if improvement > 0 else ("↓" if improvement < 0 else "=")
    print(f"   {name}: F1 {baseline_f1:.4f} → {optimized_f1:.4f} ({arrow} {abs(improvement):.4f})")

# ===========================================================================
# 9.1 EVALUACIÓN EN CONJUNTO DE PRUEBA
# ===========================================================================

print("=" * 70)
print("EVALUACIÓN FINAL EN CONJUNTO DE PRUEBA")
print("=" * 70)

final_results = {}

for name, model in best_models.items():
    y_pred = model.predict(X_test)
    y_proba = model.predict_proba(X_test)[:, 1]

    acc = accuracy_score(y_test, y_pred)
    prec = precision_score(y_test, y_pred)
    rec = recall_score(y_test, y_pred)
    f1 = f1_score(y_test, y_pred)
    fpr, tpr, _ = roc_curve(y_test, y_proba)
    roc_auc_val = auc(fpr, tpr)

    final_results[name] = {
        'Accuracy': acc, 'Precision': prec, 'Recall': rec,
        'F1-Score': f1, 'AUC-ROC': roc_auc_val,
        'y_pred': y_pred, 'y_proba': y_proba, 'fpr': fpr, 'tpr': tpr
    }

    print(f"\n🔹 {name}:")
    print(f"   Accuracy:  {acc:.4f}")
    print(f"   Precision: {prec:.4f}")
    print(f"   Recall:    {rec:.4f}")
    print(f"   F1-Score:  {f1:.4f}")
    print(f"   AUC-ROC:   {roc_auc_val:.4f}")

# Tabla comparativa final
print("\n" + "=" * 70)
print("TABLA COMPARATIVA FINAL (Conjunto de Prueba)")
print("=" * 70)
final_df = pd.DataFrame({
    name: {k: v for k, v in vals.items() if k not in ['y_pred', 'y_proba', 'fpr', 'tpr']}
    for name, vals in final_results.items()
}).T
display(final_df.round(4))

# Identificar el mejor modelo
best_model_name = final_df['F1-Score'].idxmax()
print(f"\n🏆 Mejor modelo por F1-Score: {best_model_name} ({final_df.loc[best_model_name, 'F1-Score']:.4f})")

# ===========================================================================
# 9.2 MATRICES DE CONFUSIÓN
# ===========================================================================
fig, axes = plt.subplots(1, 3, figsize=(18, 5))
fig.suptitle('Matrices de Confusión — Modelos Optimizados', fontsize=14, fontweight='bold')

for idx, (name, vals) in enumerate(final_results.items()):
    ConfusionMatrixDisplay.from_predictions(
        y_test, vals['y_pred'],
        display_labels=['No Sobrevivió', 'Sobrevivió'],
        cmap='Blues', ax=axes[idx]
    )
    axes[idx].set_title(f'{name}\nF1 = {vals["F1-Score"]:.4f}')

plt.tight_layout()
plt.show()

# ===========================================================================
# 9.3 CURVAS ROC COMPARATIVAS
# ===========================================================================
fig, ax = plt.subplots(figsize=(8, 6))

colors = ['#2ecc71', '#e74c3c', '#3498db']
for idx, (name, vals) in enumerate(final_results.items()):
    ax.plot(vals['fpr'], vals['tpr'],
            color=colors[idx], lw=2,
            label=f"{name} (AUC = {vals['AUC-ROC']:.4f})")

ax.plot([0, 1], [0, 1], 'k--', lw=1, label='Azar (AUC = 0.5)')
ax.set_xlabel('Tasa de Falsos Positivos (FPR)')
ax.set_ylabel('Tasa de Verdaderos Positivos (TPR)')
ax.set_title('Curvas ROC — Comparativa de Modelos Optimizados', fontweight='bold')
ax.legend(loc='lower right')
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

# ===========================================================================
# 9.4 IMPORTANCIA DE CARACTERÍSTICAS (Random Forest optimizado)
# ===========================================================================
rf_model = best_models['Random Forest']
feature_names_num = FEATURES_NUM
feature_names_cat = rf_model.named_steps['preprocessor'] \
    .named_transformers_['cat'] \
    .named_steps['onehot'] \
    .get_feature_names_out(FEATURES_CAT).tolist()
all_features = feature_names_num + feature_names_cat

importances = rf_model.named_steps['classifier'].feature_importances_
feat_imp_df = pd.DataFrame({
    'Feature': all_features,
    'Importancia': importances
}).sort_values('Importancia', ascending=True)

fig, ax = plt.subplots(figsize=(10, 6))
ax.barh(feat_imp_df['Feature'], feat_imp_df['Importancia'], color='#3498db', edgecolor='#2c3e50')
ax.set_xlabel('Importancia')
ax.set_title('Importancia de Características — Random Forest Optimizado', fontweight='bold')
ax.grid(True, alpha=0.3, axis='x')
plt.tight_layout()
plt.show()

print("\nTop 5 características más importantes:")
for _, row in feat_imp_df.tail(5).iloc[::-1].iterrows():
    print(f"   {row['Feature']:>20s}: {row['Importancia']:.4f}")

# ===========================================================================
# 9.5 CURVA DE APRENDIZAJE (Mejor modelo)
# ===========================================================================
print(f"Generando curva de aprendizaje para: {best_model_name}")

train_sizes, train_scores, val_scores = learning_curve(
    best_models[best_model_name], X_train, y_train,
    cv=5, scoring='f1',
    train_sizes=np.linspace(0.1, 1.0, 10),
    n_jobs=-1
)

train_mean = train_scores.mean(axis=1)
train_std = train_scores.std(axis=1)
val_mean = val_scores.mean(axis=1)
val_std = val_scores.std(axis=1)

fig, ax = plt.subplots(figsize=(10, 6))
ax.fill_between(train_sizes, train_mean - train_std, train_mean + train_std, alpha=0.1, color='#2ecc71')
ax.fill_between(train_sizes, val_mean - val_std, val_mean + val_std, alpha=0.1, color='#e74c3c')
ax.plot(train_sizes, train_mean, 'o-', color='#2ecc71', label='F1 Entrenamiento')
ax.plot(train_sizes, val_mean, 'o-', color='#e74c3c', label='F1 Validación')
ax.set_xlabel('Tamaño del conjunto de entrenamiento')
ax.set_ylabel('F1-Score')
ax.set_title(f'Curva de Aprendizaje — {best_model_name}', fontweight='bold')
ax.legend(loc='lower right')
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

gap = train_mean[-1] - val_mean[-1]
print(f"\nGap entrenamiento-validación: {gap:.4f}")
if gap < 0.05:
    print("→ El modelo no presenta sobreajuste significativo.")
elif gap < 0.10:
    print("→ El modelo muestra un ligero sobreajuste que podría mejorarse con más datos o regularización.")
else:
    print("→ El modelo presenta sobreajuste. Se recomienda regularización adicional.")