| """Evaluate trained Stage 1 + Stage 2 checkpoints on configured validation sets.""" |
|
|
| import argparse |
| from pathlib import Path |
|
|
| import torch |
|
|
| from .flowfm.checkpointing import load_state_dict, resolve_stage2_checkpoint |
| from .flowfm.config import load_config, resolve_subjects |
| from .flowfm.data_pipeline import make_data_loaders |
| from .flowfm.model_factory import ( |
| build_stage1_model, |
| build_stage2_models, |
| infer_feature_dims, |
| infer_target_dim, |
| ) |
| from .flowfm.stage1 import evaluate_stage1 |
| from .flowfm.stage2 import evaluate_stage2 |
|
|
|
|
| def build_models( |
| cfg, |
| sample_batch, |
| subjects: list[int], |
| checkpoint_dir: Path, |
| stage2_ckpt_name: str | None, |
| device: torch.device, |
| ): |
| """Construct Stage 1/2 models and load checkpoint weights.""" |
| feat_dims = infer_feature_dims(sample_batch) |
| target_dim = infer_target_dim(sample_batch) |
|
|
| stage1_model = build_stage1_model( |
| cfg=cfg, |
| feat_dims=feat_dims, |
| subjects=subjects, |
| device=device, |
| ) |
| stage1_model.load_state_dict(load_state_dict(checkpoint_dir / "stage1_best.pt", device)) |
| stage1_model.eval() |
|
|
| stage2_models = build_stage2_models( |
| cfg=cfg, |
| target_dim=target_dim, |
| subjects=subjects, |
| device=device, |
| ) |
| stage2_ckpt = resolve_stage2_checkpoint(checkpoint_dir, stage2_ckpt_name) |
| stage2_models.load_state_dict(load_state_dict(stage2_ckpt, device)) |
| stage2_models.eval() |
|
|
| return stage1_model, stage2_models, stage2_ckpt |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description="Evaluate two-stage checkpoints") |
| parser.add_argument("--checkpoint-dir", type=str, required=True) |
| parser.add_argument("--cfg-path", type=str, default=None) |
| parser.add_argument("--stage2-ckpt", type=str, default=None) |
| parser.add_argument("--device", type=str, default=None) |
| parser.add_argument("--split", action="append", default=None) |
| parser.add_argument("--n-timesteps", type=int, default=None) |
| args = parser.parse_args() |
|
|
| checkpoint_dir = Path(args.checkpoint_dir) |
| cfg_path = args.cfg_path or str(checkpoint_dir / "config.yaml") |
|
|
| cfg = load_config(cfg_path) |
| if args.device is not None: |
| cfg.device = args.device |
|
|
| device = torch.device(cfg.device) |
| subjects = resolve_subjects(cfg) |
| n_timesteps = int(args.n_timesteps or cfg.stage2.get("n_timesteps", 25)) |
|
|
| print(f"Checkpoint dir: {checkpoint_dir}") |
| print(f"Config: {cfg_path}") |
| print(f"Device: {device}") |
| print(f"Subjects: {subjects}") |
|
|
| data_loaders = make_data_loaders(cfg) |
| train_loader = data_loaders["train"] |
| eval_loaders = {name: loader for name, loader in data_loaders.items() if name != "train"} |
|
|
| if args.split: |
| selected = set(args.split) |
| eval_loaders = {name: loader for name, loader in eval_loaders.items() if name in selected} |
| missing = selected - set(eval_loaders) |
| if missing: |
| raise ValueError(f"Requested split(s) not found: {sorted(missing)}") |
|
|
| sample_batch = next(iter(train_loader)) |
| stage1_model, stage2_models, stage2_ckpt = build_models( |
| cfg=cfg, |
| sample_batch=sample_batch, |
| subjects=subjects, |
| checkpoint_dir=checkpoint_dir, |
| stage2_ckpt_name=args.stage2_ckpt, |
| device=device, |
| ) |
|
|
| print(f"Loaded Stage 1 checkpoint: {checkpoint_dir / 'stage1_best.pt'}") |
| print(f"Loaded Stage 2 checkpoint: {stage2_ckpt}") |
|
|
| for split_name, loader in eval_loaders.items(): |
| print(f"\n=== Evaluating split: {split_name} ===") |
|
|
| stage1_acc, _ = evaluate_stage1( |
| epoch=0, |
| model=stage1_model, |
| val_loader=loader, |
| device=device, |
| subjects=subjects, |
| ds_name=split_name, |
| ) |
|
|
| stage2_acc, _ = evaluate_stage2( |
| epoch=0, |
| stage1_model=stage1_model, |
| stage2_models=stage2_models, |
| val_loader=loader, |
| device=device, |
| subjects=subjects, |
| ds_name=split_name, |
| n_timesteps=n_timesteps, |
| ) |
|
|
| print(f"Summary [{split_name}] Stage1={stage1_acc:.4f} Stage2={stage2_acc:.4f}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
