เทคนิคการเตรียมและทำความสะอาดข้อมูลสำหรับ Fine-tuning โมเดล AI

บทนำ: ทำไมข้อมูลถึงสำคัญมาก

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

ขั้นตอนที่ 1: ทำความรู้จักรูปแบบข้อมูลสำหรับ Fine-tuning

ก่อนเริ่มต้น เราต้องเข้าใจก่อนว่าโมเดลต้องการข้อมูลรูปแบบใด สำหรับการ Fine-tune ผ่าน API โดยทั่วไปจะใช้รูปแบบ JSONL ที่มีโครงสร้างดังนี้

{
  "messages": [
    {"role": "system", "content": "คุณคือผู้ช่วยตอบคำถามเกี่ยวกับสูตรอาหาร"},
    {"role": "user", "content": "วิธีทำส้มตำใส่อะไรบ้าง"},
    {"role": "assistant", "content": "ส้มตำใส่มะละกอดิบ มะเขือเทศ พริก กระเทียม ถั่วฝักยาว ปลาร้า น้ำปลา และมะนาว"}
  ]
}
{
  "messages": [
    {"role": "system", "content": "คุณคือผู้ช่วยตอบคำถามเกี่ยวกับสูตรอาหาร"},
    {"role": "user", "content": "อยากทำต้มยำกุ้งต้องใช้เครื่องสมุนไพรอะไร"},
    {"role": "assistant", "content": "ต้มยำกุ้งใช้ตะไคร้ ข่า มะกรูดใบ พริกเหลือง ซอสน้ำปลา น้ำมะขามเปียก และหอมแดง"}
  ]
}

แต่ละบรรทัดคือหนึ่งตัวอย่างการสนทนา โดยมี 3 ส่วนหลักคือ system (บทบาทของ AI), user (คำถามจากผู้ใช้), และ assistant (คำตอบที่ถูกต้อง)

ขั้นตอนที่ 2: แหล่งรวบรวมข้อมูลดิบ

มีหลายช่องทางในการได้มาซึ่งข้อมูลดิบ ขึ้นอยู่กับงานของเรา สำหรับผู้เริ่มต้น ผมแนะนำให้เริ่มจากการสร้างข้อมูลเองโดยใช้ LLM ช่วย เพราะควบคุมคุณภาพได้ง่าย วิธีนี้เรียกว่า Self-Instruct โดยใช้โมเดลที่มีอยู่แล้วช่วยสร้างตัวอย่างเพิ่มเติม

import requests
import json

ส่งคำขอไปยัง HolySheep API เพื่อสร้างตัวอย่างข้อมูลฝึก
url = "https://api.holysheep.ai/v1/chat/completions"
headers = {
    "Authorization": "Bearer YOUR_HOLYSHEEP_API_KEY",
    "Content-Type": "application/json"
}

data = {
    "model": "gpt-4.1",
    "messages": [
        {
            "role": "user", 
            "content": """สร้างตัวอย่างคู่คำถาม-คำตอบ 5 ชุด 
            เกี่ยวกับการใช้งานโปรแกรม Excel 
            โดยเขียนในรูปแบบ JSON ดังนี้
            {"question": "...", "answer": "..."}"""
        }
    ]
}

response = requests.post(url, headers=headers, json=data)
result = response.json()
print(result['choices'][0]['message']['content'])

จากประสบการณ์ของผม การใช้ HolySheep AI ช่วยประหยัดค่าใช้จ่ายได้มาก เพราะราคาถูกกว่าบริการอื่นถึง 85% โดยราคา DeepSeek V3.2 อยู่ที่ $0.42 ต่อล้านตัวอักษร เหมาะสำหรับการสร้างข้อมูลจำนวนมาก หากสนใจสามารถ สมัครที่นี่ เพื่อรับเครดิตฟรีเมื่อลงทะเบียน

ขั้นตอนที่ 3: การทำความสะอาดข้อมูลเบื้องต้น

เมื่อได้ข้อมูลดิบมาแล้ว ต้องผ่านการทำความสะอาดหลายขั้นตอนก่อนจะนำไปฝึกโมเดล

import json

def clean_text(text):
    """ฟังก์ชันทำความสะอาดข้อความ"""
    # ลบช่องว่างมากเกินไป
    text = ' '.join(text.split())
    
    # ลบอักขระพิเศษที่ไม่จำเป็น
    special_chars = ['\n', '\t', '\r', '\\n', '\\t']
    for char in special_chars:
        text = text.replace(char, ' ')
    
    # ลบ URL
    import re
    text = re.sub(r'http\S+', '', text)
    
    return text.strip()

def validate_data_format(data):
    """ตรวจสอบว่าข้อมูลมีรูปแบบถูกต้องหรือไม่"""
    required_keys = ['messages']
    
    if not all(key in data for key in required_keys):
        return False
    
    messages = data['messages']
    if len(messages) < 2:
        return False
    
    valid_roles = ['system', 'user', 'assistant']
    for msg in messages:
        if 'role' not in msg or 'content' not in msg:
            return False
        if msg['role'] not in valid_roles:
            return False
        if not isinstance(msg['content'], str) or len(msg['content']) == 0:
            return False
    
    return True

ทดสอบกับข้อมูลตัวอย่าง
sample = {
    "messages": [
        {"role": "user", "content": "  สวัสดี    ครับ  "},
        {"role": "assistant", "content": "ไง    สบายดีไหม"}
    ]
}

sample['messages'][0]['content'] = clean_text(sample['messages'][0]['content'])
print(f"หลังทำความสะอาด: {sample['messages'][0]['content']}")
print(f"รูปแบบถูกต้อง: {validate_data_format(sample)}")

ขั้นตอนที่ 4: กรองข้อมูลซ้ำและไม่เหมาะสม

ข้อมูลที่มีคำถามหรือคำตอบซ้ำกันจะทำให้โมเดลเรียนรู้แบบ bias ได้ ต้องกรองออก

def remove_duplicates(dataset):
    """ลบข้อมูลที่ซ้ำกันออก"""
    seen = set()
    unique_data = []
    
    for item in dataset:
        # สร้าง fingerprint จากเนื้อหาทั้งหมด
        fingerprint = ""
        for msg in item.get('messages', []):
            fingerprint += msg.get('content', '')
        
        if fingerprint not in seen:
            seen.add(fingerprint)
            unique_data.append(item)
    
    return unique_data

def check_quality_score(item):
    """ให้คะแนนคุณภาพของข้อมูล"""
    score = 100
    
    for msg in item['messages']:
        content = msg['content']
        
        # หักคะแนนถ้าข้อความสั้นเกินไป
        if len(content) < 10:
            score -= 20
        
        # หักคะแนนถ้ามีอักขระแปลกประหลาด
        if any(ord(c) > 10000 for c in content):
            score -= 10
        
        # หักคะแนนถ้าเป็นลิงก์ทั้งด้าน
        if content.count('http') > 2:
            score -= 15
    
    return max(0, score)

ทดสอบกับชุดข้อมูล
dataset = [
    {"messages": [{"role": "user", "content": "ทดสอบ"}, {"role": "assistant", "content": "คำตอบ"}]},
    {"messages": [{"role": "user", "content": "ทดสอบ"}, {"role": "assistant", "content": "คำตอบ"}]},  # ซ้ำ
]

unique = remove_duplicates(dataset)
print(f"ข้อมูลก่อนกรอง: {len(dataset)} รายการ")
print(f"ข้อมูลหลังกรอง: {len(unique)} รายการ")

ขั้นตอนที่ 5: แปลงข้อมูลเป็นรูปแบบ JSONL

เมื่อทำความสะอาดเสร็จแล้ว ต้องแปลงเป็นรูปแบบ JSONL เพื่อส่งไป Fine-tune

def export_to_jsonl(data, filename):
    """ส่งออกข้อมูลเป็นไฟล์ JSONL"""
    with open(filename, 'w', encoding='utf-8') as f:
        for item in data:
            json_line = json.dumps(item, ensure_ascii=False)
            f.write(json_line + '\n')
    
    print(f"ส่งออกไฟล์ {filename} สำเร็จ")
    print(f"จำนวนรายการ: {len(data)}")

def import_from_jsonl(filename):
    """นำเข้าข้อมูลจากไฟล์ JSONL"""
    data = []
    with open(filename, 'r', encoding='utf-8') as f:
        for line in f:
            if line.strip():
                data.append(json.loads(line))
    return data

ตัวอย่างการใช้งาน
training_data = [
    {
        "messages": [
            {"role": "system", "content": "คุณคือผู้เชี่ยวชาญด้านการเงิน"},
            {"role": "user", "content": "วิธีออมเงินที่ดีที่สุดคืออะไร"},
            {"role": "assistant", "content": "ควรแบ่งเงินเดือนเก็บ 20% ฝากออมทรัพย์ จ่ายหนี้ก่อน และลงทุนในกองทุนรวม"}
        ]
    }
]

export_to_jsonl(training_data, 'training_data.jsonl')
loaded_data = import_from_jsonl('training_data.jsonl')
print(f"นำเข้าได้: {len(loaded_data)} รายการ")

ขั้นตอนที่ 6: ส่งข้อมูลไป Fine-tune ผ่าน HolySheep API

เมื่อเตรียมข้อมูลเรียบร้อยแล้ว สามารถส่งไปฝึกโมเดลได้เลย

import requests
import time

อัปโหลดไฟล์ข้อมูลไปที่ HolySheep
def upload_training_file(filepath, api_key):
    """อัปโหลดไฟล์ข้อมูลฝึก"""
    url = "https://api.holysheep.ai/v1/files"
    headers = {"Authorization": f"Bearer {api_key}"}
    
    with open(filepath, 'rb') as f:
        files = {'file': ('training.jsonl', f, 'application/json')}
        response = requests.post(url, headers=headers, files=files)
    
    result = response.json()
    print(f"อัปโหลดสำเร็จ: {result}")
    return result['id']

สร้างงาน Fine-tune
def create_finetune_job(file_id, api_key, model="gpt-4.1"):
    """สร้างงาน Fine-tune"""
    url = "https://api.holysheep.ai/v1/fine_tuning/jobs"
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    data = {
        "training_file": file_id,
        "model": model,
        "suffix": "my-custom-model"
    }
    
    response = requests.post(url, headers=headers, json=data)
    result = response.json()
    print(f"งาน Fine-tune สร้างสำเร็จ: {result['id']}")
    return result['id']

ตัวอย่างการใช้งาน
api_key = "YOUR_HOLYSHEEP_API_KEY"
file_id = upload_training_file('training_data.jsonl', api_key)
time.sleep(2)  # รอให้ไฟล์พร้อม
job_id = create_finetune_job(file_id, api_key)
print(f"รหัสงาน: {job_id}")

ข้อผิดพลาดที่พบบ่อยและวิธีแก้ไข

ปัญหาที่ 1: ไฟล์ข้อมูลมีรูปแบบ JSON ไม่ถูกต้อง

ข้อผิดพลาดนี้เกิดขึ้นบ่อยมาก มักจะเป็นเพราะลืมใส่เครื่องหมายคั่นบรรทัด (comma) ระหว่าง object หรือเครื่องหมายคำพูดไม่ตรงกัน

# ❌ ผิด - ลืมลบเครื่องหมายคั่นตัวสุดท้าย
{"messages": [...]},  # ← ตัวสุดท้ายห้ามมี comma

✅ ถูกต้อง
{"messages": [...]}
{"messages": [...]}

วิธีแก้: ใช้โค้ด Python ตรวจสอบก่อนส่ง
import json

def validate_jsonl(filepath):
    with open(filepath, 'r', encoding='utf-8') as f:
        for i, line in enumerate(f, 1):
            try:
                json.loads(line)
            except json.JSONDecodeError as e:
                print(f"บรรทัด {i}: {e}")
                return False
    return True

if validate_jsonl('training_data.jsonl'):
    print("ไฟล์ถูกต้องพร้อมใช้งาน")
else:
    print("กรุณาแก้ไขข้อผิดพลาดก่อน")

ปัญหาที่ 2: ข้อมูลคำถาม-คำตอบไม่สมดุล

โมเดลอาจเรียนรู้แบบหนึ่งมากเกินไป เช่น มีคำถามเกี่ยวกับเรื่อง A 1000 ชุด แต่เรื่อง B แค่ 10 ชุด

# วิธีแก้: ตรวจสอบการกระจายตัวของหัวข้อ
from collections import Counter

def analyze_topic_distribution(dataset):
    topics = []
    for item in dataset:
        user_content = item['messages'][1]['content'] if len(item['messages']) > 1 else ''
        # สมมติว่าคำ 2 คำแรกคือหัวข้อ
        words = user_content.split()[:2]
        topics.append(' '.join(words))
    
    counter = Counter(topics)
    print("การกระจายตัวของหัวข้อ:")
    for topic, count in counter.most_common(10):
        print(f"  {topic}: {count} รายการ")
    
    # แนะนำให้มีอย่างน้อย 50-100 ตัวอย่างต่อหัวข้อ
    return all(count >= 50 for count in counter.values())

ถ้าพบว่าการกระจายไม่ดี ให้เพิ่มข้อมูลในหัวข้อที่มีน้อย
โดยใช้ LLM ช่วยสร้างเพิ่มเติม

ปัญหาที่ 3: ข้อมูลมีความละเอียดอ่อนหรือไม่เหมาะสม

ถ้าโมเดลได้รับข้อมูลที่มี bias หรือเนื้อหาไม่เหมาะสม จะส่งต่อปัญหานั้นไปยังผู้ใช้

import re

def filter_sensitive_content(text):
    """กรองเนื้อหาที่ไม่เหมาะสม"""
    sensitive_patterns = [
        r'\b(ยาเสพติด|สารเสพ)\b',
        r'\b(เชื้อชาติ|ศาสนา)\b.*\b(ดูถูก|เหยียด)\b',
        r'\b(ความลับ|รหัสผ่าน)\s*[:=]\s*\S+',
    ]
    
    for pattern in sensitive_patterns:
        if re.search(pattern, text, re.IGNORECASE):
            return False
    return True

def clean_dataset(dataset):
    """ทำความสะอาดชุดข้อมูลทั้งหมด"""
    cleaned = []
    removed_count = 0
    
    for item in dataset:
        should_keep = True
        for msg in item['messages']:
            if not filter_sensitive_content(msg['content']):
                should_keep = False
                removed_count += 1
                break
        
        if should_keep:
            cleaned.append(item)
    
    print(f"ลบออก {removed_count} รายการที่ไม่เหมาะสม")
    print(f"เหลือข้อมูล {len(cleaned)} รายการ")
    return cleaned

สรุปและแนวทางปฏิบัติที่ดีที่สุด

จากประสบการณ์การ Fine-tune โมเดลมาหลายครั้ง ผมขอแบ่งปันแนวทางปฏิบัติที่ดีที่สุดดังนี้ ควรมีข้อมูลอย่างน้อย 100-500 ตัวอย่างต่อโมเดล และควรมีความหลากหลายในหัวข้อ จำนวนข้อมูลที่น้อยเกินไปจะทำให้โมเดล overfit แต่ถ้ามากเกินไปอาจทำให้โมเดลลืมสิ่งที่เคยรู้ ทำความสะอาดข้อมูลทุกครั้งก่อนฝึก และทดสอบโมเดลหลังฝึกเสร็จทันที ราคาของ HolySheep AI ค่อนข้างคุ้มค่า โดย DeepSeek V3.2 อยู่ที่ $0.42 ต่อล้านตัวอักษร ซึ่งเหมาะมากสำหรับการเตรียมข้อมูลจำนวนมาก รวมถึงมีความเร็วในการตอบสนองน้อยกว่า 50 มิลลิวินาที รองรับการชำระเงินผ่าน WeChat และ Alipay อีกด้วย 👉 สมัคร HolySheep AI — รับเครดิตฟรีเมื่อลงทะเบียน