পুনরুৎপাদনযোগ্য ML experiment — seed, config, tracking আর তুলনা

১ · একই ফল আবার — repeat, reproduce আর replicate

বাজারঘরের ডেটা দলের রুমানা জানালেন, নতুন churn model-এর AUC ০.৭৪. দুই সপ্তাহ পরে ম্যানেজার একই সংখ্যা চাইলেন, কারণ বোর্ড মিটিংয়ে দেখাতে হবে। রুমানা notebook খুলে চালালেন: ০.৭২. আবার চালালেন: ০.৭৬. কোনটি আসল? কোন ডেটায়, কোন সেটিংয়ে ০.৭৪ এসেছিল, তা কেউ লিখে রাখেননি। এই পর্বের বিষয় ঠিক এই সমস্যা।

ভিত্তির কাজ আগেই হয়েছে। AI-এর ভিত্তি কোর্সের পর্ব ১২-এ ফোল্ডার, uv.lock, ডেটার SHA-256 ছাপ আর একটি JSONL খাতা দিয়ে নতুন clone-এ হুবহু একই metrics পাওয়া গেছে; পর্ব ৭৪-এ একটি ছোট run log আর একটি MLflow run দেখা গেছে। এখানে আমরা আরও গভীরে যাব: config-চালিত experiment, ফলের ওঠানামা মাপা, ন্যায্য তুলনা, ablation, আর অনেক চেষ্টার ফাঁদ।

শুরুতে তিনটি শব্দ আলাদা করা দরকার, কারণ গবেষণায় এগুলো প্রায়ই গুলিয়ে যায় (বিভিন্ন সংস্থা সংজ্ঞা একটু আলাদাভাবে দেয়, তাই এখানে প্রচলিত একটি রূপ):

একটি run-কে একটি ফাংশন হিসেবে দেখলে পুরো ব্যাপারটি পরিষ্কার হয়: ফল = f(code, environment, ডেটা, config, seed). পাঁচটি ইনপুটের যেকোনো একটি অজানা থাকলে ফলটি আর ফাংশনের মান নয়, একটি গুজব। নিচের ছবিতে একটি run-এর পুরো রেকর্ড:

২ · Run আবার চালাতে কী লাগে — config ফাইল আর পাঁচ উপাদান

সবচেয়ে সাধারণ ভুল হলো সেটিং code-এর ভেতরে ছড়িয়ে রাখা: এক লাইনে C=0.5, আরেক জায়গায় max_depth=6, notebook-এর কোনো ঘরে হাতে বাদ দেওয়া একটি কলাম। তখন একটি experiment মানে code-এ হাত দেওয়া, আর পুরোনো run-এর সেটিং ফিরে পেতে Git-এর ইতিহাস খুঁড়তে হয়। প্রতিকার হলো config ফাইল: সব সেটিং এক জায়গায়, code শুধু সেটি পড়ে।

{"model": "logreg", "C": 1.0, "features": "all", "seed": 42, "folds": 5}

এরপর নতুন experiment মানে নতুন একটি config ফাইল, code-এ হাত নয়। Config-এর ধরন JSON, YAML বা TOML যেকোনোটি হতে পারে; বড় প্রকল্পে Hydra-র মতো হাতিয়ার কয়েকটি config জুড়ে দেয় (একটি ডেটার, একটি model-এর) আর command line থেকে একটি মান বদলাতে দেয়। ধরন যা-ই হোক, তিনটি নিয়ম কাজে লাগে:

• প্রতিটি মান স্পষ্ট: library-র default-এর ওপর ভরসা নয়। scikit-learn-এর কোনো default পরের version-এ বদলালে config-এ লেখা মান আপনাকে বাঁচায়।
• Config-এর ছাপ: config-কে key সাজিয়ে JSON বানিয়ে তার hash নিলে একটি ছোট cfg_id পাওয়া যায়। একই config দুবার চললে একই id, তাই খাতায় পুনরাবৃত্তি ধরা সহজ।
• শুধু প্রাসঙ্গিক key: tree model-এর config-এ logistic regression-এর C রেখে দিলে খাতায় বিভ্রান্তি আসে (পরের ব্লকে তা চোখে পড়বে)।

Config একা যথেষ্ট নয়। একটি run আবার চালাতে কী কী লাগে, নিচের stepper-এ একটি রেকর্ড ধাপে ধাপে ভরে উঠছে; প্রতিটি ধাপে দেখুন, ওই মুহূর্তে কেউ run-টি আবার চালাতে পারতেন কি না।

৩ · Config থেকে run, run থেকে খাতা — পাতার ভেতরে

এবার পুরো চক্রটি পাতার ভেতরেই। ডেটা আসে নিচের module থেকে: বাজারঘরের ১,০০০ জন কাল্পনিক গ্রাহক, চারটি feature-দলে আটটি কলাম, আর লক্ষ্য churn (পরের ৯০ দিনে আর কেনেননি = 1). সব সংখ্যা seed দিয়ে বানানো, কোনো আসল গ্রাহকের নয়।

GROUPS = {"activity": ["orders_90d", "days_since"],
          "money": ["basket", "discount"],
          "service": ["late", "returns"],
          "profile": ["dhaka", "tenure"]}
# z = -0.9 - 0.35*orders + 0.025*days + 0.45*late + 0.30*returns
#     + 2.0*(discount - 0.3) - 0.2*log(basket/1100) + 0.05*dhaka
# churn = 1, সম্ভাবনা 1 / (1 + e^(-z)) দিয়ে; tenure-এর কোনো প্রভাব নেই

লক্ষ করুন, ডেটা আমরা নিজেরাই বানিয়েছি, তাই সত্যটা জানা: activity আর service-এর প্রভাব বড়, money-র মাঝারি, profile-এর প্রায় শূন্য (dhaka-র ওজন মাত্র ০.০৫, tenure-এর শূন্য)। অংশ ৬-এর ablation এই সত্যটি খুঁজে পায় কি না, দেখব। নিচের ব্লকে একটি run_experiment(cfg) ফাংশন config নিয়ে ৫-fold cross-validation চালায়, আর খাতায় এক লাইন লেখে। scikit-learn প্রথমবার লোড হতে প্রায় ১০ সেকেন্ড লাগতে পারে।

import json, hashlib
import numpy as np
import pandas as pd
import sklearn
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import StratifiedKFold, cross_val_score
from bazar_churn import make_customers

CODE_VERSION = "7b6a64f"            # বাস্তবে: git rev-parse --short HEAD
df = make_customers(n=1000, seed=7)
data_hash = hashlib.sha256(df.to_csv(index=False).encode()).hexdigest()[:12]
def run_experiment(cfg):
    m = (make_pipeline(StandardScaler(), LogisticRegression(C=cfg["C"]))
         if cfg["model"] == "logreg" else
         DecisionTreeClassifier(max_depth=cfg["depth"], random_state=cfg["seed"]))
    cv = StratifiedKFold(cfg["folds"], shuffle=True, random_state=cfg["seed"])
    s = cross_val_score(m, df.drop(columns="churn"), df.churn, cv=cv, scoring="roc_auc")
    cfg_id = hashlib.sha256(json.dumps(cfg, sort_keys=True).encode()).hexdigest()[:8]
    rec = {"cfg_id": cfg_id, "code": CODE_VERSION, "data": data_hash,
           "sklearn": sklearn.__version__, "params": cfg,
           "auc_mean": round(s.mean(), 4), "auc_sd": round(s.std(ddof=1), 4)}
    with open("runs.jsonl", "a", encoding="utf-8") as f:     # শুধু শেষে যোগ
        f.write(json.dumps(rec) + "\n")

base = {"model": "logreg", "C": 1.0, "seed": 42, "folds": 5}
for change in [{}, {"C": 0.01}, {"model": "tree", "depth": 4}, {}]:  # শেষটি পুনরাবৃত্তি
    run_experiment({**base, **change})

rows = [json.loads(line) for line in open("runs.jsonl", encoding="utf-8")]
log = pd.json_normalize(rows).rename(columns=lambda c: c.replace("params.", ""))
print("data", data_hash, "| sklearn", log.sklearn[0], "| code", CODE_VERSION)
print(log[["cfg_id", "model", "C", "depth", "auc_mean", "auc_sd"]].to_string())

data 72706f45cd4b | sklearn 1.8.0 | code 7b6a64f
     cfg_id   model     C  depth  auc_mean  auc_sd
0  8061b6d9  logreg  1.00    NaN    0.7357  0.0257
1  848b0468  logreg  0.01    NaN    0.7361  0.0256
2  b3f95ae1    tree  1.00    4.0    0.6507  0.0347
3  8061b6d9  logreg  1.00    NaN    0.7357  0.0257

৪ · ফল কতটা নড়ে — split-এর seed, model-এর seed আর fold

খাতায় ০.৭৩৫৭ লেখা থাকলেই সেটি “model-এর AUC” নয়। সংখ্যাটি একটি নির্দিষ্ট ভাগের, একটি নির্দিষ্ট seed-এর। Seed বাঁধলে ফল স্থির হয়, কিন্তু সঠিক হয় না; শুধু একটি এলোমেলো বিন্দুতে আটকে যায়। কতটা এলোমেলো, সেটি জানতে ওঠানামার উৎসগুলো আলাদা করতে হয়:

• ভাগের ভাগ্য: কোন গ্রাহক train-এ, কোন গ্রাহক test-এ। ছোট test set-এ এটিই সাধারণত সবচেয়ে বড় উৎস।
• Model-এর ভেতরের এলোমেলোতা: tree-তে কোন feature আগে বিবেচনা হবে, forest-এ কোন নমুনা কোন গাছে, neural network-এ শুরুর ওজন।
• Fold-এর ভাগ: cross-validation-এ কোন গ্রাহক কোন fold-এ।
• হিসাবের ক্রম: একাধিক thread বা GPU-তে যোগের ক্রম বদলালে দশমিকের শেষ ঘর বদলায় (AI-এর ভিত্তি কোর্সের পর্ব ১২-এর “আরও গভীরে” অংশ)।

নিচের ব্লক প্রথম তিনটি উৎস আলাদা করে মাপে। (ক) logistic regression, ডেটা একই, শুধু ৭০/৩০ ভাগের seed ০ থেকে ১৯. (খ) একটি tree, ভাগ একটিই, শুধু model-এর seed ০ থেকে ১৯ (max_features=0.5 থাকায় tree-তেও এলোমেলোতা আছে)। (গ) একটি ৫-fold. শেষে একটি test set-এর AUC-র bootstrap interval: test-এর সারিগুলো ফেরত রেখে ৫০০ বার নতুন করে টেনে।

import numpy as np
import pandas as pd
from scipy import stats
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split, StratifiedKFold
from sklearn.metrics import roc_auc_score
from bazar_churn import make_customers
df = make_customers(n=1000, seed=7)
X, y = df.drop(columns="churn").to_numpy(), df.churn.to_numpy()
idx, lr = np.arange(len(y)), lambda: make_pipeline(StandardScaler(), LogisticRegression())
def auc(model, tr, te):
    return roc_auc_score(y[te], model.fit(X[tr], y[tr]).predict_proba(X[te])[:, 1])
def summary(name, s):
    m, sd, n = s.mean(), s.std(ddof=1), len(s)
    h = stats.t.ppf(0.975, n - 1) * sd / np.sqrt(n)      # t-interval-এর অর্ধেক
    print(f"{name:<22} {m:.4f} ± {sd:.4f}  CI [{m-h:.4f}, {m+h:.4f}]  "
          f"range {s.min():.3f}-{s.max():.3f}")
split = np.array([auc(lr(), *train_test_split(idx, test_size=0.3, random_state=s,
                  stratify=y)) for s in range(20)])     # শুধু ভাগ বদলায়
tr0, te0 = train_test_split(idx, test_size=0.3, random_state=0, stratify=y)
tree = np.array([auc(DecisionTreeClassifier(max_depth=5, max_features=0.5,
                 random_state=s), tr0, te0) for s in range(20)])  # শুধু model-এর seed
folds = np.array([auc(lr(), tr, te) for tr, te in
                  StratifiedKFold(5, shuffle=True, random_state=0).split(X, y)])
for name, s in [("logreg 20 split seeds", split), ("tree 20 model seeds", tree),
                ("logreg 5 folds", folds)]:
    summary(name, s)
p0 = lr().fit(X[tr0], y[tr0]).predict_proba(X[te0])[:, 1]
B = np.random.default_rng(0).integers(0, len(te0), (500, len(te0)))  # bootstrap
b = [roc_auc_score(y[te0][i], p0[i]) for i in B]
print("one split AUC", round(roc_auc_score(y[te0], p0), 4), "bootstrap 95%",
      np.percentile(b, [2.5, 97.5]).round(4))

logreg 20 split seeds  0.7370 ± 0.0214  CI [0.7270, 0.7470]  range 0.705-0.784
tree 20 model seeds    0.6587 ± 0.0210  CI [0.6489, 0.6685]  range 0.607-0.693
logreg 5 folds         0.7398 ± 0.0455  CI [0.6834, 0.7963]  range 0.664-0.776
one split AUC 0.7588 bootstrap 95% [0.7074 0.8119]

৫ · mean ± sd পড়া, interval, আর fold কেন স্বাধীন নয়

“০.৭৩৮ ± ০.০২৬” দেখলে প্রথম প্রশ্ন: ± এর পরের সংখ্যাটি কী? দুটি সম্পূর্ণ আলাদা জিনিস এখানে বসতে পারে, আর রিপোর্টে সেটি না লিখলে পাঠক বিভ্রান্ত হন:

• Standard deviation (sd): একটি একক run-এর score কতটা ছড়ায়। নতুন একটি seed-এ চালালে মোটামুটি কোন পরিসরে পড়বে, তার আন্দাজ। n বাড়লেও এটি কমে না।
• Standard error (SE = sd/√n): গড়টি কতটা অনিশ্চিত। n বাড়লে কমে। Confidence interval এখান থেকেই আসে: গড় ± t × SE, যেখানে t আসে t-distribution থেকে (n − 1 মুক্তমাত্রা; n = ৫ হলে ৯৫%-এর জন্য t ≈ ২.৭৭৬)। t-interval-এর পুরো ব্যাখ্যা AI-এর ভিত্তি কোর্সের পর্ব ৩৭-এ।

এখন দুটি model তুলনা করা যাক, যা অংশ ৮-এর MLflow run থেকে এসেছে: A = profile-দল বাদ দেওয়া logistic regression, B = সব feature. দুজনই একই ৫টি fold-এ মাপা (fold-ভাগের seed 42). নিচের stepper হাতে হিসাব করে, আর শেষে জোড়া পার্থক্য দেখে।

Fold-এর score কেন স্বাধীন নয়

t-interval ধরে নেয় সংখ্যাগুলো একে অপরের থেকে স্বাধীন। k-fold-এ তা সত্য নয়: ৫-fold-এ যেকোনো দুটি fold-এর training অংশের তিন-চতুর্থাংশ সারি একই, তাই তাদের model প্রায় একই, আর score একসঙ্গে ওঠানামা করে। ফল: sd/√k ছোট দেখায়, interval বেশি সরু। Bengio ও Grandvalet (২০০৪) দেখিয়েছেন, k-fold-এর score থেকে variance-এর কোনো নিরপেক্ষ (unbiased) অনুমান সাধারণভাবে সম্ভব নয়। ব্যবহারিক একটি প্রতিকার Nadeau ও Bengio (২০০৩)-র corrected resampled t-test: variance-কে 1/k দিয়ে গুণ না করে (1/k + n_test/n_train) দিয়ে গুণ করা। ৫-fold-এ n_test/n_train = ২০০/৮০০ = ০.২৫, তাই গুণক ০.২ থেকে বেড়ে ০.৪৫ হয়, আর interval প্রায় √(০.৪৫/০.২) ≈ ১.৫ গুণ চওড়া। এটি একটি আনুমানিক সংশোধন, নিখুঁত নয়।

তাহলে কী রিপোর্ট করবেন? একটি সৎ লাইন এমন: “৫-fold × ৪ পুনরাবৃত্তি, একই ভাগে, AUC ০.৭৩৯ (sd ০.০২৬); A − B জোড়া পার্থক্য +০.০০২৬, সংশোধিত ৯৫% interval [−০.০০৩, ০.০০৯]।” কোন উৎসের ওঠানামা (split, seed, fold), কতগুলো, আর ± মানে sd না SE, তিনটিই লেখা। দুই model-এর তুলনার পূর্ণ পরিসংখ্যান, যেমন paired test, McNemar test আর অনেক তুলনার সংশোধন, আসবে পর্ব ২২ (Model তুলনার পরিসংখ্যান)-এ; bootstrap-এর তত্ত্ব পর্ব ২১-এ।

৬ · Ablation study — একটি করে অংশ খুলে দেখা

চায়ের দোকানের মালিক ভাবছেন, কোন জিনিসটির জন্য বিক্রি বাড়ছে: নতুন কাপ, বিস্কুট, না পাশের টিভি? একসঙ্গে সব বদলালে বোঝা যায় না। এক সপ্তাহ একটি করে সরিয়ে দেখলে বোঝা যায় কোনটি না থাকলে বিক্রি কমে। এটিই ablation study: একটি সম্পূর্ণ ব্যবস্থা থেকে একটি অংশ (একটি feature-দল, একটি preprocessing ধাপ, model-এর একটি অংশ) সরিয়ে দেখা ফল কতটা বদলায়। শব্দটি এসেছে জীববিজ্ঞানের পরীক্ষা থেকে, যেখানে কোনো টিস্যু সরিয়ে তার কাজ বোঝা হতো।

Ablation-এর নিয়ম তিনটি। (১) একই ভাগ: প্রতিটি সংস্করণ হুবহু একই fold-এ, যাতে পার্থক্য শুধু সরানো অংশের জন্য হয়। (২) জোড়া পার্থক্য: প্রতিটি ভাগে পূর্ণ model থেকে কতটা সরল, আর কতগুলো ভাগে খারাপ হলো। (৩) দল ধরে: সম্পর্কিত feature একসঙ্গে, কারণ orders_90d সরালে days_since তার অনেকটা কাজ ঢেকে দিতে পারে। নিচের ব্লকে ৫-fold × ৪ পুনরাবৃত্তি = ২০টি একই ভাগে প্রতিটি দল একবার করে সরানো হয়েছে।

import numpy as np
import pandas as pd
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import RepeatedStratifiedKFold, cross_val_score
from bazar_churn import make_customers, GROUPS

df = make_customers(n=1000, seed=7)
y = df.churn
cv = RepeatedStratifiedKFold(n_splits=5, n_repeats=4, random_state=0)  # ২০টি একই ভাগ
model = make_pipeline(StandardScaler(), LogisticRegression())

def scores(cols):
    return cross_val_score(model, df[cols], y, cv=cv, scoring="roc_auc")

all_cols = [c for g in GROUPS.values() for c in g]
full = scores(all_cols)
rows = [{"dropped": "(none)", "auc": full.mean(), "delta": 0.0, "delta_sd": 0.0, "worse": "-"}]
for g, cols in GROUPS.items():
    s = scores([c for c in all_cols if c not in cols])
    d = s - full                                          # একই ভাগে জোড়া পার্থক্য
    rows.append({"dropped": g, "auc": s.mean(), "delta": d.mean(), "delta_sd": d.std(ddof=1),
                 "worse": f"{(d < 0).sum()}/{len(d)}"})
pd.set_option("display.width", 70)
print(pd.DataFrame(rows).round(4).to_string(index=False))

dropped    auc   delta  delta_sd worse
  (none) 0.7391  0.0000    0.0000     -
activity 0.6032 -0.1359    0.0389 20/20
   money 0.7271 -0.0119    0.0130 17/20
 service 0.7147 -0.0243    0.0186 17/20
 profile 0.7408  0.0018    0.0019  5/20

৭ · Garden of forking paths — অনেক চেষ্টা করলে noise-ও জেতে

AI-এর ভিত্তি কোর্সের পর্ব ৬২-এ EDA-র প্রসঙ্গে garden of forking paths দেখা গেছে: প্রতিটি “এটা দেখি, ওটা বাদ দিই” একটি শাখা। ML experiment-এ শাখাগুলো আরও বেশি: কোন feature, কোন outlier নিয়ম, কোন model, কোন C, কোন threshold, কোন metric. প্রতিটি ছোট সিদ্ধান্ত validation-এর ফল দেখে নিলে, শেষ পথটি অনেক পথের সেরা, আর সেরা হওয়ার পেছনে ভাগ্যের অংশ বড়।

সবচেয়ে কঠিন পরীক্ষা: এমন ডেটা যেখানে শেখার মতো কিছুই নেই। নিচের ব্লকে ৩০টি feature আর label সবই এলোমেলো, তাই সত্যিকারের accuracy ঠিক ০.৫. তারপর ২০০টি “বিশ্লেষণের পথ” চেষ্টা করা হয়: প্রতিটিতে এলোমেলো কয়েকটি feature, একটি C, আর outlier বাদ দেওয়ার একটি নিয়ম। প্রতিটি পথ ৬০ সারির validation-এ মাপা, আর সেরাটি তারপর ৫,০০০টি নতুন সারিতে।

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression

rng = np.random.default_rng(42)
p = 30                                       # ৩০টি feature, সবই নিছক noise
Xtr, Xva, Xnew = (rng.normal(size=(n, p)) for n in (200, 60, 5000))
ytr, yva, ynew = (rng.integers(0, 2, n) for n in (200, 60, 5000))  # label-ও noise

results = []
for k in range(200):                         # ২০০টি "বিশ্লেষণের পথ"
    cols = rng.choice(p, size=rng.choice([3, 5, 8, 12]), replace=False)
    C = rng.choice([0.01, 0.1, 1.0, 10.0])
    keep = np.abs(Xtr[:, cols]).max(axis=1) < rng.choice([2.0, 2.5, 99])  # outlier বাদ?
    m = LogisticRegression(C=C).fit(Xtr[keep][:, cols], ytr[keep])
    results.append((m.score(Xva[:, cols], yva), m, cols))

accs = np.array([r[0] for r in results])
best_acc, best_m, best_cols = max(results, key=lambda r: r[0])
print(f"validation accuracy: median {np.median(accs):.3f}, best {best_acc:.3f}")
print(f"best path on 5000 fresh rows: {best_m.score(Xnew[:, best_cols], ynew):.3f}")
print("paths with validation >= 0.60:", int((accs >= 0.60).sum()), "of", len(accs))

fig, ax = plt.subplots(figsize=(6, 3))
ax.hist(accs, bins=20, color="#5b8def")
ax.axvline(0.5, color="black", ls="--", label="true accuracy (0.5)")
ax.axvline(best_acc, color="#d9534f", label=f"best of 200 ({best_acc:.2f})")
ax.set_xlabel("validation accuracy (60 rows)")
ax.set_ylabel("number of paths")
ax.legend(fontsize=8)
plt.show()

validation accuracy: median 0.500, best 0.667
best path on 5000 fresh rows: 0.498
paths with validation >= 0.60: 10 of 200

প্রতিকার — পথ কমানো, পথ গোনা, আর অদেখা ডেটা

• আগে লেখা পরিকল্পনা: metric, প্রধান তুলনা আর থামার নিয়ম শুরুতেই লিখে commit করা। বিজ্ঞানে একে preregistration বলে; ML দলে একটি ছোট “experiment plan” ফাইলই যথেষ্ট।
• সব চেষ্টা খাতায়: JSONL বা MLflow-এ ব্যর্থ run-ও থাকে। রিপোর্টে লিখুন “৪৮টি config চেষ্টা করা হয়েছে”, শুধু বিজয়ীটি নয়।
• বাছাই আর মূল্যায়ন আলাদা: যত পথই চেষ্টা করুন, বিজয়ীর সংখ্যা আসবে এমন ডেটা থেকে যা বাছাইয়ে লাগেনি: তালাবন্ধ test set, বা পুরো বাছাই-পদ্ধতির জন্য nested cross-validation (AI-এর ভিত্তি কোর্সের পর্ব ৬৬)।
• বড় validation, কম পথ: ৬০ সারির বদলে ৬০০ সারিতে SE তিন গুণের বেশি কমে; আর চেষ্টার বাজেট আগে ঠিক করা থাকলে পথ সীমিত থাকে (tuning-এর বাজেট নিয়ে পর্ব ৩৮ আর পর্ব ৪৯)।

৮ · MLflow দিয়ে ডেস্কটপে — run, param, metric, artifact আর তুলনা

পাতার JSONL খাতা ছোট প্রকল্পে যথেষ্ট। Run শতাধিক হলে, প্রতিটি fold-এর metric, model ফাইল আর chart-ও রাখতে হলে, বা দলের কয়েকজন একসঙ্গে কাজ করলে একটি experiment tracking হাতিয়ার সুবিধাজনক। MLflow (Databricks ২০১৮ সালে open-source হিসেবে প্রকাশ করে) এর বহুল ব্যবহৃত একটি। এর চারটি মূল ধারণা:

• Run: একবার চালানো, যার একটি id আছে; কয়েকটি run মিলে একটি experiment (“churn-baseline”).
• Param: একবার লেখা সেটিং (config-এর মান), পরে বদলানো যায় না।
• Metric: সংখ্যা, যা step ধরে বারবার লেখা যায়, যেমন প্রতিটি fold বা প্রতিটি epoch.
• Artifact: যেকোনো ফাইল: config-এর কপি, chart, model. সঙ্গে tag: commit, dirty চিহ্ন, ডেটার hash.

MLflow ব্রাউজারের Python-এ চলে না, তাই একটি ডেস্কটপ venv-এ সত্যিকারের run করা হলো (লেখার সময়ের version: Python 3.14.4, MLflow 3.18.0, scikit-learn 1.9.1; শুধু CPU, কোনো server বা account নয়)। প্রকল্প ~/bazarghar-ml: পাতার মতোই bazar_churn.py, configs/-এ চারটি config, আর train.py. প্রকল্পটি Git-এ, commit-এর লেখক কাল্পনিক “Rahim”. train.py-এর MLflow অংশ:

mlflow.set_tracking_uri("sqlite:///mlflow.db")   # একটি স্থানীয় ফাইল, server নয়
mlflow.set_experiment("churn-baseline")
with mlflow.start_run(run_name=sys.argv[1].split("/")[-1][:-5]) as run:
    s = cross_val_score(model, df[cols], df.churn, cv=cv, scoring="roc_auc")
    mlflow.log_params(cfg)
    mlflow.set_tags({"code_version": commit, "git_dirty": dirty,
                     "data_sha256": data_hash, "sklearn": sklearn.__version__})
    for i, v in enumerate(s):
        mlflow.log_metric("fold_auc", v, step=i)          # প্রতিটি fold আলাদা step
    mlflow.log_metrics({"cv_auc_mean": s.mean(), "cv_auc_sd": s.std(ddof=1)})
    mlflow.log_dict(cfg, "config.json")                   # artifact: config-এর কপি
    model.fit(df[cols], df.churn)
    trusted = ["sklearn.tree._tree.Tree"] if cfg["model"] == "tree" else None
    mlflow.sklearn.log_model(model, name="model", skops_trusted_types=trusted,
                             input_example=df[cols].head(3).astype(float))

এর আগে train.py config পড়ে, ডেটা বানিয়ে data.csv লেখে আর তার byte থেকে SHA-256 নেয়, আর git rev-parse --short HEAD ও git status --porcelain থেকে commit আর dirty চিহ্ন। চারটি config-এর সত্যিকারের run (MLflow-এর INFO আর কিছু সতর্কবার্তা “…” দিয়ে ছাঁটা):

~/bazarghar-ml$ git log --oneline
7b6a64f Save tree models with an explicit skops trust list
5e16dc0 Track runs in a local SQLite file
c5be8dd Churn baseline: data generator, configs, train script
~/bazarghar-ml$ for c in logreg_c1 logreg_c001 tree_d4 logreg_noprofile; do
>   python train.py configs/$c.json; done
… INFO mlflow.store.db.utils: Creating initial MLflow database tables...
… INFO mlflow.tracking.fluent: Experiment with name 'churn-baseline' does not exist. Creating a new experiment.
logreg_c1          auc 0.7357 ± 0.0257  commit 7b6a64f  data c4ef92b5edb4
logreg_c001        auc 0.7361 ± 0.0256  commit 7b6a64f  data c4ef92b5edb4
tree_d4            auc 0.6507 ± 0.0347  commit 7b6a64f  data c4ef92b5edb4
logreg_noprofile   auc 0.7384 ± 0.0262  commit 7b6a64f  data c4ef92b5edb4

প্রথম তিনটি সংখ্যা পাতার ব্লক ১-এর খাতার সঙ্গে হুবহু মেলে: একই ডেটা, একই fold-ভাগ, একই model. ডেস্কটপে scikit-learn 1.9.1, পাতায় 1.8.0; এই সরল model-এ দুই version একই ফল দিয়েছে। Run চলার পথে তিনটি সত্যিকারের বাধা এসেছিল, আর তিনটিই শিক্ষণীয়:

1. ফাইল-ভিত্তিক store আর ডিফল্ট নয়। প্রথম চেষ্টায় set_tracking_uri("file:./mlruns") দেওয়া হয়েছিল। MLflow 3.18 সেটি থামিয়ে দিল: MlflowException: The filesystem tracking backend (e.g., './mlruns') is in maintenance mode … Please migrate to a database backend (e.g., 'sqlite:///mlflow.db'). তাই একটি SQLite ফাইল (mlflow.db) ব্যবহার হয়েছে: এখনো স্থানীয়, কোনো server ছাড়া। Artifact তবু mlruns/ ফোল্ডারে ফাইল হিসেবেই থাকে। পুরোনো টিউটোরিয়াল বা AI-এর দেওয়া code-এ ./mlruns দেখলে এই পরিবর্তনটি মনে রাখবেন।
2. Model সংরক্ষণে নিরাপত্তা। MLflow 3.18 scikit-learn model ডিফল্টভাবে skops ফরম্যাটে রাখে, pickle-এ নয়, কারণ pickle খোলার সময় ফাইলের ভেতরের নির্দেশে code চলতে পারে। Tree model রাখার সময় এটি থামল: Untrusted types found in the file: ['sklearn.tree._tree.Tree']. আমরা নিজেরাই model-টি বানিয়েছি, তাই শুধু ওই একটি type-কে skops_trusted_types-এ বিশ্বস্ত বলা হয়েছে; MLflow-এর বার্তাও সতর্ক করে যে না দেখে সব type বিশ্বস্ত বলা উচিত নয়।
3. Dirty চিহ্ন প্রথমেই কাজে লাগল। প্রথম চালানোয় সব run +dirty হয়েছিল, কারণ ফোল্ডারে না-commit-করা কিছু লগ ফাইল ছিল। Run-এর আগে ফোল্ডার পরিষ্কার রাখা এই চিহ্নের উদ্দেশ্য।

এবার ইচ্ছা করে নিয়ম ভাঙা: configs/logreg_c1.json-এ C = ১.০ থেকে ০.৫ করা হলো, commit ছাড়াই, তারপর একই নামে run:

~/bazarghar-ml$ git status --short
 M configs/logreg_c1.json
~/bazarghar-ml$ python train.py configs/logreg_c1.json
logreg_c1          auc 0.7357 ± 0.0258  commit 7b6a64f+dirty  data c4ef92b5edb4

Commit একই 7b6a64f, run-এর নামও একই “logreg_c1”, অথচ config আলাদা। নাম বা commit দেখে এই run-কে আগেরটির সঙ্গে গুলিয়ে ফেলা খুব সহজ; শুধু dirty চিহ্ন আর param-এর C = ০.৫ সত্যটা বলে। এবার compare.py দিয়ে তুলনা: search_runs একটি SQL-এর মতো filter নেয়, metric ধরে সাজায়, আর একটি pandas DataFrame দেয়।

runs = mlflow.search_runs(experiment_names=["churn-baseline"],
                          filter_string="params.model = 'logreg'",
                          order_by=["metrics.cv_auc_mean DESC"])
best = runs.iloc[0]
client = MlflowClient()
hist = client.get_metric_history(best.run_id, "fold_auc")
print("artifacts:", [a.path for a in client.list_artifacts(best.run_id)])
model = mlflow.sklearn.load_model(f"runs:/{best.run_id}/model")

~/bazarghar-ml$ python compare.py
             run    C   features  auc_mean  auc_sd  commit dirty
logreg_noprofile  1.0 no_profile    0.7384  0.0262 7b6a64f False
     logreg_c001 0.01        all    0.7361  0.0256 7b6a64f False
       logreg_c1  1.0        all    0.7357  0.0257 7b6a64f False
       logreg_c1  0.5        all    0.7357  0.0258 7b6a64f  True
fold_auc by step: [0.729, 0.725, 0.708, 0.773, 0.757]
artifacts: ['config.json']
reloaded model, churn prob of first 3 customers: [0.163 0.371 0.219]

কয়েকটি জিনিস খেয়াল করুন। (ক) Filter-এ শুধু logreg run, AUC অনুযায়ী সাজানো; dirty run-টি আলাদা চেনা যাচ্ছে। (খ) সেরা run-এর fold_auc-এর ইতিহাস ঠিক সেই পাঁচটি সংখ্যা, যা অংশ ৫-এর stepper-এ A হিসেবে ব্যবহার হয়েছে। (গ) Run-এর artifact তালিকায় শুধু config.json, model নেই! MLflow 3-এ model একটি আলাদা সত্তা (“logged model”, id m-…), যা run-এর সঙ্গে যুক্ত থাকে আর mlruns/1/models/-এ রাখা হয়। তবু runs:/<id>/model ঠিকানা দিয়ে লোড করা গেছে, আর ফেরত আনা model প্রথম তিনজন গ্রাহকের churn সম্ভাবনা দিয়েছে। সেই model ফোল্ডারে কী আছে:

~/bazarghar-ml$ ls mlruns/1/models/m-2816…/artifacts
MLmodel  conda.yaml  input_example.json  model.skops  python_env.yaml
requirements.txt  serving_input_example.json
~/bazarghar-ml$ cat mlruns/1/models/m-2816…/artifacts/requirements.txt
mlflow==3.18.0
numpy==2.5.4
pandas==3.1.1
scikit-learn==1.9.1
scipy==1.18.1
skops==0.16.0

অর্থাৎ model-এর artifact নিজেই environment-এর একটি ছোট রেকর্ড বহন করে: কোন version-এ বানানো, কোন ইনপুটের নমুনা। MLmodel ফাইলে একটি artifact_path থাকে, যাতে এই কম্পিউটারের পুরো ফোল্ডারের ঠিকানা লেখা; দলের সঙ্গে ভাগ করার আগে এমন ফাইলে ব্যক্তিগত path আছে কি না দেখে নেওয়া ভালো। ওয়েব পাতায় তুলনা দেখার mlflow ui এখানে চালানো হয়নি; প্রয়োজনে সেটি 127.0.0.1-এ চালাতে হয়, যাতে বাইরের কেউ দেখতে না পান। Model registry, deployment আর পুরো MLOps পরের একটি কোর্সের বিষয়; এই কোর্সে production-এর দিক আসবে পর্ব ৬৮ আর পর্ব ৬৯-এ।

৯ · একটি সৎ experiment report — ছাঁচ

খাতা যন্ত্রের জন্য, report মানুষের জন্য। বাজারঘরের এই পর্বের কাজ দিয়ে ভরা একটি ছাঁচ নিচে; নিজের প্রকল্পে শিরোনামগুলো রেখে বিষয়বস্তু বদলাবেন। খেয়াল করুন, এখানে “কী চেষ্টা করা হয়েছিল” আর “কী জানি না” দুটোরই আলাদা জায়গা আছে।

# EXP-004 · churn model-এ profile-দল দরকার কি না (কাল্পনিক)
১. প্রশ্ন ও পরিকল্পনা (run-এর আগে commit 5e16dc0-এ লেখা)
   - প্রশ্ন: profile (dhaka, tenure) বাদ দিলে AUC কমে কি না
   - metric: ROC AUC; ভাগ: 5-fold × 4, random_state=0; test তালাবন্ধ
২. ইনপুট
   - code 7b6a64f (dirty=False) · data sha256 c4ef92b5edb4 · uv.lock
   - Python 3.14.4, scikit-learn 1.9.1, MLflow 3.18.0
৩. কী কী চেষ্টা হয়েছে
   - ৪টি config + ৪টি ablation সংস্করণ; ১টি dirty run বাতিল
৪. ফল (mean, sd, একই ২০টি ভাগে জোড়া পার্থক্য)
   - পূর্ণ 0.7391; profile বাদ Δ +0.0018 (sd 0.0019), খারাপ 5/20
৫. সিদ্ধান্ত
   - profile বাদ: ক্ষতির প্রমাণ নেই, ২টি feature কম
৬. সীমা ও যা জানি না
   - কাল্পনিক ডেটা, ১,০০০ সারি; fold স্বাধীন নয়, interval আনুমানিক
   - বাছাই CV দেখে; test একবার খোলা হবে চূড়ান্ত model-এ
৭. পুনরুৎপাদন: uv sync --locked; python train.py configs/logreg_noprofile.json

১০ · AI-এর যুগে — AI assistant-এর experiment code আর তার “উন্নতি” যাচাই

AI assistant দিয়ে training script, MLflow-এর code বা tuning loop লেখানো এখন সাধারণ। সময় বাঁচে, কিন্তু experiment-এর ক্ষেত্রে AI-এর ভুলগুলো চুপচাপ থাকে: code চলে, সংখ্যা আসে, আর সংখ্যাটি ভুল জিনিস মাপে। নিচের টেবিলে প্রায়ই দেখা কয়েকটি ধরন, আর কীভাবে ধরবেন:

AI-এর লেখা experiment code বা ফল হাতে পেলে — যাচাইয়ের চেকলিস্ট

• একই config দুবার চালিয়েছি, আর metric হুবহু মিলেছে
• খাতায় commit, dirty চিহ্ন, ডেটার hash, library-র version আর সব seed আছে
• “উন্নতি” দাবির আগে একাধিক seed বা fold-এ mean ± sd আর একই ভাগে জোড়া পার্থক্য দেখেছি
• একটি সরল baseline-এর সঙ্গে একই ভাগে তুলনা করেছি
• Test set শুধু শেষে, একবার; কতগুলো config চেষ্টা হলো তা রিপোর্টে লিখেছি
• প্রতিটি অচেনা ফাংশন আর parameter আমার version-এর অফিসিয়াল docs-এ পেয়েছি