在当下AI Agent落地场景中，绝大多数多智能体系统都存在一个共性痛点，长期复杂任务的规划稳定性极差。无论是多工具协同检索、数学推理加信息核验的复合任务，还是多子智能体分工协作的落地场景，常规Agent架构都容易出现规划错乱、工具滥用、内容幻觉、步骤偏离等问题。
深究根源，传统Agent的推理模式存在致命短板，每一次任务迭代、每一次工具调用都属于从零推理，没有历史最优策略的沉淀，也没有错误行为的定向抑制。同时传统强化学习算法适配多智能体场景时，存在奖励赋值模糊、梯度方差大、多主体协同优化难的问题，导致智能体无法在长期任务中迭代进化，只能依赖单次Prompt约束，容错率极低。
而GRPO，组相对策略优化算法的出现，彻底补齐了这一短板。作为适配大模型智能体训练的新型强化学习方案，它跳出了传统单轨迹、单奖励的优化逻辑，通过组内对比、相对优势学习、错误轨迹抑制的核心机制，让多智能体系统能够自主迭代优化任务规划、工具调用、协同配合能力。
本文结合完整实战项目，从算法核心逻辑、数据集预处理、多智能体架构搭建、GRPO训练循环实现、模型迭代优化到落地效果验证，完整拆解一套可直接复用的多智能体GRPO训练方案，全程附带可运行代码与实战踩坑经验，帮大家彻底掌握AI Agent长期任务优化的核心思路。
一、为什么传统多智能体训练方案普遍失效
在正式切入GRPO实战之前，我们需要先理清传统方案的核心缺陷，才能理解GRPO的优化价值，避免盲目套用算法。
常规多智能体系统的运行逻辑很简单，依靠规划、执行、检索、核验多个子智能体分工，单次接收用户查询后，实时拆解任务、调用工具、执行推理、输出结果。整个过程属于"单次推理模式"，没有预训练沉淀，没有迭代优化机制。
这种模式在简单单步任务中可以正常使用，但面对复杂多步骤任务，比如先数学计算、再检索历史信息、最后整合答案的复合需求，会暴露三大核心问题。
第一，规划逻辑无沉淀，随机性极强。大模型本身的采样随机性，会导致同一查询每次的任务拆解顺序、工具选择逻辑完全不同。有时先计算后检索，有时盲目先检索再计算，步骤错乱直接导致任务失败。
第二，错误行为无抑制，幻觉问题频发。传统方案只会对最终正确结果给予正向反馈，不会对中间错误步骤、无效工具调用、幻觉生成行为做惩罚。智能体长期积累错误推理习惯，越复杂的任务，幻觉概率越高。
第三，多子智能体协同混乱，全局最优难达成。多智能体场景下，不同子智能体各司其职，传统强化学习算法采用单轨迹绝对奖励机制，无法精准区分单个智能体的贡献，出现奖励分配模糊、梯度噪声大的问题，容易出现局部最优、整体失效的情况，子智能体之间无法形成高效协同。
市面上绝大多数Agent项目，都试图通过优化Prompt、增加规则约束、细化工具描述来解决上述问题，但本质都是治标不治本。规则约束无法覆盖所有复杂场景，Prompt优化无法改变模型的推理权重，只有通过针对性的强化学习训练，让模型自主学习最优规划策略、抑制错误行为，才能从根本上提升多智能体系统的稳定性。
而GRPO算法，正是为解决大模型智能体规划优化、多主体协同、错误抑制场景量身打造的强化学习方案。
二、GRPO核心原理：用组内对比实现智能体自主进化
GRPO全称组相对策略优化，是在PPO近端策略优化算法基础上迭代优化而来，专门适配大模型Agent训练、多智能体协同优化的新型算法。和传统RL算法相比，它最大的革新是抛弃了"单轨迹绝对奖励优化"的逻辑，转而采用"多轨迹组内相对对比优化"的核心思路，完美适配Agent的多步骤推理、工具调用场景。
结合多智能体任务场景，我们可以把GRPO的核心机制拆解为五个通俗易懂的核心能力，也是它能完胜传统算法的关键。
2.1 基于群组的多轨迹评估机制
传统RL训练时，针对单个查询只会生成一条推理轨迹，系统根据这条轨迹的最终结果给出0或1的绝对奖励，模型只能基于单次结果更新参数。这种方式的缺陷非常明显，单次结果存在极大偶然性，无法区分"运气正确"和"策略正确"，优化精度极低。
GRPO采用群组采样逻辑，针对同一个用户查询，强制智能体生成多条不同的推理轨迹，项目实战中默认设置每组4条轨迹。由于大模型采样温度非零，每条轨迹的任务规划、工具调用、推理步骤都会存在差异，有的轨迹逻辑通顺、步骤正确、结果精准，有的轨迹步骤错乱、工具滥用、存在幻觉错误。
系统会统一评估同一群组内所有轨迹的完成质量，不再孤立评判单条轨迹的好坏，而是通过横向对比，精准筛选出最优推理策略和劣质错误策略，让模型有明确的学习参照物。
2.2 相对优势学习，告别绝对奖励偏差
这是GRPO最核心的创新点。传统算法依赖绝对奖励打分，简单任务容易全员高分、无优化空间，复杂任务容易全员低分、无有效学习信号，梯度方差极大，训练极不稳定。
GRPO不直接使用原始奖励更新模型，而是通过组内均值、标准差做归一化处理，计算每条轨迹的相对优势值。简单来说，它不看这条轨迹"绝对好不好"，只看它"比同组平均水平好多少、差多少"。
举个实战场景的例子，同一群组4条轨迹，平均奖励0.25，最优轨迹奖励1.0，相对优势为+0.75，会被大幅强化，劣质轨迹奖励0.0，相对优势为-0.25，会被定向抑制。通过这种方式，无论任务难度高低，每组都能生成有效的正负优化信号，彻底解决奖励失效、梯度噪声大的问题。
核心计算公式简洁高效，也是后续代码实现的核心逻辑：
Plain
# GRPO相对优势核心计算逻辑
rewards_tensor = torch.tensor(group_rewards, device=device, dtype=torch.float32)
mean_reward = rewards_tensor.mean()
std_reward = rewards_tensor.std() + 1e-8 # 极小值防止除零报错
advantages = (rewards_tensor - mean_reward) / std_reward2.3 定向错误抑制，根治Agent幻觉与步骤偏离
在多智能体任务中，幻觉生成、无效工具调用、步骤颠倒、中途跑偏是最常见的问题。传统训练方式无法精准惩罚中间错误行为，导致模型反复踩坑。
GRPO通过相对优势机制实现了精细化的行为调控，优于群组均值的正确轨迹，推理逻辑、工具调用步骤、规划方式对应的模型权重会被强化，劣于均值的错误轨迹，包括幻觉输出、无效检索、步骤错乱、重复调用工具等行为，都会得到负向优势信号，模型会自动降低这类行为的出现概率。
长期迭代后，模型会自主沉淀最优任务规划范式，主动规避无效操作和幻觉输出，大幅提升复杂任务的推理稳定性。
2.4 迭代式Rollout优化，适配长期任务
长期复杂任务的核心特点是步骤多、链路长、单一错误即可导致全局失败。GRPO支持多轮迭代Rollout机制，智能体可以反复执行任务、生成轨迹、对比优化，每一轮迭代都会细化规划逻辑、修正错误细节，逐步提升长链路任务的完成精度。
2.5 多智能体协同优化，解决子模块配合混乱问题
针对多子智能体协作场景，GRPO的群组对比机制可以让不同功能的子智能体，包括规划智能体、执行智能体、检索智能体、核验智能体，在同一任务群组中相互适配、协同优化。通过组内相对评分，精准优化各子智能体的分工逻辑、调用时机、配合节奏，解决传统多智能体各自为战、协同错乱的问题。
三、项目整体架构与代码目录说明
本次实战项目完整实现了"数据预处理、多智能体架构搭建、GRPO训练、模型部署推理、效果验证"的全链路流程，所有代码开源可复用，整体目录结构清晰，分工明确，方便二次开发和迭代优化。
项目核心目录结构如下：
Plain
GRPO_Training_Agentic/
├── 01_data_preprocessing.ipynb # 训练数据集清洗、合并、标准化
├── 02_agentic_architecture.ipynb # 多智能体核心架构、工具集、结构化定义
├── 03_grpo_training.ipynb # GRPO完整训练循环、损失计算、参数更新
└── utils.py # 智能体训练通用工具函数整个项目的核心逻辑可以分为四大模块，分别是数据层、架构层、训练层、推理验证层，层层递进，完全贴合工业级Agent训练落地规范。
四、训练数据预处理：构建多场景通用训练数据集
模型训练的效果上限，永远由数据集质量决定。针对多智能体复杂任务规划场景，我们需要模型同时具备数学推理、真实信息检索、多步骤任务拆解能力，因此本次训练选用两个高质量开源数据集做融合处理。
第一个是DeepMath-103K数据集，包含10.3万道各类数学题目及标准答案，覆盖极限、代数、几何等多类型题型，主要用于训练智能体的结构化推理、分步计算、代码工具调用能力，解决数学类任务的规划错乱问题。
第二个是Natural Questions数据集，收录谷歌真实用户的检索问题与维基百科标准答案，用于训练智能体的信息检索、工具调用、真实场景任务规划能力，适配生活化、场景化的复杂查询。
我们需要对两个数据集做统一清洗、格式标准化、合并洗牌处理，最终生成18万+高质量训练样本，适配GRPO多轨迹训练需求。
4.1 环境依赖与目录初始化
首先导入项目所需核心依赖，创建训练集、验证集存储目录，保证后续数据读写规范化。
Plain
# 基础库导入
import os
import json
import pandas as pd
import numpy as np
from datasets import load_dataset, concatenate_datasets, Dataset
from tqdm import tqdm
# 创建数据存储目录
train_output_dir = "./data/train"
val_output_dir = "./data/val"
os.makedirs(train_output_dir, exist_ok=True)
os.makedirs(val_output_dir, exist_ok=True)4.2 DeepMath-103K数据集标准化处理
原始数学数据集包含题目、多套解法、难度、话题、标准答案等字段，训练中我们仅保留question和final_answer核心字段，同时统一数据格式，适配智能体训练的通用schema。
标准化schema包含id、question、chain、result、source、extra_info六个字段，其中chain为推理步骤占位符，后续训练中自动填充，source标记数据来源，方便溯源分析。
Plain
# 加载数学数据集
print("\n=== Loading DeepMath-103K ===")
math_dataset = load_dataset(
"zwhe99/DeepMath-103K",
split="train"
)
print("数据集字段：", math_dataset.column_names)
print("样本总数：", len(math_dataset))
# 数据标准化处理
math_rows = []
for idx, item in enumerate(tqdm(math_dataset, desc="Processing Math Dataset")):
question = item["question"]
answer = item["final_answer"]
math_rows.append({
"id": idx,
"question": question,
"chain": "",
"result": str(answer),
"source": "mathhard",
"extra_info": {
"ground_truth": str(answer),
"idx": idx
}
})
# 转换为Hugging Face标准数据集格式
ds_math = Dataset.from_pandas(
pd.DataFrame(math_rows),
preserve_index=False
)4.3 Natural Questions数据集清洗与适配
检索类数据集的清洗难度更高，原始数据存在答案格式不统一、问句无标点、多答案混杂等问题，需要针对性做格式规整、答案合并、异常过滤处理。
Plain
# 加载检索数据集
print("\n=== Loading Natural Questions Dataset ===")
nq_dataset = load_dataset(
"RUC-NLPIR/FlashRAG_datasets",
"nq",
split="train"
)
# 数据清洗与标准化
nq_rows = []
for idx, item in enumerate(tqdm(nq_dataset, desc="Processing NQ Dataset")):
# 规整问句格式
question = item.get("question", "").strip()
if question and not question.endswith("?"):
question += "?"
# 统一答案格式，兼容多类型输入
golden_answers = item.get("golden_answers", [])
cleaned_answers = []
if isinstance(golden_answers, np.ndarray):
for x in golden_answers.flatten():
if x is not None and pd.notna(x):
cleaned_answers.append(str(x))
elif isinstance(golden_answers, (list, tuple)):
for x in golden_answers:
if x is not None and pd.notna(x):
cleaned_answers.append(str(x))
elif isinstance(golden_answers, str) and golden_answers.strip():
cleaned_answers.append(golden_answers.strip())
elif isinstance(golden_answers, (int, float, np.generic)) and not pd.isna(golden_answers):
cleaned_answers.append(str(golden_answers))
final_result = "; ".join(cleaned_answers)
nq_rows.append({
"id": idx,
"question": question,
"chain": "",
"result": final_result,
"source": "nq",
"extra_info": {
"ground_truth": final_result,
"idx": idx
}
})
ds_nq = Dataset.from_pandas(
pd.DataFrame(nq_rows),
preserve_index=False
)4.4 数据集合并、洗牌与持久化存储
两个数据集单独处理完成后，需要合并为统一训练集，同时做全局洗牌、重新索引，避免模型按数据顺序学习，防止过拟合。最终采用Parquet格式存储，兼顾读写速度与压缩效率，适配大规模训练场景。
Plain
# 数据集合并
combined = concatenate_datasets([ds_nq, ds_math])
print(f"\n合并后总样本数：{len(combined)}")
# 全局洗牌，固定随机种子保证可复现
combined = combined.shuffle(seed=42)
# 重新生成唯一索引
combined = combined.map(
lambda _, idx: {"id": idx},
with_indices=True
)
# 保存为parquet格式
output_path = os.path.join(train_output_dir, "combined_train.parquet")
combined.to_parquet(output_path)
print(f"训练数据集已保存，总样本量：{len(combined)}")处理完成后，我们得到包含182190条多场景样本的高质量训练集，同时覆盖数学推理、真实检索两大核心场景，完美匹配多智能体系统的训练需求。
五、多智能体架构搭建：分工明确的模块化Agent系统
本次项目搭建了一套标准化、可扩展的多智能体协作架构，摒弃单一模型全包的模式，拆分出规划、执行、核验、工具调用四大核心模块，同时封装通用工具集，实现任务拆解、工具调用、结果核验、答案合成的全自动化流程。
整套架构基于vLLM部署推理模型，选用Qwen2.5-7B-Instruct作为核心规划与执行模型，兼顾推理速度与效果，支持高并发、低延迟的模型调用，适配训练阶段的高频迭代需求。
5.1 基础环境与模型服务部署
首先安装项目所需全部依赖，启动vLLM模型服务，为后续智能体推理、训练提供模型支撑。
Plain
# 安装核心依赖
!pip install -q openai pydantic tenacity beautifulsoup4 requests wikipedia google-genai numpy json_repair datasets torch peft transformers
# 启动vLLM模型服务
vllm serve Qwen/Qwen2.5-7B-Instruct \
--api-key a-secret-key \
--port 8000 \
--max-model-len 81925.2 核心配置与LLM引擎封装
为了实现模型调用解耦、统一接口规范，我们封装通用LLM引擎类，支持自动重试、结构化JSON输出、异常修复等能力，为所有智能体模块提供统一调用入口。
Plain
import re
import sys
import threading
from io import StringIO
from typing import Any, Dict, List, Union, Optional, Tuple
from abc import ABC, abstractmethod
from pydantic import BaseModel
from openai import OpenAI
from tenacity import retry, stop_after_attempt, wait_random_exponential
import requests
from bs4 import BeautifulSoup
import wikipedia
from google import genai
import numpy as np
import json_repair
# 核心服务配置
VLLM_BASE_URL = "http://localhost:8000"
VLLM_API_KEY = "a-secret-key"
MODEL_NAME = "Qwen/Qwen2.5-7B-Instruct"
# 抽象LLM引擎基类
class EngineLM(ABC):
def __call__(self, *args, **kwargs):
return self.generate(*args, **kwargs)
@abstractmethod
def generate(self, prompt, system_prompt=None, **kwargs):
pass
# vLLM推理引擎实现
class ChatVLLM(EngineLM):
def __init__(self, model_string, base_url, api_key, temperature=0.0):
self.model_string = model_string
self.base_url = base_url
self.api_key = api_key
self.temperature = temperature
self.client = OpenAI(base_url=self.base_url, api_key=self.api_key)
self.default_system_prompt = "You are a helpful, creative, and smart assistant."
@retry(wait=wait_random_exponential(min=1, max=5), stop=stop_after_attempt(3))
def generate(self, content: Union[str, List[Union[str, bytes]]], system_prompt=None, response_format=None, **kwargs):
sys_prompt_arg = system_prompt if system_prompt else self.default_system_prompt
messages = [
{"role": "system", "content": sys_prompt_arg},
{"role": "user", "content": content}
]
request_params = {
"model": self.model_string,
"messages": messages,
"temperature": self.temperature,
"max_tokens": kwargs.get("max_tokens", 4096),
}
# 结构化输出约束
if response_format and issubclass(response_format, BaseModel):
json_schema = response_format.model_json_schema()
schema_instruction = (f"\n\nPlease format your entire response as a single JSON object that strictly adheres to the following Pydantic schema.\n"+
f"Do not include any other text, explanations, or markdown formatting outside of the JSON object.\n\n"+
f"Schema:\n```json\n{json.dumps(json_schema, indent=2)}\n```")
if isinstance(request_params['messages'][-1]['content'], str):
request_params['messages'][-1]['content'] += schema_instruction
response = self.client.chat.completions.create(**request_params)
response_text = response.choices[0].message.content
# JSON解析与异常修复
if response_format and issubclass(response_format, BaseModel):
match = re.search(r"```json\s*(.*?)\s*```", response_text, re.DOTALL)
json_str = match.group(1) if match else response_text
try:
parsed_obj = response_format.model_validate_json(json_str.strip())
return parsed_obj
except Exception:
try:
decoded_obj = json_repair.loads(json_str)
parsed_obj = response_format.model_validate(decoded_obj)
return parsed_obj
except Exception as e2:
return response_text
return response_text
# 引擎工厂函数
def create_llm_engine(model_string: str, **kwargs) -> ChatVLLM:
return ChatVLLM(model_string=model_string, base_url=VLLM_BASE_URL, api_key=VLLM_API_KEY, temperature=kwargs.get('temperature', 0.0))
# 连接测试
test_engine = create_llm_engine(MODEL_NAME)
test_response = test_engine.generate("Ping")
print("✅ 模型服务连接成功")5.3 结构化数据模型定义
为了保证多智能体之间的通信规范、参数合法，我们通过Pydantic定义全套结构化交互模型，覆盖查询分析、步骤规划、工具指令、结果核验全流程，实现类型安全、自动校验。
Plain
# 查询分析结构化模型
class QueryAnalysis(BaseModel):
concise_summary: str
required_skills: str
relevant_tools: str
additional_considerations: str
# 下一步行动规划模型
class NextStep(BaseModel):
justification: str
context: str
sub_goal: str
tool_name: str
# 工具执行指令模型
class ToolCommand(BaseModel):
analysis: str
explanation: str
command: str
# 结果核验模型
class MemoryVerification(BaseModel):
analysis: str
stop_signal: bool
# 维基检索匹配模型
class Select_Relevant_Queries(BaseModel):
matched_queries: list[str]
matched_query_ids: list[int]5.4 工具集封装：多场景能力全覆盖
工具是智能体与外部环境交互的核心，我们封装四大核心工具，覆盖通用问答、代码计算、全网检索、维基百科精准检索，同时实现沙箱执行、超时保护、RAG检索、结果截断序列化等能力，保证工具调用安全、高效、精准。
所有工具继承统一基类，接口标准化，支持灵活扩展，后续可快速新增数据库查询、文件处理等自定义工具。
Plain
# 工具抽象基类
class BaseTool(ABC):
require_llm_engine = False
def __init__(self, tool_name=None, tool_description=None, tool_version=None, input_types=None, output_type=None, demo_commands=None, user_metadata=None, model_string=None):
self.tool_name, self.tool_description, self.tool_version = tool_name, tool_description, tool_version
self.input_types, self.output_type = input_types, output_type
self.demo_commands, self.user_metadata, self.model_string = demo_commands, user_metadata, model_string
def get_metadata(self) -> dict:
return {"tool_name": self.tool_name, "tool_description": self.tool_description, "tool_version": self.tool_version, "input_types": self.input_types, "output_type": self.output_type, "demo_commands": self.demo_commands, "user_metadata": self.user_metadata, "require_llm_engine": self.require_llm_engine}
@abstractmethod
def execute(self, *args, **kwargs):
raise NotImplementedError
# 通用问答工具
class Base_Generator_Tool(BaseTool):
require_llm_engine = True
def __init__(self, model_string="gpt-4o-mini"):
super().__init__(
tool_name="Generalist_Solution_Generator_Tool",
tool_description="通用问答工具，用于解答基础问题",
tool_version="1.0.0",
input_types={"query": "str"},
output_type="str"
)
self.llm_engine = create_llm_engine(model_string, temperature=0.0)
def execute(self, query, **kwargs):
return self.llm_engine.generate([query])
# 超时异常与上下文管理器
class TimeoutException(Exception):
pass
@contextmanager
def timeout(seconds):
def raise_timeout(signum, frame):
raise TimeoutException("代码执行超时")
timer = threading.Timer(seconds, lambda: raise_timeout(None, None))
timer.start()
try:
yield
finally:
timer.cancel()
# Python代码执行工具（沙箱安全执行）
class Python_Coder_Tool(BaseTool):
require_llm_engine = True
def __init__(self, model_string="gpt-4o"):
super().__init__(
tool_name="Python_Code_Generator_Tool",
tool_description="生成并执行Python代码，用于数学计算、逻辑运算",
tool_version="1.0.0",
input_types={"query": "str"},
output_type="dict"
)
self.llm_engine = create_llm_engine(model_string, temperature=0.0)
def execute(self, query, **kwargs):
task_description = "根据查询生成可执行的Python代码，打印最终结果，仅输出markdown代码块"
full_prompt = f"Task:\n{task_description}\n\nQuery:\n{query}"
response = self.llm_engine.generate(full_prompt)
match = re.search(r"```python\s*(.*?)\s*```", response, re.DOTALL)
if not match:
return {"error": "未检测到有效Python代码", "raw_response": response}
code_snippet = match.group(1).strip()
output_capture = StringIO()
old_stdout, old_stderr = sys.stdout, sys.stderr
local_vars = {}
try:
sys.stdout = sys.stderr = output_capture
with timeout(10):
exec(code_snippet, {}, local_vars)
printed_output = output_capture.getvalue().strip()
return {"printed_output": printed_output, "variables": {k: repr(v) for k, v in local_vars.items() if not k.startswith('__')}}
except TimeoutException as e:
return {"error": str(e), "code": code_snippet}
except Exception as e:
return {"error": str(e), "code": code_snippet, "captured_output": output_capture.getvalue().strip()}
finally:
sys.stdout, sys.stderr = old_stdout, old_stderr
# 谷歌全网搜索工具
class Google_Search_Tool(BaseTool):
def __init__(self, model_string="gemini-1.5-flash"):
super().__init__(
tool_name="Ground_Google_Search_Tool",
tool_description="全网实时信息检索工具",
tool_version="1.0.0",
input_types={"query": "str"},
output_type="str"
)
self.search_model = model_string
if not os.getenv("GOOGLE_API_KEY") or 'YOUR_GOOGLE_API_KEY' in os.getenv("GOOGLE_API_KEY"):
print("警告：谷歌搜索工具已进入模拟模式")
self.client = None
else:
genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
self.client = genai.GenerativeModel(self.search_model)
def execute(self, query: str, add_citations: bool = True, **kwargs):
if not self.client:
return f"[模拟检索结果] 检索关键词：{query}"
try:
grounding_tool = genai.Tool(google_search=genai.GoogleSearch())
response = self.client.generate_content(query, tools=[grounding_tool])
return response.text
except Exception as e:
return f"检索失败：{str(e)}"
# 维基百科RAG检索工具
class Wikipedia_Search_Tool(BaseTool):
require_llm_engine = True
def __init__(self, model_string="gpt-4o-mini"):
super().__init__(
tool_name="Wikipedia_RAG_Search_Tool",
tool_description="维基百科精准检索，结合RAG提炼有效信息",
tool_version="1.0.0",
input_types={"query": "str"},
output_type="dict"
)
self.llm_engine = create_llm_engine(model_string, temperature=0.0)
self.web_rag_tool = Web_Search_Tool(model_string=model_string)
def execute(self, query, **kwargs):
try:
search_results = wikipedia.search(query, results=10)
if not search_results:
return {"error": f"未检索到{query}相关维基百科条目"}
query_candidates_str = "\n".join([f"{i}. {q}" for i, q in enumerate(search_results)])
prompt = f"从以下检索结果中筛选3个最匹配用户查询的条目：{query}\n候选列表：{query_candidates_str}"
selection = self.llm_engine.generate(prompt, response_format=Select_Relevant_Queries)
if not isinstance(selection, Select_Relevant_Queries):
selection = Select_Relevant_Queries(matched_queries=[search_results[0]], matched_query_ids=[0])
relevant_pages = []
for title in selection.matched_queries:
try:
page = wikipedia.page(title, auto_suggest=False)
info = self.web_rag_tool.execute(query=query, url=page.url)
relevant_pages.append({"title": title, "url": page.url, "retrieved_information": info})
except Exception as page_e:
relevant_pages.append({"title": title, "url": f"https://en.wikipedia.org/wiki/{title.replace(' ', '_')}", "error": str(page_e)})
return {"query": query, "relevant_pages": relevant_pages}
except Exception as e:
return {"error": f"维基检索失败：{str(e)}"}5.5 多智能体编排核心：Solver调度系统
Solver是整个多智能体系统的核心调度中枢，负责统筹规划、执行、核验、合成四大模块，实现完整的任务闭环。它会初始化所有模型引擎、工具集、记忆模块，循环执行任务推理流程，直到任务完成或达到最大步骤数。
同时新增记忆模块，全程记录智能体的每一步操作、工具调用、执行结果，为GRPO训练提供完整的轨迹数据。
Plain
# 智能体记忆模块
class Memory:
def __init__(self):
self.actions: Dict[str, Dict[str, Any]] = {}
def add_action(self, step_count: int, tool_name: str, sub_goal: str, command: str, result: Any) -> None:
self.actions[f"Action Step {step_count}"] = {
'tool_name': tool_name,
'sub_goal': sub_goal,
'command': command,
'result': result
}
def get_actions(self) -> Dict[str, Dict[str, Any]]:
return self.actions
# 数据序列化工具
def make_json_serializable_truncated(obj, max_length: int = 2000):
if isinstance(obj, (int, float, bool, type(None))): return obj
elif isinstance(obj, str): return obj if len(obj) <= max_length else obj[:max_length - 3] + "..."
elif isinstance(obj, dict): return {str(k): make_json_serializable_truncated(v, max_length) for k, v in obj.items()}
elif isinstance(obj, list): return [make_json_serializable_truncated(element, max_length) for element in obj]
else:
result = repr(obj)
return result if len(result) <= max_length else result[:max_length - 3] + "..."
# 工具初始化器
class Initializer:
def __init__(self, enabled_tools: List[str], tool_engine: List[str], model_string: str):
self.toolbox_metadata, self.tool_instances_cache, self.available_tools = {}, [], []
self._set_up_tools(enabled_tools, tool_engine, model_string)
def _set_up_tools(self, enabled_tools: List[str], tool_engine: List[str], model_string: str):
all_tool_classes = {
"Base_Generator_Tool": Base_Generator_Tool,
"Python_Coder_Tool": Python_Coder_Tool,
"Google_Search_Tool": Google_Search_Tool,
"Wikipedia_RAG_Search_Tool": Wikipedia_Search_Tool
}
for i, tool_class_name in enumerate(enabled_tools):
if tool_class_name in all_tool_classes:
engine = tool_engine[i] if i < len(tool_engine) else model_string
instance = all_tool_classes[tool_class_name]() if engine == "Default" else all_tool_classes[tool_class_name](model_string=engine)
ext_name = instance.tool_name
self.tool_instances_cache[ext_name] = instance
self.toolbox_metadata[ext_name] = instance.get_metadata()
self.available_tools.append(ext_name)
print("✅ 工具集初始化完成")
# 核心调度器
class Solver:
def __init__(self, planner_main_engine, planner_fixed_engine, verifier_engine, executor_engine, enabled_tools, tool_engine, max_steps=5):
self.max_steps = max_steps
# 初始化各角色模型引擎
self.llm_planner_main = create_llm_engine(planner_main_engine)
self.llm_planner_fixed = create_llm_engine(planner_fixed_engine)
self.llm_verifier = create_llm_engine(verifier_engine)
self.llm_executor = create_llm_engine(executor_engine)
# 初始化工具集
initializer = Initializer(enabled_tools, tool_engine, planner_main_engine)
self.tool_instances_cache = initializer.tool_instances_cache
self.toolbox_metadata = initializer.toolbox_metadata
self.available_tools = initializer.available_tools
# 初始化记忆模块
self.memory = Memory()
# 步骤0：查询全局分析
def solve_step_0_analyze(self, question: str) -> QueryAnalysis:
self.memory.actions.clear()
prompt_analyze_query = f"""分析用户查询，明确任务目标、所需技能、适配工具和注意事项。
查询：{question}
可用工具：{json.dumps(self.available_tools)}
工具元数据：{json.dumps(self.toolbox_metadata, indent=2)}"""
query_analysis = self.llm_planner_fixed.generate(prompt_analyze_query, response_format=QueryAnalysis)
return query_analysis
# 步骤1：任务规划
def solve_step_1_plan(self, question: str, query_analysis: QueryAnalysis, step_count: int) -> NextStep:
prompt_next_step = f"""结合历史操作与当前任务，规划最优下一步动作。
查询：{question}
任务分析：{query_analysis}
可用工具：{json.dumps(self.available_tools)}
工具元数据：{json.dumps(self.toolbox_metadata, indent=2)}
历史操作：{json.dumps(self.memory.get_actions())}"""
next_step = self.llm_planner_main.generate(prompt_next_step, response_format=NextStep)
return next_step
# 步骤2：生成执行指令
def solve_step_2_generate_command(self, question: str, next_step: NextStep, step_count: int) -> str:
prompt_tool_command = f"""根据子目标生成精准的工具执行代码。
查询：{question}
子目标：{next_step.sub_goal}
工具名称：{next_step.tool_name}
工具元数据：{self.toolbox_metadata.get(next_step.tool_name, {})}
上下文数据：{next_step.context}"""
tool_command_obj = self.llm_executor.generate(prompt_tool_command, response_format=ToolCommand)
return tool_command_obj.command.strip()
# 步骤3：执行工具指令
def solve_step_3_execute_command(self, next_step: NextStep, command_to_run: str, step_count: int):
tool_instance = self.tool_instances_cache.get(next_step.tool_name)
local_context = {'tool': tool_instance}
result = ""
if not tool_instance:
result = f"错误：未找到工具{next_step.tool_name}"
else:
try:
exec(command_to_run, {}, local_context)
result = local_context.get('execution', "错误：未获取执行结果")
except Exception as e:
result = f"执行异常：{str(e)}"
serializable_result = make_json_serializable_truncated(result)
self.memory.add_action(step_count, next_step.tool_name, next_step.sub_goal, command_to_run, serializable_result)
return serializable_result
# 步骤4：结果核验
def solve_step_4_verify(self, question: str, query_analysis: QueryAnalysis, step_count: int) -> bool:
prompt_verify = f"""核验当前任务是否完成，判断是否需要继续执行。
查询：{question}
任务分析：{query_analysis}
可用工具：{json.dumps(self.available_tools)}
历史操作：{json.dumps(self.memory.get_actions())}"""
verification = self.llm_verifier.generate(prompt_verify, response_format=MemoryVerification)
return verification.stop_signal
# 最终答案合成
def solve_final_step_synthesize(self, question: str, query_analysis: QueryAnalysis) -> str:
prompt_final_output = f"""结合全部操作历史，整合信息生成最终答案。
查询：{question}
任务分析：{query_analysis}
操作历史：{json.dumps(self.memory.get_actions())}"""
return self.llm_planner_fixed.generate(prompt_final_output)
# 主执行循环
def solve(self, question: str):
query_analysis = self.solve_step_0_analyze(question)
step_count = 0
while step_count < self.max_steps:
step_count += 1
next_step = self.solve_step_1_plan(question, query_analysis, step_count)
command_to_run = self.solve_step_2_generate_command(question, next_step, step_count)
self.solve_step_3_execute_command(next_step, command_to_run, step_count)
should_stop = self.solve_step_4_verify(question, query_analysis, step_count)
if should_stop:
break
final_answer = self.solve_final_step_synthesize(question, query_analysis)
return final_answer
# 初始化调度器
def construct_solver():
planner_main_engine = MODEL_NAME
planner_fixed_engine = MODEL_NAME
verifier_engine = MODEL_NAME
executor_engine = MODEL_NAME
enabled_tools = ["Base_Generator_Tool", "Python_Coder_Tool", "Google_Search_Tool", "Wikipedia_RAG_Search_Tool"]
tool_engine = [MODEL_NAME, MODEL_NAME, "Default", MODEL_NAME]
return Solver(planner_main_engine, planner_fixed_engine, verifier_engine, executor_engine, enabled_tools, tool_engine, max_steps=5)六、未训练多智能体系统的核心缺陷实测
在正式开始GRPO训练之前，我们先通过复合复杂任务测试原生多智能体系统的能力短板，直观感受传统架构的问题，同时作为训练前后的效果对比基准。
测试任务选用经典复合需求，计算12的平方，再检索对应公元年份的重大历史事件。这个任务需要严格遵循"先计算、后检索"的步骤逻辑，非常考验智能体的规划能力和步骤逻辑性。
Plain
# 初始化原生智能体
solver = construct_solver()
# 测试复合查询
query_to_solve = "Calculate 12 squared, and then use Wikipedia to find out what major historical event happened in that year (AD)."
final_answer = solver.solve(query_to_solve)
print(f"最终答案：{final_answer}")实测过程中，原生未训练的多智能体出现多处致命错误，完全符合我们前文分析的传统架构缺陷。
第一，规划顺序错乱，优先执行检索任务，未先完成数学计算，盲目检索"12平方对应年份"，错误预判为公元120年，直接导致后续检索全部失效。
第二，步骤纠错滞后，第二轮才执行数学计算，得到正确结果144，但前期无效检索已经浪费步骤、产生错误上下文干扰。
第三，推理容错率极低，检索144年历史事件无结果后，智能体未调整检索策略，直接判定无重大事件。
第四，严重幻觉问题，最终通过通用生成工具虚构"罗马扩张北非贸易路线"的错误历史信息，无任何检索依据，完全属于模型臆造内容。
第五，核验模块失效，未能识别步骤错乱、信息虚构的问题，直接判定任务完成。
整个实测过程充分证明，无强化学习训练的多智能体系统，面对多步骤复合任务完全不可靠，规划逻辑、工具调用、错误规避、信息核验能力均存在严重短板，必须通过GRPO迭代优化。
七、GRPO算法完整训练实现：从轨迹采样到参数更新
本章节是项目核心，我们从零实现完整的GRPO训练循环，包含模型轻量化微调配置、轨迹采样、奖励计算、相对优势归一化、PPO损失计算、梯度累积、参数更新、模型保存全流程，采用QLoRA+LoRA高效微调方案，仅训练1.1%的模型参数，兼顾训练效率与效果。
7.1 训练超参数与全局配置
通过数据类统一管理所有训练超参数，适配多智能体GRPO训练特性，支持梯度累积、KL正则、裁剪系数等关键参数配置，保证训练稳定性。
Plain
import torch
import random
from dataclasses import dataclass, field
from torch.utils.data import DataLoader, Dataset
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, get_scheduler
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training, PeftModel
from torch.optim import AdamW
import torch.nn.functional as F
@dataclass
class TrainingConfig:
# 数据配置
data_file: str = "./data/train/combined_train.parquet"
# 模型配置
base_model_name: str = "Qwen/Qwen2-1.5B-Instruct"
fixed_model_name: str = "Qwen/Qwen2.5-7B-Instruct"
fixed_model_api_base: str = "http://localhost:8001/v1"
# 训练超参数
run_name: str = "flow_grpo_training_run_v1"
output_dir: str = "./agentflow_checkpoints"
learning_rate: float = 1e-6
train_batch_size: int = 2
rollout_n: int = 4 # GRPO每组轨迹数量
gradient_accumulation_steps: int = 4
num_train_epochs: int = 1
# PPO/GRPO超参数
ppo_clip_eps: float = 0.2
kl_coef: float = 0.01
max_grad_norm: float = 1.0
# 智能体配置
max_turns: int = 5
max_seq_length: int = 4096
enabled_tools: List[str] = field(default_factory=lambda: ["Python_Coder_Tool", "Wikipedia_RAG_Search_Tool", "Google_Search_Tool", "Base_Generator_Tool"])
tool_engine: List[str] = field(default_factory=lambda: ["gpt-4o-mini", "gpt-4o-mini", "gpt-4o-mini", "gpt-4o-mini"])
# 奖励模型
reward_model_name: str = "gpt-4o"
# 初始化配置
config = TrainingConfig()
os.makedirs(config.output_dir, exist_ok=True)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"训练设备：{device}")7.2 模型轻量化初始化（QLoRA+LoRA）
采用4位量化QLoRA加载基础模型，大幅降低显存占用，同时通过LoRA微调核心投影层，仅微调少量参数，实现高效迭代，避免全量微调的资源浪费与过拟合问题。
Plain
# 加载分词器
tokenizer = AutoTokenizer.from_pretrained(config.base_model_name, trust_remote_code=True)
if tokenizer.pad_token is None:
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "left"
# 4位量化配置
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.bfloat16
)
# 加载策略模型
policy_model = AutoModelForCausalLM.from_pretrained(
config.base_model_name,
quantization_config=bnb_config,
device_map="auto",
trust_remote_code=True,
use_cache=False
)
# 模型微调预处理
policy_model = prepare_model_for_kbit_training(policy_model)
peft_config = LoraConfig(
r=16,
lora_alpha=32,
target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
lora_dropout=0.05,
bias="none",
task_type="CAUSAL_LM"
)
policy_model = get_peft_model(policy_model, peft_config)
policy_model.print_trainable_parameters()
# 参考模型初始化
ref_model = policy_model7.3 轨迹数据结构与奖励计算模块
定义单步轨迹数据结构，记录每一步的提示词、动作、token序列、对数概率，同时接入GPT-4o作为奖励裁判，实现精准的轨迹质量打分。
Plain
# 轨迹单步数据结构
@dataclass
class TurnData:
prompt_str: str
action_str: str
prompt_ids: torch.Tensor
action_ids: torch.Tensor
action_log_probs: torch.Tensor
# 答案核验模型
class AnswerVerification(BaseModel):
true_false: bool
# 奖励计算函数
def compute_reward(query: str, ground_truth: str, final_answer: str) -> float:
prompt = f""" impartial judge，判断模型答案是否正确。
用户查询：{query}
标准答案：{ground_truth}
模型输出：{final_answer}
输出true/false"""
try:
judgement = reward_llm.generate(prompt, response_format=AnswerVerification)
return 1.0 if judgement.true_false else 0.0
except Exception:
return 1.0 if str(ground_truth).lower() in str(final_answer).lower() else 0.07.4 GRPO核心损失函数实现
结合PPO裁剪策略与GRPO相对优势机制，实现核心损失计算逻辑，包含代理损失、KL正则项，平衡训练效果与稳定性，避免策略突变。
Plain
def compute_ppo_loss(
policy_model: PeftModel,
ref_model: PeftModel,
tokenizer: AutoTokenizer,
trajectories: List[List[TurnData]],
advantages: torch.Tensor
) -> Tuple[torch.Tensor, torch.Tensor]:
total_policy_loss = torch.tensor(0.0, device=device)
total_kl_div = torch.tensor(0.0, device=device)
valid_trajectories = 0
for i, trajectory in enumerate(trajectories):
if not trajectory: continue
# 拼接完整序列
full_input_ids_list = [trajectory[0].prompt_ids]
full_labels_list = [torch.full_like(trajectory[0].prompt_ids, -100)]
for turn in trajectory:
full_input_ids_list.append(turn.action_ids)
full_labels_list.append(turn.action_ids)
input_ids = torch.cat(full_input_ids_list, dim=-1).to(device)
labels = torch.cat(full_labels_list, dim=-1).to(device)
# 新策略对数概率
outputs = policy_model(input_ids=input_ids.unsqueeze(0), labels=labels.unsqueeze(0))
neg_log_probs = outputs.loss * (labels != -100).sum()
log_probs = -neg_log_probs
# 旧策略对数概率
with ref_model.disable_adapter(), torch.no_grad():
ref_outputs = ref_model(input_ids=input_ids.unsqueeze(0), labels=labels.unsqueeze(0))
ref_log_probs = -ref_outputs.loss * (labels != -100).sum()
# 历史对数概率
old_log_prob = torch.cat([turn.action_log_probs for turn in trajectory]).sum().to(device)
# PPO核心计算
ratio = torch.exp(log_probs - old_log_prob)
advantage = advantages[i]
surr1 = ratio * advantage
surr2 = torch.clamp(ratio, 1.0 - config.ppo_clip_eps, 1.0 + config.ppo_clip_eps) * advantage
policy_loss = -torch.min(surr1, surr2)
# KL正则
kl_div = log_probs - ref_log_probs
total_policy_loss += policy_loss
total_kl_div += kl_div
valid_trajectories += 1
if valid_trajectories == 0:
return torch.tensor(0.0, device=device), torch.tensor(0.0, device=device)
return total_policy_loss / valid_trajectories, total_kl_div / valid_trajectories7.5 完整训练循环
整合数据加载、群组轨迹采样、相对优势计算、损失反向传播、梯度累积、模型保存全流程，实现工业级GRPO训练逻辑。
Plain
# 加载训练数据集
print(f"加载训练数据：{config.data_file}")
full_dataset = load_dataset("parquet", data_files=config.data_file, split="train")
print(f"加载完成，样本总量：{len(full_dataset)}")
# 数据集包装
class SimpleDataset(Dataset):
def __init__(self, hf_dataset):
self.hf_dataset = hf_dataset
def __len__(self):
return len(self.hf_dataset)
def __getitem__(self, idx):
return self.hf_dataset[idx]
train_data = SimpleDataset(full_dataset)
train_dataloader = DataLoader(train_data, batch_size=config.train_batch_size, shuffle=True)
# 初始化智能体训练系统
agent_system = AgenticSystem(policy_model, tokenizer, fixed_llm)
# 优化器与学习率调度器
optimizer = AdamW(policy_model.parameters(), lr=config.learning_rate)
total_training_steps = config.num_train_epochs * len(train_dataloader)
scheduler = get_scheduler(
"cosine",
optimizer=optimizer,
num_warmup_steps=int(total_training_steps * 0.1),
num_training_steps=total_training_steps
)
# 开始训练
print("\n===== 启动GRPO多智能体训练 =====")
global_step = 0
for epoch in range(config.num_train_epochs):
print(f"\n===== 第{epoch+1}轮训练 =====")
for step, batch in enumerate(tqdm(train_dataloader)):
optimizer.zero_grad()
batch_loss = 0.0
# 批次内样本迭代
for i in range(len(batch['question'])):
query = batch['question'][i]
ground_truth = batch['result'][i]
group_trajectories = []
group_rewards = []
# GRPO群组轨迹采样
policy_model.eval()
for _ in range(config.rollout_n):
trajectory, final_answer = agent_system.run_trajectory(query)
reward = compute_reward(query, ground_truth, final_answer)
group_trajectories.append(trajectory)
group_rewards.append(reward)
# 相对优势计算
rewards_tensor = torch.tensor(group_rewards, device=device, dtype=torch.float32)
mean_reward = rewards_tensor.mean()
std_reward = rewards_tensor.std() + 1e-8
advantages = (rewards_tensor - mean_reward) / std_reward
# 损失计算与反向传播
policy_model.train()
policy_loss, kl_div = compute_ppo_loss(policy_model, ref_model, tokenizer, group_trajectories, advantages)
loss = policy_loss + config.kl_coef * kl_div
loss = loss / (len(batch['question']) * config.gradient_accumulation_steps)
loss.backward()
batch_loss += loss.item()
torch.cuda.empty_cache()
# 梯度更新
if (step + 1) % config.gradient_accumulation_steps == 0:
torch.nn.utils.clip_grad_norm_(policy_model.parameters(), config.max_grad_norm)
optimizer.step()
scheduler.step()
optimizer.zero_grad()
global_step += 1
print(f"迭代步骤{global_step}：损失值={batch_loss:.6f}，群组平均奖励={mean_reward.item():.2f}")
# 保存模型检查点
checkpoint_dir = os.path.join(config.output_dir, f"epoch_{epoch+1}")
policy_model.save_pretrained(checkpoint_dir)
tokenizer.save_pretrained(checkpoint_dir)
print(f"✅ 模型检查点已保存：{checkpoint_dir}")
print("\n🎉 GRPO多智能体训练全部完成")八、训练效果验证：GRPO优化后的智能体能力升级
训练完成后，我们加载微调后的LoRA模型，重新部署vLLM服务，复用之前的测试用例，对比训练前后的智能体表现，直观验证GRPO的优化效果。
Plain
# 加载训练后的模型
vllm serve ./agentflow_checkpoints/epoch_1 \
--served-model-name Qwen/Qwen2-1.5B-Instruct \
--quantization bitsandbytes \
--enable-lora \
--port 8000
# 初始化训练后的智能体
trained_policy_model = AutoModelForCausalLM.from_pretrained(
config.base_model_name,
quantization_config=bnb_config,
device_map="auto",
trust_remote_code=True,
use_cache=False
)
trained_policy_model = prepare_model_for_kbit_training(trained_policy_model)
trained_policy_model = PeftModel.from_pretrained(trained_policy_model, "./agentflow_checkpoints/epoch_1")
trained_agent_system = AgenticSystem(trained_policy_model, tokenizer, fixed_llm)
# 复测测试用例
query_to_solve = "Calculate 12 squared, and then use Wikipedia to find out what major historical event happened in that year (AD)."
final_answer = trained_agent_system.solve(query_to_solve)
print(f"训练后最终答案：{final_answer}")8.1 核心能力提升总结
经过GRPO迭代训练后，多智能体系统的短板问题得到全方位修复，核心能力实现质的提升。
第一，任务规划逻辑标准化，智能体能够自主识别复合任务的优先级，严格遵循"先计算、后检索"的正确步骤，彻底解决步骤错乱、盲目操作的问题。
第二，错误抑制能力显著增强，无效工具调用、盲目检索、重复操作等劣质行为被大幅抑制，模型主动规避低效率推理路径。
第三，幻觉问题基本根治，模型不再依赖通用生成模块虚构信息，所有输出均基于工具检索、代码计算的真实结果，无臆造内容。
第四，容错与纠错能力提升，检索无结果时，智能体能够自主调整检索关键词、更换检索策略，而非直接判定任务失败或虚构答案。
第五，多模块协同更流畅，规划、执行、核验子智能体配合默契，核验模块能够精准识别步骤错误、信息虚假问题，闭环纠错能力大幅提升。
九、落地总结与迭代优化思路
通过本次完整的实战落地，我们可以清晰看到，GRPO算法相较于传统强化学习方案，是更适配大模型多智能体系统的优化范式。它摒弃了绝对奖励的固有缺陷，通过群组对比、相对优势学习、精细化错误抑制，让多智能体系统能够自主迭代优化任务规划、工具调用、协同推理能力，从根本上解决了传统Agent长期任务稳定性差、幻觉频发、协同混乱的核心痛点。
本次项目搭建的整套训练框架具备极强的可扩展性，后续可以从三个方向持续迭代优化。一是扩充训练数据集，加入更多多步骤复合任务、多智能体协同场景，提升模型泛化能力。二是优化GRPO超参数，调整群组采样数量、学习率、KL正则系数，进一步提升训练精度与稳定性。三是拓展工具集与智能体角色，适配更多垂直场景，实现工业级落地应用。