একটি অনুমানের ব্যাখ্যা — SHAP আর LIME

পর্ব ৫৬ (Model বোঝা — permutation importance, PDP আর ICE) পুরো model-এর আচরণ দেখেছে: কোন feature সব মিলিয়ে কতটা কাজে লাগে। এই পর্বের প্রশ্ন ছোট আর ধারালো: এই একটি অনুমান কেন এমন হলো? ভিত্তি হিসেবে লাগবে পর্ব ৩৫-এর gradient boosting, পর্ব ২৬-এর probability, আর AI-এর ভিত্তি কোর্সের পর্ব ৫৯-এর log-odds. AI-এর ভিত্তি কোর্সের পর্ব ৭২-এ model card আর দায়িত্বশীল AI-এর মূল কথা এসেছে; এখানে ব্যাখ্যার গণিত আর তার সীমা। চারটি চালানো যায় এমন ব্লক পাতাতেই চলে, একই namespace-এ (একটি চালালে আগেরগুলো নিজে থেকে চলে)। প্রথমবার scikit-learn নামতে প্রায় দশ সেকেন্ড লাগে।

১ · একটি অর্ডার কেন আটকাল — local ব্যাখ্যা কী চায়

বাজারঘর প্রতিটি অর্ডারে একটি প্রতারণা-স্কোর দেয়। একটি অর্ডার আটকে গেছে: ৯,৬০০ টাকার, ১০টি পণ্য, ৬ দিন বয়সী অ্যাকাউন্ট, আগে কোনো অর্ডার নেই, রাত ১২টা থেকে ৫টার মধ্যে দেওয়া। Model বলছে প্রতারণার সম্ভাবনা ০.৭০৯. গ্রাহকসেবার কর্মী জানতে চান কেন; ক্রেতাও জানতে চাইতে পারেন। এই প্রশ্নের উত্তর একটি local explanation: শুধু এই একটি সারির জন্য, প্রতিটি feature স্কোরকে কতটা ঠেলেছে।

Global ব্যাখ্যা (পর্ব ৫৬) বলে “সব অর্ডারে গড়ে টাকার অঙ্ক সবচেয়ে গুরুত্বপূর্ণ”। Local ব্যাখ্যা বলে “এই অর্ডারে অ্যাকাউন্টের বয়স সবচেয়ে বেশি ঠেলেছে”। দুটি একই কথা নয়। একটি feature গড়ে দুর্বল হয়েও কোনো বিশেষ সারিতে প্রধান হতে পারে। ব্যাখ্যা নিয়ে সাধারণ ধারণা (explainability) AI-এর ভিত্তি কোর্সে এসেছে; এখানে আমাদের লক্ষ্য একটি সংখ্যা-ভিত্তিক, যাচাইযোগ্য উত্তর।

প্রথমে একটি মৌলিক প্রশ্ন: “feature-এর অবদান” কোন এককে? প্রতারণার model একটি classifier; তার আউটপুট probability, কিন্তু gradient boosting ভেতরে হিসাব করে log-odds-এ (log(p/(১ − p))), আর গাছের মানগুলো log-odds-এ যোগ হয়। যোগফলে ভাগ করা সহজ বলে এই পর্বের SHAP হিসাব log-odds-এ। Probability-তে ভাগ করলে একই feature-এর অবদান অন্য feature-এর মানের ওপর নির্ভর করে, কারণ sigmoid বাঁকা। এককটি সবসময় স্পষ্ট লিখতে হবে; এটি প্রথম ফাঁদ।

২ · Shapley value — খেলার তত্ত্ব থেকে feature-এর ন্যায্য ভাগ

১৯৫৩ সালে Lloyd Shapley cooperative game-এ লাভ ভাগের একটি নিয়ম প্রকাশ করেন। খেলোয়াড়দের যেকোনো দল (coalition) S একসঙ্গে v(S) মূল্য তৈরি করে। প্রশ্ন: পুরো দলের লাভ v(N) − v(∅) প্রত্যেককে কতটা দেওয়া ন্যায্য? ML-এ খেলোয়াড় হলো feature, আর v(S) হলো “শুধু S-এর feature-গুলো জানলে model গড়ে কী বলত”। M টি feature থাকলে feature i-এর Shapley value:

φ_i = ∑_{S ⊆ N∖{i}} [ |S|! (M − |S| − ১)! / M! ] · ( v(S ∪ {i}) − v(S) )

বন্ধনীর ভেতরটি i-এর প্রান্তিক অবদান: S দলে i যোগ হলে মূল্য কতটা বাড়ে। ওজনটির একটি সহজ মানে আছে। M টি feature-কে এলোমেলো ক্রমে একে একে দলে ঢোকান; i ঢোকার সময় তার আগে ঠিক S দলটি থাকার সম্ভাবনাই এই ওজন। অর্থাৎ φ_i = সব M! ক্রমে i-এর প্রান্তিক অবদানের গড়। Shapley দেখান, নিচের চারটি নীতি একসঙ্গে মানে এমন ভাগ মাত্র একটি (Shapley axioms):

নিচের stepper তিনটি feature-এ পুরো হিসাব হাতে করে: টাকার অঙ্ক বড় (A), নতুন অ্যাকাউন্ট (N), রাতের অর্ডার (T). প্রতিটি coalition-এর মান একটি কাল্পনিক ঝুঁকি-স্কোর।

সমস্যা গোনায়। ক্রম M! টি, coalition ২^M টি। পাঁচটি feature-এ ৩২টি coalition সহজ; ২০টিতে প্রায় দশ লাখ; ৫০টিতে অসম্ভব। তাই বাস্তবে আনুমানিক পদ্ধতি লাগে (অংশ ৫)। তার আগে ছোট ক্ষেত্রে নিখুঁত হিসাব করে রাখা ভালো, যাতে আনুমানিক ফল মেলানো যায়।

৩ · বাজারঘরের অর্ডারে ৩২টি coalition — নিখুঁত হিসাব

নিচের module ৪,০০০টি কাল্পনিক অর্ডার বানায়। পাঁচটি feature: amount (টাকা), items (পণ্যের সংখ্যা, টাকার সঙ্গে জড়িত), acct_days (অ্যাকাউন্টের বয়স), past_orders (আগের অর্ডার, বয়সের সঙ্গে জড়িত), night (রাতের অর্ডার)। আসল নিয়মে প্রতারণা নির্ভর করে শুধু টাকা, অ্যাকাউন্টের বয়স আর রাতের ওপর; items আর past_orders শুধু সঙ্গী। প্রথম ৩,২০০টিতে একটি ছোট HistGradientBoosting classifier শেখে, বাকি ৮০০টি test.

# বাজারঘর (কাল্পনিক দোকান): অর্ডারে প্রতারণার সন্দেহ, seeded ডেটা
import numpy as np
import pandas as pd
from sklearn.ensemble import HistGradientBoostingClassifier

COLS = ["amount", "items", "acct_days", "past_orders", "night"]
ORDER = pd.DataFrame([[9600, 10, 6, 0, 1]], columns=COLS)  # আটকে যাওয়া অর্ডার

def orders(n=4000, seed=57):
    rng = np.random.default_rng(seed)
    amount = np.round(rng.lognormal(7.4, 0.7, n), -1)        # টাকা
    items = np.clip(np.round(amount / 900 + rng.normal(0, 1, n)), 1, 20)
    acct_days = np.round(rng.exponential(300, n))             # অ্যাকাউন্টের বয়স
    past_orders = rng.poisson(acct_days / 30)                 # আগের অর্ডার
    night = (rng.random(n) < 0.15).astype(int)                # রাত ১২টা-৫টা
    logit = (-4.0 + 1.6 * np.log(amount / 1600)
             + 3.0 * np.exp(-acct_days / 30) + 1.4 * night)  # আসল নিয়ম
    fraud = (rng.random(n) < 1 / (1 + np.exp(-logit))).astype(int)
    df = pd.DataFrame(dict(amount=amount, items=items, acct_days=acct_days,
                           past_orders=past_orders, night=night))
    return df, fraud

def fitted():
    X, y = orders()
    model = HistGradientBoostingClassifier(max_iter=80, max_leaf_nodes=4,
                                           min_samples_leaf=50, random_state=0)
    model.fit(X.iloc[:3200], y[:3200])
    bg = X.iloc[:3200].sample(100, random_state=1)            # background
    return model, X, y, bg

এখন v(S)-এর সংজ্ঞা দরকার: “শুধু S জানলে model কী বলত”। Model-কে তো সব কলামেই মান দিতে হয়। সবচেয়ে প্রচলিত উত্তর: S-এর কলামে অর্ডারের মান বসান, আর বাকি কলামে একটি background dataset-এর (এখানে training-এর ১০০টি এলোমেলো সারি) মান; তারপর ১০০টি অনুমানের গড়। একে বলে interventional (বা marginal) পদ্ধতি। v(∅) হলো background-এ model-এর গড় আউটপুট, যার নাম base value. প্রথম ব্লক ৩২টি coalition-এর প্রতিটিতে v(S) গোনে, তারপর অংশ ২-এর সূত্রে φ বের করে efficiency যাচাই করে।

import numpy as np
import pandas as pd
from itertools import combinations
from math import factorial
from sklearn.metrics import roc_auc_score
from bazar_fraud import fitted, ORDER, COLS

model, X, y, bg = fitted()
print(f"fraud rate {y.mean():.3f} | test AUC "
      f"{roc_auc_score(y[3200:], model.predict_proba(X.iloc[3200:])[:, 1]):.3f}")
x, B, M = ORDER.to_numpy()[0], bg.to_numpy(), len(COLS)

def f(Z):                                   # model-এর log-odds
    return model.decision_function(pd.DataFrame(Z, columns=COLS))

def v_int(S):                               # S অর্ডার থেকে, বাকিটা background থেকে
    Z = B.copy()
    Z[:, list(S)] = x[list(S)]
    return f(Z).mean()

def shapley(v):                             # সব 2^M coalition গুনে নিখুঁত হিসাব
    vals = {S: v(S) for k in range(M + 1) for S in combinations(range(M), k)}
    phi = np.zeros(M)
    for S, vS in vals.items():
        for i in set(range(M)) - set(S):
            w = factorial(len(S)) * factorial(M - len(S) - 1) / factorial(M)
            phi[i] += w * (vals[tuple(sorted(S + (i,)))] - vS)
    return phi, vals
phi, vals = shapley(v_int)
base, fx = vals[()], vals[tuple(range(M))]
print("coalitions:", len(vals))
print(f"base E[f] = {base:.3f} (p {1 / (1 + np.exp(-base)):.3f}) | "
      f"f(order) = {fx:.3f} (p {model.predict_proba(ORDER)[0, 1]:.3f})")
print(pd.Series(phi, index=COLS).round(3).to_string())
print(f"sum(phi) = {phi.sum():.4f}  f - base = {fx - base:.4f}")

fraud rate 0.059 | test AUC 0.840
coalitions: 32
base E[f] = -3.457 (p 0.031) | f(order) = 0.892 (p 0.709)
amount         1.578
items          0.595
acct_days      1.644
past_orders   -0.268
night          0.799
sum(phi) = 4.3484  f - base = 4.3484

৪ · “অনুপস্থিত” feature-এর মানে — interventional বনাম conditional

Shapley-র সূত্র নির্দিষ্ট; অস্পষ্ট শুধু v(S). “items জানা নেই” মানে কী? দুটি প্রধান উত্তর আছে। Interventional: items-এর জায়গায় background-এর যেকোনো মান বসানো হয়, বাকি feature যা-ই হোক। এটি model-কে প্রশ্ন করে: “এই কলাম বদলে দিলে আউটপুট কী হয়?” Conditional (conditional SHAP): জানা feature-গুলোর সঙ্গে মানানসই সারি থেকে মান নেওয়া হয়, অর্থাৎ E[f(X) | X_S = x_S]. এটি ডেটাকে প্রশ্ন করে: “S জানলে বাকিগুলো সাধারণত কেমন হয়?” Feature স্বাধীন হলে দুটি একই। জড়িত হলে নয়। নিচের stepper সবচেয়ে ছোট উদাহরণে পার্থক্যটি দেখায়।

দ্বিতীয় ব্লক বাজারঘরের ডেটায় conditional রূপ চালায়। প্রতিটি coalition S-এর জন্য training-এর ৩,২০০টি সারি থেকে S-এর কলামে অর্ডারের সবচেয়ে কাছের ৫০টি সারি (standardised দূরত্বে, kd-tree দিয়ে) নিয়ে তাদের ওপর গড় করে। এটি conditional প্রত্যাশার একটি সরল, আনুমানিক রূপ; গবেষণায় আরও নিখুঁত পদ্ধতি আছে (যেমন Aas ও সহকর্মীদের ২০২১ সালের কাজ)।

from sklearn.neighbors import NearestNeighbors

P = X.iloc[:3200].to_numpy()                # conditional-এর জন্য বড় pool
sd = P.std(axis=0)
print("corr(amount, items) =", round(np.corrcoef(P[:, 0], P[:, 1])[0, 1], 2),
      "| corr(acct_days, past_orders) =", round(np.corrcoef(P[:, 2], P[:, 3])[0, 1], 2))

def v_cond(S, k=50):                        # S-এ অর্ডারের মতো সারিগুলোর গড়
    if not S:
        return f(P).mean()
    S = list(S)
    nn = NearestNeighbors(n_neighbors=k, algorithm="kd_tree").fit(P[:, S] / sd[S])
    idx = nn.kneighbors(x[S][None, :] / sd[S], return_distance=False)[0]
    Z = P[idx].copy()
    Z[:, S] = x[S]
    return f(Z).mean()

phi_c, vals_c = shapley(v_cond)
print(pd.DataFrame({"interventional": phi, "conditional": phi_c},
                   index=COLS).round(3).to_string())
print(f"conditional: base {vals_c[()]:.3f}, sum {phi_c.sum():.3f}, "
      f"f - base {fx - vals_c[()]:.3f}")
# বাস্তবে অসম্ভব সারি: interventional কী মিশিয়েছে?
Z = B.copy(); Z[:, 1] = x[1]                # items = 10, amount background থেকে
print("background rows with items = 10 but amount < 3000 Tk:",
      int((Z[:, 0] < 3000).sum()), "of", len(Z))

corr(amount, items) = 0.88 | corr(acct_days, past_orders) = 0.95
             interventional  conditional
amount                1.578        1.016
items                 0.595        1.205
acct_days             1.644        1.312
past_orders          -0.268       -0.024
night                 0.799        0.829
conditional: base -3.446, sum 4.338, f - base 4.338
background rows with items = 10 but amount < 3000 Tk: 79 of 100

কোনটি বেছে নেবেন? প্রশ্ন যদি হয় “model কোন কলামের ওপর নির্ভর করছে” (debugging, নিয়ম মানা হচ্ছে কি না দেখা), তাহলে interventional: সে model যা ছোঁয় না তাকে শূন্য দেয়। প্রশ্ন যদি হয় “ডেটায় কোন তথ্য এই ঝুঁকি বহন করে”, তাহলে conditional. Janzing ও সহকর্মীরা ২০২০ সালে যুক্তি দেন যে feature বদলানো একটি intervention, তাই interventional রূপই স্বাভাবিক; Chen ও সহকর্মীরা একই বছর “true to the model or true to the data” নামে দুই দৃষ্টিভঙ্গি পাশাপাশি রাখেন। বিতর্কটি এখনো খোলা। নিয়ম একটাই: কোন background, কোন রূপ, আর কোন একক, তা ব্যাখ্যার পাশে লিখে রাখুন।

৫ · KernelSHAP আর TreeSHAP — দ্রুত হিসাবের কৌশল

২০১৭ সালে Scott Lundberg আর Su-In Lee NeurIPS-এ SHAP (SHapley Additive exPlanations) প্রস্তাব করেন। তাঁদের একটি পর্যবেক্ষণ: Shapley value হলো একটি weighted least squares সমস্যার সমাধান। প্রতিটি coalition-কে ০/১ ভেক্টর z দিয়ে লিখুন (১ = feature উপস্থিত)। তারপর v(S) ≈ φ₀ + ∑ φ_i z_i সরলরেখা fit করুন, যেখানে |S| = s আকারের coalition-এর ওজন

π(s) = (M − ১) / [ C(M, s) · s · (M − s) ]

এটি KernelSHAP. C(M, s) হলো M থেকে s বাছাইয়ের সংখ্যা। খালি আর পূর্ণ coalition-এর ওজন অসীম (বাস্তবে খুব বড়), যাতে φ₀ = base value আর efficiency মানতেই হয়। খুব ছোট আর খুব বড় coalition বেশি ওজন পায়, কারণ সেগুলো একটি feature-এর একক প্রভাব সবচেয়ে পরিষ্কার দেখায়। সুবিধা: যেকোনো model-এ চলে, আর সব coalition না নিয়ে নমুনা থেকেও আনুমানিক উত্তর দেয়। তৃতীয় ব্লক প্রথমে ৩২টির সবগুলো দিয়ে, তারপর ৮, ১৪ আর ২০টি নমুনা coalition দিয়ে (প্রতিটি ২০টি seed-এ) regression চালায়।

from math import comb

def kernel_w(s):                            # Shapley kernel, s = coalition-এর আকার
    return 1e6 if s in (0, M) else (M - 1) / (comb(M, s) * s * (M - s))

def kernel_shap(coals):                     # weighted least squares: v(S) ≈ φ0 + Σ φi z_i
    Zb = np.array([[1.0] + [i in S for i in range(M)] for S in coals])
    w = np.sqrt([kernel_w(len(S)) for S in coals])
    t = np.array([vals[S] for S in coals])
    coef = np.linalg.lstsq(Zb * w[:, None], t * w, rcond=None)[0]
    return coef[1:]

allS = list(vals)                           # 32টি coalition-ই
print("w by size:", [round(kernel_w(s), 3) for s in range(1, M)])
print("all 32  max|kernel - exact| =", f"{np.abs(kernel_shap(allS) - phi).max():.1e}")
sizes = np.arange(1, M)
p = np.array([kernel_w(s) * comb(M, s) for s in sizes]); p /= p.sum()
for m in (8, 14, 20):                       # নমুনা থেকে আনুমানিক হিসাব
    errs = []
    for seed in range(20):
        rng = np.random.default_rng(seed)
        picked = {(), tuple(range(M))}
        while len(picked) < m:
            s = rng.choice(sizes, p=p)
            picked.add(tuple(sorted(int(i) for i in rng.choice(M, s, replace=False))))
        errs.append(np.abs(kernel_shap(list(picked)) - phi).max())
    print(f"m = {m:2d} coalitions: median max error {np.median(errs):.3f}, "
          f"worst {max(errs):.3f}")

w by size: [0.2, 0.067, 0.067, 0.2]
all 32  max|kernel - exact| = 9.4e-09
m =  8 coalitions: median max error 0.516, worst 1.189
m = 14 coalitions: median max error 0.237, worst 0.463
m = 20 coalitions: median max error 0.074, worst 0.283

TreeSHAP (Lundberg ও সহকর্মীরা, Nature Machine Intelligence, ২০২০) গাছ-ভিত্তিক model-এ গাছের গঠন কাজে লাগিয়ে নিখুঁত হিসাব করে, ২^M গোনা ছাড়াই। এর দুটি রূপ। Interventional রূপ একটি background নেয় আর প্রথম ব্লকের সংজ্ঞাই হুবহু মানে; খরচ background-এর আকারের সঙ্গে রৈখিক। Tree path dependent রূপ background ছাড়া চলে: কোনো feature “অনুপস্থিত” হলে গাছের দুই শাখায় training-এর কতগুলো সারি গিয়েছিল, সেই অনুপাতে গড় নেয়। এটি conditional-এর একটি আনুমানিক রূপ হিসেবে প্রায়ই বর্ণনা করা হয়, তবে সেটি সব ক্ষেত্রে conditional প্রত্যাশার সমান নয়। পরের অংশে দুটিই চলবে।

৬ · shap library ডেস্কটপে — TreeExplainer আর lime-এর সত্যিকারের run

shap আর lime পাতার Python-এ নেই, তাই ডেস্কটপে একটি আলাদা প্রকল্পে একই bazar_fraud.py চালানো হলো (uv দিয়ে প্রকল্প বানানো AI-এর ভিত্তি কোর্সের পর্ব ০৭-এ আছে)। scikit-learn ইচ্ছে করে পাতার মতোই 1.8.0-তে বাঁধা, যাতে model হুবহু এক হয়।

~/bazarghar-explain$ uv init --bare --vcs none --author-from none
~/bazarghar-explain$ uv add "scikit-learn==1.8.0" numpy pandas scipy matplotlib shap lime
 …
 + lime==0.2.0.1
 + numpy==2.5.4
 + pandas==3.1.1
 + scikit-learn==1.8.0
 + shap==0.54.1
 …

import numpy as np
import pandas as pd
import shap
from lime.lime_tabular import LimeTabularExplainer
from bazar_fraud import fitted, ORDER, COLS

model, X, y, bg = fitted()
ex = shap.TreeExplainer(model, data=bg, feature_perturbation="interventional")
sv = ex(ORDER)                                   # একটি অর্ডারের Explanation
print("base value:", round(float(sv.base_values[0]), 3))
for c, v in zip(COLS, sv.values[0]):
    print(f"  {c:12s} {v:+.3f}")
print("base + sum =", round(float(sv.base_values[0] + sv.values[0].sum()), 3),
      "| model log-odds =", round(float(model.decision_function(ORDER)[0]), 3))

tp = shap.TreeExplainer(model)                   # background ছাড়া: path-dependent
print("tree_path_dependent:", np.round(tp.shap_values(ORDER)[0], 3))

test = X.iloc[3200:]
all_sv = ex(test)                                # 800টি অর্ডার, beeswarm-এর কাঁচামাল
print("mean |SHAP| on 800 test orders:")
for c, m in sorted(zip(COLS, np.abs(all_sv.values).mean(0)), key=lambda t: -t[1]):
    print(f"  {c:12s} {m:.3f}")

lx = LimeTabularExplainer(X.iloc[:3200].to_numpy(), feature_names=COLS,
                          class_names=["ok", "fraud"], mode="classification",
                          random_state=0)
for seed in (0, 1):
    lx.random_state = np.random.RandomState(seed)
    e = lx.explain_instance(ORDER.to_numpy()[0], lambda a: model.predict_proba(
        pd.DataFrame(a, columns=COLS)), num_features=5)
    print(f"LIME seed {seed}:", [(n, round(w, 3)) for n, w in e.as_list()])

সত্যিকারের run (ডেস্কটপ, Python 3.14.4; লেখার সময়ে shap 0.54.1, lime 0.2.0.1, scikit-learn 1.8.0, NumPy 2.5.4, pandas 3.1.1):

~/bazarghar-explain$ uv run python desktop_shap.py
base value: -3.457
  amount       +1.578
  items        +0.595
  acct_days    +1.644
  past_orders  -0.268
  night        +0.799
base + sum = 0.892 | model log-odds = 0.892
tree_path_dependent: [ 1.54   0.592  1.632 -0.216  0.79 ]
mean |SHAP| on 800 test orders:
  amount       0.786
  acct_days    0.494
  night        0.277
  past_orders  0.093
  items        0.064
LIME seed 0: [('amount > 2640.00', 0.125), ('night > 0.00', 0.088), ('acct_days <= 85.00', 0.073), ('past_orders <= 2.00', -0.016), ('items > 3.00', 0.011)]
LIME seed 1: [('amount > 2640.00', 0.123), ('night > 0.00', 0.09), ('acct_days <= 85.00', 0.072), ('past_orders <= 2.00', -0.01), ('items > 3.00', 0.009)]

পড়া: (১) Interventional TreeExplainer প্রথম ব্লকের নিজে গোনা মানের সঙ্গে তিন দশমিক পর্যন্ত মেলে (+১.৫৭৮, +০.৫৯৫, +১.৬৪৪, −০.২৬৮, +০.৭৯৯), কারণ দুটি একই সংজ্ঞা, একই ১০০টি background সারি। এভাবে library-কে নিজের ছোট হিসাব দিয়ে যাচাই করা যায়। (২) Background ছাড়া path-dependent রূপ কাছাকাছি কিন্তু আলাদা (past_orders −০.২১৬). (৩) ৮০০টি test অর্ডারে গড় |SHAP| হলো shap-এর bar plot আর beeswarm plot-এর (beeswarm plot: প্রতিটি অর্ডার একটি বিন্দু) কাঁচামাল: টাকা প্রথম, তারপর বয়স আর রাত; items সবার শেষে। এই অর্ডারে বয়স প্রথম, সবার গড়ে টাকা: local আর global আলাদা। (৪) lime library-র default আচরণ আমাদের অংশ ৭-এর রূপ থেকে আলাদা: সে প্রতিটি সংখ্যাকে quartile-এ ভাগ করে (“amount > 2640”) আর ৫,০০০ নমুনা নেয়, তাই দুই seed-এ প্রায় একই উত্তর। এখানে টাকা সবার ওপরে, অথচ পরের ব্লকের continuous LIME-এ টাকার ওজন প্রায় শূন্য। কেন, তা পরের অংশে।

৭ · LIME — আশপাশে নমুনা, নৈকট্যের ওজন আর সরল model

২০১৬ সালে Marco Tulio Ribeiro, Sameer Singh আর Carlos Guestrin KDD-তে LIME (Local Interpretable Model-agnostic Explanations) প্রস্তাব করেন। AI-এর ভিত্তি কোর্সের পর্ব ০৬-এ তাঁদের husky আর নেকড়ের উদাহরণ এসেছে। ধারণাটি সরল: জটিল model-এর একটি বিন্দুর চারপাশে ছোট এলাকায় একটি সরল (রৈখিক) model প্রায় ঠিক থাকে, যেমন পৃথিবী গোল হলেও একটি মাঠ সমতল মনে হয়। ধাপ চারটি: (১) অর্ডারের চারপাশে এলোমেলো নমুনা বানান; (২) প্রতিটির জন্য আসল model-এর probability নিন; (৩) কাছের নমুনাকে বেশি ওজন দিন, proximity kernel exp(−d²/w²) দিয়ে, যেখানে d = standardised দূরত্ব আর w = kernel width; (৪) সেই ওজনে একটি ridge regression fit করে তার coefficient-কে ব্যাখ্যা বলুন।

লক্ষ করুন, LIME-এর প্রশ্ন SHAP-এর থেকে আলাদা। SHAP জিজ্ঞেস করে “গড় অর্ডার থেকে এই অর্ডার পর্যন্ত পথে কে কতটা দিল”। LIME জিজ্ঞেস করে “এই অর্ডারের চারপাশে কোন feature সামান্য বদলালে probability কত বদলায়”, অর্থাৎ ঢাল। চতুর্থ ব্লক তিনটি kernel width (০.৫, lime-এর default ০.৭৫·√M ≈ ১.৬৮, আর ৫) আর দশটি seed-এ, প্রতিবার মাত্র ২০০ নমুনায় LIME চালায়, আর শেষে তুলনার জন্য পর্ব ৫৬-এর global permutation importance.

import matplotlib.pyplot as plt
from sklearn.linear_model import Ridge
from sklearn.inspection import permutation_importance

def lime(seed, width, n=200):               # LIME নিজে লেখা
    rng = np.random.default_rng(seed)
    E = rng.normal(size=(n, M))             # standard একক-এ আশপাশে নমুনা
    E[:, 4] = ((rng.random(n) < 0.15) - x[4]) / sd[4]   # night: 0 বা 1
    Z = np.maximum(x + E * sd, 0)           # ঋণাত্মক টাকা/দিন বাদ
    E = (Z - x) / sd
    w = np.exp(-(E ** 2).sum(axis=1) / width ** 2)      # নৈকট্যের ওজন
    p = model.predict_proba(pd.DataFrame(Z, columns=COLS))[:, 1]
    return Ridge(alpha=1.0).fit(E, p, sample_weight=w).coef_

rows = {}
for width in (0.5, 0.75 * np.sqrt(M), 5.0):
    C = np.array([lime(seed, width) for seed in range(10)])
    rows[f"w={width:.2f}"] = C
    print(f"width {width:.2f}: mean", np.round(C.mean(0), 3),
          "| sd", np.round(C.std(0), 3))
    rank = [COLS[j] for j in np.argmax(np.abs(C), axis=1)]
    print("   top feature over 10 seeds:", pd.Series(rank).value_counts().to_dict())
fig, axes = plt.subplots(1, 3, figsize=(10, 3.4), sharey=True)
for ax, (name, C) in zip(axes, rows.items()):
    ax.boxplot(C, tick_labels=COLS, orientation="horizontal")
    ax.axvline(0, color="grey", lw=0.8)
    ax.set_title(f"LIME, kernel {name}")
    ax.set_xlabel("weight per 1 sd (prob.)")
fig.subplots_adjust(left=0.12, right=0.98, bottom=0.18, wspace=0.08)
plt.show()
pi = permutation_importance(model, X.iloc[3200:], y[3200:], scoring="roc_auc",
                            n_repeats=5, random_state=0)
print("global permutation (AUC drop):",
      {c: round(float(m), 3) for c, m in zip(COLS, pi.importances_mean)})

width 0.50: mean [ 0.004  0.005 -0.017  0.008  0.   ] | sd [0.014 0.008 0.013 0.007 0.   ]
   top feature over 10 seeds: {'acct_days': 5, 'items': 2, 'past_orders': 2, 'amount': 1}
width 1.68: mean [ 0.003  0.027 -0.212  0.044  0.073] | sd [0.01  0.012 0.013 0.022 0.004]
   top feature over 10 seeds: {'acct_days': 10}
width 5.00: mean [ 0.     0.026 -0.263  0.061  0.077] | sd [0.01  0.01  0.023 0.016 0.005]
   top feature over 10 seeds: {'acct_days': 10}
global permutation (AUC drop): {'amount': 0.168, 'items': 0.004, 'acct_days': 0.087, 'past_orders': 0.001, 'night': 0.041}

৮ · ফাঁদ, প্রতারণা আর ক্রেতাকে সৎ ব্যাখ্যা

ফাঁদ ১, কারণ নয়: SHAP value model-এর হিসাবের ভাগ, পৃথিবীর কারণ নয়। items-এর +০.৬০ মানে “model items দেখে স্কোর বাড়িয়েছে”, “বেশি পণ্য কিনলে প্রতারণা বাড়ে” নয়। কারণ-ফলের প্রশ্ন পর্ব ৬৪ (Causal inference-এর পরিচয় — DAG, matching আর difference-in-differences)-এর বিষয়। ফাঁদ ২, জড়িত feature: অংশ ৪-এ দেখেছেন, ভাগ দুই জড়িত কলামের মধ্যে যেকোনোভাবে ছড়াতে পারে; এ জন্য জড়িত কলাম একসঙ্গে গোষ্ঠী করে দেখানো নিরাপদ। ফাঁদ ৩, একক: log-odds-এর ভাগ probability-র ভাগ নয়। ফাঁদ ৪, নমুনার অনিশ্চয়তা: KernelSHAP আর LIME-এর উত্তর seed-এর সঙ্গে নড়ে।

ফাঁদ ৫, ইচ্ছাকৃত প্রতারণা: ২০২০ সালে Dylan Slack ও সহকর্মীরা (AIES সম্মেলনে, “Fooling LIME and SHAP”) দেখান, একটি model প্রায় নিশ্চিতভাবে চিনতে পারে কোন সারি বাস্তব আর কোনটি ব্যাখ্যার জন্য বানানো off-manifold নমুনা। বাস্তব সারিতে সে পক্ষপাতদুষ্ট নিয়ম চালায়, বানানো নমুনায় নিরীহ নিয়ম। ফলে LIME আর KernelSHAP নিরীহ ব্যাখ্যা দেখায়, অথচ আসল সিদ্ধান্ত পক্ষপাতদুষ্ট। শিক্ষা: explanation manipulation সম্ভব, তাই ব্যাখ্যা একা নিরীক্ষার প্রমাণ নয়; আসল সিদ্ধান্তের ডেটায় সরাসরি মাপ (পর্ব ৬০-এর ন্যায্যতার মাপের মতো) লাগে।

ক্রেতাকে ব্যাখ্যা: সংখ্যার তালিকা ক্রেতার কাজে আসে না। দরকার এমন বাক্য যা সত্য, বোঝা যায়, ক্ষতি করে না, আর সম্ভব হলে পথ দেখায়। পথ দেখানোর একটি ধারণা counterfactual explanation (Sandra Wachter, Brent Mittelstadt আর Chris Russell, ২০১৭ সালে প্রকাশিত প্রবন্ধে জনপ্রিয় করেন): “কোন ন্যূনতম পরিবর্তনে ফল বদলাত?” ক্রেতা নিজে যে পরিবর্তন করতে পারেন, তার নাম algorithmic recourse. নিচের stepper প্রথম ব্লকের সংখ্যা থেকে একটি বাক্য বানায় (counterfactual probability-গুলো একই model-এ ডেস্কটপে গোনা)।

ব্যাখ্যার আইনি দিক নিয়েও আলোচনা আছে। যেমন ইউরোপের তথ্য-সুরক্ষা আইন (GDPR) স্বয়ংক্রিয় সিদ্ধান্তে “ব্যাখ্যার অধিকার” দেয় কি না, তা নিয়ে গবেষকেরা ভিন্নমত দিয়েছেন। নিয়ম দেশ আর খাতভেদে আলাদা, তাই নির্দিষ্ট প্রয়োগের আগে আইনজ্ঞের পরামর্শ নেওয়াই নিরাপদ। প্রযুক্তিগত দিক থেকে সাধারণ নীতি: কোন পদ্ধতি, কোন background, কোন একক, আর তার সীমা, সব লিখে রাখা।

৯ · AI-এর যুগে — ব্যাখ্যার কোড আর ভাষা যাচাই

“এই prediction ব্যাখ্যা করো” বললে AI assistant প্রায়ই দ্রুত shap-এর তিন লাইন দেয়, সঙ্গে আত্মবিশ্বাসী ব্যাখ্যা: “অ্যাকাউন্টের বয়স প্রতারণার প্রধান কারণ”। কোড চলতে পারে, ভাষা ভুল। নিচের ভুলগুলো প্রায়ই চোখে পড়ে।

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

• base value + ∑φ = model-এর আউটপুট মিলিয়েছি, আর একক (log-odds বা probability) লিখেছি
• কোন background আর কোন রূপ (interventional বা conditional) ব্যবহার হয়েছে, তা জানি
• ছোট একটি model-এ নিজের নিখুঁত Shapley হিসাবের সঙ্গে library মিলিয়েছি
• LIME বা KernelSHAP কয়েকটি seed আর সেটিংয়ে চালিয়ে বিস্তার দেখেছি
• ব্যাখ্যার ভাষায় কারণের দাবি করিনি, আর জড়িত feature গোষ্ঠী করে দেখিয়েছি
• কোনো আসল ক্রেতার নাম, ফোন নম্বর বা অর্ডারের ইতিহাস AI-তে পেস্ট করিনি