Upload strict640x480-v2/code/train_act.py with huggingface_hub

strict640x480-v2/code/train_act.py

@@ -0,0 +1,466 @@
+"""Decentralized local-observation ACT training for RoboFactory tasks."""
+import argparse
+import copy
+import glob
+import json
+import os
+import random
+from collections import Counter, OrderedDict, defaultdict
+from pathlib import Path
+
+import h5py
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.data import DataLoader, Dataset, Sampler
+from torchvision.models import resnet18
+from five_task_contract import task_from_path
+from five_task_contract import hierarchical_item_weights
+
+
+# Kept module-global deliberately so a parent process can preload a corpus and
+# fork independent CUDA training children.  NumPy image arrays then remain
+# read-only copy-on-write pages shared by the children; ordinary one-process
+# training has exactly the same semantics as before.
+EPISODE_CACHE = OrderedDict()
+
+
+def seed_everything(seed):
+    random.seed(seed); np.random.seed(seed); torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+
+
+def _trajectories(paths, arms):
+    result = []
+    for path in paths:
+        with h5py.File(path, "r") as f:
+            for key in sorted(f.keys()):
+                if key.startswith("traj_"):
+                    tr = f[key]
+                    # A pooled 2+3-agent corpus deliberately contains both
+                    # two-arm and three-arm episodes.  Retain each local policy
+                    # stream that actually exists, instead of requiring the
+                    # absent panda-2 stream in two-arm demonstrations.
+                    present = tuple(
+                        arm for arm in arms
+                        if f"panda-{arm}" in tr["actions"]
+                        and f"panda-{arm}" in tr["obs"]["agent"]
+                        and f"head_camera_agent{arm}" in tr["obs"]["sensor_data"]
+                    )
+                    if not present:
+                        continue
+                    n = min(
+                        len(tr["actions"][f"panda-{arm}"])
+                        for arm in present
+                    )
+                    n = min(
+                        n, *(len(tr["obs"]["agent"][f"panda-{arm}"]["qpos"]) for arm in present),
+                    )
+                    # The source task is retained so mixed-task training can
+                    # balance task probability despite unequal arm counts and
+                    # episode lengths (notably LongPipelineDelivery).
+                    # Canonical sampling label only.  It is never passed to the
+                    # policy, and fixes per-seed LPD files being mistaken for
+                    # separate tasks by mixed-task samplers.
+                    result.append((path, key, n, present, task_from_path(path)))
+    return result
+
+
+def _stats(trajectories, arms):
+    qs, acts = [], []
+    for path, key, _, present, _ in trajectories:
+        with h5py.File(path, "r") as f:
+            tr = f[key]
+            for arm in present:
+                qs.append(np.asarray(tr["obs"]["agent"][f"panda-{arm}"]["qpos"], np.float32))
+                acts.append(np.asarray(tr["actions"][f"panda-{arm}"], np.float32))
+    q, a = np.concatenate(qs), np.concatenate(acts)
+    return {"q_mean": q.mean(0), "q_std": q.std(0).clip(1e-4),
+            "a_mean": a.mean(0), "a_std": a.std(0).clip(1e-4)}
+
+
+class RoboFactoryACTDataset(Dataset):
+    def __init__(self, trajectories, arms, horizon, stats, train, *, preload=True, cache_limit=0):
+        self.arms, self.horizon, self.stats = tuple(arms), horizon, stats
+        self.cache_limit = int(cache_limit)
+        # Keep entire episodes together: predictable held-out demonstrations.
+        kept = [x for i, x in enumerate(trajectories) if (i % 10 != 0) == train]
+        # A/B views of one joint episode always share a split: no paired leakage.
+        self.items = [
+            (p, k, t, arm, task)
+            for p, k, 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, _, arm, task) in enumerate(self.items):
+            self.stream_indices[(path, key, arm, task)].append(index)
+        # This is deliberately RAM-resident. With random ACT batches, lazy episode
+        # caching repeatedly decompresses 20+ MB RGB trajectories for one frame.
+        # The host has 192 GB RAM; keeping this single-task corpus in memory turns
+        # that I/O bottleneck into continuous GPU training.
+        self.cache = EPISODE_CACHE
+        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 f:
+                tr = f[key]
+                cam = tr["obs"]["sensor_data"][f"head_camera_agent{arm}"]["rgb"][:]
+                qpos = tr["obs"]["agent"][f"panda-{arm}"]["qpos"][:]
+                actions = tr["actions"][f"panda-{arm}"][:].astype(np.float32)
+            self.cache[tag] = (cam, qpos.astype(np.float32), actions)
+            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, idx):
+        path, key, t, arm, _ = self.items[idx]
+        image, qpos, actions = self._episode(path, key, arm)
+        # RGB observations are local to this arm only; no ID or global view.
+        # Keep the camera frame as uint8 until it reaches the GPU. Per-sample
+        # CPU resizing starves two 5090s; batched resize is done in _loss.
+        im = torch.from_numpy(image[t]).permute(2, 0, 1).contiguous()
+        q = (qpos[t] - self.stats["q_mean"]) / self.stats["q_std"]
+        future = actions[t:t + self.horizon]
+        valid = len(future)
+        padded = np.empty((self.horizon, actions.shape[1]), np.float32)
+        padded[:valid] = future
+        padded[valid:] = future[-1]
+        padded = (padded - self.stats["a_mean"]) / self.stats["a_std"]
+        mask = np.zeros(self.horizon, np.bool_); mask[:valid] = True
+        return im, torch.from_numpy(q), torch.from_numpy(padded), torch.from_numpy(mask)
+
+
+class EpisodeBlockBatchSampler(Sampler):
+    """Task-balanced local episode blocks for bounded RGB caching."""
+    def __init__(self, dataset, batch_size, updates, block_updates, seed, task_balanced):
+        if batch_size % 4:
+            raise ValueError("episode-block batching requires batch size divisible by 4")
+        self.batch_size = batch_size
+        self.updates = updates
+        self.block_updates = block_updates
+        self.seed = seed
+        self.epoch = 0
+        self.per_stream = batch_size // 4
+        # Preserve the requested hierarchy: task -> demonstration -> local
+        # arm -> time.  Flat stream sampling would over-represent a four-arm
+        # demonstration simply because it contributes four streams.
+        self.by_task_episode = defaultdict(lambda: defaultdict(list))
+        for (path, key, arm, task), indices in dataset.stream_indices.items():
+            self.by_task_episode[task][(path, key)].append(indices)
+        self.tasks = sorted(self.by_task_episode)
+        self.task_balanced = task_balanced
+        self.all_episodes = [streams for episodes in self.by_task_episode.values() for streams in episodes.values()]
+
+    def __len__(self):
+        return self.updates
+
+    def __iter__(self):
+        rng = random.Random(self.seed + self.epoch)
+        self.epoch += 1
+        produced = 0
+        while produced < self.updates:
+            episodes = self.all_episodes
+            if self.task_balanced:
+                task = self.tasks[rng.randrange(len(self.tasks))]
+                episodes = list(self.by_task_episode[task].values())
+            # Choose a demonstration first and then an arm uniformly within it.
+            streams = [episode[rng.randrange(len(episode))]
+                       for episode in (episodes[rng.randrange(len(episodes))] for _ in range(4))]
+            for _ in range(min(self.block_updates, self.updates - produced)):
+                batch = [
+                    stream[rng.randrange(len(stream))]
+                    for stream in streams
+                    for _ in range(self.per_stream)
+                ]
+                rng.shuffle(batch)
+                yield batch
+                produced += 1
+
+
+class ACT(nn.Module):
+    """ACT-style CVAE with independently configurable action encoder/decoder."""
+    def __init__(self, state_dim, action_dim, horizon=100, d_model=384, enc_layers=4, dec_layers=7,
+                 latent_dim=32, vision_backbone="resnet18",
+                 dino_model="facebook/dinov3-vitb16-pretrain-lvd1689m"):
+        super().__init__()
+        self.vision_backbone = vision_backbone
+        self.dino_model = dino_model
+        if vision_backbone == "resnet18":
+            backbone = resnet18(weights=None)
+            self.vision = nn.Sequential(*list(backbone.children())[:-2])
+            self.vision_proj = nn.Conv2d(512, d_model, 1)
+        elif vision_backbone == "dinov3_vitb16_frozen":
+            # DINOv3 is intentionally a frozen visual head: only the ACT
+            # projection/transformers/policy layers receive gradients.
+            from transformers import AutoImageProcessor, AutoModel
+            token = os.environ.get("HF_TOKEN")
+            processor = AutoImageProcessor.from_pretrained(dino_model, token=token)
+            self.vision = AutoModel.from_pretrained(dino_model, token=token)
+            self.vision.requires_grad_(False)
+            self.vision.eval()
+            self.register_buffer("dino_mean", torch.tensor(processor.image_mean).view(1, -1, 1, 1))
+            self.register_buffer("dino_std", torch.tensor(processor.image_std).view(1, -1, 1, 1))
+            self.vision_proj = nn.Linear(self.vision.config.hidden_size, d_model)
+        else:
+            raise ValueError(f"unknown vision backbone: {vision_backbone}")
+        self.state = nn.Sequential(nn.Linear(state_dim, d_model), nn.GELU(), nn.Linear(d_model, d_model))
+        self.action = nn.Linear(action_dim, d_model)
+        self.pos = nn.Parameter(torch.randn(1, horizon, d_model) * .02)
+        self.query = nn.Parameter(torch.randn(1, horizon, d_model) * .02)
+        enc = nn.TransformerEncoderLayer(d_model, 8, d_model * 4, dropout=.1,
+                                         batch_first=True, norm_first=True, activation="gelu")
+        dec = nn.TransformerDecoderLayer(d_model, 8, d_model * 4, dropout=.1,
+                                         batch_first=True, norm_first=True, activation="gelu")
+        self.posterior = nn.TransformerEncoder(enc, num_layers=enc_layers)
+        self.decoder = nn.TransformerDecoder(dec, num_layers=dec_layers)
+        self.latent = nn.Linear(d_model, latent_dim * 2)
+        self.z_proj = nn.Linear(latent_dim, d_model)
+        self.out = nn.Linear(d_model, action_dim)
+        self.horizon = horizon
+
+    def _vision_tokens(self, image):
+        if self.vision_backbone == "resnet18":
+            image = F.interpolate(image, size=(256, 256), mode="bilinear", align_corners=False)
+            return self.vision_proj(self.vision(image)).flatten(2).transpose(1, 2)
+        # 640×480 is retained natively: both dimensions are divisible by the
+        # DINOv3 ViT-B/16 patch size, yielding a 40×30 local-image token grid.
+        if tuple(image.shape[-2:]) != (480, 640):
+            raise ValueError(f"strict 640x480 protocol required, got {tuple(image.shape[-2:])}")
+        image = (image - self.dino_mean) / self.dino_std
+        self.vision.eval()  # model.train() must never enable frozen-head dropout
+        with torch.no_grad():
+            all_tokens = self.vision(pixel_values=image).last_hidden_state
+            # Drop CLS and DINO register tokens; retain exactly the 40×30
+            # patch grid produced by an unresized 640×480 ViT-B/16 image.
+            first_patch = 1 + int(getattr(self.vision.config, "num_register_tokens", 0))
+            tokens = all_tokens[:, first_patch:]
+        if tokens.shape[1] != 30 * 40:
+            raise ValueError(f"strict 30x40 DINO grid required, got {tokens.shape[1]} tokens")
+        return self.vision_proj(tokens)
+
+    def forward(self, image, qpos, actions=None):
+        x = self._vision_tokens(image)
+        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)
+        pred = self.out(self.decoder(self.query.expand(image.shape[0], -1, -1), memory))
+        return pred, mu, logvar
+
+
+def _loss(model, image, qpos, actions, mask, beta):
+    """Return differentiable total loss plus reporting tensors for one microbatch."""
+    image = image.float().div_(255)
+    with torch.autocast("cuda", dtype=torch.bfloat16):
+        pred, mu, logvar = model(image, 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 _sync_to_replica(master, replica, replica_device):
+    """Copy the one authoritative shared-policy state to the second GPU."""
+    with torch.no_grad():
+        for src, dst in zip(master.parameters(), replica.parameters()):
+            dst.copy_(src.to(replica_device))
+        for src, dst in zip(master.buffers(), replica.buffers()):
+            dst.copy_(src.to(replica_device))
+
+
+def _aggregate_replica_grads(master, replica, master_device):
+    """Sum already globally weighted replica gradients without NCCL."""
+    with torch.no_grad():
+        for p0, p1 in zip(master.parameters(), replica.parameters()):
+            if p0.grad is None:
+                p0.grad = p1.grad.to(master_device).clone()
+            elif p1.grad is not None:
+                p0.grad.add_(p1.grad.to(master_device))
+        # Keep BatchNorm running statistics representative of both local halves.
+        for b0, b1 in zip(master.buffers(), replica.buffers()):
+            if b0.is_floating_point():
+                b0.add_(b1.to(master_device)).mul_(0.5)
+
+
+def epoch(model, loader, opt, device, beta, max_updates=None, scheduler=None, replica=None, replica_device=None):
+    training = opt is not None
+    model.train(training)
+    total = {"loss": 0., "mse": 0., "kl": 0., "n": 0}
+    ctx = torch.enable_grad if training else torch.no_grad
+    updates = 0
+    with ctx():
+        for image, qpos, actions, mask in loader:
+            # A second replica receives the other half of the *global* batch.
+            # This is manual synchronous data parallelism, needed because this
+            # Vast host cannot bootstrap NCCL even though both CUDA devices work.
+            use_replica = replica is not None and image.shape[0] >= 2
+            if use_replica:
+                split = image.shape[0] // 2
+                first = tuple(x[:split].to(device, non_blocking=True) for x in (image, qpos, actions, mask))
+                second = tuple(x[split:].to(replica_device, non_blocking=True) for x in (image, qpos, actions, mask))
+                loss0, mse0, kl0 = _loss(model, *first, beta)
+                loss1, mse1, kl1 = _loss(replica, *second, beta)
+                action_weight0 = float(first[3].sum().item())
+                action_weight1 = float(second[3].sum().item())
+                action_total = max(action_weight0 + action_weight1, 1.)
+                sample_total = float(image.shape[0])
+                # Weight gradients exactly as the loss over the unsharded batch.
+                # Metrics live on the master GPU only. The actual backward below
+                # stays separate on each GPU and never needs a cross-device graph.
+                mse = mse0.detach() * (action_weight0 / action_total) + mse1.detach().to(device) * (action_weight1 / action_total)
+                kl = kl0.detach() * (first[0].shape[0] / sample_total) + kl1.detach().to(device) * (second[0].shape[0] / sample_total)
+                loss = mse + beta * kl
+                n = image.shape[0]
+            else:
+                image, qpos, actions, mask = (x.to(device, non_blocking=True) for x in (image, qpos, actions, mask))
+                loss, mse, kl = _loss(model, image, qpos, actions, mask, beta)
+                n = image.shape[0]
+            if training:
+                opt.zero_grad(set_to_none=True)
+                if use_replica:
+                    for p in replica.parameters(): p.grad = None
+                    # Backpropagate weighted local terms before averaging.
+                    loss0w = mse0 * (action_weight0 / action_total) + beta * kl0 * (first[0].shape[0] / sample_total)
+                    loss1w = mse1 * (action_weight1 / action_total) + beta * kl1 * (second[0].shape[0] / sample_total)
+                    loss0w.backward(); loss1w.backward()
+                    _aggregate_replica_grads(model, replica, device)
+                else:
+                    loss.backward()
+                torch.nn.utils.clip_grad_norm_(model.parameters(), 1.)
+                opt.step()
+                if use_replica: _sync_to_replica(model, replica, replica_device)
+                if scheduler is not None: scheduler.step()
+                updates += 1
+            for k, v in (("loss", loss), ("mse", mse), ("kl", kl)):
+                total[k] += float(v.detach()) * n
+            total["n"] += n
+            if training and max_updates is not None and updates >= max_updates:
+                break
+    return ({k: v / total["n"] for k, v in total.items() if k != "n"}, updates)
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("--data", required=True, help="Glob or comma-separated HDF5 paths")
+    p.add_argument("--arm", type=int, choices=(0, 1), help="single-arm ablation only")
+    p.add_argument("--shared", action="store_true", help="pool listed agents' local data into one shared policy")
+    p.add_argument("--shared-arms", default="0,1", help="comma-separated agents for --shared, e.g. 0,1,2")
+    p.add_argument("--devices", default="0", help="one shared DataParallel model, e.g. 0,1")
+    p.add_argument("--output", required=True)
+    p.add_argument("--horizon", type=int, default=100)
+    p.add_argument("--enc-layers", type=int, default=4)
+    p.add_argument("--dec-layers", type=int, default=7)
+    p.add_argument("--d-model", type=int, default=384)
+    p.add_argument("--vision-backbone", choices=("resnet18", "dinov3_vitb16_frozen"), default="resnet18")
+    p.add_argument("--dino-model", default="facebook/dinov3-vitb16-pretrain-lvd1689m")
+    p.add_argument("--camera-width", type=int, default=320)
+    p.add_argument("--camera-height", type=int, default=240)
+    p.add_argument("--batch-size", type=int, default=128)
+    p.add_argument("--updates", type=int, default=60000)
+    p.add_argument("--save-updates", default="20000,40000,60000",
+                   help="comma-separated exact optimizer-update checkpoints")
+    p.add_argument("--workers", type=int, default=8)
+    p.add_argument("--lazy-cache-episodes", type=int, default=0,
+                   help="Bound RGB cache and use episode-block batches (0 keeps full preloading).")
+    p.add_argument("--episode-block-updates", type=int, default=64,
+                   help="Updates reusing four local streams in lazy-cache mode.")
+    p.add_argument("--task-balanced", action="store_true",
+                   help="Sample each source task equally in mixed-task training.")
+    p.add_argument("--lr", type=float, default=2e-4)
+    p.add_argument("--beta", type=float, default=1e-3)
+    p.add_argument("--seed", type=int, default=2026)
+    a = p.parse_args()
+    assert a.shared != (a.arm is not None), "set exactly one of --shared or --arm"
+    arms = tuple(int(x) for x in a.shared_arms.split(",")) if a.shared else (a.arm,)
+    assert arms and len(set(arms)) == len(arms) and all(x >= 0 for x in arms)
+    seed_everything(a.seed); torch.backends.cudnn.benchmark = True
+    device_ids = [int(x) for x in a.devices.split(",")]
+    device = torch.device(f"cuda:{device_ids[0]}")
+    paths = sorted({p for item in a.data.split(",") for p in glob.glob(item)})
+    assert paths, f"no HDF5 files match {a.data}"
+    tr = _trajectories(paths, arms); assert len(tr) >= 10, "need at least 10 successful demonstrations"
+    stats = _stats(tr, arms)
+    lazy_cache = a.lazy_cache_episodes > 0
+    if lazy_cache and a.workers:
+        raise ValueError("lazy RGB cache requires --workers 0")
+    train = RoboFactoryACTDataset(tr, arms, a.horizon, stats, True,
+                                  preload=not lazy_cache, cache_limit=a.lazy_cache_episodes)
+    valid = RoboFactoryACTDataset(tr, arms, a.horizon, stats, False,
+                                  preload=not lazy_cache, cache_limit=a.lazy_cache_episodes)
+    kwargs = dict(batch_size=a.batch_size, num_workers=a.workers, pin_memory=True,
+                  persistent_workers=a.workers > 0)
+    # Forking workers after CUDA is initialized can deadlock (and h5py is not
+    # fork-friendly either). Spawn keeps the two GPU training jobs independent.
+    if a.workers > 0:
+        kwargs["multiprocessing_context"] = "spawn"
+    sampler = None
+    if lazy_cache:
+        sampler = EpisodeBlockBatchSampler(train, a.batch_size, a.updates,
+                                           a.episode_block_updates, a.seed, a.task_balanced)
+        train_loader = DataLoader(train, batch_sampler=sampler, num_workers=0, pin_memory=True)
+    elif a.task_balanced:
+        counts = Counter(train.item_tasks)
+        if 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:
+        train_loader = DataLoader(train, shuffle=sampler is None, sampler=sampler, drop_last=True, **kwargs)
+    val_loader = DataLoader(valid, shuffle=False, **kwargs)
+    sample = train[0]
+    if tuple(sample[0].shape[-2:]) != (a.camera_height, a.camera_width):
+        raise ValueError(f"dataset frame {tuple(sample[0].shape[-2:])} does not match requested "
+                         f"{a.camera_height}x{a.camera_width}")
+    model = ACT(len(sample[1]), len(sample[2][0]), a.horizon, a.d_model, a.enc_layers, a.dec_layers,
+                vision_backbone=a.vision_backbone, dino_model=a.dino_model).to(device)
+    replica = None; replica_device = None
+    if len(device_ids) > 1:
+        assert len(device_ids) == 2, "manual synchronous mode currently supports exactly two GPUs"
+        replica_device = torch.device(f"cuda:{device_ids[1]}")
+        replica = copy.deepcopy(model).to(replica_device)
+    opt = torch.optim.AdamW(model.parameters(), lr=a.lr, weight_decay=1e-4)
+    sched = torch.optim.lr_scheduler.CosineAnnealingLR(opt, a.updates)
+    out = Path(a.output); out.mkdir(parents=True, exist_ok=True)
+    np.savez(out / "normalization.npz", **stats)
+    best = float("inf")
+    info = vars(a) | {"arms": arms, "files": paths, "episodes": len(tr), "train_steps": len(train), "val_steps": len(valid),
+                      "train_task_item_counts": dict(Counter(train.item_tasks)),
+                      "state_dim": len(sample[1]), "action_dim": len(sample[2][0])}
+    (out / "config.json").write_text(json.dumps(info, indent=2))
+    milestones = {int(x) for x in a.save_updates.split(",") if x}
+    updates = 0; e = 0
+    while updates < a.updates:
+        e += 1
+        next_stop = min([a.updates] + [m for m in milestones if m > updates])
+        train_metrics, ran = epoch(model, train_loader, opt, device, a.beta, next_stop - updates, sched, replica, replica_device)
+        updates += ran
+        val_metrics, _ = epoch(model, val_loader, None, device, a.beta, replica=replica, replica_device=replica_device)
+        report = {"epoch": e, "updates": updates, "lr": sched.get_last_lr()[0], "train": train_metrics, "val": val_metrics}
+        print(json.dumps(report), flush=True)
+        state = {"model": model.state_dict(), "optimizer": opt.state_dict(), "epoch": e,
+                 "updates": updates, "stats": stats, "config": info}
+        torch.save(state, out / "last.pt")
+        if val_metrics["loss"] < best:
+            best = val_metrics["loss"]; torch.save(state, out / "best.pt")
+        if updates in milestones:
+            torch.save(state, out / f"checkpoint_{updates:06d}.pt")
+
+
+if __name__ == "__main__": main()