WYNN747/burmese-coder-gemma

Burmese Coder 🏹🔥 (SF-FT-BASE)

Model Name: Burmese Coder (Gemma-3 4B)
Author: Dr. Wai Yan Nyein Naing (waiyan.nn18@gmail.com)
Model Type: Autoregressive Language Model (Causal LM)
Base Model: Google gemma-3-4b
Languages: Burmese (my), English (en)

📖 Model Description

Burmese Coder is a state-of-the-art, fine-tuned large language model specifically optimized for professional technical software development and programming assistance in the Burmese language. Built on top of the powerful Gemma-3 4B architecture, this model bridges the gap for Myanmar developers by providing highly accurate, conversational, and culturally nuances technical explanations without language barriers.

The model underwent rigorous training phases, starting with Supervised Fine-Tuning (SFT) on an enriched MBPP (Mostly Basic Python Problems) dataset translated and expanded with step-by-step Burmese explanations. To ensure linguistic purity and eliminate multilingual hallucinations, the model was ultra-hardened using Direct Preference Optimization (DPO) with targeted On-Policy Rejections.

🎯 Intended Uses & Limitations

⚠️ Disclaimer: This model is released strictly for educational purposes and academic testing. It is NOT production-ready and should NOT be used for commercial purposes or integrated into mission-critical applications.

Best-Suited Uses

• Educational Exploration: Learning and experimenting with fine-tuned Small Language Models (SLMs) tailored for the Burmese language.
• Code Generation & Prompt Testing: Evaluating the model's ability to write scripts and algorithms based on Burmese instructions in a controlled environment.
• Academic Research: Serving as a baseline or case study for localized, non-English programming assistants.
• Local Prototyping: Optimized for edge deployment and local inference testing via Ollama / GGUF on consumer hardware (macOS/Windows/Linux).

Out-of-Scope & Limitations

• Not for Production or Commercial Use: The model is an experimental research prototype. Its outputs must not be relied upon for production environments or commercial software systems.
• Domain Restriction: The model's primary focus strictly remains on programming and software engineering. General-purpose conversations outside technical domains may not be robust or highly coherent.

🛠️ Training Details

Training Paradigm

1. Supervised Fine-Tuning (SFT): Initial instruction fine-tuning to teach the model structured technical problem-solving and accurate Burmese translation.
2. Preference Alignment (DPO): Phase 4 ultra-hardening using Direct Preference Optimization (Beta=0.5). This phase utilized custom-generated hallucination datasets to heavily penalize language drift and reinforce strict Burmese linguistic consistency.

Dataset

• MBPP Enriched: 974-sample Mostly Basic Python Problems, augmented with extremely detailed, step-by-step Burmese explanations.
• Hallucination Rejection DPO: A curated dataset constructed to identify and reject mixed-language outputs.

💬 Example Output

Here is a sample interaction showcasing the model's ability to seamlessly blend technical programming logic with professional Burmese explanations.

User Prompt:

"Python မှာ Function တစ်ခု Error တက်သွားရင် သတ်မှတ်ထားတဲ့ အကြိမ်အရေအတွက်အတိုင်း ပြန်ကြိုးစားပေးမယ့် (Retry) Decorator တစ်ခုကို delay အချိန်နဲ့တကွ ရေးပြပါ။"

Burmese Coder Response: (The model generates both the executable code and the step-by-step explanation)

import time
from functools import wraps

def retry_on_failure(max_retries=3, delay=2):
    """
    Error တက်ခဲ့ပါက သတ်မှတ်ထားသော အကြိမ်အရေအတွက်အတိုင်း စောင့်ဆိုင်း၍ ပြန်ကြိုးစားမည့် Decorator
    """
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(1, max_retries + 1):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    print(f"[Error] Attempt {attempt} failed: {e}")
                    if attempt == max_retries:
                        raise e  # နောက်ဆုံးအကြိမ်တွင် Error ကို ပြန်လွှင့်မည်
                    time.sleep(delay)
        return wrapper
    return decorator

@retry_on_failure(max_retries=3, delay=2)
def unstable_api_call():
    # ကျပန်း Error ထွက်စေမည့် API Call အတု
    raise ConnectionError("Server Timeout!")

ရှင်းလင်းချက် (Explanation):

ဒီ code က အရည်အသွေးမြင့်တဲ့ Custom Decorator တစ်ခုကို `functools` ထဲက `wraps` နဲ့ 
တွဲဖက်တည်ဆောက်ထားတာ ဖြစ်ပါတယ်။ `retry_on_failure` ဆိုတဲ့ အပြင်ဆုံး function က 
`max_retries` နဲ့ `delay` parameter တွေကို လက်ခံပြီး အတွင်းပိုင်း logic ကို ထိန်းချုပ်ပေးပါတယ်။

`wrapper` အထဲမှာတော့ `try-except block` ကို အသုံးပြုပြီး Error တက်/မတက် စစ်ဆေးပါတယ်။
Error တက်ခဲ့ရင် `time.sleep(delay)` နဲ့ သတ်မှတ်ထားတဲ့ အချိန်စောင့်ပြီး နောက်တစ်ကြိမ် 
ပြန်ကြိုးစားပါတယ်။ အကယ်လို့ နောက်ဆုံးအကြိမ်အထိ Error ထပ်တက်နေသေးရင်တော့ မူလ Error
ကိုပဲ `raise e` ဆိုပြီး ပြန်လွှင့်ပေးလိုက်ပါတယ်။

---

🚀 How to Use (Local Inference)

This model is exported to GGUF format and is highly recommended to be run locally using Ollama for optimal memory efficiency and speed.

Via Ollama

1. Create the Modelfile:

FROM ./burmese_coder_v4.gguf
# Add specific system prompts or parameters here if needed

2. Initialize and Run:

ollama create burmese_coder -f Modelfile
ollama run burmese_coder

Via llama.cpp or text-generation-webui

Simply download the .gguf file and load it using the standard llama.cpp pipeline. Choose the quantization level (e.g., Q4_K_M or Q8_0) that best fits your VRAM requirements.

⚖️ License

This model is released under the Gemma License due to its base model heritage. Please adhere to the usage guidelines outlined by Google for Gemma derivatives.

🤝 Acknowledgments

• Creator: Engineered and trained by Dr. Wai Yan Nyein Naing.
• Initiative: Part of the Burmese Coding Assistant project.
• Mission: Empowering the technology and developer community in Myanmar with localized, open-source AI tools.