在我们之前的文章—— 使用 Google TPU 上的 Tunix 轻松微调 FunctionGemma 和 使用 Tunix 在 TPU 上开展自主式 LLM 后训练 ——我们展示了 Google Tunix 如何简化在 Cloud TPU 上进行的监督微调(SFT)和单轮组相对策略优化(GRPO)。然而,现实世界中的 AI 智能体很少能在单轮交互中完成任务。它们必须根据不完整的观察进行推理、调用工具、观察环境反馈,并在多个步骤中调整策略。因此,本文将介绍如何在 Cloud TPU v6e-8 上使用 Tunix 的智能体强化学习流程,训练一个能够进行多轮交互和使用工具的 LLM 智能体。完整代码可在 这个 GitHub 仓库中找到.
游戏设置
我们将重新探讨之前一篇 TensorFlow/JAX 强化学习博客中的 Plane Strike 棋盘游戏,并在单台 Cloud TPU v6e-8 主机上,以思考模式运行 Gemma 4 E2B,取代自定义 MLP 策略。Plane Strike 在一个 6×6 的网格(A1 至 F6)上进行,其中一架占据 8 个单元格的飞机以 4 种朝向之一隐藏。每一轮,智能体都会看到上一次出击的结果和原始可见棋盘(. 表示尚未尝试, X 表示命中, O 表示未命中),随后分析候选放置位置,并调用 strike(cell="...") 工具攻击一个单元格。当所有 8 个飞机单元格都被命中,或出击 23 次后,游戏结束。
尽管 google/gemma-4-E2B-it 具备不错的空间推理和工具调用能力,但在未经训练的情况下,它在留出棋盘上的胜率仅为 9.4%(平均出击 22.44 次)。使用 Tunix 进行 100 步智能体 GRPO 训练后,其胜率达到 95%,同时将平均游戏长度缩短至约 16 次出击。
在 Tunix 中构建智能体强化学习流程
我们将多轮强化学习流程划分为四个模块化组件:
- 任务环境(
BaseTaskEnv,位于 env.py) - 工具和聊天模板解析器(
BaseTool和Gemma4ChatTemplateParser位于 strike_tool.py) - 对话智能体(
ConversationAgentBase位于 agent.py) - 轨迹收集与智能体 GRPO 学习器(
TrajectoryCollectEngine和GRPOLearner位于 trajectory_utils.py 和 train_planestrike.py)
下面来看各个部分的关键步骤。
步骤 1:定义环境(env.py)
在 env.py中,我们继承 Tunix 的 BaseTaskEnv 来实现 PlaneStrikeEnv。每个环境实例都会接收一个任务字典,其中包含一个 seed ,用于固定隐藏飞机的位置,使 GRPO 组中的全部 8 条 rollout 轨迹都在完全相同的棋盘上进行:
class PlaneStrikeEnv(BaseTaskEnv):
"""One Plane Strike game. `entry["seed"]` fixes the hidden plane position."""
def __init__(
self,
entry: dict[str, Any],
group_id: int | None = None,
pair_index: int | None = None,
max_steps: int = MAX_STEPS,
**kwargs,
):
entry = {k: _unwrap(v) for k, v in entry.items()}
self.seed = int(entry.get("seed", 0))
self.split = str(entry.get("split", "train"))
super().__init__(task=dict(entry), max_steps=max_steps, **kwargs)
self.extra_kwargs["group_id"] = group_id
self.extra_kwargs["pair_index"] = pair_index
self._reset_board()
Python
已复制
每一轮, _step_impl 会根据隐藏棋盘评估被攻击的单元格索引,更新可见网格,计算单步奖励(在整个回合中累加为轨迹级奖励),并返回 EnvStepResult(observation, reward, done, info).
对于标准的多工具智能体, tunix.rl.agentic 还开箱即用地提供了现成的 ToolEnvironment, ToolAgent 和 ToolManager 抽象,因此除非需要自定义轮次控制,否则无需编写自定义的消息/观察结果衔接逻辑。
步骤 2:Gemma 4 原生工具调用(strike_tool.py)
在 Gemma 4 中,工具架构在系统提示词内的 <|tool>declaration:...<tool|>中声明,而调用工具的模型轮次以以下内容结束:
<|channel>thought
...model reasoning...
<channel|><|tool_call>call:strike{cell:<|"|>C5<|"|>}<tool_call|><|tool_response>
纯文本
已复制
<|tool_response> 是 Gemma 4 的原生停止词元之一:模型会在此处暂停并等待 response:strike{value:<|"|>...<|"|>}<tool_response|>,然后在同一个助手轮次中继续生成下一步思考和工具调用。
在 strike_tool.py中,我们定义 StrikeTool(BaseTool) ,并继承 Tunix 的 Gemma4ChatTemplateParser ,将工具声明追加到系统提示词中,并将 "tool" 消息渲染为轮次内响应:
class Gemma4ToolChatTemplateParser(parser_lib.Gemma4ChatTemplateParser):
"""Gemma4ChatTemplateParser plus native tool declarations and in-turn tool
responses."""
def __init__(self, tokenizer, tools: list[base_tool.BaseTool], enable_thinking: bool = True):
super().__init__(tokenizer, enable_thinking=enable_thinking)
self.tool_declarations = render_tool_declarations(tokenizer, tools)
self.tool_response_id = tokenizer.convert_tokens_to_ids(TOOL_RESPONSE_START)
def _parse_system(self, content: str) -> str:
return self.tokens.system_token + content.strip() + self.tool_declarations + self.tokens.eot_token
def _parse_tool(self, content: str) -> str:
return f"response:{TOOL_NAME}{{value:{_STR}{content}{_STR}}}<tool_response|>"
def parse(self, messages, add_generation_prompt: bool = False, is_first_msg: bool = False) -> str:
if messages and messages[-1]["role"] == "tool":
add_generation_prompt = False # The model continues its own turn.
return super().parse(messages, add_generation_prompt=add_generation_prompt,
is_first_msg=is_first_msg)
Python
已复制
步骤 3:构建对话智能体(agent.py)
在 agent.py, PlaneStrikeAgent(ConversationAgentBase) 负责在环境观察结果与模型消息之间进行转换。
当模型结束一个轮次时, tool_strike 会忽略其中的所有内容 <|channel>thought...<channel|> 并解析其后的最终答案 <channel|>;只有最终答案中包含一个有效的 strike 调用时,才会被视为有效的棋盘坐标(否则返回 INVALID_ACTION )。如果模型在 <|tool_response> 处停止,则会将下一次棋盘观察结果连同 role="tool" 一并追加,以便模型继续当前轮次:
class PlaneStrikeAgent(base_agent.ConversationAgentBase):
def _observation_to_messages(
self, observation: Any, reward: float, done: bool, info: dict[str, Any]
) -> None:
if not done:
role = "tool" if self._awaiting_tool_response else "user"
self._messages.append({"role": role, "content": str(observation)})
def update_from_model(self, response: str, **kwargs) -> agent_types.Action:
action = tool_strike(response, self.tool)
answer = final_answer(response)
self.tool_calls_per_turn.append(
0 if answer is None else len(strike_tool.parse_tool_calls(answer)))
self._awaiting_tool_response = response.rstrip().endswith(strike_tool.TOOL_RESPONSE_START)
self._messages.append({"role": "assistant", "content": response})
self._trajectory.steps.append(self.cur_step)
self.cur_step.action = action
self.cur_step.model_response = response
return agent_types.Action(action=action)
Python
已复制
步骤 4:接入智能体 GRPO(train_planestrike.py)
在 train_planestrike.py, 中,我们配置 Tunix 的异步 vllm rollout 引擎, RLEngine,以及 GRPOLearner:
rollout_config = base_rollout.RolloutConfig(
max_prompt_length=args.max_prompt_length,
max_tokens_to_generate=args.max_response_length,
kv_cache_size=args.max_prompt_length + args.max_response_length + 256,
temperature=args.temperature,
top_p=1.0,
top_k=0,
return_logprobs=True,
eos_tokens=[tokenizer.eos_token_id, tokenizer.convert_tokens_to_ids("<turn|>"),
tokenizer.convert_tokens_to_ids(strike_tool.TOOL_RESPONSE_START)],
rollout_vllm_model_version=MODEL_VERSION,
rollout_vllm_hbm_utilization=args.vllm_hbm_utilization,
rollout_vllm_tpu_backend_type="jax",
rollout_vllm_server_mode=True,
rollout_vllm_kwargs={
"enable_prefix_caching": True,
"dtype": "bfloat16",
"hf_overrides": {
"final_logit_softcapping": 30.0,
"text_config": {"final_logit_softcapping": 30.0},
"architectures": ["Gemma4ForCausalLM"],
},
},
rollout_vllm_sampling_kwargs={"skip_special_tokens": False},
)
Python
已复制
多轮智能体强化学习通常受制于长度不一的 rollout 生成,因此我们将 rollout_vllm_server_mode 设置为 true,以通过 vllm-tpu 启用连续的异步多轮 rollout,并将 enable_prefix_caching to true 设置为 true,以缓存不断增长的多轮对话历史。由于我们使用的是单主机 v6e-8,actor 模型、参考模型和 rollout 工作进程共享这 8 颗芯片。
然后,我们传入 actor、分词器、 ClusterConfig, GRPOConfig (loss_algo="gspo-token", advantage_estimator="rloo", exact_token_continuity=True 以在多轮 rollout 中保留精确的词元 ID,避免重新分词产生偏移)、智能体和环境,并将它们传入 RLEngine 和 PlaneStrikeGRPOLearner:
rl_engine = rl_engine_lib.RLEngine(
actor=actor, reference=reference, tokenizer=tokenizer, cluster_config=cluster_config)
learner = PlaneStrikeGRPOLearner(
rl_engine=rl_engine,
agent_class=agent_lib.PlaneStrikeAgent,
agent_kwargs={},
env_class=env_lib.PlaneStrikeEnv,
env_kwargs={"max_steps": args.max_steps_per_game},
algo_config=grpo_config,
chat_parser=chat_parser,
metric_fns=[metric_fn],
)
learner.train(train_dataset, eval_dataset=eval_dataset)
Python
已复制
有了这些,我们就可以使用以下命令启动 100 步训练任务:
python train_planestrike.py \
--run_dir runs/grpo_6x6_tool_thinking_100 \
--learning_rate 2e-6 \
--lr_end 2e-7
Shell
已复制
训练结果
经过 100 步训练(每步 8 个棋盘,每个棋盘进行 8 局游戏),智能体学会了可靠地调用工具并进行空间推理:
- 工具调用合规性最先收敛:
game/train/tool_call_rate迅速达到约 100%,而game/train/invalid降至约 0,且game/train/repeats从约 0.55 降至约 0.15。由于目前一局游戏中的所有出击共享同一个轨迹级奖励,因此通过更精细的逐轮信用分配,还能进一步提升表现。 - 胜率(智能体在 23 步内成功击中全部 8 个隐藏单元格的比例)从初始训练 rollout 时的约 0.20(在留出评估棋盘上为 9.4%)升至约 0.95。
- 平均游戏长度从每局约 22 次出击降至约 16 次。
下一步是什么?
借助 Tunix 的 tunix.rl.agentic 抽象, vllm-tpu,而且 GRPOLearner,在 Cloud TPU 上开展多轮、使用工具的智能体强化学习既简单又高效。查看 planestrike-gemma4-rl GitHub 代码仓库 ,并阅读 Tunix 文档 ,了解如何使用 Tunix 和 Google TPU 训练你自己的智能体模型。
移动
AI
案例研究
公告
加速超大型 Git 代码仓库的开发
2026 年 11 月 17 日
AI
云
教程
案例研究
在 TPU 上实现稳定的同策略强化学习:训练与推理之间的逐位零差异
2026 年 11 月 16 日
AI
案例研究
公告
Gemini 4 Hydrogen:面向通用机器人的更快模型
2026 年 11 月 17 日
AI
云
教程
操作指南
保护你的智能体:智能体异常检测实操指南
2026 年 11 月 16 日
AI 热点