ক্যাপস্টোন — বাজারঘরের churn আর lifetime value প্রকল্প

# bazar_churn.py — বাজারঘর ক্যাপস্টোন (কাল্পনিক, seeded)
import numpy as np
import pandas as pd

START, END = pd.Timestamp("2024-07-01"), pd.Timestamp("2026-08-31")
EXP = pd.Timestamp("2025-12-01")       # কুপন-পরীক্ষা
MARGIN, COUPON = 0.20, 100             # margin, কুপন (৳)
DISTRICTS = ["Dhaka", "Chattogram", "Sylhet", "Rajshahi", "Khulna"]   # প্রথম দুটি metro
FEATURES = ["recency", "tenure", "n_orders", "n_90", "spend_90", "aov",
            "late_share", "ddays", "visits_30"]

def _chain(rng, t0, lam, p0, metro, K=90):
    """অর্ডারের সারি; প্রতি অর্ডারের পর p0 (+0.25 দেরিতে) সম্ভাবনায় বিদায়"""
    n = t0.size
    gap = rng.exponential(1.0, (n, K)) / lam[:, None]
    gap[:, 0] = 0
    t = t0[:, None] + np.cumsum(gap, axis=1)
    dd = np.where(metro[:, None], 1 + rng.poisson(0.8, (n, K)), 2 + rng.poisson(1.9, (n, K)))
    late = dd > np.where(metro, 2, 4)[:, None]             # প্রতিশ্রুতি 2 বা 4 দিন
    stay = rng.uniform(size=(n, K)) >= p0[:, None] + 0.25 * late
    kept = np.cumprod(np.c_[np.ones(n, bool), stay[:, :-1]], axis=1).astype(bool)
    gone = np.where(kept[:, -1], np.inf, np.where(kept, t, -np.inf).max(axis=1))
    i, k = np.nonzero(kept)
    return i, t[i, k], dd[i, k], late[i, k], t, kept, gone

def simulate(n=5000, seed=72):
    rng = np.random.default_rng(seed)
    T, e = (END - START).days, (EXP - START).days
    dist = rng.choice(5, n, p=[0.40, 0.20, 0.15, 0.15, 0.10])
    metro = dist < 2
    lam = rng.gamma(2.0, 0.012, n)                     # দিনে অর্ডারের হার
    p0 = rng.beta(1.2, 16, n)                          # বিদায়ের সম্ভাবনা
    aov = rng.gamma(5.0, 120, n)                       # গড় অর্ডারের টাকা
    i, t, dd, late, tm, kept, gone = _chain(rng, rng.integers(0, T - 30, n).astype(float), lam, p0, metro)
    last_before = np.where(kept & (tm < e), tm, -np.inf).max(axis=1)
    nxt = np.where(kept & (tm >= e), tm, np.inf).min(axis=1)
    treat = np.where(last_before >= e - 180, rng.integers(0, 2, n), -1)   # -1 = পরীক্ষার বাইরে
    pull = (treat == 1) & np.isfinite(nxt) & (nxt >= e + 90) & (rng.uniform(size=n) < 0.20)
    back = (treat == 1) & (gone < e) & (rng.uniform(size=n) < 0.35)       # ফিরে আসা
    b = np.nonzero(back)[0]
    tb0 = e + rng.uniform(0, 90, b.size)
    j, tb, db, lb, _, _, gb = _chain(rng, tb0, lam[b], p0[b], metro[b])
    q = np.nonzero(pull)[0]
    c = np.r_[i, b[j], q]
    od = pd.DataFrame({"customer": c, "day": np.floor(np.r_[t, tb, e + rng.uniform(0, 90, q.size)]),
                       "amount": np.round(aov[c] * rng.gamma(8, 1 / 8, c.size)),
                       "ddays": np.r_[dd, db, np.where(metro[q], 2, 4)],
                       "late": np.r_[late, lb, np.zeros(q.size, bool)]})
    od = od[od.day <= T]
    od["date"] = START + pd.to_timedelta(od.day, unit="D")
    back_at, gone2 = np.full(n, np.inf), np.full(n, -np.inf)
    back_at[b], gone2[b] = tb0, gb                     # লুকোনো সত্য
    cust = pd.DataFrame({"district": np.array(DISTRICTS)[dist], "metro": metro.astype(int),
                         "treat": treat, "lam": lam, "gone": gone,
                         "back_at": back_at, "gone2": gone2})
    return od.sort_values(["date", "customer"]).reset_index(drop=True)[
        ["customer", "date", "amount", "ddays", "late"]], cust

ORDERS, CUST = simulate()

def snapshot(cut, label=True, horizon=180):
    """feature: cut-এর আগে; y: ৯০ দিনে অর্ডার নেই; m: ১৮০ দিনের margin"""
    cut = pd.Timestamp(cut)
    h = ORDERS[ORDERS.date < cut]
    d = (cut - h.date).dt.days
    g = h.assign(d=d, a90=h.amount.where(d < 90, 0), n90=d < 90).groupby("customer")
    X = pd.DataFrame({"recency": g.d.min(), "tenure": g.d.max(), "n_orders": g.size(),
                      "n_90": g.n90.sum(), "spend_90": g.a90.sum(), "aov": g.amount.mean(),
                      "late_share": g.late.mean(), "ddays": g.ddays.mean()})
    X = X[X.recency < 180]                             # unit: শেষ ১৮০ দিনে সক্রিয়
    c = CUST.reindex(X.index)
    now = (cut - START).days                           # এখনো আছেন? (লুকোনো)
    on = (c.gone > now) | ((c.back_at <= now) & (c.gone2 > now))
    rng = np.random.default_rng(cut.toordinal())       # app visit, শেষ ৩০ দিন
    X["visits_30"] = rng.poisson(30 * c.lam.to_numpy() * np.where(on.to_numpy(), 2, 0.4))
    X["metro"] = c.metro.to_numpy()
    if not label:
        return X
    f = ORDERS[(ORDERS.date >= cut) & (ORDERS.date < cut + pd.Timedelta(days=horizon))]
    y = pd.Series((~X.index.isin(f[f.date < cut + pd.Timedelta(days=90)].customer)).astype(int),
                  index=X.index)
    m = (f.groupby("customer").amount.sum() * MARGIN).reindex(X.index, fill_value=0)
    return X, y, m

import numpy as np
import pandas as pd
import bazar_churn as bc
from bazar_churn import ORDERS, CUST, EXP, FEATURES, snapshot

od = ORDERS
print("অর্ডার:", od.shape, "| ক্রেতা:", od.customer.nunique(), "of", len(CUST))
print("তারিখ:", od.date.min().date(), "→", od.date.max().date())
print("টাকা/অর্ডার: median", od.amount.median(), "| p99", od.amount.quantile(0.99))
print("দেরির হার:", od.groupby(CUST.metro.reindex(od.customer).to_numpy())
      .late.mean().round(3).rename({0: "other", 1: "metro"}).to_dict())
print("জেলা:", CUST.district.value_counts().to_dict())
print("কুপন-পরীক্ষা", EXP.date(), "arm:", CUST.treat.value_counts().sort_index().to_dict())
checks = {"null নেই": not od.isna().any().any(),
          "নকল সারি নেই": not od.duplicated().any(),
          "টাকা > 0": bool((od.amount > 0).all()),
          "ভবিষ্যতের তারিখ নেই": bool((od.date <= bc.END).all())}
print(checks)
assert all(checks.values())

-- :cutoff = '2025-04-01'; প্রতিটি feature শুধু cutoff-এর আগের অর্ডার থেকে
SELECT customer,
       :cutoff - MAX(date)                         AS recency,
       :cutoff - MIN(date)                         AS tenure,
       COUNT(*)                                    AS n_orders,
       COUNT(*) FILTER (WHERE date >= :cutoff - 90) AS n_90,
       AVG(amount)                                 AS aov,
       AVG(late::int)                              AS late_share
FROM orders
WHERE date < :cutoff
GROUP BY customer
HAVING :cutoff - MAX(date) < 180;               -- unit: শেষ ১৮০ দিনে সক্রিয়

CUTS = pd.date_range("2025-01-01", "2025-09-01", freq="MS")   # train-এর cutoff
TEST, LAUNCH = pd.Timestamp("2026-03-01"), pd.Timestamp("2026-09-01")
P = {c: snapshot(c) for c in [*CUTS, EXP, TEST]}
rows = [(c.date(), len(y), y.mean(), m.mean()) for c, (X, y, m) in P.items()]
T = pd.DataFrame(rows, columns=["cutoff", "n", "churn_90", "margin_180"])
print(T.round(3).to_string(index=False))

# leakage test: cutoff-এর পরের সব অর্ডার মুছে দিলে feature এক থাকতে হবে
full = bc.ORDERS
for c in [CUTS[3], TEST]:
    bc.ORDERS = full[full.date < c]
    same = snapshot(c, label=False).equals(P[c][0])
    bc.ORDERS = full
    print("leakage test", c.date(), "features unchanged:", same)
    assert same
X, y, m = P[CUTS[0]]
print(X.head(3).round(2).to_string())

from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import FunctionTransformer, StandardScaler
from sklearn.metrics import roc_auc_score, brier_score_loss

def stack(cs):
    S = [P[c] for c in cs]
    return [pd.concat([s[i] for s in S]) for i in range(3)]
make_lr = lambda: make_pipeline(FunctionTransformer(np.log1p), StandardScaler(),
                                LogisticRegression(max_iter=1000))
make_hgb = lambda: HistGradientBoostingClassifier(max_iter=150, learning_rate=0.05,
                       max_leaf_nodes=15, early_stopping=False, random_state=72)
res = []
for k in range(2, 6):                       # rolling origin: ৪টি fold
    Xt, yt, _ = stack(CUTS[:k + 1]); va = CUTS[k + 3]   # মাঝে ৯০ দিনের ফাঁক
    Xv, yv, _ = P[va]
    r = {"valid": va.strftime("%b"), "n_train": len(yt), "rule": roc_auc_score(yv, Xv.recency),
         "base_brier": brier_score_loss(yv, np.full(len(yv), yt.mean()))}
    for name, make in [("lr", make_lr), ("hgb", make_hgb)]:
        p = make().fit(Xt[FEATURES], yt).predict_proba(Xv[FEATURES])[:, 1]
        r[name], r[name + "_brier"] = roc_auc_score(yv, p), brier_score_loss(yv, p)
    res.append(r)
R = pd.DataFrame(res).set_index("valid")
print(R.round(3).to_string())
print("mean:", R.mean(numeric_only=True).round(3).to_dict())
print("lr − hgb AUC প্রতি fold:", (R.lr - R.hgb).round(3).tolist())

from sklearn.calibration import CalibratedClassifierCV
from sklearn.frozen import FrozenEstimator

def ece(y, p, bins=10):
    k = np.minimum((p * bins).astype(int), bins - 1)
    return sum(abs(y[k == b].mean() - p[k == b].mean()) * (k == b).mean()
               for b in range(bins) if (k == b).any())
Xt, yt, _ = stack(CUTS[:6])                       # Jan–Jun: চূড়ান্ত train
lr = make_lr().fit(Xt[FEATURES], yt)
Xc, yc, _ = P[CUTS[7]]                            # Aug: calibration-এর ডেটা
iso = CalibratedClassifierCV(FrozenEstimator(lr), method="isotonic").fit(Xc[FEATURES], yc)
Xs, ys, _ = P[CUTS[8]]                            # Sep: যাচাই
for name, mdl in [("lr", lr), ("lr+isotonic", iso)]:
    p = mdl.predict_proba(Xs[FEATURES])[:, 1]
    print(f"{name:12s} Brier {brier_score_loss(ys, p):.4f}  ECE {ece(ys.to_numpy(), p):.4f}"
          f"  mean p {p.mean():.3f} vs rate {ys.mean():.3f}")
p = lr.predict_proba(Xs[FEATURES])[:, 1]
tab = pd.DataFrame({"bin": pd.cut(p, np.linspace(0, 1, 6)), "p": p, "y": ys.to_numpy()})
print(tab.groupby("bin", observed=True).agg(n=("y", "size"), mean_p=("p", "mean"),
                                            churn=("y", "mean")).round(3).to_string())

# test: একবার, চূড়ান্ত model (lr, Jan–Jun) — এর পরে আর কোনো বদল নয়
Xte, yte, mte = P[TEST]
pte = lr.predict_proba(Xte[FEATURES])[:, 1]
rng = np.random.default_rng(72)
boot = []
for _ in range(300):
    i = rng.integers(0, len(yte), len(yte))
    boot.append(roc_auc_score(yte.iloc[i], pte[i]))
TESTRES = {"n": len(yte), "churn": yte.mean(), "auc": roc_auc_score(yte, pte),
           "auc_lo": np.quantile(boot, 0.025), "auc_hi": np.quantile(boot, 0.975),
           "rule_auc": roc_auc_score(yte, Xte.recency),
           "brier": brier_score_loss(yte, pte), "ece": ece(yte.to_numpy(), pte)}
for k, v in TESTRES.items():
    print(f"{k:9s} {v:.3f}")
top = pte >= np.quantile(pte, 0.7)
print("শীর্ষ ৩০% ঝুঁকির মধ্যে আসল churn:", round(yte[top].mean(), 3),
      "| ধরা পড়া churner-এর ভাগ:", round(yte[top].sum() / yte.sum(), 3))

from sklearn.ensemble import HistGradientBoostingRegressor
# CLV: থাকলে ১৮০ দিনের margin; শুধু থেকে-যাওয়াদের সারিতে
Xa, ya, ma = stack(CUTS[:3])                      # Jan–Mar: ১৮০ দিন শেষ হয় Aug-এ
clv = HistGradientBoostingRegressor(loss="poisson", max_iter=150, learning_rate=0.05,
          max_leaf_nodes=15, random_state=72).fit(Xa[FEATURES][ya == 0], ma[ya == 0])
Xk, yk, mk = P[CUTS[5]]                           # Jun: conformal calibration
s = (yk == 0).to_numpy()
fk = clv.predict(Xk[FEATURES][s])
score = np.abs(mk[s] - fk) / fk                   # আপেক্ষিক ভুল
n_cal, alpha = s.sum(), 0.2
q = np.sort(score)[int(np.ceil((n_cal + 1) * (1 - alpha))) - 1]
st = (yte == 0).to_numpy()                        # test: যাঁরা থেকেছেন
f = clv.predict(Xte[FEATURES][st])
lo, hi = np.maximum(f * (1 - q), 0), f * (1 + q)
truth = mte[st].to_numpy()
CLVRES = {"n_cal": n_cal, "q": q, "coverage": ((truth >= lo) & (truth <= hi)).mean(),
          "median_width": np.median(hi - lo), "mean_pred": f.mean(), "mean_true": truth.mean()}
for k, v in CLVRES.items():
    print(f"{k:12s} {v:8.3f}")
i = np.argsort(f)[[len(f) // 2, int(len(f) * 0.95)]]
for j in i:
    print(f"ক্রেতা: অনুমান ৳{f[j]:.0f}, 80% পরিসর [{lo[j]:.0f}, {hi[j]:.0f}], আসল ৳{truth[j]:.0f}")

from sklearn.inspection import permutation_importance
pi = permutation_importance(lr, Xte[FEATURES], yte, scoring="roc_auc",
                            n_repeats=5, random_state=72)
imp = pd.DataFrame({"auc_drop": pi.importances_mean, "sd": pi.importances_std},
                   index=FEATURES).sort_values("auc_drop", ascending=False)
print(imp.round(3).head(5).to_string())

# একজন ক্রেতা: linear model-এ log-odds = intercept + Σ coef × z (z = scaled log1p)
sc, m = lr[1], lr[2]
z = sc.transform(np.log1p(Xte[FEATURES]))
who = int(np.argmin(np.abs(pte - 0.80)))              # ঝুঁকি প্রায় ০.৮০
contrib = pd.Series(m.coef_[0] * z[who], index=FEATURES).sort_values(key=abs, ascending=False)
print("\nক্রেতা", Xte.index[who], "| কাঁচা মান:",
      Xte.iloc[who][["recency", "n_orders", "visits_30", "late_share"]].round(2).to_dict())
print("intercept", round(m.intercept_[0], 3), "+ অবদান:")
print(contrib.round(3).head(5).to_string())
logit = m.intercept_[0] + contrib.sum()
print(f"মোট log-odds {logit:.3f} → p = {1 / (1 + np.exp(-logit)):.3f} | model: {pte[who]:.3f}")

# জেলা-দল শুধু যাচাইয়ের জন্য; model-এর feature-এ নেই
grp = np.where(Xte.metro == 1, "metro", "other")
thr = np.quantile(pte, 0.7)                        # শীর্ষ ৩০% = "ঝুঁকিতে"
rows = {}
for g in ["metro", "other"]:
    s = grp == g
    y, p = yte[s].to_numpy(), pte[s]
    rows[g] = {"n": s.sum(), "churn": y.mean(), "mean_p": p.mean(), "auc": roc_auc_score(y, p),
               "flag_rate": (p >= thr).mean(), "recall": (p[y == 1] >= thr).mean(),
               "precision": y[p >= thr].mean(), "late_share": Xte.late_share[s].mean()}
FAIR = pd.DataFrame(rows).T
print(FAIR.round(3).to_string())
rng = np.random.default_rng(72)
d = []
for _ in range(300):                               # recall-এর পার্থক্যের bootstrap
    i = rng.integers(0, len(yte), len(yte))
    y, p, g = yte.to_numpy()[i], pte[i], grp[i]
    r = [(p[(g == k) & (y == 1)] >= thr).mean() for k in ["other", "metro"]]
    d.append(r[0] - r[1])
print("recall: other − metro =", round(FAIR.recall["other"] - FAIR.recall["metro"], 3),
      "| 95% CI", np.quantile(d, [0.025, 0.975]).round(3))

from bazar_churn import COUPON
# ১ ডিসেম্বর ২০২৫-এর এলোমেলো কুপন-পরীক্ষা
Xe, ye, me = P[EXP]
pe = lr.predict_proba(Xe[FEATURES])[:, 1]          # শুধু আগের তথ্য
EDGES = np.quantile(pe, [0.25, 0.5, 0.75])         # ঝুঁকির চারটি ভাগ
E = pd.DataFrame({"risk": np.digitize(pe, EDGES) + 1, "t": CUST.treat[Xe.index].to_numpy(),
                  "churn": ye.to_numpy(), "m": me.to_numpy()})
E["net"] = E.m - COUPON * (E.t == 1) * (1 - E.churn)    # কিনলে কুপন খরচ
g = E.groupby(["risk", "t"])[["churn", "net"]]
mu, se = g.mean().unstack(), (g.std() / np.sqrt(g.count())).unstack()
UP = pd.DataFrame({"n": E.groupby("risk").size(), "churn_ctrl": mu.churn[0],
                   "uplift": mu.churn[0] - mu.churn[1], "se": np.hypot(se.churn[0], se.churn[1]),
                   "net_taka": mu.net[1] - mu.net[0], "net_se": np.hypot(se.net[0], se.net[1])})
print(UP.round(3).to_string())

def expected_profit(X):
    """uplift × CLV − কুপন × P(ব্যবহার)"""
    p = lr.predict_proba(X[FEATURES])[:, 1]
    risk = np.digitize(p, EDGES) + 1
    u = UP.uplift.reindex(risk).to_numpy()
    v = clv.predict(X[FEATURES])                   # অনুমান!
    return pd.DataFrame({"p": p, "risk": risk, "u": u, "clv": v,
                         "profit": u * v - COUPON * (1 - p + u)}, index=X.index)
chk = expected_profit(Xe).groupby("risk").profit.mean()
print("\nপরীক্ষার দিনে ৳/জন: model-এর হিসাব বনাম পরীক্ষায় মাপা")
print(pd.DataFrame({"model": chk, "measured": UP.net_taka}).round(1).T.to_string())

import matplotlib.pyplot as plt
XL = snapshot(LAUNCH, label=False)                 # আজ, ১ সেপ্টেম্বর ২০২৬: label নেই
D = expected_profit(XL)
D["offer"] = D.profit > 0
top30 = D.p >= D.p.quantile(0.7)
POL = {"nobody": 0.0, "everyone": D.profit.sum(),
       "top 30% risk": D.profit[top30].sum(), "profit > 0": D.profit[D.offer].sum()}
print({k: round(v) for k, v in POL.items()}, "| offers:", int(D.offer.sum()), "of", len(D))
DT = D.groupby("risk").agg(n=("p", "size"), mean_p=("p", "mean"), uplift=("u", "first"),
                          clv=("clv", "mean"), offers=("offer", "sum"),
                          exp_profit=("profit", lambda s: s[s > 0].sum()))
print(DT.round(2).to_string())
grp = XL.metro.map({1: "metro", 0: "other"})
print("কুপন পাবেন (ভাগ):", D.offer.groupby(grp).mean().round(3).to_dict(),
      "| গড় CLV:", D.clv.groupby(grp).mean().round(0).to_dict())
s = D.sort_values("profit", ascending=False).profit.cumsum().to_numpy()
r = D.sort_values("p", ascending=False).profit.cumsum().to_numpy()
fig, ax = plt.subplots(figsize=(6, 3.4))
ax.plot(s, label="sorted by expected profit"); ax.plot(r, label="sorted by churn risk")
ax.axhline(0, color="grey", lw=0.8)
ax.set(xlabel="customers offered", ylabel="expected profit (BDT)", title="Offer policy at launch")
ax.legend(); fig.subplots_adjust(bottom=0.16, left=0.15); plt.show()

from scipy.stats import norm
za, zb = norm.ppf(1 - 0.05 / 2), norm.ppf(0.80)        # α = 0.05 (দুই দিক), power 80%
Esel = E[E.risk >= 3]                                  # একই ধরনের ক্রেতা
sigma = Esel.net.std()                                 # net margin-এর SD
delta = D.profit[D.offer].mean()                       # প্রত্যাশিত লাভ/জন (৳)
n_taka = int(np.ceil(2 * (za + zb) ** 2 * sigma**2 / delta**2))
p1 = Esel[Esel.t == 0].churn.mean()                    # holdout-এর churn
p2 = p1 - 0.10                                         # ১০ বিন্দু কম
pbar = (p1 + p2) / 2
top = za * np.sqrt(2 * pbar * (1 - pbar)) + zb * np.sqrt(p1 * (1 - p1) + p2 * (1 - p2))
n_churn = int(np.ceil(top**2 / (p1 - p2) ** 2))
ABPLAN = {"sigma": sigma, "delta": delta, "n_per_arm_taka": n_taka,
          "months_taka": 2 * n_taka / D.offer.sum(), "p1": p1, "n_per_arm_churn": n_churn}
for k, v in ABPLAN.items():
    print(f"{k:16s} {v:9.2f}")
# score PSI: test বনাম আজ
b = np.quantile(pte, np.linspace(0, 1, 11)); b[[0, -1]] = 0, 1
a1, a2 = np.histogram(pte, b)[0] / len(pte), np.histogram(D.p, b)[0] / len(D)
PSI = np.sum((a2 - a1) * np.log(a2 / a1))
print(f"score PSI, test → launch: {PSI:.3f}  (সতর্কতা ≥ 0.1, ব্যবস্থা ≥ 0.25)")

# Model card — বাজারঘর churn-v1 আর clv-v1 (কাল্পনিক ডেটা)
## উদ্দেশ্য
- মাসিক retention কুপনের তালিকা; সিদ্ধান্ত marketing দলের
## নিষেধ
- দাম বাড়ানো, সেবা কমানো, একক ক্রেতা সম্পর্কে রায়
## Model আর ডেটা
- churn: log1p + StandardScaler + LogisticRegression, 9টি feature, train cutoff Jan–Jun 2025
- clv: HistGradientBoostingRegressor(loss="poisson"); scikit-learn 1.8.0
## Test (cutoff 1 Mar 2026, n = 2604, একবার)
- AUC 0.775 [0.756, 0.793]; recency-নিয়ম 0.689; ECE 0.029
- CLV 80% conformal পরিসর: coverage 0.829
## দলভিত্তিক (metro বনাম বাকি)
- calibration-এর ফাঁক ≤ 0.016; churner-দের "ঝুঁকিতে" আসার হার 0.442 বনাম 0.536
- লাভের নিয়মে কুপনের হার 0.458 বনাম 0.421: CLV দেরির জন্য বাইরের ক্রেতাকে কম মূল্য দেয়
## জানা সীমা আর অনুমান
- uplift: Dec 2025-এর চার ঝুঁকি-ভাগ (±0.03–0.04); মৌসুমে বদলাতে পারে
- অনুমান: কুপনে ফেরা ক্রেতা = সাধারণ ক্রেতা; A/B-তে যাচাই
## নজরদারি
- মাসিক PSI, ৯০ দিন পরে ECE, স্থায়ী 10% holdout; মালিক: বাজারঘর ডেটা দল

def memo_numbers():
    """memo-র প্রতিটি সংখ্যা আগের ব্লকের ফল থেকে"""
    return {"test_auc": TESTRES["auc"], "auc_lo": TESTRES["auc_lo"], "auc_hi": TESTRES["auc_hi"],
            "rule_auc": TESTRES["rule_auc"], "ece": TESTRES["ece"],
            "clv_coverage": CLVRES["coverage"], "recall_gap": FAIR.recall["other"] - FAIR.recall["metro"],
            "uplift_top": UP.uplift[4], "measured_top": UP.net_taka[4],
            "offers": float(D.offer.sum()), "customers": float(len(D)),
            "profit_policy": POL["profit > 0"] / 1000, "profit_top30": POL["top 30% risk"] / 1000,
            "profit_all": POL["everyone"] / 1000, "n_per_arm": ABPLAN["n_per_arm_taka"], "psi": PSI}
MEMO = {"test_auc": 0.775, "auc_lo": 0.756, "auc_hi": 0.793, "rule_auc": 0.689, "ece": 0.029,
        "clv_coverage": 0.829, "recall_gap": 0.094, "uplift_top": 0.279, "measured_top": 58.4,
        "offers": 1199, "customers": 2700, "profit_policy": 48.6, "profit_top30": 37.0,
        "profit_all": 1.5, "n_per_arm": 472, "psi": 0.042}
N = memo_numbers()
digits = lambda v: len(str(v).split(".")[1]) if "." in str(v) else 0
bad = {k: (v, N[k]) for k, v in MEMO.items() if round(N[k], digits(v)) != v}
assert not bad, f"memo-র সংখ্যা কোডের সঙ্গে মেলে না: {bad}"
print(f"memo-র {len(MEMO)}টি সংখ্যাই কোড থেকে আবার মিলেছে")
print(f"সুপারিশ: {MEMO['offers']:.0f} জনকে কুপন, প্রত্যাশিত লাভ ৳{MEMO['profit_policy']} হাজার,"
      f" A/B-তে প্রতি দলে {MEMO['n_per_arm']} জন")