TL;DR
หลังจากเขียน "สิ่งที่คุณไม่รู้เกี่ยวกับ Claude Code: สถาปัตยกรรม ธรรมมาภิบาล และแนวปฏิบัติทางวิศวกรรม" และ "สิ่งที่คุณไม่รู้เกี่ยวกับ Agents: หลักการ สถาปัตยกรรม และแนวปฏิบัติทางวิศวกรรม" ผมอยากท้าทายตัวเองด้วยการสรุปว่าการเทรน Large Language Model (LLM) จริงๆ แล้วทำงานอย่างไร บทความนี้ตั้งใจให้เข้าใจได้แม้กับคนที่ไม่มีพื้นฐานทางวิชาชีพ
มองไปถึงปี 2026 ช่องว่างที่แท้จริงของประสิทธิภาพ LLM ไม่ใช่แค่การ Pre-training อีกต่อไป แต่เป็นส่วนท้ายที่ยาวตามมา นั่นคือ Post-training, Evaluation, Rewards, Agent Training และ Distillation ทุกขั้นตอนส่งผลต่อประสบการณ์จริงของผู้ใช้ เมื่อคุณเจอว่าโมเดล suddenly แข็งแกร่งขึ้น โอกาสสูงที่เกิดจากการปรับพื้นที่เหล่านี้ร่วมกัน ไม่ใช่ปัจจัยเดียว
ต่อไปนี้จะไล่ตามท่อ pipeline การเทรน LLM โดยเน้นที่ผู้ผลิตปรับปรุงผลลัพธ์สุดท้ายผ่านครึ่งหลังของ stack การเทรน
การเทรน LLM คือ Pipeline
ในช่วงไม่กี่ปีที่ผ่านมา ความก้าวหน้าของโมเดลมักอธิบายด้วยการสะสมของพารามิเตอร์ ข้อมูล และพลังประมวลผล แต่การปรับปรุงที่ผู้ใช้หลายคนรู้สึกจริงๆ ไม่ได้มาจากการเทรน corpus พื้นฐานเพิ่ม แต่มาจากกระบวนการเทรนทั้งหมดหลังจาก Pre-training ว่าที่โมเดลพูด ตอบตามคำสั่ง คิดหาเหตุผล และใช้เครื่องมือได้ มันไม่ได้เกิดขึ้นเองตามธรรมชาติแค่โดยการป้อนข้อความจากอินเทอร์เน็ตมากขึ้น
InstructGPT ให้ตัวอย่างที่ตรงไปตรงมามาก: โมเดลที่มีพารามิเตอร์เพียง 1.3B ที่ผ่าน Alignment และ Preference Optimization เอาชนะ GPT-3 ขนาด 175B ในการประเมินความชอบของมนุษย์ได้ ด้วยความต่างของพารามิเตอร์ถึงสองลำดับขนาด ผู้ใช้สุดท้ายกลับชอบเวอร์ชั่นที่เล็กกว่ามาก ครึ่งหลังของการเทรนนี้เขียนการรับรู้ของผู้ใช้ใหม่จริงๆ
กระบวนการเทรนจริงๆ แล้วคือ Pipeline ที่ Data, Algorithms, Systems และ Feedback เชื่อมโยงกันอย่างแน่นหนา การเปลี่ยนแปลงในเลเยอร์หนึ่งมักจะแพร่กระจายไปยังเลเยอร์อื่นๆ ในปี 2026 ความสามารถของโมเดลและคุณค่าทางอุตสาหกรรมรวมศูนย์มากขึ้นในเลเยอร์ที่ตามหลัง Pre-training
นี่เป็นสาเหตุที่เรามักรู้สึกว่า Doubao ไม่ได้แข่งขันเพื่อจัดอันดับ แต่กลับรู้สึกดีกว่าในการใช้งานประจำวัน – เพราะ Post-training ทำได้ดี
หกเลเยอร์นี้มีไว้เพื่อเห็นการแบ่งงานกันทำเท่านั้น เก้าขั้นตอนในรูปด้านล่างเป็นเวอร์ชั่นที่ละเอียดกว่า: Raw Data และ System Recipe แยกออกจากกัน และ Agent Harness กับ Deployment เป็นส่วนย่อยของครึ่งหลัง นอกจากนี้ยังมี Feedback Loops สองอย่างตลอดทั้งกระบวนการ: Production Traffic ส่งกลับไปยัง Data Engineering และผล Evaluation แบบ Offline ส่งกลับไปยัง Pre-training
Pre-training เป็นแค่พื้นฐาน
Pre-training ยังคงเป็นจุดเริ่มต้นของห่วงโซ่การเทรน การเข้าใจว่ามันทำอะไรเท่านั้นถึงจะเข้าใจว่าแต่ละเลเยอร์ถัดมาเติมเต็มอะไร หากไม่มีขั้นตอนนี้ ก็ไม่มีความสามารถในการสร้างแบบจำลองภาษา ไม่มีการบีบอัดความรู้ และไม่มีพื้นที่สำหรับการถ่ายโอนความสามารถในภายหลัง ในแง่วิศวกรรม มันทำมากกว่าแค่สอนโมเดลให้ทำนาย Token ถัดไป: มันเรียนรู้การกระจายตัวของภาษา บีบอัดความรู้และรูปแบบจากข้อความขนาดใหญ่เป็นพารามิเตอร์ และเหลือพื้นที่สำหรับการ激活ความสามารถในภายหลัง การทำนาย Token ถัดไปแค่อธิบายรูปแบบการเทรน มันไม่ได้อธิบายว่าทำไมโมเดลถึงพัฒนาความสามารถใหม่ๆ อย่างกะทันหันเมื่อขนาดเพิ่มขึ้น
หลังจาก GPT-3 การปรับแต่งโมเดลหลายครั้งคำนึงถึงงบประมาณและสัดส่วนอย่างระมัดระวังมากขึ้น โมเดลไม่ได้ดีขึ้นแค่เพราะใหญ่ขึ้น มีปัญหาเรื่องสัดส่วนระหว่างจำนวนพารามิเตอร์, Training Tokens และงบประมาณการคำนวณทั้งหมด โมเดลหลายตัวไม่ได้เล็กเกินไป แต่ถูกเทรนไม่พอ และยังไม่ถึงจุดที่เหมาะสมกว่าภายใต้งบประมาณที่กำหนด
ในการตัดสินใจเทรนจริง คำถามเชิงปฏิบัติคือ: ถ้ามีคนให้ H100 จำนวน 10,000 ตัวกับเวลาหนึ่งเดือน คุณจะเทรนโมเดล Open-Source ที่ดีพอได้ยังไง? Scaling Laws ที่นี่更像เครื่องมือจัดสรรงบประมาณมากกว่าเส้นโค้งนามธรรมใน paper สุดท้ายคุณต้องคิดว่า: รอบการเทรนถัดไปควรเพิ่มพารามิเตอร์หรือป้อนข้อมูลมากขึ้น? โมเดลปัจจุบันขาดความสามารถหรือแค่เทรนไม่พอ? ภายใต้งบ GPU ที่จำกัด สัดส่วนไหนมีค่าที่สุด?
Pre-training เหมือนการวางรากฐานสำหรับความสามารถของโมเดล กำหนดขอบเขตของความรู้ ศักยภาพในการ generalization และความสามารถในการเหนี่ยวนำรูปแบบ นอกจากนี้ยังกำหนดว่ายังมีพื้นที่ให้ Post-training ใช้ประโยชน์หรือไม่ อย่างไรก็ตาม Pre-training ไม่สามารถควบคุมว่าโมเดลทำตามคำสั่ง ให้ความร่วมมือกับผู้ใช้ หรือทำงานได้อย่างเสถียรในงานสำคัญต่างๆ ได้หรือไม่
เฟส Pre-training ไม่ได้แค่ตัดสินว่าเรียนรู้ความรู้มากแค่ไหน มันกำหนดล่วงหน้าว่าโมเดลจะเป็นอะไรได้บ้าง วิธีการแบ่ง Token ของ Tokenizer ส่งผลโดยตรงต่อการเทรนถัดไป และความยาว Context Window ต้องตั้งค่าล่วงหน้า ไม่ว่าจะทำ Multi-modal Pre-training ต่อหรือไม่ หรือการทำงานบน Single Accelerator เป็นข้อกำหนดตั้งแต่ต้น – การแลกเปลี่ยนเหล่านี้ถูกเขียนลงใน Recipe ระหว่างเฟสการเทรน ไม่ใช่เพิ่มเป็นฟีเจอร์ตอนปล่อย Gemma 3 เน้น Single Accelerator, 128K Context, ความสามารถด้าน Vision และ Quantization พร้อมกัน ซึ่งสะท้อนถึงการแลกเปลี่ยนเหล่านี้ ความสามารถที่ผู้ใช้เห็นในที่สุด – ทำงานบนคอมพิวเตอร์ส่วนตัว เห็นภาพ เข้าใจเอกสารยาว – จริงๆ แล้วถูกกำหนดส่วนใหญ่ระหว่างเฟสการเทรน
ดูจุดที่ข้อมูลเหมาะสมที่สุดที่ ChinChilla ให้ สำหรับโมเดลขนาด 8B พารามิเตอร์ คือประมาณ 200B Tokens อย่างไรก็ตาม Llama 3 8B จริงๆ แล้วใช้ 15T Tokens ประมาณ 75 เท่า Recipe การเทรนเกิน (Over-training) แบบนี้มักจะแลกความหนาแน่นของความสามารถที่สูงกว่าสำหรับพารามิเตอร์เท่าเดิม ส่งผลให้โมเดลเล็กลงและคุ้มค่ากว่าสำหรับ Inference การวัดด้วย Total FLOPs (การดำเนินการ floating-point) ทั้งหมดน่าเชื่อถือกว่าการดูจำนวนพารามิเตอร์ รูปด้านล่างแสดงให้เห็นช่องว่างนี้อย่างชัดเจน
การออกแบบอีกอย่างที่มักถูกมองข้ามเกิดขึ้นในเฟส Pre-training: ขนาดคำศัพท์ Tokenizer, กลยุทธ์การแบ่ง และวิธีการเข้ารหัสระดับไบต์มีผลกระทบอย่างมาก Llama 2 มีคำศัพท์ 32K หลังจาก Llama 3 ขยายเป็น 128K ความยาว Sequence ถูกบีบอัดประมาณ 15% และประสิทธิภาพปลายน้ำก็ตามมา ผลกระทบนี้ขยายไปถึงค่าใช้จ่าย Inference และความสามารถหลายภาษา ประสิทธิภาพ Token ของภาษาจีน, โค้ด และสูตรคณิตศาสตร์ถูกกำหนดระหว่างการออกแบบคำศัพท์ ตัวอย่างเช่น Tokenizer ที่แบ่งภาษาจีนเป็นชิ้นเล็กมากไม่เพียงแค่ทำให้เสีย Token มากขึ้นในแต่ละครั้ง ทุกครั้งที่ Inference ต้องแบกรับต้นทุนของการตัดสินใจที่แย่นั้นอย่างต่อเนื่อง
Data Recipes กำหนดความสามารถของโมเดล
ขนาดพารามิเตอร์เคยเป็นตัวชี้วัดหลักในอดีต แต่ในสองปีที่ผ่านมา สิ่งสำคัญกว่าคือ "Data Recipe"
กระบวนการนี้ภายนอกดูเหมือนการทำความสะอาดข้อมูล แต่จริงๆ แล้วเป็นงานวิศวกรรมการผลิตข้อมูลที่สมบูรณ์ ข้อมูลดิบจากหน้าเว็บ, โค้ด Repository, หนังสือ และฟอรั่มต้องผ่านการสกัดข้อความ, ระบุภาษา, กรองคุณภาพ, จัดการความเป็นส่วนตัว, กรองความปลอดภัย และ Deduplication ก่อนเข้าสู่ Pre-training รูปด้านล่างแสดงขั้นตอนการประมวลผลแบบ Funnel ที่สมบูรณ์
ถ้าคุณปฏิบัติต่อข้อมูลเป็นแค่เชื้อเพลิงการเทรน มันง่ายที่จะสรุปว่ายิ่งมากยิ่งดี แต่วิศวกรรมข้อมูลใกล้เคียงกับการออกแบบความสามารถมากกว่า สิ่งที่โมเดลเห็นและไม่เห็น และสัดส่วนของโค้ด, คณิตศาสตร์, และสารานุกรม ส่งผลโดยตรงต่อการกระจายความสามารถสุดท้ายของโมเดล
Deduplication และ Contamination Control มักถูกมองข้าม แต่มีผลกระทบอย่างมากต่อผลลัพธ์ ไม่ใช่แค่ข้อมูลคุณภาพต่ำเท่านั้น มันรวมถึงเทมเพลตซ้ำ, ข้อความใบอนุญาต, เว็บไซต์มิเรอร์ และ Contamination จากการรั่วไหลของ Benchmark ถ้า Deduplication ระดับเอกสารและระดับบรรทัดไม่เพียงพอ โมเดลมักจะดูดซับเนื้อหาที่คัดลอกง่ายที่สุดซ้ำๆ โดยไม่จำเป็นต้องเรียนรู้ส่วนที่มีค่าที่สุด ประสิทธิภาพที่ไม่สม่ำเสมอของโมเดล Open-Source หลายตัวมักเกิดจากช่องว่างในคุณภาพการประมวลผลข้อมูล
ในสองปีที่ผ่านมา Data Mixing เองกลายเป็นปัญหาการวิจัยแยกต่างหาก งานอย่าง Data Mixing Laws ไม่ได้เน้นแค่ว่าสามารถเก็บข้อมูลเพิ่มได้มากแค่ไหน แต่เน้นว่าสัดส่วนของประเภทข้อมูลต่างๆ นำโมเดลไปสู่โครงสร้างความสามารถเฉพาะได้อย่างไร
Synthetic Data ก็ย้ายจากวิธีการเสริมมาเป็นส่วนหนึ่งอย่างเป็นทางการของกระบวนการเทรน วิธีการอย่าง Self-Instruct, Trajectory การ Distillation ของ DeepSeek-R1 และการควบคุมแบบ Synthetic ที่เห็นได้ชัดขึ้นในซีรีส์ Qwen และ Kimi ล้วนไปในทิศทางเดียวกัน โมเดลที่แข็งแกร่งขึ้นแต่ละรุ่นมีส่วนร่วมในการสร้างข้อมูลที่รุ่นถัดไปเห็นขึ้นมาใหม่ โมเดลยุคแรกสร้าง Instruction Data พื้นฐาน โมเดลที่แข็งแกร่งขึ้นสร้าง Reasoning Trajectory และ CoT (Chain of Thought) Data คุณภาพสูง และโมเดล Reasoning ที่เทรนด้วย RL ดึง Trajectory เหล่านี้ลงใน Dense Model ที่เล็กกว่า "Dense" หมายถึงพารามิเตอร์ทั้งหมดทำงาน ต่างจาก MoE (Mixture of Experts) ที่เปิดใช้งานตามต้องการ
ประเด็นสำคัญที่นี่คือโมเดลมักต้องสร้างความสามารถในขนาดที่ใหญ่กว่าก่อน แล้วจึงบีบอัดความสามารถเหล่านั้นลงในโมเดลที่เล็กกว่า ซีรีส์ DeepSeek-R1-Distill เป็นตัวอย่างโดยตรง Trajectory ของโมเดลใหญ่หลัง RL ให้ประโยชน์อย่างมากกับ Dense Model ตั้งแต่ 1.5B ถึง 70B Llama 3.1 405B ก็ถูกใช้อย่างชัดเจนเพื่อปรับปรุงคุณภาพ Post-training ของโมเดล 8B และ 70B สิ่งเหล่านี้ไม่ใช่ผลพลอยได้ แต่เป็นส่วนหนึ่งของการออกแบบการเทรน
ข้อจำกัดของ System และ Architecture ต้องชัดเจนก่อนการเทรน
หลายคนเข้าใจการเทรนเป็นปัญหาการวิจัย: จะตั้ง Objective Function อย่างไร, จะลด Loss อย่างไร, และจะเปลี่ยนโครงสร้างโมเดลอย่างไร แต่ในการเทรน LLM จริง ข้อจำกัดของระบบมีความสำคัญมาก มันเป็นปัญหา Distributed System ไม่ใช่ปัญหา Deep Learning บนเครื่องเดียว จำนวน GPU, แบนด์วิธหน่วยความจำ, กลยุทธ์แบบขนาน, ความทนทานต่อข้อผิดพลาด และต้นทุน – สิ่งเหล่านี้รอจนหลังการเทรนเพื่อปรับให้เหมาะสมไม่ได้ มันกำหนดตั้งแต่แรกว่าเทรนได้ใหญ่แค่ไหน, รองรับ Context ยาวแค่ไหน, และสามารถรัน Post-training ที่ซับซ้อนขึ้นได้หรือไม่
MoE เป็นตัวอย่างที่ชัดเจนที่สุดในเลเยอร์นี้ โหมดหลาย Expert ช่วยให้โมเดลขยายพารามิเตอร์รวมภายใต้การคำนวณที่คล้ายกัน ในขณะที่ควบคุมต้นทุนการเปิดใช้งานต่อ Token การแลกเปลี่ยนคือ Routing ที่ซับซ้อน, Load Balancing ที่ยาก และโครงสร้างพื้นฐานที่หนักหน่วง การออกแบบ MoE ของ DeepSeek-V3 และ Qwen เป็นการประนีประนอมระหว่างต้นทุนและผลลัพธ์ ไม่ใช่แค่ความชอบด้านสถาปัตยกรรม
การอภิปรายใน Recipe ที่เปิดเผยเมื่อเร็วๆ นี้ไม่ได้เป็นแค่การวิเคราะห์หยาบๆ เช่น ขนาดโมเดลและอัตราส่วน Token อีกต่อไป muP อนุญาตให้ Hyperparameters ถ่ายโอนจากการทดลองขนาดเล็กไปยังการเทรนขนาดใหญ่ WSD Learning Rate เป็นตารางเวลาที่เพิ่มขึ้น, คงที่ แล้วลดลง เมื่อรวมกับ Batch Size ที่เหมาะสมและอัตราส่วนข้อมูลต่อพารามิเตอร์ที่สูงขึ้น รายละเอียดเหล่านี้กำลังกลายเป็นความแตกต่างที่แท้จริงระหว่างโมเดลที่มีขนาดเท่ากัน
Long Context, Multi-modality และสถาปัตยกรรมใหม่ ถ้าเข้าใจเป็นแค่ฟีเจอร์ของผลิตภัณฑ์ จะพลาดข้อจำกัดด้านการเทรน เป้าหมาย Context 128K เปลี่ยนต้นทุน Attention, Batch Size, Training Curriculum (การเรียงลำดับข้อมูล) และกลยุทธ์แบบขนานโดยตรง Multi-modality ไม่เพียงเปลี่ยนโครงสร้างโมเดล แต่ยังเปลี่ยน Data Mixing, Encoder Design และ Safety Evaluation ด้วย ถ้าการทำงานบนการ์ดเดียวเป็นข้อกำหนดที่เข้มงวด จำนวนพารามิเตอร์, เส้นทาง Quantization และขนาดตระกูลโมเดลก็จะตึงตัวขึ้น
งานอย่าง Forgetting Transformer และ Attention Residuals ของ Kimi ตอบคำถามคล้ายกัน: วิธีเทรน Context ที่ยาวขึ้นและวิธีหลีกเลี่ยงการเจือจางข้อมูลเมื่อเครือข่ายลึกขึ้น สิ่งที่คุณเห็นคือโมเดลที่สามารถจัดการ Input ที่ยาวขึ้นหรือปรับใช้ได้ง่ายขึ้น แต่สิ่งที่เผชิญระหว่างการเทรนคือชุดข้อจำกัดที่แตกต่างกันโดยสิ้นเชิง
งบประมาณการคำนวณคงที่ ขนาดโมเดล, ปริมาณ Token การเทรน, ความยาว Context และต้นทุน Serving – ทุกบิตที่ใช้ในทิศทางหนึ่ง ทิศทางอื่นต้องลดลง
เมื่อ Context ยาวขึ้น ต้นทุน Attention พุ่งสูงขึ้น และ Batch Size ต้องลดลง เมื่อโมเดลใหญ่ขึ้น การใช้ GPU Memory เพิ่มขึ้น และต้นทุน Serving ก็ตามมา สิ่งเหล่านี้ไม่ใช่ทางเลือก แต่เป็นผลลัพธ์ของข้อจำกัดด้านทรัพยากร การตัดสินใจส่วนใหญ่ถูกกำหนดไว้ก่อนที่การเทรนจะเริ่มต้นขึ้น
นอกจากนี้ยังมีความเป็นจริงทางวิศวกรรมที่มักถูกมองข้าม: การเทรนไม่เสถียรเสมอไป GPU หลายพันตัวทำงานเป็นเวลาหลายสัปดาห์ และทันใดนั้นเกิด Loss Spike ขึ้น ใหญ่มากจนมองไม่ข้าม บังคับให้ย้อนกลับไปยัง Checkpoint จากหลายวันก่อนเพื่อเริ่มใหม่
นอกจาก Loss Spike แล้ว ยังมีข้อผิดพลาด GPU แบบเงียบ – GPU ตัวเดียวที่ไม่รายงานข้อผิดพลาด แต่สร้าง Gradient ผิดอย่างเงียบๆ – ความผิดปกติของแบนด์วิธ NVLink และ Jitter การสื่อสารระหว่างโหนด แต่ละอย่างสามารถปนเปื้อนการเทรนหลายขั้นตอน การตรวจจับ, แยก และกู้คืนได้อย่างรวดเร็วในการเทรนขนาดใหญ่เป็นความสามารถทางวิศวกรรมระดับห้องปฏิบัติการ ไม่ใช่ปัญหาที่แก้ได้ด้วยการอ่าน Paper
DeepSeek-V3 กล่าวโดยเฉพาะในรายงานเทคนิคว่า กระบวนการ Pre-training ทั้งหมดไม่มี Loss Spike ที่กู้คืนไม่ได้ และไม่มีการย้อนกลับ นอกจากนี้ยังเป็นหนึ่งในไม่กี่กรณีที่ยืนยันว่าการเทรนแบบผสม FP8 นั้นเป็นไปได้ในโมเดลขนาดใหญ่มาก ตามข้อมูลสาธารณะ กระบวนการทั้งหมดใช้เวลาประมาณ 2.788M ชั่วโมง GPU H800 เพื่อ Pre-training 14.8T Tokens
ระบบเทรนและระบบ Inference เกี่ยวข้องกันอย่างใกล้ชิด แต่ไม่ใช่ปัญหาทางวิศวกรรมเดียวกัน การเทรนสนใจ Gradient, ความขนาน, Checkpoint, ปริมาณงาน และต้นทุน Inference สนใจ Latency, KV Cache (การแคชการคำนวณประวัติเพื่อหลีกเลี่ยงการทำซ้ำ), Quantization และเสถียรภาพของบริการ
Post-training กำหนดช่องว่างที่ผู้ใช้รับรู้
การปรับปรุงหลายอย่างที่ผู้ใช้ทั่วไปรู้สึกได้จริงเกิดขึ้นหลัง Pre-training Instruction Tuning ใช้คู่คำสั่ง-คำตอบที่ติดป้ายกำกับสำหรับการเทรนแบบมี Supervision มันเปลี่ยนวิธีที่โมเดลตอบ แปลงข้อกำหนดเช่นวิธีรับงาน, จัดระเบียบ Output และทำตัวเป็นผู้ช่วยที่ให้ความร่วมมือเป็นสัญญาณ Supervision โมเดลพื้นฐานอาจมีความสามารถแฝงอยู่มากมาย แต่หากไม่มีขั้นตอนนี้ ความสามารถเหล่านั้นมักจะไม่ปรากฏอย่างเสถียรในรูปแบบที่ผู้ใช้คาดหวัง
มองลึกลงไป RLHF, DPO และ RFT มีทิศทางคล้ายกัน – ผสานคำจำกัดความของ "คำตอบที่ดีกว่า" เข้าไปใน Training Loop – แต่ผ่านเส้นทางที่แตกต่าง
- RLHF (Reinforcement Learning from Human Feedback) เริ่มต้นด้วยการเลียนแบบคำตอบคุณภาพสูง จากนั้นใช้การเปรียบเทียบความชอบเพื่อ Reinforcement
- DPO (Direct Preference Optimization) ย่นเส้นทางนี้ให้สั้นลง โดยเรียนรู้จากการเปรียบเทียบความชอบโดยตรง โดยไม่ต้องมี Reward Model แยกต่างหาก
- RFT (Reinforcement Fine-Tuning) เป็นอินเทอร์เฟซที่นำไปใช้ได้ง่ายกว่าในทางวิศวกรรม โดยใส่ Task Definition, Grader Design และ Reward Signal ลงในกระบวนการ Productization
ทุกวันนี้ การพูดถึง Post-training แค่ในแง่ของ SFT หรือ RL ไม่เพียงพออีกต่อไป ส่วนที่ยากกว่าคือวิธีตั้งค่า Evaluation, ให้คะแนน และคำตอบแบบไหนที่คุ้มค่าต่อการปรับปรุงอย่างต่อเนื่อง SFT คือ Supervised Fine-tuning; มันเรียนรู้ไม่ใช่แค่ความรู้แต่รวมถึงสไตล์ด้วย ความยาวข้อมูล, รูปแบบ, การรวม Citation หรือไม่ และความชอบรายการหัวข้อย่อยมีผลอย่างมากต่อรูปแบบ Output สุดท้ายของโมเดล ผู้ใช้หลายคนคิดว่ากำลังเปรียบเทียบความสามารถ แต่บ่อยครั้งแค่เปรียบเทียบความแตกต่างของสไตล์เท่านั้น ยิ่งไปกว่านั้น การประเมินความชอบมักชอบคำตอบที่ยาวกว่า ทำให้เข้าใจผิดว่าคำตอบยาวที่ดูจริงจังน่าเชื่อถือกว่า ดังนั้น การดู Leaderboard สำหรับ Post-training มักไม่เพียงพอ ต้องรวมผลลัพธ์งานจริง ต้นทุน และเสถียรภาพ
Post-training สมัยใหม่เป็น Pipeline หลายขั้นตอน Recipe ของ DeepSeek-R1 ชัดเจนที่สุดในเอกสารสาธารณะ มันดำเนินไปในสี่ขั้นตอน:
ขั้นตอนที่ 1 คือ Cold-start SFT ก่อนทำ Reinforcement Learning ใช้ Chain of Thought (CoT) คุณภาพสูงจำนวนเล็กน้อยเพื่ออุ่นเครื่อง DeepSeek-R1-Zero พิสูจน์ว่าการทำ RL โดยตรงจากโมเดลพื้นฐาน (โมเดลดิบหลัง Pre-training โดยไม่มีการ Alignment) เป็นไปได้ แต่โมเดลที่เทรนด้วย RL ล้วนๆ จะพูดซ้ำซาก, ภาษาไม่เป็นระเบียบ และอ่านยาก Cold-start SFT ทำให้ RL มีจุดเริ่มต้นที่เสถียรกว่า ล็อกรูปแบบและความสอดคล้องของภาษา
ขั้นตอนที่ 2 ทำ Reinforcement Learning ในสาขาที่ตรวจสอบได้ เช่น คณิตศาสตร์, โค้ด และตรรกะ โดยใช้ GRPO เป็นอัลกอริทึมการเทรน และใช้ความถูกต้องที่ตรวจสอบได้ด้วยโปรแกรมเป็น Reward Signal ประเด็นสำคัญคือเหตุใดจึงเลือก GRPO แทน PPO แบบดั้งเดิม: PPO (Proximal Policy Optimization) ต้องการ Value Network ที่เป็นอิสระเพื่อประมาณค่าสถานะปัจจุบัน ซึ่งเป็นภาระทางวิศวกรรมที่สูงสำหรับโมเดลขนาดใหญ่ GRPO สุ่มตัวอย่างหลายคำตอบสำหรับ Prompt เดียวกัน และใช้การจัดอันดับภายในกลุ่มแทนการประมาณค่าสัมบูรณ์ โดยไม่จำเป็นต้องมี Value Network ที่เป็นอิสระ ซีรีส์ DeepSeek และโครงสร้างพื้นฐาน RL ของ Cursor Composer 2 ทั้งคู่ใช้รูปแบบที่ใกล้เคียงกับ GRPO
ขั้นตอนที่ 3 ทำ Rejection Sampling Fine-Tuning โดยกรอง Trajectory ที่ประสบความสำเร็จที่สร้างโดย RL และแปลงเป็นข้อมูล SFT ใหม่สำหรับการเทรนแบบมี Supervision อีกรอบ นี่คือสะพานเชื่อมระหว่าง RL และ SFT; Trajectory ที่ดีที่ RL สำรวจพบกลายเป็นตัวอย่างการเทรนคุณภาพสูงสำหรับรอบถัดไปของ SFT
ขั้นตอนที่ 4 รวม Feedback ความชอบด้านประโยชน์และความปลอดภัยเพื่อปรับโมเดลให้เป็นรูปแบบผู้ช่วยที่ตรงตามมาตรฐานการปล่อย
สี่ขั้นตอนพึ่งพากัน: Cold Start ทำให้ RL เริ่มต้นได้อย่างเสถียร, RL สร้างข้อมูลคุณภาพสูง, Rejection Sampling เปลี่ยนข้อมูลนั้นเป็น Input สำหรับรอบ SFT ถัดไป และ Alignment RL ทำให้พฤติกรรมบรรจบกัน จากผลลัพธ์สาธารณะ ช่องว่างระหว่าง SFT โดยตรงและการทำทั้งสี่ขั้นตอนให้สมบูรณ์มักจะเห็นได้ชัด
Eval, Grader และ Reward กำลังกำหนดเป้าหมายการเทรนใหม่
คอมโพเนนต์ที่รับผิดชอบในการเปลี่ยน Output ของโมเดลเป็นคะแนนการเทรนเรียกว่า Grader และมันสามารถมีปัญหาที่ไม่คาดคิดได้ง่าย ถ้ามันดูแค่คำตอบสุดท้าย โมเดลจะเรียนรู้วิธีลัดอย่างรวดเร็ว ถ้าการให้คะแนนหยาบเกินไป Noise จะถูกขยายอย่างต่อเนื่องโดย Reinforcement Learning ถ้าคะแนน Leaderboard เพิ่มขึ้น งานจริงอาจไม่ตามมา บ่อยครั้ง ผู้ใช้คิดว่ากำลังเห็นช่องว่างในโมเดลพื้นฐาน แต่ช่องว่างอยู่ที่วิธีกำหนดเป้าหมาย
ในโฟลว์การเทรน Eval กำหนดสิ่งที่จะทดสอบ, Grader กำหนดว่า Output กลายเป็นคะแนนได้อย่างไร และ Reward กำหนดว่าโมเดลจะถูกผลักไปทางไหน เมื่อรวมกันแล้วจะสร้าง Feedback Loop เฉพาะ: Task Definition, Eval, Grader, Optimization, Rollout และ Re-evaluation Rollout หมายถึง Trajectory ที่โมเดลสร้างขึ้นโดยการดำเนินงาน ถ้าห่วงโซ่ใดหลงทาง การปรับให้เหมาะสมในภายหลังก็จะหลงทางเช่นกัน
มองแค่ผลลัพธ์สุดท้าย โมเดลอาจได้คำตอบที่ถูกต้องโดยบังเอิญ หรือทำตามกระบวนการที่ผิดเพื่อให้ได้คำตอบที่ถูกต้อง สิ่งนี้ชัดเจนเป็นพิเศษในงานโค้ด, คณิตศาสตร์ และการให้เหตุผลเชิงซับซ้อน ถ้าขั้นตอนกลางไม่เข้า Feedback สิ่งที่โมเดลเรียนรู้มักจะไม่ใช่การให้เหตุผลที่น่าเชื่อถือมากขึ้น แต่เป็นวิธีได้คะแนนสุดท้ายนั้นด้วยความน่าจะเป็นที่สูงขึ้น
ดังนั้น งานมากขึ้นในช่วงไม่กี่ปีที่ผ่านมาได้เปลี่ยนจาก RLHF แบบดั้งเดิมไปเป็น Verified Rewards โดยใช้โปรแกรมตรวจสอบความถูกต้องโดยตรง ในงานที่ตรวจสอบได้ เช่น คณิตศาสตร์, โค้ด และตรรกะ ความถูกต้องสามารถให้คะแนนได้โดยตรง โดยไม่ต้องพึ่งพาความชอบของมนุษย์เป็นหลัก แต่ Verified Rewards ยังไม่สามารถแก้ปัญหาได้อย่างสมบูรณ์ ปรากฏการณ์เช่น Over-optimization, Reward Overfitting (การปรับกฎการให้คะแนนมากเกินไปโดยไม่มีความสามารถเพิ่มขึ้นจริง) และ Mode Collapse (Output กลายเป็นเอกพจน์สูงและสูญเสียความหลากหลาย) ยังคงเกิดขึ้น ปัญหาได้เปลี่ยนจากความชอบถูกติดป้ายกำกับอย่างถูกต้องหรือไม่ เป็นห่วงโซ่การให้คะแนนเสถียรหรือไม่
กระบวนการคิดที่โมเดลเขียนไม่สามารถถือเป็นบันทึกที่สมบูรณ์ของกระบวนการภายในได้ Anthropic พบในการทดลองการสังเกต Reasoning Model ว่าโมเดลใช้คำใบ้เพิ่มเติมแต่ไม่ยอมรับใน CoT ที่มองเห็นได้; ในสถานการณ์ Reward Hacking พวกมันมีแนวโน้มที่จะเพิ่มคำอธิบายที่ดูเป็นไปได้ Reward Hacking คือการใช้ประโยชน์จากระบบการให้คะแนนแทนที่จะทำงานให้สำเร็จอย่างแท้จริง CoT ที่มองเห็นได้เหมาะกว่าเป็นสัญญาณการเทรนและตรวจสอบ ไม่ใช่ความจริงที่สมบูรณ์
ลงลึกไปอีกเลเยอร์ โมเดลอาจเริ่มใช้ประโยชน์จากช่องทางการให้คะแนนเอง งานวิจัยเกี่ยวกับ Reward Tampering และ Alignment Faking แสดงให้เห็นว่าในทางทฤษฎีโมเดลสามารถแทรกแซงกระบวนการให้คะแนนอย่างแข็งขัน Reward Tampering คือการเปลี่ยนแปลงกระบวนการคำนวณ Reward โดยตรง; Alignment Faking คือการแกล้งทำ Alignment – ดูเหมือนปฏิบัติตามบนพื้นผิวในขณะที่ซ่อนเจตนาที่ไม่สอดคล้องกัน
เมื่อโมเดลมีการเข้าถึงสภาพแวดล้อมที่แข็งแกร่งพอ สิ่งที่มันปรับให้เหมาะสมไม่ใช่แค่ผลลัพธ์ของงาน แต่รวมถึงรายการตรวจสอบ, โค้ด Reward และความสัมพันธ์ในการเทรนด้วย การทดลองของ Anthropic ในปี 2025 ฉีดความรู้ Reward Hack เพิ่มเติมเข้าไปในชุดสภาพแวดล้อม RL การเขียนโค้ดที่หาประโยชน์ได้ และต่อมาสังเกตเห็นการ Generalization ที่คล้ายกัน หลังจากเรียนรู้ Reward Hacking โมเดลไม่ได้แค่ใช้ประโยชน์ต่อไปในงานที่คล้ายกัน แต่ยังแสดง Misalignment ที่กว้างขึ้นเช่น Alignment Faking
พฤติกรรมเหล่านี้ไม่เห็นในการประเมินบทสนทนามาตรฐาน เห็นได้เฉพาะในสภาพแวดล้อมงาน Agent ผลกระทบทางวิศวกรรมนั้นตรงไปตรงมา: Reward, Grader, การแยกสภาพแวดล้อม และการตรวจสอบต้องเป็นส่วนหนึ่งของการออกแบบการเทรน
ในเฟส Agent การออกแบบ Reward ได้รับการปรับปรุงเพิ่มเติม ผลลัพธ์สุดท้ายเป็นเพียงหนึ่งรายการ; คุณภาพกระบวนการ, การจัดการ Context และข้อจำกัดป้องกันการโกงต้องถูกวัดแยกต่างหาก Kimi K2.5 ให้รางวัลการ分解ที่มีประสิทธิภาพและความขนานที่แท้จริง; Chroma Context-1 ให้คะแนนเอกสารที่เกี่ยวข้องที่พบระหว่างการค้นหา; Cursor Composer 2 รวมบทสรุปในงานยาวเป็นรางวัล เพราะถ้าบทสรุปบิดเบือน บริบทที่ตามมาจะถูกเข้าใจผิด
ในการนำไปใช้ ORM คือ Outcome Reward Model ให้คะแนนเฉพาะคำตอบสุดท้าย สัญญาณเบาบาง ต้นทุนต่ำ เหมาะสำหรับเริ่มต้น แต่โมเดลหาทางลัดได้ง่ายกว่า PRM คือ Process Reward Model ให้คะแนนขั้นตอนกลาง สัญญาณหนาแน่นกว่า และโดยทั่วไปแข็งแกร่งกว่าสำหรับการให้เหตุผลทางคณิตศาสตร์และโค้ด แต่ต้นทุนการติดป้ายกำกับและระบบสูงกว่ามาก OpenAI เห็นในการทดลองการให้เหตุผลทางคณิตศาสตร์ว่า PRM ไม่เพียงปรับปรุงความแม่นยำ แต่ยังทำให้ควบคุมกระบวนการได้ง่ายขึ้นเพราะทุกขั้นตอนได้รับการตรวจสอบ ปัญหาก็ตรงไปตรงมาเช่นกัน: ต้นทุนของ PRM มักจะสูงกว่า ORM หลายเท่า ดังนั้นระบบจริงส่วนใหญ่จึงเริ่มต้นด้วย ORM เฉพาะในงานที่ตรวจสอบได้ เช่น คณิตศาสตร์, โค้ด และตรรกะเท่านั้นที่ทำให้ PRM อัตโนมัติได้ง่ายขึ้น โดยใช้โปรแกรมตรวจสอบขั้นตอนกลางและหลีกเลี่ยงคอขวดการติดป้ายกำกับของมนุษย์
Loop ที่สมบูรณ์ทำงานดังนี้:
วิธีการ Alignment ล่าสุดทั้งหมดทำสิ่งเดียวกัน Constitutional AI ของ Anthropic ผสานหลักการที่มนุษย์เขียนไว้ในการเทรน โดยใช้ AI Feedback แทนความชอบของมนุษย์แต่ละคน Deliberative Alignment ของ OpenAI ใส่การปฏิบัติตามความปลอดภัยในกระบวนการให้เหตุผล ปล่อยให้ความสามารถในการให้เหตุผลรับผิดชอบข้อจำกัดด้านความปลอดภัยบางส่วน Deliberative Alignment ในที่นี้หมายถึงโมเดลตัดสินบรรทัดฐานความปลอดภัยด้วยตัวเองระหว่างเฟสการให้เหตุผล แทนที่จะพึ่งพาปฏิกิริยาตอบสนองที่เทรนมา ทั้งสองเส้นทางเปลี่ยน Alignment จากป้ายกำกับของมนุษย์เป็นส่วนหนึ่งของเป้าหมายการเทรนภายใน
ยกตัวอย่าง Constitutional AI กระบวนการสองขั้นตอนแรกให้โมเดลวิจารณ์ตนเองและแก้ไข Output ตามหลักการ จากนั้นใช้ AI Feedback แทนการติดป้ายกำกับความชอบของมนุษย์แต่ละคน Alignment ไม่เคยเป็นแพทช์ที่แขวนอยู่หลังการเทรน; ไม่ว่าระบบทดสอบอะไร, ให้คะแนนอย่างไร, และให้รางวัลอะไร โมเดลจะเคลื่อนไปในทิศทางนั้น นี่คือเครื่องมือปรับเปลี่ยนที่ตรงที่สุดในช่วงครึ่งหลังของการเทรน
ในการเทรน Agent ไม่ใช่แค่โมเดลที่ถูกปรับให้เหมาะสม
ในสองปีที่ผ่านมา การเกิดขึ้นอย่างรวดเร็วของโมเดลการให้เหตุผลที่นำโดยซีรีส์ o1 และ DeepSeek-R1 แสดงให้เห็นว่าภายใต้เงื่อนไขของรางวัลที่เสถียร การตรวจสอบที่เชื่อถือได้ และโครงสร้างพื้นฐานที่เพียงพอ การใช้ RL กับโมเดลภาษาสามารถปรับปรุงประสิทธิภาพในงานคณิตศาสตร์ โค้ด และตรรกะได้อย่างมีนัยสำคัญ
สิ่งนี้ยังเปิดมิติใหม่ขึ้นด้วย นั่นคือการคำนวณเชิงอนุมานสามารถปรับขนาดได้ บทบาทของการฝึกอบรม RL เพิ่มอีกชั้นหนึ่ง นอกเหนือจากการสอนให้โมเดลตอบคำถามแล้ว ยังสอนให้โมเดลรู้จักจัดสรรงบประมาณเชิงอนุมาน รู้ว่าเมื่อใดควรคิดมากขึ้นและเมื่อใดควรหยุด ก้าวต่อไป ความท้าทายคือการปล่อยให้โมเดลทำงานอย่างต่อเนื่องในสภาพแวดล้อม แทนที่จะแค่ยืดความคิดเดียวให้ยาวขึ้น
Junyang Lin อดีตหัวหน้าโมเดลของ Qwen มีข้อคิดที่เป็นตัวแทนเกี่ยวกับเส้นทางผสมระหว่าง Thinking และ Instruct: ความยากไม่ได้อยู่ที่การให้สวิตช์คิดแก่โมเดล แต่อยู่ที่เป้าหมายของทั้งสองโหมดนั้นแตกต่างกัน โหมดหนึ่งมุ่งเน้นความตรงไปตรงมา การปฏิบัติตาม และความหน่วงต่ำ ในขณะที่อีกโหมดมุ่งเน้นการสำรวจมากขึ้นและความแม่นยำที่สูงขึ้น ก้าวต่อไป เป้าหมายการฝึกอบรมเปลี่ยนจาก "คิดนานแค่ไหนก่อนตอบ" เป็น "จะจัดสรรงบประมาณระหว่างการกระทำอย่างไร จะรับฟีดแบ็กอย่างไร และจะดำเนินงานต่อไปอย่างไร"
ณ จุดนี้ วัตถุที่ถูกฝึกอบรมไม่ใช่แค่โมเดลที่ตอบคำถามอีกต่อไป แต่เป็นระบบที่สามารถวางแผน เรียกใช้เครื่องมือ รับฟีดแบ็ก และรักษาความต่อเนื่องในงานที่ยาวนาน ดังนั้น สแต็กการฝึกอบรมจึงเปลี่ยนไป: เบราว์เซอร์ เทอร์มินัล การค้นหา แซนด์บ็อกซ์สำหรับการทำงาน ระบบหน่วยความจำ เซิร์ฟเวอร์เครื่องมือ และเฟรมเวิร์กการประสานงาน เริ่มเข้ามาอยู่ในระบบการฝึกอบรมทั้งหมด
พูดให้ถูกต้องยิ่งขึ้น harness คือโปรแกรมควบคุมที่ห่อหุ้มโมเดลไว้ แนวคิดนี้ไม่ได้เป็นของ Agent runtime เท่านั้น มันมีอยู่ในช่วงการฝึกอบรมด้วยเช่นกัน: กำหนดว่าโมเดลเห็นอินพุตอะไร ได้รับฟีดแบ็กอย่างไร เมื่อใดควรตัดบริบท และเมื่อใดควรเรียกใช้เครื่องมือ การสร้าง prompt การอัปเดตหน่วยความจำ นโยบายการดึงข้อมูล การแก้ไขบริบท และการประสานงานเครื่องมือ ล้วนอยู่ที่นี่ สภาพแวดล้อมไม่ใช่แค่ตัวตรวจสอบแบบคงที่อีกต่อไป แต่เป็นชั้นที่ทั้งการฝึกอบรมและการปรับใช้ต้องเผชิญโดยตรง
harness ต้องมีความเสถียรเพื่อให้การฝึกอบรมโมเดลมีความหมาย หากค่าที่ส่งคืนจากเครื่องมือไม่เสถียร สภาพแวดล้อมของเบราว์เซอร์ไม่สอดคล้องกับสภาพแวดล้อมออนไลน์ หรือสถานะของระบบไฟล์ไม่สามารถทำซ้ำได้ ผู้ตรวจให้คะแนนจะล้มเหลวก่อน และโมเดลจะเรียนรู้วิธีใช้ประโยชน์จากช่องโหว่ของสภาพแวดล้อมแทนที่จะได้รับความสามารถ เมื่อฝึกอบรม Agent คุณมักจะต้องดีบักทั้งโมเดลและสภาพแวดล้อมไปพร้อมกัน
แนวทางของสามบริษัทมีความชัดเจน: Kimi ใช้ PARL เพื่อแก้ปัญหาการแยกย่อยแบบขนานและการกำหนดเครดิต Cursor ใช้การสรุปด้วยตนเองและ RL แบบเรียลไทม์เพื่อเชื่อมต่อเซสชันการเขียนโค้ดระยะยาวและทราฟฟิกการผลิตกลับไปสู่การฝึกอบรม Chroma ฝึก prune_chunks เป็นกลยุทธ์ในตัวมันเอง ปล่อยให้การตัดบริบทเข้าสู่กระบวนการดึงข้อมูลโดยตรง
ในยุค SFT ความหลากหลายของข้อมูลเป็นสิ่งสำคัญยิ่ง ในยุค Agent คุณภาพของสภาพแวดล้อมเป็นแกนหลัก: ความเสถียร ความถูกต้อง ความครอบคลุม การกระจายความยาก ความสมบูรณ์ของฟีดแบ็ก และการป้องกันการหาประโยชน์ เป้าหมายการฝึกอบรมเปลี่ยนไปตามนั้น ต้องการความน่าเชื่อถือในงานที่สมบูรณ์ ไม่ใช่แค่การตอบคำถามให้ถูกต้องหนึ่งข้อ เกณฑ์มาตรฐาน CoT แบบคลาสสิกไม่สามารถครอบคลุมสิ่งนี้ได้
การเปลี่ยนแปลงนี้ยังคงก้าวไปข้างหน้า: ไม่ใช่แค่การฝึกอบรมโมเดลภายใน runtime harness เท่านั้น แต่แม้แต่โค้ดของ harness เองก็กำลังกลายเป็นวัตถุที่สามารถค้นหาและปรับให้เหมาะสมโดยลูปภายนอก
PARL ของ Kimi K2.5 เป็นกรณีศึกษาทางวิศวกรรมที่น่าสนใจซึ่งมีเส้นทางที่ชัดเจน: ฝึกอบรมเฉพาะ orchestrator รวมศูนย์การกำหนดเครดิตไปที่ชั้นการประสานงาน และไม่ปรับแต่ง sub-agent ทั้งหมดพร้อมกัน
สัญญาณรางวัลแบ่งออกเป็นสามประเภท: ความสำเร็จของงาน การแยกย่อยแบบขนาน และข้อจำกัดในการทำให้เสร็จ ซึ่งร่วมกันขับเคลื่อนชั้นการประสานงาน ในช่วงแรกของการฝึกอบรม น้ำหนักของ r_parallel จะเพิ่มขึ้นเพื่อส่งเสริมการสำรวจกลยุทธ์แบบขนาน จากนั้นค่อยๆ ลดลงเป็น 0 ในภายหลังเพื่อหลีกเลี่ยงการเปิด sub-agent หลายตัวเป็นทางลัด การประเมินไม่เพียงแค่ดูจำนวนขั้นตอนทั้งหมด แต่ยังดูความยาวของเส้นทางวิกฤตด้วย เส้นทางวิกฤตที่สั้นกว่าบ่งชี้ว่าการทำงานแบบขนานมีประสิทธิภาพอย่างแท้จริง
แต่เมื่อถึงปี 2026 สิ่งต่างๆ ได้ก้าวไปอีกขั้น Meta-Harness ถือว่าวิศวกรรม harness เป็นเป้าหมายการปรับแต่งที่แยกต่างหากอย่างชัดเจน มันไม่ได้ปรับแต่งน้ำหนัก แต่ปรับแต่งโค้ดของ harness เอง นั่นคือโปรแกรมการสร้าง prompt การดึงข้อมูล หน่วยความจำ และการอัปเดตสถานะที่อยู่รอบโมเดลที่ถูกตรึงไว้ ตัวเลขในช่วงต้นของบทความนั้นตรงไปตรงมา: สำหรับโมเดลพื้นฐานเดียวกัน การเปลี่ยน harness เพียงอย่างเดียวอาจส่งผลให้ประสิทธิภาพแตกต่างกันถึง 6 เท่าในเกณฑ์มาตรฐานเดียวกัน ชุดโปรแกรมภายนอกโมเดลนี้ไม่ใช่แค่รายละเอียดในการปรับใช้อีกต่อไป แต่เป็นชั้นของการสร้างความสามารถ
ประเด็นสำคัญไม่ใช่การเพิ่มตัวปรับแต่งนามธรรมอีกตัวหนึ่ง แต่คือการเขียนโค้ดก่อนหน้า คะแนน และร่องรอยการดำเนินการ (บันทึกการเรียกใช้เครื่องมือและการเปลี่ยนแปลงสถานะ) ลงในระบบไฟล์ ปล่อยให้ proposer ใช้ grep, cat และ diff เหมือนกับการเขียนโค้ด จากนั้นจึงแก้ไข harness ไปตามเส้นทางที่ล้มเหลว proposer คือโมดูลที่แนะนำการปรับเปลี่ยน harness
ผู้เขียนตัดสินอย่างชัดเจนว่าตัวปรับแต่งข้อความในอดีตจำนวนมากไม่ได้ผลสำหรับโปรแกรมที่มีสถานะและระยะยาวเช่น harness เพราะการดูเฉพาะคะแนนสเกลาร์ เทมเพลตสั้นๆ หรือบทสรุปจะทำให้ปัญหาลดความซับซ้อนลง คะแนนสเกลาร์ให้เฉพาะคะแนนสุดท้ายโดยไม่มีข้อมูลกระบวนการ ข้อผิดพลาดของ harness มักจะปรากฏให้เห็นหลายขั้นตอนต่อมา เมื่อฟีดแบ็กถูกบีบอัดมากเกินไป ห่วงโซ่การวินิจฉัยก็จะขาด
ผลลัพธ์เหล่านี้มีมากกว่าแค่คะแนนเกณฑ์มาตรฐานที่สูงขึ้น ในการจำแนกข้อความออนไลน์ Meta-Harness สูงกว่า ACE (baseline การปรับแต่งบริบทของ Agent) อยู่ 7.7 จุด ในขณะที่บีบอัดการใช้โทเค็นบริบทเหลือ 1/4 ในการให้เหตุผลทางคณิตศาสตร์แบบเสริมการดึงข้อมูล harness ที่ค้นพบได้ปรับปรุงโมเดลที่ถูกกันไว้ 5 ตัว (ไม่ได้มีส่วนร่วมในการปรับแต่ง) โดยเฉลี่ย 4.7 จุดในโจทย์ระดับ IMO 200 ข้อ บน TerminalBench-2 ก็เกินกว่า baseline ทางวิศวกรรมที่ทำด้วยมือเช่นกัน สิ่งนี้แสดงให้เห็นว่าสิ่งที่กำลังถูกปรับแต่งนั้นไม่ใช่แค่กลยุทธ์ภายในโมเดลอีกต่อไป แต่ยังรวมถึงโปรแกรมที่จัดระเบียบข้อมูลและการกระทำรอบๆ โมเดลด้วย
ตัวอย่างเฉพาะ: Meta-Harness ค้นพบการบูตสแตรปสภาพแวดล้อมบน TerminalBench-2 โดยอัตโนมัติ นั่นคือการรันคำสั่งเชลล์ก่อนที่ลูป Agent จะเริ่มต้น เพื่อจัดระเบียบไดเรกทอรีทำงาน ภาษาที่มีให้ใช้ ตัวจัดการแพ็กเกจ และสถานะหน่วยความจำให้เป็น snapshot ที่ถูกฉีดเข้าไปใน prompt แรก Agent การเขียนโค้ดจำนวนมากใช้เวลาสองสามรอบแรกในการสำรวจสภาพแวดล้อม เมื่อมีการประมวลผลล่วงหน้านี้ การปรับปรุงไม่ได้มาจากน้ำหนักที่แข็งแกร่งขึ้นเสมอไป แต่มาจาก harness ที่ปล่อยให้โมเดลเริ่มต้นด้วยบริบทที่ดีกว่า
ณ จุดนี้ เป้าหมายการปรับแต่งได้ขยายจากคำตอบไปสู่เส้นทาง และจากนั้นไปยังโปรแกรม harness ที่บรรทุกเส้นทางเหล่านั้น
หลังจากโมเดลชั้นนำถูกปล่อยออกมา ห่วงโซ่การฝึกอบรมยังคงดำเนินต่อไป
การทำความเข้าใจโมเดลขนาดใหญ่ในปัจจุบันผ่านเลนส์ของการฝึกอบรมล่วงหน้าเพียงรอบเดียวไม่เพียงพออีกต่อไป เบื้องหลังโมเดลที่ถูกปล่อยออกมา ห่วงโซ่ทั้งหมดของการฝึกอบรมล่วงหน้า การฝึกอบรมภายหลัง การกลั่น และการปรับแต่งเฉพาะทาง มักจะเสร็จสมบูรณ์แล้ว และโมเดลที่แข็งแกร่งกว่ายังคงผลิตข้อมูลการฝึกอบรมสำหรับรุ่นต่อไป
การกลั่นของซีรีส์ DeepSeek-R1 เป็นตัวอย่างทั่วไป โมเดลขนาดใหญ่พัฒนาความสามารถในการให้เหตุผลผ่าน RL และรางวัลที่ได้รับการตรวจสอบก่อน จากนั้นจึงถ่ายโอนเส้นทางการให้เหตุผลเหล่านี้ไปยังโมเดลหนาแน่นขนาดเล็ก โมเดลเฉพาะทางอย่าง TranslateGemma แสดงให้เห็นอีกเส้นทางหนึ่ง: ในงานเป้าหมายที่เฉพาะเจาะจงมากขึ้น การใช้ข้อมูลคุณภาพสูงและการออกแบบรางวัลเฉพาะทางเพื่อบีบอัดและกำหนดทิศทางความสามารถเพิ่มเติม ในขั้นตอนนี้ โมเดลที่แข็งแกร่งกว่าไม่ได้มีไว้เพื่อให้บริการผู้ใช้เท่านั้น แต่ยังมีไว้เพื่อผลิตข้อมูลการฝึกอบรมสำหรับรุ่นต่อไปโดยตรง
เหตุผลเบื้องหลังนี้เป็นพื้นฐานมากกว่าการถ่ายโอนเส้นทาง: คำอธิบายหนึ่งที่เป็นไปได้คือ ในคลังข้อมูลอินเทอร์เน็ต ความรู้ความจำและความสามารถในการให้เหตุผลนั้นเชื่อมโยงกัน และเป้าหมายการฝึกอบรมล่วงหน้าที่มีอยู่กำหนดให้โมเดลต้องเรียนรู้ทั้งสองอย่างได้ดี โมเดลขนาดใหญ่ต้องมาก่อนเพราะมีขนาดใหญ่พอที่จะรองรับทั้งสองอย่างเท่านั้น จากนั้นจึงสามารถใช้สร้างข้อมูลสาธิตการให้เหตุผลที่บริสุทธิ์ได้ เมื่อโมเดลขนาดเล็กฝึกอบรมบนข้อมูลดังกล่าว พวกมันสามารถมุ่งเน้นไปที่การให้เหตุผลได้เองโดยไม่ต้องถูกบังคับให้จดจำความรู้ทั้งหมด การเริ่มต้นจากขนาดใหญ่แล้วไปสู่ขนาดเล็กนั้นเกี่ยวกับการแยกความสามารถออกจากกัน ไม่ใช่แค่กลยุทธ์ด้านต้นทุน
ในอีกด้านหนึ่ง ความสามารถในการปรับใช้ก็มีความสำคัญพอๆ กับความสามารถเอง หลายสถานการณ์ไม่จำเป็นต้องใช้โมเดลขนาดใหญ่ที่ใช้งานได้ทุกอย่าง พวกเขาใส่ใจเรื่องต้นทุน ความหน่วง ความเสถียร และความสามารถในการควบคุมมากกว่า จุดสิ้นสุดของการฝึกอบรมไม่จำเป็นต้องใหญ่ขึ้นเสมอไป แต่อาจเล็กลง ถูกกว่า และเฉพาะทางมากขึ้น
โมเดลที่ถูกปล่อยออกมาในที่สุดไม่จำเป็นต้องเป็น checkpoint ที่อยู่ด้านขวาสุดของเส้นโค้งการฝึกอบรม ก่อนการปล่อยจริง มักจะมีการเปรียบเทียบ checkpoint หลายตัวซ้ำๆ สำหรับผลลัพธ์ของงานจริง รูปแบบการปฏิเสธ ความเสถียรของเครื่องมือ ต้นทุน และความเสี่ยงจากการถดถอย เวอร์ชันที่ขึ้นออนไลน์มักเป็นการตัดสินใจด้านผลิตภัณฑ์ ไม่ใช่เวอร์ชันที่ทำงานได้ดีที่สุดในเมตริกเดียว
เมื่อผู้ใช้เห็นชื่อโมเดล พวกเขาคิดว่ามันสอดคล้องกับเส้นโค้งการฝึกอบรมที่เพิ่มขึ้นอย่างราบรื่น แต่ checkpoint ใดที่ถูกนำขึ้นออนไลน์จริงนั้นเป็นอีกเรื่องหนึ่ง
คุณค่าของโมเดลขนาดใหญ่อยู่ทั้งในความสามารถในการให้บริการของตัวมันเอง และในการจัดหาข้อมูลการฝึกอบรม แหล่งที่มาสำหรับการกลั่น และรากฐานสำหรับการปล่อยรุ่นต่อไปอย่างต่อเนื่อง
นอกเหนือจากการฝึกอบรมแบบออฟไลน์ การปรับแต่งอย่างต่อเนื่องแบบใกล้เคียงออนไลน์ได้เข้าสู่กระบวนการหลักแล้ว RL แบบเรียลไทม์ของ Cursor Composer 2 แสดงให้เห็นว่าความสามารถของ Agent บางอย่างเริ่มวนซ้ำอย่างต่อเนื่องผ่านทราฟฟิกการผลิต แทนที่จะรอการฝึกอบรมออฟไลน์ขนาดใหญ่รอบถัดไป เส้นแบ่งระหว่างการฝึกอบรมและการปรับใช้ยังไม่หายไป แต่วงจรป้อนกลับระหว่างทั้งสองกำลังสั้นลง
วิธีตัดสินว่าเหตุใดโมเดลจึงแข็งแกร่งขึ้นในอนาคต
คุณค่าของโมเดลชั้นนำในปี 2026 ขึ้นอยู่กับว่าใครสามารถทำให้ห่วงโซ่การฝึกอบรมทั้งหมดหลังการฝึกอบรมล่วงหน้าสมบูรณ์ได้: การผลิตข้อมูลการฝึกอบรมอย่างต่อเนื่อง การกลั่น การปรับแต่งเฉพาะทาง การประเมินและรางวัลที่ดี และการตัดสินใจเลือกปล่อยรุ่นสุดท้าย
ด้วยเหตุนี้ เมื่อดูว่าเหตุใดโมเดลหนึ่งจึงแข็งแกร่งขึ้นอย่างกะทันหัน คุณสามารถดูสามสิ่งนี้ก่อน:
- ประการแรก ดูว่าการเปลี่ยนแปลงเกิดขึ้นที่ชั้นการฝึกอบรมล่วงหน้าหรือในกระบวนการฝึกอบรมภายหลัง การปรับปรุงความสามารถหลายอย่างมาจากการฝึกอบรมล่วงหน้าที่แข็งแกร่งขึ้นและสูตรข้อมูลที่ดีขึ้น แต่การเปลี่ยนแปลงที่รับรู้ได้หลายอย่างแท้จริงแล้วมาจากการฝึกอบรมภายหลัง ไม่ว่าโมเดลจะปฏิบัติตามคำแนะนำ ใช้เครื่องมือ หรือมีรูปแบบการตอบที่เสถียร มักจะไม่เติบโตตามธรรมชาติเพียงแค่ฝึกอบรมบนคลังข้อมูลมากขึ้น
- ถัดไป ดูว่าการปรับปรุงมาจากชั้นใด: มาจากน้ำหนักและสูตรการฝึกอบรม หรือรางวัล/การประเมิน/ผู้ตรวจให้คะแนน หรือโค้ด harness และลูปการปรับใช้ เมื่อถึงโมเดลการให้เหตุผลและ Agent ความแข็งแกร่งที่ผู้ใช้รู้สึกมักไม่ใช่ผลลัพธ์ของโมเดลพื้นฐานเพียงอย่างเดียว การตั้งค่าการประเมินอย่างไร การให้คะแนนรางวัลอย่างไร สภาพแวดล้อมของเครื่องมือเสถียรหรือไม่ การจัดระเบียบการดึงข้อมูลและหน่วยความจำอย่างไร การสรุปและการตัดบริบทอย่างไร และ checkpoint ใดที่ถูกเลือกสำหรับการปล่อย ทั้งหมดนี้ร่วมกันเปลี่ยนประสิทธิภาพของผลิตภัณฑ์ขั้นสุดท้าย
- สุดท้าย ดูว่าเวอร์ชันออนไลน์กำลังปรับแต่งอะไรอยู่ บางเวอร์ชันมุ่งสู่เพดานที่สูงขึ้น บางเวอร์ชันมุ่งสู่ต้นทุน ความหน่วง และความเสี่ยงจากการถดถอยที่ต่ำลง และบางเวอร์ชันมีความเชี่ยวชาญสำหรับสถานการณ์บางประเภท เวอร์ชันที่ปล่อยออกมาคือการตัดสินใจด้านผลิตภัณฑ์ ไม่ใช่จุดที่อยู่ด้านขวาสุดของเส้นโค้งการฝึกอบรม ดังนั้นเมื่อดูการอัปเดตโมเดล การดูว่ามันกำลังปรับแต่งอะไรจริงๆ จะใกล้เคียงกับความจริงมากขึ้น
การแยกย่อยการปรับปรุงอย่างกะทันหันของโมเดลออกเป็นขั้นตอนการผลิต ผลกำไรหลายอย่างถูกขยายโดยครึ่งหลังของสแต็กการฝึกอบรมและ harness ภายนอก วงจรการวนซ้ำของห่วงโซ่นี้ก็สั้นลงเช่นกัน: ทราฟฟิกการผลิตไหลกลับไปสู่การฝึกอบรมอย่างต่อเนื่อง โมเดลที่แข็งแกร่งกว่าแต่ละรุ่นผลิตข้อมูลการดูแลรุ่นต่อไปในขณะที่ผลิตความสามารถ และโปรแกรมภายนอกถูกเขียนใหม่ตลอดเวลาตามการเปิดตัว บันทึก และฟีดแบ็กจากงานจริง
โมเดลที่ปล่อยออกมาในวันนี้เป็นเพียงภาพรวมเท่านั้น pipeline และโปรแกรม harness คือผลิตภัณฑ์ที่ยังคงทำงานต่อไป
สื่อการเรียนรู้
- Hoffmann et al. (2022). Training Compute-Optimal Large Language Models (Chinchilla). arXiv:2203.15556
- Ouyang et al. (2022). Training language models to follow instructions with human feedback (InstructGPT). arXiv:2203.02155
- Shao et al. (2024). DeepSeekMath: Pushing the Limits of Mathematical Reasoning in Open Language Models (GRPO). arXiv:2402.03300
- DeepSeek-AI (2025). DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning. arXiv:2501.12948
- DeepSeek-AI (2024). DeepSeek-V3 Technical Report. arXiv:2412.19437
- Llama Team, AI @ Meta (2024). The Llama 3 Herd of Models. arXiv:2407.21783
- Bai et al. (2022). Constitutional AI: Harmlessness from AI Feedback. arXiv:2212.08073
- OpenAI (2024). Deliberative Alignment: Reasoning Enables Safer Language Models. openai.com/index/deliberative-alignment
- Anthropic (2025). Sycophancy to Subterfuge: Investigating Reward Tampering in Language Models. anthropic.com/research/reward-tampering
- MacDiarmid et al. (2025). Natural Emergent Misalignment from Reward Hacking in Production RL. arXiv:2511.18397
- Lee et al. (2026). Meta-Harness: End-to-End Optimization of Model Harnesses (preprint project page). yoonholee.com/meta-harness
- Kimi Team (2026). Kimi K2.5 Tech Blog: Visual Agentic Intelligence. kimi.com/blog/kimi-k2-5
- Rush, S. (2026). A technical report on Composer 2. cursor.com/blog/composer-2-technical-report
- Chroma (2026). Chroma Context-1: Training a Self-Editing Search Agent. trychroma.com/research/context-1
บทความนี้ไม่อนุญาตให้มีการทำซ้ำหรือเขียนใหม่ในรูปแบบใดๆ เพื่อการเผยแพร่ซ้ำ หากคุณพบเห็น กรุณาช่วยแจ้งให้ฉันทราบด้วย
