Ctrl-World-Graph/scripts/train_wm_graph.py

import os
import sys
import argparse
from pathlib import Path

import torch
from torch.utils.data import DataLoader, Subset
from torch.utils.tensorboard import SummaryWriter
from accelerate import Accelerator
from accelerate.logging import get_logger
from tqdm.auto import tqdm

ROOT = Path(__file__).resolve().parents[1]
if str(ROOT) not in sys.path:
    sys.path.insert(0, str(ROOT))

from graphwm.config_graph import GraphWMArgs
from graphwm.cli_graph import (
    add_graph_model_args,
    apply_graph_model_args,
    load_graph_model_config_sidecar,
    write_graph_model_config_sidecar,
)
from graphwm.dataset.collate_graph_wm import collate_graph_wm
from graphwm.dataset.dataset_graph_wm import (
    GraphWorldModelDataset,
    HanoiProductsOnlyGraphWorldModelDataset,
    SampledDataGraphWorldModelDataset,
)
from graphwm.models.ctrl_world_graph import CtrlWorldGraph


def parse_args() -> GraphWMArgs:
    parser = argparse.ArgumentParser(description="Train graph-conditioned Ctrl-World.")
    parser.add_argument("--tag", type=str, default=None)
    parser.add_argument("--output-dir", type=str, default=None)
    parser.add_argument("--tensorboard-log-dir", type=str, default=None)
    parser.add_argument("--ckpt-path", type=str, default=None)
    parser.add_argument("--resume-step", type=int, default=None)
    parser.add_argument("--max-train-steps", type=int, default=None)
    parser.add_argument("--checkpointing-steps", type=int, default=None)
    parser.add_argument("--validation-steps", type=int, default=None)
    parser.add_argument("--log-every-steps", type=int, default=None)
    parser.add_argument("--train-batch-size", type=int, default=None)
    parser.add_argument("--eval-batch-size", type=int, default=None)
    parser.add_argument("--num-workers", type=int, default=None)
    parser.add_argument("--learning-rate", type=float, default=None)
    parser.add_argument("--hanoi-frame-interval", type=int, default=None)
    parser.add_argument("--hanoi-stride", type=int, default=None)
    parser.add_argument("--fps", type=int, default=None)
    parser.add_argument("--history-corruption", action="store_true")
    parser.add_argument("--history-corruption-prob", type=float, default=None)
    parser.add_argument("--history-corruption-std", type=float, default=None)
    parser.add_argument("--current-corruption-std", type=float, default=None)
    add_graph_model_args(parser)
    cli = parser.parse_args()

    args = GraphWMArgs()
    for cli_name, attr in [
        ("tag", "tag"),
        ("output_dir", "output_dir"),
        ("tensorboard_log_dir", "tensorboard_log_dir"),
        ("ckpt_path", "ckpt_path"),
        ("resume_step", "resume_step"),
        ("max_train_steps", "max_train_steps"),
        ("checkpointing_steps", "checkpointing_steps"),
        ("validation_steps", "validation_steps"),
        ("log_every_steps", "log_every_steps"),
        ("train_batch_size", "train_batch_size"),
        ("eval_batch_size", "eval_batch_size"),
        ("num_workers", "num_workers"),
        ("learning_rate", "learning_rate"),
        ("hanoi_frame_interval", "hanoi_frame_interval"),
        ("hanoi_stride", "hanoi_stride"),
        ("fps", "fps"),
        ("history_corruption_prob", "history_corruption_prob"),
        ("history_corruption_std", "history_corruption_std"),
        ("current_corruption_std", "current_corruption_std"),
    ]:
        value = getattr(cli, cli_name)
        if value is not None:
            setattr(args, attr, value)
    if cli.history_corruption:
        args.history_corruption = True
    if args.ckpt_path:
        load_graph_model_config_sidecar(args, args.ckpt_path)
    apply_graph_model_args(args, cli)
    return args


def build_datasets(args: GraphWMArgs):
    if args.use_hanoi_data_loader:
        full_dataset = HanoiProductsOnlyGraphWorldModelDataset(
            hanoi_root=args.hanoi_data_root,
            session_ids=args.hanoi_session_ids,
            num_history=args.num_history,
            num_frames=args.num_frames,
            stride=args.hanoi_stride,
            frame_interval=args.hanoi_frame_interval,
            resize_hw=args.sampled_resize_hw,
            graph_dir_name=args.hanoi_graph_dir_name,
        )
        if not args.use_eval_split:
            return full_dataset, None

        episodes = []
        seen = set()
        for episode_dir, _ in full_dataset.samples:
            if episode_dir not in seen:
                episodes.append(episode_dir)
                seen.add(episode_dir)

        val_episode_count = max(1, int(len(episodes) * args.val_ratio))
        if len(episodes) - val_episode_count < 1:
            val_episode_count = max(1, len(episodes) - 1)
        val_episodes = set(episodes[-val_episode_count:])

        train_indices = []
        val_indices = []
        for idx, (episode_dir, _) in enumerate(full_dataset.samples):
            if episode_dir in val_episodes:
                val_indices.append(idx)
            else:
                train_indices.append(idx)

        if not train_indices or not val_indices:
            raise ValueError(
                f"Invalid Hanoi train/val split: train={len(train_indices)} val={len(val_indices)} "
                f"episodes={len(episodes)} val_episode_count={val_episode_count}"
            )
        return Subset(full_dataset, train_indices), Subset(full_dataset, val_indices)
    elif args.use_sampled_data_loader:
        full_dataset = SampledDataGraphWorldModelDataset(
            sample_root=args.sampled_data_root,
            type_vocab=args.graph_type_vocab,
            session_id=args.sampled_session_id,
            episode_id=args.sampled_episode_id,
            num_history=args.num_history,
            num_frames=args.num_frames,
            resize_hw=args.sampled_resize_hw,
            include_depth=args.include_depth,
        )
    else:
        full_dataset = GraphWorldModelDataset(args.graph_manifest_path, args.graph_type_vocab)

    if not args.use_eval_split:
        return full_dataset, None

    dataset_len = len(full_dataset)
    val_len = max(1, int(dataset_len * args.val_ratio))
    if dataset_len - val_len < 1:
        val_len = max(1, dataset_len - 1)
    train_len = dataset_len - val_len
    train_indices = list(range(0, train_len))
    val_indices = list(range(train_len, dataset_len))
    return Subset(full_dataset, train_indices), Subset(full_dataset, val_indices)


def evaluate(model, loader, accelerator):
    model.eval()
    total = 0.0
    count = 0
    with torch.no_grad():
        for batch in loader:
            with accelerator.autocast():
                loss_gen, _ = model(batch)
            avg_loss = accelerator.gather(loss_gen.detach().reshape(1)).mean()
            total += float(avg_loss.item())
            count += 1
    model.train()
    return total / max(count, 1)


def main(args: GraphWMArgs):
    logger = get_logger(__name__, log_level="INFO")
    accelerator = Accelerator(
        gradient_accumulation_steps=args.gradient_accumulation_steps,
        mixed_precision=args.mixed_precision,
    )

    model = CtrlWorldGraph(args)
    if args.ckpt_path:
        state_dict = torch.load(args.ckpt_path, map_location="cpu")
        model.load_state_dict(state_dict, strict=False)

    train_dataset, val_dataset = build_datasets(args)
    train_loader = DataLoader(
        train_dataset,
        batch_size=args.train_batch_size,
        shuffle=args.shuffle,
        num_workers=args.num_workers,
        collate_fn=collate_graph_wm,
    )
    val_loader = None
    if val_dataset is not None:
        val_loader = DataLoader(
            val_dataset,
            batch_size=args.eval_batch_size,
            shuffle=False,
            num_workers=args.num_workers,
            collate_fn=collate_graph_wm,
        )

    optimizer = torch.optim.AdamW(model.parameters(), lr=args.learning_rate)
    if val_loader is not None:
        model, optimizer, train_loader, val_loader = accelerator.prepare(model, optimizer, train_loader, val_loader)
    else:
        model, optimizer, train_loader = accelerator.prepare(model, optimizer, train_loader)

    writer = None
    if accelerator.is_main_process and args.use_tensorboard:
        os.makedirs(args.tensorboard_log_dir, exist_ok=True)
        writer = SummaryWriter(log_dir=args.tensorboard_log_dir)

    model.train()
    global_step = int(args.resume_step)
    running_loss = 0.0
    running_count = 0
    progress_bar = tqdm(
        total=args.max_train_steps,
        initial=global_step,
        disable=not accelerator.is_local_main_process,
    )
    progress_bar.set_description("Graph WM Steps")

    if accelerator.is_main_process:
        logger.info("Output dir: %s", args.output_dir)
        logger.info("TensorBoard dir: %s", args.tensorboard_log_dir)
        logger.info(
            "Hanoi frame_interval=%s stride=%s fps=%s history_corruption=%s",
            args.hanoi_frame_interval,
            args.hanoi_stride,
            args.fps,
            args.history_corruption,
        )
        logger.info(
            "Graph encoder: backbone=%s hidden=%s layers=%s heads=%s resampler=%s resampler_layers=%s tokens=%s",
            args.graph_backbone,
            args.graph_hidden_dim,
            args.graph_num_layers,
            args.graph_num_heads,
            args.graph_resampler,
            args.graph_resampler_layers,
            args.graph_num_tokens,
        )
        logger.info("Train samples: %s", len(train_dataset))
        if val_dataset is not None:
            logger.info("Val samples: %s", len(val_dataset))

    while global_step < args.max_train_steps:
        for batch in train_loader:
            with accelerator.accumulate(model):
                with accelerator.autocast():
                    loss_gen, _ = model(batch)
                avg_loss = accelerator.gather(loss_gen.detach().reshape(1)).mean()
                running_loss += float(avg_loss.item())
                running_count += 1
                accelerator.backward(loss_gen)
                if accelerator.sync_gradients:
                    accelerator.clip_grad_norm_(model.parameters(), args.max_grad_norm)
                optimizer.step()
                optimizer.zero_grad()

            if accelerator.sync_gradients:
                global_step += 1
                progress_bar.update(1)
                progress_bar.set_postfix({"loss": float(avg_loss.item())})

                if global_step % args.log_every_steps == 0:
                    train_loss = running_loss / max(running_count, 1)
                    if accelerator.is_main_process:
                        logger.info("step=%s train_loss=%.6f", global_step, train_loss)
                        if writer is not None:
                            writer.add_scalar("loss/train", train_loss, global_step)
                    running_loss = 0.0
                    running_count = 0

                if val_loader is not None and global_step % args.validation_steps == 0:
                    val_loss = evaluate(model, val_loader, accelerator)
                    if accelerator.is_main_process:
                        logger.info("step=%s val_loss=%.6f", global_step, val_loss)
                        if writer is not None:
                            writer.add_scalar("loss/val", val_loss, global_step)

                if global_step % args.checkpointing_steps == 0 and accelerator.is_main_process:
                    os.makedirs(args.output_dir, exist_ok=True)
                    save_path = os.path.join(args.output_dir, f"checkpoint-{global_step}.pt")
                    torch.save(accelerator.unwrap_model(model).state_dict(), save_path)
                    write_graph_model_config_sidecar(args, save_path)
                    logger.info("Saved checkpoint to %s", save_path)

                if global_step >= args.max_train_steps:
                    break

    if writer is not None:
        writer.close()


if __name__ == "__main__":
    main(parse_args())