Propensión a contratar (cross-sell)

"""#7 Propensión a contratar un producto (cross-sell) con corte óptimo por costo/beneficio.

Datos: Bank Marketing (UCI, banco portugués, 41,188 llamadas de telemarketing).
Se excluye `duration` porque solo se conoce después de la llamada (fuga de información).
"""
import io

import numpy as np
import pandas as pd
from lightgbm import LGBMClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score
from sklearn.model_selection import StratifiedKFold, TimeSeriesSplit, cross_val_score

from common import (SEED, bars, cumulative_gain_curve, download, export, gains_table, line,
                    read_from_zip, table)
from validacion import bootstrap_ci, graficas_validacion, model_card

URL = "https://archive.ics.uci.edu/static/public/222/bank+marketing.zip"
COSTO_LLAMADA = 8.0      # USD por llamada
MARGEN_PRODUCTO = 120.0  # margen esperado por cada depósito contratado


def load() -> pd.DataFrame:
    raw = read_from_zip(download(URL, "bank_marketing.zip"), "bank-additional-full.csv")
    df = pd.read_csv(io.BytesIO(raw), sep=";")
    df["y"] = (df["y"] == "yes").astype(int)
    df["contactado_antes"] = (df["pdays"] != 999).astype(int)
    return df.drop(columns=["duration"])


MACRO = ["emp.var.rate", "cons.price.idx", "cons.conf.idx", "euribor3m", "nr.employed"]


def gbm():
    return LGBMClassifier(n_estimators=400, learning_rate=0.02, num_leaves=15, min_child_samples=100,
                          subsample=0.8, subsample_freq=1, colsample_bytree=0.8, random_state=SEED, verbose=-1)


def utilidad(y, p, u):
    sel = p >= u
    return float(y[sel].sum() * MARGEN_PRODUCTO - sel.sum() * COSTO_LLAMADA)


def run():
    df = load()
    y = df.pop("y").values
    for c in df.select_dtypes("object").columns:
        df[c] = df[c].astype("category")
    conjuntos = {"Completo (con macro)": list(df.columns),
                 "Solo cliente (sin macro)": [c for c in df.columns if c not in MACRO]}

    # Los datos están ordenados en el tiempo (may-2008 → nov-2010). Un split aleatorio mezcla periodos y es
    # optimista. Cambio de enfoque: validación fuera de tiempo (OOT) —
    # entrenamiento 0–70 %, validación 70–80 % (umbral y recalibración), prueba 80–100 %.
    n = len(df)
    i_tr, i_va = int(n * 0.7), int(n * 0.8)
    tasa = [float(y[k * n // 10:(k + 1) * n // 10].mean() * 100) for k in range(10)]

    comp = []
    for nombre, cols in conjuntos.items():
        X = df[cols]
        # (a) CV aleatoria estratificada — lo que haría un análisis ingenuo
        aleat = cross_val_score(gbm(), X.iloc[:i_va], y[:i_va], cv=StratifiedKFold(5, shuffle=True, random_state=SEED),
                                scoring="roc_auc")
        # (b) CV temporal (expanding window) — respeta el orden
        temp = cross_val_score(gbm(), X.iloc[:i_va], y[:i_va], cv=TimeSeriesSplit(5), scoring="roc_auc")
        # (c) Prueba fuera de tiempo
        m = gbm().fit(X.iloc[:i_tr], y[:i_tr])
        oot = roc_auc_score(y[i_va:], m.predict_proba(X.iloc[i_va:])[:, 1])
        comp.append({"Variables": nombre, "CV aleatoria": aleat.mean(), "CV temporal": temp.mean(),
                     "Prueba OOT": oot, "std_a": aleat.std(), "std_t": temp.std()})
    comp = pd.DataFrame(comp)
    mejor = comp.loc[comp["Prueba OOT"].idxmax(), "Variables"]

    # Modelo final con el conjunto que mejor generaliza fuera de tiempo
    X = df[conjuntos[mejor]]
    modelo = gbm().fit(X.iloc[:i_tr], y[:i_tr])
    p_va, p_te = modelo.predict_proba(X.iloc[i_tr:i_va])[:, 1], modelo.predict_proba(X.iloc[i_va:])[:, 1]
    y_va, y_te = y[i_tr:i_va], y[i_va:]
    auc, auc_lo, auc_hi = bootstrap_ci(y_te, p_te)
    # Recalibración Platt con la ventana de validación (la más reciente antes de la prueba)
    logit = lambda q: np.log(np.clip(q, 1e-6, 1 - 1e-6) / (1 - np.clip(q, 1e-6, 1 - 1e-6))).reshape(-1, 1)
    platt = LogisticRegression(C=1e6).fit(logit(p_va), y_va)
    p_te_cal = platt.predict_proba(logit(p_te))[:, 1]

    # Umbral: (1) regla teórica costo/margen sobre prob. calibrada; (2) óptimo en validación; (3) oráculo en prueba
    u_teorico = COSTO_LLAMADA / MARGEN_PRODUCTO
    umbrales = np.round(np.arange(0.01, 0.81, 0.01), 2)
    u_va = float(umbrales[np.argmax([utilidad(y_va, p_va, u) for u in umbrales])])
    util_te = [utilidad(y_te, p_te_cal, u) for u in umbrales]
    u_oraculo = float(umbrales[int(np.argmax(util_te))])
    estrategias = {
        "Llamar a todos": utilidad(y_te, np.ones_like(p_te), 0.5),
        "Umbral de validación (sin recalibrar)": utilidad(y_te, p_te, u_va),
        "Regla costo/margen (recalibrado)": utilidad(y_te, p_te_cal, u_teorico),
        "Oráculo (máximo posible)": max(util_te),
    }

    # Explicabilidad: SHAP global + efecto parcial de la variable principal
    contrib = modelo.predict(X.iloc[i_va:], pred_contrib=True)[:, :-1]
    shap = pd.Series(np.abs(contrib).mean(0), index=X.columns).sort_values(ascending=False)
    top = shap.index[0]
    pdp = []
    if pd.api.types.is_numeric_dtype(X[top]):
        for v in np.unique(np.quantile(X[top], np.linspace(0.02, 0.98, 15))):
            Xg = X.iloc[i_va:].copy()
            Xg[top] = v
            pdp.append([round(float(v), 3), round(float(modelo.predict_proba(Xg)[:, 1].mean() * 100), 2)])

    g = gains_table(y_te, p_te)
    g_tbl = g[["decil", "n", "pos", "tasa", "captura_acum", "lift"]].copy()
    g_tbl["tasa"] = (g_tbl["tasa"] * 100).round(1)
    g_tbl["captura_acum"] = (g_tbl["captura_acum"] * 100).round(1)
    g_tbl["lift"] = g_tbl["lift"].round(2)
    g_tbl.columns = ["Decil", "Clientes", "Contratan", "Conversión %", "Captura acum. %", "Lift"]
    comp_tbl = pd.DataFrame({"Variables": comp["Variables"],
                             "AUC CV aleatoria": [f"{m:.3f} ± {s:.3f}" for m, s in comp[["CV aleatoria", "std_a"]].values],
                             "AUC CV temporal": [f"{m:.3f} ± {s:.3f}" for m, s in comp[["CV temporal", "std_t"]].values],
                             "AUC prueba OOT": comp["Prueba OOT"].round(3)})
    c_full = comp.set_index("Variables").loc["Completo (con macro)"]
    # Con capacidad limitada (30 % de llamadas) el valor del modelo es priorizar
    orden = np.argsort(-p_te)
    cap30 = y_te[orden[: int(len(y_te) * 0.3)]].sum() / y_te.sum()
    result = {
        "title": "Propensión a contratar (cross-sell)",
        "summary": [
            f"Los datos cubren 2008–2010 y la conversión pasa de {tasa[0]:.0f} % a {tasa[-1]:.0f} % entre el primer y el último "
            "decil de tiempo: hay drift fuerte. Cambio de enfoque: validación fuera de tiempo en lugar de split aleatorio.",
            f"La CV aleatoria es optimista: AUC {c_full['CV aleatoria']:.3f} vs. {c_full['CV temporal']:.3f} en CV temporal "
            f"y {c_full['Prueba OOT']:.3f} fuera de tiempo (con variables macro). Mejor conjunto OOT: {mejor}.",
            f"Prueba OOT: AUC {auc:.3f} (IC 95 % {auc_lo:.3f}–{auc_hi:.3f}). Sin recalibrar, la probabilidad media es "
            f"{p_te.mean():.1%} vs. {y_te.mean():.1%} real; la recalibración con la ventana más reciente la lleva a {p_te_cal.mean():.1%}.",
            f"Utilidad en el periodo de prueba: regla costo/margen recalibrada ${estrategias['Regla costo/margen (recalibrado)']:,.0f} "
            f"vs. ${estrategias['Llamar a todos']:,.0f} llamando a todos y ${estrategias['Umbral de validación (sin recalibrar)']:,.0f} "
            f"con el umbral viejo (oráculo ${estrategias['Oráculo (máximo posible)']:,.0f}). Con {y_te.mean():.0%} de conversión "
            "llamar a todos ya es casi óptimo: el umbral debe recalibrarse con datos recientes y el valor del modelo "
            f"está en priorizar con capacidad limitada (llamando al 30 % se captura {cap30:.0%} de las contrataciones).",
        ],
        "metrics": [
            {"label": "AUC CV aleatoria (optimista)", "value": f"{c_full['CV aleatoria']:.3f}"},
            {"label": "AUC fuera de tiempo", "value": f"{auc:.3f} [{auc_lo:.2f}–{auc_hi:.2f}]"},
            {"label": "Lift decil 1 (OOT)", "value": f"{g.lift.iloc[0]:.1f}×"},
            {"label": "Captura con 30 % de llamadas", "value": f"{cap30:.0%}"},
        ],
        "charts": [
            line("drift", "Tasa de conversión a lo largo del tiempo (deciles de llamadas)",
                 {"Conversión": [[k + 1, round(v, 2)] for k, v in enumerate(tasa)]},
                 x_label="Decil temporal (1 = may-2008, 10 = nov-2010)", y_label="% que contrata", fmt="pct",
                 markers=[[7.5, "Fin entrenamiento"], [8.5, "Inicio prueba"]]),
            bars("auc", "AUC según esquema de validación (variables completas)",
                 ["CV aleatoria", "CV temporal", "Prueba fuera de tiempo"],
                 [round(c_full["CV aleatoria"], 3), round(c_full["CV temporal"], 3), round(c_full["Prueba OOT"], 3)], fmt="dec"),
            bars("estr", "Utilidad en el periodo de prueba por estrategia", list(estrategias),
                 [round(v) for v in estrategias.values()], fmt="usd"),
            line("util", "Utilidad en prueba según umbral (probabilidad recalibrada)",
                 {"Utilidad": [[float(u), v] for u, v in zip(umbrales, util_te)]},
                 x_label="Umbral de probabilidad para llamar", y_label="USD", fmt="usd",
                 markers=[[round(u_teorico, 3), "Costo/margen"]]),
            *graficas_validacion(y_te, {"Sin recalibrar": p_te, "Recalibrado": p_te_cal}),
            line("gain", "Curva de ganancia acumulada (fuera de tiempo)",
                 {"Modelo": cumulative_gain_curve(y_te, p_te), "Al azar": [[0, 0], [100, 100]]},
                 x_label="% de clientes llamados", y_label="% de contrataciones capturadas", fmt="pct"),
            bars("shap", "Explicabilidad: |SHAP| promedio", shap.index[:10], shap.values[:10].round(3), fmt="dec"),
            *([line("pdp", f"Efecto parcial de {top}", {"Prob. de contratar": pdp}, x_label=top,
                    y_label="Prob. promedio %", fmt="pct")] if pdp else []),
        ],
        "tables": [table("AUC por esquema de validación y conjunto de variables", comp_tbl),
                   table("Tabla de ganancia por decil (fuera de tiempo)", g_tbl)],
        "card": model_card(
            "LightGBM de propensión; selección de variables y umbral con validación fuera de tiempo; "
            "recalibración Platt con la ventana más reciente.",
            ["Comparación explícita: CV aleatoria vs. CV temporal (TimeSeriesSplit) vs. prueba fuera de tiempo.",
             "Entrenamiento 0–70 %, validación 70–80 %, prueba 80–100 % en orden cronológico.",
             "AUC con IC bootstrap; calibración antes y después de recalibrar.",
             "Se excluye `duration` (solo existe después de la llamada: fuga)."],
            [f"Costo ${COSTO_LLAMADA:.0f} por llamada y margen ${MARGEN_PRODUCTO:.0f} por producto (editables en el simulador).",
             "La probabilidad recalibrada es comparable con la regla costo/margen."],
            ["Banco portugués 2008–2010, periodo de crisis: las variables macro dominan el periodo.",
             "El simulador del sitio usa la muestra de prueba fuera de tiempo."]),
        "assumptions": {"costo_llamada": COSTO_LLAMADA, "margen_producto": MARGEN_PRODUCTO},
    }
    sample = pd.DataFrame({"p": p_te_cal.round(4), "y": y_te})
    export("p07-cross-sell", result, sample.sample(min(4000, len(sample)), random_state=1))
    return result


if __name__ == "__main__":
    run()