လေ့ကျင့်ခန်း: သင့်ကိုယ်ပိုင် Local AI Stack ကို ဒီဇိုင်းရေးဆွဲခြင်း

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

ဒီ course ထဲက lesson တိုင်းက ထပ်ခါထပ်ခါ အသုံးချနိုင်သော decision framework တစ်ခုဆီ ဦးတည်ခဲ့ပြီး၊ ဒီ exercise ကတော့ ၎င်းအားလုံးကို တစ်ပြိုင်နက်တည်း အသုံးချရမည့်နေရာဖြစ်သည်။ Framework က မေးခွန်းသုံးခုကို အစဉ်လိုက်မေးသည်။

• သင့်ရဲ့ အဓိက task က ဘာလဲ - ယေဘုယျ chat, coding ကူညီမှု, သင့်ကိုယ်ပိုင် document များပေါ်တွင် မေးခွန်း-အဖြေ, ဒါမှမဟုတ် agent တစ်ခုအနေဖြင့် tool များကို action လုပ်စေခြင်း
• သင့်တွင် hardware ဘာရှိသလဲ - CPU-only, integrated GPU, dedicated GPU, ထို hardware က RAM နှင့် VRAM ဘယ်လောက်ပေးနိုင်သလဲ
• အဲ့ဒီ ပထမနှစ်ခုက tradeoff တစ်ခု ဖြစ်ပေါ်လာချိန် သင့်အတွက် ဘာအရေးအကြီးဆုံးလဲ - speed, quality, privacy (offline ဖြစ်ခြင်း), ဒါမှမဟုတ် memory budget ကျဉ်းမြောင်းခြင်း

ဒီမေးခွန်းသုံးခုထဲက ဘယ်တစ်ခုမှ တစ်ကမ္ဘာလုံးအတွက် မှန်ကန်သော အဖြေမရှိပါ။ နှစ်ငါးနှစ်လောက်အသက်ရှိပြီးသော laptop ပေါ်ရှိ student တစ်ဦးနှင့် workstation GPU ရှိသော developer တစ်ဦးနှစ်ဦးလုံးက အလုပ်လုပ်နိုင်သော local AI stack ကို တည်ဆောက်နိုင်သော်လည်း model size, quantization level, runtime, retrieval-augmented generation (သို့) agent tooling လိုအပ်မလိုအပ်ဆိုတာက နှစ်ဦးအတွက် လုံးဝကွာခြားလိမ့်မည်။

Model, quantization format, hardware တို့သည် ဒီ course ပြီးနောက်လည်း အမြဲပြောင်းလဲနေမည်။ မေးခွန်းသုံးခုနှင့် ၎င်းကို မေးရမည့်အစဉ်ကတော့ မပြောင်းလဲပါ။ ဒါဟာ ဒီ exercise က တကယ်စမ်းသပ်နေတဲ့ skill ပင်ဖြစ်သည်။

THE THREE-QUESTION LOCAL AI DECISION FRAMEWORK
----------------------------------------------
THE THREE-QUESTION LOCAL AI DECISION FRAMEWORK
-----------------------------------------------------------
   TASK                HARDWARE              PRIORITY
   chat / coding /      CPU-only / iGPU /     speed / quality /
   documents / agent    dGPU + RAM + VRAM     privacy / low-mem
        \                    |                     /
         \                   |                    /
          v                  v                   v
                    ---------------------
                    |   RECOMMENDATION   |
                    ---------------------
                    - model size band
                    - quantization level
                    - runtime: CPU-only or GPU
                    - RAG needed?  agent needed?

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

Framework ကို လူနှစ်ဦးအပေါ် အသုံးချကြည့်ကြပါစို့။

လူနှစ်ဦးလုံးမှာ agent tooling မလိုအပ်ခဲ့ပါ၊ သို့သော် research task များကို automate လုပ်မည့် တတိယ persona တစ်ဦးဆိုလျှင် ၎င်းကို layer အသစ်တစ်ခုအဖြစ် ထပ်ပေါင်းရမည်ဖြစ်သည်။

• Decision framework ကတော့ task -> hardware -> priority ဆိုသော အစဉ်လိုက်ဖြစ်သည် - task က capability floor သတ်မှတ်ပေးပြီး၊ hardware က size ceiling သတ်မှတ်ပေးကာ၊ priority က ထိုအကွာအဝေးထဲမှာ ဆုံးဖြတ်ချက်ချပေးသည်။
• မေးခွန်းသုံးခုအတူတူကပင် လူတစ်ဦးနှင့်တစ်ဦးအတွက် လုံးဝကွာခြားသော်လည်း တန်ဖိုးတူညီသော stack များ ထုတ်ပေးနိုင်သည် -- local AI setup မှန်ကန်သည့် တစ်ခုတည်းသောပုံစံမရှိပါ၊ သင့်ပုံစံကို ရှာဖွေရန် မှန်ကန်သော process တစ်ခုသာရှိသည်။
• သင့်ကိုယ်ပိုင်အဖြေများကို ချရေးပါ။ သင့်ကိုယ်ပိုင် hardware နှင့် task အပေါ် တစ်ကြိမ်အသုံးချပြီးသား framework တစ်ခုသည် model (သို့) hardware ပြောင်းလဲလာသည့်အခါ ထပ်မံအသုံးချနိုင်မည့် framework တစ်ခုဖြစ်လိမ့်မည်။

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

def recommend(task, ram_gb, vram_gb, priority):
    """Illustrative, rule-based local-AI stack recommendation.

    This is a teaching simplification, not a production sizing tool.
    Real choices depend on the exact model, quantization method,
    runtime, and how much of the model can be offloaded to GPU vs CPU.
    """
    usable_gb = max(ram_gb, vram_gb)

    # Step 1: pick a rough model size band from usable memory.
    if usable_gb >= 40:
        size_band = "13B-34B"
        quant = "8-bit or FP16"
    elif usable_gb >= 16:
        size_band = "7B-13B"
        quant = "4-bit"
    else:
        size_band = "1B-3B"
        quant = "4-bit"

    # Step 2: bias the choice by stated priority.
    if priority == "quality" and usable_gb >= 16:
        quant = "8-bit" if usable_gb >= 24 else quant
    if priority == "speed":
        quant = "4-bit"
    if priority == "low_memory":
        size_band = "1B-3B" if usable_gb < 16 else size_band
        quant = "4-bit"

    # Step 3: task-specific add-ons.
    needs_rag = task == "documents"
    needs_agent = task == "agent"
    privacy_note = "safe to run fully offline" if priority == "privacy" else None

    runtime = "GPU-accelerated (llama.cpp/vLLM with GPU offload)" if vram_gb >= 6 \
        else "CPU-only (llama.cpp)"

    return {
        "task": task,
        "size_band": size_band,
        "quantization": quant,
        "runtime": runtime,
        "needs_rag": needs_rag,
        "needs_agent": needs_agent,
        "privacy_note": privacy_note,
    }


personas = [
    ("Small business owner: private document Q&A", "documents", 16, 0, "privacy"),
    ("Developer with a strong GPU: coding assistant", "coding", 32, 24, "quality"),
    ("Student on an old laptop: quick chat helper", "chat", 8, 0, "low_memory"),
]

for label, task, ram, vram, priority in personas:
    result = recommend(task, ram, vram, priority)
    print(label)
    print(f"  inputs: task={task}, ram={ram}GB, vram={vram}GB, priority={priority}")
    print(f"  recommendation: {result}")
    print()

`recommend()` ကို persona သုံးဦးအတွက် run လိုက်လျှင် တစ်ဦးစီအတွက် dict တစ်ခုစီ print ထုတ်သည်။ Business owner (documents, RAM 16 GB, VRAM 0 GB, privacy) အတွက် `{'size_band': '7B-13B', 'quantization': '4-bit', 'runtime': 'CPU-only (llama.cpp)', 'needs_rag': True, 'needs_agent': False, 'privacy_note': 'safe to run fully offline'}` ရရှိသည်။ Developer (coding, RAM 32 GB, VRAM 24 GB, quality) အတွက် `{'size_band': '7B-13B', 'quantization': '8-bit', 'runtime': 'GPU-accelerated (llama.cpp/vLLM with GPU offload)', 'needs_rag': False, 'needs_agent': False}` ရရှိသည်။ Student (chat, RAM 8 GB, VRAM 0 GB, low_memory) အတွက် `{'size_band': '1B-3B', 'quantization': '4-bit', 'runtime': 'CPU-only (llama.cpp)', 'needs_rag': False, 'needs_agent': False}` ရရှိသည် -- input သုံးမျိုးမှ stack သုံးမျိုးထွက်လာခြင်းသည် framework က ခန့်မှန်းသည့်အတိုင်းပင်ဖြစ်သည်။

Ollama Model Library — Local AI / Local LLM

Local AI Glossary — အသုံးများသော ဝေါဟာရများ