এক্সপ্লেইনেবল AI (XAI) টেকনিক — LIME ও SHAP-এর ধারণা

# LIME-এর ধারণার একটি সরলীকৃত, সৎ ডেমো (আসল LIME লাইব্রেরির প্রতিলিপি নয়)
import random
random.seed(7)

def black_box(x1, x2):
    # কাল্পনিক "ব্ল্যাক-বক্স" মডেল -- ইচ্ছাকৃতভাবে অ-রৈখিক (nonlinear)
    return 2*x1 + 3*x2 + 0.4*x1*x2 - 0.1*x1**2

point_of_interest = (3.0, 2.0)

# ধাপ ১: point_of_interest-এর কাছাকাছি (একটি ছোট পরিসরে) কিছু পয়েন্ট স্যাম্পল করা
samples = []
for _ in range(60):
    dx1 = random.uniform(-0.5, 0.5)
    dx2 = random.uniform(-0.5, 0.5)
    x1 = point_of_interest[0] + dx1
    x2 = point_of_interest[1] + dx2
    y = black_box(x1, x2)
    samples.append((x1, x2, y))

# ধাপ ২: একটি সরল লিনিয়ার মডেল y = b0 + b1*x1 + b2*x2 ফিট করা -- normal equations দিয়ে
def build_normal_equations(samples):
    XtX = [[0.0]*3 for _ in range(3)]
    Xty = [0.0]*3
    for x1, x2, y in samples:
        row = [1.0, x1, x2]
        for i in range(3):
            Xty[i] += row[i] * y
            for j in range(3):
                XtX[i][j] += row[i] * row[j]
    return XtX, Xty

def solve_3x3(A, b):
    # গাউসিয়ান এলিমিনেশন (partial pivoting) দিয়ে ৩x৩ লিনিয়ার সিস্টেম সমাধান করা
    A = [row[:] for row in A]
    b = b[:]
    n = 3
    for col in range(n):
        pivot_row = max(range(col, n), key=lambda r: abs(A[r][col]))
        A[col], A[pivot_row] = A[pivot_row], A[col]
        b[col], b[pivot_row] = b[pivot_row], b[col]
        pivot = A[col][col]
        for r in range(col+1, n):
            factor = A[r][col] / pivot
            for c in range(col, n):
                A[r][c] -= factor * A[col][c]
            b[r] -= factor * b[col]
    x = [0.0]*n
    for i in reversed(range(n)):
        s = b[i] - sum(A[i][j]*x[j] for j in range(i+1, n))
        x[i] = s / A[i][i]
    return x

XtX, Xty = build_normal_equations(samples)
b0, b1, b2 = solve_3x3(XtX, Xty)

def local_linear_approx(x1, x2):
    return b0 + b1*x1 + b2*x2

print(f"ফিট করা লোকাল লিনিয়ার মডেল: y ≈ {b0:.3f} + {b1:.3f}*x1 + {b2:.3f}*x2\n")

actual = black_box(*point_of_interest)
approx = local_linear_approx(*point_of_interest)
print(f"পয়েন্ট অফ ইন্টারেস্ট: {point_of_interest}")
print(f"ব্ল্যাক-বক্সের প্রকৃত আউটপুট: {actual:.3f}")
print(f"লোকাল লিনিয়ার আনুমানিক (LIME-স্টাইল): {approx:.3f}")
print(f"পার্থক্য: {abs(actual-approx):.4f}\n")

print("পয়েন্ট অফ ইন্টারেস্টের কাছাকাছি আরও কয়েকটি টেস্ট পয়েন্টে তুলনা:")
random.seed(99)
total_err = 0.0
n_test = 5
for _ in range(n_test):
    tx1 = point_of_interest[0] + random.uniform(-0.3, 0.3)
    tx2 = point_of_interest[1] + random.uniform(-0.3, 0.3)
    a = black_box(tx1, tx2)
    p = local_linear_approx(tx1, tx2)
    err = abs(a - p)
    total_err += err
    print(f"  ({tx1:.2f}, {tx2:.2f}) -- প্রকৃত: {a:.3f}, আনুমানিক: {p:.3f}, পার্থক্য: {err:.4f}")

print(f"\nগড় absolute error (কাছাকাছি ৫টি টেস্ট পয়েন্টে): {total_err/n_test:.4f}")

# SHAP-এর ধারণার একটি ছোট, সম্পূর্ণ গণনাযোগ্য শ্যাপলি-ভ্যালু ডেমো (২টি ফিচার)
import itertools

def toy_function(x1, x2):
    return 2*x1 + 3*x2 + x1*x2  # ইচ্ছাকৃতভাবে একটি ইন্টারঅ্যাকশন-টার্ম (x1*x2) রাখা হয়েছে

baseline = (0, 0)   # "কোনো ফিচার উপস্থিত নয়" -- বেসলাইন রেফারেন্স পয়েন্ট
instance = (4, 5)   # যে নির্দিষ্ট পয়েন্টের ব্যাখ্যা চাই

orderings = list(itertools.permutations([1, 2]))  # ২টি ফিচারের সব সম্ভাব্য ক্রম -- ২! = ২টি
contributions = {1: [], 2: []}

for order in orderings:
    current = list(baseline)
    prev_value = toy_function(*current)
    for feat in order:
        if feat == 1:
            current[0] = instance[0]
        else:
            current[1] = instance[1]
        new_value = toy_function(*current)
        contributions[feat].append(new_value - prev_value)
        prev_value = new_value

shap_x1 = sum(contributions[1]) / len(contributions[1])
shap_x2 = sum(contributions[2]) / len(contributions[2])

print(f"বেসলাইন আউটপুট f{baseline}: {toy_function(*baseline)}")
print(f"ইনস্ট্যান্স আউটপুট f{instance}: {toy_function(*instance)}\n")

print("প্রতিটি সম্ভাব্য ক্রমে x1-এর প্রান্তিক অবদান:", contributions[1])
print("প্রতিটি সম্ভাব্য ক্রমে x2-এর প্রান্তিক অবদান:", contributions[2])

print(f"\nশ্যাপলি ভ্যালু (x1): {shap_x1:.2f}")
print(f"শ্যাপলি ভ্যালু (x2): {shap_x2:.2f}")

total_shap = shap_x1 + shap_x2
total_diff = toy_function(*instance) - toy_function(*baseline)
print(f"\nশ্যাপলি ভ্যালুর যোগফল: {total_shap:.2f}")
print(f"ইনস্ট্যান্স আউটপুট - বেসলাইন আউটপুট: {total_diff:.2f}")
print("(এই দুটো সমান হওয়াটাই SHAP-এর একটি মূল বৈশিষ্ট্য -- efficiency/সংযোজনযোগ্যতা: সব ফিচারের অবদানের যোগফল ঠিক মোট পার্থক্যের সমান।)")