Update experiments code - 2025-09-25T15:16:05.109591

light_subspace_removal/sbatch/train_vpct_spatial_cv.sbatch

@@ -0,0 +1,37 @@
+#!/bin/bash
+#SBATCH --job-name=chm_cv_vpct_spatial
+#SBATCH --partition=general
+#SBATCH --gres=gpu:A6000:1
+#SBATCH --cpus-per-task=8
+#SBATCH --mem=32G
+#SBATCH --time=24:00:00
+#SBATCH --array=0-7%8
+#SBATCH --output=/home/anonymous/logs/light_subspace_removal/%x_%A_%a.out
+#SBATCH --error=/home/anonymous/logs/light_subspace_removal/%x_%A_%a.err
+
+cd /home/anonymous/imageomics-2025
+
+# Env
+source ~/.bashrc
+mamba activate light-stable
+
+export PYTHONUNBUFFERED=1
+
+# Grid parameters (spatial-only CV with variance targets)
+TOTAL_CONFIGS=110     # 11 var levels × 5 folds × 2 model_configs
+TOTAL_JOBS=8          # matches --array 0-7
+OUT_SIZE=224          # supervision size (must be integer multiple of token grid)
+
+echo "Node: $(hostname)"
+echo "CUDA_VISIBLE_DEVICES=${CUDA_VISIBLE_DEVICES:-unset}"
+echo "Job ${SLURM_ARRAY_TASK_ID}/${TOTAL_JOBS} over ${TOTAL_CONFIGS} configs"
+
+# Run
+python -u light_subspace_removal/scripts/train_vpct_spatial_cv.py \
+  --job_id ${SLURM_ARRAY_TASK_ID} \
+  --total_jobs ${TOTAL_JOBS} \
+  --total_configs ${TOTAL_CONFIGS} \
+  --outdir results/light_subspace_removal \
+  --epochs 50 \
+  --batch_size 32 \
+  --out_size ${OUT_SIZE}

light_subspace_removal/scripts/aggregate_cv_results.py

@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+"""
+Aggregate spatial 5-fold CV results into side-by-side model comparison plots.
+
+Directory structure expected:
+results/{model_config}/simple_decoder/cv_s{fold}_v{vvv}.json
+where vvv is zero-padded integer percent (e.g., 000, 005, 010, 025, 050, 100)
+
+Each JSON should include:
+- val_rmse_history (list[float])
+- var_pct_target (float)
+- k_chosen (int)
+- cum_evr_at_k (float)
+"""
+
+import argparse, json, os, glob
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy import stats
+from pathlib import Path
+
+# --------------------------
+# IO
+# --------------------------
+def _safe_load_json(path):
+    try:
+        with open(path, "r") as f:
+            return json.load(f)
+    except Exception as e:
+        print(f"Error loading {path}: {e}")
+        return None
+
+def load_results_for_model(base_dir, model_config):
+    """
+    Returns: dict[var_pct] -> list[result_dict]
+    """
+    model_dir = os.path.join(base_dir, model_config, "simple_decoder")
+    if not os.path.exists(model_dir):
+        print(f"Directory not found: {model_dir}")
+        return {}
+
+    # New naming: cv_s{fold}_v{vvv}.json
+    paths = sorted(glob.glob(os.path.join(model_dir, "cv_s*_v*.json")))
+    if not paths:
+        print(f"No result files found in {model_dir}")
+        return {}
+
+    print(f"Found {len(paths)} result files for {model_config}/simple_decoder")
+
+    by_var = {}
+    for p in paths:
+        r = _safe_load_json(p)
+        if not r: 
+            continue
+        if "val_rmse_history" not in r:
+            print(f"Warning: {p} missing val_rmse_history, skipping")
+            continue
+
+        # Prefer explicit field; fallback to filename parse if needed
+        if "var_pct_target" in r:
+            vp = float(r["var_pct_target"])
+        else:
+            # Fallback: parse ..._v{vvv}.json
+            stem = Path(p).stem
+            try:
+                vtag = stem.split("_v")[-1]
+                vp = float(int(vtag))
+            except Exception:
+                print(f"Warning: could not infer var_pct from {p}; skipping")
+                continue
+
+        by_var.setdefault(vp, []).append(r)
+
+    return by_var
+
+# --------------------------
+# CV metrics
+# --------------------------
+def compute_cv_metrics(fold_results):
+    """
+    Given a list of result dicts (one per fold), compute:
+    mean RMSE at the epoch minimizing the mean RMSE across folds,
+    plus 95% t-CI across folds at that epoch.
+    """
+    if not fold_results:
+        return None, None, None
+
+    histories = []
+    for r in fold_results:
+        h = r.get("val_rmse_history", [])
+        if h:
+            histories.append(h)
+
+    if not histories:
+        return None, None, None
+
+    min_len = min(len(h) for h in histories)
+    H = np.array([h[:min_len] for h in histories])  # [n_folds, n_epochs]
+    n_folds = H.shape[0]
+
+    mean_per_epoch = H.mean(axis=0)
+    best_epoch = int(np.argmin(mean_per_epoch))
+
+    fold_rmses = H[:, best_epoch]
+    mean_rmse = float(fold_rmses.mean())
+    std_rmse  = float(fold_rmses.std(ddof=1)) if n_folds > 1 else 0.0
+
+    if n_folds > 1:
+        t_crit = stats.t.ppf(0.975, df=n_folds - 1)
+        margin = float(t_crit * std_rmse / np.sqrt(n_folds))
+        ci_lower, ci_upper = mean_rmse - margin, mean_rmse + margin
+    else:
+        ci_lower = ci_upper = mean_rmse
+
+    return mean_rmse, ci_lower, ci_upper
+
+# --------------------------
+# Plot
+# --------------------------
+def create_comparison_plot(dinov2_results, dinov3_results, output_path):
+    """
+    Combined comparison of DINOv2 vs DINOv3 across % variance removed.
+    X-axis: percent variance removed (0..100).
+    """
+    v2_keys = set(dinov2_results.keys()) if dinov2_results else set()
+    v3_keys = set(dinov3_results.keys()) if dinov3_results else set()
+    all_vps = sorted(v2_keys | v3_keys)
+
+    if not all_vps:
+        print("No variance-percent keys found; nothing to plot.")
+        return
+
+    vps = np.array(all_vps, dtype=float)
+
+    def collect(model_dict):
+        means, lows, ups = [], [], []
+        for vp in all_vps:
+            fr = model_dict.get(vp, [])
+            m, lo, up = compute_cv_metrics(fr)
+            means.append(np.nan if m is None else m)
+            lows.append(np.nan if lo is None else lo)
+            ups.append(np.nan if up is None else up)
+        return np.array(means), np.array(lows), np.array(ups)
+
+    v2_mean, v2_low, v2_up = collect(dinov2_results)
+    v3_mean, v3_low, v3_up = collect(dinov3_results)
+
+    fig, ax = plt.subplots(1, 1, figsize=(10, 6))
+
+    # DINOv2 - Python blue (C0)
+    mask2 = ~np.isnan(v2_mean)
+    if np.any(mask2):
+        ax.plot(vps[mask2], v2_mean[mask2], color='C0', linewidth=2, marker='o',
+                label='DINOv2-base')
+        ax.fill_between(vps[mask2], v2_low[mask2], v2_up[mask2], color='C0', alpha=0.25)
+
+    # DINOv3 - Python orange (C1)
+    mask3 = ~np.isnan(v3_mean)
+    if np.any(mask3):
+        ax.plot(vps[mask3], v3_mean[mask3], color='C1', linewidth=2, marker='o',
+                label='DINOv3-sat')
+        ax.fill_between(vps[mask3], v3_low[mask3], v3_up[mask3], color='C1', alpha=0.25)
+
+    ax.set_xlabel('Percent of lighting subspace variance removed')
+    ax.set_ylabel('Plant canopy height RMSE (cm)')
+    ax.grid(True, alpha=0.3)
+    ax.set_xlim(-2, 102)
+
+    # Set y-limits based on available data
+    if np.any(mask2) or np.any(mask3):
+        all_lows = []
+        all_ups = []
+        if np.any(mask2):
+            all_lows.extend(v2_low[mask2])
+            all_ups.extend(v2_up[mask2])
+        if np.any(mask3):
+            all_lows.extend(v3_low[mask3])
+            all_ups.extend(v3_up[mask3])
+
+        y_min = np.nanmin(all_lows)
+        y_max = np.nanmax(all_ups)
+        pad = 0.05 * (y_max - y_min) if y_max > y_min else 0.1
+        ax.set_ylim(y_min - pad, y_max + pad)
+
+    # Legend in lower left with Model title
+    legend = ax.legend(title='Model', loc='upper left', framealpha=0.9)
+    legend.get_title().set_fontweight('bold')
+
+    # Main title
+    plt.tight_layout()
+
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    plt.savefig(output_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    print(f"Saved comparison plot: {output_path}")
+
+# --------------------------
+# Main
+# --------------------------
+def main():
+    parser = argparse.ArgumentParser(description="Aggregate spatial CV results into model comparison plots")
+    parser.add_argument("--results_dir", type=str, default="results/light_subspace_removal",
+                        help="Base results directory")
+    parser.add_argument("--output_dir", type=str, default="plots",
+                        help="Output directory for plots")
+    args = parser.parse_args()
+
+    model_configs = ["dinov2_base", "dinov3_sat"]
+
+    # Load results
+    dinov2_results = load_results_for_model(args.results_dir, "dinov2_base")
+    dinov3_results = load_results_for_model(args.results_dir, "dinov3_sat")
+
+    if not dinov2_results and not dinov3_results:
+        print("No results found for either model; nothing to plot.")
+        return
+
+    # Plot
+    out_path = os.path.join(args.output_dir, "cv_comparison_variance_pct.png")
+    create_comparison_plot(dinov2_results, dinov3_results, out_path)
+
+    # Console summary
+    print("\nSummary by % variance removed:")
+    for mc, res in zip(model_configs, [dinov2_results, dinov3_results]):
+        if not res:
+            print(f"  {mc}: No results")
+            continue
+        print(f"  {mc}:")
+        for vp in sorted(res.keys()):
+            m, lo, up = compute_cv_metrics(res[vp])
+            if m is not None:
+                n_folds = len(res[vp])
+                ci = (up - lo) / 2.0 if up is not None and lo is not None else np.nan
+                print(f"    v={int(vp):3d}%: {m:.2f} ± {ci:.2f} cm (n={n_folds})")
+            else:
+                print(f"    v={int(vp):3d}%: No valid results")
+
+if __name__ == "__main__":
+    main()

light_subspace_removal/scripts/train_vpct_spatial_cv.py

@@ -0,0 +1,354 @@
+#!/usr/bin/env python3
+"""
+Patch-agnostic dense CHM regression from pre-encoded DINOv2/DINOv3 patch tokens.
+
+Spatial-only 5-fold CV:
+- Train: ~80% of tiles, all timepoints (t0,t1,t2)
+- Val  : held-out ~20% tiles, all timepoints (t0,t1,t2)
+
+Lighting subspace removal by TARGET VARIANCE EXPLAINED:
+- --var_pct in range(0, 110, 10)
+- Chooses minimal k with cumulative EVR >= var_pct/100 on TRAIN-ONLY residuals
+  (per-patch, per-tile residuals z_{i,p,t} - mean_t z_{i,p,·}, T=3).
+
+Writes:
+  results/{model_config}/simple_decoder/cv_s{fold}_v{vvv}.json
+"""
+
+import argparse, json, os, random, math
+from collections import defaultdict
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch import nn
+from torch.utils.data import Dataset, DataLoader
+from datasets import load_dataset
+from sklearn.model_selection import KFold
+
+# ---------------------------
+# Small helpers
+# ---------------------------
+def _is_pow2(x: int) -> bool:
+    return x > 0 and (x & (x - 1)) == 0
+
+def _next_pow2(x: int) -> int:
+    return 1 << (x - 1).bit_length()
+
+def set_seed(seed=42):
+    random.seed(seed); np.random.seed(seed); torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+# ---------------------------
+# Grid / targets
+# ---------------------------
+def infer_token_grid(X_patch: np.ndarray):
+    assert X_patch.ndim == 3, f"Expected [M,Np,D], got {X_patch.shape}"
+    _, Np, D = X_patch.shape
+    side = int(round(Np ** 0.5))
+    assert side * side == Np, f"Tokens not square: Np={Np}"
+    return side, side, D
+
+def tokens_to_chw(tokens: np.ndarray, H: int, W: int):
+    D = tokens.shape[-1]
+    return tokens.reshape(H, W, D).transpose(2, 0, 1)
+
+def make_target(y, H_out: int, W_out: int):
+    if np.isscalar(y):
+        return torch.full((1, H_out, W_out), float(y), dtype=torch.float32)
+    arr = np.array(y)
+    t = torch.from_numpy(arr).float()
+    if t.ndim == 2:
+        t = t[None, None, ...]
+    else:
+        t = t.view(1, 1, *t.shape[-2:])
+    return F.interpolate(t, size=(H_out, W_out), mode='bilinear', align_corners=False)[0]
+
+# ---------------------------
+# tcSVD with variance target
+# ---------------------------
+@torch.no_grad()
+def svd_rank_for_var_explained(D: torch.Tensor, target_pct: float):
+    target_pct = float(target_pct)
+    if target_pct <= 0: return None, 0, np.array([]), np.array([])
+    U, S, Vh = torch.linalg.svd(D.cpu(), full_matrices=False)  # Vh: [r,d]
+    var = S**2
+    total = var.sum().item()
+    if total <= 0: return None, 0, np.array([]), np.array([])
+    evr = (var / total).cpu().numpy()
+    cum = np.cumsum(evr)
+    k = int(np.searchsorted(cum, target_pct/100.0) + 1)
+    k = max(0, min(k, Vh.shape[0]))
+    if k == 0: return None, 0, evr, cum
+    Vk = Vh[:k].T.contiguous()
+    Q, _ = torch.linalg.qr(Vk)  # [d,k]
+    return Q, k, evr, cum
+
+@torch.no_grad()
+def estimate_Q_train_only_patchwise_vpct(X_patch: np.ndarray, ids: list[str], T=3, var_pct: float = 0.0):
+    """Compute residual matrix D from TRAIN tiles only, across all patches/time,
+       with z_{i,p,t} - mean_t z_{i,p,·}. Then pick k by target EVR."""
+    if var_pct <= 0: return None, 0, np.array([]), np.array([])
+    groups = defaultdict(list)
+    for i, tid in enumerate(ids): groups[tid].append(i)
+    diffs = []
+    for tid, idxs in groups.items():
+        if len(idxs) != T:  # expect all three times in train
+            continue
+        Z = torch.tensor(X_patch[idxs], dtype=torch.float32)  # [T,Np,D]
+        mu = Z.mean(dim=0, keepdim=True)
+        diffs.append(Z - mu)
+    if not diffs: return None, 0, np.array([]), np.array([])
+    D_mat = torch.cat(diffs, dim=0).reshape(-1, X_patch.shape[-1])  # [T*Ntiles*Np, D]
+    return svd_rank_for_var_explained(D_mat, var_pct)
+
+def apply_projection_np(X_patch: np.ndarray, Q: torch.Tensor | None):
+    X = torch.from_numpy(X_patch).float()
+    if (Q is None) or (Q.numel() == 0): return X.numpy().astype(np.float32)
+    P = Q @ Q.T
+    return (X - X @ P).numpy().astype(np.float32)
+
+# ---------------------------
+# Data (HF): load ALL times
+# ---------------------------
+def load_all_times_from_hf(model_config: str, H_out: int, W_out: int):
+    """Return arrays containing ALL timepoints for every tile."""
+    ds_embed = load_dataset("anondatasets/imageomics-2025", model_config, split='train')
+    ds_default = load_dataset("anondatasets/imageomics-2025", "default", split='train')
+    canopy_map = {ex['idx']: ex['canopy_height'] for ex in ds_default}
+
+    X_all, ids_all, Y_all = [], [], []
+    for ex in ds_embed:
+        idx = ex['idx']
+        target = make_target(canopy_map[idx], H_out, W_out).numpy()
+        for key in ('t0', 't1', 't2'):
+            tokens = np.array(ex[f'patch_{key}'], dtype=np.float32)  # [Np,D]
+            X_all.append(tokens); ids_all.append(idx); Y_all.append(target)
+
+    return np.stack(X_all, 0), ids_all, np.stack(Y_all, 0)  # [3*Ntiles, Np/D or 1/H/W]
+
+class DenseSplit(Dataset):
+    def __init__(self, X_patch, Y, H, W):
+        self.Xp = X_patch; self.Y = Y; self.H, self.W = H, W
+    def __len__(self): return len(self.Xp)
+    def __getitem__(self, i):
+        x = tokens_to_chw(self.Xp[i], self.H, self.W)      # [D,H,W]
+        y = torch.from_numpy(self.Y[i]).float()            # [1,H_out,W_out]
+        return torch.from_numpy(x).float(), y
+
+# ---------------------------
+# Decoder
+# ---------------------------
+class UpBlock(nn.Module):
+    def __init__(self, c_in, c_out):
+        super().__init__()
+        self.conv1 = nn.Conv2d(c_in, c_out, 3, padding=1)
+        self.gn1   = nn.GroupNorm(8, c_out)
+        self.conv2 = nn.Conv2d(c_out, c_out, 3, padding=1)
+        self.gn2   = nn.GroupNorm(8, c_out)
+    def forward(self, x):
+        x = F.gelu(self.gn1(self.conv1(x)))
+        x = F.gelu(self.gn2(self.conv2(x)))
+        return x
+
+class GenericDenseDecoder(nn.Module):
+    def __init__(self, c_in: int, H: int, W: int, H_out: int, W_out: int,
+                 base: int = 256, dropout: float = 0.05):
+        super().__init__()
+        assert (H_out % H == 0) and (W_out % W == 0)
+        sx = H_out // H; sy = W_out // W
+        assert sx == sy
+        self.H_out, self.W_out = H_out, W_out
+        self.stem = nn.Sequential(
+            nn.Conv2d(c_in, base, 1),
+            nn.GELU(),
+            nn.Dropout2d(dropout),
+            UpBlock(base, base),
+        )
+        sx_p2 = sx if _is_pow2(sx) else _next_pow2(sx)
+        n_ups = int(math.log2(sx_p2))
+        ups, blks = [], []
+        c = base
+        for _ in range(n_ups):
+            ups.append(nn.ConvTranspose2d(c, c // 2, 2, 2))
+            blks.append(UpBlock(c // 2, c // 2))
+            c //= 2
+        self.ups = nn.ModuleList(ups)
+        self.blks = nn.ModuleList(blks)
+        self.head_mid = nn.Conv2d(c, 1, 1)
+        self.need_final_resize = (sx_p2 != sx)
+
+    def forward(self, x):
+        x = self.stem(x)
+        for up, blk in zip(self.ups, self.blks):
+            x = blk(up(x))
+        x = self.head_mid(x)
+        if self.need_final_resize:
+            x = F.interpolate(x, size=(self.H_out, self.W_out),
+                              mode='bilinear', align_corners=False, antialias=True)
+        return x
+
+# ---------------------------
+# Train / Eval
+# ---------------------------
+def rmse_map(y_true, y_pred):
+    return torch.sqrt(torch.mean((y_true - y_pred)**2))
+
+def train_epoch(model, opt, loader, device):
+    model.train()
+    for xb, yb in loader:
+        xb, yb = xb.to(device), yb.to(device)
+        opt.zero_grad(set_to_none=True)
+        pred = model(xb)
+        loss = F.mse_loss(pred, yb)
+        loss.backward(); opt.step()
+
+@torch.no_grad()
+def eval_epoch(model, loader, device):
+    model.eval()
+    rmses = []
+    for xb, yb in loader:
+        xb, yb = xb.to(device), yb.to(device)
+        pred = model(xb)
+        rmses.append(rmse_map(yb, pred).cpu())
+    return float(torch.stack(rmses).mean())
+
+# ---------------------------
+# Main
+# ---------------------------
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--spatial_fold", type=int, default=None, help="fold index in [0..4] (single-exp mode)")
+    ap.add_argument("--var_pct", type=float, default=None, help="target % variance explained to remove [0..100]")
+    ap.add_argument("--model_config", type=str, default=None, help="dinov2_base or dinov3_sat")
+
+    ap.add_argument("--job_id", type=int, default=None)
+    ap.add_argument("--total_jobs", type=int, default=8)
+    ap.add_argument("--total_configs", type=int, default=110)  # 11 var levels × 5 folds × 2 configs
+
+    ap.add_argument("--outdir", type=str, default="results/light_subspace_removal")
+    ap.add_argument("--seed", type=int, default=42)
+    ap.add_argument("--batch_size", type=int, default=32)
+    ap.add_argument("--epochs", type=int, default=50)
+    ap.add_argument("--base", type=int, default=256)
+    ap.add_argument("--dropout", type=float, default=0.05)
+    ap.add_argument("--out_size", type=int, default=224)
+    args = ap.parse_args()
+
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    set_seed(args.seed)
+
+    if args.job_id is not None:
+        VAR_PCTS = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
+        FOLDS = [0,1,2,3,4]
+        MODEL_CONFIGS = ['dinov2_base', 'dinov3_sat']
+        all_configs = [(vp, f, mc) for mc in MODEL_CONFIGS for f in FOLDS for vp in VAR_PCTS]
+        assert len(all_configs) == args.total_configs, f"Expected {args.total_configs}, got {len(all_configs)}"
+        per_job = args.total_configs // args.total_jobs
+        extra = args.total_configs % args.total_jobs
+        if args.job_id < extra:
+            start = args.job_id * (per_job + 1); end = start + per_job + 1
+        else:
+            start = extra * (per_job + 1) + (args.job_id - extra) * per_job
+            end = start + per_job
+        job_configs = all_configs[start:end]
+        print(f"Job {args.job_id} handling {len(job_configs)} configs")
+    else:
+        if args.spatial_fold is None or args.var_pct is None or args.model_config is None:
+            raise ValueError("Provide --job_id ... or all of: --spatial_fold --var_pct --model_config")
+        job_configs = [(float(args.var_pct), int(args.spatial_fold), args.model_config)]
+
+    for var_pct, spatial_fold, model_config in job_configs:
+        vtag = f"{int(round(var_pct)):03d}"
+        print(f"\n=== v={var_pct}%, spatial_fold={spatial_fold}, model_config={model_config} ===")
+
+        model_outdir = os.path.join(args.outdir, model_config, 'simple_decoder')
+        os.makedirs(model_outdir, exist_ok=True)
+        out_path = os.path.join(model_outdir, f"cv_s{spatial_fold}_v{vtag}.json")
+        if os.path.exists(out_path):
+            print(f"Exists: {out_path} — skipping.")
+            continue
+
+        # Load all times, all tiles
+        X_all, ids_all, Y_all = load_all_times_from_hf(model_config, args.out_size, args.out_size)
+        H, W, D = infer_token_grid(X_all)
+        print(f"Inferred token grid: H={H}, W={W}, D={D}; supervising at {args.out_size}x{args.out_size}")
+
+        # Group by tile id (each tile should have exactly 3 rows: t0,t1,t2)
+        groups = defaultdict(list)
+        for i, tid in enumerate(ids_all):
+            groups[tid].append(i)
+        tiles = sorted(groups.keys())
+
+        # Spatial 5-fold over tiles
+        kf = KFold(n_splits=5, shuffle=True, random_state=args.seed)
+        folds = list(kf.split(tiles))
+        tr_idx, va_idx = folds[spatial_fold]
+        tr_tiles = [tiles[i] for i in tr_idx]
+        va_tiles = [tiles[i] for i in va_idx]
+        tr_rows = [j for t in tr_tiles for j in groups.get(t, [])]
+        va_rows = [j for t in va_tiles for j in groups.get(t, [])]
+
+        # Prepare arrays
+        Xtr, Ytr = X_all[tr_rows], Y_all[tr_rows]
+        Xva, Yva = X_all[va_rows], Y_all[va_rows]
+        id_tr = [ids_all[j] for j in tr_rows]
+
+        # Fit tcSVD on TRAIN-ONLY residuals (T=3)
+        Q, k_chosen, evr, cum = estimate_Q_train_only_patchwise_vpct(Xtr, id_tr, T=3, var_pct=var_pct)
+
+        # Project train/val
+        XtrP = apply_projection_np(Xtr, Q)
+        XvaP = apply_projection_np(Xva, Q)
+
+        # Datasets / loaders
+        train_ds = DenseSplit(XtrP, Ytr, H, W)
+        val_ds   = DenseSplit(XvaP, Yva, H, W)
+        train_loader = DataLoader(train_ds, batch_size=args.batch_size, shuffle=True,  num_workers=0, pin_memory=True)
+        val_loader   = DataLoader(val_ds,   batch_size=args.batch_size, shuffle=False, num_workers=0, pin_memory=True)
+
+        # Model + optimizer
+        model = GenericDenseDecoder(c_in=D, H=H, W=W, H_out=args.out_size, W_out=args.out_size,
+                                    base=args.base, dropout=args.dropout).to(device)
+        opt = torch.optim.AdamW(model.parameters(), lr=1e-3)
+
+        # Train
+        val_rmse_history = []
+        for epoch in range(1, args.epochs+1):
+            train_epoch(model, opt, train_loader, device)
+            rm = eval_epoch(model, val_loader, device)
+            val_rmse_history.append(rm)
+            print(f"[s{spatial_fold}_v{var_pct:.0f}% (k={k_chosen})] epoch {epoch:03d}  VAL RMSE@{args.out_size} = {rm:.3f} cm")
+
+        # Save
+        evr_head = [float(x) for x in evr[:10]] if evr.size else []
+        cum_head = [float(x) for x in cum[:10]] if cum.size else []
+        achieved_cum = float(cum[k_chosen-1]) if (k_chosen > 0 and cum.size >= k_chosen) else 0.0
+
+        out = {
+            "spatial_fold": spatial_fold,
+            "var_pct_target": float(var_pct),
+            "k_chosen": int(k_chosen),
+            "cum_evr_at_k": achieved_cum,
+            "evr_head": evr_head,
+            "cum_evr_head": cum_head,
+            "model_config": model_config,
+            "seed": args.seed,
+            "epochs": args.epochs,
+            "val_rmse_history": [round(x, 6) for x in val_rmse_history],
+            "token_grid": [H, W, D],
+            "out_size": args.out_size,
+            "n_train_rows": len(tr_rows),
+            "n_val_rows": len(va_rows),
+            "train_tiles": tr_tiles,
+            "val_tiles": va_tiles,
+        }
+        with open(out_path, "w") as f:
+            json.dump(out, f, indent=2)
+        print(f"Saved {out_path}")
+
+    print("Done.")
+
+if __name__ == "__main__":
+    main()

light_subspace_removal/scripts/view_subspace_removal.py

@@ -0,0 +1,396 @@
+#!/usr/bin/env python3
+"""
+Visualize a single tile across time with shadow-subspace removal + local PCA.
+
+Layout (3 rows × 4 columns):
+  - Column 1: RGB at t0, t1, t2 (rows: t0→t2)
+  - Column 2: False color composite after 0% variance removal
+  - Column 3: False color composite after 90% variance removal
+  - Column 4: False color composite after 100% variance removal
+
+Shadow/lighting basis (Q) is fit on ALL tiles (no fold-based splitting),
+using variance thresholds of 0%, 90%, and 100%. False color composites map the top 3
+PCA components directly to RGB channels for visualization.
+
+Processes both models (dinov2_base, dinov3_sat) automatically, generating separate outputs.
+
+Embeddings source:
+  load_dataset("mpg-ranch/drone-lsr", {model_config}, split="train")
+
+RGB source:
+  - Tries to read from the "default" HF config using common key patterns
+  - Or pass --rgb_template like "/path/to/rgb/{tile_idx}_{time}.png" with time in {t0,t1,t2}
+
+Example:
+  python view_subspace_removal.py --tile_idx "137_45"
+    # Outputs auto-generated as:
+    # supporting/processed/dinov2_base_subspace_removal.png
+    # supporting/processed/dinov3_sat_subspace_removal.png
+"""
+
+import argparse, os
+from collections import defaultdict
+from pathlib import Path
+
+import numpy as np
+import torch
+import matplotlib.pyplot as plt
+import matplotlib as mpl
+from sklearn.decomposition import PCA
+from datasets import load_dataset
+from PIL import Image
+from scipy.linalg import orthogonal_procrustes
+
+# --- display prefs
+mpl.rcParams["figure.dpi"] = 120
+PRGN = "PRGn"  # Diverging for signed PCA scores (user preference)
+
+def set_seed(seed=42):
+    import random
+    random.seed(seed); np.random.seed(seed)
+    torch.manual_seed(seed); torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+def infer_token_grid(X_patch: np.ndarray):
+    """X_patch: [M, Np, D] -> returns (H, W, D), with Np = H*W a perfect square."""
+    assert X_patch.ndim == 3, f"Expected [M,Np,D], got {X_patch.shape}"
+    _, Np, D = X_patch.shape
+    side = int(round(Np ** 0.5))
+    assert side * side == Np, f"Tokens not square: Np={Np}"
+    return side, side, D
+
+@torch.no_grad()
+def svd_rank_for_var_explained(D: torch.Tensor, target_pct: float):
+    """
+    SVD on residual matrix D [N, d]. Choose minimal k s.t. cumEVR >= target_pct/100.
+    Returns (Q [d,k] or None, k, evr np.array, cum np.array).
+    """
+    target_pct = float(target_pct)
+    if target_pct <= 0:
+        return None, 0, np.array([]), np.array([])
+    U, S, Vh = torch.linalg.svd(D.cpu(), full_matrices=False)  # Vh: [r,d]
+    var = S ** 2
+    total = var.sum().item()
+    if total <= 0:
+        return None, 0, np.array([]), np.array([])
+    evr = (var / total).cpu().numpy()
+    cum = np.cumsum(evr)
+    k = int(np.searchsorted(cum, target_pct / 100.0) + 1)
+    k = max(0, min(k, Vh.shape[0]))
+    if k == 0:
+        return None, 0, evr, cum
+    Vk = Vh[:k].T.contiguous()
+    Q, _ = torch.linalg.qr(Vk)  # [d,k]
+    return Q, k, evr, cum
+
+@torch.no_grad()
+def estimate_Q_train_only_patchwise_vpct(Xtr_patch: np.ndarray, tr_ids: list[str], T=3, var_pct: float = 0.0):
+    """
+    Build residuals per (tile, patch, time): z_{i,p,t} - mean_t z_{i,p,·} for TRAIN tiles (expect T=3).
+    Stack across tiles/patches -> D_mat [T*Ntiles*Np, D], then choose k by target EVR.
+    """
+    if var_pct <= 0:
+        return None, 0, np.array([]), np.array([])
+    groups = defaultdict(list)
+    for i, tid in enumerate(tr_ids):
+        groups[tid].append(i)
+    diffs = []
+    for tid, idxs in groups.items():
+        if len(idxs) != T:
+            continue
+        Z = torch.tensor(Xtr_patch[idxs], dtype=torch.float32)  # [T,Np,D]
+        mu = Z.mean(dim=0, keepdim=True)
+        diffs.append(Z - mu)
+    if not diffs:
+        return None, 0, np.array([]), np.array([])
+    D_mat = torch.cat(diffs, dim=0).reshape(-1, Xtr_patch.shape[-1])  # [T*Ntiles*Np, D]
+    return svd_rank_for_var_explained(D_mat, var_pct)
+
+def apply_projection_np(X_patch: np.ndarray, Q: torch.Tensor | None):
+    """Project out columns of Q from last-dim of X_patch [M,Np,D]."""
+    X = torch.from_numpy(X_patch).float()
+    if (Q is None) or (Q.numel() == 0):
+        return X.numpy().astype(np.float32)
+    P = Q @ Q.T  # [D,D]
+    return (X - X @ P).numpy().astype(np.float32)
+
+def align_components(target_components: np.ndarray, reference_components: np.ndarray) -> np.ndarray:
+    """Align target PCA components to reference using Procrustes rotation.
+
+    Args:
+        target_components: [n_components, n_features] array to be aligned
+        reference_components: [n_components, n_features] reference array
+
+    Returns:
+        aligned_components: [n_components, n_features] rotated target components
+    """
+    # Components are [3, D]. We want to rotate in 3D component space, not D-dimensional feature space
+    # Transpose to [D, 3] so we find 3x3 rotation matrix R
+    target_T = target_components.T      # [D, 3]
+    reference_T = reference_components.T # [D, 3]
+
+    # Find 3x3 rotation R such that target_T @ R ≈ reference_T
+    R, _ = orthogonal_procrustes(target_T, reference_T)
+
+    # Apply rotation and transpose back to [3, D]
+    aligned_components = (target_T @ R).T
+    return aligned_components
+
+def make_false_color_composite(Xt_proj: np.ndarray, H: int, W: int, target_height: int = 1024,
+                             target_width: int = 1024, seed: int = 42,
+                             reference_pca=None) -> tuple[np.ndarray, object]:
+    """Convert projected embeddings [3, Np, D] to false color RGB [3, target_H, target_W, 3].
+    Uses PCA to get top 3 components and maps them to RGB channels.
+
+    Args:
+        Xt_proj: Projected embeddings [3, Np, D]
+        H, W: Patch grid dimensions
+        target_height, target_width: Output image dimensions (default 1024x1024)
+        seed: Random seed for PCA
+        reference_pca: Optional reference PCA object for component alignment
+
+    Returns:
+        (false_colors, pca): False color images [3, target_H, target_W, 3] and fitted PCA object
+    """
+    # Flatten across time and patches for PCA
+    D = Xt_proj.shape[-1]
+    Xtile_cat = Xt_proj.reshape(-1, D)  # [3*Np, D]
+
+    if float(Xtile_cat.var()) == 0.0:
+        # If no variance, return black images
+        return np.zeros((3, target_height, target_width, 3), dtype=np.uint8), None
+
+    # PCA to get top 3 components
+    pca = PCA(n_components=3, svd_solver="auto", random_state=seed)
+    scores = pca.fit_transform(Xtile_cat)  # [3*Np, 3]
+
+    # Align with reference PCA if provided
+    if reference_pca is not None:
+        # Align current PCA components to reference
+        aligned_components = align_components(pca.components_, reference_pca.components_)
+        # Re-orthonormalize to eliminate numerical drift
+        U, _, Vt = np.linalg.svd(aligned_components, full_matrices=False)
+        aligned_components = (U @ Vt)
+        # Recompute scores using aligned components (must center first!)
+        scores = (Xtile_cat - pca.mean_) @ aligned_components.T
+
+    # Split back by time and reshape to spatial grid
+    Np = H * W
+    false_colors = []
+    for t in range(3):
+        pc_scores = scores[t*Np:(t+1)*Np, :].reshape(H, W, 3)  # [H, W, 3]
+
+        # Create RGB image: PC1→Red, PC2→Green, PC3→Blue
+        rgb_img = np.zeros((H, W, 3), dtype=np.uint8)
+
+        # PC1 → Red channel
+        red_channel = pc_scores[:, :, 0]
+        r_low, r_high = np.nanpercentile(red_channel, [1, 99])
+        if r_high > r_low:
+            red_norm = np.clip((red_channel - r_low) / (r_high - r_low), 0, 1)
+        else:
+            red_norm = np.zeros_like(red_channel)
+        rgb_img[:, :, 0] = (red_norm * 255).astype(np.uint8)
+
+        # PC2 → Green channel
+        green_channel = pc_scores[:, :, 1]
+        g_low, g_high = np.nanpercentile(green_channel, [1, 99])
+        if g_high > g_low:
+            green_norm = np.clip((green_channel - g_low) / (g_high - g_low), 0, 1)
+        else:
+            green_norm = np.zeros_like(green_channel)
+        rgb_img[:, :, 1] = (green_norm * 255).astype(np.uint8)
+
+        # PC3 → Blue channel
+        blue_channel = pc_scores[:, :, 2]
+        b_low, b_high = np.nanpercentile(blue_channel, [1, 99])
+        if b_high > b_low:
+            blue_norm = np.clip((blue_channel - b_low) / (b_high - b_low), 0, 1)
+        else:
+            blue_norm = np.zeros_like(blue_channel)
+        rgb_img[:, :, 2] = (blue_norm * 255).astype(np.uint8)
+
+        # Upsample to target resolution using PIL
+        if (H, W) != (target_height, target_width):
+            pil_img = Image.fromarray(rgb_img, mode='RGB')
+            rgb_img_upsampled = np.array(pil_img.resize((target_width, target_height), Image.LANCZOS))
+        else:
+            rgb_img_upsampled = rgb_img
+
+        false_colors.append(rgb_img_upsampled)
+
+    return np.stack(false_colors, 0), pca  # [3, target_H, target_W, 3]
+
+def load_embeddings(model_config: str):
+    """Return (tile_idxs list, dict tile_idx -> {'t0','t1','t2': np.ndarray[Np,D]})"""
+    ds = load_dataset("mpg-ranch/drone-lsr", model_config, split="train")
+    tiles, X_by_tile = [], {}
+    for ex in ds:
+        tid = ex["idx"]
+        X_by_tile[tid] = {
+            "t0": np.array(ex["patch_t0"], dtype=np.float32),
+            "t1": np.array(ex["patch_t1"], dtype=np.float32),
+            "t2": np.array(ex["patch_t2"], dtype=np.float32),
+        }
+        tiles.append(tid)
+    return tiles, X_by_tile
+
+
+def load_rgb_triplet(tile_idx: str, rgb_template: str | None):
+    # Try user template first
+    if rgb_template:
+        frames = []
+        for tk in ("t0","t1","t2"):
+            p = Path(rgb_template.format(tile_idx=tile_idx, time=tk))
+            if not p.exists():
+                raise FileNotFoundError(f"RGB template path not found: {p}")
+            frames.append(Image.open(p).convert("RGB"))
+        return frames
+
+    # Try HF default config with common key patterns
+    ds_def = load_dataset("mpg-ranch/drone-lsr", "default", split="train")
+    by_id = {ex["idx"]: ex for ex in ds_def}
+    if tile_idx not in by_id:
+        raise KeyError(f"Tile {tile_idx} not found in default config")
+    ex = by_id[tile_idx]
+    candidates = [
+        ("rgb_t0","rgb_t1","rgb_t2"),
+        ("image_t0","image_t1","image_t2"),
+        ("t0","t1","t2"),
+    ]
+    for t0k,t1k,t2k in candidates:
+        if t0k in ex and t1k in ex and t2k in ex:
+            def to_img(x):
+                return x if isinstance(x, Image.Image) else Image.fromarray(np.array(x))
+            return [to_img(ex[t0k]).convert("RGB"), to_img(ex[t1k]).convert("RGB"), to_img(ex[t2k]).convert("RGB")]
+    raise KeyError(f"No RGB keys found for tile {tile_idx}. Provide --rgb_template.")
+
+
+def tile_rows_for_idxs(X_by_tile, tile_idxs):
+    rows, ids = [], []
+    for tidx in tile_idxs:
+        for tk in ("t0","t1","t2"):
+            rows.append(X_by_tile[tidx][tk])
+            ids.append(tidx)
+    return np.stack(rows, 0), ids  # [3*Nt, Np, D]
+
+def process_model(model_config: str, tile_idx: str, rgb_template: str | None, seed: int = 42):
+    """Process a single model and generate visualization."""
+    print(f"[info] Processing model: {model_config}")
+
+    # Load embeddings for all tiles
+    all_tiles, X_by_tile = load_embeddings(model_config)
+    if tile_idx not in X_by_tile:
+        raise KeyError(f"Tile '{tile_idx}' not found in embeddings for {model_config}")
+
+    # Shape info
+    sample = X_by_tile[tile_idx]["t0"]
+    H, W, D = infer_token_grid(np.stack([sample], 0))
+    Np = H * W
+
+    # Use ALL tiles for fitting Q matrices (no fold-based splitting)
+    # Fit Q matrices for 0%, 90%, 100% variance removal
+    Xtr, id_tr = tile_rows_for_idxs(X_by_tile, all_tiles)  # [3*Nt, Np, D]
+    var_levels = [0.0, 90.0, 100.0]
+    Q_matrices = []
+    k_values = []
+
+    for var_pct in var_levels:
+        Q, k_chosen, evr, cum = estimate_Q_train_only_patchwise_vpct(Xtr, id_tr, T=3, var_pct=var_pct)
+        Q_matrices.append(Q)
+        k_values.append(k_chosen)
+        if Q is None:
+            print(f"[info] {model_config} var_pct={var_pct}% → k=0 (no removal)")
+        else:
+            cumk = (cum[k_chosen-1] if len(cum) >= k_chosen and k_chosen > 0 else 0.0)
+            print(f"[info] {model_config} var_pct={var_pct}% → k={k_chosen}, cumEVR≈{cumk:.3f}")
+
+    # Pull this tile's 3 timepoints
+    Xt_tile = np.stack([X_by_tile[tile_idx][tk] for tk in ("t0","t1","t2")], 0)  # [3, Np, D]
+
+    # Generate false color composites for each variance level
+    false_color_imgs = []
+    reference_pca = None
+
+    for i, Q in enumerate(Q_matrices):
+        Xt_proj = apply_projection_np(Xt_tile, Q)  # [3, Np, D]
+
+        if i == 0:
+            # First level (0%) - establish reference
+            fc_rgb, reference_pca = make_false_color_composite(
+                Xt_proj, H, W, target_height=1024, target_width=1024,
+                seed=seed, reference_pca=None)
+        else:
+            # Subsequent levels (90%, 100%) - align to reference
+            fc_rgb, _ = make_false_color_composite(
+                Xt_proj, H, W, target_height=1024, target_width=1024,
+                seed=seed, reference_pca=reference_pca)
+
+        false_color_imgs.append(fc_rgb)
+
+    # Load RGB triplet
+    rgb_imgs = load_rgb_triplet(tile_idx, rgb_template)  # list[PIL] length 3
+
+    # === Plot 3x4 grid: rows t0,t1,t2; col1 RGB, col2-4 false color at 0%,90%,100% ===
+    fig, axes = plt.subplots(3, 4, figsize=(16, 12))
+    times = ["t0","t1","t2"]
+    col_headers = ["RGB", "0%", "90%", "100%"]
+
+    # Add column headers at the top
+    for c, header in enumerate(col_headers):
+        axes[0, c].text(0.5, 1.05, header, transform=axes[0, c].transAxes,
+                       ha='center', va='bottom', fontsize=14, fontweight='bold')
+
+    for r in range(3):
+        # Column 1: RGB
+        ax = axes[r,0]
+        ax.imshow(rgb_imgs[r])
+        ax.set_axis_off()
+
+        # Add time label on the left
+        ax.text(-0.1, 0.5, times[r], transform=ax.transAxes,
+               ha='right', va='center', fontsize=12, rotation=90)
+
+        # Columns 2-4: False color composites for 0%, 90%, 100%
+        for c in range(1, 4):
+            var_idx = c - 1  # 0, 1, 2 for 0%, 90%, 100%
+            ax = axes[r, c]
+            ax.imshow(false_color_imgs[var_idx][r])  # [time_idx][H, W, 3]
+            ax.set_axis_off()
+
+    plt.tight_layout()
+
+    # Auto-generate output path
+    out_path = f"supporting/processed/{model_config}_subspace_removal.png"
+    out = Path(out_path)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    plt.savefig(out, dpi=300)
+    plt.close()
+    print(f"Saved {out}")
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--tile_idx", type=str, required=True, help="Tile identifier")
+    ap.add_argument("--rgb_template", type=str, default=None,
+                    help="e.g., '/data/rgb/{tile_idx}_{time}.png' with time in {t0,t1,t2}'")
+    ap.add_argument("--seed", type=int, default=42)
+    args = ap.parse_args()
+
+    set_seed(args.seed)
+
+    # Validate tile_idx is provided
+    if not args.tile_idx:
+        raise ValueError("Provide --tile_idx")
+
+    # Process both models
+    models = ["dinov2_base", "dinov3_sat"]
+    for model_config in models:
+        try:
+            process_model(model_config, args.tile_idx, args.rgb_template, args.seed)
+        except Exception as e:
+            print(f"[error] Failed to process {model_config}: {e}")
+            continue
+
+if __name__ == "__main__":
+    main()