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

GRPO ส่งผลต่อการฝึกเอเจนต์อย่างไร:

1. การประเมินแบบกลุ่ม: GRPO จะประเมินหลายเส้นทาง (trajectory) สำหรับคำถามเดียวกัน ทำให้เอเจนต์สามารถเปรียบเทียบกลยุทธ์ที่แตกต่างกัน แทนที่จะพึ่งพารางวัลแบบขั้นตอนเดียว
2. การเรียนรู้จากข้อได้เปรียบสัมพัทธ์: เส้นทางที่สำเร็จจะได้รับการเสริมแรงเมื่อเทียบกับค่าเฉลี่ยของกลุ่ม ซึ่งช่วยเพิ่มความน่าจะเป็นของการวางแผนและการดำเนินการที่ถูกต้อง
3. การยับยั้งข้อผิดพลาด: เส้นทางที่แย่กว่าจะได้รับสัญญาณข้อได้เปรียบเชิงลบ ซึ่งช่วยลดการหลงผิด (hallucination) และการใช้เครื่องมือผิดพลาด
4. การปรับปรุงแบบวนซ้ำ: ผ่านการสร้างเส้นทางซ้ำๆ เอเจนต์จะปรับปรุงอย่างต่อเนื่อง เพื่อรับมือกับการวางแผนงานระยะยาวได้อย่างน่าเชื่อถือมากขึ้น
5. ความร่วมมือข้ามซับเอเจนต์: การฝึกในบริบทกลุ่ม GRPO ช่วยให้ซับเอเจนต์หลายตัวปรับการกระทำให้สอดคล้องกัน ซึ่งช่วยเพิ่มประสิทธิภาพของระบบมัลติเอเจนต์โดยรวม

สารบัญ

• บทบาทของอัลกอริทึม GRPO ในระบบเอเจนต์
• การประมวลผลข้อมูลเบื้องต้นสำหรับเอเจนต์
• การสร้างสถาปัตยกรรมมัลติเอเจนต์
  • กำหนดความคิดของเอเจนต์
  • สร้างชุดเครื่องมือ
  • Solver, Planner, Executor และ Verifier
  • การจัดวงจรการทำงานของเอเจนต์
• วิเคราะห์การหลงผิดในคำถาม
• การนำอัลกอริทึม GRPO สำหรับเอเจนต์ไปปฏิบัติ
  • เริ่มต้นโมเดลนโยบาย (QLoRA & PEFT)
  • ตัวห่อหุ้มระบบเอเจนต์สำหรับการสร้างเส้นทาง
  • ใช้ GPT-4o สำหรับการสร้างแบบจำลองรางวัล
  • สร้างข้อได้เปรียบและความสูญเสีย PPO
• เรียกใช้เอเจนต์วางแผนที่ได้รับการปรับปรุงแล้ว

บทบาทของอัลกอริทึม GRPO ในระบบเอเจนต์

อัลกอริทึมการเรียนรู้แบบเสริมแรงเกือบทั้งหมดอาศัยกลไกรางวัล: เอเจนต์ดำเนินการในสภาพแวดล้อมและได้รับรางวัลหรือการลงโทษตามการกระทำนั้น เป้าหมายคือการเพิ่มรางวัลสะสมให้สูงสุดในมิติเวลา

อย่างไรก็ตาม ในระบบมัลติเอเจนต์ที่มีเอเจนต์หลายตัวโต้ตอบกันและกับสภาพแวดล้อม การเรียนรู้แบบเสริมแรงแบบดั้งเดิมมักไม่สามารถประสานและปรับการกระทำเหล่านี้ให้เหมาะสมได้

GRPO ถูกพัฒนาขึ้นเพื่อแก้ไขความท้าทายบางประการที่การเรียนรู้แบบเสริมแรงแบบดั้งเดิมเผชิญในสถานการณ์มัลติเอเจนต์ ใน GRPO ที่ใช้เอเจนต์เป็นพื้นฐาน แทนที่จะให้คะแนนการกระทำแต่ละอย่างแยกกัน ระบบจะให้เอเจนต์ลองแก้ปัญหาเดียวกันหลายครั้ง (สร้างเป็น “กลุ่ม”) เปรียบเทียบผลลัพธ์เหล่านี้ และเสริมแรงกลยุทธ์ที่ทำได้ดีกว่าค่าเฉลี่ยของกลุ่ม

เรามาทำความเข้าใจด้วยตัวอย่าง (ซึ่งเป็นหัวใจของการนำไปปฏิบัติในบทความนี้):

1. ระบบรับคำถามที่ซับซ้อน เช่น: “คำนวณ 12 กำลังสอง จากนั้นใช้ Wikipedia หาเหตุการณ์ประวัติศาสตร์สำคัญที่เกิดขึ้นในปีนั้น”
2. กลยุทธ์ของตัววางแผนสร้างชุดเส้นทางที่แตกต่างกันสำหรับคำถามเดียวนี้ (เช่น 4 ความพยายาม) เนื่องจากโมเดลใช้อุณหภูมิที่ไม่เป็นศูนย์ มันจะสำรวจกลยุทธ์ต่างๆ: เส้นทางหนึ่งอาจคำนวณ 12^2=144 ถูกต้องโดยใช้ Python อีกเส้นทางอาจเดาค่าผิด และอีกเส้นทางอาจหลงผิดเกี่ยวกับเหตุการณ์ประวัติศาสตร์โดยไม่ทำการค้นหา
3. ผู้ตัดสินภายนอกจะประเมินคำตอบสุดท้ายของแต่ละเส้นทางกับคำตอบจริง เส้นทางที่คำนวณ 144 ได้สำเร็จและพบเหตุการณ์ประวัติศาสตร์ที่ถูกต้องจะได้รับรางวัล = 1.0 ในขณะที่เส้นทางที่เดาผิด การดำเนินการเครื่องมือล้มเหลว หรือคำตอบหลงผิดจะได้รับรางวัล = 0.0
4. อัลกอริทึมคำนวณข้อได้เปรียบสัมพัทธ์โดยเปรียบเทียบกับประสิทธิภาพเฉลี่ยของกลุ่ม หากค่าเฉลี่ยกลุ่มคือ 0.25 เส้นทางที่สำเร็จ (1.0) จะได้รับข้อได้เปรียบบวกสูง (+0.75) และเส้นทางที่ล้มเหลว (0.0) จะได้รับข้อได้เปรียบลบ (-0.25)
5. โมเดลนโยบายอัปเดตน้ำหนักตามสัญญาณข้อได้เปรียบเหล่านี้ เนื่องจากเส้นทางที่สำเร็จทำได้ดีกว่าค่าเฉลี่ยของกลุ่ม มันจึงเพิ่มความน่าจะเป็นของขั้นตอนการวางแผนที่ใช้ในเส้นทางที่สำเร็จอย่างมาก ในขณะเดียวกันก็ยับยั้งกลยุทธ์ที่ล้มเหลว

เราจะเข้ารหัสและนำอัลกอริทึม GRPO ข้างต้นไปใช้ในระบบมัลติเอเจนต์ เพื่อปรับปรุงขั้นตอนการวางแผนและลดผลลัพธ์ที่หลงผิดและออกนอกเรื่อง

การประมวลผลข้อมูลเบื้องต้นสำหรับเอเจนต์

ระบบมัลติเอเจนต์มักประกอบด้วยซับเอเจนต์ที่มีวัตถุประสงค์ต่างกันทำงานร่วมกันเพื่อทำงานให้สำเร็จ ตัวอย่างเช่น อาจมีเอเจนต์ค้นหาเว็บ เอเจนต์วางแผน เอเจนต์ดำเนินงาน เป็นต้น

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

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

เราจะใช้ชุดข้อมูล Hugging Face สองชุดเพื่อเตรียมข้อมูลการฝึก:

1. DeepMath-103K: ประกอบด้วยโจทย์คณิตศาสตร์มากกว่า 100,000 ข้อและคำตอบ สามารถช่วยให้เอเจนต์เรียนรู้การวางแผนเมื่อดำเนินการคำนวณแทนผู้ใช้ ซึ่งจะช่วยสร้างการให้เหตุผลเป็นขั้นตอนที่มีโครงสร้างในขั้นตอนการวางแผน
2. Natural Questions: ประกอบด้วยคำถามจากผู้ใช้จริง ซึ่งช่วยเพิ่มความสามารถของเอเจนต์ในการวางแผนกระบวนการทั้งหมด

ขั้นแรก นำเข้า dependency ที่จำเป็นและสร้างไดเรกทอรีเอาต์พุตสำหรับข้อมูลการฝึก/ตรวจสอบ

python

Standard library imports for interacting with the operating system and handling JSON data.

import os
import json

Core data science libraries for data manipulation and numerical computation.

import pandas as pd
import numpy as np

Hugging Face library for dataset loading and processing.

from datasets import load_dataset, concatenate_datasets, Dataset

Utility for displaying progress bars, making long-running operations more informative.

from tqdm import tqdm

สร้างไดเรกทอรีข้อมูลการฝึกและตรวจสอบ:

python

Define the path for the training data output directory.

train_output_dir = “./data/train”

Define the path for the validation data output directory.

val_output_dir = “./data/val”

ไดเรกทอรีการฝึกจะเก็บชุดข้อมูลการฝึกที่รวม DeepMath และ NQ เข้าด้วยกัน ไดเรกทอรีตรวจสอบจะเก็บชุดข้อมูลตรวจสอบ AIME 2024

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

จัดการ DeepMath-103K ก่อน โหลดและดูโครงสร้าง:

python
print(“n=== Loading DeepMath-103K ===”)

math_dataset = load_dataset(
“zwhe99/DeepMath-103K”,
split=”train”
)

ก่อนประมวลผล ให้ตรวจสอบชื่อคอลัมน์ จำนวนตัวอย่าง และเรกคอร์ดเดี่ยว:

python
print("Columns:", math_dataset.column_names)
print("Total samples:", len(math_dataset))

ตัวอย่างผลลัพธ์:
Columns: ['question', 'final_answer', 'difficulty', 'topic', 'r1_solution_1', 'r1_solution_2', 'r1_solution_3']
Total samples: 103022

จะเห็นว่าแต่ละปัญหามี question และคำตอบสามแบบที่แตกต่างกัน พร้อมกับ final_answer (ซึ่งจะใช้เป็น ground truth สำหรับการฝึก)

ดูตัวอย่างหนึ่งรายการ:

python
sample = math_dataset[0]
...
print(json.dumps(truncated_sample, indent=2))

ตัวอย่างผลลัพธ์ถูกย่อไว้ ที่นี่เราไม่ใช้ r1_solution_* สำหรับการฝึก เราใช้เพียง question และ final_answer เนื่องจากเอเจนต์ของเราจะรันโค้ดและพยายามหาคำตอบสุดท้าย

แปลงแต่ละเรกคอร์ดเป็นรูปแบบมาตรฐานเพื่อให้ง่ายต่อการรวมกับชุดข้อมูลอื่นในภายหลัง Schema เป้าหมาย:
* id: ตัวระบุเฉพาะ
* question: ข้อความคำถาม
* chain: ตัวยึดสำหรับ Chain-of-Thought หรือขั้นตอนการให้เหตุผล (เว้นว่างไว้ชั่วคราว)
* result: คำตอบสุดท้าย
* source: แหล่งที่มาของข้อมูลดั้งเดิม
* extra_info: เก็บข้อมูลเมตาดั้งเดิม

python
print("n=== Processing MathHard ===")
...

หลังจากประมวลผลเสร็จ ให้ตรวจสอบจำนวนตัวอย่างและโครงสร้าง:

python
print("Processed math samples:", len(math_rows))
print(json.dumps(math_rows[0], indent=2))

แปลงรายการเป็น Hugging Face Dataset:

python
ds_math = Dataset.from_pandas(
pd.DataFrame(math_rows),
preserve_index=False
)

จากนั้นจัดการ Natural Questions (NQ) โหลดและดูตัวอย่างหนึ่งรายการ:

python
nq_dataset = load_dataset(
“RUC-NLPIR/FlashRAG_datasets”,
“nq”,
split=”train”
)

print(json.dumps(nq_dataset[0], indent=2))

จะเห็นว่า question คือคำถามผู้ใช้ golden_answers คือรายการคำตอบ ทำความสะอาด NQ:
1. เพิ่มเครื่องหมายคำถามให้กับคำถามทั้งหมด
2. จัดการรูปแบบต่างๆ ของ golden_answers (list, ndarray, string, number…) และแยกออกมาเป็นสตริง
3. เชื่อมคำตอบหลายคำตอบด้วยเครื่องหมายอัฒภาคเป็นสตริงเดียว

python
print("n=== Processing NQ ===")
...

ตรวจสอบผลลัพธ์การประมวลผลและแปลงเป็น Dataset:

python
print(json.dumps(nq_rows[0], indent=2))

ds_nq = Dataset.from_pandas(
pd.DataFrame(nq_rows),
preserve_index=False
)

รวมชุดข้อมูลทั้งสอง สับเปลี่ยนและจัดเรียง id ใหม่:

python
combined = concatenate_datasets([ds_nq, ds_math])
print(“Combined size:”, len(combined))

combined = combined.shuffle(seed=42)
combined = combined.map(
lambda _, idx: {“id”: idx},
with_indices=True
)

บันทึกในรูปแบบ Parquet:

python
output_path = os.path.join(train_output_dir, "combined_train.parquet")
combined.to_parquet(output_path)

ตรวจสอบจำนวนตัวอย่างทั้งหมด:

python
train_count = len(combined)
print(f"nTotal train samples: {train_count}")

เรารวม DeepMath-103K และ NQ สำเร็จเป็นชุดฝึกที่มีตัวอย่าง 182,190 รายการ สำหรับใช้ในการฝึกต่อไป

การสร้างสถาปัตยกรรม Multi-Agentic

เวิร์กโฟลว์แบบ Agentic (ระบบมัลติเอเจนต์) หมายถึงเฟรมเวิร์กที่ประกอบด้วยชุดคอมโพเนนต์เฉพาะทาง (เอเจนต์) ที่ทำงานร่วมกันเพื่อแก้ปัญหา แทนที่จะพึ่งพาการเรียกใช้โมเดลภาษาขนาดใหญ่ครั้งเดียว มันจะแบ่งปัญหาที่ซับซ้อนออกเป็นหลายขั้นตอนที่จัดการได้:

Multi-Agent System (Created by Fareed Khan)

1. การวางแผน: วิเคราะห์คำถามเริ่มต้น สร้างแผนระดับสูงหรือตัดสินใจการกระทำต่อไป
2. การใช้เครื่องมือ: เลือกและเรียกใช้เครื่องมือเฉพาะทาง (เช่น ตัวแปลโค้ด การค้นหาเว็บ การสืบค้นฐานข้อมูล เป็นต้น)
3. การดำเนินการ: สร้างคำสั่งเรียกใช้เครื่องมือที่แม่นยำ
4. การสังเกตและการสะท้อนคิด: สังเกตผลลัพธ์การดำเนินการเครื่องมือ ตัดสินใจว่าเป้าหมายบรรลุผลหรือต้องการขั้นตอนเพิ่มเติมหรือไม่
5. การวนซ้ำ: วนซ้ำไปเรื่อยๆ จนกว่าตัวตรวจสอบจะตัดสินว่าปัญหาได้รับการแก้ไขอย่างสมบูรณ์
6. การสังเคราะห์: สรุปข้อมูลจากกระบวนการทั้งหมด ให้คำตอบสุดท้าย

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

สภาพแวดล้อมการทดลองใช้ GPU A100 80GB 1 ตัว โมเดลวางแผนเลือก Qwen/Qwen2.5-7B-Instruct; ลิงก์อื่นๆ

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