README.md

---
language:
- my
- en
tags:
- gemma
- gemma-3
- coding
- burmese
- dpo
- text-generation
- gguf
- conversational
base_model: google/gemma-3-4b
license: mit
library_name: transformers
---

# Burmese Coder-4b  🏹🔥 

**Model Name:** Burmese Coder (Gemma-3 4B)  
**Author:** Dr. Wai Yan Nyein Naing ([waiyan.nn18@gmail.com](mailto: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.

> [!NOTE]
> **Further Fine-Tuning (FT):** This model is specifically designed as a solid base for further fine-tuning or specialized downstream technical tasks in the Burmese language.

## 🎯 Intended Uses & Limitations

### 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.

## 📊 Benchmarks
Burmese-Coder-4B was evaluated using a two-track framework: **Functional Correctness (Pass@1)** and **Language-Aware Quality (LLM-as-a-Judge)**.

### Functional & Linguistic Performance
| Model | Pass@1 (%) | Rubric (DeepSeek) | Rubric (Gemini) |
| :--- | :---: | :---: | :---: |
| **Burmese-Coder-4B** | **62.0** | **3.456** | **3.779** |
| Gemma-3 4B (Base) | 62.0 | 2.939 | 3.203 |
| Qwen 2.5 3B | 45.0 | 1.220 | 2.526 |

### Visual Performance Comparison
![Benchmarks](benchmarks.png)

### Linguistic Stability (Mixed-Language Penalty)
*Lower is better. Measures resistance to script mixing and token drift.*
- **Burmese-Coder-4B**: **0.02** (Gemini) / **0.09** (DeepSeek)
- Gemma-3 4B: 0.69 (Gemini) / 0.72 (DeepSeek)
- Qwen 2.5 3B: 1.37 (Gemini) / 1.18 (DeepSeek)

> [!NOTE]
> **Key Finding:** Burmese-Coder-4B maintains the full functional power of the base model while drastically reducing mixed-language hallucinations and improving technical terminal accuracy in Burmese.

## 💬 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)*
```python
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():
    # API ခေါ်ဆိုမှုတွင် Error ဖြစ်ပေါ်မှုကို စမ်းသပ်ရန်အတွက် ဖန်တီးထားသော လုပ်ဆောင်ချက် အတု
    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:**
```text
FROM ./burmese_coder_v4.gguf
# Add specific system prompts or parameters here if needed
```

2. **Initialize and Run:**
```bash
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.

## 📜 Citation
If you use Burmese Coder in your research or application, please cite the following paper:

```bibtex
@inproceedings{naing2026burmesecoder,
  title = {Burmese-Coder-4B: Fine-Tuning a Small Language Model for Burmese Coding with Language-Aware Evaluation},
  author = {Naing, Wai Yan Nyein},
  year = {2026},
  publisher = {GitHub Pages},
  url = {https://waiyannyeinnaing.github.io/assets/pdf/burmese_coder_4b.pdf},
  dataset = {https://huggingface.co/datasets/WYNN747/burmese-human-eval},
  dataset_mbpp = {https://huggingface.co/datasets/WYNN747/burmese-mbpp}
}
```

Find the full research paper here: [Burmese-Coder-4B Paper](https://waiyannyeinnaing.github.io/assets/pdf/burmese_coder_4b.pdf)

## ⚖️ License
This model is released under the **MIT License**.