scikit-learn pipeline — fit, transform আর leakage-মুক্ত কাজ

পর্ব ৫৬ (Train, validation আর test — data leakage-এর ফাঁদ)-এ দেখেছেন, preprocessing ভাগের আগে পুরো ডেটায় করলে test-এর তথ্য চুইয়ে ঢোকে, আর এর সহজ প্রতিকার Pipeline. সেখানে Pipeline ছিল এক লাইনের পরিচয়। এই পর্বে সেটিকে পুরো কাজের হাতিয়ার বানাব: বাজারঘরের (এই কোর্সের কাল্পনিক অনলাইন দোকান) অর্ডারের ডেটায়, যেখানে সংখ্যা, category আর ফাঁকা ঘর মেশানো, কাঁচা CSV থেকে নতুন অর্ডারের ফেরতের সম্ভাবনা পর্যন্ত একটি বস্তুতে। Logistic regression আর ROC-AUC-এর বিস্তার পর্ব ৫৯ আর পর্ব ৬০-এ; কোন scaling বা encoding কখন ভালো, তা পর্ব ৬৩ (Feature engineering — scaling, encoding আর নতুন feature)-এর বিষয়। এখানে প্রশ্ন একটাই: এই টুকরোগুলো কীভাবে নির্ভুলভাবে জোড়া লাগে। চালানো যায় এমন ব্লকগুলো পাতাতেই চলে (ব্রাউজারের Python, scikit-learn 1.8.0); scikit-learn প্রথমবার নামতে প্রায় ১০ সেকেন্ড লাগে, পরের run দ্রুত।

১ · একটি চুক্তি, অনেক টুকরো — estimator API

scikit-learn-এর শত শত class একই আচরণের নিয়ম মানে। এই নিয়মকে বলে estimator API. ২০১৩ সালে Lars Buitinck, Gilles Louppe, Mathieu Blondel, Fabian Pedregosa, Andreas Müller-সহ প্রকল্পের ১৫ জন ডেভেলপার “API design for machine learning software: experiences from the scikit-learn project” নামের লেখায় (ECML PKDD ২০১৩-এর সঙ্গে প্রকাশিত, arXiv-এ উন্মুক্ত) এই নকশার কারণ ব্যাখ্যা করেন। তাঁদের মূল নীতিগুলো: সব বস্তুর একই ধরনের interface (consistency), শেখা মান খোলাখুলি দেখা যাবে (inspection), নতুন class যত কম সম্ভব আর ডেটা থাকে NumPy array-র মতো সাধারণ ধরনে (non-proliferation of classes), টুকরো জুড়ে বড় জিনিস বানানো (composition), আর যুক্তিসঙ্গত default.

ছোট একটি হিসাব দিয়ে নিয়মটা হাতে ধরুন। Train-এ ডেলিভারির দিন ২, ৪, ৬. StandardScaler().fit শেখে mean_ = ৪, আর scale_ = population standard deviation = √((৪ + ০ + ৪)/৩) ≈ ১.৬৩৩. এরপর যেকোনো নতুন মান x-কে সে বদলায় z = (x − ৪) ÷ ১.৬৩৩ দিয়ে; নতুন অর্ডারের ১০ দিন হয় ৩.৬৭. নতুন ডেটা দেখে mean_ বদলায় না, কারণ transform কিছু শেখে না। এই ভাগাভাগিই পুরো পর্বের ভিত্তি।

নিয়মটা কাগজে মামুলি, কিন্তু এর ফল বিশাল। যেহেতু প্রতিটি estimator-এর fit আর predict আছে, তাই এমন কোড লেখা যায় যা কোন estimator তা না জেনেই কাজ করে: cross_val_score, Pipeline, পরে GridSearchCV. Python-এ একে বলে duck typing: “হাঁসের মতো হাঁটলে আর ডাকলে, তাকে হাঁস ধরে নাও”. Python-এর class আর inheritance-এর মূল কথা Python কোর্সের class পর্বে আছে।

২ · ভুল পথ বনাম pipeline — একই ডেটায় পাশাপাশি

এক লাইনে মনে করিয়ে দিই: scaler বা imputer পুরো ডেটায় fit করলে test-এর গড় আর median train-এর মাপকাঠিতে ঢুকে যায় (পর্ব ৫৬-এর preprocessing leakage). এবার পুরো পর্বের ডেটা। বাজারঘরের ৩৬০টি কাল্পনিক অর্ডার, প্রতিটিতে জেলা, পণ্যের ধরন, পরিশোধের উপায়, দাম, পরিমাণ, ছাড়ের হার, ডেলিভারির দিন, প্রথম অর্ডার কি না, আর লক্ষ্য returned (পণ্য ফেরত এসেছিল কি না). ডেটা seed দিয়ে বানানো, ফেরতের হার ৩৯%, আর কিছু ঘর ইচ্ছে করে ফাঁকা: দাম ১০টিতে, ডেলিভারির দিন ১৮টিতে, পরিশোধ ১৪টিতে। ফাইলটি পাতার ভেতরেই রাখা, কোড একে returns.csv নামে পড়ে; প্রথম দুই সারি:

order_id,district,category,payment,price,qty,discount_pct,delivery_days,first_order,returned
5001,বরিশাল,fashion,COD,2470,3,0,5,0,1
5002,চট্টগ্রাম,books,card,580,4,20,2,1,0

প্রথম ব্লক শুধু সংখ্যার পাঁচটি কলাম নেয় আর দুটি পথ পাশাপাশি চালায়। ভুল পথে imputer আর scaler পুরো ৩৬০টি সারি দেখে; ঠিক পথে Pipeline শুধু ২৭০টি train সারি দেখে। সঙ্গে estimator API-এর দুটি জিনিস দেখি: get_params আর fit-এর আগে শেখা attribute-এর অনুপস্থিতি।

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import make_pipeline

df = pd.read_csv("returns.csv")
num = ["price", "qty", "discount_pct", "delivery_days", "first_order"]
X, y = df[num], df["returned"]
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.25,
                                          stratify=y, random_state=42)

sc = StandardScaler()                     # hyperparameter যায় __init__-এ
print("সেটিং:", sc.get_params())
print("fit-এর আগে mean_ আছে?", hasattr(sc, "mean_"))

# ভুল পথ: পুরো ডেটায় imputer আর scaler fit, তারপর আলাদা model
imp_all = SimpleImputer(strategy="median").fit(X)
sc_all = StandardScaler().fit(imp_all.transform(X))
prep = lambda d: sc_all.transform(imp_all.transform(d))
leaky = LogisticRegression(max_iter=1000).fit(prep(X_tr), y_tr)

# ঠিক পথ: তিনটি ধাপ এক বস্তুতে, fit শুধু train-এ
pipe = make_pipeline(SimpleImputer(strategy="median"), StandardScaler(),
                     LogisticRegression(max_iter=1000))
pipe.fit(X_tr, y_tr)

print("price-এর median: পুরো ডেটা", imp_all.statistics_[0],
      "| শুধু train", pipe[0].statistics_[0])
print("price-এর গড়   : পুরো ডেটা", round(sc_all.mean_[0], 1),
      "| শুধু train", round(pipe[1].mean_[0], 1))
print("test accuracy: ভুল পথ", round(leaky.score(prep(X_te), y_te), 3),
      "| pipeline", round(pipe.score(X_te, y_te), 3))
print("baseline (সবসময় 'ফেরত নয়'):", round(1 - y_te.mean(), 3))

সেটিং: {'copy': True, 'with_mean': True, 'with_std': True}
fit-এর আগে mean_ আছে? False
price-এর median: পুরো ডেটা 1330.0 | শুধু train 1310.0
price-এর গড়   : পুরো ডেটা 1945.9 | শুধু train 1932.5
test accuracy: ভুল পথ 0.622 | pipeline 0.622
baseline (সবসময় 'ফেরত নয়'): 0.611

৩ · Pipeline আর make_pipeline — ভেতরে কোন ডাক কখন

Pipeline([("imputer", SimpleImputer()), ("scaler", StandardScaler()), ("model", LogisticRegression())]) একটি তালিকা নেয়: প্রতিটি উপাদান (নাম, estimator). শেষটি ছাড়া সবাইকে transformer হতে হয়। make_pipeline(...) একই জিনিস বানায়, শুধু নাম নিজে দেয়: class-এর নাম ছোট হাতে, যেমন simpleimputer, standardscaler, logisticregression. ছোট কাজে make_pipeline সুবিধাজনক; পরে সেটিং খুঁজতে হবে এমন কাজে নিজের ছোট নাম ("pre", "model") দেওয়া ভালো।

Pipeline নিজেও একটি estimator: তারও fit, predict, score আছে। ভেতরে কী ঘটে, তা দেখতে আমরা প্রতিটি ধাপকে একটি ছোট “গুপ্তচর” wrapper-এ মুড়ে দিয়েছিলাম, যা প্রতিটি ডাক লিখে রাখে। ডেটা ইচ্ছে করে ছোট: পাঁচটি অর্ডারের ডেলিভারির দিন ২, ফাঁকা, ৮, ৪, ৬; ফেরত ০, ০, ১, ০, ১. নিচের সব সংখ্যা ও ডাকের ক্রম ডেস্কটপে সেই সত্যিকারের run থেকে (Python 3.14.4, scikit-learn 1.8.0).

1pipe = Pipeline([2  ("imputer", SimpleImputer(strategy="median")),3  ("scaler", StandardScaler()),4  ("model", LogisticRegression())])5pipe.fit(X, y)          # X: 2, NaN, 8, 4, 66pipe.predict_proba(X_new)   # X_new: NaN, 9

ধাপে হাত দেওয়া আর ধাপ__সেটিং নাম

Pipeline-এর ধাপ তিনভাবে পাওয়া যায়: নাম দিয়ে pipe.named_steps["model"] বা pipe["model"], অবস্থান দিয়ে pipe[0], আর শেষটি pipe[-1]. Slice দিলে pipe[:-1] নিজেই একটি Pipeline, যা শুধু প্রস্তুতির অংশ; model-এর আগে ডেটা কেমন দেখায়, তা দেখতে কাজে লাগে। ভেতরের সেটিংয়ের নাম তৈরি হয় দুটি underscore দিয়ে জুড়ে: ধাপের নাম__সেটিং, আর গভীরে গেলে আরও স্তর। পর্ব ৬৬ (Model বাছাই — cross-validation আর hyperparameter search)-এ GridSearchCV ঠিক এই নাম দিয়ে সেটিং বদলাবে। সত্যিকারের run (ডেস্কটপ, Python 3.14.4, scikit-learn 1.8.0), একটি pipeline যার ধাপের নাম "pre" আর "model", আর pre-এর ভেতরে "num" ও "cat" শাখা:

~/bazarghar-ai$ python steps_params.py
True | Pipeline
47 টি nested সেটিং, যেমন:
   model__C = 1.0
   pre__num__simpleimputer__strategy = median
   pre__cat__handle_unknown = ignore
বদলের পরে: 0.1 mean
ValueError: Invalid parameter 'c' for estimator LogisticRegression(C=0.1, max_iter=1000). Valid parame …

প্রথম লাইন বলে named_steps["model"] আর pipe[-1] একই বস্তু, আর pipe[:-1] একটি Pipeline. set_params(model__C=0.1, pre__num__simpleimputer__strategy="mean") গভীরের দুটি সেটিং একসঙ্গে বদলেছে। আর বানান ভুল (model__c, ছোট হাতের c) চুপচাপ উপেক্ষা হয় না, স্পষ্ট ValueError দেয়। AI assistant-এর বানানো parameter নাম ধরতে এটি কাজের।

৪ · ColumnTransformer — সংখ্যা আর category আলাদা পথে

বাস্তবের টেবিলে কলাম মেশানো: দাম সংখ্যা, জেলা লেখা। দামে median বসিয়ে scale করা ঠিক, জেলায় গড় হয় না। জেলার জন্য দরকার one-hot encoding: প্রতিটি জেলার জন্য একটি ০/১ কলাম (পর্ব ৫৮-এ dummy trap-সহ দেখেছেন)। ColumnTransformer কাজটা ভাগ করে: প্রতিটি শাখা (নাম, transformer, কলামের তালিকা); প্রতিটি শাখা নিজের কলাম নিয়ে আলাদা fit করে, আর শেষে সব ফল পাশাপাশি জোড়া হয়।

Category শাখায় দুটি সেটিং জরুরি। SimpleImputer(strategy="most_frequent") ফাঁকা পরিশোধে সবচেয়ে বেশি দেখা মান বসায়। আর OneHotEncoder(handle_unknown="ignore") বলে, train-এ দেখা হয়নি এমন জেলা এলে error না দিয়ে সেই জেলার সব কলাম ০ রাখতে; এই unseen category-এর সমস্যা অংশ ৭-এ সত্যিই ঘটিয়ে দেখব। নিচের stepper চারটি অর্ডারে পুরো ঘটনাটা দেখায় (ডেস্কটপে সত্যিকারের run, scikit-learn 1.8.0).

এবার পুরো ডেটায়। set_output(transform="pandas") বললে transformer-এর ফল NumPy array না হয়ে কলামের নামসহ DataFrame হয় (scikit-learn 1.2 থেকে). আর get_feature_names_out() বলে শেষ পর্যন্ত model কোন কলামগুলো পায়। একটি ফাঁদ: OneHotEncoder default-এ sparse matrix দেয় (বেশিরভাগ ঘর ০ হলে শুধু অশূন্য ঘর রাখার ধরন), আর pandas ফল sparse নিতে পারে না; তাই এখানে sparse_output=False.

import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.pipeline import make_pipeline

df = pd.read_csv("returns.csv")
X = df.drop(columns=["order_id", "returned"])
print("কলামের ধরন:", X.dtypes.astype(str).to_dict())

num = ["price", "qty", "discount_pct", "delivery_days"]
cat = ["district", "category", "payment"]
num_pipe = make_pipeline(SimpleImputer(strategy="median"), StandardScaler())
cat_pipe = make_pipeline(SimpleImputer(strategy="most_frequent"),
                         OneHotEncoder(handle_unknown="ignore", sparse_output=False))
ct = ColumnTransformer([("num", num_pipe, num), ("cat", cat_pipe, cat)],
                       remainder="passthrough")   # first_order যেমন আছে তেমন
ct.set_output(transform="pandas")

Xt = ct.fit_transform(X)
print("আকার:", X.shape, "→", Xt.shape)
names = ct.get_feature_names_out()
for i in range(0, len(names), 3):
    print("  ", ", ".join(names[i:i + 3]))
print("remainder পেল:", ct.transformers_[-1][2])
row = Xt.iloc[0]                                  # প্রথম অর্ডার, রূপান্তরের পরে
print("০ নয় এমন ঘর:", row[row != 0].round(2).to_dict())

কলামের ধরন: {'district': 'str', 'category': 'str', 'payment': 'str', 'price': 'float64', 'qty': 'int64', 'discount_pct': 'int64', 'delivery_days': 'float64', 'first_order': 'int64'}
আকার: (360, 8) → (360, 20)
   num__price, num__qty, num__discount_pct
   num__delivery_days, cat__district_খুলনা, cat__district_চট্টগ্রাম
   cat__district_ঢাকা, cat__district_বরিশাল, cat__district_রাজশাহী
   cat__district_সিলেট, cat__category_books, cat__category_electronics
   cat__category_fashion, cat__category_grocery, cat__category_shoes
   cat__payment_COD, cat__payment_Nagad, cat__payment_bKash
   cat__payment_card, remainder__first_order
remainder পেল: ['first_order']
০ নয় এমন ঘর: {'num__price': 0.28, 'num__qty': 0.43, 'num__discount_pct': -1.04, 'num__delivery_days': 1.24, 'cat__district_বরিশাল': 1.0, 'cat__category_fashion': 1.0, 'cat__payment_COD': 1.0}

Jupyter-এ pipeline-এর নাম লিখে চালালে scikit-learn নিজেই একটি ভাঁজ-খোলা HTML ছবি দেখায় (estimator-এর _repr_html_). এই পাতার ব্রাউজার-Python শুধু লেখা আর matplotlib-এর ছবি দেখায়, ওই HTML নয়; তাই ওপরের ছবিটি হাতে আঁকা। পাতায় বা terminal-এ print(pipe) লেখার আকারে একই কাঠামো দেখায়।

৫ · নিজের transformer — FunctionTransformer আর একটি ছোট class

কখনো আপনার দরকার এমন ধাপ, যা scikit-learn-এ নেই। দুটি পথ। এক, যে রূপান্তর কিছু শেখে না, যেমন দামের log, তার জন্য FunctionTransformer: FunctionTransformer(np.log1p) যেকোনো function-কে transformer বানায়। log1p মানে log(১ + x), যা ০ টাকাতেও চলে; দামের মতো ডান দিকে লম্বা লেজের কলামে log transform বড় মানের দাপট কমায় (কখন দরকার, তা পর্ব ৬৩-এ)। feature_names_out="one-to-one" না দিলে পরে get_feature_names_out ব্যর্থ হয়; ডেস্কটপে আমরা ঠিক এই AttributeError পেয়েছিলাম।

দুই, যে ধাপ train থেকে কিছু শেখে, তার জন্য নিজের class. নিয়মগুলো অংশ ১-এর চুক্তিই:

• BaseEstimator থেকে উত্তরাধিকার নিলে get_params/set_params বিনা খরচে আসে; TransformerMixin দেয় fit_transform. এমন ছোট সাহায্যকারী class-কে বলে mixin.
• __init__ শুধু argument-গুলো একই নামে জমা রাখে; কোনো হিসাব, যাচাই বা ডেটা পড়া নয়। কারণ clone (cross-validation আর grid search যা প্রতিবার করে) get_params পড়ে নতুন বস্তু বানায়; __init__-এ অন্য কিছু ঘটলে copy আর আসল আলাদা হয়ে যায়।
• fit শেখা মান underscore-যুক্ত নামে রাখে আর self ফেরত দেয়। transform শুরুতে check_is_fitted(self) ডাকে, যা underscore-এ শেষ হওয়া attribute খোঁজে, না পেলে NotFittedError.

নিচের UnitPrice একটি নতুন feature বানায়: প্রতি পিসের দাম = দাম ÷ পরিমাণ, আর train-এর ৯৫তম শতাংশের ওপরের মান কেটে সেখানে নামায়। সেই সীমা (cap_) train থেকে শেখা, তাই এটি FunctionTransformer দিয়ে করা যেত না: সীমাটা পুরো ডেটা থেকে নিলে ছোট একটি leakage. তারপর পুরো pipeline-এর ওপর ৫-fold cross-validation, মাপ ROC-AUC (পর্ব ৬০).

import numpy as np, pandas as pd
from sklearn.base import BaseEstimator, TransformerMixin
from sklearn.utils.validation import check_is_fitted
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import FunctionTransformer, OneHotEncoder, StandardScaler
from sklearn.impute import SimpleImputer as Imp
from sklearn.pipeline import make_pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import StratifiedKFold, cross_val_score
class UnitPrice(BaseEstimator, TransformerMixin):    # নতুন কলাম: price ÷ qty
    def __init__(self, cap_q=0.95):
        self.cap_q = cap_q                           # শুধু সেটিং রাখা, হিসাব নয়
    def fit(self, X, y=None):                        # শেখা: train-এর উচ্চ সীমা
        self.cap_ = (X["price"] / X["qty"]).quantile(self.cap_q)
        return self
    def transform(self, X):
        check_is_fitted(self)                        # cap_ না থাকলে NotFittedError
        return X.assign(unit_price=(X["price"] / X["qty"]).clip(upper=self.cap_))
df = pd.read_csv("returns.csv")
X, y = df.drop(columns=["order_id", "returned"]), df["returned"]
try: UnitPrice().transform(X)
except Exception as e: print(type(e).__name__, "→", str(e)[:48], "…")
log1p = FunctionTransformer(np.log1p, feature_names_out="one-to-one")
ct = ColumnTransformer([
    ("log", make_pipeline(Imp(strategy="median"), log1p, StandardScaler()), ["price", "unit_price"]),
    ("num", make_pipeline(Imp(strategy="median"), StandardScaler()),
     ["qty", "discount_pct", "delivery_days"]),
    ("cat", make_pipeline(Imp(strategy="most_frequent"), OneHotEncoder(handle_unknown="ignore")),
     ["district", "category", "payment"])], remainder="passthrough")
pipe = make_pipeline(UnitPrice(), ct, LogisticRegression(max_iter=1000))
cv = StratifiedKFold(5, shuffle=True, random_state=42)
s = cross_val_score(pipe, X, y, cv=cv, scoring="roc_auc")
print("৫টি fold-এর ROC-AUC:", np.round(s, 3), f"গড় {s.mean():.3f} ± {s.std(ddof=1):.3f}")
names = pipe.fit(X, y)[1].get_feature_names_out()
print("ধাপ:", list(pipe.named_steps), "| cap_:", round(pipe[0].cap_, 1), "| কলাম:", len(names))

NotFittedError → This UnitPrice instance is not fitted yet. Call  …
৫টি fold-এর ROC-AUC: [0.769 0.733 0.813 0.748 0.721] গড় 0.757 ± 0.036
ধাপ: ['unitprice', 'columntransformer', 'logisticregression'] | cap_: 3042.5 | কলাম: 21

৬ · Pipeline-এর ওপর cross_val_score — প্রতিটি fold-এ কী নতুন করে শেখে

cross_val_score(pipe, X, y, cv=cv) প্রতিটি fold-এ তিনটি কাজ করে: clone(pipe) দিয়ে একটি শূন্য copy (শুধু সেটিং, কোনো শেখা মান নয়), সেই copy-কে fold-এর train অংশে fit, আর test অংশে score. Pipeline-এর প্রতিটি ধাপ তাই প্রতিটি fold-এ নতুন করে শেখে। নিচের সংখ্যাগুলো ওপরের ব্লকের একই pipeline আর একই folds থেকে, cross_validate(..., return_estimator=True) দিয়ে প্রতিটি fold-এর fit করা copy খুলে পড়া (ডেস্কটপে সত্যিকারের run, scikit-learn 1.8.0).

খেয়াল করুন, পাঁচটি fold-এ শেখা মানগুলো ভিন্ন। Pipeline-এর বাইরে আগে একবার পুরো ডেটায় এগুলো শিখে ফেললে পাঁচটি fold একই মান ব্যবহার করত, আর প্রতিটি test fold নিজের তথ্য আগেই দিয়ে ফেলত। cross_validate, StratifiedKFold বা GridSearchCV দিয়ে model বাছাই আর একই folds-এ ন্যায্য তুলনা পর্ব ৬৬-এর বিষয়; এখানে শুধু জানুন, সেখানে যা কিছু ঘটে, তা এই “প্রতি fold-এ clone আর fit” নিয়মের ওপর দাঁড়িয়ে।

৭ · Pipeline-এর তিনটি সাধারণ বাগ — সত্যিই ঘটিয়ে দেখা

তিনটি বাগই ডেস্কটপে সত্যিই চালানো হয়েছে (Python 3.14.4, scikit-learn 1.8.0, pandas 3.1.1), অংশ ২-এর একই train অংশে fit করা pipeline দিয়ে। আউটপুট হুবহু, শুধু project-এর পথ বদলে ~/bazarghar-ai.

~/bazarghar-ai$ python bugs.py
scikit-learn 1.8.0 | pandas 3.1.1

[1] নতুন ব্যাচে আবার fit (fit_transform)
train-এর গড় [3.35] → z: [-0.97  0.46  1.18]
ব্যাচে নতুন fit  → z: [-1.34  0.27  1.07]
একটি অর্ডার, ৯ দিন → train-এর মাপে [4.06] | নতুন fit-এ [0.]

[2] handle_unknown ভুলে গেলে
ValueError: Found unknown categories ['কুমিল্লা'] in column 0 during transform

[3] dtype মেলে না: ওয়েব ফর্ম থেকে সব মান লেখা (string)
{'district': 'str', 'category': 'str', 'payment': 'str', 'price': 'str', 'qty': 'str', 'discount_pct': 'str', 'delivery_days': 'str', 'first_order': 'str'}
সব string হলেও: [0.797]
price='1,800' দিলে ValueError: Cannot use median strategy with non-numeric data:
could not convert string to float: '1,800'
price='' দিলে ValueError: Cannot use median strategy with non-numeric data:
could not convert string to float: ''
first_order='yes' দিলে ValueError: could not convert string to float: 'yes'

বাগ ১ — test বা নতুন ডেটায় আবার fit

দর্জির গল্পের ভুল। নতুন অর্ডারের ব্যাচে কেউ scaler.fit_transform(batch) লিখলেন, transform-এর বদলে। তিনটি অর্ডারের ২, ৪, ৫ দিন train-এর মাপে −০.৯৭, ০.৪৬, ১.১৮; ব্যাচে নতুন fit-এ −১.৩৪, ০.২৭, ১.০৭. Model অন্য মাপকাঠির সংখ্যা পাচ্ছে, কিন্তু কোনো error নেই। আরও খারাপ শেষ লাইন: একটি অর্ডারের ব্যাচ, ৯ দিন, train-এর মাপে ৪.০৬ (স্পষ্ট অস্বাভাবিক দেরি), নতুন fit-এ ঠিক ০, অর্থাৎ “একদম গড়”. একটি সারির sd শূন্য, তাই scaler সব মান ০ বানায়। একই বাগ ঘটে যখন কেউ pipe.fit(X_test, y_test) দিয়ে “test-এ মানিয়ে” নেন; তখন test আর test থাকে না। প্রতিকার: test আর নতুন ডেটায় শুধু pipe.predict বা pipe.predict_proba; pipeline-এর বাইরে কোনো আলাদা transformer রাখবেন না।

বাগ ২ — handle_unknown ভুলে যাওয়া

OneHotEncoder-এর default handle_unknown="error". Train-এ কুমিল্লার কোনো অর্ডার ছিল না; নতুন অর্ডার আসতেই পুরো অনুমান থেমে গেল। নতুন জেলা, নতুন পণ্যের ধরন বা নতুন পরিশোধের উপায় বাস্তবে আসবেই। "ignore" দিলে অচেনা মানের সব কলাম ০, অর্থাৎ model সেটিকে “কোনো পরিচিত জেলা নয়” ধরে। এটি চুপচাপ মেনে নেওয়াও একটি সিদ্ধান্ত: কত অর্ডারে অচেনা category আসছে, তা আলাদা গুনে নজরে রাখা ভালো। বিরল category একসঙ্গে করার জন্য min_frequency আর handle_unknown="infrequent_if_exist"-ও আছে; সেটি পর্ব ৬৩-এর আলোচনা।

বাগ ৩ — prediction-এর সময় dtype মেলে না

Train-এ দাম ছিল float64; ওয়েব ফর্ম বা JSON থেকে আসা নতুন অর্ডারে সব মান লেখা, অর্থাৎ string আকারে এসেছে। প্রথম ফল অবাক করে: সব string হলেও উত্তর এসেছে (০.৭৯৭), কারণ scikit-learn ভেতরে "1800"-কে সংখ্যায় বদলাতে পেরেছে। এই নিঃশব্দ সাফল্যই বিপদ: পরের দিন কেউ "1,800" (হাজারের কমা) পাঠালে ValueError. সবচেয়ে কপট দ্বিতীয়টি: ফর্মে দাম ফাঁকা থাকলে আসে "", NaN নয়; imputer ফাঁকা string-কে ফাঁকা মান মনে করে না, তাই সে নিজের কাজটাই করতে পারে না। আর first_order="yes" (train-এ ছিল ০/১) সরাসরি ব্যর্থ। প্রতিকার: model-এর সামনে একটি স্পষ্ট ধরনের চুক্তি (schema) রাখুন। কলামের নাম আর dtype train থেকে লিখে রাখুন, নতুন ডেটায় pd.to_numeric(..., errors="coerce") দিয়ে বদলান, ফাঁকা string-কে NaN করুন, আর অমিল হলে স্পষ্টভাবে আটকান (পর্ব ২৩-এ type ঠিক করা দেখেছেন)।

৮ · কাঁচা CSV থেকে নতুন অর্ডারের অনুমান — পুরো pipeline

সব টুকরো এবার এক জায়গায়, আর সঠিক ক্রমে: কাঁচা CSV পড়া, ID আর লক্ষ্য আলাদা করা, সবার আগে ভাগ, preprocessing আর model এক pipeline-এ, শুধু train-এ fit, test-এ একবার মাপা, তারপর তিনটি নতুন অর্ডারে অনুমান। নতুন অর্ডারের দ্বিতীয়টি কুমিল্লার (train-এ নেই), তৃতীয়টির দাম আর পরিশোধ অজানা। শেষে fit করা pipeline joblib দিয়ে একটি ফাইলে লিখে আবার পড়া। ব্রাউজারের Python-এর নিজস্ব অস্থায়ী, মেমোরির ভেতরের file system আছে; ফাইলটি সেখানেই থাকে, পাতা বন্ধ করলে মুছে যায়, আপনার কম্পিউটারে কিছু লেখা হয় না।

import os, joblib, numpy as np, pandas as pd
from sklearn.compose import make_column_transformer
from sklearn.impute import SimpleImputer as Imp
from sklearn.preprocessing import OneHotEncoder, StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score

df = pd.read_csv("returns.csv")                      # কাঁচা CSV, ফাঁকা ঘরসহ
X, y = df.drop(columns=["order_id", "returned"]), df["returned"]
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.25,
                                          stratify=y, random_state=42)
num = ["price", "qty", "discount_pct", "delivery_days"]
cat = ["district", "category", "payment"]
pre = make_column_transformer(
    (make_pipeline(Imp(strategy="median"), StandardScaler()), num),
    (make_pipeline(Imp(strategy="most_frequent"), OneHotEncoder(handle_unknown="ignore")), cat),
    remainder="passthrough")
model = make_pipeline(pre, LogisticRegression(max_iter=1000)).fit(X_tr, y_tr)
print("test ROC-AUC:", round(roc_auc_score(y_te, model.predict_proba(X_te)[:, 1]), 3))

new = pd.DataFrame({"district": ["ঢাকা", "কুমিল্লা", "সিলেট"],      # কুমিল্লা: train-এ নেই
                    "category": ["grocery", "fashion", "shoes"],
                    "payment": ["bKash", "COD", np.nan],              # ফাঁকা payment
                    "price": [650.0, 1800.0, np.nan], "qty": [2, 1, 1],
                    "discount_pct": [0, 20, 10], "delivery_days": [2.0, 4.0, 5.0],
                    "first_order": [0, 1, 0]})
p = model.predict_proba(new)[:, 1]
print("নতুন অর্ডারে ফেরতের সম্ভাবনা:", np.round(p, 3))

joblib.dump(model, "returns_model.joblib")               # ব্রাউজারের অস্থায়ী ফাইলে
again = joblib.load("returns_model.joblib")
print("ফাইল:", os.path.getsize("returns_model.joblib"), "বাইট | একই উত্তর?",
      np.array_equal(again.predict_proba(new)[:, 1], p))

test ROC-AUC: 0.684
নতুন অর্ডারে ফেরতের সম্ভাবনা: [0.02  0.822 0.559]
ফাইল: 5562 বাইট | একই উত্তর? True

৯ · সংরক্ষণ — joblib, pickle-এর ঝুঁকি আর version pinning

Fit করা pipeline ফাইলে রাখাকে বলে model persistence. joblib.dump(model, "returns_model.joblib") আর joblib.load(...) সবচেয়ে প্রচলিত পথ; joblib ভেতরে Python-এর pickle ব্যবহার করে, বড় NumPy array-র জন্য কিছু দক্ষতা যোগ করে। এর দুটি সীমা জানা জরুরি: নিরাপত্তা আর version.

Pickle খোলা মানে কোড চালানো

Python-এর নথি স্পষ্ট সতর্ক করে যে pickle মডিউল নিরাপদ নয়, শুধু বিশ্বস্ত ডেটা খুলতে হবে; scikit-learn-এর model persistence নথিও বলে, অবিশ্বস্ত উৎসের pickle ফাইল কখনো load করবেন না, ঠিক যেমন অচেনা উৎসের কোড চালান না। কারণটা নিচের নিরীহ পরীক্ষায় দেখা যায়: একটি বস্তু pickle-কে বলে রাখে “খোলার সময় এই function চালাও”, আর আমরা শুধু pickle.loads করি। সত্যিকারের run (ডেস্কটপ, Python 3.14.4; function-টি ইচ্ছে করে শুধু print):

import pickle

class NotAModel:
    def __reduce__(self):                 # pickle-কে বলে: খোলার সময় এই function চালাও
        return (print, ("!!! এই লাইন ফাইল খোলার সময় চলেছে; print-এর জায়গায় যেকোনো কোড হতে পারত",))

data = pickle.dumps(NotAModel())
print("ফাইলের আকার:", len(data), "বাইট; এবার শুধু load করছি …")
obj = pickle.loads(data)                 # কোনো method ডাকিনি, তবু কোড চলল
print("load-এর ফল:", obj)

~/bazarghar-ai$ python pickle_danger.py
ফাইলের আকার: 212 বাইট; এবার শুধু load করছি …
!!! এই লাইন ফাইল খোলার সময় চলেছে; print-এর জায়গায় যেকোনো কোড হতে পারত
load-এর ফল: None

২১২ বাইটের একটি ফাইল খুলতেই কোড চলেছে, কোনো method ডাকার আগেই। আক্রমণকারী print-এর জায়গায় ফাইল মোছা বা গোপন তথ্য পাঠানোর কোড বসাতে পারে, আর .joblib বা .pkl নাম দেখে তা বোঝা যায় না। তাই নিয়ম: শুধু নিজের বা যাচাই করা উৎসের model ফাইল খুলুন, ফাইলের hash মিলিয়ে নিন, আর ইন্টারনেট থেকে নামানো “ready model” সরাসরি joblib.load করবেন না। এই deserialization-এর ঝুঁকি নিয়ে বিস্তারিত পড়ুন Cybersecurity কোর্সের secure coding পর্বে আর model ফাইলের supply chain নিয়ে AI নিরাপত্তা পর্বে।

যে version-এ বানানো, সেই version-এ খোলা

scikit-learn-এর নথি অনুযায়ী এক version-এ সংরক্ষিত model অন্য version-এ খোলার কোনো সমর্থিত উপায় নেই; অনেক সময় খোলে, কিন্তু ফল ভিন্ন হতে পারে বা process ভেঙে পড়তে পারে। ১.৩ version (২০২৩) থেকে এমন ক্ষেত্রে InconsistentVersionWarning আসে। লেখার সময় PyPI-তে সর্বশেষ scikit-learn 1.9.1, আর এই কোর্সের পাতাগুলো চলে 1.8.0-এ; তাই সত্যিকারের পরীক্ষা সহজ ছিল। 1.8.0-এর একটি venv-এ model আর একটি ছোট metadata JSON লেখা, তারপর আলাদা একটি venv-এ 1.9.1 দিয়ে খোলা, warning-কে error বানিয়ে:

(sk18) ~/bazarghar-ai$ python save_model.py
saved: 5562 bytes | 1.8.0 3.14.4
(sk18) ~/bazarghar-ai$ python load_model.py
এখন scikit-learn 1.8.0 | model বানানো 1.8.0 দিয়ে
load ঠিক আছে, ধাপ: ['columntransformer', 'logisticregression']

(sk19) ~/bazarghar-ai$ python load_model.py
এখন scikit-learn 1.9.1 | model বানানো 1.8.0 দিয়ে
load থামানো হলো: InconsistentVersionWarning
  estimator: SimpleImputer | সংরক্ষণের version: 1.8.0 | এখনকার: 1.9.1

Warning-কে error না বানালে একই load চলত, শুধু প্রতিটি estimator-এর জন্য একটি করে লম্বা warning ছাপত (এই pipeline-এ সাতটি: SimpleImputer, StandardScaler, Pipeline, OneHotEncoder, FunctionTransformer, ColumnTransformer, LogisticRegression; remainder="passthrough" ভেতরে একটি FunctionTransformer হিসেবে জমা থাকে)। Log-এ এমন warning চোখ এড়িয়ে যাওয়া সহজ, তাই production-এ থামিয়ে দেওয়াই নিরাপদ।

প্রতিকার তিন স্তরে। এক, version pinning: প্রকল্পের lockfile বা requirements-এ scikit-learn==1.8.0 হুবহু লিখে রাখা (পর্ব ১২-এর lockfile), যাতে model যেখানে খোলা হবে সেখানে একই version থাকে। দুই, model-এর পাশে metadata: scikit-learn আর Python-এর version, কলামের নাম, train-এর সারির সংখ্যা, cross-validation-এর score; scikit-learn-এর নথিও প্রশিক্ষণের ডেটার snapshot, কোড আর dependency-র version রাখার পরামর্শ দেয়। তিন, version বদলানোর সময় পুরোনো ফাইল খোলার চেষ্টা না করে কোড আর ডেটা থেকে model আবার train করা; সেজন্যই পুরো কাজ একটি pipeline-এ থাকা দরকার।

১০ · AI-এর যুগে — AI assistant-এর লেখা pipeline যাচাই

“এই CSV থেকে ফেরতের model বানাও” বললে AI assistant প্রায়ই চলনসই কোড দেয়, কিন্তু কয়েকটি ভুল ঘুরেফিরে আসে, কারণ ইন্টারনেটের পুরোনো টিউটোরিয়ালে এগুলোই বেশি।

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

• Split সবার আগে, আর তার আগে বা Pipeline-এর বাইরে কোনো fit, get_dummies বা গড়ের হিসাব নেই
• get_feature_names_out ছাপিয়ে দেখেছি model কোন কলাম পায়; ID বা লক্ষ্য-সম্পর্কিত কলাম সেখানে নেই, আর দরকারি কলাম remainder-এ হারায়নি
• অচেনা category, ফাঁকা মান আর string হিসেবে আসা সংখ্যা দিয়ে নতুন সারিতে predict চালিয়ে দেখেছি
• Score পুরো pipeline-এর cross-validation বা একবারের test থেকে, baseline-এর পাশে আর পরিসরসহ
• প্রতিটি API নিজের scikit-learn version-এর docs-এ মিলিয়েছি, আর সব warning পড়েছি, চাপা দিইনি
• Model ফাইলের সঙ্গে version আর metadata আছে, আর কোনো অচেনা উৎসের pickle খুলিনি; আসল গ্রাহকের ডেটা AI-তে পেস্ট করিনি