| """OpenAI Gym wrapper for the CLEVRER-lite environment. |
| |
| env = CLEVRERLiteEnv() |
| obs, info = env.reset(seed=0) |
| obs, reward, terminated, truncated, info = env.step(env.action_space.sample()) |
| |
| Observation: (frame_size, frame_size, 3) uint8 RGB frame (top-down view). |
| Action: Discrete(5) - {noop, push probe ball E/N/W/S}. |
| With ``probe=False`` every action is a no-op, giving the purely |
| passive CLEVRER dynamics. |
| Reward: 0.0 (the task is video reasoning, not control). |
| Info: per-frame physics state + collisions so far. |
| |
| The env records the full trajectory, so after an episode you can call |
| ``extract_events()`` / ``build_questions()`` to get CLEVRER-style annotations. |
| """ |
|
|
| import numpy as np |
|
|
| try: |
| import gym |
| except ImportError: |
| import gymnasium as gym |
| from gym import spaces |
|
|
| from . import config, renderer, simulate, events as events_mod, questions as questions_mod |
|
|
|
|
| class CLEVRERLiteEnv(gym.Env): |
| """A CLEVRER-like world of colliding objects as a gym environment.""" |
|
|
| metadata = { |
| "render_modes": ["rgb_array"], |
| "render_fps": int(round(1.0 / config.FRAME_DT)), |
| } |
|
|
| def __init__(self, num_objects=(3, 6), num_frames=64, frame_size=128, |
| probe=False, min_collisions=2, min_initially_moving=2, |
| render_mode=None): |
| self.num_objects = (tuple(num_objects) if isinstance(num_objects, (tuple, list)) |
| else (int(num_objects), int(num_objects))) |
| self.num_frames = int(num_frames) |
| self.frame_size = int(frame_size) |
| self.probe = bool(probe) |
| self.min_collisions = int(min_collisions) |
| self.min_initially_moving = int(min_initially_moving) |
| self.render_mode = render_mode |
|
|
| self.observation_space = spaces.Box(0, 255, (self.frame_size, self.frame_size, 3), |
| np.uint8) |
| self.action_space = spaces.Discrete(len(config.ACTION_LABELS)) |
|
|
| |
| self._spec = None |
| self._bodies = None |
| self._t = 0 |
| self._last_obs = None |
| self._trajectory = None |
| self._collisions = [] |
| self._wall_hits = [] |
|
|
| |
| def reset(self, *, seed=None, options=None): |
| super().reset(seed=seed) |
| rng = self.np_random |
|
|
| |
| for _ in range(60): |
| spec = simulate.sample_spec(rng, rng.integers(self.num_objects[0], |
| self.num_objects[1] + 1), |
| probe=self.probe) |
| bodies = simulate.bodies_from_spec(spec) |
| out = simulate.rollout(bodies, self.num_frames) |
| ev = events_mod.extract_events(out["states"], out["collisions"], |
| out["wall_hits"], n=len(bodies)) |
| stationary = [i for i in range(len(bodies)) |
| if i not in ev["initially_moving"]] |
| if (len(ev["collisions"]) >= self.min_collisions |
| and len(ev["initially_moving"]) >= self.min_initially_moving |
| and (not self.probe or len(stationary) >= 1)): |
| break |
| else: |
| pass |
|
|
| self._spec = spec |
| self._bodies = simulate.bodies_from_spec(spec) |
| self._t = 0 |
| self._collisions = [] |
| self._wall_hits = [] |
| self._trajectory = np.zeros((self.num_frames, len(self._bodies), 4)) |
| self._last_obs = self._render() |
| return self._last_obs, self._info() |
|
|
| def step(self, action): |
| if self._bodies is None: |
| raise RuntimeError("call reset() before step()") |
| action = int(action) |
|
|
| def action_fn(t, bodies): |
| if self.probe and action != 0: |
| dirs = {1: (1, 0), 2: (0, 1), 3: (-1, 0), 4: (0, -1)} |
| dx, dy = dirs[action] |
| for b in bodies: |
| if b.is_probe: |
| b.vel = b.vel + np.array([dx, dy]) * (config.PROBE_IMPULSE / b.mass) |
|
|
| out = simulate.rollout(self._bodies, 1, render_fn=None, action_fn=action_fn) |
| t = self._t |
| self._trajectory[t] = out["states"][0] |
| for c in out["collisions"]: |
| self._collisions.append((t, c[1], c[2])) |
| for (_, i, ax, s) in out["wall_hits"]: |
| self._wall_hits.append((t, i, ax, s)) |
|
|
| self._t += 1 |
| self._last_obs = self._render() |
| truncated = bool(self._t >= self.num_frames) |
| info = self._info() |
| info.update({ |
| "frame": self._t - 1, |
| "collisions_so_far": len(self._collisions), |
| "latest_collision": self._collisions[-1] if self._collisions else None, |
| "truncated": truncated, |
| }) |
| return self._last_obs, 0.0, False, truncated, info |
|
|
| def render(self): |
| return self._last_obs |
|
|
| def close(self): |
| self._bodies = None |
|
|
| |
| @property |
| def scene(self): |
| """Scene spec (list of dicts) of the current episode.""" |
| return self._spec |
|
|
| @property |
| def trajectory(self): |
| """(T, n, 4) array of (x, y, vx, vy) recorded so far.""" |
| return self._trajectory |
|
|
| def extract_events(self): |
| return events_mod.extract_events(self._trajectory, self._collisions, |
| self._wall_hits, n=len(self._bodies)) |
|
|
| def build_questions(self, ev=None, max_questions=8): |
| ev = ev if ev is not None else self.extract_events() |
| return questions_mod.build_questions(self._spec, ev, self.np_random, |
| self.num_frames, |
| max_questions=max_questions) |
|
|
| |
| def _render(self): |
| return renderer.render(self._bodies, size=self.frame_size) |
|
|
| def _info(self): |
| return { |
| "t": self._t, |
| "objects": [b.idx for b in self._bodies], |
| "positions": np.array([b.pos for b in self._bodies]), |
| "speeds": np.array([b.speed for b in self._bodies]), |
| } |
|
|
