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