| """SPAgent GRPO plugin for deterministic VRBench navigation. |
| |
| The model-facing interaction contract matches FrozenLake v3: explicit image |
| placement, one-step ``move`` calls, cumulative image anchors, full conversation |
| history, and final-answer replay from the initial state. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import json |
| import os |
| import re |
| import sys |
| import uuid |
| from pathlib import Path |
| from typing import Any, Dict, List |
|
|
|
|
| REPO_ROOT = Path(__file__).resolve().parents[1] |
| if str(REPO_ROOT) not in sys.path: |
| sys.path.insert(0, str(REPO_ROOT)) |
|
|
| from spagent.vrbench_navigation_protocol import ( |
| SUPPORTED_TASKS, |
| clone_state, |
| create_tool_response, |
| decode_initial_state, |
| encode_initial_state, |
| parse_action_tokens, |
| render_state, |
| replay_actions, |
| step_state, |
| ) |
|
|
| from swift.llm import RolloutInferRequest |
|
|
| sys.path.insert(0, str(Path(__file__).resolve().parent)) |
| import grpo_filtered_trainer |
| from swift.llm.infer.protocol import ChatCompletionResponseChoice |
| from swift.plugin import ORM, orms |
| from swift.plugin.multi_turn import MultiTurnScheduler, multi_turns |
| from swift.utils import get_logger |
|
|
|
|
| logger = get_logger() |
|
|
| TOOL_CALL_RE = re.compile(r"<tool_call>\s*(.*?)\s*</tool_call>", re.DOTALL) |
| ANSWER_RE = re.compile(r"<answer>(.*?)</answer>", re.DOTALL) |
| _THINK_INNER = r"(?:(?!</think>|<tool_call>|<answer>).)*" |
| _TOOL_CALL_TURN_RE = re.compile( |
| rf"^<think>{_THINK_INNER}</think>\s*<tool_call>.*?</tool_call>(?![\s\S])", |
| re.DOTALL, |
| ) |
| _ANSWER_TURN_RE = re.compile( |
| rf"^<think>{_THINK_INNER}</think>\s*<answer>.*?</answer>(?![\s\S])", |
| re.DOTALL, |
| ) |
|
|
|
|
| def _is_canonical_format(completion: str) -> bool: |
| value = (completion or "").strip() |
| return bool( |
| _TOOL_CALL_TURN_RE.match(value) |
| or _ANSWER_TURN_RE.match(value) |
| ) |
|
|
|
|
| def _batch_values(value: Any, count: int) -> List[Any]: |
| if isinstance(value, list) and len(value) == count: |
| return value |
| return [value] * count |
|
|
|
|
| class VRBenchNavigationReward(ORM): |
| """Reward a final direction sequence that reaches the recorded goal.""" |
|
|
| def __call__( |
| self, |
| completions, |
| task_id=None, |
| initial_state=None, |
| **kwargs, |
| ) -> List[float]: |
| completions = list(completions or []) |
| tasks = _batch_values(task_id, len(completions)) |
| states = _batch_values(initial_state, len(completions)) |
| rewards: List[float] = [] |
| for completion, task, state in zip(completions, tasks, states): |
| match = ANSWER_RE.search(completion or "") |
| if not match or task not in SUPPORTED_TASKS or not state: |
| rewards.append(0.0) |
| continue |
| actions = parse_action_tokens(match.group(1)) |
| solved = bool(actions) and replay_actions(task, state, actions) |
| rewards.append(1.0 if solved else 0.0) |
| return rewards |
|
|
|
|
| orms["vrbench_navigation_reward"] = VRBenchNavigationReward |
|
|
|
|
| class VRBenchNavigationFormatReward(ORM): |
| """Use the same canonical format reward scale as FrozenLake v3.""" |
|
|
| def __call__(self, completions, **kwargs) -> List[float]: |
| rewards: List[float] = [] |
| for completion in completions or []: |
| completion = completion or "" |
| match = ANSWER_RE.search(completion) |
| valid_actions = bool( |
| match and parse_action_tokens(match.group(1)) |
| ) |
| rewards.append( |
| 0.3 * float(_is_canonical_format(completion)) |
| + 0.2 * float(valid_actions) |
| ) |
| return rewards |
|
|
|
|
| orms["vrbench_navigation_format"] = VRBenchNavigationFormatReward |
|
|
|
|
| class VRBenchNavigationScheduler(MultiTurnScheduler): |
| """FrozenLake-v3-style scheduler for three VRBench grid tasks.""" |
|
|
| def __init__(self, max_turns: int = 100, *args, **kwargs): |
| super().__init__(max_turns=max_turns, *args, **kwargs) |
| self.tool_img_dir = Path( |
| os.environ.get( |
| "VRBENCH_NAV_IMG_DIR", |
| "/tmp/vrbench_navigation_rollout", |
| ) |
| ) |
| self.tool_img_dir.mkdir(parents=True, exist_ok=True) |
|
|
| def _state(self, infer_request: RolloutInferRequest) -> Dict[str, Any]: |
| if ( |
| not hasattr(infer_request, "data_dict") |
| or infer_request.data_dict is None |
| ): |
| infer_request.data_dict = {} |
| data = infer_request.data_dict |
| if "_vrbench_navigation" not in data: |
| task_id = data.get("task_id") |
| initial_state = data.get("initial_state") |
| if task_id not in SUPPORTED_TASKS: |
| raise RuntimeError( |
| "VRBenchNavigationScheduler requires task_id in " |
| f"{SUPPORTED_TASKS}; got {task_id!r}" |
| ) |
| if not initial_state: |
| raise RuntimeError( |
| "VRBenchNavigationScheduler requires the dataset column " |
| "`initial_state`." |
| ) |
| decoded = decode_initial_state(initial_state) |
| encoded = encode_initial_state(decoded) |
| data["initial_state"] = encoded |
| data["_vrbench_navigation"] = { |
| "task_id": task_id, |
| "initial_state": encoded, |
| "state": clone_state(decoded), |
| "done": False, |
| "success": False, |
| "actions": [], |
| } |
| if "rollout_uuid" not in data: |
| data["rollout_uuid"] = uuid.uuid4().hex[:12] |
| if "session_messages" not in data: |
| data["session_messages"] = [ |
| { |
| "role": message["role"], |
| "content": message["content"], |
| } |
| for message in (infer_request.messages or []) |
| if message.get("role") != "assistant" |
| ] |
| return data["_vrbench_navigation"] |
|
|
| @staticmethod |
| def _sample_id(infer_request: RolloutInferRequest) -> str: |
| data = infer_request.data_dict or {} |
| if "rollout_uuid" not in data: |
| data["rollout_uuid"] = uuid.uuid4().hex[:12] |
| infer_request.data_dict = data |
| return data["rollout_uuid"] |
|
|
| def check_finished( |
| self, |
| infer_request: RolloutInferRequest, |
| response_choice: ChatCompletionResponseChoice, |
| current_turn: int, |
| ) -> bool: |
| state = self._state(infer_request) |
| content = response_choice.message.content or "" |
| if "<answer>" in content and "</answer>" in content: |
| return True |
| if state.get("done"): |
| return True |
| return super().check_finished( |
| infer_request, |
| response_choice, |
| current_turn, |
| ) |
|
|
| def step( |
| self, |
| infer_request: RolloutInferRequest, |
| response_choice: ChatCompletionResponseChoice, |
| current_turn: int, |
| ) -> Dict[str, Any]: |
| rollout_state = self._state(infer_request) |
| task_id = rollout_state["task_id"] |
| content = response_choice.message.content or "" |
| new_images: List[str] = [] |
|
|
| match = TOOL_CALL_RE.search(content) |
| if not match: |
| body_text = ( |
| "No <tool_call> found in your response. Call the move tool " |
| "with one direction, or finalize with " |
| "<answer>full action sequence space-separated</answer>." |
| ) |
| else: |
| try: |
| tool_call = json.loads(match.group(1)) |
| except json.JSONDecodeError: |
| body_text = ( |
| "Your <tool_call> JSON was malformed. Use exactly:\n" |
| '<tool_call>{"name": "move", "arguments": ' |
| '{"direction": "Down"}}</tool_call>' |
| ) |
| else: |
| if not isinstance(tool_call, dict): |
| body_text = ( |
| "Malformed tool call: the JSON value must be an object." |
| ) |
| else: |
| name = tool_call.get("name") |
| arguments = tool_call.get("arguments") or {} |
| if name != "move": |
| body_text = ( |
| f"Unknown tool {name!r}. Only `move` is available." |
| ) |
| elif not isinstance(arguments, dict): |
| body_text = ( |
| "Malformed move arguments: `arguments` must be " |
| "a JSON object." |
| ) |
| else: |
| direction = arguments.get("direction", "") |
| outcome = step_state( |
| task_id, |
| rollout_state["state"], |
| direction, |
| ) |
| body_text = outcome.body_text |
| if outcome.changed: |
| rollout_state["actions"].append(direction) |
| rollout_state["done"] = outcome.done |
| rollout_state["success"] = outcome.success |
| image_path = self.tool_img_dir / ( |
| f"{self._sample_id(infer_request)}_" |
| f"t{current_turn:03d}.png" |
| ) |
| try: |
| render_state( |
| task_id, |
| rollout_state["state"], |
| image_path, |
| ) |
| except Exception as exc: |
| logger.warning( |
| f"VRBench navigation render failed: {exc}" |
| ) |
| else: |
| new_images.append(str(image_path)) |
|
|
| if rollout_state.get("done"): |
| body_text += ( |
| "\n\nThe episode has ended. Output your full executed action " |
| "sequence as <answer>Direction1 Direction2 ...</answer>." |
| ) |
|
|
| all_images = list(infer_request.images or []) + new_images |
| labelled = [ |
| ( |
| "initial state" if index == 0 else f"after step {index}", |
| path, |
| ) |
| for index, path in enumerate(all_images) |
| ] |
| continuation_prompt = create_tool_response(body_text, labelled) |
|
|
| data = infer_request.data_dict or {} |
| session_messages = data.get("session_messages") |
| if session_messages is not None: |
| session_messages.append( |
| {"role": "assistant", "content": content} |
| ) |
| session_messages.append( |
| {"role": "user", "content": continuation_prompt} |
| ) |
| next_messages = list(session_messages) |
| else: |
| next_messages = [ |
| {"role": "user", "content": continuation_prompt} |
| ] |
|
|
| new_request = RolloutInferRequest( |
| messages=next_messages, |
| images=all_images, |
| audios=getattr(infer_request, "audios", None), |
| videos=getattr(infer_request, "videos", None), |
| tools=getattr(infer_request, "tools", None), |
| objects=getattr(infer_request, "objects", None), |
| data_dict=infer_request.data_dict, |
| ) |
| return { |
| "infer_request": new_request, |
| "rollout_infos": { |
| "task_id": task_id, |
| "navigation_actions": list(rollout_state["actions"]), |
| "navigation_done": rollout_state["done"], |
| "navigation_success": rollout_state["success"], |
| "num_turns": current_turn, |
| }, |
| } |
|
|
|
|
| multi_turns["vrbench_navigation_scheduler"] = VRBenchNavigationScheduler |
|
|
