1. EDA, data leakage y modelos

import time
import warnings
from pathlib import Path

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.ticker as mtick
from matplotlib.colors import LinearSegmentedColormap
import seaborn as sns
from scipy import stats
from IPython.display import display

warnings.filterwarnings("ignore")

pd.set_option("display.max_columns", 60)
pd.set_option("display.max_rows", 60)
pd.set_option("display.float_format", "{:.4f}".format)

SEED = 42

print(f"pandas {pd.__version__} | numpy {np.__version__} | seaborn {sns.__version__}")

COLOR = {
    "principal":  "#2a78d6",   # azul: color de serie por defecto
    "secundario": "#eb6834",   # naranja: solo para destacar
    "texto":      "#0b0b0b",
    "texto_2":    "#52514e",
    "tenue":      "#898781",   # gris: categorías raras / outliers
    "rejilla":    "#e1e0d9",
    "eje":        "#c3c2b7",
}

plt.rcParams.update({
    "font.family": "sans-serif",
    "font.sans-serif": ["Segoe UI", "Calibri", "Arial", "DejaVu Sans"],
    "font.size": 10,
    "axes.titlesize": 11,
    "axes.titleweight": "semibold",
    "axes.titlelocation": "left",
    "axes.titlepad": 10,
    "axes.labelsize": 10,
    "axes.labelcolor": COLOR["texto_2"],
    "axes.edgecolor": COLOR["eje"],
    "axes.linewidth": 0.8,
    "axes.spines.top": False,
    "axes.spines.right": False,
    "axes.grid": True,
    "axes.axisbelow": True,
    "grid.color": COLOR["rejilla"],
    "grid.linewidth": 0.6,
    "xtick.color": COLOR["texto_2"],
    "ytick.color": COLOR["texto_2"],
    "xtick.labelsize": 9,
    "ytick.labelsize": 9,
    "text.color": COLOR["texto"],
    "figure.facecolor": "white",
    "axes.facecolor": "white",
    "figure.dpi": 110,
    "savefig.dpi": 150,
    "savefig.bbox": "tight",
    "legend.frameon": False,
    "legend.fontsize": 9,
})

# Colores y nombres de las clases de la variable objetivo
CLASE_COLOR = {0: COLOR["principal"], 1: COLOR["secundario"]}
CLASE_NOMBRE = {0: "Sin enfermedad", 1: "Con enfermedad"}

CMAP_DIV = LinearSegmentedColormap.from_list("azul_rojo", ["#104281", "#6da7ec", "#f0efec", "#ec835a", "#b2302f"])
CMAP_SEC = LinearSegmentedColormap.from_list("azul", ["#f7f9fc", "#9ec5f4", "#2a78d6", "#0d366b"])


def titulo_figura(fig, texto):
    fig.suptitle(texto, x=0.01, ha="left", fontsize=13, fontweight="semibold")


def fmt_p(p):
    return "p < 0.001" if p < 0.001 else f"p = {p:.3f}"

# El notebook vive en notebooks/, los datos en data/ y las figuras en figuras/
ROOT = Path.cwd().parent if Path.cwd().name == "notebooks" else Path.cwd()
FILE_PATH = ROOT / "data" / "heart.csv"
FIG_DIR = ROOT / "figuras"
FIG_DIR.mkdir(exist_ok=True)

assert FILE_PATH.exists(), f"No se encontró el archivo: {FILE_PATH.resolve()}"

t_inicio = time.time()
df = pd.read_csv(FILE_PATH)
print(f"Archivo  : {FILE_PATH.resolve()}")
print(f"Tamaño   : {FILE_PATH.stat().st_size / 1e3:.1f} KB en disco")
print(f"Filas    : {df.shape[0]:,} pacientes")
print(f"Columnas : {df.shape[1]}")
print(f"Memoria  : {df.memory_usage(deep=True).sum() / 1e3:.1f} KB")
print(f"Carga en {time.time() - t_inicio:.3f} s")

TARGET = "HeartDisease"
NUM_VARS = ["Age", "RestingBP", "Cholesterol", "MaxHR", "Oldpeak"]
CAT_VARS = ["Sex", "ChestPainType", "FastingBS", "RestingECG", "ExerciseAngina", "ST_Slope"]

assert set(NUM_VARS + CAT_VARS + [TARGET]) == set(df.columns)
print(f"Numéricas   ({len(NUM_VARS)}): {NUM_VARS}")
print(f"Categóricas ({len(CAT_VARS)}): {CAT_VARS}")
print(f"Objetivo       : {TARGET}")

df.info()

tipos = pd.DataFrame({
    "dtype": df.dtypes.astype(str),
    "n_unicos": df.nunique(),
    "ejemplo": df.iloc[0],
    "rol": ["objetivo" if c == TARGET else "numérica" if c in NUM_VARS else "categórica" for c in df.columns],
})
display(tipos)

nulos = pd.DataFrame({"n_nulos": df.isna().sum(), "pct_nulos": df.isna().mean() * 100})
display(nulos.T)
print(f"Total de nulos explícitos: {df.isna().sum().sum()}")
print(f"Filas duplicadas         : {df.duplicated().sum()}")
print(f"Duplicados sin el target : {df.drop(columns=TARGET).duplicated().sum()}")

CEROS_IMPOSIBLES = ["RestingBP", "Cholesterol"]      # 0 no es un valor clínico posible

filas = []
for col in NUM_VARS:
    s = df[col]
    filas.append({
        "variable": col,
        "min": s.min(), "max": s.max(),
        "n_ceros": int((s == 0).sum()),
        "pct_ceros": (s == 0).mean() * 100,
        "n_negativos": int((s < 0).sum()),
        "¿el 0 es posible?": "No → nulo oculto" if col in CEROS_IMPOSIBLES else "Sí",
    })
display(pd.DataFrame(filas).set_index("variable").style.format({"pct_ceros": "{:.2f} %", "min": "{:g}", "max": "{:g}"}))

# Copia para el EDA con los ceros imposibles marcados como faltantes.
# El dataset original (df) no se modifica: la imputación se hará dentro del Pipeline (sin fuga).
df_eda = df.copy()
df_eda[CEROS_IMPOSIBLES] = df_eda[CEROS_IMPOSIBLES].replace(0, np.nan)

print("Nulos en la copia del EDA:")
display(df_eda[CEROS_IMPOSIBLES].isna().agg(["sum", "mean"]).T.rename(columns={"sum": "n_nulos", "mean": "proporcion"}))

def resumen_numerico(data, columnas):
    filas = []
    for col in columnas:
        s = data[col].dropna().astype("float64")
        q1, q2, q3 = s.quantile([0.25, 0.50, 0.75])
        iqr = q3 - q1
        lim_inf, lim_sup = q1 - 1.5 * iqr, q3 + 1.5 * iqr
        n_out = int(((s < lim_inf) | (s > lim_sup)).sum())
        filas.append({
            "variable": col, "n": len(s),
            "media": s.mean(), "mediana": q2, "desv_std": s.std(),
            "min": s.min(), "p25": q1, "p50": q2, "p75": q3, "max": s.max(),
            "IQR": iqr, "lim_inf": lim_inf, "lim_sup": lim_sup,
            "n_outliers": n_out, "pct_outliers": n_out / len(s) * 100,
            "asimetria": s.skew(), "curtosis": s.kurt(),
        })
    return pd.DataFrame(filas).set_index("variable")

resumen_num = resumen_numerico(df_eda, NUM_VARS)
display(resumen_num.style.format("{:,.2f}"))

# Efecto de dejar los ceros como si fueran datos reales
comparacion = pd.DataFrame({
    "media_con_ceros": df[CEROS_IMPOSIBLES].mean(),
    "media_sin_ceros": df_eda[CEROS_IMPOSIBLES].mean(),
    "mediana_con_ceros": df[CEROS_IMPOSIBLES].median(),
    "mediana_sin_ceros": df_eda[CEROS_IMPOSIBLES].median(),
})
print("Efecto de los ceros imposibles en la media y la mediana:")
display(comparacion.style.format("{:,.1f}"))

outliers = (resumen_num[["p25", "p75", "IQR", "lim_inf", "lim_sup", "min", "max", "n_outliers", "pct_outliers"]]
            .sort_values("pct_outliers", ascending=False))
display(outliers.style.format("{:,.2f}"))

# Detalle de los valores fuera de los límites
for col in NUM_VARS:
    lim_inf, lim_sup = resumen_num.loc[col, ["lim_inf", "lim_sup"]]
    s = df_eda[col].dropna()
    fuera = s[(s < lim_inf) | (s > lim_sup)]
    if len(fuera):
        print(f"{col:12s} ({len(fuera)} outliers): bajos = {sorted(fuera[fuera < lim_inf].unique())[:10]} | "
              f"altos = {sorted(fuera[fuera > lim_sup].unique())[-10:]}")

fig, axes = plt.subplots(2, 3, figsize=(14, 8))
paneles = [(col, df_eda[col].dropna()) for col in NUM_VARS] + [("Cholesterol (con los ceros originales)", df["Cholesterol"])]

for ax, (nombre, s) in zip(axes.flat, paneles):
    unicos = np.unique(s)
    if len(unicos) <= 60:                      # variable discreta: una barra por valor
        paso = np.diff(unicos).min()
        bins = np.arange(unicos[0] - paso / 2, unicos[-1] + paso, paso)
    else:
        bins = 35
    es_original = "originales" in nombre
    ax.hist(s, bins=bins, color=COLOR["tenue"] if es_original else COLOR["principal"],
            edgecolor="white", linewidth=0.4)
    ax.axvline(s.mean(), color=COLOR["texto"], linestyle="--", linewidth=1.2, label=f"Media: {s.mean():,.1f}")
    ax.axvline(s.median(), color=COLOR["texto_2"], linestyle=":", linewidth=1.6, label=f"Mediana: {s.median():,.1f}")
    if es_original:
        n0 = int((s == 0).sum())
        ax.annotate(f"{n0} ceros\n({n0 / len(s):.1%})", xy=(0, n0), xytext=(90, n0 * 0.85),
                    color=COLOR["secundario"], fontsize=9, arrowprops=dict(arrowstyle="->", color=COLOR["secundario"]))
    ax.set_title(nombre)
    ax.set_ylabel("Frecuencia")
    ax.grid(axis="x", visible=False)
    ax.legend(loc="upper right")

titulo_figura(fig, "Distribución de las variables numéricas")
fig.tight_layout()
fig.savefig(FIG_DIR / "01_histogramas.png")
plt.show()

fig, axes = plt.subplots(len(NUM_VARS), 1, figsize=(11, 1.6 * len(NUM_VARS) + 1))
for ax, col in zip(axes, NUM_VARS):
    ax.boxplot(df_eda[col].dropna(), vert=False, widths=0.55, patch_artist=True,
               boxprops=dict(facecolor=COLOR["principal"], edgecolor=COLOR["texto_2"], alpha=0.85),
               medianprops=dict(color="white", linewidth=2),
               whiskerprops=dict(color=COLOR["texto_2"]), capprops=dict(color=COLOR["texto_2"]),
               flierprops=dict(marker="o", markersize=3.5, markerfacecolor=COLOR["secundario"],
                               markeredgecolor="none", alpha=0.6))
    ax.set_yticks([])
    ax.grid(axis="y", visible=False)
    ax.set_title(f"{col}  ·  outliers IQR: {resumen_num.loc[col, 'n_outliers']} ({resumen_num.loc[col, 'pct_outliers']:.1f} %)")

titulo_figura(fig, "Diagramas de caja (ceros imposibles excluidos)")
fig.tight_layout()
fig.savefig(FIG_DIR / "01_boxplots.png")
plt.show()

def recomendar_transformacion(asim, minimo):
    if abs(asim) < 0.5:
        return "Aprox. simétrica: no requiere"
    if abs(asim) < 1:
        return "Asimetría moderada: opcional"
    if minimo > 0:
        return "Asimetría fuerte: log o Box-Cox"
    return "Asimetría fuerte: Yeo-Johnson (hay ceros o negativos)"

filas = []
for col in NUM_VARS:
    s = df_eda[col].dropna().astype("float64")
    w, p_sw = stats.shapiro(s)
    k2, p_dp = stats.normaltest(s)
    filas.append({
        "variable": col, "n": len(s),
        "asimetria": s.skew(), "curtosis": s.kurt(),
        "W_Shapiro": w, "p_Shapiro": p_sw,
        "K2_DAgostino": k2, "p_DAgostino": p_dp,
        "¿normal? (p > 0.05)": "Sí" if min(p_sw, p_dp) > 0.05 else "No",
        "recomendación": recomendar_transformacion(s.skew(), s.min()),
    })

normalidad = pd.DataFrame(filas).set_index("variable").sort_values("asimetria", key=abs, ascending=False)
display(normalidad.style.format({"asimetria": "{:.2f}", "curtosis": "{:.2f}", "W_Shapiro": "{:.4f}",
                                 "p_Shapiro": "{:.2e}", "K2_DAgostino": "{:.1f}", "p_DAgostino": "{:.2e}"}))

# Gráficos Q-Q
fig, axes = plt.subplots(1, len(NUM_VARS), figsize=(16, 3.6))
for ax, col in zip(axes, NUM_VARS):
    (osm, osr), (pend, inter, _) = stats.probplot(df_eda[col].dropna(), dist="norm")
    ax.scatter(osm, osr, s=8, color=COLOR["principal"], alpha=0.6, linewidth=0)
    ax.plot(osm, pend * osm + inter, color=COLOR["secundario"], linewidth=1.5)
    ax.set_title(col)
    ax.set_xlabel("Cuantiles teóricos")
axes[0].set_ylabel("Cuantiles observados")
titulo_figura(fig, "Gráficos Q-Q frente a la distribución normal")
fig.tight_layout()
fig.savefig(FIG_DIR / "01_qqplots.png")
plt.show()

UMBRAL_RARA = 5   # %

def tabla_frecuencias(data, col):
    abs_ = data[col].value_counts(dropna=False)
    tabla = pd.DataFrame({"frecuencia": abs_, "porcentaje": abs_ / len(data) * 100})
    tabla.index = tabla.index.astype(str)
    tabla.index.name = col
    tabla["baja_frecuencia"] = np.where(tabla["porcentaje"] < UMBRAL_RARA, "Sí", "")
    return tabla

frecuencias = {col: tabla_frecuencias(df, col) for col in CAT_VARS}

resumen_cat = pd.DataFrame([{
    "variable": col,
    "n_categorias": len(t),
    "categoria_mas_frecuente": t.index[0],
    "pct_mas_frecuente": t["porcentaje"].iloc[0],
    "categoria_menos_frecuente": t.index[-1],
    "pct_menos_frecuente": t["porcentaje"].iloc[-1],
    f"n_bajo_{UMBRAL_RARA}pct": int((t["porcentaje"] < UMBRAL_RARA).sum()),
} for col, t in frecuencias.items()]).set_index("variable")
display(resumen_cat.style.format({"pct_mas_frecuente": "{:.1f} %", "pct_menos_frecuente": "{:.1f} %"}))

for col in CAT_VARS:
    print(f"\n{col}  ({df[col].nunique()} categorías)")
    display(frecuencias[col].style.format({"frecuencia": "{:,}", "porcentaje": "{:.2f} %"}))

ORDEN = {
    "ChestPainType": ["TA", "ATA", "NAP", "ASY"],
    "RestingECG": ["Normal", "ST", "LVH"],
    "ST_Slope": ["Up", "Flat", "Down"],
    "FastingBS": ["0", "1"],
}

fig, axes = plt.subplots(2, 3, figsize=(14, 7))
for ax, col in zip(axes.flat, CAT_VARS):
    t = frecuencias[col]
    t = t.loc[[c for c in ORDEN[col] if c in t.index]] if col in ORDEN else t
    colores = np.where(t["baja_frecuencia"] == "Sí", COLOR["tenue"], COLOR["principal"])
    barras = ax.bar(t.index, t["frecuencia"], color=colores, width=0.6)
    for barra, f, p in zip(barras, t["frecuencia"], t["porcentaje"]):
        ax.text(barra.get_x() + barra.get_width() / 2, f, f"{f}\n({p:.1f} %)",
                ha="center", va="bottom", fontsize=8.5, color=COLOR["texto_2"])
    ax.set_ylim(0, t["frecuencia"].max() * 1.25)
    ax.set_title(col)
    ax.set_ylabel("Pacientes")
    ax.grid(axis="x", visible=False)

titulo_figura(fig, f"Distribución de las variables categóricas  ·  en gris: categorías con < {UMBRAL_RARA} %")
fig.tight_layout()
fig.savefig(FIG_DIR / "01_barras_categoricas.png")
plt.show()

clases = df[TARGET].value_counts().sort_index().to_frame("frecuencia")
clases["porcentaje"] = clases["frecuencia"] / len(df) * 100
clases.index = [f"{k} · {CLASE_NOMBRE[k]}" for k in clases.index]
display(clases.style.format({"porcentaje": "{:.2f} %"}))
print(f"Razón de clases (1 : 0) = {clases['frecuencia'].iloc[1] / clases['frecuencia'].iloc[0]:.2f} : 1")

fig, ax = plt.subplots(figsize=(7, 4.5))
barras = ax.bar(clases.index, clases["frecuencia"], color=[CLASE_COLOR[0], CLASE_COLOR[1]], width=0.55)
for barra, f, p in zip(barras, clases["frecuencia"], clases["porcentaje"]):
    ax.text(barra.get_x() + barra.get_width() / 2, f, f"{f:,}\n({p:.1f} %)",
            ha="center", va="bottom", fontsize=10, color=COLOR["texto"])
ax.set_ylabel("Pacientes")
ax.set_ylim(0, clases["frecuencia"].max() * 1.2)
ax.grid(axis="x", visible=False)
ax.set_title("Distribución de la variable objetivo HeartDisease")
fig.tight_layout()
fig.savefig(FIG_DIR / "01_variable_objetivo.png")
plt.show()

fig, axes = plt.subplots(2, len(NUM_VARS), figsize=(18, 8))
for j, col in enumerate(NUM_VARS):
    datos = df_eda[[col, TARGET]].dropna()

    # Fila 1: boxplots
    ax = axes[0, j]
    cajas = ax.boxplot([datos.loc[datos[TARGET] == k, col] for k in (0, 1)], widths=0.55, patch_artist=True,
                       medianprops=dict(color="white", linewidth=2),
                       whiskerprops=dict(color=COLOR["texto_2"]), capprops=dict(color=COLOR["texto_2"]),
                       flierprops=dict(marker="o", markersize=3, markerfacecolor=COLOR["tenue"],
                                       markeredgecolor="none", alpha=0.5))
    for caja, k in zip(cajas["boxes"], (0, 1)):
        caja.set(facecolor=CLASE_COLOR[k], edgecolor=COLOR["texto_2"])
    ax.set_xticks([1, 2], [CLASE_NOMBRE[0], CLASE_NOMBRE[1]])
    ax.set_title(col)
    ax.grid(axis="x", visible=False)

    # Fila 2: violines
    ax = axes[1, j]
    partes = ax.violinplot([datos.loc[datos[TARGET] == k, col] for k in (0, 1)], showmedians=True, widths=0.8)
    for cuerpo, k in zip(partes["bodies"], (0, 1)):
        cuerpo.set(facecolor=CLASE_COLOR[k], edgecolor=COLOR["texto_2"], alpha=0.6)
    for clave in ("cbars", "cmins", "cmaxes", "cmedians"):
        partes[clave].set(color=COLOR["texto_2"], linewidth=1)
    ax.set_xticks([1, 2], [CLASE_NOMBRE[0], CLASE_NOMBRE[1]])
    ax.set_title(col)
    ax.grid(axis="x", visible=False)

titulo_figura(fig, "Variables numéricas por clase de HeartDisease (arriba: boxplots, abajo: violin plots)")
fig.tight_layout()
fig.savefig(FIG_DIR / "01_boxplots_violines_por_clase.png")
plt.show()

def magnitud(r):
    r = abs(r)
    return "Despreciable" if r < 0.1 else "Pequeño" if r < 0.3 else "Mediano" if r < 0.5 else "Grande"

filas = []
for col in NUM_VARS:
    datos = df_eda[[col, TARGET]].dropna()
    x0 = datos.loc[datos[TARGET] == 0, col]
    x1 = datos.loc[datos[TARGET] == 1, col]
    t_stat, p_t = stats.ttest_ind(x1, x0, equal_var=False)
    u_stat, p_u = stats.mannwhitneyu(x1, x0, alternative="two-sided")
    r_pb, _ = stats.pointbiserialr(datos[TARGET], datos[col])
    r_rb = 2 * u_stat / (len(x0) * len(x1)) - 1
    filas.append({
        "variable": col, "n_0": len(x0), "n_1": len(x1),
        "media_0": x0.mean(), "media_1": x1.mean(), "dif_medias": x1.mean() - x0.mean(),
        "mediana_0": x0.median(), "mediana_1": x1.median(),
        "t_Welch": t_stat, "p_t": p_t, "p_MannWhitney": p_u,
        "r_rank_biserial": r_rb, "r_punto_biserial": r_pb,
        "efecto": magnitud(r_rb),
        "significativa (p<0.05)": "Sí" if p_u < 0.05 else "No",
    })

pruebas_num = pd.DataFrame(filas).set_index("variable").sort_values("r_punto_biserial", key=abs, ascending=False)
display(pruebas_num.style.format({
    "media_0": "{:.2f}", "media_1": "{:.2f}", "dif_medias": "{:+.2f}", "mediana_0": "{:.2f}", "mediana_1": "{:.2f}",
    "t_Welch": "{:.2f}", "p_t": "{:.2e}", "p_MannWhitney": "{:.2e}",
    "r_rank_biserial": "{:+.3f}", "r_punto_biserial": "{:+.3f}"}))

fig, axes = plt.subplots(1, len(NUM_VARS), figsize=(18, 3.8))
for ax, col in zip(axes, pruebas_num.index):
    datos = df_eda[[col, TARGET]].dropna()
    for k in (0, 1):
        sns.kdeplot(datos.loc[datos[TARGET] == k, col], ax=ax, color=CLASE_COLOR[k],
                    fill=True, alpha=0.25, linewidth=2, label=CLASE_NOMBRE[k])
    ax.set_title(f"{col}  ·  r_pb = {pruebas_num.loc[col, 'r_punto_biserial']:+.3f}")
    ax.set_ylabel("Densidad" if ax is axes[0] else "")
    ax.grid(axis="x", visible=False)
axes[0].legend(loc="upper left")
titulo_figura(fig, "Densidad (KDE) por clase de HeartDisease")
fig.tight_layout()
fig.savefig(FIG_DIR / "01_kde_por_clase.png")
plt.show()

ALFA = 0.05

def cramer_v(tabla):
    chi2 = stats.chi2_contingency(tabla, correction=False)[0]
    n = tabla.values.sum()
    k = min(tabla.shape) - 1
    return np.sqrt(chi2 / (n * k)) if k > 0 else np.nan

def magnitud_v(v):
    return "Despreciable" if v < 0.1 else "Pequeña" if v < 0.3 else "Moderada" if v < 0.5 else "Grande"

TASA_GLOBAL = df[TARGET].mean() * 100
tablas_cat, filas = {}, []
for col in CAT_VARS:
    conteos = pd.crosstab(df[col].astype(str), df[TARGET])
    conteos.columns = ["n_sin_enfermedad", "n_con_enfermedad"]
    tabla = conteos.assign(n_total=conteos.sum(axis=1))
    tabla["tasa_enfermedad"] = tabla["n_con_enfermedad"] / tabla["n_total"] * 100
    tabla["dif_vs_global"] = tabla["tasa_enfermedad"] - TASA_GLOBAL

    chi2, p, gl, esperadas = stats.chi2_contingency(conteos)
    n = conteos.values.sum()
    prop_fila = conteos.sum(axis=1).values[:, None] / n
    prop_col = conteos.sum(axis=0).values[None, :] / n
    residuos = (conteos.values - esperadas) / np.sqrt(esperadas * (1 - prop_fila) * (1 - prop_col))
    tabla["residuo_ajustado"] = residuos[:, 1]
    critico = stats.norm.ppf(1 - ALFA / (2 * len(conteos)))     # corrección de Bonferroni
    tabla["significativa_posthoc"] = np.where(np.abs(tabla["residuo_ajustado"]) > critico, "Sí", "No")
    tablas_cat[col] = tabla

    v = cramer_v(conteos)
    filas.append({"variable": col, "n_categorias": len(conteos), "chi2": chi2, "gl": gl, "p_value": p,
                  "V_Cramer": v, "magnitud": magnitud_v(v),
                  "pct_esperadas_<5": (esperadas < 5).mean() * 100,
                  "significativa (p<0.05)": "Sí" if p < ALFA else "No"})

pruebas_cat = pd.DataFrame(filas).set_index("variable").sort_values("V_Cramer", ascending=False)
display(pruebas_cat.style.format({"chi2": "{:.1f}", "p_value": "{:.2e}", "V_Cramer": "{:.3f}",
                                  "pct_esperadas_<5": "{:.0f} %"}))

for col in pruebas_cat.index:
    print(f"\n{col}  ·  χ² = {pruebas_cat.loc[col, 'chi2']:.1f}  ·  {fmt_p(pruebas_cat.loc[col, 'p_value'])}"
          f"  ·  V = {pruebas_cat.loc[col, 'V_Cramer']:.3f}")
    display(tablas_cat[col].style.format({"tasa_enfermedad": "{:.1f} %", "dif_vs_global": "{:+.1f}",
                                          "residuo_ajustado": "{:+.2f}"}))

for col in pruebas_cat.index:
    tabla = tablas_cat[col]
    tabla = tabla.loc[[c for c in ORDEN[col] if c in tabla.index]] if col in ORDEN else tabla.sort_values("tasa_enfermedad")
    n = len(tabla)

    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(13, 0.55 * n + 1.8), sharey=True)
    ax1.barh(tabla.index, tabla["n_sin_enfermedad"], color=CLASE_COLOR[0], height=0.7, label=CLASE_NOMBRE[0])
    ax1.barh(tabla.index, tabla["n_con_enfermedad"], left=tabla["n_sin_enfermedad"], color=CLASE_COLOR[1],
             height=0.7, label=CLASE_NOMBRE[1])
    ax1.set_xlabel("Pacientes")
    ax1.set_title("Frecuencia por clase (barras apiladas)")
    ax1.legend(loc="upper center", bbox_to_anchor=(0.5, -0.22), ncol=2)

    ax2.barh(tabla.index, tabla["tasa_enfermedad"], height=0.7,
             color=np.where(tabla["tasa_enfermedad"] > TASA_GLOBAL, COLOR["secundario"], COLOR["tenue"]))
    ax2.axvline(TASA_GLOBAL, color=COLOR["texto"], linestyle="--", linewidth=1, label=f"Tasa global {TASA_GLOBAL:.1f} %")
    ax2.legend(loc="upper center", bbox_to_anchor=(0.5, -0.22))
    for i, v in enumerate(tabla["tasa_enfermedad"]):
        ax2.text(v, i, f"  {v:.1f} %", va="center", fontsize=8.5, color=COLOR["texto_2"])
    ax2.xaxis.set_major_formatter(mtick.PercentFormatter())
    ax2.set_xlim(0, 105)
    ax2.set_xlabel("Tasa de enfermedad cardíaca")
    ax2.set_title("Tasa por categoría  ·  naranja: sobre la tasa global")

    for ax in (ax1, ax2):
        ax.grid(axis="y", visible=False)

    fila = pruebas_cat.loc[col]
    titulo_figura(fig, f"{col}  ·  χ² = {fila['chi2']:.1f}  ·  {fmt_p(fila['p_value'])}  ·  V de Cramér = {fila['V_Cramer']:.3f}")
    fig.tight_layout()
    fig.savefig(FIG_DIR / f"01_tasa_por_{col}.png")
    plt.show()

cols_corr = NUM_VARS + [TARGET]
fig, axes = plt.subplots(1, 2, figsize=(14, 6))
for ax, metodo in zip(axes, ["pearson", "spearman"]):
    corr = df_eda[cols_corr].corr(method=metodo)
    sns.heatmap(corr, mask=np.triu(np.ones_like(corr, dtype=bool), k=1), cmap=CMAP_DIV, vmin=-1, vmax=1,
                annot=True, fmt=".2f", annot_kws={"size": 9}, linewidths=1.5, linecolor="white", square=True,
                cbar_kws={"shrink": 0.7, "label": f"r de {metodo.capitalize()}"}, ax=ax)
    ax.grid(False)
    ax.set_title(f"Correlación de {metodo.capitalize()}")
titulo_figura(fig, "Correlación entre variables numéricas y HeartDisease")
fig.tight_layout()
fig.savefig(FIG_DIR / "01_heatmap_correlacion.png")
plt.show()

corr_p = df_eda[NUM_VARS].corr()
pares = (corr_p.where(np.triu(np.ones_like(corr_p, dtype=bool), k=1)).stack()
         .rename("r_pearson").to_frame().sort_values("r_pearson", key=abs, ascending=False))
print(f"Pares con |r| > 0.7: {(pares['r_pearson'].abs() > 0.7).sum()}")
display(pares.head(5).style.format("{:+.3f}"))

vars_cat_pares = CAT_VARS + [TARGET]
matriz_v = pd.DataFrame(np.eye(len(vars_cat_pares)), index=vars_cat_pares, columns=vars_cat_pares)
filas = []
for i, a in enumerate(vars_cat_pares):
    for b in vars_cat_pares[i + 1:]:
        tabla = pd.crosstab(df[a], df[b])
        chi2, p, _, _ = stats.chi2_contingency(tabla)
        v = cramer_v(tabla)
        matriz_v.loc[a, b] = matriz_v.loc[b, a] = v
        filas.append({"variable_1": a, "variable_2": b, "chi2": chi2, "p_value": p, "V_Cramer": v})

pares_cat = pd.DataFrame(filas).sort_values("V_Cramer", ascending=False)
display(pares_cat.head(8).style.format({"chi2": "{:.1f}", "p_value": "{:.2e}", "V_Cramer": "{:.3f}"}).hide(axis="index"))

fig, ax = plt.subplots(figsize=(8, 6.5))
sns.heatmap(matriz_v, mask=np.triu(np.ones_like(matriz_v, dtype=bool), k=1), cmap=CMAP_SEC, vmin=0, vmax=1,
            annot=True, fmt=".2f", annot_kws={"size": 9}, linewidths=1.5, linecolor="white", square=True,
            cbar_kws={"shrink": 0.7, "label": "V de Cramér"}, ax=ax)
ax.grid(False)
ax.set_title("Asociación entre variables categóricas (V de Cramér)")
fig.tight_layout()
fig.savefig(FIG_DIR / "01_heatmap_cramer.png")
plt.show()

def razon_eta(categorias, valores):
    datos = pd.DataFrame({"c": categorias, "v": valores}).dropna()
    media = datos["v"].mean()
    ss_entre = datos.groupby("c")["v"].apply(lambda g: len(g) * (g.mean() - media) ** 2).sum()
    ss_total = ((datos["v"] - media) ** 2).sum()
    return np.sqrt(ss_entre / ss_total)

matriz_eta = pd.DataFrame({num: {cat: razon_eta(df_eda[cat], df_eda[num]) for cat in CAT_VARS} for num in NUM_VARS})

fig, ax = plt.subplots(figsize=(8, 5))
sns.heatmap(matriz_eta, cmap=CMAP_SEC, vmin=0, vmax=1, annot=True, fmt=".2f", annot_kws={"size": 9},
            linewidths=1.5, linecolor="white", cbar_kws={"shrink": 0.8, "label": "η"}, ax=ax)
ax.grid(False)
ax.set_title("Razón de correlación η (categórica → numérica)")
fig.tight_layout()
fig.savefig(FIG_DIR / "01_heatmap_eta.png")
plt.show()

datos_pair = df_eda[NUM_VARS + [TARGET]].copy()
datos_pair["clase"] = datos_pair[TARGET].map(CLASE_NOMBRE)
datos_pair = datos_pair.sort_values(TARGET)

g = sns.pairplot(datos_pair.drop(columns=TARGET), hue="clase", corner=True,
                 palette={CLASE_NOMBRE[k]: CLASE_COLOR[k] for k in (0, 1)},
                 plot_kws=dict(s=12, alpha=0.5, linewidth=0),
                 diag_kws=dict(common_norm=False, fill=True, alpha=0.3), height=2.3)
g._legend.set_title("")
for ax in g.axes.flat:
    if ax is not None:
        ax.grid(True, color=COLOR["rejilla"], linewidth=0.5)
g.fig.suptitle(f"Pairplot de las variables numéricas por clase ({len(datos_pair):,} pacientes)",
               x=0.01, ha="left", y=1.01, fontsize=13, fontweight="semibold")
g.savefig(FIG_DIR / "01_pairplot.png")
plt.show()

falta_col = df["Cholesterol"].eq(0).map({True: "Falta", False: "Presente"})

# 1) Relación con la variable objetivo
conteos = pd.crosstab(falta_col, df[TARGET])
conteos.columns = ["n_sin_enfermedad", "n_con_enfermedad"]
conteos["n_total"] = conteos.sum(axis=1)
conteos["tasa_enfermedad"] = conteos["n_con_enfermedad"] / conteos["n_total"] * 100
chi2, p, _, _ = stats.chi2_contingency(pd.crosstab(falta_col, df[TARGET]))
print(f"Cholesterol faltante vs HeartDisease: χ² = {chi2:.1f}, {fmt_p(p)}, "
      f"V = {cramer_v(pd.crosstab(falta_col, df[TARGET])):.3f}")
display(conteos.style.format({"tasa_enfermedad": "{:.1f} %"}))

# 2) Relación con las demás variables
filas = []
for col in [c for c in NUM_VARS if c != "Cholesterol"]:
    a, b = df_eda.loc[falta_col == "Falta", col].dropna(), df_eda.loc[falta_col == "Presente", col].dropna()
    filas.append({"variable": col, "tipo": "numérica", "falta": f"mediana {a.median():.1f}",
                  "presente": f"mediana {b.median():.1f}", "prueba": "Mann-Whitney",
                  "p_value": stats.mannwhitneyu(a, b).pvalue})
for col in CAT_VARS:
    tabla = pd.crosstab(falta_col, df[col])
    moda_f, moda_p = tabla.loc["Falta"].idxmax(), tabla.loc["Presente"].idxmax()
    filas.append({"variable": col, "tipo": "categórica",
                  "falta": f"{moda_f} ({tabla.loc['Falta', moda_f] / tabla.loc['Falta'].sum():.0%})",
                  "presente": f"{moda_p} ({tabla.loc['Presente', moda_p] / tabla.loc['Presente'].sum():.0%})",
                  "prueba": "χ²", "p_value": stats.chi2_contingency(tabla)[1]})
mcar = pd.DataFrame(filas).set_index("variable")
mcar["¿rechaza MCAR? (p<0.05)"] = np.where(mcar["p_value"] < 0.05, "Sí", "No")
display(mcar.style.format({"p_value": "{:.2e}"}))

fig, ax = plt.subplots(figsize=(7, 3))
ax.barh(conteos.index, conteos["tasa_enfermedad"], color=[COLOR["secundario"], COLOR["principal"]], height=0.55)
ax.axvline(TASA_GLOBAL, color=COLOR["texto"], linestyle="--", linewidth=1)
for i, (v, n) in enumerate(zip(conteos["tasa_enfermedad"], conteos["n_total"])):
    ax.text(v, i, f"  {v:.1f} %  (n = {n})", va="center", fontsize=9)
ax.xaxis.set_major_formatter(mtick.PercentFormatter())
ax.set_xlim(0, 115)
ax.grid(axis="y", visible=False)
ax.set_title("Tasa de enfermedad cardíaca según si falta el colesterol")
fig.tight_layout()
fig.savefig(FIG_DIR / "01_mcar_cholesterol.png")
plt.show()

import os
# joblib no puede contar los núcleos físicos en este Windows y lanza un aviso; se le indica cuántos usar
os.environ["LOKY_MAX_CPU_COUNT"] = str(max(1, (os.cpu_count() or 2) // 2))

import sklearn
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import MinMaxScaler, OneHotEncoder
from sklearn.pipeline import Pipeline
from sklearn.model_selection import train_test_split, GridSearchCV, StratifiedKFold, cross_val_score
from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.metrics import (roc_auc_score, accuracy_score, precision_score, recall_score,
                             f1_score, roc_curve)
from sklearn.svm import SVC
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.naive_bayes import GaussianNB

print(f"scikit-learn {sklearn.__version__}")

X = df.drop(columns=TARGET).copy()
y = df[TARGET].copy()
X[CEROS_IMPOSIBLES] = X[CEROS_IMPOSIBLES].replace(0, np.nan)

print(f"X: {X.shape[0]} filas x {X.shape[1]} columnas | y: {y.shape[0]} valores")
print("Nulos en X después de marcar los ceros imposibles:")
display(X.isna().sum()[lambda s: s > 0].to_frame("n_nulos"))

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

particion = pd.DataFrame({
    "n": [len(y), len(y_train), len(y_test)],
    "pct_con_enfermedad": [y.mean() * 100, y_train.mean() * 100, y_test.mean() * 100],
    "nulos_cholesterol": [X["Cholesterol"].isna().sum(), X_train["Cholesterol"].isna().sum(),
                          X_test["Cholesterol"].isna().sum()],
}, index=["completo", "train", "test"])
display(particion.style.format({"pct_con_enfermedad": "{:.2f} %"}))

# Validación cruzada estratificada y reproducible para todas las búsquedas
CV = StratifiedKFold(n_splits=5, shuffle=True, random_state=SEED)

COLS_ESCALAR = ["Age", "MaxHR", "Oldpeak"]
COLS_IMPUTAR = ["RestingBP", "Cholesterol"]
COLS_ONEHOT = ["Sex", "ChestPainType", "RestingECG", "ExerciseAngina", "ST_Slope"]
COLS_BINARIAS = ["FastingBS"]


def crear_preprocesador(extra_num=()):
    """Imputa, escala y codifica. Todos los parámetros se aprenden solo con los datos que recibe en fit."""
    return ColumnTransformer([
        ("num", MinMaxScaler(), COLS_ESCALAR + list(extra_num)),
        ("num_nulos", Pipeline([("imputar", SimpleImputer(strategy="median", add_indicator=True)),
                                ("escalar", MinMaxScaler())]), COLS_IMPUTAR),
        ("cat", OneHotEncoder(handle_unknown="ignore", sparse_output=False), COLS_ONEHOT),
        ("bin", "passthrough", COLS_BINARIAS),
    ], verbose_feature_names_out=False)


prep = crear_preprocesador().fit(X_train)            # se ajusta SOLO con train
X_train_t = pd.DataFrame(prep.transform(X_train), columns=prep.get_feature_names_out(), index=X_train.index)

print(f"Columnas antes: {X_train.shape[1]} -> después del preprocesamiento: {X_train_t.shape[1]}")
print(list(X_train_t.columns))
display(X_train_t.head())

# Los parámetros aprendidos vienen solo de train (comparación con los del dataset completo)
aprendido = pd.DataFrame({
    "mediana_train (usada)": prep.named_transformers_["num_nulos"]["imputar"].statistics_,
    "mediana_dataset_completo": X[COLS_IMPUTAR].median().values,
}, index=COLS_IMPUTAR)
display(aprendido)

X_fuga = X.copy()
np.random.seed(0)
X_fuga["leaky_feature"] = y + np.random.normal(0, 0.01, size=len(y))

# --- Ejemplo con fuga de datos: el preprocesamiento ve el dataset completo antes del split ---
X_fuga_enc = pd.get_dummies(X_fuga, columns=COLS_ONEHOT, dtype=float)
X_fuga_enc = X_fuga_enc.fillna(X_fuga_enc.median())             # mediana calculada con train + test
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X_fuga_enc)                     # mínimo y máximo calculados con train + test
X_train_l, X_test_l, y_train_l, y_test_l = train_test_split(X_scaled, y, test_size=0.2, stratify=y,
                                                            random_state=SEED)
grid_l = GridSearchCV(SVC(probability=True, random_state=SEED),
                      param_grid={"C": [0.1, 1, 10], "gamma": [0.01, 0.1]}, cv=5, scoring="roc_auc")
grid_l.fit(X_train_l, y_train_l)
auc_l = roc_auc_score(y_test_l, grid_l.predict_proba(X_test_l)[:, 1])

# --- Flujo correcto: split primero, preprocesamiento dentro del Pipeline ---
X_train_f, X_test_f, y_train_f, y_test_f = train_test_split(X_fuga, y, test_size=0.2, stratify=y,
                                                            random_state=SEED)
pipe = Pipeline([("prep", crear_preprocesador(extra_num=["leaky_feature"])),
                 ("svc", SVC(probability=True, random_state=SEED))])
param_grid = {"svc__C": [0.1, 1, 10], "svc__gamma": [0.01, 0.1]}
grid = GridSearchCV(pipe, param_grid, cv=5, scoring="roc_auc")
grid.fit(X_train_f, y_train_f)
auc = roc_auc_score(y_test_f, grid.predict_proba(X_test_f)[:, 1])

print(f"AUC con fuga: {auc_l:.3f}")
print(f"AUC sin fuga: {auc:.3f}")

def escenario_fuga(X_base, preprocesar_antes_del_split):
    """Entrena un SVC con GridSearchCV y devuelve el AUC de validación cruzada y el de test."""
    extra = ["leaky_feature"] if "leaky_feature" in X_base.columns else []
    grilla = {"C": [0.1, 1, 10], "gamma": [0.01, 0.1]}
    if preprocesar_antes_del_split:
        X_base = crear_preprocesador(extra).fit_transform(X_base)       # ajuste con train + test
        modelo, grilla = SVC(probability=True, random_state=SEED), grilla
    else:
        modelo = Pipeline([("prep", crear_preprocesador(extra)), ("svc", SVC(probability=True, random_state=SEED))])
        grilla = {f"svc__{k}": v for k, v in grilla.items()}
    Xtr, Xte, ytr, yte = train_test_split(X_base, y, test_size=0.2, stratify=y, random_state=SEED)
    g = GridSearchCV(modelo, grilla, cv=CV, scoring="roc_auc").fit(Xtr, ytr)
    return g.best_score_, roc_auc_score(yte, g.predict_proba(Xte)[:, 1])


filas = []
for nombre_x, X_base in [("Sin leaky_feature", X), ("Con leaky_feature", X_fuga)]:
    for antes in (True, False):
        auc_cv, auc_test = escenario_fuga(X_base, antes)
        filas.append({"variables": nombre_x,
                      "preprocesamiento": "Antes del split (con fuga)" if antes else "Dentro del Pipeline (sin fuga)",
                      "AUC_CV": auc_cv, "AUC_test": auc_test})

tabla_fuga = pd.DataFrame(filas).set_index(["variables", "preprocesamiento"])
display(tabla_fuga.style.format("{:.4f}"))

filas = []
for semilla in range(50):
    Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.2, stratify=y, random_state=semilla)

    # Con fuga: el preprocesador se ajusta con train + test
    prep_fuga = crear_preprocesador().fit(X)
    lr = LogisticRegression(max_iter=2000).fit(prep_fuga.transform(Xtr), ytr)
    auc_fuga = roc_auc_score(yte, lr.predict_proba(prep_fuga.transform(Xte))[:, 1])

    # Sin fuga: el preprocesador se ajusta solo con train (Pipeline)
    pipe_ok = Pipeline([("prep", crear_preprocesador()), ("clf", LogisticRegression(max_iter=2000))]).fit(Xtr, ytr)
    auc_ok = roc_auc_score(yte, pipe_ok.predict_proba(Xte)[:, 1])
    filas.append({"semilla": semilla, "AUC_con_fuga": auc_fuga, "AUC_sin_fuga": auc_ok})

repeticiones = pd.DataFrame(filas)
repeticiones["diferencia"] = repeticiones["AUC_con_fuga"] - repeticiones["AUC_sin_fuga"]
display(repeticiones[["AUC_con_fuga", "AUC_sin_fuga", "diferencia"]].describe().T
        .style.format("{:.5f}"))
w_stat, p_w = stats.wilcoxon(repeticiones["AUC_con_fuga"], repeticiones["AUC_sin_fuga"])
print(f"Wilcoxon pareado: {fmt_p(p_w)}")
print(f"Repeticiones donde la fuga da mayor AUC: {(repeticiones['diferencia'] > 0).sum()} de 50")

rng = np.random.default_rng(SEED)
X_ruido = rng.normal(size=(len(y), 5000))

# Con fuga: SelectKBest ve todas las filas (incluidas las que después serán de validación)
seleccion = SelectKBest(f_classif, k=20).fit(X_ruido, y)
auc_sel_fuga = cross_val_score(LogisticRegression(max_iter=2000), seleccion.transform(X_ruido), y,
                               cv=CV, scoring="roc_auc")

# Sin fuga: la selección se repite dentro de cada fold
pipe_sel = Pipeline([("seleccion", SelectKBest(f_classif, k=20)), ("clf", LogisticRegression(max_iter=2000))])
auc_sel_ok = cross_val_score(pipe_sel, X_ruido, y, cv=CV, scoring="roc_auc")

print(f"AUC CV con fuga (selección antes de la CV) : {auc_sel_fuga.mean():.3f} ± {auc_sel_fuga.std():.3f}")
print(f"AUC CV sin fuga (selección en el Pipeline) : {auc_sel_ok.mean():.3f} ± {auc_sel_ok.std():.3f}")

resumen_fuga = pd.DataFrame({
    "experimento": ["Ejemplo del profesor\n(leaky_feature)", "Ejemplo del profesor\n(leaky_feature)",
                    "Preprocesamiento\n(50 repeticiones)", "Preprocesamiento\n(50 repeticiones)",
                    "Selección de variables\n(5,000 de ruido)", "Selección de variables\n(5,000 de ruido)"],
    "flujo": ["Con fuga", "Sin fuga"] * 3,
    "AUC": [auc_l, auc, repeticiones["AUC_con_fuga"].mean(), repeticiones["AUC_sin_fuga"].mean(),
            auc_sel_fuga.mean(), auc_sel_ok.mean()],
})

fig, ax = plt.subplots(figsize=(10, 4.8))
posiciones = np.arange(3)
for i, (flujo, color) in enumerate([("Con fuga", COLOR["secundario"]), ("Sin fuga", COLOR["principal"])]):
    valores = resumen_fuga.loc[resumen_fuga["flujo"] == flujo, "AUC"].values
    barras = ax.bar(posiciones + (i - 0.5) * 0.36, valores, width=0.36, color=color, label=flujo)
    for barra, v in zip(barras, valores):
        ax.text(barra.get_x() + barra.get_width() / 2, v, f"{v:.3f}", ha="center", va="bottom", fontsize=9)
ax.axhline(0.5, color=COLOR["texto_2"], linestyle=":", linewidth=1.2, label="Azar (AUC = 0.5)")
ax.set_xticks(posiciones, resumen_fuga["experimento"].unique())
ax.set_ylim(0, 1.12)
ax.set_ylabel("AUC")
ax.grid(axis="x", visible=False)
ax.legend(loc="upper center", bbox_to_anchor=(0.5, -0.18), ncol=3)
ax.set_title("AUC con y sin fuga de datos en los tres experimentos")
fig.tight_layout()
fig.savefig(FIG_DIR / "01_resumen_fuga.png")
plt.show()

def construir_pipeline(modelo):
    """Preprocesador (Parte 29) + clasificador en un solo objeto."""
    return Pipeline([("prep", crear_preprocesador()), ("clf", modelo)])


def train_pipeline(X_train, y_train, model, param_grid, cv=CV, scoring="roc_auc"):
    """Busca los mejores hiperparámetros con validación cruzada. El preprocesamiento se reajusta en cada fold."""
    grid = GridSearchCV(construir_pipeline(model), param_grid, cv=cv, scoring=scoring,
                        n_jobs=-1, return_train_score=True)
    grid.fit(X_train, y_train)
    return grid


def evaluar_modelo(grid, X_test, y_test):
    """Métricas en test y resumen de la validación cruzada del mejor modelo."""
    proba = grid.predict_proba(X_test)[:, 1]
    pred = (proba >= 0.5).astype(int)
    i = grid.best_index_
    folds = [grid.cv_results_[f"split{k}_test_score"][i] for k in range(grid.n_splits_)]
    return {
        "AUC_test": roc_auc_score(y_test, proba),
        "Accuracy_test": accuracy_score(y_test, pred),
        "Precision_test": precision_score(y_test, pred),
        "Recall_test": recall_score(y_test, pred),
        "Especificidad_test": recall_score(y_test, pred, pos_label=0),
        "F1_test": f1_score(y_test, pred),
        "AUC_CV_media": grid.cv_results_["mean_test_score"][i],
        "AUC_CV_std": grid.cv_results_["std_test_score"][i],
        "AUC_train_CV": grid.cv_results_["mean_train_score"][i],
        "AUC_folds": folds,
        "mejores_parametros": {k.replace("clf__", ""): v for k, v in grid.best_params_.items()},
        "proba_test": proba,
    }


def comparar_modelos(modelos, X_train, y_train, X_test, y_test):
    """Entrena y evalúa cada modelo. Devuelve los GridSearchCV ajustados y el ranking por AUC de test."""
    ajustados, filas = {}, []
    for nombre, (modelo, grilla) in modelos.items():
        t0 = time.time()
        grid = train_pipeline(X_train, y_train, modelo, grilla)
        segundos = time.time() - t0
        resultado = evaluar_modelo(grid, X_test, y_test)
        ajustados[nombre] = grid
        n_comb = len(grid.cv_results_["params"])
        filas.append({"modelo": nombre, **resultado, "combinaciones": n_comb, "tiempo_s": segundos})
        print(f"{nombre:20s} {n_comb:4d} combinaciones x {grid.n_splits_} folds  ·  {segundos:6.1f} s  ·  "
              f"AUC CV = {resultado['AUC_CV_media']:.4f}  ·  AUC test = {resultado['AUC_test']:.4f}")
    ranking = (pd.DataFrame(filas).set_index("modelo")
               .sort_values(["AUC_test", "AUC_CV_media"], ascending=False))
    ranking.insert(0, "puesto", range(1, len(ranking) + 1))
    return ajustados, ranking

MODELOS = {
    "SVC": (SVC(probability=True, random_state=SEED),
            {"clf__C": [0.1, 1, 10, 100], "clf__gamma": ["scale", 0.01, 0.1], "clf__kernel": ["rbf"]}),
    "LogisticRegression": (LogisticRegression(max_iter=5000, solver="liblinear", random_state=SEED),
                           {"clf__C": [0.01, 0.1, 1, 10], "clf__penalty": ["l1", "l2"]}),
    "KNN": (KNeighborsClassifier(),
            {"clf__n_neighbors": [5, 11, 21, 31, 51, 71, 101], "clf__weights": ["uniform", "distance"], "clf__p": [1, 2]}),
    "DecisionTree": (DecisionTreeClassifier(random_state=SEED),
                     {"clf__max_depth": [3, 4, 5, 7, None], "clf__min_samples_leaf": [1, 5, 10, 20],
                      "clf__criterion": ["gini", "entropy"]}),
    "RandomForest": (RandomForestClassifier(random_state=SEED, n_jobs=1),
                     {"clf__n_estimators": [300], "clf__max_depth": [None, 5, 10],
                      "clf__min_samples_leaf": [1, 3, 5], "clf__max_features": ["sqrt", 0.5]}),
    "GradientBoosting": (GradientBoostingClassifier(random_state=SEED),
                         {"clf__n_estimators": [100, 300], "clf__learning_rate": [0.01, 0.03, 0.1],
                          "clf__max_depth": [2, 3], "clf__subsample": [0.8, 1.0]}),
    "GaussianNB": (GaussianNB(), {"clf__var_smoothing": [1e-9, 1e-7, 1e-5, 1e-3]}),
}

pd.DataFrame([{"modelo": n, "hiperparámetros": ", ".join(k.replace("clf__", "") for k in g),
               "combinaciones": int(np.prod([len(v) for v in g.values()]))} for n, (_, g) in MODELOS.items()]
            ).set_index("modelo")

t_total = time.time()
grids, ranking = comparar_modelos(MODELOS, X_train, y_train, X_test, y_test)
print(f"\nTiempo total: {time.time() - t_total:.1f} s")

ranking["brecha_train_CV"] = ranking["AUC_train_CV"] - ranking["AUC_CV_media"]
ranking["puesto_accuracy"] = ranking["Accuracy_test"].rank(ascending=False, method="min").astype(int)

cols_ranking = ["puesto", "AUC_test", "Accuracy_test", "puesto_accuracy", "AUC_CV_media", "AUC_CV_std",
                "brecha_train_CV", "Precision_test", "Recall_test", "Especificidad_test", "F1_test", "tiempo_s"]
display(ranking[cols_ranking].style
        .format({c: "{:.4f}" for c in cols_ranking if c not in ("puesto", "puesto_accuracy", "tiempo_s")}
                | {"tiempo_s": "{:.1f}"})
        .background_gradient(subset=["AUC_test", "Accuracy_test"], cmap=CMAP_SEC))

print("Mejores hiperparámetros:")
for nombre, fila in ranking.iterrows():
    print(f"  {fila['puesto']}. {nombre:20s} {fila['mejores_parametros']}")

# Comparación directa con el SVC del enunciado
svc_auc = ranking.loc["SVC", "AUC_test"]
print("\nDiferencia de AUC de test frente al SVC:")
display((ranking["AUC_test"] - svc_auc).rename("dif_vs_SVC").to_frame().style.format("{:+.4f}"))

orden = ranking.index[::-1]
mejor = ranking.index[0]
colores = [COLOR["secundario"] if m == mejor else COLOR["principal"] for m in orden]

fig, axes = plt.subplots(1, 3, figsize=(17, 5), gridspec_kw={"width_ratios": [1, 1, 1.2]})

# Panel 1: AUC de test y AUC de CV (media ± desviación)
ax = axes[0]
ax.barh(orden, ranking.loc[orden, "AUC_test"], color=colores, height=0.6, label="AUC test")
ax.errorbar(ranking.loc[orden, "AUC_CV_media"], np.arange(len(orden)), xerr=ranking.loc[orden, "AUC_CV_std"],
            fmt="o", color=COLOR["texto"], markersize=4, capsize=3, label="AUC CV (media ± std)")
for i, v in enumerate(ranking.loc[orden, "AUC_test"]):
    ax.text(0.705, i, f"{v:.3f}", va="center", fontsize=8.5, color="white")
ax.set_xlim(0.7, 1)
ax.set_title("AUC")
ax.legend(loc="upper center", bbox_to_anchor=(0.5, -0.1), ncol=2)

# Panel 2: Accuracy de test
ax = axes[1]
ax.barh(orden, ranking.loc[orden, "Accuracy_test"], color=colores, height=0.6)
ax.axvline(y_test.mean(), color=COLOR["texto_2"], linestyle=":", linewidth=1.2)
ax.text(y_test.mean(), len(orden) - 0.45, " Modelo trivial", fontsize=8.5, color=COLOR["texto_2"])
for i, v in enumerate(ranking.loc[orden, "Accuracy_test"]):
    ax.text(0.505, i, f"{v:.3f}", va="center", fontsize=8.5, color="white")
ax.set_xlim(0.5, 1)
ax.set_yticklabels([])
ax.set_title("Accuracy (test)")

# Panel 3: AUC de cada fold de la validación cruzada
ax = axes[2]
datos_folds = [ranking.loc[m, "AUC_folds"] for m in orden]
cajas = ax.boxplot(datos_folds, vert=False, widths=0.55, patch_artist=True, showfliers=False,
                   medianprops=dict(color="white", linewidth=2),
                   whiskerprops=dict(color=COLOR["texto_2"]), capprops=dict(color=COLOR["texto_2"]))
for caja, c in zip(cajas["boxes"], colores):
    caja.set(facecolor=c, edgecolor=COLOR["texto_2"])
for i, valores in enumerate(datos_folds, start=1):
    ax.scatter(valores, np.full(len(valores), i), s=14, color=COLOR["texto"], zorder=3)
ax.set_yticks(np.arange(1, len(orden) + 1), [])
ax.set_title("AUC por fold de validación cruzada (5 folds)")

for ax in axes:
    ax.grid(axis="y", visible=False)
titulo_figura(fig, f"Comparación de modelos  ·  naranja: mejor AUC de test ({mejor})")
fig.tight_layout()
fig.savefig(FIG_DIR / "01_comparacion_modelos.png")
plt.show()

PALETA = ["#2a78d6", "#eb6834", "#1f9e89", "#b2302f", "#7b5bb6", "#c29b00", "#52514e"]

fig, ax = plt.subplots(figsize=(7.5, 6.5))
for (nombre, fila), color in zip(ranking.iterrows(), PALETA):
    fpr, tpr, _ = roc_curve(y_test, fila["proba_test"])
    ax.plot(fpr, tpr, color=color, linewidth=2.4 if nombre == mejor else 1.4,
            label=f"{fila['puesto']}. {nombre} (AUC = {fila['AUC_test']:.3f})")
ax.plot([0, 1], [0, 1], color=COLOR["tenue"], linestyle=":", linewidth=1, label="Azar (AUC = 0.5)")
ax.set_xlabel("Tasa de falsos positivos (1 − especificidad)")
ax.set_ylabel("Tasa de verdaderos positivos (sensibilidad)")
ax.set_xlim(0, 1)
ax.set_ylim(0, 1.01)
ax.set_aspect("equal")
ax.legend(loc="lower right", fontsize=8.5)
ax.set_title("Curvas ROC en el conjunto de prueba")
fig.tight_layout()
fig.savefig(FIG_DIR / "01_curvas_roc.png")
plt.show()