Feature engineering — scaling, encoding আর নতুন feature

পর্ব ৫৬-এ শিখেছেন ডেটা আগে ভাগ করতে হয় আর প্রস্তুতির ধাপও leakage ঘটাতে পারে। পর্ব ৫৭-এ দেখেছেন scaling ছাড়া টাকার কলাম দূরত্ব দখল করে, পর্ব ৫৮-এ one-hot আর dummy-variable trap, পর্ব ৫৯-এ logistic regression আর পর্ব ৬০-এ ROC AUC. পর্ব ৬২ (Exploratory data analysis — প্রশ্ন, পরিসংখ্যান আর chart)-এ ডেটা দেখে প্রশ্ন তোলা হয়; এই পর্বে সেই প্রশ্নের উত্তর feature-এ রূপ দেব, আর প্রতিটি সিদ্ধান্ত held-out ডেটায় মাপব। চালানো যায় এমন ব্লকগুলো পাতাতেই চলে (ব্রাউজারের Python, scikit-learn 1.8.0). scikit-learn প্রথমবার নামতে প্রায় ১০ সেকেন্ড লাগে; পরের run দ্রুত।

১ · Feature engineering কী — model শুধু আপনার দেওয়া সংখ্যা দেখে

Feature engineering মানে কাঁচা কলাম থেকে এমন feature বানানো, যাতে model সম্পর্কটা সহজে ধরতে পারে। কাজগুলো তিন পরিবারে পড়ে। রূপ বদল: একই তথ্য অন্য মাপে, যেমন scaling বা log. Category থেকে সংখ্যা: “cod”, “mobile”, “card” বা হাজারো পণ্যের ID-কে সংখ্যায় আনা। নতুন feature: অনুপাত, দুই কলামের গুণফল, তারিখ থেকে ঘণ্টা, “ফাঁকা ছিল কি না”।

পুরো পর্বের একটি নিয়ম আগেই বলে রাখি: যে রূপান্তর ডেটা থেকে কিছু শেখে (গড়, median, category-র তালিকা, লক্ষ্যের গড়), তা শুধু train অংশে fit হবে, আর test বা নতুন ডেটায় শুধু সেই শেখা মাপকাঠি দিয়ে transform. কেন, তা পর্ব ৫৬-এ দেখেছেন; অংশ ৯-এ প্রতিটি রূপান্তর কী শেখে, তার একটি তালিকা।

বাজারঘরের ফেরতের ডেটা

প্রশ্ন: একটি অর্ডার ফেরত আসবে কি না (returned, 0/1). নিচের কোড ৩০০০টি কাল্পনিক অর্ডার বানায়, প্রায় ১৯% ফেরত। কলাম: মোট দাম (value, টাকা), পণ্যের সংখ্যা, ছাড় ছিল কি না, প্রথম অর্ডার কি না, অর্ডারের ঘণ্টা আর মাস, পরিশোধের ধরন, ১৫০০টি সম্ভাব্য পণ্য-ID, আর ডেলিভারির দিন (১২% ফাঁকা)। এটি পাতায় bazarghar.py নামে রাখা আছে, তাই পরের ব্লকগুলো শুধু from bazarghar import make_orders লেখে (সঙ্গে import pandas, কারণ পাতা ব্লকের নিজের import দেখে প্যাকেজ নামায়)। ডেস্কটপে চালাতে চাইলে এই কোডটি একই নামে পাশে রাখুন।

# বাজারঘরের কাল্পনিক অর্ডার: সব সংখ্যা seed দিয়ে বানানো, বাস্তব নয়
import numpy as np
import pandas as pd

def make_orders(n=3000, seed=42):
    r = np.random.default_rng(seed)
    items = r.integers(1, 7, n)
    per_item = r.lognormal(np.log(450), 0.8, n)          # এক পণ্যের দাম, ডানে লম্বা লেজ
    value = np.round(items * per_item, -1)                # অর্ডারের মোট দাম (টাকা)
    discount = (r.random(n) < 0.35).astype(int)
    first = (r.random(n) < 0.30).astype(int)
    hour = r.integers(0, 24, n)
    month = r.integers(1, 13, n)
    pay = r.choice(["cod", "mobile", "card"], n, p=[0.5, 0.35, 0.15])
    product = r.choice([f"P{i:04d}" for i in range(1500)], n)   # ID-এর মতো, কোনো সংকেত নেই
    days = r.integers(1, 8, n).astype(float)
    miss = r.random(n) < 0.12
    days[miss] = np.nan                                   # courier স্ক্যান করেনি
    logit = (-2.4 + 1.1 * (np.log(per_item) - np.log(450))
             + 1.6 * discount * first + 0.9 * np.cos(2 * np.pi * hour / 24)
             + 0.9 * miss + 0.5 * (pay == "cod"))
    returned = (r.random(n) < 1 / (1 + np.exp(-logit))).astype(int)
    return pd.DataFrame({"value": value, "items": items, "discount": discount,
                         "first_time": first, "hour": hour, "month": month,
                         "pay": pay, "product_id": product, "delivery_days": days,
                         "returned": returned})

২ · Scaling — StandardScaler, MinMaxScaler, RobustScaler আর একটি outlier

Feature scaling-এর তিনটি প্রচলিত পথ, প্রতিটি train থেকে দুটি সংখ্যা শেখে:

প্রথমটি standardization; দ্বিতীয়টি min-max scaling; তৃতীয়টি robust scaling, যা median আর IQR ব্যবহার করে (পর্ব ৩৭-এর robust statistic মনে করুন)। নিচের stepper পাঁচটি অর্ডারের দাম নিয়ে তিনটি scaler চালায়: ১০০, ২০০, ৩০০, ৪০০ টাকা আর একটি ৫০০০ টাকার outlier. সংখ্যাগুলো scikit-learn 1.8.0-এ মেলানো (ডেস্কটপ, সত্যিকারের run).

এখন দেখি model-এর score-এ এর প্রভাব। বাজারঘরের ৮০০টি ডেলিভারি: দূরত্ব মিটারে (১০০০–২৫০০০), পার্সেলের ওজন কেজিতে; দূরত্ব আর ওজন যত বেশি, দেরির সম্ভাবনা তত বেশি। কিন্তু ৩% সারিতে কেউ ওজন গ্রামে লিখেছেন (২.৬ কেজি হয়ে গেছে ২৬০০)। Model একটি k-NN (পর্ব ৫৭), যা দূরত্বে চলে, তাই scaling-এর প্রভাব সরাসরি দেখা যায়। algorithm="kd_tree" দেওয়া হয়েছে, কারণ ব্রাউজারের Python-এ default বিকল্পটি একটি অপ্রাসঙ্গিক warning ছাপে; প্রতিবেশী একই থাকে।

import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split

rng = np.random.default_rng(42)
n = 800
meter = rng.uniform(1000, 25000, n)                 # ডেলিভারির দূরত্ব, মিটারে
kg = rng.gamma(2.0, 1.5, n)                         # পার্সেলের ওজন, কেজিতে
p = 1 / (1 + np.exp(-(0.25 * (meter / 1000 - 13) + 0.9 * (kg - 3))))
late = (rng.random(n) < p).astype(int)              # দেরিতে পৌঁছেছে কি না
bad = rng.random(n) < 0.03                          # ৩% সারিতে ওজন গ্রামে লেখা
X = np.column_stack([meter, np.where(bad, kg * 1000, kg)])
X_tr, X_te, y_tr, y_te, bad_tr, _ = train_test_split(
    X, late, bad, test_size=0.3, random_state=42, stratify=late)
print("ভুল লেখা সারি:", bad.sum(), "| ওজনের median:", round(np.median(X[:, 1]), 2),
      "| সর্বোচ্চ:", round(X[:, 1].max()))

fig, axes = plt.subplots(3, 1, figsize=(7, 4.6), sharex=True)
scalers = [None, StandardScaler(), MinMaxScaler(), RobustScaler()]
for i, sc in enumerate(scalers):
    name = "none" if sc is None else type(sc).__name__
    A, B = (X_tr, X_te) if sc is None else (sc.fit(X_tr).transform(X_tr), sc.transform(X_te))
    acc = KNeighborsClassifier(15, algorithm="kd_tree").fit(A, y_tr).score(B, y_te)
    lo, hi = np.percentile(A[:, 1], [5, 95])        # train-এর মাঝের ৯০% ওজন
    print(f"{name:14s} test accuracy {acc:.3f} | মাঝের ৯০% ওজন: {lo:.2f} থেকে {hi:.2f}")
    if sc is not None:
        ax, w = axes[i - 1], A[~bad_tr, 1]
        ax.scatter(w, rng.random(w.size), s=5, alpha=0.5)
        ax.set_title(f"{name}: normal rows; outliers (not drawn) at "
                     f"{A[bad_tr, 1].min():.1f} to {A[bad_tr, 1].max():.1f}", fontsize=9)
        ax.set_yticks([]); ax.set_xlim(-2, 5)
axes[-1].set_xlabel("weight after scaling (train rows)")
fig.tight_layout()

ভুল লেখা সারি: 22 | ওজনের median: 2.6 | সর্বোচ্চ: 6738
none           test accuracy 0.654 | মাঝের ৯০% ওজন: 0.50 থেকে 9.67
StandardScaler test accuracy 0.658 | মাঝের ৯০% ওজন: -0.16 থেকে -0.14
MinMaxScaler   test accuracy 0.650 | মাঝের ৯০% ওজন: 0.00 থেকে 0.00
RobustScaler   test accuracy 0.792 | মাঝের ৯০% ওজন: -0.79 থেকে 2.73

৩ · বাঁকা দাম, log আর নতুন feature — ratio আর interaction

অনলাইন দোকানের অর্ডারের দাম প্রায় সবসময় ডানে লম্বা লেজওয়ালা: বেশির ভাগ ছোট অর্ডার, অল্প কিছু অনেক বড়। বাজারঘরের ডেটায় গড় ২১৮২ টাকা কিন্তু median ১৪৩০; skewness (বাঁকার মাপ) প্রায় ৩.৪. Log transform এই লেজ গুটিয়ে আনে: ১০০ → ৪.৬, ১০০০ → ৬.৯, ১০০০০ → ৯.২. প্রতি দশগুণ বাড়ায় একই ২.৩ ধাপ। Linear model-এর জন্য এতে দুটি লাভ: কয়েকটি বিশাল অর্ডার সহগ টেনে নিতে পারে না, আর আনুপাতিক প্রভাব সরল হয় (২০০ থেকে ৪০০ আর ২০০০ থেকে ৪০০০ দুটোই “দ্বিগুণ”, log-এ একই দূরত্ব)।

শূন্য থাকলে np.log −∞ দেয়, তখন np.log1p (অর্থাৎ log(1 + x)). ঋণাত্মক মানও থাকলে বা কোন ঘাত ভালো তা ডেটা থেকে বের করতে চাইলে power transform: scikit-learn-এর PowerTransformer (default Yeo-Johnson; Box-Cox শুধু ধনাত্মক মানে)। এটি একটি λ শেখে, তাই অংশ ৯-এর নিয়মে পড়ে; সাধারণ log কিছু শেখে না। আরেকটি পথ binning: দামকে কয়েকটি পরিসরে ভাগ করা (KBinsDiscretizer, যা train থেকে সীমা শেখে)। এতে বাঁকা সম্পর্ক ধরা যায়, কিন্তু একই bin-এর ভেতরের পার্থক্য হারায়।

Ratio আর interaction

Ratio feature দুটি কলামের ভাগফল। ছয়টি পণ্যের ৩০০০ টাকার অর্ডার আর একটি পণ্যের ৩০০০ টাকার অর্ডার আলাদা জিনিস: দ্বিতীয়টিতে একটি দামি জিনিস, যা ফেরতের ঝুঁকি বেশি বহন করে। তাই per_item = value ÷ items. Interaction feature বলে একটির প্রভাব অন্যটির ওপর নির্ভর করে। বাজারঘরে ছাড় একা বা প্রথম অর্ডার একা ফেরত বাড়ায় না, কিন্তু প্রথমবারের গ্রাহক ছাড়ে কিনলে বেশি ফেরত দেন, হয়তো “দেখি কেমন” ভেবে কেনেন। Linear model ছাড়ের একটি সহগ আর প্রথম অর্ডারের একটি সহগ শেখে; “দুটো একসাথে হলে বাড়তি” বোঝাতে গুণফল discount × first_time নিজে দিতে হয়। পর্ব ৫৮-এর polynomial feature এই ধারণারই যান্ত্রিক রূপ, যা সব জোড়ার গুণফল বানায়; feature সংখ্যা তাতে দ্রুত বাড়ে, তাই জ্ঞান থেকে বাছা কয়েকটি interaction প্রায়ই ভালো।

নিচের ব্লক প্রতি ধাপে আগের সব রেখে একটি বদল আনে, আর একটি logistic regression-এর test AUC মাপে (০.৫ মানে কাকতাল, ১ মানে নিখুঁত ক্রম)। একটি ভাগের ফল নড়বড়ে, তাই পাঁচটি আলাদা কাল্পনিক ডেটাসেটে একই পরীক্ষা।

import numpy as np, pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score
from bazarghar import make_orders

df = make_orders(seed=0)
print(df[["value", "items", "discount", "first_time", "returned"]].head(3))
print("value: mean", round(df.value.mean()), "median", df.value.median(),
      "| skew raw", round(df.value.skew(), 2), "log", round(np.log(df.value).skew(), 2))

def versions(d):                                    # প্রতিটি ধাপে আগের সব রেখে একটি বদল
    f1 = d[["value", "items", "discount", "first_time"]]
    f2 = f1.assign(per_item=d.value / d["items"])                      # ratio
    f3 = f2.assign(value=np.log(d.value), per_item=np.log(f2.per_item))  # log
    f4 = f3.assign(disc_x_first=d.discount * d.first_time)             # interaction
    return {"1 raw": f1, "2 + per_item": f2, "3 + log": f3, "4 + disc x first": f4}

scores = {}
for seed in range(5):                               # ৫টি আলাদা কাল্পনিক ডেটাসেট
    d = make_orders(seed=seed)
    tr, te = train_test_split(d, test_size=0.3, random_state=0, stratify=d.returned)
    A, B = versions(tr), versions(te)
    for name in A:
        m = make_pipeline(StandardScaler(), LogisticRegression()).fit(A[name], tr.returned)
        auc = roc_auc_score(te.returned, m.predict_proba(B[name])[:, 1])
        scores.setdefault(name, []).append(auc)
res = pd.DataFrame(scores).T                        # সারি = feature-এর ধাপ, কলাম = seed
res["গড়"] = res.mean(axis=1)
print(res.round(3))

    value  items  discount  first_time  returned
0  3420.0      6         1           0         0
1  2140.0      4         0           0         0
2  1510.0      4         0           0         0
value: mean 2182 median 1430.0 | skew raw 3.4 log -0.16
                      0      1      2      3      4    গড়
1 raw             0.680  0.674  0.699  0.705  0.700  0.691
2 + per_item      0.694  0.690  0.725  0.720  0.722  0.710
3 + log           0.721  0.690  0.742  0.728  0.737  0.723
4 + disc x first  0.746  0.702  0.753  0.741  0.756  0.740

৪ · Category থেকে সংখ্যা — one-hot, ordinal, অচেনা আর অসংখ্য category

One-hot encoding আর dummy-variable trap পর্ব ৫৮-এ দেখেছেন: প্রতিটি category-র জন্য একটি 0/1 কলাম, যাতে model কোনো মিথ্যা ক্রম না ধরে। Nominal কলামে (পরিশোধের ধরন, জেলা) এটিই স্বাভাবিক। Ordinal কলামে (জামার মাপ S < M < L < XL, রেটিং) ক্রম সত্যিই আছে, তখন ordinal encoding একটি কলামে কাজ সারে। OrdinalEncoder-কে ক্রমটি নিজে বলে দিন, যেমন categories=[["S", "M", "L", "XL"]]; না দিলে সে বর্ণানুক্রমে সাজায় (L, M, S, XL), যা অর্থহীন।

Prediction-এর সময় অচেনা category

ধরুন বাজারঘর নভেম্বরে “voucher” দিয়ে পরিশোধ চালু করল। Model train হয়েছিল cod, mobile আর card দেখে। OneHotEncoder-এর handle_unknown ঠিক করে তখন কী হবে। Default "error": transform থেমে যায় (ValueError), যা চালু সিস্টেমে গ্রাহকের অর্ডার আটকে দিতে পারে। "ignore": অচেনা মানের সব one-hot কলাম ০, অর্থাৎ model তাকে “কোনো পরিচিত ধরন নয়” হিসেবে দেখে। "infrequent_if_exist": train-এ বিরল category-গুলোকে একটি “বাকি সব” কলামে রাখা থাকলে অচেনা মানও সেখানে যায়। scikit-learn 1.6 থেকে "warn"-ও আছে, যা warning দিয়ে তারপর আগেরটির মতো চলে। ভুল ডেটা থামাতে চাইলে error; সিস্টেম চালু রাখতে চাইলে ignore, আর অচেনা মানের সংখ্যা লগে রাখা।

অসংখ্য category — high cardinality

পণ্য-ID-র মতো কলামে আলাদা মান হাজারো; একে বলে high cardinality. বাজারঘরের train অংশে ২১০০টি সারিতে ১১৪৩টি আলাদা ID, যার ৫৪৭টি মাত্র একবার এসেছে। One-hot দিলে ১১৪৩টি কলাম, যার বেশির ভাগ একটি সারির জন্য; model সেগুলো মুখস্থ করতে পারে, কিন্তু শেখার মতো কিছু পায় না। আর test-এর ২৩.৮% সারির ID train-এ নেই। উপায়গুলো:

• বিরলদের এক কলামে: min_frequency=5 (৫ বারের কম দেখা সব ID একটি infrequent কলামে) বা max_categories=20.
• গণনা বা হার: “এই পণ্য train-এ কতবার বিক্রি হয়েছে” (count encoding), বা লক্ষ্যের গড় (target encoding, অংশ ৫)। দুটোই train থেকে শেখা।
• Feature hashing: প্রতিটি মানকে একটি hash function দিয়ে নির্দিষ্ট সংখ্যক কলামে পাঠানো (FeatureHasher); অভিধান লাগে না, নতুন ID-ও চলে, কিন্তু কিছু ID একই কলামে মেশে।
• ID-র পেছনের তথ্য: ID-কে তার বৈশিষ্ট্যে বদলানো (পণ্যের শ্রেণি, দাম), আর অর্থহীন ID (অর্ডার নম্বর) বাদ দেওয়া; পর্ব ৫৬-এ দেখেছেন ID-তে ক্রম বা leakage লুকিয়ে থাকতে পারে।

সত্যিকারের run (ডেস্কটপ, Python 3.14.4, scikit-learn 1.8.0, pandas 3.1.1), অংশ ১-এর ডেটায়:

~/bazarghar-ai$ python highcard.py
{}                       কলাম: 1143
{'min_frequency': 5}     কলাম: 27
{'max_categories': 20}   কলাম: 20
test-এর কত ভাগ ID train-এ নেই: 0.238
[1. 3. 0. 2.]

প্রথম তিনটি লাইন OneHotEncoder(handle_unknown="infrequent_if_exist", ...) দিয়ে: min_frequency=5 রাখে ২৬টি ঘন ঘন ID আর একটি product_id_infrequent_sklearn কলাম, মোট ২৭টি; max_categories=20 রাখে ১৯টি সবচেয়ে ঘন ঘন ID আর একটি infrequent কলাম। শেষ লাইনে OrdinalEncoder(categories=[["S", "M", "L", "XL"]]) M, XL, S, L-কে দিয়েছে ১, ৩, ০, ২.

৫ · Target encoding — শক্তিশালী, কিন্তু নিজের উত্তর দেখে ফেলার ফাঁদ

Target encoding প্রতিটি category-কে একটি সংখ্যায় বদলায়: train-এ সেই category-র লক্ষ্যের গড়। জেলা “সিলেট”-এর ২০০টি অর্ডারের ২৫% ফেরত এলে সিলেটের মান ০.২৫. একটি কলামেই কাজ, হাজারো category হলেও। কিন্তু অল্প সারির category-র গড় অবিশ্বাস্য, তাই গড়কে সামগ্রিক গড়ের দিকে টানা হয় (shrinkage বা smoothing):

encoding = (n × category-র গড় + m × সামগ্রিক গড়) ÷ (n + m)

এখানে n সেই category-র train সারির সংখ্যা, আর m একটি smoothing শক্তি: n যত ছোট, মান তত সামগ্রিক গড়ের কাছে। scikit-learn-এর TargetEncoder-এ smooth একটি সংখ্যা (এই m) বা "auto" (default), যেখানে m ডেটা থেকে একটি empirical Bayes হিসাবে আসে। সমস্যা অন্য জায়গায়: একটি সারির encoding-এর হিসাবে তার নিজের label থাকলে feature-টি label-এর ছায়া হয়ে যায়। একবারই দেখা ID-র গড় তো তার নিজের label! এটি target leakage-এর একটি সূক্ষ্ম রূপ, কারণ কোনো ভবিষ্যতের কলাম নেই, শুধু হিসাবের ক্রম ভুল।

সমাধান cross-fitting: train-কে কয়েকটি fold-এ ভাগ করুন, আর প্রতিটি fold-এর সারির encoding বসান অন্য fold-গুলো থেকে হিসাব করে। কোনো সারি নিজের label দেখে নিজের feature পায় না। নিচের stepper আটটি অর্ডারে পুরোটা দেখায় (হাতে হিসাব; smoothing-এর সংখ্যা scikit-learn-এর TargetEncoder(smooth=2.0)-এ মেলানো)।

এখন বাজারঘরের ৩০০০টি অর্ডারে একসাথে দুটি জিনিস: (ক) one-hot-এ অচেনা “voucher”, (খ) কোনো সংকেত নেই এমন product_id-এর তিন রকম ব্যবহার: একেবারে বাদ, naive গড়, আর TargetEncoder. বাকি feature দুটি (প্রতি পণ্যের দামের log আর interaction) তিনটিতেই এক।

import numpy as np, pandas as pd
from sklearn.preprocessing import OneHotEncoder, TargetEncoder
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score
from bazarghar import make_orders

# ক) one-hot: train-এ যা দেখেনি, prediction-এর সময় তা এলে?
old = pd.DataFrame({"pay": ["cod", "mobile", "card"]})
new = pd.DataFrame({"pay": ["cod", "voucher"]})    # "voucher" নতুন পদ্ধতি
ohe = OneHotEncoder(handle_unknown="ignore", sparse_output=False).fit(old)
print(ohe.get_feature_names_out(), ohe.transform(new).tolist())
try:
    OneHotEncoder().fit(old).transform(new)        # default: handle_unknown="error"
except ValueError as e:
    print("ValueError:", str(e).split(" during")[0])

# খ) product_id: ১৫০০টি ID, কোনো সংকেত নেই। target encoding কী দেখায়?
df = make_orders(seed=42)
tr, te = train_test_split(df, test_size=0.3, random_state=0, stratify=df.returned)
print("train-এ আলাদা ID:", tr.product_id.nunique(), "| সারি:", len(tr))
base = lambda d: np.column_stack([np.log(d.value / d["items"]), d.discount * d.first_time])
means = tr.groupby("product_id").returned.mean()            # নিজের সারিসহ গড়
naive = lambda d: d.product_id.map(means).fillna(tr.returned.mean()).to_numpy()
enc = TargetEncoder(random_state=0)
cross_tr = enc.fit_transform(tr[["product_id"]], tr.returned).ravel()  # cross-fitting
cross_te = enc.transform(te[["product_id"]]).ravel()
plans = {"ID ছাড়া": (base(tr), base(te)),
         "naive TE": (np.c_[base(tr), naive(tr)], np.c_[base(te), naive(te)]),
         "TargetEncoder": (np.c_[base(tr), cross_tr], np.c_[base(te), cross_te])}
for name, (a, b) in plans.items():
    m = LogisticRegression().fit(a, tr.returned)
    auc_tr = roc_auc_score(tr.returned, m.predict_proba(a)[:, 1])
    auc_te = roc_auc_score(te.returned, m.predict_proba(b)[:, 1])
    print(f"{name:14s} train AUC {auc_tr:.3f}  test AUC {auc_te:.3f}")

['pay_card' 'pay_cod' 'pay_mobile'] [[0.0, 1.0, 0.0], [0.0, 0.0, 0.0]]
ValueError: Found unknown categories ['voucher'] in column 0
train-এ আলাদা ID: 1143 | সারি: 2100
ID ছাড়া       train AUC 0.706  test AUC 0.752
naive TE       train AUC 0.958  test AUC 0.651
TargetEncoder  train AUC 0.708  test AUC 0.747

একটি খুঁটিনাটি, যা অনেককে বিভ্রান্ত করে: TargetEncoder-এ fit(X, y).transform(X) আর fit_transform(X, y) এক নয়; scikit-learn-এর docs এটি স্পষ্ট বলে। প্রথমটি পুরো train-এর গড় (smoothing-সহ) দিয়ে train-কেই encode করে, তাই naive-এর মতোই ফাঁস করে। পাঁচটি কাল্পনিক ডেটাসেটে সত্যিকারের run (ডেস্কটপ, Python 3.14.4, scikit-learn 1.8.0); প্রতিটি জোড়া (train AUC, test AUC):

~/bazarghar-ai$ python te_seeds.py
seed  ID ছাড়া         naive TE        fit_transform   fit().transform(train)
0     (0.746, 0.747)  (0.959, 0.624)  (0.746, 0.748)  (0.96, 0.619)
1     (0.733, 0.704)  (0.963, 0.604)  (0.733, 0.704)  (0.965, 0.598)
2     (0.737, 0.752)  (0.958, 0.657)  (0.738, 0.745)  (0.96, 0.651)
3     (0.71, 0.742)   (0.956, 0.63)   (0.711, 0.741)  (0.957, 0.623)
4     (0.723, 0.758)  (0.961, 0.62)   (0.727, 0.753)  (0.963, 0.61)

প্রতিটি ডেটাসেটে একই ছবি। “auto” smoothing থাকা সত্ত্বেও fit().transform()-এ train ০.৯৬, test ০.৬০–০.৬৫. সুখবর: Pipeline.fit প্রতিটি transformer-এর fit_transform ডাকে, তাই train-এ cross-fitting আপনা থেকেই হয়, আর predict-এ পুরো train-এর গড়। ঝুঁকি হাতে আলাদা fit আর transform ডাকায়। Pipeline পর্ব ৬৪ (scikit-learn pipeline — fit, transform আর leakage-মুক্ত কাজ)-এর বিষয়।

৬ · ফাঁকা ঘর আর লেখা — missing indicator, দৈর্ঘ্য আর গণনা

পর্ব ২৩-এ missing value পূরণের কৌশল (imputation) দেখেছেন। Model-এর দিক থেকে একটি প্রশ্ন বাকি: “ফাঁকা ছিল” কথাটি নিজেই কি তথ্য? বাজারঘরে ডেলিভারির দিন ফাঁকা থাকে যখন courier পার্সেল স্ক্যান করেননি, আর সেসব অর্ডার বেশি ফেরত আসে। Median দিয়ে ঘর ভরালে এই ইঙ্গিত মুছে যায়। সমাধান একটি missing indicator: আলাদা 0/1 কলাম days_missing. scikit-learn-এ SimpleImputer(strategy="median", add_indicator=True) দুটো কাজ একসাথে করে, আর MissingIndicator শুধু flag বানায়। Imputer-এর median train থেকে শেখা, তাই সেটিও অংশ ৯-এর নিয়মে।

লেখা থেকে সহজ সংখ্যা। গ্রাহকের রিভিউ বা অর্ডারের নোট থেকে model-এর আগে কিছু সরল feature বানানো যায়: অক্ষরের সংখ্যা, শব্দের সংখ্যা, “!” কয়টি, সংখ্যা বা ফোন নম্বর আছে কি না। একটি সতর্কতা: Python-এর len() Unicode code point গোনে, তাই “ভালো” শব্দে ৪টি code point (ভ, া, ল, ো), যদিও চোখে দুটি অক্ষর; আর একই লেখা দুই রকম Unicode রূপে থাকলে দৈর্ঘ্যও আলাদা আসতে পারে, তাই আগে NFC normalization (পর্ব ২৩)। পুরো লেখাকে feature বানানো, যেমন TF-IDF, পর্ব ৬৭ (বাংলা লেখার ডেটা — tokenization, TF-IDF আর একটি classifier)-এ।

৭ · সময়ের feature — ঘণ্টা ২৩ আর ০ পাশাপাশি

তারিখ থেকে ঘণ্টা, সপ্তাহের দিন, মাস, ছুটির দিন কি না, “শেষ অর্ডারের পর কত দিন” বের করা পর্ব ২৬-এর .dt দিয়ে সহজ; সেখানে lag feature আর তার leakage-ও দেখেছেন। কিন্তু ঘণ্টাকে সরাসরি ০ থেকে ২৩ সংখ্যা হিসেবে দিলে একটি সমস্যা: রাত ১১টা (২৩) আর রাত ১২টা (০) মাত্র এক ঘণ্টার ব্যবধান, অথচ সংখ্যায় সবচেয়ে দূরে। Linear model ঘণ্টার একটি সহগ শেখে, অর্থাৎ “ঘণ্টা বাড়লে ফেরত বাড়ে” বা “কমে”, কিন্তু “মধ্যরাতের দুই পাশে বেশি” বোঝাতে পারে না।

Cyclical encoding ঘণ্টাকে ঘড়ির কাঁটার মতো একটি বৃত্তে বসায়। কোণ θ = 2π × ঘণ্টা ÷ 24 (π ≈ ৩.১৪১৬, তাই এক পাক 2π রেডিয়ান = ৩৬০°), আর দুটি কলাম: sin θ আর cos θ. মাসের জন্য পর্যায় (P) 12, সপ্তাহের দিনে 7. সাধারণ সূত্র: sin(2πx ÷ P), cos(2πx ÷ P).

Linear model sin আর cos-এর দুটি সহগ a, b শেখে। গণিতের একটি সূত্রে a sin θ + b cos θ = R cos(θ − φ), অর্থাৎ দিনে একটি শিখর, যেকোনো ঘণ্টায়: মধ্যরাতে, দুপুরে বা সন্ধ্যা ৭টায়, model ডেটা থেকে φ বেছে নেয়। দিনে দুটি শিখর হলে (দুপুর আর রাতে বেশি) এক জোড়া sin/cos যথেষ্ট নয়; তখন 2θ-এর sin/cos যোগ করা, ২৪টি ঘণ্টার one-hot, বা scikit-learn-এর SplineTransformer(extrapolation="periodic"). sin/cos কিছু শেখে না, তাই leakage-এর ঝুঁকি নেই।

৮ · কোন feature কাজে লাগল — permutation importance আর তার ফাঁদ

অনেক feature বানানোর পর প্রশ্ন: কোনটি সত্যিই কাজ করছে? Permutation importance একটি সরল, model-নিরপেক্ষ পরীক্ষা: held-out ডেটায় একটি কলামের মানগুলো সারিদের মধ্যে এলোমেলো করে দিন (অন্য সব অপরিবর্তিত), তারপর score কতটা কমল দেখুন। কলামটি জরুরি হলে score অনেক পড়বে; অপ্রয়োজনীয় হলে প্রায় নড়বে না। ক্রিকেটে একজন ব্যাটসম্যানকে বসিয়ে দলের রান কত কমে, দেখার মতো। sklearn.inspection.permutation_importance-এ n_repeats বলে কতবার এলোমেলো করবেন, আর scoring বলে কোন মাপ।

নিচের ব্লক প্রথমে ঘণ্টাকে কাঁচা আর sin/cos রূপে তুলনা করে, তারপর মাস, ডেলিভারির দিন আর missing flag যোগ করে, আর শেষ model-এ test অংশে permutation importance মাপে। Median শুধু train থেকে।

import numpy as np, pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score
from sklearn.inspection import permutation_importance
from bazarghar import make_orders

df = make_orders(seed=42)
tr, te = train_test_split(df, test_size=0.3, random_state=0, stratify=df.returned)
med = tr.delivery_days.median()                     # median শুধু train থেকে
def feats(d):
    return pd.DataFrame({
        "log_per_item": np.log(d.value / d["items"]), "disc_x_first": d.discount * d.first_time,
        "cod": (d.pay == "cod").astype(int), "hour": d.hour,
        "hour_sin": np.sin(2 * np.pi * d.hour / 24), "hour_cos": np.cos(2 * np.pi * d.hour / 24),
        "month_sin": np.sin(2 * np.pi * d.month / 12), "month_cos": np.cos(2 * np.pi * d.month / 12),
        "days": d.delivery_days.fillna(med), "days_missing": d.delivery_days.isna().astype(int)})
A, B = feats(tr), feats(te)
keep = ["log_per_item", "disc_x_first", "cod"]
plans = {"hour raw": keep + ["hour"], "hour sin/cos": keep + ["hour_sin", "hour_cos"],
         "+ month, days, missing flag": keep + ["hour_sin", "hour_cos", "month_sin",
                                     "month_cos", "days", "days_missing"]}
for name, cols in plans.items():
    m = make_pipeline(StandardScaler(), LogisticRegression()).fit(A[cols], tr.returned)
    print(f"{name:28s} test AUC {roc_auc_score(te.returned, m.predict_proba(B[cols])[:, 1]):.3f}")

pi = permutation_importance(m, B[cols], te.returned, scoring="roc_auc",
                            n_repeats=20, random_state=0)
order = pi.importances_mean.argsort()[::-1]
for j in order:
    print(f"  {cols[j]:13s} AUC কমে {pi.importances_mean[j]:+.3f} ± {pi.importances_std[j]:.3f}")

hour raw                     test AUC 0.762
hour sin/cos                 test AUC 0.813
+ month, days, missing flag  test AUC 0.821
  log_per_item  AUC কমে +0.142 ± 0.013
  hour_cos      AUC কমে +0.097 ± 0.011
  disc_x_first  AUC কমে +0.046 ± 0.007
  days_missing  AUC কমে +0.017 ± 0.005
  cod           AUC কমে +0.008 ± 0.003
  hour_sin      AUC কমে +0.001 ± 0.003
  days          AUC কমে +0.000 ± 0.000
  month_cos     AUC কমে +0.000 ± 0.000
  month_sin     AUC কমে -0.000 ± 0.001

ফাঁদ: প্রায় একই তথ্যের দুটি কলাম

ধরুন কেউ প্রতি পণ্যের দাম ডলারেও একটি কলাম যোগ করলেন, সামান্য গোলমালসহ; দুই কলামের correlation ০.৯৯৮. একটি এলোমেলো করলে অন্যটি প্রায় একই তথ্য দেয়, তাই score তেমন পড়ে না। সত্যিকারের run (ডেস্কটপ, Python 3.14.4, scikit-learn 1.8.0); প্রতিটি সংখ্যা test-এ AUC কতটা কমে:

~/bazarghar-ai$ python corr_trap.py
logistic copy=False log_per_item 0.149, disc_x_first 0.046, hour_cos 0.102
logistic copy=True  log_per_item 0.000, disc_x_first 0.046, hour_cos 0.101, log_per_item_usd 0.144
forest   copy=False log_per_item 0.136, disc_x_first 0.038, hour_cos 0.090
forest   copy=True  log_per_item 0.029, disc_x_first 0.034, hour_cos 0.087, log_per_item_usd 0.033

Logistic regression-এ সব ওজন চলে গেছে ডলারের কলামে, আর আসল log_per_item দেখাচ্ছে ০.০০০, যেন অপ্রয়োজনীয়। কোন কলাম ওজন পাবে, তা প্রায় কাকতালীয় (পর্ব ৫৮-এর multicollinearity). Random forest-এ (অনেক decision tree-এর গড়; পর্ব ৬৬-এ পরিচয়) গুরুত্ব দুই ভাগ হয়ে ০.০২৯ আর ০.০৩৩, যোগফলও আগের ০.১৩৬-এর অনেক কম। দুই ক্ষেত্রেই একজন পাঠক ভুল সিদ্ধান্তে পৌঁছাতে পারেন: “দামের তেমন প্রভাব নেই”। উপায়: correlated কলাম আগে খুঁজে (correlation matrix) দলকে একসাথে এলোমেলো করা, বা একটি রেখে বাকিগুলো বাদ দেওয়া। আর মনে রাখুন: permutation importance বলে এই model কোন কলামে নির্ভর করে, বাস্তবে কোন কারণে ফেরত আসে তা নয়।

Linear model আর tree model-এর চাহিদা আলাদা

Decision tree কীভাবে split বাছে (information gain, পর্ব ৩৮), আর random forest ও gradient boosting কী, তা পর্ব ৬৬ (Model বাছাই — cross-validation আর hyperparameter search)-এ আসবে। মোট কথা, feature engineering model-নির্ভর।

৯ · কোন রূপান্তর কী শেখে — fit শুধু train-এ

পুরো পর্বের রূপান্তরগুলো দুই দলে পড়ে। কিছু শেখে না (stateless): log, sin/cos, দুটি কলামের ভাগফল বা গুণফল, লেখার দৈর্ঘ্য; প্রতিটি সারি একা হিসাব হয়, তাই ভাগের আগে বা পরে করলে একই ফল। ডেটা থেকে কিছু শেখে (stateful): এদের প্রতিটি fit-এ একটি মাপকাঠি মনে রাখে, আর সেটি শুধু train থেকে আসবে।

মূল নিয়মটা পর্ব ৫৬-এর: label দেখে এমন ধাপ (target encoding, feature বাছাই) সবচেয়ে বিপজ্জনক, শুধু মান দেখে এমন ধাপ (scaler) কম; কিন্তু অভ্যাস একই রাখা সহজ: সব শেখা রূপান্তর split-এর পরে, train-এ fit. দ্বিতীয় নিয়ম: prediction-এর সময়ও হুবহু একই কোড আর একই শেখা সংখ্যা; নইলে model অচেনা ডেটা পায় (training-serving skew, ভাবনার প্রশ্ন ৫)। দুটোর সমাধান: সব ধাপ একটি Pipeline-এ, একবার fit, একসাথে সংরক্ষণ। ColumnTransformer দিয়ে বিভিন্ন কলামে বিভিন্ন ধাপ আর বাজারঘরের পুরো leakage-মুক্ত pipeline পর্ব ৬৪ (scikit-learn pipeline — fit, transform আর leakage-মুক্ত কাজ)-এ।

১০ · AI-এর যুগে — AI assistant-এর লেখা feature কোড যাচাই

“ভালো feature বানিয়ে দাও” বললে AI assistant দ্রুত অনেক কলাম বানায়, আর কোড চলে; ভুল লুকানো থাকে চলার মধ্যেই।

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

• Split-এর লাইন খুঁজেছি; তার আগে কোনো scaler, imputer, encoder বা groupby-গড় fit হয়নি
• Target বা label ব্যবহার করে এমন প্রতিটি feature cross-fitting বা Pipeline-এর ভেতরে
• Train আর test score পাশাপাশি দেখেছি, আর একটি সরল baseline-এর সঙ্গে তুলনা করেছি
• প্রতিটি parameter নিজের scikit-learn version-এর docs-এ মিলিয়েছি, আর কোড চালিয়ে সব warning পড়েছি
• নতুন category, ফাঁকা মান আর শূন্য দিয়ে ভাগ prediction-এর সময় কী করবে, তা ছোট উদাহরণে চালিয়ে দেখেছি
• কোনো আসল গ্রাহকের নাম, ফোন নম্বর বা অর্ডারের ডেটা AI-তে পেস্ট করিনি