Google 标签管理器(noscript) Google 标签管理器结束(noscript) HTML 使用 Tunix 和 Gemma 4 在 Google TPU 上开展多轮智能体强化学习 2026 年 11 月 19 日 Wei Wei 开发者倡导者 Ai-1-banner (9)

在我们之前的文章—— 使用 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 中构建智能体强化学习流程

我们将多轮强化学习流程划分为四个模块化组件:

  1. 任务环境(BaseTaskEnv ,位于 env.py)
  2. 工具和聊天模板解析器(BaseTool 和 Gemma4ChatTemplateParser 位于 strike_tool.py)
  3. 对话智能体(ConversationAgentBase 位于 agent.py)
  4. 轨迹收集与智能体 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 局游戏),智能体学会了可靠地调用工具并进行空间推理:

sample_train_curves
  • 工具调用合规性最先收敛: 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 训练你自己的智能体模型。

发布于: 上一篇 下一篇 相关文章 Accelerating development for massive Git repositories 移动 AI 案例研究 公告

加速超大型 Git 代码仓库的开发

2026 年 11 月 17 日
Unlocking Stable On-Policy RL on TPU with Bitwise-Zero Train–Inference Mismatch AI 云 教程 案例研究

在 TPU 上实现稳定的同策略强化学习:训练与推理之间的逐位零差异

2026 年 11 月 16 日
Gemini 4 Hydrogen: a faster model for general purpose robotics AI 案例研究 公告

Gemini 4 Hydrogen:面向通用机器人的更快模型

2026 年 11 月 17 日
Securing Your Agents: A Hands-On Guide to Agent Anomaly Detection AI 云 教程 操作指南

保护你的智能体:智能体异常检测实操指南

2026 年 11 月 16 日