import numpy as np, pandas as pd, json
from itertools import product
pd.set_option("display.width", 200)

CAUSAS = ["error_picking", "dano_transporte", "direccion_incorrecta", "stock_desactualizado", "fallo_proveedor"]
SINTOMAS = ["paquete_danado", "producto_equivocado", "no_llega", "retraso"]
P_ALMACEN = {"zaragoza": 0.60, "getafe": 0.40}
P_CAUSA = {"zaragoza": [0.35, 0.30, 0.15, 0.08, 0.12], "getafe": [0.25, 0.20, 0.12, 0.33, 0.10]}     # CPT de 06-03
P_SINTOMA = {"paquete_danado":      [0.10, 0.80, 0.02, 0.02, 0.15],                                  # P(sí | causa)
             "producto_equivocado": [0.70, 0.02, 0.01, 0.10, 0.30],
             "no_llega":            [0.05, 0.10, 0.85, 0.40, 0.30],
             "retraso":             [0.10, 0.30, 0.60, 0.90, 0.70]}
DIAS_MEDIA = {"error_picking": 3, "dano_transporte": 4, "direccion_incorrecta": 8, "stock_desactualizado": 9, "fallo_proveedor": 7}
P_TRANSPORTISTA = {"zaragoza": {"TransNova": 0.5, "RapidEnvio": 0.3, "LogiSur": 0.2},
                   "getafe":   {"RapidEnvio": 0.5, "LogiSur": 0.3, "TransNova": 0.2}}

def generar_incidencias(n=2000, semilla=42, frac_etiquetada=0.5, p_causa=None):
    """incidencias.csv sintético coherente con la red de 06-03. 'causa' es la verdad; 'causa_registrada' solo en frac_etiquetada."""
    rng = np.random.default_rng(semilla); p_causa = p_causa or P_CAUSA        # p_causa: para simular un mes distinto (deriva)
    almacen = rng.choice(list(P_ALMACEN), size=n, p=list(P_ALMACEN.values()))
    causa = np.array([rng.choice(CAUSAS, p=p_causa[a]) for a in almacen])
    idx = np.array([CAUSAS.index(c) for c in causa])
    df = pd.DataFrame({"id_incidencia": [f"I{7000 + i}" for i in range(n)], "almacen": almacen})
    for s in SINTOMAS:
        df[s] = (rng.random(n) < np.array(P_SINTOMA[s])[idx]).astype(int)
    df["dias_desde_envio"] = np.clip(rng.poisson([DIAS_MEDIA[c] for c in causa]) + 1, 1, 30)
    df["transportista"] = [rng.choice(list(P_TRANSPORTISTA[a]), p=list(P_TRANSPORTISTA[a].values())) for a in almacen]
    df["valor_pedido"] = np.round(rng.gamma(2.0, 60.0, n) + 5, 2)
    df["causa"] = causa
    df["causa_registrada"] = np.where(rng.random(n) < frac_etiquetada, causa, None)
    return df

inc = generar_incidencias(); print(inc.shape, "| etiquetadas:", inc["causa_registrada"].notna().sum())
print(inc.drop(columns=["causa"]).head(3).to_string())
print(inc.groupby("almacen")["causa"].value_counts(normalize=True).unstack()[CAUSAS].round(2).to_string())
print(inc.groupby("causa")[SINTOMAS].mean().loc[CAUSAS].round(2))
print("días medios por causa:", inc.groupby("causa")["dias_desde_envio"].mean().round(1).to_dict())
etiq = inc[inc["causa_registrada"].notna()].copy(); y = etiq["causa_registrada"]

(2000, 11) | etiquetadas: 1003
  id_incidencia   almacen  paquete_danado  producto_equivocado  no_llega  retraso  dias_desde_envio transportista  valor_pedido      causa_registrada
0         I7000    getafe               0                    0         0        1                 9    RapidEnvio         23.26  stock_desactualizado
1         I7001  zaragoza               1                    0         0        0                 5     TransNova        100.02       dano_transporte
2         I7002    getafe               0                    0         1        1                 7    RapidEnvio        119.75                   NaN
causa     error_picking  dano_transporte  direccion_incorrecta  stock_desactualizado  fallo_proveedor
almacen
getafe             0.26             0.19                  0.12                  0.32             0.11
zaragoza           0.37             0.30                  0.14                  0.08             0.11
                      paquete_danado  producto_equivocado  no_llega  retraso
causa
error_picking                   0.08                 0.70      0.06     0.10
dano_transporte                 0.83                 0.01      0.11     0.32
direccion_incorrecta            0.02                 0.02      0.83     0.58
stock_desactualizado            0.03                 0.11      0.40     0.90
fallo_proveedor                 0.13                 0.25      0.30     0.68
días medios por causa: {'dano_transporte': 5.1, 'direccion_incorrecta': 9.0, 'error_picking': 4.0, 'fallo_proveedor': 8.0, 'stock_desactualizado': 10.2}

from sklearn.metrics import accuracy_score, f1_score, log_loss, classification_report

def cpt_binaria(lista): return {(c,): {1: p, 0: round(1 - p, 4)} for c, p in zip(CAUSAS, lista)}
RED = {"almacen": ([], list(P_ALMACEN), {(): P_ALMACEN}),
       "causa": (["almacen"], CAUSAS, {(a,): dict(zip(CAUSAS, P_CAUSA[a])) for a in P_ALMACEN})}
for s in SINTOMAS: RED[s] = (["causa"], [1, 0], cpt_binaria(P_SINTOMA[s]))
ORDEN = ["almacen", "causa"] + SINTOMAS

def prob_conjunta(asig):
    p = 1.0
    for nodo in ORDEN:
        padres, _, cpt = RED[nodo]; p *= cpt[tuple(asig[q] for q in padres)][asig[nodo]]
    return p

def inferir(consulta, evidencia):
    ocultas = [n for n in ORDEN if n != consulta and n not in evidencia]; res = {}
    for v in RED[consulta][1]:
        res[v] = sum(prob_conjunta(dict(evidencia, **{consulta: v}, **dict(zip(ocultas, comb))))
                     for comb in product(*[RED[n][1] for n in ocultas]))
    z = sum(res.values()); return {v: p / z for v, p in res.items()}

def diagnostico_bayes(df):
    cache, filas = {}, []
    for _, r in df.iterrows():
        clave = (r["almacen"],) + tuple(int(r[s]) for s in SINTOMAS)
        if clave not in cache:
            cache[clave] = inferir("causa", dict({"almacen": r["almacen"]}, **{s: int(r[s]) for s in SINTOMAS}))
        filas.append(cache[clave])
    return pd.DataFrame(filas, index=df.index)[CAUSAS]

CLASES = sorted(CAUSAS)                                    # el orden alfabético que usa scikit-learn
P_bayes = diagnostico_bayes(etiq); pred_bayes = P_bayes.idxmax(axis=1)
print("Mayoritaria (error_picking):", round((y == "error_picking").mean(), 3))
print("Red bayesiana: exactitud", round(accuracy_score(y, pred_bayes), 3), "| F1 macro", round(f1_score(y, pred_bayes, average="macro"), 3),
      "| log-loss", round(log_loss(y, P_bayes[CLASES].values, labels=CLASES), 3))
print(classification_report(y, pred_bayes, digits=2))
maxp = P_bayes.max(axis=1)
print(f"P máxima media {maxp.mean():.3f} | filas con P ≥ 0,6: {(maxp >= 0.6).mean():.1%}, acierto {accuracy_score(y[maxp >= 0.6], pred_bayes[maxp >= 0.6]):.3f} | P < 0,6: acierto {accuracy_score(y[maxp < 0.6], pred_bayes[maxp < 0.6]):.3f}")

Mayoritaria (error_picking): 0.314
Red bayesiana: exactitud 0.719 | F1 macro 0.606 | log-loss 0.789
                      precision    recall  f1-score   support
     dano_transporte       0.88      0.82      0.85       257
direccion_incorrecta       0.62      0.62      0.62       134
       error_picking       0.78      0.90      0.83       315
     fallo_proveedor       0.50      0.05      0.09       118
stock_desactualizado       0.54      0.77      0.64       179
            accuracy                           0.72      1003
           macro avg       0.66      0.63      0.61      1003
P máxima media 0.723 | filas con P ≥ 0,6: 67.3%, acierto 0.822 | P < 0,6: acierto 0.506

from sklearn.model_selection import StratifiedKFold, cross_val_predict
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, HistGradientBoostingClassifier

CATS, NUMS, BINS = ["almacen", "transportista"], ["dias_desde_envio", "valor_pedido"], SINTOMAS
COLS = CATS + NUMS + BINS
def crear_modelo(clasificador=None, cats=CATS, nums=NUMS, bins=BINS):
    partes = ([("cat", OneHotEncoder(handle_unknown="ignore"), cats)] if cats else []) + \
             ([("num", StandardScaler(), nums)] if nums else []) + ([("bin", "passthrough", bins)] if bins else [])
    return Pipeline([("prep", ColumnTransformer(partes)), ("modelo", clasificador if clasificador is not None else LogisticRegression(max_iter=2000))])

cv = StratifiedKFold(5, shuffle=True, random_state=42)
def evaluar_cv(pipe, Xd, nombre):
    P = cross_val_predict(pipe, Xd, y, cv=cv, method="predict_proba"); pred = np.array(CLASES)[P.argmax(1)]
    print(f"{nombre:34s} exactitud {accuracy_score(y, pred):.3f}  F1 macro {f1_score(y, pred, average='macro'):.3f}  log-loss {log_loss(y, P, labels=CLASES):.3f}")
    return P, pred
modelos = {"Logística multiclase": LogisticRegression(max_iter=2000), "Árbol (prof. 5)": DecisionTreeClassifier(max_depth=5, random_state=42),
           "Bosque (300, hoja 5)": RandomForestClassifier(n_estimators=300, min_samples_leaf=5, random_state=42),
           "HGB (prof. 3)": HistGradientBoostingClassifier(max_depth=3, learning_rate=0.05, max_iter=200, random_state=42)}
resultados = {n: evaluar_cv(crear_modelo(m), etiq[COLS], n) for n, m in modelos.items()}
evaluar_cv(crear_modelo(cats=["almacen"], nums=[], bins=BINS), etiq[["almacen"] + BINS], "Logística SOLO almacén + síntomas")
evaluar_cv(crear_modelo(cats=[], nums=["dias_desde_envio"], bins=[]), etiq[["dias_desde_envio"]], "Logística SOLO días")
P_log, pred_log = resultados["Logística multiclase"]
print(pd.crosstab(y, pred_log, rownames=["real"], colnames=["logística"]).to_string())
accs = [(accuracy_score(y.iloc[te], pred_bayes.iloc[te]), accuracy_score(y.iloc[te], pred_log[te])) for _, te in cv.split(etiq[COLS], y)]
print("Por pliegue (bayes, logística):", [(round(a, 3), round(b, 3)) for a, b in accs], "| ventaja media", round(np.mean([b - a for a, b in accs]), 3))
for n_lab in (100, 250, 500, 1003):
    sub = etiq.sample(n_lab, random_state=1) if n_lab < len(etiq) else etiq
    P = cross_val_predict(crear_modelo(), sub[COLS], sub["causa_registrada"], cv=cv, method="predict_proba")
    print(f"n etiquetadas={n_lab:4d}: logística {accuracy_score(sub['causa_registrada'], np.array(CLASES)[P.argmax(1)]):.3f}  red bayesiana {accuracy_score(sub['causa_registrada'], diagnostico_bayes(sub).idxmax(axis=1)):.3f}")

Logística multiclase               exactitud 0.738  F1 macro 0.658  log-loss 0.690
Árbol (prof. 5)                    exactitud 0.690  F1 macro 0.598  log-loss 1.796
Bosque (300, hoja 5)               exactitud 0.735  F1 macro 0.646  log-loss 0.759
HGB (prof. 3)                      exactitud 0.724  F1 macro 0.655  log-loss 0.802
Logística SOLO almacén + síntomas  exactitud 0.709  F1 macro 0.612  log-loss 0.804
Logística SOLO días                exactitud 0.454  F1 macro 0.292  log-loss 1.206
logística             dano_transporte  direccion_incorrecta  error_picking  fallo_proveedor  stock_desactualizado
real
dano_transporte                   211                     3             26               12                     5
direccion_incorrecta                2                    85              4               15                    28
error_picking                      10                     2            291                9                     3
fallo_proveedor                    15                    24             20               26                    33
stock_desactualizado                3                    24              5               20                   127
Por pliegue (bayes, logística): [(0.677, 0.716), (0.731, 0.721), (0.751, 0.761), (0.73, 0.77), (0.705, 0.72)] | ventaja media 0.019
n etiquetadas= 100: logística 0.780  red bayesiana 0.790
n etiquetadas= 250: logística 0.752  red bayesiana 0.744
n etiquetadas= 500: logística 0.764  red bayesiana 0.746
n etiquetadas=1003: logística 0.738  red bayesiana 0.719

UMBRAL_AUTO, VALOR_ALTO, DIAS_MAX = 0.60, 300.0, 10
def decidir(fila, probs):
    causa, p = CLASES[int(np.argmax(probs))], float(np.max(probs)); acciones, traza = [], []
    if fila["valor_pedido"] > VALOR_ALTO:
        cola = "revision_humana"; traza.append(f"R0: valor {fila['valor_pedido']:.0f} € > {VALOR_ALTO:.0f} € → siempre revisa una persona")
    elif p < UMBRAL_AUTO:
        cola = "revision_humana"; traza.append(f"R1: P({causa})={p:.2f} < {UMBRAL_AUTO} → zona gris")
    else:
        cola = "automatica"; traza.append(f"R2: P({causa})={p:.2f} ≥ {UMBRAL_AUTO} → causa aceptada como hecho")
    if causa == "dano_transporte" and p >= UMBRAL_AUTO:
        acciones.append(f"abrir_traza:{fila['transportista']}"); traza.append("R3: daño en transporte → traza con el transportista")
    if causa == "error_picking" and p >= UMBRAL_AUTO:
        acciones.append(f"reenvio_desde:{fila['almacen']}"); traza.append("R4: error de picking → reenvío inmediato y aviso al almacén")
    if fila["no_llega"] == 1 and fila["dias_desde_envio"] > DIAS_MAX:
        acciones.append("reclamacion_transportista"); traza.append(f"R5: no llega y {fila['dias_desde_envio']} días > {DIAS_MAX} → reclamación, sea cual sea la causa")
    if causa == "stock_desactualizado" and p >= UMBRAL_AUTO:
        acciones.append("aviso_compras"); traza.append("R6: stock desactualizado → aviso a compras y alternativa al cliente")
    return {"cola": cola, "causa_propuesta": causa, "confianza": round(p, 3), "acciones": acciones, "traza": traza}

decisiones = pd.DataFrame([decidir(f, P_log[i]) for i, (_, f) in enumerate(etiq.iterrows())], index=etiq.index)
etiq2 = pd.concat([etiq, decisiones], axis=1)
for cola, g in etiq2.groupby("cola"):
    print(f"{cola:16s} n={len(g):4d} ({len(g) / len(etiq2):.1%})  acierto de la causa propuesta {accuracy_score(g['causa_registrada'], g['causa_propuesta']):.3f}")
print("acciones lanzadas:", pd.Series([a.split(':')[0] for l in etiq2["acciones"] for a in l]).value_counts().to_dict())
r = etiq2.iloc[6]; print(r["id_incidencia"], "| real:", r["causa_registrada"], "→", r["cola"], r["causa_propuesta"], r["confianza"], r["acciones"]); [print("   ", t) for t in r["traza"]]
for u in (0.5, 0.6, 0.7, 0.8):
    auto = etiq2[(P_log.max(1) >= u) & (etiq2["valor_pedido"] <= VALOR_ALTO)]
    print(f"umbral {u}: automática {len(auto) / len(etiq2):.1%}, acierto {accuracy_score(auto['causa_registrada'], auto['causa_propuesta']):.3f}")
modelo = crear_modelo().fit(etiq[COLS], y)                                       # modelo final con las 1.003 etiquetadas
sin = inc[inc["causa_registrada"].isna()].copy(); P_sin = modelo.predict_proba(sin[COLS])
dec_sin = pd.DataFrame([decidir(f, P_sin[i]) for i, (_, f) in enumerate(sin.iterrows())], index=sin.index)
auto = dec_sin["cola"] == "automatica"
print("Sin etiqueta:", dec_sin["cola"].value_counts().to_dict(), "| acierto real (oculto) automática:", round(accuracy_score(sin.loc[auto, "causa"], dec_sin.loc[auto, "causa_propuesta"]), 3),
      "| humana:", round(accuracy_score(sin.loc[~auto, "causa"], dec_sin.loc[~auto, "causa_propuesta"]), 3))

automatica       n= 649 (64.7%)  acierto de la causa propuesta 0.858
revision_humana  n= 354 (35.3%)  acierto de la causa propuesta 0.517
acciones lanzadas: {'reenvio_desde': 290, 'abrir_traza': 223, 'aviso_compras': 104, 'reclamacion_transportista': 67}
I7010 | real: error_picking → revision_humana error_picking 0.808 ['reenvio_desde:zaragoza']
    R0: valor 349 € > 300 € → siempre revisa una persona
    R4: error de picking → reenvío inmediato y aviso al almacén
umbral 0.5: automática 76.5%, acierto 0.821
umbral 0.6: automática 64.7%, acierto 0.858
umbral 0.7: automática 53.8%, acierto 0.906
umbral 0.8: automática 45.8%, acierto 0.919
Sin etiqueta: {'automatica': 697, 'revision_humana': 300} | acierto real (oculto) automática: 0.852 | humana: 0.52

import joblib
card = {"nombre": "Diagnóstico de causa de incidencias NovaMarket (caso 9)", "version": "0.1.0-prototipo", "fecha": "2026-08-18",
        "modelo": "Regresión logística multiclase: almacén, transportista, 4 síntomas, días desde envío, valor del pedido",
        "datos": {"incidencias": int(len(inc)), "etiquetadas": int(len(etiq)), "clases": CLASES},
        "metricas_cv5": {"exactitud": 0.738, "f1_macro": 0.658, "linea_base_red_bayesiana": 0.719, "linea_base_mayoritaria": 0.314},
        "colas": {"umbral_automatica": UMBRAL_AUTO, "valor_alto_revision": VALOR_ALTO, "fraccion_automatica": 0.647, "acierto_automatica": 0.858},
        "uso_previsto": "Proponer causa y acciones al agente; decidir automáticamente solo en la cola automática y con acciones reversibles",
        "uso_no_previsto": "Imputar responsabilidad a un transportista o empleado sin revisión humana; usar la causa para penalizar",
        "limitaciones": ["fallo_proveedor se detecta mal (recall 0,22)", "solo 1.003 etiquetas, registradas en la mitad de los casos",
                          "datos sintéticos coherentes con las CPT de 06-03: validar con datos reales antes del piloto"]}
referencia = {"tasa_sintomas": etiq[SINTOMAS].mean().round(3).to_dict(), "frac_automatica": 0.647,
              "dist_causa_propuesta": etiq2["causa_propuesta"].value_counts(normalize=True).round(3).to_dict(),
              "bordes_dias": [0, 2, 4, 6, 8, 10, 14, None], "frec_dias": None}
PSI_AVISO, PSI_ALERTA, DIF_TASA = 0.10, 0.25, 0.08
def psi(ref, nuevo, eps=1e-4):
    r, n = np.clip(np.asarray(ref, float), eps, None), np.clip(np.asarray(nuevo, float), eps, None)
    return float(np.sum((n - r) * np.log(n / r)))
def frecuencias(valores, bordes):
    b = [-np.inf if x is None else x for x in bordes]; b[-1] = np.inf
    c, _ = np.histogram(valores, bins=b); return (c / c.sum()).tolist()
referencia["frec_dias"] = frecuencias(etiq["dias_desde_envio"], referencia["bordes_dias"])
json.dump(card, open("model_card_incidencias.json", "w"), indent=2, ensure_ascii=False)
json.dump(referencia, open("referencia_deriva_incidencias.json", "w"), indent=2); joblib.dump(modelo, "modelo_incidencias.joblib")

def chequear_deriva(lote, referencia, modelo):
    P = modelo.predict_proba(lote[COLS]); dec = pd.DataFrame([decidir(f, P[i]) for i, (_, f) in enumerate(lote.iterrows())])
    avisos, v = [], psi(referencia["frec_dias"], frecuencias(lote["dias_desde_envio"], referencia["bordes_dias"]))
    if v > PSI_AVISO: avisos.append(f"PSI días = {v:.3f}")
    for s, t in referencia["tasa_sintomas"].items():
        if abs(lote[s].mean() - t) > DIF_TASA: avisos.append(f"tasa {s}: {lote[s].mean():.3f} frente a {t:.3f}")
    fa = (dec["cola"] == "automatica").mean()
    if abs(fa - referencia["frac_automatica"]) > DIF_TASA: avisos.append(f"fracción automática {fa:.3f} frente a {referencia['frac_automatica']:.3f}")
    dc = dec["causa_propuesta"].value_counts(normalize=True)
    for c, t in referencia["dist_causa_propuesta"].items():
        if abs(dc.get(c, 0) - t) > DIF_TASA: avisos.append(f"causa propuesta {c}: {dc.get(c, 0):.3f} frente a {t:.3f}")
    estado = "ALERTA" if v > PSI_ALERTA or len(avisos) >= 2 else ("AVISO" if avisos else "OK")
    return estado, avisos
print("Mes normal:", chequear_deriva(generar_incidencias(400, semilla=7), referencia, modelo))
p_transporte = {"zaragoza": [0.20, 0.55, 0.10, 0.06, 0.09], "getafe": [0.15, 0.45, 0.08, 0.25, 0.07]}   # el daño en transporte se dispara
print("Mes con problema de transporte:", chequear_deriva(generar_incidencias(400, semilla=8, p_causa=p_transporte), referencia, modelo))

Mes normal: ('OK', [])
Mes con problema de transporte: ('ALERTA', ['tasa paquete_danado: 0.525 frente a 0.259', 'tasa producto_equivocado: 0.150 frente a 0.282', 'tasa no_llega: 0.177 frente a 0.260', 'fracción automática 0.782 frente a 0.647', 'causa propuesta error_picking: 0.233 frente a 0.345', 'causa propuesta dano_transporte: 0.497 frente a 0.240'])