File size: 9,034 Bytes
1f2e262 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 | """
Border Ablation Test - Stage 9 diagnostic
==========================================
QUESTION: Does the model's decision depend on the image borders / facial
region, or only on the central brain content?
Grad-CAM (correlational) showed margin-dominant activation for pituitary
in particular. This script provides the CAUSAL test: evaluate the model on
the full validation split with border bands of the image masked out (filled
with black, i.e. as if that band were cropped away) and compare per-class
accuracy against the unmasked baseline.
If border masking collapses pituitary accuracy -> the model really uses
border information (shortcut). If accuracy holds -> the Grad-CAM margin
heat was incidental, not causal.
Usage (run from backend/):
..\\.venv\\Scripts\\python.exe src\\border_ablation.py \
--checkpoint models\\best_epoch019_macro-recall0.9929.pth \
--config configs\\efficientnet_b0.yaml --split val
"""
import argparse
from pathlib import Path
from typing import Dict, List, Tuple
import numpy as np
import pandas as pd
import torch
from models import create_model
from utils import load_config, set_seed
from data.dataset import CLASS_TO_IDX
from data.transforms import get_val_transforms
# ---------------------------------------------------------------------------
# Mask variants: (name, description, band thickness as fraction of side)
# The bottom band is where the facial / peri-orbital tissue lives in coronal
# scout MRIs (the pituitary class presumed shortcut); top/left/right bands
# complete the check.
# ---------------------------------------------------------------------------
MASK_VARIANTS: List[Tuple[str, str]] = [
("none", "Baseline, no masking"),
("bottom", "Bottom 20% rows zeroed (facial band)"),
("top", "Top 20% rows zeroed"),
("top_bottom", "Top and bottom 20% zeroed"),
("all_borders", "All four borders, 10% each, zeroed"),
]
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(
description="Border-ablation shortcut test for the MRI classifier"
)
parser.add_argument("--checkpoint", type=str, required=True)
parser.add_argument("--config", type=str, required=True)
parser.add_argument("--split", type=str, default="val",
choices=["train", "val", "test"],
help="Split to evaluate (default: val — test stays locked)")
parser.add_argument("--batch-size", type=int, default=64)
return parser.parse_args()
def apply_mask(image: np.ndarray, variant: str) -> np.ndarray:
"""Zero the specified border bands of a uint8 (H, W, C) image."""
h, w = image.shape[:2]
masked = image.copy()
if variant == "none":
return masked
elif variant == "bottom":
masked[int(h * 0.8):, :, :] = 0
return masked
elif variant == "top":
masked[: int(h * 0.2)] = 0
return masked
elif variant == "top_bottom":
masked[: int(h * 0.2)] = 0
masked[int(h * 0.8):, :, :] = 0
return masked
elif variant == "all_borders":
masked[: int(h * 0.1)] = 0
masked[int(h * 0.9):] = 0
masked[:, : int(w * 0.1)] = 0
masked[:, int(w * 0.9):] = 0
return masked
raise ValueError(f"Unknown mask variant: {variant}")
def evaluate_variant(
variant: str,
model: torch.nn.Module,
df: pd.DataFrame,
processed_dir: Path,
transform,
device: str,
batch_size: int,
channels_last: bool,
) -> Tuple[Dict[str, float], np.ndarray]:
"""Evaluate masked accuracy per class for one mask variant."""
n_classes = max(CLASS_TO_IDX.values()) + 1
confusion = np.zeros((n_classes, n_classes), dtype=np.int64)
model.eval()
batch_images: List[torch.Tensor] = []
batch_labels: List[int] = []
filepaths = df["filepath"].tolist()
labels = df["class"].tolist()
with torch.no_grad():
def flush():
if not batch_images:
return
batch = torch.stack(batch_images).to(device)
if channels_last:
batch = batch.to(memory_format=torch.channels_last)
logits = model(batch)
preds = logits.argmax(dim=1).cpu().numpy()
for label, pred in zip(batch_labels, preds):
confusion[label, pred] += 1
batch_images.clear()
batch_labels.clear()
for filepath, class_name in zip(filepaths, labels):
image = np.load(processed_dir / filepath)
image = apply_mask(image, variant)
tensor = transform(image)
batch_images.append(tensor)
batch_labels.append(CLASS_TO_IDX[class_name])
if len(batch_images) >= batch_size:
flush()
flush()
per_class_acc = {}
for idx, class_name in enumerate(
[k for k, v in CLASS_TO_IDX.items() if v < n_classes]
):
total = confusion[idx].sum()
correct = confusion[idx, idx]
per_class_acc[class_name] = correct / total if total else float("nan")
return per_class_acc, confusion
def main() -> None:
print("=" * 70)
print("Border Ablation Test (Stage 9 shortcut diagnostic)")
print("=" * 70)
assert torch.cuda.is_available(), "CUDA GPU required. Aborting."
device = "cuda"
args = parse_args()
config = load_config(args.config)
set_seed(config.get("seed", 42))
processed_dir = Path.cwd() / config["data"]["processed_dir"]
manifest = pd.read_csv(processed_dir / "manifest.csv")
df = manifest[manifest["split"] == args.split].reset_index(drop=True)
print(f"Split: {args.split} | Images: {len(df)}")
print(df["class"].value_counts().to_string())
# Load model from checkpoint (weights_only=False: local trusted file
# containing numpy metrics).
checkpoint = torch.load(
args.checkpoint, map_location=device, weights_only=False
)
model = create_model(checkpoint.get("config", config))
model.load_state_dict(checkpoint["model_state_dict"])
model.to(device)
if config["training"].get("channels_last", False):
model = model.to(memory_format=torch.channels_last)
transform = get_val_transforms(config)
use_amp = config["training"]["use_amp"]
amp_dtype = (
torch.float16
if config["training"]["amp_dtype"] == "float16"
else torch.bfloat16
)
autocast = torch.amp.autocast("cuda", enabled=use_amp, dtype=amp_dtype)
results: Dict[str, Dict[str, float]] = {}
confusions: Dict[str, np.ndarray] = {}
for name, description in MASK_VARIANTS:
print(f"Variant: {name} — {description}")
with autocast:
accs, conf = evaluate_variant(
name, model, df, processed_dir, transform,
device, args.batch_size,
config["training"].get("channels_last", False),
)
confusions[name] = conf
results[name] = accs
for cls, acc in accs.items():
print(f" {cls:<12}: {acc * 100:6.2f}%")
# ------------------------------------------------------------------
# Summary table with deltas vs. baseline
# ------------------------------------------------------------------
print()
print("=" * 70)
print("SUMMARY (accuracy %, delta vs baseline)")
print("=" * 70)
classes = config["data"]["classes"]
header = " {:<12}".format("variant") + "".join(
f"{c:>14}" for c in classes
)
print(header)
baseline = results["none"]
for name, description in MASK_VARIANTS:
cells = []
for c in classes:
acc = results[name][c] * 100
delta = results[name][c] - baseline[c]
cells.append(f"{acc:6.2f} ({delta:+.2%})")
print(" {:<12}".format(name) + "".join(f"{c:>14}" for c in cells))
# Confusion matrices show WHERE masked predictions migrate to
print()
print("=" * 70)
print("CONFUSION MATRICES (rows = true, cols = predicted)")
print("=" * 70)
for name, _ in MASK_VARIANTS:
print(f"\n[{name}]")
print(" " + "".join(f"{c[:8]:>10}" for c in classes))
for idx, c in enumerate(classes):
row = confusions[name][idx]
print(" {:<9}".format(c[:9]) + "".join(f"{v:>10}" for v in row))
# Save report
reports_dir = Path.cwd() / "reports"
reports_dir.mkdir(exist_ok=True)
out_path = reports_dir / "border_ablation.txt"
with open(out_path, "w", encoding="utf-8") as f:
f.write("Border Ablation Test Report\n")
f.write("=" * 70 + "\n")
f.write(f"Checkpoint: {args.checkpoint}\n")
f.write(f"Split: {args.split} | Images: {len(df)}\n\n")
for name, description in MASK_VARIANTS:
f.write(f"[{name}] {description}\n")
for c in classes:
f.write(f" {c:<12}: {results[name][c] * 100:6.2f}%\n")
f.write("\n")
print(f"Report saved: {out_path}")
if __name__ == "__main__":
main()
|