เมื่อเร็วๆ นี้ ทีม Seed ของ ByteDance และนักวิจัยจาก AIR แห่งมหาวิทยาลัย Tsinghua ได้ร่วมกันเผยแพร่งานวิจัยใหม่ชื่อ CUDA Agent ซึ่งได้รับความสนใจอย่างกว้างขวางในวงการสร้างโค้ด AI

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

ในการทดสอบมาตรฐาน CUDA Agent แสดงประสิทธิภาพที่โดดเด่น: บนเคอร์เนลความซับซ้อนระดับง่าย/ปานกลาง ประสิทธิภาพสูงกว่า torch.compile ถึง 2 เท่า; บนเคอร์เนลที่ซับซ้อน ประสิทธิภาพเพิ่มขึ้นประมาณ 92%; แม้แต่ในการตั้งค่าโจทย์ที่ท้าทายที่สุด ประสิทธิภาพยังนำหน้าโมเดลเฉพาะทางที่ทรงพลังอย่าง Claude Opus 4.5 และ Gemini 3 Pro ประมาณ 40%

• ลิงก์บทความวิจัย: https://arxiv.org/abs/2602.24286
• หน้าแรกโครงการ: https://cuda-agent.github.io/
• ลิงก์ Github: https://github.com/BytedTsinghua-SIA/CUDA-Agent
• ลิงก์ชุดข้อมูล: https://huggingface.co/datasets/BytedTsinghua-SIA/CUDA-Agent-Ops-6K

ปัจจุบัน โมเดลขนาดใหญ่ที่เป็นตัวแทนเช่น GPT, Claude สามารถสร้างโค้ด CUDA ที่ “ถูกต้อง” ตามไวยากรณ์ได้ และได้รับการนำไปใช้ในระดับหนึ่ง อย่างไรก็ตาม ยังมีช่องว่างใหญ่ระหว่าง “สามารถรันได้” กับ “รันได้เร็ว” การปรับแต่งเคอร์เนล GPU เป็นกุญแจสำคัญของประสิทธิภาพการเรียนรู้เชิงลึก แต่งานนี้มีความเชี่ยวชาญสูง ต้องการความรู้ด้านฮาร์ดแวร์ที่ลึกซึ้ง

วิธีการสร้างโค้ด CUDA ด้วย AI ที่มีอยู่ในปัจจุบันส่วนใหญ่พึ่งพาวิศวกรรมพรอมต์ (prompt engineering) แบบไม่ฝึกฝน หรือการปรับแต่งละเอียดด้วยผลตอบรับจากการรันหลายรอบ วิธีการประเภทนี้มักสามารถแก้ไขข้อผิดพลาดทางไวยากรณ์ผิวเผินได้เท่านั้น ยากที่จะเข้าใจตรรกะฮาร์ดแวร์ระดับลึก จึงจำกัดความสามารถภายในในการปรับแต่งลึก

การปรับแต่ง CUDA ที่สุดขั้วอย่างแท้จริง ต้องการให้ความสนใจกับตัวชี้วัดระดับฮาร์ดแวร์ที่สามารถสังเกตได้จากโปรไฟเลอร์ประสิทธิภาพ วงการคาดหวังมานานที่จะมี AI ที่ “คิด” เหมือนผู้เชี่ยวชาญ CUDA มนุษย์

เพื่อรับมือกับความท้าทายนี้ CUDA Agent เสนอแนวคิดหลักว่า: กุญแจสำคัญของประสิทธิภาพ CUDA ไม่ได้อยู่ที่ความถูกต้องของโค้ด แต่อยู่ที่ความเข้าใจและการใช้ประโยชน์จากคุณลักษณะของฮาร์ดแวร์อย่างลึกซึ้ง การจัดตารางเธรดวอร์ป (warp scheduling) การใช้ประโยชน์จากแบนด์วิดท์หน่วยความจำ ความขัดแย้งในการเข้าถึงหน่วยความจำ – รายละเอียดเหล่านี้ที่สามารถมองเห็นได้ในโปรไฟเลอร์ประสิทธิภาพเท่านั้น คือหัวใจของการปรับแต่ง

เพื่อจุดประสงค์นี้ ทีมวิจัยละทิ้งรูปแบบดั้งเดิมของ “การคอมไพล์สำเร็จคือรางวัล” หันมาใช้การฝึกฝนการเรียนรู้แบบเสริมกำลัง (RL) ที่อิงตามความเร็วการทำงานจริงบน GPU เอเจนต์เรียนรู้โดยตรงจากข้อมูลโปรไฟล์ประสิทธิภาพ กลไกรางวัลเชื่อมโยงโดยตรงกับความเร็วการทำงานจริงของเคอร์เนล

วิธีการนี้ได้ผลลัพธ์ที่โดดเด่น ในการทดสอบมาตรฐาน KernelBench CUDA Agent ทำได้ผลลัพธ์ระดับแนวหน้า (SOTA): ในสามระดับความยาก Level-1, Level-2 และ Level-3 อัตราเร่งเฉลี่ย (faster rate) เมื่อเทียบกับการใช้งาน torch.compile อยู่ที่ 100%, 100% และ 92% ตามลำดับ

การเปรียบเทียบประสิทธิภาพของ CUDA Agent กับ torch.compile และโมเดลเฉพาะทางที่ทรงพลังบน KernelBench

กล่าวโดยสรุป CUDA Agent เป็นระบบการเรียนรู้แบบเสริมกำลังขนาดใหญ่สำหรับเอเจนต์อัจฉริยะ ซึ่งมีแกนหลักสามส่วน: กลไกการสังเคราะห์ข้อมูลที่สามารถขยายได้ สภาพแวดล้อมการพัฒนา CUDA ที่ผสานรวมความสามารถในการเสริมทักษะและการตรวจสอบความน่าเชื่อถือ/การวิเคราะห์ประสิทธิภาพ และชุดอัลกอริทึมการเรียนรู้แบบเสริมกำลังสำหรับการฝึกฝนคอนเท็กซ์ยาวอย่างมีเสถียรภาพ

นอกจากนี้ ทีมวิจัยยังเผยแพร่ CUDA-Agent-Ops-6K พร้อมกัน ซึ่งเป็นชุดข้อมูลการฝึกสังเคราะห์คุณภาพสูงที่ผ่านการคัดกรองอย่างเข้มงวดและการควบคุมการปนเปื้อนของข้อมูล มีเป้าหมายเพื่อสนับสนุนการทำซ้ำงานวิจัยเกี่ยวกับการปรับแต่งเคอร์เนล CUDA ที่อิงตามการเรียนรู้แบบเสริมกำลัง

การออกแบบไปป์ไลน์ระบบ

การสังเคราะห์ข้อมูล

ทีมวิจัยสร้างงานฝึกฝนผ่านไปป์ไลน์สามขั้นตอน: การรวบรวมปัญหาเมล็ดพันธุ์ (seed) การสังเคราะห์เชิงประกอบ (compositional synthesis) ตามโมเดลภาษาขนาดใหญ่ (LLM) และการคัดกรองตามผลการรัน

• การขุดหาเมล็ดพันธุ์: ขุดหาโอเปอเรเตอร์เมล็ดพันธุ์จากไลบรารี PyTorch และ Transformers แต่ละโอเปอเรเตอร์แสดงในรูปแบบคลาส Python ประกอบด้วยวิธีการเริ่มต้น (initialization) และการส่งต่อ (forward propagation)
• การสังเคราะห์เชิงประกอบ: ในขั้นตอนการสังเคราะห์ จะสุ่มตัวอย่างโอเปอเรเตอร์สูงสุด 5 ตัว และนำมารวมกันตามลำดับ เพื่อสร้างงานคำนวณแบบผสาน (fusion)
• การคัดกรองโดยการรัน: รักษาเฉพาะงานที่สามารถรันได้ปกติทั้งในโหมด Eager และโหมด Compile และลบโอเปอเรเตอร์ที่มีความสุ่มออก
• การป้องกันการโกง: เพื่อป้องกันไม่ให้โมเดล “ใช้วิธีลัด” จะคัดออกงานที่ให้ผลลัพธ์เป็นค่าคงที่หรือแยกแยะไม่ได้ภายใต้อินพุตที่ต่างกัน
• การควบคุมโหลด: จำกัดเวลาในการรันภายใต้โหมด Eager ไว้ที่ช่วง 1ms–100ms และลบตัวอย่างที่คล้ายคลึงกับชุดประเมินสุดท้าย KernelBench อย่างมาก

แผนภาพไปป์ไลน์การรวบรวมข้อมูลสามขั้นตอน

ในที่สุด ทีมงานได้รวบรวมตัวอย่างการฝึก 6000 ตัวอย่าง สร้างชุดข้อมูล CUDA-Agent-Ops-6K ชุดข้อมูลนี้ออกแบบมาเพื่อการฝึกการเรียนรู้แบบเสริมกำลังที่สามารถขยายได้ มีทั้งความหลากหลายของงานและความเสี่ยงการปนเปื้อนของข้อมูลที่ต่ำ

สภาพแวดล้อมเอเจนต์

ไปป์ไลน์วนรอบของเอเจนต์ปฏิบัติตามเวิร์กโฟลว์สไตล์ ReAct ผสานรวมเครื่องมือโค้ดและข้อกำหนดทักษะ CUDA รองรับวงจรการเขียน-คอมไพล์-ดีบั๊กแบบวนซ้ำ และกระบวนการปรับแต่งที่อิงตามโปรไฟเลอร์ประสิทธิภาพ

• ขั้นตอนมาตรฐาน: วิเคราะห์ประสิทธิภาพการใช้งาน PyTorch ดั้งเดิม เขียนเคอร์เนล CUDA และโค้ดผูกมัด (binding code) ดำเนินการคอมไพล์ในสภาพแวดล้อมแซนด์บ็อกซ์ GPU และปรับแต่งให้ดีขึ้นอย่างต่อเนื่อง
• เป้าหมายการปรับแต่ง: กำหนดให้โค้ดที่สร้างขึ้นผ่านการตรวจสอบความถูกต้อง และมีประสิทธิภาพเร็วกว่าการใช้งาน torch.compile อย่างน้อย 5%
• กลไกรางวัล: ใช้การออกแบบรางวัลแบบไม่ต่อเนื่องตามเหตุการณ์สำคัญ (milestone) ให้รางวัลตามการบรรลุเงื่อนไขความถูกต้องและระดับการเพิ่มประสิทธิภาพ
• มาตรการป้องกันการโกง: รวมถึงการป้องกันสคริปต์ตรวจสอบและวิเคราะห์ประสิทธิภาพ ห้ามเรียกย้อนกลับ ใช้การตรวจสอบความถูกต้องด้วยอินพุตต่างกัน 5 ชุด วิเคราะห์ประสิทธิภาพหลังวอร์มอัพแบบซิงโครนัส และห้ามการค้นหาทางอินเทอร์เน็ต

แผนภาพสภาพแวดล้อมและเวิร์กโฟลว์ของเอเจนต์

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

ขั้นตอนการฝึกฝน

กระบวนการฝึกฝนใช้การออกแบบแบบหลายขั้นตอน เพื่อสร้างเสถียรภาพให้กับงานการเรียนรู้แบบเสริมกำลังที่มีลำดับเวลายาว (การเขียนโค้ด CUDA) เริ่มด้วยการฝึกวอร์มอัพ PPO แบบรอบเดียว จากนั้นเริ่มต้นตัวแสดง (actor) และผู้วิจารณ์ (critic) แยกกัน สุดท้ายเข้าสู่ขั้นตอนการเรียนรู้แบบเสริมกำลังเต็มรูปแบบของเอเจนต์แบบหลายรอบ

• การวอร์มอัพแบบรอบเดียว: มีเป้าหมายเพื่อเพิ่มความสามารถพื้นฐานในการสร้างโค้ด CUDA เป็นพื้นฐานสำหรับการฝึกเอเจนต์แบบโต้ตอบในขั้นตอนต่อไป
• การเริ่มต้น Actor: ใช้การปรับแต่งละเอียดแบบปฏิเสธ (Rejection Fine-Tuning – RFT) ที่อิงตามการสุ่มตัวอย่างเส้นทางผลลัพธ์เชิงบวก กลไกการกรองของ RFT จะคัดกรองลูปที่ไม่มีประสิทธิภาพและรูปแบบการเรียกใช้เครื่องมือที่ไม่มีผลออก เพื่อลดความเสี่ยงของการล่มสลายของกลยุทธ์
• การเริ่มต้น Critic: ผ่านการฝึกล่วงหน้าของฟังก์ชันค่า (value function) ทำให้การประมาณค่าความได้เปรียบ (advantage estimation) มีความน่าเชื่อถือสูงตั้งแต่เริ่มต้นการฝึก

แผนภาพขั้นตอนการฝึกฝนหลายขั้นตอน

ด้วยการออกแบบนี้ ระบบยังคงมีเสถียรภาพภายใต้การตั้งค่าคอนเท็กซ์ยาว (คอนเท็กซ์ยาวสุด 128k, สูงสุด 150 รอบในขั้นตอนฝึก, สูงสุด 200 รอบในขั้นตอนประเมิน) ทำให้สามารถเพิ่มรางวัลได้อย่างต่อเนื่อง

ผลการทดลองหลัก

ทีมวิจัยรายงานตัวชี้วัดแบบเต็มทั้งในระดับรวมและแยกตามความยาก Level-3 บนมาตรฐาน KernelBench รวมถึงอัตราการผ่าน (pass rate) อัตราเร่ง (faster rate) (เทียบกับโหมด Eager/Compile) และอัตราเร่งเฉลี่ยเรขาคณิต (geometric mean speedup) (เทียบกับโหมด Eager/Compile)

ตารางผลการทดลองโดยละเอียดของ CUDA Agent บน KernelBench

เมื่อเทียบกับโมเดลฐานเฉพาะทางที่ทรงพลัง CUDA Agent แสดงให้เห็นถึงความได้เปรียบอย่างชัดเจนในการปรับแต่งประสิทธิภาพเมื่อเทียบกับ torch.compile:
* ในชุดทดสอบมาตรฐาน KernelBench ทั้งหมด อัตราการบรรลุการเร่งความเร็ว (speedup achievement rate) เมื่อเทียบกับ torch.compile อยู่ที่ 96.8% และ อัตราเร่งเฉลี่ยเรขาคณิตอยู่ที่ 2.11 เท่า
* ความได้เปรียบนี้เด่นชัดเป็นพิเศษในการตั้งค่าความยากสูง: ในงานระดับ Level-3 อัตราการบรรลุการเร่งความเร็วเมื่อเทียบกับ torch.compile อยู่ที่ 90% ซึ่งสูงกว่าโมเดลฐานเฉพาะทางที่แข็งแกร่งที่สุดประมาณ 40 เปอร์เซ็นต์; ในงานลำดับโอเปอเรเตอร์ระดับ Level-2 อัตราการบรรลุการเร่งความเร็วอยู่ที่ 100% และอัตราเร่งเฉลี่ยเรขาคณิตอยู่ที่ 2.80 เท่า

การแสดงภาพประสิทธิภาพโดยรวมและตัวชี้วัดการเร่งความเร็วของ CUDA Agent บน KernelBench

งานวิจัยนี้ก็มีข้อจำกัดบางประการ

ประการแรก งานวิจัยครั้งนี้ไม่ได้เปรียบเทียบ CUDA Agent กับเฟรมเวิร์กคอมไพเลอร์ที่ซับซ้อนกว่า เช่น TVM ประการที่สอง ขั้นตอนการฝึกฝนพึ่งพาพูลทรัพยากร GPU ขนาดใหญ่และกลไกการแยกระดับกระบวนการ นำมาซึ่งต้นทุนการคำนวณและวิศวกรรมที่สำคัญ การสำรวจกลยุทธ์การฝึกฝนที่มีประสิทธิภาพสูงขึ้นเป็นทิศทางการวิจัยที่สำคัญในอนาคต

การปรากฏตัวของเทคโนโลยีเช่น CUDA Agent มีแนวโน้มที่จะก้าวข้ามข้อจำกัดการปรับแต่งของคอมไพเลอร์แบบดั้งเดิม (เช่น torch.compile หรือ Triton) นี่บ่งชี้ว่าโมเดลภาษาขนาดใหญ่ไม่เพียงแต่สามารถเรียนรู้ภาษาธรรมชาติและภาษาการเขียนโปรแกรมระดับสูงเท่านั้น แต่ยังสามารถทำให้เกิด “สัญชาตญาณฮาร์ดแวร์” ที่มีเกณฑ์สูงผ่านการเรียนรู้แบบเสริมกำลังที่อิงตามผลตอบรับจากฮาร์ดแวร์

เส้นทางสู่โครงสร้างพื้นฐานการคำนวณที่ปรับแต่งได้อัตโนมัติเต็มรูปแบบและมีประสิทธิภาพสูงกำลังปรากฏให้เห็น

⚠️ หมายเหตุ: เนื้อหาได้รับการแปลโดย AI และตรวจสอบโดยมนุษย์ หากมีข้อผิดพลาดโปรดแจ้ง