Refactor A1 evaluation protocols to focus exclusively on Protocol C; update documentation and scripts accordingly.

README.md

@@ -1,6 +1,6 @@
-## Plan: A1 SI Baseline with Dual Evaluation and Expanded Parcels
+## Plan: A1 SI Baseline with Protocol C Evaluation and Expanded Parcels
 
-Implement A1 as a frozen SI baseline with two required evaluation protocols: cross-run generalization and within-run blocked split. Keep both 7 language ROIs and expanded Harvard-Oxford symmetric parcels, and report results separately so speaker-shift robustness and same-condition fit are not conflated.
+Implement A1 as a frozen SI baseline with Protocol C cross-subject shared-space evaluation. Keep both 7 language ROIs and expanded Harvard-Oxford symmetric parcels, and report results by fold and run condition.
 
 **Steps**
 1. Phase 0: Paper-first gate before coding
@@ -38,21 +38,17 @@ Implement A1 as a frozen SI baseline with two required evaluation protocols: cro
 - Apply per-run z-score to regressors and BOLD targets.
 - Enforce exact regressor-target TR length match after trimming policy.
 
-8. Phase 7: Dual evaluation implementation (both required)
-- Protocol A: cross-run split
-- Leave-one-run-out per subject to test speaker and condition transfer.
-- Nested alpha selection on training-only partitions.
-- Protocol B: within-run blocked split
-- Use contiguous temporal blocks inside each run for train and test, not random word sampling.
-- Add temporal gap buffer between train and test blocks to reduce HRF bleed leakage.
-- Tune alpha using training-only temporal partitions.
-- Compute metrics for both target sets in both protocols: 7 ROIs and expanded parcels.
-- Keep outputs clearly labeled by protocol to avoid mixing interpretations.
+8. Phase 7: Evaluation implementation (required)
+- Protocol C: cross-subject shared-space split
+- Use 21:3 subject split with 2-fold cross-validation over accepted subjects.
+- Keep fold construction deterministic via a fixed seed.
+- Compute metrics for both target sets: 7 ROIs and expanded parcels.
+- Keep outputs clearly labeled by fold and run condition.
 
 9. Phase 8: Outputs and reporting
 - Save per-model, per-layer, per-subject, per-run, per-target, per-protocol tables.
 - Save left-right asymmetry summaries and significance tables for parcel and ROI levels.
-- Save protocol comparison report: cross-run versus within-run blocked.
+- Save Protocol C summary report across folds and run conditions.
 
 10. Phase 9: Optional extension after baseline
 - Add fine-tuning branch as a separate experiment only after frozen baseline is complete.
@@ -83,8 +79,8 @@ Implement A1 as a frozen SI baseline with two required evaluation protocols: cro
 
 4. Modeling checks
 - Frozen baseline confirmed with no weight updates.
-- Protocol A and Protocol B each have independent train and validation and test metadata.
-- Within-run blocked split includes temporal buffer and zero overlap after buffering.
+- Protocol C fold table uses 21 train and 3 test subjects per fold with 2 folds.
+- Each canonical run condition is evaluated per fold.
 
 5. Reporting checks
 - 7 ROI and expanded parcel outputs exist for both protocols.
@@ -92,7 +88,7 @@ Implement A1 as a frozen SI baseline with two required evaluation protocols: cro
 
 **Decisions**
 - Baseline SI uses frozen inference plus ridge only.
-- Two evaluation protocols are both required in baseline: cross-run and within-run blocked.
+- Protocol C cross-subject shared-space is the required baseline evaluation protocol.
 - Random word-level 500/100 split is excluded from primary SI evaluation due temporal leakage risk after HRF convolution.
 - Expanded ROI set uses Harvard-Oxford cortical maxprob-thr0-2mm with symmetric split.
 - Fine-tuning remains a separate post-baseline experiment branch.
@@ -148,7 +144,7 @@ python mohith/TEAM-9/hf_jobs.py \
   --results-path hf_jobs/run_001 \
   --flavor a10g-small \
   --model-profile current \
-  --protocols B,C \
+  --protocols C \
   --secret-hf-token \
   --launch
 ```
@@ -158,5 +154,4 @@ python mohith/TEAM-9/hf_jobs.py \
 - `--secret-hf-token` is recommended when the dataset repos are private.
 - The job keeps the CUDA-enabled PyTorch already present in the container image and installs the rest of `project/requirements.txt` separately.
 - By default bootstrap artifacts go to `outputs/a1_bootstrap_hf` inside the cloned repo.
-- You can forward the normal end-to-end controls such as `--model-profile`, `--model-slug`, `--reuse-caches`, `--skip-bootstrap`, `--skip-fit`, and `--skip-visualize`.
 - You can forward the normal end-to-end controls such as `--model-profile`, `--model-slug`, `--protocols`, `--reuse-caches`, `--skip-bootstrap`, `--skip-fit`, and `--skip-visualize`.

code/run_a1_bootstrap.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-"""Bootstrap A1 baseline with manifest QC and dual evaluation split artifacts.
+"""Bootstrap A1 baseline with manifest QC and Protocol C split artifacts.
 
 This command currently implements:
 - Phase 1: strict derivatives manifest and integrity checks
@@ -8,13 +8,14 @@ This command currently implements:
 - Phase 4: annotation harmonization to unified run/condition/speaker event tables
 - Phase 5: optional frozen feature extraction wrappers and caching
 - Phase 6: optional TR-level HRF regressor + z-score alignment input caching
-- Phase 7 prep: Protocol A (cross-run) and Protocol B (within-run blocked) split tables
+- Phase 7 prep: Protocol C (cross-subject) split table
 """
 
 from __future__ import annotations
 
 import argparse
 import json
+import random
 from pathlib import Path
 from typing import Any
 
@@ -29,11 +30,6 @@ from a1_pipeline.io_utils import ensure_directory, write_json
 from a1_pipeline.manifest import build_derivatives_manifest
 from a1_pipeline.model_config import load_model_ids_from_config, list_model_profiles
 from a1_pipeline.spatial import build_symmetric_analysis_mask
-from a1_pipeline.splits import (
-    build_cross_run_folds,
-    build_within_run_blocked_splits,
-    summarize_split_counts,
-)
 from a1_pipeline.targets import evaluate_core_roi_preservation, load_core_roi_masks
 
 
@@ -74,6 +70,69 @@ def _parse_layer_indices(raw: str) -> list[int] | None:
     return indices
 
 
+def _build_protocol_c_folds(
+    manifest_df: pd.DataFrame,
+    n_test_subjects: int,
+    n_folds: int,
+    seed: int,
+) -> pd.DataFrame:
+    """Build Protocol C folds using repeated 21:3 subject holdout splits."""
+    canonical_labels = {
+        1: "single_female",
+        2: "single_male",
+        3: "mixed_female",
+        4: "mixed_male",
+    }
+
+    subjects = sorted(manifest_df["subject"].astype(str).unique().tolist())
+    n_subjects = len(subjects)
+
+    if n_subjects != 24:
+        raise ValueError(
+            "Protocol C 21:3 split requires exactly 24 accepted subjects. "
+            f"Found {n_subjects}."
+        )
+    if n_test_subjects != 3:
+        raise ValueError(
+            "Protocol C is fixed to 21:3, so --protocol-c-test-subjects must be 3"
+        )
+    if n_folds <= 0:
+        raise ValueError("--protocol-c-num-folds must be positive")
+
+    rng = random.Random(int(seed))
+    shuffled_subjects = list(subjects)
+    rng.shuffle(shuffled_subjects)
+
+    rows: list[dict[str, Any]] = []
+    for fold_idx in range(int(n_folds)):
+        start = (fold_idx * n_test_subjects) % n_subjects
+        test_subjects = [
+            shuffled_subjects[(start + offset) % n_subjects]
+            for offset in range(n_test_subjects)
+        ]
+        test_subject_set = set(test_subjects)
+        train_subjects = [subject for subject in subjects if subject not in test_subject_set]
+
+        if len(train_subjects) != 21:
+            raise ValueError(
+                "Protocol C expected 21 train subjects per fold, got "
+                f"{len(train_subjects)}"
+            )
+
+        for canonical_run, condition_label in canonical_labels.items():
+            rows.append(
+                {
+                    "fold_id": f"cv2_run{canonical_run}_fold{fold_idx + 1}",
+                    "canonical_run": int(canonical_run),
+                    "condition_label": str(condition_label),
+                    "train_subjects": ",".join(train_subjects),
+                    "test_subjects": ",".join(test_subjects),
+                }
+            )
+
+    return pd.DataFrame(rows).sort_values(["canonical_run", "fold_id"]).reset_index(drop=True)
+
+
 def _build_arg_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(description="Bootstrap A1 manifest and split artifacts")
     parser.add_argument(
@@ -139,28 +198,22 @@ def _build_arg_parser() -> argparse.ArgumentParser:
         help="Disable mixed-run condition fallback to generic 'mixed' label",
     )
     parser.add_argument(
-        "--within-test-fraction",
-        type=float,
-        default=0.2,
-        help="Protocol B test fraction per run",
-    )
-    parser.add_argument(
-        "--within-gap-tr",
+        "--protocol-c-test-subjects",
         type=int,
-        default=8,
-        help="Protocol B temporal gap (in TR) between train and test blocks",
+        default=3,
+        help="Protocol C test subject count per fold (fixed to 3 for 21:3)",
     )
     parser.add_argument(
-        "--within-min-train-volumes",
+        "--protocol-c-num-folds",
         type=int,
-        default=40,
-        help="Minimum train TR count for Protocol B",
+        default=2,
+        help="Protocol C repeated holdout fold count",
     )
     parser.add_argument(
-        "--within-min-test-volumes",
+        "--protocol-c-seed",
         type=int,
-        default=20,
-        help="Minimum test TR count for Protocol B",
+        default=0,
+        help="Random seed for Protocol C fold construction",
     )
     parser.add_argument(
         "--run-mask-method",
@@ -456,20 +509,8 @@ def main() -> None:
         enable_mixed_fallback=mixed_fallback_enabled,
     )
 
-    cross_run_df = build_cross_run_folds(manifest_df)
-    within_run_df, within_run_skipped_df = build_within_run_blocked_splits(
-        manifest_df=manifest_df,
-        test_fraction=float(args.within_test_fraction),
-        gap_tr=int(args.within_gap_tr),
-        min_train_volumes=int(args.within_min_train_volumes),
-        min_test_volumes=int(args.within_min_test_volumes),
-    )
-
     accepted_manifest_path = output_dir / "accepted_manifest.csv"
     rejected_manifest_path = output_dir / "rejected_manifest.csv"
-    protocol_a_path = output_dir / "protocol_a_cross_run_folds.csv"
-    protocol_b_path = output_dir / "protocol_b_within_run_splits.csv"
-    protocol_b_skipped_path = output_dir / "protocol_b_within_run_skipped.csv"
     protocol_c_path = output_dir / "protocol_c_cross_subject_folds.csv"
     analysis_mask_path = output_dir / "analysis_mask.nii.gz"
     run_mask_qc_path = output_dir / "run_mask_qc.csv"
@@ -493,25 +534,13 @@ def main() -> None:
 
     manifest_df.to_csv(accepted_manifest_path, index=False)
     rejected_df.to_csv(rejected_manifest_path, index=False)
-    cross_run_df.to_csv(protocol_a_path, index=False)
-    within_run_df.to_csv(protocol_b_path, index=False)
-    within_run_skipped_df.to_csv(protocol_b_skipped_path, index=False)
-
-    # Protocol C: leave-one-subject-out folds across all 4 canonical runs.
-    _CANONICAL_RUN_LABELS = {1: "single_female", 2: "single_male", 3: "mixed_female", 4: "mixed_male"}
-    protocol_c_subjects = sorted(manifest_df["subject"].unique().tolist())
-    protocol_c_rows = []
-    for _cr, _cl in _CANONICAL_RUN_LABELS.items():
-        for _test_sub in protocol_c_subjects:
-            _train_subs = ",".join(s for s in protocol_c_subjects if s != _test_sub)
-            protocol_c_rows.append({
-                "fold_id": f"loso_run{_cr}_{_test_sub}",
-                "canonical_run": _cr,
-                "condition_label": _cl,
-                "train_subjects": _train_subs,
-                "test_subjects": _test_sub,
-            })
-    pd.DataFrame(protocol_c_rows).to_csv(protocol_c_path, index=False)
+    protocol_c_df = _build_protocol_c_folds(
+        manifest_df=manifest_df,
+        n_test_subjects=int(args.protocol_c_test_subjects),
+        n_folds=int(args.protocol_c_num_folds),
+        seed=int(args.protocol_c_seed),
+    )
+    protocol_c_df.to_csv(protocol_c_path, index=False)
     run_mask_qc_df.to_csv(run_mask_qc_path, index=False)
     core_roi_coverage_df.to_csv(core_roi_coverage_path, index=False)
     core_roi_failures_df.to_csv(core_roi_failures_path, index=False)
@@ -521,12 +550,14 @@ def main() -> None:
 
     nib.save(analysis_mask_img, str(analysis_mask_path))
 
-    split_summary = summarize_split_counts(
-        manifest_df=manifest_df,
-        cross_run_df=cross_run_df,
-        within_run_df=within_run_df,
-        within_run_skipped_df=within_run_skipped_df,
-    )
+    split_summary = {
+        "n_manifest_rows": int(len(manifest_df)),
+        "n_subjects_manifest": int(manifest_df["subject"].nunique()) if not manifest_df.empty else 0,
+        "n_protocol_a_folds": 0,
+        "n_protocol_b_splits": 0,
+        "n_protocol_b_skipped": 0,
+        "n_protocol_c_folds": int(len(protocol_c_df)),
+    }
 
     write_json(manifest_qc_path, manifest_qc)
     write_json(analysis_mask_qc_path, mask_qc)
@@ -645,11 +676,11 @@ def main() -> None:
             "min_voxels_required": int(args.min_core_roi_voxels),
             "allow_core_roi_failures": bool(args.allow_core_roi_failures),
         },
-        "within_protocol": {
-            "test_fraction": float(args.within_test_fraction),
-            "gap_tr": int(args.within_gap_tr),
-            "min_train_volumes": int(args.within_min_train_volumes),
-            "min_test_volumes": int(args.within_min_test_volumes),
+        "protocol_c_config": {
+            "n_test_subjects": int(args.protocol_c_test_subjects),
+            "n_train_subjects": 21,
+            "n_folds": int(args.protocol_c_num_folds),
+            "seed": int(args.protocol_c_seed),
         },
         "manifest_qc": manifest_qc,
         "analysis_mask_qc": mask_qc,
@@ -684,9 +715,6 @@ def main() -> None:
             if alignment_regressor_summary_path.exists()
             else None,
             "alignment_qc": str(alignment_qc_path) if alignment_qc_path.exists() else None,
-            "protocol_a_cross_run": str(protocol_a_path),
-            "protocol_b_within_run": str(protocol_b_path),
-            "protocol_b_within_run_skipped": str(protocol_b_skipped_path),
             "protocol_c_cross_subject": str(protocol_c_path),
         },
     }
@@ -696,9 +724,7 @@ def main() -> None:
     print("A1 bootstrap complete")
     print(f"Accepted manifest rows: {len(manifest_df)}")
     print(f"Rejected candidate rows: {len(rejected_df)}")
-    print(f"Protocol A folds: {len(cross_run_df)}")
-    print(f"Protocol B splits: {len(within_run_df)}")
-    print(f"Protocol B skipped: {len(within_run_skipped_df)}")
+    print(f"Protocol C folds: {len(protocol_c_df)}")
     print(f"Core ROI fail rows: {len(core_roi_failures_df)}")
     print(f"Core ROI gate passed: {core_roi_gate_passed}")
     print(f"Run-level event rows: {len(run_events_df)}")

code/run_a1_end_to_end.py

@@ -112,8 +112,8 @@ def _build_parser() -> argparse.ArgumentParser:
     parser.add_argument(
         "--protocols",
         type=str,
-        default="B,C",
-        help="Fit protocols to execute: B, C, or a comma-separated subset (bootstrap generates protocol_c_cross_subject_folds.csv automatically).",
+        default="C",
+        help="Fit protocols to execute: C (bootstrap generates protocol_c_cross_subject_folds.csv automatically).",
     )
     parser.add_argument(
         "--metric",

code/run_a1_fit.py

@@ -3,7 +3,6 @@
 
 This script consumes Phase 6 artifacts from `run_a1_bootstrap.py` and computes
 ridge-regression performance for:
-- Protocol B: within-run blocked split
 - Protocol C: cross-subject subject-holdout on a shared canonical stimulus
 
 It is optimized for ROI-level evaluation using the 7 core language ROIs.
@@ -81,7 +80,7 @@ def _parse_protocols(raw: str) -> set[str]:
     if not values:
         raise ValueError("At least one protocol is required")
 
-    allowed = {"B", "C"}
+    allowed = {"C"}
     unknown = values.difference(allowed)
     if unknown:
         raise ValueError(f"Unsupported protocol(s): {sorted(unknown)}")
@@ -137,8 +136,8 @@ def _build_parser() -> argparse.ArgumentParser:
     parser.add_argument(
         "--protocols",
         type=str,
-        default="B,C",
-        help="Protocols to run: B, C, or a comma-separated subset (default: B,C).",
+        default="C",
+        help="Protocols to run: C (cross-subject shared-space).",
     )
     parser.add_argument(
         "--roi-mask-dir",
@@ -166,7 +165,7 @@ def _build_parser() -> argparse.ArgumentParser:
         type=str,
         default="auto",
         help=(
-            "Number of CPU workers to evaluate layers in parallel for protocols B and C. "
+            "Number of CPU workers to evaluate layers in parallel for protocol C. "
             "'auto' uses min(n_layers, cpu_count // 2). Use 1 to force serial."
         ),
     )
@@ -187,7 +186,6 @@ def _resolve_core_paths(bootstrap_output_dir: Path) -> dict[str, Path]:
         "analysis_mask": bootstrap_output_dir / "analysis_mask.nii.gz",
         "bold_summary": _pick_csv("alignment_bold_summary.csv"),
         "regressor_summary": _pick_csv("alignment_regressor_summary.csv"),
-        "protocol_b": _pick_csv("protocol_b_within_run_splits.csv"),
         "protocol_c": _pick_csv("protocol_c_cross_subject_folds.csv"),
     }
 
@@ -199,8 +197,6 @@ def _check_required_files(path_map: dict[str, Path], protocols: set[str]) -> Non
         "bold_summary",
         "regressor_summary",
     }
-    if "B" in protocols:
-        required_names.add("protocol_b")
     if "C" in protocols:
         required_names.add("protocol_c")
 
@@ -443,18 +439,6 @@ def _score_matrix(y_true: np.ndarray, y_pred: np.ndarray) -> dict[str, float]:
     }
 
 
-def _stack_protocol_b_train(
-    values: np.ndarray,
-    left_start: int,
-    left_end: int,
-    right_start: int,
-    right_end: int,
-) -> np.ndarray:
-    left = values[left_start:left_end]
-    right = values[right_start:right_end]
-    return np.concatenate([left, right], axis=0)
-
-
 def _collect_protocol_c_subjects(cross_subject_df: pd.DataFrame) -> list[str]:
     if cross_subject_df.empty:
         return []
@@ -467,224 +451,6 @@ def _collect_protocol_c_subjects(cross_subject_df: pd.DataFrame) -> list[str]:
     return sorted(subjects)
 
 
-def _evaluate_protocol_b_layer(
-    layer_idx: int,
-    subjects: list[str],
-    alpha: float,
-    within_run_df: pd.DataFrame,
-    regressor_path_map: dict[tuple[int, int], Path],
-    canonical_runs_required: list[int],
-    subject_roi_cache: dict[str, dict[int, dict[str, np.ndarray]]],
-    participant_run_map: dict[str, dict[int, int]],
-    model_slug: str,
-    model_id: str,
-    blas_threads: int,
-) -> list[dict[str, Any]]:
-    """Evaluate Protocol B for a single layer. Returns list of result rows."""
-    from threadpoolctl import threadpool_limits
-
-    rows: list[dict[str, Any]] = []
-
-    with threadpool_limits(limits=int(blas_threads)):
-        x_by_canonical_run: dict[int, np.ndarray] = {}
-        for canonical_run in canonical_runs_required:
-            key = (canonical_run, layer_idx)
-            if key not in regressor_path_map:
-                raise KeyError(
-                    "Missing regressor cache for "
-                    f"canonical_run={canonical_run}, layer={layer_idx}, model={model_slug}"
-                )
-            x_by_canonical_run[canonical_run] = np.asarray(np.load(regressor_path_map[key]), dtype=np.float32)
-
-        group_columns = [
-            "run",
-            "test_start_tr",
-            "test_end_tr_exclusive",
-            "train_left_start_tr",
-            "train_left_end_tr_exclusive",
-            "train_right_start_tr",
-            "train_right_end_tr_exclusive",
-            "split_id",
-        ]
-
-        for _, group_df in within_run_df.groupby(group_columns):
-            example = group_df.iloc[0]
-
-            run = int(example["run"])
-            split_id = str(example["split_id"])
-            test_start = int(example["test_start_tr"])
-            test_end = int(example["test_end_tr_exclusive"])
-            left_start = int(example["train_left_start_tr"])
-            left_end = int(example["train_left_end_tr_exclusive"])
-            right_start = int(example["train_right_start_tr"])
-            right_end = int(example["train_right_end_tr_exclusive"])
-
-            per_canonical_cache: dict[int, tuple[np.ndarray, np.ndarray, int]] = {}
-
-            for row in group_df.itertuples(index=False):
-                subject = str(getattr(row, "subject"))
-                canonical_run = resolve_subject_canonical_run(
-                    participant_run_map=participant_run_map,
-                    subject=subject,
-                    run=run,
-                )
-
-                if canonical_run not in per_canonical_cache:
-                    x_full = x_by_canonical_run[canonical_run]
-                    x_train = _stack_protocol_b_train(
-                        values=x_full,
-                        left_start=left_start,
-                        left_end=left_end,
-                        right_start=right_start,
-                        right_end=right_end,
-                    )
-                    x_test = x_full[test_start:test_end]
-                    projector = _ridge_projection_matrix(x_train=x_train, alpha=alpha)
-                    per_canonical_cache[canonical_run] = (projector, x_test, int(x_train.shape[0]))
-
-                projector, x_test, n_train_tr = per_canonical_cache[canonical_run]
-                y_subject = subject_roi_cache[subject]
-
-                for roi_name in CORE_ROI_NAMES:
-                    y_full = y_subject[run][roi_name]
-                    if y_full.shape[0] != x_by_canonical_run[canonical_run].shape[0]:
-                        raise ValueError(
-                            "Protocol B full-run TR mismatch between regressors and BOLD for "
-                            f"subject={subject}, run={run}, canonical_run={canonical_run}, "
-                            f"layer={layer_idx}, roi={roi_name}. "
-                            f"x_full_tr={x_by_canonical_run[canonical_run].shape[0]}, y_full_tr={y_full.shape[0]}"
-                        )
-
-                    y_train = _stack_protocol_b_train(
-                        values=y_full,
-                        left_start=left_start,
-                        left_end=left_end,
-                        right_start=right_start,
-                        right_end=right_end,
-                    )
-                    y_test = y_full[test_start:test_end]
-
-                    if y_train.shape[0] != n_train_tr:
-                        raise ValueError(
-                            "Protocol B train TR mismatch between regressors and BOLD for "
-                            f"subject={subject}, run={run}, canonical_run={canonical_run}, "
-                            f"layer={layer_idx}, roi={roi_name}. "
-                            f"x_train_tr={n_train_tr}, y_train_tr={y_train.shape[0]}"
-                        )
-                    if y_test.shape[0] != x_test.shape[0]:
-                        raise ValueError(
-                            "Protocol B test TR mismatch between regressors and BOLD for "
-                            f"subject={subject}, run={run}, canonical_run={canonical_run}, "
-                            f"layer={layer_idx}, roi={roi_name}. "
-                            f"x_test_tr={x_test.shape[0]}, y_test_tr={y_test.shape[0]}"
-                        )
-
-                    weights = projector @ np.asarray(y_train, dtype=np.float64)
-                    y_pred = np.asarray(x_test, dtype=np.float64) @ weights
-
-                    scores = _score_matrix(y_true=y_test, y_pred=y_pred)
-
-                    rows.append(
-                        {
-                            "protocol": "B_within_run_blocked",
-                            "model_id": model_id,
-                            "model_slug": model_slug,
-                            "subject": subject,
-                            "run": int(run),
-                            "canonical_run": int(canonical_run),
-                            "split_id": split_id,
-                            "layer_idx": int(layer_idx),
-                            "roi_name": roi_name,
-                            "alpha": float(alpha),
-                            "n_train_tr": int(n_train_tr),
-                            "n_test_tr": int(x_test.shape[0]),
-                            "n_voxels_roi": int(y_test.shape[1]),
-                            **scores,
-                        }
-                    )
-
-    return rows
-
-
-def _evaluate_protocol_b(
-    subjects: list[str],
-    layers: list[int],
-    alpha: float,
-    within_run_df: pd.DataFrame,
-    bold_path_map: dict[tuple[str, int], Path],
-    regressor_path_map: dict[tuple[int, int], Path],
-    roi_index_map: dict[str, np.ndarray],
-    participant_run_map: dict[str, dict[int, int]],
-    model_slug: str,
-    model_id: str,
-    n_workers: int = 1,
-    blas_threads_per_worker: int = 0,
-) -> pd.DataFrame:
-    runs = sorted({int(value) for value in within_run_df["run"].tolist()})
-
-    subject_roi_cache: dict[str, dict[int, dict[str, np.ndarray]]] = {}
-    for subject in subjects:
-        subject_roi_cache[subject] = _load_subject_roi_runs(
-            subject=subject,
-            runs=runs,
-            bold_path_map=bold_path_map,
-            roi_index_map=roi_index_map,
-        )
-
-    canonical_runs_required = sorted(
-        {
-            resolve_subject_canonical_run(
-                participant_run_map=participant_run_map,
-                subject=subject,
-                run=run,
-            )
-            for subject in subjects
-            for run in runs
-        }
-    )
-
-    if blas_threads_per_worker <= 0:
-        blas_threads_per_worker = max(1, (os.cpu_count() or 4) // max(1, n_workers))
-
-    def _layer_task(layer_idx: int) -> list[dict[str, Any]]:
-        return _evaluate_protocol_b_layer(
-            layer_idx=int(layer_idx),
-            subjects=subjects,
-            alpha=alpha,
-            within_run_df=within_run_df,
-            regressor_path_map=regressor_path_map,
-            canonical_runs_required=canonical_runs_required,
-            subject_roi_cache=subject_roi_cache,
-            participant_run_map=participant_run_map,
-            model_slug=model_slug,
-            model_id=model_id,
-            blas_threads=blas_threads_per_worker,
-        )
-
-    if n_workers > 1 and len(layers) > 1:
-        from joblib import Parallel, delayed
-
-        print(
-            f"[fit] Protocol B: parallel layers across {n_workers} threads "
-            f"(layers={len(layers)}, blas_threads/worker={blas_threads_per_worker})",
-            flush=True,
-        )
-        results = Parallel(n_jobs=int(n_workers), prefer="threads")(
-            delayed(_layer_task)(layer_idx) for layer_idx in layers
-        )
-    else:
-        results = [_layer_task(layer_idx) for layer_idx in layers]
-
-    rows: list[dict[str, Any]] = []
-    for layer_rows in results:
-        rows.extend(layer_rows)
-
-    df = pd.DataFrame(rows)
-    if not df.empty:
-        df = df.sort_values(["layer_idx", "subject", "run", "roi_name"]).reset_index(drop=True)
-    return df
-
-
 def _evaluate_protocol_c(
     layers: list[int],
     alpha: float,
@@ -946,7 +712,6 @@ def main() -> None:
 
     bold_summary_df = pd.read_csv(path_map["bold_summary"])
     regressor_summary_df = pd.read_csv(path_map["regressor_summary"])
-    within_run_df = pd.read_csv(path_map["protocol_b"]) if path_map["protocol_b"].exists() else pd.DataFrame()
     cross_subject_df = (
         pd.read_csv(path_map["protocol_c"]) if path_map["protocol_c"].exists() else pd.DataFrame()
     )
@@ -958,11 +723,8 @@ def main() -> None:
 
     if requested_subjects is not None:
         subject_set = set(requested_subjects)
-        within_run_df = within_run_df[within_run_df["subject"].isin(subject_set)].copy()
         bold_summary_df = bold_summary_df[bold_summary_df["subject"].isin(subject_set)].copy()
 
-    if within_run_df.empty and "B" in protocols:
-        raise ValueError("Protocol B was requested but no within-run rows remained after filtering")
     if cross_subject_df.empty and "C" in protocols:
         raise ValueError("Protocol C was requested but no cross-subject rows were available")
 
@@ -998,10 +760,7 @@ def main() -> None:
     )
 
     protocol_c_subjects = _collect_protocol_c_subjects(cross_subject_df) if "C" in protocols else []
-    subjects = sorted(
-        set(within_run_df["subject"].tolist())
-        | set(protocol_c_subjects)
-    )
+    subjects = sorted(set(protocol_c_subjects))
     if not subjects:
         raise ValueError("No subjects available after filtering")
 
@@ -1023,7 +782,6 @@ def main() -> None:
         }
     )
 
-    protocol_b_df = pd.DataFrame()
     protocol_c_df = pd.DataFrame()
 
     n_fit_workers, blas_threads_per_worker = _resolve_num_fit_workers(
@@ -1038,23 +796,6 @@ def main() -> None:
             flush=True,
         )
 
-    if "B" in protocols:
-        protocol_b_df = _evaluate_protocol_b(
-            subjects=subjects,
-            layers=layers,
-            alpha=float(args.alpha),
-            within_run_df=within_run_df,
-            bold_path_map=bold_path_map,
-            regressor_path_map=regressor_path_map,
-            roi_index_map=roi_index_map,
-            participant_run_map=participant_run_map,
-            model_slug=str(args.model_slug),
-            model_id=model_id,
-            n_workers=n_fit_workers,
-            blas_threads_per_worker=blas_threads_per_worker,
-        )
-        protocol_b_df.to_csv(output_dir / "protocol_b_core_roi_scores.csv", index=False)
-
     if "C" in protocols:
         protocol_c_df = _evaluate_protocol_c(
             layers=layers,
@@ -1071,7 +812,7 @@ def main() -> None:
         )
         protocol_c_df.to_csv(output_dir / "protocol_c_core_roi_scores.csv", index=False)
 
-    combined_df = pd.concat([protocol_b_df, protocol_c_df], ignore_index=True)
+    combined_df = protocol_c_df.copy()
     combined_df.to_csv(output_dir / "core_roi_scores_all.csv", index=False)
 
     layer_summary_df, best_layer_df = _summarize_layers(scores_df=combined_df)
@@ -1093,7 +834,6 @@ def main() -> None:
         "participant_run_info_path": str(participant_run_info_path),
         "required_runs": [int(value) for value in required_runs],
         "canonical_runs_used": [int(value) for value in canonical_runs_used],
-        "n_protocol_b_rows": int(len(protocol_b_df)),
         "n_protocol_c_rows": int(len(protocol_c_df)),
         "n_total_rows": int(len(combined_df)),
     }
@@ -1106,7 +846,6 @@ def main() -> None:
     print(f"Subjects: {len(subjects)}")
     print(f"Layers: {len(layers)}")
     print(f"Alpha: {float(args.alpha)}")
-    print(f"Protocol B rows: {len(protocol_b_df)}")
     print(f"Protocol C rows: {len(protocol_c_df)}")
     print(f"Output directory: {output_dir}")
     print("=" * 72)

hf_jobs.py

@@ -297,7 +297,7 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--model-profile", default="current")
     parser.add_argument("--model-slug", default="auto")
     parser.add_argument("--alpha", type=float, default=300.0)
-    parser.add_argument("--protocols", default="B,C")
+    parser.add_argument("--protocols", default="C")
     parser.add_argument("--metric", default="mean_corr")
     parser.add_argument("--allowed-runs", default="1,2,3,4")
     parser.add_argument("--exclude-subjects", default="sub-03,sub-18")