src/flowfm/model_factory.py

"""Model and optimizer factories for two-stage training."""

from typing import Any

import torch
import torch.nn as nn
from omegaconf import DictConfig

try:
    from src.stage1.medarc_architecture import MultiSubjectConvLinearEncoder
    from src.stage2.CFM import CFM
except ImportError:
    from stage1.medarc_architecture import MultiSubjectConvLinearEncoder
    from stage2.CFM import CFM


def infer_feature_dims(sample_batch: dict[str, Any]) -> list[int]:
    """Infer feature dimensions from a single batch."""
    return [feature.shape[-1] for feature in sample_batch["features"]]


def infer_target_dim(sample_batch: dict[str, Any]) -> int:
    """Infer output voxel dimension from a single batch."""
    return int(sample_batch["fmri"].shape[-1])


def build_stage1_model(
    cfg: DictConfig,
    feat_dims: list[int],
    subjects: list[int],
    device: torch.device,
) -> nn.Module:
    """Instantiate Stage 1 mean-anchor model."""
    model = MultiSubjectConvLinearEncoder(
        num_subjects=len(subjects),
        feat_dims=feat_dims,
        **cfg.stage1.model,
    )
    return model.to(device)


def build_stage1_optimizer(cfg: DictConfig, model: nn.Module) -> torch.optim.Optimizer:
    """Instantiate Stage 1 optimizer."""
    return torch.optim.AdamW(
        model.parameters(),
        lr=cfg.stage1.lr,
        weight_decay=cfg.stage1.weight_decay,
    )


def build_stage2_models(
    cfg: DictConfig,
    target_dim: int,
    subjects: list[int],
    device: torch.device,
) -> nn.ModuleDict:
    """Create one CFM model per subject."""
    stage2_models = nn.ModuleDict()

    cfm_params = cfg.stage2.cfm
    decoder_params = cfg.stage2.decoder

    for sub in subjects:
        sub_key = str(sub)
        cfm_model = CFM(
            feat_dim=target_dim,
            cfm_params=cfm_params,
            decoder_params=decoder_params,
        ).to(device)
        stage2_models[sub_key] = cfm_model

    return stage2_models


def build_stage2_optimizers(
    cfg: DictConfig,
    stage2_models: nn.ModuleDict,
) -> dict[str, torch.optim.Optimizer]:
    """Create one optimizer per Stage 2 subject model."""
    optimizers: dict[str, torch.optim.Optimizer] = {}
    for sub_key, cfm_model in stage2_models.items():
        optimizers[sub_key] = torch.optim.AdamW(
            cfm_model.parameters(),
            lr=cfg.stage2.lr,
            weight_decay=cfg.stage2.weight_decay,
        )
    return optimizers