diff --git a/chapters/my/_toctree.yml b/chapters/my/_toctree.yml index ad7896471..fef5b92ec 100644 --- a/chapters/my/_toctree.yml +++ b/chapters/my/_toctree.yml @@ -29,27 +29,27 @@ title: အသိအမှတ်ပြု စာမေးပွဲ quiz: 1 -# - title: 2. Using 🤗 Transformers -# sections: -# - local: chapter2/1 -# title: Introduction -# - local: chapter2/2 -# title: Behind the pipeline -# - local: chapter2/3 -# title: Models -# - local: chapter2/4 -# title: Tokenizers -# - local: chapter2/5 -# title: Handling multiple sequences -# - local: chapter2/6 -# title: Putting it all together -# - local: chapter2/7 -# title: Basic usage completed! -# - local: chapter2/8 -# title: Optimized Inference Deployment -# - local: chapter2/9 -# title: End-of-chapter quiz -# quiz: 2 +- title: 2. 🤗 Transformers ကို အသုံးပြုခြင်း + sections: + - local: chapter2/1 + title: နိဒါန်း + - local: chapter2/2 + title: Pipeline နောက်ကွယ်မှ အကြောင်းအရာများ + - local: chapter2/3 + title: Models + - local: chapter2/4 + title: Tokenizers + - local: chapter2/5 + title: Sequence များစွာကို ကိုင်တွယ်ခြင်း + - local: chapter2/6 + title: အားလုံးကို ပေါင်းစပ်ခြင်း + - local: chapter2/7 + title: အခြေခံ အသုံးပြုမှု ပြီးဆုံးပါပြီ! + - local: chapter2/8 + title: Optimization လုပ်ထားသော Inference Deployment + - local: chapter2/9 + title: အခန်းပြီးဆုံးခြင်း စစ်ဆေးမှု + quiz: 2 # - title: 3. Fine-tuning a pretrained model # sections: diff --git a/chapters/my/chapter2/1.mdx b/chapters/my/chapter2/1.mdx new file mode 100644 index 000000000..a6111d6e1 --- /dev/null +++ b/chapters/my/chapter2/1.mdx @@ -0,0 +1,54 @@ +# နိဒါန်း[[introduction]] + + + +[Chapter 1](/course/chapter1) မှာ သင်တွေ့ခဲ့ရသလို Transformer မော်ဒယ်တွေဟာ များသောအားဖြင့် အရွယ်အစား အလွန်ကြီးမားပါတယ်။ Parameters သန်းပေါင်းများစွာကနေ ဘီလီယံပေါင်းများစွာအထိ ရှိတာကြောင့် ဒီမော်ဒယ်တွေကို လေ့ကျင့်တာနဲ့ အသုံးပြုတာ (deploy) ဟာ ရှုပ်ထွေးတဲ့ လုပ်ငန်းစဉ်တစ်ခု ဖြစ်ပါတယ်။ ဒီအပြင်၊ မော်ဒယ်အသစ်တွေ နေ့တိုင်းနီးပါး ထွက်ပေါ်လာပြီး တစ်ခုချင်းစီမှာ သူ့ရဲ့ကိုယ်ပိုင် implement လုပ်ပုံတွေရှိတာကြောင့် ဒါတွေကို အားလုံး စမ်းသပ်ကြည့်ဖို့က မလွယ်ပါဘူး။ + +🤗 Transformers library ကို ဒီပြဿနာကို ဖြေရှင်းဖို့အတွက် ဖန်တီးခဲ့တာပါ။ သူ့ရဲ့ ရည်ရွယ်ချက်ကတော့ Transformer မော်ဒယ်တိုင်းကို load လုပ်နိုင်၊ train လုပ်နိုင်ပြီး save လုပ်နိုင်တဲ့ API တစ်ခုတည်းကို ပံ့ပိုးပေးဖို့ပါပဲ။ library ရဲ့ အဓိကအင်္ဂါရပ်တွေကတော့- + +- **အသုံးပြုရလွယ်ကူမှု**: state-of-the-art Natural Language Processing (NLP) မော်ဒယ်တစ်ခုကို inference အတွက် download လုပ်တာ၊ load လုပ်တာနဲ့ အသုံးပြုတာကို code နှစ်ကြောင်းတည်းနဲ့ လုပ်ဆောင်နိုင်ပါတယ်။ +- **ပြောင်းလွယ်ပြင်လွယ်မှု (Flexibility)**: မူရင်းအားဖြင့် မော်ဒယ်အားလုံးဟာ ရိုးရှင်းတဲ့ PyTorch `nn.Module` classes တွေဖြစ်ပြီး ၎င်းတို့ရဲ့ သက်ဆိုင်ရာ machine learning (ML) frameworks တွေထဲက တခြားမော်ဒယ်တွေလိုမျိုး ကိုင်တွယ်နိုင်ပါတယ်။ +- **ရိုးရှင်းမှု (Simplicity)**: library တစ်လျှောက်လုံးမှာ abstraction တွေဟာ သိပ်မရှိပါဘူး။ "All in one file" ဆိုတာက အဓိကသဘောတရားတစ်ခုပါ- မော်ဒယ်တစ်ခုရဲ့ forward pass ကို file တစ်ခုတည်းမှာ အပြည့်အစုံ သတ်မှတ်ထားတာကြောင့် code ကို နားလည်ရလွယ်ကူပြီး ပြင်ဆင်ရ လွယ်ကူပါတယ်။ + +ဒီနောက်ဆုံးအင်္ဂါရပ်က 🤗 Transformers ကို အခြားသော ML library တွေနဲ့ အတော်လေး ကွဲပြားစေပါတယ်။ မော်ဒယ်တွေကို file တွေတစ်လျှောက် မျှဝေထားတဲ့ modules တွေနဲ့ တည်ဆောက်ထားတာ မဟုတ်ပါဘူး။ အဲဒီအစား မော်ဒယ်တစ်ခုစီမှာ သူ့ကိုယ်ပိုင် layers တွေ ရှိပါတယ်။ ဒါက မော်ဒယ်တွေကို ပိုမိုနားလည်ရလွယ်ကူပြီး လက်လှမ်းမီစေတဲ့အပြင်၊ မော်ဒယ်တစ်ခုပေါ်မှာ အခြားမော်ဒယ်တွေကို မထိခိုက်စေဘဲ အလွယ်တကူ စမ်းသပ်နိုင်စေပါတယ်။ + +ဒီအခန်းကို end-to-end ဥပမာတစ်ခုနဲ့ စတင်ပါမယ်။ ဒီဥပမာမှာ ကျွန်တော်တို့ဟာ [Chapter 1](/course/chapter1) မှာ မိတ်ဆက်ခဲ့တဲ့ `pipeline()` function ကို ပြန်လည်ဖန်တီးဖို့အတွက် မော်ဒယ်တစ်ခုနဲ့ tokenizer တစ်ခုကို ပေါင်းပြီး အသုံးပြုပါမယ်။ နောက်တစ်ဆင့်အနေနဲ့ model API ကို ဆွေးနွေးပါမယ်- မော်ဒယ်နဲ့ configuration classes တွေထဲကို နက်ရှိုင်းစွာ လေ့လာပြီး၊ မော်ဒယ်တစ်ခုကို ဘယ်လို load လုပ်ရမယ်၊ ပြီးတော့ ဂဏန်းဆိုင်ရာ inputs တွေကို output predictions တွေအဖြစ် ဘယ်လိုလုပ်ဆောင်တယ်ဆိုတာကို သင်ပြပါမယ်။ + +အဲဒီနောက် `pipeline()` function ရဲ့ အခြားအဓိက အစိတ်အပိုင်းဖြစ်တဲ့ tokenizer API ကို ကြည့်ပါမယ်။ Tokenizers တွေက ပထမဆုံးနဲ့ နောက်ဆုံး လုပ်ဆောင်မှုအဆင့်တွေကို ကိုင်တွယ်ပေးပြီး၊ စာသားကနေ neural network အတွက် ဂဏန်းဆိုင်ရာ inputs တွေအဖြစ် ပြောင်းလဲခြင်းနဲ့ လိုအပ်တဲ့အခါ စာသားအဖြစ် ပြန်ပြောင်းလဲခြင်းတို့ကို လုပ်ဆောင်ပေးပါတယ်။ နောက်ဆုံးအနေနဲ့၊ မော်ဒယ်တစ်ခုကနေတဆင့် စာကြောင်းများစွာကို batch အဖြစ် ပေးပို့တာကို ဘယ်လိုကိုင်တွယ်ရမလဲဆိုတာ သင်ပြပြီး၊ အဆင့်မြင့် `tokenizer()` function ကို ပိုမိုနက်ရှိုင်းစွာ လေ့လာခြင်းဖြင့် အားလုံးကို အပြီးသတ်ပါမယ်။ + + +⚠️ Model Hub နဲ့ 🤗 Transformers မှာ ရရှိနိုင်တဲ့ အင်္ဂါရပ်အားလုံးကို ရယူဖို့အတွက် [account တစ်ခု ဖန်တီး](https://huggingface.co/join) ဖို့ ကျွန်တော်တို့ အကြံပြုပါတယ်။ + + +--- + +## ဝေါဟာရ ရှင်းလင်းချက် (Glossary) + +* **Transformer Models**: Natural Language Processing (NLP) မှာ အောင်မြင်မှုများစွာရရှိခဲ့တဲ့ deep learning architecture တစ်မျိုးပါ။ ၎င်းတို့ဟာ စာသားတွေထဲက စကားလုံးတွေရဲ့ ဆက်နွယ်မှုတွေကို "attention mechanism" သုံးပြီး နားလည်အောင် သင်ကြားပေးပါတယ်။ +* **Parameters**: Machine Learning မော်ဒယ်တစ်ခု၏ သင်ယူနိုင်သော အစိတ်အပိုင်းများ။ ၎င်းတို့သည် လေ့ကျင့်နေစဉ်အတွင်း ဒေတာများမှ ပုံစံများကို သင်ယူကာ ချိန်ညှိပေးသည်။ +* **Deploying**: Machine Learning မော်ဒယ်တစ်ခုကို အမှန်တကယ် အသုံးပြုနိုင်သော စနစ် သို့မဟုတ် environment တစ်ခုထဲသို့ ထည့်သွင်းခြင်း။ +* **🤗 Transformers Library**: Hugging Face က ထုတ်လုပ်ထားတဲ့ library တစ်ခုဖြစ်ပြီး Transformer မော်ဒယ်တွေကို အသုံးပြုပြီး Natural Language Processing (NLP), computer vision, audio processing စတဲ့ နယ်ပယ်တွေမှာ အဆင့်မြင့် AI မော်ဒယ်တွေကို တည်ဆောက်ပြီး အသုံးပြုနိုင်စေပါတယ်။ +* **API (Application Programming Interface)**: ဆော့ဖ်ဝဲလ် နှစ်ခုကြား အပြန်အလှန် ချိတ်ဆက်ဆောင်ရွက်နိုင်ရန် လမ်းကြောင်းဖွင့်ပေးသော အစုအဝေး (set of rules) များ။ +* **State-of-the-art (SOTA)**: လက်ရှိအချိန်တွင် အကောင်းဆုံး သို့မဟုတ် အဆင့်မြင့်ဆုံး စွမ်းဆောင်ရည်ကို ပြသနိုင်သော နည်းပညာ သို့မဟုတ် မော်ဒယ်။ +* **NLP (Natural Language Processing)**: ကွန်ပျူတာတွေ လူသားဘာသာစကားကို နားလည်၊ အဓိပ္ပာယ်ဖော်ပြီး၊ ဖန်တီးနိုင်အောင် လုပ်ဆောင်ပေးတဲ့ Artificial Intelligence (AI) ရဲ့ နယ်ပယ်ခွဲတစ်ခု ဖြစ်ပါတယ်။ +* **Inference**: လေ့ကျင့်ပြီးသား Artificial Intelligence (AI) မော်ဒယ်တစ်ခုကို အသုံးပြုပြီး input data ကနေ ခန့်မှန်းချက်တွေ ဒါမှမဟုတ် output တွေကို ထုတ်လုပ်တဲ့ လုပ်ငန်းစဉ်။ +* **Flexibility**: ပြောင်းလွယ်ပြင်လွယ်ရှိခြင်း၊ အခြေအနေအမျိုးမျိုးနဲ့ လိုက်လျောညီထွေစွာ အသုံးပြုနိုင်ခြင်း။ +* **PyTorch `nn.Module` classes**: PyTorch deep learning framework မှာ Neural Network layers တွေနဲ့ models တွေကို တည်ဆောက်ဖို့အတွက် အသုံးပြုတဲ့ အခြေခံ class တွေ။ +* **Machine Learning (ML) Frameworks**: Machine learning မော်ဒယ်များကို တည်ဆောက်ရန်၊ လေ့ကျင့်ရန်နှင့် အသုံးပြုရန်အတွက် ကိရိယာများနှင့် library များ စုစည်းမှု (ဥပမာ - PyTorch, TensorFlow)။ +* **Abstractions**: ကွန်ပျူတာပရိုဂရမ်းမင်းတွင် ရှုပ်ထွေးသောအသေးစိတ်အချက်အလက်များကို ဝှက်ထားပြီး အရေးကြီးသော အချက်များကိုသာ ပြသခြင်း။ +* **Forward Pass**: Neural Network တစ်ခုတွင် input data ကို ယူပြီး network layers များကို ဖြတ်သန်းကာ output prediction ကို ထုတ်လုပ်သည့် လုပ်ငန်းစဉ်။ +* **End-to-end Example**: စနစ်တစ်ခု၏ စတင်ခြင်းမှ အဆုံးအထိ အပြည့်အစုံ ပြသထားသော ဥပမာ။ +* **`pipeline()` function**: Hugging Face Transformers library မှာ ပါဝင်တဲ့ လုပ်ဆောင်ချက်တစ်ခုဖြစ်ပြီး မော်ဒယ်တွေကို သီးခြားလုပ်ငန်းတာဝန်များ (ဥပမာ- စာသားခွဲခြားသတ်မှတ်ခြင်း၊ စာသားထုတ်လုပ်ခြင်း) အတွက် အသုံးပြုရလွယ်ကူအောင် ပြုလုပ်ပေးပါတယ်။ +* **Tokenizer**: စာသား (သို့မဟုတ် အခြားဒေတာ) ကို AI မော်ဒယ်များ စီမံဆောင်ရွက်နိုင်ရန် tokens တွေအဖြစ် ပိုင်းခြားပေးသည့် ကိရိယာ သို့မဟုတ် လုပ်ငန်းစဉ်။ +* **Model API**: မော်ဒယ်တစ်ခုကို ပရိုဂရမ်ကနေ ဘယ်လို ဝင်ရောက်အသုံးပြုနိုင်မလဲဆိုတာကို သတ်မှတ်ပေးတဲ့ interface။ +* **Configuration Classes**: Transformer မော်ဒယ်တစ်ခု၏ architecture နှင့် hyperparameters များကို သတ်မှတ်ပေးသော Python classes များ။ +* **Numerical Inputs**: ကွန်ပျူတာစနစ်များက လုပ်ဆောင်နိုင်သော ဂဏန်းပုံစံဖြင့် ဖော်ပြထားသော အချက်အလက်များ။ +* **Output Predictions**: မော်ဒယ်က input ကို အခြေခံပြီး ခန့်မှန်းထုတ်ပေးသော ရလဒ်များ။ +* **Tokenizer API**: Tokenizer တစ်ခုကို ပရိုဂရမ်ကနေ ဘယ်လို ဝင်ရောက်အသုံးပြုနိုင်မလဲဆိုတာကို သတ်မှတ်ပေးတဲ့ interface။ +* **Neural Network**: လူသားဦးနှောက်၏ လုပ်ဆောင်မှုပုံစံကို အတုယူထားသော ကွန်ပျူတာစနစ်များ။ +* **Batch**: မော်ဒယ်တစ်ခုက တစ်ပြိုင်နက်တည်း လုပ်ဆောင်ရန်အတွက် စုစည်းထားသော inputs အများအပြား။ +* **Model Hub**: Hugging Face ပေါ်ရှိ pre-trained model များနှင့် datasets များကို ရှာဖွေ၊ မျှဝေပြီး အသုံးပြုနိုင်သော online platform။ +* **Hugging Face Account**: Hugging Face ပလက်ဖောင်းပေါ်ရှိ သုံးစွဲသူအကောင့်။ ၎င်းသည် မော်ဒယ်များ၊ datasets များနှင့် အခြားအရင်းအမြစ်များကို ဝင်ရောက်ကြည့်ရှုရန် ခွင့်ပြုသည်။ \ No newline at end of file diff --git a/chapters/my/chapter2/2.mdx b/chapters/my/chapter2/2.mdx new file mode 100644 index 000000000..8157d6ae1 --- /dev/null +++ b/chapters/my/chapter2/2.mdx @@ -0,0 +1,292 @@ + + +# Pipeline နောက်ကွယ်မှ အကြောင်းအရာများ[[behind-the-pipeline]] + + + + + +[Chapter 1](/course/chapter1) မှာ အောက်ပါ code ကို run တဲ့အခါ ဘာတွေဖြစ်ပျက်သွားလဲဆိုတာကို ကြည့်ခြင်းဖြင့် ဥပမာတစ်ခုနဲ့ စလိုက်ရအောင်...။ + +```python +from transformers import pipeline + +classifier = pipeline("sentiment-analysis") +classifier( + [ + "I've been waiting for a HuggingFace course my whole life.", + "I hate this so much!", + ] +) +``` + +အောက်ပါရလဒ်ကို ရရှိခဲ့ပါတယ်။ + +```python out +[{'label': 'POSITIVE', 'score': 0.9598047137260437}, + {'label': 'NEGATIVE', 'score': 0.9994558095932007}] +``` + +[Chapter 1](/course/chapter1) မှာ ကျွန်တော်တို့ တွေ့ခဲ့ရသလို၊ ဒီ pipeline ဟာ အဆင့်သုံးဆင့်ကို ပေါင်းစပ်ထားပါတယ်၊ preprocessing လုပ်ခြင်း၊ model ကနေတဆင့် inputs တွေကို ပေးပို့ခြင်း၊ နဲ့ postprocessing လုပ်ခြင်းတို့ ဖြစ်ပါတယ်။ + +
+The full NLP pipeline: tokenization of text, conversion to IDs, and inference through the Transformer model and the model head. + +
+ +ဒါတွေကို အမြန်ဆုံး တစ်ခုချင်းစီ လေ့လာကြည့်ရအောင်။ + +## Tokenizer ဖြင့် Preprocessing ပြုလုပ်ခြင်း[[preprocessing-with-a-tokenizer]] + +အခြား neural network များကဲ့သို့ Transformer မော်ဒယ်များသည် raw text များကို တိုက်ရိုက်လုပ်ဆောင်၍ မရပါ။ ထို့ကြောင့် ကျွန်တော်တို့ pipeline ၏ ပထမအဆင့်မှာ text inputs များကို မော်ဒယ်နားလည်နိုင်သော ဂဏန်းများအဖြစ် ပြောင်းလဲခြင်းဖြစ်သည်။ ၎င်းကို ပြုလုပ်ရန် ကျွန်တော်တို့သည် *tokenizer* ကို အသုံးပြုပါသည်။ ၎င်းသည် အောက်ပါတို့ကို လုပ်ဆောင်ရန် တာဝန်ရှိသည်- + +- input ကို *tokens* ဟုခေါ်သော စကားလုံးများ၊ subwords များ သို့မဟုတ် သင်္ကေတများ (ဥပမာ- ပုဒ်ဖြတ်သံ) အဖြစ် ပိုင်းခြားခြင်း +- token တစ်ခုစီကို integer တစ်ခုသို့ တွဲချိတ်ခြင်း +- မော်ဒယ်အတွက် အသုံးဝင်နိုင်သော အပို inputs များကို ထည့်သွင်းခြင်း + +ဒီ preprocessing အားလုံးကို မော်ဒယ်ကို pre-trained လုပ်ခဲ့စဉ်က အတိအကျလုပ်ခဲ့တဲ့ နည်းလမ်းအတိုင်း ပြုလုပ်ဖို့ လိုအပ်ပါတယ်။ ဒါကြောင့် ကျွန်တော်တို့ အရင်ဆုံး [Model Hub](https://huggingface.co/models) ကနေ အဲဒီအချက်အလက်တွေကို download လုပ်ဖို့ လိုပါတယ်။ ဒါကို လုပ်ဖို့အတွက် `AutoTokenizer` class နဲ့ သူ့ရဲ့ `from_pretrained()` method ကို ကျွန်တော်တို့ အသုံးပြုပါတယ်။ ကျွန်တော်တို့ model ရဲ့ checkpoint name ကို အသုံးပြုပြီး၊ ၎င်းသည် model ရဲ့ tokenizer နဲ့ ဆက်စပ်နေတဲ့ ဒေတာတွေကို အလိုအလျောက် ရယူပြီး cache လုပ်ပါလိမ့်မယ် (ဒါကြောင့် အောက်က code ကို ပထမဆုံးအကြိမ် run မှသာ download လုပ်ပါလိမ့်မယ်)။ + +`sentiment-analysis` pipeline ရဲ့ default checkpoint က `distilbert-base-uncased-finetuned-sst-2-english` ဖြစ်တာကြောင့် (၎င်းရဲ့ model card ကို [ဒီနေရာမှာ](https://huggingface.co/distilbert-base-uncased-finetuned-sst-2-english) ကြည့်နိုင်ပါတယ်)၊ အောက်ပါ code ကို ကျွန်တော်တို့ run ပြုလုပ်ပေးပါတယ်။ + +```python +from transformers import AutoTokenizer + +checkpoint = "distilbert-base-uncased-finetuned-sst-2-english" +tokenizer = AutoTokenizer.from_pretrained(checkpoint) +``` + +tokenizer ကို ရရှိပြီဆိုတာနဲ့၊ ကျွန်တော်တို့ရဲ့ စာကြောင်းတွေကို တိုက်ရိုက် ပေးပို့နိုင်ပြီး model ကို ထည့်သွင်းဖို့ အဆင်သင့်ဖြစ်နေတဲ့ dictionary တစ်ခု ပြန်ရပါလိမ့်မယ်။ လုပ်ဆောင်ဖို့ ကျန်ရှိတာကတော့ input IDs တွေရဲ့ list ကို tensors တွေအဖြစ် ပြောင်းလဲဖို့ပါပဲ။ + +သင်ဟာ backend မှာ ဘယ် ML framework ကို အသုံးပြုလဲဆိုတာ စိုးရိမ်စရာမလိုဘဲ 🤗 Transformers ကို အသုံးပြုနိုင်ပါတယ်။ အချို့မော်ဒယ်တွေအတွက် PyTorch ဒါမှမဟုတ် Flax ဖြစ်နိုင်ပါတယ်။ သို့သော် Transformer မော်ဒယ်တွေက *tensors* တွေကိုပဲ input အဖြစ် လက်ခံပါတယ်။ tensors တွေအကြောင်းကို အခုမှ စကြားဖူးတာဆိုရင်၊ ၎င်းတို့ကို NumPy arrays တွေအဖြစ် တွေးကြည့်နိုင်ပါတယ်။ NumPy array တစ်ခုက scalar (0D)၊ vector (1D)၊ matrix (2D) သို့မဟုတ် dimension များစွာရှိနိုင်ပါတယ်။ ဒါက တကယ်တော့ tensor တစ်ခုပါပဲ။ အခြား ML frameworks တွေရဲ့ tensors တွေလည်း အလားတူပဲ အလုပ်လုပ်ပြီး၊ NumPy arrays တွေလိုပဲ လွယ်ကူစွာ instantiate လုပ်နိုင်ပါတယ်။ + +ကျွန်တော်တို့ ပြန်လိုချင်တဲ့ tensors (PyTorch သို့မဟုတ် plain NumPy) အမျိုးအစားကို သတ်မှတ်ဖို့အတွက် `return_tensors` argument ကို အသုံးပြုနိုင်ပါတယ်။ + +```python +raw_inputs = [ + "I've been waiting for a HuggingFace course my whole life.", + "I hate this so much!", +] +inputs = tokenizer(raw_inputs, padding=True, truncation=True, return_tensors="pt") +print(inputs) +``` + +padding နဲ့ truncation အကြောင်းကို အခုထိ စိတ်ပူမနေပါနဲ့၊ ဒါတွေကို နောက်မှ ရှင်းပြပါမယ်။ ဒီနေရာမှာ မှတ်ထားရမယ့် အဓိကအချက်တွေကတော့ သင်ဟာ စာကြောင်းတစ်ကြောင်း ဒါမှမဟုတ် စာကြောင်းများစွာပါတဲ့ list ကို ပေးပို့နိုင်သလို၊ သင်ပြန်လိုချင်တဲ့ tensors အမျိုးအစားကိုလည်း သတ်မှတ်နိုင်ပါတယ် (မည်သည့် type ကိုမျှ မပေးပို့ရင် list of lists အဖြစ် ရလဒ်ရပါလိမ့်မယ်)။ + +PyTorch tensors အဖြစ် ရလဒ်တွေက အောက်ပါအတိုင်း ဖြစ်ပါတယ်။ + +```python out +{ + 'input_ids': tensor([ + [ 101, 1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012, 102], + [ 101, 1045, 5223, 2023, 2061, 2172, 999, 102, 0, 0, 0, 0, 0, 0, 0, 0] + ]), + 'attention_mask': tensor([ + [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], + [1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0] + ]) +} +``` + +output ကိုယ်တိုင်က `input_ids` နဲ့ `attention_mask` ဆိုတဲ့ key နှစ်ခုပါဝင်တဲ့ dictionary တစ်ခု ဖြစ်ပါတယ်။ `input_ids` မှာ integer row နှစ်ခု (စာကြောင်းတစ်ကြောင်းစီအတွက် တစ်ခု) ပါဝင်ပြီး ၎င်းတို့ဟာ စာကြောင်းတစ်ကြောင်းစီရှိ tokens တွေရဲ့ ထူးခြားတဲ့ identifiers တွေ ဖြစ်ပါတယ်။ `attention_mask` ဆိုတာ ဘာလဲဆိုတာကို ဒီအခန်းရဲ့ နောက်ပိုင်းမှာ ကျွန်တော်တို့ ရှင်းပြပါမယ်။ + +## Model ကို ဖြတ်သန်းခြင်း[[going-through-the-model]] + +ကျွန်တော်တို့ tokenizer ကို လုပ်ခဲ့သလိုပဲ pre-trained model ကို download လုပ်နိုင်ပါတယ်။ 🤗 Transformers က `from_pretrained()` method ပါဝင်တဲ့ `AutoModel` class ကို ပံ့ပိုးပေးပါတယ်။ + +```python +from transformers import AutoModel + +checkpoint = "distilbert-base-uncased-finetuned-sst-2-english" +model = AutoModel.from_pretrained(checkpoint) +``` + +ဒီ code snippet မှာ ကျွန်တော်တို့ဟာ ယခင်က pipeline မှာ အသုံးပြုခဲ့တဲ့ checkpoint အတူတူကို download လုပ်ပြီး model တစ်ခုကို instantiate လုပ်ခဲ့ပါတယ်။ (ဒါကို အမှန်တကယ်တော့ cache လုပ်ထားပြီးသား ဖြစ်သင့်ပါတယ်)။ + +ဒီ architecture မှာ base Transformer module သာ ပါဝင်ပါတယ်- inputs အချို့ကို ပေးလိုက်တဲ့အခါ ၎င်းသည် *hidden states* ဟုခေါ်သော အရာများကို ထုတ်ပေးပါတယ်။ ၎င်းတို့ကို *features* ဟုလည်း ခေါ်ပါတယ်။ model input တစ်ခုစီအတွက် **Transformer model က အဲဒီ input ကို အကြောင်းအရာအရ နားလည်ထားမှုကို ကိုယ်စားပြုတဲ့ high-dimensional vector တစ်ခုကို** ကျွန်တော်တို့ ပြန်ရပါလိမ့်မယ်။ + +ဒါကို နားမလည်ရင် စိတ်မပူပါနဲ့။ ဒါတွေကို နောက်မှ အားလုံးရှင်းပြပါမယ်။ + +ဒီ hidden states တွေက သူ့ဘာသာသူ အသုံးဝင်နိုင်ပေမယ့်၊ ၎င်းတို့ဟာ များသောအားဖြင့် *head* လို့ခေါ်တဲ့ model ရဲ့ နောက်ထပ်အစိတ်အပိုင်းတစ်ခုရဲ့ inputs တွေ ဖြစ်ပါတယ်။ [Chapter 1](/course/chapter1) မှာ မတူညီတဲ့ လုပ်ငန်းတာဝန်တွေကို architecture တူတူနဲ့ လုပ်ဆောင်နိုင်ခဲ့ပေမယ့်၊ ဒီလုပ်ငန်းတာဝန်တစ်ခုစီမှာ ၎င်းနဲ့ ဆက်စပ်နေတဲ့ head တစ်ခုစီ ရှိပါတယ်။ + +### High-dimensional vector တစ်ခုလား။[[a-high-dimensional-vector]] + +Transformer module ကနေ ထုတ်ပေးတဲ့ vector ဟာ များသောအားဖြင့် ကြီးမားပါတယ်။ ဒါက အများအားဖြင့် dimensions သုံးခု ရှိပါတယ်- + +- **Batch size**: တစ်ကြိမ်တည်း လုပ်ဆောင်တဲ့ sequence အရေအတွက် (ကျွန်တော်တို့ ဥပမာမှာ ၂ ခု)။ +- **Sequence length**: sequence ရဲ့ ဂဏန်းဆိုင်ရာ ကိုယ်စားပြုမှုရဲ့ အရှည် (ကျွန်တော်တို့ ဥပမာမှာ ၁၆ ခု)။ +- **Hidden size**: model input တစ်ခုစီရဲ့ vector dimension။ + +နောက်ဆုံးတန်ဖိုးကြောင့် "high dimensional" လို့ ခေါ်တာ ဖြစ်ပါတယ်။ hidden size က အလွန်ကြီးမားနိုင်ပါတယ် (768 က ပိုသေးငယ်တဲ့ မော်ဒယ်တွေအတွက် အများအားဖြင့်ဖြစ်ပြီး၊ ပိုကြီးတဲ့ မော်ဒယ်တွေမှာ ဒါက 3072 ဒါမှမဟုတ် ပိုများနိုင်ပါတယ်)။ + +ကျွန်တော်တို့ preprocessing လုပ်ထားတဲ့ inputs တွေကို model ကို ပေးပို့ကြည့်ရင် ဒါကို တွေ့နိုင်ပါတယ်။ + +```python +outputs = model(**inputs) +print(outputs.last_hidden_state.shape) +``` + +```python out +torch.Size([2, 16, 768]) +``` + +🤗 Transformers မော်ဒယ်တွေရဲ့ outputs တွေဟာ `namedtuple` တွေ ဒါမှမဟုတ် dictionaries တွေလို အလုပ်လုပ်တယ်ဆိုတာကို သတိပြုပါ။ attribute တွေ (ကျွန်တော်တို့ လုပ်ခဲ့သလို) ဒါမှမဟုတ် key ( `outputs["last_hidden_state"]` ) နဲ့ ဒါမှမဟုတ် သင်ရှာနေတဲ့အရာ ဘယ်နေရာမှာရှိတယ်ဆိုတာ အတိအကျသိရင် index ( `outputs[0]` ) နဲ့ပါ ဝင်ရောက်ကြည့်ရှုနိုင်ပါတယ်။ + +### Model heads: ဂဏန်းတွေကနေ အဓိပ္ပာယ်ထုတ်ယူခြင်း[[model-heads-making-sense-out-of-numbers]] + +Model heads တွေက hidden states တွေရဲ့ high-dimensional vector ကို input အဖြစ် ယူပြီး ၎င်းတို့ကို မတူညီတဲ့ dimension တစ်ခုပေါ်သို့ project လုပ်ပါတယ်။ ၎င်းတို့ဟာ များသောအားဖြင့် linear layers တစ်ခု ဒါမှမဟုတ် အနည်းငယ်နဲ့ ဖွဲ့စည်းထားပါတယ်- + +
+A Transformer network alongside its head. + +
+ +Transformer model ရဲ့ output ကို model head ကို တိုက်ရိုက်ပို့ပြီး လုပ်ဆောင်ပါတယ်။ + +ဒီပုံမှာ မော်ဒယ်ကို embeddings layer နဲ့ နောက်ဆက်တွဲ layers တွေနဲ့ ကိုယ်စားပြုထားပါတယ်။ embeddings layer က tokenized input ထဲက input ID တစ်ခုစီကို ၎င်းနဲ့ ဆက်စပ်နေတဲ့ token ကို ကိုယ်စားပြုတဲ့ vector တစ်ခုအဖြစ် ပြောင်းလဲပေးပါတယ်။ နောက်ဆက်တွဲ layers တွေက attention mechanism ကို အသုံးပြုပြီး အဲဒီ vectors တွေကို စီမံခန့်ခွဲကာ စာကြောင်းတွေရဲ့ နောက်ဆုံးကိုယ်စားပြုမှုကို ထုတ်ပေးပါတယ်။ + +🤗 Transformers မှာ မတူညီတဲ့ architecture များစွာ ရရှိနိုင်ပြီး၊ တစ်ခုချင်းစီကို သီးခြားလုပ်ငန်းတစ်ခုကို ဖြေရှင်းဖို့ ဒီဇိုင်းထုတ်ထားပါတယ်။ အောက်ပါတို့ကတော့ မပြည့်စုံသေးသော စာရင်းတစ်ခု ဖြစ်ပါတယ်- + +- `*Model` (hidden states များကို ပြန်ရယူခြင်း) +- `*ForCausalLM` +- `*ForMaskedLM` +- `*ForMultipleChoice` +- `*ForQuestionAnswering` +- `*ForSequenceClassification` +- `*ForTokenClassification` +- နဲ့ အခြားအရာများ 🤗 + +ကျွန်တော်တို့ရဲ့ ဥပမာအတွက်၊ sequence classification head ပါဝင်တဲ့ မော်ဒယ်တစ်ခု လိုအပ်ပါလိမ့်မယ် (စာကြောင်းတွေကို positive သို့မဟုတ် negative အဖြစ် ခွဲခြားသတ်မှတ်နိုင်ဖို့)။ ဒါကြောင့် ကျွန်တော်တို့ဟာ `AutoModel` class ကို အမှန်တကယ် အသုံးပြုမှာ မဟုတ်ဘဲ `AutoModelForSequenceClassification` ကို အသုံးပြုပါမယ်။ + +```python +from transformers import AutoModelForSequenceClassification + +checkpoint = "distilbert-base-uncased-finetuned-sst-2-english" +model = AutoModelForSequenceClassification.from_pretrained(checkpoint) +outputs = model(**inputs) +``` + +အခု outputs တွေရဲ့ shape ကို ကြည့်လိုက်ရင်၊ dimensionality က အများကြီး နိမ့်သွားပါလိမ့်မယ်၊ model head က ယခင်က ကျွန်တော်တို့ တွေ့ခဲ့တဲ့ high-dimensional vectors တွေကို input အဖြစ် ယူပြီး၊ တန်ဖိုးနှစ်ခု (label တစ်ခုစီအတွက် တစ်ခု) ပါဝင်တဲ့ vectors တွေကို ထုတ်ပေးပါတယ်။ + +```python +print(outputs.logits.shape) +``` + +```python out +torch.Size([2, 2]) +``` + +ကျွန်တော်တို့မှာ စာကြောင်းနှစ်ကြောင်းနဲ့ label နှစ်ခုပဲ ရှိတာကြောင့်၊ ကျွန်တော်တို့ model ကနေ ရရှိတဲ့ ရလဒ်ဟာ 2 x 2 shape ဖြစ်ပါတယ်။ + +## Output ကို Postprocessing ပြုလုပ်ခြင်း[[postprocessing-the-output]] + +ကျွန်တော်တို့ model ကနေ output အဖြစ် ရရှိတဲ့ တန်ဖိုးတွေက သူ့ဘာသာသူ အဓိပ္ပာယ်ရှိတာ မဟုတ်ပါဘူး။ ကြည့်ကြည့်ရအောင်။ + +```python +print(outputs.logits) +``` + +```python out +tensor([[-1.5607, 1.6123], + [ 4.1692, -3.3464]], grad_fn=) +``` + +ကျွန်တော်တို့ရဲ့ model က ပထမစာကြောင်းအတွက် `[-1.5607, 1.6123]` ကို ခန့်မှန်းခဲ့ပြီး၊ ဒုတိယစာကြောင်းအတွက် `[ 4.1692, -3.3464]` ကို ခန့်မှန်းခဲ့ပါတယ်။ ဒါတွေက ဖြစ်နိုင်ခြေတွေ မဟုတ်ဘဲ *logits* တွေ ဖြစ်ပါတယ်။ ၎င်းတို့က model ရဲ့ နောက်ဆုံး layer ကနေ ထုတ်ပေးတဲ့ raw, unnormalized scores တွေပါ။ ဖြစ်နိုင်ခြေတွေအဖြစ် ပြောင်းလဲဖို့အတွက် [SoftMax](https://en.wikipedia.org/wiki/Softmax_function) layer ကို ဖြတ်သန်းဖို့ လိုအပ်ပါတယ် (🤗 Transformers model အားလုံးက logits တွေကို ထုတ်ပေးပါတယ်၊ ဘာလို့လဲဆိုတော့ training အတွက် loss function က SoftMax လိုမျိုး နောက်ဆုံး activation function နဲ့ cross entropy လိုမျိုး loss function အမှန်တကယ်ကို ပေါင်းစပ်ထားတာ ဖြစ်လေ့ရှိပါတယ်)။ + +```py +import torch + +predictions = torch.nn.functional.softmax(outputs.logits, dim=-1) +print(predictions) +``` + +```python out +tensor([[4.0195e-02, 9.5980e-01], + [9.9946e-01, 5.4418e-04]], grad_fn=) +``` + +အခု ကျွန်တော်တို့ model က ပထမစာကြောင်းအတွက် `[0.0402, 0.9598]` ကို ခန့်မှန်းခဲ့ပြီး၊ ဒုတိယစာကြောင်းအတွက် `[0.9995, 0.0005]` ကို ခန့်မှန်းခဲ့တယ်ဆိုတာ တွေ့ရပါပြီ။ ဒါတွေက အသိအမှတ်ပြုနိုင်တဲ့ ဖြစ်နိုင်ခြေ scores တွေ ဖြစ်ပါတယ်။ + +position တစ်ခုစီနဲ့ ကိုက်ညီတဲ့ labels တွေကို ရယူဖို့အတွက် model config ရဲ့ `id2label` attribute ကို စစ်ဆေးနိုင်ပါတယ် (ဒီအကြောင်းကို နောက်အပိုင်းမှာ ပိုမိုသိရှိရပါလိမ့်မယ်)။ + +```python +model.config.id2label +``` + +```python out +{0: 'NEGATIVE', 1: 'POSITIVE'} +``` + +Nအခု ကျွန်တော်တို့ model က အောက်ပါအတိုင်း ခန့်မှန်းခဲ့တယ်လို့ ကောက်ချက်ချနိုင်ပါပြီ- + +- ပထမစာကြောင်း - NEGATIVE: 0.0402, POSITIVE: 0.9598 +- ဒုတိယစာကြောင်း - NEGATIVE: 0.9995, POSITIVE: 0.0005 + +ကျွန်တော်တို့ pipeline ရဲ့ အဆင့်သုံးဆင့်လုံးကို အောင်မြင်စွာ ပြန်လည်ဖန်တီးနိုင်ခဲ့ပါပြီ- tokenizers တွေနဲ့ preprocessing လုပ်ခြင်း၊ model ကနေတဆင့် inputs တွေကို ပေးပို့ခြင်း၊ နဲ့ postprocessing လုပ်ခြင်းတို့ ဖြစ်ပါတယ်။ အခုတော့ ဒီအဆင့်တစ်ခုချင်းစီကို ပိုပြီး နက်နက်နဲနဲ လေ့လာကြည့်ရအောင်။ + + + +✏️ **စမ်းသပ်ကြည့်ပါ။** သင်ကိုယ်တိုင် စာသား (၂) ခု (သို့မဟုတ် ပိုမိုများပြား) ရွေးချယ်ပြီး `sentiment-analysis` pipeline ကနေတဆင့် run ပါ။ ထို့နောက် ဒီနေရာမှာ သင်တွေ့ခဲ့ရတဲ့ အဆင့်တွေကို ကိုယ်တိုင်ပြန်လုပ်ပြီး တူညီတဲ့ ရလဒ်တွေ ရရှိမရရှိ စစ်ဆေးပါ။ + + + +## ဝေါဟာရ ရှင်းလင်းချက် (Glossary) + +* **Pipeline**: Hugging Face Transformers library မှာ ပါဝင်တဲ့ လုပ်ဆောင်ချက်တစ်ခုဖြစ်ပြီး မော်ဒယ်တွေကို သီးခြားလုပ်ငန်းတာဝန်များ (ဥပမာ- စာသားခွဲခြားသတ်မှတ်ခြင်း၊ စာသားထုတ်လုပ်ခြင်း) အတွက် အသုံးပြုရလွယ်ကူအောင် ပြုလုပ်ပေးပါတယ်။ +* **Preprocessing**: Machine Learning မော်ဒယ်တစ်ခုကို မထည့်သွင်းမီ raw data များကို လုပ်ဆောင်ရန် အသင့်ဖြစ်အောင် ပြင်ဆင်ခြင်း။ +* **Postprocessing**: Machine Learning မော်ဒယ်တစ်ခု၏ output များကို ပိုမိုနားလည်လွယ်သော သို့မဟုတ် အသုံးဝင်သော ပုံစံသို့ ပြောင်းလဲခြင်း။ +* **Neural Networks**: လူသားဦးနှောက်၏ လုပ်ဆောင်မှုပုံစံကို အတုယူထားသော ကွန်ပျူတာစနစ်များ။ +* **Transformer Models**: Natural Language Processing (NLP) မှာ အောင်မြင်မှုများစွာရရှိခဲ့တဲ့ deep learning architecture တစ်မျိုးပါ။ ၎င်းတို့ဟာ စာသားတွေထဲက စကားလုံးတွေရဲ့ ဆက်နွယ်မှုတွေကို "attention mechanism" သုံးပြီး နားလည်အောင် သင်ကြားပေးပါတယ်။ +* **Raw Text**: မည်သည့်လုပ်ဆောင်မှုမျှ မပြုလုပ်ရသေးသော သို့မဟုတ် ပုံစံမချရသေးသော မူရင်းစာသား။ +* **Tokenizer**: စာသား (သို့မဟုတ် အခြားဒေတာ) ကို AI မော်ဒယ်များ စီမံဆောင်ရွက်နိုင်ရန် tokens တွေအဖြစ် ပိုင်းခြားပေးသည့် ကိရိယာ သို့မဟုတ် လုပ်ငန်းစဉ်။ +* **Tokens**: စာသားကို ခွဲခြမ်းစိတ်ဖြာရာတွင် အသုံးပြုသော အသေးငယ်ဆုံးယူနစ်များ (ဥပမာ- စကားလုံးများ၊ subwords များ သို့မဟုတ် ပုဒ်ဖြတ်သံများ)။ +* **Integer**: အပြည့်အစုံ ကိန်းဂဏန်း။ +* **Pretrained**: ဒေတာအမြောက်အမြားပေါ်တွင် ကြိုတင်လေ့ကျင့်ထားပြီးသား Artificial Intelligence (AI) မော်ဒယ်တစ်ခု။ +* **Model Hub**: Hugging Face ပေါ်ရှိ pre-trained model များနှင့် datasets များကို ရှာဖွေ၊ မျှဝေပြီး အသုံးပြုနိုင်သော online platform။ +* **`AutoTokenizer` Class**: Hugging Face Transformers library မှာ ပါဝင်တဲ့ class တစ်ခုဖြစ်ပြီး မော်ဒယ်အမည်ကို အသုံးပြုပြီး သက်ဆိုင်ရာ tokenizer ကို အလိုအလျောက် load လုပ်ပေးသည်။ +* **`from_pretrained()` Method**: Pre-trained model သို့မဟုတ် tokenizer ကို load လုပ်ရန် အသုံးပြုသော method။ +* **Checkpoint Name**: အင်တာနက်ပေါ်ရှိ Hugging Face Hub မှ pre-trained model သို့မဟုတ် tokenizer ကို ဖော်ထုတ်ရန် အသုံးပြုသော အမည်။ +* **Cache**: မကြာခဏ အသုံးပြုရသော ဒေတာများကို အမြန်ဆုံး ဝင်ရောက်ရယူနိုင်ရန် ယာယီသိုလှောင်ထားသော နေရာ။ +* **`sentiment-analysis` pipeline**: စာသားတစ်ခု၏ စိတ်ခံစားမှု (အပြုသဘော သို့မဟုတ် အနုတ်သဘော) ကို ခွဲခြမ်းစိတ်ဖြာပေးသော pipeline။ +* **`distilbert-base-uncased-finetuned-sst-2-english`**: `sentiment-analysis` pipeline ၏ default checkpoint အဖြစ် အသုံးပြုသော DistilBERT မော်ဒယ်၏ အမည်။ `base` သည် မော်ဒယ်၏ အရွယ်အစားကို ဖော်ပြပြီး `uncased` သည် စာလုံးအကြီးအသေး ခွဲခြားခြင်းမရှိဘဲ လေ့ကျင့်ထားကြောင်း ဖော်ပြသည်။ `finetuned-sst-2-english` က SST-2 dataset တွင် English ဘာသာစကားအတွက် fine-tune လုပ်ထားသည်ကို ဆိုလိုသည်။ +* **Model Card**: Hugging Face Hub ပေါ်ရှိ မော်ဒယ်တစ်ခု၏ အချက်အလက်များ၊ အသုံးပြုပုံနှင့် စွမ်းဆောင်ရည်များကို အကျဉ်းချုပ်ဖော်ပြထားသော စာမျက်နှာ။ +* **Dictionary**: key-value pair များဖြင့် ဒေတာများကို သိုလှောင်သော ဒေတာဖွဲ့စည်းပုံ။ +* **Tensors**: Machine Learning frameworks (PyTorch, TensorFlow) များတွင် ဒေတာများကို ကိုယ်စားပြုသော multi-dimensional array များ။ +* **NumPy Arrays**: Python တွင် ဂဏန်းတွက်ချက်မှုများအတွက် အသုံးပြုသော multi-dimensional array များအတွက် library။ +* **Scalar (0D)**: Dimension မရှိသော တစ်ခုတည်းသော ကိန်းဂဏန်းတန်ဖိုး။ +* **Vector (1D)**: ကိန်းဂဏန်းတန်ဖိုးများ၏ တစ်ကြောင်းတည်းသော sequence။ +* **Matrix (2D)**: ကိန်းဂဏန်းတန်ဖိုးများ၏ နှစ်ကြောင်းအတန်းလိုက် စီစဉ်ထားသော အစုအဝေး။ +* **`return_tensors` Argument**: tokenizer ကို ခေါ်ဆိုသောအခါ ပြန်လိုချင်သော tensor အမျိုးအစားကို သတ်မှတ်ရန် အသုံးပြုသော argument။ +* **`padding`**: မတူညီသော အရှည်ရှိသည့် input sequence များကို အရှည်တူညီအောင် သတ်မှတ်ထားသော တန်ဖိုးများဖြင့် ဖြည့်စွက်ခြင်း။ +* **`truncation`**: အရှည်ကန့်သတ်ချက်ထက် ပိုနေသော input sequence များကို ဖြတ်တောက်ခြင်း။ +* **`input_ids`**: Tokenizer မှ ထုတ်ပေးသော tokens တစ်ခုစီ၏ ထူးခြားသော ဂဏန်းဆိုင်ရာ ID များ။ +* **`attention_mask`**: မော်ဒယ်ကို အာရုံစိုက်သင့်သည့် tokens များနှင့် လျစ်လျူရှုသင့်သည့် (padding) tokens များကို ခွဲခြားပေးသည့် binary mask။ +* **`AutoModel` Class**: Hugging Face Transformers library မှာ ပါဝင်တဲ့ class တစ်ခုဖြစ်ပြီး မော်ဒယ်အမည်ကို အသုံးပြုပြီး Transformer model ကို အလိုအလျောက် load လုပ်ပေးသည်။ +* **Hidden States**: Transformer model ၏ အလယ်အလတ် layers များမှ ထုတ်ပေးသော output များ။ ၎င်းတို့သည် input ၏ အကြောင်းအရာဆိုင်ရာ ကိုယ်စားပြုမှုများကို ဖမ်းယူထားသည်။ +* **Features**: Hidden states များကို ရည်ညွှန်းသော အခြားအသုံးအနှုန်းတစ်ခု။ +* **High-dimensional Vector**: dimension များစွာရှိသော vector တစ်ခု။ +* **Batch Size**: မော်ဒယ်က တစ်ပြိုင်နက်တည်း လုပ်ဆောင်သော input sequence အရေအတွက်။ +* **Sequence Length**: input sequence ၏ token အရေအတွက်။ +* **Hidden Size**: hidden states vector တစ်ခု၏ dimension အရွယ်အစား။ +* **`namedtuple`s**: Python တွင် tuple ကဲ့သို့ အလုပ်လုပ်သော်လည်း attribute name များဖြင့် elements များကို ဝင်ရောက်ကြည့်ရှုနိုင်သော data type။ +* **Model Heads**: Transformer model ၏ hidden states များကို သီးခြားလုပ်ငန်းတစ်ခုအတွက် လိုအပ်သော output များအဖြစ် ပြောင်းလဲပေးသော အစိတ်အပိုင်း။ များသောအားဖြင့် linear layers များဖြင့် ဖွဲ့စည်းထားသည်။ +* **Embeddings Layer**: input IDs များကို vector representations များအဖြစ် ပြောင်းလဲပေးသော model layer။ +* **`*Model`**: base Transformer model (hidden states များကို ပြန်ရယူရန်) ကို ကိုယ်စားပြုသော Hugging Face model class family။ +* **`*ForCausalLM`**: Causal Language Modeling (နောက်ထပ် token ကို ခန့်မှန်းခြင်း) အတွက် ဒီဇိုင်းထုတ်ထားသော model class family။ +* **`*ForMaskedLM`**: Masked Language Modeling (ပျောက်ဆုံးနေသော token များကို ဖြည့်စွက်ခြင်း) အတွက် ဒီဇိုင်းထုတ်ထားသော model class family။ +* **`*ForMultipleChoice`**: Multiple Choice question answering အတွက် ဒီဇိုင်းထုတ်ထားသော model class family။ +* **`*ForQuestionAnswering`**: Question Answering လုပ်ငန်းတာဝန်များအတွက် ဒီဇိုင်းထုတ်ထားသော model class family။ +* **`*ForSequenceClassification`**: Sequence Classification လုပ်ငန်းတာဝန်များ (ဥပမာ- sentiment analysis) အတွက် ဒီဇိုင်းထုတ်ထားသော model class family။ +* **`*ForTokenClassification`**: Token Classification လုပ်ငန်းတာဝန်များ (ဥပမာ- Named Entity Recognition) အတွက် ဒီဇိုင်းထုတ်ထားသော model class family။ +* **`AutoModelForSequenceClassification`**: Hugging Face Transformers library မှာ ပါဝင်တဲ့ class တစ်ခုဖြစ်ပြီး sequence classification အတွက် pre-trained model ကို အလိုအလျောက် load လုပ်ပေးသည်။ +* **`outputs.logits`**: မော်ဒယ်၏ နောက်ဆုံး layer မှ ထုတ်ပေးသော raw, unnormalized scores များ။ +* **Logits**: မော်ဒယ်၏ နောက်ဆုံး layer မှ ထုတ်ပေးသော raw, unnormalized scores များ။ ၎င်းတို့သည် ဖြစ်နိုင်ခြေများအဖြစ်သို့ ပြောင်းလဲခြင်းမရှိသေးပါ။ +* **SoftMax Layer**: input numbers များကို 0 နှင့် 1 ကြားရှိ ဖြစ်နိုင်ခြေများအဖြစ်သို့ ပြောင်းလဲပေးသော activation function တစ်ခု။ ၎င်းတို့၏ စုစုပေါင်းသည် 1 ဖြစ်သည်။ +* **Loss Function**: မော်ဒယ်၏ ခန့်မှန်းချက်များနှင့် အမှန်တကယ်တန်ဖိုးများကြား ကွာခြားမှုကို တိုင်းတာသော function တစ်ခု။ +* **Cross Entropy**: Classification လုပ်ငန်းများတွင် အသုံးများသော loss function တစ်ခု။ +* **`torch.nn.functional.softmax(outputs.logits, dim=-1)`**: PyTorch တွင် softmax function ကို `outputs.logits` ပေါ်တွင် နောက်ဆုံး dimension (dim=-1) အတိုင်း အသုံးပြုခြင်း။ +* **`model.config.id2label`**: Model configuration ထဲတွင် `id` (ဂဏန်း) မှ `label` (စာသား) သို့ တွဲချိတ်ပေးသော dictionary တစ်ခု။ \ No newline at end of file diff --git a/chapters/my/chapter2/3.mdx b/chapters/my/chapter2/3.mdx new file mode 100644 index 000000000..b7d947938 --- /dev/null +++ b/chapters/my/chapter2/3.mdx @@ -0,0 +1,342 @@ + + +# Models[[the-models]] + + + + + +ဒီအပိုင်းမှာတော့ model တွေကို ဘယ်လိုဖန်တီးရမလဲ၊ အသုံးပြုရမလဲဆိုတာကို ပိုမိုနက်နဲစွာ လေ့လာသွားပါမယ်။ checkpoint တစ်ခုကနေ မည်သည့် model ကိုမဆို instantiate လုပ်ချင်တဲ့အခါ အသုံးဝင်တဲ့ `AutoModel` class ကို ကျွန်တော်တို့ အသုံးပြုပါမယ်။ + +## Transformer တစ်ခုကို ဖန်တီးခြင်း[[creating-a-transformer]] + +`AutoModel` တစ်ခုကို instantiate လုပ်တဲ့အခါ ဘာတွေဖြစ်ပျက်လဲဆိုတာကို ကြည့်ခြင်းဖြင့် စတင်လိုက်ရအောင်။ + +```py +from transformers import AutoModel + +model = AutoModel.from_pretrained("bert-base-cased") +``` + +tokenizer နဲ့ ဆင်တူစွာ၊ `from_pretrained()` method က Hugging Face Hub ကနေ model data တွေကို download လုပ်ပြီး cache လုပ်ပါလိမ့်မယ်။ ယခင်က ဖော်ပြခဲ့သလိုပဲ၊ checkpoint name က သီးခြား model architecture နဲ့ weights တွေနဲ့ ကိုက်ညီပါတယ်။ ဒီဥပမာမှာတော့ basic architecture (12 layers, 768 hidden size, 12 attention heads) နဲ့ cased inputs (ဆိုလိုသည်မှာ စာလုံးအကြီးအသေး ခွဲခြားမှုက အရေးကြီးသည်) ပါဝင်တဲ့ BERT model တစ်ခု ဖြစ်ပါတယ်။ Hub မှာ ရရှိနိုင်တဲ့ checkpoints များစွာ ရှိပါတယ် - [ဒီနေရာမှာ](https://huggingface.co/models) ရှာဖွေနိုင်ပါတယ်။ + +`AutoModel` class နဲ့ ၎င်းရဲ့ ဆက်စပ် classes တွေဟာ တကယ်တော့ ပေးထားတဲ့ checkpoint အတွက် သင့်လျော်တဲ့ model architecture ကို ရယူဖို့ ဒီဇိုင်းထုတ်ထားတဲ့ ရိုးရှင်းတဲ့ wrappers တွေပါ။ ဒါက "auto" class တစ်ခုဖြစ်ပြီး သင့်အတွက် သင့်လျော်တဲ့ model architecture ကို ခန့်မှန်းပြီး မှန်ကန်တဲ့ model class ကို instantiate လုပ်ပေးပါလိမ့်မယ်။ သို့သော်၊ သင်အသုံးပြုချင်တဲ့ model အမျိုးအစားကို သိရှိထားတယ်ဆိုရင်၊ ၎င်းရဲ့ architecture ကို တိုက်ရိုက်သတ်မှတ်ပေးတဲ့ class ကို အသုံးပြုနိုင်ပါတယ်။ + +```py +from transformers import BertModel + +model = BertModel.from_pretrained("bert-base-cased") +``` + +## Loading နှင့် Saving[[loading-and-saving]] + +Model တစ်ခုကို save လုပ်တာက tokenizer တစ်ခုကို save လုပ်တာလိုပဲ ရိုးရှင်းပါတယ်။ တကယ်တော့၊ model တွေမှာ model ရဲ့ weights တွေနဲ့ architecture configuration တွေကို save လုပ်ပေးတဲ့ `save_pretrained()` method တူတူကို ပိုင်ဆိုင်ထားပါတယ်။ + +```py +model.save_pretrained("directory_on_my_computer") +``` + +ဒါက သင့် disk ထဲမှာ ဖိုင်နှစ်ခုကို save လုပ်ပါလိမ့်မယ်။ + +``` +ls directory_on_my_computer + +config.json model.safetensors +``` + +*config.json* ဖိုင်ထဲကို ကြည့်လိုက်ရင်၊ model architecture ကို တည်ဆောက်ဖို့ လိုအပ်တဲ့ attributes အားလုံးကို တွေ့ရပါလိမ့်မယ်။ ဒီဖိုင်ထဲမှာ checkpoint ဘယ်ကနေ စတင်ခဲ့သလဲ၊ နောက်ဆုံး checkpoint ကို save လုပ်ခဲ့တုန်းက သင်အသုံးပြုခဲ့တဲ့ 🤗 Transformers version စတဲ့ metadata အချို့လည်း ပါဝင်ပါတယ်။ + +*pytorch_model.safetensors* ဖိုင်ကို state dictionary လို့ခေါ်ပါတယ်။ ၎င်းထဲမှာ သင့် model ရဲ့ weights အားလုံး ပါဝင်ပါတယ်။ ဖိုင်နှစ်ခုစလုံး အတူတူ အလုပ်လုပ်ပါတယ်- configuration file က model architecture အကြောင်း သိရှိဖို့ လိုအပ်ပြီး၊ model weights တွေကတော့ model ရဲ့ parameters တွေ ဖြစ်ပါတယ်။ + +save လုပ်ထားတဲ့ model တစ်ခုကို ပြန်လည်အသုံးပြုဖို့အတွက် `from_pretrained()` method ကို ထပ်မံအသုံးပြုပါ။ + +```py +from transformers import AutoModel + +model = AutoModel.from_pretrained("directory_on_my_computer") +``` + +🤗 Transformers library ရဲ့ အံ့ဖွယ်ကောင်းတဲ့ အင်္ဂါရပ်တစ်ခုကတော့ model တွေနဲ့ tokenizers တွေကို community နဲ့ အလွယ်တကူ မျှဝေနိုင်စွမ်းပါပဲ။ ဒါကို လုပ်ဖို့ Hugging Face မှာ account ရှိဖို့ သေချာပါစေ။ သင် notebook ကို အသုံးပြုနေတယ်ဆိုရင်၊ ဒါနဲ့ အလွယ်တကူ log in လုပ်ဆောင်နိုင်ပါတယ်။ + +```python +from huggingface_hub import notebook_login + +notebook_login() +``` + +မဟုတ်ရင်တော့ သင့် terminal မှာ အောက်ပါအတိုင်း run ပါ။ + +```bash +huggingface-cli login +``` + +အဲဒီနောက် `push_to_hub()` method နဲ့ model ကို Hub ကို push လုပ်နိုင်ပါတယ်။ + +```py +model.push_to_hub("my-awesome-model") +``` + +ဒါက model files တွေကို Hub ကို upload လုပ်ပါလိမ့်မယ်။ သင့် namespace အောက်မှာ *my-awesome-model* လို့ နာမည်ပေးထားတဲ့ repository ထဲမှာပါ။ အဲဒီနောက်၊ မည်သူမဆို သင့် model ကို `from_pretrained()` method နဲ့ load လုပ်နိုင်ပါပြီ။ + +```py +from transformers import AutoModel + +model = AutoModel.from_pretrained("your-username/my-awesome-model") +``` + +Hub API နဲ့ ပိုပြီး လုပ်ဆောင်နိုင်တာတွေ အများကြီး ရှိပါတယ်- +- local repository ကနေ model တစ်ခုကို push လုပ်ခြင်း +- အားလုံးကို ပြန်လည် upload မလုပ်ဘဲ သီးခြား files များကို update လုပ်ခြင်း +- model ရဲ့ စွမ်းဆောင်ရည်၊ ကန့်သတ်ချက်များ၊ သိထားတဲ့ bias စသည်တို့ကို မှတ်တမ်းတင်ဖို့ model cards တွေ ထည့်သွင်းခြင်း + +ဒီအကြောင်းအရာတွေအတွက် ပြည့်စုံတဲ့ tutorial ကို [documentation](https://huggingface.co/docs/huggingface_hub/how-to-upstream) မှာ ကြည့်ရှုနိုင်ပါတယ်၊ ဒါမှမဟုတ် အဆင့်မြင့် [Chapter 4](/course/chapter4) ကို လေ့လာနိုင်ပါတယ်။ + +## Text များကို Encoding လုပ်ခြင်း[[encoding-text]] + +Transformer မော်ဒယ်တွေက inputs တွေကို ဂဏန်းတွေအဖြစ် ပြောင်းလဲခြင်းဖြင့် text တွေကို ကိုင်တွယ်ပါတယ်။ ဒီနေရာမှာ သင်ရဲ့ text ကို tokenizer က ဘယ်လိုလုပ်ဆောင်တယ်ဆိုတာကို အတိအကျ ကြည့်ပါမယ်။ [Chapter 1](/course/chapter1) မှာ tokenizer တွေက text ကို tokens တွေအဖြစ် ပိုင်းခြားပြီး အဲဒီ tokens တွေကို ဂဏန်းတွေအဖြစ် ပြောင်းလဲတယ်ဆိုတာကို ကျွန်တော်တို့ တွေ့ခဲ့ရပါပြီ။ ဒီ conversion ကို ရိုးရှင်းတဲ့ tokenizer တစ်ခုနဲ့ ကြည့်နိုင်ပါတယ်။ + +```py +from transformers import AutoTokenizer + +tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") + +encoded_input = tokenizer("Hello, I'm a single sentence!") +print(encoded_input) +``` + +```python out +{'input_ids': [101, 8667, 117, 1000, 1045, 1005, 1049, 2235, 17662, 12172, 1012, 102], + 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]} +``` + +ကျွန်တော်တို့ဟာ အောက်ပါ fields တွေပါဝင်တဲ့ dictionary တစ်ခုကို ရရှိပါတယ် - +- input_ids: သင့် tokens တွေရဲ့ ဂဏန်းဆိုင်ရာ ကိုယ်စားပြုမှုများ +- token_type_ids: ဒါတွေက model ကို input ရဲ့ ဘယ်အပိုင်းက sentence A ဖြစ်ပြီး ဘယ်အပိုင်းက sentence B ဖြစ်တယ်ဆိုတာ ပြောပြပါတယ် (နောက်အပိုင်းမှာ ပိုမိုဆွေးနွေးပါမယ်) +- attention_mask: ဒါက မည်သည့် tokens များကို အာရုံစိုက်သင့်ပြီး မည်သည့် tokens များကို အာရုံစိုက်ရန် မလိုအပ်ကြောင်း ဖော်ပြပါတယ် (နောက်မှ ပိုမိုဆွေးနွေးပါမယ်) + +မူရင်း text ကို ပြန်ရဖို့အတွက် input IDs တွေကို decode လုပ်နိုင်ပါတယ်။ + +```py +tokenizer.decode(encoded_input["input_ids"]) +``` + +```python out +"[CLS] Hello, I'm a single sentence! [SEP]" +``` + +tokenizer က model လိုအပ်တဲ့ special tokens တွေဖြစ်တဲ့ `[CLS]` နဲ့ `[SEP]` တွေကို ထည့်သွင်းပေးထားတာကို သင်သတိထားမိပါလိမ့်မယ်။ မော်ဒယ်အားလုံးက special tokens တွေ လိုအပ်တာ မဟုတ်ပါဘူး။ ၎င်းတို့ကို မော်ဒယ်ကို pretrained လုပ်ခဲ့တုန်းက အသုံးပြုခဲ့ရင် အသုံးဝင်ပါတယ်။ အဲဒီအခါမှာတော့ tokenizer က ဒီ tokens တွေကို model က မျှော်လင့်ထားတဲ့အတိုင်း ထည့်ပေးဖို့ လိုအပ်ပါတယ်။ + +စာကြောင်းများစွာကို တစ်ကြိမ်တည်း encode လုပ်နိုင်ပါတယ်၊ ဒါကို batch လုပ်ခြင်းဖြင့် (ဒီအကြောင်းကို မကြာမီ ဆွေးနွေးပါမယ်) ဒါမှမဟုတ် list တစ်ခု ပေးပို့ခြင်းဖြင့် လုပ်ဆောင်နိုင်ပါတယ်။ + +```py +encoded_input = tokenizer("How are you?", "I'm fine, thank you!") +print(encoded_input) +``` + +```python out +{'input_ids': [[101, 1731, 1132, 1128, 136, 102], [101, 1045, 1005, 1049, 2503, 117, 5763, 1128, 136, 102]], + 'token_type_ids': [[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], + 'attention_mask': [[1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]} +``` + +စာကြောင်းများစွာကို ပေးပို့တဲ့အခါ၊ tokenizer က dictionary value တစ်ခုစီအတွက် စာကြောင်းတစ်ခုစီအတွက် list တစ်ခု ပြန်ပေးတာကို သတိပြုပါ။ tokenizer ကို PyTorch ကနေ tensors တွေကို တိုက်ရိုက်ပြန်ပေးဖို့လည်း တောင်းဆိုနိုင်ပါတယ်။ + +```py +encoded_input = tokenizer("How are you?", "I'm fine, thank you!", return_tensors="pt") +print(encoded_input) +``` + +```python out +{'input_ids': tensor([[ 101, 1731, 1132, 1128, 136, 102], + [ 101, 1045, 1005, 1049, 2503, 117, 5763, 1128, 136, 102]]), + 'token_type_ids': tensor([[0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]), + 'attention_mask': tensor([[1, 1, 1, 1, 1, 1], + [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])} +``` + +ဒါပေမယ့် ပြဿနာတစ်ခု ရှိပါတယ်- list နှစ်ခုရဲ့ အရှည်က မတူပါဘူး။ Arrays နဲ့ tensors တွေဟာ ထောင့်မှန်ပုံစံ (rectangular shapes) ဖြစ်ဖို့ လိုအပ်ပါတယ်။ ဒါကြောင့် ဒီ list တွေကို PyTorch tensor (သို့မဟုတ် NumPy array) အဖြစ် ရိုးရှင်းစွာ ပြောင်းလဲလို့ မရပါဘူး။ tokenizer က ဒါအတွက် ရွေးချယ်စရာတစ်ခု ပေးထားပါတယ်၊ padding ပါ။ + +### Inputs တွေကို Padding လုပ်ခြင်း[[padding-inputs]] + +ကျွန်တော်တို့ inputs တွေကို pad လုပ်ဖို့ tokenizer ကို တောင်းဆိုရင်၊ ၎င်းက အရှည်ဆုံးစာကြောင်းထက် တိုနေတဲ့ စာကြောင်းတွေမှာ special padding token တွေ ထည့်သွင်းခြင်းဖြင့် စာကြောင်းအားလုံးကို အရှည်တူညီအောင် ပြုလုပ်ပေးပါလိမ့်မယ်။ + +```py +encoded_input = tokenizer( + ["How are you?", "I'm fine, thank you!"], padding=True, return_tensors="pt" +) +print(encoded_input) +``` + +```python out +{'input_ids': tensor([[ 101, 1731, 1132, 1128, 136, 102, 0, 0, 0, 0], + [ 101, 1045, 1005, 1049, 2503, 117, 5763, 1128, 136, 102]]), + 'token_type_ids': tensor([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]), + 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 0, 0, 0, 0], + [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]])} +``` + +အခု ကျွန်တော်တို့မှာ ထောင့်မှန်ပုံစံ tensors တွေ ရပါပြီ။ padding tokens တွေကို ID 0 နဲ့ input IDs တွေအဖြစ် encode လုပ်ထားပြီး၊ ၎င်းတို့မှာ attention mask value ကလည်း 0 ဖြစ်တာကို သတိပြုပါ။ ဒါက ဘာလို့လဲဆိုတော့ အဲဒီ padding tokens တွေကို model က analyze လုပ်ဖို့ မလိုအပ်ပါဘူး- ၎င်းတို့က တကယ့်စာကြောင်းရဲ့ အစိတ်အပိုင်းတွေ မဟုတ်ပါဘူး။ + +### Inputs တွေကို Truncating လုပ်ခြင်း[[truncating-inputs]] + +Tensors တွေက model က လုပ်ဆောင်ဖို့အတွက် အရမ်းကြီးလာနိုင်ပါတယ်။ ဥပမာအားဖြင့်၊ BERT ကို အများဆုံး tokens 512 ခုအထိပဲ sequences တွေနဲ့ pretrain လုပ်ထားတာကြောင့် ပိုရှည်တဲ့ sequences တွေကို လုပ်ဆောင်လို့ မရပါဘူး။ သင့်မှာ model က ကိုင်တွယ်နိုင်တာထက် ပိုရှည်တဲ့ sequences တွေရှိရင်၊ `truncation` parameter နဲ့ ၎င်းတို့ကို ဖြတ်တောက်ဖို့ လိုအပ်ပါလိမ့်မယ်- + +```py +encoded_input = tokenizer( + "This is a very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very very long sentence.", + truncation=True, +) +print(encoded_input["input_ids"]) +``` + +```python out +[101, 1188, 1110, 170, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1505, 1179, 5650, 119, 102] +``` + +padding နဲ့ truncation arguments တွေကို ပေါင်းစပ်ခြင်းဖြင့်၊ သင်လိုအပ်တဲ့ တိကျတဲ့ size ရှိတဲ့ tensors တွေကို ရရှိကြောင်း သေချာစေနိုင်ပါတယ်။ + +```py +encoded_input = tokenizer( + ["How are you?", "I'm fine, thank you!"], + padding=True, + truncation=True, + max_length=5, + return_tensors="pt", +) +print(encoded_input) +``` + +```python out +{'input_ids': tensor([[ 101, 1731, 1132, 1128, 102], + [ 101, 1045, 1005, 1049, 102]]), + 'token_type_ids': tensor([[0, 0, 0, 0, 0], + [0, 0, 0, 0, 0]]), + 'attention_mask': tensor([[1, 1, 1, 1, 1], + [1, 1, 1, 1, 1]])} +``` + +### Special Tokens တွေ ထည့်သွင်းခြင်း + +Special tokens တွေ (သို့မဟုတ် ၎င်းတို့ရဲ့ သဘောတရား) ဟာ BERT နဲ့ ဆင်းသက်လာတဲ့ မော်ဒယ်တွေအတွက် အထူးအရေးကြီးပါတယ်။ ဒီ tokens တွေကို စာကြောင်းရဲ့ အစ ( `[CLS]` ) ဒါမှမဟုတ် စာကြောင်းတွေကြားက ပိုင်းခြားတဲ့နေရာ ( `[SEP]` ) လိုမျိုး စာကြောင်းရဲ့ နယ်နိမိတ်တွေကို ပိုမိုကောင်းမွန်စွာ ကိုယ်စားပြုနိုင်ဖို့ ထည့်သွင်းထားတာပါ။ ရိုးရှင်းတဲ့ ဥပမာတစ်ခုကို ကြည့်ကြည့်ရအောင်။ + +```py +encoded_input = tokenizer("How are you?") +print(encoded_input["input_ids"]) +tokenizer.decode(encoded_input["input_ids"]) +``` + +```python out +[101, 1731, 1132, 1128, 136, 102] +'[CLS] How are you? [SEP]' +``` + +ဒီ special tokens တွေကို tokenizer က အလိုအလျောက် ထည့်သွင်းပေးပါတယ်။ မော်ဒယ်အားလုံးက special tokens တွေ လိုအပ်တာ မဟုတ်ပါဘူး။ ၎င်းတို့ကို မော်ဒယ်ကို pretrained လုပ်ခဲ့တုန်းက အသုံးပြုခဲ့ရင် အဓိကအားဖြင့် အသုံးပြုပါတယ်။ အဲဒီအခါမှာတော့ tokenizer က ဒီ tokens တွေကို model က မျှော်လင့်ထားတဲ့အတိုင်း ထည့်ပေးပါလိမ့်မယ်။ + +### ဒါတွေအားလုံး ဘာကြောင့် လိုအပ်တာလဲ။ + +ဒီနေရာမှာ တိကျတဲ့ ဥပမာတစ်ခု ရှိပါတယ်- encode လုပ်ထားတဲ့ sequences တွေကို စဉ်းစားကြည့်ပါ။ + +```py +sequences = [ + "I've been waiting for a HuggingFace course my whole life.", + "I hate this so much!", +] +``` + +tokenized လုပ်ပြီးတာနဲ့ ကျွန်တော်တို့မှာ အောက်ပါအတိုင်း ရှိပါတယ်။ + +```python +encoded_sequences = [ + [ + 101, + 1045, + 1005, + 2310, + 2042, + 3403, + 2005, + 1037, + 17662, + 12172, + 2607, + 2026, + 2878, + 2166, + 1012, + 102, + ], + [101, 1045, 5223, 2023, 2061, 2172, 999, 102], +] +``` + +ဒါက encode လုပ်ထားတဲ့ sequences တွေရဲ့ list တစ်ခုပါ- list of lists တစ်ခုပေါ့။ Tensors တွေက ထောင့်မှန်ပုံစံ (rectangular shapes) တွေကိုသာ လက်ခံပါတယ် (matrices တွေကို တွေးကြည့်ပါ)။ ဒီ "array" ဟာ ထောင့်မှန်ပုံစံ ဖြစ်နေပြီဆိုတော့ ဒါကို tensor အဖြစ် ပြောင်းလဲဖို့က လွယ်ကူပါတယ်။ + +```py +import torch + +model_inputs = torch.tensor(encoded_sequences) +``` + +### Tensors များကို Model ၏ Inputs များအဖြစ် အသုံးပြုခြင်း[[using-the-tensors-as-inputs-to-the-model]] + +tensors တွေကို model နဲ့ အသုံးပြုတာက အလွန်ရိုးရှင်းပါတယ်- inputs တွေနဲ့ model ကို ခေါ်လိုက်ရုံပါပဲ။ + +```py +output = model(model_inputs) +``` + +model က မတူညီတဲ့ arguments များစွာကို လက်ခံပေမယ့်၊ input IDs တွေကသာ လိုအပ်တဲ့ arguments တွေပါ။ အခြား arguments တွေက ဘာလုပ်တယ်၊ ဘယ်အချိန်မှာ လိုအပ်တယ်ဆိုတာကို နောက်မှ ရှင်းပြပါမယ်။ ဒါပေမယ့် ပထမဆုံး Transformer model က နားလည်နိုင်တဲ့ inputs တွေကို တည်ဆောက်တဲ့ tokenizers တွေအကြောင်းကို ပိုပြီး နက်နဲစွာ လေ့လာဖို့ လိုအပ်ပါတယ်။ + +## ဝေါဟာရ ရှင်းလင်းချက် (Glossary) + +* **Models**: Artificial Intelligence (AI) နယ်ပယ်တွင် အသုံးပြုသော သင်္ချာဆိုင်ရာ ပုံစံများ သို့မဟုတ် algorithms များ။ +* **`AutoModel` Class**: Hugging Face Transformers library မှာ ပါဝင်တဲ့ class တစ်ခုဖြစ်ပြီး မော်ဒယ်အမည်ကို အသုံးပြုပြီး Transformer model ကို အလိုအလျောက် load လုပ်ပေးသည်။ +* **Checkpoint**: မော်ဒယ်တစ်ခု၏ လေ့ကျင့်မှုအခြေအနေ (weights, architecture configuration) ကို သတ်မှတ်ထားသော အချိန်တစ်ခုတွင် မှတ်တမ်းတင်ထားခြင်း။ +* **`from_pretrained()` Method**: Pre-trained model သို့မဟုတ် tokenizer ကို load လုပ်ရန် အသုံးပြုသော method။ +* **`bert-base-cased`**: BERT မော်ဒယ်၏ အမည်။ `base` သည် မော်ဒယ်၏ အရွယ်အစားကို ဖော်ပြပြီး `cased` သည် စာလုံးအကြီးအသေး ခွဲခြားမှုကို ထည့်သွင်းစဉ်းစားပြီး လေ့ကျင့်ထားကြောင်း ဖော်ပြသည်။ +* **Hugging Face Hub**: AI မော်ဒယ်တွေ၊ datasets တွေနဲ့ demo တွေကို အခြားသူတွေနဲ့ မျှဝေဖို့၊ ရှာဖွေဖို့နဲ့ ပြန်လည်အသုံးပြုဖို့အတွက် အွန်လိုင်း platform တစ်ခု ဖြစ်ပါတယ်။ +* **Model Architecture**: မော်ဒယ်တစ်ခု၏ ဖွဲ့စည်းပုံ၊ layer အမျိုးအစားများ၊ ၎င်းတို့ ချိတ်ဆက်ပုံ စသည်တို့ကို ဖော်ပြသော ဒီဇိုင်း။ +* **Weights**: Machine Learning မော်ဒယ်တစ်ခု၏ သင်ယူနိုင်သော အစိတ်အပိုင်းများ။ ၎င်းတို့သည် လေ့ကျင့်နေစဉ်အတွင်း ဒေတာများမှ ပုံစံများကို သင်ယူကာ ချိန်ညှိပေးသည်။ +* **Layers**: Neural Network တစ်ခု၏ အဆင့်များ။ +* **Hidden Size**: Hidden states vector တစ်ခု၏ dimension အရွယ်အစား။ +* **Attention Heads**: Transformer model ၏ attention mechanism တွင် ပါဝင်သော အပြိုင်လုပ်ဆောင်နိုင်သည့် အစိတ်အပိုင်းများ။ +* **Cased Inputs**: စာလုံးအကြီးအသေး ကွာခြားမှုကို ထည့်သွင်းစဉ်းစားသည့် inputs များ။ +* **Wrappers**: အခြား code များကို ပိုမိုလွယ်ကူစွာ အသုံးပြုနိုင်စေရန် ပတ်ခြုံပေးထားသော code များ။ +* **`BertModel` Class**: BERT model architecture ကို တိုက်ရိုက်သတ်မှတ်ပေးသော class။ +* **`save_pretrained()` Method**: Model သို့မဟုတ် tokenizer ၏ weights များနှင့် architecture configuration ကို save လုပ်ရန် အသုံးပြုသော method။ +* **`config.json`**: Model architecture တည်ဆောက်ရန် လိုအပ်သော attributes များနှင့် metadata များ ပါဝင်သော JSON ဖိုင်။ +* **`model.safetensors` / `pytorch_model.safetensors`**: Model ၏ weights များ ပါဝင်သော ဖိုင်။ +* **State Dictionary**: မော်ဒယ်တစ်ခု၏ သင်ယူထားသော parameters (weights) များကို သိုလှောင်ထားသော dictionary။ +* **Metadata**: ဒေတာအကြောင်းအရာနှင့်ပတ်သက်သော အချက်အလက်များ (ဥပမာ - ဘယ်ကနေ စတင်ခဲ့သည်၊ ဘယ် version ဖြင့် save လုပ်ခဲ့သည်)။ +* **Hugging Face**: AI နှင့် machine learning အတွက် tools များနှင့် platform များ ထောက်ပံ့ပေးသော ကုမ္ပဏီ။ +* **`huggingface_hub`**: Hugging Face Hub နှင့် ချိတ်ဆက်ရန်အတွက် Python library။ +* **`notebook_login()`**: Jupyter/Colab notebook များတွင် Hugging Face Hub ကို log in လုပ်ရန် အသုံးပြုသော function။ +* **`huggingface-cli login`**: terminal တွင် Hugging Face Hub ကို log in လုပ်ရန် အသုံးပြုသော command line tool။ +* **`push_to_hub()` Method**: model ကို Hugging Face Hub သို့ upload လုပ်ရန် အသုံးပြုသော method။ +* **Repository**: Hugging Face Hub ပေါ်ရှိ model files များ သို့မဟုတ် datasets များကို သိုလှောင်ထားသော နေရာ။ +* **Namespace**: Hugging Face Hub တွင် သုံးစွဲသူအကောင့် သို့မဟုတ် အဖွဲ့အစည်းအမည်။ +* **Hub API**: Hugging Face Hub နှင့် ပရိုဂရမ်ဖြင့် အပြန်အလှန် ချိတ်ဆက်ရန်အတွက် API။ +* **Local Repository**: သင့်ကွန်ပျူတာပေါ်ရှိ model files များ သို့မဟုတ် datasets များကို သိုလှောင်ထားသော နေရာ။ +* **Model Cards**: Hugging Face Hub ပေါ်ရှိ မော်ဒယ်တစ်ခု၏ အချက်အလက်များ၊ အသုံးပြုပုံနှင့် စွမ်းဆောင်ရည်များကို အကျဉ်းချုပ်ဖော်ပြထားသော စာမျက်နှာ။ +* **`AutoTokenizer` Class**: Hugging Face Transformers library မှာ ပါဝင်တဲ့ class တစ်ခုဖြစ်ပြီး မော်ဒယ်အမည်ကို အသုံးပြုပြီး သက်ဆိုင်ရာ tokenizer ကို အလိုအလျောက် load လုပ်ပေးသည်။ +* **Tokens**: စာသားကို ခွဲခြမ်းစိတ်ဖြာရာတွင် အသုံးပြုသော အသေးငယ်ဆုံးယူနစ်များ (ဥပမာ- စကားလုံးများ၊ subwords များ သို့မဟုတ် ပုဒ်ဖြတ်သံများ)။ +* **`encoded_input`**: Tokenizer ကနေ ထွက်လာတဲ့ encode လုပ်ထားတဲ့ input data။ +* **`input_ids`**: Tokenizer မှ ထုတ်ပေးသော tokens တစ်ခုစီ၏ ထူးခြားသော ဂဏန်းဆိုင်ရာ ID များ။ +* **`token_type_ids`**: Multi-sentence inputs တွေမှာ မည်သည့် token က မည်သည့် sentence (A သို့မဟုတ် B) မှ လာသည်ကို model ကို ပြောပြပေးသော IDs များ။ +* **`attention_mask`**: မော်ဒယ်ကို အာရုံစိုက်သင့်သည့် tokens များနှင့် လျစ်လျူရှုသင့်သည့် (padding) tokens များကို ခွဲခြားပေးသည့် binary mask။ +* **`tokenizer.decode()` Method**: Token IDs များကို မူရင်းစာသားသို့ ပြန်ပြောင်းလဲပေးသော method။ +* **Special Tokens**: Transformer model များက စာကြောင်းနယ်နိမိတ်များ သို့မဟုတ် အခြားအချက်အလက်များကို ကိုယ်စားပြုရန် အသုံးပြုသော အထူး tokens များ (ဥပမာ - `[CLS]`, `[SEP]`, `[PAD]`)။ +* **`[CLS]`**: BERT မော်ဒယ်တွင် classification task အတွက် အသုံးပြုသော special token (စာကြောင်း၏ အစတွင် ပေါ်လာသည်)။ +* **`[SEP]`**: BERT မော်ဒယ်တွင် စာကြောင်းများကြား ပိုင်းခြားရန် အသုံးပြုသော special token။ +* **Batching**: မတူညီသော input များစွာကို တစ်ပြိုင်နက်တည်း လုပ်ဆောင်နိုင်ရန် အုပ်စုဖွဲ့ခြင်း။ +* **Tensors**: Machine Learning frameworks (PyTorch, TensorFlow) များတွင် ဒေတာများကို ကိုယ်စားပြုသော multi-dimensional array များ။ +* **Rectangular Shapes**: ညီညာသော အတန်းများနှင့် ကော်လံများပါဝင်သည့် ပုံစံ (matrices ကဲ့သို့)။ +* **Arguments**: function သို့မဟုတ် method တစ်ခုသို့ ပေးပို့သော တန်ဖိုးများ။ \ No newline at end of file diff --git a/chapters/my/chapter2/4.mdx b/chapters/my/chapter2/4.mdx new file mode 100644 index 000000000..c193f478c --- /dev/null +++ b/chapters/my/chapter2/4.mdx @@ -0,0 +1,255 @@ + + +# Tokenizers[[tokenizers]] + + + + + +Tokenizers တွေဟာ NLP pipeline ရဲ့ အဓိက အစိတ်အပိုင်းတွေထဲက တစ်ခုပါ။ ၎င်းတို့မှာ ရည်ရွယ်ချက်တစ်ခုတည်းပဲ ရှိပါတယ်၊ text ကို model က လုပ်ဆောင်နိုင်တဲ့ data အဖြစ် ပြောင်းလဲဖို့ပါပဲ။ Model တွေက ဂဏန်းတွေကိုပဲ လုပ်ဆောင်နိုင်တာမို့၊ tokenizers တွေက ကျွန်တော်တို့ရဲ့ text inputs တွေကို numerical data အဖြစ် ပြောင်းလဲပေးဖို့ လိုအပ်ပါတယ်။ ဒီအပိုင်းမှာတော့ tokenization pipeline မှာ ဘာတွေ အတိအကျဖြစ်ပျက်လဲဆိုတာကို လေ့လာသွားပါမယ်။ + +NLP လုပ်ငန်းတွေမှာ အများအားဖြင့် လုပ်ဆောင်တဲ့ data က raw text ပါ။ ဒီလို text ရဲ့ ဥပမာတစ်ခုကို အောက်မှာ ကြည့်ပါ။ + +``` +Jim Henson was a puppeteer +``` + +သို့သော်လည်း၊ model တွေက ဂဏန်းတွေကိုပဲ လုပ်ဆောင်နိုင်တာမို့၊ raw text ကို ဂဏန်းတွေအဖြစ် ပြောင်းလဲဖို့ နည်းလမ်းတစ်ခုကို ကျွန်တော်တို့ ရှာဖွေဖို့ လိုအပ်ပါတယ်။ ဒါက tokenizers တွေ လုပ်ဆောင်တဲ့အရာ ဖြစ်ပြီး၊ ဒါကို လုပ်ဆောင်ဖို့ နည်းလမ်းများစွာ ရှိပါတယ်။ ရည်ရွယ်ချက်ကတော့ အဓိပ္ပာယ်အရှိဆုံး ကိုယ်စားပြုမှု (ဆိုလိုသည်မှာ model အတွက် အဓိပ္ပာယ်အရှိဆုံး ကိုယ်စားပြုမှု) နဲ့ ဖြစ်နိုင်ရင် အသေးငယ်ဆုံး ကိုယ်စားပြုမှုကို ရှာဖွေဖို့ပါပဲ။ + +tokenization algorithm အချို့ရဲ့ ဥပမာတွေကို ကြည့်ပြီး၊ tokenization နဲ့ ပတ်သက်ပြီး သင့်မှာရှိနိုင်တဲ့ မေးခွန်းအချို့ကို ဖြေဆိုဖို့ ကြိုးစားကြရအောင်။ + +## Word-based[[word-based]] + + + +ပထမဆုံး တွေးမိတဲ့ tokenizer အမျိုးအစားကတော့ *word-based* ပါ။ ဒါကို စည်းမျဉ်းအနည်းငယ်နဲ့ တည်ဆောက်ပြီး အသုံးပြုဖို့ အလွန်လွယ်ကူပြီး၊ အများအားဖြင့် ကောင်းမွန်တဲ့ ရလဒ်တွေ ထွက်ပေါ်လာပါတယ်။ ဥပမာအားဖြင့်၊ အောက်က ပုံမှာ၊ ရည်ရွယ်ချက်က raw text ကို စကားလုံးတွေအဖြစ် ပိုင်းခြားပြီး တစ်ခုချင်းစီအတွက် ဂဏန်းဆိုင်ရာ ကိုယ်စားပြုမှုကို ရှာဖွေဖို့ပါပဲ။ + +
+ An example of word-based tokenization. + +
+ +text ကို ပိုင်းခြားဖို့ နည်းလမ်းအမျိုးမျိုး ရှိပါတယ်။ ဥပမာအားဖြင့်၊ Python ရဲ့ `split()` function ကို အသုံးပြုပြီး whitespace ကို သုံးကာ text ကို စကားလုံးတွေအဖြစ် tokenize လုပ်ဆောင်နိုင်ပါတယ်။ + +```py +tokenized_text = "Jim Henson was a puppeteer".split() +print(tokenized_text) +``` + +```python out +['Jim', 'Henson', 'was', 'a', 'puppeteer'] +``` + +punctuation အတွက် အပိုစည်းမျဉ်းတွေရှိတဲ့ word tokenizer အမျိုးအစားတွေလည်း ရှိပါသေးတယ်။ ဒီလို tokenizer အမျိုးအစားနဲ့ဆိုရင် ကျွန်တော်တို့ဟာ အတော်လေး ကြီးမားတဲ့ "vocabularies" တွေနဲ့ အဆုံးသတ်နိုင်ပါတယ်။ vocabulary ဆိုတာက ကျွန်တော်တို့ရဲ့ corpus မှာရှိတဲ့ သီးခြား tokens စုစုပေါင်းအရေအတွက်နဲ့ သတ်မှတ်ပါတယ်။ + +စကားလုံးတစ်ခုစီကို ID တစ်ခုစီ ခွဲပေးပြီး 0 ကနေစပြီး vocabulary အရွယ်အစားအထိ သတ်မှတ်ပေးပါတယ်။ model က ဒီ IDs တွေကို စကားလုံးတစ်ခုစီကို ခွဲခြားသိမြင်ဖို့ အသုံးပြုပါတယ်။ + +ကျွန်တော်တို့ဟာ word-based tokenizer တစ်ခုနဲ့ ဘာသာစကားတစ်ခုကို အပြည့်အစုံ ကာဗာလုပ်ချင်တယ်ဆိုရင်၊ ဘာသာစကားထဲက စကားလုံးတစ်ခုစီအတွက် identifier တစ်ခုစီ ရှိဖို့ လိုအပ်ပါလိမ့်မယ်။ ဒါက ကြီးမားတဲ့ tokens အရေအတွက်ကို ထုတ်ပေးပါလိမ့်မယ်။ ဥပမာအားဖြင့်၊ English ဘာသာစကားမှာ စကားလုံး ၅၀၀,၀၀၀ ကျော်ရှိတာကြောင့် စကားလုံးတစ်ခုစီကနေ input ID တစ်ခုဆီ map လုပ်ဖို့အတွက် ID အရေအတွက် အများကြီးကို မှတ်ထားဖို့ လိုအပ်ပါလိမ့်မယ်။ ဒါ့အပြင် "dog" လို စကားလုံးတွေကို "dogs" လို စကားလုံးတွေနဲ့ မတူအောင် ကိုယ်စားပြုထားပြီး၊ "dog" နဲ့ "dogs" တို့ဟာ ဆင်တူတယ်ဆိုတာကို model က အစပိုင်းမှာ သိဖို့ နည်းလမ်းမရှိပါဘူး- ၎င်းက စကားလုံးနှစ်ခုကို ဆက်စပ်မှုမရှိဘူးလို့ ခွဲခြားသတ်မှတ်ပါလိမ့်မယ်။ "run" နဲ့ "running" လို အခြားဆင်တူစကားလုံးတွေနဲ့လည်း အတူတူပါပဲ၊ model က အစပိုင်းမှာ ဆင်တူတယ်လို့ မမြင်ပါဘူး။ + +နောက်ဆုံးအနေနဲ့၊ ကျွန်တော်တို့ရဲ့ vocabulary မှာ မပါဝင်တဲ့ စကားလုံးတွေကို ကိုယ်စားပြုဖို့ custom token တစ်ခု လိုအပ်ပါတယ်။ ဒါကို "unknown" token လို့ ခေါ်ပြီး၊ မကြာခဏဆိုသလို "[UNK]" သို့မဟုတ် "<unk>" နဲ့ ကိုယ်စားပြုပါတယ်။ tokenizer က ဒီ tokens တွေ အများကြီး ထုတ်ပေးနေတာကို သင်တွေ့ရရင် ဒါက မကောင်းတဲ့ လက္ခဏာတစ်ခုပါ။ ဘာလို့လဲဆိုတော့ ၎င်းက စကားလုံးတစ်ခုရဲ့ အဓိပ္ပာယ်ရှိတဲ့ ကိုယ်စားပြုမှုကို ရယူနိုင်ခြင်းမရှိဘဲ၊ သင်ဟာ အချက်အလက်တွေကို ဆုံးရှုံးနေတာကြောင့်ပါပဲ။ vocabulary ကို ဖန်တီးတဲ့အခါ ရည်ရွယ်ချက်ကတော့ tokenizer က unknown token အဖြစ် စကားလုံးအနည်းဆုံးကို tokenized လုပ်နိုင်အောင် ဖန်တီးဖို့ပါပဲ။ + +unknown tokens အရေအတွက်ကို လျှော့ချဖို့ နည်းလမ်းတစ်ခုကတော့ တစ်ဆင့်နိမ့်ဆင်းပြီး *character-based* tokenizer ကို အသုံးပြုဖို့ပါပဲ။ + +## Character-based[[character-based]] + + + +Character-based tokenizers တွေက text ကို စကားလုံးတွေအစား characters တွေအဖြစ် ပိုင်းခြားပါတယ်။ ဒါက အဓိက အကျိုးကျေးဇူး နှစ်ခု ရှိပါတယ်- + +- Vocabulary က အများကြီး သေးငယ်ပါတယ်။ +- out-of-vocabulary (unknown) tokens တွေ အများကြီး နည်းပါးသွားပါတယ်။ ဘာလို့လဲဆိုတော့ စကားလုံးတိုင်းကို characters တွေကနေ တည်ဆောက်နိုင်လို့ပါ။ + +ဒါပေမယ့် ဒီနေရာမှာလည်း နေရာလွတ်တွေ (spaces) နဲ့ punctuation တွေနဲ့ ပတ်သက်ပြီး မေးခွန်းအချို့ ပေါ်ပေါက်လာပါတယ်။ + +
+ An example of character-based tokenization. + +
+ +ဒီနည်းလမ်းကလည်း ပြီးပြည့်စုံတာ မဟုတ်ပါဘူး။ ကိုယ်စားပြုမှုဟာ စကားလုံးတွေအစား characters တွေပေါ် အခြေခံထားတာကြောင့်၊ တစ်ခုတည်းသော character တစ်ခုက သူ့ဘာသာသူ အဓိပ္ပာယ်သိပ်မရှိဘူးလို့ အလိုလိုဆိုနိုင်ပါတယ်။ စကားလုံးတွေနဲ့ဆိုရင်တော့ အဲလို မဟုတ်ပါဘူး။ ဒါပေမယ့် ဒါက ဘာသာစကားပေါ် မူတည်ပြီး ကွဲပြားပါတယ်။ ဥပမာအားဖြင့်၊ တရုတ်ဘာသာစကားမှာ character တစ်ခုစီက Latin ဘာသာစကားက character တစ်ခုထက် အချက်အလက် ပိုသယ်ဆောင်ပါတယ်။ + +စဉ်းစားရမယ့် နောက်ထပ်အချက်တစ်ခုကတော့ ကျွန်တော်တို့ရဲ့ model က လုပ်ဆောင်ရမယ့် tokens ပမာဏ အများကြီးနဲ့ အဆုံးသတ်ရပါလိမ့်မယ်။ word-based tokenizer တစ်ခုနဲ့ဆိုရင် စကားလုံးတစ်လုံးဟာ token တစ်ခုတည်းသာ ဖြစ်ပေမယ့်၊ characters တွေအဖြစ် ပြောင်းလဲလိုက်တဲ့အခါ token ၁၀ ခု သို့မဟုတ် ပိုများတဲ့အထိ အလွယ်တကူ ဖြစ်သွားနိုင်ပါတယ်။ + +နှစ်ခုစလုံးရဲ့ အကောင်းဆုံးကို ရယူဖို့အတွက်၊ ချဉ်းကပ်မှုနှစ်ခုကို ပေါင်းစပ်ထားတဲ့ တတိယနည်းပညာဖြစ်တဲ့ *subword tokenization* ကို ကျွန်တော်တို့ အသုံးပြုနိုင်ပါတယ်။ + +## Subword Tokenization[[subword-tokenization]] + + + +Subword tokenization algorithm တွေဟာ မကြာခဏ အသုံးပြုတဲ့ စကားလုံးတွေကို ပိုသေးငယ်တဲ့ subwords တွေအဖြစ် ပိုင်းခြားသင့်ပါဘူး၊ ဒါပေမယ့် ရှားပါးတဲ့ စကားလုံးတွေကိုတော့ အဓိပ္ပာယ်ရှိတဲ့ subwords တွေအဖြစ် ခွဲခြမ်းသင့်တယ်ဆိုတဲ့ နိယာမပေါ် အခြေခံပါတယ်။ + +ဥပမာအားဖြင့်၊ "annoyingly" ကို ရှားပါးတဲ့ စကားလုံးအဖြစ် မှတ်ယူနိုင်ပြီး "annoying" နဲ့ "ly" အဖြစ် ခွဲခြားနိုင်ပါတယ်။ ဒါတွေဟာ တစ်ဦးချင်းစီ subwords တွေအဖြစ် ပိုမိုမကြာခဏ ပေါ်လာနိုင်ဖွယ်ရှိပြီး၊ တစ်ချိန်တည်းမှာ "annoyingly" ရဲ့ အဓိပ္ပာယ်ကို "annoying" နဲ့ "ly" ရဲ့ ပေါင်းစပ်အဓိပ္ပာယ်ကနေ ထိန်းသိမ်းထားပါတယ်။ + +ဒီနေရာမှာ subword tokenization algorithm က "Let's do tokenization!" ဆိုတဲ့ sequence ကို ဘယ်လို tokenize လုပ်မယ်ဆိုတာကို ပြသထားတဲ့ ဥပမာတစ်ခု ဖြစ်နိုင်ပါတယ်။ + +
+ A subword tokenization algorithm. + +
+ +ဒီ subwords တွေဟာ အဓိပ္ပာယ်ဆိုင်ရာ အချက်အလက်များစွာကို ပေးစွမ်းပါတယ်။ ဥပမာအားဖြင့်၊ အထက်ပါ ဥပမာမှာ "tokenization" ကို "token" နဲ့ "ization" အဖြစ် ပိုင်းခြားခဲ့ပါတယ်။ ဒါတွေဟာ အဓိပ္ပာယ်ရှိတဲ့ tokens နှစ်ခုဖြစ်ပြီး နေရာလည်းသက်သာပါတယ် (ရှည်လျားတဲ့ စကားလုံးတစ်လုံးကို ကိုယ်စားပြုဖို့ tokens နှစ်ခုပဲ လိုအပ်ပါတယ်)။ ဒါက ကျွန်တော်တို့ကို သေးငယ်တဲ့ vocabularies တွေနဲ့ ကောင်းမွန်တဲ့ coverage ကို ပေးနိုင်ပြီး unknown tokens တွေလည်း မရှိသလောက်ပါပဲ။ + +ဒီနည်းလမ်းက Turkish လိုမျိုး agglutinative languages တွေမှာ အထူးအသုံးဝင်ပါတယ်။ ဘာလို့လဲဆိုတော့ subwords တွေကို ဆက်စပ်ပြီး (နီးပါး) ပမာဏအကန့်အသတ်မရှိ ရှည်လျားတဲ့ ရှုပ်ထွေးတဲ့ စကားလုံးတွေကို ဖွဲ့စည်းနိုင်လို့ပါ။ + +### အခြားနည်းလမ်းများ![[and-more]] + +အံ့သြစရာမလိုဘဲ၊ အခြားနည်းပညာများစွာ ရှိပါသေးတယ်။ အချို့ကို ဖော်ပြရရင်- + +- Byte-level BPE, GPT-2 မှာ အသုံးပြုထားပါတယ်။ +- WordPiece, BERT မှာ အသုံးပြုထားပါတယ်။ +- SentencePiece သို့မဟုတ် Unigram, multilingual models အများအပြားမှာ အသုံးပြုထားပါတယ်။ + +Tokenizer တွေ ဘယ်လိုအလုပ်လုပ်တယ်ဆိုတဲ့ အသိပညာဟာ API နဲ့ စတင်ဖို့ လုံလောက်သင့်ပါပြီ။ + +## Loading နှင့် Saving[[loading-and-saving]] + +Tokenizers တွေကို load လုပ်တာနဲ့ save လုပ်တာက model တွေနဲ့ လုပ်တာလိုပဲ ရိုးရှင်းပါတယ်။ တကယ်တော့၊ ၎င်းဟာ `from_pretrained()` နဲ့ `save_pretrained()` ဆိုတဲ့ methods နှစ်ခုတည်းပေါ် အခြေခံထားတာပါ။ ဒီ methods တွေက tokenizer အသုံးပြုတဲ့ algorithm (model ရဲ့ architecture နဲ့ ဆင်တူပါတယ်) နဲ့ ၎င်းရဲ့ vocabulary (model ရဲ့ weights နဲ့ ဆင်တူပါတယ်) နှစ်ခုလုံးကို load သို့မဟုတ် save လုပ်ပေးပါလိမ့်မယ်။ + +BERT နဲ့ တူညီတဲ့ checkpoint နဲ့ train လုပ်ထားတဲ့ BERT tokenizer ကို load လုပ်တာက model ကို load လုပ်တာနဲ့ နည်းလမ်းတူတူပါပဲ၊ ဒါပေမယ့် ကျွန်တော်တို့က `BertTokenizer` class ကို အသုံးပြုရုံပါပဲ။ + +```py +from transformers import BertTokenizer + +tokenizer = BertTokenizer.from_pretrained("bert-base-cased") +``` + +`AutoModel` နဲ့ ဆင်တူစွာ၊ `AutoTokenizer` class က checkpoint name ကို အခြေခံပြီး library ထဲက မှန်ကန်တဲ့ tokenizer class ကို ရယူပါလိမ့်မယ်၊ ပြီးတော့ မည်သည့် checkpoint နဲ့မဆို တိုက်ရိုက် အသုံးပြုနိုင်စေပါတယ်။ + +```py +from transformers import AutoTokenizer + +tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") +``` + +အခု ကျွန်တော်တို့ tokenizer ကို ယခင်အပိုင်းမှာ ပြသခဲ့သလို အသုံးပြုနိုင်ပါပြီ။ + +```python +tokenizer("Using a Transformer network is simple") +``` + +```python out +{'input_ids': [101, 7993, 170, 11303, 1200, 2443, 1110, 3014, 102], + 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0], + 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1]} +``` + +tokenizer ကို save လုပ်တာက model ကို save လုပ်တာနဲ့ အတူတူပါပဲ။ + +```py +tokenizer.save_pretrained("directory_on_my_computer") +``` + +`token_type_ids` အကြောင်းကို [Chapter 3](/course/chapter3) မှာ ပိုပြီး အသေးစိတ် ဆွေးနွေးပါမယ်။ `attention_mask` key ကိုတော့ နောက်မှ အနည်းငယ် ရှင်းပြပါမယ်။ ပထမဆုံးအနေနဲ့ `input_ids` တွေ ဘယ်လို ထုတ်လုပ်ခဲ့လဲဆိုတာ ကြည့်ရအောင်။ ဒါကို လုပ်ဖို့ tokenizer ရဲ့ ကြားခံ methods တွေကို ကြည့်ဖို့ လိုအပ်ပါလိမ့်မယ်။ + +## Encoding[[encoding]] + + + +Text ကို ဂဏန်းတွေအဖြစ် ပြောင်းလဲတာကို *encoding* လို့ ခေါ်ပါတယ်။ Encoding ကို အဆင့်နှစ်ဆင့်နဲ့ လုပ်ဆောင်ပါတယ်- tokenization လုပ်ခြင်း၊ ပြီးရင် input IDs တွေအဖြစ် ပြောင်းလဲခြင်းတို့ ဖြစ်ပါတယ်။ + +ကျွန်တော်တို့ တွေ့ခဲ့ရသလိုပဲ၊ ပထမအဆင့်က text ကို စကားလုံးတွေအဖြစ် (သို့မဟုတ် စကားလုံးအစိတ်အပိုင်းများ၊ punctuation symbols စသည်တို့) ပိုင်းခြားတာဖြစ်ပြီး၊ ဒါကို အများအားဖြင့် *tokens* လို့ ခေါ်ပါတယ်။ ဒီလုပ်ငန်းစဉ်ကို ထိန်းချုပ်နိုင်တဲ့ စည်းမျဉ်းများစွာ ရှိတာကြောင့် model ကို pretrained လုပ်ခဲ့တုန်းက အသုံးပြုခဲ့တဲ့ စည်းမျဉ်းတွေ အတူတူကို သေချာအသုံးပြုနိုင်ဖို့ model ရဲ့ နာမည်ကို အသုံးပြုပြီး tokenizer ကို instantiate လုပ်ဖို့ လိုအပ်ပါတယ်။ + +ဒုတိယအဆင့်ကတော့ အဲဒီ tokens တွေကို ဂဏန်းတွေအဖြစ် ပြောင်းလဲတာပါ၊ ဒါမှ ၎င်းတို့ကနေ tensor တစ်ခုကို တည်ဆောက်ပြီး model ကို ထည့်သွင်းပေးနိုင်မှာပါ။ ဒါကို လုပ်ဖို့အတွက် tokenizer မှာ *vocabulary* တစ်ခုရှိပြီး၊ ဒါက `from_pretrained()` method နဲ့ instantiate လုပ်တဲ့အခါ ကျွန်တော်တို့ download လုပ်တဲ့ အစိတ်အပိုင်းပါပဲ။ ထပ်မံပြီး၊ model ကို pretrained လုပ်ခဲ့တုန်းက အသုံးပြုခဲ့တဲ့ vocabulary အတူတူကို ကျွန်တော်တို့ အသုံးပြုဖို့ လိုအပ်ပါတယ်။ + +အဆင့်နှစ်ဆင့်ကို ပိုမိုနားလည်နိုင်ဖို့အတွက် ၎င်းတို့ကို သီးခြားစီ လေ့လာသွားပါမယ်။ tokenization pipeline ရဲ့ အစိတ်အပိုင်းအချို့ကို သီးခြားစီ လုပ်ဆောင်တဲ့ methods အချို့ကို ကျွန်တော်တို့ အသုံးပြုသွားမှာပါ။ ဒါက အဲဒီအဆင့်တွေရဲ့ ကြားခံရလဒ်တွေကို သင့်ကို ပြသဖို့ပါပဲ။ ဒါပေမယ့် လက်တွေ့မှာတော့ သင်ဟာ သင်ရဲ့ inputs တွေပေါ်မှာ tokenizer ကို တိုက်ရိုက် ခေါ်ဆိုသင့်ပါတယ် (အပိုင်း ၂ မှာ ပြထားသလို)။ + +### Tokenization[[tokenization]] + +Tokenization လုပ်ငန်းစဉ်ကို tokenizer ရဲ့ `tokenize()` method က လုပ်ဆောင်ပါတယ်။ + +```py +from transformers import AutoTokenizer + +tokenizer = AutoTokenizer.from_pretrained("bert-base-cased") + +sequence = "Using a Transformer network is simple" +tokens = tokenizer.tokenize(sequence) + +print(tokens) +``` + +ဒီ method ရဲ့ output ကတော့ strings ဒါမှမဟုတ် tokens တွေရဲ့ list တစ်ခုပါ။ + +```python out +['Using', 'a', 'transform', '##er', 'network', 'is', 'simple'] +``` + +ဒီ tokenizer က subword tokenizer တစ်ခုပါ- ဒါက စကားလုံးတွေကို သူ့ရဲ့ vocabulary က ကိုယ်စားပြုနိုင်တဲ့ tokens တွေ ရရှိတဲ့အထိ ပိုင်းခြားပေးပါတယ်။ ဒီဥပမာမှာ `transformer` ကို `transform` နဲ့ `##er` ဆိုတဲ့ tokens နှစ်ခုအဖြစ် ပိုင်းခြားထားတာကို တွေ့ရပါတယ်။ + +### Tokens တွေကနေ Input IDs တွေဆီသို့[[from-tokens-to-input-ids]] + +Input IDs တွေအဖြစ် ပြောင်းလဲခြင်းကို `convert_tokens_to_ids()` tokenizer method က ကိုင်တွယ်ပါတယ်။ + +```py +ids = tokenizer.convert_tokens_to_ids(tokens) + +print(ids) +``` + +```python out +[7993, 170, 11303, 1200, 2443, 1110, 3014] +``` + +ဒီ outputs တွေကို သင့်လျော်တဲ့ framework tensor အဖြစ် ပြောင်းလဲပြီးတာနဲ့၊ ဒီအခန်းရဲ့ အစောပိုင်းမှာ တွေ့ခဲ့ရသလို model ရဲ့ inputs တွေအဖြစ် အသုံးပြုနိုင်ပါတယ်။ + + + +✏️ **စမ်းသပ်ကြည့်ပါ။** အပိုင်း ၂ မှာ အသုံးပြုခဲ့တဲ့ input sentences တွေ ("I've been waiting for a HuggingFace course my whole life." နဲ့ "I hate this so much!") ပေါ်မှာ နောက်ဆုံးအဆင့်နှစ်ခု (tokenization နဲ့ input IDs အဖြစ် ပြောင်းလဲခြင်း) ကို ပြန်လည်လုပ်ဆောင်ပါ။ ကျွန်တော်တို့ အစောပိုင်းက ရရှိခဲ့တဲ့ input IDs တွေ အတူတူ ရရှိမရရှိ စစ်ဆေးပါ။ + + + +## Decoding[[decoding]] + +*Decoding* ဆိုတာကတော့ ပြောင်းပြန်လုပ်တာပါ၊ vocabulary indices တွေကနေ string တစ်ခုကို ပြန်ရချင်တာပါ။ ဒါကို `decode()` method နဲ့ အောက်ပါအတိုင်း လုပ်ဆောင်နိုင်ပါတယ်။ + +```py +decoded_string = tokenizer.decode([7993, 170, 11303, 1200, 2443, 1110, 3014]) +print(decoded_string) +``` + +```python out +'Using a Transformer network is simple' +``` + +`decode` method က indices တွေကို tokens တွေအဖြစ် ပြန်ပြောင်းပေးရုံသာမကဘဲ၊ တူညီတဲ့ စကားလုံးရဲ့ အစိတ်အပိုင်းဖြစ်တဲ့ tokens တွေကို စုစည်းပြီး ဖတ်လို့ရတဲ့ စာကြောင်းတစ်ခုကို ထုတ်လုပ်ပေးတာကို သတိပြုပါ။ ဒီ behavior က text အသစ်တွေကို ခန့်မှန်းတဲ့ model တွေကို အသုံးပြုတဲ့အခါ (prompt တစ်ခုကနေ ထုတ်လုပ်တဲ့ text ဖြစ်စေ၊ ဒါမှမဟုတ် translation သို့မဟုတ် summarization လို sequence-to-sequence ပြဿနာတွေအတွက် ဖြစ်စေ) အလွန်အသုံးဝင်ပါလိမ့်မယ်။ + +အခုဆိုရင် tokenizer တစ်ခုက ကိုင်တွယ်နိုင်တဲ့ atomic operations တွေကို သင်နားလည်သင့်ပါပြီ- tokenization လုပ်ခြင်း၊ IDs တွေအဖြစ် ပြောင်းလဲခြင်း၊ နဲ့ IDs တွေကို string အဖြစ် ပြန်ပြောင်းလဲခြင်းတို့ ဖြစ်ပါတယ်။ သို့သော်လည်း၊ ကျွန်တော်တို့ဟာ ရေခဲတောင်ရဲ့ ထိပ်ဖျားလေးကိုပဲ ကုတ်ဖဲ့မိပါသေးတယ်။ နောက်အပိုင်းမှာတော့ ကျွန်တော်တို့ရဲ့ နည်းလမ်းကို သူ့ရဲ့ အကန့်အသတ်တွေဆီ ယူဆောင်သွားပြီး ၎င်းတို့ကို ဘယ်လိုကျော်လွှားရမလဲဆိုတာ ကြည့်ရပါလိမ့်မယ်။ + +## ဝေါဟာရ ရှင်းလင်းချက် (Glossary) + +* **Tokenizers**: စာသား (သို့မဟုတ် အခြားဒေတာ) ကို AI မော်ဒယ်များ စီမံဆောင်ရွက်နိုင်ရန် tokens တွေအဖြစ် ပိုင်းခြားပေးသည့် ကိရိယာ သို့မဟုတ် လုပ်ငန်းစဉ်။ +* **NLP Pipeline**: Natural Language Processing (NLP) လုပ်ငန်းတာဝန်တစ်ခုကို ပြီးမြောက်အောင် လုပ်ဆောင်ရန် အဆင့်ဆင့် လုပ်ဆောင်ရမည့် လုပ်ငန်းစဉ်များ။ +* **Raw Text**: မည်သည့်လုပ်ဆောင်မှုမျှ မပြုလုပ်ရသေးသော သို့မဟုတ် ပုံစံမချရသေးသော မူရင်းစာသား။ +* **Numerical Data**: ဂဏန်းပုံစံဖြင့် ဖော်ပြထားသော အချက်အလက်များ။ +* **Tokenization**: စာသားကို tokens များအဖြစ် ပိုင်းခြားသော လုပ်ငန်းစဉ်။ +* **Tokens**: စာသားကို ခွဲခြမ်းစိတ်ဖြာရာတွင် အသုံးပြုသော အသေးငယ်ဆုံးယူနစ်များ (ဥပမာ- စကားလုံးများ၊ subwords များ သို့မဟုတ် ပုဒ်ဖြတ်သံများ)။ +* **Word-based Tokenizer**: စာသားကို စကားလုံးများအဖြစ် ပိုင်းခြားသော tokenizer အမျိုးအစား။ +* **Whitespace**: စာသားထဲရှိ နေရာလွတ်များ (space, tab, newline)။ +* **`split()` Function**: Python တွင် string တစ်ခုကို သတ်မှတ်ထားသော delimiter ဖြင့် ပိုင်းခြားရန် အသုံးပြုသော function။ +* **Vocabulary**: tokenizer သို့မဟုတ် model တစ်ခုက သိရှိနားလည်ပြီး ကိုင်တွယ်နိုင်သော ထူးခြားသည့် tokens များ စုစုပေါင်း။ +* **Corpus**: Machine Learning တွင် အသုံးပြုသော စာသားဒေတာအစုအဝေးကြီး။ +* **ID**: token တစ်ခုစီကို ကိုယ်စားပြုသော ထူးခြားသည့် ဂဏန်း။ +* **Unknown Token (`[UNK]`, ``)**: tokenizer ၏ vocabulary တွင် မပါဝင်သော စကားလုံးများကို ကိုယ်စားပြုရန် အသုံးပြုသော special token။ +* **Character-based Tokenizer**: စာသားကို characters များအဖြစ် ပိုင်းခြားသော tokenizer အမျိုးအစား။ +* **Out-of-vocabulary (OOV) Tokens**: tokenizer ၏ vocabulary တွင် မပါဝင်သော tokens များ။ +* **Subword Tokenization**: မကြာခဏ အသုံးပြုသော စကားလုံးများကို မခွဲဘဲ၊ ရှားပါးသော စကားလုံးများကို အဓိပ္ပာယ်ရှိသော subwords များအဖြစ် ခွဲခြားသော tokenization နည်းလမ်း။ +* **Agglutinative Languages**: စကားလုံးများကို အစိတ်အပိုင်းငယ်လေးများ ပေါင်းစပ်ခြင်းဖြင့် ဖွဲ့စည်းထားသော ဘာသာစကားများ (ဥပမာ- တူရကီဘာသာ)။ +* **Byte-level BPE**: Byte Pair Encoding (BPE) ၏ ပြောင်းလဲထားသော ပုံစံတစ်ခုဖြစ်ပြီး characters များအစား bytes များကို အသုံးပြုသည်။ GPT-2 တွင် အသုံးပြုသည်။ +* **WordPiece**: Google မှ ဖန်တီးထားသော subword tokenization algorithm တစ်ခုဖြစ်ပြီး BERT တွင် အသုံးပြုသည်။ +* **SentencePiece / Unigram**: Google မှ ဖန်တီးထားသော subword tokenization algorithm များဖြစ်ပြီး multilingual models များတွင် အသုံးပြုသည်။ +* **`AutoTokenizer` Class**: Hugging Face Transformers library မှာ ပါဝင်တဲ့ class တစ်ခုဖြစ်ပြီး မော်ဒယ်အမည်ကို အသုံးပြုပြီး သက်ဆိုင်ရာ tokenizer ကို အလိုအလျောက် load လုပ်ပေးသည်။ +* **`BertTokenizer` Class**: BERT model အတွက် သီးသန့်ဒီဇိုင်းထုတ်ထားသော tokenizer class။ +* **`from_pretrained()` Method**: Pre-trained model သို့မဟုတ် tokenizer ကို load လုပ်ရန် အသုံးပြုသော method။ +* **`save_pretrained()` Method**: Model သို့မဟုတ် tokenizer ၏ weights များနှင့် architecture configuration ကို save လုပ်ရန် အသုံးပြုသော method။ +* **Encoding**: Text ကို ဂဏန်းဆိုင်ရာ ကိုယ်စားပြုမှုအဖြစ် ပြောင်းလဲသော လုပ်ငန်းစဉ်။ +* **`tokenize()` Method**: tokenizer ၏ text ကို tokens များအဖြစ် ပိုင်းခြားပေးသော method။ +* **`convert_tokens_to_ids()` Method**: tokens list ကို input IDs list အဖြစ် ပြောင်းလဲပေးသော tokenizer method။ +* **Decoding**: ဂဏန်းဆိုင်ရာ ကိုယ်စားပြုမှု (vocabulary indices) များမှ မူရင်းစာသားသို့ ပြန်ပြောင်းလဲသော လုပ်ငန်းစဉ်။ +* **`decode()` Method**: input IDs များကို မူရင်းစာသားသို့ ပြန်ပြောင်းလဲပေးသော method။ +* **Sequence-to-sequence Problems**: input sequence တစ်ခုမှ output sequence တစ်ခုသို့ ပြောင်းလဲခြင်း လုပ်ငန်းများ (ဥပမာ- ဘာသာပြန်ခြင်း၊ အနှစ်ချုပ်ခြင်း)။ +* **Prompt**: မော်ဒယ်ကို text ထုတ်လုပ်ရန်အတွက် ပေးသော အစစာသား။ \ No newline at end of file diff --git a/chapters/my/chapter2/5.mdx b/chapters/my/chapter2/5.mdx new file mode 100644 index 000000000..7be56ee32 --- /dev/null +++ b/chapters/my/chapter2/5.mdx @@ -0,0 +1,231 @@ + + +# Sequence များစွာကို ကိုင်တွယ်ခြင်း[[handling-multiple-sequences]] + + + + + +ယခင်အပိုင်းမှာ ကျွန်တော်တို့ဟာ အသေးစား အရှည်ရှိတဲ့ sequence တစ်ခုတည်းပေါ်မှာ inference လုပ်တဲ့ အလွယ်ကူဆုံး အသုံးပြုမှုပုံစံကို လေ့လာခဲ့ပါတယ်။ သို့သော်လည်း၊ အချို့မေးခွန်းတွေ အခုကတည်းက ပေါ်ပေါက်လာပါတယ်- + +- sequence များစွာကို ဘယ်လိုကိုင်တွယ်မလဲ။ +- *အရှည်မတူညီတဲ့* sequence များစွာကို ဘယ်လိုကိုင်တွယ်မလဲ။ +- vocabulary indices တွေဟာ model က ကောင်းကောင်း အလုပ်လုပ်နိုင်ဖို့ တစ်ခုတည်းသော input တွေလား။ +- အရမ်းရှည်လျားတဲ့ sequence မျိုး ရှိပါသလား။ + +ဒီမေးခွန်းတွေက ဘယ်လိုပြဿနာတွေ ဖြစ်စေလဲ၊ Hugging Face Transformers API ကို အသုံးပြုပြီး ဒါတွေကို ဘယ်လိုဖြေရှင်းနိုင်လဲဆိုတာ ကြည့်ရအောင်။ + +## Model များသည် Inputs များ၏ Batch တစ်ခုကို မျှော်လင့်ကြသည်[[models-expect-a-batch-of-inputs]] + +ယခင် လေ့ကျင့်ခန်းမှာ sequence တွေကို ဂဏန်း list တွေအဖြစ် ဘယ်လိုပြောင်းလဲတယ်ဆိုတာကို သင်တွေ့ခဲ့ရပါတယ်။ ဒီဂဏန်း list ကို tensor အဖြစ် ပြောင်းလဲပြီး model ကို ပို့ကြည့်ရအောင်။ + +```py +import torch +from transformers import AutoTokenizer, AutoModelForSequenceClassification + +checkpoint = "distilbert-base-uncased-finetuned-sst-2-english" +tokenizer = AutoTokenizer.from_pretrained(checkpoint) +model = AutoModelForSequenceClassification.from_pretrained(checkpoint) + +sequence = "I've been waiting for a HuggingFace course my whole life." + +tokens = tokenizer.tokenize(sequence) +ids = tokenizer.convert_tokens_to_ids(tokens) +input_ids = torch.tensor(ids) +# This line will fail. +model(input_ids) +``` + +```python out +IndexError: Dimension out of range (expected to be in range of [-1, 0], but got 1) +``` + +ဟာ မဟုတ်သေးပါဘူး။ ဒါက ဘာကြောင့် အဆင်မပြေတာလဲ။ ကျွန်တော်တို့ အပိုင်း ၂ မှာပါတဲ့ pipeline အဆင့်တွေကို လိုက်နာခဲ့တာပဲလေဗျာ။ + +ပြဿနာကတော့ ကျွန်တော်တို့ model ကို single sequence တစ်ခုပဲ ပို့ခဲ့တာပါ၊ ဒါပေမယ့် 🤗 Transformers model တွေက default အားဖြင့် sentences များစွာကို မျှော်လင့်ထားပါတယ်။ ဒီနေရာမှာ tokenizer က `sequence` တစ်ခုပေါ်မှာ အသုံးပြုခဲ့တုန်းက နောက်ကွယ်မှာ လုပ်ခဲ့တဲ့အရာ အားလုံးကို ကျွန်တော်တို့ လုပ်ဆောင်ဖို့ ကြိုးစားခဲ့ပါတယ်။ ဒါပေမယ့် သေချာကြည့်မယ်ဆိုရင် tokenizer က input IDs list ကို tensor တစ်ခုအဖြစ် ပြောင်းပေးရုံသာမကဘဲ၊ ၎င်းရဲ့ အပေါ်မှာ dimension တစ်ခုကို ထည့်သွင်းခဲ့တယ်ဆိုတာကို သင်တွေ့ရပါလိမ့်မယ်- + +```py +tokenized_inputs = tokenizer(sequence, return_tensors="pt") +print(tokenized_inputs["input_ids"]) +``` + +```python out +tensor([[ 101, 1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, + 2607, 2026, 2878, 2166, 1012, 102]]) +``` + +နောက်တစ်ကြိမ် ထပ်ကြိုးစားပြီး dimension အသစ်တစ်ခု ထည့်ကြည့်ရအောင်။ + +```py +import torch +from transformers import AutoTokenizer, AutoModelForSequenceClassification + +checkpoint = "distilbert-base-uncased-finetuned-sst-2-english" +tokenizer = AutoTokenizer.from_pretrained(checkpoint) +model = AutoModelForSequenceClassification.from_pretrained(checkpoint) + +sequence = "I've been waiting for a HuggingFace course my whole life." + +tokens = tokenizer.tokenize(sequence) +ids = tokenizer.convert_tokens_to_ids(tokens) + +input_ids = torch.tensor([ids]) +print("Input IDs:", input_ids) + +output = model(input_ids) +print("Logits:", output.logits) +``` + +ကျွန်တော်တို့ input IDs တွေရော၊ ထွက်လာတဲ့ logits တွေရော print လုပ်လိုက်ပါတယ်၊ ဒါကတော့ output ပါ။ + +```python out +Input IDs: [[ 1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012]] +Logits: [[-2.7276, 2.8789]] +``` + +*Batching* ဆိုတာက model ကို sentences များစွာကို တစ်ပြိုင်နက်တည်း ပေးပို့တဲ့ လုပ်ဆောင်ချက်ပါပဲ။ သင့်မှာ စာကြောင်းတစ်ကြောင်းတည်းသာ ရှိရင်၊ single sequence တစ်ခုတည်းနဲ့ batch တစ်ခုကို တည်ဆောက်နိုင်ပါတယ်။ + +``` +batched_ids = [ids, ids] +``` + +ဒါက အတူတူ sequences နှစ်ခုပါတဲ့ batch တစ်ခုပါပဲ။ + + + +✏️ **စမ်းသပ်ကြည့်ပါ။** ဒီ `batched_ids` list ကို tensor အဖြစ် ပြောင်းလဲပြီး သင့် model ကို ဖြတ်သန်းပါ။ ယခင်က ရရှိခဲ့တဲ့ logits တွေ အတူတူ (ဒါပေမယ့် နှစ်ဆ) ရရှိမရရှိ စစ်ဆေးပါ။ + + + +Batching လုပ်ခြင်းက သင် model ကို sentences များစွာ ထည့်သွင်းတဲ့အခါ အလုပ်လုပ်စေပါတယ်။ sentences များစွာကို အသုံးပြုတာက single sequence နဲ့ batch တစ်ခုတည်ဆောက်တာလိုပဲ ရိုးရှင်းပါတယ်။ ဒါပေမယ့် ဒုတိယပြဿနာတစ်ခု ရှိပါတယ်။ စာကြောင်းနှစ်ခု (သို့မဟုတ် ပိုများ) ကို batch လုပ်ဖို့ ကြိုးစားတဲ့အခါ၊ ၎င်းတို့ရဲ့ အရှည်တွေက မတူညီနိုင်ပါဘူး။ သင် tensors တွေနဲ့ အရင်က အလုပ်လုပ်ဖူးတယ်ဆိုရင်၊ ၎င်းတို့ဟာ ထောင့်မှန်ပုံစံ (rectangular shape) ဖြစ်ဖို့ လိုအပ်တယ်ဆိုတာ သင်သိပါလိမ့်မယ်။ ဒါကြောင့် input IDs list ကို tensor တစ်ခုအဖြစ် တိုက်ရိုက်ပြောင်းလို့ ရမှာ မဟုတ်ပါဘူး။ ဒီပြဿနာကို ဖြေရှင်းဖို့အတွက် ကျွန်တော်တို့ဟာ inputs တွေကို များသောအားဖြင့် *pad* လုပ်ပါတယ်။ + +## Inputs များကို Padding လုပ်ခြင်း[[padding-the-inputs]] + +အောက်ပါ list of lists ကို tensor အဖြစ် ပြောင်းလဲလို့ မရပါဘူး။ + +```py no-format +batched_ids = [ + [200, 200, 200], + [200, 200] +] +``` + +ဒီပြဿနာကို ဖြေရှင်းဖို့အတွက် ကျွန်တော်တို့ tensors တွေကို ထောင့်မှန်ပုံစံ ဖြစ်အောင် ပြုလုပ်ဖို့ *padding* ကို အသုံးပြုပါမယ်။ Padding က ကျွန်တော်တို့ရဲ့ sentences တွေအားလုံးကို အရှည်တူညီအောင် သေချာစေဖို့အတွက် *padding token* လို့ခေါ်တဲ့ special word တစ်ခုကို တန်ဖိုးနည်းတဲ့ sentences တွေမှာ ထည့်ပေးပါတယ်။ ဥပမာအားဖြင့်၊ သင့်မှာ စကားလုံး ၁၀ လုံးပါတဲ့ စာကြောင်း ၁၀ ကြောင်းနဲ့ စကားလုံး ၂၀ လုံးပါတဲ့ စာကြောင်း ၁ ကြောင်းရှိရင်၊ padding က စာကြောင်းအားလုံးမှာ စကားလုံး ၂၀ လုံးစီ ရှိစေမှာပါ။ ကျွန်တော်တို့ရဲ့ ဥပမာမှာ၊ ထွက်လာတဲ့ tensor က ဒီလိုဖြစ်ပါတယ်။ + +```py no-format +padding_id = 100 + +batched_ids = [ + [200, 200, 200], + [200, 200, padding_id], +] +``` + +padding token ID ကို `tokenizer.pad_token_id` မှာ ရှာတွေ့နိုင်ပါတယ်။ ဒါကို အသုံးပြုပြီး ကျွန်တော်တို့ရဲ့ စာကြောင်းနှစ်ကြောင်းကို model ကနေတဆင့် တစ်ဦးချင်းစီနဲ့ batch အဖြစ် ပေါင်းပြီး ပို့ကြည့်ရအောင်။ + +```py no-format +model = AutoModelForSequenceClassification.from_pretrained(checkpoint) + +sequence1_ids = [[200, 200, 200]] +sequence2_ids = [[200, 200]] +batched_ids = [ + [200, 200, 200], + [200, 200, tokenizer.pad_token_id], +] + +print(model(torch.tensor(sequence1_ids)).logits) +print(model(torch.tensor(sequence2_ids)).logits) +print(model(torch.tensor(batched_ids)).logits) +``` + +```python out +tensor([[ 1.5694, -1.3895]], grad_fn=) +tensor([[ 0.5803, -0.4125]], grad_fn=) +tensor([[ 1.5694, -1.3895], + [ 1.3373, -1.2163]], grad_fn=) +``` + +ကျွန်တော်တို့ရဲ့ batched predictions တွေထဲက logits တွေမှာ တစ်ခုခု မှားယွင်းနေပါတယ်။ ဒုတိယ row က ဒုတိယစာကြောင်းအတွက် logits တွေနဲ့ တူညီသင့်ပေမယ့်၊ ကျွန်တော်တို့မှာ လုံးဝမတူညီတဲ့ တန်ဖိုးတွေ ရနေပါတယ်။ + +ဒါက Transformer model တွေရဲ့ အဓိကအင်္ဂါရပ်ဖြစ်တဲ့ attention layers တွေက token တစ်ခုစီကို *contextualize* လုပ်ပေးလို့ ဖြစ်ပါတယ်။ ၎င်းတို့သည် sequence တစ်ခု၏ tokens အားလုံးကို အာရုံစိုက်တာကြောင့် padding tokens တွေကို ထည့်သွင်းစဉ်းစားပါလိမ့်မယ်။ မတူညီတဲ့ အရှည်ရှိတဲ့ တစ်ဦးချင်းစီ စာကြောင်းတွေကို model ကနေတဆင့် ပို့တဲ့အခါ ဒါမှမဟုတ် တူညီတဲ့ စာကြောင်းတွေနဲ့ padding လုပ်ထားတဲ့ batch တစ်ခုကို ပို့တဲ့အခါ တူညီတဲ့ရလဒ် ရရှိဖို့အတွက်၊ အဲဒီ attention layers တွေကို padding tokens တွေကို လျစ်လျူရှုဖို့ ကျွန်တော်တို့ ပြောပြဖို့ လိုအပ်ပါတယ်။ ဒါကို attention mask ကို အသုံးပြုခြင်းဖြင့် လုပ်ဆောင်ပါတယ်။ + +## Attention Masks[[attention-masks]] + +*Attention masks* တွေက input IDs tensor နဲ့ အတိအကျတူညီတဲ့ shape ရှိတဲ့ tensors တွေဖြစ်ပြီး 0 တွေနဲ့ 1 တွေနဲ့ ဖြည့်ထားပါတယ်။ 1 တွေက သက်ဆိုင်ရာ tokens တွေကို အာရုံစိုက်သင့်တယ်လို့ ဖော်ပြပြီး၊ 0 တွေကတော့ သက်ဆိုင်ရာ tokens တွေကို အာရုံစိုက်ရန် မလိုအပ်ဘူး (ဆိုလိုသည်မှာ model ရဲ့ attention layers တွေက လျစ်လျူရှုသင့်တယ်) လို့ ဖော်ပြပါတယ်။ + +ယခင် ဥပမာကို attention mask တစ်ခုနဲ့ ဖြည့်စွက်ကြည့်ရအောင်။ + +```py no-format +batched_ids = [ + [200, 200, 200], + [200, 200, tokenizer.pad_token_id], +] + +attention_mask = [ + [1, 1, 1], + [1, 1, 0], +] + +outputs = model(torch.tensor(batched_ids), attention_mask=torch.tensor(attention_mask)) +print(outputs.logits) +``` + +```python out +tensor([[ 1.5694, -1.3895], + [ 0.5803, -0.4125]], grad_fn=) +``` + +အခု batch ထဲက ဒုတိယစာကြောင်းအတွက် logits တွေ အတူတူကို ရရှိပါပြီ။ + +ဒုတိယ sequence ရဲ့ နောက်ဆုံးတန်ဖိုးက padding ID တစ်ခုဖြစ်ပြီး၊ attention mask ထဲမှာတော့ 0 တန်ဖိုးဖြစ်နေတာကို သတိပြုပါ။ + + + +✏️ **စမ်းသပ်ကြည့်ပါ။** အပိုင်း ၂ မှာ အသုံးပြုခဲ့တဲ့ စာကြောင်းနှစ်ကြောင်း ("I've been waiting for a HuggingFace course my whole life." နဲ့ "I hate this so much!") ပေါ်မှာ tokenization ကို ကိုယ်တိုင် လုပ်ဆောင်ပါ။ ၎င်းတို့ကို model ကို ဖြတ်သန်းပြီး အပိုင်း ၂ မှာ ရရှိခဲ့တဲ့ logits တွေ အတူတူ ရရှိမရရှိ စစ်ဆေးပါ။ အခု ၎င်းတို့ကို padding token ကို အသုံးပြုပြီး batch လုပ်ပါ၊ ပြီးရင် မှန်ကန်တဲ့ attention mask ကို ဖန်တီးပါ။ model ကို ဖြတ်သန်းတဲ့အခါ တူညီတဲ့ရလဒ်တွေ ရရှိမရရှိ စစ်ဆေးပါ။ + + + +## ပိုမိုရှည်လျားသော Sequences များ[[longer-sequences]] + +Transformer model တွေနဲ့ဆိုရင် model တွေကို ပေးပို့နိုင်တဲ့ sequences တွေရဲ့ အရှည်မှာ ကန့်သတ်ချက်တစ်ခု ရှိပါတယ်။ model အများစုက tokens 512 သို့မဟုတ် 1024 အထိ sequences တွေကို ကိုင်တွယ်နိုင်ပြီး၊ ပိုရှည်တဲ့ sequences တွေကို လုပ်ဆောင်ဖို့ တောင်းဆိုတဲ့အခါ crash ဖြစ်ပါလိမ့်မယ်။ ဒီပြဿနာကို ဖြေရှင်းဖို့ နည်းလမ်းနှစ်ခု ရှိပါတယ်- + +- ပိုမိုရှည်လျားတဲ့ sequence length ကို ထောက်ပံ့ပေးတဲ့ model ကို အသုံးပြုပါ။ +- သင်ရဲ့ sequences တွေကို truncate လုပ်ပါ။ + +Model တွေမှာ မတူညီတဲ့ ထောက်ပံ့ပေးထားတဲ့ sequence lengths တွေရှိပြီး၊ အချို့က အလွန်ရှည်လျားတဲ့ sequences တွေကို ကိုင်တွယ်ရာမှာ အထူးပြုပါတယ်။ [Longformer](https://huggingface.co/docs/transformers/model_doc/longformer) က ဥပမာတစ်ခုဖြစ်ပြီး၊ [LED](https://huggingface.co/docs/transformers/model_doc/led) က နောက်ဥပမာတစ်ခု ဖြစ်ပါတယ်။ သင်ဟာ အလွန်ရှည်လျားတဲ့ sequences တွေလိုအပ်တဲ့ လုပ်ငန်းတစ်ခုပေါ်မှာ အလုပ်လုပ်နေတယ်ဆိုရင်၊ အဲဒီ model တွေကို လေ့လာကြည့်ဖို့ ကျွန်တော်တို့ အကြံပြုပါတယ်။ + +မဟုတ်ရင်တော့ သင်ရဲ့ sequences တွေကို `max_sequence_length` parameter ကို သတ်မှတ်ခြင်းဖြင့် truncate လုပ်ဖို့ ကျွန်တော်တို့ အကြံပြုပါတယ်။ + +```py +sequence = sequence[:max_sequence_length] +``` +## ဝေါဟာရ ရှင်းလင်းချက် (Glossary) + +* **Inference**: လေ့ကျင့်ပြီးသား Artificial Intelligence (AI) မော်ဒယ်တစ်ခုကို အသုံးပြုပြီး input data ကနေ ခန့်မှန်းချက်တွေ ဒါမှမဟုတ် output တွေကို ထုတ်လုပ်တဲ့ လုပ်ငန်းစဉ်။ +* **Sequence**: စာသားတစ်ခု သို့မဟုတ် စကားလုံးများ၊ tokens များ၏ အစဉ်လိုက် စီစဉ်ထားသော အစုအဝေး။ +* **Vocabulary Indices**: စာသားကို encode လုပ်ပြီးနောက် ရရှိလာသော tokens တစ်ခုစီ၏ ထူးခြားသော ဂဏန်း ID များ။ +* **🤗 Transformers API**: Hugging Face Transformers library ကို အသုံးပြုရန်အတွက် ပရိုဂရမ်မာများက ခေါ်ဆိုနိုင်သော လုပ်ဆောင်ချက်များ၊ class များနှင့် methods များ။ +* **Batching**: မတူညီသော input များစွာကို တစ်ပြိုင်နက်တည်း လုပ်ဆောင်နိုင်ရန် အုပ်စုဖွဲ့ခြင်း။ +* **Tensor**: Machine Learning frameworks (PyTorch, TensorFlow) များတွင် ဒေတာများကို ကိုယ်စားပြုသော multi-dimensional array များ။ +* **`AutoTokenizer` Class**: Hugging Face Transformers library မှာ ပါဝင်တဲ့ class တစ်ခုဖြစ်ပြီး မော်ဒယ်အမည်ကို အသုံးပြုပြီး သက်ဆိုင်ရာ tokenizer ကို အလိုအလျောက် load လုပ်ပေးသည်။ +* **`AutoModelForSequenceClassification` Class**: Hugging Face Transformers library မှာ ပါဝင်တဲ့ class တစ်ခုဖြစ်ပြီး sequence classification အတွက် pre-trained model ကို အလိုအလျောက် load လုပ်ပေးသည်။ +* **`from_pretrained()` Method**: Pre-trained model သို့မဟုတ် tokenizer ကို load လုပ်ရန် အသုံးပြုသော method။ +* **`tokenize()` Method**: tokenizer ၏ text ကို tokens များအဖြစ် ပိုင်းခြားပေးသော method။ +* **`convert_tokens_to_ids()` Method**: tokens list ကို input IDs list အဖြစ် ပြောင်းလဲပေးသော tokenizer method။ +* **`input_ids`**: Tokenizer မှ ထုတ်ပေးသော tokens တစ်ခုစီ၏ ထူးခြားသော ဂဏန်းဆိုင်ရာ ID များ။ +* **`output.logits`**: မော်ဒယ်၏ နောက်ဆုံး layer မှ ထုတ်ပေးသော raw, unnormalized scores များ။ +* **Padding**: မတူညီသော အရှည်ရှိသည့် input sequence များကို အရှည်တူညီအောင် သတ်မှတ်ထားသော တန်ဖိုးများဖြင့် ဖြည့်စွက်ခြင်း။ +* **Padding Token**: Padding လုပ်ရာတွင် အသုံးပြုသော အထူး token (ဥပမာ - `[PAD]`)။ +* **`tokenizer.pad_token_id`**: tokenizer ၏ padding token ၏ ID။ +* **Attention Layers**: Transformer model ၏ အစိတ်အပိုင်းများဖြစ်ပြီး input sequence အတွင်းရှိ မတူညီသော tokens များ၏ အရေးပါမှုကို ဆုံးဖြတ်ရာတွင် အထောက်အကူပြုသည်။ +* **Contextualize**: စကားလုံးတစ်ခု၏ အဓိပ္ပာယ်ကို ၎င်းပါဝင်သော စာကြောင်း သို့မဟုတ် စာသား၏ အခြေအနေအရ နားလည်စေခြင်း။ +* **Attention Mask**: မော်ဒယ်ကို အာရုံစိုက်သင့်သည့် tokens များနှင့် လျစ်လျူရှုသင့်သည့် (padding) tokens များကို ခွဲခြားပေးသည့် binary mask။ +* **Truncate**: sequences ၏ အရှည်ကို ကန့်သတ်ချက်တစ်ခုအထိ ဖြတ်တောက်ခြင်း။ +* **`max_sequence_length` Parameter**: input sequence ၏ အများဆုံး အရှည်ကို သတ်မှတ်သော parameter။ +* **Longformer**: အလွန်ရှည်လျားသော sequences များကို ကိုင်တွယ်နိုင်ရန် ဒီဇိုင်းထုတ်ထားသော Transformer model တစ်မျိုး။ +* **LED (Longformer-Encoder-Decoder)**: Longformer ကို အခြေခံထားသော encoder-decoder Transformer model တစ်မျိုး။ \ No newline at end of file diff --git a/chapters/my/chapter2/6.mdx b/chapters/my/chapter2/6.mdx new file mode 100644 index 000000000..a24a3475a --- /dev/null +++ b/chapters/my/chapter2/6.mdx @@ -0,0 +1,160 @@ + + +# အားလုံးကို ပေါင်းစပ်ခြင်း[[putting-it-all-together]] + + + +နောက်ဆုံးအပိုင်းအချို့မှာတော့ ကျွန်တော်တို့ အလုပ်အများစုကို ကိုယ်တိုင်လုပ်ဆောင်ဖို့ အစွမ်းကုန် ကြိုးစားခဲ့ပါတယ်။ tokenizers တွေ ဘယ်လိုအလုပ်လုပ်တယ်ဆိုတာကို လေ့လာခဲ့ပြီး tokenization, input IDs အဖြစ် ပြောင်းလဲခြင်း၊ padding, truncation, နဲ့ attention masks တွေအကြောင်းကို လေ့လာခဲ့ပါတယ်။ + +သို့သော်လည်း၊ အပိုင်း ၂ မှာ ကျွန်တော်တို့ တွေ့ခဲ့ရသလိုပဲ၊ 🤗 Transformers API က ဒါတွေအားလုံးကို ကျွန်တော်တို့အတွက် အဆင့်မြင့် function တစ်ခုနဲ့ ကိုင်တွယ်ပေးနိုင်ပြီး၊ အဲဒါကို ဒီနေရာမှာ ကျွန်တော်တို့ နက်ရှိုင်းစွာ လေ့လာပါမယ်။ သင်ရဲ့ `tokenizer` ကို စာကြောင်းပေါ်မှာ တိုက်ရိုက် ခေါ်ဆိုတဲ့အခါ၊ သင်ရဲ့ model ကို ဖြတ်သန်းဖို့ အဆင်သင့်ဖြစ်နေတဲ့ inputs တွေကို ပြန်ရပါလိမ့်မယ်။ + +```py +from transformers import AutoTokenizer + +checkpoint = "distilbert-base-uncased-finetuned-sst-2-english" +tokenizer = AutoTokenizer.from_pretrained(checkpoint) + +sequence = "I've been waiting for a HuggingFace course my whole life." + +model_inputs = tokenizer(sequence) +``` + +ဒီနေရာမှာ `model_inputs` variable မှာ model တစ်ခု ကောင်းကောင်း အလုပ်လုပ်နိုင်ဖို့ လိုအပ်တဲ့ အရာအားလုံး ပါဝင်ပါတယ်။ DistilBERT အတွက်ဆိုရင်၊ အဲဒါက input IDs တွေအပြင် attention mask ပါ ပါဝင်ပါတယ်။ အပို inputs တွေကို လက်ခံတဲ့ တခြား model တွေအတွက်လည်း `tokenizer` object က အဲဒါတွေကို output အဖြစ် ထုတ်ပေးပါလိမ့်မယ်။ + +အောက်ပါ ဥပမာအချို့မှာ ကျွန်တော်တို့ မြင်ရမယ့်အတိုင်း၊ ဒီ method က အလွန်အစွမ်းထက်ပါတယ်။ ပထမဆုံးအနေနဲ့၊ ဒါက single sequence တစ်ခုကို tokenize လုပ်ဆောင်နိုင်ပါတယ်။ + +```py +sequence = "I've been waiting for a HuggingFace course my whole life." + +model_inputs = tokenizer(sequence) +``` + +ဒါက API မှာ ဘာမှမပြောင်းလဲဘဲ sequence များစွာကို တစ်ပြိုင်နက်တည်း ကိုင်တွယ်နိုင်ပါတယ်။ + +```py +sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"] + +model_inputs = tokenizer(sequences) +``` + +ဒါက ရည်ရွယ်ချက်အမျိုးမျိုးအရ pad လုပ်နိုင်ပါတယ်။ + +```py +# Sequences တွေကို အရှည်ဆုံး sequence length အထိ pad လုပ်ပါလိမ့်မယ်။ +model_inputs = tokenizer(sequences, padding="longest") + +# Sequences တွေကို model ရဲ့ max length (BERT ဒါမှမဟုတ် DistilBERT အတွက် 512) အထိ pad လုပ်ပါလိမ့်မယ်။ +model_inputs = tokenizer(sequences, padding="max_length") + +# Sequences တွေကို သတ်မှတ်ထားတဲ့ max length အထိ pad လုပ်ပါလိမ့်မယ်။ +model_inputs = tokenizer(sequences, padding="max_length", max_length=8) +``` + +ဒါက sequences တွေကို truncate လည်း လုပ်နိုင်ပါတယ်။ + +```py +sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"] + +# Model ရဲ့ max length (BERT ဒါမှမဟုတ် DistilBERT အတွက် 512) ထက် ပိုရှည်တဲ့ sequences တွေကို truncate လုပ်ပါလိမ့်မယ်။ +model_inputs = tokenizer(sequences, truncation=True) + +# သတ်မှတ်ထားတဲ့ max length ထက် ပိုရှည်တဲ့ sequences တွေကို truncate လုပ်ပါလိမ့်မယ်။ +model_inputs = tokenizer(sequences, max_length=8, truncation=True) +``` + +`tokenizer` object က သီးခြား framework tensors တွေအဖြစ် ပြောင်းလဲခြင်းကို ကိုင်တွယ်နိုင်ပါတယ်။ ၎င်းတို့ကို model ကို တိုက်ရိုက် ပို့နိုင်ပါတယ်။ ဥပမာအားဖြင့်၊ အောက်ပါ code sample မှာ ကျွန်တော်တို့က tokenizer ကို မတူညီတဲ့ frameworks တွေကနေ tensors တွေကို ပြန်ပေးဖို့ တောင်းဆိုနေတာပါ။ `"pt"` က PyTorch tensors တွေကို ပြန်ပေးပြီး `"np"` က NumPy arrays တွေကို ပြန်ပေးပါတယ်။ + +```py +sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"] + +# PyTorch tensors များကို ပြန်ပေးသည်။ +model_inputs = tokenizer(sequences, padding=True, return_tensors="pt") + +# NumPy arrays များကို ပြန်ပေးသည်။ +model_inputs = tokenizer(sequences, padding=True, return_tensors="np") +``` + +## Special Tokens များ[[special-tokens]] + +tokenizer က ပြန်ပေးတဲ့ input IDs တွေကို ကြည့်လိုက်ရင်၊ အစောပိုင်းက ကျွန်တော်တို့ ရရှိခဲ့တာတွေနဲ့ အနည်းငယ် ကွဲပြားနေတာကို တွေ့ရပါလိမ့်မယ်။ + +```py +sequence = "I've been waiting for a HuggingFace course my whole life." + +model_inputs = tokenizer(sequence) +print(model_inputs["input_ids"]) + +tokens = tokenizer.tokenize(sequence) +ids = tokenizer.convert_tokens_to_ids(tokens) +print(ids) +``` + +```python out +[101, 1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012, 102] +[1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012] +``` + +token ID တစ်ခုကို အစမှာ ထည့်သွင်းထားပြီး၊ တစ်ခုကို အဆုံးမှာ ထည့်သွင်းထားပါတယ်။ ဒါက ဘာအကြောင်းလဲဆိုတာ သိဖို့ အထက်ပါ IDs sequence နှစ်ခုကို decode လုပ်ကြည့်ရအောင်။ + +```py +print(tokenizer.decode(model_inputs["input_ids"])) +print(tokenizer.decode(ids)) +``` + +```python out +"[CLS] i've been waiting for a huggingface course my whole life. [SEP]" +"i've been waiting for a huggingface course my whole life." +``` + +tokenizer က အစမှာ `[CLS]` ဆိုတဲ့ special word ကို ထည့်ထားပြီး၊ အဆုံးမှာ `[SEP]` ဆိုတဲ့ special word ကို ထည့်ထားပါတယ်။ ဒါက model ကို အဲဒီ tokens တွေနဲ့ pretrained လုပ်ထားတာကြောင့် ဖြစ်ပြီး၊ inference အတွက် တူညီတဲ့ ရလဒ်တွေ ရရှိဖို့အတွက် ကျွန်တော်တို့လည်း ဒါတွေကို ထည့်ဖို့ လိုအပ်ပါတယ်။ တချို့ model တွေက special words တွေ မထည့်တာ ဒါမှမဟုတ် မတူညီတဲ့ special words တွေ ထည့်တာမျိုး ရှိနိုင်ပါတယ်။ model တွေက special words တွေကို အစမှာပဲ ဒါမှမဟုတ် အဆုံးမှာပဲ ထည့်တာမျိုးလည်း ရှိနိုင်ပါတယ်။ ဘယ်လိုပဲဖြစ်ဖြစ်၊ tokenizer က ဘယ် special tokens တွေ လိုအပ်တယ်ဆိုတာ သိပြီး သင့်အတွက် ဒါတွေကို ကိုင်တွယ်ပေးပါလိမ့်မယ်။ + +## အနှစ်ချုပ်: Tokenizer မှ Model ဆီသို့[[wrapping-up-from-tokenizer-to-model]] + +`tokenizer` object က text တွေပေါ်မှာ အသုံးပြုတဲ့အခါ တစ်ဦးချင်းစီ အဆင့်တွေကို အားလုံး မြင်ပြီးသွားပြီဆိုတော့၊ ဒါက sequences များစွာကို (padding!)၊ အလွန်ရှည်လျားတဲ့ sequences တွေကို (truncation!) နဲ့ မတူညီတဲ့ tensors အမျိုးအစားများစွာကို သူ့ရဲ့ အဓိက API နဲ့ ဘယ်လိုကိုင်တွယ်လဲဆိုတာကို နောက်ဆုံးတစ်ကြိမ် ကြည့်ရအောင်။ + +```py +import torch +from transformers import AutoTokenizer, AutoModelForSequenceClassification + +checkpoint = "distilbert-base-uncased-finetuned-sst-2-english" +tokenizer = AutoTokenizer.from_pretrained(checkpoint) +model = AutoModelForSequenceClassification.from_pretrained(checkpoint) +sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"] + +tokens = tokenizer(sequences, padding=True, truncation=True, return_tensors="pt") +output = model(**tokens) +``` + +## ဝေါဟာရ ရှင်းလင်းချက် (Glossary) + +* **Tokenizer**: စာသား (သို့မဟုတ် အခြားဒေတာ) ကို AI မော်ဒယ်များ စီမံဆောင်ရွက်နိုင်ရန် tokens တွေအဖြစ် ပိုင်းခြားပေးသည့် ကိရိယာ သို့မဟုတ် လုပ်ငန်းစဉ်။ +* **Tokenization**: စာသားကို tokens များအဖြစ် ပိုင်းခြားသော လုပ်ငန်းစဉ်။ +* **Input IDs**: Tokenizer မှ ထုတ်ပေးသော tokens တစ်ခုစီ၏ ထူးခြားသော ဂဏန်းဆိုင်ရာ ID များ။ +* **Padding**: မတူညီသော အရှည်ရှိသည့် input sequence များကို အရှည်တူညီအောင် သတ်မှတ်ထားသော တန်ဖိုးများဖြင့် ဖြည့်စွက်ခြင်း။ +* **Truncation**: အရှည်ကန့်သတ်ချက်ထက် ပိုနေသော input sequence များကို ဖြတ်တောက်ခြင်း။ +* **Attention Mask**: မော်ဒယ်ကို အာရုံစိုက်သင့်သည့် tokens များနှင့် လျစ်လျူရှုသင့်သည့် (padding) tokens များကို ခွဲခြားပေးသည့် binary mask။ +* **🤗 Transformers API**: Hugging Face Transformers library ကို အသုံးပြုရန်အတွက် ပရိုဂရမ်မာများက ခေါ်ဆိုနိုင်သော လုပ်ဆောင်ချက်များ၊ class များ နှင့် methods များ။ +* **`AutoTokenizer` Class**: Hugging Face Transformers library မှာ ပါဝင်တဲ့ class တစ်ခုဖြစ်ပြီး မော်ဒယ်အမည်ကို အသုံးပြုပြီး သက်ဆိုင်ရာ tokenizer ကို အလိုအလျောက် load လုပ်ပေးသည်။ +* **`from_pretrained()` Method**: Pre-trained model သို့မဟုတ် tokenizer ကို load လုပ်ရန် အသုံးပြုသော method။ +* **`distilbert-base-uncased-finetuned-sst-2-english`**: `sentiment-analysis` pipeline ၏ default checkpoint အဖြစ် အသုံးပြုသော DistilBERT မော်ဒယ်၏ အမည်။ `base` သည် မော်ဒယ်၏ အရွယ်အစားကို ဖော်ပြပြီး `uncased` သည် စာလုံးအကြီးအသေး ခွဲခြားခြင်းမရှိဘဲ လေ့ကျင့်ထားကြောင်း ဖော်ပြသည်။ `finetuned-sst-2-english` က SST-2 dataset တွင် English ဘာသာစကားအတွက် fine-tune လုပ်ထားသည်ကို ဆိုလိုသည်။ +* **`model_inputs` Variable**: tokenizer ကနေ ထွက်လာတဲ့ model ရဲ့ inputs တွေအားလုံးကို သိမ်းဆည်းထားတဲ့ variable။ +* **PyTorch Tensors**: PyTorch deep learning framework မှာ ဒေတာတွေကို ကိုယ်စားပြုသော multi-dimensional array များ။ +* **NumPy Arrays**: Python တွင် ဂဏန်းတွက်ချက်မှုများအတွက် အသုံးပြုသော multi-dimensional array များအတွက် library။ +* **`padding="longest"`**: Batch အတွင်းရှိ အရှည်ဆုံး sequence အထိ pad လုပ်ခြင်း။ +* **`padding="max_length"`**: Model ၏ အများဆုံး length အထိ pad လုပ်ခြင်း။ +* **`max_length`**: Padding သို့မဟုတ် truncation အတွက် သတ်မှတ်ထားသော အရှည် ကန့်သတ်ချက်။ +* **`truncation=True`**: Sequences များကို သတ်မှတ်ထားသော length အထိ ဖြတ်တောက်ခြင်း။ +* **`return_tensors="pt"`**: PyTorch tensors များကို ပြန်ပေးရန် tokenizer ကို ညွှန်ကြားခြင်း။ +* **`return_tensors="np"`**: NumPy arrays များကို ပြန်ပေးရန် tokenizer ကို ညွှန်ကြားခြင်း။ +* **Special Tokens**: Transformer model များက စာကြောင်းနယ်နိမိတ်များ သို့မဟုတ် အခြားအချက်အလက်များကို ကိုယ်စားပြုရန် အသုံးပြုသော အထူး tokens များ (ဥပမာ - `[CLS]`, `[SEP]`, `[PAD]`)။ +* **`[CLS]`**: BERT မော်ဒယ်တွင် classification task အတွက် အသုံးပြုသော special token (စာကြောင်း၏ အစတွင် ပေါ်လာသည်)။ +* **`[SEP]`**: BERT မော်ဒယ်တွင် စာကြောင်းများကြား ပိုင်းခြားရန် အသုံးပြုသော special token။ +* **`tokenizer.decode()` Method**: Token IDs များကို မူရင်းစာသားသို့ ပြန်ပြောင်းလဲပေးသော method။ +* **Inference**: လေ့ကျင့်ပြီးသား Artificial Intelligence (AI) မော်ဒယ်တစ်ခုကို အသုံးပြုပြီး input data ကနေ ခန့်မှန်းချက်တွေ ဒါမှမဟုတ် output တွေကို ထုတ်လုပ်တဲ့ လုပ်ငန်းစဉ်။ +* **`AutoModelForSequenceClassification` Class**: Hugging Face Transformers library မှာ ပါဝင်တဲ့ class တစ်ခုဖြစ်ပြီး sequence classification အတွက် pre-trained model ကို အလိုအလျောက် load လုပ်ပေးသည်။ +* **`model(**tokens)`**: tokenizer ကနေ ထုတ်ပေးတဲ့ dictionary ကို model ရဲ့ input အဖြစ် ထည့်သွင်းပေးခြင်း။ \ No newline at end of file diff --git a/chapters/my/chapter2/7.mdx b/chapters/my/chapter2/7.mdx new file mode 100644 index 000000000..a2543dcec --- /dev/null +++ b/chapters/my/chapter2/7.mdx @@ -0,0 +1,32 @@ +# အခြေခံ အသုံးပြုမှု ပြီးဆုံးပါပြီ![[basic-usage-completed]] + + + +ဒီသင်တန်းကို ဒီအထိ လိုက်ပါခဲ့တဲ့အတွက် ဂုဏ်ယူပါတယ်။ အနှစ်ချုပ်အနေနဲ့၊ ဒီအခန်းမှာ သင်ဟာ အောက်ပါတို့ကို သင်ယူခဲ့ပါပြီ - + +- Transformer model တစ်ခု၏ အခြေခံတည်ဆောက်ပုံများကို သင်ယူခဲ့သည်။ +- tokenization pipeline ကို ဘာတွေနဲ့ ဖွဲ့စည်းထားတယ်ဆိုတာ သိရှိခဲ့သည်။ +- လက်တွေ့မှာ Transformer model တစ်ခုကို ဘယ်လိုအသုံးပြုရမယ်ဆိုတာကို တွေ့ခဲ့ရသည်။ +- tokenizer ကို အသုံးပြုပြီး text ကို model က နားလည်နိုင်တဲ့ tensors တွေအဖြစ် ဘယ်လိုပြောင်းလဲရမယ်ဆိုတာကို သင်ယူခဲ့သည်။ +- text ကနေ predictions တွေရဖို့ tokenizer နဲ့ model ကို အတူတကွ တည်ဆောက်ခဲ့သည်။ +- input IDs တွေရဲ့ ကန့်သတ်ချက်များကို သင်ယူခဲ့ပြီး attention masks တွေအကြောင်း သိရှိခဲ့သည်။ +- အသုံးဝင်ပြီး စိတ်ကြိုက်ပြင်ဆင်နိုင်သော tokenizer methods များနှင့် ကစားကြည့်ခဲ့သည်။ + +အခုကစပြီး သင်ဟာ 🤗 Transformers docs တွေထဲမှာ လွတ်လပ်စွာ သွားလာနိုင်ပါလိမ့်မယ်၊ Vocabulary တွေက ရင်းနှီးလာမှာဖြစ်ပြီး၊ သင် အချိန်အများစု အသုံးပြုရမယ့် methods တွေကိုလည်း သင် မြင်တွေ့ခဲ့ရပါပြီ။ + +## ဝေါဟာရ ရှင်းလင်းချက် (Glossary) + +* **Transformer Model**: Natural Language Processing (NLP) မှာ အောင်မြင်မှုများစွာရရှိခဲ့တဲ့ deep learning architecture တစ်မျိုးပါ။ ၎င်းတို့ဟာ စာသားတွေထဲက စကားလုံးတွေရဲ့ ဆက်နွယ်မှုတွေကို "attention mechanism" သုံးပြီး နားလည်အောင် သင်ကြားပေးပါတယ်။ +* **Tokenization Pipeline**: စာသားကို AI မော်ဒယ်များ လုပ်ဆောင်နိုင်သော ဂဏန်းဆိုင်ရာ ကိုယ်စားပြုမှုအဖြစ် ပြောင်းလဲရန် လိုအပ်သော အဆင့်များ (ဥပမာ- tokenization, input IDs conversion, padding, truncation)။ +* **Tokenizer**: စာသား (သို့မဟုတ် အခြားဒေတာ) ကို AI မော်ဒယ်များ စီမံဆောင်ရွက်နိုင်ရန် tokens တွေအဖြစ် ပိုင်းခြားပေးသည့် ကိရိယာ သို့မဟုတ် လုပ်ငန်းစဉ်။ +* **Text**: လူသားဘာသာစကားဖြင့် ရေးသားထားသော စာသားအချက်အလက်များ။ +* **Tensors**: Machine Learning frameworks (PyTorch, TensorFlow) များတွင် ဒေတာများကို ကိုယ်စားပြုသော multi-dimensional array များ။ +* **Predictions**: Machine Learning မော်ဒယ်တစ်ခုက input data ကို အခြေခံပြီး ခန့်မှန်းထုတ်ပေးသော ရလဒ်များ။ +* **Input IDs**: Tokenizer မှ ထုတ်ပေးသော tokens တစ်ခုစီ၏ ထူးခြားသော ဂဏန်းဆိုင်ရာ ID များ။ +* **Attention Masks**: မော်ဒယ်ကို အာရုံစိုက်သင့်သည့် tokens များနှင့် လျစ်လျူရှုသင့်သည့် (padding) tokens များကို ခွဲခြားပေးသည့် binary mask။ +* **Configurable Tokenizer Methods**: အသုံးပြုသူ၏ လိုအပ်ချက်များအတိုင်း ပြင်ဆင်သတ်မှတ်နိုင်သော tokenizer functions များ။ +* **🤗 Transformers Docs**: Hugging Face Transformers library ၏ တရားဝင် မှတ်တမ်းများ (documentation)။ +* **Vocabulary**: tokenizer သို့မဟုတ် model တစ်ခုက သိရှိနားလည်ပြီး ကိုင်တွယ်နိုင်သော ထူးခြားသည့် tokens များ စုစုပေါင်း။ \ No newline at end of file diff --git a/chapters/my/chapter2/8.mdx b/chapters/my/chapter2/8.mdx new file mode 100644 index 000000000..74e01168c --- /dev/null +++ b/chapters/my/chapter2/8.mdx @@ -0,0 +1,930 @@ +# Optimization လုပ်ထားသော Inference Deployment[[optimized-inference-deployment]] + +ဒီအပိုင်းမှာတော့ LLM deployments တွေကို optimization လုပ်ဖို့အတွက် အဆင့်မြင့် frameworks တွေဖြစ်တဲ့ Text Generation Inference (TGI), vLLM, နဲ့ llama.cpp တို့ကို လေ့လာသွားပါမယ်။ ဒီ application တွေက အဓိကအားဖြင့် ထုတ်လုပ်မှု ပတ်ဝန်းကျင် (production environments) တွေမှာ LLM တွေကို သုံးစွဲသူများဆီသို့ ဝန်ဆောင်မှုပေးဖို့ အသုံးပြုကြပါတယ်။ ဒီအပိုင်းက ဒီ frameworks တွေကို production မှာ ဘယ်လို deploy လုပ်ရမယ်ဆိုတာကို အဓိကထားပြီး၊ single machine တစ်ခုပေါ်မှာ inference အတွက် ဘယ်လိုအသုံးပြုရမယ်ဆိုတာကို အာရုံစိုက်ထားခြင်း မရှိပါဘူး။ + +ဒီ tools တွေက inference efficiency ကို ဘယ်လိုအမြင့်ဆုံးမြှင့်တင်ပြီး Large Language Models တွေကို production deployments တွေကို ဘယ်လို ရိုးရှင်းအောင် လုပ်ဆောင်တယ်ဆိုတာကို ကျွန်တော်တို့ ဖော်ပြပေးပါမယ်။ + +## Framework ရွေးချယ်မှု လမ်းညွှန်[[framework-selection-guide]] + +TGI, vLLM, နဲ့ llama.cpp တို့ဟာ ရည်ရွယ်ချက်ချင်း တူညီပေမယ့်၊ မတူညီတဲ့ အသုံးပြုမှုပုံစံတွေအတွက် ပိုမိုသင့်လျော်စေတဲ့ ထူးခြားတဲ့ အင်္ဂါရပ်တွေ ရှိပါတယ်။ ၎င်းတို့ကြားက အဓိက ကွာခြားချက်တွေကို စွမ်းဆောင်ရည် (performance) နဲ့ ပေါင်းစပ်မှု (integration) ကို အာရုံစိုက်ပြီး ကြည့်ရအောင်။ + +### Memory Management နှင့် Performance[[memory-management-and-performance]] + +**TGI** ကို production မှာ တည်ငြိမ်ပြီး ခန့်မှန်းနိုင်စေဖို့ ဒီဇိုင်းထုတ်ထားပြီး၊ memory အသုံးပြုမှုကို တသမတ်တည်း ထိန်းထားဖို့အတွက် fixed sequence lengths တွေကို အသုံးပြုပါတယ်။ TGI က Flash Attention 2 နဲ့ continuous batching နည်းစနစ်တွေကို အသုံးပြုပြီး memory ကို စီမံခန့်ခွဲပါတယ်။ ဒါက ၎င်းသည် attention calculations တွေကို အလွန်ထိထိရောက်ရောက် လုပ်ဆောင်နိုင်ပြီး GPU ကို အလုပ်တွေ အဆက်မပြတ် ပေးခြင်းဖြင့် အလုပ်များနေအောင် ထိန်းထားနိုင်တယ်လို့ ဆိုလိုပါတယ်။ လိုအပ်တဲ့အခါ စနစ်က model ရဲ့ အစိတ်အပိုင်းတွေကို CPU နဲ့ GPU ကြား ရွှေ့ပြောင်းနိုင်တာကြောင့် ပိုကြီးတဲ့ model တွေကို ကိုင်တွယ်ရာမှာ အထောက်အကူ ဖြစ်စေပါတယ်။ + +Flash Attention + + + +Flash Attention ဆိုတာ transformer models တွေမှာ attention mechanism ကို memory bandwidth bottlenecks တွေကို ဖြေရှင်းပေးခြင်းဖြင့် optimization လုပ်တဲ့ နည်းပညာတစ်ခုပါ။ [Chapter 1.8](/course/chapter1/8) မှာ ယခင်က ဆွေးနွေးခဲ့သလိုပဲ၊ attention mechanism မှာ quadratic complexity နဲ့ memory usage ရှိတာကြောင့် ရှည်လျားတဲ့ sequences တွေအတွက် ထိရောက်မှု မရှိပါဘူး။ + +အဓိက တီထွင်မှုကတော့ High Bandwidth Memory (HBM) နဲ့ ပိုမြန်တဲ့ SRAM cache ကြား memory transfers တွေကို ဘယ်လို စီမံခန့်ခွဲလဲဆိုတဲ့ အချက်မှာပါပဲ။ ရိုးရာ attention နည်းလမ်းက HBM နဲ့ SRAM ကြား ဒေတာတွေကို အကြိမ်ကြိမ် transfer လုပ်တာကြောင့် GPU ကို အလုပ်မရှိဘဲ ထားခြင်းဖြင့် bottlenecks တွေ ဖြစ်စေပါတယ်။ Flash Attention က ဒေတာတွေကို SRAM ထဲကို တစ်ကြိမ်တည်း load လုပ်ပြီး အဲဒီမှာပဲ calculations တွေအားလုံးကို လုပ်ဆောင်တာကြောင့် ကုန်ကျစရိတ်များတဲ့ memory transfers တွေကို လျှော့ချပေးပါတယ်။ + +အကျိုးကျေးဇူးတွေက training လုပ်နေစဉ်မှာ အရေးအပါဆုံး ဖြစ်ပေမယ့်၊ Flash Attention ရဲ့ လျှော့ချထားတဲ့ VRAM အသုံးပြုမှုနဲ့ တိုးတက်လာတဲ့ efficiency က inference အတွက်ပါ အဖိုးတန်စေပြီး၊ ပိုမိုမြန်ဆန်ပြီး ပိုမို scalable ဖြစ်တဲ့ LLM serving ကို ဖြစ်ပေါ်စေပါတယ်။ + + + +**vLLM** က PagedAttention ကို အသုံးပြုပြီး မတူညီတဲ့ နည်းလမ်းတစ်ခုကို အသုံးပြုပါတယ်။ ကွန်ပျူတာက memory ကို pages တွေနဲ့ စီမံခန့်ခွဲသလိုပဲ၊ vLLM က model ရဲ့ memory ကို ပိုသေးငယ်တဲ့ blocks တွေအဖြစ် ပိုင်းခြားပါတယ်။ ဒီ clever system ကြောင့် ၎င်းသည် မတူညီတဲ့ အရွယ်အစားရှိတဲ့ requests တွေကို ပိုမိုပြောင်းလွယ်ပြင်လွယ် ကိုင်တွယ်နိုင်ပြီး memory space ကို မဖြုန်းတီးပါဘူး။ ဒါက မတူညီတဲ့ requests တွေကြား memory ကို မျှဝေရာမှာ အထူးကောင်းမွန်ပြီး memory fragmentation ကို လျှော့ချပေးတာကြောင့် စနစ်တစ်ခုလုံးကို ပိုမိုထိရောက်စေပါတယ်။ + + + +PagedAttention ဆိုတာ LLM inference မှာ နောက်ထပ် အရေးကြီးတဲ့ bottleneck တစ်ခုဖြစ်တဲ့ KV cache memory management ကို ဖြေရှင်းပေးတဲ့ နည်းပညာတစ်ခုပါ။ [Chapter 1.8](/course/chapter1/8) မှာ ဆွေးနွေးခဲ့သလိုပဲ၊ text generation လုပ်နေစဉ်မှာ model က attention keys နဲ့ values (KV cache) တွေကို ထုတ်လုပ်လိုက်တဲ့ token တစ်ခုစီအတွက် သိမ်းဆည်းထားပြီး ထပ်ခါတလဲလဲ တွက်ချက်မှုတွေကို လျှော့ချပါတယ်။ KV cache က အထူးသဖြင့် ရှည်လျားတဲ့ sequences တွေ ဒါမှမဟုတ် concurrent requests များစွာနဲ့ဆိုရင် အလွန်ကြီးမားလာနိုင်ပါတယ်။ + +vLLM ရဲ့ အဓိက တီထွင်မှုကတော့ ဒီ cache ကို ဘယ်လို စီမံခန့်ခွဲလဲဆိုတဲ့ အချက်မှာပါပဲ- + +1. **Memory Paging**: KV cache ကို ကြီးမားတဲ့ block တစ်ခုအဖြစ် မမှတ်ယူဘဲ၊ ၎င်းကို fixed-size "pages" တွေအဖြစ် ပိုင်းခြားထားပါတယ် (operating systems တွေမှာ virtual memory နဲ့ ဆင်တူပါတယ်)။ +2. **Non-contiguous Storage**: Pages တွေကို GPU memory မှာ ဆက်တိုက် သိမ်းဆည်းထားဖို့ မလိုအပ်တာကြောင့် ပိုမိုပြောင်းလွယ်ပြင်လွယ်ရှိတဲ့ memory allocation ကို ဖြစ်ပေါ်စေပါတယ်။ +3. **Page Table Management**: Page table တစ်ခုက ဘယ် pages တွေက ဘယ် sequence နဲ့ သက်ဆိုင်တယ်ဆိုတာကို ခြေရာခံပြီး၊ ထိရောက်တဲ့ lookup နဲ့ access ကို ဖြစ်ပေါ်စေပါတယ်။ +4. **Memory Sharing**: parallel sampling လို လုပ်ငန်းတွေအတွက်၊ prompt အတွက် KV cache ကို သိမ်းဆည်းထားတဲ့ pages တွေကို sequences များစွာမှာ မျှဝေအသုံးပြုနိုင်ပါတယ်။ + +PagedAttention နည်းလမ်းက ရိုးရာနည်းလမ်းတွေနဲ့ နှိုင်းယှဉ်ရင် throughput ကို ၂၄ ဆအထိ ပိုမိုမြင့်မားစေနိုင်တာကြောင့် production LLM deployments တွေအတွက် game-changer တစ်ခု ဖြစ်ပါတယ်။ PagedAttention ဘယ်လိုအလုပ်လုပ်တယ်ဆိုတာကို တကယ်နက်နက်နဲနဲ လေ့လာချင်တယ်ဆိုရင် [vLLM documentation ရဲ့ လမ်းညွှန်](https://docs.vllm.ai/en/latest/design/kernel/paged_attention.html) ကို ဖတ်ရှုနိုင်ပါတယ်။ + + + +**llama.cpp** ဟာ မူလက LLaMA models တွေကို consumer hardware တွေမှာ run ဖို့ ဒီဇိုင်းထုတ်ထားတဲ့ highly optimized C/C++ implementation တစ်ခုပါ။ ဒါက optional GPU acceleration ပါဝင်တဲ့ CPU efficiency ကို အာရုံစိုက်ပြီး၊ resource-constrained environments တွေအတွက် အကောင်းဆုံးပါပဲ။ llama.cpp က model size နဲ့ memory requirements တွေကို လျှော့ချဖို့အတွက် quantization နည်းစနစ်တွေကို အသုံးပြုပြီး ကောင်းမွန်တဲ့ performance ကို ထိန်းသိမ်းထားပါတယ်။ ဒါက အမျိုးမျိုးသော CPU architectures တွေအတွက် optimized kernels တွေကို implement လုပ်ထားပြီး၊ ထိရောက်တဲ့ token generation အတွက် basic KV cache management ကို ထောက်ပံ့ပေးပါတယ်။ + + + +llama.cpp မှာ Quantization ဆိုတာ model weights တွေရဲ့ precision ကို 32-bit ဒါမှမဟုတ် 16-bit floating point ကနေ 8-bit integers (INT8)၊ 4-bit ဒါမှမဟုတ် ပိုနိမ့်တဲ့ precision formats တွေအဖြစ် လျှော့ချတာပါ။ ဒါက memory အသုံးပြုမှုကို သိသိသာသာ လျှော့ချပေးပြီး အနည်းဆုံး အရည်အသွေး ဆုံးရှုံးမှုနဲ့အတူ inference speed ကို မြှင့်တင်ပေးပါတယ်။ + +llama.cpp မှာ အဓိက quantization features တွေကတော့- +1. **Multiple Quantization Levels**: 8-bit, 4-bit, 3-bit, နဲ့ 2-bit quantization ကိုပါ ထောက်ပံ့ပေးပါတယ်။ +2. **GGML/GGUF Format**: Quantized inference အတွက် optimization လုပ်ထားတဲ့ custom tensor formats တွေကို အသုံးပြုပါတယ်။ +3. **Mixed Precision**: Model ရဲ့ မတူညီတဲ့ အစိတ်အပိုင်းတွေမှာ မတူညီတဲ့ quantization levels တွေကို အသုံးပြုနိုင်ပါတယ်။ +4. **Hardware-Specific Optimizations**: အမျိုးမျိုးသော CPU architectures တွေ (AVX2, AVX-512, NEON) အတွက် optimized code paths တွေ ပါဝင်ပါတယ်။ + +ဒီနည်းလမ်းက limited memory ရှိတဲ့ consumer hardware တွေမှာ billion-parameter models တွေကို run နိုင်စေပြီး၊ local deployments နဲ့ edge devices တွေအတွက် အကောင်းဆုံး ဖြစ်စေပါတယ်။ + + + +### Deployment နှင့် Integration[[deployment-and-integration]] + +frameworks တွေကြားက deployment နဲ့ integration ကွာခြားချက်တွေကို ဆက်သွားရအောင်။ + +**TGI** က သူ့ရဲ့ production-ready features တွေနဲ့ enterprise-level deployment တွေမှာ ထူးချွန်ပါတယ်။ ဒါက built-in Kubernetes support နဲ့ Prometheus နဲ့ Grafana ကနေတဆင့် monitoring လုပ်ခြင်း၊ automatic scaling, နဲ့ ပြည့်စုံတဲ့ safety features တွေလို production မှာ run ဖို့ လိုအပ်တဲ့ အရာအားလုံး ပါဝင်ပါတယ်။ စနစ်က enterprise-grade logging နဲ့ content filtering နဲ့ rate limiting လိုမျိုး အမျိုးမျိုးသော ကာကွယ်မှု နည်းလမ်းတွေပါ ပါဝင်တာကြောင့် သင့် deployment ကို လုံခြုံပြီး တည်ငြိမ်အောင် ထိန်းထားနိုင်ပါတယ်။ + +**vLLM** က deployment အတွက် ပိုမိုပြောင်းလွယ်ပြင်လွယ်ရှိပြီး developer-friendly ဖြစ်တဲ့ ချဉ်းကပ်မှုကို အသုံးပြုပါတယ်။ ဒါက Python ကို အဓိကထားပြီး တည်ဆောက်ထားတာကြောင့် သင့်ရဲ့ လက်ရှိ application တွေမှာ OpenAI ရဲ့ API ကို အလွယ်တကူ အစားထိုးနိုင်ပါတယ်။ framework က raw performance ကို ပေးစွမ်းဖို့ အာရုံစိုက်ပြီး၊ သင့်ရဲ့ သီးခြားလိုအပ်ချက်တွေနဲ့ ကိုက်ညီအောင် စိတ်ကြိုက်ပြင်ဆင်နိုင်ပါတယ်။ ဒါက clusters တွေကို စီမံခန့်ခွဲဖို့အတွက် Ray နဲ့ အထူးကောင်းမွန်စွာ အလုပ်လုပ်တာကြောင့် high performance နဲ့ adaptability လိုအပ်တဲ့အခါ အကောင်းဆုံး ရွေးချယ်မှုတစ်ခု ဖြစ်ပါတယ်။ + +**llama.cpp** က ရိုးရှင်းမှုနဲ့ portability ကို ဦးစားပေးပါတယ်။ သူ့ရဲ့ server implementation က ပေါ့ပါးပြီး hardware အမျိုးမျိုး (powerful servers တွေကနေ consumer laptops တွေနဲ့ အချို့ high-end mobile devices တွေအထိ) မှာ run နိုင်ပါတယ်။ အနည်းဆုံး dependencies တွေနဲ့ ရိုးရှင်းတဲ့ C/C++ core နဲ့ဆိုရင်၊ Python frameworks တွေ install လုပ်ဖို့ ခက်ခဲတဲ့ environments တွေမှာ deploy လုပ်ဖို့ လွယ်ကူပါတယ်။ server က OpenAI-compatible API ကို ပံ့ပိုးပေးထားပြီး အခြား solution တွေထက် resource အသုံးပြုမှုက အများကြီး သေးငယ်ပါတယ်။ + +## စတင်ခြင်း[[getting-started]] + +LLMs တွေကို deploy လုပ်ဖို့ ဒီ frameworks တွေကို ဘယ်လိုအသုံးပြုရမလဲဆိုတာကို လေ့လာကြည့်ရအောင်။ installation နဲ့ basic setup ကနေ စတင်ပါမယ်။ + +### Installation နှင့် Basic Setup[[installation-and-basic-setup]] + + + + + +TGI က install လုပ်ဖို့နဲ့ အသုံးပြုဖို့ လွယ်ကူပြီး၊ Hugging Face ecosystem ထဲမှာ နက်ရှိုင်းစွာ ပေါင်းစပ်ထားပါတယ်။ + +ပထမဆုံး၊ Docker ကို အသုံးပြုပြီး TGI server ကို launch လုပ်ပါ။ + +```sh +docker run --gpus all \ + --shm-size 1g \ + -p 8080:80 \ + -v ~/.cache/huggingface:/data \ + ghcr.io/huggingface/text-generation-inference:latest \ + --model-id HuggingFaceTB/SmolLM2-360M-Instruct +``` + +အဲဒီနောက် Hugging Face ရဲ့ InferenceClient ကို အသုံးပြုပြီး အပြန်အလှန်ဆက်သွယ်ပါ။ + +```python +from huggingface_hub import InferenceClient + +# TGI endpoint ကို ညွှန်ပြပြီး client ကို Initialize လုပ်ပါ။ +client = InferenceClient( + model="http://localhost:8080", # URL to the TGI server +) + +# Text generation +response = client.text_generation( + "Tell me a story", + max_new_tokens=100, + temperature=0.7, + top_p=0.95, + details=True, + stop_sequences=[], +) +print(response.generated_text) + +# For chat format +response = client.chat_completion( + messages=[ + {"role": "system", "content": "You are a helpful assistant."}, + {"role": "user", "content": "Tell me a story"}, + ], + max_tokens=100, + temperature=0.7, + top_p=0.95, +) +print(response.choices[0].message.content) +``` + +တနည်းအားဖြင့် OpenAI client ကို အသုံးပြုနိုင်ပါတယ်။ + +```python +from openai import OpenAI + +# Initialize client pointing to TGI endpoint +client = OpenAI( + base_url="http://localhost:8080/v1", # /v1 ကို ထည့်သွင်းဖို့ သေချာပါစေ။ + api_key="not-needed", # TGI က default အားဖြင့် API key မလိုအပ်ပါဘူး။ +) + +# Chat completion +response = client.chat.completions.create( + model="HuggingFaceTB/SmolLM2-360M-Instruct", + messages=[ + {"role": "system", "content": "You are a helpful assistant."}, + {"role": "user", "content": "Tell me a story"}, + ], + max_tokens=100, + temperature=0.7, + top_p=0.95, +) +print(response.choices[0].message.content) +``` + + + + + +llama.cpp က install လုပ်ဖို့နဲ့ အသုံးပြုဖို့ လွယ်ကူပြီး၊ အနည်းဆုံး dependencies တွေပဲ လိုအပ်ကာ CPU နဲ့ GPU inference နှစ်ခုလုံးကို ထောက်ပံ့ပါတယ်။ + +ပထမဆုံး၊ llama.cpp ကို install လုပ်ပြီး build လုပ်ပါ။ + +```sh +# Repository ကို clone လုပ်ပါ။ +git clone https://github.com/ggerganov/llama.cpp +cd llama.cpp + +# Project ကို build လုပ်ပါ။ +make + +# SmolLM2-1.7B-Instruct-GGUF model ကို download လုပ်ပါ။ +curl -L -O https://huggingface.co/HuggingFaceTB/SmolLM2-1.7B-Instruct-GGUF/resolve/main/smollm2-1.7b-instruct.Q4_K_M.gguf +``` + +အဲဒီနောက် server ကို launch လုပ်ပါ (OpenAI API compatibility နဲ့)။ + +```sh +# Start the server +./server \ + -m smollm2-1.7b-instruct.Q4_K_M.gguf \ + --host 0.0.0.0 \ + --port 8080 \ + -c 4096 \ + --n-gpu-layers 0 # GPU ကို အသုံးပြုရန်အတွက် ပိုမိုမြင့်မားသော နံပါတ်ကို သတ်မှတ်ပါ။ +``` + +Hugging Face ရဲ့ InferenceClient ကို အသုံးပြုပြီး server နဲ့ အပြန်အလှန်ဆက်သွယ်ပါ။ + +```python +from huggingface_hub import InferenceClient + +# llama.cpp server ကို ညွှန်ပြပြီး client ကို Initialize လုပ်ပါ။ +client = InferenceClient( + model="http://localhost:8080/v1", # llama.cpp server ရဲ့ URL + token="sk-no-key-required", # llama.cpp server က ဒီ placeholder ကို လိုအပ်ပါတယ်။ +) + +# Text generation +response = client.text_generation( + "Tell me a story", + max_new_tokens=100, + temperature=0.7, + top_p=0.95, + details=True, +) +print(response.generated_text) + +# Chat format အတွက် +response = client.chat_completion( + messages=[ + {"role": "system", "content": "You are a helpful assistant."}, + {"role": "user", "content": "Tell me a story"}, + ], + max_tokens=100, + temperature=0.7, + top_p=0.95, +) +print(response.choices[0].message.content) +``` + +တနည်းအားဖြင့် OpenAI client ကို အသုံးပြုနိုင်ပါတယ်။ + +```python +from openai import OpenAI + +# llama.cpp server ကို ညွှန်ပြပြီး client ကို Initialize လုပ်ပါ။ +client = OpenAI( + base_url="http://localhost:8080/v1", + api_key="sk-no-key-required", # llama.cpp server က ဒီ placeholder ကို လိုအပ်ပါတယ်။ +) + +# Chat completion +response = client.chat.completions.create( + model="smollm2-1.7b-instruct", # Server က model တစ်ခုတည်းသာ load လုပ်တာကြောင့် model identifier က ဘာပဲဖြစ်ဖြစ် ရပါတယ်။ + messages=[ + {"role": "system", "content": "You are a helpful assistant."}, + {"role": "user", "content": "Tell me a story"}, + ], + max_tokens=100, + temperature=0.7, + top_p=0.95, +) +print(response.choices[0].message.content) +``` + + + + + +vLLM က install လုပ်ဖို့နဲ့ အသုံးပြုဖို့ လွယ်ကူပြီး၊ OpenAI API compatibility နဲ့ native Python interface နှစ်ခုလုံး ပါဝင်ပါတယ်။ + +ပထမဆုံး၊ vLLM OpenAI-compatible server ကို launch လုပ်ပါ။ + +```sh +python -m vllm.entrypoints.openai.api_server \ + --model HuggingFaceTB/SmolLM2-360M-Instruct \ + --host 0.0.0.0 \ + --port 8000 +``` + +အဲဒီနောက် Hugging Face ရဲ့ InferenceClient ကို အသုံးပြုပြီး အပြန်အလှန်ဆက်သွယ်ပါ။ + +```python +from huggingface_hub import InferenceClient + +# vLLM endpoint ကို ညွှန်ပြပြီး client ကို Initialize လုပ်ပါ။ +client = InferenceClient( + model="http://localhost:8000/v1", # vLLM server ရဲ့ URL +) + +# Text generation +response = client.text_generation( + "Tell me a story", + max_new_tokens=100, + temperature=0.7, + top_p=0.95, + details=True, +) +print(response.generated_text) + +# Chat format အတွက် +response = client.chat_completion( + messages=[ + {"role": "system", "content": "You are a helpful assistant."}, + {"role": "user", "content": "Tell me a story"}, + ], + max_tokens=100, + temperature=0.7, + top_p=0.95, +) +print(response.choices[0].message.content) +``` + +တနည်းအားဖြင့် OpenAI client ကို အသုံးပြုနိုင်ပါတယ်။ + +```python +from openai import OpenAI + +# vLLM endpoint ကို ညွှန်ပြပြီး client ကို Initialize လုပ်ပါ။ +client = OpenAI( + base_url="http://localhost:8000/v1", + api_key="not-needed", # vLLM က default အားဖြင့် API key မလိုအပ်ပါဘူး။ +) + +# Chat completion +response = client.chat.completions.create( + model="HuggingFaceTB/SmolLM2-360M-Instruct", + messages=[ + {"role": "system", "content": "You are a helpful assistant."}, + {"role": "user", "content": "Tell me a story"}, + ], + max_tokens=100, + temperature=0.7, + top_p=0.95, +) +print(response.choices[0].message.content) +``` + + + + + +### Basic Text Generation + +frameworks တွေနဲ့ text generation ရဲ့ ဥပမာတွေကို ကြည့်ရအောင်။ + + + + + +ပထမဆုံး၊ TGI ကို အဆင့်မြင့် parameters တွေနဲ့ deploy လုပ်ပါ။ +```sh +docker run --gpus all \ + --shm-size 1g \ + -p 8080:80 \ + -v ~/.cache/huggingface:/data \ + ghcr.io/huggingface/text-generation-inference:latest \ + --model-id HuggingFaceTB/SmolLM2-360M-Instruct \ + --max-total-tokens 4096 \ + --max-input-length 3072 \ + --max-batch-total-tokens 8192 \ + --waiting-served-ratio 1.2 +``` + +ပြောင်းလွယ်ပြင်လွယ်ရှိတဲ့ text generation အတွက် InferenceClient ကို အသုံးပြုပါ။ + +```python +from huggingface_hub import InferenceClient + +client = InferenceClient(model="http://localhost:8080") + +# အဆင့်မြင့် parameters ဥပမာ +response = client.chat_completion( + messages=[ + {"role": "system", "content": "You are a creative storyteller."}, + {"role": "user", "content": "Write a creative story"}, + ], + temperature=0.8, + max_tokens=200, + top_p=0.95, +) +print(response.choices[0].message.content) + +# Raw text generation +response = client.text_generation( + "Write a creative story about space exploration", + max_new_tokens=200, + temperature=0.8, + top_p=0.95, + repetition_penalty=1.1, + do_sample=True, + details=True, +) +print(response.generated_text) +``` + +ဒါမှမဟုတ် OpenAI client ကို အသုံးပြုပါ။ +```python +from openai import OpenAI + +client = OpenAI(base_url="http://localhost:8080/v1", api_key="not-needed") + +# အဆင့်မြင့် parameters ဥပမာ +response = client.chat.completions.create( + model="HuggingFaceTB/SmolLM2-360M-Instruct", + messages=[ + {"role": "system", "content": "You are a creative storyteller."}, + {"role": "user", "content": "Write a creative story"}, + ], + temperature=0.8, # Higher for more creativity +) +print(response.choices[0].message.content) +``` + + + + + +llama.cpp အတွက် အဆင့်မြင့် parameters တွေကို server ကို launch လုပ်တဲ့အခါ သတ်မှတ်နိုင်ပါတယ်။ + +```sh +./server \ + -m smollm2-1.7b-instruct.Q4_K_M.gguf \ + --host 0.0.0.0 \ + --port 8080 \ + -c 4096 \ # Context size + --threads 8 \ # CPU threads to use + --batch-size 512 \ # Batch size for prompt evaluation + --n-gpu-layers 0 # GPU layers (0 = CPU only) +``` + +InferenceClient ကို အသုံးပြုပါ။ + +```python +from huggingface_hub import InferenceClient + +client = InferenceClient(model="http://localhost:8080/v1", token="sk-no-key-required") + +# Advanced parameters example +response = client.chat_completion( + messages=[ + {"role": "system", "content": "You are a creative storyteller."}, + {"role": "user", "content": "Write a creative story"}, + ], + temperature=0.8, + max_tokens=200, + top_p=0.95, +) +print(response.choices[0].message.content) + +# တိုက်ရိုက် text generation အတွက် +response = client.text_generation( + "Write a creative story about space exploration", + max_new_tokens=200, + temperature=0.8, + top_p=0.95, + repetition_penalty=1.1, + details=True, +) +print(response.generated_text) +``` + +ဒါမှမဟုတ် sampling parameters တွေကို ထိန်းချုပ်ပြီး generation လုပ်ဖို့ OpenAI client ကို အသုံးပြုပါ။ + +```python +from openai import OpenAI + +client = OpenAI(base_url="http://localhost:8080/v1", api_key="sk-no-key-required") + +# အဆင့်မြင့် parameters ဥပမာ +response = client.chat.completions.create( + model="smollm2-1.7b-instruct", + messages=[ + {"role": "system", "content": "You are a creative storyteller."}, + {"role": "user", "content": "Write a creative story"}, + ], + temperature=0.8, # ပိုမိုဖန်တီးမှုရှိရန် ပိုမိုမြင့်မားသော တန်ဖိုး + top_p=0.95, # Nucleus sampling probability + frequency_penalty=0.5, # မကြာခဏ ပေါ်လာသော tokens များကို ထပ်ခါတလဲလဲ မဖြစ်အောင် လျှော့ချပါ။ + presence_penalty=0.5, # ရှိပြီးသား tokens များကို ပြန်လည်ပေါ်ထွက်မှုကို လျှော့ချပါ။ + max_tokens=200, # အများဆုံး generation length +) +print(response.choices[0].message.content) +``` + +llama.cpp ရဲ့ native library ကိုလည်း ပိုမိုထိန်းချုပ်နိုင်ရန် အသုံးပြုနိုင်ပါတယ်။ + +```python +# တိုက်ရိုက် model access အတွက် llama-cpp-python package ကို အသုံးပြုခြင်း +from llama_cpp import Llama + +# Model ကို load လုပ်ပါ။ +llm = Llama( + model_path="smollm2-1.7b-instruct.Q4_K_M.gguf", + n_ctx=4096, # Context window size + n_threads=8, # CPU threads + n_gpu_layers=0, # GPU layers (0 = CPU only) +) + +# Model ရဲ့ မျှော်လင့်ထားတဲ့ format အတိုင်း prompt ကို format လုပ်ပါ။ +prompt = """<|im_start|>system +You are a creative storyteller. +<|im_end|> +<|im_start|>user +Write a creative story +<|im_end|> +<|im_start|>assistant +""" + +# တိကျတဲ့ parameter ထိန်းချုပ်မှုနဲ့ response ကို generate လုပ်ပါ။ +output = llm( + prompt, + max_tokens=200, + temperature=0.8, + top_p=0.95, + frequency_penalty=0.5, + presence_penalty=0.5, + stop=["<|im_end|>"], +) + +print(output["choices"][0]["text"]) +``` + + + + + +vLLM နဲ့ အဆင့်မြင့် အသုံးပြုမှုအတွက် InferenceClient ကို အသုံးပြုနိုင်ပါတယ်။ + +```python +from huggingface_hub import InferenceClient + +client = InferenceClient(model="http://localhost:8000/v1") + +# အဆင့်မြင့် parameters ဥပမာ +response = client.chat_completion( + messages=[ + {"role": "system", "content": "You are a creative storyteller."}, + {"role": "user", "content": "Write a creative story"}, + ], + temperature=0.8, + max_tokens=200, + top_p=0.95, +) +print(response.choices[0].message.content) + +# တိုက်ရိုက် text generation အတွက် +response = client.text_generation( + "Write a creative story about space exploration", + max_new_tokens=200, + temperature=0.8, + top_p=0.95, + details=True, +) +print(response.generated_text) +``` + +OpenAI client ကိုလည်း အသုံးပြုနိုင်ပါတယ်။ + +```python +from openai import OpenAI + +client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed") + +# အဆင့်မြင့် parameters ဥပမာ +response = client.chat.completions.create( + model="HuggingFaceTB/SmolLM2-360M-Instruct", + messages=[ + {"role": "system", "content": "You are a creative storyteller."}, + {"role": "user", "content": "Write a creative story"}, + ], + temperature=0.8, + top_p=0.95, + max_tokens=200, +) +print(response.choices[0].message.content) +``` + +vLLM က fine-grained control ပါဝင်တဲ့ native Python interface ကိုလည်း ပံ့ပိုးပေးပါတယ်- + +```python +from vllm import LLM, SamplingParams + +# အဆင့်မြင့် parameters တွေနဲ့ model ကို Initialize လုပ်ပါ။ +llm = LLM( + model="HuggingFaceTB/SmolLM2-360M-Instruct", + gpu_memory_utilization=0.85, + max_num_batched_tokens=8192, + max_num_seqs=256, + block_size=16, +) + +# Sampling parameters တွေကို Configure လုပ်ပါ။ +sampling_params = SamplingParams( + temperature=0.8, # ပိုမိုဖန်တီးမှုရှိရန် ပိုမိုမြင့်မားသော တန်ဖိုး + top_p=0.95, # 95% ဖြစ်နိုင်ခြေအများဆုံး tokens များကို ထည့်သွင်းစဉ်းစားပါ။ + max_tokens=100, # အများဆုံး အရှည် + presence_penalty=1.1, # ထပ်ခါတလဲလဲ မဖြစ်အောင် လျှော့ချပါ။ + frequency_penalty=1.1, # ထပ်ခါတလဲလဲ မဖြစ်အောင် လျှော့ချပါ။ + stop=["\n\n", "###"], # Stop sequences +) + +# Text generate လုပ်ပါ။ +prompt = "Write a creative story" +outputs = llm.generate(prompt, sampling_params) +print(outputs[0].outputs[0].text) + +# Chat-style interactions အတွက် +chat_prompt = [ + {"role": "system", "content": "You are a creative storyteller."}, + {"role": "user", "content": "Write a creative story"}, +] +formatted_prompt = llm.get_chat_template()(chat_prompt) # Uses model's chat template +outputs = llm.generate(formatted_prompt, sampling_params) +print(outputs[0].outputs[0].text) +``` + + + + + +## Advanced Generation Control + +### Token Selection နှင့် Sampling[[token-selection-and-sampling]] + +text ကို generate လုပ်တဲ့ လုပ်ငန်းစဉ်မှာ အဆင့်တိုင်းမှာ နောက်ထပ် token ကို ရွေးချယ်တာ ပါဝင်ပါတယ်။ ဒီရွေးချယ်မှု လုပ်ငန်းစဉ်ကို parameters အမျိုးမျိုးကနေတစ်ဆင့် ထိန်းချုပ်နိုင်ပါတယ် - + +1. **Raw Logits**: token တစ်ခုစီအတွက် မူရင်း output probabilities များ။ +2. **Temperature**: ရွေးချယ်မှုမှာရှိတဲ့ ကျပန်းဆန်မှုကို ထိန်းချုပ်ပါတယ် (ပိုမြင့်ရင် ပိုမိုဖန်တီးမှုရှိပါတယ်)။ +3. **Top-p (Nucleus) Sampling**: ဖြစ်နိုင်ခြေပမာဏ X% ကို ဖွဲ့စည်းထားတဲ့ ထိပ်ဆုံး tokens တွေကို စစ်ထုတ်ပါတယ်။ +4. **Top-k Filtering**: ဖြစ်နိုင်ခြေအများဆုံး tokens k ခုအထိ ရွေးချယ်မှုကို ကန့်သတ်ပါတယ်။ + +ဒီ parameters တွေကို ဘယ်လို configure လုပ်ရမလဲဆိုတာကတော့... + + + + + +```python +client.generate( + "Write a creative story", + temperature=0.8, # ပိုမိုဖန်တီးမှုရှိရန် ပိုမိုမြင့်မားသော တန်ဖိုး + top_p=0.95, # 95% ဖြစ်နိုင်ခြေအများဆုံး tokens များကို ထည့်သွင်းစဉ်းစားပါ။ + top_k=50, # ထိပ်ဆုံး 50 tokens များကို ထည့်သွင်းစဉ်းစားပါ။ + max_new_tokens=100, # အများဆုံး အရှည် + repetition_penalty=1.1, # ထပ်ခါတလဲလဲ မဖြစ်အောင် လျှော့ချပါ။ +) +``` + + + + + +```python +# OpenAI API compatibility မှတစ်ဆင့် +response = client.completions.create( + model="smollm2-1.7b-instruct", # Model name (llama.cpp server အတွက် မည်သည့် string မဆို ဖြစ်နိုင်သည်) + prompt="ဖန်တီးမှုရှိတဲ့ ပုံပြင်တစ်ပုဒ် ရေးပေးပါ။", + temperature=0.8, # ပိုမိုဖန်တီးမှုရှိရန် ပိုမိုမြင့်မားသော တန်ဖိုး + top_p=0.95, # 95% ဖြစ်နိုင်ခြေအများဆုံး tokens များကို ထည့်သွင်းစဉ်းစားပါ။ + frequency_penalty=1.1, # မကြာခဏ ပေါ်လာသော tokens များကို ထပ်ခါတလဲလဲ မဖြစ်အောင် လျှော့ချပါ။ + presence_penalty=0.1, # ရှိပြီးသား tokens များကို ထပ်ခါတလဲလဲ မဖြစ်အောင် လျှော့ချပါ။ + max_tokens=100, # အများဆုံး အရှည် +) + +# llama-cpp-python တိုက်ရိုက် access မှတစ်ဆင့် +output = llm( + "Write a creative story", + temperature=0.8, + top_p=0.95, + top_k=50, + max_tokens=100, + repeat_penalty=1.1, +) +``` + + + + + +```python +params = SamplingParams( + temperature=0.8, # ပိုမိုဖန်တီးမှုရှိရန် ပိုမိုမြင့်မားသော တန်ဖိုး + top_p=0.95, # 95% ဖြစ်နိုင်ခြေအများဆုံး tokens များကို ထည့်သွင်းစဉ်းစားပါ။ + top_k=50, # ထိပ်ဆုံး 50 tokens များကို ထည့်သွင်းစဉ်းစားပါ။ + max_tokens=100, # အများဆုံး အရှည် + presence_penalty=0.1, # ထပ်ခါတလဲလဲ မဖြစ်အောင် လျှော့ချပါ။ +) +llm.generate("Write a creative story", sampling_params=params) +``` + + + + + +### ထပ်ခါတလဲလဲ ဖြစ်မှုကို ထိန်းချုပ်ခြင်း[[controlling-repetition]] + +frameworks နှစ်ခုလုံးက ထပ်ခါတလဲလဲ text generation ကို ကာကွယ်ဖို့ နည်းလမ်းတွေ ပံ့ပိုးပေးပါတယ်။ + + + + + +```python +client.generate( + "Write a varied text", + repetition_penalty=1.1, # ထပ်ခါတလဲလဲ ဖြစ်သော tokens များကို ဒဏ်ခတ်ပါ။ + no_repeat_ngram_size=3, # 3-gram ထပ်ခါတလဲလဲ ဖြစ်မှုကို ကာကွယ်ပါ။ +) +``` + + + + + +```python +# OpenAI API မှတစ်ဆင့် +response = client.completions.create( + model="smollm2-1.7b-instruct", + prompt="Write a varied text", + frequency_penalty=1.1, # မကြာခဏ ပေါ်လာသော tokens များကို ဒဏ်ခတ်ပါ။ + presence_penalty=0.8, # ရှိပြီးသား tokens များကို ဒဏ်ခတ်ပါ။ +) + +# တိုက်ရိုက် library မှတစ်ဆင့် +output = llm( + "Write a varied text", + repeat_penalty=1.1, # Penalize repeated tokens + frequency_penalty=0.5, # အပို frequency penalty + presence_penalty=0.5, # အပို presence penalty +) +``` + + + + + +```python +params = SamplingParams( + presence_penalty=0.1, # Token ရှိခြင်းအတွက် ဒဏ်ခတ်ပါ။ + frequency_penalty=0.1, # Token မကြာခဏ ပေါ်လာခြင်းအတွက် ဒဏ်ခတ်ပါ။ +) +``` + + + + + +### အရှည် ထိန်းချုပ်ခြင်းနှင့် ရပ်တန့်ခြင်း Sequences များ[[length-control-and-stop-sequences]] + +generation length ကို ထိန်းချုပ်နိုင်ပြီး ဘယ်အချိန်မှာ ရပ်တန့်ရမယ်ဆိုတာ သတ်မှတ်နိုင်ပါတယ်။ + + + + + +```python +client.generate( + "Generate a short paragraph", + max_new_tokens=100, + min_new_tokens=10, + stop_sequences=["\n\n", "###"], +) +``` + + + + + +```python +# OpenAI API မှတစ်ဆင့် +response = client.completions.create( + model="smollm2-1.7b-instruct", + prompt="Generate a short paragraph", + max_tokens=100, + stop=["\n\n", "###"], +) + +# တိုက်ရိုက် library မှတစ်ဆင့် +output = llm("Generate a short paragraph", max_tokens=100, stop=["\n\n", "###"]) +``` + + + + + +```python +params = SamplingParams( + max_tokens=100, + min_tokens=10, + stop=["###", "\n\n"], + ignore_eos=False, + skip_special_tokens=True, +) +``` + + + + + +## Memory Management[[memory-management]] + +frameworks နှစ်ခုလုံးက ထိရောက်တဲ့ inference အတွက် အဆင့်မြင့် memory management နည်းစနစ်တွေကို implement လုပ်ထားပါတယ်။ + + + + + +TGI က Flash Attention 2 နဲ့ continuous batching ကို အသုံးပြုပါတယ်။ + +```sh +# Memory optimization ပါဝင်တဲ့ Docker deployment +docker run --gpus all -p 8080:80 \ + --shm-size 1g \ + ghcr.io/huggingface/text-generation-inference:latest \ + --model-id HuggingFaceTB/SmolLM2-1.7B-Instruct \ + --max-batch-total-tokens 8192 \ + --max-input-length 4096 +``` + + + + + +llama.cpp က quantization နဲ့ optimized memory layout ကို အသုံးပြုပါတယ်- + +```sh +# Memory optimizations ပါဝင်တဲ့ Server +./server \ + -m smollm2-1.7b-instruct.Q4_K_M.gguf \ + --host 0.0.0.0 \ + --port 8080 \ + -c 2048 \ # Context size + --threads 4 \ # CPU threads + --n-gpu-layers 32 \ # ပိုကြီးတဲ့ models တွေအတွက် GPU layers များများ အသုံးပြုပါ + --mlock \ # Swapping မဖြစ်စေရန် memory ကို lock လုပ်ပါ + --cont-batching # Continuous batching ကို ဖွင့်ပါ။ +``` + +သင့် GPU အတွက် အရမ်းကြီးတဲ့ models တွေအတွက် CPU offloading ကို အသုံးပြုနိုင်ပါတယ်။ + +```sh +./server \ + -m smollm2-1.7b-instruct.Q4_K_M.gguf \ + --n-gpu-layers 20 \ # ပထမဆုံး 20 layers ကို GPU မှာ ထားပါ + --threads 8 # CPU layers တွေအတွက် CPU threads များများ အသုံးပြုပါ +``` + + + + + +vLLM က အကောင်းဆုံး memory management အတွက် PagedAttention ကို အသုံးပြုပါတယ်။ + +```python +from vllm.engine.arg_utils import AsyncEngineArgs + +engine_args = AsyncEngineArgs( + model="HuggingFaceTB/SmolLM2-1.7B-Instruct", + gpu_memory_utilization=0.85, + max_num_batched_tokens=8192, + block_size=16, +) + +llm = LLM(engine_args=engine_args) +``` + + + + + +## အရင်းအမြစ်များ[[resources]] + +- [Text Generation Inference Documentation](https://huggingface.co/docs/text-generation-inference) +- [TGI GitHub Repository](https://github.com/huggingface/text-generation-inference) +- [vLLM Documentation](https://vllm.readthedocs.io/) +- [vLLM GitHub Repository](https://github.com/vllm-project/vllm) +- [PagedAttention Paper](https://arxiv.org/abs/2309.06180) +- [llama.cpp GitHub Repository](https://github.com/ggerganov/llama.cpp) +- [llama-cpp-python Repository](https://github.com/abetlen/llama-cpp-python) + +## ဝေါဟာရ ရှင်းလင်းချက် (Glossary) + +* **Optimized Inference Deployment**: AI မော်ဒယ်များကို အသုံးပြုသူများထံသို့ ထိရောက်စွာနှင့် လျင်မြန်စွာ ဝန်ဆောင်မှုပေးနိုင်ရန် အကောင်းဆုံးဖြစ်အောင် ပြုလုပ်ထားသော လုပ်ငန်းစဉ်။ +* **LLM (Large Language Model)**: လူသားဘာသာစကားကို နားလည်ပြီး ထုတ်လုပ်ပေးနိုင်တဲ့ အလွန်ကြီးမားတဲ့ Artificial Intelligence (AI) မော်ဒယ်တွေ ဖြစ်ပါတယ်။ +* **Text Generation Inference (TGI)**: Hugging Face မှ LLM များအတွက် မြန်နှုန်းမြင့် text generation ကို အထူးပြုထားသော framework တစ်ခု။ +* **vLLM**: မြန်နှုန်းမြင့် LLM inference အတွက် ဒီဇိုင်းထုတ်ထားသော library တစ်ခုဖြစ်ပြီး PagedAttention ကို အသုံးပြုသည်။ +* **llama.cpp**: LLaMA models များကို consumer hardware ပေါ်တွင် run နိုင်ရန် အဓိကထားသော C/C++ implementation တစ်ခု။ +* **Production Environments**: ဆော့ဖ်ဝဲလ် သို့မဟုတ် မော်ဒယ်များကို အစစ်အမှန် အသုံးပြုသူများထံသို့ ဝန်ဆောင်မှုပေးသည့် ပတ်ဝန်းကျင်။ +* **Inference Efficiency**: AI မော်ဒယ်တစ်ခုက input data မှ output ကို ထုတ်လုပ်ရာတွင် အချိန်နှင့် အရင်းအမြစ်များကို မည်မျှ ထိရောက်စွာ အသုံးပြုနိုင်မှု။ +* **Framework Selection Guide**: မတူညီသော အသုံးပြုမှုပုံစံများအတွက် သင့်လျော်သော framework ကို ရွေးချယ်ရန် လမ်းညွှန်။ +* **Memory Management**: ကွန်ပျူတာ၏ memory ကို ထိထိရောက်ရောက် စီမံခန့်ခွဲခြင်း။ +* **Performance**: စနစ်တစ်ခု၏ အလုပ်လုပ်နိုင်စွမ်း သို့မဟုတ် အရှိန်အဟုန်။ +* **Flash Attention 2**: Transformer models များတွင် attention mechanism ကို memory bandwidth bottlenecks များကို ဖြေရှင်းပေးခြင်းဖြင့် optimization လုပ်သော နည်းပညာ။ +* **Continuous Batching**: GPU ကို အလုပ်များနေအောင် ထိန်းထားနိုင်ရန် requests များကို အဆက်မပြတ် batch လုပ်ပြီး ပေးပို့သော နည်းလမ်း။ +* **GPU (Graphics Processing Unit)**: AI/ML လုပ်ငန်းများတွင် အရှိန်မြှင့်ရန် အသုံးပြုသော processor။ +* **CPU (Central Processing Unit)**: ကွန်ပျူတာ၏ အဓိက processor။ +* **VRAM (Video RAM)**: GPU တွင် အသုံးပြုသော RAM အမျိုးအစား။ +* **PagedAttention**: LLM inference တွင် KV cache memory management ကို optimization လုပ်သော နည်းပညာ။ +* **KV Cache**: Text generation လုပ်နေစဉ်အတွင်း Transformer model က သိမ်းဆည်းထားသော attention keys နှင့် values များ။ +* **Memory Paging**: Memory ကို fixed-size "pages" များအဖြစ် ပိုင်းခြားခြင်း။ +* **Memory Fragmentation**: Memory ကို ထိရောက်စွာ အသုံးမပြုနိုင်ဘဲ အပိုင်းအစများအဖြစ် ပြန့်ကျဲနေခြင်း။ +* **Throughput**: အချိန်ယူနစ်တစ်ခုအတွင်း စနစ်တစ်ခုက လုပ်ဆောင်နိုင်သော လုပ်ငန်းပမာဏ။ +* **Quantization**: Model weights တွေရဲ့ precision ကို လျှော့ချခြင်းဖြင့် model size နဲ့ memory requirements တွေကို လျှော့ချသော နည်းလမ်း။ +* **INT8 (8-bit integers)**: 8-bit integers ဖြင့် ကိုယ်စားပြုသော ကိန်းဂဏန်းများ။ +* **GGML/GGUF Format**: llama.cpp မှ quantized inference အတွက် အကောင်းဆုံးဖြစ်အောင် ပြုလုပ်ထားသော custom tensor formats များ။ +* **Mixed Precision**: Model ၏ မတူညီသော အစိတ်အပိုင်းများတွင် မတူညီသော quantization levels များကို အသုံးပြုခြင်း။ +* **CPU Architectures**: CPU အမျိုးအစားများ (ဥပမာ - AVX2, AVX-512, NEON)။ +* **Local Deployments**: မော်ဒယ်များကို သုံးစွဲသူ၏ ကွန်ပျူတာ သို့မဟုတ် local server ပေါ်တွင် တပ်ဆင်အသုံးပြုခြင်း။ +* **Edge Devices**: ကွန်ပျူတာကွန်ရက်၏ အစွန်းပိုင်း (ဥပမာ - mobile devices, IoT devices) တွင် အလုပ်လုပ်သော devices များ။ +* **Enterprise-level Deployment**: လုပ်ငန်းကြီးများအတွက် ဒီဇိုင်းထုတ်ထားသော deployment ပုံစံ။ +* **Kubernetes Support**: Containerized application များကို automate လုပ်ပြီး deploy, scale လုပ်ရန်အတွက် Kubernetes platform ကို ထောက်ပံ့ခြင်း။ +* **Prometheus**: Monitoring system တစ်ခု။ +* **Grafana**: Data visualization tool တစ်ခု။ +* **Automatic Scaling**: requests များ၏ ပမာဏအပေါ် မူတည်ပြီး resources များကို အလိုအလျောက် ချိန်ညှိခြင်း။ +* **Content Filtering**: မသင့်လျော်သော သို့မဟုတ် အန္တရာယ်ရှိသော အကြောင်းအရာများကို စစ်ထုတ်ခြင်း။ +* **Rate Limiting**: အချိန်အတိုင်းအတာတစ်ခုအတွင်း requests အရေအတွက်ကို ကန့်သတ်ခြင်း။ +* **Developer-friendly Approach**: Developers များအတွက် အသုံးပြုရလွယ်ကူသော ချဉ်းကပ်မှု။ +* **OpenAI API Compatibility**: OpenAI ၏ API နှင့် တွဲဖက်အသုံးပြုနိုင်ခြင်း။ +* **Ray**: Distributed computing အတွက် Python framework တစ်ခု။ +* **Portability**: ဆော့ဖ်ဝဲလ်တစ်ခုကို မတူညီသော platform များ သို့မဟုတ် environments များသို့ အလွယ်တကူ ရွှေ့ပြောင်းအသုံးပြုနိုင်ခြင်း။ +* **`docker run --gpus all`**: Docker container ကို GPU အားလုံးကို အသုံးပြုပြီး run ရန် command။ +* **`--shm-size 1g`**: Shared memory size ကို 1GB အဖြစ် သတ်မှတ်ခြင်း။ +* **`InferenceClient`**: Hugging Face Hub မှ inference endpoint များနှင့် အပြန်အလှန်ဆက်သွယ်ရန် Python client။ +* **`openai`**: OpenAI API ကို အသုံးပြုရန်အတွက် Python client library။ +* **`git clone`**: Git repository ကို download လုပ်ရန် command။ +* **`make`**: Source code ကို executable file အဖြစ် build လုပ်ရန် command။ +* **`curl -L -O`**: URL မှ file တစ်ခုကို download လုပ်ရန် command။ +* **`--host`, `--port`**: Server ကို listen လုပ်မည့် host address နှင့် port နံပါတ်။ +* **`--n-gpu-layers`**: GPU တွင် ထားရှိမည့် model layers အရေအတွက်။ +* **Context Size (`-c`)**: Model က တစ်ကြိမ်တည်း လုပ်ဆောင်နိုင်သော tokens အရေအတွက် အများဆုံး။ +* **CPU Threads (`--threads`)**: CPU တွင် အသုံးပြုမည့် threads အရေအတွက်။ +* **Batch Size (`--batch-size`)**: Prompt evaluation အတွက် batch အရွယ်အစား။ +* **`llama_cpp`**: llama.cpp C++ library အတွက် Python bindings။ +* **`Llama` Class**: llama-cpp-python library မှ LLaMA model ကို load လုပ်ရန် class။ +* **`n_ctx`**: Model ၏ context window size။ +* **`n_threads`**: CPU threads အရေအတွက်။ +* **`n_gpu_layers`**: GPU ပေါ်တွင် ထားရှိမည့် layers အရေအတွက်။ +* **`SamplingParams`**: vLLM တွင် text generation အတွက် sampling parameters များကို သတ်မှတ်ရန် class။ +* **Temperature**: generated text ၏ randomness သို့မဟုတ် creativity ကို ထိန်းချုပ်သော parameter။ +* **Top-p (Nucleus) Sampling**: ဖြစ်နိုင်ခြေအများဆုံး tokens အချို့ကို ရွေးချယ်ပြီး ၎င်းတို့၏ စုစုပေါင်း ဖြစ်နိုင်ခြေသည် သတ်မှတ်ထားသော တန်ဖိုး (ဥပမာ - 0.95) ထက် မကျော်လွန်စေရ။ +* **Top-k Filtering**: ဖြစ်နိုင်ခြေအများဆုံး tokens `k` ခုကိုသာ ရွေးချယ်ပြီး ကျန်များကို လျစ်လျူရှုသည်။ +* **`max_new_tokens` / `max_tokens`**: Generate လုပ်မည့် tokens အရေအတွက် အများဆုံး။ +* **`repetition_penalty`**: ထပ်ခါတလဲလဲ ဖြစ်သော tokens များကို ဒဏ်ခတ်ရန် parameter။ +* **`do_sample`**: True ဖြစ်ပါက sampling ကို အသုံးပြုပြီး၊ False ဖြစ်ပါက greedy decoding ကို အသုံးပြုသည်။ +* **`frequency_penalty`**: မကြာခဏ ပေါ်လာသော tokens များကို ထပ်ခါတလဲလဲ မဖြစ်အောင် လျှော့ချရန် parameter။ +* **`presence_penalty`**: ရှိပြီးသား tokens များကို ထပ်ခါတလဲလဲ မဖြစ်အောင် လျှော့ချရန် parameter။ +* **`min_new_tokens` / `min_tokens`**: Generate လုပ်မည့် tokens အရေအတွက် အနည်းဆုံး။ +* **`stop_sequences`**: Generated text ကို ရပ်တန့်ရန်အတွက် သတ်မှတ်ထားသော sequence များ။ +* **`ignore_eos`**: End-of-sequence token ကို လျစ်လျူရှုရန်။ +* **`skip_special_tokens`**: Generated text မှ special tokens များကို ဖယ်ရှားရန်။ +* **CPU Offloading**: Model ၏ အစိတ်အပိုင်းအချို့ကို GPU မှ CPU သို့ ရွှေ့ပြောင်းပြီး လုပ်ဆောင်ခြင်း။ +* **`--mlock`**: Memory ကို lock လုပ်ပြီး swapping မဖြစ်စေရန် ကာကွယ်ခြင်း။ \ No newline at end of file diff --git a/chapters/my/chapter2/9.mdx b/chapters/my/chapter2/9.mdx new file mode 100644 index 000000000..aa0f8475d --- /dev/null +++ b/chapters/my/chapter2/9.mdx @@ -0,0 +1,252 @@ + + + + +# အခန်းပြီးဆုံးခြင်း စစ်ဆေးမှု[[end-of-chapter-quiz]] + + + +### 1. Language modeling pipeline ၏ အစီအစဉ်က ဘာလဲ။ + + + +### 2. Base Transformer model က ထုတ်ပေးတဲ့ tensor မှာ dimension ဘယ်နှစ်ခုရှိပြီး၊ ဘာတွေလဲ။ + +