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 စနစ်တစ်ခု အလုပ်လုပ်ရန်အတွက် အဓိက အစိတ်အပိုင်း (၃) ခု လိုအပ်ပါတယ်။

1. နောက်ခံဗဟုသုတ (Background Knowledge - BK) ကျွန်ုပ်တို့ ကြိုတင်သိရှိထားပြီးသား အချက်အလက်များ။
2. အပြုသဘောဆောင်သော နမူနာများ (Positive Examples – E⁺ ) မှန်ကန်ကြောင်း ကျွန်ုပ်တို့ သိရှိသော အချက်များ။
3. အနုတ်လက္ခဏာဆောင်သော နမူနာများ (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)")

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

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

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

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