scripts/act/train_task_e.py

ALGO_NAME = 'BC_ACT'

import os
import random
import time
from collections import defaultdict
from dataclasses import dataclass
from typing import Optional

import h5py
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
import torchvision.transforms as T
from torch.utils.data.dataset import Dataset
from torch.utils.data.sampler import RandomSampler, BatchSampler
from torch.utils.data.dataloader import DataLoader
from torch.utils.tensorboard import SummaryWriter
from diffusers.training_utils import EMAModel

from atec_rl_lab.train.act.act.detr.backbone import build_backbone
from atec_rl_lab.train.act.act.detr.transformer import build_transformer
from atec_rl_lab.train.act.act.detr.detr_vae import build_encoder, DETRVAE
from atec_rl_lab.train.act.act.utils import IterationBasedBatchSampler, worker_init_fn
import tyro


@dataclass
class Args:
    exp_name: Optional[str] = None
    """the name of this experiment"""
    seed: int = 1
    """seed of the experiment"""
    torch_deterministic: bool = True
    """if toggled, `torch.backends.cudnn.deterministic=False`"""
    cuda: bool = True
    """if toggled, cuda will be enabled by default"""
    track: bool = False
    """if toggled, this experiment will be tracked with Weights and Biases"""
    wandb_project_name: str = "ATEC2026"
    """the wandb's project name"""
    wandb_entity: Optional[str] = None
    """the entity (team) of wandb's project"""

    demo_path: str = './datasets/atec_task_e/trajectory.hdf5'
    """path to the HDF5 demo dataset produced by collect_demos_task_e.py"""
    num_demos: Optional[int] = None
    """number of trajectories to load (None = all)"""
    total_iters: int = 1_000_000
    """total training iterations"""
    batch_size: int = 256
    """batch size"""

    # ACT specific
    lr: float = 1e-4
    """learning rate"""
    kl_weight: float = 10
    """weight for the KL loss term"""
    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
    """replace transformer self-attention/FFN blocks with the local XSA variant"""

    log_freq: int = 1000
    """frequency of logging training metrics"""
    save_freq: int = 5000
    """frequency of saving model checkpoints"""
    num_dataload_workers: int = 0
    """number of DataLoader worker processes"""
    resume_checkpoint: Optional[str] = None
    """optional checkpoint to continue training from"""
    resume_iter: Optional[int] = None
    """absolute iteration for a legacy checkpoint that does not store train_iter"""


class DemoDataset_ACT(Dataset):
    """Load IsaacLab Task-E HDF5 demos into memory.

    HDF5 structure (produced by collect_demos_task_e.py):
        traj_N/obs          (T, 8)       joint positions (qpos)
        traj_N/actions      (T, 8)       env actions
        traj_N/images/rgb   (T, H, W, 3) uint8 RGB — optional
    """

    def __init__(self, data_path: str, num_queries: int,
                 num_traj: Optional[int] = None, include_rgb: bool = True):
        self.num_queries = num_queries
        self.include_rgb = include_rgb
        self.transforms = T.Resize((224, 224), antialias=True)

        # load raw data
        states_list: list[torch.Tensor] = []
        actions_list: list[torch.Tensor] = []
        rgb_list: list[torch.Tensor] = []   # only when include_rgb is True
        has_images = None

        with h5py.File(data_path, 'r') as f:
            traj_keys = sorted(f.keys(), key=lambda k: int(k.split('_')[1]))
            if num_traj is not None:
                traj_keys = traj_keys[:num_traj]

            for key in traj_keys:
                grp = f[key]
                states_list.append(torch.from_numpy(grp['obs'][:].astype(np.float32)))
                actions_list.append(torch.from_numpy(grp['actions'][:].astype(np.float32)))

                if include_rgb:
                    if has_images is None:
                        has_images = 'images' in grp
                    if has_images and 'images' in grp:
                        rgb_arr = grp['images/rgb'][:]          # (T, H, W, 3) uint8
                        rgb_t = torch.from_numpy(rgb_arr)       # uint8
                        # (T, 3, H, W) → resize → (T, 3, 224, 224)
                        rgb_t = self.transforms(rgb_t.permute(0, 3, 1, 2))
                        # add camera dim → (T, 1, 3, 224, 224)
                        rgb_list.append(rgb_t.unsqueeze(1))

        if has_images is None:
            has_images = False
        self.has_images = has_images and include_rgb and len(rgb_list) > 0

        if include_rgb and not self.has_images:
            print('[WARN] include_rgb=True but no images found in dataset. '
                  'Re-collect with --save_images, or set include_rgb=False.')

        self.num_traj = len(states_list)
        self.states  = states_list   # list of (T, 8)
        self.actions = actions_list  # list of (T, 8)
        self.rgb     = rgb_list      # list of (T, 1, 3, 224, 224) or empty

        # state/action dims
        self.state_dim = self.states[0].shape[1]
        self.act_dim   = self.actions[0].shape[1]

        # index slices: (traj_idx, timestep)
        self.slices = [
            (i, t)
            for i, acts in enumerate(self.actions)
            for t in range(acts.shape[0])
        ]
        print(f'Loaded {self.num_traj} trajectories, {len(self.slices)} timesteps. '
              f'state_dim={self.state_dim}, act_dim={self.act_dim}, '
              f'has_images={self.has_images}')

        # normalisation stats (pd_joint_pos = absolute actions → normalise)
        self.norm_stats = self._compute_norm_stats()

    # ------------------------------------------------------------------

    def _pad_action(self, act_seq: torch.Tensor) -> torch.Tensor:
        """Pad a short action chunk by repeating the last action."""
        shortage = self.num_queries - act_seq.shape[0]
        if shortage > 0:
            act_seq = torch.cat([act_seq, act_seq[-1:].repeat(shortage, 1)], dim=0)
        return act_seq

    def _compute_norm_stats(self) -> dict:
        # Vectorised: stack each full trajectory then slice — avoids 110k tiny ops
        all_states  = torch.cat(self.states,  dim=0)   # (total_T, state_dim)
        all_actions = torch.cat(self.actions, dim=0)   # (total_T, act_dim)

        state_mean = all_states.mean(0,  keepdim=True)
        state_std  = all_states.std(0,   keepdim=True).clamp(1e-2)
        act_mean   = all_actions.mean(0, keepdim=True)
        act_std    = all_actions.std(0,  keepdim=True).clamp(1e-2)

        return dict(state_mean=state_mean, state_std=state_std,
                    action_mean=act_mean,  action_std=act_std)

    def __len__(self):
        return len(self.slices)

    def __getitem__(self, index):
        traj_idx, ts = self.slices[index]

        state   = self.states[traj_idx][ts]
        act_seq = self._pad_action(self.actions[traj_idx][ts:ts + self.num_queries])

        # normalise
        state   = (state   - self.norm_stats['state_mean'][0])  / self.norm_stats['state_std'][0]
        act_seq = (act_seq - self.norm_stats['action_mean'])     / self.norm_stats['action_std']

        obs = dict(state=state)
        if self.has_images:
            obs['rgb'] = self.rgb[traj_idx][ts]   # (1, 3, 224, 224) uint8

        return {'observations': obs, 'actions': act_seq}



class Agent(nn.Module):
    def __init__(self, state_dim: int, act_dim: int, args: Args):
        super().__init__()
        self.state_dim  = state_dim
        self.act_dim    = act_dim
        self.kl_weight  = args.kl_weight
        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 compute_loss(self, obs: dict, action_seq: torch.Tensor) -> dict:
        self._preprocess_rgb(obs)
        a_hat, (mu, logvar) = self.model(self._model_input(obs), action_seq)

        total_kld, _, _ = kl_divergence(mu, logvar)
        l1 = F.l1_loss(action_seq, a_hat)

        return dict(l1=l1, kl=total_kld[0],
                    loss=l1 + total_kld[0] * self.kl_weight)

    def get_action(self, obs: dict) -> torch.Tensor:
        self._preprocess_rgb(obs)
        a_hat, _ = self.model(self._model_input(obs))
        return a_hat


def kl_divergence(mu, logvar):
    if mu.data.ndimension() == 4:
        mu     = mu.view(mu.size(0),     mu.size(1))
        logvar = logvar.view(logvar.size(0), logvar.size(1))
    klds       = -0.5 * (1 + logvar - mu.pow(2) - logvar.exp())
    total_kld  = klds.sum(1).mean(0, True)
    dim_kld    = klds.mean(0)
    mean_kld   = klds.mean(1).mean(0, True)
    return total_kld, dim_kld, mean_kld


def save_ckpt(run_name: str, tag: str, train_iter: int) -> None:
    os.makedirs(f'runs/{run_name}/checkpoints', exist_ok=True)
    ema.copy_to(ema_agent.parameters())
    ckpt = {
        'norm_stats': dataset.norm_stats,
        'model_args': vars(args),
        'train_iter': train_iter,
        'agent':      agent.state_dict(),
        'ema_agent':  ema_agent.state_dict(),
        'optimizer':  optimizer.state_dict(),
        'lr_scheduler': lr_scheduler.state_dict(),
    }
    if hasattr(ema, 'state_dict'):
        ckpt['ema'] = ema.state_dict()
    torch.save(ckpt, f'runs/{run_name}/checkpoints/{tag}.pt')
    print(f'[INFO] Saved checkpoint: runs/{run_name}/checkpoints/{tag}.pt')

if __name__ == '__main__':
    args = tyro.cli(Args)

    if args.exp_name is None:
        args.exp_name = os.path.basename(__file__)[:-len('.py')]
        run_name = f"{args.exp_name}__{args.seed}__{int(time.time())}"
    else:
        run_name = args.exp_name

    # seeding
    random.seed(args.seed)
    np.random.seed(args.seed)
    torch.manual_seed(args.seed)
    torch.backends.cudnn.deterministic = args.torch_deterministic

    device = torch.device('cuda' if torch.cuda.is_available() and args.cuda else 'cpu')

    # dataset & dataloader
    dataset = DemoDataset_ACT(
        args.demo_path,
        num_queries=args.num_queries,
        num_traj=args.num_demos,
        include_rgb=args.include_rgb,
    )
    if args.num_demos is None:
        args.num_demos = dataset.num_traj

    sampler       = RandomSampler(dataset, replacement=False)
    batch_sampler = BatchSampler(sampler, batch_size=args.batch_size, drop_last=True)
    start_iter = 0
    batch_sampler = IterationBasedBatchSampler(batch_sampler, args.total_iters)
    train_dataloader = DataLoader(
        dataset,
        batch_sampler=batch_sampler,
        num_workers=args.num_dataload_workers,
        worker_init_fn=lambda wid: worker_init_fn(wid, base_seed=args.seed),
    )

    # logging
    if args.track:
        import wandb
        wandb.init(
            project=args.wandb_project_name,
            entity=args.wandb_entity,
            sync_tensorboard=True,
            config=vars(args),
            name=run_name,
            save_code=True,
            group='ACT',
            tags=['act'],
        )
    writer = SummaryWriter(f'runs/{run_name}')
    writer.add_text(
        'hyperparameters',
        '|param|value|\n|-|-|\n' +
        '\n'.join(f'|{k}|{v}|' for k, v in vars(args).items()),
    )

    # agent
    agent     = Agent(dataset.state_dim, dataset.act_dim, args).to(device)
    ema_agent = Agent(dataset.state_dim, dataset.act_dim, args).to(device)

    param_dicts = [
        {'params': [p for n, p in agent.named_parameters()
                    if 'backbone' not in n and p.requires_grad]},
        {'params': [p for n, p in agent.named_parameters()
                    if 'backbone'     in n and p.requires_grad],
         'lr': args.lr_backbone},
    ]
    optimizer    = optim.AdamW(param_dicts, lr=args.lr, weight_decay=1e-4)
    lr_drop      = max(int(2 / 3 * args.total_iters), 1)
    lr_scheduler = optim.lr_scheduler.StepLR(optimizer, lr_drop)
    ema          = EMAModel(parameters=agent.parameters(), power=0.75)

    if args.resume_checkpoint:
        ckpt = torch.load(args.resume_checkpoint, map_location=device, weights_only=False)
        weight_key = 'agent'
        if weight_key not in ckpt:
            raise KeyError(f"Checkpoint {args.resume_checkpoint} has no '{weight_key}' weights")
        agent.load_state_dict(ckpt[weight_key])
        if 'ema_agent' in ckpt:
            ema_agent.load_state_dict(ckpt['ema_agent'])
        if 'optimizer' in ckpt:
            optimizer.load_state_dict(ckpt['optimizer'])
        if 'lr_scheduler' in ckpt:
            lr_scheduler.load_state_dict(ckpt['lr_scheduler'])
        if 'ema' in ckpt and hasattr(ema, 'load_state_dict'):
            ema.load_state_dict(ckpt['ema'])
        start_iter = int(ckpt.get('train_iter') or args.resume_iter or 0)
        if start_iter >= args.total_iters:
            raise ValueError(
                f"resume start_iter={start_iter} is >= total_iters={args.total_iters}; "
                "increase --total_iters or choose an earlier checkpoint"
            )
        print(f'[INFO] Resumed checkpoint {args.resume_checkpoint} at iter {start_iter}')

    # training loop
    agent.train()
    best_loss = float('inf')
    timings   = defaultdict(float)

    for local_iter, data_batch in enumerate(train_dataloader):
        cur_iter = start_iter + local_iter
        if cur_iter >= args.total_iters:
            break
        last_tick = time.time()

        obs_batch = {k: v.to(device, non_blocking=True)
                     for k, v in data_batch['observations'].items()}
        act_batch = data_batch['actions'].to(device, non_blocking=True)

        loss_dict  = agent.compute_loss(obs=obs_batch, action_seq=act_batch)
        total_loss = loss_dict['loss']

        optimizer.zero_grad()
        total_loss.backward()
        optimizer.step()
        lr_scheduler.step()
        ema.step(agent.parameters())

        timings['update'] += time.time() - last_tick

        if cur_iter % args.log_freq == 0:
            loss_val = total_loss.item()
            print(f'Iter {cur_iter:7d}  loss={loss_val:.4f}  '
                  f'l1={loss_dict["l1"].item():.4f}  '
                  f'kl={loss_dict["kl"].item():.4f}')
            writer.add_scalar('charts/lr',          optimizer.param_groups[0]['lr'], cur_iter)
            writer.add_scalar('charts/lr_backbone', optimizer.param_groups[1]['lr'], cur_iter)
            writer.add_scalar('losses/total',       loss_val,                        cur_iter)
            writer.add_scalar('losses/l1',          loss_dict['l1'].item(),          cur_iter)
            writer.add_scalar('losses/kl',          loss_dict['kl'].item(),          cur_iter)
            for k, v in timings.items():
                writer.add_scalar(f'time/{k}', v, cur_iter)

            if loss_val < best_loss:
                best_loss = loss_val
                save_ckpt(run_name, 'best_loss', cur_iter)

        if args.save_freq > 0 and cur_iter % args.save_freq == 0 and cur_iter > 0:
            save_ckpt(run_name, str(cur_iter), cur_iter)

    save_ckpt(run_name, 'final', min(args.total_iters, cur_iter + 1))
    writer.close()
    print(f'[INFO] Training done. Run: runs/{run_name}')