From ca08eb4b72e17709597ac0acbbb80be0f727b96e Mon Sep 17 00:00:00 2001 From: Kalix Louiis Date: Tue, 7 Oct 2025 22:50:18 +0630 Subject: [PATCH] feat(my): Add Myanmar translation for Chapter 8 and per-chapter Glossary --- chapters/my/_toctree.yml | 36 +- chapters/my/chapter8/1.mdx | 35 ++ chapters/my/chapter8/2.mdx | 432 ++++++++++++++++ chapters/my/chapter8/3.mdx | 210 ++++++++ chapters/my/chapter8/4.mdx | 897 ++++++++++++++++++++++++++++++++++ chapters/my/chapter8/4_tf.mdx | 564 +++++++++++++++++++++ chapters/my/chapter8/5.mdx | 125 +++++ chapters/my/chapter8/6.mdx | 12 + chapters/my/chapter8/7.mdx | 257 ++++++++++ 9 files changed, 2550 insertions(+), 18 deletions(-) create mode 100644 chapters/my/chapter8/1.mdx create mode 100644 chapters/my/chapter8/2.mdx create mode 100644 chapters/my/chapter8/3.mdx create mode 100644 chapters/my/chapter8/4.mdx create mode 100644 chapters/my/chapter8/4_tf.mdx create mode 100644 chapters/my/chapter8/5.mdx create mode 100644 chapters/my/chapter8/6.mdx create mode 100644 chapters/my/chapter8/7.mdx diff --git a/chapters/my/_toctree.yml b/chapters/my/_toctree.yml index 5261b6c1f..552a89b54 100644 --- a/chapters/my/_toctree.yml +++ b/chapters/my/_toctree.yml @@ -153,24 +153,24 @@ title: အခန်း (၇) ဆိုင်ရာ မေးခွန်းများ quiz: 7 -# - title: 8. How to ask for help -# sections: -# - local: chapter8/1 -# title: Introduction -# - local: chapter8/2 -# title: What to do when you get an error -# - local: chapter8/3 -# title: Asking for help on the forums -# - local: chapter8/4 -# title: Debugging the training pipeline -# local_fw: { pt: chapter8/4, tf: chapter8/4_tf } -# - local: chapter8/5 -# title: How to write a good issue -# - local: chapter8/6 -# title: Part 2 completed! -# - local: chapter8/7 -# title: End-of-chapter quiz -# quiz: 8 +- title: 8. အကူအညီတောင်းခံနည်း + sections: + - local: chapter8/1 + title: နိဒါန်း + - local: chapter8/2 + title: Error တစ်ခုကြုံတွေ့ရတဲ့အခါ ဘာလုပ်ရမလဲ + - local: chapter8/3 + title: Forums များတွင် အကူအညီတောင်းခံခြင်း + - local: chapter8/4 + title: Training Pipeline ကို Debugging လုပ်ခြင်း + local_fw: { pt: chapter8/4, tf: chapter8/4_tf } + - local: chapter8/5 + title: ကောင်းမွန်သော Issue တစ်ခု ရေးသားနည်း + - local: chapter8/6 + title: အပိုင်း ၂ ပြီးဆုံးပါပြီ! + - local: chapter8/7 + title: အခန်း (၈) ဆိုင်ရာ မေးခွန်းများ + quiz: 8 # - title: 9. Building and sharing demos # subtitle: I trained a model, but how can I show it off? diff --git a/chapters/my/chapter8/1.mdx b/chapters/my/chapter8/1.mdx new file mode 100644 index 000000000..69b0202f2 --- /dev/null +++ b/chapters/my/chapter8/1.mdx @@ -0,0 +1,35 @@ +# နိဒါန်း[[introduction]] + + + +🤗 Transformers ကို အသုံးပြုပြီး အသုံးအများဆုံး NLP tasks တွေကို ဘယ်လိုကိုင်တွယ်ဖြေရှင်းရမယ်ဆိုတာ သင်သိပြီဆိုတော့၊ သင်ကိုယ်ပိုင် projects တွေကို စတင်နိုင်ပါပြီ။ ဒီအခန်းမှာ ကျွန်တော်တို့ဟာ ပြဿနာတစ်ခု ကြုံတွေ့ရတဲ့အခါ ဘာလုပ်ရမလဲဆိုတာကို လေ့လာသွားမှာပါ။ သင့်ရဲ့ code ဒါမှမဟုတ် training ကို ဘယ်လိုအောင်မြင်စွာ debug လုပ်ရမလဲ၊ ပြီးတော့ သင်ကိုယ်တိုင် ပြဿနာကို ဖြေရှင်းနိုင်ခြင်းမရှိရင် community ကနေ ဘယ်လိုအကူအညီတောင်းရမလဲဆိုတာ သင်ယူရပါလိမ့်မယ်။ ပြီးတော့ Hugging Face libraries တွေထဲက တစ်ခုမှာ bug တစ်ခု တွေ့ပြီလို့ သင်ထင်တယ်ဆိုရင်၊ ပြဿနာကို အမြန်ဆုံးဖြေရှင်းနိုင်ဖို့ အကောင်းဆုံးအစီရင်ခံနည်းကို ကျွန်တော်တို့ ပြသပေးပါမယ်။ + +ပိုမိုတိကျစွာပြောရရင်၊ ဒီအခန်းမှာ သင်ယူရမယ့်အရာတွေကတော့... + +- error ရတဲ့အခါ ပထမဆုံး လုပ်သင့်တဲ့အရာ +- [forums](https://discuss.huggingface.co/) မှာ အကူအညီ ဘယ်လိုတောင်းရမလဲ +- သင့်ရဲ့ training pipeline ကို ဘယ်လို debug လုပ်ရမလဲ +- ကောင်းမွန်တဲ့ issue တစ်ခုကို ဘယ်လိုရေးရမလဲ + +ဒါတွေထဲက ဘယ်တစ်ခုမှ 🤗 Transformers ဒါမှမဟုတ် Hugging Face ecosystem နဲ့ သီးခြားသက်ဆိုင်တာ မဟုတ်ပါဘူး၊ ဒီအခန်းကနေ ရရှိမယ့် သင်ခန်းစာတွေဟာ open source projects အများစုနဲ့ သက်ဆိုင်ပါတယ်။ + +## ဝေါဟာရ ရှင်းလင်းချက် (Glossary) + +* **NLP Tasks (Natural Language Processing Tasks)**: ကွန်ပျူတာတွေ လူသားဘာသာစကားကို နားလည်၊ အဓိပ္ပာယ်ဖော်ပြီး၊ ဖန်တီးနိုင်အောင် လုပ်ဆောင်ပေးတဲ့ အလုပ်တွေ (ဥပမာ- text classification, question answering)။ +* **🤗 Transformers Library**: Hugging Face က ထုတ်လုပ်ထားတဲ့ library တစ်ခုဖြစ်ပြီး Transformer မော်ဒယ်တွေကို အသုံးပြုပြီး Natural Language Processing (NLP), computer vision, audio processing စတဲ့ နယ်ပယ်တွေမှာ အဆင့်မြင့် AI မော်ဒယ်တွေကို တည်ဆောက်ပြီး အသုံးပြုနိုင်စေပါတယ်။ +* **Projects**: သတ်မှတ်ထားသော ရည်ရွယ်ချက်တစ်ခုကို ပြည့်မီရန် စီစဉ်ထားသော အလုပ်။ +* **Debug**: ကွန်ပျူတာပရိုဂရမ်တစ်ခုရှိ အမှားများ (bugs) ကို ရှာဖွေ၊ ဖော်ထုတ်ပြီး ပြင်ဆင်ခြင်း။ +* **Training**: Artificial Intelligence (AI) သို့မဟုတ် Machine Learning (ML) မော်ဒယ်တစ်ခုကို ဒေတာများဖြင့် လေ့ကျင့်ပေးသည့် လုပ်ငန်းစဉ်။ +* **Community**: Hugging Face တွင် AI/ML နယ်ပယ်မှ သုံးစွဲသူများ၊ developer များ နှင့် သုတေသီများ စုစည်းထားသော အဖွဲ့အစည်း။ +* **Bug**: ဆော့ဖ်ဝဲလ်တစ်ခု၏ code ထဲတွင်ရှိသော အမှားတစ်ခုကြောင့် ပရိုဂရမ်သည် မျှော်လင့်ထားသည့်အတိုင်း အလုပ်မလုပ်ခြင်း။ +* **Hugging Face Libraries**: Hugging Face မှ ထုတ်လုပ်ထားသော ဆော့ဖ်ဝဲလ် library များ (ဥပမာ- 🤗 Transformers, 🤗 Datasets, 🤗 Tokenizers, 🤗 Accelerate)။ +* **Report**: ပြဿနာတစ်ခု သို့မဟုတ် bug တစ်ခုကို တရားဝင်အကြောင်းကြားခြင်း။ +* **Error**: ပရိုဂရမ်တစ်ခု အလုပ်လုပ်နေစဉ် ဖြစ်ပေါ်လာသော ပြဿနာတစ်ခုကြောင့် ၎င်းသည် ပုံမှန်အတိုင်း ဆက်လက်လုပ်ဆောင်နိုင်ခြင်းမရှိခြင်း။ +* **Forums**: အွန်လိုင်းဆွေးနွေးပွဲ ဖိုရမ်များ။ +* **Training Pipeline**: Machine Learning မော်ဒယ်တစ်ခုကို data preprocessing မှစ၍ model training, evaluation အထိ ပါဝင်သော အဆင့်များစွာရှိသည့် လုပ်ငန်းစဉ်။ +* **Issue**: ဆော့ဖ်ဝဲလ် project တစ်ခုတွင် တွေ့ရှိရသော bug, feature request, သို့မဟုတ် ပြဿနာတစ်ခု။ ၎င်းကို GitHub Issues ကဲ့သို့သော platform များတွင် မှတ်တမ်းတင်ထားသည်။ +* **Hugging Face Ecosystem**: Hugging Face ကုမ္ပဏီမှ ဖန်တီးထားတဲ့ AI နဲ့ machine learning အတွက် ကိရိယာတွေ၊ library တွေ၊ မော်ဒယ်တွေနဲ့ platform တွေရဲ့ အစုအဝေးတစ်ခုပါ။ +* **Open Source Projects**: ၎င်းတို့၏ source code ကို အများပြည်သူအား လွတ်လပ်စွာ အသုံးပြု၊ ပြင်ဆင်၊ ဖြန့်ဝေခွင့်ပြုထားသော ဆော့ဖ်ဝဲလ် project များ။ \ No newline at end of file diff --git a/chapters/my/chapter8/2.mdx b/chapters/my/chapter8/2.mdx new file mode 100644 index 000000000..342e3486a --- /dev/null +++ b/chapters/my/chapter8/2.mdx @@ -0,0 +1,432 @@ + + +# Error တစ်ခုရတဲ့အခါ ဘာလုပ်ရမလဲ။[[what-to-do-when-you-get-an-error]] + + + +ဒီအပိုင်းမှာ သင် အသစ် tune လုပ်ထားတဲ့ Transformer model ကနေ predictions တွေ ထုတ်လုပ်ဖို့ ကြိုးစားတဲ့အခါ ဖြစ်ပေါ်နိုင်တဲ့ အဖြစ်များတဲ့ errors အချို့ကို ကြည့်ရပါမယ်။ ဒါက [အပိုင်း ၄](/course/chapter8/section4) အတွက် သင့်ကို ပြင်ဆင်ပေးပါလိမ့်မယ်။ အဲဒီမှာ ကျွန်တော်တို့ training phase ကို ဘယ်လို debug လုပ်ရမလဲဆိုတာ လေ့လာသွားမှာပါ။ + + + +ဒီအပိုင်းအတွက် [template model repository](https://huggingface.co/lewtun/distilbert-base-uncased-finetuned-squad-d5716d28) တစ်ခုကို ကျွန်တော်တို့ ပြင်ဆင်ထားပါတယ်။ ဒီအခန်းမှာ code ကို run ချင်တယ်ဆိုရင် ပထမဆုံး model ကို သင်ရဲ့ account ပေါ်က [Hugging Face Hub](https://huggingface.co) သို့ copy လုပ်ဖို့ လိုအပ်ပါလိမ့်မယ်။ ဒါကိုလုပ်ဖို့၊ Jupyter notebook မှာ အောက်ပါတို့ကို run ခြင်းဖြင့် အရင်ဆုံး log in ဝင်ပါ။ + +```python +from huggingface_hub import notebook_login + +notebook_login() +``` + +သို့မဟုတ် သင်အကြိုက်ဆုံး terminal မှာ အောက်ပါတို့ကို run ပါ။ + +```bash +huggingface-cli login +``` + +ဒါက သင့် username နဲ့ password ကို ထည့်သွင်းဖို့ တောင်းဆိုပါလိမ့်မယ်၊ ပြီးတော့ token တစ်ခုကို *~/.cache/huggingface/* အောက်မှာ သိမ်းဆည်းပါလိမ့်မယ်။ log in ဝင်ပြီးတာနဲ့၊ အောက်ပါ function နဲ့ template repository ကို copy လုပ်နိုင်ပါတယ်။ + +```python +from distutils.dir_util import copy_tree +from huggingface_hub import Repository, snapshot_download, create_repo, get_full_repo_name + + +def copy_repository_template(): + # repo ကို clone လုပ်ပြီး local path ကို ထုတ်ယူပါ + template_repo_id = "lewtun/distilbert-base-uncased-finetuned-squad-d5716d28" + commit_hash = "be3eaffc28669d7932492681cd5f3e8905e358b4" + template_repo_dir = snapshot_download(template_repo_id, revision=commit_hash) + # Hub ပေါ်မှာ empty repo တစ်ခု ဖန်တီးပါ + model_name = template_repo_id.split("/")[1] + create_repo(model_name, exist_ok=True) + # empty repo ကို clone လုပ်ပါ + new_repo_id = get_full_repo_name(model_name) + new_repo_dir = model_name + repo = Repository(local_dir=new_repo_dir, clone_from=new_repo_id) + # ဖိုင်တွေကို copy လုပ်ပါ + copy_tree(template_repo_dir, new_repo_dir) + # Hub သို့ push လုပ်ပါ + repo.push_to_hub() +``` + +အခု `copy_repository_template()` ကို ခေါ်လိုက်တဲ့အခါ၊ ဒါက template repository ရဲ့ copy တစ်ခုကို သင့် account အောက်မှာ ဖန်တီးပါလိမ့်မယ်။ + +## 🤗 Transformers ရဲ့ pipeline ကို Debug လုပ်ခြင်း[[debugging-the-pipeline-from-transformers]] + +Transformer models တွေကို debug လုပ်တဲ့ အံ့ဖွယ်ကောင်းတဲ့ ကမ္ဘာဆီ ကျွန်တော်တို့ရဲ့ ခရီးကို စတင်ဖို့အတွက်၊ အောက်ပါအခြေအနေကို စဉ်းစားကြည့်ပါ- သင်ဟာ e-commerce website တစ်ခုက customers တွေကို consumer products တွေအကြောင်း အဖြေရှာဖို့ ကူညီဖို့အတွက် question answering project တစ်ခုမှာ လုပ်ဖော်ကိုင်ဖက်တစ်ဦးနဲ့ အလုပ်လုပ်နေပါတယ်။ သင့်လုပ်ဖော်ကိုင်ဖက်က သင့်ဆီကို အောက်ပါစာတစ်စောင် ပို့လိုက်ပါတယ်။ + +> G'day! ကျွန်တော် Hugging Face course ရဲ့ [Chapter 7](/course/chapter7/7) မှာပါတဲ့ နည်းလမ်းတွေကို အသုံးပြုပြီး experiment တစ်ခု run ခဲ့တာ SQuAD ပေါ်မှာ ရလဒ်ကောင်းတွေ ရခဲ့တယ်။ ကျွန်တော်တို့ ဒီ model ကို ကျွန်တော်တို့ project အတွက် starting point အဖြစ် အသုံးပြုနိုင်မယ်လို့ ထင်တယ်။ Hub ပေါ်က model ID က "lewtun/distillbert-base-uncased-finetuned-squad-d5716d28" ပါ။ စိတ်ကြိုက် စမ်းသပ်ကြည့်ပါ။ :) + +ပြီးတော့ သင်ပထမဆုံး တွေးမိတာက 🤗 Transformers က `pipeline` ကို အသုံးပြုပြီး model ကို load လုပ်ဖို့ပါပဲ။ + +```python +from transformers import pipeline + +model_checkpoint = get_full_repo_name("distillbert-base-uncased-finetuned-squad-d5716d28") +reader = pipeline("question-answering", model=model_checkpoint) +``` + +```python out +""" +OSError: Can't load config for 'lewtun/distillbert-base-uncased-finetuned-squad-d5716d28'. Make sure that: + +- 'lewtun/distillbert-base-uncased-finetuned-squad-d5716d28' is a correct model identifier listed on 'https://huggingface.co/models' + +- or 'lewtun/distillbert-base-uncased-finetuned-squad-d5716d28' is the correct path to a directory containing a config.json file +""" +``` + +ဟာ မဟုတ်သေးဘူး၊ တစ်ခုခု မှားနေပုံရတယ်။ သင် programming နဲ့ အခုမှ စတင်သူဆိုရင် ဒီလို errors တွေက ပထမတော့ နားမလည်နိုင်ပုံရနိုင်ပါတယ် (`OSError` ဆိုတာ ဘာလဲ?! )။ ဒီမှာ ပြသထားတဲ့ error က Python traceback (aka stack trace) လို့ခေါ်တဲ့ အများကြီး ပိုကြီးတဲ့ error report ရဲ့ နောက်ဆုံးအပိုင်းပဲ ရှိပါသေးတယ်။ ဥပမာ၊ ဒီ code ကို Google Colab မှာ run နေတယ်ဆိုရင်၊ အောက်ပါ screenshot လိုမျိုး တစ်ခုခုကို သင်တွေ့ရပါလိမ့်မယ်။ + +
+A Python traceback. +
+ +ဒီ reports တွေထဲမှာ အချက်အလက်များစွာ ပါဝင်တာကြောင့်၊ အဓိက အစိတ်အပိုင်းတွေကို အတူတူ လေ့လာကြည့်ရအောင်။ ပထမဆုံး သတိပြုရမယ့်အချက်က tracebacks တွေကို _အောက်ကနေ အပေါ်သို့_ ဖတ်ရတာပါပဲ။ English စာသားကို အပေါ်ကနေ အောက်ကို ဖတ်လေ့ရှိတဲ့ သင်အတွက် ဒါက ထူးဆန်းနိုင်ပါတယ်၊ ဒါပေမယ့် ဒါက model နဲ့ tokenizer ကို download လုပ်တဲ့အခါ `pipeline` က လုပ်ဆောင်တဲ့ function calls တွေရဲ့ sequence ကို traceback က ပြသနေတာကို ထင်ဟပ်ပါတယ်။ (`pipeline` က ဘယ်လိုအလုပ်လုပ်တယ်ဆိုတာ အသေးစိတ်သိရှိဖို့ [Chapter 2](/course/chapter2) ကို ကြည့်ပါ)။ + +> [!TIP] +> 🚨 Google Colab က traceback မှာ "6 frames" ကို ဝန်းရံထားတဲ့ အပြာရောင် box ကို တွေ့လား? ဒါက Colab ရဲ့ special feature တစ်ခုဖြစ်ပြီး traceback ကို "frames" တွေအဖြစ် ဖိသိပ်ထားပါတယ်။ error ရဲ့ source ကို မရှာတွေ့ဘူးဆိုရင်၊ အဲဒီ မြှားနှစ်စင်းကို နှိပ်ပြီး traceback အပြည့်အစုံကို ချဲ့ကြည့်ဖို့ သေချာပါစေ။ + +ဒါက traceback ရဲ့ နောက်ဆုံးလိုင်းက နောက်ဆုံး error message ကို ဖော်ပြပြီး raise လုပ်ခဲ့တဲ့ exception ရဲ့ နာမည်ကို ပေးတယ်လို့ ဆိုလိုပါတယ်။ ဒီကိစ္စမှာ exception အမျိုးအစားက `OSError` ဖြစ်ပြီး၊ ဒါက system နဲ့ ဆက်စပ်တဲ့ error တစ်ခုကို ဖော်ပြပါတယ်။ အတူပါလာတဲ့ error message ကို ဖတ်ကြည့်မယ်ဆိုရင်၊ model ရဲ့ *config.json* file မှာ ပြဿနာတစ်ခုခု ရှိပုံရတယ်ဆိုတာ မြင်ရပြီး၊ ဒါကို ဖြေရှင်းဖို့ အကြံပြုချက်နှစ်ခု ပေးထားပါတယ်။ + +```python out +""" +Make sure that: + +- 'lewtun/distillbert-base-uncased-finetuned-squad-d5716d28' is a correct model identifier listed on 'https://huggingface.co/models' + +- or 'lewtun/distillbert-base-uncased-finetuned-squad-d5716d28' is the correct path to a directory containing a config.json file +""" +``` + +> [!TIP] +> 💡 နားလည်ရခက်တဲ့ error message တစ်ခု ကြုံတွေ့ရရင်၊ message ကို Google ဒါမှမဟုတ် [Stack Overflow](https://stackoverflow.com/) ရဲ့ search bar ထဲကို copy လုပ်ပြီး paste လုပ်လိုက်ပါ (တကယ်ပါပဲ!)။ သင်ဟာ error ကို ပထမဆုံး ကြုံတွေ့ရသူ မဟုတ်နိုင်တာကြောင့်၊ community ထဲက တခြားသူတွေ တင်ထားတဲ့ ဖြေရှင်းနည်းတွေကို ရှာဖွေဖို့ ဒါက ကောင်းမွန်တဲ့ နည်းလမ်းတစ်ခုပါပဲ။ ဥပမာ၊ Stack Overflow ပေါ်မှာ `OSError: Can't load config for` ကို ရှာဖွေကြည့်မယ်ဆိုရင် ပြဿနာကို ဖြေရှင်းဖို့ starting point အဖြစ် အသုံးပြုနိုင်တဲ့ [hits](https://stackoverflow.com/search?q=OSError%3A+Can%27t+load+config+for+) အချို့ကို ပေးပါလိမ့်မယ်။ + +ပထမဆုံး အကြံပြုချက်က model ID မှန်ကန်ခြင်းရှိမရှိ စစ်ဆေးခိုင်းတာကြောင့်၊ ပထမဆုံး လုပ်ရမယ့်အလုပ်က identifier ကို copy လုပ်ပြီး Hub ရဲ့ search bar ထဲကို paste လုပ်ဖို့ပါပဲ။ + +
+The wrong model name. +
+ +အင်း၊ ကျွန်တော်တို့ လုပ်ဖော်ကိုင်ဖက်ရဲ့ model က Hub မှာ မရှိပုံရတယ်... ဟာ၊ ဒါပေမယ့် model ရဲ့ နာမည်မှာ typo တစ်ခုရှိနေတယ်။ DistilBERT မှာ "l" တစ်လုံးပဲ ပါတာကြောင့်၊ ဒါကို ပြင်ပြီး "lewtun/distilbert-base-uncased-finetuned-squad-d5716d28" ကို အစားရှာကြည့်ရအောင်။ + +
+The right model name. +
+ +ကောင်းပြီ၊ ဒါက hit တစ်ခုရခဲ့တယ်။ အခုမှန်ကန်တဲ့ model ID နဲ့ model ကို ထပ်မံ download လုပ်ကြည့်ရအောင်... + +```python +model_checkpoint = get_full_repo_name("distilbert-base-uncased-finetuned-squad-d5716d28") +reader = pipeline("question-answering", model=model_checkpoint) +``` + +```python out +""" +OSError: Can't load config for 'lewtun/distilbert-base-uncased-finetuned-squad-d5716d28'. Make sure that: + +- 'lewtun/distilbert-base-uncased-finetuned-squad-d5716d28' is a correct model identifier listed on 'https://huggingface.co/models' + +- or 'lewtun/distilbert-base-uncased-finetuned-squad-d5716d28' is the correct path to a directory containing a config.json file +""" +``` + +ဟာ၊ ထပ်ပြီး ဖျက်ဆီးခံရပြန်ပြီ -- machine learning engineer တစ်ယောက်ရဲ့ နေ့စဉ်ဘဝကို ကြိုဆိုပါတယ်။ model ID ကို ကျွန်တော်တို့ ပြင်ဆင်ပြီးသွားပြီဖြစ်တဲ့အတွက်၊ ပြဿနာက repository ထဲမှာ ရှိနေရပါမယ်။ 🤗 Hub ပေါ်က repository တစ်ခုရဲ့ အကြောင်းအရာတွေကို မြန်မြန်ဆန်ဆန် ဝင်ရောက်ကြည့်ရှုဖို့ နည်းလမ်းတစ်ခုက `huggingface_hub` library ရဲ့ `list_repo_files()` function ကို အသုံးပြုခြင်းပါပဲ။ + +```python +from huggingface_hub import list_repo_files + +list_repo_files(repo_id=model_checkpoint) +``` + +```python out +['.gitattributes', 'README.md', 'pytorch_model.bin', 'special_tokens_map.json', 'tokenizer_config.json', 'training_args.bin', 'vocab.txt'] +``` + +စိတ်ဝင်စားစရာကောင်းတယ် -- repository ထဲမှာ *config.json* file မရှိပုံရဘူး။ ကျွန်တော်တို့ရဲ့ `pipeline` က model ကို load မလုပ်နိုင်တာ အံ့သြစရာမရှိပါဘူး၊ ကျွန်တော်တို့ လုပ်ဖော်ကိုင်ဖက်က fine-tune လုပ်ပြီးနောက် ဒီ file ကို Hub သို့ push လုပ်ဖို့ မေ့သွားတာ ဖြစ်ရပါမယ်။ ဒီကိစ္စမှာ၊ ပြဿနာက ဖြေရှင်းရတာ ရိုးရှင်းပုံရပါတယ်- သူတို့ကို file ထည့်ဖို့ တောင်းဆိုနိုင်ပါတယ်၊ ဒါမှမဟုတ် model ID ကနေ pretrained model က [`distilbert-base-uncased`](https://huggingface.co/distilbert-base-uncased) ဖြစ်တယ်ဆိုတာ မြင်ရတာကြောင့်၊ ဒီ model အတွက် config ကို download လုပ်ပြီး ကျွန်တော်တို့ repo ကို push လုပ်ခြင်းဖြင့် ပြဿနာဖြေရှင်းနိုင်မလားဆိုတာ ကြည့်နိုင်ပါတယ်။ အဲဒါကို စမ်းကြည့်ရအောင်။ [Chapter 2](/course/chapter2) မှာ ကျွန်တော်တို့ သင်ယူခဲ့တဲ့ နည်းလမ်းတွေကို အသုံးပြုပြီး၊ model ရဲ့ configuration ကို `AutoConfig` class နဲ့ download လုပ်နိုင်ပါတယ်။ + +```python +from transformers import AutoConfig + +pretrained_checkpoint = "distilbert-base-uncased" +config = AutoConfig.from_pretrained(pretrained_checkpoint) +``` + +> [!WARNING] +> 🚨 ကျွန်တော်တို့ ဒီနေရာမှာ အသုံးပြုနေတဲ့ နည်းလမ်းက အမြဲတမ်း မှန်ကန်တာ မဟုတ်ပါဘူး၊ ဘာလို့လဲဆိုတော့ ကျွန်တော်တို့ လုပ်ဖော်ကိုင်ဖက်က model ကို fine-tuning မလုပ်ခင် `distilbert-base-uncased` ရဲ့ configuration ကို ပြောင်းလဲထားနိုင်လို့ပါပဲ။ တကယ့်ဘဝမှာတော့ ကျွန်တော်တို့ အရင်ဆုံး သူတို့နဲ့ စစ်ဆေးချင်ပါလိမ့်မယ်၊ ဒါပေမယ့် ဒီအပိုင်းရဲ့ ရည်ရွယ်ချက်အတွက်တော့ သူတို့က default configuration ကို အသုံးပြုခဲ့တယ်လို့ ယူဆပါမယ်။ + +ပြီးရင် ဒါကို configuration ရဲ့ `push_to_hub()` function နဲ့ ကျွန်တော်တို့ရဲ့ model repository ကို push လုပ်နိုင်ပါတယ်။ + +```python +config.push_to_hub(model_checkpoint, commit_message="Add config.json") +``` + +အခု `main` branch ပေါ်က နောက်ဆုံး commit ကနေ model ကို load လုပ်ခြင်းဖြင့် ဒါက အလုပ်ဖြစ်လားဆိုတာ စစ်ဆေးနိုင်ပါပြီ- + +```python +reader = pipeline("question-answering", model=model_checkpoint, revision="main") + +context = r""" +Extractive Question Answering is the task of extracting an answer from a text +given a question. An example of a question answering dataset is the SQuAD +dataset, which is entirely based on that task. If you would like to fine-tune a +model on a SQuAD task, you may leverage the +examples/pytorch/question-answering/run_squad.py script. + +🤗 Transformers is interoperable with the PyTorch, TensorFlow, and JAX +frameworks, so you can use your favourite tools for a wide variety of tasks! +""" + +question = "What is extractive question answering?" +reader(question=question, context=context) +``` + +```python out +{'score': 0.38669535517692566, + 'start': 34, + 'end': 95, + 'answer': 'the task of extracting an answer from a text given a question'} +``` + +ဝိုး၊ အလုပ်ဖြစ်သွားပြီ! သင် ခုလေးတင် သင်ယူခဲ့တာတွေကို ပြန်လည်အကျဉ်းချုပ်ကြည့်ရအောင်... + +- Python မှာ errors တွေကို _tracebacks_ လို့သိကြပြီး အောက်ကနေ အပေါ်သို့ ဖတ်ရပါတယ်။ error message ရဲ့ နောက်ဆုံးလိုင်းက ပြဿနာရဲ့ source ကို ရှာဖွေဖို့ လိုအပ်တဲ့ အချက်အလက်တွေကို အများအားဖြင့် ပါဝင်ပါတယ်။ +- နောက်ဆုံးလိုင်းမှာ လုံလောက်တဲ့ အချက်အလက်တွေ မပါဝင်ဘူးဆိုရင်၊ traceback ကို အပေါ်ကိုတက်ပြီး error ဘယ်နေရာမှာ ဖြစ်ခဲ့လဲဆိုတာ source code ထဲမှာ ဖော်ထုတ်နိုင်မလားဆိုတာ ကြည့်ပါ။ +- error messages တွေထဲက တစ်ခုမှ သင့်ကို ပြဿနာ debug လုပ်ဖို့ မကူညီနိုင်ဘူးဆိုရင်၊ အလားတူပြဿနာအတွက် online မှာ ဖြေရှင်းနည်း ရှာဖွေကြည့်ပါ။ +- `huggingface_hub` library က Hub ပေါ်က repositories တွေနဲ့ အပြန်အလှန်တုံ့ပြန်ဖို့နဲ့ debug လုပ်ဖို့ အသုံးပြုနိုင်တဲ့ ကိရိယာအစုံအလင်ကို ပံ့ပိုးပေးပါတယ်။ + +အခု pipeline ကို ဘယ်လို debug လုပ်ရမလဲဆိုတာ သင်သိပြီဆိုတော့၊ model ရဲ့ forward pass မှာ ပိုမိုခက်ခဲတဲ့ ဥပမာတစ်ခုကို ကြည့်ရအောင်။ + +## သင့် Model ၏ Forward Pass ကို Debug လုပ်ခြင်း[[debugging-the-forward-pass-of-your-model]] + +`pipeline` က predictions တွေကို မြန်မြန်ဆန်ဆန် ထုတ်လုပ်ဖို့ လိုအပ်တဲ့ applications အများစုအတွက် ကောင်းမွန်ပေမယ့်၊ တခါတလေ model ရဲ့ logits တွေကို ဝင်ရောက်ကြည့်ရှုဖို့ လိုအပ်ပါလိမ့်မယ် (ဥပမာ- သင်အသုံးပြုချင်တဲ့ custom post-processing အချို့ရှိရင်)။ ဒီကိစ္စမှာ ဘာတွေမှားနိုင်သလဲဆိုတာ ကြည့်ဖို့၊ ကျွန်တော်တို့ရဲ့ `pipeline` ကနေ model နဲ့ tokenizer ကို အရင်ဆုံး ယူလိုက်ရအောင်။ + +```python +tokenizer = reader.tokenizer +model = reader.model +``` + +နောက်ထပ် မေးခွန်းတစ်ခု လိုအပ်တာကြောင့်၊ ကျွန်တော်တို့ အကြိုက်ဆုံး frameworks တွေကို ထောက်ပံ့ပေးထားခြင်းရှိမရှိ ကြည့်ရအောင်။ + +```python +question = "Which frameworks can I use?" +``` + +[Chapter 7](/course/chapter7) မှာ ကျွန်တော်တို့ တွေ့ခဲ့ရတဲ့အတိုင်း၊ ကျွန်တော်တို့ လုပ်ဆောင်ရမယ့် ပုံမှန်အဆင့်တွေက inputs တွေကို tokenize လုပ်တာ၊ start နဲ့ end tokens တွေရဲ့ logits တွေကို ထုတ်ယူတာ၊ ပြီးတော့ answer span ကို decode လုပ်တာတွေပါပဲ- + +```python +import torch + +inputs = tokenizer(question, context, add_special_tokens=True) +input_ids = inputs["input_ids"][0] +outputs = model(**inputs) +answer_start_scores = outputs.start_logits +answer_end_scores = outputs.end_logits +# score ရဲ့ argmax နဲ့ answer ရဲ့ အဖြစ်နိုင်ဆုံး အစကို ရယူပါ +answer_start = torch.argmax(answer_start_scores) +# score ရဲ့ argmax နဲ့ answer ရဲ့ အဖြစ်နိုင်ဆုံး အဆုံးကို ရယူပါ +answer_end = torch.argmax(answer_end_scores) + 1 +answer = tokenizer.convert_tokens_to_string( + tokenizer.convert_ids_to_tokens(input_ids[answer_start:answer_end]) +) +print(f"Question: {question}") +print(f"Answer: {answer}") +``` + +```python out +""" +--------------------------------------------------------------------------- +AttributeError Traceback (most recent call last) +/var/folders/28/k4cy5q7s2hs92xq7_h89_vgm0000gn/T/ipykernel_75743/2725838073.py in + 1 inputs = tokenizer(question, text, add_special_tokens=True) + 2 input_ids = inputs["input_ids"] +----> 3 outputs = model(**inputs) + 4 answer_start_scores = outputs.start_logits + 5 answer_end_scores = outputs.end_logits + +~/miniconda3/envs/huggingface/lib/python3.8/site-packages/torch/nn/modules/module.py in _call_impl(self, *input, **kwargs) + 1049 if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks + 1050 or _global_forward_hooks or _global_forward_pre_hooks): +-> 1051 return forward_call(*input, **kwargs) + 1052 # Do not call functions when jit is used + 1053 full_backward_hooks, non_full_backward_hooks = [], [] + +~/miniconda3/envs/huggingface/lib/python3.8/site-packages/transformers/models/distilbert/modeling_distilbert.py in forward(self, input_ids, attention_mask, head_mask, inputs_embeds, start_positions, end_positions, output_attentions, output_hidden_states, return_dict) + 723 return_dict = return_dict if return_dict is not None else self.config.use_return_dict + 724 +--> 725 distilbert_output = self.distilbert( + 725 distilbert_output = self.distilbert( + 726 input_ids=input_ids, + 727 attention_mask=attention_mask, + +~/miniconda3/envs/huggingface/lib/python3.8/site-packages/torch/nn/modules/module.py in _call_impl(self, *input, **kwargs) + 1049 if not (self._backward_hooks or self._forward_hooks or self._forward_pre_hooks or _global_backward_hooks + 1050 or _global_forward_hooks or _global_forward_pre_hooks): +-> 1051 return forward_call(*input, **kwargs) + 1052 # Do not call functions when jit is used + 1053 full_backward_hooks, non_full_backward_hooks = [], [] + +~/miniconda3/envs/huggingface/lib/python3.8/site-packages/transformers/models/distilbert/modeling_distilbert.py in forward(self, input_ids, attention_mask, head_mask, inputs_embeds, output_attentions, output_hidden_states, return_dict) + 471 raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time") + 472 elif input_ids is not None: +--> 473 input_shape = input_ids.size() + 474 elif inputs_embeds is not None: + 475 input_shape = inputs_embeds.size()[:-1] + +AttributeError: 'list' object has no attribute 'size' +""" +``` + +ဟာ၊ ကျွန်တော်တို့ code ထဲမှာ bug တစ်ခုရှိပုံရတယ်။ ဒါပေမယ့် ကျွန်တော်တို့ debug လုပ်ရတာ မကြောက်ပါဘူး။ Python debugger ကို notebook မှာ အသုံးပြုနိုင်ပါတယ်။ + + + +ဒါမှမဟုတ် terminal မှာ- + + + +ဒီနေရာမှာ error message က `'list' object has no attribute 'size'` လို့ ပြောထားတာကို မြင်ရပြီး၊ `model(**inputs)` မှာ ပြဿနာဖြစ်ပွားခဲ့တဲ့ လိုင်းကို `-->` မြှားက ညွှန်ပြနေတာကို မြင်ရပါတယ်။ ဒါကို Python debugger ကို အသုံးပြုပြီး interactive mode နဲ့ debug လုပ်နိုင်ပါတယ်၊ ဒါပေမယ့် အခုတော့ ကျွန်တော်တို့ `inputs` ရဲ့ slice တစ်ခုကို ရိုးရှင်းစွာ print ထုတ်ပြီး ဘာတွေရှိသလဲဆိုတာ ကြည့်ရအောင်။ + +```python +inputs["input_ids"][:5] +``` + +```python out +[101, 2029, 7705, 2015, 2064] +``` + +ဒါက သာမန် Python `list` တစ်ခုလိုတော့ မြင်ရပါတယ်၊ ဒါပေမယ့် type ကို ထပ်စစ်ကြည့်ရအောင်။ + +```python +type(inputs["input_ids"]) +``` + +```python out +list +``` + +ဟုတ်တယ်၊ ဒါက Python `list` တစ်ခု သေချာပါတယ်။ ဒါဆို ဘာမှားခဲ့တာလဲ။ [Chapter 2](/course/chapter2) ကနေ မှတ်မိပါသေးလား၊ 🤗 Transformers မှာရှိတဲ့ `AutoModelForXxx` classes တွေက _tensors_ (PyTorch ဒါမှမဟုတ် TensorFlow မှာ) ပေါ်မှာ အလုပ်လုပ်ပြီး၊ common operation တစ်ခုကတော့ PyTorch မှာဆိုရင် `Tensor.size()` ကို အသုံးပြုပြီး tensor ရဲ့ dimensions တွေကို ထုတ်ယူတာပါပဲ။ traceback ကို ထပ်ကြည့်ရအောင်၊ ဘယ်လိုင်းက exception ကို ဖြစ်စေခဲ့သလဲဆိုတာ ကြည့်ဖို့... + +``` +~/miniconda3/envs/huggingface/lib/python3.8/site-packages/transformers/models/distilbert/modeling_distilbert.py in forward(self, input_ids, attention_mask, head_mask, inputs_embeds, output_attentions, output_hidden_states, return_dict) + 471 raise ValueError("You cannot specify both input_ids and inputs_embeds at the same time") + 472 elif input_ids is not None: +--> 473 input_shape = input_ids.size() + 474 elif inputs_embeds is not None: + 475 input_shape = inputs_embeds.size()[:-1] + +AttributeError: 'list' object has no attribute 'size' +``` + +ကျွန်တော်တို့ code က `input_ids.size()` ကို ခေါ်ဖို့ ကြိုးစားခဲ့ပုံရပါတယ်။ ဒါပေမယ့် ဒါက `list` (container တစ်ခုသာ ဖြစ်တဲ့) Python `list` အတွက် အလုပ်လုပ်မှာ မဟုတ်ပါဘူး။ ဒီပြဿနာကို ဘယ်လိုဖြေရှင်းမလဲ။ Stack Overflow ပေါ်မှာ error message ကို ရှာကြည့်လိုက်တော့ သက်ဆိုင်ရာ [hits](https://stackoverflow.com/search?q=AttributeError%3A+%27list%27+object+has+no+attribute+%27size%27&s=c15ec54c-63cb-481d-a749-408920073e8f) အတော်များများ တွေ့ရပါတယ်။ ပထမဆုံးတစ်ခုကို နှိပ်လိုက်တဲ့အခါ ကျွန်တော်တို့ရဲ့ မေးခွန်းနဲ့ ဆင်တူတဲ့ မေးခွန်းတစ်ခုကို ပြသပြီး၊ အဖြေကို အောက်ပါ screenshot မှာ တွေ့ရပါလိမ့်မယ်။ + +
+An answer from Stack Overflow. +
+ +အဖြေက tokenizer မှာ `return_tensors='pt'` ကို ထည့်ဖို့ အကြံပြုထားတာကြောင့်၊ ဒါက ကျွန်တော်တို့အတွက် အလုပ်ဖြစ်မလားဆိုတာ ကြည့်ရအောင်- + +```python out +inputs = tokenizer(question, context, add_special_tokens=True, return_tensors="pt") +input_ids = inputs["input_ids"][0] +outputs = model(**inputs) +answer_start_scores = outputs.start_logits +answer_end_scores = outputs.end_logits +# score ရဲ့ argmax နဲ့ answer ရဲ့ အဖြစ်နိုင်ဆုံး အစကို ရယူပါ +answer_start = torch.argmax(answer_start_scores) +# score ရဲ့ argmax နဲ့ answer ရဲ့ အဖြစ်နိုင်ဆုံး အဆုံးကို ရယူပါ +answer_end = torch.argmax(answer_end_scores) + 1 +answer = tokenizer.convert_tokens_to_string( + tokenizer.convert_ids_to_tokens(input_ids[answer_start:answer_end]) +) +print(f"Question: {question}") +print(f"Answer: {answer}") +``` + +```python out +""" +Question: Which frameworks can I use? +Answer: pytorch, tensorflow, and jax +""" +``` + +ကောင်းပြီ၊ အလုပ်ဖြစ်သွားပြီ! ဒါဟာ Stack Overflow က ဘယ်လောက်အသုံးဝင်တယ်ဆိုတာကို ပြသတဲ့ ဥပမာကောင်းတစ်ခုပါပဲ- အလားတူပြဿနာတစ်ခုကို ဖော်ထုတ်ခြင်းဖြင့်၊ community ထဲက တခြားသူတွေရဲ့ အတွေ့အကြုံကနေ ကျွန်တော်တို့ အကျိုးကျေးဇူး ရရှိခဲ့ပါတယ်။ ဒါပေမယ့် ဒီလို ရှာဖွေမှုမျိုးက အမြဲတမ်း သက်ဆိုင်ရာအဖြေကို ပေးမှာ မဟုတ်ပါဘူး၊ ဒါဆို ဒီလိုကိစ္စတွေမှာ သင်ဘာလုပ်နိုင်မလဲ။ ကံကောင်းစွာနဲ့ပဲ၊ [Hugging Face forums](https://discuss.huggingface.co/) မှာ ကြိုဆိုသော developers community တစ်ခု ရှိပြီး သင့်ကို ကူညီနိုင်ပါတယ်။ နောက်အပိုင်းမှာ၊ အဖြေရနိုင်ခြေရှိတဲ့ ကောင်းမွန်တဲ့ forum မေးခွန်းတွေကို ဘယ်လိုဖန်တီးရမလဲဆိုတာ ကြည့်ရပါမယ်။ + +## ဝေါဟာရ ရှင်းလင်းချက် (Glossary) + +* **Error**: ပရိုဂရမ်တစ်ခု အလုပ်လုပ်နေစဉ် ဖြစ်ပေါ်လာသော ပြဿနာတစ်ခုကြောင့် ၎င်းသည် ပုံမှန်အတိုင်း ဆက်လက်လုပ်ဆောင်နိုင်ခြင်းမရှိခြင်း။ +* **Predictions**: Machine Learning မော်ဒယ်တစ်ခုက input data ကို အခြေခံပြီး ခန့်မှန်းထုတ်ပေးသော ရလဒ်များ။ +* **Transformer Model**: Natural Language Processing (NLP) မှာ အောင်မြင်မှုများစွာရရှိခဲ့တဲ့ deep learning architecture တစ်မျိုးပါ။ +* **Debug**: ကွန်ပျူတာပရိုဂရမ်တစ်ခုရှိ အမှားများ (bugs) ကို ရှာဖွေ၊ ဖော်ထုတ်ပြီး ပြင်ဆင်ခြင်း။ +* **Training Phase**: Machine Learning မော်ဒယ်တစ်ခုကို ဒေတာများဖြင့် လေ့ကျင့်ပေးသည့် အချိန်အပိုင်းအခြား။ +* **Template Model Repository**: နမူနာအဖြစ် အသုံးပြုရန် ပြင်ဆင်ထားသော model repository။ +* **Hugging Face Hub**: AI မော်ဒယ်တွေ၊ datasets တွေနဲ့ demo တွေကို အခြားသူတွေနဲ့ မျှဝေဖို့၊ ရှာဖွေဖို့နဲ့ ပြန်လည်အသုံးပြုဖို့အတွက် အွန်လိုင်း platform တစ်ခု ဖြစ်ပါတယ်။ +* **Jupyter Notebook**: code, text, images, နှင့် mathematical equations တို့ကို ပေါင်းစပ်နိုင်သော interactive computing environment။ +* **`notebook_login()` Function**: Jupyter/Colab Notebooks များတွင် Hugging Face Hub သို့ login ဝင်ရန် အသုံးပြုသော function။ +* **Terminal**: command-line interface မှတစ်ဆင့် ကွန်ပျူတာကို ထိန်းချုပ်ရန် အသုံးပြုသော interface။ +* **`huggingface-cli login`**: Hugging Face CLI (Command Line Interface) မှ Hugging Face Hub သို့ login ဝင်ရန် အသုံးပြုသော command။ +* **Token**: Hugging Face Hub တွင် အကောင့် authentication အတွက် အသုံးပြုသော ထူးခြားသည့် ကုဒ်။ +* **`~/.cache/huggingface/`**: Hugging Face libraries များက cache ဖိုင်များကို သိမ်းဆည်းသော default directory။ +* **`distutils.dir_util.copy_tree`**: Python ရဲ့ `distutils` library ကနေ directory tree တစ်ခုလုံးကို copy လုပ်ဖို့အတွက် utility function။ +* **`huggingface_hub` Library**: Hugging Face Hub နှင့် အပြန်အလှန်ဆက်သွယ်ရန် အသုံးပြုသော Python library။ +* **`Repository` Class**: `huggingface_hub` library မှ Git repository များကို ကိုင်တွယ်ရန်အတွက် class။ +* **`snapshot_download()` Function**: Hugging Face Hub မှ repository တစ်ခု၏ snapshot ကို download လုပ်ရန် function။ +* **`create_repo()` Function**: Hugging Face Hub ပေါ်တွင် repository အသစ်တစ်ခု ဖန်တီးရန် function။ +* **`get_full_repo_name()` Function**: Hugging Face Hub ပေါ်ရှိ repository ၏ full name (username/repo_name) ကို ရယူရန် function။ +* **`local_dir`**: Repository ကို clone လုပ်မည့် local directory။ +* **`clone_from`**: Repository ကို clone လုပ်မည့် remote URL သို့မဟုတ် ID။ +* **`push_to_hub()` Method**: Hugging Face Transformers library မှ model, tokenizer, သို့မဟုတ် configuration များကို Hugging Face Hub သို့ upload လုပ်ရန် အသုံးပြုသော method။ +* **Pipeline from 🤗 Transformers**: Hugging Face Transformers library မှ model များကို သီးခြားလုပ်ငန်းများအတွက် အသုံးပြုရလွယ်ကူစေရန် အဆင့်မြင့် abstraction။ +* **Question Answering Project**: မေးခွန်းတစ်ခုကို ဖြေကြားရန် AI model များကို အသုံးပြုသည့် project။ +* **E-commerce Website**: အင်တာနက်မှတစ်ဆင့် ကုန်ပစ္စည်းများ သို့မဟုတ် ဝန်ဆောင်မှုများကို ဝယ်ယူရောင်းချနိုင်သော website။ +* **Consumer Products**: ပုံမှန်စားသုံးသူများ အသုံးပြုသော ကုန်ပစ္စည်းများ။ +* **SQuAD (Stanford Question Answering Dataset)**: မေးခွန်းဖြေဆိုခြင်းအတွက် အသုံးပြုသော လူကြိုက်များသည့် dataset။ +* **Model ID**: Hugging Face Hub ပေါ်ရှိ model တစ်ခု၏ ထူးခြားသော ဖော်ထုတ်ကိန်း (identifier)။ +* **`OSError`**: Python တွင် operating system-related error များကို ညွှန်ပြသော exception အမျိုးအစား။ +* **`config.json` File**: Transformer model ၏ configuration (ဥပမာ- hidden size, number of layers) ကို သိမ်းဆည်းထားသော JSON file။ +* **Python Traceback (Stack Trace)**: Python ပရိုဂရမ်တစ်ခုတွင် error ဖြစ်ပွားခဲ့သည့်အခါ function calls ၏ sequence ကို ပြသသော error report။ +* **Exception**: Python ပရိုဂရမ်တစ်ခု၏ ပုံမှန်စီးဆင်းမှုကို ပြတ်တောက်စေသော error တစ်မျိုး။ +* **Stack Overflow**: programmer များအတွက် မေးခွန်းများမေးရန်နှင့် အဖြေများရှာဖွေရန် လူကြိုက်များသော Q&A website။ +* **Typo**: စာလုံးပေါင်းမှားယွင်းမှု။ +* **DistilBERT**: BERT model ၏ ပေါ့ပါးသော version။ +* **`.gitattributes`**: Git repository အတွင်းရှိ files များကို မည်သို့ ကိုင်တွယ်ရမည်ကို သတ်မှတ်ရန် အသုံးပြုသော Git configuration file။ +* **`README.md`**: Markdown format ဖြင့် ရေးသားထားသော project ၏ အဓိက မှတ်တမ်းဖိုင်။ +* **`pytorch_model.bin`**: PyTorch framework ဖြင့် trained လုပ်ထားသော model ၏ weights များကို သိမ်းဆည်းထားသော binary file။ +* **`special_tokens_map.json`**: tokenizer ၏ special tokens များနှင့် ၎င်းတို့၏ mappings များကို သိမ်းဆည်းထားသော JSON file။ +* **`tokenizer_config.json`**: tokenizer ၏ configuration ကို သိမ်းဆည်းထားသော JSON file။ +* **`training_args.bin`**: training arguments များကို သိမ်းဆည်းထားသော binary file။ +* **`vocab.txt`**: tokenizer ၏ vocabulary ကို သိမ်းဆည်းထားသော text file။ +* **`AutoConfig` Class**: Hugging Face Transformers library မှာ ပါဝင်တဲ့ class တစ်ခုဖြစ်ပြီး မော်ဒယ်အမည်ကို အသုံးပြုပြီး သက်ဆိုင်ရာ configuration ကို အလိုအလျောက် load လုပ်ပေးသည်။ +* **`from_pretrained()` Method**: Hugging Face Transformers library မှ model, tokenizer, သို့မဟုတ် configuration ကို pretrained version မှ load လုပ်ရန် အသုံးပြုသော method။ +* **Default Configuration**: model သို့မဟုတ် library တစ်ခု၏ မူရင်း (standard) configuration။ +* **`commit_message`**: Git repository သို့ ပြောင်းလဲမှုများကို push လုပ်သောအခါ ထည့်သွင်းသော message။ +* **`main` Branch**: Git repository ၏ ပင်မ development branch။ +* **`revision` Argument**: `pipeline()` function တွင် model ၏ သတ်မှတ်ထားသော revision (branch name, commit hash သို့မဟုတ် tag) မှ load လုပ်ရန်။ +* **Extractive Question Answering**: ပေးထားသော စာသားတစ်ခုမှ မေးခွန်း၏ အဖြေကို တိုက်ရိုက်ထုတ်ယူခြင်း။ +* **Interoperable**: မတူညီသော စနစ်များ သို့မဟုတ် applications များကြား အတူတကွ အလုပ်လုပ်နိုင်ခြင်း။ +* **PyTorch**: Facebook (ယခု Meta) က ဖန်တီးထားတဲ့ open-source machine learning library တစ်ခုဖြစ်ပြီး deep learning မော်ဒယ်တွေ တည်ဆောက်ဖို့အတွက် အသုံးပြုပါတယ်။ +* **TensorFlow**: Google က ဖန်တီးထားတဲ့ open-source machine learning library တစ်ခုဖြစ်ပြီး deep learning မော်ဒယ်တွေ တည်ဆောက်ဖို့အတွက် အသုံးပြုပါတယ်။ +* **JAX**: Google မှ ထုတ်လုပ်ထားသော high-performance numerical computing library တစ်ခုဖြစ်ပြီး Python မှာ automatic differentiation ကို ထောက်ပံ့ပေးသည်။ +* **Tracebacks**: Python မှာ error ဖြစ်တဲ့အခါ function call sequence ကိုပြတဲ့ error report။ +* **Source Code**: ပရိုဂရမ်တစ်ခု၏ မူရင်း code။ +* **Forward Pass**: Neural network တစ်ခုသို့ input data ကို ပေးပို့ပြီး output ကို တွက်ချက်ခြင်း။ +* **Logits**: Neural network ၏ နောက်ဆုံး output layer မှ ထုတ်ပေးသော raw, unnormalized scores များ။ +* **Custom Post-processing**: model ၏ output များကို ပိုမိုအသုံးဝင်သော ပုံစံသို့ ပြောင်းလဲရန်အတွက် သီးခြားပြင်ဆင်ထားသော လုပ်ငန်းစဉ်။ +* **Tokenizer**: စာသား (သို့မဟုတ် အခြားဒေတာ) ကို AI မော်ဒယ်များ စီမံဆောင်ရွက်နိုင်ရန် tokens တွေအဖြစ် ပိုင်းခြားပေးသည့် ကိရိယာ သို့မဟုတ် လုပ်ငန်းစဉ်။ +* **`torch` Library**: PyTorch framework အတွက် Python library။ +* **`add_special_tokens=True`**: tokenizer ကို input sequence ထဲသို့ special tokens (ဥပမာ- `[CLS]`, `[SEP]`) ထည့်သွင်းရန် ညွှန်ကြားခြင်း။ +* **`input_ids`**: Tokenizer မှ ထုတ်ပေးသော tokens တစ်ခုစီ၏ ထူးခြားသော ဂဏန်းဆိုင်ရာ ID များ။ +* **`outputs.start_logits`**: Question Answering model မှ အဖြေစတင်မည့် token အတွက် ထုတ်ပေးသော logits များ။ +* **`outputs.end_logits`**: Question Answering model မှ အဖြေပြီးဆုံးမည့် token အတွက် ထုတ်ပေးသော logits များ။ +* **`torch.argmax()`**: PyTorch tensor တစ်ခု၏ အမြင့်ဆုံးတန်ဖိုးရှိသော index ကို ရယူသော function။ +* **`tokenizer.convert_tokens_to_string()`**: tokens စာရင်းကို string တစ်ခုအဖြစ် ပြန်ပြောင်းပေးသော tokenizer method။ +* **`tokenizer.convert_ids_to_tokens()`**: ID စာရင်းကို tokens စာရင်းအဖြစ် ပြန်ပြောင်းပေးသော tokenizer method။ +* **AttributeError**: Python တွင် object တစ်ခု၌ မရှိသော attribute ကို ဝင်ရောက်ကြည့်ရှုရန် ကြိုးစားသောအခါ ဖြစ်ပေါ်လာသော exception။ +* **Python Debugger**: Python code များကို step-by-step စစ်ဆေးပြီး debug လုပ်ရန် ကိရိယာ။ +* **Slice**: list သို့မဟုတ် array ၏ အစိတ်အပိုင်းတစ်ခု။ +* **`Tensor.size()` Method**: PyTorch tensor တစ်ခု၏ dimensions များကို ပြန်ပေးသော method။ +* **`return_tensors='pt'`**: tokenizer ကို output များကို PyTorch tensors အဖြစ် ပြန်ပေးရန် ညွှန်ကြားခြင်း။ +* **Community of Developers**: ဆော့ဖ်ဝဲလ်ဖန်တီးသူများ၏ အဖွဲ့အစည်း။ \ No newline at end of file diff --git a/chapters/my/chapter8/3.mdx b/chapters/my/chapter8/3.mdx new file mode 100644 index 000000000..f92b7a173 --- /dev/null +++ b/chapters/my/chapter8/3.mdx @@ -0,0 +1,210 @@ +# Forums များတွင် အကူအညီ တောင်းခံခြင်း[[asking-for-help-on-the-forums]] + + + + + +[Hugging Face forums](https://discuss.huggingface.co) များသည် open source team နှင့် ပိုမိုကျယ်ပြန့်သော Hugging Face community ထံမှ အကူအညီရယူရန် အကောင်းဆုံးနေရာတစ်ခုဖြစ်သည်။ ပုံမှန်နေ့တစ်နေ့တွင် ပင်မစာမျက်နှာသည် အောက်ပါအတိုင်း ပေါ်လာပါသည်- + +
+The Hugging Face forums. +
+ +ဘယ်ဘက်ခြမ်းတွင် topics အမျိုးမျိုးကို စုစည်းထားသော categories အားလုံးကို သင်တွေ့မြင်နိုင်ပြီး၊ ညာဘက်ခြမ်းတွင် နောက်ဆုံးပေါ် topics များကို ပြသထားသည်။ topic တစ်ခုဆိုတာ title, category, နဲ့ description ပါဝင်တဲ့ post တစ်ခုဖြစ်ပြီး၊ [Chapter 5](/course/chapter5) မှာ ကျွန်တော်တို့ရဲ့ ကိုယ်ပိုင် dataset ကို ဖန်တီးတုန်းက တွေ့ခဲ့ရတဲ့ GitHub issues format နဲ့ အတော်လေး ဆင်တူပါတယ်။ နာမည်အရ သိနိုင်တဲ့အတိုင်း၊ [Beginners](https://discuss.huggingface.co/c/beginners/5) category ကို Hugging Face libraries နဲ့ ecosystem ကို အခုမှ စတင်လေ့လာသူတွေအတွက် အဓိကရည်ရွယ်ပါတယ်။ libraries တွေထဲက ဘယ်တစ်ခုနဲ့ ပတ်သက်တဲ့ မေးခွန်းမဆို ကြိုဆိုပါတယ်။ code အချို့ကို debug လုပ်တာပဲဖြစ်ဖြစ်၊ တစ်ခုခုလုပ်နည်းအကြောင်း အကူအညီတောင်းတာပဲဖြစ်ဖြစ်ပေါ့။ (သို့သော်လည်း၊ သင့်မေးခွန်းက သီးခြား library တစ်ခုနဲ့ ပတ်သက်တယ်ဆိုရင်၊ forum မှာ သက်ဆိုင်ရာ library category ဆီ သွားသင့်ပါတယ်။) + +အလားတူပဲ၊ [Intermediate](https://discuss.huggingface.co/c/intermediate/6) နဲ့ [Research](https://discuss.huggingface.co/c/research/7) categories တွေကတော့ ပိုမိုအဆင့်မြင့်တဲ့ မေးခွန်းတွေအတွက်ပါ။ ဥပမာ - libraries တွေအကြောင်း ဒါမှမဟုတ် သင်ဆွေးနွေးချင်တဲ့ NLP သုတေသနအသစ်အကြောင်း စသည်တို့ဖြစ်ပါတယ်။ + +ပြီးတော့ သေချာပေါက် [Course](https://discuss.huggingface.co/c/course/20) category ကိုလည်း ဖော်ပြရပါမယ်။ အဲဒီမှာ Hugging Face course နဲ့ ပတ်သက်တဲ့ မေးခွန်းတွေ မေးနိုင်ပါတယ်! + +Category တစ်ခုကို ရွေးပြီးတာနဲ့၊ သင်ရဲ့ ပထမဆုံး topic ကို ရေးဖို့ အဆင်သင့်ဖြစ်ပါလိမ့်မယ်။ ဒါကို ဘယ်လိုလုပ်ရမယ်ဆိုတဲ့ [လမ်းညွှန်ချက်တွေကို](https://discuss.huggingface.co/t/how-to-request-support/3128) forum မှာ ရှာတွေ့နိုင်ပြီး၊ ဒီအပိုင်းမှာတော့ ကောင်းမွန်တဲ့ topic တစ်ခုကို ဖွဲ့စည်းထားတဲ့ features အချို့ကို ကျွန်တော်တို့ ကြည့်ရပါမယ်။ + +## ကောင်းမွန်သော Forum Post တစ်ခု ရေးသားခြင်း[[writing-a-good-forum-post]] + +ဥပမာအနေနဲ့၊ Wikipedia ဆောင်းပါးတွေကနေ embeddings တွေ ထုတ်လုပ်ပြီး custom search engine တစ်ခု ဖန်တီးဖို့ ကြိုးစားနေတယ်လို့ ယူဆကြပါစို့။ ပုံမှန်အတိုင်းပါပဲ၊ tokenizer နဲ့ model ကို အောက်ပါအတိုင်း load လုပ်ပါတယ်။ + +```python +from transformers import AutoTokenizer, AutoModel + +model_checkpoint = "distilbert-base-uncased" +tokenizer = AutoTokenizer.from_pretrained(model_checkpoint) +model = AutoModel.from_pretrained(model_checkpoint) +``` + +အခု ကျွန်တော်တို့ Transformers (franchise, library မဟုတ်ပါဘူး!) အကြောင်း [Wikipedia ဆောင်းပါး](https://en.wikipedia.org/wiki/Transformers) ရဲ့ တစ်ခုလုံးကို embed လုပ်ဖို့ ကြိုးစားတယ်လို့ ယူဆပါစို့။ + +```python +text = """ +Generation One is a retroactive term for the Transformers characters that +appeared between 1984 and 1993. The Transformers began with the 1980s Japanese +toy lines Micro Change and Diaclone. They presented robots able to transform +into everyday vehicles, electronic items or weapons. Hasbro bought the Micro +Change and Diaclone toys, and partnered with Takara. Marvel Comics was hired by +Hasbro to create the backstory; editor-in-chief Jim Shooter wrote an overall +story, and gave the task of creating the characthers to writer Dennis O'Neil. +Unhappy with O'Neil's work (although O'Neil created the name "Optimus Prime"), +Shooter chose Bob Budiansky to create the characters. + +The Transformers mecha were largely designed by Shōji Kawamori, the creator of +the Japanese mecha anime franchise Macross (which was adapted into the Robotech +franchise in North America). Kawamori came up with the idea of transforming +mechs while working on the Diaclone and Macross franchises in the early 1980s +(such as the VF-1 Valkyrie in Macross and Robotech), with his Diaclone mechs +later providing the basis for Transformers. + +The primary concept of Generation One is that the heroic Optimus Prime, the +villainous Megatron, and their finest soldiers crash land on pre-historic Earth +in the Ark and the Nemesis before awakening in 1985, Cybertron hurtling through +the Neutral zone as an effect of the war. The Marvel comic was originally part +of the main Marvel Universe, with appearances from Spider-Man and Nick Fury, +plus some cameos, as well as a visit to the Savage Land. + +The Transformers TV series began around the same time. Produced by Sunbow +Productions and Marvel Productions, later Hasbro Productions, from the start it +contradicted Budiansky's backstories. The TV series shows the Autobots looking +for new energy sources, and crash landing as the Decepticons attack. Marvel +interpreted the Autobots as destroying a rogue asteroid approaching Cybertron. +Shockwave is loyal to Megatron in the TV series, keeping Cybertron in a +stalemate during his absence, but in the comic book he attempts to take command +of the Decepticons. The TV series would also differ wildly from the origins +Budiansky had created for the Dinobots, the Decepticon turned Autobot Jetfire +(known as Skyfire on TV), the Constructicons (who combine to form +Devastator),[19][20] and Omega Supreme. The Marvel comic establishes early on +that Prime wields the Creation Matrix, which gives life to machines. In the +second season, the two-part episode The Key to Vector Sigma introduced the +ancient Vector Sigma computer, which served the same original purpose as the +Creation Matrix (giving life to Transformers), and its guardian Alpha Trion. +""" + +inputs = tokenizer(text, return_tensors="pt") +logits = model(**inputs).logits +``` + +```python output +IndexError: index out of range in self +``` + +အိုး-အိုး၊ ပြဿနာတစ်ခု ကြုံတွေ့ခဲ့ပါပြီ — ပြီးတော့ error message က [အပိုင်း ၂](/course/chapter8/section2) မှာ ကျွန်တော်တို့ တွေ့ခဲ့ရတာတွေထက် အများကြီး ပိုပြီး နားမလည်နိုင်ပါဘူး! full traceback ကို နားမလည်နိုင်တဲ့အတွက် Hugging Face forums တွေကနေ အကူအညီတောင်းဖို့ ဆုံးဖြတ်လိုက်ပါတယ်။ topic ကို ဘယ်လိုရေးသားရမလဲ။ + +စတင်ဖို့အတွက်၊ ညာဘက်အပေါ်ထောင့်မှာရှိတဲ့ "New Topic" ခလုတ်ကို နှိပ်ဖို့ လိုအပ်ပါတယ် (topic တစ်ခု ဖန်တီးဖို့အတွက် login ဝင်ထားဖို့ လိုအပ်ကြောင်း သတိပြုပါ)။ + +
+Creating a new forum topic. +
+ +ဒါက ကျွန်တော်တို့ရဲ့ topic ရဲ့ title ကို ထည့်သွင်းနိုင်မယ့်၊ category တစ်ခုကို ရွေးချယ်နိုင်မယ့်၊ ပြီးတော့ content ကို ရေးသားနိုင်မယ့် writing interface ကို ဖွင့်ပေးပါလိမ့်မယ်- + +
+The interface for creating a forum topic. +
+ +error က 🤗 Transformers နဲ့သာ သက်ဆိုင်ပုံရတာကြောင့်၊ ဒါကို category အဖြစ် ရွေးချယ်ပါမယ်။ ပြဿနာကို ရှင်းပြဖို့ ပထမဆုံး ကြိုးစားမှုက အောက်ပါအတိုင်း ဖြစ်နိုင်ပါတယ်- + +
+Drafting the content for a new forum topic. +
+ +ဒီ topic မှာ ကျွန်တော်တို့ အကူအညီလိုတဲ့ error message ပါဝင်နေပေမယ့်၊ ရေးသားထားတဲ့ ပုံစံမှာ ပြဿနာအချို့ ရှိနေပါတယ်။ + +၁။ title က သိပ်မဖော်ပြနိုင်ပါဘူး၊ ဒါကြောင့် forum ကို ကြည့်ရှုသူတွေက body ကိုပါ မဖတ်ဘဲ topic က ဘာအကြောင်းလဲဆိုတာ ပြောနိုင်မှာ မဟုတ်ပါဘူး။ +၂။ body က error ဘယ်ကနေလာသလဲ၊ ဒါကို ဘယ်လိုပြန်လည်ထုတ်လုပ်ရမလဲဆိုတဲ့ လုံလောက်တဲ့ အချက်အလက်တွေ မပေးပါဘူး။ +၃။ topic က လူအချို့ကို တောင်းဆိုတဲ့လေသံမျိုးနဲ့ တိုက်ရိုက် tag လုပ်ထားပါတယ်။ + +ဒီလို topics တွေဟာ အမြန်အဖြေရဖို့ မဖြစ်နိုင်ပါဘူး (လုံးဝအဖြေမရတာမျိုးလည်း ရှိနိုင်ပါတယ်)၊ ဒါကြောင့် ဘယ်လိုတိုးတက်အောင် လုပ်နိုင်မလဲဆိုတာ ကြည့်ရအောင်။ ကောင်းမွန်တဲ့ title တစ်ခုရွေးချယ်ခြင်းရဲ့ ပထမဆုံး ပြဿနာနဲ့ စတင်ပါမယ်။ + +### ဖော်ပြနိုင်သော Title တစ်ခု ရွေးချယ်ခြင်း[[choosing-a-descriptive-title]] + +သင့် code မှာ bug တစ်ခုနဲ့ ပတ်သက်ပြီး အကူအညီရဖို့ ကြိုးစားနေတယ်ဆိုရင်၊ title မှာ လုံလောက်တဲ့ အချက်အလက်တွေ ထည့်သွင်းခြင်းက တခြားသူတွေက သင့်မေးခွန်းကို ဖြေနိုင်မယ်လို့ သူတို့ထင်လား မထင်လားဆိုတာ လျင်မြန်စွာ ဆုံးဖြတ်နိုင်ဖို့ ကူညီပေးမယ့် အကောင်းဆုံး စည်းမျဉ်းတစ်ခုပါပဲ။ ကျွန်တော်တို့ရဲ့ ဥပမာမှာ၊ မြှင့်တင်နေတဲ့ exception ရဲ့ နာမည်ကို သိပြီး model ရဲ့ forward pass မှာ `model(**inputs)` ကို ခေါ်တဲ့အခါ ဒါက ဖြစ်ပေါ်တာလို့ အချက်အလက်အချို့ ရရှိထားပါတယ်။ ဒါကို ဆက်သွယ်ဖို့၊ ဖြစ်နိုင်တဲ့ title တစ်ခုကတော့... + +> AutoModel forward pass မှာ IndexError ရဲ့ source လား။ + +ဒီ title က error က ဘယ်ကနေလာတယ်လို့ သင်ထင်သလဲဆိုတာကို စာဖတ်သူကို ပြောပြပြီး၊ သူတို့က `IndexError` ကို အရင်က ကြုံတွေ့ဖူးတယ်ဆိုရင်၊ ဒါကို ဘယ်လို debug လုပ်ရမလဲဆိုတာ သိနိုင်ခြေများပါတယ်။ သေချာပေါက်၊ title က သင်လိုချင်တာ ဖြစ်နိုင်ပြီး၊ အခြားပုံစံတွေဖြစ်တဲ့... + +> ကျွန်ုပ်ရဲ့ model က IndexError ဘာကြောင့် ထုတ်လုပ်တာလဲ။ + +ဒါတွေကလည်း အဆင်ပြေနိုင်ပါတယ်။ အခု ဖော်ပြနိုင်တဲ့ title တစ်ခု ရရှိပြီဆိုတော့၊ body ကို တိုးတက်အောင် လုပ်ကြည့်ရအောင်။ + +### သင့် Code Snippets များကို ပုံစံချခြင်း[[formatting-your-code-snippets]] + +source code ကို IDE ထဲမှာ ဖတ်ရတာ အခက်အခဲရှိပြီးသားဖြစ်ပေမယ့်၊ code ကို plain text အဖြစ် copy paste လုပ်ထားရင် ပိုတောင် ခက်ခဲပါလိမ့်မယ်! ကံကောင်းစွာနဲ့ပဲ၊ Hugging Face forums တွေက Markdown ကို အသုံးပြုခြင်းကို ထောက်ပံ့ပေးတာကြောင့်၊ သင့် code blocks တွေကို ဖတ်ရလွယ်ကူအောင် backticks သုံးခု (```) နဲ့ အမြဲတမ်း ပတ်ထားသင့်ပါတယ်။ ဒါကို error message ကို လှပအောင်လုပ်ဖို့ လုပ်ကြပါစို့ — ပြီးတော့ ဒီလိုလုပ်ရင်းနဲ့၊ body ကို ကျွန်တော်တို့ရဲ့ မူရင်း version ထက် ပိုပြီး ယဉ်ကျေးအောင် လုပ်ကြရအောင်။ + +
+Our revised forum topic, with proper code formatting. +
+ +screenshot မှာ သင်တွေ့ရတဲ့အတိုင်း၊ code blocks တွေကို backticks နဲ့ ပတ်ထားခြင်းက raw text ကို formatted code အဖြစ် ပြောင်းလဲပေးပြီး၊ color styling ပါ အပြည့်အစုံပါပဲ! `distilbert-base-uncased` အတွက် ကျွန်တော်တို့ လုပ်ခဲ့သလိုပဲ၊ inline variables တွေကို format လုပ်ဖို့အတွက် single backticks တွေကို အသုံးပြုနိုင်ကြောင်းလည်း သတိပြုပါ။ ဒီ topic က အများကြီး ပိုကောင်းလာပြီဖြစ်ပြီး၊ ကံကောင်းရင်တော့ community ထဲက တစ်ယောက်ယောက်က error က ဘာအကြောင်းလဲဆိုတာ ခန့်မှန်းနိုင်ပါလိမ့်မယ်။ သို့သော်လည်း၊ ကံပေါ်မှာ အားကိုးမယ့်အစား၊ traceback ကို အသေးစိတ်အပြည့်အစုံ ထည့်သွင်းခြင်းဖြင့် ဘဝကို ပိုမိုလွယ်ကူအောင် လုပ်ကြပါစို့! + +### Full Traceback ကို ထည့်သွင်းခြင်း[[including-the-full-traceback]] + +traceback ရဲ့ နောက်ဆုံးစာကြောင်းက သင့်ကိုယ်ပိုင် code ကို debug လုပ်ဖို့ လုံလောက်လေ့ရှိတာကြောင့်၊ "နေရာချွေတာဖို့" သင့် topic မှာ အဲဒါကိုပဲ ပေးချင်စိတ် ပေါ်လာနိုင်ပါတယ်။ ရည်ရွယ်ချက် ကောင်းပေမယ့်၊ ဒါက တခြားသူတွေအတွက် ပြဿနာကို debug လုပ်ဖို့ ပိုခက်ခဲစေပါတယ်၊ ဘာလို့လဲဆိုတော့ traceback ရဲ့ အပေါ်ပိုင်းက အချက်အလက်တွေက တကယ်အသုံးဝင်နိုင်လို့ပါပဲ။ ဒါကြောင့်၊ ကောင်းမွန်တဲ့ အလေ့အကျင့်တစ်ခုက traceback _တစ်ခုလုံး_ ကို copy and paste လုပ်ပြီး ကောင်းကောင်း format ချထားဖို့ သေချာအောင် လုပ်တာပါပဲ။ ဒီ traceback တွေက အတော်လေး ရှည်လျားနိုင်တာကြောင့်၊ တချို့လူတွေက source code ကို ရှင်းပြပြီးမှ ၎င်းတို့ကို ပြသဖို့ ပိုကြိုက်ကြပါတယ်။ ဒါကို လုပ်ကြပါစို့။ အခု ကျွန်တော်တို့ရဲ့ forum topic က အောက်ပါအတိုင်း ဖြစ်ပါလိမ့်မယ်။ + +
+Our example forum topic, with the complete traceback. +
+ +ဒါက အများကြီး ပိုပြီး အချက်အလက်ပြည့်စုံပါတယ်၊ ပြီးတော့ သတိထားဖတ်ရှုသူတစ်ဦးက traceback ထဲက ဒီစာကြောင်းကြောင့် input ရှည်လျားစွာ ပေးပို့မိလို့ ပြဿနာဖြစ်တာလို့ ထောက်ပြနိုင်ပါလိမ့်မယ်။ + +> Token indices sequence length is longer than the specified maximum sequence length for this model (583 > 512). + +သို့သော်လည်း၊ error ကို ဖြစ်ပေါ်စေခဲ့တဲ့ code ကို တကယ်တကယ် ပေးခြင်းဖြင့် သူတို့အတွက် ပိုမိုလွယ်ကူအောင် လုပ်နိုင်ပါတယ်။ အခု အဲဒါကို လုပ်ကြပါစို့။ + +### ပြန်လည်ထုတ်လုပ်နိုင်သော ဥပမာတစ်ခု ပံ့ပိုးပေးခြင်း[[providing-a-reproducible-example]] + +သင်တခြားတစ်ယောက်ရဲ့ code ကို debug လုပ်ဖို့ ကြိုးစားဖူးတယ်ဆိုရင်၊ သင်ဟာ သူတို့အစီရင်ခံခဲ့တဲ့ ပြဿနာကို အရင်ဆုံး ပြန်လည်ဖန်တီးကြည့်ပြီးမှ traceback ကို လိုက်ကြည့်ပြီး error ကို ရှာဖွေဖို့ လုပ်ဆောင်ခဲ့ပါလိမ့်မယ်။ forums တွေမှာ အကူအညီရယူတာ (သို့မဟုတ် ပေးတာ) မှာလည်း မတူပါဘူး၊ ဒါကြောင့် error ကို ပြန်လည်ထုတ်လုပ်နိုင်တဲ့ ဥပမာသေးသေးလေးတစ်ခု ပေးနိုင်ရင် တကယ်အထောက်အကူဖြစ်ပါတယ်။ တစ်ဝက်လောက်သော အချိန်တွေမှာ၊ ဒီလေ့ကျင့်ခန်းကို လုပ်ဆောင်ရုံနဲ့ သင်ဘာမှားနေသလဲဆိုတာကို သင်ကိုယ်တိုင် ရှာဖွေနိုင်ပါလိမ့်မယ်။ ဘယ်လိုပဲဖြစ်ဖြစ်၊ ကျွန်တော်တို့ရဲ့ ဥပမာမှာ ပျောက်ဆုံးနေတဲ့ အစိတ်အပိုင်းက model ကို ပေးခဲ့တဲ့ _inputs_ တွေကို ပြသဖို့ပါပဲ။ အဲဒါကို လုပ်ဆောင်ခြင်းက အောက်ပါအတိုင်း ပြီးပြည့်စုံတဲ့ ဥပမာတစ်ခုကို ပေးပါလိမ့်မယ်။ + +
+The final version of our forum topic. +
+ +ဒီ topic မှာ အခုဆိုရင် အချက်အလက်များစွာ ပါဝင်နေပြီး၊ community ရဲ့ အာရုံစိုက်မှုကို ဆွဲဆောင်ပြီး အကူအညီဖြစ်စေမယ့် အဖြေတစ်ခု ရဖို့ အခွင့်အလမ်း ပိုများတဲ့ ပုံစံမျိုးနဲ့ ရေးသားထားပါတယ်။ ဒီအခြေခံလမ်းညွှန်ချက်တွေနဲ့ သင်ဟာ သင့်ရဲ့ 🤗 Transformers မေးခွန်းတွေရဲ့ အဖြေတွေကို ရှာဖွေဖို့ ကောင်းမွန်တဲ့ topics တွေကို ဖန်တီးနိုင်ပါပြီ! + +## ဝေါဟာရ ရှင်းလင်းချက် (Glossary) + +* **Forums**: အွန်လိုင်းဆွေးနွေးပွဲ ဖိုရမ်များ။ Hugging Face forums များသည် open source team နှင့် ပိုမိုကျယ်ပြန့်သော Hugging Face community ထံမှ အကူအညီရယူရန် ရည်ရွယ်သည်။ +* **Open Source Team**: open source project တစ်ခုကို ဖွံ့ဖြိုးတိုးတက်စေခြင်းနှင့် ထိန်းသိမ်းခြင်းအတွက် တာဝန်ယူသော အဖွဲ့။ +* **Hugging Face Community**: Hugging Face ပလက်ဖောင်းကို အသုံးပြုပြီး ပံ့ပိုးကူညီနေသော လူအဖွဲ့အစည်း။ +* **Categories**: forum ပေါ်ရှိ topics များကို စုစည်းထားသော ကဏ္ဍများ။ +* **Topics**: forum ပေါ်ရှိ title, category, နှင့် description ပါဝင်သော post တစ်ခု။ +* **GitHub Issues**: GitHub repository များတွင် bug များ၊ feature requests များနှင့် အခြားပြဿနာများကို ခြေရာခံရန် အသုံးပြုသော platform။ +* **Beginners Category**: Hugging Face libraries နှင့် ecosystem ကို အခုမှ စတင်လေ့လာသူများအတွက် ရည်ရွယ်သော forum category။ +* **Debug**: ကွန်ပျူတာပရိုဂရမ်တစ်ခုရှိ အမှားများ (bugs) ကို ရှာဖွေ၊ ဖော်ထုတ်ပြီး ပြင်ဆင်ခြင်း။ +* **Intermediate Category**: ပိုမိုအဆင့်မြင့်သော မေးခွန်းများအတွက် ရည်ရွယ်သော forum category။ +* **Research Category**: NLP သုတေသနအသစ်များ အပါအဝင် ပိုမိုအဆင့်မြင့်သော သုတေသနဆိုင်ရာ မေးခွန်းများအတွက် ရည်ရွယ်သော forum category။ +* **Course Category**: Hugging Face သင်တန်းနှင့် ပတ်သက်သော မေးခွန်းများအတွက် ရည်ရွယ်သော forum category။ +* **Embeddings**: စကားလုံးများ၊ စာသားများ သို့မဟုတ် အခြားဒေတာများကို vector space အတွင်းရှိ ဂဏန်းဆိုင်ရာ ကိုယ်စားပြုမှုများအဖြစ် ပြောင်းလဲခြင်း။ +* **Wikipedia Articles**: Wikipedia စွယ်စုံကျမ်းရှိ ဆောင်းပါးများ။ +* **Custom Search Engine**: သီးခြားလိုအပ်ချက်များ သို့မဟုတ် ဒေတာများအတွက် ကိုယ်တိုင်တည်ဆောက်ထားသော search engine။ +* **`AutoTokenizer`**: Hugging Face Transformers library မှာ ပါဝင်တဲ့ class တစ်ခုဖြစ်ပြီး မော်ဒယ်အမည်ကို အသုံးပြုပြီး သက်ဆိုင်ရာ tokenizer ကို အလိုအလျောက် load လုပ်ပေးသည်။ +* **`AutoModel`**: Hugging Face Transformers library မှာ ပါဝင်တဲ့ class တစ်ခုဖြစ်ပြီး မော်ဒယ်အမည်ကို အသုံးပြုပြီး သက်ဆိုင်ရာ model ကို အလိုအလျောက် load လုပ်ပေးသည်။ +* **`model_checkpoint`**: pretrained model ၏ နာမည် (ဥပမာ- `distilbert-base-uncased`)။ +* **`from_pretrained()` Method**: pretrained model သို့မဟုတ် tokenizer ကို load လုပ်ရန် အသုံးပြုသော method။ +* **`distilbert-base-uncased`**: DistilBERT model ၏ base, uncased version အတွက် checkpoint identifier။ +* **`text`**: စာသား input။ +* **`tokenizer(text, return_tensors="pt")`**: စာသားကို tokenize လုပ်ပြီး PyTorch tensors များအဖြစ် ပြန်ပေးသည်။ +* **`logits`**: model ၏ raw, unnormalized prediction scores များ။ +* **`IndexError`**: Python တွင် sequence (list, tuple) တစ်ခု၏ index သည် ၎င်း၏ သတ်မှတ်ထားသော အတိုင်းအတာပြင်ပတွင် ရှိနေသောအခါ ဖြစ်ပေါ်သော error။ +* **Error Message**: ပရိုဂရမ်တစ်ခုတွင် အမှားတစ်ခု ဖြစ်ပေါ်သောအခါ ပြသသော စာသား။ +* **Cryptic**: နားလည်ရခက်ခဲခြင်း သို့မဟုတ် မရှင်းမလင်းဖြစ်ခြင်း။ +* **Full Traceback**: Python ပရိုဂရမ်တစ်ခုတွင် error ဖြစ်ပေါ်သည့် အချိန်မှစ၍ code execution ၏ လမ်းကြောင်းအပြည့်အစုံကို ပြသခြင်း။ +* **New Topic Button**: forum ပေါ်တွင် post အသစ်တစ်ခု ဖန်တီးရန် ခလုတ်။ +* **Writing Interface**: post, article သို့မဟုတ် အခြားစာသားများကို ရေးသားရန်အတွက် ဆော့ဖ်ဝဲလ် interface။ +* **Category**: forum ပေါ်တွင် topic ကို ခွဲခြားသတ်မှတ်ရန် အသုံးပြုသော အုပ်စု။ +* **Draft**: topic ၏ အကြောင်းအရာကို ရေးသားခြင်း။ +* **`model(**inputs).logits`**: model ၏ forward pass ကို input များနှင့် ခေါ်ဆိုခြင်း။ +* **Descriptive Title**: topic ၏ အကြောင်းအရာကို ရှင်းရှင်းလင်းလင်း ဖော်ပြသော title။ +* **Exception**: ပရိုဂရမ်တစ်ခု အလုပ်လုပ်နေစဉ် ဖြစ်ပေါ်လာသော error သို့မဟုတ် မမျှော်လင့်သော အခြေအနေ။ +* **Forward Pass**: Neural network တစ်ခုမှ input data ကို layers များမှတစ်ဆင့် ဖြတ်သန်းကာ output ကို ထုတ်လုပ်သည့် လုပ်ငန်းစဉ်။ +* **Code Snippets**: code ၏ အစိတ်အပိုင်းငယ်များ။ +* **IDE (Integrated Development Environment)**: ဆော့ဖ်ဝဲလ် developer များအတွက် code ရေးသားခြင်း၊ debug လုပ်ခြင်းနှင့် test လုပ်ခြင်းတို့ကို လွယ်ကူစေသော ဆော့ဖ်ဝဲလ်ပတ်ဝန်းကျင်။ +* **Markdown**: Plain text format တစ်ခုဖြစ်ပြီး formatting syntax ကို အသုံးပြု၍ စာသားကို ပုံစံချခြင်း။ +* **Backticks (```)**: Markdown တွင် code blocks များကို ဖော်မတ်ချရန် အသုံးပြုသော အမှတ်အသားများ။ +* **Color Styling**: code ၏ မတူညီသော အစိတ်အပိုင်းများကို မတူညီသော အရောင်များဖြင့် ပြသခြင်း။ +* **Inline Variables**: စာကြောင်းတစ်ကြောင်းအတွင်း၌ ဖော်ပြထားသော variables များ။ +* **Reproducible Example**: အခြားသူတစ်ဦးက တူညီသော error ကို ပြန်လည်ဖန်တီးနိုင်ရန် လုံလောက်သော အချက်အလက်နှင့် code ပါဝင်သော ဥပမာ။ +* **Input**: model သို့ ပေးပို့သော ဒေတာ။ +* **Token Indices Sequence Length**: tokenizer မှ ထုတ်လုပ်ထားသော tokens များ၏ အရှည်။ +* **Maximum Sequence Length**: model တစ်ခု လက်ခံနိုင်သော အရှည်ဆုံး sequence (tokens အရေအတွက်)။ \ No newline at end of file diff --git a/chapters/my/chapter8/4.mdx b/chapters/my/chapter8/4.mdx new file mode 100644 index 000000000..1f1a83e2f --- /dev/null +++ b/chapters/my/chapter8/4.mdx @@ -0,0 +1,897 @@ + + +# Training Pipeline ကို Debug လုပ်ခြင်း[[debugging-the-training-pipeline]] + + + +[Chapter 7](/course/chapter7) က အကြံပြုချက်တွေကို လိုက်နာပြီး သတ်မှတ်ထားတဲ့ task တစ်ခုပေါ်မှာ model တစ်ခုကို train ဒါမှမဟုတ် fine-tune လုပ်ဖို့အတွက် လှပတဲ့ script တစ်ခုကို သင်ရေးခဲ့ပါပြီ။ ဒါပေမယ့် `trainer.train()` command ကို run လိုက်တဲ့အခါ ဆိုးဝါးတဲ့အရာတစ်ခု ဖြစ်သွားပါတယ်- သင် error ရပါပြီ 😱! ဒါမှမဟုတ် ပိုဆိုးတာကတော့၊ အရာအားလုံး အဆင်ပြေနေပြီး training က error မရှိဘဲ run နေပေမယ့်၊ ရရှိလာတဲ့ model က အသုံးမဝင်ပါဘူး။ ဒီအပိုင်းမှာ၊ ဒီလိုပြဿနာတွေကို debug လုပ်ဖို့ ဘာတွေလုပ်ဆောင်နိုင်လဲဆိုတာ ကျွန်တော်တို့ ပြသပေးပါမယ်။ + +## Training Pipeline ကို Debug လုပ်ခြင်း[[debugging-the-training-pipeline]] + + + +`trainer.train()` မှာ error ကြုံတွေ့ရတဲ့အခါ ပြဿနာက source မျိုးစုံကနေ လာနိုင်ပါတယ်။ ဘာလို့လဲဆိုတော့ `Trainer` က အများအားဖြင့် အရာများစွာကို ပေါင်းစပ်ထားလို့ပါပဲ။ ၎င်းက datasets တွေကို dataloaders တွေအဖြစ် ပြောင်းလဲပေးတာကြောင့်၊ ပြဿနာက သင့် dataset မှာ တစ်ခုခု မှားယွင်းတာ ဒါမှမဟုတ် datasets ရဲ့ elements တွေကို batch လုပ်တဲ့အခါ ပြဿနာတစ်ခုခု ဖြစ်နေတာ ဖြစ်နိုင်ပါတယ်။ ပြီးရင် data batch တစ်ခုကို ယူပြီး model ကို ပေးပို့တဲ့အခါ၊ ပြဿနာက model code ထဲမှာ ဖြစ်နိုင်ပါတယ်။ အဲဒီနောက်၊ gradients တွေကို တွက်ချက်ပြီး optimization step ကို လုပ်ဆောင်တာကြောင့်၊ ပြဿနာက သင့် optimizer ထဲမှာလည်း ဖြစ်နိုင်ပါတယ်။ ပြီးတော့ training အတွက် အရာအားလုံး အဆင်ပြေသွားရင်တောင်၊ သင့် metric မှာ ပြဿနာရှိရင် evaluation လုပ်နေစဉ် တစ်ခုခု မှားယွင်းသွားနိုင်ပါသေးတယ်။ + +`trainer.train()` မှာ ပေါ်လာတဲ့ error တစ်ခုကို debug လုပ်ဖို့ အကောင်းဆုံးနည်းလမ်းကတော့ အရာတွေ ဘယ်နေရာမှာ မှားယွင်းသွားလဲဆိုတာ သိဖို့ ဒီ pipeline တစ်ခုလုံးကို ကိုယ်တိုင်ဖြတ်သန်းကြည့်ဖို့ပါပဲ။ အဲဒီအခါ error က မကြာခဏဆိုသလို အလွန်လွယ်ကူစွာ ဖြေရှင်းနိုင်ပါတယ်။ + +ဒါကို သရုပ်ပြဖို့အတွက်၊ [MNLI dataset](https://huggingface.co/datasets/glue) ပေါ်မှာ DistilBERT model တစ်ခုကို fine-tune လုပ်ဖို့ ကြိုးစားတဲ့ အောက်ပါ script ကို ကျွန်တော်တို့ အသုံးပြုပါမယ်။ + +```py +from datasets import load_dataset +import evaluate +from transformers import ( + AutoTokenizer, + AutoModelForSequenceClassification, + TrainingArguments, + Trainer, +) + +raw_datasets = load_dataset("glue", "mnli") + +model_checkpoint = "distilbert-base-uncased" +tokenizer = AutoTokenizer.from_pretrained(model_checkpoint) + + +def preprocess_function(examples): + return tokenizer(examples["premise"], examples["hypothesis"], truncation=True) + + +tokenized_datasets = raw_datasets.map(preprocess_function, batched=True) +model = AutoModelForSequenceClassification.from_pretrained(model_checkpoint) + +args = TrainingArguments( + f"distilbert-finetuned-mnli", + evaluation_strategy="epoch", + save_strategy="epoch", + learning_rate=2e-5, + num_train_epochs=3, + weight_decay=0.01, +) + +metric = evaluate.load("glue", "mnli") + + +def compute_metrics(eval_pred): + predictions, labels = eval_pred + return metric.compute(predictions=predictions, references=labels) + + +trainer = Trainer( + model, + args, + train_dataset=raw_datasets["train"], + eval_dataset=raw_datasets["validation_matched"], + compute_metrics=compute_metrics, +) +trainer.train() +``` + +သင် ဒါကို run ဖို့ ကြိုးစားရင်၊ နားမလည်နိုင်တဲ့ error တစ်ခုနဲ့ ကြုံတွေ့ရပါလိမ့်မယ်။ + +```python out +'ValueError: You have to specify either input_ids or inputs_embeds' +``` + +### သင့် Data ကို စစ်ဆေးပါ[[check-your-data]] + +ဒါက ပြောစရာမလိုပါဘူး၊ ဒါပေမယ့် သင့် data က ပျက်စီးနေတယ်ဆိုရင်၊ `Trainer` က batches တွေ ဖန်တီးနိုင်မှာ မဟုတ်ပါဘူး၊ သင့် model ကို train လုပ်ဖို့ဆို ဝေးသေးတာပေါ့။ ဒါကြောင့် ပထမဆုံးအနေနဲ့၊ သင့် training set ထဲမှာ ဘာတွေပါလဲဆိုတာ ကြည့်ရပါမယ်။ + +bug ရဲ့ source မဟုတ်တဲ့အရာတစ်ခုကို ပြင်ဆင်ဖို့ ကြိုးစားရင်း အချိန်တွေ အများကြီး မကုန်စေဖို့၊ သင့်စစ်ဆေးမှုတွေအတွက် `trainer.train_dataset` ကိုပဲ အသုံးပြုဖို့ ကျွန်တော်တို့ အကြံပြုပါတယ်။ ဒါကြောင့် ဒီနေရာမှာ လုပ်ကြည့်ရအောင်။ + +```py +trainer.train_dataset[0] +``` + +```python out +{'hypothesis': 'Product and geography are what make cream skimming work. ', + 'idx': 0, + 'label': 1, + 'premise': 'Conceptually cream skimming has two basic dimensions - product and geography.'} +``` + +တစ်ခုခု မှားယွင်းနေတာကို သတိထားမိပါသလား။ ဒါက `input_ids` ပျောက်ဆုံးနေတာနဲ့ ပတ်သက်တဲ့ error message နဲ့ ပေါင်းစပ်လိုက်တဲ့အခါ၊ ဒါတွေက text တွေဖြစ်ပြီး model က နားလည်နိုင်တဲ့ ဂဏန်းတွေ မဟုတ်ဘူးဆိုတာ သင်သိလာပါလိမ့်မယ်။ ဒီနေရာမှာ၊ မူရင်း error က အလွန်ထင်ယောင်ထင်မှားဖြစ်စေပါတယ်။ ဘာလို့လဲဆိုတော့ `Trainer` က model signature (ဆိုလိုတာက model က မျှော်လင့်ထားတဲ့ arguments) နဲ့ မကိုက်ညီတဲ့ columns တွေကို အလိုအလျောက် ဖယ်ရှားလိုက်လို့ပါပဲ။ ဒါက ဒီနေရာမှာ labels တွေကလွဲပြီး ကျန်တာအားလုံး ဖယ်ရှားခံခဲ့ရတယ်လို့ ဆိုလိုပါတယ်။ ဒါကြောင့် batches တွေ ဖန်တီးရာမှာ ပြဿနာမရှိခဲ့ဘဲ၊ ပြီးမှ model ကို ပေးပို့တဲ့အခါ model က သင့်လျော်တဲ့ input ကို မရရှိခဲ့ဘူးလို့ ညည်းညူခဲ့တာပါ။ + +Data ကို ဘာကြောင့် processing မလုပ်ခဲ့တာလဲ။ ကျွန်တော်တို့ `Dataset.map()` method ကို datasets တွေပေါ်မှာ sample တစ်ခုစီမှာ tokenizer ကို အသုံးပြုဖို့ လုပ်ခဲ့ပါတယ်။ ဒါပေမယ့် code ကို သေချာကြည့်မယ်ဆိုရင်၊ training နဲ့ evaluation sets တွေကို `Trainer` ကို ပေးတဲ့အခါ အမှားလုပ်မိခဲ့တာကို တွေ့ရပါလိမ့်မယ်။ ဒီနေရာမှာ `tokenized_datasets` ကို အသုံးပြုမယ့်အစား၊ `raw_datasets` ကို ကျွန်တော်တို့ အသုံးပြုခဲ့ပါတယ် 🤦။ ဒါကြောင့် ဒါကို ပြင်ဆင်လိုက်ရအောင်! + +```py +from datasets import load_dataset +import evaluate +from transformers import ( + AutoTokenizer, + AutoModelForSequenceClassification, + TrainingArguments, + Trainer, +) + +raw_datasets = load_dataset("glue", "mnli") + +model_checkpoint = "distilbert-base-uncased" +tokenizer = AutoTokenizer.from_pretrained(model_checkpoint) + + +def preprocess_function(examples): + return tokenizer(examples["premise"], examples["hypothesis"], truncation=True) + + +tokenized_datasets = raw_datasets.map(preprocess_function, batched=True) +model = AutoModelForSequenceClassification.from_pretrained(model_checkpoint) + +args = TrainingArguments( + f"distilbert-finetuned-mnli", + evaluation_strategy="epoch", + save_strategy="epoch", + learning_rate=2e-5, + num_train_epochs=3, + weight_decay=0.01, +) + +metric = evaluate.load("glue", "mnli") + + +def compute_metrics(eval_pred): + predictions, labels = eval_pred + return metric.compute(predictions=predictions, references=labels) + + +trainer = Trainer( + model, + args, + train_dataset=tokenized_datasets["train"], + eval_dataset=tokenized_datasets["validation_matched"], + compute_metrics=compute_metrics, +) +trainer.train() +``` + +ဒီ code အသစ်က အခုဆိုရင် မတူညီတဲ့ error တစ်ခု ပေးပါလိမ့်မယ် (တိုးတက်မှုပါပဲ!) + +```python out +'ValueError: expected sequence of length 43 at dim 1 (got 37)' +``` + +traceback ကို ကြည့်လိုက်တဲ့အခါ၊ error က data collation step မှာ ဖြစ်ပေါ်နေတာကို ကျွန်တော်တို့ တွေ့နိုင်ပါတယ်။ + +```python out +~/git/transformers/src/transformers/data/data_collator.py in torch_default_data_collator(features) + 105 batch[k] = torch.stack([f[k] for f in features]) + 106 else: +--> 107 batch[k] = torch.tensor([f[k] for f in features]) + 108 + 109 return batch +``` + +ဒါကြောင့်၊ အဲဒီကို ဆက်သွားသင့်ပါတယ်။ ဒါပေမယ့် မလုပ်ခင်မှာ၊ ကျွန်တော်တို့ data ကို စစ်ဆေးတာကို အမှန်တကယ် မှန်ကန်ကြောင်း ၁၀၀% သေချာစေဖို့ အဆုံးသတ်လိုက်ကြပါစို့။ + +training session တစ်ခုကို debug လုပ်တဲ့အခါ သင်အမြဲလုပ်သင့်တာက သင့် model ရဲ့ decoded inputs တွေကို ကြည့်ဖို့ပါပဲ။ ကျွန်တော်တို့ ပေးပို့တဲ့ ဂဏန်းတွေကို တိုက်ရိုက်နားမလည်နိုင်တာကြောင့်၊ အဲဒီဂဏန်းတွေက ဘာကို ကိုယ်စားပြုလဲဆိုတာ ကြည့်သင့်ပါတယ်။ ဥပမာ၊ computer vision မှာ၊ ဒါက သင်ပေးပို့တဲ့ pixels တွေရဲ့ decoded pictures တွေကို ကြည့်တာကို ဆိုလိုပါတယ်၊ speech မှာဆိုရင် decoded audio samples တွေကို နားထောင်တာကို ဆိုလိုပါတယ်၊ ပြီးတော့ ကျွန်တော်တို့ရဲ့ NLP ဥပမာမှာ ဒါက ကျွန်တော်တို့ရဲ့ tokenizer ကို အသုံးပြုပြီး inputs တွေကို decode လုပ်တာကို ဆိုလိုပါတယ်။ + +```py +tokenizer.decode(trainer.train_dataset[0]["input_ids"]) +``` + +```python out +'[CLS] conceptually cream skimming has two basic dimensions - product and geography. [SEP] product and geography are what make cream skimming work. [SEP]' +``` + +ဒါကြောင့် ဒါက မှန်ကန်ပုံရပါတယ်။ inputs ထဲက keys အားလုံးအတွက် ဒါကို လုပ်ဆောင်သင့်ပါတယ်။ + +```py +trainer.train_dataset[0].keys() +``` + +```python out +dict_keys(['attention_mask', 'hypothesis', 'idx', 'input_ids', 'label', 'premise']) +``` + +model က လက်ခံတဲ့ inputs နဲ့ မကိုက်ညီတဲ့ keys တွေကို အလိုအလျောက် ဖယ်ရှားပစ်မှာဖြစ်တာကြောင့်၊ ဒီနေရာမှာ ကျွန်တော်တို့ `input_ids`, `attention_mask` နဲ့ `label` (ဒါကို `labels` လို့ နာမည်ပြောင်းပါလိမ့်မယ်) တွေကိုပဲ ထားရှိမှာပါ။ model signature ကို ထပ်မံစစ်ဆေးဖို့အတွက်၊ သင့် model ရဲ့ class ကို print ထုတ်ပြီး ၎င်းရဲ့ documentation ကို သွားစစ်ဆေးနိုင်ပါတယ်။ + +```py +type(trainer.model) +``` + +```python out +transformers.models.distilbert.modeling_distilbert.DistilBertForSequenceClassification +``` + +ဒါကြောင့် ကျွန်တော်တို့ရဲ့ ကိစ္စမှာ၊ [ဒီစာမျက်နှာ](https://huggingface.co/transformers/model_doc/distilbert.html#distilbertforsequenceclassification) မှာ လက်ခံတဲ့ parameters တွေကို စစ်ဆေးနိုင်ပါတယ်။ `Trainer` က ဖယ်ရှားနေတဲ့ columns တွေကိုလည်း log လုပ်ပါလိမ့်မယ်။ + +input IDs တွေ မှန်ကန်ကြောင်း decoded လုပ်ခြင်းဖြင့် စစ်ဆေးခဲ့ပါပြီ။ နောက်တစ်ခုကတော့ `attention_mask` ပါ။ + +```py +trainer.train_dataset[0]["attention_mask"] +``` + +```python out +[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] +``` + +ကျွန်တော်တို့ preprocessing မှာ padding ကို အသုံးပြုမထားတာကြောင့်၊ ဒါက လုံးဝပုံမှန်ပါပဲ။ အဲဒီ attention mask မှာ ပြဿနာမရှိကြောင်း သေချာစေဖို့၊ ကျွန်တော်တို့ input IDs တွေနဲ့ အရှည်တူညီလားဆိုတာ စစ်ဆေးကြည့်ရအောင်။ + +```py +len(trainer.train_dataset[0]["attention_mask"]) == len( + trainer.train_dataset[0]["input_ids"] +) +``` + +```python out +True +``` + +ဒါကောင်းပါပြီ! နောက်ဆုံးအနေနဲ့၊ ကျွန်တော်တို့ရဲ့ label ကို စစ်ဆေးကြည့်ရအောင်။ + +```py +trainer.train_dataset[0]["label"] +``` + +```python out +1 +``` + +input IDs တွေလိုပဲ၊ ဒါကလည်း သူ့ဘာသာသူ အဓိပ္ပာယ်မရှိတဲ့ ဂဏန်းတစ်ခုပါ။ ကျွန်တော်တို့ အရင်က တွေ့ခဲ့ရတဲ့အတိုင်း၊ integers တွေနဲ့ label names တွေကြားက map ကို dataset ရဲ့ သက်ဆိုင်ရာ *feature* ရဲ့ `names` attribute ထဲမှာ သိမ်းဆည်းထားပါတယ်။ + +```py +trainer.train_dataset.features["label"].names +``` + +```python out +['entailment', 'neutral', 'contradiction'] +``` + +ဒါကြောင့် `1` က `neutral` ကို ဆိုလိုပါတယ်၊ ဆိုလိုတာက အပေါ်မှာ ကျွန်တော်တို့ တွေ့ခဲ့ရတဲ့ စာကြောင်းနှစ်ကြောင်းက contradiction မဟုတ်ဘဲ၊ ပထမစာကြောင်းက ဒုတိယစာကြောင်းကို အဓိပ္ပာယ်မဆောင်ပါဘူး။ ဒါက မှန်ကန်ပုံရပါတယ်! + +ဒီနေရာမှာ token type IDs တွေ မရှိပါဘူး၊ ဘာလို့လဲဆိုတော့ DistilBERT က ၎င်းတို့ကို မျှော်လင့်မထားလို့ပါ။ သင့် model မှာ ဒါတွေရှိတယ်ဆိုရင်၊ ၎င်းတို့က input မှာ ပထမနဲ့ ဒုတိယစာကြောင်းတွေ ဘယ်နေရာမှာ ရှိလဲဆိုတာကို မှန်ကန်စွာ ကိုက်ညီမှုရှိမရှိလည်း သေချာစစ်ဆေးသင့်ပါတယ်။ + +> [!TIP] +> ✏️ **သင့်အလှည့်!** training dataset ရဲ့ ဒုတိယ element နဲ့ အရာအားလုံး မှန်ကန်ပုံရမလားဆိုတာ စစ်ဆေးပါ။ + +ကျွန်တော်တို့ training set ပေါ်မှာပဲ စစ်ဆေးတာဖြစ်ပေမယ့်၊ validation နဲ့ test sets တွေကိုလည်း ဒီအတိုင်းပဲ ထပ်မံစစ်ဆေးသင့်ပါတယ်။ + +ကျွန်တော်တို့ datasets တွေ ကောင်းမွန်ကြောင်း သိပြီဆိုတော့၊ training pipeline ရဲ့ နောက်တစ်ဆင့်ကို စစ်ဆေးဖို့ အချိန်တန်ပါပြီ။ + +### Datasets တွေကနေ Dataloaders တွေဆီသို့[[from-datasets-to-dataloaders]] + +training pipeline မှာ မှားယွင်းနိုင်တဲ့ နောက်တစ်ချက်ကတော့ `Trainer` က training ဒါမှမဟုတ် validation set ကနေ batches တွေ ဖန်တီးဖို့ ကြိုးစားတဲ့အခါပါပဲ။ `Trainer` ရဲ့ datasets တွေ မှန်ကန်ကြောင်း သင်သေချာပြီဆိုတာနဲ့၊ အောက်ပါအတိုင်း run ခြင်းဖြင့် batch တစ်ခုကို ကိုယ်တိုင်ဖန်တီးဖို့ ကြိုးစားနိုင်ပါတယ် (`train` ကို validation dataloader အတွက် `eval` နဲ့ အစားထိုးပါ)။ + +```py +for batch in trainer.get_train_dataloader(): + break +``` + +ဒီ code က training dataloader ကို ဖန်တီးပြီး၊ ပြီးရင် ၎င်းကို iteration လုပ်ပြီး ပထမဆုံး iteration မှာ ရပ်တန့်ပါတယ်။ code က error မရှိဘဲ run တယ်ဆိုရင်၊ သင်စစ်ဆေးနိုင်တဲ့ ပထမဆုံး training batch ကို ရရှိမှာဖြစ်ပြီး၊ code က error ဖြစ်ရင်တော့ ပြဿနာက dataloader ထဲမှာ အမှန်တကယ်ရှိနေတယ်ဆိုတာ သင်သေချာသိနိုင်ပါတယ်။ ဒီနေရာမှာလည်း ဒီလိုပါပဲ။ + +```python out +~/git/transformers/src/transformers/data/data_collator.py in torch_default_data_collator(features) + 105 batch[k] = torch.stack([f[k] for f in features]) + 106 else: +--> 107 batch[k] = torch.tensor([f[k] for f in features]) + 108 + 109 return batch + +ValueError: expected sequence of length 45 at dim 1 (got 76) +``` + +traceback ရဲ့ နောက်ဆုံး frame ကို စစ်ဆေးတာက သင့်ကို clue တစ်ခုပေးဖို့ လုံလောက်သင့်ပေမယ့်၊ နည်းနည်းထပ်တူးဆွကြည့်ရအောင်။ batch creation လုပ်နေစဉ် ပြဿနာအများစုက examples တွေကို single batch အဖြစ် collation လုပ်ခြင်းကြောင့် ဖြစ်ပေါ်တာကြောင့်၊ သံသယရှိတဲ့အခါ စစ်ဆေးသင့်တဲ့ ပထမဆုံးအရာကတော့ သင့် `DataLoader` က ဘယ် `collate_fn` ကို အသုံးပြုနေလဲဆိုတာပါပဲ။ + +```py +data_collator = trainer.get_train_dataloader().collate_fn +data_collator +``` + +```python out + Dict[str, Any]> +``` + +ဒါကြောင့် ဒါက `default_data_collator` ဖြစ်ပါတယ်။ ဒါပေမယ့် ဒီကိစ္စမှာ ကျွန်တော်တို့ လိုချင်တာ မဟုတ်ပါဘူး။ ကျွန်တော်တို့ရဲ့ examples တွေကို batch ထဲက အရှည်ဆုံး sentence အထိ padding လုပ်ချင်တာဖြစ်ပြီး၊ ဒါကို `DataCollatorWithPadding` collator က လုပ်ဆောင်ပေးပါတယ်။ ပြီးတော့ ဒီ data collator ကို `Trainer` က default အားဖြင့် အသုံးပြုသင့်တာကြောင့်၊ ဘာကြောင့် ဒီနေရာမှာ မသုံးတာလဲ။ + +အဖြေကတော့ ကျွန်တော်တို့ `tokenizer` ကို `Trainer` ကို မပေးခဲ့လို့ပါပဲ၊ ဒါကြောင့် ကျွန်တော်တို့ လိုချင်တဲ့ `DataCollatorWithPadding` ကို ဖန်တီးနိုင်ခြင်းမရှိခဲ့ပါဘူး။ လက်တွေ့မှာတော့၊ ဒီလို error မျိုးတွေ မဖြစ်စေဖို့အတွက် သင်အသုံးပြုချင်တဲ့ data collator ကို အမြဲတမ်း ရှင်းရှင်းလင်းလင်း ပေးပို့ဖို့ တုံ့ဆိုင်းမနေသင့်ပါဘူး။ ဒါကို လုပ်ဆောင်ဖို့အတွက် ကျွန်တော်တို့ရဲ့ code ကို လိုက်လျောညီထွေဖြစ်အောင် ပြင်ဆင်လိုက်ရအောင်။ + +```py +from datasets import load_dataset +import evaluate +from transformers import ( + AutoTokenizer, + AutoModelForSequenceClassification, + DataCollatorWithPadding, + TrainingArguments, + Trainer, +) + +raw_datasets = load_dataset("glue", "mnli") + +model_checkpoint = "distilbert-base-uncased" +tokenizer = AutoTokenizer.from_pretrained(model_checkpoint) + + +def preprocess_function(examples): + return tokenizer(examples["premise"], examples["hypothesis"], truncation=True) + + +tokenized_datasets = raw_datasets.map(preprocess_function, batched=True) +model = AutoModelForSequenceClassification.from_pretrained(model_checkpoint) + +args = TrainingArguments( + f"distilbert-finetuned-mnli", + evaluation_strategy="epoch", + save_strategy="epoch", + learning_rate=2e-5, + num_train_epochs=3, + weight_decay=0.01, +) + +metric = evaluate.load("glue", "mnli") + + +def compute_metrics(eval_pred): + predictions, labels = eval_pred + return metric.compute(predictions=predictions, references=labels) + + +data_collator = DataCollatorWithPadding(tokenizer=tokenizer) + +trainer = Trainer( + model, + args, + train_dataset=tokenized_datasets["train"], + eval_dataset=tokenized_datasets["validation_matched"], + compute_metrics=compute_metrics, + data_collator=data_collator, + tokenizer=tokenizer, +) +trainer.train() +``` + +သတင်းကောင်းလား? ကျွန်တော်တို့ အရင်လို error တူတူ မရတော့ပါဘူး၊ ဒါက တိုးတက်မှု အမှန်ပါပဲ။ သတင်းဆိုးလား? ကျွန်တော်တို့ နာမည်ဆိုးနဲ့ ကျော်ကြားတဲ့ CUDA error တစ်ခုကို ရပါပြီ။ + +```python out +RuntimeError: CUDA error: CUBLAS_STATUS_ALLOC_FAILED when calling `cublasCreate(handle)` +``` + +ဒါက မကောင်းပါဘူး၊ ဘာလို့လဲဆိုတော့ CUDA errors တွေကို debug လုပ်ရတာ ယေဘုယျအားဖြင့် အလွန်ခက်ခဲလို့ပါပဲ။ ဒီပြဿနာကို ဘယ်လိုဖြေရှင်းရမလဲဆိုတာ တစ်မိနစ်အတွင်းမှာ ကျွန်တော်တို့ ကြည့်ရမှာဖြစ်ပေမယ့်၊ ပထမဆုံး batch creation ရဲ့ ကျွန်တော်တို့ရဲ့ ခွဲခြမ်းစိတ်ဖြာမှုကို အဆုံးသတ်လိုက်ရအောင်။ + +သင့် data collator က မှန်ကန်တယ်ဆိုတာ သင်သေချာပြီဆိုရင်၊ သင့် dataset ရဲ့ samples အချို့ပေါ်မှာ အဲဒါကို အသုံးပြုကြည့်သင့်ပါတယ်။ + +```py +data_collator = trainer.get_train_dataloader().collate_fn +batch = data_collator([trainer.train_dataset[i] for i in range(4)]) +``` + +ဒီ code က အလုပ်လုပ်မှာ မဟုတ်ပါဘူး၊ ဘာလို့လဲဆိုတော့ `train_dataset` မှာ string columns တွေ ပါဝင်ပြီး ဒါတွေကို `Trainer` က ပုံမှန်အားဖြင့် ဖယ်ရှားလိုက်လို့ပါပဲ။ သင်ကိုယ်တိုင် ဖယ်ရှားနိုင်ပါတယ်၊ ဒါမှမဟုတ် `Trainer` က နောက်ကွယ်မှာ ဘာလုပ်နေလဲဆိုတာကို အတိအကျ ပုံတူကူးချင်တယ်ဆိုရင်၊ ဒါကို လုပ်ဆောင်ပေးတဲ့ private `Trainer._remove_unused_columns()` method ကို ခေါ်နိုင်ပါတယ်။ + +```py +data_collator = trainer.get_train_dataloader().collate_fn +actual_train_set = trainer._remove_unused_columns(trainer.train_dataset) +batch = data_collator([actual_train_set[i] for i in range(4)]) +``` + +error က ဆက်ရှိနေသေးတယ်ဆိုရင် data collator ထဲမှာ ဘာတွေဖြစ်ပျက်နေလဲဆိုတာကို ကိုယ်တိုင် debug လုပ်နိုင်ပါလိမ့်မယ်။ + +batch creation လုပ်ငန်းစဉ်ကို debug လုပ်ပြီးပြီဆိုတော့၊ model ထဲကို တစ်ခု ပေးပို့ဖို့ အချိန်တန်ပါပြီ! + +### Model ကို ဖြတ်သန်းခြင်း[[going-through-the-model]] + +အောက်ပါ command ကို run ခြင်းဖြင့် batch တစ်ခုကို ရရှိနိုင်ပါလိမ့်မယ်။ + +```py +for batch in trainer.get_train_dataloader(): + break +``` + +သင် ဒီ code ကို notebook တစ်ခုမှာ run နေတယ်ဆိုရင်၊ ကျွန်တော်တို့ အရင်က တွေ့ခဲ့ရတဲ့ error နဲ့ ဆင်တူတဲ့ CUDA error တစ်ခု ရနိုင်ပါတယ်။ ဒီလိုဖြစ်ရင် သင့် notebook ကို restart လုပ်ပြီး `trainer.train()` line မပါဘဲ နောက်ဆုံး snippet ကို ပြန် run ဖို့ လိုအပ်ပါတယ်။ ဒါက CUDA errors တွေရဲ့ ဒုတိယအ annoying ဆုံးအရာပါပဲ- ၎င်းတို့က သင့် kernel ကို ပြန်ပြင်လို့ မရအောင် ပျက်စီးစေပါတယ်။ အ annoyance ဆုံးအရာကတော့ ဒါတွေကို debug လုပ်ရတာ ခက်ခဲတာပါပဲ။ + +ဘာကြောင့်လဲ? ဒါက GPUs တွေ အလုပ်လုပ်ပုံနဲ့ ဆက်စပ်နေပါတယ်။ ၎င်းတို့ဟာ operations များစွာကို တစ်ပြိုင်နက်တည်း လုပ်ဆောင်ရာမှာ အလွန်ထိရောက်ပါတယ်၊ ဒါပေမယ့် အားနည်းချက်ကတော့ အဲဒီ instructions တွေထဲက တစ်ခုခုက error ဖြစ်သွားတဲ့အခါ၊ သင်ချက်ချင်း မသိနိုင်ပါဘူး။ program က GPU ပေါ်ရှိ multiple processes တွေကို synchronization လုပ်ဖို့ ခေါ်ဆိုတဲ့အခါမှ တစ်ခုခု မှားယွင်းသွားတယ်ဆိုတာ သိမှာဖြစ်တာကြောင့်၊ error က အမှန်တကယ်တော့ ဒါကို ဖန်တီးတဲ့အရာနဲ့ လုံးဝမသက်ဆိုင်တဲ့ နေရာမှာ ပေါ်လာတာပါ။ ဥပမာ၊ ကျွန်တော်တို့ရဲ့ ယခင် traceback ကို ကြည့်ရင်၊ error က backward pass မှာ ပေါ်လာခဲ့ပါတယ်၊ ဒါပေမယ့် ဒါက forward pass ကနေ အမှန်တကယ် ပေါက်ဖွားလာတယ်ဆိုတာ တစ်မိနစ်အတွင်းမှာ ကျွန်တော်တို့ တွေ့ရပါလိမ့်မယ်။ + +ဒါဆို ဒီ errors တွေကို ဘယ်လို debug လုပ်မလဲ? အဖြေက လွယ်ပါတယ်- ကျွန်တော်တို့ မလုပ်ပါဘူး။ သင့် CUDA error က out-of-memory error (ဆိုလိုတာက သင့် GPU မှာ memory မလုံလောက်ခြင်း) မဟုတ်ရင်၊ ဒါကို debug လုပ်ဖို့အတွက် CPU ကို အမြဲတမ်း ပြန်သွားသင့်ပါတယ်။ + +ဒီကိစ္စမှာ ဒါကိုလုပ်ဖို့၊ ကျွန်တော်တို့ model ကို CPU ပေါ်ကို ပြန်တင်ပြီး ကျွန်တော်တို့ရဲ့ batch ပေါ်မှာ ခေါ်လိုက်ရုံပါပဲ — `DataLoader` က ပြန်ပေးတဲ့ batch ကို GPU ကို မရွှေ့ရသေးပါဘူး။ + +```python +outputs = trainer.model.cpu()(**batch) +``` + +```python out +~/.pyenv/versions/3.7.9/envs/base/lib/python3.7/site-packages/torch/nn/functional.py in nll_loss(input, target, weight, size_average, ignore_index, reduce, reduction) + 2386 ) + 2387 if dim == 2: +-> 2388 ret = torch._C._nn.nll_loss(input, target, weight, _Reduction.get_enum(reduction), ignore_index) + 2389 elif dim == 4: + 2390 ret = torch._C._nn.nll_loss2d(input, target, weight, _Reduction.get_enum(reduction), ignore_index) + +IndexError: Target 2 is out of bounds. +``` + +ဒါဆို ပုံက ပိုရှင်းလာပါပြီ။ CUDA error ရမယ့်အစား၊ အခု ကျွန်တော်တို့ loss computation မှာ `IndexError` ရပါပြီ (ဒါကြောင့် အရင်က ပြောခဲ့သလို backward pass နဲ့ ဘာမှမဆိုင်ပါဘူး)။ ပိုတိကျစွာပြောရရင်၊ target 2 က error ကို ဖန်တီးတာကို တွေ့ရပါတယ်၊ ဒါကြောင့် ဒါက ကျွန်တော်တို့ model ရဲ့ labels အရေအတွက်ကို စစ်ဆေးဖို့ အလွန်ကောင်းတဲ့အချိန်ပါပဲ။ + +```python +trainer.model.config.num_labels +``` + +```python out +2 +``` + +labels နှစ်ခုနဲ့ဆိုရင်၊ targets အနေနဲ့ 0s နဲ့ 1s တွေကိုပဲ ခွင့်ပြုပါတယ်။ ဒါပေမယ့် error message အရ ကျွန်တော်တို့ 2 ကို ရရှိခဲ့ပါတယ်။ 2 ကို ရတာက တကယ်တော့ ပုံမှန်ပါပဲ- ကျွန်တော်တို့ အရင်က ထုတ်ယူခဲ့တဲ့ label names တွေကို မှတ်မိရင်၊ သုံးခုရှိခဲ့တာကြောင့် ကျွန်တော်တို့ dataset မှာ indices 0, 1, နဲ့ 2 ရှိပါတယ်။ ပြဿနာကတော့ ကျွန်တော်တို့ model ကို ဒါကို မပြောခဲ့တာပါ၊ ဒါကို labels သုံးခုနဲ့ ဖန်တီးခဲ့သင့်ပါတယ်။ ဒါကြောင့် ဒါကို ပြင်ဆင်လိုက်ရအောင်! + +```py +from datasets import load_dataset +import evaluate +from transformers import ( + AutoTokenizer, + AutoModelForSequenceClassification, + DataCollatorWithPadding, + TrainingArguments, + Trainer, +) + +raw_datasets = load_dataset("glue", "mnli") + +model_checkpoint = "distilbert-base-uncased" +tokenizer = AutoTokenizer.from_pretrained(model_checkpoint) + + +def preprocess_function(examples): + return tokenizer(examples["premise"], examples["hypothesis"], truncation=True) + + +tokenized_datasets = raw_datasets.map(preprocess_function, batched=True) +model = AutoModelForSequenceClassification.from_pretrained(model_checkpoint, num_labels=3) + +args = TrainingArguments( + f"distilbert-finetuned-mnli", + evaluation_strategy="epoch", + save_strategy="epoch", + learning_rate=2e-5, + num_train_epochs=3, + weight_decay=0.01, +) + +metric = evaluate.load("glue", "mnli") + + +def compute_metrics(eval_pred): + predictions, labels = eval_pred + return metric.compute(predictions=predictions, references=labels) + + +data_collator = DataCollatorWithPadding(tokenizer=tokenizer) + +trainer = Trainer( + model, + args, + train_dataset=tokenized_datasets["train"], + eval_dataset=tokenized_datasets["validation_matched"], + compute_metrics=compute_metrics, + data_collator=data_collator, + tokenizer=tokenizer, +) +``` + +`trainer.train()` line ကို ကျွန်တော်တို့ မထည့်သေးပါဘူး၊ အရာအားလုံး အဆင်ပြေလားဆိုတာ စစ်ဆေးဖို့ အချိန်ယူထားတာပါ။ batch တစ်ခုကို တောင်းခံပြီး ကျွန်တော်တို့ model ကို ပေးပို့လိုက်တဲ့အခါ၊ အခုဆိုရင် error မရှိဘဲ အလုပ်လုပ်ပါပြီ။ + +```py +for batch in trainer.get_train_dataloader(): + break + +outputs = trainer.model.cpu()(**batch) +``` + +နောက်တစ်ဆင့်ကတော့ GPU ကို ပြန်သွားပြီး အရာအားလုံး ဆက်အလုပ်လုပ်လားဆိုတာ စစ်ဆေးဖို့ပါပဲ။ + +```py +import torch + +device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu") +batch = {k: v.to(device) for k, v in batch.items()} + +outputs = trainer.model.to(device)(**batch) +``` + +error ဆက်ရနေသေးတယ်ဆိုရင်၊ သင့် notebook ကို restart လုပ်ပြီး script ရဲ့ နောက်ဆုံး version ကိုပဲ run ဖို့ သေချာပါစေ။ + +### Optimization Step တစ်ခု လုပ်ဆောင်ခြင်း[[performing-one-optimization-step]] + +အခုဆိုရင် model ကို အမှန်တကယ် ဖြတ်သန်းနိုင်တဲ့ batches တွေ တည်ဆောက်နိုင်ပြီဆိုတာ သိပြီဖြစ်လို့၊ training pipeline ရဲ့ နောက်တစ်ဆင့်ဖြစ်တဲ့ gradients တွေ တွက်ချက်ခြင်းနဲ့ optimization step တစ်ခု လုပ်ဆောင်ခြင်းအတွက် အဆင်သင့်ပါပဲ။ + +ပထမအပိုင်းကတော့ loss ပေါ်မှာ `backward()` method ကို ခေါ်လိုက်ရုံပါပဲ။ + +```py +loss = outputs.loss +loss.backward() +``` + +ဒီအဆင့်မှာ error ရတာ ရှားပါတယ်၊ ဒါပေမယ့် ရခဲ့တယ်ဆိုရင်တော့ အထောက်အကူဖြစ်မယ့် error message တစ်ခုရဖို့ CPU ကို ပြန်သွားဖို့ သေချာပါစေ။ + +optimization step ကို လုပ်ဆောင်ဖို့အတွက်၊ ကျွန်တော်တို့ `optimizer` ကို ဖန်တီးပြီး ၎င်းရဲ့ `step()` method ကို ခေါ်လိုက်ရုံပါပဲ။ + +```py +trainer.create_optimizer() +trainer.optimizer.step() +``` + +ထပ်မံပြီးတော့၊ `Trainer` မှာ default optimizer ကို အသုံးပြုနေတယ်ဆိုရင်၊ ဒီအဆင့်မှာ error မရသင့်ပါဘူး။ ဒါပေမယ့် သင့်မှာ custom optimizer ရှိတယ်ဆိုရင်၊ ဒီနေရာမှာ debug လုပ်စရာ ပြဿနာအချို့ ရှိနိုင်ပါတယ်။ ဒီအဆင့်မှာ ထူးဆန်းတဲ့ CUDA error တစ်ခုရခဲ့ရင် CPU ကို ပြန်သွားဖို့ မမေ့ပါနဲ့။ CUDA errors တွေအကြောင်း ပြောရရင်၊ အရင်က ကျွန်တော်တို့ special case တစ်ခုကို ပြောခဲ့ပါတယ်။ အခု ဒါကို ကြည့်ရအောင်။ + +### CUDA Out-of-Memory Errors များကို ကိုင်တွယ်ဖြေရှင်းခြင်း[[dealing-with-cuda-out-of-memory-errors]] + +`RuntimeError: CUDA out of memory` နဲ့ စတင်တဲ့ error message တစ်ခုခု ရတဲ့အခါ၊ ဒါက သင့် GPU memory ကုန်သွားပြီဆိုတာကို ညွှန်ပြပါတယ်။ ဒါက သင့် code နဲ့ တိုက်ရိုက်ဆက်စပ်တာ မဟုတ်ဘဲ၊ ကောင်းကောင်း run နိုင်တဲ့ script တစ်ခုမှာလည်း ဖြစ်နိုင်ပါတယ်။ ဒီ error က သင့် GPU ရဲ့ internal memory ထဲကို ပစ္စည်းအများကြီး ထည့်ဖို့ ကြိုးစားခဲ့ပြီး၊ ဒါက error ဖြစ်ပေါ်လာတယ်လို့ ဆိုလိုပါတယ်။ တခြား CUDA errors တွေလိုပဲ၊ သင့် training ကို ပြန် run နိုင်ဖို့ သင့် kernel ကို restart လုပ်ဖို့ လိုအပ်ပါလိမ့်မယ်။ + +ဒီပြဿနာကို ဖြေရှင်းဖို့အတွက်၊ သင် GPU space နည်းနည်းပဲ အသုံးပြုဖို့ လိုအပ်ပါတယ် — ဒါက ပြောရတာထက် လုပ်ရတာ ပိုခက်ပါတယ်။ ပထမဆုံး၊ သင် GPU ပေါ်မှာ models နှစ်ခုကို တစ်ပြိုင်နက်တည်း မထားရှိဘူးဆိုတာ သေချာပါစေ (သင့်ပြဿနာအတွက် မလိုအပ်ဘူးဆိုရင်ပေါ့)။ ပြီးရင်၊ သင့် batch size ကို လျှော့ချသင့်ပါတယ်၊ ဘာလို့လဲဆိုတော့ ဒါက model ရဲ့ ကြားခံ outputs တွေအားလုံးရဲ့ sizes နဲ့ ၎င်းတို့ရဲ့ gradients တွေကို တိုက်ရိုက်သက်ရောက်မှုရှိလို့ပါပဲ။ ပြဿနာဆက်ရှိနေသေးရင်၊ သင့် model ရဲ့ သေးငယ်တဲ့ version တစ်ခုကို အသုံးပြုဖို့ စဉ်းစားပါ။ + +> [!TIP] +> သင်တန်းရဲ့ နောက်အပိုင်းမှာ၊ သင့်ရဲ့ memory footprint ကို လျှော့ချနိုင်ပြီး အကြီးဆုံး models တွေကို fine-tune လုပ်နိုင်စေမယ့် ပိုမိုအဆင့်မြင့်တဲ့ နည်းလမ်းတွေကို ကျွန်တော်တို့ လေ့လာသွားမှာပါ။ + +### Model ကို Evaluation လုပ်ခြင်း[[evaluating-the-model]] + +အခုဆိုရင် ကျွန်တော်တို့ code ထဲက ပြဿနာအားလုံးကို ဖြေရှင်းခဲ့ပြီဆိုတော့၊ အရာအားလုံး ပြီးပြည့်စုံပြီး training က ချောချောမွေ့မွေ့ run သွားသင့်တယ်၊ မှန်တယ်မလား? မြန်မြန်ဆန်ဆန် မဟုတ်သေးပါဘူး! သင် `trainer.train()` command ကို run ရင်၊ အရာအားလုံးက ပထမတော့ ကောင်းကောင်း ကြည့်ကောင်းနေပါလိမ့်မယ်၊ ဒါပေမယ့် ခဏအကြာမှာ အောက်ပါအတိုင်း ရပါလိမ့်မယ်။ + +```py +# This will take a long time and error out, so you shouldn't run this cell +trainer.train() +``` + +```python out +TypeError: only size-1 arrays can be converted to Python scalars +``` + +ဒီ error က evaluation phase မှာ ပေါ်လာတာကို သင်သိပါလိမ့်မယ်၊ ဒါကြောင့် ဒါက ကျွန်တော်တို့ debug လုပ်ရမယ့် နောက်ဆုံးအရာပါပဲ။ + +training နဲ့ သီးခြားစီ `Trainer` ရဲ့ evaluation loop ကို အခုလို run နိုင်ပါတယ်။ + +```py +trainer.evaluate() +``` + +```python out +TypeError: only size-1 arrays can be converted to Python scalars +``` + +> [!TIP] +> 💡 error ကြုံတွေ့ရပြီး compute resources အများကြီး မကုန်ခင်မှာ `trainer.evaluate()` ကို run နိုင်ကြောင်း အမြဲတမ်း သေချာအောင် လုပ်သင့်ပါတယ်။ + +evaluation loop မှာ ပြဿနာတစ်ခုကို debug လုပ်ဖို့ ကြိုးစားမယ့်အစား၊ သင်ဟာ data ကို ကြည့်ပြီးပြီ၊ batch တစ်ခုကို မှန်ကန်စွာ ဖန်တီးနိုင်ပြီ၊ ပြီးတော့ သင့် model ကို ဒါပေါ်မှာ run နိုင်ပြီဆိုတာကို အရင်ဆုံး သေချာအောင် လုပ်သင့်ပါတယ်။ ကျွန်တော်တို့ အဲဒီအဆင့်အားလုံးကို ပြီးဆုံးခဲ့ပြီဖြစ်လို့၊ အောက်ပါ code ကို error မရှိဘဲ run နိုင်ပါတယ်။ + +```py +for batch in trainer.get_eval_dataloader(): + break + +batch = {k: v.to(device) for k, v in batch.items()} + +with torch.no_grad(): + outputs = trainer.model(**batch) +``` + +error က နောက်ပိုင်း၊ evaluation phase အဆုံးမှာ ပေါ်လာတာဖြစ်ပြီး၊ traceback ကို ကြည့်လိုက်ရင် ဒါကို တွေ့ရပါတယ်။ + +```python trace +~/git/datasets/src/datasets/metric.py in add_batch(self, predictions, references) + 431 """ + 432 batch = {"predictions": predictions, "references": references} +--> 433 batch = self.info.features.encode_batch(batch) + 434 if self.writer is None: + 435 self._init_writer() +``` + +ဒါက error က `datasets/metric.py` module ကနေ ပေါက်ဖွားလာတယ်လို့ ကျွန်တော်တို့ကို ပြောပါတယ် — ဒါကြောင့် ဒါက ကျွန်တော်တို့ရဲ့ `compute_metrics()` function နဲ့ ပတ်သက်တဲ့ ပြဿနာပါ။ ဒါက logits နဲ့ labels တွေကို NumPy arrays အဖြစ် tuple တစ်ခုနဲ့ ယူပါတယ်၊ ဒါကြောင့် ဒါကို ပေးပို့ကြည့်ရအောင်။ + +```py +predictions = outputs.logits.cpu().numpy() +labels = batch["labels"].cpu().numpy() + +compute_metrics((predictions, labels)) +``` + +```python out +TypeError: only size-1 arrays can be converted to Python scalars +``` + +ကျွန်တော်တို့ error တူတူ ရရှိပါတယ်၊ ဒါကြောင့် ပြဿနာက အဲဒီ function မှာ အမှန်တကယ် ရှိနေပါတယ်။ ကျွန်တော်တို့ရဲ့ code ကို ပြန်ကြည့်လိုက်ရင်၊ ဒါက `predictions` နဲ့ `labels` တွေကို `metric.compute()` ကိုပဲ forwarding လုပ်နေတာကို တွေ့ရပါတယ်။ ဒါဆို အဲဒီ method မှာ ပြဿနာရှိလား? တကယ်တော့ မရှိပါဘူး။ shapes တွေကို မြန်မြန်လေး ကြည့်ရအောင်။ + +```py +predictions.shape, labels.shape +``` + +```python out +((8, 3), (8,)) +``` + +ကျွန်တော်တို့ရဲ့ predictions တွေက logit တွေပဲ ရှိပါသေးတယ်၊ အမှန်တကယ် predictions တွေ မဟုတ်သေးပါဘူး။ ဒါကြောင့် metric က ဒီ (အနည်းငယ် မရှင်းလင်းတဲ့) error ကို ပြန်ပေးတာပါ။ ပြင်ဆင်တာက အတော်လေး လွယ်ပါတယ်၊ ကျွန်တော်တို့ `compute_metrics()` function ထဲမှာ argmax တစ်ခု ထည့်လိုက်ရုံပါပဲ။ + +```py +import numpy as np + + +def compute_metrics(eval_pred): + predictions, labels = eval_pred + predictions = np.argmax(predictions, axis=1) + return metric.compute(predictions=predictions, references=labels) + + +compute_metrics((predictions, labels)) +``` + +```python out +{'accuracy': 0.625} +``` + +အခု ကျွန်တော်တို့ရဲ့ error ပြင်ဆင်ပြီးပါပြီ! ဒါက နောက်ဆုံးတစ်ခုပါ၊ ဒါကြောင့် ကျွန်တော်တို့ရဲ့ script က model တစ်ခုကို မှန်ကန်စွာ train လုပ်ပါလိမ့်မယ်။ + +ရည်ညွှန်းချက်အနေနဲ့၊ ဒီနေရာမှာ လုံးဝပြင်ဆင်ပြီးသား script ပါ။ + +```py +import numpy as np +from datasets import load_dataset +import evaluate +from transformers import ( + AutoTokenizer, + AutoModelForSequenceClassification, + DataCollatorWithPadding, + TrainingArguments, + Trainer, +) + +raw_datasets = load_dataset("glue", "mnli") + +model_checkpoint = "distilbert-base-uncased" +tokenizer = AutoTokenizer.from_pretrained(model_checkpoint) + + +def preprocess_function(examples): + return tokenizer(examples["premise"], examples["hypothesis"], truncation=True) + + +tokenized_datasets = raw_datasets.map(preprocess_function, batched=True) +model = AutoModelForSequenceClassification.from_pretrained(model_checkpoint, num_labels=3) + +args = TrainingArguments( + f"distilbert-finetuned-mnli", + evaluation_strategy="epoch", + save_strategy="epoch", + learning_rate=2e-5, + num_train_epochs=3, + weight_decay=0.01, +) + +metric = evaluate.load("glue", "mnli") + + +def compute_metrics(eval_pred): + predictions, labels = eval_pred + predictions = np.argmax(predictions, axis=1) + return metric.compute(predictions=predictions, references=labels) + + +data_collator = DataCollatorWithPadding(tokenizer=tokenizer) + +trainer = Trainer( + model, + args, + train_dataset=tokenized_datasets["train"], + eval_dataset=tokenized_datasets["validation_matched"], + compute_metrics=compute_metrics, + data_collator=data_collator, + tokenizer=tokenizer, +) +trainer.train() +``` + +ဒီကိစ္စမှာ၊ ပြဿနာတွေ နောက်ထပ်မရှိတော့ပါဘူး၊ ကျွန်တော်တို့ရဲ့ script က ကျိုးကြောင်းဆီလျော်တဲ့ ရလဒ်တွေပေးသင့်တဲ့ model တစ်ခုကို fine-tune လုပ်ပါလိမ့်မယ်။ ဒါပေမယ့် training က error တစ်ခုမှမရှိဘဲ ပြီးသွားပြီး၊ train လုပ်ထားတဲ့ model က လုံးဝစွမ်းဆောင်ရည်မကောင်းဘူးဆိုရင် ဘာလုပ်နိုင်မလဲ။ ဒါက machine learning ရဲ့ အခက်ခဲဆုံးအပိုင်းပါပဲ၊ ပြီးတော့ အကူအညီဖြစ်စေနိုင်မယ့် နည်းလမ်းအချို့ကို ကျွန်တော်တို့ ပြသပေးပါမယ်။ + +> [!TIP] +> 💡 သင် manual training loop ကို အသုံးပြုနေတယ်ဆိုရင်၊ တူညီတဲ့အဆင့်တွေက သင့် training pipeline ကို debug လုပ်ဖို့ သက်ဆိုင်ပါတယ်၊ ဒါပေမယ့် ဒါတွေကို ခွဲခြားရတာ ပိုလွယ်ပါတယ်။ သင့် `model.eval()` ဒါမှမဟုတ် `model.train()` ကို မှန်ကန်တဲ့နေရာတွေမှာ ထည့်ဖို့၊ ဒါမှမဟုတ် step တစ်ခုစီမှာ `zero_grad()` ကို ထည့်ဖို့ မမေ့ပါနဲ့! + +## Training လုပ်နေစဉ် Silent Errors များကို Debug လုပ်ခြင်း[[debugging-silent-errors-during-training]] + +error မရှိဘဲ ပြီးဆုံးသွားပေမယ့် ရလဒ်ကောင်းတွေ မရတဲ့ training တစ်ခုကို debug လုပ်ဖို့ ဘာလုပ်နိုင်မလဲ။ ဒီနေရာမှာ အကြံပြုချက်အချို့ကို ကျွန်တော်တို့ ပေးပါမယ်၊ ဒါပေမယ့် ဒီလို debug လုပ်တာက machine learning ရဲ့ အခက်ခဲဆုံးအပိုင်းဖြစ်ပြီး၊ မှော်ဆန်တဲ့အဖြေ မရှိပါဘူးဆိုတာ သတိထားပါ။ + +### သင့် Data ကို စစ်ဆေးပါ (ထပ်မံပြီး!) [[check-your-data-again]] + +သင့် data ကနေ တစ်ခုခု သင်ယူဖို့ တကယ်ဖြစ်နိုင်မှသာ သင့် model က တစ်ခုခု သင်ယူပါလိမ့်မယ်။ data ကို ပျက်စီးစေတဲ့ bug တစ်ခုရှိရင် ဒါမှမဟုတ် labels တွေကို ကျပန်းပေးထားရင်၊ သင့် dataset ပေါ်မှာ model training တစ်ခုမှ ရမှာမဟုတ်ပါဘူး။ ဒါကြောင့် သင့် decoded inputs နဲ့ labels တွေကို အမြဲတမ်း နှစ်ခါစစ်ဆေးပြီး အောက်ပါမေးခွန်းတွေကို သင့်ကိုယ်သင် မေးပါ။ + +- decoded data က နားလည်နိုင်လား။ +- labels တွေနဲ့ သင်သဘောတူလား။ +- တခြား labels တွေထက် ပိုအဖြစ်များတဲ့ label တစ်ခုခု ရှိလား။ +- model က random answer/အမြဲတမ်း အဖြေတူတူကို ခန့်မှန်းရင် loss/metric က ဘာဖြစ်သင့်လဲ။ + +> [!WARNING] +> ⚠️ သင် distributed training လုပ်နေတယ်ဆိုရင်၊ process တစ်ခုစီမှာ သင့် dataset ရဲ့ samples တွေကို print ထုတ်ပြီး တူညီတဲ့အရာ ရမရ သုံးခါစစ်ဆေးပါ။ common bug တစ်ခုကတော့ data creation မှာ randomness source အချို့ရှိတာကြောင့် process တစ်ခုစီမှာ dataset ရဲ့ version မတူတာပါပဲ။ + +သင့် data ကို ကြည့်ပြီးနောက်၊ model ရဲ့ predictions အချို့ကို ဖြတ်သန်းပြီး ၎င်းတို့ကိုပါ decode လုပ်ပါ။ model က အမြဲတမ်း အဖြေတူတူကို ခန့်မှန်းနေတယ်ဆိုရင်၊ ဒါက သင့် dataset က category တစ်ခုဆီ ဘက်လိုက်နေလို့ (classification problem တွေအတွက်) ဖြစ်နိုင်ပါတယ်။ rare classes တွေကို oversampling လုပ်တာလို နည်းလမ်းတွေက အကူအညီဖြစ်နိုင်ပါတယ်။ + +သင့် initial model မှာ ရရှိတဲ့ loss/metric က random predictions တွေအတွက် မျှော်လင့်ထားတဲ့ loss/metric နဲ့ အလွန်ကွာခြားနေတယ်ဆိုရင်၊ သင့် loss သို့မဟုတ် metric ကို တွက်ချက်ပုံကို နှစ်ခါစစ်ဆေးပါ၊ ဘာလို့လဲဆိုတော့ အဲဒီမှာ bug ရှိနိုင်လို့ပါပဲ။ သင်နောက်ဆုံးမှာ ပေါင်းထည့်တဲ့ losses များစွာကို အသုံးပြုနေတယ်ဆိုရင်၊ ၎င်းတို့က scale တူညီကြောင်း သေချာပါစေ။ + +သင့် data က ပြီးပြည့်စုံကြောင်း သေချာပြီဆိုတာနဲ့၊ model က ဒါပေါ်မှာ train လုပ်နိုင်လားဆိုတာကို ရိုးရှင်းတဲ့ test တစ်ခုနဲ့ စစ်ဆေးနိုင်ပါတယ်။ + +### Model ကို Batch တစ်ခုတည်းပေါ်မှာ Overfit လုပ်ခြင်း[[overfit-your-model-on-one-batch]] + +Overfitting က training လုပ်တဲ့အခါ ကျွန်တော်တို့ ရှောင်ရှားဖို့ ကြိုးစားလေ့ရှိတဲ့ အရာတစ်ခုပါ၊ ဘာလို့လဲဆိုတော့ ဒါက model က ကျွန်တော်တို့ လိုချင်တဲ့ general features တွေကို အသိအမှတ်ပြုဖို့ သင်ယူတာမဟုတ်ဘဲ training samples တွေကိုပဲ အလွတ်ကျက်နေတာကို ဆိုလိုလို့ပါပဲ။ သို့သော်လည်း၊ သင့် model ကို batch တစ်ခုတည်းပေါ်မှာ အကြိမ်ကြိမ် train လုပ်ဖို့ ကြိုးစားတာက၊ သင်ဖန်တီးထားတဲ့ ပြဿနာကို သင် train လုပ်ဖို့ ကြိုးစားနေတဲ့ model က ဖြေရှင်းနိုင်လားဆိုတာ စစ်ဆေးဖို့ ကောင်းတဲ့ test တစ်ခုပါ။ ဒါက သင့် initial learning rate က မြင့်မားလွန်းလားဆိုတာကိုလည်း မြင်အောင် ကူညီပေးပါလိမ့်မယ်။ + +`Trainer` ကို သတ်မှတ်ပြီးတာနဲ့ ဒါကို လုပ်ဆောင်ရတာ အလွန်လွယ်ကူပါတယ်၊ training data batch တစ်ခုကို ယူပြီး၊ အဲဒီ batch တစ်ခုတည်းကိုပဲ 20 steps လောက်အတွက် manual training loop သေးသေးလေးတစ်ခု run ပါ။ + +```py +for batch in trainer.get_train_dataloader(): + break + +batch = {k: v.to(device) for k, v in batch.items()} +trainer.create_optimizer() + +for _ in range(20): + outputs = trainer.model(**batch) + loss = outputs.loss + loss.backward() + trainer.optimizer.step() + trainer.optimizer.zero_grad() +``` + +> [!TIP] +> 💡 သင့် training data က မညီမျှဘူးဆိုရင်၊ labels အားလုံးပါဝင်တဲ့ training data batch တစ်ခုကို တည်ဆောက်ဖို့ သေချာပါစေ။ + +ရရှိလာတဲ့ model က တူညီတဲ့ `batch` ပေါ်မှာ perfect နီးပါး ရလဒ်တွေ ရရှိသင့်ပါတယ်။ ရရှိလာတဲ့ predictions တွေပေါ်မှာ metric ကို တွက်ချက်ကြည့်ရအောင်။ + +```py +with torch.no_grad(): + outputs = trainer.model(**batch) +preds = outputs.logits +labels = batch["labels"] + +compute_metrics((preds.cpu().numpy(), labels.cpu().numpy())) +``` + +```python out +{'accuracy': 1.0} +``` + +100% accuracy၊ ဒါက overfitting ရဲ့ ကောင်းမွန်တဲ့ ဥပမာတစ်ခုပါပဲ (ဆိုလိုတာက သင်ရဲ့ model ကို တခြားစာကြောင်းတစ်ခုခုနဲ့ စမ်းကြည့်ရင်၊ ဒါက မှားယွင်းတဲ့ အဖြေကို ပေးနိုင်ခြေများပါတယ်)! + +သင်ဒီလို perfect ရလဒ်တွေရဖို့ သင့် model ကို မလုပ်ဆောင်နိုင်ဘူးဆိုရင်၊ ဒါက သင်ပြဿနာကို ဖန်တီးထားပုံ ဒါမှမဟုတ် သင့် data မှာ တစ်ခုခု မှားယွင်းနေတယ်လို့ ဆိုလိုတာကြောင့်၊ ဒါကို ပြင်ဆင်သင့်ပါတယ်။ overfitting test ကို အောင်မြင်စွာ ဖြတ်သန်းနိုင်မှသာ သင့် model က တကယ်တစ်ခုခု သင်ယူနိုင်တယ်ဆိုတာ သေချာနိုင်ပါတယ်။ + +> [!WARNING] +> ⚠️ ဒီ test ပြီးနောက် သင့် model နဲ့ `Trainer` ကို ပြန်လည်ဖန်တီးရပါလိမ့်မယ်၊ ဘာလို့လဲဆိုတော့ ရရှိတဲ့ model က သင့် full dataset ပေါ်မှာ အသုံးဝင်တဲ့အရာတစ်ခုကို ပြန်လည်သင်ယူနိုင်တော့မှာ မဟုတ်လို့ပါပဲ။ + +### ပထမဆုံး Baseline တစ်ခုရသည်အထိ ဘာမှ မညှိပါနှင့်[[dont-tune-anything-until-you-have-a-first-baseline]] + +Hyperparameter tuning ကို machine learning ရဲ့ အခက်ခဲဆုံးအပိုင်းအဖြစ် အမြဲတမ်း အလေးပေးပြောဆိုလေ့ရှိပေမယ့်၊ ဒါက metric မှာ နည်းနည်းလေးသာ အကျိုးကျေးဇူးရရှိစေမယ့် နောက်ဆုံးအဆင့်ပါပဲ။ အချိန်အများစုမှာ၊ `Trainer` ရဲ့ default hyperparameters တွေက ကောင်းမွန်တဲ့ ရလဒ်တွေပေးဖို့ အဆင်ပြေမှာဖြစ်တာကြောင့်၊ သင့် dataset ပေါ်မှာရှိတဲ့ baseline ကို အနိုင်ယူနိုင်တဲ့အရာတစ်ခု မရမချင်း၊ အချိန်ကုန်ပြီး ကုန်ကျစရိတ်များတဲ့ hyperparameter search ကို မစတင်ပါနဲ့။ + +ကောင်းမွန်တဲ့ model တစ်ခုရပြီဆိုတာနဲ့၊ နည်းနည်းချင်း စတင်ညှိနှိုင်းနိုင်ပါပြီ။ မတူညီတဲ့ hyperparameters တွေနဲ့ run တွေ အများကြီး မစတင်ပါနဲ့၊ ဒါပေမယ့် hyperparameter တစ်ခုအတွက် မတူညီတဲ့ values တွေနဲ့ run အနည်းငယ်ကို နှိုင်းယှဉ်ပြီး ဘယ်ဟာက အကြီးမားဆုံး သက်ရောက်မှုရှိလဲဆိုတာ စိတ်ကူးရယူပါ။ + +သင် model ကိုယ်တိုင်ကို ညှိနှိုင်းနေတယ်ဆိုရင်၊ ရိုးရှင်းအောင်ထားပြီး ကျိုးကြောင်းဆီလျော်အောင် ရှင်းပြလို့မရတဲ့ အရာတစ်ခုခုကို မစမ်းသပ်ပါနဲ့။ သင့်ပြောင်းလဲမှုက မရည်ရွယ်ဘဲ အကျိုးဆက်တွေ မဖြစ်စေဘူးဆိုတာကို စစ်ဆေးဖို့ overfitting test ကို အမြဲတမ်း ပြန်သွားဖို့ သေချာပါစေ။ + +### အကူအညီတောင်းပါ[[ask-for-help]] + +မျှော်လင့်တာကတော့ ဒီအပိုင်းမှာ သင့်ပြဿနာကို ဖြေရှင်းဖို့ ကူညီပေးမယ့် အကြံပြုချက်အချို့ကို သင်တွေ့ရှိခဲ့ပါပြီ။ ဒါပေမယ့် မဟုတ်ဘူးဆိုရင်၊ [forums](https://discuss.huggingface.co/) မှာ community ကို အမြဲတမ်း အကူအညီတောင်းနိုင်တယ်ဆိုတာ သတိရပါ။ + +ဒီနေရာမှာ အထောက်အကူဖြစ်နိုင်မယ့် နောက်ထပ် အရင်းအမြစ်အချို့ပါ- + +- Joel Grus ရဲ့ "Reproducibility as a vehicle for engineering best practices" ([https://docs.google.com/presentation/d/1yHLPvPhUs2KGI5ZWo0sU-PKU3GimAk3iTsI38Z-B5Gw/edit#slide=id.p](https://docs.google.com/presentation/d/1yHLPvPhUs2KGI5ZWo0sU-PKU3GimAk3iTsI38Z-B5Gw/edit#slide=id.p)) +- Cecelia Shao ရဲ့ "Checklist for debugging neural networks" ([https://towardsdatascience.com/checklist-for-debugging-neural-networks-d8b2a9434f21](https://towardsdatascience.com/checklist-for-debugging-neural-networks-d8b2a9434f21)) +- Chase Roberts ရဲ့ "How to unit test machine learning code" ([https://medium.com/@keeper6928/how-to-unit-test-machine-learning-code-57cf6fd81765](https://medium.com/@keeper6928/how-to-unit-test-machine-learning-code-57cf6fd81765)) +- Andrej Karpathy ရဲ့ "A Recipe for Training Neural Networks" ([http://karpathy.github.io/2019/04/25/recipe/](http://karpathy.github.io/2019/04/25/recipe/)) + +ဟုတ်ပါတယ်၊ neural nets တွေကို train လုပ်တဲ့အခါ သင်ကြုံတွေ့ရတဲ့ ပြဿနာတိုင်းက သင့်အမှားမဟုတ်ပါဘူး! 🤗 Transformers ဒါမှမဟုတ် 🤗 Datasets library ထဲမှာ တစ်ခုခု မမှန်ဘူးလို့ ထင်ရတာ ကြုံတွေ့ရရင်၊ သင် bug တစ်ခုနဲ့ ကြုံတွေ့ရတာ ဖြစ်နိုင်ပါတယ်။ ဒါကို ကျွန်တော်တို့ကို အသေးစိတ် ပြောပြသင့်ပါတယ်၊ ပြီးတော့ နောက်အပိုင်းမှာ ဒါကို ဘယ်လိုလုပ်ရမယ်ဆိုတာကို အတိအကျ ရှင်းပြပါမယ်။ + +## ဝေါဟာရ ရှင်းလင်းချက် (Glossary) + +* **Training Pipeline**: Machine Learning မော်ဒယ်တစ်ခုကို data preprocessing မှစ၍ model training, evaluation အထိ ပါဝင်သော အဆင့်များစွာရှိသည့် လုပ်ငန်းစဉ်။ +* **Debug**: ကွန်ပျူတာပရိုဂရမ်တစ်ခုရှိ အမှားများ (bugs) ကို ရှာဖွေ၊ ဖော်ထုတ်ပြီး ပြင်ဆင်ခြင်း။ +* **Fine-tune**: ကြိုတင်လေ့ကျင့်ထားပြီးသား (pre-trained) မော်ဒယ်တစ်ခုကို သီးခြားလုပ်ငန်းတစ်ခု (specific task) အတွက် အနည်းငယ်သော ဒေတာနဲ့ ထပ်မံလေ့ကျင့်ပေးခြင်းကို ဆိုလိုပါတယ်။ +* **Model**: Artificial Intelligence (AI) နယ်ပယ်တွင် အချက်အလက်များကို လေ့လာပြီး ခန့်မှန်းချက်များ ပြုလုပ်ရန် ဒီဇိုင်းထုတ်ထားသော သင်္ချာဆိုင်ရာဖွဲ့စည်းပုံများ။ +* **Task**: Artificial Intelligence (AI) သို့မဟုတ် Machine Learning (ML) မော်ဒယ်တစ်ခုက လုပ်ဆောင်ရန် ဒီဇိုင်းထုတ်ထားသော သီးခြားအလုပ်။ +* **`trainer.train()` Command**: Hugging Face Transformers library ၏ `Trainer` class မှ model ကို လေ့ကျင့်ရန်အတွက် အသုံးပြုသော method။ +* **Error**: ပရိုဂရမ်တစ်ခု အလုပ်လုပ်နေစဉ် ဖြစ်ပေါ်လာသော ပြဿနာတစ်ခုကြောင့် ၎င်းသည် ပုံမှန်အတိုင်း ဆက်လက်လုပ်ဆောင်နိုင်ခြင်းမရှိခြင်း။ +* **Crappy (Model)**: စွမ်းဆောင်ရည် နိမ့်ကျသော သို့မဟုတ် အသုံးမဝင်သော model။ +* **Datasets**: Hugging Face က ထုတ်လုပ်ထားတဲ့ library တစ်ခုဖြစ်ပြီး AI မော်ဒယ်တွေ လေ့ကျင့်ဖို့အတွက် ဒေတာအစုအဝေး (datasets) တွေကို လွယ်လွယ်ကူကူ ဝင်ရောက်ရယူ၊ စီမံခန့်ခွဲပြီး အသုံးပြုနိုင်စေပါတယ်။ +* **Dataloaders**: dataset ကနေ data တွေကို batch အလိုက် load လုပ်ပေးတဲ့ PyTorch utility class (သို့မဟုတ် TensorFlow မှာ ဆင်တူ)။ +* **Batch**: မတူညီသော input များစွာကို တစ်ပြိုင်နက်တည်း လုပ်ဆောင်နိုင်ရန် အုပ်စုဖွဲ့ခြင်း။ +* **Model Code**: model ကို တည်ဆောက်ပြီး အကောင်အထည်ဖော်ရန် ရေးသားထားသော code။ +* **Gradients**: neural network ၏ weights များကို loss function ကို အနည်းဆုံးဖြစ်အောင် ချိန်ညှိရန်အတွက် လမ်းညွှန်ပေးသော တန်ဖိုးများ။ +* **Optimization Step**: gradients များကို အသုံးပြုပြီး model ၏ parameters များကို update လုပ်ခြင်း။ +* **Optimizer**: model ၏ weights များကို training လုပ်နေစဉ် ချိန်ညှိပေးသော algorithm (ဥပမာ- AdamW, SGD)။ +* **Evaluation**: Model ၏ စွမ်းဆောင်ရည်ကို တိုင်းတာခြင်း။ +* **Metric**: Model ၏ စွမ်းဆောင်ရည်ကို တိုင်းတာရန် အသုံးပြုသော တန်ဖိုးများ (ဥပမာ- accuracy, F1 score)။ +* **MNLI Dataset (Multi-Genre Natural Language Inference)**: GLUE benchmark ထဲက text entailment task တစ်ခု။ +* **DistilBERT Model**: BERT model ၏ ပိုမိုသေးငယ်ပြီး မြန်ဆန်သော version။ +* **`load_dataset()` Function**: Hugging Face Datasets library မှ dataset များကို download လုပ်ပြီး cache လုပ်ရန် အသုံးပြုသော function။ +* **`evaluate` Library**: Hugging Face မှ metrics များကို load လုပ်ပြီး တွက်ချက်ရန်အတွက် library။ +* **`AutoTokenizer`**: Hugging Face Transformers library မှာ ပါဝင်တဲ့ class တစ်ခုဖြစ်ပြီး မော်ဒယ်အမည်ကို အသုံးပြုပြီး သက်ဆိုင်ရာ tokenizer ကို အလိုအလျောက် load လုပ်ပေးသည်။ +* **`AutoModelForSequenceClassification`**: Hugging Face Transformers library မှာ ပါဝင်တဲ့ class တစ်ခုဖြစ်ပြီး sequence classification task အတွက် model ကို အလိုအလျောက် load လုပ်ပေးသည်။ +* **`TrainingArguments`**: Hugging Face Transformers library မှ `Trainer` အတွက် training arguments များကို သတ်မှတ်ရန် အသုံးပြုသော class။ +* **`Trainer`**: Hugging Face Transformers library မှ model များကို ထိရောက်စွာ လေ့ကျင့်ရန်အတွက် ဒီဇိုင်းထုတ်ထားသော မြင့်မားသောအဆင့် API။ +* **`raw_datasets`**: Preprocessing မလုပ်ရသေးသော dataset။ +* **`model_checkpoint`**: pretrained model ၏ အမည် သို့မဟုတ် path။ +* **`preprocess_function()`**: data ကို preprocessing လုပ်ရန်အတွက် function။ +* **`premise`**: MNLI dataset တွင် ပထမဆုံး စာကြောင်း။ +* **`hypothesis`**: MNLI dataset တွင် ဒုတိယ စာကြောင်း။ +* **`truncation=True`**: input sequence များကို model ၏ maximum length အထိ ဖြတ်တောက်ရန် သတ်မှတ်ခြင်း။ +* **`tokenized_datasets`**: Tokenizer ဖြင့် preprocessing လုပ်ထားသော dataset။ +* **`Dataset.map()` Method**: 🤗 Datasets library မှာ ပါဝင်တဲ့ method တစ်ခုဖြစ်ပြီး dataset ရဲ့ element တစ်ခုစီ ဒါမှမဟုတ် batch တစ်ခုစီပေါ်မှာ function တစ်ခုကို အသုံးပြုနိုင်စေသည်။ +* **`batched=True`**: `map()` method မှာ အသုံးပြုသော argument တစ်ခုဖြစ်ပြီး function ကို dataset ရဲ့ element အများအပြားပေါ်မှာ တစ်ပြိုင်နက်တည်း အသုံးပြုစေသည်။ +* **`evaluation_strategy="epoch"`**: evaluation ကို epoch တစ်ခုစီတိုင်းမှာ လုပ်ဆောင်ရန် သတ်မှတ်ခြင်း။ +* **`save_strategy="epoch"`**: model ကို epoch တစ်ခုစီတိုင်းမှာ save လုပ်ရန် သတ်မှတ်ခြင်း။ +* **`learning_rate`**: training လုပ်ငန်းစဉ်အတွင်း model ၏ weights များကို မည်မျှပြောင်းလဲရမည်ကို ထိန်းချုပ်သော parameter။ +* **`num_train_epochs`**: model ကို training dataset တစ်ခုလုံးဖြင့် လေ့ကျင့်သည့် အကြိမ်အရေအတွက်။ +* **`weight_decay`**: overfitting ကို လျှော့ချရန်အတွက် regularization technique တစ်မျိုး။ +* **`metric.load()`**: `evaluate` library မှ metric တစ်ခုကို load လုပ်ရန် function။ +* **`compute_metrics()` Function**: evaluation အတွက် metrics များကို တွက်ချက်သော function။ +* **`eval_pred`**: evaluation လုပ်နေစဉ် model မှ ထုတ်ပေးသော predictions နှင့် labels များပါဝင်သော tuple။ +* **`predictions`**: model မှ ထုတ်ပေးသော ခန့်မှန်းချက်များ။ +* **`references`**: အမှန်တကယ် labels များ။ +* **`raw_datasets["train"]`**: preprocessing မလုပ်ရသေးသော training set။ +* **`tokenized_datasets["train"]`**: preprocessing လုပ်ထားသော training set။ +* **`tokenized_datasets["validation_matched"]`**: preprocessing လုပ်ထားသော validation set။ +* **`ValueError`**: Python တွင် value သည် မှန်ကန်ခြင်းမရှိသည့်အခါ ဖြစ်ပေါ်သော error။ +* **`input_ids`**: Tokenizer မှ ထုတ်ပေးသော tokens တစ်ခုစီ၏ ထူးခြားသော ဂဏန်းဆိုင်ရာ ID များ။ +* **`inputs_embeds`**: input tokens များ၏ embeddings များကို တိုက်ရိုက်ပေးပို့ခြင်း။ +* **Corrupted Data**: ပျက်စီးနေသော သို့မဟုတ် မမှန်ကန်သော ဒေတာ။ +* **Model Signature**: model တစ်ခုက မျှော်လင့်ထားသော input arguments များ။ +* **Labels**: AI model ကို လေ့ကျင့်ရန်အတွက် အသုံးပြုသော မှန်ကန်သော အဖြေများ သို့မဟုတ် အမျိုးအစားများ။ +* **`Dataset.map()` Method**: 🤗 Datasets library မှာ ပါဝင်တဲ့ method တစ်ခုဖြစ်ပြီး dataset ရဲ့ element တစ်ခုစီ ဒါမှမဟုတ် batch တစ်ခုစီပေါ်မှာ function တစ်ခုကို အသုံးပြုနိုင်စေသည်။ +* **Traceback**: error တစ်ခု ဖြစ်ပေါ်လာသည့်အခါ code execution path ကို ပြသသော မှတ်တမ်း။ +* **Data Collation Step**: batch တစ်ခုအတွင်း samples များကို စုစည်းပေးသည့် လုပ်ငန်းစဉ်။ +* **Decoded Inputs**: model ၏ input IDs များကို လူသားဖတ်နိုင်သော စာသားအဖြစ် ပြန်ပြောင်းခြင်း။ +* **Pixels**: digital image တစ်ခု၏ အသေးငယ်ဆုံး အစိတ်အပိုင်း။ +* **Audio Samples**: digital audio တွင် အသံ၏ တန်ဖိုးများ။ +* **`tokenizer.decode()` Method**: input IDs များကို tokens များအဖြစ် ပြန်ပြောင်းပေးသော tokenizer method။ +* **`[CLS]` Token**: BERT model တွင် sequence ၏ အစကို ကိုယ်စားပြုသော special token။ +* **`[SEP]` Token**: BERT model တွင် sentence တစ်ခု၏ အဆုံး သို့မဟုတ် sentence နှစ်ခုကြား ပိုင်းခြားရန် အသုံးပြုသော special token။ +* **`attention_mask`**: မော်ဒယ်ကို အာရုံစိုက်သင့်သည့် tokens များနှင့် လျစ်လျူရှုသင့်သည့် (padding) tokens များကို ခွဲခြားပေးသည့် binary mask။ +* **Padding**: sequence များ၏ အရှည်ကို တူညီစေရန်အတွက် အပို tokens များ ထည့်သွင်းခြင်း။ +* **Token Type IDs**: Sentence pair လုပ်ငန်းများတွင် input sequence တစ်ခုစီမှ token တစ်ခုစီသည် မည်သည့် sentence (ပထမ သို့မဟုတ် ဒုတိယ) နှင့် သက်ဆိုင်သည်ကို ဖော်ပြပေးသော IDs များ။ +* **DistilBERT**: BERT model ၏ ပိုမိုသေးငယ်ပြီး မြန်ဆန်သော version။ +* **`get_train_dataloader()`**: `Trainer` မှ training dataloader ကို ရယူရန် method။ +* **`get_eval_dataloader()`**: `Trainer` မှ evaluation dataloader ကို ရယူရန် method။ +* **Collate_fn**: `DataLoader` တစ်ခုမှာ အသုံးပြုတဲ့ function တစ်ခုဖြစ်ပြီး batch တစ်ခုအတွင်း samples တွေကို စုစည်းပေးသည်။ +* **`default_data_collator`**: 🤗 Transformers library မှ default data collator။ +* **`DataCollatorWithPadding`**: Hugging Face Transformers library မှ ပံ့ပိုးပေးသော class တစ်ခုဖြစ်ပြီး dynamic padding ကို အသုံးပြု၍ batch တစ်ခုအတွင်း samples များကို စုစည်းပေးသည်။ +* **`DataCollatorWithPadding(tokenizer=tokenizer)`**: tokenizer ကို အသုံးပြု၍ dynamic padding လုပ်ဆောင်သော data collator ကို ဖန်တီးခြင်း။ +* **CUDA Error**: NVIDIA GPU များတွင် GPU computation လုပ်နေစဉ် ဖြစ်ပေါ်လာသော error။ +* **`CUBLAS_STATUS_ALLOC_FAILED`**: CUDA BLAS (Basic Linear Algebra Subprograms) မှ memory ခွဲဝေမှု (allocation) မအောင်မြင်ခြင်း။ +* **`Trainer._remove_unused_columns()`**: `Trainer` ၏ private method တစ်ခုဖြစ်ပြီး model က လက်မခံသော columns များကို dataset မှ ဖယ်ရှားရန်။ +* **`torch.stack()`**: PyTorch tensor များစွာကို dimension အသစ်တစ်ခုတွင် ပေါင်းစည်းခြင်း။ +* **`torch.tensor()`**: PyTorch မှာ data များကို သိမ်းဆည်းရန် အသုံးပြုတဲ့ multi-dimensional array (tensor) တစ်ခုကို ဖန်တီးသော function။ +* **Kernel**: operating system ၏ အဓိကအစိတ်အပိုင်း။ Jupyter/Colab တွင် code များကို run ရန်အတွက် backend process။ +* **GPU (Graphics Processing Unit)**: ဂရပ်ဖစ်လုပ်ဆောင်မှုအတွက် အထူးဒီဇိုင်းထုတ်ထားသော processor တစ်မျိုးဖြစ်သော်လည်း AI/ML လုပ်ငန်းများတွင် အရှိန်မြှင့်ရန် အသုံးများသည်။ +* **Parallel (Computing)**: လုပ်ငန်းများစွာကို တစ်ပြိုင်နက်တည်း လုပ်ဆောင်ခြင်း။ +* **Synchronization**: multiple processes များကြား ဒေတာကို တူညီအောင် ထိန်းသိမ်းခြင်း။ +* **Backward Pass**: Neural network ၏ training လုပ်ငန်းစဉ်တွင် loss function မှ gradients များကို တွက်ချက်ခြင်း။ +* **Forward Pass**: Neural network ၏ training လုပ်ငန်းစဉ်တွင် input data ကို network ကို ဖြတ်သန်းစေပြီး output ကို တွက်ချက်ခြင်း။ +* **Out-of-Memory Error (OOM)**: စက်၏ memory မလုံလောက်ခြင်းကြောင့် ဖြစ်ပေါ်သော error။ +* **`trainer.model.cpu()(**batch)`**: model ကို CPU သို့ ရွှေ့ပြီး batch ပေါ်တွင် ခေါ်ဆိုခြင်း။ +* **`outputs = trainer.model.cpu()(**batch)`**: model မှ output များကို ရရှိခြင်း။ +* **`IndexError`**: Python တွင် sequence index သည် bounds ပြင်ပ ဖြစ်နေသည့်အခါ ဖြစ်ပေါ်သော error။ +* **Loss Computation**: model ၏ ခန့်မှန်းချက်များနှင့် အမှန်တကယ် labels များကြား ကွာခြားမှုကို တွက်ချက်ခြင်း။ +* **`trainer.model.config.num_labels`**: model ၏ configuration ထဲမှ labels အရေအတွက်။ +* **`DataCollatorWithPadding`**: Hugging Face Transformers library မှ ပံ့ပိုးပေးသော class တစ်ခုဖြစ်ပြီး dynamic padding ကို အသုံးပြု၍ batch တစ်ခုအတွင်း samples များကို စုစည်းပေးသည်။ +* **`trainer.model.to(device)(**batch)`**: model ကို သတ်မှတ်ထားသော device (CPU/GPU) သို့ ရွှေ့ပြီး batch ပေါ်တွင် ခေါ်ဆိုခြင်း။ +* **`torch.no_grad()`**: PyTorch တွင် gradient တွက်ချက်မှုကို ပိတ်ထားရန် (evaluation သို့မဟုတ် inference အတွက်)။ +* **`outputs.logits.cpu().numpy()`**: model output မှ logits များကို CPU သို့ ရွှေ့ပြီး NumPy array အဖြစ် ပြောင်းလဲခြင်း။ +* **`batch["labels"].cpu().numpy()`**: batch မှ labels များကို CPU သို့ ရွှေ့ပြီး NumPy array အဖြစ် ပြောင်းလဲခြင်း။ +* **`np.argmax(predictions, axis=1)`**: predictions array ၏ axis 1 (column) အလိုက် အမြင့်ဆုံးတန်ဖိုး၏ index ကို ရယူခြင်း။ +* **Accuracy**: classification model ၏ မှန်ကန်သော ခန့်မှန်းချက်များ၏ ရာခိုင်နှုန်း။ +* **Silent Errors**: error message များမပြသဘဲ ဖြစ်ပေါ်သော မှားယွင်းမှုများ။ +* **Corrupts the Data**: ဒေတာများကို ပျက်စီးစေခြင်း။ +* **Labels are Attributed Randomly**: labels များကို ကျပန်းပေးထားခြင်း။ +* **Biased toward One Category**: dataset သည် သီးခြား category တစ်ခုဆီသို့ ဘက်လိုက်နေခြင်း။ +* **Oversampling Rare Classes**: dataset ထဲရှိ ရှားပါးသော classes များကို ပိုမိုအသုံးပြုခြင်း။ +* **Loss/Metric on Initial Model**: မလေ့ကျင့်ရသေးသော model ၏ loss သို့မဟုတ် metric တန်ဖိုး။ +* **Scale (of Losses)**: losses များ၏ တန်ဖိုးအပိုင်းအခြား။ +* **Distributed Training**: training လုပ်ငန်းစဉ်ကို ကွန်ပျူတာများစွာ သို့မဟုတ် GPU များစွာဖြင့် ဖြန့်ခွဲလုပ်ဆောင်ခြင်း။ +* **Randomness**: ကျပန်းဖြစ်ခြင်း။ +* **Overfit**: Model သည် training data ကို အလွန်အကျွံ သင်ယူသွားခြင်းကြောင့် test data တွင် စွမ်းဆောင်ရည် နိမ့်ကျခြင်း။ +* **Memorizing Training Samples**: training samples များကို အလွတ်ကျက်မှတ်ခြင်း။ +* **General Features**: training data ၏ အခြေခံသဘောတရားများ။ +* **Initial Learning Rate**: training စတင်ချိန်တွင် learning rate တန်ဖိုး။ +* **`trainer.create_optimizer()`**: `Trainer` မှ optimizer ကို ဖန်တီးရန် method။ +* **`trainer.optimizer.step()`**: optimizer မှ optimization step ကို လုပ်ဆောင်ရန် method။ +* **`trainer.optimizer.zero_grad()`**: optimizer မှ gradients များကို သုညသို့ ပြန်လည်သတ်မှတ်ရန် method။ +* **Unbalanced Data**: dataset ထဲတွင် classes များ၏ samples အရေအတွက် မညီမျှခြင်း။ +* **Accuracy**: classification model ၏ မှန်ကန်သော ခန့်မှန်းချက်များ၏ ရာခိုင်နှုန်း။ +* **Hyperparameter Tuning**: model ၏ စွမ်းဆောင်ရည်ကို အကောင်းဆုံးဖြစ်အောင် hyperparameters များကို ချိန်ညှိခြင်း။ +* **Baseline**: model တစ်ခု၏ စွမ်းဆောင်ရည်ကို နှိုင်းယှဉ်ရန်အတွက် အခြေခံရည်ညွှန်းတန်ဖိုး။ +* **Hyperparameters**: model ၏ architecture သို့မဟုတ် training လုပ်ငန်းစဉ်ကို ထိန်းချုပ်သော parameters များ (ဥပမာ- learning rate, batch size)။ +* **Unintended Consequences**: မရည်ရွယ်ဘဲ ဖြစ်ပေါ်လာသော ရလဒ်များ။ +* **Forums**: အွန်လိုင်းဆွေးနွေးပွဲ ဖိုရမ်များ။ +* **Neural Networks**: deep learning တွင် အသုံးပြုသော computational model တစ်မျိုး။ +* **Unit Test**: ဆော့ဖ်ဝဲလ်တစ်ခု၏ သေးငယ်သော အစိတ်အပိုင်း (unit) တစ်ခုကို သီးခြားစီ စမ်းသပ်ခြင်း။ +* **🤗 Datasets Library**: Hugging Face က ထုတ်လုပ်ထားတဲ့ library တစ်ခုဖြစ်ပြီး AI မော်ဒယ်တွေ လေ့ကျင့်ဖို့အတွက် ဒေတာအစုအဝေး (datasets) တွေကို လွယ်လွယ်ကူကူ ဝင်ရောက်ရယူ၊ စီမံခန့်ခွဲပြီး အသုံးပြုနိုင်စေပါတယ်။ +* **Bug**: ဆော့ဖ်ဝဲလ်တစ်ခု၏ code ထဲတွင်ရှိသော အမှားတစ်ခုကြောင့် ပရိုဂရမ်သည် မျှော်လင့်ထားသည့်အတိုင်း အလုပ်မလုပ်ခြင်း။ \ No newline at end of file diff --git a/chapters/my/chapter8/4_tf.mdx b/chapters/my/chapter8/4_tf.mdx new file mode 100644 index 000000000..31551cc42 --- /dev/null +++ b/chapters/my/chapter8/4_tf.mdx @@ -0,0 +1,564 @@ + + +# Training Pipeline ကို Debugging လုပ်ခြင်း[[debugging-the-training-pipeline]] + + + +သင်ဟာ [Chapter 7](/course/chapter7) က အကြံပြုချက်တွေကို သေချာလိုက်နာပြီး သတ်မှတ်ထားတဲ့ task တစ်ခုပေါ်မှာ model တစ်ခုကို train ဒါမှမဟုတ် fine-tune လုပ်ဖို့ script တစ်ခုကို လှလှပပ ရေးသားခဲ့ပြီးပါပြီ။ ဒါပေမယ့် `model.fit()` command ကို run လိုက်တဲ့အခါ၊ ကြောက်စရာကောင်းတဲ့ အမှားတစ်ခု ဖြစ်ပေါ်လာပါတယ် 😱! ဒါမှမဟုတ် ပိုဆိုးတာက၊ အရာအားလုံး အဆင်ပြေပြီး training က အမှားမရှိဘဲ run နေပေမယ့်၊ ရရှိလာတဲ့ model က အသုံးမကျပါဘူး။ ဒီအပိုင်းမှာ၊ ဒီလိုပြဿနာမျိုးတွေကို debug လုပ်ဖို့ ဘာတွေလုပ်နိုင်လဲဆိုတာ ပြသပေးပါမယ်။ + +## Training Pipeline ကို Debugging လုပ်ခြင်း[[debugging-the-training-pipeline]] + + + +`model.fit()` မှာ error တစ်ခုကြုံတွေ့ရတဲ့ ပြဿနာကတော့ ၎င်းဟာ source များစွာကနေ လာနိုင်တာကြောင့်ပါပဲ။ ဘာလို့လဲဆိုတော့ training က အများအားဖြင့် သင်အဲဒီအချိန်အထိ လုပ်ဆောင်ခဲ့တဲ့ အရာများစွာကို စုစည်းထားလို့ပါပဲ။ ပြဿနာက သင့် dataset မှာ တစ်ခုခု မှားနေတာ ဒါမှမဟုတ် datasets ရဲ့ elements တွေကို အုပ်စုဖွဲ့ဖို့ ကြိုးစားတဲ့အခါ ပြဿနာတစ်ခုခု ဖြစ်နေတာမျိုး ဖြစ်နိုင်ပါတယ်။ ဒါမှမဟုတ် model code မှာ တစ်ခုခု မှားနေတာ ဒါမှမဟုတ် သင့် loss function ဒါမှမဟုတ် optimizer မှာ ပြဿနာရှိနေတာမျိုး ဖြစ်နိုင်ပါတယ်။ training အတွက် အရာအားလုံး အဆင်ပြေသွားရင်တောင်၊ သင့် metric မှာ ပြဿနာရှိနေရင် evaluation လုပ်နေစဉ်မှာ တစ်ခုခု မှားယွင်းသွားနိုင်ပါသေးတယ်။ + +`model.fit()` မှာ ဖြစ်ပေါ်လာတဲ့ error တစ်ခုကို debug လုပ်ဖို့ အကောင်းဆုံးနည်းလမ်းကတော့ ဒီ pipeline တစ်ခုလုံးကို ကိုယ်တိုင် ပြန်လည်စစ်ဆေးပြီး ဘယ်နေရာမှာ မှားယွင်းသွားလဲဆိုတာ ကြည့်ဖို့ပါပဲ။ အဲဒီအခါ error ကို ဖြေရှင်းရတာ အများအားဖြင့် အလွန်လွယ်ကူပါတယ်။ + +ဒါကို သရုပ်ပြဖို့အတွက်၊ [MNLI dataset](https://huggingface.co/datasets/glue) ပေါ်မှာ DistilBERT model တစ်ခုကို fine-tune လုပ်ဖို့ (ကြိုးစားနေတဲ့) အောက်ပါ script ကို ကျွန်တော်တို့ အသုံးပြုပါမယ်။ + +```py +from datasets import load_dataset +import evaluate +from transformers import ( + AutoTokenizer, + TFAutoModelForSequenceClassification, +) + +raw_datasets = load_dataset("glue", "mnli") + +model_checkpoint = "distilbert-base-uncased" +tokenizer = AutoTokenizer.from_pretrained(model_checkpoint) + + +def preprocess_function(examples): + return tokenizer(examples["premise"], examples["hypothesis"], truncation=True) + + +tokenized_datasets = raw_datasets.map(preprocess_function, batched=True) + +train_dataset = tokenized_datasets["train"].to_tf_dataset( + columns=["input_ids", "labels"], batch_size=16, shuffle=True +) + +validation_dataset = tokenized_datasets["validation_matched"].to_tf_dataset( + columns=["input_ids", "labels"], batch_size=16, shuffle=True +) + +model = TFAutoModelForSequenceClassification.from_pretrained(model_checkpoint) + +model.compile(loss="sparse_categorical_crossentropy", optimizer="adam") + +model.fit(train_dataset) +``` + +သင် ဒါကို run ဖို့ကြိုးစားရင် dataset conversion လုပ်တဲ့အခါ `VisibleDeprecationWarning`s အချို့ရနိုင်ပါတယ် — ဒါက ကျွန်တော်တို့မှာရှိတဲ့ သိထားပြီးသား UX ပြဿနာတစ်ခုဖြစ်လို့ လျစ်လျူရှုပေးပါ။ အကယ်၍ သင်ဟာ နိုဝင်ဘာ ၂၀၂၁ နောက်ပိုင်းမှာ ဒီသင်တန်းကို ဖတ်နေသေးပြီး ဒါက ဆက်ဖြစ်နေသေးတယ်ဆိုရင် @carrigmat ကို ပြင်ပေးဖို့ rage tweets တွေ ပို့ပေးပါ။ + +ဒါပေမယ့် ပိုပြီးပြင်းထန်တဲ့ ပြဿနာကတော့ ကျွန်တော်တို့ တိုက်ရိုက် error ရတာပါပဲ။ ပြီးတော့ အဲဒါက တကယ်ကို ကြောက်စရာကောင်းလောက်အောင် ရှည်လျားပါတယ်။ + +```python out +ValueError: No gradients provided for any variable: ['tf_distil_bert_for_sequence_classification/distilbert/embeddings/word_embeddings/weight:0', '...'] +``` + +ဒါဘာကို ဆိုလိုတာလဲ။ ကျွန်တော်တို့ data ပေါ်မှာ train လုပ်ဖို့ ကြိုးစားခဲ့ပေမယ့် gradient မရခဲ့ဘူးလား။ ဒါက အတော်လေး ရှုပ်ထွေးပါတယ်၊ ဒီလိုအရာတစ်ခုကို debug လုပ်ဖို့ ဘယ်လိုစတင်ရမလဲ။ သင်ရတဲ့ error က ပြဿနာဘယ်နေရာမှာလဲဆိုတာကို ချက်ချင်းမပြောပြတဲ့အခါ၊ အကောင်းဆုံးဖြေရှင်းနည်းကတော့ အရာတွေကို အဆင့်ဆင့် ပြန်လည်စစ်ဆေးပြီး၊ အဆင့်တိုင်းမှာ အရာအားလုံး မှန်ကန်နေခြင်းရှိမရှိ သေချာစေဖို့ပါပဲ။ ပြီးတော့၊ စတင်ရမယ့်နေရာကတော့ အမြဲတမ်း... + +### သင်၏ Data ကို စစ်ဆေးပါ[[check-your-data]] + +ဒါက ပြောစရာမလိုပါဘူး၊ ဒါပေမယ့် သင့် data ပျက်စီးနေတယ်ဆိုရင် Keras က သင့်အတွက် ပြင်ပေးနိုင်မှာ မဟုတ်ပါဘူး။ ဒါကြောင့် ပထမဆုံးအနေနဲ့၊ သင်ရဲ့ training set ထဲမှာ ဘာတွေပါလဲဆိုတာ ကြည့်ဖို့လိုပါတယ်။ + +`raw_datasets` နဲ့ `tokenized_datasets` ထဲကို ကြည့်ဖို့ ဆွဲဆောင်မှုရှိပေမယ့်၊ data က model ထဲကို ဝင်ရောက်မယ့်နေရာအထိ တိုက်ရိုက်သွားကြည့်ဖို့ ကျွန်တော်တို့ အထူးအကြံပြုပါတယ်။ ဒါက `to_tf_dataset()` function နဲ့ သင်ဖန်တီးထားတဲ့ `tf.data.Dataset` ကနေ output တစ်ခုကို ဖတ်တာကို ဆိုလိုပါတယ်! ဒါဆို ဘယ်လိုလုပ်ရမလဲ။ `tf.data.Dataset` objects တွေက ကျွန်တော်တို့ကို batch လိုက်ပေးပြီး indexing ကို မထောက်ပံ့ပါဘူး၊ ဒါကြောင့် `train_dataset[0]` ကို တိုက်ရိုက်တောင်းလို့ မရပါဘူး။ သို့သော်လည်း၊ batch တစ်ခုကို ယဉ်ယဉ်ကျေးကျေး တောင်းဆိုနိုင်ပါတယ်။ + +```py +for batch in train_dataset: + break +``` + +`break` က loop ကို iteration တစ်ခုအပြီးမှာ ရပ်တန့်စေတာကြောင့်၊ ဒါက `train_dataset` ကနေ ထွက်လာတဲ့ ပထမဆုံး batch ကို ယူပြီး `batch` အဖြစ် သိမ်းဆည်းပါတယ်။ အခု ဘာတွေပါလဲဆိုတာ ကြည့်ရအောင်။ + +```python out +{'attention_mask': , + 'label': , + 'input_ids': } +``` + +ဒါက မှန်တယ်မလား? ကျွန်တော်တို့ `labels`, `attention_mask` နဲ့ `input_ids` တွေကို model ကို ပေးနေတာဖြစ်ပြီး၊ ဒါတွေအားလုံးက outputs တွေကို တွက်ချက်ဖို့နဲ့ loss ကို တွက်ချက်ဖို့ လိုအပ်တဲ့အရာတွေပါ။ ဒါဆို ဘာလို့ gradient မရှိတာလဲ။ သေချာကြည့်ပါ- ကျွန်တော်တို့ input အဖြစ် dictionary တစ်ခုတည်းကို ပေးနေတာဖြစ်ပေမယ့်၊ training batch တစ်ခုဟာ ပုံမှန်အားဖြင့် input tensor ဒါမှမဟုတ် dictionary တစ်ခုအပြင် labels tensor တစ်ခုပါ ပါဝင်ပါတယ်။ ကျွန်တော်တို့ရဲ့ labels တွေက input dictionary ထဲက key တစ်ခုမျှသာ ဖြစ်နေပါတယ်။ + +ဒါက ပြဿနာလား။ အမြဲတမ်းတော့ မဟုတ်ပါဘူး! ဒါပေမယ့် ဒါက TensorFlow နဲ့ Transformer models တွေကို train လုပ်တဲ့အခါ သင်ကြုံတွေ့ရမယ့် အဖြစ်အများဆုံး ပြဿနာတွေထဲက တစ်ခုပါပဲ။ ကျွန်တော်တို့ရဲ့ models တွေအားလုံးက loss ကို အတွင်းပိုင်းမှာ တွက်ချက်နိုင်ပါတယ်၊ ဒါပေမယ့် အဲဒီလိုလုပ်ဖို့ labels တွေကို input dictionary ထဲမှာ ပေးဖို့လိုပါတယ်။ ဒါက ကျွန်တော်တို့ `compile()` ကို loss value တစ်ခု မသတ်မှတ်တဲ့အခါ အသုံးပြုတဲ့ loss ပါပဲ။ Keras ကတော့ labels တွေကို input dictionary ကနေ သီးခြားစီ ပေးဖို့ ပုံမှန်အားဖြင့် မျှော်လင့်ပါတယ်၊ ပြီးတော့ သင်အဲဒီလို မလုပ်ရင် loss computations တွေက အများအားဖြင့် အလုပ်လုပ်မှာ မဟုတ်ပါဘူး။ + +ပြဿနာက ပိုပြီး ရှင်းရှင်းလင်းလင်း ဖြစ်လာပါပြီ- ကျွန်တော်တို့ `loss` argument ကို ပေးခဲ့ပါတယ်၊ ဒါက Keras ကို ကျွန်တော်တို့အတွက် losses တွေ တွက်ချက်ခိုင်းနေတာကို ဆိုလိုပါတယ်၊ ဒါပေမယ့် labels တွေကို model ကို inputs အဖြစ် ပေးခဲ့တာဖြစ်ပြီး Keras မျှော်လင့်တဲ့နေရာမှာ labels အဖြစ် မဟုတ်ပါဘူး! ကျွန်တော်တို့ နှစ်ခုထဲက တစ်ခုကို ရွေးချယ်ဖို့လိုပါတယ်- model ရဲ့ internal loss ကို အသုံးပြုပြီး labels တွေကို ရှိရင်းစွဲနေရာမှာ ထားတာ၊ ဒါမှမဟုတ် Keras losses တွေကို ဆက်လက်အသုံးပြုပြီး labels တွေကို Keras မျှော်လင့်တဲ့နေရာကို ရွှေ့တာ။ ရိုးရှင်းစေဖို့အတွက် ပထမနည်းလမ်းကို ရွေးချယ်ကြရအောင်။ `compile()` ကို အောက်ပါအတိုင်း ပြောင်းလိုက်ပါ။ + +```py +model.compile(optimizer="adam") +``` + +အခုဆိုရင် ကျွန်တော်တို့ model ရဲ့ internal loss ကို အသုံးပြုတော့မှာဖြစ်ပြီး၊ ဒီပြဿနာက ဖြေရှင်းပြီးသား ဖြစ်သင့်ပါပြီ။ + +> [!TIP] +> ✏️ **သင့်အလှည့်!** အခြားပြဿနာတွေကို ဖြေရှင်းပြီးနောက် စိတ်ကြိုက်စိန်ခေါ်မှုတစ်ခုအနေနဲ့၊ ဒီအဆင့်ကို ပြန်လာပြီး model ကို internal loss အစား မူရင်း Keras-computed loss နဲ့ အလုပ်လုပ်အောင် ကြိုးစားနိုင်ပါတယ်။ labels တွေ မှန်ကန်စွာ output ထွက်လာစေဖို့ `to_tf_dataset()` ရဲ့ `label_cols` argument ကို `"labels"` ထည့်ဖို့ လိုအပ်ပါလိမ့်မယ်၊ ဒါက gradients တွေကို ရစေမှာပါ — ဒါပေမယ့် ကျွန်တော်တို့ သတ်မှတ်ထားတဲ့ loss မှာ နောက်ထပ်ပြဿနာတစ်ခု ရှိပါသေးတယ်။ ဒီပြဿနာနဲ့ training က ဆက် run မှာဖြစ်ပေမယ့်၊ သင်ယူမှုက အလွန်နှေးကွေးပြီး high training loss မှာ ရပ်တန့်နေပါလိမ့်မယ်။ ဒါဘာလဲဆိုတာ သင်တွက်ထုတ်နိုင်မလား။ +> +> သင်ပိတ်မိနေမယ်ဆိုရင် ROT13-encoded hint တစ်ခု- Vs lbh ybbx ng gur bhgchgf bs FrdhraprPynffvsvpngvba zbqryf va Genafsbezref, gurve svefg bhgchg vf `ybtvgf`. Jung ner ybtvgf? +> +> ပြီးတော့ ဒုတိယ hint- Jura lbh fcrpvsl bcgvzvmref, npgvingvbaf be ybffrf jvgu fgevatf, Xrenf frgf nyy gur nethzrag inyhrf gb gurve qrsnhygf. Jung nethzragf qbrf FcnefrPngrtbevpnyPebffragebcl unir, naq jung ner gurve qrsnhygf? + +အခု training လုပ်ကြည့်ရအောင်။ ကျွန်တော်တို့ gradients တွေ ရသင့်ပါပြီ၊ ဒါကြောင့် မျှော်လင့်ပါတယ် ( ominious music ) `model.fit()` ကို ခေါ်လိုက်တာနဲ့ အရာအားလုံး အဆင်ပြေသွားပါလိမ့်မယ်။ + +```python out + 246/24543 [..............................] - ETA: 15:52 - loss: nan +``` + +အိုး မဟုတ်ဘူး။ + +`nan` က သိပ်ပြီး အားပေးစရာကောင်းတဲ့ loss value တစ်ခု မဟုတ်ပါဘူး။ ဒါတောင် ကျွန်တော်တို့ data ကို စစ်ဆေးခဲ့ပြီးပါပြီ၊ ကောင်းကောင်းမွန်မွန်ပါပဲ။ ဒါက ပြဿနာမဟုတ်ဘူးဆိုရင် နောက်ဘယ်ကို ဆက်သွားရမလဲ။ နောက်ထပ် ရှင်းရှင်းလင်းလင်း လုပ်ဆောင်ရမယ့်အဆင့်ကတော့... + +### သင်၏ Model ကို စစ်ဆေးပါ[[check-your-model]] + +`model.fit()` က Keras မှာ တကယ်ကို ကောင်းမွန်တဲ့ convenience function တစ်ခုပါ၊ ဒါပေမယ့် ဒါက သင့်အတွက် အရာများစွာကို လုပ်ဆောင်ပေးပြီး၊ ဒါက ပြဿနာဘယ်နေရာမှာ ဖြစ်ပေါ်ခဲ့လဲဆိုတာ အတိအကျရှာဖွေဖို့ ပိုခက်ခဲစေပါတယ်။ သင် model ကို debug လုပ်နေတယ်ဆိုရင်၊ အမှန်တကယ် အကူအညီဖြစ်စေနိုင်တဲ့ နည်းလမ်းတစ်ခုကတော့ batch တစ်ခုတည်းကို model ကို ပေးပြီး အဲဒီ batch တစ်ခုတည်းအတွက် outputs တွေကို အသေးစိတ်ကြည့်ဖို့ပါပဲ။ model က error တွေ ထုတ်နေတယ်ဆိုရင် နောက်ထပ် အသုံးဝင်တဲ့ အကြံပြုချက်တစ်ခုကတော့ model ကို `run_eagerly=True` နဲ့ `compile()` လုပ်ဖို့ပါပဲ။ ဒါက ဒါကို အများကြီး နှေးကွေးစေမှာဖြစ်ပေမယ့်၊ error messages တွေကို ပိုပြီး နားလည်ရလွယ်ကူစေပါလိမ့်မယ်။ ဘာလို့လဲဆိုတော့ ၎င်းတို့က သင့် model ရဲ့ code ထဲမှာ ဘယ်နေရာမှာ ပြဿနာဖြစ်ခဲ့လဲဆိုတာ အတိအကျ ဖော်ပြပေးပါလိမ့်မယ်။ + +ဒါပေမယ့် အခုအတွက်ကတော့ ကျွန်တော်တို့ `run_eagerly` မလိုအပ်သေးပါဘူး။ ကျွန်တော်တို့ အရင်ရခဲ့တဲ့ `batch` ကို model ထဲကို run ကြည့်ပြီး outputs တွေ ဘယ်လိုပုံစံလဲဆိုတာ ကြည့်ရအောင်။ + +```py +model(batch) +``` + +```python out +TFSequenceClassifierOutput(loss=, logits=, hidden_states=None, attentions=None) +``` + +ကောင်းပါပြီ၊ ဒါက ရှုပ်ထွေးပါတယ်။ အရာအားလုံး `nan` ပါပဲ! ဒါပေမယ့် ဒါက ထူးဆန်းတယ်မလား။ ကျွန်တော်တို့ရဲ့ logits တွေအားလုံး ဘယ်လိုလုပ် `nan` ဖြစ်သွားတာလဲ။ `nan` ဆိုတာ "not a number" ကို ဆိုလိုပါတယ်။ `nan` values တွေက သုညနဲ့စားခြင်းလိုမျိုး မလုပ်ရတဲ့ operation တစ်ခုကို လုပ်ဆောင်တဲ့အခါ မကြာခဏ ဖြစ်ပေါ်ပါတယ်။ ဒါပေမယ့် machine learning မှာ `nan` အကြောင်း သိထားရမယ့် အလွန်အရေးကြီးတဲ့ အရာတစ်ခုကတော့ ဒီ value က *ပျံ့နှံ့တတ်တယ်* ဆိုတာပါပဲ။ သင် number တစ်ခုကို `nan` နဲ့ မြှောက်လိုက်ရင်၊ output ကလည်း `nan` ဖြစ်ပါတယ်။ ပြီးတော့ သင့် output၊ သင့် loss ဒါမှမဟုတ် သင့် gradient မှာ `nan` တစ်ခုခု ရခဲ့ရင်၊ ဒါက သင့် model တစ်ခုလုံးကို လျင်မြန်စွာ ပျံ့နှံ့သွားပါလိမ့်မယ် -- ဘာလို့လဲဆိုတော့ အဲဒီ `nan` value က သင့် network ထဲကို ပြန်လည်ရောက်ရှိသွားတဲ့အခါ၊ သင် `nan` gradients တွေရပါလိမ့်မယ်၊ ပြီးတော့ weight updates တွေကို အဲဒီ gradients တွေနဲ့ တွက်ချက်တဲ့အခါ၊ သင် `nan` weights တွေရပါလိမ့်မယ်၊ ပြီးတော့ အဲဒီ weights တွေက `nan` outputs တွေကို ပိုပြီး တွက်ချက်ပေးပါလိမ့်မယ်။ မကြာခင်မှာ network တစ်ခုလုံးက `nan`s တွေရဲ့ block ကြီးတစ်ခု ဖြစ်လာပါလိမ့်မယ်။ ဒါက ဖြစ်သွားပြီဆိုတာနဲ့၊ ပြဿနာဘယ်ကစလဲဆိုတာ မြင်ဖို့ အတော်လေး ခက်ခဲပါတယ်။ `nan` ဘယ်ကနေ စတင်ဝင်ရောက်လာလဲဆိုတာ ကျွန်တော်တို့ ဘယ်လို ခွဲခြားနိုင်မလဲ။ + +အဖြေကတော့ ကျွန်တော်တို့ရဲ့ model ကို *reinitialize* လုပ်ဖို့ ကြိုးစားတာပါပဲ။ training စတင်ပြီးတာနဲ့၊ ကျွန်တော်တို့ `nan` တစ်ခုခု ရခဲ့ပြီး ဒါက model တစ်ခုလုံးကို လျင်မြန်စွာ ပျံ့နှံ့သွားခဲ့ပါတယ်။ ဒါကြောင့်၊ model ကို checkpoint တစ်ခုကနေ load လုပ်ပြီး weight updates တွေ မလုပ်ဘဲ၊ ဘယ်နေရာမှာ `nan` value ရလဲဆိုတာ ကြည့်ရအောင်။ + +```py +model = TFAutoModelForSequenceClassification.from_pretrained(model_checkpoint) +model(batch) +``` + +ကျွန်တော်တို့ ဒါကို run လိုက်တဲ့အခါ၊ အောက်ပါအတိုင်း ရပါလိမ့်မယ်။ + +```py out +TFSequenceClassifierOutput(loss=, logits=, hidden_states=None, attentions=None) +``` + +*အခု*တော့ တစ်ခုခု ရလာပြီ! ကျွန်တော်တို့ရဲ့ logits တွေမှာ `nan` values တွေ မရှိတော့ဘူးဆိုတာ စိတ်ချရပါတယ်။ ဒါပေမယ့် ကျွန်တော်တို့ loss မှာ `nan` values အနည်းငယ်ကို တွေ့ရပါတယ်။ ဒါက အဲဒီ samples တွေနဲ့ပတ်သက်တဲ့ ဘာတစ်ခုခုက ဒီပြဿနာကို ဖြစ်စေတာလဲ။ ဘယ်အရာတွေလဲဆိုတာ ကြည့်ရအောင် (ဒီ code ကို သင်ကိုယ်တိုင် run မယ်ဆိုရင်၊ dataset ကို shuffle လုပ်ထားတာကြောင့် သင်မတူညီတဲ့ indices တွေ ရနိုင်တယ်ဆိုတာ သတိပြုပါ)။ + +```python +import numpy as np + +loss = model(batch).loss.numpy() +indices = np.flatnonzero(np.isnan(loss)) +indices +``` + +```python out +array([ 1, 2, 5, 7, 9, 10, 11, 13, 14]) +``` + +ဒီ indices တွေကနေ ဘယ် samples တွေလာလဲဆိုတာ ကြည့်ရအောင်။ + +```python +input_ids = batch["input_ids"].numpy() +input_ids[indices] +``` + +```python out +array([[ 101, 2007, 2032, 2001, 1037, 16480, 3917, 2594, 4135, + 23212, 3070, 2214, 10170, 1010, 2012, 4356, 1997, 3183, + 6838, 12953, 2039, 2000, 1996, 6147, 1997, 2010, 2606, + 1012, 102, 6838, 2001, 3294, 6625, 3773, 1996, 2214, + 2158, 1012, 102, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0], + [ 101, 1998, 6814, 2016, 2234, 2461, 2153, 1998, 13322, + 2009, 1012, 102, 2045, 1005, 1055, 2053, 3382, 2008, + 2016, 1005, 2222, 3046, 8103, 2075, 2009, 2153, 1012, + 102, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0], + [ 101, 1998, 2007, 1996, 3712, 4634, 1010, 2057, 8108, + 2025, 3404, 2028, 1012, 1996, 2616, 18449, 2125, 1999, + 1037, 9666, 1997, 4100, 8663, 11020, 6313, 2791, 1998, + 2431, 1011, 4301, 1012, 102, 2028, 1005, 1055, 5177, + 2110, 1998, 3977, 2000, 2832, 2106, 2025, 2689, 2104, + 2122, 6214, 1012, 102, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0], + [ 101, 1045, 2001, 1999, 1037, 13090, 5948, 2007, 2048, + 2308, 2006, 2026, 5001, 2043, 2026, 2171, 2001, 2170, + 1012, 102, 1045, 2001, 3564, 1999, 2277, 1012, 102, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0], + [ 101, 2195, 4279, 2191, 2039, 1996, 2181, 2124, 2004, + 1996, 2225, 7363, 1012, 102, 2045, 2003, 2069, 2028, + 2451, 1999, 1996, 2225, 7363, 1012, 102, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0], + [ 101, 2061, 2008, 1045, 2123, 1005, 1056, 2113, 2065, + 2009, 2428, 10654, 7347, 2030, 2009, 7126, 2256, 2495, + 2291, 102, 2009, 2003, 5094, 2256, 2495, 2291, 2035, + 2105, 1012, 102, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0], + [ 101, 2051, 1010, 2029, 3216, 2019, 2503, 3444, 1010, + 6732, 1996, 2265, 2038, 19840, 2098, 2125, 9906, 1998, + 2003, 2770, 2041, 1997, 4784, 1012, 102, 2051, 6732, + 1996, 2265, 2003, 9525, 1998, 4569, 1012, 102, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0], + [ 101, 1996, 10556, 2140, 11515, 2058, 1010, 2010, 2162, + 2252, 5689, 2013, 2010, 7223, 1012, 102, 2043, 1996, + 10556, 2140, 11515, 2058, 1010, 2010, 2252, 3062, 2000, + 1996, 2598, 1012, 102, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0], + [ 101, 13543, 1999, 2049, 6143, 2933, 2443, 102, 2025, + 13543, 1999, 6143, 2933, 2003, 2443, 102, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0]]) +``` + +ဒီထဲမှာ အများကြီးပါပေမယ့် ထူးဆန်းတာမျိုး မရှိပါဘူး။ labels တွေကို ကြည့်ရအောင်။ + +```python out +labels = batch['labels'].numpy() +labels[indices] +``` + +```python out +array([2, 2, 2, 2, 2, 2, 2, 2, 2]) +``` + +အာ! `nan` samples တွေအားလုံးမှာ label တူတူရှိပြီး၊ အဲဒါက label 2 ပါ။ ဒါက အရမ်းကောင်းတဲ့ သဲလွန်စတစ်ခုပါပဲ။ ကျွန်တော်တို့ရဲ့ label က 2 ဖြစ်တဲ့အခါမှသာ `nan` loss ရတာက ကျွန်တော်တို့ model မှာရှိတဲ့ labels အရေအတွက်ကို စစ်ဆေးဖို့ အလွန်ကောင်းတဲ့ အချိန်ဖြစ်တယ်လို့ အကြံပြုပါတယ်။ + +```python +model.config.num_labels +``` + +```python out +2 +``` + +အခု ကျွန်တော်တို့ ပြဿနာကို မြင်ပါပြီ- model က classes နှစ်ခုပဲ ရှိတယ်လို့ ထင်နေပေမယ့်၊ labels တွေက 2 အထိ ရောက်နေပါတယ်၊ ဒါက တကယ်တော့ classes သုံးခုရှိတယ်လို့ ဆိုလိုပါတယ် (ဘာလို့လဲဆိုတော့ 0 ကလည်း class တစ်ခု ဖြစ်လို့ပါ)။ ဒီလိုနဲ့ `nan` ကို ရခဲ့တာပါ -- မရှိတဲ့ class တစ်ခုအတွက် loss ကို တွက်ချက်ဖို့ ကြိုးစားခဲ့တာကြောင့်ပါ! ဒါကို ပြောင်းလဲပြီး model ကို ထပ်မံ fit လုပ်ကြည့်ရအောင်။ + +``` +model = TFAutoModelForSequenceClassification.from_pretrained(model_checkpoint, num_labels=3) +model.compile(optimizer='adam') +model.fit(train_dataset) +``` + +```python out + 869/24543 [>.............................] - ETA: 15:29 - loss: 1.1032 +``` + +ကျွန်တော်တို့ train လုပ်နေပါပြီ! `nan`s တွေ မရှိတော့ဘူး၊ ပြီးတော့ ကျွန်တော်တို့ရဲ့ loss က ကျဆင်းနေပါတယ်... တစ်နည်းအားဖြင့်ပေါ့။ သင် ခဏလောက် ကြည့်နေမယ်ဆိုရင် သင်နည်းနည်း စိတ်မရှည်ဖြစ်လာနိုင်ပါတယ်။ ဘာလို့လဲဆိုတော့ loss value က မြင့်တက်နေဆဲမို့ပါပဲ။ ဒီနေရာမှာ training ကို ရပ်ပြီး ဒီပြဿနာကို ဘာကဖြစ်စေနိုင်မလဲဆိုတာ စဉ်းစားကြည့်ရအောင်။ ဒီအဆင့်မှာတော့ data နဲ့ model နှစ်ခုလုံး အဆင်ပြေတယ်လို့ ကျွန်တော်တို့ ယုံကြည်ပါတယ်။ ဒါပေမယ့် ကျွန်တော်တို့ model က ကောင်းကောင်း သင်ယူနေတာ မဟုတ်ပါဘူး။ တခြားဘာကျန်သေးလဲ။ အချိန်ရောက်ပြီ... + +### သင်၏ Hyperparameters များကို စစ်ဆေးပါ[[check-your-hyperparameters]] + +အပေါ်က code ကို ပြန်ကြည့်လိုက်ရင်၊ `batch_size` မှလွဲပြီး hyperparameter တစ်ခုမှ သင်မတွေ့နိုင်ပါဘူး၊ ပြီးတော့ ဒါက ဖြစ်နိုင်ခြေရှိတဲ့ တရားခံတစ်ဦးလို့ မထင်ပါဘူး။ ဒါပေမယ့် မလှည့်စားပါနဲ့၊ hyperparameters တွေက အမြဲတမ်းရှိနေပြီး၊ သင်မမြင်နိုင်ဘူးဆိုရင် အဲဒါတွေ ဘယ်လို သတ်မှတ်ထားလဲဆိုတာ သင်မသိဘူးလို့ပဲ ဆိုလိုပါတယ်။ အထူးသဖြင့် Keras အကြောင်း အရေးကြီးတဲ့အချက်တစ်ခုကို မှတ်ထားပါ- သင် loss, optimizer, ဒါမှမဟုတ် activation function ကို string နဲ့ သတ်မှတ်လိုက်ရင်၊ _၎င်းရဲ့ arguments အားလုံးကို ၎င်းတို့ရဲ့ default values တွေအတိုင်း သတ်မှတ်လိုက်ပါလိမ့်မယ်_။ ဒါက strings တွေကို အသုံးပြုတာက အလွန်အဆင်ပြေပေမယ့်၊ ဒီလိုလုပ်တဲ့အခါ အလွန်သတိထားသင့်ပါတယ်။ ဘာလို့လဲဆိုတော့ ဒါက သင့်ဆီကနေ အရေးကြီးတဲ့အရာတွေကို အလွယ်တကူ ဝှက်ထားနိုင်လို့ပါပဲ။ (အပေါ်က optional challenge ကို စမ်းကြည့်နေသူတိုင်း ဒီအချက်ကို သေချာမှတ်သားထားသင့်ပါတယ်)။ + +ဒီကိစ္စမှာ၊ ကျွန်တော်တို့ argument ကို string နဲ့ ဘယ်နေရာမှာ သတ်မှတ်ခဲ့လဲ။ ကျွန်တော်တို့ loss ကို string နဲ့ စတင်သတ်မှတ်ခဲ့ပေမယ့် အခုတော့ အဲဒီလို မလုပ်တော့ပါဘူး။ ဒါပေမယ့် optimizer ကို string နဲ့ သတ်မှတ်နေပါတယ်။ ဒါက ကျွန်တော်တို့ဆီကနေ တစ်ခုခုကို ဝှက်ထားနိုင်မလား။ [၎င်းရဲ့ arguments](https://www.tensorflow.org/api_docs/python/tf/keras/optimizers/Adam) တွေကို ကြည့်ရအောင်။ + +ဒီနေရာမှာ ထူးခြားတာ တစ်ခုခုရှိလား။ မှန်ပါတယ် -- learning rate! ကျွန်တော်တို့ ရိုးရိုး `adam` string ကို အသုံးပြုတဲ့အခါ၊ default learning rate ဖြစ်တဲ့ 0.001 (ဒါမှမဟုတ် 1e-3) ကို ရရှိမှာပါ။ ဒါက Transformer model တစ်ခုအတွက် အလွန်မြင့်မားပါတယ်။ ယေဘုယျအားဖြင့်၊ သင့် models တွေအတွက် 1e-5 နဲ့ 1e-4 ကြား learning rates တွေကို စမ်းသပ်ဖို့ ကျွန်တော်တို့ အကြံပြုပါတယ်၊ ဒါက ကျွန်တော်တို့ ဒီနေရာမှာ အမှန်တကယ် အသုံးပြုနေတဲ့ value ထက် ၁၀ ဆမှ ၁၀၀ ဆအထိ နည်းပါတယ်။ ဒါက အဓိကပြဿနာတစ်ခု ဖြစ်နိုင်တယ်လို့ ထင်ရတာကြောင့် ဒါကို လျှော့ချဖို့ ကြိုးစားရအောင်။ ဒါကိုလုပ်ဖို့၊ ကျွန်တော်တို့ actual `optimizer` object ကို import လုပ်ဖို့လိုပါတယ်။ အဲဒီလိုလုပ်ရင်း၊ မြင့်မားတဲ့ learning rate နဲ့ train လုပ်တာက weights တွေကို ထိခိုက်စေနိုင်တဲ့အတွက် model ကို checkpoint ကနေ reinitialize လုပ်ရအောင်။ + +```python +from tensorflow.keras.optimizers import Adam + +model = TFAutoModelForSequenceClassification.from_pretrained(model_checkpoint) +model.compile(optimizer=Adam(5e-5)) +``` + +> [!TIP] +> 💡 သင် 🤗 Transformers ကနေ `create_optimizer()` function ကိုလည်း import လုပ်နိုင်ပါတယ်။ ဒါက သင့်ကို မှန်ကန်တဲ့ weight decay နဲ့ learning rate warmup နဲ့ decay ပါဝင်တဲ့ AdamW optimizer ကို ပေးပါလိမ့်မယ်။ ဒီ optimizer က default Adam optimizer နဲ့ ရရှိတဲ့ ရလဒ်တွေထက် အနည်းငယ် ပိုကောင်းတဲ့ ရလဒ်တွေကို မကြာခဏ ထုတ်လုပ်ပေးပါလိမ့်မယ်။ + +အခု၊ အသစ်၊ ပိုကောင်းမွန်တဲ့ learning rate နဲ့ model ကို fit လုပ်ကြည့်နိုင်ပါပြီ။ + +```python +model.fit(train_dataset) +``` + +```python out +319/24543 [..............................] - ETA: 16:07 - loss: 0.9718 +``` + +အခု ကျွန်တော်တို့ရဲ့ loss က တကယ်ကို ကျဆင်းနေပါပြီ! Training က နောက်ဆုံးမှာ အလုပ်လုပ်နေပုံရပါတယ်။ ဒီနေရာမှာ သင်ခန်းစာတစ်ခု ရှိပါတယ်- သင့် model က run နေပေမယ့် loss က မကျဆင်းဘူးဆိုရင်၊ ပြီးတော့ သင့် data က အဆင်ပြေတယ်လို့ သင်သေချာတယ်ဆိုရင်၊ learning rate နဲ့ weight decay လိုမျိုး hyperparameters တွေကို စစ်ဆေးတာက ကောင်းပါတယ်။ အဲဒီနှစ်ခုထဲက တစ်ခုခုကို အလွန်အမင်း မြင့်မားစွာ သတ်မှတ်တာက training ကို high loss value မှာ "ရပ်တန့်" စေနိုင်ခြေ အများဆုံးပါပဲ။ + +## အခြားဖြစ်နိုင်ခြေရှိသော ပြဿနာများ[[other-potential-issues]] + +အပေါ်က script ထဲက ပြဿနာတွေကို ကျွန်တော်တို့ ဖော်ပြခဲ့ပြီးပါပြီ၊ ဒါပေမယ့် သင်ကြုံတွေ့ရနိုင်တဲ့ အခြား common errors အချို့ ရှိပါသေးတယ်။ (အလွန်မပြည့်စုံသေးတဲ့) စာရင်းတစ်ခုကို ကြည့်ရအောင်။ + +### Out-of-memory errors များကို ကိုင်တွယ်ဖြေရှင်းခြင်း[[dealing-with-out-of-memory-errors]] + +memory ကုန်ဆုံးနေကြောင်း ပြသတဲ့ လက္ခဏာကတော့ "OOM when allocating tensor" လိုမျိုး error ပါပဲ — OOM က "out of memory" ရဲ့ အတိုကောက်ပါ။ ဒါက large language models တွေနဲ့ အလုပ်လုပ်တဲ့အခါ အလွန်အဖြစ်များတဲ့ အန္တရာယ်တစ်ခုပါပဲ။ သင်ဒါကို ကြုံတွေ့ရရင်၊ batch size ကို တစ်ဝက်လျှော့ချပြီး ထပ်ကြိုးစားကြည့်တာက ကောင်းပါတယ်။ ဒါပေမယ့် models တချို့က *အလွန်* ကြီးမားတယ်ဆိုတာ သတိရပါ။ ဥပမာ၊ full-size GPT-2 မှာ parameters 1.5B ပါဝင်ပါတယ်၊ ဒါက model ကို သိမ်းဆည်းဖို့အတွက် 6 GB of memory လိုအပ်ပြီး၊ ၎င်းရဲ့ gradients တွေအတွက် နောက်ထပ် 6 GB လိုအပ်ပါလိမ့်မယ်! full GPT-2 model ကို train လုပ်တာက သင်ဘယ် batch size ကို အသုံးပြုပါစေ VRAM 20 GB ကျော် လိုအပ်မှာဖြစ်ပြီး၊ GPUs အနည်းငယ်သာ ဒါကို ပိုင်ဆိုင်ပါတယ်။ `distilbert-base-cased` လိုမျိုး ပိုပေါ့ပါးတဲ့ models တွေကတော့ run ရတာ အများကြီး ပိုလွယ်ကူပြီး၊ train လုပ်ရတာလည်း ပိုမြန်ဆန်ပါတယ်။ + +> [!TIP] +> သင်တန်းရဲ့ နောက်အပိုင်းမှာ၊ memory footprint ကို လျှော့ချပြီး အကြီးဆုံး models တွေကို fine-tune လုပ်နိုင်စေမယ့် ပိုမိုအဆင့်မြင့်တဲ့ နည်းလမ်းတွေကို ကျွန်တော်တို့ ကြည့်ရှုသွားမှာပါ။ + +### Hungry Hungry TensorFlow 🦛[[hungry-hungry-tensorflow]] + +TensorFlow ရဲ့ ထူးခြားတဲ့ အချက်တစ်ချက်ကတော့ သင် model တစ်ခု load လုပ်တာ ဒါမှမဟုတ် training လုပ်တာနဲ့ တပြိုင်နက် သင့် GPU memory အားလုံးကို သူ့ဘာသာသူ ခွဲဝေယူပြီး၊ လိုအပ်သလို အဲဒီ memory ကို ခွဲခြမ်းပေးပါတယ်။ ဒါက PyTorch လိုမျိုး အခြား frameworks တွေရဲ့ လုပ်ဆောင်ပုံနဲ့ ကွာခြားပါတယ်။ PyTorch က memory ကို CUDA နဲ့ လိုအပ်သလို ခွဲဝေယူတာမျိုး မလုပ်ပါဘူး။ TensorFlow နည်းလမ်းရဲ့ အားသာချက်တစ်ခုကတော့ memory ကုန်သွားတဲ့အခါ အသုံးဝင်တဲ့ errors တွေ ပေးတတ်ပြီး၊ CUDA kernel တစ်ခုလုံး crash မဖြစ်ဘဲ အဲဒီအခြေအနေကနေ ပြန်လည်ကောင်းမွန်လာနိုင်တာပါပဲ။ ဒါပေမယ့် အရေးကြီးတဲ့ အားနည်းချက်တစ်ခုလည်း ရှိပါတယ်- သင် TensorFlow processes နှစ်ခုကို တစ်ပြိုင်နက်တည်း run မယ်ဆိုရင်၊ **သင် ဆိုးရွားတဲ့ အခြေအနေတစ်ခုနဲ့ ကြုံတွေ့ရပါလိမ့်မယ်**။ + +သင် Colab ပေါ်မှာ run နေတယ်ဆိုရင် ဒါကို စိုးရိမ်စရာမလိုပါဘူး၊ ဒါပေမယ့် သင် locally run နေတယ်ဆိုရင် ဒါက သေချာပေါက် ဂရုစိုက်သင့်တဲ့အရာတစ်ခုပါ။ အထူးသဖြင့်၊ notebook tab တစ်ခုကို ပိတ်လိုက်တာနဲ့ အဲဒီ notebook က အမြဲတမ်း ပိတ်သွားတာ မဟုတ်ဘူးဆိုတာ သတိပြုပါ။ သင် run နေတဲ့ notebooks တွေကို (green icon ရှိတဲ့ ones) ရွေးပြီး directory listing မှာ ကိုယ်တိုင် ပိတ်ဖို့ လိုအပ်နိုင်ပါတယ်။ TensorFlow ကို အသုံးပြုနေတဲ့ run နေတဲ့ notebook တစ်ခုခုက သင့် GPU memory အများအပြားကို ဆက်ကိုင်ထားနိုင်ပြီး၊ ဒါက သင်စတင်တဲ့ notebook အသစ်တိုင်းမှာ အလွန်ထူးဆန်းတဲ့ ပြဿနာအချို့ ကြုံတွေ့ရနိုင်တယ်လို့ ဆိုလိုပါတယ်။ + +သင့် code မှာ CUDA, BLAS, ဒါမှမဟုတ် cuBLAS နဲ့ပတ်သက်တဲ့ errors တွေ အရင်က အလုပ်လုပ်ခဲ့တာကနေ ရလာပြီဆိုရင်၊ ဒါက အများအားဖြင့် တရားခံပါပဲ။ `nvidia-smi` လို command တစ်ခုကို အသုံးပြုပြီး စစ်ဆေးနိုင်ပါတယ် — သင့်လက်ရှိ notebook ကို ပိတ်လိုက်တာ ဒါမှမဟုတ် restart လုပ်လိုက်တဲ့အခါ၊ သင့် memory အများစုက လွတ်နေလား၊ ဒါမှမဟုတ် အသုံးပြုနေဆဲလား။ အသုံးပြုနေဆဲဆိုရင်၊ တခြားတစ်ခုခုက ဒါကို ကိုင်ထားတာ ဖြစ်ပါတယ်။ + +### သင်၏ Data ကို စစ်ဆေးပါ (ထပ်မံ၍!)[[check-your-data-again]] + +သင့် data ကနေ တစ်ခုခု သင်ယူနိုင်တယ်ဆိုမှပဲ သင်၏ model က သင်ယူပါလိမ့်မယ်။ data ကို ပျက်စီးစေတဲ့ bug တစ်ခုခုရှိနေရင် ဒါမှမဟုတ် labels တွေက ကျပန်းသတ်မှတ်ထားတယ်ဆိုရင်၊ သင်၏ dataset ပေါ်မှာ model training က ကောင်းကောင်းဖြစ်လာမှာ မဟုတ်ပါဘူး။ ဒီနေရာမှာ အသုံးဝင်တဲ့ ကိရိယာတစ်ခုက `tokenizer.decode()` ပါပဲ။ ဒါက `input_ids` တွေကို strings တွေအဖြစ် ပြန်ပြောင်းပေးတာကြောင့်၊ သင် data ကို ကြည့်ရှုပြီး သင့် training data က သင်လိုချင်တာကို သင်ပေးနေခြင်းရှိမရှိ သိနိုင်ပါတယ်။ ဥပမာ၊ အပေါ်မှာ ကျွန်တော်တို့ လုပ်ခဲ့သလို သင့် `tf.data.Dataset` ကနေ `batch` တစ်ခု ရပြီးနောက်၊ ပထမဆုံး element ကို အောက်ပါအတိုင်း decode လုပ်နိုင်ပါတယ်။ + +```py +input_ids = batch["input_ids"].numpy() +tokenizer.decode(input_ids[0]) +``` + +ပြီးရင် ဒါကို ပထမဆုံး label နဲ့ အောက်ပါအတိုင်း နှိုင်းယှဉ်နိုင်ပါတယ်။ + +```py +labels = batch["labels"].numpy() +label = labels[0] +``` + +သင့် data ကို ဒီလိုကြည့်ရှုနိုင်ပြီဆိုတာနဲ့၊ သင်ကိုယ်တိုင် အောက်ပါမေးခွန်းတွေကို မေးနိုင်ပါတယ်။ + +- decode လုပ်ထားတဲ့ data က နားလည်ရလွယ်ကူလား။ +- labels တွေကို သင်သဘောတူလား။ +- အခြား labels တွေထက် ပိုအဖြစ်များတဲ့ label တစ်ခုခု ရှိလား။ +- model က random answer/အမြဲတမ်း အဖြေတူတူကို ခန့်မှန်းရင် loss/metric က ဘယ်လောက်ဖြစ်သင့်လဲ။ + +သင့် data ကို ကြည့်ပြီးနောက်၊ model ရဲ့ predictions အချို့ကို ကြည့်ပါ -- သင့် model က tokens တွေကို ထုတ်လုပ်တယ်ဆိုရင် ဒါတွေကိုလည်း decode လုပ်ကြည့်ပါ။ အကယ်၍ model က အမြဲတမ်း တူညီတဲ့အရာကို ခန့်မှန်းနေတယ်ဆိုရင် ဒါက သင့် dataset က category တစ်ခုကို ဘက်လိုက်နေတာကြောင့် ဖြစ်နိုင်ပါတယ် (classification problems အတွက်)၊ ဒါကြောင့် oversampling rare classes လိုမျိုး နည်းလမ်းတွေက အကူအညီဖြစ်နိုင်ပါတယ်။ တစ်နည်းအားဖြင့်၊ ဒါက bad hyperparameter settings လိုမျိုး training ပြဿနာတွေကြောင့်လည်း ဖြစ်နိုင်ပါတယ်။ + +training မလုပ်ခင် သင့် initial model ပေါ်မှာ သင်ရတဲ့ loss/metric က random predictions တွေအတွက် သင်မျှော်လင့်ထားတဲ့ loss/metric နဲ့ အလွန်ကွာခြားနေတယ်ဆိုရင်၊ သင့် loss ဒါမှမဟုတ် metric ကို တွက်ချက်တဲ့ နည်းလမ်းကို သေချာပြန်စစ်ဆေးပါ၊ ဘာလို့လဲဆိုတော့ အဲဒီမှာ bug တစ်ခု ရှိနေနိုင်လို့ပါပဲ။ သင်နောက်ဆုံးမှာ ပေါင်းထည့်တဲ့ losses အများအပြားကို အသုံးပြုနေတယ်ဆိုရင်၊ ၎င်းတို့သည် scale တူညီကြောင်း သေချာပါစေ။ + +သင့် data က perfect ဖြစ်တယ်လို့ သင်သေချာပြီဆိုရင်၊ model က ဒါကို test တစ်ခုတည်းနဲ့ train လုပ်နိုင်လားဆိုတာ သင်ကြည့်နိုင်ပါတယ်။ + +### Model ကို Batch တစ်ခုတည်းနဲ့ Overfit လုပ်ခြင်း[[overfit-your-model-on-one-batch]] + +Overfitting က အများအားဖြင့် training လုပ်တဲ့အခါ ကျွန်တော်တို့ ရှောင်ရှားဖို့ ကြိုးစားရတဲ့အရာပါ။ ဘာလို့လဲဆိုတော့ ဒါက model က ကျွန်တော်တို့ လိုချင်တဲ့ general features တွေကို မှတ်မိဖို့ မသင်ယူဘဲ training samples တွေကိုပဲ အလွတ်ကျက်နေတာကို ဆိုလိုလို့ပါ။ သို့သော်လည်း၊ သင့် model ကို batch တစ်ခုတည်းပေါ်မှာ အကြိမ်ကြိမ်အခါခါ train လုပ်ဖို့ ကြိုးစားတာက သင်ပြဿနာကို ပုံဖော်ထားတဲ့အတိုင်း သင် train လုပ်ဖို့ ကြိုးစားနေတဲ့ model က ဖြေရှင်းနိုင်ခြင်းရှိမရှိ စစ်ဆေးဖို့ ကောင်းမွန်တဲ့ test တစ်ခုပါ။ ဒါက သင့် initial learning rate က မြင့်မားလွန်းခြင်းရှိမရှိ သိရှိဖို့လည်း ကူညီပေးပါလိမ့်မယ်။ + +သင် `model` ကို သတ်မှတ်ပြီးတာနဲ့ ဒါကိုလုပ်ဆောင်တာက အလွန်လွယ်ကူပါတယ်၊ training data ရဲ့ batch တစ်ခုကို ယူပြီး၊ အဲဒီ `batch` ကို သင့် dataset အားလုံးအဖြစ် သတ်မှတ်ကာ၊ epochs အများအပြားအတွက် ဒါကို fit လုပ်လိုက်ပါ။ + +```py +for batch in train_dataset: + break + +# model.compile() ကို run ပြီး သင့် optimizer ကို သတ်မှတ်ထားကြောင်း၊ +# ပြီးတော့ သင်အသုံးပြုနေတယ်ဆိုရင် သင့် loss/metrics တွေကို သတ်မှတ်ထားကြောင်း သေချာပါစေ။ + +model.fit(batch, epochs=20) +``` + +> [!TIP] +> 💡 သင့် training data က unbalanced ဖြစ်နေတယ်ဆိုရင်၊ labels အားလုံးပါဝင်တဲ့ training data batch တစ်ခုကို တည်ဆောက်ထားကြောင်း သေချာပါစေ။ + +ရရှိလာတဲ့ model ဟာ `batch` ပေါ်မှာ perfect နီးပါး ရလဒ်တွေ ရရှိသင့်ပြီး၊ loss က 0 နီးပါး (ဒါမှမဟုတ် သင်အသုံးပြုနေတဲ့ loss အတွက် အနိမ့်ဆုံးတန်ဖိုး) သို့ လျင်မြန်စွာ ကျဆင်းသင့်ပါတယ်။ + +သင့် model ကို ဒီလို perfect ရလဒ်တွေ မရရှိနိုင်ဘူးဆိုရင်၊ သင်ပြဿနာကို ပုံဖော်ထားတဲ့ နည်းလမ်း ဒါမှမဟုတ် သင့် data မှာ တစ်ခုခု မှားနေတယ်လို့ ဆိုလိုပါတယ်၊ ဒါကြောင့် ဒါကို ပြင်ဆင်သင့်ပါတယ်။ သင် overfitting test ကို အောင်မြင်အောင် လုပ်ဆောင်နိုင်မှသာ သင့် model က တကယ်ကို သင်ယူနိုင်တယ်ဆိုတာ သေချာနိုင်ပါလိမ့်မယ်။ + +> [!WARNING] +> ⚠️ ဒီ overfitting test ပြီးရင် သင် model ကို ပြန်လည်ဖန်တီးပြီး recompile လုပ်ရပါလိမ့်မယ်။ ဘာလို့လဲဆိုတော့ ရရှိလာတဲ့ model က သင့် full dataset ပေါ်မှာ အသုံးဝင်တဲ့အရာတစ်ခုခုကို ပြန်လည်သင်ယူနိုင်မှာ မဟုတ်လို့ပါပဲ။ + +### ပထမဆုံး Baseline မရခင် ဘာမှ မညှိပါနှင့်[[dont-tune-anything-until-you-have-a-first-baseline]] + +Intense hyperparameter tuning ကို Machine Learning ရဲ့ အခက်ခဲဆုံး အပိုင်းအဖြစ် အမြဲတမ်း အလေးပေးပြောဆိုကြပေမယ့်၊ ဒါက metric ပေါ်မှာ အနည်းငယ် တိုးတက်မှုရရှိအောင် ကူညီပေးမယ့် နောက်ဆုံးအဆင့်တစ်ခုမျှသာ ဖြစ်ပါတယ်။ သင့် hyperparameters တွေအတွက် *အလွန်* ဆိုးရွားတဲ့ တန်ဖိုးတွေ (ဥပမာ- Transformer model နဲ့ default Adam learning rate 1e-3 ကို အသုံးပြုခြင်း) က သင်ယူမှုကို အလွန်နှေးကွေးစေနိုင်ပါတယ် ဒါမှမဟုတ် လုံးဝ ရပ်တန့်သွားစေနိုင်ပါတယ်၊ ဒါပေမယ့် အချိန်အများစုမှာ "သင့်လျော်သော" hyperparameters တွေ (ဥပမာ- learning rate 1e-5 ကနေ 5e-5 အထိ) က သင့်ကို ကောင်းမွန်တဲ့ ရလဒ်တွေ ပေးဖို့ အဆင်ပြေပြေ အလုပ်လုပ်ပါလိမ့်မယ်။ ဒါကြောင့်၊ သင့် dataset ပေါ်မှာ သင်ရရှိထားတဲ့ baseline ကို ကျော်လွန်တဲ့အရာတစ်ခု မရမချင်း အချိန်ကုန်ပြီး ကုန်ကျစရိတ်များတဲ့ hyperparameter search ကို မလုပ်ဆောင်ပါနဲ့။ + +သင့်မှာ ကောင်းမွန်လုံလောက်တဲ့ model တစ်ခု ရရှိပြီဆိုတာနဲ့၊ အနည်းငယ် စတင်ပြင်ဆင်နိုင်ပါပြီ။ မတူညီတဲ့ hyperparameters တွေနဲ့ run တွေ ထောင်ပေါင်းများစွာကို လုပ်ဆောင်ဖို့ မကြိုးစားပါနဲ့၊ ဒါပေမယ့် hyperparameter တစ်ခုအတွက် မတူညီတဲ့ values နှစ်ခုနဲ့ run အချို့ကို နှိုင်းယှဉ်ပြီး ဘယ်ဟာက အကြီးမားဆုံး အကျိုးသက်ရောက်မှုရှိလဲဆိုတာ စိတ်ကူးရအောင် လုပ်ပါ။ + +သင် model ကိုယ်တိုင်ကို ပြင်ဆင်နေတယ်ဆိုရင်၊ ရိုးရှင်းအောင်ထားပြီး သင်ကျိုးကြောင်းဆီလျော်စွာ အကြောင်းပြလို့ မရတဲ့အရာတွေကို မစမ်းသပ်ပါနဲ့။ သင့်ရဲ့ ပြောင်းလဲမှုက မရည်ရွယ်ဘဲ ဖြစ်ပေါ်လာတဲ့ အကျိုးဆက်တွေ မရှိဘူးဆိုတာ သေချာစေဖို့ overfitting test ကို အမြဲတမ်း ပြန်လုပ်ပါ။ + +### အကူအညီတောင်းပါ[[ask-for-help]] + +မျှော်လင့်ပါတယ် ဒီအပိုင်းက သင့်ပြဿနာကို ဖြေရှင်းဖို့ ကူညီပေးမယ့် အကြံပြုချက်အချို့ကို သင်တွေ့ခဲ့ရပါလိမ့်မယ်။ ဒါပေမယ့် မဟုတ်ဘူးဆိုရင်၊ [forums](https://discuss.huggingface.co/) မှာ community ကို အမြဲတမ်း အကူအညီတောင်းနိုင်တယ်ဆိုတာ မှတ်ထားပါ။ + +အကူအညီဖြစ်နိုင်မယ့် နောက်ထပ် အရင်းအမြစ်အချို့ကတော့ အောက်ပါအတိုင်းပါ။ + +- Joel Grus ရဲ့ ["Reproducibility as a vehicle for engineering best practices"](https://docs.google.com/presentation/d/1yHLPvPhUs2KGI5ZWo0sU-PKU3GimAk3iTsI38Z-B5Gw/edit#slide=id.p) +- Cecelia Shao ရဲ့ ["Checklist for debugging neural networks"](https://towardsdatascience.com/checklist-for-debugging-neural-networks-d8b2a9434f21) +- Chase Roberts ရဲ့ ["How to unit test machine learning code"](https://medium.com/@keeper6928/how-to-unit-test-machine-learning-code-57cf6fd81765) +- Andrej Karpathy ရဲ့ ["A Recipe for Training Neural Networks"](http://karpathy.github.io/2019/04/25/recipe/) + +ဟုတ်ပါတယ်၊ neural nets တွေကို train လုပ်တဲ့အခါ သင်ကြုံတွေ့ရတဲ့ ပြဿနာတိုင်းဟာ သင့်အမှားကြောင့် မဟုတ်ပါဘူး။ 🤗 Transformers ဒါမှမဟုတ် 🤗 Datasets library ထဲမှာ တစ်ခုခု မမှန်ဘူးလို့ ထင်တာနဲ့ ကြုံတွေ့ရရင်၊ သင် bug တစ်ခုနဲ့ ကြုံတွေ့ခဲ့တာ ဖြစ်နိုင်ပါတယ်။ သင်ဒါနဲ့ ပတ်သက်ပြီး အကုန်လုံး ကျွန်တော်တို့ကို သေချာပြောပြသင့်ပါတယ်၊ ပြီးတော့ နောက်အပိုင်းမှာ ဒါကို ဘယ်လိုအတိအကျ လုပ်ဆောင်ရမလဲဆိုတာ ကျွန်တော်တို့ ရှင်းပြပေးပါမယ်။ + +## ဝေါဟာရ ရှင်းလင်းချက် (Glossary) + +* **Training Pipeline**: Machine Learning မော်ဒယ်တစ်ခုကို data preprocessing မှစ၍ model training, evaluation အထိ ပါဝင်သော အဆင့်များစွာရှိသည့် လုပ်ငန်းစဉ်။ +* **Debug**: ကွန်ပျူတာပရိုဂရမ်တစ်ခုရှိ အမှားများ (bugs) ကို ရှာဖွေ၊ ဖော်ထုတ်ပြီး ပြင်ဆင်ခြင်း။ +* **Fine-tune**: ကြိုတင်လေ့ကျင့်ထားပြီးသား (pre-trained) မော်ဒယ်တစ်ခုကို သီးခြားလုပ်ငန်းတစ်ခု (specific task) အတွက် အနည်းငယ်သော ဒေတာနဲ့ ထပ်မံလေ့ကျင့်ပေးခြင်းကို ဆိုလိုပါတယ်။ +* **Model**: Artificial Intelligence (AI) နယ်ပယ်တွင် အချက်အလက်များကို လေ့လာပြီး ခန့်မှန်းချက်များ ပြုလုပ်ရန် ဒီဇိုင်းထုတ်ထားသော သင်္ချာဆိုင်ရာဖွဲ့စည်းပုံများ။ +* **`model.fit()`**: Keras (TensorFlow) တွင် model ကို training လုပ်ရန် အသုံးပြုသော method။ +* **Error**: ပရိုဂရမ်တစ်ခု အလုပ်လုပ်နေစဉ် ဖြစ်ပေါ်လာသော ပြဿနာတစ်ခုကြောင့် ၎င်းသည် ပုံမှန်အတိုင်း ဆက်လက်လုပ်ဆောင်နိုင်ခြင်းမရှိခြင်း။ +* **Crappy (Model)**: စွမ်းဆောင်ရည် ညံ့ဖျင်းသော သို့မဟုတ် အသုံးမကျသော model။ +* **Dataset**: AI မော်ဒယ်တွေ လေ့ကျင့်ဖို့အတွက် အသုံးပြုတဲ့ ဒေတာအစုအဝေးတစ်ခုပါ။ +* **Batch Elements**: dataset အတွင်းရှိ elements များစွာကို တစ်ပြိုင်နက်တည်း လုပ်ဆောင်နိုင်ရန် အုပ်စုဖွဲ့ခြင်း။ +* **Loss Function**: Model ၏ ခန့်မှန်းချက်များနှင့် အမှန်တကယ် labels များကြား ကွာခြားမှုကို တိုင်းတာသော function။ +* **Optimizer**: Model ၏ weights များကို training လုပ်နေစဉ်အတွင်း loss ကို လျှော့ချရန်အတွက် ချိန်ညှိပေးသော algorithm။ +* **Evaluation**: Model ၏ စွမ်းဆောင်ရည်ကို တိုင်းတာခြင်း။ +* **Metric**: Model ၏ စွမ်းဆောင်ရည်ကို တိုင်းတာရန် အသုံးပြုသော တန်ဖိုးများ (ဥပမာ- accuracy, F1 score)။ +* **`load_dataset()`**: Hugging Face Datasets library မှ dataset များကို download လုပ်ပြီး cache လုပ်ရန် အသုံးပြုသော function။ +* **`evaluate` Library**: Model ၏ metrics များကို တွက်ချက်ရန်အတွက် Hugging Face မှ ပံ့ပိုးပေးသော library။ +* **`AutoTokenizer`**: Hugging Face Transformers library မှာ ပါဝင်တဲ့ class တစ်ခုဖြစ်ပြီး မော်ဒယ်အမည်ကို အသုံးပြုပြီး သက်ဆိုင်ရာ tokenizer ကို အလိုအလျောက် load လုပ်ပေးသည်။ +* **`TFAutoModelForSequenceClassification`**: TensorFlow framework အတွက် sequence classification task အတွက် Transformer model ကို အလိုအလျောက် load လုပ်ပေးသော class။ +* **`raw_datasets`**: preprocessing မလုပ်ရသေးသော dataset။ +* **`model_checkpoint`**: pretrained model ၏ အမည် သို့မဟုတ် path။ +* **`tokenizer`**: စာသားကို tokens အဖြစ် ပြောင်းလဲပေးသော ကိရိယာ။ +* **`preprocess_function`**: dataset ကို preprocessing လုပ်ရန်အတွက် function။ +* **`examples["premise"]`**: MNLI dataset ၏ premise column မှ data။ +* **`examples["hypothesis"]`**: MNLI dataset ၏ hypothesis column မှ data။ +* **`truncation=True`**: Tokenizer ကို အရှည်ဆုံး sequence အထိ ဖြတ်တောက်ရန် သတ်မှတ်ခြင်း။ +* **`tokenized_datasets`**: tokenizer ဖြင့် preprocessing လုပ်ထားသော dataset။ +* **`map()` Method**: 🤗 Datasets library မှာ ပါဝင်တဲ့ method တစ်ခုဖြစ်ပြီး dataset ရဲ့ element တစ်ခုစီ ဒါမှမဟုတ် batch တစ်ခုစီပေါ်မှာ function တစ်ခုကို အသုံးပြုနိုင်စေသည်။ +* **`batched=True`**: `map()` method မှာ အသုံးပြုသော argument တစ်ခုဖြစ်ပြီး function ကို dataset ရဲ့ element အများအပြားပေါ်မှာ တစ်ပြိုင်နက်တည်း အသုံးပြုစေသည်။ +* **`train_dataset`**: training အတွက် အသုံးပြုမည့် dataset။ +* **`to_tf_dataset()` Method**: 🤗 Datasets library မှ dataset ကို TensorFlow `tf.data.Dataset` object အဖြစ် ပြောင်းလဲပေးသော method။ +* **`columns=["input_ids", "labels"]`**: `tf.data.Dataset` တွင် ပါဝင်မည့် columns များ။ +* **`batch_size=16`**: training အတွက် တစ်ကြိမ်လျှင် အသုံးပြုမည့် samples အရေအတွက်။ +* **`shuffle=True`**: dataset ကို training မလုပ်မီ ရောနှော (shuffle) ရန် သတ်မှတ်ခြင်း။ +* **`validation_dataset`**: validation အတွက် အသုံးပြုမည့် dataset။ +* **`model.compile()`**: Keras တွင် model ကို training အတွက် ပြင်ဆင်ရန် (optimizer, loss, metrics) အသုံးပြုသော method။ +* **`loss="sparse_categorical_crossentropy"`**: Multi-class classification အတွက် အသုံးပြုသော loss function။ +* **`optimizer="adam"`**: Adam optimizer ကို အသုံးပြုခြင်း။ +* **`VisibleDeprecationWarning`**: Python တွင် နောက်ပိုင်း version များတွင် ဖယ်ရှားခံရနိုင်သော feature တစ်ခုကို အသုံးပြုခြင်းကြောင့် ပေါ်ပေါက်လာသော warning။ +* **UX Issue (User Experience Issue)**: အသုံးပြုသူ အတွေ့အကြုံနှင့် ပတ်သက်သော ပြဿနာ။ +* **`ValueError`**: Python တွင် value မှားယွင်းစွာ ပေးပို့မိသောအခါ ဖြစ်ပေါ်လာသော error။ +* **Gradients**: Deep learning တွင် model ၏ weights များကို update လုပ်ရန်အတွက် loss function ၏ derivative (ပြောင်းလဲမှုနှုန်း)။ +* **`tf.data.Dataset`**: TensorFlow တွင် efficient data input pipeline များကို တည်ဆောက်ရန် အသုံးပြုသော API။ +* **`batch`**: `tf.data.Dataset` မှ တစ်ကြိမ်လျှင် ထုတ်ပေးသော data အစုအဝေး။ +* **`labels`**: model က ခန့်မှန်းရမည့် အမှန်တကယ် တန်ဖိုးများ။ +* **`attention_mask`**: မော်ဒယ်ကို အာရုံစိုက်သင့်သည့် tokens များနှင့် လျစ်လျူရှုသင့်သည့် (padding) tokens များကို ခွဲခြားပေးသည့် binary mask။ +* **`input_ids`**: Tokenizer မှ ထုတ်ပေးသော tokens တစ်ခုစီ၏ ထူးခြားသော ဂဏန်းဆိုင်ရာ ID များ။ +* **Input Tensor**: model သို့ ပေးပို့သော multi-dimensional array (tensor)။ +* **Keras**: TensorFlow တွင် deep learning models များကို တည်ဆောက်ရန် အသုံးပြုသော high-level API။ +* **Internal Loss**: Transformer models များတွင် ၎င်းတို့ကိုယ်တိုင် loss များကို တွက်ချက်နိုင်သော အင်္ဂါရပ်။ +* **`model.config.num_labels`**: model configuration တွင် သတ်မှတ်ထားသော output classes အရေအတွက်။ +* **`Adam` (Optimizer)**: Adaptive Moment Estimation ဟုခေါ်သော optimizer algorithm တစ်ခု။ +* **Hyperparameters**: Model ကို training မလုပ်မီ သတ်မှတ်ပေးရသော parameters များ (ဥပမာ- learning rate, batch size)။ +* **`learning_rate`**: Training လုပ်ငန်းစဉ်အတွင်း model ၏ weights များကို မည်မျှပြောင်းလဲရမည်ကို ထိန်းချုပ်သော parameter။ +* **`weight_decay`**: Model ၏ weights များ အလွန်အမင်း မကြီးထွားစေရန် ထိန်းချုပ်သော regularization technique။ +* **`AdamW`**: Weight decay ကို မှန်ကန်စွာ ကိုင်တွယ်သော Adam optimizer ၏ ပြုပြင်ထားသော version။ +* **Learning Rate Warmup**: Training အစတွင် learning rate ကို ဖြည်းဖြည်းချင်း မြှင့်တင်ခြင်း။ +* **Learning Rate Decay**: Training လုပ်နေစဉ် learning rate ကို ဖြည်းဖြည်းချင်း လျှော့ချခြင်း။ +* **"Stall" (Training)**: Training လုပ်ငန်းစဉ် ရပ်တန့်သွားခြင်း သို့မဟုတ် တိုးတက်မှု မရှိတော့ခြင်း။ +* **OOM (Out Of Memory) Error**: ကွန်ပျူတာ၏ မှတ်ဉာဏ် (memory) မလုံလောက်ခြင်းကြောင့် ဖြစ်ပေါ်လာသော error။ +* **Allocating Tensor**: Memory တွင် tensor တစ်ခုအတွက် နေရာချထားခြင်း။ +* **GPT-2**: Generative Pre-trained Transformer 2, OpenAI မှ ဖန်တီးသော large language model။ +* **Parameters (Model)**: Model ၏ လေ့ကျင့်နိုင်သော weights နှင့် biases များ။ +* **VRAM (Video RAM)**: GPU တွင် အသုံးပြုသော memory။ +* **`distilbert-base-cased`**: DistilBERT model ၏ base version, cased text ပေါ်တွင် လေ့ကျင့်ထားသည်။ +* **TensorFlow Quirk**: TensorFlow ၏ ထူးခြားသော သို့မဟုတ် ပုံမှန်မဟုတ်သော လုပ်ဆောင်ပုံ။ +* **CUDA**: NVIDIA မှ GPU များပေါ်တွင် parallel computing (ပြိုင်တူတွက်ချက်မှု) အတွက် ဖန်တီးသော platform နှင့် API။ +* **PyTorch**: Facebook (ယခု Meta) က ဖန်တီးထားတဲ့ open-source machine learning library တစ်ခုဖြစ်ပြီး deep learning မော်ဒယ်တွေ တည်ဆောက်ဖို့အတွက် အသုံးပြုပါတယ်။ +* **CUDA Kernel**: GPU ပေါ်တွင် run ရန် ရေးသားထားသော function။ +* **BLAS (Basic Linear Algebra Subprograms)**: vector နှင့် matrix operations များအတွက် standard API။ +* **cuBLAS**: NVIDIA CUDA အတွက် BLAS library။ +* **`nvidia-smi`**: NVIDIA GPU များ၏ အခြေအနေ (ဥပမာ- memory usage) ကို စစ်ဆေးရန်အတွက် command-line utility။ +* **`tokenizer.decode()`**: Tokenized input IDs များကို မူရင်းစာသားအဖြစ် ပြန်ပြောင်းပေးသော tokenizer method။ +* **Corrupt Data**: ပျက်စီးနေသော သို့မဟုတ် မှားယွင်းနေသော ဒေတာ။ +* **Randomly Attributed Labels**: ကျပန်းသတ်မှတ်ထားသော labels များ။ +* **Biased Dataset**: သီးခြား category တစ်ခု သို့မဟုတ် အုပ်စုတစ်ခုကို အချိုးမညီမျှစွာ ကိုယ်စားပြုသော dataset။ +* **Oversampling Rare Classes**: dataset ထဲက နည်းပါးတဲ့ classes တွေရဲ့ samples တွေကို တိုးမြှင့်ခြင်း။ +* **Baseline (Model)**: အခြား models များကို နှိုင်းယှဉ်ရန်အတွက် စွမ်းဆောင်ရည်ကို တိုင်းတာရန် အသုံးပြုသော အခြေခံ model။ +* **Hyperparameter Tuning**: Model ၏ hyperparameters များကို အကောင်းဆုံး စွမ်းဆောင်ရည် ရရှိရန်အတွက် ချိန်ညှိခြင်း။ +* **`git_commit()` Method**: `Repository` class မှ commit လုပ်ရန်အတွက် method။ +* **`git_pull()` Method**: `Repository` class မှ pull လုပ်ရန်အတွက် method။ +* **`git_push()` Method**: `Repository` class မှ push လုပ်ရန်အတွက် method။ +* **`Repository` Class**: `huggingface_hub` library မှ Git repository များကို ကိုင်တွယ်ရန်အတွက် class။ +* **`merge`**: Git တွင် မတူညီသော branches များမှ ပြောင်းလဲမှုများကို ပေါင်းစပ်ခြင်း။ +* **API (Application Programming Interface)**: ဆော့ဖ်ဝဲလ် နှစ်ခုကြား အပြန်အလှန် ချိတ်ဆက်ဆောင်ရွက်နိုင်ရန် လမ်းကြောင်းဖွင့်ပေးသော အစုအဝေး (set of rules) များ။ +* **TensorFlow**: Google က ဖန်တီးထားတဲ့ open-source machine learning library တစ်ခုဖြစ်ပြီး deep learning မော်ဒယ်တွေ တည်ဆောက်ဖို့အတွက် အသုံးပြုပါတယ်။ +* **Python**: အသုံးများသော programming language တစ်ခု။ +* **Markdown Files**: Plain text format တစ်ခုဖြစ်ပြီး formatting syntax ကို အသုံးပြု၍ စာသားကို ပုံစံချခြင်း။ +* **Callback**: Keras မှာ training လုပ်နေစဉ် သတ်မှတ်ထားတဲ့ အဆင့်တွေမှာ အလိုအလျောက် run ဖို့ သတ်မှတ်ထားတဲ့ function တစ်ခု။ +* **CLI (Command Line Interface)**: ကွန်ပျူတာကို စာသား command တွေနဲ့ ထိန်းချုပ်တဲ့ interface။ +* **`huggingface_hub`**: Hugging Face Hub နဲ့ ချိတ်ဆက်ဖို့အတွက် Python client library။ +* **Logits**: Neural network ရဲ့ final output layer ကနေ ထွက်လာတဲ့ raw, unnormalized prediction scores တွေ။ +* **`sparse_categorical_crossentropy`**: Multi-class classification အတွက် အသုံးပြုသော loss function (labels တွေကို integer indices အဖြစ် ပေးတဲ့အခါ)။ \ No newline at end of file diff --git a/chapters/my/chapter8/5.mdx b/chapters/my/chapter8/5.mdx new file mode 100644 index 000000000..3cdbc599e --- /dev/null +++ b/chapters/my/chapter8/5.mdx @@ -0,0 +1,125 @@ +# ကောင်းမွန်သော Issue တစ်ခုကို ရေးသားနည်း[[how-to-write-a-good-issue]] + + + +Hugging Face libraries တွေထဲက တစ်ခုခုမှာ မှားနေတယ်လို့ ထင်ရတဲ့အရာတစ်ခုကို သင်ကြုံတွေ့ရတဲ့အခါ၊ ကျွန်တော်တို့ ပြင်ဆင်နိုင်ဖို့ သေချာပေါက် အကြောင်းကြားသင့်ပါတယ် (open source library တွေအားလုံးအတွက်လည်း ဒီအတိုင်းပါပဲ)။ သင့်ရဲ့ code မှာပဲ bug ကရှိတာလား ဒါမှမဟုတ် ကျွန်တော်တို့ library တွေထဲက တစ်ခုမှာလားဆိုတာ သင်လုံးဝမသေချာရင်၊ ပထမဆုံး စစ်ဆေးရမယ့်နေရာက [forums](https://discuss.huggingface.co/) ပါပဲ။ community က ဒါကို ရှာဖွေဖို့ သင့်ကို ကူညီပေးပါလိမ့်မယ်၊ ပြီးတော့ Hugging Face team ကလည်း အဲဒီက ဆွေးနွေးမှုတွေကို အနီးကပ် စောင့်ကြည့်နေပါတယ်။ + + + +သင့်မှာ bug တစ်ခု သေချာပြီဆိုရင်၊ ပထမအဆင့်က minimal reproducible example တစ်ခုကို တည်ဆောက်ဖို့ပါပဲ။ + +## Minimal Reproducible Example တစ်ခု ဖန်တီးခြင်း[[creating-a-minimal-reproducible-example]] + +bug ကို ထုတ်လုပ်တဲ့ code အပိုင်းကို ခွဲထုတ်ဖို့ အလွန်အရေးကြီးပါတယ်။ ဘာလို့လဲဆိုတော့ Hugging Face team မှာ ဘယ်သူမှ မှော်ဆရာ မဟုတ်သေးသလို (yet)၊ သူတို့မမြင်ရတဲ့အရာကို ပြင်လို့လည်း မရလို့ပါပဲ။ minimal reproducible example တစ်ခုဟာ နာမည်က ဖော်ပြတဲ့အတိုင်း reproducible ဖြစ်သင့်ပါတယ်။ ဒါက သင်အသုံးပြုနေတဲ့ မည်သည့် external files တွေ ဒါမှမဟုတ် data တွေပေါ်မှာမှ မှီခိုမနေသင့်ဘူးလို့ ဆိုလိုပါတယ်။ သင်အသုံးပြုနေတဲ့ data ကို သင်ရဲ့ တကယ့် data နဲ့ ဆင်တူတဲ့ dummy values တွေနဲ့ အစားထိုးပြီး တူညီတဲ့ error ကို ထုတ်လုပ်အောင် ကြိုးစားပါ။ + +> [!TIP] +> 🚨 🤗 Transformers repository ထဲက issues အများအပြားဟာ ၎င်းတို့ကို reproduce လုပ်ဖို့ အသုံးပြုတဲ့ data တွေကို ဝင်ရောက်ကြည့်ရှုလို့ မရတဲ့အတွက် ဖြေရှင်းလို့ မရသေးပါဘူး။ + +သင့်မှာ self-contained ဖြစ်တဲ့အရာတစ်ခု ရရှိပြီဆိုတာနဲ့၊ အဲဒါကို code လိုင်းနည်းနည်းလေးနဲ့ ထပ်လျှော့ချကြည့်နိုင်ပါတယ်။ ဒါကို minimal reproducible example လို့ ကျွန်တော်တို့ ခေါ်ပါတယ်။ ဒါက သင့်ဘက်ကနေ အလုပ်ပိုလုပ်ရပေမယ့်၊ ကောင်းမွန်ပြီး တိုတောင်းတဲ့ bug reproducer တစ်ခုကို သင်ပံ့ပိုးပေးနိုင်ရင် အကူအညီနဲ့ fix တစ်ခု ရဖို့ အာမခံနိုင်ပါလိမ့်မယ်။ + +သင်အဆင်ပြေတယ်လို့ ခံစားရရင်၊ သင့် bug ဖြစ်ပျက်တဲ့ source code ကို ဝင်ရောက်စစ်ဆေးကြည့်ပါ။ သင့်ပြဿနာအတွက် ဖြေရှင်းနည်းတစ်ခုကို သင်တွေ့နိုင်ပါတယ် (ဒီလိုဆိုရင် fix လုပ်ဖို့ pull request တောင် အကြံပြုနိုင်ပါတယ်)၊ ဒါပေမယ့် ပိုပြီး ယေဘုယျအားဖြင့်၊ ဒါက maintainers တွေကို သင့် report ကို ဖတ်တဲ့အခါ source ကို ပိုကောင်းကောင်း နားလည်အောင် ကူညီပေးနိုင်ပါတယ်။ + +## Issue Template ကို ဖြည့်သွင်းခြင်း[[filling-out-the-issue-template]] + +သင် issue တစ်ခု file လုပ်တဲ့အခါ ဖြည့်သွင်းရမယ့် template တစ်ခုရှိတာကို သတိထားမိပါလိမ့်မယ်။ ဒီနေရာမှာ [🤗 Transformers issues](https://github.com/huggingface/transformers/issues/new/choose) အတွက် template ကို ကျွန်တော်တို့ လိုက်နာပါမယ်၊ ဒါပေမယ့် အခြား repository တစ်ခုမှာ issue တစ်ခု report လုပ်ရင်လည်း အလားတူအချက်အလက်တွေ လိုအပ်ပါလိမ့်မယ်။ template ကို ဗလာမထားပါနဲ့- ဒါကို ဖြည့်သွင်းဖို့ အချိန်ယူခြင်းက သင့်အဖြေရရှိနိုင်ခြေနဲ့ ပြဿနာကို ဖြေရှင်းနိုင်ခြေကို အမြင့်ဆုံး ဖြစ်စေပါလိမ့်မယ်။ + +ယေဘုယျအားဖြင့်၊ issue တစ်ခု file လုပ်တဲ့အခါ၊ အမြဲတမ်း ယဉ်ကျေးစွာ နေပါ။ ဒါဟာ open source project တစ်ခုဖြစ်လို့ သင်ဟာ အခမဲ့ software ကို အသုံးပြုနေတာဖြစ်ပြီး၊ ဘယ်သူမှ သင့်ကို ကူညီဖို့ တာဝန်မရှိပါဘူး။ သင်မှန်ကန်တယ်လို့ ထင်တဲ့ ဝေဖန်ချက်တွေကို သင့် issue ထဲမှာ ထည့်သွင်းနိုင်ပေမယ့်၊ maintainers တွေက ဒါကို ကောင်းကောင်းမခံယူဘဲ သင့်ကို ကူညီဖို့ အလျင်စလို မလုပ်ချင်တော့တာမျိုး ဖြစ်နိုင်ပါတယ်။ project ရဲ့ [code of conduct](https://github.com/huggingface/transformers/blob/master/CODE_OF_CONDUCT.md) ကို သေချာဖတ်ပါ။ + +### သင့် Environment အချက်အလက်များ ထည့်သွင်းခြင်း[[including-your-environment-information]] + +🤗 Transformers က သင့် environment အကြောင်း ကျွန်တော်တို့ လိုအပ်တဲ့ အချက်အလက်အားလုံးကို ရယူဖို့ utility တစ်ခု ပံ့ပိုးပေးပါတယ်။ သင့် terminal မှာ အောက်ပါအတိုင်း ရိုက်ထည့်လိုက်ရုံပါပဲ။ + +``` +transformers-cli env +``` + +ပြီးရင် ဒီလိုမျိုး တစ်ခုခုကို သင်ရရှိပါလိမ့်မယ်။ + +```out +Copy-and-paste the text below in your GitHub issue and FILL OUT the two last points. + +- `transformers` version: 4.12.0.dev0 +- Platform: Linux-5.10.61-1-MANJARO-x86_64-with-arch-Manjaro-Linux +- Python version: 3.7.9 +- PyTorch version (GPU?): 1.8.1+cu111 (True) +- Tensorflow version (GPU?): 2.5.0 (True) +- Flax version (CPU?/GPU?/TPU?): 0.3.4 (cpu) +- Jax version: 0.2.13 +- JaxLib version: 0.1.65 +- Using GPU in script?: +- Using distributed or parallel set-up in script?: +``` + +`transformers-cli env` command ရဲ့ အရှေ့မှာ `!` တစ်ခု ထည့်ခြင်းဖြင့် notebook cell ကနေ execute လုပ်နိုင်ပြီး၊ ပြီးရင် ရလဒ်ကို သင့် issue ရဲ့ အစမှာ copy & paste လုပ်နိုင်ပါတယ်။ + +### လူများကို Tag လုပ်ခြင်း[[tagging-people]] + +`@` လို့ရိုက်ပြီး ၎င်းတို့ရဲ့ GitHub handle ကို လိုက်ရိုက်ခြင်းက ၎င်းတို့ကို notification ပို့ပေးမှာဖြစ်လို့ သူတို့က သင့် issue ကို တွေ့ရမှာဖြစ်ပြီး ပိုမြန်မြန် ပြန်ကြားနိုင်ပါတယ်။ ဒါကို ချင့်ချိန်ပြီး အသုံးပြုပါ။ ဘာလို့လဲဆိုတော့ သင် tag လုပ်တဲ့သူတွေဟာ သူတို့နဲ့ တိုက်ရိုက်မသက်ဆိုင်တဲ့ ကိစ္စတစ်ခုအတွက် notify လုပ်ခံရတာကို မကြိုက်နိုင်လို့ပါပဲ။ သင့် bug နဲ့ ဆက်စပ်နေတဲ့ source files တွေကို သင်ကြည့်ရှုခဲ့တယ်ဆိုရင်၊ သင့်ပြဿနာအတွက် တာဝန်ရှိတယ်လို့ သင်ထင်တဲ့ လိုင်းမှာ နောက်ဆုံးပြောင်းလဲမှု လုပ်ခဲ့တဲ့သူကို tag လုပ်သင့်ပါတယ် (ဒီအချက်အလက်ကို GitHub ပေါ်က အဲဒီလိုင်းကို ကြည့်ပြီး၊ ရွေးချယ်ပြီး၊ "View git blame" ကို နှိပ်ခြင်းဖြင့် ရှာနိုင်ပါတယ်)။ + +မဟုတ်ရင်၊ template က tag လုပ်ဖို့ လူတွေကို အကြံပြုချက်တွေ ပေးပါတယ်။ ယေဘုယျအားဖြင့်၊ လူသုံးယောက်ထက် ပိုမ tag ပါနဲ့။ + +### Reproducible Example ထည့်သွင်းခြင်း[[including-a-reproducible-example]] + +bug ကို ထုတ်လုပ်တဲ့ self-contained example တစ်ခုကို သင်ဖန်တီးနိုင်ခဲ့ပြီဆိုရင်၊ အခု ဒါကို ထည့်သွင်းရမယ့်အချိန်ပါပဲ! ဒီလိုမျိုး သုံးချောင်းထောင် backticks တွေနဲ့ `python` ကို လိုက်ရိုက်ပြီး လိုင်းတစ်ခုကို ရိုက်ထည့်ပါ။ + +``` +```python +``` + +ပြီးရင် သင့် minimal reproducible example ကို paste လုပ်ပြီး သုံးချောင်းထောင် backticks တွေနဲ့ လိုင်းအသစ်တစ်ခု ရိုက်ထည့်ပါ။ ဒါက သင့် code ကို မှန်ကန်စွာ format လုပ်ထားတာကို သေချာစေပါလိမ့်မယ်။ + +reproducible example တစ်ခု ဖန်တီးနိုင်ခြင်းမရှိခဲ့ရင်၊ သင့် issue ကို ဘယ်လိုရရှိခဲ့သလဲဆိုတာကို ရှင်းလင်းတဲ့ အဆင့်တွေနဲ့ ရှင်းပြပါ။ သင် error ရရှိခဲ့တဲ့ Google Colab notebook ရဲ့ link တစ်ခုကိုလည်း ထည့်သွင်းနိုင်ရင် ထည့်သွင်းပေးပါ။ သင်မျှဝေတဲ့ အချက်အလက်များလေ၊ maintainers တွေက သင့်ကို ပိုကောင်းကောင်း ပြန်ကြားနိုင်လေပါပဲ။ + +အခြေအနေအားလုံးမှာ၊ သင်ရရှိနေတဲ့ error message တစ်ခုလုံးကို copy & paste လုပ်သင့်ပါတယ်။ သင် Colab မှာ အလုပ်လုပ်နေတယ်ဆိုရင်၊ stack trace မှာ frames အချို့က အလိုအလျောက် collapsed ဖြစ်နေနိုင်တာကို သတိရပါ၊ ဒါကြောင့် copy မလုပ်ခင် ၎င်းတို့ကို expand လုပ်ထားဖို့ သေချာပါစေ။ code sample နဲ့အတူတူပါပဲ၊ အဲဒီ error message ကို သုံးချောင်းထောင် backticks နှစ်ခုကြားမှာ ထားပါ။ ဒါမှ မှန်ကန်စွာ format လုပ်ထားမှာပါ။ + +### မျှော်လင့်ထားသော လုပ်ဆောင်ချက်ကို ဖော်ပြခြင်း[[describing-the-expected-behavior]] + +သင်ဘာကို မျှော်လင့်ခဲ့သလဲဆိုတာကို စာကြောင်းအနည်းငယ်နဲ့ ရှင်းပြပါ။ ဒါမှ maintainers တွေက ပြဿနာကို အပြည့်အဝ နားလည်နိုင်မှာပါ။ ဒီအပိုင်းက ပုံမှန်အားဖြင့် အတော်လေး ရှင်းလင်းတာကြောင့် စာကြောင်းတစ်ကြောင်းနဲ့ အဆင်ပြေနိုင်ပေမယ့်၊ တချို့ကိစ္စတွေမှာ ပြောစရာတွေ အများကြီး ရှိနိုင်ပါတယ်။ + +## ပြီးရင် ဘာဆက်လုပ်ရမလဲ။[[and-then-what]] + +သင့် issue ကို file လုပ်ပြီးတာနဲ့၊ အားလုံးအဆင်ပြေရဲ့လားဆိုတာကို မြန်မြန်ဆန်ဆန် စစ်ဆေးကြည့်ပါ။ အမှားလုပ်မိခဲ့ရင် issue ကို edit လုပ်နိုင်ပါတယ်၊ ဒါမှမဟုတ် ပြဿနာက အစက သင်ထင်ခဲ့တာနဲ့ ကွဲပြားနေတယ်ဆိုတာ သိလာရင် ခေါင်းစဉ်ကိုတောင် ပြောင်းနိုင်ပါတယ်။ + +အဖြေမရရင် လူတွေကို ping လုပ်နေဖို့ အဓိပ္ပာယ်မရှိပါဘူး။ ရက်အနည်းငယ်ကြာတဲ့အထိ ဘယ်သူမှ မကူညီဘူးဆိုရင်၊ ဘယ်သူမှ သင့်ပြဿနာကို နားမလည်တာ ဖြစ်နိုင်ပါတယ်။ reproducible example ကို ပြန်သွားဖို့ မတွန့်ဆုတ်ပါနဲ့။ ဒါကို ပိုတိုတောင်းပြီး ပိုပြီးတိကျအောင် လုပ်နိုင်မလား။ တစ်ပတ်အတွင်း အဖြေမရရင်၊ အထူးသဖြင့် ပြဿနာနဲ့ ပတ်သက်တဲ့ အချက်အလက်တွေ ပိုမိုထည့်သွင်းဖို့ သင့် issue ကို edit လုပ်ထားခဲ့တယ်ဆိုရင်၊ အကူအညီ တောင်းခံတဲ့ မက်ဆေ့ချ်တစ်ခုကို ယဉ်ကျေးစွာ ချန်ထားခဲ့နိုင်ပါတယ်။ + +## ဝေါဟာရ ရှင်းလင်းချက် (Glossary) + +* **Hugging Face Libraries**: Hugging Face မှ ထုတ်လုပ်ထားသော ဆော့ဖ်ဝဲလ် library များ (ဥပမာ- 🤗 Transformers, 🤗 Datasets, 🤗 Tokenizers, 🤗 Accelerate)။ +* **Open Source Library**: ၎င်း၏ source code ကို အများပြည်သူအား လွတ်လပ်စွာ အသုံးပြု၊ ပြင်ဆင်၊ ဖြန့်ဝေခွင့်ပြုထားသော library။ +* **Bug**: ဆော့ဖ်ဝဲလ်တစ်ခု၏ code ထဲတွင်ရှိသော အမှားတစ်ခုကြောင့် ပရိုဂရမ်သည် မျှော်လင့်ထားသည့်အတိုင်း အလုပ်မလုပ်ခြင်း။ +* **Forums (Hugging Face Forums)**: Hugging Face အသုံးပြုသူများ အချင်းချင်း မေးခွန်းများမေးရန်၊ အဖြေများပေးရန်နှင့် ဆွေးနွေးရန်အတွက် အွန်လိုင်းဖိုရမ်။ +* **Community**: Hugging Face တွင် AI/ML နယ်ပယ်မှ သုံးစွဲသူများ၊ developer များ နှင့် သုတေသီများ စုစည်းထားသော အဖွဲ့အစည်း။ +* **Hugging Face Team**: Hugging Face ကုမ္ပဏီမှ အဖွဲ့သားများ။ +* **Minimal Reproducible Example**: bug တစ်ခုကို ပြန်လည်ထုတ်လုပ်နိုင်ရန် လိုအပ်သော code အနည်းဆုံး အပိုင်းအစ။ ၎င်းသည် ပြဿနာကို လျင်မြန်စွာ ဖော်ထုတ်ပြီး ဖြေရှင်းနိုင်ရန် ကူညီပေးသည်။ +* **Reproducible**: သတ်မှတ်ထားသော code နှင့် data ကို အသုံးပြု၍ တူညီသော ရလဒ်များကို ပြန်လည်ထုတ်လုပ်နိုင်ခြင်း။ +* **External Files/Data**: project အတွင်း၌ ပါဝင်ခြင်းမရှိသော ပြင်ပမှ ဖိုင်များ သို့မဟုတ် ဒေတာများ။ +* **Dummy Values**: စမ်းသပ်ခြင်း သို့မဟုတ် ဥပမာပြခြင်းအတွက် အသုံးပြုသော အစစ်အမှန်မဟုတ်သည့် တန်ဖိုးများ။ +* **🤗 Transformers Repository**: Hugging Face Transformers library ၏ code များနှင့် files များကို သိမ်းဆည်းထားသော GitHub repository။ +* **Self-contained**: ပြင်ပအရာများပေါ်တွင် မှီခိုခြင်းမရှိဘဲ မိမိဘာသာ အလုပ်လုပ်နိုင်သော အရာ။ +* **Bug Reproducer**: bug ကို ပြန်လည်ထုတ်လုပ်ပေးနိုင်သော code အပိုင်းအစ။ +* **Source Code**: ပရိုဂရမ်တစ်ခုကို ရေးသားထားသော လူသားများ ဖတ်ရှုနားလည်နိုင်သည့် code။ +* **Pull Request**: open source project တစ်ခုတွင် code ပြောင်းလဲမှုများကို ပရောဂျက်၏ main codebase ထဲသို့ ထည့်သွင်းရန် အကြံပြုခြင်း။ +* **Maintainers**: open source project တစ်ခုကို စီမံခန့်ခွဲပြီး ထိန်းသိမ်းပေးသူများ။ +* **Issue Template**: GitHub Issues ကဲ့သို့သော platform များတွင် issue တစ်ခု file လုပ်သောအခါ ဖြည့်သွင်းရမည့် အချက်အလက်များအတွက် ပုံစံ။ +* **Repository**: Git version control system ကို အသုံးပြု၍ project files တွေကို ခြေရာခံ၊ စီမံခန့်ခွဲရာတွင် အသုံးပြုသည်။ +* **Open Source Project**: ၎င်းတို့၏ source code ကို အများပြည်သူအား လွတ်လပ်စွာ အသုံးပြု၊ ပြင်ဆင်၊ ဖြန့်ဝေခွင့်ပြုထားသော ဆော့ဖ်ဝဲလ် project များ။ +* **Code of Conduct**: project ၏ အသိုင်းအဝိုင်းအတွင်းရှိ လူများ လိုက်နာရမည့် ကျင့်ဝတ်စည်းကမ်းများ။ +* **`transformers-cli env`**: Hugging Face Transformers CLI (Command Line Interface) မှ environment အချက်အလက်များကို ထုတ်ပေးသော command။ +* **`!` (Exclamation Mark)**: Jupyter/Colab Notebooks များတွင် shell commands များကို run ရန်အတွက် အသုံးပြုသော prefix။ +* **Notebook Cell**: Jupyter Notebook ၏ အစိတ်အပိုင်းတစ်ခုဖြစ်ပြီး code, text သို့မဟုတ် output များကို ထည့်သွင်းနိုင်သည်။ +* **GitHub Handle**: GitHub ပေါ်ရှိ အသုံးပြုသူ၏ username။ +* **Notification**: အသုံးပြုသူတစ်ဦးကို အဖြစ်အပျက်တစ်ခုအကြောင်း အသိပေးခြင်း။ +* **Source Files**: project ၏ source code ပါဝင်သော ဖိုင်များ။ +* **`git blame`**: Git command တစ်ခုဖြစ်ပြီး ဖိုင်တစ်ဖိုင်ရှိ လိုင်းတစ်ခုစီကို နောက်ဆုံးပြောင်းလဲခဲ့သောသူနှင့် အချိန်ကို ပြသသည်။ +* **Backticks (```)**: Markdown တွင် code block များကို ဖော်ပြရန် အသုံးပြုသော အမှတ်အသား။ +* **Google Colab Notebook**: Google မှ ပံ့ပိုးပေးထားသော cloud-based Jupyter Notebook environment တစ်ခုဖြစ်ပြီး Python code များကို web browser မှတစ်ဆင့် run နိုင်စေသည်။ +* **Error Message**: ပရိုဂရမ်တစ်ခုတွင် အမှားတစ်ခုဖြစ်ပွားသောအခါ စနစ်မှ ပြသသော သတင်းစကား။ +* **Stack Trace**: ပရိုဂရမ်တစ်ခုတွင် error ဖြစ်ပွားသောအခါ function ခေါ်ဆိုမှုများ၏ စာရင်းကို ပြသသော မှတ်တမ်း။ +* **Collapsed Frames**: Stack trace တွင် အလိုအလျောက် ဝှက်ထားသော အသေးစိတ်အချက်အလက်များ။ +* **Expected Behavior**: ပရိုဂရမ်သည် သတ်မှတ်ထားသော input ဖြင့် မည်သို့ လုပ်ဆောင်မည်ဟု မျှော်လင့်ထားသော လုပ်ဆောင်ချက်။ +* **Ping**: လူတစ်ဦး သို့မဟုတ် အဖွဲ့တစ်ဖွဲ့ကို အကြောင်းကြားချက် ပို့ခြင်း သို့မဟုတ် အာရုံစိုက်မိစေရန် လုပ်ဆောင်ခြင်း။ \ No newline at end of file diff --git a/chapters/my/chapter8/6.mdx b/chapters/my/chapter8/6.mdx new file mode 100644 index 000000000..e3a59e7fc --- /dev/null +++ b/chapters/my/chapter8/6.mdx @@ -0,0 +1,12 @@ +# အပိုင်း ၂ ပြီးဆုံးပါပြီ![[part-2-completed]] + + + +ဂုဏ်ယူပါတယ်။ သင်ဟာ သင်တန်းရဲ့ ဒုတိယပိုင်းကို အောင်မြင်စွာ ပြီးဆုံးခဲ့ပါပြီ။ ကျွန်တော်တို့ တတိယပိုင်းကို အစွမ်းကုန် လုပ်ဆောင်နေပါတယ်၊ ဒါကြောင့် ထွက်ရှိမယ့်အချိန်ကို လက်လွတ်မခံရအောင် ကျွန်တော်တို့ရဲ့ [newsletter](https://huggingface.curated.co/) ကို subscribe လုပ်ထားပါ။ + +သင်ဟာ အခုဆိုရင် NLP tasks အမျိုးမျိုးကို ကိုင်တွယ်ဖြေရှင်းနိုင်ပြီး၊ အဲဒီအပေါ်မှာ model တစ်ခုကို fine-tune ဒါမှမဟုတ် pretrain လုပ်နိုင်ပါပြီ။ သင်ရဲ့ ရလဒ်တွေကို [Model Hub](https://huggingface.co/models) မှာ community နဲ့ မျှဝေဖို့ မမေ့ပါနဲ့။ + +သင်ရရှိခဲ့တဲ့ ဗဟုသုတတွေနဲ့ ဘာတွေတည်ဆောက်မလဲဆိုတာကို ကျွန်တော်တို့ စောင့်မျှော်နေပါတယ်။ \ No newline at end of file diff --git a/chapters/my/chapter8/7.mdx b/chapters/my/chapter8/7.mdx new file mode 100644 index 000000000..3d8e75352 --- /dev/null +++ b/chapters/my/chapter8/7.mdx @@ -0,0 +1,257 @@ + + +# အခန်း (၈) ဆိုင်ရာ မေးခွန်းများ[[end-of-chapter-quiz]] + + + +ဒီအခန်းမှာ သင်ယူခဲ့တာတွေကို စစ်ဆေးကြည့်ရအောင်။ + +### ၁။ Python traceback ကို ဘယ်အစီအစဥ်အတိုင်း ဖတ်သင့်သလဲ။ + + + +### ၂။ Minimal reproducible example ဆိုတာ ဘာလဲ။ + + + +### ၃။ အောက်ပါ code ကို run ဖို့ ကြိုးစားပြီး error ထွက်တယ်လို့ ယူဆပါစို့- + +```py +from transformers import GPT3ForSequenceClassification + +# ImportError: cannot import name 'GPT3ForSequenceClassification' from 'transformers' (/Users/lewtun/miniconda3/envs/huggingface/lib/python3.8/site-packages/transformers/__init__.py) +# --------------------------------------------------------------------------- +# ImportError Traceback (most recent call last) +# /var/folders/28/k4cy5q7s2hs92xq7_h89_vgm0000gn/T/ipykernel_30848/333858878.py in +# ----> 1 from transformers import GPT3ForSequenceClassification + +# ImportError: cannot import name 'GPT3ForSequenceClassification' from 'transformers' (/Users/lewtun/miniconda3/envs/huggingface/lib/python3.8/site-packages/transformers/__init__.py) +``` + +အကူအညီတောင်းဖို့အတွက် forum topic ရဲ့ ခေါင်းစဉ်တစ်ခုအတွက် ဘယ်အရာက ကောင်းမွန်တဲ့ ရွေးချယ်မှု ဖြစ်နိုင်မလဲ။ + +ImportError: cannot import name 'GPT3ForSequenceClassification' from 'transformers' (/Users/lewtun/miniconda3/envs/huggingface/lib/python3.8/site-packages/transformers/__init__.py)", + explain: "traceback ရဲ့ နောက်ဆုံး line ကို ထည့်သွင်းတာက ဖော်ပြနိုင်ပေမယ့်၊ ဒါက topic ရဲ့ main body အတွက် ပိုသင့်တော်ပါတယ်။ ထပ်ကြိုးစားပါ။" + }, + { + text: "from transformers import GPT3ForSequenceClassification နဲ့ ပြဿနာ", + explain: "ထပ်ကြိုးစားပါ -- ဒါက အသုံးဝင်တဲ့ အချက်အလက်တွေ ပေးပေမယ့်၊ စာသားရဲ့ main body အတွက် ပိုကောင်းပါတယ်။", + }, + { + text: "GPT3ForSequenceClassification ကို ဘာကြောင့် import လုပ်လို့ မရတာလဲ။", + explain: "ကောင်းမွန်တဲ့ ရွေးချယ်မှုပါ! ဒီခေါင်းစဉ်က ကျစ်လစ်ပြီး စာဖတ်သူကို ဘာမှားနေနိုင်သလဲဆိုတဲ့ အရိပ်အမြွက် ပေးပါတယ် (ဆိုလိုသည်မှာ GPT-3 ကို 🤗 Transformers မှာ ထောက်ပံ့မပေးထားပါဘူး)။", + correct: true + }, + { + text: "GPT-3 ကို 🤗 Transformers မှာ ထောက်ပံ့ပေးထားတာလား။", + explain: "ကောင်းပါတယ်။ မေးခွန်းတွေကို topic titles အဖြစ် အသုံးပြုတာက community ကို ပြဿနာကို ဆက်သွယ်ဖို့ ကောင်းမွန်တဲ့ နည်းလမ်းတစ်ခုပါပဲ။", + correct: true + } + ]} +/> + +### ၄။ သင် `trainer.train()` ကို run ဖို့ ကြိုးစားပြီး error က ဘယ်ကလာတာလဲဆိုတာ တိတိကျကျ မပြောပြတဲ့ cryptic error တစ်ခုနဲ့ ရင်ဆိုင်ရတယ်လို့ ယူဆပါ။ သင့်ရဲ့ training pipeline မှာ error တွေအတွက် ပထမဆုံး ဘယ်နေရာမှာ ရှာသင့်သလဲ။ + + + +### ၅။ CUDA error ကို debug လုပ်ဖို့ အကောင်းဆုံးနည်းလမ်းက ဘာလဲ။ + + + +### ၆။ GitHub ပေါ်က issue တစ်ခုကို ပြင်ဆင်ဖို့ အကောင်းဆုံးနည်းလမ်းက ဘာလဲ။ + + + +### ၇။ batch တစ်ခုတည်းကို overfitting လုပ်တာက ဘာကြောင့် ကောင်းမွန်တဲ့ debugging နည်းလမ်းတစ်ခု ဖြစ်တာလဲ။ + + + +### ၈။ 🤗 Transformers repo မှာ issue အသစ်တစ်ခု ဖန်တီးတဲ့အခါ သင့် compute environment အကြောင်း အသေးစိတ်အချက်အလက်တွေကို `transformers-cli env` နဲ့ ထည့်သွင်းတာက ဘာကြောင့် ကောင်းမွန်တဲ့ အကြံဥာဏ်ဖြစ်တာလဲ။ + + + +## ဝေါဟာရ ရှင်းလင်းချက် (Glossary) + +* **Python Traceback**: Python ပရိုဂရမ်တစ်ခု အလုပ်လုပ်နေစဉ် error တစ်ခုဖြစ်ပွားသောအခါ၊ error ဖြစ်ပွားရာ နေရာနှင့် ၎င်း၏ ခေါ်ဆိုမှုမှတ်တမ်း (call stack) ကို ပြသသော အစီရင်ခံစာ။ +* **Exception**: ပရိုဂရမ်တစ်ခု အလုပ်လုပ်နေစဉ် ဖြစ်ပေါ်လာသော ပြဿနာတစ်ခုကြောင့် ၎င်းသည် ပုံမှန်အတိုင်း ဆက်လက်လုပ်ဆောင်နိုင်ခြင်းမရှိခြင်း။ +* **Programming Languages**: ကွန်ပျူတာများကို ညွှန်ကြားချက်များ ပေးရန်အတွက် အသုံးပြုသော ဘာသာစကားများ (ဥပမာ- Python, Java, C++)။ +* **Minimal Reproducible Example (MRE)**: ပြဿနာတစ်ခုကို ပြန်လည်ဖန်တီးရန်အတွက် လိုအပ်သော အနည်းဆုံး code ပမာဏပါဝင်သည့် သီးခြားနှင့် ကျစ်လစ်သော code အပိုင်းအစ။ +* **Transformer Architecture**: Natural Language Processing (NLP) မှာ အောင်မြင်မှုများစွာရရှိခဲ့တဲ့ deep learning architecture တစ်မျိုးပါ။ +* **External Dependencies**: project တစ်ခု အလုပ်လုပ်ရန်အတွက် လိုအပ်သော အခြား library များ၊ modules များ သို့မဟုတ် files များ။ +* **Maintainers**: ဆော့ဖ်ဝဲလ် project တစ်ခုကို ထိန်းသိမ်းစောင့်ရှောက်ပြီး စီမံခန့်ခွဲသူများ။ +* **Screenshot**: ကွန်ပျူတာမျက်နှာပြင်ပေါ်ရှိ မြင်ကွင်းတစ်ခု၏ ပုံရိပ်။ +* **Error**: ပရိုဂရမ်တစ်ခု အလုပ်လုပ်နေစဉ် ဖြစ်ပေါ်လာသော ပြဿနာတစ်ခုကြောင့် ၎င်းသည် ပုံမှန်အတိုင်း ဆက်လက်လုပ်ဆောင်နိုင်ခြင်းမရှိခြင်း။ +* **Issue**: ဆော့ဖ်ဝဲလ် project တစ်ခုတွင် တွေ့ရှိရသော bug, feature request, သို့မဟုတ် ပြဿနာတစ်ခု။ ၎င်းကို GitHub Issues ကဲ့သို့သော platform များတွင် မှတ်တမ်းတင်ထားသည်။ +* **Google Colab Notebook**: Google မှ ပံ့ပိုးပေးထားသော cloud-based Jupyter Notebook environment တစ်ခုဖြစ်ပြီး Python code များကို web browser မှတစ်ဆင့် run နိုင်စေသည်။ +* **`ImportError`**: Python တွင် module တစ်ခု သို့မဟုတ် object တစ်ခုကို import လုပ်ရာတွင် ဖြစ်ပေါ်သော error။ +* **`GPT3ForSequenceClassification`**: Hugging Face Transformers library တွင် မရှိသော GPT-3 ၏ sequence classification version အတွက် အမည်မှား။ (GPT-3 သည် open source မဟုတ်သေးပါ)။ +* **`transformers` (Library)**: Hugging Face Transformers library ကို ရည်ညွှန်းသည်။ +* **Forum Topic**: အွန်လိုင်းဖိုရမ်တစ်ခုရှိ သီးခြားခေါင်းစဉ်။ +* **Concise**: တိုတိုတုတ်တုတ်နှင့် ရှင်းရှင်းလင်းလင်း။ +* **`trainer.train()`**: Hugging Face Trainer API ကို အသုံးပြုပြီး model ကို လေ့ကျင့်သော method။ +* **Cryptic Error**: အဓိပ္ပာယ်ဖော်ရခက်ခဲသော သို့မဟုတ် ရှင်းလင်းစွာ မဖော်ပြထားသော error။ +* **Training Pipeline**: Machine Learning မော်ဒယ်တစ်ခုကို data preprocessing မှစ၍ model training, evaluation အထိ ပါဝင်သော အဆင့်များစွာရှိသည့် လုပ်ငန်းစဉ်။ +* **Optimization Step**: Training လုပ်ငန်းစဉ်တွင် model ၏ parameters များကို ပြောင်းလဲခြင်းဖြင့် model စွမ်းဆောင်ရည်ကို မြှင့်တင်သည့် အဆင့်။ +* **Gradients**: Model ၏ parameters များကို update လုပ်ရန်အတွက် အသုံးပြုသော loss function ၏ ဆင်းသက်မှုများ။ +* **Backpropagation**: Neural networks များတွင် weights များကို update လုပ်ရန် gradients များကို တွက်ချက်သည့် algorithm။ +* **Optimizer**: Model ၏ weights များကို update လုပ်ရန် အသုံးပြုသော algorithm (ဥပမာ- AdamW)။ +* **Evaluation Step**: Model ၏ စွမ်းဆောင်ရည်ကို တိုင်းတာသည့် အဆင့်။ +* **Epoch**: Training dataset တစ်ခုလုံးကို model က တစ်ကြိမ် လေ့ကျင့်ပြီးစီးခြင်း။ +* **Datasets**: AI မော်ဒယ်တွေ လေ့ကျင့်ဖို့အတွက် အသုံးပြုတဲ့ ဒေတာအစုအဝေးတစ်ခုပါ။ +* **Encode**: ဒေတာများကို ကွန်ပျူတာက နားလည်နိုင်သော ပုံစံအဖြစ် ပြောင်းလဲခြင်း။ +* **Features**: Dataset အတွင်းရှိ attributes များ သို့မဟုတ် ကဏ္ဍများ။ +* **Dataloaders**: Dataset ကနေ data တွေကို batch အလိုက် load လုပ်ပေးတဲ့ PyTorch (သို့မဟုတ် TensorFlow) utility class။ +* **CUDA Error**: NVIDIA GPU များကို အသုံးပြုသည့်အခါ ဖြစ်ပေါ်တတ်သော error (Compute Unified Device Architecture)။ +* **Uninformative**: အချက်အလက်မပြည့်စုံခြင်း။ +* **Execute**: Program တစ်ခုကို run ခြင်း။ +* **CPU (Central Processing Unit)**: ကွန်ပျူတာ၏ ပင်မ processor။ +* **Asynchronous**: လုပ်ဆောင်ချက်တစ်ခု ပြီးဆုံးရန် စောင့်ဆိုင်းစရာမလိုဘဲ အခြားလုပ်ဆောင်ချက်များကို တစ်ပြိုင်နက်တည်း လုပ်ဆောင်နိုင်ခြင်း။ +* **Batch Size**: training လုပ်ငန်းစဉ်တစ်ခုစီတွင် model သို့ ပေးပို့သော input samples အရေအတွက်။ +* **CUDA Out-of-Memory Errors**: GPU memory ပြည့်သွား၍ ထပ်မံ data load လုပ်၍မရတော့သည့် error။ +* **Jupyter Kernel**: Jupyter Notebook တွင် code များကို execute လုပ်သော အင်ဂျင်။ +* **GitHub**: Version control အတွက် Git ကို အသုံးပြုသည့် web-based platform တစ်ခုဖြစ်ပြီး code များနှင့် project များကို host လုပ်သည်။ +* **Source Code**: ပရိုဂရမ်တစ်ခုကို လူသားများဖတ်နိုင်သော programming language ဖြင့် ရေးသားထားသော code။ +* **Pull Request**: Git repository တွင် မိမိ၏ ပြောင်းလဲမှုများကို main branch သို့ ပေါင်းစည်းရန် တောင်းဆိုခြင်း။ +* **Overfitting**: Model တစ်ခုသည် training data ကို အလွန်အမင်း ကောင်းစွာ မှတ်မိနေပြီး၊ new data တွင် စွမ်းဆောင်ရည် နည်းပါးခြင်း။ +* **Generalize**: Model တစ်ခုသည် training data မှ သင်ယူထားသော ပုံစံများကို new, unseen data တွင် ကောင်းစွာ အသုံးချနိုင်ခြင်း။ +* **Loss (Function)**: Model ၏ ခန့်မှန်းချက်များနှင့် အမှန်တကယ် labels များကြား ကွာခြားမှုကို တိုင်းတာသော တန်ဖိုး။ +* **Tensor Shapes**: tensors (multi-dimensional arrays) များ၏ dimensions များ။ +* **Compute Environment**: ကွန်ပျူတာ system ၏ hardware (CPU, GPU) နှင့် software (operating system, library versions) ဖွဲ့စည်းမှု။ +* **`transformers-cli env`**: Hugging Face Transformers CLI (Command Line Interface) မှ သုံးစွဲသူ၏ compute environment အကြောင်း အချက်အလက်များကို ထုတ်ပေးသော command။ +* **🤗 Transformers Repo**: Hugging Face Transformers library ၏ GitHub repository။ +* **Major Version**: ဆော့ဖ်ဝဲလ်တစ်ခု၏ အဓိက version ပြောင်းလဲမှု (ဥပမာ- v3 မှ v4)။ +* **API (Application Programming Interface)**: ဆော့ဖ်ဝဲလ် နှစ်ခုကြား အပြန်အလှန် ချိတ်ဆက်ဆောင်ရွက်နိုင်ရန် လမ်းကြောင်းဖွင့်ပေးသော အစုအဝေး (set of rules) များ။ +* **Operating System (OS)**: ကွန်ပျူတာ hardware နှင့် software အရင်းအမြစ်များကို စီမံခန့်ခွဲသော system software (ဥပမာ- Windows, macOS, Linux)။ \ No newline at end of file