import torch import torch.nn as nn from collections import deque import torchvision.transforms.functional as TF import torchvision.transforms as T from dataclasses import dataclass import sys import os current_path = os.path.dirname(os.path.abspath(__file__)) #sys.path.insert(0, current_path) from act.detr.backbone import build_backbone from act.detr.transformer import build_transformer from act.detr.detr_vae import build_encoder, DETRVAE @dataclass class Args: torch_deterministic: bool = True """if toggled, `torch.backends.cudnn.deterministic=False`""" cuda: bool = True """if toggled, cuda will be enabled by default""" temporal_agg: bool = True """if toggled, temporal ensembling will be performed at inference""" # Backbone position_embedding: str = 'sine' backbone: str = 'resnet18' lr_backbone: float = 1e-5 masks: bool = False dilation: bool = False include_depth: bool = False """always False — depth not collected; kept for backbone API compatibility""" include_rgb: bool = True """use RGB images as input (requires --save_images during collection)""" # Transformer enc_layers: int = 2 dec_layers: int = 4 dim_feedforward: int = 512 hidden_dim: int = 256 dropout: float = 0.1 nheads: int = 8 num_queries: int = 30 pre_norm: bool = False use_xsa: bool = False class Agent(nn.Module): def __init__(self, state_dim: int, act_dim: int, args: Args): super().__init__() self.device = 'cuda' self.state_dim = state_dim self.act_dim = act_dim self.normalize = T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) self.include_rgb = args.include_rgb # CNN backbone — None for state-only mode (DETRVAE handles both paths) backbones = [build_backbone(args)] if args.include_rgb else None # CVAE decoder transformer = build_transformer(args) # CVAE encoder encoder = build_encoder(args) # ACT ( CVAE encoder + (CNN backbones + CVAE decoder) ) self.model = DETRVAE( backbones, transformer, encoder, state_dim=state_dim, action_dim=act_dim, num_queries=args.num_queries, ) def _preprocess_rgb(self, obs: dict) -> None: if self.include_rgb and 'rgb' in obs: obs['rgb'] = obs['rgb'].float() / 255.0 # obs['rgb']: (B, num_cams, 3, 224, 224) B, N, C, H, W = obs['rgb'].shape obs['rgb'] = self.normalize(obs['rgb'].view(B * N, C, H, W)).view(B, N, C, H, W) def _model_input(self, obs: dict): # DETRVAE state-only path expects the state tensor directly, not a dict return obs if self.include_rgb else obs['state'] def get_action(self, obs: dict) -> torch.Tensor: self._preprocess_rgb(obs) a_hat, _ = self.model(self._model_input(obs)) return a_hat class AlgSolution: # Slice into proprio for joint positions (relative to default). _QPOS_SLICE = slice(0, 8) _QVEL_SLICE = slice(8, 16) _RGB_CHANNELS = 3 _CONCAT_IMAGE_CHANNELS = 8 def __init__(self): self.device = 'cuda' # Default to the submission-layout policy file, but allow local eval to # point at a checkpoint without copying 100MB+ files around. policy_path = os.environ.get("ATEC_ACT_POLICY_PATH", current_path + '/policy_act.pt') ckpt = torch.load(policy_path, map_location=self.device) norm_stats = ckpt["norm_stats"] state_dim = norm_stats["state_mean"].shape[-1] act_dim = norm_stats["action_mean"].shape[-1] weight_key = "ema_agent"# if use_ema and "ema_agent" in ckpt else "agent" train_args = Args() model_args = ckpt.get("model_args", {}) for key in ( "enc_layers", "dec_layers", "dim_feedforward", "hidden_dim", "dropout", "nheads", "num_queries", "pre_norm", "use_xsa", ): if key in model_args: setattr(train_args, key, model_args[key]) train_args.include_rgb = model_args.get( "include_rgb", any("backbone" in k for k in ckpt[weight_key].keys()), ) self.agent = Agent(state_dim, act_dim, train_args).to(self.device) self.agent.load_state_dict(ckpt[weight_key]) self.agent.eval() self.num_queries = train_args.num_queries self.temporal_agg = os.environ.get("ATEC_ACT_TEMPORAL_AGG", "1").lower() not in ("0", "false", "no") self._k = float(os.environ.get("ATEC_ACT_TEMPORAL_K", "0.01")) self._prefer_new_actions = os.environ.get("ATEC_ACT_PREFER_NEW", "0").lower() in ("1", "true", "yes") self.state_mean = norm_stats["state_mean"].to(self.device) # (1, state_dim) self.state_std = norm_stats["state_std"].to(self.device) # (1, state_dim) self.act_mean = norm_stats["action_mean"].to(self.device) # (1, act_dim) self.act_std = norm_stats["action_std"].to(self.device) # (1, act_dim) self.default_joint_pos = torch.tensor( [[0.0, 1.2, -1.5, 0.0, 1.2, 0.0, 0.035, -0.035]], dtype=torch.float32, device=self.device, ) # Per-episode state self._ts: int = 0 self._action_history: deque = deque(maxlen=self.num_queries) self._last_action_seq: torch.Tensor | None = None startup_zero_steps = 25 home_qpos_tolerance = 0.10 home_hold_steps = 5 self.teleop_home_joint_pos = torch.tensor( [[-0.000033, 0.924525, -1.514983, 0.000011, 1.219900, -0.000033, 0.035000, -0.035000]], dtype=torch.float32, device=self.device, ) self._startup_zero_steps = max(0, int(startup_zero_steps)) self._home_qpos_tolerance = float(home_qpos_tolerance) self._home_hold_steps = max(0, int(home_hold_steps)) self._home_action = torch.clamp( (self.teleop_home_joint_pos - self.default_joint_pos) / 0.5, -1.0, 1.0, ) self._startup_step = 0 self._home_stable_steps = 0 self._home_done = False def reset_episode(self): self._ts = 0 self._action_history.clear() self._last_action_seq = None self._startup_step = 0 self._home_stable_steps = 0 self._home_done = False def get_action_spec(self): # Use the official default Task-E Piper action configuration. return None def _compute_home_action(self, proprio): joint_pos_rel = proprio[:, self._QPOS_SLICE] qpos = joint_pos_rel + self.default_joint_pos qerr = self.teleop_home_joint_pos - qpos within_tolerance = torch.all(torch.abs(qerr) <= self._home_qpos_tolerance, dim=1) self._home_stable_steps = self._home_stable_steps + 1 if bool(torch.all(within_tolerance)) else 0 # Env action is a relative joint-position target, not velocity/torque. # Keep commanding the absolute teleop-home target until the ACT rollout starts. action = self._home_action.repeat(proprio.shape[0], 1) home_reached = self._home_stable_steps >= self._home_hold_steps return action, home_reached def predicts(self, obs, current_score): if not isinstance(obs, dict) or "proprio" not in obs: raise ValueError("Expected obs dict with 'proprio' key.") proprio = obs["proprio"].to(self.device) # (num_envs, 24) # Stage 1: output zero actions for the first few steps. if self._startup_step < self._startup_zero_steps: self._startup_step += 1 return {'action': torch.zeros((proprio.shape[0], self.agent.act_dim)).numpy().tolist(), 'giveup': False} # Stage 2: move to teleop_home using only observations. if not self._home_done: home_action, home_reached = self._compute_home_action(proprio) if home_reached: self._home_done = True self._ts = 0 self._action_history.clear() self._last_action_seq = None return {'action': home_action.cpu().numpy().tolist(), 'giveup': False} # Recover absolute joint positions from relative obs. joint_pos_rel = proprio[:, self._QPOS_SLICE] # (num_envs, 8) qpos = joint_pos_rel + self.default_joint_pos # (num_envs, 8) state = (qpos - self.state_mean) / self.state_std # (num_envs, 8) model_obs = {"state": state} if self.agent.include_rgb: rgb = obs["image"]["video_rgb"].to(self.device) if rgb.shape[1] == 4: rgb = rgb[:, :3] # drop alpha if RGBA/NCHW if rgb.ndim == 4 and rgb.shape[-1] == 4: rgb = rgb[..., :3] # drop alpha if RGBA/NHWC if rgb.dtype != torch.uint8: rgb = (rgb.float() * 255.0).clamp(0, 255).to(torch.uint8) if rgb.ndim == 4 and rgb.shape[1] in (3, 4): pass else: rgb = rgb.permute(0, 3, 1, 2) if rgb.shape[-2:] != (224, 224): rgb = TF.resize(rgb, [224, 224], interpolation=TF.InterpolationMode.BILINEAR, antialias=True) model_obs["rgb"] = rgb.unsqueeze(1) # (num_envs, 1, 3, 224, 224) uint8 ts = self._ts query_frequency = 1 if self.temporal_agg else self.num_queries if ts % query_frequency == 0: with torch.no_grad(): action_seq = self.agent.get_action(model_obs) # (num_envs, num_queries, act_dim) if self.temporal_agg: self._action_history.append(action_seq) else: self._last_action_seq = action_seq if self.temporal_agg: n = len(self._action_history) # deque[i=0] = oldest (added n-1 steps ago); for current step its offset = n-1-i actions_for_curr = torch.stack( [seq[:, n - 1 - i, :] for i, seq in enumerate(self._action_history)], dim=1, ) # (num_envs, n, act_dim) # Default preserves the original convention. ATECs long-horizon # rollout can also be evaluated with newer predictions weighted # higher via ATEC_ACT_PREFER_NEW=1. order = torch.arange(n, device=self.device) if self._prefer_new_actions: order = torch.flip(order, dims=[0]) exp_weights = torch.exp(-self._k * order) exp_weights = (exp_weights / exp_weights.sum()).unsqueeze(0).unsqueeze(-1) raw_action = (actions_for_curr * exp_weights).sum(dim=1) # (num_envs, act_dim) else: raw_action = self._last_action_seq[:, ts % query_frequency] # (num_envs, act_dim) # Denormalise → env action format action = raw_action * self.act_std + self.act_mean self._ts += 1 return {'action': action.tolist(), 'giveup': False}