ဥပဒေနယ်ပယ်နဲ့ တရားစီရင်ရေးနယ်ပယ်မှာအလွန်အရေးပါပြီး အမြဲလိုလို တွဲဖက်တွေ့ရှိရတတ်တဲ့ "Discretionary Power" (ကျင့်သုံးပိုင်ခွင့်/ အဆုံးအဖြတ်ပေးပိုင်ခွင့်အာဏာ) နဲ့"Inherent Power" (ကိုယ်ပိုင်ပင်ကိုယ်အရည်အသွေးအရ ရှိရင်းစွဲအာဏာ) တို့ရဲ့ အဓိပ္ပာယ်ဖွင့်ဆိုချက်တွေကို ဖော်ပြပေးပါမယ်။
သင်္ချာ၊ ကွန်ပျူတာသိပ္ပံ၊ ဉာဏ်ရည်တုပညာ နှင့် ဥပဒေ ဆိုင်ရာ သုတ ရသ ဆောင်းပါးများ
Monday, June 29, 2026
Discretionary Power v. 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
# -*- 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) စည်းမျဉ်းကို
အလိုအလျောက် ရှာဖွေပေးပါမယ်။
# Simple ILP-style Rule Learner in Python
def __init__(self, background_knowledge, pos_examples, neg_examples):
self.bk = background_knowledge
self.pos = pos_examples
self.neg = neg_examples
# အပြုသဘောဆောင်သော နမူနာအားလုံး မှန်ရမည်
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(parent_name, child_name)
bk_data = [
('Maung Maung', 'Zaw Zaw'),
('Zaw Zaw', 'Hla Hla'),
('Aung Aung', 'Kyaw Kyaw'),
('Kyaw Kyaw', 'Mya Mya')
]
pos_examples = [('Maung Maung', 'Hla Hla'), ('Aung Aung', 'Mya Mya')]
neg_examples = [('Hla Hla', 'Maung Maung'), ('Zaw Zaw', 'Maung Maung')]
def hypothesis_1(X, Y, bk):
# Rule: grandparent(X, Y) :- parent(X, Y)
return (X, Y) in 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
learner = SimpleILP(bk_data, pos_examples, neg_examples)
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) တို့တွင် အသုံးချကြပါတယ်။
Thursday, January 29, 2026
အေအိုင် နှင့် ပညာမျိုးကန်းမည့်အန္တရာယ်
Zebra Puzzle as CSP
နည်းသစ်ဉာဏ်ရည်တုပညာမိတ်ဆက်၊ အခန်း (၅)၊ ကန့်သတ်ချက်ပြေလည်စေရသော ပြဿနာများ၊ လေ့ကျင့်ခန်းများ (မေးခွန်း နှင့် အဖြေများ)၊ ပုစ္ဆာ အမှတ် ၅.၃၊ စာ-၂၆၀ ကိုကြည့်ပါ။
ဤပရိုဂရမ်အလုပ်လုပ်နိုင်စေရန် python-constraint package လိုအပ်ပါသည်။
Windows 11 ပေါ်ရှိ Spyder IDE တွင် python-constraint package ကို install လုပ်ရန် အလွယ်ကူဆုံး နည်းလမ်း။
နည်းလမ်း (၁) - Spyder အတွင်းမှ တိုက်ရိုက် Install ပြုလုပ်နည်း (အလွယ်ဆုံးနည်းလမ်း)
Spyder ဖွင့်ထားရင်းနဲ့ ပရိုဂရမ်အပြင်ထွက်စရာမလိုဘဲ Console ကနေ တိုက်ရိုက်သွင်းနိုင်ပါတယ်။
Spyder ကို ဖွင့်ပါ။
မျက်နှာပြင်ရဲ့ ညာဘက်အောက်ထောင့်နားမှာရှိတဲ့ IPython Console (အမည်းရောင် သို့မဟုတ် အဖြူရောင် စာရိုက်ကွက်) ကို ကြည့်ပါ။
ထို Console တွင် အောက်ပါ Command ကို ရိုက်ထည့်ပြီး Enter ခေါက်ပါ။ (ရှေ့ဆုံးက
!သင်္ကေတ ပါရပါမယ်)!pip install python-constraintကွန်ပျူတာက Internet ချိတ်ထားရင် download ဆွဲပြီး install လုပ်သွားပါလိမ့်မယ်။
Successfully installed python-constraint...ဆိုပြီး စာပေါ်လာရင် ရပါပြီ။
နည်းလမ်း (၂) - Anaconda Prompt မှတဆင့် Install ပြုလုပ်နည်း (ပိုမိုသေချာသောနည်းလမ်း)
ပထမနည်းလမ်းနဲ့ အဆင်မပြေရင် (သို့မဟုတ်) Error တက်နေရင် ဒီနည်းလမ်းကို သုံးပါ။
ကွန်ပျူတာရဲ့ Start Menu (Windows Key) ကို နှိပ်ပါ။
Search box မှာ "Anaconda Prompt" လို့ ရိုက်ရှာပြီး ဖွင့်လိုက်ပါ။ (အမည်းရောင် box ပေါ်လာပါမယ်)။
အဲဒီ Box ထဲမှာ အောက်ပါစာကို ရိုက်ထည့်ပြီး Enter ခေါက်ပါ။
pip install python-constraintInstall လုပ်ပြီးသွားရင် Box ကို ပိတ်လိုက်ပြီး Spyder ကို ပြန်ဖွင့် (Restart) လိုက်ပါ။
Install ဖြစ်မဖြစ် စမ်းသပ်ခြင်း
Install လုပ်ပြီးသွားရင် သေချာမသေချာ စစ်ဆေးဖို့အတွက် Spyder မှာ အောက်ပါ ကုဒ်တိုလေးကို ရိုက်ပြီး Run ကြည့်လိုက်ပါ။
import constraint
print("Installation Successful!")
Error မတက်ဘဲ "Installation Successful!" လို့ ပေါ်လာရင်တော့ python-constraint ကို စတင်အသုံးပြုပြီး မြင်းကျားပဟေဠိကို ဖြေရှင်းနိုင်ပါပြီ။
def solve_zebra_puzzle():
# ၁။ Knowledge Base အဖြစ် Problem ကို စတင်တည်ဆောက်ခြင်း
problem = Problem()
# ၂။ Variables (ကိန်းရှင်များ) သတ်မှတ်ခြင်း
# အိမ်နံပါတ် ၁ မှ ၅ ထိ (Domain)
houses = [1, 2, 3, 4, 5]
# အရည်အသွေးများ (Attributes)
nationalities = ["English", "Spaniard", "Irish", "Nigerian", "Japanese"]
colors = ["Red", "Green", "Ivory", "Yellow", "Blue"]
drinks = ["Coffee", "Tea", "Milk", "Orange Juice", "Water"]
pets = ["Dog", "Snails", "Fox", "Horse", "Zebra"]
sports = ["Cricket", "Go", "Judo", "Poker", "Polo"] # မူရင်းပဟေဠိ၏ ဆေးလိပ်အစား အားကစားဖြင့် အစားထိုးထားသည်
all_variables = nationalities + colors + drinks + pets + sports
# Variable တစ်ခုစီသည် အိမ်နံပါတ် ၁ မှ ၅ အတွင်းသာ ရှိရမည်
problem.addVariables(all_variables, houses)
# ၃။ Constraints (ကန့်သတ်ချက်များ) ထည့်သွင်းခြင်း
# အိမ်တစ်အိမ်စီတွင် အရောင်၊ လူမျိုး၊ အချိုရည်၊ တိရစ္ဆာန်၊ အားကစား တစ်မျိုးစီသာ ရှိရမည် (AllDifferent)
problem.addConstraint(AllDifferentConstraint(), nationalities)
problem.addConstraint(AllDifferentConstraint(), colors)
problem.addConstraint(AllDifferentConstraint(), drinks)
problem.addConstraint(AllDifferentConstraint(), pets)
problem.addConstraint(AllDifferentConstraint(), sports)
# ပေးထားသော အချက်အလက်များ (Facts) ကို ထည့်သွင်းခြင်း
# ၁။ အင်္ဂလိပ်လူမျိုးသည် အနီရောင်အိမ်တွင် နေထိုင်သည်။
problem.addConstraint(lambda eng, red: eng == red, ("English", "Red"))
# ၂။ စပိန်လူမျိုးသည် ခွေးတစ်ကောင် ပိုင်ဆိုင်သည်။
problem.addConstraint(lambda span, dog: span == dog, ("Spaniard", "Dog"))
# ၃။ အစိမ်းရောင်အိမ်ရှိ လူသည် ကော်ဖီ သောက်သည်။
problem.addConstraint(lambda green, coffee: green == coffee, ("Green", "Coffee"))
# ၄။ အိုင်းရစ်လူမျိုးသည် လက်ဖက်ရည် သောက်သည်။
problem.addConstraint(lambda irish, tea: irish == tea, ("Irish", "Tea"))
# ၅။ အစိမ်းရောင်အိမ်သည် ဆင်စွယ်ရောင်အိမ်၏ ညာဘက်တွင် တည်ရှိသည်။ (Green = Ivory + 1)
problem.addConstraint(lambda green, ivory: green == ivory + 1, ("Green", "Ivory"))
# ၆။ ဂိုး-GO ကစားသမားသည် ခရုများ ပိုင်ဆိုင်သည်။
problem.addConstraint(lambda go, snails: go == snails, ("Go", "Snails"))
# ၇။ အဝါရောင်အိမ်ရှိ လူသည် ကရစ်ကက် ကစားသည်။
problem.addConstraint(lambda yellow, cricket: yellow == cricket, ("Yellow", "Cricket"))
# ၈။ အလယ်အိမ် (တတိယအိမ်) တွင် နေထိုင်သူသည် နွားနို့ သောက်သည်။
problem.addConstraint(lambda milk: milk == 3, ("Milk",))
# ၉။ နိုင်ဂျီးရီးယားလူမျိုးသည် ပထမအိမ် (အိမ်နံပါတ် ၁) တွင် နေထိုင်သည်။
problem.addConstraint(lambda nigerian: nigerian == 1, ("Nigerian",))
# ၁၀။ ဂျူဒိုကစားသမားသည် မြေခွေးပိုင်ဆိုင်သူ၏ အိမ်ဘေးကပ်လျက် နေထိုင်သည်။ (Next to means abs(a-b) == 1)
problem.addConstraint(lambda judo, fox: abs(judo - fox) == 1, ("Judo", "Fox"))
# ၁၁။ ကရစ်ကတ်ကစားသမားသည် မြင်းပိုင်ဆိုင်သူ၏ အိမ်ဘေးကပ်လျက်တွင် နေထိုင်သည်။
problem.addConstraint(lambda cricket, horse: abs(cricket - horse) == 1, ("Cricket", "Horse"))
# ၁၂။ ပိုကာကစားသမားသည် လိမ္မော်ရည် သောက်သည်။
problem.addConstraint(lambda poker, oj: poker == oj, ("Poker", "Orange Juice"))
# ၁၃။ ဂျပန်လူမျိုးသည် ပိုလို ကစားသည်။
problem.addConstraint(lambda japanese, polo: japanese == polo, ("Japanese", "Polo"))
# ၁၄။ နိုင်ဂျီးရီးယားလူမျိုးသည် အပြာရောင်အိမ်၏ အိမ်ဘေးကပ်လျက်တွင် နေထိုင်သည်။
problem.addConstraint(lambda nigerian, blue: abs(nigerian - blue) == 1, ("Nigerian", "Blue"))
# ၄။ အဖြေရှာခြင်း (Get Solution)
solutions = problem.getSolutions()
# ၅။ ရလာသော အဖြေကို ရှင်းလင်းစွာ ဖော်ပြခြင်း
if not solutions:
print("No solution found!")
else:
# အဖြေတစ်ခုတည်းသာ ထွက်လေ့ရှိသည်
sol = solutions[0]
print(f"{'House':<10} {'Color':<10} {'Nation':<12} {'Drink':<15} {'Sport':<12} {'Pet':<10}")
print("-" * 70)
# အိမ်နံပါတ် ၁ မှ ၅ အထိ Loop ပတ်ပြီး စီခြင်း
for i in range(1, 6):
# လက်ရှိအိမ်နံပါတ် i နှင့် ကိုက်ညီသော variable များကို ရှာခြင်း
c = [k for k, v in sol.items() if v == i and k in colors][0]
n = [k for k, v in sol.items() if v == i and k in nationalities][0]
d = [k for k, v in sol.items() if v == i and k in drinks][0]
s = [k for k, v in sol.items() if v == i and k in sports][0]
p = [k for k, v in sol.items() if v == i and k in pets][0]
print(f"{i:<10} {c:<10} {n:<12} {d:<15} {s:<12} {p:<10}")
print("\n--- Final Answer ---")
# Zebra နှင့် Water ရှာခြင်း
zebra_owner = [k for k, v in sol.items() if k in nationalities and sol[k] == sol["Zebra"]][0]
water_drinker = [k for k, v in sol.items() if k in nationalities and sol[k] == sol["Water"]][0] # Water is implied as the remaining drink
print(f"Zebra lives in the house of the: {zebra_owner}")
print(f"The person who drinks Water is the: {water_drinker}")
if __name__ == "__main__":
solve_zebra_puzzle()
Sunday, January 25, 2026
Building A Justice Agent Part-05
ဒီအမှားဖြစ်ရတဲ့ အဓိကအကြောင်းရင်းကတော့ - AI ကိုပေးထားတဲ့ "သေဆုံးခြင်းဆိုင်ရာ စကားလုံးများ" (Keywords) စာရင်းထဲမှာ "death" (နမ်) ကျန်နေခဲ့ပြီး "dead" (နာမဝိသေသန) နဲ့ "died" (ကြိယာ) ပဲ ပါနေလို့ ဖြစ်ပါတယ်။
ကွန်ပျူတာက "dead" နဲ့ "death" ကို တူညီတယ်လို့ မသိပါဘူး။ စာလုံးပေါင်းမတူရင် မတူဘူးလို့ပဲ ယူဆပါတယ်။ မိတ်ဆွေပေးလိုက်တဲ့ စာသားမှာ "stabbed to death" လို့ပါပေမယ့်၊ AI ရဲ့ စာရင်းထဲမှာ "death" မပါတော့ "သေဆုံးခြင်းမရှိ" (No death occurred) လို့ မှားယွင်းဆုံးဖြတ်လိုက်တာ ဖြစ်ပါတယ်။
ဒါကြောင့် Keywords စာရင်းထဲမှာ "death" ကို ထပ်ဖြည့်ပြီး၊ Logic မှန်ကန်သွားအောင် ပြင်ဆင်ထားတဲ့ ကုဒ်အပြည့်အစုံက အောက်ပါအတိုင်း ဖြစ်နိုင်ပါတယ်။
Corrected Python Code
import re
class AdvancedLegalAI:
def __init__(self):
print("--- AI Legal Inference System Initialized ---")
print("System loaded with: Penal Code Section 300 & Private Defense Logic")
# အဆင့် (၁) - NLU (စာသားမှ အချက်အလက် ထုတ်နုတ်ခြင်း)
def extract_facts(self, text):
text = text.lower()
facts = {
"death_occurred": False, # လူသေမှု
"intent_to_kill": False, # သေစေလိုသောစိတ်
"intent_injury": False, # ဒဏ်ရာရစေလိုသောစိတ်
"sufficient_injury": False, # သေစေလောက်သော ဒဏ်ရာ
# For Provocation (Section 300 Exception 1)
"is_provoked": False,
"sudden_and_grave": False,
"loss_of_control": False,
# For Self-Defense (Section 96)
"under_imminent_threat": False, # ဘေးအန္တရာယ် ကျရောက်နေခြင်း
"act_was_defensive": False # ကာကွယ်ရန် ပြုလုပ်ခြင်း
}
# --- FIX APPLIED HERE (ပြင်ဆင်ချက်) ---
# "death" ကို keywords စာရင်းထဲ ထည့်လိုက်ပါသည်
death_keywords = ["died", "dead", "killed", "fatal", "death"]
# Regular Expression သုံးပြီး ရှာဖွေခြင်း (ပိုမိုတိကျစေရန်)
# \b သည် စကားလုံး၏ အစနှင့်အဆုံး (Word Boundary) ကို ဆိုလိုသည်
for word in death_keywords:
if re.search(r"\b" + re.escape(word) + r"\b", text):
facts["death_occurred"] = True
break
# Keywords for Intent (Mens Rea)
if any(w in text for w in ["intentionally", "purpose", "plan", "murdered"]):
facts["intent_to_kill"] = True
# "stabbed" ပါရင် ဒဏ်ရာရစေလိုမှုရော၊ သေစေလောက်တဲ့ဒဏ်ရာပါ True ပေးလိုက်မည်
if any(w in text for w in ["stabbed", "shot", "hit", "cut"]):
facts["intent_injury"] = True
facts["sufficient_injury"] = True
# Keywords for Provocation
if "provoked" in text or "insulted" in text:
facts["is_provoked"] = True
if "sudden" in text and "grave" in text:
facts["sudden_and_grave"] = True
if "lost control" in text or "anger" in text:
facts["loss_of_control"] = True
# Keywords for Self-Defense
if any(w in text for w in ["attacked", "danger", "threatened", "gunpoint"]):
facts["under_imminent_threat"] = True
if any(w in text for w in ["defend", "protect", "saved himself"]):
facts["act_was_defensive"] = True
return facts
# အဆင့် (၂) - Inference Engine (ဥပဒေ ယုတ္တိဗေဒ အဆုံးအဖြတ်)
def determine_verdict(self, facts):
# LOGIC LEVEL 1: Actus Reus (အပြုအမူ)
if not facts["death_occurred"]:
return "CASE DISMISSED: No death occurred. (လူသေဆုံးခြင်း မရှိပါ)"
# LOGIC LEVEL 2: General Exceptions (Self-Defense)
is_self_defense = facts["under_imminent_threat"] and facts["act_was_defensive"]
if is_self_defense:
return "NOT GUILTY: Act done in Private Defense (Section 96). (ကာကွယ်ခုခံပိုင်ခွင့်အရ အပြစ်မရှိပါ)"
# LOGIC LEVEL 3: Establish Murder Prima Facie (Mens Rea)
has_intent = facts["intent_to_kill"] or (facts["intent_injury"] and facts["sufficient_injury"])
if not has_intent:
return "NOT MURDER: Accidental or Negligent. (ရည်ရွယ်ချက် မရှိသဖြင့် လူသတ်မှု မမြောက်ပါ)"
# LOGIC LEVEL 4: Special Exceptions (Provocation)
valid_provocation = (facts["is_provoked"] and
facts["sudden_and_grave"] and
facts["loss_of_control"])
if valid_provocation:
return "REDUCED CHARGE: Culpable Homicide not amounting to Murder. (Provocation ကြောင့် လျော့ပေါ့)"
# LOGIC LEVEL 5: Default Verdict
return "GUILTY: Murder under Section 300. (လူသတ်မှု ထင်ရှားသည်)"
# Main Processing Function
def process_case(self, scenario_text):
print(f"\n[Input Scenario]: \"{scenario_text}\"")
# 1. Understand Facts
facts = self.extract_facts(scenario_text)
# 2. Print AI's Understanding (Debug View)
print(f"[AI Reasoning] Death Detected? -> {facts['death_occurred']}")
print(f"[AI Reasoning] Provocation Detected? -> {facts['is_provoked'] and facts['sudden_and_grave'] and facts['loss_of_control']}")
# 3. Final Judgment
verdict = self.determine_verdict(facts)
print(f"[FINAL VERDICT]: {verdict}")
print("-" * 60)
# --- စမ်းသပ်ခြင်း ---
ai = AdvancedLegalAI()
# Scenario: Provocation (ယခင်က အမှားပြခဲ့သော စာသား)
scenario = "The victim provoked John with sudden and grave insults. John lost control of his anger and stabbed the victim to death."
ai.process_case(scenario)
ဘာတွေ ပြင်လိုက်သလဲ?
Keyword ထပ်ဖြည့်ခြင်း:
death_keywordsစာရင်းထဲမှာ "death" ကို ထည့်လိုက်ပါတယ်။ ဒါကြောင့် "stabbed to death" ဆိုတဲ့ စာသားကို AI က ဖတ်မိပြီးdeath_occurred = Trueလို့ မှန်ကန်စွာ သတ်မှတ်ပေးနိုင်ပါပြီ။re(Regular Expression) အသုံးပြုခြင်း: ယခင်incommand အစားre.searchကို ပြောင်းသုံးထားပါတယ်။ ဒါက ပိုတိကျသလို၊import reကိုလည်း လက်တွေ့ အကျိုးရှိရှိ သုံးပြထားခြင်း ဖြစ်ပါတယ်။
ဒီကုဒ်ကို Run လိုက်ရင် အဖြေမှန်ဖြစ်တဲ့ "REDUCED CHARGE: Culpable Homicide not amounting to Murder" ကို ရရှိမှာ ဖြစ်ပါတယ်။
နောက်ဆက်တွဲ။
import re ဆိုတာ ဘာလဲ? re က ဘာကို ရည်ညွှန်းတာလဲ?
reဆိုသည်မှာ Regular Expression (အတိုကောက် RegEx) ကို ဆိုလိုခြင်း ဖြစ်ပါသည်။Regular Expression ဆိုသည်မှာ စာသားများ (Strings) အတွင်းတွင် မိမိလိုချင်သော ပုံစံ (Pattern) များကို ရှာဖွေရာတွင် အလွန်စွမ်းအားကြီးမားသော နည်းပညာတစ်ခု ဖြစ်ပါသည်။
ဥပမာ ရှင်းပြချက် -
သာမန် Python ကုဒ် (if "kill" in text) သည် "kill" ဆိုသည့် စာလုံးပါရင် အမှန်ပြပါလိမ့်မည်။ သို့သော် ပြဿနာမှာ "skilled" (ကျွမ်းကျင်သော) ဆိုသည့် စကားလုံးထဲတွင်လည်း "kill" ပါနေသဖြင့် AI က လူသတ်မှုဟု မှားယွင်း ကောက်ချက်ချသွားနိုင်ပါသည်။
re (Regular Expression) ကို သုံးလိုက်လျှင် -
re ကိုသုံးပြီး "kill" ဆိုသည့် စကားလုံး အတိအကျ (Whole Word) ကိုသာ ရှာပါ၊ ရှေ့နောက်တွင် အခြားစာလုံးများ မတွဲရ ဟု ခိုင်းနိုင်ပါသည်။ ၎င်းသည် ဥပဒေရေးရာ စကားလုံးများ ရှာဖွေရာတွင် အလွန်အရေးကြီးပါသည်။
**********************
Regular Expression (Regex) သည် စကားလုံးအတိအကျ (Word Boundary) ကို စစ်ဆေးပေးနိုင်သောကြောင့်၊ သာမန် if "word" in text နည်းလမ်းဖြင့် ရှာလျှင် အဓိပ္ပာယ်လွဲသွားနိုင်သည့် "လှည့်ကွက်" (Tricky) ဖြစ်စေမည့် Scenario (၃) ခုကို ရွေးထုတ်ပေးလိုက်ပါသည်။
ဒီ Scenario တွေကို လက်ရှိရေးထားတဲ့ ကုဒ်နဲ့ စမ်းသပ်ကြည့်ပါ။
Scenario 1: "The Dieting Soldier" (သေဆုံးမှု မှားယွင်းစစ်ဆေးခြင်း)
Input Text:
"The soldier is on a strict diet."သာမန် ရှာဖွေမှု (Simple Search) အမှား:
ကွန်ပျူတာက ဒီစာကြောင်းထဲမှာ "die" ဆိုတဲ့ စာလုံးပါမပါ ရှာပါလိမ့်မယ်။
Soldier (စစ်သား) ထဲမှာ "die" ပါနေပါတယ်။
Diet (အစားရှောင်ခြင်း) ထဲမှာလည်း "die" ပါနေပါတယ်။
ရလဒ်: "Death Occurred = True" (လူသေသွားတယ်) လို့ အဖြေမှား ထွက်လာပါလိမ့်မယ်။
Regex ရလဒ်:
\bdie\b(die သီးသန့်) ကို ရှာတဲ့အတွက် soldier နဲ့ diet ကို ကျော်သွားပြီး "False" (လူမသေပါ) လို့ အဖြေမှန် ထုတ်ပေးပါလိမ့်မယ်။
Scenario 2: "The Skilled Carpenter" (လူသတ်လိုစိတ် မှားယွင်းစစ်ဆေးခြင်း)
Input Text:
"John is a skilled carpenter."သာမန် ရှာဖွေမှု (Simple Search) အမှား:
ကွန်ပျူတာက "kill" (သတ်သည်) ဆိုတဲ့ စာလုံးကို ရှာပါမယ်။
Skilled (ကျွမ်းကျင်သော) ဆိုတဲ့ စကားလုံးထဲမှာ "kill" ပါနေပါတယ်။
ရလဒ်: "Intent to Kill = True" (သေစေလိုသော ရည်ရွယ်ချက်ရှိသည်) ဆိုပြီး လူသတ်သမားအဖြစ် မှားယွင်းသတ်မှတ်ပါလိမ့်မယ်။
Regex ရလဒ်:
\bkill\bကို ရှာတဲ့အတွက် skilled ကို ကျော်သွားပြီး "False" လို့ အဖြေမှန် ထွက်ပါမယ်။
Scenario 3: "The Stable Condition" (လက်နက်သုံးမှု မှားယွင်းစစ်ဆေးခြင်း)
Input Text:
"The patient is in a stable condition."သာမန် ရှာဖွေမှု (Simple Search) အမှား:
ကွန်ပျူတာက "stab" (ဓားဖြင့်ထိုးသည်) ဆိုတဲ့ စာလုံးကို ရှာပါမယ်။
Stable (တည်ငြိမ်သော) ဆိုတဲ့ စကားလုံးထဲမှာ "stab" ပါနေပါတယ်။
ရလဒ်: "Intent to Injury = True" (ဓားဖြင့်ထိုးရန် ရည်ရွယ်ချက်ရှိသည်) လို့ အဖြေမှား ထွက်ပါမယ်။
Regex ရလဒ်:
\bstab\bကို ရှာတဲ့အတွက် stable ကို ကျော်သွားပြီး "False" လို့ အဖြေမှန် ထွက်ပါမယ်။
စမ်းသပ်ရန် Python Code
အထက်ပါ Scenario ၃ ခုကို မိတ်ဆွေရဲ့ AI ပရိုဂရမ်မှာ ထည့်သွင်းစမ်းသပ်နိုင်ဖို့ ကုဒ်တိုလေး ရေးပေးလိုက်ပါတယ်။ (AdvancedLegalAI Class ရှိပြီးသားဖြစ်ရပါမယ်။)
# AI Agent ကို ခေါ်လိုက်ပါ
ai_test = AdvancedLegalAI()
# လှည့်ကွက်ပါသော Scenario များ
tricky_scenarios = [
"The soldier is on a strict diet.", # "die" in soldier/diet
"John is a skilled carpenter.", # "kill" in skilled
"The patient is in a stable condition." # "stab" in stable
]
print("\n--- TRICKY SCENARIO TESTS (Regex vs Simple Check) ---")
for text in tricky_scenarios:
print(f"\nTesting: '{text}'")
facts = ai_test.extract_facts(text)
# ရလဒ်များကို စစ်ဆေးခြင်း
if facts['death_occurred']:
print(">> ERROR: Wrongly detected 'DEATH'.")
elif facts['intent_to_kill']:
print(">> ERROR: Wrongly detected 'INTENT TO KILL'.")
elif facts['intent_injury']:
print(">> ERROR: Wrongly detected 'STABBING/INJURY'.")
else:
print(">> SUCCESS: AI correctly ignored tricky words. (မှန်ကန်ပါတယ်)")
ဒီ Scenario လေးတွေက import re နဲ့ \b (Word Boundary) အသုံးပြုခြင်းရဲ့ အရေးပါပုံကို ကောင်းကောင်း မီးမောင်းထိုးပြနိုင်ပါလိမ့်မယ်။
*****************************
အထက်မှာ ရှင်းပြခဲ့တဲ့ tricky_scenarios (လှည့်ကွက်ပါတဲ့ ဖြစ်စဉ်များ) ကို process_case function သုံးပြီး လက်တွေ့ စမ်းသပ်မယ့် ကုဒ်ကို ရေးပေးလိုက်ပါတယ်။
ဒီကုဒ်ကို အရင်ရေးထားတဲ့ AdvancedLegalAI Class ရဲ့ အောက်ဆုံးမှာ ကူးထည့်ပြီး Run လိုက်ရုံပါပဲ။
Tricky Scenarios Test Code
# AI Agent ကို ခေါ်ယူခြင်း
ai_judge = AdvancedLegalAI()
print("\n==================================================")
print(" TRICKY SCENARIOS TEST (Regular Expression) ")
print("==================================================\n")
# လှည့်ကွက်ပါသော ဖြစ်စဉ်များ
tricky_scenarios = [
# 1. "die" အသံထွက်ပါသော်လည်း လူသေမှုမဟုတ်သည့် ကိစ္စ (Soldier / Diet)
"The soldier is on a strict diet.",
# 2. "kill" ပါသော်လည်း လူသတ်မှုမဟုတ်သည့် ကိစ္စ (Skilled)
"John is a skilled carpenter.",
# 3. "stab" ပါသော်လည်း ဓားထိုးမှုမဟုတ်သည့် ကိစ္စ (Stable)
"The patient is in a stable condition."
]
# ဖြစ်စဉ်တစ်ခုချင်းစီကို process_case ဖြင့် စစ်ဆေးခြင်း
for i, scenario in enumerate(tricky_scenarios, 1):
print(f"--- Test Case {i} ---")
ai_judge.process_case(scenario)
မျှော်မှန်းရမည့် ရလဒ် (Expected Output)
အကယ်၍ re (Regular Expression) ကုဒ် အလုပ်လုပ်တယ်ဆိုရင်၊ အောက်ပါအတိုင်း "CASE DISMISSED" ဆိုတဲ့ အဖြေမှန်တွေ ထွက်လာပါလိမ့်မယ်။ (ဆိုလိုတာက AI က Diet ကို Died လို့မမြင်တော့ပါ၊ Skilled ကို Killed လို့ မမြင်တော့ပါ)။
==================================================
TRICKY SCENARIOS TEST (Regular Expression)
==================================================
--- Test Case 1 ---
[Input Scenario]: "The soldier is on a strict diet."
[AI Reasoning] Death Detected? -> False
[AI Reasoning] Provocation Detected? -> False
[FINAL VERDICT]: CASE DISMISSED: No death occurred. (လူသေဆုံးခြင်း မရှိပါ)
------------------------------------------------------------
--- Test Case 2 ---
[Input Scenario]: "John is a skilled carpenter."
[AI Reasoning] Death Detected? -> False
[AI Reasoning] Provocation Detected? -> False
[FINAL VERDICT]: CASE DISMISSED: No death occurred. (လူသေဆုံးခြင်း မရှိပါ)
------------------------------------------------------------
--- Test Case 3 ---
[Input Scenario]: "The patient is in a stable condition."
[AI Reasoning] Death Detected? -> False
[AI Reasoning] Provocation Detected? -> False
[FINAL VERDICT]: CASE DISMISSED: No death occurred. (လူသေဆုံးခြင်း မရှိပါ)
------------------------------------------------------------
သုံးသပ်ချက် - တွေ့ရတဲ့အတိုင်း AI ဟာ...
Soldier/Diet ထဲမှာ 'die' ပါပေမယ့် လူမသေဘူး (Death Detected -> False) လို့ သိပါတယ်။
Skilled ထဲမှာ 'kill' ပါပေမယ့် လူသတ်ဖို့ရည်ရွယ်ချက် (Intent) မရှိဘူး၊ လူမသေဘူးလို့ သိပါတယ်။
Stable ထဲမှာ 'stab' ပါပေမယ့် ဓားနဲ့မထိုးဘူးလို့ သိပါတယ်။
ဒါဟာ Regular Expression ရဲ့ \b (Word Boundary) စွမ်းဆောင်ရည်ကြောင့် ဖြစ်ပါတယ်။



