Distribution shift — covariate, label আর concept shift ধরা ও সামলানো

এতদিন প্রায় প্রতিটি পর্বে একটি নীরব অনুমান ছিল: test ডেটা training ডেটার মতো একই বণ্টন থেকে আসে। বাস্তবে model চালু হয় ভবিষ্যতে, নতুন জায়গায়, নতুন নিয়মে। AI-এর ভিত্তি কোর্সের পর্ব ৭৪-এ data drift, PSI, KS test, label delay আর ট্রিগার দিয়ে retraining দেখেছেন, আর পর্ব ৫৬-এ সময় ধরে ভাগ করার কারণ। এই পর্ব আরও গভীরে যায়: shift-এর ধরনগুলো গণিতে আলাদা করা, সব feature একসঙ্গে যাচাই, আর label ছাড়াই কিছু shift সংশোধন। চারটি চালানো যায় এমন ব্লক পাতাতেই চলে (ব্রাউজারের Python, NumPy, pandas, SciPy, scikit-learn আর matplotlib); প্রথমবার scikit-learn নামতে প্রায় দশ সেকেন্ড লাগে।

১ · তিন ধরনের shift — P(x, y)-এর কোন অংশ বদলাল

ডেটা আর label-এর যৌথ বণ্টন P(x, y)-কে দুইভাবে ভাঙা যায় (AI-এর ভিত্তি কোর্সের পর্ব ৩৫-এর গুণের নিয়ম):

P(x, y) = P(x) · P(y | x) = P(y) · P(x | y)

এখানে x হলো feature (অর্ডারের দাম, দূরত্ব, পোশাক কি না, COD কি না), আর y হলো label (অর্ডার ফেরত এসেছে কি না)। Training-এর বণ্টন P আর ব্যবহারের সময়ের বণ্টন Q আলাদা হলে তাকে বলে distribution shift বা dataset shift. কোন অংশ বদলাল, তা দিয়ে তিনটি প্রধান ধরন:

বাস্তবে এরা প্রায়ই মিশে আসে। নতুন জেলায় হয়তো courier-ও আলাদা, তাই একই দূরত্বে ঝুঁকিও বদলায়। একটি নির্দিষ্ট দলের (ধরুন নতুন ক্রেতা) ভাগ বদলালে তাকে subpopulation shift বলে, যা covariate shift-এরই একটি রূপ। নামকরণও সব বইয়ে এক নয়: কেউ ধীরে বদলকে “drift” আর এক ধাক্কার বদলকে “shift” বলেন। এই পর্বে নাম নয়, প্রশ্নটি জরুরি: কোন অংশটি স্থির আছে বলে ধরে নিচ্ছি? সেই অনুমানই ঠিক করে কোন পদ্ধতি কাজ করবে।

২ · বাজারঘরের ফেরত-অর্ডার আর তিনটি দৃশ্য

নিচের module কাল্পনিক বাজারঘরের অর্ডার বানায়: দামের log (logp), ঠিকানার দূরত্ব km-এ (dist), পোশাক কি না (cloth), আর ক্যাশ অন ডেলিভারি কি না (cod). ফেরতের আসল নিয়মে দূরত্ব ১০ km-এর পর ঝুঁকি দ্রুত বাড়ে (max(0, dist − 10) পদ), যা একটি সরল logistic regression পুরোপুরি ধরতে পারে না; এটি পরে গুরুত্বপূর্ণ হবে। Training-এ ৩,০০০টি অর্ডার, ফেরতের হার প্রায় ২৫%. তারপর ২,০০০টি অর্ডারের চারটি “ব্যবহারের” দৃশ্য: same (কোনো বদল নেই, তুলনার জন্য), district (নতুন জেলা: গড় দূরত্ব ৬ থেকে ১৪ km, COD ৫০% থেকে ৭৫%), eid (একটি বড় ভান্ডার থেকে ফেরত আর না-ফেরত আলাদা করে তুলে হার ৪৫% করা, তাই P(x | y) হুবহু একই), আর policy (x একই, কিন্তু COD-এর প্রভাব +০.৬ থেকে −১.৪). month() অংশ ৮-এর জন্য: মাস ৯ থেকে ১৬-র মধ্যে নীতিটি ধীরে চালু হয়।

# বাজারঘর (কাল্পনিক দোকান): ফেরত-অর্ডার আর তিন ধরনের shift, seeded ডেটা
import numpy as np
import pandas as pd

FEATS = ["logp", "dist", "cloth", "cod"]

def make(n, rng, kind="base", t=0.0):
    far = kind == "district"                     # নতুন জেলা: দূরের ঠিকানা, বেশি COD
    price = rng.lognormal(7.0, 0.6, n)
    dist = rng.gamma(4.0, 3.5, n) if far else rng.gamma(2.0, 3.0, n)
    cloth = rng.binomial(1, 0.4, n)
    cod = rng.binomial(1, 0.75 if far else 0.5, n)
    b_cod = 0.6 - 2.0 * t                        # নীতি বদল: t = 0 পুরোনো, t = 1 নতুন
    z = (-2.3 + 0.5 * (np.log(price) - 7) + 1.0 * cloth + b_cod * cod
         + 0.04 * dist + 0.25 * np.maximum(0, dist - 10))
    y = rng.binomial(1, 1 / (1 + np.exp(-z)))
    return pd.DataFrame({"logp": np.log(price), "dist": dist, "cloth": cloth,
                         "cod": cod, "returned": y})

def train_data(n=3000, seed=59):
    return make(n, np.random.default_rng(seed))

def scenario(name, n=2000, seed=590):
    rng = np.random.default_rng(seed)
    if name == "district":
        return make(n, rng, "district")
    if name == "policy":
        return make(n, np.random.default_rng(seed + 4), t=1.0)
    if name == "eid":                            # label shift: P(x | y) একই, হার 0.45
        pool = make(40 * n, rng)
        k = int(0.45 * n)
        pos = pool[pool.returned == 1].sample(k, random_state=seed)
        neg = pool[pool.returned == 0].sample(n - k, random_state=seed)
        return pd.concat([pos, neg]).sample(frac=1, random_state=seed)
    return make(n, np.random.default_rng(seed + 1))    # "same": কোনো shift নেই

def month(m, n=600):                             # ধীরে বদলানো নীতি: মাস 9 থেকে 16
    t = min(1.0, max(0.0, (m - 8) / 8))
    return make(n, np.random.default_rng(5900 + m), t=t)

একটি সতর্কতা: simulation-এ আমরা প্রতিটি দৃশ্যের আসল label জানি, তাই পদ্ধতিগুলোর ভুল মাপা যায়। বাস্তবে নতুন জেলা বা ঈদের প্রথম সপ্তাহে label থাকে না; ফেরত চূড়ান্ত হতে কয়েক সপ্তাহ লাগে। তাই প্রতিটি পদ্ধতির প্রশ্ন: label ছাড়া কী জানা যায়, আর কোন অনুমানের ওপর?

৩ · এক এক feature করে — KS, chi-square আর PSI

AI-এর ভিত্তি কোর্সের পর্ব ৭৪-এ দুটি হাতিয়ার দেখেছেন। Kolmogorov–Smirnov test দুই নমুনার cumulative বণ্টনের সবচেয়ে বড় ফাঁক D মাপে আর একটি p-value দেয়। PSI reference ডেটার quantile দিয়ে bin বানিয়ে প্রতিটি bin-এ পুরোনো ভাগ e আর নতুন ভাগ a তুলনা করে:

PSI = ∑_i (a_i − e_i) · ln(a_i / e_i)

এখানে তিনটি জিনিস যোগ হয়। প্রথম, PSI আসলে কী। ∑ a ln(a/e) হলো KL divergence KL(a‖e), আর ∑ e ln(e/a) হলো KL(e‖a). দুটি যোগ করলে ঠিক PSI আসে। অর্থাৎ PSI হলো দুই দিকের KL-এর যোগফল (Jeffreys divergence), তাই প্রতিসম আর সবসময় ≥ ০. দ্বিতীয়, ০/১ feature-এ KS নয়। cloth বা cod-এর মতো শ্রেণিভিত্তিক feature-এ ২×২ গণনার টেবিলে chi-square test চলে, আর PSI-এর bin হয় শ্রেণিগুলোই। তৃতীয়, সীমাগুলো হাতের নিয়ম। PSI < ০.১ “স্থির”, ০.১–০.২৫ “নজরে রাখুন”, > ০.২৫ “বড় বদল”: ঋণ-scoring-এর চর্চা থেকে আসা প্রচলিত সীমা, কোনো তত্ত্ব থেকে প্রমাণিত নয়। Bin-এর সংখ্যা, নমুনার আকার আর খালি bin-এ কী বসানো হয়, তার ওপর মান বদলায়। নিচের stepper তিনটি bin-এ পুরো হিসাব করে।

৪ · সব feature একসঙ্গে — domain classifier

এক এক feature করে দেখলে একটি বড় ফাঁক থাকে। ধরুন নতুন জেলায় দূরত্ব আর দামের বণ্টন আলাদাভাবে একই, কিন্তু দূরের অর্ডারগুলো এখন বেশি দামি। প্রতিটি univariate test শান্ত, অথচ যৌথ বণ্টন বদলেছে। সমাধানটি সুন্দরভাবে সরল: একটি classifier-কে শেখান, কোন সারি training-এর (d = ০) আর কোনটি নতুন (d = ১)। এর নাম domain classifier, আর পরিসংখ্যানে এটি classifier two-sample test নামে পরিচিত (David Lopez-Paz আর Maxime Oquab ২০১৭ সালে ICLR-এ এর তত্ত্ব আর পরীক্ষা বিশদ করেন)।

• দুই বণ্টন এক হলে কোনো classifier-ই সারিগুলো আলাদা করতে পারবে না: out-of-fold ROC AUC ≈ ০.৫.
• AUC যত ১-এর দিকে, বদল তত সহজে ধরা যায়। কোন feature-এ classifier সবচেয়ে বেশি নির্ভর করছে, তা দেখলে বদলের উৎস বোঝা যায়; এর পদ্ধতি পর্ব ৫৬ (Model বোঝা — permutation importance, PDP আর ICE)-এ দেখেছেন।
• AUC অবশ্যই cross-validation-এর out-of-fold অনুমান থেকে, নইলে একটি নমনীয় model নিজের training সারি মুখস্থ করে AUC বাড়িয়ে দেখাবে।

প্রথম ব্লক চারটি দৃশ্যে প্রতিটি feature-এর PSI আর p-value (সংখ্যার feature-এ KS, ০/১ feature-এ chi-square) ছাপায়, তারপর একটি ছোট HistGradientBoostingClassifier-কে domain classifier বানিয়ে ৩-fold cross_val_predict-এর AUC দেয়।

import numpy as np
import pandas as pd
from scipy.stats import ks_2samp, chi2_contingency
from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.model_selection import cross_val_predict
from sklearn.metrics import roc_auc_score
from bazar_shift import train_data, scenario, FEATS

def psi(ref, new, bins=10):                       # PSI, নিজে লেখা
    edges = np.quantile(ref, np.linspace(0, 1, bins + 1))   # ref-এর quantile-এ bin
    if ref.nunique() <= 2:
        edges = np.array([0, 0.5, 1.0])           # 0/1 feature: দুটি bin
    edges[0], edges[-1] = -np.inf, np.inf
    e = np.clip(np.histogram(ref, edges)[0] / len(ref), 1e-4, None)
    a = np.clip(np.histogram(new, edges)[0] / len(new), 1e-4, None)
    return np.sum((a - e) * np.log(a / e))

def test_p(ref, new):                             # সংখ্যা: KS; 0/1: chi-square
    if ref.nunique() > 2:
        return ks_2samp(ref, new).pvalue
    return chi2_contingency(pd.crosstab(np.r_[ref, new], np.r_[0 * ref, 0 * new + 1])).pvalue

ref, names = train_data(), ["same", "district", "eid", "policy"]
P, Pv, auc = {}, {}, {}
for name in names:
    new = scenario(name)
    P[name] = [psi(ref[f], new[f]) for f in FEATS]
    Pv[name] = [f"{test_p(ref[f], new[f]):.0e}" for f in FEATS]
    X = pd.concat([ref[FEATS], new[FEATS]])       # domain classifier: 0 = train, 1 = নতুন
    d = np.r_[np.zeros(len(ref)), np.ones(len(new))]
    clf = HistGradientBoostingClassifier(max_iter=60, max_depth=3, random_state=0)
    auc[name] = roc_auc_score(d, cross_val_predict(clf, X, d, cv=3, method="predict_proba")[:, 1])
print("PSI:\n", pd.DataFrame(P, index=FEATS).round(3))
print("p-value (KS / chi-square):\n", pd.DataFrame(Pv, index=FEATS))
print("domain AUC:", {k: round(v, 3) for k, v in auc.items()})

PSI:
         same  district    eid  policy
logp   0.008     0.015  0.010   0.012
dist   0.003     2.111  0.011   0.006
cloth  0.000     0.000  0.006   0.000
cod    0.000     0.235  0.001   0.000
p-value (KS / chi-square):
         same district    eid policy
logp   6e-01    3e-01  7e-02  3e-01
dist   8e-01   1e-317  2e-01  6e-01
cloth  8e-01    6e-01  9e-03  6e-01
cod    6e-01    4e-60  3e-01  6e-01
domain AUC: {'same': 0.5, 'district': 0.86, 'eid': 0.51, 'policy': 0.493}

৫ · Label দেরিতে এলে — অনুমানের বণ্টন আর মানের নজরদারি

ফেরত চূড়ান্ত হতে প্রায় এক মাস লাগে (label delay). এই সময়ে আসল accuracy অজানা, তবু কিছু সংকেত সঙ্গে সঙ্গে পাওয়া যায়। সবচেয়ে কাজের হলো prediction drift: model-এর গড় সম্ভাবনা আর “ঝুঁকিপূর্ণ” বলা অর্ডারের ভাগ। ঈদে input প্রায় শান্ত হলেও ঝুঁকিপূর্ণ বলা ভাগ ৩২% থেকে ৩৭%-এ ওঠে (তৃতীয় ব্লকে দেখবেন), কারণ ফেরত-ধাঁচের অর্ডার বেশি। নীচের সারণি সংকেতগুলো সাজায়।

শেষ সারিটি প্রায়ই উপেক্ষিত। প্রতিদিন কয়েকশো অর্ডার এলোমেলোভাবে বেছে দ্রুত যাচাই করলে (ধরুন ফোন করে নিশ্চিত করা) label delay কমে। আর একটি সূক্ষ্ম বিপদ: model যে অর্ডার আটকায়, তার ফল কখনো দেখা যায় না, তাই শুধু অনুমতি পাওয়া অর্ডারে মান মাপলে ছবি বাঁকা হয় (feedback loop). এজন্য একটি ছোট নিয়ন্ত্রণ দল রাখা হয়, যেখানে model-এর সিদ্ধান্ত প্রয়োগ হয় না। Label ছাড়া calibrated সম্ভাবনা থেকে প্রত্যাশিত accuracy গোনার পদ্ধতিও আছে, কিন্তু concept shift-এ তা অন্ধ, কারণ সম্ভাবনাগুলোই তখন ভুল।

৬ · Covariate shift সামলানো — importance weighting

Covariate shift-এ P(y | x) একই, তাই training-এর প্রতিটি সারি এখনো সঠিক শিক্ষা দেয়; সমস্যা শুধু অনুপাতে। নতুন জেলায় দূরের অর্ডার বেশি, training-এ কম। সমাধান: নতুন বণ্টনে যে ধরনের সারি বেশি, তাকে বেশি ওজন দেওয়া। গণিতে, নতুন বণ্টনে প্রত্যাশিত loss

E_Q[ℓ(x, y)] = E_P[ w(x) · ℓ(x, y) ], যেখানে w(x) = q(x) / p(x)

q(x) আর p(x) হলো নতুন আর পুরোনো ঘনত্ব। এটি importance weighting, যাকে Hidetoshi Shimodaira ২০০০ সালে log-likelihood-এ ওজন দেওয়ার পদ্ধতি হিসেবে বিশ্লেষণ করেন। কিন্তু চার মাত্রায় ঘনত্ব অনুমান করা কঠিন (পর্ব ৪০), আর দুটি অনুমানের ভাগফল আরও অস্থির। কৌশলটি domain classifier দিয়ে: Bayes-এর সূত্রে

w(x) = q(x) / p(x) = [ P(d=1 | x) / P(d=0 | x) ] × ( n_train / n_new )

অর্থাৎ classifier-এর odds, দুই দলের আকারের অনুপাত দিয়ে সংশোধিত। তারপর scikit-learn-এর প্রায় সব estimator-এ fit(X, y, sample_weight=w) (sample weight). দাম কোথায়? কয়েকটি সারি বিশাল ওজন পেলে model আসলে অল্প কয়েকটি সারি থেকে শেখে। তা মাপার জন্য Leslie Kish-এর জরিপ-পরিসংখ্যান থেকে আসা effective sample size: ESS = (∑w)² / ∑w². সব ওজন সমান হলে ESS = n; একটি ওজন বাকিদের ছাপিয়ে গেলে ESS → ১.

দ্বিতীয় ব্লক তিনটি আলাদা training নমুনায় পুরো পদ্ধতি চালায়: domain classifier-এর out-of-fold সম্ভাবনা থেকে ওজন, ৯৯তম percentile-এ কাটা ওজন, আর তিন রকম logistic regression. মূল্যায়ন নতুন জেলার ২,০০০টি label-সহ অর্ডারে, যা training-এ কখনো ঢোকেনি। তুলনার জন্য একটি “oracle”: নতুন জেলার label-সহ ডেটায় সরাসরি শেখানো model, বাস্তবে যা পাওয়া যায় না।

import numpy as np
import pandas as pd
from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_predict
from sklearn.metrics import accuracy_score, log_loss
from bazar_shift import train_data, scenario, FEATS

test = scenario("district", seed=777)            # label-সহ, শুধু মূল্যায়নে
rows = []
for s in range(3):                               # তিনটি আলাদা training নমুনা
    ref = train_data(seed=59 + s)
    new = scenario("district", seed=590 + s)[FEATS]   # নতুন জেলা, label ছাড়া
    X = pd.concat([ref[FEATS], new])
    d = np.r_[np.zeros(len(ref)), np.ones(len(new))]
    dom = HistGradientBoostingClassifier(max_iter=60, max_depth=3, random_state=0)
    p = cross_val_predict(dom, X, d, cv=3, method="predict_proba")[:len(ref), 1]
    w = p / (1 - p) * len(ref) / len(new)        # odds × (n_train / n_new)
    w_clip = np.minimum(w, np.quantile(w, 0.99))
    for name, sw in [("none", None), ("weighted", w), ("clipped", w_clip)]:
        m = LogisticRegression().fit(ref[FEATS], ref.returned, sample_weight=sw)
        q = m.predict_proba(test[FEATS])[:, 1]
        ess = len(ref) if sw is None else sw.sum() ** 2 / (sw ** 2).sum()
        rows.append({"seed": s, "weights": name, "ESS": ess,
                     "max_w": w.max() if sw is not None else 1,
                     "acc": accuracy_score(test.returned, q > 0.5),
                     "logloss": log_loss(test.returned, q), "mean_p": q.mean()})
lab = scenario("district", seed=999)             # তুলনা: নতুন জেলার label-সহ ডেটায় শেখা
q = LogisticRegression().fit(lab[FEATS], lab.returned).predict_proba(test[FEATS])[:, 1]
print("true rate:", round(test.returned.mean(), 3), " oracle: acc",
      accuracy_score(test.returned, q > 0.5), "logloss", round(log_loss(test.returned, q), 3))
t = pd.DataFrame(rows)
print(t.groupby("weights", sort=False)[["ESS", "acc", "logloss", "mean_p"]].mean().round(3))
print(t.pivot(index="seed", columns="weights", values="logloss").round(3))
print("largest weight per seed:", t[t.weights == "weighted"].max_w.round(1).tolist())

true rate: 0.522  oracle: acc 0.7475 logloss 0.506
               ESS    acc  logloss  mean_p
weights
none      3000.000  0.727    0.531   0.504
weighted   306.260  0.746    0.507   0.535
clipped    673.489  0.746    0.508   0.530
weights  clipped   none  weighted
seed
0          0.506  0.532     0.506
1          0.511  0.532     0.508
2          0.506  0.530     0.506
largest weight per seed: [87.9, 138.3, 111.6]

৭ · Label shift সামলানো — নতুন prior অনুমান (BBSE)

পর্ব ২৬-এ দেখেছেন, নতুন prior π′ জানা থাকলে odds-কে [π′/(১ − π′)] / [π/(১ − π)] দিয়ে গুণ করলেই সম্ভাবনা সংশোধন হয়, model আবার না শিখিয়েই। কিন্তু ঈদের প্রথম সপ্তাহে π′ জানা নেই; সেটিই তো label. সরল উত্তর “model যত ভাগকে ঝুঁকিপূর্ণ বলছে, ততই” ভুল, কারণ classifier নিখুঁত নয়: কিছু ফেরত সে ধরে না, কিছু না-ফেরতকে ঝুঁকিপূর্ণ বলে।

Label shift-এ P(x | y) একই, তাই classifier-এর অনুমান ŷ-এর শর্তসাপেক্ষ আচরণও একই: P(ŷ | y) পুরোনো আর নতুন জগতে সমান। তাহলে নতুন ডেটায় অনুমানের বণ্টন

μ_i = Q(ŷ = i) = ∑_j P(ŷ = i | y = j) · Q(y = j)

এটি অজানা Q(y)-এর একটি রৈখিক সমীকরণ। বাম পাশ নতুন ডেটা থেকে গোনা যায় (label ছাড়াই), আর P(ŷ | y) আসে পুরোনো ডেটার validation অংশের confusion matrix থেকে। Zachary Lipton, Yu-Xiang Wang আর Alexander Smola ২০১৮ সালে ICML-এ এই পদ্ধতি black box shift estimation (BBSE) নামে বিশ্লেষণ করেন: C_ij = P(ŷ = i, y = j) পুরোনো ডেটায়, তারপর C·w = μ সমাধান করলে w_j = Q(y = j)/P(y = j). দুই শ্রেণিতে এটি পুরোনো একটি সূত্রে নামে, যাকে quantification-এর সাহিত্যে adjusted classify-and-count বলা হয় (George Forman-এর ২০০৮ সালের কাজে সুপরিচিত): π′ = (r − FPR) / (TPR − FPR), যেখানে r হলো নতুন ডেটায় ঝুঁকিপূর্ণ বলার হার।

তৃতীয় ব্লক training ডেটার প্রথম ২,০০০ সারিতে model শেখায়, বাকি ১,০০০ সারিতে C গোনে (সীমা ০.৩), তারপর চারটি দৃশ্যে অনুমানের গড়, ঝুঁকিপূর্ণ বলার হার, BBSE-এর π′ আর তিন রকম log loss ছাপায়: যেমন আছে, BBSE-এর π′ দিয়ে সংশোধিত, আর আসল π′ দিয়ে সংশোধিত (যা prior সংশোধনের সর্বোচ্চ সম্ভাব্য লাভ)।

import numpy as np
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import log_loss
from bazar_shift import train_data, scenario, FEATS

ref = train_data()
fit, val = ref.iloc[:2000], ref.iloc[2000:]       # val: confusion matrix-এর জন্য
model = LogisticRegression().fit(fit[FEATS], fit.returned)
T = 0.3                                           # ঝুঁকিপূর্ণ বলার সীমা
pv = model.predict_proba(val[FEATS])[:, 1]
yv = val.returned.to_numpy()
pi = yv.mean()                                    # train-এর prior
C = np.array([[np.mean((pv < T) & (yv == j)) for j in (0, 1)],
              [np.mean((pv >= T) & (yv == j)) for j in (0, 1)]])
print("C = P(pred, true) on val:\n", C.round(3), " prior:", round(pi, 3))

def adjust(p, pi, pi_new):                        # পর্ব ২৬-এর odds সংশোধন
    a = p * pi_new / pi
    return a / (a + (1 - p) * (1 - pi_new) / (1 - pi))

rows = []
for name in ["same", "district", "eid", "policy"]:
    new = scenario(name)
    p = model.predict_proba(new[FEATS])[:, 1]
    mu = np.array([np.mean(p < T), np.mean(p >= T)])     # নতুন ডেটায় অনুমানের ভাগ
    w = np.linalg.solve(C, mu)                    # C·w = μ, w = q(y) / p(y)
    pi_hat = w[1] * pi                            # অনুমিত নতুন prior
    y = new.returned
    rows.append({"scenario": name, "true": y.mean(), "mean_p": p.mean(),
                 "flag_rate": mu[1], "BBSE": pi_hat, "LL_asis": log_loss(y, p),
                 "LL_bbse": log_loss(y, adjust(p, pi, np.clip(pi_hat, 0.01, 0.99))),
                 "LL_oracle": log_loss(y, adjust(p, pi, y.mean()))})
print(pd.DataFrame(rows).set_index("scenario").round(3).T)

C = P(pred, true) on val:
 [[0.579 0.111]
 [0.169 0.141]]  prior: 0.252
scenario    same  district    eid  policy
true       0.254     0.530  0.450   0.135
mean_p     0.250     0.494  0.273   0.253
flag_rate  0.316     0.748  0.366   0.314
BBSE       0.270     1.565  0.418   0.262
LL_asis    0.510     0.527  0.715   0.429
LL_bbse    0.510     2.363  0.634   0.436
LL_oracle  0.510     0.623  0.631   0.382

π′ অনুমানের আরেকটি পুরোনো পথ Marco Saerens ও সহকর্মীদের ২০০২ সালের EM (expectation–maximization): বর্তমান π′ দিয়ে প্রতিটি অর্ডারের সম্ভাবনা সংশোধন, তাদের গড়কে নতুন π′ ধরা, আবার, যতক্ষণ না স্থির হয়। এটি calibrated সম্ভাবনা চায়; BBSE চায় শুধু একটি স্থির classifier আর তার confusion matrix. অনুশীলন ৪-এ EM নিজে লিখে দুটি তুলনা করবেন।

৮ · Concept shift — নতুন label ছাড়া উপায় নেই

নিয়ম বদলালে পুরোনো ডেটার কোনো ওজন বা prior সংশোধন নতুন নিয়ম শেখাতে পারে না; নতুন label লাগে। প্রশ্ন শুধু: নতুন label কীভাবে ব্যবহার করবেন? তিনটি সাধারণ কৌশল:

• স্থির (frozen): একবার শেখা model, আর কখনো নয়। Baseline হিসেবে জরুরি।
• Sliding window: প্রতি মাসে শুধু শেষ k মাসের label-সহ ডেটায় নতুন করে শেখানো (পর্ব ৫২-এর backtesting-এর sliding window-এর মতো)। পুরোনো নিয়ম দ্রুত ভোলে, কিন্তু ডেটা কম।
• Recency weighting: সব মাস রাখা, কিন্তু প্রতিটি মাস যত পুরোনো, ওজন তত কম (এখানে প্রতি মাসে ০.৭৫ গুণ)। ডেটা বেশি, কিন্তু পুরোনো নিয়মের ছায়া থেকে যায়।

চতুর্থ ব্লক ২৪ মাসের একটি ধারা বানায়, প্রতি মাসে ৬০০টি অর্ডার। মাস ৯ থেকে ১৬-র মধ্যে COD-এর অগ্রিম নীতি ধীরে চালু হয়। Label আসে এক মাস দেরিতে, তাই মাস m-এর model শুধু m − ১ পর্যন্ত ডেটা দেখে। প্রতিটি মাসে তিনটি কৌশলের log loss মাপা হয়, আর ধূসর অংশে নীতি চালু হচ্ছে।

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import log_loss
from bazar_shift import month, FEATS

M = {m: month(m) for m in range(1, 25)}           # ২৪ মাস, প্রতি মাসে ৬০০ অর্ডার
fit = lambda ms, w=None: LogisticRegression().fit(
    pd.concat([M[k][FEATS] for k in ms]), pd.concat([M[k].returned for k in ms]),
    sample_weight=w)
frozen = fit([1, 2, 3])                           # প্রথম তিন মাসে একবার শেখা
rows = []
for m in range(4, 25):                            # label এক মাস দেরিতে: m−1 পর্যন্ত জানা
    past = list(range(1, m))
    window = fit(past[-3:])                       # sliding window: শেষ ৩ মাস
    w = np.concatenate([np.full(600, 0.75 ** (m - 1 - k)) for k in past])
    recency = fit(past, w)                        # সব মাস, পুরোনো মাসের ওজন কম
    y = M[m].returned
    rows.append({"month": m} | {n: log_loss(y, mod.predict_proba(M[m][FEATS])[:, 1])
                 for n, mod in [("frozen", frozen), ("window", window), ("recency", recency)]})
t = pd.DataFrame(rows).set_index("month")
print(t.iloc[[0, 5, 9, 13, 17, 20]].round(3))
print("mean 4-8  :", t.loc[4:8].mean().round(3).to_dict())
print("mean 9-16 :", t.loc[9:16].mean().round(3).to_dict())
print("mean 17-24:", t.loc[17:24].mean().round(3).to_dict())
ax = t.plot(marker="o", figsize=(6.4, 3.2), title="Concept drift: monthly log loss")
ax.axvspan(8.5, 16.5, color="0.9"); ax.set_ylabel("log loss"); plt.show()

       frozen  window  recency
month
4       0.549   0.549    0.549
9       0.496   0.491    0.492
13      0.465   0.428    0.439
17      0.443   0.355    0.365
21      0.454   0.347    0.348
24      0.460   0.359    0.357
mean 4-8  : {'frozen': 0.52, 'window': 0.52, 'recency': 0.52}
mean 9-16 : {'frozen': 0.46, 'window': 0.422, 'recency': 0.429}
mean 17-24: {'frozen': 0.432, 'window': 0.336, 'recency': 0.339}

কতটা পুরোনো ডেটা রাখবেন, তা বদলের গতি আর ডেটার পরিমাণের বিনিময়: দ্রুত বদলে ছোট জানালা, ধীর বদলে আর কম ডেটায় বড় জানালা বা ধীর ক্ষয়। জানালার দৈর্ঘ্য বা ক্ষয়ের হার নিজেও একটি hyperparameter, যা অতীতের ধারায় backtesting দিয়ে বাছাই করা উচিত, ভবিষ্যৎ দেখে নয়। ভুল কখন বাড়ছে তা স্বয়ংক্রিয়ভাবে ধরার জন্য স্ট্রিম-ভিত্তিক detector আছে (যেমন Albert Bifet আর Ricard Gavaldà-র ২০০৭ সালের ADWIN, যা ভুলের হারের জানালা নিজে ছোট-বড় করে); João Gama ও সহকর্মীদের ২০১৪ সালের একটি জরিপে এদের তুলনা আছে। নিয়মিত না ট্রিগারে retrain, তা AI-এর ভিত্তি কোর্সের পর্ব ৭৪-এ দেখেছেন।

৯ · নজরদারির চেকলিস্ট আর আসল টুল

সব মিলিয়ে একটি চালু model-এর জন্য কাজের ক্রম:

1. Deploy-এর আগে: reference ডেটা (সাধারণত training বা validation-এর একটি অংশ) সংরক্ষণ, bin-এর সীমা একবার ঠিক করে রাখা, আর ঋতুর জন্য আলাদা reference (ঈদের মাসকে সাধারণ মাসের সঙ্গে তুলনা করলে প্রতিবছর ভুয়া সতর্কতা)।
2. প্রতিদিন: pipeline-এর মৌলিক যাচাই (missing, অসম্ভব মান), প্রতিটি feature-এর PSI, অনুমানের গড় আর ঝুঁকিপূর্ণ বলার হার।
3. প্রতি সপ্তাহে: domain classifier-এর AUC আর তার শীর্ষ feature; BBSE দিয়ে শ্রেণি-হারের অনুমান, আর অসম্ভব মান এলে তা আলাদা সতর্কসংকেত হিসেবে।
4. Label এলে: log loss, accuracy আর calibration, একটি সরল baseline-এর পাশে, আর মূল দলভেদে (জেলা, পণ্যের ধরন)।
5. সতর্কতা এলে: আগে কারণ (pipeline-এর ভুল, ঋতু, ব্যবসার নীতি), তারপর ধরন (covariate, label, concept), তারপর প্রতিকার: ওজন, prior সংশোধন, বা নতুন label-এ আবার শেখানো।

এসব কাজের জন্য খোলা উৎসের Python library আছে। Evidently ডেটা আর অনুমানের drift-এর রিপোর্ট বানায়, feature-এর ধরন দেখে KS, chi-square, PSI বা Wasserstein-এর মতো test বাছে। NannyML label আসার আগেই model-এর মান অনুমানের পদ্ধতিতে (CBPE, regression-এর জন্য DLE) জোর দেয়, আর multivariate drift-এর জন্য PCA দিয়ে ডেটা ছোট করে আবার গড়ার ভুল (reconstruction error) মাপে। এরা পাতার Python-এ চলে না, আর API সংস্করণভেদে বদলেছে; নিজের version-এর docs দেখে ছোট ডেটায় এই পর্বের নিজে লেখা হিসাবের সঙ্গে মিলিয়ে নিন। মাসের পর মাসের নজরদারি, alert আর dashboard-এর পুরো নকশা পর্ব ৬৯ (ML system-এর test আর নজরদারি — data test, model test আর drift)-এ আসবে।

১০ · AI-এর যুগে — drift-এর কোড আর দাবি যাচাই

“আমার model-এ drift monitoring যোগ করো” বললে AI assistant প্রায়ই প্রতিটি feature-এ KS test আর “p < ০.০৫ হলে retrain” দেয়। এই পর্বের ব্লকগুলো দেখিয়েছে, তাতে নীতি বদল একেবারেই ধরা পড়ে না, আর বড় নমুনায় প্রায় প্রতিদিন ভুয়া সতর্কতা আসে। নিচের ভুলগুলো প্রায়ই চোখে পড়ে।

AI-এর দেওয়া drift-এর কোড হাতে পেলে — যাচাইয়ের চেকলিস্ট

• তিন bin-এর একটি খেলনা উদাহরণে PSI হাতে করে কোডের সঙ্গে মিলিয়েছি
• কোনো বদল নেই এমন একটি নতুন নমুনায় সব test আর AUC চালিয়ে দেখেছি যে সতর্কতা আসে না
• Domain classifier-এর AUC out-of-fold, আর ওজনের ESS আর সবচেয়ে বড় ওজন দেখেছি
• Prior সংশোধনের আগে label shift-এর অনুমান আর π′-এর পরিসর যাচাই করেছি
• Retrain-এর কৌশল অতীতের ধারায় backtest করেছি, একটি স্থির model-এর baseline-সহ, কয়েকটি seed-এ
• কোনো আসল ক্রেতার নাম, ঠিকানা বা অর্ডারের তথ্য AI-তে পেস্ট করিনি