Quantization: Model ကို ချုံ့ခြင်း

နားလည်ထားရမယ့် အချက်

သင်ခန်းစာ ၃ မှာ 7B model တစ်ခုဟာ full precision မှာ ဂဏန်းတွေကို သိမ်းထားတဲ့အခါ memory ၁၃GB လောက် လိုအပ်တယ်ဆိုတာ တွေ့ခဲ့ပါပြီ။ လူအများစုမှာ VRAM ၁၃GB အားနေတာ မရှိတတ်ပါဘူး၊ ဒါကြောင့် လက်တွေ့မေးခွန်းတစ်ခု ပေါ်လာပါတယ် - model ကို စွန့်လွှတ်ပြီး အသစ်ပြန်မလုပ်ဘဲ ချုံ့လို့ရနိုင်လား? အဖြေက quantization ပါ - model ရဲ့ internal ဂဏန်းတစ်ခုချင်းစီကို original train လုပ်ခဲ့တာထက် bit နည်းနည်းနဲ့ သိမ်းဆည်းခြင်းပါ။

model တွေကို ပုံမှန် FP32 (32-bit floating point) (သို့) FP16 (16-bit floating point) နဲ့ train လေ့ရှိပြီး ဒါတွေက အလွန်သေချာတဲ့ precision ပေးပါတယ်။ quantization က ဒီဂဏန်းတွေကို INT8 (8-bit whole number) (သို့) INT4 (4-bit whole number) အထိတောင် ပြောင်းပစ်ပါတယ် - တိကျတဲ့ measurement တစ်ခုကို decimal place နည်းနည်းလောက်ပဲ ချန်ပြီး round ချသလိုမျိုးပါ။

ဂဏန်း တစ်ခုလျှင် bit နည်းလေ model file တစ်ခုလုံးရဲ့ memory နည်းလေဖြစ်ပြီး၊ ဒါဟာ ပုံမှန် consumer hardware ပေါ်မှာ model ကြီးကြီးတွေ run လို့ရဖို့ quantization ကို လိုအပ်စေတဲ့ အကြောင်းရင်းအတိအကျပါပဲ။

ဒါပေမယ့် ဒါက free lunch မဟုတ်ပါဘူး။ round ချတိုင်း information အချို့ ဆုံးရှုံးတတ်ပြီး၊ aggressive quantize လုပ်ထားတဲ့ model တစ်ခုဟာ original ထက် သိသိသာသာ ပိုဆိုးတဲ့ အဖြေတွေ ပေးနိုင်ပါတယ် -

• fact မှားခြင်း
• ခက်ခဲတဲ့ မေးခွန်းတွေမှာ reasoning အားနည်းခြင်း
• စကားလုံးအသုံး ထူးဆန်းခြင်း

quality ဘယ်လောက်ဆုံးရှုံးမလဲဆိုတာ bit count တစ်ခုတည်းထက် သုံးထားတဲ့ quantization method အတိအကျပေါ် များစွာမူတည်ပါတယ် - clever technique အချို့က bit width နည်းနေတောင် quality နည်းနည်းပဲ ဆုံးရှုံးပြီး၊ ရိုးရိုး method တွေကတော့ ပိုဆုံးရှုံးပါတယ်။

beginner တွေ မှတ်ထားသင့်တဲ့ လက်တွေ့ rule က ရိုးရှင်းပါတယ် - quantization ဟာ memory ချွေတာမှုအတွက် quality အချို့ပေးဆပ်ရတာဖြစ်ပြီး၊ ဒီ trade-off ကို အစစ်အမှန်လို့ သဘောထားပါ၊ အခမဲ့လို့ မယူဆပါနဲ့။

Quantization

model ရဲ့ ဂဏန်းတွေကို bit နည်းနည်းနဲ့ ပြန်သိမ်းပြီး memory ချွေတာစေတဲ့ လုပ်ငန်းစဉ်ပါ။

FP16

16-bit floating point format ဖြစ်ပြီး model train လုပ်ရာမှာ အသုံးများတဲ့ precision level တစ်ခုပါ။

INT4

4-bit whole number format ဖြစ်ပြီး memory အလွန်ချွေတာပေမယ့် quality trade-off အများဆုံးရှိတတ်တဲ့ quantization level တစ်ခုပါ။

QUANTIZATION PIPELINE
---------------------
[Original Model]  -->  [Quantization]  -->  [Smaller Model]
  FP16, high precision      round each          INT8 or INT4
  ~13 GB for 7B params       number down          ~3-7 GB

  RESULT: less memory needed, faster to load and run,
          but usually some loss in answer quality

လက်တွေ့ scenario နဲ့ ချိတ်ကြည့်မယ်

VRAM 6GB ပဲ ရှိတဲ့ laptop နဲ့ 7B model run ချင်တဲ့ လူတစ်ယောက်ကို စဉ်းစားကြည့်ပါ။ full FP16 precision မှာ model က ~13GB လိုအပ်ပြီး - အံဝင်ခွင်ကျ လုံးဝမဖြစ်ပါဘူး။ INT4 အထိ quantize ချထားရင်တော့ ဒီ model အတူတူဟာ ~3-4GB အထိ ကျုံ့သွားပြီး ဒီ laptop ပေါ်မှာ comfortable စွာ အံဝင်ခွင်ကျ run နိုင်တဲ့ speed ရနိုင်ပါတယ်။

quantization ဟာ ဘာလို့အရေးကြီးလဲဆိုတဲ့ နေ့စဉ်အကြောင်းရင်းက ဒါပါပဲ - advanced optimization trick တစ်ခုမဟုတ်ဘဲ ခင်ဗျားရဲ့ hardware ပေါ်မှာ model run လို့ရမရ ကွာခြားချက်ကို ဆုံးဖြတ်ပေးတာပါ။

ဒါပေမယ့် trade-off ကလည်း တကယ်ရှိပါတယ် - ဒီလူရဲ့ task ဟာ legal document review လိုမျိုးဖြစ်ပြီး fact အမှားလေးတွေတောင် အရေးကြီးရင်၊ memory ချွေတာဖို့ အတွက်ပဲ quantize အထူး aggressive လုပ်ထားတဲ့ version ကို ရွေးလိုက်ရင် မခံနိုင်တဲ့ အမှားတွေ ဖြစ်စေနိုင်ပါတယ်။

လက်တွေ့ skill ကတော့ - memory ချွေတာဖို့ quality နည်းနည်းလျော့တာ လက်ခံသင့်ချိန်၊ ဒါမှမဟုတ် task က အရေးကြီးလွန်းလို့ quantize aggressive နည်းတာ (သို့) memory ပိုသုံးတာ ကုန်ကျစရိတ်တန်တဲ့ ချိန် ဘယ်အချိန်လဲသိထားဖို့ပါ။

• quantization က model ဂဏန်းတွေကို bit နည်းနည်းနဲ့ ပြန်သိမ်းတာ
• memory ကို သိသိသာသာ ချွေတာပေးတယ်
• quality trade-off ရှိတယ်၊ method အတိအကျပေါ်လည်း မူတည်တယ်

အတူတူ စမ်းရေးကြည့်မယ်

def estimate_memory_gb(params_billion, bytes_per_param):
    total_bytes = params_billion * 1_000_000_000 * bytes_per_param
    return total_bytes / (1024 ** 3)


precisions = [
    ("FP16", 2),
    ("INT8", 1),
    ("INT4", 0.5),
]

params_b = 7
print(f"Model size: {params_b}B parameters")
for name, bytes_per_param in precisions:
    gb = estimate_memory_gb(params_b, bytes_per_param)
    print(f"  {name}: ~{gb:.2f} GB")

7B parameter model တစ်ခုအတွက် precision သုံးမျိုး (FP16, INT8, INT4) မှာ memory ဘယ်လောက်လျော့သွားလဲ ယှဉ်ပြထားပါတယ်။ Output အတိအကျမှာ - Model size: 7B parameters
  FP16: ~13.04 GB
  INT8: ~6.52 GB
  INT4: ~3.26 GB

Hugging Face docs: Quantization — Local AI / Local LLM