Datasets:
Download src/robotics/planner/task_planner.py from Nabidnur/RoboRACE-Bench: direct link, hf CLI and curl.
- Browser
- Download file 4.43 kB
-
https://huggingface.co/datasets/Nabidnur/RoboRACE-Bench/resolve/main/src/robotics/planner/task_planner.py
- Command line
-
hf download hf://datasets/Nabidnur/RoboRACE-Bench/src/robotics/planner/task_planner.py
-
curl -L -o task_planner.py https://huggingface.co/datasets/Nabidnur/RoboRACE-Bench/resolve/main/src/robotics/planner/task_planner.py
4.43 kB
| """High-level task planner: natural-language instruction -> validated skill plan. | |
| The LLM may only use skills from SKILLS; each step becomes a short language | |
| instruction for the low-level VLA (GR00T N1.7 / SmolVLA), which is the format | |
| those policies were trained on. | |
| """ | |
| from __future__ import annotations | |
| import json | |
| import re | |
| from dataclasses import dataclass, field | |
| from typing import Callable | |
| # Skills the low-level policy has been fine-tuned on. Extend as datasets grow. | |
| SKILLS: dict[str, str] = { | |
| "pick": "pick up {object}", | |
| "place": "place the {object} {location}", | |
| "push": "push the {object} {location}", | |
| "open": "open the {object}", | |
| "close": "close the {object}", | |
| "stack": "stack the {object} on the {location}", | |
| "home": "move the arm to the home position", | |
| } | |
| SYSTEM_PROMPT = """You are the task planner for a single robot arm. | |
| Decompose the user's instruction into a short sequence of skills. | |
| Allowed skills (use ONLY these): {skills}. | |
| Each step needs "skill"; "object" and "location" when the skill uses them. | |
| Only reference objects listed in the scene. If the task is impossible with | |
| these skills or objects, return {{"steps": [], "infeasible_reason": "..."}}. | |
| Respond with JSON only: {{"steps": [{{"skill": ..., "object": ..., "location": ...}}]}}""" | |
| class Step: | |
| skill: str | |
| object: str | None = None | |
| location: str | None = None | |
| def instruction(self) -> str: | |
| tmpl = SKILLS[self.skill] | |
| return tmpl.format(object=self.object or "", location=self.location or "").strip() | |
| class Plan: | |
| steps: list[Step] = field(default_factory=list) | |
| infeasible_reason: str | None = None | |
| provider: str | None = None | |
| class PlanError(ValueError): | |
| pass | |
| def _extract_json(text: str) -> dict: | |
| text = text.strip() | |
| fence = re.search(r"```(?:json)?\s*(.*?)```", text, re.S) | |
| if fence: | |
| text = fence.group(1) | |
| start, end = text.find("{"), text.rfind("}") | |
| if start < 0 or end < start: | |
| raise PlanError("no JSON object in LLM output") | |
| try: | |
| return json.loads(text[start : end + 1]) | |
| except json.JSONDecodeError as e: | |
| raise PlanError(f"invalid JSON: {e}") from e | |
| def parse_plan(text: str, scene_objects: list[str] | None = None, max_steps: int = 12) -> Plan: | |
| data = _extract_json(text) | |
| raw = data.get("steps") | |
| if not isinstance(raw, list): | |
| raise PlanError("'steps' must be a list") | |
| if len(raw) > max_steps: | |
| raise PlanError(f"plan too long ({len(raw)} > {max_steps})") | |
| known = {o.lower() for o in scene_objects} if scene_objects else None | |
| steps: list[Step] = [] | |
| for i, s in enumerate(raw): | |
| if not isinstance(s, dict) or s.get("skill") not in SKILLS: | |
| raise PlanError(f"step {i}: unknown skill {s!r}") | |
| step = Step(s["skill"], s.get("object") or None, s.get("location") or None) | |
| if "{object}" in SKILLS[step.skill] and not step.object: | |
| raise PlanError(f"step {i}: skill '{step.skill}' needs an object") | |
| if known is not None and step.object and step.object.lower() not in known: | |
| raise PlanError(f"step {i}: object '{step.object}' not in scene") | |
| steps.append(step) | |
| return Plan(steps=steps, infeasible_reason=data.get("infeasible_reason")) | |
| def plan( | |
| instruction: str, | |
| scene_objects: list[str], | |
| chat_fn: Callable[..., tuple[str, str]] | None = None, | |
| max_attempts: int = 3, | |
| ) -> Plan: | |
| """Ask the LLM for a plan; on validation failure, feed the error back and retry.""" | |
| if chat_fn is None: | |
| from robotics.llm.providers import chat as chat_fn # lazy: keeps tests offline | |
| messages = [ | |
| {"role": "system", "content": SYSTEM_PROMPT.format(skills=", ".join(SKILLS))}, | |
| {"role": "user", "content": f"Scene objects: {scene_objects}\nInstruction: {instruction}"}, | |
| ] | |
| last_err: Exception | None = None | |
| for _ in range(max_attempts): | |
| text, provider = chat_fn(messages, json_mode=True) | |
| try: | |
| p = parse_plan(text, scene_objects) | |
| p.provider = provider | |
| return p | |
| except PlanError as e: | |
| last_err = e | |
| messages += [{"role": "assistant", "content": text}, | |
| {"role": "user", "content": f"Invalid plan: {e}. Return corrected JSON only."}] | |
| raise PlanError(f"no valid plan after {max_attempts} attempts: {last_err}") | |