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())