นักศึกษาด้าน AI คนหนึ่งทดลองให้โมเดล AI สองตัว คือ Astra และ Fable 5.1 ทำโจทย์ Machine Learning เดียวกันตั้งแต่ต้นจนจบ โดยตั้งค่า effort หรือระดับความพยายามในการคิดวิเคราะห์ไว้สูงสุดเท่ากันทั้งคู่ งานที่ให้ทำเริ่มตั้งแต่ทำความสะอาดข้อความ แปลงข้อความเป็นเวกเตอร์ เทรนตัวจำแนกข้อมูล ไปจนถึงเขียนรายงานสรุปผล ทั้งสองโมเดลได้รับไฟล์กติกาการเขียนโค้ดชุดเดียวกันใน coding-conventions.md และเรียกใช้ subagent ผู้ช่วยเฉพาะทางที่เตรียมไว้ได้เหมือนกันทั้งหมด

ผู้ทดสอบนำผลการทดลองทั้งหมดมาแชร์ไว้ในกระทู้ห้อง r/MachineLearning บน Reddit โดยระบุชัดเจนว่า Fable 5.1 ก็คือ Claude เพราะผู้โพสต์สังเกตจากสำนวนภาษาอันเป็นเอกลักษณ์ของ Claude ส่วน Astra นั้น ในกระทู้ระบุเพียงชื่อโมเดล โดยไม่ได้บอกว่าพัฒนามาจากค่ายไหน

เมื่อวัดผลตอนจบ คะแนนความแม่นยำของทั้งสองตัวห่างกันไม่ถึง 0.01 จากคะแนนเต็ม 1 ทว่าแนวทางการทำงานเพื่อไปให้ถึงผลลัพธ์นั้นกลับต่างกันคนละขั้ว ตัวหนึ่งสืบหาต้นตอบั๊กของไลบรารีอย่างละเอียด พร้อมบันทึกหลักฐานให้ตรวจสอบย้อนหลังได้ทุกขั้นตอน ส่วนอีกตัวเขียนโค้ดอ่านง่าย และเขียนรายงานวิเคราะห์ได้ลึกเกินกว่าที่สั่ง ความต่างด้านพฤติกรรมการทำงานแบบนี้นี่เอง ที่เป็นเกณฑ์สำคัญในการเลือกใช้โมเดล มากกว่าดูแค่ตัวเลขทศนิยมในตารางคะแนน

Astra แบ่งข้อมูล 3 ส่วนตามมาตรฐาน แต่ Fable แบ่งแค่ 2 ส่วน

จุดแรกที่สะท้อนถึงวิธีคิดที่ต่างกัน คือขั้นตอนการแบ่งชุดข้อมูล Astra แบ่งข้อมูลออกเป็น 3 ส่วนตามสัดส่วน 70/15/15 คือชุด Train สำหรับสอนโมเดล ชุด Validation สำหรับเลือกและปรับจูนโมเดล และชุด Test ที่แยกไว้ประเมินผลรอบสุดท้ายเท่านั้น โดย Astra เลือกโมเดลจากคะแนนของชุด Validation ตามระเบียบวิธีที่ถูกต้อง

ฝั่ง Fable กลับแบ่งข้อมูลเพียง 2 ส่วนในสัดส่วน 80/20 คือ Train กับ Test แล้วนำคะแนน F1 ที่เป็นตัววัดความแม่นยำ (คะแนนเต็ม 1) จากชุด Test มาใช้ตัดสินใจเลือกโมเดลโดยตรง

ปัญหาคือ ชุด Validation กับชุด Test ทำหน้าที่ต่างกัน ชุด Validation มีไว้ทดลองเทียบโมเดลหลายๆ ตัวเพื่อเลือกตัวที่ดีที่สุด ส่วนชุด Test ต้องเป็นข้อมูลใหม่ที่โมเดลไม่เคยเห็น และต้องไม่เคยนำมาใช้ตัดสินใจเลือกอะไรมาก่อน การที่ Fable นำคะแนนจากชุด Test มาเป็นเกณฑ์เลือกโมเดลเสียเอง ทำให้ตัวเลขนั้นไม่ใช่การประเมินผลกับข้อมูลใหม่อย่างแท้จริงอีกต่อไป เรื่องนี้ถึงกับมีคนเข้ามาแซวในคอมเมนต์ว่า แม้แต่นักเรียน ML ที่เพิ่งเรียนไปแค่สองคาบ ก็ยังรู้เลยว่าต้องแบ่งข้อมูลเป็นสามส่วน

เจอบั๊ก gensim ตัวเดียวกัน: Astra แก้ที่ต้นตอ ส่วน Fable เลือกซ่อนคำเตือน

ระหว่างการทดลอง ทั้งสองโมเดลเจอบั๊กตัวเดียวกัน คือบั๊กใน compiled kernel หรือแกนประมวลผลหลักของไลบรารีแปลงข้อความเป็นเวกเตอร์อย่าง gensim เวอร์ชัน 4.4 และจุดนี้เองที่เผยให้เห็นนิสัยการแก้ปัญหาของทั้งสองตัวอย่างชัดเจนที่สุด

Fable พยายามแก้บั๊กนี้แต่ไม่สำเร็จ สุดท้ายจึงเลือกซ่อนข้อความเตือนใน stderr หรือช่องแสดงข้อผิดพลาดของโปรแกรม ไม่ให้แสดงออกมาในรอบที่มีปัญหา ข้อดีเพียงอย่างเดียวของวิธีนี้คือ มันบอกเจ้าของโพสต์ตรงๆ ว่าตัดสินใจทำแบบนั้น

ส่วน Astra ไล่สืบหาต้นเหตุจนพบ แล้วลงมือแก้ปัญหาที่สภาพแวดล้อมโดยตรง ด้วยการปรับลดเวอร์ชัน gensim พร้อมทั้งเปลี่ยนเวอร์ชันของ NumPy และ SciPy ให้เข้ากันได้ทั้งหมด แทนที่จะแค่ทำให้ข้อความเตือนหายไปจากหน้าจอ

สิ่งที่น่าสนใจยิ่งกว่าคือ Astra ทำงานรอบคอบมาก โดยเขียนสคริปต์เทรนชื่อ training-run.py ไว้อย่างรัดกุม บังคับให้รันในสภาพแวดล้อมจำลองอย่าง uv venv แยกต่างหากที่สร้างขึ้นใหม่ โดยไม่ไปแตะต้อง venv เดิมของเจ้าของโพสต์ พร้อมสร้างค่าแฮช SHA-256 ของชุดข้อมูลเก็บไว้ เพื่อให้แน่ใจว่าเวลานำมารันซ้ำจะได้ใช้ข้อมูลชุดเดิมแน่นอน ทั้งยังเขียนไฟล์บันทึกวิธีแบ่งข้อมูล และสร้างไฟล์ run-summary.json สรุปผลการรันแต่ละรอบไว้อย่างละเอียด ยิ่งไปกว่านั้น ยังเปิดเบราว์เซอร์แบบ headless ที่ทำงานเบื้องหลังโดยไม่เปิดหน้าต่างแสดงผล เพื่อเรนเดอร์ผลลัพธ์แล้วบันทึกภาพหน้าจอเก็บไว้ให้ตรวจ ซึ่งแม้เจ้าของโพสต์จะไม่แน่ใจว่าจำเป็นถึงขั้นนั้นไหม แต่ก็ประทับใจความใส่ใจนี้มาก

ตัดภาพมาที่ Fable ตัวสคริปต์เป็นเพียงไฟล์ชั่วคราวที่สร้างทิ้งไว้ในโฟลเดอร์ /tmp และไม่ได้เก็บข้อมูลเป็นระบบเท่า Astra หากอีกสามเดือนข้างหน้าคุณอยากกลับมาตรวจสอบว่าผลคะแนนรอบนั้นมาจากข้อมูลชุดไหน แบ่งข้อมูลอย่างไร หรือรันบนสภาพแวดล้อมแบบใด ข้อมูลที่ Astra บันทึกไว้ตอบคำถามได้ทั้งหมด ขณะที่ไฟล์ชั่วคราวของ Fable แทบไม่เหลือหลักฐานอะไรให้ย้อนดูเลย

Astra เรียกใช้ subagent ที่เตรียมไว้ แต่ Fable ไม่เรียกเลย

เรื่องการใช้ subagent ก็ไปคนละทิศทาง เจ้าของโพสต์ได้เตรียม agent ย่อยไว้ช่วยงาน 2 ตัว ได้แก่ notebook-reviewer สำหรับตรวจความถูกต้องของ Jupyter Notebook และ citation-checker สำหรับตรวจการอ้างอิง Astra เรียกใช้ทั้งสองตัวตามแผน และ notebook-reviewer ก็ช่วยจับบั๊กได้จริงหนึ่งจุด คือตรวจพบว่าคำท้ายประโยคหายไปในขั้นตอนการตัดคำ Astra จึงแก้ไขจุดที่ผิดพลาดทันที พร้อมเขียน regression test กำกับไว้ เพื่อป้องกันไม่ให้บั๊กเดิมกลับมาเกิดซ้ำ

ส่วน Fable ไม่ได้เรียกใช้ subagent เลยแม้แต่ตัวเดียว จึงไม่มีตัวช่วยตรวจ และทำให้บั๊กตัดคำนั้นหลุดรอดไป เจ้าของโพสต์เล่าว่าปกติแล้ว Fable ทำเรื่องพวกนี้ได้ดี ครั้งนี้จึงผิดคาด บั๊กประเภทนี้ไม่ได้ทำให้โปรแกรมพังจนเห็นข้อผิดพลาด แต่จะทำให้คำท้ายประโยคหายไปจากข้อมูลเงียบๆ หากไม่มีใครมานั่งไล่ตรวจโค้ดซ้ำ ก็แทบไม่มีทางรู้เลย

เจ้าของโพสต์สรุปมุมนี้สั้นๆ ว่า หากคุณต้องการ AI Agent ที่ลุยแก้ปัญหาสภาพแวดล้อมที่พังได้ด้วยตัวเอง พร้อมบันทึกหลักฐานให้ตรวจย้อนหลังได้ทุกขั้นตอน Astra คือตัวเลือกที่ตอบโจทย์อย่างยิ่ง

จุดตกม้าตายของ Astra: มั่นใจผิดๆ กับเรื่องพื้นฐานที่สุด

แม้ Astra จะทำตามขั้นตอนได้อย่างรัดกุม แต่กลับมาตกม้าตายในเรื่องพื้นฐานที่สุด ข้อมูลต้นฉบับจัดเก็บด้วยการเข้ารหัสแบบ UTF-8 แต่ Astra กลับยืนยันอย่างมั่นใจว่า หากถอดรหัสด้วย Windows-1252 สัญลักษณ์สกุลเงินจะยังคงอยู่ครบถ้วน ผลลัพธ์คือไฟล์รายงานสรุปแบบ HTML มีตัวอักษรเพี้ยนไปหมดทั้งไฟล์ จุดไหนที่เป็นสัญลักษณ์สกุลเงินก็กลายเป็นตัวอักษรประหลาดอ่านไม่รู้เรื่องจนเกิดปัญหา Mojibake

ขณะที่ Fable อ่านไฟล์ด้วย UTF-8 ตามปกติ ตรวจสอบความถูกต้อง แล้วใช้ค่ามาตรฐานทั่วไป ผลลัพธ์จึงออกมาถูกต้องเรียบร้อย ไม่มีปัญหาเรื่องตัวอักษร

ข้อผิดพลาดแบบนี้สังเกตได้ยากหากดูแค่สถานะการรัน เพราะโปรแกรมไม่ฟ้อง error ทุกอย่างรันผ่านฉลุย ตัวเลขคะแนนออกครบ ไฟล์รายงานสร้างเสร็จเรียบร้อย มีเพียงตัวอักษรบางส่วนที่เพี้ยนไป ทั้งที่เป็นข้อผิดพลาดที่เปิดดูด้วยตาเปล่าก็เห็นได้ทันที โดยไม่ต้องมีความรู้ด้าน ML เลยด้วยซ้ำ น่าสนใจว่าโมเดลที่วางระเบียบวิธีแน่นหนาที่สุดในการทดลองนี้ กลับพลาดเรื่องที่ตรวจได้ง่ายที่สุด

ด้านที่ Fable โดดเด่น: รายงานวิเคราะห์เจาะลึก และโค้ดอ่านเข้าใจง่าย

เมื่อสลับมาดูจุดเด่นของ Fable บ้าง สิ่งที่ประทับใจคือคุณภาพของรายงานสรุปผลช่วงท้าย Fable เขียนรายงานวิเคราะห์ได้ลึกกว่าอย่างเห็นได้ชัด และทำงานเกินเกณฑ์ที่กำหนดไว้ ด้วยการทำ Ablation Study หรือการทดลองตัดขั้นตอนเตรียมข้อมูลออกทีละส่วนเพื่อดูผลกระทบ จนพบว่ามีขั้นตอนหนึ่งที่กินเวลาและทรัพยากรสูงมาก แต่แทบไม่มีผลต่อคะแนนความแม่นยำเลย นอกจากนี้ยังสังเกตเห็นความคลาดเคลื่อนในลำดับผลลัพธ์การจำแนก จากความซับซ้อนบางอย่างที่ตัวเจ้าของโพสต์เองยอมรับว่าคงมองข้ามไป

ประโยชน์ของการทำ Ablation แบบนี้คือนำไปต่อยอดได้ทันที ขั้นตอนไหนที่สิ้นเปลืองทรัพยากรแต่ไม่ช่วยให้ผลลัพธ์ดีขึ้น ในรอบถัดไปก็ตัดทิ้งได้เลย

ด้านสำนวนการเขียน เจ้าของโพสต์ยอมรับตรงๆ ว่าปกติไม่ค่อยชอบสำนวนของ Claude เท่าไร เพราะอ่านแล้วรู้ทันทีว่าเป็น AI เขียน แต่ Claude Fable 5.1 รุ่นนี้ลดกลิ่นอายแบบนั้นลงไปมาก จนเขากล้าบอกว่าหากต้องเลือกโมเดลมาช่วยเขียนบทความหรือรายงานเชิงวิเคราะห์ เขาจะเลือก Fable 5.1 แน่นอน นับเป็นคำชมที่เขาไม่ได้มอบให้ Claude มานานแล้ว

เรื่องโค้ดก็เช่นเดียวกัน Fable เขียนโค้ดได้อย่างเป็นธรรมชาติและอ่านง่าย รูปแบบคล้ายโค้ดที่คนเขียน อีกทั้งยังทำตามข้อกำหนดใน coding-conventions.md ได้ดีกว่า ทั้งที่ทั้งสองโมเดลได้รับโจทย์เดียวกัน ส่วนโค้ดของ Astra มีบางจุดที่อ่านยากจนเจ้าของโพสต์ต้องใช้เวลาทำความเข้าใจอยู่นาน จุดนี้สำคัญมากสำหรับเขา เพราะเขายังไม่ใช่โปรแกรมเมอร์ที่เชี่ยวชาญ และยังต้องการอ่านโค้ดเพื่อเรียนรู้ไปพร้อมกัน

นี่คือข้อคิดที่ต้องนำมาชั่งน้ำหนัก หากโค้ดชุดนั้นต้องมีคนมารับช่วงต่อ ทั้งตัวคุณเองในอนาคตและเพื่อนร่วมทีม โค้ดที่อ่านเข้าใจได้ทันทีย่อมมีค่ามากกว่าโค้ดที่รันผ่านแต่ต้องมานั่งแกะ แต่หากเป็นงานประเภทที่รันครั้งเดียวแล้วทิ้ง เรื่องโค้ดอ่านง่ายก็อาจไม่ใช่เรื่องสำคัญ

นอกจากนี้ Fable ยังจัดสรรเวลาได้น่าสนใจ ขณะที่ Astra ใช้เวลาไปกับการไล่แก้บั๊ก gensim อย่างละเอียด ฝั่ง Fable กลับนำเวลาและโควตา Token ไปใช้รันซ้ำเพื่อปรับจูน Hyperparameter ที่เป็นค่าตั้งต้นก่อนเริ่มเทรน แล้วเทรนใหม่จนได้ผลลัพธ์ที่ดีที่สุด คะแนนของ Fable จึงไต่ระดับขึ้นมาจนเกือบเท่า Astra ทั้งที่ตอนแรกตามหลังอยู่ ส่วน Astra นั้นได้ผลการเทรนที่ดีตั้งแต่รอบแรก เจ้าของโพสต์จึงไม่แน่ใจว่าหากเกิดปัญหา Astra จะรู้วิธีไล่ปรับจูนเพื่อเค้นคะแนนเพิ่มแบบเดียวกันหรือไม่ โดยเวลาที่ทั้งสองตัวใช้ไปทั้งหมดใกล้เคียงกัน

อย่างไรก็ตาม มีอีกเรื่องที่ Astra ทำตามกติกาได้ไม่ดีนัก คือเรื่องสภาพแวดล้อม เจ้าของโพสต์ตั้งใจสร้าง venv มาเพื่อบังคับให้โมเดลใช้เฟรมเวิร์กอย่าง TensorFlow กับ Keras จะได้โค้ดที่กระชับกว่า แต่ Astra กลับแอบติดตั้งไลบรารี PyTorch เพิ่มเข้ามาเอง ทั้งที่ไม่มีใครสั่ง และท้ายที่สุดมันก็ไม่ได้ใช้ แต่เปลี่ยนใจกลับมาใช้ TensorFlow ตามเดิม เท่ากับว่าไปแก้ไขสภาพแวดล้อมโดยพลการ และไม่ได้ประโยชน์อะไรกลับมาเลย

สรุปเทียบพฤติกรรมการทำงานของทั้งสองโมเดล

ตัวเลขผลลัพธ์รอบสุดท้าย พร้อมข้อสังเกตสำคัญจากผู้ทดสอบ

ตารางด้านล่างนี้คือผลการทดลองจริงจากกระทู้ โดยเลือกโมเดลพื้นฐานอย่าง Logistic Regression ที่ดีที่สุด และโมเดลโครงข่ายประสาท Simple LSTM ที่ดีที่สุดของแต่ละฝั่ง จัดอันดับด้วยคะแนน Macro F1 ที่เป็นตัววัดความแม่นยำจากการให้น้ำหนักทุกกลุ่มข้อมูลเท่ากัน:

เจ้าของโพสต์ได้เขียนข้อสังเกตกำกับตัวเลขชุดนี้ไว้ 2 ข้อสำคัญ:

ข้อแรก คะแนน Test ของ Astra ออกมาสูงกว่าคะแนน Validation ของตัวมันเอง จึงเป็นไปได้ว่ามันอาจบังเอิญได้ชุด Test ที่ง่ายกว่าปกติ แม้ผู้โพสต์จะยืนยันว่า Pipeline ของทั้งสองโมเดลไม่มีปัญหาข้อมูลรั่วไหลข้ามชุด (Data Leakage) และไม่มีปัญหาเรื่องคุณภาพข้อมูลก็ตาม

ข้อสอง ตัวเลขทั้งหมดนี้เป็นคะแนนที่ได้หลังจากที่ผู้โพสต์ให้คำแนะนำทั่วไปเพิ่มเติมไปหนึ่งรอบ โดยให้คำแนะนำชุดเดียวกันกับทั้งสองโมเดลในเรื่องข้อควรระวังเกี่ยวกับการทำความสะอาดข้อความ การแปลงเวกเตอร์ และการเทรนโมเดล และไม่ได้เจาะจงจุดอ่อนของตัวใดตัวหนึ่ง ปรากฏว่าทั้งสองโมเดลทำผลงานได้ดีขึ้นพอๆ กัน คือค่า Accuracy และ Macro F1 เพิ่มขึ้นราว 0.02 ถึง 0.04 นี่เป็นการเข้ามาให้คำแนะนำเพียงครั้งเดียวของผู้โพสต์ ส่วนขั้นตอนที่เหลือปล่อยให้โมเดลทำงานอัตโนมัติทั้งหมด ผู้โพสต์จึงประเมินว่า โมเดลทั้งสองตัวยังไม่ได้เชี่ยวชาญงาน ML นี้อย่างสมบูรณ์ เพราะถ้าเชี่ยวชาญจริง คำแนะนำทั่วไปเพียงครั้งเดียวไม่ควรช่วยดันคะแนนให้เพิ่มขึ้นได้มากขนาดนี้

ข้อคิดเห็นจากคอมเมนต์ที่ไม่ควรมองข้ามก่อนด่วนสรุป

ในช่องคอมเมนต์มีผู้ชี้ให้เห็นข้อจำกัดสำคัญของการทดลองนี้ โดยเข้ามาท้วงติงว่า การทดสอบแค่โมเดลละ 1 ครั้ง ด้วย Random Seed เพียงค่าเดียว ไม่สามารถแยกแยะได้ว่าความต่างของคะแนนมาจากความสามารถของโมเดลจริงๆ หรือเกิดจากความบังเอิญในการสุ่มแบ่งข้อมูล หากต้องการพิสูจน์ให้ชัดเจน ควรทดสอบซ้ำสัก 3 ถึง 5 Seed แล้วรายงานผลเป็นช่วงคะแนน มิฉะนั้น การที่ Astra ดูมีระเบียบวิธีที่เหนือกว่า อาจเป็นเพียงเพราะมันบังเอิญเข้ากับการแบ่งข้อมูลในรอบนี้พอดี

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

นี่คือวิธีอ่านผลเปรียบเทียบโมเดล AI บนอินเทอร์เน็ตทุกชิ้น ไม่ใช่เฉพาะบทความนี้ และเป็นวิธีคิดที่ควรนำมาใช้ก่อนจะปักใจเชื่อพาดหัวข่าวว่า Kimi K3 แซงรุ่นท็อปจริงไหม เพราะตัวเลขที่ห่างกันเพียงเล็กน้อยจากการทดสอบแค่รอบเดียวแทบไม่มีความหมายอะไรเลย หากนำมารันใหม่ด้วย Seed อื่น ผลลัพธ์อาจสลับฝั่งกันได้ทันที แต่สิ่งที่มีความหมายและส่งผลกระทบมากกว่า คือพฤติกรรมตอนทำงานที่เห็นได้ซ้ำๆ เช่น การซ่อนคำเตือนแทนที่จะแก้ปัญหา การละเลยไม่ยอมเรียกใช้ subagent ที่เตรียมไว้ หรือการมั่นใจผิดๆ ในเรื่องพื้นฐานอย่าง Text Encoding เพราะสิ่งเหล่านี้คือสิ่งที่จะติดไปอยู่ในโปรเจกต์จริงของคุณ

3 บทเรียนสำคัญสำหรับนำไปปรับใช้จริง

1. เลือกโมเดลจากนิสัยการทำงาน ไม่ใช่ดูแค่คะแนน หากงานของคุณต้องรับมือกับปัญหาด้านสภาพแวดล้อมอยู่บ่อยๆ ต้องการหลักฐานที่ตรวจสอบย้อนหลังได้ทุกขั้นตอน และมี subagent เฉพาะทางเตรียมไว้ให้เรียกใช้ จากการทดลองนี้ Astra ตอบโจทย์ได้ดีกว่า แต่หากงานของคุณเน้นโค้ดที่เพื่อนร่วมทีมต้องมาอ่านต่อ ต้องการรายงานสรุปเชิงวิเคราะห์ที่เจาะลึกเกินคำสั่ง และต้องการโมเดลที่ทำตามกติกาอย่างเคร่งครัด Fable 5.1 จะทำได้ดีกว่า อย่างไรก็ตาม ทั้งหมดนี้เป็นเพียงข้อสังเกตจากคนคนเดียวในการทำงานชิ้นเดียว ยังไม่ใช่ข้อสรุปตายตัว
2. ใช้โมเดลตัวไหน ก็ต้องตรวจสอบเรื่องพื้นฐานด้วยตัวเองเสมอ โดยเฉพาะเรื่องการเข้ารหัสไฟล์และวิธีแบ่งชุดข้อมูล ควรเปิดดูไฟล์ผลลัพธ์จริงเสมอว่าตัวอักษรและสัญลักษณ์แสดงผลถูกต้องหรือไม่ พร้อมทั้งตรวจสอบว่าโมเดลแบ่งข้อมูลกี่ส่วน และใช้ข้อมูลชุดไหนเป็นเกณฑ์เลือกโมเดล เพราะขนาดโมเดลที่ดูมีระเบียบที่สุดอย่าง Astra ยังพลาดเรื่องการเข้ารหัสไฟล์ ขณะที่ Fable ก็ยังแบ่งข้อมูลเพียงแค่สองส่วนจนโดนแซวในคอมเมนต์
3. นำไปทดสอบกับงานจริงของคุณเอง ลองตั้งโจทย์แบบเดียวกับที่เจ้าของโพสต์ทำ กำหนดกติกาชุดเดียวกัน ล็อกค่า Seed เดียวกัน แล้วนั่งสังเกตพฤติกรรมการทำงานตั้งแต่ต้นจนจบ อย่าดูแค่คะแนนตอนท้าย คอยสังเกตว่ามันเลือกแก้บั๊กหรือแอบซ่อนบั๊ก ยอมเรียกใช้เครื่องมือที่คุณเตรียมไว้ให้ไหม ตรวจสอบไฟล์ผลลัพธ์จริงหรือมั่นใจในตัวเองมากเกินไป และหากมีโควตาเพียงพอ ให้ทดสอบหลายๆ Seed เพื่อดูช่วงคะแนนเฉลี่ยแทนการดูตัวเลขเดี่ยวเพียงรอบเดียว

คะแนนจากการประเมินบอกได้เพียงว่าโมเดลทำผลงานได้แค่ไหนในงานนี้ แต่นิสัยและรูปแบบการทำงานจะบอกได้ว่าคุณจะทำงานกับมันได้ราบรื่นแค่ไหนในงานต่อไป แล้วคุณล่ะ เคยเจอ AI ตัวไหนที่มั่นใจผิดๆ ในเรื่องที่ง่ายที่สุดแบบนี้บ้างไหม?

---

ที่มา: บทความ Astra vs. Fable 5.1 on real ML tasks: tradeoffs จาก r/MachineLearning