ການ Fine-Tune ໂມເດວ Gemma 4 ດ້ວຍຊຸດຂໍ້ມູນພາສາລາວສະເພາະ

ໃນໂລກຂອງ AI ທີ່ກ້າວໄປຢ່າງໄວວາ, ໂມເດວ Open-weights ຢ່າງ Gemma 4 ຈາກ Google ໄດ້ສ້າງມາດຕະຖານໃໝ່ໃຫ້ກັບວົງການ LLMs (Large Language Models). ແນວໃດກໍ່ຕາມ, ສຳລັບນັກພັດທະນາໃນລາວ ບັນຫາຫຼັກທີ່ເຮົາມັກພົບຄື: ໂມເດວລະດັບໂລກເຫຼົ່ານີ້ມັກຈະຂາດຄວາມເຂົ້າໃຈບໍລິບົດທ້ອງຖິ່ນ (Local Context) ເຊັ່ນ: ການອະທິບາຍສະພາບຈະລາຈອນໃນນະຄອນຫຼວງວຽງຈັນ, ການວິເຄາະຂໍ້ມູນຜົນຜະລິດກາເຟຢູ່ປາກຊ່ອງ, ຫຼື ແມ່ນແຕ່ການຕອບຄຳຖາມລູກຄ້າໃຫ້ກັບທຸລະກິດ SMEs ທ້ອງຖິ່ນໃນພາສາລາວທີ່ເປັນທຳມະຊາດ.

ເພື່ອແກ້ໄຂບັນຫານີ້, ການເຮັດ Fine-Tuning ດ້ວຍຊຸດຂໍ້ມູນພາສາລາວຈຶ່ງກາຍເປັນສິ່ງຈຳເປັນ. ໃນບົດຄວາມນີ້, ເຮົາຈະລົງເລິກເຖິງວິທີການກະກຽມຂໍ້ມູນໃນຮູບແບບ JSONL ແລະ ການນຳໃຊ້ Unsloth — ເຄື່ອງມືທີ່ຊ່ວຍເພີ່ມຄວາມໄວໃນການ Training ເຖິງ 2-5 ເທົ່າ ແລະ ຫຼຸດການໃຊ້ VRAM ຢ່າງມະຫາສານ, ເຊິ່ງເໝາະສຳລັບນັກພັດທະນາທີ່ມີ GPU ຈຳກັດ.

1. ການກະກຽມຂໍ້ມູນພາສາລາວ (Data Preparation ໃນຮູບແບບ JSONL)

ສຳລັບການ Instruction Fine-Tuning, ຮູບແບບ JSONL (JSON Lines) ໂດຍສະເພາະຮູບແບບ Alpaca ເປັນມາດຕະຖານທີ່ໄດ້ຮັບຄວາມນິຍົມທີ່ສຸດ. ການສ້າງຂໍ້ມູນພາສາລາວຮຽກຮ້ອງໃຫ້ເຮົາໃສ່ໃຈເລື່ອງການຕັດຄຳ (Tokenization footprint) ເພາະພາສາລາວບໍ່ມີການຍະຫວ່າງລະຫວ່າງຄຳ. ແນວໃດກໍ່ຕາມ, Tokenizer ຂອງ Gemma 4 ສາມາດຈັດການ sub-words ໄດ້ດີຂຶ້ນ, ແຕ່ເຮົາຍັງຕ້ອງກຽມ Prompt ໃຫ້ຊັດເຈນ.

ຕົວຢ່າງໂຄງສ້າງ JSONL (Alpaca Format)

ສົມມຸດເຮົາກຳລັງສ້າງ AI Assistant ສຳລັບໃຫ້ບໍລິການລູກຄ້າຂອງບໍລິສັດໂທລະຄົມມະນາຄົມໃນລາວ (Customer Service Bot):

{"instruction": "ຕອບຄຳຖາມລູກຄ້າກ່ຽວກັບການຕັ້ງຄ່າອິນເຕີເນັດມືຖືດ້ວຍຄວາມສຸພາບ", "input": "ຂ້ອຍຢາກຕັ້ງຄ່າ APN ໃໝ່ຕ້ອງເຮັດແນວໃດ?", "output": "ສະບາຍດີລູກຄ້າ, ສຳລັບການຕັ້ງຄ່າ APN ໃໝ່ ແມ່ນໃຫ້ເຂົ້າໄປທີ່ Settings > Mobile Networks > Access Point Names ແລ້ວກົດ Add ໃໝ່. ຖ້າມີຂໍ້ສົງໄສເພີ່ມເຕີມສາມາດສອບຖາມໄດ້ເລີຍເດີ້."}
{"instruction": "ໃຫ້ຄຳແນະນຳກ່ຽວກັບສະຖານທີ່ທ່ອງທ່ຽວໃນປະເທດລາວ", "input": "ຖ້າໄປປາກຊ່ອງ, ຄວນໄປທ່ຽວໃສແດ່?", "output": "ຖ້າໄປປາກຊ່ອງ ແຂວງຈຳປາສັກ, ແນະນຳໃຫ້ໄປທ່ຽວຊົມສວນກາເຟຕ່າງໆ, ນ້ຳຕົກຕາດຟານ, ແລະ ຕາດເຍືອງ ເຊິ່ງມີບັນຍາກາດເຢັນສະບາຍຕະຫຼອດປີ."}

Python Script ສຳລັບປ່ຽນ CSV ເປັນ JSONL

ໃນສະພາບແວດລ້ອມການເຮັດວຽກຕົວຈິງ, ຂໍ້ມູນຂອງທ່ານອາດຈະມາຈາກການ Export ຖານຂໍ້ມູນ Helpdesk ຂອງບໍລິສັດ ອອກມາເປັນ CSV. ນີ້ແມ່ນ Code ໃນການປ່ຽນໃຫ້ເປັນ JSONL ສຳລັບການ Training:

import pandas as pd
import json

# ອ່ານຂໍ້ມູນຈາກ CSV
df = pd.read_csv("lao_customer_service_data.csv")

# ສ້າງໄຟລ໌ JSONL
with open("lao_dataset_gemma4.jsonl", "w", encoding="utf-8") as f:
    for index, row in df.iterrows():
        entry = {
            "instruction": str(row["instruction"]),
            "input": str(row["input"]),
            "output": str(row["output"])
        }
        json.dump(entry, f, ensure_ascii=False)
        f.write("\n")
        
print("ສ້າງໄຟລ໌ JSONL ສຳເລັດແລ້ວ!")

2. ເປັນຫຍັງຕ້ອງໃຊ້ Unsloth ໃນການ Fine-Tune?

Unsloth ເປັນ Library ທີ່ຂຽນ Custom Triton Kernels ສຳລັບສະຖາປັດຕະຍະກຳຂອງ LLMs ໂດຍສະເພາະ. ສິ່ງທີ່ເຮັດໃຫ້ Unsloth ເປັນເຄື່ອງມືທີ່ Advanced Developer ຕ້ອງເລືອກໃຊ້ມີດັ່ງນີ້:

• Exact RoPE (Rotary Position Embedding) optimizations: ຊ່ວຍຫຼຸດການຄິດໄລ່ຄະນິດສາດທີ່ຊ້ຳຊ້ອນ.
• Flash Attention 2: ຖືກນຳໃຊ້ໂດຍອັດຕະໂນມັດ, ຊ່ວຍຮັບມືກັບ Context ຍາວໆ ເຊັ່ນ: ເອກະສານພາສາລາວທີ່ມີຫຼາຍພັນຄຳ.
• VRAM efficiency: ສາມາດ Fine-tune ໂມເດວລະດັບ 9B ໄດ້ເທິງ GPU ທີ່ລຸ້ນລຸ່ມ ເຊັ່ນ RTX 3090, 4090 ຫຼື ເທິງ Google Colab (T4/L4) ຜ່ານການເຮັດ QLoRA 4-bit.

3. ຂັ້ນຕອນການ Fine-Tune: ການຂຽນ Code ຕົວຈິງ

ມາລົງມືໃນການຂຽນ Code ໂດຍນຳໃຊ້ PyTorch ແລະ Unsloth. ໃຫ້ໝັ້ນໃຈວ່າທ່ານໄດ້ຕິດຕັ້ງ Unsloth ແລ້ວ (pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git").

3.1 ໂຫຼດ Model ແລະ Tokenizer

from unsloth import FastLanguageModel
import torch

max_seq_length = 2048 # ກຳນົດຄວາມຍາວຂອງ Context ເໝາະສົມກັບການຕອບຄຳຖາມທົ່ວໄປ
dtype = None # Auto detection ສຳລັບ Float16 ຫຼື Bfloat16
load_in_4bit = True # ໃຊ້ 4-bit Quantization ເພື່ອປະຢັດ RAM

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/gemma-4-9b-bnb-4bit", # ປ່ຽນຕາມລຸ້ນຂອງ Gemma 4
    max_seq_length = max_seq_length,
    dtype = dtype,
    load_in_4bit = load_in_4bit,
)

3.2 ຕັ້ງຄ່າ LoRA Adapters ສຳລັບພາສາລາວ

ສຳລັບພາສາລາວ, ເຊິ່ງເປັນພາສາທີ່ມີລັກສະນະສະເພາະ (Under-represented language ໃນມາດຕະຖານໂລກ), ການທຳການປັບຄ່າ V_Proj ແລະ Q_Proj ແມ່ນສຳຄັນ, ແຕ່ເຮົາແນະນຳໃຫ້ Target ທຸກໆ Linear Modules ເພື່ອໃຫ້ໂມເດວຈັບໂຄງສ້າງໄວຍະກອນລາວໄດ້ດີທີ່ສຸດ.

model = FastLanguageModel.get_peft_model(
    model,
    r = 16, # Rank ຂອງ LoRA matrix (16 ຫຼື 32 ເໝາະສົມກັບພາສາໃໝ່)
    target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
                      "gate_proj", "up_proj", "down_proj",],
    lora_alpha = 16,
    lora_dropout = 0, # Unsloth ແນະນຳໃຫ້ເປັນ 0 ເພື່ອຄວາມໄວ
    bias = "none",
    use_gradient_checkpointing = "unsloth", # Optimization ສຳຄັນ
    random_state = 3407,
    use_rslora = False,
)

3.3 ການ Format ຂໍ້ມູນກັບເຂົ້າໄປໃນ Prompt

ສ້າງ Formatting Function ເພື່ອນຳເອົາຂໍ້ມູນ JSONL ມາ Map ໃສ່ Prompt ທີ່ຈະຝຶກ.

lao_prompt = """ຂ້າງລຸ່ມນີ້ຄືຄຳແນະນຳທີ່ອະທິບາຍເຖິງໜ້າທີ່. ຈົ່ງຂຽນການຕອບກັບທີ່ຖືກຕ້ອງ ແລະ ເໝາະສົມເທົ່ານັ້ນ.

### ຄຳແນະນຳ:
{}

### ຂໍ້ມູນນຳເຂົ້າ:
{}

### ຄຳຕອບ:
{}"""

EOS_TOKEN = tokenizer.eos_token # ເພີ່ມ End of Sentence token

def formatting_prompts_func(examples):
    instructions = examples["instruction"]
    inputs       = examples["input"]
    outputs      = examples["output"]
    texts = []
    for instruction, input, output in zip(instructions, inputs, outputs):
        # ປະກອບ Prompt
        text = lao_prompt.format(instruction, input, output) + EOS_TOKEN
        texts.append(text)
    return { "text" : texts, }

from datasets import load_dataset
dataset = load_dataset("json", data_files="lao_dataset_gemma4.jsonl", split = "train")
dataset = dataset.map(formatting_prompts_func, batched = True)

3.4 ກຳນົດ SFTTrainer ແລະ ເລີ່ມການຝຶກ

ເລີ່ມຂະບວນການ Supervised Fine-Tuning ດ້ວຍການປັບ Hyperparameters ສຳລັບຊຸດຂໍ້ມູນຂອງເຮົາ.

from trl import SFTTrainer
from transformers import TrainingArguments

trainer = SFTTrainer(
    model = model,
    tokenizer = tokenizer,
    train_dataset = dataset,
    dataset_text_field = "text",
    max_seq_length = max_seq_length,
    dataset_num_proc = 2,
    args = TrainingArguments(
        per_device_train_batch_size = 2,
        gradient_accumulation_steps = 4,
        warmup_steps = 5,
        max_steps = 100, # ກຳນົດຕາມຂະໜາດ Dataset ຂອງທ່ານ (ຕົວຢ່າງນີ້ໃຊ້ 100 ເພື່ອທົດລອງ)
        learning_rate = 2e-4,
        fp16 = not torch.cuda.is_bf16_supported(),
        bf16 = torch.cuda.is_bf16_supported(),
        logging_steps = 10,
        optim = "adamw_8bit", # ໃຊ້ 8-bit optimizer ເພື່ອປະຢັດ Memory
        weight_decay = 0.01,
        lr_scheduler_type = "linear",
        seed = 3407,
        output_dir = "outputs",
    ),
)

# ເລີ່ມຕົ້ນການ Training!
trainer_stats = trainer.train()

3.5 ການບັນທຶກ ແລະ ສົ່ງອອກ Model

ຫຼັງຈາກຝຶກສຳເລັດ, ທ່ານສາມາດບັນທຶກສະເພາະ LoRA Adapter ຫຼື ແປງເປັນຮູບແບບ GGUF ເພື່ອນຳໄປໃຊ້ໃນ Ollama ສຳລັບ Hosting ຢູ່ Server ສ່ວນຕົວພາຍໃນອົງກອນ (On-premise deployment ສຳລັບ SMEs).

# ບັນທຶກ LoRA Adapter
model.save_pretrained("gemma4-lao-lora")
tokenizer.save_pretrained("gemma4-lao-lora")

# ຖ້າຕ້ອງການ Export ເປັນ GGUF ສໍາລັບ Ollama (q4_k_m)
model.save_pretrained_gguf("gemma4-lao-gguf", tokenizer, quantization_method = "q4_k_m")

ຂໍ້ຄວນລະວັງ (Advanced Considerations)

1. Tokenizer Fallback: ເນື່ອງຈາກພາສາລາວບໍ່ແມ່ນພາສາຫຼັກທີ່ໃຊ້ໃນການ Pre-train ຂອງ Gemma, ບາງຄັ້ງ Tokenizer ອາດຈະແຍກຄຳລາວອອກເປັນ Byte-level (Byte Fallback). ຖ້າທ່ານມີ Dataset ມະຫາສານ, ການເຮັດ Vocabulary Expansion (ການເພີ່ມຄຳສັບເຂົ້າໄປໃນ Tokenizer) ກ່ອນການ Fine-tune ອາດຈະຈຳເປັນ. ແຕ່ສຳລັບການເຮັດ Instruction tuning ທົ່ວໄປ, ວິທີການທີ່ອະທິບາຍຂ້າງເທິງແມ່ນພຽງພໍໃຫ້ Model ເຮັດວຽກໄດ້ແລ້ວ.
2. Dataset Quality > Quantity: ການຮັກສາຄຳຕອບໃຫ້ມີປະໂຫຍກທີ່ຫຼາກຫຼາຍ, ການສະກົດຄຳພາສາລາວທີ່ຖືກຕ້ອງ (ຫຼີກລ່ຽງພາສາວິບັດ ຫຼື ຄຳຜິດທີ່ພົບທົ່ວໄປໃນ Social Media ຖ້າເຮັດແອັບທຸລະກິດ) ຈະຊ່ວຍໃຫ້ Loss Function ຫຼຸດລົງຢ່າງມີປະສິດທິຜົນກວ່າ.

ໜ້າທີ່ຕໍ່ໄປຂອງທ່ານ

ການນຳໃຊ້ Unsloth ຮ່ວມກັບ Gemma 4 ເຮັດໃຫ້ການພັດທະນາ AI ສຳລັບພາສາລາວບໍ່ແມ່ນເລື່ອງໄກຕົວ ຫຼື ຕ້ອງໃຊ້ Supercomputer ອີກຕໍ່ໄປ. ດ້ວຍ Data ທີ່ເໝາະສົມ ເຊັ່ນ: ຖານຂໍ້ມູນຈິງຈາກໜ້າວຽກຂອງທ່ານ, ບວກກັບການຂຽນ Code Fine-tune ທີ່ເຮົາໄດ້ນຳສະເໜີ, ທ່ານສາມາດສ້າງ Custom AI ທີ່ເຂົ້າໃຈບໍລິບົດຂອງສັງຄົມ ແລະ ທຸລະກິດລາວໄດ້ຢ່າງເລິກເຊິ່ງ.

ຮຽນຮູ້, ທົດລອງ, ແລະ ນຳເອົາເຕັກໂນໂລຊີ AI ມາປັບໃຊ້ເພື່ອຂັບເຄື່ອນນະວັດຕະກຳໃໝ່ໆໃນປະເທດລາວນຳກັນ!