Bayesian network — কারণ, ফল আর সম্ভাবনার জাল

মডিউল ৯-এ আমরা অনিশ্চয়তা নিয়ে যুক্তি করছি। পর্ব ৩৫-এ conditional probability, independence আর Bayes-এর নিয়মের প্রথম পরিচয় হয়েছে; পর্ব ৫০-এ (Bayes-এর উপপাদ্য) একটি অনুমান আর একটি প্রমাণ নিয়ে গভীরে যাওয়া হয়েছে, আর পর্ব ৫১-এ (Naive Bayes) অনেক শব্দকে প্রমাণ হিসেবে নেওয়া হয়েছে। এবার অনেক চলক, যারা একে অপরের ওপর নির্ভর করে, একসঙ্গে। উদাহরণ বাজারঘর, এই কোর্সের কাল্পনিক অনলাইন দোকান; network-এর গঠন আর প্রতিটি সম্ভাবনা আমাদের বানানো, কোনো আসল কোম্পানির ডেটা নয়। চালানো যায় এমন চারটি ব্লক পাতাতেই চলে (ব্রাউজারের Python, NumPy 2.4.6, matplotlib 3.10.8); প্রথমবার package নামতে প্রায় ১০ সেকেন্ড লাগতে পারে। চারটি ব্লক একই namespace ভাগ করে, তাই পরের ব্লক চালালে আগেরগুলো নিজে থেকে আগে চলে।

১ · পুরো joint table কেন চলে না — 2ⁿ-এর বিস্ফোরণ

বাজারঘরের ডেলিভারি দল একটি প্রশ্নের উত্তর চায়: “আজ একজন গ্রাহক দেরির অভিযোগ করেছেন। বৃষ্টি হয়েছিল বলে কতটা মনে হয়?” এমন প্রশ্নে অনেক চলক জড়িত: বৃষ্টি, যানজট, ঈদের ভিড়, রাইডারের সংকট, দেরিতে ডেলিভারি, অভিযোগ, খারাপ রিভিউ। প্রতিটি হ্যাঁ বা না (১ বা ০)।

সবচেয়ে সরল উপায় একটি joint probability-র টেবিল: সাতটি চলকের প্রতিটি সম্ভাব্য মানের জোড়ার জন্য একটি সংখ্যা। পর্ব ৩৫-এর crosstab-এর মতোই, শুধু দুইটির বদলে সাতটি কলাম। এমন টেবিল থাকলে যেকোনো প্রশ্নের উত্তর দেওয়া যায়: শর্তের সঙ্গে মেলা সারিগুলো যোগ করে ভাগ। সমস্যা হলো আকার।

স্বাধীন সংখ্যা এক কম, কারণ সব সারির যোগফল ১. তবে মেমরি আসল সমস্যা নয়। প্রথমত, এত সংখ্যা কেউ জানে না: একজন অভিজ্ঞ ম্যানেজার “বৃষ্টি হলে যানজটের সম্ভাবনা কত” বলতে পারেন, ৩০টি চলকের একটি নির্দিষ্ট জোড়ার সম্ভাবনা নয়। দ্বিতীয়ত, ডেটা থেকে মাপতে হলে প্রতিটি ঘরে উদাহরণ লাগে; ১০৭ কোটি ঘরের বেশিরভাগই খালি থাকবে। তৃতীয়ত, প্রতিটি প্রশ্নে অনেক সারি যোগ করতে হয়। একে বলে combinatorial explosion, পর্ব ৪৫-এর truth table-এ যা দেখেছেন।

বাঁচার পথ: কে কার ওপর সরাসরি নির্ভর করে

বাস্তবে প্রতিটি চলক সবকিছুর ওপর সরাসরি নির্ভর করে না। খারাপ রিভিউ নির্ভর করে মূলত দেরির ওপর; দেরি জানা থাকলে বৃষ্টি হয়েছিল কি না জানা রিভিউ সম্পর্কে নতুন কিছু বলে না। এটিই conditional independence, যার এক লাইনের পরিচয় পর্ব ৩৫-এ পেয়েছেন: P(A ∩ B ∣ C) = P(A ∣ C) · P(B ∣ C). এমন সম্পর্ক অনেক থাকলে বড় টেবিলটি ছোট ছোট টেবিলের গুণফলে ভেঙে ফেলা যায়।

২ · Bayesian network কী — DAG আর প্রতিটি node-এর CPT

একটি Bayesian network-এর দুটি অংশ।

• গঠন, একটি DAG (directed acyclic graph): প্রতিটি চলক একটি node; A থেকে B-তে তীর মানে B-এর সম্ভাবনা সরাসরি A-এর ওপর লেখা হবে। তীর ধরে ঘুরে আবার একই node-এ ফেরা যায় না (acyclic, চক্রহীন)। যে node থেকে তীর আসে, সে parent. Graph-এর মৌলিক কথা DSA কোর্সের graph পর্বে আছে।
• সংখ্যা, প্রতিটি node-এ একটি CPT (conditional probability table): parent-দের প্রতিটি মানের জোড়ার জন্য ওই node-এর সম্ভাবনা। Parent না থাকলে CPT শুধু একটি সাধারণ সম্ভাবনা।

এবার সংখ্যা। নিচের সব সম্ভাবনা আমাদের বানানো, কোনো মাপা ডেটা নয়। প্রতিটি সারিতে শুধু “= ১”-এর সম্ভাবনা লেখা; “= ০” হলো ১ থেকে বিয়োগ, কারণ প্রতিটি সারির যোগফল ১।

১৪টি সংখ্যার প্রতিটি একজন মানুষ বুঝতে আর যাচাই করতে পারেন: “যানজট আর রাইডার সংকট দুটোই থাকলে ৯০% অর্ডার দেরি হয়” একটি অর্থপূর্ণ দাবি। সাধারণভাবে, n টি হ্যাঁ/না node-এর প্রতিটির সর্বোচ্চ k টি parent থাকলে সংখ্যা লাগে সর্বোচ্চ n · 2^k. ৩০টি node, প্রতিটির সর্বোচ্চ ৩টি parent হলে ২৪০টি, ১০৭ কোটির বদলে।

৩ · Chain rule থেকে factorisation — একটি পূর্ণ joint হাতে হিসাব

১৪টি সংখ্যা থেকে ১২৮টি সারির যেকোনোটি কীভাবে পাওয়া যায়? প্রথম ধাপ chain rule of probability (calculus-এর chain rule নয়), যা যেকোনো joint-এর জন্য সবসময় সত্য:

P(x₁, …, x_n) = P(x₁) · P(x₂ ∣ x₁) · P(x₃ ∣ x₁, x₂) · … · P(x_n ∣ x₁, …, x_n−1)

এটি multiplication rule (পর্ব ৩৫) বারবার খাটানো। কোনো অনুমান নেই, কিন্তু শেষ গুণনীয়কটি একাই বিশাল। এখানে network-এর অনুমান ঢোকে: চলকগুলো এমন ক্রমে সাজান যাতে প্রতিটি parent তার child-এর আগে আসে (একে বলে topological order; DSA কোর্সের topological sort পর্বে এর algorithm আছে), তাহলে network বলে প্রতিটি চলক, তার parent জানা থাকলে, আগের বাকি সবার থেকে conditionally independent. ফলে প্রতিটি লম্বা শর্ত ছোট হয়ে শুধু parent-এ নামে:

P(x₁, …, x_n) = ∏_i P(x_i ∣ parents(X_i))

∏ মানে সব i-এর গুণফল। বাজারঘরের network-এ:

P(R, E, T, S, L, C, B) = P(R) · P(E) · P(T ∣ R) · P(S ∣ E) · P(L ∣ T, S) · P(C ∣ L) · P(B ∣ L)

উদাহরণ: “বৃষ্টি হয়েছে, ঈদের ভিড় নেই, যানজট আছে, রাইডার সংকট নেই, অর্ডার দেরি, গ্রাহক অভিযোগ করেছেন, কিন্তু খারাপ রিভিউ দেননি” — এই পূর্ণ অবস্থার সম্ভাবনা কত? নিচের stepper প্রতিটি node-এ একটি করে গুণনীয়ক নেয়।

৪ · Enumeration দিয়ে inference — অভিযোগ এলে বৃষ্টির সম্ভাবনা

বাস্তবের প্রশ্ন সাধারণত একটি পূর্ণ সারি নয়। আমরা কিছু চলক দেখি (evidence, প্রমাণ), একটি চলক সম্পর্কে জানতে চাই (query, প্রশ্ন), আর বাকিগুলো অজানা থাকে, যাদের বলে hidden variable বা লুকানো চলক। প্রমাণ দেখে প্রশ্নের চলকের সম্ভাবনা বের করাকে বলে inference. আমাদের প্রশ্ন: অভিযোগ এসেছে (C=1); বৃষ্টি হওয়ার সম্ভাবনা কত? লুকানো চলক E, T, S, L, B.

Inference by enumeration সবচেয়ে সরাসরি পথ। Conditional probability-র সংজ্ঞা থেকে:

P(R ∣ C=1) = α · ∑_E ∑_T ∑_S ∑_L ∑_B P(R, E, T, S, L, C=1, B)

প্রতিটি লুকানো চলকের সব মানের ওপর যোগ করা (sum out করা) মানে সেই চলককে marginalise করা। α হলো normalising constant: R=1 আর R=0 দুটোর যোগফল হিসাব করে তাদের যোগফল দিয়ে ভাগ, যাতে উত্তর দুটির যোগ ১ হয়। α আসলে 1 / P(C=1). প্রতিটি R-এর জন্য 2⁵ = ৩২টি পূর্ণ সারি, প্রতিটি সাতটি গুণনীয়কের গুণফল। হাতে ৬৪টি সারি অনেক, তাই নিচের stepper একটি কৌশল নেয়: যে গুণনীয়ক কোনো যোগের চলকের ওপর নির্ভর করে না, তাকে সেই যোগের বাইরে আনা। উত্তর একই।

এবার একই হিসাব কোডে, কোনো কৌশল ছাড়া: সব ১২৮টি সারি ঘুরে প্রমাণের সঙ্গে মেলাগুলো যোগ। CPT সাধারণ Python dict-এ (Python কোর্সের dict পর্ব), সব সারি দেয় itertools.product.

from itertools import product

# বাজারঘরের কাল্পনিক CPT: প্রতিটি মান P(চলক = 1 | parents)
P_R = 0.3                        # Rain
P_E = 0.1                        # EidRush
P_T = {1: 0.8, 0: 0.3}           # Traffic | Rain
P_S = {1: 0.6, 0: 0.1}           # RiderShortage | EidRush
P_L = {(1, 1): 0.9, (1, 0): 0.5, (0, 1): 0.6, (0, 0): 0.05}  # Late | T, S
P_C = {1: 0.6, 0: 0.05}          # Complaint | Late
P_B = {1: 0.3, 0: 0.02}          # BadReview | Late
NAMES = ["R", "E", "T", "S", "L", "C", "B"]

def b(p, x):                     # P(X = x), যখন P(X = 1) = p
    return p if x == 1 else 1 - p

def joint(R, E, T, S, L, C, B):  # DAG ধরে ৭টি গুণনীয়ক
    return (b(P_R, R) * b(P_E, E) * b(P_T[R], T) * b(P_S[E], S)
            * b(P_L[(T, S)], L) * b(P_C[L], C) * b(P_B[L], B))

def query(var, evidence):        # enumeration: বাকি চলকের ওপর যোগ
    score = {0: 0.0, 1: 0.0}
    for vals in product((0, 1), repeat=7):
        w = dict(zip(NAMES, vals))
        if all(w[k] == v for k, v in evidence.items()):
            score[w[var]] += joint(*vals)
    return score[1] / (score[0] + score[1])

total = sum(joint(*v) for v in product((0, 1), repeat=7))
print("128টি সারির যোগফল:", round(total, 12))
print("P(R=1,E=0,T=1,S=0,L=1,C=1,B=0) =", round(joint(1, 0, 1, 0, 1, 1, 0), 6))
print("P(Late = 1)             =", round(query("L", {}), 4))
print("P(Complaint = 1)        =", round(query("C", {}), 4))
print("P(Rain = 1)             =", P_R)
print("P(Rain = 1 | Complaint) =", round(query("R", {"C": 1}), 4))

128টি সারির যোগফল: 1.0
P(R=1,E=0,T=1,S=0,L=1,C=1,B=0) = 0.040824
P(Late = 1)             = 0.3249
P(Complaint = 1)        = 0.2287
P(Rain = 1)             = 0.3
P(Rain = 1 | Complaint) = 0.408

৫ · তিনটি মূল গঠন — chain, fork আর collider

যেকোনো Bayesian network তিন চলকের তিন রকম টুকরো দিয়ে গড়া। তথ্য একটি পথ ধরে “প্রবাহিত” হয় কি না, তা নির্ভর করে মাঝের node-এর গঠন আর সেটি জানা কি না তার ওপর।

• Chain (A → B → C): বৃষ্টি জানলে দেরির অনুমান বদলায়; কিন্তু যানজট জানা থাকলে বৃষ্টি আর নতুন কিছু বলে না, কারণ বৃষ্টির সব প্রভাব যানজট দিয়েই যায়।
• Fork (A ← B → C), common cause: দেরি থেকে অভিযোগ আর খারাপ রিভিউ দুটোই আসে, তাই অভিযোগ দেখলে খারাপ রিভিউর সম্ভাবনাও বাড়ে; দেরি জানা থাকলে সম্পর্কটি মুছে যায়। এটিই confounding-এর গঠন (পর্ব ২৪)।
• Collider (A → B ← C), common effect: যানজট আর রাইডার সংকট স্বাধীন, কিন্তু দুটোই দেরি ঘটায়। দেরি হয়েছে জানলে এরা সম্পর্কিত হয়ে যায়: একটি না থাকলে অন্যটি থাকার সম্ভাবনা বাড়ে।

কথাগুলো সংখ্যায় দেখি। নিচের ব্লক আগের query ব্যবহার করে (data-shared, তাই আগের ব্লক নিজে থেকে আগে চলবে)।

def show(text, var, ev):
    print(f"  {text:<22} {query(var, ev):.4f}")

print("১. Chain  Rain → Traffic → Late")
show("P(L=1)", "L", {})
show("P(L=1 | R=1)", "L", {"R": 1})
show("P(L=1 | T=1)", "L", {"T": 1})
show("P(L=1 | T=1, R=1)", "L", {"T": 1, "R": 1})

print("২. Fork  Complaint ← Late → BadReview")
show("P(B=1)", "B", {})
show("P(B=1 | C=1)", "B", {"C": 1})
show("P(B=1 | L=1)", "B", {"L": 1})
show("P(B=1 | L=1, C=1)", "B", {"L": 1, "C": 1})

print("৩. Collider  Traffic → Late ← Shortage")
show("P(T=1)", "T", {})
show("P(T=1 | S=1)", "T", {"S": 1})
show("P(T=1 | L=1)", "T", {"L": 1})
show("P(T=1 | L=1, S=1)", "T", {"L": 1, "S": 1})

print("৪. Explaining away: Rain দিয়ে Shortage")
show("P(S=1)", "S", {})
show("P(S=1 | R=1)", "S", {"R": 1})
show("P(S=1 | L=1)", "S", {"L": 1})
show("P(S=1 | L=1, R=1)", "S", {"L": 1, "R": 1})
show("P(S=1 | L=1, R=0)", "S", {"L": 1, "R": 0})

১. Chain  Rain → Traffic → Late
  P(L=1)                 0.3249
  P(L=1 | R=1)           0.4745
  P(L=1 | T=1)           0.5600
  P(L=1 | T=1, R=1)      0.5600
২. Fork  Complaint ← Late → BadReview
  P(B=1)                 0.1110
  P(B=1 | C=1)           0.2587
  P(B=1 | L=1)           0.3000
  P(B=1 | L=1, C=1)      0.3000
৩. Collider  Traffic → Late ← Shortage
  P(T=1)                 0.4500
  P(T=1 | S=1)           0.4500
  P(T=1 | L=1)           0.7757
  P(T=1 | L=1, S=1)      0.5510
৪. Explaining away: Rain দিয়ে Shortage
  P(S=1)                 0.1500
  P(S=1 | R=1)           0.1500
  P(S=1 | L=1)           0.3394
  P(S=1 | L=1, R=1)      0.2655
  P(S=1 | L=1, R=0)      0.3969

৬ · Explaining away আর d-separation-এর অন্তর্দৃষ্টি

ধরুন একটি অর্ডার দেরিতে পৌঁছেছে। ম্যানেজার ভাবেন, “নিশ্চয়ই রাইডার কম ছিল।” তারপর জানলেন সেদিন ঢাকায় মুষলধারে বৃষ্টি হয়েছিল। এখন রাইডার সংকটের সন্দেহ কমে, কারণ বৃষ্টি দেরির একটি যথেষ্ট ব্যাখ্যা। একে বলে explaining away: একটি সাধারণ ফলের এক কারণ প্রমাণিত হলে অন্য কারণের সম্ভাবনা কমে। বাজারঘরের network-এ বৃষ্টি সরাসরি দেরির parent নয়, তবে বৃষ্টি → যানজট → দেরি ← রাইডার সংকট পথটি দেরিতে collider পায়, আর প্রভাবটি সেখান দিয়েই আসে।

d-separation — পথ খোলা না বন্ধ

বড় network-এ দুটি চলক স্বাধীন কি না বুঝতে প্রতিবার হিসাব করতে হয় না; graph দেখেই বলা যায়। নিয়মটির নাম d-separation (d = directed), যা Pearl আর তাঁর সহকর্মীরা ১৯৮০-এর দশকে আনুষ্ঠানিক করেন। এখানে প্রমাণ নয়, অন্তর্দৃষ্টি: A আর B-এর মধ্যে তীরের দিক না দেখে যত পথ আছে, প্রতিটিকে একটি পাইপ ভাবুন। জানা চলকের সেট Z দেওয়া থাকলে প্রতিটি পথের প্রতিটি মাঝের node দেখুন:

একটি পথ বন্ধ, যদি তার অন্তত একটি মাঝের node বন্ধ থাকে। A আর B-এর মধ্যের প্রতিটি পথ বন্ধ হলে তারা Z দেওয়া থাকলে d-separated, আর তখন network-এর CPT-তে যে সংখ্যাই বসান, তারা conditionally independent. একটি পথও খোলা থাকলে সাধারণত নির্ভরশীল। বাজারঘরের দুটি উদাহরণ: (১) যানজট আর রাইডার সংকট, অভিযোগ জানা থাকলে? একমাত্র পথ T → L ← S, collider L জানা নেই, কিন্তু তার উত্তরসূরি C জানা, তাই পথ খোলা। হিসাবেও তাই: P(T=1 ∣ C=1) ≈ ০.৭০৪, আর রাইডার সংকটও জানলে ≈ ০.৫৪০. (২) বৃষ্টি আর অভিযোগ, দেরি জানা থাকলে? পথ R → T → L → C, chain-এ L জানা, তাই বন্ধ; P(R=1 ∣ L=1) আর P(R=1 ∣ L=1, C=1) দুটোই ≈ ০.৪৩৮ (দুটি সংখ্যাই আগের query দিয়ে হিসাব করা)।

৭ · দ্রুত নির্ভুল হিসাব আর আনুমানিক inference — elimination আর sampling

Variable elimination — একই উত্তর, কম গুণ

৪ নম্বর অংশের stepper-এ আমরা আসলে variable elimination-ই করেছি: যোগগুলোকে গুণফলের ভেতরে যতটা সম্ভব ঢুকিয়ে একটি একটি চলক বাদ দেওয়া, আর মাঝের ফল (যেমন P(S), P(L ∣ T)) জমিয়ে রেখে আবার ব্যবহার করা। এটি DSA কোর্সের dynamic programming-এর মতো একই কৌশল: একই উপ-হিসাব বারবার না করা। ধারণাটি ১৯৯০-এর দশকের মাঝামাঝি Nevin Zhang আর David Poole-এর একটি প্রবন্ধে এই নামে পরিচিত হয়, আর Rina Dechter-এর bucket elimination একই ধারার কাজ।

গোনার নিয়মভেদে সংখ্যা সামান্য বদলায়, মাত্রা নয়। আসল লাভ বড় network-এ: enumeration-এর খরচ লুকানো চলকের সংখ্যায় exponential, আর যে network-এ দুটি node-এর মধ্যে একটির বেশি পথ নেই (polytree), সেখানে variable elimination-এর খরচ network-এর আকারে মোটামুটি linear. তবে সাধারণ network-এ নির্ভুল inference কঠিন: Gregory Cooper ১৯৯০ সালে দেখান এটি NP-hard. খরচ নির্ভর করে বাদ দেওয়ার ক্রম আর মাঝের টেবিল কত বড় হয় তার ওপর (treewidth). তাই বড় বা ঘন network-এ আনুমানিক পদ্ধতি লাগে।

Prior sampling আর rejection sampling

আনুমানিক inference-এর সবচেয়ে সহজ ধারণা পর্ব ৩৬-এর Monte Carlo: network থেকে অনেক কাল্পনিক “দিন” বানানো, তারপর গোনা। Prior sampling (forward sampling) topological ক্রমে চলে: আগে বৃষ্টি আর ঈদের ভিড়ের মান টানা হয় তাদের prior থেকে, তারপর সেই মান দেখে যানজট আর রাইডার সংকট তাদের CPT-এর সঠিক সারি থেকে, তারপর দেরি, শেষে অভিযোগ আর রিভিউ। প্রতিটি নমুনা ১২৮টি সারির একটি, আর কোনো সারি যত ঘন ঘন আসে তা তার joint probability-র কাছাকাছি।

প্রমাণ থাকলে সবচেয়ে সরল উপায় rejection sampling: প্রমাণের সঙ্গে না মেলা নমুনা (C=0) ফেলে দিন, বাকিগুলোর মধ্যে বৃষ্টির অনুপাত গুনুন। নিচের ব্লক NumPy দিয়ে একসঙ্গে অনেক নমুনা টানে, বিভিন্ন N-এ অনুমান বের করে, আর enumeration-এর সঠিক উত্তরের সঙ্গে ছবিতে তুলনা করে।

import numpy as np
import matplotlib.pyplot as plt

def prior_sample(n, rng):        # DAG-এর ক্রমে: আগে parent, পরে child
    u = lambda p: rng.random(n) < p
    R, E = u(P_R), u(P_E)
    T = u(np.where(R, P_T[1], P_T[0]))
    S = u(np.where(E, P_S[1], P_S[0]))
    L = u(np.select([T & S, T & ~S, ~T & S],
                    [P_L[(1, 1)], P_L[(1, 0)], P_L[(0, 1)]], P_L[(0, 0)]))
    C = u(np.where(L, P_C[1], P_C[0]))
    B = u(np.where(L, P_B[1], P_B[0]))
    return {"R": R, "E": E, "T": T, "S": S, "L": L, "C": C, "B": B}

exact = query("R", {"C": 1})
rng = np.random.default_rng(42)
sizes = [100, 300, 1000, 3000, 10000, 30000, 100000]
est = []
for n in sizes:
    d = prior_sample(n, rng)
    keep = d["C"]                # rejection: Complaint = 1 না হলে বাদ
    est.append(d["R"][keep].mean())
    print(f"N = {n:>6}: রাখা হলো {keep.sum():>5}, অনুমান {est[-1]:.4f}")
print("সঠিক (enumeration):", round(exact, 4))

fig, ax = plt.subplots(figsize=(6.4, 3.4))
ax.semilogx(sizes, est, "o-", label="rejection sampling estimate")
ax.axhline(exact, color="crimson", ls="--", label=f"exact = {exact:.4f}")
ax.axhline(P_R, color="gray", ls=":", label="prior P(Rain) = 0.3")
ax.set_xlabel("number of prior samples N (log scale)")
ax.set_ylabel("P(Rain = 1 | Complaint = 1)")
ax.set_title("Rejection sampling converges to the exact answer")
ax.legend(fontsize=8)

N =    100: রাখা হলো    28, অনুমান 0.3571
N =    300: রাখা হলো    73, অনুমান 0.4932
N =   1000: রাখা হলো   232, অনুমান 0.4052
N =   3000: রাখা হলো   689, অনুমান 0.3977
N =  10000: রাখা হলো  2292, অনুমান 0.4058
N =  30000: রাখা হলো  6921, অনুমান 0.4102
N = 100000: রাখা হলো 22730, অনুমান 0.4108
সঠিক (enumeration): 0.408

দুর্বলতা স্পষ্ট: P(প্রমাণ) = ০.০০১ হলে ১০ লাখ নমুনার মাত্র প্রায় ১০০০টি কাজে লাগে।

৮ · ডেটা থেকে CPT শেখা, আর pgmpy দিয়ে সত্যিকারের run

বাস্তবে CPT-র সংখ্যা আসে বিশেষজ্ঞের অনুমান বা ডেটা থেকে। গঠন জানা থাকলে আর সব চলক প্রতিটি সারিতে দেখা গেলে শেখা মানে শুধু গোনা। P(T=1 ∣ R=1) = (বৃষ্টি এবং যানজটের দিনের সংখ্যা) ÷ (বৃষ্টির দিনের সংখ্যা)। এটিই maximum likelihood estimate, আর প্রতিটি CPT সারি আলাদা আলাদা গোনা যায়। পরীক্ষা করার সেরা উপায়: জানা network থেকে seeded ডেটা বানিয়ে আবার শিখে দেখা, আসল সংখ্যা ফিরে আসে কি না।

import numpy as np

d = prior_sample(5000, np.random.default_rng(2026))
R, E, T, S, L, C = (d[k] for k in "RETSLC")
everyone = np.ones(5000, dtype=bool)

rows = [("P(R=1)", R, everyone, P_R),
        ("P(T=1 | R=1)", T, R, P_T[1]), ("P(T=1 | R=0)", T, ~R, P_T[0]),
        ("P(S=1 | E=1)", S, E, P_S[1]), ("P(S=1 | E=0)", S, ~E, P_S[0]),
        ("P(L=1 | T=1,S=1)", L, T & S, P_L[(1, 1)]),
        ("P(L=1 | T=1,S=0)", L, T & ~S, P_L[(1, 0)]),
        ("P(L=1 | T=0,S=1)", L, ~T & S, P_L[(0, 1)]),
        ("P(L=1 | T=0,S=0)", L, ~T & ~S, P_L[(0, 0)]),
        ("P(C=1 | L=1)", C, L, P_C[1]), ("P(C=1 | L=0)", C, ~L, P_C[0])]

print(f"{'CPT-এর ঘর':<17}{'n':>5}{'আসল':>7}{'গোনা':>8}{'Laplace':>9}")
for name, child, mask, true in rows:
    n = int(mask.sum())
    k = int((child & mask).sum())
    mle = k / n                      # গোনা: k ÷ n
    lap = (k + 1) / (n + 2)          # প্রতিটি মানে ১ যোগ
    print(f"{name:<17}{n:>5}{true:>7.2f}{mle:>8.3f}{lap:>9.3f}")

m = (T & S)[:50]                     # মাত্র প্রথম ৫০টি অর্ডার
n, k = int(m.sum()), int((L[:50] & m).sum())
print(f"৫০টি সারিতে T=1,S=1: n={n}, k={k}, গোনা {k/n:.3f}, "
      f"Laplace {(k+1)/(n+2):.3f}, আসল 0.9")

CPT-এর ঘর            n    আসল    গোনা  Laplace
P(R=1)            5000   0.30   0.291    0.291
P(T=1 | R=1)      1456   0.80   0.797    0.797
P(T=1 | R=0)      3544   0.30   0.303    0.303
P(S=1 | E=1)       463   0.60   0.613    0.613
P(S=1 | E=0)      4537   0.10   0.097    0.097
P(L=1 | T=1,S=1)   332   0.90   0.907    0.904
P(L=1 | T=1,S=0)  1902   0.50   0.503    0.503
P(L=1 | T=0,S=1)   391   0.60   0.598    0.598
P(L=1 | T=0,S=0)  2375   0.05   0.057    0.058
P(C=1 | L=1)      1628   0.60   0.590    0.590
P(C=1 | L=0)      3372   0.05   0.053    0.053
৫০টি সারিতে T=1,S=1: n=1, k=0, গোনা 0.000, Laplace 0.333, আসল 0.9

সত্যিকারের run: pgmpy দিয়ে একই network

কাজে সাধারণত লাইব্রেরি লাগে; Python-এ পরিচিত একটি open-source লাইব্রেরি pgmpy. এটি ব্রাউজারের Python-এ নেই, তাই লেখকের যন্ত্রে একটি আলাদা virtual environment-এ (Python 3.14.4) চালানো হয়েছে। লেখার সময়ের সর্বশেষ সংস্করণ pgmpy 1.1.2; সঙ্গে নিজে থেকে এসেছে numpy 2.5.4, pandas 3.1.1, scipy 1.18.1, networkx 3.7 আর scikit-learn 1.9.1 (PyTorch লাগেনি)।

from pgmpy.models import DiscreteBayesianNetwork
from pgmpy.factors.discrete import TabularCPD
from pgmpy.inference import VariableElimination

model = DiscreteBayesianNetwork([("R", "T"), ("E", "S"), ("T", "L"),
                                 ("S", "L"), ("L", "C"), ("L", "B")])

def cpd(var, p1, parents=()):   # p1 = P(var=1), parent অবস্থার ক্রমে
    p1 = list(p1)
    return TabularCPD(var, 2, [[1 - p for p in p1], p1],
                      evidence=list(parents) or None,
                      evidence_card=[2] * len(parents) or None)

model.add_cpds(
    cpd("R", [0.3]), cpd("E", [0.1]),
    cpd("T", [0.3, 0.8], ["R"]),               # R=0, R=1
    cpd("S", [0.1, 0.6], ["E"]),
    cpd("L", [0.05, 0.6, 0.5, 0.9], ["T", "S"]),  # 00, 01, 10, 11
    cpd("C", [0.05, 0.6], ["L"]),
    cpd("B", [0.02, 0.3], ["L"]))
print("check_model:", model.check_model())

ve = VariableElimination(model)
def p1(var, ev=None):
    f = ve.query([var], evidence=ev, show_progress=False)
    return round(float(f.values[1]), 4)

print("P(R=1 | C=1)      =", p1("R", {"C": 1}))
print("P(S=1)            =", p1("S"))
print("P(S=1 | L=1)      =", p1("S", {"L": 1}))
print("P(S=1 | L=1, R=1) =", p1("S", {"L": 1, "R": 1}))
print(ve.query(["R"], evidence={"C": 1}, show_progress=False))

print("T, S d-connected?          ", model.is_dconnected("T", "S"))
print("T, S d-connected given L?  ", model.is_dconnected("T", "S", observed=["L"]))
print("C, B d-connected given L?  ", model.is_dconnected("C", "B", observed=["L"]))
print(model.local_independencies("L"))

from pgmpy.sampling import BayesianModelSampling
from pgmpy.parameter_estimator import DiscreteMLE
data = BayesianModelSampling(model).forward_sample(size=5000, seed=42,
                                                   show_progress=False)
learned = DiscreteBayesianNetwork(model.edges())
learned.fit(data, estimator=DiscreteMLE())
c = learned.get_cpds("L")
print("rows:", len(data), "| L-এর parent ক্রম:", c.variables[1:])
print("শেখা P(L=1 | ...):\n", c.values[1].round(3))

~/bazarghar-ai$ pip install pgmpy==1.1.2
…
~/bazarghar-ai$ python bn_pgmpy.py
~/bazarghar-ai/.venv/…/pgmpy/estimators/__init__.py:4: FutureWarning: `pgmpy.estimators.StructureScore` is deprecated and will be removed in v1.3.0. Use `pgmpy.structure_score` instead.
  from .StructureScore import (
check_model: True
P(R=1 | C=1)      = 0.408
P(S=1)            = 0.15
P(S=1 | L=1)      = 0.3394
P(S=1 | L=1, R=1) = 0.2655
+------+----------+
| R    |   phi(R) |
+======+==========+
| R(0) |   0.5920 |
+------+----------+
| R(1) |   0.4080 |
+------+----------+
T, S d-connected?           False
T, S d-connected given L?   True
C, B d-connected given L?   False
(L ⟂ E, R | S, T)
rows: 5000 | L-এর parent ক্রম: ['S', 'T']
শেখা P(L=1 | ...):
 [[0.055 0.534]
 [0.635 0.907]]

প্রথম দুই লাইন pgmpy-র নিজের import থেকে আসা একটি FutureWarning: একটি module 1.3.0-এ সরানো হবে। Warning লুকাবেন না; পরের সংস্করণে কী ভাঙবে তা এখানেই লেখা। check_model দেখে CPT-এর সারির যোগ ১ আর parent মিলছে কি না। VariableElimination আমাদের সংখ্যাগুলোই দেয়: ০.৪০৮, ০.১৫, ০.৩৩৯৪, ০.২৬৫৫. is_dconnected graph দেখে d-separation খাটায়, ফল ৬ নম্বর অংশের নিয়মের সঙ্গে মেলে। (L ⟂ E, R ∣ S, T) মানে parent জানা থাকলে দেরি বাকি পূর্বসূরিদের থেকে স্বাধীন, ঠিক factorisation-এর অনুমান।

শেষ অংশে pgmpy ৫,০০০টি নমুনা টেনে (নিজের random ব্যবস্থায়, তাই সংখ্যা আমাদের ব্লক থেকে আলাদা) আবার CPT শিখেছে। একটি ফাঁদ দেখুন: আমরা দেরির parent লিখেছিলাম ["T", "S"] ক্রমে, কিন্তু শেখা CPT-তে ক্রম ['S', 'T']. তাই মানের সারণির প্রথম সূচক S: [[0.055 0.534] [0.635 0.907]] পড়ুন (S=0,T=0) = ০.০৫৫, (S=0,T=1) = ০.৫৩৪, (S=1,T=0) = ০.৬৩৫, (S=1,T=1) = ০.৯০৭; আসল ০.০৫, ০.৫, ০.৬, ০.৯. Array-র সূচক দিয়ে CPT পড়ার আগে সবসময় variables দেখে নিন।

৯ · তীরের মানে কী — কারণ, সম্পর্ক, Naive Bayes আর বাস্তব ব্যবহার

আমরা তীর এঁকেছি কারণ থেকে ফলের দিকে (বৃষ্টি → যানজট), কারণ সেভাবে CPT-র সংখ্যা অনুমান করা সহজ। কিন্তু গাণিতিকভাবে একটি Bayesian network শুধু একটি সম্ভাবনা-বণ্টনের দাবি করে, কারণ-ফলের নয়। একই বণ্টন প্রায়ই একাধিক DAG দিয়ে লেখা যায়: R → T → L, R ← T ← L আর R ← T → L, তিনটিই বলে “T জানা থাকলে R আর L স্বাধীন”; শুধু observational ডেটা দেখে এদের আলাদা করা যায় না। শুধু collider (R → T ← L) অন্য রকম স্বাধীনতা বলে, তাই ডেটা থেকে collider-ই সবচেয়ে বেশি চেনা যায়। এজন্য ডেটা থেকে শেখা network-এর তীরকে কারণ হিসেবে পড়া একটি বাড়তি অনুমান, প্রমাণ নয়; লুকানো confounder থাকলে তো বটেই। Correlation আর causation নিয়ে আরও আলোচনা পর্ব ৩৭-এ।

Intervention, এক অনুচ্ছেদে: “অভিযোগ এসেছে দেখলে দেরির সম্ভাবনা” আর “অভিযোগের বোতাম সরিয়ে অভিযোগ বন্ধ করলে দেরির সম্ভাবনা” এক জিনিস নয়। প্রথমটি P(L ∣ C=0), আমাদের network-এ ≈ ০.১৬৮: অভিযোগ না আসা মানে সম্ভবত অর্ডারটি সময়মতো এসেছিল। দ্বিতীয়টি Pearl-এর do-operator দিয়ে লেখা P(L ∣ do(C=0)): বাইরে থেকে C বসালে C-এর দিকে আসা তীর কেটে যায়, আর দেরি তার কারণগুলোর ওপরই থাকে, P(L=1) ≈ ০.৩২৫. বোতাম সরালে ডেলিভারি দ্রুত হয় না। এমন হিসাব তখনই বৈধ যখন তীরগুলো সত্যিই কারণ-ফল বোঝায়; সেটি যাচাইয়ের নিয়ম (do-calculus, randomised experiment বা A/B test) causal inference-এর বিষয়, যা এই কোর্সের বাইরে। (pgmpy-তে এর জন্য do method আছে।)

Naive Bayes — একটি ছোট্ট Bayesian network

পর্ব ৫১-এর Naive Bayes আসলে একটি বিশেষ network: একটি শ্রেণি-node (spam বা ham) থেকে প্রতিটি শব্দ-node-এ তীর, শব্দগুলোর মধ্যে কোনো তীর নেই। এটি একটি বড় fork: শ্রেণি জানা থাকলে প্রতিটি শব্দ বাকিগুলো থেকে স্বাধীন। Factorisation সরাসরি দেয় P(শ্রেণি, w₁, …, w_n) = P(শ্রেণি) ∏ P(w_i ∣ শ্রেণি), আর একটি SMS দেখে শ্রেণির inference হলো Bayes-এর নিয়ম। “Naive” অংশটি হলো অনুপস্থিত তীরগুলো; বাস্তবে “অফার” আর “জিতুন” শব্দ শ্রেণি জানা থাকলেও সম্পর্কিত, তবু model প্রায়ই ভালো কাজ করে।

কোথায় ব্যবহার হয়

• রোগনির্ণয় ও চিকিৎসা-সহায়তা: রোগ → উপসর্গ ও পরীক্ষার ফল, তারপর উপসর্গ থেকে উল্টো inference. ১৯৮০-৯০-এর দশকে গবেষণায় একাধিক বড় network তৈরি হয়েছিল (ভাবনার প্রশ্ন ৫); বাস্তব ক্লিনিকে ব্যবহারের ব্যাপ্তি সীমিত আর প্রসঙ্গভেদে আলাদা।
• Troubleshooting: “প্রিন্টার চলছে না” থেকে সম্ভাব্য কারণ সাজানো, আর কোন পরীক্ষাটি আগে করলে সবচেয়ে বেশি তথ্য মিলবে তা ঠিক করা (পর্ব ৫৪-এর value of information-এর সঙ্গে মিলিয়ে)। কিছু সফটওয়্যার-সহায়তা ব্যবস্থায় এমন পদ্ধতি ব্যবহারের প্রকাশিত বিবরণ আছে।
• ঝুঁকির মডেল: নির্ভরযোগ্যতা প্রকৌশল, পরিবেশ ও কৃষির ঝুঁকি, ঋণ বা জালিয়াতির ঝুঁকি; বিশেষত যেখানে ডেটা কম, বিশেষজ্ঞের জ্ঞান বেশি, আর সিদ্ধান্তের যুক্তি ব্যাখ্যা করতে হয়।

সীমাও স্পষ্ট: গঠন আর সংখ্যা ভুল হলে উত্তরও আত্মবিশ্বাসীভাবে ভুল, শত শত CPT বিশেষজ্ঞের কাছ থেকে আদায় করা ক্লান্তিকর (পর্ব ৪৭-এর knowledge acquisition bottleneck), আর ছবি বা লেখার মতো বিশাল কাঁচা ডেটায় আজকের neural network সাধারণত বেশি সফল।

১০ · AI-এর যুগে — Bayesian network-এর কোড আর হিসাব যাচাই

AI assistant Bayesian network-এর কোড দ্রুত লিখে দেয়, কিন্তু এই বিষয়ে তার ভুলগুলো চেনা আর প্রায়ই নীরব: কোড চলে, সংখ্যা আসে, শুধু ভুল সংখ্যা।

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

• লাইব্রেরির সংস্করণ দেখে অফিসিয়াল docs-এ class আর method-এর নাম মিলিয়েছি
• প্রতিটি CPT লেবেলসহ ছাপিয়ে অন্তত একটি ঘর হাতে মিলিয়েছি; প্রতিটি সারির যোগ ১
• সব সারির joint-এর যোগফল ১ কি না, বা check_model() সত্য কি না দেখেছি
• অন্তত একটি query enumeration বা হাতের হিসাবে স্বাধীনভাবে মিলিয়েছি
• ডেটা থেকে শেখা হলে প্রতিটি CPT সারির n দেখেছি, আর তীরকে কারণ হিসেবে পড়িনি
• পুরো আউটপুট আর সব warning পড়েছি; কোনো আসল ব্যক্তিগত ডেটা AI-তে পেস্ট করিনি