[LLM 1/10] Continue Pretraining: สอนความรู้ใหม่ให้ LLM ภาษาไทย

โมเดลภาษาขนาดใหญ่ที่เก่งภาษาไทยระดับหนึ่ง มักจะ "ไม่รู้จัก" ความรู้เฉพาะทางขององค์กรคุณเลย — ไม่รู้ระเบียบราชการไทย ไม่รู้ศัพท์เฉพาะในวงการของคุณ ไม่รู้เอกสารภายในบริษัท บทความนี้จะสอนวิธีแก้ที่ตรงที่สุด คือ Continue Pretraining (CPT) ตั้งแต่สมการ ไปจนถึงโค้ดที่รันจบได้จริงบน Colab ฟรีภายในราว 15 นาที

1. ปัญหา (Problem statement)​

ลองนึกภาพว่าคุณเอา Qwen3-0.6B มาถามว่า "ตามระเบียบสำนักนายกรัฐมนตรี การจัดซื้อจัดจ้างโดยวิธีเฉพาะเจาะจงทำได้เมื่อใด" โมเดลจะตอบได้อย่างมั่นใจ และตอบผิด เพราะมันไม่เคยเห็นเอกสารราชการไทยมากพอ

หลายคนพยายามแก้ด้วยการทำ fine-tuning ด้วยคู่ถาม-ตอบไม่กี่พันตัวอย่าง แล้วพบว่าไม่ได้ผล เหตุผลคือ SFT สอน "รูปแบบการตอบ" ไม่ได้สอน "ความรู้" ถ้าโมเดลไม่เคยมีความรู้นั้นอยู่ในน้ำหนัก (weights) การสอนให้มันตอบด้วยน้ำเสียงที่ถูกต้องก็แค่ทำให้มันมั่นใจเวลาโกหกเท่านั้น

ความรู้ใหม่เข้าสู่โมเดลได้ 3 ทาง และเลือกผิดคือสาเหตุที่โปรเจกต์ LLM ส่วนใหญ่ล้มเหลว:

บทความนี้คือทางที่สอง

2. เราจะทำอะไร (Solution)​

เราจะเอาโมเดล base (ยังไม่ผ่าน instruction tuning) มาเทรนต่อด้วย objective เดียวกับตอน pretrain เป๊ะ ๆ คือทายคำถัดไป บนข้อความดิบภาษาไทยในโดเมนที่เราสนใจ ไม่มี label ไม่มีคู่ถาม-ตอบ มีแค่ข้อความล้วน ๆ

แต่หัวใจของบทความนี้ไม่ใช่ "เทรนแล้วเก่งขึ้น" — มันคือสิ่งที่แลกมา:

ปรากฏการณ์ที่โมเดลลืมสิ่งที่เคยทำได้ เรียกว่า catastrophic forgetting เราจะไม่พูดลอย ๆ แต่จะวัดมันออกมาเป็นตัวเลข แล้วหาจุดที่ยอมรับได้

3. สมการ (Equation)​

3.1 Objective ของ CPT​

• $x_t$ = token ตำแหน่งที่ $t$
• $x_{<t}$ = token ทั้งหมดก่อนหน้า
• $p_\theta$ = ความน่าจะเป็นที่โมเดลทำนาย

สมการนี้เหมือนกับตอน pretrain ทุกประการ สิ่งเดียวที่เปลี่ยนคือข้อมูล นี่คือเหตุผลที่ CPT ไม่ต้องการ label — ข้อความเองคือเฉลย

3.2 Perplexity: หน่วยวัดของเรา​

แปลเป็นภาษาคน: "โดยเฉลี่ยแล้ว โมเดลกำลังลังเลอยู่ระหว่างกี่ตัวเลือก" PPL = 20 คือลังเลประมาณ 20 คำ, PPL = 5 คือมั่นใจกว่ามาก ยิ่งต่ำยิ่งดี

3.3 สมการที่สำคัญที่สุดในบทนี้ — Replay Mixing​

$\lambda$ คือสัดส่วนข้อมูลโดเมนในแต่ละ batch

• $\lambda = 1.0$ → ข้อมูลโดเมนล้วน → เก่งโดเมนเร็วที่สุด และลืมเร็วที่สุด
• $\lambda = 0.5$ → ผสมครึ่งต่อครึ่ง → ช้ากว่าแต่ลืมน้อยกว่ามาก

อย่า hardcode ค่านี้ จงกวาดหาค่ามัน แล้วเลือกจุดที่คุณยอมรับได้

4. เห็นภาพสมการ (Visualize)​

Perplexity บอกอะไรเรากันแน่​

กราฟขวาคือสิ่งที่คนมักพลาด: ถ้ามีคนบอกว่า "ลด perplexity ได้ 5 หน่วย" แล้วไม่บอกว่าเริ่มจากเท่าไหร่ ประโยคนั้นแทบไม่มีความหมาย เพราะ 80 → 75 คือดีขึ้น 6% แต่ 10 → 5 คือดีขึ้น 50%

การแลกเปลี่ยนที่ replay ratio ควบคุม​

5. เตรียมสภาพแวดล้อม (Environment)​

เปิด Colab เลือก Runtime → Change runtime type → T4 GPU (ใช้แผนฟรีได้)

torch_dtype=torch.float16      # ไม่ใช่ bfloat16
attn_implementation="sdpa"     # ไม่ใช่ flash_attention_2
fp16=True                      # ใน TrainingArguments (ไม่ใช่ bf16=True)

เซลล์แรกของทุกโน้ตบุ๊กในซีรีส์จะพิมพ์บรรทัดนี้ออกมาให้เห็นกับตา:

cap = torch.cuda.get_device_capability(0)
print("compute capability:", cap)                    # T4 = (7, 5)
print("native bf16:", cap[0] >= 8)                   # T4 -> False
print("torch says   :", torch.cuda.is_bf16_supported())  # T4 -> True (นับ emulation!)

งบ VRAM มีเท่าไหร่ และหมดไปกับอะไร​

สังเกตว่า optimizer state กินที่มากกว่าตัวโมเดลเอง — Adam เก็บ $m$ และ $v$ อย่างละหนึ่งชุดเท่าจำนวนพารามิเตอร์ การเปลี่ยนไปใช้ adamw_bnb_8bit ประหยัดได้ 3.3 GB ซึ่งแปลว่าคุณเพิ่ม batch size หรือความยาว sequence ได้อีกมาก

ลองเล่นกับงบ VRAM ด้วยตัวเอง — ปรับค่าแล้วดูว่าเมื่อไหร่จะ OOM:

6. เตรียมข้อมูล (Data)​

เราใช้ pythainlp/thaigov-v2-corpus-22032023 — คลังข่าวและเอกสารราชการไทย (สาธารณสมบัติ) เป็นตัวแทนของ "ความรู้เฉพาะทางที่โมเดลไม่เคยเห็นมากพอ"

และใช้ข้อความภาษาไทยทั่วไปอีกชุดเป็น replay data เพื่อกันการลืม

from datasets import load_dataset

domain = load_dataset("pythainlp/thaigov-v2-corpus-22032023", split="train")
domain = domain.shuffle(seed=42).select(range(8000))

Packing: อย่าปล่อยให้ padding กินงบ​

ถ้าเอาแต่ละเอกสารมา pad ให้ยาวเท่ากัน คุณจะเสีย compute ไปกับ <pad> มหาศาล วิธีที่ถูกคือ ต่อทุกเอกสารเข้าด้วยกันแล้วหั่นเป็นบล็อกยาว 512 token เท่า ๆ กัน

def pack(examples, block_size=512):
    ids = []
    for text in examples["context"]:
        ids.extend(tokenizer(text + tokenizer.eos_token).input_ids)
    n = (len(ids) // block_size) * block_size
    return {"input_ids": [ids[i:i+block_size] for i in range(0, n, block_size)]}

7. โค้ดหลัก (Main code)​

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-0.6B-Base",           # base ไม่ใช่ instruct — CPT ต้องเริ่มจาก base
    torch_dtype=torch.float16,        # T4 ไม่มี bf16
    attn_implementation="sdpa",       # T4 ไม่มี FlashAttention-2
).cuda()

model = model.float()                 # ต้อง cast เป็น fp32 ก่อนเทรน — ดูกล่องด้านล่าง

args = TrainingArguments(
    output_dir="cpt-out",
    per_device_train_batch_size=2,
    gradient_accumulation_steps=8,    # effective batch = 16
    num_train_epochs=1,
    learning_rate=2e-5,               # ต่ำกว่า SFT 10 เท่า — ดูคำเตือนด้านล่าง
    lr_scheduler_type="cosine",
    warmup_steps=50,
    optim="adamw_bnb_8bit",           # ประหยัด 3.3 GB
    gradient_checkpointing=True,
    max_grad_norm=1.0,                # กัน fp16 ระเบิด
    fp16=True,                        # ไม่ใช่ bf16
    logging_steps=10,
)

ValueError: Attempting to unscale FP16 gradients.

8. ผลลัพธ์ (Results)​

โน้ตบุ๊กจะวัด 3 อย่างก่อนและหลังเทรน แล้วเขียนลง results.json:

1. Domain held-out PPL — ควรลดลงชัดเจน (นี่คือสิ่งที่เราจ่ายเงินซื้อ)
2. General held-out PPL — ควรเพิ่มขึ้นบ้าง (นี่คือราคาที่จ่าย)
3. TH-KNOW accuracy จากชุดวัด KobEval-TH พร้อม Wilson 95% CI

9. เปรียบเทียบ (Comparison)​

โน้ตบุ๊กเทรน 3 แบบบนข้อมูลชุดเดียวกัน เพื่อให้เห็นการแลกเปลี่ยนเป็นตัวเลข:

อ่านตารางนี้ให้ออกคือหัวใจของบทนี้:

• λ = 1.0 ชนะ domain PPL (4.07 ต่ำสุด) แต่ general PPL แย่ลง จาก 5.88 เป็น 6.72 — นี่คือ catastrophic forgetting ที่วัดออกมาเป็นตัวเลขได้จริง ไม่ใช่คำเล่าลือ
• λ = 0.5 ยอมเสีย domain นิดหน่อย (4.29) แต่ general กลับดีขึ้น เป็น 4.98 — replay ไม่ได้แค่กันลืม มันช่วยให้โมเดลอ่านภาษาไทยทั่วไปดีขึ้นด้วย

10. สรุป (Summary)​

• CPT ใส่ความรู้เข้าไปในน้ำหนัก ด้วย objective เดียวกับ pretraining ไม่ต้องมี label
• มันคือการแลกเปลี่ยนเสมอ ความแม่นในโดเมนแลกมาด้วยความสามารถทั่วไปที่หายไป
• replay ratio $\lambda$ คือปุ่มควบคุมอัตราแลกเปลี่ยน — กวาดหาค่า อย่าเดา
• learning rate ต่ำ ๆ คือเส้นแบ่งระหว่าง CPT กับการทำลายโมเดล
• ทุกตัวเลขต้องมาพร้อม confidence interval

บทต่อไป: SFT และ LoRA — เมื่อโมเดลมีความรู้แล้ว เราจะสอนให้มันตอบอย่างไร และทำไมการเทรนแค่ 1.7% ของพารามิเตอร์ถึงเกือบดีเท่าเทรนทั้งหมด

อ้างอิง (References)​

1. Gururangan et al. (2020). Don't Stop Pretraining: Adapt Language Models to Domains and Tasks — ต้นตำรับของ domain-adaptive pretraining ที่บทนี้ทำตาม
2. Ibrahim et al. (2024). Simple and Scalable Strategies to Continually Pre-train Large Language Models — กลยุทธ์ replay และ LR ที่ทำให้ CPT ไม่ทำลายโมเดล
3. Gupta et al. (2023). Continual Pre-Training of Large Language Models: How to (re)warm your model? — ทำไม learning rate warmup ถึงสำคัญมากตอนเทรนต่อ
4. Luo et al. (2023). An Empirical Study of Catastrophic Forgetting in Large Language Models During Continual Fine-tuning — การวัด catastrophic forgetting อย่างเป็นระบบ
5. Kaplan et al. (2020). Scaling Laws for Neural Language Models — scaling laws -- ที่มาของคำว่า "ข้อมูล 8,000 ชิ้นน้อยเกินไป"
6. Hoffmann et al. (2022). Training Compute-Optimal Large Language Models — Chinchilla: สัดส่วนข้อมูลต่อพารามิเตอร์ที่เหมาะสม
7. Yuenyong et al. (2025). OpenThaiGPT 1.6 and R1: Thai-Centric Open Source and Reasoning Large Language Models — CPT ภาษาไทยระดับจริง เทียบกับสเกลของบทนี้
8. Lowphansirikul et al. (2021). WangchanBERTa: Pretraining transformer-based Thai Language Models — โมเดลภาษาไทยรุ่นบุกเบิกและวิธีเตรียมคอร์ปัสไทย

บทความ โค้ด และโน้ตบุ๊กในซีรีส์นี้เผยแพร่ภายใต้สัญญาอนุญาต CC BY-NC-SA 4.0 — นำไปใช้และดัดแปลงต่อได้ โดยอ้างอิงที่มา ไม่ใช้เพื่อการค้า และเผยแพร่ต่อด้วยสัญญาเดียวกัน (โมเดลและชุดข้อมูลของบุคคลที่สามที่อ้างถึง ยังคงใช้สัญญาของเจ้าของเดิม)