src/evaluate.py

import numpy as np
import torch
import torch.nn as nn
from timm.utils import AverageMeter
from torch.utils.data import DataLoader

from .metric import pearsonr_score
from .submission_utils import EXPECTED_SUBJECTS, EXPECTED_OOD_KEYS

@torch.no_grad()
def evaluate_stage1(
    *,
    epoch: int,
    model: torch.nn.Module,
    val_loader: DataLoader,
    device: torch.device,
    subjects: list,
    ds_name: str = "val",
):
    model.eval()

    loss_m = AverageMeter()
    samples = []
    outputs = []

    for batch_idx, batch in enumerate(val_loader):
        feats = [f.to(device) for f in batch["features"]]
        fmri = batch["fmri"].to(device)
        batch_size = fmri.size(0)

        pred, _ = model(feats)
        loss = nn.MSELoss()(pred, fmri)
        loss_m.update(loss.item(), batch_size)

        N, S, L, C = fmri.shape
        assert N, S == (1, 4)

        outputs.append(pred.cpu().numpy().swapaxes(0, 1).reshape((S, N * L, C)))
        samples.append(fmri.cpu().numpy().swapaxes(0, 1).reshape((S, N * L, C)))

    outputs = np.concatenate(outputs, axis=1)
    samples = np.concatenate(samples, axis=1)

    metrics = {}

    dim = samples.shape[-1]
    acc = 0.0
    acc_map = np.zeros(dim)
    for ii, sub in enumerate(subjects):
        y_true = samples[ii].reshape(-1, dim)
        y_pred = outputs[ii].reshape(-1, dim)
        metrics[f"accmap_sub-{sub}"] = acc_map_i = pearsonr_score(y_true, y_pred)
        metrics[f"acc_sub-{sub}"] = acc_i = np.mean(acc_map_i)
        acc_map += acc_map_i / len(subjects)
        acc += acc_i / len(subjects)

    metrics["accmap_avg"] = acc_map
    metrics["acc_avg"] = acc
    accs_fmt = ",".join(
        f"{val:.3f}" for key, val in metrics.items() if key.startswith("acc_sub-")
    )

    print(
        f"Evaluate Stage 1 ({ds_name}): {epoch:>3d}"
        f"  Loss: {loss_m.avg:#.3g}"
        f"  Acc: {accs_fmt} ({acc:.3f})"
    )

    return acc, metrics

@torch.no_grad()
def evaluate_stage2(
    *,
    epoch: int,
    stage1_model: torch.nn.Module,
    stage2_models: nn.ModuleDict,
    val_loader: DataLoader,
    device: torch.device,
    subjects: list,
    ds_name: str = "val",
    n_timesteps: int = 10,
):
    stage1_model.eval()
    for model in stage2_models.values():
        model.eval()

    samples = []
    outputs = []

    for batch in val_loader:
        feats = [f.to(device) for f in batch["features"]]
        fmri = batch["fmri"].to(device)

        mu_anchor, embed_anchor = stage1_model(feats)

        batch_preds = []
        for i, sub in enumerate(subjects):
            sub_key = str(sub)
            cfm = stage2_models[sub_key]

            src_cond = mu_anchor[:, i].transpose(1, 2)
            mu_fusion = embed_anchor.transpose(1, 2)

            pred = cfm(src_cond, mu_fusion, n_timesteps=n_timesteps) 
            pred = pred.transpose(1, 2).unsqueeze(1) 
            batch_preds.append(pred)

        pred_combined = torch.cat(batch_preds, dim=1)

        N, S, L, C = fmri.shape
        assert N, S == (1, 4)

        outputs.append(
            pred_combined.cpu().numpy().swapaxes(0, 1).reshape((S, N * L, C))
        )
        samples.append(fmri.cpu().numpy().swapaxes(0, 1).reshape((S, N * L, C)))

    outputs = np.concatenate(outputs, axis=1)
    samples = np.concatenate(samples, axis=1)

    metrics = {}

    dim = samples.shape[-1]
    acc = 0.0
    acc_map = np.zeros(dim)
    for ii, sub in enumerate(subjects):
        y_true = samples[ii].reshape(-1, dim)
        y_pred = outputs[ii].reshape(-1, dim)
        metrics[f"accmap_sub-{sub}"] = acc_map_i = pearsonr_score(y_true, y_pred)
        metrics[f"acc_sub-{sub}"] = acc_i = np.mean(acc_map_i)
        acc_map += acc_map_i / len(subjects)
        acc += acc_i / len(subjects)

    metrics["accmap_avg"] = acc_map
    metrics["acc_avg"] = acc
    accs_fmt = ",".join(
        f"{val:.3f}" for key, val in metrics.items() if key.startswith("acc_sub-")
    )

    print(f"Evaluate Stage 2 ({ds_name}): {epoch:>3d}" f"  Acc: {accs_fmt} ({acc:.3f})")

    return acc, metrics

def validate_submission(
    predictions: dict[str, dict[str, np.ndarray]],
    test_set_name: str,
    fmri_num_samples: dict[str, dict[str, int]],
):
    subject_keys = set(predictions.keys())
    if subject_keys != EXPECTED_SUBJECTS:
        extra = subject_keys - EXPECTED_SUBJECTS
        missing = EXPECTED_SUBJECTS - subject_keys
        raise ValueError(
            f"Subject key mismatch. Extra: {extra}, Missing: {missing}. "
            f"Expected exactly: {EXPECTED_SUBJECTS}"
        )

    if test_set_name == "ood":
        expected_episodes = EXPECTED_OOD_KEYS
    elif test_set_name == "friends-s7":
        all_episodes = set()
        for sub_samples in fmri_num_samples.values():
            all_episodes.update(sub_samples.keys())
        expected_episodes = all_episodes
    else:
        print(f"  Warning: no key validation for test set '{test_set_name}'")
        return

    for sub, episodes_dict in predictions.items():
        episode_keys = set(episodes_dict.keys())
        extra = episode_keys - expected_episodes
        missing = expected_episodes - episode_keys

        if extra:
            raise ValueError(
                f"{sub}: extra episode keys {extra} — these will cause a formatting error"
            )
        if missing:
            raise ValueError(
                f"{sub}: missing episode keys {missing} — submission is incomplete"
            )

        for ep, pred in episodes_dict.items():
            expected_n = fmri_num_samples[sub].get(ep)
            if expected_n is not None and pred.shape[0] != expected_n:
                raise ValueError(
                    f"{sub}/{ep}: shape {pred.shape} but expected N={expected_n}"
                )
            if pred.shape[1] != 1000:
                raise ValueError(
                    f"{sub}/{ep}: shape {pred.shape} but expected 1000 parcels"
                )
            if pred.dtype != np.float32:
                raise ValueError(
                    f"{sub}/{ep}: dtype {pred.dtype} but expected float32"
                )

    print(f"  Validation passed: {len(predictions)} subjects, "
          f"{len(expected_episodes)} episodes each")