Types of Learning (သင်ယူမှု အမျိုးအစားများ)
A4.3.2: Explain how classification techniques in supervised learning are used to predict discrete categorical outcomes (k-NN, decision trees). A4.3.4: Describe how clustering techniques in unsupervised learning are used to group data based on similarities in features. A4.3.5: Describe how learning techniques using the association rule are used to uncover relations between different attributes in large data sets. A4.3.6: Describe how an agent learns to make decisions by interacting with its environment in reinforcement learning. A4.3.7: Describe the application of genetic algorithms in various real-world situations. HL only; builds on A4.1.1 (the types of machine learning).
မြန်မာလို: A4.3.2: supervised learning (label တပ်ထားတဲ့ ဥပမာတွေကနေ သင်ယူခြင်း) မှာ classification (ဘယ်အမျိုးအစားထဲ ဝင်လဲ ခွဲခြား ခန့်မှန်းခြင်း) နည်းတွေ ဖြစ်တဲ့ k-NN (အနီးဆုံး k ခုနဲ့ ဆုံးဖြတ်ခြင်း) နဲ့ decision tree (ဟုတ်/မဟုတ် မေးခွန်းတွေနဲ့ ခန့်မှန်းတဲ့ သစ်ပင်ပုံ) ကို သတ်မှတ်ထားတဲ့ အမျိုးအစားတွေထဲက တစ်ခု ဖြစ်တဲ့ ရလဒ် (discrete categorical outcome) ကို ခန့်မှန်းဖို့ ဘယ်လို သုံးလဲ ရှင်းပြနိုင်ရပါမယ်။ A4.3.4: unsupervised learning (label မပါတဲ့ ဒေတာကနေ သင်ယူခြင်း) မှာ clustering (ဆင်တူတာတွေကို အုပ်စုဖွဲ့ခြင်း) နည်းတွေကို feature (item တစ်ခုကို ဖော်ပြတဲ့ input တန်ဖိုး) တွေ ဆင်တူမှုအပေါ် မူတည်ပြီး ဒေတာကို အုပ်စုဖွဲ့ဖို့ ဘယ်လို သုံးလဲ ဖော်ပြရှင်းပြနိုင်ရပါမယ်။ A4.3.5: association rule (X ဝယ်ရင် Y ပါ ဝယ်တတ်တယ်ဆိုတဲ့ ပုံစံ) ကို သုံးတဲ့ learning နည်းတွေကို ဒေတာ အစုအဝေး ကြီးကြီးတွေထဲက မတူတဲ့ attribute (record ထဲက ဒေတာ အကွက်) တွေကြား ဆက်နွယ်မှုတွေကို ရှာဖော်ဖို့ ဘယ်လို သုံးလဲ ဖော်ပြရှင်းပြနိုင်ရပါမယ်။ A4.3.6: reinforcement learning (ဆုနဲ့ ဒဏ်ကနေ သင်ယူခြင်း) မှာ agent (ဆုံးဖြတ်ချက် ချတဲ့ program) က သူ့ environment (agent နဲ့ ထိတွေ့ဆက်ဆံရတဲ့ ပတ်ဝန်းကျင်) နဲ့ ထိတွေ့ဆက်ဆံရင်း ဆုံးဖြတ်ချက် ချတတ်အောင် ဘယ်လို သင်ယူလဲ ဖော်ပြရှင်းပြနိုင်ရပါမယ်။ A4.3.7: genetic algorithm (ဆင့်ကဲဖြစ်စဉ်ကို အတုယူတဲ့ ရှာဖွေနည်း) တွေကို လက်တွေ့ ဘဝ အခြေအနေ အမျိုးမျိုးမှာ အသုံးချပုံကို ဖော်ပြရှင်းပြနိုင်ရပါမယ်။ ဒါတွေက HL အတွက်ပဲ ဖြစ်ပြီး A4.1.1 (machine learning (ဒေတာကနေ သင်ယူတဲ့ စနစ်) အမျိုးအစားများ) ကို အခြေခံပါတယ်။ A4.3.2 လို နံပါတ်တွေက IB Computer Science သင်ရိုးထဲက ခေါင်းစဉ် နံပါတ်တွေပါ။
ဒီစာမျက်နှာက HL အတွက်ပဲ ဖြစ်ပါတယ်။ SL (Standard Level) နဲ့ HL (Higher Level) ဆိုတာ IB Computer Science (နိုင်ငံတကာ ကျောင်းတွေမှာ သင်တဲ့ ကွန်ပျူတာသိပ္ပံ သင်ရိုး) သင်တန်းရဲ့ အဆင့်နှစ်ဆင့်ဖြစ်ပြီး HL အပိုင်းတွေက ပိုနက်နက်ရှိုင်းရှိုင်း လေ့လာရတဲ့ အပိုင်းတွေပါ။ ဒီစာမျက်နှာက learning အမျိုးအစား တစ်ခုချင်းစီ ဘယ်လို အလုပ်လုပ်လဲ ဆိုတာကို ပိုနက်နက် လေ့လာပါတယ်။ SL ရော HL ရော နှစ်ဆင့်လုံး လေ့လာရတဲ့ အဓိက အပိုင်းဖြစ်တဲ့ learning အမျိုးအစားတွေရဲ့ ခြုံငုံ မိတ်ဆက်ကတော့ What Machine Learning Is (machine learning ဆိုတာ ဘာလဲ) စာမျက်နှာမှာ ရှိပါတယ်။
မာတိကာ
- ခြုံငုံ မိတ်ဆက်
- ပြန်နွှေးချက်: သင်ယူနည်း သုံးမျိုး
- Supervised Learning ကို အနီးကပ် ကြည့်ခြင်း
- Unsupervised Learning ကို အနီးကပ် ကြည့်ခြင်း
- Reinforcement Learning ကို အနီးကပ် ကြည့်ခြင်း
- Genetic Algorithms (ဆင့်ကဲဖြစ်စဉ်ကို အတုယူတဲ့ ရှာဖွေနည်းများ)
- Quick Check (အမြန် စစ်ဆေးမေးခွန်း)
- ဖော်ပြချက်နဲ့ Technique ကို တွဲပါ
- Practice Exercises (လေ့ကျင့်ခန်းများ)
- ဆက်စပ် ခေါင်းစဉ်များ
ခြုံငုံ မိတ်ဆက်
အရင် စာမျက်နှာ မှာ စနစ် တစ်ခု သင်ယူနိုင်တဲ့ နည်းလမ်း သုံးမျိုးကို မိတ်ဆက်ခဲ့ပါတယ်: supervised learning က label (ဥပမာ တစ်ခုစီမှာ တပ်ထားတဲ့ အဖြေမှန်) တပ်ထားတဲ့ ဥပမာတွေကနေ သင်ယူတာ၊ unsupervised learning က label မပါတဲ့ ဒေတာထဲမှာ ဖွဲ့စည်းပုံကို ရှာတာ၊ reinforcement learning က reward (ဆု) တွေ ရရင်း စမ်းသပ်ပြီး အမှားကနေ သင်ယူတာ ဖြစ်ပါတယ်။ အဲဒီ စာမျက်နှာက အမျိုးအစား တစ်ခုချင်းစီ ဘာလဲ ဆိုတာကို ပြောခဲ့ပါတယ်။ ဒီစာမျက်နှာကတော့ တစ်ခုချင်းစီ ဘယ်လို အလုပ်လုပ်လဲ ဆိုတာကို ပြောပါမယ်: learning အမျိုးအစား တစ်ခုစီကို လုပ်ဆောင်ပေးတဲ့ algorithm (အယ်လ်ဂိုရီသမ်၊ ပြဿနာကို အဆင့်ဆင့် ဖြေရှင်းတဲ့ နည်းလမ်း) တွေ၊ သူတို့ ဘယ်နေရာမှာ အသုံးဝင်လဲ၊ သူတို့ရဲ့ ကန့်သတ်ချက်တွေ ဘာလဲ ဆိုတာတွေပါ။
ဒီ algorithm တွေကို code ရေးပြီး ကိုယ်တိုင် တည်ဆောက်ဖို့ မလိုပါဘူး (IB သင်ရိုးက သူတို့ကို code ရေးခိုင်းတာ မဟုတ်ဘဲ explain (ရှင်းပြ) နဲ့ describe (ဖော်ပြရှင်းပြ) လုပ်နိုင်ဖို့ တောင်းတာပါ)။ လိုတာက တစ်ခုချင်းစီ ဘယ်လို အလုပ်လုပ်လဲ ဆိုတာကို ရှင်းရှင်းလင်းလင်း မြင်ထားဖို့ပါ။ ဒါမှ ပြဿနာ တစ်ခုအတွက် ဘာကြောင့် သင့်တော်လဲ၊ ဘယ်နေရာမှာ မှားတတ်လဲ ပြောနိုင်မှာပါ။ အောက်က technique (နည်းလမ်း) လေးခုမှာ simulator (တကယ့် ဖြစ်စဉ်ကို ကွန်ပျူတာနဲ့ အတုလုပ်ပြတဲ့ tool) link တွေ ပါလို့ သူတို့ run နေတာကို ကြည့်လို့ရပါတယ်။
ကိုယ်တိုင် စမ်းကြည့်ပါ: machine learning simulator တွေ မှာ input တွေနဲ့ setting တွေကို ပြောင်းပြီး boundary (အမျိုးအစားတွေကြား နယ်နိမိတ်မျဉ်း) တစ်ခု ဖြစ်လာတာ၊ cluster (အုပ်စု) တွေ နေရာ တည်ငြိမ်သွားတာ ဒါမှမဟုတ် strategy (နည်းဗျူဟာ) တစ်ခု တိုးတက်လာတာကို ကြည့်ပြီး ရလဒ်တွေကို နှိုင်းယှဉ်လို့ရပါတယ်။
ပြန်နွှေးချက်: သင်ယူနည်း သုံးမျိုး
ဒီ technique တွေ ပါဝင်တဲ့ learning အမျိုးအစား သုံးမျိုးကို အမြန် ပြန်သတိရအောင် ဖော်ပြထားပါတယ်။
| Learning အမျိုးအစား | သုံးတဲ့ ဒေတာ | ထွက်လာတဲ့ ရလဒ် |
|---|---|---|
| Supervised | Label တပ်ထားတဲ့ ဥပမာတွေ (input နဲ့ အဖြေမှန်) | Input အသစ်တွေအတွက် အဖြေကို ခန့်မှန်းပေးတဲ့ model (ဒေတာကနေ သင်ယူပြီး ခန့်မှန်းပေးတဲ့ စနစ်) |
| Unsupervised | Label မပါတဲ့ ဒေတာ | ဒေတာထဲမှာ ရှာတွေ့တဲ့ ဖွဲ့စည်းပုံ (အုပ်စုတွေ၊ ဆက်နွယ်မှုတွေ) |
| Reinforcement | Action (လုပ်ဆောင်ချက်) တွေ လုပ်ရင်း ရတဲ့ reward နဲ့ penalty (ဒဏ်) တွေ | Cumulative reward (အချိန်တစ်လျှောက် ရတဲ့ reward စုစုပေါင်း) ကို အများဆုံး ရအောင် ရည်ရွယ်တဲ့ policy (action ရွေးတဲ့ စည်းမျဉ်း) |
Genetic algorithm တွေကတော့ နည်းနည်း ကွဲပြားပါတယ်။ သူတို့က ဆင့်ကဲဖြစ်စဉ် (evolution) ကို အားကျ အတုယူထားတဲ့ ရှာဖွေနည်း တစ်မျိုးဖြစ်ပြီး optimisation (အကောင်းဆုံး အဖြေကို ရှာခြင်း) အတွက် သုံးပါတယ်: ဖြစ်နိုင်တဲ့ အဖြေ အရမ်းများတဲ့ထဲကနေ သူတို့ ရှာနိုင်သမျှ အကောင်းဆုံး အဖြေကို ရှာတာပါ။ Generation (မျိုးဆက်) အများကြီး ဖြတ်သန်းရင်း ကောင်းတဲ့ ဖြေရှင်းချက်တွေကို သင်ယူ သွားလို့ machine learning နဲ့ အုပ်စုတူ ထည့်လေ့ ရှိပါတယ်။
Supervised Learning ကို အနီးကပ် ကြည့်ခြင်း
Supervised learning က label တပ်ထားတဲ့ ဥပမာတွေကနေ အဖြေ တစ်ခုကို ခန့်မှန်းပါတယ်။ အဖြေက “spam” (အလိုမရှိတဲ့ email) ဒါမှမဟုတ် “not spam” (spam မဟုတ်တဲ့ email) လိုမျိုး သတ်မှတ်ထားတဲ့ အစုထဲက အမျိုးအစား (category) တစ်ခု ဖြစ်တဲ့အခါ အဲဒီ အလုပ်ကို classification လို့ ခေါ်ပါတယ်: item (အချက်) တစ်ခုက ဘယ်အမျိုးအစားထဲ ဝင်လဲ ဆိုတာကို model က ခန့်မှန်းတာပါ။ လက်ရေးကို ဖတ်ပြီး မှတ်မိတဲ့ စနစ်မှာ ဂဏန်း 0 ကနေ 9 အထိလိုမျိုး အမျိုးအစားကို ဂဏန်းနဲ့ ရေးလို့လည်း ရပါတယ်။ စျေးနှုန်းလို ပမာဏ တစ်ခုကို ခန့်မှန်းတာကတော့ regression (ပမာဏကို ဂဏန်းနဲ့ ခန့်မှန်းခြင်း) ဖြစ်ပါတယ် (training စာမျက်နှာမှာ ပါပါတယ်)။ လိုက်ကြည့်ရ လွယ်တဲ့ classification algorithm နှစ်ခုကတော့ k-nearest neighbours နဲ့ decision tree တွေပါ။ နှစ်ခုလုံးက ရှိပြီးသား label တပ်ထားတဲ့ ဒေတာကနေ သင်ယူပြီး သင်ယူထားတာကို သုံးကာ data point (ဒေတာ အမှတ်) အသစ်တွေကို အမျိုးအစား တစ်ခုထဲ ထည့်ပါတယ်။ ဒါပေမယ့် အောက်က အပိုင်း နှစ်ပိုင်းမှာ မြင်ရမယ့်အတိုင်း သူတို့က အလုပ်ကို မတူတဲ့ အချိန်တွေမှာ လုပ်ကြပါတယ်။
k-Nearest Neighbours (k-NN၊ အနီးဆုံး k ခုနဲ့ ဆုံးဖြတ်ခြင်း)
Item အသစ် တစ်ခုကို classify လုပ်ဖို့ k-NN က label တပ်ပြီးသား item တွေထဲက အနီးဆုံး k ခု (သူ့ရဲ့ “neighbour” (အိမ်နီးချင်း) တွေ) ကို ရှာပါတယ်။ k က 3 လို ကိန်းပြည့် အငယ်လေး တစ်ခုပါ။ ပြီးရင် အဲဒီ item တွေရဲ့ label တွေနဲ့ majority vote (အများစု မဲ) ယူပါတယ်။ တစ်နည်းပြောရရင် item အသစ်က သူနဲ့ အဆင်တူဆုံး item တွေကြားမှာ အများဆုံး တွေ့ရတဲ့ label ကို ရပါတယ်။
အနီးဆုံး neighbour တွေက မဲပေးပါတယ်။ k = 3 မှာ အစက်ချ စက်ဝိုင်းထဲမှာ class (အမျိုးအစား) B စတုရန်း နှစ်ခုနဲ့ class A စက်ဝိုင်း တစ်ခု ပါလို့ အမှတ်အသစ်ကို B မဲ 2 မဲ၊ A မဲ 1 မဲ နဲ့ B လို့ classify လုပ်ပါတယ်။
ပုံထဲက feature 1 နဲ့ feature 2 က item တွေကို ဖော်ပြတဲ့ feature နှစ်ခု (ဝင်ရိုး နှစ်ခု)၊ class A နဲ့ class B က label နှစ်မျိုး၊ new point, k = 3 က k = 3 နဲ့ classify လုပ်မယ့် အမှတ်အသစ် လို့ ဆိုလိုပါတယ်။ အောက်ခြေက စာကြောင်းက “အစက်ချ စက်ဝိုင်းထဲမှာ အနီးဆုံး neighbour 3 ခု ရှိတယ်။ နှစ်ခုက class B၊ တစ်ခုက class A ဖြစ်လို့ မဲက B အတွက် 2 နဲ့ 1 ဖြစ်တယ်” လို့ ဆိုလိုပါတယ်။
အလုပ်ကောင်းကောင်း လုပ်အောင် အသေးစိတ် အချက် တချို့ ရှိပါတယ်:
- k ကို ကိုယ်တိုင် ရွေးရပါတယ်။ k သေးရင် (1 လို) ဒေတာကို အရမ်း နီးနီးကပ်ကပ် လိုက်ပြီး noise (ပုံမှန် မဟုတ်တဲ့ ဒါမှမဟုတ် label မှားတပ်ထားတဲ့ ဥပမာတွေ) ကြောင့် အလွယ်တကူ မှားတတ်ပါတယ်။ k ကြီးရင် ထူးဆန်းတဲ့ ဥပမာ တစ်ခုကြောင့် သိပ် မပြောင်းလဲပေမယ့် class တွေကြားက တကယ့် နယ်နိမိတ်တွေကို ဝါးသွားစေနိုင်ပါတယ်။ k က hyperparameter (train မလုပ်ခင် ရွေးထားရတဲ့ setting) ပါ၊ model က သင်ယူတဲ့ setting မဟုတ်ဘဲ ကိုယ်တိုင် ရွေးရတဲ့ setting ပါ။
- Class နှစ်မျိုးပဲ ရှိရင် k ကို မကိန်း (odd number) ထားပါ၊ ဒါမှ မဲ သရေ မကျမှာပါ။
- Feature တွေရဲ့ scale (တန်ဖိုး အပိုင်းအခြား) တွေ နှိုင်းယှဉ်လို့ရအောင် ဖြစ်ရပါမယ်။ “အနီးဆုံး” ဆိုတာကို အကွာအဝေးနဲ့ တိုင်းလို့ feature တစ်ခုက 0 ကနေ 1 အထိ၊ နောက်တစ်ခုက 0 ကနေ 100000 အထိ ရှိရင် အရင် rescale (feature အားလုံးကို 0 ကနေ 1 လို အပိုင်းအခြား ဆင်တူ ဖြစ်အောင် ပြောင်းခြင်း) မလုပ်ထားရင် အကွာအဝေး အားလုံးနီးပါးကို ကြီးတဲ့ feature က ဆုံးဖြတ်သွားပါလိမ့်မယ်။
သင်ယူမှုက ဘယ်မှာလဲ။ k-NN က training (model ကို ဒေတာနဲ့ သင်ပေးတဲ့ အဆင့်) မှာ အလုပ် သိပ်မလုပ်ပါဘူး: label တပ်ထားတဲ့ ဥပမာတွေကို သိမ်းထားရုံပါပဲ။ သူ သုံးတဲ့ pattern (ပုံစံ) ဆိုတာလည်း label တစ်မျိုးချင်းစီ ပါတဲ့ ဥပမာတွေ ဘယ်နေရာမှာ ရှိလဲ ဆိုတာ သက်သက်ပါပဲ။ အလုပ်က item အသစ် ရောက်လာမှ ဖြစ်ပါတယ်: ဒီမှာ ဖော်ပြထားတဲ့ ရိုးရှင်းတဲ့ ပုံစံမှာ အနီးဆုံး neighbour တွေကို ရှာဖို့ item ကို သိမ်းထားတဲ့ ဥပမာ တိုင်းနဲ့ နှိုင်းယှဉ်ပါတယ်။ ဒါကြောင့် k-NN ကို တစ်ခါတလေ lazy learner (ပျင်းတဲ့ သင်ယူသူ၊ ခန့်မှန်းရမယ့် အချိန်ကျမှ အလုပ်လုပ်တဲ့ နည်း) လို့ ခေါ်ပြီး သိမ်းထားတဲ့ ဒေတာ များလာလေ သူ့ရဲ့ ခန့်မှန်းချက်တွေ နှေးလာလေ ဖြစ်ပါတယ်။ (စနစ် ကြီးကြီးတွေမှာတော့ နှိုင်းယှဉ်ရမယ့် အများစုကို ကျော်လို့ရအောင် ဥပမာတွေကို search structure (ရှာရလွယ်အောင် စီထားတဲ့ data structure) တစ်ခုထဲမှာ သိမ်းလေ့ ရှိပါတယ်။)
အသုံးချပုံ: collaborative filtering (စိတ်ကြိုက် ဆင်တူတဲ့ user တွေရဲ့ အမှတ်ပေးချက်ကနေ အကြံပြုခြင်း) ကို သုံးတဲ့ recommendation system (user ကြိုက်နိုင်တာတွေကို အကြံပြုပေးတဲ့ စနစ်) တွေ ဖြစ်ပါတယ်။ ဒီမှာ neighbour တွေက လူတွေပါ: စနစ်က အရင်က ပေးခဲ့တဲ့ rating (အမှတ်ပေးချက်) တွေ ကိုယ်နဲ့ အဆင်တူဆုံး user k ယောက်ကို ရှာပြီး သူတို့ အမှတ်မြင့်မြင့် ပေးခဲ့တဲ့၊ ကိုယ် မစမ်းရသေးတဲ့ item တွေကို အကြံပြုပါတယ်။ k-NN က စက်တစ်ခုက တိုင်းလိုက်တဲ့ တန်ဖိုး (reading) ကို label တပ်ထားတဲ့ အရင် တန်ဖိုးတွေနဲ့ နှိုင်းယှဉ်ပြီး ပုံမှန်လား ပုံမှန် မဟုတ်လား classify လုပ်နိုင်ပါသေးတယ်။
ကိုယ်တိုင် စမ်းကြည့်ပါ: k-NN simulator မှာ label တပ်ထားတဲ့ အမှတ်တွေကို ချထားပြီး အမှတ်အသစ် တစ်ခု ထည့်ကာ အဲဒါက သူ့ရဲ့ အနီးဆုံး neighbour k ခုနဲ့ ချိတ်ပြီး သူတို့ရဲ့ မဲကို ယူတာကို ကြည့်လို့ရပါတယ်။ k ကို တိုးလိုက် လျှော့လိုက် လုပ်ပြီး decision boundary (class တစ်ခုစီ ရတဲ့ ဧရိယာတွေကြားက မျဉ်း) ပြောင်းသွားတာကို ကြည့်ပါ။
Decision Trees (ဟုတ်/မဟုတ် မေးခွန်းတွေနဲ့ ခန့်မှန်းတဲ့ သစ်ပင်ပုံ)
Decision tree က item တစ်ခုရဲ့ feature တွေအကြောင်း မေးခွန်းတွေကို အစဉ်လိုက် မေးပြီး classify လုပ်ပါတယ်။ အဖြေ တစ်ခုစီက branch (အကိုင်း) တစ်ခုအတိုင်း အောက်ကို ဆင်းပြီး နောက်မေးခွန်းဆီ ရောက်စေပါတယ်။ ဒီလိုနဲ့ item က ဆုံးဖြတ်ချက်ကို ပေးတဲ့ leaf (tree ရဲ့ အဆုံးမှတ်) ကို ရောက်တဲ့အထိ ဆက်သွားပါတယ်။ Tree တော်တော်များများမှာ မေးခွန်း တစ်ခုစီမှာ အဖြေ နှစ်ခု ရှိပါတယ်: “ဝင်ငွေက X ထက် များသလား။ များရင် အသက်က Y ထက် ငယ်သလား။” စသဖြင့်ပါ။ Tree ကို သင်ယူတယ် ဆိုတာ label တပ်ထားတဲ့ ဒေတာကို အကောင်းဆုံး ခွဲပေးနိုင်မယ့် မေးခွန်းတွေနဲ့ သူတို့ရဲ့ အစဉ်ကို ရွေးတာပါ။ k-NN နဲ့ မတူတာက decision tree က အလုပ်ကို training မှာ လုပ်ပါတယ်: tree ကို တည်ဆောက်ပြီးသွားရင် item အသစ်ကို မေးခွန်းတွေနဲ့တင် classify လုပ်ပါတယ်။
Tree ကို ဘယ်လို သင်ယူလဲ။ ဖုန်းပြင်ဆိုင် တစ်ဆိုင်မှာ အရင်က ပြင်ခဲ့တဲ့ ဖုန်း 10 လုံးရဲ့ record (အချက်အလက် အများကြီး စုထားတဲ့ ဒေတာ တစ်ခု) တွေ ရှိပါတယ်။ Record တစ်ခုစီမှာ ပြင်ဆင်သူ (technician) တွေ့ခဲ့တဲ့ ချို့ယွင်းချက်ကို label အဖြစ် တပ်ထားပါတယ်: battery ဒါမှမဟုတ် charging port (အားသွင်းပေါက်) ပါ။
| ပြင်ဆင်မှု | အားကျန်သေးရဲ့သားနဲ့ ပိတ်သွားသလား။ | ကြိုးကို ထောင့်တစ်ခုနဲ့ ကိုင်ထားမှပဲ အားသွင်းလို့ရသလား။ | 3 နှစ်ထက် ကြာပြီလား။ | တွေ့ခဲ့တဲ့ ချို့ယွင်းချက် |
|---|---|---|---|---|
| 1 | Yes | No | Yes | Battery |
| 2 | Yes | No | No | Battery |
| 3 | Yes | No | Yes | Battery |
| 4 | Yes | No | No | Battery |
| 5 | No | No | Yes | Port |
| 6 | No | No | No | Port |
| 7 | No | Yes | Yes | Port |
| 8 | No | Yes | No | Port |
| 9 | Yes | Yes | Yes | Port |
| 10 | No | Yes | No | Port |
ဇယားထဲက Yes က ဟုတ်၊ No က မဟုတ်၊ Battery က battery ချို့ယွင်းတာ၊ Port က charging port ချို့ယွင်းတာ လို့ ဆိုလိုပါတယ်။
ပထမ မေးခွန်းကို ရွေးဖို့ algorithm က မေးခွန်း တစ်ခုချင်းကို စမ်းပြီး ချို့ယွင်းချက် နှစ်မျိုးကို ဘယ်လောက် ကောင်းကောင်း ခွဲပေးနိုင်လဲ စစ်ပါတယ်။ “အားကျန်သေးရဲ့သားနဲ့ ပိတ်သွားသလား။” မေးခွန်းက ပြင်ဆင်မှုတွေကို 5 ခုပါတဲ့ Yes အုပ်စု (battery 4 ခု၊ port 1 ခု) နဲ့ 5 ခုပါတဲ့ No အုပ်စု (အားလုံး port) ဆိုပြီး ခွဲပါတယ်။ အုပ်စု တစ်ခုထဲက ပြင်ဆင်မှု တိုင်းကို အဲဒီ အုပ်စုမှာ အများဆုံး ဖြစ်တဲ့ ချို့ယွင်းချက်လို့ သတ်မှတ်လိုက်ရင် 10 ခုမှာ 1 ခုပဲ မှားပါတယ်။ ကြိုး မေးခွန်းက 2 ခု မှားပါတယ်။ အသက် မေးခွန်းကတော့ 4 ခု မှားပါတယ်၊ ဘာလို့လဲဆိုတော့ သူ့ အုပ်စု နှစ်ခုလုံးမှာ ချို့ယွင်းချက် နှစ်မျိုး ရောနေလို့ပါ။ ဒါကြောင့် tree က ပိတ်သွားတာအကြောင်းကို အရင်ဆုံး မေးပါတယ်။ No branch မှာ port ချို့ယွင်းချက်တွေပဲ ရှိလို့ leaf တစ်ခုနဲ့ အဆုံးသတ်ပါတယ်။ Yes branch မှာတော့ ရောနေသေးလို့ algorithm က အဲဒီ ပြင်ဆင်မှု 5 ခုပေါ်မှာ ရှာတာကို ထပ်လုပ်ပါတယ်။ ကြိုး မေးခွန်းက သူတို့ကို လုံးဝ ခွဲထုတ်ပေးပါတယ် (ပြင်ဆင်မှု 9 က တစ်ဖက်၊ ပြင်ဆင်မှု 1 ကနေ 4 က နောက်တစ်ဖက်)။ သင်ယူလို့ ရလာတဲ့ tree က ဒီလိုပါ:
- ဖုန်းက အားကျန်သေးတယ်လို့ ပြနေရဲ့သားနဲ့ ပိတ်သွားသလား။
- No: charging port
- Yes: ကြိုးကို ထောင့်တစ်ခုနဲ့ ကိုင်ထားမှပဲ အားသွင်းလို့ရသလား။
- Yes: charging port
- No: battery
အား 30% ကျန်သေးချိန်မှာ ပိတ်သွားတဲ့၊ ပုံမှန်အတိုင်း အားသွင်းလို့ရတဲ့၊ 4 နှစ် ကြာပြီ ဖြစ်တဲ့ ဖုန်းအသစ် တစ်လုံးက Yes ကို လိုက်ပြီး နောက် No ကို လိုက်ပါတယ်: battery ပါ။ ဒီ record တွေမှာ အသက်က ချို့ယွင်းချက်တွေကို ခွဲဖို့ အထောက်အကူ မဖြစ်ခဲ့လို့ tree မှာ အသက် မေးခွန်း မပါပါဘူး။ လက်တွေ့မှာတော့ algorithm တွေက အမှားတွေကို ရေတွက်တာ မဟုတ်ဘဲ formula (ပုံသေနည်း) တစ်ခု (Gini impurity ဒါမှမဟုတ် entropy လို) နဲ့ အုပ်စု တစ်ခုစီ ဘယ်လောက် ရောနေလဲ တိုင်းတာပါတယ်။ ဒါပေမယ့် အယူအဆက အတူတူပါပဲ: အဆင့် တိုင်းမှာ အုပ်စုတွေကို အနည်းဆုံး ရောနေအောင် ချန်ခဲ့မယ့် မေးခွန်းကို ရွေးတာပါ။ Battery ရဲ့ အသက်ကို လနဲ့ ပြတာလို ဂဏန်း တစ်ခုအတွက်ဆိုရင် မေးခွန်းက threshold (ခွဲခြားတဲ့ ကန့်သတ် တန်ဖိုး) တစ်ခု ဖြစ်လာပါတယ် (“30 လထက် ကြာပြီလား။”)၊ အဲဒီ တန်ဖိုးကိုလည်း အဲဒီနည်းအတိုင်းပဲ ရွေးပါတယ်။ အုပ်စု တစ်ခုစီမှာ class တစ်မျိုးတည်းပဲ ရှိတဲ့အခါ (အုပ်စုက pure (သန့်) ဖြစ်တဲ့အခါ)၊ ဒါမှမဟုတ် maximum depth (tree က တစ်ဆက်တည်း မေးနိုင်တဲ့ မေးခွန်း အများဆုံး အရေအတွက်) လို ကန့်သတ်ချက် တစ်ခုကို ရောက်တဲ့အခါ tree က ကြီးထွားတာ ရပ်ပါတယ်။ Maximum depth က k-NN ထဲက k လိုပဲ hyperparameter တစ်ခုပါ။
Decision tree တွေရဲ့ အဓိက အားသာချက်က interpretability (ဘာကြောင့် ဒီလို ဆုံးဖြတ်လဲ လူက ဖတ်ပြီး နားလည်နိုင်မှု) ပါ: model တော်တော်များများနဲ့ မတူဘဲ decision tree အသေးလေး တစ်ခုကို ဖတ်လို့ရပြီး ဘယ် condition (မှန်လား မှားလား စစ်တဲ့ အခြေအနေ) တွေကြောင့် ဒီခန့်မှန်းချက် ထွက်လာလဲ ဆိုတာကို branch တွေအတိုင်း လိုက်ကြည့်လို့ရပါတယ်။ ဆုံးဖြတ်ချက် တစ်ခုက တစ်စုံတစ်ယောက်ရဲ့ ဘဝကို ထိခိုက်ပြီး သူ့ကို ရှင်းပြဖို့ လိုတဲ့အခါ ဒါက အရေးကြီးပါတယ်။ သူတို့ရဲ့ အဓိက အားနည်းချက်ကတော့ overfit (training ဒေတာကို အလွတ်ကျက်သလို သင်ယူမိခြင်း) ဖြစ်တတ်တာပါ (training စာမျက်နှာမှာ ပါပါတယ်)။ နက်တဲ့ tree တစ်ခုက training data (model သင်ယူဖို့ ပေးတဲ့ ဒေတာ) နဲ့ အရမ်း ကိုက်ညီလွန်းလို့ အဲဒါကို အလွတ်ကျက်မိပြီး generalise (ဒေတာ အသစ်ပေါ်မှာလည်း မှန်မှန် ခန့်မှန်းနိုင်ခြင်း) ညံ့သွားနိုင်ပါတယ်၊ ဆိုလိုတာက ဒေတာ အသစ်ပေါ်မှာ ခန့်မှန်းချက် ညံ့တာပါ။
အသုံးချပုံ: လူနာရဲ့ ရောဂါလက္ခဏာတွေကနေ ရောဂါ ရှာဖွေတာ (ဆရာဝန်က တွေးခေါ်ပုံ အဆင့် တစ်ခုချင်းကို စစ်ကြည့်နိုင်ပါတယ်)၊ လျှောက်ထားသူကို ရှင်းပြဖို့ လိုတဲ့ ချေးငွေ ဒါမှမဟုတ် အာမခံ ဆုံးဖြတ်ချက်တွေ ဖြစ်ပါတယ်။
Feature တွေ၊ label တွေနဲ့ supervised learning ရဲ့ training loop ကို ဥပမာ တစ်ခုနဲ့ ရှင်းပြထားပါတယ်။
Unsupervised Learning ကို အနီးကပ် ကြည့်ခြင်း
Unsupervised learning က label မပါတဲ့ ဒေတာထဲမှာ ဖွဲ့စည်းပုံကို ရှာပါတယ်။ IB သင်ရိုးမှာ ပုံစံ နှစ်မျိုး ပါပါတယ်: clustering နဲ့ association rule learning ပါ။
Clustering (ဆင်တူတာတွေကို အုပ်စုဖွဲ့ခြင်း): k-means
Clustering က အုပ်စုတွေကို ကြိုတင် မပြောထားဘဲ ဆင်တူတဲ့ item တွေကို အတူတူ အုပ်စုဖွဲ့ပါတယ်။ Item တစ်ခုစီကို သူ့ရဲ့ feature တွေနဲ့ ဖော်ပြပြီး item နှစ်ခုရဲ့ feature တန်ဖိုးတွေ နီးရင် ဆင်တူတယ်လို့ သတ်မှတ်ပါတယ်။ နီးမနီးကို k-NN မှာလိုပဲ အကွာအဝေးနဲ့ တိုင်းပါတယ်။ ကျယ်ကျယ်ပြန့်ပြန့် သုံးတဲ့ နည်း တစ်ခုက k-means (centroid k ခုနဲ့ အုပ်စုဖွဲ့တဲ့ algorithm) ပါ။ အဲဒါက cluster (အုပ်စု) အရေအတွက် k ကို ရွေးပြီး starting centroid (cluster တစ်ခုစီအတွက် တစ်ခုစီ ရှိတဲ့ ဗဟိုမှတ်) k ခုကို ချထားတာနဲ့ စပါတယ်။ များသောအားဖြင့် ကျပန်း ရွေးထားတဲ့ data point k ခုရဲ့ နေရာမှာ ချထားပါတယ်။ ပြီးရင် cluster တွေ မပြောင်းတော့တဲ့အထိ အဆင့် နှစ်ဆင့်ကို ထပ်ခါထပ်ခါ လုပ်ပါတယ်:
- Assign (သတ်မှတ်ခြင်း): အမှတ် တစ်ခုစီကို သူ့ရဲ့ ဗဟိုမှတ် (centroid) အနီးဆုံး ဖြစ်တဲ့ cluster ထဲ ထည့်ပါ။
- Update (နေရာ ပြင်ရွှေ့ခြင်း): centroid တစ်ခုစီကို သူ့ဆီ assign လုပ်ထားတဲ့ အမှတ်တွေရဲ့ ပျမ်းမျှ နေရာဆီ ရွှေ့ပါ။
အမှတ် တစ်ခုစီကို အနီးဆုံး centroid ဆီ assign လုပ်ပါ၊ ပြီးရင် centroid တစ်ခုစီကို သူ့ဆီ assign လုပ်ထားတဲ့ အမှတ်တွေရဲ့ mean (ပျမ်းမျှ) နေရာဆီ ရွှေ့ပါ၊ ပြီးရင် ထပ်လုပ်ပါ။ ညာဘက် centroid က သူ့အုပ်စုရဲ့ ဗဟိုဆီ ရွှေ့နေပါတယ်။ အကြိမ် အနည်းငယ် လုပ်ပြီးရင် centroid တွေ ရွှေ့တာ ရပ်သွားပါတယ်။
ပုံထဲက centroid moves to the mean of its points က centroid က သူ့ အမှတ်တွေရဲ့ ပျမ်းမျှ နေရာဆီ ရွှေ့တယ်၊ Each dot is an unlabelled data point က အစက် တစ်စက်စီက label မပါတဲ့ data point တစ်ခု လို့ ဆိုလိုပါတယ်။
Assignment (သတ်မှတ်ထားတဲ့ cluster) တွေ မပြောင်းတော့တဲ့အထိ ဒါမှမဟုတ် သတ်မှတ်ထားတဲ့ အကြိမ်အရေအတွက် ပြည့်တဲ့အထိ ဒီအဆင့်တွေကို ထပ်ခါထပ်ခါ လုပ်ပါ။ အကြိမ်တွေ ဆက်လုပ်လာတာနဲ့အမျှ centroid တစ်ခုစီက သူ့ဆီ assign လုပ်ထားတဲ့ အမှတ်တွေရဲ့ ဗဟိုဆီ ရွှေ့သွားပါတယ်။ Cluster တွေက အသုံးဝင်တဲ့ အုပ်စုတွေနဲ့ ကိုက်ချင်မှ ကိုက်ပါမယ်: ဒေတာမှာ ရှင်းလင်းတဲ့ အုပ်စု မရှိရင်တောင် k-means က ဒေတာကို cluster k ခု ခွဲပါတယ်။ Algorithm က အုပ်စုတွေကို နာမည် မပေးပါဘူး: cluster တစ်ခုစီထဲက item တွေကို လူတွေက ကြည့်ပြီး အဲဒီ cluster က ဘာကို ဆိုလိုလဲ၊ အသုံးဝင်လား ဆုံးဖြတ်ကြပါတယ်။ ကန့်သတ်ချက်တွေကတော့:
- k (cluster အရေအတွက်) ကို ကြိုတင် ရွေးရပါတယ်၊ အဲဒါကို များသောအားဖြင့် မသိကြပါဘူး။
- စတင်တဲ့ နေရာ မတူရင် ရလဒ်လည်း ကွဲပြားနိုင်ပါတယ်၊ ဒါကြောင့် ဒေတာ အတူတူကို run တိုင်း cluster မတူတာတွေ ရနိုင်ပါတယ်။ Run တစ်ခုက ကောင်းပေမယ့် အကောင်းဆုံး မဟုတ်တဲ့ ခွဲပုံ (local optimum) မှာ ရပ်သွားနိုင်ပါတယ်။
- အရွယ်အစား ဆင်တူပြီး အဝိုင်းပုံ နီးပါး ဖြစ်တဲ့ cluster တွေမှာ အကောင်းဆုံး အလုပ်လုပ်ပါတယ်၊ ရှည်ပြီး ပါးတဲ့ အုပ်စုတွေ ဒါမှမဟုတ် အရမ်း မညီမျှတဲ့ အုပ်စုတွေမှာတော့ ညံ့ပါတယ်။
အသုံးချပုံ: customer segmentation (ဝယ်သူတွေကို သူတို့ရဲ့ ဝယ်ယူမှု ဒေတာနဲ့ အုပ်စုခွဲပြီး အုပ်စု တစ်ခုစီကို သီးသန့် ကမ်းလှမ်းချက် ပေးနိုင်အောင် လုပ်တာ)၊ စာရွက်စာတမ်းတွေကို ခေါင်းစဉ်အလိုက် အုပ်စုဖွဲ့တာ၊ ဆင်တူတဲ့ အရောင်တွေကို အုပ်စုဖွဲ့ပြီး အုပ်စု တစ်ခုစီအတွက် အရောင် တစ်ရောင်ပဲ ထားကာ image file ကို သေးအောင် လုပ်တာ တို့ ဖြစ်ပါတယ်။
ကိုယ်တိုင် စမ်းကြည့်ပါ: k-means simulator က assign လုပ်ပြီး ဗဟိုကို ပြန်ရွှေ့တဲ့ အဆင့်တွေကို တစ်ဆင့်ချင်း ပြပေးပါတယ်။ ကျပန်း starting centroid အသစ်တွေကို ရွေးပြီး ဒေတာ အတူတူက cluster မတူတာတွေ ဖြစ်သွားတာကိုလည်း ကြည့်လို့ရပါတယ်။
Association Rule Learning (အတူတူ ဖြစ်လေ့ရှိတဲ့ ပုံစံတွေကို ရှာတဲ့ learning)
Association rule learning က record အများကြီးထဲမှာ မကြာခဏ အတူတူ ပေါ်လေ့ရှိတဲ့ item တွေ ဒါမှမဟုတ် attribute value တွေကြားက ဆက်နွယ်မှုတွေ ကို ရှာဖော်ပါတယ် (attribute value ဆိုတာ ဘောက်ချာ (receipt) ပေါ်က ကုန်ပစ္စည်း တစ်ခုလို record တစ်ခုထဲက ဒေတာ တစ်ခုပါ)။ အကျော်ကြားဆုံး အသုံးချပုံက market basket analysis (ဈေးခြင်းတောင်း ခွဲခြမ်းစိတ်ဖြာမှု) ဖြစ်ပြီး မကြာခဏ အတူတူ ဝယ်လေ့ရှိတဲ့ ကုန်ပစ္စည်းတွေကို ရှာပါတယ်။ ဒါပေမယ့် item တွေက record တစ်ခုတည်းထဲမှာ ပေါ်တဲ့ ဘယ် attribute value မဆို ဖြစ်နိုင်ပါတယ်: လူနာ record ထဲက ရောဂါလက္ခဏာတွေ၊ ပြင်ဆင်မှု report ထဲက ချို့ယွင်းချက်တွေ ဒါမှမဟုတ် website တစ်ခုမှာ session (အသုံးပြုချိန် တစ်ကြိမ်) တစ်ခုအတွင်း ဝင်ကြည့်ခဲ့တဲ့ စာမျက်နှာတွေ ဖြစ်နိုင်ပါတယ်။
Rule (စည်းမျဉ်း) တစ်ခုကို {A} → {B} လို့ ရေးပြီး “A ပါတဲ့ record တွေမှာ B လည်း မကြာခဏ ပါတတ်တယ်” လို့ ဖတ်ပါတယ်။ Rule ကို တိုင်းတာချက် နှစ်ခုနဲ့ ဖော်ပြပါတယ်:
- Support (အဖြစ်များမှု): record အားလုံးထဲက rule ထဲမှာ ပါတဲ့ အရာအားလုံး (A ရော B ရော) ပါတဲ့ record အချိုးပါ။ ပုံစံက ဘယ်လောက် အဖြစ်များလဲ ပြပါတယ်။
- Confidence (ယုံကြည်နိုင်မှု): A ပါတဲ့ record တွေထဲက B ပါ ပါတဲ့ record အချိုးပါ။ A ရှိတဲ့အခါ rule က ဘယ်လောက် မကြာခဏ မှန်လဲ ပြပါတယ်။
Rule တွေကို mining လုပ်ခြင်း။ Record အများကြီးထဲမှာ rule တွေကို ရှာတာကို mining (တူးဖော်ခြင်း) လို့ ခေါ်ပါတယ်။ ခွဲခြမ်းစိတ်ဖြာသူ (analyst) က အနည်းဆုံး support နဲ့ အနည်းဆုံး confidence ကို သတ်မှတ်ပါတယ်။ Algorithm (Apriori က လူသိများတဲ့ တစ်ခုပါ) က support အနည်းဆုံး တန်ဖိုးကို ရောက်တဲ့ item တွဲတွေကို ရှာပြီး confidence ကလည်း အနည်းဆုံး တန်ဖိုးကို ရောက်တဲ့ rule တွေကို ထားပါတယ်။ ဒေတာ အစုအဝေး ကြီးတစ်ခုက rule ထောင်ချီ ထွက်လာနိုင်သေးလို့ လူတွေက အဲဒါတွေကို အဓိပ္ပာယ် ဖော်ရပါတယ်။
Rule တစ်ခုကို အဓိပ္ပာယ် ဖော်ခြင်း။ ဥယျာဉ်သုံး ပစ္စည်းဆိုင် (garden centre) တစ်ဆိုင်က နွေဦးရာသီ တစ်ခုအတွင်း ထုတ်ခဲ့တဲ့ ဘောက်ချာ 8,000 ကို mining လုပ်ပါတယ်။ အဲဒီထဲက 400 မှာ ခရမ်းချဉ်သီး မျိုးစေ့ ပါပြီး 960 မှာ ဝါးတိုင် (bamboo cane) ပါပါတယ်၊ 240 မှာ နှစ်မျိုးလုံး ပါပါတယ်။
- {ခရမ်းချဉ်သီး မျိုးစေ့} → {ဝါးတိုင်} ရဲ့ Support = 240 ÷ 8,000 = 3%: ဘောက်ချာ 100 စောင်မှာ 3 စောင်မှာ ဒီအတွဲ ပါပါတယ်။
- Confidence = 240 ÷ 400 = 60%: ခရမ်းချဉ်သီး မျိုးစေ့ ပါတဲ့ ဘောက်ချာ 10 စောင်မှာ 6 စောင်မှာ ဝါးတိုင်လည်း ပါပါတယ်။
- ဝါးတိုင်က ဘောက်ချာ အားလုံးရဲ့ 960 ÷ 8,000 = 12% မှာ ပါပါတယ်၊ ဒါကြောင့် ခရမ်းချဉ်သီး မျိုးစေ့ ဝယ်တဲ့ ဝယ်သူတွေက ဝါးတိုင် ဝယ်ဖို့ ဖြစ်နိုင်ခြေက ယေဘုယျ ဝယ်သူတွေရဲ့ 5 ဆ ရှိပါတယ် (60% ÷ 12%)။ ဒီအချိုးကို lift (ဖြစ်နိုင်ခြေ ဘယ်နှစ်ဆ တိုးလဲ ပြတဲ့ အချိုး) လို့ ခေါ်ပါတယ်။ Lift က 1 ထက် အများကြီး ပိုရင် item တွေကြား တကယ့် ဆက်နွယ်မှု ရှိနိုင်တယ်လို့ ညွှန်ပြပါတယ်။
အခု {ခရမ်းချဉ်သီး မျိုးစေ့} → {အိုးစိုက် မြေဆွေး} rule နဲ့ နှိုင်းယှဉ်ကြည့်ပါ။ ခရမ်းချဉ်သီး မျိုးစေ့ ပါတဲ့ ဘောက်ချာ 400 ထဲက 300 မှာ မြေဆွေး ပါပါတယ်၊ confidence 75% ဖြစ်လို့ ဝါးတိုင် rule ထက် ပိုမြင့်ပါတယ်။ ဒါပေမယ့် မြေဆွေးက ဘောက်ချာ 8,000 ထဲက 6,000 (75%) မှာ ပါတာကြောင့် မျိုးစေ့ ဝယ်တဲ့ ဝယ်သူတွေက တခြား ဘယ်သူ့ထက်မှ မြေဆွေး ဝယ်ဖို့ ပိုမများပါဘူး (lift 1)။ Confidence မြင့်တာက လူတိုင်းနီးပါး ဝယ်တဲ့ item တစ်ခုကြောင့်လည်း ဖြစ်နိုင်လို့ အဲဒါကို ဒုတိယ item က ယေဘုယျ ဘယ်လောက် အဖြစ်များလဲ ဆိုတာနဲ့ နှိုင်းယှဉ်ပါ။
သတိထားရမယ့် အချက် နောက်ထပ် နှစ်ချက်:
- Rule က item တွေ အတူတူ ဖြစ်တယ်ဆိုတာကိုပဲ ပြပြီး ဘာကြောင့်လဲ ဆိုတာကို မပြပါဘူး။ ခရမ်းချဉ်သီး မျိုးစေ့ ဝယ်တာက ဘယ်သူ့ကိုမှ ဝါးတိုင် ဝယ်အောင် မလုပ်ပါဘူး၊ နှစ်မျိုးလုံးကို ဟင်းသီးဟင်းရွက် စိုက်မယ့်သူတွေက ဝယ်ကြတာ ဖြစ်နိုင်ပါတယ်။ ဝါးတိုင်ကို မျိုးစေ့ဘေးမှာ ထားတာလို rule အရ လုပ်ဆောင်တာက လူတွေ ဆုံးဖြတ်ရမယ့် ကိစ္စဖြစ်ပြီး အဲဒါ အကျိုးရှိမရှိ သူတို့ စစ်ကြည့်သင့်ပါတယ်။
- Support နည်းတဲ့ rule က တိုက်ဆိုင်မှု သက်သက် ဖြစ်နိုင်ပါတယ်။ ဘောက်ချာ 8,000 ထဲက 5 စောင်မှာပဲ တွေ့တဲ့ ပုံစံက နောက်နှစ်မှာ ထပ်ပေါ်ချင်မှ ပေါ်ပါမယ်။
Association rule learning က label ဒါမှမဟုတ် ဂဏန်း တစ်ခုကို မခန့်မှန်းပါဘူး။ အတူတူ ဖြစ်လေ့ရှိတဲ့ item တွေကို ရှာပေးပြီး လူတွေက အဲဒါတွေအပေါ် အခြေခံပြီး လုပ်ဆောင်နိုင်ပါတယ်၊ ဥပမာ အဲဒီ ကုန်ပစ္စည်းတွေကို တစ်ခုနဲ့ တစ်ခု နီးနီးမှာ ထားတာ ဒါမှမဟုတ် ဝယ်ဖွယ်ရှိတဲ့ နောက်ဆက်တွဲ ပစ္စည်းကို အကြံပြုတာမျိုးပါ။
အသုံးချပုံ: ဆိုင်တွေရဲ့ “ဒါကိုလည်း ကြိုက်နိုင်ပါတယ်” အကြံပြုချက်တွေ၊ ဘယ် ရောဂါလက္ခဏာတွေ အတူတူ ပေါ်လေ့ရှိလဲ ရှာတာ၊ ဘယ်လို ဖြစ်ရပ် အမျိုးအစားတွေကို ဧရိယာ တစ်ခုတည်းမှာ အတူတူ တိုင်ကြားလေ့ ရှိလဲ ရှာတာနဲ့ ဆိုင်ထဲ ပစ္စည်း နေရာချ ဆုံးဖြတ်ချက်တွေ ဖြစ်ပါတယ်။
Unsupervised learning နဲ့ k-means clustering ကို ရှင်းပြပါတယ်၊ label မပါတဲ့ ဒေတာထဲမှာ အုပ်စုတွေ ဖြစ်လာနေစဉ် အပေါ်မှာ ဖော်ပြထားတဲ့ assign လုပ်ပြီးမှ update လုပ်တဲ့ အဆင့်တွေကို ပြပါတယ်။
Reinforcement Learning ကို အနီးကပ် ကြည့်ခြင်း
Reinforcement learning မှာ environment (game တစ်ခု၊ လမ်းမ တစ်ခု ဒါမှမဟုတ် အဆောက်အအုံ တစ်ခုလို agent နဲ့ ထိတွေ့ဆက်ဆံရတဲ့ ကမ္ဘာ) ထဲမှာ လုပ်ဆောင်နေတဲ့ agent (ဆုံးဖြတ်ချက်တွေ ချတဲ့ program) တစ်ခု ရှိပါတယ်။ State (အဲဒီ အချိန်မှာ agent ရောက်နေတဲ့ အခြေအနေ) တစ်ခုစီမှာ agent က action တစ်ခုကို ရွေးပြီး environment က state အသစ် တစ်ခုနဲ့ reward တစ်ခုကို ပြန်ပေးပါတယ် (ဒါမှမဟုတ် penalty ပေးပါတယ်၊ penalty ဆိုတာ အနုတ် reward ပါ)။ Agent ရဲ့ ရည်မှန်းချက်က နောက်တစ်ဆင့်အတွက် reward တစ်ခုတည်းကို မဟုတ်ဘဲ သူ့ရဲ့ cumulative reward ဖြစ်တဲ့ အချိန်တစ်လျှောက် ရတဲ့ reward စုစုပေါင်းကို အများဆုံး ဖြစ်အောင် လုပ်ဖို့ပါ။ ဒါကြောင့် ဘယ် အစောပိုင်း action တွေက နောက်ပိုင်းမှာ ကောင်းတဲ့ ရလဒ်တွေဆီ ရောက်စေလဲ ဆိုတာကို သင်ယူရပါတယ်။
Reinforcement learning ရဲ့ အသွားအပြန် စက်ဝန်း။ Agent က action တစ်ခုကို ရွေးပါတယ်၊ environment က state အသစ် တစ်ခုနဲ့ reward တစ်ခုကို ပြန်ပို့ပါတယ်၊ agent က အချိန်တစ်လျှောက် ရတဲ့ reward စုစုပေါင်း အတတ်နိုင်ဆုံး များအောင် သူ့ ရွေးချယ်မှုတွေကို ညှိပါတယ်။
ပုံထဲက new state က state အသစ်၊ goal: the largest cumulative reward က ရည်မှန်းချက်: cumulative reward အများဆုံး ရဖို့ လို့ ဆိုလိုပါတယ်။
State (အခြေအနေ)၊ Action (လုပ်ဆောင်ချက်) နဲ့ Policy (action ရွေးတဲ့ စည်းမျဉ်း)
Agent ရဲ့ policy က state တစ်ခုစီမှာ action ရွေးတဲ့ သူ့ရဲ့ စည်းမျဉ်းပါ။ Reinforcement learning မှာ သင်ယူတယ် ဆိုတာ cumulative reward ပိုရအောင် အတွေ့အကြုံကနေ policy ကို တိုးတက်အောင် လုပ်တာပါ။
ကိုယ့်ဘာသာ ခက်ခဲမှုကို ညှိတဲ့ puzzle game (ဉာဏ်စမ်း game) တစ်ခုကို ဥပမာ ယူကြည့်ပါ။ Agent က နောက် level (အဆင့်) ဘယ်လောက် ခက်မလဲ ဆုံးဖြတ်ပါတယ်:
- State တွေ: နောက်ဆုံး level မှာ ကစားသူ ဘယ်လို လုပ်ခဲ့လဲ: လွယ်လွယ်နဲ့ နိုင်ခဲ့တာ၊ ခပ်ကပ်ကပ် နိုင်ခဲ့တာ ဒါမှမဟုတ် ရှုံးခဲ့တာ။
- Action တွေ: နောက် level ကို ပိုလွယ်အောင် လုပ်မလား၊ အတူတူ ထားမလား၊ ပိုခက်အောင် လုပ်မလား။
- Reward တွေ: ကစားသူက level နောက်တစ်ခု စတိုင်း +1၊ ကစားသူက လက်လျှော့ပြီး game ကို ပိတ်လိုက်ရင် -5။
- Cumulative reward: session (ကစားချိန် တစ်ကြိမ်) တစ်ခုလုံးရဲ့ စုစုပေါင်းပါ၊ ကစားသူတွေ ဆက်ကစားနေရင် အမြင့်ဆုံး ဖြစ်ပါတယ်။
ရိုးရှင်းတဲ့ policy က state တစ်ခုစီအတွက် action တစ်ခု ပေးလို့ ဇယားအဖြစ် ရေးလို့ရပါတယ်။ Session အများကြီး ပြီးတဲ့အခါ agent က ဒီ policy ကို ရလာနိုင်ပါတယ်:
| State (နောက်ဆုံး level) | Policy က ရွေးတဲ့ action |
|---|---|
| လွယ်လွယ်နဲ့ နိုင်ခဲ့ | နောက် level ကို ပိုခက်အောင် လုပ် |
| ခပ်ကပ်ကပ် နိုင်ခဲ့ | ခက်ခဲမှုကို အတူတူ ထား |
| ရှုံးခဲ့ | နောက် level ကို ပိုလွယ်အောင် လုပ် |
ဒီဇယားကို agent အတွက် ဘယ်သူမှ ရေးမပေးပါဘူး။ Agent က ဘာကိုမှ ဦးစားမပေးဘဲ စပြီး သူ ရတဲ့ reward တွေကနေ policy ကို တည်ဆောက်ပါတယ်။ စုစုပေါင်းနဲ့ အကဲဖြတ်ခံရလို့ နောက် reward တစ်ခုထက် ကျော်ပြီး ကြည့်ရပါတယ်: level တိုင်းကို လွယ်အောင် လုပ်ရင် ကစားသူကို level တစ်ခု ပိုကစားအောင် ထိန်းထားနိုင်ပေမယ့် (အခု +1) level အနည်းငယ် အကြာမှာ ငြီးငွေ့လာပြီး ထွက်သွားစေနိုင်ပါတယ် (-5)။
Policy ဘယ်လို တိုးတက်လဲ။ အသုံးများတဲ့ နည်း တစ်ခုဖြစ်တဲ့ Q-learning က state နဲ့ action အတွဲ တစ်ခုစီအတွက် အမှတ် (score) တစ်ခု မှတ်ထားပါတယ်: အဲဒီ state မှာ အဲဒီ action ကို လုပ်ပြီး အဲဒီကနေ ဆက်ပြီး အမှတ် အကောင်းဆုံး action တွေကို ရွေးသွားရင် agent မျှော်လင့်နိုင်တဲ့ cumulative reward ရဲ့ ခန့်မှန်း တန်ဖိုးပါ။ Action တစ်ခု လုပ်ပြီးတိုင်း agent က အဲဒီ အတွဲရဲ့ အမှတ်ကို target (ပစ်မှတ် တန်ဖိုး) ဆီ နည်းနည်း ရွှေ့ပါတယ်: target ဆိုတာ သူ ရခဲ့တဲ့ reward နဲ့ state အသစ်ကနေ ရနိုင်တဲ့ အကောင်းဆုံး အမှတ်ကို ပေါင်းထားတာပါ။ အဲဒီ အနာဂတ် အမှတ်ကို များသောအားဖြင့် သူ့ တန်ဖိုး အပြည့်ထက် နည်းနည်း လျှော့ပြီး တွက်လို့ စောစော ရတဲ့ reward တွေက ပိုတန်ဖိုး ရှိပါတယ်။ Agent ရဲ့ policy က state တစ်ခုစီမှာ အမှတ် အမြင့်ဆုံး action ကို ရွေးတာ ဖြစ်ပြီး ဒါက နောက်အပိုင်းမှာ ပြောမယ့် trade-off (တစ်ခု ရဖို့ တစ်ခု အလျှော့ပေးရတာ) ဆီ ဦးတည်စေပါတယ်။
Exploration (အသစ် စမ်းကြည့်ခြင်း) နဲ့ Exploitation (သိပြီးသား အကောင်းဆုံးကို သုံးခြင်း)
အဓိက အခက်အခဲက exploration versus exploitation trade-off ပါ။ Agent က action လုပ်တိုင်း ရည်ရွယ်ချက် နှစ်ခုကြားမှာ ရွေးရပါတယ်:
- Exploitation: လက်ရှိ ခန့်မှန်းချက်အရ cumulative reward အများဆုံး ပေးမယ့် action ကို လုပ်တာ။
- Exploration: ပိုကောင်းတာ ရှိမရှိ ရှာဖွေ သိဖို့ ရလဒ်ကို သိပ်မသေချာသေးတဲ့ တခြား action တစ်ခုကို စမ်းကြည့်တာ။
Puzzle game ထဲမှာ ခပ်ကပ်ကပ် နိုင်တိုင်း ခက်ခဲမှုကို အတူတူ ထားတဲ့ agent က နည်းနည်း ပိုခက်တဲ့ level က ကစားသူတွေကို ပိုကြာကြာ ထိန်းထားနိုင်မလား ဆိုတာကို မသိရပါဘူး။ Exploitation အရမ်းများရင် agent က ပိုကောင်းတဲ့ action တွေကို ရှာမတွေ့ဘဲ ဖြစ်နိုင်ပါတယ်။ Exploration အရမ်းများရင် သင်ယူနေစဉ် ရတဲ့ reward လျော့သွားနိုင်ပါတယ်။ အသုံးများတဲ့ နည်းက ဖြစ်နိုင်ခြေ (probability) နည်းနည်းနဲ့ explore လုပ်တာပါ (ဥပမာ 10 ကြိမ်မှာ 1 ကြိမ် ကျပန်း action တစ်ခုကို ရွေးပြီး ကျန်တဲ့ အကြိမ်တွေမှာ အမှတ် အကောင်းဆုံး action ကို ရွေးတာ)၊ ပြီးတော့ agent သင်ယူလာတာနဲ့အမျှ အဲဒီ ဖြစ်နိုင်ခြေကို လျှော့သွားတာပါ။
အသုံးချပုံ: game ကစားတဲ့ agent တွေ၊ robot ထိန်းချုပ်မှုနဲ့ feedback (ရလဒ်အပေါ် ပြန်ရတဲ့ တုံ့ပြန်ချက်) ကနေ တိုးတက်လာတဲ့ စနစ်တွေ ဖြစ်ပါတယ်၊ ဥပမာ recommendation system တွေနဲ့ resource scheduling (စက်၊ အခန်း ဒါမှမဟုတ် ဝန်ထမ်း တစ်ယောက်ကို နောက်ထပ် ဘယ်အလုပ် ပေးမလဲ ဆုံးဖြတ်တာ) တို့ပါ။
ကိုယ်တိုင် စမ်းကြည့်ပါ: reinforcement learning simulator က Q-learning ကို သုံးပြီး agent တစ်ခုကို ကျင်း (pit) ကို ရှောင်ရင်း ဇယားကွက် (grid) ကို ဖြတ်ပြီး ပန်းတိုင်ဆီ ရောက်အောင် train လုပ်ပေးပါတယ်။ မြှားတွေက သူ့ရဲ့ policy ဖြစ်တဲ့ အကွက် တစ်ကွက်စီမှာ သူ ဦးစားပေးတဲ့ ရွှေ့ကွက်ကို ပြပါတယ်။ Exploration setting ကို မြှင့်ပြီး သူ ဟိုဟိုဒီဒီ ပိုလျှောက်သွားတာကို ကြည့်ပါ၊ လျှော့ပြီး သူ တွေ့တဲ့ ပထမဆုံး သင့်တော်တဲ့ လမ်းကြောင်းကိုပဲ ဆက်သွားနေတာကို ကြည့်ပါ။
Agent၊ action နဲ့ reward တွေရဲ့ loop ကို လက်တွေ့ ပြပါတယ်၊ agent က ရွှေ့ကွက် အသစ်တွေကို စမ်းကြည့်တာ (exploring) နဲ့ သူ ယုံကြည်ပြီးသား ရွှေ့ကွက်တွေကို သုံးတာ (exploiting) ကြား ဘာကြောင့် ချိန်ခွင်လျှာ ညှိရလဲ ဆိုတာလည်း ပါပါတယ်။
Genetic Algorithms (ဆင့်ကဲဖြစ်စဉ်ကို အတုယူတဲ့ ရှာဖွေနည်းများ)
Genetic algorithm တွေက ကောင်းတဲ့ ဖြေရှင်းချက်တွေကို ရှာဖို့ ဆင့်ကဲဖြစ်စဉ် အလုပ်လုပ်ပုံကို အတုယူပါတယ်။ Algorithm က candidate solution (ပြဿနာအတွက် ဖြစ်နိုင်တဲ့ အဖြေ) တွေရဲ့ population (candidate အစုအဝေး) တစ်ခုကို ထိန်းထားပြီး generation (အောက်က စက်ဝန်းကို တစ်ပတ် ပတ်တာ) အများကြီး ဖြတ်ပြီး အဲဒါကို တိုးတက်အောင် လုပ်ပါတယ်:
- Population: candidate solution အစု တစ်ခုနဲ့ စပါ၊ များသောအားဖြင့် ကျပန်း ဖန်တီးထားတာပါ။
- Fitness (ဘယ်လောက် ကောင်းလဲ ဆိုတဲ့ အမှတ်): fitness function (ဖြေရှင်းချက် ဘယ်လောက် ကောင်းလဲ တိုင်းတဲ့ function) က candidate တစ်ခုစီ ဘယ်လောက် ကောင်းလဲ အမှတ်ပေးပါတယ်။
- Selection (ရွေးချယ်ခြင်း): fitness ပိုကောင်းတဲ့ candidate တွေ (fitness အမှတ် ပိုမြင့်တဲ့ candidate တွေ) ကို “parent” (မိဘ) အဖြစ် ရွေးခံရဖို့ ပိုများပါတယ်။
- Crossover (ရောစပ်ခြင်း): parent တွေကို ပေါင်းစပ်ပြီး သူတို့ရဲ့ ထူးခြားချက်တွေကို ရောထားတဲ့ candidate အသစ် (children (သားသမီး)) တွေကို ထုတ်ပါတယ်။
- Mutation (ကျပန်း ပြောင်းလဲခြင်း): ဖြစ်နိုင်ခြေ အသစ်တွေကို ဆက်ရှာနေနိုင်ဖို့နဲ့ population တစ်ခုလုံး အတူတူ ဖြစ်မသွားဖို့ candidate အသစ် တချို့မှာ ကျပန်း အပြောင်းအလဲ အသေးလေးတွေ လုပ်ပါတယ်။
- Evaluation (အကဲဖြတ်ခြင်း) နဲ့ termination (ရပ်ခြင်း): generation အသစ်ကို အမှတ်ပေးပြီး ထပ်လုပ်ပါ။ ဖြေရှင်းချက် တစ်ခု လုံလောက်အောင် ကောင်းတဲ့အခါ၊ အကောင်းဆုံး အမှတ် မတိုးတော့တဲ့အခါ ဒါမှမဟုတ် အချိန် ကုန်သွားတဲ့အခါ algorithm က ရပ်ပါတယ် (terminate လုပ်ပါတယ်)။
စက်ဝန်းကို တစ်ပတ် ပတ်တာက generation တစ်ခုပါ။ Candidate တစ်ခုက fitness မှာ လုံလောက်အောင် အမှတ်ကောင်းတဲ့အထိ ဒါမှမဟုတ် ပေးထားတဲ့ အချိန် ကုန်တဲ့အထိ စက်ဝန်းကို ထပ်ခါထပ်ခါ လုပ်ပြီး တွေ့ခဲ့တဲ့ အကောင်းဆုံး candidate က အဖြေ ဖြစ်ပါတယ်။
ပုံထဲက termination: good enough or out of time က လုံလောက်အောင် ကောင်းပြီ ဒါမှမဟုတ် အချိန် ကုန်ပြီဆိုရင် ရပ်တယ်၊ one loop = one generation က စက်ဝန်း တစ်ပတ် = generation တစ်ခု လို့ ဆိုလိုပါတယ်။
Fitness function က အဓိက ဒီဇိုင်း ရွေးချယ်မှုပါ။ Candidate တစ်ခုစီက ရည်မှန်းချက်ကို ဘယ်လောက် ပြည့်မီလဲ တိုင်းတာခြင်းအားဖြင့် “ကောင်းတယ်” ဆိုတာ ဘာကို ဆိုလိုလဲ သတ်မှတ်ပေးပြီး selection က အဲဒီ အမှတ်တွေကို သုံးကာ population ကို generation တစ်ခုပြီး တစ်ခု fitness ပိုမြင့်တဲ့ဘက် ရွှေ့ပါတယ်။ Fitness function က မှားတဲ့ အရာကို တိုင်းနေရင် algorithm က တကယ် လိုချင်တာကို မတိုးတက်စေဘဲ တိုင်းထားတဲ့ အမှတ်ကိုပဲ တိုးအောင် လုပ်မိနိုင်ပါတယ်။ Genetic algorithm တွေက search space (ဖြစ်နိုင်တဲ့ ဖြေရှင်းချက် အရမ်းများတဲ့ အစု) ကြီးတဲ့ ပြဿနာတွေမှာ အသုံးဝင်ပါတယ်။ အဲဒီ ပြဿနာတွေမှာ ဖြေရှင်းချက် ကောင်းကို အမှတ်ပေးကြည့်ပြီး သိနိုင် ပေမယ့် အကောင်းဆုံး ဖြေရှင်းချက်ကို တိုက်ရိုက် ရှာဖို့ ခက်ပါတယ်။ သူတို့က များသောအားဖြင့် ကောင်းတဲ့ ဖြေရှင်းချက် တစ်ခုကို ရှာတွေ့ပေမယ့် အဲဒါက ဖြစ်နိုင်သမျှထဲမှာ အကောင်းဆုံး ဖြစ်မယ်လို့ အာမခံချက် မရှိပါဘူး။
အဆင့်ဆင့် ရှင်းပြထားတဲ့ ဥပမာ: ဘတ်ဂျက် အတွင်း အဆင့်မြှင့်ခြင်း
ကျောင်း တစ်ကျောင်းမှာ စွမ်းအင် ချွေတာတဲ့ အဆင့်မြှင့်မှု (upgrade) တွေအတွက် သုံးဖို့ $20,000 ရှိပြီး ရွေးစရာ ခြောက်ခု ရှိပါတယ်။ တစ်ခုစီမှာ ကုန်ကျစရိတ်နဲ့ ကျောင်းရဲ့ စွမ်းအင် ကုန်ကျစရိတ်မှာ နှစ်စဉ် ချွေတာနိုင်မယ့် ခန့်မှန်း ငွေပမာဏ ရှိပါတယ်:
| ဂဏန်း နေရာ | Upgrade | ကုန်ကျစရိတ် | နှစ်စဉ် ချွေတာငွေ |
|---|---|---|---|
| 1 | LED မီးလုံးများ | $3,000 | $300 |
| 2 | ပြတင်းပေါက် အသစ်များ | $6,000 | $200 |
| 3 | အပူပေးစနစ်ကို အလိုအလျောက် ထိန်းတဲ့ smart ကိရိယာ | $4,000 | $400 |
| 4 | Boiler (ရေနွေးအိုး) အသစ် | $12,000 | $400 |
| 5 | ခေါင်မိုး အပူကာ | $5,000 | $600 |
| 6 | ဆိုလာ ပြားများ | $8,000 | $500 |
Candidate ဆိုတာ ဘာလဲ။ Candidate တစ်ခုစီက အစီအစဉ် (plan) တစ်ခုပါ၊ upgrade တစ်ခုကို ဂဏန်း တစ်လုံးနှုန်းနဲ့ ဂဏန်း ခြောက်လုံး ရေးထားပါတယ်: 1 က “လုပ်မယ်”၊ 0 က “မလုပ်ဘူး” လို့ ဆိုလိုပါတယ်။ Plan 101100 က upgrade 1၊ 3 နဲ့ 4 ကို လုပ်ပါတယ်။
Fitness က ဘယ်လို အမှတ်ပေးလဲ။ Plan တစ်ခုရဲ့ စုစုပေါင်း ကုန်ကျစရိတ်က $20,000 ဘတ်ဂျက် အတွင်း ဖြစ်ရင် fitness က သူ့ရဲ့ နှစ်စဉ် ချွေတာငွေ စုစုပေါင်းပါ၊ ပိုကုန်ရင်တော့ 0 ပါ။ Plan 101100 က $3,000 + $4,000 + $12,000 = $19,000 ကုန်ပြီး တစ်နှစ်ကို $300 + $400 + $400 = $1,100 ချွေတာလို့ သူ့ fitness က 1,100 ဖြစ်ပါတယ်။
Generation တစ်ခု။ ပထမ population မှာ ကျပန်း plan လေးခု ရှိတယ်လို့ ယူဆကြည့်ပါ:
| Plan | Upgrade များ | စုစုပေါင်း ကုန်ကျစရိတ် | Fitness |
|---|---|---|---|
| 101100 | 1, 3, 4 | $19,000 | 1,100 |
| 110001 | 1, 2, 6 | $17,000 | 1,000 |
| 010100 | 2, 4 | $18,000 | 600 |
| 011110 | 2, 3, 4, 5 | $27,000 | 0 (ဘတ်ဂျက် ကျော်) |
Selection က parent တွေကို ကျပန်း ရွေးပေမယ့် fitness ပိုကောင်းတဲ့ plan တွေ ရွေးခံရဖို့ ပိုများပါတယ်။ Fitness အကောင်းဆုံး နှစ်ခု ဖြစ်တဲ့ 101100 နဲ့ 110001 ကို ရွေးတယ်လို့ ယူဆပါ။ Crossover က နှစ်ခုလုံးကို တတိယ ဂဏန်းနောက်မှာ ဖြတ်ပြီး နောက်ပိုင်းတွေကို လဲလိုက်လို့ child (သားသမီး) နှစ်ခု ရပါတယ်:
- 101001 (ပထမ parent ဆီက 101၊ ဒုတိယ parent ဆီက 001): upgrade 1၊ 3 နဲ့ 6၊ $15,000၊ fitness 1,200၊ parent နှစ်ခုလုံးထက် ပိုကောင်းပါတယ်။
- 110100 (ဒုတိယ parent ဆီက 110၊ ပထမ parent ဆီက 100): upgrade 1၊ 2 နဲ့ 4၊ $21,000၊ fitness 0။ ဘတ်ဂျက် ကျော်နေလို့ နောက်တစ်ကြိမ်မှာ ရွေးခံရဖို့ အလားအလာ နည်းပါတယ်။
ပြီးရင် mutation က child တချို့ထဲမှာ ကျပန်း ဂဏန်း တစ်လုံးကို flip လုပ်ပါတယ် (1 ကို 0၊ ဒါမှမဟုတ် 0 ကို 1 ပြောင်းပါတယ်)။ 101001 ရဲ့ ပဉ္စမ ဂဏန်းကို flip လုပ်ရင် plan က 101011 ဖြစ်သွားပါတယ်: upgrade 1၊ 3၊ 5 နဲ့ 6 ဖြစ်ပြီး $20,000 အတိအကျ ကုန်ကာ တစ်နှစ်ကို $1,800 ချွေတာပါတယ်။ Mutation တော်တော်များများက plan ကို ပိုဆိုးစေပါတယ်၊ selection ကတော့ အကျိုးရှိတဲ့ mutation တွေကို ထိန်းထားလေ့ ရှိပါတယ်။
Upgrade ခြောက်ခုနဲ့ဆိုရင် ဖြစ်နိုင်တဲ့ plan 2 × 2 × 2 × 2 × 2 × 2 = 64 ခုပဲ ရှိပြီး အားလုံးကို စစ်ကြည့်ရင် ဒီမှာ $1,800 က အကောင်းဆုံး ချွေတာငွေ ဖြစ်တာကို တွေ့ရပါတယ်။ ဖြစ်နိုင်တဲ့ upgrade 40 ခုဆိုရင် plan 1,000,000,000,000 (တစ်သန်းရဲ့ တစ်သန်းဆ) ထက် ပိုများပြီး တစ်ခုချင်း စစ်ဖို့ အရမ်း များလွန်းပါတယ်။ Genetic algorithm က plan တိုင်းကို စစ်မယ့်အစား တစ်ကြိမ်မှာ population တစ်ခုကို အမှတ်ပေးပြီး generation အများကြီး ဖြတ်ကာ အဲဒါကို တိုးတက်အောင် လုပ်ပါတယ်။
လမ်းကြောင်း စီစဉ်ခြင်း
လူသိများတဲ့ အသုံးချပုံ တစ်ခုက travelling salesperson problem (ခရီးသွား အရောင်းသမား ပြဿနာ) လို လမ်းကြောင်း စီစဉ်ခြင်းပါ: မှတ်တိုင် (stop) တိုင်းကို တစ်ကြိမ်စီ ဝင်ပြီး အစကို ပြန်ရောက်တဲ့ အတိုဆုံး လမ်းကြောင်းကို ရှာရတာပါ။ Candidate အမျိုးအစား မတူတာကလွဲရင် စက်ဝန်း အတူတူပဲ သုံးပါတယ်:
- Candidate တစ်ခုစီက D, A, E, B, C လိုမျိုး မှတ်တိုင်တွေကို ဝင်မယ့် အစဉ်ပါ။
- Fitness ကို လမ်းကြောင်းရဲ့ စုစုပေါင်း အကွာအဝေးကနေ ရပါတယ်: လမ်းကြောင်း တိုလေ fitness မြင့်လေပါ။
- Crossover က လမ်းကြောင်း နှစ်ခုကို ရိုးရိုး ဖြတ်ပြီး အပိုင်းတွေကို ဆက်လို့ မရပါဘူး၊ ဘာလို့လဲဆိုတော့ child က မှတ်တိုင် တစ်ခုကို နှစ်ကြိမ် ဝင်ပြီး နောက်တစ်ခုကို လွတ်သွားနိုင်လို့ပါ။ လမ်းကြောင်း စီစဉ်ဖို့ genetic algorithm တွေက မှတ်တိုင် တိုင်းကို တစ်ကြိမ်တည်း အတိအကျ ပါအောင် လုပ်တဲ့ crossover နည်းတွေနဲ့ မှတ်တိုင် နှစ်ခုကို နေရာချင်း လဲတာလို မှတ်တိုင်တွေရဲ့ အစဉ်ကို ပြောင်းတဲ့ mutation တွေကို သုံးပါတယ်။
ဖြစ်နိုင်တဲ့ လမ်းကြောင်း အရေအတွက်က အရမ်း မြန်မြန် တိုးပါတယ်: မှတ်တိုင် 10 ခုကို မတူတဲ့ အစဉ် 3,628,800 မျိုး (10 × 9 × 8 × … × 1) နဲ့ ဝင်လို့ရပြီး မှတ်တိုင် 20 ခုဆိုရင် အစဉ် 2,000,000,000,000,000,000 ထက် ပိုများပါတယ်။
အသုံးချပုံ: ပစ္စည်းပို့ ကားတွေအတွက် လမ်းကြောင်း စီစဉ်တာ၊ အချိန်ဇယားတွေနဲ့ အလုပ်တာဝန် အလှည့်ကျ ဇယားတွေ ဆွဲတာ၊ စက်အစိတ်အပိုင်းတွေနဲ့ အဆောက်အအုံ ဖွဲ့စည်းပုံတွေကို ဒီဇိုင်းဆွဲတာ၊ machine learning model တွေ အပါအဝင် တခြား စနစ်တွေရဲ့ setting တွေကို ချိန်ညှိတာ တို့ ဖြစ်ပါတယ်။
ကိုယ်တိုင် စမ်းကြည့်ပါ: genetic algorithm simulator က ကျပန်း စာသားကို ကိုယ် ရိုက်ထည့်တဲ့ ပစ်မှတ် စကားစု (target phrase) ဆီ ဆင့်ကဲ ပြောင်းလဲ သွားစေပါတယ်။ သူ့ရဲ့ fitness က ပစ်မှတ်နဲ့ ကိုက်တဲ့ စာလုံးတွေကို ရေတွက်ပါတယ်။ တကယ့် ပြဿနာမှာ အကောင်းဆုံး အဖြေကို ကြိုတင် မသိတာ များပါတယ်၊ simulator က တိုးတက်မှုကို မြင်ရအောင် ပစ်မှတ်ကို သုံးတာပါ။ Generation တစ်ခုပြီး တစ်ခု fitness တက်လာတာကို ကြည့်ပြီး mutation rate (စာလုံး တစ်လုံးစီ ပြောင်းနိုင်ခြေ) ကို ပြောင်းကာ ရှာဖွေမှုကို ဘယ်လို အကျိုးသက်ရောက်လဲ ကြည့်ပါ။
ရိုးရှင်းတဲ့ arcade ဂိမ်း တစ်ခု ကစားနိုင်ဖို့ neural network တွေကို ဆင့်ကဲ ပြောင်းလဲစေတဲ့ lab video ပါ: generation တိုင်းမှာ ရမှတ် အများဆုံး network တွေကို ရွေးပြီး copy ကူးကာ mutation လုပ်ပါတယ်။ Fitness၊ selection နဲ့ mutation ကို ပြပါတယ်၊ crossover ကိုတော့ မသုံးပါဘူး။
Quick Check (အမြန် စစ်ဆေးမေးခွန်း)
Q1. သီချင်း app တစ်ခုက သူ့ editor တွေ label တပ်ပြီးသား သီချင်းတွေကို သုံးကာ သီချင်းအသစ် တစ်ပုဒ်စီကို "calm" (တည်ငြိမ်) ဒါမှမဟုတ် "energetic" (တက်ကြွ) လို့ label တပ်ဖို့ k = 5 နဲ့ k-NN ကို သုံးပါတယ်။ သီချင်းအသစ် တစ်ပုဒ်ကို ဘယ်လို label တပ်သလဲ။
Q2. k-NN model တစ်ခုက ဝန်ထမ်းတွေ label တပ်ပြီးသား email တွေကို သုံးကာ email အသစ် တစ်စောင်စီကို "urgent" (အရေးပေါ်) ဒါမှမဟုတ် "not urgent" (အရေးမပေါ်) လို့ label တပ်ပါတယ်။ သူ့ developer ကို k = 4 အစား k = 5 သုံးဖို့ အကြံပေးကြပါတယ်။ အကြောင်းရင်းက ဘာလဲ။
Q3. ဝယ်သူ 300 ရဲ့ ဈေးဝယ် ဒေတာပေါ်မှာ run နေတဲ့ k-means က ဝယ်သူ တိုင်းကို centroid သုံးခုထဲက အနီးဆုံး centroid ရဲ့ cluster ထဲ ထည့်ပြီးပါပြီ။ Algorithm က နောက်ထပ် ဘာလုပ်သလဲ။
Q4. အားကစား ပစ္စည်းဆိုင် တစ်ဆိုင်က တစ်နှစ်စာ online အော်ဒါတွေပေါ်မှာ association rule learning ကို run ပါတယ်။ ဘယ်ရလဒ်ကို ထုတ်ပေးနိုင်သလဲ။
Q5. အစားအသောက် ပို့ဆောင်ရေး app တစ်ခုရဲ့ agent က ခရီးစဉ် တစ်ခုစီအတွက် လမ်းကြောင်း လေးခုထဲက တစ်ခုကို ရွေးပါတယ်။ အခုထိ လမ်းကြောင်း 2 က အမြန်ဆုံး ဖြစ်ခဲ့ပေမယ့် လမ်းကြောင်း 3 နဲ့ 4 ကို တစ်ကြိမ်စီပဲ စမ်းဖူးပါသေးတယ်။ ဒီမှာ exploration versus exploitation trade-off က ဘာလဲ။
Q6. စနေ၊ တနင်္ဂနွေ ဈေးတစ်ခုမှာ ဆိုင်ခန်း တစ်ခုစီ ဘယ်နေရာမှာ ထားမလဲ စီစဉ်ပေးတဲ့ genetic algorithm မှာ fitness function ရဲ့ အလုပ်က ဘာလဲ။
ဖော်ပြချက်နဲ့ Technique ကို တွဲပါ
ဖော်ပြချက် တစ်ခုစီက ဘယ် technique ကို ဆိုလိုလဲ အမည် ရေးပါ: k-NN၊ decision tree၊ k-means၊ association rules၊ reinforcement learning ဒါမှမဟုတ် genetic algorithm။ ဖော်ပြချက်တွေကို code comment (code ထဲမှာ ရှင်းပြချက်အဖြစ် ရေးထားတဲ့ စာ) အဖြစ် English လို ရေးထားပြီး အဖြေကိုလည်း English လို ရိုက်ထည့်ရပါမယ်။ ဖော်ပြချက် ငါးခုရဲ့ အဓိပ္ပာယ်က အစဉ်လိုက်:
- အနီးဆုံး label တပ်ထားတဲ့ အမှတ်တွေရဲ့ majority vote နဲ့ classify လုပ်တယ်
- Centroid တွေကို သူတို့ အမှတ်တွေရဲ့ ပျမ်းမျှဆီ ရွှေ့ပြီး label မပါတဲ့ ဒေတာကို အုပ်စုဖွဲ့တယ်
- Selection၊ crossover နဲ့ mutation ကို သုံးပြီး population ကို ဆင့်ကဲ ပြောင်းလဲစေတယ်
- Reward ရဖို့ action တွေ လုပ်ရင်း exploration နဲ့ exploitation ကို ချိန်ညှိပြီး သင်ယူတယ်
- ဖတ်ပြီး နားလည်လို့ရတဲ့ ဟုတ်/မဟုတ် မေးခွန်း အစဉ်နဲ့ classify လုပ်တယ်
ကွက်လပ်ရှေ့က Technique: ဆိုတာ technique ရဲ့ အမည် လို့ ဆိုလိုပါတယ်။
ကွက်လပ်တွေကို ဖြည့်ပါ။ အဖြေကို English လို ရိုက်ထည့်ပါ။
// Classifies by a majority vote of the nearest labelled points
// Technique:
// Groups unlabelled data by moving centroids to the average of their points
// Technique:
// Evolves a population using selection, crossover, and mutation
// Technique:
// Learns by acting for rewards and balancing exploration and exploitation
// Technique:
// Classifies with a readable sequence of yes/no questions
// Technique: Practice Exercises (လေ့ကျင့်ခန်းများ)
IB CS ကျောင်းသားတွေအတွက် မှတ်ချက်: ဒီစာမျက်နှာက learning statement (သင်ရိုးမှာ သင်ယူရမယ့် အချက် ဖော်ပြချက်) တွေမှာ Explain (A4.3.2) နဲ့ Describe (A4.3.4 ကနေ A4.3.7 အထိ) ဆိုတဲ့ command term (မေးခွန်းမှာ ဘာလုပ်ရမလဲ ပြတဲ့ ညွှန်ကြားချက် စကားလုံး) တွေကို သုံးပါတယ်။ အောက်က လေ့ကျင့်ခန်းတွေက နှစ်ခုလုံးကို လေ့ကျင့်ပေးပြီး အယူအဆတွေကို အခြေအနေ အသစ်တွေမှာ အသုံးချခိုင်းပါသေးတယ်။ ဒီမှာ ပါတဲ့ အကြောင်းအရာ အားလုံးက HL ပါ။
(4 marks) လို mark allocation (မေးခွန်း တစ်ခုစီအတွက် ပေးတဲ့ အမှတ်) တွေက IB Computer Science စာမေးပွဲ ပုံစံအတိုင်း ပေးထားတာပါ၊ ဥပမာ (4 marks) ဆိုတာ 4 မှတ်ပါ။ မေးခွန်း အပိုင်းတစ်ခုရဲ့ နောက်က [2] ဆိုတာလည်း အဲဒီ အပိုင်းအတွက် 2 မှတ် လို့ ဆိုလိုပါတယ်။ IB သင်တန်း မတက်တဲ့သူတွေကတော့ အဖြေ ဘယ်လောက် အသေးစိတ် ရေးရမလဲ ချိန်ကြည့်ဖို့ လမ်းညွှန်အဖြစ် သုံးနိုင်ပါတယ်။
Core (အခြေခံ အဆင့်)
-
Explain (4 marks): k-nearest neighbours က data point အသစ် တစ်ခုကို ဘယ်လို classify လုပ်လဲ ဆိုတာကို k ရဲ့ အခန်းကဏ္ဍ အပါအဝင် ရှင်းပြပါ။
-
Describe (4 marks): k-means clustering ရဲ့ ထပ်ခါထပ်ခါ လုပ်တဲ့ အဆင့် နှစ်ဆင့်နဲ့ အဲဒီ နည်းရဲ့ ကန့်သတ်ချက် တစ်ခုကို ဖော်ပြရှင်းပြပါ။
-
Describe (6 marks): ကိုယ်ပိုင် ဥပမာ တစ်ခု (ဒီစာမျက်နှာထဲက ဥပမာ မဟုတ်ဘဲ ကိုယ်တိုင် စဉ်းစားထားတဲ့ ဥပမာ) ကို သုံးပြီး reinforcement learning agent တစ်ခု ဆုံးဖြတ်ချက် ချတတ်အောင် ဘယ်လို သင်ယူလဲ ဖော်ပြရှင်းပြပါ။ Agent ရဲ့ state တွေ၊ action တွေနဲ့ reward တွေကို အမည် ဖော်ပြပြီး သူ့ policy နဲ့ သူ ရင်ဆိုင်ရတဲ့ exploration versus exploitation trade-off ကို ဖော်ပြရှင်းပြပါ။
Extension (တိုးချဲ့ အဆင့်)
-
Explain (6 marks): လယ်ယာ တစ်ခုက နောက်နှစ်မှာ သူ့ရဲ့ လယ်ကွက် 12 ကွက် တစ်ကွက်စီမှာ ဘယ်သီးနှံ စိုက်မလဲ ဆုံးဖြတ်ဖို့ genetic algorithm ကို သုံးပါတယ်။ စုစုပေါင်း အမြတ် အများဆုံး ရချင်ပြီး ဘယ်လယ်ကွက်မှာမှ သီးနှံ တစ်မျိုးတည်းကို နှစ်နှစ် ဆက်တိုက် စိုက်လို့ မရပါဘူး။ Candidate solution တစ်ခုစီက ဘာကို ကိုယ်စားပြုလဲ၊ ဒီ အသုံးချမှုမှာ fitness function၊ crossover နဲ့ mutation တို့ရဲ့ အခန်းကဏ္ဍတွေက ဘာလဲ ဆိုတာကို mutation ဘာကြောင့် အရေးကြီးလဲ ဆိုတာ အပါအဝင် ရှင်းပြပါ။
-
Evaluate (အားသာချက်နဲ့ အားနည်းချက်တွေကို ချိန်ဆပြီး အကဲဖြတ်ပါ) (6 marks): ဆုံးဖြတ်ချက် တစ်ခုစီရဲ့ နောက်ကွယ်က အကြောင်းပြချက်ကို ရှင်းပြနိုင်ရမယ့်၊ ကိုယ်ရွေးတဲ့ အလုပ် တစ်ခုအတွက် k-NN နဲ့ decision tree တွေကို evaluate လုပ်ပြီး တစ်ခုကို အကြံပြုပါ။
-
Explain (6 marks): ကျောင်း တစ်ကျောင်းရဲ့ IT help desk (IT အကူအညီ ပေးတဲ့ ဌာန) က တစ်နှစ်စာ support ticket (အကူအညီ တောင်းခံချက် မှတ်တမ်း) 2,000 ကို mining လုပ်ပါတယ်။ Ticket 300 မှာ projector ပါပြီး 400 မှာ cable (ကြိုး) ပါပါတယ်၊ 240 မှာ နှစ်ခုလုံး ပါပါတယ်။ (a) {projector} → {cable} rule ရဲ့ support နဲ့ confidence ကို Calculate (တွက်တဲ့ အဆင့်တွေကို ပြပြီး ဂဏန်း အဖြေ ရှာပါ) လုပ်ပါ။ [2] (b) Confidence က help desk ကို ဘာပြောပြလဲ၊ ဂဏန်းတွေက နှစ်ခုကြား တကယ့် ဆက်နွယ်မှု ရှိတာကို ပြလား ရှင်းပြပါ။ [2] (c) Help desk က projector ticket တိုင်းအတွက် technician (ပြင်ဆင်သူ) နဲ့အတူ အပို cable တစ်ချောင်း ထည့်ပေးလိုက်ဖို့ စီစဉ်ပါတယ်။ Rule ကို အားမကိုးခင် ထပ်စစ်သင့်တဲ့ အကြောင်းရင်း တစ်ခုကို ရှင်းပြပါ။ [2]
Challenge (စိန်ခေါ်မှု အဆင့်)
- Discuss (အမြင် အမျိုးမျိုးကို ချိန်ဆပြီး ဆွေးနွေးပါ) (8 marks): Supermarket တစ်ခုက (a) သူ့ ဝယ်သူတွေကို segment (ဆင်တူတဲ့ ဝယ်သူ အုပ်စု) တွေ ခွဲချင်ပြီး (b) ဘယ် ကုန်ပစ္စည်းတွေကို အတူတူ ဝယ်ကြလဲ ရှာဖော်ချင်ပါတယ်။ အလုပ် တစ်ခုစီအတွက် ဘယ် technique က သင့်တော်လဲ၊ ဘာကြောင့်လဲ ဆိုတာကို Explain လုပ်ပြီး ရလဒ် တစ်ခုစီနဲ့ ဆိုင်က တာဝန်ယူမှု ရှိရှိ ဘာလုပ်နိုင်လဲ ဆိုတာကို discuss လုပ်ပါ။ (စာပိုဒ် ပုံစံနဲ့ ရေးပါ။)
ဆက်စပ် ခေါင်းစဉ်များ
- အရင် လေ့လာထားရမယ့် ခေါင်းစဉ်: What Machine Learning Is (machine learning ဆိုတာ ဘာလဲ): ဒီ technique တွေက ပိုနက်နက် ချဲ့ထွင် လေ့လာတဲ့ ခြုံငုံ မိတ်ဆက်
- နောက်ထပ် လေ့လာမယ့် ခေါင်းစဉ်: Training and Evaluating a Model (model ကို train လုပ်ခြင်းနဲ့ အကဲဖြတ်ခြင်း): ဒီ model တွေထဲက ဘယ်တစ်ခုကိုမဆို ဘယ်လို တည်ဆောက်ပြီး ဘယ်လို အကဲဖြတ်လဲ
- ဆက်စပ် ခေါင်းစဉ်: Ethics of Machine Learning (machine learning ရဲ့ ကျင့်ဝတ်): ဒီ technique တွေက တကယ့် ဆုံးဖြတ်ချက်တွေ ချတဲ့အခါ တရားမျှတမှုနဲ့ တာဝန်ခံမှု
- ဆက်စပ် ခေါင်းစဉ်: Data Warehouses (ခွဲခြမ်းစိတ်ဖြာဖို့ ယခင် ဒေတာ သိုလှောင်ရုံများ): အဖွဲ့အစည်း တစ်ခုက သိမ်းထားတဲ့ ဒေတာပေါ်မှာ classification၊ clustering နဲ့ association rule တွေကို သုံးတဲ့ data mining (ဒေတာ အများကြီးထဲက ပုံစံတွေကို ရှာဖွေခြင်း) (A3.4.3)
- ဆက်စပ် ခေါင်းစဉ်: Algorithms (အယ်လ်ဂိုရီသမ်များ): linear search (တစ်ခုချင်း ဆက်တိုက် ရှာနည်း) နဲ့ binary search (တစ်ဝက်စီ ခွဲပြီး ရှာနည်း)၊ genetic algorithm ကလည်း ရှာပါတယ်၊ ဒါပေမယ့် list တစ်ခုထဲမှာ မဟုတ်ဘဲ ဖြစ်နိုင်တဲ့ ဖြေရှင်းချက်တွေထဲမှာ ရှာတာပါ
- ထပ်ဆောင်း လေ့လာစရာ (IB စာမေးပွဲမှာ မပါ): AI Beyond Machine Learning (machine learning ထက် ကျော်လွန်တဲ့ AI (ဉာဏ်ရည်တု)): game ရှာဖွေမှုမှာ exploration versus exploitation။ အဲဒီ စာမျက်နှာရဲ့ ဝေါဟာရ မှတ်ချက်ကို A4.3.2 မတိုင်ခင် ဖတ်ထားသင့်ပါတယ်: classical AI (ရိုးရာ AI) မှာ “decision tree” ဆိုတာ လူက လက်နဲ့ ရေးထားတဲ့ flowchart (လုပ်ငန်းစဉ်ကို သင်္ကေတတွေနဲ့ ဆွဲပြတဲ့ ပုံ) ကို ဆိုလိုနိုင်ပြီး A4.3.2 ထဲက ဒေတာကနေ သင်ယူထားတဲ့ classifier (classify လုပ်ပေးတဲ့ model) နဲ့ မတူပါဘူး။