เจาะลึก SmolLM3: โมเดลภาษาขนาดเล็กประสิทธิภาพสูง พร้อมวิธีสร้างระบบ Support Ticket อัจฉริยะ

เล็กแต่ทรงพลัง

การรันโมเดลขนาด 70B ในสภาพแวดล้อมการใช้งานจริง (production) อาจมีราคาสูง ประมวลผลช้า และเกินความจำเป็นสำหรับงานหลายประเภท หากคุณกำลังสร้างระบบเฉพาะเจาะจง เช่น ตัวจำแนกประเภทเอกสาร หรือระบบตอบกลับลูกค้าหลายภาษา โมเดลขนาด 3B ที่ผ่านการฝึกฝนมาอย่างดีสามารถให้ประสิทธิภาพทัดเทียมหรือดีกว่าโมเดล 70B ในงานเฉพาะทางด้วยค่าใช้จ่ายเพียงเล็กน้อย ที่สำคัญคือโมเดล 3B สามารถรันบน GPU ระดับผู้บริโภคเพียงตัวเดียว โหลดเสร็จในไม่กี่วินาที และไม่มีค่าใช้จ่ายต่อ token

นี่คือจุดเด่นของโมเดลภาษาขนาดเล็ก (SLMs) โดยบทความนี้จะใช้ SmolLM3 โมเดลเรือธงขนาด 3B จาก Hugging Face ที่เปิดตัวเมื่อวันที่ 8 กรกฎาคม 2025 เป็นแกนหลัก SmolLM3 ได้รับการฝึกด้วยข้อมูลถึง 11.2 ล้านล้าน token รองรับ context window ขนาด 128k มีระบบการให้เหตุผลแบบสองโหมด (dual-mode reasoning) รองรับการเรียกใช้เครื่องมือ (tool calling) และใช้งานได้ถึง 6 ภาษา ภายใต้สัญญาอนุญาต Apache 2.0

เราจะนำเสนอผ่านโปรเจกต์ "ระบบส่งต่อตั๋วสนับสนุนลูกค้าหลายภาษา" (Multilingual customer support ticket router) ที่สามารถจำแนกหมวดหมู่ตั๋ว ตรวจจับภาษา สร้างคำตอบ และติดธงงานที่มีความเชื่อมั่นต่ำเพื่อให้มนุษย์ตรวจสอบ เมื่ออ่านจบคุณจะมีระบบที่พร้อมนำไปปรับใช้กับธุรกิจของคุณเองได้ทันที

ทำไมโมเดลภาษาขนาดเล็กถึงน่าจับตามอง

การยึดติดกับจำนวนพารามิเตอร์อาจนำไปสู่ความเข้าใจผิด เพราะหลังจากจุดหนึ่ง คุณภาพของข้อมูลและหลักสูตรการฝึกฝน (training curriculum) จะมีความสำคัญมากกว่าขนาด งานวิจัยจาก SmolLM2 paper (arxiv, February 2025) ชี้ให้เห็นว่าในระดับ 1B-3B ข้อมูลที่คัดสรรมาอย่างดีให้ผลลัพธ์ดีกว่าการเพิ่มพารามิเตอร์แบบสุ่มสี่สุ่มห้า

SmolLM3 ก้าวไปอีกขั้นด้วยการใช้ข้อมูลฝึกฝน 11.2 ล้านล้านชุด ครอบคลุมทั้งเว็บ โค้ด คณิตศาสตร์ และการให้เหตุผล ผลลัพธ์คือการทำคะแนนบนเกณฑ์มาตรฐาน zero-shot ได้ดีกว่า Llama-3.2-3B และ Qwen2.5-3B ในหลายด้าน เช่น คะแนน IFEval ที่ทำได้ 76.7 (สูงกว่า Qwen3-4B) และคะแนนการเรียกใช้เครื่องมือที่ 92.3 ซึ่งเทียบเท่า Llama รุ่นปรับจูนเฉพาะทาง

อย่างไรก็ตาม SLM ยังคงมีข้อจำกัดในงานที่ต้องใช้ความรู้รอบตัวเชิงลึก การให้เหตุผลที่ซับซ้อนหลายชั้น หรือการเขียนเชิงสร้างสรรค์ที่มีบริบททางประวัติศาสตร์ยาวๆ ซึ่งงานเหล่านี้ยังจำเป็นต้องใช้โมเดลขนาดใหญ่ แต่สำหรับงานเฉพาะโดเมน SLM ที่ผ่านการ fine-tuning จะให้ผลลัพธ์ที่ยอดเยี่ยมโดยลดค่าใช้จ่ายลงถึง 10 เท่า

ปัจจุบัน คอลเลกชัน Hugging Face SLM ประกอบด้วย SmolLM3-3B (รุ่นปรับจูนตามคำสั่ง), SmolLM3-3B-Base (รุ่นก่อนปรับจูน), SmolLM2-1.7B และ SmolVLM (รองรับภาพ) โดย SmolLM3-3B เป็นตัวเลือกที่สมดุลที่สุดสำหรับโปรเจกต์ใหม่ๆ ในขณะนี้

ทำความเข้าใจสถาปัตยกรรมของ SmolLM3

SmolLM3 เป็น decoder-only transformer ที่มีการปรับปรุงสถาปัตยกรรม 3 ประเด็นหลักที่ส่งผลต่อการใช้งานโดยตรง:

1. Grouped Query Attention (GQA): ช่วยลดหน่วยความจำ KV cache ลงประมาณ 25% โดยไม่เสียความแม่นยำ สิ่งนี้สำคัญมากในเวลา inference เพราะช่วยให้ประมวลผลข้อความยาวๆ หรือรับงานจำนวนมากได้บนฮาร์ดแวร์เดิม

2. NoPE (No Positional Encoding ในบางเลเยอร์): มีการถอด rotary positional encoding (RoPE) ออกจากบางเลเยอร์ตามแนวทางจากเอกสาร "RoPE to NoRoPE and Back Again" ช่วยให้โมเดลจัดการบริบทที่ยาวมากได้ดีขึ้นโดยไม่เกิดการเสื่อมสภาพของข้อมูลตำแหน่ง

3. Dual-mode reasoning: รองรับโหมด think (แสดงลำดับความคิดในแท็ก <think>) และ no_think (ตอบโดยตรง) ในโมเดลเดียว ผู้ใช้สามารถเลือกโหมดได้ตามความเหมาะสมของงานผ่าน system prompt โดยไม่ต้องเปลี่ยนรุ่นโมเดล

การตั้งค่าสภาพแวดล้อม

ข้อกำหนดฮาร์ดแวร์ขั้นต่ำ:

สำหรับการใช้งานผ่าน CPU สามารถทำได้แต่จะช้าลง 3-8 เท่า ส่วนการ fine-tuning แนะนำให้ใช้ GPU เสมอ

การติดตั้ง Python และแพ็คเกจ:

# ต้องการ Python 3.10 หรือใหม่กว่า
python --version
 
# สร้างและเปิดใช้งาน virtual environment
python -m venv smollm-env
source smollm-env/bin/activate       # macOS / Linux
smollm-env\Scripts\activate          # Windows
 
# ติดตั้ง dependencies ทั้งหมด
pip install \
  "transformers>=4.53.0" \
  "torch>=2.3.0" \
  "accelerate>=0.30.0" \
  "bitsandbytes>=0.43.0" \
  "sentencepiece" \
  "trl>=0.9.0" \
  "peft>=0.11.0" \
  "datasets>=2.19.0"

หมายเหตุ: ต้องใช้ transformers>=4.53.0 ขึ้นไปเพื่อให้รองรับสถาปัตยกรรมของ SmolLM3

สคริปต์ตรวจจับอุปกรณ์ (device_check.py):

# device_check.py
import torch
 
def detect_device():
    if torch.cuda.is_available():
        vram_gb = torch.cuda.get_device_properties(0).total_memory / 1e9
        print(f"ตรวจพบ CUDA GPU: {torch.cuda.get_device_name(0)} ({vram_gb:.1f} GB VRAM)")
        return "cuda", torch.bfloat16, {"device_map": "auto", "torch_dtype": torch.bfloat16}
    elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
        print("ตรวจพบ Apple Silicon MPS")
        return "mps", torch.float16, {"device_map": "mps", "torch_dtype": torch.float16}
    else:
        print("ไม่พบ GPU -- รันบน CPU")
        return "cpu", torch.float32, {"device_map": "cpu", "torch_dtype": torch.float32}
 
if __name__ == "__main__":
    device, dtype, kwargs = detect_device()
    print(f"Device : {device}\nDtype  : {dtype}\nKwargs : {kwargs}")

การโหลด SmolLM3 และรัน Inference ครั้งแรก

นี่คือตัวอย่างโค้ดสำหรับโหลดโมเดลและทดสอบการเปรียบเทียบระหว่างโหมด think และ no_think โดยมีการกรองแท็กความคิดออกเพื่อให้ได้คำตอบสุดท้ายที่สะอาด

# first_inference.py
import re
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
 
MODEL_ID = "HuggingFaceTB/SmolLM3-3B"
 
tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID, torch_dtype=torch.bfloat16, device_map="auto"
)
model.eval()
 
def generate(messages, max_new_tokens=512):
    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
    inputs = tokenizer(text, return_tensors="pt").to(model.device)
    with torch.no_grad():
        output_ids = model.generate(**inputs, max_new_tokens=max_new_tokens, temperature=0.6, top_p=0.95, do_sample=True)
    new_tokens = output_ids[0][inputs["input_ids"].shape[-1]:]
    raw = tokenizer.decode(new_tokens, skip_special_tokens=True)
    return re.sub(r"<think>.*?</think>", "", raw, flags=re.DOTALL).strip()
 
prompt = "ลูกค้าถูกเรียกเก็บเงินสองครั้งสำหรับคำสั่งซื้อเดียวกัน ฝ่ายสนับสนุนควรทำสามขั้นตอนที่เป็นรูปธรรมอะไรบ้าง?"
 
print("\n── โหมด no_think ──")
print(generate([{"role": "system", "content": "/no_think"}, {"role": "user", "content": prompt}], 256))
 
print("\n── โหมด think ──")
print(generate([{"role": "system", "content": "/think"}, {"role": "user", "content": prompt}], 512))

โหมด think จะให้คำตอบที่มีโครงสร้างชัดเจนผ่านการลำดับความคิด ขณะที่ no_think จะให้ผลลัพธ์ที่รวดเร็วกว่า ซึ่งเหมาะสำหรับงานที่ไม่ซับซ้อน

การสร้าง Multilingual Support Ticket Router

เราจะสร้างคลาส TicketRouter เพื่อจัดการตั๋วจากภาษาต่างๆ (อังกฤษ, ฝรั่งเศส, สเปน, เยอรมัน, อิตาลี, โปรตุเกส) โดยระบบจะทำงานแบบออฟไลน์ 100% เพื่อความปลอดภัยของข้อมูลลูกค้า

# ticket_router.py (ส่วนย่อ)
import json, re, torch
from transformers import AutoTokenizer, AutoModelForCausalLM
 
SYSTEM_PROMPT = """คุณคือผู้ส่งต่อตั๋วสนับสนุนลูกค้าหลายภาษา ตอบกลับเฉพาะ JSON: 
{"category": "", "confidence": <0.0-1.0>, "reply": ""}"""
 
class TicketRouter:
    def __init__(self, model_id="HuggingFaceTB/SmolLM3-3B"):
        self.tokenizer = AutoTokenizer.from_pretrained(model_id)
        self.model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.bfloat16, device_map="auto")
        self.model.eval()
 
def route(self, ticket):
        messages = [{"role": "system", "content": SYSTEM_PROMPT}, {"role": "user", "content": ticket}]
        text = self.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True, enable_thinking=False)
        inputs = self.tokenizer(text, return_tensors="pt").to(self.model.device)
        with torch.no_grad():
            output_ids = self.model.generate(**inputs, max_new_tokens=256, temperature=0.3, do_sample=True)
        raw = self.tokenizer.decode(output_ids[0][inputs["input_ids"].shape[-1]:], skip_special_tokens=True).strip()
        match = re.search(r"\{.*?\}", raw, re.DOTALL)
        return json.loads(match.group()) if match else {"category": "general", "confidence": 0.0, "reply": raw}

การตั้งค่าเกณฑ์ความเชื่อมั่น (เช่น 0.70) ช่วยให้ระบบสามารถคัดกรองตั๋วที่กำกวมส่งต่อให้พนักงานที่เป็นมนุษย์ตรวจสอบได้ ช่วยลดความผิดพลาดในการบริการลูกค้า

การเพิ่ม Tool Calling ให้กับ SmolLM3

หากลูกค้าถามถึงสถานะคำสั่งซื้อ โมเดลจำเป็นต้องดึงข้อมูลจากฐานข้อมูลภายนอก SmolLM3 สามารถทำสิ่งนี้ได้ผ่านระบบ Tool Calling โดยการรับ JSON Schema และส่งออกบล็อก <tool_call> เพื่อเรียกใช้ฟังก์ชันจริง

# tool_calling.py (ส่วนโครงสร้าง)
TOOLS = [{
    "name": "lookup_order_status",
    "description": "ค้นหาสถานะคำสั่งซื้อจากหมายเลข ORD-XXXXXX",
    "parameters": {
        "type": "object",
        "properties": {"order_id": {"type": "string"}},
        "required": ["order_id"]
    }
}]

โมเดลจะตัดสินใจเรียกใช้เครื่องมือเฉพาะเมื่อจำเป็นเท่านั้น เช่น เมื่อลูกค้าถามว่า "คำสั่งซื้อ ORD-4821 อยู่ที่ไหน?" ช่วยให้คำตอบมีความแม่นยำและอ้างอิงข้อมูลจริงได้

การ Fine-Tuning SmolLM3 ด้วยข้อมูลเฉพาะโดเมน

การปรับจูนโมเดล 3B สามารถทำได้บน GPU ทั่วไปในเวลาเพียงไม่กี่นาที โดยใช้เทคนิค LoRA เพื่อฝึกพารามิเตอร์เพียงเล็กน้อย (น้อยกว่า 1%) แต่ให้ผลลัพธ์ที่ตรงใจธุรกิจมากขึ้น

# finetune.py (ส่วนการตั้งค่า)
from peft import LoraConfig, get_peft_model
from trl import SFTTrainer, SFTConfig
 
lora_config = LoraConfig(
    r=16, lora_alpha=32, target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
    task_type="CAUSAL_LM"
)
model = get_peft_model(model, lora_config)
 
sft_config = SFTConfig(
    output_dir="./smollm3-ticket-router", num_train_epochs=3,
    per_device_train_batch_size=2, learning_rate=2e-4, bf16=True
)
trainer = SFTTrainer(model=model, tokenizer=tokenizer, train_dataset=dataset, args=sft_config)
trainer.train()

การ Fine-tuning จะช่วยให้โมเดลเข้าใจสไตล์การตอบและคำศัพท์เฉพาะของบริษัทได้ดีกว่าการใช้แค่ Prompt Engineering เพียงอย่างเดียว

บทสรุป

SmolLM3 พิสูจน์ให้เห็นว่าขนาดพารามิเตอร์ไม่ใช่ทุกอย่าง ด้วยการเลือกใช้สถาปัตยกรรมที่ชาญฉลาดและการฝึกฝนที่มีคุณภาพ โมเดลขนาด 3B จึงสามารถรองรับงานในระดับ Production ได้อย่างดีเยี่ยม ทั้งในด้านความเร็ว ความประหยัด และความยืดหยุ่น

แหล่งข้อมูลเพิ่มเติม:

• SmolLM3-3B model card
• SmolLM GitHub repository
• TRL Library
• PEFT Library