import numpy as np import click import zarr from diffusion_policy.common.replay_buffer import ReplayBuffer from diffusion_policy.env.pusht.pusht_keypoints_env import PushTKeypointsEnv import pygame # --- Mixed-mode controlled collection --- # Seed parity determines mode: even = LEFT, odd = RIGHT. # After each saved episode, the integer mode (0=LEFT, 1=RIGHT) and the final # coverage are appended to meta/episode_modes and meta/episode_coverages in # the zarr, alongside the standard meta/episode_ends. MODE_NAMES = {0: 'LEFT', 1: 'RIGHT'} MODE_COLORS = {0: (220, 30, 30), 1: (30, 80, 220)} # red for LEFT, blue for RIGHT SUCCESS_THRESHOLD = 0.95 # matches PushTEnv.success_threshold _FONT_CACHE = {} def _font(size, bold=False): key = (size, bold) if key not in _FONT_CACHE: if not pygame.font.get_init(): pygame.font.init() _FONT_CACHE[key] = pygame.font.SysFont(None, size, bold=bold) return _FONT_CACHE[key] def draw_overlay(mode_int, seed, coverage): """Blit mode label + live coverage bar over the env render and flip.""" screen = pygame.display.get_surface() if screen is None: return w = screen.get_width() color = MODE_COLORS[mode_int] name = MODE_NAMES[mode_int] pad = 6 # Mode label: large text top-left with translucent backdrop mode_font = _font(56, bold=True) mode_surf = mode_font.render(name, True, color) mode_rect = mode_surf.get_rect(topleft=(10, 6)) bg = pygame.Surface((mode_rect.width + pad * 2, mode_rect.height + pad * 2), pygame.SRCALPHA) bg.fill((255, 255, 255, 200)) screen.blit(bg, (mode_rect.x - pad, mode_rect.y - pad)) screen.blit(mode_surf, mode_rect) # Seed number under the mode label seed_font = _font(20) seed_surf = seed_font.render(f'seed {seed}', True, (40, 40, 40)) seed_rect = seed_surf.get_rect(topleft=(10, mode_rect.bottom + 4)) sbg = pygame.Surface((seed_rect.width + pad * 2, seed_rect.height + pad), pygame.SRCALPHA) sbg.fill((255, 255, 255, 180)) screen.blit(sbg, (seed_rect.x - pad, seed_rect.y - pad // 2)) screen.blit(seed_surf, seed_rect) # Coverage bar across the top-right: shows current IoU coverage out of 95% bar_w = 200 bar_h = 18 bar_x = w - bar_w - 10 bar_y = 12 pygame.draw.rect(screen, (255, 255, 255), (bar_x, bar_y, bar_w, bar_h)) pygame.draw.rect(screen, (60, 60, 60), (bar_x, bar_y, bar_w, bar_h), 1) cov_frac = float(min(coverage, SUCCESS_THRESHOLD)) / SUCCESS_THRESHOLD fill_w = int(bar_w * cov_frac) if cov_frac < 0.6: bar_color = (180, 40, 40) elif cov_frac < 0.9: bar_color = (200, 150, 30) else: bar_color = (40, 170, 60) pygame.draw.rect(screen, bar_color, (bar_x, bar_y, fill_w, bar_h)) cov_pct = coverage * 100.0 cov_font = _font(18, bold=True) cov_surf = cov_font.render(f'IoU {cov_pct:5.1f}% / 95%', True, (20, 20, 20)) cov_rect = cov_surf.get_rect(topright=(w - 10, bar_y + bar_h + 4)) cbg = pygame.Surface((cov_rect.width + pad * 2, cov_rect.height + pad), pygame.SRCALPHA) cbg.fill((255, 255, 255, 200)) screen.blit(cbg, (cov_rect.x - pad, cov_rect.y - pad // 2)) screen.blit(cov_surf, cov_rect) # Keybinding hint at the bottom hint_font = _font(16) hint_surf = hint_font.render('S save C cancel R retry Q quit', True, (30, 30, 30)) hint_rect = hint_surf.get_rect(midbottom=(w // 2, screen.get_height() - 4)) hbg = pygame.Surface((hint_rect.width + pad * 2, hint_rect.height + pad), pygame.SRCALPHA) hbg.fill((255, 255, 255, 200)) screen.blit(hbg, (hint_rect.x - pad, hint_rect.y - pad // 2)) screen.blit(hint_surf, hint_rect) pygame.display.flip() def append_episode_metadata(zarr_path, mode_int, coverage): """Append (mode, coverage) to meta/episode_modes and meta/episode_coverages.""" root = zarr.open(zarr_path, mode='a') meta = root.require_group('meta') if 'episode_modes' in meta: arr = meta['episode_modes'] arr.resize((arr.shape[0] + 1,)) arr[-1] = mode_int else: meta.create_dataset( 'episode_modes', data=np.array([mode_int], dtype='i1'), chunks=(64,), dtype='i1', ) if 'episode_coverages' in meta: arr = meta['episode_coverages'] arr.resize((arr.shape[0] + 1,)) arr[-1] = float(coverage) else: meta.create_dataset( 'episode_coverages', data=np.array([coverage], dtype='f4'), chunks=(64,), dtype='f4', ) @click.command() @click.option('-o', '--output', required=True) @click.option('-rs', '--render_size', default=96, type=int) @click.option('-hz', '--control_hz', default=10, type=int) def main(output, render_size, control_hz): """ Mixed-mode Push-T teleop with controlled init. Mode auto-assigned by seed parity: seed even = LEFT (wrap T from upper-left side, red label) seed odd = RIGHT (wrap T from lower-right side, blue label) Saved per episode in the zarr: data/{state,action,img,keypoint,n_contacts} meta/episode_ends (standard DP layout) meta/episode_modes (int8: 0=LEFT, 1=RIGHT) meta/episode_coverages (float32: final IoU coverage, 0..1) Keys: S = save current episode now (no need to reach 95% IoU) C = cancel current episode and restart same seed R = same as C (retry) Q = quit (script exits; saved episodes persist) Space = pause """ replay_buffer = ReplayBuffer.create_from_path(output, mode='a') kp_kwargs = PushTKeypointsEnv.genenerate_keypoint_manager_params() env = PushTKeypointsEnv(render_size=render_size, render_action=False, **kp_kwargs) agent = env.teleop_agent() clock = pygame.time.Clock() while True: episode = list() seed = replay_buffer.n_episodes mode_int = seed % 2 mode_name = MODE_NAMES[mode_int] print(f'starting seed {seed} mode={mode_name}', flush=True) # --- Controlled init: T fixed on 45-deg symmetry axis through goal, # agent perturbed +/- 15 px around (327, 185). T_INIT_XY = np.array([185.0, 327.0]) T_INIT_ANG = np.pi / 4 AGENT_NOMINAL = np.array([327.0, 185.0]) np.random.seed(seed) agent_xy = AGENT_NOMINAL + np.random.uniform(-15, 15, size=2) init_state = np.array( [agent_xy[0], agent_xy[1], T_INIT_XY[0], T_INIT_XY[1], T_INIT_ANG], dtype=np.float64, ) env.reset_to_state = init_state env.seed(seed) # --- end controlled init obs = env.reset() info = env._get_info() img = env.render(mode='human') retry = False force_save = False pause = False done = False coverage = 0.0 pygame.display.set_caption( f'[{mode_name}] seed {seed} IoU {coverage*100:.1f}% / 95%') draw_overlay(mode_int, seed, coverage) while not (done or force_save or retry): for event in pygame.event.get(): if event.type == pygame.KEYDOWN: if event.key == pygame.K_SPACE: pause = True elif event.key in (pygame.K_r, pygame.K_c): retry = True elif event.key == pygame.K_s: force_save = True elif event.key == pygame.K_q: exit(0) if event.type == pygame.KEYUP: if event.key == pygame.K_SPACE: pause = False if retry or force_save: break if pause: continue act = agent.act(obs) if act is not None: state = np.concatenate([info['pos_agent'], info['block_pose']]) keypoint = obs.reshape(2, -1)[0].reshape(-1, 2)[:9] data = { 'img': img, 'state': np.float32(state), 'keypoint': np.float32(keypoint), 'action': np.float32(act), 'n_contacts': np.float32([info['n_contacts']]), } episode.append(data) obs, reward, done, info = env.step(act) # reward = clip(coverage / 0.95, 0, 1) per PushTEnv.step coverage = float(reward) * SUCCESS_THRESHOLD img = env.render(mode='human') pygame.display.set_caption( f'[{mode_name}] seed {seed} IoU {coverage*100:.1f}% / 95%') draw_overlay(mode_int, seed, coverage) clock.tick(control_hz) if retry: print(f'cancel seed {seed} mode={mode_name}', flush=True) continue if not episode: print(f'skip seed {seed} (no teleop data — mouse never engaged)', flush=True) continue data_dict = dict() for key in episode[0].keys(): data_dict[key] = np.stack([x[key] for x in episode]) replay_buffer.add_episode(data_dict, compressors='disk') append_episode_metadata(output, mode_int, coverage) suffix = ' [PARTIAL]' if force_save and not done else '' print(f'saved seed {seed} mode={mode_name} ' f'IoU={coverage*100:.1f}%{suffix} ' f'(total {replay_buffer.n_episodes} episodes)', flush=True) if __name__ == "__main__": main()