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

CAUSES = ["error_picking", "dany_transport", "adreca_incorrecta", "stock_desactualitzat", "fallada_proveidor"]
SIMPTOMES = ["paquet_danyat", "producte_equivocat", "no_arriba", "retard"]
P_MAGATZEM = {"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_SIMPTOMA = {"paquet_danyat":      [0.10, 0.80, 0.02, 0.02, 0.15],                                  # P(si | causa)
              "producte_equivocat": [0.70, 0.02, 0.01, 0.10, 0.30],
              "no_arriba":          [0.05, 0.10, 0.85, 0.40, 0.30],
              "retard":             [0.10, 0.30, 0.60, 0.90, 0.70]}
DIES_MITJANA = {"error_picking": 3, "dany_transport": 4, "adreca_incorrecta": 8, "stock_desactualitzat": 9, "fallada_proveidor": 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_incidencies(n=2000, llavor=42, frac_etiquetada=0.5, p_causa=None):
    """incidencies.csv sintetic coherent amb la xarxa de 06-03. 'causa' es la veritat; 'causa_registrada' nomes a frac_etiquetada."""
    rng = np.random.default_rng(llavor); p_causa = p_causa or P_CAUSA         # p_causa: per simular un mes diferent (deriva)
    magatzem = rng.choice(list(P_MAGATZEM), size=n, p=list(P_MAGATZEM.values()))
    causa = np.array([rng.choice(CAUSES, p=p_causa[a]) for a in magatzem])
    idx = np.array([CAUSES.index(c) for c in causa])
    df = pd.DataFrame({"id_incidencia": [f"I{7000 + i}" for i in range(n)], "magatzem": magatzem})
    for s in SIMPTOMES:
        df[s] = (rng.random(n) < np.array(P_SIMPTOMA[s])[idx]).astype(int)
    df["dies_des_enviament"] = np.clip(rng.poisson([DIES_MITJANA[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 magatzem]
    df["valor_comanda"] = 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_incidencies(); print(inc.shape, "| etiquetades:", inc["causa_registrada"].notna().sum())
print(inc.drop(columns=["causa"]).head(3).to_string())
print(inc.groupby("magatzem")["causa"].value_counts(normalize=True).unstack()[CAUSES].round(2).to_string())
print(inc.groupby("causa")[SIMPTOMES].mean().loc[CAUSES].round(2))
print("dies mitjans per causa:", inc.groupby("causa")["dies_des_enviament"].mean().round(1).to_dict())
etiq = inc[inc["causa_registrada"].notna()].copy(); y = etiq["causa_registrada"]

(2000, 11) | etiquetades: 1003
  id_incidencia  magatzem  paquet_danyat  producte_equivocat  no_arriba  retard  dies_des_enviament transportista  valor_comanda      causa_registrada
0         I7000    getafe              0                   0          0       1                   9    RapidEnvio          23.26  stock_desactualitzat
1         I7001  zaragoza              1                   0          0       0                   5     TransNova         100.02        dany_transport
2         I7002    getafe              0                   0          1       1                   7    RapidEnvio         119.75                   NaN
causa     error_picking  dany_transport  adreca_incorrecta  stock_desactualitzat  fallada_proveidor
magatzem
getafe             0.26            0.19               0.12                  0.32               0.11
zaragoza           0.37            0.30               0.14                  0.08               0.11
                      paquet_danyat  producte_equivocat  no_arriba  retard
causa
error_picking                  0.08                0.70       0.06    0.10
dany_transport                 0.83                0.01       0.11    0.32
adreca_incorrecta              0.02                0.02       0.83    0.58
stock_desactualitzat           0.03                0.11       0.40    0.90
fallada_proveidor              0.13                0.25       0.30    0.68
dies mitjans per causa: {'adreca_incorrecta': 9.0, 'dany_transport': 5.1, 'error_picking': 4.0, 'fallada_proveidor': 8.0, 'stock_desactualitzat': 10.2}

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

def cpt_binaria(llista): return {(c,): {1: p, 0: round(1 - p, 4)} for c, p in zip(CAUSES, llista)}
XARXA = {"magatzem": ([], list(P_MAGATZEM), {(): P_MAGATZEM}),
         "causa": (["magatzem"], CAUSES, {(a,): dict(zip(CAUSES, P_CAUSA[a])) for a in P_MAGATZEM})}
for s in SIMPTOMES: XARXA[s] = (["causa"], [1, 0], cpt_binaria(P_SIMPTOMA[s]))
ORDRE = ["magatzem", "causa"] + SIMPTOMES

def prob_conjunta(assig):
    p = 1.0
    for node in ORDRE:
        pares, _, cpt = XARXA[node]; p *= cpt[tuple(assig[q] for q in pares)][assig[node]]
    return p

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

def diagnostic_bayes(df):
    cache, files = {}, []
    for _, r in df.iterrows():
        clau = (r["magatzem"],) + tuple(int(r[s]) for s in SIMPTOMES)
        if clau not in cache:
            cache[clau] = inferir("causa", dict({"magatzem": r["magatzem"]}, **{s: int(r[s]) for s in SIMPTOMES}))
        files.append(cache[clau])
    return pd.DataFrame(files, index=df.index)[CAUSES]

CLASSES = sorted(CAUSES)                                   # l'ordre alfabetic que fa servir scikit-learn
P_bayes = diagnostic_bayes(etiq); pred_bayes = P_bayes.idxmax(axis=1)
print("Majoritaria (error_picking):", round((y == "error_picking").mean(), 3))
print("Xarxa 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[CLASSES].values, labels=CLASSES), 3))
print(classification_report(y, pred_bayes, digits=2))
maxp = P_bayes.max(axis=1)
print(f"P maxima mitjana {maxp.mean():.3f} | files amb P ≥ 0,6: {(maxp >= 0.6).mean():.1%}, encert {accuracy_score(y[maxp >= 0.6], pred_bayes[maxp >= 0.6]):.3f} | P < 0,6: encert {accuracy_score(y[maxp < 0.6], pred_bayes[maxp < 0.6]):.3f}")

Majoritaria (error_picking): 0.314
Xarxa bayesiana: exactitud 0.719 | F1 macro 0.606 | log-loss 0.789
                      precision    recall  f1-score   support
   adreca_incorrecta       0.62      0.62      0.62       134
      dany_transport       0.88      0.82      0.85       257
       error_picking       0.78      0.90      0.83       315
   fallada_proveidor       0.50      0.05      0.09       118
stock_desactualitzat       0.54      0.77      0.64       179
            accuracy                           0.72      1003
           macro avg       0.66      0.63      0.61      1003
P maxima mitjana 0.723 | files amb P ≥ 0,6: 67.3%, encert 0.822 | P < 0,6: encert 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 = ["magatzem", "transportista"], ["dies_des_enviament", "valor_comanda"], SIMPTOMES
COLS = CATS + NUMS + BINS
def crear_model(classificador=None, cats=CATS, nums=NUMS, bins=BINS):
    parts = ([("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(parts)), ("model", classificador if classificador is not None else LogisticRegression(max_iter=2000))])

cv = StratifiedKFold(5, shuffle=True, random_state=42)
def avaluar_cv(pipe, Xd, nom):
    P = cross_val_predict(pipe, Xd, y, cv=cv, method="predict_proba"); pred = np.array(CLASSES)[P.argmax(1)]
    print(f"{nom:36s} exactitud {accuracy_score(y, pred):.3f}  F1 macro {f1_score(y, pred, average='macro'):.3f}  log-loss {log_loss(y, P, labels=CLASSES):.3f}")
    return P, pred
models = {"Logística multiclasse": LogisticRegression(max_iter=2000), "Arbre (prof. 5)": DecisionTreeClassifier(max_depth=5, random_state=42),
          "Bosc (300, fulla 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)}
resultats = {n: avaluar_cv(crear_model(m), etiq[COLS], n) for n, m in models.items()}
avaluar_cv(crear_model(cats=["magatzem"], nums=[], bins=BINS), etiq[["magatzem"] + BINS], "Logística NOMÉS magatzem + símptomes")
avaluar_cv(crear_model(cats=[], nums=["dies_des_enviament"], bins=[]), etiq[["dies_des_enviament"]], "Logística NOMÉS dies")
P_log, pred_log = resultats["Logística multiclasse"]
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("Per plec (bayes, logística):", [(round(a, 3), round(b, 3)) for a, b in accs], "| avantatge mitjana", 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_model(), sub[COLS], sub["causa_registrada"], cv=cv, method="predict_proba")
    print(f"n etiquetades={n_lab:4d}: logística {accuracy_score(sub['causa_registrada'], np.array(CLASSES)[P.argmax(1)]):.3f}  xarxa bayesiana {accuracy_score(sub['causa_registrada'], diagnostic_bayes(sub).idxmax(axis=1)):.3f}")

Logística multiclasse                exactitud 0.738  F1 macro 0.658  log-loss 0.690
Arbre (prof. 5)                      exactitud 0.690  F1 macro 0.598  log-loss 1.796
Bosc (300, fulla 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 NOMÉS magatzem + símptomes exactitud 0.709  F1 macro 0.612  log-loss 0.804
Logística NOMÉS dies                 exactitud 0.454  F1 macro 0.292  log-loss 1.206
logística             adreca_incorrecta  dany_transport  error_picking  fallada_proveidor  stock_desactualitzat
real
adreca_incorrecta                    85               2              4                 15                    28
dany_transport                        3             211             26                 12                     5
error_picking                         2              10            291                  9                     3
fallada_proveidor                    24              15             20                 26                    33
stock_desactualitzat                 24               3              5                 20                   127
Per plec (bayes, logística): [(0.677, 0.716), (0.731, 0.721), (0.751, 0.761), (0.73, 0.77), (0.705, 0.72)] | avantatge mitjana 0.019
n etiquetades= 100: logística 0.780  xarxa bayesiana 0.790
n etiquetades= 250: logística 0.752  xarxa bayesiana 0.744
n etiquetades= 500: logística 0.764  xarxa bayesiana 0.746
n etiquetades=1003: logística 0.738  xarxa bayesiana 0.719

LLINDAR_AUTO, VALOR_ALT, DIES_MAX = 0.60, 300.0, 10
def decidir(fila, probs):
    causa, p = CLASSES[int(np.argmax(probs))], float(np.max(probs)); accions, traca = [], []
    if fila["valor_comanda"] > VALOR_ALT:
        cua = "revisio_humana"; traca.append(f"R0: valor {fila['valor_comanda']:.0f} € > {VALOR_ALT:.0f} € → sempre ho revisa una persona")
    elif p < LLINDAR_AUTO:
        cua = "revisio_humana"; traca.append(f"R1: P({causa})={p:.2f} < {LLINDAR_AUTO} → zona grisa")
    else:
        cua = "automatica"; traca.append(f"R2: P({causa})={p:.2f} ≥ {LLINDAR_AUTO} → causa acceptada com a fet")
    if causa == "dany_transport" and p >= LLINDAR_AUTO:
        accions.append(f"obrir_traca:{fila['transportista']}"); traca.append("R3: dany en transport → traca amb el transportista")
    if causa == "error_picking" and p >= LLINDAR_AUTO:
        accions.append(f"reenviament_des_de:{fila['magatzem']}"); traca.append("R4: error de picking → reenviament immediat i avis al magatzem")
    if fila["no_arriba"] == 1 and fila["dies_des_enviament"] > DIES_MAX:
        accions.append("reclamacio_transportista"); traca.append(f"R5: no arriba i {fila['dies_des_enviament']} dies > {DIES_MAX} → reclamacio, sigui quina sigui la causa")
    if causa == "stock_desactualitzat" and p >= LLINDAR_AUTO:
        accions.append("avis_compres"); traca.append("R6: stock desactualitzat → avis a compres i alternativa al client")
    return {"cua": cua, "causa_proposta": causa, "confianca": round(p, 3), "accions": accions, "traca": traca}

decisions = pd.DataFrame([decidir(f, P_log[i]) for i, (_, f) in enumerate(etiq.iterrows())], index=etiq.index)
etiq2 = pd.concat([etiq, decisions], axis=1)
for cua, g in etiq2.groupby("cua"):
    print(f"{cua:16s} n={len(g):4d} ({len(g) / len(etiq2):.1%})  encert de la causa proposta {accuracy_score(g['causa_registrada'], g['causa_proposta']):.3f}")
print("accions llancades:", pd.Series([a.split(':')[0] for l in etiq2["accions"] for a in l]).value_counts().to_dict())
r = etiq2.iloc[6]; print(r["id_incidencia"], "| real:", r["causa_registrada"], "→", r["cua"], r["causa_proposta"], r["confianca"], r["accions"]); [print("   ", t) for t in r["traca"]]
for u in (0.5, 0.6, 0.7, 0.8):
    auto = etiq2[(P_log.max(1) >= u) & (etiq2["valor_comanda"] <= VALOR_ALT)]
    print(f"llindar {u}: automatica {len(auto) / len(etiq2):.1%}, encert {accuracy_score(auto['causa_registrada'], auto['causa_proposta']):.3f}")
model = crear_model().fit(etiq[COLS], y)                                        # model final amb les 1.003 etiquetades
sense = inc[inc["causa_registrada"].isna()].copy(); P_sense = model.predict_proba(sense[COLS])
dec_sense = pd.DataFrame([decidir(f, P_sense[i]) for i, (_, f) in enumerate(sense.iterrows())], index=sense.index)
auto = dec_sense["cua"] == "automatica"
print("Sense etiqueta:", dec_sense["cua"].value_counts().to_dict(), "| encert real (ocult) automatica:", round(accuracy_score(sense.loc[auto, "causa"], dec_sense.loc[auto, "causa_proposta"]), 3),
      "| humana:", round(accuracy_score(sense.loc[~auto, "causa"], dec_sense.loc[~auto, "causa_proposta"]), 3))

automatica       n= 649 (64.7%)  encert de la causa proposta 0.858
revisio_humana   n= 354 (35.3%)  encert de la causa proposta 0.517
accions llancades: {'reenviament_des_de': 290, 'obrir_traca': 223, 'avis_compres': 104, 'reclamacio_transportista': 67}
I7010 | real: error_picking → revisio_humana error_picking 0.808 ['reenviament_des_de:zaragoza']
    R0: valor 349 € > 300 € → sempre ho revisa una persona
    R4: error de picking → reenviament immediat i avis al magatzem
llindar 0.5: automatica 76.5%, encert 0.821
llindar 0.6: automatica 64.7%, encert 0.858
llindar 0.7: automatica 53.8%, encert 0.906
llindar 0.8: automatica 45.8%, encert 0.919
Sense etiqueta: {'automatica': 697, 'revisio_humana': 300} | encert real (ocult) automatica: 0.852 | humana: 0.52

import joblib
card = {"nom": "Diagnostic de causa d'incidencies NovaMarket (cas 9)", "versio": "0.1.0-prototip", "data": "2026-08-18",
        "model": "Regressio logistica multiclasse: magatzem, transportista, 4 simptomes, dies des de l'enviament, valor de la comanda",
        "dades": {"incidencies": int(len(inc)), "etiquetades": int(len(etiq)), "classes": CLASSES},
        "metriques_cv5": {"exactitud": 0.738, "f1_macro": 0.658, "linia_base_xarxa_bayesiana": 0.719, "linia_base_majoritaria": 0.314},
        "cues": {"llindar_automatica": LLINDAR_AUTO, "valor_alt_revisio": VALOR_ALT, "fraccio_automatica": 0.647, "encert_automatica": 0.858},
        "us_previst": "Proposar causa i accions a l'agent; decidir automaticament nomes a la cua automatica i amb accions reversibles",
        "us_no_previst": "Imputar responsabilitat a un transportista o empleat sense revisio humana; fer servir la causa per penalitzar",
        "limitacions": ["fallada_proveidor es detecta malament (recall 0,22)", "nomes 1.003 etiquetes, registrades a la meitat dels casos",
                        "dades sintetiques coherents amb les CPT de 06-03: validar amb dades reals abans del pilot"]}
referencia = {"taxa_simptomes": etiq[SIMPTOMES].mean().round(3).to_dict(), "frac_automatica": 0.647,
              "dist_causa_proposta": etiq2["causa_proposta"].value_counts(normalize=True).round(3).to_dict(),
              "vores_dies": [0, 2, 4, 6, 8, 10, 14, None], "freq_dies": None}
PSI_AVIS, PSI_ALERTA, DIF_TAXA = 0.10, 0.25, 0.08
def psi(ref, nou, eps=1e-4):
    r, n = np.clip(np.asarray(ref, float), eps, None), np.clip(np.asarray(nou, float), eps, None)
    return float(np.sum((n - r) * np.log(n / r)))
def frequencies(valors, vores):
    b = [-np.inf if x is None else x for x in vores]; b[-1] = np.inf
    c, _ = np.histogram(valors, bins=b); return (c / c.sum()).tolist()
referencia["freq_dies"] = frequencies(etiq["dies_des_enviament"], referencia["vores_dies"])
json.dump(card, open("model_card_incidencies.json", "w"), indent=2, ensure_ascii=False)
json.dump(referencia, open("referencia_deriva_incidencies.json", "w"), indent=2); joblib.dump(model, "model_incidencies.joblib")

def comprovar_deriva(lot, referencia, model):
    P = model.predict_proba(lot[COLS]); dec = pd.DataFrame([decidir(f, P[i]) for i, (_, f) in enumerate(lot.iterrows())])
    avisos, v = [], psi(referencia["freq_dies"], frequencies(lot["dies_des_enviament"], referencia["vores_dies"]))
    if v > PSI_AVIS: avisos.append(f"PSI dies = {v:.3f}")
    for s, t in referencia["taxa_simptomes"].items():
        if abs(lot[s].mean() - t) > DIF_TAXA: avisos.append(f"taxa {s}: {lot[s].mean():.3f} davant de {t:.3f}")
    fa = (dec["cua"] == "automatica").mean()
    if abs(fa - referencia["frac_automatica"]) > DIF_TAXA: avisos.append(f"fraccio automatica {fa:.3f} davant de {referencia['frac_automatica']:.3f}")
    dc = dec["causa_proposta"].value_counts(normalize=True)
    for c, t in referencia["dist_causa_proposta"].items():
        if abs(dc.get(c, 0) - t) > DIF_TAXA: avisos.append(f"causa proposta {c}: {dc.get(c, 0):.3f} davant de {t:.3f}")
    estat = "ALERTA" if v > PSI_ALERTA or len(avisos) >= 2 else ("AVIS" if avisos else "OK")
    return estat, avisos
print("Mes normal:", comprovar_deriva(generar_incidencies(400, llavor=7), referencia, model))
p_transport = {"zaragoza": [0.20, 0.55, 0.10, 0.06, 0.09], "getafe": [0.15, 0.45, 0.08, 0.25, 0.07]}   # el dany en transport es dispara
print("Mes amb problema de transport:", comprovar_deriva(generar_incidencies(400, llavor=8, p_causa=p_transport), referencia, model))

Mes normal: ('OK', [])
Mes amb problema de transport: ('ALERTA', ['taxa paquet_danyat: 0.525 davant de 0.259', 'taxa producte_equivocat: 0.150 davant de 0.282', 'taxa no_arriba: 0.177 davant de 0.260', 'fraccio automatica 0.782 davant de 0.647', 'causa proposta error_picking: 0.233 davant de 0.345', 'causa proposta dany_transport: 0.497 davant de 0.240'])