Training and Evaluating a Model (Model ကို train လုပ်ခြင်းနဲ့ အကဲဖြတ်ခြင်း)
A4.2.1: Describe the significance of data cleaning. A4.2.2: Describe the role of feature selection. A4.2.3: Describe the importance of dimensionality reduction. A4.3.1: Explain how linear regression is used to predict continuous outcomes. A4.3.3: Explain the role of hyperparameter tuning when evaluating supervised learning algorithms (accuracy, precision, recall and F1 score; overfitting and underfitting). A4.3.9: Describe how CNNs are designed to adaptively learn spatial hierarchies of features in images. A4.3.10: Explain the importance of model selection and comparison in machine learning. HL only.
မြန်မာလို: A4.2.1: data cleaning (train မလုပ်ခင် ဒေတာကို သန့်ရှင်းအောင် ပြင်ခြင်း) ဘာကြောင့် အရေးပါလဲ ဖော်ပြရှင်းပြနိုင်ရပါမယ်။ A4.2.2: feature selection (model သင်ယူမယ့် input တွေကို ရွေးခြင်း) ရဲ့ အခန်းကဏ္ဍကို ဖော်ပြရှင်းပြနိုင်ရပါမယ်။ A4.2.3: dimensionality reduction (အရေးကြီးတာ မပျောက်ဘဲ feature အရေအတွက် လျှော့ခြင်း) ရဲ့ အရေးပါပုံကို ဖော်ပြရှင်းပြနိုင်ရပါမယ်။ A4.3.1: continuous (အပိုင်းအခြား တစ်ခုထဲက ဘယ်တန်ဖိုးမဆို ဖြစ်နိုင်တဲ့) ရလဒ်တွေကို ခန့်မှန်းဖို့ linear regression (ဒေတာကြား မျဉ်းဖြောင့် ဆွဲပြီး ခန့်မှန်းခြင်း) ကို ဘယ်လို သုံးလဲ ရှင်းပြနိုင်ရပါမယ်။ A4.3.3: supervised learning (label တပ်ထားတဲ့ ဥပမာတွေကနေ သင်ယူခြင်း) algorithm (အယ်လ်ဂိုရီသမ်၊ ပြဿနာကို အဆင့်ဆင့် ဖြေရှင်းတဲ့ နည်းလမ်း) တွေကို အကဲဖြတ်တဲ့အခါ hyperparameter (train မလုပ်ခင် ရွေးထားရတဲ့ setting) တွေကို tuning (ချိန်ညှိခြင်း) လုပ်တာရဲ့ အခန်းကဏ္ဍကို ရှင်းပြနိုင်ရပါမယ်။ ဒီထဲမှာ accuracy (ခန့်မှန်းချက် မှန်တဲ့ အချိုး)၊ precision (model က “yes” လို့ ပြောတာတွေထဲက တကယ် မှန်တဲ့ အချိုး)၊ recall (တကယ့် “yes” တွေထဲက model ဖမ်းမိတဲ့ အချိုး)၊ F1 score (precision နဲ့ recall ကို ချိန်ညှိတဲ့ အမှတ်)၊ overfitting (training ဒေတာကို အလွတ်ကျက်သလို သင်ယူမိခြင်း) နဲ့ underfitting (model ရိုးလွန်းလို့ ပုံစံကို မဖမ်းမိခြင်း) တို့ ပါပါတယ်။ A4.3.9: CNN (ပုံတွေအတွက် deep network) တွေက ပုံတွေထဲက feature တွေရဲ့ spatial hierarchy (နေရာအလိုက် ရိုးရှင်းရာကနေ ရှုပ်ထွေးရာအထိ အဆင့်ဆင့်) ကို adaptively (train လုပ်ရင်း ကိုယ်တိုင် ညှိပြီး) သင်ယူနိုင်အောင် ဘယ်လို ဒီဇိုင်းထုတ်ထားလဲ ဖော်ပြရှင်းပြနိုင်ရပါမယ်။ A4.3.10: machine learning (ဒေတာကနေ သင်ယူတဲ့ စနစ်) မှာ model selection (model တွေကို နှိုင်းယှဉ်ပြီး ရွေးချယ်ခြင်း) နဲ့ model တွေကို နှိုင်းယှဉ်ခြင်း ဘာကြောင့် အရေးပါလဲ ရှင်းပြနိုင်ရပါမယ်။ ဒီ အပိုင်းအားလုံးက HL အတွက်သာ ဖြစ်ပါတယ်။
ဒီစာမျက်နှာက HL အတွက်ပဲ ဖြစ်ပါတယ်။ SL (Standard Level) နဲ့ HL (Higher Level) ဆိုတာ IB Computer Science (နိုင်ငံတကာ ကျောင်းတွေမှာ သင်တဲ့ ကွန်ပျူတာသိပ္ပံ သင်ရိုး) သင်တန်းရဲ့ အဆင့်နှစ်ဆင့်ဖြစ်ပြီး HL အပိုင်းတွေက ပိုနက်နက်ရှိုင်းရှိုင်း လေ့လာရတဲ့ အပိုင်းတွေပါ။ ဒီစာမျက်နှာမှာ ဒေတာကို ပြင်ဆင်တာ၊ model (ဒေတာကနေ သင်ယူထားပြီး ခန့်မှန်းပေးတဲ့ အရာ) တွေကို train (ဒေတာနဲ့ လေ့ကျင့်ပေးခြင်း) လုပ်တာနဲ့ သူတို့ရဲ့ စွမ်းဆောင်ရည်ကို အကဲဖြတ်တာတွေကို လေ့လာပါမယ်။ SL နဲ့ HL နှစ်ဆင့်လုံးအတွက် ခြုံငုံ မိတ်ဆက်ကို What Machine Learning Is (machine learning ဆိုတာ ဘာလဲ) မှာ ကြည့်ပါ။
မာတိကာ
- ခြုံငုံ မိတ်ဆက်
- အဆင့် 1: ဒေတာကို ပြင်ဆင်ခြင်း
- အဆင့် 2: Linear Regression နဲ့ model ကို train လုပ်ခြင်း (A4.3.1)
- အဆင့် 3: Model ကို အကဲဖြတ်ခြင်း (A4.3.3)
- အဆင့် 4: CNN တွေနဲ့ ပုံတွေအတွက် Deep Learning (A4.3.9)
- အဆင့် 5: Model တွေထဲက ရွေးချယ်ခြင်း (A4.3.10)
- Quick Check (အမြန် စစ်ဆေးမေးခွန်း)
- Match the Concept (သဘောတရားနဲ့ တွဲပါ)
- Practice Exercises (လေ့ကျင့်ခန်းများ)
- ဆက်စပ် ခေါင်းစဉ်များ
ခြုံငုံ မိတ်ဆက်
Machine learning model တစ်ခု တည်ဆောက်ရာမှာ အဓိက အဆင့် လေးဆင့် ပါပါတယ်: ဒေတာကို ပြင်ဆင်တာ၊ model ကို train လုပ်တာ၊ သူ့ရဲ့ စွမ်းဆောင်ရည်ကို အကဲဖြတ်တာ နဲ့ တခြား ရွေးစရာ model တွေနဲ့ နှိုင်းယှဉ်တာ တို့ပါ။ ဘယ်အဆင့်ကိုမဆို ညံ့ညံ့ လုပ်မိရင် algorithm ကောင်းကောင်းကတောင် လက်တွေ့ သုံးတဲ့အခါ ကျရှုံးတဲ့ model ကို ထုတ်ပေးနိုင်ပါတယ်။ အဲဒီ ကျရှုံးမှုတွေကလည်း သတိမထားမိဘဲ လွတ်သွားလွယ်ပါတယ်။
ဒီစာမျက်နှာရဲ့ အဆင့် 1၊ 2၊ 3 နဲ့ 5 က ဒီ အဆင့် လေးဆင့်ကို လေ့လာပါတယ်။ ဒေတာ အရည်အသွေး၊ train လုပ်ပုံ ရွေးချယ်မှုတွေနဲ့ အကဲဖြတ်နည်းတွေက ရလဒ်တွေကို ဘယ်လို သက်ရောက်လဲ ဆိုတာလည်း ပါပါတယ်။ ကြားထဲက အဆင့် 4 ကတော့ ပုံတွေအတွက် တည်ဆောက်ထားတဲ့ model အမျိုးအစား တစ်ခုဖြစ်တဲ့ convolutional neural network (CNN) ကို အနီးကပ် လေ့လာပါတယ်။ အဆင့်တိုင်းမှာ စစ်ရမယ့် အချက် နှစ်ခု ရှိပါတယ်: ကိုယ့်ဒေတာက သင်ယူဖို့ လုံလောက်အောင် ကောင်းရဲ့လား ဆိုတာနဲ့ model က သူ train လုပ်ခဲ့တဲ့ ဒေတာပေါ်မှာ ဘယ်လောက် ကောင်းပုံပေါ်လဲ ဆိုတာထက် ဒေတာ အသစ်ပေါ်မှာ တကယ် ဘယ်လောက် ကောင်းကောင်း အလုပ်လုပ်လဲ ဆိုတာပါ။
ကိုယ်တိုင် စမ်းကြည့်ပါ: machine learning simulator တွေ (တကယ့် ဖြစ်စဉ်ကို ကွန်ပျူတာနဲ့ အတုလုပ်ပြတဲ့ tool တွေ) မှာ regression (ကိန်းဂဏန်း တန်ဖိုးကို ခန့်မှန်းခြင်း)၊ overfitting၊ evaluation metric (model ကို အကဲဖြတ်ဖို့ တိုင်းတာတဲ့ စံ) တွေနဲ့ CNN တွေအတွက် demo တွေ ပါပါတယ်။
အဆင့် 1: ဒေတာကို ပြင်ဆင်ခြင်း
Train မလုပ်ခင် ဒေတာထဲမှာ အမှားတွေ ရှိမရှိ စစ်ပြီး model က ဘယ် feature (model ကြည့်ပြီး သင်ယူတဲ့ input တစ်ခု) တွေကို သုံးမလဲ ဆုံးဖြတ်ပါ။ Model က သူ့ဒေတာထဲမှာ ပါတာကနေပဲ သင်ယူနိုင်တာမို့ ဒေတာရဲ့ အရည်အသွေးက model ရဲ့ အရည်အသွေးကို ကန့်သတ်ပါတယ်။
Data cleaning (train မလုပ်ခင် ဒေတာကို သန့်ရှင်းအောင် ပြင်ခြင်း၊ A4.2.1)
လက်တွေ့ ဒေတာက ရှုပ်ပွနေတတ်ပါတယ်: တန်ဖိုးတွေ ပျောက်နေတယ်၊ record (အချက်အလက် အများကြီး စုထားတဲ့ ဒေတာ တစ်ခု) တွေ ထပ်နေတယ်၊ တချို့ ထည့်ထားတာတွေက ရိုးရိုး အမှားတွေ ဖြစ်ပြီး တချို့က outlier တွေပါ။ Outlier ဆိုတာ တခြား တန်ဖိုး အားလုံးနဲ့ အများကြီး ကွာနေတဲ့ တန်ဖိုးတွေဖြစ်ပြီး အမှား ဖြစ်နိုင်သလို တကယ့် တန်ဖိုးလည်း ဖြစ်နိုင်ပါတယ်။ Data cleaning ဆိုတာ train မလုပ်ခင် ဒီ ပြဿနာတွေကို ရှာပြီး ပြင်တာပါ။
Model က သူ့ဒေတာထဲမှာ ပါသမျှကို အမှားတွေ အပါအဝင် သင်ယူတာမို့ data cleaning က အရေးကြီးပါတယ်။ ဒါက “garbage in, garbage out” (အမှိုက် ထည့်ရင် အမှိုက်ပဲ ထွက်မယ်) ဆိုတဲ့ စကားရဲ့ အယူအဆပါ၊ ဒါပေမယ့် နောက်ထပ် အန္တရာယ် တစ်ခု ရှိပါသေးတယ်: training data (model သင်ယူဖို့ ပေးတဲ့ ဒေတာ) ထဲက အမှားတွေက model သင်ယူတဲ့ ပုံစံတွေကို ပုံပျက်စေပြီး ဒေတာ အသစ်ပေါ်မှာ သူ့ရဲ့ accuracy ကို လျော့ကျစေနိုင်ပါတယ်။ အမှားတွေနဲ့ noise (တန်ဖိုးတွေထဲက ကျပန်း ကွဲလွဲမှု) တွေက တကယ့် ပုံစံကို ဖုံးကွယ်ထားနိုင်သလို model ကို အလွတ်ကျက်စရာ ပုံစံအတုတွေလည်း ပေးနိုင်ပါတယ်။ ဒါက overfitting ကို ဖြစ်စေနိုင်ပါတယ်: model က သူ့ training data နဲ့ အရမ်း ကပ်ကပ် ကိုက်ညီအောင် သင်ယူမိလို့ ဒေတာ အသစ်ပေါ်မှာ ညံ့သွားတာပါ (အဆင့် 3)။
အစားအစာ ပို့ဆောင်ရေး ကုမ္ပဏီ တစ်ခုက အရင် order တွေရဲ့ record တွေကို သုံးပြီး ပို့ဆောင်မှု တစ်ခု ဘယ်လောက် ကြာမလဲ ခန့်မှန်းတဲ့ model တစ်ခုကို train လုပ်ပါတယ်။ အောက်က ဇယားမှာ အဲဒီ record တွေထဲမှာ တွေ့နိုင်တဲ့ ပြဿနာတွေနဲ့ တစ်ခုချင်းစီကို ပုံမှန် ကိုင်တွယ်ပုံတွေကို ပြထားပါတယ်။
| ပြဿနာ | ပို့ဆောင်မှု record တွေထဲမှာ | ကိုင်တွယ်ပုံ |
|---|---|---|
| Duplicate data (ထပ်နေတဲ့ ဒေတာ) | App က order 5013 ကို နှစ်ခါ ပို့လိုက်လို့ အဲဒီ order က အသေးစိတ် အတူတူနဲ့ နှစ်ခါ ပါနေပါတယ် | ပိုနေတဲ့ copy တွေကို ဖယ်ပါ။ Record နှစ်ခုက order တစ်ခုတည်းကို အသေးစိတ် နည်းနည်း မတူဘဲ ဖော်ပြနေရင် record တစ်ခုတည်း ဖြစ်အောင် consolidate (ပေါင်းစည်း) လုပ်ပါ |
| Incorrect data (မှားနေတဲ့ ဒေတာ) | ပို့ဆောင်မှု တစ်ခုက -4 မိနစ် ကြာတယ်လို့ ပြနေပါတယ်။ နောက် order တစ်ခုရဲ့ လိပ်စာက မြို့ရဲ့ တစ်ဖက်ခြမ်းမှာ ရှိပေမယ့် အကွာအဝေး 0 မီတာ လို့ ပြနေပါတယ် | Validation rule (တန်ဖိုး တိုင်း ကိုက်ညီရမယ့် စစ်ဆေးချက်၊ ဥပမာ “ပို့ဆောင်ချိန်က 0 ထက် ကြီးရမယ်” ဒါမှမဟုတ် “အကွာအဝေးက လိပ်စာနဲ့ ကိုက်ညီရမယ်”) ကို ချိုးဖောက်တဲ့ တန်ဖိုးတွေ၊ ဒါမှမဟုတ် driver ရဲ့ လမ်းကြောင်း မှတ်တမ်း လို တခြား ရင်းမြစ် တစ်ခုနဲ့ မကိုက်ညီတဲ့ တန်ဖိုးတွေကို ရှာပါ။ အဲဒီ ရင်းမြစ်ကနေ ပြင်ပါ၊ ဒါမှမဟုတ် ဖယ်ပါ |
| Outliers (တခြား တန်ဖိုးတွေနဲ့ အများကြီး ကွာနေတဲ့ တန်ဖိုးများ) | ပို့ဆောင်မှု အားလုံးနီးပါးက 10 မိနစ်ကနေ 45 မိနစ်အထိ ကြာပေမယ့် တစ်ခုက 190 မိနစ် ကြာပါတယ် | ဒေတာကို graph ဆွဲကြည့်တာ၊ ဒါမှမဟုတ် “mean (ပျမ်းမျှ) ကနေ standard deviation (စံသွေဖည်ချက်) သုံးဆထက် ပိုဝေးတာ” လို စည်းမျဉ်း တစ်ခုနဲ့ စစ်တာမျိုးနဲ့ ကျန်တဲ့ တန်ဖိုးတွေနဲ့ ဝေးနေတဲ့ တန်ဖိုးတွေကို ရှာပါ။ ပြီးရင် တစ်ခုချင်းစီက ဘာလဲ ဆုံးဖြတ်ပါ: စာရိုက် အမှား ဆိုရင် ပြင်ပါ ဒါမှမဟုတ် ဖယ်ပါ။ ရေကြီးလို့ လမ်းပိတ်တာ လို တကယ် ဖြစ်ခဲ့ပေမယ့် ရှားတဲ့ ဖြစ်ရပ် ဆိုရင် ထားခဲ့နိုင်ပါတယ်၊ ဒါမှမဟုတ် model အပေါ် သက်ရောက်မှု အရမ်း မများအောင် အမြင့်ဆုံး တန်ဖိုး တစ်ခုမှာ ကန့်သတ် (cap လုပ်) ထားနိုင်ပါတယ် |
| Irrelevant data (မသက်ဆိုင်တဲ့ ဒေတာ) | ဖောက်သည်တွေက ကောင်တာကနေ ကိုယ်တိုင် လာယူသွားလို့ ပို့ဆောင်မှု မရှိခဲ့တဲ့ order တွေ၊ ဖောက်သည် နာမည်တွေ ပါတဲ့ column (ကော်လံ) တစ်ခု | အလုပ်နဲ့ ဘာမှ မဆိုင်တဲ့ record တွေနဲ့ column တွေကို filter out (စစ်ထုတ်ပြီး ဖယ်) လုပ်ပါ။ Model အတွက် မလိုတဲ့ ကိုယ်ရေး အချက်အလက်တွေကို ဖယ်တာက privacy (ကိုယ်ရေး အချက်အလက် လုံခြုံမှု) ကိုလည်း ကာကွယ်ပေးပါတယ် |
| Improperly formatted data (format မမှန်တဲ့ ဒေတာ) | အကွာအဝေး တချို့ကို “2.4 km” လို့ ရိုက်ထားပြီး တချို့ကို “2400” လို့ ရိုက်ထားပါတယ်။ ရက်စွဲတွေက 03/04/2026 ပုံစံနဲ့ရော 2026-04-03 ပုံစံနဲ့ပါ ပါနေပါတယ် | တန်ဖိုး တိုင်းကို format တစ်မျိုးတည်း၊ unit (ယူနစ်) တစ်မျိုးတည်း ဖြစ်အောင် transform (ပုံစံ ပြောင်း) လုပ်ပါ (အကွာအဝေး အားလုံးကို မီတာနဲ့၊ ရက်စွဲ အားလုံးကို နှစ်-လ-ရက် ပုံစံနဲ့)၊ ဒါမှ တန်ဖိုး တစ်ခုတည်းကို ပုံစံ တစ်မျိုးတည်းနဲ့ပဲ အမြဲ ရေးထားမှာပါ |
| Missing data (ပျောက်နေတဲ့ ဒေတာ) | Order 12,000 ထဲက 60 မှာ အကွာအဝေး ကွက်လပ် ဖြစ်နေပါတယ် | Imputation (ခန့်မှန်း တန်ဖိုး ဖြည့်ခြင်း): အကွာအဝေးရဲ့ median (အလယ် တန်ဖိုး)၊ ဒါမှမဟုတ် လိပ်စာ တစ်ခုတည်းကို အရင်က ပို့ခဲ့တဲ့ order ရဲ့ အကွာအဝေး လို ခန့်မှန်း တန်ဖိုး တစ်ခုကို ဖြည့်ပါ။ Deletion (ဖျက်ခြင်း): အဲဒီ record 60 ခုကို ဖယ်ပါ (column တစ်ခုရဲ့ တန်ဖိုး အများစု ပျောက်နေရင် column တစ်ခုလုံးကို ဖယ်ပါ)။ Predictive modelling (သီးခြား model နဲ့ ခန့်မှန်းပြီး ဖြည့်ခြင်း): ပို့ရမယ့် နေရာရဲ့ postcode (စာပို့ သင်္ကေတ နံပါတ်) လို တခြား column တွေကနေ ပျောက်နေတဲ့ အကွာအဝေးကို ခန့်မှန်းဖို့ သီးခြား model တစ်ခုကို train လုပ်ပါ |
ဘယ် ပြင်နည်းက မှန်လဲ ဆိုတာ ဒေတာနဲ့ အလုပ်ပေါ် မူတည်ပါတယ်။ Deletion က ရိုးရှင်းပေမယ့် အချက်အလက်တွေကို လွှင့်ပစ်ရပါတယ်။ ပြီးတော့ ပျောက်နေတဲ့ တန်ဖိုးတွေက ကျပန်း ပြန့်နေတာ မဟုတ်ရင် (ဥပမာ အများစုက မြို့ရဲ့ အပိုင်း တစ်ခုတည်းက လာရင်) model က အဲဒီ နေရာ အကြောင်း ပိုနည်းနည်းပဲ သိသွားပါတယ်။ Imputation က record တိုင်းကို ထားပေမယ့် ဘယ်သူမှ တကယ် မတိုင်းခဲ့တဲ့ တန်ဖိုးတွေကို ထည့်ပါတယ်။
Feature တွေကို scale လုပ်ခြင်း: normalisation နဲ့ standardisation
Model အများအပြားက feature အများကြီးကို တွက်ချက်မှု တစ်ခုတည်းမှာ ပေါင်းသုံးကြပါတယ်။ အဲဒီအခါ unit ကြီးကြီးနဲ့ တိုင်းထားတဲ့ feature က unit သေးသေးနဲ့ တိုင်းထားတဲ့ feature ထက် ပိုလွှမ်းမိုးသွားနိုင်ပါတယ်။ ပို့ဆောင်မှု တစ်ခုရဲ့ မီတာနဲ့ တိုင်းထားတဲ့ အကွာအဝေး (ရာဂဏန်း ဒါမှမဟုတ် ထောင်ဂဏန်း) နဲ့ order ထဲက ပစ္စည်း အရေအတွက် (1 ကနေ 20) ကို ကြည့်ပါ။ k-nearest neighbours (k-NN၊ အနီးဆုံး k ခုနဲ့ ဆုံးဖြတ်ခြင်း) လို order နှစ်ခု ဘယ်လောက် ဆင်တူလဲ တိုင်းတဲ့ model က 1,000 မီတာ ကွာတာကို ပစ္စည်း 10 ခု ကွာတာထက် အများကြီး ပိုကြီးတယ်လို့ သဘောထားပါတယ်၊ unit ကြောင့် သက်သက်ပါ။ Scaling (feature တွေကို တန်ဖိုး အပိုင်းအခြား ဆင်တူအောင် ပြောင်းခြင်း) က train မလုပ်ခင် feature တွေကို ဆင်တူတဲ့ range (တန်ဖိုး အပိုင်းအခြား) တွေ ဖြစ်အောင် ပြောင်းပေးတာမို့ ဘယ် feature က အရေးအကြီးဆုံးလဲ ဆိုတာကို unit တွေက မဆုံးဖြတ်တော့ပါဘူး။ အသုံးများတဲ့ နည်း နှစ်မျိုး ရှိပါတယ်:
- Normalisation (min-max scaling) (တန်ဖိုးတွေကို 0 ကနေ 1 ကြား ပြောင်းခြင်း) က feature တစ်ခုကို 0 ကနေ 1 အထိ range ထဲ ပြန် scale လုပ်ပါတယ်: new value = (value - minimum) ÷ (maximum - minimum)၊ ဆိုလိုတာက တန်ဖိုး အသစ် = (တန်ဖိုး - အငယ်ဆုံး) ÷ (အကြီးဆုံး - အငယ်ဆုံး) ပါ။ အငယ်ဆုံး တန်ဖိုးက 0 ဖြစ်လာပြီး အကြီးဆုံး တန်ဖိုးက 1 ဖြစ်လာပါတယ်။
- Standardisation (z-scores) (mean 0၊ standard deviation 1 ဖြစ်အောင် ပြောင်းခြင်း) က feature တစ်ခုကို သူ့ရဲ့ mean က 0 ဖြစ်ပြီး standard deviation (တန်ဖိုးတွေ ဘယ်လောက် ပြန့်ကျဲနေလဲ တိုင်းတဲ့ တန်ဖိုး) က 1 ဖြစ်အောင် ပြန် scale လုပ်ပါတယ်: z = (value - mean) ÷ standard deviation။ z-score က တန်ဖိုး တစ်ခုဟာ mean ထက် standard deviation ဘယ်နှစ်ခုစာ အပေါ်မှာ (positive) ဒါမှမဟုတ် အောက်မှာ (negative) ရှိလဲ ဆိုတာကို ပြောပြပါတယ်။
Worked example (အဆင့်ဆင့် ဖြေရှင်းပြထားတဲ့ ဥပမာ): order A ကနေ D အထိ လေးခု ရှိပါတယ်။ သူတို့ရဲ့ အကွာအဝေးတွေက အငယ်ဆုံး 600 m ကနေ အကြီးဆုံး 9,600 m အထိ ရှိပြီး range က 9,000 m ပါ။ Order လေးခုထဲက ပစ္စည်း အရေအတွက်တွေရဲ့ mean က 10 ဖြစ်ပြီး standard deviation က 5 ပါ။ (ဒီမှာ population standard deviation ကို သုံးထားပါတယ်: scikit-learn (Python အတွက် machine learning library) ရဲ့ StandardScaler လုပ်သလိုပဲ တန်ဖိုး အရေအတွက် ဖြစ်တဲ့ 4 နဲ့ စားပါတယ်။)
| Order | အကွာအဝေး (m) | အကွာအဝေး၊ normalise လုပ်ပြီး | ပစ္စည်း အရေအတွက် | ပစ္စည်း အရေအတွက်၊ standardise လုပ်ပြီး |
|---|---|---|---|---|
| A | 600 | (600 - 600) ÷ 9,000 = 0 | 3 | (3 - 10) ÷ 5 = -1.4 |
| B | 2,400 | (2,400 - 600) ÷ 9,000 = 0.2 | 9 | (9 - 10) ÷ 5 = -0.2 |
| C | 4,200 | (4,200 - 600) ÷ 9,000 = 0.4 | 11 | (11 - 10) ÷ 5 = 0.2 |
| D | 9,600 | (9,600 - 600) ÷ 9,000 = 1 | 17 | (17 - 10) ÷ 5 = 1.4 |
Scale လုပ်ပြီးတဲ့အခါ feature နှစ်ခုလုံးက ဆင်တူတဲ့ range တွေ ဖြစ်သွားလို့ unit ကြောင့် ဘယ်တစ်ခုကမှ မလွှမ်းမိုးတော့ပါဘူး။ Normalisation က training data ပေါ်မှာ feature တစ်ခုစီကို 0 ကနေ 1 အထိ range ပေးပါတယ် (record တိုင်းမှာ တန်ဖိုး တူနေတဲ့ feature ကို ဒီနည်းနဲ့ scale လုပ်လို့ မရပါဘူး၊ အဲဒီ feature က record တွေကို ခွဲခြားဖို့ model ကို မကူညီနိုင်လို့ ပုံမှန်အားဖြင့် ဖယ်လိုက်ပါတယ်)။ Training data ရဲ့ အငယ်ဆုံးထက် ငယ်တဲ့ ဒါမှမဟုတ် အကြီးဆုံးထက် ကြီးတဲ့ တန်ဖိုး အသစ်က 0 အောက် ဒါမှမဟုတ် 1 အထက်ကို ရောက်သွားပါတယ်။ Normalisation က 0 ကနေ 255 အထိ ရှိတဲ့ pixel (ပုံထဲက အစက် တစ်စက်) အလင်းအမှောင် လို သိပြီးသား ကန့်သတ်ချက် ရှိတဲ့ feature တွေအတွက် သင့်တော်ပါတယ်။ Standardisation က range ကို ပုံသေ မသတ်မှတ်ပါဘူး၊ သဘာဝ ကန့်သတ်ချက် မရှိတဲ့ feature တွေအတွက် မကြာခဏ သုံးကြပါတယ်။ နှစ်မျိုးလုံးကို outlier တွေက သက်ရောက်ပါတယ်: အလွန်အမင်း ကြီးတဲ့ ဒါမှမဟုတ် ငယ်တဲ့ တန်ဖိုး တစ်ခုက range ကို ကျယ်သွားစေလို့ scale လုပ်ပြီးတဲ့အခါ ကျန်တဲ့ တန်ဖိုးတွေက တစ်ခုနဲ့ တစ်ခု နီးနီးကပ်ကပ် ဖြစ်သွားပါတယ်။ ဒါက outlier တွေကို အရင် ကိုင်တွယ်ရတဲ့ အကြောင်းရင်း တစ်ခုပါ။ အငယ်ဆုံး၊ အကြီးဆုံး၊ mean နဲ့ standard deviation တွေကို training data ကနေ ယူပြီး အဲဒီ တန်ဖိုးတွေကိုပဲ test data (model ကို စမ်းစစ်ဖို့ ချန်ထားတဲ့ ဒေတာ) နဲ့ input အသစ် တိုင်းကို scale လုပ်ဖို့ သုံးပါတယ်။
Scaling က k-NN နဲ့ k-means clustering (centroid k ခုနဲ့ အုပ်စုဖွဲ့တဲ့ algorithm) လို အကွာအဝေးကို တိုင်းတဲ့ နည်းတွေအတွက်နဲ့ neural network (အလွှာလိုက် စီထားတဲ့ neuron အတု network) တွေလို gradient descent (error ကို တစ်ကြိမ်ချင်း လျှော့ပေးတဲ့ ပြင်ဆင်မှု အသေးလေး အများကြီး၊ အဆင့် 2) နဲ့ train လုပ်တဲ့ model တွေအတွက် အရေးအကြီးဆုံးပါ။ Decision tree (ဟုတ်/မဟုတ် မေးခွန်းတွေနဲ့ ခန့်မှန်းတဲ့ သစ်ပင်ပုံ) က feature တစ်ခုကို တစ်ကြိမ်မှာ threshold (ကန့်သတ် တန်ဖိုး) တစ်ခုနဲ့ နှိုင်းယှဉ်တာမို့ scaling က သူ့အပေါ် သိပ် မသက်ရောက်ပါဘူး။
Feature selection (model သင်ယူမယ့် input တွေကို ရွေးခြင်း၊ A4.2.2)
Feature ဆိုတာ model ကြည့်နိုင်တဲ့ input တစ်ခုပါ: အကွာအဝေး ဒါမှမဟုတ် ပစ္စည်း အရေအတွက် လို ဒေတာထဲက column တစ်ခုပါ။ Feature များတိုင်း အလိုအလျောက် ပိုကောင်းတာ မဟုတ်ပါဘူး။ Irrelevant (မသက်ဆိုင်တဲ့) feature တွေ (ပို့ဆောင်ချိန် ခန့်မှန်းတဲ့ model အတွက် order ရဲ့ ရည်ညွှန်း နံပါတ် လို) က target (ခန့်မှန်းနေတဲ့ တန်ဖိုး) နဲ့ ဘာမှ မဆက်စပ်ပါဘူး။ Redundant (ထပ်နေတဲ့) feature တွေက တခြား feature တစ်ခုက ပေးပြီးသား အချက်အလက်ကို ထပ်ပေးပါတယ် (လမ်းအတိုင်း သွားရတဲ့ အကွာအဝေးနဲ့ driver ရဲ့ ခန့်မှန်း မောင်းချိန်က အတူတူ တက်လိုက် ကျလိုက် ဖြစ်ပါတယ်)။ Irrelevant feature တွေက noise ကို ထပ်ထည့်ပါတယ်၊ ဆိုလိုတာက model က ပုံစံ တစ်ခုလို့ မှားထင်နိုင်တဲ့ ကွဲလွဲမှုပါ။ Redundant feature တွေကတော့ အချက်အလက် အသစ် ဘာမှ မထည့်ပေးပါဘူး။ နှစ်မျိုးလုံးက train လုပ်တာကို နှေးစေနိုင်ပြီး model တချို့ကို ပိုဆိုးစေနိုင်ပါတယ်။ Feature selection ဆိုတာ အချက်အလက် အများဆုံး ပေးနိုင်တဲ့ feature တွေ၊ ဆိုလိုတာက model က သူ့ target ကို ခန့်မှန်းဖို့ ကူညီတဲ့ feature တွေကို ရှာဖော်ပြီး ထားတာပါ။
Feature တစ်ခုကို ထားမလား ဆုံးဖြတ်တဲ့အခါ မေးခွန်း လေးခု မေးပါ:
- Target နဲ့ ဘယ်လောက် ခိုင်ခိုင်မာမာ ဆက်စပ်သလဲ။
- တခြား feature တစ်ခုက အချက်အလက် အတူတူကို ပေးပြီးသားလား။
- Model က ခန့်မှန်းချက် ထုတ်တဲ့ အချိန်မှာ ဒီ feature ရနိုင်မလား။ Driver က order ကို ပို့ပြီးကြောင်း မှတ်တဲ့ အချိန်ကို ပို့ပြီးမှပဲ သိရတာမို့ ပို့ဆောင်ချိန်ကို ခန့်မှန်းဖို့ input အဖြစ် သုံးလို့ မရပါဘူး။
- ဒီ feature ကို သုံးတာက model ရဲ့ သက်ရောက်မှုကို ခံရတဲ့ လူတွေအတွက် တရားမျှတရဲ့လား။
ယေဘုယျ နည်းဗျူဟာ သုံးမျိုး ရှိပါတယ်:
- Filter methods (model မ train ခင် စစ်ထုတ်တဲ့ နည်းများ) က ဘယ် model ကိုမှ train မလုပ်ခင် statistic (စာရင်းအင်း တွက်ချက်မှု) တစ်ခုနဲ့ feature တွေကို အမှတ်ပေးပြီး အမှတ် အမြင့်ဆုံး feature တွေကို ထားပါတယ်။ အသုံးများတဲ့ နည်း တစ်ခုက feature တစ်ခုချင်းကို သီးခြားစီ အမှတ်ပေးတာပါ၊ ဥပမာ သူ့ တန်ဖိုးတွေက target နဲ့ ဘယ်လောက် နီးနီးကပ်ကပ် လိုက်ပြောင်းလဲလဲ ဆိုတာနဲ့ပါ။ Filter တွေက မြန်ပြီး ဘယ် model တစ်ခုတည်းပေါ်မှာမှ မမူတည်ပါဘူး။ Feature တွေကို တစ်ခုချင်း အမှတ်ပေးတဲ့ filter က ပေါင်းသုံးမှသာ အသုံးဝင်တဲ့ feature တွေကို လွတ်သွားနိုင်ပြီး နှစ်ခုလုံး အမှတ်ကောင်းတဲ့ redundant feature နှစ်ခုကို ထားမိနိုင်ပါတယ်။ တခြား filter တွေကတော့ feature တွေ ဘယ်လောက် ထပ်နေလဲ ဆိုတာကိုပါ တိုင်းပါတယ်။
- Wrapper methods (model နဲ့ စမ်းပြီး ရွေးတဲ့ နည်းများ) က feature တွေရဲ့ subset (အစုခွဲ) အမျိုးမျိုးပေါ်မှာ model ကို train လုပ်ပြီး subset တစ်ခုစီ ဘယ်လောက် ကောင်းကောင်း အလုပ်လုပ်လဲ နှိုင်းယှဉ်ပါတယ်၊ ဥပမာ feature တစ်ခုကို တစ်ကြိမ်ချင်း ထည့်ပြီး စွမ်းဆောင်ရည် တိုးလာမှသာ ထားတာမျိုးပါ။ Feature တွေကို သူတို့ကို သုံးမယ့် model နဲ့ စမ်းတာမို့ အဲဒီ model အတွက် ကောင်းကောင်း အလုပ်လုပ်တဲ့ ပေါင်းစပ်မှုတွေကို ရှာတွေ့နိုင်ပါတယ်။ ဒါပေမယ့် subset တိုင်းအတွက် train ကို သီးခြား run ရလို့ feature အများကြီး ရှိတဲ့အခါ ကွန်ပျူတာ တွက်ချိန် အများကြီး ပိုကုန်ပါတယ်။
- Embedded methods (train ရင်းနဲ့ ရွေးတဲ့ နည်းများ) က model ကို တည်ဆောက်ပုံရဲ့ အစိတ်အပိုင်း တစ်ခုအနေနဲ့ train လုပ်နေစဉ်မှာ feature တွေကို ရွေးပါတယ်။ Decision tree က ဥပမာ တစ်ခုပါ: split (ဒေတာကို ခွဲထုတ်တဲ့ မေးခွန်း) တိုင်းမှာ အချက်အလက် အများဆုံး ပေးနိုင်တဲ့ feature ကို ရွေးတာမို့ ဘယ် split အတွက်မှ မရွေးခံရတဲ့ feature က tree ရဲ့ ခန့်မှန်းချက်တွေမှာ ဘာမှ ပါဝင်မှု မရှိပါဘူး။ Regression နည်း တချို့က train လုပ်စဉ်မှာ penalty (ဒဏ်ကြေး) တစ်ခု ထည့်ပြီး အသုံးမဝင်တဲ့ feature တွေရဲ့ weight (model သင်ယူထားတဲ့ ကိန်းဂဏန်း တန်ဖိုးများ) တွေကို သုည ဖြစ်အောင် တွန်းချပါတယ်။ ရွေးတာက train run တစ်ကြိမ်တည်းထဲမှာ ဖြစ်တာမို့ embedded method တွေက wrapper method တွေထက် ကုန်ကျစရိတ် နည်းပါတယ်။ ဒါပေမယ့် သူတို့ ရွေးတဲ့ feature တွေက အဲဒီ model အမျိုးအစားနဲ့ ကိုက်ညီပြီး တခြား model တစ်မျိုးနဲ့တော့ ကိုက်ညီချင်မှ ကိုက်ညီပါလိမ့်မယ်။
Irrelevant ဒါမှမဟုတ် redundant feature တွေကို ဖယ်တာက စွမ်းဆောင်ရည်ကို ပိုကောင်းစေပြီး train ချိန်ကို လျှော့ပေးနိုင်ပါတယ်။ Model က ဘာကို ကြည့်မလဲ ရွေးတာက algorithm ကို ရွေးတာလောက် အရေးကြီးနိုင်ပါတယ်။
Dimensionality reduction (အရေးကြီးတာ မပျောက်ဘဲ feature အရေအတွက် လျှော့ခြင်း၊ A4.2.3)
Feature တစ်ခုစီက ဒေတာရဲ့ dimension (အတိုင်းအတာ) တစ်ခုပါ: feature 3 ခု ရှိရင် record တိုင်းက အတိုင်းအတာ 3 ခု ရှိတဲ့ space ထဲက အမှတ် တစ်ခု ဖြစ်ပြီး feature 300 ရှိရင် dimension 300 ထဲက အမှတ် တစ်ခု ဖြစ်ပါတယ်။ Pixel တန်ဖိုး တိုင်းက feature တစ်ခု ဖြစ်လို့ ပုံတွေမှာ dimension အရမ်း များပါတယ်: 100 × 100 pixel ရှိတဲ့ အရောင် ဓာတ်ပုံ အသေးလေး တစ်ပုံမှာ dimension 30,000 ရှိပါတယ် (pixel တစ်ခုစီအတွက် အရောင် တန်ဖိုး သုံးခု)။ Dimensionality reduction က အလုပ်အတွက် အရေးကြီးတဲ့ ဒေတာရဲ့ အချက်တွေကို ထိန်းထားရင်း feature (variable၊ ဆိုလိုတာက ပြောင်းလဲနိုင်တဲ့ တန်ဖိုး) အရေအတွက်ကို လျှော့ပေးပါတယ်။
The curse of dimensionality (feature များလာရင် ပေါ်လာတဲ့ ပြဿနာများ)
Feature အရေအတွက် များလာတာနဲ့အမျှ feature နည်းနည်းပဲ ရှိတုန်းက မရှိခဲ့တဲ့ ပြဿနာတွေ ပေါ်လာပါတယ်။ အဲဒီ ပြဿနာတွေကို စုပြီး curse of dimensionality (dimension များခြင်းရဲ့ ကျိန်စာ) လို့ ခေါ်ပါတယ်:
- Sparse data (ဒေတာ ပါးပါးလေး ပြန့်နေခြင်း) နဲ့ sample (နမူနာ) ပိုလိုလာခြင်း။ Feature တစ်ခု ထပ်တိုးတိုင်း ဖြစ်နိုင်တဲ့ တန်ဖိုး ပေါင်းစပ်မှု အရေအတွက်ကို အဆ မြှောက်ပေးပါတယ်။ Feature တစ်ခုစီကို band (အပိုင်း) 4 ခု (နိမ့်၊ အလယ်အောက်၊ အလယ်အထက်၊ မြင့်) ထဲကိုပဲ ခွဲထည့်တယ် ဆိုပါစို့။ Feature တစ်ခုက ပေါင်းစပ်မှု 4 မျိုး ပေးပြီး feature 2 ခုက 16 မျိုး၊ 5 ခုက 1,024 မျိုး၊ 15 ခုက 1,073,741,824 မျိုး ပေးပါတယ်။ Record တစ်ခုစီမှာ sensor (ပတ်ဝန်းကျင် အပြောင်းအလဲကို ထောက်လှမ်းတဲ့ ကိရိယာ) တိုင်းတာချက် 15 ခုစီ ပါတဲ့ record တစ်သန်းကို မှတ်တမ်းတင်ထားတဲ့ စက်ရုံ တစ်ခုမှာ ပေါင်းစပ်မှု တစ်ထောင်လောက်စီအတွက် record အများဆုံး တစ်ခုပဲ ရှိပါတယ်။ ဒေတာက sparse ဖြစ်နေပါတယ်၊ ဆိုလိုတာက ပါးပါးလေး ပြန့်နေတာပါ: ပေါင်းစပ်မှု အများစုမှာ ဥပမာ တစ်ခုမှ မရှိပါဘူး၊ ပြီးတော့ record အသစ် တစ်ခုက model က ဆင်တူတာ ဘာမှ မမြင်ဖူးတဲ့ နေရာမှာ ကျရောက်ဖို့ များပါတယ်။ ဖုံးလွှမ်းမှု အတူတူ ထိန်းထားဖို့ feature တွေ ထပ်ထည့်တာနဲ့အမျှ record အရေအတွက်က အရမ်း မြန်မြန် တိုးလာရပါမယ်။
- အကွာအဝေး တိုင်းတာချက်တွေ အဓိပ္ပာယ် ပျောက်လာခြင်း။ Feature အများကြီး ရှိတဲ့အခါ အမှတ် အသစ် တစ်ခုနဲ့ အနီးဆုံး record နဲ့ အဝေးဆုံး record တို့ဟာ အဲဒီ အမှတ်ကနေ အကွာအဝေး အတူတူနီးပါး ဖြစ်သွားနိုင်ပါတယ်၊ အထူးသဖြင့် feature အများကြီးက အလုပ်နဲ့ ဘာမှ မဆိုင်တဲ့ ပုံစံတွေနဲ့ ပြောင်းလဲနေတဲ့အခါ ဖြစ်တတ်ပါတယ်။ ဒါကြောင့် “အနီးဆုံး” ဆိုတာက model ကို သိပ် အချက်အလက် မပေးတော့ပါဘူး။ k-NN နဲ့ k-means clustering လို အကွာအဝေးပေါ် အခြေခံတဲ့ နည်းတွေက အများဆုံး ထိခိုက်ပါတယ်။
- Overfitting။ Feature အများကြီးနဲ့ record အတော် နည်းနည်း ရှိတဲ့အခါ model က training data ထဲမှာ တိုက်ဆိုင်မှု သက်သက်နဲ့ ပေါ်နေပြီး ဒေတာ အသစ်မှာ မမှန်တော့တဲ့ ပုံစံတွေကို ရှာတွေ့သွားနိုင်ပါတယ်။
- Computational cost (ကွန်ပျူတာ လုပ်ရတဲ့ အလုပ်နဲ့ အချိန်) နဲ့ memory (မှတ်ဉာဏ်)။ Feature အပိုတွေက algorithm ပေါ်နဲ့ အဲဒီ algorithm က သူတို့ကို သုံးမသုံးပေါ် မူတည်ပြီး train လုပ်တာနဲ့ ခန့်မှန်းတာမှာ တွက်ချက်မှုတွေ ထပ်တိုးစေနိုင်ပါတယ်။ ပြီးတော့ record တိုင်းအတွက် memory နဲ့ storage (ဒေတာ သိမ်းဆည်းရာ) နေရာကို ယူပါတယ်။
- Visualisation (ပုံဆွဲပြီး မြင်သာအောင် ပြခြင်း)။ လူတွေက feature နှစ်ခု ဒါမှမဟုတ် သုံးခုကို တစ်ပြိုင်နက် graph ဆွဲကြည့်နိုင်ပေမယ့် feature ရာနဲ့ချီ ရှိတဲ့ ဒေတာကို တိုက်ရိုက် ဆွဲပြလို့ မရပါဘူး၊ ဒါကြောင့် အမှားတွေနဲ့ ပုံစံတွေကို သတိထားမိဖို့ ပိုခက်ပါတယ်။
Dimension တွေကို လျှော့ခြင်း
Feature အရေအတွက်ကို လျှော့ဖို့ ယေဘုယျ နည်း နှစ်မျိုး ရှိပါတယ်:
- မူရင်း feature တွေထဲက subset တစ်ခုကို ထားခြင်း၊ ဒါက feature selection ပါ (အပေါ်မှာ ကြည့်ပါ)။
- Feature တွေကို ပေါင်းပြီး feature အသစ် အနည်းငယ် ဖြစ်အောင် လုပ်ခြင်း၊ အသုံးဝင်တဲ့ အချက်အလက် အများစုကို ထိန်းထားရင်းပါ။ ဥပမာ အတူတူ တက်လိုက် ကျလိုက် ဖြစ်တဲ့ စက် တစ်လုံးရဲ့ အပူချိန် sensor ခြောက်ခုကို သူတို့ရဲ့ ပျမ်းမျှ တန်ဖိုးနဲ့ အစားထိုးနိုင်ပါတယ်။ ဓာတ်ပုံ တစ်ပုံကိုလည်း train မလုပ်ခင် pixel နည်းနည်းပဲ ရှိအောင် ချုံ့နိုင်ပါတယ်။ စာရင်းအင်း နည်းစနစ်တွေက ကောင်းတဲ့ ပေါင်းစပ်မှုတွေကို အလိုအလျောက် ရှာပေးနိုင်ပေမယ့် သူတို့ ဘယ်လို အလုပ်လုပ်လဲ ဆိုတာက ဒီစာမျက်နှာရဲ့ နယ်ပယ် ပြင်ပမှာ ရှိပါတယ်။
Feature နည်းပြီး ပိုအဓိပ္ပာယ် ရှိရင် ပုံမှန်အားဖြင့် train လုပ်တာ ပိုမြန်တယ်၊ memory နည်းနည်း ယူတယ်၊ overfitting ဖြစ်နိုင်ခြေ နည်းတယ်၊ ဒေတာကို ပုံဆွဲကြည့်ရ ပိုလွယ်ပါတယ်။ ပေးရတဲ့ အဖိုးအခကတော့ အချက်အလက် တချို့ ပျောက်သွားတာပါ၊ ဒါကြောင့် ရလဒ်ကို model က မမြင်ဖူးတဲ့ ဒေတာပေါ်မှာ ဘယ်လောက် ကောင်းကောင်း အလုပ်လုပ်လဲ ဆိုတာနဲ့ အကဲဖြတ်ပါတယ်။
ကိုယ်တိုင် စမ်းကြည့်ပါ: bias simulator (ဘက်လိုက်မှုကို စမ်းကြည့်တဲ့ simulator) က ချို့ယွင်းချက် ရှိတဲ့ dataset (ဒေတာ အစုအဝေး) တစ်ခုပေါ်မှာ train လုပ်ပါတယ်။ စုစုပေါင်း accuracy ကို အုပ်စု တစ်ခုစီရဲ့ ရလဒ်တွေနဲ့ နှိုင်းယှဉ်ကြည့်ပါ: ဒေတာထဲက ပြဿနာတွေက train လုပ်တာကို ဖြတ်ပြီး model ရဲ့ ဆုံးဖြတ်ချက်တွေထဲ ရောက်သွားတာမို့ model တစ်ခုက စုစုပေါင်းအရ မှန်ကန်ပုံ ပေါ်ပေမယ့် အုပ်စု နှစ်ခုကို အရမ်း မတူအောင် ဆက်ဆံနေနိုင်ပါတယ်။
ဒေတာ ပြင်ဆင်တာကို လက်တွေ့ ပြပေးတဲ့ လက်ရေး မှတ်သိခြင်း lab video ပါ။ Train မလုပ်ခင် pixel တန်ဖိုး တိုင်းကို 0 နဲ့ 1 ကြား ရောက်အောင် scale လုပ်တယ်၊ စာလုံးတွေကို training set နဲ့ test set ခွဲတယ်၊ ပြီးတော့ လက်ရေး စာမျက်နှာ အသစ်တွေကို model က ဖတ်နိုင်ဖို့ အရင်ဆုံး training ပုံတွေနဲ့ ကိုက်အောင် အရွယ်အစား ပြောင်း၊ အလယ်ကို ရွှေ့ပြီး format ပြန်ချရပါတယ်။
အဆင့် 2: Linear Regression နဲ့ model ကို train လုပ်ခြင်း (A4.3.1)
Linear regression က continuous ရလဒ် တစ်ခုကို ခန့်မှန်းပါတယ်: ဆိုလိုတာက category (အမျိုးအစား) တစ်ခု မဟုတ်ဘဲ အချိန်၊ ဈေးနှုန်း ဒါမှမဟုတ် အပူချိန် လို range တစ်ခုထဲမှာ ဘယ်နေရာမှာမဆို ကျနိုင်တဲ့ ကိန်းဂဏန်း တစ်ခုပါ။ သူက variable အမျိုးအစား နှစ်မျိုးကြားက ဆက်နွယ်မှုကို model လုပ်ပါတယ်:
- independent (predictor) variable (အခြား variable ပေါ် မမူတည်တဲ့ variable)
x: ခန့်မှန်းချက် ထုတ်ဖို့ သုံးတဲ့ input ပါ။ - dependent (response) variable (
xပေါ် မူတည်တဲ့ variable)y: ခန့်မှန်းနေတဲ့ ရလဒ်ပါ၊ သူကxပေါ် မူတည်ပါတယ်။
Predictor တစ်ခုပဲ ရှိရင် model က မျဉ်းဖြောင့် တစ်ကြောင်း y = mx + b ဖြစ်ပြီး train လုပ်တာက သူ့ရဲ့ ကိန်းဂဏန်း နှစ်ခုကို ဒေတာကနေ သင်ယူတာပါ:
- slope (လျှောစောက်၊ မျဉ်းရဲ့ စောင်းမှု)
m:xက 1 တိုးတဲ့အခါyက ပျမ်းမျှ ဘယ်လောက် ပြောင်းလဲလဲ ဆိုတာပါ။ Positive slope ဆိုရင်xတက်တာနဲ့yတက်ပြီး negative slope ဆိုရင်yကျပါတယ်။ - intercept (y ဖြတ်ပိုင်း)
b:xက 0 ဖြစ်တဲ့အခါyရဲ့ ခန့်မှန်း တန်ဖိုးပါ၊ ဆိုလိုတာက မျဉ်းက y-axis (y ဝင်ရိုး) ကို ဖြတ်တဲ့ နေရာပါ။
Worked example: အဆင့် 1 က ပို့ဆောင်ရေး ကုမ္ပဏီက order ငါးခုရဲ့ အကွာအဝေးနဲ့ ပို့ဆောင်ချိန်ကို မှတ်တမ်းတင်ပါတယ်။
| အကွာအဝေး၊ x (km) | 2 | 4 | 6 | 8 | 10 |
|---|---|---|---|---|---|
| ပို့ဆောင်ချိန်၊ y (မိနစ်) | 21 | 26 | 36 | 46 | 51 |
Line of best fit (ဒေတာနဲ့ အကိုက်ညီဆုံး မျဉ်း) က time = 4 × distance + 12 ဖြစ်ပါတယ် (ပို့ဆောင်ချိန် = 4 × အကွာအဝေး + 12)။
- Slope 4: ကီလိုမီတာ တစ်ခု ပိုဝေးတိုင်း ပို့ဆောင်ချိန် ပျမ်းမျှ 4 မိနစ်လောက် ပိုကြာပါတယ်။
- Intercept 12: အကွာအဝေး 0 km အတွက် ခန့်မှန်း အချိန်ပါ။ ဒီမှာတော့ order ကို သွားယူတာ၊ အိမ်တံခါး ရှာတာ လို အကွာအဝေးပေါ် မမူတည်တဲ့ အချိန် အပိုင်းလို့ ယူဆနိုင်ပါတယ်။ Intercept မှာ အဓိပ္ပာယ် ရှိတဲ့ အနက် အမြဲ ရှိတာ မဟုတ်ပါဘူး:
x= 0 က ဒေတာနဲ့ အဝေးကြီးမှာ ရှိတဲ့အခါ (အရပ် 0 cm ကနေ လူ တစ်ယောက်ရဲ့ ကိုယ်အလေးချိန်ကို ခန့်မှန်းတာ လို) intercept က မျဉ်းက ဝင်ရိုးကို ဖြတ်တဲ့ အမှတ် သက်သက်ပဲ ဖြစ်ပါတယ်။ - ခန့်မှန်းချက် တစ်ခု: 7 km ဝေးတဲ့ order အသစ် တစ်ခုအတွက် time = 4 × 7 + 12 = 40 မိနစ် ဖြစ်ပါတယ်။ ခန့်မှန်းချက်တွေက training data ရဲ့ range ထဲမှာ (ဒီမှာ 2 ကနေ 10 km) အယုံကြည်ရဆုံးပါ။ 60 km ဝေးတဲ့ order က အဲဒီ range ရဲ့ ပြင်ပမှာ ရှိပါတယ်။
မျဉ်းကို fit လုပ်ခြင်း (ဒေတာနဲ့ ကိုက်အောင် ညှိခြင်း) ဆိုတာ ခန့်မှန်းချက်တွေကို တကယ့် တန်ဖိုးတွေနဲ့ တတ်နိုင်သမျှ နီးအောင် လုပ်ပေးတဲ့ slope နဲ့ intercept ကို ရွေးတာပါ။ Training point (training data ထဲက အမှတ်) တစ်ခုစီအတွက် error (ဒါမှမဟုတ် residual) က တကယ့် တန်ဖိုး အနုတ် ခန့်မှန်း တန်ဖိုး ဖြစ်ပါတယ်။ Fit ကို တိုင်းတဲ့ ပုံမှန် နည်းက positive error နဲ့ negative error တွေ အချင်းချင်း မချေဖျက်သွားအောင် error တစ်ခုချင်းကို နှစ်ထပ်တင်ပြီး ပေါင်းတာပါ။ Least squares (error နှစ်ထပ်ကိန်း ပေါင်းလဒ် အနည်းဆုံး) မျဉ်းက အဲဒီ စုစုပေါင်း အနည်းဆုံး ဖြစ်တဲ့ မျဉ်းပါ။ မျဉ်းဖြောင့် အတွက်ဆိုရင် formula (ပုံသေနည်း) တစ်ခုက ဒီမျဉ်းကို တိုက်ရိုက် ပေးပါတယ်။ Input အများကြီး ပါတဲ့ model တွေနဲ့ neural network တွေကိုတော့ gradient descent နဲ့ တစ်ဆင့်ချင်း fit လုပ်လေ့ ရှိပါတယ်: ဘယ်မျဉ်းနဲ့မဆို စပါ၊ error ကို တိုင်းပါ၊ error လျော့သွားမယ့် ဘက်ကို slope နဲ့ intercept ကို နည်းနည်း ပြောင်းပါ၊ ပြီးရင် error မကျတော့တဲ့အထိ ထပ်လုပ်ပါ။ Learning rate (သင်ယူမှု နှုန်း) က ပြောင်းလဲမှု တစ်ကြိမ်စီရဲ့ အရွယ်အစားကို သတ်မှတ်ပါတယ်။ Gradient (error ရဲ့ စောင်းမှု) က error အမြန်ဆုံး တက်တဲ့ ဘက်ကို ပြပြီး အဆင့် တစ်ဆင့်စီက ဆန့်ကျင်ဘက်၊ ဆိုလိုတာက ကုန်းဆင်း (descent) ဘက်ကို သွားတာမို့ ဒီနာမည် ရလာတာပါ။
မျဉ်းက ဘယ်လောက် ကောင်းကောင်း fit ဖြစ်လဲ ဆိုတာကို r² (coefficient of determination လို့လည်း ခေါ်ပါတယ်) နဲ့ မကြာခဏ တိုင်းပါတယ်: y ထဲက ကွဲပြားမှု (y တန်ဖိုးတွေက သူတို့ရဲ့ mean ကနေ ဘယ်လောက် ကွာလဲ) ထဲက မျဉ်းက ရှင်းပြနိုင်တဲ့ အချိုးပါ။ သူက မျဉ်းရဲ့ squared error (နှစ်ထပ်တင်ထားတဲ့ error) တွေကို ဖြစ်နိုင်တဲ့ အရိုးရှင်းဆုံး ခန့်မှန်းချက်၊ ဆိုလိုတာက y ရဲ့ mean ကို အမြဲ ခန့်မှန်းတာရဲ့ squared error တွေနဲ့ နှိုင်းယှဉ်ပါတယ်:
r² = 1 - (sum of the squared errors of the line) ÷ (sum of the squared differences between each y and the mean of y)
ဆိုလိုတာက r² = 1 - (မျဉ်းရဲ့ error တွေကို နှစ်ထပ်တင်ပြီး ပေါင်းထားတာ) ÷ (y တစ်ခုချင်းနဲ့ y ရဲ့ mean ကြား ကွာခြားချက်တွေကို နှစ်ထပ်တင်ပြီး ပေါင်းထားတာ) ပါ။
r² က 1 ဆိုရင် အမှတ် တိုင်းက မျဉ်းပေါ်မှာ ရှိပါတယ်။ r² က 0 နားမှာ ဆိုရင် မျဉ်းက mean ကို ခန့်မှန်းတာထက် သိပ် မပိုကောင်းပါဘူး။ ပို့ဆောင်မှု ငါးခုအတွက် mean အချိန်က 36 မိနစ် ဖြစ်ပြီး အဲဒီ mean ကနေ ကွာခြားချက်တွေကို နှစ်ထပ်တင် ပေါင်းရင် 650 ရပါတယ်။ မျဉ်းရဲ့ error တွေက 1, -2, 0, 2 နဲ့ -1 မိနစ် ဖြစ်ပြီး သူတို့ရဲ့ နှစ်ထပ်ကိန်းတွေ ပေါင်းရင် 10 ရလို့ r² = 1 - 10 ÷ 650 ≈ 0.98 ဖြစ်ပါတယ်: ဒီ ပို့ဆောင်ချိန်တွေရဲ့ ကွဲပြားမှု 98% လောက်ကို အကွာအဝေးက ရှင်းပြပါတယ်။ ကျန်တာက မျဉ်းက မရှင်းပြနိုင်တဲ့ ကွဲပြားမှု ဖြစ်ပြီး ယာဉ်ကြော ပိတ်ဆို့မှု လို အကြောင်းတွေကနေ ဒါမှမဟုတ် တိုင်းတာမှု အမှားတွေကနေ လာနိုင်ပါတယ်။ r² မြင့်တာက မျဉ်းက သူ train လုပ်ခဲ့တဲ့ ဒေတာနဲ့ ဘယ်လောက် ကိုက်ညီလဲ ဆိုတာကို ဖော်ပြပါတယ်။ x က y ကို ဖြစ်စေတယ် ဆိုတာကိုတော့ မပြပါဘူး၊ ပြီးတော့ model ကို ဒေတာ အသစ်ပေါ်မှာ စမ်းစစ်ရပါသေးတယ် (အဆင့် 3)။
တခြား အသုံးချပုံများ: အပြင်ဘက် အပူချိန်ကနေ အဆောက်အအုံ တစ်ခုရဲ့ စွမ်းအင် သုံးစွဲမှုကို ခန့်မှန်းတာ၊ ရာသီအတွင်း မိုးရေချိန်ကနေ သီးနှံ အထွက်နှုန်းကို ခန့်မှန်းတာ၊ ဒါမှမဟုတ် ဖုန်း screen ဖွင့်ထားတဲ့ ကြာချိန်ကနေ ဖုန်း ဘက်ထရီမှာ ကျန်တဲ့ အားကို ခန့်မှန်းတာတွေပါ။
ကိုယ်တိုင် စမ်းကြည့်ပါ: regression simulator က မျဉ်းကို gradient descent နဲ့ တစ်ဆင့်ချင်း fit လုပ်ပြပြီး မျဉ်း ငြိမ်လာတာနဲ့အမျှ error ကျသွားတာကို ပြပါတယ်။ Learning rate ကို အရမ်း မြင့်အောင် ထားကြည့်ပါ၊ error က ကျမယ့်အစား ကြီးလာပါလိမ့်မယ်: train လုပ်တာက မျဉ်းဆီ converge (တဖြည်းဖြည်း ကပ်သွားခြင်း) ဖြစ်မယ့်အစား diverge (ပိုပို ဝေးသွားခြင်း) ဖြစ်သွားပါတယ်။
အဆင့် 3: Model ကို အကဲဖြတ်ခြင်း (A4.3.3)
Model တစ်ခုက သူ train လုပ်ခဲ့တဲ့ ဒေတာပေါ်မှာ အရမ်း ကောင်းပုံ ပေါ်နေပေမယ့် ဒေတာ အသစ်ပေါ်မှာ ညံ့နေနိုင်ပါသေးတယ်။ Evaluation (အကဲဖြတ်ခြင်း) က model တစ်ခုဟာ သူ့ကို ရည်ရွယ်ထားတဲ့ အလုပ်မှာ ဘယ်လောက် ကောင်းကောင်း အလုပ်လုပ်လဲ တိုင်းတာပါ၊ train လုပ်စဉ် မသုံးခဲ့တဲ့ ဒေတာပေါ်မှာ ဘယ်လောက် လုပ်နိုင်လဲ ဆိုတာလည်း ပါပါတယ်။ Evaluation က စည်းမျဉ်း တစ်ခုနဲ့ စပါတယ်။
Model ကို သူ train လုပ်ခဲ့တဲ့ ဒေတာနဲ့ ဘယ်တော့မှ မအကဲဖြတ်ပါနဲ့
ဒေတာကို သီးခြား အစုတွေ ခွဲပါ: အပိုင်း တစ်ပိုင်းပေါ်မှာ model ကို train လုပ်ပြီး သူ မမြင်ဖူးသေးတဲ့ ဒေတာပေါ်မှာ test (စမ်းစစ်) လုပ်ပါ။ Model ကို သူ့ training data နဲ့ အကဲဖြတ်တာက ကျောင်းသားတွေကို သူတို့ လေ့ကျင့်ခဲ့တဲ့ မေးခွန်း အတိအကျတွေနဲ့ပဲ စာမေးပွဲ စစ်တာနဲ့ တူပါတယ်: အမှတ် မြင့်တာက သူတို့ အဲဒီ မေးခွန်းတွေကို မှတ်မိတယ် ဆိုတာကို ပြတာပါ၊ မေးခွန်း အသစ်တွေကို ဖြေနိုင်တယ် ဆိုတာကို မပြပါဘူး။ မမြင်ဖူးတဲ့ ဒေတာပေါ်က စွမ်းဆောင်ရည်က model ဟာ ယေဘုယျ ပုံစံကို သင်ယူခဲ့တာလား၊ ဒါမှမဟုတ် training ဥပမာတွေကို အလွတ်ကျက်ခဲ့ရုံလား ဆိုတာကို ပြပါတယ်။
Label (အဖြေမှန်ကို ပြတဲ့ အမှတ်အသား) တပ်ထားတဲ့ record 20 ခုကို အစမှာ တစ်ကြိမ်တည်း ခွဲထားပါတယ်။ Model က training အကွက်တွေကနေ သင်ယူပြီး test အကွက်တွေကို နောက်ဆုံး အကဲဖြတ်ဖို့ သီးသန့် ချန်ထားပါတယ်။
ပုံထဲက စာတွေရဲ့ အဓိပ္ပာယ်: ခေါင်းစဉ်က “train မလုပ်ခင် ဒေတာကို တစ်ကြိမ်တည်း ခွဲပါ” ပါ။ training set (model သင်ယူဖို့ ခွဲထားတဲ့ ဒေတာ အစု) အောက်က စာက “model က ဒီ record 16 ခု (80%) ကနေ သင်ယူတယ်” ဖြစ်ပြီး test set (နောက်ဆုံး စစ်ဆေးဖို့ ချန်ထားတဲ့ ဒေတာ အစု) အောက်က စာက “အဆုံးအထိ မမြင်ရအောင် ချန်ထားတယ် (20%)” ပါ။
Overfitting နဲ့ underfitting
Model တစ်ခုရဲ့ training data ပေါ်က score (ရမှတ်) နဲ့ မမြင်ဖူးတဲ့ ဒေတာပေါ်က score ကို နှိုင်းယှဉ်ကြည့်ရင် model မှားနိုင်တဲ့ အဖြစ်များတဲ့ ပုံစံ နှစ်မျိုးကို တွေ့ရပါတယ်:
- Overfitting: model က training data ကို noise နဲ့ ထူးဆန်းတဲ့ အချက်လေးတွေ အပါအဝင် အရမ်း ကောင်းကောင်း သင်ယူမိတာပါ။ Training data ပေါ်မှာ အရမ်း အမှတ်ကောင်းပြီး ဒေတာ အသစ်ပေါ်မှာ ညံ့ပါတယ်။ Generalise လုပ်တာ (ဒေတာ အသစ်မှာလည်း မှန်တဲ့ ပုံစံကို သင်ယူတာ) အစား ဥပမာတွေကို အလွတ်ကျက်ခဲ့တာပါ။
- Underfitting: model က တကယ့် ပုံစံကို ဖမ်းယူဖို့ ရိုးလွန်းနေတာပါ။ Training data ပေါ်မှာရော ဒေတာ အသစ်ပေါ်မှာပါ ညံ့ပါတယ်။
အမှတ် 10 ခု အတူတူကို နည်း သုံးမျိုးနဲ့ fit လုပ်ထားပါတယ်: overfit မျဉ်းက noise ကို အလွတ်ကျက်သွားပြီး good fit က ပုံစံကို သင်ယူသွားပါတယ်။
ပုံထဲက ခေါင်းစဉ်တွေက Underfit (ရိုးလွန်းတဲ့ fit)၊ Good fit (ကောင်းတဲ့ fit) နဲ့ Overfit (ဒေတာနဲ့ ကပ်လွန်းတဲ့ fit) ဖြစ်ပြီး အောက်က စာတွေက “မျဉ်းဖြောင့်က ကွေးတာကို လွတ်သွားတယ်”၊ “မျဉ်းကွေး ချောချောက အလားအလာကို လိုက်တယ်” နဲ့ “မျဉ်း ကွေးကောက်ကောက်က အမှတ် တိုင်းကို လိုက်ဖမ်းတယ်” လို့ ဆိုလိုပါတယ်။
ရည်မှန်းချက်က အလယ်မှာပါ: တကယ့် ပုံစံကို ဖမ်းနိုင်လောက်အောင် ရှုပ်ထွေးပြီး generalise လုပ်နိုင်လောက်အောင် ရိုးရှင်းရပါမယ်။ Model နှစ်ခုက training data နဲ့ ကိုက်ညီမှု အတူတူလောက် ရှိရင် noise ကို အလွတ်ကျက်ဖို့ နေရာ နည်းတာကြောင့် ပိုရိုးရှင်းတဲ့ model က မကြာခဏ ပိုကောင်းကောင်း generalise လုပ်ပါတယ်။
ကိုယ်တိုင် စမ်းကြည့်ပါ: fit simulator မှာ model ရဲ့ ရှုပ်ထွေးမှုကို underfit ကနေ good fit ကို ဖြတ်ပြီး overfit အထိ ဆွဲရွှေ့ကြည့်လို့ ရပြီး training error နဲ့ test error တို့ တစ်ခုနဲ့ တစ်ခု ကွာသွားတာကို ကြည့်နိုင်ပါတယ်။ Simulator မှာ အောက်က metric တွေကို ပြတဲ့ confusion matrix (ခန့်မှန်းချက်နဲ့ အမှန်ကို ယှဉ်ပြတဲ့ ဇယား) လည်း ပါပါတယ်။
Accuracy တစ်ခုတည်းနဲ့ မလုံလောက်ပါဘူး
Accuracy ဆိုတာ ခန့်မှန်းချက်တွေထဲက မှန်တဲ့ အချိုးပါ။ Class (model ခွဲခြားပေးတဲ့ အမျိုးအစား) တစ်ခုက ကျန်တစ်ခုထက် အများကြီး ရှားတဲ့ imbalanced (class တွေရဲ့ အရေအတွက် မညီမျှတဲ့) ဒေတာမှာ accuracy က ရှားတဲ့ class ပေါ်က ညံ့ဖျင်းတဲ့ စွမ်းဆောင်ရည်ကို ဖုံးကွယ်ထားနိုင်ပါတယ်။ Transaction (ငွေပေးချေမှု) တွေရဲ့ 99% က စစ်မှန်ရင် အားလုံးကို “genuine” (စစ်မှန်တယ်) လို့ label တပ်တဲ့ model မှာ accuracy 99% ရှိပေမယ့် လိမ်လည် ငွေပေးချေမှု တစ်ခုမှ မဖမ်းမိပါဘူး။
တခြား metric တွေက accuracy ဖုံးကွယ်ထားတာကို ပြပါတယ်။ သူတို့ကို ခန့်မှန်းချက် တစ်ခုရဲ့ ဖြစ်နိုင်တဲ့ ရလဒ် လေးမျိုးကနေ တည်ဆောက်ပြီး အဲဒီ လေးမျိုးကို confusion matrix လို့ ခေါ်တဲ့ ဇယားမှာ ပြပါတယ်: true positive (positive လို့ မှန်မှန် ခန့်မှန်းတာ)၊ false positive (positive လို့ မှားပြီး ခန့်မှန်းတာ)၊ true negative (negative လို့ မှန်မှန် ခန့်မှန်းတာ) နဲ့ false negative (negative လို့ မှားပြီး ခန့်မှန်းတာ) တို့ပါ။ “Positive” ဆိုတာ ရလဒ်ကောင်း တစ်ခုကို ဆိုလိုတာ မဟုတ်ဘဲ model ရှာနေတဲ့ class ကို ဆိုလိုပါတယ် (အောက်က ရောဂါ ရှာဖွေ စစ်ဆေးမှု ဥပမာမှာ ရောဂါ ရှိတာပါ)။ “True” ဒါမှမဟုတ် “false” က ခန့်မှန်းချက် မှန်မမှန်ကို ပြောပါတယ်။
စစ်ဆေးခံရတဲ့ လူ 1000 ထဲမှာ 10 ယောက်က ရောဂါ ရှိပါတယ်။ Model က negative case 980 နဲ့ positive case 6 ခုကို မှန်မှန် ခွဲခြားလို့ accuracy 98.6% ရပါတယ်။ Negative case အများကြီးက accuracy ကို လွှမ်းမိုးထားလို့ မြင့်ပုံ ပေါ်တာပါ။ Recall က ပြဿနာကို ပြပါတယ်: model က positive case 10 ခုထဲက 6 ခုကိုပဲ ဖမ်းမိလို့ ရောဂါ ရှိတဲ့ လူ 4 ယောက်ကို အိမ်ပြန်လွှတ်လိုက်ပါတယ်။ Precision (37.5%) က ဒုတိယ ဆုံးရှုံးမှု တစ်ခုကို ပြပါတယ်: model က flag လုပ် (ရောဂါ ရှိနိုင်တယ်လို့ အမှတ်အသား တပ်) လိုက်တဲ့ လူ အများစုက မှားယွင်းတဲ့ သတိပေးချက်တွေပါ။
ပုံထဲက စာတွေ: predicted (model ခန့်မှန်းတာ) နဲ့ actual (တကယ့် အခြေအနေ)၊ sick (ရောဂါ ရှိ) နဲ့ healthy (ကျန်းမာ)။ အကွက်တွေထဲက စာတွေက “sick, flagged sick” (ရောဂါ ရှိပြီး ရောဂါ ရှိတယ်လို့ flag လုပ်ခံရ)၊ “sick, sent home” (ရောဂါ ရှိပေမယ့် အိမ်ပြန်လွှတ်ခံရ)၊ “healthy, flagged sick” (ကျန်းမာပေမယ့် ရောဂါ ရှိတယ်လို့ flag လုပ်ခံရ) နဲ့ “healthy, cleared” (ကျန်းမာပြီး ရောဂါ မရှိဘူးလို့ ဆုံးဖြတ်ခံရ) ပါ။ အောက်ဆုံး စာကြောင်းက “98.6% မှန်ပေမယ့် ရောဂါ ရှိတဲ့ 10 ယောက်ထဲက 4 ယောက်ကို အိမ်ပြန်လွှတ်လိုက်တယ်” လို့ ဆိုလိုပါတယ်။
| Metric | ဖြေပေးတဲ့ မေးခွန်း | တွက်ပုံ |
|---|---|---|
| Accuracy | Model က စုစုပေါင်း ဘယ်လောက် မကြာခဏ မှန်သလဲ။ | ခန့်မှန်းချက် အားလုံးထဲက မှန်တဲ့ ခန့်မှန်းချက်: (TP + TN) ÷ total |
| Precision | “yes” လို့ ပြောတဲ့အခါ ဘယ်လောက် မကြာခဏ မှန်သလဲ။ | Positive လို့ ခန့်မှန်းထားတာ အားလုံးထဲက true positive: TP ÷ (TP + FP) |
| Recall | တကယ့် “yes” case အားလုံးထဲက ဘယ်နှစ်ခုကို ဖမ်းမိသလဲ။ | တကယ် positive ဖြစ်တာ အားလုံးထဲက true positive: TP ÷ (TP + FN) |
| F1 score | Precision နဲ့ recall ကို ချိန်ညှိပေးတဲ့ ကိန်း တစ်ခုတည်း | 2 × precision × recall ÷ (precision + recall)၊ နှစ်ခုလုံး မြင့်မှသာ မြင့်ပါတယ် |
ရောဂါ စစ်ဆေးမှု ဥပမာအတွက် F1 = 2 × 0.375 × 0.6 ÷ (0.375 + 0.6) ≈ 0.46 (46%) ဖြစ်ပါတယ်: precision (37.5%) နိမ့်လို့ accuracy 98.6% ထက် အများကြီး နိမ့်ပါတယ်။ F1 က တန်ဖိုး နှစ်ခုထဲက နိမ့်တဲ့ဘက်ကို ဆွဲယူခံရတဲ့ ပျမ်းမျှ အမျိုးအစား တစ်ခု (harmonic mean) ဖြစ်လို့ model က တစ်ခုတည်းမှာပဲ ကောင်းနေရင် F1 မှာ အမှတ်ကောင်း မရနိုင်ပါဘူး။
Precision နဲ့ recall က မကြာခဏ trade off (တစ်ခု ရဖို့ တစ်ခု အလျှော့ပေးရတာ) ဖြစ်ပါတယ်: case ပိုများများ flag လုပ်တဲ့ model က တကယ့် case တွေကို ပိုဖမ်းမိပေမယ့် (recall ပိုမြင့်) ပုံမှန်အားဖြင့် မှားယွင်းတဲ့ သတိပေးချက်တွေလည်း ပိုများလာပါတယ် (precision ပိုနိမ့်)။ ဘယ်ဟာက ပိုအရေးကြီးလဲ ဆိုတာ ပြဿနာပေါ် မူတည်ပါတယ်။ အပေါ်က ရောဂါ စစ်ဆေးမှုအတွက် လွတ်သွားတဲ့ case (recall နိမ့်တာ) က မှားယွင်းတဲ့ သတိပေးချက် ထက် ပုံမှန်အားဖြင့် ပိုဆိုးပါတယ်၊ မှားယွင်းတဲ့ သတိပေးချက်ကိုတော့ နောက်ထပ် စစ်ဆေးမှု တစ်ခုနဲ့ ရှင်းနိုင်လို့ပါ။ သူခိုး သုံးနေတယ်လို့ သံသယ ရှိတဲ့ card တွေကို ပိတ်တဲ့ ဘဏ် တစ်ခုအတွက်ဆိုရင် မှားယွင်းတဲ့ သတိပေးချက် (precision နိမ့်တာ) တစ်ခုစီက စစ်မှန်တဲ့ ဖောက်သည် တစ်ယောက်ကို ငွေမချေနိုင်အောင် တားလိုက်ပါတယ်။ နှစ်ခုလုံး ကောင်းစေချင်တဲ့အခါ F1 က ကိန်း တစ်ခုတည်း ပေးပါတယ်။
Hyperparameter tuning (train မလုပ်ခင် ရွေးထားရတဲ့ setting တွေကို ချိန်ညှိခြင်း)
Setting တချို့ကို ဒေတာကနေ သင်ယူတာ မဟုတ်ဘဲ train မလုပ်ခင် ရွေးထားပါတယ်: k-NN ထဲက k၊ decision tree ရဲ့ maximum depth (tree က အများဆုံး ခွဲထွက်နိုင်တဲ့ အဆင့် အရေအတွက်)၊ gradient descent ထဲက learning rate နဲ့ neural network ထဲက layer (အလွှာ) အရေအတွက် တို့ပါ။ ဒါတွေကို hyperparameter တွေလို့ ခေါ်ပါတယ်။ Regression မျဉ်းရဲ့ slope နဲ့ intercept၊ ဒါမှမဟုတ် network ထဲက weight တွေ လို model က train လုပ်စဉ် သင်ယူတဲ့ တန်ဖိုးတွေကတော့ သူ့ရဲ့ parameter (model က ဒေတာကနေ သင်ယူတဲ့ တန်ဖိုး) တွေပါ။
Hyperparameter တွေက model ဘယ်လောက် ရှုပ်ထွေးလာနိုင်လဲ၊ ဘယ်လို သင်ယူလဲ ဆိုတာကို ထိန်းချုပ်တာမို့ model က underfit ဖြစ်မလား၊ ကောင်းကောင်း fit ဖြစ်မလား၊ overfit ဖြစ်မလား ဆိုတာကို သက်ရောက်ပါတယ်:
- Depth 1 အထိပဲ ကန့်သတ်ထားတဲ့ decision tree က မေးခွန်း တစ်ခုတည်းပဲ မေးတာမို့ ပုံစံက မေးခွန်း တစ်ခုထက် ပိုလိုတဲ့အခါ underfit ဖြစ်နိုင်ပါတယ်။ Depth ကို ကန့်သတ်ချက် မထားရင် training data ကို အလွတ်ကျက်ပြီးတဲ့အထိ ဆက်ခွဲသွားနိုင်ပြီး overfit ဖြစ်နိုင်ပါတယ်။
- k = 1 ဆိုရင် k-NN က အနီးဆုံး training point တစ်ခုတည်းရဲ့ label ကို ကူးယူတာမို့ noise ပါတဲ့ point တစ်ခုက ခန့်မှန်းချက်ကို ပြောင်းသွားစေနိုင်ပါတယ်: model က noise ကို ထိခိုက်လွယ်ပြီး overfit ဖြစ်နိုင်ပါတယ်။ k အရမ်းကြီးရင် neighbour (အနီးက point) အရမ်း များများကို ရေတွက်လို့ class တွေကြားက တကယ့် နယ်နိမိတ်တွေကို လွတ်သွားပြီး underfit ဖြစ်နိုင်ပါတယ်။
- Learning rate အရမ်းကြီးရင် gradient descent က အကောင်းဆုံး တန်ဖိုးတွေကို ကျော်လွန်ပြီး လှမ်းသွားတာမို့ (overshoot) error က ကျဆင်းမယ့်အစား ကြီးလာနိုင်ပါတယ်။ Learning rate အရမ်းသေးရင်တော့ train လုပ်တာ အရမ်း နှေးပါတယ်။
Setting တစ်ခုတည်းကို ကြည့်ပြီး model မှာ ဘယ်ပြဿနာ ရှိလဲ မသိနိုင်ပါဘူး: underfit ဖြစ်တယ် ဒါမှမဟုတ် overfit ဖြစ်တယ်လို့ မဆုံးဖြတ်ခင် training data ပေါ်က score နဲ့ validation data (အောက်မှာ ကြည့်ပါ) ပေါ်က score ကို နှိုင်းယှဉ်ပါ။
Tuning ဆိုတာ တန်ဖိုး အမျိုးမျိုးကို စမ်းကြည့်ပြီး ပြဿနာနဲ့ ကိုက်တဲ့ metric တစ်ခုပေါ်မှာ အကောင်းဆုံး လုပ်ဆောင်တဲ့ တန်ဖိုးကို ထားတာပါ (imbalanced data အတွက်ဆိုရင် accuracy အစား F1 ဒါမှမဟုတ် recall)။ တန်ဖိုး တစ်ခုစီအတွက် model ကို training set ပေါ်မှာ train လုပ်ပြီး validation set ပေါ်မှာ score တွက်ပါတယ်: validation set ဆိုတာ train လုပ်တာထဲ မထည့်ဘဲ ချန်ထားတဲ့ ဒေတာ ဖြစ်ပြီး test set နဲ့လည်း သီးခြားပါ။ Test set ကို ရွေးထားတဲ့ model ရဲ့ နောက်ဆုံး အကဲဖြတ်မှု တစ်ကြိမ်အတွက် ချန်ထားတာမို့ သူ့ score က ဒေတာ အသစ်ပေါ်က စွမ်းဆောင်ရည်ရဲ့ မျှတတဲ့ ခန့်မှန်းချက် ဖြစ်နေပါသေးတယ်။ တန်ဖိုး ရွေးဖို့ test set ကို သုံးမိရင် ရွေးချယ်မှုက အဲဒီ test set နဲ့ ကိုက်အောင် ဖြစ်သွားပြီး သူ့ score က model ရဲ့ တကယ့် အရည်အသွေးထက် ပိုကောင်းပုံ ပေါ်နေပါလိမ့်မယ်။ ဒေတာ နည်းတဲ့အခါ cross-validation (ဒေတာကို အလှည့်ကျ ခွဲပြီး ထပ်ခါထပ်ခါ စစ်တဲ့ နည်း) က training data ရဲ့ မတူတဲ့ အပိုင်း တစ်ခုကို အကြိမ်တိုင်း validation အတွက် သုံးပြီး ဒီ လုပ်ငန်းစဉ်ကို ထပ်ခါထပ်ခါ လုပ်ကာ score တွေကို ပျမ်းမျှ ယူပါတယ်။
Network ရဲ့ weight တွေကို update လုပ်သွားတာနဲ့အမျှ error လျော့ကျသွားတာကို ကြည့်ပါ: အဆင့် 2 က gradient descent လိုပဲ ထပ်ခါထပ်ခါ ချိန်ညှိတာပါ၊ ဒါပေမယ့် အများကြီး ပိုကြီးတဲ့ model တစ်ခုမှာပါ။ အဆင့်တိုင်းမှာ network က ဘယ်လောက် မှားနေလဲ တိုင်းတဲ့ နည်း တစ်ခု သင်ယူခြင်းအတွက် ဘာကြောင့် လိုလဲ ဆိုတာလည်း ပြပါတယ်: အဲဒါ မရှိရင် ဘယ် အပြောင်းအလဲက အထောက်အကူ ဖြစ်လဲ network က မသိနိုင်ပါဘူး။
အဆင့် 4: CNN တွေနဲ့ ပုံတွေအတွက် Deep Learning (A4.3.9)
Convolutional neural network (CNN) ဆိုတာ ပုံတွေအတွက် တည်ဆောက်ထားတဲ့ deep learning (အလွှာ အများပါတဲ့ neural network နဲ့ သင်ယူခြင်း) ဒီဇိုင်း တစ်ခုပါ။ သူက spatial hierarchy of features (feature တွေရဲ့ နေရာအလိုက် အဆင့်ဆင့်) ကို သင်ယူပါတယ်: ပထမ ရိုးရှင်းတဲ့ local (ပုံရဲ့ နေရာ သေးသေးလေး တစ်ခုထဲက) ပုံစံတွေ၊ ပြီးရင် အဲဒီ ပုံစံတွေရဲ့ ပေါင်းစပ်မှုတွေ၊ နောက်ဆုံး အရာဝတ္ထု တစ်ခုလုံးအထိ တည်ဆောက်သွားပါတယ်။ သူက အဲဒါတွေကို adaptively သင်ယူပါတယ်: သူ ရှာရမယ့် ပုံစံတွေကို ဘယ်သူမှ ရေးမပေးပါဘူး။ သူ့ filter (weight တွေ ပါတဲ့ ဇယားကွက် အသေးလေး၊ အောက်မှာ ရှင်းပြထားပါတယ်) တွေထဲက ကိန်းဂဏန်းတွေက ပုံမှန်အားဖြင့် ကျပန်း တန်ဖိုးတွေနဲ့ စပြီး ဘယ် neural network ရဲ့ weight တွေလိုပဲ train လုပ်စဉ်မှာ ညှိပေးခံရပါတယ်၊ အလုပ်အတွက် အထောက်အကူ ဖြစ်တဲ့ ပုံစံတွေကို ရွေးထုတ်နိုင်တဲ့အထိပါ။
သူ့ရဲ့ အခြေခံ architecture (ဖွဲ့စည်းပုံ) မှာ အပိုင်း ခြောက်ခု ဒီ အစဉ်အတိုင်း ပါပါတယ်:
- Input layer (ပုံကို လက်ခံတဲ့ layer): ပုံကို ကိန်းဂဏန်း ဇယားကွက် တစ်ခုအဖြစ် ပေးတာပါ၊ pixel တစ်ခုစီရဲ့ အလင်းအမှောင်အတွက် ကိန်း တစ်ခုစီပါ (အရောင်ပုံ ဆိုရင် pixel တစ်ခုစီအတွက် အနီ၊ အစိမ်း၊ အပြာ သုံးခုစီ)။ 28 × 28 pixel ရှိတဲ့ greyscale (အဖြူ၊ အမည်း၊ မီးခိုးရောင်တွေပဲ ပါတဲ့) ပုံ တစ်ပုံက ကိန်း 784 ခု ဖြစ်ပါတယ်။
- Convolutional layers (filter တွေနဲ့ ပုံစံ ရှာတဲ့ layer များ): တစ်ခုစီက 3 × 3 weight ဇယားကွက်တွေ လို filter အသေးလေးတွေ (kernel လို့လည်း ခေါ်ပါတယ်) ကို ပုံပေါ်မှာ ရွှေ့သွားပါတယ်။ နေရာ တစ်ခုစီမှာ filter ရဲ့ weight တွေကို အောက်က pixel တန်ဖိုးတွေနဲ့ မြှောက်ပြီး ရလဒ်တွေကို ပေါင်းပါတယ်။ စုစုပေါင်း မြင့်ရင် filter က တုံ့ပြန်တဲ့ ပုံစံ (အနားသတ်၊ ထောင့်၊ အရောင် အကွက်) အဲဒီနေရာမှာ ရှိတယ်လို့ ဆိုလိုပြီး နေရာ တိုင်းက စုစုပေါင်းတွေက feature map (ပုံစံ ဘယ်နေရာမှာ တွေ့လဲ ပြတဲ့ ဇယား) တစ်ခု ဖြစ်လာပါတယ်။ Layer တစ်ခုမှာ ပုံမှန်အားဖြင့် filter အများကြီး ရှိပြီး filter တစ်ခုစီက သူ့ကိုယ်ပိုင် feature map ကို ပေးပါတယ်။
- Activation functions (တန်ဖိုးတွေကို ပြောင်းပေးတဲ့ function များ): feature map တစ်ခုစီထဲက တန်ဖိုး တိုင်းကို သုံးပါတယ်။ CNN တွေမှာ အသုံးအများဆုံး ဖြစ်တဲ့ ReLU က negative တန်ဖိုးတွေကို 0 နဲ့ အစားထိုးပြီး positive တန်ဖိုးတွေကို ဒီအတိုင်း ထားပါတယ်။ Activation function တွေက network ကို မျဉ်းဖြောင့် ဆက်နွယ်မှု မဟုတ်တဲ့ ပုံစံတွေကို သင်ယူနိုင်အောင် လုပ်ပေးပါတယ်။ သူတို့ မပါရင် convolutional layer တွေကို ထပ်ဆင့် စီထားတာက ပိုရိုးရှင်းတဲ့ တွက်ချက်မှု တစ်ခုတည်းနဲ့ ညီမျှသွားပါလိမ့်မယ်။
- Pooling layers (feature map ကို ချုံ့တဲ့ layer များ): ဧရိယာ အသေးလေးတွေကို အနှစ်ချုပ်ပြီး feature map တစ်ခုစီကို ချုံ့ပါတယ်၊ ဥပမာ 2 × 2 block တစ်ခုစီထဲက အကြီးဆုံး တန်ဖိုးကို ထားတာ (max pooling) ပါ၊ ဒါက အကျယ်နဲ့ အမြင့်ကို တစ်ဝက်စီ လျှော့ပါတယ်။ ဒါက နောက်ပိုင်း layer တွေရဲ့ တွက်ချက်မှုကို လျှော့ပေးပြီး feature တစ်ခုက ပုံထဲမှာ ဘယ်နေရာ အတိအကျမှာ ပေါ်လဲ ဆိုတာကို network က သိပ် မထိခိုက်တော့အောင် လုပ်ပေးပါတယ်။
- Fully connected layers (node အားလုံး ချိတ်ဆက်ထားတဲ့ layer များ): နောက်ဆုံး feature map တွေကို ကိန်းဂဏန်း list ရှည် တစ်ခုအဖြစ် flatten (ပြားအောင် ဖြန့်) လုပ်ပါတယ်။ ပြီးရင် node (network ထဲက neuron တစ်ခု) တိုင်းက နောက် layer ထဲက node တိုင်းနဲ့ ချိတ်ဆက်ထားတဲ့ layer တွေက ရှာတွေ့ထားတဲ့ feature တွေကို ပေါင်းပြီး ဆုံးဖြတ်ချက် တစ်ခု ချပါတယ်။
- Output layer (class တစ်ခုစီအတွက် score ပေးတဲ့ layer): class တစ်ခုစီအတွက် node တစ်ခုစီ ရှိပြီး တစ်ခုစီက score တစ်ခုစီ ပေးပါတယ်။ Classifier (အမျိုးအစား ခွဲခြားပေးတဲ့ model) အတွက် score တွေကို ပုံမှန်အားဖြင့် ပေါင်းရင် 1 ရတဲ့ probability (ဖြစ်နိုင်ခြေ) တွေအဖြစ် ပြောင်းပါတယ် (ဥပမာ cat (ကြောင်) 0.94 နဲ့ not a cat (ကြောင် မဟုတ်) 0.06)။
ဒါတွေကို ထပ်ဆင့် စီလိုက်တဲ့အခါ အစောပိုင်း layer တွေက အနားသတ်တွေကို ရှာတယ်၊ အလယ် layer တွေက အဲဒါတွေကို ပုံသဏ္ဌာန်တွေအဖြစ် စုပေါင်းတယ်၊ နောက်ပိုင်း layer တွေက အရာဝတ္ထု တစ်ခုလုံးကို မှတ်မိပါတယ်။ Feature တွေကို အလွှာလိုက် တည်ဆောက်သွားတဲ့ ဒီ ပုံစံက CNN တွေ ပုံတွေပေါ်မှာ ကောင်းကောင်း အလုပ်လုပ်ရတဲ့ အဓိက အကြောင်းရင်း တစ်ခုပါ။
အပိုင်း ခြောက်ခုကို ပုံ တစ်ပုံထဲမှာ ပြထားပါတယ်: convolution layer တွေက local ပုံစံတွေကို ရှာပြီး တစ်ခုစီရဲ့ နောက်မှာ activation function တစ်ခုစီ လိုက်ပါတယ်။ Pooling layer တွေက map တွေကို ချုံ့တယ်၊ fully connected layer တွေက ရှာတွေ့ထားတဲ့ feature တွေကို ပေါင်းတယ်၊ output layer က class တစ်ခုစီအတွက် score တစ်ခုစီ ပေးပါတယ်။
ပုံထဲက အပေါ်ဘက် စာတွေက “finds simple patterns” (ရိုးရှင်းတဲ့ ပုံစံတွေကို ရှာတယ်)၊ “combines them into shapes” (အဲဒါတွေကို ပုံသဏ္ဌာန်တွေအဖြစ် ပေါင်းတယ်) နဲ့ “decides” (ဆုံးဖြတ်တယ်) ပါ။ အောက်ဘက် စာတွေက အပိုင်း တစ်ခုစီရဲ့ နာမည်နဲ့ သူ ထုတ်ပေးတာပါ: pixel grid (pixel ဇယားကွက်)၊ feature maps + activation၊ smaller maps (ပိုသေးတဲ့ map တွေ)၊ flatten: one long list (list ရှည် တစ်ခု)၊ fully connected: decision (ဆုံးဖြတ်ချက်) နဲ့ output layer: one score per class (class တစ်ခုစီအတွက် score တစ်ခု)။
ကိုယ်တိုင် စမ်းကြည့်ပါ: CNN simulator က filter တစ်ခုကို ပုံပေါ်မှာ အကွက် တစ်ကွက်ချင်း ရွှေ့ပြီး feature map တစ်ခု တည်ဆောက်ပြပါတယ်၊ ပြီးရင် pooling ကို သုံးပြီး ချုံ့ပြတာမို့ convolution နဲ့ pooling ရဲ့ အဆင့် တစ်ဆင့်ချင်းကို ကြည့်နိုင်ပါတယ်။ Simulator ရဲ့ filter ကို list တစ်ခုထဲကနေ ကိုယ်တိုင် ရွေးရပါတယ်၊ train လုပ်ပြီးသား CNN မှာတော့ filter တန်ဖိုးတွေကို သင်ယူထားတာပါ။
CNN ရဲ့ စွမ်းဆောင်ရည်ကို ဘာတွေက ပြောင်းစေလဲ
CNN ကို ဒီဇိုင်းဆွဲတဲ့ လူတွေက ဒီ setting တွေကို train မလုပ်ခင် ရွေးတာမို့ သူတို့က hyperparameter တွေပါ (အဆင့် 3)။ တစ်ခုစီက network က သူ့ input ကို ဘယ်လို process လုပ်လဲ၊ ပုံတွေကို ဘယ်လောက် ကောင်းကောင်း classify (အမျိုးအစား ခွဲခြား) လုပ်လဲ ဆိုတာကို ပြောင်းစေပါတယ်:
| ရွေးချယ်မှု | သူ့ရဲ့ သက်ရောက်မှု |
|---|---|
| Number of layers (layer အရေအတွက်) | Convolutional layer ပိုများရင် network က ပိုရှုပ်ထွေးပြီး ပို abstract ဖြစ်တဲ့ feature တွေ (အနားသတ်တွေကနေ အစိတ်အပိုင်းတွေ၊ အရာဝတ္ထု တစ်ခုလုံးအထိ) ကို တည်ဆောက်နိုင်လို့ ခက်တဲ့ အလုပ်တွေမှာ အထောက်အကူ ဖြစ်ပါတယ်။ ဒါပေမယ့် သင်ယူရမယ့် weight တွေလည်း ပိုများလာလို့ training data နဲ့ ကွန်ပျူတာ တွက်ချိန် ပိုလိုပြီး ဒေတာ အရမ်းနည်းရင် network က overfit ဖြစ်နိုင်ပါတယ်။ Layer အရမ်းနည်းရင် ခက်တဲ့ အလုပ်မှာ underfit ဖြစ်နိုင်ပါတယ် |
| Kernel (filter) size (filter အရွယ်အစား) | 3 × 3 လို filter အသေးက ပုံရဲ့ နေရာ သေးသေးလေးထဲက အသေးစိတ်ကို တုံ့ပြန်ပါတယ်။ 7 × 7 လို filter အကြီးက ဧရိယာ ပိုကြီးကြီးကို တစ်ခါတည်း ကြည့်ပေမယ့် သင်ယူရမယ့် weight ပိုများပြီး နေရာ တိုင်းမှာ တွက်ချက်မှု ပိုများပါတယ်။ Network အများကြီးက အဲဒီအစား filter အသေးတွေ ပါတဲ့ layer အများကြီးကို သုံးကြပါတယ်၊ ဒါမှ နောက်ပိုင်း layer တွေက ပုံရဲ့ ဧရိယာ အကြီးကြီးကို ဖုံးနိုင်မှာပါ |
| Stride (filter တစ်လှမ်းမှာ ရွှေ့တဲ့ pixel အရေအတွက်) | Filter က အဆင့် တစ်ဆင့်စီမှာ pixel ဘယ်နှစ်ခု ရွှေ့လဲ ဆိုတာပါ။ Padding မရှိတဲ့ (ပုံပတ်လည်မှာ pixel အနားသတ် အပို မရှိတဲ့) 7 × 7 ပုံ တစ်ပုံပေါ်မှာ stride 1 နဲ့ 3 × 3 filter က အလျားလိုက် နေရာ 5 ခု၊ ဒေါင်လိုက် နေရာ 5 ခု ဆံ့လို့ 5 × 5 feature map ရပါတယ်။ Stride 2 ဆိုရင် ဘက်တိုင်းမှာ နေရာ 3 ခု ဆံ့လို့ 3 × 3 map ရပါတယ်။ Stride ပိုကြီးရင် တွက်ချက်မှု နည်းပြီး map တွေ ပိုသေးပေမယ့် နေရာတွေကြားက အသေးစိတ်တွေ လွတ်သွားနိုင်ပါတယ် |
| Activation function | ReLU က တွက်ရ မြန်ပြီး deep network တွေ train လုပ်ရတာကို အထောက်အကူ ဖြစ်ပါတယ်။ Sigmoid (S ပုံစံ မျဉ်းကွေး) လို function တွေက တန်ဖိုး တိုင်းကို range ကျဉ်းကျဉ်း တစ်ခုထဲ ဖိသွင်းတာမို့ deep network တွေကို နှေးနှေး သင်ယူစေနိုင်ပါတယ်။ Output layer ကတော့ အလုပ်နဲ့ ကိုက်တဲ့ function ကို သုံးပါတယ်၊ ဥပမာ network က class အများကြီးထဲက တစ်ခုကို ရွေးတဲ့အခါ score တွေကို ပေါင်းရင် 1 ရတဲ့ probability တွေအဖြစ် ပြောင်းပေးတဲ့ function မျိုးပါ |
| Loss function (output ဘယ်လောက် မှားလဲ တိုင်းတဲ့ function) | Training ပုံ တစ်ပုံစီအတွက် network ရဲ့ output ဘယ်လောက် မှားလဲ တိုင်းပါတယ်။ Train လုပ်တာက loss ကို ပိုသေးအောင် filter တန်ဖိုးတွေနဲ့ weight တွေကို ညှိတာမို့ loss function က ဘာကို အဖြေကောင်းလို့ သတ်မှတ်မလဲ ဆုံးဖြတ်ပါတယ်။ Classification အတွက် အသုံးများတဲ့ ရွေးချယ်မှု တစ်ခု (cross-entropy) က ယုံကြည်မှု အပြည့်နဲ့ ဖြေတဲ့ အဖြေမှားကို loss ကြီးကြီး ပေးပါတယ်။ ရှားတဲ့ class ပေါ်က အမှားတွေအတွက် loss ပိုကြီးအောင် loss ကို weight ပေးနိုင်ပြီး ဒါက network ကို အဲဒီ class အတွက် recall ပိုမြင့်အောင် တွန်းပို့ပါတယ် |
အဆင့် 5: Model တွေထဲက ရွေးချယ်ခြင်း (A4.3.10)
ပုံမှန်အားဖြင့် candidate model (ရွေးစရာ model) အများကြီး ရှိပါတယ်: မတူတဲ့ algorithm တွေ၊ ဒါမှမဟုတ် setting မတူတဲ့ algorithm တစ်ခုတည်း။ Model selection ဆိုတာ သူတို့ကို နှိုင်းယှဉ်ပြီး အလုပ်အတွက် တစ်ခုကို ရွေးတာပါ။ မတူတဲ့ algorithm တွေက ဒေတာ အတူတူပေါ်မှာ အတော် မတူတဲ့ ရလဒ်တွေ ပေးနိုင်ပြီး data set တစ်ခုမှာ ကောင်းတဲ့ algorithm က နောက် data set တစ်ခုမှာ ညံ့နိုင်လို့ model selection က အရေးကြီးပါတယ်။ ဒါကြောင့် အဖွဲ့တွေက algorithm တစ်ခုက အကောင်းဆုံးလို့ ယူဆမယ့်အစား candidate အများကြီးကို စမ်းပြီး နှိုင်းယှဉ်ကြပါတယ်။
ပြဿနာကနေ စပါ။ ပြဿနာရဲ့ သဘောသဘာဝက ရွေးချယ်မှုကို ကျဉ်းစေပါတယ်: ကိန်းဂဏန်း တစ်ခုကို ခန့်မှန်းတာက regression (linear regression လို) ပါ၊ category တစ်ခုကို ခန့်မှန်းတာက classification (အမျိုးအစား ခွဲခြားခြင်း၊ k-NN ဒါမှမဟုတ် decision tree လို) ပါ၊ label မပါတဲ့ ဒေတာထဲမှာ အုပ်စုတွေ ရှာတာက clustering (ဆင်တူတာတွေကို အုပ်စုဖွဲ့ခြင်း) ပါ၊ reward (ဆု) တွေကနေ သင်ယူတာက reinforcement learning (ဆုနဲ့ ဒဏ်ကနေ သင်ယူခြင်း) ပါ။ ပုံတွေကို classify လုပ်ရင်တော့ CNN ဘက်ကို ဦးတည်ပါတယ်။
ပြီးရင် ဒေတာကို ကြည့်ပါ။ Algorithm တစ်ခု ဘယ်လောက် ကောင်းကောင်း အလုပ်လုပ်လဲ ဆိုတာ ဒေတာရဲ့ လက္ခဏာတွေနဲ့အမျှ ကွဲပြားပါတယ်:
| ဒေတာရဲ့ လက္ခဏာ | ရွေးချယ်မှုကို ဘယ်လို သက်ရောက်လဲ |
|---|---|
| ဒေတာ ဘယ်လောက် ရှိလဲ | Data set အသေးတွေက overfit ဖြစ်ဖို့ နေရာ နည်းတဲ့ ပိုရိုးရှင်းတဲ့ model တွေ (linear regression၊ အဆင့် နည်းတဲ့ decision tree) နဲ့ ကိုက်ပါတယ်။ k-NN ဘယ်လောက် ပြောင်းလွယ်လဲ ဆိုတာ k ပေါ် မူတည်ပါတယ်၊ k သေးရင် training data ကို နီးနီးကပ်ကပ် လိုက်လို့ပါ။ Deep network တွေကတော့ ပုံမှန်အားဖြင့် data set အကြီးကြီးတွေ လိုပါတယ် |
| ဆက်နွယ်မှုရဲ့ ပုံသဏ္ဌာန် | အကြမ်းအားဖြင့် မျဉ်းဖြောင့် ဆက်နွယ်မှုက linear regression နဲ့ ကိုက်ပါတယ်။ ကွေးတဲ့ ဒါမှမဟုတ် ရှုပ်ထွေးတဲ့ ပုံစံတွေက decision tree ဒါမှမဟုတ် neural network တွေနဲ့ ကိုက်ပါတယ် |
| Feature အရေအတွက် | Feature အများကြီးက k-NN လို အကွာအဝေးပေါ် အခြေခံတဲ့ နည်းတွေအတွက် ပြဿနာ ဖြစ်စေနိုင်ပါတယ်၊ အထူးသဖြင့် အဲဒီ feature အများကြီးက ခန့်မှန်းချက်နဲ့ မဆိုင်တဲ့ ကွဲပြားမှုတွေ ထည့်တဲ့အခါပါ။ Dimension တွေကို လျှော့တာက မကြာခဏ အထောက်အကူ ဖြစ်ပါတယ် (curse of dimensionality) |
| ဒေတာ အမျိုးအစား | ပုံတွေနဲ့ အသံတွေက CNN တွေနဲ့ တခြား deep network တွေနဲ့ ကိုက်ပါတယ်။ တိုင်းတာချက် ဇယားတွေက decision tree ဒါမှမဟုတ် regression နဲ့ မကြာခဏ ကောင်းကောင်း အလုပ်လုပ်ပါတယ် |
| Noise နဲ့ outlier | အရမ်း ပြောင်းလွယ်တဲ့ model တွေက noise ကို အလွတ်ကျက်နိုင်ပြီး outlier အနည်းငယ်က regression မျဉ်းကို ကျန်တဲ့ ဒေတာကနေ ဆွဲထုတ်သွားနိုင်ပါတယ် |
| Class တွေ ဘယ်လောက် မျှတလဲ | Class တစ်ခုက ရှားတဲ့အခါ accuracy က အဲဒီ class ပေါ်က ကျရှုံးမှုတွေကို ဖုံးကွယ်နိုင်လို့ candidate တွေကို recall၊ precision ဒါမှမဟုတ် F1 နဲ့ နှိုင်းယှဉ်ပါတယ် |
ပြီးရင် လိုချင်တဲ့ ရလဒ်တွေကို ချိန်ဆပါ။ ပိုရှုပ်ထွေးတဲ့ model က ပိုကောင်းကောင်း fit ဖြစ်နိုင်ပေမယ့် train လုပ်ဖို့နဲ့ run ဖို့ ပိုကုန်ကျပြီး ရှင်းပြဖို့ ပိုခက်ပါတယ်။ Decision tree ဒါမှမဟုတ် regression မျဉ်းကို ဖတ်ကြည့်လို့ ရပြီး သူ့ ဆုံးဖြတ်ချက်တွေရဲ့ သက်ရောက်မှုကို ခံရတဲ့ လူတွေကို ရှင်းပြနိုင်ပါတယ်။ Deep network ကိုတော့ အလွယ်တကူ ရှင်းပြလို့ မရပါဘူး။ ဖုန်း ဒါမှမဟုတ် ကင်မရာ ပေါ်မှာ run တဲ့ model က သေးပြီး မြန်ရပါမယ်။ ကုန်ကျစရိတ်နဲ့ တရားမျှတမှုကလည်း အရေးပါပါတယ်။
မျှမျှတတ နှိုင်းယှဉ်ပါ။ မျှတတဲ့ နှိုင်းယှဉ်မှုမှာ စည်းမျဉ်း အနည်းငယ် လိုက်နာရပါတယ်:
- Validation data အတူတူပေါ်မှာ နှိုင်းယှဉ်ပါ။ Candidate တိုင်းကို validation set အတူတူ၊ ဒါမှမဟုတ် cross-validation fold (cross-validation မှာ ခွဲထားတဲ့ အပိုင်း) အတူတူပေါ်မှာ score တွက်ပါ၊ ပြီးရင် ရွေးထားတဲ့ model ကိုပဲ သီးခြား test set ပေါ်မှာ တစ်ကြိမ်တည်း အကဲဖြတ်ပါ။ Model တစ်ခုရဲ့ training score ကို နောက် model တစ်ခုရဲ့ validation score နဲ့ နှိုင်းယှဉ်တာက မျှတတဲ့ နှိုင်းယှဉ်မှု မဟုတ်ပါဘူး။
- ပြဿနာနဲ့ ကိုက်တဲ့ metric ကို သုံးပါ။ Imbalanced data အတွက် accuracy တစ်ခုတည်းနဲ့ မဟုတ်ဘဲ precision၊ recall ဒါမှမဟုတ် F1 နဲ့ နှိုင်းယှဉ်ပါ။
- စွမ်းဆောင်ရည် သိပ်မကွာရင် ပိုရိုးရှင်းတဲ့ model ကို ဦးစားပေးပါ။ သူက မကြာခဏ ပိုကောင်းကောင်း generalise လုပ်တယ်၊ ပိုမြန်မြန် run တယ်၊ နားလည်ရ ပြုပြင်ထိန်းသိမ်းရ ပိုလွယ်ပါတယ်။
- Score ထက် ပိုပြီး ချိန်ဆပါ။ Interpretability (model က ဆုံးဖြတ်ချက် တစ်ခုကို ဘယ်လို ရောက်လာလဲ လူတွေ လိုက်နားလည်နိုင်မနိုင်)၊ မြန်နှုန်း၊ ကုန်ကျစရိတ်နဲ့ တရားမျှတမှုက metric တစ်ခုထဲက ကွာခြားချက် အသေးလေးထက် ပိုအရေးကြီးနိုင်ပါတယ်။
အကောင်းဆုံး model က ကိန်း တစ်ခုတည်း အမြင့်ဆုံး ရတဲ့ model သက်သက် ဖြစ်တာ ရှားပါတယ်။ ကောင်းကောင်း အလုပ်လုပ်ပြီးတော့ သူ့ကို သုံးမယ့် နေရာရဲ့ လက်တွေ့ ကန့်သတ်ချက်တွေနဲ့ ကိုက်ညီတဲ့ model ပါ။
Quick Check (အမြန် စစ်ဆေးမေးခွန်း)
Q1. Data cleaning မှာ ဘာတွေ ပါဝင်သလဲ။
Q2. Model တစ်ခုက သူ့ training data မှာ 99% ရပေမယ့် တစ်ခါမှ မမြင်ဖူးတဲ့ ဒေတာ အသစ်မှာ 60% ပဲ ရပါတယ်။ ဒါက ဘာလဲ:
Q3. ပုလင်း ထုပ်ပိုးတဲ့ လိုင်း တစ်ခုမှာ ပုလင်းတွေရဲ့ 2% မှာ ချို့ယွင်းတဲ့ အဖုံး ပါပါတယ်။ Model အသစ် တစ်ခုက ပုလင်း တိုင်းကို "good" (ကောင်းတယ်) လို့ label တပ်ပြီး accuracy 98% ရပါတယ်။ ဒါက ဘာကို ပြသလဲ။
Q4. Linear regression က ဘယ်လို ရလဒ် အမျိုးအစားကို ခန့်မှန်းသလဲ။
Q5. CNN တစ်ခုမှာ convolutional layer တွေက ဘာလုပ်သလဲ။
Q6. Candidate model နှစ်ခုထဲက တစ်ခုကို ရွေးဖို့ မျှတတဲ့ နည်းက ဘာလဲ။
Match the Concept (သဘောတရားနဲ့ တွဲပါ)
ဖော်ပြချက် တစ်ခုစီက ဘယ် concept (သဘောတရား) ကို ညွှန်းနေလဲ နာမည် ပေးပါ: overfitting၊ underfitting၊ precision၊ recall ဒါမှမဟုတ် feature selection။ ဖော်ပြချက်တွေကို English နဲ့ ရေးထားပြီး ကွက်လပ်တွေမှာ concept ရဲ့ English နာမည်ကို ရိုက်ထည့်ရပါမယ်။ Concept: ဆိုတာ သဘောတရား လို့ ဆိုလိုပြီး ဖော်ပြချက် တစ်ခုချင်းရဲ့ အဓိပ္ပာယ်က အောက်ပါအတိုင်းပါ:
- Training data မှာ အရမ်းကောင်းပြီး ဒေတာ အသစ်မှာ ညံ့တယ်: noise ကို အလွတ်ကျက်ထားတယ်
- ပုံစံကို ဖမ်းဖို့ ရိုးလွန်းတယ်၊ training data မှာရော ဒေတာ အသစ်မှာပါ ညံ့တယ်
- တကယ့် positive case အားလုံးထဲက model တကယ် ဖမ်းမိတဲ့ အချိုး
- Model က “yes” လို့ ပြောတဲ့အခါ တကယ် မှန်တဲ့ အချိုး
- Model က အရေးကြီးတာကနေ သင်ယူနိုင်အောင် ဘယ် input တွေကို ထားမလဲ ရွေးတာ
ကွက်လပ် ဖြည့်ပါ။
// Great on training data, poor on new data: it memorised the noise
// Concept:
// Too simple to capture the pattern; poor on training and new data alike
// Concept:
// Of all the real positive cases, the fraction the model actually caught
// Concept:
// When the model says "yes", the fraction of times it is actually right
// Concept:
// Choosing which inputs to keep so the model learns from what matters
// Concept: Practice Exercises (လေ့ကျင့်ခန်းများ)
IB CS လေ့လာသူတွေအတွက် မှတ်ချက်: A4.2 learning statement (IB သင်ရိုးမှာ သင်ယူရမယ့် အချက်) တွေနဲ့ A4.3.9 က Describe (ဖော်ပြရှင်းပြပါ) ဆိုတဲ့ command term (မေးခွန်းမှာ ဘာလုပ်ရမလဲ ပြတဲ့ ညွှန်ကြားချက် စကားလုံး) ကို သုံးပြီး A4.3.1၊ A4.3.3 နဲ့ A4.3.10 က Explain (ရှင်းပြပါ) ကို သုံးပါတယ်။ အောက်က လေ့ကျင့်ခန်းတွေက ဒါတွေကို လေ့ကျင့်ပေးပြီး Discuss (အမြင် အမျိုးမျိုးကို ချိန်ဆပြီး ဆွေးနွေးပါ) ကိုလည်း လေ့ကျင့်ပေးပါတယ်၊ Discuss ဆိုတာ နိဂုံး တစ်ခုကို မရောက်ခင် ဘက်နှစ်ဘက်လုံးကို ချိန်ဆတာပါ။ ဒီမှာ ပါတဲ့ အကြောင်းအရာ အားလုံးက HL ပါ။ (4 marks) လို mark allocation (မေးခွန်း တစ်ခုစီအတွက် ပေးတဲ့ အမှတ်) တွေက IB စာမေးပွဲ ပုံစံအတိုင်း ပေးထားတာပါ၊ IB သင်တန်း မတက်တဲ့သူတွေကတော့ အဖြေ ဘယ်လောက် အသေးစိတ် ရေးရမလဲ ချိန်ကြည့်ဖို့ လမ်းညွှန်အဖြစ် သုံးနိုင်ပါတယ်။
Core (အခြေခံ အဆင့်)
-
Describe (4 marks): Data cleaning မှာ သုံးတဲ့ နည်းစနစ် နှစ်ခုကို describe လုပ်ပြီး train မလုပ်ခင် ဒေတာကို သန့်ရှင်းအောင် လုပ်တာ ဘာကြောင့် အရေးကြီးလဲ explain လုပ်ပါ။
-
Explain (4 marks): Training data ပေါ်မှာနဲ့ မမြင်ဖူးတဲ့ ဒေတာပေါ်မှာ တစ်ခုစီ ဘယ်လို လုပ်ဆောင်လဲ ဆိုတာကို ကိုးကားပြီး overfitting နဲ့ underfitting ကြားက ကွာခြားချက်ကို explain လုပ်ပါ။ ပြီးတော့ decision tree ရဲ့ maximum depth လို hyperparameter တစ်ခုကို tune လုပ်တာက model ကို တစ်ခုကနေ နောက်တစ်ခုဆီ ဘယ်လို ရွှေ့ပေးနိုင်လဲ explain လုပ်ပါ။
-
Explain (4 marks): ကျောင်း စားသောက်ဆောင် တစ်ခုက မနက် 8 နာရီက အပြင်ဘက် အပူချိန်ကနေ နေ့တိုင်း နေ့လယ်စာ ပူပူ ဘယ်နှစ်ပွဲ ရောင်းရမလဲ ခန့်မှန်းပါတယ်။ သူ့ regression မျဉ်းက lunches = 340 - 9 × temperature (in °C) ဖြစ်ပြီး (ဆိုလိုတာက နေ့လယ်စာ အရေအတွက် = 340 - 9 × °C နဲ့ တိုင်းထားတဲ့ အပူချိန်) r² = 0.72 ပါ။ Predictor variable နဲ့ response variable၊ slope၊ intercept နဲ့ r² ကို ကိုးကားပြီး ဒီ model က စားသောက်ဆောင်ကို ဘာ ပြောပြနေလဲ explain လုပ်ပါ။
Extension (တိုးချဲ့ အဆင့်)
-
Explain (6 marks): Accuracy တစ်ခုတည်းက ဘာကြောင့် လမ်းလွဲစေနိုင်လဲ၊ precision နဲ့ recall က ဘယ်လို ပိုပြည့်စုံတဲ့ ပုံကို ပေးလဲ ဆိုတာကို ကိုယ်တိုင် စဉ်းစားထားတဲ့ imbalanced ဥပမာ တစ်ခုနဲ့ explain လုပ်ပါ။
-
Describe (6 marks): CNN တစ်ခုထဲက convolutional layer၊ pooling layer နဲ့ fully connected layer တွေရဲ့ အခန်းကဏ္ဍတွေကို describe လုပ်ပြီး သူတို့က feature တွေရဲ့ spatial hierarchy ကို ဘယ်လို တည်ဆောက်လဲ describe လုပ်ပါ။
-
Describe (6 marks): ကုမ္ပဏီ အသေးလေး တစ်ခုမှာ သူ့ရဲ့ ဘာသာစကား သင်ယူတဲ့ app ကို သုံးတဲ့ user 300 ယောက်ရဲ့ ဒေတာ ရှိပြီး user တစ်ယောက်စီအတွက် feature 220 ခု ပါပါတယ် (သင်ခန်းစာ အချိန်တွေ၊ quiz အမှတ်တွေ၊ setting တွေ၊ device အသေးစိတ်တွေနဲ့ တခြား အများကြီး)။ ဘယ် user တွေ app ကို သုံးတာ ရပ်သွားမလဲ ခန့်မှန်းချင်ပါတယ်။ (a) ဒီဒေတာပေါ်မှာ train လုပ်ထားတဲ့ model အတွက် curse of dimensionality က ဖြစ်စေနိုင်တဲ့ ပြဿနာ နှစ်ခုကို describe လုပ်ပါ။ [4] (b) Feature selection ရဲ့ wrapper method တစ်ခုက feature အရေအတွက်ကို ဘယ်လို လျှော့ပေးနိုင်လဲ describe လုပ်ပြီး ဒီနေရာမှာ အဲဒီ နည်းကို သုံးရင် ဖြစ်နိုင်တဲ့ အားနည်းချက် တစ်ခုကို describe လုပ်ပါ။ [2]
Challenge (စိန်ခေါ်မှု အဆင့်)
- Discuss (8 marks): ရထား ကုမ္ပဏီ တစ်ခုက သံလမ်းတွေကို ဓာတ်ပုံ ရိုက်ဖို့ သူ့ ရထား တစ်စီးရဲ့ အောက်မှာ ကင်မရာ တစ်လုံး တပ်ထားပြီး အက်ကွဲကြောင်း ပါတဲ့ ဓာတ်ပုံတွေကို flag လုပ်ပေးမယ့် model တစ်ခု လိုချင်ပါတယ်။ အက်ကွဲကြောင်းတွေက ရှားပါတယ်။ Candidate model နှစ်ခုကို train လုပ်တာထဲ တစ်ပုံမှ မသုံးခဲ့တဲ့ validation ဓာတ်ပုံ 40,000 အတူတူပေါ်မှာ score တွက်ခဲ့ပါတယ်။ အဲဒီ ဓာတ်ပုံတွေထဲက 20 ပုံမှာ အက်ကွဲကြောင်း ပါပါတယ်။ ရွေးထားတဲ့ model ကို နောက်မှ သီးခြား test set တစ်ခုပေါ်မှာ တစ်ကြိမ် စစ်ပါမယ်။ Model P က ဓာတ်ပုံ 10 ပုံကို flag လုပ်ပြီး အဲဒီထဲက 9 ပုံမှာ အက်ကွဲကြောင်း ပါပါတယ်။ သူက ဓာတ်ပုံ တစ်ပုံစီကနေ ယူထားတဲ့ တိုင်းတာချက် အနည်းငယ်နဲ့ အလုပ်လုပ်တဲ့ decision tree ဖြစ်ပြီး engineer တွေက သူ့ ဆုံးဖြတ်ချက်တွေကို လိုက်နားလည်နိုင်ပါတယ်။ Model Q က ဓာတ်ပုံ 160 ပုံကို flag လုပ်ပြီး အဲဒီထဲက 19 ပုံမှာ အက်ကွဲကြောင်း ပါပါတယ်။ သူက ဓာတ်ပုံတွေကို တိုက်ရိုက် သုံးပြီး အလုပ်လုပ်တဲ့ CNN ဖြစ်ပြီး GPU (ဂရပ်ဖစ် processor) လိုပါတယ်၊ ပြီးတော့ သူ့ ဆုံးဖြတ်ချက်တွေကို အလွယ်တကူ ရှင်းမပြနိုင်ပါဘူး။ သင့်တော်တဲ့ evaluation metric တွေ၊ အမှား အမျိုးအစား တစ်ခုစီရဲ့ ဆိုးကျိုးနဲ့ model selection ထဲက တခြား အချက်တွေကို ကိုးကားပြီး ကုမ္ပဏီက ဘယ် model ကို ရွေးသင့်လဲ Discuss လုပ်ပါ။ အကြောင်းပြချက် ခိုင်လုံတဲ့ နိဂုံး တစ်ခုကို ရောက်အောင် ရေးပါ။ (Code မပါဘဲ စာပိုဒ်နဲ့ ရေးပါ။)
ဆက်စပ် ခေါင်းစဉ်များ
- အရင် လေ့လာထားရမယ့် ခေါင်းစဉ်: What Machine Learning Is (machine learning ဆိုတာ ဘာလဲ): ဒီစာမျက်နှာက အခြေခံထားတဲ့ ဝေါဟာရတွေနဲ့ machine learning အမျိုးအစားတွေ
- အရင် လေ့လာထားရမယ့် ခေါင်းစဉ်: Types of Learning (သင်ယူပုံ အမျိုးအစားများ): ဒီမှာ train လုပ်ပြီး အကဲဖြတ်မယ့် algorithm တွေ
- ဆက်စပ် ခေါင်းစဉ်: Ethics of Machine Learning (machine learning ရဲ့ ကျင့်ဝတ်ဆိုင်ရာ အချက်များ): ဘက်လိုက်နေတဲ့ ဒေတာနဲ့ လမ်းလွဲစေတဲ့ metric တွေက မတရားတဲ့ ဆုံးဖြတ်ချက်တွေဆီ ဦးတည်စေနိုင်ပါတယ်
- ဆက်စပ် ခေါင်းစဉ်: Testing Strategy (စမ်းသပ်ပုံ အစီအစဉ်): model ကို အကဲဖြတ်တာက testing (program မှန်မမှန် စမ်းစစ်ခြင်း) ရဲ့ machine learning ပုံစံပါ
- Stretch (စာမေးပွဲ မမေးတဲ့ ထပ်ဆင့် လေ့လာစရာ): How Large Language Models Work (Large language model တွေ ဘယ်လို အလုပ်လုပ်သလဲ) က neural network တွေ (A4.3.8) နဲ့ စကားလုံးတွေကို ကိန်းဂဏန်းတွေအဖြစ် ကျစ်ကျစ်လျစ်လျစ် ဖော်ပြတာ (A4.2.3) ကို စာသား ထုတ်ဖို့ ဘယ်လို သုံးလဲ ပြပါတယ်။ How AI Image Generation Works (AI က ပုံတွေကို ဘယ်လို ဖန်တီးသလဲ) က ပုံတွေကို ချုံ့ပြီး ပြန်တည်ဆောက်ဖို့ dimensionality reduction (A4.2.3) ကို သုံးတဲ့ network တစ်မျိုး ဖြစ်တဲ့ autoencoder ကို ပြပြီး ပုံ ဖန်တီးတဲ့ နည်း သုံးမျိုးကို နှိုင်းယှဉ်ပါတယ်။