Train, validation আর test — data leakage-এর ফাঁদ

পর্ব ৫৫ (যন্ত্র কীভাবে শেখে — supervised, unsupervised আর reinforcement)-এ দেখেছেন, supervised learning মানে label দেওয়া উদাহরণ থেকে একটি নিয়ম শেখা, আর আসল লক্ষ্য generalization: নতুন, না-দেখা উদাহরণে ঠিক উত্তর। এই পর্বের প্রশ্ন সোজা: “নতুন উদাহরণে কেমন করবে”, তা আমরা আগে থেকে সৎভাবে মাপব কীভাবে? পর্ব ৫-এ leakage শব্দটি প্রথম শুনেছেন, আর পর্ব ২৬-এ shift(-1)-এর ফাঁদ দেখেছেন; এখানে পুরো ছবিটা। চালানো যায় এমন ব্লকগুলো পাতাতেই চলে (ব্রাউজারের Python, NumPy 2.4, scikit-learn 1.8.0). scikit-learn প্রথমবার নামতে প্রায় ১০ সেকেন্ড লাগে; পরের run দ্রুত।

১ · কেন ডেটা আলাদা রাখি — ফাঁস হওয়া প্রশ্নপত্রের গল্প

Training-এর উদাহরণে model-এর ফল দিয়ে নতুন উদাহরণের কথা বলা যায় না, কারণ model সেগুলো মুখস্থ করে ফেলতে পারে। এই মুখস্থ করাকে বলে overfitting (পর্ব ৬১-এ পুরো আলোচনা)। তাই নিয়ম একটাই: যে ডেটা দিয়ে মাপবেন, model যেন তা কোনোভাবে আগে না দেখে। “কোনোভাবে” শব্দটিই এই পর্বের কেন্দ্র। Model সরাসরি না দেখলেও তথ্য চুইয়ে ঢুকতে পারে: একটি কলামের মাধ্যমে, ডুপ্লিকেট সারির মাধ্যমে, গড় হিসাবের মাধ্যমে, এমনকি আপনার নিজের বারবার দেখা আর বাছাইয়ের মাধ্যমে। এই চুইয়ে ঢোকারই নাম data leakage.

Leakage-এর সবচেয়ে বড় বিপদ: এটি কোনো error দেয় না, আর সংখ্যাটি ভালো আসে। ভুল ধরা পড়ে model বাস্তবে চালু হওয়ার পরে। তাই এই পর্বে প্রতিটি ফাঁদ হাতে-কলমে ঘটিয়ে দেখব, সৎ সংস্করণের পাশে।

২ · Train, validation আর test — তিন ভাগ, তিন কাজ

সবচেয়ে প্রচলিত নকশায় ডেটা তিন ভাগে যায়:

অনুপাত কত? ৬০/২০/২০, ৭০/১৫/১৫ বা ৮০/১০/১০ সবই চালু, কিন্তু এগুলো প্রচলিত অভ্যাস, কোনো সূত্র থেকে আসা নিয়ম নয়। আসল প্রশ্ন হলো, test set এত বড় কি না যে তার score যথেষ্ট স্থির। ১০০টি test উদাহরণে একটি ভুল মানে accuracy-তে ০.০১-এর লাফ; ১০ লাখ উদাহরণের ডেটায় ১% test-ও দশ হাজার উদাহরণ, যা যথেষ্ট। ডেটা কম হলে আলাদা validation set রাখার বদলে cross-validation (অংশ ৪) প্রায়ই ভালো। এক শর্ত সব ক্ষেত্রে এক: ভাগ সবার আগে, পরিষ্কার, scaling বা feature বাছাইয়ের আগে।

নিচের stepper বাজারঘরের ২০টি কাল্পনিক অর্ডার (#01–#20) ভাগ করে দেখায়। চারটি অর্ডার ফেরত এসেছিল (তারকা দিয়ে চিহ্নিত), অর্থাৎ ২০%. ভাগগুলো scikit-learn-এর train_test_split (stratify আর random_state=42 সহ) দিয়ে ডেস্কটপে সত্যিই করা।

৩ · train_test_split, random_state আর stratify — একটি ভাগ কতটা নড়বড়ে

scikit-learn-এ ভাগ করার মূল হাতিয়ার train_test_split. তিনটি argument মনে রাখুন। test_size (যেমন ০.২৫) বলে কত ভাগ test-এ যাবে। random_state একটি seed: একই সংখ্যা দিলে প্রতিবার একই ভাগ, তাই আপনার আর সহকর্মীর ফল মেলে। আর stratify=y বলে প্রতিটি শ্রেণির অনুপাত দুই ভাগে মূল ডেটার মতো রাখতে; একে বলে stratified ভাগ, যা পর্ব ৫১-এ SMS ভাগ করতে ব্যবহার করেছিলেন।

stratify সবচেয়ে জরুরি যখন একটি শ্রেণি বিরল, অর্থাৎ class imbalance. বাজারঘরে ধরুন মাত্র ৫% অর্ডার ফেরত আসে। নিচের ব্লক দুটি জিনিস মাপে: (ক) ৪০০টি অর্ডারের (২০টি ফেরত) ২০টি ভিন্ন seed-এ ভাগ করলে test-এর ১০০টিতে কয়টি ফেরত পড়ে, stratify ছাড়া আর সহ; (খ) একই model আর একই ডেটায় শুধু seed বদলালে accuracy কতটা নড়ে। দ্বিতীয় অংশে scikit-learn-এর সঙ্গে আসা Wisconsin breast cancer ডেটা (৫৬৯টি টিউমারের মাপ, UCI থেকে নেওয়া) আর পর্ব ৫১-এর পরিচিত GaussianNB.

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer
from sklearn.naive_bayes import GaussianNB

rng = np.random.default_rng(42)
y = np.zeros(400, dtype=int); y[:20] = 1     # ৪০০ অর্ডার, ২০টি (৫%) ফেরত
rng.shuffle(y)
X = rng.normal(size=(400, 3))                 # feature এখানে শুধু জায়গা ভরাট
print("পুরো ডেটায় ফেরত:", y.sum(), "/", len(y))

for strat in (None, y):
    counts = []
    for seed in range(20):
        *_, y_te = train_test_split(X, y, test_size=0.25,
                                    random_state=seed, stratify=strat)
        counts.append(int(y_te.sum()))
    name = "random    " if strat is None else "stratified"
    print(name, "test-এর ১০০টিতে ফেরত:", counts)
    print("           সর্বনিম্ন", min(counts), "সর্বোচ্চ", max(counts))

# একই model, একই ডেটা, শুধু ভাগ বদলায়
Xc, yc = load_breast_cancer(return_X_y=True)
acc = []
for seed in range(20):
    a, b, c, d = train_test_split(Xc, yc, test_size=0.25,
                                  random_state=seed, stratify=yc)
    acc.append(GaussianNB().fit(a, c).score(b, d))
acc = np.array(acc)
print(f"20টি ভাগে accuracy: গড় {acc.mean():.3f}, sd {acc.std(ddof=1):.3f}")
print(f"সর্বনিম্ন {acc.min():.3f} (seed {acc.argmin()}), "
      f"সর্বোচ্চ {acc.max():.3f} (seed {acc.argmax()})")

পুরো ডেটায় ফেরত: 20 / 400
random     test-এর ১০০টিতে ফেরত: [7, 4, 6, 2, 4, 7, 3, 5, 4, 4, 6, 5, 1, 8, 3, 7, 6, 3, 3, 2]
           সর্বনিম্ন 1 সর্বোচ্চ 8
stratified test-এর ১০০টিতে ফেরত: [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
           সর্বনিম্ন 5 সর্বোচ্চ 5
20টি ভাগে accuracy: গড় 0.939, sd 0.022
সর্বনিম্ন 0.909 (seed 12), সর্বোচ্চ 0.986 (seed 17)

৪ · k-fold cross-validation — প্রতিটি অংশ একবার করে পরীক্ষক

একটি ভাগ নড়বড়ে হলে স্বাভাবিক সমাধান: অনেক ভাগ করে গড় নেওয়া, আর এমনভাবে, যাতে প্রতিটি উদাহরণ ঠিক একবার পরীক্ষায় বসে। এটিই k-fold cross-validation: ডেটাকে k সমান অংশে (fold) ভাগ করুন; প্রতিবার একটি fold-কে পরীক্ষার জন্য রেখে বাকি k − 1টিতে train; k বার ঘুরিয়ে k-টি score, তারপর গড় আর ছড়ানো। k = ৫ বা ১০ বহুল প্রচলিত। k = n (উদাহরণের সংখ্যা) হলে সেটি leave-one-out, যা পর্ব ৫১-এ ৬০টি SMS-এ চালিয়েছিলেন।

এখন stepper-এ একটি round ঘুরিয়ে দেখুন। সংখ্যাগুলো ওপরের ছবির একই সত্যিকারের run থেকে (ডেস্কটপ, scikit-learn 1.8.0). ৫৬৯টি টিউমারের ৩৫৭টি benign (label 1), ২১২টি malignant.

মনে রাখুন, cross-validation একটি পদ্ধতির মাপ দেয়, কোনো একটি fit করা model-এর নয়; আর k বার fit লাগে, তাই খরচ k গুণ। cross-validation দিয়ে model আর hyperparameter বাছাই, nested cross-validation আর GridSearchCV পর্ব ৬৬ (Model বাছাই — cross-validation আর hyperparameter search)-এর বিষয়; এখানে শুধু ধারণাটুকু।

৫ · একই গ্রাহক, একই সময় — group split আর time-based split

এলোমেলো ভাগ একটি নীরব অনুমান করে: প্রতিটি সারি অন্যগুলো থেকে স্বাধীন। বাজারঘরের অর্ডারে তা সত্য নয়। একজন গ্রাহক দশটি অর্ডার দেন; তাঁর বয়স, জেলা আর কেনার ধরন দশটিতেই এক, আর ফেরত দেওয়ার অভ্যাসও। এলোমেলো ভাগে তাঁর সাতটি অর্ডার train-এ আর তিনটি test-এ পড়লে model পরীক্ষায় “নতুন অর্ডার” দেখছে না, দেখছে চেনা গ্রাহক। কিন্তু আসল প্রশ্ন যদি হয় “নতুন গ্রাহকের অর্ডার ফেরত আসবে কি না”, তাহলে এই score আশাবাদী।

এর সমাধান group split: প্রতিটি সারির সঙ্গে একটি group (এখানে গ্রাহকের ID) দিন, আর ভাগ এমনভাবে হোক যাতে একটি group-এর সব সারি এক দিকেই যায়। scikit-learn-এ একবারের ভাগের জন্য GroupShuffleSplit, cross-validation-এর জন্য GroupKFold. নিচের ব্লকে ৬০ জন কাল্পনিক গ্রাহক, প্রত্যেকের ৬–১৪টি অর্ডার। প্রত্যেক গ্রাহকের একটি লুকোনো অভ্যাস: কেউ বেশি ফেরত দেন (প্রতি অর্ডারে ৮০% সম্ভাবনা), কেউ কম (১০%). Feature শুধু গ্রাহকের বয়স, জেলা আর ঝুড়ির গড় দাম, যা একজন গ্রাহককে প্রায় চিনিয়ে দেয়। Model একটি DecisionTreeClassifier; tree কীভাবে শাখা গড়ে তা এখানে জরুরি নয়, শুধু জানুন এটি ডেটা মুখস্থ করতে পারদর্শী।

import numpy as np
from sklearn.model_selection import KFold, GroupKFold, GroupShuffleSplit, cross_val_score
from sklearn.tree import DecisionTreeClassifier

rng = np.random.default_rng(42)
n_cust = 60
sizes = rng.integers(6, 15, size=n_cust)            # প্রতি গ্রাহকের ৬–১৪টি অর্ডার
g = np.repeat(np.arange(n_cust), sizes.astype(np.intp))  # কোন অর্ডার কোন গ্রাহকের
age = rng.integers(18, 60, size=n_cust)
district = rng.integers(0, 8, size=n_cust)
basket = rng.normal(800, 250, size=n_cust)
# লুকোনো অভ্যাস: তরুণদের মধ্যে "বেশি ফেরত দেন" এমন গ্রাহক বেশি, তবে নিশ্চিত নয়
high = rng.random(n_cust) < np.where(age < 35, 0.7, 0.3)
y = (rng.random(g.size) < np.where(high, 0.8, 0.1)[g]).astype(int)
X = np.column_stack([age[g], district[g],
                     basket[g] + rng.normal(0, 20, size=g.size)])
print("অর্ডার:", len(y), "| গ্রাহক:", n_cust, "| ফেরতের হার:", round(y.mean(), 3))

tree = DecisionTreeClassifier(min_samples_leaf=3, random_state=42)
plans = {"KFold, এলোমেলো অর্ডার": KFold(5, shuffle=True, random_state=42),
         "GroupKFold, গ্রাহক ধরে ": GroupKFold(5)}
for name, cv in plans.items():
    grp = g if isinstance(cv, GroupKFold) else None    # KFold groups নেয় না
    s = cross_val_score(tree, X, y, cv=cv, groups=grp)
    print(f"{name}: {np.round(s, 2)} গড় {s.mean():.3f}")
print("baseline (সবসময় 'ফেরত নয়'):", round(1 - y.mean(), 3))

tr, te = next(GroupShuffleSplit(n_splits=1, test_size=0.25,
                                random_state=42).split(X, y, groups=g))
print("GroupShuffleSplit: train-এ গ্রাহক", len(set(g[tr])), "test-এ", len(set(g[te])),
      "| দুই ভাগে একই গ্রাহক:", len(set(g[tr]) & set(g[te])))

অর্ডার: 611 | গ্রাহক: 60 | ফেরতের হার: 0.457
KFold, এলোমেলো অর্ডার: [0.72 0.73 0.79 0.8  0.78] গড় 0.761
GroupKFold, গ্রাহক ধরে : [0.67 0.46 0.52 0.46 0.51] গড় 0.522
baseline (সবসময় 'ফেরত নয়'): 0.543
GroupShuffleSplit: train-এ গ্রাহক 45 test-এ 15 | দুই ভাগে একই গ্রাহক: 0

সময়ের ডেটা: অতীতে শেখা, ভবিষ্যতে পরীক্ষা

দৈনিক বিক্রির পূর্বাভাসে এলোমেলো ভাগ মানে বুধবার আর শুক্রবারের ডেটা দিয়ে শিখে বৃহস্পতিবার “ভবিষ্যদ্বাণী” করা; বাস্তবে আগামীকালের পরের দিনের ডেটা কখনো হাতে থাকে না। Time-based split-এ তাই একটি তারিখ ধরে কাটা হয়: তার আগে train, পরে test. পর্ব ২৬-এ দেখেছেন তারিখ দিয়ে এভাবে ভাগ করা। Cross-validation-এর সময়ের সংস্করণ হলো scikit-learn-এর TimeSeriesSplit: train-এর জানালা ক্রমে বড় হয়, আর test সবসময় তার ঠিক পরের অংশ।

import numpy as np
from sklearn.model_selection import TimeSeriesSplit

days = np.arange(1, 13)                               # ১২ দিনের বিক্রি
for k, (tr, te) in enumerate(TimeSeriesSplit(n_splits=4).split(days), 1):
    print(f"ভাগ {k}: train দিন {days[tr].tolist()} | test দিন {days[te].tolist()}")

সত্যিকারের run (ডেস্কটপ, Python 3.14.4, scikit-learn 1.8.0):

~/bazarghar-ai$ python ts_split.py
ভাগ 1: train দিন [1, 2, 3, 4] | test দিন [5, 6]
ভাগ 2: train দিন [1, 2, 3, 4, 5, 6] | test দিন [7, 8]
ভাগ 3: train দিন [1, 2, 3, 4, 5, 6, 7, 8] | test দিন [9, 10]
ভাগ 4: train দিন [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] | test দিন [11, 12]

দুটি বাড়তি বিবেচনা। এক, train আর test-এর মাঝে একটি ফাঁকা অংশ (gap parameter) রাখা যায়, যদি feature বানাতে কয়েক দিনের পুরোনো ডেটা লাগে বা ফল জানতে দেরি হয়। দুই, সময়ের সঙ্গে বণ্টন বদলায় (distribution shift), যেমন ঈদের মাসে; এলোমেলো ভাগ এই বদল লুকায়, সময় ধরে ভাগ তা সামনে আনে।

৬ · Data leakage-এর চেহারা — target, contamination, ID আর সময়

Shachar Kaufman, Saharon Rosset আর Claudia Perlich ২০১১ সালে KDD সম্মেলনে, আর পরে Ori Stitelman-সহ ২০১২ সালে ACM TKDD জার্নালে, leakage-কে মোটামুটি এভাবে সংজ্ঞায়িত করেন: model-এ এমন তথ্য ঢুকে পড়া, যা ভবিষ্যদ্বাণীর মুহূর্তে বৈধভাবে পাওয়া যেত না। তাঁদের প্রস্তাবিত মূল প্রতিকার “learn-predict separation”: শেখার জন্য শুধু সেই তথ্য, যা ভবিষ্যদ্বাণীর সময় সত্যিই হাতে থাকবে। নিচের পরীক্ষাগুলো বাজারঘরের ২০০০টি কাল্পনিক অর্ডারে (ফেরতের হার প্রায় ৩৫%), feature হলো দাম, ডেলিভারির দিন আর প্রথম অর্ডার কি না।

(ক) Target leakage — ফল জানার পরের কলাম

অর্ডারের টেবিলে একটি কলাম আছে refund_processed: টাকা ফেরত প্রক্রিয়া হয়েছে কি না। শুনতে নিরীহ, কিন্তু টাকা ফেরত হয় ফেরতের পরে। অর্ডার দেওয়ার মুহূর্তে, যখন model-কে আসলে প্রশ্নটি করা হবে, এই কলাম সবসময় ০. একে বলে target leakage: feature-টি আসলে label-এর ছায়া।

(খ) ID আর ক্রমের মধ্য দিয়ে

ধরুন ফেরত হওয়া অর্ডারগুলো পরে একটি আলাদা ফাইল থেকে টেবিলের শেষে জোড়া হয়েছিল, আর তারপর সারির নম্বর দিয়ে row_id বানানো হয়েছে। তখন বড় ID মানেই ফেরত। Model ID থেকে শিখবে, ফেরতের কারণ থেকে নয়। একই কারণে ক্রম অনুযায়ী সাজানো ডেটায় shuffle=False দিয়ে k-fold চালালে কোনো fold-এ শুধু এক শ্রেণি পড়তে পারে।

(গ) Train-test contamination — ডুপ্লিকেট সারি

একটি রপ্তানি স্ক্রিপ্ট ভুল করে প্রতিটি অর্ডার ১–৩ বার লিখেছে (পর্ব ২৩-এ duplicate row খোঁজা দেখেছেন)। এলোমেলো ভাগে একই অর্ডারের এক কপি train-এ, আরেক কপি test-এ পড়ে: model প্রশ্নটা হুবহু আগেই দেখেছে। একে বলে train-test contamination. তিনটি পরীক্ষার কোডের মূল অংশ:

# df: ২০০০টি কাল্পনিক অর্ডার; returned = লক্ষ্য
df["refund_processed"] = ((df["returned"] == 1) & (rng.random(n) < 0.97)).astype(int)
honest = ["price", "delivery_days", "first_order"]
print("সৎ feature:               ", score(honest))
print("+ refund_processed:        ", score(honest + ["refund_processed"]))

# ফেরত হওয়া অর্ডার পরে জোড়া হয়েছিল, তারপর সারির নম্বর = row_id
d2 = pd.concat([df[df.returned == 0], df[df.returned == 1]], ignore_index=True)
d2["row_id"] = np.arange(len(d2))

# প্রতিটি অর্ডার ১–৩ বার রপ্তানি; ভাগের আগে বনাম পরে drop_duplicates
dup = base.loc[base.index.repeat(rng.integers(1, 4, size=len(base)))]
for name, data in [("ডুপ্লিকেটসহ ভাগ   ", dup), ("আগে drop_duplicates", dup.drop_duplicates())]:
    Xtr, Xte, ytr, yte = train_test_split(data[honest], data["returned"], test_size=0.25,
                                          random_state=42)
    seen = Xte.merge(Xtr.drop_duplicates(), how="inner").shape[0]
    ...

সত্যিকারের run (ডেস্কটপ, Python 3.14.4, scikit-learn 1.8.0, pandas 3.1.1; প্রথম দুটিতে LogisticRegression আর max_depth=3-এর tree, তৃতীয়টিতে RandomForestClassifier):

~/bazarghar-ai$ python leaks_demo.py
scikit-learn 1.8.0 | pandas 3.1.1
অর্ডার: 2000 | ফেরতের হার: 0.354

[1] target leakage
baseline (সবসময় 'ফেরত নয়'): 0.646
সৎ feature:                0.656
+ refund_processed:         0.982

[2] ID-র মধ্য দিয়ে leakage
সৎ feature (tree):           0.644
+ row_id (tree):             1.0

[3] train-test contamination: ডুপ্লিকেট সারি
আসল অর্ডার 600 | ডুপ্লিকেটসহ সারি 1185
ডুপ্লিকেটসহ ভাগ   : test 297 সারি, train-এ হুবহু আছে 220, accuracy 0.916
আগে drop_duplicates: test 150 সারি, train-এ হুবহু আছে 0, accuracy 0.673

তিনটিই একই গল্প বলে। সৎ feature দিয়ে model baseline-এর সামান্য ওপরে (০.৬৫৬ বনাম ০.৬৪৬); এই কাল্পনিক ডেটায় ফেরত আগে থেকে বলা সত্যিই কঠিন, আর সেটাই সৎ খবর। refund_processed যোগ করতেই ০.৯৮২; row_id দিতেই নিখুঁত ১.০; ডুপ্লিকেট রেখে ভাগ করলে test-এর ২৯৭টির ২২০টি train-এ হুবহু ছিল, আর accuracy ০.৬৭৩ থেকে ফুলে ০.৯১৬. খেয়াল করুন, এর কোনোটিতে কোনো warning আসেনি।

(ঘ) Temporal leakage — ভবিষ্যতের তথ্য

পর্ব ২৬-এ দেখেছেন: আগামীকালের বিক্রি বলতে চাইলে shift(-1) দিয়ে লক্ষ্য বানানো ঠিক, কিন্তু shift(-1) বা ভবিষ্যৎমুখী চলমান গড় feature-এ ঢুকলে model “নিখুঁত” দেখায়। এই temporal leakage-এর আরও সূক্ষ্ম রূপ আছে: সারা বছরের ডেটা দিয়ে হিসাব করা “গ্রাহকের মোট ফেরতের হার” feature হিসেবে জানুয়ারির অর্ডারে বসানো; বা পরে সংশোধিত ডেটা (যেমন পরে ঠিক করা ঠিকানা) দিয়ে পুরোনো সিদ্ধান্তের পরীক্ষা। প্রতিকার একটাই নিয়ম: প্রতিটি feature-এর জন্য লিখে রাখুন, “এই মান কোন মুহূর্তে জানা যায়”, আর সেটি ভবিষ্যদ্বাণীর মুহূর্তের আগে কি না। Lag feature শুধু অতীতের দিকে তাকায় বলেই নিরাপদ।

৭ · Preprocessing leakage আর Pipeline — fit শুধু train-এ

সবচেয়ে প্রচলিত leakage কোনো কলাম থেকে আসে না, আসে প্রস্তুতির ধাপ থেকে। Standardization (প্রতিটি কলাম থেকে গড় বাদ দিয়ে standard deviation দিয়ে ভাগ) বা imputation (ফাঁকা ঘরে গড় বসানো) করতে একটি গড় লাগে। সেই গড় পুরো ডেটা থেকে নিলে test-এর মানও তাতে মিশে যায়। একে বলে preprocessing leakage. নিচের stepper ছোট সংখ্যায় দেখায় তথ্যটা ঠিক কোথায় চুইয়ে যায়: ছয়টি train অর্ডারের ডেলিভারির দিন, আর test-এ দুটি, যার একটি অস্বাভাবিক দেরির (৩০ দিন)।

বাস্তবে এই প্রভাব কত বড়? Breast cancer ডেটায় LogisticRegression দিয়ে ১০ রকম ৫-fold ভাগে গড় করে দেখা হয়েছে, একবার ২০% ঘর ফাঁকা করে imputation-সহ। সত্যিকারের run (ডেস্কটপ, Python 3.14.4, scikit-learn 1.8.0):

~/bazarghar-ai$ python prep_leak.py
scaler: আগে পুরো ডেটায়            গড় accuracy 0.9801
scaler: Pipeline-এর ভেতরে          গড় accuracy 0.9798
imputer+scaler: আগে পুরো ডেটায়    গড় accuracy 0.9749
imputer+scaler: Pipeline-এর ভেতরে  গড় accuracy 0.9747

পার্থক্য মাত্র ০.০০০৩ আর ০.০০০২: এখানে প্রায় নগণ্য। তাহলে এত সতর্কতা কেন? কারণ যে ধাপ label দেখে (feature বাছাই, target encoding, oversampling) বা যেখানে feature সংখ্যা উদাহরণের চেয়ে অনেক বেশি, সেখানে একই ভুল ভয়ংকর হয়। নিচের ব্লক সেই ক্লাসিক পরীক্ষা।

এলোমেলো ডেটা থেকে ০.৯১ accuracy

১০০ জন মানুষ, প্রত্যেকের ২০০০টি সংখ্যা, সব পুরো এলোমেলো; label-ও এলোমেলো, অর্ধেক ০ আর অর্ধেক ১. এখানে শেখার কিছুই নেই, সৎ উত্তর ০.৫-এর কাছে। ভুল পথ: আগে পুরো ডেটায় SelectKBest দিয়ে label-এর সঙ্গে সবচেয়ে বেশি মেলে এমন ২০টি feature বাছা (feature selection), তারপর cross-validation. ঠিক পথ: বাছাইকে Pipeline-এর প্রথম ধাপ বানানো, যাতে প্রতিটি fold-এ বাছাই শুধু সেই fold-এর train অংশ দেখে করে।

import numpy as np
from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.pipeline import make_pipeline

rng = np.random.default_rng(42)
X = rng.normal(size=(100, 2000))              # ১০০ জন, ২০০০টি পুরো এলোমেলো feature
y = rng.permutation(np.repeat([0, 1], 50))    # label-ও এলোমেলো: সৎ উত্তর ≈ 0.5
cv = StratifiedKFold(5, shuffle=True, random_state=42)

# ভুল পথ: আগে পুরো ডেটায় y-এর সঙ্গে সবচেয়ে মেলে এমন ২০টি feature বাছা, তারপর CV
X_sel = SelectKBest(f_classif, k=20).fit_transform(X, y)
leaky = cross_val_score(LogisticRegression(), X_sel, y, cv=cv)

# ঠিক পথ: বাছাই Pipeline-এর ভেতরে, তাই প্রতিটি fold-এ শুধু train অংশ দেখে
pipe = make_pipeline(SelectKBest(f_classif, k=20), LogisticRegression())
honest = cross_val_score(pipe, X, y, cv=cv)

print("ভুল পথ (বাছাই আগে):    ", np.round(leaky, 2), "গড়", round(leaky.mean(), 3))
print("ঠিক পথ (বাছাই ভেতরে):  ", np.round(honest, 2), "গড়", round(honest.mean(), 3))

# একবারের ভাগ্য নয়: আরও ১০টি এলোমেলো ডেটাসেটে একই পরীক্ষা
gap = []
for s in range(10):
    r = np.random.default_rng(100 + s)
    Xs, ys = r.normal(size=(100, 2000)), r.permutation(np.repeat([0, 1], 50))
    a = cross_val_score(LogisticRegression(),
                        SelectKBest(f_classif, k=20).fit_transform(Xs, ys), ys, cv=cv).mean()
    b = cross_val_score(pipe, Xs, ys, cv=cv).mean()
    gap.append((a, b))
gap = np.array(gap)
print("১০টি নতুন ডেটাসেটে ভুল পথ:", np.round(gap[:, 0], 2), "গড়", round(gap[:, 0].mean(), 3))
print("১০টি নতুন ডেটাসেটে ঠিক পথ:", np.round(gap[:, 1], 2), "গড়", round(gap[:, 1].mean(), 3))

ভুল পথ (বাছাই আগে):     [0.95 0.9  0.8  0.95 0.95] গড় 0.91
ঠিক পথ (বাছাই ভেতরে):   [0.4  0.4  0.55 0.35 0.4 ] গড় 0.42
১০টি নতুন ডেটাসেটে ভুল পথ: [0.83 0.82 0.88 0.83 0.87 0.87 0.85 0.87 0.91 0.86] গড় 0.859
১০টি নতুন ডেটাসেটে ঠিক পথ: [0.41 0.46 0.48 0.54 0.48 0.6  0.47 0.49 0.58 0.59] গড় 0.51

make_pipeline(ধাপ১, ধাপ২, …, model) একটি বস্তু বানায়, যার fit প্রতিটি ধাপকে ক্রমে শুধু দেওয়া ডেটায় fit করে, আর predict একই শেখা মাপকাঠিতে রূপান্তর করে। cross_val_score-কে পুরো pipeline দিলে প্রতিটি fold-এ পুরো প্রস্তুতি নতুন করে হয়: leakage-মুক্ত হওয়ার সবচেয়ে সহজ উপায়। ColumnTransformer, বিভিন্ন কলামে বিভিন্ন ধাপ আর pipeline সংরক্ষণ পর্ব ৬৪ (scikit-learn pipeline — fit, transform আর leakage-মুক্ত কাজ)-এ।

৮ · Test set একবারই — বারবার উঁকি দিলে যা হয়

শেষ leakage-টি কোডে নয়, অভ্যাসে। Test-এ ০.৭১, একটি feature বদলে আবার test-এ ০.৭৩, আরেকটি সেটিংয়ে ০.৭৫: প্রতিবার test দেখে সিদ্ধান্ত নিলে test চুপিচুপি validation set হয়ে যায়। এই অভ্যাসের নাম data snooping. ব্যাপারটা ঠিক কতটা বিপজ্জনক, তা একটি চরম পরীক্ষায় দেখা যায়: যেখানে শেখার কিছুই নেই, সেখানে ৫০টি model বানিয়ে test দেখে সেরাটি বাছা।

import numpy as np
from sklearn.linear_model import LogisticRegression

rng = np.random.default_rng(42)
def noise(n):                                   # feature আর label দুটোই এলোমেলো
    return rng.normal(size=(n, 30)), rng.integers(0, 2, size=n)
X_tr, y_tr = noise(200)
X_te, y_te = noise(100)                         # "test set"
X_new, y_new = noise(5000)                      # ভবিষ্যতের সত্যিকারের নতুন ডেটা
rows = []
for i in range(50):                             # ৫০টি "model": আলাদা feature আর C
    cols = rng.choice(30, size=5, replace=False)
    C = 10 ** rng.uniform(-3, 2)
    m = LogisticRegression(C=C).fit(X_tr[:, cols], y_tr)
    rows.append((m.score(X_te[:, cols], y_te), m.score(X_new[:, cols], y_new), i))

test = np.array([r[0] for r in rows])
best_test, best_new, best_i = max(rows)
print(f"৫০টি model-এর test accuracy: গড় {test.mean():.3f}, "
      f"সর্বনিম্ন {test.min():.3f}, সর্বোচ্চ {test.max():.3f}")
print(f"test দেখে বাছা সেরা: model {best_i}, test-এ {best_test:.3f}")
print(f"সেই model নতুন ৫০০০টিতে: {best_new:.3f}")

# পুরো পরীক্ষাটি ২০ বার: "সেরা"-র test score বনাম নতুন ডেটার score
gaps = []
for rep in range(20):
    Xa, ya = noise(200); Xb, yb = noise(100); Xc, yc = noise(2000)
    best = (-1, 0)
    for i in range(50):
        cols = rng.choice(30, size=5, replace=False)
        m = LogisticRegression(C=10 ** rng.uniform(-3, 2)).fit(Xa[:, cols], ya)
        best = max(best, (m.score(Xb[:, cols], yb), m.score(Xc[:, cols], yc)))
    gaps.append(best)
g = np.array(gaps)
print(f"২০ বারের গড়: সেরার test {g[:, 0].mean():.3f}, নতুন ডেটায় {g[:, 1].mean():.3f}")

৫০টি model-এর test accuracy: গড় 0.497, সর্বনিম্ন 0.420, সর্বোচ্চ 0.570
test দেখে বাছা সেরা: model 24, test-এ 0.570
সেই model নতুন ৫০০০টিতে: 0.496
২০ বারের গড়: সেরার test 0.587, নতুন ডেটায় 0.499

৯ · বাস্তবের leakage আর একটি চেকলিস্ট

Leakage শুধু শিক্ষার্থীর ভুল নয়। ২০২৩ সালে Sayash Kapoor আর Arvind Narayanan Patterns জার্নালে ML-ভিত্তিক বিজ্ঞানের গবেষণার একটি জরিপ প্রকাশ করেন। তাঁদের হিসাবে ১৭টি গবেষণা ক্ষেত্রে leakage-এর সমস্যা আগেই চিহ্নিত হয়েছিল, যা মিলিয়ে ২৯৪টি গবেষণাপত্রকে প্রভাবিত করেছিল (preprint সংস্করণে সংখ্যাগুলো একটু আলাদা ছিল)। নিজেদের একটি case study-তে, রাজনীতিবিজ্ঞানের গৃহযুদ্ধ পূর্বাভাসে, তাঁরা দেখান যে leakage সংশোধনের পর জটিল ML model-গুলো পুরোনো logistic regression-এর চেয়ে উল্লেখযোগ্যভাবে ভালো থাকে না। তাঁরা leakage-এর একটি শ্রেণিবিভাগ আর প্রতিটি গবেষণায় পূরণ করার জন্য “model info sheet” প্রস্তাব করেন। এর মানে এই নয় যে এসব ক্ষেত্রের সব কাজ ভুল; মানে হলো, সতর্কতা সব স্তরে দরকার।

ID-র leakage-এর একটি বহুল উদ্ধৃত উদাহরণ: Saharon Rosset ও সহকর্মীরা ২০০৮ সালের KDD Cup (স্তন ক্যান্সার শনাক্তকরণের প্রতিযোগিতা) জেতার অভিজ্ঞতায় জানান, রোগীর ID-তেই ক্যান্সারের সম্ভাবনার তথ্য ছিল। প্রতিযোগিতায় এমন সংকেত score বাড়ায়, হাসপাতালে নতুন রোগীর ক্ষেত্রে তার মূল্য নেই।

১০ · AI-এর যুগে — AI assistant-এর লেখা split আর মূল্যায়ন যাচাই

“এই CSV দিয়ে একটা model বানিয়ে accuracy দেখাও” বললে AI assistant যে কোড দেয়, তাতে leakage খুব সাধারণ, কারণ ইন্টারনেটের অনেক টিউটোরিয়ালেই পুরো ডেটায় scaling করে তারপর ভাগ করা হয়। কোড চলে, সংখ্যা ভালো আসে, তাই ভুল চোখে পড়ে না।

AI-এর লেখা মূল্যায়নের কোড হাতে পেলে — যাচাইয়ের চেকলিস্ট

• ভাগের লাইন খুঁজে পেয়েছি, আর তার আগে কোনো fit, গড় বা feature বাছাই নেই
• প্রতিটি feature ভবিষ্যদ্বাণীর মুহূর্তে জানা থাকবে, তা কলাম ধরে মিলিয়েছি
• ডেটার একক (গ্রাহক, তারিখ) অনুযায়ী ঠিক ধরনের split হয়েছে, আর দুই ভাগে মিল গুনে দেখেছি
• সংখ্যার পাশে baseline, n আর কয়েকটি ভাগের পরিসর আছে
• কোড নিজে চালিয়েছি, সব warning পড়েছি, আর API নিজের version-এর docs-এ মিলিয়েছি
• কোনো আসল গ্রাহকের নাম, ফোন নম্বর বা অর্ডারের ডেটা AI-তে পেস্ট করিনি