သတင်းကုထုံး ဗဟုတက္ကသိုလ် စာကြည့်တိုက်

Thursday, August 6, 2026

Random-Restart Hill-Climbing

Stuart Russell နဲ့ Peter Norvig တို့ရဲ့ "Artificial Intelligence: A Modern Approach" စာအုပ်၊ အခန်း ၄ တွင် ရှင်းပြထားသော "Local Search Algorithms" များထဲမှ Hill-climbing algorithm သည် လက်ရှိအခြေအနေ (Current State) မှနေ၍ ပိုမိုကောင်းမွန်သော အိမ်နီးချင်းအခြေအနေ (Neighbor State) သို့ အစဉ်မပြတ် ရွေးချယ်သွားသော နည်းလမ်းဖြစ်ပါသည်။

8-Queens Problem နှင့် Hill-Climbing ပေါင်းစပ်စဉ်းစားပုံ

8-Queens ပြဿနာကို Hill-climbing ဖြင့် ဖြေရှင်းရာတွင် အောက်ပါအတိုင်း ဖွဲ့စည်း (Formulate) ပါသည်-

State Representation (အခြေအနေ ကိုယ်စားပြုပုံ):
ဘုတ်ပြားပေါ်တွင် ဘုရင်မ (Queen) ၈ ပါးလုံးကို ကော်လံ (Column) တစ်ခုလျှင် တစ်ပါးစီ ချထားသည့် ပုံစံဖြင့် စတင်ပါသည်။ ထို့ကြောင့် ကော်လံ ၈ ခုတွင် ရှိနေသော ဘုရင်မများ၏ အတန်း (Row) နေရာများကို [0, 4, 7, 5, 2, 6, 1, 3] စသည့် 1D Array ဖြင့် ကိုယ်စားပြုနိုင်ပါသည်။
Heuristic Function ( $h$ ):
အချင်းချင်း တိုက်ခိုက်နိုင်သော (Attacking pairs) ဘုရင်မ အစုံအရေအတွက် ဖြစ်ပါသည်။ ပန်းတိုင် (Goal State) တွင် မည်သည့်ဘုရင်မမှ အချင်းချင်း မစားနိုင်ရသဖြင့် $h = 0$ ဖြစ်ရပါမည်။
Neighbor (အိမ်နီးချင်း အခြေအနေ):
ကော်လံတစ်ခုရှိ ဘုရင်မတစ်ပါးကို အခြားသော အတန်း (Row) တစ်ခုခုသို့ ရွှေ့လိုက်ခြင်းကို Neighbor ဟု သတ်မှတ်ပါသည်။ ကော်လံ ၈ ခု၊ ကော်လံတစ်ခုလျှင် ပြောင်းရွှေ့နိုင်သော အတန်း ၇ ခု ရှိသဖြင့် စုစုပေါင်း Neighbor ၅၆ ခု ( $8 \times 7 = 56$ ) ရှိပါသည်။
Action:
လက်ရှိ $h$ တန်ဖိုးထက် ပိုနည်းသော (ပိုကောင်းသော) Neighbor ကို ရွေးချယ်သွားပါသည်။

Local Maxima ပြဿနာ နှင့် Random-Restart Hill-Climbing

Hill-climbing ၏ အဓိက အားနည်းချက်မှာ Local Maxima (သို့မဟုတ် $h$ တန်ဖိုးအရ Local Minima) တွင် ပိတ်မိတတ်ခြင်း ဖြစ်ပါသည်။ လက်ရှိအခြေအနေသည် ပန်းတိုင်ရောက်မနေသော်လည်း ( $h > 0$ )၊ ရွှေ့၍ရနိုင်သော အိမ်နီးချင်း ၅၆ ခုလုံး၏ $h$ တန်ဖိုးများသည် လက်ရှိတန်ဖိုးထက် ကြီးနေလျှင် သို့မဟုတ် တူညီနေလျှင် Algorithm သည် ရှေ့ဆက်မတိုးနိုင်တော့ဘဲ ရပ်တန့်သွားပါသည်။

ဤပြဿနာကို ဖြေရှင်းရန် Random-restart hill-climbing ကို အသုံးပြုပါသည်။ ၎င်း၏ အခြေခံသဘောတရားမှာ "ပိတ်မိသွားတိုင်း အသစ်ကနေ ပြန်စမည် (If at first you don't succeed, try, try again)" ဖြစ်ပါသည်။ Local Maxima တွင် ရပ်တန့်သွားတိုင်း၊ လက်ရှိအခြေအနေကို စွန့်လွှတ်ကာ ကျပန်း (Random) အခြေအနေသစ် တစ်ခုကို ဖန်တီး၍ အစမှ ပြန်လည်ရှာဖွေပါသည်။ ပန်းတိုင်ရောက်သည်အထိ ( $h=0$ ) ဤလုပ်ငန်းစဉ်ကို အကြိမ်ကြိမ် ပြန်လုပ်သောကြောင့် 8-Queens ပြဿနာကို အမြဲတမ်း ဖြေရှင်းပေးနိုင်ပါသည်။

import random

# ==========================================

# Heuristic Function ($h$) တွက်ချက်ခြင်း

# ==========================================

def calculate_heuristic(board):

"""

ဘုတ်ပြားပေါ်ရှိ အချင်းချင်း တိုက်ခိုက်နိုင်သော ဘုရင်မ အစုံ (Attacking pairs) အရေအတွက်ကို တွက်ပါသည်။

board: 1D List (ဥပမာ - [0, 4, 7, 5, 2, 6, 1, 3] အဓိပ္ပာယ်မှာ ကော်လံ 0 တွင် အတန်း 0 ၌ ရှိသည်...)

"""

attacking_pairs = 0

n = len(board)

# ကော်လံ တစ်ခုစီရှိ ဘုရင်မများကို ကျန်ရှိသော ကော်လံများမှ ဘုရင်မများနှင့် တိုက်ရိုက် နှိုင်းယှဉ်ပါမည်

for i in range(n):

for j in range(i + 1, n):

# 1. ရေပြင်ညီ အတန်း (Same Row) တူနေသလား စစ်ဆေးခြင်း

# 2. ထောင့်ဖြတ် (Diagonal) မျဉ်းပေါ်တွင် ရှိနေသလား စစ်ဆေးခြင်း

# (ကော်လံနှစ်ခုကြား အကွာအဝေး နှင့် အတန်းနှစ်ခုကြား အကွာအဝေး တူညီနေလျှင် ထောင့်ဖြတ်မျဉ်းပေါ်တွင် ရှိသည်)

if board[i] == board[j] or abs(board[i] - board[j]) == abs(i - j):

attacking_pairs += 1

return attacking_pairs

# ==========================================

# အကောင်းဆုံး အိမ်နီးချင်း (Best Neighbor) ကို ရှာဖွေခြင်း

# ==========================================

def get_best_neighbor(board):

"""

ရွှေ့နိုင်သော အိမ်နီးချင်း ၅၆ ခုလုံးကို ဖန်တီးပြီး၊ ၎င်းတို့အနက်မှ Heuristic အနည်းဆုံး (အကောင်းဆုံး)

အခြေအနေကို ရွေးချယ်ပေးပါမည်။

"""

best_board = list(board) # လက်ရှိ Board ကို ကနဦး အကောင်းဆုံးအဖြစ် မှတ်ထားပါမည်

min_h = calculate_heuristic(board)

n = len(board)

# ကော်လံ (col) ၈ ခုလုံးကို လှည့်ပတ်စစ်ဆေးမည်

for col in range(n):

# အတန်း (row) ၈ ခုလုံးသို့ ရွှေ့ကြည့်မည်

for row in range(n):

# လက်ရှိ ရှိနေသော အတန်း မဟုတ်မှသာ ရွှေ့ကြည့်မည် (Neighbor အသစ် ဖန်တီးခြင်း)

if board[col] != row:

neighbor = list(board) # လက်ရှိ ဘုတ်ပြားကို မိတ္တူကူးပါ

neighbor[col] = row # ဘုရင်မကို အတန်းသစ်သို့ ရွှေ့ပါ

neighbor_h = calculate_heuristic(neighbor)

# အကယ်၍ Neighbor အသစ်၏ $h$ သည် လက်ရှိအနည်းဆုံး $h$ ထက် ပိုနည်းလျှင် Update လုပ်မည်

if neighbor_h < min_h:

min_h = neighbor_h

best_board = neighbor

return best_board, min_h

# ==========================================

# Standard Hill-Climbing Algorithm

# ==========================================

def hill_climbing(board):

"""

ပေးထားသော ကနဦးအခြေအနေမှ စတင်၍ Local Maxima သို့မဟုတ် Goal State ရောက်သည်အထိ ရှာဖွေမည်။

"""

current_board = board

current_h = calculate_heuristic(current_board)

while True:

# အကောင်းဆုံး Neighbor ကို ရှာပါ

neighbor_board, neighbor_h = get_best_neighbor(current_board)

# အကယ်၍ အကောင်းဆုံး Neighbor ၏ $h$ တန်ဖိုးသည် လက်ရှိ $h$ ထက် မနည်းတော့လျှင်

# (ဆိုလိုသည်မှာ ပိုမကောင်းတော့လျှင်) Local Maxima တွင် ပိတ်မိသွားပြီ ဖြစ်သဖြင့် ရပ်တန့်ပါမည်။

if neighbor_h >= current_h:

return current_board, current_h

# ပိုကောင်းသော အခြေအနေသို့ ရွှေ့ပါ

current_board = neighbor_board

current_h = neighbor_h

# ==========================================

# Random-Restart Hill-Climbing Algorithm

# ==========================================

def random_restart_hill_climbing():

"""

Hill-Climbing လုပ်ရင်း Local Maxima တွင် ပိတ်မိသွားတိုင်း၊ ကျပန်း (Random) Board အသစ်တစ်ခု

ပြန်လည်ဖန်တီး၍ Goal State ($h = 0$) ရရောက်သည်အထိ ဆက်တိုက် Restart လုပ်သွားမည့် Main Function ဖြစ်ပါသည်။

"""

restarts = 0

n = 8 # 8-Queens

while True:

# ကျပန်း ဘုတ်ပြားအသစ် တစ်ခု ဖန်တီးခြင်း (ကော်လံတစ်ခုစီအတွက် 0 မှ 7 အတွင်း ကျပန်းအတန်းတစ်ခု ရွေးခြင်း)

initial_board = [random.randint(0, n - 1) for _ in range(n)]

# Hill-Climbing ဖြင့် ဖြေရှင်းကြည့်ခြင်း

final_board, final_h = hill_climbing(initial_board)

# အကယ်၍ ဖြေရှင်းပြီးသော Board ၏ $h$ သည် 0 ဖြစ်သွားလျှင် ပြဿနာပြေလည်သွားပြီ (Goal Test အောင်မြင်သည်)

if final_h == 0:

print(f"Goal State Found! (Total Restarts: {restarts})")

return final_board

# ပိတ်မိသွားလျှင် Restart အကြိမ်ရေကို မှတ်သား၍ အပေါ်မှ `while` လှည့်ပတ်မှုအတိုင်း ပြန်လည်စတင်မည်

restarts += 1

# ==========================================

# ရလဒ်ကို ပုံဖော်ပြသရန် Function (Visualization)

# ==========================================

def print_board(board):

n = len(board)

for row in range(n):

row_str = ""

for col in range(n):

if board[col] == row:

row_str += " Q " # ဘုရင်မ ရှိသောနေရာ

else:

row_str += " . " # လွတ်နေသောနေရာ

print(row_str)

print("\nArray Representation:", board)

# Program စတင်ခြင်း

if __name__ == "__main__":

print("Running Random-Restart Hill-Climbing for 8-Queens...\n")

solution = random_restart_hill_climbing()

print("\nFinal Solution Board:")

print_board(solution)

ပရိုဂရမ်၏ အဓိက အနှစ်သာရများ

Memory အသုံးပြုမှု နည်းပါးခြင်း: State တစ်ခုလုံးကို ပြသရန် 8x8 2D Array ကြီးကို မသုံးဘဲ ကော်လံတစ်ခုလျှင် အတန်း (row index) ကိုသာ ကိုယ်စားပြုသော 1D Array (ဥပမာ [1, 3, 5, 7, 2, 0, 6, 4]) ကို အသုံးပြုထားသောကြောင့် တွက်ချက်မှု မြန်ဆန်စေပါသည်။
Steepest-Ascent: get_best_neighbor function တွင် Neighbor ၅၆ ခုလုံးကို လှည့်ပတ်စစ်ဆေးပြီးမှ အကောင်းဆုံးကိုသာ ရွေးချယ်သည့် အပြည့်စုံဆုံး (Steepest) နည်းလမ်းကို အသုံးပြုထားပါသည်။
Completeness: သာမန် Hill-climbing သည် Local Maxima ကြောင့် ဖြေရှင်းချက် ရှာမရဘဲ ရပ်တန့်နိုင်သော်လည်း၊ random_restart_hill_climbing ၏ while True: loop မှ ဖြေရှင်းချက် (Goal State) မရမချင်း Random အသစ်ပြန်လုပ်ပေးနေမည်ဖြစ်၍ ပြဿနာကို အမြဲတမ်း ဖြေရှင်းပေးနိုင်မည် (Complete ဖြစ်သည်)။

ကျမ်းပြုသူနှင့် ကျမ်းကြီးကြပ်သူ တို့၏ အခန်းကဏ္ဍများ

ကျမ်းပြု သူတစ်ဦးဟာ၊ ကျမ်းကြီးကြပ်သူ (Supervisor) ရဲ့ အလိုကျ၊ ကျမ်းကြီးကြပ်သူ သိပြီးသား ဘောင်အတွင်းကသာ ရေးသားပြုစုရတဲ့ စာတမ်းမျိုး၊ ကျမ်းမျိုး၊ သုတေသနမျိုးဟာ "သုတေသန" ဆိုတဲ့ ဝေါဟာရရဲ့ အနှစ်သာရဖြစ်တဲ့ "အသစ်ရှာဖွေတွေ့ရှိခြင်း (Originality and Novelty)" ကို သတ်ပစ်လိုက်သလို ဖြစ်သွားစေတယ်။

သုတေသန၏ အနှစ်သာရနှင့် "အသစ်ရှာဖွေတွေ့ရှိမှု" (Originality)

အဆင့်မြင့် ဘွဲ့လွန်ကျမ်းတွေ (အထူးသဖြင့် PhD Dissertation နှင့် Master's Thesis) တို့ရဲ့ အဓိက ရည်ရွယ်ချက်က၊ လူသားတို့ရဲ့ လက်ရှိ သိမြင်နားလည်ထားသော ပညာရပ်နယ်ပယ် (Knowledge boundary) ကို နောက်ထပ် ခြေတစ်လှမ်း တိုးချဲ့ပေးရန် ဖြစ်တယ်။

တကယ်လို့ ကျောင်းသားတစ်ဦးဟာ၊ ကျမ်းကြီးကြပ်သူ သိပြီးသား အဖြေကိုသာ ပြန်လည်သက်သေပြနေရမယ်၊ သို့မဟုတ် ကြီးကြပ်သူရဲ့ အယူအဆကိုသာ ပဲ့တင်ထပ်နေရမယ်ဆိုရင်၊ ၎င်းဟာ သုတေသန မဟုတ်တော့ဘဲ "လေ့ကျင့်ခန်း (Academic Exercise)" တစ်ခုသာ ဖြစ်သွားပါလိမ့်မယ်။ ဒါ့ကြောင့် လူသူလေးစားသော နိုင်ငံတကာ တက္ကသိုလ်ကြီးတွေမှာတော့၊ ထိပ်တန်း ပါမောက္ခကြီးများက မိမိ မသိသေးသော၊ မျှော်လင့်မထားသော ရလဒ်အသစ်များကို ရှာဖွေနိုင်တဲ့ ကျောင်းသားမျိုးကိုသာ လိုလားကြတယ်။

၂။ အသိပညာ အကူးအပြောင်း အမှတ် (The Point of Knowledge Transition)

သုတေသနနယ်ပယ်တစ်ခုမှာ "အကြောင်းအရာကို အသိဆုံးက ၎င်းကျမ်းကို ပြုစုမဲ့သူသာ ဖြစ်သင့်တယ်" ဆိုတဲ့ အချက်ဟာ သုတေသနလောကရဲ့ ရွှေစည်းမျဉ်း (Golden Rule) ဖြစ်တယ်။

သုတေသနခရီးစဉ်၏ တစ်နေရာ (ဥပမာ - ဒုတိယနှစ် သို့မဟုတ် တတိယနှစ်) မှာ၊ ကျောင်းသားဟာ မိမိ၏ သီးသန့် သုတေသနခေါင်းစဉ် (Niche topic) နှင့် ပတ်သက်၍ မိမိ၏ ကျမ်းကြီးကြပ်သူထက် ပိုမို သိရှိနားလည်သွားရမည် ဟု ပါမောက္ခကြီးများက လက်ခံထားကြတယ်။ ထိုသို့ ကျောင်းသားက ဆရာ့ထက် ပိုသိလာသည့် အချိန်ရောက်မှသာလျှင် ထိုကျမ်းသည် အောင်မြင်သော ကျမ်းတစ်စောင် ဖြစ်လာမည့် လမ်းစပေါ်သို့ ရောက်ရှိခြင်း ဖြစ်တယ်။ “ငါစစ်အုံးမယ် ငါကြည့်အုံးမယ်… ပေါက်ကရတွေဖြစ်ကုန်မယ်… ငါခိုင်းတဲ့အတိုင်းလုပ်” လို့ဆိုသူတွေဟာ၊ သူတို့ကိုယ်တိုင်က “ဝါလုံးခေါင်းထဲ လ သာ” ဘဝင်မြင့်နေသူတွေဖြစ်ပြီး၊ သုတေသနပြုသူ ကျောင်းသားကို အထင်သေးနေသူတွေဖြစ်တယ်။

၃။ ကျမ်းကြီးကြပ်သူ၏ အခန်းကဏ္ဍ (The True Role of a Supervisor)

တကယ်တော့ ကျမ်းကြီးကြပ်သူဟာ အလုံးစုံ ထိန်းချုပ်သူ (Micromanager) သို့မဟုတ် အဖြေကို ပုံစံချပေးသူ (Dictator) မဖြစ်ရဘူး။ ၎င်းဟာ

နည်းစနစ်ပိုင်းဆိုင်ရာ လမ်းပြသူ (Methodological Guide) - သုတေသန နည်းစနစ် မှန်ကန်စေရန်၊ ယုတ္တိဗေဒ ခိုင်လုံစေရန်နှင့် ပညာရပ်ဆိုင်ရာ စံညွှန်းများနှင့် ကိုက်ညီစေရန်သာ ထိန်းကျောင်းပေးရမှာ ဖြစ်တယ်။
အပြုသဘောဆောင် ဝေဖန်သူ (Devil's Advocate) - ကျောင်းသားရဲ့ တွေ့ရှိချက်တွေကို လွယ်လွယ်နဲ့ လက်မခံဘဲ၊ ကျောင်းသားဘက်က ခိုင်လုံသော အထောက်အထားဖြင့် ခုခံချေပနိုင်စွမ်း ရှိစေရန် အခက်ခဲဆုံး မေးခွန်းများ မေးကာ မှတ်ကျောက်တင်ဆန်းစစ်ပေးသူ (Sounding board) ဖြစ်ရပါမယ်။

အဖြစ်သင့်ဆုံး Student-Supervisor ဆက်သွယ်မှု ပုံစံ

အဆင့်မြင့် ပညာရေးစနစ်တွေမှာ အအောင်မြင်ဆုံးလို့ သတ်မှတ်ထားတဲ့ ဆက်သွယ်မှုပုံစံက "တပည့်မှသည် လုပ်ဖော်ကိုင်ဖက်သို့ ကူးပြောင်းခြင်း မော်ဒယ် (Apprenticeship to Colleagueship Model)" ဖြစ်တယ်။ ၎င်းပုံစံမှာ အောက်ပါ အဆင့် (၃) ဆင့် ပါဝင်တယ်။

လမ်းညွှန်မှု အများဆုံးကာလ (Scaffolding Stage) - သုတေသန စတင်ချိန်မှာ ကျမ်းကြီးကြပ်သူက စာတမ်းရဲ့ ရည်ရွယ်ချက်၊ သုတေသန မေးခွန်းများ ရွေးချယ်မှုနှင့် သုတေသန ပုံစံ (Research Design) တို့ကို အဓိက ကူညီလမ်းညွှန်ပေးရမှာဖြစ်တယ်။
လွတ်လပ်စွာ စူးစမ်းခွင့်ပေးသောကာလ (Independence Stage) - အချက်အလက် ကောက်ယူခြင်း၊ စမ်းသပ်ခြင်းနှင့် ခွဲခြမ်းစိတ်ဖြာခြင်းများ ပြုလုပ်ရာမှာ ကျောင်းသားအား အပြည့်အဝ လွတ်လပ်ခွင့် ပေးထားရပါမယ်။ မှားယွင်းမှုများ ရှိလာပါကလည်း ကျောင်းသားကိုယ်တိုင် သင်ခန်းစာယူ ပြင်ဆင်နိုင်ရန် အခွင့်အရေး ပေးရပါမယ်။
တန်းတူ ဆွေးနွေးခြင်းကာလ (Peer-to-Peer Stage) - တွေ့ရှိချက်များကို သုံးသပ်ရာတွင် ဆရာနှင့် တပည့် ဆက်ဆံရေးမျိုး မဟုတ်တော့ဘဲ၊ ပညာရှင် နှစ်ဦး (Scholars) အနေဖြင့် စားပွဲဝိုင်းတွင် အပြန်အလှန် ငြင်းခုံဆွေးနွေးကြသော ဆက်ဆံရေးမျိုး ဖြစ်လာရပါမယ်။

အချုပ်အားဖြင့်ဆိုရရင်၊ အကောင်းဆုံးသော ကျမ်းကြီးကြပ်သူဆိုတာ "မိမိထက် တော်သော၊ မိမိ မသိသေးသည်များကို ရှာဖွေဖော်ထုတ်နိုင်သော ပညာရှင်အသစ်တစ်ဦးကို မွေးထုတ်ပေးနိုင်သူ" သာလျှင် ဖြစ်တယ်။

(ဒီစာစုနဲ့ ကျွန်တော့ရဲ့ မဟာဥပဒေဘွဲ့ ကျမ်းကြီးကြပ်သူ တီချယ်စန္ဒာဝင်း [(Daw Sandar Win, Senior Lecturer (Retired), INTI International University, Malaysia)] ရဲ့ ဂုဏ်ကျေးဇူးကို အလေးအမြတ်မှတ်တမ်းပြုပါတယ်။)

Monday, June 29, 2026

Discretionary Power v. Inherent Power

ဥပဒေနယ်ပယ်နဲ့ တရားစီရင်ရေးနယ်ပယ်မှာအလွန်အရေးပါပြီး အမြဲလိုလို တွဲဖက်တွေ့ရှိရတတ်တဲ့ "Discretionary Power" (ကျင့်သုံးပိုင်ခွင့်/ အဆုံးအဖြတ်ပေးပိုင်ခွင့်အာဏာ) နဲ့"Inherent Power" (ကိုယ်ပိုင်ပင်ကိုယ်အရည်အသွေးအရ ရှိရင်းစွဲအာဏာ) တို့ရဲ့ အဓိပ္ပာယ်ဖွင့်ဆိုချက်တွေကို ဖော်ပြပေးပါမယ်။

၁။ Discretionary Power (ကျင့်သုံးပိုင်ခွင့် သို့မဟုတ် အဆုံးအဖြတ်ပေးပိုင်ခွင့်အာဏာ)
===========
Discretionary Power ဆိုတာ၊ ဥပဒေက တရားသူကြီး သို့မဟုတ် စီမံခန့်ခွဲရေးအာဏာပိုင်တစ်ဦးကို ကိစ္စရပ်တစ်ခုအပေါ် တိကျပြတ်သားသော စည်းမျဉ်းတစ်ခုတည်းအတိုင်း လိုက်နာရန် အတင်းအကျပ် မပြဌာန်းဘဲ၊ ဖြစ်ရပ်ရဲ့ အခြေအနေအရပ်ရပ်ကို သုံးသပ်ပြီး မိမိရဲ့ ကိုယ်ပိုင်အမြော်အမြင်၊ တရားမျှတမှုစံနှုန်းတို့အပေါ် အခြေခံကာ လွတ်လပ်စွာ ရွေးချယ်ဆုံးဖြတ်ပိုင်ခွင့် ပေးထားတဲ့ အာဏာကို ဆိုလိုတယ်။ သို့သော် ထိုအာဏာဟာ၊ လုံးဝဥဿုံ လွတ်လပ်ခြင်း (Arbitrary) မဟုတ်ဘဲ ဥပဒေကြောင်းအရ အကြောင်းပြချက် ခိုင်လုံရပါမယ်။
REF: Black's Law Dictionary (11th Edition), Bryan A. Garner, 2019, Thomson Reuters (West Publishing Co.), St. Paul, MN, USA., p.583, "Judicial Discretion"

• အနှစ်ချုပ်: ဥပဒေကြောင်းအရ ပြတ်ပြတ်သားသား ကန့်သတ်မထားတဲ့ ကိစ္စရပ်များတွေမှာ တရားသူကြီးတစ်ဦးအနေဖြင့် မျှတမှု နဲ့ သင့်လျော်မှန်ကန်မှုရှိစေရန် မိမိ၏ ကိုယ်ပိုင်ဆုံးဖြတ်ချက်ဖြင့် ဆောင်ရွက်နိုင်ခွင့် ဟာ (Discretion) ဖြစ်တယ်။
• ဥပမာအားဖြင့် ပြစ်မှုဆိုင်ရာကျင့်ထုံးဥပဒေမှာ အာမခံပေးခြင်းနဲ့စပ်လျဉ်းပြီး "May be released on bail" (အာမခံပေးနိုင်သည်) ဟု သုံးနှုန်းထားခြင်းမျိုး ဖြစ်တယ်။ "May" လို့ သုံးနှုန်းထားခြင်းဟာ တရားရုံးကို "Discretionary Power" ပေးထားခြင်းဖြစ်ပြီး၊ မဖြစ်မနေ ပေးရမည်ဟု ပြဌာန်းတဲ့ "Shall" နဲ့ကွာခြားတယ်။

၂။ Inherent Power (ကိုယ်ပိုင်ပင်ကိုယ်အရည်အသွေးအရ ရှိရင်းစွဲအာဏာ၊ မူလဘူတအာဏာ)
==============
Inherent Power ဆိုတာကို ဥပဒေပြဌာန်းချက်တွေမှာ တိတိပပ အတိအလင်း ရေးသားဖော်ပြမထားပေမဲ့၊ တရားရုံးတစ်ခုရဲ့ ဂုဏ်သိက္ခာကို ထိန်းသိမ်းရန်၊ တရားစီရင်ရေးလုပ်ငန်းစဉ်ကို အလွဲသုံးစားလုပ်ခြင်းမှ ကာကွယ်ရန်နဲ့ အမှုသည်များအတွက် "စစ်မှန်သော တရားမျှတမှု" (Ends of Justice) ဖော်ဆောင်ပေးနိုင်ရန်၊ "တရားရုံးဖြစ်တည်လာမှုနှင့်အတူ ပင်ကိုယ်ကတည်းက ကပ်ပါလာသော အာဏာ" ကို ဆိုလိုတယ်။ ဥပဒေပြဌာန်းချက်မှာ လစ်ဟာနေတဲ့ကြားနယ် (Gap) ဖြစ်နေပြီး၊ အခက်အခဲကြုံရချိန်မှာ ဒီ အာဏာကို သုံးရတယ်။

REF: Mulla: The Code of Civil Procedure (Abridged Edition / 18th Edition), Sir Dinshah Fardunji Mulla (Revised by Soli J. Sorabjee), (2012), LexisNexis Butterworths Wadhwa, Nagpur, India., (Pages 280-284), Section 151 ဖွင့်ဆိုချက်အောက်တွင်ရှု။

o အနှစ်ချုပ်: ဥပဒေပြုလွှတ်တော်ဟာ  အနာဂတ်မှာ ဖြစ်လာမဲ့ အခြေအနေအားလုံးကို ကြိုတင်ခန့်မှန်းပြီး ဥပဒေမပြဌာန်းနိုင်ဘူး။ ဒါ့ကြောင့် ဥပဒေမှာ  အတိအလင်း မပါရှိပေမဲ့ တရားမျှတမှုအတွက် လိုအပ်ပါက တရားရုံးက ၎င်းရဲ့ ရှိရင်းစွဲအာဏာ၊ မူလဘူတ အာဏာ (Inherent Power) ဆိုတာကို သုံးပိုင်ခွင့်ရှိတယ်။

Saturday, February 21, 2026

Hill-climbing Algorithm for 8-Queens Problem

Stuart Russell နဲ့ Peter Norvig တို့ ရေးသားတဲ့၊ “Artificial Intelligence: A Modern Approach, Fourth Edition” စာအုပ် ရဲ့၊ "CHAPTER 4 SEARCH IN COMPLEX ENVIRONMENTS" အခန်းမှာ ပါတဲ့ "Hill-climbing Algorithm" ကို "8-queens problem" နဲ့ ပေါင်းစပ်ပြီး အပြည့်အစုံ ရှင်းလင်းတင်ပြပေးပါမယ်။

Figure 4.3 (က) ဘုရင်မ ၈-ပါးပြဿနာ။ ဘုရင်မ ၈-ပါးကို စစ်တုရင်ဘုတ်ပေါ်တွင် ဘုရင်မတစ်ပါးနှင့်တစ်ပါး မတိုက်ခိုက်စေရန် ထားပါ။ (ဘုရင်မသည် အတန်း၊ ကော်လံ သို့မဟုတ် ထောင့်ဖြတ် ပေါ်ရှိ မည်သည့် အရာကိုမဆို တိုက်ခိုက်နိုင်ပါသည်။) ပုံတွင် ထောင့်ဖြတ်မျဉ်းတစ်လျှောက်တွင် တစ်ခုနှင့်တစ်ခု တိုက်ခိုက်နေသော စတုတ္ထနှင့် သတ္တမကော်လံရှိ ဘုရင်မနှစ်ပါးမှလွဲ၍ ဤအနေအထားသည် အဖြေတစ်ခု ရလုနီးပါးအဆင့်ဖြစ်သည်။

(ခ) heuristic cost estimate [current state အတွက်၊ ကျန်ရှိနေသေးတဲ့ ပဋိပက္ခ conflicts အရေအတွက် ကို တိုင်းတာတဲ့ဖန်ရှင်] h = 17 ပါသော ဘုရင်မ ၈-ပါးအခြေအနေ။ လက်ရှိအခြေအနေ။ စစ်တုရင်ဘုတ်သည် ၎င်း၏ကော်လံအတွင်း ဘုရင်မတစ်ပါးကို ရွှေ့ခြင်းဖြင့် ရရှိနိုင်သော ဆက်ခံသူတိုင်းအတွက် h ၏တန်ဖိုးကို ပြသည်။ h = 12 ဖြင့် အကောင်းဆုံးတွဲဖက်ထားသော ရွေ့လျားမှု ၈-ခုရှိသည်။ hill-climbing algorithm သည် ဤအရာများထဲမှ တစ်ခုကို ရွေးပါမည်။

(နည်းသစ်ဉာဏ်ရည်တုပညာမိတ်ဆက်, စာ-၁၆၀)

ပြီးပြည့်စုံသောအခြေအနေ တည်ဆောက်ခြင်း (Complete-state Formulation)

8-queens ပြဿနာကို ဖြေရှင်းရာမှာ နည်းလမ်းအမျိုးမျိုးရှိပါတယ်။ ဥပမာ - ဘုတ်ပြားအလွတ်ကနေ စပြီး ဘုရင်မ တစ်ပါးချင်းစီကို အဆင့်လိုက် နေရာချသွားတဲ့ နည်းလမ်းရှိသလို၊ ယခု ကျွန်တော်တို့ အသုံးပြုမယ့် Complete-state formulation လိုမျိုး နည်းလမ်းလည်း ရှိပါတယ်။

Complete-state formulation ဆိုတာ အစကတည်းက စစ်တုရင်ဘုတ်ပြားပေါ်မှာ ကော်လံ (Column) တစ်ခုကို ဘုရင်မတစ်ပါးစီနှုန်းနဲ့ ၈ ပါးလုံးကို နေရာချထားလိုက်ခြင်းပါ။ ဆိုလိုတာက အခြေအနေတိုင်းမှာ အဖြေတစ်ခု ဖြစ်လာဖို့ လိုအပ်တဲ့ "အစိတ်အပိုင်းများ အားလုံး (ဘုရင်မ ၈ ပါးလုံး)" ပါရှိနေပြီးသား ဖြစ်ပါတယ်။ ဒါပေမဲ့ ၎င်းတို့ဟာ အချင်းချင်း တိုက်ခိုက်နိုင်တဲ့ (စားနိုင်တဲ့) နေရာတွေမှာ ရှိနေနိုင်တဲ့အတွက် အားလုံးက မှန်ကန်တဲ့ နေရာမှာတော့ ရှိမနေသေးပါဘူး။ ကျွန်တော်တို့ရဲ့ အဓိက ရည်ရွယ်ချက်က အဲဒီ ပဋိပက္ခ (Conflicts) တွေကို တစ်ဆင့်ချင်း လျှော့ချသွားဖို့ပဲ ဖြစ်ပါတယ်။

Heuristic Cost Estimate

Hill-climbing (တောင်တက်ခြင်း) အယ်လဂိုရီသမ်က အကောင်းဆုံး အဖြေကို ရှာဖွေဖို့ Heuristic cost ကို အသုံးပြုပါတယ်။ 8-queens ပြဿနာအတွက် Heuristic ဆိုတာ "လက်ရှိအခြေအနေမှာ အချင်းချင်း တိုက်ခိုက်နေတဲ့ (စားလို့ရနေတဲ့) ဘုရင်မ စုံတွဲအရေအတွက် (Number of attacking pairs)" ကို တွက်ချက်တာပါ။ ပဋိပက္ခ လုံးဝမရှိတဲ့ ပြီးပြည့်စုံတဲ့ အဖြေမှန်ကို ရဖို့ဆိုရင် ဒီ Cost တန်ဖိုးက 0 ဖြစ်သွားရပါမယ်။

Python Code

# -*- coding: utf-8 -*-
"""
Created on Sat Feb 21 20:59:50 2026
@author: kks
"""
import random
# ဘုရင်မ ၈ ပါးရဲ့ အခြေအနေကို list တစ်ခုအနေနဲ့ ဖော်ပြပါမယ်။
# ဥပမာ - state = [3, 0, 4, 7, 5, 2, 6, 1] ဆိုပါစို့။
# index (0 မှ 7 အထိ) က ကော်လံ (Column) ကို ကိုယ်စားပြုပြီး၊
# ထိုနေရာရှိ တန်ဖိုးက အဲဒီကော်လံမှာရှိတဲ့ ဘုရင်မရဲ့ အတန်း (Row) ကို ကိုယ်စားပြုပါတယ်။
# ဒါဟာ Complete-state formulation ကို ကိုယ်စားပြုတဲ့ အကောင်းဆုံး Data Structure ဖြစ်ပါတယ်။
def calculate_conflicts(state):
"""
Heuristic cost estimate function ပါ။
လက်ရှိ board အခြေအနေ (state) မှာ အချင်းချင်း တိုက်ခိုက်နိုင်တဲ့ ဘုရင်မ စုံတွဲ အရေအတွက်ကို တွက်ချက်ပေးပါတယ်။
"""
conflicts = 0
n = len(state)
for i in range(n):
for j in range(i + 1, n):
# တိုက်ခိုက်နိုင်ခြေ (၂) မျိုးကို စစ်ဆေးရပါမယ်။
# ၁။ အတန်း (Row) တူနေသလား စစ်ဆေးခြင်း -> state[i] == state[j]
# ၂။ ထောင့်ဖြတ် (Diagonal) တူနေသလား စစ်ဆေးခြင်း -> abs(state[i] - state[j]) == abs(i - j)
# မှတ်ချက် - ကော်လံ (Column) ကတော့ Array ရဲ့ Index မတူတဲ့အတွက် အမြဲတမ်း ကွဲပြားနေပြီးသားပါ။
if state[i] == state[j] or abs(state[i] - state[j]) == abs(i - j):
conflicts += 1
return conflicts
def get_best_neighbor(state):
"""
လက်ရှိအခြေအနေကနေ သွားနိုင်တဲ့ အိမ်နီးချင်း (Neighbors) ၅၆ ခုထဲက
conflicts အနည်းဆုံးဖြစ်မယ့် အကောင်းဆုံး အိမ်နီးချင်းကို ရှာဖွေပေးပါတယ်။
(ကော်လံ ၈ ခုမှာရှိတဲ့ ဘုရင်မတွေကို ကိုယ်ပိုင်ကော်လံအတွင်း အခြား row ၇ ခုဆီ တစ်ပါးချင်း ရွှေ့ကြည့်ခြင်းဖြစ်ပါတယ်၊ ၈ x ၇ = ၅၆)
"""
best_neighbors = []
# လက်ရှိ cost ကို အနည်းဆုံး cost အဖြစ် အရင်သတ်မှတ်ထားပါမယ်။
min_conflicts = calculate_conflicts(state)
n = len(state)
for col in range(n):
for row in range(n):
if state[col] == row:
continue # လက်ရှိရှိနေတဲ့နေရာကို ရွှေ့စရာမလိုလို့ ကျော်သွားပါမယ်
# အိမ်နီးချင်း အခြေအနေသစ် တစ်ခု ဖန်တီးပါမယ်
neighbor = list(state)
neighbor[col] = row

# အိမ်နီးချင်းအသစ်ရဲ့ Heuristic cost (conflicts) ကို တွက်ချက်ပါမယ်
neighbor_conflicts = calculate_conflicts(neighbor)
if neighbor_conflicts < min_conflicts:
# ပိုကောင်းတဲ့ အခြေအနေ (conflicts ပိုနည်းတဲ့ အခြေအနေ) ကို တွေ့ရင်
min_conflicts = neighbor_conflicts
best_neighbors = [neighbor] # တွေ့ထားသမျှ အကောင်းဆုံး list ကို အသစ်ပြန်စပါမယ်
elif neighbor_conflicts == min_conflicts:
# တူညီတဲ့ အကောင်းဆုံး အခြေအနေတွေကို list ထဲ ထပ်ထည့်ပါမယ်
best_neighbors.append(neighbor)
# အကောင်းဆုံး အိမ်နီးချင်းတွေထဲက တစ်ခုကို ကျပန်းရွေးချယ်ပါမယ်
if best_neighbors:
return random.choice(best_neighbors), min_conflicts
else:
return state, min_conflicts # ပိုကောင်းတဲ့ အိမ်နီးချင်း မရှိရင် လက်ရှိကိုပဲ ပြန်ပေးပါမယ်
def hill_climbing(initial_state):
"""
Steepest-ascent Hill-climbing algorithm ရဲ့ အဓိက အပိုင်းဖြစ်ပါတယ်။
"""
current_state = initial_state
current_conflicts = calculate_conflicts(current_state)
step = 0
print(f"Step {step}: Initial State = {current_state}, Conflicts = {current_conflicts}")
while True:
# အကောင်းဆုံး အိမ်နီးချင်းကို ရှာပါမယ်
neighbor, neighbor_conflicts = get_best_neighbor(current_state)
# Hill-climbing ရဲ့ အားနည်းချက် သဘောတရားအရ၊ ပိုကောင်းတဲ့ အိမ်နီးချင်း မရှိတော့ရင် (သို့)
# လက်ရှိထက် ပဋိပက္ခ မနည်းတော့ဘူးဆိုရင် တောင်ထိပ် (Local Maxima သို့မဟုတ် Global Maxima) ကို ရောက်ပြီဖြစ်လို့ ဆက်မရှာဘဲ ရပ်ပါမယ်။
if neighbor_conflicts >= current_conflicts:
print(f"\nSearch stopped. Reached a peak (cost cannot be decreased further).")
break
# အခြေအနေသစ်ကို ပြောင်းလဲပါမယ်
current_state = neighbor
current_conflicts = neighbor_conflicts
step += 1
print(f"Step {step}: Moved to = {current_state}, Conflicts = {current_conflicts}")
return current_state, current_conflicts
# ပရိုဂရမ် စတင်ခြင်း
if __name__ == "__main__":
# Complete-state formulation အရ ဘုရင်မ ၈ ပါးကို ကျပန်း နေရာချပါမယ်
# (ကော်လံတစ်ခုစီအတွက် row 0 ကနေ 7 အထိ ကျပန်းရွေးချယ်ပါမယ်)
initial_board = [random.randint(0, 7) for _ in range(8)]

print("--- Hill-Climbing Algorithm for 8-Queens ---")
final_state, final_cost = hill_climbing(initial_board)

print("\n--- Final Result ---")
print(f"Final State: {final_state}")
print(f"Remaining Conflicts: {final_cost}")

if final_cost == 0:
print("Success! A complete solution without any conflicts was found.")
else:
print("Failed to find a perfect solution. Got stuck in a Local Maximum.")
print("(မှတ်ချက် - ရိုးရှင်းသော Hill-climbing သည် တောင်ကုန်းငယ်များ (Local Maxima) တွင် ပိတ်မိလေ့ရှိပါသည်။ ၎င်းသည် ဤ Algorithm ရဲ့ သဘာဝ အားနည်းချက်ဖြစ်ပါသည်။)")

ပရိုဂရမ် အနှစ်ချုပ်

ဒီပရိုဂရမ်က၊ ဘုရင်မ ၈ ပါးကို ကျပန်းချထားခြင်းမှ စတင်ပြီး၊ တစ်ဆင့်ချင်းစီမှာ၊ အချင်းချင်းတိုက်ခိုက်မှု (Conflicts) အနည်းဆုံးဖြစ်စေမဲ့ အိမ်နီးချင်းအခြေအနေဆီသို့ ရွှေ့လျားသွားပါတယ်။ တိုက်ခိုက်မှု လုံးဝမရှိတော့သည့် အခြေအနေ (သို့မဟုတ်) ထပ်မံ၍ လျှော့ချ၍ မရနိုင်တော့သည့် အခြေအနေ (Local Maxima) သို့ရောက်သောအခါ ရပ်တန့်သွားမှာဖြစ်ပါတယ်။

နောက် ပို့စ်မှာ Hill-Climbing ရဲ့ အဓိကပြဿနာဖြစ်တဲ့ "Local Maxima မှာ ပိတ်မိတတ်ခြင်း" ကို ဖြေရှင်းပေးနိုင်တဲ့ "Random-restart hill-climbing" အကြောင်းကိုဆက်လက်တင်ပြပေးပါမယ်။

Sunday, February 8, 2026

Inductive Logic Programming (ILP)

REF:

AIMA 4th Edition

Chapter 20 Knowledge in Learning

20.5 Inductive Logic Programming

p-758

Inductive Logic Programming (ILP) ဟူသည် စက်သင်ယူမှု (Machine Learning) နှင့် လောဂျစ်ပရိုဂရမ်ရေးသားခြင်း (Logic Programming) တို့ကို ပေါင်းစပ်ထားသော ပညာရပ်တစ်ခု ဖြစ်ပါတယ်။ ၎င်းသည် "နမူနာများမှတစ်ဆင့် ယေဘုယျကျသော စည်းမျဉ်းများကို လောဂျစ်နည်းကျ ဖော်ထုတ်ခြင်း" ဟု အဓိပ္ပာယ်ရတယ်။ အောက်မှာ ILP ရဲ့ လက်တွေ့လုပ်ဆောင်ပုံကို အတိုချုပ်ပြီး အဆင့်ဆင့် ရှင်းလင်းတင်ပြပေးလိုက်ပါတယ်။

ILP ၏ လက်တွေ့လုပ်ဆောင်ပုံ (Step-by-Step)

ILP စနစ်တစ်ခု အလုပ်လုပ်ရန်အတွက် အဓိက အစိတ်အပိုင်း (၃) ခု လိုအပ်ပါတယ်။

နောက်ခံဗဟုသုတ (Background Knowledge - BK) ကျွန်ုပ်တို့ ကြိုတင်သိရှိထားပြီးသား အချက်အလက်များ။
အပြုသဘောဆောင်သော နမူနာများ (Positive Examples – E⁺ ) မှန်ကန်ကြောင်း ကျွန်ုပ်တို့ သိရှိသော အချက်များ။
အနုတ်လက္ခဏာဆောင်သော နမူနာများ (Negative Examples -E^-) မမှန်ကန်ကြောင်း (သို့မဟုတ်) မဖြစ်နိုင်ကြောင်း ကျွန်ုပ်တို့ သိရှိသော အချက်များ။

ပန်းတိုင်: E⁺ အားလုံးကို ရှင်းပြနိုင်ပြီး E^- တစ်ခုမှ မပါဝင်သော လောဂျစ်စည်းမျဉ်း (Hypothesis - H) ကို ရှာဖွေရန်။

ဥပမာ - "ဘိုးဘွား" (Grandparent) တော်စပ်မှုကို သင်ယူခြင်း

အဆင့် (၁) - အချက်အလက်များ ထည့်သွင်းခြင်း (Inputs)

BK: parent(maung_maung, zaw_zaw), parent(zaw_zaw, hla_hla) (မောင်မောင်သည် ဇော်ဇော်၏ အဖေ၊ ဇော်ဇော်သည် လှလှ၏ အဖေ)
E⁺: grandparent(maung_maung, hla_hla) (မောင်မောင်သည် လှလှ၏ ဘိုးဘွားဖြစ်သည် - မှန်)
E^-: grandparent(hla_hla, maung_maung) (လှလှသည် မောင်မောင်၏ ဘိုးဘွားဖြစ်သည် - မှား)

အဆင့် (၂) - ယူဆချက်ကို စတင်ရှာဖွေခြင်း (Hypothesis Construction)

ILP သည် အောက်ပါအတိုင်း စည်းမျဉ်းများကို စမ်းသပ်ပါမည် -

ယူဆချက် ၁: grandparent(X, Y) :- parent(X, Y). (X သည် Y ၏ မိဘဖြစ်လျှင် ဘိုးဘွားဖြစ်သည်)

ရလဒ်: E⁺ ကို မရှင်းပြနိုင်ပါ။ (မောင်မောင်သည် လှလှ၏ မိဘမဟုတ်ပါ)။

ယူဆချက် ၂: grandparent(X, Y) :- parent(X, Z), parent(Z, Y). (X သည် Z ၏ မိဘဖြစ်ပြီး၊ ထို Z သည် Y ၏ မိဘဖြစ်လျှင် X သည် Y ၏ ဘိုးဘွားဖြစ်သည်)

ရလဒ်: E⁺ ကို ရှင်းပြနိုင်သည် (မောင်မောင် → ဇော်ဇော် → လှလှ)။ E^- ကိုလည်း ရှောင်လွှဲနိုင်ပါတယ်။

အဆင့် (၃) - ယေဘုယျပြုခြင်း (Generalization)

ရှာဖွေတွေ့ရှိထားသော စည်းမျဉ်းကို အခြားဒေတာအသစ်များတွင် အသုံးပြုနိုင်ရန် အတည်ပြုလိုက်ပါတယ်။ ဤနည်းဖြင့် ILP သည် 'Grandparent' ဆိုသော အဓိပ္ပာယ်ကို ဒေတာများမှတစ်ဆင့် ကိုယ်တိုင် သင်ယူသွားခြင်း ဖြစ်ပါတယ်။

လက်တွေ့လုပ်ဆောင်နိုင်သော Python ပရိုဂရမ်

လက်တွေ့မှာ ILP ကို Prolog ဘာသာစကားနဲ့ အရေးအများဆုံး ဖြစ်ပေမဲ့, Python တွင် Kanren သို့မဟုတ် SymPy တို့ကဲ့သို့သော Logic library များ ရှိပါတယ်။ ဒီနေရာမှာ ILP ရဲ့ သဘောသဘာဝကို နားလည်စေဖို့ Simple Rule Learner ပုံစံမျိုးကို Python ဖြင့် ဖန်တီးပြပါမယ်။

ဒီပရိုဂရမ်က ပေးထားသော မိဘတော်စပ်မှု (Parent) ဒေတာများမှ ဘိုးဘွားတော်စပ်မှု (Grandparent) စည်းမျဉ်းကို အလိုအလျောက် ရှာဖွေပေးပါမယ်။

Python
# Simple ILP-style Rule Learner in Python

class SimpleILP:
    def __init__(self, background_knowledge, pos_examples, neg_examples):
        self.bk = background_knowledge
        self.pos = pos_examples
        self.neg = neg_examples

    def test_rule(self, rule_func):
        # အပြုသဘောဆောင်သော နမူနာအားလုံး မှန်ရမည်
        for p in self.pos:
            if not rule_func(p[0], p[1], self.bk):
                return False
        # အနုတ်လက္ခဏာဆောင်သော နမူနာအားလုံး မှားရမည်
        for n in self.neg:
            if rule_func(n[0], n[1], self.bk):
                return False
        return True

# နောက်ခံဗဟုသုတ (Parent Relationship)
# parent(parent_name, child_name)
bk_data = [
    ('Maung Maung', 'Zaw Zaw'),
    ('Zaw Zaw', 'Hla Hla'),
    ('Aung Aung', 'Kyaw Kyaw'),
    ('Kyaw Kyaw', 'Mya Mya')
]

# သင်ယူရမည့် နမူနာများ (Positive & Negative)
pos_examples = [('Maung Maung', 'Hla Hla'), ('Aung Aung', 'Mya Mya')]
neg_examples = [('Hla Hla', 'Maung Maung'), ('Zaw Zaw', 'Maung Maung')]

# စမ်းသပ်မည့် ယူဆချက်များ (Hypotheses)
def hypothesis_1(X, Y, bk):
    # Rule: grandparent(X, Y) :- parent(X, Y)
    return (X, Y) in bk

def hypothesis_2(X, Y, bk):
    # Rule: grandparent(X, Y) :- parent(X, Z), parent(Z, Y)
    for parent, child in bk:
        if parent == X:
            Z = child
            if (Z, Y) in bk:
                return True
    return False

# ILP Engine စတင်လည်ပတ်ခြင်း
learner = SimpleILP(bk_data, pos_examples, neg_examples)

print("--- ILP Learning Process ---")
for i, hyp in enumerate([hypothesis_1, hypothesis_2], 1):
    result = learner.test_rule(hyp)
    status = "Passed ✅" if result else "Failed ❌"
    print(f"Testing Hypothesis {i}: {status}")
    if result:
        print(f"Found Correct Rule: grandparent(X, Y) :- parent(X, Z), parent(Z, Y)")

ရှင်းလင်းချက်:

BK Data မိသားစု ဆက်နွယ်မှုများကို Tuple အဖြစ် သိမ်းထားပါတယ်။
SimpleILP Class ၎င်းသည် ပေးထားသော Rule တစ်ခုသည် Positive examples များကို အကုန်လက်ခံပြီး Negative များကို ငြင်းပယ်ခြင်း ရှိမရှိ စစ်ဆေးပေးသည့် "Evaluator" ဖြစ်တယ်။
Hypothesis 1 ၎င်းသည် "မိဘဖြစ်လျှင် ဘိုးဘွားဖြစ်သည်" ဟု ယူဆသောကြောင့် စစ်ဆေးမှု ကျရှုံးပါတယ်။
Hypothesis 2 ၎င်းသည် "မိဘ၏ မိဘ" (Grandparent) ဖြစ်သည်ကို စစ်ဆေးနိုင်သောကြောင့် စစ်ဆေးမှု အောင်မြင်သွားပါတယ်။

လက်တွေ့အသုံးချမှု

အစစ်အမှန် ILP စနစ်များ (ဥပမာ - Aleph, Metagol) သည် ဤထက်မက ရှုပ်ထွေးသော စည်းမျဉ်းများကို ဒေတာ သန်းပေါင်းများစွာထဲမှ ရှာဖွေနိုင်ပါတယ်။ ၎င်းတို့ကို ဇီဝဗေဒဆိုင်ရာ မော်လီကျူးများ တည်ဆောက်ပုံ လေ့လာခြင်း (Drug discovery) နှင့် သဘာဝဘာသာစကား နားလည်ခြင်း (NLP) တို့တွင် အသုံးချကြပါတယ်။