Add original pairwise ManiSkill evaluation interfaces

README.md

@@ -13,6 +13,7 @@ ManiSkill 仿真上对多个 VLA 模型做的 **pairwise-OOD / all-factor / conf
 README.md                 ← 本文件:总览 + 结果 + 导航
 REPRODUCE.md              ← 怎么跑每一类评测(环境/ckpt/命令)
 code/                     ← 全部评测代码(client / runner / dispatcher)
+├─ pairwise_env.py         四类原始 pairwise 环境统一接口
 results/
 ├─ gr00t/
 │  ├─ pairgrid_hard/      6 实验 × 9 ckpt,硬口径(同色同形干扰项)

REPRODUCE.md

@@ -25,6 +25,46 @@ all-factor、conflict、VLM 评测的**可复现全集**(除 checkpoint 权重
 
 ## 0. 准备
 
+### 0.0 四类原始 pairwise ManiSkill 环境接口
+
+`code/pairwise_env.py` 是不依赖具体模型的统一入口，覆盖：
+
+- `verb_color`: 6 verbs × 6 colors，shape 从 `cube/sphere/cup` 采样；
+- `color_object`: 6 colors × 6 shapes，verb 从 `lift/grasp/push` 采样；
+- `verb_object`: 6 verbs × 6 shapes，color 从 `red/yellow/blue` 采样；
+- `verb_size`: 6 verbs × 6 size labels，固定 red cube。
+
+列出某类实验的全部 36 个 cell：
+
+```bash
+python code/pairwise_env.py verb_color --seed 42 --third-pool-size 2
+python code/pairwise_env.py color_object --seed 42 --third-pool-size 2
+python code/pairwise_env.py verb_object --seed 42 --third-pool-size 2
+python code/pairwise_env.py verb_size --seed 42
+```
+
+额外创建环境并执行一次 reset（验证 `VerbObjectColor-v1` 注册、资源和参数）：
+
+```bash
+python code/pairwise_env.py verb_color --smoke-reset --sim-backend cpu
+```
+
+模型 runner 可直接 import：
+
+```python
+from pairwise_env import build_cell, make_env
+
+cell = build_cell("verb_color", "lift", "red", seed=42)
+env = make_env(cell)
+obs, info = env.reset(seed=42, options=cell.reset_options)
+instruction = cell.instruction
+```
+
+环境实现位于
+`simulation/eval_simulation/simulation/mani_skill/envs/tasks/tabletop/verb_object_color_env.py`；
+factor vocab 和原始采集定义位于
+`simulation/Maniskill_gen_new/collection_strategy/`。
+
 ### 0.1 仿真就位(代码已是文件夹,可在线浏览;仅二进制 3D 资源是 tar)
 ```bash
 # 代码已在 simulation/eval_simulation/ 与 simulation/Maniskill_gen_new/(文件夹,可直接看)

code/pairwise_env.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env python3
+"""Unified ManiSkill interface for the four original pairwise evaluation grids.
+
+This module contains no model-specific code.  A policy evaluator can call
+``build_cell`` and receive a registered ``VerbObjectColor-v1`` environment,
+the reset options, and the natural-language instruction.
+
+Grids:
+  verb_color:  verb(6) x color(6), shape sampled from cube/sphere/cup
+  color_object: color(6) x shape(6), verb sampled from lift/grasp/push
+  verb_object: verb(6) x shape(6), color sampled from red/yellow/blue
+  verb_size: verb(6) x size(6), fixed red cube
+"""
+from __future__ import annotations
+
+import argparse
+import dataclasses
+import os
+import pathlib
+import random
+import sys
+from typing import Any
+
+
+REPO_ROOT = pathlib.Path(__file__).resolve().parents[1]
+SIM_ROOT = pathlib.Path(
+    os.environ.get(
+        "SIM_ROOT", REPO_ROOT / "simulation/eval_simulation/simulation"
+    )
+)
+MGEN_ROOT = pathlib.Path(
+    os.environ.get("MGEN_ROOT", REPO_ROOT / "simulation/Maniskill_gen_new")
+)
+for _path in (SIM_ROOT, MGEN_ROOT):
+    if str(_path) not in sys.path:
+        sys.path.insert(0, str(_path))
+
+import gymnasium as gym  # noqa: E402
+import mani_skill.envs  # noqa: E402,F401 - registers VerbObjectColor-v1
+
+from collection_strategy.lib.pairwise_task_language import VERB_TO_EN  # noqa: E402
+from collection_strategy.lib.training_vocab import (  # noqa: E402
+    THIRD_COLORS_FOR_VERB_OBJECT,
+    THIRD_OBJECTS_FOR_VERB_COLOR,
+    THIRD_VERBS_FOR_COLOR_OBJECT,
+    TRAINING_COLORS,
+    TRAINING_SHAPES,
+    TRAINING_VERBS,
+)
+
+
+EXPERIMENTS = ("verb_color", "color_object", "verb_object", "verb_size")
+SIZES = ("small", "large", "smaller", "larger", "smallest", "largest")
+COLOR_TO_ID = {color: i for i, color in enumerate(TRAINING_COLORS)}
+SIZE_CONFIG = {
+    "small": (0.72, [], 0),
+    "large": (1.34, [], 0),
+    "smaller": (0.82, [1.08], 1),
+    "larger": (1.18, [0.92], 1),
+    "smallest": (0.78, [1.00, 1.24], 2),
+    "largest": (1.26, [1.00, 0.80], 2),
+}
+
+
+@dataclasses.dataclass(frozen=True)
+class Cell:
+    experiment: str
+    factor_a: str
+    factor_b: str
+    verb: str
+    color: str
+    shape: str
+    instruction: str
+    make_kwargs: dict[str, Any]
+    reset_options: dict[str, Any]
+
+
+def factor_values(experiment: str) -> tuple[tuple[str, ...], tuple[str, ...]]:
+    """Return the two ordered axes of an evaluation grid."""
+    if experiment == "verb_color":
+        return TRAINING_VERBS, TRAINING_COLORS
+    if experiment == "color_object":
+        return TRAINING_COLORS, TRAINING_SHAPES
+    if experiment == "verb_object":
+        return TRAINING_VERBS, TRAINING_SHAPES
+    if experiment == "verb_size":
+        return TRAINING_VERBS, SIZES
+    raise ValueError(f"unknown experiment {experiment!r}; choose from {EXPERIMENTS}")
+
+
+def build_cell(
+    experiment: str,
+    factor_a: str,
+    factor_b: str,
+    *,
+    seed: int = 42,
+    third_pool_size: int = 2,
+    sim_backend: str = "cpu",
+    max_episode_steps: int = 200,
+    task_difficulty: float = 1.0,
+) -> Cell:
+    """Materialize one grid cell using the original evaluation conventions."""
+    rng = random.Random(seed)
+    pool_n = max(1, int(third_pool_size))
+    reset_options: dict[str, Any] = {}
+
+    if experiment == "verb_color":
+        verb, color = factor_a, factor_b
+        shape = rng.choice(THIRD_OBJECTS_FOR_VERB_COLOR[:pool_n])
+    elif experiment == "color_object":
+        color, shape = factor_a, factor_b
+        verb = rng.choice(THIRD_VERBS_FOR_COLOR_OBJECT[:pool_n])
+    elif experiment == "verb_object":
+        verb, shape = factor_a, factor_b
+        color = rng.choice(THIRD_COLORS_FOR_VERB_OBJECT[:pool_n])
+    elif experiment == "verb_size":
+        verb, size = factor_a, factor_b
+        color, shape = "red", "cube"
+        target_scale, distractor_scales, num_distractors = SIZE_CONFIG[size]
+        reset_options = {
+            "num_distractors": num_distractors,
+            "target_size_scale": target_scale,
+            "distractor_size_scales": distractor_scales,
+        }
+    else:
+        raise ValueError(f"unknown experiment {experiment!r}; choose from {EXPERIMENTS}")
+
+    axes = factor_values(experiment)
+    if factor_a not in axes[0] or factor_b not in axes[1]:
+        raise ValueError(
+            f"invalid {experiment} cell ({factor_a!r}, {factor_b!r}); axes={axes}"
+        )
+
+    instruction = VERB_TO_EN[verb].format(color=color, shape=shape)
+    if experiment == "verb_size":
+        instruction = f"{verb.capitalize()} the {factor_b} {color} {shape}."
+
+    distractor_max = max(2, int(reset_options.get("num_distractors", 0)))
+    make_kwargs = {
+        "obs_mode": "rgb",
+        "control_mode": "pd_joint_pos",
+        "sim_backend": sim_backend,
+        "render_backend": sim_backend,
+        "max_episode_steps": max_episode_steps,
+        "task_difficulty": task_difficulty,
+        "verb": verb,
+        "object_shape": shape,
+        "object_color_id": COLOR_TO_ID[color],
+        "distractor_max": distractor_max,
+    }
+    if experiment == "verb_size":
+        make_kwargs.update(
+            object_size_jiggle=0.0,
+            target_size_scale=target_scale,
+            distractor_size_scales=distractor_scales,
+            distractor_specs=[("cube", COLOR_TO_ID[color])] * num_distractors
+            + [None] * (3 - num_distractors),
+        )
+    return Cell(
+        experiment=experiment,
+        factor_a=factor_a,
+        factor_b=factor_b,
+        verb=verb,
+        color=color,
+        shape=shape,
+        instruction=instruction,
+        make_kwargs=make_kwargs,
+        reset_options=reset_options,
+    )
+
+
+def make_env(cell: Cell) -> gym.Env:
+    """Construct the registered environment for a materialized cell."""
+    return gym.make("VerbObjectColor-v1", **cell.make_kwargs)
+
+
+def iter_grid(experiment: str, **kwargs: Any):
+    """Yield all 36 cells in stable row-major order."""
+    axis_a, axis_b = factor_values(experiment)
+    for a in axis_a:
+        for b in axis_b:
+            yield build_cell(experiment, a, b, **kwargs)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("experiment", choices=EXPERIMENTS)
+    parser.add_argument("--seed", type=int, default=42)
+    parser.add_argument("--third-pool-size", type=int, default=2)
+    parser.add_argument("--smoke-reset", action="store_true")
+    parser.add_argument("--sim-backend", default="cpu", choices=("cpu", "gpu"))
+    args = parser.parse_args()
+
+    cells = list(
+        iter_grid(
+            args.experiment,
+            seed=args.seed,
+            third_pool_size=args.third_pool_size,
+            sim_backend=args.sim_backend,
+        )
+    )
+    print(f"{args.experiment}: {len(cells)} cells")
+    for index, cell in enumerate(cells, 1):
+        print(index, cell.factor_a, cell.factor_b, "->", cell.instruction)
+
+    if args.smoke_reset:
+        cell = cells[0]
+        env = make_env(cell)
+        try:
+            obs, info = env.reset(seed=args.seed, options=cell.reset_options)
+            print("SMOKE_RESET_OK", sorted(obs), sorted(info))
+        finally:
+            env.close()
+
+
+if __name__ == "__main__":
+    main()

simulation/eval_simulation/simulation/mani_skill/envs/tasks/tabletop/verb_object_color_env.py

@@ -139,6 +139,8 @@ class VerbObjectColorEnv(BaseEnv):
         object_color_id: int = 0,
         distractor_max: int = 3,
         object_size_jiggle: float = 0.2,
+        target_size_scale: float | None = None,
+        distractor_size_scales: list[float] | tuple[float, ...] | None = None,
         task_difficulty: float = 1.0,
         show_goal_site: bool = False,
         reconfiguration_freq: Optional[int] = None,
@@ -161,6 +163,14 @@ class VerbObjectColorEnv(BaseEnv):
             )
         self.distractor_max = max(0, min(3, int(distractor_max)))
         self.object_size_jiggle = max(0.0, float(object_size_jiggle))
+        self.target_size_scale = (
+            None if target_size_scale is None else max(0.2, float(target_size_scale))
+        )
+        self.distractor_size_scales = (
+            None
+            if distractor_size_scales is None
+            else [max(0.2, float(x)) for x in distractor_size_scales]
+        )
         self.task_difficulty = float(np.clip(float(task_difficulty), 0.5, 3.0))
         self.show_goal_site = show_goal_site
         self.object_color = OBJECT_COLORS_VERB[self.object_color_id]
@@ -257,7 +267,11 @@ class VerbObjectColorEnv(BaseEnv):
             self.object_shape,
             self.object_color,
             name="target_obj",
-            size_scale=self._sample_tabletop_size_scale(),
+            size_scale=(
+                self.target_size_scale
+                if self.target_size_scale is not None
+                else self._sample_tabletop_size_scale()
+            ),
         )
         # Alias for motion-planning code that expects ``cube``
         self.cube = self.obj
@@ -301,12 +315,16 @@ class VerbObjectColorEnv(BaseEnv):
             else:
                 sh, cid = self._sample_distractor_shape_color_id()
             col = OBJECT_COLORS_VERB[cid]
+            if self.distractor_size_scales is not None and i < len(self.distractor_size_scales):
+                d_scale = self.distractor_size_scales[i]
+            else:
+                d_scale = self._sample_tabletop_size_scale()
             act, rz = build_tabletop_object(
                 self.scene,
                 sh,
                 col,
                 name=f"distractor_{i}",
-                size_scale=self._sample_tabletop_size_scale(),
+                size_scale=d_scale,
             )
             self.distractor_actors.append(act)
             self._distractor_rest_z.append(rz)