| """Wrist-only RGB-D Stereo-ACT-cross_relbias trainer for RoboFactory. |
| |
| One shared policy sees only one local Panda wrist RGB-D stream at a time. RGB |
| uses frozen DINOv3-B/16; native ManiSkill depth (stored in millimetres) uses |
| frozen DeFM-S/14. Both become 30x40 patches before two region-aligned |
| cross_relbias fusion blocks and the standard ACT 4/7 CVAE policy. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import os |
| from collections import Counter, OrderedDict, defaultdict |
| from pathlib import Path |
|
|
| import h5py |
| import numpy as np |
| import torch |
| import torch.nn as nn |
| from torch.utils.data import DataLoader, Dataset |
|
|
| from rgbd_patch_fusion import RGBDPatchFusion |
| from train_act import ACT, EpisodeBlockBatchSampler, _stats, _trajectories, seed_everything |
| from five_task_contract import hierarchical_item_weights |
|
|
|
|
| DEPTH_MM_TO_M = 0.001 |
|
|
|
|
| class WristRGBDACTDataset(Dataset): |
| def __init__(self, trajectories, horizon, stats, train, *, preload=True, cache_limit=0): |
| self.horizon, self.stats, self.cache_limit = horizon, stats, int(cache_limit) |
| kept = [item for index, item in enumerate(trajectories) if (index % 10 != 0) == train] |
| self.items = [(path, key, t, arm, task) for path, key, n, present, task in kept |
| for arm in present for t in range(n)] |
| self.item_tasks = [task for _, _, _, _, task in self.items] |
| self.item_weights = hierarchical_item_weights(kept, self.items) |
| self.stream_indices = defaultdict(list) |
| for index, (path, key, _t, arm, task) in enumerate(self.items): |
| self.stream_indices[(path, key, arm, task)].append(index) |
| self.cache = OrderedDict() |
| if preload: |
| for path, key, _, present, _ in kept: |
| for arm in present: |
| self._episode(path, key, arm) |
|
|
| def __len__(self): |
| return len(self.items) |
|
|
| def _episode(self, path, key, arm): |
| tag = (path, key, arm) |
| if tag not in self.cache: |
| with h5py.File(path, "r") as h5: |
| tr = h5[key] |
| sensor = tr["obs"]["sensor_data"][f"head_camera_agent{arm}"] |
| if "depth" not in sensor: |
| raise ValueError(f"Stereo-ACT needs rgbd corpus; missing depth in {path}:{key}") |
| rgb, depth = sensor["rgb"][:], sensor["depth"][:] |
| if tuple(rgb.shape[1:]) != (480, 640, 3) or tuple(depth.shape[1:]) != (480, 640, 1): |
| raise ValueError( |
| f"strict 640x480 RGB-D required; {path}:{key}:panda-{arm} has " |
| f"rgb={tuple(rgb.shape[1:])}, depth={tuple(depth.shape[1:])}" |
| ) |
| self.cache[tag] = ( |
| rgb, depth, |
| tr["obs"]["agent"][f"panda-{arm}"]["qpos"][:].astype(np.float32), |
| tr["actions"][f"panda-{arm}"][:].astype(np.float32), |
| ) |
| if self.cache_limit > 0: |
| while len(self.cache) > self.cache_limit: |
| self.cache.popitem(last=False) |
| else: |
| self.cache.move_to_end(tag) |
| return self.cache[tag] |
|
|
| def __getitem__(self, index): |
| path, key, t, arm, _ = self.items[index] |
| rgb, depth, qpos, actions = self._episode(path, key, arm) |
| future = actions[t:t + self.horizon] |
| valid = len(future) |
| padded = np.empty((self.horizon, actions.shape[1]), np.float32) |
| padded[:valid], padded[valid:] = future, future[-1] |
| mask = np.zeros(self.horizon, np.bool_); mask[:valid] = True |
| return ( |
| torch.from_numpy(rgb[t]).permute(2, 0, 1).contiguous(), |
| torch.from_numpy(depth[t]).permute(2, 0, 1).contiguous(), |
| torch.from_numpy((qpos[t] - self.stats["q_mean"]) / self.stats["q_std"]), |
| torch.from_numpy((padded - self.stats["a_mean"]) / self.stats["a_std"]), |
| torch.from_numpy(mask), |
| ) |
|
|
|
|
| class StereoACT(ACT): |
| def __init__(self, state_dim, action_dim, horizon=100, d_model=384, enc_layers=4, dec_layers=7, |
| dino_model="facebook/dinov3-vitb16-pretrain-lvd1689m", defm_model="defm_vit_s14"): |
| super().__init__(state_dim, action_dim, horizon, d_model, enc_layers, dec_layers, |
| vision_backbone="dinov3_vitb16_frozen", dino_model=dino_model) |
| from defm.model_factory import create_defm_model |
| self.defm_model_name = defm_model |
| |
| |
| |
| checkpoint = os.environ.get("DEFM_CHECKPOINT") |
| self.defm = create_defm_model( |
| defm_model, pretrained=True, pretrained_path=checkpoint |
| ).eval() |
| self.defm.requires_grad_(False) |
| self.depth_proj = nn.Linear(384, d_model) |
| self.fusion = RGBDPatchFusion(d_model=d_model, heads=8, grid_h=30, grid_w=40, |
| layers=2, ffn_dim=d_model * 4) |
| self.fusion_pos = nn.Parameter(torch.randn(1, 30 * 40, d_model) * 0.02) |
|
|
| def train(self, mode=True): |
| super().train(mode) |
| self.vision.eval(); self.defm.eval() |
| return self |
|
|
| def _rgbd_tokens(self, rgb, depth_mm): |
| |
| rgb_tokens = super()._vision_tokens(rgb) |
| from defm.utils.utils import preprocess_depth_batch |
| depth_m = depth_mm.float().squeeze(1).mul(DEPTH_MM_TO_M) |
| prepared = preprocess_depth_batch(depth_m, target_size=(420, 560), patch_size=14, device=rgb.device) |
| self.defm.eval() |
| with torch.no_grad(): |
| spatial, _ = self.defm.to(rgb.device).get_intermediate_layers( |
| prepared.float(), n=1, reshape=True, return_class_token=True |
| )[0] |
| depth_tokens = self.depth_proj(spatial.flatten(2).transpose(1, 2).to(dtype=rgb_tokens.dtype)) |
| if rgb_tokens.shape[1] != 30 * 40 or depth_tokens.shape[1] != 30 * 40: |
| raise ValueError( |
| f"strict aligned 30x40 tokens required, got RGB={rgb_tokens.shape[1]} " |
| f"and depth={depth_tokens.shape[1]}" |
| ) |
| return self.fusion(rgb_tokens, depth_tokens, self.fusion_pos.to(dtype=rgb_tokens.dtype)) |
|
|
| def forward(self, image, depth_mm, qpos, actions=None): |
| x = self._rgbd_tokens(image, depth_mm) |
| state = self.state(qpos).unsqueeze(1) |
| if actions is not None: |
| h = self.posterior(self.action(actions) + self.pos) |
| mu, logvar = self.latent(h.mean(1)).chunk(2, -1) |
| z = mu + torch.randn_like(mu) * torch.exp(.5 * logvar) |
| else: |
| mu = logvar = None |
| z = torch.zeros((image.shape[0], self.z_proj.in_features), device=image.device) |
| memory = torch.cat((state, self.z_proj(z).unsqueeze(1), x), dim=1) |
| return self.out(self.decoder(self.query.expand(image.shape[0], -1, -1), memory)), mu, logvar |
|
|
|
|
| def loss(model, rgb, depth, qpos, actions, mask, beta): |
| rgb = rgb.float().div_(255) |
| with torch.autocast("cuda", dtype=torch.bfloat16): |
| pred, mu, logvar = model(rgb, depth, qpos, actions) |
| mse = ((pred - actions).square().mean(-1) * mask).sum() / mask.sum().clamp_min(1) |
| kl = -.5 * (1 + logvar - mu.square() - logvar.exp()).sum(-1).mean() |
| return mse + beta * kl, mse, kl |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--data", required=True) |
| parser.add_argument("--shared-arms", default="0,1") |
| parser.add_argument("--output", required=True) |
| |
| |
| parser.add_argument("--batch-size", type=int, default=32) |
| parser.add_argument("--updates", type=int, default=60000) |
| parser.add_argument("--save-updates", default="20000,40000,60000") |
| parser.add_argument("--lr", type=float, default=2e-4) |
| parser.add_argument("--beta", type=float, default=1e-3) |
| parser.add_argument("--workers", type=int, default=0) |
| parser.add_argument("--cache-episodes", type=int, default=0, |
| help="Bound decoded episode cache; 0 preloads all trajectories.") |
| parser.add_argument("--episode-block-updates", type=int, default=64) |
| parser.add_argument("--task-balanced", action="store_true") |
| parser.add_argument("--seed", type=int, default=20260724) |
| args = parser.parse_args() |
| import glob |
| arms = tuple(int(item) for item in args.shared_arms.split(",")) |
| paths = sorted({path for item in args.data.split(",") for path in glob.glob(item)}) |
| trajectories = _trajectories(paths, arms) |
| if len(trajectories) < 10: |
| raise ValueError("need at least 10 successful RGB-D demonstrations") |
| seed_everything(args.seed); torch.backends.cudnn.benchmark = True |
| stats = _stats(trajectories, arms) |
| lazy_cache = args.cache_episodes > 0 |
| if lazy_cache and args.workers: |
| raise ValueError("bounded RGB-D cache requires --workers 0 to keep a single cache") |
| train = WristRGBDACTDataset(trajectories, 100, stats, True, preload=not lazy_cache, |
| cache_limit=args.cache_episodes) |
| valid = WristRGBDACTDataset(trajectories, 100, stats, False, preload=False, |
| cache_limit=args.cache_episodes) |
| counts = Counter(train.item_tasks) |
| sampler = None |
| if lazy_cache: |
| sampler = EpisodeBlockBatchSampler(train, args.batch_size, args.updates, |
| args.episode_block_updates, args.seed, args.task_balanced) |
| loader = DataLoader(train, batch_sampler=sampler, num_workers=0, pin_memory=True) |
| elif args.task_balanced and len(counts) > 1: |
| weights = torch.as_tensor(train.item_weights, dtype=torch.double) |
| sampler = torch.utils.data.WeightedRandomSampler(weights, num_samples=len(weights), replacement=True) |
| if not lazy_cache: |
| loader = DataLoader(train, batch_size=args.batch_size, shuffle=sampler is None, sampler=sampler, |
| drop_last=True, num_workers=args.workers, pin_memory=True, |
| persistent_workers=args.workers > 0) |
| device = torch.device("cuda:0") |
| sample = train[0] |
| model = StereoACT(len(sample[2]), len(sample[3][0])).to(device) |
| optimizer = torch.optim.AdamW((p for p in model.parameters() if p.requires_grad), lr=args.lr, weight_decay=1e-4) |
| scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, args.updates) |
| output = Path(args.output); output.mkdir(parents=True, exist_ok=True) |
| config = vars(args) | {"horizon": 100, "enc_layers": 4, "dec_layers": 7, "d_model": 384, |
| "vision_backbone": "stereo_act_cross_relbias", |
| "dino_model": "facebook/dinov3-vitb16-pretrain-lvd1689m", "defm_model": model.defm_model_name, |
| "defm_checkpoint": os.environ.get("DEFM_CHECKPOINT"), |
| "camera_width": 640, "camera_height": 480, "patch_grid": [30, 40], "fusion_layers": 2, |
| "depth_storage_unit": "millimeters", "depth_to_meters_scale": DEPTH_MM_TO_M, |
| "arms": arms, "state_dim": len(sample[2]), "action_dim": len(sample[3][0]), |
| "files": paths, "episodes": len(trajectories), "train_task_item_counts": dict(counts)} |
| (output / "config.json").write_text(json.dumps(config, indent=2)) |
| np.savez(output / "normalization.npz", **stats) |
| milestones, updates = {int(x) for x in args.save_updates.split(",") if x}, 0 |
| while updates < args.updates: |
| model.train(); totals = {"loss": 0.0, "mse": 0.0, "kl": 0.0, "n": 0} |
| for rgb, depth, qpos, actions, mask in loader: |
| rgb, depth, qpos, actions, mask = (item.to(device, non_blocking=True) for item in (rgb, depth, qpos, actions, mask)) |
| optimizer.zero_grad(set_to_none=True) |
| total, mse, kl = loss(model, rgb, depth, qpos, actions, mask, args.beta) |
| total.backward(); torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0) |
| optimizer.step(); scheduler.step(); updates += 1 |
| batch = len(rgb) |
| for name, value in (("loss", total), ("mse", mse), ("kl", kl)): |
| totals[name] += float(value.detach()) * batch |
| totals["n"] += batch |
| if updates in milestones: |
| torch.save({"model": model.state_dict(), "stats": stats, "config": config, "update": updates}, |
| output / f"checkpoint_{updates:06d}.pt") |
| if updates % 100 == 0: |
| print(json.dumps({"update": updates, **{key: value / totals["n"] for key, value in totals.items() if key != "n"}}), flush=True) |
| if updates >= args.updates: |
| break |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
