บทที่ 3 — กลไกหลัก: Reflection, Self-Training, Self-Play
โดย Nokka (นก-กา) | กันยายน 2026
บทความนี้เขียนโดย AI (DeepSeek V4 Pro) ผ่าน Hermes Agent — ตรวจสอบและเรียบเรียงโดย Nokka
ตอนนี้เรามาถึงหัวใจของเรื่อง — "กลไก" ที่ทำให้ AI เก่งขึ้นเองได้จริง ๆ กลไกเหล่านี้มีสามตระกูลใหญ่ เรียงจากง่ายไปยาก: Reflection (ทบทวนตัวเอง), Self-Training (สร้างข้อมูลสอนตัวเอง), และ Self-Play (เล่นกับตัวเอง)
กลไกที่ 1: Reflection — ทบทวนตัวเอง
แนวคิด
Reflection เป็นกลไกที่ง่ายที่สุดและใช้กันแพร่หลายที่สุด หลักการคือ: ให้ AI ทำงาน → ดูผลลัพธ์ → วิจารณ์ผลงานตัวเอง → แก้ไข → ทำงานใหม่
วงจรนี้เรียกว่า generate → critique → revise (สร้าง → วิจารณ์ → แก้ไข)
งานวิจัยสำคัญ
Reflexion (Shinn et al., 2023) เป็นงานที่ทำให้แนวคิดนี้โด่งดัง หลักการคือ agent ทำงานพลาด แล้วแทนที่จะเริ่มใหม่จากศูนย์ มันจะ "เขียนบันทึก" ว่าทำไมถึงพลาด แล้วใช้บันทึกนั้นเป็นบทเรียนในรอบถัดไป
ลองนึกภาพ agent ที่เล่นเกมแก้โจทย์ มันตอบผิด → มันเขียนว่า "ฉันตอบผิดเพราะลืมตรวจเครื่องหมายลบ" → รอบหน้า มันเห็นโจทย์คล้ายกัน ก็จำได้ว่าต้องระวังเครื่องหมายลบ
Self-Refine (Madaan et al., 2023) ใช้หลักการเดียวกันแต่เรียบง่ายกว่า — AI สร้างผลงาน แล้วให้ feedback ตัวเอง แล้วแก้ไข วนไปเรื่อย ๆ จนกว่าจะพอใจ
ข้อดีและข้อจำกัด
ข้อดีของ reflection คือ ง่ายและได้ผลเร็ว — แค่เพิ่ม "ขั้นตอนทบทวน" เข้าไปใน agent ที่มีอยู่ ก็ได้กำไรทันที โดยไม่ต้องเทรนโมเดลใหม่เลย
แต่ข้อจำกัดก็ชัดเจน — นักวิจัยเตือนว่า "reflection ไม่เท่ากับ improvement" โมเดลเก่งในการเขียน "คำอธิบายว่าทำไมถึงผิด" ที่ฟังดูมีเหตุผล แต่ถ้าไม่มีตัวตรวจสอบภายนอก (เช่น รันโค้ดแล้วดูว่า error จริงไหม) โมเดลอาจแค่ "เก่งขึ้นในการอธิบายความผิดของตัวเอง" โดยที่ไม่ได้เก่งขึ้นจริง
พูดอีกอย่าง: reflection เปลี่ยน "วิธีคิด" ในงานเดียว แต่ไม่เปลี่ยน "ตัวโมเดล" — นี่คือ runtime optimization ไม่ใช่ learning ที่แท้จริง
กลไกที่ 2: Self-Training — สร้างข้อมูลสอนตัวเอง
แนวคิด
Self-training ก้าวไปอีกขั้น — แทนที่จะแค่ "คิดใหม่" AI จะ "สร้างข้อมูล" จากประสบการณ์ของตัวเอง แล้วใช้ข้อมูลนั้นเทรนตัวเองให้เก่งขึ้นจริง ๆ
หลักการคือ: ให้โมเดลทำโจทย์เยอะ ๆ → เก็บเฉพาะข้อที่ตอบถูก (พร้อมวิธีคิด) → ใช้ข้อมูลนั้นเทรนโมเดลอีกรอบ
งานวิจัยสำคัญ
STaR — Self-Taught Reasoner (Zelikman et al., 2022) เป็นงานบุกเบิก แนวคิดคือ: โมเดลสร้างวิธีคิด (rationale) สำหรับโจทย์หลายข้อ → เก็บเฉพาะวิธีคิดที่นำไปสู่คำตอบถูก → เทรนโมเดลด้วยวิธีคิดเหล่านั้น
ผลลัพธ์คือโมเดล "สอนตัวเอง" ให้คิดเป็นขั้นเป็นตอน โดยไม่ต้องมีมนุษย์มานั่งเขียนวิธีคิดให้
SELF (Lu et al., 2023) ต่อยอดแนวคิดนี้ด้วยการให้โมเดลสร้างโจทย์เองด้วย — ไม่ใช่แค่สร้างวิธีคิด แต่สร้างทั้งโจทย์และคำตอบ
SPIN (Self-Play fIne-tuNing, 2024) ใช้แนวคิด "เล่นกับตัวเอง" ในการเทรน — โมเดลรุ่นเก่าเป็นคู่ต่อสู้ โมเดลรุ่นใหม่ต้องเอาชนะรุ่นเก่า วนไปเรื่อย ๆ
ข้อดีและข้อจำกัด
ข้อดีคือ self-training เปลี่ยนโมเดลจริง ๆ — น้ำหนักถูกปรับ โมเดลเก่งขึ้นถาวร ไม่ใช่แค่เก่งในงานเดียว
แต่ข้อจำกัดก็ร้ายแรง: โมเดลที่เทรนด้วยข้อมูลของตัวเองเสี่ยง "model collapse" — ถ้าโมเดลสร้างข้อมูลผิดแล้วเทรนตัวเองด้วยข้อมูลผิด มันจะยิ่งผิดหนักขึ้น เหมือนคนที่ฟังแต่เสียงสะท้อนของตัวเอง
นี่คือเหตุผลที่ self-training ต้องมี "ตัวกรอง" — ต้องมีวิธีตรวจสอบว่าข้อมูลที่โมเดลสร้างขึ้นถูกต้องจริง ก่อนเอาไปเทรน
กลไกที่ 3: Self-Play — เล่นกับตัวเอง
แนวคิด
Self-play เป็นกลไกที่มีพลังที่สุด และเป็นกลไกที่ทำให้ AlphaGo เอาชนะแชมป์โลกหมากล้อมได้
หลักการคือ: ให้ AI สองตัว (หรือ AI กับเวอร์ชันเก่าของตัวเอง) แข่งกันเอง ตัวที่ชนะจะถูกเก็บไว้เป็น "รุ่นใหม่" แล้วรุ่นใหม่ก็ไปแข่งกับรุ่นถัดไป วนไปเรื่อย ๆ
งานวิจัยสำคัญ
AlphaZero (DeepMind, 2017) เป็นตัวอย่างที่โด่งดังที่สุด — มันเรียนรู้หมากรุก หมากล้อม และโชงิ โดยเล่นกับตัวเองหลายล้านเกม โดยไม่ต้องดูเกมของมนุษย์เลยแม้แต่เกมเดียว ผลลัพธ์คือมันเก่งกว่ามนุษย์และโปรแกรมอื่นทั้งหมดในเวลาไม่กี่ชั่วโมง
ในบริบทของ LLM แนวคิด self-play ถูกนำมาประยุกต์เป็น Challenger-Solver (ผู้ท้าทาย-ผู้แก้):
- Challenger สร้างโจทย์ยาก ๆ ขึ้นมา
- Solver พยายามแก้โจทย์นั้น
- ตัวตรวจสอบ (verifier) ตัดสินว่าแก้ถูกไหม
- โจทย์ที่ Solver แก้ไม่ได้ จะถูกใช้เทรน Solver ให้เก่งขึ้น
- แล้ว Challenger ก็สร้างโจทย์ที่ยากขึ้นไปอีก
งานอย่าง Absolute Zero และ Ctx2Skill ใช้แนวคิดนี้ในการสร้าง "ทักษะ" ใหม่ ๆ ให้ agent
ข้อดีและข้อจำกัด
ข้อดีคือ self-play สร้างความก้าวหน้าได้โดยไม่ต้องพึ่งข้อมูลจากมนุษย์ — AI สร้างทั้งโจทย์และคำตอบเอง วนไปได้ไม่รู้จบ
แต่ข้อจำกัดก็มีชื่อเรียกเฉพาะ: adversarial collapse — เมื่อ Challenger สร้างโจทย์ที่ "สุดโต่ง" เกินไป (ยากเกินจริง หรือเพี้ยนไปจากงานจริง) Solver ก็จะเก่งแต่เรื่องเพี้ยน ๆ ไม่ได้เก่งในงานจริง
นอกจากนี้ยังมี reward hacking — เมื่อ AI หาทาง "โกง" ตัวชี้วัด แทนที่จะเก่งขึ้นจริง เช่น หาทางได้คะแนนสูงโดยไม่ต้องแก้โจทย์จริง
สรุปบทนี้: สามกลไก หนึ่งหลักการ
| กลไก | ทำอะไร | เปลี่ยนโมเดลไหม | ความเสี่ยงหลัก |
|---|---|---|---|
| Reflection | คิดใหม่ในงานเดียว | ไม่เปลี่ยน | อธิบายเก่งแต่ไม่เก่งขึ้นจริง |
| Self-Training | สร้างข้อมูลเทรนตัวเอง | เปลี่ยน | model collapse |
| Self-Play | แข่งกับตัวเอง | เปลี่ยน | adversarial collapse, reward hacking |
สังเกตว่าแม้กลไกจะต่างกัน แต่ทั้งหมดมีหลักการร่วมกันอย่างหนึ่ง: สร้าง → ตรวจสอบ → อัปเดต (generate → verify → update)
- Reflection: สร้างคำตอบ → ตรวจสอบด้วยตัวเอง → อัปเดตวิธีคิด
- Self-Training: สร้างข้อมูล → ตรวจสอบว่าถูกไหม → อัปเดตน้ำหนักโมเดล
- Self-Play: สร้างโจทย์ → ตรวจสอบว่าแก้ได้ไหม → อัปเดตความสามารถ
หลักการ "สร้าง → ตรวจสอบ → อัปเดต" นี้เอง ที่นักวิจัยเรียกว่า GVU Operator — และมันคือกุญแจสำคัญที่จะเชื่อมทุกอย่างเข้าด้วยกันในบทที่ 5
แต่ก่อนจะไปถึงตรงนั้น เราต้องดูอีกสองชิ้นส่วนสำคัญก่อน: Skill Library (คลังทักษะ) และ Memory (ความจำ) — เพราะการ "เก่งขึ้น" จะไร้ค่าถ้า AI จำสิ่งที่เรียนรู้ไม่ได้
เอกสารอ้างอิง
- Shinn, N. et al. (2023). Reflexion: Language Agents with Verbal Reinforcement Learning. arXiv:2303.11366 — https://arxiv.org/abs/2303.11366
- Madaan, A. et al. (2023). Self-Refine: Iterative Refinement with Self-Feedback. arXiv:2303.17651 — https://arxiv.org/abs/2303.17651
- Zelikman, E. et al. (2022). STaR: Bootstrapping Reasoning With Reasoning. arXiv:2203.14465 — https://arxiv.org/abs/2203.14465
- Chen, Z. et al. (2024). Self-Play Fine-Tuning Converts Weak Language Models to Strong Language Models. arXiv:2401.01335 — https://arxiv.org/abs/2401.01335
- Silver, D. et al. (2017). Mastering Chess and Shogi by Self-Play with a General Reinforcement Learning Algorithm. arXiv:1712.01815 — https://arxiv.org/abs/1712.01815
📚 อ่านต่อในซีรีส์นี้
← บทก่อนหน้า: บทที่ 2: ระดับของ Self-Improvement (5 ระดับ)
บทถัดไป: บทที่ 4: Skill Library, Memory และ 4 Layers →
Top comments (0)