Data Lighthouse

အခုခေတ်မှာ AI ဆိုတာ အရမ်းခေတ်စားလာပြီး
LLM (Large Language Model) တွေ၊ API တွေ၊
GPT Wrapper တွေဆိုတာလည်း
တစ်နေ့တစ်ခြား ပိုများလာပါတယ်။

ဒီနေ့ခေတ်မှာ AI Tool တွေကို အသုံးပြုနိုင်တာက အရေးကြီးပေမယ့် အဲဒီ Tool တွေကို
ဘယ်လိုတည်ဆောက်ထားလဲ (How)နဲ့
ဘာကြောင့် ဒီလိုအလုပ်လုပ်နေတာလဲ (Why) ဆိုတာကို
နားလည်နိုင်တာက ပိုပြီး အရေးကြီးလာပါတယ်။

ကျွန်တော်အနေနဲ့တော့ Tool ကို သုံးတတ်ရုံနဲ့
မတင်းတိမ်ဘဲ အဲဒီ Tool တွေရဲ့ အောက်ခံမှာရှိတဲ့
Model တွေ Architecture တွေ
Concept တွေကို Deep Dive လုပ်ပြီး
လေ့လာမိပါတယ်။

ဒါကြောင့် AI ကို စိတ်ဝင်စားပြီး “အသုံးပြုသူ” ကနေ
“တည်ဆောက်သူ” အဖြစ် ပြောင်းချင်တဲ့သူတွေ
အတွက် AI နဲ့ပတ်သက်တဲ့ Knowledge Sharing တွေကို
Deep Dive အနေနဲ့ ဆက်လက်မျှဝေပေးသွားပါမယ်။

ဆက်လက်စောင့်မျှော်ပေးကြပါဦး 🙏

Embeddings & Vector Databases - 2 (How Embedding Models Actually Work)

ရှေ့က Article မှာ Embeddings & Vector Databases အကြောင်းကို
Introduction အနေနဲ့ ပြောပြပေးပြီးပြီဆိုတော့ ဒီ Post မှာ
Embedding Model တွေ ဘယ်လိုအလုပ်လုပ်လဲဆိုတဲ့
အကြောင်းကို ပိုပြီး ရှင်းပြပေးသွားပါမယ်။

ပထမဆုံး အနေနဲ့ ဒီ Embedding Model တွေ မပေါ်ခင်တုန်းက
Text တွေကို Machine တွေ နားလည်မယ့် Numerical Vectors တွေအဖြစ်
ဘယ်လိုပြောင်းလဲခဲ့တဲ့ နည်းလမ်းတွေကို အရင်သွားကြည့်ရအောင်ပါ

Bag of Words (BoW) ဆိုတာကတော့ Document တစ်ခုထဲမှာရှိတဲ့
စာလုံးတစ်လုံးချင်းစီ (Word) ရဲ့ အကြိမ်အရေအတွက်နဲ့
Represent လုပ်တာပဲ ဖြစ်ပါတယ်။
အဲဒီ Frequency ကို Count လုပ်ခြင်းအားဖြင့် Corpus ထဲမှာရှိတဲ့
Unique words တွေ ရရှိပါတယ်။

ဥပမာ အနေနဲ့ ကျွန်တော်တို့မှာ "AI is fast" နဲ့ "AI is smart" ဆိုတဲ့
စာကြောင်းနှစ်ကြောင်း ရှိတယ်ဆိုပါစို့။
BoW က စာလုံးတွေကို [AI, is, fast, smart] ဆိုပြီး စာရင်းလုပ်လိုက်ပါမယ်။

ပထမစာကြောင်းအတွက် Vector က [1, 1, 1, 0] ဖြစ်သွားပြီး၊
ဒုတိယစာကြောင်းအတွက်ကတော့ [1, 1, 0, 1] ဖြစ်သွားမှာပါ။

ဒါပေမဲ့ သူ့ရဲ့ Limitation ကတော့ သူက Word တွေအားလုံးဟာ
Independent ဖြစ်တယ်လို့ ယူဆပြီး
Grammar, Context နဲ့ Word Level တွေကို Ignore လုပ်ပါတယ်။
တစ်နည်းပြောရရင် စာလုံးတွေရဲ့ အစီအစဉ်ကို ထည့်မတွက်ဘဲ
အိတ်တစ်ခုထဲ စုထည့်ထားသလိုမျိုး ဖြစ်နေတာပါ။

နောက်တစ်ခုကတော့ TF-IDF လို့ခေါ်တဲ့
Term Frequency-Inverse Document Frequency ပါ။
Term Frequency ဆိုတာကတော့ ခုနက BoW နဲ့ အလားတူပဲ
Document တစ်ခုမှာ Word တစ်ခုချင်းစီဟာ
ဘယ်လောက်ကြိမ်ရေပါသလဲဆိုတာပါပဲ။
ဒါပေမဲ့ TF-IDF မှာကျတော့ Weight ပါ ပါလာပါတယ်။
IDF ကျတော့ Word တစ်ခုချင်းစီဟာ Corpus တစ်ခုလုံးမှာ
ဘယ်လောက် Rare ဖြစ်သလဲဆိုတာကို ပြောတာပါ။

ဥပမာ အနေနဲ့ "The", "Is", "And" တို့လို စာလုံးတွေက
Document တိုင်းမှာ ခဏခဏ ပါနေတတ်ပါတယ်။
TF-IDF က ဒီလိုစာလုံးတွေကို အရေးမကြီးဘူးလို့ သတ်မှတ်ပြီး
Weight လျှော့ချပစ်ပါတယ်။
တစ်ဖက်မှာတော့ "Deep Learning" ဒါမှမဟုတ် "Transformer" လိုမျိုး
Document အနည်းငယ်မှာပဲ ထူးထူးခြားခြား ပါတတ်တဲ့ စာလုံးတွေကိုကျတော့ Weight ပိုပေးပြီး
ဒါဟာ ဒီ Document ရဲ့ အဓိက Key ဖြစ်တယ်လို့ မှတ်ယူတာမျိုးပါ။

Word2Vec ဆိုတာကတော့ Neural Network ကို
အခြေခံထားတဲ့ အစောပိုင်း Word Embedding နည်းလမ်းတစ်ခုပါပဲ။
သူက စာလုံးတွေရဲ့ ဆက်စပ်မှုကို Vector Space ပေါ်မှာ
အကွာအဝေးနဲ့ တိုင်းတာနိုင်အောင် စတင်လုပ်ဆောင်ပေးခဲ့တာပါ။
ဒါပေမဲ့ ဒီနေရာမှာ ကျွန်တော်တို့ သိထားရမှာက Embedding တွေကို
Static နဲ့ Dynamic ဆိုပြီး နှစ်မျိုး ခွဲခြားနိုင်တာပါပဲ။

Static Embedding (ဥပမာ - Word2Vec, GloVe)
Static Embedding ဆိုတာကတော့ စာလုံးတစ်လုံးကို
Vector တစ်ခုတည်းအဖြစ်ပဲ ပုံသေ သတ်မှတ်ထားတာမျိုးပါ။
တစ်နည်းပြောရရင် စာလုံးတစ်လုံးဟာ ဘယ်စာကြောင်းထဲမှာပဲ ပါပါ၊
သူ့ရဲ့ Vector တန်ဖိုးက အမြဲတမ်း တူညီနေပါတယ်။
သူ့ရဲ့ အဓိက Limitation ကတော့ Context မရှိတာပါပဲ။
ဥပမာဆိုရရင် "I am eating an apple." (ပန်းသီး) နဲ့ "I just bought an apple iPhone." (Apple ကုမ္ပဏီ)
ဒီနေရာမှာ "Apple" ဆိုတဲ့ စာလုံးက အဓိပ္ပာယ် နှစ်မျိုး ဖြစ်နေပေမဲ့
Static Embedding မှာကျတော့ သူတို့ကို ခွဲခြားနိုင်စွမ်း မရှိပါဘူး။
Apple ဆိုတာနဲ့ Vector တစ်မျိုးတည်းကိုပဲ ထုတ်ပေးတာဖြစ်လို့
စာလုံးရဲ့ အဓိပ္ပာယ် အစစ်အမှန်ကို ယူရတာ ခက်ခဲစေပါတယ်။

Dynamic (Contextual) Embedding (ဥပမာ - BERT, RoBERTa)
ဒီနေရာမှာ Dynamic Embedding ကျတော့ Context ကိုပါ
နားလည်အောင် လုပ်ပေးနိုင်ပါတယ်။
သူက စာလုံးတစ်လုံးတည်းကိုပဲ ပတ်ဝန်းကျင်မှာရှိတဲ့
တခြားစာလုံးတွေနဲ့ နှိုင်းယှဉ်ပြီး မတူညီတဲ့ Vector တွေကို ထုတ်ပေးတာပါ။
ဒါကို Transformer Architecture ထဲက Attention Mechanism ကို
သုံးပြီး လုပ်ဆောင်တာ ဖြစ်ပါတယ်။
ခုနက "Apple" ဥပမာကိုပဲ ပြန်ကြည့်ရင် Dynamic Embedding (BERT လို Model မျိုး) က
“Eating" ဆိုတဲ့ စာလုံးပါရင် ဒါဟာ "အသီး" ဖြစ်တယ်လို့ သိပြီး Vector တစ်မျိုး ထုတ်ပေးပါတယ်။ "iPhone" ဆိုတဲ့ စာလုံးနဲ့ တွဲပါလာရင်တော့ ဒါဟာ "Company" ဖြစ်တယ်ဆိုတာကို သိပြီး နောက်ထပ် Vector တစ်မျိုး ပြောင်းလဲထုတ်ပေးတာမျိုးပါ။

ဒါကြောင့်မို့လို့ Dynamic Embedding တွေဟာ စာလုံးတစ်လုံးတည်းရဲ့ မတူညီတဲ့ အဓိပ္ပာယ် (Polysemy) တွေကို ပိုပြီး တိတိကျကျ ဖော်ပြနိုင်လာတာ ဖြစ်ပါတယ်။

ဒီနေရာမှာ Attention Mechanism ဆိုတာလေးကို နည်းနည်းလေးပိုပြီး ရှင်းပြပေးချင်ပါတယ်။
Attention ဆိုတာကတော့ အခုလက်ရှိခေတ်စားနေတဲ့ Large Language Model တွေရဲ့ အဓိက core ပဲဖြစ်ပါတယ်

ဒီ Attention Mechanism ကြောင့် Model တွေဟာ
Sentence တခုတည်းမှာရှိတဲ့ Word တခုချင်းစီဟာ
တခြားသော Word တွေနဲ့ ဘယ်လိုဆက်နွယ်နေလဲဆိုတဲ့
Information ကိုပေးပါတယ်။
တနည်းအားဖြင့် သူတို့ဟာ Context ကို
နားလည်တယ်လို့ပြောချင်တာပါ။
မြန်မာမှာ “လူတွေ ဆုံးပါးသွားတဲ့ အခါ သေသည်၊ ဆုံးသည်လို့သုံးပြီး
ဘုန်းကြီးတွေဆုံးပါးသွားတဲ့အခါကျ ပျံလွန်တော်မူသည်” ဆိုပြီး
သုံးနှုန်းကျသလိုပါပဲ။
သူတို့ဟာ Context အပေါ်မူတည်ပြီး Word တွေကို
Processing လုပ်နိုင်စွမ်းရှိပါတယ်။

Attention Mechanism ကိုမှ Self-Attention Mechanism နဲ့ Multi-Head Attention Mechanism ကို နည်းနည်းပိုရှင်းပြချင်ပါတယ်။

Self-Attention Mechanism
Transformer လို့ခေါ်တဲ့ Attention Mechanism based model တစ်ခုဟာ Word တစ်ခုချင်းစီကို Vector ၃ ခု ပေးပါတယ်။
သူတို့တွေကတော့ Q, K, V ပါ။
Query (Q): ဒီစာလုံးက ဘာကို ရှာနေတာလဲ?
Key (K): တခြားစာလုံးတွေမှာ ဘယ်လို Information တွေ ရှိသလဲ?
Value (V): ဒီစာလုံးမှာ ရှိနေတဲ့ တကယ့် အနှစ်သာရက ဘာလဲ?
ဥပမာအနေနဲ့ မြင်အောင်ပြောရမယ်ဆိုရင် စာအုပ်တစ်အုပ်ရဲ့ Page Number တွေဟာ Key ဖြစ်ပြီး အဲဒီ Page Number ထဲက Content ကတော့ Value ဖြစ်ပါတယ်။ Query ဆိုတာကတော့ ကျွန်တော်တို့ ရှာနေတဲ့ Information ပေါ့။

Self-Attention ဆိုတာကတော့ စာကြောင်းတစ်ကြောင်းထဲမှာရှိတဲ့
စာလုံးတစ်လုံးချင်းစီဟာ ကျန်တဲ့စာလုံးတွေနဲ့ ဘယ်လောက်အထိ
အဓိပ္ပာယ်သက်ရောက်မှု ရှိသလဲဆိုတာကို တွက်ချက်တာပါ။
ခုနက ပြောခဲ့တဲ့ Q, K, V ကို သုံးပြီး Machine က ဘယ်လိုတွက်လဲဆိုရင်
Machine က Q နဲ့ K ကို မြှောက်လိုက်တဲ့အခါ
(Dot Product) Attention Score ဆိုတာ ရလာပါတယ်။
အဲဒီ Score က "ဒီစာလုံးနှစ်လုံးဟာ တစ်လုံးနဲ့တစ်လုံး
ဘယ်လောက် အရေးကြီးလဲ" ဆိုတာကို ပြောပြတာပါ။
အဲဒီ Score အတိုင်း Value (V) ကို Weight ပေးပြီး
ပေါင်းလိုက်တဲ့အခါမှာတော့ Context ကို
နားလည်တဲ့ Vector တစ်ခု ထွက်လာတာ ဖြစ်ပါတယ်။

Multi-Head Attention Mechanism
ဒါဆိုရင် Multi-Head Attention ကရော ဘာလဲ?
အလွယ်ပြောရရင်တော့ Self-Attention တွေကို
အပြိုင် (Parallel) အများကြီး လုပ်ဆောင်တာပါပဲ။
ဘာဖြစ်လို့ အများကြီး လုပ်ဖို့ လိုတာလဲဆိုရင်
စာလုံးတစ်လုံးတည်းကိုပဲ မတူညီတဲ့ ရှုထောင့်တွေကနေ
နားလည်ချင်လို့ပါ။
ဥပမာ -
Head 1: က သဒ္ဒါ (Grammar) ဆက်စပ်မှုကို ကြည့်နေမယ်။
Head 2: က အဓိပ္ပာယ် (Meaning) ဆက်စပ်မှုကို ကြည့်နေမယ်။
Head 3: ကတော့ အချိန်ကာလ (Tense) ဆက်စပ်မှုကို ကြည့်နေမယ်။

"The animal didn't cross the street because it was too tired."
ဒီနေရာမှာ "it" ဆိုတာ "Animal" ကို ပြောတာလား၊ "Street" ကို ပြောတာလား?
Head တစ်ခု ကနေ ကြည့်ရင် "it" နဲ့ "Animal" ရဲ့ ဆက်စပ်မှုကို မိသွားမယ်။
နောက် Head တစ်ခု ကနေ ကြည့်ရင် "Tired" ဖြစ်နေတာဟာ
"Animal" ပဲ ဖြစ်နိုင်တယ်ဆိုတဲ့ အဓိပ္ပာယ်ကို မိသွားပါမယ်။

ဒီလိုမျိုး Head အများကြီးကနေ ရလာတဲ့ Information တွေကို
ပြန်ပေါင်းလိုက်တဲ့အခါမှာတော့ Model က
စာကြောင်းတစ်ကြောင်းလုံးရဲ့ အဓိပ္ပာယ်ကို
ရှုထောင့်ပေါင်းစုံကနေ ကျယ်ကျယ်ပြန့်ပြန့်
နားလည်သွားတာ ဖြစ်ပါတယ်။

ဒီလိုမျိုး Context ကို နားလည်သွားတဲ့ Vector တွေဟာ
Latent Space လို့ခေါ်တဲ့ အတိုင်းအဆမဲ့ ကိန်းဂဏန်း ကမ္ဘာထဲမှာ
သွားပြီး နေရာယူကြပါတယ်။
ကျွန်တော်တို့ ရှေ့မှာ ပြောခဲ့သလို Embedding ဆိုတာ
Text တွေကို နံပါတ်တွေအဖြစ် ပြောင်းလိုက်တာပါ။
ဒါပေမဲ့ အဲဒီ နံပါတ်တွေက တစ်လုံး၊ နှစ်လုံးတည်း မဟုတ်ပါဘူး။

ဥပမာအားဖြင့်:
768 dimensions (BERT base model တွေမှာ သုံးလေ့ရှိတယ်)
1536 dimensions (OpenAI ရဲ့ text-embedding-3-small မှာ သုံးလေ့ရှိတယ်)
ဒီ Dimensions ဆိုတာကို အလွယ်ပြောရရင်
စာလုံးတစ်လုံးရဲ့ "စရိုက်လက္ခဏာ" တွေလို့ မှတ်ယူလို့ ရပါတယ်။
စာလုံးတစ်လုံးမှာ dimension တွေ များလေလေ၊ သူ့ရဲ့ အဓိပ္ပာယ်ကို
ပိုပြီး အသေးစိတ် ဖော်ပြနိုင်လေလေပါပဲ။
ဒီ Latent Space ထဲမှာ:
အဓိပ္ပာယ်တူတဲ့အရာတွေ က Vector Space ထဲမှာ
တစ်ခုနဲ့တစ်ခု နီးကပ်စွာ ရှိနေကြပြီး၊
အဓိပ္ပာယ်မတူတဲ့အရာတွေ ကတော့
တစ်ခုနဲ့တစ်ခု ဝေးကွာနေမှာ ဖြစ်ပါတယ်။

ဒီနေရာမှာ "Bank" ဥပမာကိုပဲ Deep Dive ပြန်ကြည့်ရအောင်။
ကျွန်တော်တို့မှာ "Bank" ဆိုတဲ့ စာလုံး ရှိမယ်။
Dynamic Embedding Model ကနေ ဖြတ်လိုက်တဲ့အခါ:
၁။ အကယ်၍ Context က Finance (ငွေကြေး) ဖြစ်နေရင်
အဲဒီ "Bank" ရဲ့ Vector ဟာ Space ထဲမှာ
Money, Loan, Deposit စတဲ့ စာလုံးတွေ ရှိရာဘက်ကို
စုကပ် သွားပါတယ်။
၂။ အကယ်၍ Context က Nature (မြစ်ကမ်းပါး) ဖြစ်နေရင်
အဲဒီ "Bank" ရဲ့ Vector က Water, Shore, River စတဲ့ စာလုံးတွေ
ရှိရာဘက်ကို ပြောင်းပြီး စုကပ်သွားမှာပါ။
ဒါဟာ "Apple" (အသီး) နဲ့ "Apple" (Company) အတွက်လည်း အတူတူပါပဲ။

ဒါကြောင့်မို့လို့ Vector Database တွေမှာ Vector Similarity Search (ဥပမာ - Cosine Similarity) ကို သုံးပြီး ရှာလိုက်တဲ့အခါ စာသားချင်း မတူရင်တောင် အဓိပ္ပာယ်တူတာကို Model က ရှာပေးနိုင်တာ ဖြစ်ပါတယ်။

နိဂုံးချုပ်အနေနဲ့ ပြောရရင် Embedding Model တွေဟာ စာသားတွေကို နံပါတ်တွေအဖြစ် ပြောင်းပေးရုံတင် မဟုတ်ဘဲ၊ လူသားတွေရဲ့ ဘာသာစကားထဲက နက်ရှိုင်းလှတဲ့ Context တွေ၊ ဆက်စပ်မှုတွေကို Latent Space ထဲမှာ သင်္ချာနည်းအရ နေရာချပေးလိုက်တာပဲ ဖြစ်ပါတယ်။

ကျွန်တော်တို့ အပေါ်မှာ ပြောခဲ့တာတွေက Text Embedding တွေ အကြောင်းပါ။ ဒါပေမဲ့ အခုခေတ်မှာတော့ Multimodal Embedding တွေကြောင့် တခြား Data Type တွေကိုပါ Vector ပြောင်းပြီး Latent Space ထဲမှာ အတူတူ နေရာချလို့ ရလာပါပြီ။

Files & Documents: PDF တွေ၊ Word File တွေကို
စာမျက်နှာအလိုက် ဒါမှမဟုတ် အဓိပ္ပာယ်အလိုက် အပိုင်းပိုင်းဖြတ်
(Chunking) ပြီး Vector ပြောင်းလိုက်တာပါ။
ဒါမှသာ ကျွန်တော်တို့က "ဒီ File ထဲမှာ ဘယ်အကြောင်းအရာ ပါလဲ?"
ဆိုတာကို AI ကို မေးလို့ရမှာ ဖြစ်ပါတယ်။
Audio Embedding: အသံလှိုင်း (Sound waves) တွေကို
Numerical Features တွေအဖြစ် ပြောင်းလိုက်တာပါ။
ဒါကြောင့် Model တွေက စကားပြောသံတင်မကဘဲ
နောက်ခံဆူညံသံ ဒါမှမဟုတ် သီချင်းတစ်ပုဒ်ရဲ့ အမျိုးအစား (Genre) ကိုပါ
ခွဲခြားနိုင်လာတာ ဖြစ်ပါတယ်။
Video Embedding: ဗီဒီယိုဆိုတာ တကယ်တော့ Frames တွေ
အများကြီးကို အစီအစဉ်အလိုက် ပြထားတာပါ။
Model က Frame တစ်ခုချင်းစီရဲ့ အဓိပ္ပာယ်နဲ့
အဲဒီ Frame တွေကြားက ဆက်စပ်မှု (Movement) ကိုပါ
Vector ပြောင်းလိုက်ပါတယ်။
ဒါကြောင့် "ဗီဒီယိုထဲမှာ ခွေးလေး ပြေးနေတဲ့ အပိုင်းကို ရှာပေးပါ"
ဆိုတာမျိုးတွေ လုပ်လို့ရလာတာပါ။

အခုဆိုရင် Embedding Model တွေ
ဘယ်လို အလုပ်လုပ်လဲဆိုတာကို Traditional နည်းလမ်းတွေကနေ
အခုခေတ် Attention Mechanism တွေအထိ
နှံ့နှံ့စပ်စပ် သိသွားကြပြီလို့ မျှော်လင့်ပါတယ်။

ဒီ Article ကို အနှစ်ချုပ်ရမယ်ဆိုရင်:
BoW နဲ့ TF-IDF တို့လို ရိုးရာနည်းလမ်းတွေဟာ
စာလုံးအရေအတွက် (Frequency) ကိုပဲ ကြည့်နိုင်ပေမဲ့၊
Embedding Model တွေကတော့ စာလုံးတွေရဲ့ အဓိပ္ပာယ်နဲ့
ဆက်စပ်မှု (Context) ကိုပါ နားလည်လာကြပါတယ်။
Transformer Architecture ထဲက
Self-Attention နဲ့ Multi-Head Attention တို့ကြောင့်
စာလုံးတစ်လုံးတည်းကိုပဲ ရှုထောင့်ပေါင်းစုံကနေ ကြည့်ပြီး
ပိုမို တိကျတဲ့ Vector တွေ ထုတ်ပေးနိုင်တာ ဖြစ်ပါတယ်။
Embedding တွေဟာ မြင့်မားတဲ့ Dimension တွေရှိတဲ့
Latent Space ထဲမှာ နေရာယူကြပါတယ်။
အဓိပ္ပာယ်တူရင် နီးကပ်ပြီး၊ အဓိပ္ပာယ်ကွဲလွဲရင်
ဝေးကွာသွားတဲ့ သဘောတရားကို အသုံးပြုထားတာပါ။

အခုခေတ်မှာ Text တင်မကဘဲ Audio, Video နဲ့ Files တွေကိုပါ
Vector ပြောင်းလဲပြီး AI က Processing လုပ်နိုင်နေပြီ ဖြစ်ပါတယ်။
နောက်တစ်ပတ်မှာတော့ 'Vector Similarity: How AI Finds Meaningful Information' ဆိုတဲ့ ခေါင်းစဉ်နဲ့အတူ Vector တွေကြားက
အကွာအဝေးကို တိုင်းတာတဲ့ Cosine Similarity, Euclidean Distance, Manhattan Distance တို့အပြင်၊ အချက်အလက်တွေ
အများကြီးထဲကနေ မြန်မြန်ဆန်ဆန် ရှာပေးနိုင်တဲ့
ANN (Approximate Nearest Neighbor) အကြောင်းတွေကို
အသေးစိတ် ဆက်လက် ရှင်းပြပေးသွားပါဦးမယ်။

Embeddings & Vector Databases - 1

ကျွန်တော်တို့ Web Application တွေ၊
သုံးနေကျ Application တွေ Software တွေမှာဖြစ်ဖြစ်
Search ဆိုတဲ့ အရာကတော့ ရှောင်လွှဲလို့ရတဲ့ဟာ မဟုတ်ပါဘူး။

အခုခေတ် AI တွေ ခေတ်မစားခင်တုန်းက ကျွန်တော်တို့ဟာ
Traditional Search ဖြစ်တဲ့ Keyword Search ကိုပဲ မှီခိုခဲ့ကြပါတယ်။

Keyword Search ဆိုတာကတော့ ရိုးရှင်းပါတယ် ။
E-Commerce App တခုမှာ ကိုယ်လိုချင်တဲ့
Product တခုကို ရိုက်ရှာလိုက်တယ်။
အကယ်၍ ကိုယ်ရှာလိုက်တဲ့ Keyword နဲ့
Database ထဲက Product Keyword နဲ့
ကိုက်တယ်ဆိုရင် ရှာတွေ့မယ်ပေါ့။

ဒါပေမယ့် Keyword Search မှာက Limitation ရှိပါတယ်။
ဥပမာ အနေနဲ့ ကျွန်တော်တို့က Car ဆိုပြီးရိုက်ရှာတယ်။
Database ထဲမှာကျ Vehicle ပဲရှိတယ်ဆိုပါစို့ ။
အဲဒီအခါကျ ဒီနှစ်ခုဟာ အဓိပ္ပာယ်ချင်းတူတယ်ဆိုရင်တောင်မှ
Result ကထွက်မလာတော့ပါဘူး။

ဘာလို့ဆို Keyword Search ဟာ Word အပေါ်မှာပဲ
အလုပ်လုပ်ပြီး သူက အဓိပ္ပာယ်ကို နားမလည်ပါဘူး။

ဒီလိုနဲ့ ကျွန်တော်တို့ဟာ Word တွေကို Machine တွေ
နားလည်မယ့် Number အဖြစ်ပြောင်းလဲပြီး ဖော်ပြခဲ့ကြပါတယ်။

ကွန်ပျူတာတွေဟာ စာသား (Raw Text) တွေကို
နားမလည်ပါဘူး။ သူတို့ နားလည်တာက
ကိန်းဂဏန်း (Number) တွေပဲ ဖြစ်ပါတယ်။
ဒါကြောင့် စကားလုံးတွေရဲ့ အဓိပ္ပာယ်ကို
Machine တွေ နားလည်အောင် Number Array တွေ၊
တနည်းအားဖြင့် Vector တွေအဖြစ်
ပြောင်းလဲပေးရပါတယ်။

ဥပမာပြရရင် -
cat → [0.21, -0.45, 0.90, ...]
dog → [0.19, -0.42, 0.88, ...]
car → [-0.81, 0.11, 0.35, ...]

ဒီနေရာမှာ သတိထားကြည့်ရင် 'cat' နဲ့ 'dog' ရဲ့
Number လေးတွေဟာ ခပ်ဆင်ဆင်တူနေပြီး၊
'car' ကတော့ သူတို့နဲ့ လုံးဝကွဲထွက်နေပါတယ်။
ဆိုလိုတာက အဓိပ္ပာယ်တူရင် Vector တန်ဖိုးတွေလည်း ဆင်တူပါတယ်။
ဒီလိုမျိုး Data တွေရဲ့ အဓိပ္ပာယ် (Meaning) ကို
ကွန်ပျူတာနားလည်အောင် ကိုယ်စားပြုဖော်ပြပေးတဲ့
Numerical Representation ကို Embedding လို့ ခေါ်ပါတယ်။

Embedding Vector တွေကို ရပြီဆိုရင် နောက်တစ်ဆင့်အနေနဲ့
Space ဆိုတဲ့ သဘောတရားကို သွားပါမယ်။
Vector တစ်ခုစီတိုင်းကို Coordinate System ပေါ်က
အမှတ် (Point) တစ်ခုအနေနဲ့ မြင်ကြည့်လို့ရပါတယ်။

ဥပမာ - [2, 3] ဆိုတဲ့ 2D Vector လေးဆိုရင် X-axis မှာ 2၊
Y-axis မှာ 3 ဆိုတဲ့ အမှတ်လေးတစ်ခု ဖြစ်သွားပါမယ်။

ဒါပေမယ့် တကယ့်လက်တွေ့ AI Model တွေမှာသုံးတဲ့
Embedding တွေက Dimension (၂) ခုတည်း မကပါဘူး။
Dimension ပေါင်း ရာနဲ့ထောင်နဲ့ချီပြီး ရှိပါတယ်။
ဥပမာ - 768-dimensional vector ဆိုပါစို့။
ကျွန်တော်တို့ လူသားတွေအနေနဲ့ 3D ထက်ကျော်လွန်တဲ့
Space ကို မျက်စိထဲမှာ Visualizeလုပ်နိုင်စွမ်း မရှိပေမယ့်၊
သင်္ချာသဘောတရားအရတော့ ဒါဟာ တည်ရှိနေပါတယ်။

ဒီလို Dimension တွေ အများကြီးနဲ့ ဖွဲ့စည်းထားတဲ့ နေရာကို
Latent Space လို့ခေါ်ပါတယ်။ "Latent" ဆိုတဲ့ စကားလုံးရဲ့
အဓိပ္ပာယ်က "Hidden"လို့ အဓိပ္ပာယ်ရပါတယ်။
ဒါကြောင့် Latent Space ဆိုတာ Data တွေရဲ့
နောက်ကွယ်က သဘောတရားတွေ၊ Feature တွေကို
သင်္ချာနည်းကျကျ ကိုယ်စားပြုဖော်ပြပေးထားတဲ့
Hidden Space တစ်ခုပဲ ဖြစ်ပါတယ်။
ဥပမာ - ကျွန်တော်တို့ လူတွေက 'dog', 'cat', 'car' လို့ မြင်ပေမယ့်၊
Model ကတော့ အဲဒီစကားလုံးတွေရဲ့ နောက်ကွယ်က
Hidden Feature တွေဖြစ်တဲ့ animalness, vehicle-ness, size, shape, behavior
စတာတွေကို လေ့လာမှတ်သားထားပြီး
Latent Space ထဲမှာ နေရာချပေးပါတယ်။

ဒီ Latent Space ရဲ့ အဓိက အားသာချက်ကတော့ ဆက်စပ်မှုရှိတဲ့၊
အဓိပ္ပာယ်တူတဲ့ Concept တွေဟာ ဒီ Space ထဲမှာ
အချင်းချင်း နီးနီးကပ်ကပ် စုဝေးနေကြတာပါပဲ။

ဥပမာ - 'dog' နဲ့ 'cat'၊ 'tiger' နဲ့ 'lion' တို့ဟာ
တိရိစ္ဆာန်ဖြစ်တဲ့ Feature တွေ တူတဲ့အတွက်
တစ်စုတစ်စည်းတည်း (Cluster) ဖြစ်နေပါလိမ့်မယ်။
အလားတူပဲ 'car', 'truck', 'bus' တို့ကလည်း
ယာဉ်တွေဖြစ်တဲ့အတွက် အခြားတစ်နေရာမှာ
သီးသန့် Cluster လေး သွားဖြစ်နေမှာပါ။
ဒါဟာ Latent Space ကနေပြီး Knowledge တွေကို
သူ့အလိုလို စနစ်တကျ Organize ပေးလိုက်တာပဲ ဖြစ်ပါတယ်။

Latent Space ထဲမှာ နောက်ထပ် စိတ်ဝင်စားစရာကောင်းတာက
စကားလုံးတွေကြားက ဆက်စပ်မှု (Relationships) တွေကိုပါ
Model က နားလည်သွားတာပါ။
ဥပမာတစ်ခုကတော့ king - man + woman ≈ queen
'ဘုရင် (king)' ဆိုတဲ့ Vector ထဲက 'ယောက်ျား (man)' ဆိုတဲ့
Feature ကို နှုတ်ပြီး 'မိန်းမ (woman)' ဆိုတဲ့ Feature ကို
ပေါင်းထည့်လိုက်ရင် 'ဘုရင်မ (queen)' ဆိုတဲ့ အဓိပ္ပာယ်ကို
သွားရရှိတာပဲ ဖြစ်ပါတယ်။
ဆိုလိုတာက Model ဟာ Gender၊ Royalty၊ အလုပ်အကိုင် နဲ့ ပထဝီဝင်ဆိုင်ရာ
Pattern တွေကိုပါ ကောင်းကောင်း သဘောပေါက်ထားလို့ပဲ ဖြစ်ပါတယ်။

ဒီလို Latent Space ထဲမှာ နေရာချထားနိုင်ဖို့အတွက်
Embedding Model တွေဟာ အဓိကအားဖြင့်
အချက် (၃) ချက်ကို သင်ယူလေ့လာကြပါတယ်။
Semantics: စကားလုံးတွေရဲ့ တကယ့် အဓိပ္ပာယ်ကို နားလည်အောင် လုပ်ပါတယ်။
Relationships: စကားလုံး တစ်လုံးနဲ့ တစ်လုံးကြားက ဆက်စပ်ပုံတွေကို လေ့လာပါတယ်။
Contextual Meaning: ရှေ့နောက် စာသားတွေပေါ် မူတည်ပြီး အဓိပ္ပာယ်တွေ
ဘယ်လိုပြောင်းသွားလဲ ဆိုတာကိုပါ မှတ်သားပါတယ်။
ဥပမာအားဖြင့် -
"doctor" ဆိုတဲ့ စကားလုံးဟာ "nurse" ဆိုတဲ့ စကားလုံးနဲ့
အလုပ်အကိုင်၊ ဆေးရုံ စတဲ့ Feature တွေ တူတဲ့အတွက်
Latent Space ထဲမှာ နီးနီးကပ်ကပ် ရှိနေပါလိမ့်မယ်။
အလားတူပဲ "apple" ဆိုတာကလည်း "fruit" ဆိုတဲ့
စကားလုံးနဲ့ အုပ်စုတစ်ခုတည်း ဖြစ်တဲ့အတွက်
နီးကပ်စွာ တည်ရှိနေမှာပါ။

ဒီလောက်ဆိုရင် သဘောတရားကို
အတော်လေး မြင်သာလောက်ပါပြီ။
အနှစ်ချုပ်ရရင်တော့ Embedding Vector ဆိုတာ
Data Point တစ်ခုရဲ့ Latent Space ထဲမှာရှိတဲ့
Coordinate (တည်နေရာ) တစ်ခုပါပဲ။
'cat' ဆိုတာ Latent Space ထဲက အမှတ်တစ်ခု
'dog' ဆိုတာ အဲဒီအနားက ဆက်စပ်နေတဲ့ အမှတ်တစ်ခု
'car' ကတော့ သူတို့နဲ့ အဝေးကြီးမှာရှိတဲ့ အမှတ်တစ်ခု
ဒီလို တည်နေရာ (Coordinates) တွေ ရှိလာတဲ့အတွက်
Machine တွေဟာ စကားလုံးတွေရဲ့ အဓိပ္ပာယ်
ဘယ်လောက်နီးစပ်လဲ၊ ဘယ်လောက်ကွာဝေးလဲ
(Similarity Distance) ကို သင်္ချာနည်းအရ
တိုင်းတာလို့ ရသွားတာ ဖြစ်ပါတယ်။

ဒီနေရာမှာ မဖြစ်မနေ သိထားသင့်တဲ့ နောက်ထပ်
အရေးကြီးတဲ့ အဆင့်တစ်ဆင့် ရှိပါသေးတယ်။
အဲဒါကတော့ Transformer Embeddings ပါပဲ။
အရင်ခေတ်က သုံးခဲ့တဲ့ Word2Vec လို Model တွေမှာ
စကားလုံးတစ်လုံးအတွက် Vector (Embedding) တစ်ခုတည်းပဲ
အမြဲတမ်း ရှိပါတယ်။
ဥပမာ - "Bank" ဆိုတဲ့ စကားလုံးကို ကြည့်ရအောင်။
မြစ်ကမ်းပါး (River bank)
ငွေအပ်တဲ့ဘဏ် (Bank account)
အရင် Model တွေက ဒီနှစ်ခုလုံးအတွက်
Vector အတူတူပဲ ထုတ်ပေးပါတယ်။
ဒါပေမယ့် တကယ်တမ်းမှာ အဓိပ္ပာယ်က လုံးဝ မတူပါဘူး။
ဒီပြဿနာကို ဖြေရှင်းပေးလိုက်တာကတော့
BERT, GPT စတဲ့ Transformer Models တွေပါပဲ။
Transformer တွေဟာ စကားလုံးတစ်လုံးတည်းကိုပဲ
ကြည့်တာမဟုတ်ဘဲ တစ်ကြောင်းလုံးရဲ့ ရှေ့နောက်
အခြေအနေ (Context) ကိုပါ ထည့်သွင်းစဉ်းစားပြီးမှ
(Contextualized Embeddings) ထုတ်ပေးတာ ဖြစ်ပါတယ်။
ဒါကြောင့် "I went to the bank to deposit money" မှာရှိတဲ့
Bank နဲ့ "I sat on the river bank" မှာရှိတဲ့ Bank ဟာ
Latent Space ထဲမှာ လုံးဝ မတူညီတဲ့ နေရာ နှစ်ခုမှာ သွားပြီး
နေရာယူပါတော့တယ်။ ဒါဟာ ယနေ့ခေတ် LLM တွေ
လူတွေလို နားလည်လာရခြင်းရဲ့ အဓိက လျှို့ဝှက်ချက်ပဲ ဖြစ်ပါတယ်။

ဒီ Latent Space နဲ့ Embedding သဘောတရားကို
အသုံးပြုပြီး လက်ရှိခေတ် AI Application တွေမှာ
အများကြီး အသုံးချလာကြပါတယ်။
Semantic Search: Keyword မတူလည်း အဓိပ္ပာယ်တူတာတွေကို
ရှာဖွေပေးနိုင်ခြင်း။
Recommendation Systems: User နဲ့ အကြိုက်တူမယ့် Content တွေ၊
Product တွေကို ရွေးချယ်ပေးခြင်း။
Clustering & Anomaly Detection: ဆင်တူရာတွေ စုဖွဲ့ပေးခြင်းနဲ့
ပုံမှန်မဟုတ်တာတွေကို ခွဲခြားပေးခြင်း။
RAG Systems (Retrieval-Augmented Generation): AI ကို
ကိုယ်ပိုင် Data တွေထည့်ပေးပြီး အဓိပ္ပာယ်ရှိရှိ
မေးခွန်းတွေ ပြန်ဖြေခိုင်းခြင်း။
Generative AI: LLM တွေကနေ စာသားအသစ်တွေ ဖန်တီးပေးခြင်း
စတာတွေမှာ အဓိက အသုံးပြုကြပါတယ်။

ဒီ Article ရဲ့ အဓိက အချက်တွေကတော့ -
ကွန်ပျူတာတွေဟာ Raw Text တွေကို တိုက်ရိုက် နားမလည်ပါဘူး။
Embeddings တွေက Text တွေကို Vectors (ကိန်းဂဏန်းတွေ) အဖြစ် ပြောင်းလဲပေးပါတယ်။
အဲဒီ Vectors တွေဟာ Latent Space လို့ခေါ်တဲ့
Hidden Space တစ်ခုထဲက အမှတ် (Points) တွေ ဖြစ်လာပါတယ်။
အဓိပ္ပာယ်တူတဲ့ စကားလုံးတွေဟာ အဲဒီ Latent Space ထဲမှာ နီးနီးကပ်ကပ် ရှိနေကြပါတယ်။

Hello everyone, I’m back! 👋

လွန်ခဲ့တဲ့ နှစ်နှစ်လောက်ကစပြီး
ကျွန်တော် Data Science နယ်ပယ်ကနေ
AI & Machine Learning ဘက်ကို
အာရုံစိုက်ပြီး ပြောင်းလဲလေ့လာဖြစ်ခဲ့ပါတယ်။

အခုတော့ ရရှိထားတဲ့ အတွေ့အကြုံသစ်တွေနဲ့
AI/ML ဆိုင်ရာ နည်းပညာရပ်တွေကို
Data Lighthouse မှာ ပြန်လည် မျှဝေပေးသွားတော့မှာပါ။

နယ်ပယ်အသစ်မှာ ထပ်တူလေ့လာချင်သူတွေ အတွက် အကျိုးရှိမယ့် Content တွေကို
အကောင်းဆုံး တင်ဆက်ပေးသွားမှာမို့
စောင့်မျှော်ကြည့်ရှုပေးကြပါဦးခင်ဗျာ။