Multiclass আর multilabel — OvR, OvO, softmax আর classifier chain

AI-এর ভিত্তি কোর্সের পর্ব ৫৯-এ দুইয়ের বেশি শ্রেণির জন্য softmax এক ঝলক দেখেছেন, iris ফুলে; পর্ব ৬০-এ বহু শ্রেণির precision, recall আর macro, micro, weighted গড়। এই কোর্সের পর্ব ১৮-এ দেখেছেন, cross-entropy আসলে categorical বণ্টনের negative log-likelihood. এই পর্ব সেখান থেকে এগোয়: দুই শ্রেণির classifier দিয়ে বহু শ্রেণির কাজ করার কৌশলগুলো কীভাবে কাজ করে আর কোথায় ভাঙে, আর একটি পণ্য একসঙ্গে কয়েকটি ট্যাগ পেলে model আর metric কীভাবে বদলায়। চালানো যায় এমন চারটি ব্লক পাতাতেই চলে (ব্রাউজারের Python, NumPy, pandas, scikit-learn আর matplotlib); প্রথমবার scikit-learn নামতে প্রায় দশ সেকেন্ড লাগে, পরের run দ্রুত।

১ · এক শ্রেণি, নাকি কয়েকটি ট্যাগ — সমস্যার ধরন চেনা

Multiclass classification-এ K > ২টি শ্রেণি, প্রতিটি সারির উত্তর ঠিক একটি: y ∈ {১, …, K}. Model সাধারণত প্রতিটি শ্রেণির একটি score বা সম্ভাবনা দেয়, আর উত্তর হয় সবচেয়ে বড়টির index, অর্থাৎ argmax. Multilabel classification-এ L-টি ট্যাগ, প্রতিটি সারির উত্তর L দৈর্ঘ্যের একটি ০/১ vector, যেমন (১, ১, ১, ০): প্রিমিয়াম, উপহার আর ভঙ্গুর হ্যাঁ, দ্রুত ডেলিভারি না। scikit-learn এই রূপকে বলে label indicator matrix: n সারি × L কলাম।

কিছু algorithm নিজে থেকেই বহু শ্রেণি সামলায়: decision tree আর random forest (প্রতিটি পাতায় শ্রেণির ভাগ), k-NN (প্রতিবেশীদের ভোট), Naive Bayes, আর softmax-এর logistic regression. আবার কিছু algorithm জন্মগতভাবে দুই শ্রেণির, যেমন একটি রেখার দুই পাশ বলে দেওয়া linear classifier আর SVM (পর্ব ২৭, Support Vector Machine — margin, support vector আর hard margin). এদের বহু শ্রেণিতে নিতে হলে সমস্যাটিকে কয়েকটি দুই-শ্রেণির সমস্যায় ভাঙতে হয়। এই ভাঙার কৌশলকে বলে reduction; পরের অংশে দুটি প্রধান কৌশল।

২ · One-vs-rest আর one-vs-one — দুই শ্রেণির classifier দিয়ে অনেক শ্রেণি

One-vs-rest (OvR, অন্য নাম one-vs-all): প্রতিটি শ্রেণির জন্য একটি model, “এই শ্রেণি বনাম বাকি সব”। K শ্রেণিতে K-টি model, প্রতিটি পুরো n সারিতে train হয়। নতুন সারিতে K-টি score f_k(x) আসে; উত্তর argmax_k f_k(x). One-vs-one (OvO): প্রতিটি শ্রেণি-জোড়ার জন্য একটি model, “শুধু এই দুই শ্রেণির মধ্যে কে”। জোড়ার সংখ্যা K(K − ১)/২, আর প্রতিটি model শুধু ওই দুই শ্রেণির সারিতে train হয়। নতুন সারিতে প্রতিটি duel একটি ভোট দেয়; সবচেয়ে বেশি ভোট পাওয়া শ্রেণি জেতে, অর্থাৎ majority vote.

দুই কৌশলের খরচ হিসাব করুন। শ্রেণিগুলো সমান মাপের হলে প্রতিটি শ্রেণিতে n/K সারি। OvR-এ K-টি model × n সারি = Kn সারি-ব্যবহার। OvO-তে K(K − ১)/২-টি model × ২n/K সারি = (K − ১)n. মোট সারির হিসাবে প্রায় সমান! পার্থক্য আসে যখন training-এর খরচ সারির সংখ্যার চেয়ে দ্রুত বাড়ে। Kernel SVM-এর খরচ মোটামুটি n²-এর মতো বাড়ে; তখন অনেকগুলো ছোট সমস্যা একটি বড় সমস্যার চেয়ে সস্তা, আর সেজন্যই LIBSVM (আর তার ওপর বানানো scikit-learn-এর SVC) ভেতরে OvO চালায়। বিপরীতে অনুমানের সময় OvO-কে K(K − ১)/২-টি model চালাতে হয়: ১০০ শ্রেণিতে ৪,৯৫০টি।

নিচের stepper একটি পণ্যে দুই নিয়ম পাশাপাশি চালায়। Score-গুলো বোঝানোর জন্য বানানো, কোনো fit থেকে নয়; লক্ষ করুন, দুই নিয়ম আলাদা উত্তর দিতে পারে।

দুই কৌশলেরই দুর্বলতা আছে। OvR-এর প্রতিটি model একটি অসম সমস্যা দেখে: ৫ শ্রেণিতে সবচেয়ে ছোট শ্রেণি (৮%) বনাম বাকি ৯২%, ফলে সেই model প্রায় সব জায়গায় “না” বলতে শেখে (class imbalance). আর K-টি score আলাদা আলাদা শেখা, তাই তুলনা করা কঠিন: একটি model সাধারণভাবে বেশি আত্মবিশ্বাসী হলে সে বেশি জেতে। OvO-র প্রতিটি model সীমিত ডেটা দেখে, আর একটি duel-এর model এমন সারিতেও ভোট দেয় যা তার দুই শ্রেণির কোনোটিই নয়: বই-বনাম-প্রসাধনী model-কে একটি টিভির ব্যাপারে মত দিতে হয়, যদিও সে কখনো টিভি দেখেনি। OneVsRestClassifier.predict_proba K-টি sigmoid সম্ভাবনাকে শুধু যোগফল দিয়ে ভাগ করে ১-এ আনে; এটি কাজ চালানোর উপায়, তত্ত্বের ফল নয়।

৩ · Softmax — একটি model, সব শ্রেণি একসঙ্গে

তৃতীয় পথ হলো সমস্যাটিকে না ভেঙে একটি model-এ সব শ্রেণি শেখা। Multinomial logistic regression-এ প্রতিটি শ্রেণির একটি ওজন-সারি w_k আর bias b_k, তাই K-টি score বা logits z_k = w_kᵀx + b_k. তারপর softmax:

p_k = e^z_k / Σ_j=1..K e^z_j

e-এর ঘাত সব score-কে ধনাত্মক করে, আর যোগফল দিয়ে ভাগ করলে p₁ + … + p_K = ১. Loss হলো cross-entropy: আসল শ্রেণি c হলে −log p_c, সব সারির গড়। এটি categorical বণ্টনের negative log-likelihood, অর্থাৎ পর্ব ১৮-এর MLE. Score z-এর সাপেক্ষে gradient অসাধারণ সরল: ∂loss/∂z = p − y, যেখানে y আসল শ্রেণির one-hot vector. তাই ∂loss/∂w_k = (p_k − y_k)·x: যে শ্রেণির সম্ভাবনা বেশি দেওয়া হয়েছে তার ওজন x থেকে দূরে সরে, আসল শ্রেণির ওজন x-এর দিকে আসে। Binary logistic-এর σ − y gradient-এর এটিই বহু শ্রেণির রূপ (পর্ব ১১)। নিচের stepper একটি পণ্যে পুরো হিসাব চালায়।

শেষ ধাপের পর্যবেক্ষণটি গুরুত্বপূর্ণ। সব w_k-এ একই vector যোগ করলে softmax বদলায় না, তাই parameter অনন্য নয়; K-টির একটি শ্রেণিকে ভিত্তি (score ০) ধরলে K − ১টি সারিই যথেষ্ট। পরিসংখ্যানের বইয়ে multinomial logit এভাবেই লেখা হয়। scikit-learn বা neural network-এ সাধারণত সব K-টি সারি রাখা হয় আর L2 শাস্তি (পর্ব ১৭) সমাধানটিকে অনন্য করে। দুই শ্রেণিতে softmax হুবহু sigmoid: p₂ = σ(z₂ − z₁).

OvR-এর সঙ্গে softmax-এর একটি গভীর পার্থক্য আছে। OvR-এর K-টি model একে অপরকে চেনে না; softmax-এ একটি শ্রেণির score বাড়লে বাকিদের সম্ভাবনা নিজে থেকেই কমে, কারণ সবাই একই হর ভাগ করে। তাই softmax-এর সম্ভাবনাগুলো একসঙ্গে অর্থবহ। সম্ভাবনা কতটা বিশ্বাসযোগ্য, তা মাপার আর ঠিক করার পদ্ধতি পর্ব ২৬ (Probability calibration — Platt, isotonic আর reliability diagram)-এর বিষয়।

৪ · বাজারঘরের ৫ শ্রেণি — OvR, OvO, multinomial আর ECOC পাশাপাশি

এই পর্বের ডেটা: বাজারঘরের ক্যাটালগের পণ্য, সব seed দিয়ে বানানো, কোনো আসল দোকানের নয়। প্রতিটি পণ্যের চারটি feature: দামের log₁₀ (২ মানে ৳১০০, ৩ মানে ৳১,০০০), ওজন (kg), বিজ্ঞাপনে ছবির সংখ্যা, আর বিবরণে শব্দের সংখ্যা। শ্রেণি পাঁচটি, ভাগ অসম: মুদি ৩৮%, পোশাক ২৬%, ইলেকট্রনিক্স ১৬%, বই ১২%, প্রসাধনী ৮% (কোডে ইংরেজি নামে: grocery, clothing, electronics, books, beauty). একই module পরে চারটি ট্যাগও বানাবে। সব ব্লক নিচের module থেকে ডেটা নেয়।

# বাজারঘর (কাল্পনিক দোকান): পণ্যের শ্রেণি আর ট্যাগ, seed দিয়ে বানানো
import numpy as np
import pandas as pd

CATS = ["grocery", "clothing", "electronics", "books", "beauty"]
TAGS = ["premium", "gift", "fragile", "express"]

def make_products(n=600, seed=25):
    rng = np.random.default_rng(seed)
    y = rng.choice(5, size=n, p=[0.38, 0.26, 0.16, 0.12, 0.08])  # imbalance
    # শ্রেণির গড়: log10(দাম ৳), ওজন kg, ছবির সংখ্যা, বিবরণের শব্দ
    mid = np.array([[2.3, 1.4, 2, 45], [3.0, 0.6, 5, 60], [3.6, 1.1, 4, 95],
                    [2.6, 0.7, 2, 80], [2.9, 0.4, 3, 55]])
    X = mid[y] + rng.normal(0, 1, (n, 4)) * [0.3, 0.35, 1.2, 22]
    X[:, 1] = np.clip(X[:, 1], 0.05, None)
    X[:, 2:] = np.clip(np.round(X[:, 2:]), 0, None)
    df = pd.DataFrame(X.round(2), columns=["log_price", "weight", "photos", "words"])
    df["category"] = np.array(CATS)[y]
    return df

def make_tags(df, seed=26):
    rng = np.random.default_rng(seed)
    n, c = len(df), df.category.to_numpy()
    e = rng.normal(0, 1, (n, 4))
    u = rng.normal(0, 1, n)        # অদেখা কারণ (যেমন উৎসবের সংস্করণ), X-এ নেই
    prem = (df.log_price + 0.25 * e[:, 0] + 0.3 * u > 3.1).to_numpy()
    gift = 1.6 * prem + 1.2 * np.isin(c, ["beauty", "books"]) + u + e[:, 1] > 1.2
    frag = 2.0 * np.isin(c, ["electronics", "beauty"]) + 0.6 * gift + e[:, 2] > 1.4
    expr = 1.0 - 1.5 * frag - 0.9 * df.weight.to_numpy() - u + e[:, 3] > -0.3
    return pd.DataFrame(np.column_stack([prem, gift, frag, expr]).astype(int),
                        columns=TAGS)

প্রথম ব্লক একই LogisticRegression-কে চারভাবে চালায়: OvR-এ মুড়ে, OvO-তে মুড়ে, নিজের মতো (multinomial), আর error-correcting output codes (ECOC)-এ। ECOC-এর ভাবনা: প্রতিটি শ্রেণিকে একটি ০/১ কোড-শব্দ দিন, যেমন মুদি = ১০১১০; প্রতিটি কলাম একটি দুই-শ্রেণির সমস্যা (কোন শ্রেণিগুলো ১-এর দলে, কোনগুলো ০-এর দলে)। নতুন সারিতে সব কলামের model একটি করে বিট দেয়, আর যে শ্রেণির কোড-শব্দ সবচেয়ে কাছে, সে জেতে। কয়েকটি বিট ভুল হলেও কাছের কোড-শব্দ ঠিক থাকতে পারে, ঠিক যেমন ডিজিটাল যোগাযোগের error-correcting code কয়েকটি উল্টে যাওয়া বিট সামলায়। scikit-learn-এর OutputCodeClassifier-এ code_size=2 মানে কলাম = ২ × K = ১০টি, কোড এলোমেলোভাবে বানানো। OvR আসলে একটি বিশেষ কোড: identity matrix.

import warnings
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.multiclass import (OneVsRestClassifier, OneVsOneClassifier,
                                OutputCodeClassifier)
from sklearn.metrics import accuracy_score, f1_score, confusion_matrix
from bazar_catalog import make_products, CATS
warnings.filterwarnings("ignore", message="JsProxy")  # ব্রাউজারের threadpoolctl বার্তা
df = make_products()                                  # ৬০০টি পণ্য, ৫ শ্রেণি
print(df.category.value_counts().to_dict())
Xtr, Xte, ytr, yte = train_test_split(df.drop(columns="category"), df.category,
                                      test_size=0.3, stratify=df.category, random_state=42)
sc = StandardScaler().fit(Xtr)                        # শুধু train দিয়ে fit
Xtr, Xte = sc.transform(Xtr), sc.transform(Xte)
lr = LogisticRegression(max_iter=1000)                # 1.8: নিজে থেকেই multinomial
models = {"OvR": OneVsRestClassifier(lr), "OvO": OneVsOneClassifier(lr),
          "multinomial": lr,
          "ECOC x2": OutputCodeClassifier(lr, code_size=2, random_state=42)}
for name, m in models.items():
    p = m.fit(Xtr, ytr).predict(Xte)
    k = len(getattr(m, "estimators_", [m]))           # কয়টি model train হলো
    print(f"{name:12s} models={k:2d} acc={accuracy_score(yte, p):.3f}"
          f" macroF1={f1_score(yte, p, average='macro'):.3f}")

print("multinomial coef_ shape:", lr.coef_.shape)
cm = confusion_matrix(yte, lr.predict(Xte), labels=CATS)
print(pd.DataFrame(cm, index=CATS, columns=[c[:5] for c in CATS]))
bal = LogisticRegression(class_weight="balanced", max_iter=1000).fit(Xtr, ytr)
cmb = confusion_matrix(yte, bal.predict(Xte), labels=CATS)
print(pd.DataFrame({"recall": cm.diagonal() / cm.sum(axis=1),
                    "recall_bal": cmb.diagonal() / cmb.sum(axis=1)},
                   index=CATS).round(2).T)
print("balanced macroF1:", round(f1_score(yte, bal.predict(Xte), average="macro"), 3))

{'grocery': 213, 'clothing': 164, 'electronics': 102, 'books': 65, 'beauty': 56}
OvR          models= 5 acc=0.800 macroF1=0.673
OvO          models=10 acc=0.828 macroF1=0.736
multinomial  models= 1 acc=0.822 macroF1=0.735
ECOC x2      models=10 acc=0.739 macroF1=0.609
multinomial coef_ shape: (5, 4)
             groce  cloth  elect  books  beaut
grocery         62      0      0      2      0
clothing         1     41      2      1      4
electronics      0      4     27      0      0
books            1      1      1     13      3
beauty           0      9      1      2      5
            grocery  clothing  electronics  books  beauty
recall         0.97      0.84         0.87   0.68    0.29
recall_bal     0.88      0.71         0.87   0.68    0.59
balanced macroF1: 0.729

অনেক শ্রেণিতে imbalance দুই শ্রেণির চেয়ে জটিল, কারণ “ছোট শ্রেণি” একটি নয়, অনেক, আর তারা প্রায়ই একে অপরের সঙ্গে গোলমাল করে (এখানে প্রসাধনী আর পোশাক)। তিনটি অভ্যাস কাজে দেয়: accuracy-র পাশে macro F1 আর প্রতিটি শ্রেণির recall, split-এ stratify (stratified k-fold-এর মতো), আর confusion matrix দেখে গুলিয়ে যাওয়া জোড়ার জন্য নতুন feature ভাবা। Resampling, SMOTE আর threshold-এর পুরো আলোচনা পর্ব ৫০ (Imbalanced ডেটা — resampling, SMOTE, class weight আর threshold)-এ।

OvO-র খরচ বড় ডেটায় কেমন দাঁড়ায়, দেখতে ডেস্কটপে scikit-learn-এর সঙ্গে আসা digits ডেটাসেট (৮×৮ পিক্সেলের হাতে লেখা অঙ্ক, ১০ শ্রেণি, ১,৭৯৭টি ছবি) চালানো হয়েছে।

import time
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.multiclass import OneVsRestClassifier, OneVsOneClassifier

X, y = load_digits(return_X_y=True)                  # ১০ শ্রেণি, 1797 ছবি
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, stratify=y, random_state=42)
sc = StandardScaler().fit(Xtr); Xtr, Xte = sc.transform(Xtr), sc.transform(Xte)
lr = LogisticRegression(max_iter=2000)
for name, m in [("OvR", OneVsRestClassifier(lr)), ("OvO", OneVsOneClassifier(lr)),
                ("multinomial", lr), ("SVC (OvO inside)", SVC())]:
    t0 = time.perf_counter(); m.fit(Xtr, ytr); dt = time.perf_counter() - t0
    k = len(getattr(m, "estimators_", [m]))
    print(f"{name:17s} models={k:2d} fit={dt*1000:6.0f} ms acc={m.score(Xte, yte):.3f}")
svc = SVC(decision_function_shape="ovo").fit(Xtr, ytr)
print("SVC ovo decision_function shape:", svc.decision_function(Xte[:1]).shape)

ডেস্কটপে সত্যিকারের run (Python 3.14.4, scikit-learn 1.9.1, লেখার সময়ে):

$ python digits_cost.py
OvR               models=10 fit=    50 ms acc=0.969
OvO               models=45 fit=   125 ms acc=0.981
multinomial       models= 1 fit=    20 ms acc=0.981
SVC (OvO inside)  models= 1 fit=    19 ms acc=0.983
SVC ovo decision_function shape: (1, 45)

১০ শ্রেণিতে OvO ৪৫টি model বানিয়েছে আর fit-এ সময় নিয়েছে multinomial-এর প্রায় ছয় গুণ; সময়গুলো একটি ল্যাপটপের একটি run, অন্য যন্ত্রে আলাদা হবে। SVC বাইরে থেকে একটি model, কিন্তু decision_function_shape="ovo" দিলে দেখা যায় ভেতরে ৪৫টি duel-এর score. Default "ovr"-এ scikit-learn সেই ভোটগুলোকে (১, ১০) আকারের একটি OvR-ধাঁচের score-এ রূপান্তর করে দেখায়, কিন্তু train হয় OvO-তেই।

৫ · Decision region — OvR-এর ফাঁকা আর দ্বন্দ্বের এলাকা

OvR-এর argmax সবসময় একটি উত্তর দেয়, কিন্তু তার নিচে কী ঘটছে তা দেখা দরকার। দুটি feature (দামের log আর ওজন) নিয়ে model fit করলে প্রতিটি OvR model সমতলে একটি রেখা টানে: রেখার এক পাশে “আমার”, অন্য পাশে “না”। পাঁচটি রেখা মিলে সমতলকে টুকরো টুকরো করে। কোনো টুকরোয় ঠিক একজন দাবি করে (পরিষ্কার), কোথাও কেউ না (ফাঁকা), কোথাও দুজন (দ্বন্দ্ব)। Argmax ফাঁকা আর দ্বন্দ্ব দুটিই চুপচাপ মিটিয়ে দেয়, আর decision boundary সেখানে score-এর মাপকাঠির ওপর নির্ভর করে। ব্লকটি ৩০০ × ৩০০ বিন্দুর একটি জালে তিনটি ছবি আঁকে।

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
import pandas as pd                                   # ডেটা module-এর জন্য
from sklearn.linear_model import LogisticRegression
from sklearn.multiclass import OneVsRestClassifier
from bazar_catalog import make_products, CATS

df = make_products()
X = df[["log_price", "weight"]].to_numpy()            # শুধু ২টি feature, ছবির জন্য
y = df.category.map({c: i for i, c in enumerate(CATS)}).to_numpy()
ovr = OneVsRestClassifier(LogisticRegression()).fit(X, y)
mn = LogisticRegression().fit(X, y)

g1, g2 = np.meshgrid(np.linspace(0.9, 4.7, 300), np.linspace(0, 2.6, 300))
G = np.c_[g1.ravel(), g2.ravel()]
S = np.column_stack([e.decision_function(G) for e in ovr.estimators_])
claims = (S > 0).sum(axis=1)                          # কয়টি model "আমার!" বলছে
print("claims:", {k: round(float(np.mean(claims == k)), 3) for k in range(4)})
for name, m in [("OvR", ovr), ("multinomial", mn)]:
    area = np.bincount(m.predict(G), minlength=5) / len(G)
    print(f"{name:12s} area:", dict(zip(CATS, area.round(3).tolist())))
fig, ax = plt.subplots(1, 3, figsize=(12, 4.2), sharey=True)
claim_cm = ListedColormap(["#d62728", "#ffffff", "#ff7f0e", "#7f0000"])
panels = [(ovr.predict(G), "OvR: argmax of 5 scores", "tab10", 9),
          (mn.predict(G), "Multinomial (softmax)", "tab10", 9),
          (claims, "OvR claims: red 0, white 1, orange 2", claim_cm, 3)]
for a, (Z, title, cmap, vmax) in zip(ax, panels):
    a.contourf(g1, g2, Z.reshape(g1.shape), levels=np.arange(-0.5, 5),
               cmap=cmap, vmin=0, vmax=vmax, alpha=0.45)
    a.scatter(X[:, 0], X[:, 1], c=y, cmap="tab10", vmin=0, vmax=9, s=6)
    a.set_title(title, fontsize=10); a.set_xlabel("log10(price)")
ax[0].set_ylabel("weight (kg)")
fig.suptitle("blue grocery, orange clothing, green electronics, red books, purple beauty")
plt.show()

claims: {0: 0.115, 1: 0.664, 2: 0.22, 3: 0.001}
OvR          area: {'grocery': 0.477, 'clothing': 0.155, 'electronics': 0.347, 'books': 0.021, 'beauty': 0.0}
multinomial  area: {'grocery': 0.436, 'clothing': 0.133, 'electronics': 0.348, 'books': 0.081, 'beauty': 0.002}

৬ · Multilabel — binary relevance, classifier chain আর label powerset

এবার স্টিকারের কাজ। বাজারঘরের চারটি ট্যাগ: premium (দামি পণ্য), gift (উপহারের উপযোগী), fragile (ভঙ্গুর), express (দ্রুত ডেলিভারি সম্ভব)। ট্যাগগুলো একে অপরের সঙ্গে জড়িত: দামি পণ্য প্রায়ই উপহারের, ভঙ্গুর পণ্য সাধারণত দ্রুত ডেলিভারিতে যায় না। ডেটার সূত্রে একটি অদেখা কারণও আছে (যেমন উৎসবের সংস্করণ), যা feature-এ নেই কিন্তু premium আর gift বাড়ায়, express কমায়। তিনটি প্রধান কৌশল:

Binary relevance-এর অনুমান হলো, x জানা থাকলে ট্যাগগুলো পরস্পর স্বাধীন। Classifier chain সম্ভাবনার chain rule অনুসরণ করে: P(y₁, …, y_L | x) = P(y₁ | x) · P(y₂ | x, y₁) · …. Training-এর সময় প্রতিটি model আগের ট্যাগগুলোর আসল মান feature হিসেবে পায়; অনুমানের সময় আসল মান জানা নেই, তাই আগের model-গুলোর অনুমিত মান যায়। ফলে প্রথম দিকের একটি ভুল পরের model-গুলোতে ছড়াতে পারে। scikit-learn-এর নতুন version-এ chain_method দিয়ে অনুমিত ০/১-এর বদলে সম্ভাবনাও পাঠানো যায়। Label powerset নির্ভরতা পুরোপুরি ধরে, কিন্তু যে সমষ্টি training-এ নেই, তা কখনো অনুমান করতে পারে না। নিচের stepper একটি পণ্যে chain চালায়; ওজনগুলো বোঝানোর জন্য বানানো।

৭ · Multilabel-এর metric — Hamming loss, subset accuracy, micro আর macro F1

Multilabel-এ “ঠিক” কথাটির কয়েকটি মানে। পুরো স্টিকার-সমষ্টি হুবহু মিললে ঠিক? নাকি প্রতিটি স্টিকার আলাদা করে? n সারি আর L ট্যাগে চারটি প্রধান মাপ:

• Hamming loss = ভুল ঘরের সংখ্যা / (n × L). প্রতিটি ট্যাগ-ঘর সমান ওজন পায়; কম ভালো।
• Subset accuracy (exact match) = যত ভাগ সারিতে পুরো vector হুবহু মেলে। খুব কঠোর: ২০ ট্যাগের একটি ভুল হলেই সারিটি শূন্য। scikit-learn-এ multilabel ডেটায় accuracy_score এটিই দেয়।
• Micro F1: সব ট্যাগের TP, FP আর FN একসঙ্গে যোগ করে একটি F1; ঘন ঘন আসা ট্যাগ বেশি প্রভাব ফেলে।
• Macro F1: প্রতিটি ট্যাগের F1 আলাদা হিসাব করে সাধারণ গড়; বিরল ট্যাগও সমান ওজন পায়। (আরও আছে: average="samples", প্রতিটি সারির F1-এর গড়।)

কোন metric বাছবেন, তা নির্ভর করে সিদ্ধান্তের ধরনের ওপর। প্রতিটি স্টিকার আলাদা কাজে লাগলে (fragile মানে আলাদা প্যাকিং, express মানে আলাদা রুট) Hamming loss বা ট্যাগভিত্তিক F1. পুরো সমষ্টি একসঙ্গে একটি সিদ্ধান্ত হলে (যেমন একটি নির্দিষ্ট ট্যাগ-সমষ্টি মানে একটি বিশেষ গুদাম) subset accuracy. Krzysztof Dembczyński ও সহকর্মীদের তাত্ত্বিক বিশ্লেষণ একটি পরিষ্কার নিয়ম দেয়: Hamming loss কমাতে প্রতিটি ট্যাগের আলাদা (marginal) সম্ভাবনা ০.৫-এর বেশি হলে হ্যাঁ বলাই সেরা, অর্থাৎ ভালো binary relevance-ই যথেষ্ট; subset ০/১ loss কমাতে যৌথ বণ্টনের সবচেয়ে সম্ভাব্য সমষ্টি লাগে, যেখানে ট্যাগের নির্ভরতা কাজে আসে। পরের ব্লক এটি বাজারঘরের ১,৫০০টি পণ্যে পরীক্ষা করে।

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.multioutput import MultiOutputClassifier, ClassifierChain
from sklearn.metrics import hamming_loss, accuracy_score, f1_score
from bazar_catalog import make_products, make_tags, TAGS

df = make_products(n=1500, seed=7)
Y = make_tags(df)                                     # ৪টি ট্যাগ, প্রতিটি 0/1
X = pd.get_dummies(df, columns=["category"], dtype=float)
print("tag rate:", Y.mean().round(2).to_dict())
print("corr(gift, premium) =", round(Y.gift.corr(Y.premium), 2),
      " corr(express, fragile) =", round(Y.express.corr(Y.fragile), 2))
Xtr, Xte, Ytr, Yte = train_test_split(X, Y, test_size=0.4, random_state=42)
sc = StandardScaler().fit(Xtr)
Xtr, Xte = sc.transform(Xtr), sc.transform(Xte)

lr = LogisticRegression(max_iter=1000)
models = {"binary relevance": MultiOutputClassifier(lr),
          "chain p>g>f>e": ClassifierChain(lr, order=[0, 1, 2, 3]),
          "chain e>f>g>p": ClassifierChain(lr, order=[3, 2, 1, 0])}
rows = {}
for name, m in models.items():
    P = m.fit(Xtr, Ytr).predict(Xte).astype(int)
    rows[name] = {"hamming": hamming_loss(Yte, P),
                  "subset_acc": accuracy_score(Yte, P),
                  "micro_F1": f1_score(Yte, P, average="micro"),
                  "macro_F1": f1_score(Yte, P, average="macro")}
print(pd.DataFrame(rows).T.round(3))
combos = Y.astype(str).agg("".join, axis=1)          # label powerset-এর "শ্রেণি"
print("distinct tag sets:", combos.nunique(), "of", 2 ** len(TAGS), "possible")

tag rate: {'premium': 0.31, 'gift': 0.42, 'fragile': 0.29, 'express': 0.5}
corr(gift, premium) = 0.5  corr(express, fragile) = -0.35
                  hamming  subset_acc  micro_F1  macro_F1
binary relevance    0.265       0.330     0.629     0.644
chain p>g>f>e       0.267       0.372     0.644     0.658
chain e>f>g>p       0.278       0.365     0.599     0.608
distinct tag sets: 16 of 16 possible

৮ · ট্যাগভিত্তিক threshold, আর শ্রেণির শ্রেণিবিন্যাস

Binary relevance প্রতিটি ট্যাগে একটি সম্ভাবনা দেয়, আর default threshold ০.৫. কিন্তু ০.৫ শুধু তখনই স্বাভাবিক, যখন metric প্রতিটি ঘরের ভুলকে সমান গোনে (Hamming). F1 positive-গুলোর ওপর জোর দেয়, তাই প্রায়ই নিচু threshold-এ সেরা হয়। নিয়ম একটাই: threshold বাছা হলো একটি hyperparameter বাছাই, তাই সেটি হবে আলাদা validation set-এ; test set ছোঁয়া হবে শুধু শেষে, একবার। Test দেখে threshold বাছলে test-এর ফল আর নিরপেক্ষ থাকে না, এটি data leakage.

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.multioutput import MultiOutputClassifier
from sklearn.metrics import f1_score, hamming_loss
from bazar_catalog import make_products, make_tags, TAGS

df = make_products(n=1500, seed=7)
Y = make_tags(df).to_numpy()
X = pd.get_dummies(df, columns=["category"], dtype=float).to_numpy()
Xa, Xte, Ya, Yte = train_test_split(X, Y, test_size=0.4, random_state=42)
Xtr, Xva, Ytr, Yva = train_test_split(Xa, Ya, test_size=0.33, random_state=0)
sc = StandardScaler().fit(Xtr)
br = MultiOutputClassifier(LogisticRegression(max_iter=1000))
br.fit(sc.transform(Xtr), Ytr)
proba = lambda X: np.column_stack([p[:, 1] for p in br.predict_proba(sc.transform(X))])
Pva, Pte = proba(Xva), proba(Xte)                     # প্রতিটি ট্যাগের P(হ্যাঁ)

grid = np.round(np.arange(0.10, 0.91, 0.05), 2)
best = []
for j, tag in enumerate(TAGS):                        # শুধু validation দেখে বাছাই
    f1s = [f1_score(Yva[:, j], Pva[:, j] >= t) for t in grid]
    best.append(grid[int(np.argmax(f1s))])
    print(f"{tag:8s} best t={best[-1]:.2f}  val F1: 0.5 -> {f1s[8]:.3f},"
          f" best -> {max(f1s):.3f}")

for name, t in [("t = 0.5", 0.5), ("per-label t", np.array(best))]:
    P = (Pte >= t).astype(int)                        # test-এ একবারই
    print(f"TEST {name:12s} micro F1={f1_score(Yte, P, average='micro'):.3f}"
          f" macro F1={f1_score(Yte, P, average='macro'):.3f}"
          f" hamming={hamming_loss(Yte, P):.3f}")

premium  best t=0.50  val F1: 0.5 -> 0.800, best -> 0.800
gift     best t=0.30  val F1: 0.5 -> 0.630, best -> 0.710
fragile  best t=0.30  val F1: 0.5 -> 0.734, best -> 0.738
express  best t=0.30  val F1: 0.5 -> 0.589, best -> 0.675
TEST t = 0.5      micro F1=0.627 macro F1=0.643 hamming=0.264
TEST per-label t  micro F1=0.677 macro F1=0.689 hamming=0.278

সেরা F1-এর threshold কেন ০.৫-এর নিচে? ধরুন একটি ট্যাগের সম্ভাবনা সত্যিই ঠিক (calibrated). তখন দেখানো যায়, F1 সর্বোচ্চ করার threshold সেই সর্বোচ্চ F1-এর ঠিক অর্ধেক। এখানে সেরা F1 ০.৬৮–০.৭৪, তাই প্রত্যাশিত threshold ০.৩৪–০.৩৭-এর কাছে; grid-এ পাওয়া ০.৩০ এর কাছাকাছি। সম্ভাবনা calibrated না হলে এই সম্পর্ক খাটে না, আর তখন validation-এর grid-ই ভরসা। scikit-learn 1.5 থেকে TunedThresholdClassifierCV cross-validation দিয়ে threshold বাছে, তবে শুধু binary classifier-এর জন্য; multilabel-এ ব্লকের মতো প্রতিটি ট্যাগে হাতে করতে হয়।

৯ · AI-এর যুগে — AI-এর লেখা multiclass আর multilabel কোড যাচাই

“পণ্যের শ্রেণি আর ট্যাগ predict করার কোড দাও” বললে AI assistant দ্রুত চলনসই কোড দেয়, কিন্তু এই বিষয়ে কয়েকটি ভুল বারবার দেখা যায়, আর সেগুলো প্রায়ই কোনো error ছাড়াই ভুল সংখ্যা দেয়।

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

• সমস্যাটি multiclass না multilabel, তা ঠিক করেছি, আর Y-এর আকার (n,) না (n, L), ছেপে দেখেছি
• কয়টি model train হলো (len(estimators_)) গুনে সূত্রের সঙ্গে মিলিয়েছি
• ডেটা আগে ভাগ করেছি, scaler আর threshold শুধু train/validation দিয়ে, test set তালা দেওয়া
• Accuracy-র পাশে প্রতি শ্রেণির recall, macro F1, আর multilabel-এ Hamming loss ও subset accuracy দেখেছি
• একটি সরল baseline (যেমন সবচেয়ে সাধারণ শ্রেণি বা প্রতিটি ট্যাগের হার) আর কয়েকটি seed বা fold-এ তুলনা করেছি
• নিজের version-এর docs পড়েছি, কোনো warning চাপা দিইনি, আর আসল গ্রাহক বা পণ্যের গোপন ডেটা AI-তে পেস্ট করিনি