| """ |
| Training script for 2-stage fMRI encoding with Flow Matching. |
| Stage 1: Train MultiSubjectConvLinearEncoder (Mean Anchor) |
| Stage 2: Train Conditional Flow Matching (Neural Vector Field) per subject. |
| """ |
|
|
| import argparse |
| import sys |
| from pathlib import Path |
| from typing import Dict, Any, Optional |
|
|
| import numpy as np |
| import torch |
| import torch.nn as nn |
| from omegaconf import DictConfig, OmegaConf |
| from timm.utils import random_seed |
|
|
| from .visualize import plot_loss_curve |
| from .data import ( |
| Algonauts2025Dataset, |
| load_algonauts2025_friends_fmri, |
| load_algonauts2025_movie10_fmri, |
| load_sharded_features, |
| episode_filter, |
| ) |
| from .stage1.medarc_architecture import MultiSubjectConvLinearEncoder |
| from .stage2.CFM import CFM |
| from .metric import pearsonr_score |
|
|
| from .loaders import SUBJECTS, make_data_loaders, load_all_features |
| from .loops import train_one_epoch_jointly |
| from .evaluate import evaluate_stage1, evaluate_stage2 |
|
|
| def main(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--cfg-path", type=str, default="config.yml") |
| args = parser.parse_args() |
|
|
| cfg = OmegaConf.load(args.cfg_path) |
| print("Config loaded:\n", OmegaConf.to_yaml(cfg)) |
|
|
| out_dir = Path(cfg.out_dir) |
| out_dir.mkdir(parents=True, exist_ok=True) |
| OmegaConf.save(cfg, out_dir / "config.yaml") |
|
|
| random_seed(cfg.seed) |
| device = torch.device(cfg.device) |
|
|
| data_loaders = make_data_loaders(cfg) |
| train_loader = data_loaders["train"] |
| val_loaders = data_loaders.copy() |
| val_loaders.pop("train") |
|
|
| print("Creating Stage 1 Model (Encoder)...") |
|
|
| sample_batch = next(iter(train_loader)) |
| feat_dims = [f.shape[-1] for f in sample_batch["features"]] |
| print(feat_dims) |
|
|
| subjects_list = cfg.get("subjects", SUBJECTS) |
|
|
| stage1_model = MultiSubjectConvLinearEncoder( |
| num_subjects=len(subjects_list), |
| feat_dims=feat_dims, |
| **cfg.stage1.model, |
| ).to(device) |
|
|
| optimizer1 = torch.optim.AdamW( |
| stage1_model.parameters(), |
| lr=cfg.stage1.lr, |
| weight_decay=cfg.stage1.weight_decay, |
| ) |
|
|
| print("Creating Stage 2 Models (Flow Matching)...") |
| stage2_models = nn.ModuleDict() |
| optimizers2 = {} |
|
|
| target_dim = sample_batch["fmri"].shape[-1] |
|
|
| cfm_params = cfg.stage2.cfm |
| decoder_params = cfg.stage2.decoder |
|
|
| for sub in subjects_list: |
| sub_key = str(sub) |
| cfm_model = CFM( |
| feat_dim=target_dim, |
| cfm_params=cfm_params, |
| decoder_params=decoder_params, |
| embed_dim=cfg.stage1.model.embed_dim, |
| ).to(device) |
|
|
| stage2_models[sub_key] = cfm_model |
| optimizers2[sub_key] = torch.optim.AdamW( |
| cfm_model.parameters(), |
| lr=cfg.stage2.lr, |
| weight_decay=cfg.stage2.weight_decay, |
| ) |
|
|
| print("--- Starting Joint Training (Stage 1 & Stage 2) ---") |
| best_score_s1 = -1.0 |
| joint_train_losses = [] |
| joint_val_accs = [] |
|
|
| for epoch in range(cfg.epochs): |
| train_loss = train_one_epoch_jointly( |
| epoch=epoch, |
| stage1_model=stage1_model, |
| stage2_models=stage2_models, |
| train_loader=train_loader, |
| stage1_optimizer=optimizer1, |
| stage2_optimizers=optimizers2, |
| device=device, |
| subjects=subjects_list, |
| ) |
| joint_train_losses.append(train_loss) |
|
|
| val_acc = None |
| for name, loader in val_loaders.items(): |
| acc, _ = evaluate_stage1( |
| epoch=epoch, |
| model=stage1_model, |
| val_loader=loader, |
| device=device, |
| subjects=subjects_list, |
| ds_name=name, |
| ) |
| if name == cfg.val_set_name: |
| val_acc = acc |
|
|
| joint_val_accs.append(val_acc if val_acc is not None else 0.0) |
|
|
| if val_acc is not None and val_acc > best_score_s1: |
| best_score_s1 = val_acc |
| torch.save(stage1_model.state_dict(), out_dir / "stage1_best.pt") |
| print("Saved best Stage 1 model.") |
|
|
| if epoch % 5 == 0 or epoch == cfg.epochs - 1: |
| ckpt_path = out_dir / f"stage2_epoch_{epoch}.pt" |
| torch.save(stage2_models.state_dict(), ckpt_path) |
| print(f"Saved Stage 2 checkpoint to {ckpt_path}") |
|
|
| plot_loss_curve( |
| joint_train_losses, |
| joint_val_accs, |
| out_dir, |
| filename="joint_loss_curve.png", |
| prefix="Joint", |
| ) |
|
|
| print(f"Joint Training Complete. Best model at Pearson's r {best_score_s1}") |
|
|
| stage1_model.load_state_dict(torch.load(out_dir / "stage1_best.pt")) |
| stage1_model.eval() |
|
|
| print("Evaluating final Stage 2 model...") |
| for name, loader in val_loaders.items(): |
| evaluate_stage2( |
| epoch=cfg.epochs, |
| stage1_model=stage1_model, |
| stage2_models=stage2_models, |
| val_loader=loader, |
| device=device, |
| subjects=subjects_list, |
| ds_name=name, |
| n_timesteps=cfg.stage2.get("n_timesteps", 25), |
| ) |
|
|
| print("Done! All training complete.") |
|
|
| if __name__ == "__main__": |
| main() |
