update 3-19

classes/v2/backbones.py

@@ -15,7 +15,7 @@ class BackboneSpec:
     strip: Callable[[nn.Module], tuple]   # fn(model)->(out_dim, model_no_head)
     blocks: Callable[[nn.Module], List[nn.Module]]  # fn(model)->ordered blocks for freezing
 
-REFUGELIKE_BACKBONE_PATH = Path("models/refuge/classifier/refugelike_backbone.pt")
+REFUGELIKE_BACKBONE_PATH = Path("models/v2/refuge/refugelike_backbone.pt")
 REFUGE_DENSENET_PATH = Path("models/refuge/classifier/refuge_densenet_backbone.pt")
 REFUGE_EFFICIENT_B0_PATH = Path("models/refuge/classifier/refuge_efficient_b0_backbone.pt")
 REFUGE_EFFICIENT_B7_PATH = Path("models/refuge/classifier/refuge_efficient_b7_backbone.pt")

classes/v2/croppers.py

@@ -82,7 +82,9 @@ class UNetImageCropper:
 
     def _infer_masks(self, image: Image.Image) -> Optional[Tuple[np.ndarray, np.ndarray]]:
         resized = self.segmenter.preprocess_image(image)
-        tensor = self.to_tensor(resized).unsqueeze(0).to(self.segmenter.device)
+        tensor = self.segmenter._normalize_tensor(
+            self.to_tensor(resized).to(self.segmenter.device)
+        ).unsqueeze(0)
 
         with torch.no_grad():
             logits = self.segmenter.model(tensor)

classes/v2/dataset.py

@@ -16,6 +16,7 @@ class ClinicalDataset(Dataset):
         image_preprocessor=None,
         geometry_provider=None,
         geometry_dim: int = 0,
+        image_cache: "dict | None" = None,
     ):
         self.clinical = clinical_data
         self.transform_image = img_transform
@@ -23,6 +24,7 @@ class ClinicalDataset(Dataset):
         self.image_preprocessor = image_preprocessor
         self.geometry_provider = geometry_provider
         self.geometry_dim = geometry_dim if geometry_provider is not None else 0
+        self.image_cache = image_cache
 
     def __len__(self):
         return len(self.clinical.df)
@@ -31,7 +33,13 @@ class ClinicalDataset(Dataset):
         row = self.clinical.df.iloc[idx]
         # load & transform image
         img_path = self.clinical.get_image_path(row)
-        orig_img = Image.open(img_path).convert("RGB")
+        cache_key = str(img_path)
+        if self.image_cache is not None and cache_key in self.image_cache:
+            orig_img = Image.fromarray(self.image_cache[cache_key])
+        else:
+            orig_img = Image.open(img_path).convert("RGB")
+            if self.image_cache is not None:
+                self.image_cache[cache_key] = np.asarray(orig_img, dtype=np.uint8)
         img = orig_img
         if self.image_preprocessor is not None:
             img = self.image_preprocessor(img, img_path)

classes/v2/metrics.py

@@ -12,6 +12,7 @@ from sklearn.metrics import (
     matthews_corrcoef,
     recall_score,
     roc_auc_score,
+    roc_curve,
 )
 
 
@@ -142,26 +143,37 @@ def compute_extended_metrics(
 # ---------------------------------------------------------------------------
 
 def tune_binary_threshold(y_true: np.ndarray, p1: np.ndarray) -> float:
-    if y_true.size == 0:
+    """Pick threshold via Youden's J (sensitivity + specificity − 1).
+
+    This is class-distribution independent, unlike maximising raw accuracy,
+    which is biased toward the majority class on imbalanced validation sets.
+    Falls back to 0.5 if both classes are not present.
+    """
+    if y_true.size == 0 or len(np.unique(y_true)) < 2:
         return 0.5
-    grid = np.linspace(0.0, 1.0, 1001)
-    best_t, best_acc = 0.5, -1.0
-    for t in grid:
-        pred = (p1 >= t).astype(int)
-        acc = float((pred == y_true).mean())
-        if acc > best_acc or (acc == best_acc and abs(t - 0.5) < abs(best_t - 0.5)):
-            best_acc, best_t = acc, float(t)
-    return best_t
+    fpr, tpr, thresholds = roc_curve(y_true, p1)
+    j = tpr + (1.0 - fpr) - 1.0
+    return float(thresholds[np.argmax(j)])
 
 
 def multiclass_acc_with_bias(y_true: np.ndarray, probs: np.ndarray, bias: np.ndarray) -> float:
+    """Balanced accuracy (mean per-class recall) after applying log-space bias."""
     if y_true.size == 0:
         return float("nan")
     logits = np.log(np.clip(probs, 1e-8, 1.0)) + bias.reshape(1, -1)
-    return float((np.argmax(logits, axis=1) == y_true).mean())
+    preds = np.argmax(logits, axis=1)
+    classes = np.unique(y_true)
+    per_class = [(preds[y_true == c] == c).mean() for c in classes]
+    return float(np.mean(per_class))
 
 
 def tune_multiclass_bias(y_true: np.ndarray, probs: np.ndarray, *, iters: int = 2) -> np.ndarray:
+    """Grid-search per-class log-space bias to maximise balanced accuracy.
+
+    Balanced accuracy (mean per-class recall) is class-distribution independent,
+    unlike raw accuracy which is biased toward the majority class on imbalanced
+    validation sets.
+    """
     if y_true.size == 0 or probs.size == 0:
         return np.zeros((0,), dtype=float)
     c = probs.shape[1]

classes/v2/models.py

@@ -283,6 +283,7 @@ def train_single_epoch(
     *,
     phase: str,
     bcd_prob: float = 0.5,
+    tower_loss_mode: str = "bcd",
 ) -> tuple[float, float]:
     model.train()
     _set_single_phase(model, phase)
@@ -337,6 +338,11 @@ def train_single_epoch(
             elif bridge_mode == "image_only":
                 logits = model.bridge.classifier_img(img_feats)
                 loss = F.cross_entropy(logits, y)
+            elif tower_loss_mode == "all":
+                loss_i = F.cross_entropy(model.bridge.classifier_img(img_feats), y)
+                loss_m = F.cross_entropy(model.bridge.classifier_md(md_feats), y)
+                logits, _, _ = model.bridge(img_feats, md_feats)
+                loss = F.cross_entropy(logits, y) + loss_i + loss_m
             elif random() < bcd_prob:
                 if random() < 0.5:
                     logits = model.bridge.classifier_img(img_feats)
@@ -368,6 +374,7 @@ def train_bilateral_epoch(
     *,
     phase: str,
     bcd_prob: float = 0.5,
+    tower_loss_mode: str = "bcd",
 ) -> tuple[float, float]:
     model.train()
     _set_bilateral_phase(model, phase)
@@ -394,7 +401,12 @@ def train_bilateral_epoch(
             logits, _, _ = model.bridge(joint_img, joint_md)
             loss = F.cross_entropy(logits, y)
         else:
-            if random() < bcd_prob:
+            if tower_loss_mode == "all":
+                loss_i = F.cross_entropy(model.aux_img(joint_img), y)
+                loss_m = F.cross_entropy(model.aux_md(joint_md), y)
+                logits, _, _ = model.bridge(joint_img, joint_md)
+                loss = F.cross_entropy(logits, y) + loss_i + loss_m
+            elif random() < bcd_prob:
                 if random() < 0.5:
                     logits = model.aux_img(joint_img)
                 else:

classes/v2/papila_builders.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Dict, List
+from typing import Callable, Dict, List, Optional
 
 import numpy as np
 import pandas as pd
@@ -33,21 +33,80 @@ def _nearest_pachy_key(x: float) -> int:
     return int(_PACHY_KEYS[idx])
 
 
-# Ratio derived from patients with both Pneumatic and Perkins readings (n=41, OD+OS combined).
-# Pneumatic / Perkins mean ratio = 1.158; applied to Perkins-only rows to put them on the
-# Pneumatic scale before IOP_corr is computed.
-_PERKINS_TO_PNEUMATIC_RATIO: float = 1.158
+def _fit_perkins_converter(
+    frames: List[pd.DataFrame], method: str
+) -> Callable[[float, Optional[float]], float]:
+    """
+    Fit a Perkins→Pneumatic converter from pooled paired observations across all frames.
+    Returns a callable: converter(perkins_value, pachymetry_value) -> float.
+    Supported methods: "ratio", "ols", "lad", "multi".
+    """
+    combined = pd.concat(frames, ignore_index=True)
+    paired = combined.dropna(subset=["Pneumatic", "Perkins"])
+    pneumatic = paired["Pneumatic"].values.astype(float)
+    perkins   = paired["Perkins"].values.astype(float)
+
+    if len(paired) == 0:
+        raise ValueError("No paired Pneumatic+Perkins observations found; cannot fit converter.")
+
+    if method == "ratio":
+        ratio = float((pneumatic / perkins).mean())
+        def converter_ratio(p: float, pachy: Optional[float] = None) -> float:
+            return p * ratio
+        return converter_ratio
+
+    elif method == "ols":
+        from scipy import stats as _stats
+        slope, intercept, *_ = _stats.linregress(perkins, pneumatic)
+        slope, intercept = float(slope), float(intercept)
+        def converter_ols(p: float, pachy: Optional[float] = None) -> float:
+            return p * slope + intercept
+        return converter_ols
+
+    elif method == "lad":
+        from scipy import stats as _stats
+        from scipy.optimize import minimize as _minimize
+        slope0, intercept0, *_ = _stats.linregress(perkins, pneumatic)
+        def _lad_loss(params):
+            a, b = params
+            return np.abs(pneumatic - (a * perkins + b)).mean()
+        res = _minimize(_lad_loss, x0=[slope0, intercept0], method="Nelder-Mead")
+        slope, intercept = float(res.x[0]), float(res.x[1])
+        def converter_lad(p: float, pachy: Optional[float] = None) -> float:
+            return p * slope + intercept
+        return converter_lad
+
+    elif method == "multi":
+        from numpy.linalg import lstsq as _lstsq
+        paired_multi = combined.dropna(subset=["Pneumatic", "Perkins", "Pachymetry"])
+        if len(paired_multi) == 0:
+            raise ValueError("No paired Pneumatic+Perkins+Pachymetry rows; cannot fit multi method.")
+        pneu  = paired_multi["Pneumatic"].values.astype(float)
+        perk  = paired_multi["Perkins"].values.astype(float)
+        pachy_vals = paired_multi["Pachymetry"].values.astype(float)
+        X = np.column_stack([perk, pachy_vals, np.ones(len(perk))])
+        coeffs, *_ = _lstsq(X, pneu, rcond=None)
+        slope, pachy_coef, intercept = float(coeffs[0]), float(coeffs[1]), float(coeffs[2])
+        pachy_fallback = float(pachy_vals.mean())
+        def converter_multi(p: float, pachy: Optional[float] = None) -> float:
+            pv = pachy if (pachy is not None and not np.isnan(pachy)) else pachy_fallback
+            return p * slope + pachy_coef * pv + intercept
+        return converter_multi
+
+    else:
+        raise ValueError(f"Unknown iop_corr_method: {method!r}. Choose ratio/ols/lad/multi.")
 
 
-def _pick_iop(row: pd.Series) -> float:
-    """Prefer Pneumatic; scale Perkins to Pneumatic scale if Pneumatic is absent."""
+def _pick_iop(row: pd.Series, converter: Callable) -> float:
+    """Prefer Pneumatic; convert Perkins to Pneumatic scale if Pneumatic is absent."""
     pneumatic = row.get("Pneumatic", np.nan)
     if not pd.isna(pneumatic):
         return float(pneumatic)
     perkins = row.get("Perkins", np.nan)
-    if not pd.isna(perkins):
-        return float(perkins) * _PERKINS_TO_PNEUMATIC_RATIO
-    return np.nan
+    if pd.isna(perkins):
+        return np.nan
+    pachy = row.get("Pachymetry", np.nan)
+    return converter(float(perkins), None if pd.isna(pachy) else float(pachy))
 
 
 def _correct_iop(raw_iop: float, pachy: float) -> float:
@@ -60,14 +119,20 @@ def _correct_iop(raw_iop: float, pachy: float) -> float:
     return float(raw_iop) + float(_PACHY_TABLE[key])
 
 
-def _apply_iop_and_drop_md(df: pd.DataFrame) -> pd.DataFrame:
+def _apply_iop_and_drop_md(
+    df: pd.DataFrame,
+    converter: Callable,
+    drop_raw: bool = False,
+) -> pd.DataFrame:
     """Add IOP_raw/IOP_corr and drop source IOP columns + VF_MD if present (in-place safe)."""
-    df["IOP_raw"] = df.apply(_pick_iop, axis=1)
+    df["IOP_raw"] = df.apply(lambda row: _pick_iop(row, converter), axis=1)
     pachy = df.get("Pachymetry", pd.Series(np.nan, index=df.index))
     df["IOP_corr"] = [
         _correct_iop(r, p) for r, p in zip(df["IOP_raw"].values, pachy.values)
     ]
     drop_cols = [c for c in ("Pneumatic", "Perkins", "VF_MD") if c in df.columns]
+    if drop_raw:
+        drop_cols.append("IOP_raw")
     if drop_cols:
         df.drop(columns=drop_cols, inplace=True)
     return df
@@ -117,6 +182,9 @@ def build_papila_data(
     cat_cols: List[str],
     n_splits: int = 5,
     random_seed: int = 42,
+    iop_corr_method: str = "ratio",
+    iop_drop_raw: bool = False,
+    exclude_cols: Optional[List[str]] = None,
 ) -> DataBundle:
     """
     Build a DataBundle for PAPILA with dataset-specific preprocessing:
@@ -126,12 +194,17 @@ def build_papila_data(
       - compute IOP_raw / IOP_corr, drop VF_MD
       - build feature typing & folds
     """
+    _exclude = list(exclude_cols) if exclude_cols else []
+
+    # Remove excluded cols from cat_cols too so the bundle doesn't try to encode them
+    effective_cat_cols = [c for c in cat_cols if c not in _exclude]
+
     bundle = DataBundle(
         image_dir=image_dir,
         clinical_dir=clinical_dir,
         label_col=label_col,
         patient_col="Patient ID",
-        cat_cols=cat_cols,
+        cat_cols=effective_cat_cols,
         n_splits=n_splits,
         random_seed=random_seed,
         filename_template="RET{pid:03d}{eye}.jpg",
@@ -148,14 +221,17 @@ def build_papila_data(
         frame["Patient ID"] = frame["Patient ID"].astype(str).str.extract(r"(\d+)")[0].astype(int)
         _canonicalize_eye_column(frame)
 
-    bundle.add_df(od, id_column="ID")
-    bundle.add_df(os, id_column="ID")
+    bundle.add_df(od, id_column="ID", exclude_cols=_exclude or None)
+    bundle.add_df(os, id_column="ID", exclude_cols=_exclude or None)
 
+    converter = _fit_perkins_converter(bundle.frames, method=iop_corr_method)
     for i in range(len(bundle.frames)):
-        bundle.frames[i] = _apply_iop_and_drop_md(bundle.frames[i])
+        bundle.frames[i] = _apply_iop_and_drop_md(
+            bundle.frames[i], converter=converter, drop_raw=iop_drop_raw
+        )
 
-    bundle._refresh_master_df()
-    bundle._infer_or_validate_feature_types()
+    bundle._refresh_master_df(exclude_cols=_exclude or None)
+    bundle._infer_or_validate_feature_types(exclude_cols=_exclude or None)
     bundle._compute_numeric_stats()
     bundle._build_cat_maps()
     bundle._compute_feature_dim()

classes/v2/v2_hypertower.py

@@ -177,6 +177,8 @@ class V2HyperTower:
         ap.add_argument("--clinical-dir", default="Papila/ClinicalData")
         ap.add_argument("--label-col",    default="Diagnosis")
         ap.add_argument("--cat-cols",     nargs="*", default=["Gender", "Phakic/Pseudophakic"])
+        ap.add_argument("--exclude-cols", nargs="*", default=[],
+                        help="Feature columns to exclude entirely from the clinical feature matrix.")
         ap.add_argument("--eval-mode",    choices=["binary", "multiclass"], default="multiclass")
         ap.add_argument(
             "--tower-mode", choices=["single", "ensemble", "bilateral", "classic"],
@@ -217,6 +219,10 @@ class V2HyperTower:
         ap.add_argument("--lr",           type=float, default=1e-4)
         ap.add_argument("--bcd-prob",     type=float, default=0.5,
                         help="Tower-only step probability during main phase (per model).")
+        ap.add_argument("--tower-loss-mode", choices=["bcd", "all"], default="bcd",
+                        help="Main-phase tower loss strategy: "
+                             "'bcd' (Block Coordinate Descent — randomly train one tower or fused per step) "
+                             "or 'all' (sum all three losses — fused + img + md — every step).")
         ap.add_argument("--backbone",     default="refugelike")
         ap.add_argument("--freeze-ratio", type=float, default=0.0)
         ap.add_argument("--augment",      action="store_true")
@@ -299,6 +305,21 @@ class V2HyperTower:
         ap.add_argument("--log-every",    type=int, default=1)
         ap.add_argument("--save-checkpoints", action=argparse.BooleanOptionalAction, default=True,
                         help="Save best_single.pt / best_holdout_single.pt per fold (use --no-save-checkpoints to disable)")
+        ap.add_argument("--use-last-epoch", action="store_true", default=False,
+                        help="Score using the final epoch's model state rather than the best-AUC checkpoint.")
+        # IOP feature options
+        ap.add_argument(
+            "--iop-corr-method",
+            choices=["ratio", "ols", "lad", "multi"],
+            default="ratio",
+            help="Perkins→Pneumatic conversion method: ratio (default), ols, lad, or multi (+CCT).",
+        )
+        ap.add_argument(
+            "--iop-drop-raw",
+            action="store_true",
+            default=False,
+            help="Exclude IOP_raw from the feature matrix (keep only IOP_corr).",
+        )
         ap.add_argument(
             "--fused-head", action="store_true",
             help="(ensemble mode only) After base SingleEyeHT training, freeze it and train a "
@@ -329,6 +350,9 @@ class V2HyperTower:
             cat_cols=list(args.cat_cols),
             n_splits=args.n_splits,
             random_seed=args.fold_seed,
+            iop_corr_method=getattr(args, "iop_corr_method", "ratio"),
+            iop_drop_raw=getattr(args, "iop_drop_raw", False),
+            exclude_cols=list(getattr(args, "exclude_cols", []) or []),
         )
         print(f"Loaded: {len(self.data.df)} rows  feature_dim={self.data.feature_dim}", flush=True)
         self.image_preprocessor = build_image_preprocessor_from_args(args)
@@ -488,6 +512,8 @@ class V2HyperTower:
                 np.save(fold_dir / "probs_img.npy", artifacts.probs_ensemble_img)
             if artifacts.probs_ensemble_md is not None:
                 np.save(fold_dir / "probs_md.npy", artifacts.probs_ensemble_md)
+            if artifacts.y_true_classic is not None:
+                np.save(fold_dir / "y_true.npy", artifacts.y_true_classic)
             if artifacts.probs_classic is not None:
                 np.save(fold_dir / "probs_classic.npy", artifacts.probs_classic)
             if artifacts.probs_classic_img is not None:
@@ -1001,6 +1027,7 @@ class V2HyperTower:
                 sl_loss, sl_acc = train_single_epoch(
                     single, _active_loader, opt_single, device,
                     phase=phase_single, bcd_prob=float(args.bcd_prob),
+                    tower_loss_mode=args.tower_loss_mode,
                 )
             else:
                 sl_loss, sl_acc = nan, nan
@@ -1009,6 +1036,7 @@ class V2HyperTower:
                 bl_loss, bl_acc = train_bilateral_epoch(
                     bilateral, train_bilat_loader, opt_bilateral, device,
                     phase=phase_bilat, bcd_prob=float(args.bcd_prob),
+                    tower_loss_mode=args.tower_loss_mode,
                 )
             else:
                 bl_loss, bl_acc = nan, nan
@@ -1414,6 +1442,12 @@ class V2HyperTower:
 
         fold_logger.close()
 
+        # Override: use final epoch state instead of best-AUC checkpoint
+        if getattr(args, "use_last_epoch", False):
+            best_single_state = copy.deepcopy(single.state_dict())
+            if run_bilat:
+                best_bilat_state = copy.deepcopy(bilat.state_dict())
+
         if args.save_checkpoints:
             if best_single_state is not None:
                 torch.save(best_single_state, fold_dir / "best_single.pt")